From c36d7deaa2f68d3f3168f8cc08c6edc8ad255b08 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 17 Feb 2021 21:30:53 -0800 Subject: [PATCH 001/197] Update README.md --- README.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/README.md b/README.md index e69de29..e46a7e2 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,10 @@ + +Framework for training models, adapted from Michael Xie's framework for In-N-Out + +https://arxiv.org/abs/2012.04550 +In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness +Sang Michael Xie, Ananya Kumar, Robbie Jones, Fereshte Khani, Tengyu Ma, Percy Liang + + + +configs/* contains configs for the experiments From a8de5ae21bfc3e0a5b62b62fbb045a5ac19d9810 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 17 Feb 2021 21:39:26 -0800 Subject: [PATCH 002/197] Update README.md --- README.md | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index e46a7e2..927561e 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,22 @@ -Framework for training models, adapted from Michael Xie's framework for In-N-Out +# A Lightweight Framework for Training Models -https://arxiv.org/abs/2012.04550 -In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness -Sang Michael Xie, Ananya Kumar, Robbie Jones, Fereshte Khani, Tengyu Ma, Percy Liang +Adapted from Michael Xie's framework for "In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness", +https://arxiv.org/abs/2012.04550, Sang Michael Xie*, Ananya Kumar*, Robbie Jones*, Fereshte Khani, Tengyu Ma, Percy Liang. Thanks to contributions by Robbie Jones. +Benefits of framework: +- Config files to specify dataset, model, augmentations, and other arguments, for better readability and reproducibility +- Nice logging +- Saves checkpoints +- Sets up and outputs to weights and biases +- New: Saves the command line argument, and config, to run the experiment +- New: Optionally, can save all the code used to run the experiment so you know exactly what you ran +Setup: +- First install a virtualenv and activate it (instructions coming) +- Create a weights and biases account +- Run "wandb login" and "wandb on" + +To fine-tune an ImageNet model on CIFAR, run: +python experiments/baseline_train.py --config=configs/imnet_finetune_cifar_resnet_baseline.yaml --log_dir=logs/inet_ft_run_0 --project_name=cifar group_name=inet_ft --run_name=run_0 -configs/* contains configs for the experiments From 185149d6a6ed80e569adee84be627e92e2e53814 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 17 Feb 2021 22:32:42 -0800 Subject: [PATCH 003/197] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 927561e..1d74061 100644 --- a/README.md +++ b/README.md @@ -20,3 +20,5 @@ Setup: To fine-tune an ImageNet model on CIFAR, run: python experiments/baseline_train.py --config=configs/imnet_finetune_cifar_resnet_baseline.yaml --log_dir=logs/inet_ft_run_0 --project_name=cifar group_name=inet_ft --run_name=run_0 +On jag: +jag "export PYTHONPATH="."; ../env/bin/python experiments/baseline_train.py --config=configs/imnet_finetune_cifar_resnet_baseline.yaml --log_dir=logs/inet_ft_run_2 --project_name=cifar group_name=inet_ft --run_name=run_2" From e341c80abc8b5f794ae160d7144bd01541a8bd99 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 20 Feb 2021 11:08:29 -0800 Subject: [PATCH 004/197] Add pretrained model, config, add assert to utils to check for class. --- .../imnet_finetune_cifar_resnet_baseline.yaml | 22 ++++++- .../imnet_finetune_cifar_resnet_creafz.yaml | 66 +++++++++++++++++++ experiments/baseline_train.py | 10 ++- models/imnet_resnet.py | 18 +++++ utils/utils.py | 6 ++ 5 files changed, 118 insertions(+), 4 deletions(-) create mode 100644 configs/imnet_finetune_cifar_resnet_creafz.yaml create mode 100644 models/imnet_resnet.py diff --git a/configs/imnet_finetune_cifar_resnet_baseline.yaml b/configs/imnet_finetune_cifar_resnet_baseline.yaml index 0f9ab70..5f1d247 100644 --- a/configs/imnet_finetune_cifar_resnet_baseline.yaml +++ b/configs/imnet_finetune_cifar_resnet_baseline.yaml @@ -1,11 +1,15 @@ log_interval: 10 use_cuda: True save_freq: 25 -epochs: &epochs 200 +epochs: &epochs 100 batch_size: 128 num_workers: 8 save_all_checkpoints: False +finetune: True +num_classes: 10 +last_layer_name: 'fc' + optimizer: classname: torch.optim.SGD args: @@ -19,7 +23,7 @@ scheduler: T_max: *epochs model: - classname: models.resnet.resnet18 + classname: torchvision.models.resnet50 args: pretrained: True @@ -35,7 +39,14 @@ train_dataset: size: 32 padding: 4 - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] test_dataset: classname: torchvision.datasets.CIFAR10 @@ -44,7 +55,14 @@ test_dataset: download: False root: '/u/scr/ananya/cifar10_dataset' transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] criterion: classname: torch.nn.CrossEntropyLoss diff --git a/configs/imnet_finetune_cifar_resnet_creafz.yaml b/configs/imnet_finetune_cifar_resnet_creafz.yaml new file mode 100644 index 0000000..e841658 --- /dev/null +++ b/configs/imnet_finetune_cifar_resnet_creafz.yaml @@ -0,0 +1,66 @@ +log_interval: 10 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 32 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +last_layer_name: 'fc' + +optimizer: + classname: torch.optim.SGD + args: + lr: &lr 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: 1 + gamma: 0.975 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 6d8f805..2dcc481 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -37,7 +37,7 @@ def get_test_stats(config, net, test_loader, criterion, device): data = utils.to_device(data, device) images, labels = data outputs = net(images) - _, predicted = torch.max(outputs.data, 1) + _, predicted = torch.max(outputs.data, dim=1) val_acc.add_values((predicted == labels).tolist()) loss = criterion(outputs, labels) val_loss.add_value(loss.tolist()) @@ -54,9 +54,15 @@ def main(config, log_dir, checkpoints_dir): test_loader = torch.utils.data.DataLoader( test_data, batch_size=config['batch_size'], shuffle=False, num_workers=config['num_workers']) - # Use CUDA if desired. + + # Create model. logging.info(f'cuda device count: {torch.cuda.device_count()}') net = utils.initialize(config['model']) + # If fine-tune, re-initialize the last layer. + if config['finetune']: + logging.info('Fine Tuning.') + net.new_last_layer(config['num_classes']) + # Use CUDA if desired. if config['use_cuda']: device = "cuda" net.cuda() diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py new file mode 100644 index 0000000..fbad5ab --- /dev/null +++ b/models/imnet_resnet.py @@ -0,0 +1,18 @@ + +from torchvision.models import resnet50 +import torch +from torch import nn + +class ResNet50(nn.Module): + + def __init__(self, pretrained=False): + super().__init__() + self._model = resnet50(pretrained=pretrained) + + def forward(self, x): + return self._model(x) + + def new_last_layer(self, num_classes): + num_in_features = self._model.fc.in_features + self._model.fc = nn.Linear(num_in_features, num_classes) + diff --git a/utils/utils.py b/utils/utils.py index c8b1c90..857c7ce 100644 --- a/utils/utils.py +++ b/utils/utils.py @@ -16,10 +16,15 @@ def save_json(save_path, save_dict): def initialize_obj(classname, args_dict=None): module_name, class_name = classname.rsplit(".", 1) Class = getattr(importlib.import_module(module_name), class_name) + if not inspect.isclass(Class): + raise ValueError("Can only initialize classes, are you passing in a function?") # filter by argnames if args_dict is not None: argspec = inspect.getfullargspec(Class.__init__) argnames = argspec.args + for k, v in args_dict.items(): + if k not in argnames: + raise ValueError(f"{k}, {v} not found in {Class}") args_dict = {k: v for k, v in args_dict.items() if k in argnames} defaults = argspec.defaults @@ -29,6 +34,7 @@ def initialize_obj(classname, args_dict=None): if argname not in args_dict: args_dict[argname] = default class_instance = Class(**args_dict) + print(Class, args_dict) else: class_instance = Class() return class_instance From cf15b05dac704d99074948795eb11f56de7fbd2d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 20 Feb 2021 16:41:16 -0800 Subject: [PATCH 005/197] Add support for multiple test datasets, support for imagenet c --- .../imnet_finetune_cifar_resnet_creafz.yaml | 45 ++++++++++++------- datasets/__init__.py | 0 datasets/cifar10c.py | 36 +++++++++++++++ experiments/baseline_train.py | 22 ++++++--- utils/utils.py | 1 - 5 files changed, 82 insertions(+), 22 deletions(-) create mode 100644 datasets/__init__.py create mode 100644 datasets/cifar10c.py diff --git a/configs/imnet_finetune_cifar_resnet_creafz.yaml b/configs/imnet_finetune_cifar_resnet_creafz.yaml index e841658..a5f14db 100644 --- a/configs/imnet_finetune_cifar_resnet_creafz.yaml +++ b/configs/imnet_finetune_cifar_resnet_creafz.yaml @@ -8,7 +8,6 @@ save_all_checkpoints: False finetune: True num_classes: 10 -last_layer_name: 'fc' optimizer: classname: torch.optim.SGD @@ -43,21 +42,35 @@ train_dataset: mean: [0.485, 0.456, 0.406] std: [0.229, 0.224, 0.225] -test_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'fog-cifar' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 2 + - name: 'zoom-blur-cifar' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 2 criterion: classname: torch.nn.CrossEntropyLoss diff --git a/datasets/__init__.py b/datasets/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/datasets/cifar10c.py b/datasets/cifar10c.py new file mode 100644 index 0000000..53c6916 --- /dev/null +++ b/datasets/cifar10c.py @@ -0,0 +1,36 @@ +import torch +from torch.utils.data import Dataset +import numpy as np + +CORRUPTIONS = [ + 'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur', + 'glass_blur', 'motion_blur', 'zoom_blur', 'snow', 'frost', 'fog', + 'brightness', 'contrast', 'elastic_transform', 'pixelate', + 'jpeg_compression' +] + +class CIFAR10C(Dataset): + + def __init__(self, root, corruption, severity, transform=None): + super().__init__() + if corruption not in CORRUPTIONS: + raise ValueError(f"{corruption} is not a valid corruption.") + if not(0 <= severity <= 4): + raise ValueError(f"Severity was {severity} but must be 0, 1, 2, 3, 4.") + num_examples = 10000 + start_idx = num_examples * severity + end_idx = num_examples * (severity + 1) + self._xs = np.load(root + '/' + corruption + '.npy')[start_idx:end_idx] + self._ys = torch.LongTensor(np.load(root + 'labels.npy'))[start_idx:end_idx] + assert(len(self._xs) == len(self._ys) == num_examples) + self._transform = transform + + def __getitem__(self, i): + x, y = self._xs[i], self._ys[i] + if self._transform is not None: + x = self._transform(x) + return x, y + + def __len__(self) -> int: + return len(self._xs) + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 2dcc481..1a33381 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -47,14 +47,26 @@ def get_test_stats(config, net, test_loader, criterion, device): def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. train_data = utils.init_dataset(config['train_dataset']) - test_data = utils.init_dataset(config['test_dataset']) train_loader = torch.utils.data.DataLoader( train_data, batch_size=config['batch_size'], shuffle=True, num_workers=config['num_workers']) - test_loader = torch.utils.data.DataLoader( - test_data, batch_size=config['batch_size'], - shuffle=False, num_workers=config['num_workers']) - + # Set up test loaders. + logging.info('Found %d testing datasets.', len(config['test_datasets'])) + test_loaders = {} + for test_dataset_config in config['test_datasets']: + logging.info('test dataset config: ' + str(test_dataset_config)) + if 'transforms' not in test_dataset_config: + if config['default_test_transforms'] is None: + raise ValueError('Must either specify default_test_transforms or a transform for each test dataset') + test_dataset_config['transforms'] = config['default_test_transforms'] + test_data = utils.init_dataset(test_dataset_config) + test_loader = torch.utils.data.DataLoader( + test_data, batch_size=config['batch_size'], + shuffle=False, num_workers=config['num_workers']) + test_loaders[test_dataset_config['name']] = test_loader + logging.info('test loader name: ' + test_dataset_config['name']) + logging.info('test loader: ' + str(test_loader)) + logging.info('test transform: ' + str(test_dataset_config['transforms'])) # Create model. logging.info(f'cuda device count: {torch.cuda.device_count()}') net = utils.initialize(config['model']) diff --git a/utils/utils.py b/utils/utils.py index 857c7ce..b97474f 100644 --- a/utils/utils.py +++ b/utils/utils.py @@ -34,7 +34,6 @@ def initialize_obj(classname, args_dict=None): if argname not in args_dict: args_dict[argname] = default class_instance = Class(**args_dict) - print(Class, args_dict) else: class_instance = Class() return class_instance From eeabce5c7880f3800deca6f7ec04855c3103e8b7 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Feb 2021 01:08:55 -0800 Subject: [PATCH 006/197] Test on more cifar10c datasets, add stl and cinic wrappers. --- .../imnet_finetune_cifar_resnet_baseline.yaml | 112 ++++++++-- datasets/cifar10c.py | 2 + datasets/cinic.py | 21 ++ datasets/stl_cifar_style.py | 207 ++++++++++++++++++ experiments/baseline_train.py | 16 +- .../cifar10c_stl_examples-checkpoint.ipynb | 176 +++++++++++++++ .../cinic_imagenet_extractor-checkpoint.ipynb | 6 + scripts/cifar10c_stl_examples.ipynb | 176 +++++++++++++++ scripts/cinic_imagenet_extractor.ipynb | 118 ++++++++++ 9 files changed, 806 insertions(+), 28 deletions(-) create mode 100644 datasets/cinic.py create mode 100644 datasets/stl_cifar_style.py create mode 100644 scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb create mode 100644 scripts/.ipynb_checkpoints/cinic_imagenet_extractor-checkpoint.ipynb create mode 100644 scripts/cifar10c_stl_examples.ipynb create mode 100644 scripts/cinic_imagenet_extractor.ipynb diff --git a/configs/imnet_finetune_cifar_resnet_baseline.yaml b/configs/imnet_finetune_cifar_resnet_baseline.yaml index 5f1d247..ac99cf3 100644 --- a/configs/imnet_finetune_cifar_resnet_baseline.yaml +++ b/configs/imnet_finetune_cifar_resnet_baseline.yaml @@ -1,29 +1,27 @@ log_interval: 10 use_cuda: True save_freq: 25 -epochs: &epochs 100 +epochs: &epochs 25 batch_size: 128 num_workers: 8 save_all_checkpoints: False finetune: True num_classes: 10 -last_layer_name: 'fc' optimizer: classname: torch.optim.SGD args: - lr: &lr 0.01 + lr: 0.01 momentum: 0.9 scheduler: classname: torch.optim.lr_scheduler.CosineAnnealingLR args: - lr: *lr T_max: *epochs model: - classname: torchvision.models.resnet50 + classname: models.imnet_resnet.ResNet50 args: pretrained: True @@ -48,21 +46,95 @@ train_dataset: mean: [0.485, 0.456, 0.406] std: [0.229, 0.224, 0.225] -test_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'fog-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 2 + - name: 'fog-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 4 + - name: 'zoom-blur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 2 + - name: 'zoom-blur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 4 + - name: 'gaussian-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 2 + - name: 'gaussian-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 4 + - name: 'pixelate-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 2 + - name: 'pixelate-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 4 + - name: 'shotnoise-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 2 + - name: 'shotnoise-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 4 + - name: 'glassblur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 2 + - name: 'glassblur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 4 criterion: classname: torch.nn.CrossEntropyLoss diff --git a/datasets/cifar10c.py b/datasets/cifar10c.py index 53c6916..7519b0a 100644 --- a/datasets/cifar10c.py +++ b/datasets/cifar10c.py @@ -1,6 +1,7 @@ import torch from torch.utils.data import Dataset import numpy as np +from PIL import Image CORRUPTIONS = [ 'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur', @@ -27,6 +28,7 @@ def __init__(self, root, corruption, severity, transform=None): def __getitem__(self, i): x, y = self._xs[i], self._ys[i] + x = Image.fromarray(np.uint8(x)) if self._transform is not None: x = self._transform(x) return x, y diff --git a/datasets/cinic.py b/datasets/cinic.py new file mode 100644 index 0000000..eeeb91e --- /dev/null +++ b/datasets/cinic.py @@ -0,0 +1,21 @@ +import torch +import torchvision +from torch.utils.data import Dataset +import numpy as np +from PIL import Image + +class CINICImNet(Dataset): + + def __init__(self, root, mode='train', transform=None): + super().__init__() + if mode not in ['train', 'valid', 'test']: + raise ValueError(f'mode was {mode} but must be train, valid, test.') + self._cinic_data = torchvision.datasets.ImageFolder( + root + '/' + mode, transform=transform) + + def __getitem__(self, i): + return self._cinic_data[i] + + def __len__(self) -> int: + return len(self._cinic_data) + diff --git a/datasets/stl_cifar_style.py b/datasets/stl_cifar_style.py new file mode 100644 index 0000000..43ac1d7 --- /dev/null +++ b/datasets/stl_cifar_style.py @@ -0,0 +1,207 @@ +# STL dataset, but remove label not in CIFAR-10, and remap to CIFAR-10 labels. +# Adapted from https://github.com/pytorch/vision/blob/master/torchvision/datasets/stl10.py +# We copy this instead of just modifying .data .labels in case the code gets modified. + +from PIL import Image +import os +import os.path +import numpy as np +from typing import Any, Callable, Optional, Tuple + +from torchvision.datasets.vision import VisionDataset +from torchvision.datasets.utils import check_integrity, download_and_extract_archive, verify_str_arg + + +class STL10(VisionDataset): + """`STL10 `_ Dataset. + Args: + root (string): Root directory of dataset where directory + ``stl10_binary`` exists. + split (string): One of {'train', 'test', 'unlabeled', 'train+unlabeled'}. + Accordingly dataset is selected. + folds (int, optional): One of {0-9} or None. + For training, loads one of the 10 pre-defined folds of 1k samples for the + standard evaluation procedure. If no value is passed, loads the 5k samples. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + """ + base_folder = 'stl10_binary' + url = "http://ai.stanford.edu/~acoates/stl10/stl10_binary.tar.gz" + filename = "stl10_binary.tar.gz" + tgz_md5 = '91f7769df0f17e558f3565bffb0c7dfb' + class_names_file = 'class_names.txt' + folds_list_file = 'fold_indices.txt' + train_list = [ + ['train_X.bin', '918c2871b30a85fa023e0c44e0bee87f'], + ['train_y.bin', '5a34089d4802c674881badbb80307741'], + ['unlabeled_X.bin', '5242ba1fed5e4be9e1e742405eb56ca4'] + ] + + test_list = [ + ['test_X.bin', '7f263ba9f9e0b06b93213547f721ac82'], + ['test_y.bin', '36f9794fa4beb8a2c72628de14fa638e'] + ] + splits = ('train', 'train+unlabeled', 'unlabeled', 'test') + + def make_labels_like_cifar(self): + stl_to_cifar_indices = np.array([0, 2, 1, 3, 4, 5, 7, -1, 8, 9]) + self.labels = stl_to_cifar_indices[self.labels] + indices = np.where(self.labels != -1) + self.labels = self.labels[indices] + self.data = self.data[indices] + new_classes = ['']*10 + new_classes[6] = 'NONE' + for i in range(len(stl_to_cifar_indices)): + v = stl_to_cifar_indices[i] + if v != -1: + new_classes[v] = self.classes[i] + self.classes = new_classes + + + def __init__( + self, + root: str, + split: str = "train", + folds: Optional[int] = None, + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + download: bool = False, + ) -> None: + super(STL10, self).__init__(root, transform=transform, + target_transform=target_transform) + self.split = verify_str_arg(split, "split", self.splits) + self.folds = self._verify_folds(folds) + + if download: + self.download() + elif not self._check_integrity(): + raise RuntimeError( + 'Dataset not found or corrupted. ' + 'You can use download=True to download it') + + # now load the picked numpy arrays + self.labels: Optional[np.ndarray] + if self.split == 'train': + self.data, self.labels = self.__loadfile( + self.train_list[0][0], self.train_list[1][0]) + self.__load_folds(folds) + + elif self.split == 'train+unlabeled': + self.data, self.labels = self.__loadfile( + self.train_list[0][0], self.train_list[1][0]) + self.__load_folds(folds) + unlabeled_data, _ = self.__loadfile(self.train_list[2][0]) + self.data = np.concatenate((self.data, unlabeled_data)) + self.labels = np.concatenate( + (self.labels, np.asarray([-1] * unlabeled_data.shape[0]))) + + elif self.split == 'unlabeled': + self.data, _ = self.__loadfile(self.train_list[2][0]) + self.labels = np.asarray([-1] * self.data.shape[0]) + else: # self.split == 'test': + self.data, self.labels = self.__loadfile( + self.test_list[0][0], self.test_list[1][0]) + + class_file = os.path.join( + self.root, self.base_folder, self.class_names_file) + if os.path.isfile(class_file): + with open(class_file) as f: + self.classes = f.read().splitlines() + # Make labels like CIFAR. + self.make_labels_like_cifar() + + def _verify_folds(self, folds: Optional[int]) -> Optional[int]: + if folds is None: + return folds + elif isinstance(folds, int): + if folds in range(10): + return folds + msg = ("Value for argument folds should be in the range [0, 10), " + "but got {}.") + raise ValueError(msg.format(folds)) + else: + msg = "Expected type None or int for argument folds, but got type {}." + raise ValueError(msg.format(type(folds))) + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + """ + Args: + index (int): Index + Returns: + tuple: (image, target) where target is index of the target class. + """ + target: Optional[int] + if self.labels is not None: + img, target = self.data[index], int(self.labels[index]) + else: + img, target = self.data[index], None + + # doing this so that it is consistent with all other datasets + # to return a PIL Image + img = Image.fromarray(np.transpose(img, (1, 2, 0))) + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = self.target_transform(target) + + return img, target + + def __len__(self) -> int: + return self.data.shape[0] + + def __loadfile(self, data_file: str, labels_file: Optional[str] = None) -> Tuple[np.ndarray, Optional[np.ndarray]]: + labels = None + if labels_file: + path_to_labels = os.path.join( + self.root, self.base_folder, labels_file) + with open(path_to_labels, 'rb') as f: + labels = np.fromfile(f, dtype=np.uint8) - 1 # 0-based + + path_to_data = os.path.join(self.root, self.base_folder, data_file) + with open(path_to_data, 'rb') as f: + # read whole file in uint8 chunks + everything = np.fromfile(f, dtype=np.uint8) + images = np.reshape(everything, (-1, 3, 96, 96)) + images = np.transpose(images, (0, 1, 3, 2)) + + return images, labels + + def _check_integrity(self) -> bool: + root = self.root + for fentry in (self.train_list + self.test_list): + filename, md5 = fentry[0], fentry[1] + fpath = os.path.join(root, self.base_folder, filename) + if not check_integrity(fpath, md5): + return False + return True + + def download(self) -> None: + if self._check_integrity(): + print('Files already downloaded and verified') + return + download_and_extract_archive(self.url, self.root, filename=self.filename, md5=self.tgz_md5) + self._check_integrity() + + def extra_repr(self) -> str: + return "Split: {split}".format(**self.__dict__) + + def __load_folds(self, folds: Optional[int]) -> None: + # loads one of the folds if specified + if folds is None: + return + path_to_folds = os.path.join( + self.root, self.base_folder, self.folds_list_file) + with open(path_to_folds, 'r') as f: + str_idx = f.read().splitlines()[folds] + list_idx = np.fromstring(str_idx, dtype=np.int64, sep=' ') + self.data = self.data[list_idx, :, :, :] + if self.labels is not None: + self.labels = self.labels[list_idx] + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 1a33381..e284fe2 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -133,14 +133,14 @@ def main(config, log_dir, checkpoints_dir): '[%d, %5d] %s: %.3f' % (epoch + 1, i + 1, k, loss_dict[k].get_mean())) scheduler.step() - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device) - # Save train and val stats to wandb and file. - stats = { - 'epoch': epoch, - 'val_loss': val_loss.get_mean(), - 'val_acc': val_acc.get_mean(), - } + # Get loss for each test set + stats = {} + for name, test_loader in test_loaders.items(): + logging.info(' getting stats ' + name) + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device) + stats[name + '_loss'] = val_loss.get_mean() + stats[name + '_acc'] = val_acc.get_mean() for k in loss_dict: stats[k] = loss_dict[k].get_mean() if config['wandb']: diff --git a/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb b/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb new file mode 100644 index 0000000..2a50317 --- /dev/null +++ b/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "\n", + "import torchvision\n", + "import torch\n", + "import importlib\n", + "import numpy as np\n", + "from torchvision import transforms\n", + "from datasets import cifar10c\n", + "from datasets import stl_cifar_style\n", + "from datasets import cinic\n", + "import pickle\n", + "import json\n", + "import utils.utils as utils\n", + "from utils.accumulator import Accumulator\n", + "import matplotlib.pyplot as plt\n", + "importlib.reload(cifar10c)\n", + "importlib.reload(stl_cifar_style)\n", + "importlib.reload(cinic)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CIFAR-10C Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cifar10c_fog = cifar10c.CIFAR10C(root='/juice/scr/ananya/CIFAR-10-C/', corruption='snow', severity=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 15\n", + "img = cifar10c_fog[idx][0]\n", + "plt.imshow(img)\n", + "print(cifar10c_fog[idx][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# STL Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "from matplotlib import cm\n", + "im = Image.fromarray(np.uint8(img))\n", + "display(im)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stl_data.classes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 2004\n", + "img = stl_data[idx][0]\n", + "plt.imshow(img)\n", + "print(stl_data.classes[stl_data[idx][1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CINIC Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cinic_directory = '/juice/scr/ananya/cinic-10-imagenet'\n", + "\n", + "cinic_mean = [0.47889522, 0.47227842, 0.43047404]\n", + "cinic_std = [0.24205776, 0.23828046, 0.25874835]\n", + "cinic_data = cinic.CINICImNet(root=cinic_directory, mode='valid', transform=transforms.ToTensor())\n", + "# transform=transforms.Compose([transforms.ToTensor(),\n", + "# transforms.Normalize(mean=cinic_mean,std=cinic_std)]))\n", + "# cinic_train = torch.utils.data.DataLoader(\n", + "# cinic_data, batch_size=128, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 25009\n", + "img = np.transpose(cinic_data[idx][0], axes=[1,2,0])\n", + "plt.imshow(img)\n", + "print(cinic_data[idx][1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/.ipynb_checkpoints/cinic_imagenet_extractor-checkpoint.ipynb b/scripts/.ipynb_checkpoints/cinic_imagenet_extractor-checkpoint.ipynb new file mode 100644 index 0000000..7fec515 --- /dev/null +++ b/scripts/.ipynb_checkpoints/cinic_imagenet_extractor-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/cifar10c_stl_examples.ipynb b/scripts/cifar10c_stl_examples.ipynb new file mode 100644 index 0000000..2a50317 --- /dev/null +++ b/scripts/cifar10c_stl_examples.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "\n", + "import torchvision\n", + "import torch\n", + "import importlib\n", + "import numpy as np\n", + "from torchvision import transforms\n", + "from datasets import cifar10c\n", + "from datasets import stl_cifar_style\n", + "from datasets import cinic\n", + "import pickle\n", + "import json\n", + "import utils.utils as utils\n", + "from utils.accumulator import Accumulator\n", + "import matplotlib.pyplot as plt\n", + "importlib.reload(cifar10c)\n", + "importlib.reload(stl_cifar_style)\n", + "importlib.reload(cinic)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CIFAR-10C Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cifar10c_fog = cifar10c.CIFAR10C(root='/juice/scr/ananya/CIFAR-10-C/', corruption='snow', severity=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 15\n", + "img = cifar10c_fog[idx][0]\n", + "plt.imshow(img)\n", + "print(cifar10c_fog[idx][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# STL Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "from matplotlib import cm\n", + "im = Image.fromarray(np.uint8(img))\n", + "display(im)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stl_data.classes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 2004\n", + "img = stl_data[idx][0]\n", + "plt.imshow(img)\n", + "print(stl_data.classes[stl_data[idx][1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CINIC Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cinic_directory = '/juice/scr/ananya/cinic-10-imagenet'\n", + "\n", + "cinic_mean = [0.47889522, 0.47227842, 0.43047404]\n", + "cinic_std = [0.24205776, 0.23828046, 0.25874835]\n", + "cinic_data = cinic.CINICImNet(root=cinic_directory, mode='valid', transform=transforms.ToTensor())\n", + "# transform=transforms.Compose([transforms.ToTensor(),\n", + "# transforms.Normalize(mean=cinic_mean,std=cinic_std)]))\n", + "# cinic_train = torch.utils.data.DataLoader(\n", + "# cinic_data, batch_size=128, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "idx = 25009\n", + "img = np.transpose(cinic_data[idx][0], axes=[1,2,0])\n", + "plt.imshow(img)\n", + "print(cinic_data[idx][1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/cinic_imagenet_extractor.ipynb b/scripts/cinic_imagenet_extractor.ipynb new file mode 100644 index 0000000..ae54ac4 --- /dev/null +++ b/scripts/cinic_imagenet_extractor.ipynb @@ -0,0 +1,118 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "import numpy as np\n", + "from shutil import copyfile\n", + "symlink = True # If this is false the files are copied instead\n", + "combine_train_valid = False # If this is true, the train and valid sets are ALSO combined" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "cinic_directory = \"../../../cinic\"\n", + "imagenet_directory = \"../../../cinic-10-imagenet\"\n", + "classes = [\"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n", + "sets = ['train', 'valid', 'test']\n", + "if not os.path.exists(imagenet_directory):\n", + " os.makedirs(imagenet_directory)\n", + "if not os.path.exists(imagenet_directory + '/train'):\n", + " os.makedirs(imagenet_directory + '/train')\n", + "if not os.path.exists(imagenet_directory + '/test'):\n", + " os.makedirs(imagenet_directory + '/test')\n", + " \n", + "for c in classes:\n", + " if not os.path.exists('{}/train/{}'.format(imagenet_directory, c)):\n", + " os.makedirs('{}/train/{}'.format(imagenet_directory, c))\n", + " if not os.path.exists('{}/test/{}'.format(imagenet_directory, c)):\n", + " os.makedirs('{}/test/{}'.format(imagenet_directory, c))\n", + " if not combine_train_valid:\n", + " if not os.path.exists('{}/valid/{}'.format(imagenet_directory, c)):\n", + " os.makedirs('{}/valid/{}'.format(imagenet_directory, c))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "for s in sets:\n", + " for c in classes:\n", + " source_directory = '{}/{}/{}'.format(cinic_directory, s, c)\n", + " filenames = glob.glob('{}/*.png'.format(source_directory))\n", + " for fn in filenames:\n", + " dest_fn = fn.split('/')[-1]\n", + " if (s == 'train' or s == 'valid') and combine_train_valid and 'cifar' not in fn.split('/')[-1]:\n", + " dest_fn = '{}/train/{}/{}'.format(imagenet_directory, c, dest_fn)\n", + " if symlink:\n", + " if not os.path.islink(dest_fn):\n", + " os.symlink(fn, dest_fn)\n", + " else:\n", + " copyfile(fn, dest_fn)\n", + " \n", + " elif (s == 'train') and 'cifar' not in fn.split('/')[-1]:\n", + " dest_fn = '{}/train/{}/{}'.format(imagenet_directory, c, dest_fn)\n", + " if symlink:\n", + " if not os.path.islink(dest_fn):\n", + " os.symlink(fn, dest_fn)\n", + " else:\n", + " copyfile(fn, dest_fn)\n", + " \n", + " elif (s == 'valid') and 'cifar' not in fn.split('/')[-1]:\n", + " dest_fn = '{}/valid/{}/{}'.format(imagenet_directory, c, dest_fn)\n", + " if symlink:\n", + " if not os.path.islink(dest_fn):\n", + " os.symlink(fn, dest_fn)\n", + " else:\n", + " copyfile(fn, dest_fn)\n", + " \n", + " elif s == 'test' and 'cifar' not in fn.split('/')[-1]:\n", + " dest_fn = '{}/test/{}/{}'.format(imagenet_directory, c, dest_fn)\n", + " if symlink:\n", + " if not os.path.islink(dest_fn):\n", + " os.symlink(fn, dest_fn)\n", + " else:\n", + " copyfile(fn, dest_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 97d2b038dbdc973d39bc2324b6d3f55d68a28d38 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Feb 2021 14:16:26 -0800 Subject: [PATCH 007/197] Support linear probe and max samples in testing for CINIC. --- experiments/baseline_train.py | 15 +- models/imnet_resnet.py | 4 + scripts/cifar10c_stl_examples.ipynb | 274 +++++++++++++++++++++++++++- 3 files changed, 285 insertions(+), 8 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index e284fe2..aacd6c3 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -26,11 +26,13 @@ log_level = logging.DEBUG -def get_test_stats(config, net, test_loader, criterion, device): +def get_test_stats(config, net, test_loader, criterion, device, max_examples=float('infinity')): # Evaluate accuracy and loss on validation. + # Returns right after we've seen at least max_examples examples (not batches). val_loss = Accumulator() val_acc = Accumulator() net.eval() + num_examples = 0 with torch.no_grad(): for data in test_loader: if config['use_cuda']: @@ -41,6 +43,9 @@ def get_test_stats(config, net, test_loader, criterion, device): val_acc.add_values((predicted == labels).tolist()) loss = criterion(outputs, labels) val_loss.add_value(loss.tolist()) + num_examples += len(images) + if num_examples >= max_examples: + break return val_loss, val_acc @@ -62,7 +67,7 @@ def main(config, log_dir, checkpoints_dir): test_data = utils.init_dataset(test_dataset_config) test_loader = torch.utils.data.DataLoader( test_data, batch_size=config['batch_size'], - shuffle=False, num_workers=config['num_workers']) + shuffle=True, num_workers=config['num_workers']) test_loaders[test_dataset_config['name']] = test_loader logging.info('test loader name: ' + test_dataset_config['name']) logging.info('test loader: ' + str(test_loader)) @@ -71,7 +76,11 @@ def main(config, log_dir, checkpoints_dir): logging.info(f'cuda device count: {torch.cuda.device_count()}') net = utils.initialize(config['model']) # If fine-tune, re-initialize the last layer. - if config['finetune']: + finetune = 'finetune' in config and config['finetune'] + linear_probe = 'linear_probe' in config and config['linear_probe'] + if finetune or linear_probe: + if linear_probe: + net.set_requires_grad(False) logging.info('Fine Tuning.') net.new_last_layer(config['num_classes']) # Use CUDA if desired. diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py index fbad5ab..b4872ff 100644 --- a/models/imnet_resnet.py +++ b/models/imnet_resnet.py @@ -12,6 +12,10 @@ def __init__(self, pretrained=False): def forward(self, x): return self._model(x) + def set_requires_grad(val): + for param in self._model.parameters(): + param.requires_grad = val + def new_last_layer(self, num_classes): num_in_features = self._model.fc.in_features self._model.fc = nn.Linear(num_in_features, num_classes) diff --git a/scripts/cifar10c_stl_examples.ipynb b/scripts/cifar10c_stl_examples.ipynb index 2a50317..e6d74be 100644 --- a/scripts/cifar10c_stl_examples.ipynb +++ b/scripts/cifar10c_stl_examples.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# So we can load files from other sub-directories, e.g. datasets.\n", "import os\n", @@ -15,6 +26,7 @@ "\n", "import torchvision\n", "import torch\n", + "from torchvision import models\n", "import importlib\n", "import numpy as np\n", "from torchvision import transforms\n", @@ -117,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -128,8 +140,8 @@ "cinic_data = cinic.CINICImNet(root=cinic_directory, mode='valid', transform=transforms.ToTensor())\n", "# transform=transforms.Compose([transforms.ToTensor(),\n", "# transforms.Normalize(mean=cinic_mean,std=cinic_std)]))\n", - "# cinic_train = torch.utils.data.DataLoader(\n", - "# cinic_data, batch_size=128, shuffle=True)" + "cinic_train = torch.utils.data.DataLoader(\n", + " cinic_data, batch_size=128, shuffle=True)" ] }, { @@ -144,6 +156,258 @@ "print(cinic_data[idx][1])" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "128\n" + ] + } + ], + "source": [ + "batch = next(iter(cinic_train))\n", + "input, target = batch\n", + "print(len(batch))\n", + "print(len(input))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Play around with models " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_ft = models.resnet50(pretrained=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "list(list(model_ft.children())[0].parameters())[0].requires_grad = False" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ResNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", + ")" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_ft" + ] + }, { "cell_type": "code", "execution_count": null, From c001d39801f408bace111eb83369ce2c607eda98 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Feb 2021 00:05:23 -0800 Subject: [PATCH 008/197] Linear probe, log more often to wandb. --- .../imnet_finetune_cifar_resnet_baseline.yaml | 2 +- .../imnet_finetune_cifar_resnet_test_stl.yaml | 82 +++++++++++++++++++ experiments/baseline_train.py | 71 ++++++++++++---- models/imnet_resnet.py | 2 +- utils/utils.py | 1 + 5 files changed, 139 insertions(+), 19 deletions(-) create mode 100644 configs/imnet_finetune_cifar_resnet_test_stl.yaml diff --git a/configs/imnet_finetune_cifar_resnet_baseline.yaml b/configs/imnet_finetune_cifar_resnet_baseline.yaml index ac99cf3..2e0650e 100644 --- a/configs/imnet_finetune_cifar_resnet_baseline.yaml +++ b/configs/imnet_finetune_cifar_resnet_baseline.yaml @@ -1,4 +1,4 @@ -log_interval: 10 +log_interval: 5000 use_cuda: True save_freq: 25 epochs: &epochs 25 diff --git a/configs/imnet_finetune_cifar_resnet_test_stl.yaml b/configs/imnet_finetune_cifar_resnet_test_stl.yaml new file mode 100644 index 0000000..234d0c7 --- /dev/null +++ b/configs/imnet_finetune_cifar_resnet_test_stl.yaml @@ -0,0 +1,82 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 25 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + split: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index aacd6c3..6b780f7 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -58,17 +58,26 @@ def main(config, log_dir, checkpoints_dir): # Set up test loaders. logging.info('Found %d testing datasets.', len(config['test_datasets'])) test_loaders = {} + max_test_examples = {} for test_dataset_config in config['test_datasets']: logging.info('test dataset config: ' + str(test_dataset_config)) + # Use default test transform if test dataset doesn't specify a transform. if 'transforms' not in test_dataset_config: if config['default_test_transforms'] is None: - raise ValueError('Must either specify default_test_transforms or a transform for each test dataset') + raise ValueError('Must either specify default_test_transforms ' + 'or a transform for each test dataset') test_dataset_config['transforms'] = config['default_test_transforms'] + # Initialize dataset and data loader. + # Shuffle is True in case we only test part of the test set. test_data = utils.init_dataset(test_dataset_config) test_loader = torch.utils.data.DataLoader( test_data, batch_size=config['batch_size'], shuffle=True, num_workers=config['num_workers']) - test_loaders[test_dataset_config['name']] = test_loader + test_config_name = test_dataset_config['name'] + test_loaders[test_config_name] = test_loader + # Some test datasets like CINIC are huge so we only test part of the dataset. + if 'max_test_examples' in test_dataset_config: + max_test_examples[test_config_name] = test_dataset_config['max_test_examples'] logging.info('test loader name: ' + test_dataset_config['name']) logging.info('test loader: ' + str(test_loader)) logging.info('test transform: ' + str(test_dataset_config['transforms'])) @@ -78,11 +87,17 @@ def main(config, log_dir, checkpoints_dir): # If fine-tune, re-initialize the last layer. finetune = 'finetune' in config and config['finetune'] linear_probe = 'linear_probe' in config and config['linear_probe'] + def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) if finetune or linear_probe: if linear_probe: + logging.info('linear probing, freezing bottom layers.') net.set_requires_grad(False) - logging.info('Fine Tuning.') net.new_last_layer(config['num_classes']) + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine Tuning {num_trainable_params} of {num_params} parameters.') + # Use CUDA if desired. if config['use_cuda']: device = "cuda" @@ -113,11 +128,12 @@ def main(config, log_dir, checkpoints_dir): net.train() logging.info("\nEpoch #{}".format(epoch)) loss_dict = { - 'train_loss': Accumulator(), - 'train_acc': Accumulator(), + 'train/loss': Accumulator(), + 'train/acc': Accumulator(), } if 'model_loss' in config: - loss_dict['train_model_loss'] = Accumulator() + loss_dict['train/model_loss'] = Accumulator() + num_examples = 0 for i, data in enumerate(train_loader, 0): # get the inputs; data is a list of [inputs, labels] if config['use_cuda']: @@ -129,27 +145,48 @@ def main(config, log_dir, checkpoints_dir): if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) opt_loss.backward() - loss_dict['train_model_loss'].add_value(opt_loss.tolist()) + loss_dict['train/model_loss'].add_value(opt_loss.tolist()) else: loss.backward() optimizer.step() - loss_dict['train_loss'].add_value(loss.tolist()) + loss_dict['train/loss'].add_value(loss.tolist()) _, train_preds = torch.max(outputs.data, 1) - loss_dict['train_acc'].add_values((train_preds == labels).tolist()) - if i % config['log_interval'] == 0 and i != 0: + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + num_examples += len(labels) + def should_log(log_interval): + return num_examples // log_interval > (num_examples - len(labels)) // log_interval + if should_log(config['log_interval']): for k in loss_dict: logging.info( '[%d, %5d] %s: %.3f' % - (epoch + 1, i + 1, k, loss_dict[k].get_mean())) + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + stats = {} + if 'test_interval' in config and should_log(config['test_interval']): + for name, test_loader in test_loaders.items(): + max_examples = float('infinity') + if name in max_test_examples: + max_examples = max_test_examples[name] + logging.info(f'{name} test set processing max examples {max_examples}') + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device, + max_examples=max_examples) + stats['inter_ood_loss/' + name] = val_loss.get_mean() + stats['inter_ood_acc/' + name] = val_acc.get_mean() + wandb.log(stats) + scheduler.step() # Get loss for each test set stats = {} - for name, test_loader in test_loaders.items(): - logging.info(' getting stats ' + name) - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device) - stats[name + '_loss'] = val_loss.get_mean() - stats[name + '_acc'] = val_acc.get_mean() + if 'test_interval' not in config: + for name, test_loader in test_loaders.items(): + max_examples = float('infinity') + if name in max_test_examples: + max_examples = max_test_examples[name] + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device, + max_examples=max_examples) + stats['ood_loss/' + name] = val_loss.get_mean() + stats['ood_acc/' + name] = val_acc.get_mean() for k in loss_dict: stats[k] = loss_dict[k].get_mean() if config['wandb']: diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py index b4872ff..9e8332a 100644 --- a/models/imnet_resnet.py +++ b/models/imnet_resnet.py @@ -12,7 +12,7 @@ def __init__(self, pretrained=False): def forward(self, x): return self._model(x) - def set_requires_grad(val): + def set_requires_grad(self, val): for param in self._model.parameters(): param.requires_grad = val diff --git a/utils/utils.py b/utils/utils.py index b97474f..e62743d 100644 --- a/utils/utils.py +++ b/utils/utils.py @@ -1,5 +1,6 @@ # Thanks to Michael Xie for these utilities. +import ast from copy import deepcopy import json import logging From e44f4d8df76489f39bda3f89ef44e6bb696b57fe Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Feb 2021 00:58:30 -0800 Subject: [PATCH 009/197] Simplify baseline config. --- .../imnet_finetune_cifar_resnet_baseline.yaml | 72 --------- ...t_finetune_cifar_resnet_test_cifar10c.yaml | 143 ++++++++++++++++++ experiments/baseline_train.py | 1 + 3 files changed, 144 insertions(+), 72 deletions(-) create mode 100644 configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml diff --git a/configs/imnet_finetune_cifar_resnet_baseline.yaml b/configs/imnet_finetune_cifar_resnet_baseline.yaml index 2e0650e..0c6782a 100644 --- a/configs/imnet_finetune_cifar_resnet_baseline.yaml +++ b/configs/imnet_finetune_cifar_resnet_baseline.yaml @@ -63,78 +63,6 @@ test_datasets: train: False download: False root: '/u/scr/ananya/cifar10_dataset' - - name: 'fog-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 2 - - name: 'fog-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 4 - - name: 'zoom-blur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 2 - - name: 'zoom-blur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 4 - - name: 'gaussian-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 2 - - name: 'gaussian-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 4 - - name: 'pixelate-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 2 - - name: 'pixelate-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 4 - - name: 'shotnoise-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 2 - - name: 'shotnoise-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 4 - - name: 'glassblur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 2 - - name: 'glassblur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 4 criterion: classname: torch.nn.CrossEntropyLoss diff --git a/configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml b/configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml new file mode 100644 index 0000000..2e0650e --- /dev/null +++ b/configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml @@ -0,0 +1,143 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 25 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'fog-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 2 + - name: 'fog-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 4 + - name: 'zoom-blur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 2 + - name: 'zoom-blur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 4 + - name: 'gaussian-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 2 + - name: 'gaussian-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 4 + - name: 'pixelate-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 2 + - name: 'pixelate-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 4 + - name: 'shotnoise-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 2 + - name: 'shotnoise-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 4 + - name: 'glassblur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 2 + - name: 'glassblur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 4 + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 6b780f7..708c16a 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -153,6 +153,7 @@ def count_parameters(model, trainable): _, train_preds = torch.max(outputs.data, 1) loss_dict['train/acc'].add_values((train_preds == labels).tolist()) num_examples += len(labels) + print(num_examples, loss_dict['train/loss'].get_mean()) def should_log(log_interval): return num_examples // log_interval > (num_examples - len(labels)) // log_interval if should_log(config['log_interval']): From 902df7b6910b1773edb41d3ad87eed63c132a094 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 28 Feb 2021 20:06:13 -0800 Subject: [PATCH 010/197] Add more configs. --- ...netune_cifar_resnet_fixed_lr_test_stl.yaml | 90 +++++++++++ .../imnet_finetune_cifar_resnet_test_stl.yaml | 2 +- ...t_linprobe_cifar_resnet_test_cifar10c.yaml | 145 ++++++++++++++++++ .../imnet_probe_cifar_resnet_test_stl.yaml | 90 +++++++++++ experiments/baseline_train.py | 26 +++- models/imnet_resnet.py | 3 + models/mlp.py | 69 +++++++++ 7 files changed, 420 insertions(+), 5 deletions(-) create mode 100644 configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml create mode 100644 configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml create mode 100644 configs/imnet_probe_cifar_resnet_test_stl.yaml create mode 100644 models/mlp.py diff --git a/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml b/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml new file mode 100644 index 0000000..af3b0c5 --- /dev/null +++ b/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml @@ -0,0 +1,90 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 512 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +probe_net: + classname: models.mlp.MLP + args: + dims: [2048, 64, 64] + output_dim: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.1 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_finetune_cifar_resnet_test_stl.yaml b/configs/imnet_finetune_cifar_resnet_test_stl.yaml index 234d0c7..20647db 100644 --- a/configs/imnet_finetune_cifar_resnet_test_stl.yaml +++ b/configs/imnet_finetune_cifar_resnet_test_stl.yaml @@ -73,7 +73,7 @@ test_datasets: max_test_examples: 10000 args: root: '/u/scr/ananya/cinic-10-imagenet' - split: 'valid' + mode: 'valid' criterion: classname: torch.nn.CrossEntropyLoss diff --git a/configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml b/configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml new file mode 100644 index 0000000..6f6d9ed --- /dev/null +++ b/configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml @@ -0,0 +1,145 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 25 +batch_size: 512 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.1 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'fog-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 2 + - name: 'fog-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 4 + - name: 'zoom-blur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 2 + - name: 'zoom-blur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 4 + - name: 'gaussian-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 2 + - name: 'gaussian-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 4 + - name: 'pixelate-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 2 + - name: 'pixelate-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 4 + - name: 'shotnoise-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 2 + - name: 'shotnoise-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 4 + - name: 'glassblur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 2 + - name: 'glassblur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 4 + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_probe_cifar_resnet_test_stl.yaml b/configs/imnet_probe_cifar_resnet_test_stl.yaml new file mode 100644 index 0000000..6feccbd --- /dev/null +++ b/configs/imnet_probe_cifar_resnet_test_stl.yaml @@ -0,0 +1,90 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 512 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +probe_net: + classname: models.mlp.MLP + args: + dims: [2048, 1024, 1024, 1024] + output_dim: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 708c16a..85de12a 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -23,7 +23,14 @@ import utils.utils as utils -log_level = logging.DEBUG +log_level = logging.INFO + + +def reset_state(model, training): + if training: + model.train() + else: + model.eval() def get_test_stats(config, net, test_loader, criterion, device, max_examples=float('infinity')): @@ -31,6 +38,7 @@ def get_test_stats(config, net, test_loader, criterion, device, max_examples=flo # Returns right after we've seen at least max_examples examples (not batches). val_loss = Accumulator() val_acc = Accumulator() + training_state = net.training net.eval() num_examples = 0 with torch.no_grad(): @@ -46,6 +54,7 @@ def get_test_stats(config, net, test_loader, criterion, device, max_examples=flo num_examples += len(images) if num_examples >= max_examples: break + reset_state(net, training_state) return val_loss, val_acc @@ -92,8 +101,15 @@ def count_parameters(model, trainable): if finetune or linear_probe: if linear_probe: logging.info('linear probing, freezing bottom layers.') + if 'use_net_val_mode' not in config: + config['use_net_val_mode'] = True + logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') net.set_requires_grad(False) - net.new_last_layer(config['num_classes']) + if 'probe_net' in config: + probe_net = utils.initialize(config['probe_net']) + net.add_probe(probe_net) + else: + net.new_last_layer(config['num_classes']) num_trainable_params = count_parameters(net, True) num_params = count_parameters(net, False) + num_trainable_params logging.info(f'Fine Tuning {num_trainable_params} of {num_params} parameters.') @@ -125,7 +141,6 @@ def count_parameters(model, trainable): os.remove(prev_ckp_path) prev_ckp_path = checkpoints_dir / cur_ckp_filename # Train model. - net.train() logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), @@ -135,6 +150,10 @@ def count_parameters(model, trainable): loss_dict['train/model_loss'] = Accumulator() num_examples = 0 for i, data in enumerate(train_loader, 0): + if 'use_net_val_mode' in config and config['use_net_val_mode']: + net.eval() + else: + net.train() # get the inputs; data is a list of [inputs, labels] if config['use_cuda']: data = utils.to_device(data, device) @@ -153,7 +172,6 @@ def count_parameters(model, trainable): _, train_preds = torch.max(outputs.data, 1) loss_dict['train/acc'].add_values((train_preds == labels).tolist()) num_examples += len(labels) - print(num_examples, loss_dict['train/loss'].get_mean()) def should_log(log_interval): return num_examples // log_interval > (num_examples - len(labels)) // log_interval if should_log(config['log_interval']): diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py index 9e8332a..a735835 100644 --- a/models/imnet_resnet.py +++ b/models/imnet_resnet.py @@ -20,3 +20,6 @@ def new_last_layer(self, num_classes): num_in_features = self._model.fc.in_features self._model.fc = nn.Linear(num_in_features, num_classes) + def add_probe(self, probe): + self._model.fc = probe + diff --git a/models/mlp.py b/models/mlp.py new file mode 100644 index 0000000..cbc0827 --- /dev/null +++ b/models/mlp.py @@ -0,0 +1,69 @@ + +from collections import OrderedDict + +import torch +from torch import nn +from torch.autograd import Variable +import numpy as np +import itertools + +class MLPDropout(nn.Module): + ''' + A multilayer perception with ReLU activations and dropout layers. + ''' + def __init__(self, dims, output_dim, dropout_probs): + ''' + Constructor. + Parameters + ---------- + dims : list[int] + Specifies the input and hidden layer dimensions. + output_dim : int + Specifies the output dimension. + dropout_probs : list[float] + Specifies the dropout probability at each layer. The length of this + list must be equal to the length of dims. If the dropout + probability of a layer is zero, then the dropout layer is omitted + altogether. + ''' + if len(dims) != len(dropout_probs): + raise ValueError('len(dims) must equal len(dropout_probs)') + if len(dims) < 1: + raise ValueError('len(dims) must be at least 1') + if any(prob < 0 or prob > 1 for prob in dropout_probs): + raise ValueError('Dropout probabilities must be in [0, 1]') + + super(MLPDropout, self).__init__() + layers = [] + if dropout_probs[0] > 0: # Input dropout layer. + layers.append(('Dropout1', nn.Dropout(p=dropout_probs[0]))) + + for i in range(len(dims) - 1): + layers.append((f'Linear{i + 1}', nn.Linear(dims[i], dims[i + 1]))) + layers.append((f'ReLU{i + 1}', nn.ReLU())) + if dropout_probs[i + 1] > 0: + dropout = nn.Dropout(p=dropout_probs[i + 1]) + layers.append((f'Dropout{i + 2}', dropout)) + + layers.append((f'Linear{len(dims)}', nn.Linear(dims[-1], output_dim))) + self.model = nn.Sequential(OrderedDict(layers)) + + def forward(self, x): + return self.model(x) + + +class MLP(MLPDropout): + ''' + A multilayer perceptron with ReLU activations. + ''' + def __init__(self, dims, output_dim): + ''' + Constructor. + Parameters + ---------- + dims : List[int] + Specifies the input and hidden layer dimensions. + output_dim : int + Specifies the output dimension. + ''' + super(MLP, self).__init__(dims, output_dim, [0] * len(dims)) From 832f60d46d05164a73aa9f5b84ca0c5bb3f15d6d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:57:31 -0700 Subject: [PATCH 011/197] Add configs, and use Karan's tool. --- configs/datasets_cifar_test_all.yaml | 155 ++++++++++++++++++ configs/imnet_cifar_all_finetune.yaml | 38 +++++ configs/imnet_cifar_all_probe.yaml | 37 +++++ ...netune_cifar_resnet_fixed_lr_test_stl.yaml | 19 ++- ...nprobe_cifar_resnet_fixed_lr_test_stl.yaml | 95 +++++++++++ .../imnet_linprobe_cifar_resnet_test_stl.yaml | 95 +++++++++++ ...probe_noaugment_cifar_resnet_test_stl.yaml | 90 ++++++++++ 7 files changed, 520 insertions(+), 9 deletions(-) create mode 100644 configs/datasets_cifar_test_all.yaml create mode 100644 configs/imnet_cifar_all_finetune.yaml create mode 100644 configs/imnet_cifar_all_probe.yaml create mode 100644 configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml create mode 100644 configs/imnet_linprobe_cifar_resnet_test_stl.yaml create mode 100644 configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml diff --git a/configs/datasets_cifar_test_all.yaml b/configs/datasets_cifar_test_all.yaml new file mode 100644 index 0000000..614e243 --- /dev/null +++ b/configs/datasets_cifar_test_all.yaml @@ -0,0 +1,155 @@ + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + max_test_examples: 1000 + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + max_test_examples: 1000 + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 1000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + - name: 'stl-32x32' + classname: datasets.stl_cifar_style.STL10 + max_test_examples: 1000 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 32 + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + - name: 'imnet-n-cifar' + classname: datasets.imnet_intersect_c10.ImNetnC10 + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/balanced_imnet_intersect_c10_val/' + - name: 'fog-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 2 + - name: 'fog-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'fog' + severity: 4 + - name: 'zoom-blur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 2 + - name: 'zoom-blur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'zoom_blur' + severity: 4 + - name: 'gaussian-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 2 + - name: 'gaussian-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'gaussian_noise' + severity: 4 + - name: 'pixelate-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 2 + - name: 'pixelate-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'pixelate' + severity: 4 + - name: 'shotnoise-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 2 + - name: 'shotnoise-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'shot_noise' + severity: 4 + - name: 'glassblur-cifar-2' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 2 + - name: 'glassblur-cifar-4' + classname: datasets.cifar10c.CIFAR10C + max_test_examples: 1000 + args: + root: '/juice/scr/ananya/CIFAR-10-C/' + corruption: 'glass_blur' + severity: 4 + diff --git a/configs/imnet_cifar_all_finetune.yaml b/configs/imnet_cifar_all_finetune.yaml new file mode 100644 index 0000000..9433bda --- /dev/null +++ b/configs/imnet_cifar_all_finetune.yaml @@ -0,0 +1,38 @@ + +inherit: datasets_cifar_test_all.yaml + +log_interval: 5000 +use_cuda: True +save_freq: 26 +epochs: &epochs 25 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +test_interval: 10000 +finetune: True +num_classes: 10 +linear_probe: False +use_net_val_mode: False + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_cifar_all_probe.yaml b/configs/imnet_cifar_all_probe.yaml new file mode 100644 index 0000000..4c88b8f --- /dev/null +++ b/configs/imnet_cifar_all_probe.yaml @@ -0,0 +1,37 @@ + +inherit: datasets_cifar_test_all.yaml + +log_interval: 5000 +use_cuda: True +save_freq: 101 +epochs: &epochs 100 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml b/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml index af3b0c5..acda6d4 100644 --- a/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml +++ b/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml @@ -1,21 +1,22 @@ log_interval: 5000 use_cuda: True save_freq: 25 -epochs: &epochs 100 -batch_size: 512 +epochs: &epochs 25 +batch_size: 128 num_workers: 8 save_all_checkpoints: False +test_interval: 5000 finetune: True num_classes: 10 -linear_probe: True -use_net_val_mode: True +linear_probe: False +use_net_val_mode: False -probe_net: - classname: models.mlp.MLP - args: - dims: [2048, 64, 64] - output_dim: 10 +# probe_net: +# classname: models.mlp.MLP +# args: +# dims: [2048, 64, 64] +# output_dim: 10 optimizer: classname: torch.optim.SGD diff --git a/configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml b/configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml new file mode 100644 index 0000000..47bea5c --- /dev/null +++ b/configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml @@ -0,0 +1,95 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +# probe_net: +# classname: models.mlp.MLP +# args: +# dims: [2048, 64, 64] +# output_dim: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.1 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +# scheduler: +# classname: torch.optim.lr_scheduler.CosineAnnealingLR +# args: +# T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_linprobe_cifar_resnet_test_stl.yaml b/configs/imnet_linprobe_cifar_resnet_test_stl.yaml new file mode 100644 index 0000000..99f3d91 --- /dev/null +++ b/configs/imnet_linprobe_cifar_resnet_test_stl.yaml @@ -0,0 +1,95 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +# probe_net: +# classname: models.mlp.MLP +# args: +# dims: [2048, 64, 64] +# output_dim: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.1 + momentum: 0.9 + +# scheduler: +# classname: torch.optim.lr_scheduler.StepLR +# args: +# step_size: *epochs + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.RandomCrop + args: + size: 32 + padding: 4 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml b/configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml new file mode 100644 index 0000000..919907d --- /dev/null +++ b/configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml @@ -0,0 +1,90 @@ +log_interval: 5000 +use_cuda: True +save_freq: 25 +epochs: &epochs 100 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +num_classes: 10 +linear_probe: True +use_net_val_mode: True + +# probe_net: +# classname: models.mlp.MLP +# args: +# dims: [2048, 64, 64] +# output_dim: 10 + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.1 + momentum: 0.9 + +# scheduler: +# classname: torch.optim.lr_scheduler.StepLR +# args: +# step_size: *epochs + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +train_dataset: + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: '/u/scr/ananya/cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: '/u/scr/ananya/cifar10_dataset' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: '/u/scr/ananya/stl10_dataset' + split: 'test' + - name: 'cinic-val' + classname: datasets.cinic.CINICImNet + max_test_examples: 10000 + args: + root: '/u/scr/ananya/cinic-10-imagenet' + mode: 'valid' + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + From 884a120cf2ef9c917202b8a898b71f5c792037fe Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:58:05 -0700 Subject: [PATCH 012/197] Add Imnet intersect cifar 10 classes. --- datasets/imnet_intersect_c10.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 datasets/imnet_intersect_c10.py diff --git a/datasets/imnet_intersect_c10.py b/datasets/imnet_intersect_c10.py new file mode 100644 index 0000000..a01da78 --- /dev/null +++ b/datasets/imnet_intersect_c10.py @@ -0,0 +1,27 @@ +import torch +import torchvision +from torch.utils.data import Dataset +import numpy as np +from PIL import Image +from torchvision.datasets import DatasetFolder + + +def loader(path): + img = Image.open(path) + rgb_img = img.convert('RGB') + return rgb_img + + +class ImNetnC10(Dataset): + + def __init__(self, root, transform=None): + super().__init__() + self._dataset = DatasetFolder( + root=root, loader=loader, extensions=('jpeg',), transform=transform) + + def __getitem__(self, i): + return self._dataset[i] + + def __len__(self) -> int: + return len(self._dataset) + From 2f794c10e12e2f190a1ab50f3f0d14188d012be7 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:58:17 -0700 Subject: [PATCH 013/197] Add breeds. --- datasets/breeds.py | 96 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 datasets/breeds.py diff --git a/datasets/breeds.py b/datasets/breeds.py new file mode 100644 index 0000000..7796b4f --- /dev/null +++ b/datasets/breeds.py @@ -0,0 +1,96 @@ +import torch +from torch.utils.data import Dataset +import numpy as np +from PIL import Image +from robustness.tools.breeds_helpers import make_living17, make_entity13, make_entity30, make_nonliving26 + +BREEDS_SPLITS_TO_FUNC = { + 'entity13': make_entity13, + 'entity30': make_entity30, + 'living17': make_living17, + 'nonliving26': make_nonliving26, +} + +IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif'] + +SPLITS = ['train', 'val'] + +MIN_NUM_TRAIN_PER_CLASS = 1000 + +NUM_VAL_PER_CLASS = 50 + +IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif'] + +def get_classes(dir): + if sys.version_info >= (3, 5): + # Faster and available in Python 3.5 and above + classes = [d.name for d in os.scandir(dir) if d.is_dir()] + else: + classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))] + classes.sort() + class_to_idx = {classes[i]: i for i in range(len(classes))} + return classes, class_to_idx + +def has_file_allowed_extension(filename, extensions): + filename_lower = filename.lower() + return any(filename_lower.endswith(ext) for ext in extensions) + +def get_image_paths_breeds_class(class_dir, breeds_class): + image_paths_breeds_class = [] + for root, _, fnames in sorted(os.walk(class_dir)): + for fname in sorted(fnames): + if has_file_allowed_extension(fname, extensions=IMG_EXTENSIONS): + path = os.path.join(root, fname) + image_paths_breeds_class.append((path, breeds_class)) + return image_paths_breeds_class + +def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split): + image_paths_and_class = [] + for idx in range(len(subclasses)): + for subclass in subclasses[idx]: + subclass_image_paths_breeds_class = get_image_paths_breeds_class( + data_dir + '/' + idx_to_class_id[subclass] + '/', idx) + image_paths_and_class.extend(subclass_image_paths_breeds_class) + # print(data_dir + '/' + idx_to_class_id[subclass] + '/', len(subclass_image_names)) + if split == 'train': + assert(len(subclass_image_paths_breeds_class) >= MIN_NUM_TRAIN_PER_CLASS) + else: + assert(len(subclass_image_paths_breeds_class) == NUM_VAL_PER_CLASS) + return image_paths_and_class + +class Breeds(Dataset): + + def __init__(self, root, breeds_name, + info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified', + source=True, split='train', transform=None): + super().__init__() + if breeds_name not in BREEDS_SPLITS_TO_FUNC.keys(): + raise ValueError(f'breeds_name must be in {BREEDS_SPLITS_TO_FUNC.keys()} but was {breeds_name}') + if split not in SPLITS: + raise ValueError(f'split must be in {SPLITS} but was {split}') + self._breeds_name = breeds_name + self._source = source + self._split = split + self._transform = transform + self._info_dir = info_dir + self._data_dir = root + '/' + split + self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir) + breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name] + self._superclasses, self._subclass_split, self._label_map = breeds_func(self._info_dir, split="rand") + if source: + self._subclasses = self._subclass_split[0] + else: + self._subclasses = self._subclass_split[1] + self._image_paths_by_class = get_image_paths_by_class( + self._data_dir, self._idx_to_class_id, self._subclasses, split) + + def __getitem__(self, i): + path, y = self._image_paths_by_class[i] + x = Image.open(path) + if self._transform is not None: + x = self._transform(x) + return x, y + + def __len__(self) -> int: + return len(self._image_paths_by_class) + From 1252963922cdeebe59934f71f857cd67f9c14d55 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:59:13 -0700 Subject: [PATCH 014/197] Use quinine and update best stats. --- experiments/baseline_train.py | 41 +++++++++++++++++++++++++---------- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 85de12a..663522f 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -17,6 +17,7 @@ import torch.nn.functional as F import wandb import yaml +import quinine from models import resnet from utils.accumulator import Accumulator @@ -58,6 +59,18 @@ def get_test_stats(config, net, test_loader, criterion, device, max_examples=flo return val_loss, val_acc +def update_best_stats(stats, best_stats): + for k, v in stats.items(): + best_k = 'best_' + k + if best_k in best_stats: + cmb = max + if k.find('loss') != -1 and k.find('acc') == -1: + cmb = min + best_stats[best_k] = cmb(best_stats[best_k], v) + else: + best_stats[best_k] = v + + def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. train_data = utils.init_dataset(config['train_dataset']) @@ -130,7 +143,7 @@ def count_parameters(model, trainable): scheduler = utils.initialize( config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. - best_acc = 0.0 + best_stats = {} prev_ckp_path = None for epoch in range(config['epochs']): # Save checkpoint once in a while. @@ -172,6 +185,7 @@ def count_parameters(model, trainable): _, train_preds = torch.max(outputs.data, 1) loss_dict['train/acc'].add_values((train_preds == labels).tolist()) num_examples += len(labels) + outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): return num_examples // log_interval > (num_examples - len(labels)) // log_interval if should_log(config['log_interval']): @@ -191,7 +205,9 @@ def should_log(log_interval): max_examples=max_examples) stats['inter_ood_loss/' + name] = val_loss.get_mean() stats['inter_ood_acc/' + name] = val_acc.get_mean() - wandb.log(stats) + if config['wandb']: + wandb.log(stats) + update_best_stats(stats, best_stats) scheduler.step() # Get loss for each test set @@ -208,17 +224,19 @@ def should_log(log_interval): stats['ood_acc/' + name] = val_acc.get_mean() for k in loss_dict: stats[k] = loss_dict[k].get_mean() + update_best_stats(stats, best_stats) if config['wandb']: wandb.log(stats) + wandb.log(best_stats) utils.save_json(log_dir + '/current.json', stats) - # Save checkpoint of best model. - if val_acc.get_mean() > best_acc: - best_acc = val_acc.get_mean() - utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_best') - logging.info('Accuracy of the network on the 10000 test images: %.2f %%' % - (100.0 * val_acc.get_mean())) + # # Save checkpoint of best model. + # if val_acc.get_mean() > best_acc: + # best_acc = val_acc.get_mean() + # utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_best') + # logging.info('Accuracy of the network on the 10000 test images: %.2f %%' % + # (100.0 * val_acc.get_mean())) utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_last') - utils.save_json(log_dir + '/best.json', {'val_acc': best_acc}) + utils.save_json(log_dir + '/best.json', best_stats) def make_new_dir(new_dir): @@ -301,8 +319,9 @@ def setup(): # Setup logging. utils.setup_logging(log_dir, log_level) # Open config, update with command line args. - with open(args.config, 'r') as f: - config = yaml.safe_load(f) + # with open(args.config, 'r') as f: + # config = yaml.safe_load(f) + config = quinine.Quinfig(args.config) utils.update_config(unparsed, config) shutil.copy(args.config, log_dir+'/original_config.yaml') # Setup wandb. From 3a267a3237590f8759ad5187beb229994663b650 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:59:35 -0700 Subject: [PATCH 015/197] Add breeds example. --- scripts/breeds_example.ipynb | 248 +++++++++++++++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 scripts/breeds_example.ipynb diff --git a/scripts/breeds_example.ipynb b/scripts/breeds_example.ipynb new file mode 100644 index 0000000..13d85cf --- /dev/null +++ b/scripts/breeds_example.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import Dataset\n", + "import numpy as np\n", + "from PIL import Image\n", + "from robustness.tools.breeds_helpers import make_living17, make_entity13, make_entity30, make_nonliving26\n", + "\n", + "BREEDS_SPLITS_TO_FUNC = {\n", + " 'entity13': make_entity13,\n", + " 'entity30': make_entity30,\n", + " 'living17': make_living17,\n", + " 'nonliving26': make_nonliving26,\n", + "}\n", + "\n", + "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", + "\n", + "SPLITS = ['train', 'val']\n", + "\n", + "MIN_NUM_TRAIN_PER_CLASS = 1000\n", + "\n", + "NUM_VAL_PER_CLASS = 50\n", + "\n", + "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", + "\n", + "def get_classes(dir):\n", + " if sys.version_info >= (3, 5):\n", + " # Faster and available in Python 3.5 and above\n", + " classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n", + " else:\n", + " classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]\n", + " classes.sort()\n", + " class_to_idx = {classes[i]: i for i in range(len(classes))}\n", + " return classes, class_to_idx\n", + "\n", + "def has_file_allowed_extension(filename, extensions):\n", + " filename_lower = filename.lower()\n", + " return any(filename_lower.endswith(ext) for ext in extensions)\n", + "\n", + "def get_image_paths_breeds_class(class_dir, breeds_class):\n", + " image_paths_breeds_class = []\n", + " for root, _, fnames in sorted(os.walk(class_dir)):\n", + " for fname in sorted(fnames):\n", + " if has_file_allowed_extension(fname, extensions=IMG_EXTENSIONS):\n", + " path = os.path.join(root, fname)\n", + " image_paths_breeds_class.append((path, breeds_class))\n", + " return image_paths_breeds_class\n", + "\n", + "def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split):\n", + " image_paths_and_class = []\n", + " for idx in range(len(subclasses)):\n", + " for subclass in subclasses[idx]:\n", + " subclass_image_paths_breeds_class = get_image_paths_breeds_class(\n", + " data_dir + '/' + idx_to_class_id[subclass] + '/', idx)\n", + " image_paths_and_class.extend(subclass_image_paths_breeds_class)\n", + " # print(data_dir + '/' + idx_to_class_id[subclass] + '/', len(subclass_image_names))\n", + " if split == 'train':\n", + " assert(len(subclass_image_paths_breeds_class) >= MIN_NUM_TRAIN_PER_CLASS)\n", + " else:\n", + " assert(len(subclass_image_paths_breeds_class) == NUM_VAL_PER_CLASS)\n", + " return image_paths_and_class\n", + "\n", + "class Breeds(Dataset):\n", + "\n", + " def __init__(self, root, breeds_name,\n", + " info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified',\n", + " source=True, split='train', transform=None):\n", + " super().__init__()\n", + " if breeds_name not in BREEDS_SPLITS_TO_FUNC.keys():\n", + " raise ValueError(f'breeds_name must be in {BREEDS_SPLITS_TO_FUNC.keys()} but was {breeds_name}')\n", + " if split not in SPLITS:\n", + " raise ValueError(f'split must be in {SPLITS} but was {split}')\n", + " self._breeds_name = breeds_name\n", + " self._source = source\n", + " self._split = split\n", + " self._transform = transform\n", + " self._info_dir = info_dir\n", + " self._data_dir = root + '/' + split\n", + " self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir)\n", + " breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name]\n", + " self._superclasses, self._subclass_split, self._label_map = breeds_func(self._info_dir, split=\"rand\")\n", + " if source:\n", + " self._subclasses = self._subclass_split[0]\n", + " else:\n", + " self._subclasses = self._subclass_split[1]\n", + " self._image_paths_by_class = get_image_paths_by_class(\n", + " self._data_dir, self._idx_to_class_id, self._subclasses, split)\n", + " \n", + " \n", + " # Get a mapping of class index to type by sorting.\n", + " # Get the names of the classes using robustness helper\n", + " # Get the source and target classes\n", + " # Get a list of files in each class\n", + " # 1300 examples per class in train, 50 in test, check this.\n", + " # Get item by class order.\n", + "# if corruption not in CORRUPTIONS:\n", + "# raise ValueError(f\"{corruption} is not a valid corruption.\")\n", + "# if not(0 <= severity <= 4):\n", + "# raise ValueError(f\"Severity was {severity} but must be 0, 1, 2, 3, 4.\")\n", + "# num_examples = 10000\n", + "# start_idx = num_examples * severity\n", + "# end_idx = num_examples * (severity + 1)\n", + "# self._xs = np.load(root + '/' + corruption + '.npy')[start_idx:end_idx]\n", + "# self._ys = torch.LongTensor(np.load(root + 'labels.npy'))[start_idx:end_idx]\n", + "# assert(len(self._xs) == len(self._ys) == num_examples)\n", + "# self._transform = transform\n", + "\n", + " def __getitem__(self, i):\n", + " path, y = self._image_paths_by_class[i]\n", + " x = Image.open(path)\n", + " if self._transform is not None:\n", + " x = self._transform(x)\n", + " return x, y\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self._image_paths_by_class)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Breeds(root='/u/scr/nlp/imagenet/', breeds_name='living17', source=True, split='train')" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "44200" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(dataset._image_paths_by_class)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[869, 399, 578, 735, 652, 610, 501, 445, 655, 842], [87, 92, 91, 137, 14, 145, 129, 135, 85, 21], [45, 42, 51, 47, 52, 63, 55, 35, 58, 33], [119, 72, 300, 75, 73, 317, 302, 120, 309, 313], [284, 350, 292, 344, 174, 149, 375, 258, 283, 170], [443, 552, 824, 728, 433, 514, 679, 518, 570, 638], [484, 814, 554, 914, 404, 510, 628, 871, 812, 403], [890, 681, 430, 590, 872, 745, 422, 664, 522, 416], [894, 861, 553, 669, 564, 431, 493, 559, 556, 789], [881, 695, 626, 822, 704, 499, 845, 398, 778, 512], [483, 442, 562, 727, 920, 460, 500, 663, 743, 900], [803, 867, 751, 791, 880, 670, 705, 654, 609, 757], [937, 987, 950, 943, 940, 942, 941, 938, 945, 952]]\n" + ] + } + ], + "source": [ + "print(dataset._subclasses)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ape\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "idx = 40001\n", + "plt.imshow(dataset[idx][0])\n", + "print(dataset._label_map[dataset[idx][1]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From cd02aaea786f69abde67a0f7285750d770d40885 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 11:59:51 -0700 Subject: [PATCH 016/197] Update script? --- .../breeds_example-checkpoint.ipynb | 178 ++++++++++++++++++ scripts/cifar10c_stl_examples.ipynb | 134 ++++++++++--- 2 files changed, 291 insertions(+), 21 deletions(-) create mode 100644 scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb diff --git a/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb b/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb new file mode 100644 index 0000000..2c1d8d1 --- /dev/null +++ b/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb @@ -0,0 +1,178 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import Dataset\n", + "import numpy as np\n", + "from PIL import Image\n", + "from robustness.tools.breeds_helpers import make_living17, make_entity13, make_entity30, make_nonliving26\n", + "\n", + "BREEDS_SPLITS_TO_FUNC = {\n", + " 'entity13': make_entity13,\n", + " 'entity30': make_entity30,\n", + " 'living17': make_living17,\n", + " 'nonliving26': make_nonliving26,\n", + "}\n", + "\n", + "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", + "\n", + "SPLITS = ['train', 'val']\n", + "\n", + "NUM_TRAIN_PER_CLASS = 1300\n", + "\n", + "NUM_VAL_PER_CLASS = 50\n", + "\n", + "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", + "\n", + "def get_classes(dir):\n", + " if sys.version_info >= (3, 5):\n", + " # Faster and available in Python 3.5 and above\n", + " classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n", + " else:\n", + " classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]\n", + " classes.sort()\n", + " class_to_idx = {classes[i]: i for i in range(len(classes))}\n", + " return classes, class_to_idx\n", + "\n", + "def has_file_allowed_extension(filename, extensions):\n", + " filename_lower = filename.lower()\n", + " return any(filename_lower.endswith(ext) for ext in extensions)\n", + "\n", + "def get_class_image_names(class_dir):\n", + " image_names = []\n", + " for root, _, fnames in sorted(os.walk(class_dir)):\n", + " for fname in sorted(fnames):\n", + " if has_file_allowed_extension(fname, extensions=IMG_EXTENSIONS):\n", + " path = os.path.join(root, fname)\n", + " image_names.append(path)\n", + " return image_names\n", + "\n", + "def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split):\n", + " image_paths_by_class = []\n", + " for idx in range(len(subclasses)):\n", + " image_paths_by_class.append([])\n", + " for subclass in subclasses[idx]:\n", + " subclass_image_names = get_class_image_names(data_dir + '/' + idx_to_class_id[subclass] + '/')\n", + " image_paths_by_class[-1].extend(subclass_image_names)\n", + " if split == 'train':\n", + " assert(len(subclass_image_names) == NUM_TRAIN_PER_CLASS)\n", + " else:\n", + " assert(len(subclass_image_names) == NUM_VAL_PER_CLASS)\n", + " return image_paths_by_class\n", + "\n", + "class Breeds(Dataset):\n", + "\n", + " def __init__(self, root, breeds_name,\n", + " info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified',\n", + " source=True, split='train', transform=None):\n", + " super().__init__()\n", + " if breeds_name not in BREEDS_SPLITS:\n", + " raise ValueError(f'breeds_name must be in {BREEDS_SPLITS} but was {breeds_name}')\n", + " if split not in SPLITS:\n", + " raise ValueError(f'split must be in {SPLITS} but was {split}')\n", + " self._breeds_name = breeds_name\n", + " self._source = source\n", + " self._split = split\n", + " self._transform = transform\n", + " self._info_dir = info_dir\n", + " self._data_dir = root + '/' + split\n", + " self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir)\n", + " if breeds_name == \n", + " self._superclasses, self._subclass_split, self._label_map = make_living17(self._info_dir, split=\"rand\")\n", + " # print(superclasses, label_map)\n", + " if source:\n", + " self._subclasses = self._subclass_split[0]\n", + " else:\n", + " self._subclasses = self._subclass_split[1]\n", + " self._image_paths_by_class = get_image_paths_by_class(\n", + " self._data_dir, self._idx_to_class_id, self._subclasses, split)\n", + " \n", + " # Get a mapping of class index to type by sorting.\n", + " # Get the names of the classes using robustness helper\n", + " # Get the source and target classes\n", + " # Get a list of files in each class\n", + " # 1300 examples per class in train, 50 in test, check this.\n", + " # Get item by class order.\n", + "# if corruption not in CORRUPTIONS:\n", + "# raise ValueError(f\"{corruption} is not a valid corruption.\")\n", + "# if not(0 <= severity <= 4):\n", + "# raise ValueError(f\"Severity was {severity} but must be 0, 1, 2, 3, 4.\")\n", + "# num_examples = 10000\n", + "# start_idx = num_examples * severity\n", + "# end_idx = num_examples * (severity + 1)\n", + "# self._xs = np.load(root + '/' + corruption + '.npy')[start_idx:end_idx]\n", + "# self._ys = torch.LongTensor(np.load(root + 'labels.npy'))[start_idx:end_idx]\n", + "# assert(len(self._xs) == len(self._ys) == num_examples)\n", + "# self._transform = transform\n", + "\n", + " def __getitem__(self, i):\n", + " x, y = self._xs[i], self._ys[i]\n", + " x = Image.fromarray(np.uint8(x))\n", + " if self._transform is not None:\n", + " x = self._transform(x)\n", + " return x, y\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self._xs)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity13')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/cifar10c_stl_examples.ipynb b/scripts/cifar10c_stl_examples.ipynb index e6d74be..ff7de75 100644 --- a/scripts/cifar10c_stl_examples.ipynb +++ b/scripts/cifar10c_stl_examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 17, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 17, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -38,6 +38,8 @@ "import utils.utils as utils\n", "from utils.accumulator import Accumulator\n", "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "from matplotlib import cm\n", "importlib.reload(cifar10c)\n", "importlib.reload(stl_cifar_style)\n", "importlib.reload(cinic)" @@ -80,42 +82,112 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "from PIL import Image\n", - "from matplotlib import cm\n", - "im = Image.fromarray(np.uint8(img))\n", - "display(im)" + "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['airplane',\n", + " 'car',\n", + " 'bird',\n", + " 'cat',\n", + " 'deer',\n", + " 'dog',\n", + " 'NONE',\n", + " 'horse',\n", + " 'ship',\n", + " 'truck']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" + "stl_data.classes" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ship\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "stl_data.classes" + "idx = 2004\n", + "img = stl_data[idx][0]\n", + "plt.imshow(img)\n", + "print(stl_data.classes[stl_data[idx][1]])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "idx = 2004\n", - "img = stl_data[idx][0]\n", + "stl_downsampled = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False,\n", + " transform=transforms.Resize(32))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "airplane\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "idx = 12\n", + "img = stl_downsampled[idx][0]\n", "plt.imshow(img)\n", "print(stl_data.classes[stl_data[idx][1]])" ] @@ -129,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -146,11 +218,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "idx = 25009\n", + "idx = 1\n", "img = np.transpose(cinic_data[idx][0], axes=[1,2,0])\n", "plt.imshow(img)\n", "print(cinic_data[idx][1])" @@ -158,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 23, "metadata": {}, "outputs": [ { From 5d3dd0d7cf4f6ae531894c4a2492b634c6a262e7 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 18:16:57 -0700 Subject: [PATCH 017/197] Reorganize configs. --- configs/breeds_living_finetuning.yaml | 17 +++++++ configs/breeds_living_probe.yaml | 10 ++++ configs/datasets_breeds_living.yaml | 46 +++++++++++++++++++ configs/imnet_cifar_all_finetune.yaml | 27 ++--------- configs/imnet_cifar_all_probe.yaml | 35 ++------------ .../imnet_finetune_cifar_resnet_baseline.yaml | 0 .../imnet_finetune_cifar_resnet_creafz.yaml | 0 ...netune_cifar_resnet_fixed_lr_test_stl.yaml | 0 ...t_finetune_cifar_resnet_test_cifar10c.yaml | 0 .../imnet_finetune_cifar_resnet_test_stl.yaml | 0 ...nprobe_cifar_resnet_fixed_lr_test_stl.yaml | 0 ...t_linprobe_cifar_resnet_test_cifar10c.yaml | 0 .../imnet_linprobe_cifar_resnet_test_stl.yaml | 0 ...probe_noaugment_cifar_resnet_test_stl.yaml | 0 .../imnet_probe_cifar_resnet_test_stl.yaml | 0 .../small_cifar_resnet_baseline.yaml | 0 .../small_cifar_resnet_frozenfeatures.yaml | 0 .../{ => old}/small_cifar_resnet_merlin.yaml | 0 configs/resnet50_transfer.yaml | 33 +++++++++++++ 19 files changed, 113 insertions(+), 55 deletions(-) create mode 100644 configs/breeds_living_finetuning.yaml create mode 100644 configs/breeds_living_probe.yaml create mode 100644 configs/datasets_breeds_living.yaml rename configs/{ => old}/imnet_finetune_cifar_resnet_baseline.yaml (100%) rename configs/{ => old}/imnet_finetune_cifar_resnet_creafz.yaml (100%) rename configs/{ => old}/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml (100%) rename configs/{ => old}/imnet_finetune_cifar_resnet_test_cifar10c.yaml (100%) rename configs/{ => old}/imnet_finetune_cifar_resnet_test_stl.yaml (100%) rename configs/{ => old}/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml (100%) rename configs/{ => old}/imnet_linprobe_cifar_resnet_test_cifar10c.yaml (100%) rename configs/{ => old}/imnet_linprobe_cifar_resnet_test_stl.yaml (100%) rename configs/{ => old}/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml (100%) rename configs/{ => old}/imnet_probe_cifar_resnet_test_stl.yaml (100%) rename configs/{ => old}/small_cifar_resnet_baseline.yaml (100%) rename configs/{ => old}/small_cifar_resnet_frozenfeatures.yaml (100%) rename configs/{ => old}/small_cifar_resnet_merlin.yaml (100%) create mode 100644 configs/resnet50_transfer.yaml diff --git a/configs/breeds_living_finetuning.yaml b/configs/breeds_living_finetuning.yaml new file mode 100644 index 0000000..dbdc46b --- /dev/null +++ b/configs/breeds_living_finetuning.yaml @@ -0,0 +1,17 @@ + +inherit: + - datasets_breeds_living.yaml + - resnet50_transfer.yaml + +epochs: &epochs 25 + +finetune: True +num_classes: 17 +linear_probe: False +use_net_val_mode: False + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + diff --git a/configs/breeds_living_probe.yaml b/configs/breeds_living_probe.yaml new file mode 100644 index 0000000..68c9cf2 --- /dev/null +++ b/configs/breeds_living_probe.yaml @@ -0,0 +1,10 @@ + +inherit: + - datasets_breeds_living.yaml + - resnet50_transfer.yaml + +num_classes: 17 +linear_probe: True +finetune: True +use_net_val_mode: True + diff --git a/configs/datasets_breeds_living.yaml b/configs/datasets_breeds_living.yaml new file mode 100644 index 0000000..1939ea3 --- /dev/null +++ b/configs/datasets_breeds_living.yaml @@ -0,0 +1,46 @@ + +train_dataset: + classname: datasets.breeds.Breeds + args: + source: True + split: 'train' + breeds_name: 'living17' + root: '/u/scr/nlp/imagenet/' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'source_val_living' + max_test_examples: 1000 + classname: datasets.breeds.Breeds + args: + source: True + split: 'val' + breeds_name: 'living17' + root: '/u/scr/nlp/imagenet/' + - name: 'target_val_living' + max_test_examples: 1000 + classname: datasets.breeds.Breeds + args: + source: False + split: 'val' + breeds_name: 'living17' + root: '/u/scr/nlp/imagenet/' + diff --git a/configs/imnet_cifar_all_finetune.yaml b/configs/imnet_cifar_all_finetune.yaml index 9433bda..92a7e10 100644 --- a/configs/imnet_cifar_all_finetune.yaml +++ b/configs/imnet_cifar_all_finetune.yaml @@ -1,38 +1,17 @@ -inherit: datasets_cifar_test_all.yaml +inherit: + - datasets_cifar_test_all.yaml + - resnet50_transfer.yaml -log_interval: 5000 -use_cuda: True -save_freq: 26 epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False -test_interval: 10000 finetune: True num_classes: 10 linear_probe: False use_net_val_mode: False -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - scheduler: classname: torch.optim.lr_scheduler.StepLR args: step_size: *epochs -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/imnet_cifar_all_probe.yaml b/configs/imnet_cifar_all_probe.yaml index 4c88b8f..81f1618 100644 --- a/configs/imnet_cifar_all_probe.yaml +++ b/configs/imnet_cifar_all_probe.yaml @@ -1,37 +1,10 @@ -inherit: datasets_cifar_test_all.yaml +inherit: + - datasets_cifar_test_all.yaml + - resnet50_transfer.yaml -log_interval: 5000 -use_cuda: True -save_freq: 101 -epochs: &epochs 100 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True num_classes: 10 linear_probe: True +finetune: True use_net_val_mode: True -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/imnet_finetune_cifar_resnet_baseline.yaml b/configs/old/imnet_finetune_cifar_resnet_baseline.yaml similarity index 100% rename from configs/imnet_finetune_cifar_resnet_baseline.yaml rename to configs/old/imnet_finetune_cifar_resnet_baseline.yaml diff --git a/configs/imnet_finetune_cifar_resnet_creafz.yaml b/configs/old/imnet_finetune_cifar_resnet_creafz.yaml similarity index 100% rename from configs/imnet_finetune_cifar_resnet_creafz.yaml rename to configs/old/imnet_finetune_cifar_resnet_creafz.yaml diff --git a/configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml b/configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml similarity index 100% rename from configs/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml rename to configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml diff --git a/configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml b/configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml similarity index 100% rename from configs/imnet_finetune_cifar_resnet_test_cifar10c.yaml rename to configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml diff --git a/configs/imnet_finetune_cifar_resnet_test_stl.yaml b/configs/old/imnet_finetune_cifar_resnet_test_stl.yaml similarity index 100% rename from configs/imnet_finetune_cifar_resnet_test_stl.yaml rename to configs/old/imnet_finetune_cifar_resnet_test_stl.yaml diff --git a/configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml b/configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml similarity index 100% rename from configs/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml rename to configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml diff --git a/configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml b/configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml similarity index 100% rename from configs/imnet_linprobe_cifar_resnet_test_cifar10c.yaml rename to configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml diff --git a/configs/imnet_linprobe_cifar_resnet_test_stl.yaml b/configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml similarity index 100% rename from configs/imnet_linprobe_cifar_resnet_test_stl.yaml rename to configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml diff --git a/configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml b/configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml similarity index 100% rename from configs/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml rename to configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml diff --git a/configs/imnet_probe_cifar_resnet_test_stl.yaml b/configs/old/imnet_probe_cifar_resnet_test_stl.yaml similarity index 100% rename from configs/imnet_probe_cifar_resnet_test_stl.yaml rename to configs/old/imnet_probe_cifar_resnet_test_stl.yaml diff --git a/configs/small_cifar_resnet_baseline.yaml b/configs/old/small_cifar_resnet_baseline.yaml similarity index 100% rename from configs/small_cifar_resnet_baseline.yaml rename to configs/old/small_cifar_resnet_baseline.yaml diff --git a/configs/small_cifar_resnet_frozenfeatures.yaml b/configs/old/small_cifar_resnet_frozenfeatures.yaml similarity index 100% rename from configs/small_cifar_resnet_frozenfeatures.yaml rename to configs/old/small_cifar_resnet_frozenfeatures.yaml diff --git a/configs/small_cifar_resnet_merlin.yaml b/configs/old/small_cifar_resnet_merlin.yaml similarity index 100% rename from configs/small_cifar_resnet_merlin.yaml rename to configs/old/small_cifar_resnet_merlin.yaml diff --git a/configs/resnet50_transfer.yaml b/configs/resnet50_transfer.yaml new file mode 100644 index 0000000..7eb3225 --- /dev/null +++ b/configs/resnet50_transfer.yaml @@ -0,0 +1,33 @@ + +log_interval: 5000 +use_cuda: True +save_freq: 101 +epochs: &epochs 100 +batch_size: 128 +num_workers: 8 +save_all_checkpoints: False + +finetune: True +use_net_val_mode: True + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.01 + momentum: 0.9 + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + From 79c1098774ad77186de4aa27dcc9e57cb90af430 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 18:17:29 -0700 Subject: [PATCH 018/197] Fix breeds dataset. --- datasets/breeds.py | 3 +++ experiments/baseline_train.py | 1 + 2 files changed, 4 insertions(+) diff --git a/datasets/breeds.py b/datasets/breeds.py index 7796b4f..a0e740f 100644 --- a/datasets/breeds.py +++ b/datasets/breeds.py @@ -1,3 +1,5 @@ +import sys +import os import torch from torch.utils.data import Dataset import numpy as np @@ -87,6 +89,7 @@ def __init__(self, root, breeds_name, def __getitem__(self, i): path, y = self._image_paths_by_class[i] x = Image.open(path) + x = x.convert('RGB') if self._transform is not None: x = self._transform(x) return x, y diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 663522f..36bbf26 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -73,6 +73,7 @@ def update_best_stats(stats, best_stats): def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. + logging.info("Entering main.") train_data = utils.init_dataset(config['train_dataset']) train_loader = torch.utils.data.DataLoader( train_data, batch_size=config['batch_size'], From b35a2880985489e770337d4c5433044e71a2e16f Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 20:03:57 -0700 Subject: [PATCH 019/197] Add support for moco initialization. --- models/imnet_resnet.py | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py index a735835..0193cdb 100644 --- a/models/imnet_resnet.py +++ b/models/imnet_resnet.py @@ -1,13 +1,42 @@ +import torchvision.models as models from torchvision.models import resnet50 import torch from torch import nn +PRETRAIN_STYLE = ['supervised', 'mocov2', 'simclrv2'] + + +def load_moco(checkpoint_path): + checkpoint = torch.load(checkpoint_path, map_location="cpu") + model = models.__dict__[checkpoint['arch']]() + + state_dict = checkpoint['state_dict'] + for k in list(state_dict.keys()): + # retain only encoder_q up to before the embedding layer + if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'): + # remove prefix + state_dict[k[len("module.encoder_q."):]] = state_dict[k] + # delete renamed or unused k + del state_dict[k] + msg = model.load_state_dict(state_dict, strict=False) + assert set(msg.missing_keys) == {"fc.weight", "fc.bias"} + return model + + class ResNet50(nn.Module): - def __init__(self, pretrained=False): + def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_path=None): super().__init__() - self._model = resnet50(pretrained=pretrained) + if pretrain_style not in PRETRAIN_STYLE: + raise ValueError( + f'Pretrain style should be in {PRETRAIN_STYLE} but was {pretrain_style}') + if pretrained and pretrain_style == 'mocov2': + self._model = load_moco(checkpoint_path) + elif pretrained and pretrain_style == 'simclrv2': + raise NotImplementedError() + elif not pretrained or pretrain_style == 'supervised': + self._model = resnet50(pretrained=pretrained) def forward(self, x): return self._model(x) From b209fb921632de6e217cae0c79364bf3b3fde5b6 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Mar 2021 20:04:22 -0700 Subject: [PATCH 020/197] Test loading moco --- scripts/moco_simclr_loading.ipynb | 93 +++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 scripts/moco_simclr_loading.ipynb diff --git a/scripts/moco_simclr_loading.ipynb b/scripts/moco_simclr_loading.ipynb new file mode 100644 index 0000000..02f60b2 --- /dev/null +++ b/scripts/moco_simclr_loading.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + " \n", + "from models import imnet_resnet\n", + "\n", + "import importlib\n", + "importlib.reload(imnet_resnet)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "model = imnet_resnet.ResNet50(pretrained=True, pretrain_style='mocov2', checkpoint_path='/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleAttributeError", + "evalue": "'ResNet50' object has no attribute 'fc'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/juice/scr/ananya/cifar_experiments/env/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 770\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 771\u001b[0m raise ModuleAttributeError(\"'{}' object has no attribute '{}'\".format(\n\u001b[0;32m--> 772\u001b[0;31m type(self).__name__, name))\n\u001b[0m\u001b[1;32m 773\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 774\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Module'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleAttributeError\u001b[0m: 'ResNet50' object has no attribute 'fc'" + ] + } + ], + "source": [ + "model.fc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 2d7d329e86f032dc1d3a05ae6eb13c5bf63dc4e4 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 3 Apr 2021 21:17:07 -0700 Subject: [PATCH 021/197] Add more configs for breeds. --- configs/breeds_living_moco_finetuning.yaml | 24 +++++++++++ configs/breeds_living_moco_probe.yaml | 24 +++++++++++ configs/datasets_breeds_entity30.yaml | 43 ++++++++++++++++++++ configs/e30_sup_ft.yaml | 17 ++++++++ configs/e30_sup_probe.yaml | 10 +++++ configs/e30_swav_ft_augment.yaml | 47 ++++++++++++++++++++++ configs/e30_swav_probe_augment.yaml | 47 ++++++++++++++++++++++ configs/entity30_moco_finetuning.yaml | 7 ++++ configs/entity30_moco_probe.yaml | 7 ++++ configs/resnet50_transfer.yaml | 2 +- 10 files changed, 227 insertions(+), 1 deletion(-) create mode 100644 configs/breeds_living_moco_finetuning.yaml create mode 100644 configs/breeds_living_moco_probe.yaml create mode 100644 configs/datasets_breeds_entity30.yaml create mode 100644 configs/e30_sup_ft.yaml create mode 100644 configs/e30_sup_probe.yaml create mode 100644 configs/e30_swav_ft_augment.yaml create mode 100644 configs/e30_swav_probe_augment.yaml create mode 100644 configs/entity30_moco_finetuning.yaml create mode 100644 configs/entity30_moco_probe.yaml diff --git a/configs/breeds_living_moco_finetuning.yaml b/configs/breeds_living_moco_finetuning.yaml new file mode 100644 index 0000000..22540a7 --- /dev/null +++ b/configs/breeds_living_moco_finetuning.yaml @@ -0,0 +1,24 @@ + +inherit: + - datasets_breeds_living.yaml + - resnet50_transfer.yaml + +epochs: &epochs 25 + +num_classes: 17 +finetune: True +linear_probe: False +use_net_val_mode: False + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar' + diff --git a/configs/breeds_living_moco_probe.yaml b/configs/breeds_living_moco_probe.yaml new file mode 100644 index 0000000..f9ddbee --- /dev/null +++ b/configs/breeds_living_moco_probe.yaml @@ -0,0 +1,24 @@ + +inherit: + - datasets_breeds_living.yaml + - resnet50_transfer.yaml + +epochs: &epochs 25 + +num_classes: 17 +finetune: True +linear_probe: True +use_net_val_mode: True + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar' + diff --git a/configs/datasets_breeds_entity30.yaml b/configs/datasets_breeds_entity30.yaml new file mode 100644 index 0000000..8e31f25 --- /dev/null +++ b/configs/datasets_breeds_entity30.yaml @@ -0,0 +1,43 @@ + +train_dataset: + classname: datasets.breeds.Breeds + args: + source: True + split: 'train' + breeds_name: 'entity30' + root: '/u/scr/nlp/imagenet/' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'source_val_entity' + classname: datasets.breeds.Breeds + args: + source: True + split: 'val' + breeds_name: 'entity30' + root: '/u/scr/nlp/imagenet/' + - name: 'target_val_entity' + classname: datasets.breeds.Breeds + args: + source: False + split: 'val' + breeds_name: 'entity30' + root: '/u/scr/nlp/imagenet/' diff --git a/configs/e30_sup_ft.yaml b/configs/e30_sup_ft.yaml new file mode 100644 index 0000000..1cc4ba7 --- /dev/null +++ b/configs/e30_sup_ft.yaml @@ -0,0 +1,17 @@ + +inherit: + - datasets_breeds_entity30.yaml + - resnet50_transfer.yaml + +epochs: &epochs 25 + +finetune: True +num_classes: 30 +linear_probe: False +use_net_val_mode: False + +scheduler: + classname: torch.optim.lr_scheduler.StepLR + args: + step_size: *epochs + diff --git a/configs/e30_sup_probe.yaml b/configs/e30_sup_probe.yaml new file mode 100644 index 0000000..69d2cb8 --- /dev/null +++ b/configs/e30_sup_probe.yaml @@ -0,0 +1,10 @@ + +inherit: + - datasets_breeds_entity30.yaml + - resnet50_transfer.yaml + +num_classes: 30 +linear_probe: True +finetune: True +use_net_val_mode: True + diff --git a/configs/e30_swav_ft_augment.yaml b/configs/e30_swav_ft_augment.yaml new file mode 100644 index 0000000..f931b5c --- /dev/null +++ b/configs/e30_swav_ft_augment.yaml @@ -0,0 +1,47 @@ + +inherit: + - breeds_living_moco_finetuning.yaml + - datasets_breeds_entity30.yaml + +num_classes: 30 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'swav' + checkpoint_path: '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar' + +# Add augmentations, and change normalization a bit. +train_dataset: + classname: datasets.breeds.Breeds + args: + source: True + split: 'train' + breeds_name: 'entity30' + root: '/u/scr/nlp/imagenet/' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 256 + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + diff --git a/configs/e30_swav_probe_augment.yaml b/configs/e30_swav_probe_augment.yaml new file mode 100644 index 0000000..8131a07 --- /dev/null +++ b/configs/e30_swav_probe_augment.yaml @@ -0,0 +1,47 @@ + +inherit: + - breeds_living_moco_probe.yaml + - datasets_breeds_entity30.yaml + +num_classes: 30 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'swav' + checkpoint_path: '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar' + +# Add augmentations, and change normalization a bit. +train_dataset: + classname: datasets.breeds.Breeds + args: + source: True + split: 'train' + breeds_name: 'entity30' + root: '/u/scr/nlp/imagenet/' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 256 + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + diff --git a/configs/entity30_moco_finetuning.yaml b/configs/entity30_moco_finetuning.yaml new file mode 100644 index 0000000..8b52b3b --- /dev/null +++ b/configs/entity30_moco_finetuning.yaml @@ -0,0 +1,7 @@ + +inherit: + - breeds_living_moco_finetuning.yaml + - datasets_breeds_entity30.yaml + +num_classes: 30 + diff --git a/configs/entity30_moco_probe.yaml b/configs/entity30_moco_probe.yaml new file mode 100644 index 0000000..e6fc31c --- /dev/null +++ b/configs/entity30_moco_probe.yaml @@ -0,0 +1,7 @@ + +inherit: + - breeds_living_moco_probe.yaml + - datasets_breeds_entity30.yaml + +num_classes: 30 + diff --git a/configs/resnet50_transfer.yaml b/configs/resnet50_transfer.yaml index 7eb3225..0fbad2c 100644 --- a/configs/resnet50_transfer.yaml +++ b/configs/resnet50_transfer.yaml @@ -2,7 +2,7 @@ log_interval: 5000 use_cuda: True save_freq: 101 -epochs: &epochs 100 +epochs: &epochs 25 batch_size: 128 num_workers: 8 save_all_checkpoints: False From f320de6df19f11cc1ff5f0d6bc76e8904565e103 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 3 Apr 2021 21:17:39 -0700 Subject: [PATCH 022/197] ImageNet can have less than 1000 images in some classes. --- datasets/breeds.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datasets/breeds.py b/datasets/breeds.py index a0e740f..5432c27 100644 --- a/datasets/breeds.py +++ b/datasets/breeds.py @@ -17,7 +17,7 @@ SPLITS = ['train', 'val'] -MIN_NUM_TRAIN_PER_CLASS = 1000 +MIN_NUM_TRAIN_PER_CLASS = 100 NUM_VAL_PER_CLASS = 50 From d4300b8ff9d90f572e9f428321a9c314eebd043f Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 3 Apr 2021 21:17:55 -0700 Subject: [PATCH 023/197] Add support for swav. --- models/imnet_resnet.py | 27 ++- models/swav_resnet50.py | 354 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 380 insertions(+), 1 deletion(-) create mode 100644 models/swav_resnet50.py diff --git a/models/imnet_resnet.py b/models/imnet_resnet.py index 0193cdb..8a7f762 100644 --- a/models/imnet_resnet.py +++ b/models/imnet_resnet.py @@ -1,10 +1,13 @@ +from collections import OrderedDict import torchvision.models as models from torchvision.models import resnet50 import torch from torch import nn +from models import swav_resnet50 -PRETRAIN_STYLE = ['supervised', 'mocov2', 'simclrv2'] + +PRETRAIN_STYLE = ['supervised', 'mocov2', 'swav', 'simclrv2'] def load_moco(checkpoint_path): @@ -24,6 +27,26 @@ def load_moco(checkpoint_path): return model +def load_swav(checkpoint_path): + model = swav_resnet50.resnet50(output_dim=0, eval_mode=False) + state_dict = torch.load(checkpoint_path, map_location="cpu") + if "state_dict" in state_dict: + state_dict = state_dict["state_dict"] + # remove prefix "module." + state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} + for k, v in model.state_dict().items(): + if k not in list(state_dict): + print('key "{}" could not be found in provided state dict'.format(k)) + elif state_dict[k].shape != v.shape: + print('key "{}" is of different shape in model and provided state dict'.format(k)) + state_dict[k] = v + msg = model.load_state_dict(state_dict, strict=False) + model = torch.nn.Sequential(OrderedDict([ + ('resnet', model), + ('fc', nn.Linear(2048, 1000))])) + return model + + class ResNet50(nn.Module): def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_path=None): @@ -33,6 +56,8 @@ def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_pat f'Pretrain style should be in {PRETRAIN_STYLE} but was {pretrain_style}') if pretrained and pretrain_style == 'mocov2': self._model = load_moco(checkpoint_path) + if pretrained and pretrain_style == 'swav': + self._model = load_swav(checkpoint_path) elif pretrained and pretrain_style == 'simclrv2': raise NotImplementedError() elif not pretrained or pretrain_style == 'supervised': diff --git a/models/swav_resnet50.py b/models/swav_resnet50.py new file mode 100644 index 0000000..53670fc --- /dev/null +++ b/models/swav_resnet50.py @@ -0,0 +1,354 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +import torch +import torch.nn as nn + + +def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1): + """3x3 convolution with padding""" + return nn.Conv2d( + in_planes, + out_planes, + kernel_size=3, + stride=stride, + padding=dilation, + groups=groups, + bias=False, + dilation=dilation, + ) + + +def conv1x1(in_planes, out_planes, stride=1): + """1x1 convolution""" + return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + __constants__ = ["downsample"] + + def __init__( + self, + inplanes, + planes, + stride=1, + downsample=None, + groups=1, + base_width=64, + dilation=1, + norm_layer=None, + ): + super(BasicBlock, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + if groups != 1 or base_width != 64: + raise ValueError("BasicBlock only supports groups=1 and base_width=64") + if dilation > 1: + raise NotImplementedError("Dilation > 1 not supported in BasicBlock") + # Both self.conv1 and self.downsample layers downsample the input when stride != 1 + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = norm_layer(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = norm_layer(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + __constants__ = ["downsample"] + + def __init__( + self, + inplanes, + planes, + stride=1, + downsample=None, + groups=1, + base_width=64, + dilation=1, + norm_layer=None, + ): + super(Bottleneck, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + width = int(planes * (base_width / 64.0)) * groups + # Both self.conv2 and self.downsample layers downsample the input when stride != 1 + self.conv1 = conv1x1(inplanes, width) + self.bn1 = norm_layer(width) + self.conv2 = conv3x3(width, width, stride, groups, dilation) + self.bn2 = norm_layer(width) + self.conv3 = conv1x1(width, planes * self.expansion) + self.bn3 = norm_layer(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + def __init__( + self, + block, + layers, + zero_init_residual=False, + groups=1, + widen=1, + width_per_group=64, + replace_stride_with_dilation=None, + norm_layer=None, + normalize=False, + output_dim=0, + hidden_mlp=0, + nmb_prototypes=0, + eval_mode=False, + ): + super(ResNet, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + self._norm_layer = norm_layer + + self.eval_mode = eval_mode + self.padding = nn.ConstantPad2d(1, 0.0) + + self.inplanes = width_per_group * widen + self.dilation = 1 + if replace_stride_with_dilation is None: + # each element in the tuple indicates if we should replace + # the 2x2 stride with a dilated convolution instead + replace_stride_with_dilation = [False, False, False] + if len(replace_stride_with_dilation) != 3: + raise ValueError( + "replace_stride_with_dilation should be None " + "or a 3-element tuple, got {}".format(replace_stride_with_dilation) + ) + self.groups = groups + self.base_width = width_per_group + + # change padding 3 -> 2 compared to original torchvision code because added a padding layer + num_out_filters = width_per_group * widen + self.conv1 = nn.Conv2d( + 3, num_out_filters, kernel_size=7, stride=2, padding=2, bias=False + ) + self.bn1 = norm_layer(num_out_filters) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + self.layer1 = self._make_layer(block, num_out_filters, layers[0]) + num_out_filters *= 2 + self.layer2 = self._make_layer( + block, num_out_filters, layers[1], stride=2, dilate=replace_stride_with_dilation[0] + ) + num_out_filters *= 2 + self.layer3 = self._make_layer( + block, num_out_filters, layers[2], stride=2, dilate=replace_stride_with_dilation[1] + ) + num_out_filters *= 2 + self.layer4 = self._make_layer( + block, num_out_filters, layers[3], stride=2, dilate=replace_stride_with_dilation[2] + ) + self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) + + # normalize output features + self.l2norm = normalize + + # projection head + if output_dim == 0: + self.projection_head = None + elif hidden_mlp == 0: + self.projection_head = nn.Linear(num_out_filters * block.expansion, output_dim) + else: + self.projection_head = nn.Sequential( + nn.Linear(num_out_filters * block.expansion, hidden_mlp), + nn.BatchNorm1d(hidden_mlp), + nn.ReLU(inplace=True), + nn.Linear(hidden_mlp, output_dim), + ) + + # prototype layer + self.prototypes = None + if isinstance(nmb_prototypes, list): + self.prototypes = MultiPrototypes(output_dim, nmb_prototypes) + elif nmb_prototypes > 0: + self.prototypes = nn.Linear(output_dim, nmb_prototypes, bias=False) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu") + elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + # Zero-initialize the last BN in each residual branch, + # so that the residual branch starts with zeros, and each residual block behaves like an identity. + # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677 + if zero_init_residual: + for m in self.modules(): + if isinstance(m, Bottleneck): + nn.init.constant_(m.bn3.weight, 0) + elif isinstance(m, BasicBlock): + nn.init.constant_(m.bn2.weight, 0) + + def _make_layer(self, block, planes, blocks, stride=1, dilate=False): + norm_layer = self._norm_layer + downsample = None + previous_dilation = self.dilation + if dilate: + self.dilation *= stride + stride = 1 + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + conv1x1(self.inplanes, planes * block.expansion, stride), + norm_layer(planes * block.expansion), + ) + + layers = [] + layers.append( + block( + self.inplanes, + planes, + stride, + downsample, + self.groups, + self.base_width, + previous_dilation, + norm_layer, + ) + ) + self.inplanes = planes * block.expansion + for _ in range(1, blocks): + layers.append( + block( + self.inplanes, + planes, + groups=self.groups, + base_width=self.base_width, + dilation=self.dilation, + norm_layer=norm_layer, + ) + ) + + return nn.Sequential(*layers) + + def forward_backbone(self, x): + x = self.padding(x) + + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + if self.eval_mode: + return x + + x = self.avgpool(x) + x = torch.flatten(x, 1) + + return x + + def forward_head(self, x): + if self.projection_head is not None: + x = self.projection_head(x) + + if self.l2norm: + x = nn.functional.normalize(x, dim=1, p=2) + + if self.prototypes is not None: + return x, self.prototypes(x) + return x + + def forward(self, inputs): + if not isinstance(inputs, list): + inputs = [inputs] + idx_crops = torch.cumsum(torch.unique_consecutive( + torch.tensor([inp.shape[-1] for inp in inputs]), + return_counts=True, + )[1], 0) + start_idx = 0 + for end_idx in idx_crops: + _out = self.forward_backbone(torch.cat(inputs[start_idx: end_idx]).cuda(non_blocking=True)) + if start_idx == 0: + output = _out + else: + output = torch.cat((output, _out)) + start_idx = end_idx + return self.forward_head(output) + + +class MultiPrototypes(nn.Module): + def __init__(self, output_dim, nmb_prototypes): + super(MultiPrototypes, self).__init__() + self.nmb_heads = len(nmb_prototypes) + for i, k in enumerate(nmb_prototypes): + self.add_module("prototypes" + str(i), nn.Linear(output_dim, k, bias=False)) + + def forward(self, x): + out = [] + for i in range(self.nmb_heads): + out.append(getattr(self, "prototypes" + str(i))(x)) + return out + + +def resnet50(**kwargs): + return ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) + + +def resnet50w2(**kwargs): + return ResNet(Bottleneck, [3, 4, 6, 3], widen=2, **kwargs) + + +def resnet50w4(**kwargs): + return ResNet(Bottleneck, [3, 4, 6, 3], widen=4, **kwargs) + + +def resnet50w5(**kwargs): + return ResNet(Bottleneck, [3, 4, 6, 3], widen=5, **kwargs) + From d303c8e225434c2e4068ce3745bf3defc4e0ce7b Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 3 Apr 2021 21:18:17 -0700 Subject: [PATCH 024/197] Add script for moco loading --- scripts/breeds_example.ipynb | 140 +-------- scripts/moco_simclr_loading.ipynb | 476 +++++++++++++++++++++++++++++- 2 files changed, 471 insertions(+), 145 deletions(-) diff --git a/scripts/breeds_example.ipynb b/scripts/breeds_example.ipynb index 13d85cf..2edc92a 100644 --- a/scripts/breeds_example.ipynb +++ b/scripts/breeds_example.ipynb @@ -12,153 +12,31 @@ "module_path = os.path.abspath(os.path.join('..'))\n", "if module_path not in sys.path:\n", " sys.path.append(module_path)\n", - " " + " \n", + "from datasets import breeds" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "import torch\n", - "from torch.utils.data import Dataset\n", - "import numpy as np\n", - "from PIL import Image\n", - "from robustness.tools.breeds_helpers import make_living17, make_entity13, make_entity30, make_nonliving26\n", - "\n", - "BREEDS_SPLITS_TO_FUNC = {\n", - " 'entity13': make_entity13,\n", - " 'entity30': make_entity30,\n", - " 'living17': make_living17,\n", - " 'nonliving26': make_nonliving26,\n", - "}\n", - "\n", - "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", - "\n", - "SPLITS = ['train', 'val']\n", - "\n", - "MIN_NUM_TRAIN_PER_CLASS = 1000\n", - "\n", - "NUM_VAL_PER_CLASS = 50\n", - "\n", - "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", - "\n", - "def get_classes(dir):\n", - " if sys.version_info >= (3, 5):\n", - " # Faster and available in Python 3.5 and above\n", - " classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n", - " else:\n", - " classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]\n", - " classes.sort()\n", - " class_to_idx = {classes[i]: i for i in range(len(classes))}\n", - " return classes, class_to_idx\n", - "\n", - "def has_file_allowed_extension(filename, extensions):\n", - " filename_lower = filename.lower()\n", - " return any(filename_lower.endswith(ext) for ext in extensions)\n", - "\n", - "def get_image_paths_breeds_class(class_dir, breeds_class):\n", - " image_paths_breeds_class = []\n", - " for root, _, fnames in sorted(os.walk(class_dir)):\n", - " for fname in sorted(fnames):\n", - " if has_file_allowed_extension(fname, extensions=IMG_EXTENSIONS):\n", - " path = os.path.join(root, fname)\n", - " image_paths_breeds_class.append((path, breeds_class))\n", - " return image_paths_breeds_class\n", - "\n", - "def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split):\n", - " image_paths_and_class = []\n", - " for idx in range(len(subclasses)):\n", - " for subclass in subclasses[idx]:\n", - " subclass_image_paths_breeds_class = get_image_paths_breeds_class(\n", - " data_dir + '/' + idx_to_class_id[subclass] + '/', idx)\n", - " image_paths_and_class.extend(subclass_image_paths_breeds_class)\n", - " # print(data_dir + '/' + idx_to_class_id[subclass] + '/', len(subclass_image_names))\n", - " if split == 'train':\n", - " assert(len(subclass_image_paths_breeds_class) >= MIN_NUM_TRAIN_PER_CLASS)\n", - " else:\n", - " assert(len(subclass_image_paths_breeds_class) == NUM_VAL_PER_CLASS)\n", - " return image_paths_and_class\n", - "\n", - "class Breeds(Dataset):\n", - "\n", - " def __init__(self, root, breeds_name,\n", - " info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified',\n", - " source=True, split='train', transform=None):\n", - " super().__init__()\n", - " if breeds_name not in BREEDS_SPLITS_TO_FUNC.keys():\n", - " raise ValueError(f'breeds_name must be in {BREEDS_SPLITS_TO_FUNC.keys()} but was {breeds_name}')\n", - " if split not in SPLITS:\n", - " raise ValueError(f'split must be in {SPLITS} but was {split}')\n", - " self._breeds_name = breeds_name\n", - " self._source = source\n", - " self._split = split\n", - " self._transform = transform\n", - " self._info_dir = info_dir\n", - " self._data_dir = root + '/' + split\n", - " self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir)\n", - " breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name]\n", - " self._superclasses, self._subclass_split, self._label_map = breeds_func(self._info_dir, split=\"rand\")\n", - " if source:\n", - " self._subclasses = self._subclass_split[0]\n", - " else:\n", - " self._subclasses = self._subclass_split[1]\n", - " self._image_paths_by_class = get_image_paths_by_class(\n", - " self._data_dir, self._idx_to_class_id, self._subclasses, split)\n", - " \n", - " \n", - " # Get a mapping of class index to type by sorting.\n", - " # Get the names of the classes using robustness helper\n", - " # Get the source and target classes\n", - " # Get a list of files in each class\n", - " # 1300 examples per class in train, 50 in test, check this.\n", - " # Get item by class order.\n", - "# if corruption not in CORRUPTIONS:\n", - "# raise ValueError(f\"{corruption} is not a valid corruption.\")\n", - "# if not(0 <= severity <= 4):\n", - "# raise ValueError(f\"Severity was {severity} but must be 0, 1, 2, 3, 4.\")\n", - "# num_examples = 10000\n", - "# start_idx = num_examples * severity\n", - "# end_idx = num_examples * (severity + 1)\n", - "# self._xs = np.load(root + '/' + corruption + '.npy')[start_idx:end_idx]\n", - "# self._ys = torch.LongTensor(np.load(root + 'labels.npy'))[start_idx:end_idx]\n", - "# assert(len(self._xs) == len(self._ys) == num_examples)\n", - "# self._transform = transform\n", - "\n", - " def __getitem__(self, i):\n", - " path, y = self._image_paths_by_class[i]\n", - " x = Image.open(path)\n", - " if self._transform is not None:\n", - " x = self._transform(x)\n", - " return x, y\n", - "\n", - " def __len__(self) -> int:\n", - " return len(self._image_paths_by_class)\n", - "\n" + "dataset = breeds.Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity30', source=True, split='train')" ] }, { "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = Breeds(root='/u/scr/nlp/imagenet/', breeds_name='living17', source=True, split='train')" - ] - }, - { - "cell_type": "code", - "execution_count": 56, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "44200" + "154263" ] }, - "execution_count": 56, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -169,14 +47,14 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[869, 399, 578, 735, 652, 610, 501, 445, 655, 842], [87, 92, 91, 137, 14, 145, 129, 135, 85, 21], [45, 42, 51, 47, 52, 63, 55, 35, 58, 33], [119, 72, 300, 75, 73, 317, 302, 120, 309, 313], [284, 350, 292, 344, 174, 149, 375, 258, 283, 170], [443, 552, 824, 728, 433, 514, 679, 518, 570, 638], [484, 814, 554, 914, 404, 510, 628, 871, 812, 403], [890, 681, 430, 590, 872, 745, 422, 664, 522, 416], [894, 861, 553, 669, 564, 431, 493, 559, 556, 789], [881, 695, 626, 822, 704, 499, 845, 398, 778, 512], [483, 442, 562, 727, 920, 460, 500, 663, 743, 900], [803, 867, 751, 791, 880, 670, 705, 654, 609, 757], [937, 987, 950, 943, 940, 942, 941, 938, 945, 952]]\n" + "[[64, 56, 57, 52], [11, 10, 20, 19], [44, 45, 40, 46], [70, 73, 71, 75], [146, 140, 134, 127], [124, 123, 125, 118], [171, 359, 181, 253], [318, 308, 311, 325], [355, 353, 340, 345], [372, 379, 383, 367], [391, 0, 396, 392], [460, 716, 877, 421], [454, 483, 668, 467], [742, 707, 650, 508], [502, 630, 638, 770], [400, 411, 655, 568], [715, 584, 793, 452], [897, 651, 521, 882], [647, 499, 505, 813], [531, 409, 704, 635], [627, 779, 665, 511], [566, 641, 579, 881], [552, 678, 443, 906], [795, 543, 522, 752], [659, 899, 441, 898], [749, 507, 695, 783], [510, 625, 403, 871], [964, 935, 963, 933], [939, 943, 942, 944], [949, 953, 955, 948]]\n" ] } ], diff --git a/scripts/moco_simclr_loading.ipynb b/scripts/moco_simclr_loading.ipynb index 02f60b2..ebb2ed0 100644 --- a/scripts/moco_simclr_loading.ipynb +++ b/scripts/moco_simclr_loading.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 133, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 4, + "execution_count": 133, "metadata": {}, "output_type": "execute_result" } @@ -25,6 +25,7 @@ " sys.path.append(module_path)\n", " \n", "from models import imnet_resnet\n", + "from torch import nn\n", "\n", "import importlib\n", "importlib.reload(imnet_resnet)\n" @@ -32,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -41,24 +42,471 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "metadata": {}, "outputs": [ { - "ename": "ModuleAttributeError", - "evalue": "'ResNet50' object has no attribute 'fc'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/juice/scr/ananya/cifar_experiments/env/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 770\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 771\u001b[0m raise ModuleAttributeError(\"'{}' object has no attribute '{}'\".format(\n\u001b[0;32m--> 772\u001b[0;31m type(self).__name__, name))\n\u001b[0m\u001b[1;32m 773\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 774\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Module'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mModuleAttributeError\u001b[0m: 'ResNet50' object has no attribute 'fc'" + "data": { + "text/plain": [ + "Sequential(\n", + " (resnet): ResNet(\n", + " (padding): ConstantPad2d(padding=(1, 1, 1, 1), value=0.0)\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " )\n", + " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", + ")" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model._model" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [], + "source": [ + "swav_path = '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar'\n", + "model = imnet_resnet.ResNet50(pretrained=True, pretrain_style='swav', checkpoint_path=swav_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ResNet50(\n", + " (_model): Sequential(\n", + " (resnet): ResNet(\n", + " (padding): ConstantPad2d(padding=(1, 1, 1, 1), value=0.0)\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " )\n", + " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import breeds\n", + "entity30 = breeds.Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity30')" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 224, 224])\n" ] } ], "source": [ - "model.fc" + "import torchvision\n", + "import torch\n", + "import torchvision.transforms as transforms\n", + "trans = transforms.Compose(\n", + "[\n", + " transforms.Resize(size=[224,224]),\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "x = torch.unsqueeze(trans(entity30[0][0]), axis=0)\n", + "x.cuda()\n", + "print(x.shape)\n", + "model.eval()\n", + "model.cuda()\n", + "z = model._model(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1000])" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z.shape" ] }, { From 1e2151f174ac7093eacf42a3065ce13ca727cbcc Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 3 Apr 2021 21:18:40 -0700 Subject: [PATCH 025/197] Add uncertainty ensembling script. --- ...Combining models using uncertainties.ipynb | 1277 +++++++++++++++++ 1 file changed, 1277 insertions(+) create mode 100644 scripts/Combining models using uncertainties.ipynb diff --git a/scripts/Combining models using uncertainties.ipynb b/scripts/Combining models using uncertainties.ipynb new file mode 100644 index 0000000..ba41646 --- /dev/null +++ b/scripts/Combining models using uncertainties.ipynb @@ -0,0 +1,1277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [], + "source": [ + "# So we can load files from other sub-directories, e.g. datasets.\n", + "import os\n", + "import sys\n", + "\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "\n", + "import torch\n", + "import utils.utils as utils\n", + "import json\n", + "import numpy as np\n", + "from scipy.special import softmax\n", + "\n", + "import calibration as cal\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda is available: True\n" + ] + } + ], + "source": [ + "print(f'cuda is available: {torch.cuda.is_available()}')\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [], + "source": [ + "def load_model(config_path, checkpoint_path):\n", + " with open(config_path) as f:\n", + " config = json.load(f)\n", + " net = utils.initialize(config['model'])\n", + " if USE_CUDA:\n", + " net = net.cuda()\n", + " net.new_last_layer(config['num_classes'])\n", + " utils.load_ckp(checkpoint_path, net)\n", + " return net\n", + "\n", + "# Load datasets.\n", + "def load_test_dataset(config, idx):\n", + " test_config = config['test_datasets'][idx]\n", + " print(test_config['name'])\n", + " if 'transforms' not in test_config:\n", + " test_config['transforms'] = config['default_test_transforms']\n", + " test_data = utils.init_dataset(test_config)\n", + " test_loader = torch.utils.data.DataLoader(\n", + " test_data, batch_size=batch_size,\n", + " shuffle=False, num_workers=num_workers)\n", + " return test_data, test_loader\n", + "\n", + "def get_outputs_labels(net, loader):\n", + " net.cuda()\n", + " net.eval()\n", + " outputs_list, labels_list = [], []\n", + " with torch.no_grad():\n", + " for data in loader:\n", + " images, labels = data\n", + " images, labels = images.cuda(), labels.cuda()\n", + " outputs = net(images)\n", + " outputs_list.append(outputs.detach().cpu().numpy())\n", + " labels_list.append(labels.detach().cpu().numpy())\n", + " outputs = np.concatenate(outputs_list)\n", + " labels = np.concatenate(labels_list)\n", + " return outputs, labels\n", + "\n", + "def get_adjusted_probs(probs, labels):\n", + " calibrators = [cal.PlattTopCalibrator(0, num_bins=10) for _ in range(M)]\n", + " adjusted_probs = make_none_list(M, L)\n", + " for m in range(M):\n", + " calibrators[m].train_calibration(probs[m][0], labels[m][0])\n", + " for m in range(M):\n", + " for l in range(L):\n", + " adjusted_probs[m][l] = calibrators[m].calibrate(probs[m][l])\n", + " return adjusted_probs\n", + "\n", + "def get_acc(preds, labels):\n", + " return np.mean(preds == labels)\n", + "\n", + "def make_none_list(rs, cs):\n", + " return [[None] * cs for _ in range(rs)]\n", + "\n", + "def combine_confs_preds(confs, preds):\n", + " confs, preds = np.array(confs), np.array(preds)\n", + " model_choices = np.argmax(confs, axis=0)\n", + " return preds[model_choices, np.arange(confs.shape[1])]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [], + "source": [ + "USE_CUDA = True\n", + "cuda = torch.device('cuda') \n", + "batch_size, num_workers = 32, 16\n" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "metadata": {}, + "outputs": [], + "source": [ + "def combined_calibration_accs(\n", + " config_paths, checkpoint_paths, model_names, loader_names, loader_indices):\n", + " M, L = len(model_names), len(loader_names)\n", + " models = []\n", + " for m in range(M):\n", + " models.append(load_model(config_paths[m], checkpoint_paths[m]))\n", + "\n", + " with open(config_paths[0]) as f:\n", + " config = json.load(f)\n", + " loaders = []\n", + " for l in range(L):\n", + " _, loader = load_test_dataset(config, idx=loader_indices[l])\n", + " loaders.append(loader)\n", + "\n", + " logits, labels = make_none_list(M, L), make_none_list(M, L)\n", + " probs = make_none_list(M, L)\n", + " confidences, preds = make_none_list(M, L), make_none_list(M, L)\n", + " for m in range(M):\n", + " for l in range(L):\n", + " logits[m][l], labels[m][l] = get_outputs_labels(models[m], loaders[l])\n", + " probs[m][l] = softmax(logits[m][l], axis=-1)\n", + " confidences[m][l] = np.max(probs[m][l], axis=1)\n", + " preds[m][l] = np.argmax(probs[m][l], axis=-1)\n", + " print(f'Ave {model_names[m]} confidence for {loader_names[l]}: {np.mean(confidences[m][l])}')\n", + "\n", + " # Check that the ground truth labels agree at least for the first two models.\n", + " # Note these are just ground truth labels, not predictions. Just a sanity check.\n", + " # E.g. if the images were shuffled and not aligned between the two models this will fail.\n", + " for l in range(L):\n", + " assert (np.sum(labels[0][l] != labels[1][l]) == 0)\n", + "\n", + " adjusted_probs = get_adjusted_probs(probs, labels)\n", + " combined_preds = [None] * L\n", + " for l in range(L):\n", + " cur_loader_adjusted_probs = [adjusted_probs[m][l] for m in range(M)]\n", + " cur_loader_preds = [preds[m][l] for m in range(M)]\n", + " combined_preds[l] = combine_confs_preds(cur_loader_adjusted_probs, cur_loader_preds)\n", + "\n", + " stats = make_none_list(M+1, L)\n", + " for l in range(L):\n", + " print(f'Dataset {loader_names[l]}: ')\n", + " for m in range(M):\n", + " stats[m][l] = get_acc(preds[m][l], labels[0][l])\n", + " print(f'Model {model_names[m]}: {stats[m][l]}')\n", + " stats[M][l] = get_acc(combined_preds[l], labels[0][l])\n", + " print('Combined ', stats[M][l])\n", + " \n", + " return stats, combined_preds, preds, confidences, probs, adjusted_probs, labels\n" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cifar10-test\n", + "imnet-n-cifar\n", + "Ave lin_model confidence for cifar: 0.926066517829895\n", + "Ave lin_model confidence for imnc: 0.9317657947540283\n", + "Ave ft_model confidence for cifar: 0.988318145275116\n", + "Ave ft_model confidence for imnc: 0.9081357717514038\n", + "Dataset cifar: \n", + "Model lin_model: 0.9052\n", + "Model ft_model: 0.966\n", + "Combined 0.9646\n", + "Dataset imnc: \n", + "Model lin_model: 0.752\n", + "Model ft_model: 0.62\n", + "Combined 0.758\n" + ] + }, + { + "data": { + "text/plain": [ + "([[0.9052, 0.752], [0.966, 0.62], [0.9646, 0.758]],\n", + " [array([3, 8, 8, ..., 5, 1, 7]),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 9, 1, 9, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 3, 4,\n", + " 2, 3, 2, 3, 3, 3, 4, 2, 3, 6, 3, 3, 3, 3, 4, 3, 2, 3, 5, 4, 4, 3,\n", + " 3, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 2, 4, 3, 2, 3, 3, 3, 6, 3, 3, 2,\n", + " 2, 3, 3, 4, 4, 2, 4, 5, 4, 3, 2, 2, 3, 2, 4, 2, 2, 4, 2, 4, 3, 4,\n", + " 4, 4, 4, 2, 4, 2, 0, 2, 4, 2, 2, 4, 2, 4, 4, 4, 2, 4, 4, 4, 4, 2,\n", + " 2, 2, 4, 0, 4, 2, 4, 2, 4, 5, 5, 2, 3, 5, 5, 5, 3, 5, 4, 5, 3, 5,\n", + " 4, 5, 3, 5, 3, 2, 5, 3, 4, 5, 4, 3, 3, 5, 5, 5, 4, 5, 5, 4, 5, 5,\n", + " 3, 2, 4, 4, 5, 2, 2, 5, 2, 5, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 6, 2, 2, 6, 6, 6, 6, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 2, 7, 7, 8, 0, 8, 1, 8, 8, 8, 3, 2, 8, 8, 8, 8, 0, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 0, 2, 8, 8, 8,\n", + " 0, 8, 8, 2, 8, 8, 8, 8, 8, 8, 1, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9,\n", + " 1, 1, 9, 1, 9, 9, 1, 1, 0, 1, 9, 1, 0, 9, 1, 1, 9, 9, 1, 0, 9, 1,\n", + " 9, 9, 9, 1, 1, 1, 9, 1, 1, 9, 1, 1, 9, 9, 1, 9])],\n", + " [[array([3, 8, 8, ..., 5, 1, 7]),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 9, 1, 9, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 9,\n", + " 1, 9, 9, 1, 2, 1, 9, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 4, 7, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 3, 4,\n", + " 2, 4, 2, 3, 3, 2, 4, 2, 2, 6, 6, 3, 2, 3, 3, 3, 2, 3, 2, 2, 4, 2,\n", + " 3, 3, 2, 3, 3, 3, 3, 2, 2, 2, 2, 6, 4, 3, 2, 3, 3, 3, 6, 3, 2, 2,\n", + " 2, 3, 4, 4, 4, 2, 4, 2, 4, 4, 2, 2, 4, 2, 4, 2, 2, 4, 2, 4, 4, 2,\n", + " 4, 4, 4, 2, 4, 2, 4, 2, 4, 2, 2, 2, 2, 4, 4, 4, 2, 4, 4, 4, 4, 2,\n", + " 2, 2, 4, 4, 2, 2, 4, 2, 4, 5, 5, 2, 2, 5, 5, 5, 2, 5, 4, 5, 5, 5,\n", + " 4, 6, 2, 5, 5, 2, 4, 5, 2, 5, 4, 2, 5, 5, 5, 5, 4, 5, 5, 4, 5, 5,\n", + " 5, 4, 4, 4, 5, 2, 2, 5, 2, 5, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 6, 6, 2, 6, 6, 6, 6, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 2, 7, 7, 8, 2, 3, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 8, 2, 8, 8, 8,\n", + " 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 1, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9,\n", + " 1, 1, 9, 1, 9, 9, 1, 1, 9, 1, 9, 1, 9, 9, 1, 1, 9, 9, 1, 2, 9, 1,\n", + " 9, 9, 9, 1, 1, 1, 9, 1, 1, 9, 1, 1, 9, 9, 1, 9])],\n", + " [array([3, 8, 8, ..., 5, 1, 7]),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,\n", + " 0, 3, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 2, 2, 2, 5,\n", + " 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 3, 3, 2, 3, 4,\n", + " 2, 3, 0, 3, 3, 3, 4, 2, 3, 6, 3, 3, 3, 3, 4, 3, 6, 3, 5, 4, 6, 3,\n", + " 3, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 2, 3, 3, 4, 3, 3, 3, 6, 3, 3, 3,\n", + " 2, 3, 3, 4, 4, 3, 4, 5, 2, 3, 4, 4, 3, 4, 3, 3, 3, 4, 2, 4, 3, 4,\n", + " 4, 4, 4, 2, 4, 3, 0, 2, 4, 6, 3, 4, 3, 6, 4, 4, 2, 4, 4, 3, 3, 4,\n", + " 4, 4, 4, 0, 4, 4, 4, 3, 4, 5, 5, 5, 3, 5, 7, 5, 3, 5, 4, 5, 3, 2,\n", + " 5, 5, 3, 5, 3, 4, 5, 3, 4, 5, 4, 3, 3, 5, 3, 3, 3, 5, 5, 4, 2, 5,\n", + " 3, 2, 6, 4, 5, 3, 2, 3, 3, 5, 4, 3, 2, 5, 6, 1, 6, 6, 6, 6, 3, 6,\n", + " 1, 6, 2, 6, 6, 3, 2, 2, 6, 6, 2, 2, 6, 6, 6, 6, 6, 2, 3, 6, 6, 6,\n", + " 0, 6, 8, 2, 6, 6, 3, 6, 3, 6, 6, 6, 0, 2, 2, 2, 6, 6, 6, 6, 7, 7,\n", + " 4, 7, 7, 7, 7, 4, 7, 7, 7, 2, 4, 7, 7, 7, 4, 4, 7, 7, 7, 7, 7, 3,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 4, 7, 7, 7, 8, 0, 8, 1, 3, 2, 8, 3, 7, 0, 0, 8, 3, 0, 8, 8, 0, 8,\n", + " 8, 0, 8, 0, 3, 8, 0, 0, 8, 8, 3, 0, 8, 2, 0, 2, 8, 0, 0, 8, 2, 0,\n", + " 0, 2, 8, 0, 0, 8, 0, 2, 3, 8, 1, 1, 1, 1, 1, 1, 3, 1, 9, 9, 2, 9,\n", + " 1, 1, 9, 1, 9, 9, 1, 1, 0, 1, 8, 1, 0, 4, 1, 1, 9, 9, 1, 0, 1, 1,\n", + " 9, 9, 3, 1, 1, 1, 0, 3, 1, 1, 1, 1, 0, 9, 1, 9])]],\n", + " [[array([0.9968559 , 0.99574995, 0.9967172 , ..., 0.9682235 , 0.99759775,\n", + " 0.9999466 ], dtype=float32),\n", + " array([0.9999818 , 0.9998436 , 1. , 1. , 0.99993795,\n", + " 0.999897 , 0.9999895 , 1. , 0.99999815, 1. ,\n", + " 0.99998474, 0.9973324 , 1. , 0.99847156, 0.9998693 ,\n", + " 1. , 1. , 0.9999781 , 0.9253658 , 1. ,\n", + " 0.997378 , 0.9999934 , 1. , 1. , 0.99997616,\n", + " 0.99994564, 0.9999866 , 0.9999895 , 1. , 0.9999809 ,\n", + " 0.99999905, 0.9999142 , 0.99999136, 0.99997705, 0.99999523,\n", + " 1. , 0.9999791 , 0.99999815, 1. , 0.99983495,\n", + " 1. , 1. , 1. , 0.9998608 , 0.9999923 ,\n", + " 1. , 0.99999815, 0.99991703, 0.9999934 , 1. ,\n", + " 0.9661232 , 0.8574786 , 0.99999815, 0.96374446, 0.9981563 ,\n", + " 0.995597 , 1. , 0.74335945, 1. , 1. ,\n", + " 0.99998474, 0.99684733, 0.7326287 , 0.99999136, 0.9870601 ,\n", + " 0.8911717 , 0.9977728 , 0.9946329 , 0.8023502 , 0.9982049 ,\n", + " 0.87267065, 0.9994337 , 0.71720487, 0.9999971 , 0.51847017,\n", + " 0.9994919 , 0.9999962 , 0.49875155, 1. , 0.999326 ,\n", + " 0.9999895 , 1. , 0.99289286, 0.8729615 , 0.9992897 ,\n", + " 0.99994856, 0.8530985 , 0.99993795, 0.963217 , 0.77419627,\n", + " 0.9999923 , 0.9923977 , 0.99950707, 1. , 0.5199624 ,\n", + " 0.7260851 , 0.9937207 , 1. , 0.99964625, 0.99999815,\n", + " 0.9999943 , 0.9999962 , 0.99995226, 1. , 0.99999523,\n", + " 1. , 0.9998856 , 0.99972534, 0.99998474, 0.98770887,\n", + " 0.9996053 , 0.9999084 , 1. , 0.99999815, 0.9999962 ,\n", + " 1. , 0.9999923 , 1. , 0.99981695, 1. ,\n", + " 1. , 0.9999142 , 0.99999815, 1. , 0.99995613,\n", + " 0.99993706, 1. , 0.99998474, 1. , 1. ,\n", + " 0.99775946, 1. , 0.99981016, 0.9999962 , 0.99903536,\n", + " 0.99999046, 0.99999136, 0.9998931 , 0.9999886 , 0.99830383,\n", + " 0.9999666 , 0.9838225 , 1. , 0.9999962 , 1. ,\n", + " 0.99970347, 0.9999543 , 0.9998217 , 0.9973856 , 0.99995995,\n", + " 0.97000164, 0.6252936 , 0.9539478 , 0.8521118 , 0.9640487 ,\n", + " 0.7308554 , 0.9608555 , 0.9354276 , 0.98531264, 0.5734163 ,\n", + " 0.49572754, 0.9907693 , 0.56013983, 0.5092617 , 0.60572517,\n", + " 0.9999791 , 0.818998 , 0.9999829 , 0.61399174, 0.9999923 ,\n", + " 0.60608864, 0.9733868 , 0.5500202 , 0.78839636, 0.83388305,\n", + " 0.68745905, 0.99997425, 0.9977651 , 0.99323845, 0.99996567,\n", + " 0.9999056 , 0.9995795 , 0.81261134, 0.9268761 , 0.69703877,\n", + " 0.42460987, 0.6746036 , 0.5340869 , 0.9790566 , 0.9999923 ,\n", + " 0.9181435 , 0.9999409 , 0.8667585 , 0.99999046, 0.7797498 ,\n", + " 0.46442312, 0.5956848 , 0.98930687, 0.8455891 , 0.99825436,\n", + " 0.46247002, 0.9615008 , 0.9917203 , 0.96904933, 0.74621195,\n", + " 0.5138647 , 0.8021574 , 0.8934881 , 0.88725126, 0.8243233 ,\n", + " 0.68316644, 0.89995843, 0.9797422 , 0.99435693, 0.7998527 ,\n", + " 0.99423176, 0.859496 , 0.6763293 , 0.8231818 , 0.84537864,\n", + " 0.78631234, 0.94868624, 0.96586066, 0.9142662 , 0.73635656,\n", + " 0.8382209 , 0.7007466 , 0.6688185 , 0.80185074, 0.9908591 ,\n", + " 0.9980478 , 0.77275187, 0.96576667, 0.628651 , 0.9495851 ,\n", + " 0.95293444, 0.75912774, 0.9952705 , 0.79737216, 0.98654157,\n", + " 0.84316367, 0.77287644, 0.99511296, 0.98882014, 0.90712494,\n", + " 0.8981261 , 0.6081635 , 0.9922728 , 0.99265325, 0.97491974,\n", + " 0.9726045 , 0.8311317 , 0.99023277, 0.7940537 , 0.9111097 ,\n", + " 0.90015835, 0.9697029 , 0.94525176, 0.50710213, 0.9810015 ,\n", + " 0.90838635, 0.9855532 , 0.7851414 , 0.9943929 , 0.93938625,\n", + " 0.69014347, 0.85163176, 0.99885917, 0.5221127 , 0.9858559 ,\n", + " 0.5043533 , 0.8447532 , 0.6709906 , 0.9650688 , 0.5566311 ,\n", + " 0.4658366 , 0.98788226, 0.97306246, 0.8794232 , 0.9866206 ,\n", + " 0.947359 , 0.9987009 , 0.9998856 , 0.9986382 , 0.9280879 ,\n", + " 0.99435693, 0.7019218 , 0.9655116 , 0.6258524 , 0.9919294 ,\n", + " 0.81720585, 0.8785866 , 0.46574664, 0.9291497 , 0.7617534 ,\n", + " 0.9957319 , 0.745597 , 0.9928521 , 0.9909726 , 0.9315044 ,\n", + " 1. , 0.9999943 , 1. , 0.9999943 , 1. ,\n", + " 1. , 0.99613553, 0.99999815, 0.9985247 , 0.99999815,\n", + " 0.9999466 , 1. , 1. , 0.9999714 , 0.9986248 ,\n", + " 0.9844373 , 0.9999886 , 1. , 1. , 0.99999815,\n", + " 1. , 1. , 0.99400896, 1. , 1. ,\n", + " 0.99961287, 0.99926215, 1. , 1. , 1. ,\n", + " 0.9999714 , 1. , 0.99969393, 1. , 1. ,\n", + " 1. , 0.9373788 , 1. , 0.9904312 , 1. ,\n", + " 1. , 0.9872823 , 1. , 0.9999886 , 0.5154647 ,\n", + " 0.98060584, 0.99999815, 0.99584305, 0.99999815, 0.99999815,\n", + " 0.9944868 , 1. , 0.9994947 , 0.99999046, 0.9999427 ,\n", + " 0.9999962 , 1. , 0.95661396, 0.9999943 , 0.99860764,\n", + " 0.9999161 , 0.9995624 , 0.8513218 , 0.9985153 , 0.99987406,\n", + " 0.9999886 , 0.9941625 , 0.55360186, 1. , 0.9999923 ,\n", + " 0.9999781 , 1. , 0.999897 , 0.99822575, 1. ,\n", + " 0.99999523, 1. , 0.9999962 , 0.99999815, 0.99993134,\n", + " 0.99994856, 0.9999475 , 1. , 0.99577844, 0.99995226,\n", + " 0.9999399 , 0.9998083 , 0.99994564, 0.9999886 , 0.99932694,\n", + " 0.99999815, 0.99650425, 0.9999791 , 0.9998722 , 0.9399391 ,\n", + " 0.99966246, 0.99996185, 0.7389658 , 0.9999409 , 1. ,\n", + " 0.9999752 , 0.70991 , 0.6627074 , 0.49543497, 0.9978146 ,\n", + " 0.9999723 , 0.9999609 , 0.7468217 , 0.8701435 , 0.97020334,\n", + " 0.9959997 , 0.99985605, 0.99988943, 0.9373593 , 0.97390956,\n", + " 0.99999815, 0.999958 , 0.9999934 , 0.99914306, 0.9963285 ,\n", + " 0.99848294, 0.99935555, 0.91751987, 0.999466 , 0.99989605,\n", + " 0.9995547 , 1. , 0.7897158 , 0.86203134, 0.83780205,\n", + " 0.9994242 , 0.9927991 , 0.99997336, 0.99236363, 0.987045 ,\n", + " 0.652998 , 0.9363363 , 0.9998999 , 0.99857235, 0.99682826,\n", + " 0.91242874, 0.82628983, 0.999958 , 0.9142911 , 0.94633955,\n", + " 0.66393834, 0.9995805 , 0.99987125, 0.987304 , 0.99976164,\n", + " 0.9999284 , 0.88468945, 0.99999815, 0.82860464, 0.88762456,\n", + " 0.9998369 , 0.9740452 , 0.985121 , 0.99999136, 0.9960386 ,\n", + " 0.9999323 , 0.9982553 , 0.9993317 , 0.99824774, 0.99027437,\n", + " 0.99999815, 0.999957 , 0.8619733 , 0.99999815, 0.99995613,\n", + " 0.54026765, 0.97314924, 0.99679035, 0.99976444, 0.9948776 ,\n", + " 0.99985695, 0.99926305, 0.9578765 , 0.98974514, 0.95945805,\n", + " 0.99344593, 0.48623484, 0.98946446, 0.99991226, 0.9925085 ,\n", + " 0.9578856 , 0.9730879 , 1. , 0.99351704, 0.9999923 ,\n", + " 0.99665916, 0.97881854, 1. , 0.9994689 , 0.8817389 ,\n", + " 0.9984277 , 0.99542433, 0.99999815, 1. , 0.9981906 ],\n", + " dtype=float32)],\n", + " [array([1. , 1. , 0.99999815, ..., 0.9999829 , 1. ,\n", + " 1. ], dtype=float32),\n", + " array([1. , 0.9999962 , 0.999774 , 1. , 1. ,\n", + " 0.8662148 , 0.99996567, 1. , 1. , 1. ,\n", + " 0.98833644, 0.99993426, 1. , 1. , 1. ,\n", + " 1. , 1. , 1. , 0.99992657, 0.9999886 ,\n", + " 0.99993515, 0.99995226, 1. , 1. , 0.9867849 ,\n", + " 0.9996444 , 0.9999809 , 1. , 1. , 0.99972916,\n", + " 1. , 0.9999962 , 1. , 1. , 1. ,\n", + " 1. , 0.40381017, 1. , 0.99999815, 1. ,\n", + " 1. , 1. , 0.9999866 , 0.99674284, 0.9987 ,\n", + " 1. , 0.9991268 , 1. , 1. , 1. ,\n", + " 0.5585054 , 0.8932355 , 1. , 0.99102443, 0.6324849 ,\n", + " 0.7086093 , 1. , 0.99914396, 0.99524397, 1. ,\n", + " 0.9030482 , 0.99977785, 0.9889568 , 1. , 0.98109883,\n", + " 0.9905237 , 0.99937266, 0.99999815, 0.99942607, 0.9999781 ,\n", + " 0.6928853 , 1. , 0.9985438 , 0.99999523, 0.9893577 ,\n", + " 1. , 1. , 0.95078844, 0.99999523, 1. ,\n", + " 0.99999815, 1. , 1. , 0.9985572 , 0.99999905,\n", + " 1. , 0.92213666, 0.99999815, 0.9174468 , 0.56621933,\n", + " 1. , 0.9998636 , 0.98947483, 0.9999866 , 0.9975331 ,\n", + " 0.98526 , 1. , 0.9999934 , 0.9999857 , 0.9999934 ,\n", + " 0.9869726 , 0.88925683, 0.9844026 , 1. , 0.99987316,\n", + " 0.93984586, 0.99996567, 0.9999962 , 0.9973846 , 0.66004694,\n", + " 0.95643884, 0.7475895 , 0.9999695 , 1. , 0.9973285 ,\n", + " 0.99999815, 1. , 0.9645425 , 0.99999815, 0.99993706,\n", + " 0.9836714 , 1. , 1. , 0.96774805, 0.99390465,\n", + " 0.9980174 , 1. , 1. , 0.9850501 , 0.9875695 ,\n", + " 0.99397284, 0.9999962 , 0.99999046, 0.9999962 , 1. ,\n", + " 0.6457206 , 0.8791679 , 0.99821824, 1. , 0.99932694,\n", + " 0.6909436 , 0.7176482 , 1. , 1. , 0.99999815,\n", + " 0.9009657 , 0.99152267, 1. , 0.9314316 , 0.8774369 ,\n", + " 0.9996587 , 0.75645024, 0.65849334, 0.5996742 , 0.9887919 ,\n", + " 0.8991562 , 0.6362825 , 0.9999962 , 0.99999815, 0.9073153 ,\n", + " 0.8056434 , 0.99846387, 0.99999046, 0.72738016, 0.99998754,\n", + " 1. , 0.9998931 , 1. , 0.9988219 , 1. ,\n", + " 0.38097766, 0.9999666 , 0.9999791 , 0.97748643, 0.9072894 ,\n", + " 0.8540481 , 1. , 0.97256285, 0.73889464, 0.9999886 ,\n", + " 1. , 1. , 0.5565873 , 0.44403493, 0.9934375 ,\n", + " 0.9814629 , 0.8974968 , 0.8345852 , 0.98116434, 1. ,\n", + " 0.59990704, 0.9986353 , 0.8027539 , 1. , 0.5160671 ,\n", + " 0.851339 , 0.7643119 , 0.9948217 , 0.57323396, 0.99994475,\n", + " 0.82698864, 0.9641912 , 0.9999962 , 0.65607685, 0.9075975 ,\n", + " 0.6038014 , 0.86008054, 0.99485964, 0.7227869 , 0.95677954,\n", + " 0.9894786 , 0.41129076, 0.8074691 , 0.87003225, 0.8870004 ,\n", + " 0.9971886 , 0.7308336 , 0.9967751 , 0.99745786, 0.99757963,\n", + " 0.55131894, 0.999651 , 0.99919736, 0.99547076, 0.99185276,\n", + " 0.9477277 , 0.99781847, 0.5032067 , 0.9985648 , 0.6348027 ,\n", + " 0.841563 , 0.9615594 , 0.9792424 , 0.55340576, 0.6996568 ,\n", + " 0.9986877 , 0.99768436, 0.9998617 , 0.923821 , 0.6165097 ,\n", + " 0.9552911 , 0.8491083 , 0.72742486, 0.9989696 , 0.999958 ,\n", + " 0.99217534, 0.9934394 , 0.89679056, 0.9960121 , 0.60556835,\n", + " 0.9981411 , 0.9945741 , 1. , 0.5583377 , 0.99997336,\n", + " 0.99997616, 0.8654617 , 0.99997616, 0.99111044, 0.9999409 ,\n", + " 0.8491026 , 0.9996739 , 0.9981383 , 0.9465716 , 0.99096674,\n", + " 0.98501205, 0.99714696, 0.6924545 , 0.99988085, 0.9984144 ,\n", + " 0.9999027 , 0.99814403, 0.949816 , 0.6425254 , 0.99999815,\n", + " 0.99948233, 0.9999504 , 0.99737895, 0.848252 , 0.9990591 ,\n", + " 0.9626412 , 0.9994937 , 0.99834013, 0.99914783, 0.6100668 ,\n", + " 0.99985033, 0.9999752 , 0.9999781 , 0.7380196 , 0.9998941 ,\n", + " 0.79888874, 0.5906277 , 0.74517363, 0.83994853, 0.90791863,\n", + " 0.8226277 , 0.9983286 , 0.5214824 , 0.9914451 , 0.9892058 ,\n", + " 1. , 0.36203027, 0.999957 , 0.8148898 , 0.99999523,\n", + " 1. , 0.7896277 , 0.99323004, 0.85746396, 0.5193974 ,\n", + " 0.52349174, 0.99826485, 0.9193676 , 0.9050114 , 0.91077614,\n", + " 0.8538596 , 1. , 0.8278448 , 0.78192306, 0.5895883 ,\n", + " 1. , 1. , 0.9999142 , 0.8823353 , 0.999774 ,\n", + " 0.5596422 , 0.47114438, 0.99999815, 0.799791 , 0.7299109 ,\n", + " 0.63780034, 0.9939198 , 0.9234413 , 0.942677 , 0.99998754,\n", + " 0.9999962 , 0.33667505, 0.9993794 , 0.9995547 , 0.8239107 ,\n", + " 0.48382857, 0.71704865, 0.95438135, 0.766022 , 0.9653013 ,\n", + " 0.9937748 , 0.98916346, 0.99365926, 0.995354 , 0.99999905,\n", + " 1. , 1. , 0.9994174 , 0.99999136, 0.96190155,\n", + " 1. , 1. , 0.7977913 , 1. , 0.9999714 ,\n", + " 0.9999923 , 0.9996186 , 0.999304 , 0.99997336, 0.99995136,\n", + " 1. , 0.48410597, 0.56067777, 1. , 1. ,\n", + " 0.9999962 , 1. , 1. , 0.9996196 , 1. ,\n", + " 0.98746777, 1. , 0.9992926 , 1. , 0.9998017 ,\n", + " 0.9888022 , 0.9998779 , 1. , 0.99997044, 0.99999905,\n", + " 0.99997705, 0.7959278 , 0.7656601 , 0.99845815, 0.9964139 ,\n", + " 1. , 0.99996275, 1. , 0.9999866 , 0.77930826,\n", + " 1. , 0.7883621 , 0.7238762 , 0.99999046, 1. ,\n", + " 1. , 0.99593806, 0.9360881 , 0.7273541 , 0.45661375,\n", + " 0.69601184, 0.99999815, 0.9441526 , 0.71277785, 0.7112257 ,\n", + " 0.9925851 , 0.67852914, 0.63297486, 0.9994623 , 0.8102978 ,\n", + " 0.819314 , 0.9542841 , 0.9999962 , 0.9450647 , 0.37058243,\n", + " 0.99997616, 0.99440145, 0.90818405, 0.99965197, 0.9848468 ,\n", + " 0.87614965, 0.9159938 , 0.49991894, 0.74299836, 0.89273214,\n", + " 0.99578416, 0.4727627 , 0.84766 , 0.6975222 , 0.66748255,\n", + " 0.98520833, 0.992268 , 0.9672765 , 0.5521034 , 0.98542917,\n", + " 0.9993317 , 0.79276246, 0.9923211 , 0.6436066 , 0.79797614,\n", + " 0.9461397 , 0.36218894, 0.61479086, 0.97923774, 0.9987924 ,\n", + " 0.9999781 , 0.57936305, 0.9797029 , 0.99999905, 0.89546454,\n", + " 0.9939861 , 0.40192848, 0.65937245, 0.63267046, 0.9999533 ,\n", + " 0.51741564, 0.82064766, 0.9901421 , 0.99998385, 0.9641967 ,\n", + " 1. , 0.9964558 , 0.9970955 , 1. , 0.99785084,\n", + " 0.9998474 , 0.9999962 , 0.9485488 , 0.99999815, 1. ,\n", + " 0.39295483, 1. , 0.9999179 , 0.9986438 , 0.9880491 ,\n", + " 0.9999829 , 0.8127365 , 0.9973446 , 0.9997101 , 0.69363433,\n", + " 0.9966601 , 0.44464263, 1. , 1. , 0.99999523,\n", + " 0.99333847, 0.9709609 , 0.99942034, 0.9851322 , 0.99999136,\n", + " 0.9999791 , 0.5707781 , 0.7837074 , 0.99999815, 0.9995853 ],\n", + " dtype=float32)]],\n", + " [[array([[1.86022908e-06, 9.90709214e-06, 1.82218180e-04, ...,\n", + " 9.71081226e-06, 2.76929177e-06, 2.87277817e-06],\n", + " [1.66914787e-03, 2.58069206e-03, 1.44739047e-08, ...,\n", + " 4.19809992e-10, 9.95749950e-01, 1.74955048e-07],\n", + " [1.00011437e-03, 2.14464730e-03, 6.00225363e-08, ...,\n", + " 5.73124765e-08, 9.96717215e-01, 1.37350187e-04],\n", + " ...,\n", + " [2.11103298e-07, 1.57210536e-07, 1.16644995e-02, ...,\n", + " 6.87153544e-03, 9.06978642e-07, 1.05734756e-07],\n", + " [9.97609575e-04, 9.97597754e-01, 2.84363137e-04, ...,\n", + " 4.04752427e-06, 1.93417742e-04, 9.03860258e-04],\n", + " [3.01652703e-09, 4.08993638e-11, 1.60114223e-06, ...,\n", + " 9.99946594e-01, 1.65093043e-11, 1.02652375e-08]], dtype=float32),\n", + " array([[9.9998182e-01, 1.9361078e-06, 1.4101323e-05, ..., 5.4100497e-09,\n", + " 1.1466470e-07, 2.0715677e-06],\n", + " [9.9984360e-01, 9.9112174e-07, 1.5522800e-04, ..., 1.7016109e-09,\n", + " 8.8897734e-09, 1.2953745e-09],\n", + " [1.0000000e+00, 8.2984366e-09, 1.6440072e-08, ..., 1.0300713e-09,\n", + " 6.4238459e-09, 4.4733184e-08],\n", + " ...,\n", + " [1.1831658e-06, 6.1442293e-08, 6.7040520e-07, ..., 2.1582336e-09,\n", + " 4.1912315e-08, 9.9999815e-01],\n", + " [6.2062210e-11, 1.0000000e+00, 2.8723093e-08, ..., 1.7104306e-11,\n", + " 1.6462258e-12, 2.8273201e-08],\n", + " [9.5113836e-07, 1.7920695e-03, 1.5246497e-05, ..., 2.1037022e-10,\n", + " 1.5786559e-07, 9.9819058e-01]], dtype=float32)],\n", + " [array([[1.6563579e-12, 1.2862825e-12, 5.8161405e-12, ..., 2.3761214e-14,\n", + " 5.9920461e-13, 3.9925534e-13],\n", + " [1.9658232e-11, 4.5968694e-11, 1.4739742e-15, ..., 1.5924082e-16,\n", + " 1.0000000e+00, 5.1633333e-15],\n", + " [2.2273297e-09, 1.3997425e-06, 2.3417654e-10, ..., 3.1824599e-10,\n", + " 9.9999815e-01, 2.1156381e-09],\n", + " ...,\n", + " [3.3552385e-09, 3.7095443e-08, 1.6596496e-05, ..., 2.9803161e-08,\n", + " 7.6420825e-08, 4.5622691e-08],\n", + " [2.5259081e-09, 1.0000000e+00, 1.0934950e-10, ..., 1.7510023e-11,\n", + " 6.5995637e-10, 3.6035244e-10],\n", + " [7.8980329e-12, 9.2636586e-11, 1.0263431e-09, ..., 1.0000000e+00,\n", + " 4.7775764e-13, 9.6414127e-11]], dtype=float32),\n", + " array([[1.0000000e+00, 1.8365616e-07, 1.5589126e-08, ..., 4.8670259e-08,\n", + " 3.0366161e-09, 2.0537691e-08],\n", + " [9.9999619e-01, 2.6431171e-06, 1.9415596e-07, ..., 3.5825305e-08,\n", + " 5.0440612e-08, 5.4157385e-09],\n", + " [9.9977398e-01, 1.1597282e-04, 4.4442444e-07, ..., 1.0829139e-04,\n", + " 9.0374378e-08, 5.1284673e-07],\n", + " ...,\n", + " [3.7569575e-02, 3.6601876e-03, 9.5623167e-04, ..., 3.1528241e-05,\n", + " 2.5651034e-03, 7.8370738e-01],\n", + " [3.4463621e-09, 9.9999815e-01, 2.6811861e-08, ..., 1.8856926e-10,\n", + " 9.7967200e-07, 9.4327979e-10],\n", + " [2.8279146e-07, 4.1466713e-04, 6.7706618e-09, ..., 1.0345512e-08,\n", + " 2.3719220e-08, 9.9958527e-01]], dtype=float32)]],\n", + " [[array([0.98732904, 0.98406969, 0.98690633, ..., 0.92808724, 0.98967533,\n", + " 0.99943964]),\n", + " array([0.9997549 , 0.99872238, 1. , 1. , 0.9993713 ,\n", + " 0.99907258, 0.99983928, 1. , 0.99995761, 1. ,\n", + " 0.99978573, 0.98881803, 1. , 0.99268578, 0.99888661,\n", + " 1. , 1. , 0.9997175 , 0.86616584, 1. ,\n", + " 0.9889638 , 0.99988717, 1. , 1. , 0.9996982 ,\n", + " 0.99943198, 0.99980593, 0.99983928, 1. , 0.9997457 ,\n", + " 0.99997449, 0.99919405, 0.99986148, 0.99970693, 0.99991225,\n", + " 1. , 0.999727 , 0.99995761, 1. , 0.99866859,\n", + " 1. , 1. , 1. , 0.99883173, 0.99987337,\n", + " 1. , 0.99995761, 0.99921432, 0.99988717, 1. ,\n", + " 0.92462241, 0.78791849, 0.99995761, 0.9207726 , 0.99156092,\n", + " 0.98363672, 1. , 0.67946132, 1. , 1. ,\n", + " 0.99978573, 0.98730275, 0.67011227, 0.99986148, 0.96310538,\n", + " 0.82477644, 0.99025354, 0.98098788, 0.73309879, 0.99173103,\n", + " 0.80414837, 0.99657587, 0.65685468, 0.99993976, 0.49791878,\n", + " 0.99684852, 0.99992606, 0.48278283, 1. , 0.99608782,\n", + " 0.99983928, 1. , 0.97649105, 0.80446495, 0.99592763,\n", + " 0.99945554, 0.78334331, 0.9993713 , 0.91992909, 0.7069797 ,\n", + " 0.99987337, 0.97526535, 0.99692095, 1. , 0.4990659 ,\n", + " 0.66446275, 0.97859069, 1. , 0.9976118 , 0.99995761,\n", + " 0.99989907, 0.99992606, 0.99948581, 1. , 0.99991225,\n", + " 1. , 0.99899493, 0.99803275, 0.99978573, 0.96450023,\n", + " 0.99740279, 0.99915227, 1. , 0.99995761, 0.99992606,\n", + " 1. , 0.99987337, 1. , 0.99855862, 1. ,\n", + " 1. , 0.99919405, 0.99995761, 1. , 0.99951814,\n", + " 0.99936436, 1. , 0.99978573, 1. , 1. ,\n", + " 0.99020906, 1. , 0.99851777, 0.99992606, 0.99485371,\n", + " 0.99985061, 0.99986148, 0.99904594, 0.99982886, 0.99208098,\n", + " 0.99960929, 0.95640178, 1. , 0.99992606, 1. ,\n", + " 0.99791377, 0.99950264, 0.99858749, 0.98898826, 0.99955063,\n", + " 0.93107254, 0.58127658, 0.90563339, 0.78231869, 0.92126076,\n", + " 0.66857751, 0.91619487, 0.8794186 , 0.95943738, 0.54041171,\n", + " 0.48046462, 0.97137026, 0.53008672, 0.49084562, 0.56575055,\n", + " 0.999727 , 0.74907915, 0.99976608, 0.57229099, 0.99987337,\n", + " 0.56603758, 0.93690073, 0.52224474, 0.72002173, 0.76376023,\n", + " 0.63181754, 0.99967984, 0.99022791, 0.97735952, 0.99960076,\n", + " 0.99913246, 0.99727369, 0.74289677, 0.86811797, 0.63981036,\n", + " 0.42596744, 0.62118717, 0.50993926, 0.94716169, 0.99987337,\n", + " 0.85699553, 0.99939413, 0.79776268, 0.99985061, 0.71205013,\n", + " 0.45648915, 0.55784013, 0.96802288, 0.77559896, 0.99190541,\n", + " 0.45499368, 0.91720859, 0.97362113, 0.92946757, 0.681965 ,\n", + " 0.49438005, 0.7329162 , 0.82743513, 0.82031738, 0.75428635,\n", + " 0.62825612, 0.83496101, 0.94845216, 0.98025248, 0.73073798,\n", + " 0.97992194, 0.79004073, 0.62260813, 0.75316607, 0.77538366,\n", + " 0.71809153, 0.89790485, 0.92419371, 0.85217765, 0.67334795,\n", + " 0.76811549, 0.64292129, 0.61643691, 0.73262591, 0.97158006,\n", + " 0.99118492, 0.70566708, 0.92404047, 0.58395623, 0.8992076 ,\n", + " 0.90412513, 0.69340446, 0.98272473, 0.72840211, 0.9620038 ,\n", + " 0.77312335, 0.70578019, 0.98229039, 0.96693605, 0.84347954,\n", + " 0.83281448, 0.56767704, 0.97495936, 0.97589525, 0.9396085 ,\n", + " 0.93553594, 0.76101643, 0.97012708, 0.72529083, 0.84830584,\n", + " 0.83519596, 0.93056751, 0.89298914, 0.4891881 , 0.95085428,\n", + " 0.84500014, 0.95993508, 0.71700953, 0.98034773, 0.88480499,\n", + " 0.63405093, 0.78182097, 0.99414979, 0.50071947, 0.96056444,\n", + " 0.48707896, 0.77474439, 0.61821813, 0.92290655, 0.52736513,\n", + " 0.45757142, 0.96487631, 0.93633349, 0.81155876, 0.96217095,\n", + " 0.89599376, 0.99353956, 0.99899493, 0.99330278, 0.8696933 ,\n", + " 0.98025248, 0.64390941, 0.92362527, 0.58172223, 0.97412481,\n", + " 0.74733757, 0.81063359, 0.45750253, 0.87108046, 0.69575151,\n", + " 0.98401837, 0.68142459, 0.97638932, 0.97184607, 0.87418004,\n", + " 1. , 0.99989907, 1. , 0.99989907, 1. ,\n", + " 1. , 0.98517897, 0.99995761, 0.99288077, 0.99995761,\n", + " 0.99943964, 1. , 1. , 0.99965288, 0.99325248,\n", + " 0.95764458, 0.99982886, 1. , 1. , 0.99995761,\n", + " 1. , 1. , 0.97933802, 1. , 1. ,\n", + " 0.99744103, 0.99580739, 1. , 1. , 1. ,\n", + " 0.99965288, 1. , 0.99786255, 1. , 1. ,\n", + " 1. , 0.88206047, 1. , 0.97058469, 1. ,\n", + " 1. , 0.96358087, 1. , 0.99982886, 0.49560919,\n", + " 0.95009494, 0.99995761, 0.98433516, 0.99995761, 0.99995761,\n", + " 0.98059742, 1. , 0.99686183, 0.99985061, 0.99940871,\n", + " 0.99992606, 1. , 0.90964998, 0.99989907, 0.99318827,\n", + " 0.9992074 , 0.99718915, 0.78149989, 0.99284611, 0.99891789,\n", + " 0.99982886, 0.97973982, 0.5250177 , 1. , 0.99987337,\n", + " 0.9997175 , 1. , 0.99907258, 0.99180442, 1. ,\n", + " 0.99991225, 1. , 0.99992606, 0.99995761, 0.99932048,\n", + " 0.99945554, 0.99944685, 1. , 0.98415078, 0.99948581,\n", + " 0.99938664, 0.99850672, 0.99943198, 0.99982886, 0.99609206,\n", + " 0.99995761, 0.98626574, 0.999727 , 0.99890574, 0.88556569,\n", + " 0.99769611, 0.99956714, 0.67562035, 0.99939413, 1. ,\n", + " 0.99968898, 0.65065308, 0.61144033, 0.48024037, 0.99039316,\n", + " 0.99966124, 0.99955886, 0.68250123, 0.80140744, 0.93141435,\n", + " 0.98478516, 0.99880116, 0.99902074, 0.88203388, 0.93781901,\n", + " 0.99995761, 0.99953379, 0.99988717, 0.99529907, 0.98574428,\n", + " 0.99272739, 0.99621981, 0.85621583, 0.99672641, 0.999066 ,\n", + " 0.99715141, 1. , 0.72124678, 0.79272167, 0.76769337,\n", + " 0.99653209, 0.97625731, 0.99967135, 0.97518172, 0.96307305,\n", + " 0.60354458, 0.88064581, 0.99909282, 0.99305688, 0.98724439,\n", + " 0.84991842, 0.75622172, 0.99953379, 0.85220831, 0.89453568,\n", + " 0.61244507, 0.99727872, 0.99889948, 0.96362743, 0.99823526,\n", + " 0.99929842, 0.8174303 , 0.99995761, 0.75850867, 0.82073982,\n", + " 0.99868077, 0.93805817, 0.9590425 , 0.99986148, 0.98489765,\n", + " 0.99932773, 0.99190878, 0.99611326, 0.99188202, 0.97022283,\n", + " 0.99995761, 0.99952569, 0.79266011, 0.99995761, 0.99951814,\n", + " 0.51470721, 0.93648506, 0.98712866, 0.99825118, 0.98164791,\n", + " 0.99880687, 0.99581128, 0.91157752, 0.96901269, 0.91401642,\n", + " 0.97788637, 0.47319109, 0.96837755, 0.99917991, 0.97553767,\n", + " 0.9115915 , 0.93637792, 1. , 0.9780679 , 0.99987337,\n", + " 0.98673071, 0.94671638, 1. , 0.99674013, 0.81413033,\n", + " 0.99252611, 0.98315239, 0.99995761, 1. , 0.99168082])],\n", + " [array([0.99997838, 0.99997838, 0.99366458, ..., 0.98490464, 0.99997838,\n", + " 0.99997838]),\n", + " array([0.99997838, 0.99158724, 0.9593331 , 0.99997838, 0.99997838,\n", + " 0.6430424 , 0.98022972, 0.99997838, 0.99997838, 0.99997838,\n", + " 0.83231126, 0.97460678, 0.99997838, 0.99997838, 0.99997838,\n", + " 0.99997838, 0.99997838, 0.99997838, 0.97350531, 0.98711399,\n", + " 0.97474 , 0.97754749, 0.99997838, 0.99997838, 0.82523946,\n", + " 0.95176214, 0.98425346, 0.99997838, 0.99997838, 0.95645784,\n", + " 0.99997838, 0.99158724, 0.99997838, 0.99997838, 0.99997838,\n", + " 0.99997838, 0.42528774, 0.99997838, 0.99366458, 0.99997838,\n", + " 0.99997838, 0.99997838, 0.98626635, 0.8916939 , 0.92207812,\n", + " 0.99997838, 0.93263681, 0.99997838, 0.99997838, 0.99997838,\n", + " 0.48627821, 0.66588097, 0.99997838, 0.84636986, 0.51659442,\n", + " 0.55049301, 0.99997838, 0.93312716, 0.87635708, 0.99997838,\n", + " 0.67522554, 0.95959817, 0.8353301 , 0.99997838, 0.80359936,\n", + " 0.84354092, 0.94038261, 0.99366458, 0.94231953, 0.98339412,\n", + " 0.54316887, 0.99997838, 0.91879877, 0.99082099, 0.8373467 ,\n", + " 0.99997838, 0.99997838, 0.73486649, 0.99082099, 0.99997838,\n", + " 0.99366458, 0.99997838, 0.99997838, 0.91907079, 0.99511118,\n", + " 0.99997838, 0.69562929, 0.99366458, 0.69029752, 0.48936457,\n", + " 0.99997838, 0.96642972, 0.83794616, 0.98626635, 0.9018534 ,\n", + " 0.81885515, 0.99997838, 0.98956957, 0.98591753, 0.98956957,\n", + " 0.82606179, 0.6622718 , 0.81547477, 0.99997838, 0.96734452,\n", + " 0.71824325, 0.98022972, 0.99158724, 0.89979038, 0.52845313,\n", + " 0.74456965, 0.56963545, 0.98110955, 0.99997838, 0.89903183,\n", + " 0.99366458, 0.99997838, 0.76029562, 0.99366458, 0.97502809,\n", + " 0.81269791, 0.99997838, 0.99997838, 0.76726867, 0.86530428,\n", + " 0.90923343, 0.99997838, 0.99997838, 0.81801449, 0.82873568,\n", + " 0.86582334, 0.99158724, 0.98797227, 0.99158724, 0.99997838,\n", + " 0.52224016, 0.65352644, 0.91265475, 0.99997838, 0.9388083 ,\n", + " 0.54227798, 0.55479825, 0.99997838, 0.99997838, 0.99366458,\n", + " 0.67318593, 0.84929906, 0.99997838, 0.70695131, 0.65207982,\n", + " 0.95249991, 0.5742203 , 0.52777387, 0.50292659, 0.83451582,\n", + " 0.67143931, 0.51820565, 0.99158724, 0.99366458, 0.67950819,\n", + " 0.60176915, 0.91721127, 0.98797227, 0.55951869, 0.98665461,\n", + " 0.99997838, 0.96941126, 0.99997838, 0.92482412, 0.99997838,\n", + " 0.41608801, 0.98044374, 0.98367858, 0.79225363, 0.67948173,\n", + " 0.63383746, 0.99997838, 0.77878974, 0.56522767, 0.98711399,\n", + " 0.99997838, 0.99997838, 0.48551272, 0.44123527, 0.8618542 ,\n", + " 0.80482928, 0.66985776, 0.62017624, 0.80381936, 0.99997838,\n", + " 0.50302215, 0.92068908, 0.60003479, 0.99997838, 0.46948365,\n", + " 0.63186242, 0.57837281, 0.87266019, 0.49218298, 0.97624836,\n", + " 0.61514633, 0.75956056, 0.99158724, 0.52672006, 0.67979649,\n", + " 0.50462331, 0.63833029, 0.8729833 , 0.55727932, 0.74518438,\n", + " 0.83796546, 0.42827483, 0.6028738 , 0.6460533 , 0.66026692,\n", + " 0.89718609, 0.56121631, 0.89207323, 0.90079797, 0.90251757,\n", + " 0.48341399, 0.95210094, 0.93469533, 0.8784381 , 0.85130809,\n", + " 0.7299571 , 0.90606898, 0.46443531, 0.91922508, 0.517577 ,\n", + " 0.62493851, 0.75421951, 0.79758595, 0.48424467, 0.54629852,\n", + " 0.92180986, 0.90404411, 0.96625165, 0.69760277, 0.50988639,\n", + " 0.74252501, 0.63025507, 0.55954058, 0.92841711, 0.97862568,\n", + " 0.85332826, 0.8618675 , 0.66919036, 0.88371602, 0.50535152,\n", + " 0.91131174, 0.87058956, 0.99997838, 0.48621124, 0.98207612,\n", + " 0.98283078, 0.6424557 , 0.98283078, 0.84686708, 0.97562108,\n", + " 0.63025101, 0.95330591, 0.91126367, 0.72815909, 0.84603823,\n", + " 0.81786313, 0.89664854, 0.54297098, 0.96811424, 0.91625621,\n", + " 0.97049195, 0.91136191, 0.73328235, 0.52086934, 0.99366458,\n", + " 0.9444916 , 0.97721666, 0.8997133 , 0.6296425 , 0.93076223,\n", + " 0.75638058, 0.94494951, 0.91485927, 0.93323873, 0.50721054,\n", + " 0.96521985, 0.98256799, 0.98339412, 0.56478882, 0.96951585,\n", + " 0.59774062, 0.49922724, 0.56840195, 0.62382395, 0.68012543,\n", + " 0.61232661, 0.91464666, 0.47161347, 0.84883522, 0.83657611,\n", + " 0.99997838, 0.40833807, 0.97843989, 0.60743652, 0.99082099,\n", + " 0.99997838, 0.59235794, 0.86037725, 0.636365 , 0.4707931 ,\n", + " 0.47240448, 0.91348542, 0.69245315, 0.67717818, 0.68309037,\n", + " 0.63369922, 0.99997838, 0.61570557, 0.58799471, 0.49880387,\n", + " 0.99997838, 0.99997838, 0.97187984, 0.65621282, 0.9593331 ,\n", + " 0.48673223, 0.451876 , 0.99366458, 0.59827355, 0.56076155,\n", + " 0.51885154, 0.86541917, 0.69715507, 0.72230997, 0.98665461,\n", + " 0.99158724, 0.39775796, 0.94062081, 0.94752323, 0.61315125,\n", + " 0.45684355, 0.55451038, 0.74093226, 0.5792872 , 0.76190207,\n", + " 0.86432683, 0.83636286, 0.86346949, 0.87735785, 0.99511118,\n", + " 0.99997838, 0.99997838, 0.94199834, 0.98842466, 0.754898 ,\n", + " 0.99997838, 0.99997838, 0.59709449, 0.99997838, 0.98157524,\n", + " 0.98894018, 0.95047799, 0.9380443 , 0.98207612, 0.97738643,\n", + " 0.99997838, 0.45695218, 0.48714607, 0.99997838, 0.99997838,\n", + " 0.99158724, 0.99997838, 0.99997838, 0.95052734, 0.99997838,\n", + " 0.82827344, 0.99997838, 0.93767139, 0.99997838, 0.96129798,\n", + " 0.83456648, 0.96781827, 0.99997838, 0.98134006, 0.99511118,\n", + " 0.98308313, 0.59600256, 0.57909334, 0.91709976, 0.88796416,\n", + " 0.99997838, 0.97959641, 0.99997838, 0.98626635, 0.58653618,\n", + " 0.99997838, 0.59163431, 0.5578085 , 0.98797227, 0.99997838,\n", + " 0.99997838, 0.88296602, 0.71306242, 0.55950593, 0.44617884,\n", + " 0.54460946, 0.99366458, 0.72448978, 0.55246941, 0.55173172,\n", + " 0.85598182, 0.53664671, 0.51680191, 0.94370167, 0.60459903,\n", + " 0.61021523, 0.74076338, 0.99158724, 0.72585904, 0.41185079,\n", + " 0.98283078, 0.86918438, 0.68039792, 0.95215012, 0.8172085 ,\n", + " 0.65101365, 0.68869167, 0.46314638, 0.56729717, 0.66541896,\n", + " 0.88143663, 0.45250995, 0.62922041, 0.54530809, 0.53172389,\n", + " 0.8186474 , 0.85391964, 0.76621126, 0.48372616, 0.81953893,\n", + " 0.93896918, 0.59416247, 0.85426039, 0.52133263, 0.59720316,\n", + " 0.72749491, 0.40840347, 0.50917097, 0.7975714 , 0.92414273,\n", + " 0.98339412, 0.49465567, 0.79903937, 0.99511118, 0.66794631,\n", + " 0.865925 , 0.42453445, 0.52815806, 0.51667298, 0.97774326,\n", + " 0.47001377, 0.61106181, 0.84145626, 0.9852371 , 0.75957199,\n", + " 0.99997838, 0.88842579, 0.89599221, 0.99997838, 0.90657022,\n", + " 0.96496321, 0.99158724, 0.73125241, 0.99366458, 0.99997838,\n", + " 0.42093062, 0.99997838, 0.97235037, 0.92086944, 0.83095217,\n", + " 0.98490464, 0.60610019, 0.89924836, 0.95532678, 0.54351332,\n", + " 0.89073234, 0.44147444, 0.99997838, 0.99997838, 0.99082099,\n", + " 0.86114498, 0.77479971, 0.94210653, 0.81834237, 0.98842466,\n", + " 0.98367858, 0.49119487, 0.58899636, 0.99366458, 0.94890045])]],\n", + " [[array([3, 8, 8, ..., 5, 1, 7]),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", + " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", + " 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", + " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", + " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9])],\n", + " [array([3, 8, 8, ..., 5, 1, 7]),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", + " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", + " 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", + " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", + " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9])]])" + ] + }, + "execution_count": 199, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Try linear and fine-tuning models which have very different ID and OOD accs.\n", + "# On CIFAR, Im-n-C10\n", + "\n", + "config_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d01/config.json',\n", + " '../logs/imnet_cifar_all_ft_0d01/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d01/checkpoints/ckp_last',\n", + " '../logs/imnet_cifar_all_ft_0d01/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['lin_model', 'ft_model']\n", + "loader_names = ['cifar', 'imnc']\n", + "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cifar10-test\n", + "imnet-n-cifar\n", + "Ave lin_model confidence for cifar: 0.9127064347267151\n", + "Ave lin_model confidence for imnc: 0.9176557660102844\n", + "Ave ft_model confidence for cifar: 0.9871745109558105\n", + "Ave ft_model confidence for imnc: 0.9197461605072021\n", + "Dataset cifar: \n", + "Model lin_model: 0.9076\n", + "Model ft_model: 0.9652\n", + "Combined 0.9638\n", + "Dataset imnc: \n", + "Model lin_model: 0.764\n", + "Model ft_model: 0.71\n", + "Combined 0.786\n" + ] + } + ], + "source": [ + "# Try the best linear and fine-tuned models on CIFAR, Im-n-C10\n", + "\n", + "config_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d003/config.json',\n", + " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d003/checkpoints/ckp_last',\n", + " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['lin_model', 'ft_model']\n", + "loader_names = ['cifar', 'imnc']\n", + "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cifar10-test\n", + "imnet-n-cifar\n", + "Ave fine-tuned1 confidence for cifar: 0.9832788109779358\n", + "Ave fine-tuned1 confidence for imnc: 0.9021713733673096\n", + "Ave fine-tuned2 confidence for cifar: 0.9871745109558105\n", + "Ave fine-tuned2 confidence for imnc: 0.9197461605072021\n", + "Dataset cifar: \n", + "Model fine-tuned1: 0.9598\n", + "Model fine-tuned2: 0.9652\n", + "Combined 0.9655\n", + "Dataset imnc: \n", + "Model fine-tuned1: 0.686\n", + "Model fine-tuned2: 0.71\n", + "Combined 0.704\n" + ] + } + ], + "source": [ + "# Control: Try two fine-tuned models on CIFAR, Im-n-C10\n", + "\n", + "config_paths = [\n", + " '../logs/imnet_cifar_all_ft_0d001/config.json',\n", + " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/imnet_cifar_all_ft_0d001/checkpoints/ckp_last',\n", + " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['fine-tuned1', 'fine-tuned2']\n", + "loader_names = ['cifar', 'imnc']\n", + "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cifar10-test\n", + "cinic-val\n", + "Ave lin_model confidence for cifar: 0.9127064347267151\n", + "Ave lin_model confidence for cinic: 0.8465512990951538\n", + "Ave ft_model confidence for cifar: 0.9871745109558105\n", + "Ave ft_model confidence for cinic: 0.9467272162437439\n", + "Dataset cifar: \n", + "Model lin_model: 0.9076\n", + "Model ft_model: 0.9652\n", + "Combined 0.9638\n", + "Dataset cinic: \n", + "Model lin_model: 0.7216285714285714\n", + "Model ft_model: 0.7908714285714286\n", + "Combined 0.7834428571428571\n" + ] + } + ], + "source": [ + "# Battle testing this: what if fine-tuned model is better in both?\n", + "# On CIFAR, cinic\n", + "\n", + "config_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d003/config.json',\n", + " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/imnet_cifar_all_linp_0d003/checkpoints/ckp_last',\n", + " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['lin_model', 'ft_model']\n", + "loader_names = ['cifar', 'cinic']\n", + "loader_indices = [0, 2] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "source_val_living\n", + "target_val_living\n", + "Ave lin_model confidence for e30_src: 0.3781175911426544\n", + "Ave lin_model confidence for e30_trg: 0.2673947513103485\n", + "Ave ft_model confidence for e30_src: 0.9443250298500061\n", + "Ave ft_model confidence for e30_trg: 0.8535376787185669\n", + "Dataset e30_src: \n", + "Model lin_model: 0.789\n", + "Model ft_model: 0.8725\n", + "Combined 0.8803333333333333\n", + "Dataset e30_trg: \n", + "Model lin_model: 0.6496666666666666\n", + "Model ft_model: 0.5401666666666667\n", + "Combined 0.6256666666666667\n" + ] + } + ], + "source": [ + "# Try Entity 30.\n", + "\n", + "config_paths = [\n", + " '../logs/entity30_moco_linprobe_0.003/config.json',\n", + " '../logs/entity30_moco_ft_0.003/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/entity30_moco_linprobe_0.003/checkpoints/ckp_last',\n", + " '../logs/entity30_moco_ft_0.003/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['lin_model', 'ft_model']\n", + "loader_names = ['e30_src', 'e30_trg']\n", + "loader_indices = [0, 1] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "source_val_living\n", + "target_val_living\n", + "Ave lin_model confidence for l17_src: 0.4781600534915924\n", + "Ave lin_model confidence for l17_trg: 0.3302820920944214\n", + "Ave ft_model confidence for l17_src: 0.969921886920929\n", + "Ave ft_model confidence for l17_trg: 0.9005916714668274\n", + "Dataset l17_src: \n", + "Model lin_model: 0.9\n", + "Model ft_model: 0.9241176470588235\n", + "Combined 0.94\n", + "Dataset l17_trg: \n", + "Model lin_model: 0.7341176470588235\n", + "Model ft_model: 0.6541176470588236\n", + "Combined 0.731764705882353\n" + ] + } + ], + "source": [ + "# Try Living 17.\n", + "\n", + "config_paths = [\n", + " '../logs/breeds_moco_linprobe_0.003/config.json',\n", + " '../logs/breeds_moco_ft_0.003/config.json'\n", + "]\n", + "\n", + "checkpoint_paths = [\n", + " '../logs/breeds_moco_linprobe_0.003/checkpoints/ckp_last',\n", + " '../logs/breeds_moco_ft_0.003/checkpoints/ckp_last'\n", + "]\n", + "\n", + "model_names = ['lin_model', 'ft_model']\n", + "loader_names = ['l17_src', 'l17_trg']\n", + "loader_indices = [0, 1] # Relative to the config file in the first config path in config_paths.\n", + "\n", + "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 1])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[1, 2],[3, 4],[5, 6]])\n", + "a[np.array([0, 0, 0]), np.array([0, 1, 0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import calibration as cal\n", + "\n", + "def combine_preds(model_probs, labels_id, labels_ood):\n", + " model\n", + " for model in range(2):\n", + " for domain in range(2):\n", + " \n", + " model1_id_confs = np.max(model1_probs_id, axis=1)\n", + " model2_id_confs = np.max(model2_probs_id, axis=1)\n", + " model1_ood_confs = np.max(model1_probs_ood, axis=1)\n", + " model2_ood_confs = np.max(model2_probs_ood, axis=1)\n", + " model1_id_preds = np.argmax(model1_probs_id, axis=1)\n", + " model2_id_c = np.argmax(model2_probs_id, axis=1)\n", + " model1_ood_confs = np.argmax(model1_probs_ood, axis=1)\n", + " model2_ood_confs = np.argmax(model2_probs_ood, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'train_dataset': {'classname': 'torchvision.datasets.CIFAR10',\n", + " 'args': {'train': True,\n", + " 'download': False,\n", + " 'root': '/u/scr/ananya/cifar10_dataset'},\n", + " 'transforms': [{'classname': 'torchvision.transforms.Resize',\n", + " 'args': {'size': 224}},\n", + " {'classname': 'torchvision.transforms.ToTensor'},\n", + " {'classname': 'torchvision.transforms.Normalize',\n", + " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]},\n", + " 'default_test_transforms': [{'classname': 'torchvision.transforms.Resize',\n", + " 'args': {'size': [224, 224]}},\n", + " {'classname': 'torchvision.transforms.ToTensor'},\n", + " {'classname': 'torchvision.transforms.Normalize',\n", + " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}],\n", + " 'test_datasets': [{'name': 'cifar10-test',\n", + " 'max_test_examples': 1000,\n", + " 'classname': 'torchvision.datasets.CIFAR10',\n", + " 'args': {'train': False,\n", + " 'download': False,\n", + " 'root': '/u/scr/ananya/cifar10_dataset'}},\n", + " {'name': 'stl-test',\n", + " 'max_test_examples': 1000,\n", + " 'classname': 'datasets.stl_cifar_style.STL10',\n", + " 'args': {'root': '/u/scr/ananya/stl10_dataset', 'split': 'test'}},\n", + " {'name': 'cinic-val',\n", + " 'classname': 'datasets.cinic.CINICImNet',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/u/scr/ananya/cinic-10-imagenet', 'mode': 'valid'}},\n", + " {'name': 'stl-32x32',\n", + " 'classname': 'datasets.stl_cifar_style.STL10',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/u/scr/ananya/stl10_dataset', 'split': 'test'},\n", + " 'transforms': [{'classname': 'torchvision.transforms.Resize',\n", + " 'args': {'size': 32}},\n", + " {'classname': 'torchvision.transforms.Resize', 'args': {'size': 224}},\n", + " {'classname': 'torchvision.transforms.ToTensor'},\n", + " {'classname': 'torchvision.transforms.Normalize',\n", + " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]},\n", + " {'name': 'imnet-n-cifar',\n", + " 'classname': 'datasets.imnet_intersect_c10.ImNetnC10',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/balanced_imnet_intersect_c10_val/'}},\n", + " {'name': 'fog-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'fog',\n", + " 'severity': 2}},\n", + " {'name': 'fog-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'fog',\n", + " 'severity': 4}},\n", + " {'name': 'zoom-blur-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'zoom_blur',\n", + " 'severity': 2}},\n", + " {'name': 'zoom-blur-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'zoom_blur',\n", + " 'severity': 4}},\n", + " {'name': 'gaussian-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'gaussian_noise',\n", + " 'severity': 2}},\n", + " {'name': 'gaussian-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'gaussian_noise',\n", + " 'severity': 4}},\n", + " {'name': 'pixelate-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'pixelate',\n", + " 'severity': 2}},\n", + " {'name': 'pixelate-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'pixelate',\n", + " 'severity': 4}},\n", + " {'name': 'shotnoise-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'shot_noise',\n", + " 'severity': 2}},\n", + " {'name': 'shotnoise-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'shot_noise',\n", + " 'severity': 4}},\n", + " {'name': 'glassblur-cifar-2',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'glass_blur',\n", + " 'severity': 2}},\n", + " {'name': 'glassblur-cifar-4',\n", + " 'classname': 'datasets.cifar10c.CIFAR10C',\n", + " 'max_test_examples': 1000,\n", + " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", + " 'corruption': 'glass_blur',\n", + " 'severity': 4}}],\n", + " 'inherit': ['/juice/scr/ananya/cifar_experiments/custom_training/configs/datasets_cifar_test_all.yaml'],\n", + " 'log_interval': 5000,\n", + " 'use_cuda': True,\n", + " 'save_freq': 101,\n", + " 'epochs': 100,\n", + " 'batch_size': 128,\n", + " 'num_workers': 8,\n", + " 'save_all_checkpoints': False,\n", + " 'finetune': True,\n", + " 'num_classes': 10,\n", + " 'linear_probe': True,\n", + " 'use_net_val_mode': True,\n", + " 'optimizer': {'classname': 'torch.optim.SGD',\n", + " 'args': {'lr': 0.01, 'momentum': 0.9}},\n", + " 'scheduler': {'classname': 'torch.optim.lr_scheduler.StepLR',\n", + " 'args': {'step_size': 100}},\n", + " 'model': {'classname': 'models.imnet_resnet.ResNet50',\n", + " 'args': {'pretrained': True}},\n", + " 'criterion': {'classname': 'torch.nn.CrossEntropyLoss',\n", + " 'args': {'reduction': 'mean'}},\n", + " 'wandb_url': 'https://wandb.ai/p-lambda/cifar/runs/stk89vzs',\n", + " 'run_name': 'imnet_cifar_all_linp_0d01',\n", + " 'group_name': 'imnet_cifar_all_linp',\n", + " 'entity_name': 'p-lambda',\n", + " 'wandb': True}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 840d6b8e5c9a700b99dbc33940dfb924caf9a578 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 00:28:31 -0700 Subject: [PATCH 026/197] Refactor baseline_train, add support for best checkpoints. --- experiments/baseline_train.py | 141 +++++++++++++++++++++------------- 1 file changed, 87 insertions(+), 54 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 36bbf26..b5a8d13 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -71,25 +71,12 @@ def update_best_stats(stats, best_stats): best_stats[best_k] = v -def main(config, log_dir, checkpoints_dir): - # Set up datasets and loaders. - logging.info("Entering main.") - train_data = utils.init_dataset(config['train_dataset']) - train_loader = torch.utils.data.DataLoader( - train_data, batch_size=config['batch_size'], - shuffle=True, num_workers=config['num_workers']) - # Set up test loaders. - logging.info('Found %d testing datasets.', len(config['test_datasets'])) +def get_test_loaders(config): test_loaders = {} max_test_examples = {} + logging.info('Found %d testing datasets.', len(config['test_datasets'])) for test_dataset_config in config['test_datasets']: logging.info('test dataset config: ' + str(test_dataset_config)) - # Use default test transform if test dataset doesn't specify a transform. - if 'transforms' not in test_dataset_config: - if config['default_test_transforms'] is None: - raise ValueError('Must either specify default_test_transforms ' - 'or a transform for each test dataset') - test_dataset_config['transforms'] = config['default_test_transforms'] # Initialize dataset and data loader. # Shuffle is True in case we only test part of the test set. test_data = utils.init_dataset(test_dataset_config) @@ -104,8 +91,10 @@ def main(config, log_dir, checkpoints_dir): logging.info('test loader name: ' + test_dataset_config['name']) logging.info('test loader: ' + str(test_loader)) logging.info('test transform: ' + str(test_dataset_config['transforms'])) - # Create model. - logging.info(f'cuda device count: {torch.cuda.device_count()}') + return test_loaders, max_test_examples + + +def build_model(config): net = utils.initialize(config['model']) # If fine-tune, re-initialize the last layer. finetune = 'finetune' in config and config['finetune'] @@ -127,8 +116,22 @@ def count_parameters(model, trainable): num_trainable_params = count_parameters(net, True) num_params = count_parameters(net, False) + num_trainable_params logging.info(f'Fine Tuning {num_trainable_params} of {num_params} parameters.') - + return net + + +def main(config, log_dir, checkpoints_dir): + # Set up datasets and loaders. + logging.info("Entering main.") + train_data = utils.init_dataset(config['train_dataset']) + train_loader = torch.utils.data.DataLoader( + train_data, batch_size=config['batch_size'], + shuffle=True, num_workers=config['num_workers']) + # Set up test loaders. + test_loaders, max_test_examples = get_test_loaders(config) + # Create model. + net = build_model(config) # Use CUDA if desired. + logging.info(f'cuda device count: {torch.cuda.device_count()}') if config['use_cuda']: device = "cuda" net.cuda() @@ -145,6 +148,7 @@ def count_parameters(model, trainable): config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. best_stats = {} + best_accs = {} # Used to save checkpoints of best models on some datasets. prev_ckp_path = None for epoch in range(config['epochs']): # Save checkpoint once in a while. @@ -175,6 +179,9 @@ def count_parameters(model, trainable): optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) + _, train_preds = torch.max(outputs.data, 1) + loss_dict['train/loss'].add_value(loss.tolist()) + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) opt_loss.backward() @@ -182,9 +189,6 @@ def count_parameters(model, trainable): else: loss.backward() optimizer.step() - loss_dict['train/loss'].add_value(loss.tolist()) - _, train_preds = torch.max(outputs.data, 1) - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) num_examples += len(labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -196,33 +200,18 @@ def should_log(log_interval): (epoch + 1, num_examples, k, loss_dict[k].get_mean())) stats = {} if 'test_interval' in config and should_log(config['test_interval']): - for name, test_loader in test_loaders.items(): - max_examples = float('infinity') - if name in max_test_examples: - max_examples = max_test_examples[name] - logging.info(f'{name} test set processing max examples {max_examples}') - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device, - max_examples=max_examples) - stats['inter_ood_loss/' + name] = val_loss.get_mean() - stats['inter_ood_acc/' + name] = val_acc.get_mean() + stats = get_test_stats( + test_loaders, max_test_examples, config, net, criterion, device, + loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') if config['wandb']: wandb.log(stats) update_best_stats(stats, best_stats) scheduler.step() # Get loss for each test set - stats = {} - if 'test_interval' not in config: - for name, test_loader in test_loaders.items(): - max_examples = float('infinity') - if name in max_test_examples: - max_examples = max_test_examples[name] - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device, - max_examples=max_examples) - stats['ood_loss/' + name] = val_loss.get_mean() - stats['ood_acc/' + name] = val_acc.get_mean() + stats = get_test_stats( + test_loaders, max_test_examples, config, net, criterion, device, + loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') for k in loss_dict: stats[k] = loss_dict[k].get_mean() update_best_stats(stats, best_stats) @@ -230,16 +219,36 @@ def should_log(log_interval): wandb.log(stats) wandb.log(best_stats) utils.save_json(log_dir + '/current.json', stats) - # # Save checkpoint of best model. - # if val_acc.get_mean() > best_acc: - # best_acc = val_acc.get_mean() - # utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_best') - # logging.info('Accuracy of the network on the 10000 test images: %.2f %%' % - # (100.0 * val_acc.get_mean())) + # Save checkpoint of best model. + if 'early_stop_dataset_names' in config: + for name in config['early_stop_dataset_names']: + if name not in test_configs: + raise ValueError(f"{name} is not the name of a test dataset.") + metric_name = 'test_acc/' + name + assert(metric_name in stats) + if metric_name not in best_acc or stats[metric_name] > best_acc[metric_name]: + best_acc[metric_name] = stats[metric_name] + checkpoint_name = 'ckp_best_' + name + utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, checkpoint_name) utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_last') utils.save_json(log_dir + '/best.json', best_stats) +def get_test_stats(test_loaders, max_test_examples, config, net, criterion, device, + loss_name_prefix, acc_name_prefix): + stats = {} + for name, test_loader in test_loaders.items(): + max_examples = float('infinity') + if name in max_test_examples: + max_examples = max_test_examples[name] + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device, + max_examples=max_examples) + stats[loss_name_prefix + name] = val_loss.get_mean() + stats[acc_name_prefix + name] = val_acc.get_mean() + return stats + + def make_new_dir(new_dir): if os.path.isdir(new_dir): raise ValueError('{} already exists.'.format(new_dir)) @@ -254,9 +263,8 @@ def make_checkpoints_dir(log_dir): def copy_folders(log_dir): - copy_folders = ['code', 'scripts', 'lib', 'configs', 'models', - 'experiments', 'utils', 'examples', 'src', - 'datasets'] + copy_folders = ['code', 'configs', 'scripts', 'lib', 'configs', 'models', + 'experiments', 'utils', 'examples', 'src', 'datasets'] for copy_folder in copy_folders: if os.path.isdir('./' + copy_folder): shutil.copytree('./' + copy_folder, log_dir + '/' + copy_folder) @@ -297,6 +305,26 @@ def save_command_line_args(log_dir): f.write('\n') +def update_test_transform_configs(config): + # Use default test transform for test datasets that don't specify a transform. + for test_dataset_config in config['test_datasets']: + if 'transforms' not in test_dataset_config: + if config['default_test_transforms'] is None: + raise ValueError('Must either specify default_test_transforms ' + 'or a transform for each test dataset') + test_dataset_config['transforms'] = config['default_test_transforms'] + + +def update_net_eval_mode(config): + # If linear probing, then by default we want to turn off batchnorm while training. + # In other words we want to use validation mode while training unless otherwise specified. + linear_probe = 'linear_probe' in config and config['linear_probe'] + if linear_probe: + if 'use_net_val_mode' not in config: + config['use_net_val_mode'] = True + logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') + + def setup(): parser = argparse.ArgumentParser( description='Run model') @@ -305,6 +333,8 @@ def setup(): parser.add_argument('--log_dir', type=str, metavar='ld', help='Log directory', required=True) parser.add_argument('--no_wandb', action='store_true', help='disable W&B') + parser.add_argument('--copy_all_folders', action='store_true', + help='Copy all folders (e.g. code, utils) for reproducibility.') parser.add_argument('--project_name', type=str, help='Name of the wandb project', required=True) parser.add_argument('--group_name', default=None, help='Name of the wandb group (a group of runs)') @@ -316,14 +346,17 @@ def setup(): # Make log and checkpoint directories. make_new_dir(log_dir) checkpoints_dir = make_checkpoints_dir(log_dir) - # copy_folders(args.log_dir) + # If you want to copy folders to get the whole state of code + # while running. For more reproducibility. + if args.copy_all_folders: + copy_folders(args.log_dir) # Setup logging. utils.setup_logging(log_dir, log_level) # Open config, update with command line args. - # with open(args.config, 'r') as f: - # config = yaml.safe_load(f) config = quinine.Quinfig(args.config) utils.update_config(unparsed, config) + update_test_transform_configs(config) + update_net_eval_mode(config) shutil.copy(args.config, log_dir+'/original_config.yaml') # Setup wandb. setup_wandb(args, config) From 1824a6c596a3f4b94d523a4bcdebb0c2b120414a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 01:11:33 -0700 Subject: [PATCH 027/197] Save tsv files. --- experiments/baseline_train.py | 153 ++++++++++++++++++++-------------- 1 file changed, 92 insertions(+), 61 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index b5a8d13..d879aa3 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -12,6 +12,7 @@ import torch import torchvision from torchvision import transforms +import torch.backends.cudnn as cudnn import torch.optim as optim import torch.nn as nn import torch.nn.functional as F @@ -119,6 +120,63 @@ def count_parameters(model, trainable): return net +def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, + test_loaders, max_test_examples): + # Train model. + training_state = net.training + logging.info("\nEpoch #{}".format(epoch)) + loss_dict = { + 'train/loss': Accumulator(), + 'train/acc': Accumulator(), + } + if 'model_loss' in config: + loss_dict['train/model_loss'] = Accumulator() + num_examples = 0 + for i, data in enumerate(train_loader, 0): + if 'use_net_val_mode' in config and config['use_net_val_mode']: + net.eval() + else: + net.train() + # get the inputs; data is a list of [inputs, labels] + if config['use_cuda']: + data = utils.to_device(data, device) + inputs, labels = data + optimizer.zero_grad() + outputs = net(inputs) + loss = criterion(outputs, labels) + _, train_preds = torch.max(outputs.data, axis=1) + loss_dict['train/loss'].add_value(loss.tolist()) + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + if 'model_loss' in config: + opt_loss = model_loss(net, inputs, labels) + opt_loss.backward() + loss_dict['train/model_loss'].add_value(opt_loss.tolist()) + else: + loss.backward() + optimizer.step() + num_examples += len(labels) + outputs, loss, train_preds = None, None, None # Try to force garbage collection. + def should_log(log_interval): + return num_examples // log_interval > (num_examples - len(labels)) // log_interval + if should_log(config['log_interval']): + for k in loss_dict: + logging.info( + '[%d, %5d] %s: %.3f' % + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + # Sometimes we want to log the test loss more often to track things better. + if 'test_interval' in config and should_log(config['test_interval']): + stats = get_test_stats( + test_loaders, max_test_examples, config, net, criterion, device, + loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') + if config['wandb']: + wandb.log(stats) + reset_state(net, training_state) + train_stats = {'epoch': epoch} + for key in loss_dict: + train_stats[key] = loss_dict[key].get_mean() + return train_stats + + def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. logging.info("Entering main.") @@ -133,13 +191,17 @@ def main(config, log_dir, checkpoints_dir): # Use CUDA if desired. logging.info(f'cuda device count: {torch.cuda.device_count()}') if config['use_cuda']: + cudnn.benchmark = True device = "cuda" net.cuda() logging.info('Using cuda? %d', next(net.parameters()).is_cuda) # Loss, optimizer, scheduler. # Can use a custom loss that takes in a model, inputs, labels, and gets an array of values. - # Or a criterion, which takes in model_outputs, labels, outputs a loss. + # For example if you want to regularize weights in some special way. + # More commonly, we use a criterion, which takes in model_outputs, labels, and outputs a loss. + # criterion must be specified anyway, since that's the loss we evaluate on test sets. criterion = utils.initialize(config['criterion']) + model_loss = None if 'model_loss' in config: model_loss = utils.initialize(config['model_loss']) optimizer = utils.initialize( @@ -149,6 +211,8 @@ def main(config, log_dir, checkpoints_dir): # Training loop. best_stats = {} best_accs = {} # Used to save checkpoints of best models on some datasets. + train_metrics = [] + test_metrics = [] prev_ckp_path = None for epoch in range(config['epochs']): # Save checkpoint once in a while. @@ -158,68 +222,35 @@ def main(config, log_dir, checkpoints_dir): if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): os.remove(prev_ckp_path) prev_ckp_path = checkpoints_dir / cur_ckp_filename - # Train model. - logging.info("\nEpoch #{}".format(epoch)) - loss_dict = { - 'train/loss': Accumulator(), - 'train/acc': Accumulator(), - } - if 'model_loss' in config: - loss_dict['train/model_loss'] = Accumulator() - num_examples = 0 - for i, data in enumerate(train_loader, 0): - if 'use_net_val_mode' in config and config['use_net_val_mode']: - net.eval() - else: - net.train() - # get the inputs; data is a list of [inputs, labels] - if config['use_cuda']: - data = utils.to_device(data, device) - inputs, labels = data - optimizer.zero_grad() - outputs = net(inputs) - loss = criterion(outputs, labels) - _, train_preds = torch.max(outputs.data, 1) - loss_dict['train/loss'].add_value(loss.tolist()) - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) - if 'model_loss' in config: - opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() - loss_dict['train/model_loss'].add_value(opt_loss.tolist()) - else: - loss.backward() - optimizer.step() - num_examples += len(labels) - outputs, loss, train_preds = None, None, None # Try to force garbage collection. - def should_log(log_interval): - return num_examples // log_interval > (num_examples - len(labels)) // log_interval - if should_log(config['log_interval']): - for k in loss_dict: - logging.info( - '[%d, %5d] %s: %.3f' % - (epoch + 1, num_examples, k, loss_dict[k].get_mean())) - stats = {} - if 'test_interval' in config and should_log(config['test_interval']): - stats = get_test_stats( - test_loaders, max_test_examples, config, net, criterion, device, - loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') - if config['wandb']: - wandb.log(stats) - update_best_stats(stats, best_stats) - + # One epoch of model training. + train_stats = train( + epoch, config, train_loader, net, device, optimizer, criterion, model_loss, + test_loaders, max_test_examples) scheduler.step() - # Get loss for each test set - stats = get_test_stats( - test_loaders, max_test_examples, config, net, criterion, device, + # Get test stats across all test sets. + test_stats = get_test_stats( + epoch, test_loaders, max_test_examples, config, net, criterion, device, loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') - for k in loss_dict: - stats[k] = loss_dict[k].get_mean() - update_best_stats(stats, best_stats) + # Keep track of the best stats. + update_best_stats(train_stats, best_stats) + update_best_stats(test_stats, best_stats) + # Log and save stats. + train_metrics.append(train_stats) + test_metrics.append(test_stats) + train_df = pd.DataFrame(train_metrics) + eval_df = pd.DataFrame(eval_metrics) + train_df.to_csv(log_dir + '/stats_train.tsv', sep='\t') + eval_df.to_csv(log_dir + 'stats_eval.tsv', sep='\t') if config['wandb']: - wandb.log(stats) + wandb.log(train_stats) + wandb.log(test_stats) wandb.log(best_stats) - utils.save_json(log_dir + '/current.json', stats) - # Save checkpoint of best model. + utils.save_json(log_dir + '/current_train.json', train_stats) + utils.save_json(log_dir + '/current_test.json', test_stats) + # Save checkpoint of best model. We save the 'best' for each of a list + # of specified valid datasets. For example, we might want to save the best + # model according to in-domain validation metrics, but as an oracle, save + # the best according to ood validation metrics (or a proxy ood metric). if 'early_stop_dataset_names' in config: for name in config['early_stop_dataset_names']: if name not in test_configs: @@ -234,9 +265,9 @@ def should_log(log_interval): utils.save_json(log_dir + '/best.json', best_stats) -def get_test_stats(test_loaders, max_test_examples, config, net, criterion, device, +def get_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, loss_name_prefix, acc_name_prefix): - stats = {} + stats = {'epoch': epoch} for name, test_loader in test_loaders.items(): max_examples = float('infinity') if name in max_test_examples: From c2b2d7c7d7101c555b7027744e7ac27bc512aa0a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 01:26:58 -0700 Subject: [PATCH 028/197] Move functions --- experiments/baseline_train.py | 49 +++++++++++++++++++---------------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index d879aa3..022c30f 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -177,6 +177,21 @@ def should_log(log_interval): return train_stats +def get_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, + loss_name_prefix, acc_name_prefix): + stats = {'epoch': epoch} + for name, test_loader in test_loaders.items(): + max_examples = float('infinity') + if name in max_test_examples: + max_examples = max_test_examples[name] + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device, + max_examples=max_examples) + stats[loss_name_prefix + name] = val_loss.get_mean() + stats[acc_name_prefix + name] = val_acc.get_mean() + return stats + + def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. logging.info("Entering main.") @@ -191,6 +206,7 @@ def main(config, log_dir, checkpoints_dir): # Use CUDA if desired. logging.info(f'cuda device count: {torch.cuda.device_count()}') if config['use_cuda']: + # Often makes things faster, by benchmarking and figuring out how to optimize. cudnn.benchmark = True device = "cuda" net.cuda() @@ -238,46 +254,31 @@ def main(config, log_dir, checkpoints_dir): train_metrics.append(train_stats) test_metrics.append(test_stats) train_df = pd.DataFrame(train_metrics) - eval_df = pd.DataFrame(eval_metrics) + test_df = pd.DataFrame(test_metrics) train_df.to_csv(log_dir + '/stats_train.tsv', sep='\t') - eval_df.to_csv(log_dir + 'stats_eval.tsv', sep='\t') + test_df.to_csv(log_dir + '/stats_test.tsv', sep='\t') if config['wandb']: wandb.log(train_stats) wandb.log(test_stats) wandb.log(best_stats) utils.save_json(log_dir + '/current_train.json', train_stats) utils.save_json(log_dir + '/current_test.json', test_stats) + utils.save_json(log_dir + '/best.json', best_stats) # Save checkpoint of best model. We save the 'best' for each of a list # of specified valid datasets. For example, we might want to save the best # model according to in-domain validation metrics, but as an oracle, save # the best according to ood validation metrics (or a proxy ood metric). if 'early_stop_dataset_names' in config: for name in config['early_stop_dataset_names']: - if name not in test_configs: + if name not in test_loaders: raise ValueError(f"{name} is not the name of a test dataset.") metric_name = 'test_acc/' + name - assert(metric_name in stats) - if metric_name not in best_acc or stats[metric_name] > best_acc[metric_name]: - best_acc[metric_name] = stats[metric_name] + assert(metric_name in test_stats) + if metric_name not in best_accs or test_stats[metric_name] > best_accs[metric_name]: + best_accs[metric_name] = test_stats[metric_name] checkpoint_name = 'ckp_best_' + name utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, checkpoint_name) utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_last') - utils.save_json(log_dir + '/best.json', best_stats) - - -def get_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, - loss_name_prefix, acc_name_prefix): - stats = {'epoch': epoch} - for name, test_loader in test_loaders.items(): - max_examples = float('infinity') - if name in max_test_examples: - max_examples = max_test_examples[name] - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device, - max_examples=max_examples) - stats[loss_name_prefix + name] = val_loss.get_mean() - stats[acc_name_prefix + name] = val_acc.get_mean() - return stats def make_new_dir(new_dir): @@ -386,8 +387,12 @@ def setup(): # Open config, update with command line args. config = quinine.Quinfig(args.config) utils.update_config(unparsed, config) + # We make specifying some things more convenient - we don't need to specify + # a transform for each test, but can specify a default transform. update_test_transform_configs(config) + # If linear probing, by default we turn batch-norm off while training, if unspecified. update_net_eval_mode(config) + # Note: copying config over is not that useful anymore with Quinine, so use json below. shutil.copy(args.config, log_dir+'/original_config.yaml') # Setup wandb. setup_wandb(args, config) From 1cf74186dee4bed8ca20002ca355dfc2b60a55af Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 01:48:23 -0700 Subject: [PATCH 029/197] Fix indent. --- experiments/baseline_train.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 022c30f..9bc776e 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -170,11 +170,11 @@ def should_log(log_interval): loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') if config['wandb']: wandb.log(stats) - reset_state(net, training_state) - train_stats = {'epoch': epoch} - for key in loss_dict: - train_stats[key] = loss_dict[key].get_mean() - return train_stats + reset_state(net, training_state) + train_stats = {'epoch': epoch} + for key in loss_dict: + train_stats[key] = loss_dict[key].get_mean() + return train_stats def get_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, From 27dfc69ab2b535e099874d3c802cc63f36b1254c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 02:34:45 -0700 Subject: [PATCH 030/197] Fix naming bug. --- experiments/baseline_train.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py index 9bc776e..9970913 100644 --- a/experiments/baseline_train.py +++ b/experiments/baseline_train.py @@ -165,7 +165,7 @@ def should_log(log_interval): (epoch + 1, num_examples, k, loss_dict[k].get_mean())) # Sometimes we want to log the test loss more often to track things better. if 'test_interval' in config and should_log(config['test_interval']): - stats = get_test_stats( + stats = get_all_test_stats( test_loaders, max_test_examples, config, net, criterion, device, loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') if config['wandb']: @@ -177,7 +177,7 @@ def should_log(log_interval): return train_stats -def get_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, +def get_all_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, loss_name_prefix, acc_name_prefix): stats = {'epoch': epoch} for name, test_loader in test_loaders.items(): @@ -244,7 +244,7 @@ def main(config, log_dir, checkpoints_dir): test_loaders, max_test_examples) scheduler.step() # Get test stats across all test sets. - test_stats = get_test_stats( + test_stats = get_all_test_stats( epoch, test_loaders, max_test_examples, config, net, criterion, device, loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') # Keep track of the best stats. @@ -269,6 +269,7 @@ def main(config, log_dir, checkpoints_dir): # model according to in-domain validation metrics, but as an oracle, save # the best according to ood validation metrics (or a proxy ood metric). if 'early_stop_dataset_names' in config: + logging.info(f"Early stopping using datasets {config['early_stop_dataset_names']}") for name in config['early_stop_dataset_names']: if name not in test_loaders: raise ValueError(f"{name} is not the name of a test dataset.") From 057a895219defa47f3a79718a458c4cf6c8a460a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 4 Apr 2021 02:44:47 -0700 Subject: [PATCH 031/197] Save best checkpoints for living17. --- configs/datasets_breeds_living.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/configs/datasets_breeds_living.yaml b/configs/datasets_breeds_living.yaml index 1939ea3..eb639c3 100644 --- a/configs/datasets_breeds_living.yaml +++ b/configs/datasets_breeds_living.yaml @@ -44,3 +44,7 @@ test_datasets: breeds_name: 'living17' root: '/u/scr/nlp/imagenet/' +early_stop_dataset_names: + - 'source_val_living' + - 'target_val_living' + From b54a27fe6fd7bc7d4ad7e30b164485daf6125ee0 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 5 Apr 2021 15:18:16 -0700 Subject: [PATCH 032/197] Add setup file --- setup.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100755 setup.py diff --git a/setup.py b/setup.py new file mode 100755 index 0000000..b1a0478 --- /dev/null +++ b/setup.py @@ -0,0 +1,26 @@ +from setuptools import setup, find_packages + +setup(name='', + version='0.0.1', + description='unlabeled_extrapolation', + url='https://github.com/p-lambda/unlabeled_extrapolation', + author='Kendrick Shen, Robbie Jones, Michael Xie, Ananya Kumar', + author_email='ananya@cs.stanford.edu', + packages=find_packages('.'), + install_requires=[ + 'matplotlib', + 'numpy', + 'torch==1.4.0', + 'torchvision==0.5.0', + 'tqdm', + 'pyyaml', + 'requests', + 'wandb', + 'pandas', + 'h5py', + 'strconv', + 'scikit-learn', + 'scipy', + 'cdsapi', + 'uncertainty-calibration', + ]) From 86f8459eff9986c450fd0807f46b81c41df4584c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 3 Apr 2022 22:27:30 -0700 Subject: [PATCH 033/197] Release (#2) Fine-tuning paper code release --- .gitignore | 146 +- README.md | 88 +- configs/adaptation/celeba.yaml | 19 + configs/adaptation/cifar_stl.yaml | 20 + configs/adaptation/cifar_stl_nonorm.yaml | 18 + configs/adaptation/datasets_celeba.yaml | 41 + configs/adaptation/datasets_cifar_stl.yaml | 52 + .../adaptation/datasets_cifar_stl_nonorm.yaml | 41 + configs/adaptation/datasets_domainnet.yaml | 69 + .../datasets_entity30.yaml} | 30 +- configs/adaptation/datasets_fmow.yaml | 51 + configs/adaptation/datasets_fmow_all.yaml | 58 + configs/adaptation/datasets_imagenet.yaml | 61 + .../adaptation/datasets_imagenet_augs.yaml | 56 + .../datasets_landcover_auxin_to_africa.yaml | 53 + .../datasets_landcover_to_africa.yaml | 49 + .../datasets_living17.yaml} | 31 +- .../datasets_living17_noaugs.yaml} | 43 +- .../adaptation/datasets_living17_nonorm.yaml | 47 + configs/adaptation/domainnet.yaml | 18 + configs/adaptation/entity30.yaml | 20 + configs/adaptation/fmow.yaml | 19 + configs/adaptation/fmow_all.yaml | 19 + configs/adaptation/imagenet.yaml | 18 + configs/adaptation/imagenet_augs.yaml | 19 + .../adaptation/landcover_auxin_to_africa.yaml | 18 + configs/adaptation/landcover_to_africa.yaml | 18 + configs/adaptation/landcover_transfer.yaml | 22 + configs/adaptation/living17.yaml | 17 + configs/adaptation/living17_noaugs.yaml | 17 + configs/adaptation/living17_nonorm.yaml | 18 + configs/adaptation/resnet50_transfer.yaml | 23 + configs/breeds_living_finetuning.yaml | 17 - configs/breeds_living_moco_finetuning.yaml | 24 - configs/breeds_living_moco_probe.yaml | 24 - configs/breeds_living_probe.yaml | 10 - configs/cifar_resnet_baseline.yaml | 51 - configs/datasets_cifar_test_all.yaml | 155 -- configs/e30_sup_ft.yaml | 17 - configs/e30_sup_probe.yaml | 10 - configs/e30_swav_ft_augment.yaml | 47 - configs/entity30_moco_finetuning.yaml | 7 - configs/entity30_moco_probe.yaml | 7 - configs/imnet_cifar_all_finetune.yaml | 17 - configs/imnet_cifar_all_probe.yaml | 10 - .../imnet_finetune_cifar_resnet_baseline.yaml | 71 - .../imnet_finetune_cifar_resnet_creafz.yaml | 79 - ...netune_cifar_resnet_fixed_lr_test_stl.yaml | 91 -- ...t_finetune_cifar_resnet_test_cifar10c.yaml | 143 -- .../imnet_finetune_cifar_resnet_test_stl.yaml | 82 -- ...nprobe_cifar_resnet_fixed_lr_test_stl.yaml | 95 -- ...t_linprobe_cifar_resnet_test_cifar10c.yaml | 145 -- .../imnet_linprobe_cifar_resnet_test_stl.yaml | 95 -- ...probe_noaugment_cifar_resnet_test_stl.yaml | 90 -- .../imnet_probe_cifar_resnet_test_stl.yaml | 90 -- configs/old/small_cifar_resnet_baseline.yaml | 53 - .../small_cifar_resnet_frozenfeatures.yaml | 56 - configs/old/small_cifar_resnet_merlin.yaml | 56 - configs/resnet50_transfer.yaml | 33 - experiments/baseline_train.py | 412 ------ .../breeds_example-checkpoint.ipynb | 178 --- .../cifar10c_stl_examples-checkpoint.ipynb | 176 --- ...Combining models using uncertainties.ipynb | 1277 ---------------- scripts/breeds_example.ipynb | 126 -- scripts/cifar10c_stl_examples.ipynb | 532 ------- scripts/cifar_notebook.ipynb | 289 ---- scripts/cinic_imagenet_extractor.ipynb | 118 -- scripts/copy_dataset.sh | 136 ++ scripts/copy_local.sh | 16 + scripts/moco_simclr_loading.ipynb | 541 ------- scripts/run_adaptation_experiments.py | 1304 +++++++++++++++++ scripts/run_cpu_sbatch.sh | 17 + scripts/run_micro_sbatch.sh | 19 + scripts/run_rtx_sbatch.sh | 19 + scripts/run_sbatch.sh | 20 + scripts/run_sphinx_sbatch.sh | 20 + scripts/summarize_all_results.py | 104 ++ scripts/summarize_linprobe_results.py | 72 + scripts/summarize_results.py | 150 ++ scripts/update_dataset_acl.sh | 10 + setup.py | 19 +- .../.baseline_train.py.swn | Bin 0 -> 16384 bytes .../.baseline_train.py.swo | Bin 0 -> 57344 bytes .../__init__.py | 0 unlabeled_extrapolation/baseline_train.py | 655 +++++++++ unlabeled_extrapolation/datasets/__init__.py | 0 .../datasets}/breeds.py | 20 +- unlabeled_extrapolation/datasets/celeba.py | 183 +++ .../datasets/check_breeds.ipynb | 169 +++ .../datasets}/cifar10_resized.py | 0 .../datasets}/cifar10c.py | 0 unlabeled_extrapolation/datasets/cifar10p1.py | 62 + .../datasets}/cinic.py | 0 .../datasets/connectivity_utils.py | 280 ++++ unlabeled_extrapolation/datasets/domainnet.py | 99 ++ unlabeled_extrapolation/datasets/fmow.py | 39 + unlabeled_extrapolation/datasets/imagenet.py | 55 + .../datasets}/imnet_intersect_c10.py | 0 unlabeled_extrapolation/datasets/landcover.py | 612 ++++++++ unlabeled_extrapolation/datasets/looping.py | 18 + .../datasets/range_dataset.py | 22 + .../datasets}/stl_cifar_style.py | 0 .../datasets/transforms.py | 14 + unlabeled_extrapolation/extract_features.py | 202 +++ unlabeled_extrapolation/log_reg_sk.py | 153 ++ unlabeled_extrapolation/models/__init__.py | 1 + unlabeled_extrapolation/models/clip_model.py | 113 ++ .../models/imnet_models.py | 70 + .../models}/imnet_resnet.py | 47 +- .../models/innout_models.py | 344 +++++ .../models}/mlp.py | 0 unlabeled_extrapolation/models/model_utils.py | 12 + .../models}/resnet.py | 0 .../models}/swav_resnet50.py | 0 unlabeled_extrapolation/models/vit_model.py | 60 + unlabeled_extrapolation/utils/__init__.py | 0 .../utils}/accumulator.py | 0 unlabeled_extrapolation/utils/data_utils.py | 91 ++ .../utils}/merlin.py | 0 unlabeled_extrapolation/utils/multi.py | 76 + .../utils}/utils.py | 2 +- 121 files changed, 6470 insertions(+), 5278 deletions(-) create mode 100644 configs/adaptation/celeba.yaml create mode 100644 configs/adaptation/cifar_stl.yaml create mode 100644 configs/adaptation/cifar_stl_nonorm.yaml create mode 100644 configs/adaptation/datasets_celeba.yaml create mode 100644 configs/adaptation/datasets_cifar_stl.yaml create mode 100644 configs/adaptation/datasets_cifar_stl_nonorm.yaml create mode 100644 configs/adaptation/datasets_domainnet.yaml rename configs/{datasets_breeds_entity30.yaml => adaptation/datasets_entity30.yaml} (58%) create mode 100644 configs/adaptation/datasets_fmow.yaml create mode 100644 configs/adaptation/datasets_fmow_all.yaml create mode 100644 configs/adaptation/datasets_imagenet.yaml create mode 100644 configs/adaptation/datasets_imagenet_augs.yaml create mode 100644 configs/adaptation/datasets_landcover_auxin_to_africa.yaml create mode 100644 configs/adaptation/datasets_landcover_to_africa.yaml rename configs/{datasets_breeds_living.yaml => adaptation/datasets_living17.yaml} (60%) rename configs/{e30_swav_probe_augment.yaml => adaptation/datasets_living17_noaugs.yaml} (55%) create mode 100644 configs/adaptation/datasets_living17_nonorm.yaml create mode 100644 configs/adaptation/domainnet.yaml create mode 100644 configs/adaptation/entity30.yaml create mode 100644 configs/adaptation/fmow.yaml create mode 100644 configs/adaptation/fmow_all.yaml create mode 100644 configs/adaptation/imagenet.yaml create mode 100644 configs/adaptation/imagenet_augs.yaml create mode 100644 configs/adaptation/landcover_auxin_to_africa.yaml create mode 100644 configs/adaptation/landcover_to_africa.yaml create mode 100644 configs/adaptation/landcover_transfer.yaml create mode 100644 configs/adaptation/living17.yaml create mode 100644 configs/adaptation/living17_noaugs.yaml create mode 100644 configs/adaptation/living17_nonorm.yaml create mode 100644 configs/adaptation/resnet50_transfer.yaml delete mode 100644 configs/breeds_living_finetuning.yaml delete mode 100644 configs/breeds_living_moco_finetuning.yaml delete mode 100644 configs/breeds_living_moco_probe.yaml delete mode 100644 configs/breeds_living_probe.yaml delete mode 100644 configs/cifar_resnet_baseline.yaml delete mode 100644 configs/datasets_cifar_test_all.yaml delete mode 100644 configs/e30_sup_ft.yaml delete mode 100644 configs/e30_sup_probe.yaml delete mode 100644 configs/e30_swav_ft_augment.yaml delete mode 100644 configs/entity30_moco_finetuning.yaml delete mode 100644 configs/entity30_moco_probe.yaml delete mode 100644 configs/imnet_cifar_all_finetune.yaml delete mode 100644 configs/imnet_cifar_all_probe.yaml delete mode 100644 configs/old/imnet_finetune_cifar_resnet_baseline.yaml delete mode 100644 configs/old/imnet_finetune_cifar_resnet_creafz.yaml delete mode 100644 configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml delete mode 100644 configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml delete mode 100644 configs/old/imnet_finetune_cifar_resnet_test_stl.yaml delete mode 100644 configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml delete mode 100644 configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml delete mode 100644 configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml delete mode 100644 configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml delete mode 100644 configs/old/imnet_probe_cifar_resnet_test_stl.yaml delete mode 100644 configs/old/small_cifar_resnet_baseline.yaml delete mode 100644 configs/old/small_cifar_resnet_frozenfeatures.yaml delete mode 100644 configs/old/small_cifar_resnet_merlin.yaml delete mode 100644 configs/resnet50_transfer.yaml delete mode 100644 experiments/baseline_train.py delete mode 100644 scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb delete mode 100644 scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb delete mode 100644 scripts/Combining models using uncertainties.ipynb delete mode 100644 scripts/breeds_example.ipynb delete mode 100644 scripts/cifar10c_stl_examples.ipynb delete mode 100644 scripts/cifar_notebook.ipynb delete mode 100644 scripts/cinic_imagenet_extractor.ipynb create mode 100755 scripts/copy_dataset.sh create mode 100644 scripts/copy_local.sh delete mode 100644 scripts/moco_simclr_loading.ipynb create mode 100644 scripts/run_adaptation_experiments.py create mode 100644 scripts/run_cpu_sbatch.sh create mode 100644 scripts/run_micro_sbatch.sh create mode 100644 scripts/run_rtx_sbatch.sh create mode 100644 scripts/run_sbatch.sh create mode 100644 scripts/run_sphinx_sbatch.sh create mode 100644 scripts/summarize_all_results.py create mode 100644 scripts/summarize_linprobe_results.py create mode 100644 scripts/summarize_results.py create mode 100644 scripts/update_dataset_acl.sh create mode 100644 unlabeled_extrapolation/.baseline_train.py.swn create mode 100644 unlabeled_extrapolation/.baseline_train.py.swo rename {datasets => unlabeled_extrapolation}/__init__.py (100%) create mode 100644 unlabeled_extrapolation/baseline_train.py create mode 100644 unlabeled_extrapolation/datasets/__init__.py rename {datasets => unlabeled_extrapolation/datasets}/breeds.py (87%) create mode 100644 unlabeled_extrapolation/datasets/celeba.py create mode 100644 unlabeled_extrapolation/datasets/check_breeds.ipynb rename {datasets => unlabeled_extrapolation/datasets}/cifar10_resized.py (100%) rename {datasets => unlabeled_extrapolation/datasets}/cifar10c.py (100%) create mode 100644 unlabeled_extrapolation/datasets/cifar10p1.py rename {datasets => unlabeled_extrapolation/datasets}/cinic.py (100%) create mode 100644 unlabeled_extrapolation/datasets/connectivity_utils.py create mode 100644 unlabeled_extrapolation/datasets/domainnet.py create mode 100644 unlabeled_extrapolation/datasets/fmow.py create mode 100644 unlabeled_extrapolation/datasets/imagenet.py rename {datasets => unlabeled_extrapolation/datasets}/imnet_intersect_c10.py (100%) create mode 100644 unlabeled_extrapolation/datasets/landcover.py create mode 100644 unlabeled_extrapolation/datasets/looping.py create mode 100644 unlabeled_extrapolation/datasets/range_dataset.py rename {datasets => unlabeled_extrapolation/datasets}/stl_cifar_style.py (100%) create mode 100644 unlabeled_extrapolation/datasets/transforms.py create mode 100644 unlabeled_extrapolation/extract_features.py create mode 100644 unlabeled_extrapolation/log_reg_sk.py create mode 100644 unlabeled_extrapolation/models/__init__.py create mode 100644 unlabeled_extrapolation/models/clip_model.py create mode 100644 unlabeled_extrapolation/models/imnet_models.py rename {models => unlabeled_extrapolation/models}/imnet_resnet.py (61%) create mode 100644 unlabeled_extrapolation/models/innout_models.py rename {models => unlabeled_extrapolation/models}/mlp.py (100%) create mode 100644 unlabeled_extrapolation/models/model_utils.py rename {models => unlabeled_extrapolation/models}/resnet.py (100%) rename {models => unlabeled_extrapolation/models}/swav_resnet50.py (100%) create mode 100644 unlabeled_extrapolation/models/vit_model.py create mode 100644 unlabeled_extrapolation/utils/__init__.py rename {utils => unlabeled_extrapolation/utils}/accumulator.py (100%) create mode 100644 unlabeled_extrapolation/utils/data_utils.py rename {utils => unlabeled_extrapolation/utils}/merlin.py (100%) create mode 100644 unlabeled_extrapolation/utils/multi.py rename {utils => unlabeled_extrapolation/utils}/utils.py (99%) diff --git a/.gitignore b/.gitignore index 1328a96..a4ef01b 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,148 @@ *.swp logs/* wandb/* -.ipynb_checkpoints/* +led / 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 + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__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/.ipynb_checkpoints/* + +logs/ +checkpoints/ +swav/*.out +*.out +/results/ +*~ diff --git a/README.md b/README.md index 1d74061..0668202 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,86 @@ +## Steps to run an experiment + +The first time you run this project, in the current directory, which contains README, create a virtualenv: +``` +python3 -m venv .env +source .env/bin/activate +pip install -f https://download.pytorch.org/whl/torch_stable.html -e . +``` +In subsequent runs you only need to activate the environment: +``` +source .env/bin/activate +``` + +Also login to weights and biases. Usually you don't have to re-run this and it remembers the login, even across sessions: +``` +wandb login +wandb on +``` + +### Alternative: +Use the `eix-ue` conda env. Make sure you have this following code in your `.bashrc`: +``` +# >>> conda initialize >>> +# !! Contents within this block are managed by 'conda init' !! +__conda_setup="$('/u/nlp/anaconda/main/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)" +if [ $? -eq 0 ]; then + eval "$__conda_setup" +else + if [ -f "/u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh" ]; then + . "/u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh" + else + export PATH="/u/nlp/anaconda/main/anaconda3/bin:$PATH" + fi +fi +unset __conda_setup +# <<< conda initialize <<< +``` + +## Configs + +The main script is in `experiments/baseline_train.py`. The script requires a YAML config +file - an example is `configs/breeds_living_moco_probe.yaml`. +To dynamically change values of the config file with command line arguments, +simply add new arguments of the form `--key=val` where the key can be any +string of multiple keys separated by periods. This is to allow for changing +nested components of the config file. For example `--model.args.depth=3` changes +the config dictionary in this way: `config['model']['args']['depth'] = 3`. +It is important that the key and value are separated by an equals sign. + +We use Quinine so you can inherit other configs. +This makes things modularized if you have configs for a few datasets, and configs for a few models. +Try not to make these nested by more than one or two levels +(A inherits B, B inherits C, C inherits D, etc) + +If you base your config off of `configs/breeds_living_moco_probe.yaml` here are some important +args to keep in mind: +- finetune: If fine-tuning, this should be True. +- linear_probe: If only training the last linear layer (freeze lower layers), set True, for full fine-tuning set False +- use_net_val_mode: True if you want to keep the network in "val" mode while training. This should usually be True for linear probing, to turn off batchnorm. +- num_classes: Specifies the number of classes in the new task you're fine-tuning on. + +Notice that we inherit datasets_breeds_living.yaml, where we have: +- A train dataset, which we initialize using args, including a transform +- We specify a list of transforms, which are applied top to bottom +- We have a list of test_datasets, and we evaluate performance on all of these. +- Each test dataest has a name, which is used both for visualization, and to decide which ones to early stop on +- If a test_transform is not specified, it uses the default_test_transform for the test dataset +- You can also add "transforms" as a separate field for a test dataset, and we'll use that instead of default_test_transform +- We specify early_stop_dataset_names. We don't literally stop the experiment. But we save the best model checkpoint according to the accuracy on these datasets. If multiple datasets are specified, we save the best checkpoint according to each of these. E.g. you can have one where you early stop on in-domain validation, and an oracle model where you early stop on the OOD validation. + +We also inherit resnet50_transfer.yaml which specifies the scheduler, learning rate, loss criterion, and a few other things that should be self-explanatory. Some things of note: +- log_interval is after how many training examples we log the training loss. This is cheap since we keep track of a rolling average in the epoch and output that. +- save_freq is how often we should save checkpoints besides the best checkpoint. For these experiments, the config sets this to a high number so we don't save checkpoints besides the initial, final, and best (saving disk space) +- model.args.pretrained is True, indicating that we initialize from a supervised Resnet50 model (pre-trained on ImageNet labels) + +## Example run + +``` +export PYTHONPATH="." +. env/bin/python experiments/baseline_train.py --config=configs/breeds_living_moco_probe.yaml \\ +--log_dir=logs/breeds_moco_linprobe_0.003 --project_name=breeds --group_name=breeds_moco_linprobe \\ +--run_name=breeds_moco_linprobe_0.003 --optimizer.args.lr=0.003 +``` # A Lightweight Framework for Training Models @@ -17,8 +100,3 @@ Setup: - Create a weights and biases account - Run "wandb login" and "wandb on" -To fine-tune an ImageNet model on CIFAR, run: -python experiments/baseline_train.py --config=configs/imnet_finetune_cifar_resnet_baseline.yaml --log_dir=logs/inet_ft_run_0 --project_name=cifar group_name=inet_ft --run_name=run_0 - -On jag: -jag "export PYTHONPATH="."; ../env/bin/python experiments/baseline_train.py --config=configs/imnet_finetune_cifar_resnet_baseline.yaml --log_dir=logs/inet_ft_run_2 --project_name=cifar group_name=inet_ft --run_name=run_2" diff --git a/configs/adaptation/celeba.yaml b/configs/adaptation/celeba.yaml new file mode 100644 index 0000000..6aee9b8 --- /dev/null +++ b/configs/adaptation/celeba.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_celeba.yaml + +num_classes: 2 +epochs: &epochs 10 # Maybe increase this later. +batch_size: 32 # so we can run ViT on all jags. +save_model_preds: True # Save all model predictions. + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/cifar_stl.yaml b/configs/adaptation/cifar_stl.yaml new file mode 100644 index 0000000..83f005e --- /dev/null +++ b/configs/adaptation/cifar_stl.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_cifar_stl.yaml + +num_classes: 10 +epochs: &epochs 20 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/cifar_stl_nonorm.yaml b/configs/adaptation/cifar_stl_nonorm.yaml new file mode 100644 index 0000000..f4daf3f --- /dev/null +++ b/configs/adaptation/cifar_stl_nonorm.yaml @@ -0,0 +1,18 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_cifar_stl_nonorm.yaml + +num_classes: 10 +epochs: &epochs 20 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/datasets_celeba.yaml b/configs/adaptation/datasets_celeba.yaml new file mode 100644 index 0000000..31520db --- /dev/null +++ b/configs/adaptation/datasets_celeba.yaml @@ -0,0 +1,41 @@ + +root_prefix: '/u/scr/ananya/' + +train_dataset: + name: 'train' + classname: datasets.celeba.CelebA + args: + target_attribute: 'Wearing_Earrings' + split: 'train' + # pickle_file_path: 'celeba_pickle/celeba_full_pickle' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +default_test_args: + target_attribute: 'Wearing_Earrings' + +test_datasets: + - name: 'val' + classname: datasets.celeba.CelebA + args: + split: 'val' + # pickle_file_path: 'celeba_pickle/celeba_full_pickle' + - name: 'test' + classname: datasets.celeba.CelebA + args: + split: 'test' + # pickle_file_path: 'celeba_pickle/celeba_full_pickle' + +early_stop_dataset_names: + - 'val' + - 'test' + diff --git a/configs/adaptation/datasets_cifar_stl.yaml b/configs/adaptation/datasets_cifar_stl.yaml new file mode 100644 index 0000000..7c14df6 --- /dev/null +++ b/configs/adaptation/datasets_cifar_stl.yaml @@ -0,0 +1,52 @@ + +root_prefix: '/u/scr/ananya/' + +train_dataset: + name: 'cifar-train' + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: 'cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: 'cifar10_dataset/' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: 'stl10_dataset/' + split: 'test' + - name: 'imnet-n-cifar' + classname: datasets.imnet_intersect_c10.ImNetnC10 + args: + root: 'balanced_imnet_intersect_c10_val/' + +early_stop_dataset_names: + - 'cifar10-test' + - 'stl-test' + - 'imnet-n-cifar' + diff --git a/configs/adaptation/datasets_cifar_stl_nonorm.yaml b/configs/adaptation/datasets_cifar_stl_nonorm.yaml new file mode 100644 index 0000000..04dc3d2 --- /dev/null +++ b/configs/adaptation/datasets_cifar_stl_nonorm.yaml @@ -0,0 +1,41 @@ + +root_prefix: '/u/scr/ananya/' + +train_dataset: + name: 'cifar-train' + classname: torchvision.datasets.CIFAR10 + args: + train: True + download: False + root: 'cifar10_dataset' + transforms: + - classname: torchvision.transforms.Resize + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'cifar10-test' + classname: torchvision.datasets.CIFAR10 + args: + train: False + download: False + root: 'cifar10_dataset/' + - name: 'stl-test' + classname: datasets.stl_cifar_style.STL10 + args: + root: 'stl10_dataset/' + split: 'test' + - name: 'imnet-n-cifar' + classname: datasets.imnet_intersect_c10.ImNetnC10 + args: + root: 'balanced_imnet_intersect_c10_val/' + +early_stop_dataset_names: {} + diff --git a/configs/adaptation/datasets_domainnet.yaml b/configs/adaptation/datasets_domainnet.yaml new file mode 100644 index 0000000..88a576b --- /dev/null +++ b/configs/adaptation/datasets_domainnet.yaml @@ -0,0 +1,69 @@ + +root_prefix: '/scr/biggest/' + +# The train and test transforms are taken from Sentry. +# Except the normalization and the bicubic resampling, taken from CLIP. +train_dataset: + name: 'sketch_train' + classname: unlabeled_extrapolation.datasets.domainnet.DomainNet + args: + domain: 'sketch' + split: 'train' + root: 'domainnet/' + version: 'sentry' + verbose: False + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [256, 256] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [224, 224] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'sketch_val' + classname: unlabeled_extrapolation.datasets.domainnet.DomainNet + args: + domain: 'sketch' + split: 'test' + root: 'domainnet/' + version: 'sentry' + verbose: False + - name: 'real_val' + classname: unlabeled_extrapolation.datasets.domainnet.DomainNet + args: + domain: 'real' + split: 'test' + root: 'domainnet/' + version: 'sentry' + verbose: False + - name: 'painting_val' + classname: unlabeled_extrapolation.datasets.domainnet.DomainNet + args: + domain: 'painting' + split: 'test' + root: 'domainnet/' + version: 'sentry' + verbose: False + - name: 'clipart_val' + classname: unlabeled_extrapolation.datasets.domainnet.DomainNet + args: + domain: 'clipart' + split: 'test' + root: 'domainnet/' + version: 'sentry' + verbose: False + +early_stop_dataset_names: + - 'sketch_val' + - 'real_val' diff --git a/configs/datasets_breeds_entity30.yaml b/configs/adaptation/datasets_entity30.yaml similarity index 58% rename from configs/datasets_breeds_entity30.yaml rename to configs/adaptation/datasets_entity30.yaml index 8e31f25..dadc958 100644 --- a/configs/datasets_breeds_entity30.yaml +++ b/configs/adaptation/datasets_entity30.yaml @@ -1,30 +1,38 @@ +root_prefix: '/scr/biggest/' + +# The train and test transforms are taken from the Swav fine-tuning script. train_dataset: + name: 'source_train_entity' classname: datasets.breeds.Breeds args: source: True split: 'train' breeds_name: 'entity30' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' transforms: - - classname: torchvision.transforms.Resize + - classname: torchvision.transforms.RandomResizedCrop args: - size: [224, 224] + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize args: mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] + std: [0.228, 0.224, 0.225] default_test_transforms: - classname: torchvision.transforms.Resize args: - size: [224, 224] + size: 256 + - classname: torchvision.transforms.CenterCrop + args: + size: 224 - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize args: mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] + std: [0.228, 0.224, 0.225] test_datasets: - name: 'source_val_entity' @@ -33,11 +41,17 @@ test_datasets: source: True split: 'val' breeds_name: 'entity30' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' - name: 'target_val_entity' classname: datasets.breeds.Breeds args: source: False + target: True split: 'val' breeds_name: 'entity30' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' + +early_stop_dataset_names: + - 'source_val_entity' + - 'target_val_entity' + diff --git a/configs/adaptation/datasets_fmow.yaml b/configs/adaptation/datasets_fmow.yaml new file mode 100644 index 0000000..7679ea3 --- /dev/null +++ b/configs/adaptation/datasets_fmow.yaml @@ -0,0 +1,51 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'fmow-train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: [3] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.2289, 0.224, 0.225] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'europe_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: [1] + root: 'wilds/data' + - name: 'africa_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: [2] + root: 'wilds/data' + - name: 'americas_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: [3] + root: 'wilds/data' + +early_stop_dataset_names: + - 'americas_val' + - 'africa_val' diff --git a/configs/adaptation/datasets_fmow_all.yaml b/configs/adaptation/datasets_fmow_all.yaml new file mode 100644 index 0000000..c0e6ef9 --- /dev/null +++ b/configs/adaptation/datasets_fmow_all.yaml @@ -0,0 +1,58 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.2289, 0.224, 0.225] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.229, 0.224, 0.225] + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'ood_val' + regions: ['all'] + root: 'wilds/data' + - name: 'test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_imagenet.yaml b/configs/adaptation/datasets_imagenet.yaml new file mode 100644 index 0000000..3b6c8b9 --- /dev/null +++ b/configs/adaptation/datasets_imagenet.yaml @@ -0,0 +1,61 @@ + +root_prefix: '' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'train' + classname: datasets.imagenet.ImageNet + args: + root: '/scr/biggest/imagenet/' + split: 'train' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'val' + classname: datasets.imagenet.ImageNet + args: + root: '/scr/biggest/imagenet/' + split: 'val' + - name: 'renditions' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenet-r' + - name: 'imagenet-a' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenet-a' + - name: 'v2' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenetv2-matched-frequency-format-val' + - name: 'sketch' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'sketch' + + +early_stop_dataset_names: + - 'val' + diff --git a/configs/adaptation/datasets_imagenet_augs.yaml b/configs/adaptation/datasets_imagenet_augs.yaml new file mode 100644 index 0000000..1592f74 --- /dev/null +++ b/configs/adaptation/datasets_imagenet_augs.yaml @@ -0,0 +1,56 @@ + +root_prefix: '' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'train' + classname: datasets.imagenet.ImageNet + args: + root: '/scr/biggest/imagenet/' + split: 'train' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 256 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'val' + classname: datasets.imagenet.ImageNet + args: + root: '/scr/biggest/imagenet/' + split: 'val' + - name: 'renditions' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenet-r' + - name: 'imagenet-a' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenet-a' + - name: 'v2' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'imagenetv2-matched-frequency-format-val' + - name: 'sketch' + classname: datasets.imagenet.ImageNet + args: + root: '/u/scr/nlp/imagenet/' + split: 'sketch' + +early_stop_dataset_names: + - 'val' diff --git a/configs/adaptation/datasets_landcover_auxin_to_africa.yaml b/configs/adaptation/datasets_landcover_auxin_to_africa.yaml new file mode 100644 index 0000000..7ee4b5e --- /dev/null +++ b/configs/adaptation/datasets_landcover_auxin_to_africa.yaml @@ -0,0 +1,53 @@ + +root_prefix: '/u/scr/nlp/eix/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-train' + include_ERA5: True + transforms: [] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: [] + +test_datasets: + - name: 'nonafrica-val' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-val' + include_ERA5: True + - name: 'nonafrica-test' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-test' + include_ERA5: True + - name: 'africa' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'africa' + include_ERA5: True + +early_stop_dataset_names: + - 'nonafrica-val' + - 'africa' + diff --git a/configs/adaptation/datasets_landcover_to_africa.yaml b/configs/adaptation/datasets_landcover_to_africa.yaml new file mode 100644 index 0000000..51df82e --- /dev/null +++ b/configs/adaptation/datasets_landcover_to_africa.yaml @@ -0,0 +1,49 @@ + +root_prefix: '/u/scr/nlp/eix/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-train' + transforms: [] + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: [] + +test_datasets: + - name: 'nonafrica-val' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-val' + - name: 'nonafrica-test' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'nonafrica-test' + - name: 'africa' + classname: datasets.landcover.Landcover + args: + root: 'landcover/timeseries_by_box_v2' + cache_path: 'landcover/landcover_v2.pkl' + seed: 1111 + unlabeled_prop: 0.9 + split: 'africa' + +early_stop_dataset_names: + - 'nonafrica-val' + - 'africa' + diff --git a/configs/datasets_breeds_living.yaml b/configs/adaptation/datasets_living17.yaml similarity index 60% rename from configs/datasets_breeds_living.yaml rename to configs/adaptation/datasets_living17.yaml index eb639c3..7f58e1f 100644 --- a/configs/datasets_breeds_living.yaml +++ b/configs/adaptation/datasets_living17.yaml @@ -1,50 +1,57 @@ +root_prefix: '/scr/biggest/' + +# The train and test transforms are taken from the Swav fine-tuning script. train_dataset: + name: 'source_train_living' classname: datasets.breeds.Breeds args: source: True split: 'train' breeds_name: 'living17' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' transforms: - - classname: torchvision.transforms.Resize + - classname: torchvision.transforms.RandomResizedCrop args: - size: [224, 224] + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize args: mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] + std: [0.228, 0.224, 0.225] default_test_transforms: - classname: torchvision.transforms.Resize args: - size: [224, 224] + size: 256 + - classname: torchvision.transforms.CenterCrop + args: + size: 224 - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize args: mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] + std: [0.228, 0.224, 0.225] test_datasets: - name: 'source_val_living' - max_test_examples: 1000 classname: datasets.breeds.Breeds args: source: True split: 'val' breeds_name: 'living17' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' - name: 'target_val_living' - max_test_examples: 1000 classname: datasets.breeds.Breeds args: source: False + target: True split: 'val' breeds_name: 'living17' - root: '/u/scr/nlp/imagenet/' + root: 'imagenet/' early_stop_dataset_names: - - 'source_val_living' - - 'target_val_living' + - 'source_val_living' + - 'target_val_living' diff --git a/configs/e30_swav_probe_augment.yaml b/configs/adaptation/datasets_living17_noaugs.yaml similarity index 55% rename from configs/e30_swav_probe_augment.yaml rename to configs/adaptation/datasets_living17_noaugs.yaml index 8131a07..39dfb57 100644 --- a/configs/e30_swav_probe_augment.yaml +++ b/configs/adaptation/datasets_living17_noaugs.yaml @@ -1,25 +1,15 @@ -inherit: - - breeds_living_moco_probe.yaml - - datasets_breeds_entity30.yaml +root_prefix: '/scr/biggest/' -num_classes: 30 - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - pretrain_style: 'swav' - checkpoint_path: '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar' - -# Add augmentations, and change normalization a bit. +# The train and test transforms are taken from the Swav fine-tuning script. train_dataset: + name: 'source_train_living' classname: datasets.breeds.Breeds args: source: True split: 'train' - breeds_name: 'entity30' - root: '/u/scr/nlp/imagenet/' + breeds_name: 'living17' + root: 'imagenet/' transforms: - classname: torchvision.transforms.RandomResizedCrop args: @@ -31,7 +21,7 @@ train_dataset: mean: [0.485, 0.456, 0.406] std: [0.228, 0.224, 0.225] -# Change transform (e.g. centercrop), and change normalization a bit. + default_test_transforms: - classname: torchvision.transforms.Resize args: @@ -45,3 +35,24 @@ default_test_transforms: mean: [0.485, 0.456, 0.406] std: [0.228, 0.224, 0.225] +test_datasets: + - name: 'source_val_living' + classname: datasets.breeds.Breeds + args: + source: True + split: 'val' + breeds_name: 'living17' + root: 'imagenet/' + - name: 'target_val_living' + classname: datasets.breeds.Breeds + args: + source: False + target: True + split: 'val' + breeds_name: 'living17' + root: 'imagenet/' + +early_stop_dataset_names: + - 'source_val_living' + - 'target_val_living' + diff --git a/configs/adaptation/datasets_living17_nonorm.yaml b/configs/adaptation/datasets_living17_nonorm.yaml new file mode 100644 index 0000000..0a1e977 --- /dev/null +++ b/configs/adaptation/datasets_living17_nonorm.yaml @@ -0,0 +1,47 @@ + +root_prefix: '/scr/biggest/' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'source_train_living' + classname: datasets.breeds.Breeds + args: + source: True + split: 'train' + breeds_name: 'living17' + root: 'imagenet/' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: 256 + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'source_val_living' + classname: datasets.breeds.Breeds + args: + source: True + split: 'val' + breeds_name: 'living17' + root: 'imagenet/' + - name: 'target_val_living' + classname: datasets.breeds.Breeds + args: + source: False + target: True + split: 'val' + breeds_name: 'living17' + root: 'imagenet/' + +early_stop_dataset_names: {} + diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml new file mode 100644 index 0000000..e99fdaa --- /dev/null +++ b/configs/adaptation/domainnet.yaml @@ -0,0 +1,18 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_domainnet.yaml + +num_classes: 40 +epochs: &epochs 50 # Very small dataset so run for longer. + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'RN50' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/entity30.yaml b/configs/adaptation/entity30.yaml new file mode 100644 index 0000000..486c6a5 --- /dev/null +++ b/configs/adaptation/entity30.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_entity30.yaml + +num_classes: 30 +epochs: &epochs 20 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/fmow.yaml b/configs/adaptation/fmow.yaml new file mode 100644 index 0000000..11072f2 --- /dev/null +++ b/configs/adaptation/fmow.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow.yaml + +num_classes: 62 +epochs: &epochs 50 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '/u/scr/ananya/simclr_weights/mocotp_checkpoint_0200.pth.tar' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/fmow_all.yaml b/configs/adaptation/fmow_all.yaml new file mode 100644 index 0000000..0165bed --- /dev/null +++ b/configs/adaptation/fmow_all.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all.yaml + +num_classes: 62 +epochs: &epochs 20 + +model: + classname: models.imnet_resnet.ResNet50 + args: + pretrained: True + pretrain_style: 'mocov2' + checkpoint_path: '/u/scr/ananya/simclr_weights/mocotp_checkpoint_0200.pth.tar' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/imagenet.yaml b/configs/adaptation/imagenet.yaml new file mode 100644 index 0000000..f567c91 --- /dev/null +++ b/configs/adaptation/imagenet.yaml @@ -0,0 +1,18 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_imagenet.yaml + +num_classes: 1000 +epochs: &epochs 10 +batch_size: 128 + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'RN50' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/imagenet_augs.yaml b/configs/adaptation/imagenet_augs.yaml new file mode 100644 index 0000000..0e440d9 --- /dev/null +++ b/configs/adaptation/imagenet_augs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_imagenet_augs.yaml + +num_classes: 1000 +epochs: &epochs 10 +batch_size: 128 + # save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'RN50' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/landcover_auxin_to_africa.yaml b/configs/adaptation/landcover_auxin_to_africa.yaml new file mode 100644 index 0000000..a962538 --- /dev/null +++ b/configs/adaptation/landcover_auxin_to_africa.yaml @@ -0,0 +1,18 @@ + +inherit: + - landcover_transfer.yaml + - datasets_landcover_auxin_to_africa.yaml + +num_classes: 6 +epochs: &epochs 400 + +model: + classname: models.innout_models.CNN1D + args: + in_channels: 14 + output_size: 6 + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/landcover_to_africa.yaml b/configs/adaptation/landcover_to_africa.yaml new file mode 100644 index 0000000..8c83bef --- /dev/null +++ b/configs/adaptation/landcover_to_africa.yaml @@ -0,0 +1,18 @@ + +inherit: + - landcover_transfer.yaml + - datasets_landcover_to_africa.yaml + +num_classes: 6 +epochs: &epochs 400 + +model: + classname: models.innout_models.CNN1D + args: + in_channels: 8 + output_size: 6 + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/landcover_transfer.yaml b/configs/adaptation/landcover_transfer.yaml new file mode 100644 index 0000000..6ca909e --- /dev/null +++ b/configs/adaptation/landcover_transfer.yaml @@ -0,0 +1,22 @@ + +log_interval: 5000 +use_cuda: True +save_freq: 1001 +batch_size: 64 +num_workers: 2 +save_all_checkpoints: False + +finetune: True +linear_probe: False +use_net_val_mode: False + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.03 + momentum: 0.9 + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean diff --git a/configs/adaptation/living17.yaml b/configs/adaptation/living17.yaml new file mode 100644 index 0000000..a24583f --- /dev/null +++ b/configs/adaptation/living17.yaml @@ -0,0 +1,17 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_living17.yaml + +num_classes: 17 +epochs: &epochs 20 + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/living17_noaugs.yaml b/configs/adaptation/living17_noaugs.yaml new file mode 100644 index 0000000..3621157 --- /dev/null +++ b/configs/adaptation/living17_noaugs.yaml @@ -0,0 +1,17 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_living17_noaugs.yaml + +num_classes: 17 +epochs: &epochs 20 + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/living17_nonorm.yaml b/configs/adaptation/living17_nonorm.yaml new file mode 100644 index 0000000..e345e80 --- /dev/null +++ b/configs/adaptation/living17_nonorm.yaml @@ -0,0 +1,18 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_living17_nonorm.yaml + +num_classes: 17 +epochs: &epochs 20 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/adaptation/resnet50_transfer.yaml b/configs/adaptation/resnet50_transfer.yaml new file mode 100644 index 0000000..e6030e0 --- /dev/null +++ b/configs/adaptation/resnet50_transfer.yaml @@ -0,0 +1,23 @@ + +log_interval: 5000 +use_cuda: True +save_freq: 1001 +batch_size: 64 +num_workers: 4 +save_all_checkpoints: False + +finetune: True +linear_probe: False +use_net_val_mode: False + +optimizer: + classname: torch.optim.SGD + args: + lr: 0.03 + momentum: 0.9 + +criterion: + classname: torch.nn.CrossEntropyLoss + args: + reduction: mean + diff --git a/configs/breeds_living_finetuning.yaml b/configs/breeds_living_finetuning.yaml deleted file mode 100644 index dbdc46b..0000000 --- a/configs/breeds_living_finetuning.yaml +++ /dev/null @@ -1,17 +0,0 @@ - -inherit: - - datasets_breeds_living.yaml - - resnet50_transfer.yaml - -epochs: &epochs 25 - -finetune: True -num_classes: 17 -linear_probe: False -use_net_val_mode: False - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - diff --git a/configs/breeds_living_moco_finetuning.yaml b/configs/breeds_living_moco_finetuning.yaml deleted file mode 100644 index 22540a7..0000000 --- a/configs/breeds_living_moco_finetuning.yaml +++ /dev/null @@ -1,24 +0,0 @@ - -inherit: - - datasets_breeds_living.yaml - - resnet50_transfer.yaml - -epochs: &epochs 25 - -num_classes: 17 -finetune: True -linear_probe: False -use_net_val_mode: False - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - pretrain_style: 'mocov2' - checkpoint_path: '/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar' - diff --git a/configs/breeds_living_moco_probe.yaml b/configs/breeds_living_moco_probe.yaml deleted file mode 100644 index f9ddbee..0000000 --- a/configs/breeds_living_moco_probe.yaml +++ /dev/null @@ -1,24 +0,0 @@ - -inherit: - - datasets_breeds_living.yaml - - resnet50_transfer.yaml - -epochs: &epochs 25 - -num_classes: 17 -finetune: True -linear_probe: True -use_net_val_mode: True - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - pretrain_style: 'mocov2' - checkpoint_path: '/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar' - diff --git a/configs/breeds_living_probe.yaml b/configs/breeds_living_probe.yaml deleted file mode 100644 index 68c9cf2..0000000 --- a/configs/breeds_living_probe.yaml +++ /dev/null @@ -1,10 +0,0 @@ - -inherit: - - datasets_breeds_living.yaml - - resnet50_transfer.yaml - -num_classes: 17 -linear_probe: True -finetune: True -use_net_val_mode: True - diff --git a/configs/cifar_resnet_baseline.yaml b/configs/cifar_resnet_baseline.yaml deleted file mode 100644 index ac542f2..0000000 --- a/configs/cifar_resnet_baseline.yaml +++ /dev/null @@ -1,51 +0,0 @@ -log_interval: 10 -use_cuda: True -save_freq: 25 -epochs: &epochs 200 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -optimizer: - classname: torch.optim.SGD - args: - lr: &lr 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - lr: *lr - T_max: *epochs - -model: - classname: models.resnet.resnet18 - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.ToTensor - -test_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.ToTensor - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/datasets_cifar_test_all.yaml b/configs/datasets_cifar_test_all.yaml deleted file mode 100644 index 614e243..0000000 --- a/configs/datasets_cifar_test_all.yaml +++ /dev/null @@ -1,155 +0,0 @@ - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: [224, 224] - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - max_test_examples: 1000 - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - max_test_examples: 1000 - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 1000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - - name: 'stl-32x32' - classname: datasets.stl_cifar_style.STL10 - max_test_examples: 1000 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 32 - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - - name: 'imnet-n-cifar' - classname: datasets.imnet_intersect_c10.ImNetnC10 - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/balanced_imnet_intersect_c10_val/' - - name: 'fog-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 2 - - name: 'fog-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 4 - - name: 'zoom-blur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 2 - - name: 'zoom-blur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 4 - - name: 'gaussian-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 2 - - name: 'gaussian-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 4 - - name: 'pixelate-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 2 - - name: 'pixelate-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 4 - - name: 'shotnoise-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 2 - - name: 'shotnoise-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 4 - - name: 'glassblur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 2 - - name: 'glassblur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - max_test_examples: 1000 - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 4 - diff --git a/configs/e30_sup_ft.yaml b/configs/e30_sup_ft.yaml deleted file mode 100644 index 1cc4ba7..0000000 --- a/configs/e30_sup_ft.yaml +++ /dev/null @@ -1,17 +0,0 @@ - -inherit: - - datasets_breeds_entity30.yaml - - resnet50_transfer.yaml - -epochs: &epochs 25 - -finetune: True -num_classes: 30 -linear_probe: False -use_net_val_mode: False - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - diff --git a/configs/e30_sup_probe.yaml b/configs/e30_sup_probe.yaml deleted file mode 100644 index 69d2cb8..0000000 --- a/configs/e30_sup_probe.yaml +++ /dev/null @@ -1,10 +0,0 @@ - -inherit: - - datasets_breeds_entity30.yaml - - resnet50_transfer.yaml - -num_classes: 30 -linear_probe: True -finetune: True -use_net_val_mode: True - diff --git a/configs/e30_swav_ft_augment.yaml b/configs/e30_swav_ft_augment.yaml deleted file mode 100644 index f931b5c..0000000 --- a/configs/e30_swav_ft_augment.yaml +++ /dev/null @@ -1,47 +0,0 @@ - -inherit: - - breeds_living_moco_finetuning.yaml - - datasets_breeds_entity30.yaml - -num_classes: 30 - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - pretrain_style: 'swav' - checkpoint_path: '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar' - -# Add augmentations, and change normalization a bit. -train_dataset: - classname: datasets.breeds.Breeds - args: - source: True - split: 'train' - breeds_name: 'entity30' - root: '/u/scr/nlp/imagenet/' - transforms: - - classname: torchvision.transforms.RandomResizedCrop - args: - size: 224 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.228, 0.224, 0.225] - -# Change transform (e.g. centercrop), and change normalization a bit. -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 256 - - classname: torchvision.transforms.CenterCrop - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.228, 0.224, 0.225] - diff --git a/configs/entity30_moco_finetuning.yaml b/configs/entity30_moco_finetuning.yaml deleted file mode 100644 index 8b52b3b..0000000 --- a/configs/entity30_moco_finetuning.yaml +++ /dev/null @@ -1,7 +0,0 @@ - -inherit: - - breeds_living_moco_finetuning.yaml - - datasets_breeds_entity30.yaml - -num_classes: 30 - diff --git a/configs/entity30_moco_probe.yaml b/configs/entity30_moco_probe.yaml deleted file mode 100644 index e6fc31c..0000000 --- a/configs/entity30_moco_probe.yaml +++ /dev/null @@ -1,7 +0,0 @@ - -inherit: - - breeds_living_moco_probe.yaml - - datasets_breeds_entity30.yaml - -num_classes: 30 - diff --git a/configs/imnet_cifar_all_finetune.yaml b/configs/imnet_cifar_all_finetune.yaml deleted file mode 100644 index 92a7e10..0000000 --- a/configs/imnet_cifar_all_finetune.yaml +++ /dev/null @@ -1,17 +0,0 @@ - -inherit: - - datasets_cifar_test_all.yaml - - resnet50_transfer.yaml - -epochs: &epochs 25 - -finetune: True -num_classes: 10 -linear_probe: False -use_net_val_mode: False - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - diff --git a/configs/imnet_cifar_all_probe.yaml b/configs/imnet_cifar_all_probe.yaml deleted file mode 100644 index 81f1618..0000000 --- a/configs/imnet_cifar_all_probe.yaml +++ /dev/null @@ -1,10 +0,0 @@ - -inherit: - - datasets_cifar_test_all.yaml - - resnet50_transfer.yaml - -num_classes: 10 -linear_probe: True -finetune: True -use_net_val_mode: True - diff --git a/configs/old/imnet_finetune_cifar_resnet_baseline.yaml b/configs/old/imnet_finetune_cifar_resnet_baseline.yaml deleted file mode 100644 index 0c6782a..0000000 --- a/configs/old/imnet_finetune_cifar_resnet_baseline.yaml +++ /dev/null @@ -1,71 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_finetune_cifar_resnet_creafz.yaml b/configs/old/imnet_finetune_cifar_resnet_creafz.yaml deleted file mode 100644 index a5f14db..0000000 --- a/configs/old/imnet_finetune_cifar_resnet_creafz.yaml +++ /dev/null @@ -1,79 +0,0 @@ -log_interval: 10 -use_cuda: True -save_freq: 25 -epochs: &epochs 100 -batch_size: 32 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: &lr 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: 1 - gamma: 0.975 - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'fog-cifar' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 2 - - name: 'zoom-blur-cifar' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 2 - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml b/configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml deleted file mode 100644 index acda6d4..0000000 --- a/configs/old/imnet_finetune_cifar_resnet_fixed_lr_test_stl.yaml +++ /dev/null @@ -1,91 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -test_interval: 5000 -finetune: True -num_classes: 10 -linear_probe: False -use_net_val_mode: False - -# probe_net: -# classname: models.mlp.MLP -# args: -# dims: [2048, 64, 64] -# output_dim: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml b/configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml deleted file mode 100644 index 2e0650e..0000000 --- a/configs/old/imnet_finetune_cifar_resnet_test_cifar10c.yaml +++ /dev/null @@ -1,143 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'fog-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 2 - - name: 'fog-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 4 - - name: 'zoom-blur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 2 - - name: 'zoom-blur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 4 - - name: 'gaussian-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 2 - - name: 'gaussian-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 4 - - name: 'pixelate-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 2 - - name: 'pixelate-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 4 - - name: 'shotnoise-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 2 - - name: 'shotnoise-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 4 - - name: 'glassblur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 2 - - name: 'glassblur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 4 - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_finetune_cifar_resnet_test_stl.yaml b/configs/old/imnet_finetune_cifar_resnet_test_stl.yaml deleted file mode 100644 index 20647db..0000000 --- a/configs/old/imnet_finetune_cifar_resnet_test_stl.yaml +++ /dev/null @@ -1,82 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml b/configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml deleted file mode 100644 index 47bea5c..0000000 --- a/configs/old/imnet_linprobe_cifar_resnet_fixed_lr_test_stl.yaml +++ /dev/null @@ -1,95 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 100 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 -linear_probe: True -use_net_val_mode: True - -# probe_net: -# classname: models.mlp.MLP -# args: -# dims: [2048, 64, 64] -# output_dim: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -# scheduler: -# classname: torch.optim.lr_scheduler.CosineAnnealingLR -# args: -# T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml b/configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml deleted file mode 100644 index 6f6d9ed..0000000 --- a/configs/old/imnet_linprobe_cifar_resnet_test_cifar10c.yaml +++ /dev/null @@ -1,145 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 25 -batch_size: 512 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 -linear_probe: True -use_net_val_mode: True - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'fog-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 2 - - name: 'fog-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'fog' - severity: 4 - - name: 'zoom-blur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 2 - - name: 'zoom-blur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'zoom_blur' - severity: 4 - - name: 'gaussian-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 2 - - name: 'gaussian-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'gaussian_noise' - severity: 4 - - name: 'pixelate-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 2 - - name: 'pixelate-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'pixelate' - severity: 4 - - name: 'shotnoise-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 2 - - name: 'shotnoise-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'shot_noise' - severity: 4 - - name: 'glassblur-cifar-2' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 2 - - name: 'glassblur-cifar-4' - classname: datasets.cifar10c.CIFAR10C - args: - root: '/juice/scr/ananya/CIFAR-10-C/' - corruption: 'glass_blur' - severity: 4 - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml b/configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml deleted file mode 100644 index 99f3d91..0000000 --- a/configs/old/imnet_linprobe_cifar_resnet_test_stl.yaml +++ /dev/null @@ -1,95 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 100 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 -linear_probe: True -use_net_val_mode: True - -# probe_net: -# classname: models.mlp.MLP -# args: -# dims: [2048, 64, 64] -# output_dim: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.1 - momentum: 0.9 - -# scheduler: -# classname: torch.optim.lr_scheduler.StepLR -# args: -# step_size: *epochs - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml b/configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml deleted file mode 100644 index 919907d..0000000 --- a/configs/old/imnet_linprobe_noaugment_cifar_resnet_test_stl.yaml +++ /dev/null @@ -1,90 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 100 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 -linear_probe: True -use_net_val_mode: True - -# probe_net: -# classname: models.mlp.MLP -# args: -# dims: [2048, 64, 64] -# output_dim: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.1 - momentum: 0.9 - -# scheduler: -# classname: torch.optim.lr_scheduler.StepLR -# args: -# step_size: *epochs - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/imnet_probe_cifar_resnet_test_stl.yaml b/configs/old/imnet_probe_cifar_resnet_test_stl.yaml deleted file mode 100644 index 6feccbd..0000000 --- a/configs/old/imnet_probe_cifar_resnet_test_stl.yaml +++ /dev/null @@ -1,90 +0,0 @@ -log_interval: 5000 -use_cuda: True -save_freq: 25 -epochs: &epochs 100 -batch_size: 512 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -num_classes: 10 -linear_probe: True -use_net_val_mode: True - -probe_net: - classname: models.mlp.MLP - args: - dims: [2048, 1024, 1024, 1024] - output_dim: 10 - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -train_dataset: - classname: torchvision.datasets.CIFAR10 - args: - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -default_test_transforms: - - classname: torchvision.transforms.Resize - args: - size: 224 - - classname: torchvision.transforms.ToTensor - - classname: torchvision.transforms.Normalize - args: - mean: [0.485, 0.456, 0.406] - std: [0.229, 0.224, 0.225] - -test_datasets: - - name: 'cifar10-test' - classname: torchvision.datasets.CIFAR10 - args: - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - - name: 'stl-test' - classname: datasets.stl_cifar_style.STL10 - args: - root: '/u/scr/ananya/stl10_dataset' - split: 'test' - - name: 'cinic-val' - classname: datasets.cinic.CINICImNet - max_test_examples: 10000 - args: - root: '/u/scr/ananya/cinic-10-imagenet' - mode: 'valid' - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/small_cifar_resnet_baseline.yaml b/configs/old/small_cifar_resnet_baseline.yaml deleted file mode 100644 index 9c09201..0000000 --- a/configs/old/small_cifar_resnet_baseline.yaml +++ /dev/null @@ -1,53 +0,0 @@ -log_interval: 10 -use_cuda: True -save_freq: 25 -epochs: &epochs 200 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -optimizer: - classname: torch.optim.SGD - args: - lr: &lr 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - lr: *lr - T_max: *epochs - -model: - classname: models.resnet.resnet18 - -train_dataset: - classname: datasets.cifar10_resized.CIFAR10Resized - args: - train_len: &train_len 4000 - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.ToTensor - -test_dataset: - classname: datasets.cifar10_resized.CIFAR10Resized - args: - train_len: *train_len - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.ToTensor - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/small_cifar_resnet_frozenfeatures.yaml b/configs/old/small_cifar_resnet_frozenfeatures.yaml deleted file mode 100644 index 0caf3ec..0000000 --- a/configs/old/small_cifar_resnet_frozenfeatures.yaml +++ /dev/null @@ -1,56 +0,0 @@ -log_interval: 10 -use_cuda: True -save_freq: 25 -epochs: &epochs 2000 -batch_size: 512 -num_workers: 8 -save_all_checkpoints: False - -optimizer: - classname: torch.optim.SGD - args: - lr: &lr 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - lr: *lr - T_max: *epochs - -model: - classname: resnet.resnet18 - -train_dataset: - classname: cifar10_resized.CIFAR10Resized - args: - train_len: &train_len 4000 - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.ToTensor - -test_dataset: - classname: cifar10_resized.CIFAR10Resized - args: - train_len: *train_len - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.ToTensor - -model_loss: - classname: merlin.freeze_feature_loss - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/old/small_cifar_resnet_merlin.yaml b/configs/old/small_cifar_resnet_merlin.yaml deleted file mode 100644 index e8a0ac2..0000000 --- a/configs/old/small_cifar_resnet_merlin.yaml +++ /dev/null @@ -1,56 +0,0 @@ -log_interval: 10 -use_cuda: True -save_freq: 25 -epochs: &epochs 2000 -batch_size: 512 -num_workers: 8 -save_all_checkpoints: False - -optimizer: - classname: torch.optim.SGD - args: - lr: &lr 0.1 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - lr: *lr - T_max: *epochs - -model: - classname: resnet.resnet18 - -train_dataset: - classname: cifar10_resized.CIFAR10Resized - args: - train_len: &train_len 4000 - train: True - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.RandomCrop - args: - size: 32 - padding: 4 - - classname: torchvision.transforms.RandomHorizontalFlip - - classname: torchvision.transforms.ToTensor - -test_dataset: - classname: cifar10_resized.CIFAR10Resized - args: - train_len: *train_len - train: False - download: False - root: '/u/scr/ananya/cifar10_dataset' - transforms: - - classname: torchvision.transforms.ToTensor - -model_loss: - classname: merlin.model_loss - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/configs/resnet50_transfer.yaml b/configs/resnet50_transfer.yaml deleted file mode 100644 index 0fbad2c..0000000 --- a/configs/resnet50_transfer.yaml +++ /dev/null @@ -1,33 +0,0 @@ - -log_interval: 5000 -use_cuda: True -save_freq: 101 -epochs: &epochs 25 -batch_size: 128 -num_workers: 8 -save_all_checkpoints: False - -finetune: True -use_net_val_mode: True - -optimizer: - classname: torch.optim.SGD - args: - lr: 0.01 - momentum: 0.9 - -scheduler: - classname: torch.optim.lr_scheduler.StepLR - args: - step_size: *epochs - -model: - classname: models.imnet_resnet.ResNet50 - args: - pretrained: True - -criterion: - classname: torch.nn.CrossEntropyLoss - args: - reduction: mean - diff --git a/experiments/baseline_train.py b/experiments/baseline_train.py deleted file mode 100644 index 9970913..0000000 --- a/experiments/baseline_train.py +++ /dev/null @@ -1,412 +0,0 @@ - -import argparse -import datetime -import json -import logging -import os -import os.path -import pandas as pd -from pathlib import Path -import shutil -import sys -import torch -import torchvision -from torchvision import transforms -import torch.backends.cudnn as cudnn -import torch.optim as optim -import torch.nn as nn -import torch.nn.functional as F -import wandb -import yaml -import quinine - -from models import resnet -from utils.accumulator import Accumulator -import utils.utils as utils - - -log_level = logging.INFO - - -def reset_state(model, training): - if training: - model.train() - else: - model.eval() - - -def get_test_stats(config, net, test_loader, criterion, device, max_examples=float('infinity')): - # Evaluate accuracy and loss on validation. - # Returns right after we've seen at least max_examples examples (not batches). - val_loss = Accumulator() - val_acc = Accumulator() - training_state = net.training - net.eval() - num_examples = 0 - with torch.no_grad(): - for data in test_loader: - if config['use_cuda']: - data = utils.to_device(data, device) - images, labels = data - outputs = net(images) - _, predicted = torch.max(outputs.data, dim=1) - val_acc.add_values((predicted == labels).tolist()) - loss = criterion(outputs, labels) - val_loss.add_value(loss.tolist()) - num_examples += len(images) - if num_examples >= max_examples: - break - reset_state(net, training_state) - return val_loss, val_acc - - -def update_best_stats(stats, best_stats): - for k, v in stats.items(): - best_k = 'best_' + k - if best_k in best_stats: - cmb = max - if k.find('loss') != -1 and k.find('acc') == -1: - cmb = min - best_stats[best_k] = cmb(best_stats[best_k], v) - else: - best_stats[best_k] = v - - -def get_test_loaders(config): - test_loaders = {} - max_test_examples = {} - logging.info('Found %d testing datasets.', len(config['test_datasets'])) - for test_dataset_config in config['test_datasets']: - logging.info('test dataset config: ' + str(test_dataset_config)) - # Initialize dataset and data loader. - # Shuffle is True in case we only test part of the test set. - test_data = utils.init_dataset(test_dataset_config) - test_loader = torch.utils.data.DataLoader( - test_data, batch_size=config['batch_size'], - shuffle=True, num_workers=config['num_workers']) - test_config_name = test_dataset_config['name'] - test_loaders[test_config_name] = test_loader - # Some test datasets like CINIC are huge so we only test part of the dataset. - if 'max_test_examples' in test_dataset_config: - max_test_examples[test_config_name] = test_dataset_config['max_test_examples'] - logging.info('test loader name: ' + test_dataset_config['name']) - logging.info('test loader: ' + str(test_loader)) - logging.info('test transform: ' + str(test_dataset_config['transforms'])) - return test_loaders, max_test_examples - - -def build_model(config): - net = utils.initialize(config['model']) - # If fine-tune, re-initialize the last layer. - finetune = 'finetune' in config and config['finetune'] - linear_probe = 'linear_probe' in config and config['linear_probe'] - def count_parameters(model, trainable): - return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) - if finetune or linear_probe: - if linear_probe: - logging.info('linear probing, freezing bottom layers.') - if 'use_net_val_mode' not in config: - config['use_net_val_mode'] = True - logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') - net.set_requires_grad(False) - if 'probe_net' in config: - probe_net = utils.initialize(config['probe_net']) - net.add_probe(probe_net) - else: - net.new_last_layer(config['num_classes']) - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params - logging.info(f'Fine Tuning {num_trainable_params} of {num_params} parameters.') - return net - - -def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples): - # Train model. - training_state = net.training - logging.info("\nEpoch #{}".format(epoch)) - loss_dict = { - 'train/loss': Accumulator(), - 'train/acc': Accumulator(), - } - if 'model_loss' in config: - loss_dict['train/model_loss'] = Accumulator() - num_examples = 0 - for i, data in enumerate(train_loader, 0): - if 'use_net_val_mode' in config and config['use_net_val_mode']: - net.eval() - else: - net.train() - # get the inputs; data is a list of [inputs, labels] - if config['use_cuda']: - data = utils.to_device(data, device) - inputs, labels = data - optimizer.zero_grad() - outputs = net(inputs) - loss = criterion(outputs, labels) - _, train_preds = torch.max(outputs.data, axis=1) - loss_dict['train/loss'].add_value(loss.tolist()) - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) - if 'model_loss' in config: - opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() - loss_dict['train/model_loss'].add_value(opt_loss.tolist()) - else: - loss.backward() - optimizer.step() - num_examples += len(labels) - outputs, loss, train_preds = None, None, None # Try to force garbage collection. - def should_log(log_interval): - return num_examples // log_interval > (num_examples - len(labels)) // log_interval - if should_log(config['log_interval']): - for k in loss_dict: - logging.info( - '[%d, %5d] %s: %.3f' % - (epoch + 1, num_examples, k, loss_dict[k].get_mean())) - # Sometimes we want to log the test loss more often to track things better. - if 'test_interval' in config and should_log(config['test_interval']): - stats = get_all_test_stats( - test_loaders, max_test_examples, config, net, criterion, device, - loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') - if config['wandb']: - wandb.log(stats) - reset_state(net, training_state) - train_stats = {'epoch': epoch} - for key in loss_dict: - train_stats[key] = loss_dict[key].get_mean() - return train_stats - - -def get_all_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, - loss_name_prefix, acc_name_prefix): - stats = {'epoch': epoch} - for name, test_loader in test_loaders.items(): - max_examples = float('infinity') - if name in max_test_examples: - max_examples = max_test_examples[name] - val_loss, val_acc = get_test_stats( - config, net, test_loader, criterion, device, - max_examples=max_examples) - stats[loss_name_prefix + name] = val_loss.get_mean() - stats[acc_name_prefix + name] = val_acc.get_mean() - return stats - - -def main(config, log_dir, checkpoints_dir): - # Set up datasets and loaders. - logging.info("Entering main.") - train_data = utils.init_dataset(config['train_dataset']) - train_loader = torch.utils.data.DataLoader( - train_data, batch_size=config['batch_size'], - shuffle=True, num_workers=config['num_workers']) - # Set up test loaders. - test_loaders, max_test_examples = get_test_loaders(config) - # Create model. - net = build_model(config) - # Use CUDA if desired. - logging.info(f'cuda device count: {torch.cuda.device_count()}') - if config['use_cuda']: - # Often makes things faster, by benchmarking and figuring out how to optimize. - cudnn.benchmark = True - device = "cuda" - net.cuda() - logging.info('Using cuda? %d', next(net.parameters()).is_cuda) - # Loss, optimizer, scheduler. - # Can use a custom loss that takes in a model, inputs, labels, and gets an array of values. - # For example if you want to regularize weights in some special way. - # More commonly, we use a criterion, which takes in model_outputs, labels, and outputs a loss. - # criterion must be specified anyway, since that's the loss we evaluate on test sets. - criterion = utils.initialize(config['criterion']) - model_loss = None - if 'model_loss' in config: - model_loss = utils.initialize(config['model_loss']) - optimizer = utils.initialize( - config['optimizer'], update_args={'params': net.parameters()}) - scheduler = utils.initialize( - config['scheduler'], update_args={'optimizer': optimizer}) - # Training loop. - best_stats = {} - best_accs = {} # Used to save checkpoints of best models on some datasets. - train_metrics = [] - test_metrics = [] - prev_ckp_path = None - for epoch in range(config['epochs']): - # Save checkpoint once in a while. - if epoch % config['save_freq'] == 0: - cur_ckp_filename = 'ckp_' + str(epoch) - utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, cur_ckp_filename) - if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): - os.remove(prev_ckp_path) - prev_ckp_path = checkpoints_dir / cur_ckp_filename - # One epoch of model training. - train_stats = train( - epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples) - scheduler.step() - # Get test stats across all test sets. - test_stats = get_all_test_stats( - epoch, test_loaders, max_test_examples, config, net, criterion, device, - loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') - # Keep track of the best stats. - update_best_stats(train_stats, best_stats) - update_best_stats(test_stats, best_stats) - # Log and save stats. - train_metrics.append(train_stats) - test_metrics.append(test_stats) - train_df = pd.DataFrame(train_metrics) - test_df = pd.DataFrame(test_metrics) - train_df.to_csv(log_dir + '/stats_train.tsv', sep='\t') - test_df.to_csv(log_dir + '/stats_test.tsv', sep='\t') - if config['wandb']: - wandb.log(train_stats) - wandb.log(test_stats) - wandb.log(best_stats) - utils.save_json(log_dir + '/current_train.json', train_stats) - utils.save_json(log_dir + '/current_test.json', test_stats) - utils.save_json(log_dir + '/best.json', best_stats) - # Save checkpoint of best model. We save the 'best' for each of a list - # of specified valid datasets. For example, we might want to save the best - # model according to in-domain validation metrics, but as an oracle, save - # the best according to ood validation metrics (or a proxy ood metric). - if 'early_stop_dataset_names' in config: - logging.info(f"Early stopping using datasets {config['early_stop_dataset_names']}") - for name in config['early_stop_dataset_names']: - if name not in test_loaders: - raise ValueError(f"{name} is not the name of a test dataset.") - metric_name = 'test_acc/' + name - assert(metric_name in test_stats) - if metric_name not in best_accs or test_stats[metric_name] > best_accs[metric_name]: - best_accs[metric_name] = test_stats[metric_name] - checkpoint_name = 'ckp_best_' + name - utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, checkpoint_name) - utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_last') - - -def make_new_dir(new_dir): - if os.path.isdir(new_dir): - raise ValueError('{} already exists.'.format(new_dir)) - os.makedirs(new_dir) - - -def make_checkpoints_dir(log_dir): - checkpoints_dir = log_dir + '/checkpoints' - checkpoints_dir = Path(checkpoints_dir).resolve().expanduser() - os.makedirs(checkpoints_dir) - return checkpoints_dir - - -def copy_folders(log_dir): - copy_folders = ['code', 'configs', 'scripts', 'lib', 'configs', 'models', - 'experiments', 'utils', 'examples', 'src', 'datasets'] - for copy_folder in copy_folders: - if os.path.isdir('./' + copy_folder): - shutil.copytree('./' + copy_folder, log_dir + '/' + copy_folder) - - -def time_to_str(ts): - return pd.Timestamp(ts).strftime('%Y-%m-%dT%H-%M-%S-%f') - - -def now_to_str(): - return time_to_str(datetime.datetime.now()) - - -def setup_wandb(args, config): - if not args.no_wandb: - run_name = now_to_str() if args.run_name is None else args.run_name - print(args.project_name, run_name, args.group_name, args.entity_name) - run_obj = wandb.init( - project=args.project_name, name=run_name, - group=args.group_name, entity=args.entity_name) - config['wandb_url'] = run_obj.get_url() - config['run_name'] = run_name - config['group_name'] = args.group_name - config['entity_name'] = args.entity_name - config['wandb'] = True - wandb.config.update(config) - else: - config['wandb'] = False - - -def save_command_line_args(log_dir): - command = "" - command += sys.executable + " " - command += " ".join(sys.argv) - logging.info('Command: ' + command) - with open(log_dir+'/command.txt', 'w') as f: - f.write(command) - f.write('\n') - - -def update_test_transform_configs(config): - # Use default test transform for test datasets that don't specify a transform. - for test_dataset_config in config['test_datasets']: - if 'transforms' not in test_dataset_config: - if config['default_test_transforms'] is None: - raise ValueError('Must either specify default_test_transforms ' - 'or a transform for each test dataset') - test_dataset_config['transforms'] = config['default_test_transforms'] - - -def update_net_eval_mode(config): - # If linear probing, then by default we want to turn off batchnorm while training. - # In other words we want to use validation mode while training unless otherwise specified. - linear_probe = 'linear_probe' in config and config['linear_probe'] - if linear_probe: - if 'use_net_val_mode' not in config: - config['use_net_val_mode'] = True - logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') - - -def setup(): - parser = argparse.ArgumentParser( - description='Run model') - parser.add_argument('--config', type=str, metavar='c', - help='YAML config', required=True) - parser.add_argument('--log_dir', type=str, metavar='ld', - help='Log directory', required=True) - parser.add_argument('--no_wandb', action='store_true', help='disable W&B') - parser.add_argument('--copy_all_folders', action='store_true', - help='Copy all folders (e.g. code, utils) for reproducibility.') - parser.add_argument('--project_name', type=str, - help='Name of the wandb project', required=True) - parser.add_argument('--group_name', default=None, help='Name of the wandb group (a group of runs)') - parser.add_argument('--run_name', default=None, help='Name of the wandb run') - parser.add_argument('--entity_name', default='p-lambda', help='Name of the team') - - args, unparsed = parser.parse_known_args() - log_dir = args.log_dir - # Make log and checkpoint directories. - make_new_dir(log_dir) - checkpoints_dir = make_checkpoints_dir(log_dir) - # If you want to copy folders to get the whole state of code - # while running. For more reproducibility. - if args.copy_all_folders: - copy_folders(args.log_dir) - # Setup logging. - utils.setup_logging(log_dir, log_level) - # Open config, update with command line args. - config = quinine.Quinfig(args.config) - utils.update_config(unparsed, config) - # We make specifying some things more convenient - we don't need to specify - # a transform for each test, but can specify a default transform. - update_test_transform_configs(config) - # If linear probing, by default we turn batch-norm off while training, if unspecified. - update_net_eval_mode(config) - # Note: copying config over is not that useful anymore with Quinine, so use json below. - shutil.copy(args.config, log_dir+'/original_config.yaml') - # Setup wandb. - setup_wandb(args, config) - # Save updated config. - config_json = log_dir+'/config.json' - with open(config_json, 'w') as f: - json.dump(config, f) - # Save command line arguments. - save_command_line_args(log_dir) - return config, log_dir, checkpoints_dir - - -if __name__ == "__main__": - config, log_dir, checkpoints_dir = setup() - main(config, log_dir, checkpoints_dir) - diff --git a/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb b/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb deleted file mode 100644 index 2c1d8d1..0000000 --- a/scripts/.ipynb_checkpoints/breeds_example-checkpoint.ipynb +++ /dev/null @@ -1,178 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from torch.utils.data import Dataset\n", - "import numpy as np\n", - "from PIL import Image\n", - "from robustness.tools.breeds_helpers import make_living17, make_entity13, make_entity30, make_nonliving26\n", - "\n", - "BREEDS_SPLITS_TO_FUNC = {\n", - " 'entity13': make_entity13,\n", - " 'entity30': make_entity30,\n", - " 'living17': make_living17,\n", - " 'nonliving26': make_nonliving26,\n", - "}\n", - "\n", - "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", - "\n", - "SPLITS = ['train', 'val']\n", - "\n", - "NUM_TRAIN_PER_CLASS = 1300\n", - "\n", - "NUM_VAL_PER_CLASS = 50\n", - "\n", - "IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif']\n", - "\n", - "def get_classes(dir):\n", - " if sys.version_info >= (3, 5):\n", - " # Faster and available in Python 3.5 and above\n", - " classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n", - " else:\n", - " classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]\n", - " classes.sort()\n", - " class_to_idx = {classes[i]: i for i in range(len(classes))}\n", - " return classes, class_to_idx\n", - "\n", - "def has_file_allowed_extension(filename, extensions):\n", - " filename_lower = filename.lower()\n", - " return any(filename_lower.endswith(ext) for ext in extensions)\n", - "\n", - "def get_class_image_names(class_dir):\n", - " image_names = []\n", - " for root, _, fnames in sorted(os.walk(class_dir)):\n", - " for fname in sorted(fnames):\n", - " if has_file_allowed_extension(fname, extensions=IMG_EXTENSIONS):\n", - " path = os.path.join(root, fname)\n", - " image_names.append(path)\n", - " return image_names\n", - "\n", - "def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split):\n", - " image_paths_by_class = []\n", - " for idx in range(len(subclasses)):\n", - " image_paths_by_class.append([])\n", - " for subclass in subclasses[idx]:\n", - " subclass_image_names = get_class_image_names(data_dir + '/' + idx_to_class_id[subclass] + '/')\n", - " image_paths_by_class[-1].extend(subclass_image_names)\n", - " if split == 'train':\n", - " assert(len(subclass_image_names) == NUM_TRAIN_PER_CLASS)\n", - " else:\n", - " assert(len(subclass_image_names) == NUM_VAL_PER_CLASS)\n", - " return image_paths_by_class\n", - "\n", - "class Breeds(Dataset):\n", - "\n", - " def __init__(self, root, breeds_name,\n", - " info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified',\n", - " source=True, split='train', transform=None):\n", - " super().__init__()\n", - " if breeds_name not in BREEDS_SPLITS:\n", - " raise ValueError(f'breeds_name must be in {BREEDS_SPLITS} but was {breeds_name}')\n", - " if split not in SPLITS:\n", - " raise ValueError(f'split must be in {SPLITS} but was {split}')\n", - " self._breeds_name = breeds_name\n", - " self._source = source\n", - " self._split = split\n", - " self._transform = transform\n", - " self._info_dir = info_dir\n", - " self._data_dir = root + '/' + split\n", - " self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir)\n", - " if breeds_name == \n", - " self._superclasses, self._subclass_split, self._label_map = make_living17(self._info_dir, split=\"rand\")\n", - " # print(superclasses, label_map)\n", - " if source:\n", - " self._subclasses = self._subclass_split[0]\n", - " else:\n", - " self._subclasses = self._subclass_split[1]\n", - " self._image_paths_by_class = get_image_paths_by_class(\n", - " self._data_dir, self._idx_to_class_id, self._subclasses, split)\n", - " \n", - " # Get a mapping of class index to type by sorting.\n", - " # Get the names of the classes using robustness helper\n", - " # Get the source and target classes\n", - " # Get a list of files in each class\n", - " # 1300 examples per class in train, 50 in test, check this.\n", - " # Get item by class order.\n", - "# if corruption not in CORRUPTIONS:\n", - "# raise ValueError(f\"{corruption} is not a valid corruption.\")\n", - "# if not(0 <= severity <= 4):\n", - "# raise ValueError(f\"Severity was {severity} but must be 0, 1, 2, 3, 4.\")\n", - "# num_examples = 10000\n", - "# start_idx = num_examples * severity\n", - "# end_idx = num_examples * (severity + 1)\n", - "# self._xs = np.load(root + '/' + corruption + '.npy')[start_idx:end_idx]\n", - "# self._ys = torch.LongTensor(np.load(root + 'labels.npy'))[start_idx:end_idx]\n", - "# assert(len(self._xs) == len(self._ys) == num_examples)\n", - "# self._transform = transform\n", - "\n", - " def __getitem__(self, i):\n", - " x, y = self._xs[i], self._ys[i]\n", - " x = Image.fromarray(np.uint8(x))\n", - " if self._transform is not None:\n", - " x = self._transform(x)\n", - " return x, y\n", - "\n", - " def __len__(self) -> int:\n", - " return len(self._xs)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity13')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb b/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb deleted file mode 100644 index 2a50317..0000000 --- a/scripts/.ipynb_checkpoints/cifar10c_stl_examples-checkpoint.ipynb +++ /dev/null @@ -1,176 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - "\n", - "import torchvision\n", - "import torch\n", - "import importlib\n", - "import numpy as np\n", - "from torchvision import transforms\n", - "from datasets import cifar10c\n", - "from datasets import stl_cifar_style\n", - "from datasets import cinic\n", - "import pickle\n", - "import json\n", - "import utils.utils as utils\n", - "from utils.accumulator import Accumulator\n", - "import matplotlib.pyplot as plt\n", - "importlib.reload(cifar10c)\n", - "importlib.reload(stl_cifar_style)\n", - "importlib.reload(cinic)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CIFAR-10C Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cifar10c_fog = cifar10c.CIFAR10C(root='/juice/scr/ananya/CIFAR-10-C/', corruption='snow', severity=2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "idx = 15\n", - "img = cifar10c_fog[idx][0]\n", - "plt.imshow(img)\n", - "print(cifar10c_fog[idx][1])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# STL Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from PIL import Image\n", - "from matplotlib import cm\n", - "im = Image.fromarray(np.uint8(img))\n", - "display(im)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "stl_data.classes" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "idx = 2004\n", - "img = stl_data[idx][0]\n", - "plt.imshow(img)\n", - "print(stl_data.classes[stl_data[idx][1]])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CINIC Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cinic_directory = '/juice/scr/ananya/cinic-10-imagenet'\n", - "\n", - "cinic_mean = [0.47889522, 0.47227842, 0.43047404]\n", - "cinic_std = [0.24205776, 0.23828046, 0.25874835]\n", - "cinic_data = cinic.CINICImNet(root=cinic_directory, mode='valid', transform=transforms.ToTensor())\n", - "# transform=transforms.Compose([transforms.ToTensor(),\n", - "# transforms.Normalize(mean=cinic_mean,std=cinic_std)]))\n", - "# cinic_train = torch.utils.data.DataLoader(\n", - "# cinic_data, batch_size=128, shuffle=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "idx = 25009\n", - "img = np.transpose(cinic_data[idx][0], axes=[1,2,0])\n", - "plt.imshow(img)\n", - "print(cinic_data[idx][1])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/Combining models using uncertainties.ipynb b/scripts/Combining models using uncertainties.ipynb deleted file mode 100644 index ba41646..0000000 --- a/scripts/Combining models using uncertainties.ipynb +++ /dev/null @@ -1,1277 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 150, - "metadata": {}, - "outputs": [], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - "\n", - "import torch\n", - "import utils.utils as utils\n", - "import json\n", - "import numpy as np\n", - "from scipy.special import softmax\n", - "\n", - "import calibration as cal\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda is available: True\n" - ] - } - ], - "source": [ - "print(f'cuda is available: {torch.cuda.is_available()}')\n", - "torch.cuda.empty_cache()" - ] - }, - { - "cell_type": "code", - "execution_count": 190, - "metadata": {}, - "outputs": [], - "source": [ - "def load_model(config_path, checkpoint_path):\n", - " with open(config_path) as f:\n", - " config = json.load(f)\n", - " net = utils.initialize(config['model'])\n", - " if USE_CUDA:\n", - " net = net.cuda()\n", - " net.new_last_layer(config['num_classes'])\n", - " utils.load_ckp(checkpoint_path, net)\n", - " return net\n", - "\n", - "# Load datasets.\n", - "def load_test_dataset(config, idx):\n", - " test_config = config['test_datasets'][idx]\n", - " print(test_config['name'])\n", - " if 'transforms' not in test_config:\n", - " test_config['transforms'] = config['default_test_transforms']\n", - " test_data = utils.init_dataset(test_config)\n", - " test_loader = torch.utils.data.DataLoader(\n", - " test_data, batch_size=batch_size,\n", - " shuffle=False, num_workers=num_workers)\n", - " return test_data, test_loader\n", - "\n", - "def get_outputs_labels(net, loader):\n", - " net.cuda()\n", - " net.eval()\n", - " outputs_list, labels_list = [], []\n", - " with torch.no_grad():\n", - " for data in loader:\n", - " images, labels = data\n", - " images, labels = images.cuda(), labels.cuda()\n", - " outputs = net(images)\n", - " outputs_list.append(outputs.detach().cpu().numpy())\n", - " labels_list.append(labels.detach().cpu().numpy())\n", - " outputs = np.concatenate(outputs_list)\n", - " labels = np.concatenate(labels_list)\n", - " return outputs, labels\n", - "\n", - "def get_adjusted_probs(probs, labels):\n", - " calibrators = [cal.PlattTopCalibrator(0, num_bins=10) for _ in range(M)]\n", - " adjusted_probs = make_none_list(M, L)\n", - " for m in range(M):\n", - " calibrators[m].train_calibration(probs[m][0], labels[m][0])\n", - " for m in range(M):\n", - " for l in range(L):\n", - " adjusted_probs[m][l] = calibrators[m].calibrate(probs[m][l])\n", - " return adjusted_probs\n", - "\n", - "def get_acc(preds, labels):\n", - " return np.mean(preds == labels)\n", - "\n", - "def make_none_list(rs, cs):\n", - " return [[None] * cs for _ in range(rs)]\n", - "\n", - "def combine_confs_preds(confs, preds):\n", - " confs, preds = np.array(confs), np.array(preds)\n", - " model_choices = np.argmax(confs, axis=0)\n", - " return preds[model_choices, np.arange(confs.shape[1])]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 168, - "metadata": {}, - "outputs": [], - "source": [ - "USE_CUDA = True\n", - "cuda = torch.device('cuda') \n", - "batch_size, num_workers = 32, 16\n" - ] - }, - { - "cell_type": "code", - "execution_count": 198, - "metadata": {}, - "outputs": [], - "source": [ - "def combined_calibration_accs(\n", - " config_paths, checkpoint_paths, model_names, loader_names, loader_indices):\n", - " M, L = len(model_names), len(loader_names)\n", - " models = []\n", - " for m in range(M):\n", - " models.append(load_model(config_paths[m], checkpoint_paths[m]))\n", - "\n", - " with open(config_paths[0]) as f:\n", - " config = json.load(f)\n", - " loaders = []\n", - " for l in range(L):\n", - " _, loader = load_test_dataset(config, idx=loader_indices[l])\n", - " loaders.append(loader)\n", - "\n", - " logits, labels = make_none_list(M, L), make_none_list(M, L)\n", - " probs = make_none_list(M, L)\n", - " confidences, preds = make_none_list(M, L), make_none_list(M, L)\n", - " for m in range(M):\n", - " for l in range(L):\n", - " logits[m][l], labels[m][l] = get_outputs_labels(models[m], loaders[l])\n", - " probs[m][l] = softmax(logits[m][l], axis=-1)\n", - " confidences[m][l] = np.max(probs[m][l], axis=1)\n", - " preds[m][l] = np.argmax(probs[m][l], axis=-1)\n", - " print(f'Ave {model_names[m]} confidence for {loader_names[l]}: {np.mean(confidences[m][l])}')\n", - "\n", - " # Check that the ground truth labels agree at least for the first two models.\n", - " # Note these are just ground truth labels, not predictions. Just a sanity check.\n", - " # E.g. if the images were shuffled and not aligned between the two models this will fail.\n", - " for l in range(L):\n", - " assert (np.sum(labels[0][l] != labels[1][l]) == 0)\n", - "\n", - " adjusted_probs = get_adjusted_probs(probs, labels)\n", - " combined_preds = [None] * L\n", - " for l in range(L):\n", - " cur_loader_adjusted_probs = [adjusted_probs[m][l] for m in range(M)]\n", - " cur_loader_preds = [preds[m][l] for m in range(M)]\n", - " combined_preds[l] = combine_confs_preds(cur_loader_adjusted_probs, cur_loader_preds)\n", - "\n", - " stats = make_none_list(M+1, L)\n", - " for l in range(L):\n", - " print(f'Dataset {loader_names[l]}: ')\n", - " for m in range(M):\n", - " stats[m][l] = get_acc(preds[m][l], labels[0][l])\n", - " print(f'Model {model_names[m]}: {stats[m][l]}')\n", - " stats[M][l] = get_acc(combined_preds[l], labels[0][l])\n", - " print('Combined ', stats[M][l])\n", - " \n", - " return stats, combined_preds, preds, confidences, probs, adjusted_probs, labels\n" - ] - }, - { - "cell_type": "code", - "execution_count": 199, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cifar10-test\n", - "imnet-n-cifar\n", - "Ave lin_model confidence for cifar: 0.926066517829895\n", - "Ave lin_model confidence for imnc: 0.9317657947540283\n", - "Ave ft_model confidence for cifar: 0.988318145275116\n", - "Ave ft_model confidence for imnc: 0.9081357717514038\n", - "Dataset cifar: \n", - "Model lin_model: 0.9052\n", - "Model ft_model: 0.966\n", - "Combined 0.9646\n", - "Dataset imnc: \n", - "Model lin_model: 0.752\n", - "Model ft_model: 0.62\n", - "Combined 0.758\n" - ] - }, - { - "data": { - "text/plain": [ - "([[0.9052, 0.752], [0.966, 0.62], [0.9646, 0.758]],\n", - " [array([3, 8, 8, ..., 5, 1, 7]),\n", - " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 1, 9, 1, 9, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 3, 4,\n", - " 2, 3, 2, 3, 3, 3, 4, 2, 3, 6, 3, 3, 3, 3, 4, 3, 2, 3, 5, 4, 4, 3,\n", - " 3, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 2, 4, 3, 2, 3, 3, 3, 6, 3, 3, 2,\n", - " 2, 3, 3, 4, 4, 2, 4, 5, 4, 3, 2, 2, 3, 2, 4, 2, 2, 4, 2, 4, 3, 4,\n", - " 4, 4, 4, 2, 4, 2, 0, 2, 4, 2, 2, 4, 2, 4, 4, 4, 2, 4, 4, 4, 4, 2,\n", - " 2, 2, 4, 0, 4, 2, 4, 2, 4, 5, 5, 2, 3, 5, 5, 5, 3, 5, 4, 5, 3, 5,\n", - " 4, 5, 3, 5, 3, 2, 5, 3, 4, 5, 4, 3, 3, 5, 5, 5, 4, 5, 5, 4, 5, 5,\n", - " 3, 2, 4, 4, 5, 2, 2, 5, 2, 5, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 6, 2, 2, 6, 6, 6, 6, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 2, 7, 7, 8, 0, 8, 1, 8, 8, 8, 3, 2, 8, 8, 8, 8, 0, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 0, 2, 8, 8, 8,\n", - " 0, 8, 8, 2, 8, 8, 8, 8, 8, 8, 1, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9,\n", - " 1, 1, 9, 1, 9, 9, 1, 1, 0, 1, 9, 1, 0, 9, 1, 1, 9, 9, 1, 0, 9, 1,\n", - " 9, 9, 9, 1, 1, 1, 9, 1, 1, 9, 1, 1, 9, 9, 1, 9])],\n", - " [[array([3, 8, 8, ..., 5, 1, 7]),\n", - " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 1, 9, 1, 9, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 9,\n", - " 1, 9, 9, 1, 2, 1, 9, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 4, 7, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 3, 4,\n", - " 2, 4, 2, 3, 3, 2, 4, 2, 2, 6, 6, 3, 2, 3, 3, 3, 2, 3, 2, 2, 4, 2,\n", - " 3, 3, 2, 3, 3, 3, 3, 2, 2, 2, 2, 6, 4, 3, 2, 3, 3, 3, 6, 3, 2, 2,\n", - " 2, 3, 4, 4, 4, 2, 4, 2, 4, 4, 2, 2, 4, 2, 4, 2, 2, 4, 2, 4, 4, 2,\n", - " 4, 4, 4, 2, 4, 2, 4, 2, 4, 2, 2, 2, 2, 4, 4, 4, 2, 4, 4, 4, 4, 2,\n", - " 2, 2, 4, 4, 2, 2, 4, 2, 4, 5, 5, 2, 2, 5, 5, 5, 2, 5, 4, 5, 5, 5,\n", - " 4, 6, 2, 5, 5, 2, 4, 5, 2, 5, 4, 2, 5, 5, 5, 5, 4, 5, 5, 4, 5, 5,\n", - " 5, 4, 4, 4, 5, 2, 2, 5, 2, 5, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 6, 6, 2, 6, 6, 6, 6, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 2, 7, 7, 8, 2, 3, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 2, 8, 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 8, 8, 2, 8, 8, 8,\n", - " 8, 8, 8, 2, 8, 8, 8, 8, 8, 8, 1, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9,\n", - " 1, 1, 9, 1, 9, 9, 1, 1, 9, 1, 9, 1, 9, 9, 1, 1, 9, 9, 1, 2, 9, 1,\n", - " 9, 9, 9, 1, 1, 1, 9, 1, 1, 9, 1, 1, 9, 9, 1, 9])],\n", - " [array([3, 8, 8, ..., 5, 1, 7]),\n", - " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,\n", - " 0, 3, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 2, 2, 2, 5,\n", - " 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 3, 3, 2, 3, 4,\n", - " 2, 3, 0, 3, 3, 3, 4, 2, 3, 6, 3, 3, 3, 3, 4, 3, 6, 3, 5, 4, 6, 3,\n", - " 3, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 2, 3, 3, 4, 3, 3, 3, 6, 3, 3, 3,\n", - " 2, 3, 3, 4, 4, 3, 4, 5, 2, 3, 4, 4, 3, 4, 3, 3, 3, 4, 2, 4, 3, 4,\n", - " 4, 4, 4, 2, 4, 3, 0, 2, 4, 6, 3, 4, 3, 6, 4, 4, 2, 4, 4, 3, 3, 4,\n", - " 4, 4, 4, 0, 4, 4, 4, 3, 4, 5, 5, 5, 3, 5, 7, 5, 3, 5, 4, 5, 3, 2,\n", - " 5, 5, 3, 5, 3, 4, 5, 3, 4, 5, 4, 3, 3, 5, 3, 3, 3, 5, 5, 4, 2, 5,\n", - " 3, 2, 6, 4, 5, 3, 2, 3, 3, 5, 4, 3, 2, 5, 6, 1, 6, 6, 6, 6, 3, 6,\n", - " 1, 6, 2, 6, 6, 3, 2, 2, 6, 6, 2, 2, 6, 6, 6, 6, 6, 2, 3, 6, 6, 6,\n", - " 0, 6, 8, 2, 6, 6, 3, 6, 3, 6, 6, 6, 0, 2, 2, 2, 6, 6, 6, 6, 7, 7,\n", - " 4, 7, 7, 7, 7, 4, 7, 7, 7, 2, 4, 7, 7, 7, 4, 4, 7, 7, 7, 7, 7, 3,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 4, 7, 7, 7, 8, 0, 8, 1, 3, 2, 8, 3, 7, 0, 0, 8, 3, 0, 8, 8, 0, 8,\n", - " 8, 0, 8, 0, 3, 8, 0, 0, 8, 8, 3, 0, 8, 2, 0, 2, 8, 0, 0, 8, 2, 0,\n", - " 0, 2, 8, 0, 0, 8, 0, 2, 3, 8, 1, 1, 1, 1, 1, 1, 3, 1, 9, 9, 2, 9,\n", - " 1, 1, 9, 1, 9, 9, 1, 1, 0, 1, 8, 1, 0, 4, 1, 1, 9, 9, 1, 0, 1, 1,\n", - " 9, 9, 3, 1, 1, 1, 0, 3, 1, 1, 1, 1, 0, 9, 1, 9])]],\n", - " [[array([0.9968559 , 0.99574995, 0.9967172 , ..., 0.9682235 , 0.99759775,\n", - " 0.9999466 ], dtype=float32),\n", - " array([0.9999818 , 0.9998436 , 1. , 1. , 0.99993795,\n", - " 0.999897 , 0.9999895 , 1. , 0.99999815, 1. ,\n", - " 0.99998474, 0.9973324 , 1. , 0.99847156, 0.9998693 ,\n", - " 1. , 1. , 0.9999781 , 0.9253658 , 1. ,\n", - " 0.997378 , 0.9999934 , 1. , 1. , 0.99997616,\n", - " 0.99994564, 0.9999866 , 0.9999895 , 1. , 0.9999809 ,\n", - " 0.99999905, 0.9999142 , 0.99999136, 0.99997705, 0.99999523,\n", - " 1. , 0.9999791 , 0.99999815, 1. , 0.99983495,\n", - " 1. , 1. , 1. , 0.9998608 , 0.9999923 ,\n", - " 1. , 0.99999815, 0.99991703, 0.9999934 , 1. ,\n", - " 0.9661232 , 0.8574786 , 0.99999815, 0.96374446, 0.9981563 ,\n", - " 0.995597 , 1. , 0.74335945, 1. , 1. ,\n", - " 0.99998474, 0.99684733, 0.7326287 , 0.99999136, 0.9870601 ,\n", - " 0.8911717 , 0.9977728 , 0.9946329 , 0.8023502 , 0.9982049 ,\n", - " 0.87267065, 0.9994337 , 0.71720487, 0.9999971 , 0.51847017,\n", - " 0.9994919 , 0.9999962 , 0.49875155, 1. , 0.999326 ,\n", - " 0.9999895 , 1. , 0.99289286, 0.8729615 , 0.9992897 ,\n", - " 0.99994856, 0.8530985 , 0.99993795, 0.963217 , 0.77419627,\n", - " 0.9999923 , 0.9923977 , 0.99950707, 1. , 0.5199624 ,\n", - " 0.7260851 , 0.9937207 , 1. , 0.99964625, 0.99999815,\n", - " 0.9999943 , 0.9999962 , 0.99995226, 1. , 0.99999523,\n", - " 1. , 0.9998856 , 0.99972534, 0.99998474, 0.98770887,\n", - " 0.9996053 , 0.9999084 , 1. , 0.99999815, 0.9999962 ,\n", - " 1. , 0.9999923 , 1. , 0.99981695, 1. ,\n", - " 1. , 0.9999142 , 0.99999815, 1. , 0.99995613,\n", - " 0.99993706, 1. , 0.99998474, 1. , 1. ,\n", - " 0.99775946, 1. , 0.99981016, 0.9999962 , 0.99903536,\n", - " 0.99999046, 0.99999136, 0.9998931 , 0.9999886 , 0.99830383,\n", - " 0.9999666 , 0.9838225 , 1. , 0.9999962 , 1. ,\n", - " 0.99970347, 0.9999543 , 0.9998217 , 0.9973856 , 0.99995995,\n", - " 0.97000164, 0.6252936 , 0.9539478 , 0.8521118 , 0.9640487 ,\n", - " 0.7308554 , 0.9608555 , 0.9354276 , 0.98531264, 0.5734163 ,\n", - " 0.49572754, 0.9907693 , 0.56013983, 0.5092617 , 0.60572517,\n", - " 0.9999791 , 0.818998 , 0.9999829 , 0.61399174, 0.9999923 ,\n", - " 0.60608864, 0.9733868 , 0.5500202 , 0.78839636, 0.83388305,\n", - " 0.68745905, 0.99997425, 0.9977651 , 0.99323845, 0.99996567,\n", - " 0.9999056 , 0.9995795 , 0.81261134, 0.9268761 , 0.69703877,\n", - " 0.42460987, 0.6746036 , 0.5340869 , 0.9790566 , 0.9999923 ,\n", - " 0.9181435 , 0.9999409 , 0.8667585 , 0.99999046, 0.7797498 ,\n", - " 0.46442312, 0.5956848 , 0.98930687, 0.8455891 , 0.99825436,\n", - " 0.46247002, 0.9615008 , 0.9917203 , 0.96904933, 0.74621195,\n", - " 0.5138647 , 0.8021574 , 0.8934881 , 0.88725126, 0.8243233 ,\n", - " 0.68316644, 0.89995843, 0.9797422 , 0.99435693, 0.7998527 ,\n", - " 0.99423176, 0.859496 , 0.6763293 , 0.8231818 , 0.84537864,\n", - " 0.78631234, 0.94868624, 0.96586066, 0.9142662 , 0.73635656,\n", - " 0.8382209 , 0.7007466 , 0.6688185 , 0.80185074, 0.9908591 ,\n", - " 0.9980478 , 0.77275187, 0.96576667, 0.628651 , 0.9495851 ,\n", - " 0.95293444, 0.75912774, 0.9952705 , 0.79737216, 0.98654157,\n", - " 0.84316367, 0.77287644, 0.99511296, 0.98882014, 0.90712494,\n", - " 0.8981261 , 0.6081635 , 0.9922728 , 0.99265325, 0.97491974,\n", - " 0.9726045 , 0.8311317 , 0.99023277, 0.7940537 , 0.9111097 ,\n", - " 0.90015835, 0.9697029 , 0.94525176, 0.50710213, 0.9810015 ,\n", - " 0.90838635, 0.9855532 , 0.7851414 , 0.9943929 , 0.93938625,\n", - " 0.69014347, 0.85163176, 0.99885917, 0.5221127 , 0.9858559 ,\n", - " 0.5043533 , 0.8447532 , 0.6709906 , 0.9650688 , 0.5566311 ,\n", - " 0.4658366 , 0.98788226, 0.97306246, 0.8794232 , 0.9866206 ,\n", - " 0.947359 , 0.9987009 , 0.9998856 , 0.9986382 , 0.9280879 ,\n", - " 0.99435693, 0.7019218 , 0.9655116 , 0.6258524 , 0.9919294 ,\n", - " 0.81720585, 0.8785866 , 0.46574664, 0.9291497 , 0.7617534 ,\n", - " 0.9957319 , 0.745597 , 0.9928521 , 0.9909726 , 0.9315044 ,\n", - " 1. , 0.9999943 , 1. , 0.9999943 , 1. ,\n", - " 1. , 0.99613553, 0.99999815, 0.9985247 , 0.99999815,\n", - " 0.9999466 , 1. , 1. , 0.9999714 , 0.9986248 ,\n", - " 0.9844373 , 0.9999886 , 1. , 1. , 0.99999815,\n", - " 1. , 1. , 0.99400896, 1. , 1. ,\n", - " 0.99961287, 0.99926215, 1. , 1. , 1. ,\n", - " 0.9999714 , 1. , 0.99969393, 1. , 1. ,\n", - " 1. , 0.9373788 , 1. , 0.9904312 , 1. ,\n", - " 1. , 0.9872823 , 1. , 0.9999886 , 0.5154647 ,\n", - " 0.98060584, 0.99999815, 0.99584305, 0.99999815, 0.99999815,\n", - " 0.9944868 , 1. , 0.9994947 , 0.99999046, 0.9999427 ,\n", - " 0.9999962 , 1. , 0.95661396, 0.9999943 , 0.99860764,\n", - " 0.9999161 , 0.9995624 , 0.8513218 , 0.9985153 , 0.99987406,\n", - " 0.9999886 , 0.9941625 , 0.55360186, 1. , 0.9999923 ,\n", - " 0.9999781 , 1. , 0.999897 , 0.99822575, 1. ,\n", - " 0.99999523, 1. , 0.9999962 , 0.99999815, 0.99993134,\n", - " 0.99994856, 0.9999475 , 1. , 0.99577844, 0.99995226,\n", - " 0.9999399 , 0.9998083 , 0.99994564, 0.9999886 , 0.99932694,\n", - " 0.99999815, 0.99650425, 0.9999791 , 0.9998722 , 0.9399391 ,\n", - " 0.99966246, 0.99996185, 0.7389658 , 0.9999409 , 1. ,\n", - " 0.9999752 , 0.70991 , 0.6627074 , 0.49543497, 0.9978146 ,\n", - " 0.9999723 , 0.9999609 , 0.7468217 , 0.8701435 , 0.97020334,\n", - " 0.9959997 , 0.99985605, 0.99988943, 0.9373593 , 0.97390956,\n", - " 0.99999815, 0.999958 , 0.9999934 , 0.99914306, 0.9963285 ,\n", - " 0.99848294, 0.99935555, 0.91751987, 0.999466 , 0.99989605,\n", - " 0.9995547 , 1. , 0.7897158 , 0.86203134, 0.83780205,\n", - " 0.9994242 , 0.9927991 , 0.99997336, 0.99236363, 0.987045 ,\n", - " 0.652998 , 0.9363363 , 0.9998999 , 0.99857235, 0.99682826,\n", - " 0.91242874, 0.82628983, 0.999958 , 0.9142911 , 0.94633955,\n", - " 0.66393834, 0.9995805 , 0.99987125, 0.987304 , 0.99976164,\n", - " 0.9999284 , 0.88468945, 0.99999815, 0.82860464, 0.88762456,\n", - " 0.9998369 , 0.9740452 , 0.985121 , 0.99999136, 0.9960386 ,\n", - " 0.9999323 , 0.9982553 , 0.9993317 , 0.99824774, 0.99027437,\n", - " 0.99999815, 0.999957 , 0.8619733 , 0.99999815, 0.99995613,\n", - " 0.54026765, 0.97314924, 0.99679035, 0.99976444, 0.9948776 ,\n", - " 0.99985695, 0.99926305, 0.9578765 , 0.98974514, 0.95945805,\n", - " 0.99344593, 0.48623484, 0.98946446, 0.99991226, 0.9925085 ,\n", - " 0.9578856 , 0.9730879 , 1. , 0.99351704, 0.9999923 ,\n", - " 0.99665916, 0.97881854, 1. , 0.9994689 , 0.8817389 ,\n", - " 0.9984277 , 0.99542433, 0.99999815, 1. , 0.9981906 ],\n", - " dtype=float32)],\n", - " [array([1. , 1. , 0.99999815, ..., 0.9999829 , 1. ,\n", - " 1. ], dtype=float32),\n", - " array([1. , 0.9999962 , 0.999774 , 1. , 1. ,\n", - " 0.8662148 , 0.99996567, 1. , 1. , 1. ,\n", - " 0.98833644, 0.99993426, 1. , 1. , 1. ,\n", - " 1. , 1. , 1. , 0.99992657, 0.9999886 ,\n", - " 0.99993515, 0.99995226, 1. , 1. , 0.9867849 ,\n", - " 0.9996444 , 0.9999809 , 1. , 1. , 0.99972916,\n", - " 1. , 0.9999962 , 1. , 1. , 1. ,\n", - " 1. , 0.40381017, 1. , 0.99999815, 1. ,\n", - " 1. , 1. , 0.9999866 , 0.99674284, 0.9987 ,\n", - " 1. , 0.9991268 , 1. , 1. , 1. ,\n", - " 0.5585054 , 0.8932355 , 1. , 0.99102443, 0.6324849 ,\n", - " 0.7086093 , 1. , 0.99914396, 0.99524397, 1. ,\n", - " 0.9030482 , 0.99977785, 0.9889568 , 1. , 0.98109883,\n", - " 0.9905237 , 0.99937266, 0.99999815, 0.99942607, 0.9999781 ,\n", - " 0.6928853 , 1. , 0.9985438 , 0.99999523, 0.9893577 ,\n", - " 1. , 1. , 0.95078844, 0.99999523, 1. ,\n", - " 0.99999815, 1. , 1. , 0.9985572 , 0.99999905,\n", - " 1. , 0.92213666, 0.99999815, 0.9174468 , 0.56621933,\n", - " 1. , 0.9998636 , 0.98947483, 0.9999866 , 0.9975331 ,\n", - " 0.98526 , 1. , 0.9999934 , 0.9999857 , 0.9999934 ,\n", - " 0.9869726 , 0.88925683, 0.9844026 , 1. , 0.99987316,\n", - " 0.93984586, 0.99996567, 0.9999962 , 0.9973846 , 0.66004694,\n", - " 0.95643884, 0.7475895 , 0.9999695 , 1. , 0.9973285 ,\n", - " 0.99999815, 1. , 0.9645425 , 0.99999815, 0.99993706,\n", - " 0.9836714 , 1. , 1. , 0.96774805, 0.99390465,\n", - " 0.9980174 , 1. , 1. , 0.9850501 , 0.9875695 ,\n", - " 0.99397284, 0.9999962 , 0.99999046, 0.9999962 , 1. ,\n", - " 0.6457206 , 0.8791679 , 0.99821824, 1. , 0.99932694,\n", - " 0.6909436 , 0.7176482 , 1. , 1. , 0.99999815,\n", - " 0.9009657 , 0.99152267, 1. , 0.9314316 , 0.8774369 ,\n", - " 0.9996587 , 0.75645024, 0.65849334, 0.5996742 , 0.9887919 ,\n", - " 0.8991562 , 0.6362825 , 0.9999962 , 0.99999815, 0.9073153 ,\n", - " 0.8056434 , 0.99846387, 0.99999046, 0.72738016, 0.99998754,\n", - " 1. , 0.9998931 , 1. , 0.9988219 , 1. ,\n", - " 0.38097766, 0.9999666 , 0.9999791 , 0.97748643, 0.9072894 ,\n", - " 0.8540481 , 1. , 0.97256285, 0.73889464, 0.9999886 ,\n", - " 1. , 1. , 0.5565873 , 0.44403493, 0.9934375 ,\n", - " 0.9814629 , 0.8974968 , 0.8345852 , 0.98116434, 1. ,\n", - " 0.59990704, 0.9986353 , 0.8027539 , 1. , 0.5160671 ,\n", - " 0.851339 , 0.7643119 , 0.9948217 , 0.57323396, 0.99994475,\n", - " 0.82698864, 0.9641912 , 0.9999962 , 0.65607685, 0.9075975 ,\n", - " 0.6038014 , 0.86008054, 0.99485964, 0.7227869 , 0.95677954,\n", - " 0.9894786 , 0.41129076, 0.8074691 , 0.87003225, 0.8870004 ,\n", - " 0.9971886 , 0.7308336 , 0.9967751 , 0.99745786, 0.99757963,\n", - " 0.55131894, 0.999651 , 0.99919736, 0.99547076, 0.99185276,\n", - " 0.9477277 , 0.99781847, 0.5032067 , 0.9985648 , 0.6348027 ,\n", - " 0.841563 , 0.9615594 , 0.9792424 , 0.55340576, 0.6996568 ,\n", - " 0.9986877 , 0.99768436, 0.9998617 , 0.923821 , 0.6165097 ,\n", - " 0.9552911 , 0.8491083 , 0.72742486, 0.9989696 , 0.999958 ,\n", - " 0.99217534, 0.9934394 , 0.89679056, 0.9960121 , 0.60556835,\n", - " 0.9981411 , 0.9945741 , 1. , 0.5583377 , 0.99997336,\n", - " 0.99997616, 0.8654617 , 0.99997616, 0.99111044, 0.9999409 ,\n", - " 0.8491026 , 0.9996739 , 0.9981383 , 0.9465716 , 0.99096674,\n", - " 0.98501205, 0.99714696, 0.6924545 , 0.99988085, 0.9984144 ,\n", - " 0.9999027 , 0.99814403, 0.949816 , 0.6425254 , 0.99999815,\n", - " 0.99948233, 0.9999504 , 0.99737895, 0.848252 , 0.9990591 ,\n", - " 0.9626412 , 0.9994937 , 0.99834013, 0.99914783, 0.6100668 ,\n", - " 0.99985033, 0.9999752 , 0.9999781 , 0.7380196 , 0.9998941 ,\n", - " 0.79888874, 0.5906277 , 0.74517363, 0.83994853, 0.90791863,\n", - " 0.8226277 , 0.9983286 , 0.5214824 , 0.9914451 , 0.9892058 ,\n", - " 1. , 0.36203027, 0.999957 , 0.8148898 , 0.99999523,\n", - " 1. , 0.7896277 , 0.99323004, 0.85746396, 0.5193974 ,\n", - " 0.52349174, 0.99826485, 0.9193676 , 0.9050114 , 0.91077614,\n", - " 0.8538596 , 1. , 0.8278448 , 0.78192306, 0.5895883 ,\n", - " 1. , 1. , 0.9999142 , 0.8823353 , 0.999774 ,\n", - " 0.5596422 , 0.47114438, 0.99999815, 0.799791 , 0.7299109 ,\n", - " 0.63780034, 0.9939198 , 0.9234413 , 0.942677 , 0.99998754,\n", - " 0.9999962 , 0.33667505, 0.9993794 , 0.9995547 , 0.8239107 ,\n", - " 0.48382857, 0.71704865, 0.95438135, 0.766022 , 0.9653013 ,\n", - " 0.9937748 , 0.98916346, 0.99365926, 0.995354 , 0.99999905,\n", - " 1. , 1. , 0.9994174 , 0.99999136, 0.96190155,\n", - " 1. , 1. , 0.7977913 , 1. , 0.9999714 ,\n", - " 0.9999923 , 0.9996186 , 0.999304 , 0.99997336, 0.99995136,\n", - " 1. , 0.48410597, 0.56067777, 1. , 1. ,\n", - " 0.9999962 , 1. , 1. , 0.9996196 , 1. ,\n", - " 0.98746777, 1. , 0.9992926 , 1. , 0.9998017 ,\n", - " 0.9888022 , 0.9998779 , 1. , 0.99997044, 0.99999905,\n", - " 0.99997705, 0.7959278 , 0.7656601 , 0.99845815, 0.9964139 ,\n", - " 1. , 0.99996275, 1. , 0.9999866 , 0.77930826,\n", - " 1. , 0.7883621 , 0.7238762 , 0.99999046, 1. ,\n", - " 1. , 0.99593806, 0.9360881 , 0.7273541 , 0.45661375,\n", - " 0.69601184, 0.99999815, 0.9441526 , 0.71277785, 0.7112257 ,\n", - " 0.9925851 , 0.67852914, 0.63297486, 0.9994623 , 0.8102978 ,\n", - " 0.819314 , 0.9542841 , 0.9999962 , 0.9450647 , 0.37058243,\n", - " 0.99997616, 0.99440145, 0.90818405, 0.99965197, 0.9848468 ,\n", - " 0.87614965, 0.9159938 , 0.49991894, 0.74299836, 0.89273214,\n", - " 0.99578416, 0.4727627 , 0.84766 , 0.6975222 , 0.66748255,\n", - " 0.98520833, 0.992268 , 0.9672765 , 0.5521034 , 0.98542917,\n", - " 0.9993317 , 0.79276246, 0.9923211 , 0.6436066 , 0.79797614,\n", - " 0.9461397 , 0.36218894, 0.61479086, 0.97923774, 0.9987924 ,\n", - " 0.9999781 , 0.57936305, 0.9797029 , 0.99999905, 0.89546454,\n", - " 0.9939861 , 0.40192848, 0.65937245, 0.63267046, 0.9999533 ,\n", - " 0.51741564, 0.82064766, 0.9901421 , 0.99998385, 0.9641967 ,\n", - " 1. , 0.9964558 , 0.9970955 , 1. , 0.99785084,\n", - " 0.9998474 , 0.9999962 , 0.9485488 , 0.99999815, 1. ,\n", - " 0.39295483, 1. , 0.9999179 , 0.9986438 , 0.9880491 ,\n", - " 0.9999829 , 0.8127365 , 0.9973446 , 0.9997101 , 0.69363433,\n", - " 0.9966601 , 0.44464263, 1. , 1. , 0.99999523,\n", - " 0.99333847, 0.9709609 , 0.99942034, 0.9851322 , 0.99999136,\n", - " 0.9999791 , 0.5707781 , 0.7837074 , 0.99999815, 0.9995853 ],\n", - " dtype=float32)]],\n", - " [[array([[1.86022908e-06, 9.90709214e-06, 1.82218180e-04, ...,\n", - " 9.71081226e-06, 2.76929177e-06, 2.87277817e-06],\n", - " [1.66914787e-03, 2.58069206e-03, 1.44739047e-08, ...,\n", - " 4.19809992e-10, 9.95749950e-01, 1.74955048e-07],\n", - " [1.00011437e-03, 2.14464730e-03, 6.00225363e-08, ...,\n", - " 5.73124765e-08, 9.96717215e-01, 1.37350187e-04],\n", - " ...,\n", - " [2.11103298e-07, 1.57210536e-07, 1.16644995e-02, ...,\n", - " 6.87153544e-03, 9.06978642e-07, 1.05734756e-07],\n", - " [9.97609575e-04, 9.97597754e-01, 2.84363137e-04, ...,\n", - " 4.04752427e-06, 1.93417742e-04, 9.03860258e-04],\n", - " [3.01652703e-09, 4.08993638e-11, 1.60114223e-06, ...,\n", - " 9.99946594e-01, 1.65093043e-11, 1.02652375e-08]], dtype=float32),\n", - " array([[9.9998182e-01, 1.9361078e-06, 1.4101323e-05, ..., 5.4100497e-09,\n", - " 1.1466470e-07, 2.0715677e-06],\n", - " [9.9984360e-01, 9.9112174e-07, 1.5522800e-04, ..., 1.7016109e-09,\n", - " 8.8897734e-09, 1.2953745e-09],\n", - " [1.0000000e+00, 8.2984366e-09, 1.6440072e-08, ..., 1.0300713e-09,\n", - " 6.4238459e-09, 4.4733184e-08],\n", - " ...,\n", - " [1.1831658e-06, 6.1442293e-08, 6.7040520e-07, ..., 2.1582336e-09,\n", - " 4.1912315e-08, 9.9999815e-01],\n", - " [6.2062210e-11, 1.0000000e+00, 2.8723093e-08, ..., 1.7104306e-11,\n", - " 1.6462258e-12, 2.8273201e-08],\n", - " [9.5113836e-07, 1.7920695e-03, 1.5246497e-05, ..., 2.1037022e-10,\n", - " 1.5786559e-07, 9.9819058e-01]], dtype=float32)],\n", - " [array([[1.6563579e-12, 1.2862825e-12, 5.8161405e-12, ..., 2.3761214e-14,\n", - " 5.9920461e-13, 3.9925534e-13],\n", - " [1.9658232e-11, 4.5968694e-11, 1.4739742e-15, ..., 1.5924082e-16,\n", - " 1.0000000e+00, 5.1633333e-15],\n", - " [2.2273297e-09, 1.3997425e-06, 2.3417654e-10, ..., 3.1824599e-10,\n", - " 9.9999815e-01, 2.1156381e-09],\n", - " ...,\n", - " [3.3552385e-09, 3.7095443e-08, 1.6596496e-05, ..., 2.9803161e-08,\n", - " 7.6420825e-08, 4.5622691e-08],\n", - " [2.5259081e-09, 1.0000000e+00, 1.0934950e-10, ..., 1.7510023e-11,\n", - " 6.5995637e-10, 3.6035244e-10],\n", - " [7.8980329e-12, 9.2636586e-11, 1.0263431e-09, ..., 1.0000000e+00,\n", - " 4.7775764e-13, 9.6414127e-11]], dtype=float32),\n", - " array([[1.0000000e+00, 1.8365616e-07, 1.5589126e-08, ..., 4.8670259e-08,\n", - " 3.0366161e-09, 2.0537691e-08],\n", - " [9.9999619e-01, 2.6431171e-06, 1.9415596e-07, ..., 3.5825305e-08,\n", - " 5.0440612e-08, 5.4157385e-09],\n", - " [9.9977398e-01, 1.1597282e-04, 4.4442444e-07, ..., 1.0829139e-04,\n", - " 9.0374378e-08, 5.1284673e-07],\n", - " ...,\n", - " [3.7569575e-02, 3.6601876e-03, 9.5623167e-04, ..., 3.1528241e-05,\n", - " 2.5651034e-03, 7.8370738e-01],\n", - " [3.4463621e-09, 9.9999815e-01, 2.6811861e-08, ..., 1.8856926e-10,\n", - " 9.7967200e-07, 9.4327979e-10],\n", - " [2.8279146e-07, 4.1466713e-04, 6.7706618e-09, ..., 1.0345512e-08,\n", - " 2.3719220e-08, 9.9958527e-01]], dtype=float32)]],\n", - " [[array([0.98732904, 0.98406969, 0.98690633, ..., 0.92808724, 0.98967533,\n", - " 0.99943964]),\n", - " array([0.9997549 , 0.99872238, 1. , 1. , 0.9993713 ,\n", - " 0.99907258, 0.99983928, 1. , 0.99995761, 1. ,\n", - " 0.99978573, 0.98881803, 1. , 0.99268578, 0.99888661,\n", - " 1. , 1. , 0.9997175 , 0.86616584, 1. ,\n", - " 0.9889638 , 0.99988717, 1. , 1. , 0.9996982 ,\n", - " 0.99943198, 0.99980593, 0.99983928, 1. , 0.9997457 ,\n", - " 0.99997449, 0.99919405, 0.99986148, 0.99970693, 0.99991225,\n", - " 1. , 0.999727 , 0.99995761, 1. , 0.99866859,\n", - " 1. , 1. , 1. , 0.99883173, 0.99987337,\n", - " 1. , 0.99995761, 0.99921432, 0.99988717, 1. ,\n", - " 0.92462241, 0.78791849, 0.99995761, 0.9207726 , 0.99156092,\n", - " 0.98363672, 1. , 0.67946132, 1. , 1. ,\n", - " 0.99978573, 0.98730275, 0.67011227, 0.99986148, 0.96310538,\n", - " 0.82477644, 0.99025354, 0.98098788, 0.73309879, 0.99173103,\n", - " 0.80414837, 0.99657587, 0.65685468, 0.99993976, 0.49791878,\n", - " 0.99684852, 0.99992606, 0.48278283, 1. , 0.99608782,\n", - " 0.99983928, 1. , 0.97649105, 0.80446495, 0.99592763,\n", - " 0.99945554, 0.78334331, 0.9993713 , 0.91992909, 0.7069797 ,\n", - " 0.99987337, 0.97526535, 0.99692095, 1. , 0.4990659 ,\n", - " 0.66446275, 0.97859069, 1. , 0.9976118 , 0.99995761,\n", - " 0.99989907, 0.99992606, 0.99948581, 1. , 0.99991225,\n", - " 1. , 0.99899493, 0.99803275, 0.99978573, 0.96450023,\n", - " 0.99740279, 0.99915227, 1. , 0.99995761, 0.99992606,\n", - " 1. , 0.99987337, 1. , 0.99855862, 1. ,\n", - " 1. , 0.99919405, 0.99995761, 1. , 0.99951814,\n", - " 0.99936436, 1. , 0.99978573, 1. , 1. ,\n", - " 0.99020906, 1. , 0.99851777, 0.99992606, 0.99485371,\n", - " 0.99985061, 0.99986148, 0.99904594, 0.99982886, 0.99208098,\n", - " 0.99960929, 0.95640178, 1. , 0.99992606, 1. ,\n", - " 0.99791377, 0.99950264, 0.99858749, 0.98898826, 0.99955063,\n", - " 0.93107254, 0.58127658, 0.90563339, 0.78231869, 0.92126076,\n", - " 0.66857751, 0.91619487, 0.8794186 , 0.95943738, 0.54041171,\n", - " 0.48046462, 0.97137026, 0.53008672, 0.49084562, 0.56575055,\n", - " 0.999727 , 0.74907915, 0.99976608, 0.57229099, 0.99987337,\n", - " 0.56603758, 0.93690073, 0.52224474, 0.72002173, 0.76376023,\n", - " 0.63181754, 0.99967984, 0.99022791, 0.97735952, 0.99960076,\n", - " 0.99913246, 0.99727369, 0.74289677, 0.86811797, 0.63981036,\n", - " 0.42596744, 0.62118717, 0.50993926, 0.94716169, 0.99987337,\n", - " 0.85699553, 0.99939413, 0.79776268, 0.99985061, 0.71205013,\n", - " 0.45648915, 0.55784013, 0.96802288, 0.77559896, 0.99190541,\n", - " 0.45499368, 0.91720859, 0.97362113, 0.92946757, 0.681965 ,\n", - " 0.49438005, 0.7329162 , 0.82743513, 0.82031738, 0.75428635,\n", - " 0.62825612, 0.83496101, 0.94845216, 0.98025248, 0.73073798,\n", - " 0.97992194, 0.79004073, 0.62260813, 0.75316607, 0.77538366,\n", - " 0.71809153, 0.89790485, 0.92419371, 0.85217765, 0.67334795,\n", - " 0.76811549, 0.64292129, 0.61643691, 0.73262591, 0.97158006,\n", - " 0.99118492, 0.70566708, 0.92404047, 0.58395623, 0.8992076 ,\n", - " 0.90412513, 0.69340446, 0.98272473, 0.72840211, 0.9620038 ,\n", - " 0.77312335, 0.70578019, 0.98229039, 0.96693605, 0.84347954,\n", - " 0.83281448, 0.56767704, 0.97495936, 0.97589525, 0.9396085 ,\n", - " 0.93553594, 0.76101643, 0.97012708, 0.72529083, 0.84830584,\n", - " 0.83519596, 0.93056751, 0.89298914, 0.4891881 , 0.95085428,\n", - " 0.84500014, 0.95993508, 0.71700953, 0.98034773, 0.88480499,\n", - " 0.63405093, 0.78182097, 0.99414979, 0.50071947, 0.96056444,\n", - " 0.48707896, 0.77474439, 0.61821813, 0.92290655, 0.52736513,\n", - " 0.45757142, 0.96487631, 0.93633349, 0.81155876, 0.96217095,\n", - " 0.89599376, 0.99353956, 0.99899493, 0.99330278, 0.8696933 ,\n", - " 0.98025248, 0.64390941, 0.92362527, 0.58172223, 0.97412481,\n", - " 0.74733757, 0.81063359, 0.45750253, 0.87108046, 0.69575151,\n", - " 0.98401837, 0.68142459, 0.97638932, 0.97184607, 0.87418004,\n", - " 1. , 0.99989907, 1. , 0.99989907, 1. ,\n", - " 1. , 0.98517897, 0.99995761, 0.99288077, 0.99995761,\n", - " 0.99943964, 1. , 1. , 0.99965288, 0.99325248,\n", - " 0.95764458, 0.99982886, 1. , 1. , 0.99995761,\n", - " 1. , 1. , 0.97933802, 1. , 1. ,\n", - " 0.99744103, 0.99580739, 1. , 1. , 1. ,\n", - " 0.99965288, 1. , 0.99786255, 1. , 1. ,\n", - " 1. , 0.88206047, 1. , 0.97058469, 1. ,\n", - " 1. , 0.96358087, 1. , 0.99982886, 0.49560919,\n", - " 0.95009494, 0.99995761, 0.98433516, 0.99995761, 0.99995761,\n", - " 0.98059742, 1. , 0.99686183, 0.99985061, 0.99940871,\n", - " 0.99992606, 1. , 0.90964998, 0.99989907, 0.99318827,\n", - " 0.9992074 , 0.99718915, 0.78149989, 0.99284611, 0.99891789,\n", - " 0.99982886, 0.97973982, 0.5250177 , 1. , 0.99987337,\n", - " 0.9997175 , 1. , 0.99907258, 0.99180442, 1. ,\n", - " 0.99991225, 1. , 0.99992606, 0.99995761, 0.99932048,\n", - " 0.99945554, 0.99944685, 1. , 0.98415078, 0.99948581,\n", - " 0.99938664, 0.99850672, 0.99943198, 0.99982886, 0.99609206,\n", - " 0.99995761, 0.98626574, 0.999727 , 0.99890574, 0.88556569,\n", - " 0.99769611, 0.99956714, 0.67562035, 0.99939413, 1. ,\n", - " 0.99968898, 0.65065308, 0.61144033, 0.48024037, 0.99039316,\n", - " 0.99966124, 0.99955886, 0.68250123, 0.80140744, 0.93141435,\n", - " 0.98478516, 0.99880116, 0.99902074, 0.88203388, 0.93781901,\n", - " 0.99995761, 0.99953379, 0.99988717, 0.99529907, 0.98574428,\n", - " 0.99272739, 0.99621981, 0.85621583, 0.99672641, 0.999066 ,\n", - " 0.99715141, 1. , 0.72124678, 0.79272167, 0.76769337,\n", - " 0.99653209, 0.97625731, 0.99967135, 0.97518172, 0.96307305,\n", - " 0.60354458, 0.88064581, 0.99909282, 0.99305688, 0.98724439,\n", - " 0.84991842, 0.75622172, 0.99953379, 0.85220831, 0.89453568,\n", - " 0.61244507, 0.99727872, 0.99889948, 0.96362743, 0.99823526,\n", - " 0.99929842, 0.8174303 , 0.99995761, 0.75850867, 0.82073982,\n", - " 0.99868077, 0.93805817, 0.9590425 , 0.99986148, 0.98489765,\n", - " 0.99932773, 0.99190878, 0.99611326, 0.99188202, 0.97022283,\n", - " 0.99995761, 0.99952569, 0.79266011, 0.99995761, 0.99951814,\n", - " 0.51470721, 0.93648506, 0.98712866, 0.99825118, 0.98164791,\n", - " 0.99880687, 0.99581128, 0.91157752, 0.96901269, 0.91401642,\n", - " 0.97788637, 0.47319109, 0.96837755, 0.99917991, 0.97553767,\n", - " 0.9115915 , 0.93637792, 1. , 0.9780679 , 0.99987337,\n", - " 0.98673071, 0.94671638, 1. , 0.99674013, 0.81413033,\n", - " 0.99252611, 0.98315239, 0.99995761, 1. , 0.99168082])],\n", - " [array([0.99997838, 0.99997838, 0.99366458, ..., 0.98490464, 0.99997838,\n", - " 0.99997838]),\n", - " array([0.99997838, 0.99158724, 0.9593331 , 0.99997838, 0.99997838,\n", - " 0.6430424 , 0.98022972, 0.99997838, 0.99997838, 0.99997838,\n", - " 0.83231126, 0.97460678, 0.99997838, 0.99997838, 0.99997838,\n", - " 0.99997838, 0.99997838, 0.99997838, 0.97350531, 0.98711399,\n", - " 0.97474 , 0.97754749, 0.99997838, 0.99997838, 0.82523946,\n", - " 0.95176214, 0.98425346, 0.99997838, 0.99997838, 0.95645784,\n", - " 0.99997838, 0.99158724, 0.99997838, 0.99997838, 0.99997838,\n", - " 0.99997838, 0.42528774, 0.99997838, 0.99366458, 0.99997838,\n", - " 0.99997838, 0.99997838, 0.98626635, 0.8916939 , 0.92207812,\n", - " 0.99997838, 0.93263681, 0.99997838, 0.99997838, 0.99997838,\n", - " 0.48627821, 0.66588097, 0.99997838, 0.84636986, 0.51659442,\n", - " 0.55049301, 0.99997838, 0.93312716, 0.87635708, 0.99997838,\n", - " 0.67522554, 0.95959817, 0.8353301 , 0.99997838, 0.80359936,\n", - " 0.84354092, 0.94038261, 0.99366458, 0.94231953, 0.98339412,\n", - " 0.54316887, 0.99997838, 0.91879877, 0.99082099, 0.8373467 ,\n", - " 0.99997838, 0.99997838, 0.73486649, 0.99082099, 0.99997838,\n", - " 0.99366458, 0.99997838, 0.99997838, 0.91907079, 0.99511118,\n", - " 0.99997838, 0.69562929, 0.99366458, 0.69029752, 0.48936457,\n", - " 0.99997838, 0.96642972, 0.83794616, 0.98626635, 0.9018534 ,\n", - " 0.81885515, 0.99997838, 0.98956957, 0.98591753, 0.98956957,\n", - " 0.82606179, 0.6622718 , 0.81547477, 0.99997838, 0.96734452,\n", - " 0.71824325, 0.98022972, 0.99158724, 0.89979038, 0.52845313,\n", - " 0.74456965, 0.56963545, 0.98110955, 0.99997838, 0.89903183,\n", - " 0.99366458, 0.99997838, 0.76029562, 0.99366458, 0.97502809,\n", - " 0.81269791, 0.99997838, 0.99997838, 0.76726867, 0.86530428,\n", - " 0.90923343, 0.99997838, 0.99997838, 0.81801449, 0.82873568,\n", - " 0.86582334, 0.99158724, 0.98797227, 0.99158724, 0.99997838,\n", - " 0.52224016, 0.65352644, 0.91265475, 0.99997838, 0.9388083 ,\n", - " 0.54227798, 0.55479825, 0.99997838, 0.99997838, 0.99366458,\n", - " 0.67318593, 0.84929906, 0.99997838, 0.70695131, 0.65207982,\n", - " 0.95249991, 0.5742203 , 0.52777387, 0.50292659, 0.83451582,\n", - " 0.67143931, 0.51820565, 0.99158724, 0.99366458, 0.67950819,\n", - " 0.60176915, 0.91721127, 0.98797227, 0.55951869, 0.98665461,\n", - " 0.99997838, 0.96941126, 0.99997838, 0.92482412, 0.99997838,\n", - " 0.41608801, 0.98044374, 0.98367858, 0.79225363, 0.67948173,\n", - " 0.63383746, 0.99997838, 0.77878974, 0.56522767, 0.98711399,\n", - " 0.99997838, 0.99997838, 0.48551272, 0.44123527, 0.8618542 ,\n", - " 0.80482928, 0.66985776, 0.62017624, 0.80381936, 0.99997838,\n", - " 0.50302215, 0.92068908, 0.60003479, 0.99997838, 0.46948365,\n", - " 0.63186242, 0.57837281, 0.87266019, 0.49218298, 0.97624836,\n", - " 0.61514633, 0.75956056, 0.99158724, 0.52672006, 0.67979649,\n", - " 0.50462331, 0.63833029, 0.8729833 , 0.55727932, 0.74518438,\n", - " 0.83796546, 0.42827483, 0.6028738 , 0.6460533 , 0.66026692,\n", - " 0.89718609, 0.56121631, 0.89207323, 0.90079797, 0.90251757,\n", - " 0.48341399, 0.95210094, 0.93469533, 0.8784381 , 0.85130809,\n", - " 0.7299571 , 0.90606898, 0.46443531, 0.91922508, 0.517577 ,\n", - " 0.62493851, 0.75421951, 0.79758595, 0.48424467, 0.54629852,\n", - " 0.92180986, 0.90404411, 0.96625165, 0.69760277, 0.50988639,\n", - " 0.74252501, 0.63025507, 0.55954058, 0.92841711, 0.97862568,\n", - " 0.85332826, 0.8618675 , 0.66919036, 0.88371602, 0.50535152,\n", - " 0.91131174, 0.87058956, 0.99997838, 0.48621124, 0.98207612,\n", - " 0.98283078, 0.6424557 , 0.98283078, 0.84686708, 0.97562108,\n", - " 0.63025101, 0.95330591, 0.91126367, 0.72815909, 0.84603823,\n", - " 0.81786313, 0.89664854, 0.54297098, 0.96811424, 0.91625621,\n", - " 0.97049195, 0.91136191, 0.73328235, 0.52086934, 0.99366458,\n", - " 0.9444916 , 0.97721666, 0.8997133 , 0.6296425 , 0.93076223,\n", - " 0.75638058, 0.94494951, 0.91485927, 0.93323873, 0.50721054,\n", - " 0.96521985, 0.98256799, 0.98339412, 0.56478882, 0.96951585,\n", - " 0.59774062, 0.49922724, 0.56840195, 0.62382395, 0.68012543,\n", - " 0.61232661, 0.91464666, 0.47161347, 0.84883522, 0.83657611,\n", - " 0.99997838, 0.40833807, 0.97843989, 0.60743652, 0.99082099,\n", - " 0.99997838, 0.59235794, 0.86037725, 0.636365 , 0.4707931 ,\n", - " 0.47240448, 0.91348542, 0.69245315, 0.67717818, 0.68309037,\n", - " 0.63369922, 0.99997838, 0.61570557, 0.58799471, 0.49880387,\n", - " 0.99997838, 0.99997838, 0.97187984, 0.65621282, 0.9593331 ,\n", - " 0.48673223, 0.451876 , 0.99366458, 0.59827355, 0.56076155,\n", - " 0.51885154, 0.86541917, 0.69715507, 0.72230997, 0.98665461,\n", - " 0.99158724, 0.39775796, 0.94062081, 0.94752323, 0.61315125,\n", - " 0.45684355, 0.55451038, 0.74093226, 0.5792872 , 0.76190207,\n", - " 0.86432683, 0.83636286, 0.86346949, 0.87735785, 0.99511118,\n", - " 0.99997838, 0.99997838, 0.94199834, 0.98842466, 0.754898 ,\n", - " 0.99997838, 0.99997838, 0.59709449, 0.99997838, 0.98157524,\n", - " 0.98894018, 0.95047799, 0.9380443 , 0.98207612, 0.97738643,\n", - " 0.99997838, 0.45695218, 0.48714607, 0.99997838, 0.99997838,\n", - " 0.99158724, 0.99997838, 0.99997838, 0.95052734, 0.99997838,\n", - " 0.82827344, 0.99997838, 0.93767139, 0.99997838, 0.96129798,\n", - " 0.83456648, 0.96781827, 0.99997838, 0.98134006, 0.99511118,\n", - " 0.98308313, 0.59600256, 0.57909334, 0.91709976, 0.88796416,\n", - " 0.99997838, 0.97959641, 0.99997838, 0.98626635, 0.58653618,\n", - " 0.99997838, 0.59163431, 0.5578085 , 0.98797227, 0.99997838,\n", - " 0.99997838, 0.88296602, 0.71306242, 0.55950593, 0.44617884,\n", - " 0.54460946, 0.99366458, 0.72448978, 0.55246941, 0.55173172,\n", - " 0.85598182, 0.53664671, 0.51680191, 0.94370167, 0.60459903,\n", - " 0.61021523, 0.74076338, 0.99158724, 0.72585904, 0.41185079,\n", - " 0.98283078, 0.86918438, 0.68039792, 0.95215012, 0.8172085 ,\n", - " 0.65101365, 0.68869167, 0.46314638, 0.56729717, 0.66541896,\n", - " 0.88143663, 0.45250995, 0.62922041, 0.54530809, 0.53172389,\n", - " 0.8186474 , 0.85391964, 0.76621126, 0.48372616, 0.81953893,\n", - " 0.93896918, 0.59416247, 0.85426039, 0.52133263, 0.59720316,\n", - " 0.72749491, 0.40840347, 0.50917097, 0.7975714 , 0.92414273,\n", - " 0.98339412, 0.49465567, 0.79903937, 0.99511118, 0.66794631,\n", - " 0.865925 , 0.42453445, 0.52815806, 0.51667298, 0.97774326,\n", - " 0.47001377, 0.61106181, 0.84145626, 0.9852371 , 0.75957199,\n", - " 0.99997838, 0.88842579, 0.89599221, 0.99997838, 0.90657022,\n", - " 0.96496321, 0.99158724, 0.73125241, 0.99366458, 0.99997838,\n", - " 0.42093062, 0.99997838, 0.97235037, 0.92086944, 0.83095217,\n", - " 0.98490464, 0.60610019, 0.89924836, 0.95532678, 0.54351332,\n", - " 0.89073234, 0.44147444, 0.99997838, 0.99997838, 0.99082099,\n", - " 0.86114498, 0.77479971, 0.94210653, 0.81834237, 0.98842466,\n", - " 0.98367858, 0.49119487, 0.58899636, 0.99366458, 0.94890045])]],\n", - " [[array([3, 8, 8, ..., 5, 1, 7]),\n", - " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,\n", - " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", - " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", - " 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", - " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", - " 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", - " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", - " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", - " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", - " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9])],\n", - " [array([3, 8, 8, ..., 5, 1, 7]),\n", - " array([0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,\n", - " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", - " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", - " 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", - " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", - " 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", - " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", - " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", - " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", - " 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", - " 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", - " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", - " 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9])]])" - ] - }, - "execution_count": 199, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Try linear and fine-tuning models which have very different ID and OOD accs.\n", - "# On CIFAR, Im-n-C10\n", - "\n", - "config_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d01/config.json',\n", - " '../logs/imnet_cifar_all_ft_0d01/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d01/checkpoints/ckp_last',\n", - " '../logs/imnet_cifar_all_ft_0d01/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['lin_model', 'ft_model']\n", - "loader_names = ['cifar', 'imnc']\n", - "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 201, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cifar10-test\n", - "imnet-n-cifar\n", - "Ave lin_model confidence for cifar: 0.9127064347267151\n", - "Ave lin_model confidence for imnc: 0.9176557660102844\n", - "Ave ft_model confidence for cifar: 0.9871745109558105\n", - "Ave ft_model confidence for imnc: 0.9197461605072021\n", - "Dataset cifar: \n", - "Model lin_model: 0.9076\n", - "Model ft_model: 0.9652\n", - "Combined 0.9638\n", - "Dataset imnc: \n", - "Model lin_model: 0.764\n", - "Model ft_model: 0.71\n", - "Combined 0.786\n" - ] - } - ], - "source": [ - "# Try the best linear and fine-tuned models on CIFAR, Im-n-C10\n", - "\n", - "config_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d003/config.json',\n", - " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d003/checkpoints/ckp_last',\n", - " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['lin_model', 'ft_model']\n", - "loader_names = ['cifar', 'imnc']\n", - "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 205, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cifar10-test\n", - "imnet-n-cifar\n", - "Ave fine-tuned1 confidence for cifar: 0.9832788109779358\n", - "Ave fine-tuned1 confidence for imnc: 0.9021713733673096\n", - "Ave fine-tuned2 confidence for cifar: 0.9871745109558105\n", - "Ave fine-tuned2 confidence for imnc: 0.9197461605072021\n", - "Dataset cifar: \n", - "Model fine-tuned1: 0.9598\n", - "Model fine-tuned2: 0.9652\n", - "Combined 0.9655\n", - "Dataset imnc: \n", - "Model fine-tuned1: 0.686\n", - "Model fine-tuned2: 0.71\n", - "Combined 0.704\n" - ] - } - ], - "source": [ - "# Control: Try two fine-tuned models on CIFAR, Im-n-C10\n", - "\n", - "config_paths = [\n", - " '../logs/imnet_cifar_all_ft_0d001/config.json',\n", - " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/imnet_cifar_all_ft_0d001/checkpoints/ckp_last',\n", - " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['fine-tuned1', 'fine-tuned2']\n", - "loader_names = ['cifar', 'imnc']\n", - "loader_indices = [0, 4] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 207, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cifar10-test\n", - "cinic-val\n", - "Ave lin_model confidence for cifar: 0.9127064347267151\n", - "Ave lin_model confidence for cinic: 0.8465512990951538\n", - "Ave ft_model confidence for cifar: 0.9871745109558105\n", - "Ave ft_model confidence for cinic: 0.9467272162437439\n", - "Dataset cifar: \n", - "Model lin_model: 0.9076\n", - "Model ft_model: 0.9652\n", - "Combined 0.9638\n", - "Dataset cinic: \n", - "Model lin_model: 0.7216285714285714\n", - "Model ft_model: 0.7908714285714286\n", - "Combined 0.7834428571428571\n" - ] - } - ], - "source": [ - "# Battle testing this: what if fine-tuned model is better in both?\n", - "# On CIFAR, cinic\n", - "\n", - "config_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d003/config.json',\n", - " '../logs/imnet_cifar_all_ft_0d003/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/imnet_cifar_all_linp_0d003/checkpoints/ckp_last',\n", - " '../logs/imnet_cifar_all_ft_0d003/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['lin_model', 'ft_model']\n", - "loader_names = ['cifar', 'cinic']\n", - "loader_indices = [0, 2] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 203, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "source_val_living\n", - "target_val_living\n", - "Ave lin_model confidence for e30_src: 0.3781175911426544\n", - "Ave lin_model confidence for e30_trg: 0.2673947513103485\n", - "Ave ft_model confidence for e30_src: 0.9443250298500061\n", - "Ave ft_model confidence for e30_trg: 0.8535376787185669\n", - "Dataset e30_src: \n", - "Model lin_model: 0.789\n", - "Model ft_model: 0.8725\n", - "Combined 0.8803333333333333\n", - "Dataset e30_trg: \n", - "Model lin_model: 0.6496666666666666\n", - "Model ft_model: 0.5401666666666667\n", - "Combined 0.6256666666666667\n" - ] - } - ], - "source": [ - "# Try Entity 30.\n", - "\n", - "config_paths = [\n", - " '../logs/entity30_moco_linprobe_0.003/config.json',\n", - " '../logs/entity30_moco_ft_0.003/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/entity30_moco_linprobe_0.003/checkpoints/ckp_last',\n", - " '../logs/entity30_moco_ft_0.003/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['lin_model', 'ft_model']\n", - "loader_names = ['e30_src', 'e30_trg']\n", - "loader_indices = [0, 1] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 206, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "source_val_living\n", - "target_val_living\n", - "Ave lin_model confidence for l17_src: 0.4781600534915924\n", - "Ave lin_model confidence for l17_trg: 0.3302820920944214\n", - "Ave ft_model confidence for l17_src: 0.969921886920929\n", - "Ave ft_model confidence for l17_trg: 0.9005916714668274\n", - "Dataset l17_src: \n", - "Model lin_model: 0.9\n", - "Model ft_model: 0.9241176470588235\n", - "Combined 0.94\n", - "Dataset l17_trg: \n", - "Model lin_model: 0.7341176470588235\n", - "Model ft_model: 0.6541176470588236\n", - "Combined 0.731764705882353\n" - ] - } - ], - "source": [ - "# Try Living 17.\n", - "\n", - "config_paths = [\n", - " '../logs/breeds_moco_linprobe_0.003/config.json',\n", - " '../logs/breeds_moco_ft_0.003/config.json'\n", - "]\n", - "\n", - "checkpoint_paths = [\n", - " '../logs/breeds_moco_linprobe_0.003/checkpoints/ckp_last',\n", - " '../logs/breeds_moco_ft_0.003/checkpoints/ckp_last'\n", - "]\n", - "\n", - "model_names = ['lin_model', 'ft_model']\n", - "loader_names = ['l17_src', 'l17_trg']\n", - "loader_indices = [0, 1] # Relative to the config file in the first config path in config_paths.\n", - "\n", - "_ = combined_calibration_accs(config_paths, checkpoint_paths, model_names, loader_names, loader_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2, 1])" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = np.array([[1, 2],[3, 4],[5, 6]])\n", - "a[np.array([0, 0, 0]), np.array([0, 1, 0])]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "import calibration as cal\n", - "\n", - "def combine_preds(model_probs, labels_id, labels_ood):\n", - " model\n", - " for model in range(2):\n", - " for domain in range(2):\n", - " \n", - " model1_id_confs = np.max(model1_probs_id, axis=1)\n", - " model2_id_confs = np.max(model2_probs_id, axis=1)\n", - " model1_ood_confs = np.max(model1_probs_ood, axis=1)\n", - " model2_ood_confs = np.max(model2_probs_ood, axis=1)\n", - " model1_id_preds = np.argmax(model1_probs_id, axis=1)\n", - " model2_id_c = np.argmax(model2_probs_id, axis=1)\n", - " model1_ood_confs = np.argmax(model1_probs_ood, axis=1)\n", - " model2_ood_confs = np.argmax(model2_probs_ood, axis=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'train_dataset': {'classname': 'torchvision.datasets.CIFAR10',\n", - " 'args': {'train': True,\n", - " 'download': False,\n", - " 'root': '/u/scr/ananya/cifar10_dataset'},\n", - " 'transforms': [{'classname': 'torchvision.transforms.Resize',\n", - " 'args': {'size': 224}},\n", - " {'classname': 'torchvision.transforms.ToTensor'},\n", - " {'classname': 'torchvision.transforms.Normalize',\n", - " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]},\n", - " 'default_test_transforms': [{'classname': 'torchvision.transforms.Resize',\n", - " 'args': {'size': [224, 224]}},\n", - " {'classname': 'torchvision.transforms.ToTensor'},\n", - " {'classname': 'torchvision.transforms.Normalize',\n", - " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}],\n", - " 'test_datasets': [{'name': 'cifar10-test',\n", - " 'max_test_examples': 1000,\n", - " 'classname': 'torchvision.datasets.CIFAR10',\n", - " 'args': {'train': False,\n", - " 'download': False,\n", - " 'root': '/u/scr/ananya/cifar10_dataset'}},\n", - " {'name': 'stl-test',\n", - " 'max_test_examples': 1000,\n", - " 'classname': 'datasets.stl_cifar_style.STL10',\n", - " 'args': {'root': '/u/scr/ananya/stl10_dataset', 'split': 'test'}},\n", - " {'name': 'cinic-val',\n", - " 'classname': 'datasets.cinic.CINICImNet',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/u/scr/ananya/cinic-10-imagenet', 'mode': 'valid'}},\n", - " {'name': 'stl-32x32',\n", - " 'classname': 'datasets.stl_cifar_style.STL10',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/u/scr/ananya/stl10_dataset', 'split': 'test'},\n", - " 'transforms': [{'classname': 'torchvision.transforms.Resize',\n", - " 'args': {'size': 32}},\n", - " {'classname': 'torchvision.transforms.Resize', 'args': {'size': 224}},\n", - " {'classname': 'torchvision.transforms.ToTensor'},\n", - " {'classname': 'torchvision.transforms.Normalize',\n", - " 'args': {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}}]},\n", - " {'name': 'imnet-n-cifar',\n", - " 'classname': 'datasets.imnet_intersect_c10.ImNetnC10',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/balanced_imnet_intersect_c10_val/'}},\n", - " {'name': 'fog-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'fog',\n", - " 'severity': 2}},\n", - " {'name': 'fog-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'fog',\n", - " 'severity': 4}},\n", - " {'name': 'zoom-blur-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'zoom_blur',\n", - " 'severity': 2}},\n", - " {'name': 'zoom-blur-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'zoom_blur',\n", - " 'severity': 4}},\n", - " {'name': 'gaussian-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'gaussian_noise',\n", - " 'severity': 2}},\n", - " {'name': 'gaussian-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'gaussian_noise',\n", - " 'severity': 4}},\n", - " {'name': 'pixelate-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'pixelate',\n", - " 'severity': 2}},\n", - " {'name': 'pixelate-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'pixelate',\n", - " 'severity': 4}},\n", - " {'name': 'shotnoise-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'shot_noise',\n", - " 'severity': 2}},\n", - " {'name': 'shotnoise-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'shot_noise',\n", - " 'severity': 4}},\n", - " {'name': 'glassblur-cifar-2',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'glass_blur',\n", - " 'severity': 2}},\n", - " {'name': 'glassblur-cifar-4',\n", - " 'classname': 'datasets.cifar10c.CIFAR10C',\n", - " 'max_test_examples': 1000,\n", - " 'args': {'root': '/juice/scr/ananya/CIFAR-10-C/',\n", - " 'corruption': 'glass_blur',\n", - " 'severity': 4}}],\n", - " 'inherit': ['/juice/scr/ananya/cifar_experiments/custom_training/configs/datasets_cifar_test_all.yaml'],\n", - " 'log_interval': 5000,\n", - " 'use_cuda': True,\n", - " 'save_freq': 101,\n", - " 'epochs': 100,\n", - " 'batch_size': 128,\n", - " 'num_workers': 8,\n", - " 'save_all_checkpoints': False,\n", - " 'finetune': True,\n", - " 'num_classes': 10,\n", - " 'linear_probe': True,\n", - " 'use_net_val_mode': True,\n", - " 'optimizer': {'classname': 'torch.optim.SGD',\n", - " 'args': {'lr': 0.01, 'momentum': 0.9}},\n", - " 'scheduler': {'classname': 'torch.optim.lr_scheduler.StepLR',\n", - " 'args': {'step_size': 100}},\n", - " 'model': {'classname': 'models.imnet_resnet.ResNet50',\n", - " 'args': {'pretrained': True}},\n", - " 'criterion': {'classname': 'torch.nn.CrossEntropyLoss',\n", - " 'args': {'reduction': 'mean'}},\n", - " 'wandb_url': 'https://wandb.ai/p-lambda/cifar/runs/stk89vzs',\n", - " 'run_name': 'imnet_cifar_all_linp_0d01',\n", - " 'group_name': 'imnet_cifar_all_linp',\n", - " 'entity_name': 'p-lambda',\n", - " 'wandb': True}" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "config" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/breeds_example.ipynb b/scripts/breeds_example.ipynb deleted file mode 100644 index 2edc92a..0000000 --- a/scripts/breeds_example.ipynb +++ /dev/null @@ -1,126 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - " \n", - "from datasets import breeds" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = breeds.Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity30', source=True, split='train')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "154263" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(dataset._image_paths_by_class)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[64, 56, 57, 52], [11, 10, 20, 19], [44, 45, 40, 46], [70, 73, 71, 75], [146, 140, 134, 127], [124, 123, 125, 118], [171, 359, 181, 253], [318, 308, 311, 325], [355, 353, 340, 345], [372, 379, 383, 367], [391, 0, 396, 392], [460, 716, 877, 421], [454, 483, 668, 467], [742, 707, 650, 508], [502, 630, 638, 770], [400, 411, 655, 568], [715, 584, 793, 452], [897, 651, 521, 882], [647, 499, 505, 813], [531, 409, 704, 635], [627, 779, 665, 511], [566, 641, 579, 881], [552, 678, 443, 906], [795, 543, 522, 752], [659, 899, 441, 898], [749, 507, 695, 783], [510, 625, 403, 871], [964, 935, 963, 933], [939, 943, 942, 944], [949, 953, 955, 948]]\n" - ] - } - ], - "source": [ - "print(dataset._subclasses)" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ape\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "idx = 40001\n", - "plt.imshow(dataset[idx][0])\n", - "print(dataset._label_map[dataset[idx][1]])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/cifar10c_stl_examples.ipynb b/scripts/cifar10c_stl_examples.ipynb deleted file mode 100644 index ff7de75..0000000 --- a/scripts/cifar10c_stl_examples.ipynb +++ /dev/null @@ -1,532 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - "\n", - "import torchvision\n", - "import torch\n", - "from torchvision import models\n", - "import importlib\n", - "import numpy as np\n", - "from torchvision import transforms\n", - "from datasets import cifar10c\n", - "from datasets import stl_cifar_style\n", - "from datasets import cinic\n", - "import pickle\n", - "import json\n", - "import utils.utils as utils\n", - "from utils.accumulator import Accumulator\n", - "import matplotlib.pyplot as plt\n", - "from PIL import Image\n", - "from matplotlib import cm\n", - "importlib.reload(cifar10c)\n", - "importlib.reload(stl_cifar_style)\n", - "importlib.reload(cinic)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CIFAR-10C Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cifar10c_fog = cifar10c.CIFAR10C(root='/juice/scr/ananya/CIFAR-10-C/', corruption='snow', severity=2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "idx = 15\n", - "img = cifar10c_fog[idx][0]\n", - "plt.imshow(img)\n", - "print(cifar10c_fog[idx][1])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# STL Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "stl_data = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['airplane',\n", - " 'car',\n", - " 'bird',\n", - " 'cat',\n", - " 'deer',\n", - " 'dog',\n", - " 'NONE',\n", - " 'horse',\n", - " 'ship',\n", - " 'truck']" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stl_data.classes" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ship\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "idx = 2004\n", - "img = stl_data[idx][0]\n", - "plt.imshow(img)\n", - "print(stl_data.classes[stl_data[idx][1]])" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "stl_downsampled = stl_cifar_style.STL10(root='/juice/scr/ananya/stl10_dataset/', split='test', download=False,\n", - " transform=transforms.Resize(32))" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "airplane\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "idx = 12\n", - "img = stl_downsampled[idx][0]\n", - "plt.imshow(img)\n", - "print(stl_data.classes[stl_data[idx][1]])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CINIC Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "cinic_directory = '/juice/scr/ananya/cinic-10-imagenet'\n", - "\n", - "cinic_mean = [0.47889522, 0.47227842, 0.43047404]\n", - "cinic_std = [0.24205776, 0.23828046, 0.25874835]\n", - "cinic_data = cinic.CINICImNet(root=cinic_directory, mode='valid', transform=transforms.ToTensor())\n", - "# transform=transforms.Compose([transforms.ToTensor(),\n", - "# transforms.Normalize(mean=cinic_mean,std=cinic_std)]))\n", - "cinic_train = torch.utils.data.DataLoader(\n", - " cinic_data, batch_size=128, shuffle=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "idx = 1\n", - "img = np.transpose(cinic_data[idx][0], axes=[1,2,0])\n", - "plt.imshow(img)\n", - "print(cinic_data[idx][1])" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n", - "128\n" - ] - } - ], - "source": [ - "batch = next(iter(cinic_train))\n", - "input, target = batch\n", - "print(len(batch))\n", - "print(len(input))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Play around with models " - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_ft = models.resnet50(pretrained=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "list(list(model_ft.children())[0].parameters())[0].requires_grad = False" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ResNet(\n", - " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (layer1): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer2): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer3): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (4): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (5): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer4): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", - " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", - ")" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_ft" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/cifar_notebook.ipynb b/scripts/cifar_notebook.ipynb deleted file mode 100644 index f7085d3..0000000 --- a/scripts/cifar_notebook.ipynb +++ /dev/null @@ -1,289 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import torchvision\n", - "import torch\n", - "import importlib\n", - "import resnet\n", - "import numpy as np\n", - "from torchvision import transforms\n", - "import cifar10_resized\n", - "import pickle\n", - "import json\n", - "import utils.utils as utils\n", - "from utils.accumulator import Accumulator\n", - "import train\n", - "importlib.reload(train)\n", - "importlib.reload(cifar10_resized)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Read config.\n", - "# Load checkpoint\n", - "config_path = './logs/small_run_merlin_7/config.json'\n", - "checkpoint_path = './logs/small_run_merlin_7/checkpoints/ckp_best'\n", - "batch_size, num_workers = 128, 16\n", - "use_cuda = True\n", - "with open(config_path) as f:\n", - " device = 'cuda'\n", - " config = json.load(f)\n", - "net = utils.initialize(config['model'])\n", - "if use_cuda:\n", - " net.cuda()\n", - "utils.load_ckp(checkpoint_path, net)\n", - "test_data = utils.init_dataset(config['test_dataset'])\n", - "test_loader = torch.utils.data.DataLoader(\n", - " test_data, batch_size=batch_size,\n", - " shuffle=False, num_workers=num_workers)\n", - "criterion = utils.initialize(config['criterion'])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "val_loss, val_acc = train.get_test_stats(config, net, test_loader, criterion, device)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.3026" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "val_acc.get_mean()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tuning the last linear layer which doesn't really work" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(10000, 512) (10000,) (10000, 10)\n" - ] - } - ], - "source": [ - "# Train linear model on top of features.\n", - "net.eval()\n", - "features_list, logits_list, labels_list = [], [], []\n", - "with torch.no_grad():\n", - " for data in test_loader:\n", - " if use_cuda:\n", - " data = utils.to_device(data, device)\n", - " images, labels = data\n", - " outputs, features = net(images, return_features_also=True)\n", - " logits_list.append(outputs.detach().cpu().numpy())\n", - " features_list.append(features.detach().cpu().numpy())\n", - " labels_list.append(labels.detach().cpu().numpy())\n", - "features = np.concatenate(features_list)\n", - "labels = np.concatenate(labels_list)\n", - "logits = np.concatenate(logits_list)\n", - "print(features.shape, labels.shape, logits.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Select tuning and testing indices\n", - "seed = 0\n", - "num_tune = 5000\n", - "num_test = len(test_data) - num_tune\n", - "rng = np.random.default_rng(seed=seed)\n", - "indices = rng.permutation(len(test_data))\n", - "tune_indices = indices[:num_tune]\n", - "test_indices = indices[num_tune:]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.3006\n" - ] - } - ], - "source": [ - "# Get model accuracy on second part\n", - "test_logits = logits[test_indices]\n", - "test_preds = np.argmax(test_logits, axis=1)\n", - "test_labels = labels[test_indices]\n", - "print(np.mean(test_preds==test_labels))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/juice/scr/ananya/cifar_experiments/env/lib/python3.7/site-packages/sklearn/linear_model/_logistic.py:764: ConvergenceWarning: lbfgs failed to converge (status=1):\n", - "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", - "\n", - "Increase the number of iterations (max_iter) or scale the data as shown in:\n", - " https://scikit-learn.org/stable/modules/preprocessing.html\n", - "Please also refer to the documentation for alternative solver options:\n", - " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", - " extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n" - ] - } - ], - "source": [ - "# Train sklearn linear probe on first part, measure acc on second part\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "tune_features = features[tune_indices]\n", - "test_features = features[test_indices]\n", - "tune_labels = labels[tune_indices]\n", - "test_labels = labels[test_indices]\n", - "# clf = RandomForestClassifier(max_depth=3, random_state=0).fit(tune_features, tune_labels)\n", - "clf = LogisticRegression(random_state=0, C=0.1).fit(tune_features, tune_labels)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.3084\n", - "0.3102\n" - ] - } - ], - "source": [ - "# Get training acc\n", - "from scipy.special import softmax\n", - "tune_preds = clf.predict(tune_features)\n", - "tune_acc = np.mean(tune_preds==tune_labels)\n", - "print(tune_acc)\n", - "test_preds = clf.predict(test_features)\n", - "test_pred_probs = clf.predict_proba(test_features)\n", - "test_acc = np.mean(test_preds==test_labels)\n", - "print(test_acc)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9394416\n" - ] - } - ], - "source": [ - "test_probs = softmax(test_logits, axis=1)\n", - "print(np.mean(np.max(test_probs, axis=1)))" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.812295134468732\n" - ] - } - ], - "source": [ - "print(np.mean(np.max(test_pred_probs, axis=1)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/cinic_imagenet_extractor.ipynb b/scripts/cinic_imagenet_extractor.ipynb deleted file mode 100644 index ae54ac4..0000000 --- a/scripts/cinic_imagenet_extractor.ipynb +++ /dev/null @@ -1,118 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import glob\n", - "import numpy as np\n", - "from shutil import copyfile\n", - "symlink = True # If this is false the files are copied instead\n", - "combine_train_valid = False # If this is true, the train and valid sets are ALSO combined" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "cinic_directory = \"../../../cinic\"\n", - "imagenet_directory = \"../../../cinic-10-imagenet\"\n", - "classes = [\"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n", - "sets = ['train', 'valid', 'test']\n", - "if not os.path.exists(imagenet_directory):\n", - " os.makedirs(imagenet_directory)\n", - "if not os.path.exists(imagenet_directory + '/train'):\n", - " os.makedirs(imagenet_directory + '/train')\n", - "if not os.path.exists(imagenet_directory + '/test'):\n", - " os.makedirs(imagenet_directory + '/test')\n", - " \n", - "for c in classes:\n", - " if not os.path.exists('{}/train/{}'.format(imagenet_directory, c)):\n", - " os.makedirs('{}/train/{}'.format(imagenet_directory, c))\n", - " if not os.path.exists('{}/test/{}'.format(imagenet_directory, c)):\n", - " os.makedirs('{}/test/{}'.format(imagenet_directory, c))\n", - " if not combine_train_valid:\n", - " if not os.path.exists('{}/valid/{}'.format(imagenet_directory, c)):\n", - " os.makedirs('{}/valid/{}'.format(imagenet_directory, c))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "for s in sets:\n", - " for c in classes:\n", - " source_directory = '{}/{}/{}'.format(cinic_directory, s, c)\n", - " filenames = glob.glob('{}/*.png'.format(source_directory))\n", - " for fn in filenames:\n", - " dest_fn = fn.split('/')[-1]\n", - " if (s == 'train' or s == 'valid') and combine_train_valid and 'cifar' not in fn.split('/')[-1]:\n", - " dest_fn = '{}/train/{}/{}'.format(imagenet_directory, c, dest_fn)\n", - " if symlink:\n", - " if not os.path.islink(dest_fn):\n", - " os.symlink(fn, dest_fn)\n", - " else:\n", - " copyfile(fn, dest_fn)\n", - " \n", - " elif (s == 'train') and 'cifar' not in fn.split('/')[-1]:\n", - " dest_fn = '{}/train/{}/{}'.format(imagenet_directory, c, dest_fn)\n", - " if symlink:\n", - " if not os.path.islink(dest_fn):\n", - " os.symlink(fn, dest_fn)\n", - " else:\n", - " copyfile(fn, dest_fn)\n", - " \n", - " elif (s == 'valid') and 'cifar' not in fn.split('/')[-1]:\n", - " dest_fn = '{}/valid/{}/{}'.format(imagenet_directory, c, dest_fn)\n", - " if symlink:\n", - " if not os.path.islink(dest_fn):\n", - " os.symlink(fn, dest_fn)\n", - " else:\n", - " copyfile(fn, dest_fn)\n", - " \n", - " elif s == 'test' and 'cifar' not in fn.split('/')[-1]:\n", - " dest_fn = '{}/test/{}/{}'.format(imagenet_directory, c, dest_fn)\n", - " if symlink:\n", - " if not os.path.islink(dest_fn):\n", - " os.symlink(fn, dest_fn)\n", - " else:\n", - " copyfile(fn, dest_fn)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/copy_dataset.sh b/scripts/copy_dataset.sh new file mode 100755 index 0000000..6141572 --- /dev/null +++ b/scripts/copy_dataset.sh @@ -0,0 +1,136 @@ +#!/bin/bash + +set -ex + +# Usernames to give read/write permissions to +USERNAMES="ananya eix kshen6 rmjones" + +show_help() { + usage_string="Usage: copy_dataset.sh" + usage_string+=" dataset_name" + usage_string+=" [-s|--src DATASET_SOURCE]" + usage_string+=" [-d|--dst DESTINATION_FOLDER]" + + usage_string+="\n\nOptions:\n" + usage_string+="\t-s|--src Path to dataset to copy\n" + usage_string+="\t-d|--dst Path to destination folder\n" + printf "$usage_string" +} + +if [[ "$1" = "-h" || "$1" = "--help" ]]; then + show_help + exit +fi + +if [[ $# -lt 1 ]]; then + show_help + exit 1 +fi + +dataset_name=$1 + + +if [[ "$dataset_name" != imagenet && "$dataset_name" != domainnet ]]; then + echo "Unsupported dataset: $dataset_name" + exit 1 +fi +shift + +if [ "$dataset_name" = imagenet ]; then + dataset_src=/u/scr/nlp/eix/imagenet +elif [ "$dataset_name" = domainnet ]; then + dataset_src=/u/scr/nlp/domainnet/domainnet.zip +else + echo "Unsupported dataset $dataset_name" + exit 1 +fi +dst_folder=/scr/biggest/$dataset_name + +while true; do + case $1 in + -h|--help) + show_help + exit + ;; + -s|--src) + if [[ "$2" ]]; then + dataset_src=$2 + shift + else + echo "-s|--src must be non-empty!"; exit 1 + fi + ;; + -d|--dst) + if [[ "$2" ]]; then + dst_folder=$2 + shift + else + echo "-d|--dst must be non-empty!"; exit 1 + fi + ;; + *) + if [ -z "$1" ]; then + break + else + echo "Unsupported argument: $1"; exit 1 + fi + ;; + esac + shift +done + +if [ "$dataset_name" = imagenet ]; then + for folder in train val; do + if [ ! -f "$dataset_src/$folder.tar.gz" ]; then + echo "Missing ImageNet file $folder.tar.gz!" + exit 1 + fi + done +elif [ "$dataset_name" = domainnet ]; then + if [ ! "${dataset_src##*.}" = zip ]; then + echo "Expecting .zip file for DomainNet dataset" + exit 1 + fi +fi + +ACL_STRING="" +for username in $(echo "$USERNAMES"); do + if [[ $username = $(whoami) ]]; then + continue + fi + ACL_STRING+="u:$username:rwx," +done +ACL_STRING=${ACL_STRING: : -1} # Remove trailing comma + +if [ ! -d "$dst_folder" ]; then + mkdir -p $dst_folder + mkdir -p $dst_folder/tmp + setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder +fi + +a1=$RANDOM +a2=$RANDOM +if [ "$dataset_name" = imagenet ]; then + for folder in train val; do + if [ ! -f "$dst_folder/$folder.tar.gz" ]; then + echo "Copying $dataset_src/$folder.tar.gz to $dst_folder..." + cp $dataset_src/$folder.tar.gz $dst_folder/tmp_$a1$a2.tar.gz + mv -n $dst_folder/tmp_$a1$a2.tar.gz $dst_folder/$folder.tar.gz + fi + if [ ! -d "$dst_folder/$folder" ]; then + echo "Extracting $dst_folder/$folder.tar.gz..." + mkdir -p $dst_folder/tmp_$a1$a2 + tar xzf $dst_folder/$folder.tar.gz -C $dst_folder/tmp_$a1$a2 + mv -n $dst_folder/tmp_$a1$a2/* $dst_folder/ + fi + done +elif [ "$dataset_name" = domainnet ]; then + if [ ! -f "$dst_folder/domainnet.zip" ]; then + echo "Copying DomainNet files to $dst_folder" + cp $dataset_src $dst_folder + unzip -q $dst_folder/domainnet.zip -d $dst_folder + setfacl -Rm $ACL_STRING $dst_folder + fi +fi + + diff --git a/scripts/copy_local.sh b/scripts/copy_local.sh new file mode 100644 index 0000000..b1cb065 --- /dev/null +++ b/scripts/copy_local.sh @@ -0,0 +1,16 @@ + +SOURCE_PATH=$1 +BASE_DST=${3:-/scr/biggest} +DST_PATH=$BASE_DST/$2 +TAR_NAME=$(basename $SOURCE_PATH) + +if [ ! -d "$DST_PATH" ]; then + mkdir -p $DST_PATH +fi + +if [ ! -f "$DST_PATH/$TAR_NAME" ]; then + echo "Copying files to $DST_PATH" + cp $SOURCE_PATH $DST_PATH + tar -C $DST_PATH -xzf $DST_PATH/$TAR_NAME +fi + diff --git a/scripts/moco_simclr_loading.ipynb b/scripts/moco_simclr_loading.ipynb deleted file mode 100644 index ebb2ed0..0000000 --- a/scripts/moco_simclr_loading.ipynb +++ /dev/null @@ -1,541 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 133, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 133, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# So we can load files from other sub-directories, e.g. datasets.\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join('..'))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)\n", - " \n", - "from models import imnet_resnet\n", - "from torch import nn\n", - "\n", - "import importlib\n", - "importlib.reload(imnet_resnet)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "model = imnet_resnet.ResNet50(pretrained=True, pretrain_style='mocov2', checkpoint_path='/u/scr/ananya/simclr_weights/moco_v2_800ep_pretrain.pth.tar')" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Sequential(\n", - " (resnet): ResNet(\n", - " (padding): ConstantPad2d(padding=(1, 1, 1, 1), value=0.0)\n", - " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(2, 2), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (layer1): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer2): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer3): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (4): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (5): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer4): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", - " )\n", - " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", - ")" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model._model" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "metadata": {}, - "outputs": [], - "source": [ - "swav_path = '/u/scr/ananya/simclr_weights/swav_800ep_pretrain.pth.tar'\n", - "model = imnet_resnet.ResNet50(pretrained=True, pretrain_style='swav', checkpoint_path=swav_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ResNet50(\n", - " (_model): Sequential(\n", - " (resnet): ResNet(\n", - " (padding): ConstantPad2d(padding=(1, 1, 1, 1), value=0.0)\n", - " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(2, 2), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " (layer1): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer2): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer3): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (3): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (4): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (5): Bottleneck(\n", - " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (layer4): Sequential(\n", - " (0): Bottleneck(\n", - " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " (2): Bottleneck(\n", - " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " )\n", - " )\n", - " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", - " )\n", - " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", - " )\n", - ")" - ] - }, - "execution_count": 135, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model" - ] - }, - { - "cell_type": "code", - "execution_count": 136, - "metadata": {}, - "outputs": [], - "source": [ - "from datasets import breeds\n", - "entity30 = breeds.Breeds(root='/u/scr/nlp/imagenet/', breeds_name='entity30')" - ] - }, - { - "cell_type": "code", - "execution_count": 137, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([1, 3, 224, 224])\n" - ] - } - ], - "source": [ - "import torchvision\n", - "import torch\n", - "import torchvision.transforms as transforms\n", - "trans = transforms.Compose(\n", - "[\n", - " transforms.Resize(size=[224,224]),\n", - " torchvision.transforms.ToTensor(),\n", - " torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", - "])\n", - "x = torch.unsqueeze(trans(entity30[0][0]), axis=0)\n", - "x.cuda()\n", - "print(x.shape)\n", - "model.eval()\n", - "model.cuda()\n", - "z = model._model(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([1, 1000])" - ] - }, - "execution_count": 138, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "z.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py new file mode 100644 index 0000000..3c753fd --- /dev/null +++ b/scripts/run_adaptation_experiments.py @@ -0,0 +1,1304 @@ +import argparse +from collections import namedtuple +from copy import deepcopy +import os +import re +import shlex +import subprocess + +PROJECT_NAME = 'finetuning' +WORKSHEET_NAME = 'nlp::ananyak-fine-tuning' +DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' + + +def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): + output_path = args.output_dir + '/' + job_name + sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name + slurm_cmd = f'sbatch --partition={args.partition} --job-name={job_name} --output={output_path} ' +\ + f'--mail-type=END,FAIL --mail-user={args.mail_user} ' + deps = filter(lambda s: str(s) != '-1', deps) + deps = [str(s) for s in deps] + if len(deps) > 0: + slurm_cmd += ' --dependency=afterok:' + ':'.join(deps) + ' ' + slurm_cmd += f' {sbatch_script_path} ' + slurm_cmd += f'"{cmd}"' + print(slurm_cmd + '\n') + output = subprocess.check_output(shlex.split(slurm_cmd)).decode('utf8') + job_names = list(re.findall(r'\d+', output)) + assert(len(job_names) == 1) + return job_names[0] + + +def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=''): + prefix = (f'cl run -n {job_name} -w {WORKSHEET_NAME} --request-docker-image={DOCKER_IMAGE} ' + f'--request-gpus={gpus} --request-memory={mem} --request-cpus={cpus} ') + if nlp: + nlp_opt = '--request-queue tag=nlp ' + else: + nlp_opt = '' + cl_deps_str = ':' + ' :'.join(deps) + bundles = ':unlabeled_extrapolation :scripts :configs ' + cl_deps_str + ' ' + makedirs = '"export PYTHONPATH="."; export PYTHONPATH="' + args.code_dir + '"; ' + codalab_cmd = prefix + nlp_opt + bundles + makedirs + cmd + '"' + print(codalab_cmd) + subprocess.run(shlex.split(codalab_cmd)) + return job_name + + +def run_job(cmd, job_name, args, deps=[]): + if args.codalab: + return run_codalab(cmd, job_name, args, deps=deps) + else: + return run_sbatch(cmd, job_name, args, deps=deps) + + +def format_key_value(k, v): + if type(v) == list: + if type(v[0]) == list: + raise ValueError('We only support 1D lists.') + return f'--{k} ' + ' '.join([str(e) for e in v]) + # I wanted to do this, but this messes up with update_config in utils.py, and hard to fix that. + # if type(v) == bool: + # if v: + # return f'--{k}' + # return '' + return f'--{k}=' + str(v) + + +def get_python_cmd(code_path, python_path='python', kwargs=None, args=None): + if kwargs is not None: + # Make sure to keep the space at the end. + opts = ''.join([f"{format_key_value(k, v)} " for k, v in kwargs.items()]) + # opts += ''.join([f"--{k} " for k, v in kwargs.items() if isinstance(v, bool) and v and '.' not in k]) + else: + opts = '' + python_cmd = python_path + ' ' + code_path + ' ' + python_cmd += opts + if args.codalab: + python_cmd += ' --nowandb ' + return python_cmd + + +def group_run_to_log_path(group_name, run_name, args): + return args.log_dir + '/' + group_name + '/' + run_name + + +def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, root_prefix, + kwargs, args, run_saved=False): + # If run_saved, then we ignore root_prefix since we get this from the config. + kwargs = deepcopy(kwargs) + # Sometimes we might want to run from a saved json config file, in a custom location. + # Saved files have full dataset paths, e.g. /scr/biggest/..., so no need to add root_prefix. + kwargs['config'] = config_path + if not(run_saved): + if not(args.codalab): + kwargs['root_prefix'] = root_prefix + else: + kwargs['root_prefix'] = args.codalab_data_dir + # On slurm, we need to save locally to avoid overloading the distributed file system. + if not(args.codalab): + kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) + kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name + else: + kwargs['log_dir'] = args.log_dir + kwargs['project_name'] = project_name + kwargs['group_name'] = group_name + kwargs['run_name'] = run_name + code_path = args.code_dir + '/' + 'baseline_train.py' + return (get_python_cmd(code_path=code_path, python_path=args.python_path, kwargs=kwargs, + args=args), + kwargs['log_dir']) + + +def config_run(args, kwargs, config_path, run_name, group_name, project_name, + dataset_copy_cmd=None, root_prefix=None, run_saved=False, deps=[], rerun=False): + # If rerun is False, don't rerun if the log firectory exists and contains stats.tsv. + cmd, log_dir = get_baseline_experiment_cmd( + config_path=config_path, run_name=run_name, group_name=group_name, + project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved) + if dataset_copy_cmd is not None and not args.codalab: + cmd = dataset_copy_cmd + ' && ' + cmd + job_name = group_name + '_' + run_name + if os.path.isfile(log_dir + '/stats.tsv') and not(rerun): + # TODO: should we rerun if stats.tsv is not completely filled out? + # Maybe design this a bit better. + return -1 + else: + return run_job(cmd, job_name, args, deps=deps) + + +############################################ +## Functions to get directory/job names. +############################################ + +def hyperparams_to_str(hyperparams, item_sep='_', key_value_sep='-', ignore_name_hypers={}): + """Convert hyperparameters into string.""" + sorted_hyperparams = sorted(hyperparams.items()) + return item_sep.join([str(k) + key_value_sep + str(v) for k, v in sorted_hyperparams + if k not in ignore_name_hypers]) + +def get_group_name(adapt_name, dataset_name, model_name): + return adapt_name+'_'+dataset_name+'_'+model_name + +def get_job_name(adapt_name, dataset_name, model_name, hyperparams): + """Get the name for a run.""" + hyperparams_str = hyperparams_to_str(hyperparams) + return get_group_name(adapt_name, dataset_name, model_name)+'_'+hyperparams_str + +def group_run_to_log_path(group_name, run_name, args): + return args.log_dir + '/' + group_name + '/' + run_name + +def get_run_dir_path(adapt_name, dataset_name, model_name, hyperparams, args): + """Get path to directory for a specific run (method + dataset + hyperparameters).""" + hyperparams_str = hyperparams_to_str(hyperparams) + if args.codalab: + return args.log_dir+'/'+get_job_name(adapt_name, dataset_name, hyperparams) + else: + group_dir_path = get_group_dir_path(adapt_name, dataset_name, model_name) + return group_dir_path + '/ '+ hyperparams_str + '/' + +def get_group_dir_path(adapt_name, dataset_name, model_name, args): + """Get path to directory for all runs for an adaptation method + model on a dataset.""" + if args.codalab: + return args.log_dir + else: + group_name = get_group_name(adapt_name, dataset_name, model_name) + return args.log_dir + '/'+ group_name + '/' + +def get_config_path(args, config_rel_path): + return args.config_dir + '/' + config_rel_path + + +############################################ +## Adaptation sweeps and replication. +############################################ + +def add_dataset_model_deps(deps, args, dataset, model): + if args.codalab: + deps = deps + dataset.bundles + model.bundles + return deps + + +def get_best_config_path(adapt_name, dataset, model, args): + if args.codalab: + summarize_job_name = get_summarize_job_name(adapt_name, dataset.name, args.model_name) + return summarize_job_name + '/best_config.json' + else: + group_dir = get_group_dir_path(adapt_name, dataset.name, args.model_name, args) + return group_dir + '/best_config.json' + + +def add_model_to_kwargs(kwargs, args, model): + assert 'classname' in model.kwargs + for k, v in model.kwargs.items(): + if k == 'checkpoint_rel_path' and v is not None: + kwargs['model.args.checkpoint_path'] = args.pretrained_checkpoints_dir + '/' + v + else: + kwargs['model.' + k] = v + + +def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], rerun=False, + ignore_name_hypers={}, run_name_suffix=''): + run_name = hyperparams_to_str(hyperparams, ignore_name_hypers=ignore_name_hypers) + run_name += run_name_suffix + group_name = get_group_name(adapt_name, dataset.name, args.model_name) + project_name = PROJECT_NAME + kwargs = deepcopy(hyperparams) + add_model_to_kwargs(kwargs, args, model) + config_path = get_config_path(args, dataset.config_rel_path) + dataset_copy_cmd = None + if dataset.slurm_data_cmd is not None: + dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) + deps = add_dataset_model_deps(deps, args, dataset, model) + return config_run(args, kwargs=kwargs, config_path=config_path, + run_name=run_name, group_name=group_name, project_name=project_name, + dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, + deps=deps, rerun=rerun) + + +def run_adapt_replication(adapt_name, dataset, model, seed, args, deps=[], + replication_hyperparams=None, rerun=False): + run_name = 'replication_'+str(seed) + group_name = get_group_name(adapt_name, dataset.name, args.model_name) + project_name = PROJECT_NAME + best_config_path = get_best_config_path(adapt_name, dataset, model, args) + if replication_hyperparams is not None: + kwargs = deepcopy(replication_hyperparams) + else: + kwargs = {} + kwargs['seed'] = seed + dataset_copy_cmd = None + if dataset.slurm_data_cmd is not None: + dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) + deps = add_dataset_model_deps(deps, args, dataset, model) + return config_run(args, kwargs=kwargs, config_path=best_config_path , + run_name=run_name, group_name=group_name, project_name=project_name, + dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, + deps=deps, run_saved=True, rerun=rerun) + + +def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[], rerun=False, + ignore_name_hypers={}): + sweep_ids = [] + for hyperparams in hyperparams_list: + job_id = run_adapt_sweep(adapt_name, dataset, model, + hyperparams=hyperparams, args=args, deps=deps, rerun=rerun, + ignore_name_hypers=ignore_name_hypers) + # Job id of -1 means we didn't run the job because it's already run. + if job_id != -1: + sweep_ids.append(job_id) + return sweep_ids + + +def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replications, + args, deps=[], replication_hyperparams_list=[], rerun=False, + ignore_name_hypers={}): + # Run multiple replications for each sweep run. + sweep_ids = [] + for i in range(num_replications): + for hyperparams in hyperparams_list: + if len(replication_hyperparams_list) > 0: + kwargs = union_dicts(hyperparams, replication_hyperparams_list[i]) + else: + kwargs = deepcopy(hyperparams) + kwargs['seed'] = args.seed + i + job_id = run_adapt_sweep(adapt_name, dataset, model, + hyperparams=kwargs, args=args, deps=deps, rerun=rerun, + ignore_name_hypers=ignore_name_hypers, run_name_suffix='_run'+str(i)) + # Job id of -1 means we didn't run the job because it's already run. + if job_id != -1: + sweep_ids.append(job_id) + return sweep_ids + + +def adaptation_replication(adapt_name, dataset, model, num_replications, args, deps=[], + replication_hyperparams_list=None, rerun=False): + # If replication_hyperparams_list is not None, then it should be the same size as + # num_replications. And we will use the i-th entry of the list as additional hyperparameters + # for the i-th run. Useful if the replication needs to vary checkpoints to other models. + replication_ids = [] + assert (replication_hyperparams_list is None or + len(replication_hyperparams_list) == num_replications) + for i in range(num_replications): + replication_hyperparams = None + if replication_hyperparams_list is not None: + replication_hyperparams = replication_hyperparams_list[i] + job_id = run_adapt_replication(adapt_name, dataset, model, seed=args.seed+i+1, + args=args, deps=deps, replication_hyperparams=replication_hyperparams, rerun=rerun) + if job_id != -1: + replication_ids.append(job_id) + return replication_ids + + +def adaptation_experiment(adapt_name, dataset, model, hyperparams_list, num_replications, args, + deps=[], replication_hyperparams_list=None, rerun=False, ignore_name_hypers={}): + """Sweep over hyperparams_list, find best, and replicate on a dataset for a model""" + # ignore_name_hypers is the set of hyperparameters to ignore in the run name. + sweep_ids = adaptation_sweep(adapt_name, dataset, model, hyperparams_list, + args=args, deps=deps, rerun=rerun, ignore_name_hypers=ignore_name_hypers) + summarize_id = summarize_adaptation(adapt_name, dataset, model, args, + deps=sweep_ids) + replication_ids = adaptation_replication(adapt_name, dataset, model, num_replications, + args=args, replication_hyperparams_list=replication_hyperparams_list, + deps=[summarize_id], rerun=rerun) + summarize_rep_id = summarize_adaptation(adapt_name, dataset, model, args, deps=replication_ids, + replication=True) + all_ids = sweep_ids + [summarize_id] + replication_ids + [summarize_rep_id] + return [summarize_rep_id], all_ids + + +def linprobe_run(args, job_name, model, seed, config_path, features_save_path, results_save_path, + weights_save_path, val_metric, num_reg_values=50, deps=[], rerun=False, aug=True, + root_prefix='', train_mode=False, use_new_bn_stats=False): + extract_code_path = args.code_dir + '/extract_features.py' + kwargs = {} + add_model_to_kwargs(kwargs, args, model) + kwargs['config'] = config_path + kwargs['save_path'] = features_save_path + kwargs['root_prefix'] = root_prefix + if train_mode: + kwargs['train_mode'] = True + if use_new_bn_stats: + kwargs['use_new_bn_stats'] = True + # If no augmentation, then use test transform for train. + kwargs['use_test_transforms_for_train'] = not(aug) + extract_cmd = get_python_cmd(code_path=extract_code_path, python_path=args.python_path, + kwargs=kwargs, args=args) + log_reg_code_path = args.code_dir + '/log_reg_sk.py' + kwargs = { + 'load_path': features_save_path, 'results_save_path': results_save_path, + 'weights_save_path': weights_save_path, 'num_reg_values': num_reg_values, + 'val_metric': val_metric, 'seed': seed, + } + log_reg_cmd = get_python_cmd(code_path=log_reg_code_path, python_path=args.python_path, + kwargs=kwargs, args=args) + if os.path.isfile(features_save_path) and not(rerun): + cmd = log_reg_cmd + else: + cmd = extract_cmd + ' && ' + log_reg_cmd + if os.path.isfile(results_save_path) and not(rerun): + return -1 + return run_job(cmd, job_name, args, deps=deps) + + +def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], rerun=False, + aug=True, train_mode=False, use_new_bn_stats=False): + group_dir_path = get_group_dir_path(adapt_name, dataset.name, args.model_name, args) + config_path = get_config_path(args, dataset.config_rel_path) + features_save_path = group_dir_path + '/features_' + str(seed) + # summarize_results looks for files which start with stats and end with .tsv + results_save_path = group_dir_path + '/stats_' + str(seed) + '.tsv' + weights_save_path = group_dir_path + '/weights_' + str(seed) + '.pkl' + val_metric = dataset.val_metric + job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_' + str(seed) + deps = add_dataset_model_deps(deps, args, dataset, model) + if not(args.codalab): + root_prefix = dataset.slurm_data_dir + else: + root_prefix = args.codalab_data_dir + return linprobe_run( + args, job_name, model, seed, config_path, features_save_path, results_save_path, + weights_save_path, val_metric, deps=deps, rerun=rerun, aug=aug, root_prefix=root_prefix, + train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + + +def linprobe_experiment(adapt_name, dataset, model, num_replications, args, deps=[], rerun=False, + aug=True, train_mode=False, use_new_bn_stats=False): + replication_ids = [] + for i in range(num_replications): + job_id = run_linprobe_replication(adapt_name, dataset, model, seed=i, args=args, + deps=deps, rerun=rerun, aug=aug, train_mode=train_mode, + use_new_bn_stats=use_new_bn_stats) + replication_ids.append(job_id) + summarize_id = summarize_linprobe(adapt_name, dataset, model, args, deps=replication_ids, max_num=num_replications) + all_ids = replication_ids + [summarize_id] + return [summarize_id], all_ids + + +############################################ +## Functions to summarize results. +############################################ + +def get_summarize_job_name(adapt_name, dataset_name, model_name, replication=False): + job_name = 'summarize_'+get_group_name(adapt_name, dataset_name, model_name) + if replication: + job_name = job_name + '_final' + else: + job_name = job_name + '_sweep' + return job_name + + +def get_summarize_cmd(dir_path, val_metric, secondary_val_metrics, output_metrics, args, + summarize_script_name='summarize_results.py', max_num=None): + """Python cmd to summarize all the results in dir_path according to specified metrics.""" + kwargs = {} + kwargs['results_dir'] = dir_path + kwargs['val_metric'] = val_metric + if secondary_val_metrics is not None: + kwargs['secondary_val_metrics'] = secondary_val_metrics + if output_metrics is not None: + kwargs['output_metrics'] = output_metrics + if max_num is not None: + kwargs['max_num'] = max_num + code_path = args.scripts_dir + '/' + summarize_script_name + return get_python_cmd(code_path, args.python_path, kwargs=kwargs, args=args) + + +def summarize_run(dir_path, job_name, val_metric, secondary_val_metrics, output_metrics, args, deps): + """Run a job to summarize all the results in dir_path according to specified metrics.""" + cmd = get_summarize_cmd(dir_path, val_metric, secondary_val_metrics, output_metrics, args) + return run_job(cmd, job_name, args, deps) + + +def summarize_adaptation(adapt_name, dataset, model, args, deps, replication=False): + group_dir_path = get_group_dir_path(adapt_name, dataset.name, args.model_name, args) + job_name = get_summarize_job_name(adapt_name, dataset.name, args.model_name, replication) + return summarize_run(group_dir_path, job_name, dataset.val_metric, dataset.secondary_val_metrics, + dataset.output_metrics, args, deps) + + +def summarize_linprobe_run(dir_path, job_name, val_metric, secondary_val_metrics, output_metrics, args, deps, max_num=None): + cmd = get_summarize_cmd(dir_path, val_metric, secondary_val_metrics, output_metrics, args, + summarize_script_name='summarize_linprobe_results.py', max_num=max_num) + return run_job(cmd, job_name, args, deps) + + +def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): + group_dir_path = get_group_dir_path(adapt_name, dataset.name, args.model_name, args) + job_name = get_summarize_job_name(adapt_name, dataset.name, args.model_name, replication=True) + secondary_val_metrics = dataset.linprobe_secondary_val_metrics + if secondary_val_metrics is None: + secondary_val_metrics = dataset.secondary_val_metrics + return summarize_linprobe_run(group_dir_path, job_name, dataset.val_metric, + secondary_val_metrics, dataset.linprobe_output_metrics, args, deps, + max_num=max_num) + +############################################ +## Datasets. +############################################ + + +# If linprobe_secondary_val_metrics is None, use secondary_val_metrics. +# TODO: slurm_data_dir should populate root_prefix in configs, which it +# does not do at the moment. +Dataset = namedtuple( + 'Dataset', + ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', + 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', + 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', + 'eval_config_rel_path']) + +living17 = Dataset( + name='living17', + val_metric='test_acc/source_val_living', + secondary_val_metrics=['test_acc/target_val_living', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + config_rel_path='adaptation/living17.yaml', + bundles=['imagenet'], + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/living17_eval.yaml') + +celeba = Dataset( + name='celeba', + val_metric='test_acc/val', + secondary_val_metrics=['test_acc/test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/test'], + config_rel_path='adaptation/celeba.yaml', + bundles=['celeba_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/celeba_eval.yaml') + +living17_noaugs = Dataset( + name='living17_noaugs', + val_metric='test_acc/source_val_living', + secondary_val_metrics=['test_acc/target_val_living', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + config_rel_path='adaptation/living17_noaugs.yaml', + bundles=['imagenet'], + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/living17_eval.yaml') + +living17_nonorm = Dataset( + name='living17_nonorm', + val_metric='test_acc/source_val_living', + secondary_val_metrics=['test_acc/target_val_living', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + config_rel_path='adaptation/living17_nonorm.yaml', + bundles=['imagenet'], + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/living17_nonorm_eval.yaml') + +entity30 = Dataset( + name='entity30', + val_metric='test_acc/source_val_entity', + secondary_val_metrics=['test_acc/target_val_entity', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/source_val_entity', + 'test_acc/target_val_entity'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/source_val_entity', + 'test_acc/target_val_entity'], + config_rel_path='adaptation/entity30.yaml', + bundles=['imagenet'], + slurm_data_dir='/scr/biggest/', + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + eval_config_rel_path='adaptation/entity30_eval.yaml') + +imagenet = Dataset( + name='imagenet', + val_metric='test_acc/val', + secondary_val_metrics=['test_acc/renditions' 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/renditions'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/renditions'], + config_rel_path='adaptation/imagenet.yaml', + bundles=['imagenet'], + slurm_data_dir='', + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + eval_config_rel_path='adaptation/imagenet_eval.yaml') + +imagenet_augs = Dataset( + name='imagenet_augs', + val_metric='test_acc/val', + secondary_val_metrics=['test_acc/renditions' 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/renditions'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/renditions'], + config_rel_path='adaptation/imagenet_augs.yaml', + bundles=['imagenet'], + slurm_data_dir='', + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + eval_config_rel_path='adaptation/imagenet_augs_eval.yaml') + +cifar_stl = Dataset( + name='cifar_stl', + val_metric='test_acc/cifar10-test', + secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', + 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', + 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + config_rel_path='adaptation/cifar_stl.yaml', + bundles=['cifar_stl'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/ananya/', + eval_config_rel_path='adaptation/cifar_stl_eval.yaml') + +cifar_stl_nonorm = Dataset( + name='cifar_stl_nonorm', + val_metric='test_acc/cifar10-test', + secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', + 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', + 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + config_rel_path='adaptation/cifar_stl_nonorm.yaml', + bundles=['cifar_stl'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/ananya/', + eval_config_rel_path='adaptation/cifar_stl_nonorm_eval.yaml') + + +domainnet = Dataset( + name='domainnet', + val_metric='test_acc/sketch_val', + secondary_val_metrics=['test_acc/real_val', 'test_acc/painting_val', 'test_acc/clipart_val', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/sketch_val', + 'test_acc/real_val', 'test_acc/painting_val', 'test_acc/clipart_val'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/sketch_val', + 'test_acc/real_val', 'test_acc/painting_val', 'test_acc/clipart_val'], + config_rel_path='adaptation/domainnet.yaml', + bundles=['domainnet'], + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/domainnet_eval.yaml') + +fmow = Dataset( + name='fmow', + val_metric='test_acc/americas_val', + secondary_val_metrics=['test_acc/africa_val', 'test_acc/europe_val', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/americas_val', + 'test_acc/africa_val', 'test_acc/europe_val'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/americas_val', + 'test_acc/africa_val', 'test_acc/europe_val'], + config_rel_path='adaptation/fmow.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/fmow_eval.yaml') + +fmow_all = Dataset( + name='fmow_all', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/fmow_all_eval.yaml') + +landcover = Dataset( + name='landcover', + val_metric='test_acc/nonafrica-val', + secondary_val_metrics=['test_acc/africa', 'test_acc/nonafrica-test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/nonafrica-val', + 'test_acc/africa', 'test_acc/nonafrica-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/nonafrica-val', + 'test_acc/africa', 'test_acc/nonafrica-test'], + config_rel_path='adaptation/landcover_to_africa.yaml', + bundles=['landcover'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/eix/', + eval_config_rel_path='adaptation/landcover_to_africa_eval.yaml') + +landcover_auxin = Dataset( + name='landcover_auxin', + val_metric='test_acc/nonafrica-val', + secondary_val_metrics=['test_acc/africa', 'test_acc/nonafrica-test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/nonafrica-val', + 'test_acc/africa', 'test_acc/nonafrica-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/nonafrica-val', + 'test_acc/africa', 'test_acc/nonafrica-test'], + config_rel_path='adaptation/landcover_auxin_to_africa.yaml', + bundles=['landcover'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/eix/', + eval_config_rel_path='adaptation/landcover_auxin_to_africa_eval.yaml') + +names_to_datasets = { + 'living17': living17, + 'living17_nonorm': living17_nonorm, + 'entity30': entity30, + 'imagenet': imagenet, + 'imagenet_augs': imagenet_augs, + 'cifar_stl': cifar_stl, + 'cifar_stl_nonorm': cifar_stl_nonorm, + 'domainnet': domainnet, + 'fmow': fmow, + 'fmow_all': fmow_all, + 'living17_noaugs': living17_noaugs, + 'celeba': celeba, + # 'landcover': landcover, + # 'landcover_auxin': landcover_auxin, +} + + +############################################ +## Models. +############################################ + +Model = namedtuple('Model', ['kwargs', 'bundles']) + +mocotp_fmow_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'mocov2', + 'checkpoint_rel_path': 'mocotp_checkpoint_0200.pth.tar' + }, + bundles=['simclr_weights'] +) + +scratch_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': False, + }, + bundles=[] +) + +moco_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'mocov2', + 'checkpoint_rel_path': 'moco_v2_800ep_pretrain.pth.tar' + }, + bundles=['simclr_weights'] +) + +mocov1_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'mocov2', + 'checkpoint_rel_path': 'moco_v1_200ep_pretrain.pth.tar' + }, + bundles=['simclr_weights'] +) + +swav_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'swav', + 'checkpoint_rel_path': 'swav_800ep_pretrain.pth.tar' + }, + bundles=['simclr_weights'] +) + +sup_resnet50 = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'supervised', + }, + bundles=[] +) + +# Version where we normalize inside the model. +# TODO: ideally I think all normalization should be in the model... +sup_resnet50_norm = Model( + kwargs={ + 'classname': 'models.imnet_resnet.ResNet50', + 'args.pretrained': True, + 'args.pretrain_style': 'supervised', + 'args.normalize': True, + }, + bundles=[] +) + +clip_resnet50 = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'RN50', + }, + bundles=[] +) + +clip_vit_b16 = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-B/16', + }, + bundles=[] +) + +scratch_vit_b16_clipstyle = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-B/16', + 'args.scratch': True, + }, + bundles=[] +) + +dino_vit_b16 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'dino_vitb16', + }, + bundles=[] +) + +landcover_baseline = Model( + kwargs={ + 'classname': 'models.innout_models.CNN1D', + 'args.in_channels': 8, + 'args.output_size': 6, + }, + bundles=[] +) + +landcover_auxin = Model( + kwargs={ + 'classname': 'models.innout_models.CNN1D', + 'args.in_channels': 14, + 'args.output_size': 6, + }, + bundles=[] +) + +names_to_model = { + 'scratch_resnet50': scratch_resnet50, + 'resnet50': moco_resnet50, + 'mocov1_resnet50': mocov1_resnet50, + 'swav_resnet50': swav_resnet50, + 'sup_resnet50': sup_resnet50, + 'sup_resnet50_norm': sup_resnet50_norm, + 'mocotp_fmow_resnet50': mocotp_fmow_resnet50, + 'clip_resnet50': clip_resnet50, + 'clip_vit_b16': clip_vit_b16, + 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, + 'dino_vit_b16': dino_vit_b16, + 'landcover_baseline': landcover_baseline, + 'landcover_auxin': landcover_auxin, +} + +############################################ +## Functions to specify hyperparameter sweeps. +############################################ + +def union_dicts(d1, d2): + return dict(d1, **d2) + +def zip_dict_lists(dlist1, dlist2): + dlist = [] + assert(len(dlist1) == len(dlist2)) + for i in range(len(dlist1)): + dlist.append(union_dicts(dlist1[i], dlist2[i])) + return dlist + +def product_dict_lists(dlist1, dlist2): + dlist = [] + for i in range(len(dlist1)): + for j in range(len(dlist2)): + dlist.append(union_dicts(dlist1[i], dlist2[j])) + return dlist + +def range_hyper(name, values): + dlist = [] + for value in values: + dlist.append({name: value}) + return dlist + +# Append more_hyperparams to every hyperparams in hyperparams_list +def append_to_each(hyperparams_list, more_hyperparams): + return [union_dicts(d, more_hyperparams) for d in hyperparams_list] + + +############################################ +## Main experiments. +############################################ + +SWEEP_LRS = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] + +def get_datasets(args): + print(args.datasets) + if args.datasets is None: + datasets = list(names_to_datasets.values()) + else: + datasets = [names_to_datasets[n] for n in args.datasets] + print(datasets) + return datasets + + +def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications=3, + linear_probe=False, val_mode=False, final=True): + adapt_name = 'full_ft' + args.datasets = ['celeba'] + datasets = get_datasets(args) + model = names_to_model[args.model_name] + sweep_lrs = SWEEP_LRS + if linear_probe: + adapt_name = 'torch_linprobe' + sweep_lrs = [3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1.0] + if args.model_name == 'clip_vit_b16' and final: + sweep_lrs = [0.01] # We found this to be best on Wearing Earrings. + elif args.model_name == 'clip_vit_b16': + if final: + sweep_lrs = [3e-06] # We found this to be best on Wearing Earrings. + else: + sweep_lrs = [1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4] + elif args.model_name == 'scratch_vit_b16_clipstyle': + if final: + sweep_lrs = [0.003] # We found this to be best on WearingEarrings. + else: + sweep_lrs = [3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1.0] + if args.epochs is not None: + adapt_name += '_epochs' + str(args.epochs) + adapt_name += '_' + attribute_name + # Set hyperparameters + if args.only_one_run: + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs[0]) + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + else: + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) + if val_mode: + hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) + hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) + if linear_probe: + hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) + if args.epochs is not None: + hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) + hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) + if args.save_no_checkpoints: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + hyperparams_list = append_to_each(hyperparams_list, {'default_test_args.target_attribute': attribute_name}) + hyperparams_list = append_to_each(hyperparams_list, {'train_dataset.args.target_attribute': attribute_name}) + if args.no_replications: + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + for dataset in datasets: + all_ids = replicated_sweep( + adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, + num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'default_test_args.target_attribute', 'train_dataset.args.target_attribute'}) + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + + +def fine_tuning_celeba_experiments(args, linear_probe=True): + # fine_tuning_celeba_single_experiment(args, 'Wearing_Earrings', linear_probe=True, val_mode=True) + if linear_probe: + fine_tuning_celeba_single_experiment(args, 'Wearing_Earrings', num_replications=5, linear_probe=True, val_mode=True, final=True) + fine_tuning_celeba_single_experiment(args, 'Wearing_Necklace', num_replications=5, linear_probe=True, val_mode=True, final=True) + fine_tuning_celeba_single_experiment(args, 'Wearing_Necktie', num_replications=5, linear_probe=True, val_mode=True, final=True) + fine_tuning_celeba_single_experiment(args, 'Eyeglasses', num_replications=5, linear_probe=True, val_mode=True, final=True) + else: + fine_tuning_celeba_single_experiment(args, 'Wearing_Earrings', num_replications=5, final=True) + fine_tuning_celeba_single_experiment(args, 'Wearing_Necklace', num_replications=5, final=True) + fine_tuning_celeba_single_experiment(args, 'Wearing_Necktie', num_replications=5, final=True) + fine_tuning_celeba_single_experiment(args, 'Eyeglasses', num_replications=5, final=True) + + + +def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, + val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, + imagenet_lp_ft_phase2=False): + adapt_name = 'full_ft' + datasets = get_datasets(args) + model = names_to_model[args.model_name] + sweep_lrs = SWEEP_LRS + if 'imagenet' in args.datasets or 'imagenet_augs' in args.datasets: + if len(args.datasets) > 1: + raise ValueError('ImageNet uses custom learning rates, so launch it separately.') + if imagenet_lp_ft_phase2: + sweep_lrs = [0.00001, 0.00003, 0.0001] + else: + sweep_lrs = [0.0001, 0.0003, 0.001] + if side_tune: + adapt_name += '_side_tune' + sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] + if val_mode: + adapt_name += '_valmode' + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] + elif val_mode: + adapt_name += '_valmode' + if 'imagenet' not in args.datasets and 'imagenet_augs' not in args.datasets: + sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] + if no_augmentation: + adapt_name += '_no_augmentation' + if linear_probe: + adapt_name = 'torch_linprobe' + # Linear probing needs a higher learning rate. + if 'imagenet' in args.datasets or 'imagenet_augs' in args.datasets: + sweep_lrs = [0.01, 0.03, 0.1] + else: + sweep_lrs = [3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1.0] + if batchnorm_ft: + adapt_name = 'batchnorm_ft' + # TODO: hacky / hardcoded. + sweep_lrs = SWEEP_LRS[2:] + [0.03, 0.1, 0.3] + if higher_linear_lr: + adapt_name = 'full_ft_higherlinlr' + if l2sp: + adapt_name = 'l2sp' + if args.epochs is not None: + adapt_name += '_epochs' + str(args.epochs) + # Set hyperparameters + if args.only_one_run: + # TODO: how to choose which one to run? 1e-3 does well in practice. + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs[0]) + # TODO: remove this? + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + else: + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) + if side_tune: + hyperparams_list = append_to_each(hyperparams_list, {'side_tune': True}) + if no_augmentation: + hyperparams_list = append_to_each(hyperparams_list, {'no_augmentation': True}) + if val_mode: + hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) + hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) + if linear_probe: + hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) + if batchnorm_ft: + hyperparams_list = append_to_each(hyperparams_list, {'batchnorm_ft': True}) + if higher_linear_lr: + hyperparams_list = append_to_each(hyperparams_list, {'linear_layer_lr_multiplier': 10}) + if l2sp: + # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 + # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. + hyperparams_list = append_to_each(hyperparams_list, {'l2sp_weight': 0.01}) + if args.epochs is not None: + hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) + hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) + if args.save_no_checkpoints: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + if imagenet_lp_ft_phase2: + if 'imagenet_augs' in args.datasets: + hyperparams_list = append_to_each(hyperparams_list, + {'checkpoint_path': + '/u/scr/ananya/cifar_experiments/unlabeled_extrapolation/logs/' + 'torch_linprobe_epochs5_imagenet_augs_clip_vit_b16/' + 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' + 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) + + if 'imagenet' in args.datasets: + hyperparams_list = append_to_each(hyperparams_list, + {'checkpoint_path': + '/u/scr/ananya/cifar_experiments/unlabeled_extrapolation/logs/' + 'torch_linprobe_epochs5_imagenet_clip_vit_b16/' + 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' + 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) + if args.no_replications: + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + for dataset in datasets: + all_ids = replicated_sweep( + adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, + num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path'}) + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + + +def ft_imnet_lp_ft_phase_2_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, + imagenet_lp_ft_phase2=True) + + +def ft_imnet_lp_ft_phase_2_val_mode_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, + val_mode=True, imagenet_lp_ft_phase2=True) + + +def fine_tuning_no_augmentation_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, no_augmentation=True) + + +def torch_linprobe_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, linear_probe=True) + + +def torch_linprobe_valmode_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, linear_probe=True, + val_mode=True) + + +def side_tune_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, side_tune=True) + + +def side_tune_val_mode_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, val_mode=True, side_tune=True) + + +def batchnorm_ft_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, batchnorm_ft=True) + + +def ft_higher_linear_lr_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, higher_linear_lr=True) + + +def l2sp_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, l2sp=True) + + +def ft_val_mode_experiment(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, val_mode=True) + + +def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, use_new_bn_stats=False): + adapt_name = 'linprobe' + if not(aug): + adapt_name += '_noaug' + if train_mode: + adapt_name += '_trainmode' + if use_new_bn_stats: + if train_mode: + raise ValueError('If use_new_bn_stats is True, train_mode must be False.') + adapt_name += '_usenewbnstats' + datasets = get_datasets(args) + model = names_to_model[args.model_name] + if args.no_replications or args.only_one_run: + num_replications = 1 + for dataset in datasets: + all_ids = linprobe_experiment( + adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, + args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + + +def linprobe_experiments_no_aug(args, num_replications=3): + linprobe_experiments(args, num_replications=num_replications, aug=False) + + +def linprobe_experiments_trainmode(args, num_replications=3): + linprobe_experiments(args, num_replications=num_replications, train_mode=True) + + +def linprobe_experiments_usenewbnstats(args, num_replications=3): + linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) + + +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False): + if args.epochs is not None: + raise ValueError('Does not support epochs yet.') + adapt_name = 'lp_then_ft' + sweep_lrs = SWEEP_LRS + if val_mode: + adapt_name += '_valmode' + sweep_lrs = [1e-4, 3e-5, 1e-5, 3e-6, 1e-6, 3e-7] + linprobe_adapt_name = 'linprobe' + datasets = get_datasets(args) + model = names_to_model[args.model_name] + if args.only_one_run: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + else: + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) + if val_mode: + hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) + if args.no_replications: + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. + if args.epochs is not None: + hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) + hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) + if args.save_no_checkpoints: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + for dataset in datasets: + cur_hyperparams_list = deepcopy(hyperparams_list) + linprobe_group_path = get_group_dir_path(linprobe_adapt_name, dataset.name, args.model_name, args) + # cur_hyperparams_list = append_to_each( + # cur_hyperparams_list, + # {'linear_probe_checkpoint_path': linprobe_group_path + '/weights_0.pkl'}) + replication_hyperparams_list = [] + for i in range(num_replications): + replication_hyperparams_list.append({ + 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + all_ids = replicated_sweep( + adapt_name=adapt_name, dataset=dataset, model=model, + hyperparams_list=cur_hyperparams_list, num_replications=num_replications, + replication_hyperparams_list=replication_hyperparams_list, args=args, + ignore_name_hypers={'linear_probe_checkpoint_path'}) + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + + +def lp_then_ft_valmode_experiments(args, num_replications=3): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) + + +def lp_then_ft_trainmode_experiments(args, num_replications=3): + lp_then_ft_experiments(args, num_replications=num_replications, train_mode=True) + + +def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): + lp_then_ft_experiments(args, num_replications=num_replications, use_new_bn_stats=True) + + +############################################ +## Functions to spray dataset on jags. +############################################ + +def spray_dataset_jags(copy_cmd): + for i in range(10, 30): + cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + f'scripts/run_sbatch.sh "{copy_cmd}"' + subprocess.run(cmd, shell=True) + + +def spray_celeba_jags(args): + spray_dataset_jags( + f'source {args.scripts_dir}/copy_local.sh /u/scr/ananya/celeba.tar.gz') + + +def spray_fmow_jags(args): + spray_dataset_jags( + f'source {args.scripts_dir}/copy_local.sh /u/scr/nlp/wilds/data/fmow_v1.1.tar.gz wilds/data') + + +def spray_imagenet_jags(args): + spray_dataset_jags( + f'source {args.scripts_dir}/copy_dataset.sh imagenet') + + +def spray_domainnet_jags(args): + for i in range(10, 30): + cmd = 'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G' + cmd += f' --nodelist=jagupard{i} -J copy_domainnet_jag{i} -o %x.out' + cmd += ' scripts/copy_dataset.sh domainnet' + subprocess.run(shlex.split(cmd)) + + +def main(args): + experiment_to_fns = { + 'spray_celeba_jags': spray_celeba_jags, + 'spray_fmow_jags': spray_fmow_jags, + 'spray_imagenet_jags': spray_imagenet_jags, + 'spray_domainnet_jags': spray_domainnet_jags, + 'fine_tuning_experiments': fine_tuning_experiments, + 'fine_tuning_celeba_experiments': fine_tuning_celeba_experiments, + 'linprobe_experiments': linprobe_experiments, + 'linprobe_experiments_no_aug': linprobe_experiments_no_aug, + 'lp_then_ft_experiments': lp_then_ft_experiments, + 'linprobe_experiments_trainmode': linprobe_experiments_trainmode, + 'lp_then_ft_trainmode_experiments': lp_then_ft_trainmode_experiments, + 'linprobe_experiments_usenewbnstats': linprobe_experiments_usenewbnstats, + 'lp_then_ft_usenewbnstats_experiments': lp_then_ft_usenewbnstats_experiments, + 'lp_then_ft_valmode_experiments': lp_then_ft_valmode_experiments, + 'torch_linprobe_experiments': torch_linprobe_experiments, + 'torch_linprobe_valmode_experiments': torch_linprobe_valmode_experiments, + 'batchnorm_ft_experiments': batchnorm_ft_experiments, + 'ft_higher_linear_lr_experiments': ft_higher_linear_lr_experiments, + 'ft_val_mode_experiment': ft_val_mode_experiment, + 'fine_tuning_no_augmentation_experiments': fine_tuning_no_augmentation_experiments, + 'l2sp_experiments': l2sp_experiments, + 'side_tune_experiments': side_tune_experiments, + 'side_tune_val_mode_experiments': side_tune_val_mode_experiments, + 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, + 'ft_imnet_lp_ft_phase_2_val_mode_experiments': ft_imnet_lp_ft_phase_2_val_mode_experiments, + } + if args.experiment in experiment_to_fns: + experiment_to_fns[args.experiment](args) + else: + raise ValueError(f'Experiment {args.experiment} does not exist.') + + +def fill_platform_specific_default_args(args): + if args.codalab: + args.log_dir = args.log_dir if args.log_dir else '.' + args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if + args.pretrained_checkpoints_dir else + 'simclr_weights/') + else: + args.log_dir = args.log_dir if args.log_dir else 'logs/' + args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if + args.pretrained_checkpoints_dir else + '/u/scr/ananya/simclr_weights/') + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Run celeba experiments.') + parser.add_argument('--experiment', type=str, required=True, + help='Experiment to run.') + parser.add_argument('--seed', type=int, required=False, default=0, + help='Base seed, we typically add to this seed for replication runs.') + parser.add_argument('--epochs', type=int, required=False, default=None, + help='Number of epochs to run job for.') + # Note that store_true creates a default value of False. + parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--partition', type=str, required=False, default='jag-standard', + help='(Slurm only) What priority to use.') + parser.add_argument('--mail_user', type=str, required=False, + help='(Slurm only) Email if slurm job fails.', default=None) + # Locations of folders and files. + parser.add_argument('--codalab_data_dir', type=str, required=False, default='.', + help='(Codalab only) Dir (root_prefix in config) where the data is stored') + parser.add_argument('--scripts_dir', type=str, required=False, default='scripts/', + help='Path to dir where scripts are stored.') + parser.add_argument('--output_dir', type=str, required=False, default='slurm_outputs/', + help='(Slurm only) Path to dir to store stdout for experiment.') + parser.add_argument('--log_dir', type=str, required=False, default=None, + help='Path to dir where we save logs and run checkpoints.') + parser.add_argument('--pretrained_checkpoints_dir', type=str, required=False, + default=None, help='Path to dir where we keep pretrained checkpoints.') + parser.add_argument('--config_dir', type=str, required=False, default='configs/', + help='Directory where config files are stored.') + parser.add_argument('--code_dir', type=str, required=False, default='unlabeled_extrapolation/', + help='Path to directory where code files are located.') + parser.add_argument('--python_path', type=str, required=False, default='python', + help='Path or alias to Python interpreter') + parser.add_argument('--tmp_dir', type=str, required=False, default='/scr/biggest/ue/', + help='(Slurm only) Directory where tmp files are stored.') + parser.add_argument('--sbatch_script_name', type=str, required=False, default='run_sbatch.sh', + help='(Slurm only) sbatch script') + parser.add_argument('--datasets', type=str, nargs='+', + help='Datasets to test on (if unspecified, run on all).', required=False) + parser.add_argument('--model_name', type=str, default='resnet50', # This is moco resnet. + help='Model to use', required=False) + parser.add_argument('--only_one_run', action='store_true', + help=('Only run one hyperparameter setting, e.g. for debugging' + '(also do not run replications).'), required=False) + parser.add_argument('--no_replications', action='store_true', + help='Don\'t run replication runs, only sweep.', required=False) + args, unparsed = parser.parse_known_args() + fill_platform_specific_default_args(args) + main(args) diff --git a/scripts/run_cpu_sbatch.sh b/scripts/run_cpu_sbatch.sh new file mode 100644 index 0000000..14fdea0 --- /dev/null +++ b/scripts/run_cpu_sbatch.sh @@ -0,0 +1,17 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --cpus-per-task=1 +#SBATCH --mem=16G + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_micro_sbatch.sh b/scripts/run_micro_sbatch.sh new file mode 100644 index 0000000..76f5797 --- /dev/null +++ b/scripts/run_micro_sbatch.sh @@ -0,0 +1,19 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:0 +#SBATCH --cpus-per-task=2 +#SBATCH --mem=2G +#SBATCH --exclude=jagupard[10-11,17] + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh new file mode 100644 index 0000000..60f26df --- /dev/null +++ b/scripts/run_rtx_sbatch.sh @@ -0,0 +1,19 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=24G +#SBATCH --exclude=jagupard[10-27] + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh new file mode 100644 index 0000000..6dc58be --- /dev/null +++ b/scripts/run_sbatch.sh @@ -0,0 +1,20 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=16G +#SBATCH --exclude=jagupard[15,18] +# #SBATCH --exclude=jagupard[14,17,18,20] + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh new file mode 100644 index 0000000..101a759 --- /dev/null +++ b/scripts/run_sphinx_sbatch.sh @@ -0,0 +1,20 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=24G +#SBATCH --partition=sphinx +#SBATCH -t 2-0:00 + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py new file mode 100644 index 0000000..a27058d --- /dev/null +++ b/scripts/summarize_all_results.py @@ -0,0 +1,104 @@ +# Unlike summarize results, this summarizes results for many experiments at once. +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + +from summarize_results import get_result, summarize_results + + +def remove_replication_info(s): + idx = s.find('_seed') + s = s[:idx] + s[idx+7:] + idx = s.find('_run') + s = s[:idx] + s[idx+6:] + return s + + +def get_all_results(val_metric, dir_paths, output_metrics): + results, best, dirs = [], [], [] + for dir_path in dir_paths: + res, val_values_list, file_paths = summarize_results( + dir_path, val_metric, output_metrics) + if len(res) == 0: + continue + res['group'] = res['name'].apply(remove_replication_info) + grouped = res.groupby('group') + means = grouped.mean() + counts = grouped.count() + counts.drop(labels=['name', 'wandb_url'], axis=1) + stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) + stderrs = stderrs[means.columns] + min_count = grouped.count().iloc[:,0].min() + if val_metric == 'LAST': + best_row_mean = means.iloc[[-1]] + best_row_std = stderrs.iloc[[-1]] + else: + best_group = means[val_metric].idxmax() + best_row_mean = means.loc[[best_group]] + best_row_std = stderrs.loc[[best_group]] + best_row_mean['name'] = dir_path[5:] + best_row_std['name'] = dir_path[5:] + ' (stddev)' + for best_row in [best_row_mean, best_row_std]: + best_row['group'] = best_row.index + best_row.set_index('name') + results.append(res) + best.append((best_row_mean, best_row_std)) + dirs.append(dir_path) + return results, best, dirs + + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir_glob', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metrics', type=str, nargs='+', + help='Metrics to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + # Get all folders satisfying glob. + dir_paths = glob.glob(args.results_dir_glob, recursive=False) + dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path] + output = '' + for val_metric in args.val_metrics: + results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) + output += '\n\n\n' + output += f'Early stopped based on {val_metric}:\n\n' + output_header = True + for best_item, cur_dir in zip(best, dirs): + output += f'{cur_dir}\n' + output += best_item[0].to_csv(sep='\t', index=None, header=output_header) + output_header = False + output += best_item[1].to_csv(sep='\t', index=None, header=False) + output += '\n' + output += 'All results:\n\n' + for result, cur_dir in zip(results, dirs): + output += f'{cur_dir}\n' + output += result.to_csv(sep='\t', index=None, header=False) + output += '\n' + + if args.output_file is None: + output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + diff --git a/scripts/summarize_linprobe_results.py b/scripts/summarize_linprobe_results.py new file mode 100644 index 0000000..b5db401 --- /dev/null +++ b/scripts/summarize_linprobe_results.py @@ -0,0 +1,72 @@ +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + +from summarize_results import get_result, summarize_results + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metric', type=str, + help='Metric to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--secondary_val_metrics', type=str, nargs='+', + help='Additional metrics to report best row for.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('--max_num', type=int, + help='Max number of lin probe runs to use.') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + metrics, results_list = [], [] + # Get results for val_metric. + val_results, _, _ = summarize_results( + args.results_dir, args.val_metric, args.output_metrics, use_all=True, + max_num=args.max_num) + metrics.append(args.val_metric) + results_list.append(val_results) + # Get other results. + for secondary_val_metric in args.secondary_val_metrics: + secondary_results, _, _ = summarize_results( + args.results_dir, secondary_val_metric, args.output_metrics, use_all=True, max_num=args.max_num) + metrics.append(secondary_val_metric) + results_list.append(secondary_results) + # Save tsv file + output = '' + for metric, results in zip(metrics, results_list): + output += '\n' + output += f'Replication results when early stopped based on {metric}:\n' + output += results.to_csv(sep='\t', index=None, header=True) + output += '\n' + output += 'Replication average and 90% confidence interval:\n' + output += pd.DataFrame(results.mean(axis=0)).T.to_csv( + sep='\t', index=None, header=True) + multiplier = 1.645 / np.sqrt(len(results)) + output += pd.DataFrame(multiplier * results.std(axis=0)).T.to_csv( + sep='\t', index=None, header=False) + + if args.output_file is None: + output_file = args.results_dir + '/results.tsv' + # output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py new file mode 100644 index 0000000..c73b1f8 --- /dev/null +++ b/scripts/summarize_results.py @@ -0,0 +1,150 @@ +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + + +def get_parent_folder(file_path): + parent_path = file_path[:file_path.rfind('/')] + parent_folder = parent_path[parent_path.rfind('/')+1:] + return parent_folder + + +def get_result(file_path, val_metric, output_metrics, take_max=True): + df = pd.read_csv(file_path, sep='\t') + if val_metric is not None and val_metric != 'LAST': + if val_metric not in df: + raise ValueError(f'{val_metric} column not in {file_path}') + if take_max: + best_idx = df[val_metric].idxmax() + else: + best_idx = df[val_metric].idxmin() + best_value = df[val_metric][best_idx] + else: + best_idx = -1 + best_value = -1.0 + best_res = df.iloc[best_idx].to_dict() + if output_metrics is not None: + best_res = [(f"{k}", best_res[k]) for k in output_metrics] + else: + best_res = [(f"{k}", v) for k,v in best_res.items()] + # Get run-name and wandb from config file. + parent_dir = Path(file_path).parent.absolute() + config_path = parent_dir / 'config.json' + if os.path.isfile(config_path): + with open(config_path, 'r') as f: + config = json.load(f) + run_name = [('name', config['run_name'])] + wandb_url = [('wandb_url', config['wandb_url'])] + best_res = run_name + best_res + wandb_url + else: + run_name = [('name', file_path[file_path.rfind('/')+1:-4])] + best_res = run_name + best_res + return best_res, best_value + +def summarize_results(results_dir, val_metric, output_metrics, replication=False, use_all=False, max_num=None): + # If use_all is True, then look at all stats.tsv files. + # Otherwise, if replication is True look for replication files, if false ignore replicatin files. + # max_num is for linear probing, and uses only the first max_num runs. + # Returns a list of rows, each row is the result for a corresponding file. + file_paths = glob.glob(results_dir + '/**/*stats*.tsv', recursive=True) + file_paths = list(set(file_paths)) + # Sort so that the results are deterministic, e.g. if multiple runs have + # the same validation metric. + file_paths = sorted(file_paths) + results_list, val_values_list = [], [] + for file_path in file_paths: + if max_num is not None and int(file_path[-5]) >= max_num: + continue + parent_folder = get_parent_folder(file_path) + if use_all or (('replication' in parent_folder and replication) or + ('replication' not in parent_folder and not replication)): + res_row, val_value = get_result(file_path, val_metric, output_metrics) + results_list.append(OrderedDict(res_row)) + val_values_list.append(val_value) + res = pd.DataFrame(results_list) + for col in res.columns: + if 'epoch' in col: + res = res.astype({col: 'int32'}) + if 'acc' in col: + res[col] = res[col] * 100 + res = res.round(4) + return res, val_values_list, file_paths + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metric', type=str, + help='Metric to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--secondary_val_metrics', type=str, nargs='+', + help='Additional metrics to report best row for.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + # Get results for val_metric. + results, val_values, file_paths = summarize_results( + args.results_dir, args.val_metric, args.output_metrics) + # Get index of the best run, and save the config file. + best_run_idx = np.argmax(val_values) + best_config_path = os.path.dirname(file_paths[best_run_idx]) + '/config.json' + config_save_path = args.results_dir + '/best_config.json' + shutil.copy(best_config_path, config_save_path) + # Get replication summary (could be empty). + replication_results, _, _ = summarize_results( + args.results_dir, args.val_metric, args.output_metrics, + replication=True) + # Get other results. + secondary_results_list = [] + for secondary_val_metric in args.secondary_val_metrics: + secondary_results, _, _ = summarize_results( + args.results_dir, secondary_val_metric, args.output_metrics) + secondary_results_list.append(secondary_results) + # Save tsv file. + output = f'Results for {args.results_dir}, early stopped on {args.val_metric}:\n\n' + if args.s: + output += results.to_csv(sep='\t', index=None, header=False) + else: + output += results.to_csv(sep='\t', index=None) + for secondary_metric, secondary_results in zip( + args.secondary_val_metrics, secondary_results_list): + output += '\n' + output += f'Early stopped based on {secondary_metric}:\n' + output += secondary_results.to_csv(sep='\t', index=None, header=False) + if len(replication_results) > 0: + output += '\n' + output += 'Replication results:\n' + output += replication_results.to_csv(sep='\t', index=None, header=False) + output += '\n' + output += 'Replication average and 90% confidence interval:\n' + output += pd.DataFrame(replication_results.mean(axis=0)).T.to_csv( + sep='\t', index=None, header=True) + multiplier = 1.645 / np.sqrt(len(replication_results)) + output += pd.DataFrame(multiplier * replication_results.std(axis=0)).T.to_csv( + sep='\t', index=None, header=False) + + if args.output_file is None: + output_file = args.results_dir + '/results.tsv' + # output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + diff --git a/scripts/update_dataset_acl.sh b/scripts/update_dataset_acl.sh new file mode 100644 index 0000000..8732259 --- /dev/null +++ b/scripts/update_dataset_acl.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash +#SBATCH --ntasks=1 +#SBATCH --mem=1GB +#SBATCH --partition=jag-standard +#SBATCH --requeue + +if [[ -d "/scr/biggest/$1" ]]; then + setfacl -Rm u:eix:rwx,u:ananya:rwx,u:kshen6:rwx "/scr/biggest/$1" +fi + diff --git a/setup.py b/setup.py index b1a0478..73bcdf9 100755 --- a/setup.py +++ b/setup.py @@ -1,6 +1,6 @@ from setuptools import setup, find_packages -setup(name='', +setup(name='unlabeled_extrapolation', version='0.0.1', description='unlabeled_extrapolation', url='https://github.com/p-lambda/unlabeled_extrapolation', @@ -10,10 +10,9 @@ install_requires=[ 'matplotlib', 'numpy', - 'torch==1.4.0', - 'torchvision==0.5.0', + 'torch==1.8.1+cu111', + 'torchvision==0.9.1+cu111', 'tqdm', - 'pyyaml', 'requests', 'wandb', 'pandas', @@ -22,5 +21,17 @@ 'scikit-learn', 'scipy', 'cdsapi', + 'quinine', + 'pyyaml', 'uncertainty-calibration', + # 'lightning-bolts', + 'tensorboard', + 'opencv-python', + 'robustness', + 'networkx', + 'cvxpy', + 'pytorch-lightning-bolts', + 'ftfy', + 'regex', ]) +# Make sure to also install clip using pip install git+https://github.com/openai/CLIP.git \ No newline at end of file diff --git a/unlabeled_extrapolation/.baseline_train.py.swn b/unlabeled_extrapolation/.baseline_train.py.swn new file mode 100644 index 0000000000000000000000000000000000000000..dc1ec0ca25214f61237fc20844d08007086b2932 GIT binary patch literal 16384 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 literal 0 HcmV?d00001 diff --git a/unlabeled_extrapolation/.baseline_train.py.swo b/unlabeled_extrapolation/.baseline_train.py.swo new file mode 100644 index 0000000000000000000000000000000000000000..2f87561621c1b9003438b6860142beb455fd0719 GIT binary patch literal 57344 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 max_examples: + logging.info("Breaking after %d examples.", num_examples) + break + if 'save_model_preds' in config and config.save_model_preds: + preds = np.concatenate(predicted_list) + labels = np.concatenate(labels_list) + pickle_name = log_dir+'/model_preds/'+loader_name+'_'+str(epoch)+'_preds.pkl' + pickle.dump((preds, labels), open(pickle_name, "wb")) + reset_state(net, training_state) + return val_loss, val_acc + + +def update_best_stats(stats, best_stats): + for k, v in stats.items(): + best_k = 'best_' + k + if best_k in best_stats: + cmb = max + if k.find('loss') != -1 and k.find('acc') == -1: + cmb = min + best_stats[best_k] = cmb(best_stats[best_k], v) + else: + best_stats[best_k] = v + + +def get_test_loaders(config, shuffle=False): + test_loaders = {} + max_test_examples = {} + logging.info('Found %d testing datasets.', len(config['test_datasets'])) + for test_dataset_config in config['test_datasets']: + logging.info('test dataset config: ' + str(test_dataset_config)) + # Initialize dataset and data loader. + # Shuffle is True in case we only test part of the test set. + test_data = utils.init_dataset(test_dataset_config) + test_loader = torch.utils.data.DataLoader( + test_data, batch_size=config['batch_size'], + shuffle=shuffle, num_workers=config['num_workers']) + test_config_name = test_dataset_config['name'] + test_loaders[test_config_name] = test_loader + # Some test datasets like CINIC are huge so we only test part of the dataset. + if 'max_test_examples' in test_dataset_config: + logging.info( + 'Only logging %d examples for %s', test_dataset_config['max_test_examples'], + test_dataset_config['name']) + max_test_examples[test_config_name] = test_dataset_config['max_test_examples'] + else: + max_test_examples[test_config_name] = float('infinity') + logging.info('test loader name: ' + test_dataset_config['name']) + logging.info('test loader: ' + str(test_loader)) + logging.info('test transform: ' + str(test_dataset_config['transforms'])) + return test_loaders, max_test_examples + + +def get_train_loader(config, shuffle=True): + train_data = utils.init_dataset(config['train_dataset']) + train_loader = torch.utils.data.DataLoader( + train_data, batch_size=config['batch_size'], + shuffle=shuffle, num_workers=config['num_workers']) + return train_loader + + +def build_model(config): + net = utils.initialize(config['model']) + # If fine-tune, re-initialize the last layer. + finetune = 'finetune' in config and config['finetune'] + linear_probe = 'linear_probe' in config and config['linear_probe'] + batch_norm = 'batchnorm_ft' in config and config['batchnorm_ft'] + side_tune = 'side_tune' in config and config['side_tune'] + def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) + if finetune or linear_probe or batch_norm or side_tune: + if linear_probe: + logging.info('linear probing, freezing bottom layers.') + # If unspecified, we set use_net_val_mode = True for linear-probing. + # We did this in update_net_eval_mode which we called in main. + assert('use_net_val_mode' in config) + # Freeze all the existing weights of the neural network. + # TODO: enable keeeping the top linear layer. + net.set_requires_grad(False) + if batch_norm: + assert(not linear_probe) + logging.info("tuning only batch norm layers and lin probe") + net.set_requires_grad(False) + for layer in net._model.modules(): + if isinstance(layer, nn.modules.batchnorm.BatchNorm2d): + for param in layer.parameters(): + param.requires_grad = True + if 'probe_net' in config: + probe_net = utils.initialize(config['probe_net']) + net.add_probe(probe_net) + else: + net.new_last_layer(config['num_classes']) + if side_tune: + # This is currently only supported for some networks like ResNet-50, + # would need to add support for other networks. + net.enable_side_tuning() + if ('linear_probe_checkpoint_path' in config and + config['linear_probe_checkpoint_path'] != ''): + linprobe_path = config['linear_probe_checkpoint_path'] + coef, intercept, best_c, best_i = pickle.load(open(linprobe_path, "rb")) + if 'normalize_lp' in config and config['normalize_lp']: + logging.info("Normalizing linear probe std-dev") + saved_stddev = np.std(coef) + rand_weights = net.get_last_layer().weight.detach().numpy() + rand_stddev = np.std(rand_weights) + logging.info( + "Weights saved stddev: %f, desired stddev: %f", + saved_stddev, rand_stddev) + logging.info("Intercept saved stddev: %f", np.std(intercept)) + coef = (coef / saved_stddev) * rand_stddev + intercept = (intercept / saved_stddev) * rand_stddev + logging.info( + "Final stddev weights; %f, intercept: %f", + np.std(coef), np.std(intercept)) + # What should it be, based on rep size (maybe get from net last layer) + # Divide + net.set_last_layer(coef, intercept) + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine Tuning {num_trainable_params} of {num_params} parameters.') + if 'checkpoint_path' in config and len(config['checkpoint_path']) > 0: + logging.info(utils.load_ckp(config['checkpoint_path'], net)) + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine Tuning checkpoint: {num_trainable_params} of {num_params} parameters.') + return net + + +def get_l2_dist(weight_dict1, weight_dict2, ignore='.fc.'): + l2_dist = torch.tensor(0.0).cuda() + for key in weight_dict1: + if ignore not in key: + l2_dist += torch.sum(torch.square(weight_dict1[key] - weight_dict2[key])) + return l2_dist + + +def get_param_weights_counts(net, detach): + weight_dict = {} + count_dict = {} + for param in net.named_parameters(): + name = param[0] + weights = param[1] + if detach: + weight_dict[name] = weights.detach().clone() + else: + weight_dict[name] = weights + count_dict[name] = np.prod(np.array(list(param[1].shape))) + return weight_dict, count_dict + + +def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, + test_loaders, max_test_examples, weight_dict_initial): + # Returns a dictionary with epoch, train/loss and train/acc. + # Train model. + training_state = net.training + logging.info("\nEpoch #{}".format(epoch)) + loss_dict = { + 'train/loss': Accumulator(), + 'train/acc': Accumulator(), + } + if 'l2sp_weight' in config: + loss_dict['train/l2sp_loss'] = Accumulator() + if 'model_loss' in config: + loss_dict['train/model_loss'] = Accumulator() + num_examples = 0 + for i, data in enumerate(train_loader, 0): + if 'use_net_val_mode' in config and config['use_net_val_mode']: + net.eval() + else: + net.train() + # get the inputs; data is a list of [inputs, labels] + if config['use_cuda']: + data = utils.to_device(data, device) + inputs, labels = data + optimizer.zero_grad() + outputs = net(inputs) + loss = criterion(outputs, labels) + if 'l2sp_weight' in config: + weight_dict, _ = get_param_weights_counts(net, detach=False) + l2sp_loss = config['l2sp_weight'] * get_l2_dist(weight_dict_initial, weight_dict) + loss_dict['train/l2sp_loss'].add_value(l2sp_loss.tolist()) + loss += l2sp_loss + _, train_preds = torch.max(outputs.data, axis=1) + loss_dict['train/loss'].add_value(loss.tolist()) + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + if 'model_loss' in config: + opt_loss = model_loss(net, inputs, labels) + opt_loss.backward() + loss_dict['train/model_loss'].add_value(opt_loss.tolist()) + else: + loss.backward() + optimizer.step() + num_examples += len(labels) + outputs, loss, train_preds = None, None, None # Try to force garbage collection. + def should_log(log_interval): + return num_examples // log_interval > (num_examples - len(labels)) // log_interval + if should_log(config['log_interval']): + for k in loss_dict: + logging.info( + '[%d, %5d] %s: %.3f' % + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + # Sometimes we want to log the test loss more often to track things better. + if 'test_interval' in config and should_log(config['test_interval']): + stats = get_all_test_stats( + test_loaders, max_test_examples, config, net, criterion, device, + log_dir=log_dir, loss_name_prefix='inter_test_loss/', acc_name_prefix='inter_test_acc/') + if config['wandb']: + wandb.log(stats) + reset_state(net, training_state) + train_stats = {'epoch': epoch} + for key in loss_dict: + train_stats[key] = loss_dict[key].get_mean() + return train_stats + + +def get_all_test_stats(epoch, test_loaders, max_test_examples, config, net, criterion, device, + log_dir, loss_name_prefix, acc_name_prefix): + stats = {'epoch': epoch} + for name, test_loader in test_loaders.items(): + logging.info(f'testing {name}') + max_examples = float('infinity') + if name in max_test_examples: + max_examples = max_test_examples[name] + val_loss, val_acc = get_test_stats( + config, net, test_loader, criterion, device, epoch, name, + log_dir=log_dir, max_examples=max_examples) + # So this will look something like 'test_loss/cinic', 'test_acc/cinic'. + stats[loss_name_prefix + name] = val_loss.get_mean() + stats[acc_name_prefix + name] = val_acc.get_mean() + return stats + + +def get_params(layers): + params = [] + for layer in layers: + for param in layer.parameters(): + params.append(param) + return params + + +def main(config, log_dir, checkpoints_dir): + # Set up datasets and loaders. + logging.info("Entering main.") + train_loader = get_train_loader(config) + # Set up test loaders. + test_loaders, max_test_examples = get_test_loaders(config) + # Create model. + net = build_model(config) + # Use CUDA if desired. + logging.info(f'cuda device count: {torch.cuda.device_count()}') + if config['use_cuda']: + # Often makes things faster, by benchmarking and figuring out how to optimize. + cudnn.benchmark = True + device = "cuda" + net.cuda() + logging.info('Using cuda? %d', next(net.parameters()).is_cuda) + # Loss, optimizer, scheduler. + # Can use a custom loss that takes in a model, inputs, labels, and gets an array of values. + # For example if you want to regularize weights in some special way. + # More commonly, we use a criterion, which takes in model_outputs, labels, and outputs a loss. + # criterion must be specified anyway, since that's the loss we evaluate on test sets. + criterion = utils.initialize(config['criterion']) + model_loss = None + if 'model_loss' in config: + model_loss = utils.initialize(config['model_loss']) + if 'linear_layer_lr_multiplier' in config: + base_params = get_params(list(net._model.children())[:-1]) + fc_params = get_params(list(net._model.children())[-1:]) + base_lr = config['optimizer']['args']['lr'] + fc_lr = config['linear_layer_lr_multiplier'] * base_lr + logging.info('Using lr %f for fc layer, %d params', fc_lr, len(fc_params)) + param_groups = [ + {'params': base_params}, + {'params': fc_params, 'lr': fc_lr} + ] + optimizer = utils.initialize( + config['optimizer'], update_args={'params': param_groups}) + else: + optimizer = utils.initialize( + config['optimizer'], update_args={'params': net.parameters()}) + scheduler = utils.initialize( + config['scheduler'], update_args={'optimizer': optimizer}) + # Training loop. + best_stats = {} + best_accs = {} # Used to save checkpoints of best models on some datasets. + train_metrics = [] + test_metrics = [] + prev_ckp_path = None + # For the first epoch we get stats, but we don't save them or update best checkpoint. + # This can be useful if we start with a great model that quickly gets corrupted in the first + # epoch, we don't want the initial statistics to dominate. + # First argument is epoch. + test_stats = get_all_test_stats( + 0, test_loaders, max_test_examples, config, net, criterion, device, + log_dir=log_dir, loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') + # Log stats. + logging.info('Initial test stats') + logging.info(test_stats) + # If l2sp, then save initial weights so we can regularize towards them. + weight_dict_initial = None + if 'l2sp_weight' in config: + weight_dict_initial, _ = get_param_weights_counts(net, detach=True) + + for epoch in range(config['epochs']): + # Save checkpoint once in a while. + if epoch % config['save_freq'] == 0 and ( + 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): + cur_ckp_filename = 'ckp_' + str(epoch) + utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, cur_ckp_filename) + if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): + os.remove(prev_ckp_path) + prev_ckp_path = checkpoints_dir / cur_ckp_filename + # One epoch of model training. + train_stats = train( + epoch, config, train_loader, net, device, optimizer, criterion, model_loss, + test_loaders, max_test_examples, weight_dict_initial) + scheduler.step() + # Get test stats across all test sets. + test_stats = get_all_test_stats( + epoch, test_loaders, max_test_examples, config, net, criterion, device, + log_dir=log_dir, loss_name_prefix='test_loss/', acc_name_prefix='test_acc/') + # Keep track of the best stats. + update_best_stats(train_stats, best_stats) + update_best_stats(test_stats, best_stats) + # Log and save stats. + train_metrics.append(train_stats) + test_metrics.append(test_stats) + train_df = pd.DataFrame(train_metrics) + test_df = pd.DataFrame(test_metrics) + df = train_df.merge(test_df, on='epoch') + assert(len(df) == len(train_df) == len(test_df)) + df.to_csv(log_dir + '/stats.tsv', sep='\t') + if config['wandb']: + wandb.log(train_stats) + wandb.log(test_stats) + wandb.log(best_stats) + utils.save_json(log_dir + '/current_train.json', train_stats) + utils.save_json(log_dir + '/current_test.json', test_stats) + utils.save_json(log_dir + '/best.json', best_stats) + # Save checkpoint of best model. We save the 'best' for each of a list + # of specified valid datasets. For example, we might want to save the best + # model according to in-domain validation metrics, but as an oracle, save + # the best according to ood validation metrics (or a proxy ood metric). + if 'early_stop_dataset_names' in config: + logging.info(f"Early stopping using datasets {config['early_stop_dataset_names']}") + for name in config['early_stop_dataset_names']: + if name not in test_loaders: + raise ValueError(f"{name} is not the name of a test dataset.") + metric_name = 'test_acc/' + name + assert(metric_name in test_stats) + if metric_name not in best_accs or test_stats[metric_name] > best_accs[metric_name]: + best_accs[metric_name] = test_stats[metric_name] + checkpoint_name = 'ckp_best_' + name + if 'save_no_checkpoints' not in config or not config['save_no_checkpoints']: + utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, checkpoint_name) + if 'save_no_checkpoints' not in config or not config['save_no_checkpoints']: + utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, 'ckp_last') + + +def make_new_dir(new_dir, remove_old_ok=True): + if os.path.isdir(new_dir): + logging.warning("Removed old run directory.") + shutil.rmtree(new_dir) + os.makedirs(new_dir) + + +def make_checkpoints_dir(log_dir): + checkpoints_dir = log_dir + '/checkpoints' + checkpoints_dir = Path(checkpoints_dir).resolve().expanduser() + if os.path.exists(checkpoints_dir): + shutil.rmtree(checkpoints_dir) + os.makedirs(checkpoints_dir) + return checkpoints_dir + + +def copy_folders(log_dir): + copy_folders = ['code', 'configs', 'scripts', 'lib', 'configs', 'models', + 'experiments', 'utils', 'examples', 'src', 'datasets'] + for copy_folder in copy_folders: + if os.path.isdir('./' + copy_folder): + shutil.copytree('./' + copy_folder, log_dir + '/' + copy_folder) + + +def time_to_str(ts): + return pd.Timestamp(ts).strftime('%Y-%m-%dT%H-%M-%S-%f') + + +def now_to_str(): + return time_to_str(datetime.datetime.now()) + + +def setup_wandb(args, config): + if not args.no_wandb: + run_name = now_to_str() if args.run_name is None else args.run_name + print(args.project_name, run_name, args.group_name, args.entity_name) + run_obj = wandb.init( + project=args.project_name, name=run_name, + group=args.group_name, entity=args.entity_name) + config['wandb_url'] = run_obj.get_url() + config['run_name'] = run_name + config['group_name'] = args.group_name + config['entity_name'] = args.entity_name + config['wandb'] = True + wandb.config.update(config) + else: + config['wandb'] = False + + +def save_command_line_args(log_dir): + command = "" + command += sys.executable + " " + command += " ".join(sys.argv) + logging.info('Command: ' + command) + with open(log_dir+'/command.txt', 'w') as f: + f.write(command) + f.write('\n') + + +def update_train_transform(config): + if 'no_augmentation' in config and config['no_augmentation']: + if 'default_test_transforms' not in config: + raise ValueError('If no_augmentation=True, must specify default_test_transforms.') + config['train_dataset']['transforms'] = config['default_test_transforms'] + + +def update_test_transform_args_configs(config): + # Use default test transform for test datasets that don't specify a transform. + for test_dataset_config in config['test_datasets']: + if 'transforms' not in test_dataset_config: + if config['default_test_transforms'] is None: + raise ValueError('Must either specify default_test_transforms ' + 'or a transform for each test dataset') + test_dataset_config['transforms'] = config['default_test_transforms'] + if config['default_test_args'] is not None: + for default_test_arg in config['default_test_args']: + if default_test_arg not in test_dataset_config['args']: + test_dataset_config['args'][default_test_arg] = config['default_test_args'][default_test_arg] + + +def update_root_prefix(config): + # Go through test datasets, and train dataset. If root_prefix specified, then prepend that + # to the root. + def apply_root_prefix(dataset_config, root_prefix): + for key in ['root', 'cache_path', 'pickle_file_path']: + if key in dataset_config['args']: + orig_path = dataset_config['args'][key] + logging.info('orig_path %s', orig_path) + dataset_config['args'][key] = root_prefix + '/' + orig_path + + if 'root_prefix' in config: + root_prefix = config['root_prefix'] + logging.info("Adding root prefix %s to all roots.", root_prefix) + apply_root_prefix(config['train_dataset'], root_prefix) + for test_dataset_config in config['test_datasets']: + apply_root_prefix(test_dataset_config, root_prefix) + + +def update_net_eval_mode(config): + # If linear probing, then by default we want to turn off batchnorm while training. + # In other words we want to use validation mode while training unless otherwise specified. + linear_probe = 'linear_probe' in config and config['linear_probe'] + if linear_probe: + if 'use_net_val_mode' not in config: + config['use_net_val_mode'] = True + logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') + + +def set_random_seed(seed): + if seed is not None: + torch.manual_seed(seed) + np.random.seed(seed + 111) + + +def preprocess_config(config, config_path): + # If it's not a json config (e.g. if it's yaml) then process it. + if not config_path.endswith('.json'): + # If we don't specify a transform for some test datasets, but specify a default transform, + # then use the default transform for that dataset. For datasets that do specify a transform + # we use that and not the default transform. + update_test_transform_args_configs(config) + # If linear probing, by default we turn batch-norm off while training, if unspecified. + # If you want bach-norm even when lin probing then set use_net_val_mode to False in the config. + update_net_eval_mode(config) + # Datasets may be stored in different directories in different clusters and platforms. + # We allow specifying a root_prefix that gets prepended to any specified dataset roots. + # So if config['root_prefix'] is defined then we prepend it to dataset['args']['root'] for + # train and test datasets. + update_root_prefix(config) + # # Note: copying config over is not that useful anymore with Quinine, so use json below. + # shutil.copy(args.config, log_dir+'/original_config.yaml') + # If no_augmentation option in config, then use test_transforms for training. + update_train_transform(config) + + +def setup(): + parser = argparse.ArgumentParser( + description='Run model') + parser.add_argument('--config', type=str, metavar='c', + help='YAML config', required=True) + parser.add_argument('--log_dir', type=str, metavar='ld', + help='Log directory', required=True) + parser.add_argument('--tmp_par_ckp_dir', type=str, + help='Temporary directory to save checkpoints instead of log_dir.') + parser.add_argument('--no_wandb', action='store_true', help='disable W&B') + parser.add_argument('--copy_all_folders', action='store_true', + help='Copy all folders (e.g. code, utils) for reproducibility.') + parser.add_argument('--project_name', type=str, + help='Name of the wandb project', required=True) + parser.add_argument('--group_name', default=None, help='Name of the wandb group (a group of runs)') + parser.add_argument('--run_name', default=None, help='Name of the wandb run') + parser.add_argument('--entity_name', default='p-lambda', help='Name of the team') + parser.add_argument('--seed', type=int, default=None, help='random seed') + + args, unparsed = parser.parse_known_args() + log_dir = args.log_dir + # Make log and checkpoint directories. + make_new_dir(log_dir) + # Sometimes we don't want to overload a distributed file system with checkpoints. + # So we save checkpoints on a tmp folder on a local machine. Then later we transfer + # the checkpoints back. + if args.tmp_par_ckp_dir is not None: + checkpoints_dir = make_checkpoints_dir(args.tmp_par_ckp_dir) + else: + checkpoints_dir = make_checkpoints_dir(log_dir) + # If you want to copy folders to get the whole state of code + # while running. For more reproducibility. + if args.copy_all_folders: + copy_folders(args.log_dir) + # Setup logging. + utils.setup_logging(log_dir, log_level) + logging.info('Running on machine %s', socket.gethostname()) + # Open config, update with command line args + if args.config.endswith('.json'): + # For json files, we just use it directly and don't process it, e.g. by adding + # root_prefix. Use this for loading saved configurations. + with open(args.config) as json_file: + config = json.load(json_file) + else: + config = quinine.Quinfig(args.config) + # Update config with command line arguments. + utils.update_config(unparsed, config) + # This makes specifying certain things more convenient, e.g. don't have to specify a + # transform for every test datset. + preprocess_config(config, args.config) + # If we should save model preds, then save them. + if 'save_model_preds' in config and config.save_model_preds: + os.makedirs(log_dir + '/model_preds/') + # Setup wandb. + setup_wandb(args, config) + # Set seed. + config['seed'] = args.seed + set_random_seed(args.seed) + # Save updated config. + config_json = log_dir+'/config.json' + with open(config_json, 'w') as f: + json.dump(config, f) + # Save command line arguments. + save_command_line_args(log_dir) + return config, log_dir, checkpoints_dir, args.tmp_par_ckp_dir + + +if __name__ == "__main__": + config, log_dir, checkpoints_dir, tmp_par_ckp_dir = setup() + main(config, log_dir, checkpoints_dir) + # Tear down, i.e. copy checkpoints over from local machine to juice. + if tmp_par_ckp_dir is not None: + new_checkpoints_dir = log_dir + '/checkpoints' + logging.info('Copying from %s to %s', checkpoints_dir, new_checkpoints_dir) + shutil.copytree(checkpoints_dir, new_checkpoints_dir) + diff --git a/unlabeled_extrapolation/datasets/__init__.py b/unlabeled_extrapolation/datasets/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/datasets/breeds.py b/unlabeled_extrapolation/datasets/breeds.py similarity index 87% rename from datasets/breeds.py rename to unlabeled_extrapolation/datasets/breeds.py index 5432c27..2564caa 100644 --- a/datasets/breeds.py +++ b/unlabeled_extrapolation/datasets/breeds.py @@ -61,15 +61,17 @@ def get_image_paths_by_class(data_dir, idx_to_class_id, subclasses, split): return image_paths_and_class class Breeds(Dataset): - def __init__(self, root, breeds_name, info_dir='/juice/scr/ananya/cifar_experiments/BREEDS-Benchmarks/imagenet_class_hierarchy/modified', - source=True, split='train', transform=None): + source=True, target=False, split='train', transform=None): super().__init__() if breeds_name not in BREEDS_SPLITS_TO_FUNC.keys(): raise ValueError(f'breeds_name must be in {BREEDS_SPLITS_TO_FUNC.keys()} but was {breeds_name}') if split not in SPLITS: raise ValueError(f'split must be in {SPLITS} but was {split}') + if not source and not target: + raise ValueError('At least one of "source" and "target" must be True!') + self._breeds_name = breeds_name self._source = source self._split = split @@ -79,13 +81,19 @@ def __init__(self, root, breeds_name, self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir) breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name] self._superclasses, self._subclass_split, self._label_map = breeds_func(self._info_dir, split="rand") + self._subclasses = [] + if source: - self._subclasses = self._subclass_split[0] - else: - self._subclasses = self._subclass_split[1] + self._subclasses.extend(self._subclass_split[0]) + if target: + self._subclasses.extend(self._subclass_split[1]) + self._image_paths_by_class = get_image_paths_by_class( self._data_dir, self._idx_to_class_id, self._subclasses, split) + self.means = [0.485, 0.456, 0.406] + self.stds = [0.228, 0.224, 0.225] + def __getitem__(self, i): path, y = self._image_paths_by_class[i] x = Image.open(path) @@ -97,3 +105,5 @@ def __getitem__(self, i): def __len__(self) -> int: return len(self._image_paths_by_class) + def get_num_classes(self): + return len(self._idx_to_class_id) diff --git a/unlabeled_extrapolation/datasets/celeba.py b/unlabeled_extrapolation/datasets/celeba.py new file mode 100644 index 0000000..6c8bf19 --- /dev/null +++ b/unlabeled_extrapolation/datasets/celeba.py @@ -0,0 +1,183 @@ +from functools import partial +import numpy as np +import os +import pandas +from pathlib import Path +import pickle +from PIL import Image +import torch +from torch.utils.data import Dataset +from torchvision import transforms +# from innout.datasets import RangeDataset + + +JUICE_CELEBA_ROOT = '/juice/scr/ananya/celeba' + +SPLIT_TO_IDX = { + 'train': 0, + 'val': 1, + 'test': 2, +} + + +attribute_names = ['5_o_Clock_Shadow', 'Arched_Eyebrows', 'Attractive', 'Bags_Under_Eyes', + 'Bald', 'Bangs', 'Big_Lips', 'Big_Nose', 'Black_Hair', 'Blond_Hair', + 'Blurry', 'Brown_Hair', 'Bushy_Eyebrows', 'Chubby', 'Double_Chin', + 'Eyeglasses', 'Goatee', 'Gray_Hair', 'Heavy_Makeup', 'High_Cheekbones', + 'Male', 'Mouth_Slightly_Open', 'Mustache', 'Narrow_Eyes', 'No_Beard', + 'Oval_Face', 'Pale_Skin', 'Pointy_Nose', 'Receding_Hairline', + 'Rosy_Cheeks', 'Sideburns', 'Smiling', 'Straight_Hair', 'Wavy_Hair', + 'Wearing_Earrings', 'Wearing_Hat', 'Wearing_Lipstick', + 'Wearing_Necklace', 'Wearing_Necktie', 'Young'] + + +def resize_transform(): + return transforms.Compose([ + transforms.Resize((64,64), interpolation=2), + transforms.ToTensor()]) + + +def tensor_transform(): + return transforms.ToTensor() + + +def invert_list(l): + """Return a list that inverts the mapping of l.""" + dict = {} + for i, x in zip(range(len(l)), l): + dict[x] = i + return dict + + +attr_name_to_idx = invert_list(attribute_names) + + +domain_selectors = { + 'wearing_hat': lambda a: a[attr_name_to_idx['Wearing_Hat']], + 'not_wearing_hat': lambda a: 1 - a[attr_name_to_idx['Wearing_Hat']], +} + + +def select_indices(attributes, attribute_selector): + """Return a list of indices i where attribute_selector(attributes[i]) is True.""" + mask = np.apply_along_axis(attribute_selector, axis=1, arr=attributes) + return np.argwhere(mask) + + +def sample_indices(indices, target, pos_fraction, num_points, rng): + # First split into two groups, positive and negative + num_pos = round(num_points * pos_fraction) + num_neg = num_points - num_pos + pos_indices = indices[target == 1] + neg_indices = indices[target == 0] + rng.shuffle(pos_indices) + rng.shuffle(neg_indices) + indices = np.concatenate([pos_indices[:num_pos], neg_indices[:num_neg]]) + rng.shuffle(indices) + return indices + + +# TODO: call this file and produce a pickle. +def celeba_to_pickle(save_file, celeba_root=JUICE_CELEBA_ROOT): + """Save the CelebA dataset into a pickle file.""" + fn = partial(os.path.join, celeba_root) + celeba_splits = pandas.read_csv( + fn("list_eval_partition.txt"), delim_whitespace=True, header=None, index_col=0) +# mask = (celeba_splits[1] == 0) # Use celeba training set. + filenames = celeba_splits.index.values + images = [] + counter = 0 + for filename in filenames: + if counter % 1000 == 0: + print(counter) + counter += 1 + img = Image.open(os.path.join(celeba_root, "img_align_celeba", filename)) + images.append(np.array(img)) + file = open(save_file, "wb") + pickle.dump(images, file) + file.close() + + + +class CelebA(Dataset): + def __init__(self, target_attribute, split, supergroup_n=None, num_subgroups=None, subgroup_idx=None, + seed=None, transform=None, celeba_root=JUICE_CELEBA_ROOT, pickle_file_path=None, + verbose=False): + if split not in SPLIT_TO_IDX: + raise ValueError(f'Split must be in {SPLIT_TO_IDX} but was {split}') + self._rng = np.random.RandomState(seed) + self._celeba_root = celeba_root + fn = partial(os.path.join, self._celeba_root) + self._split = split + celeba_splits = pandas.read_csv( + fn("list_eval_partition.txt"), delim_whitespace=True, header=None, index_col=0) + mask = (celeba_splits[1] == SPLIT_TO_IDX[split]) # Use appropriate split. + self._pickle_file_path = pickle_file_path + if pickle_file_path is None: + self._filenames = celeba_splits[mask].index.values + else: + self._images = pickle.load(open(pickle_file_path, "rb")) + attr = pandas.read_csv(fn("list_attr_celeba.txt"), delim_whitespace=True, header=1) + self._attr = torch.as_tensor(attr[mask].values) + self._attr = (self._attr + 1) // 2 # map from {-1, 1} to {0, 1} + self._attr_names = list(attr.columns) + assert self._attr_names == attribute_names + self._transform = transform + + # Convert meta-attributes and target attribute to indices if they are strings. + def convert_attr_desc_to_index(attr_desc): + if type(attr_desc) == str: + if not attr_desc in attribute_names: + raise ValueError('Attributes specified must be a valid string or integer between 0 and' + ' 39 inclusive but was {}'.format(attr_desc)) + return attr_name_to_idx[attr_desc] + else: + if not(0 <= attr_desc <= 39): + raise ValueError('Attributes specified must be a valid string or integer between 0 and' + ' 39 inclusive but was {}'.format(attr_desc)) + return attr_desc + self._target_attribute = convert_attr_desc_to_index(target_attribute) + + # For now just return all the indices + self._indices = np.arange(len(self._attr)) + + if split == 'train': + # Populate default values, which is to use the entire training set, one subgroup, and pick the first subgroup. + if subgroup_idx is None: + subgroup_idx = 0 + if num_subgroups is None: + num_subgroups = 1 + if supergroup_n is None: + supergroup_n = len(self._indices) + # Select a random supergroup_n number of indices. + self._indices = self._rng.permutation(self._indices)[:supergroup_n] + if not(0 <= subgroup_idx < num_subgroups): + raise ValueError(f'{subgroup_idx} should be in between 0 and {num_subgroups-1} inclusive') + # Get the indices for this subgroup. + lower_i = int(np.floor(float(subgroup_idx) / num_subgroups * supergroup_n)) + upper_i = int(np.floor(float(subgroup_idx+1) / num_subgroups * supergroup_n)) + if verbose: + print('celeba index splits: ', lower_i, upper_i) + if subgroup_idx == num_subgroups - 1 and upper_i != supergroup_n: + print(f'floating point issue, got {upper_i} for upper index with subgroup idx {subgroup_idx}, converting to {supergroup_n}') + upper_i = supergroup_n + self._indices = sorted(self._indices[lower_i:upper_i]) + if verbose: + print('first 20 indices: ', self._indices[:20]) + else: + # Use the entire set of indices for val and test set. + pass + + def __getitem__(self, i): + index = self._indices[i] + if self._pickle_file_path is None: + x = Image.open(os.path.join(self._celeba_root, "img_align_celeba", self._filenames[index])) + else: + x = Image.fromarray(self._images[index]) + if self._transform is not None: + x = self._transform(x) + y = self._attr[index][self._target_attribute] + return x, y + + def __len__(self) -> int: + return len(self._indices) diff --git a/unlabeled_extrapolation/datasets/check_breeds.ipynb b/unlabeled_extrapolation/datasets/check_breeds.ipynb new file mode 100644 index 0000000..b469f37 --- /dev/null +++ b/unlabeled_extrapolation/datasets/check_breeds.ipynb @@ -0,0 +1,169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import breeds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "154263\n" + ] + } + ], + "source": [ + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'entity30', source=True, target=False)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "153565\n" + ] + } + ], + "source": [ + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'entity30', source=False, target=True)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "44200\n" + ] + } + ], + "source": [ + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'living17', source=True, target=False)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "44200\n" + ] + } + ], + "source": [ + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'living17', source=False, target=True)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset sizes: source (154263), target (153565). Standardizing to the smaller size.\n", + "153565\n", + "Dataset sizes: source (154263), target (153565). Standardizing to the smaller size.\n", + "153565\n", + "Dataset sizes: source (154263), target (153565). Standardizing to the smaller size.\n", + "153565\n" + ] + } + ], + "source": [ + "# standardization\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'entity30', source=True, target=False, downsample=True)\n", + "print(len(ds))\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'entity30', source=False, target=True, downsample=True)\n", + "print(len(ds))\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'entity30', source=True, target=True, downsample=True)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset sizes: source (44200), target (44200). Standardizing to the smaller size.\n", + "44200\n", + "Dataset sizes: source (44200), target (44200). Standardizing to the smaller size.\n", + "44200\n", + "Dataset sizes: source (44200), target (44200). Standardizing to the smaller size.\n", + "44200\n" + ] + } + ], + "source": [ + "# standardization\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'living17', source=True, target=False, downsample=True)\n", + "print(len(ds))\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'living17', source=False, target=True, downsample=True)\n", + "print(len(ds))\n", + "ds = breeds.Breeds('/u/scr/nlp/imagenet/', 'living17', source=True, target=True, downsample=True)\n", + "print(len(ds))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/datasets/cifar10_resized.py b/unlabeled_extrapolation/datasets/cifar10_resized.py similarity index 100% rename from datasets/cifar10_resized.py rename to unlabeled_extrapolation/datasets/cifar10_resized.py diff --git a/datasets/cifar10c.py b/unlabeled_extrapolation/datasets/cifar10c.py similarity index 100% rename from datasets/cifar10c.py rename to unlabeled_extrapolation/datasets/cifar10c.py diff --git a/unlabeled_extrapolation/datasets/cifar10p1.py b/unlabeled_extrapolation/datasets/cifar10p1.py new file mode 100644 index 0000000..92b5c90 --- /dev/null +++ b/unlabeled_extrapolation/datasets/cifar10p1.py @@ -0,0 +1,62 @@ +# CIFAR-10.1 dataset, by Rebecca Roelofs and Ludwig Schmidt +# Copying the utils from there for convenience. + +import os +import pathlib +from PIL import Image + +import torch +from torch.utils.data import Dataset +import numpy as np + + +def load_new_test_data(root, version_string=''): + data_path = root + filename = 'cifar10.1' + if version_string == '': + version_string = 'v7' + if version_string in ['v4', 'v6', 'v7']: + filename += '_' + version_string + else: + raise ValueError('Unknown dataset version "{}".'.format(version_string)) + label_filename = filename + '_labels.npy' + imagedata_filename = filename + '_data.npy' + label_filepath = os.path.abspath(os.path.join(data_path, label_filename)) + imagedata_filepath = os.path.abspath(os.path.join(data_path, imagedata_filename)) + print('Loading labels from file {}'.format(label_filepath)) + assert pathlib.Path(label_filepath).is_file() + labels = np.load(label_filepath) + print('Loading image data from file {}'.format(imagedata_filepath)) + assert pathlib.Path(imagedata_filepath).is_file() + imagedata = np.load(imagedata_filepath) + assert len(labels.shape) == 1 + assert len(imagedata.shape) == 4 + assert labels.shape[0] == imagedata.shape[0] + assert imagedata.shape[1] == 32 + assert imagedata.shape[2] == 32 + assert imagedata.shape[3] == 3 + if version_string == 'v6' or version_string == 'v7': + assert labels.shape[0] == 2000 + elif version_string == 'v4': + assert labels.shape[0] == 2021 + return imagedata, labels + + +class CIFAR10p1(Dataset): + + def __init__(self, root, split='train', version='v6', transform=None): + super().__init__() + imagedata, labels = load_new_test_data(root=root, version_string=version) + self._transform = transform + self._imagedata = imagedata + self._labels = labels + + def __getitem__(self, i): + x = Image.fromarray(np.uint8(self._imagedata[i])) + if self._transform is not None: + x = self._transform(x) + y = self._labels[i] + return x, y + + def __len__(self) -> int: + return len(self._imagedata) diff --git a/datasets/cinic.py b/unlabeled_extrapolation/datasets/cinic.py similarity index 100% rename from datasets/cinic.py rename to unlabeled_extrapolation/datasets/cinic.py diff --git a/unlabeled_extrapolation/datasets/connectivity_utils.py b/unlabeled_extrapolation/datasets/connectivity_utils.py new file mode 100644 index 0000000..9a58c6f --- /dev/null +++ b/unlabeled_extrapolation/datasets/connectivity_utils.py @@ -0,0 +1,280 @@ +import torch +from torch.utils.data import Dataset +import torchvision.transforms as transforms +import numpy as np +import cv2 + +import os +from PIL import Image + +from . import breeds, domainnet +VALID_BREEDS_DOMAINS = breeds.BREEDS_SPLITS_TO_FUNC.keys() +VALID_DOMAINNET_DOMAINS = domainnet.SENTRY_DOMAINS + +######################### +#### DATA AUG STUFF ##### +######################### + +def get_transforms(transform_scheme): + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + if transform_scheme == 'imagenet': + transform = transforms.Compose([ + transforms.RandomResizedCrop(224), + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + normalize, + ]) + elif transform_scheme == 'simclr': + # adapted from + # https://github.com/PyTorchLightning/Lightning-Bolts/blob/master/pl_bolts/models/self_supervised/simclr/transforms.py + size = 224 + kernel_size = int(0.1 * size) + if kernel_size % 2 == 0: + kernel_size += 1 + transform = transforms.Compose([ + transforms.RandomResizedCrop(size), + transforms.RandomHorizontalFlip(), + transforms.RandomApply([ + transforms.ColorJitter(0.8, 0.8, 0.8, 0.2) + ], p=0.8), + transforms.RandomGrayscale(p=0.2), + GaussianBlur(kernel_size=kernel_size, p=0.5), + transforms.ToTensor(), + ]) + else: + raise ValueError('Transformation scheme not supported') + return transform + +class GaussianBlur(object): + # Implements Gaussian blur as described in the SimCLR paper + # https://github.com/PyTorchLightning/Lightning-Bolts/blob/master/pl_bolts/models/self_supervised/simclr/transforms.py + def __init__(self, kernel_size, p=0.5, min=0.1, max=2.0): + self.min = min + self.max = max + + # kernel size is set to be 10% of the image height/width + self.kernel_size = kernel_size + self.p = p + + def __call__(self, sample): + sample = np.array(sample) + + # blur the image with a 50% chance + prob = np.random.random_sample() + + if prob < self.p: + sigma = (self.max - self.min) * np.random.random_sample() + self.min + sample = cv2.GaussianBlur(sample, (self.kernel_size, self.kernel_size), sigma) + + return sample + +##################### +### DATASET STUFF ### +##################### + +def validate_dataset(dataset_name, source, target): + if dataset_name == 'breeds': + if source not in VALID_BREEDS_DOMAINS: + raise ValueError(f'Valid Breeds domains are {VALID_BREEDS_DOMAINS} but received ' + f'source {source}.') + if target is not None and source != target: + raise ValueError(f'Must use the same task for source and target: tried to set ' + f'source {source} and target {target}.') + num_classes = { + 'entity30': 30, + 'living17': 17 + }[source] + elif dataset_name == 'domainnet': + if (source not in VALID_DOMAINNET_DOMAINS) or (target not in VALID_DOMAINNET_DOMAINS): + raise ValueError(f'Valid DomainNet domains are {VALID_DOMAINNET_DOMAINS} but ' + f'received source {source} and target {target}.') + if source == target: + raise ValueError(f'Should not use the same domain as source and target: {source}.') + num_classes = domainnet.NUM_CLASSES_DICT['sentry'] + else: + raise ValueError(f'Unsupported dataset: {dataset_name}.') + return num_classes + +class DomainClassificationDataset(Dataset): + def __init__(self, ds1, ds2, data_attr_name, dataset_name, transform=None, + data_path=None): + super().__init__() + ds1_samples = getattr(ds1, data_attr_name) + ds2_samples = getattr(ds2, data_attr_name) + self.samples = [(item[0], 0) for item in ds1_samples] + \ + [(item[0], 1) for item in ds2_samples] + self._transform = transform + self._dataset_name = dataset_name + self._data_path = data_path # only necessary for domainnet + + def __getitem__(self, i): + if self._dataset_name == 'breeds': + path, y = self.samples[i] + x = Image.open(path) + elif self._dataset_name == 'domainnet': + path, y = self.samples[i] + x = Image.open(os.path.join(self._data_path, path)) + y = int(y) + else: + raise NotImplementedError('Only breeds and domainnet are supported.') + x = x.convert('RGB') + if self._transform is not None: + x = self._transform(x) + return x, y + + def __len__(self): + return len(self.samples) + +def filter_to_single_class(dataset, class_to_use, data_attr_name): + setattr(dataset, data_attr_name, + list(filter(lambda item: int(item[1]) == class_to_use, getattr(dataset, data_attr_name)))) + +def get_class_datasets(dataset_name, domain_name, class_1, class_2, transform, + data_path, use_source): + if dataset_name == 'breeds': + data_attr = '_image_paths_by_class' + train_1 = breeds.Breeds(data_path, domain_name, source=use_source, + target=(not use_source), split='train') + test_1 = breeds.Breeds(data_path, domain_name, source=use_source, + target=(not use_source), split='val') + train_2 = breeds.Breeds(data_path, domain_name, source=use_source, + target=(not use_source), split='train') + test_2 = breeds.Breeds(data_path, domain_name, source=use_source, + target=(not use_source), split='val') + elif dataset_name == 'domainnet': + data_attr = 'data' + train_1 = domainnet.DomainNet(domain_name, split='train', root=data_path) + test_1 = domainnet.DomainNet(domain_name, split='test', root=data_path) + train_2 = domainnet.DomainNet(domain_name, split='train', root=data_path) + test_2 = domainnet.DomainNet(domain_name, split='test', root=data_path) + else: + raise ValueError('Only supports Breeds and domainnet currently') + filter_to_single_class(train_1, class_1, data_attr) + filter_to_single_class(test_1, class_1, data_attr) + filter_to_single_class(train_2, class_2, data_attr) + filter_to_single_class(test_2, class_2, data_attr) + train_ds = DomainClassificationDataset(train_1, train_2, data_attr, dataset_name, + transform=transform, data_path=data_path) + test_ds = DomainClassificationDataset(test_1, test_2, data_attr, dataset_name, + transform=transform, data_path=data_path) + return train_ds, test_ds + +def get_domain_datasets(dataset_name, source, target, data_path, class_idx, transform): + if dataset_name == 'breeds': + data_attr = '_image_paths_by_class' + source_train = breeds.Breeds(data_path, source, source=True, target=False, split='train') + target_train = breeds.Breeds(data_path, target, source=False, target=True, split='train') + source_test = breeds.Breeds(data_path, source, source=True, target=False, split='val') + target_test = breeds.Breeds(data_path, target, source=False, target=True, split='val') + elif dataset_name == 'domainnet': + data_attr = 'data' + source_train = domainnet.DomainNet(source, split='train', root=data_path) + target_train = domainnet.DomainNet(target, split='train', root=data_path) + source_test = domainnet.DomainNet(source, split='test', root=data_path) + target_test = domainnet.DomainNet(target, split='test', root=data_path) + else: + raise ValueError('Only supports Breeds and DomainNet currently') + filter_to_single_class(source_train, class_idx, data_attr) + filter_to_single_class(target_train, class_idx, data_attr) + filter_to_single_class(source_test, class_idx, data_attr) + filter_to_single_class(target_test, class_idx, data_attr) + train_ds = DomainClassificationDataset(source_train, target_train, data_attr, dataset_name, + transform=transform, data_path=data_path) + test_ds = DomainClassificationDataset(source_test, target_test, data_attr, dataset_name, + transform=transform, data_path=data_path) + return train_ds, test_ds + +def get_pooled_datasets(dataset_name, source, target, data_path, transform): + if dataset_name == 'breeds': + data_attr = '_image_paths_by_class' + source_train = breeds.Breeds(data_path, source, source=True, target=False, split='train') + target_train = breeds.Breeds(data_path, target, source=False, target=True, split='train') + source_test = breeds.Breeds(data_path, source, source=True, target=False, split='val') + target_test = breeds.Breeds(data_path, target, source=False, target=True, split='val') + elif dataset_name == 'domainnet': + data_attr = 'data' + source_train = domainnet.DomainNet(source, split='train', root=data_path) + target_train = domainnet.DomainNet(target, split='train', root=data_path) + source_test = domainnet.DomainNet(source, split='test', root=data_path) + target_test = domainnet.DomainNet(target, split='test', root=data_path) + else: + raise ValueError('Only supports Breeds and DomainNet currently') + train_ds = DomainClassificationDataset(source_train, target_train, data_attr, dataset_name, + transform=transform, data_path=data_path) + test_ds = DomainClassificationDataset(source_test, target_test, data_attr, dataset_name, + transform=transform, data_path=data_path) + return train_ds, test_ds + +###################### +### TRAINING STUFF ### +###################### + +def get_classes_to_compare(num_classes, num, seed): + prng = np.random.RandomState(seed) + classes = [] + class_1, class_2 = None, None # for proper scope + for _ in range(num): + while True: + class_1, class_2 = prng.choice(num_classes, size=2, replace=False) + curr_pair = sorted([class_1, class_2]) + if curr_pair not in classes: + classes.append(curr_pair) + break + return classes + +def accuracy(output, target, topk=(1,)): + """Computes the accuracy over the k top predictions for the specified values of k""" + with torch.no_grad(): + maxk = max(topk) + batch_size = target.size(0) + + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + + res = [] + for k in topk: + correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True) + res.append((correct_k.mul_(100.0 / batch_size)).item()) + return res + +class AverageMeter(object): + """Computes and stores the average and current value""" + def __init__(self, name, fmt=':f'): + self.name = name + self.fmt = fmt + self.reset() + + def reset(self): + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + def __str__(self): + fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})' + return fmtstr.format(**self.__dict__) + + +class ProgressMeter(object): + def __init__(self, num_batches, meters, prefix=""): + self.batch_fmtstr = self._get_batch_fmtstr(num_batches) + self.meters = meters + self.prefix = prefix + + def display(self, batch): + entries = [self.prefix + self.batch_fmtstr.format(batch)] + entries += [str(meter) for meter in self.meters] + print('\t'.join(entries)) + + def _get_batch_fmtstr(self, num_batches): + num_digits = len(str(num_batches // 1)) + fmt = '{:' + str(num_digits) + 'd}' + return '[' + fmt + '/' + fmt.format(num_batches) + ']' diff --git a/unlabeled_extrapolation/datasets/domainnet.py b/unlabeled_extrapolation/datasets/domainnet.py new file mode 100644 index 0000000..04bb9b4 --- /dev/null +++ b/unlabeled_extrapolation/datasets/domainnet.py @@ -0,0 +1,99 @@ +from torch.utils.data import Dataset +import os +from PIL import Image + + +VALID_DOMAINS = [ + 'clipart', + 'infograph', + 'painting', + 'quickdraw', + 'real', + 'sketch' +] + +SENTRY_DOMAINS = [ + 'clipart', + 'painting', + 'real', + 'sketch' +] + +NUM_CLASSES_DICT = { + 'full': 345, + 'sentry': 40 +} + +VALID_SPLITS = ['train', 'test'] + +VALID_VERSIONS = ['full', 'sentry'] + +ROOT = '/u/scr/nlp/domainnet' +SENTRY_SPLITS_ROOT = '/u/scr/nlp/domainnet/SENTRY_splits' + + +def load_dataset(domains, split, version): + if len(domains) == 1 and domains[0] == 'all': + if version == 'sentry': + domains = SENTRY_DOMAINS + else: + domains = VALID_DOMAINS + + data = [] + for domain in domains: + if version == 'sentry': + idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') + else: + idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') + with open(idx_file, 'r') as f: + data += [line.split() for line in f] + return data + + +class DomainNet(Dataset): + def __init__(self, domain, split='train', root=ROOT, + transform=None, unlabeled=False, verbose=True, + version='sentry'): + super().__init__() + + if version not in VALID_VERSIONS: + raise ValueError(f'dataset version must be in {VALID_VERSIONS} but was {version}') + domain_list = domain.split(',') + for domain in domain_list: + if domain != 'all' and version == 'full' and domain not in VALID_DOMAINS: + raise ValueError(f'domain must be in {VALID_DOMAINS} but was {domain}') + if domain != 'all' and version == 'sentry' and domain not in SENTRY_DOMAINS: + raise ValueError(f'domain must be in {SENTRY_DOMAINS} but was {domain}') + if split not in VALID_SPLITS: + raise ValueError(f'split must be in {VALID_SPLITS} but was {split}') + self._root_data_dir = root + self._domain_list = domain_list + self._split = split + self._transform = transform + self._version = version + + self._unlabeled = unlabeled + self.data = load_dataset(domain_list, split, version) + self.means = [0.485, 0.456, 0.406] + self.stds = [0.228, 0.224, 0.225] + if verbose: + print(f'Loaded domains {", ".join(domain_list)}, split is {split}') + print(f'Total number of images: {len(self.data)}') + print(f'Total number of classes: {self.get_num_classes()}') + + def __len__(self): + return len(self.data) + + def __getitem__(self, idx): + path, y = self.data[idx] + x = Image.open(os.path.join(self._root_data_dir, path)) + x = x.convert('RGB') + if self._transform is not None: + x = self._transform(x) + # if self._unlabeled: + # return x, -1 + # else: + return x, int(y) + + def get_num_classes(self): + return len(set([self.data[idx][1] for idx in range(len(self.data))])) diff --git a/unlabeled_extrapolation/datasets/fmow.py b/unlabeled_extrapolation/datasets/fmow.py new file mode 100644 index 0000000..77b4a40 --- /dev/null +++ b/unlabeled_extrapolation/datasets/fmow.py @@ -0,0 +1,39 @@ + +from wilds import get_dataset +from wilds.common.data_loaders import get_train_loader + +import torch +from torch.utils.data import Dataset +import numpy as np + +# Mapping from continent names to region codes: +# {'Asia': 0, 'Europe': 1, 'Africa': 2, 'Americas': 3, 'Oceania': 4, 'Other': 5} + +class Fmow(Dataset): + + def __init__(self, root, regions, split='train', transform=None): + # Split can be train, id_val, id_test, val, test. + # regions is a lister of integers between 0 and 4 denoting the regions, don't use 'Other'. + # For fmow root is the directory that contains fmow (and other wilds datasets). + super().__init__() + super_dataset = get_dataset(dataset='fmow', download=False, root_dir=root) + self._subset = super_dataset.get_subset(split, transform=transform) + self._regions = regions + if 'all' not in self._regions: + super_indices = self._subset.indices + subset_metadata = self._subset.dataset.metadata_array[super_indices].numpy() + self._indices = np.argwhere([(a in regions) for a in subset_metadata[:, 0]])[:,0] + + def __getitem__(self, i): + if 'all' not in self._regions: + x, y, _ = self._subset[self._indices[i]] + else: + x, y, _ = self._subset[i] + return x, y + + def __len__(self) -> int: + if 'all' not in self._regions: + return len(self._indices) + else: + return len(self._subset) + diff --git a/unlabeled_extrapolation/datasets/imagenet.py b/unlabeled_extrapolation/datasets/imagenet.py new file mode 100644 index 0000000..b6fc6ff --- /dev/null +++ b/unlabeled_extrapolation/datasets/imagenet.py @@ -0,0 +1,55 @@ +# CIFAR-10.1 dataset, by Rebecca Roelofs and Ludwig Schmidt +# Copying the utils from there for convenience. + +import os +import pathlib +from PIL import Image + +import torch +from torch.utils.data import Dataset +import torchvision.datasets as datasets +import numpy as np + +# Map from ImageNet renditions indices to ImageNet indices. +r_indices = [1, 2, 4, 6, 8, 9, 11, 13, 22, 23, 26, 29, 31, 39, 47, 63, 71, 76, 79, 84, 90, 94, 96, 97, 99, 100, 105, 107, 113, 122, 125, 130, 132, 144, 145, 147, 148, 150, 151, 155, 160, 161, 162, 163, 171, 172, 178, 187, 195, 199, 203, 207, 208, 219, 231, 232, 234, 235, 242, 245, 247, 250, 251, 254, 259, 260, 263, 265, 267, 269, 276, 277, 281, 288, 289, 291, 292, 293, 296, 299, 301, 308, 309, 310, 311, 314, 315, 319, 323, 327, 330, 334, 335, 337, 338, 340, 341, 344, 347, 353, 355, 361, 362, 365, 366, 367, 368, 372, 388, 390, 393, 397, 401, 407, 413, 414, 425, 428, 430, 435, 437, 441, 447, 448, 457, 462, 463, 469, 470, 471, 472, 476, 483, 487, 515, 546, 555, 558, 570, 579, 583, 587, 593, 594, 596, 609, 613, 617, 621, 629, 637, 657, 658, 701, 717, 724, 763, 768, 774, 776, 779, 780, 787, 805, 812, 815, 820, 824, 833, 847, 852, 866, 875, 883, 889, 895, 907, 928, 931, 932, 933, 934, 936, 937, 943, 945, 947, 948, 949, 951, 953, 954, 957, 963, 965, 967, 980, 981, 983, 988] + +# Map from ImageNet-A indices to ImageNet indices. +a_indices = [6, 11, 13, 15, 17, 22, 23, 27, 30, 37, 39, 42, 47, 50, 57, 70, 71, 76, 79, 89, 90, 94, 96, 97, 99, 105, 107, 108, 110, 113, 124, 125, 130, 132, 143, 144, 150, 151, 207, 234, 235, 254, 277, 283, 287, 291, 295, 298, 301, 306, 307, 308, 309, 310, 311, 313, 314, 315, 317, 319, 323, 324, 326, 327, 330, 334, 335, 336, 347, 361, 363, 372, 378, 386, 397, 400, 401, 402, 404, 407, 411, 416, 417, 420, 425, 428, 430, 437, 438, 445, 456, 457, 461, 462, 470, 472, 483, 486, 488, 492, 496, 514, 516, 528, 530, 539, 542, 543, 549, 552, 557, 561, 562, 569, 572, 573, 575, 579, 589, 606, 607, 609, 614, 626, 627, 640, 641, 642, 643, 658, 668, 677, 682, 684, 687, 701, 704, 719, 736, 746, 749, 752, 758, 763, 765, 768, 773, 774, 776, 779, 780, 786, 792, 797, 802, 803, 804, 813, 815, 820, 823, 831, 833, 835, 839, 845, 847, 850, 859, 862, 870, 879, 880, 888, 890, 897, 900, 907, 913, 924, 932, 933, 934, 937, 943, 945, 947, 951, 954, 956, 957, 959, 971, 972, 980, 981, 984, 986, 987, 988] + +v2_indices = [0, 1, 10, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 11, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 12, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 13, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 14, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 15, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 16, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 17, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 18, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 19, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 2, 20, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 21, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 22, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 23, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 24, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 25, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 26, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 27, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 28, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 29, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 3, 30, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 31, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 32, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 33, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 34, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 35, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 36, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 37, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 38, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 39, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 4, 40, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 41, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 42, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 43, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 44, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 45, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 46, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 47, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 48, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 49, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 5, 50, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 51, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 52, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 53, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 54, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 55, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 56, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 57, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 58, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 59, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 6, 60, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 61, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 62, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 63, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 64, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 65, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 66, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 67, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 68, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 69, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 7, 70, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 71, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 72, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 73, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 74, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 75, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 76, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 77, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 78, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 79, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 8, 80, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 81, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 82, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 83, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 84, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 85, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 86, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 87, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 88, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 89, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 9, 90, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 91, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 92, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 93, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 94, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 95, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 96, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 97, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 98, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 99, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999] + +class ImageNet(Dataset): + + def __init__(self, root, split='train', num_examples=None, transform=None, seed=0): + super().__init__() + self.data = datasets.ImageFolder(root=root + '/' + split, transform=None) + self._split = split + self._num_examples = num_examples + self._transform = transform + if self._split in ['imagenet-r', 'renditions']: + self.valid_indices = r_indices + elif self._split == 'imagenet-a': + self.valid_indices = a_indices + if self._num_examples is not None: + if self._num_examples > len(self.data): + raise ValueError('num_examples can be at most the dataset size {len(self.data)}') + rng = np.random.RandomState(seed=seed) + self._data_indices = rng.permutation(len(self.data))[:num_examples] + + def __getitem__(self, i): + if self._num_examples is not None: + i = self._data_indices[i] + x, y = self.data[i] + x = x.convert('RGB') + if self._transform is not None: + x = self._transform(x) + if self._split == 'renditions' or self._split == 'imagenet-r': + y = r_indices[y] + elif self._split == 'imagenet-a': + y = a_indices[y] + elif self._split == 'v2' or self._split == 'imagenetv2-matched-frequency-format-val': + y = v2_indices[y] + return x, y + + def __len__(self) -> int: + return len(self.data) if self._num_examples is None else self._num_examples diff --git a/datasets/imnet_intersect_c10.py b/unlabeled_extrapolation/datasets/imnet_intersect_c10.py similarity index 100% rename from datasets/imnet_intersect_c10.py rename to unlabeled_extrapolation/datasets/imnet_intersect_c10.py diff --git a/unlabeled_extrapolation/datasets/landcover.py b/unlabeled_extrapolation/datasets/landcover.py new file mode 100644 index 0000000..2929a1f --- /dev/null +++ b/unlabeled_extrapolation/datasets/landcover.py @@ -0,0 +1,612 @@ +from pathlib import Path +import pickle +import numpy as np +import torch +from scipy.stats import rankdata +from scipy import signal +from torch.utils.data import Dataset +import re +from .range_dataset import RangeDataset +from unlabeled_extrapolation.utils.data_utils import get_split_idxs + +DATA_ROOT = 'timeseries_by_box_v2' +DATA_CACHE = 'landcover_data.pkl' + +CLASSNAMES = ['savannas', 'permanent_wetlands', 'woody_savannas', + 'deciduous_needleleaf_forests', 'permanent_snow_and_ice', + 'croplands', 'water_bodies', 'urban_and_built_up_lands', + 'open_shrublands','evergreen_broadleaf_forests', + 'closed_shrublands', 'barren', 'grasslands', + 'deciduous_broadleaf_forests', 'mixed_forests', + 'cropland_natural_vegetation_mosaics', + 'evergreen_needleleaf_forests'] + +TOP_LABELS = [0, 2, 5, 8, 9, 12] # most prevelant classes in South Hemisphere +top_class_colors = ['r', 'g', 'b', 'm', 'c', 'k'] + +africa_top_left = [38.277609, -18.170184] +africa_bottom_right = [-36.337048, 55.037262] + + +def filter_nans(domain_to_data): + ''' + Finds and removes any data points whose MODIS measurement has at least one + NaN. + Parameters + ---------- + domain_to_data : dict from domain => (MODIS, lat/lon, label, domain) tuple + ''' + num_domains = len(domain_to_data) + for i in range(num_domains): + data = domain_to_data[i][0] + nan_mask = ~np.any(np.isnan(data), axis=(1, 2)) # Rows w/o NaNs. + num_keys = len(domain_to_data[i]) + domain_data = [None] * num_keys # Use list since tuple immutable. + for j in range(num_keys): + domain_data[j] = domain_to_data[i][j] + + # Only apply mask to NumPy arrays. + if isinstance(domain_data[j], np.ndarray): + domain_data[j] = domain_data[j][nan_mask] + + domain_to_data[i] = tuple(domain_data) + + +def split_map(domain_to_data, shuffle_seed=None): + ''' + Quick helper method to split the domain_to_data map into its constituents. + Parameters + ---------- + domain_to_data : map from domain => (MODIS, lat/lons, labels, domains) + shuffle_seed : int, default None + If not None, the domains are shuffled before stacking together using + this random seed. + Returns + ------- + map from str => NumPy array + Each array is all of the data stacked together for all domains. + ''' + indices = range(len(domain_to_data)) + if isinstance(shuffle_seed, int): + rng = np.random.default_rng(shuffle_seed) + indices = rng.permutation(len(domain_to_data)) + + data = np.vstack([domain_to_data[i][0] for i in indices]) + lat_lon = np.vstack([domain_to_data[i][1] for i in indices]) + targets = np.hstack([domain_to_data[i][2] for i in indices]) + domains = np.hstack([[domain_to_data[i][3] + for _ in range(len(domain_to_data[i][2]))] + for i in indices]) + era5 = np.vstack([domain_to_data[i][4] for i in indices]) + return {'data': data, 'lat_lon': lat_lon, 'targets': targets, + 'domains': domains, 'era5': era5} + + +def load_from_file(root_path): + ''' + Loads Landcover dataset starting from the folder given by root_path. + Parameters + ---------- + root_path : str + Path to parent folder containing Landcover dataset. + Returns + ------- + domain_to_data : map from domain => (MODIS, lat/lon, labels, domains) + ''' + domain_to_data = {} + float_regex = re.compile(r'-?\d+\.-?\d+') # Extracts lat/lon from filename + classname_to_idx = {name: i for i, name in enumerate(CLASSNAMES)} + root = Path(root_path) + for domain_idx, box in enumerate(sorted(root.iterdir())): + domain_data = [] + domain_lat_lon = [] + domain_targets = [] + for cls in box.iterdir(): + classname = cls.stem + cls_idx = classname_to_idx[classname] + for x in cls.iterdir(): + if x.suffix != '.npy': + continue + lat, lon = float_regex.findall(x.name) + domain_lat_lon.append([float(lat), float(lon)]) + domain_data.append(np.load(str(x))) + domain_targets.append(cls_idx) + + domain_data = np.asarray(domain_data) + domain_lat_lon = np.asarray(domain_lat_lon) + domain_targets = np.asarray(domain_targets) + domain_to_data[domain_idx] = ( + domain_data, domain_lat_lon, domain_targets, domain_idx) + + return domain_to_data + + +def load_data(root=DATA_ROOT, use_cache=True, save_cache=False, + cache_path=DATA_CACHE, should_filter_nans=True, template_dataset=None): + ''' + Reads the Landcover dataset from the filesystem and returns a map of the + data. Can use a cached .pkl file for efficiency if desired. + Parameters + ---------- + root : str, default DATA_ROOT + Path to the folder containing Landcover dataset. + use_cache : bool, default True + Whether to use a cached form of the dataset. The cache_path + parameter must also be present. + save_cache : bool, default False + Whether to save the loaded data as a .pkl file for future use. The + cache_path parameter must also be present. + cache_path : str, default DATA_CACHE + Path to .pkl file for loading/saving the Landcover dataset. + Returns + ------- + dict + Map from domain => (MODIS, lat/lon, label, domain). + ''' + domain_to_data = {} + if use_cache: # Default use cache. + print(cache_path) + with open(cache_path, 'rb') as pkl_file: + domain_to_data = pickle.load(pkl_file) + else: + domain_to_data = load_from_file(root) + + if save_cache: # Default don't save. + with open(cache_path, 'wb') as pkl_file: + pickle.dump(domain_to_data, pkl_file) + + return domain_to_data + + +def add_NDVI(domain_to_data): + ''' + Computes the NDVI feature and appends it as a new axis to the existing + MODIS readings. May give a RuntimeWarning for division by zero, but any NaN + entries are replaced by zero before returning. + Parameters + ---------- + domain_to_data : map from domain => (MODIS, lat/lons, labels, domains) + ''' + for i in domain_to_data: + modis_data = domain_to_data[i][0] + red, nir = modis_data[:, 0, :], modis_data[:, 1, :] + ndvi = (nir - red) / np.maximum(nir + red, 1e-8) + ndvi = ndvi[:, np.newaxis, :] + # ndvi = np.expand_dims(np.nan_to_num(ndvi), axis=1) + domain_data = list(domain_to_data[i]) # Since tuples are immutable. + domain_data[0] = np.concatenate([modis_data, ndvi], axis=1) + domain_to_data[i] = tuple(domain_data) + + +def resample_ERA5(domain_to_data): + ''' + Upsamples the monthly data in ERA5 to 8-day frequency (12 -> 46) by Fourier method + Assumes ERA5 features are at index 4 + Parameters + ---------- + domain_to_data : map from domain => (MODIS, lat/lons, labels, domains) + ''' + for i in domain_to_data: + era5 = domain_to_data[i][4] + era5_resampled = signal.resample(era5, 46, axis=2) + + domain_data = list(domain_to_data[i]) # Since tuples are immutable. + domain_data[4] = era5_resampled + domain_to_data[i] = tuple(domain_data) + + +def add_ERA5(domain_to_data): + ''' + Adds features from ERA5 features, assumed to be at index 5 of the tuples + in domain_to_data with shape (num_examples, 12, num_features). + Parameters + ---------- + domain_to_data : map from domain => (MODIS, lat/lons, labels, domains) + ''' + for i in domain_to_data: + modis_data = domain_to_data[i][0] + era5 = domain_to_data[i][4] + + domain_data = list(domain_to_data[i]) # Since tuples are immutable. + domain_data[0] = np.concatenate([modis_data, era5], axis=1) + domain_to_data[i] = tuple(domain_data) + + +def filter_top_targets(data_map): + ''' + Filters out data points whose label does not belong to TOP_LABELS. + Parameters + ---------- + data_map : dict + Stores MODIS measurements, lat/lons, labels, and domain indices. + ''' + target_mask = np.in1d(data_map['targets'], TOP_LABELS) + for key in data_map.keys(): + data_map[key] = data_map[key][target_mask] + + # Normalize targets into range [0, num_classes - 1]. + data_map['targets'] = rankdata(data_map['targets'], method='dense') - 1 + + +def normalize_lat_lon(lat_lon): + ''' + Normalizes lat/lon coordinates to a point on the unit sphere. Can be moved + to a more general file if needed. + Parameters + ---------- + lat_lon : numpy.ndarray + NumPy array of size 2 storing the latitude and longitude. + Returns + ------- + numpy.ndarray + NumPy array of size 3 storing the (x, y, z) coordinates. + ''' + lat, lon = lat_lon + x = np.cos(lat) * np.cos(lon) + y = np.cos(lat) * np.sin(lon) + z = np.sin(lat) + return np.array([x, y, z]) + + +# Note: we modified some of the default arguments from the in-n-out code base. +# And e.g. added root and use_cache. +class Landcover(Dataset): + def __init__(self, root, cache_path=None, use_cache=True, eval_mode=False, num_train_domains=86, + split='train', should_filter_nans=True, transform=None, + target_transform=None, shuffle=False, shuffle_domains=True, + seed=None, include_NDVI=True, include_lat_lon=False, + include_ERA5=False, standardize=True, multitask=False, + target_lat_lon=False, unlabeled_prop=0, + pretrain=False, masked_pretrain=False, + use_unlabeled_id=False, use_unlabeled_ood=False, + unlabeled_targets_path=None, + standardize_unlabeled_sample_size=False, + **kwargs): + ''' + Constructor for a PyTorch Dataset class around the Landcover dataset. + Parameters + ---------- + eval_mode : bool, default False + Whether this a dataset for evaluation. + num_train_domains : int, default 86 + Number of train domains up to 86. + split : str, default 'train' + Describes how to split dataset (e.g., 'train', 'val', 'test'). If + this string starts with 'north' or 'south', then splitting by + hemisphere occurs. + should_filter_nans : bool, default True + Whether to filter NaN entries from the data map before returning + (see filter_nans() method). + transform: + input transformation + target_transform: + target transformation + shuffle : bool, default False + Whether to shuffle the entire dataset. A valid seed must be passed. + shuffle_domains : bool, default False + Whether to shuffle the order of domains before splitting. A valid + seed must be passed. + seed : int, default None + Random seed to use for consistent shuffling. + include_NDVI : bool, default False + Whether to calculate NDVI as an additional feature. + include_lat_lon : bool, default False + Whether to include the lat/lon for each measurement as a feature. + standardize : bool, default False + Whether to subtract mean/divide by STD when returning samples. + multitask : bool, default False + Whether to include the lat/lon for each measurement as a target. + target_lat_lon : bool, default False + Whether to use lat/lon as the target rather than the class label. + unlabeled_prop : float, default 0 + How much data from the entire dataset to keep as unlabeled data. + use_unlabeled : bool, default False + Whether to use the unlabeled data in training. + pretrain : bool, default False + whether to pretrain + masked_pretrain : bool, default False + whether to do masked pretraining + **kwargs: + Passed through to load_data() function. + ''' + self.split = split + self.eval_mode = eval_mode + self.transform = transform + self.target_transform = target_transform + self.include_lat_lon = include_lat_lon + self.standardize = standardize + self.multitask = multitask + self.pretrain = pretrain + self.masked_pretrain = masked_pretrain + self.target_lat_lon = target_lat_lon + self.use_unlabeled_all = (use_unlabeled_id and use_unlabeled_ood) + self.use_unlabeled = (use_unlabeled_id or use_unlabeled_ood) + self.standardize_unlabeled_sample_size = standardize_unlabeled_sample_size + + if multitask and target_lat_lon: + msg = 'Only one of "multitask" and "target_lat_lon" can be True!' + raise ValueError(msg) + + data_map = load_data(root=root, use_cache=use_cache, cache_path=cache_path, **kwargs) + self.num_domains = len(data_map) + if should_filter_nans: # Default filter. + filter_nans(data_map) + if include_NDVI: + add_NDVI(data_map) + + prepare_era5 = (include_ERA5 or multitask or pretrain) + if prepare_era5: + resample_ERA5(data_map) + + if include_ERA5: + add_ERA5(data_map) + + # Try splitting by hemispheres first. + split_by_hemi = False + domain_seed = seed if shuffle_domains else None + data_map = split_map(data_map, domain_seed) + filter_top_targets(data_map) + + # get ood_idxs + if split.startswith('north') or split.startswith('south'): + lat_mask = (data_map['lat_lon'][:, 0] < 0) + ood_idxs = np.where(lat_mask)[0] + split_by_hemi = True + elif split.startswith('nonafrica') or split.startswith('africa'): + inside_mask = np.asarray([(africa_top_left[0] >= lat) and (africa_bottom_right[0] <= lat) + and (africa_top_left[1] <= lon) and (africa_bottom_right[1] >= lon) + for lat,lon in data_map['lat_lon']]) + ood_idxs = np.where(inside_mask)[0] + else: + raise ValueError(f"Split {split} not supported") + + # split procedure: + # split 10% of data for evaluation + all_split_idxs = get_split_idxs( + unlabeled_proportion=unlabeled_prop, seed=seed, + ood_idxs=ood_idxs, total_len=len(data_map['data'])) + + data = data_map['data'] + lat_lon = data_map['lat_lon'] + targets = data_map['targets'] + domains = data_map['domains'] + era5 = data_map['era5'] + + ood_splits = {'africa', 'south', 'africa-train', 'africa-val'} + if split in ood_splits: + num_total = len(all_split_idxs['test2']) + mid = num_total // 2 + if split == 'africa-train': + idxs = all_split_idxs['test2'][:mid] + elif split == 'africa-val': + idxs = all_split_idxs['test2'][mid:] + else: + idxs = all_split_idxs['test2'] + elif split.endswith('train'): # 80/20 train/val split. + idxs = all_split_idxs['train'] + elif split.endswith('val'): + idxs = all_split_idxs['val'] + elif split.endswith('test'): + idxs = all_split_idxs['test'] + + # used when standardize_unlabeled_sample_size = True + min_sample_size = min(len(all_split_idxs['unlabeled_id']), len(all_split_idxs['unlabeled_ood'])) + + if self.use_unlabeled_all: + unlabeled_idxs = all_split_idxs['unlabeled'] + if self.standardize_unlabeled_sample_size: + # change to half - half id and ood + unl_id = all_split_idxs['unlabeled_id'][:min_sample_size // 2] + unl_ood = all_split_idxs['unlabeled_ood'][:min_sample_size // 2] + unlabeled_idxs = np.concatenate([unl_id, unl_ood]) + elif use_unlabeled_id: + unlabeled_idxs = all_split_idxs['unlabeled_id'] + if self.standardize_unlabeled_sample_size: + # change to min_sample_size + unlabeled_idxs = unlabeled_idxs[:min_sample_size] + elif use_unlabeled_ood: + unlabeled_idxs = all_split_idxs['unlabeled_ood'] + if self.standardize_unlabeled_sample_size: + # change to min_sample_size + unlabeled_idxs = unlabeled_idxs[:min_sample_size] + else: + unlabeled_idxs = [] + + self.data = data[idxs] + self.targets = targets[idxs] + self.lat_lon = lat_lon[idxs] + self.domain_labels = domains[idxs] + self.unlabeled_data = data[unlabeled_idxs] + self._unseen_unlabeled_targets = targets[unlabeled_idxs] + self.unlabeled_lat_lon = lat_lon[unlabeled_idxs] + self.unlabeled_domain_labels = domains[unlabeled_idxs] + + # assumes that unlabeled_targets_path uses the same split + self.unlabeled_targets_path = unlabeled_targets_path + if unlabeled_targets_path is not None: + self.unlabeled_targets = np.load(unlabeled_targets_path) + + if len(self.unlabeled_targets) != len(self.unlabeled_data): + raise ValueError("Length of pseudolabels does not match the unlabeled data length") + + if prepare_era5: + self.era5 = era5[idxs] + self.unlabeled_era5 = era5[unlabeled_idxs] + + if self.standardize: + # take mean over time and examples + # self.mean = self.data.mean(axis=(0, 2))[:, np.newaxis] + # self.std = self.data.std(axis=(0, 2))[:, np.newaxis] + # if prepare_era5: + # self.era5_mean = self.era5.mean(axis=(0, 2))[:, np.newaxis] + # self.era5_std = self.era5.std(axis=(0, 2))[:, np.newaxis] + + # all models use unlabeled data to normalize + + all_unlabeled_idxs = all_split_idxs['unlabeled'] + all_unlabeled_data = data[all_unlabeled_idxs] + concatted = np.concatenate([self.data, all_unlabeled_data], axis=0) + self.mean = concatted.mean(axis=(0, 2))[:, np.newaxis] + self.std = concatted.std(axis=(0, 2))[:, np.newaxis] + if prepare_era5: + concatted_era5 = np.concatenate([self.era5, self.unlabeled_era5], axis=0) + self.era5_mean = concatted_era5.mean(axis=(0, 2))[:, np.newaxis] + self.era5_std = concatted_era5.std(axis=(0, 2))[:, np.newaxis] + + # if self.use_unlabeled: + # # if there is unlabeled data, estimate mean and std using more data + # concatted = np.concatenate([self.data, self.unlabeled_data], axis=0) + # self.mean = concatted.mean(axis=(0, 2))[:, np.newaxis] + # self.std = concatted.std(axis=(0, 2))[:, np.newaxis] + # if prepare_era5: + # concatted_era5 = np.concatenate([self.era5, self.unlabeled_era5], axis=0) + # self.era5_mean = concatted_era5.mean(axis=(0, 2))[:, np.newaxis] + # self.era5_std = concatted_era5.std(axis=(0, 2))[:, np.newaxis] + + def get_unlabeled_dataset(self): + unlabeled_start_idx = len(self.data) + unlabeled_end_idx = len(self) + return RangeDataset(self, unlabeled_start_idx, unlabeled_end_idx) + + def __getitem__(self, index): + """ + Args: + index (int): Index + Returns: + tuple: (image, target) where target is index of the target class. + """ + labeled = True + metadata = {} + if index < len(self.data): + x, target = self.data[index], self.targets[index] + lat_lon = self.lat_lon[index] + if self.standardize: + x = (x - self.mean) / self.std + metadata['domain_label'] = self.domain_labels[index] + elif self.use_unlabeled: + labeled = False + # index -= len(self.data) + if self.multitask: + # pick a random unlabeled point + index = np.random.choice(len(self.unlabeled_data)) + else: + index = index - len(self.data) + + if self.unlabeled_targets_path is not None and not self.eval_mode: + x, target = self.unlabeled_data[index], self.unlabeled_targets[index] + else: + x, target = self.unlabeled_data[index], -100 + if self.standardize: + x = (x - self.mean) / self.std + lat_lon = self.unlabeled_lat_lon[index] + metadata['domain_label'] = self.unlabeled_domain_labels[index] + else: + raise IndexError('Dataset index out of range.') + + metadata['lat_lon'] = lat_lon + metadata['labeled'] = 1 if labeled else 0 + + if self.transform is not None: + x = self.transform(x) + + if self.target_transform is not None: + target = self.target_transform(target) + + if self.include_lat_lon: + # TODO is this correct below? + # lat_lon = self.lat_lon[index] + if self.standardize: + lat_lon = normalize_lat_lon(lat_lon) + # TODO does this stuff assume that x has been flattened by self.transform? + if isinstance(x, np.ndarray): + x = np.hstack([x, lat_lon]) + elif isinstance(x, torch.Tensor): + lat_lon = torch.from_numpy(lat_lon).to(x.dtype) + x = torch.cat([x, lat_lon]) + + if self.multitask or self.pretrain or self.masked_pretrain: + if labeled: + era5 = self.era5[index] + else: + era5 = self.unlabeled_era5[index] + if self.standardize: + era5 = (era5 - self.era5_mean) / self.era5_std + # we just use the non-time series part as output + era5_mean = np.mean(era5, axis=1) + era5_std = np.std(era5, axis=1) + era5_as_target = np.concatenate([era5_mean, era5_std], axis=0) + era5_as_target = torch.from_numpy(era5_as_target).float() + if self.multitask: + target = [target, era5_as_target] + elif self.masked_pretrain: + x_as_target = torch.cat([x.mean(1), x.std(1)]) + target = [-100, era5_as_target, x_as_target] + else: + target = era5_as_target + + if self.masked_pretrain: + use_idx = np.random.choice([1,2]) + metadata['use_idx'] = use_idx + # mask the input accordingly + if use_idx == 1: + x[8:, :] = 0 + elif use_idx == 2: + # mask the MODIS measurements + x[:8, :] = 0 + + # return {'data': x, 'target': target, 'domain_label': metadata} + x = torch.from_numpy(x).float() + return x, target + + def __len__(self): + length = len(self.data) + if self.use_unlabeled and not self.eval_mode: + if self.multitask: + # length += len(self.unlabeled_data) + # try to balance labeled and unlabeled + length *= 2 + length = len(self.data) + len(self.unlabeled_data) + return length + + def get_mean(self): + ''' + Returns the mean for this dataset. Useful for getting the mean of a + training set in order to standardize val and test sets. + Returns + ------- + self.mean, which is a float or numpy.ndarray. + ''' + return self.mean + + def set_mean(self, mean): + ''' + Sets the mean to use for standardization. Useful for setting the mean + of a val or test set from the mean of a training set. + Parameters + ---------- + mean : Union[float, numpy.ndarray] + Mean to subtract from data. + ''' + self.mean = mean + + def get_std(self): + ''' + Returns the std for this dataset. Useful for getting the std of a + training set in order to standardize val and test sets. + Returns + ------- + self.std, which is a float or numpy.ndarray. + ''' + return self.std + + def set_std(self, std): + ''' + Sets the std to use for standardization. Useful for setting the std of + a val or test set from the std of a training set. + Parameters + ---------- + std : Union[float, numpy.ndarray] + Std to divide by for standardization. + ''' + self.std = std + diff --git a/unlabeled_extrapolation/datasets/looping.py b/unlabeled_extrapolation/datasets/looping.py new file mode 100644 index 0000000..81f5cf4 --- /dev/null +++ b/unlabeled_extrapolation/datasets/looping.py @@ -0,0 +1,18 @@ +import numpy as np +from torch.utils.data import Dataset + +class LoopingDataset(Dataset): + """ + Dataset class to handle indices going out of bounds when training + """ + def __init__(self, dataset): + self.dataset = dataset + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, index): + if index >= len(self.dataset): + index = np.random.choice(len(self.dataset)) + item, label = self.dataset[index] + return item, label \ No newline at end of file diff --git a/unlabeled_extrapolation/datasets/range_dataset.py b/unlabeled_extrapolation/datasets/range_dataset.py new file mode 100644 index 0000000..f5f2855 --- /dev/null +++ b/unlabeled_extrapolation/datasets/range_dataset.py @@ -0,0 +1,22 @@ +from torch.utils.data import Dataset +import numpy as np + +class RangeDataset(Dataset): + ''' + Takes a range over another dataset + ''' + def __init__(self, dataset, start_idx, end_idx): + self.dataset = dataset + self.start_idx = start_idx + self.end_idx = end_idx + if start_idx >= len(self.dataset): + raise ValueError(f"start index must be less than length of dataset {len(self.dataset)}") + if end_idx > len(self.dataset): + raise ValueError(f"end index must be less than or equal to length of dataset {len(self.dataset)}") + + def __getitem__(self, idx): + idx += self.start_idx + return self.dataset[idx] + + def __len__(self): + return self.end_idx - self.start_idx diff --git a/datasets/stl_cifar_style.py b/unlabeled_extrapolation/datasets/stl_cifar_style.py similarity index 100% rename from datasets/stl_cifar_style.py rename to unlabeled_extrapolation/datasets/stl_cifar_style.py diff --git a/unlabeled_extrapolation/datasets/transforms.py b/unlabeled_extrapolation/datasets/transforms.py new file mode 100644 index 0000000..d6f2987 --- /dev/null +++ b/unlabeled_extrapolation/datasets/transforms.py @@ -0,0 +1,14 @@ +# Custom transforms. + +import torchvision.transforms + +class Resize(torchvision.transforms.Resize): + + def __init__(self, size, interpolation='bilinear'): + if interpolation == 'bilinear': + interp_arg = torchvision.transforms.InterpolationMode.BILINEAR + if interpolation == 'bicubic': + interp_arg = torchvision.transforms.InterpolationMode.BICUBIC + if interpolation == 'nearest': + interp_arg = torchvision.transforms.InterpolationMode.NEAREST + super().__init__(size=size, interpolation=interp_arg) diff --git a/unlabeled_extrapolation/extract_features.py b/unlabeled_extrapolation/extract_features.py new file mode 100644 index 0000000..2529b7e --- /dev/null +++ b/unlabeled_extrapolation/extract_features.py @@ -0,0 +1,202 @@ + +import argparse +import os +import sys +import torch +from torch import nn +import json +import numpy as np +from scipy.special import softmax +from sklearn.linear_model import LogisticRegression, SGDClassifier +from sklearn import preprocessing +import yaml +import quinine +import pickle +import socket + +import unlabeled_extrapolation.utils.utils as utils +from unlabeled_extrapolation.baseline_train import build_model +from unlabeled_extrapolation.baseline_train import get_test_loaders +from unlabeled_extrapolation.baseline_train import get_train_loader +from unlabeled_extrapolation.baseline_train import preprocess_config + + +def load_model(config_path, checkpoint_path, use_cuda=True): + with open(config_path) as f: + config = json.load(f) + net = utils.initialize(config['model']) + if use_cuda: + net = net.cuda() + net.new_last_layer(config['num_classes']) + utils.load_ckp(checkpoint_path, net) + return net + + +# Load datasets. +def load_test_dataset(config, idx, split_arg_name='split', split='val', batch_size=64, + num_workers=2): + test_config = config['test_datasets'][idx] + test_config['args'][split_arg_name] = split + print(test_config['name'], test_config) + if 'transforms' not in test_config: + test_config['transforms'] = config['default_test_transforms'] + test_data = utils.init_dataset(test_config) + test_loader = torch.utils.data.DataLoader( + test_data, batch_size=batch_size, + shuffle=False, num_workers=num_workers) + return test_data, test_loader + + +def get_features_labels(net, loader, use_cuda=True, train_mode=False, use_new_bn_stats=False): + if use_cuda: + net.cuda() + if use_new_bn_stats: + if train_mode: + raise ValueError('If use_new_bn_stats, then train_mode must be False.') + net.train() + for data in loader: + images, labels = data + if use_cuda: + images, labels = images.cuda(), labels.cuda() + net(images) + if train_mode: + net.train() + else: + net.eval() + features_list, labels_list = [], [] + with torch.no_grad(): + for data in loader: + images, labels = data + if use_cuda: + images, labels = images.cuda(), labels.cuda() + features = net.get_features(images) + features_list.append(features.detach().cpu().numpy()) + labels_list.append(labels.detach().cpu().numpy()) + features = np.squeeze(np.concatenate(features_list)) + labels = np.concatenate(labels_list) + return features, labels + + +def get_acc(preds, labels): + return np.mean(preds == labels) + + +def make_none_list(rs, cs): + return [[None] * cs for _ in range(rs)] + + +# Given a network how to get representations +def get_model_representations( + config_paths, checkpoint_paths, model_names, loader_names, loader_indices, split_arg_names, split_names, + batch_size=64, num_workers=2, use_cuda=True): + M, L = len(model_names), len(loader_names) + models = [] + if not type(config_paths) == list: + # If not a list, then just use the specified config_path and checkpoint path + if M > 1: + raise ValueError('Only specified one config path but > 1 models, see config_paths.') + with open(config_paths) as f: + config = json.load(f) + models.append(load_model(config_paths, checkpoint_paths, use_cuda=use_cuda)) + else: + with open(config_paths[0]) as f: + config = json.load(f) + for m in range(M): + models.append(load_model(config_paths[m], checkpoint_paths[m], use_cuda=use_cuda)) + + loaders = [] + for l in range(L): + _, loader = load_test_dataset( + config, loader_indices[l], split_arg_names[l], split_names[l], batch_size=batch_size, + num_workers=num_workers) + loaders.append(loader) + features, labels = make_none_list(M, L), make_none_list(M, L) + for m in range(M): + for l in range(L): + features[m][l], labels[m][l] = get_features_labels(models[m], loaders[l], + use_cuda=use_cuda) + + +def main(): + parser = argparse.ArgumentParser(description='Extract features from model.') + parser.add_argument('--config', type=str, metavar='c', + help='YAML config', required=True) + parser.add_argument('--save_path', type=str, metavar='s', + help='Path to save extracted features.', required=True) + parser.add_argument('--use_test_transforms_for_train', type=str, + help='no augmentations when training.', required=False, + default='False') + parser.add_argument('--train_mode', type=str, + help='Produce features in train mode', required=False, + default='False') + parser.add_argument('--use_new_bn_stats', type=str, + help='Update batchnorm stats before producing features.', required=False, + default='False') + args, unparsed = parser.parse_known_args() + config = quinine.Quinfig(args.config) + utils.update_config(unparsed, config) + + # Check for CUDA. + print(f'cuda is available: {torch.cuda.is_available()}') + print('Running on machine ', socket.gethostname()) + # print(config.loader_names) + + # This makes specifying certain things more convenient, e.g. don't have to specify a + # transform for every test datset. + preprocess_config(config, args.config) + # Get network and data loaders. + net = build_model(config) + test_loaders, _ = get_test_loaders(config, shuffle=False) + test_name_loaders = sorted(list(test_loaders.items())) + test_names = [k for k, v in test_name_loaders] + loader_names = [config.train_dataset.name] + test_names + if args.use_test_transforms_for_train == 'True': + print('Using test transform') + if 'default_test_transforms' not in config: + raise ValueError('Specify default test transforms if not using train transform.') + config['train_dataset']['transforms'] = config['default_test_transforms'] + print(config['train_dataset']) + elif args.use_test_transforms_for_train != 'False': + raise ValueError(f'use_test_transforms_for_train must be True or False, but was ' + f'{args.use_test_transforms_for_train}') + train_loader = get_train_loader(config) + + # Get features and labels. + train_mode = False + if args.train_mode == 'True': + train_mode = True + elif args.train_mode != 'False': + raise ValueError(f'train_mode must be True or False but was {args.train_mode}') + use_new_bn_stats = False + if args.use_new_bn_stats == 'True': + use_new_bn_stats = True + elif args.use_new_bn_stats != 'False': + raise ValueError(f'use_new_bn_stats must be True or False but was {args.use_new_bn_stats}') + train_features, train_labels = get_features_labels(net, train_loader, train_mode=train_mode, + use_new_bn_stats=use_new_bn_stats) + features, labels = [train_features], [train_labels] + for _, loader in test_name_loaders: + cur_features, cur_labels = get_features_labels(net, loader) + features.append(cur_features) + labels.append(cur_labels) + print(f'Processed {len(labels)} loaders') + print('Output shape for first dataset: ', features[0].shape, labels[0].shape) + + # features, labels = get_model_representations( + # config.config_paths, config.checkpoint_paths, config.model_names, + # config.loader_names, config.loader_indices, config.split_arg_names, + # config.split_names, config.batch_size, config.num_workers, config.use_cuda) + # print('output shapes: ', features[0][0].shape, labels[0][0].shape) + # print('save path: ', config.save_path) + + # Create save directory. + save_dir = os.path.dirname(args.save_path) + if not os.path.isdir(save_dir): + os.makedirs(save_dir) + pickle.dump((features, labels, loader_names), open(args.save_path, 'wb')) + print('Saved to: ', args.save_path) + + +if __name__ == "__main__": + main() + diff --git a/unlabeled_extrapolation/log_reg_sk.py b/unlabeled_extrapolation/log_reg_sk.py new file mode 100644 index 0000000..158bc84 --- /dev/null +++ b/unlabeled_extrapolation/log_reg_sk.py @@ -0,0 +1,153 @@ + +import argparse +import copy +from collections import OrderedDict +import os +import sys +import torch +from torch import nn +import models +import json +import numpy as np +from scipy.special import softmax +from sklearn.linear_model import LogisticRegression, SGDClassifier +from sklearn import preprocessing +import socket +import yaml +import quinine +import pickle +import pandas as pd + + +def get_acc(preds, labels): + return np.mean(preds == labels) + + +def normalize_features(features, normalize_index): + # normalize_index is the index to compute mean and std-dev + # TODO: consider changing to axis=0 + mean = np.mean(features[normalize_index]) + stddev = np.std(features[normalize_index]) + normalized_features = [] + for i in range(len(features)): + normalized_features.append((features[i] - mean) / stddev) + return normalized_features + + +def inv_normalize_weights(weights, intercept, features, normalize_index): + # mean = np.mean(features[normalize_index], axis=0) + # stddev = np.std(features[normalize_index], axis=0) + # new_weights = weights / stddev + # new_intercept = intercept - np.matmul(weights, mean / stddev) + # Other version + mean = np.mean(features[normalize_index]) + stddev = np.std(features[normalize_index]) + new_weights = weights / stddev + new_intercept = intercept - np.matmul(weights, mean / stddev * np.ones(weights.shape[1])) + return new_weights, new_intercept + + +def test_log_reg_warm_starting(features, labels, train_index, test_indices, val_index, loader_names, + num_cs=100, start_c=-7, end_c=2, max_iter=200, random_state=0): + L = len(features) + # TODO: figure out what this should be based on initial results. + Cs = np.logspace(start_c, end_c, num_cs) + clf = LogisticRegression(random_state=random_state, warm_start=True, max_iter=max_iter) + #.fit(features[m][train_index], labels[m][train_index]) + accs = [] + best_acc = -1.0 + best_clf, best_coef, best_intercept, best_i, best_c = None, None, None, None, None + for i, C in zip(range(len(Cs)), Cs): + clf.C = C + clf.fit(features[train_index], labels[train_index]) + cur_accs = [] + for l in test_indices: + cur_preds = clf.predict(features[l]) + # These names are selected to be consistent with fine-tuning results. + # If you update these, please update scripts/run_adaptation_experiments.py + if l == train_index: + key = 'train/acc' + else: + key = 'test_acc/' + loader_names[l] + cur_acc = get_acc(cur_preds, labels[l]) + # Don't multiply by 100, we multiply later in summarize_linprobe_results.py + cur_accs.append((key, cur_acc)) + if l == val_index and cur_acc > best_acc: + best_acc = cur_acc + best_clf = copy.deepcopy(clf) + best_coef = copy.deepcopy(clf.coef_) + best_intercept = copy.deepcopy(clf.intercept_) + best_i = i + best_c = C + print(cur_accs, flush=True) + result_row = OrderedDict([('C', C)] + cur_accs) + accs.append(result_row) + return best_clf, best_coef, best_intercept, best_c, best_i, accs + + +def main(): + parser = argparse.ArgumentParser(description='Train logistic regression model on features.') + parser.add_argument('--load_path', type=str, + help='Pickle file where features, labels are saved', required=True) + parser.add_argument('--results_save_path', type=str, + help='Path to save tsv results file', required=True) + parser.add_argument('--weights_save_path', type=str, + help='Path to save best logistic regression weights', required=True) + parser.add_argument('--test_indices', type=int, nargs='+', + help='Datasets to test on.', required=False) + parser.add_argument('--train_index', type=int, + help='Dataset to train on.', required=False) + parser.add_argument('--num_reg_values', type=int, + help='Number of regularization values to sweep over.', required=False) + parser.add_argument('--val_metric', type=str, + help='Metric to select regularization on.', required=True) + parser.add_argument('--seed', type=int, + help='Random seed.', required=False, default=0) + args, unparsed = parser.parse_known_args() + + print('Running on machine ', socket.gethostname()) + features, labels, loader_names = pickle.load(open(args.load_path, "rb")) + assert len(features) == len(labels) == len(loader_names) + if args.train_index is None: + args.train_index = 0 + if args.test_indices is None: + args.test_indices = list(range(0, len(loader_names))) + print("Training on: ", loader_names[args.train_index]) + print("Testing on: ") + for idx in args.test_indices: + print(loader_names[idx]) + # Find the index of dataset to tune logistic regression parameters on. + val_index = -1 + for i, name in zip(range(len(loader_names)), loader_names): + if name == args.val_metric or 'test_acc/' + name == args.val_metric: + val_index = i + break + if val_index == -1: + raise ValueError('Val metric not found in loaders: ', loader_names) + # Normalize featurs, this makes regularization hyperparameters more consistent across datasets. + normalized_features = normalize_features(features, args.train_index) + # Get the best classifier. + clf, coef, intercept, best_c, best_i, accs = test_log_reg_warm_starting( + normalized_features, labels, args.train_index, args.test_indices, val_index=val_index, + loader_names=loader_names, num_cs=args.num_reg_values, random_state=args.seed) + # Create parent folders for save paths if needed. + def make_parent_dir(save_path): + save_dir = os.path.dirname(save_path) + if not os.path.isdir(save_dir): + os.makedirs(save_dir) + make_parent_dir(args.results_save_path) + make_parent_dir(args.weights_save_path) + # Save accuracies and weights to files. + accs_df = pd.DataFrame(accs) + accs_df.to_csv(args.results_save_path, sep='\t') + new_coef, new_intercept = inv_normalize_weights(coef, intercept, features, + normalize_index=args.train_index) + pickle.dump((new_coef, new_intercept, best_c, best_i), open(args.weights_save_path, 'wb')) + # Just a redundancy check that the best classifier weights, and best weights, are the same. + assert(np.allclose(clf.coef_, coef)) + assert(np.allclose(clf.intercept_, intercept)) + + +if __name__ == "__main__": + main() + diff --git a/unlabeled_extrapolation/models/__init__.py b/unlabeled_extrapolation/models/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/unlabeled_extrapolation/models/__init__.py @@ -0,0 +1 @@ + diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py new file mode 100644 index 0000000..5a504e6 --- /dev/null +++ b/unlabeled_extrapolation/models/clip_model.py @@ -0,0 +1,113 @@ + +import clip +from collections import OrderedDict +import torchvision.models as models +from torchvision.models import resnet50 +import torch +from torch import nn +import os + +from . import model_utils + +from torchvision.transforms import Normalize + + +MODELS = {'RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16'} + +normalize_transform = Normalize( + mean=(0.48145466, 0.4578275, 0.40821073), + std=(0.26862954, 0.26130258, 0.27577711)) + + +def build_model_scratch(model_name, device): + model_path = clip.clip._download(clip.clip._MODELS[model_name], os.path.expanduser("~/.cache/clip")) + model = torch.jit.load(model_path, map_location="cpu").eval() + state_dict = model.state_dict() + + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks"))) + + model = clip.model.CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + clip.model.convert_weights(model) + return model.eval().to(device) + + +class ClipModel(nn.Module): + + def __init__(self, model_name, scratch=False): + # If scratch is True, then we randomly initialize weights. + super().__init__() + if model_name not in MODELS: + raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._device = "cuda" if torch.cuda.is_available() else "cpu" + # Note that model has both a language and vision part. + if scratch: + model = build_model_scratch(model_name, device=self._device) + else: + model, _ = clip.load(model_name, device=self._device) + self._model = model + self._model.visual.float() + self._classifier = None + + def forward(self, x): + features = self.get_features(x) + if self._classifier is None: + return features + return self._classifier(features) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + if self._classifier is not None: + for param in self._classifier.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + num_in_features = self._model.visual.output_dim + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) + + def add_probe(self, probe): + self._classifier = probe + + def get_last_layer(self): + return self._classifier + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self._classifier, coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + return self._model.encode_image(normalize_transform(x)) diff --git a/unlabeled_extrapolation/models/imnet_models.py b/unlabeled_extrapolation/models/imnet_models.py new file mode 100644 index 0000000..2dd491d --- /dev/null +++ b/unlabeled_extrapolation/models/imnet_models.py @@ -0,0 +1,70 @@ + +import torchvision +import torch +from torch import nn +from . import model_utils + + +class WildsVisionModel(nn.Module): + + def __init__(self, name, pretrained=False, checkpoint_path=None, num_classes=None): + super().__init__() + if name == 'wideresnet50': + constructor_name = 'wide_resnet50_2' + self._last_layer_name = 'fc' + elif name == 'densenet121': + constructor_name = name + self._last_layer_name = 'classifier' + elif name in ('resnet50', 'resnet34'): + constructor_name = name + self._last_layer_name = 'fc' + else: + raise ValueError(f'Torchvision model {name} not recognized') + constructor = getattr(torchvision.models, constructor_name) + # Create model. If pretrained and checkpoint_path is specified then we load a custom checkpoint + # not pytorch's imagenet pretrained model. + if checkpoint_path is not None and not(pretrained): + raise ValueError('If supplying checkpoint_path, set pretrained=True') + elif pretrained and checkpoint_path is None: + self._model = constructor(pretrained=True) + else: + self._model = constructor() + # If num_classes is specified, then initialize a new head for the model. + if num_classes is not None: + if type(num_classes) != int: + raise ValueError('num_classes should be an int.') + self.new_last_layer(num_classes) + # If checkpoint is specified, then load model from checkpoint + if checkpoint_path is not None: + assert(pretrained) + checkpoint = torch.load(checkpoint_path) + self._model.load_state_dict(checkpoint['algorithm'], strict=False) + + def forward(self, x): + return self._model(x) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + num_in_features = getattr(self._model, self._last_layer_name).in_features + last_layer = nn.Linear(num_in_features, num_classes) + setattr(self._model, self._last_layer_name, last_layer) + + def add_probe(self, probe): + setattr(self._model, self._last_layer_name, probe) + + def get_last_layer(self): + return getattr(self._model, self._last_layer_name) + + def set_last_layer(self, coef, intercept): + last_layer = getattr(self._model, self._last_layer_name) + model_utils.set_linear_layer(last_layer, coef, intercept) + + def get_feature_extractor(self): + return nn.Sequential(*list(self._model.children())[:-1]) + + def get_features(self, x): + return self.get_feature_extractor()(x) + diff --git a/models/imnet_resnet.py b/unlabeled_extrapolation/models/imnet_resnet.py similarity index 61% rename from models/imnet_resnet.py rename to unlabeled_extrapolation/models/imnet_resnet.py index 8a7f762..c2cc3f6 100644 --- a/models/imnet_resnet.py +++ b/unlabeled_extrapolation/models/imnet_resnet.py @@ -4,11 +4,20 @@ from torchvision.models import resnet50 import torch from torch import nn -from models import swav_resnet50 +from . import model_utils +from torchvision.transforms import Normalize +try: + from models import swav_resnet50 +except: + from . import swav_resnet50 PRETRAIN_STYLE = ['supervised', 'mocov2', 'swav', 'simclrv2'] +imnet_normalize_transform = Normalize( + mean=(0.485, 0.456, 0.406), + std=(0.228, 0.224, 0.225)) + def load_moco(checkpoint_path): checkpoint = torch.load(checkpoint_path, map_location="cpu") @@ -49,7 +58,7 @@ def load_swav(checkpoint_path): class ResNet50(nn.Module): - def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_path=None): + def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_path=None, normalize=False): super().__init__() if pretrain_style not in PRETRAIN_STYLE: raise ValueError( @@ -62,14 +71,31 @@ def __init__(self, pretrained=False, pretrain_style='supervised', checkpoint_pat raise NotImplementedError() elif not pretrained or pretrain_style == 'supervised': self._model = resnet50(pretrained=pretrained) + self._side_tuning = False + self._normalize = normalize def forward(self, x): + if self._side_tuning: + pretrained_reps = self.get_features(x) + side_reps = self._side_network.get_features(x) + print(pretrained_reps.shape, side_reps.shape) + return self._model.fc(pretrained_reps + side_reps) return self._model(x) def set_requires_grad(self, val): for param in self._model.parameters(): param.requires_grad = val + def enable_side_tuning(self): + self._side_tuning = True + # Freeze gradients for the original network. + self.set_requires_grad(val=False) + # Create the last layer again, so that parameters are not frozen. + self.new_last_layer(num_classes=self._model.fc.out_features) + # Add a side network, as per the side-tuning paper. + # In many of their experiments, this is also a ResNet-50 like the original network. + self._side_network = ResNet50() + def new_last_layer(self, num_classes): num_in_features = self._model.fc.in_features self._model.fc = nn.Linear(num_in_features, num_classes) @@ -77,3 +103,20 @@ def new_last_layer(self, num_classes): def add_probe(self, probe): self._model.fc = probe + def get_last_layer(self): + return self._model.fc + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self._model.fc, coef, intercept) + + def get_feature_extractor(self): + return nn.Sequential(*list(self._model.children())[:-1]) + + def get_features(self, x): + # Note: For side-tuning, this gives the original pretrained features. + # It's a big ambiguous what the 'features' are in that case. + if self._normalize: + x = imnet_normalize_transform(x) + features = self.get_feature_extractor()(x) + return torch.reshape(features, (features.shape[0], -1)) + diff --git a/unlabeled_extrapolation/models/innout_models.py b/unlabeled_extrapolation/models/innout_models.py new file mode 100644 index 0000000..74f0ee7 --- /dev/null +++ b/unlabeled_extrapolation/models/innout_models.py @@ -0,0 +1,344 @@ +from collections import OrderedDict + +import torch +from torch import nn +from torch.autograd import Variable +import numpy as np +import itertools + + +class CNN(nn.Module): + ''' + Generic CNN that can handle different image sizes + ''' + + def __init__(self, output_size, in_channels=3): + super().__init__() + self.output_size = output_size + self.in_channels = in_channels + + activ = nn.ReLU(True) + + self.feature_extractor = nn.Sequential(OrderedDict([ + ('conv1', nn.Conv2d(in_channels, 32, 5, padding=2)), + ('relu1', activ), + ('conv2', nn.Conv2d(32, 32, 3, padding=1)), + ('relu2', activ), + ('maxpool1', nn.MaxPool2d(2, 2)), + ('conv3', nn.Conv2d(32, 64, 3, padding=1)), + ('relu3', activ), + ('maxpool2', nn.MaxPool2d(2, 2)), + ('conv4', nn.Conv2d(64, 128, 3, padding=1)), + ('relu4', activ), + ('avgpool', nn.AdaptiveAvgPool2d((1, 1))), + ])) + + self.classifier = nn.Sequential(OrderedDict([ + ('fc1', nn.Linear(128, 1024)), + ('relu1', activ), + ('fc2', nn.Linear(1024, output_size)), + ])) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + + def forward(self, x): + features = self.feature_extractor(x) + logits = self.classifier(features.view(-1, 128)) + return logits + + +class MLPDropout(nn.Module): + ''' + A multilayer perception with ReLU activations and dropout layers. + ''' + def __init__(self, dims, output_dim, dropout_probs): + ''' + Constructor. + Parameters + ---------- + dims : list[int] + Specifies the input and hidden layer dimensions. + output_dim : int + Specifies the output dimension. + dropout_probs : list[float] + Specifies the dropout probability at each layer. The length of this + list must be equal to the length of dims. If the dropout + probability of a layer is zero, then the dropout layer is omitted + altogether. + ''' + if len(dims) != len(dropout_probs): + raise ValueError('len(dims) must equal len(dropout_probs)') + if len(dims) < 1: + raise ValueError('len(dims) must be at least 1') + if any(prob < 0 or prob > 1 for prob in dropout_probs): + raise ValueError('Dropout probabilities must be in [0, 1]') + + super(MLPDropout, self).__init__() + layers = [] + if dropout_probs[0] > 0: # Input dropout layer. + layers.append(('Dropout1', nn.Dropout(p=dropout_probs[0]))) + + for i in range(len(dims) - 1): + layers.append((f'Linear{i + 1}', nn.Linear(dims[i], dims[i + 1]))) + layers.append((f'ReLU{i + 1}', nn.ReLU())) + if dropout_probs[i + 1] > 0: + dropout = nn.Dropout(p=dropout_probs[i + 1]) + layers.append((f'Dropout{i + 2}', dropout)) + + layers.append((f'Linear{len(dims)}', nn.Linear(dims[-1], output_dim))) + self.model = nn.Sequential(OrderedDict(layers)) + + def forward(self, x): + return self.model(x) + + +class MLP(MLPDropout): + ''' + A multilayer perceptron with ReLU activations. + ''' + def __init__(self, dims, output_dim): + ''' + Constructor. + Parameters + ---------- + dims : List[int] + Specifies the input and hidden layer dimensions. + output_dim : int + Specifies the output dimension. + ''' + super(MLP, self).__init__(dims, output_dim, [0] * len(dims)) + + +class MultitaskModel(nn.Module): + ''' + A multilayer perceptron for learning multiple tasks simultaneously. + The model consists of pairs of fully connected and ReLU layers. + ''' + def __init__(self, feature_dim, task_dims, shared_layers, batch_norm=False, use_idx=None, + freeze_shared=False, dropout_prob=0.0): + ''' + Constructor. + Parameters + ---------- + shared_dims : List[int] + Defines the number and sizes of hidden layers that are shared + amongst the tasks. + task_dims : List[List[int]] + Defines the number and sizes of hidden layers for a variable number of tasks. + use_idx: int + Use only a certain head + freeze_shared: only make the heads trainable. + ''' + super().__init__() + self.use_idx = use_idx + self.shared_layers = shared_layers + self.freeze_shared = freeze_shared + self.task_layers = nn.ModuleList() + for i in range(len(task_dims)): + curr_task_layers = [] + linear = nn.Linear(feature_dim, task_dims[i][0]) + curr_task_layers.append((f'Task{i + 1}Linear{1}', linear)) + for j in range(1, len(task_dims[i])): + if batch_norm: + curr_task_layers.append((f'Task{i + 1}BN{j}', nn.BatchNorm1d(task_dims[i][j-1]))) + curr_task_layers.append((f'Task{i + 1}ReLU{j}', nn.ReLU())) + linear = nn.Linear(task_dims[i][j - 1], task_dims[i][j]) + curr_task_layers.append((f'Task{i + 1}Linear{j + 1}', linear)) + curr_task_sequential = nn.Sequential(OrderedDict(curr_task_layers)) + self.task_layers.append(curr_task_sequential) + + self.dropout_prob = dropout_prob + self.dropout = nn.Dropout(dropout_prob) + + def trainable_params(self): + if self.freeze_shared: + return itertools.chain(*[l.parameters() for l in self.task_layers]) + else: + return self.parameters() + + def forward(self, x): + if isinstance(x, list) and not self.training: + x = x[0] + + if isinstance(x, list): + intermed_outs = [self.shared_layers(xi) for xi in x] + if self.dropout_prob > 0.0: + intermed_outs = [self.dropout(out) for out in intermed_outs] + return [layer(intermed_out) for layer, intermed_out in zip(self.task_layers, intermed_outs)] + else: + shared_output = self.shared_layers(x) + if self.dropout_prob > 0.0: + shared_output = self.dropout(shared_output) + + if self.use_idx is not None: + return self.task_layers[self.use_idx](shared_output) + + if self.training: + return [layer(shared_output) for layer in self.task_layers] + else: # For eval, return first task output only. + return self.task_layers[0](shared_output) + + +class MLPMultitask(MultitaskModel): + ''' + A multilayer perceptron for learning multiple tasks simultaneously. + The model consists of pairs of fully connected and ReLU layers. + ''' + def __init__(self, shared_dims, task_dims, batch_norm=False, use_idx=None): + ''' + Constructor. + Parameters + ---------- + shared_dims : List[int] + Defines the number and sizes of hidden layers that are shared + amongst the tasks. + task_dims : List[List[int]] + Defines the number and sizes of hidden layers for a variable number + of tasks. + ''' + shared_layers = [] + for i in range(len(shared_dims) - 1): + linear = nn.Linear(shared_dims[i], shared_dims[i + 1]) + shared_layers.append((f'SharedLinear{i + 1}', linear)) + if batch_norm: + shared_layers.append((f'SharedBN{i + 1}', nn.BatchNorm1D(shared_dims[i+1]))) + shared_layers.append((f'SharedReLU{i + 1}', nn.ReLU())) + linear = nn.Linear(shared_dims[-1], shared_dims[-1]) + shared_layers.append((f'SharedLinearFinal', linear)) + shared_layers = nn.Sequential(OrderedDict(shared_layers)) + super().__init__(shared_dims[-1], task_dims, shared_layers, batch_norm=batch_norm, use_idx=use_idx) + +class CNN1DFeatureExtractor(nn.Module): + def __init__(self, in_channels, output_size=128, batch_norm=False): + super().__init__() + self.output_size = output_size + self.in_channels = in_channels + + activ = nn.ReLU(True) + + if batch_norm: + self.feature_extractor = nn.Sequential(OrderedDict([ + ('conv1', nn.Conv1d(in_channels, 32, 5, padding=2)), + ('bn1', nn.BatchNorm1d(32)), + ('relu1', activ), + ('conv2', nn.Conv1d(32, 32, 3, padding=1)), + ('bn2', nn.BatchNorm1d(32)), + ('relu2', activ), + ('maxpool1', nn.MaxPool1d(2, 2)), + ('conv3', nn.Conv1d(32, 64, 3, padding=1)), + ('bn3', nn.BatchNorm1d(64)), + ('relu3', activ), + ('maxpool2', nn.MaxPool1d(2, 2)), + ('conv4', nn.Conv1d(64, output_size, 3, padding=1)), + ('bn4', nn.BatchNorm1d(output_size)), + ('relu4', activ), + ('avgpool', nn.AdaptiveAvgPool1d(1)), + ])) + else: + self.feature_extractor = nn.Sequential(OrderedDict([ + ('conv1', nn.Conv1d(in_channels, 32, 5, padding=2)), + ('relu1', activ), + ('conv2', nn.Conv1d(32, 32, 3, padding=1)), + ('relu2', activ), + ('maxpool1', nn.MaxPool1d(2, 2)), + ('conv3', nn.Conv1d(32, 64, 3, padding=1)), + ('relu3', activ), + ('maxpool2', nn.MaxPool1d(2, 2)), + ('conv4', nn.Conv1d(64, output_size, 3, padding=1)), + ('relu4', activ), + ('avgpool', nn.AdaptiveAvgPool1d(1)), + ])) + + def forward(self, x): + features = self.feature_extractor(x).view(-1, self.output_size) + return features + + +class CNN1D(nn.Module): + ''' + CNN for time series classification + ''' + + def __init__(self, output_size, in_channels, batch_norm=False, dropout_prob=0.0, + checkpoint_path=None): + super().__init__() + self.in_channels = in_channels + self.dropout_prob = dropout_prob + self.activ = nn.ReLU(True) + self.feature_extractor = CNN1DFeatureExtractor(in_channels, output_size=128, + batch_norm=False) + self.probe_in_features = 128 + self.batch_norm = batch_norm + self.new_last_layer(output_size) + if checkpoint_path is not None: + checkpoint = torch.load(checkpoint_path) + compatible_state_dict = OrderedDict() + for k in checkpoint['state_dict']: + comp_k = k[k.find('.')+1:] + comp_k = 'feature_extractor' + comp_k[comp_k.find('.'):] + compatible_state_dict[comp_k] = checkpoint['state_dict'][k] + self.load_state_dict(compatible_state_dict, strict=False) + + + def forward(self, x): + features = self.feature_extractor(x) + if self.dropout_prob > 0.0: + features = nn.Dropout(self.dropout_prob)(features) + logits = self.classifier(features) + return logits + + def set_requires_grad(self, val): + for param in self.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if self.batch_norm: + self.classifier = nn.Sequential(OrderedDict([ + ('fc1', nn.Linear(self.probe_in_features, 1024)), + ('bn1', nn.BatchNorm1d(1024)), + ('relu1', self.activ), + ('fc2', nn.Linear(1024, num_classes)), + ])) + else: + self.classifier = nn.Sequential(OrderedDict([ + ('fc1', nn.Linear(self.probe_in_features, 1024)), + ('relu1', self.activ), + ('fc2', nn.Linear(1024, num_classes)), + ])) + + def add_probe(self, probe): + self.classifier = self._last_layer_name + + def get_last_layer(self): + return self.classifier + + def get_feature_extractor(self): + return self.feature_extractor + + def get_features(self, x): + return self.get_feature_extractor()(x) + + + +class CNN1DMultitask(MultitaskModel): + ''' + CNN1D with Multitask heads + ''' + def __init__(self, in_channels, task_dims, batch_norm=False, use_idx=None, dropout_prob=0.0): + ''' + Constructor. + Parameters + ---------- + shared_dims : List[int] + Defines the number and sizes of hidden layers that are shared + amongst the tasks. + task_dims : List[List[int]] + Defines the number and sizes of hidden layers for a variable number + of tasks. + ''' + feature_size = 128 + shared_layers = CNN1DFeatureExtractor(in_channels, output_size=feature_size, batch_norm=batch_norm) + super().__init__(feature_size, task_dims, shared_layers, batch_norm=batch_norm, use_idx=use_idx, dropout_prob=dropout_prob) + diff --git a/models/mlp.py b/unlabeled_extrapolation/models/mlp.py similarity index 100% rename from models/mlp.py rename to unlabeled_extrapolation/models/mlp.py diff --git a/unlabeled_extrapolation/models/model_utils.py b/unlabeled_extrapolation/models/model_utils.py new file mode 100644 index 0000000..c063e4f --- /dev/null +++ b/unlabeled_extrapolation/models/model_utils.py @@ -0,0 +1,12 @@ + +import torch +import torch.nn + +def set_linear_layer(layer, coef, intercept): + coef_tensor = torch.tensor(coef, dtype=layer.weight.dtype).cuda() + bias_tensor = torch.tensor(intercept, dtype=layer.bias.dtype).cuda() + coef_param = torch.nn.parameter.Parameter(coef_tensor) + bias_param = torch.nn.parameter.Parameter(bias_tensor) + layer.weight = coef_param + layer.bias = bias_param + diff --git a/models/resnet.py b/unlabeled_extrapolation/models/resnet.py similarity index 100% rename from models/resnet.py rename to unlabeled_extrapolation/models/resnet.py diff --git a/models/swav_resnet50.py b/unlabeled_extrapolation/models/swav_resnet50.py similarity index 100% rename from models/swav_resnet50.py rename to unlabeled_extrapolation/models/swav_resnet50.py diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py new file mode 100644 index 0000000..5408297 --- /dev/null +++ b/unlabeled_extrapolation/models/vit_model.py @@ -0,0 +1,60 @@ + +from collections import OrderedDict +import torchvision.models as models +from torchvision.models import resnet50 +import torch +from torch import nn +from . import model_utils + +from torchvision.transforms import Normalize + + +MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} + + +class VitModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + if model_name not in MODELS: + raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._device = "cuda" if torch.cuda.is_available() else "cpu" + # Note that model has both a language and vision part. + model = torch.hub.load('facebookresearch/dino:main', model_name) + if self._device == 'cuda': + model.cuda() + self._model = model + self._classifier = None + + def forward(self, x): + features = self.get_features(x) + if self._classifier is None: + return features + return self._classifier(features) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + if self._classifier is not None: + for param in self._classifier.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + num_in_features = self._model.norm.normalized_shape[0] + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) + + def add_probe(self, probe): + self._classifier = probe + + def get_last_layer(self): + return self._classifier + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self._classifier, coef, intercept) + + def get_feature_extractor(self): + return self._model + + def get_features(self, x): + return self._model(x) diff --git a/unlabeled_extrapolation/utils/__init__.py b/unlabeled_extrapolation/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/utils/accumulator.py b/unlabeled_extrapolation/utils/accumulator.py similarity index 100% rename from utils/accumulator.py rename to unlabeled_extrapolation/utils/accumulator.py diff --git a/unlabeled_extrapolation/utils/data_utils.py b/unlabeled_extrapolation/utils/data_utils.py new file mode 100644 index 0000000..e05cb74 --- /dev/null +++ b/unlabeled_extrapolation/utils/data_utils.py @@ -0,0 +1,91 @@ +import numpy as np + + +def create_data_splits(num_examples, val_proportion, test_proportion): + ''' + num_examples: int + ''' + if val_proportion + test_proportion >= 1.0: + raise ValueError("val_proportion and test_proportion add to more than 1") + + num_val = int(num_examples * val_proportion) + num_test = int(num_examples * test_proportion) + idxs = np.arange(num_examples) + np.random.shuffle(idxs) + val_idxs = idxs[:num_val] + test_idxs = idxs[num_val:num_val+num_test] + train_idxs = idxs[num_val+num_test:] + return train_idxs, val_idxs, test_idxs + + +def split_ood_idxs(idxs, ood_idxs): + ''' + Split idxs into two index arrays, in-domain and ood according to the indices in ood_idxs. + Args: + idxs: List[int] or ndarray[int] + list of indices that we want to split + ood_idxs: List[int] or ndarray[int] + list of indices of ood data, where indices are wrt to the full dataset + ''' + is_ood = (ood_idxs[np.searchsorted(ood_idxs, idxs)] == idxs) + ood_split_idxs = idxs[is_ood] + id_split_idxs = idxs[~is_ood] + return id_split_idxs, ood_split_idxs + + +def get_split_idxs(unlabeled_proportion, ood_idxs, total_len, seed=None): + ''' + Args: + unlabeled_proportion: float + float between [0, 1]. Proportion of training data to use as unlabeled + ood_idxs: List[int] or ndarray[int] + list of indices of ood data, where indices are wrt to the full dataset + (range(len(data))) + total_len: int + the total length of dataset (len(data)) + seed: Optional[int] + seed for splitting of the training data (not the eval data) + ''' + ood_idxs = np.sort(ood_idxs) + # augment with one more value larger or equal to total_len for + # searchsorted + ood_idxs = np.concatenate([ood_idxs, [total_len]]) + + # hardcoded seed for evaluation split + eval_split_seed = 15485863 + rng_state = np.random.get_state() + np.random.seed(eval_split_seed) + eval_len = int(total_len * 0.1) + all_idxs = np.arange(total_len) + np.random.shuffle(all_idxs) + eval_idxs = all_idxs[:eval_len] + noneval_idxs = all_idxs[eval_len:] + + # split eval_idxs into val/test/OOD + id_split_idxs, ood_split_idxs = split_ood_idxs(eval_idxs, ood_idxs) + non_ood_len = len(id_split_idxs) + val_split_idxs = id_split_idxs[:non_ood_len//2] + test_split_idxs = id_split_idxs[non_ood_len//2:] + np.random.set_state(rng_state) + + rng_state = np.random.get_state() + if seed is not None: + np.random.seed(seed) + unlabeled_len = int(len(noneval_idxs) * unlabeled_proportion) + unlabeled_split_idxs = noneval_idxs[:unlabeled_len] + train_split_idxs = noneval_idxs[unlabeled_len:] + # throw away the OOD from the train split + train_split_idxs, _ = split_ood_idxs(train_split_idxs, ood_idxs) + np.random.set_state(rng_state) + + # split the unlabeled into ID and OOD for convenience + unlabeled_idxs_id, unlabeled_idxs_ood = split_ood_idxs(unlabeled_split_idxs, ood_idxs) + + return {'train': train_split_idxs, + 'unlabeled': unlabeled_split_idxs, + 'unlabeled_id': unlabeled_idxs_id, + 'unlabeled_ood': unlabeled_idxs_ood, + 'val': val_split_idxs, + 'test': test_split_idxs, + 'test2': ood_split_idxs} + diff --git a/utils/merlin.py b/unlabeled_extrapolation/utils/merlin.py similarity index 100% rename from utils/merlin.py rename to unlabeled_extrapolation/utils/merlin.py diff --git a/unlabeled_extrapolation/utils/multi.py b/unlabeled_extrapolation/utils/multi.py new file mode 100644 index 0000000..382ae66 --- /dev/null +++ b/unlabeled_extrapolation/utils/multi.py @@ -0,0 +1,76 @@ +import torch +import torch.distributed as dist +import torch.multiprocessing as mp + +def spawn_processes(worker_fn, args, mpargs): + args.distributed = args.world_size > 1 or args.multiprocessing_distributed + ngpus_per_node = torch.cuda.device_count() + if args.multiprocessing_distributed: + # Since we have ngpus_per_node processes per node, the total world_size + # needs to be adjusted accordingly + args.world_size = ngpus_per_node * args.world_size + # Use torch.multiprocessing.spawn to launch distributed processes: the + # main_worker process function + mp.spawn(worker_fn, nprocs=ngpus_per_node, args=(ngpus_per_node, *mpargs)) + else: + # Simply call main_worker function + worker_fn(*(args.gpu, ngpus_per_node, *mpargs)) + +def init_proc_group(args, ngpus_per_node): + if args.multiprocessing_distributed: + # For multiprocessing distributed training, rank needs to be the + # global rank among all the processes + args.rank = args.rank * ngpus_per_node + args.gpu + dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, + world_size=args.world_size, rank=args.rank) + +def init_data_parallel(args, model, ngpus_per_node): + if args.distributed: + # For multiprocessing distributed, DistributedDataParallel constructor + # should always set the single device scope, otherwise, + # DistributedDataParallel will use all available devices. + if args.gpu is not None: + torch.cuda.set_device(args.gpu) + model = model.cuda(args.gpu) + # When using a single GPU per process and per + # DistributedDataParallel, we need to divide the batch size + # ourselves based on the total number of GPUs we have + args.batch_size = int(args.batch_size / ngpus_per_node) + args.workers = int((args.workers + ngpus_per_node - 1) / ngpus_per_node) + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])#, find_unused_parameters=True) + else: + model = model.cuda() + # DistributedDataParallel will divide and allocate batch_size to all + # available GPUs if device_ids are not set + model = torch.nn.parallel.DistributedDataParallel(model, find_unused_parameters=True) + elif args.gpu is not None: + torch.cuda.set_device(args.gpu) + model = model.cuda(args.gpu) + else: + model = torch.nn.DataParallel(model).cuda() + return model + +def calculate_coeff(covariances): + coeff = covariances ** (-2) # every element should have value bounded by sigma min/max + coeff = torch.sqrt(torch.sum(coeff, [1, 2, 3])) + return 1 / coeff + +def grad_norm_for_loss(model, loss, to_filter=None): + if to_filter is not None: + params = [p for name, p in model.named_parameters() if p.requires_grad and to_filter in name] + else: + params = [p for p in model.parameters() if p.requires_grad] + if len(params) == 0: + return 0 + model_grads = torch.autograd.grad( + loss, + params, + retain_graph=True, + create_graph=False, + only_inputs=True, + allow_unused=True) + # filter out grads from unused parameters + model_grads = [grad for grad in model_grads if grad is not None] + if len(model_grads) == 0: + return 0 + return torch.norm(torch.stack([torch.norm(m.detach()) for m in model_grads])).item() diff --git a/utils/utils.py b/unlabeled_extrapolation/utils/utils.py similarity index 99% rename from utils/utils.py rename to unlabeled_extrapolation/utils/utils.py index e62743d..e3d9c3a 100644 --- a/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -103,7 +103,7 @@ def setup_logging(log_dir, level=logging.DEBUG): logging.basicConfig( format='%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', datefmt='%Y-%m-%d:%H:%M:%S', level=level, - filename=log_dir+'/logs.txt') + filename=log_dir+'/logs.txt', force=True) def update_config(unparsed, config): From dad75b1e9b8ffef333afdc3ed6ec396e1119fd95 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 3 Apr 2022 22:45:10 -0700 Subject: [PATCH 034/197] Update README --- README.md | 87 +++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 71 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 0668202..a178f22 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,14 @@ -## Steps to run an experiment +Code for our ICLR (oral) paper: + +``` +Fine-Tuning can Distort Pretrained Features and Underperform Out-of-Distribution. +Ananya Kumar, Aditi Raghunathan, Robbie Jones, Tengyu Ma, Percy Liang. ICLR 2022. +``` + + +This repository is still being improved and will be updated without backwards compatibility for now. However, we are releasing the code by popular demand. + +## Setup and installation The first time you run this project, in the current directory, which contains README, create a virtualenv: ``` @@ -17,8 +27,62 @@ wandb login wandb on ``` -### Alternative: -Use the `eix-ue` conda env. Make sure you have this following code in your `.bashrc`: +## Running paper experiments (Slurm) + +The main experiments are in scripts/run_adaptation_experiments.py. For example, if you're on the Stanford NLP cluster, then you can run fine-tuning experiments on Living-17 as follows: + +``` +python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets living17 --model_name=resnet50 --partition=jag-standard +``` + +For other slurm clusters, you will need to modify the sbatch file "run_sbatch.sh" and change the partition accordingly. + +To run LP-FT experiments: + +``` +python scripts/run_adaptation_experiments.py --experiment=lp_then_ft_valmode_experiments --datasets living17 --model_name=resnet50 --partition=jag-standard +``` + +To run linear probing experiments: + +``` +python scripts/run_adaptation_experiments.py --experiment=linprobe_experiments --datasets living17 --model_name=resnet50 --partition=jag-standard +``` + +This code may look complicated, but it's written to simplify launching and managing a large number of jobs on a cluster. +For example, scripts/run_adaptation_experiments.py essentially contains the information to run every experiment in our paper, and exactly what information to track, on a Slurm cluster. + +After running the experiments, we have scripts that can produce a tsv file (e.g., which you can copy onto Excel or Google Sheets) with a detailed summary of all the runs (e.g., ID accuracy, OOD accuracy, when early stopping on a variety of metrics). For example, for Living17, run the following: + +``` +python scripts/summarize_all_results.py --results_dir_glob=logs/*living17* --val_metrics test_acc/source_val_living test_acc/target_val_living LAST --output_metrics epoch train/acc test_acc/source_val_living test_acc/target_val_living --output_file=tmp.tsv +``` + +The summary of all living17 runs will now be contained in tmp.tsv. + +## Configs + +The config files that specify hyperparameters are located in configs. Note that run_adaptation_experiments runs a sweep over these configs and therefore modifies the hyperparameters on configs. So consult run_adaptation_experiments.py for the hyperparameters used in the sweep. + +## Main code + +The main code for fine-tuning and LP-FT are in unlabeled_extrapolation/baseline_train.py. + +For linear probing, you can first extract model features using unlabeled_extrapolation/extract_features.py, and then train a logistic regression classifier using log_reg_sk.py. + +## Example run (without slurm) + +You can run the training code directly without slurm. + +``` +export PYTHONPATH="." +. env/bin/python experiments/baseline_train.py --config=configs/adaptation/living17.yaml \\ +--log_dir=logs/living17_lr_0.003 --project_name=living17 --group_name=living17 \\ +--run_nameliving17_lr_0.003 --optimizer.args.lr=0.003 +``` + +## Alternative setup (under construction): +Use the `ananya-ue` conda env. Make sure you have this following code in your `.bashrc`: ``` # >>> conda initialize >>> # !! Contents within this block are managed by 'conda init' !! @@ -36,10 +100,10 @@ unset __conda_setup # <<< conda initialize <<< ``` -## Configs +## Running code without slurm The main script is in `experiments/baseline_train.py`. The script requires a YAML config -file - an example is `configs/breeds_living_moco_probe.yaml`. +file - an example is `configs/adaptation/living17.yaml`. To dynamically change values of the config file with command line arguments, simply add new arguments of the form `--key=val` where the key can be any string of multiple keys separated by periods. This is to allow for changing @@ -73,19 +137,10 @@ We also inherit resnet50_transfer.yaml which specifies the scheduler, learning r - save_freq is how often we should save checkpoints besides the best checkpoint. For these experiments, the config sets this to a high number so we don't save checkpoints besides the initial, final, and best (saving disk space) - model.args.pretrained is True, indicating that we initialize from a supervised Resnet50 model (pre-trained on ImageNet labels) -## Example run - -``` -export PYTHONPATH="." -. env/bin/python experiments/baseline_train.py --config=configs/breeds_living_moco_probe.yaml \\ ---log_dir=logs/breeds_moco_linprobe_0.003 --project_name=breeds --group_name=breeds_moco_linprobe \\ ---run_name=breeds_moco_linprobe_0.003 --optimizer.args.lr=0.003 -``` - # A Lightweight Framework for Training Models -Adapted from Michael Xie's framework for "In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness", -https://arxiv.org/abs/2012.04550, Sang Michael Xie*, Ananya Kumar*, Robbie Jones*, Fereshte Khani, Tengyu Ma, Percy Liang. Thanks to contributions by Robbie Jones. +Adapted from the framework for "In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness", +https://arxiv.org/abs/2012.04550, Sang Michael Xie*, Ananya Kumar*, Robbie Jones*, Fereshte Khani, Tengyu Ma, Percy Liang. Benefits of framework: - Config files to specify dataset, model, augmentations, and other arguments, for better readability and reproducibility From cea5bb2ca428ffa75d009f57dce8488c83c4839f Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 3 Apr 2022 22:45:57 -0700 Subject: [PATCH 035/197] Update --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index a178f22..982b528 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -Code for our ICLR (oral) paper: +Code for our paper: ``` Fine-Tuning can Distort Pretrained Features and Underperform Out-of-Distribution. @@ -6,7 +6,8 @@ Ananya Kumar, Aditi Raghunathan, Robbie Jones, Tengyu Ma, Percy Liang. ICLR 2022 ``` -This repository is still being improved and will be updated without backwards compatibility for now. However, we are releasing the code by popular demand. +This paper will be published as an Oral at ICLR 2022. +This repository is still being improved and will be updated without backwards compatibility for now. ## Setup and installation From f6fb9760a16648bf2f32beb184ac485c7a527c64 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 3 Apr 2022 22:47:56 -0700 Subject: [PATCH 036/197] Update readme --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 982b528..a368cb9 100644 --- a/README.md +++ b/README.md @@ -101,7 +101,7 @@ unset __conda_setup # <<< conda initialize <<< ``` -## Running code without slurm +## Guide to our codebase The main script is in `experiments/baseline_train.py`. The script requires a YAML config file - an example is `configs/adaptation/living17.yaml`. @@ -117,14 +117,14 @@ This makes things modularized if you have configs for a few datasets, and config Try not to make these nested by more than one or two levels (A inherits B, B inherits C, C inherits D, etc) -If you base your config off of `configs/breeds_living_moco_probe.yaml` here are some important +If you base your config off of `configs/adaptation/living17.yaml` here are some important args to keep in mind: - finetune: If fine-tuning, this should be True. - linear_probe: If only training the last linear layer (freeze lower layers), set True, for full fine-tuning set False - use_net_val_mode: True if you want to keep the network in "val" mode while training. This should usually be True for linear probing, to turn off batchnorm. - num_classes: Specifies the number of classes in the new task you're fine-tuning on. -Notice that we inherit datasets_breeds_living.yaml, where we have: +Notice that we inherit datasets_living17.yaml, where we have: - A train dataset, which we initialize using args, including a transform - We specify a list of transforms, which are applied top to bottom - We have a list of test_datasets, and we evaluate performance on all of these. @@ -150,6 +150,8 @@ Benefits of framework: - Sets up and outputs to weights and biases - New: Saves the command line argument, and config, to run the experiment - New: Optionally, can save all the code used to run the experiment so you know exactly what you ran +- New: can early stop based on a variety of metrics +- New: track a variety of metrics, and produce a nice TSV with all the results Setup: - First install a virtualenv and activate it (instructions coming) From c0f512245cbe279ef542527f2f3e36d4ed6242d6 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 3 Apr 2022 22:49:11 -0700 Subject: [PATCH 037/197] Training -> fine-tuning --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a368cb9..d45e6bf 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,7 @@ For linear probing, you can first extract model features using unlabeled_extrapo ## Example run (without slurm) -You can run the training code directly without slurm. +You can run the fine-tuning code directly without slurm. ``` export PYTHONPATH="." From e1adf22ff301af1753b8830c11e7cb2dc2130a87 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 29 Jun 2022 22:33:46 -0700 Subject: [PATCH 038/197] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d45e6bf..d898b41 100644 --- a/README.md +++ b/README.md @@ -141,7 +141,7 @@ We also inherit resnet50_transfer.yaml which specifies the scheduler, learning r # A Lightweight Framework for Training Models Adapted from the framework for "In-N-Out: Pre-Training and Self-Training using Auxiliary Information for Out-of-Distribution Robustness", -https://arxiv.org/abs/2012.04550, Sang Michael Xie*, Ananya Kumar*, Robbie Jones*, Fereshte Khani, Tengyu Ma, Percy Liang. +https://arxiv.org/abs/2012.04550, Sang Michael Xie*, Ananya Kumar*, Robbie Jones*, Fereshte Khani, Tengyu Ma, Percy Liang. Thanks especially to Michael and Robbie! Benefits of framework: - Config files to specify dataset, model, augmentations, and other arguments, for better readability and reproducibility From 95439193e885653e31d76b3d176a958bd4443750 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 10 Jul 2022 15:44:11 -0700 Subject: [PATCH 039/197] Add mixup, tuning middle layers, waterbirds, worst group acc --- configs/datasets_waterbirds.yaml | 70 ++++++++++++++ configs/datasets_waterbirds_augs.yaml | 68 ++++++++++++++ configs/living17_mixup.yaml | 18 ++++ configs/waterbirds.yaml | 19 ++++ configs/waterbirds_augs.yaml | 19 ++++ scripts/run_adaptation_experiments.py | 98 +++++++++++++++++++- scripts/run_rtx_sbatch.sh | 4 +- scripts/run_sbatch.sh | 5 +- scripts/summarize_all_results.py | 2 +- scripts/summarize_results.py | 12 +++ unlabeled_extrapolation/baseline_train.py | 36 ++++++- unlabeled_extrapolation/datasets/wilds.py | 45 +++++++++ unlabeled_extrapolation/models/clip_model.py | 41 +++++++- 13 files changed, 426 insertions(+), 11 deletions(-) create mode 100644 configs/datasets_waterbirds.yaml create mode 100644 configs/datasets_waterbirds_augs.yaml create mode 100644 configs/living17_mixup.yaml create mode 100644 configs/waterbirds.yaml create mode 100644 configs/waterbirds_augs.yaml create mode 100644 unlabeled_extrapolation/datasets/wilds.py diff --git a/configs/datasets_waterbirds.yaml b/configs/datasets_waterbirds.yaml new file mode 100644 index 0000000..7f73908 --- /dev/null +++ b/configs/datasets_waterbirds.yaml @@ -0,0 +1,70 @@ + +root_prefix: '/u/scr/nlp/' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'val' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'val' + - name: 'landbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 0, 0] + - name: 'landbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 1, 0] + - name: 'waterbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 0, 0] + - name: 'waterbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 1, 0] + +early_stop_dataset_names: + - 'val' + diff --git a/configs/datasets_waterbirds_augs.yaml b/configs/datasets_waterbirds_augs.yaml new file mode 100644 index 0000000..f416a8a --- /dev/null +++ b/configs/datasets_waterbirds_augs.yaml @@ -0,0 +1,68 @@ + +root_prefix: '/u/scr/nlp/' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'val' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'val' + - name: 'landbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 0, 0] + - name: 'landbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 1, 0] + - name: 'waterbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 0, 0] + - name: 'waterbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 1, 0] + +early_stop_dataset_names: + - 'val' + diff --git a/configs/living17_mixup.yaml b/configs/living17_mixup.yaml new file mode 100644 index 0000000..f25a047 --- /dev/null +++ b/configs/living17_mixup.yaml @@ -0,0 +1,18 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_living17.yaml + +num_classes: 17 +epochs: &epochs 20 +use_mixup: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + diff --git a/configs/waterbirds.yaml b/configs/waterbirds.yaml new file mode 100644 index 0000000..007751b --- /dev/null +++ b/configs/waterbirds.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 64 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/waterbirds_augs.yaml b/configs/waterbirds_augs.yaml new file mode 100644 index 0000000..4d21fb8 --- /dev/null +++ b/configs/waterbirds_augs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds_augs.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 64 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 3c753fd..14ddf79 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -463,6 +463,21 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_eval.yaml') +living17_mixup = Dataset( + name='living17_mixup', + val_metric='test_acc/source_val_living', + secondary_val_metrics=['test_acc/target_val_living', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/source_val_living', + 'test_acc/target_val_living'], + config_rel_path='adaptation/living17_mixup.yaml', + bundles=['imagenet'], + slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_dir='/scr/biggest/', + eval_config_rel_path='adaptation/living17_mixup_eval.yaml') + celeba = Dataset( name='celeba', val_metric='test_acc/val', @@ -478,6 +493,41 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/celeba_eval.yaml') +waterbirds = Dataset( + name='waterbirds', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_eval.yaml') + +waterbirds_augs = Dataset( + name='waterbirds_augs', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_augs.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_augs_eval.yaml') + + living17_noaugs = Dataset( name='living17_noaugs', val_metric='test_acc/source_val_living', @@ -662,6 +712,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): names_to_datasets = { 'living17': living17, 'living17_nonorm': living17_nonorm, + 'living17_mixup': living17_mixup, 'entity30': entity30, 'imagenet': imagenet, 'imagenet_augs': imagenet_augs, @@ -672,6 +723,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'fmow_all': fmow_all, 'living17_noaugs': living17_noaugs, 'celeba': celeba, + 'waterbirds': waterbirds, # This dataset doesn't normalize. + 'waterbirds_augs': waterbirds_augs, # This data doesn't normalize. # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } @@ -768,6 +821,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +clip_vit_l14 = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-L/14', + }, + bundles=[] +) + scratch_vit_b16_clipstyle = Model( kwargs={ 'classname': 'models.clip_model.ClipModel', @@ -777,6 +838,15 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +scratch_vit_l14_clipstyle = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-L/14', + 'args.scratch': True, + }, + bundles=[] +) + dino_vit_b16 = Model( kwargs={ 'classname': 'models.vit_model.VitModel', @@ -813,6 +883,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'mocotp_fmow_resnet50': mocotp_fmow_resnet50, 'clip_resnet50': clip_resnet50, 'clip_vit_b16': clip_vit_b16, + 'clip_vit_l14': clip_vit_l14, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'landcover_baseline': landcover_baseline, @@ -938,7 +1009,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False): + imagenet_lp_ft_phase2=False, mixup_sweep=False): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -950,6 +1021,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] + if 'waterbirds' in args.datasets or 'waterbirds_augs' in args.datasets: + sweep_lrs += [1e-5] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -982,10 +1055,15 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn # Set hyperparameters if args.only_one_run: # TODO: how to choose which one to run? 1e-3 does well in practice. - hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs[0]) + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) # TODO: remove this? num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. + elif mixup_sweep: + lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) + # TODO: add 1.0 to this as well. + mixup_alpha_hypers = range_hyper('mixup_alpha', [0.5]) + hyperparams_list = product_dict_lists(lr_hypers, mixup_alpha_hypers) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) if side_tune: @@ -994,6 +1072,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'no_augmentation': True}) if val_mode: hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) + if args.freeze_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) + adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1036,6 +1118,11 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) +def fine_tuning_mixup_sweep_experiments(args, num_replications=3): + fine_tuning_experiments(args, num_replications=num_replications, + mixup_sweep=True) + + def ft_imnet_lp_ft_phase_2_experiments(args, num_replications=3): fine_tuning_experiments(args, num_replications=num_replications, imagenet_lp_ft_phase2=True) @@ -1135,6 +1222,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) if val_mode: hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) + if args.freeze_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) + adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) if args.no_replications: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1234,6 +1325,7 @@ def main(args): 'side_tune_val_mode_experiments': side_tune_val_mode_experiments, 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, 'ft_imnet_lp_ft_phase_2_val_mode_experiments': ft_imnet_lp_ft_phase_2_val_mode_experiments, + 'fine_tuning_mixup_sweep_experiments': fine_tuning_mixup_sweep_experiments, } if args.experiment in experiment_to_fns: experiment_to_fns[args.experiment](args) @@ -1294,6 +1386,8 @@ def fill_platform_specific_default_args(args): help='Datasets to test on (if unspecified, run on all).', required=False) parser.add_argument('--model_name', type=str, default='resnet50', # This is moco resnet. help='Model to use', required=False) + parser.add_argument('--freeze_bottom_k', type=int, required=False, default=None, + help='Freeze bottom k layers (if not specified, don\'t freeze)') parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index 60f26df..1261db3 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -3,11 +3,11 @@ #SBATCH --gres=gpu:1 #SBATCH --cpus-per-task=4 #SBATCH --mem=24G -#SBATCH --exclude=jagupard[10-27] +#SBATCH --exclude=jagupard[10-25] # Print execute commands in the log. set -x -conda_env=`whoami`-ue +conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 6dc58be..13211ed 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -2,13 +2,14 @@ #SBATCH --nodes=1 #SBATCH --gres=gpu:1 #SBATCH --cpus-per-task=4 +#SBATCH --partition=jag-standard #SBATCH --mem=16G -#SBATCH --exclude=jagupard[15,18] +#SBATCH --exclude=jagupard[14,15,18] # #SBATCH --exclude=jagupard[14,17,18,20] # Print execute commands in the log. set -x -conda_env=`whoami`-ue +conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index a27058d..07c08b5 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -73,7 +73,7 @@ def get_all_results(val_metric, dir_paths, output_metrics): args = parser.parse_args() # Get all folders satisfying glob. dir_paths = glob.glob(args.results_dir_glob, recursive=False) - dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path] + dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] output = '' for val_metric in args.val_metrics: results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index c73b1f8..c7d6db8 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -22,6 +22,18 @@ def get_parent_folder(file_path): def get_result(file_path, val_metric, output_metrics, take_max=True): df = pd.read_csv(file_path, sep='\t') + # The user probably wants us to output the val metric! + if val_metric not in output_metrics and val_metric != 'LAST': + output_metrics += val_metric + # If needed, compute the worst among all the test_accs. + # That is, if the user is selecting for this metric or wants it displayed. + # I guess val_metric == 'WORST' is redundant given the previous line which will + # add it to output_metrics, but just keeping it here in case I fiddle around with + # the previous line later. + if val_metric == 'WORST' or 'WORST' in output_metrics: + test_acc_column_names = [s for s in df.columns if 'test_acc' in s] + worst_accs = df[test_acc_column_names].min(axis=1) + df['WORST'] = worst_accs if val_metric is not None and val_metric != 'LAST': if val_metric not in df: raise ValueError(f'{val_metric} column not in {file_path}') diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 60061fa..b9633ac 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -25,7 +25,7 @@ from unlabeled_extrapolation.models import resnet from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils - +from timm.data.mixup import Mixup log_level = logging.INFO @@ -149,11 +149,15 @@ def build_model(config): # If fine-tune, re-initialize the last layer. finetune = 'finetune' in config and config['finetune'] linear_probe = 'linear_probe' in config and config['linear_probe'] + freeze_bottom_k = 'freeze_bottom_k' in config batch_norm = 'batchnorm_ft' in config and config['batchnorm_ft'] side_tune = 'side_tune' in config and config['side_tune'] def count_parameters(model, trainable): return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) if finetune or linear_probe or batch_norm or side_tune: + if freeze_bottom_k: + # Currently only implemented for some models (including CLIP ViTs). + net.freeze_bottom_k(config['freeze_bottom_k']) if linear_probe: logging.info('linear probing, freezing bottom layers.') # If unspecified, we set use_net_val_mode = True for linear-probing. @@ -183,6 +187,18 @@ def count_parameters(model, trainable): config['linear_probe_checkpoint_path'] != ''): linprobe_path = config['linear_probe_checkpoint_path'] coef, intercept, best_c, best_i = pickle.load(open(linprobe_path, "rb")) + if coef.shape[0] == 1: + # For binary classification, sklearn returns a 1-d weight + # vector. So we convert it into a 2D vector with the same + # logits. To see this conversion, notice that if I have a + # binary weight vector w, the output is \sigma(w^T x) + # = e^(w^T x) / (1 + e^(w^T x)). On the other hand, + # if I have weight vector [w/2, -w/2], and I use softmax + # I get e^(w^T x / 2) / (e^(w^T x / 2) + e^(-w^T x / 2) + # and multiplying num / denom by e^(w^T x / 2) + # we get the same expression as above. + coef = np.concatenate((-coef/2, coef/2), axis=0) + intercept = np.array([-intercept[0]/2, intercept[0]/2]) if 'normalize_lp' in config and config['normalize_lp']: logging.info("Normalizing linear probe std-dev") saved_stddev = np.std(coef) @@ -248,6 +264,14 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ if 'model_loss' in config: loss_dict['train/model_loss'] = Accumulator() num_examples = 0 + if 'use_mixup' in config and config['use_mixup']: + logging.info('Using mixup') + # Hack for older versions of torch. Use KL-div loss instead of cross-entropy, + # because mixup produces soft labels. + if 'mixup_alpha' in config: + mixup = Mixup(num_classes=config['num_classes'], mixup_alpha=config['mixup_alpha']) + else: + mixup = Mixup(num_classes=config['num_classes']) for i, data in enumerate(train_loader, 0): if 'use_net_val_mode' in config and config['use_net_val_mode']: net.eval() @@ -257,6 +281,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ if config['use_cuda']: data = utils.to_device(data, device) inputs, labels = data + if 'use_mixup' in config and config['use_mixup']: + inputs, labels = mixup(inputs, labels) optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) @@ -267,7 +293,11 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss += l2sp_loss _, train_preds = torch.max(outputs.data, axis=1) loss_dict['train/loss'].add_value(loss.tolist()) - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + if 'use_mixup' in config and config['use_mixup']: + _, max_labels = torch.max(labels.data, axis=1) + loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) + else: + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) opt_loss.backward() @@ -516,7 +546,7 @@ def update_test_transform_args_configs(config): raise ValueError('Must either specify default_test_transforms ' 'or a transform for each test dataset') test_dataset_config['transforms'] = config['default_test_transforms'] - if config['default_test_args'] is not None: + if 'default_test_args' in config and config['default_test_args'] is not None: for default_test_arg in config['default_test_args']: if default_test_arg not in test_dataset_config['args']: test_dataset_config['args'][default_test_arg] = config['default_test_args'][default_test_arg] diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py new file mode 100644 index 0000000..32679b2 --- /dev/null +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -0,0 +1,45 @@ + +from wilds import get_dataset + +import torch +from torch.utils.data import Dataset +import numpy as np + +class WILDS(Dataset): + + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False): + # Split can be train, id_val, id_test, val, test. + super().__init__() + full_dataset = get_dataset(dataset=dataset_name, download=download, root_dir=root) + dataset = full_dataset.get_subset(split, transform=None) + self._transform = transform + self._dataset = dataset + self._indices = None + self._meta_selector = None + self._return_meta = return_meta + if meta_selector is not None: + self._meta_selector = tuple(meta_selector) + super_indices = self._dataset.indices + subset_metadata = self._dataset.dataset.metadata_array[super_indices].numpy() + mask = np.all(subset_metadata == np.array(meta_selector), axis=-1) + # For some reason the indices is 2d (each index is in its own list), so need [:. 0] below. + self._indices = np.argwhere(mask)[:, 0] + + + def __getitem__(self, i): + if self._indices is None: + x, y, z = self._dataset[i] + else: + x, y, z = self._dataset[self._indices[i]] + assert(tuple(z) == self._meta_selector) + x = x.convert('RGB') + x = self._transform(x) + if self._return_meta: + return x, y, z + return x, y + + def __len__(self) -> int: + if self._indices is not None: + return len(self._indices) + return len(self._dataset) + diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 5a504e6..1fd8ad6 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -12,7 +12,8 @@ from torchvision.transforms import Normalize -MODELS = {'RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16'} +MODELS = {'RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16', + 'ViT-L/14', 'ViT-L/14@336px'} normalize_transform = Normalize( mean=(0.48145466, 0.4578275, 0.40821073), @@ -62,6 +63,11 @@ def build_model_scratch(model_name, device): return model.eval().to(device) +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + class ClipModel(nn.Module): def __init__(self, model_name, scratch=False): @@ -75,6 +81,7 @@ def __init__(self, model_name, scratch=False): model = build_model_scratch(model_name, device=self._device) else: model, _ = clip.load(model_name, device=self._device) + self._model_name = model_name self._model = model self._model.visual.float() self._classifier = None @@ -92,6 +99,38 @@ def set_requires_grad(self, val): for param in self._classifier.parameters(): param.requires_grad = val + def freeze_bottom_k(self, k): + if self._model_name in {'ViT-B/32', 'ViT-B/16', + 'ViT-L/14', 'ViT-L/14@336px'}: + if k > 0: + set_requires_grad(self._model.visual.conv1, False) + if k > 1: + set_requires_grad(self._model.visual.ln_pre, False) + if k > 2: + resblocks = self._model.visual.transformer.resblocks + n_freeze_transformers = min(k-2, len(resblocks)) + for i in range(n_freeze_transformers): + set_requires_grad(resblocks[i], False) + if k-2 > len(resblocks): + set_requires_grad(self._model.visual.ln_post, False) + elif self._model_name in {'RN50'}: + visual = self._model.visual + if k > 0: + set_requires_grad(visual.conv1, False) + set_requires_grad(visual.conv2, False) + set_requires_grad(visual.conv3, False) + set_requires_grad(visual.bn1, False) + set_requires_grad(visual.bn2, False) + set_requires_grad(visual.bn3, False) + layers = [visual.layer1, visual.layer2, visual.layer3, visual.layer3, + visual.attnpool] + if k > 1: + n_freeze_upper = min(k-1, len(layers)) + for i in range(n_freeze_upper): + set_requires_grad(layers[i], False) + else: + raise NotImplementedError + def new_last_layer(self, num_classes): num_in_features = self._model.visual.output_dim self._classifier = nn.Linear(num_in_features, num_classes) From e62a38f16b41a56a9bde3899387e1da66faa7a93 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 13 Jul 2022 19:27:38 -0700 Subject: [PATCH 040/197] Add support for unlocking all layers and full fine-tuning after a certain epoch. --- scripts/run_adaptation_experiments.py | 8 +++++++- unlabeled_extrapolation/baseline_train.py | 19 +++++++++++++++++-- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 14ddf79..1f3f2ae 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1076,6 +1076,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.full_ft_epoch is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) + adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1387,7 +1391,9 @@ def fill_platform_specific_default_args(args): parser.add_argument('--model_name', type=str, default='resnet50', # This is moco resnet. help='Model to use', required=False) parser.add_argument('--freeze_bottom_k', type=int, required=False, default=None, - help='Freeze bottom k layers (if not specified, don\'t freeze)') + help='Freeze bottom k layers (if not specified, don\'t freeze).') + parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, + help='At what epoch should we unfreeze all weights and fine-tune.') parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index b9633ac..9b53be9 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -144,6 +144,10 @@ def get_train_loader(config, shuffle=True): return train_loader +def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) + + def build_model(config): net = utils.initialize(config['model']) # If fine-tune, re-initialize the last layer. @@ -152,8 +156,6 @@ def build_model(config): freeze_bottom_k = 'freeze_bottom_k' in config batch_norm = 'batchnorm_ft' in config and config['batchnorm_ft'] side_tune = 'side_tune' in config and config['side_tune'] - def count_parameters(model, trainable): - return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) if finetune or linear_probe or batch_norm or side_tune: if freeze_bottom_k: # Currently only implemented for some models (including CLIP ViTs). @@ -249,6 +251,11 @@ def get_param_weights_counts(net, detach): return weight_dict, count_dict +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial): # Returns a dictionary with epoch, train/loss and train/acc. @@ -425,6 +432,14 @@ def main(config, log_dir, checkpoints_dir): if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): os.remove(prev_ckp_path) prev_ckp_path = checkpoints_dir / cur_ckp_filename + # User might specify an epoch for us to fully fine-tune the model. + if "full_ft_epoch" in config and config["full_ft_epoch"] is not None: + if epoch == config["full_ft_epoch"]: + set_requires_grad(net, True) + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + assert(num_trainable_params == num_params) + logging.info(f'Full FT {num_trainable_params} of {num_params} parameters.') # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, From e85c42d33c2a6e7db4b2c693f87759d88032f936 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 9 Aug 2022 00:25:25 +0000 Subject: [PATCH 041/197] Add print command option --- scripts/run_adaptation_experiments.py | 41 ++++++++++++++------------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 3c753fd..1e07682 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -13,7 +13,7 @@ def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): output_path = args.output_dir + '/' + job_name - sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name + sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name slurm_cmd = f'sbatch --partition={args.partition} --job-name={job_name} --output={output_path} ' +\ f'--mail-type=END,FAIL --mail-user={args.mail_user} ' deps = filter(lambda s: str(s) != '-1', deps) @@ -48,6 +48,8 @@ def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=' def run_job(cmd, job_name, args, deps=[]): if args.codalab: return run_codalab(cmd, job_name, args, deps=deps) + elif args.print_command: + print(cmd + '\n') else: return run_sbatch(cmd, job_name, args, deps=deps) @@ -136,10 +138,10 @@ def hyperparams_to_str(hyperparams, item_sep='_', key_value_sep='-', ignore_name sorted_hyperparams = sorted(hyperparams.items()) return item_sep.join([str(k) + key_value_sep + str(v) for k, v in sorted_hyperparams if k not in ignore_name_hypers]) - + def get_group_name(adapt_name, dataset_name, model_name): return adapt_name+'_'+dataset_name+'_'+model_name - + def get_job_name(adapt_name, dataset_name, model_name, hyperparams): """Get the name for a run.""" hyperparams_str = hyperparams_to_str(hyperparams) @@ -147,7 +149,7 @@ def get_job_name(adapt_name, dataset_name, model_name, hyperparams): def group_run_to_log_path(group_name, run_name, args): return args.log_dir + '/' + group_name + '/' + run_name - + def get_run_dir_path(adapt_name, dataset_name, model_name, hyperparams, args): """Get path to directory for a specific run (method + dataset + hyperparameters).""" hyperparams_str = hyperparams_to_str(hyperparams) @@ -156,7 +158,7 @@ def get_run_dir_path(adapt_name, dataset_name, model_name, hyperparams, args): else: group_dir_path = get_group_dir_path(adapt_name, dataset_name, model_name) return group_dir_path + '/ '+ hyperparams_str + '/' - + def get_group_dir_path(adapt_name, dataset_name, model_name, args): """Get path to directory for all runs for an adaptation method + model on a dataset.""" if args.codalab: @@ -164,7 +166,7 @@ def get_group_dir_path(adapt_name, dataset_name, model_name, args): else: group_name = get_group_name(adapt_name, dataset_name, model_name) return args.log_dir + '/'+ group_name + '/' - + def get_config_path(args, config_rel_path): return args.config_dir + '/' + config_rel_path @@ -247,7 +249,7 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] # Job id of -1 means we didn't run the job because it's already run. if job_id != -1: sweep_ids.append(job_id) - return sweep_ids + return sweep_ids def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replications, @@ -268,7 +270,7 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati # Job id of -1 means we didn't run the job because it's already run. if job_id != -1: sweep_ids.append(job_id) - return sweep_ids + return sweep_ids def adaptation_replication(adapt_name, dataset, model, num_replications, args, deps=[], @@ -335,7 +337,7 @@ def linprobe_run(args, job_name, model, seed, config_path, features_save_path, r if os.path.isfile(features_save_path) and not(rerun): cmd = log_reg_cmd else: - cmd = extract_cmd + ' && ' + log_reg_cmd + cmd = extract_cmd + ' && ' + log_reg_cmd if os.path.isfile(results_save_path) and not(rerun): return -1 return run_job(cmd, job_name, args, deps=deps) @@ -402,7 +404,7 @@ def get_summarize_cmd(dir_path, val_metric, secondary_val_metrics, output_metric kwargs['max_num'] = max_num code_path = args.scripts_dir + '/' + summarize_script_name return get_python_cmd(code_path, args.python_path, kwargs=kwargs, args=args) - + def summarize_run(dir_path, job_name, val_metric, secondary_val_metrics, output_metrics, args, deps): """Run a job to summarize all the results in dir_path according to specified metrics.""" @@ -447,7 +449,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', 'eval_config_rel_path']) - + living17 = Dataset( name='living17', val_metric='test_acc/source_val_living', @@ -784,7 +786,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): }, bundles=[] ) - + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -825,27 +827,27 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): def union_dicts(d1, d2): return dict(d1, **d2) - + def zip_dict_lists(dlist1, dlist2): dlist = [] assert(len(dlist1) == len(dlist2)) for i in range(len(dlist1)): dlist.append(union_dicts(dlist1[i], dlist2[i])) return dlist - + def product_dict_lists(dlist1, dlist2): dlist = [] for i in range(len(dlist1)): for j in range(len(dlist2)): dlist.append(union_dicts(dlist1[i], dlist2[j])) return dlist - + def range_hyper(name, values): dlist = [] for value in values: dlist.append({name: value}) return dlist - + # Append more_hyperparams to every hyperparams in hyperparams_list def append_to_each(hyperparams_list, more_hyperparams): return [union_dicts(d, more_hyperparams) for d in hyperparams_list] @@ -1105,15 +1107,15 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u def linprobe_experiments_no_aug(args, num_replications=3): - linprobe_experiments(args, num_replications=num_replications, aug=False) + linprobe_experiments(args, num_replications=num_replications, aug=False) def linprobe_experiments_trainmode(args, num_replications=3): - linprobe_experiments(args, num_replications=num_replications, train_mode=True) + linprobe_experiments(args, num_replications=num_replications, train_mode=True) def linprobe_experiments_usenewbnstats(args, num_replications=3): - linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) + linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False): @@ -1264,6 +1266,7 @@ def fill_platform_specific_default_args(args): help='Number of epochs to run job for.') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', help='(Slurm only) What priority to use.') From c172641dc40e278abb704295678d3f5f00be495b Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 8 Aug 2022 17:44:46 -0700 Subject: [PATCH 042/197] Add no norm waterbirds. --- scripts/run_adaptation_experiments.py | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 1f3f2ae..c8a24b9 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -510,6 +510,23 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_norm = Dataset( + name='waterbirds_norm', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_norm.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_norm_eval.yaml') + waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', @@ -724,7 +741,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. - 'waterbirds_augs': waterbirds_augs, # This data doesn't normalize. + 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. + 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } @@ -1021,7 +1039,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if 'waterbirds' in args.datasets or 'waterbirds_augs' in args.datasets: + if ('waterbirds' in args.datasets or 'waterbirds_augs' in args.datasets or + 'waterbirds_norm' in args.datasets): sweep_lrs += [1e-5] if side_tune: adapt_name += '_side_tune' @@ -1031,7 +1050,9 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] elif val_mode: adapt_name += '_valmode' - if 'imagenet' not in args.datasets and 'imagenet_augs' not in args.datasets: + if ('waterbirds' not in args.datasets and 'waterbirds_augs' not in args.datasets and + 'waterbirds_norm' not in args.datasets and + 'imagenet' not in args.datasets and 'imagenet_augs' not in args.datasets): sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] if no_augmentation: adapt_name += '_no_augmentation' From 8aac7ee0de11f1c88a6ee3c344f6b707407d4847 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 8 Aug 2022 17:46:17 -0700 Subject: [PATCH 043/197] Updates. --- .gitignore | 3 + .../{ => adaptation}/datasets_waterbirds.yaml | 0 .../datasets_waterbirds_augs.yaml | 0 .../adaptation/datasets_waterbirds_norm.yaml | 80 +++++++++++++++++++ configs/{ => adaptation}/waterbirds.yaml | 0 configs/{ => adaptation}/waterbirds_augs.yaml | 0 configs/adaptation/waterbirds_norm.yaml | 19 +++++ unlabeled_extrapolation/baseline_train.py | 1 + unlabeled_extrapolation/models/vit_model.py | 13 +++ 9 files changed, 116 insertions(+) rename configs/{ => adaptation}/datasets_waterbirds.yaml (100%) rename configs/{ => adaptation}/datasets_waterbirds_augs.yaml (100%) create mode 100644 configs/adaptation/datasets_waterbirds_norm.yaml rename configs/{ => adaptation}/waterbirds.yaml (100%) rename configs/{ => adaptation}/waterbirds_augs.yaml (100%) create mode 100644 configs/adaptation/waterbirds_norm.yaml diff --git a/.gitignore b/.gitignore index a4ef01b..91c9254 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +**tmp.tsv** +**slurm_outputs** +**outdated** *.pyc *.swp logs/* diff --git a/configs/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml similarity index 100% rename from configs/datasets_waterbirds.yaml rename to configs/adaptation/datasets_waterbirds.yaml diff --git a/configs/datasets_waterbirds_augs.yaml b/configs/adaptation/datasets_waterbirds_augs.yaml similarity index 100% rename from configs/datasets_waterbirds_augs.yaml rename to configs/adaptation/datasets_waterbirds_augs.yaml diff --git a/configs/adaptation/datasets_waterbirds_norm.yaml b/configs/adaptation/datasets_waterbirds_norm.yaml new file mode 100644 index 0000000..02097eb --- /dev/null +++ b/configs/adaptation/datasets_waterbirds_norm.yaml @@ -0,0 +1,80 @@ + +root_prefix: '/u/scr/nlp/' + +# The train and test transforms are taken from the Swav fine-tuning script. +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + - classname: torchvision.transforms.Normalize + args: + mean: [0.485, 0.456, 0.406] + std: [0.228, 0.224, 0.225] + + +test_datasets: + - name: 'val' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'val' + - name: 'landbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 0, 0] + - name: 'landbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [0, 1, 0] + - name: 'waterbg-landbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 0, 0] + - name: 'waterbg-waterbird-test' + classname: datasets.wilds.WILDS + args: + root: '/wilds/data/' + dataset_name: 'waterbirds' + split: 'test' + meta_selector: [1, 1, 0] + +early_stop_dataset_names: + - 'val' + diff --git a/configs/waterbirds.yaml b/configs/adaptation/waterbirds.yaml similarity index 100% rename from configs/waterbirds.yaml rename to configs/adaptation/waterbirds.yaml diff --git a/configs/waterbirds_augs.yaml b/configs/adaptation/waterbirds_augs.yaml similarity index 100% rename from configs/waterbirds_augs.yaml rename to configs/adaptation/waterbirds_augs.yaml diff --git a/configs/adaptation/waterbirds_norm.yaml b/configs/adaptation/waterbirds_norm.yaml new file mode 100644 index 0000000..ec91eb9 --- /dev/null +++ b/configs/adaptation/waterbirds_norm.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds_norm.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 64 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 9b53be9..19e63e0 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -697,4 +697,5 @@ def setup(): new_checkpoints_dir = log_dir + '/checkpoints' logging.info('Copying from %s to %s', checkpoints_dir, new_checkpoints_dir) shutil.copytree(checkpoints_dir, new_checkpoints_dir) + os.system('rm -r pymp*') diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 5408297..15c4cea 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -12,6 +12,11 @@ MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + class VitModel(nn.Module): def __init__(self, model_name): @@ -32,6 +37,14 @@ def forward(self, x): return features return self._classifier(features) + def freeze_bottom_k(self, k): + patch_embed = self._model.patch_embed + layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. + layers += list(self._model.blocks) + layers += [self._classifier] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + def set_requires_grad(self, val): for param in self._model.parameters(): param.requires_grad = val From 308d87a92e85bd434600efced3235c894e44ca60 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 9 Aug 2022 01:43:35 +0000 Subject: [PATCH 044/197] Get waterbirds working on sandbox. --- configs/adaptation/datasets_waterbirds.yaml | 1 + configs/adaptation/waterbirds.yaml | 2 +- setup.py | 12 +++++++----- unlabeled_extrapolation/utils/utils.py | 7 ++++++- 4 files changed, 15 insertions(+), 7 deletions(-) diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 7f73908..55e2911 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -9,6 +9,7 @@ train_dataset: root: 'wilds/data/' dataset_name: 'waterbirds' split: 'train' + download: 'true' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize args: diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 007751b..7fc66b7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 64 +batch_size: 32 save_no_checkpoints: True model: diff --git a/setup.py b/setup.py index 73bcdf9..1bc9128 100755 --- a/setup.py +++ b/setup.py @@ -10,8 +10,8 @@ install_requires=[ 'matplotlib', 'numpy', - 'torch==1.8.1+cu111', - 'torchvision==0.9.1+cu111', + 'torch', + 'torchvision', 'tqdm', 'requests', 'wandb', @@ -29,9 +29,11 @@ 'opencv-python', 'robustness', 'networkx', - 'cvxpy', + # 'cvxpy', 'pytorch-lightning-bolts', 'ftfy', - 'regex', + 'regex', + 'timm', + 'wilds', ]) -# Make sure to also install clip using pip install git+https://github.com/openai/CLIP.git \ No newline at end of file +# Make sure to also install clip using pip install git+https://github.com/openai/CLIP.git diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index e3d9c3a..069fd92 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -100,10 +100,15 @@ def load_ckp(checkpoint_fpath, model, optimizer=None, scheduler=None, reset_opti def setup_logging(log_dir, level=logging.DEBUG): + for handler in logging.root.handlers[:]: + logging.root.removeHandler(handler) + logging.getLogger().setLevel(logging.INFO) + logger = logging.getLogger('') + logger.handlers = [] logging.basicConfig( format='%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', datefmt='%Y-%m-%d:%H:%M:%S', level=level, - filename=log_dir+'/logs.txt', force=True) + filename=log_dir+'/logs.txt') def update_config(unparsed, config): From df51eea1ce09e623e83c75ecbe520887eed278ce Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 9 Aug 2022 01:43:35 +0000 Subject: [PATCH 045/197] Get waterbirds working on sandbox. --- configs/adaptation/datasets_waterbirds.yaml | 1 + configs/adaptation/waterbirds.yaml | 2 +- setup.py | 12 +++++++----- unlabeled_extrapolation/utils/utils.py | 7 ++++++- 4 files changed, 15 insertions(+), 7 deletions(-) diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 7f73908..55e2911 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -9,6 +9,7 @@ train_dataset: root: 'wilds/data/' dataset_name: 'waterbirds' split: 'train' + download: 'true' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize args: diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 007751b..7fc66b7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 64 +batch_size: 32 save_no_checkpoints: True model: diff --git a/setup.py b/setup.py index 73bcdf9..1bc9128 100755 --- a/setup.py +++ b/setup.py @@ -10,8 +10,8 @@ install_requires=[ 'matplotlib', 'numpy', - 'torch==1.8.1+cu111', - 'torchvision==0.9.1+cu111', + 'torch', + 'torchvision', 'tqdm', 'requests', 'wandb', @@ -29,9 +29,11 @@ 'opencv-python', 'robustness', 'networkx', - 'cvxpy', + # 'cvxpy', 'pytorch-lightning-bolts', 'ftfy', - 'regex', + 'regex', + 'timm', + 'wilds', ]) -# Make sure to also install clip using pip install git+https://github.com/openai/CLIP.git \ No newline at end of file +# Make sure to also install clip using pip install git+https://github.com/openai/CLIP.git diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index e3d9c3a..069fd92 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -100,10 +100,15 @@ def load_ckp(checkpoint_fpath, model, optimizer=None, scheduler=None, reset_opti def setup_logging(log_dir, level=logging.DEBUG): + for handler in logging.root.handlers[:]: + logging.root.removeHandler(handler) + logging.getLogger().setLevel(logging.INFO) + logger = logging.getLogger('') + logger.handlers = [] logging.basicConfig( format='%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', datefmt='%Y-%m-%d:%H:%M:%S', level=level, - filename=log_dir+'/logs.txt', force=True) + filename=log_dir+'/logs.txt') def update_config(unparsed, config): From 2873b32c128301c3d0a4193176cdad29d334642f Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 10 Aug 2022 20:54:33 +0000 Subject: [PATCH 046/197] Add waterbirds background prediction task. --- scripts/waterbirds_examples.ipynb | 131 ++++++++++++++++++++++ unlabeled_extrapolation/datasets/wilds.py | 8 +- 2 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 scripts/waterbirds_examples.ipynb diff --git a/scripts/waterbirds_examples.ipynb b/scripts/waterbirds_examples.ipynb new file mode 100644 index 0000000..cb57b32 --- /dev/null +++ b/scripts/waterbirds_examples.ipynb @@ -0,0 +1,131 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "id": "0b8091ef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from unlabeled_extrapolation.datasets import wilds\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import importlib\n", + "importlib.reload(wilds)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c6e10576", + "metadata": {}, + "outputs": [], + "source": [ + "train_transform = transforms.Compose([\n", + " transforms.Resize(size=224)\n", + "])\n", + "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root='/home/t-anakumar/wilds/data/', transform=train_transform, return_meta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ae4fa7a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(0) tensor([0, 1, 1])\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [15]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(x)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(y,z)\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m(y \u001b[38;5;241m==\u001b[39m z[\u001b[38;5;241m1\u001b[39m])\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWkAAAD8CAYAAAC1p1UKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9V6ylWZqmhz1rrd9tb46PEyYzIn1lluvucU1gejA0MyQHcgAhCpAuBGgGAnghQDcCrwTwVgbkjYARJAKEBAoQRIjUTBPDIZs9Xd1V1d1l02dk+Ihj99l+798uo4v17x0ns6t6xOkpTWEQC4iMjGO2+ff6v/V97/e+7yecc7xar9ar9Wq9Wr+eS/6LfgGv1qv1ar1ar9YvX6+C9Kv1ar1ar9av8XoVpF+tV+vVerV+jderIP1qvVqv1qv1a7xeBelX69V6tV6tX+P1Kki/Wq/Wq/Vq/RqvX1mQFkL8LSHEF0KIB0KI/82v6nlerVfr1Xq1/mVe4lfBkxZCKOA+8K8BL4A/Bf5d59yn/9yf7NV6tV6tV+tf4vWryqT/EvDAOffIOVcC/w/gv/creq5X69V6tV6tf2lX8Ct63GPg+bV/vwD+8i/74TCKXBwlGGMQAnx2b7fflzIgihIEAq0rtNaAA+GQCFQQIAQYbQBQShHHEVEcsV6tyYsC5/zjCUApiQAQEuvAWIuUkiAIsM5hbf2zQhCGAUYbtNY455BSAgJnLVIqBOBwgEAIQZzEDAYDnHPM5wuMqV8rIAQgLMYYnHNYC1EUYS1UusIYQxgEOGz9qBYhIFAhzjmiMMRYjZKSOI5oNpuoIGA8HtPpdGg2mlRlyWK+IMsLrHUYY6kqDQ6klCgVEAb+Y6+qCiFl/Z7YvsfNhYqjGCklRVlSlRXWWYQQOOsQUoBzIPz7FgiEA6QjChWDQZ8sy1gsVwRhhJQSISUIsKb+bIW/jsYYf80dgPOPJyQGixASZy3W+te/+Wz8vpCAw1iDkP41KOk/WykkcRShlMLoCqst2hr/SQn/WUulyPMcYwxSCIQU/qobU3+u1D/vHxvhr5NzjpcFqCOMQsIgRGuNtRYlJUoqut0uzUYLaw1FUVDkGUEYEsYxzjnysmQ+n6OrCiH8a5dSIoXy70eI+jH9fhHCoZSq97ik3W4RhhHWWpbLJWVZYa2j0WjQaDRpJA1W6zVFkeFw9Pu9+mf863EOjDGUZfnyfYnt2/L/qd+oQCClJAwCVKCwxhKEob+OUvrraA27O7s4HBcXF5RV5R+ifkB/Dbe3Q30Pbp4QnLX1nXTtJbDZKv75hRA4h/+8hMA5+5XPYvOXw9XXbPPYbvvY1398+3ybn3P+P277qr+6ZP06/B7w+5+voxGb/UIdG37Jm/oKiuHviyvn3N7XnvJXFqT/qUsI8XeBvwsQxwnf+fZfZjqZowKBNimWAikFzkoG3SNu33qTqqy4uDhhOhsDBiEMgRTsDAcEQcBsMkUKSa/X4bXXbnH33l3+9Ec/5rMv7lOWOYESxEoy6LbAGZwM0SKhQuIEHBwdkZcFeeFv3FazRbPRYDaeMplNMcYy7PWJgpD1YkEYhAQqACF8oFCKe2++wd/5O3+HPM/50x/9KWWZYW1Fli/QNqXdjohiQVFZEAkQYDRcXU1ZLddoU7JYThDS8K/+q3+dd7/xNlHUwBhDt50Qh5J2I2Zvd0in32Y0ueL/9p/+p9y8eYvf+Vf+Ovk85Xt/8AN+/rNPWS1zptMVZycXaO3odLr0+33u3LpDHCV8+eUDnIAkSQjCgMvRCBkoirLEOcfrr71Ot9vn/v37TKdT5vM5URRRVRVJkmwDZqACEpXgjEaqgjt3dvjv/w//bX70o5/yvT/6U27cuoMVCovDSsjyAmMtRmvyPEc4aLdatJpNpJBEYch8tWS2XqKNI1AxxgBOYbQhaTRRSrFeLdGmQoQGazVhEBAiGPYGDDtdhp0OzShiMZ2iy5I0L4jbXYpS02i12Nvb5+mz5zx+8ggVSJJmhLEVabrCag1CYiw4IQnDEItCiKAO1sJ/7q6i0+7Q7/Qo8oJABjTjBns7+3z3298hiROy5ZrjgwMGvQ7jxYyk18FIycMXT/kH//Af8vTJM9pxk51en0F/CIg6GEC32+buvddotRqcX5zx4sUzZrMJg2GPf+ff+R9x9/W7/Le//0/4//wX/5DZbIFA8ff+3v+Sf/1f/1ssFiv+o//wP+KTLz5id3/A3/ybf5OnT5+itebG0Q3anTZCCH784x/z6aefMlvNsdJRlAXCOUIZoIQgiWKaSYOdwYBhf4BSAePphDfffpuqqnhx8oLziwviOOav/fZvM5nN+IM/+ANGVyMqYzDW4pwjqK+jsw5TVdSpEuJaoLZ1wuQDsE+KpJRorVFKkTSaxEkTZx268geO3DyGM1RVhVISU1Vop/1jIbB2ExQFVaXr/EL4A7qOldrVCUMdPJ3zCcDmoEZJ4kDR6XTQWm8Pt03SJeqDA0CpECEE1tqvJBbX4h9SSsqyRGuNEIL1Mn36i2LlrypInwC3rv37Zv217XLO/X3g7wN02l0nHHQ7HQQO4yRh1CYIA4pcE4URVVmRpSlaG6IwwtgSawxKKZRSlEWxPV2ttRRFwfn5BYvFcpsBAog6o7Na+w8oDAilIq9KqkqzXK7J8gxnLXGUUJaaKIoZDncZj68wxnB08yZ62KcscpxzpFlGluU4NEJoHCVRDLu7HVTYZXe3z/5+n+GwiSHn2fNHnJycIYMmgYyIwhaT8YL79x9ydTUh2dlBm4Ljoxu8c+8d4kaTfq9LHEqUNDTiECEseZURRQHDfpeHD+7z3r23iVUDJRXGGLQ2PoOos+igzqCNqbNW5+qsUxAGPlsvy4qyLAmCgDzP6XQcURQRhiFRFPmMT6lt9u2fRyMCgXMCa/3NFChFs9HAWcPV1ZgwSVimawwWJyVRFBMFIWEYgrWEYUgYReiyZDafcTWdEkQRptJEQUIUJxR5hVABURBijCGOYigcYRCyWi+QUtBIEvaGO+z2eyRKUWYZVZlR5gWvv3aX7/zWX+FHP/4JH370CViIlCJUCmM0pqxImhGNeMhytWS1XqGNBSRSKpxwBEoRBAohBFEco22IqSoWiznOOnqdHjs7QxqNmGfPntJtdwiVYjYPOT7co7RtRtMpmdGMR1eYskI6aMQxr7/2Ot/99ndoNJo8e/aU5WLO0Y0D3v/Gu9w4PuLs7ITvfe8PsEazM9hlb/eQXn+HXneAlEGd2Vk++uhn5Lnfk6fnzynLgizN+Pyzz1kulqzTNUVeYIwhSRIO9g84PT1lna0oTIHEEkUR+7u77A13aTdbrBZLnDGk6YpWu8Px7du8dvd1fvjHf8yjJ0/IiwJrLb/7j/5LptMZeVGgrUUbc/2ep6oqXxlpg6gD5fU/m2C3qRiAr1S2nU6HKEqYTme+yjCGMFAoKUEqpDE+cXIOU5lttiukQDixDc7beCDqWtj6CtrV98Q2xxXi5b+txTpJVVXb6m9zH2wya/94AmtLhJDbAwd8hR+G/j4r6uu1yaavH1RfX7+qIP2nwJtCiNfxwfl/DPxPftkPCyEQVhAHEXEc0enu8eZbd2g0Yi7Ox1yeLwhURBVUhGFEsxkjpCWOFXGgGA4HDPoDlosFWZpS5BllUTKZTCjKYvs8zn394gucBSvA13kS56AsKqy1aG0xymCtI4piWq0WRmtW6xXdVpMwlFxdXTCZjjw80EjQJiXLF1inGew0ef+Dd7h79xbtToQlZzq7IGlrjm720JVBipD5LKfR6NJo3OP+F4I0Tel2D3n6+CFlkbK7c4BSik4nQUnL3m6fXreFFYasyEmiiCrP6HY7tJMevd4AgWK9Tlmt1lhnUdKXpnEcE0ahL6+sRTtLP0noD/qMJlfMF4v6uTpUuqKqKjqdDvP5nFarRVVV29N/s0GVUkRxjMFhnMI5x2h0xdXVCK011WpFqA1hHBFIR6ErjKkgVIShQpeW5WpBUeYIfKB9/fU7xEmTOGpwenKBtRJXQbvdpdFo8PTZM6rSV1uFttzYvcHOoEeWrlBAIw7pNBvcP33GfDpmOBjw3d/4Drdv3+bJo6ckUczTR48JowiFwAFKCDrNNnEjIogDrHD+8HUABokgCEApR1HkGOthin5/QKsOZO1Wg9fv3qHVaJOn/nBYrQry9ZIokLzx9ts0+x0eP3+OMIbACRKlaCUxb927x1/+zd/k6OgIIRwXF+dcXV0ShgGzyQRbaZQQoA1VVvL44TMuzsecn48Iw5goitFa88mnn/D4yWOUUqxWMwSWLM34+OOPWa/WFGXBF198QaAC4iSh3W77RAaB1RUCRzOJef3Oa+zv7nJ2ekpZZiRhTBSFvPf+uxTGcXF5ydn5OdP5jEprVBCwvFyDFFTOkJc5SgUEKkAphbA+SNsa1nDWbgOyq2HGzb+jGqpyzrFerwGI45h7d+/x+t03+Pzzz7n/xRdU+CC8QRQ2UIQUgiAIMNawwTWcA2uvwWmbDPhaHPoKlHHt8bZ/rCXP868E103Scj3o+kD98t+b3w8Cf5hukptt/Pv/d5B2zmkhxL8H/CNAAf9X59wnv+znrXU445jPFrTaDXAV8+kCbIdOu4sdxqSpJnXQSGL2DnbpdpskcUBVZASBImkkzGczjDEYY5ESnx1pg66034RSfOXEk1Jia3xSG18qSSlpt9tIKWk1mwhgvVyBFEghKY1mPB6Rpwk4zWw+wdqKIFQUZcrl6IyT06d84/13+cb797h9+wZlteLs8pTVasL5xQvCCKDCupLdvSM63S7jyxWv3Tni/fffZHdnnyiOWMxnHB/fJIm7VKVG24LR1Sn9XhtdZVyMLlisFmRpRpGVKBHQ7Q5qnNKhtcEYB85vGKWUD+TtJlXhM96q1HVJ6fF16xyNKCJJfI8A/M2xuWE2Gc71zbepZrKyQgWOXq9Ho9lAW4M2miRpEUcRcbNJrgtMWSCUwglBGAQEgb+JG3GClJLd3V06nQ6mMtx9/U3mk++xmGdEQQjGYitDMwqppKgrnpBhZ8Cg0+Zwd4cyXzMZj6jyBGNKrNO88fY93nz7LaKwTbfT4b133uXJk2c8efYEqYQ/va1jPp2SXqQQSIIwoCEa25u6Kg26KjzEIiTDQY92q8PO7h5JnDAdj9kd7rJer0jXaxpxg7LKmc7HlGHCZDrh5PkzOjtDdodDsjzjp1GEcNDrdjk+OqTbbhEFknS95uzkBffvf0EchwAkSeQPCqFYr9aslinaCK5GE/85CoXWGWm6QkpXV5UluiqJkwY3b9zk+fMXSKFoNpscHR1xcHBAGIW8eP6C1XIO1hJHAY04wjmNlI4kiRgbTXM44K/+1b/KzVt3+N1//F/z05/9nMvLSxxgsFSVzw7zokBIiQpDlJDXMmV8kJISaywO82cySefctjeyCYCbCtA5x/Pnz5BBSK/XYzAYcHFxvq2gcbbe0yVCOIIwAF3HF/yhsIFNNlCHx+FfZrrWWqxziDp7t87DFU5cx8Hd9jE2cQSoY4/BHxcvg/Tmd7TWFEVRxzy7fU9/XoCGXyEm7Zz7XeB3/3/9eWsEVWVJ1zlFkbJO5+zv73K4f0yWg7UBIEmShFs3b7J/sENVZlxenDG+GnF6ekq6WtfNQ8tg0POP6yxhGFBVNeSxCdIIlAr8hawDWJLEOAFZlgL+ovd6PXCWq/EY330Daw1COAbDAc1WwuXoDKkEpa4YjS74b/6b/5rPv/iEt9++xzvv3mO+vOL+g4+ZzS5ZLKfs7vb54Jtv8o3379JoSobDHnEc02r0Odi/idOC+WrGcOeAMFK0kybrdUFeaMqqYrqY0+u2eecb75NnGVVpefjlU37ykw/54D3JkyfPWacZ1myyBIHWBq0rAPI8Z7VYU1XVNrter9dkee7LRvB4m/N4ta6hIV1jyGEY+iZSGG5vpM1GrKqK+WLBZDym3WoRRTGdTpd2r4/Bsp6v0dofamVVoHWJcPiGlJIIB5eXF0ynE/Z3D1inK6QQLBczkqSJjGPmi2l96Ei0NcRRRCNK0KVmNZ9idEoYSpoNxet3X+PkJGAym/HRhz9HigYvnj9nMpkRBAolFWVZIBUIEfoy2Ric8Dh5o6HQukKpgLifkGU5ZVXR6XT54Bvvo1SEdaCkxOqK4U6fIAiYz2YU+ZrJZMJyueLe7de48/odtNGUZUGz06EqS4o8wxmDKUvOz8/48U9+RKfdYjqd8umnH/Po0SOEgE6nw/HxETs7O4zal+RVRRBG3Lt3D601X3zxBbPZBCEEt27d4jd/87tMphN+/OMfMboaMxju8p3vfJfDwyPiOCZJEpbLJdPplMV8gZCCvd09inJNo5nQ6/TQhSYIIt55+13u3HqN9957l+9+9zeYL1f0ul2azSZJklBWFUW9t1QQkNQYchAEvv9fX1NRN/ykUkgEDrFNBDZrE+h8k1uRJMk2MRBCsE5Tvrz/JZ1OZ/u1l4FO1o1E3zB0dpOMCYy228cPamhvs7TW/nWJwB9sWm8r7usZtaqzaiEEcRwDUBQeNtokKl+FPdRXIJENPn09M988x9evw/X1L6xxeH0JBFIFWMBYRyAUxlgWyxU3jgKsrTwsYR0y9Beq2WzSPdil026yWi6YTqe+Y20djSQiiWPyGupwziGVIlQSqXxTxlmDNQYnLUiQAtJ0BVIipP/wK10QhopOp810PmG5XFNlKaLdptM95PXX7jKfz1jMZ5SmQApFGAbkecnDB495+PBL/sk/CdE2JysWBIFnbKSrAqUE1pQc3Tjm1s2YbqePUjFPnj5iPJ7g0PR6HRCS2zdims0Bo/E5V5MJeZEipGN3d5flfIXRiqoSfP+P/gRFwuPHT1nMVzgLSgUIIbfMgDRNybOcfF1QViVJ0AB8FqGkAqFfNlRqPC3Lsq8E9M3mUkpRVf7m3JSqDsF6vWY0GjGdzVBKesbJYoGTflOrQBFG4fbQNNpQrNfkeU4jaUAGWless5TZYk5v2KUymiLXqFCRiIgwChDCkaVr4ihEYOsOvkFIh3EV89WCwXDA4fExYZBw7823yVPNT3/6IVmWEccJrXabYppjEZ4Z0WxgA0HpLM5JilJTlRVJrHBh3WRVAU5bTk5OECLAaoOps7jlYsZ6ndLv9TDG/24YSaxwPHj6kG6nS1Tm3H/0gM8//4J5fY3CMPTV03LOp59+yHw+Zzy+4mo8IssywjBgMhvzxr17tLtdjjo93nrrLYyx20NUSkWkBO+99x5vvfUWz54/48v7Paw5IY5ivvHe+3zw/gcYY1kuljx4+IAkTvjg/W8Cjg8/+hnT6RW9bpdbx3c4OjzkG994n9t3bqPLiqoq+ZM//hGfffEFH3/8KZPxBF1VYK2HYfCZcuBAbZhPwvms2bmaNXGtvK8hic3++XqltmnOJUmy3YsCn0Sl6/UW35ZB4A8B6gBYxxVjDAgfYHUNp2ywZFMzjDz7xzcLZf287trfW8xZCIy1CKDTadFsNknTdBvDNk3OMAy3Uc1atw3cG4jkenD+Sgz8F4BJ/3dbAnb29slLTbfbJooEq3RCUWmmiyV55nzZpBRlkTGejNnbH3J4sIvA0u12uTi/oNVscufOHaqqpNtpcXp+6rO8mh6nggAlHK6mE3m6kQNXoY2mEcQEoSKKW6TpijCUrFZz0tWKIs+wVmOd80EmCFkul0wmU4z1lYCxgjhu0OsM0KZkMr2gyHMMJeAIQomSAeNRwejycz7++AHHN2/yG99Jefed91ks1/zg+z9kvpiwu9vj3pt3EEiKNGDQP+Ds8oLvff/7PHr8iE6vSyNpEqqIYXeAUm0+/+QzhA3RVb0JhUQq5TNUIej1enQ6LWaTOet0vT3xjTG0Gg3CKKKoyu3Xms3WNhBb65tJnU6HoihYLpdb+pox5uWNiKPdatHr9Xj48DG60qAKXKWxAqx0tLsdGq2Gz9odVGXpN7G22LrDLpVEu5LZakJfClrdBqVZYmWFE5a4GYBwCNWg1+nQ73coihWzxZp2O2Zvf4coCkjLHFCsVytOLi7ZHx6ws79Hq9ul2+vjlCAtUipTYnBMFzNKa5BxTGUKsizDGoOuLOt1RlhXDVWpuby4RAWRh1yS2FddNYXw7t07tFotJpMxi+WS52fPOTk/44P3P2A/2GO5XHqMUklWRcZkNqHQJfuHe1xcnTN9PmU0uaK0FVEjBiFI84zzq0t2hrvMFnPSdO1ZMqYijmO0qZBScHp6yuHhATdv3mJvbw+BJAwiAhWgteZqdIXWmu98+zvcun2Lydhn3JOxh02chjKrKLKK87NLJuMp5+cXPHz4gJPTU+aLOWmWURm9paDJmnQmncA6i6wbdrL+jDd7A+c8nHCdfXatGtvCkHXWaa0lyzKcc4RhSFlpilLjjP9es9nAOs/0kD7ue7Chpop6SqNE1D2YoKbrwrXMtsbIt1TQa2tzj4RBgJCCsMbLNwdjFEVfyfqbzSZBEJBlOcvlyh8CNaziaY/uK+97szaHwS9avx5BGvGVIG1MziqfUVaaZy9OGPSOQG1OqoBG0mAwGCCE5PLyssZ5HNoYhJBEUcTO7g7j6QTwkIexBmsVRjgqXaEkNBoR+3sHFNoiwwARKlZpSp6t6fW6NJsNiiyj0oUPDEmExJf0Dx4+4NFDtqwIhyJUEZ32kJs3X/c0LuuIkwDrSooyp8hz0jRFlwHINkVpKfIVs/GH/OwnpxRlwXo9RyrDYrVisV7Sbrf44rMTqkrQH/ZxUlJYy/xshLVgC0crbhOKkCyzjC7H7Ozs4usTH0yMsXWG4k/0oigw2n+9qrOVoCj8RpdyC22EYfCVcjIIAtrttqc7zmZUVbXtVhvjucpRlHBwcMCtW7f48suHtNttklaP0loW6xVSCqIoBDzVC+uhp2aziTPWNwOV4PBoj3W2ZrGYsVqtaDQ7yDAiCCQon814EB1aYUKarciyJVGsGOz22T/cRynF6fkFZWnASV6cnZOuC4qqJGk1GOwMef9bH1Daii/uf05lNdoYX7o7wEnKUiMcFELjrGVttM+kzQbf9M2ffr/He++9C8D5+Rmz2ZR1umI2n9Dr91mtVlhbMl8v6A8GqDBAW0NeFcggYJWt+eGf/JBnLw7pdlp0h12M0zgERzeOEEKymM8pioLxbEK32+NydEGz6XnYUvks1ge1nMFgwP7eAUIohJCUZcX9L+5TlAVaaxpJg0AFPH38hD/5kz/l2fNn5GmOMIJAhmAFZ6cXPHn6nOVyyWq1ZrVa+oCDr35szQuXStWfI2AszppaRyBBiW0G/JK07HxWal/i0RtWltcmhNs+BbBtVMdxjENQVRVRGNUZtsDWwdVXwNJz3W0NnViDkdYznbb48MvI4zN4z3baUOE2SwpBEEUEQUCj2UQoiXCW1gbmKUvWdUb/8rF8LyjPC4qi2NIHNxz6649/HYf/89avRZC2zmKcYXd3hyBU5IVBBgHSGt99DwOkFAQiYrg7ZH9/D2M0V1eXaK1JkoQ37r1BWRSk63UtBvEXzWxOxhovNc7QTiKUFHVQEgyGPZJmi+lihnOGIAgIo4CyKnG4WsNgPYE/kCC9SCRptBCIuoQPEAQYLcAGJHGbbmePw8NdkkbA4yePeTF/gTUJ1vjNRBCwWiis1iwXk1roUqACw1vv3iZJFKtVynw6ZzlP4akgajdJ84LlKiOQEWVmSFeGgICytDx4+ITLyzGNpOVZFDVNSQrBcrlkvRbo0mCco6o0YR2Q16uV36R1kN5cP2vNNmOGl9nGBmuL49hv/Lq5FgQBjUaDKIqIknj7GRuzoTf5JmWgAoq8BGcJg5A4isB5iluS+C7+fDnj9PyM6WTBcrWg2egglSCIQ4Ik4PDgkOFwSKjhi48/QSr41re+zY3jA2QoWC3XMLqiMBmBijm5PMM6h1MObQ137t5hMNghTEJG40smszFOeGhMqoiqsljjy1OTFQh8RddoN6nyAuFE3aNw9Hs9pIBGs0mr1cRaTRAqBjs77OzsIGRAnml6/T79nQGVNWR5Wot8IIxCKl1xcXmBsQPeeftt3n7nbYbDHdqdDsIJJpMJ/9U//sdcnF+ggpCiLOl0OsRJTBiEKBXgnKGsNFlWMp8vMQbP+ig1H/78Q2azGXEccXhwyDc/+ID5dOqbpcsVRVrgrKDT6XHr1h3SLOXs7Iw8K7DaksRNEGBMhQSKqqAsCl9d1nBAUGO3lfbNeqyrqZ5fFbKwLfsdzr2k4G2YHfBSvLTJVpMkQaoAYzzbSgqBqRkSUr6EMo2u964DZw1G2y30oLWhqjbNcrllmmwax0K9PDCoD4w4jj2dVICzmiAMSJKEJEkQQrBarSiKgizLqSpdC4R84NZaU1WeJbVtMl4L1FvRzJ8TqH8tgrSzjvV8TtJIWC5mpJmnMrX2d7lz5y7rVcVisSIMFHsHA27cPODoYJ/Ly3NwjmajQagCrDGMRiNWyxWj0YTFau2J6wC1mswJgVCKOI7JyorZbE5SGrKLKzq9Pm+9+R6j0RXjyRgBRGGIEAFRFGGsbzB0O21u7B/QbDQ5fX7CfGYIwwitHUoosBJrApyNWa0shXaUVYiQDeJYo03pO8+hz3zSfEmWQ6fTJM/WBIHhYLjLG2/cZj6b8ujhKTYfMVstyKoZq+UKYxxGQBw30LlBG4sKQ3RZkBeGRiIRSOIgolIl1hrWyxUqVISBL5+db0Jv1Y4bjFgKgZIKKSTO+obj5rCqdEWWZQCoICSKE1/BKOkx2KpitVpycXHms/WNMtNZoiDBKYESAa2kjXIBgVLcvHGDbrdDnqZbznsSxHQOb3Hj6BY/+fFPGY2nSOmbTgjBdD7HCkFpNJGFwpTIKGSyWDJZzlmu5mhrWGceEuh2uqwry8PnS0xl2envMJpcMhr7P3EzoqETstLSCBtEUYvlco0uS4yuG1lSeZZK3EKXzmfB0iGlIMszhBAcHR4wn894cfKcs8sRveGAXFu0rkgaDZyyZGXOcr1iNJmga7Vk0miwu7dLt9Wi22lxtH/Ia7deYzgcIqVidDVinabY+rBczBfMJjO6rS4nL85ZrXKMgUajxWKZ8v0//lPiKObJ0xeYyqAA6RxOa7KqYJUkhFJwdLDHa3duITCsFlNWa8F8Puf58+f+AEYQhRFlUVGVXpsQhIHXKmhDYX2QNtZty/+wbsibStdK1Jd4r+AlXY66SrPOEqgAKeS2AXedEbH5mq/WJEkSb7HkDbwha6Xphqfs47/AOeUP/yAgCEKMyYCXGa2HN65nz7IuotyW7y+lwFiNdb6HZURIpjPfAxGOTrdDo2qyWqWUpVdE2zprr4yvzpAC6bvTXFd2uvpiCPnrjkk7x3q5RFcZRZVibEm316c/GPCtb34LYwWPHz3GUfksSUCz2eDG0Q1aSUIgX2M6mfDl/fusl6u61NAYUws5AoVwkMQRgaCWgwu0dizmKywhRWnp9WN6nX3OzmZY4xsATkVEYZs4adDttVGB4/jGITePjrg4P+fy4ow4CdCVwRpwxjCfzim1pTQwX1SkoznrdU5lfMMSHFEjImxG5HmO1ZCnKc7FxGFAkef88Hs/5PL0lGF/QLGsaAQtgl7MxfyKJGiw1r6Zp8KIRrMJRpGEMUnYQAkJBEh8c1TUgRdnkTIiCEO01TgB2hjKqnpJP7KWRqPhMbYowu8dSxQFXsQhJZXRVMagEB4PtDXUFCgqnfL85AVJMyDPC5pJk0F/SHk5ZZFloARZkBFJ/1oFYEvHTmfI4b13mM2mZFnKa6+9zs7+HvsHh0gb8off/wFBFFJkBVEjwToYjSfMZjNCLK4q6ff7nFxckOUZZVVQmQLrKpJGiAgr2q0eSsSUpmJdRjx4+DkXFyPOz88pqgwZSgJCpPShRFqPnQq82Ack2jiWq8wrIKVCRSAlrLMVz549ReuK+WxBGCaIIGKV5sgoQuuKIs84OVEEKvKZV1GwzjICJamqgjgKOTjYY9jpMuj0mIyueP7kKdPZjKfPnnF6fs5kMmU2m1EWFYPegJvHt1guVljn93XSaJLnJatViuiFrPO8brqmOKvJ1sta0m84O3nB63fv8Fu/+W0ajYCHj76k1CXz5Zx1tiYOY4IgoNKmFpPlVFVFq9XEmJL1KqXUNQ9ZepuBoAiIWpEPmB7orQlpNdFjK3GnpsRKsBYpPQ1yK476Gjbts2Af/BASaw1l6THeUG2ajz7iObxc3JpNE9DL6N1LlftXYAel1JaeixO+sqkhjnbHw0llkaNdhQigXPnKwlmBFIpG3KzpjxvKq/KQi7PbBFFJtW0qVlWFrnwlugnmwbbh+GfXr0WQdjgqU2Lziv6wR6/fpd1ukxUF5xdj3nvvffr9XdbrBUmsuLw45+TFOXs7O7z/jW8ihePqcsTOcMiX9+/z5MlT9vb3mC3nCCnQlcZhII5q3qXHunSlsdYLWpKkwWKx5tGjZ+SZxhmFsw4VR6goIG5G7O7ucOPGHhLL+fmY0cWENCspSo0uDaDI8pwoWyGVFxcQBOjUYVG02gOU0ggMKgyIoyaNSBLKgMl4zDtvvk2Rrnj29BFVUfHl52e0WwviIKHTHRAGjmFH0u3tsc5Szs4uKAqNCyW7O7u04gbZcoWtKlaLpffK2DpQgFSKKAzrzMRuM5ag7o4DW3rRdWnulk51DUPzzb2AoizR1hHLmkttAxaLFek6J89KkqTJ3u4BrdYOxf0vSPOUKqsogoLefhes5fT5KcU6Y7I/JlCKVqvJ8dEt3vvgmzQaDf7mX8+ZT1ecXpwzW8yRTtBoNraZ/3x6jjUVg6BLI4lx0pHIpC79M4RyNZVL0ghCuq02r918nVbS5vmTZ0yuxhgs2nled2k0OZqyKBHC3+BbwUIdkzaKQycqnHTeA6VmKvR6Pd48PGCws8PJ6SnGWcbjSxbzKVmacnlxTp7mSGfBeoxXOIsUljxbMa4Kup0mp+eGjz76hBcnJ2R5AVIRxwlKhTSaIRbHfLXAI2d+X/d6XU+FLApmV2OKNEVJSZalXF1dUZQlURRgjOb5i2f0h13WqxVZmhKGAdqUrNYemorCmChKvJqxbtw7bTx1zoL3q/EYsDGaMIyIkwSpvKo3jCKqWjrtf5qXXi/XhCObxrRAbvfbBr+9Dr0ppZDWg5mixqZxbssk2fycj8ZfxXyvNwQ3+/qllFtuX5tneUjCKKwxcEdWFFS6JIwDkkZMZSpM5fnQRhvm+QLhJFZbhPBVOipCKv/6N+rCTYNx8/wb6PA6F/wXrV+LIA2QFWuSRoO40UAbx9Pnp4BEiBfEcZd7b7yFni85G19hKkvQS4jjJq1Wl/VqztXVFY1Gwl/77b/qN0d9Oju3+VD8hyqsoZnE2w2QtHocHB7R6vRYphXt7gBESLc9pChyGnHCarkgVC2ka1LmAcvljJNn56xXc/LMUJUWUeNq1hkq670tmt0WhXZo42g0O/QHHVqtiCRSZGlJGLVZrzPytGDY7/DOm3+JViPmzs3HVFXOeHzOYjYjCgN6vT2stHz3nTe5Gl8xmo4xRcBsNidUMZ1mlzfu3mU+mfDi2TNgWffb63oQR6ORECcRVWVqvqjHj5vNJsvlcosHJklCVVUURU5ZltuGiMfV1JZu1Gq1AFBslFQGR0BZlIxGE8bjGVHco9cZsrvX5OxixM7OLlIIVuslOq9oNZvkIsOUhjiM+eCDDzi6cYN333ufYW8XKQM+ePebzMZzPvrkI65mY7TV7Ozu8vT5E/q9LldNWK1nWDQWiRPG85rjJoOkT7vTZDDoUazXjM9H6LxgMhmRRxmTyZjZbE4Qhp49VFYI6Q8xIXyTU2/KaiHqvoEPIkgQgTfz6g52GAx3SJImRVFwsLtPr99DAA8fPWQ+maKUwJSaq4tLiryspdEOiSMQwnufCIdUluVqxnKVcjm6YDqdorUliBI6nQGddky726E76PHg4UOenTznanyF1hXT6ZTf+O53GV+NOTk5IV2uCKQEKbE49g8P2N3dodtpI5Xi4aNHhGHIi9NTVusF/X6HO6+/TrPRIkmalKXmajRltU4JVEir6Q+8NF1iraUdBuRFTlEVHBwe0G43Ob+4qFlQHoL8ukBlE6yu84qLomRT8VtrPb2u/t51RZ/WBu0sEulhubohvgm0/jlqGu0W83bbQL1prm7oeP7O8BX3Bp8W0jNUsjxHVL5nFoQhUinKUmOcxRgIlCRKIkxlMZWl2Wgx6A9pthoIJSjKgtlsujWg2jBUGo0GSZKwWq0oy3LbXPxl69ckSDssFmM16/WaKG7gCGg1OxirODsf0+6MCYOYp09eMLq8oNtpceNon/VyQRKHnJ6ekaVLfuM3v8ve/i7PT04968M5pJK+KVCf3NZYnHQEYcj+wRFHxze5cXwHZMTp2YiqcLRbHR+UnEMYSavdp5F0KHOBdE067T3K3KBkgRQWY0oQBmyFVLCzN2QwPGCVVsRJizhJEMKhdQ4Cer0+jXiAdAtMPuVgf5/h4Jh3336Dv/KX/xrr5ZznL57y+PEDVosZURwglOTOrTfZHd6g/ORjht0lrlIoGYKRXI0mmDKv8T2/eWWdTUglabWaNFtNlquMLC+/0k3fbNzNJvZeHyFCvKQHbTKfzebeUJHYUJ+kQNdiAWthvc6xtslylWJXBY1Gk29/61sMB32ePX3K2dkp6+Uaqy2BCjk+vsUb997g5s2bxGHM9GrB1XjCs6dPOHl2yu0bt7l18yYff/oR2XKJyXNsI+bwYJdG64jJbMHVaEK6XqPCsBbjNDg8OGb/YJfR2QnLqwnL9YpPPv6IbFVyeTGmLEvCMCaQAZWoeeV1yfxS9abYcF+N8RRHWXszRHHM8fEx+/v7fPHJpwRCstPv45xBOq9iXC9XNJsJRoXYSlPkBUWWed+SKCCOQ+IopN/rEIWSvEixTrN/sEeeFyyXKTu7+3z7298hjhK6/R4vzp7x/OQ5k+kEbbz3zOX5GWEYcOfWTaS1vHjyBCm858Xe3h6dTod33nkbcLx48Zz8POOv/fZvc++Ne3z86YfcvHWDf/Pf+jeIwoSiqDg/H1GUn9Pp9jAG8jQH4eh02+zZPYw1zBczxtMx+/v7hFHI6cVFzUP2OKxSsqa++b246X9cV+SB23Lzt1HBvTRY6vV6tNttLkcjytS7+gmltk0/74K44et7XvNX5Nzb52G7lzdMJvBKW+N8s1A4S1lVda/FJznSaExmMRifZYcx7XabdrODkgFKKHZ3dtnfO0DrimW6ZDqbMp/PKIriKzYKm+fe/AG2DJFftH49grSAJAkZDPo0my06nR6V9grEstCUhWYynvKtb77D+OYxF+dnTCZTQiX4BEun3eD05ITFYsobb97D1LSyqvRYaxiEaOM8L9f6LNLUtp2HRzd48813uHn7LhCwXFWcvLggzya0Wy2cNsRRQhy2iMMOlSkJA0GnbUiXa1KxwrnMGzcJL3WVgWAw6HPrzm2KEsrKkcQNTs9OmU6vUCpAyQjhJLeOb3Hz6CbdThslFKenZ7RaAcvFnMvRFes0QwUhi+WKLM/5wff+hCiOePrgOct5Sr4qca6kyjVVUdLvtmi1OsyCCVopVG0lWWsHaLYaqDAmyyvK0pPxNwG6rPnKG8ZMr9dDbg3fBI1GA63ttjzdlqkqABxVVaCrEmNCdGVwVtBqtdnfO2A6XxLHDYbDHb7xztsc7u3z+MkTxuMRs9mUKIqYTWd8+smnnJ6eAgEXZxMePX7C8+fPUIFkb39IXqTcf/AFSEccR8wnV7zx7i0EAe1Gk0W4rDFKL+MWKJaLlEDNOD0558WL55jKsloWLJcZpanYO9hnONxlNp1RlGUt/vHK0g2Gaa1npUgpIahlwUoglOeir9YrXjwruby4ZGfQZz6bsrMzIIojnNEeE7Xe9Mdo7wHRSGKWi401qkU4S7peoqOA1WpFZRxxFHLj+IiiMLz97vvcuHGL6WRGlmWMRiPG4yvA3/hGV559Enn5+Gq5RAJJEtPqtFmulqhAkWYp3/rWtyjLkovLM8Ig4MbxMd1eFycsz54/ZblMKUtNui6oqpJ7995mb/eAyWTKaHTJ+GpE0ohZp2u09ZTRLPc4u688JMZYokBuXeOazSYAV1dXW6HKBobQujZG4iXT4bosfGdnhxs3bpDlOVle1Ieo27JErrMjtpmzeyle+Trd7XqQ3ghXhBAeIpTevthYizOuPqwBKQnjiG5nQK/Xpd1s0ev22Rnu0O/2aTaaZFnOs2dPmcwmrNO1/xzrqmBjC7vRFmwOq18mcNmsX4sgLYQglIJ2s0G/P+D4+BZ5bshzzWqVspjPwGreuHeDG0eH3O+00WWJkJI8z1gtp5ycntBqJlvZabvtyzkhfXkl3Uaa6b2QjbWEYcRrr73B0Y1bBGHM6eklV6Mx47HPfHqdNsN+n/VqzWyRs288ZBAECpyi2WizbjQp8iXgT2EVhUghvHy4qGg2BzSbEUZbpAhpN/skcUCZ5eiqoCr9JqzKjD/9kx+wShfEsaSqMopihbGaYb+Hc47xeIouDa12m26ji60gEJ665XCUpWaxXIP16rMwiCjJfDYtHKvVgjAJCcNG3WRhm0VvysGyLLcbJwxDyjLf0qbCIMCYqlZyCcqy9GWrEAjp0KbwNZGt4YYoZme4x2t3XkeenJIWOQcH+wyHQ7qdDkc3jlinHg8dT6746U9/wo9+8qPt9V3MMvK8QEgwuuTJU4Fzvr9wcHjAer3ElQbhJMvZirI0SCdpRA2uxlPipMHR/g2CMODBF484e/GE8WhMqHyjWChF0gzZOzpkd2eP1XrNpuNl3UtPYVHj8760NhijSZImYRzhJCgUF6cXVJmXeJdFwdOnT5hMrxgMB2hd0WjE5HmBrjTNRodWq0We5ahAogJJWRVcjM4YTy6g9j6PkyZBmNBp92i2upRlzpMnj7m89GrOq8kFq9XSC2wcNJKEQCmKLPOmWLMp1lkOjg64d+8eUvqAOVssuJqM6Q56jGdjzi83zdaK5XzO97//farKkMRNGs0O7VaPIJBYZ+pqSbO7v08cR9grR1GVNJotxpOZ90FBEIQxVVWSFYUX2tTNwOsGQy991V/ixZvvfd3kSAixpbOFYUgSJ94X3Tmq0isPr/dMvm5stFmbavAr3xOeSimo/c6tw+K2B7VQkiAMaXc6tNpter0+rWaLVqPF8Y0bDIdDiqzg/Pycy8tLJtMJpS7JsmwrG7/u2b6JeV/3Lfll69ciSOMsjdhbVjbimGF/QK8zJM0KLi5HvDg5ocjXXF6cc+PGAd1ui4vzOctlSb97RFH4076qFKt1ysZw25ianL6hu1jrKUQqAGMRUtLp9lmvC6aLjNOzC2/ZmK7I85QyW3Hz6AAlHNNVQZqtabUbLOYzBJp2t8ticVWT5zVCWOKggbOC2WTOC/WCpLWm19tlvc5ZzddICasiJV3OiEJFup4BsLOzw2xxxWw2JggFSSMgz1dYV6FWmn63RxxJum1vjNNqdBiPJ6R5zmzhFYST2Yjx1YQiS2nE0bbE9BmC53OvVytaHZ/5Xi+3NhCH1nrLS62qkjRNt5l2UZa1F+9LjE/UzRawKOWQoSJOQuLYy5yPjg65ceMGD58+oawKrDO+MdxqslguOTs7ZTK9YjQekeuCZboizVKMtpSZqR3UJEWR1c5okDSSmrUCg8EQYYQ/kHTOepoyupqwWKxpdQzzqxn7h/sspgusdrTbXZwTWGFQsQQRUJiK8WyCcRoVsG2K+iELHtYIo6D2eA5qAy9R+xlbZBSR5iW2KmnEEWVREEUhQkqupmOMM1Rak5clSioGzQQpJFZ458QgEBinWWdrBFBmOcZYGs0m/f4uAgUyZ3Q19l7c2rJarVgt51hniZtN3xdQil6/R6vTIk4itNUIJRju7vLGm2/WugGfWT549NDHNCE4OTtjPL5iOpuRFSll5T07EAFhVJEVKReX5zx99ows98nHb/3mb3F0dMSPfvwjzs4vyPIcay1hHHj1nq2HLFjHarUiCALSmmK58Xy5HqiUemn5uckwr7M7xuPx9vf39vY8L1xKyqJgqZf+UL0Ga1j31UbhJhBetxa9/jVPk65NnQJJEAUveznNBr1Bn26vRxjGdFpdhoMh/V6PJE64Go158vgxy8UC57xAbL6Ys1qvvoKtX28YXrdivf66ftH6tQjSAnj/3XdpNjvkhUXnBZ2DZm26H9PrNimrgnY7odUOee31m/S6MUpKuq0mSjkC9RqTyRVnp+d+WsnVZEsg3wSgMFCURr/kXApFq9Wj0o6T0zNGoyucgF6vQxwIdJGRxIJBfwfGS6IkYDjscXb6lCJfszPsUFX+gBBCg7AooUiChNVsxXr5jGZ7hTlWRFGMEpJQSZJmgySQNBJJf9AnDCPa7RbHxwfMF1MWqxl5sSLLY4zJMTpjuR6jggCjc6o8IzNgK99sC5XncXfaXcJQsVzMcboE89KtSwUSpSRRHNJsNgjDlDwvv1IGbho5mzWfz5nPZ9ssqMhzitKT9d01QYvHox0q9HafURSQNCKCQLFcLvj8i8/4/PPPSIs1P/npnzKfjuh0OlxcXPD8xXPOLs5YrpYIJTDCYKXFKYeKHMYUGO3qm8aA8J/dZDJBSIFarHn68DkIx3y+ZLlMPQZuIZQVJ09PmF6NSRcrAhki4yZFpXEStPNNo9lqiWSBcxVBrFBWolTkDZy02Qpa/I3vzfh9UlARyIB2p0+eZ1QWhPNsIqUUR8dHpEXG2fkZy/UKa0Eby9VkDBayIkeFCodBO0PciOl3e0xGE5bzFUVtmauUZL5cMK9lxr3eAKtDsiVEQcj+zg5XziGFd26UUrLOUtIiI2rE7OzuIpVisVwymUyI45DpbMr5+TmtVoMwDLm6GpFmec3n9c3SvChQQeaFIFLVzeOcLPd9lf39fRqtFkVVorWh3Wnjc1C82b8xhDW1c4PLbrLhDYMoy7JtdrtJrq5zozeBbdNk63R7xElCkeWUdeW3bQC6rzYJXZ2hX09Grmfnm6xeqgDjHAo8Jq08tBdGEY1mQrfXIWk0aHe67O4c0O8PkXg7g9OzUy7OzreNd2McaerVmRuP7U2lukmaNq/vz7rn/eL1axGkcXDj4JB7997i8ZMT9oZDmklEVhQkUcDd124xX0xptGP29gY4+zpVeUxZFEyuRlS6xeHBPpcXHc4vzlmvU79JtLcqNdqAsMioljDXeFOv2+P45m1WaUkUTmgkTd586y2y9Ypnjx9gqxBjK+bzMe1WF5RCBdDuNHnx7BG6XLNer2qlk0QFijiMiMOEbJ0xX44pCsHe7g1uHN6g0/JilTgM6N04IAgsg0GfTqdb42eaA73DbDFlPLnk+ckTxhcXRIEmiQKqsmQ8rljPl7SaPVTg+cLL1ZJ2r8PNW0eEkWI8GvHgi89YTMd1ye62nW+c2/r4RlFYZ6fyK5SoDdThG1Yr4KWN43XFoXO+GauU9DxXDEEo2d3b4c6d2yyXBc9fPGOVlrx48ZxGK+HBl/f54tOPUUFApSvKqqxpbyWV1jjhs3KhJDJy2MrUDmbec0UIQVZmPrsNIy4uRwgsgZLkeYk2ljL3vuP5OmU6nlDlTYzT5FVKaQoskBYlTgY4IUir1DfwpMAZQyCDrTAiCBQafyiZ2phn0zz0/tKKKAiI2m1S5wUcWjsmkwkPHz2iMCXL9ZJ1nqGNl1OvsxysIM9SrNUkcUCz3eLGzWPuvvY6L56c8PTxMxBe5GKBWe3Z3Ol0aLUT2o2EUAiiKGJvfx+rNa1Om53dXQbDAVeTMVEjwQlBr9+n0+lweXnJo0ePPGe7zFksFqxWS3Z2hv4zqCqiOCaIYmbzOWadeu510qTZbiClQltNtaz45NNPmEymfPnwS5bLJVWlPT5tNEVR1WPRLNJBID1VzQd7UVM6wxpX3oxTE1tjs80KgoB+v4+UkuVy6QP9dIIKfFO4kSS1vYHPvDd7XGsv4Zd1Y/ErGbZ9OUAAXkIpWFuPd/OPE8cx3V6PRiuh2WoxHA7oD4a0mj2KomK1WLBcLFivV/gBFJGHXlcriiIHPLRzHd7YrA0XfNNM/KoP9Z9dvxZB2jmHLjPefPMeIMnykixfsX9wQFmWrFYLplcXZFnM22+9xq1bR6xWCy4uL8mr3PMmA8X+4T7j6SVX4wsQgixLKYvSe1SYgjCUGLvR0Qta7T5x0iIvBYPBLjjl8V1tUCqiyAqywiBlwOHeIYtVSrpccXx0xOnzpxhToo3Hg33jQaJCH8jjhqLtYnaHHfq9hF4nhk5EulZIAcNemypfsxyPSZSqS7eUvFiznIxZzmecPHvOeDqi0wnIQ4muLJ1mF11qmr2EncMdwjCmn7fo9fvcunOLMAj49GPDkwe1beNGUeUEzgpWi5S8sGRZSaBCcMabQBk/S08KWWN8bkt5Ekohhdq8S1wtVRTCq/Ck9EwSHzD6vPHWm7z15tucnY95/PiC1WqBc4Z0vcTqAlvLZBEgA4mTFm21H9ukIAj9HD0nHVJaZATWVuRFhbIBRaaJwoRESjJdYSvvxRKFkS9BkxghJJPpmKJI6XWb3Dy6yWw5Y7qcEUQRdjwhL4u6eth4P9TCDauplJewew8JsVXUGevnLZZa11mixpqKg4NDVmHE5cUIGUrSrOLk9BJCmK+XGGtqAZDECoGtrN9r1hDHIXt7e+zv79Ppdjg8PqTShkaj4/1ZnOXW7Vs+GZCKnZ09jg6OGF9dMbocYaXj3ttvcnzzJkc3jnj3vfd49Ogxf/TDH1DUsynniwVFWRInMfk8J81yssz/LSYznLPkeYkRoLKMqs7s/PUwVMZ6+4J1SpplfPLpp3z04ce1KCfDGkuep77Zhp/HKOqRVbVbKbb+HyEk61VaW94GRGGDTqdV47d6W7ltLAc2sJq3yi28bUMYEdejuK4H3i3GLSBSIdJ5law1xrs8YmtoxL6sjsxLGwkvYOnQ7rRpNlu0Ox0Ob9ygkTQYja54srxA4PzhXXnjNIdlsZyzmM0oyhxjN81G8RX5+fUm4fVkB/gz8Mf19c8cpIUQt4D/BDjAt5b+vnPuPxRC/G+B/wUwqn/033feW/rPeSxYLuc0Wwn7h7v87Gcf8ejpY5bpnLfefIs8gyePHhIlEW+88TpxQ/HpFx+zXK1ZLjOkiEiLiun4glIXRIkkXadeJaS9uY73gjVoU3lTchuwTgt++pOfsloXLBYLL4/WhsVyCQQIFYNMOLxxTH+wixBzLi/POTraZzjsk+dL8jyiLCTWegWjNoZGO2a4u4u1gnarz6CbsFpckWYpSgparSaL6RURjvnkiv1um6TVRIWS8fmE02dPORtfMpvNKPICnGaNqaWpvuO/KAKiteT27dewAVxNT9A2BSt49PAL0nTpG1DOl+CBClFBQFlUZEVt/tSOAEeapmTZGl15+pyuNOl6XWfODiUc1L4IIOqyztb0qgCBRElBYezWHS9uxFgcxlZoU20zKFsJXGVwlcZYz4RxCgwaJbzDYBRKokZE1IgQtey6rCqytEAbS2EqKgwSg2okiECA1XR2uhweHrK7t+u5vOs1zvrhvkJAkAX0u33KqiJWkjCJSBoJaZZT5iUg0UJRWU1RG/sb61DKD61VzvlpPdZn0056a9RmK6HdbmEr31AstXeHS5Im3d0e88dfUugcYzVOhdjK48pSitreNiSKYlarNQ8fPUJKQXfYZzg4ZDyeU1UFN272MbbAWTi6cUy73QWpmC6XaK0Z1s5+2jgqbamMpSz9tJSiLHn0+BFPnjwmCAJu3rrJ1ZXHeFutDtYaKm0otaHKPYzgyQyK+XJFECckzTZVWXI1mZKtc8q8IkuzLcVTSAEWAqUQArSp/FBlpzHWoesqzClFHMb0Bh1u3rzpZ1pGMUkccXr6nPPzM4Ig2LrJbRggW1qoAmcspSlYb5k39ivZ8kZ2bozx+/8aE2SjAnTOB+sNhKVUwKDfo9XuEMQxzVabbq/PYLhDWVgePfyCq/EUXVm6nQ69XptGI0SXmvlswnR6RZ5l9TADX7taXh4c14PwJnhvtBpbT49fsv4imbQG/tfOuZ8IITrAj4UQ/7j+3v/ROfe/++/yYNPZnMVywf7REcPTM758/NhPHclTXn/tNq/fu8PVeIw1mjTNvQosUP6iW8uTp095/PA+uzsd+v3uFo/G+YahClWtwPOm96YSjEYjPv7kIzqdAVIKrq5GnuFQlGhdEUYhURwjlWQ6ufLNmtWcNG3SaEQIEfsyRwXY2hYxjDwWu1otSNOSLCtotds4C48ePaIsC3Z2dhi0m9y9cUQrCYkU2Kqg3++S7g4x0jFezoniBpU1RKGizFOECLh58zbDnR6tVsNneSH0+i2CULJaLplezVinnhXiSygfWH3GEvuZfdaLMwLl/a+t9dCQtRZdQqX1FisEb44URht2Q/kV3K8sS6QKkCKkSAuqYsXV6MozYmqnPFyKNV61qKTEKYdzgaejWW+wb7HIsOaO1rzkOAkRShBGAR2l0JWhKAxSBKSpRghJoAJs4DDakVUFl9Mrkk6Dg+N93nrvLfr9HoGSjEdXnJ6c8PTJE1arGVHknyeKQozW6LKiKKraCMrzdp21lMb3GzZ4vVQS6Rym0CB8QJKBwlgvle90O8yWy61Uvtfrc3h0g7LKKMqULMsxlUUl3v9CWEezmVDokrTIKIscozWSiNVK46zEmIp2p0EjSej2Bty4ccN7dVgIo4TL0QvWaUZR/JyyLGm32xRFwWw2QUrJk6eP2B3uMBj0cAiGwz5JEhPHIWma1k3DKUGgsMLbfnpbXz+dpqoq1us1/f6AwyPJ2em5VyEi/GxRpK8ohVc+GqsJwxAVKLJ85UU6oUQGnvba7rT55je/yd3X7/Lg4UPmsznzhecUb/jCG/GLc4449pzkq6srz+M3lrL0HjJfx3m3PSjh521uJsib+pDQRnvzNuXnnAohaDbbtFsdTzlV3hSr2e7iEDx7dsJiuSTLitqwycePdiuhLB2zib92WldbKHVjOLZZvwgTv46NbyCaX7b+mYO0c+4MOKv/fymE+Aw4/md7LMgrzXg6Z3B4xGBvh6zMWRdrnjx/RJjAB9/5gNl4xt7ePo12yN7hLpdXY54+ecH56YjTkxMuLi5oN0M67cZWWrpZxrqtM1VVVWBDet02v/GdDzg4vEEURfzuf/m7LOYLup2IJWU91cURRXB+es5iPvPcWVsQxwHOeMOdMIwQIiSOI1rNNsZaRldXLJdrhgNNFMasVv5m8C5cBXd/89sc7A8pu03GVxcs05Q333mbvf19btx7jSoQ7F0eM1/M6TWb5OmSyeSKG0e3aHcahJGk1+sCnkY33Nmh2+7z/OkLPvnIsJhOqPIcpbwooyjyml5ktuVXVRZk69TTGR2EUvnyWht0WdFstwiUQm864XXJWZYlm6ka3lQnJpANFBJnYDlfMB5dka1SIuVLUmcsKgoJoxCnApwUSFuh64zGCYF1oIvKb3QFBBYVSKRIaCYJujTe48RanK2ojKF0Ehn4oCpDiROOk7MXpMWavMqYzDs0W01azSYffPd9jo73ePTwIZejC6zxg1Kds94pzQiqsvBNUef8wSskURR4ybT+qgOgw6GNZTafkyQN1vkagcBQIRS4ujK4eXyMMSVZsaDIS/K0oMhLdGnIspS8dIzGl2TFmkBKQhXQ6yRYa9CVIYoDbt++zfHNA3Z2dmk2ujx7dsroakIUNZiMZ0xn0xq2MXXDDZzTBEHMerWg1UgIwpDVasV4PEIIiTYlzVaCVDvESchkNiNsxP5+LAqajSZS+iBdZBmm1aHVaJLEMdZA3PBuggiHMg7lFFEc4qxluDNksNNndHnG1fiSLM3qoRENusMuzU6D8XzMbDljvpwxHY/J195AajNHc6OA7ff7JEnC+fk5UvjhFELUSUVtWXA9U/Uwhg8sm4xVSkm58f5wDqy3GW53uwz6Q6QMabbaXvSzf8B0vmB0NWYynVJWFVKqetILtJsNsizl4nxMli7ZDF/WQuPzdrnpAm2D8XW4A76KiW8oh79s/XPBpIUQrwHfAf4Y+G3g3xNC/M+AH+Gz7emf+/tSYqwfKBpGEce3bnJw7N3EfuMvfxdnNUkrYkcOqUrNUf+AfjCg2erQavQo0g/Js5yqrJhNZ1RFynw299m0FIRhRKMdYmzOMk/RVhOpiFApAgXYkjiMee32Mctlx+NmNw4Qwk/iuHHjgP2dLkVRMBwO2N0ZePP0qwv+4Pf/gMVsRrfTpD/oE0QBTmviMMA2GsRhwGI+YzKeIJVid6dPHIdI4cjyJa2kQZZLVAmXo3M6gyGHO32+9a1v8x6O7/3RHzJodnjt9k1Go3PCSNDvt8mLNYvlnG63TbfbodfrE0cNzk5VzTbxxj+eauezi0obENIbtEtZ4/1LyqJCAEmcEAQRUq5f+gFfKxf1xnJRyi0WuHH2Ek4SEBAlikAE5GnurRwRVJXPMKIo8pCLLT3O6eomHBaLxRmLw1JVgsqUNEzIzu6QJG4wny64uBiRpQXGQlUanFNbWpxSEpxBYchWa1azCegCFYXESczu/h7HNw7ZGfT45nfe4+Jyl9Vy7X2S16k/eDa82foGd86iwoAoDonCmG43rs27JvXEcF/mZ2XGMl2yzJaAINc5QRQiVMDF5QVCClbLCdpkBCr0sJj2B1yarxFBkyAOt5WEqdkNrWYLn2B54VCv1+Po8Igsq2phTYh1gso41mmGsRWtVoNCF1ijGQz6tNpNrDM8ffEE59iKvITwjblWq0Ve5DQbTQaDPiqKCKOIyWRCuk4Jw5hms0kURhR5Tim8mb5xnmIXxmE9ds5hjWbjFVNUBVEcETcj4jREKu8d4yyssyWj8aVvzIaSvMrJitxno+YlZ3+TZI3HY8AnV0p6q9mNVPw6D3oT+LZUt/oxVBBsCkpUGCGlIGk2GfQHNFtt39fp79JsNtFaM5uv0JWl3epQFhVp5ievKyXZ39ujKjIuLk7IijWh8mwfXfcrlPQBejsb8Wsc7Wsx88+83pzsF8bHv3CQFkK0gf8X8L9yzi2EEP8n4D+oP63/APjfA//zX/B7fxf4u+AzwRu3brJ/tE8YJ+zu7/G3/62/TZqtuXf3NlI4TFny4vEpo8tLdvf7tLoNOu02Ssbs753T7/Y54zlXl1fMQ7zunsBvZiVIGokXO0i1NV8x1tDvtXjrzddod9ocH+/XgP+GF6soipz5bM7e3k4NZQTgPGb32aeKQa/DvNshikOUUHRabd79xnscH9/i+fNTnj97wXy+RNdNqt1h39OeIi/9rcqMg8MDPvj2tyid49nJC/7z/+I/p9nrEraafPb553zrrfdoNtocHBySZnMq7b1BHjy8T5atWCzm9Qb2B0KaLtHaNzV8p9shgs3sjJojWjtzYb0SM6x9PNrtLlEYkmZZnVF60Qe8lK6GQUBRejgpDL3dqHMOKQKUdB6CMF7qXUlLqQt/E1KCgKrSFGWJdcazQqRvRjorkIHn0BqtKfKS+WxBlhYsF0uKovJDDKxDV5Yo8jaStix9sA4CosQ7ilUC8uUaoQRLYD6d8vTxA1QAjUZMu92h3er4AaNK1q/BvnRiMxVS+XFhURjianvLRiMBXJ2xhl60kGdcTka1kY4jiEKqqiJf5cxXCz/PMV8RRwopC7T2lZ2QsjYk8ph3EIbe0lM74ij2VLOaWz8ej/nss88Yja64OLvi2bNzvnzkHfJW69Q3q4BVuiYIFFKBwVCUOVZb0nW2/eyXyyU4aLVbSOUHApRl6ZkcShKLhGajyXK5IhKCdruDEB7amM/nLFdrtHUUVeWVlPjAJ4RvpEqpKIqCNE0xuqLRSEgafrBxFCYAjCcj0jQjCEJW6yWmHqZgMVuow3P1K9I0fUkVxSs0gyDcQlDXMenNuj413BiNE6KumhzHx8d0+32CMKTT7tBodgiCBvPFgiDw3hpBoAhDgRgKqvNzTBiyv7/HajHl7OwFabYiTkLfULcWUzNKEGrLRd+8mq9zwjf/f/3vP0/Q8hcK0kKIEB+g/+/Ouf+s3gQX177/fwb+wS/6Xefc3wf+PkCv03W7e0OkFKzTFXGjwc3btxDCEUcKnKYUnn+apR6cr6qKIIyJAkm7VZcs+Ayv3e6CEBSlwwhHUXpRRlmuvYIIX+7funXMG2+8Xhsfteh121uQPwhU3ZG2KOmI45Bet0O2XiNrF712s0G33aTd8hvQVAVRMPBOc1JyfOOIe6/fpdXu4BxetqskvX6HZhxgq5yTZ89Yr9dMFzMGu7vsHezRbMZ+1JYSRJGi3WkznlzRakfs7+/z2Wc/Z76c0m436fW6jMcTHj9+zGg0ZjKakC7XxCokCPxsQ4Q/COMkxliHVAIlRd0x98MMnPWTKJqNhsdia+GFEHJrCrOBi8DfBGEYbmfz4SCOEt579w36Oy3CKPalpZJkeYoIJHGzUQ+fdVjhQEqMc95kSNVQS33NtfHuelIo5tMleV4ihTe42XhoaO9+g61KlIOGUKhGizgIGXTa9IZ90iIjLUuKsmJ0NcUITRgFtJpNhr0hAumHNkgfYDxftxY11MMeEBYlA4qiqBWZLyeoG10gI0XUiGj326RZRpz4wb6V9gErkJLSQVlpwiAkjGJcUbFcroniiO5uFyE8x/bgYJ9O0qTV6IP1QWixWNFsR4yvxmRZgS4t6zRlvph7dVtZIJRvQkoVYm1FVRmCMMQJmC+XNOKGHzacZduDaLVa45wfOFDWFgrz2Zz5dI4KAlqNBt1OF4FjfOUz66qqKLX20EG9D7Tx+7rVbCAQtamSIc9TVKDQqfaj2KRkMNwhCiPu3/+SLMs9W0MFxEmMzsqvZMjXDZi2f6zFiZcDXjcBbgMZbJShnlXiatOsEhUEdLs9ut0B7XabKIxotNpEccJylRKGlihu1P7xiiDw1WcS+0qi3W4xm1xx+uIZxhREgSAOvaLZG5bVvtHO4mrP7I2dwnVHyU2FcD0oXxfW/KL1F2F3COD/AnzmnPs/XPv6UY1XA/wPgI//6Y/mGI3O+ezTT7h55zUOjg7Z2d1BSIc1FVJ4UcHp6RmTyyn7hzu0e00ObxwThiGDfp97d+9RpEuszRHKcP/+fdIsQ6IwlcYKW7td+cxRIFmtFnzv93+Pbr/Pm2+8wRtvvllPW/CZUlVVZOs1pqp4eP8L3rj7Ol8+eMBoNCKJIk5PT7i6uqAoMt8Nx2OlV6NLzs8v2Ns74N133+PwcJ84ihhdXTKbTbGuwXyx4umThzx9/JjZfO4DUFWRVxUiDMguSxZpSpmvefL0Pl/eLxgMurTaMcvllEYzZj7PSJLIj/kqCk5ePOf89II4CNnf2fPZQBQi89w3CYMQ6epJyjXtbIMBVpXH+HwGEXrXLiG+wqGOohDWL4UvSimP3RpXDxEGpUJu3rrDdDHDAEmrhZETnHCkRU5eZjUfuqYdOQ/DCDzMsM1CrCWJQppxE104TFEiQkWA3HqGaOthGqctoQpZr1JMqel2OtBx3LzZ5uDoiGfnp2TTMUGc0GyEHqMvNePpzGeZy4yy8B6kcV0tGasJopBmMwEkReFVgEXurTeds1BbWrY7LfrDAWES0tRNBIK4FTObzijzkjhs4ppNj1HXNL+88JVPqEJ2Brvs7AzodFq89cZd3n3rLSQxn37yiKurmacjWsdiseDFySmzyYKT0xFO+glCQjr2ugOiKKLdafLo0QNmsymjkbd+1ZUmjhqApKy8iVYQ+QO4qCqywjMomg0fZJM4odFoeIreao2pNNl6jTNeEVxVFWXhDwanFLryFVdVFKhA0mjE6KoiiWM6nR7nZ6fexlMKsrTg/fffZzgYcJqeE4cRrVaL2dgzmTZWutcbbJummjEGJ/GsoZprfH024pYjXf+uMcazhZKIXrdPo9X2UvdWm06nx8VoxOjLh8RJmxs3b9PsdJB4+1uEQ+uK1WJOq5FwenrCyYvnGJ0ThrVhFA6rzdbpz+NfXqJ/fTrU9aD8dcvUDZ7+q8qkfxv4nwIfCSF+Vn/t3wf+XSHEt/FwxxPg7/3THsgYw5NHD3j//Q8Y9rvoqiKoVYFWW4IwQJeGxXzJ+GrMJx9/QqvTIAwT+v09DvYP+OYHH3D7+JCqWvNH3/99sjzzhHFr/UgkIYijBFtVCCPRZYVwgmbSQFjLH/7BH/CTH/2YRrPB7s4O777zLsvVisePH3Hr1i0m4yumgz6XF+f84Pvf5/Bgn8V8wWoxQ1cZ8cYDw2rPJrgasZgtWM6W7O7u0Ol2mM9nTCYj4iQkL73M/PzsnNPnL0jTtbcG1ZogjjB4tsJgMCBbTKmKgsOjfZzTWFexszOo+bM3aTaavPHGGzQaDT5UP2N6NaHSJcpJv+HwXiWVrrAbn13nA3IUSqpKg4MoiGjEfvZdHEWeW6qCawqpl5OcN46CuizJspQgiBEWHjx+zPBoSJRE9Hd2sQQEccQ6TymrEuOMbxpKb1hkrfA4pN3ckLYeieSoSstivqYsLVLEmMob8TSbbVqtJmWVeRMtKchSPykjcL63kWvH8/MLknTNqiophCBqdUiSqJbvKsrKkqeZDziunkQjfY9EiYgojmi32xhjSdPUwy1abxuKKvAzN6M4BukH2rY7LdIspSgzrPUih0YjIW4kqCig1eoQhjEff/QJRbHmeLDHN9/7Fnv7Owz6XVqtBGsd6/WS87MzLi4uWKcrzs+fo5Sj1WpjNMRxROkcx3uH5EXuPZyF4ODoiBcnJxg3Y7XK/BQVFTCbLdhQzbQ2hGGjFlRUfovg7UKjWoXnaZk563Vaz7H0k+c3o6CkFH64hKtHRJUlusyJo5CqyCnLgvPTU5p375CECUVW1HS6Bc87z5lNZtw6vkm73eHL+19uHyf4Wvb8dbc66obuZh9+nSWxobQFQYBUvkrY2dkhUBFJs02vP0QbzwabL1a0211UGLJYLQijkGZtORAoSNMlSgkuL854/uwJZZGjpMVJhXABVmsq7Ss+gfCHqRNY4/fH9dd3/T19PfZ9PbP++vqLsDv+kK0rxlfWn8uJ/kVLCBhdXrBazZjPJuwf3SBdr9DakEQh61XGxx9+wmeffkaxLji7eMFkMeajjz/l9u27vPv2B8Rxwny+YHT5gslkCs6X+FWucY6Xjm3C6/KTMOE3f+u3EELw0YcfkWWZl7GGIf1+n9OTU6SUNJtNlFT0uj0W8wW60t5oSGuiKMBajdElhfVSV1F3jwWC9WrNWXVCVZY4a5hOx4wuzzHOm/6LQFFay0YOo00FzlIWGUEcEAiDMyUEcPvODdqdFkEArXbTmws5j1UG+yG3bt3i5s1jjo8O+Se/9/sspos6A/GNw5cE+s0msYSBz4Q3c+K8OZIlCiM6nS7rdE1hLULW2YoUWzm4cC+zhKqsKIzAlSVuqVksV7xz+x2enF5wdj4mKwu0M4RhgHICU2kqrdHC+OxeKoqi9BXPNvOAojCUZYogqLFMSRDA7Vu32d0bMpuNQQjCZszTp09ZTmeYQJEZTbGcs0YT5Ck6ABlH3jNCxWgjWC5WlFmGLksUiqgevmq020qDhfSl840bx+zt7XN+fsF0OmO1WiOkoCxKVKjIypymbNLr9ji4sc/Pfvoz8iIjCBTpImVvuEe71+NifMXtvQO67R5f3n9ElRv2dg85PrzJYjnj85MvWC4nZNma5SJlfLWmqhydTovd3V1arYi33n6HXneHx0+f8/T0uW/GzS3pOuXycsRoNGJ0NUFrz2YKDVTCUNMdsNaX1nlRAqJuItaQgc6pgs0EE7etrvxAVUWe+75KeC2QGlNhdIU1GqcNoZSYys/WnIxGDHs94jAiXaWsV2uUCFkvVrQbbUYXVyymCxazBbrUnip3beo88JVM08MdHr7zE8Bf9lg2AphtIBSwt7tHt9utceYWSdLixdk5i8WSQEUMh7tshzEvl1hjuHP7FkJBmq4JA8XzZ0959vSJH8wcKJSAQHovaaGg0vhBuA4248q3XG3xZ42Urgfp64H7V4ZJ//NagVIM+n32dvYIVUi2SvmjP/wBr92+w9HBAZ988jG//3u/x5f3H1AWFdqUTOZjnjx9we7uZzx98pw333iTdL3gyfOnXIz8BHHjgjq79UHQCYupvFNblCT0el0++OY36XS76Eqjjebu3bsMhkNePH/Bf/WP/hHzxZx1mtJudwiDgOVihUQyvrzy/Nrcix6yPK+N1aHIc3RVIoVjuVzgh2iGPH36hNOzFwjp6A2HtLodbt66RZ6mLKXk4OCI8XhEUeXkRUan2aTXaZPlKRfnp1i9w3vfeJe/8Tu/w3q95v6XHtc7P7sgiVusV34iShwnJHFJbgpK7RVngayHdDpPOdtIaDcBUQhvrlTqCrTHJ2WgUPXgbFPL7JXyjIqN3DwMAgLlzYLCOCKKFPsHB+zs7tLv98hKw6ooKG3JG2++znA44OzknIvzS4o8RwpPWarKkuViSaX9dG5nNFIZL0ludNjZ2aM/GPL48WMuLkaMJ2NUCHt7u3T6A+4mDSajS5bzGWWeY2yFqUpirWi1ugz3djCV5er8knxVELgQGUmcipFOIh3o0qBdfZg7iXMlo9GY9TrDGEsQhDSbLdJ1hsPPeMzSlMqU7OzscLB7SL/To8hK1suUKIhJ84wgVLz++h2W2ZoXL55T5g+ZTydEKmQyHvHl/c9pNRMO9nbZGXRZruacyhHLRY7WBet0SbwQFGXIi+cnnMpLnr04obDee+X05MRz0ksvM86zzGPNKsBZR6l1rbarD9Za2r6ZCuIppL4hZ7QlVF5MslytqYqKSldoU7BRifimu60pmLpuTvv/t6HxEJnDG0Etll5YllWYwqJiOH12ShTFLJer2k7AV1OBiuog5iXdm6kmQeh1CB7nrae61PMQqffmJgmR0ntnD3d26Ha7xHFCGMVMp3NOTvxkmnanDwiMtr5CcN7hz1YV8+mEdruFEHBxfsazZ4+pqrK2PqiD6cYLWkmUCpHGe9TjLFJ4C1u9GcTrNsQSH7glwmPldexz9ZR1b4fwS+LjP/eI+8+wjLEslymPHjxG2IiPPv4Eax3Lyyk/XK+YTMc+g40inFIoG3LQbBKGIcvVgp/8/MecXrzg4GCPRbZmma4xzlBWlqL02WMUSmyNYQrfEaTZaPDmO28z3N1FScl4PMYBO3t7DHd2efLsGX/0/T/kj//0RyRJk3azxbe/8T7ShozPTn0WFgYEIiZDUzmJUAHL+ZxnT56wXmdUlaHd6fL82RPOL88oy4xmt0mj3eTOzmv8td/+V7hz8zb/5Pf/wM9KUzHpek4YCnqDDh988D6PHz/mybOntOM2Z4/PeHz4hL3dfSgVOodspfnii0fosuRwb49vf/Ab/PxnP2O1OPXT0iXEjYhAKpyr0NrfbT7TlviZj/5mDsKQvPBzBEWZ4yrPq46CgCxNicIAJQXGWQSmpqI5rK6orEV0IrIiZzS6YrFcEsUR+/t7qDig2+vSarU42DugGTXRlWY8HpPUzofz2Yx1mpLEMUEguTh9ThhGOBST8Zirq4kXMMTKe3bvDAhiPxlEhgFJp82qSJHSoFzI3buvMRgMscbSaLYosoLL9AU6LYnCkCSIkaF3s/MHkEQph60qrPE3jy4q1npNVVO5jLEEceynwztQDvrtDtJIvvzwAct0RbHWmBx0pOn3e1yOz+mdd9Fl7lkS+Yp+t0EzTtjf7fLO26/zl37rt4iCkJ/+7Kc8ePiAy8sLssKzU8qy5OTE+2N8/tkDn+E6i5Peb8LTwxQ4QVVUKKCsym3jUooAU1vQmroP4WpGhBU+gDtroR4yW+UVBQW69NhzsZ3OU7vVCYF2L32YX87yU2jrPFOmbvJeXo4pa/9nnJfDl85iKkez0STP8rpZK1EyquEKW6sVvaVDWVVenVoHdGEDXF0hek8Zh5QQxSG9Xo/hcMBgsEuvv0uWl9z/4ksqbYjjJjs7O75xbX0fxDlHq5GQp2tcqVnPFrSTmHSx5MWzZxR5BsJPXqqxMAwCbS2B84pUEMSRH81nrPVOkbVL4+ZA2dICEXVVQ90bqnnbv+6ZtMPTsn7845/y+WcPyfOSd95+hy8+v8/DRw947bXbDIZDtIVvf/e7JIlvbAwGfX74wx/w4Yc/p9FMOL55TKOZcHF+QpquEdrDGwiDNoYwkGgtanw68oyFqmC5XpCmfnz9G/fuobX3OPg3/va/xre/+wEf/vwjfvCDP+GTT55SrDNiqdgZ7mKNZjy9AjzvsjQVq9UK12hQFjnr9YosK1gsF2hTUlY5QSiRoePp00fMV0uyPKdfN32iOKLbPeLkpGI46NJsJty+eYcsy2m1Ohzs7TG5mjK5mvHJR59zMbri8MYNWq0uXzx4QLpaIKyl3+vR7XS5DC/rEoya6uYhDWM1OLHlLctSUFYvPXyl9MNmgyBAypcmMJtGzcZoaUNx8psdEIKyLLDGsFguWC6XyMAzXwIRkCT+/9M0JaiDfpFnxGHAzu6Q1167w2Q8YTabEEch6XLKeuU9nnVVUVa+uRfWlpxK+RLcCoVVktVyQRwokqBJVRUsZlPW8wVSBPS6PdbrNWVe+IkqQtKIvYpvvV7VE9g3gUfUjdEA5zwObqyj0oXfsAKiOKIRJyRRSKfZIhAhV9Mxo8mEsiqJGyHC1dNHEBRl5c2HMs8fbzYaRFIRRgEffvwhq+WCdL3mw48+4uTsYmvkZOtZglmW+dFeNXtBG02hc1rtNkHgGQxFXm2Vr/63ZC1Trmq785fTUNg00IU3F5J4y9mqKFlUmsVigXXO2wDXcNhmHxhrqYxnt8valGij/Ns62gmBCgKPaQeh9y1RIQgI6v5NWVb+sBeercMmI7YGV/rmXRhFGGcQ5mVzcJNoeSti/77iuEG/32d3d5fhcMjNm3e4msz4/PMvcQ76/eH2PWid14wLCRjStVdFFkVGq7XLfDbji/ufsVot8HCh/9it9c3KMAwotXfO8zCq82KXmn3ir+3Lwc6Glxzuzfdh+xd/9h9fXb8eQdo5Wq0Wf+tv/S2WixRdGcIwBqDb7fL63Tus1iuysuSDD77JYDBgtVrS7/d44603mE3/bcIwoN/vcf/+fZ4/e8LV6AprC1+q1xdP1QFI1BsyjBRxHLB/uIfRmqOjfRq1Z0Cr3aizzpI4CRjsDLi4uOSzLz7j1sEBh3v7tBsJWZVhitQfBIUhimN2Bjs8V89IVytUENAbdDk83Ecqi0UznoxwUmJMwU9/9mN67T5J0uSt22/xzQ++yQ9/8APeeectnj19wo3j1zg8vkkgFUWWs5gtePLkKZeXV2Rpzs9+9nNEELBcr7xZT6BYDpbMF0uCICKJEpaFH9fkN2hdgglJFEWEUezdxYzv0Od55g2ItuWsIYyjutn4kuJkN5uqFgkIQd3lVjSbTdI05fzsDKFigrjh1WcXl2Tpmmydk6c5Re7VfbO55v79L0jimDzLyPOcvd1dOu0uUoRkeUGlvVS53Wr5SefGEgjF3t6QZqfNeDomFZYwCbG6QhjBej4jjhq0m22KNOXy/IKixmIL63DGUeS+oVWWmqoyWGN9E0gF2wG91m2mTRuPQ0chYehViEVekC7WhGHEep3VzVWBrjxrRubg5guKsmIwHOKkZDKbEQhJICSdTpcXJyd8/PHHVFXFbDKj0hAEvlkXBP515HmJNd4POgp9oxKnMNobFikZIKXZ8vz9CDBNWXk1qbomTd4E08306i3ma3TtFbPpkRgsnh65mUsIPqmK6ok0QbiZ1P1yFNaGTy+lJGy1SOKY1XJJGEW+arFeCBMEXnnqto/qjZk2Vg5BFNBoJt6Lu9iYgFniIPAkAGvB+ek/e3t7HB4ecff1e0ilePDgIdPZop7DKbYe1llW1BVTQJblBIFineUEEobDAY1GwsOHD1mtVmyFYMZPXPKB1mP1UpaEodvG1jzPt3NDg8CPurvO4b5OxbuOTX/dle8XrV+bIA1w796b7OzuA4IPf/ohq9Wav/E3/hLOWT757BOGwyG3b9+kPxhg7MuL1mo0qaqSMApotpo1R9cLJDybQRFHIcb65mClNa3EsVqvUKGkn3Rx1pJnGdoYijIjKARllVPqnCxPCQJJu9MiiUJcIHlx9oIoDJnMJgSNGBkFBJGfEK5U4MUKQtLt9bh96ybHNw+odMaLs6eUVUpWllROYCrHeHxFt93HWsPFxQVVqdnbO+SnP/2QP/zeDxnu9IjjgI9+/hGrxYqr0Yjlau2HpzrFepmxTjMGgy7Owfn5BavFwg+abfqRPlpblMRjk1sXO7G1lNxgerPZnE6vh9Z+3qQQijDwDIYw9BlRGIZbg/Rt9iS86KXRaOCcVy92ul3mi5TleEx/2MXYgvH4ilBF9TRmLxn3lrKaoNnk9u3bWOeblzjLl/e/ZJ2uicKQZqvFN97/Br/5W7/F/v4uxzePSZKINFvxwx/+Eb/7u/+A4bBPWeScnCyJgpBGGNLrdAiDiKsgZJ0XZGlWN4IC4jAiqDPmDVbrgLKstlxcY4w/7D35C/Cc6rzIcJWl1Whx69YtnJPMlysePHqAtRVOOLQpabXbCCSjyxHlRhAkFc0kYZVltJstGq0Wq9GIrKiQwo//8t7LBUJ4BoaUAc5JnPN+FCoItqby1m6GqeKx0VpcIpAeL66NhDbL85lfzrK0G9MoZ+sKSuKqEglbuiV1cAmEqIO33M7EvM5TFsJXaUEQsLu35/H7MPRqR+2FJVIpTD1LMKztAoT1GK2HVPzr9Da1dRC7RmNzWMIwpN3ucrB/yN27b3B8fJOL80vOL0Z+Sv1+g8qc1WZgslaVes57VRUoJWqqbUFv2KXVThiNLpkvpmwal5vlFZ6ivlfA1OO+RM2c2hiPUX8P8TJAX19fVxle//cvW78WQVoIga4sz58942o04fx8xIMvH5Kma186xt6U/K133yWK4q3/LMBqta4VVLae2OEIVEicNMhLcEWGdQbHZmyOl+RmecYPfvBHfPuvfIvhzg5SKi7Hl9y//yVlWbKzM2Q6nfDkyVNmsznNdsLewS7LyZR2p40tI9arNWmZU+ZrnJS02i3iOKE/GDLc2UVbS6fbZrGccfnzE+arCWm6QEiLEYJ1VoJQtBodVCi4ml7x0UcfM+jv8Pz5CetVilKCxXxEu9moh7Z6M/YgCH1ZHgZYpfw0iNkcXWRY40fdbzbM9Q3xUpoq6qxHb2907xzmG6i2xtaiSH7FlPzlDbm5wQOgxijLikaSMBgM2NnbYTKdc//hU1bLM1azBUHkoaayKn2pHSjKMvdmTu0OvX6H23duslotOTs7B+tvzMOjQz/odW+f3/md3+Gdd98lzzMePnrI8+fPmU0uWa0m3Njf4+BgnziJeO/ttygLzYtnJz5btgVFXmDqiTzgg7KRG764/yNqhVpVlF4AFPuqwuJImglJ0vOGUM6Q5yVV7tkhWZbjnKzFGSFOeaWrcRHOQrrOccJ4HwghkJGg1BUXo0sWicen46RBt+9wxmfClTZobYiikEbsR54FKqw/Poe0Rc3CKL3IBuUZOxackwQ1U6Mqyppx9DKTC4Joe+8lsfei8NxjU1PufMlunP1K1uecw4na/rNy28N6M8T4+uDYbrfLar1mla49dl7kmFpkskmygg3rxjokfiiCVC/N8Mva0rbesX7PhQFhGHJwcMg3vvFNXn/9DapC8+DBY9I0p5G0aLXbpMW63vdsPT62zBHhr1ueF+zv79BqxEwmY54+fVxXTwYhXA0X+8nkHsvfVB6ebuccXggmr08018CfzZCvMzm+zuz4lXt3/EWXq7GdR48e0e0OuRpNCMOIMCxZLhZUSczh4RHHx8dcXU5wOMrK+8oioNvpEEYhWlfM53N/o4QxYWgJIksoY8LIYYsMhPC0qSLj5x9+xH/8H/8n7O7uEicJy+WCyXjCaDSiKMstZmesJY4TVqs12TpFBoL1aoWpDDuHBzgB0/ncvw9juPvGPY5v3eT3/tvf43J0SaPZwuaG2DZQsfCe0fM5btNQEBVHN3ZZLjOMKxlPRzx//oK93QOSJGExm7OYTQmlb1YB3vMZMM5ihXfdWi0y8rXPRNqtlh/R5LzMBmfr8tkrqoC6qvAZUFh79IZhCM5tA/GGolSDf1/hom5KW+ccUegriHa3QxgGTMZXfop1VRGqoBYQOZI4pihK0tTbpRqtsVqzmGs++mjBl19+weuvv86bb77FsD+k1WrR7XZrhdySqsz4f/9n/0+qsuTk7IxBv8/h/5e5P4m1dU3zO6Hf23zNand79unP7eNGZERkZ2dmON2lSUG5GFBiUoIBIEAYFWLGgIIBA2pSQiCGCDNCoCq5BLJAULhcVS67nFnpJJ2RkRH3xm3Pvac/e++zu9V+3dsweN5vrX1ORoQx6UR3SVf3dHvttdf6vud9nv/zb27scvfmHr/9g9/k6OiIFy+e8/FHH3M8P+Xb73+Lo6M7vHh5jAuaV7M5l1dXaOTGMz3OmsyTpMhYjGFTAKOCvEweFrnFBScG/qpjNBzSdjUPHz5kOt3BBYlhcs6TKcNgOKBzrSzPdCQ4KXJtdAQX8T4SvODeCsVwNIGQ6H3GpA46cYBdwHU1AAGPMmxplkrSeWKEppEw3aKQyS6WIQUE+03R6HcPSqnNjmBvb5+VvtokwGstUn3ZGXWbiCpS0QtR0kbKshTXu8TI6Kcwl/YPdddumgNjDYbt9QepZ42y0PS+A78xngHnUEbLRJdbdqZT3nvnHd568Bb37j0gzwc8ffyM01fnEA1lOcK7wGKxpPXdppAKUiMLw7quGAwG1LXj1q0jhoOM+dUl5xdnNG29WegZo1LzrjY7gnjtUJL3U6AT2Mq/r7/Hbz6u/92bh9/Pe3wzinSInJ9f8PlnX/Cd73yft99+G1CsVitu3jzi6OgGg9GQqBSrVcX5xZlQmboGpeTDruuaEDyPHz/m6dPnOBeZTHfZ2buJtRBUxemrjlmzSpvmwMXlFR999AlVJQ5x49E44bYd8/kCbTRFXtC5TgzXjdCb9tljMB6xWC4px0PKwYBsWHJ5ccnF/IpXVxcc7h8w3tnh+ekxWkHjPMPJlM5l2DLHKxm/xtMJt45uc3C0z7p6wnRnSFt7XKuZzS9YLAQL1UqWfsNyKMXDOSHRq4jVBi9AHtbmjEdDrDEiTU5ju9iEig9013WbG6pNHeNoPCbLc4bDEVXTpEVVS5YVKN5QSmkRyfSHq0IRjAQG1HXDyxfH2NwQnGy4XdfimpZxMUAnK8yWuPHu8EQWqyWDosAYTQiem0c3+MEPfsDhwQFPnz7hD//wn1HXa1y74vz8mBjhd3/nb/D+++/z4ukj/vN/8o/4h//gK0ajEZdXl8xmc7Qx3Lp5j4vLJTEqinKAmi8TZiuLHXpetjbkqbt0iRXRX1vaygHTNBWrVSsBUVo61Olwh970XWnFeLpDnllilI5qNq8TTpzsBnTyOE4LRdc6Ki/vtRhYeUw0KBRtl+htVZ9GL0rZ4XBIbnOiiuxMS1brNVWomc3m5HmBc0GuGW1ToQ2p2F8XipDgkUDbrhkMBkxGA4ajIavlkqYPZdB6Q8Hsr4Gk3ZVmKRlTZVm2waIBViuxqi3KktFwKP7elXClpW1Q+FSYfOfAewhOuujINbqdfFZKa0ajEXfvPuD7v/xr3Lp5m8ePn/D06UeAwmih78UUktynnsiy2lHXVYJ0HOPxiIuLC7797Q/Jspynj7/i7NVLFotZco3cvkfX4QjplKFfxMSornGh2fydHKoI6+ka5nydL93/Z67h/VXV/Mz6+M0o0kCdlkPeOz7//EvhR1rLzs4OznnOz854/OwZTedZr5c8e/4M5yRn7vLykrquUicRMUawKmNLjM3pfENdryXUNBHmtUpYYzA4r5jP5iwWNUYbpjtTQjQs52ua5gqlFIORLBPXdUXtWvZ291jUa2arBc9eviDLc9arNZ989il1U/H97/8y+7eOuLFa8PjxI+bLFVW1wIWG8c6Yt9//gEFpKcuCQTkA1WFzxc6eFOnReEjwMLuUpdNkMsE1HXW9Tt29sBA0WihCClCKosjZ29ujqWu6zqHQQl/McuGu+l7+nW0uDpU66Z2dHUbDCdXZq9cuoOsddAjCsVa631Yn0UGZsZzPMZnl/W+9z/PnTzk5PmG5rOV7Kc16uWKxntMG6cpU4vJOJmPKIufGjRt8/3vf4+pqxkcf/4TBsKBrGz76+Ce8Oj1mfnXJL/3Sd/mbf/1vcOf2XX76yef8+//n/xMf/eRPef7sKXVTif+3ksioGzduUdUtV7NjfFB4bRiORlxdzTaMAp9gHqMNRVFsrkcdxYRKqYxyWIiM2kTyIkNbiXqKPhK7wKqqCaFjPr+iamo6J4U/RI8nFWitUMFv6FdokdyHdFD2o7jrPC6K2ZDS6X1WMS0qhaJWDnKOjm6yXK6YTKa07TGX9Vwgkk4yGbU2Itf3Ee8kzqoPaxB+tFBfZXTXrNcVTVWRp7RvnaYzlCIk299t1JQnJggASNBY92fG+A0TqOuovGe1XAqmnWWoEEAbSAU+H5TETbMV5P3ShojC2oz9/QPefvttPvjWh0Qs/8l/+k84PTnlxo0jmWB6zrOR1+Q7CcEVv5UGiAk/98xmV/zar/8KeZ7x8OFXzBdXnJ2fEYLHpOW61tuf7XXcuMf+I1rLJPRm9yy1+GcLWPrHdUe869L3n/X4RhRp0g92fn7JZ599DlGoVaPRiE8//Yzf+71/ytnZKxbrNcpYdnZ3uHHjkIODG8xmV8znc/HzXS1ZrVbibKYzXL0iqoq2q1ksXuFDLZxg7/A6UDUdT5+ekGU5y2ULtDK+tnMuLi4229oQHFXtqJsly9UabTWN67i8uCAEtbH+LMoSVOTFyTHLpuLBg7e5efcOXitevHiOXRXMlzN29o548Pa7GO1ZreY8e/6Ei/MzqlVFXXfs793g5u1b7Ez3OD0+4+LkGBUCwYk2sWsbnI+S9eYTKV8rvBPjemNyhgOLdxHXSqEmJDtFL54T/cWmtKJZS6c22dkRpkfbpgJuk12pYI89Nh1CwPbjLQKXtAkeujg/5/NPP+PZ86dcXV5is5JMa+r1mqpeUPtaMgPTTZyPJ+zsTCTDrq24e+8248mI09MT/os/+D3mixmaQN0sqdsFe3tDPvjgHf74n/+Qv/fv/T1ePH9BtaqwxjAajrn/4D7TnalAFvmAJ0+es1q1OB/Zv3mDw4NDnj19Rtu24mfSY7zXljibZVjwslzynvWyxhQpdNeJG97h4R6ZtlydX3F4qFksVpxfzInoVFxJcIrHdx3a2+TrIAWjGEoY62K5pF7XGwhCa0VUAaMN1uZJdWdT9+vRBvYP91Da8OTxU+bzxSasQEQeasMyAemgjc0k8ikV3B537u1KY4y09ZroxCPFOEPTtWkpxsZPw3nxrFbGYKzdBMr2z3t9gaiTu2K9klgtrYUj7DuXPMHTwpoO+gAGn2T3iUlibM6No1t8//u/zP37D/j884d8/umXVFUtO6ioCIFNg+b6zEMDRpkNRh6CeHevVktu3b6JtYZPPvmErmu5vLzA+y6ZqslSUivLdThCHq8X4+vT5WuqyISD9//u+v/7X19fsvbv2897fCOKtNKacjAkzwtWqzURzWQ0RWvD8+fPWa3mnF+cs6oqtM2YL+aEEJhMphiT4X3g4uJim2ytNU3nhfuLwkdH086x2qEQcYdS4J1jNpvhPSlvDupKCtRqJUsHbTQhOkxW48mJGi5n5+zu73B4dCgcWhdYL9e4riMi1KFVteSrR18xnk75wW//Fa7mM37ykx/z4uVzfAx8/sVXWN1BdFTrJW1bs1zNaVu5WEbDIft7e3z7Ox8wP9zj5bPnnDYtdVfTbgyGHDo4WaRYyYObTqe89fZbrBfLDdcVEsEpLU2UBsHZPF3nxAHNdlxdzfD+MtmICn4HaSzeYIY9zUul7q/ftsuFmuXid7FcLgk+0LiGznmyxlA1K4L24hpXiCufMYrFcsZ8PkOh+L3f+6fEGKnrmtnsCptpppMBmZWkjc8+/4T/y//1P+Drh484vziXMXg8YTQc8b3vf4/vfu+7PHv2jB/9+Cd0LtJ10mEtVyvsvGQ0HVOWpXgreBHq9B0hsLnJNzh9nhFVEPm6UbRdI2GzvsXoSFu1qKgZDIQGVgyGnF9cih8KUpCNVhiVM8gKnJMsx5AohMPhCKM0s/mMdVXJJ6U1+A6sLO9a51DBMigHlLagbmv+9Mc/QlPgfWB3dzfZjUqWn0t7Bgl4kAKfGsNro7g4JHadY7lcyc/e1kTXbNKOIqCMCJlCDAKBINzlrCw2tLZeuWhS0o9MqFKoVBReu9FaWA8RcmtFjq4Nk/EY550c4vSwjGY4GnF4eMRbb73NnXv3mc8X/NPf+31OT8/xDtAGHxQhSMfdT3uoKDmZJsMaS54X1HUlfO+ux/kDX375Bb5rOX7xnPn8EqN7Dnlv/NUbkb1WqTYd8GaqYAuJXM8rlOcKm2ugvwl7yfibi8O+c/9Zj29Ekc6yjF/59V/n1379N8hMzssXx9y6eZv33n2XFy+e8cd//Ee8PDmWUd9qQoh8/NMLXhw/58bRDYbDAfkqo20q6rpCG0MXklLJeaIK5BkEL2bnw3xAbiWDb1lf4SOyYECzWtUEHzFWuJqNa9AmYgvFaDKmHBZSTOMld25MsTrj/NU5Rjuqdc1ytSK0mrZVzGbw4sWQb31wn/ffuks1m3F5csbVbEEda5rmirI04n/gwXtJoV4uVyzHK548e8zNo5Ybe/t8+OG3mM3m/PhHP+Gzz74gdB4XApnWYAzlYAAo3n77Hf7W7/wOn37yKY8ePZIbRcsSSFkZhyOywAE2Y1aWZagIXdMkKlrA6uR0Fzyd6xA0UhZVRZHc4hzYzCBvoufm4RHf/vB7fPzxJxR5QZYVnJ6+wndiFh+VvM+DyZRhWbKuFixXK7xzlHnB148ecbC3z2AwYDgYce/+HYrcslzNWK0qnj0/4fTVFYUdcnB0i9OTM3Yne9y7d5eoM37/n/1zZrM5Nh+BDoQor3tvZ5dqvWaxXNBUNcF7Kc5pSgA2m3mf0kaUNdhMQ7ohl6sFbSf+FQRYzCpc7HBtx3y1ZHf3AGMtWZbCbX1AQ+pqDdrk6GgAj/OR+WJF08p05NNSynmHRm5aMY6XkN8yM2gjnXZRFizmS6r1OqXJGLquD1hGXOmCR4qKKEJjotgJF7kPedVUVYVSfWKPIjOyK/Bpj1HYEmW0+I4rS24KirJAGTnkXSeHg82s7EacF/P/vtghboUxRkyWJQaRR9ZCgaIssD6jbZ1ErGWWvb09vvNLv8S3v/Ndpju7/OSjn/LDH/4JVd2S5+n1pM+rqlbs7EyTxagsUEU8pUSslOVctY56tUIlLnRbrYkELi9fUVULYvBEZbdYeC/Oin92GSjcaf1akd4mfst7HsIWt5evYPO1m3it/m/ThPEXlXH4r+wRleLh48dgC+7ffYvFeo1/8YLdvT261O0MBkOqesmqWkoUlgvUJw1VW7O/t4siUJQWowu64PEuEuoGYxC7yeDpoqbMBoxHY5SCVbVE60Zu1hBRKkcF6LwXqpNx5DoSgtAAJ1PL4dEOdZehTI2yC/7qX/vr3Lt9B6ssZ6dnPH78lNl8nriZlvF4B9ddoJjy7tu3+fzTIRen56ACeMhtiVeKs9mM0XBKnrV4D3XdUlUtzkUWVzNCDJTFgGAM2XBEnpZ0u0l5ZzPZsn/47W8znkyZzyUlxKTxWen+5E6nvZXlVE9vikESkMuy3OTHRS9GSpKs7Il42rZJHFVhHngfZKNeV7jQcXF+zsXZBaNylGhLDqK4gimdif9zG2lWLQqVUqkjg1HJaDBkf3efv/U3fodvf+vbKena8+jR10x3RsznC756+JCDgxsMhzu89+77fPTRp/yT/+w/4yeffrZZjDZNQ1kOUNoyLAeUg4FMFd5TV2ti8iFp04j52tgZ5PV4HF1oadp6g91rZdAYVNQYlZHZAhBpsNYZJrfs7ewyHo2pVmuuLmasV2v5+a3BBeh8wKexuW5b6lZ8IZSWDjVGT1SxJ9PQUx2lkIrgRmhompBpGtdSVxVN02640sS+gCjpXmHTWfd8XgktAAgicErFJ4iWGWssWZFjcktUEF1ivmSWoKGuknugPDnGShhzT+UMMaT3RWMzszkgnBPcWWsj9sMvj4UdlBeU+YCjmzf5K3/lt/ml736X+XLN558/5OT0DGVytIl4qWypoEZJyqkrrEnKSQWFlQ6aIHTCpmko8ozBoBQjqBBYLmeslgu867BGeOlyH0h0mvDCt9jxm6wYra9pBPqKjhx2MYpLJGrbRW+XhiTxV3KoTH7v/PxG+htSpGNksVjywx/+kD/90Y8ZDcYMy5KT02OMVrw6eUkITsbnupWxS2s0kdPTE65m5wzLjK5Zo2Kg7Rx106FR5CZjkp7v6vKCyXhCWRacvzpjZ2eHW3cPyfOCy6sFwSnaBkAxGOTkhWW6O+Ty8hQ78Lz37QdE5Xn07BXT8Yi33j7i7r09bh5NKWzOO+/c4jd+6/uyUIrJY9lDXTm0KhmUU7I88h/+P/8hH3/8EU27Yugt1mpCcAwGU8pysFn8xJAEOQF+/JOfcrB/yHy5xiTnuJ1ywHRnwmQ6ZjQcUlcNs6sr/uF/9A95+OWX1HXNer2mz73rRzCtjfgMO5+Ks910kWU5oChKER50KQ4pdV51U+E6h7UmSZPlwivyHK8CTT0ToxgFw/EQUIk/DCAYaYgCCTnXEoJBawlyHY0GjIcDvve97/DX/9pf4YP3P8TYoXDaqzVZrvE+pYoAX3/1lL29Q37y48/pfKBqZN9wsHfAYi0CGnHNS0kv3jMYDjZQRv9QSm2Ud00jJkLainBB/CFkhI+xnzp06k6FfdEFh9YZSmlWqwqrJKEnLwbs7GiIYgofgnijd10LhETb0ukAjFhtyXMNSrrpGLevs2dl9BLkEFqMzvAubPBqrcUro/fB6A/QHp6S7rAvJJGmEVzapp9Va5UMgwRt6V0PBcqKm2Tt0HWbnEvnPX3ej09qSCFpJz69i4nzHOWz9z7ZlcbNdQiKPC+4efMmNw6O+Na3PuDWrTs8evSU49NTqrqhKEoGg5K6aYgxENJ1F1BUdc1ytWQwLDFIkURFOkeiMjaymC4z6qai64REcHZ2RtPUKbhhuyi8HjiwvWe2S8Dr2HP/Z9cx5T77cgsv/mwq3nUKnvz6G45JAzRNnSTLitViiVGGq6sL8tziXYtLhH3vJfzTO48OkprhfKBae/AtioDrPNYW8uEWGXjPeDjiYHcPYuDV6SlNVfPht9/jX/83fpcHb73NP/pP/glfPXzCdLJPJLIznZIXhvFkgI8Nb39wg/1bE/70Jz/ExwU3bh1w69Y+V7NXdO0KQqBrOoq8YDgcodIINBiM2Ns7ZFTmZEbzG7/5HfYOBvzeP73BJ59+wvPnzwhR89ZbD9jd3SNGzdXlnNWyISiF0RmQ0bWBp0+OyYuC3d0DbJbhuobBaEiWWdbViqvLOS9eHBODGNTU9XrDow3XKFTGGLQxuKbd+HGImspvJLPCQRdKUIxBfBfkXtvKg/tlm0JgARVo2gofHcoouuCEBWAyoiSzopUYAxVFxr17t+lCzWx+wXhc8u47D/jN3/g17ty9iTEKoy3RGCYTK+ntVjMcTJjNZlxezPmP/sE/4qc//YTxZIItDK9evWJZraW4psVY3UmkFTFSN8Ixvi7Mue5nEULYdDRaW2xmNtzx3k/7+g3XNB1N1wjGbQ1t7bjs5hBhkA8oi4LxeMpyuaaqqwT1SIHyXmAmEVp0+ODIY8ZoPGKYjegSr7lf7jnXSQKLksLuiEQPRssCtywtxrjEvtGJ395tmAiQnAvTy+9/5qIoEnNHrhM5jNJi11p01u8zUmZf2IqYlFJiep98OLRS0hjGbRHy3m+gjxAiISqyhM0bYxmPpty9d5d7d++zu7NLVbX80R/9c8rBQLrm1K0OhyPm86WYF8WYjgZ53ev1mrqqGA7KTZfrnGO9rPChZXd3wmq1pGlqFos5q9VcEmrU1uekf/RF+E0J9/Wi/Oa1c136LTfG9vl+UaHuHz2N7+c9vhFFWiklrALnU4JElMglFYjRYY2ibSVqp2lrSe8AgnNoA2WZM5mMILRE1xJ9ZGe6w7179xmUI85fnbO3u8PNoyNevHjBYnGFDy2owN07t7lx44AitwyHBXmuyPOSd999ixg9s/k5+7u73D66yeHNCVeXD4gxkJcW3wZ++tEnzK+ucJ2o/G7dusXtO7eAyGg44u69+3RuzXztaKtXNE0kLyN/82/9gA8+fIsf/ehPOTk+ochLbty4zWJRMbta03Vr1qua9aphd3rActVyeXnFndv3GI2G3Lp1xKuzE6zNKMqSsxevUkTQlOFwiE/pGVpXG4hDa01MF6VzHc7JIkgpxXA4ZDAYbvC1vqBba3GdjMkb8cGGMiTb867rCK4iqkDnG0JMuC7pQEjm/gqDUmJpSXDs700x+ZRIw+1bN3jrwV3qesHZ2QsG5QDnFLPZIhUBcVLL81K66/WC45fPcK7iw+9+m8vFjFcX54ymE4rhgNlsIT7IUdgEIS2C1DUDov7mux5Cm9kMpRU2E4sBY2yCGsKms+onjOgjOmaSHNNK6LFLC9bGSKIQkLwfBE4KQSLL+huz92zuYZa8K3ApLUc+B4+18v7H2C+qpAO1eY7CbIVNISQ2hviwoMBkGhMzVOqGY0hqP3ooRQJiu1UjfuZEQnAUyQYganlerTQYlfD7xF8mOeAFUWBqm3Dd9G96NoQywleum5bWBZS27O7tcOPoJru7e7zzzjsYZXj06Akvj4+ZjCfcvCXmX0pJuECR5QyKQsRP8umlYgpd17BarxgUeVKxyoHWtML3h8hsdsliueDi4jzlf4K85SEl33BNQbs9yPvr5M0Dvb+frhf068tAgTq2X9/XuTe9O7bWCn+BRVop9QhYAB5wMca/rJTaB/4e8DaSzvJvxl+QGG6NRLe37YoNdB89bVexXi8o8yS86AQDyzIJDlVGYTLNO+/e42/+jd9mMiq4PD+layqGRYnWhsuLOWV+QJ4PWawuWSwvQTlsHlmv53zx+eecnp5ycnKMNQpjILOayXjIYFhgLQxHBc8ev+Tk5AVdhO9/+9eJKvLoydc8/fqU4+OXDMuSO7dv4drIfLZOUuY77O3sY/qEaO9ZzJc8f3GSFjmeg4MpF+dnfP7F54Dl6OhuYk5kQC05dF6oWMPhhPOLK0JUvDeeYKx0+rt7E8phyVv33+Jw74jzszN+/Kd/Su9DoZRK1pqyQGpdR1ithEedRrjhcMhkMpWQ2BSnZIwRcUTcFufr416WC+9cIBEAyZNcrdd4H9jf3+fyQrDxdK2glMYoTde1XJyfcefBLb733W/zzrsP+PBb79Os1jx5/JDJeMxy0fH551+ilObtt95mNBqzWjXUVUWeRyZjy2KpePTka5ZVRVbkZEXOuq5ouxZtDCaTHYPgyXJd9Tdc78txfUvfY5HeBdqmw2YxdZFxs0jq6V51Lda31mSEGNAxqRe9HAhB9QedSUtYLZBBtAwHAwDmi0VK8Qg451mvqySuSaZAGIgaY01SkCYZcVCEqLBaS4cexLSoD7ZwicoWorBIUj8sFgkxCP85epSWn6frOmLrCcFtVIQC6bSbblahiMElbnwqXAi7Ir2DUtCSbYMwo+TTDwgEFJXh9q3b3Lp1m4ODQxFPVRUPH37NYrYE2MSLjUxGCALfDIqCncmEuhZ2k0o88x5fn8+vyK1hUJapAREBy2q1oGkbTk+OWa1X6bOUibHnTZMYJf3h3asmgdcO9Ov/v244dZ2K9+bjzQ76eses072j1C/utP9VddJ/K8Z4du33/zbwn8YY/12l1L+dfv8//XlfrJIePwRZTBEDSgWatsEaRdc12EwzyDJuHB0y2dml9R2ras3u7oT7D27z3vv3uXPrBt69y+ziFT/9yY85O7vi5YszQjCU5YTLqznnlxcE7TG54uTsJT/8kz8hz3IuL+fs7OySEtQ4PTthMBjQtdK9v3j+COdbpns7DPMbYDVtVZDpfXRYcvLiHBOHxJhTFDsc7t/j8OAumTG0nePli5dpNM2p1g3zxYyLi1OePX1G04SNFeWH3/qQ50+PWS2fyrjtLOtqTVlIZ9J1jhcvX7Jcrrh//w4Hhx8yne4SQuDDb3+H/Z0DLi8uuLq6wrmOEDx5llHkefp9EKpgFCbJdSqdS9FQ/QUjmKXFOIPz3WucWZ06ZKJKnZ2wIJq25fj0lLZrycsCk60T5VFoUjoqVJQba7lcsDv9Fr/0/W9x+84RO9MJl13DoBihdeD45DHPn33F/sEBw+H77O2NWCxWzGYLum5FXkTyPPLs5JiqCzRNy9OnT5MQSpaUfWKH0gqrNBG1uQHfvGGud0WruqJuGobDIVtFmfz8ZVkI+8VYBmWOUQI39VJp7wPK9KIfIJkhDYeFRDplmuFwQNd15E0mPHbk/VdRbaLEVGYwNhUOdw3DTK/ZmkxizBA/jBDT0i8zRMQfOnrRjKioE8fdC2/amOS1IV1cUeRAwHsptE3TyPNphc3l+6jYw0IJPokkXrbeKBtDund7WboP4mIRIuzu7DHdmXI7FegYFS9evOT582e0nZMDSSlW65rBqqLIRVyklRIe/GjIpBqxWEkyjk0wHTFQ1zWnJyfs7u4wHIrh2nI5Z7FccHV1yXK1oD9Yto3g1mK0/33P9wboBTz9tXI9JPc67PEmPp1+82d2gW/6eGwx7v//FOk3H/8G8Dvp1/9H4B/zC4q0d46ua3HeJZGBcDPH4xGHB7sMSstwVBDp+OVf+S4e+OrR1zx9XjHdG/DW23ewGZydH6OjQ6mAzTRnF+ecXVywWLQEr2nawLqu8b5BG4UtCk5fnScqT8Mied8WZckXDx9unLxiCMwvLiDCzTu3mV95zq6uOL86p2krrmZL2tbzyizQuuDu3XfwneXVyYyiFEzzqy8f8/LlKTdu3MJ1nrIcQJSuIc9yHjx4wIMHb5FllnffexfQvHj5gqvLBatlK2yLKPFObec4v7ikdR3T3V065wmh48svvqKpfspXX37JarXe8FWhz6HbRoj1PNn+Iuxl4FvRRKQsSuGVsk05luViKTegD8SYxAJaE9E0nePyakaWZbjE5XbBvzYSei+CgdnlnE8//YxAy8X5EZPJkMlwwK1vfUiWGXanY27fPWIymqSU8Y6izLlxeMjF+Suca1jML3GuRatr9C4SlOHj5jUD4pUSr1Omtv4V18fQjSAjSbH7jrt/7q5zyeDnEILi6uIK36W/16JG9L4DDZnNQEOIjrYLm4OyrsWRMc8ziP2Nn8yDYm+HqYWxkqYuOSiSx4iyGC3XD0o6bZP+DUolJ7mIUoGyLChsTlVVGCOBwn1R8N7RNNtUEzBbLBnSe6DS900Qg1GQFto6FUtZwHlUcAmWyhgMR9hc4JuDg0Omkym3bt9hd2eX4+MTnjx9xuXFReI4i8S691teLlcMB0PKZHBllKLMcnZ3dkArOucwif3SdWEzAUGkqlbM5zMur86Zz66o61rYVImp1F8f1x9vilOuH9jApkD3hfhneXS8VrCjSorV14v5zzJX6hfxM5Y/sz7+qyjSEfiHSqkI/O9jjH8XuBm3ieHHwM03v0gp9XeAvwOkTvYyyZhh72Cfd999h/v3bnPr5gH7e1Oadsm6vmJ3f0TrHONzy3iaM5kWTKYl88UFrql4+8F9yjxDqZyrqzWXlyuqGtpWEaPGBSuLx86xfzim6eSiX1U1PkSGoxE5pSxNrGU2X4h9Ijnj4YhJuUemhzy4s4/3hh/9+Id0rmYwKGnqiCLHtfDZZw/JUmzSzZtHjEYTTk4+4uJ8RlGUvPPuA+q6ZjAYMBpMKYoxZVHw8OFXhBB58NY9QnTUdU2WlSxmNSEodGnJEyRRVy1/8sMfs7M7YTIe8OVnX7KYX6UkDOl4nPeotk1ez/0pf+2TI6aNu4yoo9E40aPER0HcyvSf2Wr3o15/4QvHWwrgq1cXHB4eSHfuvXR1ym8WUHIIiB3oxfkFn37S8OTJV9y8ccDtm0cYpVguFtw6usfOzgHz2ZKHn3/Nxe6cnb09nj5+wu///u9xdnqOwkh4bjHirDvHOelwXSuhu8EFok+dkQaddmdv+vxev/FCFKlylg7pPny194PoXd4kQ7NNwaXiehdVxNicSKQLHUpHMVaKQXyxk5+1WIJm5HlOXbe4XvwSZeqwRjB8ATeVFPLEmJAPQNF0XcK3Be8W2EHwBWU0EYEmirJgZzSlKArm83lS1rH5mXoBTz96k96fHse3mRUbBeQ1Gt27wLFJH+mhDp2gy8FgwGg8ZjTdpRwOObpxRFGUWJvx5OlzHj95wmolMV/GWLwLKSEm3Y/riuVqtUkCQkGZFxSDkqwsuLi6oK7WKRfTs7O7y8HeLqvlktNXp8xnVyyXM1zXojQY1Oa9+1kd7XXO85tLvOvF93qBvb67ebPw9kva61Daz2Z5SKPzF91J/7UY43Ol1BHwHyulPn39RcSYCvgbLy7+XeDvApRFGeUCdBzduMEPfuu3+Cu//Vvcv3cbaxTPnz9iNm945/0PaNySqBQu1mSlIS8KLi5e8WQxo2tqDvZ3yPducH6xpKoCTavx3iJ0UZNuRgux5c7dd/il773L6fFx2vquhJM9HFGWA4bDEbP5AtDs7u6yO5pKjlzVcXTzLi5EvvjyS+YLh9GW1apmNl+yXK3QVuhMjx49YrGYk+c5H3zwPsfHrzg9fcXu3oR1VTGdTLl96x7nZwtOTk5Zr8XB7OjoBrduHbJcLnCdocgaymIEGF6+PJYLGsXl5QVVVXNVZIxHBUUmuGeXmBvBe6IxRBKOpjVaTLZTZ731O+hP9L6Ttr1lpRFxxpYjqhMTJBd/iOSdHYOCaLi6nIkzYZalCcATo3B9tQafaGlZ58mMLL9WizWLIqetxEPi5OUpf/kvjVgtav7gD/6IP/njP+XWrbsMhiNWywVXVxfcuXWP27cildcsq5aL80uCl4Wd6ySAWLjiiWamdGIjXKNLXVsKbcxukA5S2+uBq3+WU71aLmmrhhg9RWHl3ytJbQl45osZzndYm3w6AhuPDnn/rltnguqXs8kiE+8JoYdhzKagyWsScyZxKAx0TqTPWSY/q7EWZYDMkhc5aPEdGY2HyXhfKqz3bvN59wKT6yUqBimeeZET64hLUnnihsgN6edRiFx+OpmmqLQx4+ke+zduMBwOubi45LPPPuPlyxOUSoe+kn2T0XZbDKNM18vlkmFZMhmPRLVprexhGFA3A5bzOQpZ1h/uH3B1ecGz58+4uDinbWqIvifDAf11bq7BFa8X4+s4c6pRrxXP6zDHJsXnjeItF8nrX399UrtetK9fS78I1/5zF+kY4/P0/1Ol1N8HfhM4UUrdjjG+VErdBk7/Bc9Cbiym0Ny+dYsH9+9z59Ytbh7d4Mnjr3h1esLRzT1u3DyAbARoBuMSW+TMF8s0Xgl8EFRG3UZarzHZEGNbmlb4wb1UFSLWKvb3dvjuL32Xq4tLdqa7HB3dpOs6bhzeIM8K8jzn4RdfkhUZ49GQgMhsl4sZz5494fTsVFJAImgkjmk6nTIcDajrNZeXF7x4Kf4FWhl2d/d5+fKEr796xOnxMZPpkA9+40Pu33+Hy8sfU1UNNjOcnZ1TNxXvvfsubz14i6ePTsmU0AibpqOta3G7m06ZjEes1xXL5Zwyz5iORkQf8colmlSyW3UejGJQloDaSMu1lqVhlmXoZLYjRlciBJCFEa/Rr0DirIzJRRkXonR/WYkxlqurBQeHNTvTPYQbHdHRp1xEhVeKiCVES4w5ZTalaZa4RrE3mZCbQkJjX53x6vSKH//pRxwfnzGft+RZzs7OlKIYkWclPngGec6r8wWZFQP/um7IbEZIxScl8OFD3KhLTU97EprDNUxa8PYIG3yyL1wxBoq8oCxzUa8CAYcyEiShgk6Fr5HFllZoZbCpmGk0JhNJdNvW+BDIcpFxhyg+yllmUUqCV7u2S/JzMZeXJZoE9wpNTnImBcQOZFbS1G3CspXOxbvaBlovsV2jbEDbWrFG1X2HB70QRiXLBEjQg1YMyoI8zwjOSSQdCeem54DLO5wXJdOdHQ4Ojtjb22MymTDZ3UfbnGdPn/H4yWMuzi8Si8uKN4q2uM7hU9dPjCgEamqrisV8zqAo0EVO5zytawnBUxjDznjC3t4u+/v7vHz+nC+/+IKr2SXeOSIB1bNcYLN0heudtDQX/aNvQPqD+03q3fVueMviECqgdCBycKl0z2y767RITaKk/ntJ2k+CjOzPL8V/riKtlBoBOsa4SL/+rwD/S+D/Dvx3gH83/f//9gufKIreRxgIgdVyLoZD6zmPH33JyfFL9vaHeDqUFnpSOSrFlW5db/yjD2/cBJXx7OUpi3WDsjmt97SuQz76gCagVIfWntPjJ7x8/pyzV2dkmeX9994DoF5XjAcDmrpmVJa8/957VMs1y9mcpltSdy2vLo5ZVxW70xE7kwHD0QhlYDAYEaPi1dkFi/mSt956i/FowlcPv+bF8ysuLpZUS8dyccb3Dz6kbT2PnzxhuVrSuYB34ke8Wq25ulzg2kCzbphfXJGbHB/BakNmFMF1jEdjRqMRTVNRVTVVkafFUJb4qXKDy0W7ldN6J3zToiiZTCabpVPwkbbrcFEYBiEtU3obSgWJ4+qw3qOU3XTWISACD9fx9NkLbt06wmYZTdv0jCx84vjKQaGYzxvKvJOkaJ8zGe5z/95bHBwcMJnusl457t17C6OG1JXDOU/XRbJc8/TpC6q6oo6KxVJUbN5Hms6JklGRRBg9/UyholShoJDuLDnR+bRkBRLHXcyphD8cRDocxAhe46WYGI3NpMC5piE6ueFCGwVbzjO0soSUBhSSyKltWjrXSriq1dhcE6Ng//nAYm0hYQy+TT7QTl53VAlq0IlVIngmEZRRFGUOWop0iPLzK60JWhLYvbYiRAkdbedSQPFADk4n9rc205RlsfmsrdWMRkOs1oyS53qMgXIwpHNeLGGtoiiG7B/c4GD/Bju7++wfHFAUJfP5iqfPv+L5s+fUdZ2WjSKkMjJWCQQVAyq4TRHUyFRSrdes1mtMlskYFhVtXaFj5O3797CZ5cWzZ3zxxRdcXFyQQHmEFy4df4wRz+ud6rbDvU6D2zI53sSnr39dP1EaIxaqPgai9oliKs9j0uEve5seWnudE91rE5TaOjD+rMeft5O+Cfz99E0t8O/FGP+BUuqPgP9AKfXfBx4D/+YvepJIJChPWebcvnOLcljy5NljrFG8PH5GlkE+zPExcvnqjKpqWa0bjo9foZXQdEIIOO+4uLrk6ZOXPH76lIuzBXXTpO5Ii22jdyglScGLxYyziwvGkzG3b9/mg299yHQy4dnTpzz6+hEvX7ygHBT8yq/+Mq+OT3n09dd89fVXrNZrlqsVo8mY23fuEJFQAB8DlxeX+PCSSOT2zXf5zoe/ikbz9cMTzl5d0DSRQblLXip8ULx4fpzSmBXG5MyuZnSdx7Vi2Ro87Ax2GQ4HXF6co61hZzomRhk954urtEnPMUpRrSvppFCJvZHM1o0RHm/yShYYQDMYlOR5zrqqsFmGVkpwaJGd4Z1P7nn+NdFHvwnPM5t40FuFlveSElNsDgyLzTJsJmnbLtS4zhNipKoaLi5nlHlG17bs7iz5XjElzyc8e37GetXQOU3jFMuqY72qcedXDAY562rGuloRUkq1SuGfdVWJBamWAtrn9PXKPIhoFbGZluUbEj4A/dKwIdIvy3zqxuRma5uGOi3fClPQhwToNK6DkoYqaqJPh5LzOBfSYedSUhCpaxR4RCmVAl9jCi1uaLoqUcTkcFEo8GFDeeuXTvJtpQj44JM/i3CzpRAkn40gIrC27mgbJ/7ZGoITyMoHR6ELhsOC0XDEYDDAaOF559YKbU3DuqqxxtAkWfjBwSF7+4ccHB6xu3PAeDLFhcDZ2TlffvkVp2cXIj67xgmWCSUmJ7zkf52qAWx/nhA8s/kMNIzHE5QSdeCNW0fkec4nP/2ELx9+yXy+oJe998/xiwQi1x/Xl4S9erAv0m9air4Oa8gkJrh8D+dJN66RkGZjXk9euQ6fXMez/8KsSmOMXwG/8jP+/Bz43X+p59IRk2ve+eAdfuuv/gBj4OryjGenj/m1X/1Vbt+/yWp9jjElu7sTFouXLJdr6cCi0KLatublyzmXF1cslytmsyt8ENetIi9pmyplH8obs7u3z3sfvJ8Wle/xl3/zN+SDNZrnxy/BaOazFZ98/jnDvBCs1znW1ZqbN4+Y7OxQlgU6mcJcXc348uFjXryYsb9/wP405/R4xXKxYH7ZMBrsURbijT0oC7yLLBZrZlczsrxkNJjgWulOqnWdzGIiB+8dsrMz4eLykrwomO7scnl5RWk08+WK5XIhY5RS+LbDe0WR5a/jYXo7VmVZDgn/HAwkVSOu19KRpa64l0p3yfmsHwP7LgKEGqX7zq7H29LrUEpkwEopyrIkz0XFGCAJDqS7Q0HdiC94XcPDh0/xnUjqX11c0rWe87MZTRNYLCpc5/EhHbRa8ukCEWUMWZ7JzxWcRFwlKps2RhgO+QAVRBLvfYt3TcKqe3zwmpDntV/3Y7HfOAeCwCdd53Cdp2l6znk/LvuNx/GWGSNfr/TW86Ft2w0LwMewYdLUdUMIDvGIEIMjEiShE36e7jVgi5u74OT1apK6EZyTji7LBP4wVmOjFHrvXJKPB7quIYaWEDqCbzE6oNPBX+QFo9GQw/0Dqrrh1fkFrgscHh5x//4DdvcPme7sopWlrmsefvU1Z+fnXM0WSGxXwoZDz1tX+F4KHROEomW5D8KKyfIMlAjZ5vOI8x2HB/vcvHEboxUPHz7k4VcPmc+lu79OgZNL9Ocv4+B1XPjNIv3mv/tZvxbK4TU8/9pnrWKQQy3Z/b7GBEn0vK7rNkvruq5/7uv8RigOZfO9phgUoOGtdx6wf7DHT3/6p3zvV77H+9/5gLOLE9Z1w97+Dl3ruDifs1rWFDlMd3akA37+lMvLS7wTzK5pO4gmsRw6XBqBewJ+ORxy685dLucLHn79iNt37vLq1Ss++slP+OzTz4gh8vT5C+bzFUeHh1ydX9B2HfsHN/mVX/t12rbl5PSU8XRCng1p20tmF2vWlcfEIc8ev+LFs3OqakVdr7lxdMjO7pSryxmdCzSNFOn1coW1DQu1pq47qrqlKEd4L3Sii4sLovOMx0NGkwmTyYT1ekndNGS5YTIZSlxQ61Ax4qLCGsEsew6rMAAkYqlPHel/b4wR5kAIGMRSUgoeG8pYSBzY3nwmxihp41mWTNLlYmubliwX6lrTtCndZft9gooMJyNslklHlxgPbd2y9p6rywWPH8sk4pQXiCZaui7gumQmbw0uBBQRmxeYTAvXvk/3VmLY33sShyi2o9YIn7vIM0JUrJZSpKXDF+c273uzfynCIXh6/2d6pZ0Svvp6XdF1IS1Nk+eHMnQpWIFrLIB+GbgpBlHez5h2A2iFsbKgM1ahdMHEjGibTmASL0yV4IUtIp4bJi3+kmItsQkkDkImoh42lY48YoxNvhQeV3eJjaISBU98Qdom0DaWi/OWzGa0TctaaXSM3L59h8wWrKqW3b0b3Lhxk53dXUbjKRF4+vQZL49PODs/x/u4gRmJonaMaXqIMW68hWT6kP/6MISeTdSHS6zXK7SG8fgeznV8+fVXPH78iNVqyYa1JLyda0ykREm89vgXddfXqZn9768X8deKdGJQhRA2kv/+z4kBE7bio/Td0/0o6TOk5bRzTtJpfs7jG1GkAfGUrdagIoPhgPlizqOnT5ju73Ixu2RVr1kuK+bzJRfnlzx5/BLvILOG9aplMT/m8ZNndF1Lno1pWo9PVgyNkwIdfe/xKr4EF1cLPvr4Ez757HOePn7MTz/5jNnlJccnp7RNjVZaEk4cVGtH9JHpZEqWTTg+nuFcx3LRYayjWc9YzzvKbITVilE5oqtblusFdb1mNBngXMtqNUebRMmqPEYb9vZucHV+Rd1UMoaWA8aDKauqwlrHbD6ntFayFgclV1eXm27JoNPomeG1wBxEn27M0E9kmy647+iapt0sjOq6lnFLa8nR845cF+kCjJsO4foSJRIlQdzmhCAy276DDEHG8Ejc+PhqrcjyDJMbhhOJU1ouVki0UZADNciNPLAFZWlZd0u6tkUbQEcmu8PUGbYonWGsSmrVcjNmhuBpuo4+5SiEINCHEtpbCJG2a7FWRB/WaLJM/I7bpiUE6Yi10ZiocZoEk/lr7113bbFECtXNhJucqFcx9F1Vzx6Jws23mTQKQbzOYxTZNVHk2VlmycuMGANaGZSq6ZpOwhU8RHwK0O2LRuoIkeKglU6hFwqj5DAuinwzHW0KpYpE/KYg2qzgxsFtxqMBZVlw7+5dYoSTlye8eP6SPHnhXF5cobTl1s27TKe7jMYTbJ5xfn7Ji5cvOT4+YV1V+CD7jl4Sr5UiqGseF1G6XaPMJktUJ066MXKINW3qLlWkdY4dO+Hi4oyXz59xfvaKtm25Tht8nU63rc7XGRX9v7v+uG6B8LP+zfUJ8jXowkfJGE2HrH4tVd3331yOjrQQJWVg9gdp7BmW5ucfHt+IIq2A6MWk5fmz5/zoT37E5fyCxWoJNrBYX1E3axazGe1astzOz+Z0redCL8V8pmtYLmXsKYqIWGnIKB58QCWJavBipG6zAUpnOKc4PLzJfLbk9PScpqoo8gHBQ9u0TCbCUPDBsjPdYzAY0HaRr756Lq9dKRaLUzIjC6JRKTmJRaZp6iWurTAWbt46JMsNF1fnFKXBh0hVd9w42GU6mvDq2TnBQWkHTCcHdD4Qg6HrArVrGExz2rbl6uoKUNy9d4/TV2fMzi+ECdB1TMYTdER8LmI/oocNL9g5sQ11TtzIxLltvYEEjDE0TZfSN/qgzZQ8k26iqPoLVgpEz7HtO24Z+1InkkbwtpXlm80s2SBnHKYcHh3w9jtv07WOZ4+f8ezJM5p1i0Jz984D7ty7ycnZE548fUQIMJ4MGQ2HKeS0A63IrE6KOVLXmqTsCurk4hejFGltDNpY+gzFrhM81EW/cWoTtRzS7RhRUsaYX8PgSYeEJNwYo5M/R1LcxZ6Rpq5f2Zti2nOejTWS4qMlRCDGkGK2+lT3lD6tZGnXmpbVYkUXeqy0XzhdN4qSCUNbjdLC2c51Tp6LB4lKnerF2bmoCUPE+w5tM/KiwNqC4bjkzr2bHN24QVkMUFGzXlUU51cMyxHFYITRGYPBiMl0n7wsWSyWnD19zsvjY65mc1kJJ6FU7z2iU6GKfVea4BmNWK4WeU6W5Zsk9K5rcMGhPLRdK9L2zOJcy5cPv+Ds5OQ1Rs72ffvZBfr6UvA6Dtw/+s/XWrtJPN++r9chlC3kl5580xzQUwSNScG50B/YYhmwxbNj+vmJKVhB/QWyO/5VPbQ2DIsBaMPHH31CDJHZcsbtuzfZPZxSDCx1s2I9XxJaz8XFjPNXM9pGFgVN0ybrS1lGDQcdBEvwhkDE2kw2+0oxHo833rL7uzcZj/fwXnH75n1WyyWzqyu00lTlmq6VwNambojBoG0G2oIP1LWwHTKb0dQNhCrhTILprddXYnauIqbQVNWCphOrzhAdy9WSat0QujOu9BX1uhG8tCyIHSyWazwa7xUOz3A4ZLlas1ysGA5HDAYjjJ2JECIlTbvO49oG5xxFZjedbS80CCHQha19ZYyRqlqjtWE0HmOspa7aaxeiJI8bpVPor9zoIQTyQpSJTV3jfd9x9zaZMeG2ZlOgvJcFXBc9s8UcT+D2vVtEH2nqNcvFnLpo0VF4vdZmDIcjRsMxTV2jCDjfEglkeSqKCPzSNRUhpJFdyQ1Tt610K0rRBY/yDqzGKlEDhuCIISX1EFMKey/V1ZSDcgPrtG2XbF+rhAlLt9qzZWKCgVQv6EjTbA8/XDfP0dowHAzFuS+z1J0YhrVdi/PCW+9aSeuWlHXB2fuphkTB6z9TEH57lmXSgWtZACqN5CLmlvF4jDESfBwJG4c9o2TrZQwoHTk9O8GFBptZBoOW4xcnnL26JC8GjKa7jIdTRqMJg3JM3XS8eH7C8+fPxWohQkSmpRAjusdm+y42UdBi37UmvLYoCoaDgcAw2tI0DVVdI3a2TqiemVjavjo7YXZ1RVc3jIbi/th1DRA23XQI/bS39eK4Xsjf9OJ4s4BvJ7JtMX8TIrmuGtw84rWwXqcEskr/LsStvmCTuB63dqb973/e4xtRpDNr+Y1f/03myyXPX77gpx9/ymAs/sXrT1cMRjmDYU5oHc26YTFfs1rWEA1ZVlDXQvqPUcB4oxWRnLwco2KkLAqKPMNow6AckKWl2vxqzY//5COqumadUozB0rQdmoJBXtA2La4DCKyqlXj9hsiqWspmPsuFw+pFOBJ8i+tqcevDYzOL8Ybjl8dkpaUclgn3tFgTcV2krpaooPFNwGmRS0dtaFyH0RaNom1lEdV1gapqef7sJavlOv25QynNxcUlmkieWciyFIG1vVH6U/06vUjSUuK15Vn689j7GKQlVOpGVeqUB+VAPKar7rULvu+ku64jpRqlrlxhtQWtWK1XvHj5ghs3DhgNhmiryEqDDwa8ZrGa4563eF+TmYLa1yxWS7Lc0uuixOslCS+UwVpD1wkrwkcxkdJGvJ+zMhdVW+cIm5tXpcnKS0qL1mgl/GLBe4UzbFRvouOpawkqkEDY5AGcoAWhOcYt17fvyLO0E0Bu/D74tWla2q4lprDZPM/RXuxeXRLcdDiMdgQX0MaitfCht94b4gctS1kDBqq2EvzWKAbDks612Eywa/EIT0kw3jEYDcisSdxuCR+o2pqffvYpg8EI30a0zdnfv8lkvEtZjDHasljVPH/2ghcvXtJ1LYqt/3ZCbjYZir4TKEynu8ungqS1oShydqYTyqKgqhpWq4qqWtG2sitoE3Uzyyx1XTGbX9K2DVmWMZ1OUYpNzF1/zW6FSSp5dm+v581kqF9PVrkOBV7/92/ypPv/X++IQW0Wwb09sfcOF+QA7JllMUZiLxOPJIuCVJzDNh3oZz2+EUW66xzL+YoHD96ibTpW9QqlZNRpXMXFRUs5yChsRlu1rJY1q1WLwpJZEZgURSq+pVCUhoOS8XhPMEdr6LqOIsspywF1VRNDoOvg5MWZFF4v3FaNwrWB9Xot21svGK3OwVU1y0rSSpq6hhiZzx2ZzeRg8FFCbl0nLmQx4LynUAVlMeLeg3uMJiParuXs/JyL80tiFyl1wTgboKPl8nLO+cUVu4c3WC6WaGuxueb05AylNF3wNM2aEM9p2i6xAFKqhuvQKiKx9NcMfhDWaF88u6TGszbbjFtbIv/2AhVOsrAFnHOJnSEdXW++1NPWZCOuyKwlRDk4suTe5xIn22aWYlCiMkvnHVVdUZY52kI5LCTPr3JyDSwd65UwY1bLBZ2TIpIXmeT1qQZQDIcDJjtjbLEdVVdVRTe7kpvVGgaDdKCsO1Q0lEWOcy1NvaKLPvlF9MXFUA4KlEKyCJMLGyCCjkC6+VMen5HOW6AfKa4+iHxcxmeTGB/CRe4Lete2tN4RCGij0FYgF+c7tFGbIuecxyhLZjXOiEBDKH9batgmNxFP3das1sskZlEURbbpSL3bUin7xbEE6h5S5AUHR4cc3jzi668fU1cdt9+7R24HuBY0GRHD2fkVz5+9YHY1x3XC8RXxiUrFf+uBTb8PCVFYJ0CeZWRJOi5ClpaVcywXK5p+gshyfJD08TwXrH9VLelcJ7sNq4l46qrGJzZLj/1DnwL0eiTVmzj0m0vA/tEX8n75eN0u4E0FIQgbqoc4ojxxwqF7n5OtQMa9oVrdLLZDkPT0n/P4RhTpEDyffvEJV4tLxjtTPnznQ758+JD52ZxikFM3HUU+ZDzd52p9Reg6ynxMlpU4J6e39+Islmd5GoPDBjfVSgQLcmGA+FR3rFczWKU3WmuCE4lqVVW0dUsMMj4ro/Fdi3N1KhYCeUgSdMqWQ6WgVrfBmkidVWYtt45u8u5b79F0LcfHxzTrDhU0q9WSvcmUO/ce0DUeZQvOF0vaTgpwOdCEKP4R3nWCoWqLX64EU3UpS89oEVtolTb+HqWjuM712FiIAom4ZHikN+x6lJHoqW5jcRkTbQ+c76lkcrPFAG3XpdQXuTFE2itcb+dErBFDxng0YlCIA19eZsJXJwguGTyj0YB79+9w48YB62XF82fHPHv2nPWq4vJiRrWuEt9bsvt86MiMlotfgYoiBFBWUZQDymJAPhiDyuRniQHnIigv0JeWJbVzHjAYnaOtTctVIIJrO3zs7SpVmtDcBosOXvyVZRFoUxSZjPud67m6KnWXSt6/kDIeE8Oj/4beO7yLGC/dsYpSIAbFAJc8Wpzr6FqhyunU2Quc1JsjdcK6sZqizCiygqapmF3OKIqkGlVpqsiKlF8o7nbaaoajkp2dHWL0LBdrDvZuML63w+3b93FtYHa1ZrVoOH5xyvPnL5nPFuATlx6IweM7mRolZ1DgjSiu/deKpSLLcwZFibGGZl2xWMzRWou6Mkh2pndy0PVwzXx5Rdc2mASXNG3L5eWlsGP6oqkTawt1zRQquTxe853ZTJbXJkbZRcgOJUQJHumfoy/GW7WiXCM98h2j+HOHdAipXkmorzF5Ehd8C8VsITCFEjMm/uyB0T++EUVaW0MTW2brOWvXcPvBfR68/Q4Pv/yK5XKFsQOUH6LckL1xiQmSLK6spa5b5osFbdtQVWKKU5Y5xGSK03k65/Fty9IJN9ZaRYxODMS9jKVGG4IVOW70LUZ7Qr/MCZFmvRLeqliPiSigSz7FWUiLvoDSkjyirdh4eu+4cWOf3emEl0+ecTWb8ez5c6JSaTMcUSZn7RyL9ZLLakkbPSqZ3Bsl7nKdV/goQoI8LzAbgYUXw3VsCpcVuldQAWUiKkECKipU0ESbQxRM1aREZaHgqdQJaEyWEVGbLbSxmixkiU8rEvD1qqJtRcQDiqryW28M58mMJTMGkgm+0ZrcZuhMYUpNbmF2dc7h4Q5vv/M29+7dp64rPvr4Iyo/w6mK3WyMnSma2oFXeCcdR+c9JgSKzIrRO1K0qrpjPq/J8wF7e7dofcfV1ZVMD16Ue7kR/+DQySgqmG/Au46YvB6q9RoXfFrgyXQRvCe4jhCULGWNBYTHnoyqU1agvIcRRecjKlHfiKQCK1LqGH2Km4qJnifF3RqLQYNXRAdd1dE2nRRobTDZVtUm5kjdZmGqlSbPcgm/TYu72AW6xovtbV4wHFmyPKcoDMPRAKLnxekL5qsZxhTsjgM3j+6yM95nZ7THOjY8n51z8vKM45enzC4X9G54eL8pXsaYdL0m7wvxa8JomQiyzG4mi857Fqs13gk7o3OdqDe1pnMto9GQ6fRQqKtNJaZUCUaKiQHUuS17Qqtt4nsvw97sY6L41dvEjooxbmh9PbPCd7J4VWnBSZQIs35Z3kOEcvTGNKEqbIpR2zA1kFqCTqyNTQGX1yQFX6XXJ2Kz3AoMq3k9Ieb64xtRpGNUjMeH+KCYDvY4O50xne5y7+67rNZriPIGWD1guFNibSmdVQgUZYnNLJdXlzT1mjrXWF2g8UQX8CnqPgYJT/XRJ/evVjbQXZTEa5NhTImYr9eyZOta2qaVLlWJsYzVhvV6DUGwJedTekbCv5TRZLllMp3QdZ48K7hz+xbBe756+BVd5xhkBflgwKvLc/b29tk/PGRVVcwWC16enFDVNTbL0yks6rRug6el3DUn39f73pmtP7EdIfY2lalLjpGeXCCyYoe7trHOc+lsJFl92z1I1+il49I6OemphBd22KzAGEPbyBI1EqmamuAdg2Eu703d0LlWsGwVKU3OIBuSGQsxsl6vuby45PDwkBA95SDnwVv30EazmNXiNNcEQgfVqqJZV2kJKeGueZFT1RXrtqFtIyEonDfozJGlBWRbNRDEkS/TotwTxVti1iaISqsE3QTxfoB+NE3Clij2DBsqVgjUbYV1mYQptGKQL/CHvlZUUtFQ21G5Dx9AyWejlcGIAiUddC4Vl4yu9RssXmAl4f8KtCDLSJuChat1jTGK8XAiUmMVyQelNBFeuPCj0ZDpzoThsGS6M+HV6TGd69id7nO0f5vD/Zvs7Rziu8DjR0/49JNPubpc0LXClhEmS0ze2f6aN7XesIj6wFyUQGPD4QCtNfP5jLqWhPL1eo21htF4JPcZUJYl+/u7CYOeMZ/LIavQsidA9Zmx6XqXUOXrXWtfUMX98Bqr4jrk0Rd1pEs216l1PY0yxk2jthFnbSh/Kjkqqg1kuMmEjOkASAvl69+77/yzLKMoCsq8QLFdeP6sxzeiSCtlmI5vUQ6GjEcjCJrlomM8mhK8FIE8z5hOdyiKbCMEMH23oyLe1ayWS6zyuLbCdy0xRIILtFUtI03McU5wrK6TWJ3OCUSQ2YzOt9R1TSebws0HJTdGYDgckOU57925w9XFlUQtKcN6ucJ7CQUthzn5ICVdqMjB4Q3yYkAxGDCZ7nA1m2NsLoIJrRgMCmL0XF6ec3Z2zmKx2CyZehjh+gcrxuy9VPl6QZXDJwZHbpNLnZIOxyhhfngno7pP3FWVWAomTRBVJVlxPW7Z21eK81qyM02dUpk8P7quY12tNzenUlCUudACXUdZ5nIAePl3XjmygQG1kMgxYDlfcn5+BgqWqyWz2YLzswsuz+f4LqKiIXrhzrZOEsS1MShjaLqWebVkua7xHuHmRsN8Nkdb6YKMtrjgKGyOVYKRGiPjeNfVeOfIrKEoM/HwaAWz7zvWkDjPCllG9cKWnmJW1z5RAOVz8jECW2nxFtfc0sZIsm1hBUi472AwQBvNar3aBBcYY8hyC+12MSb3TD8yq80y1zmHsVompPS1IZlaxeBYVyIzj2FAZjJyW7A7OeBg94gQAqPBlMPd25TFmLOzcx5++RVfffU189kS53rOd4/Rv75I21x/6X3YCKWs0PF6vvw2d1Pw/Ijw9BVw5+5diqLg/Pyc84tXVJWEKMs0EzaK2f5n7bFj2NI+N+9vYhr12Pt1LNkkAy35d68b+19fEF6n3m2ofRs/6t6GN3Xvig3OrE3CxJUl70U51w8QJYvioig2y0P9TedJD8ohbz/4NqPRiNPTl9INWM1idowiUuQ5QcG6qnCxY1VXxODEdlNFXFujYoc1HhVafBOo1iva1iUc1m2oWl2SAvvQJXJ9wHeBuqnJrN34VGRWfCYODveZTCbMZlcYY3jnvXf5nb/5O/zoT37E2atzxuMJRZbx8vkxi+USFzuszcjykizvOLxxk4PDI9brisVqxfnFpSR6DEtc5zg7O+Pi4orLiyvm82Xq8E1KlZYb+E2T8Z67jBZjnt6tTSTcPi2KHDoTqXRmLcQG3zWbmyjLMsbjkaRmeE/dOVbrNU1Tb5YnMUbBB1M6NMgFW5YlN45uMJ5MOTs7S+6CYgafm4zpdELwjrqpxJM5apo2YpV0lRfnl3ApHcmz5y+4c/cO67qSRA3XUq9rrMko8pLat3SNmPqPxkMUkaauCE442XXb0jQu+WNErA3YGOjahtgK/VIrDS6iMuG+xx7bVVrioKLgq0WeY0clq5VK2Xgq+X3IvRl8b7x/rStCbvTrLJoNIwA2SkjhrCd8M4SN8Y4xEhrbL1fzPKPtLKv1mqqqEIvSvhC/SRlzrxV+Y0zCucMmt9F5ofd1ybyoV0c2jWc6PeDe3Xfo6XzjwQ4q5Hz98DGfffYpL4+PqSrZCYg4R0B76f0NJnnAwJYvL5PZ1oe7bhwhuHQd+7QCERjQOcdgULK3t8toOEQpuLq65NXZKavVQqaD1JEKHGQ2fHS5Frde4H3HDAJzqESVtGnB3RfITY5heh97dahKDY+6JtraRJWlz7TvdbXaKiEjm+NWIJC0o0CJOKmfMPr7ySYu9YZR4t0Gavl5j29EkbY2Y3dnSts2FEWBNbBeL8iNDBNNNcd3huX6EpNbGUVDoMgNxsBqccVquaCp1zRGp61x4uV2jrbrAIUPkv0G4KOTjXpSgimlsLnFIrzStm25f/8+/9rf/tssl0v+8T/5x9R1xcHhIcoaolIMRyP29veEA5qfERV0beD8fIbJLLdu3uLu3ftcXs14/PgJXcKyXecYTUZoo7i4uMD7wHK5QkQRPTYlN33bNnRduaH29J11H13fF+e+O7HJ/lDGrrT84E3akIyVu7u71E1D3bSSa+g9IW5TKEQlBp3raJom8ZBNGl9Hmy5GVFYRm5VU1Zost+T5gNXJAqUjg3JIOSzQGpquoWrW1HVLiEJrI8LV1YxyIPaw5WDAwf4h4+EOlxczVsslCk1uC8bjIV3TUaWlpQuSHq8w5LkYRhVFRlU1NE2Lt3Jo5iYj0xGTKcK15Z/B0Haetq1ZrSOTyZg8L8TkyvmEwYuwRX7cHq4QLq4xbApSCLJM7pkZr5v0bD1A5X96816bRPlrmgZjxbzJ2DESpBDSkjNiUJvFYV+QJGhBpeWlGGjFEOm6foEpHiZaaQLC69/fu8nR0RFHh3e4uqgYjyeMRiNOji/57Kdf8uTxE6qqSteWHNJaJxtVLbsBot7AQH0XOxwON/957zm/OKdt69R49J7aEos3Gg357ve+y8HBHsvlkqvLS148f8FiuaBNSsOuaxMdUm0YLT3eLAwmeS97do1SIuWXEAqP0tlmIScFUdwInRfbA7HiNRhriUjxJWzvFaOEWRITc0SjUdfc9MK1+0kWyduMxIBwxfsOXl6zee2g6N+TeG3x+DPr479kPf0LeWgNk+mA58/PULHB+xXr1SWZBde1yRgpEK1FpVy24GWsHw4KkQdbWPtWaEGIpaE4oAWUFse4ziUVntJMJjvcunOL88tXJOkBPgSauubw6Ii26/jeL/8y/6Xf/V0ePXrEl1895OtHX/Py9IT57/8+dVWzO92l856XL14wm82ZLRbiE5HnDIshN4/uMJsv+frrx8znC6pqLSe396yr9YZStF7XtK2Mt5LGoYVDm47u/iboC7TAHb0gJWxuWGstmRV8EqIoMVtFMFvIRKeOcTKZMByOxImublJXKB1RlskFrBJdrDeA6e0Z27ZlNptRDgbihKZIAQE+bbEDRZGT55ng971gRENIjoGj8QSIrKs1VdXIjRIj52cX+OAZDkfkdgAhMhwMhEaXF0wnO+RZzrNnz3n29LkwIYZDus5RlgXlYECeZcL9DYLrFnmONZpBmZFlUFcr1usKY9OiKC2O2rZmtYI8L+htJImgtd0U5S1Fcdsx951Sf+P1Bj19dy3/LKSOuDelAlQKqbVW0q2bRl5zLtQ4Y6Cue7FGyk7U26/Pc0vnekGLhrgVYRBJWDYYpLBPdqbsTHZ4++13mYx3yFTJzngfazM+/fhLvvj8IZfnM1ar5aaYELfTRAhRKr7aXhf9NWmMSUZaOcvlkuVySdencod+Muu7WcV3v/sdfumXfokXL15wfn7GixfPubq4oFdc9vdkf+3HRE/sm44ey+89sbe1JDE9Yu+lsQ1s0MaQazks+84/KoHRZOm37XDlZ0q2tgQpun3DEwL9TNEX6RCDHF6byKzt6+8f110k+89JUA7/Ol7+xuMbUaSd73j89DNi9PjYsFxesF6do6InhuTnGwNdAyGlbDjXYY2mbQticDTVGufaJCaAPmBSW6HRG52M761E/6g8YzSd4vBYa1itlpxfXBJi5MXLY6a7O/zJj/6U0WRKjIHZYk7rOl6enDAsBzjnmS2WlHlBtapYrldishLFdaxpHS9PX+FeHLNeV8JG0ZYQFOv1mrppCNFvOM1ZllGWQyTIOZnvd046JEVKyl5uPui2FdWc1tswSyBhdzqNaII3G63xXa88FJigz7lrGnnPFAptLD2joT8UnHNyoYbrxjWRq6srduhVWvLnLsnC54s52orgpG5q1nUlydTp5isHJYPJQDpOYDa/Yr2sGJZDdnf26Fwn3Xcu/ObxeERZlrRtg/eBq9klnXPsHuzjOs9qtcIoTVCe1WqGGo+ZTobs706p1jWrZYVSGZpIV9fMLuQg2N3fxRhRpmqTY20OyUYg+JgCYbcCn14EE9ObGyNYLR7PRjhgacGUKJixxz1jwqm3mGhfaHtc21qLczItWTRKs3FQkyWh2CaIxD5uQmRVu43BUunzlQ5fDpau6zAm4+joJvfvPyDPC/Z2Dtnfv8FoOObrR4/58osvmV3Nmc+XGx+Xvkj1B5CwS16fCuSgEGy1nyZWq9WmC1cKQuw2RbTtWsbjEd///ve4ceOQ58+f8fnnn/PFF59Lt67U5nv014osbLd4v/ijJE1Cv/nldQl3jMKRC34LQ0W2sm6ltuyL61DG9eT4/h7yCfu2NvmCpz2NUFgNOsoy1vVpP8okA6ttsHHPxLlu1rTxfjFil/uNXxzWdcXDh5/KArBr0UQIoo4KrkNM1wNtDGC2CrCWSAgFxEDTyIiktWI4HLI33SUrMg5uHLKu13z16BHJ6IzOOZZVxceffgZ4SVKpauQu01RtR9a0zOZL/os//EO6tuX84ow8N+xMd7lz+zbHxycsF0u5IIxCWUOZ5TRNB8qiVMZ8vmK1WqfFSGQ0HrN/eIieXbFYXJFlOpH3LUVRorXBu+SL7HssThK4i8JRFAVd126wS1Fahs1NL12DmO5nVqOseEa/vviQiUGMghqatpFuQJG6cFn45HnOerVMG3wZxbIsw/lIURSbi857oa2FmDhXCqp6hZ7HBHtk5EVGlumN/al3nnpds46yRDLK0rWOum7Z3duhKCTodlCMGAxKlIqcnZ3y6tUZ48lEQoPXKyajKSG05EWW/JqFRheiMD2GOzvEYHGteGDkRtO1nrKU58wMwmYZSaq1NZaIou6VlmqLfwIbXFmnm9wgnGCtttajslzcHmabXYL3KRUm9WARWTCxTefQSaIZga7tiBmbQp/nOaPRmBgFFmnbFq0jWufpfugDhg1Zlm9w793dfY5u3GJ//4AbB7cYj6fcvXePpm74yY8/5rPPPme1Wic4q0+Dfz14V2CBbHNYCfc526hOvfcsl0vW6/VmgbjhLiuhoREjd+7c5oMP3ifPMx49esSLF884Pz/fqIT796XHrtMPT6+E7el1srTdvr7rC8Qe/tDIvdXDhxLvtYUoetVmAHTUuNTd9iIUpVL9V0rcb2JMifPX4reU1AsZs0SMpHSCPdSWLXK9039TRBNC3BwmP+/x/3ORVkp9CPy9a3/0LvC/AHaB/wHwKv35/zzG+B/+oufyzrFazdBIrFH0ASveQIkfCaDItSYaj/OOQVkwnkzY3dsTB71aFl5oxWQ8YTqZMF/MyAc50QaCDjS+BQw6L1F5JqZLXWA2XzCZTEQY0gmpfrUWVeLTZy/wvsMYRZZLZzibzyhKcYlbzBfS6URROhqbo7CAxrlAWQ5Sdy3+D6vVanNRtZ1svGXTLEtC50PCsvrtsijilssl4/Fo07WQBq6+aEuxTqe/337g4rB2fcSSi7RpG7mpOpeUT3Lh9EEAZVmyWMzQSuHSyJnnOa5uZVvuthLbPDdEAsbqJKwQ3C+2MdGmkv9ETCKQlNen0AQdyWxO7FoWCzFu74UEuS0ZjYfcuXOLm7eOUDrSeRk9l6s1PgaGkxHTnRFlYYnR07YVw7LAmozMZFhbEDvFcrnGtQ1dHRgUBVlhQPXxSpp1tWLZrQAxtQpJJAV9hyUshZ4P2y8QAwGFjM69f3ZRlhuBhmz+t0sn2LoTiiacVBAT1mq1qAO9wzqxKU13HEopDg9vsL+/z2x2SdvW5LkwOdq2o6rqzfMUxYCjo0Nu3brN3u4h49EO9+8/wBjLZ59+ySc//YTzi4vNrsGlwAFJJe9hHLkuYrr/XGIHyUEupaNpms11fZ1mprW4M4YouPL9+/e5e/cubdvwxRefcXJywnK5kIKnU2FOP2kP4/Vy+Z6K2i+v+51Jnux0++/ZLw91YmtJstj2NfmeGcOWkeLj1ma098WKPdgNkCZwTyAzZmufkIRgPoTE8ZZ7wWaZYPfX3of+/ux/3e8vZIch7Ku/kCIdY/wM+FUApZQBngN/H/jvAv/bGOP/+v/r50IYGLm1MsY7j0vvkVGa3Bj5QIxDZYJrGmuZTieMRkMWqyWD8Qhj7NaCM5kIXV5dcHl5gXctO9MJJi9pW8jyAaAkJbwThofRBhedYE4pXFUhng4xBBbLBcvlktliQZkXeBdo6kY6h6gpSzAq+UT4QNM0FEUuqSlGs1jMaZqa4XBI61rqeiX0r6yQAFVtU6crqkLhvoqXRNt2zGZ92omMg+PxOE0RDW3TpL27pkzb9UjatmcZvkv88NahrQhT6qam8448deEu9ItDoZl550VWnMbxPM+pGlnC5lkmnWWUTqtq1mSlSIFjjMItJ3WqxtB2HV3ViQOhspuFWZasO40xRJVUWcHTth2ruKZq1oTo2dvbRdsMoxwFioPDAy4urshRFKOS4WjIjRu7HB7ssbc7ZZCXKBQnx+e0taNaN8xnc85OFGdnp2RWRDuta+lqt+Ey94kgSksEUo9FbxRs9PagoixzbUcCqCHE10QObRIyqP5GTdd7H5Qgng7XVHN9F2h1gr8GhBA3vtyuc8xms3TNtczmc+q6SpCMSM/zrGA63eHu3fvcvHmLPMu5c+dtJuN9Xr16xT//oz/i+PgkCZP8Rn4tnXe3wZ6tTXuJBHV4L1TGwWCYKG1QVdWmOeoLkPdelp9ZRts1lIOc9957m9FozNOnT3j69IksE7sOsSrwRC/WwcH17A9IjOiNGVa/NN9ACEqmxF46770jpNNTG4M10tzVdZtogK+no2wYOroXcV1bmG/YGMK6yfMsPafGKp3M/gOemJSk22VjX4CzJNyBLZ/dp465Nz3rXRTlfPmLF7P8LvAwxvj4F1FJft5DxYgODXVVyxuRW7QRmkwMkZjntFrYFOPpkBAC8+WCDgO2IOqWdVUhXadHp07vxs4uWaHZH5Xsj4csq5q6jfjO4dKY75qG6WRCW9c41+FcwNqMxtWyDJmW2Lyg7lZYU2Kspus863XaQAdP3bWMhyOG4yHrVU1wFZm1GANtW1EnWpsx4gtRN2uqupJx0GSEaMmTaY/ziS2hpRACjAYjoKJtWzbGPr0FZJSMuDIvQAWUzuRAC2C0JTNiA9lYB1rhoifTloBwjrOyYDAY4uZLfNMktZqmqZtNZ7A6P8ckQ/3cZlhlsFlOaD06GnKb09QVNsJ0OKZeVZhopIMMEKNJ3YoiRkVEp5+1BR1BR0wGWS4YbN02dKHC+Yj2hvlqRdSa8XhCWY7YOdphMp5y+upUdhMqkmeGxfKKooTB2FB3S05PTvj8sy9wDqzORADkPJO9kaRfE9GtJS8GDAZjZrO5fK4GdKYIAaJQ5NMNJqIHpRR5YdLYauWmDbJear3HdC0gikNApPlKY1Qa12OEGPBdhzGaQVnQsw+MEnql7zwdDc4FmloKqcawmq2Zh4WwJFyT5OoOa3ImkylHN27z9jvvsjPdZWe6y61bd3A+8v/+wz/ipz/96YYD31M8QdF2LtkXFNhsG5YKYQP75IkNAaLgbWthTsnRk2iBCrLEwPCh5uatA/b2xlxdnvD5pz9OtEaI3mGS+15Q6X0OgZgWhESZ6PLcUhQ5EGibGh8SjTGqZIwlB5x3/fI86QGVEoFVBBdaghPrAN0P5YgPu/ceXCAflGS5yOVlMvVkRQYYVGJZGdvj8JoY5LPQSqGDR7+mK+iPFyneIArdzG7ZPTI6y78MPikS9V88Jv3fAP79a7//Hyul/tvAPwf+JzHGy1/0xTEG8tzyK7/0XR49fkwE2tZhsgxtMqq6pqlqWhxeJ/MZZWnawOMnLxLDIEVDWUsXOzI14tb+Pm+9c5880/zoxx/xyWdfcnk5p/MWdClvgDZk1hC8EYP/psMoWQpIeicMx0Oy3GBzyQlcLdcsl8sNZqmVYf/ggMODQ54+eY7VFp9SlKfTKTt6ynw+Z7VabRZyXedSx2rQ2koAbdhSjWQ5ZDZ0nZ7WZVJ75zqHizElWcvG3EcnBvnWgJZEmqbthTlicGQ6uZk671EhMMxzWVI6gYxCiNiU1FL0aSoxkBtDDJHRUChqTdPhXCOYqpcuUkdFURTkieUgBvsda12TFwUERescQSMLUyIhOoLy2EyTZUPGkzG72S6ras3Z+aWki6BoGsdgoIjRsFrJInZ3d4oPHS+fPQXvQAUuLk549OjLjclRFxpcCNTtCtcErLKUeYkLPTcZsWmt2pSTJ4sqH33SLWwT17fFq8dGIUS/pWJphUZL6EBSNIoZkxjtKCUK1e3mPz1bYjzYPEtFyuO6jnpd47p+EZhJIjlsFoxt64hEdqZ77O8fcPvWXabTPSaTXW7fusP+/iFPnjznn/3BH7JYLIGt6AnYLAhBFsw2s1irktzcbYQkw6GENHjvWa3WVFWLZFpavO9kqRY9nasZjgp2plNu3b7JZDLi8ZOvOL86pgs1PjaEEOT+8D75lGiMjriwRTaVUgIzJKy7V/nJblbmxeBlaZio2xht088XU2gvoKJYpyavGZF5b+Ebo2U6LIYDWu+Ffx88WWYIaQ+j0mFijBRolEGZ10Mw+s574y0NstgM289ZVKE2/X4LP/pry82f9/hzF2mlVA7814D/Wfqj/x3w78hbx78D/G+A/97P+Lq/A/wdkBEvGwz5wW//VXyE45NjjJVxb29/j7Oz82QKJJQlrQzT4Vi67SC+u3meU+QFk/GYvcmQuzf2OTrcYf9gl/PzV3RtR17mHBwcMq9aFisxhc+tZjabpdN5y2nsTWmapuH87JyoIkUpXWkMCqKMKUYLHNCsO+Z2xXpZUWRF4pXmSHacoywHiMn+Khnl6M3GPMssTd0CQnHzPgKBJookHb+WGzKZv2glxTDGiOs6gpei4LxDR/A+QyfstK4qXOqahMEhaivnOlDiMdxzb3sVmzEifc/zQlKt0xKpax3D4RRjLM6t6VqH1pb1ap0sJBNrBNKNY4ihoakbRsORmOd0LQQnTI3gNt7HHmjqDtdFBkXOoIjsTgNEg/ewmM3JtIEQOD9/hfeem0eHTHcntHXD+dkrdnbGFIVQ+VbLNcPhgLIoWbsaH4Ua6bvA8atTBuWA8XhCCJGz80uapsGFyGA4pHWO6Jz0iNEAJjE3Ej0rZRuKsf02okl2DYlb15cTBaQO+rpXsVI6wQbCcy/LHKWha8VQyScJfqRPaxdYLM9ziC3DwYj9ImNvf5/DwyN2dvbI85I8L9nb3We9bvmDP/h/cXLyiq51m4XVdRpY/5qVEoaKsH26jdXAcDimLKWZqSqB9bwXZomPElhgjMarFlTkwbt3uP/gDoNhgbWa+eKKo7t77B+N6dqOFy9ecPziREI4Yg8/pLgywKTXoTWbBHdk/kp7k7hZpCqdIstSoblOYetpgdqazTWa5/nm77QWuqDsRiTybVlX1HUl1q+FKHBlR5TEJilrUmk5tJ0X/rjS17UN2+Kto94sM/sloiKZlCUabowx/UjxtQX1m49/FZ30vw78MMZ4grxZJ/1fKKX+D8D/42d9UYzx7wJ/FyDPsojKOD274PDGTZ4+e0HXtVJ0R0O6tqGtmwQXlBvLP9d17O/sSIEuS0LwGKXJtOby/ByLzKpXVzOMlTh7ZSSpIpqc9bqizMQsqA8QzTLJACyKkrIcYIxhPl9SDkpGoyllmYQlLrJYLLBWEYLi9PSci4sZXdtS6ybFOglLor+A5GaTIIEsK2hah1IWrSxKebSyglElb4Y2Gdc3UXDgTV6h7j2KFcpHTGIIRCwCaydjJK0TpimpzsELRBLSa9FGTNb7iLhtjl8y9s8z1rUsv+q6pm0dZblOkAsMhgPyrKSua4q82MhtvfOQDpL+MDFaMxlN8K6h6yq8a+TgTSMkXhEctJWnMQ5tMiblhKpucF3DIMvxraOaL9mf7OFcS24ybNTcOrqV0qwlVCFG6YLmc2HfVOuGum4wJkdFkZOv64bWS+BsW7eEEMnzQjL9ViuxBghCCVMhEnyiSaX0lpCc+WQEvu4LoTafDYaU7C28XmMNRbJuNcYwGg0J0dM0NYPhgNFohPeO+XzGfD5P1LxcrFnRZFmRwisshwc3+dZ3PuRbH37IalXT1DWDwZi6bvjjP/4Tnj17Qdf6zQTWB532Y7kwXF4PYO3ZMWVZUhRlEl/0VrSRtpHrNwAqN9hSUZQZt27d4O137jKZjri4POXx88dUzQpCpCxzuq7FdQFMJCuN8LetloCJZBxF8vlwyXSp34EEL7BFTEZUwq2TxfqG4ij1JB18OjlDJoOpYIhK07aOPC+YTCbCyU/vQ9N0rNs1LtFZ5aBqNgKZ2C+HAwhzyG12DFKM42Ykuo55y/247Y6jjrSd21LveoaIfMFfbCcN/De5BnUopW7HGF+m3/7XgY/+RU8QUVSNZ7ZYkeUl2li61YrZ1RUneUZb19JFKsN6uU5daiYXVuPwuUeFnqDuqGaBwkRicMwXM1z0KJPRdp55tSboDGyOzS3TyVTsLfOc8/ML2rZD1GW9P7GVmzcr8F2kCo0kJw+mtLXIzUfDkrZp8M6jokFjMCYjeFiv6s1SpW5qgWWMJShPnhvyrCTPcozO03LB0aUx1IeYFjl+w0XuBQG9xzEkDBtNwKcL+RotKQZC2KrSUOJn4pxD9daJqA2ToSiKDa/T+46qqjbft+8Y2lZ8PMajMaPROP1eljC9JDZ4oV31xlO5zRiWJZeXC6rlHKInswnXVTJ1DIZjolNcvJojhumizlTJiUx7TT7M2J/ucPLqhNOXx6zHQ/b298httmHKdE6M8vHC9bXakJkcn5z+OhfwztOloFTvZSHYVTVKNQQfybICgxW4IihcJx2XTFvpXdPQB8z20vjNzZb+XAhcCaJKDIp+WmuaWlgLnTgzDoclNpOFqs0sSsNoOAY0VS1xZ3u7B+zvH3J08ybjyZSrqxUHB4d0Zcfnn3/JRx99JLJ7Jc6OXedSxuQ2faSnCPaUyC0H2WIz4T1rpanqhqoSCKynqyljsFYxPZhw89Yh773/NgeHu1xcnnDy6glNt2Y4zRlpMdDaP9inXlccvzxhON5ld2/K+dkVddWRlR1dIxOasHoEfjRWszOdsrezR2YtTV3x6uwVq9VKIBpPyn9M3a3qI82kKfNOPLdtltG5QF7kaKUpyoKih22qVZoMxA0z6q3Pim/ZaA/Eq12hN3a0qTgrjTJblsj1wiuH8ptFe3t9XO+830wm/1mPP1eRVkqNgP8y8D+89sf/K6XUryJTyKM3/u7nPQ+/9YMf8Lf/tf8qf/jP/kBGHmVwneP87BxFZDAYoFRguVxvLrD+Ys/znLqqN7SfzresfMN6vUrBnjnL9Rrvxe2ujTCdSnHOUHR5lzCjeWKHyEa9rluMFpJ+23b4pLzL8zyJK7rNB9Z3Hl3bUldr1qu1uJBByhMU20PBzjMiEnSaZQVaW3rP2Z5dEIlYK4U2pItFRmuND+JO11tshlQYnOvQmd4uLtK2WymS/3ISVmjgGjdTDoetWXtPyaqq9YZ/HiPiDT0Y0HXCvkBBXdc0bUPrGoLy6XNSdF1HnmWbjXmmDePBiKvzE5aLBVmijikl8E4+LMltyWq1ZrWq8aHFmsDu7g7a5FTrSiChAKvlChUi9WqNb7vEiHFU9YrhsGC1XtA0FUVRYIxEp5V5SesCzkfyvMRpn5gkMfGczYZqlxeGGGScVmgZtaPHO434fMh1q7VK/g6CTRtlXrshQ+gN9nsRSz+tiWioriv5zIyiaRouLi7kgPQuLZkCq/UaYzKGgxFHR7e5d/c+u7sH5EXBcDShLAc8efKUjz76iJcvj4khUpYD2raf2nqs1m/ulX4a7P88BKHVFXmBMuKJLTCXSyydgA9i3mR1xt0Ht/lLP/g1pntjVqs5z48f0zRrPB0mg6I07O/tU5ZiwjUeT/iVoNiZ7rOcr/js0y9Zztd0XeDVyTlffvElbSu7FWPkfV2tVrR1w2BQEn2gWldyzSUmRIQUqNBL8MXLJEYpsHlZUpZj2q5jOp2Im2LXslwuqar1Jg4OYnLV2+4Z+slCCnXq3pOoyagt/tzXn2iE6+wTfbEHvOL1LpsttNQLnF5jm/yCYv3nKtIxxhVw8Maf/bf+ZZ9nf3+f/9G/9W/x8sVLus4lzGiAdx1FnhPx8iFEj7FZKmJsBBVN01CUwu01xmDzArymcS3Lek3RSq7eet0StCZqQ1c3aAzz1Zr51QxrLcvlSgpoJI12YnbknJjHq83Sr0swQSDPcqprvrq9urHvRgWHNOmG7T8YYTn0/NC6qairlhAdXdtic02MDm0iYOjavhvWguHGSG+aFYIjJkpSz8btLwIp6hK55L16LT3CGouPvZ/HdpnhnIzbXdfR9QkzQewXe8mz8FMFP5T3QbqNphG12nAwYJm27xpFDIK1ZsYwHo4505ksVpDRryyH7O8e4ENk3i1RUaOiUNxs2jeUWclisaJtOhbzJYNBwXg0ARW5upyJZFgLJm6UJc9KiIquczRVCwlPBI1WliIXbnHnOojiRyGfj6NrkzrTR2JUAuVog800WluUEhqVsRode7Wn4NQhuMQ2kM9LJNVqMxEJBh2xmZHOMRNPjA2unZaPpSlTqk1kNJxy5859bh7dZjLeYTSe4H1kNlvy4x9/zCeffEJVVRvP5N4yVeCDbnNNiChFbyah/jARuLAQi4CqIbDtDkN0hOgZlAW3bt/kW9/6gNt3j2hjzZcPP6GqVqzXS1pXUZYZeS7TyuXsivmTOXmWk+cF3kWmk10GxYjHjx/z/NlLMltQFkOBMF2XUltkQlZRoI/5vME7mS6Frib3jyzUxXujbcVvm7QwNDZjZ7rD/sERXlTsLJYzFssldcKeURGlI/QLSamiZDa7NnXEBO1t3w+tdaL+bYMAtJHmsM//3NrTbgtz9NsczB4F6e+5nh308x7fCMXhznTKpx9/zJPHTxiWJe+9+x4vX76QURuSKYokU6D7bDqRUhdW4oHyoqAYDiWWqOsS5UVy/oQDX2B1AKOJRtNULaGLr4knjo5uSmRU68jzktVKLCP7LXhM2HCZF5RFKYs6pVO+nttc/EVRkGUZg4FIn5um2SwMIaVqKHHpkK41GQ0RRD7tNUpJB+aDo3ORGHTqSuXgTwaUm87tulxCqRTNE/uATiUjnU+whdJoawmdS5OASh1VpE68b2BjeC4XpyEkbHM0kg55Xa0FT9dCSVou51RVRVGWGxyc1KVXyxXr5QqrLbnJUvGQEXsynjIeCgVO9cq/6AjeUVU1SlmMyTBGoKde8qyUpmlrmqank/UG92Kk3rQNwUV06tal6AS0lWKoosIoizY6GfaLUKpzMiXIckvhnZYABRUpCovSQjsriizhoHINXlxcJaZRTEthWWv1GOWWgRXTod1LjA1ZZsX7osjF9tIYppNd9vdusLOzj1Y5SmXYvMB5ePnyhI8//pjT05PNgdCLlTZcbwXoiGQQ6o03RX8990XbWuHnL5crWifmQzGKXUNRWPb29viVX/0eH374AU1b8ez5E2arK5zvyKzBO0e1XOE7S2UgLzIGRQFB4zo4OxZrhNFwzN7evlBJnefk5TPyvKDIC0CwaZsptMoZDYe0Tcvsap444skwKipJfknsIZ/qQoxSVIfDEXt7e+wfHFIORpyeveJqNqOqkoeMjonP7zdFUtzrsiSQKbCm92CJm+SjmJoefa3A9sXbdVubVPruOUiuY99VO+8JroeVkmrab4VD6i94cfjnflRVxdPHX/Pi+UtijIxHI5qmQ2tR79Tdkqb1ONehdLq4rEFZiy1ypnu7eO+ZL5f4rgOl0J3Cak10SSMWczKraZ0siYrktiZiD/lgxuMJxyenySymoKrqjRNanut0MXi0jmRZr8n3m2w7WSLqDbyxt7fH3bt3OT8/56uvvkoLI7txE3PJrlLGJC80LKNQKjAY5ownJV3bUVhYLmu8d6L0ij2NS0ZiENEI/Ulv06meCplSkc6ngACV8LXE4uiz6PrxDrZG7r1Etn845zA6pISNjK5zFHkpadd9hFeULsK75PmclobBB6rViqLIKbMhy2YJUTEYDDBKs5wvWM4Xm+UvxmCyRIVMl7pOLmJ1VdNe96xII2jbpgkndbdt20JUDIdjnEsJ7z4m45/ksRERJ38vdEsliNNm+aq0qCm7riHLDdqENOWQ2EaW0WhMVVWMRgL1NE27+TuTbnhZyobELpCRHrad1ng8Zjqdoq0hKzIevPU2H3zwbY5u3EZhePnyFc+eHnN6+opnz17y8sUJi+UM6COh5LPemFkpUDrK+2/E2xi27APxRBkDohpcLpcC32lLXXdYq5hMx7z99j3+0l/+ZUbjkoePPuXR44es10uyPCMvcrK8oGsaXCspM947VqpilgzwXddxcnyK9w6lz8ntccoCjQzynBADzXol015oAUuRYtbquqauqg2VrX+/SOpH79PhnJhZfZq694H5fM7ZxSWXsyvxEomShZhlmnKQYUwhC18COgmrYqLKqQQVKtLuxyY0OvZd77bA97BHD4EIdBFkJ5Jebz+xXGeg9I9Nkf4LXhz+uR9d1zK/vGS9nBGV5saNmyJYmS8SE8ELjzPP080hBbJzbtN1zOfSxeW5KP4Ee9Wiy286FFsrQoVwegfFgHVdkWcFO9MdKXdxq7gzRlgeRR4JoU30Vo1rGxZeWBrWGHwIeNdbDYqBU3/zHh7ewNpMkqaVvParq0sur67oXJs6HNAGrIWdnV2U9mSZZjjK8WVGbRRdJ8XFplguYpSOulc7he1FY62F0Dt5mQ3PNMQoxRw2IgWBbySfblAOxHuE5A/s/GtjmFJSVKc7OxAj63X1muxVjGV6yW4O3mO0WJtqJfLa4e6I3Z196rqn9kWWyeNknRbENrnYkcbHqq6JocGHhK93GpBNe+/l0NPc+odMCMI2kYPYQtBYkycFn8ROKQRS0UTa0BFQGK0IibGhEPWn2kAWHT605MbgI+CEVtm2IpcX1oRIwvv3whjLeDzCGCXBB96lZI58Y14/GAy4desme4f77B0c8N77H7Az3SOzA2azFWdn53z62We8eHHK7GqRrlOTFsl+QycTJ0JP3JDT5H9RhQTpeKzNsMYIL9576qahbTuMzSB19ePpkF/+5e/wrQ/fYb684A//6D/n1dlLlBJ5tg8Ra2RS7ZkqRkuKTLWuaNqWzArDaTyU62U2m7Gq1hI91wg7pxwU4rOhJeYqz4RxtFquaOpmQ8/jGmQrylBSfyLXszb9RNtxevoKYw1Ba+q2ThCd/FzGqmSJm0nUXQwSr5fESs65NP1JFx2jQrGl073m06LU5jPuH70qVSu9WSb/vOJ8fdF8/TnefHwjinRd1fzwT/6ELM8ZT6bs7x/w4Yff5tmz58wXS7KsSP7LER9aVusVbduhreS6NZ0jKkNeDKVIpzfIKBk4qnWF7xzWajKbKF+hI3atRCspzYIV48mE0XCSQl8DVhsxIwfaRhNCj4enJV8agRRswi47JwXv5q0j3n//PabTHa6uZulDCJubvOtquZCTKbnWkRA6mnZNURhC1PhgMVbT+gqTKWxeYrUcHiTGhuvElzm4TmTWRU5eFDTratNZyEOyEkNU0imGLa7vXdjwYUXW2lubkjiqUmjKcsDRzZvs7x9wevqK+XIp/NqE64EU/0FZMCxK1ss1uc0lPzIE2lYWn+VwRF6UiZvs0ZmmGBSoTEJipTuRDhYFbdfQdv41m07fOVk0KSWfB0jXiHTFWsNoIOpUIxtUCmswyhBSIk1vm1kmbrdWEaLHILStfqooC82gKFLIb4vWlslklLr3wHrdCIvGB4yWBPMKcfXsKVzB+xRkkNN1asMjx0KMgXI45M7du9x/8BY7e4eMRlPOz2e8ePY5X3z5FV98/hWnp2e0jcBSISlPJfjC4FxISy5xYDNGE1JXF6PErWmlE/48QCud7EQFky+yHJNbBtMR777/Dg/eukdZWD7+6U/49LOPxVtHewaDAucC61W1YVTkRc56VbEz2RGaaDR0lWPdrtEGuroV6I9MxDlBM8yHcng4KbBGS2BE1zjaphUf6ySn3lg0aJUUrCkdRvXClAQ9hJBEaAjdLcE+mZXQYjkQRZTVB2N0rk2h1XrjtgeJ8pf4HImck+6H3nsmbpoT78RkTHxpNKThL6itUOV6M/MmR/1Nxsebj29EkfYhEJRmvlwRot6cznu7e2gl4oQyy6ncmkhMXrt2w4fsusQxNgqFQYXIIJMbwvlAnWeydMwUNtO4tqKra85OKtog9pRFNsBqy3g4ZrFY0DXC0+5THTSGzomM11hwrkmkf0XbtuR5yXg8pqorsjzjL/36r/DX/vpf5dXpBQ8ffknTVLRtTedqqnpFjF0aSeU/Y8V+tGnXZHmJ95r1WiCK5bqBaLAmo3EeG3Kc85TlAJvL2IYqGQwG5GXGoChZL5eC2XWSUkFQgMZHEstEUjy0MnhC4kG3GxOb3mMgBC/y8ixjPJlw8/ZtrClY18/ofMDHyGBQ4Bud/LA1ofMysQQwSl53Fx2dD6yaBowhHw5wBLTVFOMBo8kQ5zPxouhH9iBTSqc8thR+eGYzsSV1ZpNh2Tv5jccjrDbEJFjI0ChjMKQkEA9ttyY6jwHproGY1Il5rtE6w4decALBakZFJoyP6AlGkecF41EhSd46srsrdgBXV3OU0mR2IMrXThbe3nnWyxW1VhsqpE+BFFlm2dnd4+233ub+g7cJQfPs6SsWiyccv3zJo68fc3L6imq9ToWrH491ujd6CEOorDqFKiul0DESkM5Qq0ieWfK8FEiiFi8QYiQzltFkws17R3znV7/F/uEujx894o/+6GNOT49pmhqtRHS2dmIC5juS6tRJYc0drvEps09R2pLoIqHriC5SzcVjxGqDMuLS1/szexfROkIX6XxH13q8izjXLwkNGFGBooRtI9FYanOtEtksOlXirmsleL+Y8cuvrbZEJ0rF0EFwKdFd95F0bJgXvethjCEJmzRGZ6jE0fbpkOo9RXpK3vb+Ca8V5Ten0r4Tf426+TMe34giba1ld3eXV6evqBtxZzPGslgumM9nhBD/P9T9WaxuW3bfh/3mnKv9ut2f9p57blssVhXJEkmRVN9QlmRZsvMQGHACxHICCAaS59hGAhjIk4M8BfCTgBiOgMBxACdREFiGZQcR1VAUmyKrv7duc/qz+/31q5tNHsZc3/7OPudWFUUquVmFW2fvr9/fmmvMMf7jP/5/VusVy2qBC51MHRoTu70qMkJ0hDnELHJQDCjyjEVVicBRYgTvDZbosIYxKXma0cam33R6RS8045wjzw1FIfxloxNm8zlN00BjhSKWXEuM9i4VaZpy7/49fvXXfo0/+2f+LN///g/57d/+bep6TVWvCdEIV2nFeGfIZGeCMZrVeklVaUajkvFkSLVeUzeVvJ/WBOfFJEAltF1LVUkmbpSKU4uGclDGjDjKKxI2JRdKbUSDVOSY9myOvuTelqfsv4ceQkiSlMl4QppmVOt6w5/eZG1eKgtZdBrXdZscXsU0u24quq5jMMiZ7EwIiJFr2zV0NsUkmnIwEEgLyExKluekZQbGUHcdXdsxHg4xaNbLJdOLK2ZTosJeGhXsHASN8uKUoowMHAHxgtUE223obk1ToXrzWA3BRXNYogRB8NiuRStIUmmULRcrtNFMxiOyvNi8dtc6utZjIkSljcE7H/3/JKtKswwT187h0RH333rA3t5t1quO6XTB8cklp6fnHB8fc3U1pWt71TTojQN6Pu512XzdHOzPn/cBoxP53Inc13UdVVNHep1QXXf2Jnzta1/nG9/8GpVf8IMffIfvf//7XJyfE2IAtCEI7hybrz6IuJCKaaPrPMtuRZN0Gx1sa8VA2OiC4L1w6EMApcmE2r9pZgbXbnoFPTwnkgQ9hU3cd1ByXrQ2W83Sa6zdmD4jlTH73r7q5rGB8mIm3jcHYwElDA2ivnTMoPvrKWwNL93MkrcDbtjKzPvHbv8L16JOb4JENvHxC+/5/+YRAvPZbINtDcoBtw6PsF3HYr6gWi+xnSFNEup1RbWuRYdC9yVQ2IiPG6PQtkOpVkofb9E6kGnRXDb0GWQNaHSakqTXLiKr1YokTfBONKqrah2HWQr29nawtmNdLVive4oeMioeRG8kzVLu3L7H/ftvMZlMNhrQ62pN01SkqYi9pFnGYDLi9r3bDAYFy+WCxWIWhVwCpSkxucYvPKERPLltOowG2/VdZVESS9OEroNhPWA8HmHdtpGq7PoBgSJEO9pFfLVvZOkoOm+3Tkm4we0UV+aqqjg/v6Sua8pBQe8zJzBJiGW83jTeRLFMSnoZ7Q/sH+yxszcGHO1FvYFVkiTqTbsO6y2pkY3n6PYtWmejD2XGeDzCKMViOidRirZpqZsWZ2OzL6joSRjdZkKIkp9RLwRP0CIn4FtP5zpUUCj8hq2TpWmkLtqNE4fOErIkxcfR/CzL0Fr46eWgxJiEuV0SZaEJoQ9q4TogqEASFOPxLg/efpv9/UNG4wnrteXi4iknp2ecn19wcXHJYrGMvYb+ApZgs+Hn9q8LmwDdB67tkhoFLjbUurah88LNLgYZe7u7/Nwv/Bzvv/8e63rG9z/5LienxwRvRQGxcyJI1jkp630P9zlQkGpx8Ok5wd55WiezBkki15a3HmXMxmxVKj9xlpF112E7odjaTnBgT9TJ2PD9IYLrG0f77SDYb1bbgTuJvaVtCt1mbW//LJ8qsjL697veCEX5cMtlPtjXXrM/toP2K7zoV8JdeOXfzXn6guNLEaR9NOQEoYNV1Yo0MVxdXvLB++/z8uVLLq+uUEpxdHArSgfG4QA8wTvyPOP27VuA5+zFc9bzGav1jOWqISjRX0hMFrHjhCQp5WJVArc4J5huksjIdfBC/es60fgYDKAsBwyGJUkKWsvEWH+yBBdTlCYlywqapmO+EBfs6fRSuttKSVNmNMArsNpzen4sQSHLSPKU5WqOd46izOmcxXpHnpeEROFsFZeMBOaeq+2j3KN1lqZtsb1rs/cboXnrnEiRShiLTBRZzHmeUxTF9UTXZhFfL6K2bVmv1/izUy7Op1F3usQ5uxm5Fz0Sh/N+o7UgeLHfNPkCjslkTDks6GzLql6JOE8nXHQXJ/C6rmVpDE3Xsa4rnHdxolA2gixNyPOcuqlQIhooAkdaRxy9lxQVs09rnbBalEEnolWttRKTkU42QW00JknRQKL0JnPNshTnLE3d4L0TA4EsiRWcpRwK/PZyfkxVr0iT8trCzHX0wTXLcwaDEYeHh9y7/4DDo9syWOMCZ2dXHB+fcHJyIlrRXbuRsexL7/467p1fQu8GsjVNeHPkWDjw4KNdlPMWk4ry3sN33+a99x4yGg/4wcff5uXJMxbrGUpBORD1uaZuWLWC3zrrhALXM1Ni8DL9+wexLJNG8Zbwfc+ESbXAGkRDiDSJPPyGYMTpXgRATQyUOtJte22LSGmLifE2w6IPjH2Qdl6keI29riz647WArvqA2kMprwZQVE+l63mN13DGzYy6f/0fx+TYfsz2a3zR8aUI0gBGw6AckiQZ3lom4zFaKfb3dnnr/n1OTk5YVxWT3Z2ISWtMogAr2WmR8f777zEZj3jx5HPmV5dczeZcXM2ZzddcXs5ZLGvBk3yCs9HZIjOErsU6cT7J8mwToFIM3it8sKxWy7gYciAwHA5IYmYZgoqNG4dSYoP09MkzymLAJ59+wvn5aTTjlHNsnWW+mlP7Vhw+jIkDDYHONhitSbJ9mq6jHAz56gdfI09LHn/+hPWq5upyFjMOR9e0dF17zVetqg3/MmxlcZvhhZj1bE/DZVHtrj+2F3SPmXWdZblYslw1eK9EOc6IQJAE50BWpCSpMGvyXNgdWoNJRHjI+8ByOWe5XLB/sMu9e3c5uziLhqWxARoF3713qCwT8aamZTgaSqPUWopSJjlD8Ix3RoBnna03f29wwrGWQQUZPlHRvsskCSZJxVEkjiJnmYw8m0QanF3TSlMzSommSSHltpOuvXcBvCZNsuhw3jG9mrJYLDY0RR2ZLt4jI+Y6ZW//gLt373N4cMR4skteDFks15ydXfL8+QvOLy6pqpWwCjw4+gAUx+eDwDY3g0OfKPS392prgKgkao0LHhccSWY4PNzl7t1b3Lt/h8V6yne+/7ssljPatiIoH82gU7JUY8gJncd1ltaLLGivsS6JklA1Q5CNsRjKmP54ONrQ8xKjWK+XHN7a49btfVarOW3Xcu/eXbx3fP75I+qqpq4a1suWat1SrWRkXHSWJcuVAK03m0QflLen/7Yrv37YbRtOuAlL9AmW+BlGUpGJeivhmp3Rx9EeuuuPbXbGtgvM9oZ58zNsH9sY9hcdX4ogrZXm9tGR8DVXa54+ecz9e/d49913aJuWg709JuMxH//oR5ydnMQvRniVIVgGg5w7d2/Buw/Y2xuj7G3euntICJrWBk7OpqzrDuc0q2XF8yfP+N53v8d8Ocf4a184mX4rIhOhASQQGJOI3oa3eC8TiHW9jl+sisMIctFOJjvkWcmLF8ecnZ3x7e/8Pqv1EhMXdF7IWG4XOjKd44Jk5C46nZTFAK2E29uXW+PxiN3JHvPpDGNEMW+1rMizTATyO7tpcIpVFzLuHJse1wtTzDh7EXdgg9lVVbVpGm6yAq8jtU0wwq7r8MExnuwxHI5YLOckibyeiZDJaDgiWCuKZnFTElcbQ+g8i8Wc5y+eM9mdcHBwyO7OPpeXVwTikA9sSksbm0daQVdLLyJNU0blUDa8RLL5w4M9mroSf726QoVAU69xtotMGB+txgJGB/JU9H21C8IfVqngrD7gAJ0mKOdoqw6CZrVcRvVFodY5a8mSFK0S1quK2XLBarmmbUQlrm1beneeosjZ2dllNNrl1q27HBweUZYl1gaOT0558eKEs7NL5oul+F76XiKVzXfRm0H4wKZHcG2JtqW8pq/7In2g6HWu08wwHA/YO9jh/v07FEXK48efcHp+zGI2xfpONjMTHWhS0EiWPBgUGG0EVqpbkVaN5zYoMSFO85QkNXz41Q/58MMPeffdd7h1dAtnW6yvOT19ydGtPXYPRrx88ZTVesnR0S2cc3zwMw+5ulwwm1a8fH7C2fEl52dTLs9nuE7Ov4u61SJtqjdNvr630vdS+u8BwDv7yma2bbd1M2D66DIeXMAYgWPkuydCVn0SfUOnYytIb2PR/fv05+dNcMb2bV96uOPaTFXR1BVFXnB8/BJFoChyVquV6By0NauFqIM5b5nPr2i7msEgh2A5Ob6HxvPpD7/P/OqCYjBCJyXrxvLBV7/Bg7fe4aMffsL52Rl7h/uoVLGul7Gp44QahZRzzl1zcJVCLOAT4e9mOqXrTHxewDkx5CxL4QAnSc75+SWnZy95/OgzfLCUpWTpPUaWJilpAihFGRXksjRjZ29HmhohsLZr6qrmd3/3dymzksV8yXrd4jofMdY4QdcLGxE2xpkqZh6i9tWPAMcGR7h2numzrn5ass+oN8IvIWwmMsXdPNtk3nVdk6bibJ1mGVnv04iNpbhIqbpMrKpMouga0WN58fyYw4Pb3L17n9PTc6xzJEkrlEAvQkSC6RrJZJ2ncxbtYX61IC1SikHBfLHgaH+f8XiENiKfGbwo+KlUpgm9c8KRVQnBaYqiZDAc0rQNVV3LBR8vdqWUOHR7TxiKe0/fFCUE2UyTqA7XWfAiseqcrAPvgky1BhiNJoxHEw4Pj9jbP2I43CXNchbLNaenZxwfn3FxecV6XeM2DA0PW7QtNoMVQgfblOX6GpPtg0LfW9iWIxXeueKtt+7w1oP7hGDpbMPzZy84O3/JulpuqjyhrMk5U0FhIudfKcXOzpBE77BcyBSuUEeFfjnZGbO7v0s+yHn/w/cZjUfsH+3yzvtv4V2L0o53PriDUo6r2SlBtaA6ZvMLqqqjbltx4zYJaEM+GGCSVWzGt/Fvj0mG7gW8rnH3fkPqh4Y2Dit+e2L2VUGyV0T6o0+hCiqug15ECYKOWDXC3pAE+9XvfBt73g7Q/e/9e9+EpfrHbcNTbzq+FEFaKcXuzoT9/T0ReVGak+NjvA9MJhPwnrwouHPnFnt7o40b8fFJyuXVOaPRgCxJmF1NOdzbI0tz1qsVz18cc3I+A5Nx5/5D/vE//g3+xb/4XabTKXmWU5Y5u/sjkiTh4uKCxWKxGUroy5MkCtj3QkM9Zp1Fi6q27ehaKQNBMxrvkJiMxXLG9PKKKmrUpqngzk1TU9eCD3e+I0lS8S7MxHz1zuFtlNJcXl1x9vKMRCV0ruPs/DQOCnSkJt24UfRO02liNmWgd06CdFD4OA0pnmxRaMf35durugT9RnnN8gibbnp/e+/Bt3L95KEsocFgwO7OLoPBgLWz1NH92UrLUuAPrWm7BfP5is8/e8LR0R3u3rvPi6MTXr48JksHpEmgsxajEejHJOxO9nFdS9dUuM7RtjXL9ZpdFJ2zrBfPGZQFEJhdibh9lhjGw+GGjWG0JjMJqUo4unWL27dvUzc1J6ennJ2fCe8+zVBa4a0l5Fn8TqUpWlWV6HdkRjD4ztJZh9eKuhZ1PB2V34piQJaW7O0eMJnsMh6NGY32qBrL8ckLXh5Lj6WqxVDWup7fG7FPpTdiXCEyDVDboj59oLjW3+iVIWWtNpuBoqOjQ956cItykBDwvHzxkvV6ybpa0tYVRglWHoiboE6iuJnDehv1nTV5mlKWA4yBrs1Ej3s8IkkThuMh+SAnK1Pmi0sW6ytMFji/OiY1hv39CSjHaj3D+Zp1XXNxNcO7GbPZisvzGU3jsJ1Bq5ThcIJJp6iYMesQYiUq/QbnXpX83P4OXslmI825jzG9eNhNGEKecP29bxqvkemzCci+p/OxeY+u615h1dwM0tvj+G86fhIeDV+SIJ3nGYeHB1xeXlEUeVS7kqzw/OyMwWDInTu3OTzcJ8uOWC4XdF3HZDLgo4+7+LsleDg7O6dpGsbjHc7Or6jWa0Z7A2azGb/zu7/D2fkZ1Vo0QYoy5+Bwj4cPH/KVr3zIyckJH330EdPpjDRNNmplvc5y29Z4fz06fXBwSF01NI3wYcejMbuTXcpiIBhfJ9q44ncmdkA+pDgXMFqJTkTTUisDXkmn3GuKYsDRforvAm3bsK6XONvhukqappgoKBNNN6PaXD8yK512IlYombQK4gnXl3GvkPE3YjoykLGxtleyyn3wpPp6wdV1A0pRlAVFnlPXFW3Tig7HeIy3LbOrC1KtSBIjFMjUkGQpy1VN23Qsl2uePnnOnTtv8fDt97i4mIkLh5apQMmaPGVUf+uqNW1d0UW1vVXd61orAgmrpUOpQJHvCBShYTzawSSGphbjg+ACO3sT7t+5w+HhIdY7dicTbh8dcnZ2TlVVuCDQzaqqBTpSMimZGOGKW2vxzlN3NW3XEYw0pOuuJTEpuzs77O7sU5ZjDg9vkaYFtrNMZwseP3nByckJq2pNZzvJ8oCgtqhjQfi4esPRvd5QpXl4Tffqq77tgNBT14o85979ezx85yFZ6nj54hEnpy+ZzaZisuC6DUtjuDNGG81ytQIt1nXWd1jfbdg6bduwXPro/m4Qqzob5QEapqeXrJsVg1HJ0e0j1vWC1lUEC01Ts7c/YTpdoI3He4VSGbPpjM8+e8HZ6RVNY9EqY3/vgN3xLuPxDvVOQ1PV4HsJXmkIWhdxlnhcr/34FYZXWS/9z722do9VvzpI8mqw3H6N7c3AB/0K/gywjTlvP2c7s95m27yJ3fGlp+CFANPplGdPn0ctCU1Tt6RZynQ2Z13X+BBk5l4XDIdDIHBwsEeWJXz66afs7OxS5AUvnr9kOZti24am9egk5+7d+6xWS6bTS4E3nCU1CXVbcXYiqnJ5mvHwwQPu37vHZ599xpMnT2ijNkTbtpRlgXNKFLQQDMuYhOEwA2q0TtnZ2WE0GmEMONvFIYmA8x2u9VgvRP2mlUkxcS6B1aqibTps5zg9OWc8HkuJOd6hrisZd09K2sSBFyqbZFwKY1KRBFUGFefalZfpJ6NEGMhG6VFP1D0xMpghf4ffTBl6L2IyMVIAIZbVco76sW8f+o0npSwK2rqiqRvxiexEkcxaR5InwmdNEharBSM1osgL6kqoVOfnl3z22efcuXuXW0e3xdHbeobDCXt7E45u7XDn1hH3795hOZuJf6VRLJYLZqsFJk/Z2dtjUO7QVuKmUhY5g6JAJ5rRaIQymmq9YjmbMbs8ozCQZgPa1mGMYlQOGBYF+5MdqrpmtV6zbhpOzs85vzinbTtSo1FZJtok3m+Ep5QCU2SkxYBq3WBMzsHBLSbjA/YOblEWA84vpjx7dsLp6TmXl1eSeUVOtmyp8Zwhe6Lwca+xTqUU272qTVOK62aVjIUr6qYiTQxvv32fW4cHjMZj1ssrHp094/zsBU1b07ZN3ADlzb23cRrSkGcFykQN7TzfYjkEvHXUVYWzHVmWE4wwOZq2YTld0PmOs8szdvYmBBxNV3Hnzh1wcHV5zvPnmsurS7Gm8lLxrNcd88uW+UXL1dUVISjOnl8wGo0xytC1XTSp2FKXC4EQ4kTqDWbFa3S4/tsNUdo3SWT6VfcJTtz0eD1YbkMYm3Oh9Qb6u4k/X8Mecj7fhFvfpP717/OTji9FkK7rmkePnrKYL6RJl2VUVU1ZDlDa0LQdZ2fnpAlMJgOGw2GUJdW89+77vPPwXQCKIqeuGpbzNcv1ivmypW4cw+GI9XrNxp0Yj0qIE09weXbB9+vvsbe/x/sffMgv/Pw3+cY3fp6PP/6IR48fM1/MWVdruk7EmXRs5kyncwblUBxL8t7d2bKaLZlPz+nsGudq6uj84By0rScEI9zrTHQ4bBx/NVEgyFpxhU6ShLZpWNe1qKqR4F1N14qOSKoFx06TNCYaAU0g9K4hRm0WVQgBFeL4ujbY2ABx0VU9bAVkYrkn309PpfJok0SRIyjLkvFgyLAsmF9ckASF6yzVak3bNBLEEvFHrNuW1arCJBl5MaAowAfBfj///BHeB4bDIffu3SNJUt577z2+/o2v8t4H9xiPhxRpyvxqjnOWvMgJKKq2IR8OGE12yLIhofMo60mVIc0SglboLCEo0YapVyuW0ytW8yu6ek2wDb6rWM6usF3DsCjY2dkhKMVsvmBVVUyvpnjjMUUh1EQv7iImTTb9iaTM2Ts8YrlqcM5weHiP4egAk5Q8fXnMp58/5urikuVygbNtbAZHzzudIlVZhC1QG8nZ626/2mIUvEqL9ECapCRKmtp5nvDgrfu8//472Lbi4vwZ52dnzJdXNO1KXq2nJcZMMgSihjpROTGA91Gr2WwCndU2ZvGedV2RZgm5zyizksynKAd5luGsY7lYCLygRJdGMszAfLZiMV9ycT5lOa8JzkAwVKsOWwml0ClHs2wjv15HRxw269D3egaEVzYy4M0Mii2813Y26u2IZ1M/pRj8m2lw29nyhuanekhFcOrtx4RIE+y/5/6z3dxEbjI5/lgmDpVS/xnwN4HTEMI34m37wH8JvIOI+//bIYQrJe/2vwf+BrAG/nYI4fd+3Ot777m6ukQrYUkopeLAR8r+wYEoqsWys1qt6eom4rsNrrU8fPiQoigYjccc7R8xnc95eXzMDz/6iJfHxyRJyrMXzymKgv29fXmeF/Ef42UYpmcGrNZrdvf3+NmvfY1f/KVf4r0PPuD3/+BbPHnyiBCiRkIsM9u2w2jxpFNFgVKB2eyK5WLKbHZJ29SYxGCcETEoHxsfRE/GIqNtGowX3LuIVlPz+ZzpdCrQQlXHppp4q6VpGrnSIkCeJImoxsV10y84v0URkIw7ih/FzOFVnmbErAmbi3izaIPwh5W+5un2+PXu7i6T4YDLk1PSJDImtLjLCP0taqdULdZ6utYxGBTs7IoofZ7n7O7sivbv/h7vvfMuOzsTPvjgA77yMx/gVMd8PhV8W6dk6YCjW0dMdnZxeLKiAKXjyC4kLqB9xN5VYNU1zFZLBmXJ7mQXdfcetm3wtsG1a5r1nMX0gvVyznw2o3NeDEtXNVpnJGmO0jJxaIyL3HRpsN6+dYskS7AEBqMJO5OMNBtjkgEXlwtenjzjybPnXE7nG8NbkwhmvV0e9/h/32AK+hqKimdvM7n5Cv4am2PWthRlxsHOPnfvHDEZD1nML3j54hmz2TRODPbrB3pJUOm3CH0uTWUCssezxY1EJklDZJRY6zaqiSJK1DGdXxK0pxyUuCDO4X3jsVqvWKZCk83znCwrUAGqdctqUbNeNKyWFYkuhM4X4nj0huuuXvkO2MBvPcNl21zB3wiWMVvdgh4AHNe8cq00zl8zYLaPPiDfxJKd97GC2oaXXh+sufk5bjYWtzeXm83fNx0/bSb9nwP/KfD3tm77D4H/PoTwnyil/sP4+3+AeB5+GP/7VcSY9ld/3IsrpWjbhsQklIOSEBy3b9/CdY5bhwdRhtBhmzXeNuBEs6FeVzx/8hSN4tbREWWWMxgOGY5G3Lp9m6PbtziOlL2eXnd2dsZiubwevugcNlhcHKSZLxZczKYcn51y/623+OpXf5YPv/IV0sRwfnZKVVXYLrp6xDJqMCi5e/cO7zx8m0Dg8uKE5WqJ905Gtcucuq7pOi8MgKClkRZENyFLRbx8OBjSdR3r9XpzktM02Uz+9RdJMowYXBQX74XDQ/BxMOhGE8NoGWpV0MVpxG1akCQmr466xh8250hH9/EQPEUxIE1llP/WwT5nJ8cs11OK3DAcZMxmHu9FICHLM4L1grNiGJQj9h/cYzgcie7v7i57OxO0gtVqxWQ8YlwWNOuK56cnzKdTBoVoYdw+PGI83CUhJdEKHWSIxiTCStAKaTB2HVbByeUFTism4xEmTTBKRUx/AH6E93sc3L5D11RRvL7i5OSUBsOtZY1XhsViSV3XJN6R5wWjiaKzlvHeAeVggHWB4XiXPB9ycTHn88+e8PjpS84uptRtNBtA+OniOPT6Bd1f7DcV1fpN1Pt+vD/EIGHIs160quHO7bu8884Duqbi6bPPmV6dU1drAr2HpBIK3yusAhlikmESR9s4eucY0WiGELZHqnu7Lxkk00qTZgnedVSVZzAouXP7Fqv1EgjM57Po3VhQlgWz6XOqVcv0ckG97rBW9KHlOgybzxg2U7GvBzkgquK9OjSy/V3ehCFu3t7ftz3M8qYge5OpcX1f4LpxK7dtzxjES4lepGz7WnzT53zTZ715/FRBOoTwG0qpd27c/G8BfzH+/H8E/t9IkP63gL8X5J3/uVJqV73qe/ja4bxjOBIFu/29PRHojhrLtmsZjyd0TU3nU3QiesmiD2G5uLwAH7h9dIRB8eTRI1SacnBL+KhHh4esq4q3HzxgZ3eHyWjEyekpdVNHF2XNfCGNyGIo+tL1bMbF5QVVU3N2cc6gLLl/5zYH+3t8/tnnhACLxSp29GE8GnB4eMCDB/dpmobj4+ekWU5oOzSa8XiHruyi47LD+oDRhuVyETHsa8+5xbzPvERgP0nEq21zIWtNlopADd6jVULXdrTORVaHkPHjiZMF4ENfhW2yOhflX9NUBIVEp+P1i6I/euaIqOHlr2TThGZ6MwABAABJREFU77zzEKVbmnaJMR6FqPIpAkVWoIIiSwvuv/WAt9/5gNv3HjIZ7zAoCxKj8V3Lejlnen7G5clL5henlKMx06rCto7JYIBRimaxxngwaYL1ljYKXu0clOS5VEXTkwvOL6/oFJQH+zx45z2h4202HhBVK2m2miQjKQZk411GzjM8uM2dh+/z4VfnvHjxnOfPnnF2fk5v3mqMEQEjowXDVRmLRcWjx0/57POnvHx5yny5wvaTcEbhEL3j4APEQLzd+X+t6RWnR723MXgrggr44EiNidWYQ2H54IO3effdBywXM54+fcR8MaNra0JwJMm1cpzzjuBFoTHPxW6u67o4ESmBMctSYZjEwixNE/IiJ0tTfCBqO3sZAMo149GA/YODqOXhGQwL0ajpvTwjm+L+vQcsZh9xcXFMvWzxTkt1jJJR0bgJ3cRy++9je1hFcBkV2RivrtEvCnz9RvMmbLjPlm9m0zdH67UWuKWHnvrn3Mykr/sErzcfbx4/DR4NfzRM+vZW4D0Gbsef7wNPtx73LN72hUFaK8Xu3g5N3ch4tlYsF3OCD8yMZlAWMv2lFcorskQusDpJODw44MFbD5iMxtHxQbz5ruZXTOdzen7vfL5gOp3Stg0amIxGWOc4unWb3b1dfvTxJ1R1Je4jXUMexBSg6xqmTU2q4fbRLfb394UrixaNaFTUzmg4OztlMByKQ7gXWlXbWNYraTYaZTCFXCDBB1Jt2N/ZxXvPuqrompZqXcl4tHPR5ST69CFdduccnRKhoRC8NEJ6WhFbC0Ndl8ku+E2jUTim1ws0TVNRH+uuL44QL4D+OVJSioC8HL3Os4gs7ezs8ODt+7x48YimXuFsDbjId4b7997iYP+Qg8NbDEY7BB+4OD/jebWmqVZUywVdXdE2FUYHzo8LsqJAFyW2syyKHBUCl8dPefnkE5RSLFYLggoMRiPGewWpCRQ6IzSO+WpNub/LN99/V5xUgJ6R471MHvbUSmlOJCKQbwLDtGC0c8itW4633n6X1Wp1PUloDFdXV9HJ23N1OePp0xO+992P+PzRE+bzJZ112I1OiBf+bwyCwGYD7ilzPTMHei2V2JDUUaEvltde+dgrEJbDeDTi4cO7jEZDzs9ecH52ymx6ESEHh/eWgInGEpGnmxhGoyHD4ZBlupKNuROlRehdSnSExiRTFsd3SQqSRDLPpqmEm6+VVExAmiQsV0u6tkWFwGAwYH93n52dHd5+8JA8GTDIRjx/dsLpySWqN6uItmUS0K+bal8UwDZBnFfhhv7x26yO/vH9cXM0fJuy96bhoO3/ZMMVg2q2gvKbsnDhq4v7UC9etv333Pz5JwXrP5bGYQghKPXjDGBeP5RSfwf4OwDDQclgWHJ4uC9d8iLHdh2z2YL59IpUKwblgEFR0NkoTRkDyTsP32EwGPDixQu01qzWK16enXJydYYncLC3TwBWyyXr1Vq80rSiXq8oh0MUgZ3xhH/3b/9PIk3vd/nu977LbD4nOMfu/h6r5Yr1as3T9VPu3LktVjtKs1wsaZqOrqm4OD1mOZ+Rl4PNRRy8NIXWq2pD4RoPh2Q6JXiPzbKocy1iUW3XiXmtgoVzchFnIqUqim2in1zVtfCfQ/QQ3MLgNKCis7GPDRspH0WYxke8Whsjdk1ZhovsgF4prh+CMLEcFLeYOE7uxCHHZDnTq2m0jbpkuZwCLhr1phR5Tp6mHOzvc7C/j1aak+MTquoJVSub0Xq5wHYNwXUEZ8kSTZkLb9x5i8lTkkQzLAqG5YAlirOXAhW1rsMGT1GWJC8TMqMoTUaRFHg0pixYzWdcXF1xeHjE7Vt3CM6zWi0wRjMaT0AlBKWEzbXh1ArTguBIM8VuVrKzexixY0s5mNDZx3z66Sd86/f+gI8/fszJ8TlV1RAQ1oH4/EZ/yQhT9GVyHyh69UEX+w2bqcGo7BiC6H5476LKoI1YNNy/f4cP3n8HTcfpyUsur85p24Y01ZuhGNX3BuRii7CuomnbzfnOshQXOtEYVyJwlKhrzrV8LhfZP69qVWgU69WaumkYDgYc3Dpi4Aa8/eAhVV2T5Tm3jm4xGo1o1y2JTvnlX/4Vvvnznm/93rf53nd+wNXFVCY+A68Zsd6E3q4DYcSD1atNu624Ip9vC9vfDqJfFBC/CCbZDsTCfBK7ve0m4E2qnQyFqetm4xtgju3px3+VQfqkhzGUUneB03j7c+DB1uPeire9coQQ/i7wdwEO9vdCmoksKCEQXMB1LUYFqtWaKYH8KIEip7Udi6sFIQQG5YDLqVjkyCguzOYLTi7PWLUVw9FwI6m5mPfPKYQ6tp9TDofs7u3z6NNP8c5ydHSLX/qFb/KVDz7gW9/6PX706Wcs5wvqqmbVWdEljjtjF6lmghV6prMWd3lO5zxJmouFVcilSeNlQjDoQKINxXiM0RrbdjGDbgjOMxwMyL0XHZGiYL5cCBcX0coYDoacn5/RtM0m47WudyhW4K/dUUIIBNtf2LGkixm68/5aFMdfC5MbYzYc0j6Di/kIZVlSRdcWrYWdcnl5ycnJCfP5nPV6yWBQ0rUtOztjVquKxGjqas2zp09YrevIKW/ie/RmCQpDIDGa1gV0SNiZDOi6GrucQ6qZr6DJclIj3nuTvV0whulijrv05GVJmRUcjvcIWcCkGc1qzdNHj1k2NbOrS3zbMh6OyNOENMvQaLwPdN7DlqavdQ6cQ/XGplzbdC0WCx49esTv//4f8Ad/8Pt8/NEnXF4uELsuGQBRKkRIJAYQFZtcKPxWx/8mz3ajSxyJeduMjhDpfsNhyYO3H/DVr/4MTb3i8vSMrqtJlMJq0FmGdXFiNmp8XG/Ushm1rqO1InlgEo11XVzTceAD4bX3rjGSNV9jroKbC0feOcdysaJrLc5DXpTcunWbnXFgOB5ycHDEy5cvWC1r5vM5tntBtWq5vLiUvzKKNUVp883xJorb5j6tolTpT8al3xT83gSJ9MG0nyDur4Wb+s9SHbFhjNzcQLYDtdAErzeLzezBjffe/gxfdPxRgvT/A/h3gf8k/vv3t27/Xyil/s9Iw3D24/BoYPPH5LkI6qxXa4wSmEP5gG2EQTEajbhz7y7f+ta3uLy6Aq0ZB0+aZKyqisViQVVXrKsKTIiDMQ1JkjAYlqTaMBgMWC1XJFqTKMXh3h4P7t/n4vKSj77/fayzvPvee/wP/s1/k9PTU/7RP/nHvHzxkrbuaOuaq8vLuJNrhqMhb7/7NoeHh0yvpjx68hhfN3F8WkebopQ0ai4fHRxwcLDPoCzZ291lvV5zdn4OCpbrNcWg5Go+4+ziHOsdt26JtoH1gYOjQx689Ra/8Y9+A+cDhN5TTiYIlVboAIHYqEAy6Q1mhmQr1vXaEC42MztxIH+thIuZQAzyxmgG5YA0y9jd3WEy3mE5n1MUOcPBkPX6gsl4FwIkScbp8TmL+YLFYoVzga6VrM5oRZYaykJEjpT3tE1D8CJy1emMul6RaE9iLCYgEptdjVUyNjzeGeMJovmhYOgVD99+j7cO7jDKS4rBgGIyYefwEC7OefLpp7z4/BFH+/vs7u5w595bHNy+SzAZrQuItnx/EXqUdygvw1Tei97Io0eP+fzzz/nkk0/40Y9+xJMnT1guVnhvNqJVLlYdvUAUSqY2ldjobDbLNzUJgc1rgCYxKnpGyoW9v7/PrdtH/M2/+W/wzjtv81u/+U+Ynb+gzDI0AVae1nUEDM47kiQjSaWx2toOlPQdrLVRMzkQXFSeNNfsn+FwJJWP1kyn0yhfGzZStEliSIzMMVgrwy7rZcVyWTEajyFoqqolL3JOjy958vQJk8mYtx++zZ1b91gt1uA0Z8fnMVtPaRu5Xlx4FReG1zUxNvrovJotb4+G38xO38Se2H4Ns9Un2A7M22PcwIZ50jfyt/Hom4MvNm582+/9SlZ+47P+uGz6p6Xg/RdIk/BQKfUM+I+R4Px/UUr9z4DHwL8dH/5fI/S7TxAK3r/3k15fa814MuL+/fvcOjri8vyS3ckui6sZVxdXojWtZXZ+vDNm73Cf3f09OmtZrtcY02CDx+FRRpEXGfP1gtlsyng0pkwKBkURNQkCwTvOTk+Y7Oyg3nmXh2+9xf27dzk/P+dHn37Cd37/9zk9OWZ3d5ef+9rXOdjZ5emT59jOcn5+Tl3XjHfGfOPr3+DXf/0v8+DBA07PTvkH/+Af8O3v/YBmLdlHkmQbI9ZBXnD3zl0ODvYpipxBWUKAQTlAacVyuWI+FypY27Qs1yvK4UD8/rRmsVjwO7/7u8L31goVhELUL57tBdNEHY7tUkxvE/G19AH6rDlJJQhL995H0SQ5L2lklHSdpShF3L4oxAX9/v377O7usVospImGwmgRWcqynKvLWTSjFf0MaUalDDKFMQ4T2kgVbHFeSn9rYbaYcTAZkBvITEI+LJnPl1RNi84KusZilcZZ2D+6xVvvvMPDdz4gdQqDZmeyy7prePHkCefzGafHxwyyDOo19XyGrVva1lHu7KHTHIfGeak0jNbgHa5rmU6nPHn8hCdPn/D82XOePX/Go0ePuLq8om2FWxwUeBxKGZQmwhI93U1c3zcUshtYax8Uti9i74Xi6ZXfBIPBoGD/YJ9f/dVf4c/9uT/Dvbt3uXt7n9/6x2P++T/7pxshKeMdOs0ICJUti1iy6Rp0orGdON+IJKwEa60NxqTR51Ea03UtEgj9oJN8VqITEZSjEVopGtswGoxpraXrLFcXc7zTVLUIdSUm5eT0BQHHo88esbd/RKITVovVxpG7aRqRLwhuwyb6cRguSpQO9Y373tTAu5mt3ny9636L39D4tn/fbhzKdaNf6fu8KZvePm4G/P4x2+/XS1D8kTPpEMK/8wV3/fobHhuA//lP87qbD5EYBuOStEyZ7I0ZjkrauqVtcnbshPl0ymq5ZDabcvv+XW7fvYMxhnVVcX52Lp3ntqVuW6H2aE2apTRNw2Q8AeSkDQcDlsslaZqyd+8eo+GIcTHE1g3jyQS1f0DwDt91vHj6jJOXx+zu73F+dkYInuFwgFKHMoIeF8JwOOTw8IAk1dy7d4c/+O53otWQQCNZKgML62rFZ599xvNnzxgOxWNuMBigjcg+Ot8xnV6hE4NzjuFwiElTnPecn5+hgHVVSWYbqUtKKZI03UyGKU80lu1eo3LJpKHG+Mj9DGyoTr27Sn/01CQ5lVrcPWJ3O89Fea+uVrz94B7D8YBymHNLH7AzKdjZnWA7cTXvnV2k2eLIsozxIKNIVfST6+Jnl8zTek+wjsRDlpekaFKtGZUDmqohz4eQZISgqRrL2fmMRe04ny559NlTjnb3GRhpFFrtWVRrdJZy7+5t9o+OGA9HDAYlTV1zdnLCoGrwKqHzgaqumU6n1NUa27VMr66YzWZUVcXxySnHx+LUvVqv6adN66ZFmyBFcBCYyigjXiUbMomOvsFRa4Otn6PQ1TbdTKqXhAjUUg4yDvYm/OLPf52/9Tf+Ku+8fZcsS/mZDz/g/tEed27d4r/+B/+Axeef0bQtOpFN1QdP23ZR11oapaPxmK4bsF6vWa9XKA1p5OsrpQjWU45KEmO4vLhkvVqJhIKS4aVBWTIcjdjd3QUPwXmpFNOCdJLh7Rl11YrutvPUzZSuEcGs9eqCq8slRmnqdRszYtF+cdZuhlVuHjehixAhuO2A3GeoWuuNeNg2xfRmlnpzU9xe99v48s2KJwQZINrW/3hT87JvUvev8aZNpw/QPbvnXxXc8cd26NTwM9/8Ktpo1oslMzvl7PSUh/cfSumbGnbHuySJZra4Au2j6STkRSY2PVGjQsTtO2mOGMk2W2dRTjCn2WKBdyIAPxntMC6G1PMV46JkkCbcPTwg2HdYLec0bYfvLNWqomnWlGXGZGeM7dzGyWQ2m21GhH1wGK0o8gTh7TrKvGAyHjMajmImIopbdV3TtA2ofljEUw4yOue4d/8Og8GYR4+eMr2ao7yibWrxDlTXZH9xExFs2jlHcJ7g+t3/WvNB9B0ioqYksyeEjVypc9I07Lou4nKiVdJ1jsQoiqIElZCZlEGe411DZy2X0xckaUvVXdG2c4qmQ5sUnYDJDC42WZQJJEaRF5oi1yRYGQpR4ncXTELbOMloHRwOd0jyUhan73A4sjIjzQraoGhxBAUWxdnVjKv5krPTU57lBZPRiBAC4/GIyc6YcTlhf++ArBwQ0hxrSgCmJ2dc/OBjzs7Pmc2mdG2zGZne2dkhKwYsV2uOj485Pr1gulhQNw1BaRzCmMHkhCBVDSGgEe+9VzFKtTEgALdpThLAW3eNxSrxIQwqxQVNkSYMC83De/t8/avv8Wd/+evcPyhI7II0E1Pm3ckef+HP/zpKp/xf//7/jY8+/RFN12IS0YYJwdO2YqawXKwo8pKyHFK3DUkMzklqNg1JlaeEBOquZl2vaJo1qRET3uFwQFmWQODy5BQw1FVDpeoNxOWahiwvCGhmy0WUCLDoqNDorY/rXVwaXBQvEjUDh4omB/0hga2nKxKHbKBX5pOn+Q1zRik5A15fY8CbsHkDs1bqWrp0G0vevr9nP/WP7adze0U++S+8srf0vHbvr4P09mbQB+TtIP2mLHz7+FIEaWPkgg7Kc7E458XJc8k0xwPu3L/Lw/sPyZOSycEO+3cO+c53v8vJySl13dC0Det1HWlnkKQJidakQVPXFYvlDJRMQnVtB0astpLMMBwWDAc5p8fHrFcz0jxlOBlhbcvBwT5Pnj3jBz/4IWU5oCyHzOdzCIqiGLCzs8fu7i51XfH0yROePH3E9773bap6QZLmDIdjYaSUkpn40JHliTQhlyuatqHrOtq2Js0TTGZYrpY0naMcjplOF6zXa6zz2FYaGkls4AQfoo1R2MK9emeMOBLue16zkotEixRlmos2trMOOsnGUWJE0Dkrz/fXTQ7nAkpJo3AD3eIp85SmXvH46QxnazLtuZqKkXCWl5SDkrv379F2LePhkNFgQLNekYSO0DisbemCjiV3ymA4YrUS4f7JZCzsEBxJHJowVsvEmErQSUJVrfnwq19lWbe8ePJUmp4BitGEd997hyIGljRNQRkurxbUzSXTxZL5fMZ0esViIQyeyXjMZDRkfzxg/2Afk2RczJa8fPmSzz9/zHJd0cVpZIciKENQRhpezkmQVgGlI7y0Pb6tBJWWr1khI9m9WM919txnZShQAbJUcbgz4Nf/7K/w8197Dx1qPvuD32Jnb5fR7h67h3cpij1GwyF/5a/8a1zOrvjsyef4YCkGJWmWEpy42VS18KYXiwVFWZCnOW10qjdG03kr1mOhY7Ve0dWi8TEYjrh36xbjgWx8q9WKy8tL6rrFmIyu7UjTTDZxmbGmaxoUirIs0FqT6RIfoKornA2oJArj9yyUGAy3rahezT6vmTHAJvHoj36Evl/HfWDupwq3nrQ53sS42P59O2j2VWl/vvqsXanrhm//GtvPvYlD9z/3AXoba7/5/jePL0WQVsDHP/iYi4szykFO21gSDJdXU77xlZ9DtYHFbMnBrVuYLEUb6dDPF8vY0LCgPcoITUYbGJYDyoFgwnKuHZPJkCTZYTIac+vWLco04+DOLp1b8/mjzwgqsHi0JC8GuOBo2479/X3KwYhyUDKfLzbGorP5nPliwXwxYzq/ZDIZ8t7773Ln/h3yYsB4POFgb5/9vT0SbXj58iXGGMqi5OrqgpPTE+bzK6pG3MWzIme+WHI1m3NyesXJ6SXe603Dpz+R22Lu2xSfDbczagr0AQAfCDbgvAxWlFlBmmQ4K6JV8tW4a2UwrTa3ay1NKLHD0mJx5R3gyTJRwFuuapq6IRhH6y2Q0DoRmt/d30Mpxf7ODkWWcXr8gmYp3pNZVgg8EzRJljAZ77Iqc1EtLFKKBBLnSbSCSGWrugYSGIwGfP3tD5hVLU3nuXP7Lsv5gqOjA27dus1kMsY7x3Ix4/mLZ3jrWK1XzOZzbFQPDHjyLGNvb5fxaMjOeMz+3i5t1/H4yTOevjzj5ckpi1WNDz1mHcvdINojhBCdQmIw8OrGqu4DMxLEef1ifKUUDwG8JU1gZ1jw1Q/f5t6dfUK3pl7PuVwt+OT7C2neHt7l6O777B7dJi1yLk5fkmcJSTogAG3bYKOBLerafScEqdzSJLnWZI4foW2sVIMmZWenYDIYUeQDnPXC4KnWIs8aAqnWDKKGjngJZpEb7BiNxmitOTk9o3WeumlIkxStQqQeimpkL8cKb+Y1X38tX9z46zPTm0HXaLPJormBVcPrms5fxCbZ7u1sn92btL4fB6ncvO21ZuiPCdDwJQnSoqEBx8+OybKU/f19FtWSk9NzjvbPuTg557133qccDfnoRz8SofSqZl2taW1NUB6lPHkhE05JbhiNxd6qLAq88xRZvqHZ7B/u8NaDO9i64fjsGefTU04vX+K8o2oa6sbSWTi/vMRa+ODgNl/5yleZzmY8evSEi4vT2PX2zOZXoB1/7a/9Ff7Hf+p/RF4UZFnvIC5wRFPVnJ+dopViMp5gbcf55Ql1syTNUsqyZLZc8q0/+Da/9du/R1WvcN4ivrBqI+6zfeK3mxd94IZXyymlZQCmL816rKyju/Yi3GqebGNjorsRRXeUBDWTRD0H75ldXdG1FW23outqWuPJE81gWFAUJd3FFZdXMwCmV1ckSuFtS64hNwl5kkLraNcN1jomozH7OxOaPCU3gUR5VPDRVNajk4RgobWBPGjycsj9gzt8+ugpD979gNSkNFXFsqo4v3jK7OqK9XrJcjGPcI989jRNIhQQGI9G7O/uMR6PKMuCxXLJixcvePL8hBdnMxarKgrqaKFbovEqxtIIZRZZGjnm22X3DWx1s3m+KVOE3mzBe0kw9vcG/NKf+Dp/46/8BW7vDpifv8Q2Fc1yQbtesZrNOT0+53vf/RjSjHw45Hd/+1+wnE3RaUrbdRFKE6jKaMHFd3f3sLZjuVpCULR1KzMHSiqwdbUWg90kJR2NSXRKta7RKJz1dJ0jzUqkl23Y291lMpmQpim7O/ucX5zz9Olz5vP5piE2yHKKsiQEcd6pqoqmaanrZjNUtZ1JbmPMb2I89NKs2xjuNj5987iJMW+/x7aM6Zue96YMt7/e3vSa/bm8Pu1vVsLrzZ+3m4l/ZHbHv+pjvV7z/MlzUp1xeXrJZLDDnaN7VOuaf/E7v8MgH/BLf/JXGO5MKMqC/f191mtx37auExH61YIsz9jb36UcFmij4pSYJs8SGWoJos+8u7fD3t4Oq/mck5NneBwdDSrR7I53+eTTJ8xma/JywMFolyRJmS9WnJ9NWS4qutbLUIDryK1cwC46kRSxCVMOSrJUSs7BsGA4KvHWilKetRwcjQm6YTaf8fmjJ3zv+x/xrd//Fp99/jnz5VJodijJ2rxohLzpwu6DdX/ieypVz+KQEfp+sXo6a2PACRuRHlH3kkjeL0kdF6Mx4lJT16JKaJQwNbqupVpZrGsoy4yDgwnDMqccjhkMJ1xMZzx6/BQVAlmaUaQpBDkfmRI5TIE6NG1nWSzmJDs77E3G5Ebju4ZgO0LE07VKSLIEZUqWVc0PP/qEu2+/y8N33uedh++zmM958eIZ5y9e8vLlc/IsRYfAYDiOwyXCTDBGGAxpmjAcltLgtJaTl8es1kuquiIohUlzdCI9Dh/ABRUzTukHJNGlQxpzPm6UNmZJJm6KUq77qLHyShDvv+8QRDc0YpRHtw74xT/xc/zrf+3X+ZO/+AuMc8P66ozTp5/z9LNPaZ8/o2mXiG5HhcZz8eyCer1EeUtdR70QpfABbNeBUqJnHo0hTKXpWtGnJojbuvVOKgGt8dZjW8t8tsR1lqgIgA9qIxdaiBszs8WCohCJ09W6QmlF3TYsLy/J84LEB1aVsJ3yvIiazoIvN3X7ynRff2wLHMHrgy1SHLxOw3ulERg305tQx/Zjtp/bv/7NzH4bU/YxwArM+OYA/qbNYjsIv4nx8ZOOL0WQbtsOaz2GhGExxpBiVMrXv/YVnHO89/4H7B7u8xv/5Dd49Nkj2q5Ba4VONARQiUanmrqtmM4DrRuQ5Sl5lrFYzKTTXFUYY9jb2cXZjkePH5FnhtlqhtKKylXYxuEUNLam8467R7fwXvP8xQuupivOL6YkScLu/mE0oV0yW1zw3e//gMVqxp/+07/C177xNQ4ODribJmiCMAlOT5nNZijg4OCA8WhMVio673n67Cnf/s53+PZ3vs+PPvmU+XxFRCzEZ9tv4Zu8usi2T/g21zOEyJvWZguzDrHJIVmlOAZdd6n75/cNEi+AodhPeXFDSU2cQGsb1usFo2FJ266x7ZoH925xdHhAUIbhYMDPfPAhp8dnrJZLvLV0bcugyEkSJVpk3svEXZDQVdc1VZZysDuJkpkaY3LByJMMlZa4yrJuPY3vyIqCVdVwlGas1xVnFxf84KOPWMxmZFlOYiR4Km/JEinHCZ7gLVkmHO0sNbRtQ+3W1HVN27Z0rSUxKYOBxmNo2pbOWpTu7a3YTHHKFGiHs23EWMNm0lOxfcED2kRJ0p4yeS156Z0jzTJu37nDz33z5/grf+Uv8yd++ZuMRgOSYNm9UzI5uM2tB+9z+uwZL54/5+mTp5xfnlMOhxSjEU4rnFI8Pz6mC27jY6l8IC9yxqMRdVXRxulBscDKGA7HZHmJtV3skfSGG4rGdQTnN/ZiWZnL2Lvt0NqwXC5Zr9cMhyNmswUvX74ElATjLBVZBec2yURVVZtqtvf03KzXLfhiW89kGwbpA7r310L7/X39c1/JTreumf7f7cx1G/K4+Tr9YzYBevPYa3rfZkr0DayQ7cz4Tdn0diX8k44vSZBuOTk5o8hKTk7OydKSshgxvZrxa3/q10iyhN/4p7/Bpx9/Ei8+Kc929iYslwuWyyV5kWNXHShou4Z1tZLF0HbUdc1kPOGt+/dBKZbLJXt7exTDAabI0Frzy7/6K/zghx/x4tkxDnj/w/eZjA/5p//4t7A2UBRLjMnY3z+gKAqatqZpW6qqoWnXPH7yHOd/k8dPn/H1r/8ss/fm4MQYdr1aoVAMhgPKomQ+m3Fy/pKL2Qkfffwxn376iJPTK7w3GJNHXzaLdTbqSKtXTiy86kax3Y0ObO/MvYGmTHb1IkkKJbZACPdVuV76Urigpr9AYkVQZAWJMRR5xng0INEjzlwnOjfeMb1cUC1X6MMDLmeXuM7z81//OfK04Lvf/S4vnz2jqWu8tfigSFLhyIaY7QWlqduO6XzBzmRHdMRNSus8xaAgLceQFLgCSpXgTcYHP/M1HrzzLm1r+YM/+Dbf+953RBrWaLquIdEZmdGbYKxjX4Igm5d3lqaKxgchYK27LsODJkkNWZ4KTc1qOtvhomiO8zIU5LqWgNsEBK00WknQdTFzDjHrU/q6ySUbYthUPWmasre3xy988+f5a//6X+fn/sQvUIwGeKWwwZAQ0EnO7t0hk6O3eOcbHdVywfGzRxwfP+db3/kOeTngzr17LOuGy+kMh6coCoZlyc7ehDTPOD4+ZjGfgzasqzVZXlD4Mq4JTZbkJKS0TUNTtVikFnDOk2QZugsRk4a6acnznOFQlBsXy1WU1E0j310qy/VqhXWeNM02jChxhn9VOwOuG2s9JBCCNPm3M1TvX1Whuxns+mthI8nbb543gvJr1L4bwXr78Zv/5AmvwRg36XXb1+c2DLl93Py8P+74UgRpbQwuKPb2DxiUE96+9xYffPAB5WDAd7/9XXb2J+zt7FCUKT/6+CMePnzIeDzm0eNHtE3D+fkZbduS5Rk2luKS8bWCd8euedsKMT/Pc3Gq3puQFMJJPTo6Yv/oNj/6+DM+/ugzluuKNK3IypzUy4BEkmRUdUXd1JEXK8JEtvMsFmuePXvJbDbj+fPnHB7sMxmP2ZnssLOzy93bt0l0wvHxCbPZjLOLY56+fMrL4xPm85a2ga7ThGBw0icDIpbsX10U26XgK6T6G1hdTMgjH1rH8C0bXIjDG/2Ai7AQiK4h14uv7WSqbDwcIQyZhmI4Is9SQugwaGzbMr+6In3vHVzVQem5dXDI8OeHDNKM33We0+OX6JjJOusADWgCojfR2sBkd0w2nOBMLt6G+0fs7OxhigH5cJfh3iEmLRnv7pOXA7773e/xm7/5mzx58pjhIBehq7ZhkKdkiSdRgTTRZMZvDT8kuKgbbZ1QBNM0k+faBGMT0qApEgUqwedGYKJOcHzbWVDS+1itVnSWzSRhLFsEgw4iH2uUFiEiwMZAICWzPE8pxWg04ld+5Vf4G3/jb/D1n/8GwzgsEhQ4ohAUHmtbFssFjx8/5sWzJ0zPj7l79xY7h7d5enbBxXRO0wnkkiZSyXVty3w2Aw3r1QpjjNDkAlgvsEZnHcKXNxihAdE2LRpNmhhk6lHTto6m63CuY+laQvDs7u5QtzWL5ZLFcsloNAEU62qNdY7FckWSpHgvErfL5TLOGYBWNyU+Xx/v3hgib61q71/H/t/Ei+5lfPvbtjHom8H65lzB9uf5Iqz7pkTp9nGzOXhzM/hpMuj++FIEaYCgDQ/ffY+//Od/nd/6J79JlhaMhiNevHzGg4dvsbe/w+XlCSenz7i4OuXiSjQsnHNkRY71jqqSSSnbWZbLhQzJlCW7B4fkacHFxaX48A13hOHg4OJyTjEosKcX5HmONilHt2/z9Mkxq2rNg7cfcHx8jsmEC3s1vSQEySi6tqGu4xDNssE5T1GU1FXL2dkFZycicTkaDjk6POLevXvRE7BGmYTElNS1ZzGvmU7XrKI4vlcSTEyiUM7KhW+uMaw+gL7SeX4DlqYUEfeVAN5bZImCmHkNk9sow7GN/1laG6JgUOBqOqVtamzbYnSgyDLG5YDgHPWqYliUnJ+cMr24om26jdLf8vKK4Dra1omDeWQdYLQYKSQZe0d3ufPWu9w6OmR/d8LeZEIxGKKyEpUWrBvL0xcnfPejz/jRj37E548+B+/IMsN6vWA8GsiYtBJ8PtEKgwxKmGhj55xkV3gXtwlp7iqtSdKU1Pkot6E2XGMRvVfYrqNRvR5KRpkplM4xiSQHBNkAu7aN0EG7ybw8YDQxiejoIuXx8PCQf+2v/1X++l//63zlK19hOBgghlFBNCpiD+Ds7ITvffc7/P7v/x4f//CHzK4uqdcr9g72+At/6S/x1jvv8cPPPsf2QQmF7ywEqNeWzgtDKElTlNIy8Ycn6udDEKVDkyiyJEd5YTOk0Wg4oOg6S9uKQS2uY71eobU0J3d2dqXPgN6IR61Wa7SRDa1pGkJQ8p1Ebn9PmevXbU/F69diD7/d1HyWivBaBW87EN8MsP3t24/dhjBu3t8/9yYU0kNTKPUatPiFMe0n3PfmTej140sRpOu65vHTJxwd3OLP/am/wHvvfcjjzz/j9OSYo9uHKO9Zr5a8//67eFoeff45i8WSspwwGk2o1jUXF1dcXFxS1zU7u+ON5kCeFSRJRtuJgWhiUlbrNc+fP2c4GXE5m1OfnjHZGeOs5/T4VHwvtebps+eUxZCA5+TkWGhjWi7q2fmU+WKOqJTJolsuK6azBWkqWPCgHNB1ax49esJHP/yYQTkghMB6vSbLM5bVmlXV4JxiXduYVUrW5YPHhSjjuLUwtiGP7S61MaJxjO4F5LdZHRDwBCXjwkaZjRSmi/S7/nW3R1T7ctPolLpt0Si6pmW1mKNCx6gs2N/bQU9GUZTIkRnDzmjMyfMXvP32Q9J793nx5CnEYRutFDbqYjgMAUWSZBzdvse7H3yFr3z969w6PEIDq8WcTz76jEfPj7mcrTi7mrFai+ejdx1aCc2iqmrKwtB1NZmBIk0ItiEpMrJECxuBgLPx4vMh7g9KhLCMXGxpkuAzwFoUgSxNogC+JzWGVjlUEOgkTRJCkWHSIVk+IAQp6ZWSUee2bcUByDnarqO2HU0QJ/S6rqUpqw3vPHzIn/zlX+Gdh++KJZd3pNpHKR+F7SyPHn3Of//f/UP++W/+M6ZXlzR1RV3VtNbz7PSMF2eX/OzXfhbroW0ttrOoADrESspb0UeBOKwk+75oSIkudppm8pnQBCUaGd46EY3SGussVdtgETNak6qYIQtUpLWmLMsYpOX3qqpROqGua0JgI3bWB9g+2OJf76lsT+P107WyXgXX3+Ya3wyW/c/bk7PbQTvE/73SiA9hY6cnj329sShwB69cI9vX4ZuO1977RiZ9czN40/GlCNIBKU0G5QDvAw8ePuT73/8ey8UMbQLDMuVb3/oe+wdjhmXKuw/fIgRoO0tdd9i2k0yJaJCqNMNygEaRJQW29QyHQ1QSOD09jVOBKeezc87mV7SdGGoqBGqoqoar6YKmtQQ6ZrMly8WKo6OcPBf3Z2WIOtLCG9ZaLoDp5RXBW8rBgKNDxf7+AXkx4smTxzx9cbwh2qt1RWttvADEckiZJI602ugm7SSTUn2GHJkOkYbkg0KHPmOOgjzXS1AWL33GEK/YONXl4zAB9K+nSRIJ9kmaQBRyL/MSpQ3r5Yp1K1mlGM91FCGjLAeMBiXGd7jOcufufe7efwAmZXd3h9UqIc8ShoOC1WIunHZvsV7hFKASbt+/x6/82p/hq1/9WYos5fNHn/PJR8Kbny9XTOdrrNd4I6W39x0BhzKgE0iVJngLXqGCI3hNkqeRh2vQiMxa8A6CJkQFvh7jcc4hEtACi2n6MWNFFxQ4gYNUYsh0iY6boPMizh+6iiRJGeai2ZHplFAkhDCAELDe04VA7QKr9ZrLqyuWyxUmSenajt/57d/BO/iFb/4C+zsjdBIwWmyvnj15zH/z//z7/Ivf+k2ml5f4rsM1Hco6jFcY61leXvLkk0+w6xoTQJmURMuAjbUWG0AZQ56luOAjJ74PHJI9p6nCW0/XteDlec7GgK8FkupsS5bnFGmG1hmDQYFznvl8FQOzEgmAIMNRASWemkpt1pwEzkAIouvtvTRZre0kE1fqlQB9Mzm5nuh7VaDoTeL6W4bikX11o6EXkxhxg2HDq5TPJOuhn9IN/eUTG71hk92z+R77WEaIzJnNG4X4zFebmSGaHYQ3CEttH1+KIG205mB/n6vLS37rt3+bP/HNX+LJ8+fcv3PEZDyirdc06yWndkk5FNJ8lhV0TR1dHSx3797m9u3bPH/2guVszt54lyzLqNYNddWCU+zsThCB/RXHpy94fvKCs9kVKEOa5oxHuwzKCU1j8cFQ1R1tV9N2nrwcUQ7H2K5jsZKudppq9vcPaeqK1XqJ1glozdVsyaruaDrHydklTdOwXC2xHtIsFXyyc1HdTWASFFEDImCUyMXjZVKSmHFYdy2lqCJ8IXFGRlUTIxdh19k4gn49SEEIMQYprEP8FlVPdYpCLwaSRFOWmRgXhIDtguCwBlrfQghoFZ2ibcv51RU74xH393cZDUesVyvaruPunbsMR0N8cDgv8pg+tKSpJlMlxkE63OXowTt84+d/kVt37nFxccHLF09ZTi9xrmE0Kkgzw3BYcjVdcDlbSLOxbaLJbrrhH5vN9+fQ5CgMWqd4r+msip52Aec6xCAlQWkdqxY2lDitVdykAAJomSwEsTrrRxq0lrI+08KaKYuEMiEGwE6gI63puhYVfNQTN6QKsJZMG1rrmJ5P+f53fsDZ6SUvXhzzq3/yF3n41m2yFE6Pn/P/+u/+G37vt/8Z8/MTVGdRncVYh607bCMyAZkZ0sxm2LoiDxqdp7TWxszPUJQlxluS1GBtDTpg+qAXFCEIDNW2DV3dbRzjQwC0nGvrHFpBmae4rqOJ2htdJ45DffYbQrOVvYJSHu+vXc77QC2Pz+g6qXi3eyF9hrxtkAA9RKBJkutAKxXz9XGz0pTIuhWtIzUyxPtdj7sERFs89hZUnynHPkOIxhnEZRFCiA3+N2fGSkX2SQg9SrJZOxKgPV59cQa+fXwpgnTwnizLsN7x+OljutYxGg3Z29/n9p27vHz5GKU1q9WCqlkRUBR5KVlsEErPclXJ6HIIdK4jL3KSLCXzAZ2IPfx8NWd3dwRGs1gtyLKMyXiX+XJJ11pxb7la0rYe24VodyXjrIPhmLoRLYIABFFRIs1zAh7rLSF42q6lbhvqppWueOxoA+LSbeUktm2zwe7g+qK/LgW3+J+8Ttu5CXXoOHySaAOJyJJ666I3iOz+SiNqZ0o0JrQWVxkZ8ohshthAGo2GOOs5W5zTdaKDIiL0nswI9dF7z9X0iqZaY1zHoCy5c/8++4dHjEajjbZJU9fkWQouE1y3s5h0wIMHD/mFX/k1yvEOFxfnrFcLhmXOzvAO1WrB1dVMAp0VGzXbNAQtGYlRiiLLMKnB1zU6BIzSmwuBAN55bAjink4U2o+UMPrvNF6QJkkIQRGIlLGYTWqlSWNQ6O2grBVDhizLNhz1JDEiCYrYe/V5ldZaZE8jzzZ4CfbDwYCRSnABTk9OWCyWXF1NOX7+nL/45/40tw73+P1v/Q7f+c73ubqaU9UtygWUD7RNt3Ex6TM2seeKpqzKiHWWUqhCkw1yyYKzBO8LqnrNarVEqfjZmg4bFF3bRU3r655GiOwggoh0JSbBuhbbWaoqyjFE9lHfmGfz/OtAu33090nDNsN7SVj6CcSb1LdXnwtsBbub/27jyT9Nc65/XN+P6d/7JlTSfwdvagZuf4bt329m99u0vu1r+f8v2B1Ka+azOaPBhLOzM5ra8ld//S+xWsz59PPPubo6JctLqrbicnpJQJFnrWhxoFku17SdRSvBvwajEeOdCc4HRgMZg66rGus7RrsTjFGs645yPKbF4OdLgoe2qWlbT1O3rFYNeTYARMVtd2+fziuh3DUdbedI0pTZYoX3HUonqODJC4Mn0LYtVVVFURpZ8G3bbfStjUnI84IQBFO1ccik55Ru43GS6L1Ot+t/ThJxH+8dIxLAQXQAl4UWpWQEh40NHuJtSSK+eb0bR11XzGZzvJOsPKBIk2SjQ6wVpFqjjMZoQ1AaG2C4u08xGvPDH33C8PlzDg+PePL4c9arpVhvhUCIkNLe7hHvvvMB4+GYdd0wHg95/923cG3NfHrBxXmgbmpm8zmLxRznHYNhiQtQDAoGowEmEXhnbe3G8GCDawKOWE4qBGuFa2NWIswWky2te9dxkVsNOuB8kM0sNrjSNEU7jzaOoshlA+4sq/WKphO5zjyXSk9wcxHyCpLgSz/Dhdis1Ij7TUqRa5bLFYvliunFlJMXp9y9fYhzNVoP2N29jSZhvZiLK7f2eO3QaRprKI310HlPZ50Ec22EdQIkKiXoQLDSsNVBYxBYy6lAZRu8deigUUagrzRN49+YShK0XCCypgkEkWkVmYBXA458/9t9DR/5+iLbep0Ni4jXaDRiPB7x4sVLnJVz2DvB3KS6xWjxGgZ9U+61P96Upb4mPxox8v6x29l+v5lf488ikfpFG8jNrHr79zcxRX6c8t328aUI0uKjVnB2fo7tPId7K3wQJ4vvf/RD6mrJeDLg5clTOttsKtGiEF2B1WotTcEkxbuAyQzrtibLct56+ACtNJ217O3tcHh4QN1UPH78iLbtKK0iOMNiuaRaNaRZiVYJSrnYze7Y399hd2+fxVKaVugEFxSt9Zg0QesU52TBZllCUQwwRjLoum5iEyKS4YJkdGU5YDKZsF6vqao24nGRgsA1xUeyPV7J/jaNQnXNydxmfoAEnsSIRkYSsWrnHQq5SELUntBaRxEiaJt2U6bWdYP3Qey74iaTRkNcgictcibDEaNyQLAOk6aoLOdqvuDTTz+jrWuKPCNLhBVBCKRJRp4XHNza58E7H3D33gPGozHv3b3DYFRiu4rLy1OUGjJfXDKfz5jPZ1hr+eCDD/jgw5+hblpeHr+kaioWq7kMRyQJwdpN40eOPpMRfQ3i9CWIlKnqN8FY8novjVUgNlcliPTd9+vvvL+A5f5+UrPtequq2BdQ4syO7/0lEwyJUEJNgnGepnU4X6NNQhKrrOVyxQ9+8CM+++wx9+/d4u7tfbK8JC+HXCQnrBfCc3Z1K9i71qgkJegEnRQQWqxDRupNisdTVw1tV+NsS0BoczujCVobmrbj4vySyjVoI0213pW+z6L39vaYTCZxPdcSiGOPZIPFbpp517Q0CWYCJ8j6dVtBSrL+wWDA7dt3mM8WTKczgI2tWB/EXlWru37P69tePd6U1W4f/WYCr49xbw+ubG8Qm03H2Vc2he3nvnL9KcXNDWY7k/7DHF+KIJ1lGWmeYzuHdx0uOL793W/TdTUvTk6pqzXDZU7VtnS+YzgYUFUNs8Ul9bqOAVrwQudE+P9qPkMZJeOuSLYZlBfqW2IohxPabsb52QxrIU1KauXpWk/wHcEH2s5SFgMO9g/RJkEZWdRKGwbDIU1T03USHIQ8r6mqBnDReqjZBNUk6U09zYanrdAs3DouYJlIE6PU65NojGSA25zMfsFsK2r1NCelREwnTVNAYI/W2Rhg+ucrtOoHX5RMlEV5xc5aksTgnbhxpElGINDWjYxlK3GvLosh+4eHpErzyccfs15XzJZL7t+7y2Q85utf/1mq9ZJnjx/L4EcAtKEc7nDr3kPeevtdDo9uce/BWxzcPiIrDF27glBxef6c58+fsFwuqOuKcjjhb/2tf4MPPvwq/+Sf/FPOzo7RBLJYomZpivMBo4wonwUR2nJ4fH+B9Q7TEX/WRioBYm8gCKVHtJ+RgK61bO4+QiTbbAIbJzObthEdbEVcY9BG5bQkEwsqKUEUNkqTasnPEUMAsFYyYLTCO3Ah0LQVq08es17XvPfeA95575DDwztcXpxGs18vdMaYWSZ5RpqldK3FpAbrLE0jOh22rWmrOUrDYFDK5Kjz0XhCkZoMa0KEZgVrlSxZmssHB4eUZcnV1RVXV1PqWjLpHkcWiE7W1qYhHTHbaxaGRutrCKCN2u/rdazaYpDbSIxuNQP714U+S32dg/zj6HfbP29XoDcDdH9+t2cQXmNlbDX/vui4Gdhv3n7zM/6k4ycGaaXUfwb8TeA0hPCNeNv/DvhbQAt8Cvx7IYSpUuod4AfAR/Hp/zyE8O//pPdo2pY0yxgMUoxO2NvdZ92saZoa6wNV25GWOXUXmM7mTGdLVFCCiTlPaoRlsZENNApXBXxwLKLIv9aKy6sr7t29z3g8Ic1yptM1FxdT6qrFGEOeD6jrliZ6+YU43RT7KOJGUdeMJ2MGwwFNU9F1nfRtvcf7TlgR3olzubMxc5KMuHe5uH37Nrdv3+Hs9IKutaRJQdMITQkkY7W2u26avIHuc3ORbvifztEh1DJjDFpJEHa9bRJxoettrExKVdvJ5tKXol1nBTfRKl64XaxipNxHBQ5vH/Hi+CUqSShGQ97/8EMuzs9EszgRCltrLR5Fmg8Y7R2we3CL23fus7t3wNXVFc9fPuXhe29xdOsArRXz+WwznDSejPjww5/h3r17fPzRD3n69Ak2NuPKLMPajjLL6YJk0b0AlI/fiTGakIjDs1ISpEU0KgZaL1oMEnSk1A+KaGOlpNnovXT6Tc839zHIWOq2RemIaWojWitI/6EXhjImEfqfU3iCDEE5UYLzAax3NLZD3F16xoCo0j1+fsyqrrl/74jbtw54650JtquFTtc6EpNSDkppqHpR+MvynM52rNdrurbD2opnTz6jWq9YreesVhXWWubzJdY60ftAxwrLYa38ffJ3dhhzSpqmXF5eCK1OGeGQe0V0NIg9Ctno+4zXREMLhZLJS3TMg2US03nH9Gom0r2Rrgiv+gJur/GeTdHf9qbjZoDevn17k715P7yeVb/h1b8wQL8Kn1zfdtPWq3/d7WboHwcF7z8H/lPg723d9g+B/yiEYJVS/1vgPwL+g3jfpyGEb/4Ur7s5et+yAIxGIzDRNFPGuUiLEmUyluuWZdXhnSNLE2k0GI3zclE5K9QYjJbOKYEQLN6JFuwZF3RdIE1EpW61WnN1McdaR5aJeh1BR0pQADTGZDjraeqGtq7RSpEYzXpR49pGBMZth3cyOCCDI0BQJEbgAaOvxb0HwyFHh7dJTCZO463DJHKBKMTxQwZN4mLfwk97sn8SBwyuuaPyd6dJEp0+FMF5rPeRCyycaeevhdB7HQ+I01roiE0LFNI3NXUQIaaeO2uDUMOquuJiOuXw6Ij3P3ifNMn4+Z/7Bn/+z/4Z/ulv/CM+/fgj2rqmbjusB69TitEeO/u3uHP/AYdHt1mv13znu7/P+cUJZ6fv8qf//J9GoSiLkoPDQyY7gTQtODg44vvf/x6PPn/CfHoFXjZmFxzWO1Jj0EnP9OhLVb/ZlAISDBVACOKiHcWEkjQV0aggOK7SGu/l/IfgcdZHbq5DCR6AtXJ7b/AKmqC2Rao0thNtbnHESWQDBZTTBG1xQdF5Rxcd5a0P+NCJ04sySLz1tOuOdfWSlyfHDAcFe3sj9nbHwklWhix1LKLfoInyo3Vd4aIkQds2DAcph7fu4GzDy5fPODk9IcRsWSv57pyVtZeYZKND0je1z87OXmmoyUbVMyR6tksPx4mcrVSPsZrrvTjDNcdZlCJ1ZDhVQntTrwer10WQAF4Nvv2/bwp4fQW0rfWxfbxClXvtvtfx7x+XRb8pgfpJxx9L4zCE8BsxQ96+7b/d+vWfA//Dn/hpfsKxXq8pioLOW5plR5blYHoXDMWyasjKIUM869Vqk+ngxY3Ed27joxck7SVJktgMk5PUNo7ZdEWWOkKQJqDzfSmWErzC2QAIfpYkKUYb6qqSz7haYrSnrZasFnMZptjwhuPkULi2w7lWpUs2JVSRi8vy2dk5s+lcFqePzRStSFIJqN6bSK0LoETGsmcU9Ce/b7K4frw5Qj7XXeV+nIzNcILSEFJDkqQbzqpzPrIi+gEYWbht08gAgtHo2KRzBJJEU9UN67pisVpxtH/AW/fvcefOIWmq+cVf/AUGWcJ3v/NdmrbDekUx2mGyf4vJ/iGHR7coBiWrywVpmjIejzk/O+PkxQuyzKCVYWeyEzFbmM1nHB+fsV7WceDDY22Htx3B9W4nr6KVSonanYpwkUdGtEOEQoj3a2NQMbMWnei4rGIQ6wcpdMy8JXg5PEqCuglStcSA5JwVh24gSQXGC0FeWIABD0Zh8bTO0lovKnsRQ7deMnNj0uifKB+o6Tz11ZzL+ZTyNGM0GMSNXc53VVUyyRnhgh5u67qWyTjn61//CkWe4oJiXdcoreJGYyEolDJ01pEkOpoGy7CKVtd0NR0rjD4R6L/x7ey2bxL2vH7JiP0mo4TrLPJaMF8jecergbZPbLaf0+Pcr8EQW825/tgeOrmJFb8a9OFmPH1TgA59M+zG4950vBLY35Blv+lxX3T8cWDS/1Pgv9z6/V2l1LeAOfC/DiH84zc9SSn1d4C/A1CUOXu7e1xcXsjEXNRzSNKM5WpFCFLm5IMCrwJN09JUtYQw5/CdJTiHUUqoVEqy6+Cl3EqTTHiyLtBUHV0tF4HrAC9NkMSktJ0Vx5MAZTEgSVIp7YxhtV4ynV7gnaNeWWxXk/Qc4zTFGzHTFLF9vXGQ3t5ZhY7X8eLFC+paaFRpmkuWptSGPeHj79Kc8jivNtlzH5glG8k2ZWLf1AsuxGGLXgFPMsqeWuWdx3YdRZFRliUhBFarNW3TIQ7hySbLgnhRWNGr8HiCVpuGovMCgezu7zEcDZjPrvgXv/Wb7I7HkcYGzkE5HLOzf8Rwd5/dgyNGkzFNV9O2NRCwbUPXWh59+jn7h3vkecn+QcJqVbFa19jOk6UpPveC+cdS2MWxZ2cdzlpQ8EpiFOOIC17GnLXaBDK0ZoPyh7DRz/YRhnBepgP9JhuWgOG8x8aSXkbJkxjkwVoXJ/r6IHM9POK8ImAIWjJuF4Jk0k42Ik/P2Q0E61CuxZh8U2FmWYFJNHWzom49aR4Em+7kvMpkpMNZJxBXT9X0iuFwwv7hIavVgqbrpOoIXtx6nGDyKvJ4re1w1m56FtdYbL+eJTMWuOzasHWbFdGv1W3Xku1GN8jgl7VRZySV6rGHOG7izNtwgbzPJoa8Bi9sB+WbY+M3VfOub+s3nNeP/v1DeDPUcbNZuP362xvI/8+CtFLqfwVY4P8Ub3oJvB1CuFBK/RLwf1dKfT2EMH/Dh/u7wN8F2NndCXv7h1StWP30JWZRlBHjUsLPbDtwAeVlOsr3gLFH3FoS6Z63EVuVBatJTY5JExKtsFi61oq0o3NY5zFxGsha0TdQwWCtuGIPRiXaaOZXZywXIjfqvRD7hU4niyxLsoj9eoLqYYNeR0EaDlqLD2JdrwlBWBXOEv0aVQyuotsrULACZVAqbKCOvus9KEvSLGO5XAoEkyQR8YsXhZLAIf5xARVkgENLq0kaa04aWSEyENJMegJ10xK8IzEGnWex+Xq98NM0JU3kP6EVdlxdTVlcXnBxesr9O3eZjMYENOPJDoPRLqPdffYPD7lz9zZ5rlkv51ycveTq/JjgLYNBwdnxCYOy5PDWrdigsihaZKNyWNdRN2vqpqJtG9EQsZbgYkAIAW0EW44zLpJ1e9HgwARCDEo9larPrPuL3zqPc0Egsg2tTDLtTZCOUq5GQZqLipyYKAQJxpEV4b1ocVvrpBqitzjr8dv4nxM2+2aoKUJRMmSUCgRUlhRlQVqJvGoI0LRRHyRIT6SnYDZNK5tGZymLgq9+/Rs8ePge3/v+H7BuGtI8JeDwTYcOhrzIKfKS9WpF8B1lmaOUjprtTaRrqrhyxARiOyBtB8Ft1oTb4qT362c7EF8/P2BkKDRWcduyB7zyuP627cC4Ddtt3/a6lKlcjSYqacpt1yazfaa8HTevs26BT19LuW8cXwR13MTH33T7Fx3/0kFaKfW3kYbir4f4riGEBmjiz7+rlPoU+ArwOz/utZz3XC1WDIa7mKRmPp/RNB1ZmqOCnOzWyiSTsxbfdIS+JDMalQhjwxiNbS3WBaJKEV3jWdOS55INOOvxfXmvIGiFSZXoBfsO20DwGUmaMdk9YrQ7YLa4oLPC2rg+YSIk71q58PI8i3iyio0VsasC0YlIIzMiiVmXCP3E/dv2WgGiDGa0jsI6fZB3G9H/EOUgi6Kga6Xc10qcyZ0LmKClRPV2I48ZCFgfILqTKAW286yXVdQi0WSZlKneWxSOJBGZH6MyEd/3wqfOskyE7gPU65rjFyeooDjY3UV5x2JWofw5y1GL94bxZJ/hZIedg31u373NcJhSLc+5PD2hXU25tTeJ3Owa6z17O/uoYLiaLpgv11RrGfppu5bGtjS2Zt2sxMi3roVBEAzBBgiOlDg9qXoIRxG8w8YLnxiQlY4wSGwMdtZJg9MLJqxJ6JtpKGENWedksCb2UDwaH+T7o+9KRnZElqZoI+wOH0QD2UZstu1c3AhkqtQoZBDHe0ySkheleHWaBO/ZNKHLoiBLE2azqTCLrIWoxSJDLDIK3rYWb+U9TJKyd3DEcLKDyTLKcYlpLF1XYRKDt4pEZ5TFAKOgqubkeUKWFTgvsqKR/CPwitIo/IZS2nXdJlOGa/W3m/SzNzmgJEnyxmAuOPd11i4B9HX44ObPr4qLyfSovG+ERuO1eK3lHauCeJVtHNzD9W0iSnbNWNnOnK8/7/Vcw08bgP8wNLx/qSCtlPrrwP8S+AshhPXW7UfAZQjBKaXeAz4EPvtJrxeA6WxOlmXkacZ4PME2LZPxmPVqyXw2w1krDcZY3hJF1GRyzqCUwVrJjEEGEvopIqH2NZvfRVu5Xzgulu2imeGdBKvRaIfxZIckM/ROFypyjUGy0iQV7dwuDpwkSUKWpBJktRbdAg3gI29ZbwKdUJwUSWLoOrVp0sgiEJgmiiDTj38brUUfLQSqdbWh3OnIJFCx0+697PjKCITS86yN0eKg7pywLlqhUuV5Rt5jp3EhS2ce0JrMSI6epSl5liMu1C3ruqWioq5rrkZjhkWJazuqVYu5m1MUJXmecnh0m73DQ4o8Zzq9ollcsZrP8F7YL9W6YjqbY33g+OUZte14eXrOsqqoqpqAj6pqK5bLOYvlPA48OFkTaBKMOI9EVgtKMr8QIMqryHfUwwBIg1BwYGFctO21AltQwvRw3hNaCbQ97U42vIDBo4yPDJoggTcg68/Ipt0bWlgHneupmcIM8U4cd7SWjTVLU8bjHYZjkfsMQYainLU0TU1VreN5gmpd45zw8hMj49laSQ+kLDXr1YosS6IOzYx31QN293e529zCugF1taDIUpaLmqb21NWaJA/kiNxrwJNmhjQzdF2vDOg3+Hy/VuN1D1xzyXsrsB7uuMma2MaZewbEdWb9OlywFV9e+/1msN4OlFIJvQp99J+vv997GzeDa3W8V7P8rdFv2MBiN//+bWjmDxOAf5rjp6Hg/RfAXwQOlVLPgP8YYXPkwD+MX1JPtfvzwP9GKdUh29e/H0K4/ImfIki5WFUV3joSI2O6zvnoiSbZVLCeRPfMhuvmhGCS1yfaGINREgyvx615DReztsN50SqwjaJrHb5LSdOSye4uw8GI1lU0lWCnN6UTtwdMNtoEzpMm0crK9kpfskP3wjF53gnMotNNVryNxQGb37VW5CaPZbNFa/kbe4qUihdmkuXSgHTx8wSPx0lmqBXaJBsrLbl4JMt0TiblpJF4bft03Q0XqEnHZhaRThVciA0naOuGqQ3M/RyjNPt7B2T5gHIwZLKzy87OHtZ6Li6u6JoVtlpQLZfYtsN1jqpqhfrYWZbV96i6jsV6zaqtBVrwDmc72q5lvV5RVSsZ5TYavFhYqSwhKQrSPEUZzUaIJ0DnDB6F02AQWiJO4Wsn2iJBWBo+CMe66zxGWHvC5PAWH/xG49v25rzao3QKwW0GMPqsyjtP41qqSrj01is66zeqg8IYueYGO+fI85yyFINfSTiu17TgzRbyPNI9ZXPyTpqOhH6jECnQJE0h2rppo5ns7fCufgedNjg7B3VIWaYs5ktWi4aL8xnzyzlGp2SZkcEsZTBmzHol56FrLWKKLCKvvXC/936DL28Hwm08eDug3eQjb8JAeDNDo3/e9r/98Sa8uQ+UJlIqtz9Pn6htv0+/Vrahmzd9jgCYGxvBTTbHF4n8/1GOn4bd8e+84eb/wxc89r8C/qs//MeI5aNz1HWF0ZrEaGazGd6LrkfPYOjxqD6D7IOwUjK2qyL9jfD6Trc9yilZSk1AhkfEw046/YPhmJ2dfbROaddzlosl1WotSnXxy+81CV7tFEvma23HNeZ1vYDatkNrxXq9FsflJBerpxi8+0W7/XlBhn2sbaNYvry0dTZSEFV0BNHCBlFh87eLO4iPsqQhcnu7zffVM0+ck6nNV0bRg7AWVOibagYXLL6zm4DRZ/YqNudAmqjj8S47ewdMxhNGkwmdDazqNbPFgmo5pasW1Ov1ZgS7Wres1zWrquHJyyvqzkpTLepCOyfWTj6IkUPTNCgto+pJkjDMcnSWobMMkkQyY+sFX/YKF2TkWxNIImlOmYCKIIhs+CbCH8KISUI/JBRhDhc3+iSRnoGXBu96XdGrsvXn2/fYte358jLMY931xb8ddHpGRj+WHyLX3jsblfsCaWLIspTItYh0QhWbaEE47p2FcK1bYZRcB0+fPuXZs7fZ2y8Zjyesq1aU7UKHCx3lOOW9vbe4OL3i5OmpsJycNIXzvCTNzMbhu2u72PRWuOY6IG0nQP13sZ1J38yet4PYF41Hv/n6ej1rvqkN3f9nzHXjcFvatH/OdgbfH2/aDL7oc2y/3xfd/8dxfCkmDiHuZlJ3YLsOq0SzN8/zWJZHjqZj0wnuyfOgyLIcY8zGWdtau2FBwOu0n83IdfCgBYeUYYKM8WQHrUXDYr6Yb5TdQryYXimBtnbVHkpRyIm11m3KLQl+8nsIYUOBk8fZqJ72qoh/v/i7ro1j51K+iT+cJitE8CYQmyoaoSSq6wuHLR0F20k22mfg200Z2VyuR3GlpJUGo0YRlCimQZDKxfkNkwSEOYFK8DpQlkPyoqQYDKnbjvliSWstT54+Y7Wc4ro1WZJwdHAbo1MW58c8f3HK1dWcVdPilcJkKSozmIjrOxfFoiL1UqMJDjAKFxTWBeouNu+6jq4RxxHnNUGLeBIBjIpazVsbfZIkGL2lQaE1NvQXuWxENvYHvJIM10aZWSVZA7ofQvHCT+/NZ68DtriN98d2FhdCoCxLxuMxaRpFnLo2VmciWZim0ncJXgZ00iQhWBfnAyxN3QISzLXuqYAyFfjJjz7DB8fu/gCTduzt56BaqmpO24owWb47YDQZU+3WrJcVtqppu2YzJZmkGaOiRGtDXYv12HS6kOr3Bge5D379v9sb03Yg31bEuxno+mP7WrgZpPssfvs77V+rD8jb922/d1/59knfdVKlXvv35kbwpmv/5uf9oorgX+b40gTpruswujdDtXJRhD4Ix0GOzsVx2uvyIoQQx6CzTSBzMUBvB7w+U30li0Eaa1oJDc/ZgEk0Jk1p2hYfLIv5lK6tNhf29o69TfHZnBAlgSsEFQPMq2Om/Q4vRH+1+ZzbC6cvy7IswxhDtV7TtW1s2snAgtbgbaC1soEpoY4Ib7j/m3sjWhU203XyfUjmaLSJpqls/g7vr7+PXpBXR0ul3hRXoUmNQDnBB/Ciwta6jsRkoDU6SVFJwsnLF5ydnrFaVVxeXmKMYndnj52dCd4rnj8/5vGjp1xcTlnXDa3zoA266/AVUVNbxWlAOWt5kZEQP7sLVI0MLLWtOFuHzoqiWxDaW09/UyiUCigkeJpIY0xTf13JBGQzdj7i2zKIYl3AE1AhbKRgTRJ1QBRC8Yvfu3NxYCb0o9PS0FOIaH0bnVtAdGvSNGUwGIhIFko49yFEemmHBkblgEQbmqZGB0lglEmiQqAlTWVNGC0c74DCBIV1lrZp+fRHjxiOUu7dPwTvWK4uqJslaWpI0o7VQhx7nIeuc6zWa+q6wXYygWojGyhLc7x/3XS1D7b9Or8ZoLdhie3guaEKfkGA7o+bjbmbTcKbjyfyy/vPdjOLvv5snjcNtPQbyDbeHgnj1++w9fPNDeRmZv1HybK/FEE6EP+4qK+QJAn4gOukPE+ShDzLaIMlT/KocdGfdF7BdQX/uw6kPWVtW4oQor6tCxEqSLAuEIJiMBgxGk8ohyWz6Tnr1Rzv2ziZbV77sm9CHd4HtOnFyiUgCmviWghcfpfJMPF7e9VxeHshys9qk/kmSYZzPuL0/XfQi617CTBaRwU8UFrKb9kMtrKMOLxi9DVVqR9FD0HYJ8oLNawopKELkEQKXqKvtSwkq/Ncnl+JS/SggESzbmtOzs44Pj5mtVixu7vLvfv3QGnOzs548fwFL5+/oKpqmRoliBSpDhs6o2C/oH1P7RL6W5IIFaxLHM56OiMQGd6jkSZqUCbqWasoitWjQdIjyLMM7QPBWgQQum5eqaBRAayPVVGkxwUvI93OeRmQ0UT5AMGi0zSNGK2su14rRCopmQLsRYrKsqQsS5LkusntbIe3wvrwkbkzGg8ZDAbS7G1q6koCqFMaFyK8FixtK3K5WgPB45GMeme0x7Ac8s47bzGelDx7+Rnz1VTwZS0TpYlZQ/AYoGsaFstqo0vjg4+u6MIR0CQ4q2kbu/m7t7PUH4cp3/z9ZqD7ouxz+xr5Sa/9Rff3m8ebLKv6996+Bm/iyzcz+v5z3Xzs9ob1x3F8OYJ0PAEyjBFLkBsQQpplaBKCU7Rts7lPss1kQ9UxJiE1DqckDPVuw9t6AD3lxxgDHrpOOLJZUbCzu89ovEM5LLm47GiaFQqLMXLR95+3P/osvYcMtL5ZbvUntKeDRe1fXm1A9p3x66aH2WTYWZKiPDJtFwKuc5G+1cWSW4MOJMZslNwwWhpeThxWoPeNU3gXmQjev9JIuR7jvc560sQwHo2YjCZkWUqWpNGxXYJTYgxlUch5cwGHJ8kT5ss5VV1zcnrCYrlgb3eX+/fuUbeWx8+e8/z5c6aXU7q2lfdX4LWM70sjLMoQqZ6luw3LtHgr3PZWazqTSHZpNJpAamRdJKlsRD5ENlCSCmVOyeO8UiI+FRQej/NaAAmt0SqNldy16pkyOg6dsDUGLlky/TCK7fVARCHPedkgm0Y0mPvBo+FwuAnQ232AoKS66idJ0zSlLEXStm2buJokU3dKkWQptnN0tpEegg+Mx0OKIiNLEnZ2Jjy4/xbeyhqez6+4ODmjsY1k+Vpd+2AGT6KDJPK+NzhQUQCqH4V3GAXB93MArzbRtlXktq+VbSz6JwXVN2Wd2xzs/jE3IZSb1+ZmSGerAt6cyzdAITcr45uPU4pYjalXnrd93NxI3jRA84c9vhRBmq2TYp2lbRuZHtSie6uUyG465eOEnSdLxT1EhNcdTZQEDV4yA63VBh7Yxnwl245DK2i6xqLTFKUNJs1J0oKqaWjalsV8RtuuUUqoYi68Wdlqc5uCNFEk5poK12fCfVbtY7atUJj01RLuetOR2/upLJPmJMaQJglVXdO17ZZBKBtmi84yuUWpCLlE7E8JHLL56KqnIerX3n97kWqtydJUIAAvvGPvRUhfa41G+Nnr1QoVBIbwBFarFeu2YbVaUzVrDg/3OTo45Oz8lM8fP+f5ybk0KlU0Wg1eMG8l2akU6wEt4NZmHswj3XW8ONf0gdt5JdxjreT7z7PIFXekqWE8mWA9TJdrvEpIE5EK0ADB44IYJCRai7O8lwCstZGR7Yjv+n5IW/cQlo78YbVx8nAhIGJMRCxaAm7wnqIoNlnz9jnusdW+IdtPhxqTbESq+h6LUjLYglZ0IZCXBe+/95DxaEQ5yFAKRkOhPtq2YbVa0lVLFleXLJYz1tWarlljbSd8bJPgnYKg0DqF4GOTMPZoFIQgno/G6KibrjFKi0OP8zcC2Zvhh+3r5k1B+mbiczMj3Q5228H+i/Dh6+z2dQhlOxmCHnJ51RlmGyu/fk02r3ezmbj9GW9OTd78+/6wx5cjSAOr5QJQcbTbCN/YaLwXzK3rWmwngxyJkdJbeKgtbduJvGZc6FpDnqUy0eccdS00qL4cFVHzRFgkKqUYDLEYBuM99g9vo0hYzmc436KVRYYq9XVA7k/AFtYljAFNohHMMxL+Q3hVk1hH2EJGTOKO7V9doEUhXNiua6OztmU8HGOdjeI5wptWRAnWCF/4EClXWjDk/nFpkhLiBUWcG9PRMmu7CrjG7CTbViGggsJ1Dts6SCPTIyiUk6DloheXUobBYIRKDEongCEvSvb3E5qq4dHjJzx79pyLqwWti5BPiL4x3spIvQqi+xyTUx0ztb4iUUHw8KCi04yRcyG9X4VRMEgM927tcf/+Hfb29hjt7HBwdIe6c/zW7/0BF/MFy+UK29aksQGngqazneD2SkXGipfvDaJWR4iQpJf3BSCQRI4zXKvXgVz4XRubecaQZP3GEUTX2esN39h7FR3MPbgOrKgNBq+xoSVR0hRPE78J0qNQkA9K7t67xwcfvkeWpIBjvpiyXCyYza6YXl1ydXlBtZzR1TI92HZdlKYF17aieRMgTTMxEZBSYqs5HxvGSuYHIv8IozRJkHO4vbEbZzYVotY6ToX2PP/+743fXkxg3pR1X2feEeLybmMC3a8JpZTMLcjLyDrxW5l4LwPgr11f+td+nZvtr2VMkeQBTWRNRRy7n9btA/QNAoE8hs3gmZI0/hUc+1/m+FIE6eA9y/mUNEmFpaHzuEvJ9J51nbh9BzYawhCwrqVt2mh/pMV5onMoZaJ/mos8a+mUF4Umz0uGw5Q8z2S6D4VJSmqr2du7R1nu0LY1db3GNisMUt4BopDmvJTDMeu6WcaF4MXR40ZpBmyyqK6zdLbv3kdoITa1nO1oakWWpPiuwyjIixyTGpquEe9DE3dyJVZhIPrHvUymvB7xMwSh4CkwkZ5nvZWcMPr5mfi5CeJnqBJNWuZRnzmjTEtM0LjGk+prBosiChQBPhhG4z2yIifNc0yacjm95OriitOzM2bzOU3dbLi/JhV6m3cuMkfks2nUVoOmz9JMdHaRDFeFviGb0nUNmdGkRnG4M+DDh7f5+lfe5v6d22R5RlKMKHcOOJ+tGeUJYVyQYvGtlulDayVw2Q6HvLWJbA+vZHN1XSvDSmlGUCFWJC3KCyQTgkAnsdctzUYfCK4Tiy+t0MoL5TOIDZWKTi2pMTLklGryNCdLhuSpiY3EVBKWIscFWLc1nRPcfjabkWUK42c8+fTb0mFQms62rFZLjl8es1otcd7K4EvXc7MBpURq1DmUloZmz333VoJMYgx2C7sVcozavI82BhWEZZOmYi5AuM5Uy0LkFNbzOdPZlKZpN2qAKtI1ewjwGhK8HofvkaR4AcX1CTL3rzZP2Wjk9P+L6pdKgUHhULEP0Stt9hUum/f1Pg6CxenbEOQvVehoDL1lBLD13qj+//p3lwW03ROKN22eE7b++2mPL0WQVkouzuAdXVPT1g0oGaIwWk6sVgaTCAQigS7idt6RJZIh9zthURQYpVksFhhj2NnZiV+ysBfatqWuawiQmRTnK0a7txiNd9E6oW1aVss5TVORakWiDR5N59g0IbeP69JJFlMPFfRbfJKkG0U+CeSaoJKtjAyC85gkoa1qVm1Lm4hWyWAwwBhD0zY0bXNdGnsXs/I+dYuNr5gJ9ILrQLw4/aZx6Akxy7hudPZLTSGO64OykMEhL5N8Kl7JRqmI+4tOsth2GbTJGe7skec5q/WK4+NTLq4uOT0942o2pY0Yq1xnihAcIbjIeoilbc+0iZQ/tWFGBfDydwXrUUlCnmaiPqcC4zzjrcN9vvn19/nZD97iaDenaypm8wvqpqIcjXj+9BGr+SU2ePIkCP9XG4ILNG1H3bbUXUvdtpJpuoaATDAmWiAA13UYk6J9HDRRapOleaVRRgaCbNuQGMOwzCiyDIIjM5psPBF98egtmecZk9GIyXjEznhMmeco78G2IuBvLUmaUo5GfPbsCReXV1SdKOdV1Zquq4TlE9e0ZIPCs57PFzgnOHfTeIK/FkginmuxBZOssG0a2rohxN5IokUBzxGnT4PaVBNCW0w3ZhcmVrE9rm47S6MalILOdmgNadoPUm1WPPAqdNgnMXIdCV0VAl71j5cqtR/XfxNjY6NBvYktISazwhRTQNDXCn3bD1YxQegzfGDznb0xGd4s0C34ZvvHrQqDGxDPNjzzk6CQL0WQBsmmO+s31DQJJh4hw8aR0/hH9wG6v73HnI0xFEVBWZQoYG9vj6IoaJqG2WzGer3eUNvqupbG13iXAIzHEybjESYRadJ1tcJ2HToIJSkokSbyvUGp3jKK3cKmennQvrTqG5R9g2hDt7MyTt47gCgtuh52k6UbXPzbqqraBNzeDHUb8woxC+01eT1Eml6EdYyJJXXkWmu1cTCxrfCSVXQU986RoDdUPh9EoMhog/WetjPkpiQvR9y+dZvRaEfOmUnRScbL4/8Pdf8Wa1uW5vlBv3Gbt3Xbe599zokT94iMiMzKzMqqclZ1ozYN3RYSfkBC9gO4XxAC0VgC8cITCMkIy28YXiwhNbJl+YEGJEuAEBIIyaZb7m657b5VVWZWRWZGZsbl3Pd9rTUv48LDN8Zc60RGVmZ3NVawUifj7H323mvtucb8xjf+3//yhF989hkXl5c8ffaUu7s7Ju9FAZliPr4eqJWvYH454v54oaeUZv9QnWcTpETtLNYZlFO8/+gBf/kv/Au8++Y5nQukacf15TP6yVMZS4gTP/qTP+bxF78gKvH57pqWxlWQZNPZrBas1HKGA4RZAdra2e3POouxLkvDZU6hUsI5i1IWWzUoJe9zU9fU1tA1NVYlTtZLHj08J4bAbnsnBVULlVHw/gG/36OCx6bI2CeGaeL0/gMWrWPcbbl88ZzL2zv6SWTqV9cXxBjmuUtpUgTCivNMYhoTcEgkyeVICk86rAPvPdoaonMz1uyDhCIc2EI6F/WRyjmUUfT7nnEc53timiRwQLpmKbYiSJNBrMrwXEqv4szWGupaZkzelwCBgwe1MUo8vYtXSn4cY78Hah5iZcuhIB5w6i8xUFS5Igf+9rz2jh+5E/9N2+BX68Ivf9OfxWY5fnxtinRxeZPFa+WNPLrwxhjiFBj2Az74jK/K91WVdDBiPC67qVYiHrm+vplx3NLJaq1ZLBaQFK5qqOoFq9USrcBPA2O/I07COjCugqjY7SSp+tiX4HhSXCh3MR5e8/EgrrBKZNI/EKLIkW0SwY41ByP/0inPRX2SjvqYBfBl7md5Tq31TBUrt6PRBpe9sY8OhoJhh4BwEaCo1SRNIxdQ5ZEUbTH83w/ig9w0C6p2wWpzgtGWKcFPPvmEj3/8Y549f87z58/Z7nb5Btf592F+XqVeHSYdb3bz75CxUxADImM0VotnIdFzulzx/rtv8Tvvv8V7r53SmcC0vWK3v8KPO7Sx1K3j4uI5z58/xvsekmZkIA49WxQpyOtzVZ2Hgoa6rXHO4LTFWYVzDcp0WW2Y5BSmxQVQI7TEYQqgwzxkrbWjsQoTBrG1XRgWesowV880DXg/MYaQw4FzMG0MaFU8rzW1SfS31zz+7FNePH3K1d1WQoVN5rnHINmUZJl4DHjlZYONMfuDSMentcZVFZWTgIS+H4hBLFWrSoImimI1TGGGFXSmjArXXgbIVkuiulaKyU8ZJyK/b/m5rCVGnbtfgDQHfBhtOBgpyT0pIb4mF+goJ4F8utImU1JRZbW+wsI4FrUcKHe/7KXxVQM/dfRvx0Pz468rUMlvQi8sP6t8+svP9+r3/Hrw42tSpBVt06BisYdMpBCZss2jUpLW4awkMY+jx2jLYrmgclU2MA9yJPWeIY1yBMt8VtBCHztiTng/sdsNxDhi6yVKgfcD+37k+vpC0pHVgG0MbVdjXMO+n2b14/GFP+zeGucKP/rV3bt030UCXFUVoSxm51CQ8fQsvNGakA4WnMc7fHnO4ym0FNejDDf7aqdxTPGLUWAHo7RgbClmnFm6OqNNPvpFUhJICe0wpkG5PECqHLu+Z51g3w/86Y9/wo9/+hM+/fRTbu5u50ELMIcx6AwPKHXoIsrrOh7kzFBRPklqJcZU1mjCNNFUjkcPH/J7v/tdHp2fca+KmOGWm+tr+vEWpcR8KRCpa8tPP/mU7e4uF/csVU4pc0cgeGEUhSCDH3traNsK58TAo2kamQtYkUePk8fVjqgNKacB7fuBumlp24VwoC3UBqb9HU7DsoK0uyL2PVXwxGFHGHpS8AQFQxSVocvDz9EHgnbE8TW8j2xvbyQZKMlr935EO4OKYknqrIUkmsZClSseLcaISCbFJF7VxqG1pTKZZhY1Tlu0jfjoM2yWN3qdoQVlxGkyyvtoS0OQElEdoLWUEoQMvWXdQ1FrKqVwrjpax4fiXfg74g0CztkZOjRWzzCfpOEIfHBcVMtzHxgZUvwO/17W/6sF+8tMlOMi/ctVSv1TYMmlPhz+fJUAJ2Zr2z/r8TUp0nKkLUUnRubO0x8ZJ+nWslyuaJpu7sSmaSJ5cpER2pQSBQckTdvU1LX440o455AHHBIGUDdLNqsTum7BYtFxfX3JfntDjBOoyG434L2mycIDrbV0UjAvnGMeprVCgyvFXI5xmS6X0oG3bYxgfPlrUsaNS9EiJhlkJdmwvqxGhMObXZ7fWivUqLlzzZank6RWz5RALbCBmQu8SI1V9qS0+QYBMWDCOJwRCMZYy8nJPU7Pz1menHJ1c8vHH/+UP/7RD3jx8gXb7ZZIylzqPAzUZbIugqWQZETnnJvDCkos2CyNhxnekk5XBpwGzUcfvMtf+P7vslm0pHFH6m95eXdB8DvqxmIqTVAwSfotX3zxhXSbUWOOhlSog2mS1Qqd8iYaAwQvpvgpMZJhpH1gzDDbNElwsO8HrDaEGLm5vsIow3q1oiYQ25qrF884XXUwLthe3UHwqJTQ48hwfUE/9FnaHpn8RKUVtltgbE1V1yyXS754eS1dZ9IYlfJaDyRlcFaUoTKoTJnvDJqcNhPF5tZZkz2wcwZkiPnrskgoCDcfI/eJ9L/SnSsUqIRTFm0NKco8QSFD1uP7AMDogwdNORmHmH28s+ERMPP3S1Edp/GInsicQlS6WChWo+oVGOPL3ObSsGilIDcmOhuzOWsI4Zepc4Veeng9r8IksmLKZvJqVf0qul05NZZrJM+TG5N8j8YUifHV5/iqx9ejSOdpvs6AfgxB8GCtqVw1qwPHcaRyDVUlFDw5+h+KpRTBGoVizEnd3ge8372y65Yho9Z5ceZB5PNnT7m9uaTvt6Qk6q0h+MzDlYSOpmlwzjEMwwxjHO/IwjF9NSm8dNHALAFumgafRIFWBgsyoIiQT52QOxN1wMq+vCDK34Wi5fJgz8y88JnmFQ5duFHipTx5L9c9EyokZACi94RUYrwSlRLMte0WnN57wKNHb1PVHS9eXvAnf/JjPv7JJ9zeXQuMYQ0qDwilAJu8QcQZxin0RDhsxscbmmCZaWYS2EpENpv1ig/ee4f33nqdB2cbbp8/pd9e0w8XNGpksWxAiU+GqWpUcvS959nTl4DJvPujJSe8LZlfla5da0xR7MWAMYePg5fCJOysnKBDYhx6gduS0AmTn/D9jt73xGFPd2/DtLvD2kilNdMw4PsepgETpxyMGwnaY2wlH2vN+uSUpAw/+NHHPH76HB/E8rRY3xJTZqKYmVMvAqDCcCjWAPILaq1IBMbRU9UNKhTRlKyjytWEFDM/POGDP5QjwYJQJWU+FSglZUwXDv9/OAlpJYVf+tD8vmdIxCrZyMtwTimw9ohPrRUakxsU2TBMjnE7LmkxxlkQNt8f8i8c5kNmnt2U+6YMGsUj+1Xc+KvgE+mk4y9101+eD6kM1aX5ub+En5drEA9Qyld17uXx9SjSABl7UkpkwWJkL0bA0nFVWFszTZ79vj/CsGwecmjqWorvNIoSr867cpGRy4lQFsRut2PycP++sDpubm8Zh56Li2f4qUcp8XZIeZEoJQV1GAaaphFMG+j7Xn7WNOXh4MEh78vetccYu9KaME5zsbcZ0zbK5q5PjI201jmQWd7QshiPIYyyE5vMRCEv0lc2pYxHtm2L0or9KBawqSzGKN2tykfZqhK6WeVatK5Yr8945933Wa5OcdWCj3/8Uz7+yc94+uwFN3d3Ap9oOSHMRzkQKIUCzxgq5Waa1PEmd4yvW2uJ3mO1wVSSoL1arfjd732Xh2cnbBrHtLvl7uoF0+6WyV+zvrfAOsPdbkvSBqsbVienXF/vuHh5h6HKTZBsIEXmkECulxb/7OTlvQYRsaAtOqv9Yop5cMWhCFqxJS2/gzUCC2gFKUxYo3hw/4xKRyod0DEShoE4TlgSSYm/h48BrRWurrFNi7Ydm/uv8eTlFZ8+fsZ+jCTlSHhiyMnviawhmGa+clVVjMM4+57L9QRrVYaNZCgom4+aT62KxKgmMefS0j9rzJzKkxSZy00uvmVnywNfIHEobPNjbiYKPFeajkJ4LJRGEXvJJp0LbxkSotA6zQP2AscAs/fNXEVmDFkKpVbF2L90uWIlUawZymsjX4cCFxY7Cfn3I3jiSx3v3OkfY9fpsIkcKyVLM1kexUJA1s4v49rl8bUo0qXLFdXP4ReVyXWVfaGN+OkiPFSAcZSPy7FZvk/sL7U77KyQw0NjPCpwls1myWuvvy4T/ODZbm8xWhRb260XTwQlIazGaLwfZ+vJYRjmznq1Ws2mOZJxJ9BDXdfzEf74KLbdbtkP/Stcajh4lojRDqQQGTK1qiyCQlOSTerg/Oe9xyg1e2w4a2nyRrFcLlmv14eCrsXq1AdJ8JjGkRCmueMlhXlQ1CwWvPveN7h//zU2p/e4vtnyxz/8J/zo45/w9Ll0qNo4gQMy01gbKxzkEFDZDlW6OjFl8snPopvjPzPUUQZLIWJcxbe+/S0++OAbOKvQebC2v71he31JmvYsFhZXVwyTJJNXVUvCstnc509/9iP8mFC6yg510h0mpbJwQ04QKntmx6RyIc+YeoxQwmitwTiTr7XGOAtRYV1OVw+Bpq5pm1oESdOAbWoWXQd+L4rGmGialt0kqfcqnyITSaAGYAiKzckJm3uP+MHP/5Cr24GonDBPgmDpJOE0o8Eo4SwLRVEESEZlNauOEH0u0JrNeoFShnGcUBj6/Qi58E3jIOvdZNvW3Hl+mUVE/rdSVw7371erAI8LW8wzCcGLBeLqulZsWLPPTQiBcZQppMAw2cVQvitvlocO9KvYGHJAkueQdcXs7UNkhv70DA8emqhjjPtY5p1IRzXlVXOo4+9TKtvE5pOBMQXSCOJ9rgqZYDqqgX+OIq2U+veQmKxnKaXv5s/9L4H/AfA8f9n/PKX0/8j/9j8D/vtAAP4nKaX/5697jvxMczEbhoNDmDGH3UaRXcfglY7NaBGWHFPcSBIkWqKXZkWUNujc4bbdEls1tG2D0adcXTxjGgYWi46uq7nb3nF7e5thE9kQSpAA8IpM11rLMAz0fY+1LuPg6pWds3S+hb1wPDjUSuXjY8RZK1gygcpBUsXTmdlDWSkxNjLGzsPT5EWE0LbtvIDLz2+ahnEc2e/3+OiF8meNdH5ti0oN4zSIzeeUmKaBzckpr7/9Lu+8+w1Sgi++eMY//sM/5pOf/5wp5wC6ymCcw4dRfsnMblCAdWKM5ayTRPfsxFewyAI7lWOnrB+5rpW1vPHoDd7/xjd4/c3XZRDmB6Z+x0q3+KmXbMSmYr1pMc4x9gN106FdTTQ1U4DPPnuC0Y6Y8ea5qTJqHoqhVB4k5mMxIooQqpfOPHD5kyIMw4StFG1VMUVZq0qX+CsJm4jZ7OreZoMzmqH3TBwUaSnmTVkrggGdcdRhigzjjvZMc7MfefLikt0Y8EkRVRHzlBV1EH+84hmh8onKCn46+T0pBbR2oDINLmOrNvOXURqbjahijEyZIaWSxL3JNTrEzpF+2QzsS3UjF7DSNSMbeQy52MnXFXpqUQeXIN/yvaJwlb2yPJ8PHsKrg7j5ka/N4fR2UILKEF7+bkyagzOOGVnHhfa4g4YjSEf9cgd9/H3lPXi14RTBVjmxkU9QomoVbvmvevwmnfS/D/w7wH/wpc//b1NK/+vjTyilvg38a8B3gNeB/7dS6qOU0i/bTn3pkQ8ehCCKPedqAEmHjpGmbXFOlFKVs3MRmhkLQQrP2A8EH3J3EVFhwuEJOSarqjpc02BsTdsuUdYyeM/F5QXb3S1+2pGQ7vN0s6Ktm8yp9shAcMgEfpupfiKIqOqauqpZLpbzkENwQpmwHy/aEKTTbmqdF4xYZA69xGH5IIyBqqromjaHx5ajmjrCxiuMkY66rqv8HsjC2O/3+BwxNYXAlLnWjbWSJmLIiyPMHtzSOCasrXj99XPOHz7i3mtvMgbLj370I37wox9yeXWNz6ceVxkg5GsmqkcQ8x+l81DJKrSVAiMjB4vKXYyzwueNOfS2QAUxBt55+22+861vsVx0DEMPIXD5/AnKj5y5c8b+jrqCk82CpjEi3rEVU9QEr2i7BTe7iZfX1ySbCNNAxIMSEYpGBpOlWMQU5ptYjuRqnhOoDP8UQc6Ub26LouTiaVVsTy1ET7/dY5Ln/umb1FrjU0Qlj58C476HGKkrRzKJkYjxjjFoRq95+Ohtfuf3/0WGoNjtB1AJYxIp4/nk06EuAEMemtdVA0DyI1obnKuEv4wlBEkD2u52BB8xJtsraAhJaIBVbXF1g9KWm9vbPFc5kmJnT265NnkAmUTconPhSjOYVLpPgRMOMyG53il36DFGdrs9+/1e7GVDnD1LtJYU8RgOnW/MA9KUInPzqY4hCen254gzcxisk5hPoUJNVXO2ptIWldk6hYlx+A2OX/Nc617ZpH65qEsTEBMHDF0lpuSpnWO9XHN6dsr9+w/QxjAOA/+v/+t/9JW18TdJZvlbSql3f93X5cd/E/g/Jgmk/UQp9WPgLwB/98/6ppgS230/8y+bWhabz34b1lVUTrjEVovKLOVJtc6FUzCkzHJQBpNy+neacDpR14a6WVF3a+52IyEk6kUH2jKMe/qxx8eJEAdSdGxvb1BKUdcdy8WC4Cd2uy1GH/wuJFZKurEkq5W6KY5lEmM0Dyw44FPlyKdR+DDhg0cVbwSrMdphjKOuG4gBPwyQYu6cDcuFwBfHNLYUACULt8RNpdyZ+FEYBW3T0KyWVHVNUJFxkiTulGJ2XYt03ZIHD19jc7LBNQteXGz5wZ/8Q37xi58zDD1Km9zZyNGN2XTIzkORylUkxHNkCMXHxGGyWZNWECafqZRSAoqw4+zslA8/+IB33n4DTWC/3zHs79he3bC/vuJ02VLphCfgDIxTzzBp6tpibMPt3YTXibPVGc9eXrMfe3yaiEwkFWYgWiWNkegAueGPCojSAnEd3QMCZxSPchQxp64QfJ7gZ8+ZygpeHCKNM5ysFpgUsSmhk3hQxCmiSVTOCLc4acYIoY+E4HjrvW/xzgff4u/8nb/Ls2dPiX7EGEVQHtJISJmmmuQUYG1FQqGseHDEHI6snSX5UewComIKkdBLp2oCqDanvlP8mg1V42jbBcbqrDEYZ/ZI8NmhUotXutY2t7jkYi1H+6J0VErNA2BRmB5oaQJjHKK3FMwS7KwHQ6mEVjFDASoP+HLgA7J5HJ+ej++zwhAxGUJFCbVQ6dLhJpzTeK/wI0QltNOUh8QH5OSIbqvI7pzHg8BSoHXGwfNryKwlpZScylQk4LHOslgtaRYNyimutlcUnvivevx5MOn/sVLqv4Mkgf9PU0qXwBvA3zv6ms/y537poZT668Bfh5ySEmX3FT2QQisjgy5tZ9aH0PQkOHWaJvHXOHIHa5pGCPQ+ypGIlLtOhzaGKSQuLy652U3cf/g6Dx++hmtWfP75dY6zz2yIJEngcr0HnKtwzrFer8WkZpSjfcGH54BbJcbghbFQWBdlwR5PoLU+vLlAfg7xca6rhqpqxII1eEwSCr90ao62bV+BU2IsRvLDTG+LGYM/JJokdvt9niwrtNXopIWqlQJKWx4+eMCDh6/hXI0yhp/94jN++PEnfPHkGdM00i3aWTxUhqNSLMh0QmGllNkAyPDGe4+14qmdIkQfRTORpGh2bcNqveJ3vvddvvnNj6hry/XlS7a3t+zubrm9vGJ7fYNOkWWzIU0jhoStHCoF+t2AVh0ekXW3qzUnZ/f4R3/8I4ZxEmzQGVLUxKJLzsd3zVEYhDEiKtLC3MjrlBjjTLuEw9HeB49OYqCkkBvYalHGauPYrDqWyyV+vwWdmHpPGEWtWBlNXTfoSuGUor/p6fs9Zw8fcnq64frygl98+gt2+z3aKHzGyQXfjblhjJAOlrhKHRqBEpPmfWHPRMYxISgkGBNRRnjfzjm6xQJbVfgQ2fd7FouO5XLF06cvuL25JWRTLGM0BXM8YLgxUygFuvB5MxKaq81+5nnwiBRnaw3GljmEeKNIpwxKRabJo1QgH/mOCjUcGBsHn/iU0sxwKe+by3Mpec8OYhQJB0lobfI9KVmYxb8GONpQjsQweYGrDP8ojpgfqpweUkFEcM7Sdi1V7SRLVTwwicHz/LncU027oKrr2dXyqx7/rEX6fwf8m/KK+DeBfxv47/3T/ICU0t8A/gaAq1wiT/WNNjl9Jc91lRJuq9KQyfeFTfFl39ey21lnBZvUMA7i/pVI7EfPOCnqZsn5+UPOzs4hU6J2d3fE6KmMKxAcSgv5fcx0trapXynKZSg4C0iUknRu/6o/bflTNhulCo4uA7LggyjflMYZJyyXBApFWzfUiwVaCYYLB+ysUItEiSUdTsyhqGJ4EEla4YxwsxWgrXBP/eRF7uwD1tacnG64d/8h7XLN1c2WH//4T/mTj3/M9e0t1lU0mSNeKEVN0wiUMonaTSPOepDygDeJD7ZWuZCIOVUKGYtN0k21bc2bb73JH/zB9/mX/up/ldVqyQ9+8EfcXF0w9jtur6/Y3t0Qpp5lU3P/bEMYtgz7LbVVkDxJR/wU2I4TPhjO7t/HVSJRP7jXITePOeCYWmvQ2dWsLMwsRNJKZgGHDfYwADaZc5tiROfhrNaK2jmcFcqh0Yqz01MqZ9nfjIQgOK8kvyvBomMgBYWyjhQT+92Ooe+5ub3Bf/pznjx9zDD2TF5u8PK6iwKUo7WVMiNinEaGMcde2Vwt5s5Pfs+S2COagXFmK2klPjPOim2CcxVd2zIOU96UxRYhxpiNtTJ1TVZfbjhU7rzFIzxlNoexWhg2JOrazR4dwzAwxBGSQG+yvqUgy+jiuKstv+8BEy73nzvqXI+xbblmh/9qc8CImddFeT6xTCiNxnHBnmEPlYuwynj5ERx+DHXE/BxaQeXEMiGmkE/rgZg96iW3UqDOX/X4ZyrSKaWnRy/sfw/83/OHnwNvHX3pm/lzf+bDaPEtjiHlo7FgtTFFOe5oYShKYZ6yPFc6tJgtBq0xhx1ayWTYB/EjCFEm70pJaoitO6oMqfT7HWEahJ8ZK6yOqPloJphb+bnDMNC2Lc5JJ1n+W7pmpRTRZ+5objd0do2TrlY4qNZYkbIrhfKemBOexXtEfn5TN6AUTVVRW/H5FYXXEf5WFlgiq+dMhg4UzaKdh5wqyTCuH3pJsR4D0yQmVlXbsd6ccXb+AF3VfPrFc/7ohz/ii8dPCCHStJ0s0nmiHQghzdgxiDCmHNlUtrpEFWFFylCIxsv6xntPXTnOz+/zzltv8l/+F/8Sv/8H3+fB/XsYo/jwww+4unjGk3Eg+AkdAypF2kpjCfT7W+KUh4TKgTKElNj1A1QLTu6d8fzigovra2xdyfsvESuv0KFKQnqKWciBDFOVVjlp/dXIp+NUDznGAsGTiGhlxfEuMxJsZbh/fi+zJKSH8nkorkLE6MR+CDiEtmesRpH44Q9/wD4p7r/+Jk+ePobMLY5RQgS0MTm0waPNIWWnsBgmP2TbgWxElAVEMWUvcB+wNqGjcJ6tFdbIxeUlbnuH0pbN5nReY23bst3u5qQZm0UxsiRycUayKMuMxJgS/KpQRgq0c+0cOiHkgJ5xnCSKzMf5Z8kj2/nGwyZ53PSUzv34FP2K4vGVWnUk80bmQSEcbBq8jzJXSmXjNoJAFQ8ejuThKnOk8yniy6nox5CLSmJa9XIcuLm9oW4dzlmarma1XNA0jmEYZe0WvvmvePwzFWml1KOU0uP84b8C/FH++/8N+D8opf43yODwQ+A//XU/L5HtD13hZ6p8ahAlnvDl47wQU455ipkqZq2hqp0ct5z4A/fbPeO4hxjQJoGS6XxMiqbtWCxXKBRXly+4vblkHPboVCg1CEasxf9jGnpSjFgtznpNI4Kakp4xDMOrg4RSsAudLA83TT5OiytehVGglcVolyPCarRRInZpW8FJY8IZSwpx3hAEcqgOtLWsDnTWoXQtlqBT3uAQvHkcR4a+P/JHgfXmhPPzh7TLFXf7gZ99/FM++cWnXFzf0A8TVS15hSmHrh6rK4dBThd1XRSDglm6SueOXwzvQ0woggy9chfaNjX379/ne9/7Ln/xL/4+v/Wtb7JeLakqR107PvroI7Z3Vzz/4lPSNEJlif2OBycbKqtwRrPsOpq6ZvIDIQuddsNEZRO2bvjFJx+zGweqpsGpihjG2fWvmOqXgY5S+sirOH8+f52smTR7BKdX1m3K6SYZU7cGPwzEaaRZnrJerVBxgpwx6UNk1/eYmLCmxqQkp5Smpg2axaLlRFW42vLk+Rfs9ndieOQn/FxsBAosvOiZO+xT7iDFf330HpIYbAkzRWUXQhlkS1xlzLZ0ISfOJIyWjNC6lsH06uxETlxPX8x+OdYYqlogt/1+R/F7FuZIESrJ6UJbJXj9zD8u8JzPFsIZW6dkg8rLOh7KHXfNpVv9snfO8dCuDAeLoAuEzSHvWMwzhoD3k8ArRmea33T4WRn+UBw6aYUYPEmSzS8nzRSWUmGRWaNFsTqMQjgwsApL6azzPRyjBiKV+/NR8P4m8FeAc6XUZ8C/AfwVpdTv5vr6M+B/mF/kHyul/s/ADxCn/P/Rb8LsyNtytqnMk9yYcctYVGDZ2QuOLpx0uc4J5S2lRL/fkyKCaeUX6H3EuJq6XbAfs01l1dL3fT5Wb7GUQFZIPkL2kxC6nAwhq6adj1HWWm5vb2cMrGCB4UtKpUIx0trM4puUhOtqEAFOKfBN07BcidlToSTd3NxglGaxXDEMA1dXV7IIjBhKqex5XCbnCp155AFlbMbRxKxHGYlEqqzl5OSEk9NTXFXx9MUFH//0Ez5/8oz9OBK1pmoFJzP5xFxVlmkqWLxBbkJZYEV4oLQVetE85ZfvjcETAnTdkpOTEx49esR3v/sd/uAPvs+bb75B7eRksVwuadsaaw3f//7vc3vxgr/7t/9jrq+vsMGzXi/omoqpqtCVIUXPOEzCUgkQYsInGHzgZ599hlcJq8nG/NnLJR9pZbhkcTkzMmTXvxCzDD8J/psyt14w7AMsUnDgDPFTN3L62V1d4vuee6fv0bUNYy+b6HbfM/Yj4+SptcZYh7GJphVfkC4Zzs/v0XpNtWx5+cVjtvs7EoGUPZ9VKmySg1/5IWBZ+PuhUFBJ2VTMHl6rMehQConAEylT7fL9S0yRu7s79vuBuh5YrTacbE64vLhmv78V9o+zdIsFZ2cb7rY2w14D3ksohc5DZGO1eMFnNgyQMz3zoNqT48yyIOhLjIlXS0Q5yb2qOTi8F4f3pXTZxQpVqUy/y1NjMRbLcWVJGkTnqvmapYIScczDzj7XpoQiq/nzJJlHpSK0zH+EEJZm4U8KiRQU0xiJMXvKR1Mqz68sj78Ju+OvfcWn/90/4+v/LeDf+nU/90vfIxenGCmU2U4eICpUNodPKJ1hiBgwRjx5U0piiFQwoiRUsDiP8uWC3t5t0a5jvT5FKcPjx4+5vbkUuCGrkypjmWLMCitmnwuNnot2WRRt23J7e/uKIMNYNx8FD0kwRbpdPDzI8Ux2hjcAmqbm5OQEVJxFM84aaltT161M8Q/IQx5mqcyL9mIPGX2+Li5fypxjqDVV27LoJNS0qmt8DPzi8RM+/ulPeXF5yeQD2jqsE8m80inbh0b8dOhKrK2YU3PyMbhyIjiK0efoDRn5h3EihETbLji/d8bb77zDb3/vt/nud77Dw4cPqV3FYtGyXi9o6ipTphKLxYLv/8Ff5OLZM/7x9Q21ctRVBTGSYkBbwxgDwyTSdoyDpGgXK67vtlxcX1E1LSgY/UTyo3xvOhxTCxxQmSon/ORhqPlljmx5HM8DnKvQeFSQUFuyn0XrKk7WG7SSPM5hHOmHnt1eLADqLPs2VjpLHyaatuH01HJar7gaR7b7rUBL6eBdI8MqNc8fVHqVWlaEVOXYDmT70cwaQpLMD8nxma+spOMjw7C73Z6U9jjX0zYLNpsTmqaRyLN8bcap5+rqgrqpaduGEHK02yRqYFdJuMW+3zFN4+ypHkvLljcJo8Q6NhmR3cckJ70D3l4gthKyq2dx1Mw/jge8vhRP8VA/0F+1LkPHODNIZgOwFF8p/kX5XFSRM2yoyHU/+7AfzQMOsHWisBCFCZIrt0rZQXEkxht8nDK2X6FUIUd89eNroTgEcSJLSrLTFGb+5Ut3TZ4k+vxmFZaBUoppGmdZtghLKoKJc/Jy8EHUPVpxtjnh3v0HNO2Sly+fsd/eECbJVGxcJR7CysgBMB3mLimI1/VisaBEchWl4/FNVDpcnbm1x8e0uVhnmtp6sWa1EA9rBZm+FJjGgcmL2cxms8HqSkQuzrFareciAZs5Nuzi4oJplCw9KsWU2R1oUcpVTUvTNnSLJdY5brdbfvLTT/j5L37Ort+LKVJlUUaRlCR2OGdII/gMKdV1nQdIkb4XAynnzDxAddbR1F3eZIQ2qOuKuu44PTnjGx98xG//zvf45jc/4uzsjKapWa2XnJ6saZqKGL1sxvmaP3z9Df7Cf+kv8fLJE8L2imkauekndv3AomvwITElhcud0Gpd8fa773K9u+N6e4e2lhgFktIkKVbKovNNHnPBMoaZdpeiFGkUqCjDvWIba4oqMQrMUecQWJVkqJu8pG1vNmtO1ivxJd9t2fc7+kFSaRTICSc3TyEXAplTaKJV3Fxcc3N3zegHxinO4bklMb7AYCnG+Wg/M3mi0MxMkvvH+4DRCYPLePHBveR4gBYyHFVZLSznPBi/ublhv+8Zhj4PixPTNDIOe0IYaaZaBqBJnrsfJIjAR5t5z2WAV55LfhetBRIrXb6cFkyGIDJvX0FSMW88ZDaGzidI2UCPrQUKVfKADZeqWpzmDrmjM56eZzrHRbqI4UqDV8gCctJI+bTipYM2hQOewzzKt6V51EgJHjBG0nCGfsLH4gMjdMr5bfmKx9emSJd2XwjxMbt1FeUX8osbNQ8fUJIBeMgPFHBjHIecQqFEdBBEUKKyMm+5XOGnieurK+Hg9iKWKcfHKbMeKLLTjPs566hsJQrGI4Pz0sE4l6O/jJWNdLZElEVY8gXruma5XNFVLevlmnp2+hJBxTSNQrGLLqdDi+R4Gj1t08wycGAO2t1u7wSr1hq0JYQkKS7GCJ2vrmnalrpt8SHw+dNnfP7kCU+ePGW332OsGMcoLXJbazWoSAgDWlVzISjX3ueZQFVVEng6eXyYqJxYwersgCdFQbPZnPHmG2/xne98m48+/JCzszNOTtacnG5YLRbi5JaPmEVC60Mkhcijt97m+7//B/zwH/6nbC+eYeJETInb7R4fQw6IBZJIqU/vnfHH/+CfiPw3U+u0MbisSo1J5fdH+BIpi6e01th86pG076yuK6lNurBXmCXJPrMIXF47IXhUgvvn5yzblpubC/p+nwfcQhlkEljLVhXaCBQisIrHVRXbaeLlyxfc3Fxztx/xSWNsPSseQ4AUSg1Jrxzvvfek3GkfN3YcwQOvYriHhBIRhAWijvnEJ4W/MEUKZa24f41+wiTFOMnvp1TKhcwzTZGYRMIeZzqqvLeF21yKtTQx5OFZgRXs/BsU0ExlVgVJhqYHpseB5loKdv4OZoPrXFfKPXkA4vL3W4etBGYbxwlSmGcQ88KcL+WBvXIcNC3hCUKJnF9bfpqZ9ZWpiXJKl/fJYFDGoNU/fwreP9eHUgqbAx+hXNAgc2Od8Z0Us6RbbDhFJXd0XPExY8IGkiZF6Ic9pIR1Dmsblos1D+6/Rl3VXFzdsb29JkWJKBLCWsyLSKONxjgnfOJ5gi58WWusCE0A53LuIXrGo4ytcC7T0WZ8TGTuq9WarmshxHwDTyiyY5wRattms2Ich+wF4lFJQ9Jys+RTRF3XJBK7/Zbbu1tGP6EyQyGME0oZmraj6VqqpsY4y3bY8/kXX/DzTz/n4uqKEAN1Jb+jzQMRyjAMcc5TKlFVTtg0YcJZi7gWi3x68p7Cny0QjbEKa4RO2DQN56dnPLh3n/ViSdfUrNcLTk/WrBYdzihi8KTJE6aRYdhzd3vL7d2WcfTcXV9xdXXNvp+4vusxcaJ2JotQpHgEA8kZTu7fR7uaJ0+f0jR1BsQztSofQ1OZws85lMc+MVnBmg7cYvkScdCLiNQblPhAJ4HerKuwWV6u64rz0xM0cH11zeT7XDzBZd67c5aqshgjYbpTiIQ0YtuW7W7Hk4sLtsMoJ8ucTwml8BzuGW2dYLulyKacQqgOwy5myCZlRoMUQp0ZN+WoniKZ6eAxlWzGIQaIoiR1RaugHEpHxqzMO+DekMjBFn7CxOJeJz8/+EQIYyYEiNTeaCNQS5T7V4qiRTjHJYBCxCApQx4xlLmUKPpmSXxKIt/XNsMjMRc+IRiU05k0gaVAA9qCdqAcxjoqLNGP+JDnKtmu1iefZd35+utSrOW+l8uu5bUrIFnptDWgRU8gbiLIOtF5puY6XNVkTPyrH1+LIk0SBZrWUhyzxlTI7uRcPCv44ehHxmkUvFpLmoWfhwL5QqWESuIRrBSZGtSw7E5p6gX9vmd3+4L99hI/eXEtMyZDKgkVRVRjs8lPyFBDisJOcK5GKzsnjDRNJxtJLLttROvD8ckYi3NiJGOtns2MBLsV/4oQhVAfo2a7FbzXZZzX6QpbZxVfCoIZG03f77nb3zGFkbqt6NPINCa0ddRdRdU26MoxAS8uLvj88Rc8ff6Mfr9HKTkGKxUlr9CaeeBndXbzy363ohn0WKWoGkuF4I1iHzsBwkAJXlgWy0VL3bQsFwsenN/j4fkDVnUDw0hnDeenK5adQ4WB3V3PsNuyu73l9uqCq8tLrq+u6PsBX+YARB69+S7T5Lm9fIEfejonQ69Ka1IF3ipOXrvPdhiYvAznoh9QSXpinyT4lqCyqRGZ8npg45BiPp6HuXOToeHBylJphKniQ3Yc1NRWksAVcLJccLZZM/R7hr5n8D3j6LNng6aqHcZEnJPXYF0Ndc2IRjWOyxcDN1MgulbeByStXcUogogYZdPOtWEoYhVAl5DmlOGQgo8qMR2bJp/92fNtJ5pywbmTEpoiYp1a23zyiAEf+rnr1UqjTACfZlYTHAZ2k4/EQC6qUr20MpCyN81MazTEvLHJi9GgXN6QStCA/Jwi4glBk6J0pSg133MFThS/crnOSkvnH8KUZ1wZysg/P6FISlPZGuMWKNNIQ2cc45RQxLngBikmwiYLk2yExkLQxGRQSefADQhxJKGIycnvYTUQZq8cJp99h0RhbOsFump+KTf1+PG1KNLH09yUJ+rlTS8DOZkIB4nOmgTPKUDOjP9E+SAqgUuqqpKuUDmMqdhsTnG2Yrvb0e/v0IXLW573aGJc6HWz93Se3pZaXtRJxXb0gGlFphy9pfLkv3JunrILxzPOaNkw+PmIVgj5xWPaZgOlUY3UVStOfbs76WxcRdL5iFnXeZOxGCvHd1M7lNX048Dl9RWfP3nMs+fPmcI0c8rlCKpnPnPJySvWk8GLWbp0KjnFJMMqVhvGMGGMJUyRKSUW3YK2rSVcdbFgs1py/+yURdPQWEMae25evuTqScedMwy7HdcXl9xcXrC7u2Xqe8jZf3XbsVptaLuOk82Gtq159/13+Tv/n/+Iq2dfkPIA2VoFlQNnWG5O+PEPPhY2QZjEvD8Pb1KSMAkVC8cXDp3mwQ/8IFiRhiGkSMhsito6wYMnT0iSRm2MExgqwwf3z89pm5rt7TXjKAlBSmumccQ6RdXUyEwvYZylqhsmbXF1Dc5xOwwEZai7hazrUdLUSbIJxKTmDEuliieEPoAc+Ywt615+J5fZRUK4KmwIdYBDjtb/NB3IWKVwiIDlYAlavi5mTLzgwErl8IGj4fYMvn/pIUPRwoySoqWTyR+rGdJMKMIUM8SRB6Zll83vF0q2Gnl5B+WlMVoYR0bu15CKwZZ4aCdl0NaJU6O1MuJTYKuakPMetVVgVE4wEvsFoS8aktIZqsiKU60wSnxDlHYobbCVxRqNccLFTmbEGIczNSgDVYN29VcOqef34Vf+y3/Bj+ObZOYUZyx0FhHk44oqkuPInFhchoyFDVIYFGXg0rYdy+WayXv2+x273VagBnUw/y64VpV9l48J8sGHPECoZjwaDhLhmE3QlcqMCCVhpDYfBWMIkMQ32rrsfzHFWXADAocUNkiRXYcgkWDj1MsgMsNsUxiZBpn+7/d7jJGdO0UFmQrY7wYJhH3+jKvbmzl8QKl8XMzr4niwWXA9ufGgaYSmhnJMU0+/67O4x2URguQDdosFb771FiebNffvnbLqOvx+h0mJyiqMCkz9lk9/8jHPv/gF1gk9MHhPKgY/VUVT15yennLvtddYnj+kWy4EezeaB6/d5+Llc/7wP7+l1oG78RZl5Ai5Wm9YdEs+/fRTxlEChIUJEY8w2chx3l4+l1KKSKHhyfsb5gJQuuiyTpU2JC2NgDOapqpRCJa/WC7wwcuRX8smaJTCZKvQqnLUzuVCJJ14iAmjHdth4ub6Tmhu1qGS0JhDZp3Mu/7RgEvpAtEkiEdMkCPM9zAsLJz9A+9YrkSGguZCLc5+pUH5Mje5NCDl5x7zmb9MnzvmEJePv4piJz9/zDh5gVbKfVm8zssmVJ6vvJVpnksU87PZqiFpUsp5ilHcBmVgK8VWKemajQnIVqdQqpL5gpF7yVYOXRliAmsCfhQfF2USc2p5Kj+vwhqDqzuWGdoc/Mh2ewsp0bhGTqfJ4KqGVLXUixV1U3/lNYGvUZGGwxtZKFLHNpZF1acLSTzmwY5UbulMlZEQ22K0Hzw+JJrGsVyu0MbQ73u229vcGWSbSV410wdmxgKANTa/Hp25tj4fqaQzLrzUVAQcIVJXNVVlRbef8U1ZaMwdab/v8XnoeEzAL9aNskF5kvLshoFIIwVCCSd4u98x5OCApu2oqhptJN365uqS58+fc3l1KdxnkqQ761KYDn7AxyEF5X0Qipk9CrAN2XtXbmjpqA1du+LBg4dszs84f3Cf87NTvvHOO2wWHc8+/4yXTx+j/IROCsLI1EecgWXXUtU1KguQjNYslh1n9+5x7/ycZrWGqsv2oB5UYnFywm/97vd4/uxT7i6eoqsKVEIbx8MHj5h84OryRtaI0sJ3L96kR3VBms0jEUL+vMBtgs2HkP07VD4pZW4vKaHEsQhlNLWraOqKNIzUTU1Kkbu7W8ZpyIbzkjre1BW1q6gyVKWQoFbnKgIabMXd5TU3t3dzp2uUBhOJxgpUkJgFOQVHLp2zFM70yu8oFFYpeEVkUta1nFQPvOTDfCfN99qXBVllYxCWhc0d86sbfNnwirKwfPyKGk8dYq/ynU9KgRCzA2GKs6BFRDIxU28PI9HDxnBcP6Q5Vdn9rnx/IoDOroFpnnzl74oy7Bx3+YqZ0k4TgKZZsFitJZBaWVTQjMOe/e6Wye/wIYcA5+AApRzONZzeO+f+/QeSnP7yGUG5vHnUoFz25qkwyw3L03v//0HBO14MZRcs/hwHpZE66nsOWNhM19NmlvqGlLBWboa6aVks1xjrGCcxsoEo0+ZMVTr2tS2LpxRMQBZOysOLVGSvWoY2QTouYWGM+WcpQKLpDwVCuroYImEKuYs8GIkXjO/wO8liHKZR2AaTFOcQZDUOoyimjHW4qsLVDZOPXFxI93x9fcPkp7n4HF22eXWXzrkoGUs8mFwDoUTKJig3T3k/nHWcn5/x4MHrPHztEauzEx6+8ZD79+7xwTvvcv90w8OzDf9gd8PFsyeYZKl0g3aW5XLJ+x99yP1HjzDOYpxQ/2xV4aoKozQRRdAar0BboWtB5PV33uGj73yHf/z3r6gWC+Kwp2476qrhZ5/8nGmSkGKrxTc5Irhl2RyZp+5HPOh8PLZFxZkx6ZTl5jFbkaY8R1BzCYRl21JlL/GubQgpMPiJIpkX7Frj8tdVlZPkG+dYLpaYtkMry2Rrbm4es931FIe3hCS3O+fweLEcyFivNCnyPsaY8fOC8c4n53JaOhTMAnMdOMjZGB8ggY45niq9mpx93FEfmBIHjrAsp+JlkYvWERFgfkXq1fv2sM5LYop8vwTOlgFiJM070pe79UNFkO8LxGjyeslroLgGKhkElo1bZagrRc8wekJMWNuQlAPtcHXH6f3XMLn7resltVvgx5677Ut2+wv2+2uCH0kJXN3Q1gtIhhAtwwT9GBm9JqkG5WpM1aFNw2K5oVuuMYs17Woze6x/1eNrUaTnocwRJ7EwBX5ZVCCYazo6dpWhgc2kffK0t20bwFB3S9puQdO07Pf7zJCQ4qaTzsMvcvfojvjAB4pTzPxs4XGmefGWBWWMwU8TIvF0GJ0khmtSeRIs44rgKkx2vTLLxVzAS7KLcFEPkENKkd7vJak6S+RjSHk4oSAf76LSjNPEy4srPv38U25ubvPRXAax88Kewfv0SoEGckpGR13XxBgZhwmVpMtROuZjoYhnzs/Pef3Rmzx8+Ij7Dx5ycv+MN955k81qyfvvvcWm62gt/OSHC55+NhLHAZJAVvtxQFeOk/v30JUjGZUHOvlYLWcbUaBF8YpSOe25Xa758Nvf5cXTz/mk3zMqRVW3vHx5xR/9+Od4L0OmYp1ZjsqCFkhihgQqpMPio3hgkOGNYr6EVJ+QfWS04IrFadgYLUydKDDWarVCZ5FPjBIAEAZPldk4xoIzItVu25bFYsmkDU7XDFHz7Pkl27tehog6InHxSRLBQ5o9HkrBTSlJykjmGyelZoFFifkq+OwxRlwKoc4GYmX4FmMiqmyOlDvqL5+uhJNNhugOdLqykA9Q4CHb71fBIYfuMb+mVIpwFkMd9zfwSkEv9/5xgT7eNMprOkA6haMtnitaiwI3RWYmmdUW62pCsijb8eD1d9mc3meYEiTDoj3BqJrBbKmTAmOxTUu/v8NPnrZdUtmGoZ/YjQHu9vKabINWCVN31N0JVbOgW56In33dYWyH+zOI0l+LIk0ujgVyKEO7LxfoORuPSCTkfkM8K6q6wjo5mmvrxGpIa5ytOLt3znK1Zpo8N9c3YtozG4Jn858jeXfx2ihHQ+8n/DTmoZ+fPQwKXg7CWUaBM5LgnJInBnUkeJHFsN/vCSEIpzinTB8T6ctzFycv7z22qenHgZQCOmfAKS03JYhN6O3tLdc3tzx7/oLbu9tMhbPomGTopI46h5QoHQpASWjuuo62befnnvwkCRgqEZNHazjZbHjttdd48PA17p/f5/VHb/H6G29wcn7Cw9cf0NSOupJTRFNb1uuVDCeTdFcxJXb9ntvbG0Y/4RonBo7ZK1ih5gRrBdnQXsCkhJgCnT14jW997/e4vrrm+uIFlau4ud3y8sUl3ieiT/RxxKRRJvIJwIjfs8r+3lH88bQ5MAxExJAHUVmJZzInOqTM3dcCoyRkdrHoOpgm2kUnXifkOLJpIIWAyWuisgbrZNjojKZpaqxz7AeP7ip211teXlwzToExH8GTD+DzphCzXQLycVIqW1/m02DGUwURUPNM9Njis2DU0uWKPF4oiSrPVMBPiC3qMe59NMRPqXTS8g7pArdw8DV5dQZWhBwHuOSXcWu51jodIJMD3lw2nLIR6AzrqIJ8yP8V6XWSk+Y0haMinr8+z6dUXouoTImLikpX1N0S16zYezDNhtXpayTTsupWONcSg8KPgag9yi6orWVVnbPfSz6qVoqhH9GVePRMHgY/4oNCmQpdraiXZ7TtGlMviapC05CiI6mveZFWSoJGlVLi4DUTyY+OSnL6FjMUq9Axi0wqMagRuprOUENNP3qmKdB1NWdn55ye3uPl82v2+z115bC2JhGIwWR60kQxIO/7fi6Qkrc24rNBfimgpYsOIVMHdVYbqkThiwqLoqaqpEiP45SVeFnHn7HdVwaUR/i7sFMsxtVse8G1UxSM0SjDNI7s+j3D0HNzu+Xubiv+yYAqxkAzPenAkindilJSoKuqmjum/X4/u4sBpGlCa3CVYXOy4t7ZhoevnfP6o4e8/fY7vPvON1hv1jRdxWZZUdcV/fYGrw2KSLdoWa/X6IQc9a1DxcT29pax76mXixwJdSjQGjXfWrMJ0nys1RjX8Na7H/Li2Qv+5Ad/yGnX0X/+FBmcSmESqpmoCY0RXxGUQSMBxymVIZQ8EgU3zbMDjcjDtZzMrJHotimfbsqpSyfxMlm2bcZVJS2eJO2ERljlWmUPhyQOgm3TyM9UEVfV7HYX7PuJhLgLppjmIhRjmhlMKg8PFeTifOhIkz50tgdFXRFWHU5/OjsVKg1J6cx+UCSrj76eeU3OzI10zNwo79LhIqry+o4eiVezD49hPF75eg3aoFShDx7W6cxtTpk3jTr6/vyzJK1ZvidqpinlQAlz9Bqk2CsiSbg5snklg0oOoxra9oTK1Kh6DUY63836Pt7DbteDmajaBRiZzzSNxbgbxnHHsN8ShivIG0VKCm1kNmVcw+rkASf3HlE3K5RpULjs2qlfWYtffnxtinTBfsvfj6We5WGswbUOW/ybi19G9vM1mXYjCcyGylgWyxVt12GsI+QibF1OhIgT0YuxeMFaCwVuv9/Pu77cNHLTH7+mY8xuLoQqkmLhfMswJwYRfFijs6dAFFVbhqFK4S+sjsLCqKqarm4Yg6aql/J82ezp9uqGm9sb7rZ37LMoRtR0+pWifzzd/6rJuz2yWyzPXQZNKQUUAescm82K119/yHLZ8fDhOR998xu8/943eOONt3HOMU47pv4OE2u5eePhOjWLDoMRbNaIaVN/s2V3c8f69AyrjMiIkjggqpSvmwoUBV1ZxCkPwtr1CR9867tcXV6Tdnfs+wGlhXWSUFjdYJBOOCnFmFQWVuQOMQm2XFStRfIbc3FNXrityujskiasoXEYMCgqY2mblug9aEXbNDinGHYlYDbTLPWBHldwfecslXOgFF23RFctd9sdKE1V10zDyBR9hsi+/Jj71RlOmAONs9tT4tXw1+Pvk9+/YLFFZFGoqBqsJtj4Ctx3XHgLvJiidKL6qAB/9b198Fw+dPHHg78CwxkSVgaHR0T2lOG2w5ouf4oCUqij4vtRXAKVYGQajHF5AJxQysxbvtYWY6qZWqeoSdFhqwUnZ6+h6hVVu6FZnGKrJfthz+gTq0WL1i1D38ythLEKmyzTFNF2j/cjOlnqpqVpWupuQbPcsFidsVieoW2HMg1a5ZNuCIcwiq94fD2KNILJljfMWisc1eBziq900K52tJ0cE3XuKGKUgheO2BNayzDKWhlEDcMA8Yrt7hofelIa8X5ApM8RnSWtQ9+zzxhWSeIo1K2DUxgU85rjgWPpgpU+HO+MluI/jEM2hclevCEIhzJ7SIzjlI1wbFY6KYEjo/hEJ2OwdcMwyNDz6vqKq8sL+n7H6MeMqSE2ikoEKlqbGeMr2uaYOw2jwRSmE8xy3BAPOGQmrFDXjtVqwXrVsepq1suWD99/m9/93rd5+PA12naJtY7JVwy9xGM1bYtOmu3tHT5KsMAUgyQouwjKcHd9w931DXGS58vUYXQ+vqoEyhzd+K+Ak+IcdnL/NT78rd/mD//+3+F6e0fd1ATtGUZw2qAQ747Be+Lk8ylE4I3SvShd+Me5a4v5euUiJoGymqCjzJxChtmspWtrtE50TS25m8Q8KxFLA620sDmUmHdZfeh8Q46jWpxu2CvL85eXDN7jnKQRsd8zebknFGp+K8urQ8Cfo+Hn0cAwyeJMKWUjLxkGKpVPJkn+Sz5NFZm7QvjVrrKQBSTl8xSoBE1KsnmRMfDyfs201CzLE58knWXQgr+UjWW+8SF3yxqFnTfR8ppEGKaywhbRSni5xqWxG6eBcegFhlQZPsmDVWNMpuzmblwp6daVkVNLkiT5qtmQTM0QNOeLE7qT+0RVk1SFjwptK6qmoV21kEr6PEyDWCdo7bFVi2taXGqoXUddd7SLFe1iSdOucM0SY1tQDutyyPY4Efw0w6Zf9fhaFOkEmWKUZZcq43DGYI3LRVpRNQ5XV/PQQAy6zSxBhUSIAWMkP65rl3Ttkt12y814xc31S1K8FV9jXO6e/DwUkk5pRCvm9PGy0et8M88k+1TYKIc8NRmAytCLZBDTFRk6+ew6VjyKdbEaLcMRbUCZnAgt/h9eOUKAPk1s+z3XV5fc3Nywvbth2O8hygZjYE6JSCrk47DcFCkI5lg6GEXxPs5YbJKuIyZIIaen5EFoVVcslxXnZxtONwsaDa+fn/LdD97jrUfnaJMYdldUJ2c0TUNdtxkvFzpS5eH0/AGrk6fsbu/QUQyNIhEdApP3xBgwwl2aC5Cab6ZD11WO4GIkbyWZu2p5/b1v8Itf/JRmvWRFRG13VM5DDMSo6HthRKgkGKzcvHG2m4RcXIq3cpzRXWkCgKgSgQBaYdAQA5XROCOH6VXXYkshCok4BaLPSep5bThncEaBkU5/O3hUXXOyOuHpi0ueXV0KK8Q4rHO0yHP5fiSFbOyTQYCYC1FGb3OtS/kEUuq1mgt1JJQWOOPYxSulbFQC6Qj+C642aFuLQVkUHJgSKqEy51hp6U4R5oQCYb+kbDGgNH5KmceuJZ0939whSFOldMG0IzpJMHCJXSPjyTGn+qS5MCjEP9cQpRqDcWiXSFqgKOmaFUpL12xNRVIiMkl5w9Ouwpgaqx1Ne0JVn7DtA3scg6pYtxsCFu9Feau0eK9ELGKVoPHDQO9HmIN8Gxb6hKQUVbXC2oZmscY1HeiKEAT21CZR7AC97xnG/RzJ91WPr0WRJgmUofJAy1iDqxxJk5V0CeMMrrIyNgy5QOYjkNWaoLUYLk2eIY7UVc3pyT3ee+cDbi6v+OKzn9HvLwlhyxTA4HBVQ4zjrLRzlcX7CW00bZ2tN4OY4KSUxTI5okqc+F6Nz9EqL+c5/kdu7lQ6RJUdtEgMk5j9GC0sBmUtSVl8khtCG0vSjv048uL2JZc3V1xfXdLv90I6yIXHZDI9qXgUZNwvP29JTJHXmsNujZI9QWlI4nUSQyKFiFEGZw1d17BcNjS1YtW1dLWjNop1W9E2lu3VS5pugamaXNBkc5EbC5ROVG3H2+++y/b2ls9/9vNsiO8R7wbNbrtlt9uyqi3a2bz5lY7vS83z0ZEZyGovRbNY8f63fotPH3/G9JOPSXh2cSBGxTBGQoawnDMkNGGKRwb/B1c0ZvaCFNuDzWQ+fStFCilLwSNVZTMcBE1lsVoRkoga/ORlU8jWAaZs+knwZ6UMwxRYrqXzen75Cbe7nQTHZkn0er2B5VryHW+3pCznjuX3h9IVcPjE4fqUk2YRwSRV4IZSr/VsgCUFTeYchZJnrSa6LKXHZEMhjVZOiiaSXiP5mAmrAKS7NLpCK4vS2fJXKRliayd7YQrZLtWLjDoJbk+IB4Ou7OmRQhLhySTdc0iSPK8yi0TgQ0SmDZlvmSErpXD1Am2sWMPGxBQTTdXStB1aW5puRbs45fp2ZOrvWFQLTNWStCVGjY8TBLGOWHULYX/4ieB7ximfyAkYq9GqBqMYgzQQdbPEuBZweA8qBJwzVE6jCYz9nru723kO9Ksev4np/78H/DeAZyml7+bP/Z+Ab+YvOQGuUkq/qyRV/IfAn+R/+3sppX/91z1HPk3JcTgnqOgMeRibaU9aY0DsHmM+AuZCabTIMkM6koZisbZhtToBH/mChPejFMogOXALrUlIaG2InsViQduJcVJdiwLIq4BO2cUupXl4o3NOXBlulOOUykPEmV2URFCRAG1ENhpiZJwmQtI4J1zuzHolhoh14ml9d3PL1fU1z66fCiY2DrNJe1FaKhnhy4LOA69D13lIj5CP1XwUDSknKZPxPYWkaBjNZr1kvV7iHBg9oeJAHCO6qnj2+DP+3n/yt/noW7/FN7/z26w2LWhhbYSjHUvnwdViueTs9JQnP/+UKUi3Z60h+sDzp894+MYjlusVycykuFcw6PKXX0X2T8CjN97i29/9bW6urwhhYux7gpcsP+cqVIyHLiox5++J0bxcN2FUFTiKvL4UhVorsVVeMFhjsleJx9YVRmuC93PQREkYAWH0VBmDVmmS8FnniMqwXK1BKb548oR93+OsI0XFNAVSDc46dO68U2ZwcNxp5hAMafoPcNwxBzkDG5Q5admetAKndYbqBCawRhGNeHiIDapYwGplSVGStcGglM2vqSTBI9Jn6yCJDalRjslHxrAXJlY5KU4SY1c50SzEacoQU+F4y9dJMlLKLhtIgShQWNk8jcTmkZ0E0ZNAZpm1YU3N+sFrtG0L2nC33dGPE6dn51RNi9KWbrliGiLx5iVVvWS9OsVox+5uxxSEluhy7mPbNvgoJ5Cy8TRth596mW+lREzi2a2RzEujFCqKNmKcBqL3NJUlTJ7Lly/Y7bZ52Pzn40n/+8C/A/wH842R0n97voWU+reB66Ov/0lK6Xd/g597eChJ5854AtEX57oKZx0+CCac/EQYpgw5ZC6sNSQjogGmiApSwI2ucaZhd7fnxcsL+qHHVhpjK6yBgSI3FTlvwcKappmZHaXrgDJ8OxS/GDPb4vhP7kYKeKhUwTuz65oCYSAkfIp4ZBCojdCMJK3D0Y+eq8srbm623O3u6P2OEEeIaR4kFUOflDeORJqPiAUKKipGuXH1kZm5FHVPyoG48rVNVbFatizaFq0T0fcYGyFMDPsd1eYBu+0tf/onP8DVNd/41rcx1okxlBbssbCjUDkKzZi53qokbJgpJtI0cfkicXN5zWtviIl/OoIY5Eeossbm//6yvDhRNy0ffPBNnj5+wu3NNeMwMvX97NMwTBNp8nLstocNV/jjuRnVRRKMFIiYecl5wDgX3xixWtJtkg/UKynSfpqIx17GBULJg1vnHAb5L8bi6pZuuWScPE+fPmPfD3jlGX3CB4WfAkZbht0gysDiD8EBe86XeV6jcl1e3cxkyMe8dlX5yiTwROH/pyQD7pQH8WTam9GikktR5h0hSpGWuUxOKtHyPruqxpiKqmrR2jKME7vhmsAkhS3CoDL+msTwvjaW2RAjSDjx5AsmbbJXhxTwmE84QhCw2ahIzxi7i1LArXVY11AvTlmsTjg9O2e1OeH6+pbr2zvhp4cojWDlmPY3NM2Gblmx3pyRgmLsB3zITaBzpChD9UjWK4SEMo6qEc79tB1zWIjQfrVSqCisnhAm/CRycpUi0TcEP7Hf3uD9mJG2PwcmnVL6W7lD/qWHkrvnvwX8S7/u5/yaZwElIpXKObpuQVXVxAhaWdpGFF3DbpDkEWdn1oX3Ye7gos8WhSlhVYX38OLFJS+ev2C/3wp2phN1ZTE4Ji9QSdsuALlQEmeV5oDLwhE1xs5dh6REFBpXZn+khEp6zl0siKEMb7NhUUzZb1pYGEkZwtw1GEKC7e0dFxdXXLy8YPJ5I9CC2aX5Rstp1mU4lKfa5GNr5ars/JfTOSZRU6WUFWZJuOaC1wm0s+xa2rqidoYYevp9j8JjazFPUk7jxz1awdgH/DRydXWJ7VasNuckkyGegs3L+sA5x8npGaenJzzf98RxghQzvAV+GImTR1duPpaXyqPQRyvkVabPzFzRQmPbnJ7z4Ue/xc9/9gljP6CVmnMFhfGhCQlSCGIxGtNc5VLeWQ4/U3jEks9ILhS5WMRAZS1NVVNbiT9LMXOjvbikEQOKJHatVrIPrTa4bA8aElR1jakcL2/uuLy+lgHz5OnHiNKOaRRTpRRihkDKO1865bJZ8crmrHIIcL5D8z4hxUsdQR56HsyRGwkZZIo1p6Kq6kzNrDC6IniVB+MWsTmVQm2cmIApY2m7BXXb0XUrlDbs+j2ub0lKFJsqGcZhYhonxmEk+BGXU4DiJFoEP3mhOZIFRUo6e/EOF7Mrawx116G0+GkYI82NMZWYF9mKdrGmWt6j7tasN6cslhs2DwyTF9fM/Tiw7/dcX1/SxwrjwBWpdvaXnoIYdDmXbSaiUPd8EFNjYytInoBmjIkQoG7arCo1mY8tgSZ+FGOzpnaQPNvtDVoFKmck69H/c04LP3r8ZeBpSunjo8+9p5T6h8AN8L9IKf3tX/dDZCeUDLm27ei6pcQy5Rs1DAEV5eiZgmBaxRMYC8U3QHIRFbVradsVCsPV1RVX11dst3c4O1JVAqEYZXGVyKUTB76yUuLpXEQ1QO6EBG/1PlJifAT/TYjDWsgnMsGdQ5SMtZRJ8ygj9qfW0dYtY1BEXWGzj+zdfs/t7S0317f0e0l8htK9eRFVlJtUGs4ZHigFxDqJyXLZdU9rS4qJKQWCD1lQAKBwpsI5y7JrWK9a2spB9IzjljjJMAQlu78BjGsY91vqusKZhjBNTMMg4bk6u4qZ0jPnaagC6ywn9844f/CAm8srkg+ESczxVYTt9S39dk/dNGinM6/iaChWIJRjgJpDd10uhLYVr7/5Dt/48Jvc3twwjiPWOLSacE5uZkIiKAkJTZl7rFFHle5AzytCH63NTPWMPqCBrmmxStPWDbWr6Ic9MUiqjNHZKjGrYp2raJoGkznq2hiiNtStGP9f3jyhHye0tpDGLD+Xm8Jn7+pD6yzQlgKMMtlTJM2vFQ5Kw/zRqyyOGfaS36sUakjM1rpKOmStxYNdBoXyXHXXUNkOo2VD9VNEaUPTLaibhrrtaNqO1fqEkCJV37BIS4zRbO/2pKBZrR1+kKHxfrsDokTgxYkYxmxOJfdO24l3y93dlv2+Z5wmsdVwYv8Qk3i3r9Yn1HWLsTVtu5RraRzJLTDNCt0sSa7DVo0k1gBVnHC7W8ZoCF6DHUkpMIVE3VVijVDM0/KG7qOIjEKKVE2DMZp+tyVpS7tYEUvcXV1llpJi7Eem0WOteKtXztH3e3a7W5SCpmlQwDT2v7I+/nmL9F8D/ubRx4+Bt1NKL5VS3wf+L0qp76SUbr78jUqpvw78dRDKXUiK1XrDyemZGJBPsvDGoWccPM6ZnDwiJkezn0fK7lwpihm/q1ksV6zXJ1hrefH8mu32dsbdYgzEUHyhK8mQyyKGECL7/Z7FoqNkokk3aBGBhCeEKfv3Fo6pdFmFq104mVrlFJAMNVRVg3U1rmrESQ/NlDTb3Y7rmxtub27Y73bC2w2lEyfT0mRYasoALEniRaEnFYMmpWT6HULEe8k/TFmpJm5dJsMgmq5rWC0XVFaT0sg07oheMDOVYRCNYN8x5kR0oFiJXl9cSiL7rqdpAtZVlNFHQTxya0e3WvLWe+/S7/d88cnP6W92uUhHrl684OWTpyzWSyonfO34pbp8DH18+ZFSIiSFVo7FasNvf+/3CH7ih3/4T3gxPaFTir4XNZiPMs9IUyDkQGGtFDoHGKTckaYUiSr7XJQXkjPtLJrNaoUCuroRi0x/wKq1MSStCD7PCoIX+nJ2ShMExqBdhXaOu92OcRIs1WgZKoUg8y8ZxpYEkDwMTGQ4L8NLJErwa5lFHHOT5/OXUYedXckQGZXl8EqjMmVNWbH3FbZTjbUVShnaZslmfY/V6gRjHLvdnrvbLaP3NE3L2b1z1psT3nv/fd7/xlugE/04YZ2iHyIvX17z4tkVT55ecnV5x34/Er0TloexYDy2CugYMUlomnXbYK3DLSLrIMNGYw11U6OUZvIRYx3L1YlQ2lxD2y0BTdKGIWp81Niqw7UriFosHJympqFqWtrlivHhQ8K+Z7+7w09DDtVoqKqKfhh5efESbRU2CV2uXSxomgYfJkzdsGlbaueI3rPb3kr8XfCyxqLcj+Wa+hAYxjE76gkv/uzsHqf9KX/3VxTZf+YirZSywL8KfP/ohhmAIf/9P1dK/QT4CPjPvuLm+hvA3wBo2zYtFmvu3Tun6xbs7nbEEBiHgRgC0zjhJ4vCo7IcXJy4BLOSX1h4x8aKc5vWimEc2O7umKYBoyW6ZoqR5BXO1CgS/dSL6iczNUo8lvfTbGVaFnyJo59R4MKNzus/BImf0q5CK03w4lxmrcNUDbZqUMZRL1agNM8vLnjx4jkvX77Ej2LT6Kx0OAezOrlBTcYaYxD62HGWYl3XGGMk6mjKrI4Ys3iDDNXIwuvajmXX0FTC3/W+x097CePNtKC5oKWINQpnDsEEVjsWTQcx8ad//EMuLrf8xb/0l1mfN5I7USALeemi7XKWzfk9Ts7v8ezzx1RukiKdFP3dlhdPnnLv4QNsXR0lnB+w11/1mFFWlTtwrXn0+ltUxtDair/zn/wtbq6v5PQQUz52is1kyKGtKeP0ZUMoJkUyiI4UhkdKCaMUThsW3YIw9jR1DWSv44gwR0iZ7ifD2ILeiF1AQ9BZWq4UUwjsh0EGVAkxx1cao+XfCj95ChKwoFSSBJhs0RuVwFWCy8q/K0VOPFGHnEBtwcxgiaybLM5JShofbXTuzi2uknDgrmtxlaNpOt568x0263vs9wO7/V5oZo2copqm5c033+Ls3hnvvPMW77xzn6p4nBvyMHTiyZM7/uO/9fd58vg5Wldszs7Y9yM+pcyO8TijqbOmwDiTm5uKRKIfBlJSYv9gLJ02GOeoaoE+XNvRtMLmsFXFGDzjlHCmoXId0ygnYGsNSke0SaTUMAwdYZxk+KkSfuhnF85+8FTdkv0gealg2Kw3VG3NMPT4LiftGEsYJzSGa39Fvx+ZpkBTt0LVdA60YRj3TCHgmpqmqVDG0C46Fuv1r1znf55O+r8G/Cil9Fn5hFLqPnCRUgpKqfeBD4Gf/iY/7N791zg9OeHi4oIweW5ubkTdpSH4wDTJ4c3ZnMCtRXyR8nDHGJFQ13VDu1iglBRp+XrD0E8kPEYrNC5TimSCnghZ5aeyA5xIfQsmXbx/rU0MQ2Kc+vz7wlwqVBHWQArS4aIN1tVUVYetWupajlzb3Z5nz57z/CJPd71Ir1VKh0IJFMWVQs2BtyFMmKqmrqv5+bXW+OAZc9yWyUbkOg9dnJNcxfV6LR7XRNK0Zxi3hDgBE6kYsGd6lcw4LRGYfKJ2hmmKrJYbVqs117d3fPHpZ0xecfNb12zuvSbqKYXEvBUYwQiWZ2rHvdcesvn0cz5/fkkYRpTRaGd58fQpq5+vsY1jcXbC7KH6GzyKQEFweYe2cP/hA773L/wejx9/zh/9k3+ENZYhDQJvJPHPSNqIz0cZ2KhCW5OLX3xitJaEEmJChchqtZYThjZy4gCCUvg45Ui3KNRInWjahqapqayTIqgNAYWzFcZanjx7xi8++5xhHDNbQFgjRhvGEIkqi1EmzThMaCSCSxg+mrpZQBZMleF0CGE+Vc1ybgvRFNxdhDzGVgKHBckUrJuGuu5o6o7N6QnLZUfXSRL4ZrPhnXfepd+PfPbZF7Qalusue710OFdxfn6P05M1y6Uj+gFTZ3aD1Wht8aGmfsvyW998m2fPn3F5tWOcEraxcm2NRamlUAGNZbFY0nYdrm6o64YQ5ZQrkI7FBxnKNu2CbrnC5JNJQHJKvVLUrWOxtGhVEYPQDevKUVUGpQNKB3xQ2EqDWlFbgzWKMA5y4orQRs3m3iOGyRN8xA+TDCmdY1os6Ps+N3QBpTR109H04orXKsVyscyWFZIcb2vHWXOGq+REG2NisVhgrfuVa/w3oeD9TeCvAOdKqc+AfyOl9O8C/xqvQh0A/xXgf6WUEjs4+NdTShe/7jmMdSwXKy6vrrm6uiJMHuccYRozf1WKcyH0W63mTqAU05Ad4uq24975OT5ZLi4u8GGk61qM6Umxz1CCIYSE9z26ztl2Vo6LfhoydcvJUChxZLYE43jwFhH2hHTV1lqUNviUiEljTJWHCA3WNlhbMwV4/uQZT588Zbu9EwjGR6HpwMwIOCjJ0oG9kfJzZjpXXVciDIlyfBrGQVzxEAzRVBVt3VLXNW3bys1kLSF49vstTD0gG1fOF0KbI/qYMnnKn/BhYJrkWL3f9zi75+b6BlctiFPg8uUL3nrvA5Qx+QheuumDuk0bzep0zcm9ezw2P6cPXuYMIXB9ccknP/kp9XrBW4sO0zUy2Ezm13bThykl8+vWtuLs9JzvfOe3efzFF3j/hL4fcCagDMI5RjawkF9jufw+eqKKRKPQVmLPSBK+SwisV0vCNLFsa6GMUuTeGRqrKlLwpCCnsLYRPxPx5M7D2yTKuR98/DF/9Ed/zDCMKCU+6FVuEqJKYpOKUANtjGhk3sCksbZmc3JKP/m80UinaawELit98JCOFoJJMohM4mHhbI014hLpXM2iW9DUC5qm4+zslLOzDW+8+Rqvv/GQtmlomobb2zvun9+jaSuM0zRtTdN0NFUl66x2WKvQeLSJaBUwOojAyhiMgc3a8tab97DOcHXbY8bAMAYwDtdscLVALKv1hsVyiXVyH4UQ5zlDTIpdP5AA19TUTYu2FozBx4iuRDhWO6idQ+GIXhGD1AtrpeFTBlxyEkfnGhnOxwlr2szWSRgMRENjakiK4AZhflmLjsW8C8Ycs6e0UCvbxQLtDJWtaJoWFOx3W9pFw72zE7QVKFdOQIcQka96/Cbsjr/2Kz7/3/2Kz/2HwH/4637mlx/OGvr+hqvL56QYmYaeruvYbNaiflOKoe+Zsv1jU9dU1hDyQKzvJyYPruqw1QnWLRh2e25vL7l4+YS60pyctFjdME0j/XaiH2RoYVJE1w2Va6RLUZUQ5CdmA3GtwDgtYg9naHULyIApTMUmMmIqS1UtUbrFVY1kGjqHHwOXl9c8e/qM29tbmV6HQAoh48WIv0zOhkAVWyEk6t4ktDMYoyApog70fhTsOf+MZBtq11K5jrp2dK3cNAdHvp6h96QY0AS0laN8QuwaEzI1h2y3m8eUWkkOX0pyJB9j5HbY49oaT2A3bhnGnqAiSadZal4OGaKCE187ox3VskOvW9LUo2MW+YTIcLvl5edPOL//gKUVnjwlHio/vgqXVhSXvqJ+A6Ucpmp5890PeOPNP+Xy4praDULRVHJjqQgRMbfxKeJjpGSEJ3U0ZzBm9guvm4q6Nvj9Hat7CxoHOkwQJsEkjZVZShZyWOdo6pqmkq7bx4CpW1JdM0R48vySm20vx3PX0HUd2mhu7m7xfszpIbLxGmSOkYIDXeHaJVQty4Vlu93iXIVbyJoq0VkpJoH/uoaoStCsJiZNU3UojHSi7RJQ1HVFVVV0q5YHj854+92HPHrtnNViQW0rUrqPM5LTKBi3vAPixKsOnGbhiwiLRLYm2UsNvP/WAzbrBZc3e+72I7e3A1c3WyY6qO4xRcW+H/MAWRPRIvBSZk5ccdawXC2yt4pBGS0sqgiVcei2E7jCCoUuoYtLbrmryKJ62VgzO0oi0FqZ9ygFOpGC2N36kIOvldyLiRyWrZQwdbQmNc1MjeXI7EpOUob12anMALQMIZVpIYXs+vk195PWWjH2W6zkDREmyairXYutHZWxdN2SbS8T3ilEhmFPyCqdaYJIRdMtUHrJMAR22y3Dfst+f4cfgdRjjaJrOpq6xo8+xyxJd7pcLlBYhn5EJY/3I35MOKcxBlEXpUTd1VSpZhj2TP0g0nVrM7uiomqWKLPE2ZoQxEL0xYsX3FxdSdhAjDkhQqZDNotfykwn5eJfioRxFcYJcT7GxDgIV1xp6YyUEQ/o5XpD162onHCcVYqo5IlhIEwDIfRi/JSfJabic6JB23lHhwy7kFkjQPSeZEUe262WuNrNR86QAq6pxBO6mHmpYlsvD1EYKuqm4fT8Hu3phourK1KKdFbeX5Pg9uKSF4+f0CwXVMYeNip+dYGWJjpiMh4uX6/A1qw2Z7zz7jf45Mc/Ydz2RDWAMiTjmAJyZEY2R1LKNyYCdxCZgkd5m827FIumRquEjxPOQFMZ0qiY1PzUGVuWtdA0Tc4XRJgu1jEAbdtyNUw8efoClcNmjTVUtcxSZiVrNtNWyiBSLgNKMOLz+69x/vAhIUXu7rb0+x1t2xJTZNF17HY7NicbHr3+OjfbLdpaLi4umcaAtRXTGGjbJW+//Q7LxZrdrufha/d58NoZ5+dLTk861uuWrrE4rbDKYpSVa6WkeUhHWYO80gnKxjJ/lKQkNlZxdrpifbLmzaQZpogPiW3veXmd+PmTicubPftRhvM+5E3fR2rX0NYVxmiqWtG2Dm2U5E8qxeQj+35k8gGbTNYrmMO2oUVMNq9rXWV4yGNSwBo1D9YlaMIKHBdAW4fL8ygJ6wjz/ZMJN/MarZqGpq4xlRWRXFbxSoMF4zAwDFK3gvdM4yBc6fQ19+4IPnB3t8+GKUpMe5QEyXbdgjBO+GyKH4LPrldjphaJleeiOeHs3gPabsl+13Nzfc049uLypiXF2pMwSo6U3aJluVrQ91vu7u6IPrFebViuWi4vLhn8njQFzJRz6uoKZd18ZFXK0HZLqqpBG+FOJmXQriVhuL4TxsbN1RW3t1ekIDQ6DfK6CWCybCPLXMXJMg8KNRirMFaLyUuQUAEfbM5JrGiqhvVyzWK5mA1ofPSkIJtM9CMxDKjkMSqJrzOZ4UKkZN0VDu7h2F+ob1kpqfQMtzx48ADnLJdXNzhX8+5773F+dn5AJY7mfYmsIqVwTKHpOpq2FR8NJQrNKQSG2zv6MBGdpdusOX/jdUz1q3G6w9PlQnH8ApJ0d03b8f4HH/DxD3/A7uaGqa6EWogixJil1ocNSWtFyq55MSG+0TrkEN7E2cmaZdfR+710ZbFsbDIY80G61cqJ/WvT1CJUyhh2tBVpErbN02fPubi6zmamiODm9iYXHBkUhiC4qNbkRPsa58RZzbmKe/ceYq3j5vaGtm34y3/5L3F1fc319RX7/Y79fkvbdfgUsVXN/fsPWS6WeB9p6o5Hj96g61ZiJpYUp2druoXjtddOWCwsSomvilXqYCCboLg9qVffiK/+IPuZl+NiZkIyBcXgReaNtvg4oVWkripO1mv6ENjvR6YsKGkage+UTigt2Z6SUCTWCkoLfGEzK8c6nWcjsp5lved5dLEszeyWmGuKMeXeVlSVw3vZnJ3LKy0q/OhnO2U9kw3EllhrTdu2LJcLtNXs93vGQdwZdZ6bpOLjnqHN+e9/xuPrUaRDJHihpGhtqBvHouvYbndcXV4TvBetfk4CL4yKYmgu7IlKhgfGst/fcnd3hR97NDGLTeQIs+/3DH3Poluw2axwznB7e0s/9Ex+kiNnpelsQwiDDBXjRJgiJkqeHkpL5hkWHw0kKykv2rDvPZfXF1xfX7G72+Kngcpmzw9p6WXGroOYO8VEjKJUNFgKvj2rBYFxKr+ro65alt2CzXpN1zbUlXAyp2lk9DvG0At/K0Uh08cJRcI6k49dihBGpjFmtoqfC9UhIikKdomEqEp3L5zOi4sLnLO8//4H3N71NFXNcrV8tU5yYDUcwGL5RN0I9c9ay7C9g9FTG0tIkaa2bO/uePniBacPH/xGRfqXH4dXoY3h7Pw+H3z0Ec8ePyZ4yShMDNhpwttsxJRAfKmS0N7k/pG16QMpeSyR2jkqrXGLBaQoUWlRCuo0eUIQQQPOZuyzDHDFi2XbD9h2gzKOzx8/YbeXAbTOePUwSBpRUqJ+1NqStLT2kUzZqmQIuetHSJbf/u3f4/b2hpPTE77//d9l8gNXV9dorbm7uyWRRMpsLOvVGmsdL15c4lwtCsB+pNkI3OGcomudDLERKVHZBLOoHoUVe8/f+CEmWSEk9uPA7X7gtvcMQbEfYQwGHzTX24APUiDrpsZEsLbC+4CzMoMxRhFDwPuJMQ/6lRbDqdLWamNQJhKTqBzj0ZuZYtlfIgYRkFXOoFxNjF7eO4Seq1VimkbIXioq+29ro9BGNnGNcLaNlYay+LJba+bTcLFtSIiDojWWFCJ+FNplXVUkK+Efv+rxtSjSxhjOzu4zTRPWWKKfuL3ZilcFCWtsdrfTjCHgw4TKTm3GOlarE9557yPWJ/e5vtmz292RwoizCpW9ogvJP2QV2jiM9P2euq7pug7rHNvdln7c03YNxonpkTIGEzQ+n2lDLAGlMlgTA5eK/TBxcXHFy6sL+mEvAZVeZKByPAqk4IWapfPgojAHAFDZSlRMj1JSxfaDEMT+c7XoWHYti66hcpbkJ/rdDXEas7nSREqS4JKN5bJpWE47SQGCKqDzXJyP/bGL3Frgl8QUIrWzWCunkf1uz1sffoPf//73+cf/5Ac8/eIJNy8vWZ7eB1sxBzoXGh6HAq2UJFDXTUtKiSlIHiFGYxBjfWsM25sbxt2eqm0OOMKvfaijP8w4aFXXfOPDD3n8+Wf0w05grOAxlcEliwpKVIiIFbwEJWT+e4I4ejRQ1Qa8Z+r3rLoakkj0pykccHMFxijh9GdcuORmehRJJ5puwYjmsy+e5Ey9mqDULEgRTrTKTomalOSPNnkwHTxNt+DBg/u8/fa73Dt7wP37D2kax93tSNM61usTjNG88eZrWCu2qCjNOEZubm5pG8mMfPbyJSkqHjx8SIqJ9arl/vlaOsowgjmsVbmmgBI+dVJ/dvdXHilPSoOP9P3I1fUdV7uRIViCahmCYvSJhMVaiMkTkGLaZshQziKRFCacNTRVi3EKV2mMFS+cYfSMozgfluOcKmpgyIZMRX6tUEkAJJ0hP+cqQhBmyBwlFku6y2FRay1ddqHcikAsWwMD0yTBHsc+4uM4QiJ7lMg1dZWT+ds0MIy9hIH8isfXokinBOMgFDLTCvaqlabrFsQ8JTdGo2tN0hu0EqmzszWLds1iccLZ/XOabs3t3Q6jI6ebJZulI8TA0Pf0w56+F+cqrdQ8/S7c55DCbE50fXeNdTKYrCtR7kWVbxhAaUddd7iqw0fD85fXvHh5yXa7Y5z2JB0p2Xqi3Rcs2BoxoZc3Pds+KkOVYZ7oY96kImFKKCtJJucnpyzXa9qmEmFL7NltR8Hu/QA5kVpbMMrPoZaCDBYerUcaycLxPk7MKPFdxTVDvjtmA6txGjFajvBd26JQ/KN/8A959vySbrlh6Pd5IFX8hylUC2mk5ZAnoiESdV1hnWDOUxSRgnWWyU8M/cB+u2fY71nEE16xokhHL2/+DTOb5JUCTQYLFWjN6f0HvP/RR3z+xWfsdlv0MKCtxkRDVMKm0UlJN50NdCQ1OmKSRxNY1B0OhYqBxjk0RwEQGYdOWgZzxkjgg7EGaysq54gx4poK1y548vSCy6sbjKkYkSIjAq0s31dF+JI3C20xRsKBF8sl773/Ht/57u/x7W9/h2HwDONA32/p+x2oQFUbTk43dItaCpMPTF5S6U9Pliy6lsop7p2u2e1HtM7DuGWD1YoYRoZxj7Ma09QyBDva/FDxy2/Er3wIyqFxlaFF0/nE1u/Y7SM+Kqag2O69tLkB6dKVmqGAlKJI+zGSSZjInHRkDmQsTW2F9VSHPATX83xF8klTLtCRsQh+8smAKNffI5uz9wXzK3izl5mAzk6RczCu3N/GapSyWRDnKYyskD3aUzZXSlnOHr2I54Zh5PLiJfvdlqp2R83aLz++FkU6ROEYnp6c0rYN09DLUVIrgodpHDNoD1UjHey4D2z3t9xebamaa0JSnN1PeL9le3PB1F/hjGK5WrG+d8bkJ+62W4ZpIKXI5KfMXlCMfkLFSVgKCG0pJPFuCGi0qfJQoUYbh8JgTMVuP/L02UteXlyx3fW5iERQAWMET7baYJTLC0K8AORkZglBDNTRLdZYfJoYhoHa1axWK1bLJXVTUy8qkk5Mw459vyXFCZ0iJA8qoI1sACqrBENKhFQsHA/835hKIklCaYVVJVJLshqlgxB5vBY/1HkQNk0SqXV7e8vPPvkZJDC25ZFp2N1t5fc6gjyK4dM8PlRApk62bUvbtFwgNwg5UcVoIyZF40QKWQGXDgNVFGLg/kv1IRdk1AwVQEJpg06Rplvw3gcf8PzpE/bbrWxQWnxc0hDlPU8KnQQvVUnO0CrKwMsqxWaxZNXUdI1hvVgwDT1DnxWi6YDjG2vmbtpasROwrkJPnhg1ylZ8/vQ5oxdV46tpMcWYXk6I4gynAUPTtVRVy3qzoek6+n7Ps+dPeOutd1ivH/L48Rd88fgLPvjwPc7PT3DVwYv75uaG7XbLYrGQNVVZ6srQPDiR5+dw6lJEYhDBjc0TzxgLc+bgonh4U3/NI3eiGoWrDIvFgklVUAW2g8KmCrRn6CfJWURejHNG8PpRTj7Kil9JihPTGJAgC8uoHAkrrz/DCrKpZSc8rYmGHO6hsFoofGKvE0Dr3Kcze/DISyjahOxwrorCOGYPei9hI3muM6s9c7NQ0Iui7UgpzTDHOA5st1uur28IfmCzfsBm8/8bMcs/t4fRRtRNzjJNI7e314QgR4QYJlIUqXUkcncnUTNhDFKjtKNpWqxN3N2+5PLlFwz9Nfg9+96zvbsBNNY5qqqibmqsNUx+wE8egqjrinpRaHjSgVlnCRjCBNY1JCWybq0NL1685Nmzl2y3W6bRY7S4pYkaMF/WLN8uiSgAVumc0uKwphKPXSK7/UgYJ1aLjvv3ztisN7hMQ+vHW6awl3DTKF7GRmUfkRCprIRzBj/hvQwAC0ugMEcgCUUudwwqL6rZSzt3e8XXtgxVjBGYpOz0wXt2d3fUrqZr1wz9wOWzlwy7PU3dHhb5EW4Zj2BprTXdYsH6ZMPLFy9g8hiXlaMhELxmd7fl5fPnnLz2QJ73uNh/+THTBfNf0+HripcyWrHebPjGRx/y2We/YJz2xDgy+R3aJ0yQGLGYEiHJC06ZkUBMNG3Fg3tnrFcNZ+slZydrLi8u2G/vxAAp5bAJa8UwyMi1TzFmBaNm9BHXLkBbfvbp54w+EpQVB8GUjeizR3ZShhBLoIRDG8tqtWa5WqNNxWq15M03X2e17mhbw9lZx+RPGMZb7t07ZbVakAiZvSMFJgYxxRqGXpSAqaKqnOQA6vz+pDQPmE3bUAyYyjBNutNMVfkNHyn/j3xqs07TNhX9NDJMsiEu25plLRj5fghs+57eT/g4Mk0jkx9RKeCsygHOgg/bSjJFmUZ8dnsxxsqAXss6D4BKYR7UyYmlwNQKoiFQlAKZZVVmNFZOVCHm3FGt5llDXTtK5F7JgRyGQfzotZk3s6jJ91pxwYwEP2EU3DvdUFeWzWY1WyN/1eNrUaRjitze3ogPEYkUPeJCNpEQabKAQFFMj0JRjYnNaFcbkt9zc3fBfneBn+4wccqudQcajg8BvCImj6sM3aKDoLi9u8upL5bBe/oiLlCVRFiZGl0tQDmutj0XL1/y8sUL/DhkObrQkVL04BMxHPx8pdjZjJ+Lc1i5MbUSExdrLOvViuWiYdW1VFYRvGe7vyEGzxT2WKtkAKnywkxi25hUjuyM4LPjo8iJpTsQabakW5chuzLZWCj/u7ESmaSUYhxyYnMu7DEnmYQYGYeBUFeEGLDGQYTd7R0///nPeP/pU946OZ1NacgDx1BQ6Ywta2Oo6pqmbem6BXjp3EOMqAQuiZvhzfU1fd+zaOpDB/eVtUEd/feAR8p9lkEQpbCu4sGjR7z3wTe4vnlJP9zhBss0aWwUOEYnhUm5K1egCJBg2bQ0zpG8Z9V1LLuOm6vLbPXJ3EkbkyXH2XS+gNUSHKHolhv2w8SzFxdEFKMPhDxYg5KJaUjKYWwtKjRlWCxX3H9wn4Smblp+53d/h2984yNevrjk8dPPqBvNo0f3uP9gg1Iqq0gTMWpCSJxsNpysV2JJe5SOLm+LvMgiYZdioqR5SHJdjC4DZeY1k+ai82c/hNEgKyEizYRRCZU8BJnZWMSlsPfggycGnyOlhKmkSaQUCH4iWRH0dF1N3Vpi9MJoIs+onMBCCfBJSQJ6MOhJ3DKVrQDxR5FBbySGNEOEh6KbKbr64G9CErpmsVnQ2uV/k07dWi0eN0qiwIKPDH0R0MmG2RZOdYxy0sqK6D+XmOW/iIeCvEAhBinQ0gXaHOHj8y4oSQ0pyLnUWstmuWDZ1sRpz7C7Jkx3GCVsjhjkxqmbDusqkTjHKZv/C4Vm0a4YpoEQJlRWL6IlxSNGTdOuaNoVQVU8e3nJF59/zjhs0Yg01JrM609kV7WCXUvnobTJP08RIoxednhtNW3XslkvWS5anFPoJD67w7jFT8JrVhrMFHBUVEbYDiEG/OTxPptQBRmOpJhn8lp4ySrj3yEFUo44UkZJynT2fyjOfyWEt6SWzDaoqEzBE8WXHOllcQ59j3Owu7vj+bNn3H/nXdquyx3tl97g/JeChWutJVZsGhlDxKocVOtkoLK9veP6+oZus54dB5k3oD9rNR2A65gl9VZrlDUslyveffddfvGzn3B58Syb3mi0jnOqjpT5bJYUFcY41suVhIWmSGWsGOhkCK5M8aULU/PvGEOQa60kudwYx2q94fNPPmW73VJM87UpDAQZaMUoHumbzQnWOrS2vPv++yyXa+6d3+fb3/k2jx69ToyJ+w9kQHh6tmCxsvS9sExSkrDiYehpmprGWUocWF6h8zWcva9VvnLzMFm+Nm+tB3pm/t9vPM/lMITWJJzRjMaT4gRRkpRGr0jUKNNROSeHIavxMWQ5vSZ6CfhNwRMnUMnhlEI5S1SSCC6Q6EgsiHP2dCknCjESkU1YWQnmMMaInUGUQFvxkp/yOuXg9ZFZP8X9q3TRQB4Sa+HFOyf3YJIUIKs1Qy8n4BQTySqaozCOygm99WsvZpGVkBU9uXtOpT2MnjiJBDQm+eWVihgD60XNybqB2ONHRQqD4LXSdIvvgStT3YgPE1MYUTbiPYy3A+RU7P2+p2panOuIKaFtQ1V3VHXH3Xbg8YtPub69IYWJrq6xWtzpKqPQOkIJAYiaEDQxd7Uxn/UFXRAe5Wq9oWtrjI5onTAMhN4z+UE2pOBRSk4QCoW2BlJi2A+ifMoue9pUUhCi3OByfJUhRkgxT7LD7Ic8J6oDcHDQE4n8gYpXCmxKChEjAwTGUcyb1qsVANPUY6zFh4Hrly/YXV3RNLXAGyoHlirQqchOZMreLjruPbjP0ydPuByGXKykkHg/0u8T/kXk8WefcXp+Rtu0edMxx2jGvHQK9yCp0jsXmqPOaCOC8zY19157xMM33uCLLz5j2PU464mTwiAdm4bMLhCebVV1bDYnGWaSzWl7u6PvB0KQ/ECNkdOSriTBJERGLanrkrqRUFWNaRc8eXnFzsMYs4gIJWKPnEikjKNul1SN2HR+9M1v8i//1/9lHjx8yGq5YLHopPBHGZz1w8SLiwvutnuWy272dLm7kyLdNo6mcajZelXolRQufDZlKgNQeWjISTCyBjJkoQtey3yVf12tLiwb8bNWOK3oKsvpegHJsNt5VPLsx57RR1LGkztTEfLguq5dxsoj0Qvn37kESZJwGqcFMkNk4cMQGTLFTaxmlQgPlGLoA5NP+T6VQaHSCmcV0U8YHSWPEYs1TmDAJPcHCZQ+BE+XcJAElJANY2x2j9RUlaWqxC/E+4kYZPMMPsgpOCV8mLLJ2ddczAIJqwIhBhJB1GMxSo4fEZt9kH0y+JjQTCw6y9lJQ1cHhmnLFBVhmkQinLtYox3WCNYzTSMRj3OC/42+p6ocU9gDYsxkbYc1S6quQtuaYfT84qefc3Ut6RLOQG0BAjqlOakjBimU4zgxek1Sdcad5WaorGO9WLBeLSXKRymS34PfkoLPN3KYXcu0lp879gGMnjsuIJv1c9SlyU3nnBMMOwqvu1jgKUXmKojXiYqQiIQwopMMCIVulIUZ6SitROXJtcpijDCy2w2crATnM1aB9txtX/L4Fx9zdnYiuX3LdSmNqKQomSIx3+5N1/LO++8x9QOfoNjf3JK8n3m5IYwob7h69ozxbsuiaYQ9Qh4gzuKIXGTKBsDh769078jvEpOlWi14/d33+OSnP2e480zbhE87nI5EM8qAzFiGIG6Ep6dLlicbhpsX2LpjCoFdP+CDFKmQB0jWdBi1QCVFmLYkZzDGypAKTbvcMOmKn3z+lOiWaCuSdJPhBLDUiw2Lkw3KyjzkzTde56/+1b/Khx9+RNc12Bz3FkNgGibuhsh+PwI1TbciAeOADERjxFkloadKshgLBCUVNuVZCTBfeTlFpHmQJv4hqKwuTJFIwObj/G/STAsVDVJusBIKZxSbRYWKGqcHutpyM0Su+2xHaoRRJQZYI6GfJNpNQ9NBWymcDcKFVkqUkEngCBMDlY5YJ0wpZZSwhvyEVgZbG0KlmUJiGCO1k7xPj8Tk1cbmU7TCT4k0ylXRwdKPI54Rm+lzMUaBMJWWLjwErHXUzmKs/NxIEgfEqAlToO8jkx+JKeJyQQ8x4ePXPIhWkfPlYrF8R/6bZBe22SZzCsy5Z9ZB3WmaVqMnSxo8fj+K2b4VLErpSFDjjK35FIHiEKaZggZnAY2tW5pmQ0wimX3x7LnEbvUiOLCVlg0gBMHKEBOcGAMpxOxpjQC+SnbWxaKdu5/a2RnO6fd7/HCHTgO2aPxTDi0oxafcQDFJIUjCua3qClCE4OeE4SJ8kXy+kNNXymVUMggrl5TsVZ3DZ4c4zUNVifE5hLMWhursN+Bht9tzfXPDatnmCCN5uRcvX/D4s0959P573OsWs3eBTjJ8k04sv99as1yvODu/x9PPv2Dc73Ngq2LoJctxUzmin3j+5Aknp6dQsvgoBfqfboUVXLyqWx69/hbvvf8RqU841XClrwghUgfPlCJBOfox0jrD+dmCaZqIMVJXNcMwsNvt5NorlU8xWY2HRE8ZVdM0jqquxTTJVLTLDeiK8/M3aBeXuLrl9PSUB2dn1LXj8uqW9dkDPvjot7i6uWO72/L222+TUs3jJ5csF0uqyuKnkSdPnnB1c8fy9B6b9QlGG168uEGpyKJr6bqabrFAqSYH5ko3fEi6ybh9pkv64s8u7zYhRnGSC3EeelunheJpjwv6P8Mjw0qVVazWFleLG2E7RVa5cJY1OI4xu8tJxFzb1pysa9atxirwIZHJQdLE+UAIOp8aK5pKJP3jZNgN8ntFZUBZQtKMo/DcpwBD0LTKEXxiGBP7wbO72TL0npK2VjcVVRWx2eI26IRYJ4PSiCGWn9j7Ee8zdBrzJpyEQ10SfGpXcXqyIaWefoDVqv2Vl+xrUaRBZWWXWEOSi5W2OstihYNKClgLtbW0q1roeE5c8aL3aJdwSqN0hWsd0zRx01+JDanRpKhwocZoh/eaKSiitVS2Jhkh1u92W774/LGY8tT1jEnFFBgHOfLE0oWkMliT4lZkoYvlhm6xyInjihhHhn4nnUgMhDCRkhgFpmxBE6IXqhEKbbKwoxJPEJU04zhmVVtWT+XjkqgTxe85ek9IWYmby4ZALglDmq1LtdJybVOSpJi2RWEY+hHIWZP5NFLUhj4EDDCmxBi8BLuGQK3AOQllvb684vNf/JzV+Tm2W86li3QwSpKhSswYYKAf+jlgdwqRaZzQ1pKAYT/w8tkL3n6vp8teCqiD9/M//SqTInSyOeOb3/o2491EW69YrG7Z7nqmKBt5AFIIVAYaNbG7foYJHlc5xnFkHMd86su9Z940QhiwtsY5Q7doabtWYAzb4OqO/Wh46+0Pef8q0CxXPLx/n0f3T4nBs+0HAjZTOS2r7h531yM63aBpudsmrq9uePz4C/p+j60qHlHjTEdi5Ob6Eucsp6cy06nOxCpAIZt20UirdACIpFuW9au1kZiqFBj6keubW66vJKujaxuapsI6zWq1QNcOY9JvtlnO+FQBolJuFsAZMK1wpWsUbYhcXe/Y3vXopKhqQ7UUN0prFVVl6CpNrZMULptxdFXYPcWDRqi1hRIancF3jcyEQsJ7GKbIdpi43e/wg2cMh6Bf4yMVgUbv0GYCI4G965OaQGI/9iIxNxadB7xJOYbJM/kA5b4JOT0qJsLkSSHhtKVZOEmGUrJxOC0d+a96fC2KdEpCXxED+0pw6Vych3FgCCNag6tAW401kW5laVYO8ITBM8aeZANVVWGrBlvVhDBhbxW3t9eMQzbXiYbGdHTtClwNbQNKc3235+r6gquLW/GDtpbJe6zRgiNl3LdQeWxOYrHWYrWmaaR7WSxWVFUFCvwkwoyQY9+VinOhTjEQOBaUMB9FQxTLLqttHmDIRLlMoqWZVHPuolJapPUhEaY0czdVNrRXmW8bM83KVo66csQUBLNTlSxuY3NMWeFKy8BNp0gKCozN1BCHz5vU/7e9P421LMvy+7Dfns50pzfEkFGRVZmV1VVNtkBapGlLBmXBkCBb7C9tA4LALxYlCCCgAbAAG3DbAgz5m2zAAmTAkEBDAkhDMCnLMkQBNmCaIilQJrtFNpvdXazKGiOHGF+84Y5n2JM/rH1fRFVndlezrc5IIBaQ+d67970b+95zzjprr/UfQojUlSb7QL/fc/HiJV/vR1y7OI6YXruIjuSPjDaCmZ3P5hw2m+JYIT15qxumYQCz5+bqiuePn/Dw/fdxnVQbP92X/lmqOtGdEJ89a2vu3vsK77y7ZvKaqFqy60XruWmoK8tw2KBCTxrW3Dw9cDar0UYz7Pb4ckMpTcoCTcuMYy/zkiKaRcFsu7rF1guGyXB+72v8d/6xeyxOz7h8+Zxvf/c77DbXZK3RVcs0KSrTcbI6Zb5YoFVFVe9ZnVSMXtGPCuOWLFZL7t57wPXVmsl7lBKsfEaDLoOu8tnkrAkxM4wTwU8yfM/pVb9cQU6Zm82Wm92WzWbL9dUN282OuqpYLRecn51y//45TV2LI43Sv+tnfvzkX337+u01vXoNC45MZTLNSY2fSfV/JAZVleXIcTFETBEpO7JjX3W4yg2z9MyLaB1GiaZH1lBrRTSKaDUL61jWDZvDgb0f0VpMBirXEGPmcNDs9we8D9SV5eS0Bj1jt5/oR89h8ByGHlJE2RptMiZFgfTlUnyFIv3gAxpNbR2+n7jZXOLunmHcxNhLAfd58UYkaTjqRsh2XGuoa0fV1JgehuEg7C0N2mS6tubegzNWy5r9YYvtDKp1XK0PbPYj2UZMZyAmZrZDVZnDvodgSaGmMjPqagW2Zh8zV+sbXr64YBonbHE7ySGUNksiRl9w74bKibX7arkQtasyfRYPRIQ1FiZSCng/EoMMM48JOmeRk5SEddwuq+IOU+jgZVt/FFtKJIyuMDoXE9yj8JFBoQlepsMCN7O3kCmlXg3sjhoEZFDKoXUl/Wsfyk3HykWeQpns51dVtxaKcmUVpjKMMeOCrHG3P0ivLzekEDlsd2w3G7qV2CwBUJJ0KsO9snhWpyec3Tlnt75m572ojmFFAjYlwjCyub7h048/4e47D3BtIxj227L8Z0vQ8DrYRBAsTTfn/lfe5fJyy/YQMV4zjYHadrzz4D6zOrG+eMyLxweapmY+b0kpcRh66U3GKIPJWyyx9IpJGuda6lraajFrbN1h6jnbbaT3hqo74WY78hu/9T0+/ejHpDAQU8JULXW9YDVX1FUjOjTDxHq3Z768oe1m3H/wUPSTjeHi5Y7tZsdqtWSxmNE2FfN5R9PWUOylfPAcdgPrzYGbmzWH/U4ch8o1J0w6zzgMPH1xwZOLCw59z2HfMw0T827G1776Lq6qODs9Ke4x6vZDfV1M9rMtzl4bGt9OKo6zA2F7JsTP1KpEUxsoLb3jySLnu8ynZCgnA95ywh8HKOVEeHVG6NJ7F+OMV9eEEa0EmsrQNiL36gsOunIOY6TCzakhhOUrU2ptGMZIqzL2rMM4x36IrLeezcEzBYiNwUdFH2CYAj704tiSRNRrGDQ5JKbDhheP9yxWNTH17Pa7zz13fxbR/68CfwG4Xz6BP5dz/neVUmfAXwLeBx4B/3zO+VrJkfp3gV8EDsC/mHP+td/xH8mZyhqySpLMVCYQmDUNzWzJZh1Fb9koYpo4PV/wjZ9/n9nM8cnjj+iHkWa1IFc12e2JyoDJ+ODxKaKsY75sIVTkUOPUgmnQXF1seHJ9zTAOKEToKCtJijElmQqXlkIzn7FcrjhdndC2DW1TY4rbwjSKEPg4DsQoal4CCZIEqDk6UCtSzDKso9zplS4DGm5LxGMVEVPR88hlmJgp+FVKb1yS9i3RQJlbJUF5nXwLE7oFmCkIUTOMcjLnJKgClBN3D0Ux1KXonUgmVMIQYPRRWjVZ0dZQO0Pfj7TG4MeJFCPXV1fcffBQbiJF0+DYExYUhjQeqrpmvljgqgpbOTo9K1tVuSGSZbg29kMRR0LII/qnsL6/20l8PM3KGhQaYzXz5ZJmvkDZNdlMKJMZJ8/V1SXN3Rl17dAqM+sa2q6h7w8MkyBsUi6JoiQTrTWusbSNE2KTyiVLWJRrUdWcw7RmfQgcQhDrtOsdiYr5csZ8sWAMCR8EnpmI+DQxn684Oz+jqltxOdeJ/bCnHwZilJ2jcTVdt6Bpa1wt1lwxwTiOPProET/43o+4eHnN+notcrkI5JCUmMahnEMQciYUX0WNiAb1fc/HH33Mfrdjv1kXrfKHWG1f5er8qqpV6icp5Pk46C670GOzyqhXUD5XmnOGV+dbycCv5d9XTMdcdgm3C7hNzq9HKVKOL1deM6Nu1fEgYwzMVEWOZbeX5LhOQX6utUU1DrQi50irIwcmQpqo9IzZSc2ys+z7msMY2O4HtoeJpm5Is5q5DURvSCEx7Ad2mw0mK1Tc8+LFBetrRzefsd2sP/e8/Vkq6QD8z3POv6aUWgB/Vyn1V4B/EfirOed/Wyn1y8AvA/9L4E8htlnfBP4x4N8rXz835GAVKrWTfU3MgZQn2qahyzVKU+iVNXfunTClAX/YM6SRKcvkdnW+wrYzLq5u2O520pvNDmMachT6aEiW7a7n8mLD9c0OrzTWGXIMhQYrF1jbNczaTiBziwUnq1NxxkYRCgsyhHzrhSgmtQWloeQ1pF9WhklGCXMySxvBWEtCoEKvqmBd4H8FbpaSkF2K5nAsDhxyQejyvBJXbCMuz0fdAiHaqaLNXrbeKd0KCMVctuRkcrakZAqzzGDsKwv7FEtS1YaQCoU2ZJrsSNkIeiHrQrPN5BA57Hb4aaKqms8+4ArpuztL23XUTcNht5O5RIriRpLkgtbB4IeB9fWa+ckJRfzkHzLkok5letXNZ5yen/L4yTORq/QjTsE09rx8scMfbhgOB5wTh5bN9ZVYXWVuXWhAIJKuctRWY60iZ08/Hmj9SNXOqGdLPIbDlJmSZjtMYBu++v63GLZX1E6xXC7ZHAYmH1jOOuazGd18zp17d1mtTvEhcnNzw3a3EanMlGm6TpxMXI1PYALs+4yPApd89Ohj/qu/9f/lk48+IfokbkBFNMiPgyTKYpiqTXHzWS6ZLRZyTqExdYP3novnz9EEvvWtD5i8x1ktN+7MLXTzJwgvxwr4OAAv2tPqtSMhqbn09fMxESsEz3x8oeNf6NsfM5r0GVX7Z92sjzuv11rxr7J2Se6CgJIbV0iiCzQetuwPW3LOzBctVWVlgEmkcYEQlUgXhMC8rpm3jpgt/Vhxcbnjcn2gqhrePTuRmZWfePnihgvTo1CM+wGt9qRg8X1gGn4fSTrn/BRxASfnvFVKfQd4CPwS8D8ov/bngb+OJOlfAv5ClqPzt5VSJ0qpB+V1PjME0BDLhN/gnKapKpSJDGFPyAPzruPu+R0q52g6w+NnjzEuC43WKnyOVJVheTqjHz2XL6/xHmq7RKuWaVDsd4HLi0t2216ga4DNGh2l4nTOMJt3zBdSNXdNhzGWqqrFnHXyRdJQnFWM0a8Sc3HuVqVdAhmiQhVlN620iK2YYqRrdam4XUm+cGQROieCK75Qto0Sh3RR9UqvVNqUvO6xxZGyAiUUb9HkyLfVDSiyTqgk/4ZcXArrBJrnfSrtJpF+VSozjRMxZJIusKysy80mMXnBp2pdo9AkL69dWce8nX2uYExW3OpxaGNYnqyYLxasr68h51vn96QMDkXWET9NXF9e8uC9r6KtueXo/Z4HiEfkTGm7NF3N+Z1TlssZm+sr/BCJw44+AVVi2osmeVckU6dJdkyUwevRdVubo+mDxdksbRsjhBhXtWjXsN71+ATYGltbVt0JD+49IE17psMWV1Uszy1T8EV1OXEYA/veo/SeQ9+z2+0I3kP57Iwx+OCZgqcKkcxEjIrtbqI/bPnwu4+4vNxhdM3gt+XmnSVBA6REnCaG/iDVqjZ476mMxTYKbSuWszmL5YJpGqgqTUyR7X6H1om2DNb1ZxzrWzLUbZLmFl+tygPqtmIuf3NsVbyG17+tgks/OxeW7WsvC8fa/adnFeWP808k5+O5EKGIJEnx7gk5kgiM455nLz7i8uoFzinme/F7PDk5papmVFWFiplxGhgOe5zrqNsFlXGE7MnjNVWcuLdomM8yShmqesaDs4brdzo2mwM53KDoaGdzlssTNpvF5562v6eetFLqfeCPAb8C3H8t8T5D2iEgCfyT1/7s0/LY5yZpgJw9KUecqnCNwdUGbRXoiHGO2aKlaizOiKX7THVkHRn8wHq3pR8SsMPoBqJm1nT0KaNzw3DQvLw4cH2957AfZbhjDcoobBZHjNnshLarWZ0uaNqGlGXr62PCh1RqVBFLkWv9yKQSVSylRcxFJCaFxMAkmrbWVqV3LPZVSovOsLIRYzLBl+2zEsEhV/Skjb3lHJOTUOBjjD9xARxB9EcKsbEVVfUKG+79EYT/WoVdtpRaiz5xJguDLsdbwsixBaOUDNoEuyraJJUVDV1tjGiaJA+I7klTVZydnRYn7Z9Mo7cXXH61RW5nM1xdi25IfH03AlabojkRuLm6YuhfJcx/mDgOZ4sWE0orTk6X3L1zwvXFc+J4oN+PhMGz7UeSP5BiYH66RBeqtZCHEqpM47UyGG1uhfmNkd1N17V0bYerxQTi8noDpoEk8gAZsYWadUvaSobXytX4KHyBEDzxcOD65sDFyzXTMDCNIkNwcrLCaof3EyElnr94zm524GR1UvSWJ3bbNdc3e1K05KQF/QS4qmLe1FRWc/nyBf1+T/ATkLDWEa1h3G7BB6q6Yawsd+6cce/eGcN0AA0xeUnmpRiQzzbf6lW8XkXH4lul0UK5f32mcNsYoTRGjsNYee44l6EIG3FsneTfTqNRSv3kXPL427kwbDm+9PG1imKHCigiWXlyCox+T2KgW2QwFZM/kLghqZqEIURwJlNVTkTRImQChB05OlqjeXg+Y1q21LXCT3tRQqSmnmmWsxX+nRV3zhsuLu4yjBMnJ2dY9/8HdIdSao74F/4bOefNT3L5c1bqpz+i3/X1/izwZwGB91gtVjg6o3VGGzAOJh+IybPbbxn7Ca00zimiGqk6K32/rPGTpx/2TOMOp1tatyI7uLn2vHh+w83VwDRFtDE0bU3X1cyalvPlmdBOk+h5ZJ2Zhh6hQxuatkXSWsYZRds0hBAIfioCRDJM1PpIFBBMtgwbKoy2mOIjqFTC2rL3UrFMo3PZRpUKutCznaux9qhFHV5VxSXZai0thqNprjFGLvRCBFBANgiiQanSDjk2EaVvKMPaLKiK0oM0VggTfhI0jKtqFosV7Wx2KxzV1hVtZahspNaJOG1JU2AMnt1uyzSOcjMy5rYnmdTxQsyvJvNI3zaBSHRy7GeWbXSSG1h/6Lm6vOT65Uu6eSdKd685qf/OJ9rxJJV/P+bjLkQSy2zW8rWvvcv2+gp/2JFGIQiN4wHiiFYZaw3jbkcoUqtHtUCU6AhbY6kqJ+JKRJTVdG1HXXdo1+Kj4up6w2A0U87SWkqKwSeU1zKwzcXyzFS4ytA0itnshP1ux2Z9Q87y+nXlqFxHiKJZoU2mjxNaWebdnBgTh8Mg/94YGMdEnBJt3fHy4jk5J965d44zhuQjfhyLnK4nkomjZnN1iTKWum7ZbTYMhwPvfu2r3Ll/h/lsJRK9WezHjFVFDre0PLIMiI+ZuOxbSgUsN0p1e5xVGVKDyJ+WAyWySLfNkZzTbSUtHYry+sdZYam+S619e8h1SfbH8ypTdpEqQg4Iy9kXwX2FNo7KtaiqxlU18/lSiFUq4mpL7VqgwRh3q4Pusui9S07wxJDR2VAbi4qBxhnJK0l08EMU38nz0wWnqxmojLO2fGafHT9TklZKOSRB/0c55/+0PPz82MZQSj0AXpTHHwNffe3P3y2P/UTknP8c8OcAlosuA0WvQyQ3Qwj048gURC9iHCPkCaO03PmYWJ0uOL93h2ZxAnEPaZKTJHSsN47nz66k7TEGnLPMuprZrGW57JjPxeGksy3TNLHZDELtjtDWjajdGYurGowRKFxWWZxQiryh9JortBJ1rpgiPoYCifLMuoq2non4kZfELtPmRPADPvRApqmrWzseo6XqPSZahdjOa5sLwkRkPbUSJIgMrQxKyw1L21Ir5ISxTlTUtEFbJ64yCFxPiDNI60Zl6UfOOrpZi9IwDD1+8jhd0bWduB+bCqUcTd3SVBZrJioz0u8TIe9JThNJDMOBTEChxaBWiYRoQuRMby/M0rKp6gZddgLHPrjOkJT09wM9ScHzJ0+4/5V3ZLCobJll6NtL/redY5/xwO3sv1znRhvu3b1D+PlvgQ88+uEP2ay3pDCS/EBlFT4m+uDFCV4pqfniKFotqsHm4maPIIG6usK5mrZZ4hbn7GLFmDR9HLGVpW0tMWb22wNjhOhqlHEkH8Anmqahmc1w1lLZphjFInT/WPzxphGTAyRoK0dlamEh7nfy33YvhC5lCF6QMqnoiT/59CmV1Ww3a5EJNqIdTvTEUJQnsyL5SfrVGLSqWCzuQG7JqsMTGJLGJFHu07e96WPlK3Rrnc2tQYBg7kvKVPrVUTsOzW/7xvkWespryfyo25I4Us1f/f9omnDLPlXymqlIE0Am5UApCUhpIoaRycsg2LiKtmmwri67rJqqXsouqRQFKhvy0buxoLUUCWuFUKN1ZkqBcYxMHsZpJGfZvQBMwQtkta5wlZXh9aLF2eMe4bPjZ0F3KOA/AL6Tc/53XnvqLwN/Bvi3y9f/7LXH/3Wl1F9EBobr36kfLf+G9Pas09SVVJ1+8vTTJDKiR7lKpTGFnkqGg/bUdqJqLU7NaWwUZ+5d5OWLG9Y3stU4WS6ZtQ1tbWVSX4tOrFEB8EDAWNkWaVsxny+oqpZhnCAmYgqkFFBG4/PEOAmKgUJqMda9VjsIZdYoTeU65osznK2IIbLdrhn6fTHTrAmhlnNaidFtLK9prLntKZMUyiSBBtYWayu0FpakXBNlGq9t8Q0UOj1JmFDWOknWtkKZGmWEAZBS4GiQ2gVPTGJHZKpWPgvb0GWFLYLnAU3yss1Tbo5rOpz1aLUjDluS6tGVw1aOaRqFtBM8unKvpvFytG8vLgDrKlYnZ8wWS4Z+JE5CdEk5lR6hoGH8NPH86VM26zWn9+6iSK+9ym3qvf3ps88z0RGRHCJiXX0/sLvZoIHlfI4C/DgSfWDoB3Jl2O979vuJEAWDLggu+apzIgVhkoWY0MqjVUPbdDTNjKpdcrNRmKpBe1jMa+7dOSfFzKOPDviYyAi7zx8tSXLEqIy3op5YNzXOiS6EnyYOfU/MCWvqW8zDNAzsd1u22w390HPYiyVcLsZ+IYTiag2Hw4br9Q05BtAaH7xQ9jPELDj5nDQhTBhTie1TOYeGMbHdT9gqo42lihmjxbAixYAp9lKlo1ZaDtJmS8c2HYIeSce2m1J4Hxn6AymK5KvsTsswspw/plwTqZgB2KMkqJKb0XEU+aoJfdTUFgu0lEZi9kIumw5MfV9uUobGmHKvkItCrpMyoH+tIMpZFdSXHDeZK8nu31UaZ1uaTuODYbPtubq6Yb3dE4KYj2x3O5aLBU1bcefOOU1T3ufvU/T/TwL/U+A3lVK/Xh77XyPJ+T9WSv3LwEfAP1+e+38i8LsfIBC8f+l3+weM1jRNh60UxipCGMlZo5UVtk6xxDFKoay4VKQ4MQ2KzdWAdpB1wxQ0u83EfnsgZ8+d8wXz+Uy86QopQytVmEAJZTRjCqQEzklfUBuLdTW2qugqcbbwQQwHRBYxid1SDCXRKcY00Q/SO41J7rhg8FozDQPVoqabzYVKmqVfbRTMWxkWhDBhK+lDhujlZESo5tpKFaOUwlV1ScbiqYjSWCsGtN6/ap+QItF7cvC4cnGhLClpbNUWnzzkbm403nuG4cA0jcSsxW/SivFnDKKlK1W6wzULqmaJrVusOeJHW1LeMo4BP0X2uwPT4KnmFUfon3ptUCQnubQzjDEsV0vm8wXrqxuSCaiUiyjcsfQVrenNZsOzJ09YnZ/J4JVji0mVbXSJz+yASBVvsuhaxBDYr7d88ugRzx8/ZXt9w8vnL7i6eMk0jgzDxDR6VEps1juGQ3Gnj5Gq6HJYpaldTc6ZcZowLlM5Uc6r6gbjKpLS7A578eSzFlcpZrOKxWKGDwcuLq8JCXzKTP0ovoOjJ/oe6yxN02CNZRxl5xa8GEPknEhZhsuHw4FMlHWPI8MoAy0fJoIXn86kRHdjGAbRrnYW5RQ5KvwUUUrITb6YGChEc9zkhKks9x7c48HDd2hmlfxegHEMVEZ2fGkSxFNT2zJUlR1HTJJkNeoWWaSVEuGxMvuQNkHg4uWa/W5PVTkWiwVH5EXTdlSVo20bQES4xnGgqWsqW8mOyIjZ6+1tuyjF5pxIjMR4YPRbYjxwOOwYpx6rLN1sTtPOqFyH0Y5j1Z6Lho0UNNzCsWOMVE6uvZxFae9VY0aBVoVrYTk7XVA5y+HQczj0jLVjs1nz5MmnwvD0gapxWNfdGjZ/Vvws6I6/+XmnPfBPf8bvZ+Bf+91e9yf+pvT5/JQYfSQmMWwFhVXVbaWdM5BkYCVwMkWYDNnDGCaGCSafaeuG+aylsk6QFYghUvSJEBIRoY0aYwozCGwl1akyhohimDzz5QpQ+N3+tjo7mtpSAPjGKKF0BxH8jj4jgv41pMA49sSkaLqMsRXz1TnDJNtIV9cFLD3hamkxOCV9ee89iemWfquUKKSFDJVraBdLUJq2m2Gto+9F0a8yIrIUx4H+sBe9AJ8YppGsDKt6QdMtqWoxFIgxQjSgE9oa8V0sbaeQDT5pRi/PdXWLaxfYZk7ShoCidgua7gw1HPBTZBwDm82eoZ/oVieCOCmmtp915JUS7RGlRUM7FqQMZHKhsd96MMbE86fPeO8bHzCvV4CwMwVd8dtfXf3U9yoL5Cx4z/rqmkc/+KG0N65v2G92rK+v6ff9re+cyuBzYhsORO8hRiFCZEPO4ovXtp2ci0YGSD4GtHPEBMo4fMrsenGMbpqacepJTJye3qGqHrJYVqJJ4xyX11tePLtkv9njo8wfxt6JLEERjj/KaapyDqcQ8EGGmt6Li0kK0mvN0ROnkXEc8MXAVRlhIyrvJCm5imzMrZ+f1qJtnEIma4epWs7u3ufh177G6uxUGKjOkXNknCLORmJI0pjNQYxZbxsZMj+JSQnlPkSGYSSECFlRN44QIoedwBynqEjKsh8ih/GathUvyaQ0thLIqiICEzHs8GYiJ5HvclTlWjccgX1SHEwoejJbYrqhHzfs+y3GVLTzObOZJGhFJUVhLhocMZdEnck5FPQUBB9lH2AoGjfhVl0ylTbNUX7BWs1y2TCf10yTuLQbo/jhD37IUTY1J9AY6XF/TrwRjMOUEv2wB5WwlZFtk5VqxaFlC5K1mK0m4cCbI0IiG4LPTKMn43DaYizUTelVRfEoM0pjKxFQIcmgSu7mhpCELKMUAncrd8zNdgtZiQBN8GiOFuwJo2XAcdSf9WESCmgETSQrLR5xVjwCx82WqplRdzOqtqHPPSEZrDE0lbiWo7fEOImIjZlI9LcSnRQpSxJ0yxNOz884DCNJaaKpiAZIZTChFLlA8g79QD+MpKyYL0/oZh1122GskUGGT8KUylYqZWdxVuQZvfckZdCVwTgDtiIZQ8iKHETG3RpN3SyhmaMZSBnGYRQSzXFIlF+5eRz7k0pJz5KYbtEyKQkyIU7iFXfUt9ZZxNFzShx2e/w4CSa7DP+OqA1F2R6/BuGSNmbZe8dIv95y8ewZTx4/5pOPP+bm8ooYIpW11FXFbr0uIjjFcDVGfA6oKPL8IgdgIWuMFVs1tCblwBQCbWNZLFcoW2Gbjs0h4BN08yV0DYrIycmcrrN03YLFomb0ohcym1XEsYcwMvQjm801wyCIDh+CwDDLttgW4XgyKE0xVh44mqIqrbAanFWEYHHzFfudIWeBODatBQSVVLdLMuAq8dQki26Knya6xSlndx4wW5yRsIxTwuSINcIvCAGUAaOtaEPHhE3l2GZFiJnD4Bn6kXH03NxsWa+3aKWpGxm4d13LqmmYL1d08wXX12tyirTdnMmPovhoFP20J8cDOe0Yw5ZQ3L3rqkaZVli0ynKUQdBK/EBTOgAHnBsR+dUa55Y09QJyB9lJeyYVOF5KBB+YpuJvqAymLiqS6ugJqogxFeNagcdSCo660mhTUF9knBXmLrXla199wKytScmIAXYl5DPzuXXwG5KkIVO3IkPadhXRQ11XpOKekLNkUOu0MPqQXmuKieBHJi8uFFVdCXgdfxTmFNHvLFRS5xpsI6Lc/WEgZY11NUqFsjWSa3kYR15p7ZrbwUPOCa0yypaR3q2BqCcl0U+oKofOprD2pL1irGMMiN6DFynMmC37MdC1FdpWJAzd/AwfPVpnbAhktRM9kMXqVpFMacNiuaKddajDQfQYQiQkXYRcRvw0MOy3TGMPOVM3laA0ThZ08wZttUALfWKa5GtGsNYixWSFWGQaEYxJE03jaNqGupLBivcTOo0EDc5mXOUwSQSgbif4GV7pkhwPdcF4HJNpfqVnEqJn8qOYdRYki+BwZag6DSPhdh4gw1Glj9WOqLjd4rOFyVTOLoUfR9YvX/Ls0cd88tFH7LZbdrsd/W5fFO4qmqahbhohi4RETgGtMjl6VArI9SSD28oZrBH2p7RNDdbUrM5OOD2/S910YCvWuwPoitlsgTea09M5d05PhAxCRrcW1MQ4ebpac7ZqqY145l28MFxcXDBNE10jZhLGWLquoz8c2G5kpzQcDhz6nuAD3k9UdY2rKpq6kfPeWqxtsLomRC8th2LFUtdOksWx5x0jXdNitGa72XKyOuHhww9QqmEYEjZn4qGn6yqMNgwpEgxUVgbSNklfW2dJdj4qhjFwdbPjsOt58eKSly+vmM/mZBKrkyVdNycjOjEqikiY1oZ9PzCOB1IayAzENBD8DSleE+MBZ7WoDeqOkCpMbshYclJYY8k5Mvkd47THh+LgrSucbXFmgVErrF4UE+URHwZyzgzDiJ8C1tQYZ4o7i7TW6vooX5FxzqKVou97dvsD1mpmM1sGpKIsKJ09cYMii+3W3btnpCifVyJhfheA0puRpFWmmSmsaVkuF+gMVVWx3ew5HAZSEvdkpRXZWLnj5Uj0kXES1+GULV4Bysj2JItgN0VmMAbQ2WKV2OsYJdApV9Xi0J2zCOpn8SALMeJShXNV6XcJzTunTFZHuU/prxmtiUqhjaWtO0gGH8TtJKRUtpiQkRuR4PEMprJ0i5U4mvvIfDFHBc8wDGhbszyZcefuXRYnpyRgHCepLI1lmiaqagZUeO1RyuILpjSliK2qAtmq0EYcYkxlmOJEmlQRPI+3aAFBqtiCey1a3M4BHj94UfGqZEtbmYqgE8kPTMOEbTxWFx+96IvrejyO2F+fwcvw6BZeAcIuFfW7EIL4AmpxKPExopK4WxzF1cdhYLvecHbvrtCnlTBABa+sbok6x68pJcZ+4PmTJ3z8gx9y+eQZ++22aINMJC/CTsEHnBN50ZRFUoAyO0gxonNAV+4WC6yUiGu1bUtdO4LKrA83zOZzrKvRrmKz3vLi5YZY30Ulg6tbZu1SdI4RfigpkMNA9pHaaO7fPcHcF5u1n/v6A9brNY8fP6FpWpQS1umdu3c47PZ89NFHpJjYbfe8fHnB/nBguw3EOLHf7Al1Q11XaNVATpysVlR1LZ91FunV1Wop5rZNW3TWPc5YZm0HOdM2LdZaDvsRH0GPoZgZK0Cs3DIRazJGR5q2EUeUFNlud0TcrdPRFDLr7YFnz14yWwzM5y0n52dEYJwCWYuMr1T0mquXL5jGLX7S7A4RpSZJ0ukS5wJ1bbBVR6IHVeGjJYZMTqIxnZPMWuSAWWKUXUJMFY1bULlTUnL0/ZbMjnE4EKMk6WkKzGdLrJM2XB9HYgpkEnUtXqeqsJVbJQYNWlOIZIIAUQVOIG2kV6xiKkWOms1mIKQJYxK5rj43Pb4RSdo5w8lZS9s0MtVFkug4KvpDQGfRIohFlS5HaW/4KRJiFkA1UT7knEXwSCuccVDYhKpAuqY8AVrwjDoC461BbT8O9EMvOF4SKUyEHFHWSgVdvOtE0kPdph+yxiiHsw5rK2JUEDMhZWzK1LXDVDUZi3ZygKfgscaxOFkxjhPDOIK1NHVHOz9BXFwa6qYm25pu1lH5UARxEiFuZLJsRQgk+YTHFajhnBxWxStS+s5iWw/D6LHh2C6S7bAuQkpCf64KsqTQXlPGolApQpwwqqKykdZoklH4scf3O7Tf4ZQgYSDfGjbcikgfrT6PPmPwqs0RA6GIUgmsTqq8KPYNRSdC1plC5MXTZ9z9yjvMTpbyOlnhXqMoa2RXMR4OXL284sXzZ1w8fc7NxUvGzQ4/edF18b70ykWmU3RjBK54O9wklZuqvLYgfUSTWFxDxBh2iIGX60vqugVtSEpzs9lyvd7CbIll5LQ5wY/Q9zIcNkoG2JW1GO3IWbOcz4Vt6j0517xz75T7985QSrE/7OkP4sBy93TBYlZRVzU+RC5evGCz2fL48ZPyXjSbzYbDfk/Tzei6Befnd1gsVqSU2A8DMSTaruPOvXsslytcU5GVeFkmHzDK0LUdMSY2my277ZaQE7P5nLFq8OEgOGmbZXaSPW3bMJ+Jia33os/dzle4yuFjQmmHcTX9MKGtEfndnFhv10xe0CgnqxWaxGG/5vrqGbs2kdIe7zeEuKGqBpbLiqpSoGZYt0TrVlo0PlFVDU5XYlYdoZ2d0DQrcqpJaUZKDXV7itaO/jDSD2vq+kBKIkMr/oOKnAdSFG2aFy9e4KOnnVecnp6xmJ1QVR1aubK7aW/18MWFhuJkEyBnxFwpASLclrVlPq8Zp8x6fUXTfI6EAm9Kkq4sp6ddcWARp5Nx6ElpRKlQpvuJafAMSfSVtTKQxa/N6Lokr1B80DJ+COg0ISL/Mnjsuhl11XLoJ1IU/HWKAWcbrNGolEjeo3KmMqoInFNIKCIBmfMrT8AYIaREyBqtK6ytBa9cbghh8mQ9YarIyXLB6vQOPmYmH3HREXNmSpO4XVQOpR0nZ3do247+MOGqCh+kp1lhcG1F7SqpLo1j7A9Mw0gfIarAvFtRVw6rMn4SidScI1oHYvHlExeRSGVfkSiODERyocoe2xUoSJnKGLkQVcAwoeIBUsAP1+w3TxmHa2yaOD89FfPgLMiX4wDw2I9WZRKeciygDenEWWdomoaqrojTRAqRkBK+CAhZa6XdpQUlcPnyJZfPX9Au5ihjbofDR3JLnCbWV9c8+fgTnnz6mM3NDX6ciKNn6id8kLZMCDJ81sahjMZVgsZo2hY/HYhT0QTW4pUp+OgMSnYp1hmauiJnGIsJwHJ1UmBcwjQdfSANnqaGcczc3PSQR5ZzmHUGpSNN3dBWTdlxicBUcEp0q2OgqQUG2TYrOFvdtnROT+Y4K7IC737lLn0/8oPTJScnp8xnc/7Bdz7k6uUV7zx4AEaYqe+884DVyZKbmx3rzR5jHXXT0rQty9MFxkkVPA0D42HCGUflalarlifPX3C9vmGaenZb6fuaSlE3hoynbYTgIdQQRdd1TBmc03Szjm424Ko17Wwu3paTZ73dcsefst1dE+KAs5arq4k7Z6dAYL+7ZhpHttvn7PYXGDOxWtVMk6NtFMZMVC6h8oj3AWdcUXR0NHaGocVVK8gtIVZovcC5Dmsq0W/XE11nSAR0CnSdZbc/4GyFdRmlPUp79odrEpHFySnaTOz7GzG/WJwxa5dwq7L32kikeFRk4q29njFV+b1A21oyhm5Wy67/c+KNSNKKTNvJVnscJnzfs9nsCAEhn0WBTE1jIEWxVM9lu+WcFWiTtViVCSlBAhUhBTA6i5iPdVjjZBKdpcFPEjLH2A/0hwP9MBxRNMXFu0gWZhFGilHgaMZI9Zqj0LXlGGSyUeIgomRbHxNMU2AcPVVhMG22e2KYUApxze46cZ/A4lyNqSpi1piqRtuKtmpJDtCiEZEL4KeuG3EhjkBN6f9KyyJMA5MfCEGSb4jiNhGmMmwrODmgY4gAACjASURBVM8weVIs/oLKEJXCFqEmsiQwo6UPipqY+g1bv2HUmux7hv0Vvr8ipz1Oa/x8Rs4R70f2u7XoaR96Xr58SYqyTcwq00+j4MuVhhjZr7e8ePaEixfPOWy35CjMwGwdlTtFKUQJz3u0s2zWay4uLnj49fegtK4oELwUEi+ePOWH3/s+L54+47DdMo0TIXgIEKZQ5gi5JGiDTpGYMmhDVbc0Xcs41ow5FKSRDOOMkZ1ACuJobZ3GWMPkJ4a+vz1/qyowW1qytqANaEXfDzIYnjm6puVy2LKrE2dnCyonbTNnTMH8Fg9LZZmmTIwCQew6GfhKv1VurkJNFkeWi/CS9772Lqcnp0w+8OCde7xz7x7f+Ln3SVl2UycnJwXaZ7h7d0U3EwYnSlG1ToyFsiNFR/RyLQmyoWG2MDx94djtJ2IysruNEaUrUgoY42ia+paZeXl1xfow4hpBT0zeE7MIW/UHxTQN7A97fIisViugQWvNYbdnGge6psI5zcuXz9lunxDTFvBYNyckg/cGV8Fq1RFCJT1+pCUWFSy7E6xeYNSclDu0alCqRWsn6BgdqBpQaGJ0GCVGyEeJhapqiwxxxXvvfY1h3DH4LZdXI94rDC111dDUDTFACKnspu3tgPe4U/NpwmhIxYMVBLHlnGHh5r9jfnwjkjRA5SxN3TAePId+ImaDUpYUZSJrnAYdsdoCmX2/B+QDNMlSaRFlbyqRuAxTgRHJWQ8otpstMWZcsXUXax7ox0E0LgoCRGBDgRwp0KeEMY6MOLREH6C4/wYfSKGwkbwiqIRPkRQy1tbUzYz5bEXTzJm89M+1a9AKutlMeoFZY10hqWhLPwWatqPp5pJks0hJxgBTnIpxqSIpDdZhG2isERRFcXEJGbLWAu3JEymNGBNlCIJQV7W2IsmaLcZUdLWIx4QkFSQ54iqDMYGcAznsGbZrksqoOIE/QNigGFGmIaaJqYjODPsDN88v+K3f+A0+/PC7UFh5MSUm/0p2dBxHxmFgs1kLvnqSwaHSmvn8BGZzvJYevI6GvNtTpcBuK76IRqheZKUJ3nPz4iU/+PBDHn/0McPhwDgMDMOAjwFrqtu6/pYFl7OQZ2IkTBNN2zCfL+iHHcPYFwd5i7ZZaN8qyn85YIuHXYwBq2HVzuk3PfP5Xar2lKdPnhIytJ2jnyaGYQNYFnOFQqRtrdFY46hsLfjaQgTR+pgwrCS+EAs00khVn0GlYoBagGkKzWw2E6u4FHjwlQc0bcNquRTkklXY4sZ+froAJYiOWzMGnRGl84Q2oCotTi7Fp9FWC+rO0Q8RnzQ3Nz2HfmCx6Oj7VGC0vgxcFWOEl9c79vsrclYc9gP7Xc9qecLZ6Sm77ZbZrCV5jaoMq9OOpnLE1Qk6KxqrePniU773/SvGsKfpYPIDF5s995sz2sVdTu/coetW7DZ7cogsZ+IbiLMo1aHMDGU7dG7RrkUMLkQi4ShzMPmRGFqckeHprHslnpVSoqrg/GxGP27Y7J6xP2yI00Td1mzWFzx7+pibmx1GO87OzqiqitXJCfP5qkBxMzpnTI4kJo6mvESFNRWR8NuMLF6PNyJJq9vpKbdWP/PFHGcblBEYnLMV7eyAHwKHw8Dos1hKjZ4KQSwYZUUzRR3Jn9IRTSEyTntiyIUEUuBBIWKtJcXM5INIa2aN0pbKWdAZn4/i6IrJexHyTwV2UyhVSlmssaC0eMOljDU13fyU5ck9Tk7fET3gCMbWOF2YV0njh1Ts5cXKytU1oz+A1lRtI4pwoxAwQoy3FytAygK105UqdHWL1Y66q6hnFdN4IIYePSSUCqQ0kaInjF60ArRoSLSzGXfuvsNqdSrQw82WcRwI0VO3hpQO9Pst03iNTgeMgTjt8eMeP+1BTaAykx/pDwfW19esX17x6Hs/4Nf+zt9hf9ihEeqsyJGqMgRLTH4SJTcfSCkVRppUkn48MA09XdvRdZ0w+qy4duy3e/wwYisHOXPY7/n00Ud89IMfcfn8GX4YhXySi1JiAn80NJATDY3CaYt2VgadSdA488WCKY4M44GJiHEKpxK2UjgUXeuYzxq6ukaZjLGaKlm0MtRVy3x2gnZz9r3YZE1hKltgQ4yBm5sr6jpz7+6Kk5MTmkbwwNFLe84UZ5WjBoZzFq1lF6eLE0zOUVp+SGvBWMvqdCXGFZWjblskERlUgYBZV0xhNbhKoTSCbDr23I9uLhmZwXD0lNTorHBW0zYVqEidNWPv2e0mLp9vWW9uUFrx4ukTMcIwUtDc3AzsdgMxRLwPTMOEHyMP3vkKRjka1xEnzXras95cEKaRylbU1tIfbjj0B2bzGXncEtjRLCrqOnHn/glf/+A97t+5i9OGyxfXpDFQqRk6B3Id6GtPbhLaZlQOKCtDPFXu1Ec39OgtKbZkU5OzVMFKy4zDCJER5RJKG5pGk9JdvI8EnznsB6wOOKNo6oraWTabG9aba+7d+wqL+TlN3QkGG49RCUWQtmLKRTVTECGfF29GklaKpm2YfEQ7RVKR/bBG5T0YjcZQtZrF4px+N/DyIjH6UU4h5cTp29UcnUSsrTHaEIzIegqKIRWhdhHkP+6Ps4B/qJxM6kNpZ5yfn6GN4urmkhQ9MUz0/VaEh47Vhjblw0+EnNA5krW59T6rqoamnWFcjQ+ZpIRWDOrW+BUtlO50xGjmMqAsvd2qblAFs3w0QYWMM1bw2sZQO7lJaONE81rPWCznTNOeod+w2xp6p5nGAyGM0t+fBKliTcVsvuD8/C7O1Xjvmc1FXW+Ydig9Ef2eYbghjFsaIx54+801YRpRymNswkShgacQMErzyaNH/NZv/ibXV1dYa8nRk1UqLaKj9KlUXzFLdX3rcVnE2kOK+ODR1tC0s5LIM8on1tdrrl9eoYxltz3w7MkzPnn0EevLK/r9jui9tLKmianIeU4+EL0MTWvrqKzgY1NKaGOEXFT6iicnp6TouX75jDgesCpROUPnFCeLGctFR1vVIjlh5G9G74Wpuliy2w8MU2SInkPaYyuhGk9TYpsOGNOwWM44u3OCs0c95YIvRs6TEERYy7mCKjFH9+2ifaGOmm6lXeIs2ghrVuQUTEGhiACSKkL7EAtjsTTP1JF8ItL7Sh3hi0cmnRwTPwVurtZcXG3o+8jk5bzcH/Y8f/oCpRTTOBaCkUajiVhiMiKmrxQhaq6uthh9xTRNHA5DEfoa2O6eMfQ72qpi1la0LYzjltnM0syX1G3H4sRxejrj3a884HR1AkkxDoEQxCh5sxtoqob9sOVq/WNOz0YevOOwlUEzCXmkaNiAJGHxgix6OSUnCDK02NtpJSQvHE7NUSqRaiG2dE3m/EwzvRNvi0ltHI8+esR+94gH73jOz0+ZzywoT8qjfMbZokx1i0L9HWDSb0iS1oqqtUUK0aPsJAnKNRz6kfl8yclpjcWynC+pKg0qs9t6tG5wrgNVJvTZQpI3L3fDiLEaaykynyK1qJXCVRW1a4gh45Ti3t1zrKu4ur4RUZUkfdsYJwHFF1hW5IhOkG1mjAlrMrV1oAthRhmUq9GulmHheEAZR123mKN5rBZJ0oQMnkLc4o5u4Mnj/cBs1lLPZ0wFonZUmfNKLLfaphEb+boWMaXSrzSVCJEvljPatuHiRWa/34nh6hSIPoqAT9ehrGXf94TNvii8JfZ9z35/g6t3jMMLpukG6On7Hn/YM/aCgjFWbnLeC3wux8BwOPD048e8ePqcFCPeKKyVPnjO0mONSWQsj6a+IcaC6hDavFKKkCODn7i4ukRxI/jXYrq73+34tV/9u5yenXJ1uWZbqv8cI0Pfl5aJaFYA5UaeiCFjtcEqSSIyAI4oa3B1gR1qqK0T66R+L+tPnlljWXY1i3krMgNKUbeNsAytZlzvCUDSlqubLdrWDAePrlohCMWR3W5N02jOzh9grZIesC4JupByXt/7vu54IvZqr9T/8rHJoUuxoUE7J4QqpXCVlXNeyZDG3ybd21cvfpgUrLAIEmklOOeCXeJ2SUUoLPrINHli0e3omo5ZO2e1PGG92fD82Qv6vpfrQ0ub0FlLXVcobYl5Yn/Yl4HgBmsNftrS9y/IaUIlT2Uj1g4oc6CZB+o28O6793n47l3mXQMJPv34MdubLaercxbLc2pb09ZyrTz+9AnPnnxC1z3hcDjw4Cvv03VnUtSZmTBCj0QVq0oLIpNTvr2h+aMxdHEMEE8QUZ/0IbJdiyZH8JH9oWc+X3J+p+Pe3fvUdcvTZ88Yxz05tay3u4JOGVjOz6hsoqotSktx+cZX0pAZw475qiYyEGlRWjMMI9VMID3aenQWzdvlSU1MZ1TViJ8sOTlCFOpKCIKvRZnSvzO3zt6m4DfRCbQuMx1N1VVMPtLULadnd7hZb3n69Jk0/Qp1OkwRrSzaOVQUgqrWjhCL04dpMfUcpR1RBepmRjdfYmzN5APDGDEV1E0nQk3ei0NmoaGqLAOpoME4J/RjkiAlslRQTdPQtq0kw2KLJRoiqeCnTbFOKkB6o3BOKuV+OGW33zGGgFKWaOUm2M5m2Koi5cwwTfT9npwz/dAzjDvG6SUhvCSHLdnvGPY3xGHCKkPdNGgjOFmjFLroYjz+5BOuL2/E6ioLuSUlwU6HlES/pJBRci77mkJeyWXtyhp8jDLkVFI5Vq6mPRoK5MTL5y/Zr7cc9gMpCj58mibRG0mhtNEsMU6E4raeciYqQ1RHb0rZiWFkYhyIqJRZdEtOTpZUWnH98jnaj8w7R1eL6UCYPLmLaJ1pq5rV2Rmu7XFdh+1m2N6gTE9VO5RraZqanCfq+oTVsuHr7z/k7HyJNUqm3IC0Fgo5Bv3bJ/75p38sSVdyCNoaYsqFqOQRfQmwOhOT7Ca1kgF9jGWekhLWGaxszIgpFxRNxigxwslQmLSGxWJR0Cs7+sIibKqGrz78KrNuQeM6Gtvy7OkLtvs9o48MU09VV6QsxVFVGdbba3IM7HdbUBmjPCHcoJUnhT27uKWuJ1YnGlcZ2s4wm2VWi4YcFI9+9BGPHz9lGgLTO3DvfoVbLtjuPZ9++oSPPvqIx598wmqxpKobfIzMZpc413J+fl8QXU6qXnJGqaPtXDknU2azvibEIN6OZQA8DAf6Qy8mHkWYLcbEkyefcH19zQcffIP79++jbcXZ6RLnFKiBR48+5OrqGeubl3zlna9y5/whDx9+QNUuibeONJ8db0SSzikyjDe8//WfZ3li2O1r2qbl+npN8JmuW1C7BhUVoU/sXSBnQ0oVm3ViHBRaWemV+gAcxYiM3KGi9JCFcXR0+TZYU0nyKEnk8ZPnbHY9fkrEJAiQZlYzDgMpKowp0J2CDOi6Bd1sSdPOqNuWbjZj9IEXLy8wpmJ1co51HWpMGCc95N1+Q9gEjLIsuiVN2xFDIKQoPedDxNU1Ic5QSkxmlXI4VxVkiehHh2kCxCTAe08MUapardC6IqrMNPXkqJi1Hffu3Sf6ibqqb91PZu2M5eIEoyvCFIh5zzQNQCKniZxGEnuS3zP01+SwI/gdZIWpHaY2ovttKmy24kSdFJuba3F/LxC+pBKhiLbHrAgce5+5dF1FIY0YKT0sdM4UbR6cczgrTDFQHPY9SkmSAej3PSqJjkdIov8RvCfrXHRVghgjVIJl104qw6xUcZd3sjvSim4+486dcz74xgfcvXvOpz/+Ib/+q3+L/fVLagPGZIbDjq4W+rH3HmekHXNvdkq1uoubL9k+3bLtB7rujMXpO8L0NJ7z8yV3zuesVnPq2grW/Zh8Vcm3+dVO7dVFckzK6rXrWVhwBdCEQt+KGHmfQEecdUw+ME4ClaorRQjSi50mS4yBySdS8mI0oSw+K1ROWA1d61BKdFOMgbaxBf5WCfyvTYXENaPvJ1ED9KkMQyumtCfnnv6wI3hLigFFZugPLOYdSgdS8uz7DVrtscYzTVfMukjTelYnHV9975T775yyXHWsb654/njN9z/8MZcvr2nbObv9p/zgR89Yzk85OTlns93zo0dP2W7WPHz3a0whsN3e0M469v0AVwGrK1arE4SPUPwjC6P3+uqKFy+e8/TpU9brDd/61je5f+8+PkSGfc9ut+fOnTviz2ktqdOcnFi++90f8aMf/Ua57mdsNxvm85p776x4+vQjjIHdZs3VxRV/6A95FouGmZm4uLzh/Pze5+bHNyJJN23FN3/uXboOmmbGYqlp246z845pjGhVEaZEGAJBC0RsGD0wCpzOOJSpi0uCF/hcdVTMCuQs21qlJBnnbMSFImnRep4SWlf4lLm4vKGqKharM8apZ7M9yPabFmdqoZIby/LkjNXqlLPzO5ycnqKtZRgHLm8u6bpFwVPLCVBVikM/MnlhMuboSSrR91ti9BhrBTM9TvicQCsqXzONHtDUjePW6dgU/8Gcb/XlQHC8deVK33Mik7DWMmtr7t1ZYs05y1nLzc01PnomH8kh0TYzoff2PcEPqFzjpwFyIDmp8Kd+JIUB0ijmCKaibhx1W5c9cUJFeb/9cOAwHvAhYpTBKEXKsTTeRNwqZW6rZ5BkeSvZfhzqxCTiQdOE9xNGSw/fh4n9fs/RTDZ4T5yCJF8jFHytHKYSOdrgBaPsXBkYk+naltrVGGOwlRXEh9YsT5d88+d/nve+/j4nZ2c4Z+i6hrHf8YNv/waMexwRE2uMk51ea2sqJWzCbnZCe+cdgrZc3KxR1tHO5qVAgHlXc7Kci7OKU696xLflcCmWX6uYj2L1t9thVY65yohcbb6tvIFyjihcpXDWCCszWerasN32wkEY4+2wcbef6PsdPowoMl3TMm9brFYkozBK9Gl8iEwxEBKsN3v6/Vj0bxChppzxU2S33XDYH9hub9hsNmynG6Y4ipypNxz6HQZo24aqSjgD2+2BcViT4hqjJ5p6pK4Vp2cVDx+esZhX+GngxYsDjz++4OLZgd16InjHIWUuXrxkGAMPHsCz51ueP3+JNZpvfPCHyRiu1xu++70POVmt+CN/5I9QOcjGoc2ssGQntJGd3Ha749vf+U3GYSTExNNnP+bHj77Dgwdf4asPv8rDBw+p64zSo4g76YrGWb72/h2ePj/n7//6Jzx+8pL5XIaLL682XK87YvDMuhkKy2a9ZRz3XF9/im01fb9hs33DK+mqsrz/3h0gEpMWDGZIzLsGPymcbZmGyH7bc3mxZb8/cNjLpF6wz8UINYPVllQq0JSzaEkgNvS5UL91UjjnGMdAN5txenLO5AULYoxj9BMhBXxSZFOjVMa6FmdajKk5PT3n5ORUsMXR8PJyTYiBceo5DHuxokqK9c0N4xhwrmGaoojZOC1dFA05TvSDF3y0FXeP2jnqpqNtZ6JHXNei06E0fd8XnYA9YZro2gbnpL8dQmC/F7ozObNczlgtVre6AG1T85V37rOYz1hvtvSDF62HcWK72zD1e8gjTQ05jlgzYhtF9Jp9EsW/kAQKOF90tF2LslosuqYBR01VtfTjwDhNr9TUXtPWEHGfY6vjp3bvZVh4TEK6kFcMmqaqWS2WWNuw3/W0M6hc6R9neb9HzfFEJuZUIJSRHEU8yVpBVvjomc1ntE0j21ytqNqWkzvnfPX993jvGx8wWy5L6yXQLhe8940P2F6/YPvyBS57bFez36xZb7doq6naTMqa1d17dHfu8t1HL8BV4AI+Bd45XfHOO+dYI5/j0StEMMbcIpsyqljY5NsB4RHt8hNVdUnqR5cZlAweU0Gu9H1kvdlhrWO26HAV9P3IetMXjLAl+EhVRw5DTz/0TP6AK0k5hwOzrkErx+XlDZvNmilE6m4OaHb7Pc7WtK7GOdFft7Zitxvw/j45wYcfeqZpy24YUHmkqzua2uFMw+ZmDdEw7vfEEDlst8RpROmIUoKUuHt+ynvvnWFN4upiQ920XF1v+MH3H7O+9gx94rAfyFlaOsY4/PgcV9XM5ktOVkuGITCbNXSzFdfr7zKbtTx79gnX18+pq5pZ55jP58BQ7Nsyz55/ypMnP+ThV97D+8zp6QkfPfqEcRgR2dSKqtas1y+5eDlSNxXGKKrK8XPffEhmx49+9BGLRcedO/dZr6+oXM03vv5Nbq73fO/DD1mdn/Duw3u4JtK1lvt375b889nxRiRpazVnpw3GQD8coIikpGTYrqdb1bOUPN737PYbdruE941sta1lGqW3aZwMA3xIYmkTIuLYbanrhvmswhQ8pFI9dTfHNTN241b0hutKqORZox20VlojKVpOFuc8ePCQpu5ECH63I+wnUprwYSQmzxQmRh/QSi4GP90QgmSkphXBlhB8wWFaqrohpZHkI6uTBXU3x7pGemRZkZNiHD1KcTsEq6oKp9WtZZb3kzhBZ9mSVs6x6CpIgWEa2G8m+l2NyolpGhj7kfXNnv3+ICSUcWB98xLyhNaBaVoTpwM594yHAzmIhoZWisVyyaybEVNiOOwZp4GUA42CWolUpjLyecdwtD0SvZOUZdQlw0I59hlut+/Hbb8uP5SRADkIciRnTd002KpGF70Vgc6JKI8gQmTwmVFoK1BKHRM5SOJr25amroWGmzPaGmbLBQ/ffcj73/iAdjEn5mIWXJiMq/Nz7j98l2G/xQRNGiPbw4E8TRwOE66LTD5SL0642fV8+7sfku2cdjbHWk3TOlmnLcPmKANXCn1Yld1FTIlpGIg+CAOzKuy0I/aiJOpbc9cSKUEIojjX9xP7/cgwBIbxwOXVhm5REZk4PT3n8eMXxVjZsusPuBrurBY8f7Gl73fsdxMqJk5PVtTWst8f2Kw3pKxYrM5QxtEfBuxC09QdlbNEPxD9xHDYcXrScnFxyfnZjP2hYYodkzcFdw+1qUSpMml21zvxyaTG1YrRexSRxaJjtTxjPCTqZYvB8tEPX/DjR0/YbD3TBNMYqeycpukYholhGEkx8N/++T/Kn/yT/33u3r3LD3/0Xf7m3/zrfOfDD9Fahu7juODsdM73vvcd7pwv+YVf+Ef49PHHOKdYLc7o2pp3Hz7k+uqa73//Ed/8xh/mn/mn/lkRZ7Oax598ynzRkVLk+dNn3Kwv6YcDi0XHz33zA1arOdZkHn30HT7+9PtoLLN2xde+8i1+7ht/lMsXe3a7p4IQSQcuLp6j7F2Wi/PPz4+//xT7+w+tFfPOMI49tZNq9+nTF9TVnKZasb/ZcrOWE24aVWHzJPpDTwwivuR9JsRchmeGwcei9mVo2xldu6CpW4GZhcQ4jDSNoZ2tyNpx/8G7zGcLST6T5+r6khAn2q5hGHoqVfHeB1/nzvldXrx4yWHYMYWBod8Rw4A2EW3Ajwf6g5c7++SxthIlOSCGkaZtqGonQzMVqSuNMjUxCQywdk6slEobJhNJ00RVW+q6FhbkYgFJXLQF9ykIhWncyyAqVVxfXtDvb2jrCk0iTj3Bj+KZt+059EI4SEYz9DvGfk8Me1Lcl77zyDjKoFCJAjezbs6iqwkxMU4F3hZHaa1oy2EcGIMna8RUVIuLhrhYcMtsOzaij6mmpHGA24QEJVmnyHA4yEVSaZTOKF2ViXgCo1G2IgYvLaMsuslaK5zWiHu6pTJGTA6ao8mv0MnbWcfJnXNOz86o20YMipXoH8dCeGkWC+4+eMD2+oJxfc36sCWmSNt1svMaJmLWpKT48aOPeXbxEl0PfP2DuwSfubq6YBoP3Lu7omtnxCDKcc4JLT4VudWhH9lud+icsdbinLtN0kfNdZCbmaCUhFcwhcjQB0Yf2G4O+CAkF6MrjLOkPKJdxtUKWyVsBbOu5jB4pmnH7nrNMF5zspqjoqXS0nPOIaJ1zWx2j262oK5nYBwh5kLygsW84+ZmwyefPMYay9nZOffurnjnnRXDuGG7ueLO2RnPn74g9KLLfDq/g7OOfvtCjtngydpj6hpSZLeeuLk8YM5amHVM+56Pf7Tm6iKRVUs/jGx2I3UF8+iYBo9SGrLh0Y8/5ee/dY3VNZ9+8oxnz6/Y769xLrJdX/DwK3d5+PABVQX9sObv/b2/xeXlFZeX19y//xXu3HmnQDpf0jVLPn70FKOWjONLbq4vefL0Rzinmc9nKJV58vQTfBh558EdTk9WbHcb7t67w8n5CdvtjsX8jKm3PHt6xWHj+N53H7FcyazE2sR3vvNdfvSjX+N09Yb3pHNMDDvZyt/cXPPixUuePr1gMT9lPj/nsA9oVRN6OOwju41sd3IqYkNBaKopa1KQQZU1Fc1sxurkhNXqjLqZkQr0y4fE6Z2Kuu3AyiDR2QaUYhwnTmcn1O2M7XZNTBNtazhZndF2LZdXL7m4eE5/ODANB4ZhhyZSV0KaSWHEarnwxnEixlpgd+boLl1kWOG22q9MRUqZ7XbNOAWMa0QHxDiyT1KFWtEoyUr0rUWyM1DXMlTzo2E4BJSxzDpRZtOquK8giTwnUyQ9I1YnQojsDgP9bsNw2BDjnjBtyXmPUiPRH9B6xBhFztIyGH0slSrynrwSSVmr8CkyBV8wuCW5ZOA4KCQJk0K98p17ZSUrW/cjZvcoZhSiGIUKYajBlxtxCAKRSsVnLkZfRNclwenynkM4+mI6EdtRFa5paJuGk9MT7ty7x53791ienogXnTquIaOzFANKVyzP79Etz9lerzkMEyiZjbi2YYyJ/dCz3WxYX6/ZbbfUybJaLFiv9/TDnkxAm8Aw9Tx89x6dqwu4R3YVIQSGaSLlTNuIJOwruyhJiDEdv8Khn6SXW3SPx9Ezetk11s2M+WKBNuKOMsZEyJ5PH39KDJEhBFLuCfHAYbiGfGB1Aos2ggeVJ9FLt4oYRNJgtWyYL5ZkTEnSx52PoqktX3v3ATEmlqsVCvj+93+I1XD3zjn37t3HKi1ojHFk1s2oCmzUmorJVYx+T8wTMWTGIfD0yRX7neXlxZoYFfutZxoyMQe8jxgc0xC4Hm4wWqGNZuh7pmHkv/wbf52cE0+ePWa/v2Gxajk/O+fQX/P84pK/+tf+Br/wj3wLRea73/42q+UJFy+v+M3f+pB79x8yn5/wyePneA/v3H+XkzvnbK63/I2/8dfp+zXb7TWZRNc1OCcoj6qybDd7ORbTRDVzfP3n3ufnv/nfQuUV477myUeXvPPgIReXH/LRx4/4Y3/ia5zfXfC3/+vv87d/9Vc+Nz++EUk6hsjVsw3DODKOik9+fMn6pufkg3dJk0UlsYfabyK7jeKwyYy94G2FVeUwthZwOJrZ7IR7975C3c7KhWfxkaJcp2nQzBdLfIjs+j0qa9EbSFAfqdExY3Qvw7/aMG/nvHj6nMvLS4ZhIPmJ4AdSHDEmE30kpQBJrIB8zBhbo3XBouoalGPX7/Fk5rMFzjpygsO+x6eMNp5hChjbs1idoHNkGHZknRlHizPiYJ689FqdEbU/o6GpDWNd0TQVdVVRVQ7vR25u1qicMFraSlVTo/sDMGIUbA5r1usrkh/QjGgC5MA07kEN1K04Qqdk8WMvSf44qMoKgqarZpgiti6EIiW6HKnga7MqA8OirqAEH3xbEiJQSP26z1sWIaaQY3H5tPTDhA/Q6ophHBCpfBFVt8YVKGJmNusI44BSokBotRA9qrrm/N49zs/PaWei/nZ65xxX13LT0KUpnjI25+KfJ9K4dXdGs7jDGH5MTGKxdjjsse3I6vyc7W7Ho0c/5vEnj7m5uGQ2KfrdTmBm+z39YMgq0c5E2VAhOPwklFViKu438xlNVUtFz7HXLPuM/jCS0fRT4Opmw+gTow+I2qwiK0fbzXB1RXaarOVmt9ns6fsdykemwx5IVB10K0NVTzx/+ojWJkZj2d0cOD055+6dezTNvFhdeRQjpIPoUhtDTAZnK6bJY1ZzzKllHEMhhije++rXBLs+jYQwsFiIbntVa5SK+Djg40TMgcVywVkzI+WWFy96UvaMY2CaLFUlLF5jDa7SEDI6yNA8pSgSA0dCjsqM48CLi6dUtcMYz927K77+wXt86+e/wfXNJY8f/xilDSEJNFNXHf0UWJ6c8eT5JU+eP6P/5FMxEa5aTu6echh3xOxxdcUUHKOX4iijuLnZiL7IxRXf/vZ3+OpX3yXmxMurS6YM5zc73n/366xOzvna+3+Y83dO+M//8j9gvb5kfTOn7mraxcTTi+99bn5UP93f+iJCKXUB7IGXX/Rafh9xhy/3+uHL/x6+7OuHL/97+LKvH7649/BezvnuTz/4RiRpAKXU38k5/4kveh3/sPFlXz98+d/Dl3398OV/D1/29cOb9x4+30f8bbyNt/E23sYXHm+T9Nt4G2/jbbzB8SYl6T/3RS/g9xlf9vXDl/89fNnXD1/+9/BlXz+8Ye/hjelJv4238Tbextv47fEmVdJv4228jbfxNn4qvvAkrZT6Z5VSHyqlfqCU+uUvej0/ayilHimlflMp9etKqb9THjtTSv0VpdT3y9fTL3qdr4dS6j9USr1QSv3Wa4995pqVxP+xHJffUEr98S9u5bdr/az1/1tKqcflOPy6UuoXX3vuf1XW/6FS6n/0xaz6VSilvqqU+mtKqX+glPq2Uup/Vh7/Mh2Dz3sPX4rjoJRqlFK/qpT6+2X9/9vy+NeVUr9S1vmXlFJVebwuP/+gPP/+H/iijyLiX8R/gAF+CHwAVMDfB37hi1zT72Htj4A7P/XY/x745fL9LwP/uy96nT+1vn8S+OPAb/1uawZ+Efh/Icoa/zjwK2/o+v8t4H/xGb/7C+V8qoGvl/PMfMHrfwD88fL9AvheWeeX6Rh83nv4UhyH8lnOy/cO+JXy2f7HwJ8uj//7wL9Svv9XgX+/fP+ngb/0B73mL7qS/u8CP8g5/yjnPAF/EfilL3hNv5/4JeDPl+//PPA//uKW8tsj5/xfAlc/9fDnrfmXgL+QJf42cKKUevAHstDPic9Z/+fFLwF/Mec85px/DPwAOd++sMg5P805/1r5fgt8B3jIl+sYfN57+Lx4o45D+Sx35UdX/svAPwX8J+Xxnz4Gx2PznwD/tPoJScL/5uOLTtIPgU9e+/lTfucD/iZFBv7fSqm/q5T6s+Wx+znnp+X7Z8D9L2Zpv6f4vDV/mY7Nv17aAf/hay2mN3r9Zdv8x5BK7kt5DH7qPcCX5DgopYxS6teBF8BfQar7m5xzKL/y+hpv11+eXwOfL1n330B80Un6yxz/RM75jwN/CvjXlFL/5OtPZtkffamgM1/GNQP/HvAN4B8FngL/hy90NT9DKKXmwP8d+DdyzpvXn/uyHIPPeA9fmuOQc445538UeBep6v/QF7ui3zm+6CT9GPjqaz+/Wx574yPn/Lh8fQH8P5CD/fy4HS1fX3xxK/yZ4/PW/KU4Njnn5+WiS8D/mVdb6Tdy/UophyS3/yjn/J+Wh79Ux+Cz3sOX7TgA5JxvgL8G/PeQVtJRcO71Nd6uvzy/Ai7/INf5RSfp/xr4ZpmsVkhj/i9/wWv6XUMpNVNKLY7fA/9D4LeQtf+Z8mt/BvjPvpgV/p7i89b8l4F/oSAM/nFg/dqW/I2Jn+rR/k+Q4wCy/j9dpvNfB74J/Oof9Ppej9LL/A+A7+Sc/53XnvrSHIPPew9fluOglLqrlDop37fAP4P01f8a8M+VX/vpY3A8Nv8c8F+U3c4fXHxRU9bXpq2/iEyIfwj8m1/0en7GNX+ATKz/PvDt47qRXtVfBb4P/H+Asy96rT+17v8rshX1SN/tX/68NSNT8P9TOS6/CfyJN3T9/5eyvt9ALqgHr/3+v1nW/yHwp96A9f8TSCvjN4BfL//94pfsGHzee/hSHAfgjwJ/r6zzt4D/TXn8A+Tm8QPg/wbU5fGm/PyD8vwHf9Brfss4fBtv4228jTc4vuh2x9t4G2/jbbyN3yHeJum38Tbextt4g+Ntkn4bb+NtvI03ON4m6bfxNt7G23iD422Sfhtv4228jTc43ibpt/E23sbbeIPjbZJ+G2/jbbyNNzjeJum38Tbextt4g+P/B2Gg/7fntW3fAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Test that the label matches up with the appropriate entry in the metadata.\n", + "for i in range(4000):\n", + " x, y, z = waterbirds_train[i]\n", + " plt.imshow(x)\n", + " print(y,z)\n", + " assert(y == z[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0cc60ca8", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index 32679b2..af27aad 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -10,8 +10,12 @@ class WILDS(Dataset): def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False): # Split can be train, id_val, id_test, val, test. super().__init__() - full_dataset = get_dataset(dataset=dataset_name, download=download, root_dir=root) + parent_dataset_name = dataset_name + if 'waterbirds' in dataset_name: + parent_dataset_name = 'waterbirds' + full_dataset = get_dataset(dataset=parent_dataset_name, download=download, root_dir=root) dataset = full_dataset.get_subset(split, transform=None) + self._dataset_name = dataset_name self._transform = transform self._dataset = dataset self._indices = None @@ -34,6 +38,8 @@ def __getitem__(self, i): assert(tuple(z) == self._meta_selector) x = x.convert('RGB') x = self._transform(x) + if 'waterbirds' in self._dataset_name and 'background' in self._dataset_name: + y = z[0] if self._return_meta: return x, y, z return x, y From 04b4c8d2cdda61c31883b1b6feb2a3e8646be5eb Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 10 Aug 2022 20:54:33 +0000 Subject: [PATCH 047/197] Add waterbirds background prediction task. --- scripts/waterbirds_examples.ipynb | 131 ++++++++++++++++++++++ unlabeled_extrapolation/datasets/wilds.py | 8 +- 2 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 scripts/waterbirds_examples.ipynb diff --git a/scripts/waterbirds_examples.ipynb b/scripts/waterbirds_examples.ipynb new file mode 100644 index 0000000..cb57b32 --- /dev/null +++ b/scripts/waterbirds_examples.ipynb @@ -0,0 +1,131 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "id": "0b8091ef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from unlabeled_extrapolation.datasets import wilds\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import importlib\n", + "importlib.reload(wilds)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c6e10576", + "metadata": {}, + "outputs": [], + "source": [ + "train_transform = transforms.Compose([\n", + " transforms.Resize(size=224)\n", + "])\n", + "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root='/home/t-anakumar/wilds/data/', transform=train_transform, return_meta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ae4fa7a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(1) tensor([1, 1, 1])\n", + "tensor(0) tensor([0, 1, 1])\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [15]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(x)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(y,z)\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m(y \u001b[38;5;241m==\u001b[39m z[\u001b[38;5;241m1\u001b[39m])\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Test that the label matches up with the appropriate entry in the metadata.\n", + "for i in range(4000):\n", + " x, y, z = waterbirds_train[i]\n", + " plt.imshow(x)\n", + " print(y,z)\n", + " assert(y == z[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0cc60ca8", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index 32679b2..af27aad 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -10,8 +10,12 @@ class WILDS(Dataset): def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False): # Split can be train, id_val, id_test, val, test. super().__init__() - full_dataset = get_dataset(dataset=dataset_name, download=download, root_dir=root) + parent_dataset_name = dataset_name + if 'waterbirds' in dataset_name: + parent_dataset_name = 'waterbirds' + full_dataset = get_dataset(dataset=parent_dataset_name, download=download, root_dir=root) dataset = full_dataset.get_subset(split, transform=None) + self._dataset_name = dataset_name self._transform = transform self._dataset = dataset self._indices = None @@ -34,6 +38,8 @@ def __getitem__(self, i): assert(tuple(z) == self._meta_selector) x = x.convert('RGB') x = self._transform(x) + if 'waterbirds' in self._dataset_name and 'background' in self._dataset_name: + y = z[0] if self._return_meta: return x, y, z return x, y From 549b532905f931a641b193f7fba9b0b7b5f7e7f6 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 10 Aug 2022 15:25:37 -0700 Subject: [PATCH 048/197] Support waterbirds background sweeps. --- scripts/run_adaptation_experiments.py | 83 ++++++++++++++++------- unlabeled_extrapolation/baseline_train.py | 12 ++++ 2 files changed, 71 insertions(+), 24 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 4c2db27..a3ae85b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -67,7 +67,7 @@ def format_key_value(k, v): return f'--{k}=' + str(v) -def get_python_cmd(code_path, python_path='python', kwargs=None, args=None): +def get_python_cmd(code_path, python_path='python', kwargs=None, args=None, overwrite_options=None): if kwargs is not None: # Make sure to keep the space at the end. opts = ''.join([f"{format_key_value(k, v)} " for k, v in kwargs.items()]) @@ -78,6 +78,8 @@ def get_python_cmd(code_path, python_path='python', kwargs=None, args=None): python_cmd += opts if args.codalab: python_cmd += ' --nowandb ' + if overwrite_options is not None: + python_cmd += ' ' + overwrite_options + ' ' return python_cmd @@ -86,7 +88,7 @@ def group_run_to_log_path(group_name, run_name, args): def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, root_prefix, - kwargs, args, run_saved=False): + kwargs, args, run_saved=False, overwrite_options=None): # If run_saved, then we ignore root_prefix since we get this from the config. kwargs = deepcopy(kwargs) # Sometimes we might want to run from a saved json config file, in a custom location. @@ -108,16 +110,18 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, kwargs['run_name'] = run_name code_path = args.code_dir + '/' + 'baseline_train.py' return (get_python_cmd(code_path=code_path, python_path=args.python_path, kwargs=kwargs, - args=args), + args=args, overwrite_options=overwrite_options), kwargs['log_dir']) def config_run(args, kwargs, config_path, run_name, group_name, project_name, - dataset_copy_cmd=None, root_prefix=None, run_saved=False, deps=[], rerun=False): + dataset_copy_cmd=None, root_prefix=None, run_saved=False, deps=[], rerun=False, + overwrite_options=None): # If rerun is False, don't rerun if the log firectory exists and contains stats.tsv. cmd, log_dir = get_baseline_experiment_cmd( config_path=config_path, run_name=run_name, group_name=group_name, - project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved) + project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, + run_saved=run_saved, overwrite_options=overwrite_options) if dataset_copy_cmd is not None and not args.codalab: cmd = dataset_copy_cmd + ' && ' + cmd job_name = group_name + '_' + run_name @@ -212,10 +216,11 @@ def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], reru if dataset.slurm_data_cmd is not None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) + overwrite_options = dataset.overwrite_options return config_run(args, kwargs=kwargs, config_path=config_path, run_name=run_name, group_name=group_name, project_name=project_name, dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, - deps=deps, rerun=rerun) + deps=deps, rerun=rerun, overwrite_options=overwrite_options) def run_adapt_replication(adapt_name, dataset, model, seed, args, deps=[], @@ -233,10 +238,11 @@ def run_adapt_replication(adapt_name, dataset, model, seed, args, deps=[], if dataset.slurm_data_cmd is not None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) + overwrite_options = dataset.overwrite_options return config_run(args, kwargs=kwargs, config_path=best_config_path , run_name=run_name, group_name=group_name, project_name=project_name, dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, - deps=deps, run_saved=True, rerun=rerun) + deps=deps, run_saved=True, rerun=rerun, overwrite_options=overwrite_options) def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[], rerun=False, @@ -311,7 +317,8 @@ def adaptation_experiment(adapt_name, dataset, model, hyperparams_list, num_repl def linprobe_run(args, job_name, model, seed, config_path, features_save_path, results_save_path, weights_save_path, val_metric, num_reg_values=50, deps=[], rerun=False, aug=True, - root_prefix='', train_mode=False, use_new_bn_stats=False): + root_prefix='', train_mode=False, use_new_bn_stats=False, + overwrite_options=None): extract_code_path = args.code_dir + '/extract_features.py' kwargs = {} add_model_to_kwargs(kwargs, args, model) @@ -325,7 +332,7 @@ def linprobe_run(args, job_name, model, seed, config_path, features_save_path, r # If no augmentation, then use test transform for train. kwargs['use_test_transforms_for_train'] = not(aug) extract_cmd = get_python_cmd(code_path=extract_code_path, python_path=args.python_path, - kwargs=kwargs, args=args) + kwargs=kwargs, args=args, overwrite_options=overwrite_options) log_reg_code_path = args.code_dir + '/log_reg_sk.py' kwargs = { 'load_path': features_save_path, 'results_save_path': results_save_path, @@ -353,6 +360,7 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re weights_save_path = group_dir_path + '/weights_' + str(seed) + '.pkl' val_metric = dataset.val_metric job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_' + str(seed) + overwrite_options = dataset.overwrite_options deps = add_dataset_model_deps(deps, args, dataset, model) if not(args.codalab): root_prefix = dataset.slurm_data_dir @@ -361,7 +369,8 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re return linprobe_run( args, job_name, model, seed, config_path, features_save_path, results_save_path, weights_save_path, val_metric, deps=deps, rerun=rerun, aug=aug, root_prefix=root_prefix, - train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + train_mode=train_mode, use_new_bn_stats=use_new_bn_stats, + overwrite_options=overwrite_options) def linprobe_experiment(adapt_name, dataset, model, num_replications, args, deps=[], rerun=False, @@ -443,12 +452,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): # If linprobe_secondary_val_metrics is None, use secondary_val_metrics. # TODO: slurm_data_dir should populate root_prefix in configs, which it # does not do at the moment. +fields = ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', + 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', + 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', + 'eval_config_rel_path', 'overwrite_options'] + Dataset = namedtuple( - 'Dataset', - ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', - 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', - 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', - 'eval_config_rel_path']) + 'Dataset', fields, defaults=[None] * len(fields) +) living17 = Dataset( name='living17', @@ -512,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_background = Dataset( + name='waterbirds_background', + overwrite_options=' --overwrite_dataset_name=waterbirds-background ', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_eval.yaml') + waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', @@ -745,6 +774,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_background': waterbirds_background, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } @@ -1034,16 +1064,17 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn datasets = get_datasets(args) model = names_to_model[args.model_name] sweep_lrs = SWEEP_LRS - if 'imagenet' in args.datasets or 'imagenet_augs' in args.datasets: + if len(args.datasets) > 1: + print('WARNING: learning rates sweeps will not be done properly with > 1 dataset.\n\n') + if 'imagenet' in args.datasets[0]: if len(args.datasets) > 1: raise ValueError('ImageNet uses custom learning rates, so launch it separately.') if imagenet_lp_ft_phase2: sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if ('waterbirds' in args.datasets or 'waterbirds_augs' in args.datasets or - 'waterbirds_norm' in args.datasets): - sweep_lrs += [1e-5] + if 'waterbirds' in args.datasets[0]: + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1052,9 +1083,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] elif val_mode: adapt_name += '_valmode' - if ('waterbirds' not in args.datasets and 'waterbirds_augs' not in args.datasets and - 'waterbirds_norm' not in args.datasets and - 'imagenet' not in args.datasets and 'imagenet_augs' not in args.datasets): + if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] if no_augmentation: adapt_name += '_no_augmentation' @@ -1077,8 +1106,14 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name += '_epochs' + str(args.epochs) # Set hyperparameters if args.only_one_run: - # TODO: how to choose which one to run? 1e-3 does well in practice. - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or + args.freeze_bottom_k == 0): + hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + elif 1e-3 in sweep_lrs: + # 1e-3 is a good default value for fine-tuning (with SGD). + hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + else: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) # TODO: remove this? num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 19e63e0..85db755 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -595,6 +595,14 @@ def update_net_eval_mode(config): logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') +def update_dataset_names(config): + if 'overwrite_dataset_name' in config and config['overwrite_dataset_name'] is not None: + new_dataset_name = config['overwrite_dataset_name'] + for test_dataset_config in config['test_datasets']: + test_dataset_config['args']['dataset_name'] = new_dataset_name + config['train_dataset']['args']['dataset_name'] = new_dataset_name + + def set_random_seed(seed): if seed is not None: torch.manual_seed(seed) @@ -620,6 +628,10 @@ def preprocess_config(config, config_path): # shutil.copy(args.config, log_dir+'/original_config.yaml') # If no_augmentation option in config, then use test_transforms for training. update_train_transform(config) + # Update dataset names, if overwrite_dataset_name is specified. This is useful + # if we want to run the same experiments on variants of a dataset (e.g., + # waterbirds-background (vs. original waterbirds experiment which uses foreground). + update_dataset_names(config) def setup(): From 88574856b892ea3f722263efea8cefd78bec8d29 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 10 Aug 2022 15:25:37 -0700 Subject: [PATCH 049/197] Support waterbirds background sweeps. --- scripts/run_adaptation_experiments.py | 83 ++++++++++++++++------- unlabeled_extrapolation/baseline_train.py | 12 ++++ 2 files changed, 71 insertions(+), 24 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 4c2db27..a3ae85b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -67,7 +67,7 @@ def format_key_value(k, v): return f'--{k}=' + str(v) -def get_python_cmd(code_path, python_path='python', kwargs=None, args=None): +def get_python_cmd(code_path, python_path='python', kwargs=None, args=None, overwrite_options=None): if kwargs is not None: # Make sure to keep the space at the end. opts = ''.join([f"{format_key_value(k, v)} " for k, v in kwargs.items()]) @@ -78,6 +78,8 @@ def get_python_cmd(code_path, python_path='python', kwargs=None, args=None): python_cmd += opts if args.codalab: python_cmd += ' --nowandb ' + if overwrite_options is not None: + python_cmd += ' ' + overwrite_options + ' ' return python_cmd @@ -86,7 +88,7 @@ def group_run_to_log_path(group_name, run_name, args): def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, root_prefix, - kwargs, args, run_saved=False): + kwargs, args, run_saved=False, overwrite_options=None): # If run_saved, then we ignore root_prefix since we get this from the config. kwargs = deepcopy(kwargs) # Sometimes we might want to run from a saved json config file, in a custom location. @@ -108,16 +110,18 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, kwargs['run_name'] = run_name code_path = args.code_dir + '/' + 'baseline_train.py' return (get_python_cmd(code_path=code_path, python_path=args.python_path, kwargs=kwargs, - args=args), + args=args, overwrite_options=overwrite_options), kwargs['log_dir']) def config_run(args, kwargs, config_path, run_name, group_name, project_name, - dataset_copy_cmd=None, root_prefix=None, run_saved=False, deps=[], rerun=False): + dataset_copy_cmd=None, root_prefix=None, run_saved=False, deps=[], rerun=False, + overwrite_options=None): # If rerun is False, don't rerun if the log firectory exists and contains stats.tsv. cmd, log_dir = get_baseline_experiment_cmd( config_path=config_path, run_name=run_name, group_name=group_name, - project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved) + project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, + run_saved=run_saved, overwrite_options=overwrite_options) if dataset_copy_cmd is not None and not args.codalab: cmd = dataset_copy_cmd + ' && ' + cmd job_name = group_name + '_' + run_name @@ -212,10 +216,11 @@ def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], reru if dataset.slurm_data_cmd is not None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) + overwrite_options = dataset.overwrite_options return config_run(args, kwargs=kwargs, config_path=config_path, run_name=run_name, group_name=group_name, project_name=project_name, dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, - deps=deps, rerun=rerun) + deps=deps, rerun=rerun, overwrite_options=overwrite_options) def run_adapt_replication(adapt_name, dataset, model, seed, args, deps=[], @@ -233,10 +238,11 @@ def run_adapt_replication(adapt_name, dataset, model, seed, args, deps=[], if dataset.slurm_data_cmd is not None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) + overwrite_options = dataset.overwrite_options return config_run(args, kwargs=kwargs, config_path=best_config_path , run_name=run_name, group_name=group_name, project_name=project_name, dataset_copy_cmd=dataset_copy_cmd, root_prefix=dataset.slurm_data_dir, - deps=deps, run_saved=True, rerun=rerun) + deps=deps, run_saved=True, rerun=rerun, overwrite_options=overwrite_options) def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[], rerun=False, @@ -311,7 +317,8 @@ def adaptation_experiment(adapt_name, dataset, model, hyperparams_list, num_repl def linprobe_run(args, job_name, model, seed, config_path, features_save_path, results_save_path, weights_save_path, val_metric, num_reg_values=50, deps=[], rerun=False, aug=True, - root_prefix='', train_mode=False, use_new_bn_stats=False): + root_prefix='', train_mode=False, use_new_bn_stats=False, + overwrite_options=None): extract_code_path = args.code_dir + '/extract_features.py' kwargs = {} add_model_to_kwargs(kwargs, args, model) @@ -325,7 +332,7 @@ def linprobe_run(args, job_name, model, seed, config_path, features_save_path, r # If no augmentation, then use test transform for train. kwargs['use_test_transforms_for_train'] = not(aug) extract_cmd = get_python_cmd(code_path=extract_code_path, python_path=args.python_path, - kwargs=kwargs, args=args) + kwargs=kwargs, args=args, overwrite_options=overwrite_options) log_reg_code_path = args.code_dir + '/log_reg_sk.py' kwargs = { 'load_path': features_save_path, 'results_save_path': results_save_path, @@ -353,6 +360,7 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re weights_save_path = group_dir_path + '/weights_' + str(seed) + '.pkl' val_metric = dataset.val_metric job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_' + str(seed) + overwrite_options = dataset.overwrite_options deps = add_dataset_model_deps(deps, args, dataset, model) if not(args.codalab): root_prefix = dataset.slurm_data_dir @@ -361,7 +369,8 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re return linprobe_run( args, job_name, model, seed, config_path, features_save_path, results_save_path, weights_save_path, val_metric, deps=deps, rerun=rerun, aug=aug, root_prefix=root_prefix, - train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + train_mode=train_mode, use_new_bn_stats=use_new_bn_stats, + overwrite_options=overwrite_options) def linprobe_experiment(adapt_name, dataset, model, num_replications, args, deps=[], rerun=False, @@ -443,12 +452,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): # If linprobe_secondary_val_metrics is None, use secondary_val_metrics. # TODO: slurm_data_dir should populate root_prefix in configs, which it # does not do at the moment. +fields = ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', + 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', + 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', + 'eval_config_rel_path', 'overwrite_options'] + Dataset = namedtuple( - 'Dataset', - ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', - 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', - 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', - 'eval_config_rel_path']) + 'Dataset', fields, defaults=[None] * len(fields) +) living17 = Dataset( name='living17', @@ -512,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_background = Dataset( + name='waterbirds_background', + overwrite_options=' --overwrite_dataset_name=waterbirds-background ', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_eval.yaml') + waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', @@ -745,6 +774,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_background': waterbirds_background, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } @@ -1034,16 +1064,17 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn datasets = get_datasets(args) model = names_to_model[args.model_name] sweep_lrs = SWEEP_LRS - if 'imagenet' in args.datasets or 'imagenet_augs' in args.datasets: + if len(args.datasets) > 1: + print('WARNING: learning rates sweeps will not be done properly with > 1 dataset.\n\n') + if 'imagenet' in args.datasets[0]: if len(args.datasets) > 1: raise ValueError('ImageNet uses custom learning rates, so launch it separately.') if imagenet_lp_ft_phase2: sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if ('waterbirds' in args.datasets or 'waterbirds_augs' in args.datasets or - 'waterbirds_norm' in args.datasets): - sweep_lrs += [1e-5] + if 'waterbirds' in args.datasets[0]: + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1052,9 +1083,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] elif val_mode: adapt_name += '_valmode' - if ('waterbirds' not in args.datasets and 'waterbirds_augs' not in args.datasets and - 'waterbirds_norm' not in args.datasets and - 'imagenet' not in args.datasets and 'imagenet_augs' not in args.datasets): + if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] if no_augmentation: adapt_name += '_no_augmentation' @@ -1077,8 +1106,14 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name += '_epochs' + str(args.epochs) # Set hyperparameters if args.only_one_run: - # TODO: how to choose which one to run? 1e-3 does well in practice. - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or + args.freeze_bottom_k == 0): + hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + elif 1e-3 in sweep_lrs: + # 1e-3 is a good default value for fine-tuning (with SGD). + hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + else: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) # TODO: remove this? num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 19e63e0..85db755 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -595,6 +595,14 @@ def update_net_eval_mode(config): logging.warning('Linear probing, so setting unspecified use_net_val_mode to True') +def update_dataset_names(config): + if 'overwrite_dataset_name' in config and config['overwrite_dataset_name'] is not None: + new_dataset_name = config['overwrite_dataset_name'] + for test_dataset_config in config['test_datasets']: + test_dataset_config['args']['dataset_name'] = new_dataset_name + config['train_dataset']['args']['dataset_name'] = new_dataset_name + + def set_random_seed(seed): if seed is not None: torch.manual_seed(seed) @@ -620,6 +628,10 @@ def preprocess_config(config, config_path): # shutil.copy(args.config, log_dir+'/original_config.yaml') # If no_augmentation option in config, then use test_transforms for training. update_train_transform(config) + # Update dataset names, if overwrite_dataset_name is specified. This is useful + # if we want to run the same experiments on variants of a dataset (e.g., + # waterbirds-background (vs. original waterbirds experiment which uses foreground). + update_dataset_names(config) def setup(): From 44c16858cc017806036b452b98a151c7571b09d5 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 10 Aug 2022 16:06:50 -0700 Subject: [PATCH 050/197] Add get_layers to clip model. --- unlabeled_extrapolation/models/clip_model.py | 39 +++++++------------- 1 file changed, 13 insertions(+), 26 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 1fd8ad6..daee451 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -99,38 +99,25 @@ def set_requires_grad(self, val): for param in self._classifier.parameters(): param.requires_grad = val - def freeze_bottom_k(self, k): + def get_layers(self, k): + visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - if k > 0: - set_requires_grad(self._model.visual.conv1, False) - if k > 1: - set_requires_grad(self._model.visual.ln_pre, False) - if k > 2: - resblocks = self._model.visual.transformer.resblocks - n_freeze_transformers = min(k-2, len(resblocks)) - for i in range(n_freeze_transformers): - set_requires_grad(resblocks[i], False) - if k-2 > len(resblocks): - set_requires_grad(self._model.visual.ln_post, False) + return ([visual.conv1, visual.ln_pre] + + list(visual.transformer.resblocks) + + [visual.ln_post, self._classifier]) elif self._model_name in {'RN50'}: - visual = self._model.visual - if k > 0: - set_requires_grad(visual.conv1, False) - set_requires_grad(visual.conv2, False) - set_requires_grad(visual.conv3, False) - set_requires_grad(visual.bn1, False) - set_requires_grad(visual.bn2, False) - set_requires_grad(visual.bn3, False) - layers = [visual.layer1, visual.layer2, visual.layer3, visual.layer3, - visual.attnpool] - if k > 1: - n_freeze_upper = min(k-1, len(layers)) - for i in range(n_freeze_upper): - set_requires_grad(layers[i], False) + return [visual.conv1, visual.bn1, visual.conv2, visual.bn2, + visual.conv3, visual.bn3, visual.layer1, visual.layer2, + visual.layer3, visual.layer3, visual.attnpool, self._classifier] else: raise NotImplementedError + def freeze_bottom_k(self, k): + layers = self.get_layers(k) + for i in range(k): + set_requires_grad(layers[i], False) + def new_last_layer(self, num_classes): num_in_features = self._model.visual.output_dim self._classifier = nn.Linear(num_in_features, num_classes) From 64f71b62fecee4e69373b8e937ce1878c3f9e6bb Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 10 Aug 2022 16:06:50 -0700 Subject: [PATCH 051/197] Add get_layers to clip model. --- unlabeled_extrapolation/models/clip_model.py | 39 +++++++------------- 1 file changed, 13 insertions(+), 26 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 1fd8ad6..daee451 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -99,38 +99,25 @@ def set_requires_grad(self, val): for param in self._classifier.parameters(): param.requires_grad = val - def freeze_bottom_k(self, k): + def get_layers(self, k): + visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - if k > 0: - set_requires_grad(self._model.visual.conv1, False) - if k > 1: - set_requires_grad(self._model.visual.ln_pre, False) - if k > 2: - resblocks = self._model.visual.transformer.resblocks - n_freeze_transformers = min(k-2, len(resblocks)) - for i in range(n_freeze_transformers): - set_requires_grad(resblocks[i], False) - if k-2 > len(resblocks): - set_requires_grad(self._model.visual.ln_post, False) + return ([visual.conv1, visual.ln_pre] + + list(visual.transformer.resblocks) + + [visual.ln_post, self._classifier]) elif self._model_name in {'RN50'}: - visual = self._model.visual - if k > 0: - set_requires_grad(visual.conv1, False) - set_requires_grad(visual.conv2, False) - set_requires_grad(visual.conv3, False) - set_requires_grad(visual.bn1, False) - set_requires_grad(visual.bn2, False) - set_requires_grad(visual.bn3, False) - layers = [visual.layer1, visual.layer2, visual.layer3, visual.layer3, - visual.attnpool] - if k > 1: - n_freeze_upper = min(k-1, len(layers)) - for i in range(n_freeze_upper): - set_requires_grad(layers[i], False) + return [visual.conv1, visual.bn1, visual.conv2, visual.bn2, + visual.conv3, visual.bn3, visual.layer1, visual.layer2, + visual.layer3, visual.layer3, visual.attnpool, self._classifier] else: raise NotImplementedError + def freeze_bottom_k(self, k): + layers = self.get_layers(k) + for i in range(k): + set_requires_grad(layers[i], False) + def new_last_layer(self, num_classes): num_in_features = self._model.visual.output_dim self._classifier = nn.Linear(num_in_features, num_classes) From d6988327aa9fcee0cfff0b49f1629fa1a95529a6 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 10 Aug 2022 23:47:32 +0000 Subject: [PATCH 052/197] Fix typo with get layer, only include classifier layer if it exists. --- unlabeled_extrapolation/models/clip_model.py | 23 ++++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index daee451..5761b1f 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -99,22 +99,27 @@ def set_requires_grad(self, val): for param in self._classifier.parameters(): param.requires_grad = val - def get_layers(self, k): + def get_layers(self): visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - return ([visual.conv1, visual.ln_pre] + - list(visual.transformer.resblocks) + - [visual.ln_post, self._classifier]) + layers = ([visual.conv1, visual.ln_pre] + + list(visual.transformer.resblocks) + + [visual.ln_post]) elif self._model_name in {'RN50'}: - return [visual.conv1, visual.bn1, visual.conv2, visual.bn2, - visual.conv3, visual.bn3, visual.layer1, visual.layer2, - visual.layer3, visual.layer3, visual.attnpool, self._classifier] + layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, + visual.conv3, visual.bn3, visual.layer1, visual.layer2, + visual.layer3, visual.layer3, visual.attnpool] else: raise NotImplementedError + if self._classifier is not None: + layers = layers + [self._classifier] + return layers def freeze_bottom_k(self, k): - layers = self.get_layers(k) + layers = self.get_layers() + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): set_requires_grad(layers[i], False) @@ -134,6 +139,6 @@ def set_last_layer(self, coef, intercept): def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') - + def get_features(self, x): return self._model.encode_image(normalize_transform(x)) From d8ab1d719f3730e56c354ad01f942d818ed19ae5 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 10 Aug 2022 23:47:32 +0000 Subject: [PATCH 053/197] Fix typo with get layer, only include classifier layer if it exists. --- unlabeled_extrapolation/models/clip_model.py | 23 ++++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index daee451..5761b1f 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -99,22 +99,27 @@ def set_requires_grad(self, val): for param in self._classifier.parameters(): param.requires_grad = val - def get_layers(self, k): + def get_layers(self): visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - return ([visual.conv1, visual.ln_pre] + - list(visual.transformer.resblocks) + - [visual.ln_post, self._classifier]) + layers = ([visual.conv1, visual.ln_pre] + + list(visual.transformer.resblocks) + + [visual.ln_post]) elif self._model_name in {'RN50'}: - return [visual.conv1, visual.bn1, visual.conv2, visual.bn2, - visual.conv3, visual.bn3, visual.layer1, visual.layer2, - visual.layer3, visual.layer3, visual.attnpool, self._classifier] + layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, + visual.conv3, visual.bn3, visual.layer1, visual.layer2, + visual.layer3, visual.layer3, visual.attnpool] else: raise NotImplementedError + if self._classifier is not None: + layers = layers + [self._classifier] + return layers def freeze_bottom_k(self, k): - layers = self.get_layers(k) + layers = self.get_layers() + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): set_requires_grad(layers[i], False) @@ -134,6 +139,6 @@ def set_last_layer(self, coef, intercept): def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') - + def get_features(self, x): return self._model.encode_image(normalize_transform(x)) From 95dc7907e4e8a5932543540e30f0b308374b943d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 12:27:28 -0700 Subject: [PATCH 054/197] Add dino layers change. --- unlabeled_extrapolation/baseline_train.py | 27 +++++++++++++++++++++ unlabeled_extrapolation/models/vit_model.py | 7 ++++-- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 85db755..5325d89 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -256,6 +256,31 @@ def set_requires_grad(component, val): param.requires_grad = val +_grad_layer_name = 'train/grad_layer_' +_normalized_grad_layer_name = 'train/normalized_grad_layer_' + + +def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): + if getattr(net, 'get_layers', None) is None or 'no_log_grads' in config: + return + layers = net.get_layers() + for i in range(len(layers)): + cur_layer = list(layers[i].parameters()) + if not cur_layer[0].requires_grad: + continue + if _grad_layer_name + str(i) not in loss_dict: + loss_dict[_grad_layer_name + str(i)] = Accumulator() + if _normalized_grad_layer_name + str(i) not in loss_dict: + loss_dict[_normalized_grad_layer_name + str(i)] = Accumulator() + grads = [p.grad.detach().cpu().numpy() for p in cur_layer] + grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] + grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size + loss_dict[_grad_layer_name + str(i)].add_value(grad_norm) + num_params = np.sum([p.numel() for p in cur_layer]) + normalized_grad_norm = grad_norm / np.sqrt(num_params) + loss_dict[_normalized_grad_layer_name + str(i)].add_value(normalized_grad_norm) + + def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial): # Returns a dictionary with epoch, train/loss and train/acc. @@ -311,6 +336,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/model_loss'].add_value(opt_loss.tolist()) else: loss.backward() + # Collect the gradients at each layer. + add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) optimizer.step() num_examples += len(labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 15c4cea..0a05f4b 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -36,12 +36,15 @@ def forward(self, x): if self._classifier is None: return features return self._classifier(features) - - def freeze_bottom_k(self, k): + def get_layers(self): patch_embed = self._model.patch_embed layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. layers += list(self._model.blocks) layers += [self._classifier] + return layers + + def freeze_bottom_k(self, k): + layers = self.get_layers() for i in range(min(k, len(layers))): set_requires_grad(layers[i], False) From 21234e37d749d90b81ada7bdd457fb6e27d8a27a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 12:27:28 -0700 Subject: [PATCH 055/197] Add dino layers change. --- unlabeled_extrapolation/baseline_train.py | 27 +++++++++++++++++++++ unlabeled_extrapolation/models/vit_model.py | 7 ++++-- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 85db755..5325d89 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -256,6 +256,31 @@ def set_requires_grad(component, val): param.requires_grad = val +_grad_layer_name = 'train/grad_layer_' +_normalized_grad_layer_name = 'train/normalized_grad_layer_' + + +def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): + if getattr(net, 'get_layers', None) is None or 'no_log_grads' in config: + return + layers = net.get_layers() + for i in range(len(layers)): + cur_layer = list(layers[i].parameters()) + if not cur_layer[0].requires_grad: + continue + if _grad_layer_name + str(i) not in loss_dict: + loss_dict[_grad_layer_name + str(i)] = Accumulator() + if _normalized_grad_layer_name + str(i) not in loss_dict: + loss_dict[_normalized_grad_layer_name + str(i)] = Accumulator() + grads = [p.grad.detach().cpu().numpy() for p in cur_layer] + grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] + grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size + loss_dict[_grad_layer_name + str(i)].add_value(grad_norm) + num_params = np.sum([p.numel() for p in cur_layer]) + normalized_grad_norm = grad_norm / np.sqrt(num_params) + loss_dict[_normalized_grad_layer_name + str(i)].add_value(normalized_grad_norm) + + def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial): # Returns a dictionary with epoch, train/loss and train/acc. @@ -311,6 +336,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/model_loss'].add_value(opt_loss.tolist()) else: loss.backward() + # Collect the gradients at each layer. + add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) optimizer.step() num_examples += len(labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 15c4cea..0a05f4b 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -36,12 +36,15 @@ def forward(self, x): if self._classifier is None: return features return self._classifier(features) - - def freeze_bottom_k(self, k): + def get_layers(self): patch_embed = self._model.patch_embed layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. layers += list(self._model.blocks) layers += [self._classifier] + return layers + + def freeze_bottom_k(self, k): + layers = self.get_layers() for i in range(min(k, len(layers))): set_requires_grad(layers[i], False) From 29735555f5cc3c981daf88e2ca037fd5b47e2761 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 14:21:27 -0700 Subject: [PATCH 056/197] Add bit resnet model. --- unlabeled_extrapolation/models/bit_resnet.py | 191 +++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 unlabeled_extrapolation/models/bit_resnet.py diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py new file mode 100644 index 0000000..56622dc --- /dev/null +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -0,0 +1,191 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Lint as: python3 +"""Bottleneck ResNet v2 with GroupNorm and Weight Standardization.""" + +from collections import OrderedDict # pylint: disable=g-importing-member + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class StdConv2d(nn.Conv2d): + + def forward(self, x): + w = self.weight + v, m = torch.var_mean(w, dim=[1, 2, 3], keepdim=True, unbiased=False) + w = (w - m) / torch.sqrt(v + 1e-10) + return F.conv2d(x, w, self.bias, self.stride, self.padding, + self.dilation, self.groups) + + +def conv3x3(cin, cout, stride=1, groups=1, bias=False): + return StdConv2d(cin, cout, kernel_size=3, stride=stride, + padding=1, bias=bias, groups=groups) + + +def conv1x1(cin, cout, stride=1, bias=False): + return StdConv2d(cin, cout, kernel_size=1, stride=stride, + padding=0, bias=bias) + + +def tf2th(conv_weights): + """Possibly convert HWIO to OIHW.""" + if conv_weights.ndim == 4: + conv_weights = conv_weights.transpose([3, 2, 0, 1]) + return torch.from_numpy(conv_weights) + + +class PreActBottleneck(nn.Module): + """Pre-activation (v2) bottleneck block. + + Follows the implementation of "Identity Mappings in Deep Residual Networks": + https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua + + Except it puts the stride on 3x3 conv when available. + """ + + def __init__(self, cin, cout=None, cmid=None, stride=1): + super().__init__() + cout = cout or cin + cmid = cmid or cout//4 + + self.gn1 = nn.GroupNorm(32, cin) + self.conv1 = conv1x1(cin, cmid) + self.gn2 = nn.GroupNorm(32, cmid) + self.conv2 = conv3x3(cmid, cmid, stride) # Original code has it on conv1!! + self.gn3 = nn.GroupNorm(32, cmid) + self.conv3 = conv1x1(cmid, cout) + self.relu = nn.ReLU(inplace=True) + + if (stride != 1 or cin != cout): + # Projection also with pre-activation according to paper. + self.downsample = conv1x1(cin, cout, stride) + + def forward(self, x): + out = self.relu(self.gn1(x)) + + # Residual branch + residual = x + if hasattr(self, 'downsample'): + residual = self.downsample(out) + + # Unit's branch + out = self.conv1(out) + out = self.conv2(self.relu(self.gn2(out))) + out = self.conv3(self.relu(self.gn3(out))) + + return out + residual + + def load_from(self, weights, prefix=''): + convname = 'standardized_conv2d' + with torch.no_grad(): + self.conv1.weight.copy_(tf2th(weights[f'{prefix}a/{convname}/kernel'])) + self.conv2.weight.copy_(tf2th(weights[f'{prefix}b/{convname}/kernel'])) + self.conv3.weight.copy_(tf2th(weights[f'{prefix}c/{convname}/kernel'])) + self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma'])) + self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma'])) + self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma'])) + self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta'])) + self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta'])) + self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta'])) + if hasattr(self, 'downsample'): + w = weights[f'{prefix}a/proj/{convname}/kernel'] + self.downsample.weight.copy_(tf2th(w)) + + +class ResNetV2(nn.Module): + """Implementation of Pre-activation (v2) ResNet mode.""" + + def __init__(self, block_units, width_factor, head_size=21843, zero_head=False): + super().__init__() + wf = width_factor # shortcut 'cause we'll use it a lot. + + # The following will be unreadable if we split lines. + # pylint: disable=line-too-long + self.root = nn.Sequential(OrderedDict([ + ('conv', StdConv2d(3, 64*wf, kernel_size=7, stride=2, padding=3, bias=False)), + ('pad', nn.ConstantPad2d(1, 0)), + ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)), + # The following is subtly not the same! + # ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)), + ])) + + self.body = nn.Sequential(OrderedDict([ + ('block1', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=64*wf, cout=256*wf, cmid=64*wf))] + + [(f'unit{i:02d}', PreActBottleneck(cin=256*wf, cout=256*wf, cmid=64*wf)) for i in range(2, block_units[0] + 1)], + ))), + ('block2', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=256*wf, cout=512*wf, cmid=128*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=512*wf, cout=512*wf, cmid=128*wf)) for i in range(2, block_units[1] + 1)], + ))), + ('block3', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=512*wf, cout=1024*wf, cmid=256*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=1024*wf, cout=1024*wf, cmid=256*wf)) for i in range(2, block_units[2] + 1)], + ))), + ('block4', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=1024*wf, cout=2048*wf, cmid=512*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=2048*wf, cout=2048*wf, cmid=512*wf)) for i in range(2, block_units[3] + 1)], + ))), + ])) + # pylint: enable=line-too-long + + self.zero_head = zero_head + self.head = nn.Sequential(OrderedDict([ + ('gn', nn.GroupNorm(32, 2048*wf)), + ('relu', nn.ReLU(inplace=True)), + ('avg', nn.AdaptiveAvgPool2d(output_size=1)), + ('conv', nn.Conv2d(2048*wf, head_size, kernel_size=1, bias=True)), + ])) + + def forward(self, x): + x = self.head(self.body(self.root(x))) + assert x.shape[-2:] == (1, 1) # We should have no spatial shape left. + return x[...,0,0] + + def load_from(self, weights, prefix='resnet/'): + with torch.no_grad(): + self.root.conv.weight.copy_(tf2th(weights[f'{prefix}root_block/standardized_conv2d/kernel'])) # pylint: disable=line-too-long + self.head.gn.weight.copy_(tf2th(weights[f'{prefix}group_norm/gamma'])) + self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta'])) + if self.zero_head: + nn.init.zeros_(self.head.conv.weight) + nn.init.zeros_(self.head.conv.bias) + else: + self.head.conv.weight.copy_(tf2th(weights[f'{prefix}head/conv2d/kernel'])) # pylint: disable=line-too-long + self.head.conv.bias.copy_(tf2th(weights[f'{prefix}head/conv2d/bias'])) + + for bname, block in self.body.named_children(): + for uname, unit in block.named_children(): + unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/') + + +KNOWN_MODELS = OrderedDict([ + ('BiT-M-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)), + ('BiT-M-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)), + ('BiT-M-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)), + ('BiT-M-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)), + ('BiT-M-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)), + ('BiT-M-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)), + ('BiT-S-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)), + ('BiT-S-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)), + ('BiT-S-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)), + ('BiT-S-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)), + ('BiT-S-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)), + ('BiT-S-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)), +]) + From a1f2d2a3a0241eeca07a47c509e6980e0c3271e3 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 14:21:27 -0700 Subject: [PATCH 057/197] Add bit resnet model. --- unlabeled_extrapolation/models/bit_resnet.py | 191 +++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 unlabeled_extrapolation/models/bit_resnet.py diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py new file mode 100644 index 0000000..56622dc --- /dev/null +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -0,0 +1,191 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Lint as: python3 +"""Bottleneck ResNet v2 with GroupNorm and Weight Standardization.""" + +from collections import OrderedDict # pylint: disable=g-importing-member + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class StdConv2d(nn.Conv2d): + + def forward(self, x): + w = self.weight + v, m = torch.var_mean(w, dim=[1, 2, 3], keepdim=True, unbiased=False) + w = (w - m) / torch.sqrt(v + 1e-10) + return F.conv2d(x, w, self.bias, self.stride, self.padding, + self.dilation, self.groups) + + +def conv3x3(cin, cout, stride=1, groups=1, bias=False): + return StdConv2d(cin, cout, kernel_size=3, stride=stride, + padding=1, bias=bias, groups=groups) + + +def conv1x1(cin, cout, stride=1, bias=False): + return StdConv2d(cin, cout, kernel_size=1, stride=stride, + padding=0, bias=bias) + + +def tf2th(conv_weights): + """Possibly convert HWIO to OIHW.""" + if conv_weights.ndim == 4: + conv_weights = conv_weights.transpose([3, 2, 0, 1]) + return torch.from_numpy(conv_weights) + + +class PreActBottleneck(nn.Module): + """Pre-activation (v2) bottleneck block. + + Follows the implementation of "Identity Mappings in Deep Residual Networks": + https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua + + Except it puts the stride on 3x3 conv when available. + """ + + def __init__(self, cin, cout=None, cmid=None, stride=1): + super().__init__() + cout = cout or cin + cmid = cmid or cout//4 + + self.gn1 = nn.GroupNorm(32, cin) + self.conv1 = conv1x1(cin, cmid) + self.gn2 = nn.GroupNorm(32, cmid) + self.conv2 = conv3x3(cmid, cmid, stride) # Original code has it on conv1!! + self.gn3 = nn.GroupNorm(32, cmid) + self.conv3 = conv1x1(cmid, cout) + self.relu = nn.ReLU(inplace=True) + + if (stride != 1 or cin != cout): + # Projection also with pre-activation according to paper. + self.downsample = conv1x1(cin, cout, stride) + + def forward(self, x): + out = self.relu(self.gn1(x)) + + # Residual branch + residual = x + if hasattr(self, 'downsample'): + residual = self.downsample(out) + + # Unit's branch + out = self.conv1(out) + out = self.conv2(self.relu(self.gn2(out))) + out = self.conv3(self.relu(self.gn3(out))) + + return out + residual + + def load_from(self, weights, prefix=''): + convname = 'standardized_conv2d' + with torch.no_grad(): + self.conv1.weight.copy_(tf2th(weights[f'{prefix}a/{convname}/kernel'])) + self.conv2.weight.copy_(tf2th(weights[f'{prefix}b/{convname}/kernel'])) + self.conv3.weight.copy_(tf2th(weights[f'{prefix}c/{convname}/kernel'])) + self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma'])) + self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma'])) + self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma'])) + self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta'])) + self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta'])) + self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta'])) + if hasattr(self, 'downsample'): + w = weights[f'{prefix}a/proj/{convname}/kernel'] + self.downsample.weight.copy_(tf2th(w)) + + +class ResNetV2(nn.Module): + """Implementation of Pre-activation (v2) ResNet mode.""" + + def __init__(self, block_units, width_factor, head_size=21843, zero_head=False): + super().__init__() + wf = width_factor # shortcut 'cause we'll use it a lot. + + # The following will be unreadable if we split lines. + # pylint: disable=line-too-long + self.root = nn.Sequential(OrderedDict([ + ('conv', StdConv2d(3, 64*wf, kernel_size=7, stride=2, padding=3, bias=False)), + ('pad', nn.ConstantPad2d(1, 0)), + ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)), + # The following is subtly not the same! + # ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)), + ])) + + self.body = nn.Sequential(OrderedDict([ + ('block1', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=64*wf, cout=256*wf, cmid=64*wf))] + + [(f'unit{i:02d}', PreActBottleneck(cin=256*wf, cout=256*wf, cmid=64*wf)) for i in range(2, block_units[0] + 1)], + ))), + ('block2', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=256*wf, cout=512*wf, cmid=128*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=512*wf, cout=512*wf, cmid=128*wf)) for i in range(2, block_units[1] + 1)], + ))), + ('block3', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=512*wf, cout=1024*wf, cmid=256*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=1024*wf, cout=1024*wf, cmid=256*wf)) for i in range(2, block_units[2] + 1)], + ))), + ('block4', nn.Sequential(OrderedDict( + [('unit01', PreActBottleneck(cin=1024*wf, cout=2048*wf, cmid=512*wf, stride=2))] + + [(f'unit{i:02d}', PreActBottleneck(cin=2048*wf, cout=2048*wf, cmid=512*wf)) for i in range(2, block_units[3] + 1)], + ))), + ])) + # pylint: enable=line-too-long + + self.zero_head = zero_head + self.head = nn.Sequential(OrderedDict([ + ('gn', nn.GroupNorm(32, 2048*wf)), + ('relu', nn.ReLU(inplace=True)), + ('avg', nn.AdaptiveAvgPool2d(output_size=1)), + ('conv', nn.Conv2d(2048*wf, head_size, kernel_size=1, bias=True)), + ])) + + def forward(self, x): + x = self.head(self.body(self.root(x))) + assert x.shape[-2:] == (1, 1) # We should have no spatial shape left. + return x[...,0,0] + + def load_from(self, weights, prefix='resnet/'): + with torch.no_grad(): + self.root.conv.weight.copy_(tf2th(weights[f'{prefix}root_block/standardized_conv2d/kernel'])) # pylint: disable=line-too-long + self.head.gn.weight.copy_(tf2th(weights[f'{prefix}group_norm/gamma'])) + self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta'])) + if self.zero_head: + nn.init.zeros_(self.head.conv.weight) + nn.init.zeros_(self.head.conv.bias) + else: + self.head.conv.weight.copy_(tf2th(weights[f'{prefix}head/conv2d/kernel'])) # pylint: disable=line-too-long + self.head.conv.bias.copy_(tf2th(weights[f'{prefix}head/conv2d/bias'])) + + for bname, block in self.body.named_children(): + for uname, unit in block.named_children(): + unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/') + + +KNOWN_MODELS = OrderedDict([ + ('BiT-M-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)), + ('BiT-M-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)), + ('BiT-M-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)), + ('BiT-M-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)), + ('BiT-M-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)), + ('BiT-M-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)), + ('BiT-S-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)), + ('BiT-S-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)), + ('BiT-S-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)), + ('BiT-S-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)), + ('BiT-S-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)), + ('BiT-S-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)), +]) + From 497c1e79369c5bc96a5c723ff00ea0a00501afab Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 11 Aug 2022 23:45:56 +0000 Subject: [PATCH 058/197] bit resnet fixes. --- unlabeled_extrapolation/models/bit_resnet.py | 60 ++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index 56622dc..c869fda 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -1,3 +1,4 @@ +# Note: this model does normalization. # Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +22,9 @@ import torch.nn as nn import torch.nn.functional as F +import numpy as np +from torchvision.transforms import Normalize + class StdConv2d(nn.Conv2d): @@ -172,6 +176,62 @@ def load_from(self, weights, prefix='resnet/'): for bname, block in self.body.named_children(): for uname, unit in block.named_children(): unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/') + + +normalize_transform = Normalize( + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5)) + + +class BitResNet(nn.Module): + + def __init__(self, model_name, pretrained_weights_dir='.', normalize=True): + super().__init__() + if model_name not in KNOWN_MODELS: + raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') + self._model_name = model_name + self._model = KNOWN_MODELS[model_name](head_size=1000) + self._model.load_from(np.load(pretrained_weights_dir + f'/{model_name}-ILSVRC2012.npz')) + self._normalize = normalize + + def forward(self, x): + if self._normalize: + x = normalize_transform(x) + return self._model(x) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def get_layers(self): + layers = [self._model.root] + list(self._model.body) + [self._model.head] + return layers + + def freeze_bottom_k(self, k): + layers = self.get_layers() + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + for i in range(k): + set_requires_grad(layers[i], False) + + def new_last_layer(self, num_classes): + num_features = self._model.head.gn.num_channels + self._model.head.conv = nn.Conv2d(num_features, num_classes, kernel_size=(1, 1), stride=(1, 1)) + + def add_probe(self, probe): + raise NotImplementedError('Not Implemented yet.') + + def get_last_layer(self): + return self._model.head.conv + + def set_last_layer(self, coef, intercept): + raise NotImplementedError('Not Implemented yet.') + + def get_feature_extractor(self): + raise NotImplementedError('Not Implemented yet.') + + def get_features(self, x): + raise NotImplementedError('Not Implemented yet.') KNOWN_MODELS = OrderedDict([ From 53825d8c82f84deb57c28f8c4f905e5c25632ef9 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 11 Aug 2022 23:45:56 +0000 Subject: [PATCH 059/197] bit resnet fixes. --- unlabeled_extrapolation/models/bit_resnet.py | 60 ++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index 56622dc..c869fda 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -1,3 +1,4 @@ +# Note: this model does normalization. # Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +22,9 @@ import torch.nn as nn import torch.nn.functional as F +import numpy as np +from torchvision.transforms import Normalize + class StdConv2d(nn.Conv2d): @@ -172,6 +176,62 @@ def load_from(self, weights, prefix='resnet/'): for bname, block in self.body.named_children(): for uname, unit in block.named_children(): unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/') + + +normalize_transform = Normalize( + mean=(0.5, 0.5, 0.5), + std=(0.5, 0.5, 0.5)) + + +class BitResNet(nn.Module): + + def __init__(self, model_name, pretrained_weights_dir='.', normalize=True): + super().__init__() + if model_name not in KNOWN_MODELS: + raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') + self._model_name = model_name + self._model = KNOWN_MODELS[model_name](head_size=1000) + self._model.load_from(np.load(pretrained_weights_dir + f'/{model_name}-ILSVRC2012.npz')) + self._normalize = normalize + + def forward(self, x): + if self._normalize: + x = normalize_transform(x) + return self._model(x) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def get_layers(self): + layers = [self._model.root] + list(self._model.body) + [self._model.head] + return layers + + def freeze_bottom_k(self, k): + layers = self.get_layers() + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + for i in range(k): + set_requires_grad(layers[i], False) + + def new_last_layer(self, num_classes): + num_features = self._model.head.gn.num_channels + self._model.head.conv = nn.Conv2d(num_features, num_classes, kernel_size=(1, 1), stride=(1, 1)) + + def add_probe(self, probe): + raise NotImplementedError('Not Implemented yet.') + + def get_last_layer(self): + return self._model.head.conv + + def set_last_layer(self, coef, intercept): + raise NotImplementedError('Not Implemented yet.') + + def get_feature_extractor(self): + raise NotImplementedError('Not Implemented yet.') + + def get_features(self, x): + raise NotImplementedError('Not Implemented yet.') KNOWN_MODELS = OrderedDict([ From 0f9cce834e32ddffeb2c90640588fa10655cad8a Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 11 Aug 2022 23:57:29 +0000 Subject: [PATCH 060/197] Use checkpoint_path to streamline with other models. --- unlabeled_extrapolation/models/bit_resnet.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index c869fda..1d636aa 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -185,13 +185,13 @@ def load_from(self, weights, prefix='resnet/'): class BitResNet(nn.Module): - def __init__(self, model_name, pretrained_weights_dir='.', normalize=True): + def __init__(self, model_name, checkpoint_path=None, normalize=True): super().__init__() if model_name not in KNOWN_MODELS: raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') self._model_name = model_name self._model = KNOWN_MODELS[model_name](head_size=1000) - self._model.load_from(np.load(pretrained_weights_dir + f'/{model_name}-ILSVRC2012.npz')) + self._model.load_from(np.load(checkpoint_path)) self._normalize = normalize def forward(self, x): From 8be6fb89b3f024287ec8953b53c047634ce13b8a Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 11 Aug 2022 23:57:29 +0000 Subject: [PATCH 061/197] Use checkpoint_path to streamline with other models. --- unlabeled_extrapolation/models/bit_resnet.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index c869fda..1d636aa 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -185,13 +185,13 @@ def load_from(self, weights, prefix='resnet/'): class BitResNet(nn.Module): - def __init__(self, model_name, pretrained_weights_dir='.', normalize=True): + def __init__(self, model_name, checkpoint_path=None, normalize=True): super().__init__() if model_name not in KNOWN_MODELS: raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') self._model_name = model_name self._model = KNOWN_MODELS[model_name](head_size=1000) - self._model.load_from(np.load(pretrained_weights_dir + f'/{model_name}-ILSVRC2012.npz')) + self._model.load_from(np.load(checkpoint_path)) self._normalize = normalize def forward(self, x): From ffedf7ecb2b6bb84beda0ef95d4df18cfcd44360 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 16:58:03 -0700 Subject: [PATCH 062/197] Add bit model to sweep --- scripts/run_adaptation_experiments.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index a3ae85b..caef316 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -905,6 +905,15 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +bit_resnet_50 = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R50x1', + 'checkpoint_rel_path': 'BiT-M-R50x1-ILSVRC2012.npz', + }, + bundles=[] +} + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -936,6 +945,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_l14': clip_vit_l14, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, + 'bit_resnet_50': bit_resnet_50, 'landcover_baseline': landcover_baseline, 'landcover_auxin': landcover_auxin, } From 7966d6ef421600aeec9a5f110a91f27e9bd461be Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 16:58:03 -0700 Subject: [PATCH 063/197] Add bit model to sweep --- scripts/run_adaptation_experiments.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index a3ae85b..caef316 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -905,6 +905,15 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +bit_resnet_50 = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R50x1', + 'checkpoint_rel_path': 'BiT-M-R50x1-ILSVRC2012.npz', + }, + bundles=[] +} + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -936,6 +945,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_l14': clip_vit_l14, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, + 'bit_resnet_50': bit_resnet_50, 'landcover_baseline': landcover_baseline, 'landcover_auxin': landcover_auxin, } From 3a6c05319deadf7d506095e5d40a2ac75c7c3d82 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 17:35:55 -0700 Subject: [PATCH 064/197] Bit fixes. --- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/models/bit_resnet.py | 3 ++- unlabeled_extrapolation/utils/utils.py | 7 ++++++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index caef316..754d4f3 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -912,7 +912,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'checkpoint_rel_path': 'BiT-M-R50x1-ILSVRC2012.npz', }, bundles=[] -} +) landcover_baseline = Model( kwargs={ diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index 1d636aa..a598424 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -25,6 +25,7 @@ import numpy as np from torchvision.transforms import Normalize +import unlabeled_extrapolation.utils.utils as utils class StdConv2d(nn.Conv2d): @@ -212,7 +213,7 @@ def freeze_bottom_k(self, k): if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): - set_requires_grad(layers[i], False) + utils.set_requires_grad(layers[i], False) def new_last_layer(self, num_classes): num_features = self._model.head.gn.num_channels diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index 069fd92..2774f02 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -1,4 +1,4 @@ -# Thanks to Michael Xie for these utilities. +# Thanks to Michael Xie for inital version of these utilities. import ast from copy import deepcopy @@ -165,3 +165,8 @@ def to_device(obj, device): else: return obj.to(device) + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + From 1ae10676805d680eadcbe02cd266ce1a3024fb9f Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 11 Aug 2022 17:35:55 -0700 Subject: [PATCH 065/197] Bit fixes. --- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/models/bit_resnet.py | 3 ++- unlabeled_extrapolation/utils/utils.py | 7 ++++++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index caef316..754d4f3 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -912,7 +912,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'checkpoint_rel_path': 'BiT-M-R50x1-ILSVRC2012.npz', }, bundles=[] -} +) landcover_baseline = Model( kwargs={ diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index 1d636aa..a598424 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -25,6 +25,7 @@ import numpy as np from torchvision.transforms import Normalize +import unlabeled_extrapolation.utils.utils as utils class StdConv2d(nn.Conv2d): @@ -212,7 +213,7 @@ def freeze_bottom_k(self, k): if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): - set_requires_grad(layers[i], False) + utils.set_requires_grad(layers[i], False) def new_last_layer(self, num_classes): num_features = self._model.head.gn.num_channels diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index 069fd92..2774f02 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -1,4 +1,4 @@ -# Thanks to Michael Xie for these utilities. +# Thanks to Michael Xie for inital version of these utilities. import ast from copy import deepcopy @@ -165,3 +165,8 @@ def to_device(obj, device): else: return obj.to(device) + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + From 9a0a529ccf1a22651f2fbfd8b535a41d8255e011 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:06:54 -0700 Subject: [PATCH 066/197] Add support for subsampled wilds. --- scripts/waterbirds_examples.ipynb | 68 +++++++++++++++++++---- unlabeled_extrapolation/datasets/wilds.py | 37 +++++++++++- 2 files changed, 93 insertions(+), 12 deletions(-) diff --git a/scripts/waterbirds_examples.ipynb b/scripts/waterbirds_examples.ipynb index cb57b32..9f08e33 100644 --- a/scripts/waterbirds_examples.ipynb +++ b/scripts/waterbirds_examples.ipynb @@ -2,17 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, - "id": "0b8091ef", + "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } @@ -21,6 +20,8 @@ "from unlabeled_extrapolation.datasets import wilds\n", "import torchvision.transforms as transforms\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from collections import defaultdict, Counter\n", "\n", "import importlib\n", "importlib.reload(wilds)" @@ -28,21 +29,69 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "c6e10576", + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "train_transform = transforms.Compose([\n", " transforms.Resize(size=224)\n", "])\n", - "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root='/home/t-anakumar/wilds/data/', transform=train_transform, return_meta=True)" + "root = '/u/scr/nlp/wilds/data' # For NLP cluster.\n", + "# root = '/home/t-anakumar/wilds/data/' # For microsoft sandbox.\n", + "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root=root, transform=train_transform, return_meta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({1: 1113, 0: 1113})\n" + ] + } + ], + "source": [ + "# Subsampled y waterbirds. Test that it is balanced.\n", + "waterbirds_train_sub = wilds.WILDS(dataset_name='waterbirds', split='train', download='true', root=root,\n", + " transform=train_transform, return_meta=True, subsampled_y=True)\n", + "y = []\n", + "for i in range(len(waterbirds_train_sub)):\n", + " y.append(int(waterbirds_train_sub[i][1].numpy()))\n", + "\n", + "print(Counter(y))" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({(1, 1, 1): 56, (0, 1, 1): 56, (0, 0, 1): 56, (1, 0, 1): 56})\n" + ] + } + ], + "source": [ + "# Subsampled meta, waterbirds. Test that it is balanced.\n", + "waterbirds_train_meta_sub = wilds.WILDS(dataset_name='waterbirds', split='train', download='true', root=root,\n", + " transform=train_transform, return_meta=True, subsampled_meta=True)\n", + "metas = []\n", + "for i in range(len(waterbirds_train_meta_sub)):\n", + " metas.append(tuple(waterbirds_train_meta_sub[i][2].numpy()))\n", + "\n", + "print(Counter(metas))" ] }, { "cell_type": "code", "execution_count": 15, - "id": "ae4fa7a5", "metadata": {}, "outputs": [ { @@ -101,7 +150,6 @@ { "cell_type": "code", "execution_count": 19, - "id": "0cc60ca8", "metadata": {}, "outputs": [], "source": [] @@ -109,7 +157,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index af27aad..d89ac5f 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -1,13 +1,31 @@ from wilds import get_dataset +from collections import defaultdict import torch from torch.utils.data import Dataset import numpy as np + +def get_indices_by_value(values): + # Returns list_of_lists, where list_of_lists[i] corresponds to all indices + # i with equal values[i]. + index_dict = defaultdict(list) + for i, v in zip(range(len(values)), values): + index_dict[v].append(i) + return list(index_dict.values()) + +def equal_subsample(list_of_lists, rng): + min_size = np.min([len(l) for l in list_of_lists]) + subsampled = [rng.choice(l, size=min_size, replace=False) for l in list_of_lists] + subsampled = np.concatenate(subsampled) + return subsampled + + class WILDS(Dataset): - def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False): + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False, + subsampled_y=False, subsampled_meta=False, seed=0): # Split can be train, id_val, id_test, val, test. super().__init__() parent_dataset_name = dataset_name @@ -21,6 +39,7 @@ def __init__(self, dataset_name, split, root, meta_selector=None, transform=None self._indices = None self._meta_selector = None self._return_meta = return_meta + self._rng = np.random.default_rng(seed=seed) if meta_selector is not None: self._meta_selector = tuple(meta_selector) super_indices = self._dataset.indices @@ -28,6 +47,19 @@ def __init__(self, dataset_name, split, root, meta_selector=None, transform=None mask = np.all(subset_metadata == np.array(meta_selector), axis=-1) # For some reason the indices is 2d (each index is in its own list), so need [:. 0] below. self._indices = np.argwhere(mask)[:, 0] + if subsampled_y or subsampled_meta: + if meta_selector is not None or (subsampled_y and subsampled_meta): + raise ValueError(f"subsampled_y ({subsampled_y}), subsampled_meta ({subsampled_meta}), " + f"meta_selector ({meta_selector}) but two of these three must be None.") + super_indices = self._dataset.indices + if subsampled_y: + subset_ys = self._dataset.dataset._y_array[super_indices].numpy() + list_of_lists = get_indices_by_value(subset_ys) + if subsampled_meta: + subset_metas = self._dataset.dataset.metadata_array[super_indices].numpy() + subset_metas = [tuple(l) for l in subset_metas] + list_of_lists = get_indices_by_value(subset_metas) + self._indices = equal_subsample(list_of_lists, self._rng) def __getitem__(self, i): @@ -35,7 +67,8 @@ def __getitem__(self, i): x, y, z = self._dataset[i] else: x, y, z = self._dataset[self._indices[i]] - assert(tuple(z) == self._meta_selector) + if self._meta_selector is not None: + assert(tuple(z) == self._meta_selector) x = x.convert('RGB') x = self._transform(x) if 'waterbirds' in self._dataset_name and 'background' in self._dataset_name: From 2175f69d365cdc7f9f38bbe9ddb5591f2803d926 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:06:54 -0700 Subject: [PATCH 067/197] Add support for subsampled wilds. --- scripts/waterbirds_examples.ipynb | 68 +++++++++++++++++++---- unlabeled_extrapolation/datasets/wilds.py | 37 +++++++++++- 2 files changed, 93 insertions(+), 12 deletions(-) diff --git a/scripts/waterbirds_examples.ipynb b/scripts/waterbirds_examples.ipynb index cb57b32..9f08e33 100644 --- a/scripts/waterbirds_examples.ipynb +++ b/scripts/waterbirds_examples.ipynb @@ -2,17 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, - "id": "0b8091ef", + "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } @@ -21,6 +20,8 @@ "from unlabeled_extrapolation.datasets import wilds\n", "import torchvision.transforms as transforms\n", "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from collections import defaultdict, Counter\n", "\n", "import importlib\n", "importlib.reload(wilds)" @@ -28,21 +29,69 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "c6e10576", + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "train_transform = transforms.Compose([\n", " transforms.Resize(size=224)\n", "])\n", - "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root='/home/t-anakumar/wilds/data/', transform=train_transform, return_meta=True)" + "root = '/u/scr/nlp/wilds/data' # For NLP cluster.\n", + "# root = '/home/t-anakumar/wilds/data/' # For microsoft sandbox.\n", + "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root=root, transform=train_transform, return_meta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({1: 1113, 0: 1113})\n" + ] + } + ], + "source": [ + "# Subsampled y waterbirds. Test that it is balanced.\n", + "waterbirds_train_sub = wilds.WILDS(dataset_name='waterbirds', split='train', download='true', root=root,\n", + " transform=train_transform, return_meta=True, subsampled_y=True)\n", + "y = []\n", + "for i in range(len(waterbirds_train_sub)):\n", + " y.append(int(waterbirds_train_sub[i][1].numpy()))\n", + "\n", + "print(Counter(y))" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({(1, 1, 1): 56, (0, 1, 1): 56, (0, 0, 1): 56, (1, 0, 1): 56})\n" + ] + } + ], + "source": [ + "# Subsampled meta, waterbirds. Test that it is balanced.\n", + "waterbirds_train_meta_sub = wilds.WILDS(dataset_name='waterbirds', split='train', download='true', root=root,\n", + " transform=train_transform, return_meta=True, subsampled_meta=True)\n", + "metas = []\n", + "for i in range(len(waterbirds_train_meta_sub)):\n", + " metas.append(tuple(waterbirds_train_meta_sub[i][2].numpy()))\n", + "\n", + "print(Counter(metas))" ] }, { "cell_type": "code", "execution_count": 15, - "id": "ae4fa7a5", "metadata": {}, "outputs": [ { @@ -101,7 +150,6 @@ { "cell_type": "code", "execution_count": 19, - "id": "0cc60ca8", "metadata": {}, "outputs": [], "source": [] @@ -109,7 +157,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index af27aad..d89ac5f 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -1,13 +1,31 @@ from wilds import get_dataset +from collections import defaultdict import torch from torch.utils.data import Dataset import numpy as np + +def get_indices_by_value(values): + # Returns list_of_lists, where list_of_lists[i] corresponds to all indices + # i with equal values[i]. + index_dict = defaultdict(list) + for i, v in zip(range(len(values)), values): + index_dict[v].append(i) + return list(index_dict.values()) + +def equal_subsample(list_of_lists, rng): + min_size = np.min([len(l) for l in list_of_lists]) + subsampled = [rng.choice(l, size=min_size, replace=False) for l in list_of_lists] + subsampled = np.concatenate(subsampled) + return subsampled + + class WILDS(Dataset): - def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False): + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False, + subsampled_y=False, subsampled_meta=False, seed=0): # Split can be train, id_val, id_test, val, test. super().__init__() parent_dataset_name = dataset_name @@ -21,6 +39,7 @@ def __init__(self, dataset_name, split, root, meta_selector=None, transform=None self._indices = None self._meta_selector = None self._return_meta = return_meta + self._rng = np.random.default_rng(seed=seed) if meta_selector is not None: self._meta_selector = tuple(meta_selector) super_indices = self._dataset.indices @@ -28,6 +47,19 @@ def __init__(self, dataset_name, split, root, meta_selector=None, transform=None mask = np.all(subset_metadata == np.array(meta_selector), axis=-1) # For some reason the indices is 2d (each index is in its own list), so need [:. 0] below. self._indices = np.argwhere(mask)[:, 0] + if subsampled_y or subsampled_meta: + if meta_selector is not None or (subsampled_y and subsampled_meta): + raise ValueError(f"subsampled_y ({subsampled_y}), subsampled_meta ({subsampled_meta}), " + f"meta_selector ({meta_selector}) but two of these three must be None.") + super_indices = self._dataset.indices + if subsampled_y: + subset_ys = self._dataset.dataset._y_array[super_indices].numpy() + list_of_lists = get_indices_by_value(subset_ys) + if subsampled_meta: + subset_metas = self._dataset.dataset.metadata_array[super_indices].numpy() + subset_metas = [tuple(l) for l in subset_metas] + list_of_lists = get_indices_by_value(subset_metas) + self._indices = equal_subsample(list_of_lists, self._rng) def __getitem__(self, i): @@ -35,7 +67,8 @@ def __getitem__(self, i): x, y, z = self._dataset[i] else: x, y, z = self._dataset[self._indices[i]] - assert(tuple(z) == self._meta_selector) + if self._meta_selector is not None: + assert(tuple(z) == self._meta_selector) x = x.convert('RGB') x = self._transform(x) if 'waterbirds' in self._dataset_name and 'background' in self._dataset_name: From cc558f84ec804b54a87ad5ee30e9e8048a4f55cb Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:07:23 -0700 Subject: [PATCH 068/197] Add support for more optimizers. --- scripts/run_adaptation_experiments.py | 47 +++++++++++++++++++++-- unlabeled_extrapolation/baseline_train.py | 15 ++++++++ 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 754d4f3..aba1622 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_rmsprop = Dataset( + name='waterbirds_rmsprop', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_eval.yaml') + + waterbirds_background = Dataset( name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', @@ -774,6 +792,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_rmsprop': waterbirds_rmsprop, 'waterbirds_background': waterbirds_background, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, @@ -1114,6 +1133,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name = 'l2sp' if args.epochs is not None: adapt_name += '_epochs' + str(args.epochs) + if args.optimizer is not None: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] # Set hyperparameters if args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or @@ -1144,6 +1165,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.optimizer is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'optimizer.classname': args.optimizer}) + adapt_name += '_opt_' + args.optimizer if args.full_ft_epoch is not None: hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) @@ -1186,7 +1211,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, - num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path'}) + num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1275,7 +1300,7 @@ def linprobe_experiments_usenewbnstats(args, num_replications=3): linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) -def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False): +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False): if args.epochs is not None: raise ValueError('Does not support epochs yet.') adapt_name = 'lp_then_ft' @@ -1304,6 +1329,15 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) + if args.optimizer is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'optimizer.classname': args.optimizer}) + adapt_name += '_opt_' + args.optimizer + if l2sp: + # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 + # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. + adapt_name += '_l2sp' + hyperparams_list = append_to_each(hyperparams_list, {'l2sp_weight': 0.01}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) for dataset in datasets: @@ -1320,7 +1354,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'linear_probe_checkpoint_path'}) + ignore_name_hypers={'linear_probe_checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1328,6 +1362,10 @@ def lp_then_ft_valmode_experiments(args, num_replications=3): lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) +def lp_then_ft_l2sp_experiments(args, num_replications=3): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, l2sp=True) + + def lp_then_ft_trainmode_experiments(args, num_replications=3): lp_then_ft_experiments(args, num_replications=num_replications, train_mode=True) @@ -1393,6 +1431,7 @@ def main(args): 'ft_val_mode_experiment': ft_val_mode_experiment, 'fine_tuning_no_augmentation_experiments': fine_tuning_no_augmentation_experiments, 'l2sp_experiments': l2sp_experiments, + 'lp_then_ft_l2sp_experiments': lp_then_ft_l2sp_experiments, 'side_tune_experiments': side_tune_experiments, 'side_tune_val_mode_experiments': side_tune_val_mode_experiments, 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, @@ -1426,6 +1465,8 @@ def fill_platform_specific_default_args(args): help='Base seed, we typically add to this seed for replication runs.') parser.add_argument('--epochs', type=int, required=False, default=None, help='Number of epochs to run job for.') + parser.add_argument('--optimizer', type=str, required=False, default=None, + help='Class name of optimizer to use, e.g., torch.optim.Adam') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 5325d89..0275a97 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -387,6 +387,10 @@ def get_params(layers): return params +def check_value_not_none(d, k, v): + return k in d and d[k] == v + + def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. logging.info("Entering main.") @@ -636,6 +640,15 @@ def set_random_seed(seed): np.random.seed(seed + 111) +def update_optimizer_args(config): + if config['optimizer']['classname'] in [ + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop']: + # These optimizers don't have a momentum term. + # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, + # without having to rework the config. + del config['optimizer']['args']['momentum'] + + def preprocess_config(config, config_path): # If it's not a json config (e.g. if it's yaml) then process it. if not config_path.endswith('.json'): @@ -659,6 +672,8 @@ def preprocess_config(config, config_path): # if we want to run the same experiments on variants of a dataset (e.g., # waterbirds-background (vs. original waterbirds experiment which uses foreground). update_dataset_names(config) + # Update optimizer arguments. + update_optimizer_args(config) def setup(): From fcfd20918154419a373588b7b4a58c6617d2c4fa Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:07:23 -0700 Subject: [PATCH 069/197] Add support for more optimizers. --- scripts/run_adaptation_experiments.py | 47 +++++++++++++++++++++-- unlabeled_extrapolation/baseline_train.py | 15 ++++++++ 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 754d4f3..aba1622 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_rmsprop = Dataset( + name='waterbirds_rmsprop', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_eval.yaml') + + waterbirds_background = Dataset( name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', @@ -774,6 +792,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_rmsprop': waterbirds_rmsprop, 'waterbirds_background': waterbirds_background, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, @@ -1114,6 +1133,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name = 'l2sp' if args.epochs is not None: adapt_name += '_epochs' + str(args.epochs) + if args.optimizer is not None: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] # Set hyperparameters if args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or @@ -1144,6 +1165,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.optimizer is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'optimizer.classname': args.optimizer}) + adapt_name += '_opt_' + args.optimizer if args.full_ft_epoch is not None: hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) @@ -1186,7 +1211,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, - num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path'}) + num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1275,7 +1300,7 @@ def linprobe_experiments_usenewbnstats(args, num_replications=3): linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) -def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False): +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False): if args.epochs is not None: raise ValueError('Does not support epochs yet.') adapt_name = 'lp_then_ft' @@ -1304,6 +1329,15 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) + if args.optimizer is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'optimizer.classname': args.optimizer}) + adapt_name += '_opt_' + args.optimizer + if l2sp: + # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 + # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. + adapt_name += '_l2sp' + hyperparams_list = append_to_each(hyperparams_list, {'l2sp_weight': 0.01}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) for dataset in datasets: @@ -1320,7 +1354,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'linear_probe_checkpoint_path'}) + ignore_name_hypers={'linear_probe_checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1328,6 +1362,10 @@ def lp_then_ft_valmode_experiments(args, num_replications=3): lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) +def lp_then_ft_l2sp_experiments(args, num_replications=3): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, l2sp=True) + + def lp_then_ft_trainmode_experiments(args, num_replications=3): lp_then_ft_experiments(args, num_replications=num_replications, train_mode=True) @@ -1393,6 +1431,7 @@ def main(args): 'ft_val_mode_experiment': ft_val_mode_experiment, 'fine_tuning_no_augmentation_experiments': fine_tuning_no_augmentation_experiments, 'l2sp_experiments': l2sp_experiments, + 'lp_then_ft_l2sp_experiments': lp_then_ft_l2sp_experiments, 'side_tune_experiments': side_tune_experiments, 'side_tune_val_mode_experiments': side_tune_val_mode_experiments, 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, @@ -1426,6 +1465,8 @@ def fill_platform_specific_default_args(args): help='Base seed, we typically add to this seed for replication runs.') parser.add_argument('--epochs', type=int, required=False, default=None, help='Number of epochs to run job for.') + parser.add_argument('--optimizer', type=str, required=False, default=None, + help='Class name of optimizer to use, e.g., torch.optim.Adam') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 5325d89..0275a97 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -387,6 +387,10 @@ def get_params(layers): return params +def check_value_not_none(d, k, v): + return k in d and d[k] == v + + def main(config, log_dir, checkpoints_dir): # Set up datasets and loaders. logging.info("Entering main.") @@ -636,6 +640,15 @@ def set_random_seed(seed): np.random.seed(seed + 111) +def update_optimizer_args(config): + if config['optimizer']['classname'] in [ + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop']: + # These optimizers don't have a momentum term. + # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, + # without having to rework the config. + del config['optimizer']['args']['momentum'] + + def preprocess_config(config, config_path): # If it's not a json config (e.g. if it's yaml) then process it. if not config_path.endswith('.json'): @@ -659,6 +672,8 @@ def preprocess_config(config, config_path): # if we want to run the same experiments on variants of a dataset (e.g., # waterbirds-background (vs. original waterbirds experiment which uses foreground). update_dataset_names(config) + # Update optimizer arguments. + update_optimizer_args(config) def setup(): From 413fd2ddf57de52ccf47308755c0118c45c5bccb Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:07:57 -0700 Subject: [PATCH 070/197] Reduce batch size for larger models. --- configs/adaptation/domainnet.yaml | 2 ++ configs/adaptation/waterbirds.yaml | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml index e99fdaa..396a50b 100644 --- a/configs/adaptation/domainnet.yaml +++ b/configs/adaptation/domainnet.yaml @@ -5,6 +5,8 @@ inherit: num_classes: 40 epochs: &epochs 50 # Very small dataset so run for longer. +batch_size: 32 +save_no_checkpoints: True model: classname: models.clip_model.ClipModel diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 7fc66b7..430c6a7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 32 +batch_size: 16 save_no_checkpoints: True model: From 6e774728a244ade4b41506a8cde565d853f19673 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:07:57 -0700 Subject: [PATCH 071/197] Reduce batch size for larger models. --- configs/adaptation/domainnet.yaml | 2 ++ configs/adaptation/waterbirds.yaml | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml index e99fdaa..396a50b 100644 --- a/configs/adaptation/domainnet.yaml +++ b/configs/adaptation/domainnet.yaml @@ -5,6 +5,8 @@ inherit: num_classes: 40 epochs: &epochs 50 # Very small dataset so run for longer. +batch_size: 32 +save_no_checkpoints: True model: classname: models.clip_model.ClipModel diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 7fc66b7..430c6a7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 32 +batch_size: 16 save_no_checkpoints: True model: From 1ccdb67fb682a6e58e2891ac394ab184cb6dec1a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:08:08 -0700 Subject: [PATCH 072/197] Do normalization inside vit. --- unlabeled_extrapolation/models/clip_model.py | 2 +- unlabeled_extrapolation/models/vit_model.py | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 5761b1f..a1a1513 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -1,4 +1,4 @@ - +# Note: this model does normalization. import clip from collections import OrderedDict import torchvision.models as models diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 0a05f4b..59508d9 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -1,4 +1,4 @@ - +# Note: this model does normalization. from collections import OrderedDict import torchvision.models as models from torchvision.models import resnet50 @@ -12,6 +12,11 @@ MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} +normalize_transform = Normalize( + mean=(0.485, 0.456, 0.406), + std=[0.228, 0.224, 0.225]) + + def set_requires_grad(component, val): for param in component.parameters(): param.requires_grad = val @@ -36,6 +41,7 @@ def forward(self, x): if self._classifier is None: return features return self._classifier(features) + def get_layers(self): patch_embed = self._model.patch_embed layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. @@ -70,7 +76,7 @@ def set_last_layer(self, coef, intercept): model_utils.set_linear_layer(self._classifier, coef, intercept) def get_feature_extractor(self): - return self._model + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') def get_features(self, x): - return self._model(x) + return self._model(normalize_transform(x)) From 3ba5517a796f3fe9f9197b8768caa9d9cade6e99 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 00:08:08 -0700 Subject: [PATCH 073/197] Do normalization inside vit. --- unlabeled_extrapolation/models/clip_model.py | 2 +- unlabeled_extrapolation/models/vit_model.py | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 5761b1f..a1a1513 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -1,4 +1,4 @@ - +# Note: this model does normalization. import clip from collections import OrderedDict import torchvision.models as models diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 0a05f4b..59508d9 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -1,4 +1,4 @@ - +# Note: this model does normalization. from collections import OrderedDict import torchvision.models as models from torchvision.models import resnet50 @@ -12,6 +12,11 @@ MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} +normalize_transform = Normalize( + mean=(0.485, 0.456, 0.406), + std=[0.228, 0.224, 0.225]) + + def set_requires_grad(component, val): for param in component.parameters(): param.requires_grad = val @@ -36,6 +41,7 @@ def forward(self, x): if self._classifier is None: return features return self._classifier(features) + def get_layers(self): patch_embed = self._model.patch_embed layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. @@ -70,7 +76,7 @@ def set_last_layer(self, coef, intercept): model_utils.set_linear_layer(self._classifier, coef, intercept) def get_feature_extractor(self): - return self._model + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') def get_features(self, x): - return self._model(x) + return self._model(normalize_transform(x)) From 5ae97946f658a498179c7be2ffbeb2a1419676c6 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 11:04:08 -0700 Subject: [PATCH 074/197] update --- configs/adaptation/datasets_waterbirds.yaml | 1 - .../adaptation/waterbirds_group_balanced.yaml | 39 +++++++++++++++++++ .../adaptation/waterbirds_label_balanced.yaml | 38 ++++++++++++++++++ scripts/run_adaptation_experiments.py | 27 ++++++++++--- 4 files changed, 99 insertions(+), 6 deletions(-) create mode 100644 configs/adaptation/waterbirds_group_balanced.yaml create mode 100644 configs/adaptation/waterbirds_label_balanced.yaml diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 55e2911..7f73908 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -9,7 +9,6 @@ train_dataset: root: 'wilds/data/' dataset_name: 'waterbirds' split: 'train' - download: 'true' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize args: diff --git a/configs/adaptation/waterbirds_group_balanced.yaml b/configs/adaptation/waterbirds_group_balanced.yaml new file mode 100644 index 0000000..e4192b8 --- /dev/null +++ b/configs/adaptation/waterbirds_group_balanced.yaml @@ -0,0 +1,39 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + subsampled_meta: True + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + diff --git a/configs/adaptation/waterbirds_label_balanced.yaml b/configs/adaptation/waterbirds_label_balanced.yaml new file mode 100644 index 0000000..c31d0ad --- /dev/null +++ b/configs/adaptation/waterbirds_label_balanced.yaml @@ -0,0 +1,38 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + subsampled_y: True + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index aba1622..2cf1487 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,8 +523,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') -waterbirds_rmsprop = Dataset( - name='waterbirds_rmsprop', +waterbirds_label_balanced = Dataset( + name='waterbirds_label_balanced', val_metric='test_acc/val', secondary_val_metrics=['LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', @@ -534,12 +534,28 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], - config_rel_path='adaptation/waterbirds.yaml', + config_rel_path='adaptation/waterbirds_label_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. - eval_config_rel_path='adaptation/waterbirds_eval.yaml') + eval_config_rel_path='adaptation/waterbirds_label_balanced_eval.yaml') +waterbirds_group_balanced = Dataset( + name='waterbirds_group_balanced', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_group_balanced.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_group_balanced_eval.yaml') waterbirds_background = Dataset( name='waterbirds_background', @@ -792,8 +808,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. - 'waterbirds_rmsprop': waterbirds_rmsprop, 'waterbirds_background': waterbirds_background, + 'waterbirds_group_balanced': waterbirds_group_balanced, + 'waterbirds_label_balanced': waterbirds_label_balanced, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } From 756ee70ee4ed1c0e8913741002e7a28ca61b8d89 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 16 Aug 2022 11:04:08 -0700 Subject: [PATCH 075/197] update --- configs/adaptation/datasets_waterbirds.yaml | 1 - .../adaptation/waterbirds_group_balanced.yaml | 39 +++++++++++++++++++ .../adaptation/waterbirds_label_balanced.yaml | 38 ++++++++++++++++++ scripts/run_adaptation_experiments.py | 27 ++++++++++--- 4 files changed, 99 insertions(+), 6 deletions(-) create mode 100644 configs/adaptation/waterbirds_group_balanced.yaml create mode 100644 configs/adaptation/waterbirds_label_balanced.yaml diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 55e2911..7f73908 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -9,7 +9,6 @@ train_dataset: root: 'wilds/data/' dataset_name: 'waterbirds' split: 'train' - download: 'true' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize args: diff --git a/configs/adaptation/waterbirds_group_balanced.yaml b/configs/adaptation/waterbirds_group_balanced.yaml new file mode 100644 index 0000000..e4192b8 --- /dev/null +++ b/configs/adaptation/waterbirds_group_balanced.yaml @@ -0,0 +1,39 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + subsampled_meta: True + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + diff --git a/configs/adaptation/waterbirds_label_balanced.yaml b/configs/adaptation/waterbirds_label_balanced.yaml new file mode 100644 index 0000000..c31d0ad --- /dev/null +++ b/configs/adaptation/waterbirds_label_balanced.yaml @@ -0,0 +1,38 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + root: 'wilds/data/' + dataset_name: 'waterbirds' + split: 'train' + subsampled_y: True + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: 224 + interpolation: 'bicubic' + - classname: torchvision.transforms.CenterCrop + args: + size: 224 + - classname: torchvision.transforms.ToTensor + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index aba1622..2cf1487 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,8 +523,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') -waterbirds_rmsprop = Dataset( - name='waterbirds_rmsprop', +waterbirds_label_balanced = Dataset( + name='waterbirds_label_balanced', val_metric='test_acc/val', secondary_val_metrics=['LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', @@ -534,12 +534,28 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], - config_rel_path='adaptation/waterbirds.yaml', + config_rel_path='adaptation/waterbirds_label_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. - eval_config_rel_path='adaptation/waterbirds_eval.yaml') + eval_config_rel_path='adaptation/waterbirds_label_balanced_eval.yaml') +waterbirds_group_balanced = Dataset( + name='waterbirds_group_balanced', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_group_balanced.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_group_balanced_eval.yaml') waterbirds_background = Dataset( name='waterbirds_background', @@ -792,8 +808,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. - 'waterbirds_rmsprop': waterbirds_rmsprop, 'waterbirds_background': waterbirds_background, + 'waterbirds_group_balanced': waterbirds_group_balanced, + 'waterbirds_label_balanced': waterbirds_label_balanced, # 'landcover': landcover, # 'landcover_auxin': landcover_auxin, } From 5515b81585043a8a0047861d50efc05a3d84c753 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 18 Aug 2022 18:33:20 -0700 Subject: [PATCH 076/197] Add per step scheduling and gradient clipping. --- configs/adaptation/waterbirds.yaml | 2 +- .../adaptation/waterbirds_clipped_warmup.yaml | 20 ++++++ scripts/run_adaptation_experiments.py | 45 +++++++++++++ unlabeled_extrapolation/baseline_train.py | 46 ++++++++++--- unlabeled_extrapolation/models/vit_model.py | 67 ++++++++++++++++--- 5 files changed, 161 insertions(+), 19 deletions(-) create mode 100644 configs/adaptation/waterbirds_clipped_warmup.yaml diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 430c6a7..7fc66b7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 16 +batch_size: 32 save_no_checkpoints: True model: diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml new file mode 100644 index 0000000..a3d2e01 --- /dev/null +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 32 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +max_grad_norm: 1.0 + +batch_scheduler: + classname: transformers.get_cosine_schedule_with_warmup + args: {} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 2cf1487..c6d40ef 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,23 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_clipped_warmup = Dataset( + name='waterbirds_clipped_warmup', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_clipped_warmup.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_clipped_warmup_eval.yaml') + waterbirds_label_balanced = Dataset( name='waterbirds_label_balanced', val_metric='test_acc/val', @@ -808,6 +825,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_clipped_warmup': waterbirds_clipped_warmup, 'waterbirds_background': waterbirds_background, 'waterbirds_group_balanced': waterbirds_group_balanced, 'waterbirds_label_balanced': waterbirds_label_balanced, @@ -941,6 +959,30 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +deit_vit_b16 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'deit_base_patch16_224', + }, + bundles=[] +) + +timm_vit_b16 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_base_patch16_224', + }, + bundles=[] +) + +timm_vit_b16_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_base_patch16_224_in21k', + }, + bundles=[] +) + bit_resnet_50 = Model( kwargs={ 'classname': 'models.bit_resnet.BitResNet', @@ -977,8 +1019,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'sup_resnet50_norm': sup_resnet50_norm, 'mocotp_fmow_resnet50': mocotp_fmow_resnet50, 'clip_resnet50': clip_resnet50, + 'deit_vit_b16': deit_vit_b16, 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, + 'timm_vit_b16': timm_vit_b16, + 'timm_vit_b16_in21k': timm_vit_b16_in21k, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 0275a97..6c4301d 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -282,7 +282,7 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial): + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None): # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training @@ -338,7 +338,11 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss.backward() # Collect the gradients at each layer. add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) - optimizer.step() + if check_exists_not_none(config, 'max_grad_norm'): + torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) + optimizer.step() + if batch_scheduler is not None: + batch_scheduler.step() num_examples += len(labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -357,6 +361,8 @@ def should_log(log_interval): wandb.log(stats) reset_state(net, training_state) train_stats = {'epoch': epoch} + if batch_scheduler is not None: + train_stats['train/batch_scheduler_lr'] = batch_scheduler.get_lr() for key in loss_dict: train_stats[key] = loss_dict[key].get_mean() return train_stats @@ -387,7 +393,11 @@ def get_params(layers): return params -def check_value_not_none(d, k, v): +def check_exists_not_none(d, k): + return k in d and d[k] != None + + +def check_exists_value(d, k, v): return k in d and d[k] == v @@ -430,9 +440,25 @@ def main(config, log_dir, checkpoints_dir): config['optimizer'], update_args={'params': param_groups}) else: optimizer = utils.initialize( - config['optimizer'], update_args={'params': net.parameters()}) - scheduler = utils.initialize( - config['scheduler'], update_args={'optimizer': optimizer}) + config['optimizer'], update_args={'params': net.parameters()}) + # If batch scheduler is specified, then use a batch scheduler that updates the learning + # rate every step. Otherwise, update the learning rate every epoch. + batch_scheduler = None + scheduler = None + if check_exists_not_none(config, 'batch_scheduler'): + # TODO: add batch scheduler. + num_batches = len(train_loader) + num_training_steps = num_batches * config['epochs'] + num_warmup_steps = int(0.1 * num_training_steps) + batch_scheduler = utils.initialize( + config['batch_scheduler'], update_args={ + 'optimizer': optimizer, + 'num_warmup_steps': num_warmup_steps, + 'num_training_steps': num_training_steps, + }) + else: + scheduler = utils.initialize( + config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. best_stats = {} best_accs = {} # Used to save checkpoints of best models on some datasets. @@ -459,6 +485,7 @@ def main(config, log_dir, checkpoints_dir): if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): cur_ckp_filename = 'ckp_' + str(epoch) + # TODO: update to save batch scheduler if specified? utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, cur_ckp_filename) if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): os.remove(prev_ckp_path) @@ -474,8 +501,11 @@ def main(config, log_dir, checkpoints_dir): # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial) - scheduler.step() + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + # Call scheduler to update learning rate, unless we have a batch scheduler, in which + # case we will update the learning rate every step. + if not check_exists_not_none(config, 'batch_scheduler'): + scheduler.step() # Get test stats across all test sets. test_stats = get_all_test_stats( epoch, test_loaders, max_test_examples, config, net, criterion, device, diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 59508d9..6d50920 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -6,15 +6,22 @@ from torch import nn from . import model_utils +import timm +from timm.models import vision_transformer +from timm.data import resolve_data_config + from torchvision.transforms import Normalize -MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} +MODELS = { + 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', + 'deit_base_patch16_224', +} -normalize_transform = Normalize( +default_imnet_normalize = Normalize( mean=(0.485, 0.456, 0.406), - std=[0.228, 0.224, 0.225]) + std=[0.229, 0.224, 0.225]) def set_requires_grad(component, val): @@ -22,18 +29,37 @@ def set_requires_grad(component, val): param.requires_grad = val +def is_timm_vit_name(model_name): + timm_vit_names = vision_transformer.default_cfgs.keys() + return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names + + +def get_timm_name(model_name): + assert model_name.startswith('timm.') + return model_name[5:] + + class VitModel(nn.Module): def __init__(self, model_name): super().__init__() - if model_name not in MODELS: + if model_name not in MODELS and not(is_timm_vit_name(model_name)): raise ValueError(f'model_name must be in {MODELS} but was {model_name}') self._device = "cuda" if torch.cuda.is_available() else "cpu" # Note that model has both a language and vision part. - model = torch.hub.load('facebookresearch/dino:main', model_name) + if is_timm_vit_name(model_name): + model = timm.create_model(get_timm_name(model_name), pretrained=True) + elif 'dino' in model_name: + model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) + elif 'deit' in model_name: + model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) if self._device == 'cuda': model.cuda() - self._model = model + self._model_name = model_name + if 'deit' in model_name or is_timm_vit_name(model_name): + self._model = nn.Sequential(*list(model.children())[:-1]) + else: + self._model = model self._classifier = None def forward(self, x): @@ -43,9 +69,16 @@ def forward(self, x): return self._classifier(features) def get_layers(self): - patch_embed = self._model.patch_embed + if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + patch_embed = self._model[0] + blocks = self._model[2] + else: + patch_embed = self._model.patch_embed + self._model.blocks layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. - layers += list(self._model.blocks) + layers += list(blocks) + # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring + # for now. layers += [self._classifier] return layers @@ -62,7 +95,10 @@ def set_requires_grad(self, val): param.requires_grad = val def new_last_layer(self, num_classes): - num_in_features = self._model.norm.normalized_shape[0] + if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + num_in_features = self._model[3].normalized_shape[0] + else: + num_in_features = self._model.norm.normalized_shape[0] self._classifier = nn.Linear(num_in_features, num_classes) self._classifier.to(self._device) @@ -79,4 +115,15 @@ def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') def get_features(self, x): - return self._model(normalize_transform(x)) + # The normalize transform for Deit is standard imagenet transform. See: + # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls + # the timm library create_transform, which uses these imagenet defaults. + if is_timm_vit_name(self._model_name): + timm_name = get_timm_name(self._model_name) + config = resolve_data_config({}, model=self._model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + cls_features = self._model(normalize_transform(x))[:,0] + assert(len(cls_features.shape) == 2) + return cls_features + else: + return self._model(default_imnet_transform(x)) From 64980e9d21343a76a2d7b603b4a4d1d7b36b87c9 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 18 Aug 2022 18:33:20 -0700 Subject: [PATCH 077/197] Add per step scheduling and gradient clipping. --- configs/adaptation/waterbirds.yaml | 2 +- .../adaptation/waterbirds_clipped_warmup.yaml | 20 ++++++ scripts/run_adaptation_experiments.py | 45 +++++++++++++ unlabeled_extrapolation/baseline_train.py | 46 ++++++++++--- unlabeled_extrapolation/models/vit_model.py | 67 ++++++++++++++++--- 5 files changed, 161 insertions(+), 19 deletions(-) create mode 100644 configs/adaptation/waterbirds_clipped_warmup.yaml diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 430c6a7..7fc66b7 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -5,7 +5,7 @@ inherit: num_classes: 2 epochs: &epochs 100 -batch_size: 16 +batch_size: 32 save_no_checkpoints: True model: diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml new file mode 100644 index 0000000..a3d2e01 --- /dev/null +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 32 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +max_grad_norm: 1.0 + +batch_scheduler: + classname: transformers.get_cosine_schedule_with_warmup + args: {} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 2cf1487..c6d40ef 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,23 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_clipped_warmup = Dataset( + name='waterbirds_clipped_warmup', + val_metric='test_acc/val', + secondary_val_metrics=['LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_clipped_warmup.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_clipped_warmup_eval.yaml') + waterbirds_label_balanced = Dataset( name='waterbirds_label_balanced', val_metric='test_acc/val', @@ -808,6 +825,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'waterbirds': waterbirds, # This dataset doesn't normalize. 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. + 'waterbirds_clipped_warmup': waterbirds_clipped_warmup, 'waterbirds_background': waterbirds_background, 'waterbirds_group_balanced': waterbirds_group_balanced, 'waterbirds_label_balanced': waterbirds_label_balanced, @@ -941,6 +959,30 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +deit_vit_b16 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'deit_base_patch16_224', + }, + bundles=[] +) + +timm_vit_b16 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_base_patch16_224', + }, + bundles=[] +) + +timm_vit_b16_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_base_patch16_224_in21k', + }, + bundles=[] +) + bit_resnet_50 = Model( kwargs={ 'classname': 'models.bit_resnet.BitResNet', @@ -977,8 +1019,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'sup_resnet50_norm': sup_resnet50_norm, 'mocotp_fmow_resnet50': mocotp_fmow_resnet50, 'clip_resnet50': clip_resnet50, + 'deit_vit_b16': deit_vit_b16, 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, + 'timm_vit_b16': timm_vit_b16, + 'timm_vit_b16_in21k': timm_vit_b16_in21k, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 0275a97..6c4301d 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -282,7 +282,7 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial): + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None): # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training @@ -338,7 +338,11 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss.backward() # Collect the gradients at each layer. add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) - optimizer.step() + if check_exists_not_none(config, 'max_grad_norm'): + torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) + optimizer.step() + if batch_scheduler is not None: + batch_scheduler.step() num_examples += len(labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -357,6 +361,8 @@ def should_log(log_interval): wandb.log(stats) reset_state(net, training_state) train_stats = {'epoch': epoch} + if batch_scheduler is not None: + train_stats['train/batch_scheduler_lr'] = batch_scheduler.get_lr() for key in loss_dict: train_stats[key] = loss_dict[key].get_mean() return train_stats @@ -387,7 +393,11 @@ def get_params(layers): return params -def check_value_not_none(d, k, v): +def check_exists_not_none(d, k): + return k in d and d[k] != None + + +def check_exists_value(d, k, v): return k in d and d[k] == v @@ -430,9 +440,25 @@ def main(config, log_dir, checkpoints_dir): config['optimizer'], update_args={'params': param_groups}) else: optimizer = utils.initialize( - config['optimizer'], update_args={'params': net.parameters()}) - scheduler = utils.initialize( - config['scheduler'], update_args={'optimizer': optimizer}) + config['optimizer'], update_args={'params': net.parameters()}) + # If batch scheduler is specified, then use a batch scheduler that updates the learning + # rate every step. Otherwise, update the learning rate every epoch. + batch_scheduler = None + scheduler = None + if check_exists_not_none(config, 'batch_scheduler'): + # TODO: add batch scheduler. + num_batches = len(train_loader) + num_training_steps = num_batches * config['epochs'] + num_warmup_steps = int(0.1 * num_training_steps) + batch_scheduler = utils.initialize( + config['batch_scheduler'], update_args={ + 'optimizer': optimizer, + 'num_warmup_steps': num_warmup_steps, + 'num_training_steps': num_training_steps, + }) + else: + scheduler = utils.initialize( + config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. best_stats = {} best_accs = {} # Used to save checkpoints of best models on some datasets. @@ -459,6 +485,7 @@ def main(config, log_dir, checkpoints_dir): if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): cur_ckp_filename = 'ckp_' + str(epoch) + # TODO: update to save batch scheduler if specified? utils.save_ckp(epoch, net, optimizer, scheduler, checkpoints_dir, cur_ckp_filename) if (prev_ckp_path is not None and not(config['save_all_checkpoints'])): os.remove(prev_ckp_path) @@ -474,8 +501,11 @@ def main(config, log_dir, checkpoints_dir): # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial) - scheduler.step() + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + # Call scheduler to update learning rate, unless we have a batch scheduler, in which + # case we will update the learning rate every step. + if not check_exists_not_none(config, 'batch_scheduler'): + scheduler.step() # Get test stats across all test sets. test_stats = get_all_test_stats( epoch, test_loaders, max_test_examples, config, net, criterion, device, diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 59508d9..6d50920 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -6,15 +6,22 @@ from torch import nn from . import model_utils +import timm +from timm.models import vision_transformer +from timm.data import resolve_data_config + from torchvision.transforms import Normalize -MODELS = {'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8'} +MODELS = { + 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', + 'deit_base_patch16_224', +} -normalize_transform = Normalize( +default_imnet_normalize = Normalize( mean=(0.485, 0.456, 0.406), - std=[0.228, 0.224, 0.225]) + std=[0.229, 0.224, 0.225]) def set_requires_grad(component, val): @@ -22,18 +29,37 @@ def set_requires_grad(component, val): param.requires_grad = val +def is_timm_vit_name(model_name): + timm_vit_names = vision_transformer.default_cfgs.keys() + return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names + + +def get_timm_name(model_name): + assert model_name.startswith('timm.') + return model_name[5:] + + class VitModel(nn.Module): def __init__(self, model_name): super().__init__() - if model_name not in MODELS: + if model_name not in MODELS and not(is_timm_vit_name(model_name)): raise ValueError(f'model_name must be in {MODELS} but was {model_name}') self._device = "cuda" if torch.cuda.is_available() else "cpu" # Note that model has both a language and vision part. - model = torch.hub.load('facebookresearch/dino:main', model_name) + if is_timm_vit_name(model_name): + model = timm.create_model(get_timm_name(model_name), pretrained=True) + elif 'dino' in model_name: + model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) + elif 'deit' in model_name: + model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) if self._device == 'cuda': model.cuda() - self._model = model + self._model_name = model_name + if 'deit' in model_name or is_timm_vit_name(model_name): + self._model = nn.Sequential(*list(model.children())[:-1]) + else: + self._model = model self._classifier = None def forward(self, x): @@ -43,9 +69,16 @@ def forward(self, x): return self._classifier(features) def get_layers(self): - patch_embed = self._model.patch_embed + if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + patch_embed = self._model[0] + blocks = self._model[2] + else: + patch_embed = self._model.patch_embed + self._model.blocks layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. - layers += list(self._model.blocks) + layers += list(blocks) + # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring + # for now. layers += [self._classifier] return layers @@ -62,7 +95,10 @@ def set_requires_grad(self, val): param.requires_grad = val def new_last_layer(self, num_classes): - num_in_features = self._model.norm.normalized_shape[0] + if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + num_in_features = self._model[3].normalized_shape[0] + else: + num_in_features = self._model.norm.normalized_shape[0] self._classifier = nn.Linear(num_in_features, num_classes) self._classifier.to(self._device) @@ -79,4 +115,15 @@ def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') def get_features(self, x): - return self._model(normalize_transform(x)) + # The normalize transform for Deit is standard imagenet transform. See: + # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls + # the timm library create_transform, which uses these imagenet defaults. + if is_timm_vit_name(self._model_name): + timm_name = get_timm_name(self._model_name) + config = resolve_data_config({}, model=self._model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + cls_features = self._model(normalize_transform(x))[:,0] + assert(len(cls_features.shape) == 2) + return cls_features + else: + return self._model(default_imnet_transform(x)) From 1a53342e59e58652783159bda1614e86a01c35ce Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 19 Aug 2022 17:21:37 -0700 Subject: [PATCH 078/197] Make it easy to summarize results. --- scripts/run_adaptation_experiments.py | 41 ++++++++++++++++++--------- 1 file changed, 28 insertions(+), 13 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index c6d40ef..0223240 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -509,10 +509,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds = Dataset( name='waterbirds', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -526,10 +526,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -546,7 +546,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): secondary_val_metrics=['LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -560,10 +560,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_group_balanced = Dataset( name='waterbirds_group_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -578,10 +578,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -595,10 +595,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -612,10 +612,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -1470,6 +1470,20 @@ def spray_domainnet_jags(args): subprocess.run(shlex.split(cmd)) +def summarize_dataset(args): + assert len(args.datasets) == 1 + dataset = names_to_datasets[args.datasets[0]] + cmd = 'python scripts/summarize_all_results.py ' + cmd += '--results_dir_glob=logs/*' + dataset.name + '* ' + cmd += '--val_metrics ' + dataset.val_metric + ' ' + cmd += ' '.join(dataset.secondary_val_metrics) + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' + cmd += '--output_file=tmp.tsv' + print(cmd) + if not args.print_command: + os.system(cmd) + + def main(args): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, @@ -1499,6 +1513,7 @@ def main(args): 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, 'ft_imnet_lp_ft_phase_2_val_mode_experiments': ft_imnet_lp_ft_phase_2_val_mode_experiments, 'fine_tuning_mixup_sweep_experiments': fine_tuning_mixup_sweep_experiments, + 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: experiment_to_fns[args.experiment](args) From c72c1725e160b041adec38a7ac869555e844212c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 19 Aug 2022 17:21:37 -0700 Subject: [PATCH 079/197] Make it easy to summarize results. --- scripts/run_adaptation_experiments.py | 41 ++++++++++++++++++--------- 1 file changed, 28 insertions(+), 13 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index c6d40ef..0223240 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -509,10 +509,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds = Dataset( name='waterbirds', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -526,10 +526,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -546,7 +546,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): secondary_val_metrics=['LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -560,10 +560,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_group_balanced = Dataset( name='waterbirds_group_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -578,10 +578,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -595,10 +595,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -612,10 +612,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -1470,6 +1470,20 @@ def spray_domainnet_jags(args): subprocess.run(shlex.split(cmd)) +def summarize_dataset(args): + assert len(args.datasets) == 1 + dataset = names_to_datasets[args.datasets[0]] + cmd = 'python scripts/summarize_all_results.py ' + cmd += '--results_dir_glob=logs/*' + dataset.name + '* ' + cmd += '--val_metrics ' + dataset.val_metric + ' ' + cmd += ' '.join(dataset.secondary_val_metrics) + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' + cmd += '--output_file=tmp.tsv' + print(cmd) + if not args.print_command: + os.system(cmd) + + def main(args): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, @@ -1499,6 +1513,7 @@ def main(args): 'ft_imnet_lp_ft_phase_2_experiments': ft_imnet_lp_ft_phase_2_experiments, 'ft_imnet_lp_ft_phase_2_val_mode_experiments': ft_imnet_lp_ft_phase_2_val_mode_experiments, 'fine_tuning_mixup_sweep_experiments': fine_tuning_mixup_sweep_experiments, + 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: experiment_to_fns[args.experiment](args) From 79d3efbec8c7baa72344a30808106320d4f7252a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 19 Aug 2022 17:21:48 -0700 Subject: [PATCH 080/197] Add linear warmup and gradient clipping. --- .../adaptation/waterbirds_clipped_warmup.yaml | 3 +- unlabeled_extrapolation/models/vit_model.py | 49 ++++++++++++------- unlabeled_extrapolation/utils/schedulers.py | 20 ++++++++ 3 files changed, 54 insertions(+), 18 deletions(-) create mode 100644 unlabeled_extrapolation/utils/schedulers.py diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index a3d2e01..fc3047f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -16,5 +16,6 @@ model: max_grad_norm: 1.0 batch_scheduler: - classname: transformers.get_cosine_schedule_with_warmup + classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} + diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 6d50920..187d57d 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -39,47 +39,57 @@ def get_timm_name(model_name): return model_name[5:] +def get_timm_transform(model_name): + timm_name = get_timm_name(model_name) + config = resolve_data_config({}, model=model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + class VitModel(nn.Module): def __init__(self, model_name): super().__init__() if model_name not in MODELS and not(is_timm_vit_name(model_name)): raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._model_name = model_name self._device = "cuda" if torch.cuda.is_available() else "cpu" # Note that model has both a language and vision part. if is_timm_vit_name(model_name): model = timm.create_model(get_timm_name(model_name), pretrained=True) + self._normalize_transform = get_timm_transform(model_name) elif 'dino' in model_name: model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) elif 'deit' in model_name: model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) if self._device == 'cuda': model.cuda() - self._model_name = model_name - if 'deit' in model_name or is_timm_vit_name(model_name): + if 'deit' in model_name: self._model = nn.Sequential(*list(model.children())[:-1]) else: self._model = model self._classifier = None def forward(self, x): + if is_timm_vit_name(self._model_name): + return self._model(self._normalize_transform(x)) features = self.get_features(x) if self._classifier is None: return features return self._classifier(features) def get_layers(self): - if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + if 'deit' in self._model_name: patch_embed = self._model[0] blocks = self._model[2] else: patch_embed = self._model.patch_embed - self._model.blocks + blocks = self._model.blocks layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. layers += list(blocks) # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring # for now. - layers += [self._classifier] + layers += [self.get_last_layer()] return layers def freeze_bottom_k(self, k): @@ -95,21 +105,31 @@ def set_requires_grad(self, val): param.requires_grad = val def new_last_layer(self, num_classes): - if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + if 'deit' in self._model_name: num_in_features = self._model[3].normalized_shape[0] else: num_in_features = self._model.norm.normalized_shape[0] - self._classifier = nn.Linear(num_in_features, num_classes) - self._classifier.to(self._device) + if is_timm_vit_name(self._model_name): + self._model.head = nn.Linear(num_in_features, num_classes) + self._model.head.to(self._device) + else: + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) def add_probe(self, probe): - self._classifier = probe + if is_timm_vit_name(self._model_name): + self._model.head = probe + else: + self._classifier = probe def get_last_layer(self): - return self._classifier + if is_timm_vit_name(self._model_name): + return self._model.head + else: + return self._classifier def set_last_layer(self, coef, intercept): - model_utils.set_linear_layer(self._classifier, coef, intercept) + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') @@ -119,11 +139,6 @@ def get_features(self, x): # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls # the timm library create_transform, which uses these imagenet defaults. if is_timm_vit_name(self._model_name): - timm_name = get_timm_name(self._model_name) - config = resolve_data_config({}, model=self._model_name) - normalize_transform = Normalize(mean=config['mean'], std=config['std']) - cls_features = self._model(normalize_transform(x))[:,0] - assert(len(cls_features.shape) == 2) - return cls_features + raise NotImplementedError('Need to implement this for timm models.') else: return self._model(default_imnet_transform(x)) diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py new file mode 100644 index 0000000..e31d09b --- /dev/null +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -0,0 +1,20 @@ + +from torch.optim.lr_scheduler import LambdaLR +import math + +# Code adapter from Hugging Face transformers implementation. + +class CosineScheduleWithWarmup(LambdaLR): + """Linear warm up and then cosine annealing of the learning rate.""" + def __init__(self, optimizer, num_warmup_steps, num_training_steps, num_cycles=0.5, last_epoch=-1): + self.num_warmup_steps = num_warmup_steps + self.num_training_steps = num_training_steps + self.num_cycles = num_cycles + super(CosineScheduleWithWarmup, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) + + def lr_lambda(self, current_step): + if current_step < self.num_warmup_steps: + return float(current_step) / float(max(1, self.num_warmup_steps)) + progress = float(current_step - self.num_warmup_steps) / float(max(1, self.num_training_steps - self.num_warmup_steps)) + return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + From b2f432da387c60a2e9687bd8ff937c6963f1cdda Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 19 Aug 2022 17:21:48 -0700 Subject: [PATCH 081/197] Add linear warmup and gradient clipping. --- .../adaptation/waterbirds_clipped_warmup.yaml | 3 +- unlabeled_extrapolation/models/vit_model.py | 49 ++++++++++++------- unlabeled_extrapolation/utils/schedulers.py | 20 ++++++++ 3 files changed, 54 insertions(+), 18 deletions(-) create mode 100644 unlabeled_extrapolation/utils/schedulers.py diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index a3d2e01..fc3047f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -16,5 +16,6 @@ model: max_grad_norm: 1.0 batch_scheduler: - classname: transformers.get_cosine_schedule_with_warmup + classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} + diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 6d50920..187d57d 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -39,47 +39,57 @@ def get_timm_name(model_name): return model_name[5:] +def get_timm_transform(model_name): + timm_name = get_timm_name(model_name) + config = resolve_data_config({}, model=model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + class VitModel(nn.Module): def __init__(self, model_name): super().__init__() if model_name not in MODELS and not(is_timm_vit_name(model_name)): raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._model_name = model_name self._device = "cuda" if torch.cuda.is_available() else "cpu" # Note that model has both a language and vision part. if is_timm_vit_name(model_name): model = timm.create_model(get_timm_name(model_name), pretrained=True) + self._normalize_transform = get_timm_transform(model_name) elif 'dino' in model_name: model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) elif 'deit' in model_name: model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) if self._device == 'cuda': model.cuda() - self._model_name = model_name - if 'deit' in model_name or is_timm_vit_name(model_name): + if 'deit' in model_name: self._model = nn.Sequential(*list(model.children())[:-1]) else: self._model = model self._classifier = None def forward(self, x): + if is_timm_vit_name(self._model_name): + return self._model(self._normalize_transform(x)) features = self.get_features(x) if self._classifier is None: return features return self._classifier(features) def get_layers(self): - if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + if 'deit' in self._model_name: patch_embed = self._model[0] blocks = self._model[2] else: patch_embed = self._model.patch_embed - self._model.blocks + blocks = self._model.blocks layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. layers += list(blocks) # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring # for now. - layers += [self._classifier] + layers += [self.get_last_layer()] return layers def freeze_bottom_k(self, k): @@ -95,21 +105,31 @@ def set_requires_grad(self, val): param.requires_grad = val def new_last_layer(self, num_classes): - if 'deit' in self._model_name or is_timm_vit_name(self._model_name): + if 'deit' in self._model_name: num_in_features = self._model[3].normalized_shape[0] else: num_in_features = self._model.norm.normalized_shape[0] - self._classifier = nn.Linear(num_in_features, num_classes) - self._classifier.to(self._device) + if is_timm_vit_name(self._model_name): + self._model.head = nn.Linear(num_in_features, num_classes) + self._model.head.to(self._device) + else: + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) def add_probe(self, probe): - self._classifier = probe + if is_timm_vit_name(self._model_name): + self._model.head = probe + else: + self._classifier = probe def get_last_layer(self): - return self._classifier + if is_timm_vit_name(self._model_name): + return self._model.head + else: + return self._classifier def set_last_layer(self, coef, intercept): - model_utils.set_linear_layer(self._classifier, coef, intercept) + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) def get_feature_extractor(self): raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') @@ -119,11 +139,6 @@ def get_features(self, x): # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls # the timm library create_transform, which uses these imagenet defaults. if is_timm_vit_name(self._model_name): - timm_name = get_timm_name(self._model_name) - config = resolve_data_config({}, model=self._model_name) - normalize_transform = Normalize(mean=config['mean'], std=config['std']) - cls_features = self._model(normalize_transform(x))[:,0] - assert(len(cls_features.shape) == 2) - return cls_features + raise NotImplementedError('Need to implement this for timm models.') else: return self._model(default_imnet_transform(x)) diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py new file mode 100644 index 0000000..e31d09b --- /dev/null +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -0,0 +1,20 @@ + +from torch.optim.lr_scheduler import LambdaLR +import math + +# Code adapter from Hugging Face transformers implementation. + +class CosineScheduleWithWarmup(LambdaLR): + """Linear warm up and then cosine annealing of the learning rate.""" + def __init__(self, optimizer, num_warmup_steps, num_training_steps, num_cycles=0.5, last_epoch=-1): + self.num_warmup_steps = num_warmup_steps + self.num_training_steps = num_training_steps + self.num_cycles = num_cycles + super(CosineScheduleWithWarmup, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) + + def lr_lambda(self, current_step): + if current_step < self.num_warmup_steps: + return float(current_step) / float(max(1, self.num_warmup_steps)) + progress = float(current_step - self.num_warmup_steps) / float(max(1, self.num_training_steps - self.num_warmup_steps)) + return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + From a913346467e888d73e93f7101c73d3c216a54e86 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 22 Aug 2022 13:58:01 -0700 Subject: [PATCH 082/197] Implement gradient accumulation. --- .../adaptation/waterbirds_large_batch.yaml | 20 +++++ scripts/run_adaptation_experiments.py | 19 +++++ unlabeled_extrapolation/baseline_train.py | 77 +++++++++++-------- 3 files changed, 85 insertions(+), 31 deletions(-) create mode 100644 configs/adaptation/waterbirds_large_batch.yaml diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml new file mode 100644 index 0000000..0f2bf4e --- /dev/null +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 512 +batch_splits: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 0223240..742c7d7 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_large_batch = Dataset( + name='waterbirds_large_batch', + val_metric='test_acc/val', + secondary_val_metrics=['LAST', 'WORST',], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_large_batch.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_large_batch_eval.yaml') + + waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', @@ -823,6 +841,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. + 'waterbirds_large_batch': waterbirds_large_batch, 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. 'waterbirds_clipped_warmup': waterbirds_clipped_warmup, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 6c4301d..3321404 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -81,8 +81,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na correct = (predicted == labels.detach().cpu().numpy()) val_acc.add_values(correct.tolist()) loss = criterion(outputs, labels).cpu() - loss_list = loss.tolist() - val_loss.add_value(loss_list) + val_loss.add_value(float(loss.detach().cpu()) / len(images)) num_examples += len(images) if num_examples >= max_examples: logging.info("Breaking after %d examples.", num_examples) @@ -286,6 +285,10 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training + if 'use_net_val_mode' in config and config['use_net_val_mode']: + net.eval() + else: + net.train() logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), @@ -304,49 +307,61 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ mixup = Mixup(num_classes=config['num_classes'], mixup_alpha=config['mixup_alpha']) else: mixup = Mixup(num_classes=config['num_classes']) + # Should we split each batch into multiple parts so we don't run out of GPU memory. + batch_splits = 1 + if check_exists_not_none(config, 'batch_splits'): + batch_splits = config['batch_splits'] for i, data in enumerate(train_loader, 0): - if 'use_net_val_mode' in config and config['use_net_val_mode']: - net.eval() - else: - net.train() - # get the inputs; data is a list of [inputs, labels] - if config['use_cuda']: - data = utils.to_device(data, device) - inputs, labels = data - if 'use_mixup' in config and config['use_mixup']: - inputs, labels = mixup(inputs, labels) optimizer.zero_grad() - outputs = net(inputs) - loss = criterion(outputs, labels) + all_inputs, all_labels = data + if 'use_mixup' in config and config['use_mixup']: + all_inputs, all_labels = mixup(all_inputs, all_labels) if 'l2sp_weight' in config: weight_dict, _ = get_param_weights_counts(net, detach=False) l2sp_loss = config['l2sp_weight'] * get_l2_dist(weight_dict_initial, weight_dict) loss_dict['train/l2sp_loss'].add_value(l2sp_loss.tolist()) - loss += l2sp_loss - _, train_preds = torch.max(outputs.data, axis=1) - loss_dict['train/loss'].add_value(loss.tolist()) - if 'use_mixup' in config and config['use_mixup']: - _, max_labels = torch.max(labels.data, axis=1) - loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) - else: - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) - if 'model_loss' in config: - opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() - loss_dict['train/model_loss'].add_value(opt_loss.tolist()) - else: - loss.backward() + l2sp_loss.backward() + del l2sp_loss + # Split up the batch so we can do the backward pass on a GPU, accumulate gradients + # across the split. + split_inputs = torch.split( + all_inputs, split_size_or_sections=len(all_inputs) // batch_splits) + split_labels = torch.split( + all_labels, split_size_or_sections=len(all_labels) // batch_splits) + for j in range(batch_splits): + inputs, labels = split_inputs[j], split_labels[j] + if config['use_cuda']: + inputs, labels = inputs.to(device), labels.to(device) + outputs = net(inputs) + loss = criterion(outputs, labels) + _, train_preds = torch.max(outputs.data, axis=1) + assert len(loss.shape) == 0 + loss_dict['train/loss'].add_value(float(loss.detach().cpu()) / len(inputs)) + if 'use_mixup' in config and config['use_mixup']: + _, max_labels = torch.max(labels.data, axis=1) + loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) + else: + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + if 'model_loss' in config: + opt_loss = model_loss(net, inputs, labels) + opt_loss.backward() + assert len(opt_loss.shape) == 0 + loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) + del opt_loss + else: + loss.backward() + del inputs, labels, loss # Collect the gradients at each layer. - add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) + add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) if check_exists_not_none(config, 'max_grad_norm'): torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) optimizer.step() if batch_scheduler is not None: batch_scheduler.step() - num_examples += len(labels) + num_examples += len(all_labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): - return num_examples // log_interval > (num_examples - len(labels)) // log_interval + return num_examples // log_interval > (num_examples - len(all_labels)) // log_interval if should_log(config['log_interval']): for k in loss_dict: logging.info( From 143abfea13174c7f9fafcb649c8202cf4646338c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 22 Aug 2022 13:58:01 -0700 Subject: [PATCH 083/197] Implement gradient accumulation. --- .../adaptation/waterbirds_large_batch.yaml | 20 +++++ scripts/run_adaptation_experiments.py | 19 +++++ unlabeled_extrapolation/baseline_train.py | 77 +++++++++++-------- 3 files changed, 85 insertions(+), 31 deletions(-) create mode 100644 configs/adaptation/waterbirds_large_batch.yaml diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml new file mode 100644 index 0000000..0f2bf4e --- /dev/null +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -0,0 +1,20 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_waterbirds.yaml + +num_classes: 2 +epochs: &epochs 100 +batch_size: 512 +batch_splits: 16 +save_no_checkpoints: True + +model: + classname: models.clip_model.ClipModel + args: + model_name: 'ViT-B/16' + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 0223240..742c7d7 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -523,6 +523,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') +waterbirds_large_batch = Dataset( + name='waterbirds_large_batch', + val_metric='test_acc/val', + secondary_val_metrics=['LAST', 'WORST',], + output_metrics=['epoch', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', + 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test'], + config_rel_path='adaptation/waterbirds_large_batch.yaml', + bundles=['waterbirds_pickle'], + slurm_data_cmd=None, + slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + eval_config_rel_path='adaptation/waterbirds_large_batch_eval.yaml') + + waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', @@ -823,6 +841,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. + 'waterbirds_large_batch': waterbirds_large_batch, 'waterbirds_augs': waterbirds_augs, # This dataset doesn't normalize. 'waterbirds_norm': waterbirds_norm, # This dataset normalizes. 'waterbirds_clipped_warmup': waterbirds_clipped_warmup, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 6c4301d..3321404 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -81,8 +81,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na correct = (predicted == labels.detach().cpu().numpy()) val_acc.add_values(correct.tolist()) loss = criterion(outputs, labels).cpu() - loss_list = loss.tolist() - val_loss.add_value(loss_list) + val_loss.add_value(float(loss.detach().cpu()) / len(images)) num_examples += len(images) if num_examples >= max_examples: logging.info("Breaking after %d examples.", num_examples) @@ -286,6 +285,10 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training + if 'use_net_val_mode' in config and config['use_net_val_mode']: + net.eval() + else: + net.train() logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), @@ -304,49 +307,61 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ mixup = Mixup(num_classes=config['num_classes'], mixup_alpha=config['mixup_alpha']) else: mixup = Mixup(num_classes=config['num_classes']) + # Should we split each batch into multiple parts so we don't run out of GPU memory. + batch_splits = 1 + if check_exists_not_none(config, 'batch_splits'): + batch_splits = config['batch_splits'] for i, data in enumerate(train_loader, 0): - if 'use_net_val_mode' in config and config['use_net_val_mode']: - net.eval() - else: - net.train() - # get the inputs; data is a list of [inputs, labels] - if config['use_cuda']: - data = utils.to_device(data, device) - inputs, labels = data - if 'use_mixup' in config and config['use_mixup']: - inputs, labels = mixup(inputs, labels) optimizer.zero_grad() - outputs = net(inputs) - loss = criterion(outputs, labels) + all_inputs, all_labels = data + if 'use_mixup' in config and config['use_mixup']: + all_inputs, all_labels = mixup(all_inputs, all_labels) if 'l2sp_weight' in config: weight_dict, _ = get_param_weights_counts(net, detach=False) l2sp_loss = config['l2sp_weight'] * get_l2_dist(weight_dict_initial, weight_dict) loss_dict['train/l2sp_loss'].add_value(l2sp_loss.tolist()) - loss += l2sp_loss - _, train_preds = torch.max(outputs.data, axis=1) - loss_dict['train/loss'].add_value(loss.tolist()) - if 'use_mixup' in config and config['use_mixup']: - _, max_labels = torch.max(labels.data, axis=1) - loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) - else: - loss_dict['train/acc'].add_values((train_preds == labels).tolist()) - if 'model_loss' in config: - opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() - loss_dict['train/model_loss'].add_value(opt_loss.tolist()) - else: - loss.backward() + l2sp_loss.backward() + del l2sp_loss + # Split up the batch so we can do the backward pass on a GPU, accumulate gradients + # across the split. + split_inputs = torch.split( + all_inputs, split_size_or_sections=len(all_inputs) // batch_splits) + split_labels = torch.split( + all_labels, split_size_or_sections=len(all_labels) // batch_splits) + for j in range(batch_splits): + inputs, labels = split_inputs[j], split_labels[j] + if config['use_cuda']: + inputs, labels = inputs.to(device), labels.to(device) + outputs = net(inputs) + loss = criterion(outputs, labels) + _, train_preds = torch.max(outputs.data, axis=1) + assert len(loss.shape) == 0 + loss_dict['train/loss'].add_value(float(loss.detach().cpu()) / len(inputs)) + if 'use_mixup' in config and config['use_mixup']: + _, max_labels = torch.max(labels.data, axis=1) + loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) + else: + loss_dict['train/acc'].add_values((train_preds == labels).tolist()) + if 'model_loss' in config: + opt_loss = model_loss(net, inputs, labels) + opt_loss.backward() + assert len(opt_loss.shape) == 0 + loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) + del opt_loss + else: + loss.backward() + del inputs, labels, loss # Collect the gradients at each layer. - add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(labels)) + add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) if check_exists_not_none(config, 'max_grad_norm'): torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) optimizer.step() if batch_scheduler is not None: batch_scheduler.step() - num_examples += len(labels) + num_examples += len(all_labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): - return num_examples // log_interval > (num_examples - len(labels)) // log_interval + return num_examples // log_interval > (num_examples - len(all_labels)) // log_interval if should_log(config['log_interval']): for k in loss_dict: logging.info( From 52187d2abf029c109f3812dc53e6150a7f5417a0 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Aug 2022 16:00:32 -0700 Subject: [PATCH 084/197] fix loss computation issue, add warmup_frac option. --- configs/adaptation/waterbirds_clipped_warmup.yaml | 2 ++ configs/adaptation/waterbirds_large_batch.yaml | 12 +++++++----- scripts/run_adaptation_experiments.py | 2 +- scripts/run_sbatch.sh | 2 +- 4 files changed, 11 insertions(+), 7 deletions(-) diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index fc3047f..7c1c25f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -15,6 +15,8 @@ model: max_grad_norm: 1.0 +warmup_frac: 0.25 + batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 0f2bf4e..4f8c285 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -6,7 +6,7 @@ inherit: num_classes: 2 epochs: &epochs 100 batch_size: 512 -batch_splits: 16 +batch_splits: 32 save_no_checkpoints: True model: @@ -14,7 +14,9 @@ model: args: model_name: 'ViT-B/16' -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs +max_grad_norm: 1.0 + +batch_scheduler: + classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup + args: {} + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 742c7d7..f070e2a 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1220,7 +1220,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): - hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) elif 1e-3 in sweep_lrs: # 1e-3 is a good default value for fine-tuning (with SGD). hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 13211ed..e657813 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --partition=jag-standard #SBATCH --mem=16G -#SBATCH --exclude=jagupard[14,15,18] +#SBATCH --exclude=jagupard[13,14,15,17,18] # #SBATCH --exclude=jagupard[14,17,18,20] # Print execute commands in the log. From c322dd7820884d5a6dca243ebd554184c637330c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Aug 2022 16:00:32 -0700 Subject: [PATCH 085/197] fix loss computation issue, add warmup_frac option. --- configs/adaptation/waterbirds_clipped_warmup.yaml | 2 ++ configs/adaptation/waterbirds_large_batch.yaml | 12 +++++++----- scripts/run_adaptation_experiments.py | 2 +- scripts/run_sbatch.sh | 2 +- 4 files changed, 11 insertions(+), 7 deletions(-) diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index fc3047f..7c1c25f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -15,6 +15,8 @@ model: max_grad_norm: 1.0 +warmup_frac: 0.25 + batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 0f2bf4e..4f8c285 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -6,7 +6,7 @@ inherit: num_classes: 2 epochs: &epochs 100 batch_size: 512 -batch_splits: 16 +batch_splits: 32 save_no_checkpoints: True model: @@ -14,7 +14,9 @@ model: args: model_name: 'ViT-B/16' -scheduler: - classname: torch.optim.lr_scheduler.CosineAnnealingLR - args: - T_max: *epochs +max_grad_norm: 1.0 + +batch_scheduler: + classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup + args: {} + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 742c7d7..f070e2a 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1220,7 +1220,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): - hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) + hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) elif 1e-3 in sweep_lrs: # 1e-3 is a good default value for fine-tuning (with SGD). hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 13211ed..e657813 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --partition=jag-standard #SBATCH --mem=16G -#SBATCH --exclude=jagupard[14,15,18] +#SBATCH --exclude=jagupard[13,14,15,17,18] # #SBATCH --exclude=jagupard[14,17,18,20] # Print execute commands in the log. From bb6bce7d53801a527e0d94f97de83fdc5d621878 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Aug 2022 16:01:26 -0700 Subject: [PATCH 086/197] log warmup steps --- unlabeled_extrapolation/baseline_train.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 3321404..35b55ae 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -81,7 +81,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na correct = (predicted == labels.detach().cpu().numpy()) val_acc.add_values(correct.tolist()) loss = criterion(outputs, labels).cpu() - val_loss.add_value(float(loss.detach().cpu()) / len(images)) + val_loss.add_values([float(loss.detach().cpu())] * len(images)) num_examples += len(images) if num_examples >= max_examples: logging.info("Breaking after %d examples.", num_examples) @@ -334,9 +334,13 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ inputs, labels = inputs.to(device), labels.to(device) outputs = net(inputs) loss = criterion(outputs, labels) + # Important: nede to adjust the loss. This assumes the reduction operation is + # mean. + if config["criterion"]["args"]["reduction"] != 'sum': + loss = loss * len(inputs) / len(all_inputs) _, train_preds = torch.max(outputs.data, axis=1) assert len(loss.shape) == 0 - loss_dict['train/loss'].add_value(float(loss.detach().cpu()) / len(inputs)) + loss_dict['train/loss'].add_values([float(loss.detach().cpu())] * len(inputs)) if 'use_mixup' in config and config['use_mixup']: _, max_labels = torch.max(labels.data, axis=1) loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) @@ -464,7 +468,11 @@ def main(config, log_dir, checkpoints_dir): # TODO: add batch scheduler. num_batches = len(train_loader) num_training_steps = num_batches * config['epochs'] - num_warmup_steps = int(0.1 * num_training_steps) + if check_exists_not_none(config, 'warmup_frac'): + num_warmup_steps = int(config['warmup_frac'] * num_training_steps) + else: + num_warmup_steps = int(0.1 * num_training_steps) + logging.info("Warming up for %d steps", num_warmup_steps) batch_scheduler = utils.initialize( config['batch_scheduler'], update_args={ 'optimizer': optimizer, From 216a0d3ff9baa0c8998156ad2009d8d1bc076447 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 23 Aug 2022 16:01:26 -0700 Subject: [PATCH 087/197] log warmup steps --- unlabeled_extrapolation/baseline_train.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 3321404..35b55ae 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -81,7 +81,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na correct = (predicted == labels.detach().cpu().numpy()) val_acc.add_values(correct.tolist()) loss = criterion(outputs, labels).cpu() - val_loss.add_value(float(loss.detach().cpu()) / len(images)) + val_loss.add_values([float(loss.detach().cpu())] * len(images)) num_examples += len(images) if num_examples >= max_examples: logging.info("Breaking after %d examples.", num_examples) @@ -334,9 +334,13 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ inputs, labels = inputs.to(device), labels.to(device) outputs = net(inputs) loss = criterion(outputs, labels) + # Important: nede to adjust the loss. This assumes the reduction operation is + # mean. + if config["criterion"]["args"]["reduction"] != 'sum': + loss = loss * len(inputs) / len(all_inputs) _, train_preds = torch.max(outputs.data, axis=1) assert len(loss.shape) == 0 - loss_dict['train/loss'].add_value(float(loss.detach().cpu()) / len(inputs)) + loss_dict['train/loss'].add_values([float(loss.detach().cpu())] * len(inputs)) if 'use_mixup' in config and config['use_mixup']: _, max_labels = torch.max(labels.data, axis=1) loss_dict['train/acc'].add_values((train_preds == max_labels).tolist()) @@ -464,7 +468,11 @@ def main(config, log_dir, checkpoints_dir): # TODO: add batch scheduler. num_batches = len(train_loader) num_training_steps = num_batches * config['epochs'] - num_warmup_steps = int(0.1 * num_training_steps) + if check_exists_not_none(config, 'warmup_frac'): + num_warmup_steps = int(config['warmup_frac'] * num_training_steps) + else: + num_warmup_steps = int(0.1 * num_training_steps) + logging.info("Warming up for %d steps", num_warmup_steps) batch_scheduler = utils.initialize( config['batch_scheduler'], update_args={ 'optimizer': optimizer, From e16e29a18fc879302042573ea6bbd8a01cd236d1 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Aug 2022 11:09:08 -0700 Subject: [PATCH 088/197] Fine-grained layers --- .../adaptation/waterbirds_large_batch.yaml | 5 +-- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/baseline_train.py | 31 +++++++++++++------ unlabeled_extrapolation/models/clip_model.py | 20 ++++++++++-- unlabeled_extrapolation/models/model_utils.py | 5 +++ unlabeled_extrapolation/models/vit_model.py | 31 +++++++++++++++---- 6 files changed, 73 insertions(+), 21 deletions(-) diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 4f8c285..998177f 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -4,9 +4,9 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 100 +epochs: &epochs 200 batch_size: 512 -batch_splits: 32 +batch_splits: 16 save_no_checkpoints: True model: @@ -15,6 +15,7 @@ model: model_name: 'ViT-B/16' max_grad_norm: 1.0 +warmup_frac: 0.25 batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index f070e2a..b747b72 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1184,7 +1184,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn else: sweep_lrs = [0.0001, 0.0003, 0.001] if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 35b55ae..0e0aa65 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -264,20 +264,33 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): return layers = net.get_layers() for i in range(len(layers)): - cur_layer = list(layers[i].parameters()) - if not cur_layer[0].requires_grad: + if len(layers[i]) == 1: + # In the older version of model code, we just return a list of layers without names. + layer_name = 'train/grad_layer_' + str(i) + normalized_layer_name = 'train/normalized_grad_layer_' + str(i) + cur_layer = list(layers[i].parameters()) + else: + # In newer version of model code, we have a (name, layer) tuple. + layer_name = 'train/grad_' + layers[i][0] + normalized_layer_name = 'train/normalized_grad_' + layers[i][0] + cur_layer = list(layers[i][1].parameters()) + if len(cur_layer) == 0 or not cur_layer[0].requires_grad: continue - if _grad_layer_name + str(i) not in loss_dict: - loss_dict[_grad_layer_name + str(i)] = Accumulator() - if _normalized_grad_layer_name + str(i) not in loss_dict: - loss_dict[_normalized_grad_layer_name + str(i)] = Accumulator() + if layer_name not in loss_dict: + loss_dict[layer_name] = Accumulator() + if normalized_layer_name not in loss_dict: + loss_dict[normalized_layer_name] = Accumulator() grads = [p.grad.detach().cpu().numpy() for p in cur_layer] grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size - loss_dict[_grad_layer_name + str(i)].add_value(grad_norm) + loss_dict[layer_name].add_value(grad_norm) num_params = np.sum([p.numel() for p in cur_layer]) - normalized_grad_norm = grad_norm / np.sqrt(num_params) - loss_dict[_normalized_grad_layer_name + str(i)].add_value(normalized_grad_norm) + if num_params == 0: + assert np.isclose(grad_norm, 0.0) + normalized_grad_norm = grad_norm + else: + normalized_grad_norm = grad_norm / np.sqrt(num_params) + loss_dict[normalized_layer_name].add_value(normalized_grad_norm) def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index a1a1513..8dc9e8d 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -103,9 +103,23 @@ def get_layers(self): visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - layers = ([visual.conv1, visual.ln_pre] + - list(visual.transformer.resblocks) + - [visual.ln_post]) + layers = [ + ('patch_embed', visual.conv1), + ('ln_pre', visual.ln_pre), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(visual.positional_embedding)), + ('cls_token', model_utils.ParamWrapperModule(visual.class_embedding)), + ] + blocks = visual.transformer.resblocks + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn_qkv', block.attn.qkv), + ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', visual.ln_post)] + layers += [('head', self.get_last_layer())] elif self._model_name in {'RN50'}: layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, visual.conv3, visual.bn3, visual.layer1, visual.layer2, diff --git a/unlabeled_extrapolation/models/model_utils.py b/unlabeled_extrapolation/models/model_utils.py index c063e4f..e491c36 100644 --- a/unlabeled_extrapolation/models/model_utils.py +++ b/unlabeled_extrapolation/models/model_utils.py @@ -2,6 +2,11 @@ import torch import torch.nn +class ParamWrapperModule(torch.nn.Module): + def __init__(self, param): + super().__init__() + self._param = param + def set_linear_layer(layer, coef, intercept): coef_tensor = torch.tensor(coef, dtype=layer.weight.dtype).cuda() bias_tensor = torch.tensor(intercept, dtype=layer.bias.dtype).cuda() diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 187d57d..e6f8006 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -65,6 +65,9 @@ def __init__(self, model_name): if self._device == 'cuda': model.cuda() if 'deit' in model_name: + # deit implementation is not complete, doesn't seem to load properly, and also + # get_layers likely isn't handled correctly. + raise NotImplementedError self._model = nn.Sequential(*list(model.children())[:-1]) else: self._model = model @@ -83,17 +86,33 @@ def get_layers(self): patch_embed = self._model[0] blocks = self._model[2] else: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token patch_embed = self._model.patch_embed blocks = self._model.blocks - layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. - layers += list(blocks) - # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring - # for now. - layers += [self.get_last_layer()] + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn_qkv', block.attn.qkv), + ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + if 'dino' not in self._model_name: + layers += [('post_norm', self._model.norm)] + else: + layers += [('empty_post_norm', nn.Module())] + layers += [('head', self.get_last_layer())] return layers def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [layer for name, layer in self.get_layers()] for i in range(min(k, len(layers))): set_requires_grad(layers[i], False) From e216a35d6731fdb01a55b8add5f4a4f4a54470cd Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Aug 2022 11:09:08 -0700 Subject: [PATCH 089/197] Fine-grained layers --- .../adaptation/waterbirds_large_batch.yaml | 5 +-- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/baseline_train.py | 31 +++++++++++++------ unlabeled_extrapolation/models/clip_model.py | 20 ++++++++++-- unlabeled_extrapolation/models/model_utils.py | 5 +++ unlabeled_extrapolation/models/vit_model.py | 31 +++++++++++++++---- 6 files changed, 73 insertions(+), 21 deletions(-) diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 4f8c285..998177f 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -4,9 +4,9 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 100 +epochs: &epochs 200 batch_size: 512 -batch_splits: 32 +batch_splits: 16 save_no_checkpoints: True model: @@ -15,6 +15,7 @@ model: model_name: 'ViT-B/16' max_grad_norm: 1.0 +warmup_frac: 0.25 batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index f070e2a..b747b72 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1184,7 +1184,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn else: sweep_lrs = [0.0001, 0.0003, 0.001] if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 35b55ae..0e0aa65 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -264,20 +264,33 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): return layers = net.get_layers() for i in range(len(layers)): - cur_layer = list(layers[i].parameters()) - if not cur_layer[0].requires_grad: + if len(layers[i]) == 1: + # In the older version of model code, we just return a list of layers without names. + layer_name = 'train/grad_layer_' + str(i) + normalized_layer_name = 'train/normalized_grad_layer_' + str(i) + cur_layer = list(layers[i].parameters()) + else: + # In newer version of model code, we have a (name, layer) tuple. + layer_name = 'train/grad_' + layers[i][0] + normalized_layer_name = 'train/normalized_grad_' + layers[i][0] + cur_layer = list(layers[i][1].parameters()) + if len(cur_layer) == 0 or not cur_layer[0].requires_grad: continue - if _grad_layer_name + str(i) not in loss_dict: - loss_dict[_grad_layer_name + str(i)] = Accumulator() - if _normalized_grad_layer_name + str(i) not in loss_dict: - loss_dict[_normalized_grad_layer_name + str(i)] = Accumulator() + if layer_name not in loss_dict: + loss_dict[layer_name] = Accumulator() + if normalized_layer_name not in loss_dict: + loss_dict[normalized_layer_name] = Accumulator() grads = [p.grad.detach().cpu().numpy() for p in cur_layer] grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size - loss_dict[_grad_layer_name + str(i)].add_value(grad_norm) + loss_dict[layer_name].add_value(grad_norm) num_params = np.sum([p.numel() for p in cur_layer]) - normalized_grad_norm = grad_norm / np.sqrt(num_params) - loss_dict[_normalized_grad_layer_name + str(i)].add_value(normalized_grad_norm) + if num_params == 0: + assert np.isclose(grad_norm, 0.0) + normalized_grad_norm = grad_norm + else: + normalized_grad_norm = grad_norm / np.sqrt(num_params) + loss_dict[normalized_layer_name].add_value(normalized_grad_norm) def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index a1a1513..8dc9e8d 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -103,9 +103,23 @@ def get_layers(self): visual = self._model.visual if self._model_name in {'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'}: - layers = ([visual.conv1, visual.ln_pre] + - list(visual.transformer.resblocks) + - [visual.ln_post]) + layers = [ + ('patch_embed', visual.conv1), + ('ln_pre', visual.ln_pre), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(visual.positional_embedding)), + ('cls_token', model_utils.ParamWrapperModule(visual.class_embedding)), + ] + blocks = visual.transformer.resblocks + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn_qkv', block.attn.qkv), + ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', visual.ln_post)] + layers += [('head', self.get_last_layer())] elif self._model_name in {'RN50'}: layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, visual.conv3, visual.bn3, visual.layer1, visual.layer2, diff --git a/unlabeled_extrapolation/models/model_utils.py b/unlabeled_extrapolation/models/model_utils.py index c063e4f..e491c36 100644 --- a/unlabeled_extrapolation/models/model_utils.py +++ b/unlabeled_extrapolation/models/model_utils.py @@ -2,6 +2,11 @@ import torch import torch.nn +class ParamWrapperModule(torch.nn.Module): + def __init__(self, param): + super().__init__() + self._param = param + def set_linear_layer(layer, coef, intercept): coef_tensor = torch.tensor(coef, dtype=layer.weight.dtype).cuda() bias_tensor = torch.tensor(intercept, dtype=layer.bias.dtype).cuda() diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 187d57d..e6f8006 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -65,6 +65,9 @@ def __init__(self, model_name): if self._device == 'cuda': model.cuda() if 'deit' in model_name: + # deit implementation is not complete, doesn't seem to load properly, and also + # get_layers likely isn't handled correctly. + raise NotImplementedError self._model = nn.Sequential(*list(model.children())[:-1]) else: self._model = model @@ -83,17 +86,33 @@ def get_layers(self): patch_embed = self._model[0] blocks = self._model[2] else: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token patch_embed = self._model.patch_embed blocks = self._model.blocks - layers = [patch_embed, patch_embed] # To streamline with CLIP ViT. - layers += list(blocks) - # Note: Deit and timm vit have a layernorm after the transformer blocks, which I'm ignoring - # for now. - layers += [self.get_last_layer()] + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn_qkv', block.attn.qkv), + ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + if 'dino' not in self._model_name: + layers += [('post_norm', self._model.norm)] + else: + layers += [('empty_post_norm', nn.Module())] + layers += [('head', self.get_last_layer())] return layers def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [layer for name, layer in self.get_layers()] for i in range(min(k, len(layers))): set_requires_grad(layers[i], False) From 537256e4a94cf25e15c91005fef859aea4dfceb5 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Aug 2022 13:11:28 -0700 Subject: [PATCH 090/197] Log warmup steps. --- configs/adaptation/waterbirds_clipped_warmup.yaml | 2 -- unlabeled_extrapolation/baseline_train.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index 7c1c25f..fc3047f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -15,8 +15,6 @@ model: max_grad_norm: 1.0 -warmup_frac: 0.25 - batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 0e0aa65..1a01d80 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -485,7 +485,7 @@ def main(config, log_dir, checkpoints_dir): num_warmup_steps = int(config['warmup_frac'] * num_training_steps) else: num_warmup_steps = int(0.1 * num_training_steps) - logging.info("Warming up for %d steps", num_warmup_steps) + logging.info("Warming up for %d steps", num_warmup_steps) batch_scheduler = utils.initialize( config['batch_scheduler'], update_args={ 'optimizer': optimizer, From b5a61df1690ea12cb57cc06c26d3ad54c159b0c9 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 24 Aug 2022 13:11:28 -0700 Subject: [PATCH 091/197] Log warmup steps. --- configs/adaptation/waterbirds_clipped_warmup.yaml | 2 -- unlabeled_extrapolation/baseline_train.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/configs/adaptation/waterbirds_clipped_warmup.yaml b/configs/adaptation/waterbirds_clipped_warmup.yaml index 7c1c25f..fc3047f 100644 --- a/configs/adaptation/waterbirds_clipped_warmup.yaml +++ b/configs/adaptation/waterbirds_clipped_warmup.yaml @@ -15,8 +15,6 @@ model: max_grad_norm: 1.0 -warmup_frac: 0.25 - batch_scheduler: classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup args: {} diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 0e0aa65..1a01d80 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -485,7 +485,7 @@ def main(config, log_dir, checkpoints_dir): num_warmup_steps = int(config['warmup_frac'] * num_training_steps) else: num_warmup_steps = int(0.1 * num_training_steps) - logging.info("Warming up for %d steps", num_warmup_steps) + logging.info("Warming up for %d steps", num_warmup_steps) batch_scheduler = utils.initialize( config['batch_scheduler'], update_args={ 'optimizer': optimizer, From f6ae4a313998d1aefa44c14cedae5ea3f6bfc83e Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 25 Aug 2022 14:35:15 -0700 Subject: [PATCH 092/197] Tune bottom k --- .../adaptation/waterbirds_large_batch.yaml | 12 +++---- scripts/run_adaptation_experiments.py | 12 ++++++- unlabeled_extrapolation/baseline_train.py | 7 +++- unlabeled_extrapolation/models/clip_model.py | 36 ++++++++++++++----- unlabeled_extrapolation/models/vit_model.py | 14 ++++++-- 5 files changed, 61 insertions(+), 20 deletions(-) diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 998177f..e998f81 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -4,7 +4,7 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 200 +epochs: &epochs 100 batch_size: 512 batch_splits: 16 save_no_checkpoints: True @@ -14,10 +14,8 @@ model: args: model_name: 'ViT-B/16' -max_grad_norm: 1.0 -warmup_frac: 0.25 - -batch_scheduler: - classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup - args: {} +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index b747b72..49fb25b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1184,7 +1184,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn else: sweep_lrs = [0.0001, 0.0003, 0.001] if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1] + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1246,6 +1246,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.tune_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) + adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) if args.optimizer is not None: hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) @@ -1404,6 +1408,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.tune_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) + adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) if args.no_replications: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1598,6 +1606,8 @@ def fill_platform_specific_default_args(args): help='Model to use', required=False) parser.add_argument('--freeze_bottom_k', type=int, required=False, default=None, help='Freeze bottom k layers (if not specified, don\'t freeze).') + parser.add_argument('--tune_bottom_k', type=int, required=False, default=None, + help='Tune bottom k layers (if not specified, tune everything).') parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, help='At what epoch should we unfreeze all weights and fine-tune.') parser.add_argument('--only_one_run', action='store_true', diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 1a01d80..9fbe8a8 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -153,9 +153,10 @@ def build_model(config): finetune = 'finetune' in config and config['finetune'] linear_probe = 'linear_probe' in config and config['linear_probe'] freeze_bottom_k = 'freeze_bottom_k' in config + tune_bottom_k = check_exists_not_none(config, 'tune_bottom_k') batch_norm = 'batchnorm_ft' in config and config['batchnorm_ft'] side_tune = 'side_tune' in config and config['side_tune'] - if finetune or linear_probe or batch_norm or side_tune: + if finetune or linear_probe or batch_norm or side_tune: if freeze_bottom_k: # Currently only implemented for some models (including CLIP ViTs). net.freeze_bottom_k(config['freeze_bottom_k']) @@ -180,6 +181,10 @@ def build_model(config): net.add_probe(probe_net) else: net.new_last_layer(config['num_classes']) + if tune_bottom_k: + if freeze_bottom_k: + raise ValueError("Cannot have tune bottom k and freeze bottom k simultaneously.") + net.tune_bottom_k(config['tune_bottom_k']) if side_tune: # This is currently only supported for some networks like ResNet-50, # would need to add support for other networks. diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 8dc9e8d..0bd894f 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -112,26 +112,44 @@ def get_layers(self): blocks = visual.transformer.resblocks for i, block in zip(range(len(blocks)), blocks): layers += [ - ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn_qkv', block.attn.qkv), - ('trans' + str(i) + '_attn_proj', block.attn.proj), - ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_norm1', block.ln_1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.ln_2), ('trans' + str(i) + '_mlp', block.mlp), ] layers += [('post_norm', visual.ln_post)] layers += [('head', self.get_last_layer())] elif self._model_name in {'RN50'}: - layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, - visual.conv3, visual.bn3, visual.layer1, visual.layer2, - visual.layer3, visual.layer3, visual.attnpool] + layers = [ + ('conv1', visual.conv1), + ('bn1', visual.bn1), + ('conv2', visual.conv2), + ('bn2', visual.bn2), + ('conv3', visual.conv3), + ('bn3', visual.bn3), + ('layer1', visual.layer1), + ('layer2', visual.layer2), + ('layer3', visual.layer3), + ('attnpool', visual.attnpool)] else: raise NotImplementedError if self._classifier is not None: - layers = layers + [self._classifier] + layers = layers + [('head', self._classifier)] return layers + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [layer for name, layer in self.get_layers()] if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index e6f8006..b893c7f 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -99,8 +99,7 @@ def get_layers(self): for i, block in zip(range(len(blocks)), blocks): layers += [ ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn_qkv', block.attn.qkv), - ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_attn', block.attn), ('trans' + str(i) + '_norm2', block.norm2), ('trans' + str(i) + '_mlp', block.mlp), ] @@ -111,6 +110,17 @@ def get_layers(self): layers += [('head', self.get_last_layer())] return layers + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + def freeze_bottom_k(self, k): layers = [layer for name, layer in self.get_layers()] for i in range(min(k, len(layers))): From 792ead2568766a79690553c1c7dbd13935ba775a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 25 Aug 2022 14:35:15 -0700 Subject: [PATCH 093/197] Tune bottom k --- .../adaptation/waterbirds_large_batch.yaml | 12 +++---- scripts/run_adaptation_experiments.py | 12 ++++++- unlabeled_extrapolation/baseline_train.py | 7 +++- unlabeled_extrapolation/models/clip_model.py | 36 ++++++++++++++----- unlabeled_extrapolation/models/vit_model.py | 14 ++++++-- 5 files changed, 61 insertions(+), 20 deletions(-) diff --git a/configs/adaptation/waterbirds_large_batch.yaml b/configs/adaptation/waterbirds_large_batch.yaml index 998177f..e998f81 100644 --- a/configs/adaptation/waterbirds_large_batch.yaml +++ b/configs/adaptation/waterbirds_large_batch.yaml @@ -4,7 +4,7 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 200 +epochs: &epochs 100 batch_size: 512 batch_splits: 16 save_no_checkpoints: True @@ -14,10 +14,8 @@ model: args: model_name: 'ViT-B/16' -max_grad_norm: 1.0 -warmup_frac: 0.25 - -batch_scheduler: - classname: unlabeled_extrapolation.utils.schedulers.CosineScheduleWithWarmup - args: {} +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index b747b72..49fb25b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1184,7 +1184,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn else: sweep_lrs = [0.0001, 0.0003, 0.001] if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1] + sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1246,6 +1246,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.tune_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) + adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) if args.optimizer is not None: hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) @@ -1404,6 +1408,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'freeze_bottom_k': args.freeze_bottom_k}) adapt_name += '_freeze_bottom_' + str(args.freeze_bottom_k) + if args.tune_bottom_k is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) + adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) if args.no_replications: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1598,6 +1606,8 @@ def fill_platform_specific_default_args(args): help='Model to use', required=False) parser.add_argument('--freeze_bottom_k', type=int, required=False, default=None, help='Freeze bottom k layers (if not specified, don\'t freeze).') + parser.add_argument('--tune_bottom_k', type=int, required=False, default=None, + help='Tune bottom k layers (if not specified, tune everything).') parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, help='At what epoch should we unfreeze all weights and fine-tune.') parser.add_argument('--only_one_run', action='store_true', diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 1a01d80..9fbe8a8 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -153,9 +153,10 @@ def build_model(config): finetune = 'finetune' in config and config['finetune'] linear_probe = 'linear_probe' in config and config['linear_probe'] freeze_bottom_k = 'freeze_bottom_k' in config + tune_bottom_k = check_exists_not_none(config, 'tune_bottom_k') batch_norm = 'batchnorm_ft' in config and config['batchnorm_ft'] side_tune = 'side_tune' in config and config['side_tune'] - if finetune or linear_probe or batch_norm or side_tune: + if finetune or linear_probe or batch_norm or side_tune: if freeze_bottom_k: # Currently only implemented for some models (including CLIP ViTs). net.freeze_bottom_k(config['freeze_bottom_k']) @@ -180,6 +181,10 @@ def build_model(config): net.add_probe(probe_net) else: net.new_last_layer(config['num_classes']) + if tune_bottom_k: + if freeze_bottom_k: + raise ValueError("Cannot have tune bottom k and freeze bottom k simultaneously.") + net.tune_bottom_k(config['tune_bottom_k']) if side_tune: # This is currently only supported for some networks like ResNet-50, # would need to add support for other networks. diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 8dc9e8d..0bd894f 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -112,26 +112,44 @@ def get_layers(self): blocks = visual.transformer.resblocks for i, block in zip(range(len(blocks)), blocks): layers += [ - ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn_qkv', block.attn.qkv), - ('trans' + str(i) + '_attn_proj', block.attn.proj), - ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_norm1', block.ln_1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.ln_2), ('trans' + str(i) + '_mlp', block.mlp), ] layers += [('post_norm', visual.ln_post)] layers += [('head', self.get_last_layer())] elif self._model_name in {'RN50'}: - layers = [visual.conv1, visual.bn1, visual.conv2, visual.bn2, - visual.conv3, visual.bn3, visual.layer1, visual.layer2, - visual.layer3, visual.layer3, visual.attnpool] + layers = [ + ('conv1', visual.conv1), + ('bn1', visual.bn1), + ('conv2', visual.conv2), + ('bn2', visual.bn2), + ('conv3', visual.conv3), + ('bn3', visual.bn3), + ('layer1', visual.layer1), + ('layer2', visual.layer2), + ('layer3', visual.layer3), + ('attnpool', visual.attnpool)] else: raise NotImplementedError if self._classifier is not None: - layers = layers + [self._classifier] + layers = layers + [('head', self._classifier)] return layers + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [layer for name, layer in self.get_layers()] if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index e6f8006..b893c7f 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -99,8 +99,7 @@ def get_layers(self): for i, block in zip(range(len(blocks)), blocks): layers += [ ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn_qkv', block.attn.qkv), - ('trans' + str(i) + '_attn_proj', block.attn.proj), + ('trans' + str(i) + '_attn', block.attn), ('trans' + str(i) + '_norm2', block.norm2), ('trans' + str(i) + '_mlp', block.mlp), ] @@ -111,6 +110,17 @@ def get_layers(self): layers += [('head', self.get_last_layer())] return layers + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + def freeze_bottom_k(self, k): layers = [layer for name, layer in self.get_layers()] for i in range(min(k, len(layers))): From b7e33de5562f118e399203a9a343d0ee851a10bd Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 25 Aug 2022 16:11:53 -0700 Subject: [PATCH 094/197] Add no train option, useful to e.g., get gradient stats across train data --- unlabeled_extrapolation/baseline_train.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 9fbe8a8..4e4a442 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -366,12 +366,14 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() + if not check_exists_value(config, 'no_train', True): + opt_loss.backward() assert len(opt_loss.shape) == 0 loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) del opt_loss else: - loss.backward() + if not check_exists_value(config, 'no_train', True): + loss.backward() del inputs, labels, loss # Collect the gradients at each layer. add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) @@ -760,7 +762,7 @@ def setup(): parser.add_argument('--copy_all_folders', action='store_true', help='Copy all folders (e.g. code, utils) for reproducibility.') parser.add_argument('--project_name', type=str, - help='Name of the wandb project', required=True) + help='Name of the wandb project') parser.add_argument('--group_name', default=None, help='Name of the wandb group (a group of runs)') parser.add_argument('--run_name', default=None, help='Name of the wandb run') parser.add_argument('--entity_name', default='p-lambda', help='Name of the team') From 3f9713441aee72f595a53bde71298df42766bd47 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 25 Aug 2022 16:11:53 -0700 Subject: [PATCH 095/197] Add no train option, useful to e.g., get gradient stats across train data --- unlabeled_extrapolation/baseline_train.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 9fbe8a8..4e4a442 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -366,12 +366,14 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) - opt_loss.backward() + if not check_exists_value(config, 'no_train', True): + opt_loss.backward() assert len(opt_loss.shape) == 0 loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) del opt_loss else: - loss.backward() + if not check_exists_value(config, 'no_train', True): + loss.backward() del inputs, labels, loss # Collect the gradients at each layer. add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) @@ -760,7 +762,7 @@ def setup(): parser.add_argument('--copy_all_folders', action='store_true', help='Copy all folders (e.g. code, utils) for reproducibility.') parser.add_argument('--project_name', type=str, - help='Name of the wandb project', required=True) + help='Name of the wandb project') parser.add_argument('--group_name', default=None, help='Name of the wandb group (a group of runs)') parser.add_argument('--run_name', default=None, help='Name of the wandb run') parser.add_argument('--entity_name', default='p-lambda', help='Name of the team') From 908cfbc8fa0c3df8733a128bf6193440734ca55a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 26 Aug 2022 15:30:27 -0700 Subject: [PATCH 096/197] Add option to not trian. --- scripts/run_adaptation_experiments.py | 31 ++++++++++++++++----------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 49fb25b..ae793de 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1216,8 +1216,15 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name += '_epochs' + str(args.epochs) if args.optimizer is not None: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + if args.no_replications or args.only_one_run: + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. # Set hyperparameters - if args.only_one_run: + if args.no_train: + hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) + hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) + adapt_name += '_no_train_' + elif args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) @@ -1226,9 +1233,6 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) else: hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) - # TODO: remove this? - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. @@ -1290,9 +1294,6 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn 'torch_linprobe_epochs5_imagenet_clip_vit_b16/' 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) - if args.no_replications: - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, @@ -1396,12 +1397,17 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] - if args.only_one_run: - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if args.only_one_run or args.no_replications: num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. + if args.no_train: + hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) + hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) + adapt_name += '_no_train_' + elif args.only_one_run: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) + # Would be num_replications = 0 if we used adaptation_experiment below. if val_mode: hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) if args.freeze_bottom_k is not None: @@ -1412,9 +1418,6 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) - if args.no_replications: - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) @@ -1615,6 +1618,8 @@ def fill_platform_specific_default_args(args): '(also do not run replications).'), required=False) parser.add_argument('--no_replications', action='store_true', help='Don\'t run replication runs, only sweep.', required=False) + parser.add_argument('--no_train', action='store_true', + help='Don\'t train model, just collect stats.', required=False) args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) main(args) From b0f127d8a160f9bdbd88665ceaa90805e246f201 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 26 Aug 2022 15:30:27 -0700 Subject: [PATCH 097/197] Add option to not trian. --- scripts/run_adaptation_experiments.py | 31 ++++++++++++++++----------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 49fb25b..ae793de 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1216,8 +1216,15 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name += '_epochs' + str(args.epochs) if args.optimizer is not None: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + if args.no_replications or args.only_one_run: + num_replications = 1 + # Would be num_replications = 0 if we used adaptation_experiment below. # Set hyperparameters - if args.only_one_run: + if args.no_train: + hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) + hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) + adapt_name += '_no_train_' + elif args.only_one_run: if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) @@ -1226,9 +1233,6 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) else: hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) - # TODO: remove this? - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. @@ -1290,9 +1294,6 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn 'torch_linprobe_epochs5_imagenet_clip_vit_b16/' 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) - if args.no_replications: - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, @@ -1396,12 +1397,17 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] - if args.only_one_run: - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if args.only_one_run or args.no_replications: num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. + if args.no_train: + hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) + hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) + adapt_name += '_no_train_' + elif args.only_one_run: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) + # Would be num_replications = 0 if we used adaptation_experiment below. if val_mode: hyperparams_list = append_to_each(hyperparams_list, {'use_net_val_mode': True}) if args.freeze_bottom_k is not None: @@ -1412,9 +1418,6 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) - if args.no_replications: - num_replications = 1 - # Would be num_replications = 0 if we used adaptation_experiment below. if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) @@ -1615,6 +1618,8 @@ def fill_platform_specific_default_args(args): '(also do not run replications).'), required=False) parser.add_argument('--no_replications', action='store_true', help='Don\'t run replication runs, only sweep.', required=False) + parser.add_argument('--no_train', action='store_true', + help='Don\'t train model, just collect stats.', required=False) args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) main(args) From 4ceaa679a5a03975223688ed253f60a9ec5a5ebb Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Sat, 27 Aug 2022 00:51:18 -0700 Subject: [PATCH 098/197] Add amlt template files. --- .amltignore | 2 ++ scripts/amlt_config_template_amlk8s.yaml | 28 ++++++++++++++++++++++++ scripts/amlt_config_template_sing.yaml | 25 +++++++++++++++++++++ 3 files changed, 55 insertions(+) create mode 100644 .amltignore create mode 100644 scripts/amlt_config_template_amlk8s.yaml create mode 100644 scripts/amlt_config_template_sing.yaml diff --git a/.amltignore b/.amltignore new file mode 100644 index 0000000..fb7bc62 --- /dev/null +++ b/.amltignore @@ -0,0 +1,2 @@ +**logs** +**amlt_results** diff --git a/scripts/amlt_config_template_amlk8s.yaml b/scripts/amlt_config_template_amlk8s.yaml new file mode 100644 index 0000000..3b108b7 --- /dev/null +++ b/scripts/amlt_config_template_amlk8s.yaml @@ -0,0 +1,28 @@ +target: + service: amlk8s + # run "amlt target list amlk8s" to list the names of available AMLK8s targets + name: itplabrr1cl1 + vc: resrchvc + +environment: + image: pytorch/pytorch:latest + registry: docker.io # any public registry can be specified here + setup: + - apt-get update + - apt-get install git + - pip install ./CLIP + - pip install -e . + +code: + # local directory of the code. this will be uploaded to the server. + # $CONFIG_DIR is expanded to the directory of this config file + local_dir: . + +# data: +# data upload is not required for this example + +jobs: + - name: test_job + sku: G1-V100-P100 + command: + - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=logs/debug_run1 --batch_size=16 --train_dataset.args.download=True --no_wandb diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml new file mode 100644 index 0000000..d1f22e4 --- /dev/null +++ b/scripts/amlt_config_template_sing.yaml @@ -0,0 +1,25 @@ +target: + service: sing + name: msrresrchvc + +environment: + image: amlt-sing/pytorch-1.8.0 + setup: + - apt-get update + - apt-get install git + - pip install ./CLIP + - pip install -e . + +code: + # local directory of the code. this will be uploaded to the server. + # $CONFIG_DIR is expanded to the directory of this config file + local_dir: . + +# data: +# data upload is not required for this example + +jobs: + - name: test_job + sku: G1-V100-P100 + command: + - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=logs/debug_run1 --batch_size=16 --train_dataset.args.download=True --no_wandb From 7662a444079b0161eeec2221786ef0c8b611c03d Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Sat, 27 Aug 2022 00:51:18 -0700 Subject: [PATCH 099/197] Add amlt template files. --- .amltignore | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .amltignore diff --git a/.amltignore b/.amltignore new file mode 100644 index 0000000..fb7bc62 --- /dev/null +++ b/.amltignore @@ -0,0 +1,2 @@ +**logs** +**amlt_results** From cb4452bdae7919d6a424317043fc85c12671c1c4 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Mon, 29 Aug 2022 14:01:25 -0700 Subject: [PATCH 100/197] Update amulet output dir From bd4912d12019a3519eb97275fbafc5a3ecfb936a Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Mon, 29 Aug 2022 14:01:25 -0700 Subject: [PATCH 101/197] Update amulet output dir --- scripts/amlt_config_template_amlk8s.yaml | 2 +- scripts/amlt_config_template_sing.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/amlt_config_template_amlk8s.yaml b/scripts/amlt_config_template_amlk8s.yaml index 3b108b7..a5c6788 100644 --- a/scripts/amlt_config_template_amlk8s.yaml +++ b/scripts/amlt_config_template_amlk8s.yaml @@ -25,4 +25,4 @@ jobs: - name: test_job sku: G1-V100-P100 command: - - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=logs/debug_run1 --batch_size=16 --train_dataset.args.download=True --no_wandb + - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=$$AMLT_OUTPUT_DIR --batch_size=16 --train_dataset.args.download=True --no_wandb diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml index d1f22e4..5d9f4e1 100644 --- a/scripts/amlt_config_template_sing.yaml +++ b/scripts/amlt_config_template_sing.yaml @@ -22,4 +22,4 @@ jobs: - name: test_job sku: G1-V100-P100 command: - - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=logs/debug_run1 --batch_size=16 --train_dataset.args.download=True --no_wandb + - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=$$AMLT_OUTPUT_DIR --batch_size=16 --train_dataset.args.download=True --no_wandb From 9e030f8161edd939eccb55b3debe28a69ba702be Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Aug 2022 18:24:16 -0700 Subject: [PATCH 102/197] Add wilds downloader, fix model layers --- configs/adaptation/waterbirds.yaml | 2 +- scripts/download_wilds_datasets.py | 40 ++++ scripts/load_models_get_layers.ipynb | 228 +++++++++++++++++++ scripts/run_adaptation_experiments.py | 95 +++++--- scripts/summarize_results.py | 8 +- unlabeled_extrapolation/datasets/wilds.py | 2 +- unlabeled_extrapolation/models/bit_resnet.py | 12 +- unlabeled_extrapolation/models/vit_model.py | 2 +- unlabeled_extrapolation/utils/utils.py | 5 + 9 files changed, 361 insertions(+), 33 deletions(-) create mode 100644 scripts/download_wilds_datasets.py create mode 100644 scripts/load_models_get_layers.ipynb diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 7fc66b7..fca21e4 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -4,7 +4,7 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 100 +epochs: &epochs 20 batch_size: 32 save_no_checkpoints: True diff --git a/scripts/download_wilds_datasets.py b/scripts/download_wilds_datasets.py new file mode 100644 index 0000000..b4808c5 --- /dev/null +++ b/scripts/download_wilds_datasets.py @@ -0,0 +1,40 @@ +# From the WILDS GitHub repository. + +import os, sys +import argparse +import wilds + +def main(): + """ + Downloads the latest versions of all specified datasets, + if they do not already exist. + """ + parser = argparse.ArgumentParser() + parser.add_argument('--root_dir', required=True, + help='The directory where [dataset]/data can be found (or should be downloaded to, if it does not exist).') + parser.add_argument('--datasets', nargs='*', default=None, + help=f'Specify a space-separated list of dataset names to download. If left unspecified, the script will download all of the official benchmark datasets. Available choices are {wilds.supported_datasets}.') + parser.add_argument('--unlabeled', default=False, type=bool, + help=f'If this flag is set, the unlabeled dataset will be downloaded instead of the labeled.') + config = parser.parse_args() + + if config.datasets is None: + config.datasets = wilds.benchmark_datasets + + for dataset in config.datasets: + if dataset not in wilds.supported_datasets: + raise ValueError(f'{dataset} not recognized; must be one of {wilds.supported_datasets}.') + + print(f'Downloading the following datasets: {config.datasets}') + for dataset in config.datasets: + print(f'=== {dataset} ===') + wilds.get_dataset( + dataset=dataset, + root_dir=config.root_dir, + unlabeled=config.unlabeled, + download=True) + + +if __name__=='__main__': + main() + diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb new file mode 100644 index 0000000..f321b84 --- /dev/null +++ b/scripts/load_models_get_layers.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "importlib.reload(bit_resnet)\n", + "importlib.reload(vit_model)\n", + "importlib.reload(utils)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_layers_freeze_test(model):\n", + " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", + " print(model.get_layers()[1])\n", + " print(len(model.get_layers()))\n", + " model.freeze_bottom_k(k=1)\n", + " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", + " model.freeze_bottom_k(k=2)\n", + " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 68256659\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params before freezing: 87248787\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n" + ] + } + ], + "source": [ + "# Bit-resnet (get layers) for ResNet-50 and ResNet-101\n", + "\n", + "resnet50_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R50x1.npz\"\n", + "resnet50 = bit_resnet.BitResNet(model_name='BiT-M-R50x1', checkpoint_path=resnet50_checkpoint_path)\n", + "get_layers_freeze_test(resnet50)\n", + "\n", + "resnet101_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R101x1.npz\"\n", + "resnet101 = bit_resnet.BitResNet(model_name='BiT-M-R101x1', checkpoint_path=resnet101_checkpoint_path)\n", + "get_layers_freeze_test(resnet101)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading: \"https://github.com/facebookresearch/dino/archive/main.zip\" to /sailhome/ananya/.cache/torch/hub/main.zip\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 85798656\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 85208064\n", + "num params after freezing 2: 85208064\n" + ] + } + ], + "source": [ + "# DINO\n", + "model = vit_model.VitModel(model_name='dino_vitb16')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 22050664\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n" + ] + } + ], + "source": [ + "# Timm ViT-S\n", + "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Conv-next\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index ae793de..16077a9 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -509,10 +509,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds = Dataset( name='waterbirds', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -520,16 +521,17 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/scr/biggest/ue_datasets/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_large_batch = Dataset( name='waterbirds_large_batch', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -544,10 +546,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -561,10 +564,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_label_balanced = Dataset( name='waterbirds_label_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -578,10 +582,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_group_balanced = Dataset( name='waterbirds_group_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -596,10 +601,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -613,10 +619,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -630,10 +637,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -1011,6 +1019,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +bit_resnet_101_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R101x1', + 'checkpoint_rel_path': 'BiT-M-R101x1.npz', + }, + bundles=[] +) + +bit_resnet_50_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R50x1', + 'checkpoint_rel_path': 'BiT-M-R50x1.npz', + }, + bundles=[] +) + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -1046,6 +1072,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, + 'bit_resnet_50_in21k': bit_resnet_50_in21k, + 'bit_resnet_101_in21k': bit_resnet_101_in21k, 'landcover_baseline': landcover_baseline, 'landcover_auxin': landcover_auxin, } @@ -1183,8 +1211,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] + # if 'waterbirds' in args.datasets[0]: + # sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1297,7 +1325,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, - num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'optimizer.classname'}) + num_replications=num_replications, args=args, + ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1425,6 +1454,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) adapt_name += '_opt_' + args.optimizer + if args.full_ft_epoch is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) + adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1446,7 +1479,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1471,10 +1504,13 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset_jags(copy_cmd): - for i in range(10, 30): + for i in range(10, 32): cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' - subprocess.run(cmd, shell=True) + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) def spray_celeba_jags(args): @@ -1492,8 +1528,14 @@ def spray_imagenet_jags(args): f'source {args.scripts_dir}/copy_dataset.sh imagenet') +def spray_wilds_jags(args): + spray_dataset_jags( + f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' + f'--datasets {" ".join(args.datasets)}') + + def spray_domainnet_jags(args): - for i in range(10, 30): + for i in range(10, 32): cmd = 'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G' cmd += f' --nodelist=jagupard{i} -J copy_domainnet_jag{i} -o %x.out' cmd += ' scripts/copy_dataset.sh domainnet' @@ -1504,7 +1546,7 @@ def summarize_dataset(args): assert len(args.datasets) == 1 dataset = names_to_datasets[args.datasets[0]] cmd = 'python scripts/summarize_all_results.py ' - cmd += '--results_dir_glob=logs/*' + dataset.name + '* ' + cmd += '--results_dir_glob=' + args.log_dir + '/*' + dataset.name + '* ' cmd += '--val_metrics ' + dataset.val_metric + ' ' cmd += ' '.join(dataset.secondary_val_metrics) + ' ' cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' @@ -1520,6 +1562,7 @@ def main(args): 'spray_fmow_jags': spray_fmow_jags, 'spray_imagenet_jags': spray_imagenet_jags, 'spray_domainnet_jags': spray_domainnet_jags, + 'spray_wilds_jags': spray_wilds_jags, 'fine_tuning_experiments': fine_tuning_experiments, 'fine_tuning_celeba_experiments': fine_tuning_celeba_experiments, 'linprobe_experiments': linprobe_experiments, @@ -1589,7 +1632,7 @@ def fill_platform_specific_default_args(args): help='Path to dir where scripts are stored.') parser.add_argument('--output_dir', type=str, required=False, default='slurm_outputs/', help='(Slurm only) Path to dir to store stdout for experiment.') - parser.add_argument('--log_dir', type=str, required=False, default=None, + parser.add_argument('--log_dir', type=str, required=False, default='logs/', help='Path to dir where we save logs and run checkpoints.') parser.add_argument('--pretrained_checkpoints_dir', type=str, required=False, default=None, help='Path to dir where we keep pretrained checkpoints.') diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index c7d6db8..cc456b9 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -33,7 +33,13 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): if val_metric == 'WORST' or 'WORST' in output_metrics: test_acc_column_names = [s for s in df.columns if 'test_acc' in s] worst_accs = df[test_acc_column_names].min(axis=1) - df['WORST'] = worst_accs + df['WORST'] = worst_accs * 100 + if val_metric == 'WATERBIRDS_VAL' or 'WATERBIRDS_VAL' in output_metrics: + val_accs = (df['test_acc/waterbg-waterbird-test'] * 1057.0 + + df['test_acc/landbg-waterbird-test'] * 56.0 + + df['test_acc/waterbg-landbird-test'] * 184.0 + + df['test_acc/landbg-landbird-test'] * 3498.0) / 4795 * 100 + df['WATERBIRDS_VAL'] = val_accs if val_metric is not None and val_metric != 'LAST': if val_metric not in df: raise ValueError(f'{val_metric} column not in {file_path}') diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index d89ac5f..dd33304 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -24,7 +24,7 @@ def equal_subsample(list_of_lists, rng): class WILDS(Dataset): - def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False, + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=True, return_meta=False, subsampled_y=False, subsampled_meta=False, seed=0): # Split can be train, id_val, id_test, val, test. super().__init__() diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index a598424..39b3125 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -191,7 +191,10 @@ def __init__(self, model_name, checkpoint_path=None, normalize=True): if model_name not in KNOWN_MODELS: raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') self._model_name = model_name - self._model = KNOWN_MODELS[model_name](head_size=1000) + if 'ILSVRC2012' in checkpoint_path: + self._model = KNOWN_MODELS[model_name](head_size=1000) + else: + self._model = KNOWN_MODELS[model_name](head_size=21843) self._model.load_from(np.load(checkpoint_path)) self._normalize = normalize @@ -205,11 +208,14 @@ def set_requires_grad(self, val): param.requires_grad = val def get_layers(self): - layers = [self._model.root] + list(self._model.body) + [self._model.head] + blocks = list(self._model.body) + layers = ([('stem', self._model.root)] + + [('conv-block-' + str(i), b) for i, b in zip(range(len(blocks)), blocks)] + + [('head', self._model.head)]) return layers def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [l for _, l in self.get_layers()] if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index b893c7f..32c2322 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -170,4 +170,4 @@ def get_features(self, x): if is_timm_vit_name(self._model_name): raise NotImplementedError('Need to implement this for timm models.') else: - return self._model(default_imnet_transform(x)) + return self._model(default_imnet_normalize(x)) diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index 2774f02..229fda7 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -9,6 +9,11 @@ import torch from torchvision import transforms + +def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) + + def save_json(save_path, save_dict): with open(save_path, 'w') as outfile: json.dump(save_dict, outfile) From bb0ebcaaade980abd76dc59f14895a9f7d35dd19 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Aug 2022 18:24:16 -0700 Subject: [PATCH 103/197] Add wilds downloader, fix model layers --- configs/adaptation/waterbirds.yaml | 2 +- scripts/download_wilds_datasets.py | 40 ++++ scripts/load_models_get_layers.ipynb | 228 +++++++++++++++++++ scripts/run_adaptation_experiments.py | 95 +++++--- scripts/summarize_results.py | 8 +- unlabeled_extrapolation/datasets/wilds.py | 2 +- unlabeled_extrapolation/models/bit_resnet.py | 12 +- unlabeled_extrapolation/models/vit_model.py | 2 +- unlabeled_extrapolation/utils/utils.py | 5 + 9 files changed, 361 insertions(+), 33 deletions(-) create mode 100644 scripts/download_wilds_datasets.py create mode 100644 scripts/load_models_get_layers.ipynb diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 7fc66b7..fca21e4 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -4,7 +4,7 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 100 +epochs: &epochs 20 batch_size: 32 save_no_checkpoints: True diff --git a/scripts/download_wilds_datasets.py b/scripts/download_wilds_datasets.py new file mode 100644 index 0000000..b4808c5 --- /dev/null +++ b/scripts/download_wilds_datasets.py @@ -0,0 +1,40 @@ +# From the WILDS GitHub repository. + +import os, sys +import argparse +import wilds + +def main(): + """ + Downloads the latest versions of all specified datasets, + if they do not already exist. + """ + parser = argparse.ArgumentParser() + parser.add_argument('--root_dir', required=True, + help='The directory where [dataset]/data can be found (or should be downloaded to, if it does not exist).') + parser.add_argument('--datasets', nargs='*', default=None, + help=f'Specify a space-separated list of dataset names to download. If left unspecified, the script will download all of the official benchmark datasets. Available choices are {wilds.supported_datasets}.') + parser.add_argument('--unlabeled', default=False, type=bool, + help=f'If this flag is set, the unlabeled dataset will be downloaded instead of the labeled.') + config = parser.parse_args() + + if config.datasets is None: + config.datasets = wilds.benchmark_datasets + + for dataset in config.datasets: + if dataset not in wilds.supported_datasets: + raise ValueError(f'{dataset} not recognized; must be one of {wilds.supported_datasets}.') + + print(f'Downloading the following datasets: {config.datasets}') + for dataset in config.datasets: + print(f'=== {dataset} ===') + wilds.get_dataset( + dataset=dataset, + root_dir=config.root_dir, + unlabeled=config.unlabeled, + download=True) + + +if __name__=='__main__': + main() + diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb new file mode 100644 index 0000000..f321b84 --- /dev/null +++ b/scripts/load_models_get_layers.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "importlib.reload(bit_resnet)\n", + "importlib.reload(vit_model)\n", + "importlib.reload(utils)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_layers_freeze_test(model):\n", + " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", + " print(model.get_layers()[1])\n", + " print(len(model.get_layers()))\n", + " model.freeze_bottom_k(k=1)\n", + " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", + " model.freeze_bottom_k(k=2)\n", + " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 68256659\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params before freezing: 87248787\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n" + ] + } + ], + "source": [ + "# Bit-resnet (get layers) for ResNet-50 and ResNet-101\n", + "\n", + "resnet50_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R50x1.npz\"\n", + "resnet50 = bit_resnet.BitResNet(model_name='BiT-M-R50x1', checkpoint_path=resnet50_checkpoint_path)\n", + "get_layers_freeze_test(resnet50)\n", + "\n", + "resnet101_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R101x1.npz\"\n", + "resnet101 = bit_resnet.BitResNet(model_name='BiT-M-R101x1', checkpoint_path=resnet101_checkpoint_path)\n", + "get_layers_freeze_test(resnet101)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading: \"https://github.com/facebookresearch/dino/archive/main.zip\" to /sailhome/ananya/.cache/torch/hub/main.zip\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 85798656\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 85208064\n", + "num params after freezing 2: 85208064\n" + ] + } + ], + "source": [ + "# DINO\n", + "model = vit_model.VitModel(model_name='dino_vitb16')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 22050664\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n" + ] + } + ], + "source": [ + "# Timm ViT-S\n", + "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Conv-next\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index ae793de..16077a9 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -509,10 +509,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds = Dataset( name='waterbirds', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -520,16 +521,17 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/scr/biggest/ue_datasets/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_large_batch = Dataset( name='waterbirds_large_batch', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -544,10 +546,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -561,10 +564,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_label_balanced = Dataset( name='waterbirds_label_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -578,10 +582,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_group_balanced = Dataset( name='waterbirds_group_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -596,10 +601,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -613,10 +619,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -630,10 +637,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -1011,6 +1019,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +bit_resnet_101_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R101x1', + 'checkpoint_rel_path': 'BiT-M-R101x1.npz', + }, + bundles=[] +) + +bit_resnet_50_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R50x1', + 'checkpoint_rel_path': 'BiT-M-R50x1.npz', + }, + bundles=[] +) + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -1046,6 +1072,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, + 'bit_resnet_50_in21k': bit_resnet_50_in21k, + 'bit_resnet_101_in21k': bit_resnet_101_in21k, 'landcover_baseline': landcover_baseline, 'landcover_auxin': landcover_auxin, } @@ -1183,8 +1211,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] + # if 'waterbirds' in args.datasets[0]: + # sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1297,7 +1325,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, - num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'optimizer.classname'}) + num_replications=num_replications, args=args, + ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1425,6 +1454,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) adapt_name += '_opt_' + args.optimizer + if args.full_ft_epoch is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) + adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1446,7 +1479,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1471,10 +1504,13 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset_jags(copy_cmd): - for i in range(10, 30): + for i in range(10, 32): cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' - subprocess.run(cmd, shell=True) + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) def spray_celeba_jags(args): @@ -1492,8 +1528,14 @@ def spray_imagenet_jags(args): f'source {args.scripts_dir}/copy_dataset.sh imagenet') +def spray_wilds_jags(args): + spray_dataset_jags( + f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' + f'--datasets {" ".join(args.datasets)}') + + def spray_domainnet_jags(args): - for i in range(10, 30): + for i in range(10, 32): cmd = 'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G' cmd += f' --nodelist=jagupard{i} -J copy_domainnet_jag{i} -o %x.out' cmd += ' scripts/copy_dataset.sh domainnet' @@ -1504,7 +1546,7 @@ def summarize_dataset(args): assert len(args.datasets) == 1 dataset = names_to_datasets[args.datasets[0]] cmd = 'python scripts/summarize_all_results.py ' - cmd += '--results_dir_glob=logs/*' + dataset.name + '* ' + cmd += '--results_dir_glob=' + args.log_dir + '/*' + dataset.name + '* ' cmd += '--val_metrics ' + dataset.val_metric + ' ' cmd += ' '.join(dataset.secondary_val_metrics) + ' ' cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' @@ -1520,6 +1562,7 @@ def main(args): 'spray_fmow_jags': spray_fmow_jags, 'spray_imagenet_jags': spray_imagenet_jags, 'spray_domainnet_jags': spray_domainnet_jags, + 'spray_wilds_jags': spray_wilds_jags, 'fine_tuning_experiments': fine_tuning_experiments, 'fine_tuning_celeba_experiments': fine_tuning_celeba_experiments, 'linprobe_experiments': linprobe_experiments, @@ -1589,7 +1632,7 @@ def fill_platform_specific_default_args(args): help='Path to dir where scripts are stored.') parser.add_argument('--output_dir', type=str, required=False, default='slurm_outputs/', help='(Slurm only) Path to dir to store stdout for experiment.') - parser.add_argument('--log_dir', type=str, required=False, default=None, + parser.add_argument('--log_dir', type=str, required=False, default='logs/', help='Path to dir where we save logs and run checkpoints.') parser.add_argument('--pretrained_checkpoints_dir', type=str, required=False, default=None, help='Path to dir where we keep pretrained checkpoints.') diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index c7d6db8..cc456b9 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -33,7 +33,13 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): if val_metric == 'WORST' or 'WORST' in output_metrics: test_acc_column_names = [s for s in df.columns if 'test_acc' in s] worst_accs = df[test_acc_column_names].min(axis=1) - df['WORST'] = worst_accs + df['WORST'] = worst_accs * 100 + if val_metric == 'WATERBIRDS_VAL' or 'WATERBIRDS_VAL' in output_metrics: + val_accs = (df['test_acc/waterbg-waterbird-test'] * 1057.0 + + df['test_acc/landbg-waterbird-test'] * 56.0 + + df['test_acc/waterbg-landbird-test'] * 184.0 + + df['test_acc/landbg-landbird-test'] * 3498.0) / 4795 * 100 + df['WATERBIRDS_VAL'] = val_accs if val_metric is not None and val_metric != 'LAST': if val_metric not in df: raise ValueError(f'{val_metric} column not in {file_path}') diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index d89ac5f..dd33304 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -24,7 +24,7 @@ def equal_subsample(list_of_lists, rng): class WILDS(Dataset): - def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False, + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=True, return_meta=False, subsampled_y=False, subsampled_meta=False, seed=0): # Split can be train, id_val, id_test, val, test. super().__init__() diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index a598424..39b3125 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -191,7 +191,10 @@ def __init__(self, model_name, checkpoint_path=None, normalize=True): if model_name not in KNOWN_MODELS: raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') self._model_name = model_name - self._model = KNOWN_MODELS[model_name](head_size=1000) + if 'ILSVRC2012' in checkpoint_path: + self._model = KNOWN_MODELS[model_name](head_size=1000) + else: + self._model = KNOWN_MODELS[model_name](head_size=21843) self._model.load_from(np.load(checkpoint_path)) self._normalize = normalize @@ -205,11 +208,14 @@ def set_requires_grad(self, val): param.requires_grad = val def get_layers(self): - layers = [self._model.root] + list(self._model.body) + [self._model.head] + blocks = list(self._model.body) + layers = ([('stem', self._model.root)] + + [('conv-block-' + str(i), b) for i, b in zip(range(len(blocks)), blocks)] + + [('head', self._model.head)]) return layers def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [l for _, l in self.get_layers()] if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index b893c7f..32c2322 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -170,4 +170,4 @@ def get_features(self, x): if is_timm_vit_name(self._model_name): raise NotImplementedError('Need to implement this for timm models.') else: - return self._model(default_imnet_transform(x)) + return self._model(default_imnet_normalize(x)) diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index 2774f02..229fda7 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -9,6 +9,11 @@ import torch from torchvision import transforms + +def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) + + def save_json(save_path, save_dict): with open(save_path, 'w') as outfile: json.dump(save_dict, outfile) From 3b18056c642ebef42946adc938e2a0c36959a22b Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 31 Aug 2022 18:24:16 -0700 Subject: [PATCH 104/197] Add wilds downloader, fix model layers --- configs/adaptation/waterbirds.yaml | 2 +- scripts/download_wilds_datasets.py | 40 ++++ scripts/load_models_get_layers.ipynb | 228 +++++++++++++++++++ scripts/run_adaptation_experiments.py | 95 +++++--- scripts/summarize_results.py | 8 +- unlabeled_extrapolation/datasets/wilds.py | 2 +- unlabeled_extrapolation/models/bit_resnet.py | 12 +- unlabeled_extrapolation/models/vit_model.py | 2 +- unlabeled_extrapolation/utils/utils.py | 5 + 9 files changed, 361 insertions(+), 33 deletions(-) create mode 100644 scripts/download_wilds_datasets.py create mode 100644 scripts/load_models_get_layers.ipynb diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index 7fc66b7..fca21e4 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -4,7 +4,7 @@ inherit: - datasets_waterbirds.yaml num_classes: 2 -epochs: &epochs 100 +epochs: &epochs 20 batch_size: 32 save_no_checkpoints: True diff --git a/scripts/download_wilds_datasets.py b/scripts/download_wilds_datasets.py new file mode 100644 index 0000000..b4808c5 --- /dev/null +++ b/scripts/download_wilds_datasets.py @@ -0,0 +1,40 @@ +# From the WILDS GitHub repository. + +import os, sys +import argparse +import wilds + +def main(): + """ + Downloads the latest versions of all specified datasets, + if they do not already exist. + """ + parser = argparse.ArgumentParser() + parser.add_argument('--root_dir', required=True, + help='The directory where [dataset]/data can be found (or should be downloaded to, if it does not exist).') + parser.add_argument('--datasets', nargs='*', default=None, + help=f'Specify a space-separated list of dataset names to download. If left unspecified, the script will download all of the official benchmark datasets. Available choices are {wilds.supported_datasets}.') + parser.add_argument('--unlabeled', default=False, type=bool, + help=f'If this flag is set, the unlabeled dataset will be downloaded instead of the labeled.') + config = parser.parse_args() + + if config.datasets is None: + config.datasets = wilds.benchmark_datasets + + for dataset in config.datasets: + if dataset not in wilds.supported_datasets: + raise ValueError(f'{dataset} not recognized; must be one of {wilds.supported_datasets}.') + + print(f'Downloading the following datasets: {config.datasets}') + for dataset in config.datasets: + print(f'=== {dataset} ===') + wilds.get_dataset( + dataset=dataset, + root_dir=config.root_dir, + unlabeled=config.unlabeled, + download=True) + + +if __name__=='__main__': + main() + diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb new file mode 100644 index 0000000..f321b84 --- /dev/null +++ b/scripts/load_models_get_layers.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "importlib.reload(bit_resnet)\n", + "importlib.reload(vit_model)\n", + "importlib.reload(utils)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def get_layers_freeze_test(model):\n", + " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", + " print(model.get_layers()[1])\n", + " print(len(model.get_layers()))\n", + " model.freeze_bottom_k(k=1)\n", + " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", + " model.freeze_bottom_k(k=2)\n", + " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 68256659\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params before freezing: 87248787\n", + "('conv-block-0', Sequential(\n", + " (unit01): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (unit02): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (unit03): PreActBottleneck(\n", + " (gn1): GroupNorm(32, 256, eps=1e-05, affine=True)\n", + " (conv1): StdConv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (gn2): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv2): StdConv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (gn3): GroupNorm(32, 64, eps=1e-05, affine=True)\n", + " (conv3): StdConv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + "))\n", + "6\n", + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n" + ] + } + ], + "source": [ + "# Bit-resnet (get layers) for ResNet-50 and ResNet-101\n", + "\n", + "resnet50_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R50x1.npz\"\n", + "resnet50 = bit_resnet.BitResNet(model_name='BiT-M-R50x1', checkpoint_path=resnet50_checkpoint_path)\n", + "get_layers_freeze_test(resnet50)\n", + "\n", + "resnet101_checkpoint_path = \"/u/scr/ananya/simclr_weights/BiT-M-R101x1.npz\"\n", + "resnet101 = bit_resnet.BitResNet(model_name='BiT-M-R101x1', checkpoint_path=resnet101_checkpoint_path)\n", + "get_layers_freeze_test(resnet101)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading: \"https://github.com/facebookresearch/dino/archive/main.zip\" to /sailhome/ananya/.cache/torch/hub/main.zip\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 85798656\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 85208064\n", + "num params after freezing 2: 85208064\n" + ] + } + ], + "source": [ + "# DINO\n", + "model = vit_model.VitModel(model_name='dino_vitb16')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 22050664\n", + "('empty_ln_pre', Module())\n", + "54\n", + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n" + ] + } + ], + "source": [ + "# Timm ViT-S\n", + "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Conv-next\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index ae793de..16077a9 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -509,10 +509,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds = Dataset( name='waterbirds', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -520,16 +521,17 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/scr/biggest/ue_datasets/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_large_batch = Dataset( name='waterbirds_large_batch', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST'], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -544,10 +546,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_clipped_warmup = Dataset( name='waterbirds_clipped_warmup', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -561,10 +564,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_label_balanced = Dataset( name='waterbirds_label_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST'], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST'], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -578,10 +582,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_group_balanced = Dataset( name='waterbirds_group_balanced', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL','LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -596,10 +601,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): name='waterbirds_background', overwrite_options=' --overwrite_dataset_name=waterbirds-background ', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -613,10 +619,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_norm = Dataset( name='waterbirds_norm', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -630,10 +637,11 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): waterbirds_augs = Dataset( name='waterbirds_augs', val_metric='test_acc/val', - secondary_val_metrics=['LAST', 'WORST',], + secondary_val_metrics=['WATERBIRDS_VAL', 'LAST', 'WORST',], output_metrics=['epoch', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', - 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', 'WORST',], + 'test_acc/waterbg-landbird-test', 'test_acc/waterbg-waterbird-test', + 'WATERBIRDS_VAL', 'WORST',], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/val', 'test_acc/landbg-landbird-test', 'test_acc/landbg-waterbird-test', @@ -1011,6 +1019,24 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +bit_resnet_101_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R101x1', + 'checkpoint_rel_path': 'BiT-M-R101x1.npz', + }, + bundles=[] +) + +bit_resnet_50_in21k = Model( + kwargs={ + 'classname': 'models.bit_resnet.BitResNet', + 'args.model_name': 'BiT-M-R50x1', + 'checkpoint_rel_path': 'BiT-M-R50x1.npz', + }, + bundles=[] +) + landcover_baseline = Model( kwargs={ 'classname': 'models.innout_models.CNN1D', @@ -1046,6 +1072,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, + 'bit_resnet_50_in21k': bit_resnet_50_in21k, + 'bit_resnet_101_in21k': bit_resnet_101_in21k, 'landcover_baseline': landcover_baseline, 'landcover_auxin': landcover_auxin, } @@ -1183,8 +1211,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [0.00001, 0.00003, 0.0001] else: sweep_lrs = [0.0001, 0.0003, 0.001] - if 'waterbirds' in args.datasets[0]: - sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] + # if 'waterbirds' in args.datasets[0]: + # sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3] if side_tune: adapt_name += '_side_tune' sweep_lrs = sweep_lrs + [3e-2, 1e-1, 3e-1, 1.0, 3.0, 10.0] @@ -1297,7 +1325,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn for dataset in datasets: all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, - num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'optimizer.classname'}) + num_replications=num_replications, args=args, + ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1425,6 +1454,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) adapt_name += '_opt_' + args.optimizer + if args.full_ft_epoch is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) + adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1446,7 +1479,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1471,10 +1504,13 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset_jags(copy_cmd): - for i in range(10, 30): + for i in range(10, 32): cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' - subprocess.run(cmd, shell=True) + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) def spray_celeba_jags(args): @@ -1492,8 +1528,14 @@ def spray_imagenet_jags(args): f'source {args.scripts_dir}/copy_dataset.sh imagenet') +def spray_wilds_jags(args): + spray_dataset_jags( + f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' + f'--datasets {" ".join(args.datasets)}') + + def spray_domainnet_jags(args): - for i in range(10, 30): + for i in range(10, 32): cmd = 'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G' cmd += f' --nodelist=jagupard{i} -J copy_domainnet_jag{i} -o %x.out' cmd += ' scripts/copy_dataset.sh domainnet' @@ -1504,7 +1546,7 @@ def summarize_dataset(args): assert len(args.datasets) == 1 dataset = names_to_datasets[args.datasets[0]] cmd = 'python scripts/summarize_all_results.py ' - cmd += '--results_dir_glob=logs/*' + dataset.name + '* ' + cmd += '--results_dir_glob=' + args.log_dir + '/*' + dataset.name + '* ' cmd += '--val_metrics ' + dataset.val_metric + ' ' cmd += ' '.join(dataset.secondary_val_metrics) + ' ' cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' @@ -1520,6 +1562,7 @@ def main(args): 'spray_fmow_jags': spray_fmow_jags, 'spray_imagenet_jags': spray_imagenet_jags, 'spray_domainnet_jags': spray_domainnet_jags, + 'spray_wilds_jags': spray_wilds_jags, 'fine_tuning_experiments': fine_tuning_experiments, 'fine_tuning_celeba_experiments': fine_tuning_celeba_experiments, 'linprobe_experiments': linprobe_experiments, @@ -1589,7 +1632,7 @@ def fill_platform_specific_default_args(args): help='Path to dir where scripts are stored.') parser.add_argument('--output_dir', type=str, required=False, default='slurm_outputs/', help='(Slurm only) Path to dir to store stdout for experiment.') - parser.add_argument('--log_dir', type=str, required=False, default=None, + parser.add_argument('--log_dir', type=str, required=False, default='logs/', help='Path to dir where we save logs and run checkpoints.') parser.add_argument('--pretrained_checkpoints_dir', type=str, required=False, default=None, help='Path to dir where we keep pretrained checkpoints.') diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index c7d6db8..cc456b9 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -33,7 +33,13 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): if val_metric == 'WORST' or 'WORST' in output_metrics: test_acc_column_names = [s for s in df.columns if 'test_acc' in s] worst_accs = df[test_acc_column_names].min(axis=1) - df['WORST'] = worst_accs + df['WORST'] = worst_accs * 100 + if val_metric == 'WATERBIRDS_VAL' or 'WATERBIRDS_VAL' in output_metrics: + val_accs = (df['test_acc/waterbg-waterbird-test'] * 1057.0 + + df['test_acc/landbg-waterbird-test'] * 56.0 + + df['test_acc/waterbg-landbird-test'] * 184.0 + + df['test_acc/landbg-landbird-test'] * 3498.0) / 4795 * 100 + df['WATERBIRDS_VAL'] = val_accs if val_metric is not None and val_metric != 'LAST': if val_metric not in df: raise ValueError(f'{val_metric} column not in {file_path}') diff --git a/unlabeled_extrapolation/datasets/wilds.py b/unlabeled_extrapolation/datasets/wilds.py index d89ac5f..dd33304 100644 --- a/unlabeled_extrapolation/datasets/wilds.py +++ b/unlabeled_extrapolation/datasets/wilds.py @@ -24,7 +24,7 @@ def equal_subsample(list_of_lists, rng): class WILDS(Dataset): - def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=False, return_meta=False, + def __init__(self, dataset_name, split, root, meta_selector=None, transform=None, download=True, return_meta=False, subsampled_y=False, subsampled_meta=False, seed=0): # Split can be train, id_val, id_test, val, test. super().__init__() diff --git a/unlabeled_extrapolation/models/bit_resnet.py b/unlabeled_extrapolation/models/bit_resnet.py index a598424..39b3125 100644 --- a/unlabeled_extrapolation/models/bit_resnet.py +++ b/unlabeled_extrapolation/models/bit_resnet.py @@ -191,7 +191,10 @@ def __init__(self, model_name, checkpoint_path=None, normalize=True): if model_name not in KNOWN_MODELS: raise ValueError(f'model_name ({model_name}) not found in KNOWN_MODELS ({KNOWN_MODELS})') self._model_name = model_name - self._model = KNOWN_MODELS[model_name](head_size=1000) + if 'ILSVRC2012' in checkpoint_path: + self._model = KNOWN_MODELS[model_name](head_size=1000) + else: + self._model = KNOWN_MODELS[model_name](head_size=21843) self._model.load_from(np.load(checkpoint_path)) self._normalize = normalize @@ -205,11 +208,14 @@ def set_requires_grad(self, val): param.requires_grad = val def get_layers(self): - layers = [self._model.root] + list(self._model.body) + [self._model.head] + blocks = list(self._model.body) + layers = ([('stem', self._model.root)] + + [('conv-block-' + str(i), b) for i, b in zip(range(len(blocks)), blocks)] + + [('head', self._model.head)]) return layers def freeze_bottom_k(self, k): - layers = self.get_layers() + layers = [l for _, l in self.get_layers()] if k > len(layers): raise ValueError(f"k {k} should be less than number of layers {len(layers)}") for i in range(k): diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index b893c7f..32c2322 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -170,4 +170,4 @@ def get_features(self, x): if is_timm_vit_name(self._model_name): raise NotImplementedError('Need to implement this for timm models.') else: - return self._model(default_imnet_transform(x)) + return self._model(default_imnet_normalize(x)) diff --git a/unlabeled_extrapolation/utils/utils.py b/unlabeled_extrapolation/utils/utils.py index 2774f02..229fda7 100644 --- a/unlabeled_extrapolation/utils/utils.py +++ b/unlabeled_extrapolation/utils/utils.py @@ -9,6 +9,11 @@ import torch from torchvision import transforms + +def count_parameters(model, trainable): + return sum(p.numel() for p in model.parameters() if p.requires_grad == trainable) + + def save_json(save_path, save_dict): with open(save_path, 'w') as outfile: json.dump(save_dict, outfile) From 1565eee9c5fffe54f066609982e3e08fe808193d Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 1 Sep 2022 17:48:53 -0700 Subject: [PATCH 105/197] Add amulet sweep capability. --- .amltignore | 1 + scripts/run_adaptation_experiments.py | 104 ++++++++++++++++++++++---- 2 files changed, 90 insertions(+), 15 deletions(-) diff --git a/.amltignore b/.amltignore index fb7bc62..6cccde4 100644 --- a/.amltignore +++ b/.amltignore @@ -1,2 +1,3 @@ **logs** **amlt_results** +**amlt_configs** diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 16077a9..77ebb9b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -11,6 +11,12 @@ DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' +def print_os_system(cmd, args): + print("Running OS command: " + cmd) + if not args.print_command: + os.system(cmd) + + def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): output_path = args.output_dir + '/' + job_name sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name @@ -76,8 +82,8 @@ def get_python_cmd(code_path, python_path='python', kwargs=None, args=None, over opts = '' python_cmd = python_path + ' ' + code_path + ' ' python_cmd += opts - if args.codalab: - python_cmd += ' --nowandb ' + if args.codalab or args.amulet_option is not None: + python_cmd += ' --no_wandb ' if overwrite_options is not None: python_cmd += ' ' + overwrite_options + ' ' return python_cmd @@ -95,16 +101,19 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, # Saved files have full dataset paths, e.g. /scr/biggest/..., so no need to add root_prefix. kwargs['config'] = config_path if not(run_saved): - if not(args.codalab): - kwargs['root_prefix'] = root_prefix - else: + if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir + if args.amulet_option is not None: + kwargs['root_prefix'] = '.' + else: + kwargs['root_prefix'] = root_prefix # On slurm, we need to save locally to avoid overloading the distributed file system. - if not(args.codalab): + if args.codalab or args.amulet_option is not None: + kwargs['log_dir'] = args.log_dir + else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name - else: - kwargs['log_dir'] = args.log_dir + kwargs['project_name'] = project_name kwargs['group_name'] = group_name kwargs['run_name'] = run_name @@ -122,13 +131,16 @@ def config_run(args, kwargs, config_path, run_name, group_name, project_name, config_path=config_path, run_name=run_name, group_name=group_name, project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved, overwrite_options=overwrite_options) - if dataset_copy_cmd is not None and not args.codalab: + if dataset_copy_cmd is not None and not args.codalab and args.amulet_option is None: cmd = dataset_copy_cmd + ' && ' + cmd job_name = group_name + '_' + run_name if os.path.isfile(log_dir + '/stats.tsv') and not(rerun): # TODO: should we rerun if stats.tsv is not completely filled out? # Maybe design this a bit better. + # TODO: handle this for amulet as well. return -1 + elif args.amulet_option is not None: + return job_name, cmd else: return run_job(cmd, job_name, args, deps=deps) @@ -205,6 +217,7 @@ def add_model_to_kwargs(kwargs, args, model): def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], rerun=False, ignore_name_hypers={}, run_name_suffix=''): + """Run one job in sweep (if Amulet, then just return the command to run).""" run_name = hyperparams_to_str(hyperparams, ignore_name_hypers=ignore_name_hypers) run_name += run_name_suffix group_name = get_group_name(adapt_name, dataset.name, args.model_name) @@ -213,7 +226,7 @@ def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], reru add_model_to_kwargs(kwargs, args, model) config_path = get_config_path(args, dataset.config_rel_path) dataset_copy_cmd = None - if dataset.slurm_data_cmd is not None: + if dataset.slurm_data_cmd is not None and args.amulet_option is None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) overwrite_options = dataset.overwrite_options @@ -258,6 +271,40 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids +def get_amlt_config(experiment_name, job_names, cmds, args=None): + # Returns an amulet config for a sweep. + amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" + if args.amulet_cluster == 'amlk8s': + amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' + elif args.amulet_cluster == 'sing' or args.amulet_cluster == 'sing_basic': + amlt_config_path = 'scripts/amlt_config_template_sing.yaml' + else: + raise ValueError(f'Unknown cluster {args.cluster}') + with open(amlt_config_path, "r") as f: + amlt_config += f.read() + for job_name, cmd in zip(job_names, cmds): + amlt_config += " - name: " + job_name + "\n" + amlt_config += " sku: G1-V100\n" + if args.amulet_cluster == 'sing_basic': + amlt_config += " sla_tier: basic\n" + amlt_config += " command:\n" + amlt_config += " - " + cmd + "\n" + return amlt_config + + +def run_amlt_config(amlt_config, experiment_name, args, preemptible=False): + # Save the config to amlt_configs, and then run the script. + config_path = "amlt_configs/generated/" + experiment_name + '.yaml' + os.makedirs(os.path.dirname(config_path), exist_ok=True) + with open(config_path, "w") as f: + f.write(amlt_config) + # This echo trick gets rid of the prompt! + # Note: this preemptible option is for amltk8s, not sing. + cmd = "echo '\n' | amlt run -y " + config_path + " " + experiment_name # + " -t ms-shared --preemptible" + # Run config. + print_os_system(cmd, args) + + def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replications, args, deps=[], replication_hyperparams_list=[], rerun=False, ignore_name_hypers={}): @@ -276,7 +323,22 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati # Job id of -1 means we didn't run the job because it's already run. if job_id != -1: sweep_ids.append(job_id) - return sweep_ids + experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) + if args.amulet_option == 'run': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + job_names, cmds = list(zip(*sweep_ids)) + print(job_names) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + run_amlt_config(amlt_config, experiment_name, args) + elif args.amulet_option == 'cancel': + print_os_system('amlt cancel -y ' + experiment_name, args) + elif args.amulet_option == 'results': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + else: + assert(args.amulet_option is None) + return sweep_ids def adaptation_replication(adapt_name, dataset, model, num_replications, args, deps=[], @@ -1177,7 +1239,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'default_test_args.target_attribute', 'train_dataset.args.target_attribute'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_celeba_experiments(args, linear_probe=True): @@ -1327,7 +1390,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_mixup_sweep_experiments(args, num_replications=3): @@ -1400,7 +1464,8 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u all_ids = linprobe_experiment( adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def linprobe_experiments_no_aug(args, num_replications=3): @@ -1480,7 +1545,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def lp_then_ft_valmode_experiments(args, num_replications=3): @@ -1600,6 +1666,9 @@ def fill_platform_specific_default_args(args): args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if args.pretrained_checkpoints_dir else 'simclr_weights/') + elif args.amulet_option is not None: + args.log_dir = '$$AMLT_OUTPUT_DIR/' + args.pretrained_checkpoints_dir = '/mnt/default/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if @@ -1619,6 +1688,11 @@ def fill_platform_specific_default_args(args): help='Class name of optimizer to use, e.g., torch.optim.Adam') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--amulet_option', type=str, required=False, default=None, + help='{run/cancel/results} to use amulet cluster to perform corresponding operation.') + parser.add_argument('--amulet_cluster', type=str, required=False, default='sing', + help='What amulet cluster to run on? Only relevant if amulet_option is not None. Options:' + '(sing/amlk8s/sing_basic)') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', From 3b5504de47a3be4d819bf80a1d740834fae02a06 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 1 Sep 2022 17:48:53 -0700 Subject: [PATCH 106/197] Add amulet sweep capability. --- .amltignore | 1 + scripts/run_adaptation_experiments.py | 104 ++++++++++++++++++++++---- 2 files changed, 90 insertions(+), 15 deletions(-) diff --git a/.amltignore b/.amltignore index fb7bc62..6cccde4 100644 --- a/.amltignore +++ b/.amltignore @@ -1,2 +1,3 @@ **logs** **amlt_results** +**amlt_configs** diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 16077a9..77ebb9b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -11,6 +11,12 @@ DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' +def print_os_system(cmd, args): + print("Running OS command: " + cmd) + if not args.print_command: + os.system(cmd) + + def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): output_path = args.output_dir + '/' + job_name sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name @@ -76,8 +82,8 @@ def get_python_cmd(code_path, python_path='python', kwargs=None, args=None, over opts = '' python_cmd = python_path + ' ' + code_path + ' ' python_cmd += opts - if args.codalab: - python_cmd += ' --nowandb ' + if args.codalab or args.amulet_option is not None: + python_cmd += ' --no_wandb ' if overwrite_options is not None: python_cmd += ' ' + overwrite_options + ' ' return python_cmd @@ -95,16 +101,19 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, # Saved files have full dataset paths, e.g. /scr/biggest/..., so no need to add root_prefix. kwargs['config'] = config_path if not(run_saved): - if not(args.codalab): - kwargs['root_prefix'] = root_prefix - else: + if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir + if args.amulet_option is not None: + kwargs['root_prefix'] = '.' + else: + kwargs['root_prefix'] = root_prefix # On slurm, we need to save locally to avoid overloading the distributed file system. - if not(args.codalab): + if args.codalab or args.amulet_option is not None: + kwargs['log_dir'] = args.log_dir + else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name - else: - kwargs['log_dir'] = args.log_dir + kwargs['project_name'] = project_name kwargs['group_name'] = group_name kwargs['run_name'] = run_name @@ -122,13 +131,16 @@ def config_run(args, kwargs, config_path, run_name, group_name, project_name, config_path=config_path, run_name=run_name, group_name=group_name, project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved, overwrite_options=overwrite_options) - if dataset_copy_cmd is not None and not args.codalab: + if dataset_copy_cmd is not None and not args.codalab and args.amulet_option is None: cmd = dataset_copy_cmd + ' && ' + cmd job_name = group_name + '_' + run_name if os.path.isfile(log_dir + '/stats.tsv') and not(rerun): # TODO: should we rerun if stats.tsv is not completely filled out? # Maybe design this a bit better. + # TODO: handle this for amulet as well. return -1 + elif args.amulet_option is not None: + return job_name, cmd else: return run_job(cmd, job_name, args, deps=deps) @@ -205,6 +217,7 @@ def add_model_to_kwargs(kwargs, args, model): def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], rerun=False, ignore_name_hypers={}, run_name_suffix=''): + """Run one job in sweep (if Amulet, then just return the command to run).""" run_name = hyperparams_to_str(hyperparams, ignore_name_hypers=ignore_name_hypers) run_name += run_name_suffix group_name = get_group_name(adapt_name, dataset.name, args.model_name) @@ -213,7 +226,7 @@ def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], reru add_model_to_kwargs(kwargs, args, model) config_path = get_config_path(args, dataset.config_rel_path) dataset_copy_cmd = None - if dataset.slurm_data_cmd is not None: + if dataset.slurm_data_cmd is not None and args.amulet_option is None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) overwrite_options = dataset.overwrite_options @@ -258,6 +271,40 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids +def get_amlt_config(experiment_name, job_names, cmds, args=None): + # Returns an amulet config for a sweep. + amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" + if args.amulet_cluster == 'amlk8s': + amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' + elif args.amulet_cluster == 'sing' or args.amulet_cluster == 'sing_basic': + amlt_config_path = 'scripts/amlt_config_template_sing.yaml' + else: + raise ValueError(f'Unknown cluster {args.cluster}') + with open(amlt_config_path, "r") as f: + amlt_config += f.read() + for job_name, cmd in zip(job_names, cmds): + amlt_config += " - name: " + job_name + "\n" + amlt_config += " sku: G1-V100\n" + if args.amulet_cluster == 'sing_basic': + amlt_config += " sla_tier: basic\n" + amlt_config += " command:\n" + amlt_config += " - " + cmd + "\n" + return amlt_config + + +def run_amlt_config(amlt_config, experiment_name, args, preemptible=False): + # Save the config to amlt_configs, and then run the script. + config_path = "amlt_configs/generated/" + experiment_name + '.yaml' + os.makedirs(os.path.dirname(config_path), exist_ok=True) + with open(config_path, "w") as f: + f.write(amlt_config) + # This echo trick gets rid of the prompt! + # Note: this preemptible option is for amltk8s, not sing. + cmd = "echo '\n' | amlt run -y " + config_path + " " + experiment_name # + " -t ms-shared --preemptible" + # Run config. + print_os_system(cmd, args) + + def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replications, args, deps=[], replication_hyperparams_list=[], rerun=False, ignore_name_hypers={}): @@ -276,7 +323,22 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati # Job id of -1 means we didn't run the job because it's already run. if job_id != -1: sweep_ids.append(job_id) - return sweep_ids + experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) + if args.amulet_option == 'run': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + job_names, cmds = list(zip(*sweep_ids)) + print(job_names) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + run_amlt_config(amlt_config, experiment_name, args) + elif args.amulet_option == 'cancel': + print_os_system('amlt cancel -y ' + experiment_name, args) + elif args.amulet_option == 'results': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + else: + assert(args.amulet_option is None) + return sweep_ids def adaptation_replication(adapt_name, dataset, model, num_replications, args, deps=[], @@ -1177,7 +1239,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'default_test_args.target_attribute', 'train_dataset.args.target_attribute'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_celeba_experiments(args, linear_probe=True): @@ -1327,7 +1390,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_mixup_sweep_experiments(args, num_replications=3): @@ -1400,7 +1464,8 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u all_ids = linprobe_experiment( adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def linprobe_experiments_no_aug(args, num_replications=3): @@ -1480,7 +1545,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def lp_then_ft_valmode_experiments(args, num_replications=3): @@ -1600,6 +1666,9 @@ def fill_platform_specific_default_args(args): args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if args.pretrained_checkpoints_dir else 'simclr_weights/') + elif args.amulet_option is not None: + args.log_dir = '$$AMLT_OUTPUT_DIR/' + args.pretrained_checkpoints_dir = '/mnt/default/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if @@ -1619,6 +1688,11 @@ def fill_platform_specific_default_args(args): help='Class name of optimizer to use, e.g., torch.optim.Adam') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--amulet_option', type=str, required=False, default=None, + help='{run/cancel/results} to use amulet cluster to perform corresponding operation.') + parser.add_argument('--amulet_cluster', type=str, required=False, default='sing', + help='What amulet cluster to run on? Only relevant if amulet_option is not None. Options:' + '(sing/amlk8s/sing_basic)') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', From 879effa648f8421fa42aee7a092c688a913d10c5 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Thu, 1 Sep 2022 17:48:53 -0700 Subject: [PATCH 107/197] Add amulet sweep capability. --- .amltignore | 1 + scripts/amlt_config_template_amlk8s.yaml | 4 - scripts/amlt_config_template_sing.yaml | 5 +- scripts/run_adaptation_experiments.py | 104 +++++++++++++++++++---- 4 files changed, 91 insertions(+), 23 deletions(-) diff --git a/.amltignore b/.amltignore index fb7bc62..6cccde4 100644 --- a/.amltignore +++ b/.amltignore @@ -1,2 +1,3 @@ **logs** **amlt_results** +**amlt_configs** diff --git a/scripts/amlt_config_template_amlk8s.yaml b/scripts/amlt_config_template_amlk8s.yaml index a5c6788..b0c6fc8 100644 --- a/scripts/amlt_config_template_amlk8s.yaml +++ b/scripts/amlt_config_template_amlk8s.yaml @@ -22,7 +22,3 @@ code: # data upload is not required for this example jobs: - - name: test_job - sku: G1-V100-P100 - command: - - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=$$AMLT_OUTPUT_DIR --batch_size=16 --train_dataset.args.download=True --no_wandb diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml index 5d9f4e1..f5ad2e4 100644 --- a/scripts/amlt_config_template_sing.yaml +++ b/scripts/amlt_config_template_sing.yaml @@ -19,7 +19,4 @@ code: # data upload is not required for this example jobs: - - name: test_job - sku: G1-V100-P100 - command: - - python unlabeled_extrapolation/baseline_train.py --config=configs/adaptation/waterbirds.yaml --root_prefix=. --log_dir=$$AMLT_OUTPUT_DIR --batch_size=16 --train_dataset.args.download=True --no_wandb + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 16077a9..77ebb9b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -11,6 +11,12 @@ DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' +def print_os_system(cmd, args): + print("Running OS command: " + cmd) + if not args.print_command: + os.system(cmd) + + def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): output_path = args.output_dir + '/' + job_name sbatch_script_path = args.scripts_dir + '/' + args.sbatch_script_name @@ -76,8 +82,8 @@ def get_python_cmd(code_path, python_path='python', kwargs=None, args=None, over opts = '' python_cmd = python_path + ' ' + code_path + ' ' python_cmd += opts - if args.codalab: - python_cmd += ' --nowandb ' + if args.codalab or args.amulet_option is not None: + python_cmd += ' --no_wandb ' if overwrite_options is not None: python_cmd += ' ' + overwrite_options + ' ' return python_cmd @@ -95,16 +101,19 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, # Saved files have full dataset paths, e.g. /scr/biggest/..., so no need to add root_prefix. kwargs['config'] = config_path if not(run_saved): - if not(args.codalab): - kwargs['root_prefix'] = root_prefix - else: + if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir + if args.amulet_option is not None: + kwargs['root_prefix'] = '.' + else: + kwargs['root_prefix'] = root_prefix # On slurm, we need to save locally to avoid overloading the distributed file system. - if not(args.codalab): + if args.codalab or args.amulet_option is not None: + kwargs['log_dir'] = args.log_dir + else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name - else: - kwargs['log_dir'] = args.log_dir + kwargs['project_name'] = project_name kwargs['group_name'] = group_name kwargs['run_name'] = run_name @@ -122,13 +131,16 @@ def config_run(args, kwargs, config_path, run_name, group_name, project_name, config_path=config_path, run_name=run_name, group_name=group_name, project_name=project_name, root_prefix=root_prefix, kwargs=kwargs, args=args, run_saved=run_saved, overwrite_options=overwrite_options) - if dataset_copy_cmd is not None and not args.codalab: + if dataset_copy_cmd is not None and not args.codalab and args.amulet_option is None: cmd = dataset_copy_cmd + ' && ' + cmd job_name = group_name + '_' + run_name if os.path.isfile(log_dir + '/stats.tsv') and not(rerun): # TODO: should we rerun if stats.tsv is not completely filled out? # Maybe design this a bit better. + # TODO: handle this for amulet as well. return -1 + elif args.amulet_option is not None: + return job_name, cmd else: return run_job(cmd, job_name, args, deps=deps) @@ -205,6 +217,7 @@ def add_model_to_kwargs(kwargs, args, model): def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], rerun=False, ignore_name_hypers={}, run_name_suffix=''): + """Run one job in sweep (if Amulet, then just return the command to run).""" run_name = hyperparams_to_str(hyperparams, ignore_name_hypers=ignore_name_hypers) run_name += run_name_suffix group_name = get_group_name(adapt_name, dataset.name, args.model_name) @@ -213,7 +226,7 @@ def run_adapt_sweep(adapt_name, dataset, model, hyperparams, args, deps=[], reru add_model_to_kwargs(kwargs, args, model) config_path = get_config_path(args, dataset.config_rel_path) dataset_copy_cmd = None - if dataset.slurm_data_cmd is not None: + if dataset.slurm_data_cmd is not None and args.amulet_option is None: dataset_copy_cmd = dataset.slurm_data_cmd.format(scripts_dir=args.scripts_dir) deps = add_dataset_model_deps(deps, args, dataset, model) overwrite_options = dataset.overwrite_options @@ -258,6 +271,40 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids +def get_amlt_config(experiment_name, job_names, cmds, args=None): + # Returns an amulet config for a sweep. + amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" + if args.amulet_cluster == 'amlk8s': + amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' + elif args.amulet_cluster == 'sing' or args.amulet_cluster == 'sing_basic': + amlt_config_path = 'scripts/amlt_config_template_sing.yaml' + else: + raise ValueError(f'Unknown cluster {args.cluster}') + with open(amlt_config_path, "r") as f: + amlt_config += f.read() + for job_name, cmd in zip(job_names, cmds): + amlt_config += " - name: " + job_name + "\n" + amlt_config += " sku: G1-V100\n" + if args.amulet_cluster == 'sing_basic': + amlt_config += " sla_tier: basic\n" + amlt_config += " command:\n" + amlt_config += " - " + cmd + "\n" + return amlt_config + + +def run_amlt_config(amlt_config, experiment_name, args, preemptible=False): + # Save the config to amlt_configs, and then run the script. + config_path = "amlt_configs/generated/" + experiment_name + '.yaml' + os.makedirs(os.path.dirname(config_path), exist_ok=True) + with open(config_path, "w") as f: + f.write(amlt_config) + # This echo trick gets rid of the prompt! + # Note: this preemptible option is for amltk8s, not sing. + cmd = "echo '\n' | amlt run -y " + config_path + " " + experiment_name # + " -t ms-shared --preemptible" + # Run config. + print_os_system(cmd, args) + + def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replications, args, deps=[], replication_hyperparams_list=[], rerun=False, ignore_name_hypers={}): @@ -276,7 +323,22 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati # Job id of -1 means we didn't run the job because it's already run. if job_id != -1: sweep_ids.append(job_id) - return sweep_ids + experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) + if args.amulet_option == 'run': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + job_names, cmds = list(zip(*sweep_ids)) + print(job_names) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + run_amlt_config(amlt_config, experiment_name, args) + elif args.amulet_option == 'cancel': + print_os_system('amlt cancel -y ' + experiment_name, args) + elif args.amulet_option == 'results': + print_os_system('amlt results ' + experiment_name, args) + print_os_system('amlt logs ' + experiment_name, args) + else: + assert(args.amulet_option is None) + return sweep_ids def adaptation_replication(adapt_name, dataset, model, num_replications, args, deps=[], @@ -1177,7 +1239,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'checkpoint_path', 'default_test_args.target_attribute', 'train_dataset.args.target_attribute'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_celeba_experiments(args, linear_probe=True): @@ -1327,7 +1390,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def fine_tuning_mixup_sweep_experiments(args, num_replications=3): @@ -1400,7 +1464,8 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u all_ids = linprobe_experiment( adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def linprobe_experiments_no_aug(args, num_replications=3): @@ -1480,7 +1545,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) - print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + if all_ids is not None: + print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) def lp_then_ft_valmode_experiments(args, num_replications=3): @@ -1600,6 +1666,9 @@ def fill_platform_specific_default_args(args): args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if args.pretrained_checkpoints_dir else 'simclr_weights/') + elif args.amulet_option is not None: + args.log_dir = '$$AMLT_OUTPUT_DIR/' + args.pretrained_checkpoints_dir = '/mnt/default/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if @@ -1619,6 +1688,11 @@ def fill_platform_specific_default_args(args): help='Class name of optimizer to use, e.g., torch.optim.Adam') # Note that store_true creates a default value of False. parser.add_argument('--codalab', action='store_true', help='run on CodaLab not slurm') + parser.add_argument('--amulet_option', type=str, required=False, default=None, + help='{run/cancel/results} to use amulet cluster to perform corresponding operation.') + parser.add_argument('--amulet_cluster', type=str, required=False, default='sing', + help='What amulet cluster to run on? Only relevant if amulet_option is not None. Options:' + '(sing/amlk8s/sing_basic)') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', From 0862ea5d8d4ade0811795cd1decb74c274bb0254 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 6 Sep 2022 14:53:16 -0700 Subject: [PATCH 108/197] Fix edge case with batch splitting, and add timm model --- configs/adaptation/domainnet.yaml | 1 + configs/adaptation/living17_nonorm.yaml | 2 + configs/adaptation/waterbirds.yaml | 1 + scripts/load_models_get_layers.ipynb | 168 +++++++-- scripts/run_adaptation_experiments.py | 9 + unlabeled_extrapolation/baseline_train.py | 7 +- unlabeled_extrapolation/models/timm_model.py | 131 +++++++ unlabeled_extrapolation/models/vit_model.py | 343 +++++++++---------- 8 files changed, 460 insertions(+), 202 deletions(-) create mode 100644 unlabeled_extrapolation/models/timm_model.py diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml index 396a50b..c1613bf 100644 --- a/configs/adaptation/domainnet.yaml +++ b/configs/adaptation/domainnet.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 40 epochs: &epochs 50 # Very small dataset so run for longer. batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/configs/adaptation/living17_nonorm.yaml b/configs/adaptation/living17_nonorm.yaml index e345e80..2ff3008 100644 --- a/configs/adaptation/living17_nonorm.yaml +++ b/configs/adaptation/living17_nonorm.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 17 epochs: &epochs 20 save_no_checkpoints: True +batch_size: 32 +batch_splits: 2 model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index fca21e4..f508c49 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 2 epochs: &epochs 20 batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f321b84..f00a5e6 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,27 +2,30 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", + "import timm\n", + "import torch\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", - "importlib.reload(utils)" + "importlib.reload(utils)\n", + "importlib.reload(timm_model)" ] }, { @@ -35,15 +38,14 @@ " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", " print(model.get_layers()[1])\n", " print(len(model.get_layers()))\n", - " model.freeze_bottom_k(k=1)\n", - " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", - " model.freeze_bottom_k(k=2)\n", - " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + " for k in [1, 2, len(model.get_layers())]:\n", + " model.freeze_bottom_k(k=k)\n", + " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -82,8 +84,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 68247251\n", - "num params after freezing 2: 68032339\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params after freezing 6: 0\n", "num params before freezing: 87248787\n", "('conv-block-0', Sequential(\n", " (unit01): PreActBottleneck(\n", @@ -116,8 +119,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 87239379\n", - "num params after freezing 2: 87024467\n" + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n", + "num params after freezing 6: 0\n" ] } ], @@ -135,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -149,23 +153,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "num params before freezing: 85798656\n", + "num params before freezing: 85806346\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 85208064\n", - "num params after freezing 2: 85208064\n" + "1\n", + "num params after freezing 1: 85215754\n", + "2\n", + "num params after freezing 2: 85215754\n", + "54\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# DINO\n", "model = vit_model.VitModel(model_name='dino_vitb16')\n", - "get_layers_freeze_test(model)" + "model.new_last_layer(10)\n", + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -175,25 +184,132 @@ "num params before freezing: 22050664\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 21755368\n", - "num params after freezing 2: 21755368\n" + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# Timm ViT-S\n", "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", - "get_layers_freeze_test(model)" + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 109953489\n", + "('stage0', ConvNeXtStage(\n", + " (downsample): Identity()\n", + " (blocks): Sequential(\n", + " (0): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (1): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (2): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " )\n", + "))\n", + "7\n", + "num params after freezing 1: 109946961\n", + "num params after freezing 2: 109531473\n", + "num params after freezing 7: 0\n" + ] + } + ], "source": [ "# Conv-next\n", - "\n" + "model = timm_model.TimmModel('convnext_base_in22k')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " ...,\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625]],\n", + " device='cuda:0')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = torch.zeros((8,3,224,224))\n", + "x = x.cuda()\n", + "model(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sequential(\n", + " (global_pool): SelectAdaptivePool2d (pool_type=avg, flatten=Identity())\n", + " (norm): LayerNorm2d((1024,), eps=1e-06, elementwise_affine=True)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " (fc): Linear(in_features=1024, out_features=21841, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "print(model._model.head)" ] }, { diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 77ebb9b..6f1fffe 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1072,6 +1072,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +convnext_vit_b = Model( + kwargs={ + 'classname': 'models.timm_model.TimmModel', + 'args.model_name': 'convnext_base_in22k', + }, + bundles=[] +) + bit_resnet_50 = Model( kwargs={ 'classname': 'models.bit_resnet.BitResNet', @@ -1131,6 +1139,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_l14': clip_vit_l14, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, + 'convnext_vit_b': convnext_vit_b, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 4e4a442..516bdf5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -342,11 +342,12 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ del l2sp_loss # Split up the batch so we can do the backward pass on a GPU, accumulate gradients # across the split. + split_size = int(np.ceil(len(all_inputs) / batch_splits)) split_inputs = torch.split( - all_inputs, split_size_or_sections=len(all_inputs) // batch_splits) + all_inputs, split_size_or_sections=split_size) split_labels = torch.split( - all_labels, split_size_or_sections=len(all_labels) // batch_splits) - for j in range(batch_splits): + all_labels, split_size_or_sections=split_size) + for j in range(len(split_inputs)): inputs, labels = split_inputs[j], split_labels[j] if config['use_cuda']: inputs, labels = inputs.to(device), labels.to(device) diff --git a/unlabeled_extrapolation/models/timm_model.py b/unlabeled_extrapolation/models/timm_model.py new file mode 100644 index 0000000..ada423c --- /dev/null +++ b/unlabeled_extrapolation/models/timm_model.py @@ -0,0 +1,131 @@ +# Note: this model does normalization. +# Also supports convnext and potentially some other timm models. TODO: refactor. + +from collections import OrderedDict +import torchvision.models as models +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.models import convnext +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def get_timm_transform(model_name): + config = resolve_data_config({}, model=model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class TimmModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + model = timm.create_model(model_name, pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + if self._device == 'cuda': + model.cuda() + self._model = model + + def forward(self, x): + return self._model(self._normalize_transform(x)) + + def get_layers(self): + if 'vit' in self._model_name: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + elif 'convnext' in self._model_name: + layers = [('stem', self._model.stem)] + blocks = self._model.stages + for i, block in zip(range(len(blocks)), blocks): + layers += [('stage' + str(i), block)] + # The convnext head contains multiple pieces. I checked that all the parameters + # are accounted for by these two components (norm and fc). + layers += [('post_norm', self._model.head.norm)] + layers += [('head', self._model.head.fc)] + else: + raise NotImplementedError('Model currently not implemented') + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'vit' in self._model_name: + num_in_features = self._model.norm.normalized_shape[0] + self._model.head = nn.Linear(num_in_features, num_classes) + elif 'convnext' in self._model_name: + num_in_features = self._model.head.norm.normalized_shape[0] + self._model.head.fc = nn.Linear(num_in_features, num_classes) + else: + raise NotImplementedError('Model currently not implemented') + self._model.head.to(self._device) + + def add_probe(self, probe): + if 'vit' in self._model_name: + self._model.head = probe + elif 'convnext' in self._model_name: + self._model.head.fc = probe + else: + raise NotImplementedError('Model currently not implemented') + + def get_last_layer(self): + if 'vit' in self._model_name: + return self._model.head + elif 'convnext' in self._model_name: + return self._model.head.fc + else: + raise NotImplementedError('Model currently not implemented') + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + raise NotImplementedError('Need to implement this for timm models.') diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 32c2322..6913df5 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -1,173 +1,170 @@ -# Note: this model does normalization. -from collections import OrderedDict -import torchvision.models as models -from torchvision.models import resnet50 -import torch -from torch import nn -from . import model_utils - -import timm -from timm.models import vision_transformer -from timm.data import resolve_data_config - -from torchvision.transforms import Normalize - - -MODELS = { - 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', - 'deit_base_patch16_224', -} - - -default_imnet_normalize = Normalize( - mean=(0.485, 0.456, 0.406), - std=[0.229, 0.224, 0.225]) - - -def set_requires_grad(component, val): - for param in component.parameters(): - param.requires_grad = val - - -def is_timm_vit_name(model_name): - timm_vit_names = vision_transformer.default_cfgs.keys() - return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names - - -def get_timm_name(model_name): - assert model_name.startswith('timm.') - return model_name[5:] - - -def get_timm_transform(model_name): - timm_name = get_timm_name(model_name) - config = resolve_data_config({}, model=model_name) - normalize_transform = Normalize(mean=config['mean'], std=config['std']) - return normalize_transform - - -class VitModel(nn.Module): - - def __init__(self, model_name): - super().__init__() - if model_name not in MODELS and not(is_timm_vit_name(model_name)): - raise ValueError(f'model_name must be in {MODELS} but was {model_name}') - self._model_name = model_name - self._device = "cuda" if torch.cuda.is_available() else "cpu" - # Note that model has both a language and vision part. - if is_timm_vit_name(model_name): - model = timm.create_model(get_timm_name(model_name), pretrained=True) - self._normalize_transform = get_timm_transform(model_name) - elif 'dino' in model_name: - model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) - elif 'deit' in model_name: - model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) - if self._device == 'cuda': - model.cuda() - if 'deit' in model_name: - # deit implementation is not complete, doesn't seem to load properly, and also - # get_layers likely isn't handled correctly. - raise NotImplementedError - self._model = nn.Sequential(*list(model.children())[:-1]) - else: - self._model = model - self._classifier = None - - def forward(self, x): - if is_timm_vit_name(self._model_name): - return self._model(self._normalize_transform(x)) - features = self.get_features(x) - if self._classifier is None: - return features - return self._classifier(features) - - def get_layers(self): - if 'deit' in self._model_name: - patch_embed = self._model[0] - blocks = self._model[2] - else: - pos_embed = self._model.pos_embed - cls_token = self._model.cls_token - patch_embed = self._model.patch_embed - blocks = self._model.blocks - layers = [ - ('patch_embed', patch_embed), - ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. - ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), - ('cls_token', model_utils.ParamWrapperModule(cls_token)), - ] - for i, block in zip(range(len(blocks)), blocks): - layers += [ - ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn', block.attn), - ('trans' + str(i) + '_norm2', block.norm2), - ('trans' + str(i) + '_mlp', block.mlp), - ] - if 'dino' not in self._model_name: - layers += [('post_norm', self._model.norm)] - else: - layers += [('empty_post_norm', nn.Module())] - layers += [('head', self.get_last_layer())] - return layers - - def tune_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - if k > len(layers): - raise ValueError(f"k {k} should be less than number of layers {len(layers)}") - set_requires_grad(self._model, False) - for i in range(k): - set_requires_grad(layers[i], True) - # Also need to tune the prediction head because the fine-tuning task is different - # from pretraining. - set_requires_grad(layers[-1], True) - - def freeze_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - for i in range(min(k, len(layers))): - set_requires_grad(layers[i], False) - - def set_requires_grad(self, val): - for param in self._model.parameters(): - param.requires_grad = val - if self._classifier is not None: - for param in self._classifier.parameters(): - param.requires_grad = val - - def new_last_layer(self, num_classes): - if 'deit' in self._model_name: - num_in_features = self._model[3].normalized_shape[0] - else: - num_in_features = self._model.norm.normalized_shape[0] - if is_timm_vit_name(self._model_name): - self._model.head = nn.Linear(num_in_features, num_classes) - self._model.head.to(self._device) - else: - self._classifier = nn.Linear(num_in_features, num_classes) - self._classifier.to(self._device) - - def add_probe(self, probe): - if is_timm_vit_name(self._model_name): - self._model.head = probe - else: - self._classifier = probe - - def get_last_layer(self): - if is_timm_vit_name(self._model_name): - return self._model.head - else: - return self._classifier - - def set_last_layer(self, coef, intercept): - model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) - - def get_feature_extractor(self): - raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') - - def get_features(self, x): - # The normalize transform for Deit is standard imagenet transform. See: - # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls - # the timm library create_transform, which uses these imagenet defaults. - if is_timm_vit_name(self._model_name): - raise NotImplementedError('Need to implement this for timm models.') - else: - return self._model(default_imnet_normalize(x)) +# Note: this model does normalization. +from collections import OrderedDict +import torchvision.models as models +from torchvision.models import resnet50 +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + + +MODELS = { + 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', + 'deit_base_patch16_224', +} + + +default_imnet_normalize = Normalize( + mean=(0.485, 0.456, 0.406), + std=[0.229, 0.224, 0.225]) + + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def is_timm_vit_name(model_name): + timm_vit_names = vision_transformer.default_cfgs.keys() + return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names + + +def get_timm_name(model_name): + assert model_name.startswith('timm.') + return model_name[5:] + + +def get_timm_transform(model_name): + timm_name = get_timm_name(model_name) + config = resolve_data_config({}, model=timm_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class VitModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + if model_name not in MODELS and not(is_timm_vit_name(model_name)): + raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + # Note that model has both a language and vision part. + if is_timm_vit_name(model_name): + model = timm.create_model(get_timm_name(model_name), pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + elif 'dino' in model_name: + model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) + elif 'deit' in model_name: + model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) + if self._device == 'cuda': + model.cuda() + if 'deit' in model_name: + # deit implementation is not complete, doesn't seem to load properly, and also + # get_layers likely isn't handled correctly. + raise NotImplementedError + self._model = nn.Sequential(*list(model.children())[:-1]) + else: + self._model = model + self._classifier = None + + def forward(self, x): + if is_timm_vit_name(self._model_name): + return self._model(self._normalize_transform(x)) + features = self.get_features(x) + if self._classifier is None: + return features + return self._classifier(features) + + def get_layers(self): + if 'deit' in self._model_name: + patch_embed = self._model[0] + blocks = self._model[2] + else: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + if self._classifier is not None: + for param in self._classifier.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'deit' in self._model_name: + num_in_features = self._model[3].normalized_shape[0] + else: + num_in_features = self._model.norm.normalized_shape[0] + if is_timm_vit_name(self._model_name): + self._model.head = nn.Linear(num_in_features, num_classes) + self._model.head.to(self._device) + else: + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) + + def add_probe(self, probe): + if is_timm_vit_name(self._model_name): + self._model.head = probe + else: + self._classifier = probe + + def get_last_layer(self): + if is_timm_vit_name(self._model_name): + return self._model.head + else: + return self._classifier + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + # The normalize transform for Deit is standard imagenet transform. See: + # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls + # the timm library create_transform, which uses these imagenet defaults. + if is_timm_vit_name(self._model_name): + raise NotImplementedError('Need to implement this for timm models.') + else: + return self._model(default_imnet_normalize(x)) From fd42695b7fb0035d1f9cc59e2d56193668415137 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 6 Sep 2022 14:53:16 -0700 Subject: [PATCH 109/197] Fix edge case with batch splitting, and add timm model --- configs/adaptation/domainnet.yaml | 1 + configs/adaptation/living17_nonorm.yaml | 2 + configs/adaptation/waterbirds.yaml | 1 + scripts/load_models_get_layers.ipynb | 168 +++++++-- scripts/run_adaptation_experiments.py | 9 + unlabeled_extrapolation/baseline_train.py | 7 +- unlabeled_extrapolation/models/timm_model.py | 131 +++++++ unlabeled_extrapolation/models/vit_model.py | 343 +++++++++---------- 8 files changed, 460 insertions(+), 202 deletions(-) create mode 100644 unlabeled_extrapolation/models/timm_model.py diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml index 396a50b..c1613bf 100644 --- a/configs/adaptation/domainnet.yaml +++ b/configs/adaptation/domainnet.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 40 epochs: &epochs 50 # Very small dataset so run for longer. batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/configs/adaptation/living17_nonorm.yaml b/configs/adaptation/living17_nonorm.yaml index e345e80..2ff3008 100644 --- a/configs/adaptation/living17_nonorm.yaml +++ b/configs/adaptation/living17_nonorm.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 17 epochs: &epochs 20 save_no_checkpoints: True +batch_size: 32 +batch_splits: 2 model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index fca21e4..f508c49 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 2 epochs: &epochs 20 batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f321b84..f00a5e6 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,27 +2,30 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", + "import timm\n", + "import torch\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", - "importlib.reload(utils)" + "importlib.reload(utils)\n", + "importlib.reload(timm_model)" ] }, { @@ -35,15 +38,14 @@ " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", " print(model.get_layers()[1])\n", " print(len(model.get_layers()))\n", - " model.freeze_bottom_k(k=1)\n", - " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", - " model.freeze_bottom_k(k=2)\n", - " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + " for k in [1, 2, len(model.get_layers())]:\n", + " model.freeze_bottom_k(k=k)\n", + " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -82,8 +84,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 68247251\n", - "num params after freezing 2: 68032339\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params after freezing 6: 0\n", "num params before freezing: 87248787\n", "('conv-block-0', Sequential(\n", " (unit01): PreActBottleneck(\n", @@ -116,8 +119,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 87239379\n", - "num params after freezing 2: 87024467\n" + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n", + "num params after freezing 6: 0\n" ] } ], @@ -135,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -149,23 +153,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "num params before freezing: 85798656\n", + "num params before freezing: 85806346\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 85208064\n", - "num params after freezing 2: 85208064\n" + "1\n", + "num params after freezing 1: 85215754\n", + "2\n", + "num params after freezing 2: 85215754\n", + "54\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# DINO\n", "model = vit_model.VitModel(model_name='dino_vitb16')\n", - "get_layers_freeze_test(model)" + "model.new_last_layer(10)\n", + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -175,25 +184,132 @@ "num params before freezing: 22050664\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 21755368\n", - "num params after freezing 2: 21755368\n" + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# Timm ViT-S\n", "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", - "get_layers_freeze_test(model)" + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 109953489\n", + "('stage0', ConvNeXtStage(\n", + " (downsample): Identity()\n", + " (blocks): Sequential(\n", + " (0): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (1): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (2): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " )\n", + "))\n", + "7\n", + "num params after freezing 1: 109946961\n", + "num params after freezing 2: 109531473\n", + "num params after freezing 7: 0\n" + ] + } + ], "source": [ "# Conv-next\n", - "\n" + "model = timm_model.TimmModel('convnext_base_in22k')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " ...,\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625]],\n", + " device='cuda:0')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = torch.zeros((8,3,224,224))\n", + "x = x.cuda()\n", + "model(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sequential(\n", + " (global_pool): SelectAdaptivePool2d (pool_type=avg, flatten=Identity())\n", + " (norm): LayerNorm2d((1024,), eps=1e-06, elementwise_affine=True)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " (fc): Linear(in_features=1024, out_features=21841, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "print(model._model.head)" ] }, { diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 77ebb9b..6f1fffe 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1072,6 +1072,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +convnext_vit_b = Model( + kwargs={ + 'classname': 'models.timm_model.TimmModel', + 'args.model_name': 'convnext_base_in22k', + }, + bundles=[] +) + bit_resnet_50 = Model( kwargs={ 'classname': 'models.bit_resnet.BitResNet', @@ -1131,6 +1139,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_l14': clip_vit_l14, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, + 'convnext_vit_b': convnext_vit_b, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 4e4a442..516bdf5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -342,11 +342,12 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ del l2sp_loss # Split up the batch so we can do the backward pass on a GPU, accumulate gradients # across the split. + split_size = int(np.ceil(len(all_inputs) / batch_splits)) split_inputs = torch.split( - all_inputs, split_size_or_sections=len(all_inputs) // batch_splits) + all_inputs, split_size_or_sections=split_size) split_labels = torch.split( - all_labels, split_size_or_sections=len(all_labels) // batch_splits) - for j in range(batch_splits): + all_labels, split_size_or_sections=split_size) + for j in range(len(split_inputs)): inputs, labels = split_inputs[j], split_labels[j] if config['use_cuda']: inputs, labels = inputs.to(device), labels.to(device) diff --git a/unlabeled_extrapolation/models/timm_model.py b/unlabeled_extrapolation/models/timm_model.py new file mode 100644 index 0000000..ada423c --- /dev/null +++ b/unlabeled_extrapolation/models/timm_model.py @@ -0,0 +1,131 @@ +# Note: this model does normalization. +# Also supports convnext and potentially some other timm models. TODO: refactor. + +from collections import OrderedDict +import torchvision.models as models +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.models import convnext +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def get_timm_transform(model_name): + config = resolve_data_config({}, model=model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class TimmModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + model = timm.create_model(model_name, pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + if self._device == 'cuda': + model.cuda() + self._model = model + + def forward(self, x): + return self._model(self._normalize_transform(x)) + + def get_layers(self): + if 'vit' in self._model_name: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + elif 'convnext' in self._model_name: + layers = [('stem', self._model.stem)] + blocks = self._model.stages + for i, block in zip(range(len(blocks)), blocks): + layers += [('stage' + str(i), block)] + # The convnext head contains multiple pieces. I checked that all the parameters + # are accounted for by these two components (norm and fc). + layers += [('post_norm', self._model.head.norm)] + layers += [('head', self._model.head.fc)] + else: + raise NotImplementedError('Model currently not implemented') + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'vit' in self._model_name: + num_in_features = self._model.norm.normalized_shape[0] + self._model.head = nn.Linear(num_in_features, num_classes) + elif 'convnext' in self._model_name: + num_in_features = self._model.head.norm.normalized_shape[0] + self._model.head.fc = nn.Linear(num_in_features, num_classes) + else: + raise NotImplementedError('Model currently not implemented') + self._model.head.to(self._device) + + def add_probe(self, probe): + if 'vit' in self._model_name: + self._model.head = probe + elif 'convnext' in self._model_name: + self._model.head.fc = probe + else: + raise NotImplementedError('Model currently not implemented') + + def get_last_layer(self): + if 'vit' in self._model_name: + return self._model.head + elif 'convnext' in self._model_name: + return self._model.head.fc + else: + raise NotImplementedError('Model currently not implemented') + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + raise NotImplementedError('Need to implement this for timm models.') diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 32c2322..6913df5 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -1,173 +1,170 @@ -# Note: this model does normalization. -from collections import OrderedDict -import torchvision.models as models -from torchvision.models import resnet50 -import torch -from torch import nn -from . import model_utils - -import timm -from timm.models import vision_transformer -from timm.data import resolve_data_config - -from torchvision.transforms import Normalize - - -MODELS = { - 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', - 'deit_base_patch16_224', -} - - -default_imnet_normalize = Normalize( - mean=(0.485, 0.456, 0.406), - std=[0.229, 0.224, 0.225]) - - -def set_requires_grad(component, val): - for param in component.parameters(): - param.requires_grad = val - - -def is_timm_vit_name(model_name): - timm_vit_names = vision_transformer.default_cfgs.keys() - return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names - - -def get_timm_name(model_name): - assert model_name.startswith('timm.') - return model_name[5:] - - -def get_timm_transform(model_name): - timm_name = get_timm_name(model_name) - config = resolve_data_config({}, model=model_name) - normalize_transform = Normalize(mean=config['mean'], std=config['std']) - return normalize_transform - - -class VitModel(nn.Module): - - def __init__(self, model_name): - super().__init__() - if model_name not in MODELS and not(is_timm_vit_name(model_name)): - raise ValueError(f'model_name must be in {MODELS} but was {model_name}') - self._model_name = model_name - self._device = "cuda" if torch.cuda.is_available() else "cpu" - # Note that model has both a language and vision part. - if is_timm_vit_name(model_name): - model = timm.create_model(get_timm_name(model_name), pretrained=True) - self._normalize_transform = get_timm_transform(model_name) - elif 'dino' in model_name: - model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) - elif 'deit' in model_name: - model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) - if self._device == 'cuda': - model.cuda() - if 'deit' in model_name: - # deit implementation is not complete, doesn't seem to load properly, and also - # get_layers likely isn't handled correctly. - raise NotImplementedError - self._model = nn.Sequential(*list(model.children())[:-1]) - else: - self._model = model - self._classifier = None - - def forward(self, x): - if is_timm_vit_name(self._model_name): - return self._model(self._normalize_transform(x)) - features = self.get_features(x) - if self._classifier is None: - return features - return self._classifier(features) - - def get_layers(self): - if 'deit' in self._model_name: - patch_embed = self._model[0] - blocks = self._model[2] - else: - pos_embed = self._model.pos_embed - cls_token = self._model.cls_token - patch_embed = self._model.patch_embed - blocks = self._model.blocks - layers = [ - ('patch_embed', patch_embed), - ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. - ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), - ('cls_token', model_utils.ParamWrapperModule(cls_token)), - ] - for i, block in zip(range(len(blocks)), blocks): - layers += [ - ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn', block.attn), - ('trans' + str(i) + '_norm2', block.norm2), - ('trans' + str(i) + '_mlp', block.mlp), - ] - if 'dino' not in self._model_name: - layers += [('post_norm', self._model.norm)] - else: - layers += [('empty_post_norm', nn.Module())] - layers += [('head', self.get_last_layer())] - return layers - - def tune_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - if k > len(layers): - raise ValueError(f"k {k} should be less than number of layers {len(layers)}") - set_requires_grad(self._model, False) - for i in range(k): - set_requires_grad(layers[i], True) - # Also need to tune the prediction head because the fine-tuning task is different - # from pretraining. - set_requires_grad(layers[-1], True) - - def freeze_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - for i in range(min(k, len(layers))): - set_requires_grad(layers[i], False) - - def set_requires_grad(self, val): - for param in self._model.parameters(): - param.requires_grad = val - if self._classifier is not None: - for param in self._classifier.parameters(): - param.requires_grad = val - - def new_last_layer(self, num_classes): - if 'deit' in self._model_name: - num_in_features = self._model[3].normalized_shape[0] - else: - num_in_features = self._model.norm.normalized_shape[0] - if is_timm_vit_name(self._model_name): - self._model.head = nn.Linear(num_in_features, num_classes) - self._model.head.to(self._device) - else: - self._classifier = nn.Linear(num_in_features, num_classes) - self._classifier.to(self._device) - - def add_probe(self, probe): - if is_timm_vit_name(self._model_name): - self._model.head = probe - else: - self._classifier = probe - - def get_last_layer(self): - if is_timm_vit_name(self._model_name): - return self._model.head - else: - return self._classifier - - def set_last_layer(self, coef, intercept): - model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) - - def get_feature_extractor(self): - raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') - - def get_features(self, x): - # The normalize transform for Deit is standard imagenet transform. See: - # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls - # the timm library create_transform, which uses these imagenet defaults. - if is_timm_vit_name(self._model_name): - raise NotImplementedError('Need to implement this for timm models.') - else: - return self._model(default_imnet_normalize(x)) +# Note: this model does normalization. +from collections import OrderedDict +import torchvision.models as models +from torchvision.models import resnet50 +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + + +MODELS = { + 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', + 'deit_base_patch16_224', +} + + +default_imnet_normalize = Normalize( + mean=(0.485, 0.456, 0.406), + std=[0.229, 0.224, 0.225]) + + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def is_timm_vit_name(model_name): + timm_vit_names = vision_transformer.default_cfgs.keys() + return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names + + +def get_timm_name(model_name): + assert model_name.startswith('timm.') + return model_name[5:] + + +def get_timm_transform(model_name): + timm_name = get_timm_name(model_name) + config = resolve_data_config({}, model=timm_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class VitModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + if model_name not in MODELS and not(is_timm_vit_name(model_name)): + raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + # Note that model has both a language and vision part. + if is_timm_vit_name(model_name): + model = timm.create_model(get_timm_name(model_name), pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + elif 'dino' in model_name: + model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) + elif 'deit' in model_name: + model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) + if self._device == 'cuda': + model.cuda() + if 'deit' in model_name: + # deit implementation is not complete, doesn't seem to load properly, and also + # get_layers likely isn't handled correctly. + raise NotImplementedError + self._model = nn.Sequential(*list(model.children())[:-1]) + else: + self._model = model + self._classifier = None + + def forward(self, x): + if is_timm_vit_name(self._model_name): + return self._model(self._normalize_transform(x)) + features = self.get_features(x) + if self._classifier is None: + return features + return self._classifier(features) + + def get_layers(self): + if 'deit' in self._model_name: + patch_embed = self._model[0] + blocks = self._model[2] + else: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + if self._classifier is not None: + for param in self._classifier.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'deit' in self._model_name: + num_in_features = self._model[3].normalized_shape[0] + else: + num_in_features = self._model.norm.normalized_shape[0] + if is_timm_vit_name(self._model_name): + self._model.head = nn.Linear(num_in_features, num_classes) + self._model.head.to(self._device) + else: + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) + + def add_probe(self, probe): + if is_timm_vit_name(self._model_name): + self._model.head = probe + else: + self._classifier = probe + + def get_last_layer(self): + if is_timm_vit_name(self._model_name): + return self._model.head + else: + return self._classifier + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + # The normalize transform for Deit is standard imagenet transform. See: + # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls + # the timm library create_transform, which uses these imagenet defaults. + if is_timm_vit_name(self._model_name): + raise NotImplementedError('Need to implement this for timm models.') + else: + return self._model(default_imnet_normalize(x)) From 4e811d57d8f8e679586fed287f065be7abf414a4 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 6 Sep 2022 14:53:16 -0700 Subject: [PATCH 110/197] Fix edge case with batch splitting, and add timm model --- configs/adaptation/domainnet.yaml | 1 + configs/adaptation/living17_nonorm.yaml | 2 + configs/adaptation/waterbirds.yaml | 1 + scripts/load_models_get_layers.ipynb | 168 +++++++-- scripts/run_adaptation_experiments.py | 9 + unlabeled_extrapolation/baseline_train.py | 7 +- unlabeled_extrapolation/models/timm_model.py | 131 +++++++ unlabeled_extrapolation/models/vit_model.py | 343 +++++++++---------- 8 files changed, 460 insertions(+), 202 deletions(-) create mode 100644 unlabeled_extrapolation/models/timm_model.py diff --git a/configs/adaptation/domainnet.yaml b/configs/adaptation/domainnet.yaml index 396a50b..c1613bf 100644 --- a/configs/adaptation/domainnet.yaml +++ b/configs/adaptation/domainnet.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 40 epochs: &epochs 50 # Very small dataset so run for longer. batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/configs/adaptation/living17_nonorm.yaml b/configs/adaptation/living17_nonorm.yaml index e345e80..2ff3008 100644 --- a/configs/adaptation/living17_nonorm.yaml +++ b/configs/adaptation/living17_nonorm.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 17 epochs: &epochs 20 save_no_checkpoints: True +batch_size: 32 +batch_splits: 2 model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index fca21e4..f508c49 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -6,6 +6,7 @@ inherit: num_classes: 2 epochs: &epochs 20 batch_size: 32 +batch_splits: 2 save_no_checkpoints: True model: diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f321b84..f00a5e6 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,27 +2,30 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", + "import timm\n", + "import torch\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", - "importlib.reload(utils)" + "importlib.reload(utils)\n", + "importlib.reload(timm_model)" ] }, { @@ -35,15 +38,14 @@ " print('num params before freezing: ', utils.count_parameters(model, trainable=True))\n", " print(model.get_layers()[1])\n", " print(len(model.get_layers()))\n", - " model.freeze_bottom_k(k=1)\n", - " print('num params after freezing 1: ', utils.count_parameters(model, trainable=True))\n", - " model.freeze_bottom_k(k=2)\n", - " print('num params after freezing 2: ', utils.count_parameters(model, trainable=True))" + " for k in [1, 2, len(model.get_layers())]:\n", + " model.freeze_bottom_k(k=k)\n", + " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -82,8 +84,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 68247251\n", - "num params after freezing 2: 68032339\n", + "num params after freezing 1: 68247251\n", + "num params after freezing 2: 68032339\n", + "num params after freezing 6: 0\n", "num params before freezing: 87248787\n", "('conv-block-0', Sequential(\n", " (unit01): PreActBottleneck(\n", @@ -116,8 +119,9 @@ " )\n", "))\n", "6\n", - "num params after freezing 1: 87239379\n", - "num params after freezing 2: 87024467\n" + "num params after freezing 1: 87239379\n", + "num params after freezing 2: 87024467\n", + "num params after freezing 6: 0\n" ] } ], @@ -135,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -149,23 +153,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "num params before freezing: 85798656\n", + "num params before freezing: 85806346\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 85208064\n", - "num params after freezing 2: 85208064\n" + "1\n", + "num params after freezing 1: 85215754\n", + "2\n", + "num params after freezing 2: 85215754\n", + "54\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# DINO\n", "model = vit_model.VitModel(model_name='dino_vitb16')\n", - "get_layers_freeze_test(model)" + "model.new_last_layer(10)\n", + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -175,25 +184,132 @@ "num params before freezing: 22050664\n", "('empty_ln_pre', Module())\n", "54\n", - "num params after freezing 1: 21755368\n", - "num params after freezing 2: 21755368\n" + "num params after freezing 1: 21755368\n", + "num params after freezing 2: 21755368\n", + "num params after freezing 54: 0\n" ] } ], "source": [ "# Timm ViT-S\n", "model = vit_model.VitModel(model_name='timm.vit_small_patch16_224')\n", - "get_layers_freeze_test(model)" + "get_layers_freeze_test(model)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num params before freezing: 109953489\n", + "('stage0', ConvNeXtStage(\n", + " (downsample): Identity()\n", + " (blocks): Sequential(\n", + " (0): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (1): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " (2): ConvNeXtBlock(\n", + " (conv_dw): Conv2d(128, 128, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=128)\n", + " (norm): LayerNorm((128,), eps=1e-06, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=128, out_features=512, bias=True)\n", + " (act): GELU()\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=128, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path): Identity()\n", + " )\n", + " )\n", + "))\n", + "7\n", + "num params after freezing 1: 109946961\n", + "num params after freezing 2: 109531473\n", + "num params after freezing 7: 0\n" + ] + } + ], "source": [ "# Conv-next\n", - "\n" + "model = timm_model.TimmModel('convnext_base_in22k')\n", + "get_layers_freeze_test(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " ...,\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625],\n", + " [-2.1558, 0.1969, -2.2230, ..., -2.2479, 0.7122, 0.2625]],\n", + " device='cuda:0')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = torch.zeros((8,3,224,224))\n", + "x = x.cuda()\n", + "model(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sequential(\n", + " (global_pool): SelectAdaptivePool2d (pool_type=avg, flatten=Identity())\n", + " (norm): LayerNorm2d((1024,), eps=1e-06, elementwise_affine=True)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " (fc): Linear(in_features=1024, out_features=21841, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "print(model._model.head)" ] }, { diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 77ebb9b..6f1fffe 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1072,6 +1072,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +convnext_vit_b = Model( + kwargs={ + 'classname': 'models.timm_model.TimmModel', + 'args.model_name': 'convnext_base_in22k', + }, + bundles=[] +) + bit_resnet_50 = Model( kwargs={ 'classname': 'models.bit_resnet.BitResNet', @@ -1131,6 +1139,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_l14': clip_vit_l14, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, + 'convnext_vit_b': convnext_vit_b, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, 'bit_resnet_50': bit_resnet_50, diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 4e4a442..516bdf5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -342,11 +342,12 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ del l2sp_loss # Split up the batch so we can do the backward pass on a GPU, accumulate gradients # across the split. + split_size = int(np.ceil(len(all_inputs) / batch_splits)) split_inputs = torch.split( - all_inputs, split_size_or_sections=len(all_inputs) // batch_splits) + all_inputs, split_size_or_sections=split_size) split_labels = torch.split( - all_labels, split_size_or_sections=len(all_labels) // batch_splits) - for j in range(batch_splits): + all_labels, split_size_or_sections=split_size) + for j in range(len(split_inputs)): inputs, labels = split_inputs[j], split_labels[j] if config['use_cuda']: inputs, labels = inputs.to(device), labels.to(device) diff --git a/unlabeled_extrapolation/models/timm_model.py b/unlabeled_extrapolation/models/timm_model.py new file mode 100644 index 0000000..ada423c --- /dev/null +++ b/unlabeled_extrapolation/models/timm_model.py @@ -0,0 +1,131 @@ +# Note: this model does normalization. +# Also supports convnext and potentially some other timm models. TODO: refactor. + +from collections import OrderedDict +import torchvision.models as models +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.models import convnext +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def get_timm_transform(model_name): + config = resolve_data_config({}, model=model_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class TimmModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + model = timm.create_model(model_name, pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + if self._device == 'cuda': + model.cuda() + self._model = model + + def forward(self, x): + return self._model(self._normalize_transform(x)) + + def get_layers(self): + if 'vit' in self._model_name: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + elif 'convnext' in self._model_name: + layers = [('stem', self._model.stem)] + blocks = self._model.stages + for i, block in zip(range(len(blocks)), blocks): + layers += [('stage' + str(i), block)] + # The convnext head contains multiple pieces. I checked that all the parameters + # are accounted for by these two components (norm and fc). + layers += [('post_norm', self._model.head.norm)] + layers += [('head', self._model.head.fc)] + else: + raise NotImplementedError('Model currently not implemented') + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'vit' in self._model_name: + num_in_features = self._model.norm.normalized_shape[0] + self._model.head = nn.Linear(num_in_features, num_classes) + elif 'convnext' in self._model_name: + num_in_features = self._model.head.norm.normalized_shape[0] + self._model.head.fc = nn.Linear(num_in_features, num_classes) + else: + raise NotImplementedError('Model currently not implemented') + self._model.head.to(self._device) + + def add_probe(self, probe): + if 'vit' in self._model_name: + self._model.head = probe + elif 'convnext' in self._model_name: + self._model.head.fc = probe + else: + raise NotImplementedError('Model currently not implemented') + + def get_last_layer(self): + if 'vit' in self._model_name: + return self._model.head + elif 'convnext' in self._model_name: + return self._model.head.fc + else: + raise NotImplementedError('Model currently not implemented') + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + raise NotImplementedError('Need to implement this for timm models.') diff --git a/unlabeled_extrapolation/models/vit_model.py b/unlabeled_extrapolation/models/vit_model.py index 32c2322..6913df5 100644 --- a/unlabeled_extrapolation/models/vit_model.py +++ b/unlabeled_extrapolation/models/vit_model.py @@ -1,173 +1,170 @@ -# Note: this model does normalization. -from collections import OrderedDict -import torchvision.models as models -from torchvision.models import resnet50 -import torch -from torch import nn -from . import model_utils - -import timm -from timm.models import vision_transformer -from timm.data import resolve_data_config - -from torchvision.transforms import Normalize - - -MODELS = { - 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', - 'deit_base_patch16_224', -} - - -default_imnet_normalize = Normalize( - mean=(0.485, 0.456, 0.406), - std=[0.229, 0.224, 0.225]) - - -def set_requires_grad(component, val): - for param in component.parameters(): - param.requires_grad = val - - -def is_timm_vit_name(model_name): - timm_vit_names = vision_transformer.default_cfgs.keys() - return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names - - -def get_timm_name(model_name): - assert model_name.startswith('timm.') - return model_name[5:] - - -def get_timm_transform(model_name): - timm_name = get_timm_name(model_name) - config = resolve_data_config({}, model=model_name) - normalize_transform = Normalize(mean=config['mean'], std=config['std']) - return normalize_transform - - -class VitModel(nn.Module): - - def __init__(self, model_name): - super().__init__() - if model_name not in MODELS and not(is_timm_vit_name(model_name)): - raise ValueError(f'model_name must be in {MODELS} but was {model_name}') - self._model_name = model_name - self._device = "cuda" if torch.cuda.is_available() else "cpu" - # Note that model has both a language and vision part. - if is_timm_vit_name(model_name): - model = timm.create_model(get_timm_name(model_name), pretrained=True) - self._normalize_transform = get_timm_transform(model_name) - elif 'dino' in model_name: - model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) - elif 'deit' in model_name: - model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) - if self._device == 'cuda': - model.cuda() - if 'deit' in model_name: - # deit implementation is not complete, doesn't seem to load properly, and also - # get_layers likely isn't handled correctly. - raise NotImplementedError - self._model = nn.Sequential(*list(model.children())[:-1]) - else: - self._model = model - self._classifier = None - - def forward(self, x): - if is_timm_vit_name(self._model_name): - return self._model(self._normalize_transform(x)) - features = self.get_features(x) - if self._classifier is None: - return features - return self._classifier(features) - - def get_layers(self): - if 'deit' in self._model_name: - patch_embed = self._model[0] - blocks = self._model[2] - else: - pos_embed = self._model.pos_embed - cls_token = self._model.cls_token - patch_embed = self._model.patch_embed - blocks = self._model.blocks - layers = [ - ('patch_embed', patch_embed), - ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. - ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), - ('cls_token', model_utils.ParamWrapperModule(cls_token)), - ] - for i, block in zip(range(len(blocks)), blocks): - layers += [ - ('trans' + str(i) + '_norm1', block.norm1), - ('trans' + str(i) + '_attn', block.attn), - ('trans' + str(i) + '_norm2', block.norm2), - ('trans' + str(i) + '_mlp', block.mlp), - ] - if 'dino' not in self._model_name: - layers += [('post_norm', self._model.norm)] - else: - layers += [('empty_post_norm', nn.Module())] - layers += [('head', self.get_last_layer())] - return layers - - def tune_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - if k > len(layers): - raise ValueError(f"k {k} should be less than number of layers {len(layers)}") - set_requires_grad(self._model, False) - for i in range(k): - set_requires_grad(layers[i], True) - # Also need to tune the prediction head because the fine-tuning task is different - # from pretraining. - set_requires_grad(layers[-1], True) - - def freeze_bottom_k(self, k): - layers = [layer for name, layer in self.get_layers()] - for i in range(min(k, len(layers))): - set_requires_grad(layers[i], False) - - def set_requires_grad(self, val): - for param in self._model.parameters(): - param.requires_grad = val - if self._classifier is not None: - for param in self._classifier.parameters(): - param.requires_grad = val - - def new_last_layer(self, num_classes): - if 'deit' in self._model_name: - num_in_features = self._model[3].normalized_shape[0] - else: - num_in_features = self._model.norm.normalized_shape[0] - if is_timm_vit_name(self._model_name): - self._model.head = nn.Linear(num_in_features, num_classes) - self._model.head.to(self._device) - else: - self._classifier = nn.Linear(num_in_features, num_classes) - self._classifier.to(self._device) - - def add_probe(self, probe): - if is_timm_vit_name(self._model_name): - self._model.head = probe - else: - self._classifier = probe - - def get_last_layer(self): - if is_timm_vit_name(self._model_name): - return self._model.head - else: - return self._classifier - - def set_last_layer(self, coef, intercept): - model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) - - def get_feature_extractor(self): - raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') - - def get_features(self, x): - # The normalize transform for Deit is standard imagenet transform. See: - # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls - # the timm library create_transform, which uses these imagenet defaults. - if is_timm_vit_name(self._model_name): - raise NotImplementedError('Need to implement this for timm models.') - else: - return self._model(default_imnet_normalize(x)) +# Note: this model does normalization. +from collections import OrderedDict +import torchvision.models as models +from torchvision.models import resnet50 +import torch +from torch import nn +from . import model_utils + +import timm +from timm.models import vision_transformer +from timm.data import resolve_data_config + +from torchvision.transforms import Normalize + + +MODELS = { + 'dino_vits16', 'dino_vits8', 'dino_vitb16', 'dino_vitb8', + 'deit_base_patch16_224', +} + + +default_imnet_normalize = Normalize( + mean=(0.485, 0.456, 0.406), + std=[0.229, 0.224, 0.225]) + + +def set_requires_grad(component, val): + for param in component.parameters(): + param.requires_grad = val + + +def is_timm_vit_name(model_name): + timm_vit_names = vision_transformer.default_cfgs.keys() + return model_name.startswith('timm.') and get_timm_name(model_name) in timm_vit_names + + +def get_timm_name(model_name): + assert model_name.startswith('timm.') + return model_name[5:] + + +def get_timm_transform(model_name): + timm_name = get_timm_name(model_name) + config = resolve_data_config({}, model=timm_name) + normalize_transform = Normalize(mean=config['mean'], std=config['std']) + return normalize_transform + + +class VitModel(nn.Module): + + def __init__(self, model_name): + super().__init__() + if model_name not in MODELS and not(is_timm_vit_name(model_name)): + raise ValueError(f'model_name must be in {MODELS} but was {model_name}') + self._model_name = model_name + self._device = "cuda" if torch.cuda.is_available() else "cpu" + # Note that model has both a language and vision part. + if is_timm_vit_name(model_name): + model = timm.create_model(get_timm_name(model_name), pretrained=True) + self._normalize_transform = get_timm_transform(model_name) + elif 'dino' in model_name: + model = torch.hub.load('facebookresearch/dino:main', model_name, force_reload=True) + elif 'deit' in model_name: + model = torch.hub.load('facebookresearch/deit:main', model_name, force_reload=True) + if self._device == 'cuda': + model.cuda() + if 'deit' in model_name: + # deit implementation is not complete, doesn't seem to load properly, and also + # get_layers likely isn't handled correctly. + raise NotImplementedError + self._model = nn.Sequential(*list(model.children())[:-1]) + else: + self._model = model + self._classifier = None + + def forward(self, x): + if is_timm_vit_name(self._model_name): + return self._model(self._normalize_transform(x)) + features = self.get_features(x) + if self._classifier is None: + return features + return self._classifier(features) + + def get_layers(self): + if 'deit' in self._model_name: + patch_embed = self._model[0] + blocks = self._model[2] + else: + pos_embed = self._model.pos_embed + cls_token = self._model.cls_token + patch_embed = self._model.patch_embed + blocks = self._model.blocks + layers = [ + ('patch_embed', patch_embed), + ('empty_ln_pre', nn.Module()), # To streamline number of layers with CLIP. + ('pos_embed', model_utils.ParamWrapperModule(pos_embed)), + ('cls_token', model_utils.ParamWrapperModule(cls_token)), + ] + for i, block in zip(range(len(blocks)), blocks): + layers += [ + ('trans' + str(i) + '_norm1', block.norm1), + ('trans' + str(i) + '_attn', block.attn), + ('trans' + str(i) + '_norm2', block.norm2), + ('trans' + str(i) + '_mlp', block.mlp), + ] + layers += [('post_norm', self._model.norm)] + layers += [('head', self.get_last_layer())] + return layers + + def tune_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + set_requires_grad(self._model, False) + for i in range(k): + set_requires_grad(layers[i], True) + # Also need to tune the prediction head because the fine-tuning task is different + # from pretraining. + set_requires_grad(layers[-1], True) + + def freeze_bottom_k(self, k): + layers = [layer for name, layer in self.get_layers()] + for i in range(min(k, len(layers))): + set_requires_grad(layers[i], False) + + def set_requires_grad(self, val): + for param in self._model.parameters(): + param.requires_grad = val + if self._classifier is not None: + for param in self._classifier.parameters(): + param.requires_grad = val + + def new_last_layer(self, num_classes): + if 'deit' in self._model_name: + num_in_features = self._model[3].normalized_shape[0] + else: + num_in_features = self._model.norm.normalized_shape[0] + if is_timm_vit_name(self._model_name): + self._model.head = nn.Linear(num_in_features, num_classes) + self._model.head.to(self._device) + else: + self._classifier = nn.Linear(num_in_features, num_classes) + self._classifier.to(self._device) + + def add_probe(self, probe): + if is_timm_vit_name(self._model_name): + self._model.head = probe + else: + self._classifier = probe + + def get_last_layer(self): + if is_timm_vit_name(self._model_name): + return self._model.head + else: + return self._classifier + + def set_last_layer(self, coef, intercept): + model_utils.set_linear_layer(self.get_last_layer(), coef, intercept) + + def get_feature_extractor(self): + raise NotImplementedError('Be careful, we need to normalize image first before encoding it.') + + def get_features(self, x): + # The normalize transform for Deit is standard imagenet transform. See: + # https://github.com/facebookresearch/deit/blob/main/datasets.py which calls + # the timm library create_transform, which uses these imagenet defaults. + if is_timm_vit_name(self._model_name): + raise NotImplementedError('Need to implement this for timm models.') + else: + return self._model(default_imnet_normalize(x)) From 33de4e49c0802ada003b36b130b57a8bb71c3e34 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:25:14 -0700 Subject: [PATCH 111/197] Add option to run all hyper sweeps in one job --- scripts/run_adaptation_experiments.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6f1fffe..e4453d7 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -282,13 +282,18 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() - for job_name, cmd in zip(job_names, cmds): - amlt_config += " - name: " + job_name + "\n" - amlt_config += " sku: G1-V100\n" - if args.amulet_cluster == 'sing_basic': - amlt_config += " sla_tier: basic\n" - amlt_config += " command:\n" - amlt_config += " - " + cmd + "\n" + job_header = (" - name: {}\n" + " sku: G1-V100\n") + if args.amulet_cluster == 'sing_basic': + job_header += " sla_tier: basic\n" + job_header += " command:\n" + if args.amulet_option == 'run_separate': + for job_name, cmd in zip(job_names, cmds): + amlt_config += job_header.format(job_name) + amlt_config += " - " + cmd + "\n" + elif args.amulet_option == 'run': + amlt_config += job_header.format(experiment_name) + " - " + amlt_config += " && ".join(cmds) + "\n" return amlt_config @@ -324,7 +329,8 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati if job_id != -1: sweep_ids.append(job_id) experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) - if args.amulet_option == 'run': + if args.amulet_option == 'run' or args.amulet_option == 'run_separate': + # 'run' will group all the runs into a single job. ' print_os_system('amlt results ' + experiment_name, args) print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) From acf6136708002d362662394d285beae504b28fbd Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:25:14 -0700 Subject: [PATCH 112/197] Add option to run all hyper sweeps in one job --- scripts/run_adaptation_experiments.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6f1fffe..e4453d7 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -282,13 +282,18 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() - for job_name, cmd in zip(job_names, cmds): - amlt_config += " - name: " + job_name + "\n" - amlt_config += " sku: G1-V100\n" - if args.amulet_cluster == 'sing_basic': - amlt_config += " sla_tier: basic\n" - amlt_config += " command:\n" - amlt_config += " - " + cmd + "\n" + job_header = (" - name: {}\n" + " sku: G1-V100\n") + if args.amulet_cluster == 'sing_basic': + job_header += " sla_tier: basic\n" + job_header += " command:\n" + if args.amulet_option == 'run_separate': + for job_name, cmd in zip(job_names, cmds): + amlt_config += job_header.format(job_name) + amlt_config += " - " + cmd + "\n" + elif args.amulet_option == 'run': + amlt_config += job_header.format(experiment_name) + " - " + amlt_config += " && ".join(cmds) + "\n" return amlt_config @@ -324,7 +329,8 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati if job_id != -1: sweep_ids.append(job_id) experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) - if args.amulet_option == 'run': + if args.amulet_option == 'run' or args.amulet_option == 'run_separate': + # 'run' will group all the runs into a single job. ' print_os_system('amlt results ' + experiment_name, args) print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) From 6d2173887bbf0f74a221ea48df2a82c532e9ab2c Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:25:14 -0700 Subject: [PATCH 113/197] Add option to run all hyper sweeps in one job --- scripts/amlt_config_template_sing.yaml | 1 - scripts/run_adaptation_experiments.py | 22 ++++++++++++++-------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml index f5ad2e4..46d764a 100644 --- a/scripts/amlt_config_template_sing.yaml +++ b/scripts/amlt_config_template_sing.yaml @@ -19,4 +19,3 @@ code: # data upload is not required for this example jobs: - diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6f1fffe..e4453d7 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -282,13 +282,18 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() - for job_name, cmd in zip(job_names, cmds): - amlt_config += " - name: " + job_name + "\n" - amlt_config += " sku: G1-V100\n" - if args.amulet_cluster == 'sing_basic': - amlt_config += " sla_tier: basic\n" - amlt_config += " command:\n" - amlt_config += " - " + cmd + "\n" + job_header = (" - name: {}\n" + " sku: G1-V100\n") + if args.amulet_cluster == 'sing_basic': + job_header += " sla_tier: basic\n" + job_header += " command:\n" + if args.amulet_option == 'run_separate': + for job_name, cmd in zip(job_names, cmds): + amlt_config += job_header.format(job_name) + amlt_config += " - " + cmd + "\n" + elif args.amulet_option == 'run': + amlt_config += job_header.format(experiment_name) + " - " + amlt_config += " && ".join(cmds) + "\n" return amlt_config @@ -324,7 +329,8 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati if job_id != -1: sweep_ids.append(job_id) experiment_name = get_group_name(adapt_name, dataset.name, args.model_name) - if args.amulet_option == 'run': + if args.amulet_option == 'run' or args.amulet_option == 'run_separate': + # 'run' will group all the runs into a single job. ' print_os_system('amlt results ' + experiment_name, args) print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) From 85b11942c925b154660583027634068a809e209f Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:51:20 -0700 Subject: [PATCH 114/197] Add amlt_data_cmd to run copy data bash script. --- scripts/run_adaptation_experiments.py | 36 +++++++++++++++++++-------- 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index e4453d7..5b49acd 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -271,8 +271,9 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids -def get_amlt_config(experiment_name, job_names, cmds, args=None): +def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Returns an amulet config for a sweep. + # TODO: use some better library to inject additional options into the yaml files. amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" if args.amulet_cluster == 'amlk8s': amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' @@ -282,6 +283,16 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() + # Read and fill out the setup. + setup_config_path = 'scripts/amlt_setup.yaml' + with open(setup_config_path, "r") as f: + amlt_setup = f.read() + if dataset.amlt_data_cmd is not None: + dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) + amlt_setup += "\n - " + dataset_copy_cmd + amlt_config = amlt_config.format(setup=amlt_setup) + # Check if the dataset has additional setup operations, and if so add it. + # Read and fill out the jobs section. job_header = (" - name: {}\n" " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': @@ -335,7 +346,7 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) print(job_names) - amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, dataset, args) run_amlt_config(amlt_config, experiment_name, args) elif args.amulet_option == 'cancel': print_os_system('amlt cancel -y ' + experiment_name, args) @@ -523,7 +534,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): fields = ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', - 'eval_config_rel_path', 'overwrite_options'] + 'eval_config_rel_path', 'overwrite_options', 'amlt_data_cmd'] Dataset = namedtuple( 'Dataset', fields, defaults=[None] * len(fields) @@ -734,7 +745,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') living17_nonorm = Dataset( name='living17_nonorm', @@ -749,7 +761,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_nonorm_eval.yaml') + eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') entity30 = Dataset( name='entity30', @@ -764,7 +777,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/entity30_eval.yaml') + eval_config_rel_path='adaptation/entity30_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet = Dataset( name='imagenet', @@ -779,7 +793,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_eval.yaml') + eval_config_rel_path='adaptation/imagenet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet_augs = Dataset( name='imagenet_augs', @@ -794,7 +809,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_augs_eval.yaml') + eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') cifar_stl = Dataset( name='cifar_stl', @@ -826,7 +842,6 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/ananya/', eval_config_rel_path='adaptation/cifar_stl_nonorm_eval.yaml') - domainnet = Dataset( name='domainnet', val_metric='test_acc/sketch_val', @@ -840,7 +855,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['domainnet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/domainnet_eval.yaml') + eval_config_rel_path='adaptation/domainnet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') fmow = Dataset( name='fmow', From d92c08d5f55e9f88e4e6799c0d43c98521ed0b20 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:51:20 -0700 Subject: [PATCH 115/197] Add amlt_data_cmd to run copy data bash script. --- scripts/run_adaptation_experiments.py | 36 +++++++++++++++++++-------- 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index e4453d7..5b49acd 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -271,8 +271,9 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids -def get_amlt_config(experiment_name, job_names, cmds, args=None): +def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Returns an amulet config for a sweep. + # TODO: use some better library to inject additional options into the yaml files. amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" if args.amulet_cluster == 'amlk8s': amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' @@ -282,6 +283,16 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() + # Read and fill out the setup. + setup_config_path = 'scripts/amlt_setup.yaml' + with open(setup_config_path, "r") as f: + amlt_setup = f.read() + if dataset.amlt_data_cmd is not None: + dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) + amlt_setup += "\n - " + dataset_copy_cmd + amlt_config = amlt_config.format(setup=amlt_setup) + # Check if the dataset has additional setup operations, and if so add it. + # Read and fill out the jobs section. job_header = (" - name: {}\n" " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': @@ -335,7 +346,7 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) print(job_names) - amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, dataset, args) run_amlt_config(amlt_config, experiment_name, args) elif args.amulet_option == 'cancel': print_os_system('amlt cancel -y ' + experiment_name, args) @@ -523,7 +534,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): fields = ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', - 'eval_config_rel_path', 'overwrite_options'] + 'eval_config_rel_path', 'overwrite_options', 'amlt_data_cmd'] Dataset = namedtuple( 'Dataset', fields, defaults=[None] * len(fields) @@ -734,7 +745,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') living17_nonorm = Dataset( name='living17_nonorm', @@ -749,7 +761,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_nonorm_eval.yaml') + eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') entity30 = Dataset( name='entity30', @@ -764,7 +777,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/entity30_eval.yaml') + eval_config_rel_path='adaptation/entity30_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet = Dataset( name='imagenet', @@ -779,7 +793,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_eval.yaml') + eval_config_rel_path='adaptation/imagenet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet_augs = Dataset( name='imagenet_augs', @@ -794,7 +809,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_augs_eval.yaml') + eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') cifar_stl = Dataset( name='cifar_stl', @@ -826,7 +842,6 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/ananya/', eval_config_rel_path='adaptation/cifar_stl_nonorm_eval.yaml') - domainnet = Dataset( name='domainnet', val_metric='test_acc/sketch_val', @@ -840,7 +855,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['domainnet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/domainnet_eval.yaml') + eval_config_rel_path='adaptation/domainnet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') fmow = Dataset( name='fmow', From 1b037f07995bb1bda38c7f8af98b9c0b4b123733 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Tue, 6 Sep 2022 17:51:20 -0700 Subject: [PATCH 116/197] Add amlt_data_cmd to run copy data bash script. --- scripts/amlt_config_template_amlk8s.yaml | 6 +--- scripts/amlt_config_template_sing.yaml | 6 +--- scripts/amlt_setup.yaml | 5 ++++ scripts/run_adaptation_experiments.py | 36 +++++++++++++++++------- 4 files changed, 33 insertions(+), 20 deletions(-) create mode 100644 scripts/amlt_setup.yaml diff --git a/scripts/amlt_config_template_amlk8s.yaml b/scripts/amlt_config_template_amlk8s.yaml index b0c6fc8..a1bba32 100644 --- a/scripts/amlt_config_template_amlk8s.yaml +++ b/scripts/amlt_config_template_amlk8s.yaml @@ -7,11 +7,7 @@ target: environment: image: pytorch/pytorch:latest registry: docker.io # any public registry can be specified here - setup: - - apt-get update - - apt-get install git - - pip install ./CLIP - - pip install -e . +{setup} code: # local directory of the code. this will be uploaded to the server. diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml index 46d764a..2337642 100644 --- a/scripts/amlt_config_template_sing.yaml +++ b/scripts/amlt_config_template_sing.yaml @@ -4,11 +4,7 @@ target: environment: image: amlt-sing/pytorch-1.8.0 - setup: - - apt-get update - - apt-get install git - - pip install ./CLIP - - pip install -e . +{setup} code: # local directory of the code. this will be uploaded to the server. diff --git a/scripts/amlt_setup.yaml b/scripts/amlt_setup.yaml new file mode 100644 index 0000000..ec2ecdd --- /dev/null +++ b/scripts/amlt_setup.yaml @@ -0,0 +1,5 @@ + setup: + - apt-get update + - apt-get install git + - pip install ./CLIP + - pip install -e . \ No newline at end of file diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index e4453d7..5b49acd 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -271,8 +271,9 @@ def adaptation_sweep(adapt_name, dataset, model, hyperparams_list, args, deps=[] return sweep_ids -def get_amlt_config(experiment_name, job_names, cmds, args=None): +def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Returns an amulet config for a sweep. + # TODO: use some better library to inject additional options into the yaml files. amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" if args.amulet_cluster == 'amlk8s': amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' @@ -282,6 +283,16 @@ def get_amlt_config(experiment_name, job_names, cmds, args=None): raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() + # Read and fill out the setup. + setup_config_path = 'scripts/amlt_setup.yaml' + with open(setup_config_path, "r") as f: + amlt_setup = f.read() + if dataset.amlt_data_cmd is not None: + dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) + amlt_setup += "\n - " + dataset_copy_cmd + amlt_config = amlt_config.format(setup=amlt_setup) + # Check if the dataset has additional setup operations, and if so add it. + # Read and fill out the jobs section. job_header = (" - name: {}\n" " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': @@ -335,7 +346,7 @@ def replicated_sweep(adapt_name, dataset, model, hyperparams_list, num_replicati print_os_system('amlt logs ' + experiment_name, args) job_names, cmds = list(zip(*sweep_ids)) print(job_names) - amlt_config = get_amlt_config(experiment_name, job_names, cmds, args) + amlt_config = get_amlt_config(experiment_name, job_names, cmds, dataset, args) run_amlt_config(amlt_config, experiment_name, args) elif args.amulet_option == 'cancel': print_os_system('amlt cancel -y ' + experiment_name, args) @@ -523,7 +534,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): fields = ['name', 'val_metric', 'secondary_val_metrics', 'output_metrics', 'linprobe_secondary_val_metrics', 'linprobe_output_metrics', 'config_rel_path', 'bundles', 'slurm_data_cmd', 'slurm_data_dir', - 'eval_config_rel_path', 'overwrite_options'] + 'eval_config_rel_path', 'overwrite_options', 'amlt_data_cmd'] Dataset = namedtuple( 'Dataset', fields, defaults=[None] * len(fields) @@ -734,7 +745,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') living17_nonorm = Dataset( name='living17_nonorm', @@ -749,7 +761,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_nonorm_eval.yaml') + eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') entity30 = Dataset( name='entity30', @@ -764,7 +777,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/entity30_eval.yaml') + eval_config_rel_path='adaptation/entity30_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet = Dataset( name='imagenet', @@ -779,7 +793,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_eval.yaml') + eval_config_rel_path='adaptation/imagenet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') imagenet_augs = Dataset( name='imagenet_augs', @@ -794,7 +809,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - eval_config_rel_path='adaptation/imagenet_augs_eval.yaml') + eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') cifar_stl = Dataset( name='cifar_stl', @@ -826,7 +842,6 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/u/scr/ananya/', eval_config_rel_path='adaptation/cifar_stl_nonorm_eval.yaml') - domainnet = Dataset( name='domainnet', val_metric='test_acc/sketch_val', @@ -840,7 +855,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['domainnet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/domainnet_eval.yaml') + eval_config_rel_path='adaptation/domainnet_eval.yaml', + amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') fmow = Dataset( name='fmow', From e04c4a3ec05ead643f8d02185a5dbfdde113856c Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 02:37:04 -0700 Subject: [PATCH 117/197] Copy imagenet and domainnet on amulet. --- scripts/amlt_copy_dataset.sh | 20 ++++++++++ scripts/amlt_copy_domainnet.sh | 10 +++++ scripts/amlt_copy_imagenet.sh | 13 +++++++ scripts/run_adaptation_experiments.py | 37 ++++++++++++------- unlabeled_extrapolation/datasets/breeds.py | 5 ++- unlabeled_extrapolation/datasets/domainnet.py | 14 +++++-- 6 files changed, 81 insertions(+), 18 deletions(-) create mode 100644 scripts/amlt_copy_dataset.sh create mode 100644 scripts/amlt_copy_domainnet.sh create mode 100644 scripts/amlt_copy_imagenet.sh diff --git a/scripts/amlt_copy_dataset.sh b/scripts/amlt_copy_dataset.sh new file mode 100644 index 0000000..c1fe086 --- /dev/null +++ b/scripts/amlt_copy_dataset.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +echo $1 + +if [ "$1" = "domainnet" ]; then + echo "Extracting $1" + cp -r /mnt/external/domainnet . + echo "Copied file" + ls + cd domainnet + ls + unzip -q '*.zip' + ls + cd .. +elif [ "$1" = "imagenet" ]; then + echo "Extracting $1" + +else + echo "Dataset '$1' not supported" +fi diff --git a/scripts/amlt_copy_domainnet.sh b/scripts/amlt_copy_domainnet.sh new file mode 100644 index 0000000..068e23e --- /dev/null +++ b/scripts/amlt_copy_domainnet.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +cp -r /mnt/default/domainnet . +echo "Copied file" +ls +cd domainnet +ls +unzip -q '*.zip' +ls +cd .. diff --git a/scripts/amlt_copy_imagenet.sh b/scripts/amlt_copy_imagenet.sh new file mode 100644 index 0000000..dc296b4 --- /dev/null +++ b/scripts/amlt_copy_imagenet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +cp -r /mnt/default/imagenet . +echo "Copied file" +ls +cd imagenet +ls +for file in *.tar.gz +do + tar -xzf $file +done +ls +cd .. diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 5b49acd..34f5ff8 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -107,11 +107,20 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, kwargs['root_prefix'] = '.' else: kwargs['root_prefix'] = root_prefix - # On slurm, we need to save locally to avoid overloading the distributed file system. - if args.codalab or args.amulet_option is not None: + if args.codalab: kwargs['log_dir'] = args.log_dir + elif args.amulet_option is not None: + if args.amulet_option == 'run_separate': + # If we run each run on a separate job, then just write results to log_dir. + # Amulet will organize the results into a different folder for each job. + kwargs['log_dir'] = args.log_dir + else: + # If we run all the runs on a single amulet job, then need to write results into + # a different folder for each run, to avoid conflicts. + kwargs['log_dir'] = args.log_dir + '/' + run_name else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) + # On slurm, we need to save locally to avoid overloading the distributed file system. kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name kwargs['project_name'] = project_name @@ -289,12 +298,12 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): amlt_setup = f.read() if dataset.amlt_data_cmd is not None: dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) - amlt_setup += "\n - " + dataset_copy_cmd + amlt_setup += "\n - " + dataset_copy_cmd amlt_config = amlt_config.format(setup=amlt_setup) # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-V100-P100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" @@ -553,7 +562,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_mixup = Dataset( name='living17_mixup', @@ -568,7 +578,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_mixup_eval.yaml') + eval_config_rel_path='adaptation/living17_mixup_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') celeba = Dataset( name='celeba', @@ -746,7 +757,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_nonorm = Dataset( name='living17_nonorm', @@ -762,7 +773,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') entity30 = Dataset( name='entity30', @@ -778,7 +789,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/entity30_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet = Dataset( name='imagenet', @@ -794,7 +805,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet_augs = Dataset( name='imagenet_augs', @@ -810,7 +821,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') cifar_stl = Dataset( name='cifar_stl', @@ -856,7 +867,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/domainnet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') fmow = Dataset( name='fmow', @@ -1699,7 +1710,7 @@ def fill_platform_specific_default_args(args): 'simclr_weights/') elif args.amulet_option is not None: args.log_dir = '$$AMLT_OUTPUT_DIR/' - args.pretrained_checkpoints_dir = '/mnt/default/' + args.pretrained_checkpoints_dir = '/mnt/default/pretrained_weights/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if diff --git a/unlabeled_extrapolation/datasets/breeds.py b/unlabeled_extrapolation/datasets/breeds.py index 2564caa..e0f0e75 100644 --- a/unlabeled_extrapolation/datasets/breeds.py +++ b/unlabeled_extrapolation/datasets/breeds.py @@ -76,7 +76,10 @@ def __init__(self, root, breeds_name, self._source = source self._split = split self._transform = transform - self._info_dir = info_dir + if os.path.isdir(root + '/BREEDS-Benchmarks'): + self._info_dir = root + '/BREEDS-Benchmarks/imagenet_class_hierarchy/modified' + else: + self._info_dir = info_dir self._data_dir = root + '/' + split self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir) breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name] diff --git a/unlabeled_extrapolation/datasets/domainnet.py b/unlabeled_extrapolation/datasets/domainnet.py index 04bb9b4..1ab781e 100644 --- a/unlabeled_extrapolation/datasets/domainnet.py +++ b/unlabeled_extrapolation/datasets/domainnet.py @@ -32,7 +32,7 @@ SENTRY_SPLITS_ROOT = '/u/scr/nlp/domainnet/SENTRY_splits' -def load_dataset(domains, split, version): +def load_dataset(root, domains, split, version): if len(domains) == 1 and domains[0] == 'all': if version == 'sentry': domains = SENTRY_DOMAINS @@ -42,9 +42,15 @@ def load_dataset(domains, split, version): data = [] for domain in domains: if version == 'sentry': - idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') + if os.path.isdir(root + '/SENTRY_splits'): + idx_file = os.path.join(root, f'SENTRY_splits/{domain}_{split}_mini.txt') + else: + idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') else: - idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') + if os.path.isfile(root + f'/{domain}_{split}.txt'): + idx_file = os.path.join(root, f'{domain}_{split}.txt') + else: + idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') with open(idx_file, 'r') as f: data += [line.split() for line in f] return data @@ -73,7 +79,7 @@ def __init__(self, domain, split='train', root=ROOT, self._version = version self._unlabeled = unlabeled - self.data = load_dataset(domain_list, split, version) + self.data = load_dataset(root, domain_list, split, version) self.means = [0.485, 0.456, 0.406] self.stds = [0.228, 0.224, 0.225] if verbose: From c13e5432aa814633970d96be50c505684a827bd6 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 02:37:04 -0700 Subject: [PATCH 118/197] Copy imagenet and domainnet on amulet. --- scripts/amlt_copy_dataset.sh | 20 ++++++++++ scripts/amlt_copy_domainnet.sh | 10 +++++ scripts/amlt_copy_imagenet.sh | 13 +++++++ scripts/run_adaptation_experiments.py | 37 ++++++++++++------- unlabeled_extrapolation/datasets/breeds.py | 5 ++- unlabeled_extrapolation/datasets/domainnet.py | 14 +++++-- 6 files changed, 81 insertions(+), 18 deletions(-) create mode 100644 scripts/amlt_copy_dataset.sh create mode 100644 scripts/amlt_copy_domainnet.sh create mode 100644 scripts/amlt_copy_imagenet.sh diff --git a/scripts/amlt_copy_dataset.sh b/scripts/amlt_copy_dataset.sh new file mode 100644 index 0000000..c1fe086 --- /dev/null +++ b/scripts/amlt_copy_dataset.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +echo $1 + +if [ "$1" = "domainnet" ]; then + echo "Extracting $1" + cp -r /mnt/external/domainnet . + echo "Copied file" + ls + cd domainnet + ls + unzip -q '*.zip' + ls + cd .. +elif [ "$1" = "imagenet" ]; then + echo "Extracting $1" + +else + echo "Dataset '$1' not supported" +fi diff --git a/scripts/amlt_copy_domainnet.sh b/scripts/amlt_copy_domainnet.sh new file mode 100644 index 0000000..068e23e --- /dev/null +++ b/scripts/amlt_copy_domainnet.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +cp -r /mnt/default/domainnet . +echo "Copied file" +ls +cd domainnet +ls +unzip -q '*.zip' +ls +cd .. diff --git a/scripts/amlt_copy_imagenet.sh b/scripts/amlt_copy_imagenet.sh new file mode 100644 index 0000000..dc296b4 --- /dev/null +++ b/scripts/amlt_copy_imagenet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +cp -r /mnt/default/imagenet . +echo "Copied file" +ls +cd imagenet +ls +for file in *.tar.gz +do + tar -xzf $file +done +ls +cd .. diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 5b49acd..34f5ff8 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -107,11 +107,20 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, kwargs['root_prefix'] = '.' else: kwargs['root_prefix'] = root_prefix - # On slurm, we need to save locally to avoid overloading the distributed file system. - if args.codalab or args.amulet_option is not None: + if args.codalab: kwargs['log_dir'] = args.log_dir + elif args.amulet_option is not None: + if args.amulet_option == 'run_separate': + # If we run each run on a separate job, then just write results to log_dir. + # Amulet will organize the results into a different folder for each job. + kwargs['log_dir'] = args.log_dir + else: + # If we run all the runs on a single amulet job, then need to write results into + # a different folder for each run, to avoid conflicts. + kwargs['log_dir'] = args.log_dir + '/' + run_name else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) + # On slurm, we need to save locally to avoid overloading the distributed file system. kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name kwargs['project_name'] = project_name @@ -289,12 +298,12 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): amlt_setup = f.read() if dataset.amlt_data_cmd is not None: dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) - amlt_setup += "\n - " + dataset_copy_cmd + amlt_setup += "\n - " + dataset_copy_cmd amlt_config = amlt_config.format(setup=amlt_setup) # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-V100-P100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" @@ -553,7 +562,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_mixup = Dataset( name='living17_mixup', @@ -568,7 +578,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_mixup_eval.yaml') + eval_config_rel_path='adaptation/living17_mixup_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') celeba = Dataset( name='celeba', @@ -746,7 +757,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_nonorm = Dataset( name='living17_nonorm', @@ -762,7 +773,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') entity30 = Dataset( name='entity30', @@ -778,7 +789,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/entity30_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet = Dataset( name='imagenet', @@ -794,7 +805,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet_augs = Dataset( name='imagenet_augs', @@ -810,7 +821,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') cifar_stl = Dataset( name='cifar_stl', @@ -856,7 +867,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/domainnet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') fmow = Dataset( name='fmow', @@ -1699,7 +1710,7 @@ def fill_platform_specific_default_args(args): 'simclr_weights/') elif args.amulet_option is not None: args.log_dir = '$$AMLT_OUTPUT_DIR/' - args.pretrained_checkpoints_dir = '/mnt/default/' + args.pretrained_checkpoints_dir = '/mnt/default/pretrained_weights/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if diff --git a/unlabeled_extrapolation/datasets/breeds.py b/unlabeled_extrapolation/datasets/breeds.py index 2564caa..e0f0e75 100644 --- a/unlabeled_extrapolation/datasets/breeds.py +++ b/unlabeled_extrapolation/datasets/breeds.py @@ -76,7 +76,10 @@ def __init__(self, root, breeds_name, self._source = source self._split = split self._transform = transform - self._info_dir = info_dir + if os.path.isdir(root + '/BREEDS-Benchmarks'): + self._info_dir = root + '/BREEDS-Benchmarks/imagenet_class_hierarchy/modified' + else: + self._info_dir = info_dir self._data_dir = root + '/' + split self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir) breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name] diff --git a/unlabeled_extrapolation/datasets/domainnet.py b/unlabeled_extrapolation/datasets/domainnet.py index 04bb9b4..1ab781e 100644 --- a/unlabeled_extrapolation/datasets/domainnet.py +++ b/unlabeled_extrapolation/datasets/domainnet.py @@ -32,7 +32,7 @@ SENTRY_SPLITS_ROOT = '/u/scr/nlp/domainnet/SENTRY_splits' -def load_dataset(domains, split, version): +def load_dataset(root, domains, split, version): if len(domains) == 1 and domains[0] == 'all': if version == 'sentry': domains = SENTRY_DOMAINS @@ -42,9 +42,15 @@ def load_dataset(domains, split, version): data = [] for domain in domains: if version == 'sentry': - idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') + if os.path.isdir(root + '/SENTRY_splits'): + idx_file = os.path.join(root, f'SENTRY_splits/{domain}_{split}_mini.txt') + else: + idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') else: - idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') + if os.path.isfile(root + f'/{domain}_{split}.txt'): + idx_file = os.path.join(root, f'{domain}_{split}.txt') + else: + idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') with open(idx_file, 'r') as f: data += [line.split() for line in f] return data @@ -73,7 +79,7 @@ def __init__(self, domain, split='train', root=ROOT, self._version = version self._unlabeled = unlabeled - self.data = load_dataset(domain_list, split, version) + self.data = load_dataset(root, domain_list, split, version) self.means = [0.485, 0.456, 0.406] self.stds = [0.228, 0.224, 0.225] if verbose: From 2876b60525f3478ca2114adc8731112e15afe8b3 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 02:37:04 -0700 Subject: [PATCH 119/197] Copy imagenet and domainnet on amulet. --- scripts/amlt_copy_dataset.sh | 20 ++++++++++ scripts/amlt_copy_domainnet.sh | 10 +++++ scripts/amlt_copy_imagenet.sh | 13 +++++++ scripts/amlt_setup.yaml | 12 +++--- scripts/run_adaptation_experiments.py | 37 ++++++++++++------- unlabeled_extrapolation/datasets/breeds.py | 5 ++- unlabeled_extrapolation/datasets/domainnet.py | 14 +++++-- 7 files changed, 88 insertions(+), 23 deletions(-) create mode 100644 scripts/amlt_copy_dataset.sh create mode 100644 scripts/amlt_copy_domainnet.sh create mode 100644 scripts/amlt_copy_imagenet.sh diff --git a/scripts/amlt_copy_dataset.sh b/scripts/amlt_copy_dataset.sh new file mode 100644 index 0000000..c1fe086 --- /dev/null +++ b/scripts/amlt_copy_dataset.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +echo $1 + +if [ "$1" = "domainnet" ]; then + echo "Extracting $1" + cp -r /mnt/external/domainnet . + echo "Copied file" + ls + cd domainnet + ls + unzip -q '*.zip' + ls + cd .. +elif [ "$1" = "imagenet" ]; then + echo "Extracting $1" + +else + echo "Dataset '$1' not supported" +fi diff --git a/scripts/amlt_copy_domainnet.sh b/scripts/amlt_copy_domainnet.sh new file mode 100644 index 0000000..068e23e --- /dev/null +++ b/scripts/amlt_copy_domainnet.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +cp -r /mnt/default/domainnet . +echo "Copied file" +ls +cd domainnet +ls +unzip -q '*.zip' +ls +cd .. diff --git a/scripts/amlt_copy_imagenet.sh b/scripts/amlt_copy_imagenet.sh new file mode 100644 index 0000000..dc296b4 --- /dev/null +++ b/scripts/amlt_copy_imagenet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +cp -r /mnt/default/imagenet . +echo "Copied file" +ls +cd imagenet +ls +for file in *.tar.gz +do + tar -xzf $file +done +ls +cd .. diff --git a/scripts/amlt_setup.yaml b/scripts/amlt_setup.yaml index ec2ecdd..1f85616 100644 --- a/scripts/amlt_setup.yaml +++ b/scripts/amlt_setup.yaml @@ -1,5 +1,7 @@ - setup: - - apt-get update - - apt-get install git - - pip install ./CLIP - - pip install -e . \ No newline at end of file + setup: + - set -x + - apt-get update + - apt-get install git + - pip install ./CLIP + - pip install -e . + - echo "$SHELL" \ No newline at end of file diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 5b49acd..34f5ff8 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -107,11 +107,20 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, kwargs['root_prefix'] = '.' else: kwargs['root_prefix'] = root_prefix - # On slurm, we need to save locally to avoid overloading the distributed file system. - if args.codalab or args.amulet_option is not None: + if args.codalab: kwargs['log_dir'] = args.log_dir + elif args.amulet_option is not None: + if args.amulet_option == 'run_separate': + # If we run each run on a separate job, then just write results to log_dir. + # Amulet will organize the results into a different folder for each job. + kwargs['log_dir'] = args.log_dir + else: + # If we run all the runs on a single amulet job, then need to write results into + # a different folder for each run, to avoid conflicts. + kwargs['log_dir'] = args.log_dir + '/' + run_name else: kwargs['log_dir'] = group_run_to_log_path(group_name, run_name, args) + # On slurm, we need to save locally to avoid overloading the distributed file system. kwargs['tmp_par_ckp_dir'] = args.tmp_dir + '/' + group_name + '_' + run_name kwargs['project_name'] = project_name @@ -289,12 +298,12 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): amlt_setup = f.read() if dataset.amlt_data_cmd is not None: dataset_copy_cmd = dataset.amlt_data_cmd.format(scripts_dir=args.scripts_dir) - amlt_setup += "\n - " + dataset_copy_cmd + amlt_setup += "\n - " + dataset_copy_cmd amlt_config = amlt_config.format(setup=amlt_setup) # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-V100-P100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" @@ -553,7 +562,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_eval.yaml') + eval_config_rel_path='adaptation/living17_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_mixup = Dataset( name='living17_mixup', @@ -568,7 +578,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', - eval_config_rel_path='adaptation/living17_mixup_eval.yaml') + eval_config_rel_path='adaptation/living17_mixup_eval.yaml', + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') celeba = Dataset( name='celeba', @@ -746,7 +757,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') living17_nonorm = Dataset( name='living17_nonorm', @@ -762,7 +773,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') entity30 = Dataset( name='entity30', @@ -778,7 +789,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/entity30_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet = Dataset( name='imagenet', @@ -794,7 +805,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') imagenet_augs = Dataset( name='imagenet_augs', @@ -810,7 +821,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh imagenet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') cifar_stl = Dataset( name='cifar_stl', @@ -856,7 +867,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', slurm_data_dir='/scr/biggest/', eval_config_rel_path='adaptation/domainnet_eval.yaml', - amlt_data_cmd='source {scripts_dir}/amlt_copy_dataset.sh domainnet') + amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') fmow = Dataset( name='fmow', @@ -1699,7 +1710,7 @@ def fill_platform_specific_default_args(args): 'simclr_weights/') elif args.amulet_option is not None: args.log_dir = '$$AMLT_OUTPUT_DIR/' - args.pretrained_checkpoints_dir = '/mnt/default/' + args.pretrained_checkpoints_dir = '/mnt/default/pretrained_weights/' else: args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if diff --git a/unlabeled_extrapolation/datasets/breeds.py b/unlabeled_extrapolation/datasets/breeds.py index 2564caa..e0f0e75 100644 --- a/unlabeled_extrapolation/datasets/breeds.py +++ b/unlabeled_extrapolation/datasets/breeds.py @@ -76,7 +76,10 @@ def __init__(self, root, breeds_name, self._source = source self._split = split self._transform = transform - self._info_dir = info_dir + if os.path.isdir(root + '/BREEDS-Benchmarks'): + self._info_dir = root + '/BREEDS-Benchmarks/imagenet_class_hierarchy/modified' + else: + self._info_dir = info_dir self._data_dir = root + '/' + split self._idx_to_class_id, self._class_to_idx = get_classes(self._data_dir) breeds_func = BREEDS_SPLITS_TO_FUNC[breeds_name] diff --git a/unlabeled_extrapolation/datasets/domainnet.py b/unlabeled_extrapolation/datasets/domainnet.py index 04bb9b4..1ab781e 100644 --- a/unlabeled_extrapolation/datasets/domainnet.py +++ b/unlabeled_extrapolation/datasets/domainnet.py @@ -32,7 +32,7 @@ SENTRY_SPLITS_ROOT = '/u/scr/nlp/domainnet/SENTRY_splits' -def load_dataset(domains, split, version): +def load_dataset(root, domains, split, version): if len(domains) == 1 and domains[0] == 'all': if version == 'sentry': domains = SENTRY_DOMAINS @@ -42,9 +42,15 @@ def load_dataset(domains, split, version): data = [] for domain in domains: if version == 'sentry': - idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') + if os.path.isdir(root + '/SENTRY_splits'): + idx_file = os.path.join(root, f'SENTRY_splits/{domain}_{split}_mini.txt') + else: + idx_file = os.path.join(SENTRY_SPLITS_ROOT, f'{domain}_{split}_mini.txt') else: - idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') + if os.path.isfile(root + f'/{domain}_{split}.txt'): + idx_file = os.path.join(root, f'{domain}_{split}.txt') + else: + idx_file = os.path.join(ROOT, f'{domain}_{split}.txt') with open(idx_file, 'r') as f: data += [line.split() for line in f] return data @@ -73,7 +79,7 @@ def __init__(self, domain, split='train', root=ROOT, self._version = version self._unlabeled = unlabeled - self.data = load_dataset(domain_list, split, version) + self.data = load_dataset(root, domain_list, split, version) self.means = [0.485, 0.456, 0.406] self.stds = [0.228, 0.224, 0.225] if verbose: From dcf380558c78a7b2eb0eb19419b1d8fa150a4633 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:07:07 -0700 Subject: [PATCH 120/197] Add modified CLIP repo inside --- CLIP | 1 + 1 file changed, 1 insertion(+) create mode 160000 CLIP diff --git a/CLIP b/CLIP new file mode 160000 index 0000000..d50d76d --- /dev/null +++ b/CLIP @@ -0,0 +1 @@ +Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 From 015fd34d93836e5e2d18afe9fa6f937b120a5867 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:07:07 -0700 Subject: [PATCH 121/197] Add modified CLIP repo inside --- CLIP | 1 + 1 file changed, 1 insertion(+) create mode 160000 CLIP diff --git a/CLIP b/CLIP new file mode 160000 index 0000000..d50d76d --- /dev/null +++ b/CLIP @@ -0,0 +1 @@ +Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 From a2223bce98d524c7c5c3f57a28ba67d9d0eea59f Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:07:07 -0700 Subject: [PATCH 122/197] Add modified CLIP repo inside --- CLIP | 1 + 1 file changed, 1 insertion(+) create mode 160000 CLIP diff --git a/CLIP b/CLIP new file mode 160000 index 0000000..d50d76d --- /dev/null +++ b/CLIP @@ -0,0 +1 @@ +Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 From 7c66464cc3325ed897bcf6ce8da9232cee31ff24 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:08:52 -0700 Subject: [PATCH 123/197] Add CLIP --- CLIP | 1 - CLIP/.gitignore | 10 + CLIP/CLIP.png | Bin 0 -> 252444 bytes CLIP/LICENSE | 22 + CLIP/MANIFEST.in | 1 + CLIP/README.md | 193 + CLIP/clip/__init__.py | 1 + CLIP/clip/bpe_simple_vocab_16e6.txt.gz | Bin 0 -> 1356917 bytes CLIP/clip/clip.py | 244 ++ CLIP/clip/model.py | 436 +++ CLIP/clip/simple_tokenizer.py | 132 + CLIP/data/country211.md | 12 + CLIP/data/prompts.md | 3401 +++++++++++++++++ CLIP/data/rendered-sst2.md | 11 + CLIP/data/yfcc100m.md | 14 + CLIP/downoad_clip_models.py | 24 + CLIP/hubconf.py | 42 + CLIP/model-card.md | 120 + CLIP/notebooks/Interacting_with_CLIP.ipynb | 925 +++++ .../Prompt_Engineering_for_ImageNet.ipynb | 1107 ++++++ CLIP/requirements.txt | 5 + CLIP/setup.py | 21 + CLIP/tests/test_consistency.py | 25 + 23 files changed, 6746 insertions(+), 1 deletion(-) delete mode 160000 CLIP create mode 100644 CLIP/.gitignore create mode 100644 CLIP/CLIP.png create mode 100644 CLIP/LICENSE create mode 100644 CLIP/MANIFEST.in create mode 100644 CLIP/README.md create mode 100644 CLIP/clip/__init__.py create mode 100644 CLIP/clip/bpe_simple_vocab_16e6.txt.gz create mode 100644 CLIP/clip/clip.py create mode 100644 CLIP/clip/model.py create mode 100644 CLIP/clip/simple_tokenizer.py create mode 100644 CLIP/data/country211.md create mode 100644 CLIP/data/prompts.md create mode 100644 CLIP/data/rendered-sst2.md create mode 100644 CLIP/data/yfcc100m.md create mode 100644 CLIP/downoad_clip_models.py create mode 100644 CLIP/hubconf.py create mode 100644 CLIP/model-card.md create mode 100644 CLIP/notebooks/Interacting_with_CLIP.ipynb create mode 100644 CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb create mode 100644 CLIP/requirements.txt create mode 100644 CLIP/setup.py create mode 100644 CLIP/tests/test_consistency.py diff --git a/CLIP b/CLIP deleted file mode 160000 index d50d76d..0000000 --- a/CLIP +++ /dev/null @@ -1 +0,0 @@ -Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 diff --git a/CLIP/.gitignore b/CLIP/.gitignore new file mode 100644 index 0000000..321f181 --- /dev/null +++ b/CLIP/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.py[cod] +*$py.class +*.egg-info +.pytest_cache +.ipynb_checkpoints + +thumbs.db +.DS_Store +.idea diff --git a/CLIP/CLIP.png b/CLIP/CLIP.png new file mode 100644 index 0000000000000000000000000000000000000000..a1b5ec9171fd7a51e36e845a02304eb837142ba1 GIT binary patch literal 252444 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%0DeXzksd;-# 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�HbU>U!f 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 R>eLeW(pJ}3%RF=<=x@pmd%6Gs literal 0 HcmV?d00001 diff --git a/CLIP/LICENSE b/CLIP/LICENSE new file mode 100644 index 0000000..4e97f0b --- /dev/null +++ b/CLIP/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2021 OpenAI + +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/CLIP/MANIFEST.in b/CLIP/MANIFEST.in new file mode 100644 index 0000000..effd8d9 --- /dev/null +++ b/CLIP/MANIFEST.in @@ -0,0 +1 @@ +include clip/bpe_simple_vocab_16e6.txt.gz diff --git a/CLIP/README.md b/CLIP/README.md new file mode 100644 index 0000000..abc8a34 --- /dev/null +++ b/CLIP/README.md @@ -0,0 +1,193 @@ +# CLIP + +[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb) + +CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision. + + + +## Approach + +![CLIP](CLIP.png) + + + +## Usage + +First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick: + +```bash +$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0 +$ pip install ftfy regex tqdm +$ pip install git+https://github.com/openai/CLIP.git +``` + +Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU. + +```python +import torch +import clip +from PIL import Image + +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load("ViT-B/32", device=device) + +image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device) +text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + +with torch.no_grad(): + image_features = model.encode_image(image) + text_features = model.encode_text(text) + + logits_per_image, logits_per_text = model(image, text) + probs = logits_per_image.softmax(dim=-1).cpu().numpy() + +print("Label probs:", probs) # prints: [[0.9927937 0.00421068 0.00299572]] +``` + + +## API + +The CLIP module `clip` provides the following methods: + +#### `clip.available_models()` + +Returns the names of the available CLIP models. + +#### `clip.load(name, device=..., jit=False)` + +Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint. + +The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded. + +#### `clip.tokenize(text: Union[str, List[str]], context_length=77)` + +Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model + +--- + +The model returned by `clip.load()` supports the following methods: + +#### `model.encode_image(image: Tensor)` + +Given a batch of images, returns the image features encoded by the vision portion of the CLIP model. + +#### `model.encode_text(text: Tensor)` + +Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model. + +#### `model(image: Tensor, text: Tensor)` + +Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100. + + + +## More Examples + +### Zero-Shot Prediction + +The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset. + +```python +import os +import clip +import torch +from torchvision.datasets import CIFAR100 + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Download the dataset +cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False) + +# Prepare the inputs +image, class_id = cifar100[3637] +image_input = preprocess(image).unsqueeze(0).to(device) +text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device) + +# Calculate features +with torch.no_grad(): + image_features = model.encode_image(image_input) + text_features = model.encode_text(text_inputs) + +# Pick the top 5 most similar labels for the image +image_features /= image_features.norm(dim=-1, keepdim=True) +text_features /= text_features.norm(dim=-1, keepdim=True) +similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1) +values, indices = similarity[0].topk(5) + +# Print the result +print("\nTop predictions:\n") +for value, index in zip(values, indices): + print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%") +``` + +The output will look like the following (the exact numbers may be slightly different depending on the compute device): + +``` +Top predictions: + + snake: 65.31% + turtle: 12.29% + sweet_pepper: 3.83% + lizard: 1.88% + crocodile: 1.75% +``` + +Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs. + + +### Linear-probe evaluation + +The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features. + +```python +import os +import clip +import torch + +import numpy as np +from sklearn.linear_model import LogisticRegression +from torch.utils.data import DataLoader +from torchvision.datasets import CIFAR100 +from tqdm import tqdm + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Load the dataset +root = os.path.expanduser("~/.cache") +train = CIFAR100(root, download=True, train=True, transform=preprocess) +test = CIFAR100(root, download=True, train=False, transform=preprocess) + + +def get_features(dataset): + all_features = [] + all_labels = [] + + with torch.no_grad(): + for images, labels in tqdm(DataLoader(dataset, batch_size=100)): + features = model.encode_image(images.to(device)) + + all_features.append(features) + all_labels.append(labels) + + return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy() + +# Calculate the image features +train_features, train_labels = get_features(train) +test_features, test_labels = get_features(test) + +# Perform logistic regression +classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1) +classifier.fit(train_features, train_labels) + +# Evaluate using the logistic regression classifier +predictions = classifier.predict(test_features) +accuracy = np.mean((test_labels == predictions).astype(np.float)) * 100. +print(f"Accuracy = {accuracy:.3f}") +``` + +Note that the `C` value should be determined via a hyperparameter sweep using a validation split. diff --git a/CLIP/clip/__init__.py b/CLIP/clip/__init__.py new file mode 100644 index 0000000..dcc5619 --- /dev/null +++ b/CLIP/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/CLIP/clip/bpe_simple_vocab_16e6.txt.gz b/CLIP/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..7b5088a527f720063f044eb928eee315f63b2fc0 GIT binary patch literal 1356917 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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag z{;TkR-}PI&T*J&1{NLS`MmqO}$TR+^q9@1&`u^_hV8JBgETyU>7yvMY2kns>(d;7z z4gVcIAV zUyBO(=Tz$aw3z83H4$$Zh>4Xpsd$=};~u&v2HW!^5NJ2(XGdcxNuCup0f`wtI=2Xz z%WkvHV&w&3pEn7%kbfk;1N}iSpdnLn%g*Apql7Kpc(eRJE$2GzaR>qo^C4*umgW#J zf^%lU5$w3?xaSgmnX#Vr3}8>v_3mfyE1zz0NT)hWy!@W6VHC76XMbD{M9?t zCzx5@F0`0|2Z6)1?MM%~>RLVx$=AnnIZaVu!BB^9^{`SKoyA(ugr&29Uo+K%IAJ zDl}+QCB>OW=sVqG*nNf2o>Gw6l!~Hy8K;SukIP!~p5kT|ThW z8_3CaQ$EOKCiMICkg8Ap$vUQo=M88$i!=#RMc9+Y62`oxChA2)hsOm?;!|~$?h8GtWd`lYvhehQ-hs}S#Ds$iCA1WsdH^PFppT*=Jrt(UydpE# z9}14e<=+vY(}Ee;x`|x~HLij-pbwn*Cmzt9ua@8^MkWN|r&xEDxUx4B{Zs|= z*Bjrq=xIY!^HD$HChEy^E5S+H4wVO`82gwzDM+ieqi zwG#y0A<8geGYV+N=2PqO=!;;0N2Id72k}biy&S2Iv&AVp!WmxGkR1ZWM9eEmMA`fl zep!7?jrpm*_vNRiTM%~F%N+dS&(mG$Pqxd69fk`a(z&o{ywOua*s};pRJJ^C#tEh zyKB0P3p@htIZj2S87ThoQeD|%mnR}Eif%KH7NC1ij;DNhi*B5w5^ekF+xa|?w?q~M zNEXx69&2dgWctR<(TNL41LzNu27{|a^7PU@!txcYCR_G3hpH-yqdI<5B_k7z91b)` z2xxxzF{Y@PnslQDLMzXrRA;|+cmvCSp}Lz(h@|=bnMO`Yy0@BDzKoy(xb7?PUi|8^ zj{yujA!U2@olm82HG3$xRVayXS-AFuts zV(whG5Z8)*hRdf9s4tH{ss83~)2~)jy0lH)0;|?;Ou2P;hda>g;FM^_S*J!l2T zabstHT&LB-v|5fMK;zlzW#y5bjBrns^M%rowE~Ii%){Q&;b$}C>Do!^ z#~*(2@fU!6V&?rIRwJsWE(J2pVa(1_8leddbyXC=SebESHw*M;GT@#{wxS`u^ zN1%^{YJ!1%$z%o?n*N1)(P~Hct!NHjXrE5SswUbW>j?F6l%$u0p@mh}NM@PUc`6kE zsRpKO){5&Vcst8Q76aOwI%qV*a}4=4>y3G>?uP-~lL+RekYW0n#U4Q=EI91ccor+$ zv4RLK7lE|e+#|oGJP3vFjvU4k$}75^2LRT*bEX=g8-k*Fk$B%R2=g#s@}4C=Eo>6e zcAR#30MF2^&q9a9_oZNogxpWaE>8M}IF`C;@VM1*q(@QJsJ(H*RriC{W?`R(xv@8b zj#ZL^6p@_v5%!vtzKKyrgL6oSHPVh2CFls)tV`>hr<~g{Wtui`NJl1e#zM1YzG|jP z#|#N+cW29xN&*1ypZ{a>KgWnW3Z7u#SteXd#m5ICfVJL|&`gu{Ye}*wBykkf4OGp=x+Ec@vsTqw6D*24v8_OKRw6NZ9QcSkS44*t27~-Lzz; zp}M`kM>h+gS9>>m*8W-0@KLvK>+f&$?EwjmLi^hh#E$za1Z>^D?8qv@?tZCWc9nGa zhpX*?v2@S8C5MR|R;%duJj?UVV|M$5gN!ei1xGG`Bdx+b?0+pagW^>omwH4mHpS36 z4?(Y;D1obz48VxWBN~8iHY%Rvp=DFSTtc6EP>=dN5Cs#Q#VIi}8uEDe)h!+$Ai1GV z&2YO16L z>GNTWrsC2SV;70K=A59y`qi6o$YcTip4IA(uo-|+g9L-bKc7JaOcxAkvyKBWfxDVQ zDCuIGy7eXeN^7PhNi98{U;Crv$U{zw-};uKYkChtHS2ytLptP%f0me=i0ofS!J8tYC75OH86OW zJ|Lifog#N1mXZAc>Ct5JsHrF5z}>B2;Q%cwAjC*J_9_{79MGvQkhzl}%M|ce()jRC zN1oPtOC|C(^}?Ti#(@tTJ?UhJb#dNmy|U^FKauB3)O&Pbw^zvDs_cLl8WfoA#i1y= zs=!#t!GM%i9ez}H#^y`j5qqm+x-a%bpO#n8-PBj_k~H(uvBC*yq~jako<8h^CxWi#y(G&5D&+Qvb7(pvj0GK}sc)Fv7jPrn4!=z)q+4G2zO+n#12k@n_A_mZ z0DT;z(nr6-g8b8$R5Qewh=QVUS~=7^8DSDabJ2K$vV6$(vSZN(DdG~W6oE{Bll_cW zooLQfo@e5;l!H8|M4eIEqLKgTP`}b-v$sGD)y3)TlghPBp4c^^t4KMBv27aG+ni!n zkFL|$hjI!x%cyahBrkxD$l?JS0!jpXO01n}jG|?Qu6^34Nb2D=qfn&l{wF<(c?%&?=A(1-v|Yle?S> z4TX#g+Es0g3{(F-jMvA)+;EF}oz%SS)-K(UD-dB=8ExFQPj@7R6IQWi20J@DxC=Ka zmOui1=rJ^7u5uF9*y%jJ%d3}!k#Z(@!*c_~2nV+%6$zz9_i%+Lhoz7w_B(SUoV?+< zn6|~h@a>WP*Rub7r;0&ly(s z^*s^S{r8SNjE%%KIkKyY2F8YCT6*GE(t4nFabrqGJrgY~);m2|9^%Vo!-o(505546 z0-S=nPxnBN92c+|ZfLWgB`=?Av?jo*oXD14&Anh|0_xwU9PvUa8+F*AwI^MbBy7`V za#;$uaA|%cS_UpYG!1cWz7vq5Z&W~=n~wcNFJnNc42b8MMQ4z@SLnPQ>RX|`k>-lN z;*VU6*p{~*-E|7@`hJ)JXzCMn*B;4JPSYfaRYdgoBYiVCwY7HB;oO3}sC&iH1TuoX;1T#_4<)c@y@Wry~I>o^Pc)ypg~fjSoFi9;uagrXRU&2rge$ z(Xa#V%s#vjupWAFpNXo&LXWU260Riyg(v-I-w4F^F&=?WK0;|Xf# zm1X!mwe!G|!Vj%=fe1@s=$qIxbUyOCH2`tx1F~OeV)hGvy=5s~;gE1m7z%lEwPdU| zbWPEHzhtH;QuY51#Yv0Ck89=Vr#!N2cBpWvdSnSeou>53?f6sK`qM~kTM8I<*@|u##oRl=zMe${2_b1exEx^`c0}5&wHdv zmM+ly8p_zN%k8@xKNCAB&FDd`gS+agu?#F2fy1I|flHb!aHPak0AwV`yW7F%9|i6w ze>hyHK5S@_U`^1?kY3yoko!c{O|MAQoB#UXSFSZgwTqn51u*&?GoY+d56Dv8u)xwL zmP9jsoz_!zwk$0qv@CBrs+EDM;KNJIB+ZBqbWa|49-%PIxn^D)Y);CF5K}y_xjEF; zzQ8#LVgHDjyZ=5(wHg0ox40oyPu$4JeQc9$a{Psy*sT(_f!H$mvUsqXGRNFCnF!bn zEEJ=8GXBWy_!n*1^Py$h{*bXFa_Ezn{FqBP42pGD)+;7Pis4}bUm57mdiJG|I3 zInl{kfoyg9fUT(00*4Q3-oizCs{5d0CV=2B7K%6&I=w0-f}9ofxdnzf;J610c*QgK z!&dzvjMUMk%EP>B-+a!4XfjF3BuIipsj{oI2*Yd3^%5AHp~O(N5(ERw%@R(Gtu&21 z#{t|v5k#!MCU-?y0CiD_5GzcaqFYW0Z4gB-b7Y<;znf5+#`G#5@pU_9<^kM6FTHOp zwDN^FYbu6yn>a8SN}AI`-6#9}ks$J2DuupygpZCW!MZprbM18Y!d$ zCEz2)7_*yPp}D(s7iccPpK2=_>6THfdZZQ;w#!Z(Imf0!f*Fky^gQIXk&xyp$ClY{ z@KJ#QLc{G7R@m5xVJ>JJ&MkFn2;X=fkvz`(7=h=$Hw9oVqWMw^E3+}!0X#m}?1-|) zxY`am9UB9T+c9w_5ge7NoD{a9V{%fu~X)r>-S@B zm#m^4HYjAH>(@{^K(B(~;}dSVc|xaq{D9$KKi;qpeO15}FLgpiiB0%R&Xn9K^}`n* ze+={nS`uwf=&Kdy>>3D{8HxipC}9j@*EE&5wqIK|>Z=_6*%lByG_TG9q>^ZFDCwmS zxZ`ZeWZR}|_e^PhTJ0C3c6=?JV3=~vNqP$N+)e^BS-U+fCtM!@qmtLI4#@}(Afj3T zMndzlp}K~HEM%dz20#1^6GprM62n_}`0jVBzwux}D;z&@KK`zH|Ifa?;MD2CzmCIs z+l!7H5mA!@=#Es)bKE*7Z89_R$APjPbTcaigE3||=N70OLel&`+|=5wccuIvK70Q~ z75%dSgM%^|a{zdMU!1LQ!x+c4&NI@?PAB@C)DQw`yP0-wf}Uw`GrV59OicDBrWF8S zK%c)Zwfve>`4LVbYeKnZ1G4iJDr|+`>;I!c}{7Q7$`zQ5*uWjr8_qKVAVp zqX8jIMB<#T=_Vsl|1ae&|E2G*pJ4=uabJrvIrGtuWOU=Sw3BNNfvD7auNR{IFb+lf z&5}T(iPZ%SsO^48K*Yl?WuqeqG)o8Fl&A|Z80pejpwD)$ZOkZA8KI@JsV+D|2BX6( zUTP^mu+Q(&za}yaMZq=BvwM%SE@e1jcxNGVnC%H!W_GUqn4xzKzxrp~elPt9nx>)0pWta8Z>T8M=t4L?6alGl2*@-@HQ@niBv>kQ(6QQ-ceAxx zG}Cb$MPF$c>SJ+BYZ5n!Qt*#)yV%L_`dT6N0ueNahTm2nf9z+CKWWx+ zF7*n&@MYaxi`h)#(1ldAMcO(39@DuH=P4O_uY{9__QDuy5;>d=&#ZlF$LS@^idN9q zWrzZFIqjyq&0=+;s4Y4YA)oAFGGhDM1nGRKU-j_dIK@VgMx+oW2di)Dp~&Dy5WvI# z3h5muN*SkWS(8J1I84K_*l(JVUIVY5I_&m5(?*O1)y5t=S6Gwac>z;=o$u?tO z`>4L_V+*{$^L9|OiO3B|!Ls``FF>`x?IWP3u)o^gmR?P%nr!L4AD)8)ZT{@fsz3X) zd#KIb{lE(*1V9V@Q|uG0>dx5ar3rhQHcX`k%^5DP%$bygN2b#Q4Y zsayzH{dx80_GTFugnxeZ>)tBj`(ZZD>QW!>RdX!r%pVVcGrBbZJX9wnRNg`r1D&FQ z@o-TzoRPEdz_040KZ6HfxA)SMeyEx}(K|~IxIYn#C{DvbTMEs@@q{>2QH9;5p*yUo z{5~f3CK3QG>n((gOOQ`ac3EhtxB1B@)hC~PqIKxGvS35~;kH(R;{vi){qHSS-}cNY zHE!69xRx|CkGd6_@nfaIkSnwU(2H@g2*Q7($hR!=`%>N6A#AdPOk4MU^k@4+@Aq8z zz2`zV+@~z_4tNyMQ5MbYtbmM}lvsw0Ely(S-kcG-cgtRZAZYadP2YyW;)+pipo!Dq zbtocF7ZDn1m9$q!g>F0h=6mXA3O0)o2yhG)eU;STy%uQFQx5_sQt^$LXz3o%)#OOP z=cF0nIeZ;5iy2nyqMjXh4WoyyW}!i~(z7VOKu$In+JO~nb0ZYJEU)p2>=t$cRv*?G zC_@T^-`;`*MWVai6Al^n8w*+(aOaT}2=3oX`xsy0~ni&WilnPTw`l0wQv2va-;zh2l~C{-wGKYj?{7rv--> z_KMgP7bHg^xjx(Kxkr@^^uyLvBTJi$7nSgOTRTEAW*OSDjb??&+DMEWV*DO$6daqP z$(=zE+pK}~#H=~Na#mtj+MofkMX!p^o)r`<24NASp0z{X;eqoUcH@9wrmW7N4U7RA z85}|j_t4#XaMlFw*t56f2ocVwLf1G-o&`g;zo`B!T|uh22HFFqe^0K?Z6{aTpUTZP z&0%53^{V3!Y9@*^81+ojel7tDXVy#brO@G)bX-th%sEIDmT>JEWC$Gc_%bQg)@XO=dtdt)#d4Mbfn{vZGp-xle{m$TmSM&mq0Y$fM2pnWH@%)ONfP}yLk%|3a;m?cXX2)R_`YCJZ3cK`B9EFzL^#lxV+WzRn z&)VhPfTBUJ!_K94y{jf(bd%rVF?i=^+W9O+Tx|j%L_I(+!$9LA`g#GhL=Ph!qz4!> zN`566NUrF!7S=OetE7HIEzwgW?-^~F5ny6vchX0$r!Y0P#gmw#%YJj+^jLU{_rpMM zA5rw3s+T?T>7kRZ6~?cD*!t3c1xDoh^uTv{6&z8>3Xe5`tRO0v{_b1$Uxokk8+!C1 zECgqf2+a|2ap8-`u9oi!+y&I1i?F}RwJrPfB`iQ7HHkH>L%vrS(yCoqhbZ$C^pI>? z+GR7RjvVTBU$D#lx%?L&M>J^Tsn>}V^6VRfZ~`^LXEI%ZE;&$xFZ$t?ot+q@QBR=W zhw!0A(*koCb&hZolPZ&kGzm6ZZh^U63Bj=?{0Dz7v;0XeaE9$dmm5sg#}iL2-33bp zpgEuz7o&Vyh2@xmsa|RsA!K4cABH(C*rp2;idvAz0+8TtJv zr;(3Pu1plWj^m9dVxWJneXYjEqgS1wR1#qGy+eESz>QKoWdv@`ZteQ%jx0~(Kgo?U zH`ySZw5go~8948vOoiCo&<5~VNV*ksrfV`APS~`cB3oGMo4*jEg!0ZhBc1CBg8~dV zs-(qfIV5;T{!H(%T>)KN$7gqftcduLc(Az|f(n=Ni3!%nyLTQSso?4=^>!Je_ecWD z!BQejvLL|VIa9mydH9{2=0|lBrlwO)jyCkuk}yRs48ahws503HG`O*Cv1{c$ZTGtO z#T_}uD$``({`Oc--rR=-vJ&rssKUY<>I@N>wm+RHEWh=K!qf5G&4rE+%KgA^a*8Xc z^Z`t=0>fa z=%DmK6`%K>sv|2+L^&Q0FlQ zsv4TqB>BzuBj=f-Ln3m3(kAh+>{$|^W3^&xX7Q{Ng}WJVrFdGmLaQ`5N`1DAfwl2? zBw1l|ltS=cdEpuS zTg;Ois=CFoML37WBTGpA&ddt>7)a+9HOW~rgs8Jy_Nlh>omw>>nDTUPtwS6fls37< zKcjL@`t}Ll2vov2x=dH`zLGNfeW=NGvFg+3g-e(>Y>`p;6Bx40Jc|a+7?)D<`3WJE zl1{ZxTh^hWIoX1+yM{#KX^6(`*cXE-5V~~TAP%HRSGBZ9#{TfY3$eP34un2mt;Q$- ze}s+v?4%>IO{!^^JC|n+4a?)s@9Qhtk1ZxVmM*kV?e&lIm*1(rlgt@$5W)fYs{SUW z6$Gc9i909HNF*k{O2Lly5P2(@yDP*lp){cF+NV%%2e@%+7} z(H#ZuC;};0AFFev!HZ^i)ml`8c=N&~E_);dv5=bwK!}hD&sc03%SPLqP5$DGmWACC z6de2-qO`vFsCqQ06P<)P>sJeRT*d^JXIV$L=K*3vX?Sib3B&m;< z0kBknHPyxM9l*Qj@p&W#9@myc!FaysX1GNy*p&;gQV4jrbfxqAa8k`Ut>o<|0gv={ zFVzv7L?frvdLp@|Ag#G7yCk&&S$Cs!yK5X+@ed0$&^o?xbPgK zM$-+1@bGoT;eYJT{gfR(KrBeD_Iu^tP%v~z;i8QOZ+#~Vt)*MhmIz&2!Q<_-Fu+CU z{H1Hp;9~@2&~j38lj1~Ppg|khHTzgm*YLzDJE{~t{`}*=z5hXabb4EG->Y|4S2KA` z;inH%3`*wuRPs0%I`s<>;x&3Hdm}4`LZQcQ#8Hrr-EUxb17b_X>i6vgpsRRPF)rPPeS5)7&9k#n1ZntT z^|~b<+)tQv*pl3XAx&Al@!z$i{@|aJaekp@QZMLr!khjZ%d#NKSCeDo(fj5f{1?jQ z-_UT|vi7LG?5iqrG?wDAP#)WMrEQpHmJKEPL#KFj7@a4(F_rf-5tFqxN7aK@qk|fJ zKFW{6Ufmy)k_k%>_3UXrT!MjqBSFA(9cGTWPle|edZ3cH4tweJ43;sYB#(5;k*YLa z9K)pB3zYrzF&1SGoh^fjT^Z4+;Gp~P!!DdhQ#U0>zBlcoO?*S(l3g9u(P!=8Qb%kUjVw5U|HcY(;u8g2G`ZYM%^K`qCtMlY2byz#BU4fR7cXIeK#Na;rz@y3CJgFOvFI`SFqdCdKU{JES~k#93lO zGc9C7114cq{ICKE)z2F0=N1B-U%&TlXqZi>Ua7!UnvHk`IlcA4*DO7d>c@~p=SRq=n zMLuLq?byUWC&@>>3{{$>I8aFA$XmjH>|3D#<51f7ze}GY)2Zo)ocSEnrkxNU5IwEs1J6IcKkGfRg=vdvA!9u`ss}CRku6qAl z4d;Fqex&Js<00w;BE)jkL+!#*2?2W0xWW!?bmN$3(&BQH?>1M<Te`#-yRlowR@6fYRm0R+qdG3`}@_}b@gV?Uj`swtH*k{;}55-w<Q^0ZU4tKhF!y^826V?|v&?C@$XcQtF;FQNoMt)xdBL z;VEq0d)}_>v~QGeKw+F#*#+2IQnWKBo0@`ppwMsdV)39Z6AJAef&KKXU`SLYxm3s%4?{@^^a)6oJG})Qb$n( z|6ju1ZAX&qx)OZ%uP|zamZ%xF-qk{@f22W}o0+>=xZTPw?&0wupvnFK=}kRPQjtYc zB1KZXv`AKo1TvHVHG8eI*FF|C7>oq4va&KG!p+Xv*L87OVNXmL>o)tM__=|}DK&|1 z_?kc`_H+Oz!DkB|!s(`A*X4w{vWC%*PKkYJ>;*=w8TcwdH}b}>nW?S z48V1JKg!y}i#fW{575iw!Y0rHYuLA2<8|(I)RNbWo*(2(?4Akk(pwF__T@p?5X$ga ztVtTg{b-WQ*r;#z@M;i!vcrAg?hvL{t8W#e-lUk4~Wq+cijuWP-Rzz8Odhw>J^B?ZY zmbC0=XkaxW8IQ33>B%RhxZ|v9u@}iwfgya|h?!gC)>A93ebMCg(GCVk(p&+rt4w6fKnYQq6w^jOPM>3ZMoc5~Jr)Ni+80 z|75jbjbgazyEmTE7RY5!cY^;4H;JZp%*3k7Sf7NoRP(s}QZ{&Gg2VgvwnEg+Kxw79Ed-2e#D7PX5pgf(3H zOi52$Y6sd@TV=e?pwnqFQ(G6(c>{JoXny@%*_!NlX`BQmRpGMOHcLsgQxPxg(X1G# z9zdK2FQt2IwrPjl1hOz3=&}IPi>L_5WblH@CYe>U5Gbv1T3BkZ+Ub#p=y!Yb>jQWL zbSR2X#S1E*VSu<{%#^#NV=&KIl)i_D!5L`8CQ~oA$lZB#rZxvQK&$H(Z!ftnK#*F;3>uuQZwHgPcMW2H8S@ z+mRkoqnFr2ooa`0nTRLJ7Jli*6)6p9zrzK*PSEehTmaXYd|_O{Q_b$O(o9& zy8s;paxhzL8WBuSRiMDJu7N-D5b z-(fr%yBv!K-cMVdCrMN!+7Uh}eW>L_W8&-TQ%RWcbRPV}cO&O(dYh93Py4O`L~YcM z1jEH}Rl?I459IhTq`m?21@`TKfMyBIQOG(3odmjvN2-C9h^QZ9NbuGKs&Z+P(4#LZ z;`yALJcvs=)jp8HWX;`# zrTXsVp(|651~Rxaid?-v`fPWOxS`d7uTz0C?vgz5;u-=pRK}QX)f;ZIBIh)|v*3mg z?@gnVgB}3HuZ}P_7q?xtxOa`Lm%z4zjGDefs-yivHdi~R8D)F7kAOlnFA6?Qz)Kuxt^!lyUXqY27qJzGiALaBpNs>s;{4Mz^tcfa%VDe$|lt@nQnCJoMke%maOg=Kw7$^t&&y%_A8VNlC55X zRIujQVEOM-K0|x|Ws@#QR3f6-K zDWK*sI1D+70gXX^C?&M+{Z;GlV^)IgyG&*79AlzGP$)lJRkom9C1Uim)cr4uzx>PeOs~w5p=J(-39yl;=M<_QgreXSctg318Nd|;)!uUJr*Z+PXxpC)5qB3 z(&tTpeR#*Ak6k!nJ(}!L4_WD~Q*r@M!#*1tI!V8jV$LPq%@fJ6mYn?nh40&{kj-Q% z+!I}j(~E(zWme6A>UREkUlpHz8&}&();2I6AV($vYb#Yk+NkU6;-ZZh`eiJiR^3PR zlcCYS&-I};5H;Y-q#M=ky4}}e_nzS<_$(N^rOuG`acGC&-@F&KQ({`Eub-!9M2}e` zACMq6Pg5u}Z*GJnI}~IDg?#9Jf4v~LL*o;4JGGzfomY8F9wAl-^34^17a!~GOC%(2 z$+0hKln3h$HE2~tbA>(2>GidEJ;*8jPAoS2#fcVjDS+}d3(*D)67(BG7T%h=4pnc0 zW?nnH4HuVJB7=t79J}NI4h@y_Ie>BY755W8SPwF_qu31KzD~ih zBhT;JU~l2oa$uxdhE1#l$HNrrXBf&sJc6K3X{KG4GG>ujfk?5%rw&nh7Uz)v0|y7V zn48`LN0iYyWQR5jT-)hW0$<4&UTf)gy^=Xy;=cywlJfhK@E&c(@Pp;JlTD-a<&y}<&4m) z5$q1WeFqeRJrsHezZ7zNw<0ITGqo3qGupANw?*Sw=m$|XaFaikMc|P%TnSHR(J#Z;idX!A#lICVzZ0&5ubfMI0$-v$I;dh z2>PwXIRpkkP3)bvAA*G$jqO(@q0&|Bci80J560xF2!~-z^54y4qZP2X^}?>s`&JG! zEL8n@@#jbnR=rq)Na&al`@h2|m+n!U+6KEOJ9s_Htv4a_FJgUMaAp)G$sN$D6hfTa z?#)R}8w};aLDPP#nwrphNd9}lq~a<+{pIN~S^_9T3+|mRRWOU|Vs`XZ^l@|Xa1Es$ zmQldtDQ?)Ax&gV{$3Q+U#$pB1OaRP<>o)bPYKvVjOZNx^ns#imwg5I1Q*a!5csq)0 zxN*)CUz!6T%!=k2BjxoSf8!St}M;~er8#M8y`ruuCB z+W_e`s2+!oQ3)SVB3zyXN_LDfA*>w}E1ECKh6-JHa2@0=LY+mSIR;(#sK81YQSV4J9 zT?r-MhiRRaF-Zr^+6&i!E63ZiTf7IW8>~S8931a>Fh*bw_z?=rrg(;g7(MJ#1qx6Hm>{=Yr&sI_&$*nv6auOiF zr8=NpOGx{rXMmP-JbMBME8?e0y~XR)^hk;laba=IysRum41{LVna@OXe4yp&vdw=heO{eUPs-`xJzh! zID88d+;D`Dtg!{aM)uQ}$*JvI{(psjfvW-xoKFF694Rji>C@3&miB)I{>SQzR72Xc zSTd@7ZMdg{+|*Sy#ztFAITwu~I60#|DX+p&|4%!i5DMrg2jNJmlapS=$szE)S&39* zU!Wwyhj|7)PHMZcYI(Sy^ze>Zh0aEQ_DXqKqBARaKiZc$z0>1v;5pTB@fI!iIyVh| z>>wp_EFvE>>a7P<=Kx+FyIXN1yq*R7g~Di3$GTwusogR#aen5BwaR*fD4ugEn^r$T z=g4l^_6R(Za|#I8-{Q|avUa__C?6}nTkCmo@C9^&XSAH5Rf94q)BSfuvtLD#VPDo4e6J|BEle9Nsb?Z`^ z7BsAxOYZZ~W)Z=xv7V!Rlv(PaFO-SC?MCk}=uoY9vpX50QSKL9AO0nbi(k9k!q>18 zyNYB9s6!q0 zn_>qM)+8V-dO8YG^iYNU_^%kF;Q*vG;oO4s5%26BEPY9GW_Nf+ z*-8e~ZtI6_uCOlscIYeGn3@8nC2~_keQ77Z zJ|?QHWRe6;M>QgbcEk*deV2{Sp*7rN59yoE5-JgEDS1PP+urQ%ju$A@Dw_I{PBmMqYj6yS&Q=QEl06#?IZkB zD*@;*>yZRT7L;2V(g)sUSdxyG;iGE((vKNNR&UvvJ{esyxwNDe*zrn&@Qu$$>`ltX zU@qU`Iye&c`gDELjkM|gJW(*6zuLtnF8eF0&aL%W(H+=(^c7~(0%Ssj4w>@9E_wq&s(oerB(m&|iy$iNAXw3!Zl8i*nWGxHYXl;N=@J||8L#T0phh(uk!_C@# zMCqz{_7<*2&*E;E%>r{uf-kJ&o2N#_U3RgxOW?KDL-^UTc&y1izQ7zYD_&D=&yJq< z)gAacUqi)EQpLCJA%Tr=FX?Vqbb%_yDM?GGQ!%n5Aq6Nl(cEBd5Tjm0Vv$=1DmtNz z=!PUsyFhJjIS8LF4QikIkYQTOpbvPeEeD_z`*J%^Ghnx{ztMkc%k0csmlAsVwH&qT zKpQ}LIZyqd#L`jx&l_Z7N77PTYGVDtDzGo43^a5hhIyT8yOJ6%Ama9i+SWpQ;l3>E zl-$`Iw1I9h5Hb+r@T)a3r-Qr9n6U3v*JMUD(YFar zjT#O(B&vKsI@ERkVc1Dq#vik3gI0H zDVYUZD)N68U;hnkUQ_$*hhxSY2eot>^KKQ>{DornBD{3xf)*bZPSCoCco;5wj8)gr z%B=RRzCgMVAR!xd6jhKswNxLJtmtR5B1m2_m6SGtFQA0rXmi8XK#*xI&nnE3|DXIla|;(Y#txT{5)7X<(Al*R!XD3%urpj6;< ztx{aI4jJy*<#6sI^I;e&`_1eq4C#5t7gp{B(c(*;r&xltO?U`a3?d%SmTa5_#g=Z% zrg^k9_r1AAm`4&Z5tIx_%Z1geSVaSZDSv z1>-TjbMj-Z5Tp!4V1=t6`K>!2ww{P6OXt^Pz#s$zdr$6GvR*eV*^kOYl*8F9fDRop zXt)Bwh7C5viCTV`Zv9dQhEmXgy;NqYzL5?`nc zUm&;kZjbwO^lj%*E(CDO%56V|bsXsp?*>kToSjR+@!%$fU{g1TUwRB`8Qah0VmY(g zb#%hK403^q{=acQ zDS3C&*n*}s=i!GPUA2Pt)h|mId!%azs8oUOTN&{jLZsbzkAQ}#k>WWKN*YUZxe&_F zQ||L=h8kLOG<@R9Q#x!G&nW=o@Axl@Z@I8-Rtww_D`Y+U=xWVZR%%|QAz}8v>!@># zu3r+3(==zr${mX^AJ>B;;uVDTwTW{rP7ogq!2^S%@V;AK5 z&iQYc!XXb1bX7|+ooSD7D(c<+ z;3U~Qfnqff>r0ph`Is6@irMSM2d)Dc>don!J}V>es#W7Z<|KMZo(`V(?^y@C0`*eg zWNz%xONs`)DR%echOLmOL<@F9nw+&is-~-hr;6K9#C$lg zt@A;`vMWM!8lBUmEeLjy(?WwMsNRar(oXjCa1mr*Zm{Yr2h5~Pp&2Rq=UZl@VRCK% zCUajeV^t6hcCape32klk?jQdigK)?ds0DIywe-b84Ft_YlPxdS0}dgT>e(-9qt5M2 z#p2c9`R4QcCFoEC%#{SK+CW*J8^z1z)?{D+0Rg@d$Ivj*XCIUta9jkmz%MT4l1eum z6FP|}6mmpStGJ=JB5yzmvU84zfo zVou<|Pnjl~H=Rn-KRIQKNO(JycR0Se5;5keJg|CLHCGOffI)w0=}-ijP{M~&4!J9S z42#*jQ>eWC8&c!~+RC`)U8&^&De#Z*Y&wU|SW*L6n<2!Uhv&h61VfOdgro8NQ<8NZ}NTRl9>4qfQ-k_e@Z1o+6y!H}!FB1c~JoUuNs4#r9L z7XV)>vf4YC))F(t;JDExfmtSGqKJE4_v@8I4tYbAg|z#v{I^h0Lv7mYPb-~91mDB9 z51whlnFHgXxlKiif&k>LBmleYGJM^$c6jjKTWc)OQe*@8WxeDPK4-M=5UL-(iuYTT zbFxsjM#8>G2dl?xzPq01exf}0!vu-xsuMhn!_^hIaj ze13Y;^P?Nzk?1uE$fvvXNU$ffh?TwljQ8S=&3AfUfs=?jd zPeaD?m-JflAIl1pjWYoIh$Im^f^^2G2?ABJJV{NUg?;DT0*U3Hw-r+&u_K##!=&|8{i4wguAYKJmc3-2PFP1%pF~pb9cCMz}yRZJA z6+I=|hx!*gDT%FNHD-DKIW32Q5mBaK*!kxiItWt=`n*;YEA}Y6X1`5FM5UohWS}SZ z%4>Y(^bsuO{!KpjG%xPt4`gTN5*^4alb6&)TC%lv<9o#)zvB?B1M3YBdTox_ff%s) zBP4CD+PEiCX-3aCl!cy-%eQ7ZTif%Z1O3`|M|2mppS@`%09Q+u8|?LPIQpja83U^cvooWB$tZmUPTiH(@kfitcZf;LVe?jNmp}#&&`IN&0l;3IH)2mL!1! zEG6o&hkNOkr%_uPC{mImdkAWzak^&#D3DM{V4GXOO@3>&Ea4_EAru5Dt|p?*O$G!6 ziTP=<79g$#x20A7p5U%yH~5p{)4xJ6Yg9AvlDxO2HOOsjM+?YA@(Ut5(BmQg)}h;# zF%bq;P@}U`e<>c4j26-qq>@CQ>SFLY2L%B8gA9naBGmH(2Yf%`xMCz9vTB#a@E+jA z^dlC|xZf2Yu@br`6ikD)Xj)&N}r||FjP*Nen+|4VvQaPFF?8!dsHXV+Rg1Fo2cS%9_nfyhnJ6%ShWWIEqjTxmIz zTSrCY{HJ*o&mENR({mg0AF7w^l6K7xGpFkZ^R=e>n|flGUcB-X9y7s{6@H|mlu z5@5>eL}cSeP`o!sQUtsE+0!g`tR6l3G~Dja1o-*G1&aCo++uX_u3%xgwXI4_1oT19 zOBtrVR*v5CC;HW=-wK-fTmOmFJ0=pK9~kcKM#)l7+{|w<9tEQ`#Cz?bRvD*h57LXU z;?fZ`wUw2XKGngm@7m-*Hi|DWG+a>WH9Cv03j6PWQe3S?RLO#yGf1!25?jno%+H9q|bt&ovjsz0)3vhvK4AR^G zUznspr42UQ<2t6&XL7)W-ez1DX)wYk}0gC^<-mR9rblS|4C`gj6K#rrfY&;3Vx!<>Ps z4BRJ6HYdgw)HiM8wbjd%i}ImtviZt*baiZSC;ACuFtS&V!*-co!!{K<9HP?mbm(dK z(>ofR1+Y~F)-o1C_QS22EZq7y3IK$Mrfj9;1c#(;uFVqmgnqVE|2|@db~{KA!)s~s z0UrjHcS4)YTJPR3BTz zM@+aag~^+OSJSgrJjnU%#azdcYk?VBlUCH$C1p<~*_*EF^`W7zC3ru&_Eewb@P!`x zOr-!~W`Y5Nj;9OhhogZ5A{MIpGhTVEmCd0Lz+hu zD%lBNh!dO8B9fu)7L2jgsZ#3%^oaFDa_ndk5WM`nWZ94U^{~74fJgUb6vWoWKqN~B zEv}`4&^E#bk4j~Nmq72{n-lxegn`GEO#op1j0=?1yUGnfJvY|$*}HU2pBY%)0Tu9b znXr``MmsQq603k;DCB}^R4h9SG{8~4Pa&6^M(~;K2fR?D@|Es2r|>a37{dH%@u!xo z78;4BA3JGWfb-*V2ZvqYu0trU6U8N4!gdtul|&iFGiQ&1)Fz=y` zrDf@G&=3Fa7ui3;3jAB7#tprMZ=6C%ZJ;>VnjJ+S(GguRdeN)I+{LdN@jltRtfNe{ z3u*5`T%5u4R2d(0|7|(w3ap`@4s=%)q6kTn=CTl{Y2~zMxdHB2C1#z<>zg-KaElRO zm&w8tWKADeep)ZnH)N`EkO@YPu=ZLiOViGP#NXIrDhlPYRu1bVk*-rf9qeEMp#e;t z{~p|xRGokr549GIi(($!c4A|P8(|rSXNS=pnJfW=w#S?#{UuX;4|+@$=p$^xmMmSh zD3Am_l!M^9IR@}YckmS?Gfs0f`&iC->TX4drUU`qzf1oNW1q7ezU=BxF~Z9u%jDsC zwTgGw$Ecus5yf07a0CpR-`TW+qp^8pup+`?XwaVsYXV@lNPYE_U32bAA)w|RmF{8< ztmVNnKoi?@ey3_V9p}9rjN{;36(ajRcg@i?^+nqCigU45P?KC@yiEzTI=?A@x{!kq zO{4)-a18WK7k|oW|NeFkt*9GMb-9b6)ftWG1fBrQx0Se;Ci?JUYL+l(E_YHg6GJC6 z$B;6kFaTnraWLg8cVOZCaxUuA(l%5|SX^i?q;K2IXCW>QbPXUXLo=Z(xL9B*x4V^sx?xu>C3FCRGXF&YV$ z&)JBu2o0AD-2&2gwZg*%y{*_;0uq71wKU1#(D8OtfFeiq5<#JY!)Yu9&Q?^^h{!Ku z0@S4n3J8y`(KJ9SR;grVB>sCx-3=3T2M?lW@YE%>b}}+WZ-u}`AYdKb%qL9AMRX4n zS3-(L>b%ESyaumGB02w#NagTAYd9xYWdq44*Jp`@vnIBb7M_@WQRa;bcUCFa8K(`q z4WH{^^&c+mvZYducoG9Q9g72;E;+(jyg7%UCWT)R zj8p@zE$jC)OR%W==fq_4)jkmOLCL1`AX@XMzQ?P-1bamT*h#>$Y=Vvy0{%9ysA**J zYM~`#EsPV6;TBzw>1|dhM zZ7=3sZ#13@t^cu^QqRAF5?ZQn1gtM*1beb;y0ahu1zjpQvQMQZw^ZTkOmlz<*1?(3 z0>jlpMC^)72|KT~rLDc|51M5tjl&(+Cwxz=P84it66-%JQX0-`VoryfBj&PIrze0N za5k~F7bNwjPV(wjnxyS@K48Cts_Y{BL9|@YgMY7o1yaSl7Me)wlm0_Ym@Zvx!S)OX zJvXJKqW}k7br|kb1oM*l@qJ}Ib8A7<9mb(V;)Ahjdl7#?WLra z1qzX(A%GB07cZdGEg&H8jxlmS0J1;)Q1jKRC5}r53Rvm7?T7K6y%m~y2CyZ`!lv^~ zF|m_tKxhEdHU5J^&jEL++RvxIF8&${$MQ8^w+qkq;86*_%YZuxt3N>*JLasn&|=z( z*LU(1;!>7t%exsybHyrqUr23fn?iZ0TBCdXeA&V5H*g}~x=0OBw@S|xKj}dGXt#mD z7wt|^L%_k&{(Rk9(e3Qdf`WGGcqcZsM_Q`KTO9UL~e~8d5^jfxEoXrK>w$RhQ`wLt%ynWHSeQu z=uGFS3wP26#2KVqXxzY&VovCB3kWoZ@8KaPGX(o-oY&VMc259xa(HBANK>@W{oN#m zZa{uukg953lVFE6L2sG+ov?RJo~*Q2o`FlvkB=rO3sw`NjUe8hmkt)}oyg`6A+5pn#ei99Cmn?K{@Yfb8e1G@eNfQ3>EHzfXwC;^n z5a}mACB0t+=(OrSJ*jfJ?g#uEboqL_i5hdD&y*B{eLX8rxQ=lYgvAvV#p@$zpZ0go zZ1^!tYLj#`5Z8z0119oG9b>Xvq)qjQcOE=&y0W%()eGGh%Ioy9cvmg9MfJTjFBz@m zdc&b~?MHA4$4jsh)K$Q>ei1DVd~pa_^PE#fmEwGY@PmhXIMUmspMzl&E(0R>L{R7f zf8+)GeVC0wdI2V7+JfYL zy0jv7%~n?Zgt?-78164!7E-TDLP)%gSR>dI;SdAcvWji}wuItH4^p|n-$BpU2QL=+ zh$lM6S(FNdiYm*aPl0u9q~_@?p8OQAK$)yq!3l(CrNMEcSH8*H01zZer=r@-&fp>V z#UC;@S)au=nnGe)?!CH(n7>86;{k!8(c;9uNO~AIh9}ER;DiLkMA})fLnI@GM%O~y z!ko-gS2iK-;$=`@p?HL1Mtx-8ZDsM2e)r%w=j}kT-IMo_w#Or+Q!NbSN`enE{nu%~ zV<+Q`MyqR}YEVd;ZYXY=^J-ee0dGd`wlXAjKRPe+MxD}L%Y%R&ujskT5F1Vkoyl%A{nv?ePsj0v>-tKI zy12A2kWO*bkCdWh88UYTq3oY@jw6_-EmFlTu%$jygBr?aonGfOved@UADXS@&*d@0v ztuZ~FU@M+EyR|ViQsJiUmycBW zn#n>O(t%uK^|NrcP~Y%|ankily(gr|Q(vOYvolpHhSI@w^P}BPQ)qf($>0#M!9Lfc zsUeIW>RO+{V7m@b$+wC>^)pJHCo%u_B1m&q@sNZT)QO-z!T8JXMV2;!N<#Xtc81+A z9;4JW(#&_|(e!yA0rW;w$^>)>HcUqG$6cK#Hn-d#|6(R}C@BpPF{y2t*>*nYOT)LI(&-94wgc( zN>9L2-`eztbtUIdp31D8uVH4KzHEZBq1w*~5gig0kDxv0&A?;9zTZMq=bx($e|E2K zu5Iz$g`lL#Nx7uMRn}B}O_#o5(Dv^LeXbnI@a^-nnfob*y}PBui~l|yGJ`m}dzHVH z2ZHk>R{g+Hi;0?AYAAP->V3Kha6%@w2LIx0z7*8O5Cm#`6p`k*EgG6udZFB!U=@u2 zLJ^?`pS2K>1|y7$zEgVA79-}^)+5I?-Y>pUH#RSa${rNea?4B$NG=B-)t14!JO zO3xdW<3J!kYJWaGiMF$vZlj5h4|P#bkg@ZGm`~^`|J+Y{8}-~vS;RO#cGaI1on~f3 z>_pbX9)inqoxf7!_~7eNjN3mpO>%YDKNna2jYaAu2Dq&h#?L?*C@Y`)B8wQ@fSh_F zlnXQir5CABB6)3ZN6FAex9tEuloatt67td3A%Qcv; zI?5Y@T}(=?k;(%~iWj9H``LvS4r@P|;VjmAhHmw`VfCoOqo>bD9|D6JgXc=)u^al5 zFkPP-VcOgc=;51;+lILL92oO6G*#0Jw&LZPH7tQLTj@epeEQdPj4TJ9u467bFU#%? zmBiyXSVWnBha^qkR0+8~ojiNxdX;1LH3C`{ex;Q4T+r~hXawgnjoOgGH{1m)x3*=< zv{Dz@Js27`&n8C2)q6c;yQpg1Es)ul{rHa`z9>HZbNU%@dwi_rlrNt~_w_q{U-iM~ zrcILswXY}*Q#}5wZ@F1C2--QWatDNS@!6h@g|QO8(IL`0krD*(5Zt$S0Fa&3x{@8% z)mpPzVpAnIn`*?l5s_ z9WEw`qMyT9sw`eR>_%!#$ns`?Tk>#WjXf&mG($oFaPeAEiGfya^IsHy@fUyL@6dz) zP!-qZ^yvr1#~*{t)yM$vFgeOfzka=*C_NEGHS+;Do%~8o;+f%#7~0 zg!OoGxK1^)bq5-{$WANaHy}qBgBttOtlmAgZBs5YVSV6(Ey|}ajp*DzaEFHvze}$V zg@#zKc(i$5|2tsTEgszAfjwpqm_Z#p#I&GK_;@IE_zT(j&;?XX#G^j(wPm z1D?fcFS=#)hi=~5Jd$q$hyKBHSAx{M9O0tE>2gy$bU-4@?gzK?vcDdD=yu>nr?cj_ zm~cCeu%C{NjO1|q6y3`z<}w}U4tVaDq?3Rlp)aPut;ovVl9A>VM$5ggPV5;&U9Rph z6%PzZgSG~mTG6U4lLgb=g94{H#Lo^Qe8PeJ8WcUc`at#4p1^K> zST#vjpf9Y{BBwp|{JQ|En9Y3-KPlwK5UVVY4z5=G?Opm5N2;<(O zbOQ_p*u{!f>?t^?3D@dphweYrSrm@@XT^tKr9)Rq^~OGCvfcK0j2W$HkuFw)R&+KMHKXL<|MQF46y+r_uPty_JN-UMY6tCY~eM#1*FQ6k@J2(TUO4@ywyA(nEDC9l~?YK5Ppb=QR4?Q4hjAt#f^S%NEzT$GVv;(=7 zUYb|IlbwPSL+#Vp_60=r+#GOz>wwiLHWyY%L9n*c+frhHBCjg7xsM`%SxYr>uby@q zo2+yIaz@w%)MfEm`u68S3SB);6af}C8xPKZ27Ugw~P;}Nf1l|3@M-zCR$0uC970jx`O~l4ZSWxq-delkY($4AFi@i zs6As$K-905u|bVYn8NsY4^+U)+)wWAwX%<%T2lj1>Mr}3roe~M^york%5BxO%+qqL zm+7zV6W3nWY1AgjfXkRL9fa$^-c}0*lM+mPM~fO75Z$CBWv#ntH$wKUhbO$ciyygrDpu(>#KX)s-r z>uMRvCWr2}31_|JV+;`}W%e=~2|?lugkVAS|D^bnKS|k78*$)fp-7q59Pn#!2QobW zOo}}Fap4U2JRL=Q&?BcH-)&K!uR=^vA5jbp2U1b56O`6u5fOrwSOZcjvQKWcdY}yv znm{uynbWs&D{mKr-dBs2D+`78fxe$;oy`5$BwQ3d7wrS!SWJDc0;bd`DqOiN0xCPlHgOcB5C6+>PWJP(Hi+E@q53+rnjqj9?^##n<$`@eiY7T2M zd+LUn6-rnY8DNm=?&7qSOpp`UN*0eOy&d_$V~iCLka`s)z)E_%YS{G&mD2%N*@SW* zRZaSGCzZ3&nZmXhTVoxIOsXdslHr-M9??kd7KS8VH6}rP!AnCU(P4rRdrzlqAqK{4 z1_*_gl4RHDmrBK42wnjIKPb*l6W36({Hu?%T~J^9CX*=8NI#Rva0e`Jakm1lo!o;E zTLE_mnta(xLmsbrNVg9W8bEb4=z?#b$QBL+Ql?sNQT>69mLp${b!OtMxY7x`qYpL$G({?P|0}14THtZu0}DE@KKdqu_!QB9 z>;^~IZgJM~lofb5JhBt*x?@~cX>w>un(CT<4eZBx8rd3ta>SMWClFB4fwnm0v{;j^@j|*yN4#>m;GS^Sh-_Qgi66@q!?2L8Ra>ITKAF!K!ZLJ zE3>4BbugtofO_BOAz?1se zPKptG*^4)aZCY=x$pWU7H~W-#zhsg%z0e^pqy`8hcpMa}9@^HDGIa2y>OpS4r=$Pz zC!c=w>8Brm4D`bfxNnBQq4$FKA~b&kDcIWsfbprNN$>SA)V9FCX~fs>@8pcLTnU*a zfQ7jX3f%y-6W^h34_NAiw!rQV%#O)K5LP>ZLnEpw-=B9P(4M-H4gDe~7{C<)R>flC zU3~v#@!@AD{@8JI`&6E(A60b*+jFpW>>rT5>Vp=pk-*wecJeAuOYD$6US?EKv$6CF zkk0^94@F}d##HpA(LviaBIgNppW3$RA@87t2Q;qU^a^fMnv8%1R2~$U&`()|)?w7% z1oxq%e=!hrE;m$L*@*=VHeL18E^9I?Iwr(VKR>+z?7dPpv8SI4iBm{f$4ni8NdyKPU#Tb;g0BBH!8qPzik+l56ZCrZ;&d z&g<^6g~I-A`Q}@oq7OO;^m<_O+-mYBCu_vCY=l>gE=;lm8|0%^D7h;*j(C!ReK@0= zb$Ej&+c#@14;fppPE-OrD)zK@4PWiskZ$8)RR?ouRusaWW$yOqnN+nM(0@xwfsfVR zRKr)J6LRDLTD{*Nxlt(EXH*!%jbT>{&{!6ceTp zz6QTQjlb$Z)@=9F*#W$_LBUS&WO`?Gozy47Ft9H1b5r;AT$U z-$`vn08Lt2fBYYXet{v*cq8F$DPB;R*t64dy5grUF>Rs#Y1aeAS-n$WKfM)uXZG<3 zC6CqM%hZl3yMbL@ZOxJ#;k9r=*7eXCrmm``Ni+20v5iUf0`|rU&FK;Oa!_aA!pPQ| ze6VE~;oQSobcM5(PrAbn?S|F$1)O2anYRm(uJVOWm-`UT$U~z z$uJ3;g~x^o=z|#g@FvUB&KSHm9>?ry&3bv|Ou=QDQg-77Sj^|Mcs_kU@Q)yaq&@E& zrhz%URb^iRaUT{clSC#aIsAdOEk}Tbnz_>OBji|IG)i(;U*{s|-gBkq&0Sf%*h>V$ zBmKY^yt%i8^>#5x%qn0gUNMyi@%qyrU~mZGnL}Xsg;gbfnexWv35RosS9jr_P~L*Y z1>C{;#1&|YrL-#`c79V%tdbMM71Z`#iaQwQgOiULmsI)eObF6EyEEp3N#2N$ej`K` zD~PAclwkk|4*x|o&!j=55Bl8?Ulkawfr|`T2rMn002SO0Z&+0lH5WeolO0WbuR2aA zz$Y3Klve0AI>6avGS^(aKvz^MNdNMmi-fUUCh#I;%XZC9vf?#}E!*`_m=Aq0^v-u+ zcj(oee(%qUZ|R(!E9hsIM+p||(#pUXC%DN*>2hp=b6B?YY)$T_GWbR(6n`?+fkR&d zK)tUmCC|&$xW#}S`;l_COoZ)#mmRSENyqtKtSVwaWsL(eP*5qr9NCxVkzrizwa_)fl(t zx6mS)8rZ5@khb%@8pN!524cCB{+aib-|LRQ5U*8mE>(AgaXDS^;m$PMpv zi=vkbYFV2Y{<0k5>GRbth~kaN6mMyE2y(!BqOjEM z@Cciljv%*aeU@tgXc`19D@ULS8N}bCC-jnh+dZ3#w7n5!0U__90p85pwiY7m>F*6q zk~8-^Gu6eV44pV4K&3MbaMS4<#W&N^l``_W*-6V^)xbb^JY~jP@suR_my#s^56=jQ zn0|PdtX-Lm3$e+%adfk27BTBNK6gFZwg@lJH}*_0{a#51krGL7rIX!oL60yJJ7w$X z4RY0%8Uv2CYV;zL z=wWF7sIfnD0jrCU9@)Y%m(R5<+OK7 zob}_)IVHgBaK&{_)0Ch@zEIh%naw>RfRxYV2o$KY8>;33Yd?*-Li1kMPoc{h&Li^_ zrnKWk^9GDo{2GA+Uvaa_MJWVjV~e*8P& zAUdLOoL2VFqLp#}hJ8G!(q0l+5id7K@P*MeG&rH2&yjl(AC_VXM_dD7Xmq-bTAyQ`q=u<7^4hYPUHX zw{^uZVVBj#D8thK6$0W1H^UY9t!I_=p0C-prBZi4@6AGOFQ0B>5ZYiQvE;{?p(c=7 zl%^JlLNi2)uxa3ux1TnIGBCEM>`pX@^A4Z(jxO1hGV+4phsB34xZVs>HcT+{J_AnT z9+dn2RS+!8r9-2t@gHD22{`d)eV-)te2p1I@?K&YyI@w0Ya=o(XTuD@L4pN%DTAaE z8jn^KU>a3sLacqN5$J1GSPb>JI|24g9)6b)fI+uWxjdopb{AUIVGt>#&Yu6XL+l)!6(!Trw^UqFeIDH~R{-`op@myaG#PURmpzL#69I^Mpl%UX zA2*O1wx$y?6)32cdIu9HsFKobE?ZtL+fA*7>7*`-YN4_s4_A>btv+FRQ}}~j-{nU=WjPtE;?uXj#&jeV zV@q~Tv*<}VvF-5LJHV!f{3;dfOE9hk@wb?h_l{`<3IQjeku9>U=%}J0pe*CTj^;~C zL%tFGy?=$GyfDL|-HfN0v}>^E#Wl6~x5SnN!$=>K{qcV&J`Ir`L4&PMAOG*-!#~r~ zJr>QsJ%JK(4{r1fIA*wSTN6sz?={}orVtM8ehf(L+enipPpqw=Ksm74H7(Qs7x*84 z_;xV-3+^DGJx`Rx&6|BKC9vFcpuj=e>arj{SE22H=6YMndSWKSOwjkTGem18-b8aK z;mb9TfrGj|@CZ|L1J&$Jxf1}t^bj8p-`>pq9@616HX=_e&>q zS#SlTHg-}2?9uE=b@E`iA|MBS0yGhvKAJ&=)*nKGnvXJTxIoYoG=$kxGd$ku4<*j% zi%I~DwRMTk#S82pM$3(37agPX6MrUL>aY2`AXI=woc_pBO%Q&vvpR_~gjFxNKkAuQ z(SFKH>a3!4Q5}i#-6KRo>=X3e!FUD*+#+5AOxaXSfBc_z@Ew02`%Y8}xryX)BhBq) ziWcv2FmeF;Shh3|OQgh`r6>YgUBH4VrWXqj^pJIQ>FX}_nX2E}LVf+-}e zufi2x``mcDH3ln4|9Ic~^nHve5*;+bL#X=Tb2}QH2$~#^6_t1$85QX3&XNhRV9%_s z4Z%ylJ(uFOb5<67xoCZr^9hBb^T|N;@EeVIHhSczPpzM8U@`ihzgVH92ws`L86k!m zOwqBP)3z9ciL8y7j80Am`o`BI=2sMjvFrDoM1QhQ7kb58Q8_LF3;9r@7!km)!QUXs zqpH*QI3HB)0nvD}dm0>Qwfgh6&sOeyKGyDXSYK1+1`#MjH#R!Jh(Wz(H zNGw!0r-Vccl{u@LN5kC~mlHQLhn)`XxcM(YHrNR{r3N@HLdU(;zv?DCi6&$8T&q~e^gr90XYoT^!hX)NIp zYmd$i8~(~|{Opc@u1PAMqJeylf`n*;A@MF!$DpHSF3~=nv0*aOT-H=0U=KuBW<5B6qbBIl7x-W zZ=EE}h7RhePk@}#CEQ_ZaE@nAx3!v(W*?_mtzPE|SP=F~2nZ{-&-U%H5wx-f!$5gm zQ3(rGpw>aDx}f|gkCxNtI}YQ0L;z7zY?}}6$z0(9xS9X{;jgbDW-@>WP{}Ob0s*(Z zl1&Kuml0I1bTvI=q{=jEsF0(Y2~Znq$|P>epNnjRy^@%ao^5&5p_s5qpGN0q7g>N)F(#L*{~Pv=>_R zq1{FGuB`^BDxiavw>C3^(gy4g{$pUDXWwq=^s*tq(suS1HsFTR(+5=|aNos2CO3{5 zFc5hruuT$aycC1OE;7he!T&^E?`;xsV;&}Vg&{;dWhy>s%UR`x5qu@alhSM z-w&Qyj(U!-y;!ph-jhWs_RqDbDxI>*;$&IvSt^L6a0rD0u0Bd%+-^-D(-(}(7r_zs zAjYFBZ*?QriSeF%@)(@@;`qD8hhK54F!g(mNOoOA&v+$0W?|%P)6OcKJ1wD01krw( z`sy?^$v=j!K8EEeVXY%xMTVk6|H!&wh6sm5Y_^9F#@%<__^wH2c}}seEJYJxPViI(SeshBJCB zAzQFB5nmmN%BK=gQ*cd?ZrOIBC|acObQ}HSP(Z!0;8G#9LLef_*>~n$82QO6^y7E1 zbH4*aHi^iAdef1a<2xMS?;sI2cX1|2*h>HTd!N3Ls2a9?4}DvYsy$twb!qIoUHroB z%Q;vSSInt_H;p7!M0zPEaYAOz-3b%|!v2zJ(j3rT4nNHhUC_1e&2xdXCL7CMqr5Cu*fJmb}ZnB?H-7tXb$3uRy81qom z@qZQnDgA(~_5nc%u#KzlFHCFKF)zwP7Np0qFYNbocEgBz&yeO4 zYS&$%^a%`%T+rBm!_;$d=5TC4@3cf^=dJ`DlWbcuoUJ*2GmK|&tl1E&8cGV zg=G(JtP6#q62Fv~kjqxkULb}A{;=xUEAMOG^4r<}T(0L_cAOXOAqQt}K|$H>0+F?_ zx1c;udRgczn!_7v<%dQ^m77%wENWENl+Q?3rF5+3;x2Q^@qk?GFhd=!6CT}q{T!BFhXw!P=)k^uG=D`!W~8)(>1Fa&%ZtQKukIWr-Kt&4+S`R&?MTTh0VcI^2__ z242B4tjF^GfIqU2igmI2+XP4Yp*``z(vH^zP@67mA4!$tp=?f=Y7c6!unCK;aO3ME z&TWA}QnmE)^H0Amd?va*3n+@ul#_MQ0z4iEwF1@ap8`M5sa4W>VxP*TBiftZvy>+= z93a1-lh;KrFiP^Hv|!k*`JuHUX9224ovgB|lB(iCGijk2rvF*~+8#)w)WKrVb2(rb zS7@qe+D-3m&+O$z(sm$gdfKy~DmVb_1u^-EN_u;6p|+Igb8yr!Seqz+B(ap5kmV|5 zmRBM~N7Zx<9C7?=j(N?WKvYT5Pnqi;TP8@#Wc-B1gM)U#(g8jOplrHWc0YZyfhW|XnlFtWBBQ#@*a8dky)h9)~2sv(`b>(#n04LuMi z6rK*UJ>a|yF&VvMvpAeNOBtqnCs1t~8l+ILgki{=rAGgoc0AJJk_0rUrs#nz?Gvc{ zIe_#~udDL|Yk_h*V$!o#gEbl`2;Z#Y1MqZ%Tf2sf3EEqQBZl(cP_EJ30ws|G??^PG zl$x*|?I0E?cu6u|l5O(<&AargokHVhyEj!txNb?>%wphoM2Bb-H_Y#pqf=Mt6{HXv zPukt2?;tZ#ly{KS8*-cjx7@$#2+B{c%op%cs&-%ew0<2T^`*bIH|riknq;1$_JoTN z##T$S(QNuaa7%-`20Pd;Y`$oR-A*~qqqOY~O41dFI5QB-neOceIIEWwca3Q3FvBeb#4>RaqOvG7Hu})m#KE?BM0c44jCc znzHYwiXX9Wcr-_YYx{&!u9(Q|@(%$ZnLm3pVRF938WtV{N@0M+B20>Z?ZIwA zXPlBfgr_V&#X+%CzxSsRTK9Fhl-udK<|na%o;(4W55dMnPO2GmO?Ic4B>4elCL4945HXH)GaN8&+ z{2R!v8l5|-Yg%%M_TRk2g;{D58+Z^lZR0f7L)Hz-Eq-<%)8aqi9Q~9veD*}?r`&4q zWf=pi$lQF)d~N9&J~djvb5K$$(Vy$8931ba_vU)K>$bL3FBij=ZYqxsQkCETTx@s4-RCG6m)3pf8-n{@`2V&v0pa>;eLxwl!8CO5KBc^+cQ^>1`#Mqy| zGlau#{79N43p2;zFL~OxJ%nh%1=fO>$a|$}bl|6N72p1reIp#4F|>Aq}v`5k0tEq_ScF3^w2y<<1_>^ zq>42UZl?FL_h9i=^jpi}jQ7p=J`F99v~I=v4eo=VzJE%nhfw9v?0n6Pz^5ve;QiRn07}p8QEXSEc!-4_~3#oBgwQWUPqKSO@w=g&^ga;Tq6>vL77n zf*-g7obmMK|DpKsYpZ#NB%tE8wOxlB*b@tWTZ$G?c0jzN(8hxz;!>!}x~DDiouI~O zD^M2)HwK?sTsQULRWm}fAsW|G___4~xQ;ZMo>4e~wI_jN`!;qO1;QjRT%(&i*X{g9 z2Qr!UF+CKeEmM5m-}(2bW3Py2aWN*<_TXe&C{HhowCXt1jT)5nV6Dg*!dMGamkbg+ zmuRXvB(}Gk;dmZKF&hkX_^GH)fJb>|EG`d)pkl4M0Q>=>>zf7a{{r(L3N5`PfX0dN z06E#==$;Rb57ueG$?h#bk$;n8>Ne@p;^Sy!aTT*k0totN@%7*Ept@37*0OyqLi2dH zfackL=yWm$kSR{2%Zp(GDuRLw2^_>Aq#}$ zZ8*mV>`NEW+d1DBj-DR(crPMg)CU#aBx(`*sAq09BWP@GXpuZ)S9PUtAiuZT8tqyB z`E)qQnz=`RI%VGgtEwpb#wqm#?8itcKi|kyswg1v*l`J6>Ui0M0J6@HwEg@~Kv^_2 zrFY-I(C)|~ZvaGT9k|5UvZNO!a3%J?Q|Qpt%^ZSaPlz8Y?HtsMU>ke@eEh2T^a~3j zsnqk=Uigyv1v)zOl2$^5tHvPHnl?;G&$J?g_*_T4Zp>|N#S2&GR{ay~)+#%XI_vgS znx|ZKXx7-lo%DLv@%~4I#|PTy6Xt2k zjg68xixwv@0OLq&U@u;AJZdsq@@wlGU1*_mt*NvMRNU_$!7d&B$>9RLo~PG ztnlI#rF%DpoI$q8!)nfT&NedRi1$e9%UQ&)4aJ^*ddREwfiTsmCS^tF7j@3k07RU> zNISZUr}ma4LNS?iHa*cM8|PfjdMe3Yes^PjNJ>@u*pF-(W;Lpvs=j=R2QoeFg+7`( z3Wp{OU^W&d=59+{7>Se-#qKjnOf;pdjb-~qSEvh7Ih@s=)sgoX6*TLqy5MhDtQSZ> zw00G*G3C8b`u(*lL80$YSCva+(ctb)tO7GG(8@fGPZR?iO& zTeGaz*!HJ#>&Z8m6l_2L@Ok>*;`lFCLv4WMkGk&n$*x~W7o>HdRUK9SDEdgoduaiWC)Wwk_=87zQ1_j3fXT$M{`nJs&K{S7@G#C~Vcs7;=DV)(!V= z2R^dCk2PksFOq8dalj1I^C*)ZI~s7BC4_TGEd>N?{gvk*+`KI@NZomF&VkB)T91o+ z&}|1&Y;TXqzQCik&JIch+e91dr=RaE1Y_rQ;@Bjgu%Aj87h01ed<|KH&^~*x%IVph znl~xASF_~fxs;v+P}2c^LA#}GTv2K!6+$2@XZ3Jl3ahv4QI1eV8K6`_H6UW#cNQxE za@Xhsw-(uLPyTmpzB6~z5}%S!P4bQRURvx! zJ9AV79RqXO@U!6U_f+tmtUS)n6lf&bP; zu}JX2>FJA+2P^~Us6?I$!iaI$nx}iHOReGW$(p^V1Z2178MP*G zl(D){aV$X{m=|*H;(ANpnebnkTdoQl1gpu4MFN- zO)@4PW$0D!uMN5f-sI8^g5{TWrwO_oi&J7qL3i1G8;q%UVLwFPVyX9?gZEkHW&tDr zQDcpH$^ttxJJuM^ub5lGP)tK+3}WLyCd5L2ZzI;i>qi8Q}y_W%g9= z-Cxo-gIK9bzqE`G2v@CiwVrv^+%tzu*=uc!^Q6KTOas5}eL&%W#kOuJMoz_WS}DU* zlE;JXl5iutHPRE4+)go1Ez{i25#bn;Emoa9x~yGO z_R-~H>FFR4{D3hZg_A=^)fvR$(A>(N#j((h5S3=zkVY;({pj>)&e$GrlQyF@zGwJ` z($oo$EgC2Ydwar-bt{G-{u0Ya5fwBirZIFW_CY6F zyd+95{o3NoG)I{I1CHI9LI~WvT9%))!KYSGg2^2x~VSE6mx2ev~D3Iu#BkC?vKD725%r2dd zd!o0)Ujb7csiI@mRCgp?Bt3NwFk=^SKFjeu*?Tkm`ENWFY#-LE4T%R3hjDn?@$^Gt zMZqk0+X}lEbVdHjT8j=?%g#WnqR?5BxFyEyhl)(r4H{<3#e4Puw6*V0=Mv|@cdBAw zIShwQ)aReR2Xi?7BN1k=Qw~y7_P;3?v@cgO;BHxPa$LKk$==J<2CQzw5@YiN_n#bn z1$PAM8~9y)&E0$tnkt+QJi?GlCu9NT2vq3iDb*DUx3TGR-jsx&dqgwqS$SbRV0J6m zRDw{fNVxHFFGZE8S6NrtjsOxM(ZlH^Xnx)t0V(HfPcfBQB=HQYH87h;VkMwAnhp-Y zg+uM8?Cl44X(Ky}FUc~@vm9Elwbqu1ATdwq@MQIQ^NlA%a@H#XRcui?eGLmF+=g8z zXe-YYL>P2^tA3CAWIi(Kx1$K=%Jt95d)$$zJ79$}au5~|I-Kg|K@h*wbBO9o z?hbInRJX&XTQoYX9(}O(GX%ty?oo^uyTzF?UiDnY00Louaa_tm%sL`s58U42onl3r zj`I{YEvN~~dEz4&1;5>wG5e-vTg2qYD=R^qQ84uUhM;^A!4dgCfB*y^^d~SKU;JjS zBcX37_q19?dUB^V+^eqXWP&{dc#T5ACFm?C%xG#*q2PrwY zw7NlL$3b#n5p0Ar`^*L!Lel&u?CPe+qJaZ$fz#a4vNbVzqiih+)cBYyPmFybb4x<^?65naLb`MZF{l~5QbjlLR|dBRKdBw75thtiev%uTA|fv`|NNx^8QaK?NBF&YfF$<-30 z`SD@6He;W@fVhdn(??mc+#ri<1sN>Ju379UD=zLC3;m666yNw0zm#)S)WGotsmaeb zMqUSjIID4=;mZJxzfLyB-ji9{I1BT5Bj+NWZ)*=gAxR$2$m@3%FOb#HxEb5_^#Bao zEc0yPrAOz>Q(M&0(+`wP>+T`GGTn>V=|4I^=_amFp?oBSDhy@_$-@@Znp;={q~i;B zyDnyD&cFF0;+6Y*F~C0riJQz1i|V6txxD_a*%1|G=9*_|ymI`->M`C_FEx8teIEoexE3U5K zb5PmdQ44u*u0M3K^p4fbQA)X9EAZmKzM3FX!E*X%yR>yO;0`I~Ks;Or0JKpf*VO7z zT*dZJ-{=aR`zjHeM05Dvqna)>E7w`f)H*P%ONh-vSm^S49;UmFj1^IE=#&SQ;hcI(YXvWYX?-Oec;M8U!4VZu6P^|ek7*O8lSh24rof0dhL=QMPMlkl3cPdd0Gttfq5 zT%um{IW0!&R*FSBZj$-6Mgrl-o;@uG3mL%n`zft=t={J{tNY!$Vp0zNy>f68pmO^; zsC8Q-Bzu>IYa*=+>;8ruF(-S zZS&Ml9s2anCkT~vvdR26%cHJh66)4g7GQ*s0zz}IGS87K15|+(+Q^+{!Z~wOV+rOnxub8z5I(>z;6YRoLkur9u9=xr; zrFo#llJ-@7c<&`5v~4Z_Y82Xb+^Sd}B~924<~tP{AB>jU6Wgf}uPv^vosqT!vn?hq z>)`Fu+J^QB--nlErGOCYMCEOCM|iu^;8ul1p99zj0uB@gg>W&CWdaUkkFFk=P5#c6 zc+NabVA~tTZX#fY#AEVB9V8C#A_Y(cSi zS;9g&(kl5Smgi}zVXqHPx9GsWnd0j|e)w(i>8E~mFvmORVQbZdiZh(J)}e&*dEbm< zry}8j*9(~`U=_0j*&37UnRdh>H)2XNA;$cqdmRStTb} z)51fup)|DUqCE!Iqm|mBG<+@Jio6*sUL4127g?+nU@vQRc`c><*I)*%O>ljzTXT+* zb8^&SUoJ;cho(vl*Ggx_#~u3?>8O9v^&A@e?;=rkV8|B2YpVEWRmJ5-cIzvmN@(#lantFBf>jc=iuT zi)!hrTN9%bOREn(sO!{Uierkkni^9}uw#T)C_3L0K`V5S#@S#$)ZA@Z=p9QQC?-l5H{Bi)ju7v2%)=0LAYs{Hli|&-ot+lCqEY%E zwX=o_DZnw9S!$Si^b#cX-6~IwSsGfIUdRqQPt!pvE#!-}WQu{zTGDr_+oGlz?b}-* z^OqdLnAEVcJ_1{j$q|wVH0y`&+o#bl6oLDrG}%OKjYlf(ZIl+fEXj49Y9J?lK5o(f z%||~qsbF%S}G8pX>PN`-cXd}{=4t&NC2#^8b&3Gq1HYz5ctM7FulhAr9a+^ zy1IKpw<#uM($zAW=(WQZNkD)1Q`FxZ|oNk5N`fEJN*I zh@welD+)1+TaCQJzZGs^-N}(< z4Co=#Qs?-ce)U$m0PSbZdh0~7sspMIi$DslhBKlwW;AWrEa_!@`l(queO4USW= zPlho0^j#%ybzs*~ozlch*T=Oj6yv*~VQyQx_5LUCbms6C_|#9Ze2q6USdT>U$}~Cy zQY?%GBXrM!E@=Zz0^?07Sw%+cu`&&72@MN}Cq>9gPKOm#{`HIBM* zS{+62_PYL@P;d0Yv}kgd3wPUGeGHk(81(QyxQFle{G#W&5qxIXpvyRj!j? z>?5fwg*3@1qo_%AklL#oi0+IH*A3}G_7sJ-d)6K{)@y_-=L2QR2f)mBhoK&R4i?%x zKMNK`4_&6p(v?!^z^TjCS5%6VKIS5BP+2p?z*opM`DtFVP;zy}zeIU$?HXW?ea44R zxk)@btmIl{T_B_s@^m%_{B$b}P1uCEXaMOh(fL|QJN2?&T;vY|xq)9Lsy@YnlAix@ zX#ZQi&Rgqg=>fRbjmUEUe2=eiifS9Go5TlD zYEu6(CXIQxdqjAK-{6;wjI=SCTAUB)$8MV!sQ?lr0TQ5ig8))8%S!xL@3qce`*>0k z+gd0TsxmX&&)L^?0Sj@GBloox^5HpZ6>R3x1DOIe9~57}R|KZ9@&nZXnw&hV>54N% z{rwX{#U_kb>1u0L+T=k>%hiSweHd1v%oyCled_>F-3xNiUwsZ3Ti_ey(3(hKGjQk~ zwNN^`UlI|zI$OaC6u@%CY#!~nyOOGWOc>PHVDb1)!g&=-_JpF1NKH!&du1njThGn` z?YfO5rhtJ-xGnM9meC1A7@Ep9OOB;hkYcgsAl}DJIju`Ti~?{pw__Ry4M}BFel`?Q zL4k8AB?;G&9+-9q$INF>d|5Y6Y2R2_pT|dupY-E16zN(mM)5=dA*zMq0m!56sr==e z&Q)e~F_qYl5%bb-Ts+0BD_EOMisMi9NmgAr3=f=}1Z1f&BZrR|l zx@mV<&V1$jkLExo2-MAwZ`8YMIJm${ScI`TT#vBHECu(TV_>$<8|xmSF6{6t$V`D( zbyl_19UAVfN-J9-{kVg^R;?ZOVXyLz{h5}ScIkS5AN?IfgrLkr^OF0J%P1X`$6Ol? zd%4wWWcdY36+*OCsZK5hJgb8Wf`C1@nIg&$R4i1LLOIyO>z8{nTnd~c;lbrJCV_3N zWV|a*0;|*Ta8||3@FZh_{#_>mool5RW7o`0CA0B8!W|di&XB0PyI7X@NdsE9f zfi5IZa3|dI1ymH43_H(i8Q%U5lI~vNG%c9=ZELQHgRcG=FCrHlXUzMjgyMBK0lU zK!r8VGuw8_9JE&ZCI!ss?l%fgOH}r@8%6)2m&t9pM9YYS3<4*vU{%H?RO0s_p+&IMg&+6zj#lZ7)q_X3ewoPGOW?ck_$b{!fwq_gv`{qO;DBTThhp(v{0 z>A^qG8o*c!u6cfI4c{#zx)6^tEYZ5Ud-3RZ9$6bp&`h|$q#_N=;)XT@&k}=Rw5Qc= zC2^X*?SNSl1O?-g+V19z5e#r_K!PryK8ky`ciK+%gtfbM{te3?zQzyf-L8F8bOUXn zKcbEEoFEfEOnLYEZ^dhJ^IDf8mjr3NQCs3wYsfZ7QT8KET|Ux3b(BVO9D&^&qb8)# z(k-jJqGk{0wQ^X}WX#i~-I1#{Rs+ppy6l^C1n-;6CYjVz=->#DyB#HDxEwvZMotd1 zZgqbw1X^RL2dpU8#&p7Ih*uoyLr6VeW+%N`&GQj-Ptw%SuMxEyLBW%f3tYs6&;&hK zpxZHQ&$|d7s7dVgW37Stg0|f)z}(h^i#3kTa2CHTqZo`q1lT{T!wQm*o~C719$78f z>%D!B3;u7e83>@G7pRYg^!Gc=ue`e4?}AWw4F{fmQu3!nLK{Lh?sx~Cv4@%kJNX5Cvv*1h0;l0sZIb=`6Aem2E&M^;GKIiu+frwa*Rp_WgB5VtS;9)x15BE% zBJ9BMQ}nL{r1e?GtQl6qT;v?|YfTq__42j9iLH)e3CiczOg5gRfjO)s#NN(*$RrKP zLPH@B`Ro+73!X%9@&YMj5AznVJ^JUBI<^;-ynauLWfPL6)HVk#kN?3lvYnSZkFnM& zJ7`Qu`UrlP)(OE2|+WR}F90A{^Q8R{HyX0FC$%7%NOm)myd0 zBf8`BE)f@e`F_@|c(`f;1C*g0n|VrFMcT&^VBIIy#MppX4`#QW2B7{oXU?|sYTr(N zok;|@Q9Z=moJlVv!||kgP}2#lzPyN{h2(*?4Vs8t9USd<{EF0+R)K0)IY>Q}J(=F6 zJ(mel_K#t-y2ha35|v&+cOX?+u2qJ7I*&I4_vJjXn3FZ1Y9bxbTDqBmeKpqUVmZ%^!=xf97hckE3dLfHb5MtqeOm# zKXm8`rO~aEyMvV?I?^bWmQl+BFt1%G12tlMpz`*iwoJNNX0&4XL0swaE$asT4nVG# zi0XAqk6n*lp-VKqJv`vaD};2rcfQ{k2(cn)0n7}3jDcC*!u@rrHpyUFYCZ>A z%PQ!N@8|GA@x%0=?NVQwEbeV}QF{FJ5Y5(rK6<9^1l&8*zjCQiZl1xc#x)>;*ME?wuzq#{EW5t62`;D!!YZ5dgtR z_1GdE)nXw1s9*S-;{W!iL$!nSvq01#X7n4SoToO~_t-Dbq`0Y#ZMt^q{xj z+mKf;Q{Jtmd#SnA23*g%3GK`aL4)xm-7E`b@7f-oMTo2$>utw`L-8R2-`mck98-H* zIB7p`tMsKg~b;5HD6-@uy+>0Rb3c&5%Mu|mT|$;O`gR@hs5I2f7| zsx0?-9G3dYR-LImE3L^h?qEZsfq(UEIg^FOj}l|o>N294#o`dv6q&$v8DE>yBN1nJ zkV?u;42MnfR9J~w_j6YDMMD|DsaNnpX;uOOiF?*)1=I?=dta5zZIitS9?Q(A#=6*t z!HeQ^d0~rT8KT1~br>Z_ZFP^Qr8c78FSUfGAvAzIb1 zN%p@;Gz3%ag_ND5JrCG`rdgg{`I3ONP+zjtL@5NJ-Y@}vBlP{N;`Jk14*GKM1WnKb zTQ3K7XYY6TjgA;ogI*}n>XFu-7E{OMcD2rJeQw@-0~Z-6F58@hwX&$rR?%@md`)52 z?AH7QQucjWJU_z4w*mR51dmDSu)Hz+C}uWWCq=UyP{cTtp>s8<&uWl1kKFe8|A&eOR2@$2ZfmU4z6 zr~?E%4!4Kz7k@^hF)Ooj-2!H-9<{Z-C+oWbE%GDu{(ruFS-k(B)&!q24#;kYD^dTh zcujsab`GCZF`VW0_3Vxw&#CZInj3<^&E2&S_*3UjXCAmmEo7Gl4-ZTljD;*iYQP6^ zkCwg?5plw?$PzMiV;d2k#qENko-#U$%-tFR2xBlS^Lh^RKq$I>iX347wHC;+gfvqY zddXOVXD?-@EWcC<@hYU}uMSYHouJmX?kr<7j%OG{4-l=e-8vs8T|(ex!6;guL|bv) zlF!hc0-7r#&A&o98gO(i(zXdp^|%sN&~&hw)M+AicI0BfiX?OjSEsvo8+GO~aGW9N zC;qK1g-E!ilNd?A6O-Ik4YZEebiD~}Sj;52mRPb|FX#fn*Tiz%TYo??)Yq{Gq0FY! zIeS=<3Q|jx0?x;FRSJ;Zz)vtZh4IFhGC^4S9slrNUJHAy6_B4ky2daXblc^I61Qvm z2%u-m-b)QMte&fKYO}P`waq5jD{-C~s;fC8;%Mrs{Zd{Fd3d0WXH?fo4$mV z8b%GLVCD4FrHru(RFroTHxokc7)`btE(O>Qh&6&Z<-rRz^LDwwg>21mCscB6LU~(| z1bzPbumlCz8ca+U5EWc386(n4rT~4pP?6lqs(^*u8mOp(M-#Tk0Kht(u9;JhV~$bDLo-6J!2eza@@+bVk3EVd6;yN#3UG`Sz7zWBNj_cW5|ok!P~b3t z$zw1N9@`H5aBTV9Howu2W!LPq<$#79=N_8x)Ki3u3I03Eh{;0)G%1K>Rg2V%k;9=?ECX)@JUIftlyU&( zY6yawcQfepi?0soJBMJfC1tWaIP80v$8`E|qs)J*u2_@PTIi~1rJsIS`wW=om--x5 zFKMTOkX%ZugGfe>RWMb-Y#P|UJ4VVUx1`LGr#qaolu_zJLVe?bj6{Sp^kaEYR5M*z zyLa)|!$Fd73LeKheiWZ@p}s1^d^ibbgS36)Nv%<{kD9S9)JZ$fEznRJ9LDJEjBh$b zT4z-PeSv!e02&UBU*?fDGazMKx9IX=rV(rq5Tc&5gA#1GV4Zs*FYCV-|NRHb?OG?V zF-y1Lb{|-R_JQ2-rN1>OSP>3YOYIn?yt>}?Z8ODxRElwk@7I3-!Y=|J)VwXv$iE8{ zK(G2}K~;yY!edxUbnNi6mqUQp z8jRseJ)VT#c=@VG=nY!0rtkJdJ1ybNx^{&Vf%V4eUqf0qX|k5mO9KDTiWU#Tpk8SV zaz!_ko{!)a=wa==Y4C`JY`6f{i5IGfDmKQ+4$4|)bPjUph|@10>1oHt9$++k(|wqS z!Xc()863CJASNHx1N(TyrlRtXcY>*vUEd61@V{fnec%jw(FHwcrOYEbR__omK&zoa zmBa(TycL}2yWu(2f`ZFNrpammSLpCvgKKXuqdY@>^IOFa6D4R1H{7!n*qW>k0r3O#Z7Vmk#1>rWH+HRR18x~N zjPB2o@SWuUITrW3h||=|$Hj-9U9$#Y>I3_q&#BW&Istu`%^t)qOL87CX%#kWws|TZ z0o56$z?nFUff8-rq^>nf`=9d~*^X&-h4xTb6-;diA%|_CQA)i(u7!+%=a?n!>>US7ghISO{``(@T5&GvQN*qDbalVzdr_9Hu;G>HkknZ z-6GlUjjQ)9eTzDMM(O7!SLeha?V&8LzH*e0Utd_CbB^7Hq)E9v%?qXbBH57V+Vf`IB!JJnU2c>jY=;YZp~8$ zRa(}*7EA59!tZWAXAkoWZ8B#yMof#-v%BKAwd!AToio z^(RjK7OccGc&bzI!PqZUIDqfOM&9~UI^g)JyOfYGxt13Eg2gzISmDcdt0lL&*>(P! z#e3fe;Z`6{(l;+2{hAVI-#K*|Q{8M%dv-et3drkgHZ)|MNc8Mwn}`*!FtyMm#*+VZ z(muZrFJSxmhUSb$ddM?)M210_mop(T0b;BXW$MGa3oH%rCDQ2y$60lxUG%q3PpY`E zS@G;V5;i8SMyv;>04rhbsR{3tJZk)V*!30D1oZGM>Iv^ry1V#s?AV~BUo*wo_w$2y z1!PC;Xt*7=xywOKXn%p!n#xmDNs3)R{iz*b7F1<@8V*BCkLDfM>Tc!ZoW*8o9kI1k zmGHtdpF<%;jSEN8~j}}7L8OJ-c$$=_^8)-|rDoMD2uyaVD zDRxFZXHn-a=k6d3O=EWtpD@fQR*i1CH^bTlQ19=GON~lhqC^SF6FM z2IUun8oJit(T6Jd(5&H9xMXPBgt70!DnGy`37R9R=t8Xw+FfpmCJ@B3KCQ*^Z2Hv~ zk{y^DXbV|fL**t-9xAa^cm#J`R^Zg8!edoC=LN52ud1N{n8?gE%&=pakg7h7=q;3h z2ri1u3Aho=q31T|U{EMl7?)y}pI0jAjYEd*Xx~AE(Q*djL1Uw{y1VZs6S$xFE6MWa z%iam>Ye+-Ox%P_`Y%Z$Yu4rVXnytl~I&gvvIdFZ-xZ^0ylD|*bWZ()wVDzp8YK3Ih z=Zis2xhy+zKoW-ov0`UOvV9zyRVZN7)p*`eoneBkO)|b4nfR@mnJh_jEfeDOkucJy zc(@qWA8_HO%OQ)FWKl`en*STdB(siM z;R?Scm)Ic-`+*&)Z~o!+o&S9}Dfr)>2g%O^p`&|X*U8l@MjEM6`XU{spaVc)r`Z`H z0ifGp3h3h%Vg2kXTw`E`nM+_Nv0c^40v1JSuf$r~o1WzkVay5Bd22+V^pLN>4z~FR zzbqSkZWG>0xpU8#R=V(knfJ z;!&b~sSc0rV~};{nC4--@1#CE#pok9s$gH612yc&li)WeEDWO2;JCC3B(dO40I_P= zvC?84;{4%Z+Qc+x=^|jBq37Y)s&D&r2)iG9y}`I#4B%t3`BG3@FI^LR#uA3H{#T$qokhJcQY~&xmNG1B=zd38hIm3Q zpkEYJEZFFI%e3AKIW)snBK_v~zE^xNHO|c)0*a+fwC2chkQ9j#ED{LjjZtbYYqmy} zIMAHu{rJdW9wU9kgQ920A*%_=j^J~DQ1d#5MGi6#;24n_Ru!56 z!1@X=tqZ_8bWB?6ygbO&HJMd;D4McN$g%|y%1TW5|If{F)7OP)8SA1XlxlukA% z_7&eCLd%dF97CQ5*g<$huF173{%D^!A~SGh<$UyGg)%TUZPw41VGMSMml;At=o$i4 zr|Av{RQ~(*O+W5~m5t?&t^fswQq0z~938+u2%y$_pJQ>h+(KSwB)ZLiWCY_``KCNJ zAtPu3R0T5>2p|u$UsGvd=I+&>%f|Y1mZQxDYGQFbre33m$epS4Bz5B?D=;3Yh9UF z`h3#Eh+6rsC=@i4YG-=6#8qIZo42Xh!EVYsG0$4tl$3(KvlAA8`Ta+)?+QOos0luL z{V3V&W?^)P0;$hORQEdOxL5ecOhu`7ARW~G?UMe6C#mBKK`2*0vy z7BMU;_f}novnrBZnZ<6-FgczY{C$ArLPFk$UQxkQRl(kzcpr5{zcF)Fg$K` z%yAUQP-84KZkh?*b#NsHI%R;2KTXfNAjlhUNh|w`rDKyQQ^$z4SDaGM4Oe7f(IxBy zNyGsR<>KXMR0p2pM@ZYDpf%*S5C4HYuP_O~t1AbK$GyaSuiPG42+z_d{U}^!a3mGb zpqdqG6F|bCRJ+{CHxCdoA8@{ZZjH;L{8=C44=;brqt*DA1Lc^~jhn3Oz`HtXi~vRU zFi2mTc*W3638Vxh{^%Rg=<|lp8}4w`gkZ1BcHWD5w`lxX@y(B*p<@Y|<238*cRHCI zmnLH+tD*zDlExoPTaW=3kBYi*7lLDZc&b3nd=_*DtDp1()79kAMbQW`V5>m=mP}Tp zP9)h%cZIil4)=v=oN{^9K#ijb+R3o3)EW_1?;JSoy4fI^bKxcylGI5Y!FvyT?LcLq zY|lm-Xq?owh5J(jfwjCvpx|)Vpix*#JgK;z@F<`qr9{3!OCDlN*8^bVm%T$c^%srt zOha(9u)%#%r%HyZcrJWU!2nIt$3sx{Q9_R^L)b9{ykY4GJV9QvNkcTLb`iXk&bQs9 ztAE!LmI?xh^pa3dHT|;Hr8qfZ{7W8XCk{2xYGmc#p{=RCQL9zr6%w~TY=ZQxZw0OT zF6~ja8g6BiS`6K`!mU=ne*I;kUw9g5Y3z>Ymu_5ni7lN}kJmEYUX;F}q!)nLsoXMz zsvA)=k5OHn^U?yuCW&h<380#um|iFB&(}4V)GiK(b}5gdZS|UH5s?Ko9`LHo?G89Vm4~Jn%{=SD zq!56!Dfdw<&3!}G?yVo1V56?>3FrJy!21}Im6(#-ExB4fy{7FPuwg(}qd=UCkPtt2 zqL4E+ik1rum0hPGAGcZff3}Zj@m@XT9TRovQIyh&!-9Y!s|!rb2dlH4gFxEBt%+b+ z0gzm#Z~p*W-x3pB4C}8LgGpBW2G}dydzw1t1gFdftzxQ>cH}?tr+6-;msZ?0W+?|C z*V_?e4ovNIQPNodFqAHgNETE0)E%K+HH!@BIt;HV`(iKbi~Zj$p)e4aS&5QqS@=}=uu^+dFs*-tAf z*_Hw+>*=hq@G?ODYJ%Vf=D(?>_|jjJH@fH1-ra&SUs6lEo=EFK!sPw!Hf2T62fvFC zRAE|WAPy*}WcExXe zg9XmV9Zhd(;~n+coT86W1PXlg1;{H$FO{hrc6k38RF~c!hCg^*@vK*uH~T>Js`V8z zhWCZ+bF4}9*h!Q&rii7@!o55S?` z{EUIBbtG(8I7NuqKw`p=pu8%qL?r4n7Pxz+4hHBhYBOeCm3mi|SCnm5u;|He@0)JT zKzzYa{}hh;IgmQf5(n6+_F^0Fz1c*4F9jnF>;8=dd+&*SKfYrGko75-N#8P&dkzB= zL5daxhdRw{1K1CDJarq7BZS5=Xp?&iuV(s>90l$ul5AA`YHslD3kFy6l=g#6pqMJF zBc7;-Jmkn{K{^FNqP&R&be!cs#KVA$a-|DG`cp%3B}dv-@EP25I#`)Dih6)PTuTeg zbxscx@U5k4qZ>-OKrV2(lfLpay^$zu@Hsr>jqq;o)C`QpLzdvMph;yRFT=0J#XGTS zT#_J--r#mtTMP1z^_gN3UJD&XtPIniU5Z|4=1H558mn3ucnZT_?Oq+n#vqt0%Kwq} zr+1-tE{v-z-gE=Y;;98+r?}=zQap~;j>UyttWxR%mJpr172h^+Q4jOB$mMsTdUgu7 z#d74zS{*0OvfYTCdr2|M3#)l+@_r=N)G52zkXc83-&LGzaZ{^BC--dHg2`+2KDROp z?0{*Hz3q;dtuFSs$GL3SO7A!Z9>c!YKNZxz_ViQ`%F4~Qbu~#vA*w7YHFXXx z#Pj?CL%79fc(gP=HyOSh#Bzcb6{5@NYtCe&y&cAQ9+0du2s+@L>Spu2#> zhQqi_#!$Hls$MrqI#n+oaPWJ;iN-9GWM5^hL*jhJh71z#4`Yd+QPiiZlKL$1`0OV4 z7Q#CzvwtpLzCKJ8#o1LzLCiqLyB?Cww+cXOgekPG9@>iq)QpyhfWpF>eU;n|+^Ny$ z-)^_!*q+~v%}zn6QPfd{F~q96&{gnJm!bH7hztt&E7J`!!&B18c^P6Avq zXC(a87WXZg+TTH825Lcw*_`6f%-L96U!cVTVVGv;GkLUw=1T}<&DtMHn&Z8GDqwYz zcjy|o)=A%ATJ0!@Nq=5S3`NBW1M9Z~0rjNG7$RVkcYe+$yhfwGF+vDq6#`;dsg0pI zh&m}#Owrx?OI++ziFANM&+m5+BIB_O_l8UM+-uToMP(+6hCOdc&SP7mzyHUAX5N*g(N?r0cI|6dzftW|%-;@*p-g(xyDdFst*= z50gdA1S(t*RnCeIeqfpzYxNz|jJ>50kh8rzN(t01M8K>7#`Qg zDo*O_$55s#(mxWN@HMGe0a@tH04QBq9B}E0K9iVafCnqACr_S9N18+VQ?=*OwGg(N zXP|3+p-K0diJ2!_W3cL#dZ|$v6f7v@om~Ru$oUfphX~zrQF;FOn^%eC+$21F6WzTu)y$$V2W|-z(U#z%V!qrJeWr! zMH*0u%W_hfI0nG=xV2sU;E7cF&z^RN)-l%}{6YKO1@hm#zEchG?qCUts5rMo^C2^A zt|mbu*kXOYUr6?pox7A&WxeiXP+mTM{pxLFzDbx3X}YZ}W!UdXU1AJ#M!Qf)b(rjD z8mDpi{- zN-$%dcbS{plI>bCq{whVuuOkpNpAXc zl%Z}H;zy9C)LeuK3dP*Yo4RU>gklQ~EoMSqRc_7nLhkH6(5`#gCaAf?2C)M`)z7Ql z+Y5D|d`EVNb;$@pa#n|X(Td*`FYbFmmqL%zly<>V4DqAa4Yaybj{`=`ie!?2dWM>6 z`mbFFAZE;f{;QXi$87ysX*@ZVRDAZ*!m@KeZF&ys{ce!;?NV1L5628!xI6L%?h^>7 z7H-#c1JoS|61|MvCHd=!QlED6ejqZPf z-|)BDy|u%1yRB9eHmnjFjHa!W>||S)oKduGVC4Fwc=@NpOozT!neC=DQCu&jMMY+9 z&fpXn-xaS3SqfJyM3@LLS4~l6D*Ye3OizFU>Ea?F5{6SR7%6&hnF8y}M}>ajDFDFS zXf9@w6s6;c+kcR0JIAJMNhjP5DNdQ_{wvLhKlhX zQ;h3aNbx^8-616S8?r^`*{X`OrijNm#J^yT7I|-WPGr}>UF!fhyzxLtxVj%$ z+BiSAiG%$9Gx%ftnsi=|XI95hr9Yf6yN-)TM^7HE_P+xEheNZiKOP=7z`*4A%F%=% z;0PF5u#)6?H56R>z-crnAwurs+ogoMoI&OzRlt( zw*a&EnFtK{&BEE}$C#O6@ii2hz|S<@Y7T!^{9oyJvWE|jf~KNa+})LK^6Giss34vh zPf67)@OzjbG+L2^4(I_Rb74>I$zHL&j6UW9@PeSpT948@Z%NC}$|0Z>1X4K96v+~v z`zutt*L;6pf2}n$TsVM6z>?h`_(PoAb7A+*JqKGWVMbiykBXO%pw;pPv|1KAxRQ^k z7>8N=e1ORToTBW1n$MQ{Gv$&eeiz-A2^AixATZNi>1)%(3he^5YwGFwhoR267}IW7`1%D{P%HIK{bZl4 zmcHx=W=pxClMUgTgdWjkR8865B<4BcXG z0z58wV{kq~3Kj&GEdg$D038|5>FZh2I3l!pz0?|4( zYera7bJ&ZA;Qw}IQVBeh6rrNwxX=fv(6@mO73xNaUj^&p4EVmf{4StjH5sXXT_Iv$ z+y$UNmJs%IMius#)cyb?!Yi$Zk@PqI`tOQF89%mau>N1i;7wiT0kQv~!rW0gJwx{X z+K&x%Z|MhkZUdrl1X9GyVp`l5$8o%d_+bM-cl$Acv4qEnj%yEnxmum%88K)}-x-VX zXRb0(9{M+7Fi?|$i@LP*az#2A<)L?T!@HOtWd)?6K{)}>G8M%3tgH|h6AuRF0#3B+ zWf^mq3!q|orgemPl}8kkOS(tFtwUvfd85Rn4o#$G#q6|3OOw(_^43c0Xaao*WhLl+ zYrG@utH7WnYFV?;?Gq|u_Cz@9sN|y&7ib2~-IK>`1%=1DRZk5pMF)H19sMzBJA->L zWee9%bq5-ZdC!7wk_FToNk@;loSpl*R&!v_{K@lS@$5*NMABNewAV!wOTB@^hjvNo zXhxD1Vl`G)UyZ(SEwf-y)nyJ0=&SlPn@$RZG#|C@6{PT!^wWRy_vuqUdKrh~j5F=0 z?>=rsun~r_XjFPC9-#4Ol~PLQ?xCV^Rs;7yZAYv4hG%=w;y+~~&y>Jj7i^}r3%C5% z+*sU_Ye_Y8h&{3pE9bzn!zAinC_D_6CazdcI_I#2)qN}^q|z{1yg6$D10?A^p~Iy_ zGAi67^Vr>@#zL>>d?vK4#3HJmh3Z$95`){%;iZK}8Z z>I@sZ6Te3n5@=yGFB0CePy`7|9$FX++xqgy{h*A@?{uIl+~}BcUU<=44XGd^1#<(m zIUI~QRL^>4Pu!56mTtn9bQfd%@xO~#_cn_%cg}0zN+a$wjCTsJYXjmU`XDMKs2J|g2WmH zzL&nJ4qfcp0FS~*$N%l!pJ*1wv+V6I((B_VJ}(Ag6mX+=#1Ki+b@bn2k4Kj_FV0bK!-n%oXd zNc=-UcuU_68Y`*-`@1}s(fR5_)Hvz#G;kr*HHbHMq#T#m77yi7uivZmtJYnW(v)l= zIpFF7hYTG${nCD@BUcS}duE8BLHN&u!T;kL*k_Jt1wz<}6c4BJrFdvH`?ctY>7&1Z zBFrMJ^tC2(iWYYXX3GRjlV7A0pRykL9XJ*ZbRg2>!~J%)=P`9sH&`l~yn7XeiUvt= zY9C=T=8pHc;|N=ILpL1HY-91%_LLW^VnmZwRgY{9(VEtQe5Nf3C8`hP33VHHb&#b| z$*2wQR~`#GwU@g$Pq7MGtK`-U1J)*>Ho&g=B&0ZY^bDi=$yeA4>wfBGkdjP{0qV`C64BM7tcu)Z|26FO&iY2nrr8YwEX$+wbx~&~##yUx~ zN{{FFp>-Ypzoh4ir8y`0EA}CvS~(Wfx6b&7<&CJtF*J9ad=kSOqc9Z0>Y6!{coO4b zCos`N=iulvG(C#*PVG1LTqAft5N6Uimp+dH0zEps9l4{Vo{JB4DyfQ}!5dP;_U+<> z4^kO$9YxW`7K9$Uf!9Re?o2*AC5d4>*(LQ&E~ZUtQ7)=w;HVY*H>)AiM@Uu{60vy{ zLYThy{xa!Exj+{~L1zVy%7skYbFy?z?>J%*#}>yn@!g&2FeM8Kdpj?`E$kov;-C|- zZjjb3i{^Et1z4w;1Fj-1K)bkHhAz~Z+(ddJpQ;QxNxfwk=BXIm^RDF{>==|WYVHd? ziaE!?$--`U{7W&nYT{lREe;@EvU&2cMA&&F$tmQe^cR!H-WWwKcPl#KEPe8iJ7hPx zYoJGwQYi{LWX$>^QaQj;P+@Mk!%yd6>oxoVyMK%T@+goAr{-rtzA=hDVR7r8Y9n^^ z5el|`!idXDl8cYOILE=yyBz+u_y7xR+G&smC-wmD=y_ij*|FU{kEMOq#>etbgSCKb z&V)Hd-m*D&-q)nRc2xi47B-d|Oz)f&n1^n}I~t6fD{dW12Rq>V%k1%wH~Q@aQ%$FD+)t+U=e!E*+i=aZii# z#x&@2YfRCT=sd=6r(`MMulSysU3R_f>}q2H#tF2h^uWS~Pm%|C$8aV%+!_jvHeIqo zK*oL?D=KY|D-w75u>cXQ>BNTmdgq!AW7>fW0UyL+n*SxhZvCO9yrIR9%Lv#Db!spX zj=_XAUx)GpF@VgbS*8&yXT{ftF<`+ce?dLQupl>zU%&jU;6Fa~Kw}@I^#119G&ly1 zo3SqXq12Qg-Z*0&xD$*zzeWXQ(WFD+z-4TYpZusagVM#iDlcn`HN8I!VEuIfk7rS5 z+{t(qov!?cz!9%xp`P0O{Fa70^VqLCBp~n_{7YoPFH6`>okay3(7l9dNV67s3HJuK zb*Q(!B@Rz~?m8g_-+7*ddxEF43+SW(GmigmSpRhb-q&-P^2E1_@Bf8ABfEr}EkK1} z?BTeVOe;OLs&iSJ$XU{-t>R2}{QJ|DXDKtAsVyXrf=kGk zz%g*gr0MB3;U^O|NNAlM_5AW#@%~fGW94~+fq*5n0JZ{y6m0{Yj?>Ywa>nk>sAIG& zhf64_lvEx(X5M<#)vlfgB6+X_lJN z6p#=B^kxicG}Bx+_6|Mqxl}Zt9bqQQU#`oL+~}rD&{j(R8)v zvFYX8ud>Pwkco*5h#xXzT{GsCU{AQ8vNla+Cm`5;k@Z+Q+_(v-2WR;eJATSGltbI^ zWZ=(5pDM_c<5FUJ2he*NPK6mvjyn$YR{Y#o;AMp>eiW(He!z5tSEZt%%T5WLHH7L0PdAiaX+UyNBVJL2>=D^HkipA?ykDu5*PBW{+P{~ z8(qhQ>c_&x_XNdrnY7j2tsc0$oqP}lK0M|KugJZsC5M6j!1hUxJ9p!yES_RBpY3tG zy`SKp7k~ce>8ZT?=I@J_e{z+Bwx?!ynDi0vlJ@&|;7Ks>M5xm0gbZpteZt_Y23#QR zMEa2fYJVO=A^f~}`7PN>5NGsa9ZjF#rAre0i-((M(0CuAbrwr?Smlc3kI_T8wx9wN z5Cr~9UnfGK-7lDzx&zHxgecsYweE2!b^wFlf|6#(t>39wC53gJ`JbuDODXpmXLo4M zY^}8XCyp~~xNRZeYTs?q2h^x~xk1!F&7VC3MU3>J~$8A^1EvRSUt5sHG;MQ2s9hy5}7W5c_h`^=_Bw&+K zC$>VFi9`woJUbJkA3ktYybz#P^O+)x{6X9t4(e4OA4qytjt+)5hBt5U@YU8IK|dI^ z)LrgSeUiz^7JgStQkP90>M#ycHPT~LmY?O^Ffe5o3aU1if)H4J74%oZ*=T)*_T*QQTb5+NO`YZ5o3TK+gm$XkEmUR*ui&`^#VGEj__x}L3{Zg zV!d61n&&5|6GcaBmM?VE?+~1pR3+?I%afpJp>>!9m0tc?esF*Eb3N^aR&kjC!i&a` zvOW^bWt+A4qx_F3@PGQxbX}=#t|qO+fo&s8-9SbaaFFM*1g=!aimr_KcR4v?TS|1oS8vx-FEx-h! z+#uWM)6w%r9TcI9+;InFF1zMX(`n@MTFD9atZmOdINLc zBhLj2o*`XT?xp(IeX<8Ouc4xqHN7zp|8ep1bC);}HD(F%Xx45cI6WghEEbJc8hg| zv~cIRY+C0mRc;mfc5k!TJaMc98;EnZ3+qQlc%FNjfvs{$fDceDOcjW4!jwZM<$9py zA3z_=n3iIMvArV{C7OB!>efNiD+hH=CwV6LS*K6+fZ%lmupvaF7jXF^mJb<6_<$aH zuzJrbv2KAVXLuz{yNV~|KzlbHgj`ktR-hx|6Rw>Ac01INKpwi*9-QiTE8b9m4eG^8 zj5=yN9Zx$Oic5oWvmG(NHu2?fWE6^QbZ=-Z^V^bwBbJzLh)<5}S0dEDDF(B`$0$I%slXKQ!w+5Fm1 zJ}7?KCGFDq((p?bgl;c8lWBdh?*-CIItsuyR($+wG^~Zfh8nRWICfnFVu>Om=+^pa zFQBe-llCy)BN1Ur03Hp{$G~-Aq}WSZp^Nqu8*MB4=tywHpYat?iEmYmj?g)e;{wL3 z46pi~G2cCSie*6C>|u|j4>`u6Aqij-i?9zJ0!&My3;?z2KjvC3u`HgOhi1olna6cc z&ugj0(#nMZI!Xf(!j1vL%7ShCp-EMDgDEUcBp&>Ok$!N|)EdgS?SgGJkpO#UUvhRWP^xJHebEAP*xL78&Off_;Cs(2P6BUR*@rViB z_Avm~4(3Qc^_GeQG1(@?5_=IRt*7A3QNbr96)|U2L{}i+pbNWT_3SUAxcQ|(5vw^= zfaupZz;(nrm6G;=?@C*zIdO#dMDSmtrvMk=tbP&etKfG*W@*4IJ(;-AWfEpSJR(f0 z9O{Z}za+#oAk8pM$x1Sm9Ki_!d`0o0S69r2vIB`4+ZD`jTS$nVOHN497{(Q|KXHDe zUXICoQ$y;p8Qe@P*$}5co-BtWSk%Y}wP-ZpjXP)&KA!1s&j9>iDjmj~B(AZEvWFAVl2}+2{=-aVT**%yNWhTtOJj$V>lr(IT2mXnrh(1I^ z6=`uG8$9w6(k+_EU2s{OOn4{3&!10#zqX|~9SH7df#})TZFYx?(hy(gIdRjuHKQ|Czy8|%K5zw!3R!WtV&*&KhA3)%IY|sFS_T}Vr zookIc5TWl7o3u7?+T|w-Q29jO?gWYx4KW)ONPZS)(F4)uRMaWDSrBSNdNRqqPh;OC z5|sveyq{x2B5LR}0-g$#rIgx}#Kx}U{mtti#Y6rh3x$_|fhhQolL>_5UkW=9xzm?s zEtL-Jx*oAb@hHGLf2P-|aHD+unAg`V0Q8ZiZAXa@#SWy%>LOC5ecRRBCOs;+eRjCy zxly=c2>!d&Dh6uU`X-GlSyFi#oI_u|q5WuD)@Ekw+84nLc5c81j0P7|#}Tx2d=UG{ zZPXaJfq)uZ+93>ZAQiI^V|x*9oto0b=Pg`JYV2n1bdv{6+?h$&)3QL}dbblGWP9bH zUkM6G%$U6eEBiv}^qc_EL_F$>OiTzvqq=Mr#RPgZg&yh2;b` zKzsPRzbpRE-)<i$V4>Gx8FdQ+X9H-|B0?LP#Bu9e zF4r;>7?6bhRA|0{b!Z2|6Rh>r+Ap50!#U7wrQT_!RH7sdcNbZ)V|<52pliA4yw%M_ z_LLkIvZTagnd3E0lLRHe@Jf>>hyhhH>;j~0O|`N|rOr;p3PQP^XDb2xY|^Y2Y`z(A zHAsYJ4?9OA()-hrhT~a+K&=2(1!)}KYl5ELv$prQiht)SY6WT;z$yHc8KLAmCvfon z1;7?X$qGGi$Fe22rdVWZRiq7l8s>Ir1+|^*Hzy4!#DIUe zW(R4qPy8?{iOor*3gPYnJ1zaNv(UGlebG_*o>+;y&h3gB!TAE3BY1G?BrLCt%Lo@d zfjuX?)0-Rti^Vh0V?R{Ep!Z^kck(Bopx>;dRR#gNzK9| z0U9B4Jsk=mc?min`vU_G&`DC@bsSjDLNy~|6Ga)q=g5vuD{R00jWI@>OSX2YL8_s&stN`feI?ol3}@k4#b%0g1Ud{`~Saij|e->er*8G-VS93Sgku@lX5#VAqXp6 z6^}=cufrQvm){aYUh2}x=ndfcspMG1`Mzkw(`%4@A&D#8uGji(Iwk! zx=0yudxTJkfPkD$Cuyx)8?!*dQUd8d&W*FbBSjX;iKE@^+O1VdUk5eRxzsLi0qQ<4 zw5AqonMxy_a8f{4 zw^`%B0_823Y+z!gUqMtLghlO>cxbdg{oyt;MOn?5`r)FHXYSR$6k0(^sIG{|V)qW} zei6>BY5v5ODY3p5loN9qKLEwcXNLiO;JK)Guk+V<{{2W4fF5>FK3XfK%UNIJ-OFdM zKixAvrxw#7zYx!jYLU|zGDdjWo_blY&4&-+@Hr=6q^Qi$HM?j|MoDx+$Ut~?P~-;@ zI<`bp=_T=0?lp}A{wKLgWbH*?*Tq=r`=q_ciThWrp>bQj`B8cWrA&NN`6mC~V(WY{ z94w=C*@dbtlTo5AYZad2@A z%@=4}4XXEs!c;~!0h+q*2#XiMI2cHL^cr;-R7(9`Ldqna7z@|(3f^FR69|J1#8dw> z#W)2`ngZE=Ql=%FX;AVm{RHx)^GEAs68_7B(730fcV5K)Ki5{HIRtQ!A_3Ks4s{W< zXiEpWfn^;dX+RhhFJbha#vdmkqaGTpZkv13XI1et(`sZ zOKwc5b%()P4^LjIm#Tz**y(5azDI2+s^F5yE^)0$vh+udKN}GVW&Gyt@=cOC)`iIa zxH-9rz$*1u@GE_d1ucWX8e31-2qSXID!Kp{p7V}qE+5(fs$|2u6Jq-6<((SRchH(m zj#o)iB>fl`zMe2+n=r=5!s^sY(E)AT9R2UI-VsCmPEaOmhxUWfO}SeFT`0Wj1<3Vo zDXUWjj1Cm#A;y;!rcK`gr9vR-IZsYvLjL5j@1N}Uxfr_qI$(8iQ+&N4<%*p$bdUr* zT<0xViq}AtcFhA;D*_}jh(*{ZCN}t{QyEmhG3+7|aoX#CL;_ej#D-=a>yqExI;|!` z;KL|%&Y5oHa^g)Ms^}{_g(vtrIe@!ds{QmTfuTM-EWl&?#+Eh~G1Qy@zjt}<<~*)# zULVZN44N@RL?gYRAN-*B!4H0reze>npY0DMGi2`P^TPBQIwS$Q5X=^9JxPr86R}uv z+xkIDEm_68nlV2S8XGg=HkuwH-0z1q^n5V(^hogl;Tz{op3x|&BpD$9;h*Rv61yd8 z08SS2M?%5av1?qxF%%1i-W9XvnPFolTrpOb*t_LgA25%LGz08C!a6aY(lv~9k19h5 z3YTz7nKekPC^&E~xTbYWJW&fS9IJS0fn9OGYnXnm`HcPI0GI9PUr$yhAIDC|bJ2;g z>jPwQHQqvmX1T;>9t&=PcAx_dkKD61Ocm?O;!6x?GlwGsdq(?bxXM8e2LLXuGi z{B4SArU%;HFZ>ybJhk$DRTd9kdSsHErI@PO>BJCGE8h4Vwsnivpj4exFHD$t7j=yv zv2l`TmD>iq{)=U(Gsfv6_+n7qs#>e>`?ZRWOTrdS!UwA{`wX7EnmmR~mv?`kqE*Li zeid-gdRGC{Hg@2rhIAkQ&y_@h&u=>JUly-vJa*Z7I4Ib)6h2pOb>L<+X-sIP{PmUd3KsA&I z%eX{`gAu1ny)oQ<@eUxO05#>C^u|HNWmfer@)}mZ0??%cwyOUl|2inKbf2z$=m#I! zXML-*+YIFrc%a(D}R5}0`?zWZRd!h_hNAG1cDZR&74w)Z z-nD$0E^s!WAFov_5u1|Xf*(Z;?>v?4+@&rfCq2vF1?F0!Exr$j`En26a!{7rC2QG1 zA5?Utj#{#)F)S+J(KhNr-oLY(`;z+U8_C8OumwvnM*Jxt))x;k6h3wBbj{Ruq#@dt zc#JB}8|_VnVA#C50sLs*r4)P7zexwVqlv24iHQo6iDnhbH9gleENnH9COpzkp*ZN#1|u;0`7_-t1HFN?dkA^MdymBDH7xwMv7xTR zpXN$lm3$O|7b}uNqTe1cSGjBn02#RQ#FtlCTdJA6v=mxRA0J~0=zETK=R%Y9 zdZTEWdro{u`6puu#a{x}pwh=4O(ougk6;;(F7lRw&nD;6|Ml_-1Ok8R z0g^V)emtPR51xLUiKPFY9s|(tS$Ku*$2gpKiUw_9$w7L?BTly*%LB~$05IB(I&ZW% z5+b`Bk1TQo1{%h-0H|3kH}ChM>X^PCb~kw_0Q~KCfPvo z%QIqd7t=bv!G8e+7(vggjE5%6&C}HT922BVK---urMEW)c zx?q6@jf^A%@1~y-n$9f+M4eAyaZZn`ZmMp#HQcPjlC9~G+ZKR27vg97m=jPQ`~VBP zhMKrSJYxnzKdA;VyCI7EBen0q%XHU*;oN0+5s+xE{sQqe58o-i^Bupm$76_DTuK%< zhdm_j6l!Ab%AS7LKJasSNUbueE2-+uQbs?!^}GNynqpWlDJu|SN-r8`(I?H5_obHd zAp#l15A)Ig>h%{w(WbEte+ci9PVJcj3Mx2zW2txI{V<=*vUSTYgg;zLJP$aZ%fo^)Wfp6O0cm&{9gz+_b*G^RzDi&mIdxI zWf^r3EX=0HBNs&eNubi@@umZcqjoCEX>LQ@oXe7RRas z{hpRk6Lz4^t{xD6Lhv6qMYz2b|Lr*9vw@mq%?-GXxWNFJ$^7Z$CW?GGE1>$+uH0mUmw{r}V-+%J@yW*Sw zA^z;YH8R-)adtoZ)354^>+(0+S2Sy*#J3re_`*}yQW%WH-Xi+p7j_L z1tN7OEm%EPJ?A_3dEtU)37b0XaKZd-i0cWNb}2%2X+LT^%j^#O`W*PE>9{z$%@0$J z^NL05Tyl*EA+3#493J{U{?Gnd{OND_Q61>!0*v%h?OYi^dJH*qd-M`yt7+vLy8lhx z3~M$##dVsQBVF-_5RiMCF$aY~5RKt-(;&~WC zO7hTN_o>sMzArDV;ZI4-u|a2h1+IC7t56fpqeqLMfrhN5uXWm>mT*e5aLpBN09!XBe|6ul2rS)Mfgkgia9TYuTh5dK2OG zh()$NJ_!pQTe)NcPgBYzCF#%LyLt_FWmyI3I>z(3PuDWAI?pT(FD>;RDbps=5CY+; z(iDT4q#UaQixKz`a7P$^LP*V-kk|&P_8aLh>$+L*UO)QgAByyk^q6RiEzsefVX7;4LL#Mr73eGY z6Y@+=fD3tF=N94l|?IT3AC(A+0wTPC*!Wg;o7G4}$ zM>#6>FtrEH9&iwS1`3!$$+qE!H(JQOdQIR2%BqPw-e)!gEGmw{+<}_wAN_I(4pCMW zBz^OY2Y1`*95lFrD;f4|J@7BQL$-iZFC=$h`U^z?xhnqXn;)tAYR;h7rE)jR~?t}>^cyKwf_UK``A-8^X{X%C(Tx z%bgP3IrTZQYCNRufUeaI1s{kCUfyiSgWu(V; z3CC;5e*0G*=PUuDNm`S12tze6dxv5axnLU>Fl_NYPYF}70PhNr888e$u@U)%prO5j z9hGoF8RBH2C(fgst?2u7CdaIl)^-`-Z{Jv=c;gdiAlT*m;+d$**M1xAc(n5kE-m>c@_w4`fe+K+=er{d|z-A zwRgBj`mP(gJ;X3}fVuFzpS>dDJeK`rZ}vusuA{Da6Ah5K z)3TtHU7Mv0v6363TVMGpso7*E(6@>h>i{Adzy7N5S`zTAG?g1OTd69K+%;PrqKq@ZP*ffJ@^O<-YR6V^^iXX)ZcgZs#u(HM_o^>z=s`Z{KU!gso1BS%@# zys(P>N+d=tLC*^aZxw1Mc-#3K1zdr$7xvPC!%2ZR+3@bi`6S+ehckeBQ>`u-pk)+6ACw6^<8Xu03E*vzFcucM&KIygh zbZx|LTbm@Ol77NFO+nOX&B99{K-63b6s^Lj#Y_te+@)2Qyo6SlFcred4OaFSF_D~t zm`pxLizcFKB+E>KoZUWPX1OJP*dSeR?PV!+3A*%78{K*@@eK35Li6L}yeIvnx!(iA zt5RXvs?-9tbnpZK0ImvJ`>=K#c_S#JVwi$Cc0Hf|h z+AR+|5CcY&mLTn@+IK^?0dA(eh5t)KRGXj2amRoAjR4Ycx^LG57Dpi_j0+J=8vE`i zGI;wCRvy--pY{&uO;=*nt=1ibpECwfxj=`~s`bHXmfTyPAp)!oc?+CHOwjTY_$Vm6#mtjEL%hHUTc|pg7{_F;@C1d9bo*F|_|B5`0) z?+f%BUqCg2G^Jg3%4M|?4>?f5WYJDKz1l3@YuE}X`b7PDxAMiuX4yy;R7V?8^u{i(y&yE+WT zlu{UXb^dhTB*+`3Lp2?o9~(+50w(+$9e1)qWn)SV}9;$ z@JUmHd$IXM2T9Q(su3d_SYSfxMX?84Kzpo*mGTa=OjXL{OCj_Y8+5#BRF!%iP_2_c z?b4o$fr^jKV;+;RvL2$Nl)F(4yy6?%mg%y^V6jg!ZC2;jI@wlkIV+3@5r!?4&b9aa z;A!0|cT5MPU9}vT@p#}6boM?hI&@f1HK0KTqYK!H_dk01nNBlKM%T#Pc#CI+t79Kn z*)3r;w6)*h3Mr~0Hn(8}AF%*#K)w`28SXn-?0oo(r@~Q_fv{a+%9?`aNUt@ZX#6~o z#=@uTk8~-L!R4y3)#$V?TFxgCLx=sKcL*4$eId_N(1?aeR!AD1%RG(|5N3e9b{rCg ztD5$87g8NkXMs&6q_o3bbqpifLL?WV`ur-x-|LQvOFiDS396e0J5b@v`s5zukNZv& zY`Ioz%-}mn5g}9vA4wg~!vIP{A=F7YDo< z9nyCW=PJBIst`zcBtF{XDG(6kfy*qnVjvR0Jh93~%(@_4vBb{^(#K`9d`)}l05kUc zxBs)3UrO29^Tn-=k;76#RF%K{!2VZ!U`^FAX&-3HYVY!pxY+C-z-*ZtPSvcZX&tTt z)LGzd%4G+_10L8)&|BLj7(90pdo5-F%l#H@XfdLwsiG>!V9DFlGBMe?UQfOu_C#Xu z+T5}}(-oE&Rz|l?4M>hGG~I*vm^69(TXhUQLe+lrBYPJ@j1Gu=(}51;o|1@}wexJbtqr9MD~ytYEHc6{(vfi9ln{>hW#7A1WyqhR4YMlI@tS@{Q=%f6*M!44e6!Ql=}hc(WM`A{SSYP$=(@)=qWn~$_8 zbqmg6Bs+l0*0tkP3s()*>5%(g<%dfNEK5#JsKFKw4rj_3 z*b$AHbXhF(d(%76$fP4qEl3txGp?BWivDUj2)2yb9|orKtrvZ6@BlD~H*)sNGIHeY zR@`of#v-Y`x-^s-cG~>*kkUcAHPG1-6( z&53zI&VEgI$}7b|YLX2)B##<*?19slz86paAzHHeT`XlMa#haP8s~96s&KIvrqUi}l;>e5+u$P* z&wW-p9WgnFZ6!W?`ZnKYeeQx7Sc5~l?bMBMcql2I*b20IgAkK6wc$MZPsxDtpOj@9 zNFDpvMdfRshpJG(w)<8*>ya7bJf`U!Q`E@J_-@w3G5Q*V=>>7VA`e?1VUNFFL! z;}@kGFhGY4M-NSVN^qxNK2V!F-8Cq`6oH*b7CMs^6u7cmb3_UWnyqy!TV_oQW@lgI z8q@2ZMfn)QYmZRII<$53X1Y*Tu#c>hG!fhZoPaiOz;#H%4pyU&+BPA=2WYyJa3W_; z*e~QkI5{kWX2W#6Od7WfHeU8{w3xfHAMh(pE}eenzj8Ae?xci+FQFAx+h@U*gV~)1 z`n#4F>&E-x{f}V?2D?wtvJQYoIVOI>PCG_pH?WZXr^!IENtGj@)smM%!f#jL+EvYY zR{p87@=p$w6!WS74O1hu4j$jngwP;6nh=?#N;`jbak}^PZWXI z-=@lAjm09wUF$9OORxhKw)(@sN};Bkcifz0)EHA!_8v^w9<42QN0&Q?V!BqIIWJ$tE@U>!+-Qt{Sq5{5}=7I&-A zO0$Q)q7H#-P7p|zQQY*UZ?k@)w0Tc-*qg)A#^d5FJCa+Pw`jVxP4w=G6^!Lv7fU&U zIT`{>bWqr-i2oP?#xi(JS%}J<#QRF?`KhzvglRFv}yFLEM;GJJ+>Cwv;Q zMh$!mXej0IhIPYy8eGQ`rV%qmV>@R3{h|wCgR5o@GmY*CY(V^tl!8t$a!b)*raOS= zK-`NA>_bn~3lCH{6vh*WpOcSXKLMtX|464UEL5J8bbbk>ql{!}vKx~Fh_SBeNA$k~ z`{g1mrkh?3JxUdPi|9^}B>^~efxPJt-Ui(fE5n`CrN0nY- zCo&~lI$xv$1r;v!0KV6E-u#Ol!#&tQzD(~wefhkAcM>&`#LBYJHpf}PbZ;%Rs~IJv zU6pIO(60QV!_E1fC418Qqz-Yk)9)e*|A>p5=qQteN%${+Tl_8c7_Q`UVu>$7ZTCpg z5S9|y%DV`jF1LaozIF#PuQQ+`|EZ-VY%;UW3^RBNW+-m>t8Y2Db8g(2Y*GptBW$61 zW5)A$0Q`(SGR+Y!;4n+l1; zD*IH?<^>cOwalRxL6|of86C?aAbspd(aJW$m_6iDK?_J#kc?sd24S7l7zc!3LMomE zEhS+ZI_8blLu^Mfv;vShFMKTswCQ7Y*n@WWL}&1h2iX(EPY6vqX7t#U*|4!MrL|`T zjK`OFN2rZ{g{1Y!S$aR|HFix&cy7=hdg)?Rl09tFSa$$g-zV^`l`~P;kJ!1KGxJIB z6%Mbh%X6b}2Eea*OlYBW=x_v&3FD@ZfN=x*ox5jUfR;l5=Nf9S0B)%&ZI{5(91$x{j9@3Px=eHFy#`XlC5BP8SO>_x6hv*TQ|xtgrcU}(34#h7qGBy@PpP54qO zZ=s3tLkI_~Jm<2nyQLwt$fHo6JdAGpVHE<%Kxc>#j2ZGFl~Xhd()NdlR)F5H?Ynx* zGspA{Sno%Hg}@wxB94EhIY{Uzd=|MJ)TtlJ1tWG1eG^E>J?Ob=86M>j37ITMI$$LA z{rvcTBWI+92+_ilt5zKJz&2aB0MZ0c(%CgGf|p(;si6Vkw7AgjiO1A1IDo`2{q$bz zYCJf%vhWU!!*=cY=YF%_^g_Ojdxwyoj5hrT{^1XcAKL%?KUybr9`R0|t!#g`!|qpE+yZ;PDf_ejH`4{6{z~d z(pV|yF58z8e_$FtRgCxIC|ddz&<*?hAfHNZFDVc6*WXF;?6)t!|Gqz8s%`A#H7qD= z9c3?Y#NNA2llcmA?H_Ij7D9vK#L2INDDO3DHGMfcvr&Xv=o~u&5~V@F$N1E9Ei#kJ z%s*h#;0*P zbbwVTzz^30*-|`?%DoQ|JpfDUZUI=;FeFPPr#h9n3$@#40Ww_~j|BC&9cdF@#_IQ8 zAtdT*CZuGdn!Nlp+0}jX54(N8U6R|IqZ{p8J7=H(AQvbE0GD_SnUv(I2C%j!6Kz1c zFr(~BR&VxxtYefwMrb0o*khJ+9(CDa_=6NL?=&NvcUWGlhhDx&n?E1wCpuG*QKfKH z(m*g9*1iACI@H(SIChJD{-|Hs*G})I38Dfdwz4hqv2!k)GVD`sLaMzr;@xM_ zl4TmD2$=$$E`rAR9aj6Dt9k(%)GCctT;`64BPv!_dx1W&5{&CH;7I`|Eo7^Cg1@p| zug_lpE$C+8*u`e=JQqY)>KK!8LRIF?!q16XUqpa+o{K<3^RNs>cNK9D;WDs3 z6_>^J1VJJ1DFkdswmEQLyweFFqyerxO^--7V_u>?*#uplE#qG8h7kfM1SJx+mV+3B zhj+;wZ6@J-N_3j_T+lqiob5mxWvg75t)lFWfBI``PugcuzFxlAqmeKPg6m5c>rnfQ zK9Mc8*+bRh%CpE(F}snyF&XJDeGUprFbn1JD-o&^fK-vRS;g*y68%!OncrtW zI+k(>i^A~%Rqr>$>XJ1El&7*v+?s6KdMh&~x%7POi7VS7Ibq5JG@N`B72ll`p}um4+-_I{6Y%>x?^V$psm z%0+-0ds0`R@MNJ}f*#XGQC&C3ZO5xYJWj_aRgLQAgIvS8$8wRKe89EB+^Dp^ApsDu z(n#OrFN?nn;^*fWFh4&dN@XXNt)pjTQg=}W4qu*41>p%`I!K`pVZw?Lr-*}#gx$}f z-vFG}qCb1$)IP>JvYxQ2I!UCZA49n15^l?jmZHlxXHVAUMolX?ABZqt&c}A$OA?f~ zLIxiLJeOj8W(ORg$Kr&!EtH$c5Of4N0k5R3h?4sbg@HSg0^*8iuK;`tiFM!0Tl|R~ z!2(?eNjtduZs#$c1_cW#eNd$E_?$|%J4sV#b-1JbFvHQKnq}}ywspF`VUDIy14kW1 z%sl*Jm*@}9;^M_SBHr7%tL7ndW@n$?DmGKZ5K*KdlbRK$cOL%}S{%kYvjpbs0+PumixzV`Eae z${NYrgnJX$YHp=(Q7%g&f<%$?F{l<8V4Nf`*aj7B4cajb#Z)U`8B~W5UY+UaH?f2s z*@}8t$o@P>OJoqGb&n=;_=Z^ge9o3&^tBy(xt@+XSgAfBTz9xOkVrVUJ0+oVCcDyO z`z&1dLZot(ILW>C-!MhPaZ8WrDPFMkbiEGpo5_XBY{G#~f{9(Jyno*<*S^4H*^cM2 zeX}s3b?h6_&^*1zDpiCb>sc+5b|Hmq^(MdUPpwu=ALjxUBT2HI3XQaASV`#@;;}k= zKUNg0OiVZzRl*B&aMI)5p5T*v7m|sLR9(}Bc{ub?Zn0lFXUAtN!yrpt00nly{z_yt zP!Q2~pZuo-ex}?~CUwK=660j_)a7FTu#hcteoe!>Cj=u^w+H4jn*&bNr|ub0!X1B#SvB>=A(W*anO{ zRfYr_nagluEIZ2Bx~$m@D3YJXhAzc|wOK4*AN_)C6iGnIzg4anG-zr9SE=hxwXlyE zP3!b~Gi&&`(HlclIP%co=yB>ck_##Y-;INqk1&heq_3wQAxleo~L>ui;;jK@U-0$g}J z{8jN+f8{q|3&0_UFs_=P8E>3@!Su?1#)_vvXQ1DPygakCQfvMBZ66$7N~^20@Yjm! zQ>ZDf4 zxUK}>^DCU}88c~QqTaiw#r_XjH_ao$Gb1YFhPY%_*4UV-CF|#r-qhAFBY+SE0>Xs= zC=sMUvvZ37HG6H}YkL%=fzfzwRau!H?%VfeT@KVY048faq-n8gE^Zq~ca3JhQ*5k? zJ+%)iStyLa-LtBNM9~Kdn(Y6nec>v~W_Uv-f<>+bK_H*TEJbKb$b9IGMyZ|Wdl9&! zzEOj=SOl708zhHo;)O%_3AcG6PT%CsO(in}Wil2iy2T!JB|HBtBpej)& zK|zbk1U*Yhl6A(on7Efs5sny)89&_mGuSs)d2WQwUz27^XKg+dx=J`qryzr}(K>OQ zboB4meqZy3V;>y7fo6vVYYd zy~@i=nP{=2OgQXwo6Z%zVG;T6A4C4-G&Md(0SbsH4tOOQ)czn02^oa*F#VJB=W z1jQXn9~0#y0I7BPGmUSd2y!jz(MdNkB<61hEB1Alv~A(BdbW_01>{ezswl@5DYi!o zIZTk+*;u=Wb6&}v*k%ptVLG3nh!C2L_4w%6aH^$tu(mKt5vuvJo9N>bRq$?H*X07_ z(@h>3zaUGs@k+*3d-Kj`7B!Y^CN_PivLY_Cv}#e!M?pe{I2ew0fFN;xt~MijSdS#JAhS*}yqsOXq_f>~m^c zS;32fR+2+#=E(OxIA7e}OhYeWGh?uwc2iIx7WM$6dQL;F21w8PM2ggmvqO+f2MBI0JwgC*=d+l6Kg$&qyb zdb6K!1r+SmElW~mi;g{QM9hQM-`B5S(Ml`)@Go$w-T6Uf|DM!jhef~S=nrm#yT$n4 zlpC|lt8=E~ZPGynN_lGuw5U|bpi(y4DI%D~i-Si%{!y0kbV{%?C#fAy%ISs{QdK#V zVFO>^1}MMb6`Qx)oj0?ZLv0RISIK^d+>U6%HKxl)gmv#y{vE7#4V?$zm+RLw65ZJh zXy7e-QJ$Q2wm^Ecp8O^$Qbg}asSZj|8ym}QRuzXa%LvoEgz)y}+%`4jIRKk6F3geJ z%&=^7`!?zAemEIFSYAu2>F^(Nmmk{@zSPCCbS=Ne&7@ z33r`Xvy9@CQj1c~PmRYZlpL3n!#}G44yAMqsSR+f*mES2TlklZTG@zjuBHn-(iz}G zS`9%WRs%!IX?C9?MeODmzzyOIXY@2E=>9o`4|PDkD`^V!@a;h1ye8lKnTu@vQHbSt zXKrFr;f|2qS}X181aGR*CjwvUT__79N9meq6k{{*i&u_=S|t~09i>@<6LO`(GxXaF zYP?6;E}LkGIOF!3>Z#ZfmOW8>%#2ah^^<9WEZilz-twwjYB>b%LOgH6rI6e=?f916 zfk_M7cvn|ng{QPP%BzlU_g6_Uu5oFA$+FePn99aT4=5aym$!#v(enX@xw-Elv7>r~ z7f2nUP{{Y4dQu=eR=~ZrQWrX_O7y()x<=2_$+pc@?+0Vs8S}t%=aQjlSS>C(1|!p< z5TIH|b13%~>{UYo)LK}n6>K-iX|@SNjX2=`2N9WK;}SY?mTd@rOwPgWYdEf1RlS1n zNm1nCaNMycP%GK89Ut^3fE1VNCx zH>#uVwxc_`MFzY?6Oe9D zXXM`Fe`gqv&-2TpYxVFah1~lfx;eLUsjPDtPo-@SxrK!^c?5RLFe*xvQ@6L8SP_DW z+?;+CtRIOB($Vw+!HkGHz$6<0{CmGf zZ$6~4*0}PcvmL8Nvl*@NxYlNUnt!(J)Fy65J%fjcEL`QY-X7|_Sp>_a)}A8O6fV00 zv{u@PR>;gcf}|mt-xYDfY}4n>fI3__%s{umF1%E?XlHaqSZ8|!^NuK7WV2o@Z1NOD zrE18c!Eja$1CGR_?_NLSui=M(ftaS=_FWz_7CE5dD6R;7@h6kDLEV)XPZIg7$GgV4 zJYdY*^;oH35&gy%sH@~-X@1pco~lV_qg~HJ_n$!5AE3g;7!B&1x|{aAYHIh%fF~$P z)pr&C#ax*^u{-QDl2hw|KFk729gvmscwr1(06crRTLX70EX;b^qZ ztSbU^0&hUq3d5xN%-E@7l@4uy#_Vb^sGF+5y#FQC7`CZTMG$L2vlqUBF8=YP-Qp4L z7DAKsXq;r%!d~i>I!MU3Zg{khU6zV>yfg6qVeHU@X5~~(%_CfPM^{PO`bCcY!6%Ix z;7+PnaX@ksj<1sKov-nXZD^6|nI)*~ON^dqZpFPOneEdPL+XpI_Tr)dKa&5#kMzI1 zT0CL{Br-NU`@Gt8n#rOgsdjl@^mGb%yPf8PqPkR%rt$;e2jiDqv$?f`tz4>8#@<`VT_? zC-3=*^D(5DojS_f=B(_tLmgQJR+g0Y&+UL?3M4NA`7>_Hv+ifQHHOxhVoR3Y*@^Z- z)(Oj?gRA)xU+mL5AW7=k4ba8^5#Ig1>_VmPVz}pEcc0Qdh~RH4UlbwXg2)2vkq_sQ;sqV3xM1Ewn5i3w0`GGjLKi|pTeJNV>r^~^g5|; zTPsPTCa0L8-dG`e!&(VTo%;I}`?(C3rBK|h&Mg`k>_ zDPogSn9G0@o^^|oXAQM|vjP*En#@BQPp9AiHK1NQ)V|0tlLtoSwe0|-u0lMYb#!kZ z0gkq#YP#MF(E_qDWL4K)AVqS4eIjFnTLd&NycUP516dpt_u$pV9O{L?p}5ar;X|s( zGlU(XOs3+H(O|_aSHH@$WJDKR8NXo&XCJq?KIBTBwu)US&|a5G_V_{FU4ABU>S$m| z$!ObY&{4*W^s3(di8@}Q)%luaWd!D6Yt<(h2zZC8TUY^Ma4@?3qkYP_gC2pXm z05d?$zh@T@rJ-i=06OhSzIxN(7S#~AzIrU&!P?#q6EGB*6Xv>mRRF)a|Cs4VYCH(Q zRAB)Rl}`8EGOOK?j^rZ;HD>!rFE2X%u7RbED>uJd>sUpoR7$Q#H+8$CiXpHfETwokUHo>?GA7Xh7x01IKu}%f7zMC z(F15{biya-~aZL@ZW5|Vc(uy zr|t~A5WUHvj%kHvHi2XoeH0i`h-=9m)=oB}H&NG!+G{7LXwzw7#rU$M^S-EBx+gV_ z8|%uMk@cn(Km`VaH3CtTpklH+pWCNW<(3GHf>@r7Ewn@}hTp>pUXYVg45~1k& zNkz&1_ace&Xb{p_X;hfmv5J({l=GQgNb{{^LnVSirlKzgE()i_>h}ey&dgd-Mny*xd}*_HCcAAiY}I#Z$}gI3lteu65q2czyo%B&cM=8QTTjV8047; z?Vl$0sB>r~LAK!+xp0fu5;0o35VkG=Psfrf`Oq;&Vskn<*>ANRerYeou1Q}y$W*5S zXwQ+)^WrdL6k$ohAUsD2UWkOM%O9@nLTNH{>WZN^eqdkjIUk&^ZZWAzDiq3~r=DNZ z+tYW_njr>vkt;zy)pVNRAw%EK%un?Bbf-RxE(nq@iidprrPwDb*bmKcHe#UgFzfZB z9G*WhIl){$uP{QCHwY!P=*`}j;{LJo1i%`G8;H1?T5}qjeC!S_j!Z&TdIA{jWn;Q% zGb_N}ssFRlejpoTy5cq5PwcdZC!VAp6leBW!swRYZ-(ZNNpZvrpTPJn)as`nw0)3XFugZeau!W)G9E*Vl zDsTibiGdiCZEF0;x*%Z$QXUSNwmuSynxHX7{$Nii(fjET=MIcs@Ezrn`&?qyk&LId z&pd5NH5Z8r15ne+Qgx;;S_|3tkgKoIZ(PI^ zy=Z`6MK%+6aEiL@t=%(ym!i}}&K6FC?qRA_PI=uVn*7P1D%+iY2k6oC9nDjTZT_{r3{s67k6VZ225v2q z`1(9vYC0=op?Prv+>uxnNjN(~tFdQbz314BZZx1+r|q3*$E@yfno{@fh$?#@aWSE6 zCZAevtVqm?B(V>E=M!3flw|1^2f(WkwYjOG?aiHLW+^nhfci;k;7Q0Fb_`ICKGaCe zCc3Vx(T#1Jn$xqb5JURztVppH3nK~e)|M=ANqtdAMr_|YH<*|o;E-PmrWf^_)u2m| z>{7k*>^;HT3jAYV1W4|}IYUbxFwgQLCpFEnlS~CHi9whcv!?MXvD%l>Gb*iD3I#)F z&-ou36U4I?`+}*axW822?KfYhaULLndy| ztpPpmm_B@qzDv6=>fkwM6%h-|pol-LtspgrwFMMcV)u+P33TbH^E0Veu-uVPUf@U( znX?dCFxFj{F%&p@9qk40;W0YkW=416mJZF>EY88s%uXm8s9l48va!n=`h0RgxQ?f> z&7&&@{o;3RzmX&R1KhSme(T=fRq}vLcqyO|plM5KFbX1G(H&+q$8|E~J=+Sdy$`OQf+Y&xb6kn6B4GeNGgYMt2Iz*jC%ZU>5p6gZl-q7T;b{rXnMRw$=k9CN@zz%m-#K+2e9~F!j2I)!vR&kT3e8 zQ1^-qd1_kX2N@mhyp)Rk@t%H@&IgCOTS(8SgXHVS&H=lY5`e-2=t5ULN-F z*BaQ-ZBj(0IU20VF$jNdqCDD!tEmIdPN-VL+H3-Qd$$)Qjp?_LUfSB_)OLflqDiF4+qxDRva+!~!$-oFg*zJ?;R zMTyscf_~sfy42cy06BJ5$!bc#su9gGH2#{XWt4j^RD$q5gUHy!*0}0cG`RdO%PP0F z16mvc&-+IV1sIc6oahm6U}A%MWuA=EYlFfL^{5-@VkI;` zhh;MWSQ;P2SSZWO%Nd1?>z|qL8@ONY=dBVF;XtCZ+h#_Nrve^us|C~ByU5vawxLE225S%YyaxjUMSSR{$&_m-^( zaP=1UhrpSruiCbe)9bvCoJX%rL#ZAH9DTtvs#2i!-Bq5Tg|L%-gdGirA*__-0}hmk zD>(c0EVbU4MH|NJ{ipD08HO+n>IJnwD<`#caZHdt?2hecZ-P{imgZnJc0eoHP1}XL zlj)NAnNkjb2U$zLdZy=Po2U^A?7d^*Et-77Xd=ftC)p5#wAmsi z%*s!7L{ZhnGph#ZX*i*=8$uQ=I_ecQ$Oj0@qPZtKU9dyv#Fk_-WXVYzKy~yhhlCu+ zTwvI}`Uk^IDHU;GZ5ICn=J~3e=jL%&DNh+EE3|$&Jw$=mpD=AMbCE1yl>5yQBo(Lmt(vg zEHY+X!5~g+f@JZqr)H{lU?rVEZB;!~1@6l3VH?`EbnzaPOH!%v{9Ev4Sa`UgHku<3 z(wFbW@?l}u0SKvdQ_$xOIUX3dr_|iEOAp!blDk9`Ei6f z^{DoyAZmbaj{}Fkb9+eJu8+{=Q*+1a-CYG-TQ!t(MS+l1c9U~*Njq_N7CsF;5IhJ8 zI}b?0+pDPJZO?@>n4UVh-6Q3as&J)?TIY?4YdZ8RSG-U14uy=~i-1)Q>nfQTK#vEV4CE?>O(a?Cj)4?n1-}9Se!6P) zbX@gX{o*db>*%&OamU`LK>E zxe|B1l{@&1#C6lTNAIOhh=!R*-87vg&n%YGo!m&c*^BB({sdb#cBdTp!+4SeDst+3 zn8L}~$*slh7$j$ip?E7)B{)-|ebjzxF8d-GW&mHc&{b6t!q^odc|8=f-VU-Cs7emZ zc&^Js!KDllCi|+|Ncr<;g=D3L?Y_506^pgoYCGH|QXR?eR!0oe6u=mkCZAV`)BvV& zC!7_yt9sK3PBB@Knuudc36mqHHg@0Ux_6k0wlGkDz+EawMGeJxdtcT02nLp_;eHT> zM8D%g6`4n+uQ--{51KH6ETqJKtA^Q}0znW9&~5Z+Rh-L8>YI)-Rgl=UWF-iUurAa; zOv~JQdAV(@dsiqs(3@y&KY+KFL0aXr0r4#B??FNiDcVK`JJxYFMUFFRx@AG{p9%pa=`A=jGin7M&`|%AXlZT zX%u510Li?)*kF4%alNNVtwFWUpQHqZWGBH+1vb= zJk{Y)$l_v5AY54Q8&=iR11QLS%ZZgzzz)Fr>s+9*2(S2ch=n4TFx_F&O^|G!u_P?Ven=<^yYqhfFnV)0zp)<37t-p z*=AeN?I;utQ1$E?$6R0ce8NO3scJS?=hmqy=_4~RZ@gHcfQe*7at)W8?&u$&BC!yI z0XKxcO{-oX1tK#CA8`&9GLeR&!v(Jdi}#!6e-3bo=O5@1KE;=p;tEo+^9qn1-J&_@ z>tO;&JvCw>S;2uoS5GKln=RlUzrKh4B)ku2yUIRu z6GC^5qz%=BXl$*J(cU|%h{=kmbuos}wo|XW1TuDtu5g|{X?klLL%r?FbS^>YtVo+6 zNjI9dzNr0npnxeVi!yFSg`MBki{#@3mCD93Bx5ERp=ZXM>khMk#kInLZUHuq;&XsD z15QZgzbVY{>*_n5+s_A0X1Ns2XJ_YFG;>Vk6wc6V8x@}*N9(ksHMN{j684@H`b6`R zO{oeau<8^T@TS4@H8sY+;#JTvvqM$k=mI%dagpS4wZnmP;Ks_K+T}bN$8iX5LOf-! zY&`ynT0X3Sc1+$a?kIL5w|rf@bDoaKcA^J=uWju!^2vrBF{r7oWE94^;7er#+<_I4 zJ-}|!RP2W@@!^dxDZK$xm>FRu*Y|Yd3T+TI|MR}-1ql!Uw?!UV*}$XDKkYT-hEq7n zEjc>6Tc)gQ#KyL>Xy-K)Y9A1dpW4cpa;1I4W0#nOCLUE+itJC(Ie5qBQjiR0W+J#&i`PqqJJuU4^pZu~D+;GP&(w^ocR<18N z6#$Z(1R)DMgAa*)F0Id%3S|GqFJl=AF|aW#OSZS}c|%Ww%m6 zvIuV^O2u}N=mmJMJI#`DnbL?4GJ&#A&op?3?&%JT$&14+(ATr!dEeBtaNO-pdFf@|G;lpJ3o}a(_F1-5=!UO$)o*Q5$qkY|`eoEECdE|gr z%-`$2Uf`{(H=!XNUcayrrvi)FF^1E6$swBuA)x!4?%~chr;_siWTSS>VJM z9|eb}-8!i%2)+=GzJ}(^LuP2IO#V4RgxfF8-Hy~T_`Lf_O?kON7O=*x&}bejY_19k zrUs4A4FeQ^O;CCnXs^42L7L(!sFJ9M`WA;-lV$nYe5`E(kdOiqmBQP4x(4COlbZrq zI~ub#Y2Q%#J5?JVPI6W%U@CeGS07NpXjuU*xtDknYh_ELvDK;QXw$h^fV$PVmcjt7 z3bls01Xe{G?wk&T!xc7vG?{daQia2Locw-$45{pk+crJ1RyPbr7cnp7OyO5OB~3$Yhe9B1%4((-+=yt;)(=vK^(P z*qGwBbZ;Qz5L`a0*PzE7m(L!8>^GRN}tJgMFox$rGoQB;(IuTq}!T2Q`& zFN56C;vvA4MWD$7@?GLe;zz)gy_EgG+K_Bf7Yz>MZj#?yQp8gKU@Wavp_d`;VgshtekAS{N$ZfqkNG=+D9*<)0}@BHbI{Bhpd5LsoxQSkfJ!NQXE+O{zbX zznAP60Jp3UCp(^~XNX#N-u+QL?*c5){h%SHLXd8Vz87H<_(rjTyig4a!Zvw+?0P%r zJX+5GthU@2Ig9 zaXK+8{v0$oK6&?hn=6_~>6L8nST%c=8MZeY96bn8him8UO)C6yPLys(hxTt?f5U<5 zZ}@9I_;$k#q)*^pOQGMNY#w_7B`5Z~#1Tohn2JDp95DqR)$Ao|PX*B8q}ISqGT!Ji zU6xn`^em#oR9#>8dQ<7;&Sl$xtqDH50N+Kr` zctkN9n;k}HXp6EmEsx0E(Jb897eKBMNvPrOoIl#5y(J+g`zCU7b1kVeE<~khS9VnQ zazjGZCMrTP(DWl>uYsQC86SjCCHS7fv0kW)Q!DD0mEI0LSvxu!XXCRSvmLTa`Gr-` znmvhZkNE|9T(2J<2Y}PWBE404h7}p4L0~SWWG@0g;_MX1Cdw?wU$SVVb|FgLc5%1xCwFYDGz0G z*c@`NuVlXz)?yDYj=b|EJ$+~_rX_@SKS}PHoV+(69LY*Zv3frytMUjU^f7PvKgjtuvcEbk0=hgK<$SQ$-RM#WG4^gBl*2)<-n+P${Q~+Y z3J}FYSR<_{w5|j&TpL+N4A*Q-=x#DwPY!f{( zN=R9aY-3Y&hM`Di>MY8cQJ^uy`=a`oDAvoLws*J|$6CsrYvpV&_Kz;uYa(!B6 zs{AWMpCtHZl~mAxjhhS{+K z&Sf*K>Yi$=sqDr`R!*l_OZke6`%K^|JC;MTVb_6FF$Hb?q|-Bpqf=mkv}EX$W`mMO zXdgXZRNre-W&RBZ(-Idn`!qrlv3lSgUt#c|MJ#l=0NnKf)jIb|f?{T?mc4R??H34? zAdw=Q=8?HsWE=s#DJjY(Np?$)Nz=ij@}QzvKxn&ut9o#O|8y;F#OJ`qtCAiTv8Sh?>K3j^ZT!lJ+u$=u!DkNnI+Cq1uE^KWY21} z*WB2#hk&XhwR;^H_9{R#6-iX6VC+3y9cl|}&cThmUq#Y#%Wps4(DK_8O4N^o= zygmVvRptrs*O{5q!q-d&;WQMAeCsJPE103Dm5t= z*6zF30e5#`%e^fr?@Jf;Qj}3P$2BN7y5`o?WMn~n!{J~enO2ZaA7 znRnKw^6C|FH3^DzcDpZGR~%`5aZZRZ7N>B=UWofIl9B@d+jr@fpgPa18m#{$m#4fb zGyv3mcq5mlZc)9(_UB!P zW<+k`QaQ8@yk+c2M(CHwuCwFtGxLJ%eatV91S&ct++ZvfJIzjzS2v43@S0N_2usmX zB7!(VXp^KkdtEy|ZeE;ydIpM^YE+UuRV=q=oiy>7YA^*V9mTLbPUxD;Dv`5>2jjSQ z6uw)CrDwvn9QZ>9Y#$H8Ugn zVI{!Vfn{9*iQROla^ZugW7`)#bc5YhjUBzXt@wlG)04&qyCoFX?2?uZ;2#C!sp4@^t>Remrt~H&ie&#mH zVYXnmaoag|`t{SJM8~GRaElA0a=Gk5g=h1%Sh7$Oou2!C&sJi*tS?^8sz7x_wX1`*1I9C& zpcuN{FDK=Ytq6-4@w4z;(1YInhM)H^sP44Xov7M~qgg^_6<#@>W3Xm`+^%P*5WUsA zl#I;wI=$6~dOYd?nhs{^d+d0(gas}|ob|#P4a`GIoyKd?Mg*9o4UZZl3Ch!|s{u8pG-1%ILVt?JFORmbdBZaxzb=L=(vxMX zL-7{wAQJ-j7hY>qe}GOR_txN5E$YZ>N*2merTt>1j^EUstk`{$ZQ15!=<<`W?KDmL z7CXYT7P8fbq%GCNbD)aK)PeymRT9?iNGJrG^aS$-4)zA%~WdUU4{J7);t;RG3FzgrELMGX9_Dw+g33ykVvx zpUGwM`YUXVtWw}jU8%`ku~Kej+I&`}t%trNp8zbXZHr?DaF@pefYuN6EURfc)@%z6 zz(M*fhBuXBa@e<4lOEX;FY@+!5;WynjAecm;u(2?GqQoaU({r=NJC7_hj^k*!pIW1 z4C~Jy)>Tk{7XIwiKL)8mCpw;&lCb}x|%^-FOQFyxq;r9CC7ebl)k^)a779FFVsR(cBQkX^aRF=PV(*E>6O#nyJv!tV>8^e%FdQV4B)wSIN);r^ z50%S%VENt1);YUyLGgG-$>Uy!Fk>fLr&_zh8qXSnwkDH$t&+hxBX!>-byfY^R$Y>) zxRHe?@+%}o8`DM+HAT;iLX~$N_D2BHzvLcGQp9Ke(bq16JS{@P{FmxbSyWr0m#{zK zMPT$j0C((n{iG#c6_-lkLz9)%5Uk7Z?!{ZPWAc%eiaB&E2HYbA9YCn`gY~qdMGVRy zNKnTXIS_qFO?iOk&}5S8St=MtyS0`FF8S=?9@K719Tdy~IP3zMyLcJ3RY9ak*t4S5(YqIh7Lo=YhFffzO-f3E=gBF1%)KNzr;R!* zlY8rmL#uV01N>~=O_LW@Zk zIIk9%pz3<)=Kgbd{Vf0KuW6qJDt$V|n+uIum*`spEx+Uqq39BDlGw190+?5#@&Jb9YX zCuA9dZGeY&>u^8a-(;;Pxkkf)%wsno*_0nx}KedxeA7HNc zaPc5W_=W?@HIfMApY9yx3}0PFV|0s>Icm6ldCBn$G(x$ckt z)vGrQ5JBL@i0qHTl$@f<6qZ7Y&#h!YywVl<(I%mGIILjf|8euD9mD{#bB@R@OuI|{_ zI)hBtuyzWyR}<(K-Lp3M3eS=$6z^ak;9yELN%d8ARK2Ko-B^5;7qmSOnlVzrSd7cW zc2u`(+D=#e${W&spG<@PbUQSkV2TtU=(gB z)mh|Z=7)(NL7AVHE??Oajg8%Es$kxiR~u4+&FMvLz~28)rkOTb`-mg9kFvg9)A1(w zXW|6EvmdaGD*r22s-5Ny9BuXY$nW9B=Z>|`IqdvOyizm4HmUYLI7OP4TTZfhg4FLy zm9R+A!5i&Lx2j+!oFFyx@j_~SUD-m{{}0DMU{H756ITk^`Okcg{)*sY62ECW_t3xlbfV(pfNt*|&r$%8urJO8m4g!->7`+i4CXnQ z>(ab$lAvg3T~npMfkwvz%?O~)whSD*>{1leEP;PW)cqdB(UjY=(RH5GeUUU&fJNxs z0tsYDflKv0GP-+P`e>;59YvzPvx-w|2Q4BjO_|CDZsg`IbX=SHlTYS&Gn+f1uXnx(_;CmC$w4 zbfY8|NdiuxhQ=MZEn_%8$z7oW{PuP+lC0f)`zlLKH_50~@@?u-B~IRn1#GCJ3BhEu ziE6LqtA4QQzs6ALXaQkcSI*$W^RpTzHl{e;?ng$-%L^N5@Bbgt3-!ZiJ{-rD;1sy{ zxKF9%Q027*1OXtjU6FPc1JI#|UN<>>x)WL58VnQQf=J*%C~Q~6e=7#j&Y2CKx5HOJ z%7#bj`hc4!g|%s{ULXbGs0X+Fxk^R%Li2_cymMTW%QK^2tD;h}scdQ(TG!|a3VGnf zV9Q>~CuNcPp#|W1I_H9`kJd+4A3c(PZ`y~c3wZ~Cpl3(rp`BN$dXtSHHo0(IFa~*? zz37-Z$+R|*D?+JWmr~sK9r^39dk5YtsFVF`js+m?`rN3MjCippIQ!Av~A`k zvmopkPJ|8Br3c2$fG3(&czY&vtd>ok4 zk&2*_a7>>ap_WImkJ!RU1lMaMVu4AKM6%H(U#4Adjxl$)V62B}`whH{?9So+VMyDo z+=I8I#(W@pF=BKk%4g8AO#JV;kY{|?IfsffmY69EMjivO3vf&xZw&HSk^y^VbD#?# zBFxCuSsm|9O>?9``nnLOWeL7}i`L7AfVktXTz&(UJMDEl2r)1s{Zi+njQEoMZpwEe z>{rz{EFg|by@cLGuc!-@a*xvo%=qEpg1g5r7Z!z3y5p#irMIR~AV=SU-oP>OsmC0z z@G9F0T3WY)cYQ<0z(ZXeYbkNysA~%&+@$WTgQv?ZWG-^d6fe$$JyABQf!e^6*_9;6 z@PG_~-ZIK~rG-&slp?{XqK%)ati7d36R5C*?HBp>^@L$E-8Hs*1OGs3C%}K9f=NtH z^FU{V+EMg6-tx@PhEkT8W{M=eqKyP|;z8bjCR~jVJJ<_IwglzWIO|pVp!@v5$BH zXQjw)e1KB988j=!v(qai17gUkWk;uQX75d{<&BG@F7rCo#i1A}HQP^PPK68)G%Bzb zimpYPsiGdrGCeB-$<$6_cm~WHu~+NuxpSeeM$<~GlvJI-NR2g4#1hqrflO}6yD85F zcR=6+?1dU-nslRDH$iRwf6@i4$~Mr}5sr%gq2}+t!56$pHxaUo`jEFG2I~e~pQc8$ z_OojoZt3iyLJkd_3aMoy=gUEO2Z!Oo3)1~~yD!@NcF2%H96*VZW`unyxT za0?z4p!c8bp5w6gGf%c; z0cF#3OUZ7a=~=k+-g;C~iP^x%%m&D^_mBXZZ-mi~ox|pa4txQI?+TAP$=kF+$yP{7o2kvmplw+&I$No?sqbrkIe2G5-Y{Pk zNkdPZySbL7L{F5Mv*_8TUUOxSizjT%lTmF zhpsD+CQ=TA0v87ZiS&AY^9l}Ns=Bfe`t$NLvC@55wq49!#nTQYT92JdO1jG^)Vx?$Z3w8=UqOXT%la1cHL}=Y@ZOuLmXupG z6iI_BYG^|kQ)&Rml|T(J=obC zeJU2R5Po5NuRE`J`p&od5TAW9frBPNF@^^SGID=YJfvddvknvQm67(Xi1Kl_(b2E$ z>Hu`lmHYGwSld_KDN%Uf!kE{tMrshsyaFf2x(i$6P`*hfhgB3!a{8)z4=0-_b58FAoWzv)Y$7{;r6E5yZOVasHXc~pmltJM8`SLagr#g*cS5`Ycq zo0Ndgw4%Ot`fIkmE`9Je>0lGsj z%CRdd#m9`9Jrs!ms2=C29c&l(t5cs2Qe*SfKMs6J6=k>4Dv6vyi9ZsqVO z1uXn%+`K7?!*O5}w9{k}F3ELT;W(Z){UsJjbGb3gE;M)namWkN7`r<~qTyN}dQP%k zI-$C`(w9d6PIpTf6S;p$$_7SuUN&C)hGiK!2#94)hoFx^)tR;n%~w^Sm_b zHf@UM%TXNwPi8Vyfu!c8u#>$!9_n>T!jSdso$Lhl3stvcYJI95fqOUJUA74fU^4tv z$eH0m;+!?4C&Ue-AcJ}-Z?h{vbs&(?>$DlECbeJ|U>z^uCt;9O#$ax-Wl>lwUbd!i zQ|RS~jD2yNrC*(f<_JcDk{rTx#DBem9$R{J^?-S46s~DmURZsKo(F! zqtzcOu8?1$3)iblLS}XR2ElgX=8+B1sDh^@vGQt5k;MHT!-0#=JUGV8YM&rfPvc`S zZ`u56iS7JKZDaXtA6fvR;mF2rtp_mwRw|{gE>r0kZWB&(dY)yQGskE!JgHHP)>c}8 zTMaEa0wFPFJi~9nn)s6PbsiJL=Ay9&LKIqpvT6!}xgW<--!SR_>RqO=o!z}^ka%~{ ze9wFHX@~ful8If+LvC%kv?U7o0lOxYoATus42Rb!Cre81Hfnz_W9ICK9V5EBR}<#= z=H1J?emb>oxwhufZ}txeuJ~;23>D3(4Ev=f2))NkXnXM3p)X&uDA`_5>dt*yCkUUX z47hn?qY9tiyn!g2*G>eMxk2~j*XbacG;%R1>blb-`ut)fGHZx*zN!*{8W(TTjW|U^fe7tQLP!eMZ4{jGZNTY zfB=!CjWmdw=5&}UR1yqe9pfEtRs7Dk5oq{SE3@6AvkR2sQs-Ox_5QEIyD!vQ9%4`K zq#_$jr{FwW(?&@*2%S4vq3M1wW`$M(j;dQ?0tF+N=gHeuCT~GpScgU%?BF^4>lG>H z8WESac$MEKm;w1llz`lO8jlg5<=POj;9yPi#@~e3Tz=-3kl)uSST_f>`;BVkErz&~ zBEfcTwrzXhu1HeyyG+!Fs5pJzI`kH9-D(->H9I}ULQ!9+R!}lw%qKBS2fhkZnHS$0 z%Rvac8#Jz<>kA>B;6hrq-jUFbP1SlbWzO59tplf*aMhHU>kKv{6wA(%t2k()XJuXK zo*zw2!zTeKmKx6?Fy9P!=Neg^`uZIs{)VPnQtU6(zGPF?K1)KSd587`L}r$!o^U-^ySL%BAyx9rxrA=Hd|8q>7(OHtNd@dQvwnm{=V&H3V3l z$Wn(3{rr$M>LsUo{rN9f#-bXHO%_}4KMwDH1E`a`8;?-AmlW3cUtjNMr>q2hw|md$U{`v3w=z|K^Ra5*Tl zh1RV-E+orPTD7>-Dfya3!e9p?Ka-Wa`j&R5pUHpWXBJ=zAE_HT*MK5e?Y#?dkk8nZ=!kAGogUD5tf9hS_(FZPxa|e#Dfj4P?t{Hg z&(7UB1{JriO{)NHh;0ACJ?Q>-2_RX?W08Zg-KSounZG?eymnATat}!wuXHkcfKjf7 z3g8)Yl&R86QoJLBp4|y$Itpoi5FmF)^o+DIfyN;INpykdG&MbnTm;?a(q7uMR zYgG)HT15mS4zH9ZGU6Y%KA>H_?vW8sDm9y*+h-CC2p@l5uANF~Iv^Xj$!0ZTqs#=yah>%ZvtyRE&?NKCU5+&~pyZqTDH6XNk8U<& zyh)|*{V`=-v8ZYat1Lr|-LEe~eBM^Cc}Vo1i(AN@x6D`=ntBFXOWjT;Ts6kIc;W%nN3j)& zLM+Nw%r18AGqxT4C09r~mIZ$xy+^lfRx&_W#Q5w4s9;2Z+J9cM$+0R>o;VX-g}s6I zeC2ppg0w7&oqC8183-uqI1piPP1Jt0UfewvGBLnGXx{y2`7hxAP8W#9RC4CmP05dj z0aGP`1Vf8C9F4-ipy3SINj=Pz+VGe(EJJFZ$j(`HCIBU|>TW-(E5g{8id?WK&f=9P zb(?1~1g#XZ)X@8GX&e|sm!rb#$EZl%hXetmuo+dl)_qj7Uns{7)G5rxbUI0vZmr@5 z8M|9W{O#*M=s@FdVX7#!)0-@b*teAt}Y|&U)CKYd4*gJ=e&9bdW z&k8p;%(LLU2y)B;a9&g#(}(^4SNOjz97El>Vsrxk@L!?J&bfqU*hTkYNSj80Y)d2| zb{NY*J|(N+R9|Lx;?x;3R?3J?&uOWDppd;n+;5SXuqD;$NEx8XG;<*QqH|xN$wO^t zds^Pbot5r-#9Az*xb(QdEmn3ItYgL*sg&#}CCzp+qNls(i!(M`j1*k;h=~qCX;ztqoMV!A>g8mOrc;*&<};d&})o{_t0?ABOx(z6&AM$VyW(%tW%O@{+Pp9wUy6 zwZm%JV!BG=+<9B0szaRG0q}H>yxhoKsQiv9(;6PBXt2OPeN3e6OZbrDpRu$B0>f&x zPg%76^Qo6BuN$#TTu|fXK?rLXVcO~uO#vqbiM&H{rbOhCvVQCKU@D?GO-^d1ewfY_ zmPI~)eS>L(*)n<&haR&XRMm#F$1>m|?>ks!j&}lCwQ)`{6=r!5UHBg0K)3a?1 z$#ERk8uHjx?}hC5<3lzmYO_+lSs7Mo+FkW~nI^CZnh1E^z**l^w%;JY^3%Cdv>sXs!le>?ExT&GD-CauIeD9t`B1sgUKaU2hO-PZkR79b%XV`}0I>G$0Lf z(?V%i?ff7FQv&EC6(`Zz1=IFfb?GhU!ecpGq?@IbQZTvq(Ux{MpVWFDA}@BchX{Z( z$Vm&s{pDZ;*q(e8BVqo5{oL?I2a}?VyoW}88EOybE_iX(JE5REtjBO%M+bRV==e6B4`ZcRQg|BP4m&u}(>vAh;_aq_cs{(+ zAr16#Hc#frA-~b+gfi00Y-oLzUQ%a~nHaAYP!cPW0 z2CgT$^cX!ARNH_WlEAYvk9!U|mCiRMMx+l7r#L>Gzo`*vUX&g8EOC_pdyl7=?m`uk z7wc)9yOIz>09`<$zlX{Iq$&}uzUr#-jE?11?yX4yVx@T>ob2Pu2oFh)N6*IecI)B^ zl^s1*)Cs@|rSiNW@?2n9XC)GZ;@~;L4*;N&=)NMdnTDB8WZ66-e@vCzhg#cJ?H24g zqGfuKeSby9&H^*DC^)3s!tgjPkYP#Kte%;V;84jGNubY+?7z6}LLCO;Fh|Q_(DS?t z-ed$_OzvV%9@_$AU^vupLz>daq4?Mh;mYf8?&KYIOz+>ZMH;rIvHbn?|He4sjN z4|r9hU-+~WNv<5Jep-FTp#`l%7BvO8yCfXu>tCV=V7~$CU!fg6zNoWJWN>*-jJ$dG zG!_35h+;2O|HkP-0`1BLhtxrL;pWAr8BRT+cM0$dNj*|RSfG@Oo_qHY_9jaJD& z!yd&?Gs14}v|yM;JvQ3fWal_Z7py(FtC%V}qsQ4^BWJktC-C}D`TxW552w<^xJ6t6 z(W=X&GhVK{GS&PmDa`Dc-EZx9N$7w7;k(Z`dsR#2&Ccrb2ET`dW$R4vArn!$0v&~S z43m$ed?%V&|ce$o|T(`1oCyEQGi;o=%bvtEl}BZ}jU z9jU3gj=>_u;I@O^H@dzSwNTvJ5!CMB0V*IjgY^pGfQ#}n9SKkVqV5Il{e_!I z;@9Fa__7p-FIly`95?N^ooY8rh4)I~!prenH&j?~ZZ3!cHPhp*B30Ge4yw<7=j+x{{>o+an4q@6Dn!R#NF`&UP11t32_Cq9La16kJ>I7 z$#bnap@wN4IHV&u@Rz+)YN9pw>TanaroSWz5Zbarr`hXJc(ThmV)7_aq6o#L5Q}ak)Og?oX^7;hux0JuswaSR$nI&R@T` z8;jGrEQ4~ITe$H?GU{DOQX-1M@^(3CQuEvVPXhTUM`L)S4lvAaFo}NdLG1-{$1ir{ zj9Dn!dg|)Xx19dSWEdfMu_~>@WB?#2>{uB&Bs=D)z|$zi&~~jm`Kjy%KjNqwmn#fE zvm46FS7FNul`827k@$@N9RB!^EszW_%3kTP)pzxgPn_Yq)?PMz5=Iv}FHL1Fg5~rO zz@X6HS;vT@vz5#6*}%E)rhT)APH2JpcM~^l!~9kiAIf=NAx7@wPo#&vGq&`gwXtDZlQgRws9_6Xw;1@YYPh;v%;~X-)MQsy)JL!AMndb ziBN1DM{PtFKs@vVB<4>&5u+FgW4_dx+qD9)EDxxmAh?3%y8+^`IV=?eNs92|B=wyS z$K^Uxi_W}XEoIK)adlhd+g`l-S^KPPl6Mh?_bcmmiTHU~O5o(y<=3!_>S)jq>kszs zO=U5ui1e^;Zy5JD>R7Ii!)xAy^VFyi2Q)j-5K?Ws3*>~|CK-3z%8?#QoB0iS?^{{> z|B~N66j*WFDP2rOn|OAl#KhI2#R}d0R=<+qVVoT4g+bT@c(b@ns=-3@wq$wL1s8pv zNRE9n5&nrB=!QhDaRNA`O(jcOLp=S*@aOrtFf#OEoOxHeahN2x)=P<3v@)!?=;q9# zvrD-N?vb}p{v3-eb$Ax$wlKKio!nhW03(MhgxGJD$9_zbk??$|Z_I=p^~rWhJeC-~uxhVq(G zx>Lp54$JyLB@mhBREz2nT9kE~2w+K$w%R5HEub*4&9$#)wMNzu)-I6?N#=(OB-$x6 z$B86Fy=bZ6J#2;ujU&+DMGX1bp4Q?R`ZT~#fHI%JJ(~0&d%G~e+bkNZY>J0$ARcE)$q)CXdVedbbd$$>Do(k5n0^f$*58X2c=3yB)A#aL*jr* zq(T#y>=|r<8Tt;0>{r@EX_*RH<0Fx)!=3y_&*f{s`F85iWI%cmxCxV7Q?hlS_sch) zy(xKy;Rd;1TKj+qEFC$PRhH8OLjG*ma@S9+AS;6WAwuR45B8JSGI>8fGcW&#vD!c615AdL5B0lOX&xf%O1CLW!$eY~<%26F%&0-7{Zq!PY%#Y@de3Bh)RhJ8Gm zd4C?PBcrq1OX~)ikxX{IfwJa&UvOCJOvSq*_mX<-!&P<*I=B<2meTr=J!<|j^aJ1l{pIYplwYK^n*rf^fT>j>u>;=CY6$0 zG_*B1>WYYC_*FSGR_Rc{V(&q6;rdNaxPqCO8zxwFhfHKGA}a$nmoIXDFb=zcs0||p zP+vvPwYWJ9Wt4I5cR(&pasno=&vYV!bDm4QB%%Y3sf#ijrZad3(G$=E^9OTtN^eTK zl4Iu}H9ce31R)TkE+2eK;Ds*NEvV zwZ~}c5^+;45tU$??s9Z`@IB@6O5K+8yobZAR;3aj3bi?!#XYNf)v&ifqOe0|n|mu}pyRh=Uaas!UG)V!3F>D|c)Do}3)^g|xaBlGWLeOeoXv#hZ3I{oyg z;iqJ!_G}=fS<333l#$NI?RQyqdwPnTaqZHT`ggc7B_TCs9*MfVRTxWA(;a_krM}@JqJAW zQ7+MHx8$S?H=WiP4~|@~O4Yb5bnKE9j0gT^8l<{qr{$WC9&pOveh_}Vp--`LY__IU z=#du%&iZIY9s(Rq^FKk8O48$70ro3M9xi7ezWz?Gf|3h?sDiP(-QyD`NX(HTx@aF^ zbK%{ZlM1A0WHV|%-tMdz=7~MQ%77T&`}^?SKZN{?9eS8cPyN}Bv($&Dtn*kpIV+}i zgR1!2yd@n(&RZ2&G6l7Xy8Y+iOeRVk`lB7;!e^gLxpf4moq;plU`rXybmbgs97v=? zBT?=#5Lm40)hajeP)WjB+fb`Zhp%ru3=y5=m2MT=%5=YJP&WIhM@awhjH4Fy#8I|I z!oBKTK@`ef$-Tm_BP6%kqrXxKp@T6MGbEq@Wj8!cmNdW+f;Lq^n3e8D++rT{Q~m;j z3!=V5Dc<%hIrMj+;Qrmauk>;|74e&X2R@`u75VY-VjK+vrFXgwTF^SQQa=GL9uHe6=5ZO&d2AGqH; zU~+{ZcO!mWLx5e`a+ftOaIvq&ZsJ*P6T77;__yLn@0``r`@oSo~$E=I+Tb8W72v5t5L?ZZ-cy8e-R* zQVaLq!+XR4_fZu9QVYiCgHT15=R|;AETry`Few7*<`hx^WA7P$eCh}UMmCsNphfGV zI1Q!nj1j8*Xa5X{{>ISQJEj;O5~PvO#ZM~nY6q{C^CCbg$_+Y#_X`CgB83X9e&5jA zby0~`g@tW8Fu~_*plab0Ss9Y`Uy1+PZIYlg`Si@;eEuNVZ?tSG9qt3lPxax{vP`qT zd`hEw&?50~^3Ma@1;UjV_w-uWBufvqtB;^GNQkQ-K)iSuS1m%@c-!r>KG>ex#=K{Kq&@~YiFfa6FHB*0aVSrn?%{C_~Zl9#2n+H7=`4(8YOP_ z@#HpDS1mU9U10SB6k(cCcez`P`USNYWYs;tt#bj%EQ=*O#ya8HR4Sw)Tb;rSP%F3e zT~R(1@_|3`juCR(Vf=)XzfJC$wyShBbPpKMQR!}R)?SFMy*2{;bTlfq3|*xw@033K z!Vuvj_ud?jx?y<|`OoMh-HQxd+#86Ij&{ukb%c@~bcKAir3Q_67BNbaodoSqHlhbK zA5~{hetwyhIC^954(NQ@ldURV5$YX2P~}3Yjod5n6Wi(r!-)N*+z>69`$>#X+hhr3$hDFp8y2J*^J{ zn&ARqamZUvO&7tHW6O3`$zhj@x(5RN!7`w8XG3x-nCePcXMB^Sd+s4jGh1HLP-Rzk zpHzZW{sP>$SA5NINIG;ljn1kbPTMlmr6|#64ktvi7B_Zyd06W+UqYu2Wm?-Q8fr)< zbYhEzs5k47UuM85SWwLJFi`~-yx4;f5rwQm{`R192C7oX+JSb*NwVcw{R6iKzL{Dy zTY#wYBtPR}_1ma+F%Zy%cATScHBH4lc=z}iuShou?U$vi zAB8`)BU`)4EH;_r<-=8nGImy^$jgK>9d781K^{?w5ppvDawx%UZI{?IEdaD$7Ro;7 z6b9wN02o_jZ%SQrdW!XRnj_=$ua+7$g~BL#3Gdz z+6^(CnK*s;hrfLNm;C?X_y@&;!BV#jG-Y$!eD)sXiR;w;34KnfwV+LEOuD4T)s$$! z=&N|hN_weo>l-9Ubi9<`q%t{3Df=&f7do%V#2n}axy|e8rq{7#Flz5?iKDhb`<~-!I7__2 z*l<1wNQy)wHP1PXoXo(+cF%7BU0#l%rKB4|!P;6;^M}98h;f|#w|d{d(s&^IgL#aU z#fMxHHVa1CzFYNqKxzYMju;$bzs%KwhSw6k{pcIK+s*B4iuMN+D*97(b8CVOhJ zOHMDzrEMth@pE*w#%j_#CO_Liu;I*X-iS7zl6LsZOig_K3_3}tC&ElQ!4~^CQ1oNDIM`eOB3IY2V87s_5i^Ot+@rOIQmyeVM z#PVN`h-)2zy_AK76|`BAC8+qby4At=2uKRJ1~7O;rNfxkEr%Rnl~Z!D_o^)tLw7yY z?1nDIP?_E+0obdj=b@aCyuIlznhtP;P#msYvq}*cXoeJ^yPO}1f%yk&&Fu`3)F&-} z{En#rc*luC+3uEBng%*5B=co{ZOP*F&|DrkMY%B>Nt%$pNU_Q;Ww_Zrr-MX!^{CJ! zrm8Ch2km!~+LTSN+8UK%N-of0vuZ$73`y%Hw`N0%v~JLVNC!V?0;gG0$@VnXIH=rx znN!huT_<@d-epl}!jeObj!7U%Oj~W45V+z`-+Bn8iPRvp(-a=c8%OdF}_1C1#P(!gYyvZ@5 zJLCtTHQIT{C%rtNlh!GDo%m0=VRhg1eI$emVR|h<{y9`erGcx|T4;4QxQGI(?dV;V zb5vjS>v{n;iaNDkQ=k#=XbkY;rBv^9DxprL9n76_Qz*Y6C|suZgX=Dt#Sq$hY!?FY z!q~rR>sfkX!!0+|+YGgM*d6<3olRV(&RD2!k9c{WS{&Hj6X~i8WHw*8& zd~2Z_LIL+$8E3u|0VLT^H|2c3*ynHPHMt^9&T>=>)S+FbJj9icc!^IAE00<@$fpBP zin?WskLk44+{O&jSwu9_^@oz~AQVV5_RLZ`L?Q-XCyWk1Iw zaYDKOjC|^dNH@8zhMd?r!>(o@fNJhR#fDbL_7%~mk!EfSaB^%9WV@r1HsAPupwY57 zn$|!tGTG6PawPd1?ilFT(d}F$Kk|>Rt~K+aK_9!djGDk@FY~S*_BhtL!4)+);%sv@ zCs|o|K*p1niJU&OR}H~D13yf zfLvo@C8%@qix;8Y*!9q#nHU!!^C{&pO^(khDF)4$2r-kw0>GTL29(E6Y(#ooJhxQU z)^@wZ4|&)YC$&MJJVsyn&K5|Wq1n~j?&}$c`ub>2lG7UUAtf}=H2aY)zXNPN3@RE4 zai-w4sLnL6=|C!1-2%jFf@{aHGntd59D5w%;anGF&2$0E7Vks{L11Pp-hIe-v=`w> z$PvuLUM;usQAkQivR(e8AK3s{s-Hjn_xuCaK;nNLTxdp*oqOAi;Vc33P{%9R*`7@g zzPiHVCE0NhisGiA(dAmet4gdRuDaI2L|2p9`@j+4^W-(&91aq$Pp0ux;I7sZ#)V5)BMBQEU zF2jSx89>qxW6&#ZU;45v&B0V~EiEND7&)5gGl=X=pttT^k7KW@jedzq4gS}!zhb+h z{5~B2V24rSk2_MR^o|KvZYe^A)GkGsq7jM@ExP&C>-}!U*Tapbq=c@oCEMsS{k9Hg z!^DB?Y;21zj=b?{fjf}vHk(c0nJ2|=LgEL3^WE@oGGwIkmWv%0WE`Q4=D z@;^OI?WhmpSZBYZQ|LQemdX1B5Atgk$+>CmG*4PL6|IK`RuU_4yhQ_alo*q@*hqtL zmTGx(Xc1zdTC}o$t#!B|E>s5sMKphiB-!vWlW53BGU^sWLs0)+)jG(8`O%M+>kL(j z!S|HCaq7qikN|SYO>C;~!d_@{JCP=x6)4OS4aSK9H7z7 zR2N_v+*-|P`9qLzKJkz~PO?78(E$>$Qx{}IOLlqW>n~GP`M6GAYi2ceWQt#}!O8x6 ze<_nSG`e61%o)>=uP90}s2?A&Dzfcd1^?=bHA6zhJh6IKja^$lps-x%14ixYu)VVf z=nY-@;n4rbEs_QnQ|JyWe(Hcm`kcJirA67o@*S-eo_9F`7zRL{wmWvgzNXi`{D!|C z{x!U2rz?fQil}i)KqK)LF`8+u5o?j0n3vgi#8Kj1CmuyuNSS!eWjAQ@>wOr*faUgmRnX6%B_;P z6Hc)=AVv}uBcumJpG0ad*A^6RST)~g~8j{U`VU;Xelt z$s)LUMTW;@k|Gs>fLQ2GnFO=*fsdFV`(DiX(lxY?Q+20M04!CY&`PhltOKK!fBDe| z;YrmgXp>p3r-K?9+@%6~`T6T$U2ely$f-`ftZn5P_)|O_>{|OBO;R;F$Sq|8O6L(= zMa-e!TuBgi(?H09>0I}O_N5UD9DD<+P8_Ukebr0GXRdX zPSjPYZTCcJ-?mu0$o6Ogl&i8WxTDZ&OvCTCsRo2cuie)NxpWY-h7gZk@=%!v1g2H3 z`9;d&to-jG8I)+dt|Y6G+)(>oP!@ScLV!{qykhkh`4|%<1V9OO=#;la&iWVnq!m(g z)-cnxm@r?ymg}bXk_$ekZnF#o&c#|F5jgMspxl~PHA`TmI?e4=SphNL52O+wb+j&K zuE&@Yse2bX%V6c`VuY9f{s|oiyFy9U|AmEhkZZl~&^q}JaKu#^RD%wjcL%TFa{d-6Vbv#jmPIi-ReH&z$1S%;$8D%>k^Fwvu<$w< zDhG!iqL}riY%lG)^A)BTEQH{iP5oHRtDQyDII>a&Ze1ah&C!bz;GUsM zj}hynrW*%)t84I%iW^DWP4X1M(mWK^!@y0J_PJH*(ERpbD#ME^LLf;B*sEw z$$-cWo(6pe&p8#;yrC#gHU;Db9gUma-Iqn>S!xK`_vW&-W}e<+xtt1yIO42I_ik$+ z({ArsGLrr=yID^*m6c$$>2j9NM-6dAxePhif50MZ&)sx(;*c4yDf37uJo`%=^KVVX zJF&r$yt;^s>QLmj=fl|*5Fr;omW&O7?n<2Bxd|hyPfgpP>FiB4Hv?U53+&-KTE%vg zTZ*c?#5Ai|*bJfg48J`hvi`fGMB47uLC!sa7W#2`{ZL1L+5|Y*(!Lx%=!itlM(>5|8=I#i%V8{5)22e^ z?3tR3fLjNz_CXn&T;Xe&ISK1E;MjRNWL5z3NSeWx9RialoXB|h%21?Nm~V8=r1X~? zpC_SUa8nV~@Qu1fWT2duPiPJ}O&s_^3 z)?ZSmny5`Nwn8?_YvqFJH__F|IOS7JN0)9T>_}<>S)ArTjXEzjMa=JU0vpMm(ZLV} zTICP!`F+eD6;thDrbpYRK0*Bdgc1{#i(ISetj=_~3{pp;tRE(2MqxkJeI{?YFcoPS zo4PH_F7cLn>bwfIt`JKt>!;S!`FuphegFE|TZz3!aqK3tNExO@5<(ycVVA6g**hxu z)fc&;|B@uO#xSCW0VT<&WETk=O63!6*AHAqMUXRp5vC|1tJv zOR^+Ymgu{Gg;LUTfs!hCr$vhXk6V3HY)~7*Z8|o%hljM3+@kses@`tDH6+QDKtclv zl|UjAC-T2~udRD+wL^D{TuLfW#5ob}=4Pr}_pk=XISyb4up_X5d7IV-q%GyB^F`6W z$nCbN$#Nk9Z{v{RW>6`DJZwaMYEO0h zU;^P*VBa;tONq)&w5hT4-)eB3PTJdYiji*TU?X4+OV7*30!t2dAI!+n#kxT5lSEY= z>FPw#);l;Q-nyJoulr_9QrzRAs6Sh*uEn9?ug~P5z@V_GJbc*_EW^7CXr(q;glaz) zAk_vA1_1f1n|dW$3r<)83w629^%@UEszCj!y}%OX|%?J4>jVU&@_-56%Gfe6({YnK1y^=GK7 z4i&(_`>e3^7&6$U1snl=NwAx)rxyF?R5-$z8Y|kBq){cM_sL)3dCECatK2YDFC=Es zaH&uYeY3IxXV(#DvMDV1Cjs5m=I5!_dcv!@6ahaySY{TCq8hl7*hM& zD|BGEF9Cjq;LcfRaDf_tscvJ$R-A^EbLPw-!6DfSw&0q(Wzfui*d~KeD+g_HEa5G* zZD&<{J?7C}u>~^erXwW#5ypwJdr?i64bo20k4I?bf@+)di_V4nz_5!3f4UV&AvA+X z&L>+XfoySnm84{zLV(ypqHe8;C+mdDj*VGPOViYxcz$SKZa5S3fP!73FJdWejq`Yf zXCJipY74@cT&ruC>EIcVSB1e8KAZRB3aL*{NRk(1nV-`Zz4>wjKw7cqd7HORdTDvF(13ChB@r@lSb zEOD$d_4H%gAK8^TjtJNcTGym%e&r3&*+{8yuXzWqO;$JnP_1N9_Uw{byS2FUoFNT6 zPSl6)2(EiOflbf#D*p?SsxY2xZHnZ{*x+UDabC~Up4(zl8GZ5B`u+YFwnyXmp=-uc zfE}yMCQF;&|NQMouYY*|DJs5{_wGf1*QDxnRWmv(n`SIhV@#Eq5`3*~s zbSsqiob4&>!#?k-nZ)AhF{;vkrSRA35?>+`LZ1dt=aXo2(uXQAr0^c0#5j07zsK+x zVHf1*11BluxhPZG@;<1~_Nnk#D62F}g{|sjB{eSEEO+q|w(gxDB5fZNxv8i)E#( z+>ckiLO7B@w(Qbc*FxP+y+y0a+n!hy;YH=-Nj8*&4eeJx`vwTV500b(Vk4Ymeaa^3 zr?wCz-`~36eU2&IA|*xR2OhUiQXch{{H_1nYN-8Oo`q^jdFL3C-Xjx!mKYK=ZDF9sO784 zAL1C7%X(xL<=V-M6Be9yArOZKLbsaL8$f{{9nNc9<^$Z_v3>@-D{8ky?p3??<3@b* zq>dxWDdseX{L`yxE&s_HG=DN(a}X}cUU=r*KlMpi6V}B;l3YE_5Gj1pwYflj1@N3f zUT5MD8-rkUE^8)b+5l6@CzK{|b+->agPqZ?#Yto9Z^GZWFXeC1;`$Lq(+Z4@P|ZjH z0XvELDsZq_J_}qI6;4G8X3w_*0qrcV2Q-;_1s6UnmApgeCv)h|m zEXk9zU$fk#{N1V&nLHD?jL@s}vW!}p;5_l@gM#KnNvfH2o3(%8v~aE+ZBgOPtIXv7 zR``07jF-s%;%LKDFB-y;EHVJsNk6QUMQVe=9A|Y8vAVd0tbes2H8_#$x)}sui@(Wa zmz(FuZ(oM5{uzC%gVWemYF+^4_oE_fOovuVH`!f126Mue$Gurt;}ADHsTY#`S4dTo zzvg~wCk5N>s!0*e(0J1tkgV6lM@hd74|ll*7XTl!Yk(G9ql*UsvPno+i5rG0xOaE# zh{j9S4QaTC@$NR}TYS*qZ5r4%0*Gkjkvj)qMM#>I^x%RA8lD?4TXFS|X z#~CU3LGHpSPNMVABdHsnGDZmz86e zhse@9HvwHWYb?NN?d?Y=3pRcuK^;wUgUx+6{9TTfKZSaWc?za2GA0x}C51=i{d;rJ zGV(z)3Fw5%y}uM^O%Z4=dR5*IxpgPUwB+$>41JZa!JkS zG`V^lk&B%ZSadLNJ3;lhYiEd+&UBYD%BBIcN-0}yeUhHrRLkQb`=SNj&35_qtYJ97 zB9zc0O%!`6&@4wRQTW*Km8Kqr`hD71i#B|C>WVRrmjtB%kt%u@ZrdFd4x!09i$Vh1 z(hM%uUF#SvK8GaGrE$yYCqqCWu_Or5zq@ro9`yyj!s7s!WBp=?bx8W|Gd4WTW5NV+-C$4asCUT;=abrQF1M2Y^let;_xeV%UbYS82!!!agOcd?hX3iox3+JCisL66|%1M6@=aN zn|eT43e>CWVFiyw76&4=qp4;?-ha zfe{2lvx^>E5is^`Hmik;gg&fQso#Fc$rfjHZIH9C+gXtS$EZu*PEj34f#jIx)V1KQ zLLQE07j`Yh>LhF*Ne24LhtkE8P^0#6ag};*1FXHu_2hd$4Jmaz3k#hb!0d0n8NT%` zi|l=S=HkjaFVx#4#e-TE40MK)lc7;fah2YA5H(A)c@Fp{m=$z|n@5p&q;qN_gyG^_ zuCBF#x#!}UF)E)axiiv+N7G(f#Uuo@9k=ReEjJGC!E#psQnF93z3hj5=#vm0Fe|q> z+*k}K&r{*rX_PG)<(Bog)?RJgK?hKj0Iht(0@S ziam1=R|Mv|a8a6_VDLq%21u<|2N0UUpy4SYfdA!oDFCxZ9nJf$1+}dd6y}}FX~{Y? zPl+Z$mB6e7C))6IHg2_n=+ePc#4UvX*7EUDEmHeQN1CYo=^F-xI~!rDF^-}%Z7KZM zV5r?XlIm9zV@o4I(!xro`rI;1WY@+b{LLYGZ30!^DpnA#`;t_u86lB+dlwpRso>C? zVoV>oUu&-cu=P)_&NeV7IBCa}O!fHOScum(L$DRHmmHPI5f7IyP|v73pq;g4!MM@h zZ6l2m)9%eSWy)xuB=Gl&WiOb0>ul**lhUy)U`7&^HMhw6yt})s8l58q0CE4!t!$m6 zBxSetHQ|A^p?3h2K#P-{=iye+906dPns*AbR6;k#(9tf_9T3%@%0Bu($o~TVBl!rc zAz8G_M)ssgO3FbBQ(LlNOx7FbzidC;k$nMTYRev86wrXgbhK0tfIe%SL56`QIFeou zvmQFOw=;`TY8>m@YF?^Ma63xwlhU`-bMM?Tp`t*u^5|?BfF?GWZV#7Kogj{uRhDSq zE~^o&IM+AP8FC`kQ+JLnd9=^yEV#8tRz-PO9dMg_sp7NgBJ5F(Cb)#NrbBrBQYX%t zTAa2CvmO;9wtsmF?ZwEB324Kf3IsI)qO;qO?9bSfc*%&~YwE|svcfju14#HD(Wlka zX@$lswAN?JxfIKySz}8W`|85ImZtphLnyDR(^!Vyx@d%Ach)S|A@QJkFaP)5rU2t1?0L!B*Skn3t79K&2d_yrvC(?APDv8x%iFgu?LY?l5wfl^i{J zPOEK$V_JG~_(KgWC_f3We?YQ^0l#a0rYLc^yH)E}mM}7}uJm_SGckLvwM%`Y2Q(lu zx@->>%$qEvlB{8e^9@A&%+KMcufH?^p`7P)hA1@su%D&#p{zwo+fgzyV&c(qf(qKE zc87Ye+rtmo@B}LYpfD9>rioViH)Y8CkaR3+@0PYJ=ERl6!p%N^cUYj6I$?$J$OhGsi>+wiWyeS&EDnm^1p;BWz%g~CQXl5MJ2e(a?^*NN&wbLs8cuP$XI#ZP@n!i|PmQ0YcmOJVX!%FINY;Hwk|7MA5R$PLX{-FL^# zn7VjEcvnJ|d{!G|(1x&^Q%4=2OTmoj8sD7alUj&l)nKSX7Y!H`Vs=;XBed`fYP`ig z53aA4`nr3O5gXixRJ%V+hI;0a72U;SwzXR=m ziy+MZ3iU>Z4V)TlegM1Gk5mp|iL!k(^;egI1BzE}Et{+FY~_thD~n>W7eS71>m78y z7r2D018{o$_$(!+3QX8gveJIQAt|=CvdWe#jh|%M;QIT3$Z9D`YO?Qf@t93TP_mOJ z3WjWesRJes)gddg`^8_Q`gts{Mc5q$x=Pq^*(O*DQs43#_DKblm<2E3uFXl%AF`?K zWtj{Lgy@tM#l3y44WnaIktNremDm!^-!gsQ&DL!`kySqC1(PEPJh?JJy4t4%7BaIi0pHe5~Wiu#XO zsFOukQ{4frD}U!CJ@pqATA~o7543@kYGff#a?nPVY_ZicjG-wUb}q*li#+gIgj%cxJqFWBAB7GF_GQdC~%3cF!DttVr&8@;IHH>!Oc+>6l&WfsB?Mh zjO|VkfG`#1LqPxYY2&qkD9WhQC0l+o4ZEtdduCZ^Hy+2oEk-cR(x)jTQfFPH@z{C@ z@##0Q*wnrL@}Ogm3hKBAhHHsy^ad;{wL?~ zNiiM)BxhG09oTt>!5BwG!%!&u&t>n9HhcCyd^(~d4O_|wQ1g>q%1qjgZSN#iy7E-% zGeETW*=W2ecGG(;IJ9|s#!wCBTfb)wQ3p|^rd&8Vc!HZsXb|QFKC6H}LSm6z;{y^O z)|@!pcnZnwoxL02B$OY)Ga%emsWuC4f-WAi@(eaJhm@r~&*>4C8Ym4px@@k9yf8j4 z?}pmt(kkdSWYLi()Ev2IU=`4~;q5mTIIPlKR2Lf(R4&<5L$99vqjmwqr-LEaP8V9%mS}N5VX1B^ zqKAB&5Dn$z;jJnD&)vudF+-b%@t z;9D^{Ctz|lZ|F2UAdGsm1p~>4)(L% zl{8ATLy)x<+$bdmbUAtF+4|{5<6evPl zD{l*LW%)~@%~r>f99!(T(y zQ|Seso2^fXT&L^CD9!xBRa4p8V0WTEYoIaQFF0{6|47p1mln1sXx2z5dd%EiH(@GzP=O#@Pu~MNYW}nwxIjk67P^GU)b=0QLcNeYd#1)V79H* zmCeo+l?;?K^XyEy zsA{0hz(bf5o&g+GsqzVrVhb)k2ejIFVz>fR4lN*d0w7)N)l?bR)(^e+|NZrc;qBio zGW3{%drM5tcsbfs^jD%M3mBN5V3MALdE@~g*(}Sb{ZOdUG0bTquyuG4lEPn9)?w0) zkYi?7#WPP)5iPv5dn~}mRlb5nb&th^oG`?LfR<}By#~!H)w*(I3Y$as^zS5J1S|@Q7DN;|J6UA)oC8Z^`H~S3pLyO z+;U9*C0@cNgt8COF?-}ly|_9grUE3VrTPN}I3&&5C@{Q3coJE}15O$#qgj- z-Za+2bB>Y+juiip9!DtMsm}356-F<0Wq~h&UTx^T2Z}jvdmfm7EBsSh?xpqRN1$=7 zC88G5D99wB!7`>e!Sv+`j*mRJL6Ke}(0`>jWcB_8uGjwiA5k@54tQsZK*$BJ%rCda`Ci z{e)S-DgnydMd}B|Vfad%CP#hWvolVr=!@I{QeE3DoRGTVkIT@Ow3%*U`sB=o6%_h{ zpdr29VZQ2j=dbsma(=0wcSCYIUI{NoSeumIhkBv~B7Y&_Jl!7=TJEc6$4XsmCt zMb?6&0X1R1yP0b;;yRMw?4`de80WoK>mX1zY%QuD%PH*o^3gt@Xl85PO2E^RD12yzyiMc^r&Sxet41NFKg1n>T z3Izm1m=bJ3H91$jZ_fHJ96|_ro#zfjeA&j1_z3lGV_ZRNk;$860p*+f2Ez~liP(-e-3e)NW z=(yz0QYy>2B;Bq7042(EV<5}vi-yCzhA@HX9G``Wc8PRC7MF_bpHL<*!Iiv|v~EWR z#UUrDVvOuGug}_k65CXuo}zPw>Xh25qJa1`Kj+rR)6CkaR|N$7HDhwfx~fks@3=c= zDv2_Ue6aTpehlC~c&kaXkn7Cc57odBwRn9=uy?@ANgcMFfkGXUE?@Jwd5n9UjW%It z_haAy4!{KnukC1cCH?&@!G#W{!3Aal)wGvv`G*wXGo^K@h^Gc~k4V8NNzvsp*WBoO zc$ehX&wA3PiyR$5hVo&!tmn)qWp@n5y~8e)J0XV=P;xlSY|`tQiFfF&oN!<*+Qm|c z+XCH@Z!`_47k1zjA*zuSG)Y?Jc4M3_+l#G7%Q7%`qq0;|UU~go$K~){r)F5`0y~lp zou+S<7VP@vbI@n|%$72kHuTz>kKB6 zEE%>%;++G=BsFN1TxkmqMTc4nCeH=eR+e>GTxu3>6^6fd>)qdEnc{)Jrgl{O- z9d3P-J~M!`VJjY|`B{cQVX_K!;b4bZuLY?jh?vd~D*3!V79!jsHB7_x?-zjnPi_PXsNE9Qoi6ao1VCW!PK

MmcrSAt1=dxs^0NPn3)$^cQvvQS(EUa{e-?IM!u0w4r ziGxQ?2CwIks@Ft(1p}EB_1lk1KWmgj1&O@+2SB zKHQco$38o6_iOcmG8j!@KS_@meaLF?S9Fo>565B%dHUfm$g8{K6O{`+dJW z6#)ND%8ZyIL|`JpJowaXo}A6*+E5y>vzb8VG^`MDk!*qmASwVNlv z515=6tG*<XH!USOY-|FmZuaOXJ{@-W_L$$pfds2sHW(+_ z2O;Y^u7kgH(Nb@&?FR?@?)#Ia9w%~ z7^N<(Yfch^`DZQzAO?IkLtnC;r+(!vp6t%?vGV5&y;(cp5efZ8mvzj?p*daAcwV-o zy;7d7qtgW-)2jKlB3WElfX=U2+727p;#rSoiqMywFW<1fY_+;uxq5$}4$sekZpJiO zmaYnT^rgPn<=U^;tS%yj+l(>bz0fnZs828P#oL$UuYGAp`#Zb;t1>Zdrdrs+fhSg4 z2zi1FfcfSvJllW?k-`r=9Hb-Z19obdAWQbz0pGgqN)PZeiIzPW=NJr8j_In)A3@t6 z=?LOzxSH=Jy!KAL-A1yT?dYj}zaD7mAz6EXpu#@q26WGK(IJ&2o{reIR=HfxGkQWG zC@x*k!2`PzCZaWk&Zb{cAy35YZCd8jV53kU?VZ9*weFXzDt%p^!0#P;OM#)Yu(Bu`W-lV$GZ2=}L zm#c%eC3zo{xe!qw+n!QL3sYB2F)mj?buDE=YsN&U0hI^7#5OjBqZ@DhOdoO^v<$fQ zrLCmD&w$$*uq#x3Yd`2F;T}N`D{X}r%p9Q+bhDWr=Il!!=_Arh2w3Rv(e&=msII5` zX@URx_0LIr_cIuvzy0vkrzQdBV>^EoW@IM>`rZ$z-c-tCa~xQCTxKlY`7)^8ZbR5I zAo|&kaY;_ukgukMPP!P#Qrj02zvP3nt-2j0`pP8#w92&0;K5?&*zJyPkG$`~!h+K* z;83hkgs0ia;y0?m6-Q4gt`)!HFn%1Ee z@Y^ay9uC*q>S)0Y2qB`L1rR#ls19(2CwwOq2`}3+Idq=Cy`0fN(E{4tF_ghdlE@)*@Sa!IM@3>fISFu-hGH$87-|1PzjGy)(?4 z58UhaWL>*_z!x8`4{y&RHMR9Jt9B;(mwAFO$KvIkiYHh)y!1-u((oiPlW+L$bBAd<4f!uF~(QeT_ncrsaL=vl;%kz z*x+}vc`hX@=$*aJprj1z`OP48cdW{kgW?J17LzNHM`W19#%P1`8DRjda}1!m)1Hw) zv7?r8cTz0KZ9mH)bO~i5QB^YIu`mNT!sxL9cnx*L!;HL1;Q!nDP^L4~;o&n+upn@h z?Lkyyi|2*bp1O{zgya-_@ciVOzpai_U@c#`hE7+pV|4*V6<$Ld|#*gv}tq|%CBoCms&jY{UpZ55A&sB!r+nHZ|55q0B z+v9>s`RiBz!au`b{{{clpMKz^mdJu42Bo_8_vrHka+I875`9&2nW)QU*7KZpF*>Ht zC>;Gsh)O-I`!R3eh^=h2)6a8P4V(on(}c!;{Up48p;;c}Qu|#h?`Uo<7QC)%^QFcH zs#Z+giME>oPn!qYfxrLN+h4-lZ_yZ-ur}>{l#K9^4M2CKoR14EO{CU7>pZt77z>f& zzdQx+X&48^+k@t zf(~d_j2E!jVFyJ)shT)gnQ_m5Ms>7Fs_CG3Z@W+#5eo;sk0_;524ZOE0*BbITDs)s5@0Ur7rzt!bGmInS)jhj z>h{`$lwi;_&Xkg3%fMeBzx@y=&c|<`sHo8dN7q62?)fD66@g|-5oS4$*^!+)SK2Fp z*#uME^e#aaj3{9Awea`pdG%Rw-kjj9gy_Lk*En;W1cM&QQy_s(e@FD`?<_EY-9~Pe zi||!YiFWxNpU-t{3^htI_pWts$je`ZEH z39A&cFZ&Y%3b{4k5p!~iJT3g)7KOyYbQ|oWD98F`eVmZFYaGu7_KgF~5#2W{HmacX zB)hf=T@b350;3BCxv>(O;saKK4ht?)BPS}S{XX80w8jDXC|EKr=UCL-1Fw0ocpIMq ziS))@NiM_Do_vIH`Y#uiKC@IiI$@)oF=wl0O7(-mV{%5=`)YnZ=F5Ue{-$Fr*&y|i zrDit>oQJEt4!eI4{fPD9P4R1Z=u8l&tk3*Ed%1_$WULd2UmS1{o_?@N5Zqt@=*hXsmbpYm?2l!daEi-ib(dkb2?392SNwkyE^4%l}y1VbqsD3|`YFF8!jjM5SdIoT+03V^juXo0RIb^h~-1fSDnR{d} zyuO(%8%TXyc?1aEYLO3YW_Pz(Ag8>!>7v=I_*>7c5=JUn#u{o;Lm}z%x}B|0Fp@)zq0q!J$QBv~ zblA~NRfHfBLuy{76=haA&HXv1Q78#9&rtD&ieX#j>z#KDha#GvK&5HDK*8P)D6C|f zOG+}@*uw#QcvZ@wwSV>RUjhMMRE~o5JXX-gD9>S;G5a^}BTEhMSqOfE9^AaP0J}@D z=jMJW&P<*;m?o}&dJrijfq)=T!%i#c-02E;SEIolF}MgkKMU*yi3J^P7&~t#pYdT= z*)1C_l;&0a6DE>c8WnRGod62p-~}pl8>}|=_>2P`CVEsw2#VURl*L{%ELqodi+bc! z5y@o4KBG6_pKXa)2P-P-z~bah4dc_tjGBigS~BYoDId&55T0p=?DETh;`|#x2cLKU zN`9hE%21ArS)C20_5e1Vp7k>zDS|#3`r~PqstA4ujgMiJ|D_G8wA#R%hweo$D+;># zzBOkmZ31FMmJnvM*@YAGaCe4x;8H3sFSK4Dj1ZI62?_J}@UT(KmP@Or`4QwMz~Uo^ z>ic7Y%}S6xu-IarSR7xW#VPw22Fh-hL{REhJZn8TsVE2gZ7r6(EfjT!agvFgYn%ft zlt>z=St{2PnjO&{E=S&SeR;v=m#5{oqL+j)EnFxQ0X1Qe(omQj-^3L?A{3zBzEfCw zg5ZT0?$`K1iyqlKl~UxKD;_8JG#19Uq@wICNG&b3P-wBn<ru zl2QG?fv5V<7JZ!A7ok+D-mDw!((P?hAL}>hNu%h+g--O2s(`t!hJJMJSoDNEHw_tV{nQ*h-L^`lmAuih%@3NOOYm?is{Pet)=odiKynt(m9wq^ z)wZ~U(S3TjLj*c}tuJXLV|#}R^T)EN42Pq58>u#i#M^df0@X(MyriU>!tICyo4_OF zS6~=g&@6L_UQSJ=B&Y+7aT?|+;l_W%Oy_B)bS3%`E3G&xig;Hm{H!!<`p}LPH0W}(rtobF!Wjkr)QWvzy9FR+6s^`` z0s*|B-tLNtZFJ+3G~sIsJBZEK#OnL+Qq%k1*K+IaB~XPXe+mp6IMI>A-ga3Jpb$Ai zMeT093n5=xK6}eeClNQOP)hc+L^51fAHG8-+h%^j_;~6HE?EIwF{&%Ht%htejXtBK z(w+_K&{icNR98MiQnSzSZo~&0OHzo$#EN3>6R$dj_7i!|-n56LO)Xa|>c<0inm%&R!!dfd7MP123XhQFNw!jeB3@1K zYF2tl?T4^i(9zOGLf2sM&mKqc9Rq5$Ng&ySakHmoQsaG)1P5@KAobIx!)=5(7 zwLJ!}*}0LkP9>tIlogn$lOCViuq_LIeC-fQs)Bad4s^NY5Wu^_!5Meo9@%~i&+qK4 zDPRL@ebm$i(Eo<>H};(2c;OpuJln8>30lXJ2b@8YZN>mtjGR0755q4ue1xK!ZFD)u z4Dial39RtVHXWR9`^0=p8El5e)O2Zlq-G0V3)CPeHCUQl!TbPcA-yb$bdSs=-g=uZ zD4}EO=G3=&{eF1+5~z182i5t@q9gPWOClmrMROhuVpu6hX;LzJBov3?K*H|QrmDD> z0PhQNM+(mc?pF0zdU(_%5`WEQta>hab2)6QoonR@@O6e*AT3geD+WLuo?bK63`RO6 zCaQ{+RzIO)QAr4)B1F8;U#lq-u|0eRV0@&;?Y9n%TEdTjmUM~eMV%+`2-5<-yOK8N zzAH>bJy6^f_c6^kLUdpgikf*=(5OiYSVaIZ7bHxww&m7G9IxcQ+{{8@N`8!yx3mh4 z?}0Dgew_Xr&flb{mGBj8=YTltOBF+Is^`jAt(sS#y`1eL{@%*79Wv<J^Yl9Uz|5bgk^=NV>HpQ8z&P|4w~AfG&Chcg!|oSqZ(3MTi?`J9wC&;wM-SO^6h zB%!OWBO3&+XBqL|zJ5k~na^x_%BcmW`p~eGr-rx~*X~(FTJgKqTOKqY0k(O9=S=T~ z@05mNNqnF>tk(vKHlV`O&3U{a1oET3J7TWdT8-hbX&O#KM4ft4+qR!iBO{y$rDVsd zx@BnP|0AR!>3LsFAG9DhJSXl4rfo0Jzou4<@}guTfX(3tlH@47#{GonhY1I{ z^Hlw5`aGYC568it$hHd<0Sac6BSwowWDG7D=8C#FX=N>}uokre-W?%DscxVVjZg7d zX6T1dGOb?*MS0qrcMpt33QS;14u`;n+idr#K1^XN`ID8T@mHy59@DEbHs(UHJ zx`Z_O{VKY79XJ(*;R&-%o_~`*hR!H{W+%%K2mrzve-dBhbaN>RG#274<|<;GhCa()Ia(m~PpX04HVjTNG9{HA8QNKb#de9~jJ8 z(|>ZnLj&!m;WXktviNNpH*WdNkDIKm+hWfRvpr;J=~?tIFX+rr$$5oZu6=M&8=43( zMeQf$UJfdg;ivp2kKgttA_>=H+h?kzS6=S3hWgUfB}FbS%%vI$yoUHswS3o z4hmHlgaTj5#3qoDph9?(gLHj~YR^)a4Q+)gk3I;`e|`?n&(HkDEZjY>CoWM^8?n!_ zw#dgSPU>n90G&Ut#6P$Gg9Q8)!;WG#o+xIwHV}dAQ(lxutCGyL;?Rw?=bqwb9oD%z zRCetoT-{m0i$GNzq$N`&@#=d&a*nEn3Fa@MK4{}pXwnA>R2ZG7pLf;hUGbGtM}aZn zLPex=5l(ICsTZ@}_Nh=oTu(r~&p9E)-KynR42B~&pqp4F*gIaSoq`F%3d>EG)q%s%L23FXx+*US;2Yzqd2gqaF1-H9 z9v9N;z2DkmO{e-lnIlcI$0m0S**`K$#f0QTmt2=hu`cLUTiKXZ^wF4$IVKC>RS&$s$ z>paLl?qdJpbN)iHYHMHR>ClE#J1dj#^2y;vv&vc+@>IJgolCs~YcOJQvz`xzbV- zGZxPo!G<6gS~_mdiQuBJujypH_uKIH>E->WP%~EqLp1deG%hy6ZU3EcThk&#Xpnjj zgdmg1wt5eC5P_kvr}}byt_BF>k^B|L9`mKW1Ejr|j~TDH;e=e?l}%_haj{O0O@oE{ z&usnTQTy=6GZ4trN^!=mse%4%k5~ZgZX}X$Qhia^RZBdS99#2%c92K~%RjsVL$rEt zS$H>9B_0n>z(fetaX_e*#jg!@gk^$q%cGGRVTRzHZP@oelC19a=M;hc#N>nzXi2Lu zKwo*qvwHg)M#tpaVN=+26~y~FTTITtDbT=8*@+62o7&4tDQ!3ixa{)HwyiCwF;KF1 zU%e-YdmOxJaO=1JtbD4?j?oUzQd{vrJIx->Aw8ZFp8e43XQtGnYBO6V>I#~8I__%u z&eno<$GrWnf_0#p#2bOQs>Cy*#W@c(O59n3Rd*n7(N3cR;w8@6aVUFX^L~ybjl(JT z?_5i(fl?kEf-OuzcyVVC(LF&dqWlaLh&lW$`Z~40(t`y)NYynRwAIZS#4qa=x3Ez( zi`_<~CVhooSDm3{#nf7IwJ3A(Nhugm$m}6kok2Wu)aq=86#NPdGTDj+xuN%P5UvC9 zXIZ$lA1CT;;{a;7MUDx{(TDod!YtuKf*BdXClM-%Jb{D^IwAK7w{GCg?=sO=H7P2~EHllbEoG?@Lu3}$b$%Eg1( z5-&QuLowepNlpbv+q_6hbI@$;!Bf1PCA@^ExtoZrxEH<0-hPxLFl2iTq0K1~An|VD zCE}vIjHh-RhKjNvV+>C&OoyKL?vpX}0PB1c|3o^;(x2FPvQ^Use?9z1TT${r6%@q& zz@at;W6~m4aG?95Ny4*Gq7c6bL${cDswg!IbrXRt?pUhn8j=+n8a!qzYL-k;>au{) zvKiJv9qH5CcnLT)`pJvt}dwuM4nOkv{y|0q3N zZ?d)O;gp_F4|keI9v4qlq_gqnpZ5_C=mAAQeY^oH+o0=}5=gjxj|SG7dfh+BO&$LR zK;3jNGBvruGO@-ns=|)gsLqX0js;C9RH^ofy;8o<;YE?Le@SIRW)-;lMR+<;Zq+#) zIfMo3Q?@rxc}cStD#gQGYDAw(C9f?Y0+Nhh0k#haGU%7{4s zPN;s?Nu?23nCRy~+Y#V^VMXL1(zT;h4e*e}xao%MmLrK28G?kq19DD$`O0WkwQq|1E z1XyC$0VV`HJfPxycM-zftzVIc?x|3vYzGLW_yJD@y-LU4r1UDN_lW0eL^iADG8;3g z7{O=+9bX>$@J=$g!eNK6RNHi_7=~o^>Qo@;H5a?emm0d))81KeM0V(X`uZ8$A$Qar zw#eY#hBtZw4QQ977{F1?I(PLRpftULH8J|;)JE&7jP|pPVBa2K02+D(Y^KOUlrTNX zoQ;q&oRJ)o4cG~{l^X-rLmr{WzwwZcp+dO~?p`Tv% zS^}50>UG*@1-C;VB|q08B8rG3LiSQpQMxY|E5{io}Iov2gcL+w8iXdlW zbMTql9$5H+b)ejZE5~$_9wY@Xj@C4-MgoZZl0Blh-a?k$1j4+B=mmWPF}rQSX((#a zb0L0UPv%qfr=4!Lqd|Jx{?~QsFJw${$E~ylfL;V zd_BF^{VcMGPRzy)_XG_Q30-y~$LB>=XdL~bGLG0$Dg`WshSc%!(xCtw$vIE4!Oy_t z2XIF&Ar)$1Ceb5mZHp|)p3OpeL1iE5H#dw`ZIrCzZtp1;!@lbH(q&z-(njr^rijxf znazvVroPpdBO^M%m9^m~lJ7w-9`j_o+t~VRtcIS3RiFdAf1E4v7T`EA+DLT9fF9lX zfm>uy(3>}kgUO`bl{@TppM++ebsm#vjD{3```zUQd(n!Z{p_*=w+;y_IOc8J$SoR9 zXPO$Kq|yfTG@XCKv_j40*+V$UDU!P|K#klYnD~cw&)Y+l;t^9R^tz)VWby8 zHfYgd9sn+d>0i3NkI-Iu#4(nP6G%Qb?g3tYJ2ByK#oI$RR;3OnY8B)7#iu^VL$*B| zM^(cu)x5^j86;_T<~DMu)-1nEv_CG5(iUg}b}(1y32>TvHMOwK&5C#o6InNy$*dCQ z2lvjA8hIfoiPHDEiF2qoA?0BK1l=@QNuM??QnoCCwL<%q6B4NwAyO_!G-LU-kn;y{ zX4nE+H3HdeRTIq?8{o%FPPg{9)vuT@+X4MFd%LYqj5yAO(b_1o$dOd~&`7cx8(o%L z?@(HmT>3mIFC_s1wFY$)KA3!6-Vtu|bf6GpPa-*wK;$D+EbigD0dSm4CNvL7Lx9%L zBtc^IWtIvi%s9eOn*h*UBHMQ7m#9QT7p;(c2H!7(rfJtlYN>lHF-2tG6}3f+Q*AoC zt!|1qO+Ns%uE(&A4CONv9sNuxQsyBwn+M9%5b>5NEc+>3sxF#G-ec=vS}L1^t(vv- zx&p~$p=~w-|6}$*HUD;MAvia5QNtA-(%x)J56mjr`%}2lCa#2T&aForsU+~o=UpF~ z1g|q$)ELBQEG1ghtN8lx)^6pj!m&_a@3-Hd$As^H3WxLE9aX!Bc0wSum9iqqG*LBb z0;kqU_PQ$9+N&Qf8_x^m=^BOq6|zw7>bp_8C>3g^x(^TQ8x>KFv$O?YA+3u(?xzj= z=)5&3TR&*sBU`6|L(vdU;R@P-1+0mo-1b!TI}1-`u)73osZu~d6Gm1}_i#HdeJuwq zP^_k4tDbj~RrnC3NggWrhcUbUq)l{V9#RwF;lqKFlIj}u)WxFn*K2?In`3OY!J&B-!J zREa7f@(*+YTTMS$#Zoh0Ya`0FJxSI;mB(>4I<}QEfYLVGXqf!*XlS``?en1yA4vcu zPL;)Wg}Z@!nX;pAI#T#aFkT?4f*@o1$|mf0l3YM4l6dIq#PRM>RpJ*HLYJqN+R7;G z8IP+96~u?`N7Ue@$Ax)xETlEC#mdBg$0@aa05ojgG;Zop2C3sd>_4%U6Fp5XJvM12Y2b&4? ziX}4pL$d+894{q`T$~ObIVPt}zq2TlG}68qKKiyElX~KA6cI)kt9;bZLvS5XPM8KA0i*qU-27M%D^gRTfws9c2%v<29u%d%jCJSxk^0(K+)<@M+$!(H4;(L z9(OgiH#|e+@1Qrc*mX1{7Qtc=TNISMfyWTAlU@UOhLXGtih+?IK*k9 zdz`fCQK%9&kqp_HdE{d~O&*m(9+^_b5AFwCC-$Jqx#VC`WQ0o7UvXWp>JZL3v{Zl4rp5*28uUlb1AjabUj+4SP4>fqdE) zH2{< zGTS%bmH!3&N1kMtUI-nDhlK0S$M#Ssf?5Ep$o1TQL9??oLc-KnXnf*~os2AcSBnSv zw3~K%Y40b8EK+8jOISqu`0bO|-#}>RhbGuL7VFiGGaiGgiv~zSroVwxNaVA1c$#cm zD4R9VpR$zd3cLvxB&dyU=!ap9MT4X4W-Ca%XE0y+@(@_5-9PkWnTM zc2avGI`M|$$u1GS!OK-`0_AkfIEJ(Rc-`Mr#ja-6Nqu){a&<~j)8>XZALV>q3zaA@ zZILU=QLc654c{C}B;_0YmRf695#g8E?rH2W^cVn00`d)4ZN>({1Gk;?`Z1K=M&u71 zvw;$iOif?G^%elwmd~f^=S%<&X!pdhrhLqG{p8c^Nz1?i2$F=jKFUt&K~!1pkyuI) zBVF!C%~**QmRR^m!lqmkvrV!OToslfpjc(kB(l!xogMsk;KB@7#Z^ypSu>a=QDUoj z05C1-6ZIq$Z(U^ifjr`dJfohecT3GZZ= zEuD()dUvuqLHA*}HyxLOA_l6PsUm=FRCx#stCe@}MhK3hah9RKU{}3R{Vk2fGr8Y|H}XJa5Qxa&QdT#irtSJiM`?7PE0^)xvm2 zoX}yNMVz8Ow^d==&GB(tsJ`Yy?=kQV8%>vCyk^%<^oUa6JdI_wp=u*!X-KlPoG_mg zyzH~2Z<+fRPE>mi zPyIMTnhdi&{@m{ZrSzRp)IvSb7An(hs5hfJ>L@=a-)fx)C`%un4z9UPF^#TnASpnV z5zEN$s=-|f1MksD-C#Lh?Cf8Iw{@{GFa^lL-V_fCrw^{gLp0!NFBhnAT-~niB|LQC zR?~(a&h55P7mNnxvnO>;kqlKC9-J+R8CZ7=Z17hxS(sVus?qbXoh9qZ*=kx3vb(M7 ztG@0lISnO?;~qqok|+9F658_svcsMOPcXT~#;Gk>l{Og}2@}!-K?s&>cE%2_ZHeV+ zdd@f}vn+KdImM}mpl*#>z9{YvUm0ek>2B*NMaiTU+vBqIk3&v^c7Cv-x+a)z#au?p zvNVE8==Z}5IV^c?8)Oy_z+C!I3(%MvRw9eKC`a@-c3jG@0d7k3u=K9HQ?|For8|I z2S7RLOVjSO+Y5yD#GBsOg9q}!Iz^Zz^e0$)GpJf@x_v9it37eT2w(HcU_jIe0NN61 z(f6>xzoV&@fmNK?Pj!*FHf$N7Vx^{_sn4cch!OG+AzljTn*ny z@@Puib3_uR54~iEhSgQNC9U0CBr_bER(AIGedsO!JHW|52nujSgZ+x)kU@;pOiCLu*d~jC}el8$y ze9X<6?vsRJ=w@g)d~)Z7C^xd1U6HLAnb91zg@E~v>Y`3biR${1T%s(SAv+8Wew3q0lUDpAT4^@|cI(FWNk8I*KK%{gc}Xhl zOGfQagTY|OqV@?sOl=GKfUsex08C0Rh-wbVZCl8NoKJf}u`kRW(Id;zGHDCA__C}z zyy1_iuM0%g3uTT#L6~_>f0iFQP1fdTi3(O1Lif^xxt!noi{r`>J!WR#)sXQ}NI~|) z8|V_6@Iib^&>c(%FrYW!&JdQSM>Z$>VYZtO8X6hT$^1}`WLNhn51rp(jgRUHXzO@T zFe^I$sCKC@pnN#0O6br{TcYX4^ipeXRK=4efw7^YceFdQff}xpF#Ftbw4 z)E$X4;D&K-|NeWg-^Xz8`*wk;Da)ViCmJL$O({_(4>*(+Yp?KXd;cO_XWL}JQ!MtN z!;_Q>$*^EtHm5sxDtR5l6}S(bicgI1CxtAW{IbA_MN<1qse3QaS=?`6t-q@~i|38e zv1>!0eI`m*%iRV812;uyIvMcYG({`=ygdVr1JtRK&g=n8ZQNroQG%*Va{ufX92&TY z=tbLQuFpuxI$!znc8zF;swHc8F%Gh*HodBDqQ{w+_2BUelnYR3<|HgtG#f3 zI(I>BGD%yRZGl3z7DgH)h{g~VIjY?;kZ}(r>vUH%&MgTq$f4Pq@cEShAw+ z+?*sHLy|>eM{COsVt_a;0glf*nu>0zjsb)Vi!@5%CS;k2ms&^Zp2Mo;ds@sJU}Y-= zSXSa;wm4tI6HVMv71}}4$gXttcMiR!dT6wLT{&?ldXFJRkcm{C5o`5y8mQ0PPM5$# zef2V!#DSc~3;l!C>cN^evNx>O({9M>TY^y}E3A92M_8Bv4wF_2X~G(N z4y&|#z?6tg0s^~8_VA<{`6Df|-HC>I7D3R98XKg@iS3xCF4Q zU9jB)rSz0+rnb_+)uvFFj&Bk_Ti=P0Om&)x)LxmOz^3obtuTGv$wN9w!=rCehZ8V zHRg*ni)N&}Ln7j^n5JiK*)+lk^C+&=?3 z5Ma1#d|=S&spXO35^zlnWUZIQFz;#s$$+$;6-W8$a`CSNG47C6Hm!XkU5!d7S9m(G z$YXipv~KF6!!!!|_xZDLKv`kDfe()5WFKW$vs&Ckd%vseti1gqO%>5slKhb4r@*Y$ zYTdI8Qh59QrJaW+RKsDTGReqSJuj*SGz?+GsI`G^Kl#)wDJAVUVnv4-jac@`y#BWkA(3J zQ;bo{r*xT^CwX@oPGMFp(sfgX@|qdy<%f|FZHCRNo@eW#?hi8D zR9#H@Ei1fSUr;EMh)q6a-JKsWgVV`(a-J7unccMy=W&4IR_f*pJ3Q|SM@D&@o_tW!acY~gY$VT(* z3oX`}IvGlZvYGg?+ffQNfz1s-0nc1#_aXa@6dwvm2lPzx5IAXC((k~%c~aG%NZ5jR zz!oVW;p=*1rQO2P1_X@vzkukK$v?_+W#hTXxm2&e2Fc_p@k=MRUf}8_DWdVnFhQlE zfhLrR`Nh^|esWhJ+!iJb#=E3jBVu>SMv&6*xp`R#q}_InK;Wo0mydtwsA@#MS(sbKC1ixe2g(%*iMx& zOf-=HcmgpTQ%0Rp93RznaO<{aWqV$}xv!b-Cf{!vs!|LPY#P-SkK<~&#gK*1?%dF= zY%_vrS8e{pLAVn4+B8bcyOiBg!r>4h+=Bs^40NJmP&61YzG0=OMAv&;7wTSeTo85`Q&N6p?UtX(TmRx5{;}|$j5+4{!r;xIf)z#uz~*H zuLmTf&SSj&+@Y4_gB)f_RUs88M<%jBOE6U$?)zt*xbL4jf&ewF7#-P}V#)@)3b%T| z10iB|(ZoB3cJ|at)N2$OP-P>FcJF`u`tRZG7tpN&G^4nJTKfL`I6?ON37I6TPC^3X zs$6Vt?t+sCtZiR9u^nX2BU05Vn zI@h!`M8dP$0%esJpbgSdbl53=gxovDV8Q+wC_wbB#uN}#_1xrCDMy_=BS9%lD`#-% zF~;A;nof$`Tah1V)J)=7TeZlD!(-wmuV91w&|{jluKE>2HEzn(BPP{vztpVn?dSSn zif0Ei!ZdJpyL0(%bX5t)Xkoyft_5IsqDz7I+31mu_6sG`o6ySMDi0!oY9!1bO!|TK zR_o=HmVmEp*QH<&{ubuOSRHi-5;ca29dkOm9Z;sy&lcP5d^nK8ywJBsevN% zm9PF8%kks4q&c!$hGe@$@(j+kB;L;pNO|@#=RG6->zJhOA>FeXc6Zcn2g!5=G#Xs7 zaDT~h8Rmafy-?|?CRVQTz?N+VcOUP&0Sf7+ZfF3QmM0!97$bpGV{D?RqIDa)TR;$6 z*`GMja!wU0I01(b)#ZU>C8Vm}CL|MiQI{;=(bq>-p$wB}bI>yMyA zb1XP#%{Z`gUep~uLhYzQ@s}8R?(1qQA)i}A>kGZJ4h;IiSKoX4!TyGZ&x33NIgwDf8k{A72#o5ErXafr3OVOYE6;ZJ$BR$u{*T~oZ=r| ze+|zxw8>Dz{hFXCaD?IoU~URanPOHTd|}Q$vTD{>v=Lv`xe$7BHoFR3(7^IoRZK<^ z;f2I>3kXj-ze^if;!nD}SBbaOH1+DSA?M>59@$kv33)EC_ai7En^?Ab;aX;mCs$CY z82LD{Jdk7Z{=*}@GsxMjt$s9WAq!%QE-b~1oh-dJ=m|pf4p;zWyO<9n(2C% zj}y5%suoyAO@;NKtF+Vxu%Y)LE63QF;8=C9OzZL}`I;qOQ%$Ig(NLTjqJr^4Q}j$< zcG8OGd&t70PJvMyP1mp;(Y?xr|LYIKTN)wAK?d@y9C;%I4zftc;HkPYtnbWzaDtYIw;t6)Qt^qJvf9Jb#y6yQGPckO zkOCB8pY-z63_u6iH~~w799tfYSM(W7#^O)>le!j3bmWGy`PxgmKIV=I7E251p#Kh7 zwrc&QGJit!dkIF!^&r$($!)2M1)OCS4x;Y!mNcL(I-XhCXV#dkqkyKu&US?ZRE?51IWclnXt0fH$Ml_TB3b?9%`1zcs3nUAjDE&3 zR1iIALU(pB0OXjwE;6JT^El`ynv*-MdQS<*uW?F4Kj1TizvKbbOr^@J9HQ)}!-?>r zHe1_HpkRa9%}x(2^bw%A4Mmy4?xm!4)tMEwI(BPO{O-WM184wAK(@c6#RgB$s6o`W zM&c^~;Zuyo3%A`<#IV}It~i$H?gp~~-q^SWV9=+@XSnk^rGbq-hHrm6eEZwVVyjOY zSI|y|!h~-W5O*ctSP6PaVT<^b9u0LKxstrwtqHk{>V^2m(^MPeD>0aAPr(fXba4&j zCS34ll{yQNP=Yigc>VXlFZ4c6Bz*3gA=vpk5`rl^V+TSHO&ULc8;sI|Lq?QbCo!9x z9uSldrQeYN8sRV4%}}kmONjaN&fw>5(+o9+2TAn#A~vg zGE*QaT}+4UDa0{NTdgtEwoYEDDAQhy>R*J#;5^8($o&NLM|_a*KhU#oK}Pk)9!EY3 zu1tVon0%pVBTF$k3$faiSa&HIi@@Bsy^SKma2wi>m@fAYSdC4+H?GPp0#-a@d*m6z zDq8z%ceWW4r1$L?7A%8WTV`tzMQOBpSh8$njA;~ zCkfe2$rYAsCtcSs&;-QewV6=&fc6*d9V<(?F}JYAfw*cklaXIZ;yj1!&No$=Ji9_2 z!421e8T~81v4qO=VW8qes_mfq(&ee-(p4r`EV07wTsgayrbO9y;K+TB!J`B;wKvX} zF{v1>qNM04+AjTZ8qEIKR^oOvjfASJGFj)m6J?zA8jv5q6G?$0xbhpi%Q++Df&-pNJy$=*g#^8Pe1v&fTnh1JLn z+v79n{!y1F5F?7aWBU`u9+e2zp4jybF7O@#M>f;^k=5mE zwFR-|qaq*l5r%$(b=)AO9WOVe9+qXytC}j31h4?8njUq{K?Ja75BAaTCX#DgJz&J+ z4Q=GfMV@YDp_ z*4=?o7rAu=jv(ekK9K^~lJ8h=s|gmE%d9D3I{VRja1{@-9Z+X~i?odfmEG591Wgl@`HB!fLoJH_l!)6q=|+09y9 zdTh6vmgZ8id>r0BJ+&9F=wD0P=EE8TCL*>FD?s1mdGqF-97H>P=6#T$2p064*Q3u| zy5f*!*juX#6n{SmR?wm*1$9uEag9*uP?E`icwJSe6`Rw=^Q?mP(3PUWF2JT za@AWQ;plC1$Qm0S>^f1_)h)$BY?7hTZWx(}G1huQoBS@k{y-^cvTal(?*cmPVwPQq z`5lzIb>x8K$`%tQdc8XYsGSzQXCL_5bMGtj`~WQG-NK@lvez`e)a zIr9(-=2?EY(=xpAZhrxZst4&_cWtvU;RJl*TNKMm)}5;NcZDm8EnZoA;AN2&tl&}! zv+@k3U~wZx@S?q(J7{uMt8t%Ys?ek$4zyv9Wm{yu-eDb(zJGyC2+;vrtlK00diZ+k zvGedipwchD5&pwBEezHt6IsaF$pf(?vVh_&JXtp>hO9_*{f}^q|^zA{V^=h6Sg(Rs-olN^0ur=kVOo}|o&OW`s00ubX8f9$h%BiQh zV+EEi9()KT%S$kgyeL_TpF`>N)xV?y>ZizZZSz!g)c_g_mZoYrn6(^L>$U*NEIo=V zNq?{nQ!1G|g`suM?r&c|2G{b5aOK7P14+4$C?knKJI)s=UyIs1trW+&_ruAbT`Mo5 z8XL9K;Fu_x=s_?K6HN!L*n&IRW8(yb5`wj!b3du6W)J!K>nFBeR0u8Iq1|2& zP;8rGG_v4f!`Mk}lkAG^dT=-Gwx|dMyhD+ zrD}O@I&*>YgrduPV@gQmx;lXA{ijkNy#DZVy`wQ`Axg>u;2&;Yq4nktr6*OD?I;{| zI`-bHlcctm;6Ulr+V$m!x!K*9O76L7cB@F#)GVI*YTljo zAgLp~Ax2BSW*h>t!O?0CUbVl>W2y5=>?R8WIO0}J$~NlDDGhbMJY+*)SnjjIzDlmN7rBR48{dEm zQGy;FOHTG%904IC@ME(jp{^?F=M$~O0J-Q??bqr_-8wC%E8OR=Ml)nU-K3J#QWm>6 z#Jpw_ELcuM&aZD0e5}@lpR5A5FtncUa-PAq$)+{i2fC&5h(>wl{UFif8h0b8Em4vK zIa5sY9f~1xsT&F6P~nLN-BH@9#I7w{Re{*W#peCvBnGTb@=)Hv-ePLntLi<>WB_>W zhkKD_Lkz``TE^*b&{nY=<_JZxK)2koR@}0xKlyK<^GKY}v0TbS4dn4)-J55FbvVqT zGl>oIt;EfB;b7d1Y#*#+pB$)8Ymn4VIAk8vC97B0$@RwNO;U~d`g^Z2Q{x=7ZhA-9 zxig^)v|T|kQZNj`i?foG9e1H#OeWOgtoRm#s>yz1zlRJal#qyiNES&#$Wv{_la`wz zHz@a|k?G3X1wb}BOsHmF+PY16P8FCej7ecL_5{FKbk>Q=vio;MlfcRiQA~=&VTd)c z92abzp?rv0tB2Xvqv=L;rD*zQ1?MB_f*cxd8UJKwn!;j?dXW{CpO4bEp7}JnC+Y7}_)s;Yo z9h8xu0RU~zeu3EEJK1A)#NwRq5ushK{YV0~{^M-(ZIW5soj@{@v?yu3LTVkLSK3_4 zPG$1AwdX{65Y!p=5aHhj=P2V@vNYFe!%lLIi;$^yrfsJnduPBE9wUk^<2_^GPe#?Q zod)RBAtTL80y2n!bSIS@$FBfLdrSb6`HV>a4o)XteiJaxz_ zFuvfyVRe*q}o4zdnsH^HS2wl>8@whaNqAhZ+%sS9|p;IOW-r|*gc-)o27I-gwe zV$)Q}<}Zu@*BIIKrIhleLsORG7OIM8$Jn?8S!#zpIFvV!e5Jjnv>m0or%X# z9PFXhcT1SpsICivYjo0LL;hPE0}v<8qX`Hng%cR{@t2({{}xQ2O* z7lZdFSJQq{dpok-)u4>^{{~8P`sy82V{DGI=5hfQiR7?PYED*RQVoE9MI9q9CQQxC zi^6QdxXzbpk4P@S;vE8`)CI<{!+v4Lr<|PuBVVRAYUCi#`Z2)+k`(zDI72fO)~bI7 z%tiXEw_j#JyX=q?oLCLUa;B`V*XtuRj7;eKEN;ReHFTS!H%fb}+WJ+Fn%U$SF`4`7 zd+ER7{EghgC))y;cpiEZDu+>iyH(FvKl0^)(?W>xd7f~DRg7h&&iY#wPlK~7GbVVFCCH&~4@Ex9S`1{`VFA{q_s;#Y0VgQ>s*$9+u z=Ev;m47>sn^~*5Bvrxs=I!wJsACYy7W&0e1|GM~fn9i{Z7 zn=KOX^|kQbuYH#>I6oHPeX{4>j+tiIY}&i+#3QK;r^2%kp`f`W1+b|TNd4{;K;TWU zDh}nAEC2?e#Pq?il8EVbC`WoOA>ed1$w4A#`34Oh1DS%H6z3+a1lNw0-YY1O!E%Ac z+d{um*oU3zm*Mr(q$SOfSrG$;1*DqNgX8_LaH#zbVoFhOZ2E9RQ~@(@CM_;AmPe#2 zEia2m_A+j|PMH+n1H0AJi4MR>X;t}bzuTySlggALkl%Xh#7YSfj>Aaj9qor`BpR}`mOW&8}TuT61sgtCpS1lvP?7O<)%vK}T zn;eJgUcrCgl7h&C!IC`>bS3Lqj(ShIP`ph5{YO^73y)LX9#FV=?y$CHBU z5*VV6*kr>xokxcRszXd{w2ImLy;~q?nb;K|PQW`B?kf@6J%+HxOXPd{>(?*CsloKa zQ-euSDp6rkQvnm;yd|CftD}*l#0avMc)2PAXirH zrV=L-RS^!&H$4+7&T|t1^?wrfCQG(t*LC3he#HS~RTM}eHAhh(Kcq}BZ_ai1xZb5V z_lCznCK9u%8fZwFCQ`OYW}-(DAdm#i;ywIV?X}Nd`*@^86RU*xGV{HN8}8@qb~Tzl z)LJU@K9;@gQ}c(-+6Mi#cUZOhZ&>~ho?zpw?fPDa#Mdi>vEQ9_U%}5 zZZSLuYD~`bxc=Wf0w; z7yO*uIzZL9&!b6mz+RARGk<=hd&2F2qT>^~QOj^T06Reh7RSV?Y-Pnp$Dom!lDlR# z=w#%2chXp&{81HQC5`>mjHn%*SfQv8`aNO(1mRFXx$Ks7Nogb5Qgs`xt0W{IZ17P= z`y_1iaeJd|I5%u7ds|Lbs@uZG;``qZKm1|(ntSLsDRCfGO@`+VRNkQ`CN`x4xm}}9 zdehrIl#8@(sCf>KwL#_9vGI((gaM5j=ky)&U(trGE9`5qU%RTPDm7$lqAaw{NxcDw zMkiG(2%g6dx2@};wj28l7ARcHH7Zr_f_`AqSo4WR4+i-op{8jj?6!5-y{aN}I!VL07(ieYluWY1D zJa))KnW2nXE?Y_o1*gX*7wlRMs)#k&@?o5O`dtGzoqlfVW?p|1K&Cb>bxZ$igo$(j z=CE&@R%x`{t&K#n z^hF^GRFqVQwVq!wwv$=;qI8tch()4;5pW$#^s8CzC?lI+SKjf?DoxI>B)#NSPA1YR6$W{&j;kUmyr%C|B*rn~c?6z}4)8tN%V z!L&5o`fx{SS}=@Hm#gFHqIP|(niV{q75Iv)M4DaMD3<$43!1^7cIsO2fDB#$mR2hX zGjL|%(WtYvt7*jHba#ZqCz-bC(NmU|k~3OKgWX&gJpCAuX9kY#M^aQk2+Yk@OBl=sbxhHi;?xj$T zeFeuLsYV}w#jns-ac_-|u2I{bu-UX(NO)07n4?KKp;W#XzVjW+z!_XExx}V;GyDN< zWTX=#l_09!+e1pawYnVSTe?VRl+Vx}Mx9*?^}o@9KM*E9tpZSs5qKt$2>NUzw=@}C zIb!ZZ#C0!!aox1*=eXvX@nky;ez^Ian0r@GRw|4YI-oxk-fe~(lrpD5$~y%IadrjZ zziA2C=&{doEE4Ea3`#)$i$fbG?}V!5Fn?;rq+4B!-B2xOv!7I|#VqADpb%68%9xc9WLFK6r!vAGC;M)1$DMM4)3!D24-$P$c92YDu!S0yb zNeRu5qO`Lqhs;DvHnh-$rp=w&xM$6aMO~w7UymvX_aA}K_TIAE6Q7HtiFf}cNadv{ zP{lzMo!IQNgxGOLy+9t_rzR zBxbL;WuEn>+&~ulhu6>F{nzmRbE$r4o1KXHc8x=C5@rC_$@yDywx-==grXK3*sGd8 z4Jxe%u~-lb9I}c{zOG$oZ`tZN!4>c_txDdaGQ|srcILLdwVc3UIlow}A~kA;bH$X! zOE3s^M2oEwRQji6h8WJFv0t1fX}-< zhqmD+rXQ|qvSs*Sqvbtml`MpPNsyOh|=jXVkT!ClU){Z}b=zO<7bh|5=)l4LzpFb7KD&~(7% zRCX*UId>7FIn#at?Bq~z{@g4vFQxe%_ko26ESq&gu`HEVvLX;?pJ)YFp(xo0SGu7cT4H&YF%Na zSH>~{+-!kAJ_C(t)zA?}7D6axsEwTE1VNFp=a`vY)@tl(0op1*R?=uQDVy?CkGRKE z(UB3s`FJg4$6&U70yzE(oNr}5^nl?z7H%`+WV&E?No~qTuANRqmZJ7~FZ3PDXdE?= zd-2$$l*5pb!N&14Aj_bDSAK+Ts^ma3CCDq4jDztgs6>qvah7&=PfZo@JD22F3a*X4 zDk)r0LfYHdrl6~q9E|VXq}{R$Phq*&6<(!j+w8TAiY91&gri&jQFo29wrVb2bP5~I zUa0`Z$@l>Hse|J7o$3VwCEN}0rbbWZbmg{NFu9`R-d4Dfqhi+8n*q;I0_q^ytmD*F zYWdzp(^O*?AIk2%7C4^;a|pe|!~we#AgpYb^O#;>v9V5hjsThFxGb=(Up5eS>Ml?T zyD9o&D|Gm0<0YwPURX8bAbZ(tO1bYpwP%ktj}EO@z*8hQQGYzFd6gtR6|^W|6x2EG zoXd09B1f3`Re1fAy>*VQq_vtQ7N=j(kk6X>F9y#arK!^u7kl8|zF=as|}Ku=$Q z7&WKh#RZ6`;@L$}B$i`hanfj$6jtfr4UiuQfriOGJ%IJdm6%v<(l9DzMd3Wh<+fA) z=c&k)8fj+w?CVudz??R`z0`_GwxZSiGG~4M*61jKf z@6vs=yJq1gH512@-yv91&g{e_t6@adxh3PddQbM*KJtHgv6uettM_s({-j%KJ5Ks3 zED()5;!a;=JO}tCw*Ew;-knCTzb0Q6Vg~Pj8{Yl&{cqp@URx|QnI+CoO(=q<1=kXl zOILntdPw&?U71T0&3k}0Clx$ES=;U-3IYCL7)ib zVnHzjDd{$8=&#t`Hv{pXMF2k6P@Kt9r3CqOpA9=nYwc8h_a(q>t z=&GW$BZq!b5(l5)JKLboQU`DOnEf8jvi*kHZcp3$m42d7E+o4E6TeZc96)owu+X#X_^!^M_>$KG=yi%ZEAHdogGp~ zNoVybqAg^~tv+UujQ3Q`ydDw}k}*Y!iVIuj=xbvXvkWlM1#deA5lgv1V>#twjFbU_ z7Mr}yyqS=A)m^zb+q@sC70f9&&-PmzaIjfeT5g;Yy&zl?TpCWjl-$PwfY0*a87MG> z?Jr}83A=Tp5SFB$ul&~+%mh|D!Bg+>tlFn{_YUSDYuwuXG7jNkx-Kh67dIVA7|IuN z$&h+AF8!(!faH=*uDNqV4u!4P&WU83i~-BA8d&wiko_Nw*D7J_Mnt$ee5W6JvBtEx zgDCDG(IV4Rclf%d&t0nJ56=dcsP6V}FlwxhFJZ^ikenMT%B)0 zSfa=#4ye(u7GE4C7zbSyDTy1yJ-u zvaKgRxD?&LMPF6NyU#oT=5h>^`ULBIYT===)S()YM3UhJ>~d>Ch@BYLRY#voe3cQ& zr|lQ-P0;BV#uBMJ1)oJVC>iAKx=@+Cdw%doK>{dtvQi{uw^3lM#<4&GbGKjZ=0{xI zY-?bS zj`QLkUZpAG37ePo21t`1r43gt0o*Uw9k%n#nKgKX7YwiLs2j6{Kf;M4FZCli9WTLm zR`RxX>c}1GXe2kRnzBMok?g;j8EaJqf+r}J@=M-3YbLWSwYkPgtt!H>50JC^6e$ce zEw`96gi%x7{ck{NcxV7X1D_dja&;d(#}L|;$W-u-hv_11ryDLwp5olxrUIq~#*uDO zhVr;18?>6lMR=;(Tf+oQj+~-C z_LW#vbvw67-Z4vZC+8wUV4g2)2GEW<^r6IYP*X1hRGeJWaz~H2C0u18AM%PBh<%Xh z*##d92(5-;S8YN{6NYn{=2hCj;T0sXVQf5R>(pX_ce$1S9oQ&xaV-6HCsG4Q^!@3s zj~%xjeRq2!wS?IZxXV%*s{YIp6<@m`NP!E4+J|f9gK{4$mf=mdO%L7W35|ujssqVy zns)H*mas*^FHQG<{?B&V?T;tDIRZ{$-D9A#CrA#-&tk;{HXU7)1xu$Y*4dY5=uAST zRlLnboiZACbm34jv+*#69JqB>8ZxT-7-3X#yzw4+n?iz*HhcdO~ z1aRW0u8$8ckTFQ5e&*I~;M+2L0ibHWaf|(cK-|_@ztXh@NfiLLpF|Pt3Zr?uwa%JS z^Fk@HMqrg~429vDFC*RP(-uvWI)M}VRAbzRE5TViLJ9Kr7dbEIjqV*gtZm1Qg9NtkE4Kq^r%l5 zIdn{m%GLr(x}6qtg&L|YD-i~>asqQ{#L@h_|B52yA6|c{KsH}4sh0U0YAAjV&uN*)(~n^Vn$bsQBA#@&xi5-x|giWBe(dI@cOd^K`AH?wLUse zzIT;lclIIV0x>MHTJ<>$lU<}2-{z|Xn?1LBuTImZK9Bw(nwgp2#D}w3{W84%3do|z z!#u-^6>7(>jnYA+6hPAhR(Pz5fqdjt6S50a)?}dr+q`fi4l%|O|3<^{f? z1xgkD>FdYgZ_|k$`Nc3VrBuZA8nc46lvq}x-4*uf^Am+k;vQ|CQKnk+0&T)LRqR9| zTG}*LHeozVEw9aYsSL}r; z1)+0z8-mCI=K!i;$y6WIRor605+%jJ zyQs>F@wE>_U$US22CX3S{}UW`*`$Vg|0ft`p!KhDNmeLbjt&8=r5d%JKvAD+JQZ{G zqE{aDQ@q@crIB2(!u((AzDTtabEJ}D{{hmJVmw01plKucc-=L=KSQi428)^@SfdTi3@ zmU5f%Br_oS$3=rGBI*jIfJMhEnEg^(jPc=nG(&E$kmRyik6YvbwU+FO zGATABbrCy)5IVu)J%Tz1B?Kqa5+gsT(|lcQAR~IxnCw3*R2MRF4nUaTpEotkm-uT_ z4;|Y!B+HE)#j;5KS!*W^bF*2HfvWLbEVn-B{M#MgdNoTI)s=_=ZaSl&zm_xk1AAhN zZ-Fr{@2HLODSr*${ugh=*BbXUGIv)(?-bc1Jy6dMI5>QHi5f(FW_%E$v=p8eP3lbz ziT-3LSmV`Lv%}bLc z_R@!+kglYDT`OA;BpOl3k|4uQoGnlX08n(W<;xouT{zZWy+PrS$kliY06_v3THK4S z_lP`47)XOFe^KUyrYD=+=>6@yOE=k>a72uCi<1hMgai`MCm*AxK7>2?MMH%C{y&B9 zrcbqOsn*h_Mw=EX7tzAGwq0}?9v!W9W3u2q%ujdOXX=ojIU7|W0qowLa27qZC>dd{ zoUK+MM)RdAddYeKgmE8jVWEoh&*yjR1Q37dNI4&`Dmy;ImAZr~1q=l+a z`4kQc#d-v3_Ji|iw*a@$y(EqDO!{X;qi1xx^7 zR!{)z1UH^;&3Gkxgd`yu%eTE8Xvk3&n5R*>>?R3D-UIE_$l1c3q(E)C^CyNz+KoL@ zr)c28Ol;ILz3U~W4%+Wa+#q;^T0?quMxgc_9zW~-^q&t@uD`py`v(|`tt$Uw<-V@! zT1&O36O>(;fhMYl8T;ecloI@P*6Dd6X>9~_iSs8#iI=+J zHHuT$*ZP^?4nR=mQIu+SFC9g!reif=_(h@Tf&=^odD7kq7Ol4U(4u|6aikwfLax)n|w?&~F`rz_J>!*JrejgY||a~TnzXUO&Yw8J>@K#h^fP%(lR zkQe8u;7%!}wSxjAx$eL*+jg{=foHioG(J*y08zEH&oev-H;ggieCJS>kS6GSUcYWC z_GMpI{)|+$L3KsA(89dIia=;=`}K)L0`hrwH5OV+*FccP#+IaB-1x^p;l)bs4JHB_ zstITFa9h;*wA4Gv>$mX2#i-rJKavY9`>I$QhxCIg2wFCs2@G1!%mnD$RqaIuVqprs zV^4GdFK?l>l?Nrolblx<1}%t5UehjT%#@U#r>@kNn;SVr^~pB|s*H+{Dp7ynJvcT1 z*~Mjx##P+LG>+!)BH8ZKA(bkNHSt_3L}Oo8TC${A zQ^_GcpnTvjz0)~@?}#bDIE2Qm2|5)PWfaZ!I+glSH_f8XI8MdH{cx1myC2KDMe?gD zzkm_7eclhTT_r&^o~S0Zl&+k#D2v){5%4gqxSCM0UXz@A30PNsQD{`T#AjbjVbupU zqdc@yXY4oe>|gse{O|riLS6%#f6Fm%S3urXU7v{Gt<)2CkRo!-yVWNx)->#7kl~Q= z$=jau>xco2tHVek@MKC%a$qMsPy3R`^hVk9=Mq-ZpHt{H5t=jVT50%Za2Vy&x5>8Q zN|4|O-%ZV=fmVKuks=2CgTtsQc&z0$Qs+K(un0Br#Wd1y-Z3~A=-#||2CM^=mf`YTvr1N2uWEa0~ zO_v2np;%o{rpDU|Lg2V!0ic+D|&bZKf~zgoF4j+r8*q)npXCGdjrrPD;oDlLzW z>!d^pRM;Nyb7HW?2mgPVn8nV9eA}fY=qVJW1VzF#VI2(j8jJ2d-&k^dWTxQV0su6$ zPAzyiK3%ec%6nKCmYBJ^G}Id);EagwPGJ)`8}9q7WH@=RUG195hTQn-ErerHr2R-T z{V?ak{0jXJ{q3{-%Ou%+VtJylg^N)7jzGt{clp-Mu8*W}Q?>6f zR%8hVDcAV0vxLRxMY_CERZEQA1VCH1G@(C&p267+rJ|C<^XTSI@dcO~)a%^kB}bY!HgrjxhQ@n&^ILN~!nWxZ~ zxhB;Dn@YI`Y=h9c`XyL(c#E)6?2!L`Bc9R?Gx+$@z}g%Oq!Nrppc4km-$@-lOwS#= ziAPu4KSGvwgWD*J&Z&iVxSjEnA;RENqjJvSgV%91c=Of!YLNs473OIPgzeOWum+(U zxUS0mH8GKd2w#e;JyJ}ME4AaY725^9Yup@p34xGVWu@5QzzANxH1OWx0oa!P6!IAZ zjV`4iFw{BNr@ZpRY2^tr*MzS=!@FV4EwMUsbzWLxBuo%apFC9^28-Uy%=SLzuYtee z1-Eq+%FC7Uk+e~#yfpWSqZ6EVl4bfnN?1OTaUtwEGT-5ZkAReeG*^Q^*$SdGIr z&C<;c%S6T1$~A0yY@L?Wy6$utE0t-Qzg(kKGisj9CV^`l9^QVZRZS(3s9sWlHNg%U zBOGZ+-+lc4)9~m240eWz2Nn23C7Xev;J&=eMuAt=9jjXXjgE>eu1w(xsIM{E>8_lc zo@V#RhmPKJdr935S_qtr6C-WM-i~i^E{wL|vsb!tA++SX-Uzl71 zTUoYLhECQ4HP@6XB(wS;Qsv{*t>Orekyo#Z-U zdc)wH^-&VxQN;yKfwctg8rA{ZetKt+hJZBu>gRq_4}tMAKFO=jpcq&7;O+^)xWe_C zF>6{UsEy9k3_9>i*EztK`u|CR=Nl+-&r4Lhp6-mr{yMz>oq33d_uojyM7RL|E^}}8 z5+En`b$ICmrh6_Q3*84BHinx!&RWk6#o5XMI$bE~5CC0WR0MYq{!&GndIv<`%8Ak` zW6X+&*gQ)3*Z&RYe}LaP-1+1QCl!bEak<)9!4J<6H`Usq{x_ zYc{RPTkMBRvSCM++IIl*RYk;5?wrQ`@4tC(ED!n3WrjrGsOqfJwM*)?Tm#ryS=1^< zH$u%fF7VK?C18{~5g;~KIFf$@(cgz6XrNMMWwZM`)=QCX+*A(Gy%egwM2&gRBZS`T z^qOcd)RV5b^l)q)T6x3VV-^|uy<#K%paEB|m@UbKr$Pq;k`VZGuTbCSd=w_(aq-9t z>oCrg04y+0D3p4gRCjLFU%%k5B-5lBM558itEhmE9!Cxh1Ludt-ee7EiLPkHR(`B$ zRt-b8v5J1?9flN(1F@8@eB|(V+Ly0tNXFqA_*BMnfoi2>@(W7qkp#ryj95j79t}kJ zgm6Bm(TByM3Y?)Lp*ww&9U-(4}q~>7Q)7Tev86jj?fr-W|8{Al_;l zrjYn&b$PJOr&@Bs*oY`Llu2@UgN@#iWy+{#15!Ch7k)o2%O?4Q+#`MMA zv869wFx}y@4E~{RtD!MKE^4d$Fn;b1Y@F%BqRn3P;zkZl3%PHqB==G?W_OZOm6i-( zEe)MDa*r0%EsxKtg||hrC*gq&k;FwIPTZ;un<~HK@PlY*e-od$oo?YK{qDs0a8voU zzVUIN!r0jtl&ShBZxlq)qL8|glN2d!=@UO6cmFXb4W%t9f>cKMK3Q&2!-^@0vn9`A0WX-uGNmY3a__GxciFky6JRHkan zq<}6>kxEw9Qyv5*e!LkLVLGQ)q!t!>Iw~~ebE!ZOPrp@&7RGe1%g$2nttGE+gn3e2 za=5A0iR;wHWAAR0#t8l$U8u45XbO9OI2bP~x6FN2EuY(x#BP@brkB>aYM)$`EjW8a z^f0j9?S{>)3lIsbYF}ImR*J(UVkqg(f zP&xprh$_i@y{z6|mhcp*fu}rKVJ%#M%xRli{xN2c&q;bP%t_Mq6Fk9~ZQ6 zfYBB`v@KF4=F>(wJx*m!)W2WYhXnD1Ds^aPJ1XrSK^dmjBZB8kFxbRAfUs#YeH|a$ z`p9&^xV*8C16#!BrPnJ_%E0|g0>K1mM4jUKrZw^n1lPd;XWrEsv7NF&1IAd%!VY>A z#gH{1)}(vM%Q+{rT?qM%z_R$tP93!!kforFISUDNXedr2QBUq;Poku`I&tbUqXfKM z2|KO|%8x7eaf?_%w+>7SEw54180Z1VBG{C&pKxVaCZgcBL@?a|c=iXTSJ)>%i8r^! zMiO8Eyvd1eOENh~jBa3j+?WKIn3)6F7hufOgX}86NEYT0Oa$;8%^i+@9r80DN~Ex- z-6~zd?03R&=e_8#G|yatN6U5@smGmm0bZNgt4e{PA_dfhj;H2zR1XyJ!q*+)aBy@O zgrz9O#NRbqif7@a^$q_HN)0dmS*#8Kzv8yj1m;>SScv!p;0l3FCxlu}{2La>zu`NU zn+pOZcec`#E=Ptd&kEJUoQsCUV0}E2G|Ds6ot!eCt|jHo7+DnrpQ}B~t0K*mO1+S2 zkdO%NVRfUj&j7C3q^co{D*W}{X#Z4~U}S#6)FmXZY?hG)#1%c4tKJiYCmn+MI6S89 zgiWNwnspO3qNb-kg=orbCvZ(UI+&&y6^zL3OiI9)@7Vu^@0iM>lK2XL6bLT3Of{{e z?h&$(D;Di827;z{3vlF1Z}6-4-!MJ`1Zc&}5FD_dg*}@C9xS7#t+;e2gewlHDa5Bd+g@4+i)c7d*ki~aAldhz^KFGGRtck> z)A;T66F_Ir;3~CdMm*5vUV}MR=c{^M^G^E)JvjIoEk>Vw6y^;JS^o$yV$FkYNQ#Bc zc8c&)-cXryqZRWN5PUWolFRrkhWUgn=a}WhMP=!&YwwmUgAc-A{Ds}62_n=!DbQW6 zJxTRUYgCnMd$GW@kx?Z-BUP4^o=|slHUoXZ$j}PVe)X*t2h6|b3$~yx$1bj>N@Xpc z{PyMS83J6Qg2cMX>$2<+41;Y@4f2+ZB4iyBD3!FK`0bO@q+>r_6Hw9j>PJvZs@SDcWQhmt%*dHJu8ve`=>-oy zuTflt5@aZDj_>7WF`d_-SM@Z2H=4!0m6|&`^p-vXero!B$d7=9PuhWuh1=F7i5UI;UB1PK zyD_Rh+zWWlT7fiZJ+d4ma2bzBU>D&CxDIhOQ zY11`pOZ_N(hjAU11VIv#ua=4UCaW!nF$bQs!H>d-bhrV2vs(%6sd$t(1bhQOGan4K*t{%J#^HS`fM)dOq+(*8|2sZA76^`rE@d{KxDd# zJM}OX2M@+yxt)k-NJ%K#VX=$kz}z4K;Xc8m6qBJ51>(ps=1M9Es3hI0s`J2~?eKjH zz!Ur|B`{V}H`m&bTD&d+nw%6BzHs{7Z6S+9U3FLeGSS-*%q~2D=JJS10^;nVtqa7} zc@veIL3Qiuk~vpm>))&j+?NGMq8l#v;aDS% z!!m1c&b4Zrtt*}QT>O9qkmQx1*#)J0j^Tk_Y#=v{S4swZFv2?Mbrt*xoINA zVxa&zhBM>E9L(gatiU~`*M`2D;$+xrP4XlU6~95;-h7=URa9BLQN<#vz~mOYfkntntSiY}KZ1rV?*j7u+oHW@+$1&HF#{&ZTZ}1vAG7=>Uvyh411k)ub15 zbFjs4QppS1dFgNz&n8`C?tg(gOHbn#VV*9%W;3m5@-Fg|fh0qn*(}UVBx~rWrAxq; z_g|{`cc;{y)9`sS8Zf>EgB(YWEw|@+1%wM2!J(B3#DNV+hotH~c`O zYIr>+!fKaE64o}&EIVKf%o^h<3>H@)%#+TL*>%`w%bf5bJFuV&ks5V?`Yam|6cig* zuBDtSV!TlbTN1rT0svH4cUngN@os^{K$VSaF$$2Q4R#H?k*#Q*(g@UyL-^qhW1TP9 zAScuVbReAe0Ue0QOgZnPdQUPN%FW#&+)gZ&DhZPzWzhXft)HFAK2EfV@%~vJzX1!L zaOo{ltB83Pxmsd-`QYv5^{Ly#laxwEZ>?1PhO@(cZIfJ1D4uxtfVFfTVrYoTX*f6q zFV;#$c(^!RnzYE_OU2}^bp99vgYYTKX&E-tP+k4>Drcoe0onA%K8VY#}5yeeq2 z!yFziVFb4!2+3P@(5K^VQHMyT=Nsx~AT#RdV zG*E!Zcngi%M2QF zKc?t|MEp!9pR!|X5f84)fAIbA@6(g{@2|gm{W{1m|7;+fm`F@eD5N>|gfnT~s0y1{ ztQ_28v?y$z7w<*2JG88IXOWr$tq&y2qErfT`T@(}-Ui7)2mmgrhwfC2xxE`M5>k zY?;HL?2B4m&)6S8S%n90sWL$?zT{KSWczU@Qe9`YityB;&r+$J@Ly!sD!N8+ix(2LqZrAN_mt=o+5e2W8b2Rd6WLY?5&MP&@X z|2pN0uXVLiy(wyc9&8)6tL0*rKve-C;&{snh>qfRrNwlihooRuTz$l7XuMC}!t(Sd zcR_kMC#8!JotV4>5?;L7EpNp|BJe`tD5dLJh|5eHc=L2#6sa8)H>Ysp!)oDDw~9ly z;c4rib!)o?wYqdKi&H|M3O8^}@a6PJX~IA z5Sni3byhoFRXh;AxPAFiL3zg0ERi%gvNONR04QnMe={6-}j66pYaNRt_9A(dX%!GHO!XNr;1s3%OCo`NykLR zC!NER_4c&wd$dX0*a)J_bXDElY~l!sgbnqJn@xvUDIb6BZlr@%x8$!xUAm2C&P%dt zPv39^>U4C;);lEr;o68K;WXQde(=RxI$Wu9`1AuNAG-9YGpkEtijwGgn?aMG1#{UFb#j9a#fD^e-#o8#rzM!(eiXo~PEF=)IGCKwI#u!2u$4baTwUdLhsB60 z8LK8bi(H9j8Qj}6p=nfTO3J1KPQD8W#Q;*aJ9HXG!pFA)xu-vTKP#2^x9qI{WSI%B zeoy;Kw`~Z>k7IWVXKOZUt9SKWz3~d0eZh_Dobp3Jg$KlGB|KIOptGQ;gJR87I2JzX z#?Tk9nV_GN6A4K{XA-6=BjrVv^%tYs-}IV`?g{6zNbg~CoeM|xp>SJ@SiN2T5^4;P6rhl zVNzs>pAn2sO3~7e_1$Oiv#zz!Kc~=7vxhen3$6dd)C|^nIAy*!>lU3VJ2ylg@^;4X z00T+0RK?EMKzrD=6J~v5!`$@I_ zgoZ;HsW_W#yWD-D_>$_FxRft0OTzM4mw_7N^fdm7c)EXj{W^UqVhTzyJT7&jD5mfJ zz!lxRGKOgWgi^g$VH+pur~-^6L+R2mKwPK}03!uLD4$fN3YR!#m^esQXc|m;uf@2^ zcVDfuduZk1X;jM@rag&2`$&3@JW_8bI%X>gYtDmFAWBZV;o+`7kfo}5VkM(N{lxyU z(DC0R+@x*-CH*~(Hu83#ca^Y2QFrh&$Fsu_t!vd4!s4x*@=h}%RE`-QCpX+e z`L#_4C31Znx#o8%u{ry`U%RUmx>5ph333cPe)O>i9-&+NI9zM&&==S75f7v_!|DC`TRXit`l@<^PBC3giBRA(eZ7g#FOIu;6o z2cvI^+?oAzu-~MiysFUIkR6RV&fX2Kob*_(VKs0vL6-Qv5LEMRBaDB9(gvZT$b7ax z?l2iNE~${99ZC7fFlR(lV~Q1+yQsX3 z&mqm42ujfqE|3Q@8NyA|^8$+y2A&D9i#VchIBE4KD`;QYPtGPDmf+*F@dVe1si5FI z?cGn`|1=oLmM({xjPV5i#R~J@EN_?n#3fD{ELDeI_6!!x^^2O+KjeaECah5A)qs`c zDyWeDz(x;2RJ}&32-B*Uq{$|UZ2ar72&0Ncu$QP3;J3z>8XcAnM(myU zp6TX^#sXDdhbR46dpe=)pmZ5gVRws{Aq&U&g9*+_79y$>T9fQZ!8@_c5d)<(>dq;S zD(!Z1n7Qx$i0iApn-7{h?gi5HTjfMtD-mAo=>Q;$&M=3tGSpO9aFiySc+TtL>y}#K zTo!w$>83cmGu-z5zr0Q;Kd^uPgFOeiXOajxQYduqWbo@5T-#j@ z?l3+ki?OPb7b2mVQ^-{)k1po`-5owX<+he3C(#x7+5L$m23AjcE5M+!+L-rQnjhXo zNyEQ;{qhXp+g^xng*N+D8A};gYscuJD%m#GqKTt@gFY5-7#4DqwvDAN5ER_L;XYAm zI5zSkG5zJ1bDdRALlG1`j!U>OR`#ZAJ@}aQ3J(Un9J`-X z=~XiJ=q@b~7=mAqlou@&WpBExBz*3}eNtV^sYd;tHN(O8+nj`BAqBX6fD}hB?AL^7 zwog!_!myhRE%vpd)L#;dCd(Ou!pZUb5lx2}L$;+mPk6BQ>K5mZnGyjcI5)%80kCW* za|bHiStYA;!L$M(1&cm*(!xQ)&3tTKSwYvLp9g|5AbOMYxT>j4hyivD5f*&P#SXja z=P3`xSm zi8{nW&|Sji&TU>dK)IBqoU*mfhC%VMhS95DDU&4>(n4J;1bHqln<}w>3elJ1T;EPr z)WMX6rco8OdkmE0Y1XGs5&knt1Duv~bSsu#mejQk1qFc;7;{On02SMEvT4q{{~{Hb zZ>%r>@%!OFrlX7T-o{%*ebZ%gLG-IOZ{Te1shfNEUm=|F52h%9mdb8-d$>1EExEDD zNPtSwRmALIUgo1<%x(8E?doGwwo6r4)zm$S(=AZzZh0)=`QeD}Xkos8^B! z?D4|(b>Z<=-Cnx@q28fX&JLqED~Umpgz{7<9-R+f$h*afE+s>#cC|doWMRWL&-y*B zW@qMQ$AUUVjYIDY;)Wl(W$viEk6FvYQumde2Q)vb` zybIBuQUyh-B@@V5g=?j}M?0o>h5yd#Txq#ot^GLSDGLyUMDL+!KsJ>!5~8SE@*>vm+F1E(p_U|Z3rrdNcz#|9ERnx9I(S^A4e2Zd`s*E))_f0&?bVSxZ!DJwMO z6C9x%Tz#sM7U`M6H#% z&f0jt$t%X#AbmxsfiX5i2X$aeEtN1IkF*sd27Qw1+R4t{K#ylA!`WBHOo-94vMw~Q z_scv|!$6JIgy*p0;j$G&1sj`=ZmaMZ;pn=byfX(m2w~f{6&gxRFG}6vcSp%fWZcyh zhNJiHsx%=9=m>A^i*ur=Z z^!X`EckY(AEA5{|^Hpk!1r?#o{;N7F5K&9#{b(Q*Yr{;`>QVqHqfYu8_;A9zjE4t+ z2i4E^9t}HxwhFCeFPr7dJ@6uX*QBeyhHlJVLmtwWgVKdgZZ`eyD?rCSy1e^TMK`-} zYts{3CiNP05G$Bw4&y-AMLtXO;O&813t>e41cRQPO2)NH{3<0zPNMD!B`Z*o0U)Z@ zuaQdA0QQ4o*h-G?ob97VsG7^GDdg?66bx4L(K(Yqy3z{a1{e}z@)9jA`?@0LIp5NK zW8`r^6~0!eCLYS{3e)w3EKoVZ_%kPWEG1Orrmc?+J71}l4yk-NYnMa-@ddenlG~!9 zbwG)}p$5e6C97BAM6KjUl$cw94#n}^=KSMy^(0o(`DdCpg=_QZ6ovC!G3@jiti?Pi zG$bSj^wPa?hVstVrY#an0)@lcH| zq`KmuYPCvpsk~jQvrWCsuK2p>o~t!A(PIqEuNYN4IrLZx8dI>WxI>W6&{~JiJxyWK zm^CXF2m9Y{#?^!CkNwdD-e7%{uprm)@JYp^vne5@p6 z@=fg4s+-jo)T{z9arW8AZM)k?ui+f*9sW+jeTyDI?XJ1&FTBQ-q?V^F>N0tLW_Ils zT|sc9bW-Bth(I2{?(V0@>VnXlT7396v^qbZ&v;cof7g8R-(ZfB*g`A^oENMD-`BMdBmm7Czfsmza9w-Du(6ZxRBx z3KGMG9`lU57V7pPbbYt*Mc|ZCRGnOl&%^58hgAEe(N%|1b0!k~zZB!!VYh3pqm2NLM1I0@iJKr^Xl3 zDEj5Gl%QgHf(r;*x8W_2@Tf;7N$<9X^$|BY}`giV)QBwpwtL}9kcG$ zolovVqsPOphH`3v09Jj>qkbfxA%ghWnfM(fJnYBsP9{uGh3=tH0y~j+eG-T!5l~Eo@^66Ijekt54?&r zwiy4sMAcs=<=`Huxwz25c2cEX%00kU8u7rwIibk%V7lz74PtEPxFF=fDK~gpzji{edhre zIeTzw6g0q1zz`0_0$&T{mr47s9WIG0_};dJj5_b~f@XSlLqc4YcJkF}tIU-2PF$#Q z0&-&yWD)e>i7G)SUM(OzV!UA!aqmh;4PWKrsBUI9h(XM}ck$s>IIK0(mHyy^55f<= zm%dnXrz2uYCpMV}T8GOhL z^IxR{QK2v+I0s|2F5bBdkYhPrRMywM2CIsJ8X4WRP*p(5(h~@Bpt~P(y7IJ1O@|J< zAz+Zve3cdO=XOqtF_%?q*DGh&36w=v(yhVKmT#PxA#Xs5KV<~@DOBc6nOAor_F3X4 z&2VxPseH1hUMB8N5n-{xdbN{tb_0@Bm+X91YcjlC(CRZMsA!_RPu3e_powhF zf@+?0*znuo>jw!hrg1nZ<(6YKP|)lQefs(du%<)8R9c3Um}035Shy>0#2$k3QIkv}GxA(2`rk81go{{dKdCE6NQHyGjYPZDA9xqk&6ghhvK0 z+iwGOf{nAMq#0LvPZ|{VNuU5}WB;lGz07wytJ%t>e?;E6j3*t`Ti#Vb)`)WIO8bJ0 zl;32G9_$JJ`1OC#l}C5|DK6JKb+C-r%jXEs`2V@nL&IN-~$cAX^S)MkA*d6=DUGFq7IU zg*=q=C~xKg>E>{~6tQvdWVqQI6Zkw&1r*-G2b97T+38{G3C@KXH4H;3Af|w*$=?!p zeHgM{5!|P3{)jj&kEnQr20_}e=JG9%VA8yHS>$)!tX3CH;c!RXUT%!O37nZVFce3b zPu?m;_`q1Ly*=7)Ih(_wOU+d?Sj+bCu@UiuxI~o^Mha+@t=t>k;3_=uz%Qec?b4&` zE0X_PqzcII64ASyLBuC&)?TqV*zj<#692uj-8OK_;1?k+IUE0zxF%oOT%c z?@k+NLF_j3(WVtNsHQR+ojs!0WVJoQRZ zbRdkbqROZf^m6Z3*Y?`r-au(|AZ%2(16*3XiJ??w1eES_crT55S~`yndc^f5nLxSX zRkkOzg8KLN>+in(&*6Xf2a=m3rpJp@rsW){yNI{NK*BZ+mpEZVm4Oy#n%e?oODvNy zQqrNz#^Aea+?Qf#gS=q5%ikF~^sr1bC1R8r)uVy0Res&(M|V}c#Am9I>4@^q4ef(5Of5|v^g@T2jY)N7VX1LQnDoh7>A@#m z_$l3FO5z>f{<|+xXNnB2z}%x*xKY8? zy}Bx*d{X1UtHzv)H5Mm3r8YRSGte-k@%V0B!~a8lmrG zzb`uoE?cfDfI3ZIewnhpmD(f|MEmlRv<~aZ$!kz_WfH-ke_kQBEPx3yo9VC)?WduLk5(~YGF!_RnKQiIxdo0;qv|m4(ASO z%0m6;X|DvCWi_UeR>wnqYe7IM8-;`_FSOJr$l(OAVscCjK>2WLaNmJ4dE`z^2(@|K^@oP!@&)#^!MVJ7QnuIM=(XBTKsuPXqfikW=H}p-^KMsH&BhzP8G) zn({VNmvS`^rRrVcQ`%+Lp3JBewjS-13{Llw;-_T?+)o|~ZrZPGo8^lKL=Alxx$4|dik4}$LSw`aXvq~#92CF#8bWIy1de=Y=xq_ZMzt(*9k>BcHVU&~jn*=-nVxrAK=5sZ?7H zV2X`dc1Ra7TDF}E&8oT($PbNFz86XV6ZH}j3^mXI7P4qgxoz+%30sRpIpsMOI6mvf zg@-5c8MCre(UI&gifiO<0Dumpdal5Q^HBI!=x!?KnW`EBO@`#4O8IQCa#H z__qzarf4Djs%SKl!>T2De_OP^(E+EhB8$ri~H4-Z|LQ zUS@G&Ipr4{N|1#{R^(T(uaqck#DBN>56)pjb$wPmt56S}}@tZ5p*U;(NtJeAcfJ=j;VpV#$mdtOUTDsOQ+(4ArtJY8H z2ZRXvq^7L>L|Z=HZPx_VF54CT+r&{(UP~%}0LFzD$av{>R@M7@vcc-T=tDcLv!@A= zJ=EAQp{rPqHdJkIy=Iog=uU}J7Cf>emei6DLw3jI-X#t)6C`lJhF6g%6)qtq+vR3L$F&pUK&77kE2nMieF8yDU1o~TRkATAzZ(sTpG z4eJ1!JlU5BIC8B1Q%0+w^4FB5cb(!_D4eZ@Y(weKI>b_kRrjoG2P*zbx!tyNIk`Gc zwN{vvGVp~6ZJNGK7fsdE0Wb;x(2p!4{6a5rAOJQZ>X(oQ2Pc6A*o>qzT;Qk4N-faq;whcN7vXT-;a< zdG>Ly!Sgf!Y`ynH9c-bo&1D{jav&NI^%vbgi|VB9 zL7vWM5_bu~Ox)_rzY8Cv;u|j16p=tVkEM6|gU?m$F_2vt3?X_3u|Wwy=}(MA8*a-U zPb*H)V(W`7o~1)OhS@z{@;np6J)iD@jalwpuJT?&x$I=`PFO6A)J`l&+C=nLs)n3Z z*TlY|qpdU&X>6nu_}UFzv{>GTOSMNo5Gk`dc;;wzp2nBrmi8$2zVJxx9et=j{vw^v zuz;w53Fpn8X;6X(cMF&ZRE2A7l|b+=^zUp{Ue$sX8eWdy*-U-vL)Fg~%qS%pJNxL}t5jg|?_Sv#^II(he;V^e?+;-QcDMe(vTB_|avT z*JZCx?OsvQ!Tr6295wahrP^HWZN@=4N%I7!H{GZ@?h228zU=OEG|LMZHvR1mwnKqgd55eGKqArNMKBY`P+GfCSkF- zbh2vL!DWhR@hQu^)e#irm{D6O6EX#PU()QJQ;KoR(i3IzMBg`1t8P@ay?45UoTW=J z1k1W`Nv#w9j5k$jW33v#QK9VKfFX@a)g^VbeOW9VyHX92?GG5W=$7!_(XR*P_|>AM zyhe}+1KqAVkhM33z^kIYt5}xqMDp%S47iU%Rjmytk22T(Gt61-cSr(Y-dx`OPsdd_8o6k&>MwlBTm)BnibcM<=;*$?W(}iRXZrPfW zI4|HMrjMR9JZJ=@>$HmE(*|LCDoz`m(>c41eca?GnaIW71>2eo78 zZZB4dQcj&&X)0Z+eu@gz!D0>6D3@Nn2V!~NefA!nx7x23giXD?0CK--!8#D{EzQ2J zdYOcXU7K}f>Q5KycUUr1iB1VTjMVe9J3}e$Cd-2W1kf^={Zc+j5)eOp=(etT@QXFD z`rOrK^0ul@OW~4UrS#u!^;E2TaQ{+W@>fa>D9^d#*Cs#bsbfu>>+8SU)j`7R?4`hBa8tAKNIXT^Cs-74*_OZnso=m* zlH7`*WQAUNYG=nZynqx8bG6zQ<4EIwG3l}IE2n;t+UrAv*~3vkF}2Xn83e7x>fK#| zGX~B{LzgFtfnw&ec0`)>>Md;3OXES$7Smf-qQ34b+_>=TNfty?Vg;%~`>5%>x&k(O zy`~^8E8OK|$`4-xfu9TWCZw$`nlgXV@)iu0wshrcpygxX#OmeBuwiaZ?GvBp=1D?X>jXy@us$$1d+R^c)c1>BScE z*X?$GVE-5Nf74Gh^%&?bj`jt_wQ=S;UdcX6XP9eU90t2qPdky6Nh6Ol9oX0T!2)x_ zmvc}C^&BGj^N zS`hHcPPcL}>Iv&Gq36uYZ0R2|5?s@a4ZHSC>?@LYy<`1XHn=Mll8!J=deG2^LShb> zck78eC{lWh=2P+;oEyGD6)fQ;J<}Ixvg!0s4%HnX#*KJh#A9>21DVL?Nn^5q;C(w$ zbyO;G%iCr6i~XJEc5h>o5S6!!bK!16a&r%P6r+3<^edhpK_-xEHrq2#4|tu>T+qvM zRJ=NoyUya-7Ilu6zw*@aTZG0(aA&JNy;blAflCNEHju4qxUd_cciu^`UgiEsQh+0b z_dm^kLY5RaY<8HtHW$rs*A3S=8N;$;A`uCKF9Ak3a1OfQ%T2c>t{Az*N{#Sr>4QA2 zVBYRj8caBGEYOpI8{Az2mBPx$YnD5Z95WE1zWQbRahVx@zXdFul4>2`Wi;Q&Q!ryqLvgVS-WmSp&W>(8&>T2$~~!VeeTB;5tbe|5XcfY)CW(g4pIV>yQx@FvipDVJ#t!R zj3pha*M+^}K=bO5vkl`FY-~Z$yg8slkx8XO{}Y!_9lTSHMQdE`4(aXH{7GFCqG_Jf z>rf71AL>ipH6v!KoOgt){iF%Wg?@o(ct~VM=yxjBE5no&uz`?kkzmtdVICFCO9ISl zH=VvzmnBk1Pz-{13pm2rj z-Ye!Pp8iHkj9=NMb}S0aH{_G2;{pw+%Xfo0kU^>TG}5v0Iri&P4})LDLy?S4*tCKl zaI=c&1>k?fXOi*>oSxJVTLJ4dp94U_s_uy6hsQ7Br_ir^P?S)6H4`!b%+~ly5~Mnp zR2vT|BWJ(>El{3--R4r}9(H`0?U3qe~g6zCv zFGCx%NkUR9m^|-K)UO%a9^)7*O?p^T>x^{A=rmU9S8aF(bWQz49=nuFCkJoXC=-MO z^8zf;&{<%P(PXtj+e!U`OR8U7kVz~=spE|m7C5{!HWL;b27XfO0Tx zgdajgT9#rc-L9o8OE*lEu<>LB==-^^k}`PiC&fMugLjnJebIUv2=2((4N3 z;)UT28tBGA?h{K?dO$G$Xv7BwS4UCE6_gb4M=_jia4#*b?R1j>X~-<-FjePMJESgV zfVwM2&cWdm$YDexB0}sl&viybOAa2+Iw2dc`xT+gBpeVTDehumYuAIEs8@SOEKQmw#=ka&qS*Kq%lk2T=gijgf@m zG*-}UE4k5}IB3iQ6i2>adKQmkgqWI%CCtjDVB7#U%F!8^L`EJ7W8H|1K(pOh}IboipC^?Njh zx~1Vd4SLziR!mN7pUO*Cxtwxh$AX)$|X&bJN_36KN0E2tq)Qvb?_6^#z zxCG>}<(wt&LHquy-Oq*!f+nimG=kU|U+n9V_GMt#3GNs=rGnBY#W>`M!q-bjTSTJ| zrB-xup$w@LogW1$#$lp)qk2>GsZXQly06{}2cS*ASzW!|c$j<1ThcDHg-VfKR-mD1 z(>J;#Hn>gQ+J?rIp;|0>QSpGl<O2K z+q5Ld0$nZKGpBs^dFK-*VvFlPfhu7|5$^V=q-~Y&EYvTzJp6gQHZx95=X;n#CmrX@QLciKcNzFEi zktCu1lAT)(Mt1sLX^CV0|Oi{+-BA zUZ^x|R2-gkIE9J<*=3b0zmOjaFgZ0>*GWxn?e>-`__Euky^RETK6^ zNW4jCJ(7s-azMs472DzUW911&mjICR#}p$5wF_MonQ`w3835sfXhi^BGBdt&;fL|e z=)>YSy#7-2AV&q+JhM;`v)tU1D%a2c{CE5{@HhHjUtpXw#JIRH82S-YU6v}TqmaNg zJj|xJOv(%_SFpxG%qX&vrz%kwm9KXu$1+1t*Y%kG30n>Q#l{~}Cfz&?d3b_rmsj^A zGMSM`d!lvGEjkzqATAyVorlZiO!oyd-0UN~IqVUTbXsB+;loSk3b<8osQbIRCM}9+ zj5shou+!Tx8Nm1jAWiVDpaX%B8K#m*B30>u+Ak(xTUHPTRnAHwz&e;q2J9#~3B)O? zDQV&SiKjh0?G&VPMT0)erlOkIQ6SOD^LYb4gFkxmvyMLS)2fNzF^m}Z{?`^t-M<}8@*tIEqtu9Lp$iKJy} zE1wW>zj^&Re+~RidVmuB7GE7yh@2TCqnsTIs4geA11s5B~9 zzcXpIYkz?1cPARHQpr&MUfLw150vb3>WQ@aGJ;V+CqfBikeQNxvX=Np7%ql}(*4)W zEkLbxmjlHX=M~V<>P+#MMD@M^AY^fv+E@T@uyh0cIKWh7LSIlyUe<^7Wn33X0+gb1 zbya%|DYNV->EjCXx_}ku=Gm!zJ*`yJ2V*?KP-ULMD6>_+3N#tEKiq7#s@pBBb^vH3 zPvnq5(qzIb$^*XXk#o0gr9KbJKDv{HZId%qViay$eC{5B-*OkM#7}y#N&e1)On+2Dpz zmI0-D+L7D82#?FV&)@$O61L*TPO!0SJ}67x`z`D4K8&ip&+T1F;nSj)3+WliimIuP#-)cz$SCw8CQO10T> zhNAQgtVAs2~pL?p5vLpSRFro~l;mXlDjlVmO#;pXiiLMoJZGw^;D) zZ!g%(IHy>vWK;-k=M2SWT4&ug?hYKDm3Pj;X!HUC{wRGR!9p7mOBWr<)So5YQJ9=v zF(+x7gcGiJ_B`s z7hXTb71-$8hN1-rX5ih!x@JrUC+p?f)wQDrV4r1g{*EYsy-VjbhAtc4V#Lk!+}BR4 zyFw=nT^V&M-lEf69;*%0yPfSfGRdF=UByG#w^;lpfk|VZoY=F0at&R_b@jD(L=&2A zR!Ndqphc0+)xJs0wk&q`o?5Xzj2BQ6@10!Er=rqTl6K8bS*nVyb};)mDXmm$%%-0* zcMPz$CAKOq;R-nlK(OjgVq;nQ<|w!uh*BFSKiipppm<}(S+y-n@A{+nAHQm=F2C3h z(JJtrTu5vh6cJnGl?RsE-A0At5r+x`HR)x19xj(Rx@ch;lXoGP=IT8{Ek9RgOTpZi zZ2I`u6$3H?ZDA?vW@pfqa0Gh z-PIOEKpb-yKCXVH@U9qZL0ok$Ku-B|b0rT<;Xz4J37%-blz6>4Uv;6+(lCu{l4kZ* ziTvFjUwgBwesGPuLY(2|Yde=rdpNmdmoH`0cC=TS95p#Kx=m6*L^9)&faXLplQdty z3a@|UXA9ec&_gTY=5U=6XWqkrv?pV&SdZ`&ofpN9q>KmlKWZQjrCi#50$?Wj0S11A zg29HXJ(Lod^z8gt!8K6Y>_W+37^yi@@OOB;8@?SI?1w9`jWBIqIKsb&1JtLY@2=C5 z$pKJ@7`t=lqh!vMsX7o(PH^J5OXvhmY13w@bQ100n^X>1k}r4k#iFu;(nnlk@~gw+MOY54R~1Vg zO0J5pS++rCp?bG=URP*X*?)Tg`F)4c7!8Z3?0G!5T@SW8=r_iEcw!kWFC30Sev+=N zR8~yPi$s?K0xlhQBterAa1$1}+AC$>7YM?U71Jm6Lm#EjQKiUS#Y8GGC5%e>4Jefo zBzq}o!So|KE$us?Ur^k@n6)Q?nbM+~_w0P0B0%=`;p7LtDlj-5v|%ZrR#r&S)7if% z%C2buDJsS_Jnh)dmR+PLlw8;V%hk>?Vqp1_2#eJP@Qmqfp#_&uW9tK05yB(R&0i&Q zvWs zr~@DetCspCefsf z%qR0HlOh}7&0_@+*4L>XuBU!dUq$;2sQgUbUpIsowMod~8#{0lmTiw2Tq*y%YnJ8E z4&RP9yq~>|MI4v^C;z`i)@R6UMd}?(R7_DN0eg|w8OaZM+xAQ%I1$t6OrzFa8OlA5 z$nl+1h<1p2&up70eW3$2Rq0i&;Vq%>Q(V=7q^@Y}Coa{^VH!%7Ztefi*qbd$b6jVF z_xTh~^^A>VP4WRoZOwTTna7fmkr^9e$*iccX_G|j%bAhxB%7Ni2rk%25Cj1d;9^#P z;l1X3$Io{>3X*IFG~%!NQI#1P;ePxq-xA5Yto!L`sf)(Dv$xd@Tz;=$Z)4hEU1BaI zL)PI2>0RYul8_~B3Kcdpn(c~8!ag!sghj)+gKuYN`0EESZchIW$8Rty*#p&SgLH!lO{t5eGos<~L}r-{HAQiKc@%$u%g z8308?==|DvNloia$jogscsvD~~Fi7phs!xt*jpZEEZzNyq}uFlK*lJPze~2+w=XIswO6 zvmqeYH&COZ#UXaF&fUE~6#F9>ktqW0JmEG_8y29oH~S$#=F^>lHOZ`u$@ezUUK#L4 zn9Q)X2)w5OjcN?=FQb(k4SHGiye3h7FEA9%c$)lNJlBd_%kn>xom3##P~c~9#`tEK zL2WG)4?9#k6v6Iy1fANv*;U|)T@r@0*)ac~GckR0p|I88q?4OW9E$uZPnEN7W(Wup ze1~ordI{(y5?cRg7tjN- z^U4TWv&zAt<8kxOn|A=-eT34=P#G5>@G~Y}<%!cJt6m|!7?5DohBmso=Q_&s1UR(K z(j()Uvuc$shWcRgwBUef8G_&6l{f%(yJ=k^rf7*5exwcvJXO4ccmQ&iz5-HTb?B{J zGtY|$Rn@Lh4SvuAT2~Juc!u87p5%zXV487|CzM<~3-S~PaciZ&e3V!)AK4uPrC}XU z5TLZ;DS;eS>F~3I@{h$4kO`YBl`& zr_&Qy!i6drNZF>MfzwI7ZHFA()2-=zleE2RP%-b-m1@WS8MCqco6tfkl9~oQE7T#o zN&|{>H`0nl@;vqbF70mi(7X3-T6Wm9JfN@(M&7wEgAK7;p5xFkmbb`!AO-Ku?3C}` z!7LmOia`bE-}0R0;cZq*f&G99n=1bUA;3#QLbZU*KSFyOu2E>MSPcUk(amZ1)hHjW zxolMWQfC3gqcn18X$aC3M9HW&NUOscd5e*Wy1MS#lULu}ZU;IJ{Xl0T8Wfq~L*2N7*CJJxJcWLMEe2V2Yn!tMxix!~ z)dw`cLI0Ftzi?H;*IT`Nf2S6{FA21`!l5G@&7kL-D*YsY&aDPFN7Xx6uO;>fD`Fy*g!-o4m`PoMj>ECRJOU`cjVB{6f|f#Mz7hScc`y z_nuX|j%%umz|x0i(0_k zxKQfqwCs>&DK<7@It=DIAJ>~LspY*=`1QNIs1}=`!w|~%?T=qSPX%{4ev_W2<6U$T zM!ko##2f3D4IsdeTzIk)pkbbV_gtpoD_SuUuc4e@m`H5aS(UTp#I1SeZn&tr3cLOP5=+y-PV_Jjv@_3hIl>5S{jsTXaG?PR5*$PYe~cWU~B}1{XH)sKP_4J+?rd`J-Ev$-*GVq@K$>I)Yoab;i-;sa^gM zSxZT0EO6MfIz7^4Rl>4cv~DM~f}YgeAM6Uh{*??ze0J@?YCV|Z>EN~F-0 zl+5!V42djo4xu?gScf`LsvA48d7iqxgB-qN~ zhQh7wU7}Rs+r;K)iK;inCQL??LD#`biKo=1mHk=D@&ogU3UZwzh8p#uHF(dDUp};a z2zD=QC`nLyvgJ@G&5cK!ElGBCM$(qFiP0CQXY4hjEMT*7r%_S@RF!A%({oTTf<;Pr zqa1|j$A?uadH4L;`mDdbY_8i41TOnSY6*utNCL8hi#o3XB!F;sJ2pBzRlZ#brfCv^ zlRx1L)bCWAsgs-;#SC!RGz=x@EnH7`pPE1b$?h;A3p z7Wzkv;}iSwd_EXURfZ^uc))~bnT@mofmXP`Akb-t9CD**R>*l+)R)}qggT^E@}n9z zr#Fvt0_=1yPd=xvF{4+rom3-9d6?KYWm0NzbImyHWXTRb=3kPkyrtDp*!WTwxGKm4 zpRxD_6c`b?x8nPp6A|db*3aT z0je%g+5oTbzFT%ZuV1@{&L7gp!V;0ARnE}eG(57`Wf{TD*S{nRI}t%HnJlrFpugkN&MPe zb{`ARm8dkJGmap$CA8-CE7)>MxV35@S&-@oLGUEd)uaohwe$cqjj0qLIah~kN~bRO zZjmxxtW@vRMY2m#@R?dPrJPufiw^9pUC!D(+txOU;+`Ylu54 zHI+x*4X{mh799D+Fw&NnDj0?kqi)RSrg0%#XB+w!NGPAa!JD{|vf;jVq9^E3Dn~fvlsE#-|itigy2?6X-C4&gmzJG?kBSle4K4 zG!Z%P?V8>bBncNpIV+UuXfb7Z%A{uW>BY9({OMtl`9>4?i}3Q3(>~bvX;SD)EkW?E z1kv>NOq^W9Rbp3&(+26+l6qeU$v~jeB*W?03v1-ew)-<|x^y|0lJk9mfnLYmh}8qB z?NfuHqaWWWfI=K?M0G|VgP!T&yZ|NC{3eq<-%6v%v=gI;e>} zLL*sz)T&TYkQ*zy_N};ZL({l&h8_q`+<}aW#AC8dPUTNz`_fISl>-CvL)M`U&!@#% zc1t*$Dqrf*xRW4eUT4n+H&+erYG;Jqp!`YRm(F-NIg-7!p`to1nu%Igs`zTUaHBT~ zTFDAZHfbhxSeRkA5GvCq8mmwYOe2*UtM)AK;g_q`=MJ^6*<0bWd}_0s7#H)ctR-|etQe;r;vJjj;H(ev)p*H109s|CA@AncNf$l9%mT_1vR=%8Ue9i~4^ zoswdrVVYS>9ir}9v+ccVHx1_~H(0wV5Jl%ler)eCof6Vt*psvogH z*r5;2z-J)2pbcu^QlG9E^S=$!vSHZ_G5~B!@P#LjsqD6JFhPNMMNKvMv+R6pe3gMU zk@5qR?T;i%x6>Uh|Kg;`D4sA~-Ke-TIS2|UwaA!C0Cj7y$KR*y-d23}WG=Ca;?`VX zyJ%ZfHI;w$midh%+~Ad9dd+g{RYKV3J8_ZRHCrq#7%qU)gm#9!x)k3P*xmu2wkNm? zWpEa#1%0A|F7fvQOLDQFPf3 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

Rp5@H-63rPkl?5M!`%e$q5M^(XmdeOwiW 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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG 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

nj;X-C@gua07)qPBmS6kxKbsrp_1VbHQ%kr&^ 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�J#6HekB- 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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9> 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

brXZX@VYhc!=SFxwhp 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 z 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

B0o?DtF!VT!YjrDC^S2?RV?P>**rUM?tSk)et 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 literal 0 HcmV?d00001 diff --git a/CLIP/clip/clip.py b/CLIP/clip/clip.py new file mode 100644 index 0000000..cedac5f --- /dev/null +++ b/CLIP/clip/clip.py @@ -0,0 +1,244 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str, amlt_root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + + amlt_download_target = os.path.join(amlt_root, filename) + if os.path.isfile(amlt_download_target): + if hashlib.sha256(open(amlt_download_target, "rb").read()).hexdigest() == expected_sha256: + return amlt_download_target + + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + # Use an amlt_root for amulet. + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip"), amlt_root='/mnt/default/pretrained_weights') + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/CLIP/clip/model.py b/CLIP/clip/model.py new file mode 100644 index 0000000..232b779 --- /dev/null +++ b/CLIP/clip/model.py @@ -0,0 +1,436 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu1(self.bn1(self.conv1(x))) + out = self.relu2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x[:1], key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + return x.squeeze(0) + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.relu3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=1, keepdim=True) + text_features = text_features / text_features.norm(dim=1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/CLIP/clip/simple_tokenizer.py b/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000..0a66286 --- /dev/null +++ b/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/CLIP/data/country211.md b/CLIP/data/country211.md new file mode 100644 index 0000000..4cd0960 --- /dev/null +++ b/CLIP/data/country211.md @@ -0,0 +1,12 @@ +# The Country211 Dataset + +In the paper, we used an image classification dataset called Country211, to evaluate the model's capability on geolocation. To do so, we filtered the YFCC100m dataset that have GPS coordinate corresponding to a [ISO-3166 country code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) and created a balanced dataset by sampling 150 train images, 50 validation images, and 100 test images images for each country. + +The following command will download an 11GB archive countaining the images and extract into a subdirectory `country211`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/country211.tgz +tar zxvf country211.tgz +``` + +These images are a subset of the YFCC100m dataset. Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/data/prompts.md b/CLIP/data/prompts.md new file mode 100644 index 0000000..6d8aaf7 --- /dev/null +++ b/CLIP/data/prompts.md @@ -0,0 +1,3401 @@ +# Prompts for Image Classification + +Below are the class names and templates that are used for collecting the zero-shot classification scores in the paper. Each dataset has two lists `classes` and `templates`, where the string `{}` in the template is to be replaced with the corresponding class names. For the Facial Emotion Recognition 2013 dataset specifically, we used multiple class names for certain classes. + +This file contains prompt data for 26 of the 27 datasets shown in Table 9 of the paper; the text prompts for ImageNet (as well as other [ImageNet Testbed](https://modestyachts.github.io/imagenet-testbed/) datasets in Figure 13) can be found in [this notebook](https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb), as well as how to ensemble predictions from multiple prompts using these templates. + +If you are viewing this document on GitHub, use the table of contents icon at the upper left to browse the datasets. + + +## Birdsnap + +```bash +classes = [ + 'Acadian Flycatcher', + 'Acorn Woodpecker', + 'Alder Flycatcher', + 'Allens Hummingbird', + 'Altamira Oriole', + 'American Avocet', + 'American Bittern', + 'American Black Duck', + 'American Coot', + 'American Crow', + 'American Dipper', + 'American Golden Plover', + 'American Goldfinch', + 'American Kestrel', + 'American Oystercatcher', + 'American Pipit', + 'American Redstart', + 'American Robin', + 'American Three toed Woodpecker', + 'American Tree Sparrow', + 'American White Pelican', + 'American Wigeon', + 'American Woodcock', + 'Anhinga', + 'Annas Hummingbird', + 'Arctic Tern', + 'Ash throated Flycatcher', + 'Audubons Oriole', + 'Bairds Sandpiper', + 'Bald Eagle', + 'Baltimore Oriole', + 'Band tailed Pigeon', + 'Barn Swallow', + 'Barred Owl', + 'Barrows Goldeneye', + 'Bay breasted Warbler', + 'Bells Vireo', + 'Belted Kingfisher', + 'Bewicks Wren', + 'Black Guillemot', + 'Black Oystercatcher', + 'Black Phoebe', + 'Black Rosy Finch', + 'Black Scoter', + 'Black Skimmer', + 'Black Tern', + 'Black Turnstone', + 'Black Vulture', + 'Black and white Warbler', + 'Black backed Woodpecker', + 'Black bellied Plover', + 'Black billed Cuckoo', + 'Black billed Magpie', + 'Black capped Chickadee', + 'Black chinned Hummingbird', + 'Black chinned Sparrow', + 'Black crested Titmouse', + 'Black crowned Night Heron', + 'Black headed Grosbeak', + 'Black legged Kittiwake', + 'Black necked Stilt', + 'Black throated Blue Warbler', + 'Black throated Gray Warbler', + 'Black throated Green Warbler', + 'Black throated Sparrow', + 'Blackburnian Warbler', + 'Blackpoll Warbler', + 'Blue Grosbeak', + 'Blue Jay', + 'Blue gray Gnatcatcher', + 'Blue headed Vireo', + 'Blue winged Teal', + 'Blue winged Warbler', + 'Boat tailed Grackle', + 'Bobolink', + 'Bohemian Waxwing', + 'Bonapartes Gull', + 'Boreal Chickadee', + 'Brandts Cormorant', + 'Brant', + 'Brewers Blackbird', + 'Brewers Sparrow', + 'Bridled Titmouse', + 'Broad billed Hummingbird', + 'Broad tailed Hummingbird', + 'Broad winged Hawk', + 'Bronzed Cowbird', + 'Brown Creeper', + 'Brown Pelican', + 'Brown Thrasher', + 'Brown capped Rosy Finch', + 'Brown crested Flycatcher', + 'Brown headed Cowbird', + 'Brown headed Nuthatch', + 'Bufflehead', + 'Bullocks Oriole', + 'Burrowing Owl', + 'Bushtit', + 'Cackling Goose', + 'Cactus Wren', + 'California Gull', + 'California Quail', + 'California Thrasher', + 'California Towhee', + 'Calliope Hummingbird', + 'Canada Goose', + 'Canada Warbler', + 'Canvasback', + 'Canyon Towhee', + 'Canyon Wren', + 'Cape May Warbler', + 'Carolina Chickadee', + 'Carolina Wren', + 'Caspian Tern', + 'Cassins Finch', + 'Cassins Kingbird', + 'Cassins Sparrow', + 'Cassins Vireo', + 'Cattle Egret', + 'Cave Swallow', + 'Cedar Waxwing', + 'Cerulean Warbler', + 'Chestnut backed Chickadee', + 'Chestnut collared Longspur', + 'Chestnut sided Warbler', + 'Chihuahuan Raven', + 'Chimney Swift', + 'Chipping Sparrow', + 'Cinnamon Teal', + 'Clapper Rail', + 'Clarks Grebe', + 'Clarks Nutcracker', + 'Clay colored Sparrow', + 'Cliff Swallow', + 'Common Black Hawk', + 'Common Eider', + 'Common Gallinule', + 'Common Goldeneye', + 'Common Grackle', + 'Common Ground Dove', + 'Common Loon', + 'Common Merganser', + 'Common Murre', + 'Common Nighthawk', + 'Common Raven', + 'Common Redpoll', + 'Common Tern', + 'Common Yellowthroat', + 'Connecticut Warbler', + 'Coopers Hawk', + 'Cordilleran Flycatcher', + 'Costas Hummingbird', + 'Couchs Kingbird', + 'Crested Caracara', + 'Curve billed Thrasher', + 'Dark eyed Junco', + 'Dickcissel', + 'Double crested Cormorant', + 'Downy Woodpecker', + 'Dunlin', + 'Dusky Flycatcher', + 'Dusky Grouse', + 'Eared Grebe', + 'Eastern Bluebird', + 'Eastern Kingbird', + 'Eastern Meadowlark', + 'Eastern Phoebe', + 'Eastern Screech Owl', + 'Eastern Towhee', + 'Eastern Wood Pewee', + 'Elegant Trogon', + 'Elf Owl', + 'Eurasian Collared Dove', + 'Eurasian Wigeon', + 'European Starling', + 'Evening Grosbeak', + 'Ferruginous Hawk', + 'Ferruginous Pygmy Owl', + 'Field Sparrow', + 'Fish Crow', + 'Florida Scrub Jay', + 'Forsters Tern', + 'Fox Sparrow', + 'Franklins Gull', + 'Fulvous Whistling Duck', + 'Gadwall', + 'Gambels Quail', + 'Gila Woodpecker', + 'Glaucous Gull', + 'Glaucous winged Gull', + 'Glossy Ibis', + 'Golden Eagle', + 'Golden crowned Kinglet', + 'Golden crowned Sparrow', + 'Golden fronted Woodpecker', + 'Golden winged Warbler', + 'Grasshopper Sparrow', + 'Gray Catbird', + 'Gray Flycatcher', + 'Gray Jay', + 'Gray Kingbird', + 'Gray cheeked Thrush', + 'Gray crowned Rosy Finch', + 'Great Black backed Gull', + 'Great Blue Heron', + 'Great Cormorant', + 'Great Crested Flycatcher', + 'Great Egret', + 'Great Gray Owl', + 'Great Horned Owl', + 'Great Kiskadee', + 'Great tailed Grackle', + 'Greater Prairie Chicken', + 'Greater Roadrunner', + 'Greater Sage Grouse', + 'Greater Scaup', + 'Greater White fronted Goose', + 'Greater Yellowlegs', + 'Green Jay', + 'Green tailed Towhee', + 'Green winged Teal', + 'Groove billed Ani', + 'Gull billed Tern', + 'Hairy Woodpecker', + 'Hammonds Flycatcher', + 'Harlequin Duck', + 'Harriss Hawk', + 'Harriss Sparrow', + 'Heermanns Gull', + 'Henslows Sparrow', + 'Hepatic Tanager', + 'Hermit Thrush', + 'Herring Gull', + 'Hoary Redpoll', + 'Hooded Merganser', + 'Hooded Oriole', + 'Hooded Warbler', + 'Horned Grebe', + 'Horned Lark', + 'House Finch', + 'House Sparrow', + 'House Wren', + 'Huttons Vireo', + 'Iceland Gull', + 'Inca Dove', + 'Indigo Bunting', + 'Killdeer', + 'King Rail', + 'Ladder backed Woodpecker', + 'Lapland Longspur', + 'Lark Bunting', + 'Lark Sparrow', + 'Laughing Gull', + 'Lazuli Bunting', + 'Le Contes Sparrow', + 'Least Bittern', + 'Least Flycatcher', + 'Least Grebe', + 'Least Sandpiper', + 'Least Tern', + 'Lesser Goldfinch', + 'Lesser Nighthawk', + 'Lesser Scaup', + 'Lesser Yellowlegs', + 'Lewiss Woodpecker', + 'Limpkin', + 'Lincolns Sparrow', + 'Little Blue Heron', + 'Loggerhead Shrike', + 'Long billed Curlew', + 'Long billed Dowitcher', + 'Long billed Thrasher', + 'Long eared Owl', + 'Long tailed Duck', + 'Louisiana Waterthrush', + 'Magnificent Frigatebird', + 'Magnolia Warbler', + 'Mallard', + 'Marbled Godwit', + 'Marsh Wren', + 'Merlin', + 'Mew Gull', + 'Mexican Jay', + 'Mississippi Kite', + 'Monk Parakeet', + 'Mottled Duck', + 'Mountain Bluebird', + 'Mountain Chickadee', + 'Mountain Plover', + 'Mourning Dove', + 'Mourning Warbler', + 'Muscovy Duck', + 'Mute Swan', + 'Nashville Warbler', + 'Nelsons Sparrow', + 'Neotropic Cormorant', + 'Northern Bobwhite', + 'Northern Cardinal', + 'Northern Flicker', + 'Northern Gannet', + 'Northern Goshawk', + 'Northern Harrier', + 'Northern Hawk Owl', + 'Northern Mockingbird', + 'Northern Parula', + 'Northern Pintail', + 'Northern Rough winged Swallow', + 'Northern Saw whet Owl', + 'Northern Shrike', + 'Northern Waterthrush', + 'Nuttalls Woodpecker', + 'Oak Titmouse', + 'Olive Sparrow', + 'Olive sided Flycatcher', + 'Orange crowned Warbler', + 'Orchard Oriole', + 'Osprey', + 'Ovenbird', + 'Pacific Golden Plover', + 'Pacific Loon', + 'Pacific Wren', + 'Pacific slope Flycatcher', + 'Painted Bunting', + 'Painted Redstart', + 'Palm Warbler', + 'Pectoral Sandpiper', + 'Peregrine Falcon', + 'Phainopepla', + 'Philadelphia Vireo', + 'Pied billed Grebe', + 'Pigeon Guillemot', + 'Pileated Woodpecker', + 'Pine Grosbeak', + 'Pine Siskin', + 'Pine Warbler', + 'Piping Plover', + 'Plumbeous Vireo', + 'Prairie Falcon', + 'Prairie Warbler', + 'Prothonotary Warbler', + 'Purple Finch', + 'Purple Gallinule', + 'Purple Martin', + 'Purple Sandpiper', + 'Pygmy Nuthatch', + 'Pyrrhuloxia', + 'Red Crossbill', + 'Red Knot', + 'Red Phalarope', + 'Red bellied Woodpecker', + 'Red breasted Merganser', + 'Red breasted Nuthatch', + 'Red breasted Sapsucker', + 'Red cockaded Woodpecker', + 'Red eyed Vireo', + 'Red headed Woodpecker', + 'Red naped Sapsucker', + 'Red necked Grebe', + 'Red necked Phalarope', + 'Red shouldered Hawk', + 'Red tailed Hawk', + 'Red throated Loon', + 'Red winged Blackbird', + 'Reddish Egret', + 'Redhead', + 'Ring billed Gull', + 'Ring necked Duck', + 'Ring necked Pheasant', + 'Rock Pigeon', + 'Rock Ptarmigan', + 'Rock Sandpiper', + 'Rock Wren', + 'Rose breasted Grosbeak', + 'Roseate Tern', + 'Rosss Goose', + 'Rough legged Hawk', + 'Royal Tern', + 'Ruby crowned Kinglet', + 'Ruby throated Hummingbird', + 'Ruddy Duck', + 'Ruddy Turnstone', + 'Ruffed Grouse', + 'Rufous Hummingbird', + 'Rufous crowned Sparrow', + 'Rusty Blackbird', + 'Sage Thrasher', + 'Saltmarsh Sparrow', + 'Sanderling', + 'Sandhill Crane', + 'Sandwich Tern', + 'Says Phoebe', + 'Scaled Quail', + 'Scarlet Tanager', + 'Scissor tailed Flycatcher', + 'Scotts Oriole', + 'Seaside Sparrow', + 'Sedge Wren', + 'Semipalmated Plover', + 'Semipalmated Sandpiper', + 'Sharp shinned Hawk', + 'Sharp tailed Grouse', + 'Short billed Dowitcher', + 'Short eared Owl', + 'Snail Kite', + 'Snow Bunting', + 'Snow Goose', + 'Snowy Egret', + 'Snowy Owl', + 'Snowy Plover', + 'Solitary Sandpiper', + 'Song Sparrow', + 'Sooty Grouse', + 'Sora', + 'Spotted Owl', + 'Spotted Sandpiper', + 'Spotted Towhee', + 'Spruce Grouse', + 'Stellers Jay', + 'Stilt Sandpiper', + 'Summer Tanager', + 'Surf Scoter', + 'Surfbird', + 'Swainsons Hawk', + 'Swainsons Thrush', + 'Swallow tailed Kite', + 'Swamp Sparrow', + 'Tennessee Warbler', + 'Thayers Gull', + 'Townsends Solitaire', + 'Townsends Warbler', + 'Tree Swallow', + 'Tricolored Heron', + 'Tropical Kingbird', + 'Trumpeter Swan', + 'Tufted Titmouse', + 'Tundra Swan', + 'Turkey Vulture', + 'Upland Sandpiper', + 'Varied Thrush', + 'Veery', + 'Verdin', + 'Vermilion Flycatcher', + 'Vesper Sparrow', + 'Violet green Swallow', + 'Virginia Rail', + 'Wandering Tattler', + 'Warbling Vireo', + 'Western Bluebird', + 'Western Grebe', + 'Western Gull', + 'Western Kingbird', + 'Western Meadowlark', + 'Western Sandpiper', + 'Western Screech Owl', + 'Western Scrub Jay', + 'Western Tanager', + 'Western Wood Pewee', + 'Whimbrel', + 'White Ibis', + 'White breasted Nuthatch', + 'White crowned Sparrow', + 'White eyed Vireo', + 'White faced Ibis', + 'White headed Woodpecker', + 'White rumped Sandpiper', + 'White tailed Hawk', + 'White tailed Kite', + 'White tailed Ptarmigan', + 'White throated Sparrow', + 'White throated Swift', + 'White winged Crossbill', + 'White winged Dove', + 'White winged Scoter', + 'Wild Turkey', + 'Willet', + 'Williamsons Sapsucker', + 'Willow Flycatcher', + 'Willow Ptarmigan', + 'Wilsons Phalarope', + 'Wilsons Plover', + 'Wilsons Snipe', + 'Wilsons Warbler', + 'Winter Wren', + 'Wood Stork', + 'Wood Thrush', + 'Worm eating Warbler', + 'Wrentit', + 'Yellow Warbler', + 'Yellow bellied Flycatcher', + 'Yellow bellied Sapsucker', + 'Yellow billed Cuckoo', + 'Yellow billed Magpie', + 'Yellow breasted Chat', + 'Yellow crowned Night Heron', + 'Yellow eyed Junco', + 'Yellow headed Blackbird', + 'Yellow rumped Warbler', + 'Yellow throated Vireo', + 'Yellow throated Warbler', + 'Zone tailed Hawk', +] + +templates = [ + 'a photo of a {}, a type of bird.', +] +``` + + + +## CIFAR10 + +```bash +classes = [ + 'airplane', + 'automobile', + 'bird', + 'cat', + 'deer', + 'dog', + 'frog', + 'horse', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CIFAR100 + +```bash +classes = [ + 'apple', + 'aquarium fish', + 'baby', + 'bear', + 'beaver', + 'bed', + 'bee', + 'beetle', + 'bicycle', + 'bottle', + 'bowl', + 'boy', + 'bridge', + 'bus', + 'butterfly', + 'camel', + 'can', + 'castle', + 'caterpillar', + 'cattle', + 'chair', + 'chimpanzee', + 'clock', + 'cloud', + 'cockroach', + 'couch', + 'crab', + 'crocodile', + 'cup', + 'dinosaur', + 'dolphin', + 'elephant', + 'flatfish', + 'forest', + 'fox', + 'girl', + 'hamster', + 'house', + 'kangaroo', + 'keyboard', + 'lamp', + 'lawn mower', + 'leopard', + 'lion', + 'lizard', + 'lobster', + 'man', + 'maple tree', + 'motorcycle', + 'mountain', + 'mouse', + 'mushroom', + 'oak tree', + 'orange', + 'orchid', + 'otter', + 'palm tree', + 'pear', + 'pickup truck', + 'pine tree', + 'plain', + 'plate', + 'poppy', + 'porcupine', + 'possum', + 'rabbit', + 'raccoon', + 'ray', + 'road', + 'rocket', + 'rose', + 'sea', + 'seal', + 'shark', + 'shrew', + 'skunk', + 'skyscraper', + 'snail', + 'snake', + 'spider', + 'squirrel', + 'streetcar', + 'sunflower', + 'sweet pepper', + 'table', + 'tank', + 'telephone', + 'television', + 'tiger', + 'tractor', + 'train', + 'trout', + 'tulip', + 'turtle', + 'wardrobe', + 'whale', + 'willow tree', + 'wolf', + 'woman', + 'worm', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CLEVRCounts + +```bash +classes = [ + '10', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of {} objects.', +] +``` + + + +## Caltech101 + +```bash +classes = [ + 'background', + 'off-center face', + 'centered face', + 'leopard', + 'motorbike', + 'accordion', + 'airplane', + 'anchor', + 'ant', + 'barrel', + 'bass', + 'beaver', + 'binocular', + 'bonsai', + 'brain', + 'brontosaurus', + 'buddha', + 'butterfly', + 'camera', + 'cannon', + 'side of a car', + 'ceiling fan', + 'cellphone', + 'chair', + 'chandelier', + 'body of a cougar cat', + 'face of a cougar cat', + 'crab', + 'crayfish', + 'crocodile', + 'head of a crocodile', + 'cup', + 'dalmatian', + 'dollar bill', + 'dolphin', + 'dragonfly', + 'electric guitar', + 'elephant', + 'emu', + 'euphonium', + 'ewer', + 'ferry', + 'flamingo', + 'head of a flamingo', + 'garfield', + 'gerenuk', + 'gramophone', + 'grand piano', + 'hawksbill', + 'headphone', + 'hedgehog', + 'helicopter', + 'ibis', + 'inline skate', + 'joshua tree', + 'kangaroo', + 'ketch', + 'lamp', + 'laptop', + 'llama', + 'lobster', + 'lotus', + 'mandolin', + 'mayfly', + 'menorah', + 'metronome', + 'minaret', + 'nautilus', + 'octopus', + 'okapi', + 'pagoda', + 'panda', + 'pigeon', + 'pizza', + 'platypus', + 'pyramid', + 'revolver', + 'rhino', + 'rooster', + 'saxophone', + 'schooner', + 'scissors', + 'scorpion', + 'sea horse', + 'snoopy (cartoon beagle)', + 'soccer ball', + 'stapler', + 'starfish', + 'stegosaurus', + 'stop sign', + 'strawberry', + 'sunflower', + 'tick', + 'trilobite', + 'umbrella', + 'watch', + 'water lilly', + 'wheelchair', + 'wild cat', + 'windsor chair', + 'wrench', + 'yin and yang symbol', +] + +templates = [ + 'a photo of a {}.', + 'a painting of a {}.', + 'a plastic {}.', + 'a sculpture of a {}.', + 'a sketch of a {}.', + 'a tattoo of a {}.', + 'a toy {}.', + 'a rendition of a {}.', + 'a embroidered {}.', + 'a cartoon {}.', + 'a {} in a video game.', + 'a plushie {}.', + 'a origami {}.', + 'art of a {}.', + 'graffiti of a {}.', + 'a drawing of a {}.', + 'a doodle of a {}.', + 'a photo of the {}.', + 'a painting of the {}.', + 'the plastic {}.', + 'a sculpture of the {}.', + 'a sketch of the {}.', + 'a tattoo of the {}.', + 'the toy {}.', + 'a rendition of the {}.', + 'the embroidered {}.', + 'the cartoon {}.', + 'the {} in a video game.', + 'the plushie {}.', + 'the origami {}.', + 'art of the {}.', + 'graffiti of the {}.', + 'a drawing of the {}.', + 'a doodle of the {}.', +] +``` + + + +## Country211 + +```bash +classes = [ + 'Andorra', + 'United Arab Emirates', + 'Afghanistan', + 'Antigua and Barbuda', + 'Anguilla', + 'Albania', + 'Armenia', + 'Angola', + 'Antarctica', + 'Argentina', + 'Austria', + 'Australia', + 'Aruba', + 'Aland Islands', + 'Azerbaijan', + 'Bosnia and Herzegovina', + 'Barbados', + 'Bangladesh', + 'Belgium', + 'Burkina Faso', + 'Bulgaria', + 'Bahrain', + 'Benin', + 'Bermuda', + 'Brunei Darussalam', + 'Bolivia', + 'Bonaire, Saint Eustatius and Saba', + 'Brazil', + 'Bahamas', + 'Bhutan', + 'Botswana', + 'Belarus', + 'Belize', + 'Canada', + 'DR Congo', + 'Central African Republic', + 'Switzerland', + "Cote d'Ivoire", + 'Cook Islands', + 'Chile', + 'Cameroon', + 'China', + 'Colombia', + 'Costa Rica', + 'Cuba', + 'Cabo Verde', + 'Curacao', + 'Cyprus', + 'Czech Republic', + 'Germany', + 'Denmark', + 'Dominica', + 'Dominican Republic', + 'Algeria', + 'Ecuador', + 'Estonia', + 'Egypt', + 'Spain', + 'Ethiopia', + 'Finland', + 'Fiji', + 'Falkland Islands', + 'Faeroe Islands', + 'France', + 'Gabon', + 'United Kingdom', + 'Grenada', + 'Georgia', + 'French Guiana', + 'Guernsey', + 'Ghana', + 'Gibraltar', + 'Greenland', + 'Gambia', + 'Guadeloupe', + 'Greece', + 'South Georgia and South Sandwich Is.', + 'Guatemala', + 'Guam', + 'Guyana', + 'Hong Kong', + 'Honduras', + 'Croatia', + 'Haiti', + 'Hungary', + 'Indonesia', + 'Ireland', + 'Israel', + 'Isle of Man', + 'India', + 'Iraq', + 'Iran', + 'Iceland', + 'Italy', + 'Jersey', + 'Jamaica', + 'Jordan', + 'Japan', + 'Kenya', + 'Kyrgyz Republic', + 'Cambodia', + 'St. Kitts and Nevis', + 'North Korea', + 'South Korea', + 'Kuwait', + 'Cayman Islands', + 'Kazakhstan', + 'Laos', + 'Lebanon', + 'St. Lucia', + 'Liechtenstein', + 'Sri Lanka', + 'Liberia', + 'Lithuania', + 'Luxembourg', + 'Latvia', + 'Libya', + 'Morocco', + 'Monaco', + 'Moldova', + 'Montenegro', + 'Saint-Martin', + 'Madagascar', + 'Macedonia', + 'Mali', + 'Myanmar', + 'Mongolia', + 'Macau', + 'Martinique', + 'Mauritania', + 'Malta', + 'Mauritius', + 'Maldives', + 'Malawi', + 'Mexico', + 'Malaysia', + 'Mozambique', + 'Namibia', + 'New Caledonia', + 'Nigeria', + 'Nicaragua', + 'Netherlands', + 'Norway', + 'Nepal', + 'New Zealand', + 'Oman', + 'Panama', + 'Peru', + 'French Polynesia', + 'Papua New Guinea', + 'Philippines', + 'Pakistan', + 'Poland', + 'Puerto Rico', + 'Palestine', + 'Portugal', + 'Palau', + 'Paraguay', + 'Qatar', + 'Reunion', + 'Romania', + 'Serbia', + 'Russia', + 'Rwanda', + 'Saudi Arabia', + 'Solomon Islands', + 'Seychelles', + 'Sudan', + 'Sweden', + 'Singapore', + 'St. Helena', + 'Slovenia', + 'Svalbard and Jan Mayen Islands', + 'Slovakia', + 'Sierra Leone', + 'San Marino', + 'Senegal', + 'Somalia', + 'South Sudan', + 'El Salvador', + 'Sint Maarten', + 'Syria', + 'Eswatini', + 'Togo', + 'Thailand', + 'Tajikistan', + 'Timor-Leste', + 'Turkmenistan', + 'Tunisia', + 'Tonga', + 'Turkey', + 'Trinidad and Tobago', + 'Taiwan', + 'Tanzania', + 'Ukraine', + 'Uganda', + 'United States', + 'Uruguay', + 'Uzbekistan', + 'Vatican', + 'Venezuela', + 'British Virgin Islands', + 'United States Virgin Islands', + 'Vietnam', + 'Vanuatu', + 'Samoa', + 'Kosovo', + 'Yemen', + 'South Africa', + 'Zambia', + 'Zimbabwe', +] + +templates = [ + 'a photo i took in {}.', + 'a photo i took while visiting {}.', + 'a photo from my home country of {}.', + 'a photo from my visit to {}.', + 'a photo showing the country of {}.', +] +``` + + + +## DescribableTextures + +```bash +classes = [ + 'banded', + 'blotchy', + 'braided', + 'bubbly', + 'bumpy', + 'chequered', + 'cobwebbed', + 'cracked', + 'crosshatched', + 'crystalline', + 'dotted', + 'fibrous', + 'flecked', + 'freckled', + 'frilly', + 'gauzy', + 'grid', + 'grooved', + 'honeycombed', + 'interlaced', + 'knitted', + 'lacelike', + 'lined', + 'marbled', + 'matted', + 'meshed', + 'paisley', + 'perforated', + 'pitted', + 'pleated', + 'polka-dotted', + 'porous', + 'potholed', + 'scaly', + 'smeared', + 'spiralled', + 'sprinkled', + 'stained', + 'stratified', + 'striped', + 'studded', + 'swirly', + 'veined', + 'waffled', + 'woven', + 'wrinkled', + 'zigzagged', +] + +templates = [ + 'a photo of a {} texture.', + 'a photo of a {} pattern.', + 'a photo of a {} thing.', + 'a photo of a {} object.', + 'a photo of the {} texture.', + 'a photo of the {} pattern.', + 'a photo of the {} thing.', + 'a photo of the {} object.', +] +``` + + + +## EuroSAT + +```bash +classes = [ + 'forest', + 'permanent crop land', + 'residential buildings or homes or apartments', + 'river', + 'pasture land', + 'lake or sea', + 'brushland or shrubland', + 'annual crop land', + 'industrial buildings or commercial buildings', + 'highway or road', +] + +templates = [ + 'a centered satellite photo of {}.', + 'a centered satellite photo of a {}.', + 'a centered satellite photo of the {}.', +] +``` + + + +## FGVCAircraft + +```bash +classes = [ + '707-320', + '727-200', + '737-200', + '737-300', + '737-400', + '737-500', + '737-600', + '737-700', + '737-800', + '737-900', + '747-100', + '747-200', + '747-300', + '747-400', + '757-200', + '757-300', + '767-200', + '767-300', + '767-400', + '777-200', + '777-300', + 'A300B4', + 'A310', + 'A318', + 'A319', + 'A320', + 'A321', + 'A330-200', + 'A330-300', + 'A340-200', + 'A340-300', + 'A340-500', + 'A340-600', + 'A380', + 'ATR-42', + 'ATR-72', + 'An-12', + 'BAE 146-200', + 'BAE 146-300', + 'BAE-125', + 'Beechcraft 1900', + 'Boeing 717', + 'C-130', + 'C-47', + 'CRJ-200', + 'CRJ-700', + 'CRJ-900', + 'Cessna 172', + 'Cessna 208', + 'Cessna 525', + 'Cessna 560', + 'Challenger 600', + 'DC-10', + 'DC-3', + 'DC-6', + 'DC-8', + 'DC-9-30', + 'DH-82', + 'DHC-1', + 'DHC-6', + 'DHC-8-100', + 'DHC-8-300', + 'DR-400', + 'Dornier 328', + 'E-170', + 'E-190', + 'E-195', + 'EMB-120', + 'ERJ 135', + 'ERJ 145', + 'Embraer Legacy 600', + 'Eurofighter Typhoon', + 'F-16A/B', + 'F/A-18', + 'Falcon 2000', + 'Falcon 900', + 'Fokker 100', + 'Fokker 50', + 'Fokker 70', + 'Global Express', + 'Gulfstream IV', + 'Gulfstream V', + 'Hawk T1', + 'Il-76', + 'L-1011', + 'MD-11', + 'MD-80', + 'MD-87', + 'MD-90', + 'Metroliner', + 'Model B200', + 'PA-28', + 'SR-20', + 'Saab 2000', + 'Saab 340', + 'Spitfire', + 'Tornado', + 'Tu-134', + 'Tu-154', + 'Yak-42', +] + +templates = [ + 'a photo of a {}, a type of aircraft.', + 'a photo of the {}, a type of aircraft.', +] +``` + + + +## FacialEmotionRecognition2013 + +```bash +classes = [ + ['angry'], + ['disgusted'], + ['fearful'], + ['happy', 'smiling'], + ['sad', 'depressed'], + ['surprised', 'shocked', 'spooked'], + ['neutral', 'bored'], +] + +templates = [ + 'a photo of a {} looking face.', + 'a photo of a face showing the emotion: {}.', + 'a photo of a face looking {}.', + 'a face that looks {}.', + 'they look {}.', + 'look at how {} they are.', +] +``` + + + +## Flowers102 + +```bash +classes = [ + 'pink primrose', + 'hard-leaved pocket orchid', + 'canterbury bells', + 'sweet pea', + 'english marigold', + 'tiger lily', + 'moon orchid', + 'bird of paradise', + 'monkshood', + 'globe thistle', + 'snapdragon', + "colt's foot", + 'king protea', + 'spear thistle', + 'yellow iris', + 'globe flower', + 'purple coneflower', + 'peruvian lily', + 'balloon flower', + 'giant white arum lily', + 'fire lily', + 'pincushion flower', + 'fritillary', + 'red ginger', + 'grape hyacinth', + 'corn poppy', + 'prince of wales feathers', + 'stemless gentian', + 'artichoke', + 'sweet william', + 'carnation', + 'garden phlox', + 'love in the mist', + 'mexican aster', + 'alpine sea holly', + 'ruby-lipped cattleya', + 'cape flower', + 'great masterwort', + 'siam tulip', + 'lenten rose', + 'barbeton daisy', + 'daffodil', + 'sword lily', + 'poinsettia', + 'bolero deep blue', + 'wallflower', + 'marigold', + 'buttercup', + 'oxeye daisy', + 'common dandelion', + 'petunia', + 'wild pansy', + 'primula', + 'sunflower', + 'pelargonium', + 'bishop of llandaff', + 'gaura', + 'geranium', + 'orange dahlia', + 'pink and yellow dahlia', + 'cautleya spicata', + 'japanese anemone', + 'black-eyed susan', + 'silverbush', + 'californian poppy', + 'osteospermum', + 'spring crocus', + 'bearded iris', + 'windflower', + 'tree poppy', + 'gazania', + 'azalea', + 'water lily', + 'rose', + 'thorn apple', + 'morning glory', + 'passion flower', + 'lotus', + 'toad lily', + 'anthurium', + 'frangipani', + 'clematis', + 'hibiscus', + 'columbine', + 'desert-rose', + 'tree mallow', + 'magnolia', + 'cyclamen', + 'watercress', + 'canna lily', + 'hippeastrum', + 'bee balm', + 'air plant', + 'foxglove', + 'bougainvillea', + 'camellia', + 'mallow', + 'mexican petunia', + 'bromelia', + 'blanket flower', + 'trumpet creeper', + 'blackberry lily', +] + +templates = [ + 'a photo of a {}, a type of flower.', +] +``` + + + +## Food101 + +```bash +classes = [ + 'apple pie', + 'baby back ribs', + 'baklava', + 'beef carpaccio', + 'beef tartare', + 'beet salad', + 'beignets', + 'bibimbap', + 'bread pudding', + 'breakfast burrito', + 'bruschetta', + 'caesar salad', + 'cannoli', + 'caprese salad', + 'carrot cake', + 'ceviche', + 'cheese plate', + 'cheesecake', + 'chicken curry', + 'chicken quesadilla', + 'chicken wings', + 'chocolate cake', + 'chocolate mousse', + 'churros', + 'clam chowder', + 'club sandwich', + 'crab cakes', + 'creme brulee', + 'croque madame', + 'cup cakes', + 'deviled eggs', + 'donuts', + 'dumplings', + 'edamame', + 'eggs benedict', + 'escargots', + 'falafel', + 'filet mignon', + 'fish and chips', + 'foie gras', + 'french fries', + 'french onion soup', + 'french toast', + 'fried calamari', + 'fried rice', + 'frozen yogurt', + 'garlic bread', + 'gnocchi', + 'greek salad', + 'grilled cheese sandwich', + 'grilled salmon', + 'guacamole', + 'gyoza', + 'hamburger', + 'hot and sour soup', + 'hot dog', + 'huevos rancheros', + 'hummus', + 'ice cream', + 'lasagna', + 'lobster bisque', + 'lobster roll sandwich', + 'macaroni and cheese', + 'macarons', + 'miso soup', + 'mussels', + 'nachos', + 'omelette', + 'onion rings', + 'oysters', + 'pad thai', + 'paella', + 'pancakes', + 'panna cotta', + 'peking duck', + 'pho', + 'pizza', + 'pork chop', + 'poutine', + 'prime rib', + 'pulled pork sandwich', + 'ramen', + 'ravioli', + 'red velvet cake', + 'risotto', + 'samosa', + 'sashimi', + 'scallops', + 'seaweed salad', + 'shrimp and grits', + 'spaghetti bolognese', + 'spaghetti carbonara', + 'spring rolls', + 'steak', + 'strawberry shortcake', + 'sushi', + 'tacos', + 'takoyaki', + 'tiramisu', + 'tuna tartare', + 'waffles', +] + +templates = [ + 'a photo of {}, a type of food.', +] +``` + + + +## GTSRB + +```bash +classes = [ + 'red and white circle 20 kph speed limit', + 'red and white circle 30 kph speed limit', + 'red and white circle 50 kph speed limit', + 'red and white circle 60 kph speed limit', + 'red and white circle 70 kph speed limit', + 'red and white circle 80 kph speed limit', + 'end / de-restriction of 80 kph speed limit', + 'red and white circle 100 kph speed limit', + 'red and white circle 120 kph speed limit', + 'red and white circle red car and black car no passing', + 'red and white circle red truck and black car no passing', + 'red and white triangle road intersection warning', + 'white and yellow diamond priority road', + 'red and white upside down triangle yield right-of-way', + 'stop', + 'empty red and white circle', + 'red and white circle no truck entry', + 'red circle with white horizonal stripe no entry', + 'red and white triangle with exclamation mark warning', + 'red and white triangle with black left curve approaching warning', + 'red and white triangle with black right curve approaching warning', + 'red and white triangle with black double curve approaching warning', + 'red and white triangle rough / bumpy road warning', + 'red and white triangle car skidding / slipping warning', + 'red and white triangle with merging / narrow lanes warning', + 'red and white triangle with person digging / construction / road work warning', + 'red and white triangle with traffic light approaching warning', + 'red and white triangle with person walking warning', + 'red and white triangle with child and person walking warning', + 'red and white triangle with bicyle warning', + 'red and white triangle with snowflake / ice warning', + 'red and white triangle with deer warning', + 'white circle with gray strike bar no speed limit', + 'blue circle with white right turn arrow mandatory', + 'blue circle with white left turn arrow mandatory', + 'blue circle with white forward arrow mandatory', + 'blue circle with white forward or right turn arrow mandatory', + 'blue circle with white forward or left turn arrow mandatory', + 'blue circle with white keep right arrow mandatory', + 'blue circle with white keep left arrow mandatory', + 'blue circle with white arrows indicating a traffic circle', + 'white circle with gray strike bar indicating no passing for cars has ended', + 'white circle with gray strike bar indicating no passing for trucks has ended', +] + +templates = [ + 'a zoomed in photo of a "{}" traffic sign.', + 'a centered photo of a "{}" traffic sign.', + 'a close up photo of a "{}" traffic sign.', +] +``` + + + +## HatefulMemes + +```bash +classes = [ + 'meme', + 'hatespeech meme', +] + +templates = [ + 'a {}.', +] +``` + + + +## KITTI + +```bash +classes = [ + 'a photo i took of a car on my left or right side.', + 'a photo i took with a car nearby.', + 'a photo i took with a car in the distance.', + 'a photo i took with no car.', +] + +templates = [ + '{}', +] +``` + + + +## Kinetics700 + +```bash +classes = [ + 'abseiling', + 'acting in play', + 'adjusting glasses', + 'air drumming', + 'alligator wrestling', + 'answering questions', + 'applauding', + 'applying cream', + 'archaeological excavation', + 'archery', + 'arguing', + 'arm wrestling', + 'arranging flowers', + 'arresting', + 'assembling bicycle', + 'assembling computer', + 'attending conference', + 'auctioning', + 'baby waking up', + 'backflip (human)', + 'baking cookies', + 'bandaging', + 'barbequing', + 'bartending', + 'base jumping', + 'bathing dog', + 'battle rope training', + 'beatboxing', + 'bee keeping', + 'being excited', + 'being in zero gravity', + 'belly dancing', + 'bench pressing', + 'bending back', + 'bending metal', + 'biking through snow', + 'blasting sand', + 'blending fruit', + 'blowdrying hair', + 'blowing bubble gum', + 'blowing glass', + 'blowing leaves', + 'blowing nose', + 'blowing out candles', + 'bobsledding', + 'bodysurfing', + 'bookbinding', + 'bottling', + 'bouncing ball (not juggling)', + 'bouncing on bouncy castle', + 'bouncing on trampoline', + 'bowling', + 'braiding hair', + 'breading or breadcrumbing', + 'breakdancing', + 'breaking boards', + 'breaking glass', + 'breathing fire', + 'brush painting', + 'brushing floor', + 'brushing hair', + 'brushing teeth', + 'building cabinet', + 'building lego', + 'building sandcastle', + 'building shed', + 'bulldozing', + 'bungee jumping', + 'burping', + 'busking', + 'calculating', + 'calligraphy', + 'canoeing or kayaking', + 'capoeira', + 'capsizing', + 'card stacking', + 'card throwing', + 'carrying baby', + 'carrying weight', + 'cartwheeling', + 'carving ice', + 'carving marble', + 'carving pumpkin', + 'carving wood with a knife', + 'casting fishing line', + 'catching fish', + 'catching or throwing baseball', + 'catching or throwing frisbee', + 'catching or throwing softball', + 'celebrating', + 'changing gear in car', + 'changing oil', + 'changing wheel (not on bike)', + 'chasing', + 'checking tires', + 'checking watch', + 'cheerleading', + 'chewing gum', + 'chiseling stone', + 'chiseling wood', + 'chopping meat', + 'chopping wood', + 'clam digging', + 'clapping', + 'clay pottery making', + 'clean and jerk', + 'cleaning gutters', + 'cleaning pool', + 'cleaning shoes', + 'cleaning toilet', + 'cleaning windows', + 'climbing a rope', + 'climbing ladder', + 'climbing tree', + 'closing door', + 'coloring in', + 'combing hair', + 'contact juggling', + 'contorting', + 'cooking chicken', + 'cooking egg', + 'cooking on campfire', + 'cooking sausages (not on barbeque)', + 'cooking scallops', + 'cosplaying', + 'coughing', + 'counting money', + 'country line dancing', + 'cracking back', + 'cracking knuckles', + 'cracking neck', + 'crawling baby', + 'crocheting', + 'crossing eyes', + 'crossing river', + 'crying', + 'cumbia', + 'curling (sport)', + 'curling eyelashes', + 'curling hair', + 'cutting apple', + 'cutting cake', + 'cutting nails', + 'cutting orange', + 'cutting pineapple', + 'cutting watermelon', + 'dancing ballet', + 'dancing charleston', + 'dancing gangnam style', + 'dancing macarena', + 'deadlifting', + 'dealing cards', + 'decorating the christmas tree', + 'decoupage', + 'delivering mail', + 'digging', + 'dining', + 'directing traffic', + 'disc golfing', + 'diving cliff', + 'docking boat', + 'dodgeball', + 'doing aerobics', + 'doing jigsaw puzzle', + 'doing laundry', + 'doing nails', + 'doing sudoku', + 'drawing', + 'dribbling basketball', + 'drinking shots', + 'driving car', + 'driving tractor', + 'drooling', + 'drop kicking', + 'drumming fingers', + 'dumpster diving', + 'dunking basketball', + 'dyeing eyebrows', + 'dyeing hair', + 'eating burger', + 'eating cake', + 'eating carrots', + 'eating chips', + 'eating doughnuts', + 'eating hotdog', + 'eating ice cream', + 'eating nachos', + 'eating spaghetti', + 'eating watermelon', + 'egg hunting', + 'embroidering', + 'entering church', + 'exercising arm', + 'exercising with an exercise ball', + 'extinguishing fire', + 'faceplanting', + 'falling off bike', + 'falling off chair', + 'feeding birds', + 'feeding fish', + 'feeding goats', + 'fencing (sport)', + 'fidgeting', + 'filling cake', + 'filling eyebrows', + 'finger snapping', + 'fixing bicycle', + 'fixing hair', + 'flint knapping', + 'flipping bottle', + 'flipping pancake', + 'fly tying', + 'flying kite', + 'folding clothes', + 'folding napkins', + 'folding paper', + 'front raises', + 'frying vegetables', + 'gargling', + 'geocaching', + 'getting a haircut', + 'getting a piercing', + 'getting a tattoo', + 'giving or receiving award', + 'gold panning', + 'golf chipping', + 'golf driving', + 'golf putting', + 'gospel singing in church', + 'grinding meat', + 'grooming cat', + 'grooming dog', + 'grooming horse', + 'gymnastics tumbling', + 'hammer throw', + 'hand washing clothes', + 'head stand', + 'headbanging', + 'headbutting', + 'helmet diving', + 'herding cattle', + 'high fiving', + 'high jump', + 'high kick', + 'historical reenactment', + 'hitting baseball', + 'hockey stop', + 'holding snake', + 'home roasting coffee', + 'hopscotch', + 'hoverboarding', + 'huddling', + 'hugging (not baby)', + 'hugging baby', + 'hula hooping', + 'hurdling', + 'hurling (sport)', + 'ice climbing', + 'ice fishing', + 'ice skating', + 'ice swimming', + 'inflating balloons', + 'installing carpet', + 'ironing', + 'ironing hair', + 'javelin throw', + 'jaywalking', + 'jetskiing', + 'jogging', + 'juggling balls', + 'juggling fire', + 'juggling soccer ball', + 'jumping bicycle', + 'jumping into pool', + 'jumping jacks', + 'jumping sofa', + 'jumpstyle dancing', + 'karaoke', + 'kicking field goal', + 'kicking soccer ball', + 'kissing', + 'kitesurfing', + 'knitting', + 'krumping', + 'land sailing', + 'laughing', + 'lawn mower racing', + 'laying bricks', + 'laying concrete', + 'laying decking', + 'laying stone', + 'laying tiles', + 'leatherworking', + 'letting go of balloon', + 'licking', + 'lifting hat', + 'lighting candle', + 'lighting fire', + 'listening with headphones', + 'lock picking', + 'long jump', + 'longboarding', + 'looking at phone', + 'looking in mirror', + 'luge', + 'lunge', + 'making a cake', + 'making a sandwich', + 'making balloon shapes', + 'making bubbles', + 'making cheese', + 'making horseshoes', + 'making jewelry', + 'making latte art', + 'making paper aeroplanes', + 'making pizza', + 'making slime', + 'making snowman', + 'making sushi', + 'making tea', + 'making the bed', + 'marching', + 'marriage proposal', + 'massaging back', + 'massaging feet', + 'massaging legs', + 'massaging neck', + "massaging person's head", + 'metal detecting', + 'milking cow', + 'milking goat', + 'mixing colours', + 'moon walking', + 'mopping floor', + 'mosh pit dancing', + 'motorcycling', + 'mountain climber (exercise)', + 'moving baby', + 'moving child', + 'moving furniture', + 'mowing lawn', + 'mushroom foraging', + 'needle felting', + 'news anchoring', + 'opening bottle (not wine)', + 'opening coconuts', + 'opening door', + 'opening present', + 'opening refrigerator', + 'opening wine bottle', + 'packing', + 'paragliding', + 'parasailing', + 'parkour', + 'passing American football (in game)', + 'passing American football (not in game)', + 'passing soccer ball', + 'peeling apples', + 'peeling banana', + 'peeling potatoes', + 'person collecting garbage', + 'petting animal (not cat)', + 'petting cat', + 'petting horse', + 'photobombing', + 'photocopying', + 'picking apples', + 'picking blueberries', + 'pillow fight', + 'pinching', + 'pirouetting', + 'planing wood', + 'planting trees', + 'plastering', + 'playing accordion', + 'playing american football', + 'playing badminton', + 'playing bagpipes', + 'playing basketball', + 'playing bass guitar', + 'playing beer pong', + 'playing billiards', + 'playing blackjack', + 'playing cards', + 'playing cello', + 'playing checkers', + 'playing chess', + 'playing clarinet', + 'playing controller', + 'playing cricket', + 'playing cymbals', + 'playing darts', + 'playing didgeridoo', + 'playing dominoes', + 'playing drums', + 'playing field hockey', + 'playing flute', + 'playing gong', + 'playing guitar', + 'playing hand clapping games', + 'playing harmonica', + 'playing harp', + 'playing ice hockey', + 'playing keyboard', + 'playing kickball', + 'playing laser tag', + 'playing lute', + 'playing mahjong', + 'playing maracas', + 'playing marbles', + 'playing monopoly', + 'playing netball', + 'playing nose flute', + 'playing oboe', + 'playing ocarina', + 'playing organ', + 'playing paintball', + 'playing pan pipes', + 'playing piano', + 'playing piccolo', + 'playing pinball', + 'playing ping pong', + 'playing poker', + 'playing polo', + 'playing recorder', + 'playing road hockey', + 'playing rounders', + 'playing rubiks cube', + 'playing saxophone', + 'playing scrabble', + 'playing shuffleboard', + 'playing slot machine', + 'playing squash or racquetball', + 'playing tennis', + 'playing trombone', + 'playing trumpet', + 'playing ukulele', + 'playing violin', + 'playing volleyball', + 'playing with trains', + 'playing xylophone', + 'poaching eggs', + 'poking bellybutton', + 'pole vault', + 'polishing furniture', + 'polishing metal', + 'popping balloons', + 'pouring beer', + 'pouring milk', + 'pouring wine', + 'preparing salad', + 'presenting weather forecast', + 'pretending to be a statue', + 'pull ups', + 'pulling espresso shot', + 'pulling rope (game)', + 'pumping fist', + 'pumping gas', + 'punching bag', + 'punching person (boxing)', + 'push up', + 'pushing car', + 'pushing cart', + 'pushing wheelbarrow', + 'pushing wheelchair', + 'putting in contact lenses', + 'putting on eyeliner', + 'putting on foundation', + 'putting on lipstick', + 'putting on mascara', + 'putting on sari', + 'putting on shoes', + 'putting wallpaper on wall', + 'raising eyebrows', + 'reading book', + 'reading newspaper', + 'recording music', + 'repairing puncture', + 'riding a bike', + 'riding camel', + 'riding elephant', + 'riding mechanical bull', + 'riding mule', + 'riding or walking with horse', + 'riding scooter', + 'riding snow blower', + 'riding unicycle', + 'ripping paper', + 'roasting marshmallows', + 'roasting pig', + 'robot dancing', + 'rock climbing', + 'rock scissors paper', + 'roller skating', + 'rolling eyes', + 'rolling pastry', + 'rope pushdown', + 'running on treadmill', + 'sailing', + 'salsa dancing', + 'saluting', + 'sanding floor', + 'sanding wood', + 'sausage making', + 'sawing wood', + 'scrambling eggs', + 'scrapbooking', + 'scrubbing face', + 'scuba diving', + 'seasoning food', + 'separating eggs', + 'setting table', + 'sewing', + 'shaking hands', + 'shaking head', + 'shaping bread dough', + 'sharpening knives', + 'sharpening pencil', + 'shaving head', + 'shaving legs', + 'shearing sheep', + 'shining flashlight', + 'shining shoes', + 'shoot dance', + 'shooting basketball', + 'shooting goal (soccer)', + 'shooting off fireworks', + 'shopping', + 'shot put', + 'shouting', + 'shoveling snow', + 'shredding paper', + 'shucking oysters', + 'shuffling cards', + 'shuffling feet', + 'side kick', + 'sieving', + 'sign language interpreting', + 'silent disco', + 'singing', + 'sipping cup', + 'situp', + 'skateboarding', + 'ski ballet', + 'ski jumping', + 'skiing crosscountry', + 'skiing mono', + 'skiing slalom', + 'skipping rope', + 'skipping stone', + 'skydiving', + 'slacklining', + 'slapping', + 'sled dog racing', + 'sleeping', + 'slicing onion', + 'smashing', + 'smelling feet', + 'smoking', + 'smoking hookah', + 'smoking pipe', + 'snatch weight lifting', + 'sneezing', + 'snorkeling', + 'snowboarding', + 'snowkiting', + 'snowmobiling', + 'somersaulting', + 'spelunking', + 'spinning plates', + 'spinning poi', + 'splashing water', + 'spray painting', + 'spraying', + 'springboard diving', + 'square dancing', + 'squat', + 'squeezing orange', + 'stacking cups', + 'stacking dice', + 'standing on hands', + 'staring', + 'steer roping', + 'steering car', + 'sticking tongue out', + 'stomping grapes', + 'stretching arm', + 'stretching leg', + 'sucking lolly', + 'surfing crowd', + 'surfing water', + 'surveying', + 'sweeping floor', + 'swimming backstroke', + 'swimming breast stroke', + 'swimming butterfly stroke', + 'swimming front crawl', + 'swimming with dolphins', + 'swimming with sharks', + 'swing dancing', + 'swinging baseball bat', + 'swinging on something', + 'sword fighting', + 'sword swallowing', + 'tackling', + 'tagging graffiti', + 'tai chi', + 'taking photo', + 'talking on cell phone', + 'tango dancing', + 'tap dancing', + 'tapping guitar', + 'tapping pen', + 'tasting beer', + 'tasting food', + 'tasting wine', + 'testifying', + 'texting', + 'threading needle', + 'throwing axe', + 'throwing ball (not baseball or American football)', + 'throwing discus', + 'throwing knife', + 'throwing snowballs', + 'throwing tantrum', + 'throwing water balloon', + 'tickling', + 'tie dying', + 'tightrope walking', + 'tiptoeing', + 'tobogganing', + 'tossing coin', + 'tossing salad', + 'training dog', + 'trapezing', + 'treating wood', + 'trimming or shaving beard', + 'trimming shrubs', + 'trimming trees', + 'triple jump', + 'twiddling fingers', + 'tying bow tie', + 'tying knot (not on a tie)', + 'tying necktie', + 'tying shoe laces', + 'unboxing', + 'uncorking champagne', + 'unloading truck', + 'using a microscope', + 'using a paint roller', + 'using a power drill', + 'using a sledge hammer', + 'using a wrench', + 'using atm', + 'using bagging machine', + 'using circular saw', + 'using inhaler', + 'using megaphone', + 'using puppets', + 'using remote controller (not gaming)', + 'using segway', + 'vacuuming car', + 'vacuuming floor', + 'visiting the zoo', + 'wading through mud', + 'wading through water', + 'waiting in line', + 'waking up', + 'walking on stilts', + 'walking the dog', + 'walking through snow', + 'walking with crutches', + 'washing dishes', + 'washing feet', + 'washing hair', + 'washing hands', + 'watching tv', + 'water skiing', + 'water sliding', + 'watering plants', + 'waving hand', + 'waxing armpits', + 'waxing back', + 'waxing chest', + 'waxing eyebrows', + 'waxing legs', + 'weaving basket', + 'weaving fabric', + 'welding', + 'whistling', + 'windsurfing', + 'winking', + 'wood burning (art)', + 'wrapping present', + 'wrestling', + 'writing', + 'yarn spinning', + 'yawning', + 'yoga', + 'zumba' +] + +templates = [ + 'a photo of {}.', + 'a photo of a person {}.', + 'a photo of a person using {}.', + 'a photo of a person doing {}.', + 'a photo of a person during {}.', + 'a photo of a person performing {}.', + 'a photo of a person practicing {}.', + 'a video of {}.', + 'a video of a person {}.', + 'a video of a person using {}.', + 'a video of a person doing {}.', + 'a video of a person during {}.', + 'a video of a person performing {}.', + 'a video of a person practicing {}.', + 'a example of {}.', + 'a example of a person {}.', + 'a example of a person using {}.', + 'a example of a person doing {}.', + 'a example of a person during {}.', + 'a example of a person performing {}.', + 'a example of a person practicing {}.', + 'a demonstration of {}.', + 'a demonstration of a person {}.', + 'a demonstration of a person using {}.', + 'a demonstration of a person doing {}.', + 'a demonstration of a person during {}.', + 'a demonstration of a person performing {}.', + 'a demonstration of a person practicing {}.', +] +``` + + + +## MNIST + +```bash +classes = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of the number: "{}".', +] +``` + + + +## OxfordPets + +```bash +classes = [ + 'Abyssinian', + 'Bengal', + 'Birman', + 'Bombay', + 'British Shorthair', + 'Egyptian Mau', + 'Maine Coon', + 'Persian', + 'Ragdoll', + 'Russian Blue', + 'Siamese', + 'Sphynx', + 'american bulldog', + 'american pit bull terrier', + 'basset hound', + 'beagle', + 'boxer', + 'chihuahua', + 'english cocker spaniel', + 'english setter', + 'german shorthaired', + 'great pyrenees', + 'havanese', + 'japanese chin', + 'keeshond', + 'leonberger', + 'miniature pinscher', + 'newfoundland', + 'pomeranian', + 'pug', + 'saint bernard', + 'samoyed', + 'scottish terrier', + 'shiba inu', + 'staffordshire bull terrier', + 'wheaten terrier', + 'yorkshire terrier', +] + +templates = [ + 'a photo of a {}, a type of pet.', +] +``` + + + +## PascalVOC2007 + +```bash +classes = [ + 'aeroplane', + 'bicycle', + 'bird', + 'boat', + 'bottle', + 'bus', + 'car', + 'cat', + 'chair', + 'cow', + 'dog', + 'horse', + 'motorbike', + 'person', + 'sheep', + 'sofa', + 'diningtable', + 'pottedplant', + 'train', + 'tvmonitor', +] + +templates = [ + 'a photo of a {}.', +] +``` + + + +## PatchCamelyon + +```bash +classes = [ + 'lymph node', + 'lymph node containing metastatic tumor tissue', +] + +templates = [ + 'this is a photo of {}', +] +``` + + + +## RESISC45 + +```bash +classes = [ + 'airplane', + 'airport', + 'baseball diamond', + 'basketball court', + 'beach', + 'bridge', + 'chaparral', + 'church', + 'circular farmland', + 'cloud', + 'commercial area', + 'dense residential', + 'desert', + 'forest', + 'freeway', + 'golf course', + 'ground track field', + 'harbor', + 'industrial area', + 'intersection', + 'island', + 'lake', + 'meadow', + 'medium residential', + 'mobile home park', + 'mountain', + 'overpass', + 'palace', + 'parking lot', + 'railway', + 'railway station', + 'rectangular farmland', + 'river', + 'roundabout', + 'runway', + 'sea ice', + 'ship', + 'snowberg', + 'sparse residential', + 'stadium', + 'storage tank', + 'tennis court', + 'terrace', + 'thermal power station', + 'wetland', +] + +templates = [ + 'satellite imagery of {}.', + 'aerial imagery of {}.', + 'satellite photo of {}.', + 'aerial photo of {}.', + 'satellite view of {}.', + 'aerial view of {}.', + 'satellite imagery of a {}.', + 'aerial imagery of a {}.', + 'satellite photo of a {}.', + 'aerial photo of a {}.', + 'satellite view of a {}.', + 'aerial view of a {}.', + 'satellite imagery of the {}.', + 'aerial imagery of the {}.', + 'satellite photo of the {}.', + 'aerial photo of the {}.', + 'satellite view of the {}.', + 'aerial view of the {}.', +] +``` + + + +## SST2 + +```bash +classes = [ + 'negative', + 'positive', +] + +templates = [ + 'a {} review of a movie.', +] +``` + + + +## STL10 + +```bash +classes = [ + 'airplane', + 'bird', + 'car', + 'cat', + 'deer', + 'dog', + 'horse', + 'monkey', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## SUN397 + +```bash +classes = [ + 'abbey', + 'airplane cabin', + 'airport terminal', + 'alley', + 'amphitheater', + 'amusement arcade', + 'amusement park', + 'anechoic chamber', + 'apartment building outdoor', + 'apse indoor', + 'aquarium', + 'aqueduct', + 'arch', + 'archive', + 'arrival gate outdoor', + 'art gallery', + 'art school', + 'art studio', + 'assembly line', + 'athletic field outdoor', + 'atrium public', + 'attic', + 'auditorium', + 'auto factory', + 'badlands', + 'badminton court indoor', + 'baggage claim', + 'bakery shop', + 'balcony exterior', + 'balcony interior', + 'ball pit', + 'ballroom', + 'bamboo forest', + 'banquet hall', + 'bar', + 'barn', + 'barndoor', + 'baseball field', + 'basement', + 'basilica', + 'basketball court outdoor', + 'bathroom', + 'batters box', + 'bayou', + 'bazaar indoor', + 'bazaar outdoor', + 'beach', + 'beauty salon', + 'bedroom', + 'berth', + 'biology laboratory', + 'bistro indoor', + 'boardwalk', + 'boat deck', + 'boathouse', + 'bookstore', + 'booth indoor', + 'botanical garden', + 'bow window indoor', + 'bow window outdoor', + 'bowling alley', + 'boxing ring', + 'brewery indoor', + 'bridge', + 'building facade', + 'bullring', + 'burial chamber', + 'bus interior', + 'butchers shop', + 'butte', + 'cabin outdoor', + 'cafeteria', + 'campsite', + 'campus', + 'canal natural', + 'canal urban', + 'candy store', + 'canyon', + 'car interior backseat', + 'car interior frontseat', + 'carrousel', + 'casino indoor', + 'castle', + 'catacomb', + 'cathedral indoor', + 'cathedral outdoor', + 'cavern indoor', + 'cemetery', + 'chalet', + 'cheese factory', + 'chemistry lab', + 'chicken coop indoor', + 'chicken coop outdoor', + 'childs room', + 'church indoor', + 'church outdoor', + 'classroom', + 'clean room', + 'cliff', + 'cloister indoor', + 'closet', + 'clothing store', + 'coast', + 'cockpit', + 'coffee shop', + 'computer room', + 'conference center', + 'conference room', + 'construction site', + 'control room', + 'control tower outdoor', + 'corn field', + 'corral', + 'corridor', + 'cottage garden', + 'courthouse', + 'courtroom', + 'courtyard', + 'covered bridge exterior', + 'creek', + 'crevasse', + 'crosswalk', + 'cubicle office', + 'dam', + 'delicatessen', + 'dentists office', + 'desert sand', + 'desert vegetation', + 'diner indoor', + 'diner outdoor', + 'dinette home', + 'dinette vehicle', + 'dining car', + 'dining room', + 'discotheque', + 'dock', + 'doorway outdoor', + 'dorm room', + 'driveway', + 'driving range outdoor', + 'drugstore', + 'electrical substation', + 'elevator door', + 'elevator interior', + 'elevator shaft', + 'engine room', + 'escalator indoor', + 'excavation', + 'factory indoor', + 'fairway', + 'fastfood restaurant', + 'field cultivated', + 'field wild', + 'fire escape', + 'fire station', + 'firing range indoor', + 'fishpond', + 'florist shop indoor', + 'food court', + 'forest broadleaf', + 'forest needleleaf', + 'forest path', + 'forest road', + 'formal garden', + 'fountain', + 'galley', + 'game room', + 'garage indoor', + 'garbage dump', + 'gas station', + 'gazebo exterior', + 'general store indoor', + 'general store outdoor', + 'gift shop', + 'golf course', + 'greenhouse indoor', + 'greenhouse outdoor', + 'gymnasium indoor', + 'hangar indoor', + 'hangar outdoor', + 'harbor', + 'hayfield', + 'heliport', + 'herb garden', + 'highway', + 'hill', + 'home office', + 'hospital', + 'hospital room', + 'hot spring', + 'hot tub outdoor', + 'hotel outdoor', + 'hotel room', + 'house', + 'hunting lodge outdoor', + 'ice cream parlor', + 'ice floe', + 'ice shelf', + 'ice skating rink indoor', + 'ice skating rink outdoor', + 'iceberg', + 'igloo', + 'industrial area', + 'inn outdoor', + 'islet', + 'jacuzzi indoor', + 'jail cell', + 'jail indoor', + 'jewelry shop', + 'kasbah', + 'kennel indoor', + 'kennel outdoor', + 'kindergarden classroom', + 'kitchen', + 'kitchenette', + 'labyrinth outdoor', + 'lake natural', + 'landfill', + 'landing deck', + 'laundromat', + 'lecture room', + 'library indoor', + 'library outdoor', + 'lido deck outdoor', + 'lift bridge', + 'lighthouse', + 'limousine interior', + 'living room', + 'lobby', + 'lock chamber', + 'locker room', + 'mansion', + 'manufactured home', + 'market indoor', + 'market outdoor', + 'marsh', + 'martial arts gym', + 'mausoleum', + 'medina', + 'moat water', + 'monastery outdoor', + 'mosque indoor', + 'mosque outdoor', + 'motel', + 'mountain', + 'mountain snowy', + 'movie theater indoor', + 'museum indoor', + 'music store', + 'music studio', + 'nuclear power plant outdoor', + 'nursery', + 'oast house', + 'observatory outdoor', + 'ocean', + 'office', + 'office building', + 'oil refinery outdoor', + 'oilrig', + 'operating room', + 'orchard', + 'outhouse outdoor', + 'pagoda', + 'palace', + 'pantry', + 'park', + 'parking garage indoor', + 'parking garage outdoor', + 'parking lot', + 'parlor', + 'pasture', + 'patio', + 'pavilion', + 'pharmacy', + 'phone booth', + 'physics laboratory', + 'picnic area', + 'pilothouse indoor', + 'planetarium outdoor', + 'playground', + 'playroom', + 'plaza', + 'podium indoor', + 'podium outdoor', + 'pond', + 'poolroom establishment', + 'poolroom home', + 'power plant outdoor', + 'promenade deck', + 'pub indoor', + 'pulpit', + 'putting green', + 'racecourse', + 'raceway', + 'raft', + 'railroad track', + 'rainforest', + 'reception', + 'recreation room', + 'residential neighborhood', + 'restaurant', + 'restaurant kitchen', + 'restaurant patio', + 'rice paddy', + 'riding arena', + 'river', + 'rock arch', + 'rope bridge', + 'ruin', + 'runway', + 'sandbar', + 'sandbox', + 'sauna', + 'schoolhouse', + 'sea cliff', + 'server room', + 'shed', + 'shoe shop', + 'shopfront', + 'shopping mall indoor', + 'shower', + 'skatepark', + 'ski lodge', + 'ski resort', + 'ski slope', + 'sky', + 'skyscraper', + 'slum', + 'snowfield', + 'squash court', + 'stable', + 'stadium baseball', + 'stadium football', + 'stage indoor', + 'staircase', + 'street', + 'subway interior', + 'subway station platform', + 'supermarket', + 'sushi bar', + 'swamp', + 'swimming pool indoor', + 'swimming pool outdoor', + 'synagogue indoor', + 'synagogue outdoor', + 'television studio', + 'temple east asia', + 'temple south asia', + 'tennis court indoor', + 'tennis court outdoor', + 'tent outdoor', + 'theater indoor procenium', + 'theater indoor seats', + 'thriftshop', + 'throne room', + 'ticket booth', + 'toll plaza', + 'topiary garden', + 'tower', + 'toyshop', + 'track outdoor', + 'train railway', + 'train station platform', + 'tree farm', + 'tree house', + 'trench', + 'underwater coral reef', + 'utility room', + 'valley', + 'van interior', + 'vegetable garden', + 'veranda', + 'veterinarians office', + 'viaduct', + 'videostore', + 'village', + 'vineyard', + 'volcano', + 'volleyball court indoor', + 'volleyball court outdoor', + 'waiting room', + 'warehouse indoor', + 'water tower', + 'waterfall block', + 'waterfall fan', + 'waterfall plunge', + 'watering hole', + 'wave', + 'wet bar', + 'wheat field', + 'wind farm', + 'windmill', + 'wine cellar barrel storage', + 'wine cellar bottle storage', + 'wrestling ring indoor', + 'yard', + 'youth hostel', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## StanfordCars + +```bash +classes = [ + 'AM General Hummer SUV 2000', + 'Acura RL Sedan 2012', + 'Acura TL Sedan 2012', + 'Acura TL Type-S 2008', + 'Acura TSX Sedan 2012', + 'Acura Integra Type R 2001', + 'Acura ZDX Hatchback 2012', + 'Aston Martin V8 Vantage Convertible 2012', + 'Aston Martin V8 Vantage Coupe 2012', + 'Aston Martin Virage Convertible 2012', + 'Aston Martin Virage Coupe 2012', + 'Audi RS 4 Convertible 2008', + 'Audi A5 Coupe 2012', + 'Audi TTS Coupe 2012', + 'Audi R8 Coupe 2012', + 'Audi V8 Sedan 1994', + 'Audi 100 Sedan 1994', + 'Audi 100 Wagon 1994', + 'Audi TT Hatchback 2011', + 'Audi S6 Sedan 2011', + 'Audi S5 Convertible 2012', + 'Audi S5 Coupe 2012', + 'Audi S4 Sedan 2012', + 'Audi S4 Sedan 2007', + 'Audi TT RS Coupe 2012', + 'BMW ActiveHybrid 5 Sedan 2012', + 'BMW 1 Series Convertible 2012', + 'BMW 1 Series Coupe 2012', + 'BMW 3 Series Sedan 2012', + 'BMW 3 Series Wagon 2012', + 'BMW 6 Series Convertible 2007', + 'BMW X5 SUV 2007', + 'BMW X6 SUV 2012', + 'BMW M3 Coupe 2012', + 'BMW M5 Sedan 2010', + 'BMW M6 Convertible 2010', + 'BMW X3 SUV 2012', + 'BMW Z4 Convertible 2012', + 'Bentley Continental Supersports Conv. Convertible 2012', + 'Bentley Arnage Sedan 2009', + 'Bentley Mulsanne Sedan 2011', + 'Bentley Continental GT Coupe 2012', + 'Bentley Continental GT Coupe 2007', + 'Bentley Continental Flying Spur Sedan 2007', + 'Bugatti Veyron 16.4 Convertible 2009', + 'Bugatti Veyron 16.4 Coupe 2009', + 'Buick Regal GS 2012', + 'Buick Rainier SUV 2007', + 'Buick Verano Sedan 2012', + 'Buick Enclave SUV 2012', + 'Cadillac CTS-V Sedan 2012', + 'Cadillac SRX SUV 2012', + 'Cadillac Escalade EXT Crew Cab 2007', + 'Chevrolet Silverado 1500 Hybrid Crew Cab 2012', + 'Chevrolet Corvette Convertible 2012', + 'Chevrolet Corvette ZR1 2012', + 'Chevrolet Corvette Ron Fellows Edition Z06 2007', + 'Chevrolet Traverse SUV 2012', + 'Chevrolet Camaro Convertible 2012', + 'Chevrolet HHR SS 2010', + 'Chevrolet Impala Sedan 2007', + 'Chevrolet Tahoe Hybrid SUV 2012', + 'Chevrolet Sonic Sedan 2012', + 'Chevrolet Express Cargo Van 2007', + 'Chevrolet Avalanche Crew Cab 2012', + 'Chevrolet Cobalt SS 2010', + 'Chevrolet Malibu Hybrid Sedan 2010', + 'Chevrolet TrailBlazer SS 2009', + 'Chevrolet Silverado 2500HD Regular Cab 2012', + 'Chevrolet Silverado 1500 Classic Extended Cab 2007', + 'Chevrolet Express Van 2007', + 'Chevrolet Monte Carlo Coupe 2007', + 'Chevrolet Malibu Sedan 2007', + 'Chevrolet Silverado 1500 Extended Cab 2012', + 'Chevrolet Silverado 1500 Regular Cab 2012', + 'Chrysler Aspen SUV 2009', + 'Chrysler Sebring Convertible 2010', + 'Chrysler Town and Country Minivan 2012', + 'Chrysler 300 SRT-8 2010', + 'Chrysler Crossfire Convertible 2008', + 'Chrysler PT Cruiser Convertible 2008', + 'Daewoo Nubira Wagon 2002', + 'Dodge Caliber Wagon 2012', + 'Dodge Caliber Wagon 2007', + 'Dodge Caravan Minivan 1997', + 'Dodge Ram Pickup 3500 Crew Cab 2010', + 'Dodge Ram Pickup 3500 Quad Cab 2009', + 'Dodge Sprinter Cargo Van 2009', + 'Dodge Journey SUV 2012', + 'Dodge Dakota Crew Cab 2010', + 'Dodge Dakota Club Cab 2007', + 'Dodge Magnum Wagon 2008', + 'Dodge Challenger SRT8 2011', + 'Dodge Durango SUV 2012', + 'Dodge Durango SUV 2007', + 'Dodge Charger Sedan 2012', + 'Dodge Charger SRT-8 2009', + 'Eagle Talon Hatchback 1998', + 'FIAT 500 Abarth 2012', + 'FIAT 500 Convertible 2012', + 'Ferrari FF Coupe 2012', + 'Ferrari California Convertible 2012', + 'Ferrari 458 Italia Convertible 2012', + 'Ferrari 458 Italia Coupe 2012', + 'Fisker Karma Sedan 2012', + 'Ford F-450 Super Duty Crew Cab 2012', + 'Ford Mustang Convertible 2007', + 'Ford Freestar Minivan 2007', + 'Ford Expedition EL SUV 2009', + 'Ford Edge SUV 2012', + 'Ford Ranger SuperCab 2011', + 'Ford GT Coupe 2006', + 'Ford F-150 Regular Cab 2012', + 'Ford F-150 Regular Cab 2007', + 'Ford Focus Sedan 2007', + 'Ford E-Series Wagon Van 2012', + 'Ford Fiesta Sedan 2012', + 'GMC Terrain SUV 2012', + 'GMC Savana Van 2012', + 'GMC Yukon Hybrid SUV 2012', + 'GMC Acadia SUV 2012', + 'GMC Canyon Extended Cab 2012', + 'Geo Metro Convertible 1993', + 'HUMMER H3T Crew Cab 2010', + 'HUMMER H2 SUT Crew Cab 2009', + 'Honda Odyssey Minivan 2012', + 'Honda Odyssey Minivan 2007', + 'Honda Accord Coupe 2012', + 'Honda Accord Sedan 2012', + 'Hyundai Veloster Hatchback 2012', + 'Hyundai Santa Fe SUV 2012', + 'Hyundai Tucson SUV 2012', + 'Hyundai Veracruz SUV 2012', + 'Hyundai Sonata Hybrid Sedan 2012', + 'Hyundai Elantra Sedan 2007', + 'Hyundai Accent Sedan 2012', + 'Hyundai Genesis Sedan 2012', + 'Hyundai Sonata Sedan 2012', + 'Hyundai Elantra Touring Hatchback 2012', + 'Hyundai Azera Sedan 2012', + 'Infiniti G Coupe IPL 2012', + 'Infiniti QX56 SUV 2011', + 'Isuzu Ascender SUV 2008', + 'Jaguar XK XKR 2012', + 'Jeep Patriot SUV 2012', + 'Jeep Wrangler SUV 2012', + 'Jeep Liberty SUV 2012', + 'Jeep Grand Cherokee SUV 2012', + 'Jeep Compass SUV 2012', + 'Lamborghini Reventon Coupe 2008', + 'Lamborghini Aventador Coupe 2012', + 'Lamborghini Gallardo LP 570-4 Superleggera 2012', + 'Lamborghini Diablo Coupe 2001', + 'Land Rover Range Rover SUV 2012', + 'Land Rover LR2 SUV 2012', + 'Lincoln Town Car Sedan 2011', + 'MINI Cooper Roadster Convertible 2012', + 'Maybach Landaulet Convertible 2012', + 'Mazda Tribute SUV 2011', + 'McLaren MP4-12C Coupe 2012', + 'Mercedes-Benz 300-Class Convertible 1993', + 'Mercedes-Benz C-Class Sedan 2012', + 'Mercedes-Benz SL-Class Coupe 2009', + 'Mercedes-Benz E-Class Sedan 2012', + 'Mercedes-Benz S-Class Sedan 2012', + 'Mercedes-Benz Sprinter Van 2012', + 'Mitsubishi Lancer Sedan 2012', + 'Nissan Leaf Hatchback 2012', + 'Nissan NV Passenger Van 2012', + 'Nissan Juke Hatchback 2012', + 'Nissan 240SX Coupe 1998', + 'Plymouth Neon Coupe 1999', + 'Porsche Panamera Sedan 2012', + 'Ram C/V Cargo Van Minivan 2012', + 'Rolls-Royce Phantom Drophead Coupe Convertible 2012', + 'Rolls-Royce Ghost Sedan 2012', + 'Rolls-Royce Phantom Sedan 2012', + 'Scion xD Hatchback 2012', + 'Spyker C8 Convertible 2009', + 'Spyker C8 Coupe 2009', + 'Suzuki Aerio Sedan 2007', + 'Suzuki Kizashi Sedan 2012', + 'Suzuki SX4 Hatchback 2012', + 'Suzuki SX4 Sedan 2012', + 'Tesla Model S Sedan 2012', + 'Toyota Sequoia SUV 2012', + 'Toyota Camry Sedan 2012', + 'Toyota Corolla Sedan 2012', + 'Toyota 4Runner SUV 2012', + 'Volkswagen Golf Hatchback 2012', + 'Volkswagen Golf Hatchback 1991', + 'Volkswagen Beetle Hatchback 2012', + 'Volvo C30 Hatchback 2012', + 'Volvo 240 Sedan 1993', + 'Volvo XC90 SUV 2007', + 'smart fortwo Convertible 2012', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', + 'a photo of my {}.', + 'i love my {}!', + 'a photo of my dirty {}.', + 'a photo of my clean {}.', + 'a photo of my new {}.', + 'a photo of my old {}.', +] +``` + + + +## UCF101 + +```bash +classes = [ + 'Apply Eye Makeup', + 'Apply Lipstick', + 'Archery', + 'Baby Crawling', + 'Balance Beam', + 'Band Marching', + 'Baseball Pitch', + 'Basketball', + 'Basketball Dunk', + 'Bench Press', + 'Biking', + 'Billiards', + 'Blow Dry Hair', + 'Blowing Candles', + 'Body Weight Squats', + 'Bowling', + 'Boxing Punching Bag', + 'Boxing Speed Bag', + 'Breast Stroke', + 'Brushing Teeth', + 'Clean And Jerk', + 'Cliff Diving', + 'Cricket Bowling', + 'Cricket Shot', + 'Cutting In Kitchen', + 'Diving', + 'Drumming', + 'Fencing', + 'Field Hockey Penalty', + 'Floor Gymnastics', + 'Frisbee Catch', + 'Front Crawl', + 'Golf Swing', + 'Haircut', + 'Hammer Throw', + 'Hammering', + 'Hand Stand Pushups', + 'Handstand Walking', + 'Head Massage', + 'High Jump', + 'Horse Race', + 'Horse Riding', + 'Hula Hoop', + 'Ice Dancing', + 'Javelin Throw', + 'Juggling Balls', + 'Jump Rope', + 'Jumping Jack', + 'Kayaking', + 'Knitting', + 'Long Jump', + 'Lunges', + 'Military Parade', + 'Mixing', + 'Mopping Floor', + 'Nunchucks', + 'Parallel Bars', + 'Pizza Tossing', + 'Playing Cello', + 'Playing Daf', + 'Playing Dhol', + 'Playing Flute', + 'Playing Guitar', + 'Playing Piano', + 'Playing Sitar', + 'Playing Tabla', + 'Playing Violin', + 'Pole Vault', + 'Pommel Horse', + 'Pull Ups', + 'Punch', + 'Push Ups', + 'Rafting', + 'Rock Climbing Indoor', + 'Rope Climbing', + 'Rowing', + 'Salsa Spin', + 'Shaving Beard', + 'Shotput', + 'Skate Boarding', + 'Skiing', + 'Skijet', + 'Sky Diving', + 'Soccer Juggling', + 'Soccer Penalty', + 'Still Rings', + 'Sumo Wrestling', + 'Surfing', + 'Swing', + 'Table Tennis Shot', + 'Tai Chi', + 'Tennis Swing', + 'Throw Discus', + 'Trampoline Jumping', + 'Typing', + 'Uneven Bars', + 'Volleyball Spiking', + 'Walking With Dog', + 'Wall Pushups', + 'Writing On Board', + 'Yo Yo', +] + +templates = [ + 'a photo of a person {}.', + 'a video of a person {}.', + 'a example of a person {}.', + 'a demonstration of a person {}.', + 'a photo of the person {}.', + 'a video of the person {}.', + 'a example of the person {}.', + 'a demonstration of the person {}.', + 'a photo of a person using {}.', + 'a video of a person using {}.', + 'a example of a person using {}.', + 'a demonstration of a person using {}.', + 'a photo of the person using {}.', + 'a video of the person using {}.', + 'a example of the person using {}.', + 'a demonstration of the person using {}.', + 'a photo of a person doing {}.', + 'a video of a person doing {}.', + 'a example of a person doing {}.', + 'a demonstration of a person doing {}.', + 'a photo of the person doing {}.', + 'a video of the person doing {}.', + 'a example of the person doing {}.', + 'a demonstration of the person doing {}.', + 'a photo of a person during {}.', + 'a video of a person during {}.', + 'a example of a person during {}.', + 'a demonstration of a person during {}.', + 'a photo of the person during {}.', + 'a video of the person during {}.', + 'a example of the person during {}.', + 'a demonstration of the person during {}.', + 'a photo of a person performing {}.', + 'a video of a person performing {}.', + 'a example of a person performing {}.', + 'a demonstration of a person performing {}.', + 'a photo of the person performing {}.', + 'a video of the person performing {}.', + 'a example of the person performing {}.', + 'a demonstration of the person performing {}.', + 'a photo of a person practicing {}.', + 'a video of a person practicing {}.', + 'a example of a person practicing {}.', + 'a demonstration of a person practicing {}.', + 'a photo of the person practicing {}.', + 'a video of the person practicing {}.', + 'a example of the person practicing {}.', + 'a demonstration of the person practicing {}.', +] +``` + + diff --git a/CLIP/data/rendered-sst2.md b/CLIP/data/rendered-sst2.md new file mode 100644 index 0000000..d27454c --- /dev/null +++ b/CLIP/data/rendered-sst2.md @@ -0,0 +1,11 @@ +# The Rendered SST2 Dataset + +In the paper, we used an image classification dataset called Rendered SST2, to evaluate the model's capability on optical character recognition. To do so, we rendered the sentences in the [Standford Sentiment Treebank v2](https://nlp.stanford.edu/sentiment/treebank.html) dataset and used those as the input to the CLIP image encoder. + +The following command will download a 131MB archive countaining the images and extract into a subdirectory `rendered-sst2`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/rendered-sst2.tgz +tar zxvf rendered-sst2.tgz +``` + diff --git a/CLIP/data/yfcc100m.md b/CLIP/data/yfcc100m.md new file mode 100644 index 0000000..06083ef --- /dev/null +++ b/CLIP/data/yfcc100m.md @@ -0,0 +1,14 @@ +# The YFCC100M Subset + +In the paper, we performed a dataset ablation using a subset of the YFCC100M dataset and showed that the performance remained largely similar. + +The subset contains 14,829,396 images, about 15% of the full dataset, which have been filtered to only keep those with natural languag titles and/or descriptions in English. + +We provide the list of (line number, photo identifier, photo hash) of each image contained in this subset. These correspond to the first three columns in the dataset's metadata TSV file. + +```bash +wget https://openaipublic.azureedge.net/clip/data/yfcc100m_subset_data.tsv.bz2 +bunzip2 yfcc100m_subset_data.tsv.bz2 +``` + +Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/downoad_clip_models.py b/CLIP/downoad_clip_models.py new file mode 100644 index 0000000..296e50b --- /dev/null +++ b/CLIP/downoad_clip_models.py @@ -0,0 +1,24 @@ + +import requests +import os + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + +save_dir = 'clip_models/' + +for model_name in _MODELS: + url = _MODELS[model_name] + response = requests.get(url) + save_file_path = save_dir + os.path.basename(url) + open(save_file_path, "wb").write(response.content) + print(f"Wrote model {model_name} to file {save_file_path}") \ No newline at end of file diff --git a/CLIP/hubconf.py b/CLIP/hubconf.py new file mode 100644 index 0000000..520b354 --- /dev/null +++ b/CLIP/hubconf.py @@ -0,0 +1,42 @@ +from clip.clip import tokenize as _tokenize, load as _load, available_models as _available_models +import re +import string + +dependencies = ["torch", "torchvision", "ftfy", "regex", "tqdm"] + +# For compatibility (cannot include special characters in function name) +model_functions = { model: re.sub(f'[{string.punctuation}]', '_', model) for model in _available_models()} + +def _create_hub_entrypoint(model): + def entrypoint(**kwargs): + return _load(model, **kwargs) + + entrypoint.__doc__ = f"""Loads the {model} CLIP model + + Parameters + ---------- + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The {model} CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + return entrypoint + +def tokenize(): + return _tokenize + +_entrypoints = {model_functions[model]: _create_hub_entrypoint(model) for model in _available_models()} + +globals().update(_entrypoints) \ No newline at end of file diff --git a/CLIP/model-card.md b/CLIP/model-card.md new file mode 100644 index 0000000..6db1ca4 --- /dev/null +++ b/CLIP/model-card.md @@ -0,0 +1,120 @@ +# Model Card: CLIP + +Inspired by [Model Cards for Model Reporting (Mitchell et al.)](https://arxiv.org/abs/1810.03993) and [Lessons from Archives (Jo & Gebru)](https://arxiv.org/pdf/1912.10389.pdf), we’re providing some accompanying information about the multimodal model. + +## Model Details + +The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. + +### Model Date + +January 2021 + +### Model Type + +The base model uses a ResNet50 with several modifications as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. There is also a variant of the model where the ResNet image encoder is replaced with a Vision Transformer. + +### Model Versions + +Initially, we’ve released one CLIP model based on the Vision Transformer architecture equivalent to ViT-B/32, along with the RN50 model, using the architecture equivalent to ResNet-50. + +As part of the staged release process, we have also released the RN101 model, as well as RN50x4, a RN50 scaled up 4x according to the [EfficientNet](https://arxiv.org/abs/1905.11946) scaling rule. In July 2021, we additionally released the RN50x16 and ViT-B/16 models, and in January 2022, the RN50x64 and ViT-L/14 models were released. Lastly, the ViT-L/14@336px model was released in April 2022. + +Please see the paper linked below for further details about their specification. + +### Documents + +- [Blog Post](https://openai.com/blog/clip/) +- [CLIP Paper](https://arxiv.org/abs/2103.00020) + + + +## Model Use + +### Intended Use + +The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. + +#### Primary intended uses + +The primary intended users of these models are AI researchers. + +We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. + +### Out-of-Scope Use Cases + +**Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. + +Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. + +Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. + + + +## Data + +The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as [YFCC100M](http://projects.dfki.uni-kl.de/yfcc100m/). A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. + +### Data Mission Statement + +Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. + + + +## Performance and Limitations + +### Performance + +We have evaluated the performance of CLIP on a wide range of benchmarks across a variety of computer vision datasets such as OCR to texture recognition to fine-grained classification. The paper describes model performance on the following datasets: + +- Food101 +- CIFAR10 +- CIFAR100 +- Birdsnap +- SUN397 +- Stanford Cars +- FGVC Aircraft +- VOC2007 +- DTD +- Oxford-IIIT Pet dataset +- Caltech101 +- Flowers102 +- MNIST +- SVHN +- IIIT5K +- Hateful Memes +- SST-2 +- UCF101 +- Kinetics700 +- Country211 +- CLEVR Counting +- KITTI Distance +- STL-10 +- RareAct +- Flickr30 +- MSCOCO +- ImageNet +- ImageNet-A +- ImageNet-R +- ImageNet Sketch +- ObjectNet (ImageNet Overlap) +- Youtube-BB +- ImageNet-Vid + +## Limitations + +CLIP and our analysis of it have a number of limitations. CLIP currently struggles with respect to certain tasks such as fine grained classification and counting objects. CLIP also poses issues with regards to fairness and bias which we discuss in the paper and briefly in the next section. Additionally, our approach to testing CLIP also has an important limitation- in many cases we have used linear probes to evaluate the performance of CLIP and there is evidence suggesting that linear probes can underestimate model performance. + +### Bias and Fairness + +We find that the performance of CLIP - and the specific biases it exhibits - can depend significantly on class design and the choices one makes for categories to include and exclude. We tested the risk of certain kinds of denigration with CLIP by classifying images of people from [Fairface](https://arxiv.org/abs/1908.04913) into crime-related and non-human animal categories. We found significant disparities with respect to race and gender. Additionally, we found that these disparities could shift based on how the classes were constructed. (Details captured in the Broader Impacts Section in the paper). + +We also tested the performance of CLIP on gender, race and age classification using the Fairface dataset (We default to using race categories as they are constructed in the Fairface dataset.) in order to assess quality of performance across different demographics. We found accuracy >96% across all races for gender classification with ‘Middle Eastern’ having the highest accuracy (98.4%) and ‘White’ having the lowest (96.5%). Additionally, CLIP averaged ~93% for racial classification and ~63% for age classification. Our use of evaluations to test for gender, race and age classification as well as denigration harms is simply to evaluate performance of the model across people and surface potential risks and not to demonstrate an endorsement/enthusiasm for such tasks. + + + +## Feedback + +### Where to send questions or comments about the model + +Please use [this Google Form](https://forms.gle/Uv7afRH5dvY34ZEs9) diff --git a/CLIP/notebooks/Interacting_with_CLIP.ipynb b/CLIP/notebooks/Interacting_with_CLIP.ipynb new file mode 100644 index 0000000..1043f23 --- /dev/null +++ b/CLIP/notebooks/Interacting_with_CLIP.ipynb @@ -0,0 +1,925 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Interacting with CLIP.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "1369964d45004b5e95a058910b2a33e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_12e23e2819094ee0a079d4eb77cfc4f9", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7a5f52e56ede4ac3abe37a3ece007dc9", + "IPY_MODEL_ce8b0faa1a1340b5a504d7b3546b3ccb" + ] + } + }, + "12e23e2819094ee0a079d4eb77cfc4f9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "7a5f52e56ede4ac3abe37a3ece007dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_5e6adc4592124a4581b85f4c1f3bab4d", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 169001437, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 169001437, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_4a61c10fc00c4f04bb00b82e942da210" + } + }, + "ce8b0faa1a1340b5a504d7b3546b3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b597cd6f6cd443aba4bf4491ac7f957e", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 169001984/? [00:06<00:00, 25734958.25it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_161969cae25a49f38aacd1568d3cac6c" + } + }, + "5e6adc4592124a4581b85f4c1f3bab4d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "4a61c10fc00c4f04bb00b82e942da210": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b597cd6f6cd443aba4bf4491ac7f957e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "161969cae25a49f38aacd1568d3cac6c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "YPHN7PJgKOzb" + }, + "source": [ + "# Interacting with CLIP\n", + "\n", + "This is a self-contained notebook that shows how to download and run CLIP models, calculate the similarity between arbitrary image and text inputs, and perform zero-shot image classifications." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "4d9b51f8-d255-4868-97f6-be0a67dadfae" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 34.6 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 20.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 16.4 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 15.2 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 7.0 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 8.2 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 2.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=ce00f21233e5e1a5c3e84204d651ae0c17403484418c330c69ebae7297ca7003\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-tbmjxrgj\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-tbmjxrgj\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=9059060f3a406b8268cfcbbf03647ab9b59e660d03f86c6120a9dd06f2b82cec\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-7v3mrcvj/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "70a44964-883d-4fd0-b95a-2c7f2b19aca9" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "`clip.available_models()` will list the names of available CLIP models." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "11779e1e-8bdd-4167-c18e-d26bdd6b67db" + }, + "source": [ + "import clip\n", + "\n", + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "f06fd2fd-6126-475b-87d0-b10aa3b7da49" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")\n", + "model.cuda().eval()\n", + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.0MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "21slhZGCqANb" + }, + "source": [ + "# Image Preprocessing\n", + "\n", + "We resize the input images and center-crop them to conform with the image resolution that the model expects. Before doing so, we will normalize the pixel intensity using the dataset mean and standard deviation.\n", + "\n", + "The second return value from `clip.load()` contains a torchvision `Transform` that performs this preprocessing.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "d6cpiIFHp9N6", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "880cb98e-1e5e-430e-8b59-4bf35fa554f9" + }, + "source": [ + "preprocess" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Compose(\n", + " Resize(size=224, interpolation=bicubic, max_size=None, antialias=None)\n", + " CenterCrop(size=(224, 224))\n", + " . at 0x7f3a24ffb440>\n", + " ToTensor()\n", + " Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))\n", + ")" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xwSB5jZki3Cj" + }, + "source": [ + "# Text Preprocessing\n", + "\n", + "We use a case-insensitive tokenizer, which can be invoked using `clip.tokenize()`. By default, the outputs are padded to become 77 tokens long, which is what the CLIP models expects." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGom156-i2kL", + "outputId": "050b0ce1-caba-47e1-f4ac-dba994599718" + }, + "source": [ + "clip.tokenize(\"Hello World!\")" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[49406, 3306, 1002, 256, 49407, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Setting up input images and texts\n", + "\n", + "We are going to feed 8 example images and their textual descriptions to the model, and compare the similarity between the corresponding features.\n", + "\n", + "The tokenizer is case-insensitive, and we can freely give any suitable textual descriptions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tMc1AXzBlhzm" + }, + "source": [ + "import os\n", + "import skimage\n", + "import IPython.display\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from collections import OrderedDict\n", + "import torch\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# images in skimage to use and their textual descriptions\n", + "descriptions = {\n", + " \"page\": \"a page of text about segmentation\",\n", + " \"chelsea\": \"a facial photo of a tabby cat\",\n", + " \"astronaut\": \"a portrait of an astronaut with the American flag\",\n", + " \"rocket\": \"a rocket standing on a launchpad\",\n", + " \"motorcycle_right\": \"a red motorcycle standing in a garage\",\n", + " \"camera\": \"a person looking at a camera on a tripod\",\n", + " \"horse\": \"a black-and-white silhouette of a horse\", \n", + " \"coffee\": \"a cup of coffee on a saucer\"\n", + "}" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NSSrLY185jSf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "outputId": "06451963-5ecb-4ddc-d0a8-24e9b110af7d" + }, + "source": [ + "original_images = []\n", + "images = []\n", + "texts = []\n", + "plt.figure(figsize=(16, 5))\n", + "\n", + "for filename in [filename for filename in os.listdir(skimage.data_dir) if filename.endswith(\".png\") or filename.endswith(\".jpg\")]:\n", + " name = os.path.splitext(filename)[0]\n", + " if name not in descriptions:\n", + " continue\n", + "\n", + " image = Image.open(os.path.join(skimage.data_dir, filename)).convert(\"RGB\")\n", + " \n", + " plt.subplot(2, 4, len(images) + 1)\n", + " plt.imshow(image)\n", + " plt.title(f\"{filename}\\n{descriptions[name]}\")\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " original_images.append(image)\n", + " images.append(preprocess(image))\n", + " texts.append(descriptions[name])\n", + "\n", + "plt.tight_layout()\n" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1116, + "height": 351 + } + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEVKsji6WOIX" + }, + "source": [ + "## Building features\n", + "\n", + "We normalize the images, tokenize each text input, and run the forward pass of the model to get the image and text features." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HBgCanxi8JKw" + }, + "source": [ + "image_input = torch.tensor(np.stack(images)).cuda()\n", + "text_tokens = clip.tokenize([\"This is \" + desc for desc in texts]).cuda()" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZN9I0nIBZ_vW" + }, + "source": [ + "with torch.no_grad():\n", + " image_features = model.encode_image(image_input).float()\n", + " text_features = model.encode_text(text_tokens).float()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuxm2Gt4Wvzt" + }, + "source": [ + "## Calculating cosine similarity\n", + "\n", + "We normalize the features and calculate the dot product of each pair." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yKAxkQR7bf3A" + }, + "source": [ + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5zvMxh8cU6m", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 831 + }, + "outputId": "22bca748-ab42-4888-c9da-8f22c21c6185" + }, + "source": [ + "count = len(descriptions)\n", + "\n", + "plt.figure(figsize=(20, 14))\n", + "plt.imshow(similarity, vmin=0.1, vmax=0.3)\n", + "# plt.colorbar()\n", + "plt.yticks(range(count), texts, fontsize=18)\n", + "plt.xticks([])\n", + "for i, image in enumerate(original_images):\n", + " plt.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin=\"lower\")\n", + "for x in range(similarity.shape[1]):\n", + " for y in range(similarity.shape[0]):\n", + " plt.text(x, y, f\"{similarity[y, x]:.2f}\", ha=\"center\", va=\"center\", size=12)\n", + "\n", + "for side in [\"left\", \"top\", \"right\", \"bottom\"]:\n", + " plt.gca().spines[side].set_visible(False)\n", + "\n", + "plt.xlim([-0.5, count - 0.5])\n", + "plt.ylim([count + 0.5, -2])\n", + "\n", + "plt.title(\"Cosine similarity between text and image features\", size=20)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cosine similarity between text and image features')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1038, + "height": 796 + }, + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "alePijoXy6AH" + }, + "source": [ + "# Zero-Shot Image Classification\n", + "\n", + "You can classify images using the cosine similarity (times 100) as the logits to the softmax operation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Nqu4GlfPfr-p", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "1369964d45004b5e95a058910b2a33e6", + "12e23e2819094ee0a079d4eb77cfc4f9", + "7a5f52e56ede4ac3abe37a3ece007dc9", + "ce8b0faa1a1340b5a504d7b3546b3ccb", + "5e6adc4592124a4581b85f4c1f3bab4d", + "4a61c10fc00c4f04bb00b82e942da210", + "b597cd6f6cd443aba4bf4491ac7f957e", + "161969cae25a49f38aacd1568d3cac6c" + ] + }, + "outputId": "ca7a0e3c-e267-4e6e-8a1b-bbab3c0a2462" + }, + "source": [ + "from torchvision.datasets import CIFAR100\n", + "\n", + "cifar100 = CIFAR100(os.path.expanduser(\"~/.cache\"), transform=preprocess, download=True)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /root/.cache/cifar-100-python.tar.gz\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1369964d45004b5e95a058910b2a33e6", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=169001437.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Extracting /root/.cache/cifar-100-python.tar.gz to /root/.cache\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4S__zCGy2MT" + }, + "source": [ + "text_descriptions = [f\"This is a photo of a {label}\" for label in cifar100.classes]\n", + "text_tokens = clip.tokenize(text_descriptions).cuda()" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4z1fm9vCpSR" + }, + "source": [ + "with torch.no_grad():\n", + " text_features = model.encode_text(text_tokens).float()\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "top_probs, top_labels = text_probs.cpu().topk(5, dim=-1)" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 931 + }, + "id": "T6Ju_6IBE2Iz", + "outputId": "e1a155dc-474d-409c-e03d-d41b804648c3" + }, + "source": [ + "plt.figure(figsize=(16, 16))\n", + "\n", + "for i, image in enumerate(original_images):\n", + " plt.subplot(4, 4, 2 * i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(4, 4, 2 * i + 2)\n", + " y = np.arange(top_probs.shape[-1])\n", + " plt.grid()\n", + " plt.barh(y, top_probs[i])\n", + " plt.gca().invert_yaxis()\n", + " plt.gca().set_axisbelow(True)\n", + " plt.yticks(y, [cifar100.classes[index] for index in top_labels[i].numpy()])\n", + " plt.xlabel(\"probability\")\n", + "\n", + "plt.subplots_adjust(wspace=0.5)\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 917, + "height": 914 + }, + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb new file mode 100644 index 0000000..dba7fb6 --- /dev/null +++ b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb @@ -0,0 +1,1107 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Prompt Engineering for ImageNet.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "66a1639713ae441d8a9b873381f9d774": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_610b775178c645e2b4663b77cc0c67b6", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_412dd15f0d8542f5ab2730f8616fb582", + "IPY_MODEL_5e6315f36b4e4eeea5c6294b024e0c97" + ] + } + }, + "610b775178c645e2b4663b77cc0c67b6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "412dd15f0d8542f5ab2730f8616fb582": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_085d5388abda4202bfa66d0c088452f8", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 1000, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 1000, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f75124b64aa147c693c67a78f8e3a231" + } + }, + "5e6315f36b4e4eeea5c6294b024e0c97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6e5676a054874243b55fc6d120a07d01", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 1000/1000 [16:51<00:00, 1.01s/it]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_dc6d1416c01a4047935ee15c3fd2eb1c" + } + }, + "085d5388abda4202bfa66d0c088452f8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "f75124b64aa147c693c67a78f8e3a231": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6e5676a054874243b55fc6d120a07d01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "dc6d1416c01a4047935ee15c3fd2eb1c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "84f80a7f3e764346969a347b0f71b24e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_392656f01b2945f3bd7903783ed8cc96", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_8e47a435519b4ce090879b4be2f61f99", + "IPY_MODEL_41b1ed6b0a9745c1a595377670b15ff4" + ] + } + }, + "392656f01b2945f3bd7903783ed8cc96": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "8e47a435519b4ce090879b4be2f61f99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_179b8ae1eb7f4a828f953e889b141725", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 313, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 313, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_d8708e8414fd44f4abd6590c9b57996f" + } + }, + "41b1ed6b0a9745c1a595377670b15ff4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_800e30f5b4f24475a2b0046da0703631", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 313/313 [02:31<00:00, 2.07it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8764308b948745f1a677332fd21fcaf0" + } + }, + "179b8ae1eb7f4a828f953e889b141725": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "d8708e8414fd44f4abd6590c9b57996f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "800e30f5b4f24475a2b0046da0703631": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "8764308b948745f1a677332fd21fcaf0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "41a4070f-5321-4fc4-bd4d-0b5c1f476d56" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 14.9 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 18.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 9.0 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 4.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 4.6 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 4.7 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 1.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=90ec193331444b2c4ff1cd81935e7de42065b89d304db7efac67bcfd87c27873\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-hqnbveqi\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-hqnbveqi\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=fda43d2b80cfb2b33c2d43e23ea5f53293a9a8b48d5f9e341de527f6adfbf5a3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmmplf44/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e10d4f17-8fa6-4b75-a18f-f0c38990b5a3" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "import clip\n", + "from tqdm.notebook import tqdm\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "Download and instantiate a CLIP model using the `clip` module that we just installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "09abb234-693e-4efb-953f-e1847ba95758" + }, + "source": [ + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cboKZocQlSYX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "240acdd0-ca62-45db-8418-9e4ef73e8aff" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.6MiB/s]\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "785019a1-1f40-45b0-e349-b0d4ec3173bf" + }, + "source": [ + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LhO3OtOmF8M4" + }, + "source": [ + "# Preparing ImageNet labels and prompts\n", + "\n", + "The following cell contains the 1,000 labels for the ImageNet dataset, followed by the text templates we'll use as \"prompt engineering\"." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "R2HbOZrqa0jF" + }, + "source": [ + "imagenet_classes = [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eMQSCuBta2G6" + }, + "source": [ + "A subset of these class names are modified from the default ImageNet class names sourced from Anish Athalye's imagenet-simple-labels.\n", + "\n", + "These edits were made via trial and error and concentrated on the lowest performing classes according to top_1 and top_5 accuracy on the ImageNet training set for the RN50, RN101, and RN50x4 models. These tweaks improve top_1 by 1.5% on ViT-B/32 over using the default class names. Alec got bored somewhere along the way as gains started to diminish and never finished updating / tweaking the list. He also didn't revisit this with the better performing RN50x16, RN50x64, or any of the ViT models. He thinks it's likely another 0.5% to 1% top_1 could be gained from further work here. It'd be interesting to more rigorously study / understand this.\n", + "\n", + "Some examples beyond the crane/crane -> construction crane / bird crane issue mentioned in Section 3.1.4 of the paper include:\n", + "\n", + "- CLIP interprets \"nail\" as \"fingernail\" so we changed the label to \"metal nail\".\n", + "- ImageNet kite class refers to the bird of prey, not the flying toy, so we changed \"kite\" to \"kite (bird of prey)\"\n", + "- The ImageNet class for red wolf seems to include a lot of mislabeled maned wolfs so we changed \"red wolf\" to \"red wolf or maned wolf\"" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "toGtcd-Ji_MD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6eb0753-2bee-4144-abe3-fbd23f35f555" + }, + "source": [ + "imagenet_templates = [\n", + " 'a bad photo of a {}.',\n", + " 'a photo of many {}.',\n", + " 'a sculpture of a {}.',\n", + " 'a photo of the hard to see {}.',\n", + " 'a low resolution photo of the {}.',\n", + " 'a rendering of a {}.',\n", + " 'graffiti of a {}.',\n", + " 'a bad photo of the {}.',\n", + " 'a cropped photo of the {}.',\n", + " 'a tattoo of a {}.',\n", + " 'the embroidered {}.',\n", + " 'a photo of a hard to see {}.',\n", + " 'a bright photo of a {}.',\n", + " 'a photo of a clean {}.',\n", + " 'a photo of a dirty {}.',\n", + " 'a dark photo of the {}.',\n", + " 'a drawing of a {}.',\n", + " 'a photo of my {}.',\n", + " 'the plastic {}.',\n", + " 'a photo of the cool {}.',\n", + " 'a close-up photo of a {}.',\n", + " 'a black and white photo of the {}.',\n", + " 'a painting of the {}.',\n", + " 'a painting of a {}.',\n", + " 'a pixelated photo of the {}.',\n", + " 'a sculpture of the {}.',\n", + " 'a bright photo of the {}.',\n", + " 'a cropped photo of a {}.',\n", + " 'a plastic {}.',\n", + " 'a photo of the dirty {}.',\n", + " 'a jpeg corrupted photo of a {}.',\n", + " 'a blurry photo of the {}.',\n", + " 'a photo of the {}.',\n", + " 'a good photo of the {}.',\n", + " 'a rendering of the {}.',\n", + " 'a {} in a video game.',\n", + " 'a photo of one {}.',\n", + " 'a doodle of a {}.',\n", + " 'a close-up photo of the {}.',\n", + " 'a photo of a {}.',\n", + " 'the origami {}.',\n", + " 'the {} in a video game.',\n", + " 'a sketch of a {}.',\n", + " 'a doodle of the {}.',\n", + " 'a origami {}.',\n", + " 'a low resolution photo of a {}.',\n", + " 'the toy {}.',\n", + " 'a rendition of the {}.',\n", + " 'a photo of the clean {}.',\n", + " 'a photo of a large {}.',\n", + " 'a rendition of a {}.',\n", + " 'a photo of a nice {}.',\n", + " 'a photo of a weird {}.',\n", + " 'a blurry photo of a {}.',\n", + " 'a cartoon {}.',\n", + " 'art of a {}.',\n", + " 'a sketch of the {}.',\n", + " 'a embroidered {}.',\n", + " 'a pixelated photo of a {}.',\n", + " 'itap of the {}.',\n", + " 'a jpeg corrupted photo of the {}.',\n", + " 'a good photo of a {}.',\n", + " 'a plushie {}.',\n", + " 'a photo of the nice {}.',\n", + " 'a photo of the small {}.',\n", + " 'a photo of the weird {}.',\n", + " 'the cartoon {}.',\n", + " 'art of the {}.',\n", + " 'a drawing of the {}.',\n", + " 'a photo of the large {}.',\n", + " 'a black and white photo of a {}.',\n", + " 'the plushie {}.',\n", + " 'a dark photo of a {}.',\n", + " 'itap of a {}.',\n", + " 'graffiti of the {}.',\n", + " 'a toy {}.',\n", + " 'itap of my {}.',\n", + " 'a photo of a cool {}.',\n", + " 'a photo of a small {}.',\n", + " 'a tattoo of the {}.',\n", + "]\n", + "\n", + "print(f\"{len(imagenet_classes)} classes, {len(imagenet_templates)} templates\")" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1000 classes, 80 templates\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aRB5OzgpHwqQ" + }, + "source": [ + "A similar, intuition-guided trial and error based on the ImageNet training set was used for templates. This list is pretty haphazard and was gradually made / expanded over the course of about a year of the project and was revisited / tweaked every few months. A surprising / weird thing was adding templates intended to help ImageNet-R performance (specifying different possible renditions of an object) improved standard ImageNet accuracy too.\n", + "\n", + "After the 80 templates were \"locked\" for the paper, we ran sequential forward selection over the list of 80 templates. The search terminated after ensembling 7 templates and selected them in the order below.\n", + "\n", + "1. itap of a {}.\n", + "2. a bad photo of the {}.\n", + "3. a origami {}.\n", + "4. a photo of the large {}.\n", + "5. a {} in a video game.\n", + "6. art of the {}.\n", + "7. a photo of the small {}.\n", + "\n", + "Speculating, we think it's interesting to see different scales (large and small), a difficult view (a bad photo), and \"abstract\" versions (origami, video game, art), were all selected for, but we haven't studied this in any detail. This subset performs a bit better than the full 80 ensemble reported in the paper, especially for the smaller models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Loading the Images\n", + "\n", + "The ILSVRC2012 datasets are no longer available for download publicly. We instead download the ImageNet-V2 dataset by [Recht et al.](https://arxiv.org/abs/1902.10811).\n", + "\n", + "If you have the ImageNet dataset downloaded, you can replace the dataset with the official torchvision loader, e.g.:\n", + "\n", + "```python\n", + "images = torchvision.datasets.ImageNet(\"path/to/imagenet\", split='val', transform=preprocess)\n", + "```" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "moHR4UlHKsDc", + "outputId": "40731297-edc7-4cd0-be75-ed426c8fb005" + }, + "source": [ + "! pip install git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + "\n", + "from imagenetv2_pytorch import ImageNetV2Dataset\n", + "\n", + "images = ImageNetV2Dataset(transform=preprocess)\n", + "loader = torch.utils.data.DataLoader(images, batch_size=32, num_workers=2)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + " Cloning https://github.com/modestyachts/ImageNetV2_pytorch to /tmp/pip-req-build-0kih0kn2\n", + " Running command git clone -q https://github.com/modestyachts/ImageNetV2_pytorch /tmp/pip-req-build-0kih0kn2\n", + "Building wheels for collected packages: imagenetv2-pytorch\n", + " Building wheel for imagenetv2-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for imagenetv2-pytorch: filename=imagenetv2_pytorch-0.1-py3-none-any.whl size=2663 sha256=ac31e0ed9c61afc5e0271eed315d3a82844a79ae64f8ce43fc1c98928cec129f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-745b5n1m/wheels/ab/ee/f4/73bce5c7f68d28ce632ef33ae87ce60aaca021eb2b3b31a6fa\n", + "Successfully built imagenetv2-pytorch\n", + "Installing collected packages: imagenetv2-pytorch\n", + "Successfully installed imagenetv2-pytorch-0.1\n", + "Dataset matched-frequency not found on disk, downloading....\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "100%|██████████| 1.26G/1.26G [01:02<00:00, 20.2MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Extracting....\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fz6D-F-Wbrtp" + }, + "source": [ + "# Creating zero-shot classifier weights" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "66a1639713ae441d8a9b873381f9d774", + "610b775178c645e2b4663b77cc0c67b6", + "412dd15f0d8542f5ab2730f8616fb582", + "5e6315f36b4e4eeea5c6294b024e0c97", + "085d5388abda4202bfa66d0c088452f8", + "f75124b64aa147c693c67a78f8e3a231", + "6e5676a054874243b55fc6d120a07d01", + "dc6d1416c01a4047935ee15c3fd2eb1c" + ] + }, + "id": "sRqDoz1Gbsii", + "outputId": "312b8ebf-3961-4903-d8cb-3b7a94cc97b6" + }, + "source": [ + "def zeroshot_classifier(classnames, templates):\n", + " with torch.no_grad():\n", + " zeroshot_weights = []\n", + " for classname in tqdm(classnames):\n", + " texts = [template.format(classname) for template in templates] #format with class\n", + " texts = clip.tokenize(texts).cuda() #tokenize\n", + " class_embeddings = model.encode_text(texts) #embed with text encoder\n", + " class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n", + " class_embedding = class_embeddings.mean(dim=0)\n", + " class_embedding /= class_embedding.norm()\n", + " zeroshot_weights.append(class_embedding)\n", + " zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n", + " return zeroshot_weights\n", + "\n", + "\n", + "zeroshot_weights = zeroshot_classifier(imagenet_classes, imagenet_templates)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66a1639713ae441d8a9b873381f9d774", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1fZo7hG8iJP5" + }, + "source": [ + "# Zero-shot prediction" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "j4kPSZoShQxN" + }, + "source": [ + "def accuracy(output, target, topk=(1,)):\n", + " pred = output.topk(max(topk), 1, True, True)[1].t()\n", + " correct = pred.eq(target.view(1, -1).expand_as(pred))\n", + " return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk]" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "84f80a7f3e764346969a347b0f71b24e", + "392656f01b2945f3bd7903783ed8cc96", + "8e47a435519b4ce090879b4be2f61f99", + "41b1ed6b0a9745c1a595377670b15ff4", + "179b8ae1eb7f4a828f953e889b141725", + "d8708e8414fd44f4abd6590c9b57996f", + "800e30f5b4f24475a2b0046da0703631", + "8764308b948745f1a677332fd21fcaf0" + ] + }, + "id": "wKJ7YsdlkDXo", + "outputId": "ab824854-38e4-4d37-ad40-2a7ce3c5fd43" + }, + "source": [ + "with torch.no_grad():\n", + " top1, top5, n = 0., 0., 0.\n", + " for i, (images, target) in enumerate(tqdm(loader)):\n", + " images = images.cuda()\n", + " target = target.cuda()\n", + " \n", + " # predict\n", + " image_features = model.encode_image(images)\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " logits = 100. * image_features @ zeroshot_weights\n", + "\n", + " # measure accuracy\n", + " acc1, acc5 = accuracy(logits, target, topk=(1, 5))\n", + " top1 += acc1\n", + " top5 += acc5\n", + " n += images.size(0)\n", + "\n", + "top1 = (top1 / n) * 100\n", + "top5 = (top5 / n) * 100 \n", + "\n", + "print(f\"Top-1 accuracy: {top1:.2f}\")\n", + "print(f\"Top-5 accuracy: {top5:.2f}\")" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84f80a7f3e764346969a347b0f71b24e", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=313.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Top-1 accuracy: 55.93\n", + "Top-5 accuracy: 83.36\n" + ], + "name": "stdout" + } + ] + } + ] +} diff --git a/CLIP/requirements.txt b/CLIP/requirements.txt new file mode 100644 index 0000000..6b98c33 --- /dev/null +++ b/CLIP/requirements.txt @@ -0,0 +1,5 @@ +ftfy +regex +tqdm +torch +torchvision diff --git a/CLIP/setup.py b/CLIP/setup.py new file mode 100644 index 0000000..c9ea7d0 --- /dev/null +++ b/CLIP/setup.py @@ -0,0 +1,21 @@ +import os + +import pkg_resources +from setuptools import setup, find_packages + +setup( + name="clip", + py_modules=["clip"], + version="1.0", + description="", + author="OpenAI", + packages=find_packages(exclude=["tests*"]), + install_requires=[ + str(r) + for r in pkg_resources.parse_requirements( + open(os.path.join(os.path.dirname(__file__), "requirements.txt")) + ) + ], + include_package_data=True, + extras_require={'dev': ['pytest']}, +) diff --git a/CLIP/tests/test_consistency.py b/CLIP/tests/test_consistency.py new file mode 100644 index 0000000..f2c6fd4 --- /dev/null +++ b/CLIP/tests/test_consistency.py @@ -0,0 +1,25 @@ +import numpy as np +import pytest +import torch +from PIL import Image + +import clip + + +@pytest.mark.parametrize('model_name', clip.available_models()) +def test_consistency(model_name): + device = "cpu" + jit_model, transform = clip.load(model_name, device=device, jit=True) + py_model, _ = clip.load(model_name, device=device, jit=False) + + image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device) + text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + + with torch.no_grad(): + logits_per_image, _ = jit_model(image, text) + jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + logits_per_image, _ = py_model(image, text) + py_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1) From ac6e03809a360a04f596d1b2e85fb84f277d13fe Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:08:52 -0700 Subject: [PATCH 124/197] Add CLIP --- CLIP | 1 - CLIP/.gitignore | 10 + CLIP/CLIP.png | Bin 0 -> 252444 bytes CLIP/LICENSE | 22 + CLIP/MANIFEST.in | 1 + CLIP/README.md | 193 + CLIP/clip/__init__.py | 1 + CLIP/clip/bpe_simple_vocab_16e6.txt.gz | Bin 0 -> 1356917 bytes CLIP/clip/clip.py | 244 ++ CLIP/clip/model.py | 436 +++ CLIP/clip/simple_tokenizer.py | 132 + CLIP/data/country211.md | 12 + CLIP/data/prompts.md | 3401 +++++++++++++++++ CLIP/data/rendered-sst2.md | 11 + CLIP/data/yfcc100m.md | 14 + CLIP/downoad_clip_models.py | 24 + CLIP/hubconf.py | 42 + CLIP/model-card.md | 120 + CLIP/notebooks/Interacting_with_CLIP.ipynb | 925 +++++ .../Prompt_Engineering_for_ImageNet.ipynb | 1107 ++++++ CLIP/requirements.txt | 5 + CLIP/setup.py | 21 + CLIP/tests/test_consistency.py | 25 + 23 files changed, 6746 insertions(+), 1 deletion(-) delete mode 160000 CLIP create mode 100644 CLIP/.gitignore create mode 100644 CLIP/CLIP.png create mode 100644 CLIP/LICENSE create mode 100644 CLIP/MANIFEST.in create mode 100644 CLIP/README.md create mode 100644 CLIP/clip/__init__.py create mode 100644 CLIP/clip/bpe_simple_vocab_16e6.txt.gz create mode 100644 CLIP/clip/clip.py create mode 100644 CLIP/clip/model.py create mode 100644 CLIP/clip/simple_tokenizer.py create mode 100644 CLIP/data/country211.md create mode 100644 CLIP/data/prompts.md create mode 100644 CLIP/data/rendered-sst2.md create mode 100644 CLIP/data/yfcc100m.md create mode 100644 CLIP/downoad_clip_models.py create mode 100644 CLIP/hubconf.py create mode 100644 CLIP/model-card.md create mode 100644 CLIP/notebooks/Interacting_with_CLIP.ipynb create mode 100644 CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb create mode 100644 CLIP/requirements.txt create mode 100644 CLIP/setup.py create mode 100644 CLIP/tests/test_consistency.py diff --git a/CLIP b/CLIP deleted file mode 160000 index d50d76d..0000000 --- a/CLIP +++ /dev/null @@ -1 +0,0 @@ -Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 diff --git a/CLIP/.gitignore b/CLIP/.gitignore new file mode 100644 index 0000000..321f181 --- /dev/null +++ b/CLIP/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.py[cod] +*$py.class +*.egg-info +.pytest_cache +.ipynb_checkpoints + +thumbs.db +.DS_Store +.idea diff --git a/CLIP/CLIP.png b/CLIP/CLIP.png new file mode 100644 index 0000000000000000000000000000000000000000..a1b5ec9171fd7a51e36e845a02304eb837142ba1 GIT binary patch literal 252444 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%0A|F7fvQOLDQFPf3 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

Rp5@H-63rPkl?5M!`%e$q5M^(XmdeOwiW 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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG 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

nj;X-C@gua07)qPBmS6kxKbsrp_1VbHQ%kr&^ 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�J#6HekB- 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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9> 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

brXZX@VYhc!=SFxwhp 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 z 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

B0o?DtF!VT!YjrDC^S2?RV?P>**rUM?tSk)et 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 literal 0 HcmV?d00001 diff --git a/CLIP/clip/clip.py b/CLIP/clip/clip.py new file mode 100644 index 0000000..cedac5f --- /dev/null +++ b/CLIP/clip/clip.py @@ -0,0 +1,244 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str, amlt_root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + + amlt_download_target = os.path.join(amlt_root, filename) + if os.path.isfile(amlt_download_target): + if hashlib.sha256(open(amlt_download_target, "rb").read()).hexdigest() == expected_sha256: + return amlt_download_target + + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + # Use an amlt_root for amulet. + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip"), amlt_root='/mnt/default/pretrained_weights') + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/CLIP/clip/model.py b/CLIP/clip/model.py new file mode 100644 index 0000000..232b779 --- /dev/null +++ b/CLIP/clip/model.py @@ -0,0 +1,436 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu1(self.bn1(self.conv1(x))) + out = self.relu2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x[:1], key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + return x.squeeze(0) + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.relu3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=1, keepdim=True) + text_features = text_features / text_features.norm(dim=1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/CLIP/clip/simple_tokenizer.py b/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000..0a66286 --- /dev/null +++ b/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/CLIP/data/country211.md b/CLIP/data/country211.md new file mode 100644 index 0000000..4cd0960 --- /dev/null +++ b/CLIP/data/country211.md @@ -0,0 +1,12 @@ +# The Country211 Dataset + +In the paper, we used an image classification dataset called Country211, to evaluate the model's capability on geolocation. To do so, we filtered the YFCC100m dataset that have GPS coordinate corresponding to a [ISO-3166 country code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) and created a balanced dataset by sampling 150 train images, 50 validation images, and 100 test images images for each country. + +The following command will download an 11GB archive countaining the images and extract into a subdirectory `country211`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/country211.tgz +tar zxvf country211.tgz +``` + +These images are a subset of the YFCC100m dataset. Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/data/prompts.md b/CLIP/data/prompts.md new file mode 100644 index 0000000..6d8aaf7 --- /dev/null +++ b/CLIP/data/prompts.md @@ -0,0 +1,3401 @@ +# Prompts for Image Classification + +Below are the class names and templates that are used for collecting the zero-shot classification scores in the paper. Each dataset has two lists `classes` and `templates`, where the string `{}` in the template is to be replaced with the corresponding class names. For the Facial Emotion Recognition 2013 dataset specifically, we used multiple class names for certain classes. + +This file contains prompt data for 26 of the 27 datasets shown in Table 9 of the paper; the text prompts for ImageNet (as well as other [ImageNet Testbed](https://modestyachts.github.io/imagenet-testbed/) datasets in Figure 13) can be found in [this notebook](https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb), as well as how to ensemble predictions from multiple prompts using these templates. + +If you are viewing this document on GitHub, use the table of contents icon at the upper left to browse the datasets. + + +## Birdsnap + +```bash +classes = [ + 'Acadian Flycatcher', + 'Acorn Woodpecker', + 'Alder Flycatcher', + 'Allens Hummingbird', + 'Altamira Oriole', + 'American Avocet', + 'American Bittern', + 'American Black Duck', + 'American Coot', + 'American Crow', + 'American Dipper', + 'American Golden Plover', + 'American Goldfinch', + 'American Kestrel', + 'American Oystercatcher', + 'American Pipit', + 'American Redstart', + 'American Robin', + 'American Three toed Woodpecker', + 'American Tree Sparrow', + 'American White Pelican', + 'American Wigeon', + 'American Woodcock', + 'Anhinga', + 'Annas Hummingbird', + 'Arctic Tern', + 'Ash throated Flycatcher', + 'Audubons Oriole', + 'Bairds Sandpiper', + 'Bald Eagle', + 'Baltimore Oriole', + 'Band tailed Pigeon', + 'Barn Swallow', + 'Barred Owl', + 'Barrows Goldeneye', + 'Bay breasted Warbler', + 'Bells Vireo', + 'Belted Kingfisher', + 'Bewicks Wren', + 'Black Guillemot', + 'Black Oystercatcher', + 'Black Phoebe', + 'Black Rosy Finch', + 'Black Scoter', + 'Black Skimmer', + 'Black Tern', + 'Black Turnstone', + 'Black Vulture', + 'Black and white Warbler', + 'Black backed Woodpecker', + 'Black bellied Plover', + 'Black billed Cuckoo', + 'Black billed Magpie', + 'Black capped Chickadee', + 'Black chinned Hummingbird', + 'Black chinned Sparrow', + 'Black crested Titmouse', + 'Black crowned Night Heron', + 'Black headed Grosbeak', + 'Black legged Kittiwake', + 'Black necked Stilt', + 'Black throated Blue Warbler', + 'Black throated Gray Warbler', + 'Black throated Green Warbler', + 'Black throated Sparrow', + 'Blackburnian Warbler', + 'Blackpoll Warbler', + 'Blue Grosbeak', + 'Blue Jay', + 'Blue gray Gnatcatcher', + 'Blue headed Vireo', + 'Blue winged Teal', + 'Blue winged Warbler', + 'Boat tailed Grackle', + 'Bobolink', + 'Bohemian Waxwing', + 'Bonapartes Gull', + 'Boreal Chickadee', + 'Brandts Cormorant', + 'Brant', + 'Brewers Blackbird', + 'Brewers Sparrow', + 'Bridled Titmouse', + 'Broad billed Hummingbird', + 'Broad tailed Hummingbird', + 'Broad winged Hawk', + 'Bronzed Cowbird', + 'Brown Creeper', + 'Brown Pelican', + 'Brown Thrasher', + 'Brown capped Rosy Finch', + 'Brown crested Flycatcher', + 'Brown headed Cowbird', + 'Brown headed Nuthatch', + 'Bufflehead', + 'Bullocks Oriole', + 'Burrowing Owl', + 'Bushtit', + 'Cackling Goose', + 'Cactus Wren', + 'California Gull', + 'California Quail', + 'California Thrasher', + 'California Towhee', + 'Calliope Hummingbird', + 'Canada Goose', + 'Canada Warbler', + 'Canvasback', + 'Canyon Towhee', + 'Canyon Wren', + 'Cape May Warbler', + 'Carolina Chickadee', + 'Carolina Wren', + 'Caspian Tern', + 'Cassins Finch', + 'Cassins Kingbird', + 'Cassins Sparrow', + 'Cassins Vireo', + 'Cattle Egret', + 'Cave Swallow', + 'Cedar Waxwing', + 'Cerulean Warbler', + 'Chestnut backed Chickadee', + 'Chestnut collared Longspur', + 'Chestnut sided Warbler', + 'Chihuahuan Raven', + 'Chimney Swift', + 'Chipping Sparrow', + 'Cinnamon Teal', + 'Clapper Rail', + 'Clarks Grebe', + 'Clarks Nutcracker', + 'Clay colored Sparrow', + 'Cliff Swallow', + 'Common Black Hawk', + 'Common Eider', + 'Common Gallinule', + 'Common Goldeneye', + 'Common Grackle', + 'Common Ground Dove', + 'Common Loon', + 'Common Merganser', + 'Common Murre', + 'Common Nighthawk', + 'Common Raven', + 'Common Redpoll', + 'Common Tern', + 'Common Yellowthroat', + 'Connecticut Warbler', + 'Coopers Hawk', + 'Cordilleran Flycatcher', + 'Costas Hummingbird', + 'Couchs Kingbird', + 'Crested Caracara', + 'Curve billed Thrasher', + 'Dark eyed Junco', + 'Dickcissel', + 'Double crested Cormorant', + 'Downy Woodpecker', + 'Dunlin', + 'Dusky Flycatcher', + 'Dusky Grouse', + 'Eared Grebe', + 'Eastern Bluebird', + 'Eastern Kingbird', + 'Eastern Meadowlark', + 'Eastern Phoebe', + 'Eastern Screech Owl', + 'Eastern Towhee', + 'Eastern Wood Pewee', + 'Elegant Trogon', + 'Elf Owl', + 'Eurasian Collared Dove', + 'Eurasian Wigeon', + 'European Starling', + 'Evening Grosbeak', + 'Ferruginous Hawk', + 'Ferruginous Pygmy Owl', + 'Field Sparrow', + 'Fish Crow', + 'Florida Scrub Jay', + 'Forsters Tern', + 'Fox Sparrow', + 'Franklins Gull', + 'Fulvous Whistling Duck', + 'Gadwall', + 'Gambels Quail', + 'Gila Woodpecker', + 'Glaucous Gull', + 'Glaucous winged Gull', + 'Glossy Ibis', + 'Golden Eagle', + 'Golden crowned Kinglet', + 'Golden crowned Sparrow', + 'Golden fronted Woodpecker', + 'Golden winged Warbler', + 'Grasshopper Sparrow', + 'Gray Catbird', + 'Gray Flycatcher', + 'Gray Jay', + 'Gray Kingbird', + 'Gray cheeked Thrush', + 'Gray crowned Rosy Finch', + 'Great Black backed Gull', + 'Great Blue Heron', + 'Great Cormorant', + 'Great Crested Flycatcher', + 'Great Egret', + 'Great Gray Owl', + 'Great Horned Owl', + 'Great Kiskadee', + 'Great tailed Grackle', + 'Greater Prairie Chicken', + 'Greater Roadrunner', + 'Greater Sage Grouse', + 'Greater Scaup', + 'Greater White fronted Goose', + 'Greater Yellowlegs', + 'Green Jay', + 'Green tailed Towhee', + 'Green winged Teal', + 'Groove billed Ani', + 'Gull billed Tern', + 'Hairy Woodpecker', + 'Hammonds Flycatcher', + 'Harlequin Duck', + 'Harriss Hawk', + 'Harriss Sparrow', + 'Heermanns Gull', + 'Henslows Sparrow', + 'Hepatic Tanager', + 'Hermit Thrush', + 'Herring Gull', + 'Hoary Redpoll', + 'Hooded Merganser', + 'Hooded Oriole', + 'Hooded Warbler', + 'Horned Grebe', + 'Horned Lark', + 'House Finch', + 'House Sparrow', + 'House Wren', + 'Huttons Vireo', + 'Iceland Gull', + 'Inca Dove', + 'Indigo Bunting', + 'Killdeer', + 'King Rail', + 'Ladder backed Woodpecker', + 'Lapland Longspur', + 'Lark Bunting', + 'Lark Sparrow', + 'Laughing Gull', + 'Lazuli Bunting', + 'Le Contes Sparrow', + 'Least Bittern', + 'Least Flycatcher', + 'Least Grebe', + 'Least Sandpiper', + 'Least Tern', + 'Lesser Goldfinch', + 'Lesser Nighthawk', + 'Lesser Scaup', + 'Lesser Yellowlegs', + 'Lewiss Woodpecker', + 'Limpkin', + 'Lincolns Sparrow', + 'Little Blue Heron', + 'Loggerhead Shrike', + 'Long billed Curlew', + 'Long billed Dowitcher', + 'Long billed Thrasher', + 'Long eared Owl', + 'Long tailed Duck', + 'Louisiana Waterthrush', + 'Magnificent Frigatebird', + 'Magnolia Warbler', + 'Mallard', + 'Marbled Godwit', + 'Marsh Wren', + 'Merlin', + 'Mew Gull', + 'Mexican Jay', + 'Mississippi Kite', + 'Monk Parakeet', + 'Mottled Duck', + 'Mountain Bluebird', + 'Mountain Chickadee', + 'Mountain Plover', + 'Mourning Dove', + 'Mourning Warbler', + 'Muscovy Duck', + 'Mute Swan', + 'Nashville Warbler', + 'Nelsons Sparrow', + 'Neotropic Cormorant', + 'Northern Bobwhite', + 'Northern Cardinal', + 'Northern Flicker', + 'Northern Gannet', + 'Northern Goshawk', + 'Northern Harrier', + 'Northern Hawk Owl', + 'Northern Mockingbird', + 'Northern Parula', + 'Northern Pintail', + 'Northern Rough winged Swallow', + 'Northern Saw whet Owl', + 'Northern Shrike', + 'Northern Waterthrush', + 'Nuttalls Woodpecker', + 'Oak Titmouse', + 'Olive Sparrow', + 'Olive sided Flycatcher', + 'Orange crowned Warbler', + 'Orchard Oriole', + 'Osprey', + 'Ovenbird', + 'Pacific Golden Plover', + 'Pacific Loon', + 'Pacific Wren', + 'Pacific slope Flycatcher', + 'Painted Bunting', + 'Painted Redstart', + 'Palm Warbler', + 'Pectoral Sandpiper', + 'Peregrine Falcon', + 'Phainopepla', + 'Philadelphia Vireo', + 'Pied billed Grebe', + 'Pigeon Guillemot', + 'Pileated Woodpecker', + 'Pine Grosbeak', + 'Pine Siskin', + 'Pine Warbler', + 'Piping Plover', + 'Plumbeous Vireo', + 'Prairie Falcon', + 'Prairie Warbler', + 'Prothonotary Warbler', + 'Purple Finch', + 'Purple Gallinule', + 'Purple Martin', + 'Purple Sandpiper', + 'Pygmy Nuthatch', + 'Pyrrhuloxia', + 'Red Crossbill', + 'Red Knot', + 'Red Phalarope', + 'Red bellied Woodpecker', + 'Red breasted Merganser', + 'Red breasted Nuthatch', + 'Red breasted Sapsucker', + 'Red cockaded Woodpecker', + 'Red eyed Vireo', + 'Red headed Woodpecker', + 'Red naped Sapsucker', + 'Red necked Grebe', + 'Red necked Phalarope', + 'Red shouldered Hawk', + 'Red tailed Hawk', + 'Red throated Loon', + 'Red winged Blackbird', + 'Reddish Egret', + 'Redhead', + 'Ring billed Gull', + 'Ring necked Duck', + 'Ring necked Pheasant', + 'Rock Pigeon', + 'Rock Ptarmigan', + 'Rock Sandpiper', + 'Rock Wren', + 'Rose breasted Grosbeak', + 'Roseate Tern', + 'Rosss Goose', + 'Rough legged Hawk', + 'Royal Tern', + 'Ruby crowned Kinglet', + 'Ruby throated Hummingbird', + 'Ruddy Duck', + 'Ruddy Turnstone', + 'Ruffed Grouse', + 'Rufous Hummingbird', + 'Rufous crowned Sparrow', + 'Rusty Blackbird', + 'Sage Thrasher', + 'Saltmarsh Sparrow', + 'Sanderling', + 'Sandhill Crane', + 'Sandwich Tern', + 'Says Phoebe', + 'Scaled Quail', + 'Scarlet Tanager', + 'Scissor tailed Flycatcher', + 'Scotts Oriole', + 'Seaside Sparrow', + 'Sedge Wren', + 'Semipalmated Plover', + 'Semipalmated Sandpiper', + 'Sharp shinned Hawk', + 'Sharp tailed Grouse', + 'Short billed Dowitcher', + 'Short eared Owl', + 'Snail Kite', + 'Snow Bunting', + 'Snow Goose', + 'Snowy Egret', + 'Snowy Owl', + 'Snowy Plover', + 'Solitary Sandpiper', + 'Song Sparrow', + 'Sooty Grouse', + 'Sora', + 'Spotted Owl', + 'Spotted Sandpiper', + 'Spotted Towhee', + 'Spruce Grouse', + 'Stellers Jay', + 'Stilt Sandpiper', + 'Summer Tanager', + 'Surf Scoter', + 'Surfbird', + 'Swainsons Hawk', + 'Swainsons Thrush', + 'Swallow tailed Kite', + 'Swamp Sparrow', + 'Tennessee Warbler', + 'Thayers Gull', + 'Townsends Solitaire', + 'Townsends Warbler', + 'Tree Swallow', + 'Tricolored Heron', + 'Tropical Kingbird', + 'Trumpeter Swan', + 'Tufted Titmouse', + 'Tundra Swan', + 'Turkey Vulture', + 'Upland Sandpiper', + 'Varied Thrush', + 'Veery', + 'Verdin', + 'Vermilion Flycatcher', + 'Vesper Sparrow', + 'Violet green Swallow', + 'Virginia Rail', + 'Wandering Tattler', + 'Warbling Vireo', + 'Western Bluebird', + 'Western Grebe', + 'Western Gull', + 'Western Kingbird', + 'Western Meadowlark', + 'Western Sandpiper', + 'Western Screech Owl', + 'Western Scrub Jay', + 'Western Tanager', + 'Western Wood Pewee', + 'Whimbrel', + 'White Ibis', + 'White breasted Nuthatch', + 'White crowned Sparrow', + 'White eyed Vireo', + 'White faced Ibis', + 'White headed Woodpecker', + 'White rumped Sandpiper', + 'White tailed Hawk', + 'White tailed Kite', + 'White tailed Ptarmigan', + 'White throated Sparrow', + 'White throated Swift', + 'White winged Crossbill', + 'White winged Dove', + 'White winged Scoter', + 'Wild Turkey', + 'Willet', + 'Williamsons Sapsucker', + 'Willow Flycatcher', + 'Willow Ptarmigan', + 'Wilsons Phalarope', + 'Wilsons Plover', + 'Wilsons Snipe', + 'Wilsons Warbler', + 'Winter Wren', + 'Wood Stork', + 'Wood Thrush', + 'Worm eating Warbler', + 'Wrentit', + 'Yellow Warbler', + 'Yellow bellied Flycatcher', + 'Yellow bellied Sapsucker', + 'Yellow billed Cuckoo', + 'Yellow billed Magpie', + 'Yellow breasted Chat', + 'Yellow crowned Night Heron', + 'Yellow eyed Junco', + 'Yellow headed Blackbird', + 'Yellow rumped Warbler', + 'Yellow throated Vireo', + 'Yellow throated Warbler', + 'Zone tailed Hawk', +] + +templates = [ + 'a photo of a {}, a type of bird.', +] +``` + + + +## CIFAR10 + +```bash +classes = [ + 'airplane', + 'automobile', + 'bird', + 'cat', + 'deer', + 'dog', + 'frog', + 'horse', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CIFAR100 + +```bash +classes = [ + 'apple', + 'aquarium fish', + 'baby', + 'bear', + 'beaver', + 'bed', + 'bee', + 'beetle', + 'bicycle', + 'bottle', + 'bowl', + 'boy', + 'bridge', + 'bus', + 'butterfly', + 'camel', + 'can', + 'castle', + 'caterpillar', + 'cattle', + 'chair', + 'chimpanzee', + 'clock', + 'cloud', + 'cockroach', + 'couch', + 'crab', + 'crocodile', + 'cup', + 'dinosaur', + 'dolphin', + 'elephant', + 'flatfish', + 'forest', + 'fox', + 'girl', + 'hamster', + 'house', + 'kangaroo', + 'keyboard', + 'lamp', + 'lawn mower', + 'leopard', + 'lion', + 'lizard', + 'lobster', + 'man', + 'maple tree', + 'motorcycle', + 'mountain', + 'mouse', + 'mushroom', + 'oak tree', + 'orange', + 'orchid', + 'otter', + 'palm tree', + 'pear', + 'pickup truck', + 'pine tree', + 'plain', + 'plate', + 'poppy', + 'porcupine', + 'possum', + 'rabbit', + 'raccoon', + 'ray', + 'road', + 'rocket', + 'rose', + 'sea', + 'seal', + 'shark', + 'shrew', + 'skunk', + 'skyscraper', + 'snail', + 'snake', + 'spider', + 'squirrel', + 'streetcar', + 'sunflower', + 'sweet pepper', + 'table', + 'tank', + 'telephone', + 'television', + 'tiger', + 'tractor', + 'train', + 'trout', + 'tulip', + 'turtle', + 'wardrobe', + 'whale', + 'willow tree', + 'wolf', + 'woman', + 'worm', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CLEVRCounts + +```bash +classes = [ + '10', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of {} objects.', +] +``` + + + +## Caltech101 + +```bash +classes = [ + 'background', + 'off-center face', + 'centered face', + 'leopard', + 'motorbike', + 'accordion', + 'airplane', + 'anchor', + 'ant', + 'barrel', + 'bass', + 'beaver', + 'binocular', + 'bonsai', + 'brain', + 'brontosaurus', + 'buddha', + 'butterfly', + 'camera', + 'cannon', + 'side of a car', + 'ceiling fan', + 'cellphone', + 'chair', + 'chandelier', + 'body of a cougar cat', + 'face of a cougar cat', + 'crab', + 'crayfish', + 'crocodile', + 'head of a crocodile', + 'cup', + 'dalmatian', + 'dollar bill', + 'dolphin', + 'dragonfly', + 'electric guitar', + 'elephant', + 'emu', + 'euphonium', + 'ewer', + 'ferry', + 'flamingo', + 'head of a flamingo', + 'garfield', + 'gerenuk', + 'gramophone', + 'grand piano', + 'hawksbill', + 'headphone', + 'hedgehog', + 'helicopter', + 'ibis', + 'inline skate', + 'joshua tree', + 'kangaroo', + 'ketch', + 'lamp', + 'laptop', + 'llama', + 'lobster', + 'lotus', + 'mandolin', + 'mayfly', + 'menorah', + 'metronome', + 'minaret', + 'nautilus', + 'octopus', + 'okapi', + 'pagoda', + 'panda', + 'pigeon', + 'pizza', + 'platypus', + 'pyramid', + 'revolver', + 'rhino', + 'rooster', + 'saxophone', + 'schooner', + 'scissors', + 'scorpion', + 'sea horse', + 'snoopy (cartoon beagle)', + 'soccer ball', + 'stapler', + 'starfish', + 'stegosaurus', + 'stop sign', + 'strawberry', + 'sunflower', + 'tick', + 'trilobite', + 'umbrella', + 'watch', + 'water lilly', + 'wheelchair', + 'wild cat', + 'windsor chair', + 'wrench', + 'yin and yang symbol', +] + +templates = [ + 'a photo of a {}.', + 'a painting of a {}.', + 'a plastic {}.', + 'a sculpture of a {}.', + 'a sketch of a {}.', + 'a tattoo of a {}.', + 'a toy {}.', + 'a rendition of a {}.', + 'a embroidered {}.', + 'a cartoon {}.', + 'a {} in a video game.', + 'a plushie {}.', + 'a origami {}.', + 'art of a {}.', + 'graffiti of a {}.', + 'a drawing of a {}.', + 'a doodle of a {}.', + 'a photo of the {}.', + 'a painting of the {}.', + 'the plastic {}.', + 'a sculpture of the {}.', + 'a sketch of the {}.', + 'a tattoo of the {}.', + 'the toy {}.', + 'a rendition of the {}.', + 'the embroidered {}.', + 'the cartoon {}.', + 'the {} in a video game.', + 'the plushie {}.', + 'the origami {}.', + 'art of the {}.', + 'graffiti of the {}.', + 'a drawing of the {}.', + 'a doodle of the {}.', +] +``` + + + +## Country211 + +```bash +classes = [ + 'Andorra', + 'United Arab Emirates', + 'Afghanistan', + 'Antigua and Barbuda', + 'Anguilla', + 'Albania', + 'Armenia', + 'Angola', + 'Antarctica', + 'Argentina', + 'Austria', + 'Australia', + 'Aruba', + 'Aland Islands', + 'Azerbaijan', + 'Bosnia and Herzegovina', + 'Barbados', + 'Bangladesh', + 'Belgium', + 'Burkina Faso', + 'Bulgaria', + 'Bahrain', + 'Benin', + 'Bermuda', + 'Brunei Darussalam', + 'Bolivia', + 'Bonaire, Saint Eustatius and Saba', + 'Brazil', + 'Bahamas', + 'Bhutan', + 'Botswana', + 'Belarus', + 'Belize', + 'Canada', + 'DR Congo', + 'Central African Republic', + 'Switzerland', + "Cote d'Ivoire", + 'Cook Islands', + 'Chile', + 'Cameroon', + 'China', + 'Colombia', + 'Costa Rica', + 'Cuba', + 'Cabo Verde', + 'Curacao', + 'Cyprus', + 'Czech Republic', + 'Germany', + 'Denmark', + 'Dominica', + 'Dominican Republic', + 'Algeria', + 'Ecuador', + 'Estonia', + 'Egypt', + 'Spain', + 'Ethiopia', + 'Finland', + 'Fiji', + 'Falkland Islands', + 'Faeroe Islands', + 'France', + 'Gabon', + 'United Kingdom', + 'Grenada', + 'Georgia', + 'French Guiana', + 'Guernsey', + 'Ghana', + 'Gibraltar', + 'Greenland', + 'Gambia', + 'Guadeloupe', + 'Greece', + 'South Georgia and South Sandwich Is.', + 'Guatemala', + 'Guam', + 'Guyana', + 'Hong Kong', + 'Honduras', + 'Croatia', + 'Haiti', + 'Hungary', + 'Indonesia', + 'Ireland', + 'Israel', + 'Isle of Man', + 'India', + 'Iraq', + 'Iran', + 'Iceland', + 'Italy', + 'Jersey', + 'Jamaica', + 'Jordan', + 'Japan', + 'Kenya', + 'Kyrgyz Republic', + 'Cambodia', + 'St. Kitts and Nevis', + 'North Korea', + 'South Korea', + 'Kuwait', + 'Cayman Islands', + 'Kazakhstan', + 'Laos', + 'Lebanon', + 'St. Lucia', + 'Liechtenstein', + 'Sri Lanka', + 'Liberia', + 'Lithuania', + 'Luxembourg', + 'Latvia', + 'Libya', + 'Morocco', + 'Monaco', + 'Moldova', + 'Montenegro', + 'Saint-Martin', + 'Madagascar', + 'Macedonia', + 'Mali', + 'Myanmar', + 'Mongolia', + 'Macau', + 'Martinique', + 'Mauritania', + 'Malta', + 'Mauritius', + 'Maldives', + 'Malawi', + 'Mexico', + 'Malaysia', + 'Mozambique', + 'Namibia', + 'New Caledonia', + 'Nigeria', + 'Nicaragua', + 'Netherlands', + 'Norway', + 'Nepal', + 'New Zealand', + 'Oman', + 'Panama', + 'Peru', + 'French Polynesia', + 'Papua New Guinea', + 'Philippines', + 'Pakistan', + 'Poland', + 'Puerto Rico', + 'Palestine', + 'Portugal', + 'Palau', + 'Paraguay', + 'Qatar', + 'Reunion', + 'Romania', + 'Serbia', + 'Russia', + 'Rwanda', + 'Saudi Arabia', + 'Solomon Islands', + 'Seychelles', + 'Sudan', + 'Sweden', + 'Singapore', + 'St. Helena', + 'Slovenia', + 'Svalbard and Jan Mayen Islands', + 'Slovakia', + 'Sierra Leone', + 'San Marino', + 'Senegal', + 'Somalia', + 'South Sudan', + 'El Salvador', + 'Sint Maarten', + 'Syria', + 'Eswatini', + 'Togo', + 'Thailand', + 'Tajikistan', + 'Timor-Leste', + 'Turkmenistan', + 'Tunisia', + 'Tonga', + 'Turkey', + 'Trinidad and Tobago', + 'Taiwan', + 'Tanzania', + 'Ukraine', + 'Uganda', + 'United States', + 'Uruguay', + 'Uzbekistan', + 'Vatican', + 'Venezuela', + 'British Virgin Islands', + 'United States Virgin Islands', + 'Vietnam', + 'Vanuatu', + 'Samoa', + 'Kosovo', + 'Yemen', + 'South Africa', + 'Zambia', + 'Zimbabwe', +] + +templates = [ + 'a photo i took in {}.', + 'a photo i took while visiting {}.', + 'a photo from my home country of {}.', + 'a photo from my visit to {}.', + 'a photo showing the country of {}.', +] +``` + + + +## DescribableTextures + +```bash +classes = [ + 'banded', + 'blotchy', + 'braided', + 'bubbly', + 'bumpy', + 'chequered', + 'cobwebbed', + 'cracked', + 'crosshatched', + 'crystalline', + 'dotted', + 'fibrous', + 'flecked', + 'freckled', + 'frilly', + 'gauzy', + 'grid', + 'grooved', + 'honeycombed', + 'interlaced', + 'knitted', + 'lacelike', + 'lined', + 'marbled', + 'matted', + 'meshed', + 'paisley', + 'perforated', + 'pitted', + 'pleated', + 'polka-dotted', + 'porous', + 'potholed', + 'scaly', + 'smeared', + 'spiralled', + 'sprinkled', + 'stained', + 'stratified', + 'striped', + 'studded', + 'swirly', + 'veined', + 'waffled', + 'woven', + 'wrinkled', + 'zigzagged', +] + +templates = [ + 'a photo of a {} texture.', + 'a photo of a {} pattern.', + 'a photo of a {} thing.', + 'a photo of a {} object.', + 'a photo of the {} texture.', + 'a photo of the {} pattern.', + 'a photo of the {} thing.', + 'a photo of the {} object.', +] +``` + + + +## EuroSAT + +```bash +classes = [ + 'forest', + 'permanent crop land', + 'residential buildings or homes or apartments', + 'river', + 'pasture land', + 'lake or sea', + 'brushland or shrubland', + 'annual crop land', + 'industrial buildings or commercial buildings', + 'highway or road', +] + +templates = [ + 'a centered satellite photo of {}.', + 'a centered satellite photo of a {}.', + 'a centered satellite photo of the {}.', +] +``` + + + +## FGVCAircraft + +```bash +classes = [ + '707-320', + '727-200', + '737-200', + '737-300', + '737-400', + '737-500', + '737-600', + '737-700', + '737-800', + '737-900', + '747-100', + '747-200', + '747-300', + '747-400', + '757-200', + '757-300', + '767-200', + '767-300', + '767-400', + '777-200', + '777-300', + 'A300B4', + 'A310', + 'A318', + 'A319', + 'A320', + 'A321', + 'A330-200', + 'A330-300', + 'A340-200', + 'A340-300', + 'A340-500', + 'A340-600', + 'A380', + 'ATR-42', + 'ATR-72', + 'An-12', + 'BAE 146-200', + 'BAE 146-300', + 'BAE-125', + 'Beechcraft 1900', + 'Boeing 717', + 'C-130', + 'C-47', + 'CRJ-200', + 'CRJ-700', + 'CRJ-900', + 'Cessna 172', + 'Cessna 208', + 'Cessna 525', + 'Cessna 560', + 'Challenger 600', + 'DC-10', + 'DC-3', + 'DC-6', + 'DC-8', + 'DC-9-30', + 'DH-82', + 'DHC-1', + 'DHC-6', + 'DHC-8-100', + 'DHC-8-300', + 'DR-400', + 'Dornier 328', + 'E-170', + 'E-190', + 'E-195', + 'EMB-120', + 'ERJ 135', + 'ERJ 145', + 'Embraer Legacy 600', + 'Eurofighter Typhoon', + 'F-16A/B', + 'F/A-18', + 'Falcon 2000', + 'Falcon 900', + 'Fokker 100', + 'Fokker 50', + 'Fokker 70', + 'Global Express', + 'Gulfstream IV', + 'Gulfstream V', + 'Hawk T1', + 'Il-76', + 'L-1011', + 'MD-11', + 'MD-80', + 'MD-87', + 'MD-90', + 'Metroliner', + 'Model B200', + 'PA-28', + 'SR-20', + 'Saab 2000', + 'Saab 340', + 'Spitfire', + 'Tornado', + 'Tu-134', + 'Tu-154', + 'Yak-42', +] + +templates = [ + 'a photo of a {}, a type of aircraft.', + 'a photo of the {}, a type of aircraft.', +] +``` + + + +## FacialEmotionRecognition2013 + +```bash +classes = [ + ['angry'], + ['disgusted'], + ['fearful'], + ['happy', 'smiling'], + ['sad', 'depressed'], + ['surprised', 'shocked', 'spooked'], + ['neutral', 'bored'], +] + +templates = [ + 'a photo of a {} looking face.', + 'a photo of a face showing the emotion: {}.', + 'a photo of a face looking {}.', + 'a face that looks {}.', + 'they look {}.', + 'look at how {} they are.', +] +``` + + + +## Flowers102 + +```bash +classes = [ + 'pink primrose', + 'hard-leaved pocket orchid', + 'canterbury bells', + 'sweet pea', + 'english marigold', + 'tiger lily', + 'moon orchid', + 'bird of paradise', + 'monkshood', + 'globe thistle', + 'snapdragon', + "colt's foot", + 'king protea', + 'spear thistle', + 'yellow iris', + 'globe flower', + 'purple coneflower', + 'peruvian lily', + 'balloon flower', + 'giant white arum lily', + 'fire lily', + 'pincushion flower', + 'fritillary', + 'red ginger', + 'grape hyacinth', + 'corn poppy', + 'prince of wales feathers', + 'stemless gentian', + 'artichoke', + 'sweet william', + 'carnation', + 'garden phlox', + 'love in the mist', + 'mexican aster', + 'alpine sea holly', + 'ruby-lipped cattleya', + 'cape flower', + 'great masterwort', + 'siam tulip', + 'lenten rose', + 'barbeton daisy', + 'daffodil', + 'sword lily', + 'poinsettia', + 'bolero deep blue', + 'wallflower', + 'marigold', + 'buttercup', + 'oxeye daisy', + 'common dandelion', + 'petunia', + 'wild pansy', + 'primula', + 'sunflower', + 'pelargonium', + 'bishop of llandaff', + 'gaura', + 'geranium', + 'orange dahlia', + 'pink and yellow dahlia', + 'cautleya spicata', + 'japanese anemone', + 'black-eyed susan', + 'silverbush', + 'californian poppy', + 'osteospermum', + 'spring crocus', + 'bearded iris', + 'windflower', + 'tree poppy', + 'gazania', + 'azalea', + 'water lily', + 'rose', + 'thorn apple', + 'morning glory', + 'passion flower', + 'lotus', + 'toad lily', + 'anthurium', + 'frangipani', + 'clematis', + 'hibiscus', + 'columbine', + 'desert-rose', + 'tree mallow', + 'magnolia', + 'cyclamen', + 'watercress', + 'canna lily', + 'hippeastrum', + 'bee balm', + 'air plant', + 'foxglove', + 'bougainvillea', + 'camellia', + 'mallow', + 'mexican petunia', + 'bromelia', + 'blanket flower', + 'trumpet creeper', + 'blackberry lily', +] + +templates = [ + 'a photo of a {}, a type of flower.', +] +``` + + + +## Food101 + +```bash +classes = [ + 'apple pie', + 'baby back ribs', + 'baklava', + 'beef carpaccio', + 'beef tartare', + 'beet salad', + 'beignets', + 'bibimbap', + 'bread pudding', + 'breakfast burrito', + 'bruschetta', + 'caesar salad', + 'cannoli', + 'caprese salad', + 'carrot cake', + 'ceviche', + 'cheese plate', + 'cheesecake', + 'chicken curry', + 'chicken quesadilla', + 'chicken wings', + 'chocolate cake', + 'chocolate mousse', + 'churros', + 'clam chowder', + 'club sandwich', + 'crab cakes', + 'creme brulee', + 'croque madame', + 'cup cakes', + 'deviled eggs', + 'donuts', + 'dumplings', + 'edamame', + 'eggs benedict', + 'escargots', + 'falafel', + 'filet mignon', + 'fish and chips', + 'foie gras', + 'french fries', + 'french onion soup', + 'french toast', + 'fried calamari', + 'fried rice', + 'frozen yogurt', + 'garlic bread', + 'gnocchi', + 'greek salad', + 'grilled cheese sandwich', + 'grilled salmon', + 'guacamole', + 'gyoza', + 'hamburger', + 'hot and sour soup', + 'hot dog', + 'huevos rancheros', + 'hummus', + 'ice cream', + 'lasagna', + 'lobster bisque', + 'lobster roll sandwich', + 'macaroni and cheese', + 'macarons', + 'miso soup', + 'mussels', + 'nachos', + 'omelette', + 'onion rings', + 'oysters', + 'pad thai', + 'paella', + 'pancakes', + 'panna cotta', + 'peking duck', + 'pho', + 'pizza', + 'pork chop', + 'poutine', + 'prime rib', + 'pulled pork sandwich', + 'ramen', + 'ravioli', + 'red velvet cake', + 'risotto', + 'samosa', + 'sashimi', + 'scallops', + 'seaweed salad', + 'shrimp and grits', + 'spaghetti bolognese', + 'spaghetti carbonara', + 'spring rolls', + 'steak', + 'strawberry shortcake', + 'sushi', + 'tacos', + 'takoyaki', + 'tiramisu', + 'tuna tartare', + 'waffles', +] + +templates = [ + 'a photo of {}, a type of food.', +] +``` + + + +## GTSRB + +```bash +classes = [ + 'red and white circle 20 kph speed limit', + 'red and white circle 30 kph speed limit', + 'red and white circle 50 kph speed limit', + 'red and white circle 60 kph speed limit', + 'red and white circle 70 kph speed limit', + 'red and white circle 80 kph speed limit', + 'end / de-restriction of 80 kph speed limit', + 'red and white circle 100 kph speed limit', + 'red and white circle 120 kph speed limit', + 'red and white circle red car and black car no passing', + 'red and white circle red truck and black car no passing', + 'red and white triangle road intersection warning', + 'white and yellow diamond priority road', + 'red and white upside down triangle yield right-of-way', + 'stop', + 'empty red and white circle', + 'red and white circle no truck entry', + 'red circle with white horizonal stripe no entry', + 'red and white triangle with exclamation mark warning', + 'red and white triangle with black left curve approaching warning', + 'red and white triangle with black right curve approaching warning', + 'red and white triangle with black double curve approaching warning', + 'red and white triangle rough / bumpy road warning', + 'red and white triangle car skidding / slipping warning', + 'red and white triangle with merging / narrow lanes warning', + 'red and white triangle with person digging / construction / road work warning', + 'red and white triangle with traffic light approaching warning', + 'red and white triangle with person walking warning', + 'red and white triangle with child and person walking warning', + 'red and white triangle with bicyle warning', + 'red and white triangle with snowflake / ice warning', + 'red and white triangle with deer warning', + 'white circle with gray strike bar no speed limit', + 'blue circle with white right turn arrow mandatory', + 'blue circle with white left turn arrow mandatory', + 'blue circle with white forward arrow mandatory', + 'blue circle with white forward or right turn arrow mandatory', + 'blue circle with white forward or left turn arrow mandatory', + 'blue circle with white keep right arrow mandatory', + 'blue circle with white keep left arrow mandatory', + 'blue circle with white arrows indicating a traffic circle', + 'white circle with gray strike bar indicating no passing for cars has ended', + 'white circle with gray strike bar indicating no passing for trucks has ended', +] + +templates = [ + 'a zoomed in photo of a "{}" traffic sign.', + 'a centered photo of a "{}" traffic sign.', + 'a close up photo of a "{}" traffic sign.', +] +``` + + + +## HatefulMemes + +```bash +classes = [ + 'meme', + 'hatespeech meme', +] + +templates = [ + 'a {}.', +] +``` + + + +## KITTI + +```bash +classes = [ + 'a photo i took of a car on my left or right side.', + 'a photo i took with a car nearby.', + 'a photo i took with a car in the distance.', + 'a photo i took with no car.', +] + +templates = [ + '{}', +] +``` + + + +## Kinetics700 + +```bash +classes = [ + 'abseiling', + 'acting in play', + 'adjusting glasses', + 'air drumming', + 'alligator wrestling', + 'answering questions', + 'applauding', + 'applying cream', + 'archaeological excavation', + 'archery', + 'arguing', + 'arm wrestling', + 'arranging flowers', + 'arresting', + 'assembling bicycle', + 'assembling computer', + 'attending conference', + 'auctioning', + 'baby waking up', + 'backflip (human)', + 'baking cookies', + 'bandaging', + 'barbequing', + 'bartending', + 'base jumping', + 'bathing dog', + 'battle rope training', + 'beatboxing', + 'bee keeping', + 'being excited', + 'being in zero gravity', + 'belly dancing', + 'bench pressing', + 'bending back', + 'bending metal', + 'biking through snow', + 'blasting sand', + 'blending fruit', + 'blowdrying hair', + 'blowing bubble gum', + 'blowing glass', + 'blowing leaves', + 'blowing nose', + 'blowing out candles', + 'bobsledding', + 'bodysurfing', + 'bookbinding', + 'bottling', + 'bouncing ball (not juggling)', + 'bouncing on bouncy castle', + 'bouncing on trampoline', + 'bowling', + 'braiding hair', + 'breading or breadcrumbing', + 'breakdancing', + 'breaking boards', + 'breaking glass', + 'breathing fire', + 'brush painting', + 'brushing floor', + 'brushing hair', + 'brushing teeth', + 'building cabinet', + 'building lego', + 'building sandcastle', + 'building shed', + 'bulldozing', + 'bungee jumping', + 'burping', + 'busking', + 'calculating', + 'calligraphy', + 'canoeing or kayaking', + 'capoeira', + 'capsizing', + 'card stacking', + 'card throwing', + 'carrying baby', + 'carrying weight', + 'cartwheeling', + 'carving ice', + 'carving marble', + 'carving pumpkin', + 'carving wood with a knife', + 'casting fishing line', + 'catching fish', + 'catching or throwing baseball', + 'catching or throwing frisbee', + 'catching or throwing softball', + 'celebrating', + 'changing gear in car', + 'changing oil', + 'changing wheel (not on bike)', + 'chasing', + 'checking tires', + 'checking watch', + 'cheerleading', + 'chewing gum', + 'chiseling stone', + 'chiseling wood', + 'chopping meat', + 'chopping wood', + 'clam digging', + 'clapping', + 'clay pottery making', + 'clean and jerk', + 'cleaning gutters', + 'cleaning pool', + 'cleaning shoes', + 'cleaning toilet', + 'cleaning windows', + 'climbing a rope', + 'climbing ladder', + 'climbing tree', + 'closing door', + 'coloring in', + 'combing hair', + 'contact juggling', + 'contorting', + 'cooking chicken', + 'cooking egg', + 'cooking on campfire', + 'cooking sausages (not on barbeque)', + 'cooking scallops', + 'cosplaying', + 'coughing', + 'counting money', + 'country line dancing', + 'cracking back', + 'cracking knuckles', + 'cracking neck', + 'crawling baby', + 'crocheting', + 'crossing eyes', + 'crossing river', + 'crying', + 'cumbia', + 'curling (sport)', + 'curling eyelashes', + 'curling hair', + 'cutting apple', + 'cutting cake', + 'cutting nails', + 'cutting orange', + 'cutting pineapple', + 'cutting watermelon', + 'dancing ballet', + 'dancing charleston', + 'dancing gangnam style', + 'dancing macarena', + 'deadlifting', + 'dealing cards', + 'decorating the christmas tree', + 'decoupage', + 'delivering mail', + 'digging', + 'dining', + 'directing traffic', + 'disc golfing', + 'diving cliff', + 'docking boat', + 'dodgeball', + 'doing aerobics', + 'doing jigsaw puzzle', + 'doing laundry', + 'doing nails', + 'doing sudoku', + 'drawing', + 'dribbling basketball', + 'drinking shots', + 'driving car', + 'driving tractor', + 'drooling', + 'drop kicking', + 'drumming fingers', + 'dumpster diving', + 'dunking basketball', + 'dyeing eyebrows', + 'dyeing hair', + 'eating burger', + 'eating cake', + 'eating carrots', + 'eating chips', + 'eating doughnuts', + 'eating hotdog', + 'eating ice cream', + 'eating nachos', + 'eating spaghetti', + 'eating watermelon', + 'egg hunting', + 'embroidering', + 'entering church', + 'exercising arm', + 'exercising with an exercise ball', + 'extinguishing fire', + 'faceplanting', + 'falling off bike', + 'falling off chair', + 'feeding birds', + 'feeding fish', + 'feeding goats', + 'fencing (sport)', + 'fidgeting', + 'filling cake', + 'filling eyebrows', + 'finger snapping', + 'fixing bicycle', + 'fixing hair', + 'flint knapping', + 'flipping bottle', + 'flipping pancake', + 'fly tying', + 'flying kite', + 'folding clothes', + 'folding napkins', + 'folding paper', + 'front raises', + 'frying vegetables', + 'gargling', + 'geocaching', + 'getting a haircut', + 'getting a piercing', + 'getting a tattoo', + 'giving or receiving award', + 'gold panning', + 'golf chipping', + 'golf driving', + 'golf putting', + 'gospel singing in church', + 'grinding meat', + 'grooming cat', + 'grooming dog', + 'grooming horse', + 'gymnastics tumbling', + 'hammer throw', + 'hand washing clothes', + 'head stand', + 'headbanging', + 'headbutting', + 'helmet diving', + 'herding cattle', + 'high fiving', + 'high jump', + 'high kick', + 'historical reenactment', + 'hitting baseball', + 'hockey stop', + 'holding snake', + 'home roasting coffee', + 'hopscotch', + 'hoverboarding', + 'huddling', + 'hugging (not baby)', + 'hugging baby', + 'hula hooping', + 'hurdling', + 'hurling (sport)', + 'ice climbing', + 'ice fishing', + 'ice skating', + 'ice swimming', + 'inflating balloons', + 'installing carpet', + 'ironing', + 'ironing hair', + 'javelin throw', + 'jaywalking', + 'jetskiing', + 'jogging', + 'juggling balls', + 'juggling fire', + 'juggling soccer ball', + 'jumping bicycle', + 'jumping into pool', + 'jumping jacks', + 'jumping sofa', + 'jumpstyle dancing', + 'karaoke', + 'kicking field goal', + 'kicking soccer ball', + 'kissing', + 'kitesurfing', + 'knitting', + 'krumping', + 'land sailing', + 'laughing', + 'lawn mower racing', + 'laying bricks', + 'laying concrete', + 'laying decking', + 'laying stone', + 'laying tiles', + 'leatherworking', + 'letting go of balloon', + 'licking', + 'lifting hat', + 'lighting candle', + 'lighting fire', + 'listening with headphones', + 'lock picking', + 'long jump', + 'longboarding', + 'looking at phone', + 'looking in mirror', + 'luge', + 'lunge', + 'making a cake', + 'making a sandwich', + 'making balloon shapes', + 'making bubbles', + 'making cheese', + 'making horseshoes', + 'making jewelry', + 'making latte art', + 'making paper aeroplanes', + 'making pizza', + 'making slime', + 'making snowman', + 'making sushi', + 'making tea', + 'making the bed', + 'marching', + 'marriage proposal', + 'massaging back', + 'massaging feet', + 'massaging legs', + 'massaging neck', + "massaging person's head", + 'metal detecting', + 'milking cow', + 'milking goat', + 'mixing colours', + 'moon walking', + 'mopping floor', + 'mosh pit dancing', + 'motorcycling', + 'mountain climber (exercise)', + 'moving baby', + 'moving child', + 'moving furniture', + 'mowing lawn', + 'mushroom foraging', + 'needle felting', + 'news anchoring', + 'opening bottle (not wine)', + 'opening coconuts', + 'opening door', + 'opening present', + 'opening refrigerator', + 'opening wine bottle', + 'packing', + 'paragliding', + 'parasailing', + 'parkour', + 'passing American football (in game)', + 'passing American football (not in game)', + 'passing soccer ball', + 'peeling apples', + 'peeling banana', + 'peeling potatoes', + 'person collecting garbage', + 'petting animal (not cat)', + 'petting cat', + 'petting horse', + 'photobombing', + 'photocopying', + 'picking apples', + 'picking blueberries', + 'pillow fight', + 'pinching', + 'pirouetting', + 'planing wood', + 'planting trees', + 'plastering', + 'playing accordion', + 'playing american football', + 'playing badminton', + 'playing bagpipes', + 'playing basketball', + 'playing bass guitar', + 'playing beer pong', + 'playing billiards', + 'playing blackjack', + 'playing cards', + 'playing cello', + 'playing checkers', + 'playing chess', + 'playing clarinet', + 'playing controller', + 'playing cricket', + 'playing cymbals', + 'playing darts', + 'playing didgeridoo', + 'playing dominoes', + 'playing drums', + 'playing field hockey', + 'playing flute', + 'playing gong', + 'playing guitar', + 'playing hand clapping games', + 'playing harmonica', + 'playing harp', + 'playing ice hockey', + 'playing keyboard', + 'playing kickball', + 'playing laser tag', + 'playing lute', + 'playing mahjong', + 'playing maracas', + 'playing marbles', + 'playing monopoly', + 'playing netball', + 'playing nose flute', + 'playing oboe', + 'playing ocarina', + 'playing organ', + 'playing paintball', + 'playing pan pipes', + 'playing piano', + 'playing piccolo', + 'playing pinball', + 'playing ping pong', + 'playing poker', + 'playing polo', + 'playing recorder', + 'playing road hockey', + 'playing rounders', + 'playing rubiks cube', + 'playing saxophone', + 'playing scrabble', + 'playing shuffleboard', + 'playing slot machine', + 'playing squash or racquetball', + 'playing tennis', + 'playing trombone', + 'playing trumpet', + 'playing ukulele', + 'playing violin', + 'playing volleyball', + 'playing with trains', + 'playing xylophone', + 'poaching eggs', + 'poking bellybutton', + 'pole vault', + 'polishing furniture', + 'polishing metal', + 'popping balloons', + 'pouring beer', + 'pouring milk', + 'pouring wine', + 'preparing salad', + 'presenting weather forecast', + 'pretending to be a statue', + 'pull ups', + 'pulling espresso shot', + 'pulling rope (game)', + 'pumping fist', + 'pumping gas', + 'punching bag', + 'punching person (boxing)', + 'push up', + 'pushing car', + 'pushing cart', + 'pushing wheelbarrow', + 'pushing wheelchair', + 'putting in contact lenses', + 'putting on eyeliner', + 'putting on foundation', + 'putting on lipstick', + 'putting on mascara', + 'putting on sari', + 'putting on shoes', + 'putting wallpaper on wall', + 'raising eyebrows', + 'reading book', + 'reading newspaper', + 'recording music', + 'repairing puncture', + 'riding a bike', + 'riding camel', + 'riding elephant', + 'riding mechanical bull', + 'riding mule', + 'riding or walking with horse', + 'riding scooter', + 'riding snow blower', + 'riding unicycle', + 'ripping paper', + 'roasting marshmallows', + 'roasting pig', + 'robot dancing', + 'rock climbing', + 'rock scissors paper', + 'roller skating', + 'rolling eyes', + 'rolling pastry', + 'rope pushdown', + 'running on treadmill', + 'sailing', + 'salsa dancing', + 'saluting', + 'sanding floor', + 'sanding wood', + 'sausage making', + 'sawing wood', + 'scrambling eggs', + 'scrapbooking', + 'scrubbing face', + 'scuba diving', + 'seasoning food', + 'separating eggs', + 'setting table', + 'sewing', + 'shaking hands', + 'shaking head', + 'shaping bread dough', + 'sharpening knives', + 'sharpening pencil', + 'shaving head', + 'shaving legs', + 'shearing sheep', + 'shining flashlight', + 'shining shoes', + 'shoot dance', + 'shooting basketball', + 'shooting goal (soccer)', + 'shooting off fireworks', + 'shopping', + 'shot put', + 'shouting', + 'shoveling snow', + 'shredding paper', + 'shucking oysters', + 'shuffling cards', + 'shuffling feet', + 'side kick', + 'sieving', + 'sign language interpreting', + 'silent disco', + 'singing', + 'sipping cup', + 'situp', + 'skateboarding', + 'ski ballet', + 'ski jumping', + 'skiing crosscountry', + 'skiing mono', + 'skiing slalom', + 'skipping rope', + 'skipping stone', + 'skydiving', + 'slacklining', + 'slapping', + 'sled dog racing', + 'sleeping', + 'slicing onion', + 'smashing', + 'smelling feet', + 'smoking', + 'smoking hookah', + 'smoking pipe', + 'snatch weight lifting', + 'sneezing', + 'snorkeling', + 'snowboarding', + 'snowkiting', + 'snowmobiling', + 'somersaulting', + 'spelunking', + 'spinning plates', + 'spinning poi', + 'splashing water', + 'spray painting', + 'spraying', + 'springboard diving', + 'square dancing', + 'squat', + 'squeezing orange', + 'stacking cups', + 'stacking dice', + 'standing on hands', + 'staring', + 'steer roping', + 'steering car', + 'sticking tongue out', + 'stomping grapes', + 'stretching arm', + 'stretching leg', + 'sucking lolly', + 'surfing crowd', + 'surfing water', + 'surveying', + 'sweeping floor', + 'swimming backstroke', + 'swimming breast stroke', + 'swimming butterfly stroke', + 'swimming front crawl', + 'swimming with dolphins', + 'swimming with sharks', + 'swing dancing', + 'swinging baseball bat', + 'swinging on something', + 'sword fighting', + 'sword swallowing', + 'tackling', + 'tagging graffiti', + 'tai chi', + 'taking photo', + 'talking on cell phone', + 'tango dancing', + 'tap dancing', + 'tapping guitar', + 'tapping pen', + 'tasting beer', + 'tasting food', + 'tasting wine', + 'testifying', + 'texting', + 'threading needle', + 'throwing axe', + 'throwing ball (not baseball or American football)', + 'throwing discus', + 'throwing knife', + 'throwing snowballs', + 'throwing tantrum', + 'throwing water balloon', + 'tickling', + 'tie dying', + 'tightrope walking', + 'tiptoeing', + 'tobogganing', + 'tossing coin', + 'tossing salad', + 'training dog', + 'trapezing', + 'treating wood', + 'trimming or shaving beard', + 'trimming shrubs', + 'trimming trees', + 'triple jump', + 'twiddling fingers', + 'tying bow tie', + 'tying knot (not on a tie)', + 'tying necktie', + 'tying shoe laces', + 'unboxing', + 'uncorking champagne', + 'unloading truck', + 'using a microscope', + 'using a paint roller', + 'using a power drill', + 'using a sledge hammer', + 'using a wrench', + 'using atm', + 'using bagging machine', + 'using circular saw', + 'using inhaler', + 'using megaphone', + 'using puppets', + 'using remote controller (not gaming)', + 'using segway', + 'vacuuming car', + 'vacuuming floor', + 'visiting the zoo', + 'wading through mud', + 'wading through water', + 'waiting in line', + 'waking up', + 'walking on stilts', + 'walking the dog', + 'walking through snow', + 'walking with crutches', + 'washing dishes', + 'washing feet', + 'washing hair', + 'washing hands', + 'watching tv', + 'water skiing', + 'water sliding', + 'watering plants', + 'waving hand', + 'waxing armpits', + 'waxing back', + 'waxing chest', + 'waxing eyebrows', + 'waxing legs', + 'weaving basket', + 'weaving fabric', + 'welding', + 'whistling', + 'windsurfing', + 'winking', + 'wood burning (art)', + 'wrapping present', + 'wrestling', + 'writing', + 'yarn spinning', + 'yawning', + 'yoga', + 'zumba' +] + +templates = [ + 'a photo of {}.', + 'a photo of a person {}.', + 'a photo of a person using {}.', + 'a photo of a person doing {}.', + 'a photo of a person during {}.', + 'a photo of a person performing {}.', + 'a photo of a person practicing {}.', + 'a video of {}.', + 'a video of a person {}.', + 'a video of a person using {}.', + 'a video of a person doing {}.', + 'a video of a person during {}.', + 'a video of a person performing {}.', + 'a video of a person practicing {}.', + 'a example of {}.', + 'a example of a person {}.', + 'a example of a person using {}.', + 'a example of a person doing {}.', + 'a example of a person during {}.', + 'a example of a person performing {}.', + 'a example of a person practicing {}.', + 'a demonstration of {}.', + 'a demonstration of a person {}.', + 'a demonstration of a person using {}.', + 'a demonstration of a person doing {}.', + 'a demonstration of a person during {}.', + 'a demonstration of a person performing {}.', + 'a demonstration of a person practicing {}.', +] +``` + + + +## MNIST + +```bash +classes = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of the number: "{}".', +] +``` + + + +## OxfordPets + +```bash +classes = [ + 'Abyssinian', + 'Bengal', + 'Birman', + 'Bombay', + 'British Shorthair', + 'Egyptian Mau', + 'Maine Coon', + 'Persian', + 'Ragdoll', + 'Russian Blue', + 'Siamese', + 'Sphynx', + 'american bulldog', + 'american pit bull terrier', + 'basset hound', + 'beagle', + 'boxer', + 'chihuahua', + 'english cocker spaniel', + 'english setter', + 'german shorthaired', + 'great pyrenees', + 'havanese', + 'japanese chin', + 'keeshond', + 'leonberger', + 'miniature pinscher', + 'newfoundland', + 'pomeranian', + 'pug', + 'saint bernard', + 'samoyed', + 'scottish terrier', + 'shiba inu', + 'staffordshire bull terrier', + 'wheaten terrier', + 'yorkshire terrier', +] + +templates = [ + 'a photo of a {}, a type of pet.', +] +``` + + + +## PascalVOC2007 + +```bash +classes = [ + 'aeroplane', + 'bicycle', + 'bird', + 'boat', + 'bottle', + 'bus', + 'car', + 'cat', + 'chair', + 'cow', + 'dog', + 'horse', + 'motorbike', + 'person', + 'sheep', + 'sofa', + 'diningtable', + 'pottedplant', + 'train', + 'tvmonitor', +] + +templates = [ + 'a photo of a {}.', +] +``` + + + +## PatchCamelyon + +```bash +classes = [ + 'lymph node', + 'lymph node containing metastatic tumor tissue', +] + +templates = [ + 'this is a photo of {}', +] +``` + + + +## RESISC45 + +```bash +classes = [ + 'airplane', + 'airport', + 'baseball diamond', + 'basketball court', + 'beach', + 'bridge', + 'chaparral', + 'church', + 'circular farmland', + 'cloud', + 'commercial area', + 'dense residential', + 'desert', + 'forest', + 'freeway', + 'golf course', + 'ground track field', + 'harbor', + 'industrial area', + 'intersection', + 'island', + 'lake', + 'meadow', + 'medium residential', + 'mobile home park', + 'mountain', + 'overpass', + 'palace', + 'parking lot', + 'railway', + 'railway station', + 'rectangular farmland', + 'river', + 'roundabout', + 'runway', + 'sea ice', + 'ship', + 'snowberg', + 'sparse residential', + 'stadium', + 'storage tank', + 'tennis court', + 'terrace', + 'thermal power station', + 'wetland', +] + +templates = [ + 'satellite imagery of {}.', + 'aerial imagery of {}.', + 'satellite photo of {}.', + 'aerial photo of {}.', + 'satellite view of {}.', + 'aerial view of {}.', + 'satellite imagery of a {}.', + 'aerial imagery of a {}.', + 'satellite photo of a {}.', + 'aerial photo of a {}.', + 'satellite view of a {}.', + 'aerial view of a {}.', + 'satellite imagery of the {}.', + 'aerial imagery of the {}.', + 'satellite photo of the {}.', + 'aerial photo of the {}.', + 'satellite view of the {}.', + 'aerial view of the {}.', +] +``` + + + +## SST2 + +```bash +classes = [ + 'negative', + 'positive', +] + +templates = [ + 'a {} review of a movie.', +] +``` + + + +## STL10 + +```bash +classes = [ + 'airplane', + 'bird', + 'car', + 'cat', + 'deer', + 'dog', + 'horse', + 'monkey', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## SUN397 + +```bash +classes = [ + 'abbey', + 'airplane cabin', + 'airport terminal', + 'alley', + 'amphitheater', + 'amusement arcade', + 'amusement park', + 'anechoic chamber', + 'apartment building outdoor', + 'apse indoor', + 'aquarium', + 'aqueduct', + 'arch', + 'archive', + 'arrival gate outdoor', + 'art gallery', + 'art school', + 'art studio', + 'assembly line', + 'athletic field outdoor', + 'atrium public', + 'attic', + 'auditorium', + 'auto factory', + 'badlands', + 'badminton court indoor', + 'baggage claim', + 'bakery shop', + 'balcony exterior', + 'balcony interior', + 'ball pit', + 'ballroom', + 'bamboo forest', + 'banquet hall', + 'bar', + 'barn', + 'barndoor', + 'baseball field', + 'basement', + 'basilica', + 'basketball court outdoor', + 'bathroom', + 'batters box', + 'bayou', + 'bazaar indoor', + 'bazaar outdoor', + 'beach', + 'beauty salon', + 'bedroom', + 'berth', + 'biology laboratory', + 'bistro indoor', + 'boardwalk', + 'boat deck', + 'boathouse', + 'bookstore', + 'booth indoor', + 'botanical garden', + 'bow window indoor', + 'bow window outdoor', + 'bowling alley', + 'boxing ring', + 'brewery indoor', + 'bridge', + 'building facade', + 'bullring', + 'burial chamber', + 'bus interior', + 'butchers shop', + 'butte', + 'cabin outdoor', + 'cafeteria', + 'campsite', + 'campus', + 'canal natural', + 'canal urban', + 'candy store', + 'canyon', + 'car interior backseat', + 'car interior frontseat', + 'carrousel', + 'casino indoor', + 'castle', + 'catacomb', + 'cathedral indoor', + 'cathedral outdoor', + 'cavern indoor', + 'cemetery', + 'chalet', + 'cheese factory', + 'chemistry lab', + 'chicken coop indoor', + 'chicken coop outdoor', + 'childs room', + 'church indoor', + 'church outdoor', + 'classroom', + 'clean room', + 'cliff', + 'cloister indoor', + 'closet', + 'clothing store', + 'coast', + 'cockpit', + 'coffee shop', + 'computer room', + 'conference center', + 'conference room', + 'construction site', + 'control room', + 'control tower outdoor', + 'corn field', + 'corral', + 'corridor', + 'cottage garden', + 'courthouse', + 'courtroom', + 'courtyard', + 'covered bridge exterior', + 'creek', + 'crevasse', + 'crosswalk', + 'cubicle office', + 'dam', + 'delicatessen', + 'dentists office', + 'desert sand', + 'desert vegetation', + 'diner indoor', + 'diner outdoor', + 'dinette home', + 'dinette vehicle', + 'dining car', + 'dining room', + 'discotheque', + 'dock', + 'doorway outdoor', + 'dorm room', + 'driveway', + 'driving range outdoor', + 'drugstore', + 'electrical substation', + 'elevator door', + 'elevator interior', + 'elevator shaft', + 'engine room', + 'escalator indoor', + 'excavation', + 'factory indoor', + 'fairway', + 'fastfood restaurant', + 'field cultivated', + 'field wild', + 'fire escape', + 'fire station', + 'firing range indoor', + 'fishpond', + 'florist shop indoor', + 'food court', + 'forest broadleaf', + 'forest needleleaf', + 'forest path', + 'forest road', + 'formal garden', + 'fountain', + 'galley', + 'game room', + 'garage indoor', + 'garbage dump', + 'gas station', + 'gazebo exterior', + 'general store indoor', + 'general store outdoor', + 'gift shop', + 'golf course', + 'greenhouse indoor', + 'greenhouse outdoor', + 'gymnasium indoor', + 'hangar indoor', + 'hangar outdoor', + 'harbor', + 'hayfield', + 'heliport', + 'herb garden', + 'highway', + 'hill', + 'home office', + 'hospital', + 'hospital room', + 'hot spring', + 'hot tub outdoor', + 'hotel outdoor', + 'hotel room', + 'house', + 'hunting lodge outdoor', + 'ice cream parlor', + 'ice floe', + 'ice shelf', + 'ice skating rink indoor', + 'ice skating rink outdoor', + 'iceberg', + 'igloo', + 'industrial area', + 'inn outdoor', + 'islet', + 'jacuzzi indoor', + 'jail cell', + 'jail indoor', + 'jewelry shop', + 'kasbah', + 'kennel indoor', + 'kennel outdoor', + 'kindergarden classroom', + 'kitchen', + 'kitchenette', + 'labyrinth outdoor', + 'lake natural', + 'landfill', + 'landing deck', + 'laundromat', + 'lecture room', + 'library indoor', + 'library outdoor', + 'lido deck outdoor', + 'lift bridge', + 'lighthouse', + 'limousine interior', + 'living room', + 'lobby', + 'lock chamber', + 'locker room', + 'mansion', + 'manufactured home', + 'market indoor', + 'market outdoor', + 'marsh', + 'martial arts gym', + 'mausoleum', + 'medina', + 'moat water', + 'monastery outdoor', + 'mosque indoor', + 'mosque outdoor', + 'motel', + 'mountain', + 'mountain snowy', + 'movie theater indoor', + 'museum indoor', + 'music store', + 'music studio', + 'nuclear power plant outdoor', + 'nursery', + 'oast house', + 'observatory outdoor', + 'ocean', + 'office', + 'office building', + 'oil refinery outdoor', + 'oilrig', + 'operating room', + 'orchard', + 'outhouse outdoor', + 'pagoda', + 'palace', + 'pantry', + 'park', + 'parking garage indoor', + 'parking garage outdoor', + 'parking lot', + 'parlor', + 'pasture', + 'patio', + 'pavilion', + 'pharmacy', + 'phone booth', + 'physics laboratory', + 'picnic area', + 'pilothouse indoor', + 'planetarium outdoor', + 'playground', + 'playroom', + 'plaza', + 'podium indoor', + 'podium outdoor', + 'pond', + 'poolroom establishment', + 'poolroom home', + 'power plant outdoor', + 'promenade deck', + 'pub indoor', + 'pulpit', + 'putting green', + 'racecourse', + 'raceway', + 'raft', + 'railroad track', + 'rainforest', + 'reception', + 'recreation room', + 'residential neighborhood', + 'restaurant', + 'restaurant kitchen', + 'restaurant patio', + 'rice paddy', + 'riding arena', + 'river', + 'rock arch', + 'rope bridge', + 'ruin', + 'runway', + 'sandbar', + 'sandbox', + 'sauna', + 'schoolhouse', + 'sea cliff', + 'server room', + 'shed', + 'shoe shop', + 'shopfront', + 'shopping mall indoor', + 'shower', + 'skatepark', + 'ski lodge', + 'ski resort', + 'ski slope', + 'sky', + 'skyscraper', + 'slum', + 'snowfield', + 'squash court', + 'stable', + 'stadium baseball', + 'stadium football', + 'stage indoor', + 'staircase', + 'street', + 'subway interior', + 'subway station platform', + 'supermarket', + 'sushi bar', + 'swamp', + 'swimming pool indoor', + 'swimming pool outdoor', + 'synagogue indoor', + 'synagogue outdoor', + 'television studio', + 'temple east asia', + 'temple south asia', + 'tennis court indoor', + 'tennis court outdoor', + 'tent outdoor', + 'theater indoor procenium', + 'theater indoor seats', + 'thriftshop', + 'throne room', + 'ticket booth', + 'toll plaza', + 'topiary garden', + 'tower', + 'toyshop', + 'track outdoor', + 'train railway', + 'train station platform', + 'tree farm', + 'tree house', + 'trench', + 'underwater coral reef', + 'utility room', + 'valley', + 'van interior', + 'vegetable garden', + 'veranda', + 'veterinarians office', + 'viaduct', + 'videostore', + 'village', + 'vineyard', + 'volcano', + 'volleyball court indoor', + 'volleyball court outdoor', + 'waiting room', + 'warehouse indoor', + 'water tower', + 'waterfall block', + 'waterfall fan', + 'waterfall plunge', + 'watering hole', + 'wave', + 'wet bar', + 'wheat field', + 'wind farm', + 'windmill', + 'wine cellar barrel storage', + 'wine cellar bottle storage', + 'wrestling ring indoor', + 'yard', + 'youth hostel', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## StanfordCars + +```bash +classes = [ + 'AM General Hummer SUV 2000', + 'Acura RL Sedan 2012', + 'Acura TL Sedan 2012', + 'Acura TL Type-S 2008', + 'Acura TSX Sedan 2012', + 'Acura Integra Type R 2001', + 'Acura ZDX Hatchback 2012', + 'Aston Martin V8 Vantage Convertible 2012', + 'Aston Martin V8 Vantage Coupe 2012', + 'Aston Martin Virage Convertible 2012', + 'Aston Martin Virage Coupe 2012', + 'Audi RS 4 Convertible 2008', + 'Audi A5 Coupe 2012', + 'Audi TTS Coupe 2012', + 'Audi R8 Coupe 2012', + 'Audi V8 Sedan 1994', + 'Audi 100 Sedan 1994', + 'Audi 100 Wagon 1994', + 'Audi TT Hatchback 2011', + 'Audi S6 Sedan 2011', + 'Audi S5 Convertible 2012', + 'Audi S5 Coupe 2012', + 'Audi S4 Sedan 2012', + 'Audi S4 Sedan 2007', + 'Audi TT RS Coupe 2012', + 'BMW ActiveHybrid 5 Sedan 2012', + 'BMW 1 Series Convertible 2012', + 'BMW 1 Series Coupe 2012', + 'BMW 3 Series Sedan 2012', + 'BMW 3 Series Wagon 2012', + 'BMW 6 Series Convertible 2007', + 'BMW X5 SUV 2007', + 'BMW X6 SUV 2012', + 'BMW M3 Coupe 2012', + 'BMW M5 Sedan 2010', + 'BMW M6 Convertible 2010', + 'BMW X3 SUV 2012', + 'BMW Z4 Convertible 2012', + 'Bentley Continental Supersports Conv. Convertible 2012', + 'Bentley Arnage Sedan 2009', + 'Bentley Mulsanne Sedan 2011', + 'Bentley Continental GT Coupe 2012', + 'Bentley Continental GT Coupe 2007', + 'Bentley Continental Flying Spur Sedan 2007', + 'Bugatti Veyron 16.4 Convertible 2009', + 'Bugatti Veyron 16.4 Coupe 2009', + 'Buick Regal GS 2012', + 'Buick Rainier SUV 2007', + 'Buick Verano Sedan 2012', + 'Buick Enclave SUV 2012', + 'Cadillac CTS-V Sedan 2012', + 'Cadillac SRX SUV 2012', + 'Cadillac Escalade EXT Crew Cab 2007', + 'Chevrolet Silverado 1500 Hybrid Crew Cab 2012', + 'Chevrolet Corvette Convertible 2012', + 'Chevrolet Corvette ZR1 2012', + 'Chevrolet Corvette Ron Fellows Edition Z06 2007', + 'Chevrolet Traverse SUV 2012', + 'Chevrolet Camaro Convertible 2012', + 'Chevrolet HHR SS 2010', + 'Chevrolet Impala Sedan 2007', + 'Chevrolet Tahoe Hybrid SUV 2012', + 'Chevrolet Sonic Sedan 2012', + 'Chevrolet Express Cargo Van 2007', + 'Chevrolet Avalanche Crew Cab 2012', + 'Chevrolet Cobalt SS 2010', + 'Chevrolet Malibu Hybrid Sedan 2010', + 'Chevrolet TrailBlazer SS 2009', + 'Chevrolet Silverado 2500HD Regular Cab 2012', + 'Chevrolet Silverado 1500 Classic Extended Cab 2007', + 'Chevrolet Express Van 2007', + 'Chevrolet Monte Carlo Coupe 2007', + 'Chevrolet Malibu Sedan 2007', + 'Chevrolet Silverado 1500 Extended Cab 2012', + 'Chevrolet Silverado 1500 Regular Cab 2012', + 'Chrysler Aspen SUV 2009', + 'Chrysler Sebring Convertible 2010', + 'Chrysler Town and Country Minivan 2012', + 'Chrysler 300 SRT-8 2010', + 'Chrysler Crossfire Convertible 2008', + 'Chrysler PT Cruiser Convertible 2008', + 'Daewoo Nubira Wagon 2002', + 'Dodge Caliber Wagon 2012', + 'Dodge Caliber Wagon 2007', + 'Dodge Caravan Minivan 1997', + 'Dodge Ram Pickup 3500 Crew Cab 2010', + 'Dodge Ram Pickup 3500 Quad Cab 2009', + 'Dodge Sprinter Cargo Van 2009', + 'Dodge Journey SUV 2012', + 'Dodge Dakota Crew Cab 2010', + 'Dodge Dakota Club Cab 2007', + 'Dodge Magnum Wagon 2008', + 'Dodge Challenger SRT8 2011', + 'Dodge Durango SUV 2012', + 'Dodge Durango SUV 2007', + 'Dodge Charger Sedan 2012', + 'Dodge Charger SRT-8 2009', + 'Eagle Talon Hatchback 1998', + 'FIAT 500 Abarth 2012', + 'FIAT 500 Convertible 2012', + 'Ferrari FF Coupe 2012', + 'Ferrari California Convertible 2012', + 'Ferrari 458 Italia Convertible 2012', + 'Ferrari 458 Italia Coupe 2012', + 'Fisker Karma Sedan 2012', + 'Ford F-450 Super Duty Crew Cab 2012', + 'Ford Mustang Convertible 2007', + 'Ford Freestar Minivan 2007', + 'Ford Expedition EL SUV 2009', + 'Ford Edge SUV 2012', + 'Ford Ranger SuperCab 2011', + 'Ford GT Coupe 2006', + 'Ford F-150 Regular Cab 2012', + 'Ford F-150 Regular Cab 2007', + 'Ford Focus Sedan 2007', + 'Ford E-Series Wagon Van 2012', + 'Ford Fiesta Sedan 2012', + 'GMC Terrain SUV 2012', + 'GMC Savana Van 2012', + 'GMC Yukon Hybrid SUV 2012', + 'GMC Acadia SUV 2012', + 'GMC Canyon Extended Cab 2012', + 'Geo Metro Convertible 1993', + 'HUMMER H3T Crew Cab 2010', + 'HUMMER H2 SUT Crew Cab 2009', + 'Honda Odyssey Minivan 2012', + 'Honda Odyssey Minivan 2007', + 'Honda Accord Coupe 2012', + 'Honda Accord Sedan 2012', + 'Hyundai Veloster Hatchback 2012', + 'Hyundai Santa Fe SUV 2012', + 'Hyundai Tucson SUV 2012', + 'Hyundai Veracruz SUV 2012', + 'Hyundai Sonata Hybrid Sedan 2012', + 'Hyundai Elantra Sedan 2007', + 'Hyundai Accent Sedan 2012', + 'Hyundai Genesis Sedan 2012', + 'Hyundai Sonata Sedan 2012', + 'Hyundai Elantra Touring Hatchback 2012', + 'Hyundai Azera Sedan 2012', + 'Infiniti G Coupe IPL 2012', + 'Infiniti QX56 SUV 2011', + 'Isuzu Ascender SUV 2008', + 'Jaguar XK XKR 2012', + 'Jeep Patriot SUV 2012', + 'Jeep Wrangler SUV 2012', + 'Jeep Liberty SUV 2012', + 'Jeep Grand Cherokee SUV 2012', + 'Jeep Compass SUV 2012', + 'Lamborghini Reventon Coupe 2008', + 'Lamborghini Aventador Coupe 2012', + 'Lamborghini Gallardo LP 570-4 Superleggera 2012', + 'Lamborghini Diablo Coupe 2001', + 'Land Rover Range Rover SUV 2012', + 'Land Rover LR2 SUV 2012', + 'Lincoln Town Car Sedan 2011', + 'MINI Cooper Roadster Convertible 2012', + 'Maybach Landaulet Convertible 2012', + 'Mazda Tribute SUV 2011', + 'McLaren MP4-12C Coupe 2012', + 'Mercedes-Benz 300-Class Convertible 1993', + 'Mercedes-Benz C-Class Sedan 2012', + 'Mercedes-Benz SL-Class Coupe 2009', + 'Mercedes-Benz E-Class Sedan 2012', + 'Mercedes-Benz S-Class Sedan 2012', + 'Mercedes-Benz Sprinter Van 2012', + 'Mitsubishi Lancer Sedan 2012', + 'Nissan Leaf Hatchback 2012', + 'Nissan NV Passenger Van 2012', + 'Nissan Juke Hatchback 2012', + 'Nissan 240SX Coupe 1998', + 'Plymouth Neon Coupe 1999', + 'Porsche Panamera Sedan 2012', + 'Ram C/V Cargo Van Minivan 2012', + 'Rolls-Royce Phantom Drophead Coupe Convertible 2012', + 'Rolls-Royce Ghost Sedan 2012', + 'Rolls-Royce Phantom Sedan 2012', + 'Scion xD Hatchback 2012', + 'Spyker C8 Convertible 2009', + 'Spyker C8 Coupe 2009', + 'Suzuki Aerio Sedan 2007', + 'Suzuki Kizashi Sedan 2012', + 'Suzuki SX4 Hatchback 2012', + 'Suzuki SX4 Sedan 2012', + 'Tesla Model S Sedan 2012', + 'Toyota Sequoia SUV 2012', + 'Toyota Camry Sedan 2012', + 'Toyota Corolla Sedan 2012', + 'Toyota 4Runner SUV 2012', + 'Volkswagen Golf Hatchback 2012', + 'Volkswagen Golf Hatchback 1991', + 'Volkswagen Beetle Hatchback 2012', + 'Volvo C30 Hatchback 2012', + 'Volvo 240 Sedan 1993', + 'Volvo XC90 SUV 2007', + 'smart fortwo Convertible 2012', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', + 'a photo of my {}.', + 'i love my {}!', + 'a photo of my dirty {}.', + 'a photo of my clean {}.', + 'a photo of my new {}.', + 'a photo of my old {}.', +] +``` + + + +## UCF101 + +```bash +classes = [ + 'Apply Eye Makeup', + 'Apply Lipstick', + 'Archery', + 'Baby Crawling', + 'Balance Beam', + 'Band Marching', + 'Baseball Pitch', + 'Basketball', + 'Basketball Dunk', + 'Bench Press', + 'Biking', + 'Billiards', + 'Blow Dry Hair', + 'Blowing Candles', + 'Body Weight Squats', + 'Bowling', + 'Boxing Punching Bag', + 'Boxing Speed Bag', + 'Breast Stroke', + 'Brushing Teeth', + 'Clean And Jerk', + 'Cliff Diving', + 'Cricket Bowling', + 'Cricket Shot', + 'Cutting In Kitchen', + 'Diving', + 'Drumming', + 'Fencing', + 'Field Hockey Penalty', + 'Floor Gymnastics', + 'Frisbee Catch', + 'Front Crawl', + 'Golf Swing', + 'Haircut', + 'Hammer Throw', + 'Hammering', + 'Hand Stand Pushups', + 'Handstand Walking', + 'Head Massage', + 'High Jump', + 'Horse Race', + 'Horse Riding', + 'Hula Hoop', + 'Ice Dancing', + 'Javelin Throw', + 'Juggling Balls', + 'Jump Rope', + 'Jumping Jack', + 'Kayaking', + 'Knitting', + 'Long Jump', + 'Lunges', + 'Military Parade', + 'Mixing', + 'Mopping Floor', + 'Nunchucks', + 'Parallel Bars', + 'Pizza Tossing', + 'Playing Cello', + 'Playing Daf', + 'Playing Dhol', + 'Playing Flute', + 'Playing Guitar', + 'Playing Piano', + 'Playing Sitar', + 'Playing Tabla', + 'Playing Violin', + 'Pole Vault', + 'Pommel Horse', + 'Pull Ups', + 'Punch', + 'Push Ups', + 'Rafting', + 'Rock Climbing Indoor', + 'Rope Climbing', + 'Rowing', + 'Salsa Spin', + 'Shaving Beard', + 'Shotput', + 'Skate Boarding', + 'Skiing', + 'Skijet', + 'Sky Diving', + 'Soccer Juggling', + 'Soccer Penalty', + 'Still Rings', + 'Sumo Wrestling', + 'Surfing', + 'Swing', + 'Table Tennis Shot', + 'Tai Chi', + 'Tennis Swing', + 'Throw Discus', + 'Trampoline Jumping', + 'Typing', + 'Uneven Bars', + 'Volleyball Spiking', + 'Walking With Dog', + 'Wall Pushups', + 'Writing On Board', + 'Yo Yo', +] + +templates = [ + 'a photo of a person {}.', + 'a video of a person {}.', + 'a example of a person {}.', + 'a demonstration of a person {}.', + 'a photo of the person {}.', + 'a video of the person {}.', + 'a example of the person {}.', + 'a demonstration of the person {}.', + 'a photo of a person using {}.', + 'a video of a person using {}.', + 'a example of a person using {}.', + 'a demonstration of a person using {}.', + 'a photo of the person using {}.', + 'a video of the person using {}.', + 'a example of the person using {}.', + 'a demonstration of the person using {}.', + 'a photo of a person doing {}.', + 'a video of a person doing {}.', + 'a example of a person doing {}.', + 'a demonstration of a person doing {}.', + 'a photo of the person doing {}.', + 'a video of the person doing {}.', + 'a example of the person doing {}.', + 'a demonstration of the person doing {}.', + 'a photo of a person during {}.', + 'a video of a person during {}.', + 'a example of a person during {}.', + 'a demonstration of a person during {}.', + 'a photo of the person during {}.', + 'a video of the person during {}.', + 'a example of the person during {}.', + 'a demonstration of the person during {}.', + 'a photo of a person performing {}.', + 'a video of a person performing {}.', + 'a example of a person performing {}.', + 'a demonstration of a person performing {}.', + 'a photo of the person performing {}.', + 'a video of the person performing {}.', + 'a example of the person performing {}.', + 'a demonstration of the person performing {}.', + 'a photo of a person practicing {}.', + 'a video of a person practicing {}.', + 'a example of a person practicing {}.', + 'a demonstration of a person practicing {}.', + 'a photo of the person practicing {}.', + 'a video of the person practicing {}.', + 'a example of the person practicing {}.', + 'a demonstration of the person practicing {}.', +] +``` + + diff --git a/CLIP/data/rendered-sst2.md b/CLIP/data/rendered-sst2.md new file mode 100644 index 0000000..d27454c --- /dev/null +++ b/CLIP/data/rendered-sst2.md @@ -0,0 +1,11 @@ +# The Rendered SST2 Dataset + +In the paper, we used an image classification dataset called Rendered SST2, to evaluate the model's capability on optical character recognition. To do so, we rendered the sentences in the [Standford Sentiment Treebank v2](https://nlp.stanford.edu/sentiment/treebank.html) dataset and used those as the input to the CLIP image encoder. + +The following command will download a 131MB archive countaining the images and extract into a subdirectory `rendered-sst2`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/rendered-sst2.tgz +tar zxvf rendered-sst2.tgz +``` + diff --git a/CLIP/data/yfcc100m.md b/CLIP/data/yfcc100m.md new file mode 100644 index 0000000..06083ef --- /dev/null +++ b/CLIP/data/yfcc100m.md @@ -0,0 +1,14 @@ +# The YFCC100M Subset + +In the paper, we performed a dataset ablation using a subset of the YFCC100M dataset and showed that the performance remained largely similar. + +The subset contains 14,829,396 images, about 15% of the full dataset, which have been filtered to only keep those with natural languag titles and/or descriptions in English. + +We provide the list of (line number, photo identifier, photo hash) of each image contained in this subset. These correspond to the first three columns in the dataset's metadata TSV file. + +```bash +wget https://openaipublic.azureedge.net/clip/data/yfcc100m_subset_data.tsv.bz2 +bunzip2 yfcc100m_subset_data.tsv.bz2 +``` + +Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/downoad_clip_models.py b/CLIP/downoad_clip_models.py new file mode 100644 index 0000000..296e50b --- /dev/null +++ b/CLIP/downoad_clip_models.py @@ -0,0 +1,24 @@ + +import requests +import os + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + +save_dir = 'clip_models/' + +for model_name in _MODELS: + url = _MODELS[model_name] + response = requests.get(url) + save_file_path = save_dir + os.path.basename(url) + open(save_file_path, "wb").write(response.content) + print(f"Wrote model {model_name} to file {save_file_path}") \ No newline at end of file diff --git a/CLIP/hubconf.py b/CLIP/hubconf.py new file mode 100644 index 0000000..520b354 --- /dev/null +++ b/CLIP/hubconf.py @@ -0,0 +1,42 @@ +from clip.clip import tokenize as _tokenize, load as _load, available_models as _available_models +import re +import string + +dependencies = ["torch", "torchvision", "ftfy", "regex", "tqdm"] + +# For compatibility (cannot include special characters in function name) +model_functions = { model: re.sub(f'[{string.punctuation}]', '_', model) for model in _available_models()} + +def _create_hub_entrypoint(model): + def entrypoint(**kwargs): + return _load(model, **kwargs) + + entrypoint.__doc__ = f"""Loads the {model} CLIP model + + Parameters + ---------- + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The {model} CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + return entrypoint + +def tokenize(): + return _tokenize + +_entrypoints = {model_functions[model]: _create_hub_entrypoint(model) for model in _available_models()} + +globals().update(_entrypoints) \ No newline at end of file diff --git a/CLIP/model-card.md b/CLIP/model-card.md new file mode 100644 index 0000000..6db1ca4 --- /dev/null +++ b/CLIP/model-card.md @@ -0,0 +1,120 @@ +# Model Card: CLIP + +Inspired by [Model Cards for Model Reporting (Mitchell et al.)](https://arxiv.org/abs/1810.03993) and [Lessons from Archives (Jo & Gebru)](https://arxiv.org/pdf/1912.10389.pdf), we’re providing some accompanying information about the multimodal model. + +## Model Details + +The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. + +### Model Date + +January 2021 + +### Model Type + +The base model uses a ResNet50 with several modifications as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. There is also a variant of the model where the ResNet image encoder is replaced with a Vision Transformer. + +### Model Versions + +Initially, we’ve released one CLIP model based on the Vision Transformer architecture equivalent to ViT-B/32, along with the RN50 model, using the architecture equivalent to ResNet-50. + +As part of the staged release process, we have also released the RN101 model, as well as RN50x4, a RN50 scaled up 4x according to the [EfficientNet](https://arxiv.org/abs/1905.11946) scaling rule. In July 2021, we additionally released the RN50x16 and ViT-B/16 models, and in January 2022, the RN50x64 and ViT-L/14 models were released. Lastly, the ViT-L/14@336px model was released in April 2022. + +Please see the paper linked below for further details about their specification. + +### Documents + +- [Blog Post](https://openai.com/blog/clip/) +- [CLIP Paper](https://arxiv.org/abs/2103.00020) + + + +## Model Use + +### Intended Use + +The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. + +#### Primary intended uses + +The primary intended users of these models are AI researchers. + +We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. + +### Out-of-Scope Use Cases + +**Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. + +Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. + +Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. + + + +## Data + +The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as [YFCC100M](http://projects.dfki.uni-kl.de/yfcc100m/). A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. + +### Data Mission Statement + +Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. + + + +## Performance and Limitations + +### Performance + +We have evaluated the performance of CLIP on a wide range of benchmarks across a variety of computer vision datasets such as OCR to texture recognition to fine-grained classification. The paper describes model performance on the following datasets: + +- Food101 +- CIFAR10 +- CIFAR100 +- Birdsnap +- SUN397 +- Stanford Cars +- FGVC Aircraft +- VOC2007 +- DTD +- Oxford-IIIT Pet dataset +- Caltech101 +- Flowers102 +- MNIST +- SVHN +- IIIT5K +- Hateful Memes +- SST-2 +- UCF101 +- Kinetics700 +- Country211 +- CLEVR Counting +- KITTI Distance +- STL-10 +- RareAct +- Flickr30 +- MSCOCO +- ImageNet +- ImageNet-A +- ImageNet-R +- ImageNet Sketch +- ObjectNet (ImageNet Overlap) +- Youtube-BB +- ImageNet-Vid + +## Limitations + +CLIP and our analysis of it have a number of limitations. CLIP currently struggles with respect to certain tasks such as fine grained classification and counting objects. CLIP also poses issues with regards to fairness and bias which we discuss in the paper and briefly in the next section. Additionally, our approach to testing CLIP also has an important limitation- in many cases we have used linear probes to evaluate the performance of CLIP and there is evidence suggesting that linear probes can underestimate model performance. + +### Bias and Fairness + +We find that the performance of CLIP - and the specific biases it exhibits - can depend significantly on class design and the choices one makes for categories to include and exclude. We tested the risk of certain kinds of denigration with CLIP by classifying images of people from [Fairface](https://arxiv.org/abs/1908.04913) into crime-related and non-human animal categories. We found significant disparities with respect to race and gender. Additionally, we found that these disparities could shift based on how the classes were constructed. (Details captured in the Broader Impacts Section in the paper). + +We also tested the performance of CLIP on gender, race and age classification using the Fairface dataset (We default to using race categories as they are constructed in the Fairface dataset.) in order to assess quality of performance across different demographics. We found accuracy >96% across all races for gender classification with ‘Middle Eastern’ having the highest accuracy (98.4%) and ‘White’ having the lowest (96.5%). Additionally, CLIP averaged ~93% for racial classification and ~63% for age classification. Our use of evaluations to test for gender, race and age classification as well as denigration harms is simply to evaluate performance of the model across people and surface potential risks and not to demonstrate an endorsement/enthusiasm for such tasks. + + + +## Feedback + +### Where to send questions or comments about the model + +Please use [this Google Form](https://forms.gle/Uv7afRH5dvY34ZEs9) diff --git a/CLIP/notebooks/Interacting_with_CLIP.ipynb b/CLIP/notebooks/Interacting_with_CLIP.ipynb new file mode 100644 index 0000000..1043f23 --- /dev/null +++ b/CLIP/notebooks/Interacting_with_CLIP.ipynb @@ -0,0 +1,925 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Interacting with CLIP.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "1369964d45004b5e95a058910b2a33e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_12e23e2819094ee0a079d4eb77cfc4f9", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7a5f52e56ede4ac3abe37a3ece007dc9", + "IPY_MODEL_ce8b0faa1a1340b5a504d7b3546b3ccb" + ] + } + }, + "12e23e2819094ee0a079d4eb77cfc4f9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "7a5f52e56ede4ac3abe37a3ece007dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_5e6adc4592124a4581b85f4c1f3bab4d", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 169001437, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 169001437, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_4a61c10fc00c4f04bb00b82e942da210" + } + }, + "ce8b0faa1a1340b5a504d7b3546b3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b597cd6f6cd443aba4bf4491ac7f957e", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 169001984/? [00:06<00:00, 25734958.25it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_161969cae25a49f38aacd1568d3cac6c" + } + }, + "5e6adc4592124a4581b85f4c1f3bab4d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "4a61c10fc00c4f04bb00b82e942da210": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b597cd6f6cd443aba4bf4491ac7f957e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "161969cae25a49f38aacd1568d3cac6c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "YPHN7PJgKOzb" + }, + "source": [ + "# Interacting with CLIP\n", + "\n", + "This is a self-contained notebook that shows how to download and run CLIP models, calculate the similarity between arbitrary image and text inputs, and perform zero-shot image classifications." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "4d9b51f8-d255-4868-97f6-be0a67dadfae" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 34.6 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 20.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 16.4 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 15.2 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 7.0 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 8.2 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 2.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=ce00f21233e5e1a5c3e84204d651ae0c17403484418c330c69ebae7297ca7003\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-tbmjxrgj\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-tbmjxrgj\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=9059060f3a406b8268cfcbbf03647ab9b59e660d03f86c6120a9dd06f2b82cec\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-7v3mrcvj/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "70a44964-883d-4fd0-b95a-2c7f2b19aca9" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "`clip.available_models()` will list the names of available CLIP models." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "11779e1e-8bdd-4167-c18e-d26bdd6b67db" + }, + "source": [ + "import clip\n", + "\n", + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "f06fd2fd-6126-475b-87d0-b10aa3b7da49" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")\n", + "model.cuda().eval()\n", + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.0MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "21slhZGCqANb" + }, + "source": [ + "# Image Preprocessing\n", + "\n", + "We resize the input images and center-crop them to conform with the image resolution that the model expects. Before doing so, we will normalize the pixel intensity using the dataset mean and standard deviation.\n", + "\n", + "The second return value from `clip.load()` contains a torchvision `Transform` that performs this preprocessing.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "d6cpiIFHp9N6", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "880cb98e-1e5e-430e-8b59-4bf35fa554f9" + }, + "source": [ + "preprocess" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Compose(\n", + " Resize(size=224, interpolation=bicubic, max_size=None, antialias=None)\n", + " CenterCrop(size=(224, 224))\n", + " . at 0x7f3a24ffb440>\n", + " ToTensor()\n", + " Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))\n", + ")" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xwSB5jZki3Cj" + }, + "source": [ + "# Text Preprocessing\n", + "\n", + "We use a case-insensitive tokenizer, which can be invoked using `clip.tokenize()`. By default, the outputs are padded to become 77 tokens long, which is what the CLIP models expects." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGom156-i2kL", + "outputId": "050b0ce1-caba-47e1-f4ac-dba994599718" + }, + "source": [ + "clip.tokenize(\"Hello World!\")" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[49406, 3306, 1002, 256, 49407, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Setting up input images and texts\n", + "\n", + "We are going to feed 8 example images and their textual descriptions to the model, and compare the similarity between the corresponding features.\n", + "\n", + "The tokenizer is case-insensitive, and we can freely give any suitable textual descriptions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tMc1AXzBlhzm" + }, + "source": [ + "import os\n", + "import skimage\n", + "import IPython.display\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from collections import OrderedDict\n", + "import torch\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# images in skimage to use and their textual descriptions\n", + "descriptions = {\n", + " \"page\": \"a page of text about segmentation\",\n", + " \"chelsea\": \"a facial photo of a tabby cat\",\n", + " \"astronaut\": \"a portrait of an astronaut with the American flag\",\n", + " \"rocket\": \"a rocket standing on a launchpad\",\n", + " \"motorcycle_right\": \"a red motorcycle standing in a garage\",\n", + " \"camera\": \"a person looking at a camera on a tripod\",\n", + " \"horse\": \"a black-and-white silhouette of a horse\", \n", + " \"coffee\": \"a cup of coffee on a saucer\"\n", + "}" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NSSrLY185jSf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "outputId": "06451963-5ecb-4ddc-d0a8-24e9b110af7d" + }, + "source": [ + "original_images = []\n", + "images = []\n", + "texts = []\n", + "plt.figure(figsize=(16, 5))\n", + "\n", + "for filename in [filename for filename in os.listdir(skimage.data_dir) if filename.endswith(\".png\") or filename.endswith(\".jpg\")]:\n", + " name = os.path.splitext(filename)[0]\n", + " if name not in descriptions:\n", + " continue\n", + "\n", + " image = Image.open(os.path.join(skimage.data_dir, filename)).convert(\"RGB\")\n", + " \n", + " plt.subplot(2, 4, len(images) + 1)\n", + " plt.imshow(image)\n", + " plt.title(f\"{filename}\\n{descriptions[name]}\")\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " original_images.append(image)\n", + " images.append(preprocess(image))\n", + " texts.append(descriptions[name])\n", + "\n", + "plt.tight_layout()\n" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1116, + "height": 351 + } + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEVKsji6WOIX" + }, + "source": [ + "## Building features\n", + "\n", + "We normalize the images, tokenize each text input, and run the forward pass of the model to get the image and text features." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HBgCanxi8JKw" + }, + "source": [ + "image_input = torch.tensor(np.stack(images)).cuda()\n", + "text_tokens = clip.tokenize([\"This is \" + desc for desc in texts]).cuda()" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZN9I0nIBZ_vW" + }, + "source": [ + "with torch.no_grad():\n", + " image_features = model.encode_image(image_input).float()\n", + " text_features = model.encode_text(text_tokens).float()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuxm2Gt4Wvzt" + }, + "source": [ + "## Calculating cosine similarity\n", + "\n", + "We normalize the features and calculate the dot product of each pair." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yKAxkQR7bf3A" + }, + "source": [ + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5zvMxh8cU6m", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 831 + }, + "outputId": "22bca748-ab42-4888-c9da-8f22c21c6185" + }, + "source": [ + "count = len(descriptions)\n", + "\n", + "plt.figure(figsize=(20, 14))\n", + "plt.imshow(similarity, vmin=0.1, vmax=0.3)\n", + "# plt.colorbar()\n", + "plt.yticks(range(count), texts, fontsize=18)\n", + "plt.xticks([])\n", + "for i, image in enumerate(original_images):\n", + " plt.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin=\"lower\")\n", + "for x in range(similarity.shape[1]):\n", + " for y in range(similarity.shape[0]):\n", + " plt.text(x, y, f\"{similarity[y, x]:.2f}\", ha=\"center\", va=\"center\", size=12)\n", + "\n", + "for side in [\"left\", \"top\", \"right\", \"bottom\"]:\n", + " plt.gca().spines[side].set_visible(False)\n", + "\n", + "plt.xlim([-0.5, count - 0.5])\n", + "plt.ylim([count + 0.5, -2])\n", + "\n", + "plt.title(\"Cosine similarity between text and image features\", size=20)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cosine similarity between text and image features')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1038, + "height": 796 + }, + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "alePijoXy6AH" + }, + "source": [ + "# Zero-Shot Image Classification\n", + "\n", + "You can classify images using the cosine similarity (times 100) as the logits to the softmax operation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Nqu4GlfPfr-p", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "1369964d45004b5e95a058910b2a33e6", + "12e23e2819094ee0a079d4eb77cfc4f9", + "7a5f52e56ede4ac3abe37a3ece007dc9", + "ce8b0faa1a1340b5a504d7b3546b3ccb", + "5e6adc4592124a4581b85f4c1f3bab4d", + "4a61c10fc00c4f04bb00b82e942da210", + "b597cd6f6cd443aba4bf4491ac7f957e", + "161969cae25a49f38aacd1568d3cac6c" + ] + }, + "outputId": "ca7a0e3c-e267-4e6e-8a1b-bbab3c0a2462" + }, + "source": [ + "from torchvision.datasets import CIFAR100\n", + "\n", + "cifar100 = CIFAR100(os.path.expanduser(\"~/.cache\"), transform=preprocess, download=True)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /root/.cache/cifar-100-python.tar.gz\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1369964d45004b5e95a058910b2a33e6", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=169001437.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Extracting /root/.cache/cifar-100-python.tar.gz to /root/.cache\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4S__zCGy2MT" + }, + "source": [ + "text_descriptions = [f\"This is a photo of a {label}\" for label in cifar100.classes]\n", + "text_tokens = clip.tokenize(text_descriptions).cuda()" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4z1fm9vCpSR" + }, + "source": [ + "with torch.no_grad():\n", + " text_features = model.encode_text(text_tokens).float()\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "top_probs, top_labels = text_probs.cpu().topk(5, dim=-1)" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 931 + }, + "id": "T6Ju_6IBE2Iz", + "outputId": "e1a155dc-474d-409c-e03d-d41b804648c3" + }, + "source": [ + "plt.figure(figsize=(16, 16))\n", + "\n", + "for i, image in enumerate(original_images):\n", + " plt.subplot(4, 4, 2 * i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(4, 4, 2 * i + 2)\n", + " y = np.arange(top_probs.shape[-1])\n", + " plt.grid()\n", + " plt.barh(y, top_probs[i])\n", + " plt.gca().invert_yaxis()\n", + " plt.gca().set_axisbelow(True)\n", + " plt.yticks(y, [cifar100.classes[index] for index in top_labels[i].numpy()])\n", + " plt.xlabel(\"probability\")\n", + "\n", + "plt.subplots_adjust(wspace=0.5)\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAByoAAAckCAYAAAATVYMmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzda6xleXrX9+/z/6+9z61O3au7p7unp2c8Ho+xHMAWAZFAhkuAKEoIEREhgEJ4ByFKeIGSSESQ+E0SIaIALxIiRQJCgoOSkEgIAoGMiY0ReAZjG8Z0M93T012X7rqe676t///Ji+dZ+9TcxPTYXT0e/z5Sq6pOnbPP2mutXZozv/17HnN3RERERERERERERERERESepfJhH4CIiIiIiIiIiIiIiIiI/OKjoFJEREREREREREREREREnjkFlSIiIiIiIiIiIiIiIiLyzCmoFBEREREREREREREREZFnTkGliIiIiIiIiIiIiIiIiDxzCipFRERERERERERERERE5JlTUCkiIiIiIiIiIiIiIiIiz5yCShERERERERERERERERF55hRUioiIiIiIiIiIiIiIiMgzp6BSRERERERERERERERERJ45BZUiIiIiIiIiIiIiIiIi8swpqBQRERERERERERERERGRZ274sA9AREREfu7M7E3gMvClD/lQRES+HbwKHLv7xz/sAxERERGRbw/6uVlE5Cu8yrfJz80KKkVERL4zXN7Z2bn+fd/3fdc/7AOR9+/k5ASAw8PDD/lI5P3Stfv29IUvfIHFYvFhH4aIiIiIfHvRz83vk37eeX90vt4fna/37+fznH07/dysoFJEROQ7w5deeeWV65/73Oc+7OOQb8FnP/tZAD7zmc98qMch75+u3benH/zBH+Tzn//8lz7s4xARERGRbyv6ufl90s8774/O1/uj8/X+/Xyes2+nn5u1o1JEREREREREREREREREnjkFlSIiIiIiIiIiIiIiIiLyzCmoFBEREREREREREREREZFnTkGliIiIiIiIiIiIiIiIiDxzCipFRERERERERERERERE5JlTUCkiIiIiIiIiIiIiIiIiz5yCShERERERERERERERERF55hRUioiIiIiIiIiIiIiIiMgzp6BSRERERERERERERERERJ45BZUiIiIiIiIiIiIiIiIi8swpqBQRERERERERERERERGRZ05BpYiIiIiIiIiIiIiIiIg8cwoqRUREREREREREREREROSZU1ApIiIiIiIiIiIiIiIiIs+cgkoREREREREREREREREReeaGD/sARERE5OfHW8edV/+Tv/JhH4b8XPw1Xb9fsHTtPhBf+i//1Q/7EERERETkO4h+bv4W6eed90fn6/3R+Xr/njpn3wk/N6tRKSIiIiIiIiIiIiIiIiLPnIJKEREREREREREREREREXnmFFSKiIiIiIiIiIiIiIiIyDOnoFJEREREREREREREREREnjkFlSIiIiIiIiIiIiIiIiLyzCmoFBEREREREREREREREZFnTkGliIiIiIiIiIiIiIiIiDxzCipFRERERERERERERERE5JlTUCkiIiIiIiIiIiIiIiIiz9zwYR+AiIiIiIiIyHeiv/nX/qrfvvsuq/Wa524csrc35/zkhC/84zf463/98/zUT73J6eo9Rj8GOgOH7NYbzOoehQGn43TMCvsHc37J97/AR57f4+TshH/4U7d5+N6Kl165xa/+Vd/Dpz71ca5fvU6ZVUotWKmYFdw8fu0OON0do8THcKwYOJQK7lDKgJUC7pQ6xOc4uHdKtfh4qbg7WAHvWC2AAU6xSinx8WIGdDDDKPF7N9w7eKf7iPdG6yP0EbzS6RiOA+ZOqRXzghnx+KVShoFCfKyUgWFWKVYxDLee3yuPKL4QM8O84NYwL2Dg3emMdHe8d7wDDt17nIuhMAwDtQ4MpVLzvGLx4KUULJ83bhhG90afHqhZfA9rbN8n7nlgeFxfN2iN5h4f7x7n3PL6ecc9ryFgxDUtNmyPZagDpRilFEqp1FJw6xQMs0LvG8BwgBbXA3eg4DS8N/KE4Pl83OPTzCqlQI+Dzq/zuE49jsjyPLj3OP89j9XA3ek06EYpRu8tHgLobU0ckrP9hnlG47lZvg4caNQ6BzOckWoDZo7lcy6FuN+KUfJ+K+Wp9+bnsXkD78bYNnQa3pzenN5H2mbM719wb7Q20vomrkkDJ/6eDj3vM/OCtw3NndY2uHd6N1ofOTt5xHv33uD+nX/A8eOfwfsas0LD6M1ZLTcslp3zMzg9c87Xhau3XuH7v//X8Inv+l6u3rjGMJvFvwHUeC1jdHq+lg1aXAu2r+9Gsfj+5Mtves05Pc9FXPfWNtv7vY+NtTfoztgbbdPoGL2PuMfrKM6B57WOe7j3EbzQS17v3uM+c8d7XLkOFIzeNvzQH/9T9i39YyoiIiLf0RRUioiIiIiIiHwAvuvVj/HC87fYrBvYyGq95NGDx9y994Q775zizajMaNSMJBudhlmNB3DoNAYGujt1BjduHHDl2pyjJxvOjt7j+PiEo+MFq9UGL2wDK8wy7OkRjtUKvUWYRc3AJ4ILKwPQiC8zzCLU6m3MEBKKFby3bXhWSo0AoswyEeyAbUM4K5ViU6DRcW95XCVCFavQNjhOsUK3Am6UjDEKZftwU9hqZthgFCv5X6UO84zgLAPRCvQ4hzZFlhl8mlOoNGsZcg0UBvBOc8dqofcW4Vh3ijvm+RjmGf7a9nyYlTy+CBDxjjWDPoV9nZ5BpRUy4IlAsngGxThePEK/bljJYM49g0OP5+RQSgUr1BIhrdUBI695LdtjcxrmRLjlDjaAj3EfAMUiEM4ECvcMJqlE2NUxd9yMzoh7hJFMYSXO9sGMCKXcaT5Sa4USQWjvbTrzed+M+T3jCmPTvdXwvJ6tj5hF+Bh/l19LPj8DY8CsxDWxiltGYZbHuE1J8xAtjr93w62BdawYpWcwbj2/Zx6ej2BO5JyFRqNScY/v6aVRyzwCPzeaN8w6xQa8NQDW65HF+TGnR+9wdvYG+HrK8qF3vDdKGahlpNZGmUFZOg/u3+Wtt1/jytUb7B7sczAMNOsUj/u7+wajYjZgPpJvO4AKrTfMM5ifQuhiU1IYoWrvGXQSYbcZeINaqX1Fp1N9Ri8GvVNtoGUwSrV808J0D8R56+Z4b3SfXreZ5NOh93j9W9FMNxEREfmGFFSKiIiIiIiIfAAOLh0w352zXo2cL0549Og9br/zLq+9fp/z04ZhGTgMGA1nxH3MMKBFKMU8IswOY+/M9nY42Jnz8ivXuPvuOQ/uP+Ho+ITlYgnuWDXqUHEKdRjobYNboXunDDN6iyZfrRV322Y6ZlmpNCjFI3csGTiY0/qGoe5GyGMlW34ZqGYz07JhCWxbkd0bhQgXox3YMcumVgZf7o1aKt0MulNqPP4UiJUMBM2I4LCwDSvdW0Yi0b7Doik4RSURXDVKmUVzsESYMrVJjRp/9ggEnYbhEbjRqLVQ6kDN5+ZYBobT864Ui7ZoG6NxV0qht5YNw3gafRyzqVriEH0KDFu0Mc1xi3PmvUXoaoZ5hVIo2WKLILdFWJfhajQaS5yrjK4czwAvGrFYhMBTY9KmEDmvvfcWAR2Wn9OzRRv3RWudahbPx0o0YHv+GbJFavQMpnDiPmmbbUhpJYNGiyZetQF34rrTwTpDqdGCzXC62AClRwBn2ey1ur2/4gHAS6c3o5fOYANOBmc2YETwWqgZ/DbcoG1vkrzPZjP6JoLSni3GuJMKZh2ngjU6Q3ysZ/jMgHXHGBk9zt5ms+D09AGnJ+/Q1sf5poA4D917tnidQoSxg8EwczbrNbdvv86tWy9x6fAq8/mcOhTi5TnGdbZ4zURjesxsNl4n0bqMcLbYLELoQvYgoZdtHI1ZPEsb4/NrhvudRrWCD5FhFhz3uLO6A30TrzO3KFU/9W+B53OzPCaKZUe1RGtYRERE5OtQUCkiIiIiIiLygfAIY2zJarXi8aNj3njzPnfvrKh1Nz/Do/mUI087I2NbUeqQjcQcS9oq4yYCxsuHBzz/Eeejr5yw3izYcM66ndO9UW2I9lUx8JE6RDsQj0JTFBdjJKmVmo3AqYFJNOFaj/DLIpyIcHGgW+aAOXLVc6wrOUY2cogMQtwzLImgp3vPsCfHjnbDPIJCLz1HVDasREvNLALFniNMMcN6PH7vhhWn2ZifM4WFngNm8/v0aNg5hvVNNhpzZKw93f6cM7eCd7Di2f4cMAaGMoBF4Gg5XhaH3keGOqf3hlmLsMyNPo0ApWd5LsaqukdgWLL12DPM671fNNCyBRiBU4ZLVqIVy4ANEZxtQ9anGrDRbnsqnrW4Zl9RLvQpSJ7G1G7w3jM89W0zsZCNV2/03rPNSvY/O2WaNIplwGnxbHvP9ivZNvVtGI1ZjLmN+aCUYnjrYDmmuGdDEn+qvWn53KdzYBSr23DUpvvMpwmnneI17+8IPrNvGAGc9bgH8timHJ4yNV1LtAYplFbxMlIYsDK1W8FshtFyjHCGnhlwQ6UOzmqxYLk44uz4Lqvzd8E9mobeGTOspxGvywJlgDI4tUI1OHlyxNtv/1OuXXuOS5cvcenyZUYfKaVmKzLexDCNPsbifsxMNa519+09S2/bE1brAL3QbczXS4cywxnzyhfqEMF56yNUx1uN17p7jHC1iuWI4un9DG6e59CoVvI1MDFacxRTioiIyDeioFJERERERETkA7DZbOi9M44bxrZmtVlzfr6ht2jA1TqjtJLRXm7+8xGvTi2zbBXGGMdNW7JaN8be2dnd5cbN63zP9zYOrlTm88JsbtFMtBgDGrM/I5Dykhsie8ZYZYhxneY4MaLVikX42DdAjQCDnoGUY3WAaVRsftyy2QZTYEaMxySalNZ7hFb4trVY7WJf3tQiLL3m3sVpxGyEHm6GdYtAyC+CPLcMlbI9OPU3zaZditPo1ZbJau6ItCn4GjIwtIu/z5BnsCHO09RozHZiKdEIjYfJnYzdo2HXI3DurV/s5pvGY2bYHMljRKjkuZuurWd7cbs70oYI7Nxyp2YEs1FmLBSLVmmEybYNgC2DPSsVvMZjAljFsj7pJc/l1AbcHqdnSDyFmlAYtoGqEw0+eu6n9PjcaAaOWca1POc5cnj7/GEaz+vZqDQKVDJk7LFbkhptS8iW6RRE5ohci3PkzfP1EiG7ZVIZ17QyzXwt29A2zxMeZVArGSxny9ONUisODMS56mb0HuNKawbqPfdA4jUapMXwXsBa7saMUbJts+bs7BFnJ7cZxyNgzPsvjzqDXs/2ZZ3+s5jQbJvOndtv8dwLH+X6zZvs7e8zzGc50jaapoPN4l+MDNGLFcxrBJY4MNsGg15rnnvPezjb3DXCY6sNbMh/B0ZoM8ydGXF9m40Uj3Zl651qOT55ehMDlqNlYdqHaZYNZnq8SeEiMhYRERH5GgoqRURERERERD4AMeJxxHOU6KWDA1752A2+/M4R56en2DICyxi7atnCa3TPsaG59hEiOKM4tQ7M5nN293awAvuXBlarc4Y59ByzWWr0CmNH5dQuy4bbtGSuDBn0WAZrMbYzxrROI1mdUqbG5LRnsG93ABoxKnYay1psiPGQbU0dIgyKAl2fcsUMnSy+b4ZQ0zjSYtFci5G4U7hy0QYDMlCNsawxqhWK21OBaX6yg5WaQV+BkiNRPZp20/OxKTvJHYluI3XYzT2TPZ/XLMbqMu10jNGszTZYi/DNfaR3vwhZe4w37eQI0+3//TJFivE4UxN12icZDca2vYec2AdappZilmVj/Kzn2NcejdIMVsmxuZHrFqJLO+K0aKBmO3AbZDFtkiRbcT0bl57tzdgfOo37dEa8k7stfRvgTY/i2f6LgDmCQ7cIprG6DWe313N79XJc6PQHK0C+FqZH79O0154jgQ16x2qcv8aYh1rj/i9GN2fYjpcdKJnE9mJUrxf7K3G8xIjU4jEmtfeL46kFmndKvoHAe4uAvVR63ruMzvnyiNPT+yzO3oMeLWF6z8B6Cim3z3YqJWMFijm1GGdnJ7zzzhd56cWPc+3aTebzHXK6L1gElJbXsVjN4D9eV9t5wxdXddvU7R6B5XQfxnhWoiVqA946tRheN8zqwLiJNy64F1qJkcPFLfPgnq/3eJ1UI/Z1eu6bLUCP0bsXby4QERER+VoKKkVEREREREQ+CN4pZcasOnu7u9y8eY1Pfc8LnJ+fcfLkCefnJUaMtotdj903sYePGb00rHbmu3Ouv3CNV199jqtXL7O7N2M2n1OtsjODx0+gt8ZisWBzacVs54A6zGMvZRnoJcIwz9ZTz/Zen/ZSDsRYR4tdfliEprVEKysabtkEpFIiQwQyQM3Qo7tTise41N5yXGTZ7rT0HJlazDKgnBKbBtsxocY0lTWCtRpBXo4F7d4oXoGC1UIpJZuY2crctgAjJDaPxqX1jtsmdoKWCGxrjs20bFu6OyUD0ouD8Hgcm5qvcW4My/GfHe8t25QxyrV7NiunQLIDxXM07yx2dPoYzbMyxDXpYzY5y5Qr5SHknkqvmHegRhOO2El4sUMxR8B63+7ChE7NC9Uy9Y5gq0yDaTPUy6DQjWrTvsloB2KeI4gLvbfcP5jH3wGbQkjymsI0CtgoETS7U3wa59pptMzcnE7s2Czbe6jgbDI0GyH3TeJjjCwt2Zz0Tqfl/eoROJIt5G7ZNo3PjXsn9sHG04xwcfBC6+sI1IhQN+7VCNcrEbZ19whfqRQ3xtYpJc5R80bxIfc9NtrYWCxOOT+5x9geM5TC6OsMO7PpG7dn7nuMjw84tUQYOuS5vHf3Nu/eu8Otmx/h0qVLcb/GVYmjtVm++aAx2E42GaP56fmazmw5mrDesVpi/6rH2F5atoRbjvFlRrwJYBaPNwwwtpwaXKCOWMudlUY0eyG+Z8kRtz3OZaNjJe5/37aXRURERL6WgkoRERERERGRD0CtM1rr9Aa9F3Z293ju1k2++5NnPHzwmNOTU85vPwZybCYQaWCn7hQuX97h+nNznnv+Kh958TIvv3SdWzevsru7A2YMs0atA210nhwd09sulw6vsX94KVp8Fm0/LEI1ukfjyUoGU32bx/UcjwkbSplCnWw9dra7I6d6WbQAQynTzj+/CL3y+0fqlqMmzfBSo+FJjDmNHXpxLBchYN3uRDQzemu587JQKViJQHFqQ0ZztOcY0XWO5iSbgfk4GbDlEVMt2nbR53u6WRbRn5eSo10jNHZvOTozngu5k9B7j52Y2S6MUDSfUp7fMj2vKbAljsXdMryNr8/cL47Gp/iXaK9lldJs2rOZbcYpNM22qDnbhts0ajXnvMajeY6XnULhUsBHSnc609jWAfoUUHrs4fTcl+qdhuM99zR6z3C1092i2emxQ9O9ReuxDBFiesuWbs2psJ4BawSu0TjsFOZ439B6jB+e2oFGj3NleZWcbeM2doVC8WG7t5K8tiWbqIYx+gbLXaLWM9zNMHP6VsVivakRI17NiXsgvlEca6lxC3RiNyZG23SWy1POTh6wOL0D4zrCVOK0d+94jxHHbTvJOMPLDPw8pqhSgPPzc27fe4uXXv4YV69d5WA+QL7WPMcTT68Ln0Y5b1u1gDViRWW7GFeM09qYjWXP8LDgpeNWtm1JZxPnzx0red08PrdZ7MMsPXfTTnNfp4DefBvmZ0oZx9r7t/gvqYiIiHynU1ApIiIiIiIi8gHYrDecna948vgJZ6enUBq9Na5ducInv+smjx6d8PjxY9anp5hX3Ddgxs7uwIsfO+QTn7jOiy9f5saNy1y7fsilSwfsH+wC0WibdhZuWuPJk0ds1pUbV29x83qDoWClxt68Hj2saUzoRdwYrbup6eZesoFIjvrsVCv0kuGkRWOue4wenXK/KdBiu2cxWpG1GG3aYQcUCq1vMubr9N4YLMK2qV1ZsGwpFtyc5ptoVto8JkeWKVR0Shky4GqUmjvxHGCkZAhUS6F7tBnxymAl2nzewUes7GxHe06jND3Sne1+yBj1Wui+ISuJMea2x1jS3sYMMcnRqNESncaYxn5PsinZMKvb/aNTeBehcL9o3uUex/Viybg+gVLYne+xu79HHQYYjFJmlBLjYf0i+2XKh9kGRhla+3RpfRuGTk1Ycs/hdAxuDi0qfxGgXnw92TztnuNGmULmaNFayd2QpWZwtYl7wKZY2L7i2OJc5wjiHjsvm2/i7/AM4zLszeae25DneWrEeu7qHHO3Z6eWaIUWr3lunOI1m7bkmFuyKRz3u2WwXzyPtJcIq0uNFiRjPNc+7fvMewfofc1i9YTz0wesl4+BESsR7vXe2F7ePFvbunLk4XENiJbizGDTOu/efYf7D9/l+Y+8wN6VvdhP6iW+9zTG2afzGWOKY6dqRoUFvOffe7xhwWjb0BkDb/mGAW9QDesxsre4YRW8N8beKKWy6S1HyMaYagCq4WO7CI5z1LK3PMe5F3XqgoqIiIh8NQWVIiIiIiIiIh+Ak7Mz3n77Lj/zU2/x5GjJ3u6GgwOjWqe3wpVLu9y4foWzxTGtn9GJUG6+C1cOKzev7XL96iUuH+6zt7vLfJhFe61AaZUyb8zGgf29OVac88UZJ2cnbDYj871djAwKp72A3qg1QpNqQ7awKu6dSsH7SKnRtCqlbIMMy/badpFe7zGe1greo4nlPXYD1ml06tRac7Ztv9Z77sIcMzi0iPPct2FTn/b4MQLxeNvmJNHMioCu0mmUWinUbGRG2EaJlmKxgcaYQU4EQNv9lGWIsbRTuTBHaTrZhCzk18VziSZljCmFTvdG3zbELlqKU+MyQqNst3UndjManRbBZgbGud6R1hvjOMLoLBZnHD16yBuv/zT3H94BP+fqpWtcv7nP87ee58atF7h286Ocb0bcZsx3LzObH1Bm8zhnNcMqZrGnc9tojRDasvVIAW9jtGV727ZDcSee2nYmaoSCOQq3MsQIXvNoX0K2c4fYpRnfJMO/bAvn+NxI5KIVOR1Pfjm9NXqP+6L32CVaLM8lM1qGZJZjbdm2haF77CwtZWr3RXt4yNGxzsX44SmkczyCu+3Y3IGW4VstA703ylAy3Mz2cbZ3nRrjaI3YLOsjfewsz044O71DW59mezVeO9Yq5i0/P+4Zs2zxtmhxZpYbo4wrVIfTk8e89947HB19jCvXrrOzt8c24TTbto8hRtA6PRu4DTpxHXPXZsnn5L3GNejT9ZtGFbMNob3GzRlt6krFaOYMFEY61iu9OtamnbXxWivETtApXDYf8o0IPdujIiIiIl9LQaWIiIiIiIjIB+D0+JS33rzDj/7t13nv/oJhtuHw0Lh+dcZs1nn0aMl6NWZIN+1A7CzPNzx6fMa9+yc0jJOTBZcvLzi8vMe161fZ299hNhuoJfbBXb5ylevXTzg6WrFZL1mtlhxyORpmbtnim8LHGPcZ+ysLLfciTiM8PZtTMZaz5M67vt1v6TR6BntglBJNSqNiRFNvGicbuwxbjjGNMMdyDGqxGDc5Ne2msZEAGBmkdswjVDQrlFqotTCUkqNtIwSL8HDcNr2mDAtvkG3Cnr+H2NuJRUszS3vbUZhuYwQ1OVKze49GWPccQNq2bbxaIrCjFmi5u3Fq/tkQbUmmUa4jPc+z9wjJOkYfG4vTE+7fu83x0QNWi2Pu3f8yZ+dH7OzOuHrlgL3dq1y6tMPVy/u08QkP7jxgfXKHS5eus3v5OY4e3OH4+IT5/Cr7l25ycPUW+wdXKbMI4IoNee2m9mzBGSkUerUYgVoG2leMcwVyx2iE0X4xMrhYfHxqwVrNHDsau/GxGIlqeeNY7hI1G8AsRhAzUEo0KTuNDtsA2Lttd6FObcNY3xntP88qonmE081bhuVxfUvJMabE3sTee+w7JUPyHINatlfIsGIxWjj3hNaaIWCPUcHdobfYlemlRcifo2X7ZmS9WrBanLE4f5duK8xa7HJ0ogHsHpm1Pd16jeByujLVoA5ObbEfczVuePf+PY6Ojlivlsx3dynFto3WbWDpA2TIGu3mug2NR3qMc8YiaKWDx67Wvt1p2rbN29HHaMVGvs5QKm1j0EfGAoPNaNahj/RaoI8Uhmi6dqBF67TkSNnS4/rUp4JpERERkacpqBQRERERERH5ANy//5gvvn6Pu7dPWS1h01e8e3cFfUWdw2Z1ztnpBvOBYrt03+CMnC3P+PKXHvLovQ17Bw842K9cu7HHiy9f51Pf+yIf/ehHmM2GaFaWgdmww81rN7B+RGdkuVzSxzXDzg517FALvg1zcr8jnu25GPkag1ILpUzJUARt0CjZmms5MtKm8Z30HGMaQQjEXj+sZ1hStn82j1GuALXMoI8ZE0XY5Q6DzekW40Mj/LzYY1hLifCpTNXItg2kKB6jODPYjMAR8E4tcezFhxyVW3NSpmEWQWkcVwavDNtRoN1btiFzdCo1d/dZtjZXEfySYS+FWnOEacZg3R1vzrgeWSzOqEOJANkKpyen3LvzZW6/9RpHR3dpbcWt6zf45Cc/yu7uJ9jdmzOvcw6vXGVvfw/DWS9WYM5iseLRyQnt0RFjc7oZR4/eY73+Am47XDq4xUuvfi/Pv/gqO3t7cW6m/ZvThNwpiMz7wp4KH6dRqTw1utNyruy0Y9NyxC/TWGG7COWm3YuU7abNuK65iLGWilFxH+NvWqe3xthG6DkS1qMJbDVHCVvNj03jh2fxuNPeS/K6Zjg/hZE9G7tOz72Xtj0fsQc17lyzghXLMaUbaomwnGJ5Gjpe4ix2InAuNe97K6zX55ydPWRcnFE9A89sBse442ksMNmetMjS4+RQgQ3TrejbHa9PHt7n4cP7nJ58jIPLlyl12sNZo7XrJYPbmq/J2JMa36dQnHwLQcTjQ8l2aqnZ+O10q5Qcc1tzj2yzkVoHfIShZuWztNhV2zplGOi9Y63QmkOP1xbFKJ3YeUq0Riuz7bhjERERka+moFJERH7RM7NXgTeBP+vuv/dD+P6fBf4ld9c8JBERke8g79y+y8++fpfz5ZrBdiLw8xXr1YbxdMVmXDC21TY0IaOE5kvW6xVn44qz0zUPvXPnnRPu3D1nvle5cuUSB5d2YXTOT845OQBOerMAACAASURBVD5nudxQilErMVp1HLH5TuyYyyCuUKg1plH2yAJzHGr8uWR4EoFTtB9Ltr86Hesl4h6PkJIMvqaQbwr3bGqoTc08n0ahRpDS3aNRabFrs9gQQZVtY5xogHm03KzmMFXrmM1iTGfJcDTHz3Zv23DGsGwQchHiGPFYOcbWLMK0jF+y9dkuwrp8nNjn2MEKva0jzJqe9dSedItRpt7oOBSbpo+yWpzy6N373Lv3NuO45PLVqxQqDx+9y6MH73J8co/Ckp155eaN53nhIy/ywkdejNbsfGBnZ59hmOPurJcLfG4sl0uG2R47e8a5nbE6PWG1WrM8P+d8sWC5XtH7a9x993VefunTfOJTv5xr11+AaoybFbXO4rzRaW1Db7kn02I8au8tx/zG/XjxP1Dzd97Askk4/T6SzQyuN1zcFgNmTrdOIZqKOWOU1jfRhuzTzsgxR7CSDc4Yw1ttJ/unw7aKaBb7V+mOl+nmdbp5BKrd6aVR/SKgozuFut2oOd1nMeE3/2wl95qWeH69xf7R7lCN4jXHmOZOz0Lu1Wys10sW5+/R2jEZ2UOZ0b3Tu2NTa7hYHJ9HS9mmqbp9mxFTsw1ZzDg7PeX+g7ucnZ0wbm4ym+/keN0x9kFSYgyvd3qGlW6d7pY7XB1vPQP3gV4u2svFyBHITqPHuSgx+tfM8AyVmztWS5xPm94M0OPp1DlmjdYazXIXrY1YizcrxA7UpqBSREREviEFlSIiIiIiIiIfgNdeu8tbbz6g+26OvhwiNMkdebXOaL6KECF3HOLTWNCGW6f6gGNs1htOnqw5ebJmsVjSx8byfMHdOw/54pt32Kwb81nHW2F19ZzWRmoGOr1GA4wWAWPffv8YWeruEXSQAxvN83CyGUkjI8oMoiJQMmJMp2XjMBpkPXb72TRUc8BZ5+dPI0MLfRpHm7sDsZZFxZKBpmV7km0Ts9hAcctxnTX3XLYYb4rhli0679kCLRGE1pLBHNGAzF2DRgQpnoFcnoAMLXPsbD5v7z3CTY+QqveRQqVSYj5mhqHF43sszk65+86Xeeut16k7czaLFZvlEW++/hOcnT5h92Dg8uFVXvnIdS5fPuT6jWtcuXydg8N9dub7MVq2DlQ3+rim1jmlVHYPdjm8dp3eO8vlkvVqzePHDzg9PWGoc2qp7O8dsFyesTx7yBd+5rN86Yuf58bNVzi8cpOXXvlubjz3cu6uZBsiY9DaJu+FSs95qxEktmj3WY/z1uO8upVo3GXLdhqNmws+oxVbcoyus/2907c7DC/2LeYI2dZo9GhLWqHUitOyGTs1JONcu41sk3SI/ZklGqsxvjV2RJplCFsycCTG1HruZTQjAlVyvK2BuUdYWko2SVsGnBFODiX2gdJhHNf42FgtTlgtT3BaTsedmpsDlZHRMngf840BRBM2jinj7ylgLxF0msOmjbz37h2Ojh6zXr/M/kHsSm29x/fJ0cu9EG8CyDcQVHx77byWaFOXSqfHec09svEgHSNbpl6otdNb3B+91O344OYb6BWbQe8NGxpjH7OxGaFoNJxrbqbMhqcXepnqoyIiIiJfSUGliIiIiIiIyAfg9dcecXp8zjB3hjqP/XlWs7Vo9BxDaVYzWMkFdnS6b4ApRIjgYdyMLFYbxnFkvdlwdrLk9u3HfO4nvkzbGDduzXj5xcaNqzfZ3FwDnTrE6FUcymB4j1GQLePQ2FdJjiltkTGRYyetRkvOo1lYqDRfU2xqf0agUrJN6ZFsxPPbhh8NbAoFiWMq0Jtns3OkYJRac19hNMniW7dsuA25ly/Gv1qGWkx7E32T7cjYKejWLwKo7ExG4S6+dtqFGNsah9wZSZ7/KVyZnlWhuW8D5GnCZiGqqN1HCtEsczc2ywXHjx/xT/7RT/Dw/pdYrBbs7Fzi4cOHxGDPNbO9gfkw5+rlQ249d4vLly+xv7/PsDPQNhvONyeQcexsb5dLly4zzGbMdua0Pu1JHJmXQp3PWO8fQHOW5wswYzZU9q7f4PT0hCdPHnJ+9oTT00fsH1zj5OgRN597h+vPvcilw+vMdvawvPa9x75Utwz4cv9hycZh80bJUK3YgFmPXafTaSZGr/o2SCw5PjgCyeYNOnENmYJ5z92RcT1qMazMsGw2lulmyIZn8WlEa8lQL4IwzLejba1YfI8CWI/mIh6t1+2Y3wwh46nm1Yz706hQarZpc1yrDXk+iFZhj3uP6vjojH1kuTxmdf4epbft69nyuU8hnuV9aQZteknE4cdxTMcyvQ7cYYTHjx5xdPKY1WIBVxxmHqF4Vne9R524muXYXMOLUxjzzQYWe2anzuXUavYeATSxp3S795JCKQPNNhGkWoHu28a1TSGvO5ajcbcv3mIRZpYex1iIWb0+zaMVERER+UoKKkVEREREREQ+AF/+0kM26yV1mOdYTItmZRlilGg2mKL9lwEDsV+vM9J8pPpsqljRxsZiMbJejSxPFjx+dMzbbz/ivdsL6IXjowWL5cgLLzzPyy8tM8SJAa02tc6Gkvv2ZjQfYx+fG707sYMxR32ag+e+yZ6jT32Mx8u9lGTTESebhhl4WMn1hNOY1AihpuaieaHWetFce2qUqJeLvYel1PyvRLu0VjzbclYzwC0OLc+bZS/Nau7MnIKlGuMuIxeOYM17Bmmd1sccX1pyqCfg0w7PcYpkYzQnPVqdGZR1LK7L+YL7797j7S/9Ex7c+xL7+8ZsGDk/O8Lrghdf2Md9zu7eNa5fu8Hu7gGzYWB3/xJ93NA2xobGyju7uzvsHxxQ55Fged8wrjttXDNuNqwXyxgR3GBsjdPjJxwdPWGzXDIMlc24ZnU+sjPf5fnnX+Ls7Jzl6pSz0/c4P3/Mwwdvcv3hx3jhuU9w/fmXOTi8Es+/RMDVib2R5oVuZRusVZtFKEaGWxZ7ITueI0T7dqwrudOyW8PqsA38Yo+oM406zgWK8bqIM04hg+lSI6O0mtc1Yz/Puag4hYHOJsJFs7y+lqGfUQr5veLr3KZhxZ57Ry9G29o0NjWP/6LnGDtRY//jkG1XaO7b+37crFguj2nrBV4GajZzq81zpOoygtE+BZWN6RTEiNUsh5bt04jQskS4enZ8wuMnjzhfLmitUQeLMDWXXFqGv5EVWox+zYBxesa1ZDDpF6VXm+bO5o5X3zaKAWoGu5t8U0PNBnQG2T125Jo3So/XbSmVvtlMnel8LRe6jVSb/xz+NRUREZHvZOXDPgAREZFvJ2b2aTP7y2b2yMzOzOxHzew3fYPP/Z1m9v+a2RMzW5rZF8zsj5jZzjf4/H/bzD5nZgsze8/M/ryZvfjBPiMRERH5sCyWq2hOtk7zDVYqdbZDHWbQW+6mi4AuwpSaLT7DveHe4mvKwFDnmBeWZ2vOT5Y8enjC3buPeeetY9rG6a2zPN/w3t0lb9+5z8npCW0TrcxSjGrTnrgNbiPGhqEaVmCoRi1QrFPNtmNcY5QqlBpBZ4QmNfLJ3CUInWIRwlbLoZO9RTBbK5Tcv2lsg0yfgjCg1EqtlaFWqg3bP5dhjpVCrRGU1Rrh1VCnEJJo0blFEGaxS8/yc4Y6YEOl1AEbjFIG6jBsR8m6Q++dsW8w4vy59/zVt6Fa3+5UJFuWubcwdzm2zcjx0RO+9Mbr/Nj/9zd484s/zYMnb0XIPBu4fvMGL774UT7+8U/yPd/zvXzXJz7N4eF15sOczdhYnC05fnLC3TvvcOfLb7FZLbA+UmyM8zg2ehsZNyvG1ZJqxnx/B8yY7w3sX9pjPp+zu7PH/sEhpeYo0T6yWi1ZnK8wnFnZ4eDgOru7O6zWZ9z58s/yD3/yr/N3f/Qv809/5ic4P3oCfer+le2I02Il95wSYXWOUd02TmOeLn0cIySb9hdm5GvEDtHWOvRp/ynZzIvmYLWBYpVSZpRhxny2wzDbZZgNlDJQqkVzkR7tXItxxG4e7dY6QK0Reua4YvMM1Cg5ktiy0Rz3rvNUK9KiPUkxPJus0Qie7rP4GrNh+2fPkBN3xnFksTxheX5Mb5toTZddhuEKZTiklp04PgpmlfnuZWY7O/F6mh6veI5KjcbvlPdGuG603nj85AGL8yVt7HlIhVpm1DqP432queoQ93q2HM06xQqDDflGgmgkV4YIXy0fz2o2vPN8lYFad/EyRLBvJa9uBv0X3zX/3YqRuV4iBDUr+W9H3e7FlG+emV0ys7WZ/dhXfXwvf/50M/s9X/V3vz8//vue+th3m9mfM7Pb+Xh38s/f/XW+5x/Lr/9M/rz7OTM7z6/5E9PPumb2683ss2Z2bGaP82fbG1/n8X6dmf0ZM/vH+bkLM/sZM/ujZrb7z/j+v93M/l5+/0dm9hfN7KWfyzkVEZFvT2pUioiIXPg48OPATwP/PfAR4HcAf9XM/h13/+HpE83sfwT+PeAd4H8DngC/Cvgh4DeY2b/s7uNTn/+HgD+Rn/fn8tffDPwd4OiDf2oiIiLyrOWWuWwu1RzJGAFeGWbU5jSPvYDVZttxkZ2G+ZrmG8ZxxVB3tsnF6Wnj3btHrE42fPntJzy8f567L0e8O4vzcx4+OOXJ0QnL9Yq9gx2qzSMW9A6lMvY1WKFm8NS9ZUgR4c60r7FaiR1209dC7p5s2/ARCp0R8xp7/6znAE7H2ypORO8RbHiM22QarVrIHYLxHmqrxpDhR80aX8km3VRFi92GNQOxbPC5X+ycLBmglcIwNfEiiowCHzWjoGgOxljMQqnQsx2HF8yG7Q7NTo44NWMccz+ndTbLBY8ePOTNL/4s//S1f8DDx3c4mM/Z2a14G7lx6xYHB4fs7O1CbywXS85PzsFhtTqP8A4oM2Nvf5+DvT3ms8Jms+L85JjdS5cpBarBbGcH350zrjf0cU0x4+TJYzYt9nVevXYTB85PT3hy9ISjx48ZW+xkPDk7YTbfYagDm41zevqIYbYHq8ZyccTRwzvcu/dFXn7101y//iL7l64ym+9GIFmmJm0E6NWG3Ilo2yZtNIV3cGu0Nl7c72a5X7RTqERoHi1Mz/u55F7TGK8KxWO3KBbXI6a6DhHEbVuANUcV92046n2k1Mo2OYsoEu+OV8dKjI31HEFsU0005pJGuzLH+0ZrMsI9z7HH027ZKYxr015Gd9oYofBqdYz3EWPArFLLJazOcAplXON1ZHfvBQ6vfYzz84c8fPc12rigWNzvhchaK9Hf3I6FtWhKHj15wtnihE1bs2M7Mf54O/422sZtOk3uFGt4qfHarfN4A0LP1mbvUGZ4adSeAbw13I1SnNaNWqNpTTFqr/laideat0YpxtiybWyWAek03tXiPJQ4Rx2gaPTr++Xup2b294BfaWaH7n6Sf/UvANObY38D8Oef+rLfkL/+TQAz+xXA/wMcAv8X8I+BTwO/G/itZvYb3f3vf51v/x8A/wrwl4HPAr8J+EPAdTP7P4G/CPwV4M8Avzof72Z+zdP+4/x+fyc/fzeP/48Bn8nv//UWmP4B4F/PY/4R4FcSP5v/UjP7Ze6++jpfIyIiv0ApqBQREbnwa4E/7u5/ePqAmf1pIrz878zsr7r7sZn9XiKk/D+A3+Xui6c+/48BfxT494H/Nj/2KvBfAY+BH3D3L+XH/1PgLwH/5jd7gGb2uW/wV5/+Zh9DROQXis9+9rPf0tednJz8sz9J5Bno4ybCD2/bHYexF69gteKbbATmOEojRsCSvarum2gNmtH7GrPK8aNz3vjiY+azE+7eO2a13ORo1gbm9I3z8MERR0cnLFdLjKsZ4GVI542h1Nyp2J4KH2L/opVK71w030qD7S7NKQPyzF+n487dkN7Be3bpnDrtcbQMQj0HQuaY14vgKsbexvhPz9GtZRt6lFIxZjFG0mLMpXuMhqXnGFErYC1bleUijHp6JGzuT5xagOYx0jMaeGxbc9GYzJCsWlyjHKNZDMa2pndYrBa89vpP8/f+7t9iXB1Ta+d8LNDnjAe7LI8H5gV2ZpXZUBkOL7Eczjk/W+A456tTzk9OMXOuXrnBcr7g8cOH7O/vs3dwQH30kL3Lh1zaO6A7LM5OWa9XlGGIkbhDxdqazbhkqHuMm856vcB7Y2dngM3IZuPUUlkuznCH1eKY7o1a9xhmA8aGYgPnp3d587UnvDO/xMHBLV585bu5+cJHGeZzBhsycLSMsCNYbt4jiKJ9RUBH7k2Mxmuc107sG/XeKXVqRUaTMG5Go3pe8xLjgM1qNvGg90Yps3htdPJ6wzTP16xkmJy/euyNpBizHo3BaexwjCf2bTAZj5JhuDtj2zCUDExzFyMeO1i7TXsn45josBrXLFenrFYndN8w2EAdLrO39yI27LBavEsbz5jNLvHKJ34VL3/in+Pk7DH/6Cc7777xM/TmF0syp9OBU7xQzLc7QE9PTjhbnLEZ19mojNdkz7HEU9vUc7doPGjfjo/FHc9RviWDYO892qHTa4tYKllwvEer0nJstZf4dyyuc4kwtFb62LFu4Pm68Qyxi8cizmmH6zRjV96vv0UEe7+WCPogwshGBHhTMInFuz5+HfCGu79l8Y/gnwMuA7/b3f/CU5/7O4iw8c+b2S9x/5olor8R+EF3/0J+/g7weeD3AP8a8Jvc/Uee+r7/N/BbMkT8yace5w8Ab7p/ZaXWzH4I+CPAbwd+mK/1W4Bf4e4//dTX/M/A7wR+K/C/fuNTpp+bReQXl++En5sVVIqIiFw4Av6Lpz/g7j9hZn8B+HeB3wb8WeA/BEbg9z0dUqYfAv4g8LvIoDJ/PwP+1BRS5mN3M/vDwL+BxrGLiIh8x7FsADqd1jfQS7YCe4QQdYichYv9lFO44MTo1+YbKvMMHuDsdM3bbz8BCquzVYQCZjgD3jc4zsnxhidPzjg9O2X0MZuaPYPFHHfpMYI1HrZiPRqP0Z4b6LQIMHqMbrUc+ehMGxuzkNbz/9vOFlu00yq9bXBrU68NGDNMgagJ+kUzbxopW2KvYWSKPcdilsykoklJyV2fHo1Hap7PQp67+G8aD+sZ9NIdzKhWoyXnYLkvEa85kjYadDGy8iKY6+4xRrR3htkOq80S752z0xNuv/1l3nnnHns7Hg287rz04jVuv3OPe3dus7+3y61bz2HVKHWH2WyP+ayyu7fDjZvPc/XKVUot7O7tMxsGDi9fo84r8/kOlw6vcOnyIbNhDlbobUP3xuLsNILO41OOFucUg3XurlyPK9oYo3Xns8rOzpxSnMXSODs9x6rRNiOr5TGt7WA0jAXL83fZ37vCbPc6d+/d5ejkEd83zHjuhZfpNsY1KEM2Wj3v7/yVQrfYWToNIO1ctF+jLOX0PlJLNFp7b5Qh/i8p90Ih7tFpeaIxxOP4yDQyNYaVxP3ivW2D8rj/415sOd5103PscR/Y1E2G7IWcBktMes3RpdOuym75xoBpTHGZCrt5D0eI15lCPqe3Rtss2azOaJtFvhmhsn/peT7+S34t+4fXeOMLP8bmnWOG+S6vfvcv49VP/lJOz4958OANHtz+WcbVdHxsw3gwrDi1Q8l9n+vliuXZKeOm0b1Dhv5T/mN5r07BYusRUkPLED6enzs0i5DWsynrlm9UmM6FgdUSu2v79EowIF4/VuPaFmIPaCvGMOzgvqDlvwnTufAewXGfrpe8X38T+M+IQPLpoPJzwP8O/Gkz+5S7vwb8MuA6MfEHoun4aeDHnw4pAdz9h83sDwL/Yv73t7/q+/7JKaTMz1+Z2Q8D/znwV6aQMv+um9n/RISbvxT4yaf+7o1v8Lz+GyKo/M18/aDyTz4dUqb/gQgq/3n+GUGliIj8wqKgUkRE5MLnnxqn87TPEkHlLzezv0T88PUA+I+mBsRXWQHf+9SffyB//ZGv/kR3f8PM3gY+9s0coLv/4Nf7eL5j9Ae+3t+JiPxC9ZnPfOZb+rrDw8Of3wMR+RY5HqNL3WPXXqm0tmGY7dDHMUewGrXM6d4oPmBeiR2Oje5ruo+5926InKAZi5MRt2hD1TKDHnshY5rlwNnpgvsPjjh+cs56sWYoA1bAGSkMGAMjmxxnGc3KQqEXx3oEUeaxf7Aw0MlQhJrBZY7v7D1Ho7ZoMOYeuu4bKLHDrve2bTP2Eo03prYm0X4spURzkalpObW+sumFMTDQs0FnXrJJ1nPEZowVnfYRFivR9OvxGDHzNY55Copbaxnylhyd2/EeOzsrNXdYNgojRqWY0djQ3eh95OTomLvv3OX2nbd5+OgYs8ZzN3d59aMvcGn/gE5jf3dOwTk7P2M9Ljg5XVDKnFs3bnJ45SqHh5cZ5nOqzVier6n7Rt8s2Z0fcDDfYW82Y+iFtl6ys38ZKzPOzx+zWW04fvKI5eKMjHBZnpyyWK2YzWccXj5k3OwwzPeotXD//nucnR7T+pLZfI/9/UNKLWxWC7wMPHn0Lgf7e5wvzqibzqWrL9LaGa//7N+nWOfGreeY1Uu4Q/EItyKzivsB92jpEmHiFH5BjhWerqtPgblHOzIDtQgOCwwFeqO7U2oE70al52jW7mW7LxTAfYww0TN8z3PRW8d6jKRtrHEvWBkw65Ti+Bgt3YZvm4NTkBlBnNO8U6dg0wu9b4AIKMc+UrzQc/fmOI5sVivaehVvQBh2+MT3/xp+y7/1+9nbv8Q/+Puv8Df+l9vMhh1uPP8yL734SU7Oj7hy7TnqbAebj9uA/uksL781DE7psF6vODs/Zhw3MTKZGCdtdHru5oyItVDM4nWV52RqgeJxvouXzO6zQWmdVrJd7T1bzQOYMRJTOa1lu9ud4gPd19FCtWht9uYU26HbJt6Y0ZzGGnoEoYaCym/RjwMLsjlpZleIn/v+a6JtSf7da8Cvzz9PH/+Br/rzV/tbREj5y/naoPInvs7n38lfv15b8Xb++vLTHzSzA+KNvr8N+BQxgvbpm+Eb7Zz8et//7fz12jf4mi393Cwiv5h8J/zcrKBSRETkwrvf4OP38tcrxA9FBtwiRrx+M658E4//TQWVIiIi8gtHHWbYcBF62XbPY44n7R77G32k+2YbPEzjJruN29YTxSLMxCM8zN2OvedqrwzonM64Hrn/4Jij4yMWiyV7BwdABI9gdB+zzbhdfYkZVGa4tZzR6Nu9gU6nTCNRmfZMkmM9neLQveGtx/jHHNlqGZ7EnskcGpqjPGO9ZYlGFgYdSok2V6nTSNmSn9+3zbcYLRpjJuMhpjDGKSXPneX3nGZm5jMtpeaewRp7B3NfZu+b3EtZsj2X42AhAk2Msa9pbWS9WPPg0bvc/vKb/JOf/Snu3HmTcey0tXN3s2TOIz71XXNeevEjWJ3R+oa9+ZydvR2KdXZ3dzg8vMbOfJfVekWU+AzKjN2dXZobj58csVhvKE/uM5vtsn94iXp0/P+z926xtmbpedbzjfEf5mkd99q7dp26qrrd7o7tGJPYjiCBmBCEQEFGKFIuEBAkJHMQN0ggkBBE5AYUkZtccEXiCyCKxEEoISiKEgVkLAE+gO22u9t9qNpV+1B7r9M8/4cxxsfFN+Za1U21MbYros14uktr15pzzTUP/7+6137m+76kMDBbLJgfH/Pg0WNiTOy7HdvVmv3RhrHvWd0s6bqOyjvb0Lxds+1WHJ+ccHZxzu3NLdvtFhkDbdOAei4u3iTGgSofEA+Opvh2Qh+WvHj2FdK44vzhu7SzU5PRaH5dnSVmXUTz1qMckqz5OnYsWBpXCHacqoJLd6/lIavLIRkolnbVvHEpKYctyYlBsdtGLXnr7lKyeYsURaOak3MuC+ss1dXeOBBjwHlHkgpR5TuzoCas5VCPiuSUZX7TAZ6oQ65pjcQwEtJg4g7BuQlvvftlzi5eA+BLP/KT/NzZBXG3ZzI5pp1MGdJA3U7xbkpVBaIO6C7lauP7gLI7nJ9ACpH9fs8wjoSUqCW/FgcxLOBcRYy5ojW/odJR5S1LRYkQcyVvftOBiCPcbUs6vLefMimHKH3lLfUqNTFlqRoPb0wQvHMmI/1otbve5S1Yh4sBdfaGiBQ/bYaw8P+Eqg4i8nPAnxSRh1hK0gN/R1V/Q0SeY6LyP8sflXsxefg99Pn3uPnD508/5bLlp3wu/DYuqw+fEJE635efBH4NS06+AsZ8lf+Q+63N7+b2t/ge/nt8TaFQKBS+TymislAoFAqFe177Hp9/nD8uuf+l7JdV9bf7TszD17wGfOW3uP1CoVAoFAq/nziItVyFKAjiK1KwOlZfNVQ6gdATUpaUci/WDtLlkERy+HyRSaKoY75dl2tLNe8DCtc3a26WG3Zdx0kcqcVb2iwFq3XVg6SUXOt62LWLlk0UQZPdF0XvKmCB+11LsS7XpNFqZxXy0KUV2Gq0ZKPcx2dCCrhD4ivLy0PvpYiY6FLbglSx2/A2sJl3C6uDdsRL3sLLdbWHhN6hrvXwfN0J1/w6JL1/ThVyPSVoMgnrxP6qJMWROCbCsCHGkaHrWN7e8uGTb/D06RM+fvWC5bpj6BMxQB+Ub3ywIoYRJyNvvvUuJ2en1L5hSAGNI6IeSQ4nDYtFi6sE7yvEOSbTOeIczaSl9p4EjKPy/MOnXF9dIl6oxDObTnn0+DWaZkIcO1abNdvVms3ymtV6iXMN+/2e7XaNqnJ28QhfCV6Ex48vwF3w8sXHgDCbLej6Pbv1wNXVK4b9wO3NNZPJgoeP32AxbXn+dMvVq495450f4vTBm4iv7iWYE1S9yTJNVkkqHtUxHweH5zm/xuqQLK5UDpuR2T3fZ5CtilQ/kcw8pPpw93uHSk4/WurVJvbswE5iglnVgUZStCO79o0NNCqklBAsZYkK6g7pZ0tu3tUmY6LUamATKSVLWcaRkCIxjsTRkqAqDkk12+slKUac9/T7HbEb8K7Bi4l30ZxIlgrxLT4mnB/vqlkFCwG7iFUii5JSouv2jMOAxMPxClFHNJpk5XDu5gpYO9ZzTXI+qUy9urwVaz+XrPw4p16dJVStstXkf8IRSXipiYyozVPPEwAAIABJREFUJLxzpORI0lvCO/+MI4GTisiY90bzzwxX3NLvgr8L/BOYiPyHgQ74Xz5x2T+VNyT/EeArqvoyX3b4PfR7/b75+ndd7/ean8Yk5c+q6r/8yQtE5HV++2/8LRQKhcLvc4qoLBQKhULhnj8kIkefUv/6U/njL6vqRkS+AvywiJyr6vVv43Z/CfjngD/Od9XuiMjngbd/l/e7UCgUCoXC/xdRsQpVV5FigDoLApfF4l2PpeClYiTmVFmWLYyMaUvtZrmqMZrg8CZUTGgcZI7pBnKKcb3seXW1ZLPZE0KgqipMJaScbnPZ9pCF6KEk8r4u8tCzKepIIrYjKIqkRMz31e5uypLSvsqpu6+iTFneuEO9JnYfxISkitVW2nYhuSbUUo2emiTRqj81p9o05MjZ4Tm060MEtYSe5OcvMubUH1k+prx5aIlKyPt+h38cqAQ0CWHo6YeeOPYMw8Dy9prl9Utub68Yho6T0wXdV/fsNwMpmh+2XUB4eRt4fbkB3udR/4DTs0eoClVTEfD0Y8RVA/PZjMXREW1dM/Y9KQzgHbubPSEmuiHQDwPXy1ua2YSjxQIRJQ4jT58+4fLFC5588ARXtywWR1S5OhU6XO2ZHZ/kqmHHbDbHOWHfr1lev2CxOOfk9AEffPNbpAST5ojHb0zp+oHl6hI3bUjO8fTph3RdT1PPef7iOV/88o/z5rtfom4n+djRLKLztqGz9J5z9nyr+pyETDlRLCge53LVr7ufaRexo++wuXg34e7sdTfplpOCKuA8qgOaLCloO5OHM8rSlSkNeCqUgDjJ9yNvT8ZA5RwxC8OYIrWv8hlhqUM7rDVLcxN/kIgpmJRNkTRGQhyy+AQ08uzbv8lHX/sWs+Njfv0Xfp5uvWQ6WzD2PeMY6Lodfd+RxFFVM2IMCJbSdDYFaanF/Cxo9pDjMJBCsCS1KFI5vDaENN6J+DzziSYhiUNjsFcnvxfBZGqW9oAQ8+vh8psdPOI8IhCivanB0poQo6WxLZAZs0y25LMXJTnIFjW/p8IeiJfaBG/hd8rfyR//ceAfAn5eVbtPXPbPA/8aMP/EdQF+OX/8qe9xu/9Y/vhLv2f39Dv5gfzxv/2Uy/74Z/Q9C4VCofB9SBGVhUKhUCjccwL8B8C/ffiEiPw49ovfEvjv8qf/IvCfA39ZRP6sqn5HLY2InAHvqerhF77/Enu36L8pIn9FVd/P13PAX+Dub2EKhUKhUCj8vkKzBFSrej3UiVrtqstCLctCtSXG79hxy7Iv6oDXGhGHOJ/rXiVvMTpiHPByL1hUE90+cXW9YrVe0ncPmEwaSxg6kxRRYk4h2v6kctiGzDJBNVdfcsi4EbTP4u/+ft+luBCSjiY+soSSQ5UnYonMQ2WssxrapMFEVcrfXxKSPOrM0ITU583J/PwdUqaaLPx5l4y0JKqJE8Udkpm4LJZscxBVNJL3OgFNOFXL6jlLoA1dx7DvGcaeqBFJkZvra168eEIKA5PJhGZasd/2AERVnIchgvcwBuXtz13w7HnPW2+dIVWLaqJqGwRl7Hdcb9ecnJ7hKwfB8WJzRRgjlfcsHpwxnU85O3lA5WvEeWKM9PuOvhuJ4551WnH14mOePX/CR68+Zr0ZODs6Zjqrmc9b2ko4PjphNp+gVc1+vWXsdoxRaZuaB2dvMD9acH11yzd+81tUTct7n3+H2XTO8ck5ZxcXpKGnrVvioCTd0fVbrm+/xvX1NX/i6JSL194CJ3dykYOkxF5XESv1TRrvxLi4e6GrKWXRmJO6LprUdjXg0KT5DBGrd82VyCYCJacbbV/xkLo04Rzu3gBwqGwFE6dKJIUI3sQkamlE5xzqIpWvs8gUnLP9xqDx7qZNtNkma4wJjfmjOFKMaBxJRFIauXzxhJ/7m/8NdT3hxfNfIY4dIU3Y7lds1ks2q1u67cbkvbN0IyK2AZrse7tK8AG8A++EmBJh7BiDVazWbUM7nRJDYhNXjOOId3m/VU3m6qFCN79BwanPIjifOXLYd83PcZXLb1VM8Dp700GKIZ/Lmp/TQwVvTn+rknI1rjjBqdimrCii3t5kUSYqfzf8Evb76E9jEyT/1ScuO7wR9t/7rn8HS11+DfhjIvKnVfW/PlwgIn8aS2B+Hfi5z+h+v58//hTw1z/xvT8P/Cef0fcsFAqFwvchRVQWCoVCoXDP/wz8KyLyR7Bf6l4H/gwmEn9GVVcAqvqXReQPA/868E0R+VvAE+AceA/4R4G/Avyr+frvi8i/C/ynwC+LyF/DftH8J7E9kF8BfvTv26MsFAqFQqHw9wXJdaPOVZb0UxNoThyuqvDVBBk6kwKuggiIQ9SjkrD0Y7RNSQ5rizZiJzhiGqnwOUlpl7oEzk0I456ryy23yzX7ruco3Ve1qssVnHrYoXRZ/IHHkVIAKqJGE0qaJQq5fjXBYesSDSZ2RPCuJqI5oUa+t45EMJml6ROWUPB54w4VNFl9q7oAatL1Pi2qtiOJ7X2KV9vPU0WIJkvkkzlQl/fwrMJSxNvO4V2CNd3te5o8VlKM7Pdb+v2OMA503Z7dds12u0JJnJ4c2/U00XcdOzZMGse08fiJsNlHvBM6jUiMPHp4yocfLvmBz0/Z6J6FJo7PTjk+Pcc3Lfvtjpuba6p6ixCovLdNyzGxurxh2PfUTUMYA2EIdLs9YxoY+45dt2e53DCbn/H6GzWfqyd03cDq9pqnzy85OZlStVPqdsDJyDB27HaBpp2xHjbsdhUvnz9ltdszPz3hg/efUTUzvvRDZ4QUCN0ATri+fIFzwsnilCGMTGfHJODJ+7/O/PiI6ezI5KQcZHbeohS5e+3U2fOrmhCp72qQEW8S/CCzcHa8KFY76tVahHOCEXHgUhb67k5KmgwNd3r/IDAFq0s9JD1tAzZvWCZIYkdWQm0zk0RM0c5NEROTh2pilTvh6n2Fqf1ACgMaIymOCFnEaSLqnr6/4fL5V1Hn2G8+JsY9cWxZXl3yfPo+q/UVy8tXEH2WhYcksT0nDpBKiQg+3ackxxDv0pTT2Zz54phxDOy6LSGNiNYmOJ2dv3dxSLztaebNUDQhzv7syIljAefq/DWJ5NTS0Xlb0uqiLQltOrOyZLL4/FrYeW0bnopzFelQY5tT0oXfGaoaReTvYaISPpGaVNUPROSbwBew/xX5nz5xmYrIvwT8beCvich/D3wV+BLwzwJr4F9U1c8q7vrXgW8A/5aI/EEs4fk54E8B/0P+c6FQKBQKRVQWCoVCofAJvo3Jxf84f2yxd6/+R6r6tz55RVX9N0Tkf8zX+5OYcLzGhOVfAP6L77r+XxSR51ha889ivxT+LeDf4TvfEVsoFAqFQuH3CSIO7xs0JTRFpLINOBGPr1pSFfFVa6mu6E2oqSUb0YiKkHSwXTwNOOy2DlJS5F4imAfMXZGiuFRxfbXh9nbNftcRY6SpPVEPW5dCSgnFEmQpARosBZUOgskqOw/JrEP/pB7+PRdHJgKabEfS4ew21C4RHJoEdQnF50SWuxNIVo+rqDtUdQqOaNuA2YEkYn5eEuogxSxYSbkq0+X0nGY5pbka1jYySSHP85m4SknvamhjisQw0HcD6801aQysbq64unoOJCaTOc3k8LyD946mrZlOWo6Ojzk5nbLfDxxXMJ+1VHWDr5U/+kd/jK9+7Tf5+PKK40VNN7SklKirmqNTT+Xg5PTU0phdj4hSNzUiQjubE2KEGPFNzWy6YHo8Z7+5ZbdRuv0OjcrxyQnvffkPEPY9XT+wWq9YrW/ouz2r1YbTowtwShf2+KoF56n9nPX2ErShbWbM5wlXJX7jqx8w9IEvfvEd2okz+e1h6Ae6/mO2uw2JmrqeM46/wtn5Y95+58tMFhPbVTxoDuEuzXpIEIs6U1R6qIlVvHiSpruaV9GD5rJdSSXl4wkEjx32OZJ5V3Hqcro4H6fk/dEc+M3Bv7vblXzeJA15c1UsqSuelBxOI8klVDxO7vdZUwooJv/aZooLib7v6cYRzelGSzAqIoGUAnHc0+1uEF8xDGs0DQz7NZcfPyGGxGp9yer6I6um9Ud2oOcaXeXuFKcSpfJCZYcDqiYqfeWZTOZM2gniBkSEEAPihZbGnj9RnK9ISawaNx6eAztzXcLOhaoiiuLE2ZsT1GQjhCx+ySlWJSX7R5OlKTUlVKP9aBC7UY3xrh4WuU+3Hl6rwu+Yv4OJyhXwC59y2ReAX1TV79ibVNX/VUR+Avj3sd9b/xngEvirwJ9X1a99VndYVbci8iew369/Cktwfgv481hL0Z/5rL53oVAoFL6/KKKyUCgUCv+/J1exfrKM6Ke/x1W/++v+BvA3/l98n7+K/UL43fzUb/c2CoVCoVAofP9gqUjNFZkmX6xyMou6FHHiLYmYBqs4xdsXZ8uiWJVm0hFccydbTNJprlQ8JBP1rmZTRdlvApdXt6xWW8YhUFU1It4Eg8S89aekeBB7mqVSQqNJQEl2i3LYoUwRxGepGPNdtT27FCNJTOglNRGEBlR8rnpNuCyXkiS8WpWtJEvSqcubhepQTA5ptBpMC9EpGtNd6s4eL0SsxjYhOFGEgOZaUrLITSJZADm7TykQk6Ip0nc9m80t/W7DyxfPePnifcR7pm1LO2lo6jl1W9PUc+I4sN6s2C7X9Ps9F+cnPHt5RRhtw/Mf/JEvEsPAw4fnnJz+OB98+CGrq5dstzv6bs+rV885PnuIz7J4cbygaWpm0wmTo5r50YJ20lI1dd5FjIR+JIWKUC0QDTSTOW997oTTh6fUVcP6dknlhWl9xrSu2HU9EGnnE0RnPLqYg3csb67Z7fdMpxes10tUR0Qq3nvvc7x4teL9p89xVeDLX/oSXiKVrxhlZN8vCSkyhJ7V6oqr65ccHT/k9bfeQ5nhqFEZ78VfTskmkr2WIjglV4/mXGOydKoTASdo3hCNyp0k/MSRDoAXSzYmsXNH9SDSTN5pTlomEj6njm1pwWXRnrJMzJKcXI2qHpJ9ne1mCpHDQKUJVwUq31LXU8QFfFUzhsA49IRxtDcKIGj0JDeS0p4xbNERQtgRU0caA6+ef5PN+pbN5prt6mN7HN52N8P9ZC1yCJHWlpI+6L4YbKO1qWdMpguqpmGMVqEckyIaqH2D8xXORUs/ukQIh91b+3nipbJKWHGWekwQs2S2c9BEckqJGCwlbbuUanLy8Of888bhUYlUrkH9aOI2jjip7HV3CdXyV5C/G1T1LwF/6Xtc9jPAz/wWX/s14F/4bX6fPwf8ue9x2c8CP/s9Lvt7fOfv1IfPf4hNqXwan3b93+r7v/9pX1MoFAqF73/K/0soFAqFQqFQKBQKhULhs0DlLjFmyaP7BJkKuKpGRo+mLE2s+NFEYy4xVYa8y4iJQW9ffNiyFDHZEtWEnJfKdh0RQr/nxaslt6sV3TDQTGq8ZGmaEvFwXxyW2rQ+1Zy+stRhJOGSzx7U6lQ1Wc2jU7UqTpcsHWe5s7tHouJQtbssWBouX4LH5GWMnVVfOk+V9/OSRAtiqZrsVUXU0puHWk4rxbT7nwCXtwSj5DrRpFYlK3L3HB3KPlNSYhhJqozDjuXtFevlFS+fP2G/WyEu0k5q2ukEL444jIQsNFOM9MPAGCL9sMHVcHo2Jw4ji9mEiwfnnD88I8bE0fGCH/j859k+vmCzWRPHjv1uRUqKn0JTT4jq6Edhs11yeXXDYjGnQmhmM2bHp6QQ2W7XpJRoJg0xJI6Pj2jaFk2J3e0NbV3RthNub5ecnMy4eO2cMURCgMuXLzl7sGA2nbJeLQlp4PLVjqppuL19hfdWz3tx1vL4tbdp/IwxJI7Pz6jbHcM40FYLNO44Pl5wdb3i6vKaX//K/8477/0wX/7Rn6BqGiRXuapqDrpmsX04XpzPu5SmtVRsH/Gwl3jYHr0/BwA51BSDeLlLXSIJkiMAGpWkep/y1ZRfb7XjD81nk6UKRbxtod5FLa2WNqE4HC45kiNbO+4FvYCrGnxdI97n9GGgHzrGYYB8TGree40aiLE3CZsCiBBjz+r2Y/p9x25/TRw3qFRIksMZYi4VcBXgrfbVHY7pvBmLEyazOVXl8F5yZavVIo8hUFeJiXcEDfmxWbrSplwFlw5P6kGAOpJY0lk15dBqIum9oFQghGCVuMpdjbOm+0JlW5BNds46LDUblRADKg7yRm2hUCgUCoXCd1NEZaFQKBQKhUKhUCgUCp8BzldwWOtzgq+haSANFZqU6MT2+bzHpYpKGqJUBJUsKyOHZUrbsTOBcPiz81UWcNZ16fAm48TqUjUpV6/W3Nyu2W33HC0WqIOYxhzZsiSmiNW6OrEkXDzUrKpJI0RsmxITQCENedmOnMK8U5EgJo5QxYlVuqb8tSBIHiZMedNPpM5VsJCiyUQvyZKfku56MK1+MlqtrMhdBa5gsstSlYdqT7lLjTpyDWiWViaMAiEM9H3PdnvL9atnPP/om/T9BudMroZ+pNc93b5n0g74xlFVDaLCZrNiTAOzyYz9fs/F6Rm79ZLjRQMp8vi1N/mN//MX+eE/+ENMFxN22zUXD85J4tltt6xvb6iokQTttOLho4eIaxnGnpvLS27Xa2Sz4Swoqkq33ZHiQN00zOczduuO/QqcT8TRakBD3i8c9j2r5YpExFc1737hLU6OT7i5uWU6nZA4IemKzeqWqsrPSUrU4tAU2XTX9PuRSeu5eHBGCoGnT18wDiO77QsS0DQ1u90t/9vP/20ev/Uej15/C5HKHLrmeJ4mSIpm02iVv2Spnkyscdiz5K5KWPJWIlkwozHvJ6Ys6BWXBLzggidqMLmdIqoR56q8S2rf12HVwvm0QNX2UnNRrAlGH+xIlto+xmj7i1nEI+Bdja8c3ltqs6paAELo6cYuezt3l6JWVaL2eG1RelLsUE30w4qUHGHscmCzRlyNkwbxOUWJnZquFiQqrgJvpyGqSt1OaSZT6rrG+drSk75CRBhjJMaAyiG9DJIS4hyVc8Rkx4WIy9W7ieRSbmgVFMcYrbY5qanH/OrlNx9oPsfz8ycui2PBuwbVjso3oJGgI2LZYQBi+KxmEAuFQqFQKHy/U0RloVAoFAqFQqFQKBQKnwWqiBOqpuHs0ZQ3XztCU8X1deDmJuR0F5ATT6b6HIdskgnKhspXTOZTNEAKVrWaY4V4akLq8c4ki1XK5pSTVqyXA1dXS9abPeenAZlgEgaySCKnN3NNJ9ztXIo6XJY9KR2ykDk1Kd+VFkVtAzKZ7LQ0pdztBSL+oDry6F3ekMzbgYJDneYsnd49BhVFYkKcyRHBWRjMVdzNZuZ0qeph61AQl9CU60dFUIZcKero91vG0LNfrbi6/JDLFx8SY08MI11IiBOSQEhKXTXsUyKuFVdVnD84ZzZrmKw8bzx+nX2/YzppWC4rTo7n3C5vuLm6op60fPCtD3j7nbd557336MdICMp8MXJy+oDJtMFjFbpN09D1O8YhMDs6YbY4I4aBNAbGcSDpQEyO7e01v/p//AKiHYvFMW17TDObcXR0RtO2OCc0izmzumY6mXBydgbiuHpxxdXlNc7XvPb4DO88u+0txBrvPEMaUGDStkymLZWbIuq4ubzh+uo5682a1WpFVQlVO+Xo5Ijtds+z51/n61/5RS4evUHdVPb8i5m9FEGc5oSjJxEQzbpaDs2NWUCTcg3soao1j5yqINT5mLOvq7QmOUVIRHcv4w7JwIP0dHiqfH4pyY4jdZYSzrFFq0i2Y9tSnono8zFMglxHi0JVO6tEFYc4xXnBuYphDPTdwBgGRAWXKpwXBNtpHNOemEZEop0jYU/QhjF0WbaPJB9IhCxn9a7XUhWc94iLOJdTpc7RtlOadoKv7Jx3OKqqsvrXGAlhJMbBapWd4KhATcZ6b+d4IuU3CNgxGFO8/7lz90PA9mgRS0o6Byl52w6V/LMj5RPcOUiKcy0xJbyzet4kJnAFR/JFVBYKhUKhUPh0iqgsFAqFQqFQKBQKhULhM8A54fjRgrffOeKL711wNG/Y3CaSblneDLne9F7a2H8tJQhYKtEJ8/mMBxcznHNcvuxIPXe7lzHm2skUrcZSbPcRTJz0+8jl9ZLNdsM4BuqJB7VqVdWUNwXdnWg0r5dTUlkYxsMeZszVmk6IOub2yCw3iTg8pJwq05zEsl5W0ITDkZzmncD8vZxauFMSzps00XTYKVQTj3KnYPPtQgp657PsGUyIq3IFpyXRUq6NdVJBrqUcx45+6Nkur3jx0TdZrV6x2y7Z7XYMwwCq1HVL5Sq8r1mubxiz9Hnjjfdo6wb1iYuLMzyJyb6mrSseHD/g8RuP+c2vf4WPP37BfDJlu17z/rc+4I23Ayfn54yhp/U1VTuFkFCNRE1ESUwmc2bziul8zuryktW6px8Gjk6OiDqj2w9s+yUnjx7Q1DUuOqaTOVJ5xDnGMUGKnE5aJu2MlBK79Y7NdkvSyPnFQ7p+Q4y26onCZnl5l9DTqmbsRprJlBQHXrz4gN1ug8Pz6OIx692eMQ04TVTeowS2my2//Et/ly//yE/w+K3P3Qku04gjIh5x9sxLclnE2XFtftLqilXUamCTWnLXe0v6WcwPn5O+4rAXnMShSTQ5EOctzZsszWupR9tQPBzHJqtTTkna54QGIaHRkr9IQqJDD+dfThqK91R1i/dNTtwmvPNUVYOidMOevh9Q9STJx7kmnCqS1KpUYyShBAYcO8K4R9X2J5MGS32m7PCxoKJ3ioqlKV2yh1JXNfPFiW1l5o3NmELe1nTEmOj7nulkajXPLidLpSKmZPLycE6lnJq+GwPN8VFNJhb1oIjtDQDK4fUTEJ+FsBJyZa/mJKmlU7HzzuU3YKji3CFbWSgUCoVCofCdFFFZKBQKhUKhUCgUCoXCZ8CXfuwh775zxHvvXHA093Tbng/2K/bbgFDhXI33DYJt3jnn79JmebEOEc/xyYw33jhmOmlQbnn5dGOuKe8umhBy+BaqyhOGgBttnzGMI1dXa1bLJftuw2zRWroMsY05yEWYJgmdOBKK5hpWNGZphDkMhRhNjKjcSy9b6AuWtszJNVGreRW168acquNORrq73U3BIUlNBB2SXSKkFHBUqMRDuWzeHbQ0nunLnNQ61IfiD59B8m2IOMYwMPQd15fP+fBbX2G9uqTfbRhCwFU1MQ5475Aqse+23HRXdP2Otp3w4OJNjo8W1LVnMT+nEqXfrjk+nlPXDX3X0zQTHj1+i5ura+bzBbP5nPX6hidPnjB98ZKj01NCHIkRxrEjhj3OKcfH5xyfntM2LbsYaWdTzqcV4hxNPSWFEUX4/Bc+TxgH1usNN9eXDP3IfHGE9xVjP5JSz2azYb/bWorNWR2ob1pUI33XcXl5iUpicXzGerWk7zrEB1Ia2O7WDENkvR6ovYCrWCxmXFw84nPvfJ4PP3qfYdiTUqTvR5IKL1484Td/4xe5eO0NmnZKSraLWLmKlEZw/k68q8acIrRjV8082u5oTvipKElDPgME57KNBrttsvhKKV/Djog8nJgTiYd9V0VTsn9zilOX5VoFzkSxiLfbEIWoJK8I0apRD5Wp4vHO411OWgKIo64bvK+y29OcTiQLV+6EXqIGaXCJfI6DyACMBIU6DqQ4mOJ14AVLQnp7dBXga/DiOHtwwdHxKXVVEe+eD7v/dW3idIyJYYxM6sbuq3P2JoI70ZvPC+fzxudoz1k+V5PGnHZ2uVY34UTBNTl5KaQYTW46Z2nUoDm9zH3Vrqid42KytvZFVBYKhUKhUPh0iqgsFAqFQqFQKBQKhULhM+BP/dM/ytnJgpOjKfv9im/cPOGjp7fcXgckWqrJ+/qu7tLES2WyD49KRLM4OD1tOTuZ4bzQ7wOrmx4Nphld7Tg+b3nwcIILNbe3Hctlz7jvQSuWN3tWmx37rieEkIXGISmlVmepijqHRktZifMmlVSwqcyUE2nkJKXm9KKJG83ClGSyJWU56clbk/bdzPM4jyokiTi1ykjEEqiih2RW9iBSoXJIwVnaU/J0prWD2v1ABdRSeya68tfmBF3SSBgHXjx7n2dPvsZuf8047OjGzhKIGkzKJiEMkTH09KGjbhuOFiecHJ9QV1bpGYaR+eKEt1v7K5UUlc1+y2a7YtK01FXN6vaGqqpoJzNiDNxubunGjr7v6PYdk3bBZN5QeSGNdptehNT3dMMOVWU6P4ZWiDHiRUnOEcJAUwsXFw9JGvHi2G8HkgghAuJx3tH3I8M4gFO83yFOGMeeswfnoJ6mWrFdbeiGK/oxMWmmzOc1zq9Zr3qayRFVU3N8doS6iuP5KWfnO54/eZ/edbhqwtHpgrHr+NpXf4k/8CM/yWtvvmP1qCllSYqlJxWLBSYhScpVwTntl4LViuJAo72w6sApqsGmLl1l6lkEJwdZbceu5qSuSryrBkbVjrksRcHl9GA+ViUnCdWhKVh6N7lcheruxPuhitb7BhFPVIFoj8eLo/INTTOlqhoTsuIRTaizTct6csRkesxmrcRwQ5IB5z1Ne4p4zzDu0BhJcSTlNx1UooRDitLbJqWvwfUwm0948+13mS+OQZR495gUJ4L3VnU7xoExBCaAE0+SQy2yu3/85HPYgSRnU5PqiBpx4uytAE7QFPA4YspRT82Vsc72clWj/SxxVf6ZpjkhqyiV/UwTQcNIjsQWCoVCoVAo/N8oorJQKBQKhUKhUCgUCoXPgD/0D/wwzkEYe25urnj69IYPPtgxdD5v5gmkhMuVpYcSUxFvO4+qaAr0faBpKx5cHLE4ahnGwFe/cst+E6kX8Pa7x7zz1ilHs5r1coQPEsvbrbU5hshyueXFyytWyzUPzs/x3hKYLktEFcniQiwEhuRdPYBwJwVFD5uCtnGHRsi7jwKkFPHirfJVlMrd/5XDfYnkYYdQLeUleVNSLJOp6oFDwu6QxDOJ49SRNObkV+IgoFy+viYF8XkPM6f21B50Rx7OAAAgAElEQVRbGAMvXzzj2Ye/SRx2ECN1M2HuayQJfb9jGLd2/VTR9z1JBk5OHlDVFSHsWK88spjT7QO1b5hOJ+w2G1KISIqMfc96tWSzvGa1vuHh40dM2hnTds6227LdbWjbluPTI3uuPIjUBGC9XbLdRGbzOW01wfuKGBK7sCNqoHImfMahZzqdooMSYmS1XdJ1HX3fo+pIOqIx0C5meO/oxp7dvkNiYjI/gpTY73esb1f0Q0BSpB87Pn5xy36nTCaV7SLuE5vLLeLOeO/dM3abFaKK9w2r9ZrF8Yw4Jvp+4OMXT/jGN36VR6+/fXdcJVHEVbiUCLmaNDnNFbDgONQIO5LaKyg58Yik+1pirB41Wn8q3nkOnb+HZO3ImJN8JsrQLBxF0TgC/i41fKgRNtftrEo4J4DxiRSTJR5zwliS3CV5U8w1slnk+8rTNg3tZE5d1agTnFgStp4c884X/ggnJ495efU13v/aDd3+lsXiMQ9e/0H23YYxbdjcPCfqBg1DrkTOwcf8ULw4fJWoWzg5O+Xdd36Q09Nzqtp/4vh2OF9RVTXOCWMfGcaelI6pKzvXkipJTGha0NlehxQDztVICp8Qic5qc3MaNWFbuylaAtXSo3aWqnK3VZv7pO1zdwlxJcaU392gvzc/WAuFQqFQKPy+o4jKQqFQKBQKhUKhUCgUPgPOTk/p+i3r1YqXL2745jdvub0dqaS++zt7EY/L6SWi4qXG4YmoJZEI9P1ASEI7n3B+cUpyjjEKt6uON9484gvvnHN6OiP0kaG/ZL8fSSlLKyL9LnJ9uWJ5u6bvB9rJBElCkICkw0adpacStqfn1JGIJv40j+flOKVqsnSWWnpRJVLh8c5hmkWonScd6mvzR58lpSZLvCX1tncoCSXmZCe5upP7FKUzLRXVEp2kaHEzIiJC1Gjf5/C5w56eWSlSjLx88SHvf/PX2CxfAIHJZIrgGIeRYdix3S7puj0aE8MQUPFcPHzMtJ1DSsR+RJrI8vaGduLZdEt2bctuvWToA03b0A09tzdXXF4+ZRw66tozm26Ji1Mm0wUpKGFQosD5xQPapsIqdx3deo2TESeO0EQmszkinjEkut2Gtp7QThqc99ze3NLvB9Qpk8mU47ZhHAPDMNINHZv1wEQbIoH1ak0aA9Ppgs16QwrCarNhud5wc3PL7bJjterxlWeIkbhX/KTl8tmeMYxUk1fE+APM5gteXl3SzBdcf3jJtr9hMauJY+Lq+pJnH32bm8tLzh8+sC3KvIEac6WrHWKORMqasEJTzIlee53ES07pRoSEU287iRaStORjtMBl0mivsPN4TUSNaK6A1bxHSopZaeYEp0ST2VgFq+aaYe9sJ9KpN6Gq6b4ltXJ4V+HqBueyyFcBEaqqwVetpUhd9nQ4KhbM2gc8fPCDLNoTnHe8+PAXCEPHg9e+wKOHX6AbtizXT9isX0JMVllrwU405lPNudyuKjQVvPHmu7z+xuc4Pj5mOpnbo0wxp0wFl3czt7plHEZiiNA0iCRLWyZyvXNtrxHgnJ3P6hyS7DyzBxPtvDq8QQETwOQN2KQJEclVuw7VYPdXHIgnRqvv1WR1vMnVHNZ4C4VCoVAoFL6bIioLhUKhUCgUCoVCoVD4DFBRQohsVns+enrDR092pFQhlUMlWe2pP4w/mmiQ5HBSI1pZwhBlHBP7/YDzFacXJ1RtxXQ+YRwTJ8czzs8WCMrzp5dcXnVcvTLhJmLyLsSRVy+33G627Pc980VAK2+yNEskxKQPGpFc0yl59y9fjDpnqbZcDYkmq6rVnJgUwaH4yufK1ZATdnXeHow4ybuaeMQJ4qyeUlXylmGy50Ocpe2SmSmTV4dq2EOrp97VyjqxbcxDbSxiGU5RZb/b8K2v/yqr5TNEI6fnD6nqmtX1FePQE+NgCdY40I+Bys84Oj5iPpnhK4dT2+gbY0ff7dHYstusWaZISpEUEl2njCGQwo7KD4xpoN+vGIcNSk3bTplPp+y6Lbv9kuU3XtLUNaKB+WxB3bQ57VexOGpJUWhbz9F8wTidMowjiUjT1LTTM8Z9AA+oMJnPs+tzzI+PuLm64cWzFxzPKyazI559+A2ubp6yWq3p+0Ak4qspRydn7Aelv+7Yr0bGQamqRNrsmE4803nNfOa4vHzFG288skM1RibTls22ZxwT4xA5VcfTJ9/m2bNvcfrgzARWTiEehFg+XPCVt9dOc1uvxpwglCy8QPUur4dPcMhAijpwOd5rI4h3m5WC3U5CrTI5H0eHnUWVbDgPaUw1Me+ckNTSvZYWvJebIg4nFb5paeoKXzVAIoWIc5bcreuGpm7sGJbAwaqOfcfq5jnuzLNeXdHvdkDM1bG5eHUE71rEzVHdgmyQvG8pajuV3jkqlNbXvPn2l3hw8ZjpbEbVVKQU0dGqV504vBMqb9uV/djTD3sm00nefXWgo70W3p5DRXC+RmMAIuqSVcXGiFCB2OMMcQT1IPncxN4YgDicb/I2bGVpZ3KFs6tJCUusJkFI98dEoVAoFAqFwndRRGWhUCgUCoVCoVAoFAqfAZoiIQ7sw4bVdkvXB6AipXCfUgLEm5RzWt3JEcjpJyqTbs4EynQyZTadcn5+yjD2tJMJTpVXH1/y4sUtTz7csu96q3VF8DREHbi8uuHqesXtZsXR6ZzWNSBZDarmZBuYLUsm/CRXvDrQZPrG5zpOsykehyWyvIht1jkharB9P9M/5pS8s4RjsrrYSjyJYDuLzt9t5uVCVxNFIVmCTVKuqMyZLLGKULWImFWEJtsGlHy52abIECOvXjxjefMCV8HR6QN81dJtVwxjzzBu6bsdzntc1eBTJKUeX5+gYtuBy+WKo+NjnPdUlbDvdmz6DU1+TM6mMXEE6qpmMplROdseXS5vGPrAMHZcXFzQNBVeZoRpZWIsQnKRfX9DVc0Yxob9foeII4RA33UWag2JGAL14phx2DMOAykpdd2yW0YevPaQ2eKY6fyI8/NHXLz2mOcffcBs6hFf8/TDb+H8hOXqmn4YEKd0wxbvlQcXM5bXIy8vO3Y75eTEc3QKTdXw4OEjYoqsrpfEFOn7NZMGhgG6fcA52G72/Pqv/yo/9hN/jH74Yeq6xokgkquMndp+pGTFKGKvpbNUrn02crhSEkdK5O3JwEEs4g5pR2fPnY44HIEAoogXnFZZwQkpRWJKOOfy+WZHl51bwc6RGO3+Oc3f/34AVUmI9/jK4X1l6d8sU0Hx5tOp6paqqu1rZCSR2Pcv+fa3f5766Yyuu2To18Q0cvnqCaMm+n7L6vYZJI+rW1wFjm0W/uArclKzQpxycvwab771RU7PHtA0DieH9KPeVdlaCtPSz2MY6IfOKlydCWFQxOf0o5jAFVJOuebHnDcvlYhzjqQp337MCe/8c8DneljnkJjsDQeaa2aTvdDOJVISe0OCVmgaP5sftIVCoVAoFL7vKaKyUCgUCoVCoVAoFAqFzwAR8M7TtBVvvHHK59695cn7Vmkp4pCYa09jtLTYoa4Uq1B11EymNW+8ecT5+Zx22uAqx6T1eDclsSAmWN9suL3u+PDJmqsXK1z0qFOcr4gp4WnZrve8fHXNarliuLigrirE21ZmJJlQ1MNUZgSp0HiogUx45wlpuKu+lKwTRRMqjqif2KBUAG87hDgSiktYIksFJz5XyGYZpVYValWSkAg4asRZD6YetjBTAnGkZLWS4vJ9TtG+v6tNXGLVtEkDcRx4+uyb9OOWadUiSRi7Pft+wxg7EKGdLEADTdPSNlNwnsbXeGkIY+DBxWtUvsK7Ct9OWI23LGZz5osFcehzVS50I0yZU/sKvDLsd+x3S/r9iusAKe6Zz0+YTBcQHe10yslr51TO4yvo+g1jN1K3DnUj3XZPVVcsjk6pj2aE0DEMgdvlihAGVJTFbM7s6IynHz3nnfdamtkc+sTrr3+O6XzOt7/+dSZVS9PO2W5WoELbHpNSYNVfs17viUOkahKPHnvG4Khdg6TAbKb0myWh9twMGypfE2OkrirmC0c37KkaQVBC3PDRB9/iD/9kT135rL5MwIPg7xKuOXEnYsLe5TQxLlf8moxMmnJhq79XcdnGSf6PHSOJlCpilm+I5iSw4F1F0mTu/ROJ3YPUQ0FFco2xaUzEFi3tBPY4X+OrFnEe533eS7X0sOQEo68qXFWD86R8N5Pu2G8/ptu3hHGNIxIIbFfP6LoNYxjp+5U9H5LfHCAWOzU/6XAHoV8ppw8+x8XFG8zmc6qqxQngPTHVeAk4wWS7q6h8w3a7o+87QhiZ1I09tvxcg+1UimDfT+xcOdTpeueJCjHG/Jw4nDiTzNFSl5oSrhJLSzq18zclFI/zks9JZ/oz/7yIlI3KQqFQKBQKn04RlYVCoVAoFAqFQqFQKHwGOPE0bcPDBxd88Ysd3W6EeMXL50I/jJY6Sg7naiqfECeE1OOipe2aasIbrx/zxS+e89rFnKYRxmFP28yo6xpwbLZLttstl9dbPnqyJvS5FlOTCQIPTj1hcLx6teL2ZsO+2zOZNjixjUzBEleqasJFaxMRCkltZ05dwktttZXOkpGqERW5S5ghgogjaqTyNYeI413tozpwereDdydoVMElDi5TXGWJSc3XTZjoUKuzVYCUkJw8dXhSlqBWDetJacR5z3675+XTb9M2LcN+R1fPaSct3tV4PJN6wm6/Zre9QRxMp8f2WAj0/ZaT00ccH52hycRNO53SDoGqrjg9PSb2Pd47hq5j4Y4JoyVEm6YlLAIxJJbrS/b7jhSmdPtbdOgRVxHjyHa9pG0nHJ2eUlWCOEfoBI/n9MEZ3leAkEIgjdB1A4ujY/a7LWO/ZbPZUtczzh9e8Pz5Uy6GkfnpAz5+9iF1W3Px2mt8e/lVZrOGbn/Cer1h6Hu6/ZKbyxV9n3BOqLyANwFV1SOahDQmNqtrlIFHFxcmRWcTpBLmzrPvA04T82nLyfkxi+O5CTQFL7nmMycZnTgTY4fUrlgDqeBRjVlSC2jEi+RK4ZiFohDiaKlV8aSD8lJL1ooIVVXnVK6J9ajJxJkzIao535tQ21dUh7oIOY3oDonLJHb7ItRuSlW1eF9R1xXOOWKMWQhaVbP3HhGraPVS4wU0KTEq3iVEk202opAcI1tCr8SYbG9THEqFcy3qslTF0oleanuqFI6PH7BYnDBpF1TeA7k1mhHns8rVgwgUQgiEACEGVFt7zIdKZcQSyHfCMp+L4kmSm1zJz32Wu0mt9jXlFLPKYXEyIq7Cqf0siXkT1jkPMdjtiSBRca78FWShUCgUCoVPp/y/hEKhUCgUCoVCoVAoFD4DhiEQxkTbTnnt4QO6H9gy7BO/xpqnHwaIDqkqqy4VRWO0tBImX+pKmM0qThYtdZsIYce+d7gKqqrGOY/L+3Ti7htPk5pMcL4iKbg8CHh1s+J2tWa/7zk5SRAliz/Ne5EmjVAhpmBJM1EiEac1iJJIOLztAx4EJQkR8lYgoEIKI66q7iRQIuGcbVeKQEwBLz7XyAqS5DDMZ3WdIijhLo2luZrW0mrRgp5qe39J1FJhcTTZJXlfEMfq9hW3tx9zcfGQqm7x3nY4nQr1dIYOa5arPVVVIa5mOj1CNNL3PfiRSVOT4sh2u0eccMI5fR+YTqe0zZSYoGo8TVVR1S2bzRZRJQarBD06vkAlIWpCcnG0QJKwXl0SQk1dt8Q4EFPP+YMLXn/zXXDCq49fsX7/Wzx+6weYzWb4pqJdYEJWIrPFjFVIzCeeECLjMOCc58kH7/Na33Ny8ZCXz56CwoOH54wpMIbI5WXDzc3HjONI3VZ03UBKlnxdLBwbFcZeqCp7XWfzCU0l7Pd7VrfXjH3Cu4rJbEFT3TD2kRgCaRwhjSaZ81Fi9b+WgNRcGip3/2ZSTUn5WMqfs8iuJfgO6cQU8+aoJY9FDrXJ+XPOIUnutiURZ2ne/4u9d+uRJrvS8561dkTkqbKqvkM3+0BR1Aw5mhEk27rzpe79x/yLDMOAgbmyDPkgW6Y0o9GQw2myu7/zV1V5jIi91/LF2pkfKdEGxkZjAGE/DaJPVZWRkREJdj35vm9SwkVqjQqXmliuyWWPBK+b4Sk2PgUQ6UIw1mOPjUdC5AuU678ruNd9R7fYK7VMSgMiCUjgIZ0jtWkh+CVEOBfhKlbvO0AvwUdDVKMWWZxhsaQf+lqfG49vZmARNA6xbxSLfc65jMy5Vr8iIY4lnoPVr73U7rrnKjnjhFtNnV5S05ed0bh3NcTy772KVlPU8UEB1freoLWK1zIkQVugstFoNBqNxv8DTVQ2Go1Go9FoNBqNRqPxA/Dq9WvG00RKgtvM/d2GP/rpcyzD+Vx493qOGlitv/T32JdTEiDMpTBPzuPTI/unWxbDQLfoWCyWmGX6lBiGnuUq8fnnG/7JP/2c/2N6xcc3+6jWLBOx+AgI7HdnPnx8Yrff8TI/Z5kGis84RqIDN8zlKiIRw4qRdMCxawWnilA8dE+p0iK+J8ShaAikSGYphS42A2ttpnvs77kYEDWcfq2ODV8Zm3ryqfaVS/ouJFZ8X0bRSH1K3T6UhFnsFQI8PL7GOHMeT2w3d+T5zNANzDaxXq15PD1xe/c5SqGUwnKxpOSR02nP7e0LvExMo3E+PXI4HsjjEcO4u11yenpCxUjdkr5f4rVCtO/WJJmY5pGbm2d0g9KlHkPpdcmwHFhvtzy8e81isWC5XnN7/zllnjgdjnz+5Zfc3b/kN7/+93z7q7/k9vkLlpstq/UtNzcvSAlMZhbLG3aPj2zv7jmdj6RhhXRLvvnbX3H38JHl9oaPb18BcP/8GfOUud1uedP3vH/3RNd3dH3H/jCz6IGSWXXC4akwzcpnL5cczyO7pwOqD6yWiVyF9TwdmMeJcYbt7cA0j/zmm7/kfN6xWH52leh1LLTuVVYxeBVldbOyymut1whQZV5cFxep5h5CMSRjue454o7qgFsJ8a6O0OO5IFitgHXMSq1/LbWSltjAlLoFScdFOl6FoFxqYiPxWdyINlmrydEOUcIuCqjWWufLha0h/kQHhA4XISm4d1VQOhTHmKNCtV7/KpfnmCK5qfE+gUQaUzCmYszZmOcJM7BiSK12jbSpX0WwSKo/LyRnvdNqitVR6XGM4iXEbdxQ8dp5vtbSxgcBauWye/25V3Uaj+XEhwVq+XOqH5jw0jYqG41Go9Fo/GGaqGw0Go1Go9FoNBqNRuMH4F/+T79g93Rie7NktXIWS5inmfWQ+PzZksePM9MMkiL9Z5JQ7QEQV6Z55NtvP9CpsFhs6boV683tVZzUP3F7t+XzeeZ8GjmPM7+YM4eHkUIkE4WEek8+j7x/98j+cOY8nRmGHkmCWo+aQrpsTlpIFBKqISCuu49SqzFrNatIVLoaFtuAnqLW1CYkdbX21YBUty2j4vaakLxKSa+JzBxSSBVKzWt5iYSl1CcM1R4JJoZqXwVMnBNRIr0mwuOH92gaKGUmW2a7vmE+j/T9knkeWd3c0atgxSllRgVmMW63dySEUmbmaebt2/cMAzw9fE/qVhweVgz3maFbcN4fEJ3JZWQ8jXgSehc8G4rQpyWb22ecjxNWMp57Oun58sc/4/HDt5Cd+XSmHxYc9k9888s9m+0tLz/7MZvbFzy9/8Bxf+L4dCL1A8Oq5/7FM4Z+oOsTH96/ZrlasHt/JAP708g4v+dZgfNpJpcJc2GzuWG93vDZy+c8PuyYzoXUwcvPNpg5x93MzWbg5z+/4esff02i8P2r37Cf96hCqaddNHE47ClmbLdLXn72jI8f3vDmzW94++03vHzxNVbTrqhHdbA7qSYnY7iQ6jAVc0e8hAr3gnhU/xrEBqJo7CdKJPzMqqT0SEFexKLUSlQrGbM5MpwSiWO3CUlReaq17jgSuh1aBbdjcSy1ItWvX0M8nzJjHle0u4BqzVx2tZa2q5uNCRfFJCM+gCSSrMjpUCVf7Vf1VJPIjniKnKd4TSdSE8aCShdJYKgfaLjMdRrUDxBQk5JSn6/UGmaRhKSuVvJK3BZljBRrTWVqSpHOvExzqoLFBxIwj+dS7Hr+IRE7tkr42ksa9nKEgmgXAtTi9Yra1/YryEaj0Wg0Gn+Y9v8SGo1Go9FoNBqNRqPR+AH48//xr/jwfma77dlslfu7xN22J09wPOWrdLukxoRIeYmG1MNgdzjxy1+/AV2xWt/y7PmEmzCOE5YhlxF3Z3uz5MsvnzNNmcPhzH/4xUdOB7umqoREngvvPzzy+PjE+Xxiu9mgFlt75hklRTKxHknUTyYMwKT+HCFSmqXu3UGhikavqrFuC4YUclKVMS6OSlerWSPN5RK7gEqKFKZXAWNSU2VRvYlJSA8MN/u9XT3c4ms8js4uhZRWOBwf6btFnAeb+fDmW6acub17zu39s9hDFGGeJoQF4sI4HfGuI88T4+mRaXbmckTmJWozfbfEy0SfOsgzh+MRQyg2YbNTgL5TrEBxoeTMcrmlzHtS6kGdeZ7xg7NY3JBzpswTgrLcbEidsH96RJIyDBtu759zPB45n47MZ2POGZuNxSrOUSkjh92Z2QXPPYvFltPhicfHHW7w/s1bHoY3bFY3LJcd87Rne7fkyWeKGYvlEqFjc9Px1Rdf8OL5DTerG07nEyLO93zD4XCiZFhuBqa5gEHqOj57eQuS6Trh8PTIL/7Nv+SP/vF/RdcPNdVboF7XIf9KCO2a9DWLa8dNMZ+rvKypvirlqK+p4FwDtiIhLF0+pS3r9RoSvMo081qFnHCfAQlpVn/uRVhatf4h1AT3TJKhlsQKbiVSk/VoIiWq1+SxqlZBCX6pfJUeTQOYUGQfqUXTGJfUDtXYrjQUat1zVK+Ce0hVdMTpQDqUDqnbruafqlnjqErNroKKxocQNCHiYPl3PhRA3dqsCWnRa+2rU1PJJEwNr7WxiJCqzIxq6UihxmsE4Khqfa0lqms9jkdS7aSur3+j0Wg0Go3GH6KJykaj0Wg0Go1Go9FoNH4Avv1uxzzBfj/Ddx6bh0tlMSzJc2KcMiYh/yR1SI1KqXQkWVDkhLlzOo/85jfv+fLLHV9+feLlOPN4LhxOR6az0XfKsOhQUZ7dbfjpP7jn6ePEt99APkfdomgCU3ZPI0+PB86nOSQPXd2EjArHlJQo4Yx0otXlPq/JOC4iEWq9a4g+s5CtJhNKpELdDBNBKEhy1BMmHjWWMQ4Yu3WXKlfzKku9pja5JrVUupoiu0z5aZU1JYSne5w/EdRrZE9AXLCpMGwGxuMjx8MTqNOlxPbmnuVmjYixWi2Zz2eSCillcgYvmYfTgcNx5HSc2OUjX7zYsFgu6dNAL4kixnjaMc4Tqetq5aZQDFR6VLsQti5R2Zsnci5RM+o9Xeo5To/kPLFa3dP1A/1iDSXz8OEjfX9isVxgeaZLMOUTu4cDDwU+++IzVrcrzqeJ8+nEcrUBFXZPJ3Dh8eEjQuHh8QN53jP0wnJ1H02nOOM0cT47fTdzu12wWC3otOO4P7B/fAKUcTyzWi45HGYkKV1KgLFc37C5uWWz3YKN2MbZPz7y3Xd/y/u3r/n8yx/H9irxOguRigyiJrVYqVXAHtfK5TWsctBqNTBorYnVT5WxXiKpWZO0UvcXxepuokfq0UVqIjcBIdekJv9UB5yCSqR5Iz0ZNk9E4ar+MtCFCHer1ag1FCqKSh8p0Ivsq8/TqTLSZ0wMZ0bTCtE+nocoXjJ4qTu1cg0M40TyWBKuCXdFpCYj65wrXuoHEcBFURWSKsvVkpu8ZbFYIJJCokpNkxISVDShVtBU793Lhwm4nJtUn/uME6lXRSmFqwyOr9dPu5USxyv1+KlVsF3XR13tNSraaDQajUaj8fs0UdloNBqNRqPRaDQajcYPwHSq+3eimBpldsoMRxnp0gK77MVpZBhFEp0uMM3M5Ugk0QSnME6Zx6cT+eycjyPn48Svfv2ab3974PZmwd39ku3NAG74LAx9RzcoeQTQWsvacTjMPDweOB5OzDnT913d1PMq/LSKDUXcanrrIkM8KjjrX+MhQMxBLCphRauQEq+bjeAqtZIy0psRkyuoKHbd86MKS436S/MQap5CWtZMnajgJSRWJOtC8IiHbFHi66WKqtXqhsPhEadjHneYw2K5Ic8zqoIkx6aC55FhvUTdWSzvOewf+PDuNYfjjvHsvH2/QxF+8tULFosVN9sbrMx0XccwLNgfnii5p9MFqDLnkcV6oB96BCFJYixHSi4MXUJVGM8n+qGj628ZhoHlasU8jfAE3bpn2o/sPr4jaaIbEn2v5DLSiVFEePfmLT/e/IzFYsPD+/eI9iw3PcUmDk8jy03idHzCJfH+/ZEkI8PwgVyF3WJInMeZV6/2PD6dWa96jvtH7u5fctg9sNvv6Yda3ytG6iBpYrnaoF1PSgOqA09PR552B3a7Ex8+vOfh4R0vPv8RBY++WDxSh6VKbayaNsGMKhULKh3FcxVgBak7i6IpWkYt9h5j8DCuv2rsMLfaBlxCYnpUEheLrVSnVBmp1+vIvNQtU63CM8VjSsYQ1B3zS9Wpxt5kqSloIg06TxPH48jhPDLOAr6iIHTSQa2yjfplxWyGJKis45jcUXFca1NxvBVgdglbX2pvDfP5uidLvVcvtcrCZf+zQ1RZrzbginZ9jYxqVPZKTZ7WjyGIxgcSREHcogZWtaZL4x6tBrPuTYa0FalCVrs4WGI/U6qYjFreONdSty5F5bKW22g0Go1Go/Gf0ERlo9FoNBqNRqPRaDQaPwBeM4mmpe45xt6jSh8Vpm4hVXC0S7jlaxVmyEO9VpnmPHE6zBwPI7unEx8/7PnLf/eKv/6LB0RhvVny7NmSzbaDIjw+nJnPmahiDDmU6MnjifcfHxjHHMLPna7WVspVedhVAF66KN0uKUqiAvKykUnNnXWOWo/bJamp9Vs9hKBUIeQZrcLookwQDenol7096magfwMv3MsAACAASURBVOrmFIlNQo+0V/y8EIBGVFuqXH7FoRgFRdlsblApnA77Og9ouGcW64E873h8v8OsMAwLlss1q80aEed42HM87RhPM0+PM69fn/nq6zXzDKvlhufPX3A+PDIsl7x8+QV5njkdDwyDcj6fGE97Ol0wdCtQSAqDOsfTDusWLBY9Iso4nqJWVzr6u56uW7J/fGCcTwDM5yOPhyeGxZJu0ZPHkbToGU873JzF8obt/TO0W2DFefz4EZWew+mBaUzMZcf+6ZE5G4ez8/Jlx9PHI6cpcdjNLHpYDspkwnk2Xr/b8+HhjHuhWGbthecvnqFasDKjXc+wGDjsjwyrxHn/jqfdgWmayTPs9gfOp1NUrZYwbvGaWu1sra/5RTRSv+YixywkdExZCppSrUYGTQmKUShxbV6vy9i9FCQ2JA1KGat4i+vo8teXewoXNPUIBSQhTq2eTSG+CfkdPzMePwKeHpLTjP3Tnt9+9z2//NWv+e2vf8vD648MduJmvaRTrunkYsZshZITxTLJpyr6Bty0JqkvdcmXMGKp58ZJ2pM01e3JFHdoTWTKJQfpsRurqnTdwJzjuXBJQ6pck9tqFlW2rjWBXCLNqlGj20kcp2iHUijZ65amValZ700ige1+kaR1rdJKvddSbI+6IxT0Wp3baDQajUaj8fs0UdloNBqNRqPRaDQajcYPgEj3OxWVtToVw1OHRKQKNw8Bl2NPUlJCLWpcL9oQD9Gy3505HEYePz7y4e2Od28O5DEEx3w88vjugPZCpz25TDAnEIu0GUZKPbnMPH488rTbk8uElaHu6kXCUWq3pIrWestyFUUekbarZArJGvuXXgCZa6IxtiRVu+oZ/VNVpgmevCYs9boViAuJi/z0Wu8aNbCC1B09CVFTDam7kMmkq1RVXAqKYJ5whPX2NiQTiX4QLGeWwwrMeHz4QJe6+HsH7RKLxRpsokyF6ewcjidcOhYLYbVa4d7TdR2bzS3bzYY8TwzbBQBvvv+GnAtD1zGLM09nhjwiAkPf0esdZKMU43h4ZFhtwD02/cqR1795z832M1LfY2Mm+4Smwnq7QkyZz2dOpx3jh1Osgk5nTJYhhPPIw9OO2Yy+X3I6vuPsiXE6cD6cOR1HjqfM85d3dAvHp4kpGz7Bs7sF29slSTv2hxPH04zlwmKpDH3Hsu8ppsz5hJUR9TWqsYU4TzN5zoh0oIoz8fjxQ1zrKvXa89gTxWtUUHAjBDPgJa5RlYt0uxSQWiQjaz0sVi59qyH31MPnERI7tlRz1MiaRwVvrvefFLz4p6pWdUwyWqtK45KKBOCn3crLtV8/VBD9spTiHI5nvv3+Ff/b//6/8q/+l/+Zd29fofNHXixnvngO8nxGO1BxpmnmdNgxnvaIDvSLGVEj5xL3tgKm1+s+zk1NcnofCccw8dd7kXobXsOlHh8gcCf+oQkkvVa0RmpU4v2GqMSNmtqo5VWNGtdIjVaJ6bVWV2s9b62Ejfcsj7pZAavnzP13PnjgViVq3d+E+lo2Go1Go9Fo/Kc0UdloNBqNxn8m/MNb5a/+2//m7/swGv8f+PM//3MA/sW/+Bd/r8fR+LvTXrtGo/H/hqiEW/FSE1uxledeKGJcOk/NSrS8uuJzqbWPkcbyundnnjke9jw+nEg4bz/seXo84QjmkZwUg2JOCStQKzujPvKSiBQXHh8PvP/wwOk0sVpHsapaSIoQTIbV7Umspt+k1r0Sla7uJf7ZpdqzSo2IXBXUUqRHtYomrMrQLlYF6x5gJCcFI0cV5cW6iF4X8y5bgcLlZ12WCascqY9hHht82eaQUcBqdcv29h4rZ6bpyHq9pO+c+bzDkkLaMImy2K4peabMM6fDiYcPr/nw8YGnvXF7m7i/61gOynHco72yWC5YDj2aEtPpyFdffM3QJ77//lvElZLPuGem+cyQejpVFoslZTozbLbk8x3TPNKvbhjHJ9ShSx2Hpzeo9mQT1ps1m80Wd6PMM1ih9Imnj4/MRVgve9785q9IEq/Fx3dvWdw847A70KcFb998hxWhlDO7x5lxFh4fJzZ3Nzw9vmPoEqUYecps7wyjcD6NjJPRJchjYegXjNOR4+nMNE703YJ5nkip592b1xxOBza3dzx83GPupLTg4cNrpulI6vtI7ElfK0ep0tpBHMuFqH8tmGVK3WVMtTY1VGWpGcxL5WpIsEjN5lpNGsbOPMRfMcfKZUsyKldFEwgkAdeoNHUzRDLIpf64Xoeka1LR/NMOa9TWCjnPvHv7lv/r3/5r/vv/4b/jl7/8BiuGKnxcCWOeoNvRD88oxTkdHnn6+JExZ4Yesh0RKZRyjms3nShWatK41A1NuaatL9IwQsfler/Zxf7Xe8+sUMpM8cxpPNF1xmqxrD8rPiRxiUCLS92MvDyOXGtbzWqi2grF4meHNI73ApdauWuX+Gd870W1XsTvJSUa9zq1prfR+Pun/Xfz34323zt/N9r5+rvRztffnf9cz1kTlY1Go9FoNBqNRqPRaPwApK7HcUqZY4cy11/4o9colFndzrvkJyWhaiRN8UOuca/C8Xzk9ZsHjoclHz7sOB6PuPUk6SJJpdQ02uV/YJZR6RDpMCYc43xwPnzY8fHhI9vtmi4tq7SI7xEZcM9QhY2I1jRbFGcWn8GiXjUOrya23HGpClEVxVHpcLVr/Wtxq0lKA1ckSZUatRrXAY1dRBeuojSkkiCeQGpKTCIpSU1tBX0VIlEsu1gsWC035GwsBuV02mH5xGpzx3ic2G4SXbdFLDGdT7w7HZnnifcPb9kfjywWiig8e35DyTNDf8dmeUvXdwyLNcMwhAgdZzbbO26fveTDu9fcbFaM00S/WCM4KSUWi4Evv/oxLj1D35HnmUJhmm447p+4kZ67Z88pudClBW4zuWRKiY3A7c0Ws5GuS+TxxNDdsMsPPL1/zfJmyzzP+PGBjx8/slw/4/B0Zp5B1DidndPkPHzcMQwbuhSJWVWhG3ry5Dx/ccft7TPGcWacj2w3Wz777HPO45785jsw6PoBQxExjueRw25GOVKmzDwZ716957vf/pLz8cj22X1NA8ZrV4tU8SrdxIVcppo6DuEoLliJrVPXENF9rfJ1UUQv13Wp12aOq124pv6KF8wivVlsDkmXZzT1uF5SiwV1wZJG9amUeu/p9T5QURSNjcnLlirC8Xjm1etX/J//5l/zzTffRmrThWLwcHIWD4X1YmLVH1E9MZ3fczzPuAoJReaMCORSQuqnjHghFwv3p45rpCJFHU2KaEexOe5FIq2t6kiSuG+sRKoVZxzPnM9HFoPjfg+iqF7urVqtrIJd0o6SrklLcDR1lIiqRsq1VvOqXoyjR+I6xQcb9HIvVgEaadRPaWmzXPcx//++ozYajUaj0fjPlSYqG41Go9FoNBqNRqPR+AEoJWNlxi2k3+UX9tR0V1Q0gnuk2S6TjOIKBkJH5JQyRuY8nvj+tx/5sBg4HHZM88SgfX20y+ZfbO2pdtcUmyTFLZNkgfnMPBsPj3v2uz3znFmtCQkkHaI1eSldpN5qXWeIGscuKSzxKpw6XOqx1w26SDleaiCdrtZr6qX50QtIh9WaVkEiWVZ39y7qU6Sr1bKKdB1hQMBJiJRL0DOeejzzuk2ZEAnBs1z3vPjiS95+d+Tm5o7T8YnTecTZs765Y1hsQJzpvMNyousGdo8feXrcIThdisTZ7mlisepZLTds1mu61KMaIrRLA/1mQc4j9599wXZ7x2m3YxrPLDY3mBfG4xExYzGsuX3xI+acmU47UGE87bHtPZoW5ATzNJKnTNKOwsw8njkeDozHM/c3z5CSeS/vGLqBly++5DRmci4oheP+I3k88+7hHYtl4uHjGe2UnOP0HvYjT6sQfiUb6/WSoU/MubDbPbHoF6SkbJZL1quB8+HAaTwxnQpzKZxGR9JMsZFhgOLw9u0TfZ/o+0j3fvf9r3n95rfc3D+ru4rVYlGTfKTfu+bNqfWkEhWofqkiTqgIhQmlq6937CiGpBRMBDGjuMeWZDHEQqwXr1uMddfxoq+9zKjGP8PBU4rDuwQOhWtFrXnmsjWLJHKZeXja87ff/JK/+dtfhQ6vyWmAucDu7Lzfnej1FX03k88HxGFYQE4ZlRB9c4lK3JJDpuYSVbYigheBwTDJIefrxqRTtz4FpPi1AhkHsxlHGKczp/Me1R7IKJFc1Vr5WocmEfOQlF5CZNZ7CULSusbeZ6Qlo8bVLSqrUUFcMf100upbQ30fs9oSXUAEK5F0bTQajUaj0fhDNFHZaDQajUaj0Wg0Go3GD8CldpW6Daepw0qOGk8l5J8q4omkHaaFJAOeR0SUJB2Zmi6kUErmw4cnECdbBk+Y23XZ8VKLql636ISo0XRQHUActZ4yjxz2E6fzxJxzJBtVMaDzDjBEEyIJ84lCCB9zi/06AatSsXhBPF2rXCGEZcjHWjt7rXgN3SEakq94rZOU+rWeanIytgLBQ7J6JPGiETfkjtulCjQKQvE4n+Y5dghrmq7rlWd3NxwebjHP3Gy3nDpB6BiGG4oZ4+mI9T0prdnvd3x8fEPxjM3CTKTsLIcAWwyJxWqBiJC0Q7UnpY7UdyyXKxzovv5jpvHM6bhj6JfhcbRj9/4VKspms2G1uSf1HWaZ82lHnmZyzuQ8Uko9L/HCYXMhzxPT+cjTx7d8/uJH3G1fcT6fWC5veDzseHh6z+1qw2JYMZ0/cPITp2NIv3kWcoZpdBLOh3cnnr0cMIePH87IizXPX9wyjRN5njBmxvPEm1fvMBO6pTCfJ7QT0ukACoveWQ0r7u+UDx92zHOhOMxaeHjcM+f5Wqd6uRdCgVuVk1UsAl6i7jhZRwRkJRK41+bfuAacKr2u1zqETAypKG6YQ/FM7TEmKmIdRXGPXciolrW4ljwhVkiaalpToIr1+JBAfJ8Z4Mb5PPPh41vevXvP/d3n/PEfJ16/+pbHj3vmXHDgNMLDPjPPTwziLBVuV/VwimFaq1MLmHrd04RiF2kbL31xQT3jlsgl49R0Y928jXMIZrWuFYnK23p+RaIW+fIeVG+SuK9ELu64JpW1vh7xIYDYsVRi47ZWMbvVNHMcoHm8vxi/n5g0t7qbGalms/pa+yX13Gg0Go1Go/H7NFHZaDQajUaj0Wg0Go3GD4DUxFbtMCW6Eh2nIKSQaq6oaq2+BMwQhKQLRBL8TgrJmBjLqaagDBUwMsm7SzisPvBF9IUEtPq1WOw8iidOh8zheGYa56hjtRCMxT0aZC2DlJAi7litWVU3MoZ5iXScKhTHxVFNuDuJVFOjdbPOHJNCMiB1IYfcUVLUwNZjvKTWomSzVDniIEbHRZyWa0rOsdjJA5L01wpaXDAKHQVxZzEsSR3s9wdKUbpuDTjzNEJKCCP98JLz8cC7d7+h0GEZjsfC7fOex8eZ81R49nzJ7faWzXpD0o7URdWmaqLvlnQ6xDEMkYjtbxf0wyI2Dztl6BO4sF7e0C2WLNa3pGHBND4yH4/MJdKT2Q0lkZLiQt1bnCEL59Mj4/nIyy++5uP79wyLBcXg1dvvOB0OnKcTpRjjaSK70A897z7O9D1xvRgcD8ZiGMkznEfn228PjCPcbGDKM8djYc5xbm/ve7bLWxZ9RzGLpKpDziHDbrYbDOPx6cj4lFmvhWmemc5jvWZj8zEsnVcBVqtVqYW9FzmnkRjUek2Rav2xK1ZF9UVs44qVuc4kXqJ8F2Vf65Sl1gpb/Gw8ruVCyD8IOakGLh5Cz73eOzUN6AYedbXZ4Hw6cj4fWC3X/Jf/7J9zOOx5/+E1r15/z2+/+w1PD0+UOXPOMI7Gwp2bNawXUoWkhPi7ZICL4V6wet9fnt4lpejmFMtgWjORdTHS4t6M+4S43+oOpbujdKgqqVYuR2Osfno7EUUTlOKxC6sd4oVkjqWElxCfogq5/E6bdLrKStU4N3FqL1uXvyPZr8IyVmh/5x2q0Wg0Go1G4/doorLRaDQajUaj0Wg0Go0fgKQDJWWkio6SR9wsxEqe0a5HU00iiSAuOAljrLWqdY/uqidiA1KqLLBLLarUKlmotZiRkIQq9S7CQQRVx8qZw9OO3W7H6XzA7Rl0fZWCEELDakrS4phNIlmmIEXodEA8KmNdcxVHJZJV6ngpiIYfEtWoAKUHN6TzmtJK1+dA3T1ULomtSGsmTbhFKjNklyBJwRJKicfyepx+SWPG94OQukSxqOHNeUYF+r6jTwuKzeQyITYxjyfmeaYUJRfn6emE9MI8T4zjRN8r8+nM5uaGlFJ9nESfFrEnWpwikOcTVgxRZVis6FJH160wL/T3A7jR6ZJuMdCtNogoy+4lw3KizCPz+UwpE123pF+twSwSamZ4Kdj0OefxifvPvubZx9eIJ7Qf+Oof/ZyHd284jxMvfvQVn3/+N3z36g1j/shzM7SD1WCcRmPOcNg7ZEgdzNn4/s2OzUbpOkFFGPqo+lRNzKeRxWqF5RP4zGl8YJ5g6Bfc3t2SV0YSoU8ncOV0PvKrX/4V/+yf/9dxboSapY1r2axgHnWn7p8Et7mhl/1W7aJS1UsIuGrvQobFtRDVsZHUc3fMpErPBCmhZQ51naKy1AWSdnGdozhGMQU1ktWfr47ZjKaE11pUq8lAiOTnzWbDP/rjn0dyt35A4Hjc8+r73/CrX/+Sv/7rv+Dd29c8vf/I8VToRjhNzpCgXzjqFpWxl71Wk0h8kiGDpZDApRTEe0bPkaj0jEuK1KV0wFyfryNi9XMJqR7TRTTWGuRavyvOtc6V64cdpNZTVxl8SWiKxPZlEkr+VMVcY7DxfiNSb0u5Skm3UqV2FdR+SXw2Go1Go9Fo/GGaqGw0Go1Go9FoNBqNRuMHQKUnaY/JfN15pApEcam/wK+yhbr7VmULKqj0CB3mYyS+MMwnVIY6cTlTfKJjqFWrfezU1Q28SJ9V8Xfpk5RCh5CzMZ5G5qlQikfWTfQyAxmywgtmtZMSwcxii08SUPcqLeou0U/P272m5jwydOYWydEkkLoaFpOoVK0i4yJ8pP5sERCTayA1ZKYjXp8XIUri6wkBKjG0Z1hUjZowngEZSN2anN/R9Us2N7d4nrG5MI9Hur6jmJNLQXTBcfdIzsJy6NntJ0SFpInUJV7cv6QTDWEmhmjHbM50PnE8vOW4e6BfLLh99iOGtEBSwkXo0gKRZfx9mdFhGTuJmupu6SeZLGehWyzpV1u8ZMp8DuGsiWyFhaxDgvYD8zyjqWdjsFxtOJ/2PPvsC37yD/8J79+95o9f/ZZv//bXvHrzitdvHjiP4Y6O5wgs9n2cX02QzVkkpR86cGO1VPq+p1t0uFq83rlWFqdYIXx4eMvxPLJerXjx4p7H3ZFyyjhVdIsjJpjENeQ1oagIRSQuHPWalqTWChcUxaxetrWKNRJ6BWr1qZBqYjMkWYQGtQp/B1LUGjshIOsDxLVWgD7+nRvQYQj1MOu9mWsaUKu/TywXK+6ffU6Xthgzq/WK5WKBO3x4/5qvvvya5/f3/Nt/9wt+mf+CD+dHzjOMk5AHJ+c412jc715FNHikQ+OWJVpiC56NQn2RJJLIIQWrmESrjAxJeDmJqoKmhGpUF8ulujXahLGScYm0pdZNzkhFxr0X1buCu+JW6FIkQpPUh/D6XsNl2zK2Or3Uqms8Ep+XrxeNY280Go1Go9H4AzRR2Wg0Go1Go9FoNBqNxg+AWVRQauopZiEla3LL1FDv6i/4FSVRcoEkJOsxyyEZJSF0OHNNM1ndg4vcoXnBFbgmtNK1GlIlAVKln+I6VdEB603HcrWKbUqzug0ZaU+zi/AgBAYpvqbKSdVIUYmmqO+sCTFItdbTo3pVFrEtKQlUKRQSKZo4qXLO4hgvG4N+qQet4vaaLBXFy1S3LKM0NGRT1OpK6mrCsz6+O5YLp9PE61eveHr4wPmwo/geykg/LGMb0SQ2ALMxzhO745l37/eYCp6j6nS56K9CarO+wYVIX+bMh3ev2D09snt6YJxGOu3oho7X337ParPmZnPHanPH+uaG9faGYbGm64cQcuZgY8QaHZBE6pZYX3AJ0eOlXKtRc5nivHYrzI3VuqfLGTOjR1EVhmHFOJ1ZrTbc3N2zubvj7u4lL15/x+ZX/57vX73h/a4wnjLb20TXGa/eGfPodD1MyRkGSF1isepQM+ZxppyEOc8kcVZJSercbO+wnFEprDZLhsUKkY7Xp/fc3T+LFJ8SNa4AVsU3hhev13IVWtRNylrBGrJS6rWeq2SsKUEJ2WteiOLXck1rJhFco3rXuwRVNqon9PLBgHqNRUITVJRiGUVD0qF4qT7+It08LKKqotox5xEwlsOaZ/dbkihDEnKe2e0eePvuLa9e/ZaHtGOcjNMMcxEWxSnZ6XsodaPTaiKUa5oYrDglG7lcNjljfzOkIDVJGv/uco1clzs1zqNq5EYl3gDiOcvvBFQj1xnfX2tvozp5jvcQN7BSz1TIz2KxX2mXdDPE91rmEus2L1XsRpI10JrybDQajUaj0fhPaaKy0Wg0Go1Go9FoNBqNHwC5bNFZTaGJUDzHL/FNKD7FlpxI7EeqXKVOpKMg1INd618/RRcvf18FjijFc1Rs1oQiUd4ZwivNYJmkys2zDT/7kx/x+efP2GzWJNEqLqiJskSxsW5HRnJNVBHrarLKUHUKhncJtRQbdDWR5cRGHuJI6lGJLT2VhDskqefDJQRkPGNEBtwKJjmSXw54/HtxEO1C5YjHrmcpaOqwUricKdW6PWgZ6RJd6tjvH3n/4Q3n48SwFJ4e39N3ia5b0PUdRuI8jkzTxOl0IFtms14ynkaG1JM6sDnz/MsvWa835NlA4f3rVxwOT2zuXvLyyx+zvX3G7fMv6PqO0+nM4eE9j+/e8vbNb8jziCBsb+/4+qd/yt2zz1nd3MY5yWek7xDtKNM5XuvieIlqT7Mc26Wi8fWiWM4YURE6zSec+OfaDdh0YsohUlU6VqsNL55/TqfO1//gpzw+PXA4PTEMSx4eXvP+8YHd3jln5/2xsD06m43SDwOrQXl63KEpKkNHFbrBWG8GyjSBZLa3K1abO4Zhw+H4ipvtmmfPX4IKvXYUN+KPT5LLpVa6XkcZuV4/eMg1SXJN0uIFq9czYvE/D7En0tWdV8e13itx8YRUvzh3d1IaPj1GKEjMLSpho1OVIvmabjYruNcq1lw4ns7s93seHj+iCje3W6Zpw6KPBGPf9fT9QNf1JB3QJEwO4+ScZ2Fd4nYt5ZJcFgqOiWE5bn+p1/ucjZzjKHPxmpqup0sSoqH8Y69VSdoDIQdVFJX4kELSSHJHRW6klItbVLYSG5V+3Y+M7zWf4/EkhYd0MBNSBCavFbDxQQIJ9etViGqkYTGryWO5Fv82Go1Go9Fo/CGaqGw0Go1Go9FoNBqNRuOHQAS1HlXDxWDid+JMUfUZQbFI/9llf0+iGlVQkiwofv4kEq6/66/pJQpmmU6XtQ42kmEQ+35R52q4zaQEt/fCz//sx/zxz77gyx99wXq9iaRWUYpfJEUJQWnx1+41GSopZJGCSoc6v5escmqzLeCuIY/cISlJqkBUqF2T9VxwTXqZ52vl62WTEFXUI9EplydfRadKD55q6s6q+IodQ9FI0+EKbkxTzdEVGOdMzsJqZZgZh8MHUr8gT5lpKqw3a4Z+YB6NdZcQFabjyP2LZ6TURSpQlc3tc559/iV3L75gtbxhsVizWG/o+gXPtcO+/Cnz6cR43rPfP/Du+294ev+KX/3iX3H/oy/54uufs1yt6VJCe0W6REqrmjAMyWN5pOQz0XZrsVVohf3je/ZPj4zjicNxByjjODKOB07HI9mU3fGJp4dH9scDxQztEsOw5tn9gtVqQyln8rxltdrjD1NcBwav9sZmclSPbNfCcpXwAn2nzKXQ90Iumf1hYuj7eEl0z3E3sXs8sr2757OXX4S4qklJ8ajtNeZI71Lrcy+iq9YDX/QhohSzEPu/e81HbDbuDRyvSUCLTtqQ9EQS+T++Z+I4FJeQk3L5Q+t2Ixmz2OgslhE1rBTMCvM0M04j+32cc9yx4hwPezrt6DvhsN/x8PDA8XBkmjK5GEkTI4VxhjE7cxEke/wyrm50TjUBXGYoc911FUgS25DFjTyPcS9afAjBHKTW6Aa12pVLVa1Eda1ZPWdRmSui9WfEJqZbSHdB6utyqc0NSamJmnJ2NFHTzAJJsALZDbzUr6jiFEOxCI9fXn/R3znWRqPRaDQajd+nicpGo9FoNBqNRqPRaDR+AMQVUSfRU/KECyEGkoKXSD1pivRW0tj/80hmpRKJLLEOlSXmR5yC+ZnCgMoQssRnCjMdS1S6a0oRibFJY4rEZG+8+OyGP/nTL/nZn/yUr756yfb+BklRIzvPmX7oI/nmVvf/QlaYZUSlbj92oTJiOLImpWp2U2KbUuG6dSdoPQ8J85nkXa2TDcl62ZiMyb1IgJk4Il3dB4zqT6TqEq3exerzJGSsoFgC0EimGpHk6hJdv2S9vuNwzOyORxToUuZ4GAFFO2foJ6BjGAZWN3fMpz0iib7vIvW5dF48exm7lAj9sGC5uWW5WVdZZ5QyUvICKyGcLRfKfMIts1lv6X7yc158+SWWjdNxz8PHNyzGDZvVmsVyTecLkhqSEogzn/bM0x5zAVXmaWIcT8yHE+/ffctht6eYo0PHan3L3d09pcxM84iknnGcOOz3vHv3itff/ZoP796wO40sFyv6vqPvO7ab59zdPvD9m4lS4tLEIgF4OBmdCjebgexTXKfulCycjxkVmHyieObtmyPzHNuGP/nJP+bm9q6ekxxJvpIxK5QyR0rWc60rtSorOwyrVaypVoZetGWt962pYRdD6a5XntV6YbnssZKq/C6IhTkPgZnivlBB7dMWpltINXe5ikwBsmdKKVgx0AIi3NzcsN5s+eqrryhlrm68kKcz0zwyzycOdCWiUwAAIABJREFU5yOHw4GcDZUOZ2I0mCaYZuiSYylGWT/NdGrUKovXvUnIxfEM+KVqOOqfY962Sr8q+LnW4Ea9bbzNdGiKSmAcLNV0qXutdDVcHfG68yqxGWsWCW2RSEmKgWrcjyZRE+1WLu9y9V7XazpWxEE75PIayqca7Eaj0Wg0Go0/RBOVjUaj0Wg0Go1Go9Fo/ACI1nRSFW6RMPuP9iMvpYiiUZlYCpYL2SZUEkl6iifKNR9mOBm8r48SoiYEgeIpJEQ8viNmSFd4+aM1f/pPvubnP/8HfPXjH3FzE0k+M2cuIyIL1GovZRUURqmPd6notJrAilRldEKmaw1nVDwCaKSvgESkMnGpMkPBIsWGx3amScZFauJKgYR7rs23sVN43RWsbboXYYinWo1LyCuJKktBMZTl+oab23tS55TZOO4y8+wgMyIw9NB1wtFnFusFw2LNalhz2u3jJ6QVc55YLBbc3t5hlhm6DryEiHUnlzk2OCfncHzD6fDEdD5zPp+rnC10/UDqerRTOo3zVHxmOh/pxOkWA5qhdH1U5lZxVSy2Kadpwt0Zjyfmw4HVzT2Lm3vEO7TvWayWDKsNfVqEVKyp3WmceHx4x+sf/Zi/+dW/46//wy94enzNzd1zunSLdh032xVdesQ6oMQvipLAnOPxz2djsVSmsXA6G8fjmdTFeZMk5H3hcCz0nbJc9rx8+Tmr5TJEuc8UsyorC1ZiS9WoW5QWaUi97CdaVKJGyi9kYpIBE4sqZSPkek39eRWY4rVSVqvWdAvpLxfVqbXa1esWZtjAJCHkowI2AyX2ZD0+PHARg6nr6NOS7c1dyFycUjLFMvOcOR2PlCJst3vub5+x3W5IXUI0NiOLw5yhGFUeRsLQ3Rj6niTOyWfKxO+VpKpCMWOeTyF9rVCDk/H+IZckY30ONpM9hKaqktInkRjzrSX8PoJ6yMTLMqx7RiIsHAIWq5XLl5QrqAtFqpAEuqTk+qvFYrEZK3UjVAVcFHdBtW7fNhqNRqPRaPwBmqhsNBqNRqPRaDQajUbjB0CS4DnSXG5ek2MpqhLdKA5pOUTdqjrMUVsKNVWmHapDSEKXT9WnrtedOL8klnyOelddRCUqmeIz3QBffP2cf/pf/ISf/dGP+fLHL9hut/F4JohlMGUuE1IgdSEpL7uQLoJoQmtiSlRD6IjGll4S3Gr6qkoT5XdqXyVda2FFqozSTyrGuNRZCsWdTjQkqDu5VtfKZSDxUvtZj8UkUlpRZ5m51Ey6O6KOSsdiuWa7fUHJE6fjkdNkqAqWnZTgPEKfgaTo5Cw3A6XA+ZxZbpac8pkkcPf8JdubLS6C9h2aOvKUmbtMzgc+vP0Vr797zcP+wJu37xjLjGpHyWfWQ8/97R3b9ZLNasPLzz5jtV2hmhCfmKdEnufYOPRSU4aJeTySy8zpfOA8nvDi7D58ZNwfyWJI6sGNrl/Q9T3DasVytSX1PZIE1USxQtcr27sbvv7Jz3ASr7//W8a5oCkBHavlkq4XphybjqvOyeZMJ2PxeU8alMWqI+eRUmVTydB1GhuLZpg557Fws73h63/4U5ImSim4FUpNUxoh4cUjgRsp2cvNEnL2Os1q4MSOZWGqw40hyJxylW4qCTRFws8NlT4kZZXb7qUmbx06ojDWcySAU4dVIe7uuMQ96iTcDTWLFGE2OlWWywV96uql6wgLis3M2VgMsUspYjw9PfHim5csl2u06+m7M3l0zlkYC2RzhvTpAwCisb8qKYNWkVrvPwMQY54PlDlHurPaenPDSq7nLdfn36E1XXoVlFrfT2rVLG6YStwzdcvSrJBSj1m53Kxx30oIRr98UACLcy6ROL1W95rFeXEHNFKVqUesRD20SGxlNhqNRqPRaPwBmqhsNBqNRqPRaDQajUbjB6BjQekiRlWu6cnYvBOJX+aXPEWtooCmHhEl+0hKQ1Su+mVJT69i0pmJlbsqYwg/kHSoScgZyHQqfPbFLX/2Z1/xsz/6iq+//hG39zeIhrTITIinqHn1mtQq4FKislI9Umk13hYC1KoICdEoCCklkFJnJ7sqfGIHT8RjX7Gm2rRuCl6cq7kDCXOvKVOrGqZ+LZHEi4pJ6h5lSBOtVZPUn3HdqhSiarZkkiY2N/ccDmeengrZIHkc9zyFrCwefwahU+fN968YpxOqazabe+bxwP/N3rs1yZKd53nP962VWYfu3r2Ps+c8OAwGACGQICVKIilRokRbCsqmbYWvHOGwfeH/4J9gRfg/+Ma39oUPYYUjHA7ZYVsKOSxbEkWIEgEMgDlhZh967+6uqsy1vs8X38raja2BLFMc02asFzHoQ1Vlrsxcq2J3Pfm+78N7D9msR7JkVsMarDCXPb43Pnr/B/y9v/e/8+mzSy52xmq14cMPvse0PyAI59st73zpS3z1y19CdeTDH/6QOw9e4e69u+RVwLJaJvAVqJLThjJdY+aUemB32HF19Yz98x3PHj+h1Eqxyu7ymt3lFavNKcUcl8RqtSEPmWE9sDk5Ybtds16vqHMha+LW6W3qK5UnT54wHa5wKZystgwpIV4QPNyUBEA7XMO9OwMqldOTRBoAUcpspKSYw7DasN5WdruJ23ce8KW3vwYO07QPgNXm1hIr6hadhksPK6IUqVFdSjh51SNGeKGW0bva4oQtx/SRFHOrwTWV6A9tmzl2WQY4kwYhK9JA5IsZLNQFaHqM4AjovDkWHWox5nlPqTNZM+MwoKqIRAyrqpBzZrPestlsWI+JYRjQpOyp7IszTXHTwXEua4trdcOC8dGMzG1dRxfkdDgwTft2fBKOVGhdnC3NtdW0spy21nUbBtAaoBIPMGrSXMcBdaOzsrkmJcYXazKevzgsEUGqt9c45q2TMkWsbrXwpzYjeYB9FcxSgOeurq6urq6urs9RB5VdXV1dXV1/TPT+M+NL/9F/80c9jK5/Gf3Nfv3+KPWD//iv/VEPoaur64+bBuH81or1kHn06MBnM0hJEa1Ym9uJhKQU3X80WKJA9Rb9mkmyorA7ftDf0EZzOAnVJ0ROmlNtDmeVOrfvb/jGt97ga++9zetvPuTkbIUmj2jGCpVMSuEaAyhW0DQGEhVvkY3aolQTkhw3QcnNW9VcYeixL1Ba5Khqw0BLXyYsXDUQS+S6wrG3rsVzLufOor/SNPoqXxAYQSX6LkUUp0Q/IdqOO2FLBK0KWTInZw94/GQCTZxslDKXiOMVGv4Fqc5qteL5s4lnT5+wOV1zvS9sTyp5WPHg/gOSJPKg5KFto848/cmn/NPv/g7vf/ghDGt+6df/Kufbc/6L/+w/4ctf+SofPTnw6Sc/4DVLjLdfYX/1lK0WPvvkR5TDFXfvv8LpndsgErC4wSJ3p5pF9Ot+Zv/0iiePP2U/FeZaePzJR2hesd7c4mqa+OGPPuCjjz+hVGOzXePVOb9zm3t3bvP2229y9949dteXgJDzyGpcMc/XVCvkPLBaK/4srsg4wDAG/5MsJB2xumOzWuECRmE1egO8mXEYKXXmZLvmF//kn+HBK69TbcI9UcsU19UNK9ZiitulNEM08L2Y4RpRoYJgDVKmlFpssi/TpLmJHWVxBTboBw1+xhw85qfSOio1H8+xiIBrcyNbRM+6QEp4rbHWWhRzrc7uUHi+m3ny9DHX+0tONqfcv3OX05M1muRFp6MqKQ+sViPDuGK1OmO9KewPz5jNOczONMPoQooLjRkRn2wRfRs9nWC+THuhTBPzdGAuM9WX2NvlEJf9azu1FnM1pRfrUCO2NaCoBBRO2uAl0ZHrkNr+Rdu2rIAIimDu7SaLJR42ulSbBRoDkqbW0bpIWDpG/cUvu7r+SPX/xt/N/e+Krq6urv9n6qCyq6urq6urq6urq6urq+sL0Fe/ecaX3z6Hcs0PflDY75/zeL8L52BqjZNWSQzRraiK1TkcVS5oyjATUa8v2h9xasMCLdISb0BhjMhVKZzfXfP1b7zB17/6Nq+/fp/T01MGjZ6+pIKLkJJgFhBJPWI83QzJGW1uKG9AD1o0Z8ulVFI7ysCm2iJZhehWlBa3aWYtsXNxU754TXQU2hG5VKmINbiJ4l4RSw2GWoOeRrNotg7CVbgoCRflMjaHY0TlZnvC/Ydv8MlH3+P0ZCST2U0Hpr1RypLk6Tx9fMnuUDnZZOpkbG+tMJ+5dXqPB7fvoBLdm3kYGNdbri8uKLVydvcV3ri85I13vsmf+uVf48njJ5xuElIK5bDnq1//E/zJX/vLfOuX/iTv//2/zbPv/0Pu3L/DMCQO13vy+JzNySkrtngtuDp12jMfnjMfJq6eX/DsyWOePnnK5eUlJvDmO18lp5EPP3vM7/7eP+ajjz/g+z/+hEEqX/rq13jvT/wSP37/ezx+9kPe/9Hv8+7bX+XB668yTTu8VtbrDYfpQD1cMQ7Kdr3CZEKAUmG7Uao6h4Oxmyt3bt/idJPx62dcXWfy6AyagcR6vcJky3p1m+/8/J9mHIYG3aw56yzmltvR1YdXNOXjtVtskIo0l6QQib8B5JPkoHgtnlVc8ESLFm6xpBL7dCHWgXmLMBVEDJd6jE92IToaid5KFwVr3aYpALq5U21mt7vm+X7m0ZMrfve7/4CfPHrG6w/f5L133+b1h3c4v3XCEJZckio5KUMeWW9O2ax21DJz9fySUivTDPMEXoEUHaDJgBRdkOoBEqO7kyO4NivsD/vmejYk0bi9NsjaopElzmKtpd2AEHG+STO1bTNcztbWGs1FGr83SYhEXGsSxVOKc4qgbscYV4EXbtJqDRzXBkE1bmFo7x2yXNOurq6urq6urp+hDiq7urq6urq6urq6urq6ur4A/blf/zL3z9Y8f/qMq2dXCBmrBaegOuJix0hGNNxViuKa8GLU5irUBvncU4uupEVaCk70xJlGXqRQOT0fee/d13jv3Td4/Y2H3D4/R3Or+FM5gsekikgFFK/eoFHCrOKyhGISDkoNopGac8spJFKLYVWMiLN1CYccrbNOGjgRF1wq7j8dV0sDH+bWuvkaoGxxnceuPF9cmOHdUono2yPoah2DKgG1InbSqDazPTnjz/zKX+Bv/fePUNuzPduS986VHDjsnFKEaXZKmRlXAWOnatxfb9jvLrl/Z2S73ZBy5uQkonPLtEdEWK9OeOdLb/HgwQPqBJ/+3t/n5PwVvvylr/Phh9/jTK4ZfcTmHbdPb/Hkzjn18SuIKJtbG042pwGkXfBSmaddXM9aKPs9u8srrp9fcr2fuLreM6zPeO21V9lfPEXPz/nOr/4V3v/gY371536RH//n/yV3biVObp3w7le+zre+88v8r//jf8eP/ul3ubj43/ja9Xu8+tpDrBhJIWewq0OM5WRFzs+je1JhtzdWI9hcmXaV4d5IHjZsN4X97orD3jg7y5hVnjx6gnvi3ffe4vzWeZgDPSCleFzb8N8WKo3KYVALojdihFs3Iq1j1N1RUlRMYpiUFivaHJMWHZau4cKkxQ0vjtR4XWSpuhu4Noi2AMuCaEB5A5oxkiWDNfosM1fPdnzy7BG/9/3v8zu/84+Ya+b6auBqv+P583u8+eqrnJ/dQpNhNeBczpmcAqxnTaSszFNlrjBZi2lNjc+aIZLAnFqOFZFHiIhCdWO3v+BwuKLW8xa/TIvRbbcrWMWbY1Q14KXS3lpo0bopjs80dpIk41ZaZLIilHi9CJEDHcvruBZFSIsPWTO1zqgqpc4RDd2coGKF1rDZQLIfr3NXV1dXV1dX18vqoLKrq6urq6urq6urq6ur6wvQd779LjbNfO/6wKOLid3OSGnA7EVXm2iAP2sOM7MWZZoqWdcAzHaNsqIy3dh6fPAvnqO/z2c0HTg5G3jvG6/xzW+9zTvvvMHtO7cYxjHcbepo0nCb4Q2OCO4FQzAzzANGLv2QooqJtZ+X1M5wNYa7Uo9QMxxUi0POo/9uCeLUjLWYV7MagEQE9wBHKtI68Rq0UWkuvOjpBEFUAoIcYz2j/zJJwrw0YBr7XsabdGS9Ud7+0jd59Y2v8r1/8n9AFoZhTbVCNef64NTq5Czs9kadYbUdqdUocyGniLTUITGkkfX6lDrMrDKcnMZJKVPBppk0rjnsD/yFX/2rzKpcPP4EBR7eP+fT7/5d9PKC89sbxs3A+uSU9cmWWprzsILVgqWB4jPFjOvdFbv9nqlWNttTHrzyKk8++pAvf+tPce+tLzNsTrh1+4T/8+/8t2R/zFtv/yL3X3mT7XrFejC+/OZbjPM1j578hP3hknm6jSZltT3BxTgc9hwOO26drhiSUOew1+UUxCmPituMlcpqfcI0XXJ5NYMI11fPmEvE6K7Hkdt33mB9cnKMZoWWCgrU2uaQh7tOJMfcUI24UCouhrsg4g2aRVSpNBex8AKmh7VQMAy1mF9L4muA7KG9toXEioBECGlaui2R5spt29NmShwGao05Xmvh+X7m08efcPHkY043lWFcs9pUPnt0wdXlBY+fXvL6w3vcO9+Sk4YzMiVEnWKF2uCfAXuDQ3GqKcmW2NdAeeYC2VvmaxipBcFqOJMPux2Hw55ixuApeCoe56v1fy7RyMVKrAPVG7G0AS9FFVoMrwiQhnBAWkWStojY9i7Tuik98mBRXVzQAVJTUmqZY/3qcj6t4ejovo284HZyu7q6urq6uro+Rx1UdnV1dXV1dXV1dXV1dXV9Abp/5w4ffvgTPvjoGT98/zm1xVK6V2oQCjQPiMgNh5QhFtAvKMbinlwa6eTY5aiewymFkEisTzJfevc1vv7em7z11kPu3D1nGEYQJw3hXHOxF/2SLlExJ4nqc+yz9d+pgC9FeQswalGqxx5KkXgOhD3Mm9utOUS1feQgS/+iO+LpCKDcajuedOwcbFmh4cYTRcgNKtmxV5LmvDSvzWn6IvpVHMQXN2durjrn7r1X+PYv/AqffvIJh92nXD0/sN9VLq+NMsF6lIjkRBjWoOJcXl6Qs3LS4NuYEilnUMis0G0Gh1JnVqstw5BQzTiJO6++htlMeeM15sM1zDO1zJys18h2xbhZsd6uyeMas0P0HALiGTdjmidmm9nvrpmnA6LC+d273L1/j1u3Tthk5/D4Q6Y88u1vfJvtmLn34HfRLLx+fs7WnfnRE07VOFln8r2HbLcDAOvNyO3zc8YRrp4/xebCrc0Jq1E5TBVJMOSAenN19oeJWsMht96sSQqfPdlDbeApwf4ws12fMg7rBopTgC8yeAEVis+IQtLhCJZBwsGrHvHDYsdKU/dwzi64MjobHZUlDHgBkd5AZoPmbQ4GSH/h5BPJR8AdwC7m97Hv0v0YJZskgKqbstkOvPPm67z+8C5eJhxlX4wPP37Ejz74jH/wu+9z8fQJP/e1tzm/dYqboSqoZuZ64FAPaIqxlUqLf3WG5nK26kAAX69gJhENXQWL6krcCtO8Z5r2zKWQh3x0oMb7imIO1QJY5jQ017GS0xAg2LxF3dIclynOkQvU5oBtNwG0itAGQRsBbo5lNMXbhNX2diGopta3aSxebFEIY2VcLaU7Kru6urq6uro+Xx1UdnV1dXV1dXV1dXV1dXV9AZpn47PPnvH937/g8nmDbybgAWfyuMbNqGUiDWPAPLPoqxTBGrSTBvMC7MTXaINM0H5arZS337nLN997jbffeoW7d++wGgaSOqoNBIqCBqwSrRHLqUpyp0rCpVJrYRgGDIvOPo9+OxcnoYhDtUpqXX5KjqhWASRFD2FzvoXjM1xVjrV+zQCfxo3+OgpugqogmsKx5fFI9RpgRRI0aFV9JpmSml3P3OLcuB/dndFTGU6wrCMnW/j6z/0SH3zwA/7u3/lb7PcHysEWFsxc41jXq/jZq5OSsMoDJ9sTVDOSItqSWhhXZ6ScEU3hki0zSGJcr0kpnKrmyv76GVfPjHlXSJrwHO41MRBX6nQAadGoZcJSwNk6F7xWrM7UWtCcw602rrh35y5DjutYq/G1r36NB7fv8p2vf4eLiydghs/PMZtZqbJKA8PpwDiMJJTTk1MkOeO4YrM+4fp6z8nJhu02sZ8q5RDTRFVICZIK8zzhONv1GVmF5MJucuYpIlbf+fJ9vvre10i62BoN1UwtzY2HkXQ49iaKCrq47ISYo0YAQzNcZ0QS5jMR8avHfkQza+A8BxCVBvEdxDScgg1Qe+tFDYi50LeYq+bO0nm6uIzdaUBfcM9s1htun9xms92y3Q6IKofDxOXlJbdO3+fy+pr3f/wZnz6Gy6trzk43iAg5D5ydnnLr9ITtZs16HHH/jMPVzGGGw+RsxtbWmj0grEgw+jB3IuoYgrZzVGtlf7hmnifWq1XMb4sbCNwCEtbW6QkBGVWheom1KI57lFuKQJLWhWkRJx2Q16luEfcsUG0Gcjs3cWOBChSP/YrMxGhtMbQe3w9qMUQyLqW5xu2LeaPt6urq6urq+v+9Oqjs6urq6urq6urq6urq6voCdPH0GR9/cMGHP77AiqOpdT1WJ+ehdcqBqZGyoCnjg2PXuwbqAjikG3+6OzNOIpri4n/j4Lz25jnvvfc6b739Kg/u32ez2SCqqOTWP+e4GOoJVw8XY6vGbOmTzbcWEBUVki7uxwCHJjWa+zQAqbQRsQAWD8iqNFMlGq5JkQBDgNvciMjCjOL1okt0ZPRyLlGZ0Ye5PDOAnmjAlhfAM9ydKuGvQ8ClYl6bI7OieeD81h3+0r/61zm//ZD/6X/4r3n06U+QeSKPjlVnPUJukbPDCEPKrIbEerVh6etLmhjGTUC/PKKaSeMqoGIx6hROyDrNFKuU/Q6fCymtyVlwFFQZRkGYIlpWAkKm1YAMA6VG1KoAZ6e3ubqcubzeUbVSDtf4eoVLIo8rcoJaJk5PMqs8cnb7VZABq8bV5XOMiXv2KrW5/G6dnXHrzhkuFbmEzckZ4/MrVsVYj5khzZQGynMSRJ1qld1uZp5mTm+fsV5vqHZNGqLbM+fMu+9+g7fffLdZBGku2XC55uZ+Nfdw8bb5JFmPfshwOObjfArw3GafE9a8mKQR9+qpXe8Wm+vSOlLbnHSjBRO33tQltvhYdNqiYCNWNuaWIxowPByEymq74db5OXfvnrE93eBAOUxcnmzZH3bc/+GP+ODjxGazZhgGwDE3Nus1Dx8+JGvG3Hj65DFJf5cPfvgRc4FDgblCTjH2JIp7CZiqzc3Z1pF7zMk6F6b9NXWeG2SN55mVgLsesD0iYAPem1eSJKR1d1aLeexEX6x7vC/QonC9AUgggLDF9Vrc3MvNE/HG1fpEpb1voMB8vGaiilv0ii69uF1dXV1dXV1dn6cOKru6urq6urq6urq6urq6vgBd7yc++eyCi4upwZIXMaXhLGtdkdCiShWM5kSbohNOMqoDqQ6Uo6vSm0MRsiTu3l7z1a+8zttvvsb9+3dZbVbhwRTFrIZTUXLsUyPmsiaNLVmN5+oQEIOAHImhEcwb4EgkoiZ9JskIBMwQXTojG5ykBJBr4Kj6HDGwxwjJBQVZe05BCPiovkCa1lXoThtpg0oRcxunzJurtJ1TAA/wZC0KNEyXzW0nmdvnd/nWt3+Rzx59zD/97j/gJx/8iKnMRxfYkIWkkFRJZMacWI8DIglVyDowDiuSpmOXp4qg4xqSUUpiLgnLwkqU9fpWADi31qsIiGFlx+FywmtFhtT6AwWrBa8RE5vSCtFrhnFEry8Rc+o8M6420T3YzklSZRgzaTxBdYW13kAGwQchrzdM8wQ42+0JZ2dnlDqz300RISpOSrBZj+S8IweHZhjBUYYcXaG1zsxlZr0O8Le/juN55eEd/syf/YusNictHrj1H7oEt/QAVHKcJincvaKI+3GOLddQA20FiLSEU0BBXdp1lRYLDDRovujo6G37d00svarmJbYu0naZWm+iH0Hn0uGokvCUGVcbxiGTU47XASkNDEPm1ukprz98wPOrPbfPTtlu1qSUwZ3VuOLBvVc429yi1APnp7d4+uwRH/74E2YzSolkZ88xz2OpLfG/wQEXVyiE49MwSjHmMlPmmZyHtqY8gGO7WSBgaQP4DRjHWq3tXFlAXSe+X6KlvRzXSm3bhHAsx/fpCETD1aq4tJhdF9xqjNPbWq3z8YaEmPo9+rWrq6urq6vr89VBZVdXV1dXV1dXV1dXV1fXF6BhNXD77paz85Gr6330UGpCJUUMohUkjy0psyIabkVPA2RnnvcNQDiqA1Jb9KssMK6wXivvvP6Ad954yCsP7rLZbkmiLeaxBjhpz9fFBSkBfRCojR0EbIx9hVsr4jgDMxiugppjEsDCWuecSAC2KnNAQw8XXWo9m+52dFZGlGdzPyINFGnrkgzwVCno4oBrMAskII6AtuPHo+9TnQX1svQRBhj0BsmW2NgAULhz795Dfu3P/SbbzQn/EHj02U/YX19xegJUx4szJNhsMuN6jO7L5hmL8Ub/nihoSkcvma4GVJQxrfG14V7QYcCrtehYwc2Zr55zdfWMWgqKk5fjwbHpwDRdUZmpxSilYB5A0ZprU3A2qzXmM2ageUWWFWWaKDZDiW7H9eos4mhXa/b7PXWeGfLINFXcKzkF6BqHLbNXTjYrVIQ8gFRhzBkVb8cqzPPMfrfDrDJkxTHGIfMX/9Jf4Zvf+kXGcd2Md7X1REaErmqbM27NAdnihL21TLb4VVHF6xK/GrDRqIGjtUW4eriIkaVbcsCp7ecGH93D+de6Td21rRk9QkAEzOdYER6wUNo+1BWSkvLIahzJQ2YqFZ0M90qZC+6wWa1487VXWK1GFOPs9IxjZas44zDCFqolDtPEar0GDRfqVGEukHN0UiaJmxeWPk6RF12RoguAFGqdmQ57qhmJGTBUNcbOclzhJq1eI8LZ48YAbzdKJMlUd6C21wjeALCLt07JuKFhacmNytw5bkBozsuAnOE8RSBlodTaonZri61urmmNGOiurq6urq6urs9TB5VdXV1dXV0dIOgMAAAgAElEQVRdXV1dXV1dXV+Abp9vePdrr/Lxh0+4eHbFYS+oJqw5FEUbSTM/urw8KT69cDMBJM2IhbuyQoM9hSQHbo+ZV++M3Lu1ZrVRVL252SLGMqJYpTnWYn+NiwEeEA/DpaCiVLxBDEVJmLQuOmiQ0uIYrFCBxBCvdUgotUWkBpgKl6LbEvoYTi4j+i7N64uOQHPChJkaZNTmjlwcp0t8ZOvA04R7xbSiksPZ2eJrF1gUhxxuwHDgGS5CGjJvvv1l0jCAGx++/32efPZD/PAp084YV4JmIatw586r5GF1jDEVAZtnJK2iWjIZOW0DJEtGcoHWV2nNDZd0HRGYkrCyZz48p8x7cCflFZJG5jqhtkLMEAM1ZbYZEaXORs4DVQrlcGC+3lHHFTmNDEMDR1R0vWKdTnHgMB2YpWAM4bjMmcNuxzTtMXesOLU5SavMDDriZtGHGGeZHHyXuTiHg7O73rNeK9NhwtXJAl/7+lf4y7/5r7PZbNCc8Gptnih4jfrCY3xwQjQiQ4WAjqaGyoBJQC9XC+ekBzRT0cVTCNIgtgg0J69TY4K1uFKnNlCeWgxs/C6+0TYnpbkJXzj8AmQaIonaomXHYU3KA3N1pusDz6/2mBlJjCEn0jBw9859hjEgsYgyTVNE3FrErNba4p29LnZRZhOmCUqRYIICbnZ0GlsFGQCLdFUzkBbBOs8H5nnPfLhGZYWbYbXC8bgct9h/9E8K1UoDmQHqq1tA4hYPWy2clC6OulJaDG7kQmt7LwpqmjSAs9gLMCouVLUW69uwfVujuIJOcZPDjfe0rq6urq6urq6b6qCyq6urq6urq6urq6urq+sL0O07p7xV7/OdX3yLx0+f8vf+9o7DFP2L1eaI7UwZw3BrYMBBc6bOU3N7NaDQ+hfFIzYzI5yw49SdU98zWkEMxDycewjmxtAgo7csSW/7CEmLPJWAm6pIrSgBVlxTJGM20CkN9PgSp8pSVxfRnYWKW2kxt61X0ltvJBLURezYlwdLLGfFgOzRURhoMkUMZwNIAazkCCOd0no8U4NATnR3ShjFNDxh4e7KiNaAlaJIErKOvPbaO3z723+aMk2c3zrhk/cPrPPEyXbkMO1ZjRvu3n2F9XqNksmSojsyR0RrImPTgaoZzQlNCmmk1EOk0VbDmHGfsDKThw3V9pQyUcshwOCYMYGcRtQNlUR1weoEViiHPWU+YKKs12vGIVPrRJkOkApJI34WDbSsGjB2yErSNeMwsJ927K5mksAwZHyeKTZTreLS4HmCYk5q8axusNsV7pyP1MNMqQVNwvXVBfvdgayJt7/8Cv/uv/cfcv/BQ8LX6qhmaHHCnqJ30arE9VPHWhysiEAS1CMaVlICa+BcBLHSYL62yNZwyioKaniLbdUFZmsD0R4Q8hgka63L0SqIUr2iDbwF5vRwd5qHA7SloMaUT7gL17uZ6/nA9W4CN043A2fbgawwjpkT37BvjlN3o5ZCrSVAupfYNoKmWLuzV+YKpUAt0UGpSbFaQDy6WhvcX3oqK5XqYDjzNDHNB4ZxFTDe7Rjj6kufpEOpM7VOYH4EtOCtwxKQdMNJGe814aC0NgfsGPXqi6e4/Ywq4oZZvJkEMA1X8BKfSy24z+1aJ7Rtvaurq6urq6vrZXVQ2dXV1dXV1dXV1dXV1dX1BUgQzm+d8c6XXuXnf+GCR59c8I/+4ZMW/VowCpRwD3oeCYej4ppIeempFGiRjbIgPBe2KLfE2R6usMcfs794lbq/h683WDaShwPTF3MbtChGQ8igARnC1FnJMuAyUVu/HRUsRVxsHEn0TWaGABctQ9NkDpJiesypDMDqzfV4bMjDZaFA4TLz5vJUUoMh4apT5UZUq91wcwpiDSxR8Bb/GdGTi7OOBixjP6q5xWhmWmpldFwKjHnkldde5zu//Of49MMfsHv6I+7fvk0tB548/ZQxCeMwcHp2jifFyoxbATfKYUcalVr3pDQiwya6NT16AG0+YDZRbUZlRFCsjdGtRmRsGtA8YKVQSoFcAlgOiXRQTDKalWByzpAyWaFOB2qdyAxoWiMONs3oMCJeERJZEi7G5IUswjAMzJNiBWxuEabThJWCeMKtMM8zNRgUZnCYom00GKKwu77CBuH62lmv1vzWb/91vvaNn49rKAGhMQvoiMUcqBHpSovzVQvgFRG/LSoY+Skg7nhEFqN4bc/TBjcJ92PKKToXhehf5ZhYGjB7mXdLLSoabYwtGrZN0bhWWABvs3YcDpIxq5Q6M1vlcCjMhxlRmOZ4rh0jURWrxjRNHPY7pmlimidKqS12NcBg0iEcssBc4VBhU2hRtRY5zBZr3JdheOP7S4enOWWeKGXGzAMkAilFpLSSqB7jjn5KCYcnjlCO5yVuMCjHeNa4GWJZr0GrrVYWoAuOHztGiUZZ97jJYAG/zdG5gGG3cGYuN0q4lT+Mt9Wurq6urq6uP4bqoLKrq6urq6urq6urq6ur6wvQxx8/ZswDo468dv827733gI8+/IyPry/BHfWEE+CqlAOScsCMI1k0qI5ZaQAshbMPY6t7TmVmUxL7Tx5x/eknHO4/ZLPZkLIA62MEqyLRFSkaIAZH2vbEU+xPK1IDGlYrFDeyjM392JxQDlUMNYnuQsKhJp6jc9Obc84tOiytNPOmIJJb3mzri2y5nOoK6uHq84isVWtERAoqQ4NRChbAxs0DcrZuz6RjPKYpInQXhyhyJD66uCs1YJWIoDlx595D1usTkjv167/AiCNJuX//NS6ePsLKgbOTU+ZpB5qhucqyDqgk0vosQEwpSKqIZNJ4ArVCEUSGcICWibKfqM1tOI5bHKXUgtcaY6qOW8WYycOaebpGXNlsTtnt9uz312gprMcNlNL6Tg03Iec1UJkPOxAhjVtqPQTAShusViZVtAZkLRbXCxO8GNN+z353oBaP34cxDpvD9WdUnj7esdkIkkZ+7S/+Jr/yq7/BsFofp4c0+CzEtYqCUCdJDtckAQBdnMwY0awe0cQujpDwWnGB5IlKRVJC3SlSIlpXlMDdjqgc40TFvfWYyvExN4tuRCI2WBrJXFy6Cwz0WqgS8NhsRtOAWaGYkT0ibteDMOiLGF2VZRROrYVSC2WemcocPY1H+Err3bRjz2oF9hUOBablPLtjGn7IqKMMZyUNVrpbOB5rZT9dU+bm2oRwRi6ua/EX37sH6DQHsRfO5gaNrXXIYi/WUoDjcKmq6hFgxqmLxx1vPZ/LDQHWrpseoaw3YqyimNW4wSIPf8jvsF1dXV1dXV1/XNRBZVdXV1dXV1dXV1dXV1fXF6D/+X/5R5yfblmtlOcXF5RDIaeIHwXFZXEAQiufxLyiDbhhQlrK6hDEwyt4wsy5zJwKqAj75zNXH3zM4eGblFu3yOMaVUMckrzoopPmjIx9ZBIEYGw9kTkN0WtXa4MYDZCIBLSQGi4vyRH0GaWa4QZzW/hWQEpNxx5M0Yx7QTUcaCq59QEuHYNBdNQdlSG6O8UayOI4dpeAq07FXcBre6kfAVaAqjhebTAzHKRLL6IgGi4/ESWlke3ZOW9++T306lNsf8H2/Jxad/zkgw+oxUji+DAGqD3s8XENOJoyqtHKh4CuTpFhjdc59jvtqYcd1ErFsFIwjFpqADur1FqwUsPdlpQ0aEDU5sQbxw2rNPP8cIHViqwT28PMPBWGIUcEbRqi21ISg47MZaLO17gZlQJkvEYMakR3wmG/p0xTo2JweXWB14kky2yLJOJ5dqYSka0pKbu98su/8hv8xr/yb3Hr1ivh0E3L3FoceQGSTYxWUklyArQlR6zi3mJiW/QrFCB6J7WtDXVtLlUnydDcvQHOFcGMBtPC2acutNxiXrgzW48qFVFrEE4i49Us4DbCUmyqGt2sOW8YhjVJB9IwMI4j1Y2kwpASmmI+IQPTBLUa82ykdGBcbRiGFZoHyvUB91jvlYDKEI7VUoJnz9UZhuihdH/hpmz3KTT3Z0QvL1Gw8zwxzzNDDodzpLl6657kRW7s0QN5LKYFaD2VAVTDbZmOgBIJmM4CKBuYjDVtJElUM4rNLRIWXAbcS5hVRclJqWVu+0+42o2xdHV1dXV1dXX9tDqo7Orq6urq6urq6urq6ur6AvQ3/6vf4ex0w/ntFSlXPvvJBc+fT9RSwpElASYwMK1YnclpDUefUolORY++xoSywbircEeUU6Kzb5qFZx98yrOH32d7dsaw2UZ0ZhrAoufPMVRfgAJrQCFgaUSqGkuEY0JNcatIyuHu8houNfeIrAVAEUqQFU1H4JgktYetwZPo41wgE+LN2RnoyfGATJICnkgiSWq9me0ZLVLSvAIcHaIiipsFPG2Rk5JSAMkGuVrtYcBEiY5QlYRLQGEvxnp7woO3voJef8qw3YJNrPOaw7RHk5KcAI2Wj017XiZcBpCI4MQM8oCOa2QY4OoZZbdjd/WEw+45+8tnpNWGPKwQosuwzAdUhKSJQQaoFU1KmQvJYNSRZILNzvPL59js2FwYcmYcEuOwIuexxW2CVm89lQPDsMbnPbVWbNqBGXWesFIppVBrpXqlurHfHxg0wDcOQ5hHmebC/uDkIXP3wQO++XM/z2/99r/Dw4dvoOqtt/QF7hJZMlU1KlfdIg54gW3tmobjLzpI1Z1q0ZW5PN8RvMQ8scWXKx68rRVJJm2P+eLii7WExjxyAkz74sh1Yh2INIfm0tGaYHEbNrAqkhiGFeM4kIcxgoRrRQVyHtBEQ55K3QTcM3esRoTualzhGKXO4Vj0JRk5jmX2AJRzbTDdo2MzubeGyHiNWqQq4xzdkmZGLTOlTqS0dNCG21Kaq9m89aNKpVmRj1AxzlesKW0uTPParn30gcZjCZcSbtgGQ0XiBgSr0wsovZy6BpTNl9jXJR42HnOr/xLvpl1dXV1dXV1/nNVBZVdXV1dXV1dXV1dXV1fXF6DHn01cPJr56McJp3C9u+QwR/yo1RqAMIVLKT7Yl6MTSlrMq9kB8UoCBiq35MBtqdyRFQmlNkC0u3Seff/HnN1+hWG7Ia1G8rgCH2gIJ2IZkQY/LeAjAdlEM8kcT0t/ZgARsrf4xhYRCUeIIQpuAy4FxEnNwdbICyIJaX2W2goipcVBulmDtc1npSkgozanpHCM8dQGrqL2MECKiiCaYl9YAFdaT+ZyvB79jrR+S9UAUkkzsTGlejgCB02c3H8deVoYxkytI6+8tqHUPVfPniOiGI4MY7jPcmKqOwaJ2FYfDZv36CG6Dev1c3ZPP+by8Sccri+5ev4ULLG9vULcSKkBW83NczZS5z0pK26KKiQVavE2fEeSMGxGpt0Vz58+Iw9CGjJpHEmuEQWbEuNwFueTBvKyw9VzvILVBijLzFwmSinMdWa/vyaLYMVbTGt0hc7VqdV57fU7/PKf/fP8+m/8NV57+FaDie06WRRbLtB5iW0FUB1aJ2SLX21RvwEOEzf7G8FQT9DOteVw9gXE07i88X+xTQX1uO7m4RwGRcQxNKDgAlG9NldtDu9ncy1WD+exEX2tmGEaUFBFSDmTBj26nZdoYVxinVgBKjklUop+T/eKWWFZDS7xc3SqxtirCHMhOkNtuQHAo6bSgvvLC/aPqzUgH8cUkcEWPZ1Yc1I2oO+gGg5YFY6wX0Qw8+bWrs3RzIJFw9kqsngkw4XaIDoK1QyrgY0Xx7Q3O7hQ42YAHLxda01xgK3P9uaNEl1dXV1dXV1dN9VBZVdXV1dXV1dXV1dXV1fXF6Bp3jGmNe5KLYZVAkiKIEmPLjwVDVBjAYhENOJfXRoImRgxNnLgXAtnkhkZAW9ASHBLXH1yxdMf/BPy6Zbh5JRhXGMpITKQNGG1ou6QFG9uxkYXAncKN0CMUa1QLeMqrdcPFtCJg9UAnwv4q1abS7PBu+baFBGsGiIWkabtOAOSeKMkc4BNDZeauLTeyoAvAZ8aZKG57swbhHnhQRXX5qb0iPps7k5p4DOnIaCmL042OUK31eYOdX/FIDuSKDIU1oyICU+fX1LcqbUylT2ixqCJ7IZrxmul7p9TdxfUUpgPe3bPnnJ18ZTLp0/Y7a44f+UNhmFNrYX1ao25BDpukDHrKcNqBUkoVpE8YHKNXILowDiuWQ9bdlPl008+QKSSVwN5tWWUiDiVFFZIQdA0ksSp09zOzgwqVC8c5n1Ayjk6FUWJqM9qzakY3ZQCPHhwh3/t3/i3+eVf+fPcu/86SzdjXGBFg85hAopiDRYL2uBcRQlIfJwPHvGtKglXmjuPo9Mvo9QFNEqbr0v/ItqclB5gcZlDrR8z4on9OJdjrIJLak+L/eKg3s6/ZbAaXZnmxzhfISC7N+emLQ2ZXsOparU5FZd9KVZLrA/z5iS0eI0FzFviW0uN6NdanJoDftZ2WO5ADQZcxKlWMQz36OWspYYbN40NGMoRplaf23oWNCWShpvSzI/QVlQRc6oZmlK73cFZVlPzQrdjX/ymFmuMVmupglusZKM2vPnCIa0CVQJ4Y9pe2dXV1dXV1dX1z6qDyq6urq6urq6urq6urq6uL0IOXmn9ieEKExTVTJlmUD3CALOK1NrMgC0P1g2YGHxiK3vOpXBbEltZNWAniBvVKybKPCUuvv8p460fsNmesRrXpDyQNeMpuuWafTHGF7wxYESNCFCJhj6qlOCBCAkDSVQv7eeESW2ALWIhUSGRA8CK4bbQloBHKQWIkaChR9eVSwOTR+C49FE2MOIBPiCh4q0zT16cpxYlG7GigqaIGQ1wMjRo1eAqztJfGa692lydqUVrGnr2gMOzH7FZZdbjCSpweusO9tEnXF78hMNhR86ZrAlVY0YZyEy750iK+NV5f820O3D57AlPHz3i+cUFm9tnrE62ZAWqRv/ouCGLBGQCxu0pJ69/hXp1wf7qKYiyTiv8yadYmUg+UKcJd7ia93z82cdUDNWB27fvRNSuF2qp5GGLJkc8UadnVJswd8pcqaXgplQPL6emxHa7ZbvKvH4frqvx6dNCzsobD+/zW7/9b/Ibv/XXGYYhHJG+RLGGS1ZFqG4NatUGG2mdpDXcfvrCqScqJG89rNQW/xrg2Ky2zkohOUf43fZEtQLqrYoyYmRTA+e1OUERawC65a022LkAVZFlLlWSp4B/1ICZbm0+tOzbBrp96XdcnJttHQX8nJuL0oMsujaHY4D8gItLZG2o4swuHIpTirCqvhhPl+XRJEd4a+7UOuNWKXVmngspH2I5i0UP6pLDKh5rYYG40MA9R2jpyjEmtqHWBjPbGMxwjzheZ1lH3qBoOK6j81VR83CH1xLva65UmyJ618GlWUW7urq6urq6uj5HHVR2dXV1dXV1dXV1dXV1dX0BEiIe0lucpXhCJZFSpsiLbrqlKw6P7rkkGS8V/MDoUzgp5Zq7IqyIyNeGKRuYaQ44hP0VPP3eD9mc3WE8OWVYbxEVsq7wdMSGAZRIqFnEvC6ddIQbDYtOvlqNpDn65Tygh8sCqqLzUaJCE9HmN3ONHkexyMIM0+cxapIlWlQCaMSht77I5vaKmNmAYN7cd46Q9EWPYESnpuO4QFskZcA7bbmyAVhS2197qThKChcnUCXFuRwztr7H7vmHpG3i9PQMzZn1as2FgVWnTDM15Rhno73SAGotE4fDNdNh4urZBU+fPEbymvO7D1mNa+o8Uw4Tc8rknEGUeZooYgx1zdWnP8ZrZZ4m5mlmP+95+ugptTjjuOaw33M47MBhmmeeXFwg8iOSG6dnt0kJyAOlHJBaKGaUuZLSmjo9i7GXBtHc4pymgfOz+2y+subJs8f8/vuf8dqrd/n6V97ha+++x6/8+m+xGteoR0eoE3DQaR2rzYkX5z23XsQWt9rQtptHhCiLw3CJhU2o67GLUtRQC6BdzclpbKDMAgQC4o6QW5SvHVeCqh/diCIp4KNA0hYd7EZkobZ4VGK+I0efZLhAG9AO96bzYqXFnHRv0cNSA3ojuATYNK/N3anN8OkBX2t0SC5OXgj3ZClQrIG8wo2s1/atNjBoNAj6ont1nifyMCCamw0znhNVnoqKklNiSDl6LdEWtVvRBhytxTJ7i8jFDZfW00nA3cXV7K4oiYqTJKPqATktfJZmNdzPvJgTcgSUenQ3d3V1dXV1dXW9rD8wqPwbf+Nv+DEShvhHUvwRU5nnmc1mw2q1av94mimlkFKKO9gAVSWl+EfK8lgpBXePMnARVJXVasU0TQzDEAPOmWma2O/3bLdbxnEEOI5jeV1KiZQS8zwf97eMcZ5nVJX1es1qtUJVqTXK5M3suK+bY17GMAwDKaXj85d4kpvHthzDMAyYGaWU43m7Oc6ccytv9+N2lnNaSjl+r6o/db6maYp+kBvbyTnHPyDb/szseB7t+EeAMgzDcZzL9VrGdHN8i5bjXbazHBvAPM8/NcaXx7s8392PYyilHB9/ef64+089dvP3L4/r5niX47l5/l5+/ObYPm8bN78uz/m8Y7v53Jvf2//NnYEvP//l3y3X/+bXm3Pi847tn7fdl3Vzey8/92f9/med85f3/4epz7s+/yL6wxzHv+ixv6zbt2/3HJuurq6urq6urq6fknhADCP65RxrvYrL30wVkQAu0Rup2DQhYvi8Z/Q9W/bc1j3nIpzICkMozeGUhfAfNsdWdaGYc/2TA09+//dYn5yy2myQnCApSUYkJWqZou/PFLvh3lIJwJg1U+oMkvBaIeeAJBJA6QW6ib811MMRaR6RqoFEcgBUr7gqS6RtkoiuXKIi0YC05ikgUnOcetKlWjJAF454Jmk4vFBvrk0C1EALqWygE/AwTiJLIWGDN/Hv/Tho8xlpsaSRZOoMp/fYzQc+e/wxh+tr1pstlxePKWVimhJDNua5YlIwc4pOaAFRZZ4OHK6veP7kMz756GNqHnn3vfc4XW9Jyam1QHKeXnzK8+8/5erykvVmw+ndO9RiDPtr3Ix5KlxeXPDJpx/w6OOPY3+rGRen1BnDUEuYCM+ePWU9JhBjuz6HYqTBmUvBVKjTTN3P8RmAWfy+VMoUsa9jHtic3WJarXny/Bk/981v8q2v/xyn2y1f+aVf596rb+G1XbMGrjCHJOAVb+7IwHvNbbj8rWkN72n0h0Yv6tIzecPxJ4JgJDJkjs5Gt/DA4gHdXK1BUW89pg2AmQdiFEd0bDCcmEBL6KikmK9ogEF3jBLOYMnNzTk36g4pDW3uLdLjOokuyJhHATvDCukIbkatpUXMCtXDtWhHoB7TrwDVI/41KmoXp+iR09/gli+crOHOdKqVOE9W8XbDQ7zfxFeVBBZrU1C0WruBIJ4rCuqKeWkQ0aNrdNmv2NGlurgq4zpxPJZwP7fPbNxjftSKi5F1pHrECov7jfPY1dXV1dXV1fXT+gODypzzEUQtX+GnAaSZHf9bfr4JAW6+bgF/8AI6LBBtAYwQ/xhbQNyy75tg6eZ2l683IdMCw5bvb47tJkx7GSItx1tr/WeO+WW4cxOsvQyBFhC3nKebIG/5/uZrburmOV5+fhlULdu+ua3Pg5Y3x/R5oPLmNVh+fvmYP++/ZVw3n/t52/3n7fvzXvcvo5uw8+X58LOe/7Ng383f39xmV1dXV1dXV1dXV1fXyzIKIISxK0CN41itAUDqDDkAUFKlThPSYIuW55zwnAd6xS0xNrIBhIOXcHy1D/61ddMt2wbBa+Lygyc8Of0uebtBxsQmPwyglyJKE2kAwyRcWhqQUhGq6hFaznVmtBH3eGxJlgRpfZIBOMwqSXMAtAb8Ag0OcR6ccKlJc5daxal4c+Yh4fBLoggZpLnxlr/jWufe0n8JjikkyTQ7XGyfcIZK+2WApjieMD86x4ZMaa46bzfwujRnpLK98zplfc5nH32X8uhHXO92gDJ75TBdYTYzDpm57ElkfCrYPDNNMxdPPuWTj94nbc547+d/gdOzU7LT+kkzOsI4bNn95GMunl9yOExMs3N1uWNcR+fg9fUlT58+4dnzC66eXLGbd1zm52zPzpAMaViTsjLmgWGVefTkEeNqTZKBtFphIszzgVoq0zxxOFQO08Q8T8zzjmqVuU6YG5vVipPVKULi3p0HnNy6hWri7htf5vUvfSPmglg7n82HqI4KmGqkFC8xvBDgXGI2odKiV1OANSx4tAvVJ1LKCEr19tlD27ZbiyOV5pqU6Gs9gvLkJJbPVAxNAR/jI49wHarmSE92xROL7bdFrHqbNy2alPZ5lSdEpbk1vcFDoRJdm2EgzXEzAYYLLyJl21jC46kNfC6fZTXXMIur0JkR5hquylojCrmx91g7xypVx2v0UzbjLhGp6+1zttietwhmQXGX+PwKY64lxtPOozRXptncaL40l2t8ThXOSI5ryMOiGoBYPGJ1aTfutzhbF2+xuvLChSkvOner2/G5XV1dXV1dXV0v6w8MKhfQE+Xh9lO/u+mUvPk4BBDMOXa7QL/FfbeAzJuQbXE/LvtSVeZ5/qntvgyMlq/L9pb9Lbrp2LsJUxfouTgph2E4bmscR6Zp+pkAdIGqN52VyxhvgqzPA33LOD/v/C7bu/n4TdC6PPflbb8MK29C1GWsn+cwfBnifZ7r8iZw/jxQuTzn5e3e/Pqybo7v887RH0Q/y60IHF2z/yK6OZ6Xgef/F9XBaZeI/PvAfwr8B+7/F3tvHmTJcd93fn6ZVe+97jd9TM+JwQBzAMQAJEiCICHKJAHCEkQCFiVSJh30SlyLsVKs1mutZNrh5Vq7tmXL2lDYWkdoJUd4fSjAlS3aMilQEnjBAkBhSUIEwBsniQFmgMExR0/f76rK/O0fmVld89g9wMyAAgjVF9Hzet6rIzMr62GqPvX9/vTW89zGEQBV3f9StasRiMiNwN3AP1XVX315W9OoUaNGjRo1+r7LxMjGGOEY8JhiMoMbBXcZTsikjS8K1BUIBZkWdP0y21lml/F0TQuPoeejIwrBpxBX8WRYPIojODRBKPsZy1yTNskAACAASURBVEeeo711jla3S9aZxOQZmTGoVWyKk5QALkWDIyrABYcYi/oCVXC+jCAoOKaCo8zFmNgarJEQOylkAbZ4F7YfQRUkcKGEjFKJaZXleoyqpHqBgMZIXEn+x+DqTKzUxtjWaA9FklNMag8zGxO2HehYaIek687g4kubNrKezCliaG+ZYudrrsO5EUsnnmHpmW9jM4O0MlzpGA5KjAnxpG44ZLQ2YOH0CY4fP8rsrr0cfN0bmJ2ZDm4/Yyi9x7TauMJhvWfv5fu5+Iocg2U0GLF8eoHF06cZ9Pv0ej36owGStWjPbCFjgtIXOEJdRTFK3umQtTtMTk6gExMsLS6TZS26LQuFw5cObBstCtb6K/TWVhgUA8p4nK3NsN4x0ZmkOzkVo1nBeWVq+y4OvO6t5K1WuAeQKcYll6SPEaKh5mow+0nlMPSEZSqgLSY6KYlHLqUWhahRJx4rGZ4C0QzvfHTZBggnCS/bANSsyaK5MMDS6pgieBNhoBjQEqwN8NmG6GVfuz/gfdgPNtS+VOcRCU7NEO1qItRP7Q7zQsXH+psBYSZ6H3le8BrHdZKT0nsXzlFfkvy8ilL4EAHrEazq+tcF4A0RAodlnZYRIqZ7WDFGNwxCnMsJxccV4/dEypL1rMNNkRAFG2rEhqjbUC/VVw8hqC/DZnxwUWqMt011ZNOZmc5rjcfdQHUuBje0D+d1o7/0Ot/7FSLyq8A/Af6qqn7h+9G2Ro0aNWr08um8QWUdMsKZjsTxaNHk6Bt3DtYh3kaQrQ67NnMe1iNdk8ahXlo/OSLrgK7uqEzrju8bQrRrHXjW40BVtYKY9TGpt318+/X+1j9L200wcDx2tA5hxwFoOibj45DclPX16s7OcTC4UfRq/fPx3+sad16OH4/6uuMuzI3cinWYeyE6F3g3vux4+8fB5UbLvNLUwMtGf1nUgMBGjRo1atSo0StKuv6LqMWoRXyIzTQ2w7o8WKjKAC9ER+Q6YNqvMMsS26xj1rbIRRhGA5jBrMemCqFeZQQQTqHQEAkLhuGysvSd79LqTJB1JrBZGzNlsCbU/as2IqHOnEanVnBJFqmUH6qhzqDU/7M5iAtAKWRRBueiycE7AuwQhBylDPGPcRsoEW5moA6RPMCMFHdJAFcq0ZsmKTrWhvdEUO8qMBktq2EZAyo+LKtxPbUYyUjxnCIG9QkXWUTWwQ0ilTuT+F5uOuRZjrV5vF6GsDmDsQbnSkpR1karLK2c5pJDV3PxgStptzNEwLRaGHIyE8CPzaYoigGZDTG4WTZB1mlhM+jYjOWlhRDLWYZoXucMo2KEFILNM3JryfM2rWyCVquDMRmtVhsmJlheXcG0MlqdCRCLcyWDwYBef5VRWUZXo6JaRrefwY88rlOGlCsRdh98LZdd/VYmujPBAWkllHckC45gGVXHkAS9iHMJiW5YE38n7CfaBMWE+qqqHrABDKvidBTuT4gDdcG1mOp/igHnUfFYEzB9OI4xThkbnYSWVgShVE5cm8JZg+vPu8qVaIzgXWijEUHjQ/RGLNbYAFIJMNWYVFKICAUl1Hk0AWYaCfNp/b6Vj5M51OpU7/HO47yvvhY0nq+lg9JpGkRiCmzlrAwG6HTPJNbhFCjdgLJsk2WCujLC4oQ1BefLEMcMlQMbFGtiRG2ElOpTbc7gag7njgvvS/h+iQcN9S58R5gM8cHBHB4oMBjbwhE+V4m1NOP5J96THito1KhRo0aNGjUa13mDyuR0TD/AGbGoCS7VAdO4o2+zSNg6YEt1HhNAS+7LjSJOkzaKe01tqUe/pmXH21d3E9b7l2VZtXzd1ZhqVSZYWq89OR6HOv57vc+b1W6sty9td7zvdYibwGS9r+OAtP66EYisty0tV+/zZoBuIyC2WQTsZvvaCGKejy4Ezm0EI+vtS8u80gBlAyQbRd0G/Dnw3MvdkEaNGjVq1KhRo7/MMmIDKJBQ187FZ1pVg/PQiMX5AU6H5CYnZ8i0X2Eri8yYkmmT0zEhktGkiEX1OHzEQOE9C5QRVCaIAYJ6S//kiKUnD5NPTZG3JzCtUP/R5gFGBJSQ4STUuzPGggrWGpzzoUagBteWxvhVxIc4UI01B8WsAyHn8BJgT/BSBRhiUg1OFEzcrtcIFYPrSyREaFojsS1hHxK9qEY8HkU0xsICPkZRJrgSQGiImA3wESQLwM9UUCnCMhSLAZMQSkzQCX7NCGECiPN4nC9QWhiTYY1g1JC3WhgjuLJguLrGnoOvYWbbNrwbURQBhBrKmNi0XsPQZi2yvE1rYgsmzxkN+8GF6MB223RHI4pyhCtKSnX0+muMigIxJjhVVTE4vBsxKjxKzmS3g5TK8vw8W7bOIllGUSqD4RplMaQ/XGU0KCKENaCWickt2HbGoBixZW4X+w+9iYv3X03eaqFaxihcYtvLuF5wqIoKYgLwSm5XUIzaUJs0OmhNOAHCcVGC+1GCyw4TQLfi4hw3GNHozgORsHUx1RGK9wsIcck+VkuVsP0E3lUsubSDg1CLeCwDfAx1HePciA5eYwSXSgtVYDw9zG3x3pKAOKqhxiXEeagV7DSsv+81OJK9S05gT2KfxJdCg6vS187dyCMxHspofK4clEp8A9SHmqfWttJTBqE+ZHRGegkuRu/LcG4R+6Jl5bYEasBf4+fh/Maayj0b8GoY3/qD8GE8PBVnFUHI4j7DAwW6TqnP85u00atMzf2KRo0aNWr0PTpvUDnuiAQqeJZqPG62XlmWZ8DCBATrNSLH6zhaa6sfWIebad30fr3WZYKcab/AGdtIqrsInXMVkCzLcDFhjKn2U18+wcm0TgK1qb3j41R3MtZdjmm5tL2627PuXM2y7AwImVTfft0tWkWZjLkm0+tm0HK8XfWo2Pp647Uyx8c0ta2+j/pn9d/r+94Ifm7mqDxbNOw4gB0H4S+0Tr1v4+By/Bi8mHY0avQXJVVdApZe7nY0atSoUaNGjRr9ZZf6EMjqVdadRj7c7PfqUV8CQ4xCB89WXWWbrDIpjkmTk0f/pMFhEXKBkRiM+sptZQigwWiMn4x4KCIdXJGx+tQ82dRhss4kdCyTdieZzRFrQSwaHZoBFAqiwfGJxPIn6gOUshZjImCSUNfSqI2gEQLcW6/DJ2KCg83IujNMo9POaNynDaAzRsMaYyvAhQpWpAqXTGBRQ74sDo0VEwNwRWy4PkYR67ARzkjCumLXIz1t9P8lV2mowBmcZRIfAsZWQMqrx7kCkRYiBmtyrBVa7Q5ZbshkBjd05K02o2JAMSwZrPVoT3jyiQzn4n2KbALbaiECuW2Ttzu0u3NMTilT3W2o94yGPYphj7IsGQx79Pp9emsrDIsBxaikLAuKogCFwo0ofMHq2iKLCyW7du1FnMFpSWZztBwyGPUYjkbhXokRgpEyXMPuuuQyfvhH34eqkuftUPMTIkw0EXyla2pTHdfgolTUhTjgAMp8rBKqiElRv4DY6MD0EeQF+qZGcS7E+6YZBB7vIbPhiCBxNkl0Tioxojbsx4qE2quR7okKagLIDvcZ4noxftThK0jtYm1SS0aZ4o29ROvyuoPRK2ENTwVBNbVXXYS3WkWwqkanZ7oHkcYMU5lOk0kxGKoVVwitjOBsju5pbHh18VwI096SRjmOEKolTh0qEaCqor5EXPBNhp3FOq+qFSiVdG5pOqYJNIfzxXuHWEHUIOoCcjaAtzgf7l0574KBNR5/g+IEMmuriFkDWJuHOpWN/tKruV/RqFGjRo020nk/zlR3EyYwOB4luhF8qrsb03bq7ssE3cZjZOuOwwTsvPcURVGBvATx6pGz9Z/6Njaq8zjuQqz3adwdmrZfj7ZN66W21N8bb3+WZd/j7Ez7SO1PY5tqfY7XvBwHeCLrNS3H63Bu5Jocd2LW/56OSb2f42OatpH2MQ6u6/OkHk27WWRs3alZd7JupHEX7XjfNgKndSC9GVQcd3G+GMcobAxkNxqPF6vNxjF9tpkL9kK00diNu3Y3audmP3+ReiW04fspEdkvIioit4rIlSLyKRE5LSJrIvJFEXnX2PIfjst/eINt7RWR/1tEvisi/bid+0TkH73Itvy0iAxF5BER2R/fUxH5wibL3xo/33++/XmxEpFbCbGvAP8k7iP93BiXqcZGRG4WkS+IyJKEXKcz2rbJPr6Qlt3gs3eJyJ+IyIk4Rk+LyB+JyE0vou0dEflE3Pe/FmkeN27UqFGjRo1eDVLWIxMTHRBjMBhwJfgRxpfkusasW2AXq8xZx6TJMKRrOoOpUF2ICg017TwJ4aV/OJR4Cg1gJewxAKBykLF25FlWjj1F78RJhivLlMMBvkxupxCvqj5wFxXFqARoFY1UvhaPamyOiMViMUYiiJHqc3S9TiSi6y6z5HAUiVGZgpEMQ0ZqsUaQogQQqaTrowhiRRDJsNIKri8RMJaQzRnajontluRki+NuLdZmGJOunfOAJq0lGOlMZfoKwDKCVCPkrRaignOjcDytJW91yFotbJZj84zprXN0p2eYndtFtzvF6vxpvnb33Xzt7i9z9OHHWHjmFMsn5umd7jFcGFD0PMPFAaOVPlparJ3EZB1arS20WlNYaWO0jYyEXFrkTCDe4kqhGHjKgaccOEZrA9wIvFg6U5O0O50I9KKn1TmKskSMxeQZJrcBoosws3UHWdai0+6u1xmV9fsJiIkxpMkyF2Y2EQJqWiyOler6+kZMcGGqRpBoapMgbEOU6DoObdXYblSqxYj7MWKD4zfCvrAtxfsyAkmN0bI2+jhDJKlIctl6rDERiko4xyLQNGoiYHTRRSrRmmwq2CcpihgbYl/TeZkgbnxYIJLQ8FcCuHSuqLZbNT+eoyH6NcTA+vh14SPMDFM/WC19jOtV7wJERHAEZ3IkwaSHIILj1IZIVhMAZDhdEhKObU2Nraye1U7jfQhC7KyROLZheSOhxqxIgMnBgZqhEh8LkHhKGgkPFxDqfzZ6dUqCfllEHhaRgYg8IyK/IyIzInJERI7Ult3wfkVaTkSmReRfxd8LCbUpGzVq1KjRq1zn7ahMMCu5HxOIGo1G5HmOiDAcDlHVyqGYICBQAcZ2u02WZYxGI1qtFs458jyvaj4ClUMzORuzLKPVatHv92m32zjnGA6H1fpABeystZRlWTkLy7LEWnvGemmd5GZMbW61WhWkTOAu7WM0GlWQSGrOzjr0gzNBax3S1cFW/f30muBvgq/p/XocbQKHIULmTCeniJBl2Rngt+5QTX1O41pvU9pmOn6pDQlGJtA6DjfT9lJb622vw806wK3Pi7RsHZbW+zIOVpPSenVQnObmOHjeSHWnq4hUc7Pe1rMdqzSeyVWb2prmy9k0PjZpDqXzII1/eiigvg5QnWupr5v182zQrj4HzrZufdvpODX6C9cB4F7g28D/A1wEfBD4rIj8tKr+l7OtLCJvAT4PzAH3AH8ITAKvBX4V+LUXWP9/BX4D+DLwk6p6+kI6wwX2ZwN9Kr7+LPBnwBdqnx0ZW/YDwM3AZ4F/A+w7x32dIRH5p8A/BlZjO54G9gBvAz4E/OlZ1t0K/DHwduAfqupvXEhbGjVq1KhRo0avHIXIxOBEQsFKFuq1AahD1JEzZIYVtknJdgstMZRKhI1SJTTadC0Ztxvci8m7qNUenSoF0EqgBwE19Oc9S4cP09oyRWdyC0WrTZYp1kT3pEp0gCrWW8REGKEFrizwvg02XqtlLTIJkZ/GWNSl68HQWGNNjOgEVRvdYBLhX/BBigaHpPNl2IYKmYkuLBNhZ4SFxkQYYmwEZCHyFQK8Sg5SRTEmwkwAsaEOZnpwuLqmCTBNBYzm1TVhcuBZyXHEWolxW9a28REYiRWQEGPqVciNod3p0mltwbmSohjRaXfZvucSvnHvvXzj6w9z6KqruGTXRczMzjG1bQedfIKJ9jStTptWa5Est+GgC0iWM1hZY+QKRqOC/qhHv7/G8soSvbVlBv0BvcEax08c48T8GnPdnGve9kPsP/QapmemWe4N6c7MQka4V9LZgrEraAmoJzMZI4ITbnprdNcaWY/yREOsb6pBKAJ+HYiJGJz6yvEIUgE+kTQPEjgzrNPfeF8kcUs1YHwKIAXi/QcVRH1w4oqvaiRKKtwYva+SXJTGYFSCqROHNRYXLJthXQJoUx8gorHB6YsaSlcEoiYgXmJTI5Q1AsSajRJcuxU8DIgzQFlc+ls1h1LUanDhxvls1oNhU389UHgYqdL2gq99SgSXEOp8hjqSLjoghdI7rCvIbbzvYMBKiJkuCWBW4wGRSP9FwIqN3y+hLqyaEJvsI9jFaHR+U/VFJILOeK8m8OPkVnXRyVmSYnir+wjxuBsjeF3vfaNXnf418LeBZ4F/C4yAnwR+CMiB4kVupwXcRbhncQewDDz5Uje2UaNGjRq98nRBNSqzLKtASYI7RVGQ53nlwAMqSCbR8VcHYnUnYR0KJddkURQVfEswpg4DU63MtI1xKJX2lcAjULUtgbsExcahIJwJeBIcTECoDvvSsumzoiiqz+rgsg4S61C1vo1x12S9TeniaRwMJni1mZNs3ElYB6jpeNVBWIKU9fGs76vet81Uh411ELaRM7A+juMwd/yY1IFmfXvp+I+7TOuqj/Nmy6QxPhvcHFee59X4JYA83t+NVJblGVHD6TxI51UdktbPoXTMRqPRGa7fjfrzYrRZG8/1/Ubfd90A/Kaq/oP0hoj8DgH2/RsR+ayqLm+0ooi0gP9K+Af/z6jq7499vneznUZ3328Bv0iAmz+jqoML7QwX0J+NpKqfEpFFAqj8gqr+6lkW/2vAX1PVz51f09clwQH6jwkXUNer6jNjn59tbPcRYOnlwH+vqv/pQtvTqFGjRo0aNXrlyEgeQI8GJCEImWY4NbQsiBsyZfpsZ4WtkjEhWYAMGuvyxT8DlElgDpIfSwkA0yJYNYzU4YUAmQSQFAMriFr6z/dYnn6c9pYpTKfNZJ4j5Eg7w+NjO0PUp5EMCNe/XgHnURsfpPQebwJ8QAmg0Wjcj6BaYiRDz7TbRaOWjZAquiolOjgxOO8DMNMYrJkecBVPFQ4a/1BAJNa8FAtSjygN7j6RAIWNWd+/saEOIngi/4zt1CqK06nDa6yxpx6DIW93yfJJUE/emiS3OU5H2DJDWl1UlbwzgfUhFtcNh2zbuZsbfuzHwVrYfjH7Xn8tWTFi7vKLWHzoKYrWiGFvFbsk5HkLdY5yOACbMXKeYTliUPTp99bor60yHA4odMjK/CLPnHyWR544is06vP6v/hWueP1VzM5txfuC9vQWZndezNrqaWw+BFlFxWDEUpZDyCyKJ8vbTM1uxavDeItIBr5EJV1bZngX6mH6WGvUx/jOYFYN16vxLg5qPFYjxCWAsExyklPWq8FmMfZYtXLEqnehLiXr90tCvGoZ5pMokqCzKhqhXSBvAYpTuQZNmL8RoqYHBQQPEmpTGmxVx9VGh6YXkCxDfYDvmdgKkHpCndgwpzyeElEb56HGINZ1Z7EquLJEy3BOld7hNNwrSK7ReGIA4DQ6Km0cV4j1Oan2gXq8hvhZJdbTlALnDKUbxYV9rHWZInfDeuF8COem1/WKk6HVpuoFhNqx4aEAwQQbawCdGp3RJgFKDxKiZMOcMFCrExvuqYTvE4xFnRBq4jZ6tUlEridAyu8Ab1XVxfj+rxAe2N0DHH2Rm7sIeBh4p6qufR+a26hRo0aNXqE6b1BZr/OYIliTAzE5JJPq7sLxaNhU/7AOmRJETNtJMLFeA7ION5Pjrh6nmgAmcMbnzrkKfrbb7TOgVP33caBVB5BpHwkMttttANbW1rDWMjk5+T2xtBvBuTr4G9/fOJirj2Ud9HrvzwCM47GX41G3abl6m8qyrI6XtZZOp0O/32cwGLBly5Yz2jEOgsedouOQuN6/LMuqto6P60b9rC8z7vjbDCiPOzHPBibHQed4v87mMtxIZVlWcyHtO821zeBh3bGb4GTqR3L2jkYjnHO0Wq0z3KbjdVHPtb0vVukYbTROjf7CtQT8s/obqvqAiPwnApz7KeBjm6z7E8B+4I/HIWXczrGNVhKRDvD7cdu/Dfxd1ZesuMiF9OdC9UcvBaSM+l/i698fh5Rw1rG9BvgM0AVuUdU7X8zOROSrm3x05YtZv1GjRpvrC1/4wjmvs7Kyct7rNvr+KR2XRo1ebhkMqsFFZRBs6VH1lHhyHTGhK2yTVebE0LUWK0CEk0JybkEKT8wk4JkYRomqx2MRJNb5C/GvLobFOq3DPShHlpWn5mnPPEU2uYW8OwU2w2QZNstCDblAAGOUowRI5Uu8S75Fj6UVgJEnwEQcRrJ1SBJrTiolhgzvy+CqEhsAoFa2uwBLfPjNSLwm98GMZ1IUZRVua9bdYdGxiSQHZe06VwOcFBPqagqh1mUAqx4jFjEpHpSImgJISruqIkEl/N5qT5K1u4j2ccWAVpbFWE0hOVoVj81b5Brq+qmW7Di4l+v1Jo6fOk17xzY6uWHHvgNMSIupSw/Qe+YEw5U1Ji/ey+rzz3D6kUdozXTYMjeDP72An/fM7L+YteMnkYmMUwvPcGJ5nqdPneaiiy/lx274IfYdOsDEVBcVA1h2XHyQvJWxtuziA64lKhaMxbYnGBUDhsMhszv20N2ylQR+0eiQ1XgAouPOq0aYG1yk6/UXQ61K9a5yDPqI7ERiXcMEkV0CV/HYxf/CtawNzlivOK+o8SGylQyRUKc1EO3ompUsgudYbzK6IC02QFAhJpm6sE9R8EJm8gjpPOJD3KmJ95uMiU5IEwFq8ulGR6bGOavOYyQjxDCnQy/r+0FjVK4J+/IOX7owwiIItpotYftC6aEswWXBerb+LZBgItX3SEhmdeAtXgTnYqmeskR9jNElwFL1AS6KrMe4JkCvEqCzdy4+OGAquKuk7wETa0+G7xcX3aQSHyxQE2uUEhyfVjIwWYillXAQhCxE0Vbfao1ehfrZ+PrrCVICqOpIRP4h8MVz3N7ffykg5ct93fxqujZornfOTc14nZua8Tp3vZRj9kq6bj5vUDnu0EsgcHFxkdFoRLvdJs/zCjLWQVIdEI3XT0xutCzLqvcSpEz7TXDOOUe73a7cnXU3ZoovBSqYk9ZLLrbNaiqOQ7CksiyrfSXHJwQ3XafTqUDT8vIyw+GQbdu2VX2uu0dTP1MfN4OXddU/H6/nmeBfGoO6s3O8f5uB2FarhYgwPz/PzMwMrVaLTqdzBtAcB5XjzsoXA7Dq+x3vc72N4yBzM0i2Eays93Gz/dQdj2mdcci50fubKUHzurM3HY/NalXWt12PS07wHqiiihOUTOdGURQVGK2fY+cLEV/IOVnf9tncqI2+7/qaqm70f5AvEC4O3sTmYO+H4+tnz2F/E8CdwF8BPqqq/+Ic1n0xupD+XKjuewm39cOES/lzAZ/vAP4esALcoKrffAnb06hRo0aNGjV6hSi5KQGM8xhV2rkyNZExq5O0VwytVWWCnJwQ2+hiJGrl0GLdWVkHQGH78folOSxjtKOLLkhNjsqK3BhGK46lw0fIu12ybpfp3OLzHIwgEhxV6bpTACOC94rXAqET4mAlQad43YXFqEVQjHHB4agxujU6ukJkpSKSHGURaGmCV0QHWOw0HnWC2Dw61UwFbZAAgsI9gOg2VRvr5mlMGzWhdmUFRKMTTASMgsaYz+g+80RY5cHHeM0QrOtBFZtldLbMUCytMhz0abU6ZDY4yFQ9TodYn0f3psfYDOcUQ872Sy+l3e6w9NQRBpMtdl5yEd1LLsG22kxevJvprE33osuZ23857XbO7P4ryCbaLJ18luWTJ8lnZlnYOkU2OckTn/8O3S1b+PEf+RH27d/PxMwktm3BB0DXnd1GpzvJsLcSXIleGQ2GuHIUgBWCd8EduXXHRUxMdjEmq6BYuFbOUB/rIWq8fk6HSEx0Ewbgp6qB7ZowF6yxKbcYn1yOmAi043FQh9gc9S4ezwgdjanQsUQoKWIwxkbnbICW8e5SvB4NfUGIDwSkeogSAVqAaoYIEo3B+fVrWU+81lVT9UlikUWN8z9sXxE8NpDr0CsjqJoIszXCaY1QPgBYMRYRF89SDfMpDkSFt73gPJQ+GBhtnOMSpjIFUGoR7gmo4tWFsUhj6gMeDpA+xvVGV7Qxsh6dawR8dKJWrtO4MxP6H5oUHyTwNbisIBLqTHovFQTF2tglj1TPs8b7d2SVk9yJYO1534Js9MrWm+LrRkDyz4HyHLY1AL51wS1q1KhRo0Y/cDrvfyWUZUmn06niWvM8ZzAY8Pjjj3P69GmyLKvqRk5PT7N//352795dAcekuoMygZhUSzK5FxOUrDvGEmgqioItW7YgIhw+fJhnnnmGq666il27dlXLp6jXerxmHVrCukN0I9hV73MdrmZZhkioD7i8vEye5ywuLnLbbbcxGAz463/9r5/RjjrgUV2vPZjaBuswbTwqtQ7r6i7K1L+zRcKOuznrsDFtyxjDyZMnuf3227n44ou54YYbmJ6ePmP9FJU7ro0clhu1od7/eo3O8RqZL6Tx47IRLKs7S8cjUeswt97mcQA37kzdDGADjEYj5ubmquOyurrK2tpaNTc3AoF1QFmf7xMTE9X7Kysr1Vyru5bTHKnXHj1fWLkZpDzb5w2gfNl0fJP3n4+vM2dZdza+fo/j7yyaAq4l1IX4/Dms92J1If25UD3/wou8aM0CC6raP4d13kQY3y8Dj57LzlT1zRu9H58YvfZcttWoUaMzdeONN57zOukpxvNZt9H3T1NTUy93Exo1AlLEpAsEAk/e8mzfs4WLd29nmlX8Sc/qQ2uUaynaVCsPISQQmWBkgAYSHVzE5RLCjGylgpzrte4CNFFMBA4Zg/kBy0ePks/M0JrsYFodTJaHbUeoKJJFU51UrjBfBpgkNrqzgqUxtEM9iMGLYE07gCdVxKfQ0NSyDK9FdGQGzYboIgAAIABJREFUFx7p4Vc1OF8iGExMplEtgRhLqqHHXmJgZXQ8hsGOSTbiQWwFqlCPSlYNqqY/pJba5D0pprYsCkAwxlK6AtEQRysCrcmtrM0/xQQh7UYlRo2K4EuHZopzfcRkYCJ5krBuZ3YKPywoegMWH/4Os5deTvuiOaSdh/shvRVElal9l9CenkEQ2pOztGcKTJ7jfMHC4cfYmnU4eNlrmexuQVtCgSNvd8FktPJJJruzgOJKhys9o9EwHBtjoHYfRKxh++59SISZHkfw6hqclsGt66lgZYgVjY5UfJjbGuqYSgTXYYATyCPOyiArBqehzqNYqZaXuB1EY+RsmM0B8KXjZzDRAagSonhT9KtiQ/1D58K5JlJBc28C6HM+nVFS0Xyj4OMcUXycvxJAtfcR/gUno1areqJhMeFURNKZFs9ckQjk18/RKkLZa6xzeub3hANcGVyVsaRq6J0l7E+JkcoaIWyMa9UQKSu+xDmNsa0JwDpUPE7L2FitgK7XMh5v4g5sqOEZOhzGXMOxNzbHqMGLBnelCbVJvUo4nhoftFZFNYFpi0oRxlQDYAY33u1Grx6l6/bvub5XVSci8+ewrRP6QjepXqRe7uvmV9O1QXO9c25qxuvc1IzXueulHLNX0nXzeYPK5ChMEDBFVB49epTTp0+zc+dOnHOsrq7y1FNP8eyzz3LNNdewZ8+eCvDBmaAsRaWmiNDkzKy70tKTnQnOJEfZ6uoqjzzyCA8++CDT09Ps2LGjWi4BynrMpqpWrrR63Uw4E7CNA5lUT9B7X0VxOuew1lbQ9siRI5XDLtXZHId9CVIC1e/1n/p+61Av/b1e07P+k9x4dbA27lBM7Uj9SG69NIatVotut3vGchuB242cjuNgM/297jRMGm/TOFDcLH71bK7K8e3WnafjY1JffiMXZ5pr4/3ZSJ1Oh6WlJb785S9z4MAB9u3bd4ajciPVIWpZlrRaLVqtFk8//TTPPvssBw8eZHp6uppfIsKTTz7JPffcw/79+7n++utptVoMBoPKPfxSazNH7oW4NxtdkHZt8v7u+Lp0lnVTBMvF57C/E8DPAX8M3C0i71LVBzZYTtn8/yezm7wPF9afC9VmFz/phD2X/iwC20Rk4hxg5e8AO4H/CfhjEXnfOYLORo0aNWrUqNEPgMQIjEKEaacjXLRviitfu5u9F83QZsDKMy2OjxZYevhZGEUXpHpcJCPhn9y1KE2Cw6tytwUf1Rmxil7BiadMrkxZd14SHY7FKGf56ZO0tj5JvqVLNtlFcgM2jxGc4I3HGoPJwBeK8yXOl1gNdfywASaFFoIai4gBNVX9P42QDwXvNYJYV7VV7LrjylMitMlsqG0ZTF2x3qQxKKHuZQCSvoIvRNdaKOpHAJoVQI24TB3eQekCvBsM+wx6A/q9IYP+gMFgQK/fY9QfMRqOKMqCclSgAtaAzULE60Tu2DWtTHZKSldiMkvpPRaPNRbvRyAtxHi8L3B+FCCNMZhOTr61i5bK6PnTzB//GsOLTpBNdci2TDMxvYrYjGKwxtCdwg0LeosLlKM+3pUMjj6LWe6zc2YnpYHFwQJGcrrtacRmYIS83UZdyWjQo7/WY21tiWFRhnqGJtR9LIYDhkVBa3KWbbv34FwRYntRVIvgXNUwZ1JNRK/BjRvcpQEcagRQ6+A3zfoAxUlALRQBRfGkipYqGuNAoxNSDPgAslUdRNdecvuJd2EZCGC1guQEwKkmugXD5xBqtarXEIcrEdZ5CU5EX6IJJPpUnzHM19CZVI8yzEyjJsa6xgcPiPcPwsSv+mFsOEfFBKjqfHI+m2p+1i9C0pA5D4WD0iuZgkuQ3a1zvhQjm6JYVYPT2RCAuXfB2eudw2v4EYEsnQ+S7n2kIxTr0sZjKNE1GRzFrLuYfdxudB5byYJT2zisD05T50NtTNDgwMYh3oD40G410Q37vQ++N3pVaDm+7gKeqH8g4YTcxot/YLrh2Y0aNWr0l1QXBCpDrYNRBetSXca5uTne/va3MzU1RVEUPProozz88MM8/fTT7N69uwI0dXCUgGEdBpVleQYUST+tVouyLMnzvAKc7Xabq6++mrm5OS699FKAytFZdykmJ2MCYGkf6e9FUZDnebVecrnVI1DH41DrNSKT47AOV/M8PwOW1cevHhGa6mduBBVT5OxGwLNe59N7T6fTOQMQprYl4FXvU4qfrdf3nJycZHJykpWVFSYmJs5w7tWPV4r2HY1GZ0DJtL/UhzTmqd1pDOrHJ7UzHZu0Tj0GtQ7H6jGrrVarGrc6WKvXOU37SOslh2KC5iJyRm3VNNapn8lBnPad5koC9iLCkSNH+O3f/m1+7Md+jJ//+Z+n3W5XY5P2mRzEafupn2nOqSrf/OY3+ZM/+RM+9KEP8Za3vKWaV6PRiJMnT/KlL32JU6dOce211zIzM1ONTTpGaS4BZwD1dI7Vl687OtOYiUj1kEA6P85HL/QQ3AsB55dCZ2vDZvs713b/BetaEZnaIC71xvj69bOs++fx9Rbg37zYHarqnSJyM/Bp4E9F5BZVvXdssQXgkvF140XJNWfZ/IX0ZzMl2/75XgUvxNeN+jMNXLHBOn8OvAe4GbjtRe5HVfVvi8gA+LvAp0XkJ/QlqMXRqFGjRo0aNXoFSRWL0MoMuy/ZwtVv2sdll1/M3OwkfriKYchweRG/3Gft6GnUS4Xx1mv5eUQ8xgeHZsAiggtoCRsBpuj6+15DnTyvsg5hiP+WjfCn7FmWnjhGa8ssre5UcFVOKtgMazoYbIiYjGBJEBwONSHSEkmVMgNERWKtSBFSJKyY4FZEBGNy0BI0rB+uAROJCWDR4cK/5kyo8RjskglIBTtpuJ5MMNJgogUt9E0AjzEZ6pXSlYx6Q0aDkpWlNZYXl1hZW6bf79Ff6zMqClzpKEYDSlfiihGlD7BHvce5eH0uoN6R5wa/f5ZO3mViIsMaQZ3DGos4MJKRSxGOn0THaCA+CIZschLdJujKEDs0SCFMTGxHnFA8N89wZRlVx5DnKHsD+kuLeGsZrq1hRgGOro76lKbEtFu0pUWW58Gx2Z4izzqog3JQMBqOGA5G9PprlNH15oqSYljiS8OuvVcw2Z1BAUcZAFasS0m8XoyZROE4xfcjwoowmuh0dHFmQuIM4XiYANYlgDUxJvqGPeIEbHAZEsc4zHeLopRaYskQCYGsRj0SI2BDSmkAdNEGWPl1xZeRywVgqT6A1XRWQYjIDY7B9FA4AXh6wnwCQqSsxnkdxiZF5waUZ6J7V2O/Qt8l2SHjOakxBjftz8j49WY4i0qnOB+cikk+OZwVcL5yfirBfaqs15kMcbBx3DU9HFBGN2yqPxkqdJoUxRtdoybOURULUoY+pvUEnBaI2Oiu9fE8j5xWA5i1GmCqGIPxEiJ2tUQkw/sCweJc8cLfmY1+EPV1QmLQOxgDlYQyKU3mb6NGjRo1ekGd9/8skpMSqIBSAi6dTodut1vVcnz961/PyZMnmZ+fZzgc0m63K0A2Pz/P008/zfLyMhMTE8zMzLB7926mp6crF6S1lsXFRU6dOsVgMGDbtm2Vg2xubo5Op4Oq0m632b17N1u3bq3aZ61lbW2NU6dOMRwOERGmpqbYvXs3MzMzFWg9ceIEALt27eLYsWP0ej0Apqen2bt3L9ZaWq1Wtc0UIZtAT4KGqcbg7Owso9GII0eOsLy8jHOOmZkZ9u7dW0EyVWVhYYHV1VX6/T5LS0uoKrOzs+zdu5fp6Wn6/T6Tk5MAnDp1iuPHj3PixAkmJibodrvMzMxw8OBBRqNRBaqef/55jh8/Tq/XY3p6mosuuoi5uTmAavxbrRbPP/88zz77LMvLy1x00UWcPHmyihZdW1vDe1/BxLrztdVqASHu9PTp0ywsLDAcDlFVdu/ezbZt2zDGsLq6ypYtWyjLkvn5eebn5xERtmzZwq5du7DW0uv1aLfbtNttJiYmOHLkCGtraxhj2LdvHwDLy8vMzc1VQLDX66GqdLtdhsMhzz33HEVRsGvXLjqdDq1Wi16vx/z8fHW8du/eXfVhYmKiigzu9XosLi6iqkxNTVXHLUHkOgi31rK8HB4Um5qaqqAvwMTERBV3nPYxGAwqMFqH2Om8UVW2bNlSHbvRaES326Xb7XLixAlWVlbI87wCmyLC1VdfzUc/+lGyLGNqaqoC4KpKq9Wq3MhZltFqtRgOh/R6PSYnJ8myrIKuycXbbrcZDAZ0u12896ytrVVzIC27kav1pdTZInVfLm0GK18B7ZwB/jHwD9IbIvIW4GcI7sOzQbI/AY4APyki/52qfrz+oYjsVdVjG62oqv+fiPwYoQbjHSLyHlX9s9oi9wE3R8flHbX3/w9g3/epP5spxcpceh7roqorIvIo8HYRea2qPhzbZYF/RajbOa7fJoDK/0tE7lPVM54WFZGLx9+r7e8jItIH/iHweRH5a6q6vNGyjRo1atSoUaMfPAmezAhbt3e44rV7eM2hfey5aAdZ7llbGTExt5XZS/ajvT5u8A0Gz63gNUCVVKFSJKCk9ByWoBEeVGGTGCATsGopcXHPVFtRCaGeERFFd5RlOD9i6Ynv0p6ZJp/o0LE7MZ1JxEfnHA5jwGJRBBdBlffRQSga4GmEUkIeYI7V4DQTiy/LwG28C32TdXgZbGghDlNibcdU69DYUGMyRIsaxOi6Qw/FRKeimADLiJzSe2U4cPRWB8zPz7N4epm11TUG/R7FqI9zjrIcUIzKCIcKBE8xKinK4D50rkCdxjqN8WFhDK5wHDu+yva5jMnJPq1WC2tznBthJdSr9D5FdILNc4iAuSjCQ7GdqS7Z9A7M0DMxuY3u9t2Y7gSjEyfRMoCj3snncIOSfKKLZi2K0jEarTHQESPj8cbQabfJWy2MEWzWIW+1wStFMaS/1KPfX6E/GDIaDDFiKNUxKksKVyJZxv4r3hScf1UsaphJZzw4LQHGmRTnqqAJ3BFrFGoa//hgM4Kqw5pUn1QjfIvRoxF5p7KpJgLukDjqKi6dTJyaAByx/mg17zXWowzzx6RUpHCSVGegRMio3sUI3LgvjZBcKw8lqMN7hzF5cJPGeZ8AJyIxEjYAWNUIQxWo5mlwh667GANYFBEyY0EtUFRbBY0xqoSoXac4EUyY0sFdLVqNX3WtqoRI4gg6Q4RxPKeUEJ2MRc36qRbaaUBcONdQjA1zQH2IPBYjeB8idFGP96HWZaqa6wFi3VkxhLqvSIjt9dHlGV2cPt77SDG9L//ldKPvk/5f4H8A/ncR+SNVXQIQkRbwf76sLWvUqFGjRj8wuqCnWurRo/X6kt57+v3+Ga6xBOeSUkTqV7/6VZxztNttFhYW+O53v8ull17Km9/8ZrZs2QLAAw88wEMPPcRgMKjq9w0GA8qy5N3vfjdXXHEFzjkeffRRnnjiCaampti2bRutVouFhQXuueceDh8+TIp7bbfbXHfddbz97W8nz3NWVla48847WVxcZM+ePXznO99hOBxSFAXbt2/nlltu4corr6xccbAOLBLQSu7O5PpbWlrirrvu4tixY6ysrLC2tsbOnTt5z3vew5vf/GY6nQ7tdpvPf/7z3HFHuK+fQOhgMOBHfuRHeNe73sX09DRFUfDII49wxx13cOLEicr9VhQF09PT/OIv/iK7du1iMBhw//33c9ddd8WLrwBTd+7cyS233MIb3/jGqs0PPPAAn/vc5zh27BiLi4vs2LGDPM95/vnnKwdoak8CSfVamoPBgAceeIA77riD48dDDL2qMjMzwzvf+U5uuukmut0up06d4s477+SBBx6oQOXs7Cw33HADN998cxXfOxgMuPPOO/nMZz7D8vIyZVly8cUXMzMzw9TUFD/90z/N7OwsvV6Pe+65h0ceeYR9+/YxPz/Pfffdh/eeyy+/nHe9613s27ePP/3TP+Xee+9lOByyd+9ePvjBD3LNNdewurqK955ut8vjjz/O7bffzre//W1GoxF79+7l7W9/OzfffDOdTofRaMQ3v/lNvvGNb/COd7yDkydPctddd7GwsMCBAwf4yZ/8Sa666iqMMTzxxBN86lOfYjAYcPjwYT72sY8BMDMzww033MDWrVt58MEH+dKXvsTx48dxzpHnOddeey1veMMb2LdvXzWHv/GNbyAi3HvvvayurqKqHDhwgNe//vUVHN62bVsFRicmJnDO8fDDD3P//fezsLDA7OwsV111FW9961urz51zPP744+R5zp49e3jkkUd47LHH6Pf7XHnllVxzzTUVEM3znKIoNqxJ2uhl1T3Az4vIW4EvARcBHyTcm/qFswEuVR2JyN8A7gB+X0R+geAE7ABXAT/KWf6foKpfEZEfAf4b8JkYVfrf4se/Cbwb+CMR+S/AaeBtwAHgC6w7JF+y/pxFjxFiZf6miBTAUcI9gN9T1aMvchv/EvgPwJdE5L8CA+CvAjnwTeCN9YVV9Q4R+ecEMPuIiHwKeJoQffMOwjh/eLOdqeqvRGflPwX+m4jcrKoLmy3fqFGjRo0aNfrBUeahM2nYd8Uclx06wJ49O5mYalMMeoBgOx26u/bgR32KtWVGK9/GL4cb+iaCmODFs1jx2IhrpPovAAArBqNSxTX6UKEu/mlJdQN9DOVMaMo7S++5JZa2PontTGLyDu0dHbTlQELEqyHAFxEbIjA1RFyqKmJaAYYI2BiV6WPUp2hwrokJsZdiQu1AVY8XXznuLBYvfj2200SoFZ2SxiQUk60nJVFzh2qqoyj0eiOWFvusnl5hcfE0K6srDIdrFEWBdx7nRxSFwxeOwWiNwWBIf7jGsNdjbW2N5bU1RqMBvUGfYjhE1QVYK4bMGHKbc+m+nRzcdy1TvYwt3S0YWyJqKb0wGg4x7RBDakyONwWuHIJKqMvowEiLvDUBxlHaIUvPP44vS7Q3QsWG9URCTcBWG+dLSuPQNmjWAhfGemJiC51OGzBkuQURiqLPqD+iP+oxGPTp9VdDhKoxjIpVimFJUSiXvOZq5nZeFONDS4xYnJYYkweAR3BAVubBSIFFPN47rIRZmNyAQTHONZBB1JtEsrAhlbWK+U0zWMVVNRtVg5vSa4kRwVhidKpGRKkxZlaxkkW3b3DzhhqsNQerD/tSUcQrTot4DghaxmBTlSoGFe9wKiGiVMvQTrGp82HZqt6moiadRWEOK2XykcZxC+eciKlSlQDE2hpEJa5BdLUKZQnOQGYDtMxMeABhpNF1qT7Gs8YIV/UxrtbE+V2GMUvHTZPtkcoVGiBjFuCkSgVRQ+1YRSkjUEzAPdbN9WFfyaPtvYIo1rZwvgjnso3jKgGqGslwXqMb0wcndqNXnVT1z0Tk3wL/I/CQiHwSKICfIDyA/CzrJVYaNWrUqFGjDXXeoLL+lN14xKj3nna7TbfbxTnHt771LU6cOMG+ffsqB2Kqh9jv97nhhhvYuXMnw+GQ+++/n0cffZS5uTle//rXc+TIEb72ta+xfft2rr/+eg4cOMCpU6e47777OHLkSAVEAZaWljh69Gi4CPGe+fl5vvzlL/Pggw9y6NAhDh06RL/f59577+Xuu+9m+/btXHfddayurvL888/z3HPP0ev1uPTSSzlw4ACHDx/mvvvu48/+7M+45JJLyPO8AjiwHpOZokdTzGee5xw7dozp6WkOHTrEpZdeyhNPPMF9993H3Xffza5du9izZw+qytzcHO985zvZv38/O3bsYGFhga985SvcdtttdLtdfuqnfor5+XnuuOMOnn76aW655ZYKWD322GPcd999LCwssHv3br797W9z2223cfDgQd7znvcwMzPD/fffz6c//Wnuvvtu9uzZw/79+3nyySf5xCc+wfHjx7npppt43etex8rKCt/61rdYXFysQGVy3dVdZOmzr3/963zyk59k//79/OiP/ih79uzh9OnT3HnnnRw/frxa95Of/CTf/va3ufbaazl06BBra2s88sgj3H777WRZxo033khRFNx11138/u//Pnv37uWmm26qnJIPPfQQW7du5fTp0+zYsQNjDN/97nf55Cc/yd69e7n88sur4/rVr36Vo0ePMjU1xdLSEpdddhmDwYBvfOMbLCws8Au/8Au85jWvYTQa8fjjj/M7v/M7rKyssG/fPrrdLisrK/y7f/fvWFxc5Md//MeZmpri8OHDfPzjH+e+++5jNBoxMzNDr9fjD/7gD3jsscf46Ec/yhvf+EaWl5d56qmnWFpa4oknnmB1dZUsy5ienubaa68lyzLuuecebr/9dmZnZyvoevvtt3P99dfzS7/0S1x11VU8+eSTfO1rX2NtbY3Dhw/zxBNPsLy8zHXXXcfll1/OwsICv/Vbv8Wb3vQmPvKRj1Tn3p133smtt97KyZMnqzYWRcHP/uzP8qEPfaiKyf3sZz/LV77yFS666CKOHTvGiRMncM4xNzfH3/pbf4v3ve99FbxX1cqt3OgVoycJNQ1/I762ga8B/0xVP/9CK6vqAyJyDfC/ESJg3wasAI8TnI0vtP7XReRG4E+BPxGR96vqp2M87PviNv4msEYAmh8kwLfvS382aaMTkZ+K2/wbwBThUv2LBGj5YrbxuxK++P4e8LOEONg/An4F+OQm6/wjEbkX+CWCu7JLqPH5AOEJ0xfa5z+Lzsp/AdwZ3amnXkx7GzVq1KhRo0avXGWZsmPXBAcO7Gbn7jkmp7oYoxR4VDxZnsNUF929h9HqGmsnjjP87nEoAmCwooi46EoL15+ZCFaJaCQQCB/dTkYEoyGG0msAEV4UKyA1QiIVYLL4gbJ69Cna01Pk3S3I5AQmi/Um49LGWJQC73Ocd1ibgzGVnVPExu15JDrxQl1JjYzLIt6gJkRHGvIQ7RojJ/EhPjNRlQB0QoRrcFESYWlcLsXFKjivDPoj1pYLTp06yeLCImurqxSjIUUxpCxKnFfKckR/MOD06ROcPHWSE/PPsbi8Qq+3xlp/lVExIqZ0ViMVxik4B60omYG8NcCaH6LfG9DvDxEbxsoKOF/g6ZAhlEU/uEGNBYXMZvjc4IuSoljDRgw9LAcUgzXK0QBjJxAViqyALRlqPMNhD7Zk5K0t5H2lHDrydpsst9gMTGZweJyWDIshw2GP1cEiK/1VCl+imVAWQ4phuGeRT05x2WuvCy5IH+JO1YZeJ0gZHHUGo1mo9aggMYc0xf4Gt6Svjm81ctWhcQGkSw1mqgZQXY1tOOYa41CdlhgkRrLaAOxNcGF60TOcnYiJ814rqKriqS5fNUbYKpUrMtXbVI1tU1lneeoCXDQmOhVdhIDEWNXkZozjY1oBZMc6lCIpLYgI1AGUItWOjC7gdFqt+1jD+eu84Bw4B+qBLMBFB3F8BNUy1L7UEl+v2+njuRioPRJrbHotq3PeiKXQgqrerQToGEr4BNgpIuClinm1xuK8j5CyhBjLK2owRnEewGEwGOPxGsAsqhFCB2iqPsbQ+oZVvYr1t4FHgV8gXNvPExKSfgU4Bhx++ZrWqFGjRo1+EHRBoDLVpkywJD3duLS0xKOPPooxhl6vx9GjR+l2u+zfv5/p6WmstXznO9/hxIkTvPGNb+Tiiy+m1+uxdetW3vCGN/Dcc89x8uRJhsNhFQX63ve+lz179mCt5eDBg5w8eZInnniiitZMtf5S/Gy73WZ5eZmHHnqIgwcPcssttzAxMYG1lq1bt/KHf/iHPPzww7z2ta+t1t22bRvvf//7ueyyy5icnOTKK69kbW2NY8eOcfLkSXbv3g1Av98n1TRMTtIUz9nv9xkMBuzdu5cPfOADXHrppbTb7Wo/999/P8eOHePSSy9lMBhw3XXX0e12q4jNLMvYvn07jz32GE899VTloHvmmWe46qqreP/738+pU6dot9tcdtllXH311ezcuZPTp09zzz33sGfPHj784Q+zY8cORqMRN998M6dOneLBBx+s9vvYY48xGAz44Ac/yLvf/e4KRGVZxkMPPcRwOKwiX8uyrJyoCcqurq5y9OhRrLW8973v5dChQywsLHDw4EFe97rXVc7XL37xi9x77728973v5QMf+ACpXufrXvc6Hn74YR5++GFuuukmnnrqKf7gD/6A7du383f+zt/hsssuQ1UZDAb85m/+Jk899RRlWVa1Jo0xbN++nZ/4iZ/gxhtv5IorQsm4X//1X+dzn/scb3vb2/iZn/kZrrvuOvI85/d+7/f4z//5P/PNb36TQ4cOAXDrrbeiqnzkIx+pXIenTp3iN37jN/j0pz/NNddcw7XXXluBuj179nDDDTfwjne8A2MMv/u7v8vHP/5xvvjFL3LgwAGuu+46JicnefbZZ3nHO97BL//yL1OWZVXHdXJykptuuol3vvOdXHnllXQ6HXq9Hrfddhv//t//e+655x4OHjzI9ddfT6/X4xOf+ATve9/7eNe73lVFFs/OzjI/P8/k5OQZtTYff/xx/uN//I9MTEzwa7/2a7zhDW/g+eef5+Mf/zi33347+/fv5y1veUsV/Zpqxf7cz/0cV199NU8//TQf+9jH+OIXv8gP//APs2/fvjNqWTZ6ZUlVHwHe+wLL3ArcuslnTwH/84vYz/5N3n8Q2L3B+38M/PEGq3yYs7sJX7A/5ypVvZ/gEN3os1vZZGzGlvsPBFfluG48yzqfAT7zAtv9At/zHHX12b8kuDkbNWrUqFGjRq8Sbd3a4uAVO9i3fw9zc7O0WjnehQhQYyzGWKSV0Z6ZYWrPXgZXXMlweYXesT4aI05FBcThY/SrEYOJMaOqCibGoKZYTI34RjQGVgqmSqKUGoiLaFEtg9Mjlp58gqw7RdadxLYy1EyDDc43G52S4fogC4mtJovORkMdgQbnXYxnDSgkREiKIsZiNETPqmjsBxibB5CqgsaI11CPMouxl3Es4nWKFYsHipGnt1Jy4vgpFhcW6PdXGQ6HjIZDRkXBaDig3+9x6uQJnnz6MM8cf475hVPkWd/VAAAgAElEQVQMYvkNZePrHT3jtwSzEoTytFpC3p6oSmeILzFMhoQp53EEqIMasjyjKPqhjmUm+LLE+yI45IbD4Dpst5DMIGophn3KfIhIFlibBTcscEWBL0va7Qk6Ey0yG32JJiDPsiz/f/be7MmO4zD3/GVmVZ21924AbAAEQAAkQIiLCEriorFFydpMaw0vskMOxYTliInQy/wH42frQTfm0U9WxDzYd+yrkcOyHZavLVG0JK6iSQgQQRDETiwN9HL2qsrMecilCy0QoiD7WrbrYzTRfZZasrI6us6vvu8jH+X0exts9HtMJgVl7hyQk3xCUbio28NHHmN+cYd3MDrHqjtywo2z9ZXv1mCFS5ByA2I2Z441DrrhnIsOTjqC6PoanX/SGo2VwUMpsbZwS/ElkcbNTj/Svn/UuK7PcBQ8o/Ngzl+nCo/3PASVoQPTeqhpCw8qBcaW8ThbD1tDPK3rjFS4HlbhtkcIt30IhDMNOlAfb9a/GWS7ue47K5EeAnoAbAxKyIBsI5evnC0EjGoslJYIK5XyCbIEfC/Buj5QQq+ndeeI8W5Wd/7hXZ6QqKwyqS2JTPx+uP7RcH4Z7dynGOP2x8fiGh8PazzIDK5R/O8S5aNtwzkv8J8VCgd+pVLoovQAt+rlrvWfTdbR7q/5ryghxEGgC5yovPZPucU1+Tt9BlF5/o+AP/oFN7VWrVq1av2S6o5BZbUbL7i1QmxkURRcvHgRrTU3btyg0Wjw6KOPsnfv3uiALMuSwWDA6uoqL7/8MuPxmHa7TVEUEfD0+33W1tZYXFyk3W7Hzr/QDRhiV0PfYwBhAMPhkMuXL9NqtThy5AjdbpfxeIwQgh07djA1NcWZM2eig7AsSzqdDnNzcxRFEWHg4uIiFy5cIPQJrq2t8eyzz3LlyhWklEwmE7rdLo888ggPPPAA6+vraK1j36ExJq7j8OHDPP/881y4cCFG0OZ5ztmzZ3nzzTdZXXVJfysrK5RlSa/XixG0aZpy6dIl/u7v/o4dO3bQbDaZn59naWkJay0XL15kdXWV++67jzfffJM333wz9lsGh9z169cZDoe8/PLLZFnGAw88wGAwiJ2KoWex1WrRbrejoy5E+gLRMZqmKRsbG/zoRz8iTVNmZmZu2u9ms8m5c+fQWtNqtThx4gTj8Th2PW7fvp1+v0+v1+P06dPcuHGDz3/+8+zatYuNjQ2yLIvjE/oow9wKDsD3v//9HDx4MHZh7t+/n4WFBZ566ine9773MRwOmZqa4tChQ8zNzUUg/eabb/L666/zG7/xG9x9991cunSJJEnodDocOXKEY8eOxYjdsizJsowPfehDfO5zn4udmh//+Md55plnuHr1auy0nJ6eZjweMxwO0VrHjsjQM7lv377YYxo6Ue+55x62b9/OpUuXohtyYWEhRsOmacr09DT9fp+NjY04x0MvrDGGU6dOUZYlX/rSl/jABz5AkiR0u12++MUv8tWvfpWXX36Zxx9/PO7Pww8/zJe//GXuu+8+Wq0Wy8vLrKys8D/+x//g6tWr7Nq1KwLh6rGvVatWrVq1atWqVavWz6flPVPsObDM4rYl2p2MRElybVEoJMrHVkpsltKYn6W7azcz69fI146T92zsp7RWeS7hQEuIfzWEfjr3mCSkPbpGuRJBZm0EOvjXGBHgkQMW1iQMr/TIuqdJOh1EI6EtU0Qz9RGsLhLTdVu6uEfAAwp3LR567CTKAR4kSO+dk4lzWhoLKA+yjIdMCiuck89FeSabDkq/b86YJyIk0kYznmiGfc3bF99mZeUqZe7gVFGUFEXBsD/gzLmTvPaT17h89QqD8RD9czq6Qoeg8M47bVxnoEoy5rfNcuXSNdqTAilSijJ3MbFKkaYNlEwwuiARDZKkiSlzlGr4MRAghXO5FWPQkKYNyvGI6P/LC0prMIWmGA/IJxPSNCFtShqNhCzJHJAyDjQNNtYYDwb0+uvRHeoAn6XMNUVRsrC8j3sOPeKOqXVHQAiw2nhqJr3P0/qIXdfTGdyEAtfRaChd1K/cjIA1VqOEg82OV3vHrI97NR5oSeuAoBWGUFUqouPRUzwbkJjAWFBSogI4dE84DG7dcrUoPQg1/qCJ6N60HoAb/zPCOMeicNHJWpcRjCsUm5G3Is6AsEyBcE5fITcjUT3AjpBXOEAaKnTc/sk4h5XYvL4O2NThXu+q9D2V4TzXfhO01v78c+801iCti9Z1ANY4aOzjdsFg/Hnm0pS1v1FBAAoptAeczlUphUTb3I+XB6rerY2wYe+BFIO7oR3h+jxdnKwDmUpatHEAWBvtO0JLB7Hrapn/tBJC7ACu2mBDdo+1gf/mf/zGv8uG1apVq1at/zD6hUClEAKl1E3RoMH59cADDzA1NcVbb73Fa6+9xurqKnfffXeEmrm/gzHPc/I8pyxLNjZcHdny8jJ33303UkryPGd+fj6C0GazeVMfZpa5C6Tg7gxOMK01a2trZFnG4uIiZVneFNk6NTXFYOC6KkKEa6PRoNVqYa2N/YxFUZBlGa1WizzPGY1GrK6usr6+TpIk9Pt9iqJgNBpFp2XoNwxdkqG7cn5+nm63y2AwiK7DF198kX/8x39kPB4zNzdHs9mMr5+ZmYlg9ejRo3z/+9/nL//yL2k0GszOzrJz504+8IEPcPDgQQAmkwk//vGPIyAsyzLG4s7OzkZwdvXqVTqdTgRh4b3W2uhcDN2jASqHyNs8z2k2mxw+fJg33niDb33rW3zve9+L8akPPPAAR44cYWpqivPnz8f+z+9+97tx/NM0pd/vx+OysrJCp9PhnnvuibDbWhudhOF4Vp+rAm1jDEVRMDc3dxO4bjQalGUZYWsAim+88UaMhA3AOcyBixcvkud5hMbBOWutjRA6gEAhBIPBIPY/ArTbbYQQTCaTeBwD6Lt27RrPPfccx48fZzQaMRwOuX79OisrKxEKh/WF86QsS4bDIVmWkaYp1lqGwyGj0Shu85kzZ+h0OuzcuTMey8lkwuLiIvv27YvxsbOzs3HuLy8vk2UZw+EQKSULCwtxf8KY127KWrVq1apVq1atWrV+MR28fye7dy8zOz9FmmZYW3p4guuCAwKuSNotOtt3UI7uI7++ytqJS5hS+tcGR5ODGqGfUgbgGJmKQCLRVns3lGu6RARPmQhprRhcrKTCIoWBMfTPXkF2pxDNFiprk8kZVEMhE0lZGKCgLHOMaZKkCVYotzXSgTclpOsptA5SuksK5xQ0NiTkCKxxMENYMN5oJYTESufeFNL1GwqpEML1Zbqtd/GYppSM1yecOXWa3rDvbqC2mnyiGfb7nD5zkpdefY4zF86h7c8HJ28l492qRggHkYSm0WgxvzjHxvoGKpvB5AZUgzwfOQepzJAIpJKkKkM1WpiyJGs10aUDPFYXLqkJgykLsBopNUYLDDnCgFSWpNlgqp2hnI0SqdxxzssSdIkRlnw8ZjgcMJ6MMNaQlznjyZiJd5Wq1jQPP/Zx2u0pjIdesOnAlUJ6xib8NayHYkJEUOUSWQXSpFgs2mgXNywFCOXjfEO/o3XxoATXHWAt2hoXC2xCDKrFGOshoAOrvoUUKd2/2hbOsSfdcZDWA/IIQpUbc6sjNMMKjHDnWujVNFZiTYmxGknqx8DBXjwcd72kEitKf5YYrI+hBe8GlSCsxHVZWgcGoxPVgnciur7YArlpdPQdrFV5XCnc2krj4199DPHmkdB+Hx28xcNfad3nDaV2PaxQuvPdGIQVSJH4uF43tuEcRUgwDnIKBNpYvx5//pmCEM6rlOu0NFb7/dWetTuobYWL05UorBQY3//p7KiAlSig1CW1/tPq/wR+VwjxHeBtXArTR4BdwN8C/++/36bVqlWrVq3/CLpjUDkajZieno7gKACxAKN27NjB9PQ0WZZx8eJFjh8/zszMDHfddReh93Bqaop9+/axb9++2CsZAM/U1FR0041GIxqNBsYYer1ehInBdRZ3xkexCiEixBoOh66HIU1v6pAcDoekaRrh3Xg8ptlsAkQAOhwOGY/HEfgF2Pjxj388ri/sb7PZRCkVwV6j0YgRnXmekyQJUsrotFNKcfr0ab75zW+yfft2Pve5z3HXXXfRbrdZWVnhjTfeiPs5PT3NJz7xCY4cOcKNGzc4e/YsZ8+e5dlnn+Wtt97iK1/5SgRkjzzyCE899RTr6+s0Go0ItwC2bdsWQeTc3FzsoQywr3oMAygLEaNhPwPw3b9/P7//+7/PT37yEy5fvszp06d55ZVX+NGPfsRnP/tZnnrqqXisnn766dhBOplM4joXFhaYm5uL8cFhDAOgHI/HEY4G8KuUipG0AQSG7Q5gTylFo9GIMC8c59CfGo79jh07eM973hOdlqGf9Fd+5Vd48MEH43KDQxKI3ZthP7Isi69L0zTGqzYaDYC4zjzP+frXv86xY8e46667eP/738/8/Dy9Xo9vfOMbcfnBoVztPA1gNqyv0+lER3OAvu12m06nE98TImuXlpY4efJkjPKdmZnh0qVL9Pt95ubmyLIsHudGoxFvDgjz+Haq3qDwiyi4ocMdp7/MCtta63+dfKfmZ9/Na30UTK1atWrVqlWr1i+N9u6/m8XtS2SNpkOEwt/IKH33nrLOuSVcL1xjao7ujl1MDh5ifGOd/FIPb+/y/i2JC5IMkZAmOuACVJAISkJspAeZNji7nKdKx1ZLHwZrFVZY8oFm4+x5kqkpGtNTiGaGlYrEuxnxfXVCKhAqAhiXDOrAkRAO5Lj/hR49F/Pqug8TwCBE4vbC9+FJf01gRbBzbfZoSh8dqQuNsA16qxu8+cYp1jd66DIHLNparl69wHMv/jPHTv6Y8WTyjtGu71Ye2zgo43/GWsqiREnF/OIik9GE3vqAznQbVWgKCjCWRiqRSYIpS0TSRhjrHIFSIhKJlClpZwatC3RZUowHmCylyAcIVZJ1umhdUOoSMXYRsSJVzp2GZTKcUJQ5xljQJaPhiNFogBElaEFZaopJyXAwZpIbtu/cxczcdu++s96V6CGidT2a1kexKil9LKuLgzVWA97+6IGWi2R1gNpY49yIfm5K4b631s09x6wsxjsNne3X3fzu3I02ppkiNdb6Dkz/rwOnHkgKi7ElklD26JtEbZgvzvVpcbspkWE6ORCpHeCPJJBgAvXgT7h9FkL5uWlR3v2L8J2bFt8b6Y8pwT0ZqbtzeprSb7NBSoVSyS2veZWr/aTUHlTi/hXKzzkA41yhWOdadjcphFsdrL9WLf3N0kmYrB4S+98d0rlnQ++ntdb9+gm/B/DnOdZtt7QIIz1ktSQ+h1fIJEa+Wu1/M/nPLhy8xQFpJAINaP8bqu6o/E+sbwMPAR8D5oESOAn838B/s/UHKbVq1apV62fojkFlkPHRKQHIWWtpt9uUZcn6+jrdbpejR4/ywgsvcOrUqRhtKaVkY2ODs2fPsmfPngiSsixjMBgwmUwA6HQ6rK6uUhRFdOANBoPYBRGgWnCiBSAohKDdbqO1ZnV1NTrbAoCcTCbMzc3FbW232xGAJUkSwVgAocF5CTA/P1+J8RARRgXINJlMKMuSyWRyEwQ6ceIEg8GAXbt2MTMzwwsvvMBgMIguxAC/YNNBGMDY3Nwcc3Nz9Pt9Hn30Ua5evco//dM/8Td/8zecPHmS5eVliqJgPB6ztLTErl27YuxoAIBFUdDr9ZiammJ9fT1uZ1EUzMzMMDU1FccwOEhhEwAD0WWptWbHjh3s2bOHXq/HaDTi9OnTfOMb3+DFF1/k8ccfZ/fu3Zw6dYq77ror9iZKKZmdnUUIER2oS0tLTCYTbty4Efs+m80m3W6XTqdDq9Wi0+lEx2GYawEIhnkXnIzBTaqUQkpJo9GIQA5g79695HnO9u3b+fSnPx1fn2VZnDvhb6gQsxrmToCqWZaRZVkE5lUgOZlMyPOcRqMRj+Frr73Gq6++yuOPP85v/uZvsry8zHg8pt/vR7fpaDSKzkljDKPRKELv6hyrQr3gvL106VKcuwHEB/gc4G+I+Q0gOCwr7HM49mHfw9y7nW51kXUn7wnv+2UHlf9estaeoXKN+h9dP+f+PAz8X+/ytX90J9tTq1atWrVq1ar1b6Udy9vodNson1dprfRRkd4R6TGjwcVhqjSlNTdP967dzOy7yuraq9iRxQTnIsa59IR1TjaC20rgTI0iQkmL67yzIuCnoJCg4mGgcHGWAgnGkq8M6Z8/R2t2AdXsIJMGqAS0c2QVssBoTZIoByKEInTeBbBnPfAQUnkK5DsEpXSPC4kS7nrDYDfBifTOtQrwsa4kkDwvaWddblxe443XT7LRXwcjMQbKcsLrr/+Yf/z+P3Dtxsq/DqAUsbURKSCV0vc5Sso8x1qDkortyzs58+ZpbC9E27aw1pCoFg3VwpgSow1Z2nRjow1og8oSlEgcFEwUMivQhUWYlESkGCtQKNIUUpVRlgWaHCETynFOMSkwUlIY9znAaDQmz0dkWRNTavLRmNF4wiQvIZEsbt+NksqPq0JZgbalc8F5sOZAGhFWIYJ3V6CtCOzLjZGQHjw5x6UV1sFDAQbtXb4SKH0Mqx9ZY7HS+t5HnPvQhmhZ1+2IjxDGTwXhoam1DoIKjL/ulGA0VqgIxqww7nvrgKq0xjsnQ1irc/T6b/1yQwyxjNAxQDthK/tqnQVYKO8k9DA+RLgKKZ170Z9jDly6mFgpJIlUEb8HSSXpdBOkNJR9jfGOSmPcdJLCGzb9OjDEz02SJIv7RBgPBNqEbfKQ1tp4TljhbjZw42tc/yzeKeq31R0pi9alo6W4GyDAzR8hLMI7aI00KCTGT39hnZtToTCiRFiJss7lnfziH0HW+iWVtfZ/Av/z33s7atWqVavWf1zdcflco9GIUaEBeATX3Xg8vgnc7d27lyNHjjAcDnn99dfZ2Nhg+/bt7N27lwsXLvDyyy/T7/cZjUasrKxw4sQJzp8/j7WWe+65h/F4zGuvvca5c+d4++23OX78OOfPn0drHR2YWusIYkLc5/LyMo1Ggx//+Mdcu3aNZrNJWZY899xz5HnOvn37YqRpURQ3Qc4ATcNjIT40/EEY4FYATL1eL3ZmBiellJLp6Wk6nQ43btzgRz/6Edu3b+fQoUMRPAFcvXqV0WhEs9lkfX09dg6G8T1//jzPPfccFy9epNvt0m63ufvuu1laWoouuKmpKXbs2MHrr7/O888/H52bUkp6vR4vvfQSV65cYWZmhvvvv5/JZMK5c+di7OfJkyf553/+55sAcDh+qtIjEJyOly5d4uLFi4zH4xjPu2vXLhqNRoTMhw4dIs9z/vZv/5a3336b7du3RxfueDxmdXWVqakp9u/fj7WWv/qrv+LkyZO0221Go1GMsQ3wdzweRxdt1XEZtjPARKUUo9HoJoduWZYR/N17773s27ePH//4x1y8eJF2u02j0YhxrgE4VsFZ6AoFootzNBrFOFghBHmeMx6PGQwG8dgG2Hv+/Pno2FxaWooxx0opOp0OSZLEdQSwXIXgQISQRVEwHA7jnN2+fTtvvfUWZ86cwRjDeDwmTVMmkwlvvvlm7LkM+z8cDgHnjg2O4QAwAzwO0cxh3e+kcO5Xv2rV+teUtfZPrbXi3Xz9e29rrVq1atWqVavWVs3NdVFKoIXxbrWIMBBKgnQuLAciBFYZRCOhOTfP1J59dPYsYxOJNt6FhusUVDiA4tEDoXnO/eRjOv1/PoQyvj9ARSl8P2HFlyWEwhQJg3NXWTt7isGVK+QbPcoyB6vR+YRSl5TFJDrYLN6hJUT8Ci5Ea/w22M3PB7yPD4RCqASVZAiZIJOEJEmd41BKVJKBcPGZk8mEZtbCloY3Tr1Bf7CBNZbSFEzyET98/hn+6tv/H1dvXMNiSVTyC6FKCxjrXJqFteTGMtKGcakZjScuWleXGFPSbCbs2reL9V6PlevX6W1sMB5OyMucoiywpfsMwQRgZzRFPkEXE0xZurkgJNIk7hhphdUlwvgIzjJ0D4KUCUJljCcFucnJdclgOGKjt0GeTxCJpCw1/VGf/mDAaDwGJZEqYXFxGVSYD3g4LUD4CGEBxpTBHuugo/XzSPgJ50sirYhoDox3VwZQJnDxqRrvihR+HrpoViNcZKyNHZL+mlNs3rxqcfGkxmq00Wg2uxutdSDSCuFdfdL7jd280v6zKBc569zDxsfbGuu6McGfDsLdIBCIpDWFc/1agzXBRRqiXPHz24HCEPtqCZ8bWB/OvHlTsHtOOreqJd54Hc5VAbSairm5eWZmZ0maitJCYcBvhnNvWutjYUt/Y4GMzmM3V03lPANM6Y6J/73g+nD9NvoOWCu0d41Kv2vxFoPNxwVuLFyDJkiLVfhoZne4lZIgJdZHzgrpooktOs4fY0s3J8TtP1+oVatWrVq1av3X1R3fzlTtpgxAQ0rJjh076Pf7KKXodrv0+32EEOzdu5fhcMiZM2cQQnD//fdz9OhRXnzxRY4fP87Zs2dj5KS1lqmpKdrtNgcPHuT8+fOcOHGC48ePR7ATXquUio6xAG6CU3BpaYn9+/fzyiuv8K1vfYudO3dGWHrw4EEeeuih+P48z6PzMbgoA7yp9ljCT8c/KqVizG2/36csS9566y2++c1vsrS0hDGGc+fOsbGxwYc//GEWFhaYTCZs376dZrPJ97//fZRSNJtNLl68yNmzZyPoTZKE1dVVvvnNb5JlGQ8++CCLi4tcv36dF154gaNHj3L48GFmZ2f5xCc+wV/8xV/w9a9/nddee40DBw5gjOHEiRNcuXKFP/iDP+DAgQM88MADvPLKK/z5n/85p06dwlrLW2+9xcWLF9nY2IjHM0DHsC1SSowxrK+v8/3vf5+XXnqJJ598MjpiX3zxRVZWVnjyySdRSnHvvffy2GOP8dxzzwFw9OhROp0Oly5d4tixY8zOzvK7v/u7LC0t8ZnPfIa///u/50/+5E/Yt28fq6urrKyscObMGe69916EEPG4SCljfGwVlAfwNhqNoisxxLomSRKdiVNTU7z//e/nz/7sz/jTP/1TPvWpT7G4uIiUkosXL/LDH/6QJ554gieffDLC3gDsAowO0b4BmmqtWVxc5NChQ1y/fp3Tp0+zf//+CKB37twZXbWPPfYYMzMzrK2t8dd//ddcuHCBgwcP0ul0aLfb0XV8/PhxPvShD7Fz504uXrzIwsLCTXMuOFvvu+8+lpeX+c53vsPu3bvZtm0baZrygx/8gJMnT/Kxj33sJmdqUIhmCa7bAFlbrVaMzQ1O2lupdkDWqlWrVq1atWrVqnV7qSTFGFBIb4nynXhotC39B/lglQVtPdQRqHaL5rZtTB+8F73RY3xpAxPcTMGzKKKfjYAnif93aMHgIjXxr1U3oVInedNPDkDlQ8Xg3EUa0/M0pqZR3QYibVCWGiZjjCn9NgBWY00CQjkcZV2UrASEEr6z0rsqg5tUJB52OQelSDOEtc6BiYxQBZlgdYmSgqlOlx9893l6/Q1nbMMyycc8/9IzfPeHzzD2N4kioLjNdcy7UfUqR3inaiIESglUIjCl6+psyw5WwPTULLvv3sX5cxdYWV1nZlp7x6wgVcrFfkqBks6FJhOFVEmEPUIoRJIgSkmaNlGq6XomJxN/LS5AJGhjGA43GOVDSq0Z5kMG/SHjyZgkTUjIGI179AcbjEYFVgiSNEUmTZrtrnO3CQe2MBYlQ/up6xG1/pgaXN8gwjvyDN6V5wGfMd6F59yRCOG9eG65wclnrXNaKivRwsWgOg7qIKSUrj8yxtFiscZbCIWDxc4Q6GNEQ78i0gFF77wUQiGMxUXPOreuNjq+JkJKa52B0zuTjQn2UBkdlQ5euj5GfISs67AU/md31jnnp8aa0sNEQ2kcLCQAV28zNB54WrHZxRlJupR0uzMgLcP+gHyo0Rq08VG5IWLXOkdzWeaUuiCxytNPF49rbbgZwbkbLdaf924fgnPS+i7NEByrvdtTowmxrca6763VrnfUCr8UF/sspOs0BYEwAmtLhEjcZ0nWujhr6/o+ES5y1gRaW6tWrVq1atWqdQvdMagM4CZ02gUH34EDB2LnYYBE/X6fRqPBgQMHmJ6eju+dmZnh8ccf5+233+by5ctMJhOWlpaYnZ1l27ZtEZJ85CMf4dSpU4xGIzqdDktLS7z22mv85Cc/iRGlQgj27NnDzMxMdLvNzs7y+OOPk2UZly9f5s033yTLMh566CGOHDlCp9NhMBiQpin33XdfBDTBMTmZTNi9ezedTidG08JPR1dWuw+ttTz88MMMBgO01hw7dizG4X7iE5/gAx/4QHT4HTlyhE9/+tP84Ac/4PXXX0dKyd13383nP/95XnzxRRYXF7HWsm3bNu655x4uXbrEq6++Gh2j+/fv58knn2RmZoY8z3nve9+LEILnn3+ea9eucebMGdI0ZXFxkQ9+8IPs3LmTfr/Pvffey2c+8xm+853v8MILL5AkCQ8++CAPPfQQV65cYWFhIYLnKowOQDDLMnbs2MHMzAzPPvss3/72t2MP5JNPPslHPvKRCNy+8IUvMDU1xalTp/jJT34SnardbpfDhw9HoP2Zz3yGRqPBsWPHOHPmDNPT0zz22GPRORlg4Hg8JkmS6JYNsCyMyd13302z2SRJkvh4v9+/qTdSKcUnP/lJ1tfXOX78OF/72tcisNZa0+12efzxxxFCUBQFjUaDZrNJmqbR0Rm2KcQOl2XJ9PR0BKBf/epXWVhYIMsyvvKVr3Dffffx6KOP8uyzz3Lu3Dnm5+cZDAaMx2N6vR7D4TD2vk5PT/Poo4/yrW99iz/+4z9m27ZtNJtNvvjFL8bI2QDjkyTh3nvv5Xd+53f4+te/zte+9jX279/PeDzm9OnT7Nu3j49+9KMxMnniL3R7vR7btm2L+xhAfXBYwrsDkbdzUNYQs1atWrVq1apVq9Z/eQmBkhJtAAxYEW+8TG/QMgIAACAASURBVESKpgSrUQiESLHWd06mitb8IjIv0RsblIPXyFc1iZAOOAqJig5NQQiiVMIFyQZ3WWnBSrEZyWpxsY0xgNLBC2klUpQIYTBWIqwgX5kwOP8Wzdl5VKeNnJlGG41IJDovMbogVU18Viu+bNC7IL270iqEMN5ZF6IoRXShCSEQKnXuLeMjJUOUpXf6Tcqc3Tt38crzb3Dl+jV0qdFWU+QFr736It/94TOM8snmmNv4v9sfmjAmfn2JkqSpdEk9SYoxGl2WSGlpJJJECZRI6LQzpFCgHZhLRINEJszPLZK2Glx46zwrV1fRsxqVZDTThFS1wLYQQqEaTRIhkEmGSpsOJvnPNFTWcmAyN85cqS22cLtT6jFaw2gwoihKBuOc4XBIf9h380yljCZDev0+g+EYpKTRShEIprrzZK0OwoPyVCZY6Y6XsMHl5iy6yoMv91rvxxXBKekySKVwN70i3OuxLvbVfwveVegApsBYHWF1IiSl9Z8xGOsBaYCBm7Gz1k8DQpwoIoI+4aOEpVDe+YkHdoApMNHV6PFnmH8iTA/XnChclixCSL8O/wYp400DDooLhHHuTeGdlHgXqrAKhMYGqIuDeBL3GQMhL9fHNatExR0L+52k7jo/azYYiDGl9fGvGg+WrdtWv0/GQ1hjjH9s8zM4rI69nNY4B6W/oyDCXtDR8emOn68gCr8VrAOaAWaGcXHdpA7A+sRnSlPG6SNFgqHESjcuxubge0kTpbA/I7GpVq1atWrVqvVfV3cMKsuyvCmWMsS4VKM9w2sCzOh0OuzatSvGxI5GI+bm5piZmWHPnj1ug3xPXvgjq9lsIqXkwIEDMYo1wJ0kSWJMaLPZ5MCBA0wmk9hbGMDPU089FaNDQxTr2toa6+vrNJtN5ubm+OQnPxkdmUFpmvLwww/H7Qj7UQWW4UtrTVEUzM7O8slPfpJut8v6+jorKyu0Wi3a7Tbz8/MAjEYjWq0WWmsee+wx9u7dizGGNE3pdrs0m00OHTpEWZYYY1haWuK3fuu3KMuSlZUVjDE0m0127NgRuz6Du+/hhx/m8OHDjEYjBoMBQggWFxfpdrtI6SNzmk2OHj3Kvn37uHr1Ko1Ggx07djA1NcVoNIoRo8G1F45tAFcBMAewubGxQbPZpNPpsG3bNjqdDqPRiPF4zPLyMl/60pe4fPkyFy5cQGvN3Nwc27ZtY25uDnAXKLOzs/z2b/82H/3oR8nznJmZGZrNJq+++irj8Zhmsxlh2gc/+EEOHz7M7t27Y2fmaDTi8OHDfOlLX4pxwSEKdseOHbEXMoDtqakpvvzlL/PGG29w7NixOIc6nQ6PPfZYdL0++OCD/OEf/iH3339/jIOVUjIzM8Pv/d7v0Wq1aDabgIs8Do7ZEydOMBwO2bVrV+zX/MIXvsDBgwc5efIkaZry3ve+l/vvv59r167FLsoAPH/913+dbrcb41zn5+dpt9tIKXn66afjuAU9/vjjpGnKs88+S6/XoyxLPvShD/HEE0+wvLwcx+6BBx6g3W4zPT0d57rWmj179vD0009z//333+SevZ1qR2WtWrVq1apVq1atWreXkhKjncvLSg8aKH30po9Htb6H0T9mcJBKNjJaC9uY3rOXYm2NtcFbmMIirNnsvAwuNpTrrsQiBb5vzr3CWIsRgkRsuicr+MGDH0Ns0/PuMlNKJldu0F86SzI9QyNRmEbmojdNuXm9EAAWIFCuQ1AqQi+eFGBVsnn9ICRKBBgpnLMQ4fZZ2NhViLAUeclUd4rrV3pcuXaNWBNYWi5dOMOzz32X0aQCKW8jF3frXJEC180ppaCRSZRIyBKJyhTCCLQpsFZi0gQlrQNbWoN08ZYWF/0KFiUlUgla7TZI2HfgABfOnWXlxpqLXF2Yp2kMeZEjlEAmDZTMkGnmug6NpDRDdFnEKFNrLba0JKqJVA3yYgBlST4ZUpSW8aRgMBgyHA3Jy9LddDoYstHrMcxHyFSRJh7oIejMztNoNJEyQfqjb2LxoYe11iBMmCHKAczAAIV1HYVSonXhgKC1rnM0OAzBJaVK6eZZOI7WRY8aHx9rvGsPH1UaPcHCYow7VxwQtD7yVPiYY+/y9KeKFCqCRyGsh2ASG+Nn3RwzwsfYevjp5qr1kafSL9t4iO+2S3pA6ast3Rx2oxbdogLvgA40FA040B2jUa1FeCctVqJUipTKba/fD+M7OZuNBq12h9VkHT0Bbbwj1R+RQmsMoR/Sn+0h6jV+RoU/5tq5RX00rBskN7fwLtcwjsbDTYvbVm388fFx08ZohFTOYUqC0aV3troYXud6Va6j0qdzWeuel1IhcOeTMG75tWrVqlWrVq1at9Iv5KgMXYRpmkZnZTVqM4DKZrOJEILJZIIQIkZnCiEYDodkWRYjV0NHXuganEwmfO9732NqaorZ2VnG4zHXr1/nwoULHD16lEajcVOHn9Y6RqYGwBZ6ALZt20aj0UBrTbPZpNFoRBedUirGeAbYmaZpBHbBtRm2P3wPm1Gw4bGwrPn5+dh7GGJLJ5MJWZaR5zllWTI7O8vi4mKEsyHOtNVqRTgY9qnZbLK0tBRBYnCcttttkiSh1+uRpikzMzNMT0/f1FNpjKEsS6SUDIdDkiRh27Zt0bUZOjinpqZu6kEM+x4cluEPTyFEdMkGR2EYlzAvwlgnScLevXtZXl4GHLAej8dxnKy1nDt3jmazyeLiYlz+Sy+9xLFjx3j66adpt9txvHfu3MmuXbvi/AhjsbCwQLvdJsuyOGZ5npNlGU888UQE5GG+BnftoUOHAOKYh7k7mUzYt29fhK/BwWitpdPp8OEPf3jzREoShsMhc3NzPPXUUzzxxBPurkEP3ofDIcvLy2zfvp0Pf/jD8Xg3Gg0OHToUnZp5niOlZNu2bXz2s5+NsFpKSavVoigKfvVXf5Vut0tRFD8FKx988EFKf6GqlIpjAa4v85FHHuHw4cM3nSvGGObm5vjYxz7G9PR0dItWHbW1atWqVatWrVq1atX6+eXAHwTA4TrihP/exUgqkTgwhrsOElZghUIqQzLVpr3tLsr9IyarqwzPr4KWhCUghF+ec0biozKFFZvuMayLhRQhHtapGhSLFSgJStgYrSmQ6H7B+PwF+tPz2GaDdH4Oq7WDPdpB0IC2pJB+ecJBo2Cq9IBn03np40aVcsBFALZwEEUkCGscADMaXUzoLizwwxdfobe26qCvUYzHG3z7mb/h2vrqzzwGQghSJVFC0p5qcs/+PbSaLZRSXLl8lRvXr2G0u+4uBoWHSG6bpZAUuevCxFpajYQyLzC6cPG3VpIIRZJmWCtIVE7WMOy6exdSCC5fWwEkUqQUJsfarnPgZQK0wQiBsQXlJMeU3mGYCUpTUBRjZNp0oBnIJwWr6yv0hn16G+v0hiPyvMBYS5nnDAdDCqtpddo0sgYicdGc1krmF3aSJe4zFnBdlA52bToFrVVYAUIK5y708aHCbkI8azWpaFCisWgfIyrd+6xGITHaA0yrXQQr1vWhGu+VFcLzMvdaYxwcd5DbOXOtKd0ycbY9bXyfqlQ+KjewOT+frPWdlh7da+MdgMbBbeO6Ka1x8Azr4m0dOFduf0WIRFVU+zOttRjtViVFgib3EavB7ok/r10kqvDno5AOwkupkJSur9RoZID04ez0ztRWq8P09CzXm1eY5BpjHaxUxt/QQHAA+5sM/PZJH4crIN5AIIRESH8DhHVdmyJ0UxqDcAm90WmJ/z3h9t9Gx6b7zACMzj0YtrEPU9oAS7U/P8DYEoMEqzG2QKkEjP8dIRIHbGvVqlWrVq1atW6hOwaVUsr4fQBLofMuQL0AkYIbsfoV4F1wAlY7JqsOPiDGtoY+wk6nw/3338/BgwcjXArAJoC5amRpkiTR9RY6F0O/pTEmbm+r1XKD4p9LkoSiKG4CeSHWtgrtQhxqgJ4Ag8EgPhbWUR23ABsnk0nsAgxOtnhw/PpD3GnYx7C9AayCc8UFaNvv92MnYxUoV9cdOh3D+8J+BgdsAK5hf8IFjRAiAmljTHQ7hmWEMQn7rJT7Iz9EjgYIWu01BXj22Wf5h3/4B3bt2kW326XX63HixAl2797NE088ESFdgNABUob9yrKM8Xgc4WiYi9UI2xCxFJzAAeiFYxvGP7w/HOPwfBVMh3jUMCfCdmmtbzo21bjcMK4BulYdiWGcAtAOywhdm2G9Yd5snSvh/e12Oz4Wzp/w/jAXsyyL+189n1utVhyTdwso3yn69XaRsFXX8s/zvqqq21cdh636Wa7QWrVq1apVq1atWrX+LeWiFxVaaqzRHkq4uEpjteMVyjmzMLgoRauxpnAteklCMjNNc8cOOnv3MF7vk6+Ctta7IMPfwiH9Bw9R3GtMRJXeHRY68gj+rwBALFJo1ysprOtRxGA1jK9twKWziO4U3XaLtNVE6xxtClJjfdSrd9Z5B58UahNMsglmBAahQtemg0rWujHCO7uEcBG5usyR0nL96jpXr11jkhcYfz3+yr/8kLOXLtx27KWARDnXnfbbeej+g9x38F5GwyGTScHF8xewpcZoQ6k1Vrsx08ahWtBoYx0oAxqZ6wl0wEVg0FgJSdLAWJeSQy5QMmFhaQ5tDJeuvc14PGT7tu2U2ZiiVZCkKY1mC6tLB2RLA1aCtNhCYZhgpGEy7FGakslwzNrGKv2NPuuDDdbXVxlNcoy25HrCcDJGJQ2aWYMkESCM60WVEmMsU7PzPnLUeCidYEwB0h2rMBelddPQgUCfsiNkmMyA9I5I4+OGhYdWmzdyS6Giwza4Y92/ASoa5+yUErT2c6D0zkQP4ITnf8LNKWmrN4sbhNgEXs4faX3/ookgbbMrUvnrTAnCOWGdexAQmXexRvTv/aEuBNX461MpLFYI3+O4ecqZgP6tI4nWGDdMfj+CU3EyKRmONhgMe2jvxA3S2mC1odloMjszT7PbZNzvUxqBNv5ctz7FrNTu/eGENmCVdcDXO2S1cXPW+mhdjMB1x/rPIPC9oPjfOdZF88a6H6Nx3bnOzemuqQXalFhKsNJPCe869ePu3KebEdBKJJvH3WXkom1+23O2Vq1atWrVqvVfV3cMKoPzK0CNKmDodrsA0Q0WV+bdZbDpQszzPDq4ql/VmNVPfepT0YEY3JjT09N0u93YC1lVFVBVYVCAO1vdYlU3ZQBD4fkAd4wx0aUGxOfDugKgqsK+APmq0DVAlRBZWn2s6tisbntYb4Cng8Egvr66P1UIrJSKz1UhZ1XhdaHPsfpVVVh2GMPqe4ODNmxzcKuG76sQWykVXbZhWQFm79q1i7m5OdbW1jhz5gztdpsPfvCD/Nqv/RpHjx5lOBxuXvj4dVWPTdj30C9anUfVY7HV/Vp9rApOq5G+AWxW5/rWeb31fdUxDiAzfFVfd6s44a1zeet7bgcRb/dcOF63ummg+v3WY387EPhOuh1wfKflVfd1q8J4bx2n6jG6lWpHaK1atWrVqlWrVq1/TwVXo0KhhXOn+dY/hEjB5s5RZqx3JLpP/rW1KOvcmEmrSTY3R3f3fvKNPsXgFIwVCtezB1RCXIMXUlJSYoWltJYsgJ8IY6LPkU3rY4IQhY8G1fHVegyDt68i5i/TmJ0j6bQxZYmxBm0KUArpezDD/wwGKRK/n647UDoy5BxtHoM4R6WDQI78ONedFJYb197mngP38eoLpxhPcowRGCtYX7/Bj47/CH2bmxKbaQZWo62hKN3oLMxNs/OuHYxGE3qDPvkoZzQYU5aW0ljK0l8jGbdt2sd+6gDvcC60PNcURjjXoDYe3AkajW50vOmyoNOZZmmbi7q9cW2VtdV1luYXmG2t02l3aLRbzg3rXWYChVQSKxSlydFlST4akxdDNtYHbAx63FhbZb2/xmg8YjQZu+tfIG00aDY7KIlz8cUbdAVlAW+cvECnu4Nt2xfc9R+4HkbCdSZ+VkqkH1djDVK4DkIpfDyvNQgJ0oS4YhFdvPjYXke/N+NT3TzQfvw02vqBFXgXbYghDcA7oHPfr0i4fnfHRkjvFAUPt4MD1rn7rHAdinGe2+A69I5JEfC8d4wGUzHezYlGyARESUhktn58iMBVbJ7gHlzn/jFnthRxXUpISu1uQB8NNkAbQvSy2wXrU74kMzNzzM8tMVwbYMeO+RkDiRJxf2Icq7/ZQdnUuyCNHw7XWRnAqbalf60fKyEd6LW4mGlj/Lmsvc3SnwMaB8+9K9X442+tcxIbU7DZeQnCQ2EwaGv8TRHu/VIqF5X87u5LrlWrVq1atWr9F9Qdg8oq7Al/WE0mkwinqhAJiO604LKruraqoGQrCJRSMjs7G11sVZh448YNGo3GTdCwGpVaBXa3A1Fpmt7kCAz7UI1eDW6+KgAMsCzAnPBzUNjn6lhV4WLV0bZ1LMI6w3LCPlXBYtW9GF5X3YYAdsNyq0AvPFZ1EG7GwGy6BLdCpa3AMrw+bHPVbbr1OAYFKBzGIHQnvu9972M0GjEcDknTlIWFBZrNJhsbGxhjKIripwBkdUzDPlXnUPVYbwWM1e+3uklvBcSqcyu8bivIq45t+L7q4qxuT9j/6jpuBSqr7/tZ0PB2z1fB7NZt3RpnXH3tz+tKfLeuyFvpnbZ/600HPwvY1qpVq1atWrVq1ar1SyGx2aknPJxxgMd4uCM8xHFwT9sCbdwH+kISbY/Z9BTtu7ajJwcZXb/G+GzPgQEbnIqbQa5+Zc5taTchi0EgrfXP+S2yDitaXPRrIt11UilCog5YKxlfL5CXLtGe305jZsbRu9I3AooEYUHKxO2qcNAIIYh9flKBVG4rrfFgU3pQFSCnd7xZyWQ8Yu36Csm9D3L1ylWKUjtYYjUX3n4DXfb8tt083Eoq2pm7UXdU+huGBTSzhCeffJSZ2SnefvsK12/coMwN+WRCURaU2jvbhL+e8RxNW4vxHE0JgRQwmuQMhjlCuqjNGMspBFmzgxUORbc6U1jpokWlhKtXrvLmubMoBHOdLnPzczSbDVSSkagEpTK3T8ZSFDnaGIpJTm+wwY3r19kY9NkYrDGZTMh1QSkNjUabVtYiVRmJcnGfroMTrBHk5QQtOly7NuKZZ17m4MGdHDp8gEYrRdmE2E2JRAnh+galciBMCFwUb0l0xAbI52NQTXDUYsFKjNAoA6B87KhxzmAh0TZ3EFpKSuOcddXjJ0QCvofS+hPAQUsf+4oF6UBwaYKPUtx0fRuih8P8c8vy0N13rwobMKjBUiJsgvVOY6kUxgjv6EzYjHjlpu1wgFk6sCkUBh15f7zeBxf7Kt25JawlkSlZMyXNJDb3FUZKkiSKVqtNs9VgeeceNtZv0L+8QWFcLSp416T2ENC6qGeJ//zGH0NrHQRVMsWK0u2TSLDWoGSKFhajS5RIMZQOXoY7Fmy4SSBB2wIrBEYXCA/OjTEImXiw63ooXVyuc3Zb4UEmliRRYPzN68J3eXrQXKtWrVq1atWqdSvdMagMsLHaf5jnOXmeMxwOI1gIMC68FjbBSPja6pQL0CwAntAhGfobQ7dkgIdVUFmWZQR8IW6zGmEaIFmWZQjh4mlbrRZSSkaj0U3OxOCUC/sXImMDKJRS3tRrudWteSsn3K2A5TtpMpncsu8zyzJgs6i82mNYjQqtxraGsa+C0/B4GN9wDAIUDB2K7+TyC2NfBVnh5+ox3uo8DcsP69Ra0+12Y0Tw9PR0XE9RFBG4Vsc3fB+WGcY5fB+0Fb5VXYVbHYpV12t1HeH5ajxsmJu3ckJufazqqN06H8J6b+WuvJXD8Faux3erKhjfqndydt6Jo/JOt+9nve92rtN30jtB1ncDfWvVqlWrVq1atWrV+oUlBWgT4aSDYL7Tz8edumhE9702xjksPZQRiYM1qiFozs9BUTDYv4/B9WOM1w1ChIhSb1DD9cFVgSWEeEznyFL+wfBXtEGghPUONYdMHeAJwbECU0gGb1+nvf0yzblZxvPzdGZL5+CiwBiJ8T2DWJBKQoAgwm2ZFN5dSfgZnO/OBNIHwoXZnj7+Olk75ca1dfqjCbYsMbZEW825829hfcxlVWmaMtdpM5kMGcXPIQTtluR9j72X3/zc53jme//kr0lLNnobTIo8Rnxa4aM+tzgpNw+ls6VOCsPpC2/zvkcOo0QCusSUBVolJFlGkmZgFdr2yZIU3WqwsG0badbkgjjL9esbXL2wjjh/hnajTSPLSJOENMvAGGcwFBatDaORi3zN84Jc5xTlCKFSkmaDqVYTpRJUkpLIBGtLkjR1x19Kyon7nKCUGZkQjMc5x157k+vXb/DQw0dYmJ93n39I44G3J1ZCImTiXXkuZlVZiRECK4yPQ7WARgoXhStk8OsmhAHcvEzTDoAG96Qnv1XIKJSD5oR4UinBWKywcd4Y3LkhpXAxp8K/B+ngnXEQ3J0F3rXo3ZrWnycOBLu5Jqx7zHqob4UAA4lsokXhzgwZ3KZ4aCmRwmU0a6M9LLe+79JtCz72VkjXxZmmGY0sZao7hZCW2cUFti+vMhgMwSranTb79uxl5/IyU9MzpGnKRu8Gp/vH0SPtnL0aSoN3X7tuUGtKhGrGcyw4lK3ffxNuivDA2VoTo54DeNTauOhho51702ofPe1zqK1A62LTsWq0X0/i3avud4WRgHGOSjcXwnptjLk2pe96rVWrVq1atWrVuoXuGFTCZjclEDsRA9wLf3AGkFSNVw3xnFVXWhW2hfcHp9+NGzdinGhRFAyHw9hFWRTFT4HK0GWZJAmTySR2B1ahZYAUoaMxyzJGo9FN4DPEswohIrgL/YhhO8PzVQdiFQwWRRHX907OwqAA86x1nYYB0AV3ahjnrQCr+r6t8LjqwgwKkCzAtgANq8cubHcY9yp0C7Cxuj1VgFh1dFbHJXw1m80IdsP4lWVJu91mMpnEfQ9QOozD1ijcKqwMy666ZoGbjlV4/Fau0ipMDeNQBZXV8c6yLG53dZ5W17sVYlbfvxXgVufAVnfmzxv9ejv4ttWRWN22d4pWrcbm/mvpTkDmVtD7bpdTdTjXqlWrVq1atWrVqvW/WsJ6SCMltnTxlZvszngXlkQwiSDR4mCVEolzHsoUrEW1EsTiNqb37qd//QbDY+fQuSLBx3BaELh1eGsjxuPG8Ne09F4y4aGUi8T07/OOMQd0TAjXjGypWC8ZXDhHa2GBqR3L6CL3wDBFKueQNLhISoyLABW4vkvnMvQ9lri4V+I6FTFjk4SNjRH/8uIxPvb5j3Lt8ir5xEEVg6Hf63Hq9GmurY3iPgmg2Wiyc/sSN25cYzgpEAJaqaDVVTzy6CN8+X//P7h+fYWLl64yGg3Y2LhGkSvy3CfmGF8HUoGfhsoPgJS4hkJtefFfTvErjz/C/NwiVruo10QmWJWQNbookft4zgBuUwcRFTSb17jRWmdt4wZX1tcY9HsU4wnWFIS8WSldX6XR3qGWJaSZi3dtdzpkjQwpFUpK71J0TjgpnHPQ+DjPoix56diLtGdWefDIozSaHc6dvcbKyg946KH72X/gbhqNxAM+6+GfdtuAwlrt+kPx/ZVWoITyHlx3PB2Ykv5oWkQAmd5VaK2JvZVujgSUFm4edoBYhHkpQwSu8RHCEmuFn7vGw2OJ9Q5Cb1PGWO1hp4lzK7j9hPDXwkYg5Ob5EJyUQkAilY/xtSirQEi01S461Up/zjjXIJXrZbc079b03wspkUJ5kCxpd9u02y12NnYxNTOLkCmldh2jUilmpmdYWrqLqakue3bfjZTQW7/Oyrm3KQsH0bW2aGvQVhPPTuvc2MJ676kNNmPrXY/4710krgPBziVtbOiCtRiDA5be6V2WhXdeO9dt6JK11jgELA0y9HJKFx+bqNRbtS2bNk0wpvRxysbHP9eqVatWrVq1av20fiFHJWwChOA0tNb1ToZI1fBYeH2AYlsjHKtQaGukZpqmZFlGmqYRogVXJHCTww1uhmnhfVU4VO0w3ArswnsC9ArPBehXXd9WOBWWW3VdBgBbBWvVcauOQRU4BkC4tUdwa9xrNdq2GtVaBU/BRRi2fatjsNfrRWhYBbhbuzrD49Xn0jSNPwfwGl47mUyiiy9N03j8whgFZVnGZDKJxzTsS5qmt+xArSq4M8MxKYoirids71Zn5FYHYxXuBsD7TnCz6kCtgsqtjuEqRAuwNjy3dS5ufc9WR+XPAyrfDcS81XK2rqO6rXcC++5kG3/WurZu41YX6M+zrjt1fdaqVatWrVq1atWq9fNIa11xKjp3pES4KERj8YQAHa5hSwslvtvNIlDOtSVcT2Da7tJZWmZmzwGGV9cYXOp7V6bHAsIBJSfnanMxlnjQ4iIoHUTy0AI2IzaRKKHJhKGwDvZI/36MYnytx/jKFco9A0yhsUY4h6ijnQilnPMQu8krhEDKxP/97hxxouq2FB6uWMjzgrdef5Mrly/T6U5x6dRFijxHW4MSgvX1FdaHA+/qg1Q5KLRvz05uXL9Kf+SuK5sNwcJCl/c89B4+/7nfI1UJ3/vePyOARCkaaZNJb0KpHcwJywuXnZsoqyJrEd7IefbCNf76777Hwvw8e3Z10EajTYnQBVIqkqRBmhSUWpMkqesgbbSZm4FEJbSabeYW5un3e2z0evTW1ljvrTMZTxiO+uhy7K63k4ys0aLVaNJsdei2OySpQiXKGd6kO44KCdJ1e2KEA55CMJ7knDx9jkvXT3Lh4nl+5fGPMrewxHBY8MPnXuXaynWOvvc9dLqtEJjqDI8+wtMivCnREHsZw7xE+B5L93mDsDa+x2KxxkE/9zxuu6S/FhMJ0jpQ7z65KJFSbToqcaBSWEnA63j3o/Xz18Fl/zmJtWBcR6WDo6VD4sLFC1tr/HWk9C4/vzv+/FBCeQOgh3pWUmpITZgTyp8/pZsbBnyGrL/RwCKscme3kGDdnFdSkaQZTSzKSuYWFtm2bZlmK3V7XTps22m2mFvcTqc7xezClBmeGwAAIABJREFUgHE+4e3LFxkPBgyuraM16NLfRGxDV6S/sdhaDx19NyWuXzSc784dGWCum9naaHRpMEZjreuPjONuLZIUvBMS65yWbt+UGyPtkKaUAqt9JK40bgyCocFDU2sdyLzVKVWrVq1atWrVqhV0x6Cy2WzeBK0CoAoQptpFWY2+rMamwiZUrMLKoPCe4KoL768ClwAQA/yqgsXxeBy3LUBT4Cb3ZoB4ATYlSUKr1UIIQZ7nN8HMVqt1075WnY7VKNoAVsN2hB7GraDyVg7M6uNZlsW427DtYVyrbsngKgzjE1SN0N3qCK2C5gBmq2MbtqMKlre6YQN8DGC66j4NoDqMaXWd4bWhh7Pdbv9Up2V4Ljh1J5NJ3K/qXAtjHJaf5/lNoLIK5argL8uyn5q31X7VKsAOCiDzVrGhW+F79d/qfK7Cv+ocq25r9fVbAe3PApW30ztFEVdh+K22/07Wdztn552C1neCqXe6vFq1atWqVatWrVq1/s1lASudC0mIiAMFIKxCiARE6WGdcx9pUaJkghCbaUNS+J8VtOcXmd65m/H6dcreMYoND2z8CpWHkHETIkDy4EkEbGk3IzGxgELF/kyLEsY5Mk3Db6/E9A35yg0mvR56oiO8kqTesWWQMnPgSCrw16pKxr12MAxQzgbowAYWKwRXV4ac/vExRnlBo9lkvdfDaI2QglIb1tauU2p37ZgqQZYo7tl3gEFvhRtrfSSQZYLlXfM88r5H+bUP/zp7du3lv//3/4crV65h0ayvXafINWsbQ++grELKWyJKBJClCqEElILhpOSZF0/w9tVVvvC5j/PBJx8jSVtIbdFMUFmTrN3yrrmEJHWBu6qTkqUt0qzBaFSyOL9IoUuGgz69/pDhaMTa6nVWr68wGPVot7tMdadptJqkWUomXZ+lsSXWuI5Aq60HchZhPHg1Fq1LhoMRa4Oc4XjC8//yMucvXeDjTz3NPfvuxRr4yYkzrFy9zgf/t/extDRPoMvWx66GuQKuf9JdP/p4VQ+23AxyZarWO/ycs9JBvDi2wgFOKSVauOexIKMb0LcuCou22seyCucQxXiwGKCnAincOHhnphXRTIm10h9Ln5saZt7/z967xdhx3Oe+v6rqXvdZc+PwMhySEinRpCzpyFYky7Ki2LKlxLYMWfBOggRwAr8EeQiQlwB5CfIW5DwEQR6CAAGEPARQEm8dbweWt21ZsiLrSkqyKW5RokiJongZcu63NbMu3V1V56GqenpGlK0txyf7wP1BxFCz1uquWy+w+1ff9xcervsaqa7GIuFDSCPQAhJjsFYTGU3FCOIA1v1ql1L4LQcWYzLfQbcpQfi6q84cGhOrKtZoMJYoljTqdVpDLaw1ZPmzlYhICRrNFhrD+MRujhy+hU5nlTf7r5IuD0gySNMMqz2gzBKUVCCld1KK/EqWRGjSHPxqq1Ei8msDjH/2YbQhTRMPI42fAwe8bahxawxYmdeIzTcNC+vmQxgEDnYKDybxMdDufK6GptYaYz+4HE2pUqVKlSpV6ldbHxlUBmATIFkx4jVArAAJws1VEdoV4zOLsaxFx2TR1bjd2RigWq1Wy98fwGH4TKVSyeFhcN0FQBXeG8BbkiS0Wq0t8acBfoZ/iPV6vTzeNjhHt8fVbncfhraGYxRrdhYhVIBkAVKGmpThHAEm9nq9LQC1GL8L7h+sxTaGuQrAsAgct8PScLzQxu0wazAYoLXO2xLaEeBomP96vZ73NZwjANcAF8OcRVGU1xQN9TWL8Lc4BkUFJ2LRvRpAbBGMFwF4EW4VXbWhfWH+wvuKrtQisC46Iov6eaCv2IciQP9519h2Xevcxfm/FnT8IP08l+ZHAX3XOvd/BjC81nF/nqvyg5y4/1ltKlWqVKlSpUqVKlXqZ0lbEGRIETtoYjWQYciwMvMP+fERjBprXG1CJY2Lv5QuktHV2xNIpRBVRX1iB6PXH2awtMjS6WmyJPbRmXgnWYA2wSvpJLzLUvooVgcNrf+kgy3SSqTwtfGsdI5K76q02jJYWWCwskR/Y41M7yCmhhUGKwRCKDS+HIfrGMLxDqR0MMjBCgcoXaync1Oub2TMXJnl3Nl3iBtVIqHQOtTOdOO00V33YBNq1ZiR4RFGhmqcv7CCABotxYGDu7nzzk/zqTs/w5HDN3HsxWc5eeotNCnWZKysLZMNoN8feIibo8oPhpSRg1M6c2NorCVJDe9cnOXv/+kx3jl/mfs//xmm9u6lXqvSMIaoWqPWaCFERL+/gTUWVXH36khoNCHTKekgYag1RHt0gNGWjY2drCwvs7yyDEjiWo1YCQegnV0QbapgLJmx+dwoEaNJMDbDCIPRmtnFNTZ6CWDRxjI9N8u3/ud/5+5fu4fbP3kH1WqT+YVlnnjyGe644//i0MEDKBkhZXheYdFkCOvri1qDtd4RK5V3H7p7a1c3MqB4U1hTrs4lUnrHXuYgnnDxo9J6J6UP25W4Gpn42qXGTf9mVKxvlUC51WvDLLkfxhhf39K3VTh4r9EoFEJo57I0FuH7EJySxlpSLRgYi4wFvpxlfh0FGWuJpHMtSgTG99ta56x1kbm+VQKkVKQ2IUkzMg82tXd5unt4tz2g291AZylYzc5du/nYjbewtr7Me/23GeiUQZqSZi4y1rFV46N2jXeWGj9HGmMcdJZS+fhmX4fS+GdB2tWoFBZXO9Js1vbM2KyFqfVm1K1zWFoQEmmsA85SYj0MdseTQIaQxsfxWlwMrX3fc51SpUqVKlWqVKmgjwwqNzY2csdcgH+wCYaKKjrJrgV5iu61Iuy7lssN2OLSK7oxiyAwiqIclgbAGSBcMS616KoDtkC60PbwM8C18Hroc3gtHCvAUWALdNsOkIpQLqjorizGgiZJsuV428es+PtrOVSLsbLFcQe2jEV4z3awV3xf8dxhbIsRr6GdRfAafvfz4FCx7mQAiMU2XEvXctr9f6V8N+E1fl/8uf3vH/bY19LPgm/XOveHOe8v05VYbMfPa/uHOU6pUqVKlSpVqlSpUv9/UZ7I4t1pwoQ4Vn9v5eFIljucdAhozV2WeISjMAipUFFMtT1Ec8cO2gcO0ptfYO1q6h1VmyDNhjqQwrmtrHAwxHnNwCNNAKwVLvITV8NPGV/b0jq3nEB515siWx2QrCyQ9DbQ2jvdKLo4fTQnDmgoFedJsFIGhx4IKdCZIUt7SBExs5hx5eK7LHU6HNi1G6s90MQirEZImTvQGvUqtUrEweuu4+LFSwwGGfW64NCNU9z16Xv45Cfu5OCBGxHWcu69d7EyxmpNf5CQDFIwNZI0830KmPL9EkAtUo7J2Xw6sAaS1FCRkrX1lG9+50e89OprXDc1xa6dE+zbu5sDB65j184xhtst4kqMlAqpIoSMUFFMkqYYNKZhyFJNNelirWKo3WBkdJSx1Q7drnN9Wp35WNbMQdLEwSohlHfxWbRJvQPWQcn1Xp/T56/SG2R536y1rHY6PPX8kywsz3Hfrz/A0NAYvY2Ul158jY1Ol4/ffIRKFCN8jUhhRR7nSnimIXDwyY+SA76hGqpz0wnpYl8N2sWrSuXrXno4KCSR9BvNURgrEFJuRsyK2FV+tKDdJx1kExYhIqzRDnR7SJg/WxH42pPSQ0gQUiKMxYgUiQL82Fm9GW1rQFtBkmmMiKlWm1Tiqqu9aHHgMywKa4DY9VgIsBIhIndcnHvTAlL5518SpHZOS2tsXntT28z5VWWEVM6dmhkLKqLeajG5dx+HO7ey3llnYfYKG/2ug5XpgJqpYqxF2fBsKcUYm7sqjdYYq8l0ip869/vgbsTmDkcXD+ucmdY4wGvCh/yaAufARLjvCIRFCIvV2n/fgERhhMGKDGUlOgsndVDV6jL/tVSpUqVKlSp1bf1CjsoAoYrQTQiRg8siHNsOIGHzhqBYmy4cM7jkwrmKteuKbsvtzs4AtoqOwWJdx3DscNwQQ1p0QYY2FY9TdAeGcxbB43a3XHAPFgFi6F8R/BU/WwQxRVdlALKh/UUX5+YOvM1xC23cHrdarN0Zjrs9OnZ7BGuxXdtrHBbPFdyUxXEtjsn2sSseJ4xJEZAW5xfYMv/XWovbAXixT/9ZKs5d8Xe/DP2s414rEjbovwLWlipVqlSpUqVKlSpV6tqyaO9Ac/GZwf4mMI5DWgeZhLA5QMBubtQVOKAjczebxaKRShK3hmjs3M3Q9dczWD1DtgGgAE3Agcb7Ba0wuDp7gLDe77ZZ+w/AEGFsQiQt+S2FsB4cFe4xEkV/cZF0fR2dpK59UjnXmVTOjRc+LhywEVa7CFwfByoFdDsbvP7ayxz+2A20h9rYZJGpqZiDh3ch8RuFpaspaXGRo0YblJTsnphAiJThVpOZuTmqVcH1B/fymc98lptuupU9u/ZQrVR4/fWTZFmFaqVGMkjo9TqkWUY66KPNZt+vDSkFlUgSKefKk8KFfWoPwgaJploRGA1SwrnLc5y/POuAnLLUKg0atSqVakS70aQ93KLdajEy2mbn+DjjE2OMjo7QHmpTq9eo1ppIIalUYuLKACkUcVxhkPWxWjvHmzb0kz4STYbBZA7cOfAt6A/6rC6tcWF6hjPvznLmvaX39c3iIkR/8r9OsLy8yG9+/ivs2j1FMsh45ZXXWVlb41Of+gSNag0I99jWrWHpV4w1PuiU3CHrajU6j66wIgdZkYgxAjf/Ijy/UQjhIkKVcOtC+bhQg4splVKijSXTBqkUIZbWWIM1Di4aH0EqvOnPWo/ihXMvGx/Qaoy7zvDvl1ZhbBbwK1iBQdDLNKkVNFrDtJoN6rW6g+tCIW2Idg3eZfKYW2ONc4ciEVKglEQKlV9ZWHddpklKv99lKGuhQjKVyZAmIxKKRr2BkIJuvcdGY53ByCgHr/8YyWDAKWvpD1LW1lbpj49TqzeI4oqPnt2MfgbhwKKFLEsdU/UA2JgkdzBb76zU2s+lNW6ssN596WtfIlz9VescqIFTm+AmRWOFO6fFP+8R0kU0G8hs5uCn0R/gWS5VqlSpUqVKlfoFQOV251vRiRdASnAxFqFKAEpw7WjNIqiCrTAzfCa4BovAbTucKUaNFtsajlkEZ6ENRRdk6EvRGRjiaoM78lruxOLPa8HU4mcC6CtC1WIfQ+RriEeVUhLHcR6VWoSKoV1FkBlAZNEVGs5VbGM4VvF4xXHaPk/bYW3xMwGubndTFsd8+3gHFcHsdmfu/w58+2WCug/qx0c95y8LdJYqVapUqVKlSpUqVeq/XlpnSBHquPkMVBviEX11SANYF8+YgxgAa7EoF+PqXW1SSYSRWCGwsaI+Nk5raj/J8iKrb89jMneOgBYDKgmOSn9YpBBsw48eBkqkBGGt81AKQ+r9YSJADGPpLSzRX1si7fXRWYrw+bDCOjenO7KLlsUYrBQoKd3rWJCCC++8xdtvnuT6g/sZG2uD3eCV6TX6aYcIySAZECmBEhFGZGidEUWCiZEW9apgz+QBZmevoqThwIFd3H3PvXz8plvZvWuSodYIC4vzvPb662gTkWUpG71Vehs9pK3Q7w9gE1NdU5VYUFEOuCmlkEgshkw7V2yiM9JMgLQQKbCQaoNWII0gy3p0NtaxVqKiBQdxXJYv1loiqajXKzSbLRr1GsMjQ+ya2MF1B/YzuWeCRi1CKUmsKq4WpYFB2kWnmiRLSdKENMvQmWG102F1dZWL0zO8dW6emaUuqW9nqAlalAW0MZy7eIF//+5/58Hf/G/s2TNJmsLpN8+RJQPuuut2mq26c+oK13f3YY32c5zXPfWg0rqMUecgFBIhlXuHh5YIgzAKqVyNRywIJR0y947eSCiENTnUl0qirYtzVSoC46OTjQOFeIeig6XKbQ4wLjZWWLwb2ddplJGPZjVYDErIvB/9NCEzimpzhFZrmFatQVTxJXWs9uvbtSN/DkCIXTXkBTKFdA5DyOu0EjYimAxt3Ob4UCMSEcZXIpWg1WySphmpTjHaoNOMg4eOMEgy5uamWV93Ttt6o0UcRUgp8ghloy3aZLjNCf66t5ZMpygZYT3EtFb7mXPOV6H98x4DBufadc+IMoRVrmaosCgBFncuhcLo4Lp1mwkym3pI7YbCwc4MrIva9UVhS5UqVapUqVKl3qePDCpDvGgRwsVxnMe1BlBYjO4sAsUiwAz1IouRrOE9QdtBWAChxZqEAc5tdxcG16TWmsFggDGGarWaH/tagDC0ORxbKUUcx1vqTQYVIVXRZVo89vafoU3XGldjTB5bW4zLLfYxjPG1wO52yFccw+JxQjuLoLToyNvuhi2CS631lnOE44Y2FfVhIV5xLYW2FZ22H6Tt4//LVBFU/qJRph82wrVUqVKlPqwOtCVn/+8v/1c3o9RH0DPPPAPAZz/72f/SdpQqVapUqf9cBUeS8m40V6OPHCBYDEZkm25J6yIp8c5JayV5WmIAmAawYAREQy2G9+zHdLsMltdZv9p3dfOEILIRWxyDnh86RMrm7wmRkL5epTGupp8zY3rc6ECV9HAj63RJV5dJuxs+ojUGI0E5dOXvTh0ok7jP29AEh7aiikIpQ7VWZXhklLNnX+fY8ZdItWRkaJi1zhrVaoUkHbiGWE27WefAgb1onTK5ew/n37nA9Qd38/kHfpNbbrmNPbsnaTXatFpDzMzOsLK2QZqCMQM6qx3WOgkjrRaDNPtASCmFIJKSaiQ2YZiHu6m2vgyjQBtDlllUDFbr3F0Xxllbg7SuDqPNLFJGLvrTOtegMZCuD1jbSMiy1MEhbTAaooqi3aiza2KcvZM7mdw1zo4dw1SUoj8YsNEbsNZZY3ZhhXfOTXN1YYW1jYzUmMI4b/ZH2Gv31ljL5blZHnv8Ue6/934O3/hxrJG89dZ7dNe73HvvXYyMDrvnBsGdGOKEHYny7tsQ0esMuFY66CiEzefb/aeQSvn41rAKvdtY+s3AViBkjAmpXAG44ROrLEgRudMjsDLFaoHBxx9bi8S5N130q5sDgfSxphYj/HxJhzgTbclsRLXZpjXUZrjVoBJV0B5FWms2Ya9w9/IGFz0rkLi6l/6aNTpfr2ByZ6XAICXEccWtE+Hjcq119SyVA5bVSo2RYYEV3vNsXa3Hw9nHqFaq9PrrrKysUq+3qMQx1WrNgVHfL2MM2mZ+w4MHuVYjvetSCQne9WyNixTGu1ed+9NvTs83HRhcDUrlWKyfT+/pdeNoDcZov+h8/Ky2Pk4adJaBLR2Vpf7PUXnfXKpUqVL/5+kjg8qi+xF4n8vugxyHQUXYVXQBFh17RVdjeC3Uniw6BcN7A/gLsCyKojyyNYC0NE1zSFh0ExbjU4NjMRxPKUW1Ws3bVYxADe0KdRqLoC0AwO1jFBSgZBEuhs8YY7b0J7yv6FItOhxD38DViQzvDa7SYj+3uyKL7SzC4qJrtQgvtzsvi+th+xopwtHisa7lQA1g+Vrv/SCoF8Z/+3uKMPGXpZ+1vkuVKlWqVKlSpUqVKlXKGIuQxgMbfFSlAwZSxj4CUyFlirGpj9G0bNYDdLAv3PMYTymF9ZtFK4rq2Ajt/j56i3P0ls9ie86rKfEAhFA90nnihAgoQSB9OKzxAMrVpXTuSIlxcKkAN/P7t15CsrLCYGONLBkQVavOMWdj56AUPu4ViRUxUshNV5pwYGrP/oPsn7tKZ22ZN0+d5NLFaaYvX2HHjkkynTI/P0traAeZHiBFhBCW8fFdGNVnZu4yrUYTZJ9bbruLQ4duYGS4Tb1WJY4jtE6J4ipZltHrDdhYX2NxcZ1IVegOMrJM53MkBCgpiSPnXlVCIBU+sdNgtMUYSGwWDLGEW8FBalAClHKuNoR0jjXjaxd6kGWNcWYyaTDGIn00qhFuJqRyNReFdu9JU838Sof5pQ6vn71AFClqlSq1ekymNWlqGCQpvUHKIHGRpNe6Y7Zhzf0cLa+s8oOnf0CmNUc+dgtKxVy4NMePnn6e+z5/D+NjYy7C1WqkjLFoD3AjjNHklU+F8OBu068rpQeTeQs9tBSWsFIdzXYeP+s/72CXg31CO5uwlMKTUIGQEcZmaA1S4FaoFC5iVBqksQilXDQqInf6SqR3GBu0lSSZITMQ1xs0m0O0Wy2qcRUpBUbbfMKdYxQ/+RbhXZwW3x4kwsc0O8LtrlMh/XUjFCGW1WCJcWvGWF/ORigHPoWlVq0y2h7BWk2aJegsxWRu/c1cvUJvMGB1bZVarYYUEqn8BghjnbsT7ya1CVpmvsKnG21TgIkuJteAMUjAV6708+vm02SZA+/GBju2d4+66F7tAaXFYLW7lqyxWL8krHYOTixkZaJUqVKlSpUqVeoD9JFBZTFqtAjSQq3C7c64IizcHpdZdBsWIRpwTShYjDXd7vorQs8izCu+tt0JWgR1xVqNRfiplCJN09xdWayZGGpSZllGHMcAOSANn1VK5ZCxCAK3A7XQ/6LjMkDdAB+LTsPwmWJ9zgBoizUkrzXO4e/bY1qL9SWLAHc7gN7utNzuEP0gp+MHActrrYvt594OOMP4Xmv9FCN/w/wX4XZxDD+oT2GNFQF18f3b13DR2Vpcgx/U96Jjt9jf7WO2/VzFz29f68VzhfEJ12mxbdvXwnZtd42Ga2W7y/VaIDmMW7Hd22uGhuux2P/iccPviu/ZPobbP7t9/sM8h80LxTVQ7F9xjYW2Fd3BxTErVapUqVKlSpUqVepDSzs4Z/AwJUAsrDeQ+ThEYz3/CCDTImQMKBeXuRU1erwoUVIStWqwYyftfdfTuXqF/nsdMNLHNPpzeDjkyIHw4AgCaLE2QC1H6JQEbUF5ICOFg2vhzsFk0Fucpb+6RNLrUWkMEUUKozPnlJMCoUK8rXNjipA8JBRISaXaQBrDxfNnsAcOMnNlmjTJWFpcJUk2OP3mG3zhs7+NlBEmS1FKMtQapZcu0Wy2yJKMoZEW+/btp1aNHWxUFYSEq1cvsrGRMDExwRtvnGRmZoZuN2ViR5P5hRXAOQ2rcUQ1ksjI1c00mXUxo9YipIvCFQIy46M9rUBb9x4LZJlBR8I50myGsD7uVgmwzuGmrKsfacmIlEIKP3/WQR4Xi4qLAZUCtHMvYhzU0saQZoaNbope2UzPfN/9IlthZdEtK3Fg9FqcSAmoRdDrr/PUj3+ANppbjn4Say3T0ws89cPnuP+BexmfGEda6eySymKtRNnwvAdfK9ExR+eW9MA61Gr0v7fGP1cAlJJ5y60VOL7p/l+gkMLBS8j827w7E5tDexf56g2Z1v3eMTKJ0RlSRlgjQGgfr2zBOz61tiTaIisN6q02reYQtUoVqUI9Ve+oFQohJFonfu04KOknLu9PiMjdhIDuvVKq/P7d2MxHJGdobTycteh0QF4PVljiOGKkPe5gaQiZtQ4JLyzMsbGxwfLyEtgRqrUqUsQI6V3Uxl97Vrr6nQikVGgf+yqlxNjU0Uxh0TZFiopvt3N2Gqs9oHVfJAK39qXRft1KhDBobfL5dUDTuHMYQWYt1mi3jq37falSpUqVKlWq1LX0kZ+8FwFCgAJaa9bW1kgS/483DxSDGzGAjiClVA7TwmtJkmxx/lWrVWq12hbI4nZF9gCoVqtUKhWklGRZtuXcUkpqtRr1en1L3caic08IQa/Xy2FjgIBFMKq1ptvtbgGLRdBYdFJur2FZjGgN7w1jlmVZ7vDs9/ukaYoxJh+Dorsy1KjcDrPCuBT7ppRiMBgQRdGW9oR2xHGcj9n2fiZJQpqmebu2g+GgcNwoiqhUKlv6XoyrLULU7S7NMG6h/cEVKoSgUqnk/SvCwu2QLRw7jFnRqbvdpQtba5wWz11ck8W5Cn/v9/tb1uC1FOa6CM2yLMtB2XYXbDh3cW0WgXvxPaGtxTkIf9/+Wvj/Ynu2X6/XApTbPxdUBKFF1+92B3AYmwAPi9HExXMXYbPWOncCh2sjnCuspe2O3uLrYcxC37dvjCgCy/C+4tgGZ3Ucx1v6XOxL6ZYtVapUqVKlSpUq9VHl/t2pcG5DQLpah859B0pUUKKCozgRQkU+BVNhshCt6D5rEUgiH+noHGZCKVRcoTLUpLFzN+3rr6c2LImFRSHyP2B8DKMDITmY9F68SLjA1sxK7zyTKBk2IDuYJYX3xFmBMILB4jK95UX6a2sYH6XqOFP4N7R0sFLiIKV07lE8QI1iBTYlrrTYtXOKZqPK5+6/lxtuOEAkK7x16jStdkytWvdHlsiohjUw3B4lzTY4fPgQu3ftoFKJqNVroKDf67K4uMKgn7J/aj9LC4ssL/eoVGJ6vQFSSYZbdSbGhmgP1YiVg6nG81wlhau/ZyRSKOJIUfHzZoRFW4vxBT8NFm08ZNQCa1xkpzUOlWltSbVG2wxtDQOdkWpXA1DrDKMtVlufleqBn4edUgUrqwPdmtzM582LwbVY/HNtmRBJ+wGqxIJKrFjb6PEfzz7F6bOvIZQgjitcnVnkh088w/LSkosxlQolI5RwNRURAiFd/VQZRblzUAiJkhU3d0Ihw++lQqnYxbf69wkihFQgleeRbs06gGkcgCu030rfW+OdrMbVpxTSATmpIsfDlUPtQgHWb4R1Aa0YI+mnFhHXabbaDLVGaNQbRFHlfeMaIlo379Vxbbc+6Fh4iC8EUkT+XjVCyRgl4xxUhsqwBh/xjKtja4yzXnp8ixDuXrdWrTA2Ms6O8V1MTOxmfHyMsZ27GRufAKlY66yxur5Of5AySAYuYjXcP1sX+Wqsg93WWL+K3FpzdXLd9SxFBazfQCElkgilYpSM/MYDMMKbE6yrt2mNA71urqT//wyMW8eZ0WRZSqYzjPGb4XW5+bdUqVKlSpUqdW39QqCyGC2qlGJ2dpYzZ84A5O7DwWCQA4tQtzIAxQsXLtDpdHJgF9xPxWjXUOcy1JYMtSbTNN0Cs7IsY319PXcihvOEP0B+7AAuOp0OV65cod/v56AwyzIGgwHVahWlFEmSUK/Xc5hShHuWEY0dAAAgAElEQVQBhhSBbIBl1Wo1B4WhjaHuZHhPt9tlbW0tr6cZ2h3HMXEc520vAtFKpZL3oQgDi+0IMDJAmAAU4zje4nITQuQAdDAYUKlUqNVqNBqNfJ4DEAqQEcjPH+a4Xq8TxzFJkmwBSsU/xXUT/oFfqVS2xPOG84X5LUKlUIu0CGbDuG1sbOTH2x6la62lUqnkayVAyTDeYV0FuFWpVBgMBvmchXUWQHgRNm53fgb4XISyYYxDX4tuzXDtFOu6Ftd90VEY1kP4exEShjEJ81EEoeEYYTzDekySJAe6RSehUipfY0XXcuhXmJMkSbZA9yI8jOOYfr+fHy+sgSJ4DJ8L1812wF2E+mG+iuNeHPvQ716vl3/nhGs8jEuA6KHd4Xhra2tMT0/n30FhE0O/39/yXRGc0h8EqUuVKlWqVKlSpUqVuqaMBuvcR0a4GEkrAmi0LnZRWKywPr7SuuhU/H0HHi56V5MxWR6haTEuLlRYiCTxcIvWnv0MX7eLSjXzcNG56XIfmvXQKoAV/0ggtXiHWoAo+DjPgL/EZvyrP1q23GVjdppeZ5k06XqzpgeUUjlIKRyYklK5zwl8xKUijqscvvVTXL14iR8+8T2WV1ZoNYaYGN+JkBFXr04zPz/DULOF0RqTZcRRRHtomFqtxsjYMEePHmW41WLXrkn27N5LtVJnY2OdK9PTLC3No7Vhda1Dpi3NRo1mrcaOkSGGhxrEsXDuPyVRytWlVJHrpd+GibUG7WvrKenmwUXj+um1zm1prXE1K60m8y5Irf14Byejlc5J58GmMwA6j6wxBo0lNQZttD9ucAu6mqMycMgCkxQiuP7CSx8MK+3mx7ZIW1jtGdZ7GVjLerfLj599knfffZMojpGR5OrcIs/8x/Osra2hlHVxpsrfQ+ZzG2oxem+nACEMQlr/nEL5fvhxFwGaGwfkhXRxuxbcX0zu9nWDJfL1q7XOYb21bg5d3U+3hrEWiXNBCik8bLN+I4AEFANtEFHsIeUwrXqdKFJYP+8O9LmTB2BPDodd3Ut3HYVnGX5qhGsP1sN96+pqRip2/TW+lmfB8+oAoHNbunqQPmFMCKrViNHhEUZHJxgbn2BkeJTRsXFGR8axVtBZW6Oztsog6bl7aF8jM3hOjSnMCTinsHdUW2PzuGkTauBa5z61aLDGz60kr53robw2Kca4uqDapG68tCHTCUYbdObgqNEWrQ0mMz+LlZcqVapUqVKlfsX1C4FK2HQ4AayvrzMzM5M7AAMEKjoEq9Uqw8PDrK6u8vrrr7O6uroFAhTdY0WAEuBJFEU0Go3cxRcceAGShN8XIzGLbrzw/8eOHePxxx/n+PHjHD9+nB/+8IdcuXIlBy0BWtRqNYwxVCoV2u12DjTSNOWtt97i/PnzOfwIDs4AcopOvQA8AjQzxvDCCy/wwgsvMBgMcoiSJEkO/0Jc7MLCQg4Bi/UmYTP2NcC2KIpyN2QRJBUBT7Va3RKDC7Bz50601jz//POcPXs2h4BFWJZlGbVajUqlQpqm1Go1rLWsrq5iraVarQJc08VXHIcADQeDAdbafF63O00DrBoMBvl4VqtVhBBbHKjBTXfixAnm5+dzIFuMBg7rKUCysCaLwDmKInq9Xg54izA29LuootOu6EwNsDi0oVarsba2ll8bAcyFP8V5U0oxNDSUz2kURczNzdHv92m1Wlvge4DnAUyH/hYdsGEe6vU6QA6si3C86GYNADNcr6Ed9Xqd4eHhHCgGEB/Wc7juAjgNrxcdlkUgW1TYiBCuqyK8Lc5v+HtYF2FuoijijTfe4MUXX9ziXi7OTejX5cuXOXv2bP5dMT8/z3e+8x1mZ2cZGRnZ4jpOkoRGo5Gv69JZWapUqVKlSpUqVep/V9ZHnwoL0juWLI5R+uJ1IXwVKwKcUB4xgItKtDlYEEK4GE9ARg6wWWOwVhDXm7R27mL00BFau9pE0hIq/+VeygLU2qywJ1AeMNrgLARcnTpJ8IEpIYh8HT6LIuvB6qVpNhYXSbo9sNa57HwspsC5y2SeqKK8qxKkdPdm47v2IlSF6w9dT1XBemcDGUlm5+aYmb3KT3/yMhM7dyDwpRmswhpJFMUMtceI4gbVxgh7dk2xY3SCdmsYISQnT/yU6cuXOHnyVfr9lIMH9/PJT97Mrt1jREr65xQpRodaiw4OZ9oBxyTNSLOMJM1IUu2iWJXE+SoJNA1w6b6JBhM27VpXmzREh7qoV+lrgEof52p9jGeE1oYs1WTakGpXw9LxbUuabd7POii5iSK33J1sA5YfvB6vLZM7bN3P5fUNnnvhR1y+9DZRJULJCuffneXpHz1Ld6Obz7FSPulGFiGkcA5aDwqlUGAzAnxzcNI7Kf1PCLGgnlRanJPSGudazJ/naEI0anAWC+H8pkoo76A03vkpkVKgZATe5StVhBCKVBusVDSGRmkPDdNsNpzDF+Hibb2L0tWaDKmz1rkQrfQRtNIPqK+naUH4+pDWhI0IuHMGymwgyxLnoLQB1FqyLMVkGp15um2Fdzi674Narc6O0R2Mj+1iYucuRkbHaA+P0BoaJk0zVldX6XTW6Pe7ZEl4DuT+WDadla6t1h/bYITxAFn59WMKGxOEc15K5de7h8lI/21iwbjNE8b4JDHcM4nEOymdQ9jkwFeb9Oes0FKlSpUqVarUr6o+MqgsRjMWa/gFaBGARYCSJ06c4Pjx47zxxhtMT0/T6XSYnZ3l0qVLvPPOO3S73feBqmJtwaWlJa5evZqDjKWlJZaWlnKn29raGmtraywsLPhdfpuwaHscZ6/X47333uPIkSM8/PDD3HrrrezatYuhoaE8VrbRaOROyvX1daSU+c9arcbKygo//vGPOXfuHM1mk3a7nQNI2HSSBegRHGnGGDY2NojjmNXV1dy5FWBdALEbGxtYa5mZmeH73/8+MzMzjI+P58CuCCyLfev3+yilaLfbOSQeDAa5G9NaS6fTodvtboFHSZIwPT3Nq6++yvnz5/NzdLvdPBozjMfGxkY+rsGFWa1W2djYoNfrbYlmLcLmAMe63S5CCJrNJlrrLZ+TUtJqtWg2m+9zkQYwHUURo6OjecRtrVZjY2ODRx99lJ/85Cf0+/0cKoXY4Y2NDYAcQBUdgwEQV6tVBoMBg8EgH39jDP1+P4fMRRXHHdgC+QIs7na7/OM//iN/9md/xl//9V9z5syZLeMR1kXo1+nTpzlx4kQOqnu9Ht/85jf51re+la+/cE1Uq9U8sjS0sd/v0+12SZIkB4kBDgagXoS4vV4vH68i7AzvCw7fl19+mb/7u79jaWkpH4cANzudTh6fXHRLhu+AAM2LjtHiJoIwhkNDQ9RqtXyDQwDhwfkZXKa1Wi134kopaTabXLhwgZ/+9Kf0+33q9TqVSmULdA5r6MKFC7z88svMz8+TZRnNZjNfD4uLi6ysrFCr1XJ4PDc3x5kzZzh16lR+/lKlSpUqVapUqVKlPqyMSf1dt4+oDPYw4R70SyGQKgYhUTYCqzHGu6I8XBHGOTHDcdznHDhEyPx4Ko6oj4wytHM3w/umqFQsyjs1gzPTer+WN6PhjmhzKKKti900Bh/7iDt3OLPwuMkC2tC/usD6zDTdlSVMlnmnnXIRmNLBIqUEUkYoFSGVKkR/Si6ce4vX3niLTNcYm9hNb9AnjhX1OMZqw4lXX2VoqI6UDt5ao6lGbUDQqDWJVJVmc5g4rqC1IYpjdu/ez62fuIOV1WWEgF+/9y5+47OfZu/+vRw8fIj2cBudZSjhK3BqgzaWLNMkg4w0c5sXjXfxubqKDtpUlERsuyUw4Z7Xx8E6WGVR1hX6NBlYbbzbzPgl4MBPZjTWWD/uLsLUWBevqXE1CY1xIFFY6WqFhkRY8rKAueyH2Fv5895irIOsyyurPPvij9jorFKpKOJKxPl3r/D888dIBgnFWpQIZ1QMsFLJCBXFBQeir9loRQ7fBeRPpNx9rtriCHXQPDxPEHkHra8FKqxwdsEA/QOtDWRRenevcHMolQORqTYYK6k12jQbTZqNJrVKzW0QMJrUZP7eNpw2eCZd/UmL3nRpik2nopTKOYqDq9jXtXTXj5vXzGi0h+HBOSmFwGpNmvbRxoFqa/13RL55Aeq1OqPDI4yPTrBz1yQjY+MMDY/SbA6RpBnrnXW6G10Ggx7pwG3MDvVvsSFq1kW1OngJERKVR/KGPrn1KaRARMrBXiXzTQ9CWRDa73Rw7kyLRRvt3JQ2OFL9JnYNJjMYrX38bKlSpUqVKlWq1PsVfdQPFuvWFWMsa7UaaZpSr9fJsoxOp8PZs2fJsoyxsTGWlpYYDAYMDQ3l0Gp5eZnR0VEajcYWF2ARyJ05c4YkSbjzzjtJ05RTp06xZ88ebrrpJk6cOMH09HTuTLz99tu56aabcnAUXFfBIfjee+8xPz/P9PQ0Wmt27dpFHMcMDw8zGAw4deoUu3fvptPpEMcx4+PjnD17lrW1NarVKmNjYzSbTfr9PpcuXeLYsWOMjIxw6NChPKI09CW4x0Lk5nvvvcf09DTNZpPZ2Vn279+fw7PZ2Vnm5+dJkoTh4WFuu+025ubmmJ2dZW5ujmeeeYbrr7+esbExVlZWuHDhAt1ul8nJSSYnJwGYnZ1laGiI1dVVer0eBw8eZGlpCSEE6+vrJEnCzTffzPLyMqdPn0ZKyY033ogQgt27d3Pvvfeyd+9eKpUKFy5coNFosLCwwPz8PFNTU+zevRtjDM1mk6WlJd544w0qlQoHDx6k3W7ngO9a6yVEbQYX7NLSEsPDw0xMTLC2tsbFixdzABmAU5IkzM3NIYSg3W5TrVbp9Xp5ZG6oi1qr1VhcXGR9fZ16vZ5HgQanX7VaRWtNr9djZGSETqcDkDscA+BrNBr5ugzu2ABsi+u+CNGDUzWKIoaGhnJAWalUuHz5Mk888QS/+7u/y5EjR9ixYwe9Xo/h4WE6nU7ufkyShFarxVNPPcXMzAx/8Rd/Qa1WI45jLl++TKPRYGRkhPX1dULMbQDGAeiF9R1eC9dhiDkN0cSDwWDL74eGhkiSJK/7GhzLAXL3+32Wl5e5ePEiS0tLOQQH8kjbAMUrlUo+nkWgmiRJPqdFyB7cr51Oh7W1tdzFHNyivV4PrTXr6+tb3KlhY8C5c+fodDosLi7mULbX6+WOTnDRr41Gg36/z1tvvcUTTzyRXwf79u3j4sWLPProo8zMzLC6usrv//7vc9ddd9HpdPjXf/1X3n77bVZXV/nSl77EF7/4xdxhWapUqVKlSpUqVarUz5MUvt6gCPDBekiVEYkILSKM7YHRGJuClc5tZpwrT1iJlQaJwOjMO8mCuytCKu9UFAYjQdVq1EcmGJ66ns6lqwwur6FNcEGavLif8V5PE0JhfeysRmCIHADK73WcG9S5rGwOhgSQrPRYm75A5+CNjO7ZT1ytIZSrFxggjrWx77er6SeEAGPp9fp89//5V5Zm5+ms97j+uuu4fOkqjUYTISSVOObU6VOsrs4ztmOMhbl5siylUWuxPqhQbzRI0Cjp7huskR6uChYWV5hf7NAeGiaSA3rdLlEUMzExztKeHSwuL2BSB0/SzJBZQywESgpSbcmsd/D5yFUlIZKKzKZsR30O7Ak3X6HPDqsipR9KJfyceSBsLJEF7cc/OM+0cTGxwT1pcdBSecgcUlARLsIzuA+VEOgcgH6wczK8FkmJUhGDNLnm6+HPwsIcz/z4f/KbX/gq1eoIloTXT56lUa9x1913EiuFIDy3Md7l6Csx5rVUnQvSWp279bD+vUK6ZRJ6KKSLPzUahHJOSh8PawUYq8FKjMlczVAXbprn2grrIHNY0ibEseLqSiY6IzPSuY+HRmi1hqhVawgExrh2uvqOxjFQYzDGO0Sl9YDfgUtrDDbEOYfY1NzaKv0cutcQzhVqlMWazP3On0sbd13qLEOn2kXKWhD4Tb5CeseroVZvMkLkQHaaoLUbK2M1q6vLDJI+tWrswL3NHBANTkprXD3VopsT8vYJq1DeiCClcmMswZlYXb8UzkGMcY5pE/phJdY4d6bj9AJjtYPvOFeoFeJnL8xSpUqVKlWq1K+0fiFQGcBgiMgMcZxCCLIsQwjB6uoqS0tLTE1NMTU1RbfbRWvNyMgI7XabgwcPsmfPntyhF0BQAIxKKRqNRn7M4PoK9Si73S7z8/McPnyYsbExpqent0S3XqtWYoA0waXX7/eZmZmh3+9TqVQ4duwYY2NjjIyMsGfPHmZmZrhy5Qp79+5laWmJxcVFdu/encfWzs/P5zGXURTl7rZqtZoDlyiKOHnyJD/+8Y9zF9zy8jJTU1NUq1Xeffddnn766RzELS4uMjs7y8rKCktLS5w+fXpLjcDHH3+cwWCAEIIXXniBe++9lwMHDvDYY4/lTsGRkRG63S7PPvtsHpk6MzPDSy+9hFKKpaUlpqen+cIXvsBXv/pVFhcXOXbsGHfffTftdpt//ud/JssyhoeHWVhYYGxsjN/5nd/h0KFDnD59mqeeeoq1tTXW19eZnJzk61//eg69AsAuRs5KKXnyySeZn5+nVqtx/vx5duzYwdGjR7l48SJXrlxhbGyMr371qxw9epRTp07x3e9+N68ZuW/fPr785S9TqVR4+umnc1i4uLjIV77yFdrtdu4MfOWVV3jttdd44IEHGBkZ4eWXX+bixYsYY5iamuLXf/3XWV5e5uTJkzQaDebm5jDGcPfdd3PmzBkuX76MEIKpqSl+7dd+LQeexXjTYtTrxsYGb7zxRg7MDh8+zNTUFC+++CKrq6v5Om61WsCm+zKsjXa7zcrKSg6Fjx07xujoKDfeeCNSSmZmZnjmmWdYWFhgYmKCW265JR/rxcVFTp8+zWAwYGRkhFtvvZV6vU6v18vdicHhGNyxcRwzPT3N66+/DsDY2BhHjhyhVqvx5ptv8t577+UA+tChQ9x2221Uq1WmpqZYXl7m3LlzJEmSA/FbbrmFo0ePMhgMeO2113j99ddJkoTx8XHuvPPO/Bovjl9o05UrV3j++eeZnp4mSRImJyf56le/ilKKf/u3f2NhYYE0TZmenubzn/88Dz/8MADf+c53eOGFF7DWsrCwkAP24GwOP6WU9Hq9vFatlJKRkRHq9Tr1ej13NX/5y1/m+eef59SpU3z84x/nxRdfpN1u85d/+ZecPHmSV155hdXVVXbu3PlRvzZLlSpVqlSpUqVK/YrJxU+qELwKRnkDpAKpff3GEP7qol6ttVijPLzyJVcwHmgF8uL8TUJKF5GJRIgIoQzVVpPGjh009+5kfXGVwYbxgaUOomlL7hjcHhdqvZvOYFDIPA6SvIXhA845JzLBxpWrbCzO0dtYpTk87OM4XV07KYVHbH48nNUNhGBxZpqL594klk3Wli6RTOyn190gI6FSjYmUYm5xnp+eOM7tn/wsiwsLZFograBWGaLX75OJlG53g7XVDr1KipQKrTVTk5OcPn2a8+fPMTw8xNBQnf6gQ5okjI+P0h5usjS74qJera+h511v1jowJoUMg4KSFaQSKBN5vFsYM3zUq7AonNFMSTd22pdMxEPHMBpSSAyuBqKyzpVmjIOaBjzQDSVMHNBU0sVx6nCfTfAlWg9JPzwHEkIyuWsPc4vzbPS673vdWEtqBMoIrs7OcewnL/K5e7+EsgpszIkTZxgeHuGWW27yPNrDMCFdPKofGQcIjU8zNT4OWKID4MKCddA71EgVSOfSMyEqWaBt5tOafNBq/rxBFlKcBNgI0A4SC4Vjue46SVONNhBVa7RaQwy1WtSrNQfXrIeHVmxGzArhObB2gDn/42Nh/TksFikFOk3zRGDhNybozANZ4yGzgSRLHMTT3kXrQWyS9Mmy1D9rEFg36w5k+mtPSWjWq+isjTF70H5stU8lW+uskGUZ9ZoFYdBZkn+naGP8dWkxRhPqcGpfZ9J6t6oJIcAC51oV0rXX+0ndq8Gf7Y4V9i+4zRR+blDeuSncNWM3U6lKlSpVqlSpUqW26yODymL0K5BDKSCHlCF2cWNjg5WVFS5dukS/36fZbOZ1Kev1uttF5iFcOHaAiCF+slqt0u12cwAZ6gwG6DE3N0etVmPXrl2MjY3lbSnCpQBKDhw4wNjYGHfeeSc7d+7k7bffziFocGLdfffd7NmzB2stzz77LFmWcfPNN1Ov13PQePz4cW6++WbuvvvufDzC+QIgCu1L05RXX32Ver3OfffdR7PZ5N///d/z+nxvvfUWg8GAz33uc4yPj/Poo48yPT3NbbfdxuzsbN6enTt38sILL9Dtdvmt3/otxsfH+da3vsUrr7ySg8lbbrmF2267jdHRUVZWVkjTlHvuuYdPfvKTPPvss3z/+9/nK1/5Cg8//DDPPPMMb731Vh6pGyJ4gwuu0Whw//330+12+e53v8vp06e57rrrOHnyJEop/vAP/5CFhQW+/e1v88wzz/DFL34RpVRe6684BwGOnjp1igcffJCDBw/y5JNPsrCwwKc//WluuukmfvjDH/Lqq68yNTVFmqZcd9117N+/n8XFRV544QWGhoZ44IEHOHnyJDMzM9x+++2MjIzkx69UKpw6dYr/8T/+B5OTkwwNDfHSSy/x3HPPceutt6KU4vHHH6fVarFjxw7+5V/+hXa7zb59+xgbG+MHP/gBJ06c4OMf/zjGGE6fPs3U1BT79u3L12exbyHK97HHHuPNN99k3759rK2tcfz4cb72ta/lbtC3334brTX33Xdf7hiM4zi/2RkMBszMzLC4uMj8/DynTp1icnKSnTt3UqvVeOWVV4jjmG63y9LSEl/72tf44he/yOXLl/nmN7+ZuwbfffddHnjgAR566KG8xmkURVvqQkZRxKVLl3jkkUeoVqsMDQ2xvLycuyC/973vMTY2xmAw4Pnnn+cb3/gGa2trPProoxw+fJgkSfinf/onarUak5OTTE9Pc/z4cf70T/+UwWDAY489lgP42dlZFhYW2LVrV74OAqQMUcCNRoODBw+yb98+BoMBjz/+OHv37uUzn/kM77zzDiMjIzz00EOcOnWK733ve9x9992kacqFCxd46KGHuOmmm3jhhRd47bXX8mNnWUaj0cgjpEOk8B133MHy8jIPP/wwlUqFxcVFDhw4wJe+9CUOHTpEHMe8/vrrCCE4f/4877zzDoPBgIWFhfz7rFSpUqVKlSpVqlSpDytXk1GAVY6jEOIPLVK62nUChfQ5nkpEiDxa0sFAK4JXS3kSlaFUjDFuI54QEiEzrE85EtWY2tAQzd37aFydRne74EGmLyuHti5yMtqCu/w9Ds6dp6yL8nT1Ji2RgMyGSoOu/qUSit58h/XZGQadddJUU6taD059/KV32wkp/MZkB8JWl+dZWV5i984K63NLNH7tNtKkj7CWoXaLSrWCzlKef+FZfuPe36RRrdHZGKAzQ6M6yqCXEjcj1tbWqVbWiKM+2pc4HBkZ4+aP38w7777N/MIcAksv7YCRVCoxOyZGWVlYxabkMbjaGAdxPRRyzkXnqBTSbo6DVAiyrbDSJ2wiLMrX+Swm81oL0jonpQWUdG4055YzYISLUjWbrj3pna/GWyit9ccLjsUA+oSr2RgY0IdBQZnWLK0ssG9yDxevTNPr9d/3OW0smbGkWcK7F84yeWaSo0c+Qc9Y+v0+z/74OBMTO9gzudsRVuH66GJOg4vSuQ5FSG61Fm0ylxOLQdoII4KD04Nc4WJujdUORHqXqfWgDQ/PsK5molIKbbRzYYJzAtvAhyVWSLTOyCwIVaHWGKLZdE5KV34x8zA1DLADgyZsKPCbA6wVvn7swI+ycym7ZwPawz+3cgJGNlaTpaEEi3bwWhuyNMNWPBDEuSizLCXzJWSiqOL7oLFI91n/nWGEoNVoOICbZejMkCUJ2mjSJKGzsYbt9VAKd7zMYrXBRg5KCusinZ2rUwGurich29nHxCphsUg0BqFBSheTbK1GeLhurUH7KF7nBveAUmhkmAM8qBXOJVuqVKlSpUqVKnUtfWRQGZyTwbUI5LGSASaG6M12u83evXs5cOAAvV4vj68MkC4AzwB/gNwVGJyaoa5ho9EgjuMccgB87GMf4/Lly5w4cYJms8ktt9zC8PBw7src7uoL9RCDe1EplTsOQ+Tn0NAQ9XodgKmpKWZmZvj2t7/N/v37OXDgAIcPH86jbpvNJt1ul263m8dvhljSACuTJGFlZYU77riD3bt35+PXbrcBuHDhApcuXeIHP/hBXi8vxFvGcUy73c6h7vT0NNPT0zz55JNEUZRDpgBbP/axj3Ho0KE8XnV0dJSDBw8yMjLCjh07aDQaHDlyhMnJSfbs2cPJkydzh2lwnYVanTfffDM33HADWZbx/PPPE+o9vvnmmyil+O53v4uUkrm5Oa5evXrNMS/WcqzVahw5coSvfOUrZFnGG2+8QbVa5aGHHsJay/T0NEtLS2it2bdvH1evXuWNN96g0+kwNzfH0tIStVqNer3OJz7xCR588EHGx8fzmNRz584xNzfHjTfeyIMPPohSimPHjhFFETfccANSSn7605/yne98hz/6oz+iXq/zG7/xG3zhC19AKcU3v/lNVlZWuOuuu9i/fz+9Xo+JiYl8LYf6jGEtgYvbfeWVV/jc5z7Hb//2b/Pee+/xD//wD5w/f55PfepTPPfcczz44INMTU3ldT6D2zZEn4Z5O3jwILVaja9//es5kA9Oxm984xtEUcTf//3f85Of/IR77rmHY8eOsbCwwB/8wR8wNTXFI488wksvvcQXvvAFarVa7m4N12e47l555RXm5+f58z//c9rtdh7J+8gjjzA1NcUf//EfMz8/zyOPPMLx48c5evQoq6urOdCuVqvce++9PPTQQ1y6dIm//du/5dy5c4yMjHDy5Enuv/9+br/9diqVSl5LFHgf6DPG0G63iaKIN998k4WFBc6fP8+VK1eI45hWq8Wddwk8XdkAACAASURBVN7J7bffzr59+3juueew1jI3N0elUuHo0aO0221uuOEGzpw5k0dQSym3uFaFEHkd0hBxGxScpiFeNriiwxr89Kc/zcbGBiMjIwwPD3/Ur8xSpUqVKlWqVKlSv4KSUnlkkYFxTiwrwOIdlYQ6dAJhBQaDFhqFzB1MDh1Kh8+EQFqFFtoZE62LWZXSbN5XS4FqNqjvGKN9YD/Z6jukKw6guLqHDkCGAoE2OCVxMEYbVwTRmgx8C5QA7Z1vctMf6iDEhmVt+hIbq0tkSReoeyArHAexLkrSxX2CzAZUFi7Seu8E7WzAhffOM0hatHbvoD26g9On36LRamCt69OFSxc5/dZrTOzZQ+fsKlaANIJIVIgjSa/fZ6O3ThxVMVogpPs3fbPR5PZP3sXIyBgXLrzDaydO0M3WkEoiRI3qUIQWlnQtdQGiHhAiLEqEcTHIKCKUoNTGkHlAXJTji85tl1lDpATWOLjpxtV58JAS5R2IUigQxrMbAUKRmRSbWR9z6uFn4fMKiZK+LqYHfCK44bY5PX+e1rtdZudnObBnkgtXpun1B+9ziiZaE2UQ9Qf8r1M/ZWJiJ2Nje9GZZqOb8aP/eI4HH7yP9lAbgcTgYm6FdpDSxdMWz+raKf3K2oTwoZ8uKjX0z+jMYT+hclhoyDzQdKhWhzRiFYHRfswt1kqkEWQ2IzXus41Gk1azRaNWR0nlz2X8vIv82ZZzOloPXC3a4Mdde6DnImeN3ryCokgR67C51fiNCW4DgNZZ7gQVKISNcjgY6p9mWZbXLMUGD7XzmkopsFZijPuOQEpajRY6S9E6RWcJSZqQDRL6SZ9ebx0lDWmWoY3GWIvQDh5npk+ok5qZQQ64scH5LHP4mkf3CovR2sXyCouVYDPtILSf0xCJCwZhna9V4jZqWOmclRQ2UJcqVapUqVKlShX1C4PKcDMUwOJgMODll1/OAd0NN9xArVbjnXfeod/v5/Ck3W7TbDZZW1uj1WpRqVRy1+P2+n/BwRbAZafTYWVlhcnJSQaDAa1Wi89//vPMz8/z9NNPc+nSJa6//votLrIAzAI0zLKM9fX1Le5LrXVeN7DT6TA8PIxSiqNHj3LdddcxMzPD+fPnefXVVxkdHWVpaSmvAxj6G8Yl9CeAu1DvL9QVTNMUay3Dw8M5/Dly5Aif+MQniOOYWq2GEIKNjQ0GgwHtdpuhoSHW19eJ45jrrruOO+64A2stk5OTdDodjDF0u93cURacesHR2e/3t9RYDCA11A0MwDbUGyyOfQA9Qgh6vR7dbpdDhw6xd+9epJTs2bOH8fHxLXG7sNVpa63NgbO1lpWVlbyeYK/XI4oiMh9ZkmUZTzzxBM899xyHDh1i//79rKysUK/X0VqjtWbHjh1MTk6ytraWR30+9dRT7Nu3jz/5kz+h3W7T6XSYnZ1ldnaWxcXF3NV5+PBhBoMBg8GAnTt30mw2SZIkd53+zd/8Dfv27ePOO+/k/vvvp1KpUKvVcudvGJcAlaWU3HPPPWxsbDA1NcXRo0e5fPkyO3fuJMsyRkdHGRsby+cgrJcwLkmSMDo6yq5du7hw4UIeTxw0Pj7Oddddx/r6OqOjo/R6PeI4ZnZ2ltdeey2vhxqieBcWFpicnMzrUCZJQhzHDAYDoiji7NmzjI+Pc/jwYdbW1hgeHubq1ausrq5y3333obVmYmKCQ4cOsbi4SJIkW9bJjh07OHDgANZaWq1WDvBuuOEGbr/9dv7qr/6KiYkJbr/9dn7v934vd0smSZLD/HCdXLp0iccee4w9e/Zw6623sry8nNdtDddBWDNxHLO+vk6n08mvvUajkV9noc5oEY4XHb3r6+v5RopqtUqoZWqM4f9l791jLLkO887fOfW6z35PP2ampzlPzotDzlB8SSRFSY6kNWVH4QqxtGtjsxK8TuBs1gIMLBAgfwQBjEUCx4gX8T9xIMSGgQSJETt0KJsxZYoiJYoUyaE4HA7nwel59PT0+3b3fVbVOWf/OHVqakYjiZICeHddHzCYmb731uPUqYuu+tX3fSMjIwC5C7Ver7O4uMjc3BxBEORdr6VKlSpVqlSpUqVKfXjZ3kGJdX8ZZW/4WzdY5lYUtgOPLC4UF2VpbGSr7ZCzywKRucAssBTIDJxIfC/KuubACwKi4WEaU3uId26y2V5CKZmDE9d2aKElOD+b40raQRUDHoo0D+HM4CQSULZ/U0n6yyt0N9YYdLvUx8bxsn3DkHXTZfurFNGVN1Hvvkz1gws8PF7nTy+v8P7577Pcuskv/O1f4MoHbzI2PkIlCvCAeNDn+T//c/6Pr/6fLFxbZNDvApq0D0FN4AmJ0QKlbARmVPFoDtXZtWsXqTLs3LWH4/fdTxBV+OZL32AwsBGdY6MTGLOGSlK6XQ1C4EuRRa/a+FYpLdT1pY/RNoxT67vhwIxkZu9XxvZT2qhegzACKWz8phZZ76e0x01pgxTWLeh5kjS1MZl5bG5xdVkPposRzfI5M/DET5D9al2eW+0Okb/B3t2zfHDtGoN4kMNRYVfHINFUQ8X29iZvvPUdfv6zXyCIAoyAa1dv8uqr3+PnPvUUnrQY0lYsZte6ujBvjMjiX28NmYt71S7SGNt9mOWE2ipFR4mdG8949r8ugtjYNViHYBaFLKTtYJUCrQQaQVipUqnVqVYq9r5FFifr4KklozrDvQbw8nVL6dKiTH6+GaNy+G6JvMxcw37m+MxibpWyrwl75imdoIx1WErp2e8FFHEyIB50SVWCNqEFnlkMsdHkMc/GAUWhaTSapEqhkpgkTUmThDhNWFEpve6WfXg368Q0OnO6mlvfMUJ4oOMsylVm0DtzfuO+h7LpXejhFFpjpLEuVuMeTjf28Qqj81Qjk323CAPS3BmaXKpUqVKlSpUqdUs/U0clkEMxIQQ7d+7MIYxzKNXrdU6ePMmlS5e4ceMGSil27txJo9FgcnKStbU1FhcXOXLkCJOTk7f1STrYUK1WmZ6e5u233+bZZ5+lVqvl/YxpmvL6669z7tw5RkdHCcMwh20OlhVhhQN0rttvcnKSJEnY3NzM4V6v16PRaFCtVtna2uLdd99lYmKCAwcO0Gq12NraIgxDJiYm2N7eZmFhIe8ZdI5EB0acyzSKIsbGxjh//jxzc3NIKVldXaXT6VCv1xkZGaHVajE8PMzMzAytVouVlZU8bjRJEtrtNpVKhUqlQrvd5sCBA+zevZurV6/mLsQi3HWgNAiCHHy5+MowDHPwlKYp/X4/d2U6ECilpF6v4/t+HrNbrVYZHh5mbGyM4eFhnnzySarVKt1uN3ewuc86OTBqjMkBru/7OWRynYmDwYB6vU6apsRxzHvvvcfs7Cz/5J/8E7a2tlhdXWUwGNBsNnMoZYyhVquxtbVFt9vl8ccfR0rJ17/+debm5nJn7JNPPslXvvKVPBLUQUvncIzjGCklBw8e5Ld+67eYn5/nxRdf5Gtf+xpzc3M89NBDbG9v3+b+dUDLQfper8fU1BRKqRy8uvmbJAndru3+cDA3iqJ8bnQ6Hba3t/PxARgMBgRBQBiGtNttNjc3McYwMTHBe++9R5qmDAYDjhw5wi//8i/nn2k0GkxPT+fb56Jf3fngfu46HAeDQd5dmaYpIyMj+Zi6OVSEnW6uuO+BMLQXUe5BhH/8j/8xly5d4uLFi/zxH/8xu3fv5plnniGOY5rNZg6nB4MBxhguXboEwG/8xm/g+z7z8/MkSYLneTmwdO9182rXrl288sorXL9+nTAMmZ+fz49ttVplc3Mzn+uDwSB3w9ZqNVqtFv/5P/9nHn30UaIoolar0W63831VSlGpVPj4xz/Ov/yX/5Jf+7Vfo9FocOzYMb70pS/lQLNUqVKlSpUqVapUqR8noQVKJYAFUzrvwsM6+3yBEL4FK9ZYBcb2/Cml8ojW3K1kbZU2eFL6WcQqIE0OaLRWSE8SVuvURsdIdu6kf3OdwYbtp0yNjSclhz0WLGUppRZUGmHjJj0PhHVWeii08CD3zlnIKY0g3ejSW19h0G5jUo2seCAycCMkQlgnqbd6HXHxNdYXFrh65QPuH6/w2hXJu91trlzaZvHGAgcP3MuNm9fYtWsXS4vrVDy4cPF9XvvOKxw8dB9n3z2T1a308Xoh9eEKRicgJUmaEpiQer2JEJI0MUShvWb7hc99HqUUL7/yEkolVKIhRkYkRt9E0SMZCIS2HjaEjWf1Ag/pIJPBRmjygzwwYz94WTysI4FCZMcE0FpYh6HOuv6UtgAzc8sZReabJQOkIJEoYVAZULOIWFhHojGZM5YsypO7bNkPmZduuw2sbrQIfI979+/l7IWLqFRl67PQNdXQ7adEoWF5eYU3T3+HBx98gnQjwfNCTp8+z+zsTo4cvjeHkmR+YITtFNXaYIQGBy6zQbTuSD93r9pxtNfbGpWBeue8tPDbAVwMtv8RO8cs27wV3YoAowyJMuAFRNU61UqNKIjsGBiDNhptBEkckyQp0kikZ8cY6UEWXSyyOYCRGJ3kxzuPt8XeR0nTFJXa813YzOD8QWdjLKC299BiDDX7IKwoVAbFMUmSuIVbWCiyNkit7HlpVOa1FHh+yFBzBK0VygiU1hilUGnCUjIgTbU9nmmC8GQGKw0IH20Su02ehykkEdlOS5Fvm4PhQgg8KUELlCesaVRKlFEIBUar3PXteZ6NNLZFnPaYC2kjgkuVKlWqVKlSpe6in6mj0rmL4jgGYGhoiEajkcOLra0t+v0+IyMjnDhxgjRNc6gTRRGzs7NEUZSDxR+mJEk4dOgQjUaDjY0NhoaG6Pf7zMzMEIYhR48e5dKlS6ysrHD//feza9eu3P13ZwSpg2Vzc3N5tKsDoc4tNjs7m2+P53l0Oh3m5+d5/fXX89jUyclJjh07xnvvvUer1eLUqVMcPHiQMAwpdlS65URRxPHjx3nllVf4+te/ngMU58C8//77eeGFF/j3//7f02g0SNOUw4cPc9999xEEAX/4h39IpVLh05/+NA888ABXr17ld37nd5iYmMhdgW79DrYopej3+/kvve12m1arlUMlF8Pr1O/3cwDsQJyDVG4Z6+vrhGHIiRMnePnllxFCMDo6yne/+10efvhhHn/8cZRSeURq0TXooHaapjlkdNvlnIrOremWe/HiRZ577jm2trb43ve+x6lTp9je3s63zTn0fN+n1Wpx8uRJTp48yR/8wR/wx3/8x3zxi1/kscce41vf+hZnzpxhbm6ODz74gLW1NQ4cOJA7d10U6yuvvJLvH8D777/PtWvXOHr0KPV6nV6vl4NY51Sdnp6mUqnwwgsv8OUvf5n33nuPd999l89+9rNEUZQfB9fL6mC5224hRH7euMjdlZUVRkdHb+s5dSBxc3Mz75OcnZ3l0qVLeXRsp9NheXk5dxY6wOjG1/ViHjp0iP/wH/4DL730EqdOneLKlSsA7Nmzhz/7sz9j79699Pt9Lly4wOHDhxkeHr7NEencunALvLpY4rNnz3LixAkOHz7M/v3787nogLfv+/n5IaVkcnKSq1ev8m/+zb9hZGSEl19+mUcffTQHvgD1ep3l5eUcih88eJB6vc5v/dZvMTs7S7vdzs8F57x04+nGvd/vc+DAAY4ePcq3v/1tPM/j4Ycf5qGHHsph5eHDh9mxYwdBEHD8+HH+6T/9p1y7di2PDq5UKvmcLlWqVKlSpUqVKlXqx8kkAxARStiHe7WxcZJSWOeYJ3yk9AlkmHUfShApyqQgIgurhA9ojElsDCaBjVTMIKZBgBQI42UdiSGen+KFPkGjQWVsnOpEk2RznVT5GRB1v9OKLGTWBsHavkBJaqwbUBiDFBJJVqKJg1wOCEmk0KieoLe2TLy9jUk0Rgm8wDqsRFbW6KuE6s2ziKTLoNtm4cYWwxF89p4xrr2zxEqa8r3Xv8enP/O3SK8mTO+col6rElSq9PtdvvXSixw9coJGo0G/28ZozaAds7G2AUZQHxrBaEOv28Ubn2BsdJT19U2k54MQ1OpNvvCFL3Hz5gJnz74HJERBlWZ9Aq1WSCuGuK9IBwqEBZYeApk9gKy0AiGR4u7XAzq75pVC5H1/qTGIzIkWSPCkj8ZYuJMBaOtus9fMnuf6EEFrgydFkUKCw6CZSxXIOk9F/vqHg5W3PiN9j9XNFs1mnf1ze5i/dhWVGmKlbNSvEPRTRT9WhKHgwsUL3DN3kOHhCba2OpjE49XvvM3U5A7GxsbtbHIg0rmCHegVAg8/i1D1rINRWEhpP5ZBOaNyt6PGIPNUIxuVauNg3exVWfCoBZxGk8FfgTL2WtiPIipRjSgMEV4Wlatt/2U/HrC53WGztYWHoVGJiHwP6fn4UUQQVcHXSGEfDJDSt/2wIgOjwmTHInNA5jHK7n5Itn9YAKi1QGn3QLDJ3LUSlWp6/TbxIGYwUAShoHhkjSHfZ7cWYxS+7zHUHENrQ5omxP0eqUoZJF2MFKQqJU0V0lfZNjmgaHs+jTE21lbbOSc9L+ui1KQqLewLSBlgTMKtKW6Qxj6UYGT2Xuz3hhA2RSnVqYWjKkGr8lq6VKlSpUqVKnV3/dSg0oEJ5/hzMALIIVgQBPi+T6fTAbjNEdXv9xkeHs5BTbHDrhj7CuTL2r17N1NTU3mEo4vi3LdvH7t3785jKB0EdM49tywHyxw0HB4ept/vMzQ0xIkTJ3JY9alPfSrvDvR9n8cff5yNjY3c/ecA0MmTJ9m3bx9Syty5V3SDOsDkwOCpU6eYmppiY2ODsbExkiRhfHycXq/Hrl27ePrpp7lx4wbGGEZHR9m1axe1Wo2nn36ay5cv4/s+O3bsYOfOnfzSL/0S77zzDnEcMzExweTkZL7+qampfJynp6d55JFHaDQa+L7Pvn37+PjHP06lUkFrzYEDB2g2m2itaTabPPHEE0xMTCCE4Mknn+See+4ByPd3bm4OIQSPPfYYYRhy5swZFhYW2LdvHwcPHsyPZ1FuLIwxOQR2Txvu2rUrd7o64BpFEUEQ8IlPfIJOp8Nf/uVf0mg0mJubY25uDrCOuqGhofy4Osdbo9Hg+PHjPPPMM/zH//gfOX36NJ/+9KfZ2NjgT/7kT2g2m6yvr3Py5EmOHz/OzMxMHinsXH7/6T/9J/7iL/6CwWDA/v37efDBBxFC3Bad646rMYbx8XE++clP8vzzz/PP/tk/Y3Nzk6mpKR555BFWVlYYHx/P3brO6epigovjEwQBBw4c4IUXXuC3f/u3OXHiBH/n7/wdhoaGWF9fz49Do9EgiiLSNOVzn/scV65c4Wtf+xozMzNsbW1RrVb5B//gHyClJEmS22KIlVJEUcTHPvYx3nnnHZ599llefPFFWq0Wn/nMZ/j85z/P7//+7/PP//k/p1KpUKvVeOSRRwCYnZ3NY5vHx8dz0C+EYMeOHfn4/dVf/RUvvPACvu+za9cuHnvssRzYFh9wkFLS7Xa5//77+fmf/3neeust9uzZwxNPPMH+/fsBeOKJJ/Ko23q9zi/+4i8yMzPD0NAQv/qrv8prr71GrVZjcnKSZrOZP8TgAG21Wr3NKT0yMsLf//t/n62tLYIgYHh4mPHxccIwJI5j6vU6w8PDxHFMt9tlamqKiYkJwjCk3+/n33ulSpUqVapUqVKlSn0YmaSHBvxKLeMVPlopjNT4QRUpEqQEZRJcMaHRIHQWm4rrqzMY4VmjmMH2G0oLFjCZQy0LZrXX04F1XAY+wdAI1Z0z9FZbDDYUwvjc8v258E2wdXsWDGkj0SiEi37MY18daNDILHLUEx6p0vRvLtNvt0jjPhXRsBDJGDApgVZUl96nvn2dRAQMNeogA64vtRm/x+eRj57izXffZ31piZWlFcKgwuVL8+zbP8v33zlHGNVZWrrBK698i4c+8jAXz1/EoEgTRbphQG6A8KjVmvR6fba22+yamSEKe3Q6XaQXouqKibEJfu1/+3X+1e/+LufeO4vWfbRWjI/tRosYg6bdarO50cETXnZdbUhVat13SqHuGv16y1WpyeJ0pbReQZNFhiIs7MzebEGkREqPxLnwjHXz6SyW13VSKm0/JDPYbV2FoEzRwXgrcvXDyCHNRq0OUnP9xiLHDx8mnprh6vXrFvZpi6SlFGx3e1TCkLgf8P3Tb/CpT/08gR+CEiwsrPDWG2f4xCeesC68zPlnshBRaxWWYAxpFitq516+t2Slqy6I1SZFZaBPa9t3aZ2ZAoyykDCPbs0AGQYhLZg2JrVRu8bg+wG+5+FJ355jJs3MfcY+DLzVYn5+Hk+lTNRrNOs1m0I1PIoZFoSyghDKglQNShuEyVpkTba/OkGb1N4PcqWnyiWF2U5aKe1jAWmaonWKMQFC+CRJj0G/izaaKFoBI/ECHyMg8H08T6IMBF6I73ngCRshnYW2ep6k0aiTJOMkyYBkMCCOe0QBKKVRqUErMFmI8y3InfVuZm2YBoNK03xuSLxsO208tUpjhPEywKqzjlyDFlnfbrZQQ3asSDBaIo0kNT/Y7VqqVKlSpUqVKuUkflp30G/+5m+aorvK9fW5iFAH+ZyrKUmSvHvRgYMwDHNA6QCKi8t0n3URkHEc5xGTvu/nTiv71KF3W1emc40V3XZFV6ADTA6QOhdkEAR57KNbh3MWOldWpVIByLcniqJ8e4UQef+dc7+BdWW2Wi0mJiZot9v5uty2u/clSUKlUqHRaNwGsdz2un0swlAHWNx6XMSn53k5DHN9fC66042FW7fv+2xvb1Ov15FS5u9z4xcEAUmSkCQJw8PDeayp68R0Dkp3bN12uu12++DGVGudd0J2u90c9PZ6vTwu10XOrqys5PsQhiGe59FsNvMew7GxsXz+rK6u0mg0ckfq8vIyWmv27NlDkiR88MEHKKWo1+uMjY3RbDZZWlpiaGiI0dHRHORduHCBVqtFFEXs2LGDffv23daT6mJnK5VKPucGgwHXrl3j+vXr1Go17rnnHmZnZ+l0Oly8eJH9+/fn8apunhWPr+vYjOOYt99+m+vXrzM2NsZDDz3E9evX6fV6HDt2DICVlRUWFhY4deoUaZqyvb3N2bNn2djYYHJykvHxcQ4ePHjbeeVcla4jFqDb7XLhwgXW1tYYGxvj0KFDjI2NMT8/z/Xr1/OHAGZmZhgMBiwtLTE1NUUURSwvLxNFEePj4wDcvHkzj/JdX19nfX0d3/cZHx9neno6h4fFzkwXUezmrZuDDhwXuyfdwwturrmuzeI+uv5Uz/Nuc3kWzw0XU12tVvMxcd9h7jPu365Htvg986Mg5djYWEkwS/21SgjxRji1/9TM3/tXf92bUqrU/2c0/389/TMv48UXXwTgqaee+pmXVeq/nx588EHefPPNN40xD/51b0upv9k6/eyfG6/ZxKvV8byIQdwnjrt4fkAYVEniHp32Bttb63Ta22xvbxHHfYIgolqtUK1ULZQUFkhqrZGehxDWGakdyDTWU+Z51vXV63Zpt9bptjcxg5ju4k02z59l/b3rqDjAQxJm7kD76LHrrbR+rVAo6n6fwINEC/pKEGv7+7fO3u0gJ0BiDNHcCPs/94scePQpRnbtxg8jC+JMQmX5PPVrryO7HZK4T2ejxTde+h4XP1jh3v/hCRoPfYaXvvk85y9eQQqfdjfmyrXrHD12LwvzN+j0UqQUTO7Yxf/8P/09uu0+62s3sXhV4Y1ImqMNRkcnSRNDpVJldvcs1VqNG4trBFGVmelpxifGqUYVTr99mt/93d/m6tUrJEmP5nCTRqNOGAbEcZ9r89fobPbstZpJUKkhUQqlNHGqSe9yH0UKQeAJ63I1Bik8PA9S57Ik42pZxq5zVHpSWteZBoTM7gVkjkFhl5ukFkhKabGeL+06UmVy4qi5lWj04yRFjpXwpGD37BTr6xs0KhWOHD7K6Xffpb29TaIMWkPoSbQxVMMKE2OjNOpVPv7xT7BjYg+brS5J0icMNF/8pV9kemYKByURrrPyluNTo2yEauYGNll/qx0Y11Vpo4e12x8h0dogpI0ltvA+671EZ6dH1oOaRY1qpegOElKV0hgaZ3RoiFq1kh0H2wOKMXR7A5aXlrl26SKq02OoElKvhPiVgNr4NI2xcaJG3YJbsp7RVOVjaYTBaEGSJsSDPt1uh5XlmywtLbDZ2qDd6WT3fAzSE4RhxMjIMCPDw0RRFaU0nfYWW9vbKK0ZHh5nbGKGMKxh0FSy+yBISRhWqNcaBGFoY1URWUemBbLdbpfllUVu3rjKjYWrBJ5mdnqSXTO7CEI/nysG11Vpo1uNsZ832mSQV6O1Aq1R2jpHtVFopTMnqc5SXW2krzHaujABlAEpSFNt42W1RhtJqhKE8vnK//4b5XVzqb9W/STXzf89rhX+/6DyeucnUzleP5nK8frJ9d9zzP7fdN38Uzsqgbz7zt3sd/Cm2N3nbuxHUZQDTOC2zjsHBBwMq9VqbG9vU6vVbuu+cxDBLVMIQaVSyd2PwG0wwgGhYuylix8twrMiLKpWq7c5p9wv+t1ul6GhIZRSeXdg0V1XhCkOqBRjUx18dHBlMBjkMZJuO7TWeUSo62xM0zQHXG7fHMAtjqUbW+ceda85MOkAjpMbh2KvpXt/HMf0ej1qtRq+7+cg1QGvYi+pc3EWx7m4TUUQlKZpDnrdtjo3Z6/Xy+dNrVbLHZbDw8OFTgcLPV2ccLF70RjDjh07cjDueV4e5wsWVDnHJ9yKot25c2cOo9M0JQxDDh8+fNuccPG8brsdMHfj5ubxoUOH2LdvXz7vHcw+duxYvg43R90YFf9O05Qoinj44Yc5fvx4DkH37t17GyCbmJhgamoqX9709DQTExP5Prl1uXnj5quDb+7ver2eRwtrrfP+yenpaXbu3JnvqwOBe/fuzef0zMzMbS7q6enpfHx27tzJ+Ph4Pvfc8XBzoNjz6Y6X7/uMjY3l55s75nCrD9cdE7ffbptdx2cRwhfjecE6EF5ZvQAAIABJREFUuF3EtHNcu/nu3ufcnu64uXU6p6h72KJ0VJYqVapUqVKlSpX6sOq3lqlXIqSugEgRZJ2TWf+bJwMEHp4M8HwfKT2EkOQ9cUZihMZDolBZXCMIoUD6SA1gQabEs59HZr2Qt6I9q8OjMLuf/uoG7YWeXUeGjzJvVRYBa9AOFhkPjP25i4cF8GzmZIY1rcvMFxq93aa/sUrc7WFUiq9Coo0PqKzP4928iNBdtDIIpYhqVSbGhrl6dQ0Zp9x4+w02F2/Sb21z/doSidHEWhNVAvYf2s+Zty+QxgmtjWXOnDnDRx99nK3tddK4b91s24ZBNEAPKaLQPpy5vLrK3OwsI0M1Wts9ttttqjXrlLvvxAP8L3/vf+WP/uiPuHL1A4yGSlSl3qih0gbdyQ5pfwmlIUkMZDGZyvxwz6IBG5Mrs8bPrOfPy6AiwjoodXZdKwQYNNrYLkrrL9S5a/JW6KdVfv0IBYDHraTXDwkps8OXgVCBBuJ+wv69s5w/P8+NGws8dPIUr7/xGkprtrYHKGOoBD79ZECvPyDwfd5++zR/+2/fS7cbg67QH3R59bW3+NzTn7aRtZCNgYcxqYWSmcvSRteCiw8WwsN1WmIExlpSM4xpoS+ozFVsj4fIIL2QHmiB4JYTUGSw0+gUIcD3hHUiZhGmJosxBkXgCUYaNcTsLP3tLTxtI2Zl4NuOVmMsEDUapaAfxxitrOPWt8dKpZo0TWw9TdInSQbZ2WRsB6VI8WRAFFbwfInOALBwXZDSQ2lFp7dNkqT4QY1K1Z7vOlEkaUJqFI1qndAP8X0bt0rm2AUPTEoYVKhW60SVKn4QEfogpJe7fUXuV/UscMzOYmE8pACFwmiXiAVIO84qzaJ4s6RbAOH5CGNIdQJIPOGjTIwRFlLbeezZbxljkMa3gLRUqVKlSpUqVeou+pmiXx2scTf7W60WnucRhuFtIMxBS/eZO2Gb699LkoR+v0+tVmNoaCh39zkY5eBGEZA0Go0czDmY5UCkc3AVwUTRGeWcUw6iFCGWAx0OIrptKALRXq+Xg1IHUYouQiBfdhzHOahzkM9ByaIL0vUe2igQfdsft/wiAE6SJF9ncf3u9eITlW78HBguvseNtXOnaq3zsXfvdWDJHV/32WIEsFtWrVbL11N0jRa3xx03B9ec285BI/cet+1uW9x+u3W5bSuC7OJyi8ejCI/d+9zn3fgXoWQRVhe32R1bB8vuXLZbfnHdReBWPI+ce9Z1NxbjiovbUNxPB+kHgwHtdjuHqsaYfE6688TNv+JcK84nBzjdH9/3qVQqOTx22110gbp/F/fDbZ97zX3Wfd6NX3Huuf3+YcsqjrfbPwc63bnionDd/HFzyTlH3Xi4OV48vsVjUfzO2N7eBmw3ZqfTodFo5GNXqlSpUqVKlSpVqtSH1fb1GwRREy+IEBWBya9pDBIfLVKkF9geRSSeZ112NgxToYWyuCarujMoCziEh8icaCbr/gMLyjDZ798GdGphideIqE2NM3ZgL6p9jmTL4gptBLLAw1z7nTIGhcAXCjKw5NlkWqyPUyKExkOgjEDjkXY0/ZVl4q0NdGeC2uq7RDfOILtt0ArjSVApqJQg8BkfbhJGkrHWPL33T7N0bpPFbooWPp/4zBPcuHadI4f2k6Ye1+eXabc79AZt3n77dYaGRtl7zxwL85eIdYzuK9iAwUifcCjCE4Jep8fNpSVGhkdI4y5bm+v2QccwolZv8NFHn6DV2uC//bfnqVaqKK1I0z74mkZjlNVwnUGnDRpUmpJmsa8OhN3JBV0EqxQyGyd7nWWERErQJrtWz0CwEFkxoMw+bSDWLk6TDGDaCFgEKKOxFZZZJGvGk23U7F026IcoB3nZHyEEra1tjh47xO5uj8WbS0xP7+Lwvfdy/sI5KpHHoJ9itIWVW90tqhWf1uYmlz54jz2z97K2solUkvfOXebY0SscPHAgW5fO4KTrcPRAWlupRmW9kl7m6NNAihA+wvi549JCdQ0ZNLR7qe1Z4oCncdGjWTayECClhWbCBRYLlAHhYk+5lb5TrduH5NPmkO2f1AYjwAsDZOhnUF+QJAM2W5sMBj0ajWGajSaeZ5C+QKJJU7s9fhBad7MnsnBWH/BsN6kG5R72RiGkxBPu2hziZIBRisD3SbUiSWM7N5OUJIRBHBNWqm447EMKxp6HUkrCICSKqvb+hrGRxUoNCHyJMdKh3xwW2+EQpDoGh4YNYARporEwVOddqNo5V0UG2TOwrkySObs9VHY8ZdbZqY0GaVCqvJ4uVapUqVKlSt1dPzWoLEZ6uv63a9euIYRg7969tzkEK5XKbXChCAuAHDK4yNVOp0O9Xs/BQL1ez51Tg8Egdwc6t5gDOwDVapVOp5MDjTAMc9DooKRzmDnQ4eCpgzdF0OT+hGFIkiTEcZx3VBZhUtFh51R0k1arVQaDQQ7EXDylg5auH9NBG+c8c243B0jcGLpIVncs3Pa49zkHqxvrYmdmcf+KgNHF7LooXAd3i07RIjhyP3efd9vp1lEEOw6uFt2fxX0q/nHLc6852OvW6f5d/HxxXjoVHXVFwO0iZN043Alif9Scd/tfjBMufv7H6c73FJ3CRXj/o5blILdz5Lq55OZzcZxcPHCv17ttLN2/i05SB+nccoou3R82HncbnzvH48PGD90JOt25UDwvXQyz2w/nFnbncNGh7OJmiyDfGJNDS+fkDYKAMAzpdDqEYZi7Jov7Xuy8LVWqVKlSpUqVKlXqw2rz2jxRY4igVsfPXIwIiRS+dYIJGwnp+uCkyB5KNQaw3XfC8zJIIAELB40Bow1ap3ZZWZWk0dapSdYNaNAYpZFRhWishplN6a2sstlZwSjfAjEyZuUeFjUig5gm42iZOzBzYpm8jS671hOp7dRLU/qry/S3Wojlq/itt6G7jTEaGQRZoqdASgGex47JMQ7srNJEMtsMuXdIcq0D7SRFSp/Pff5zrC+tMTQ6zN79u7m52KbVusnK2g2ef/6/8vlnvsDoxATLSwuAIt6O2V7ZIggqhGGESmN6/R5gSOIBcaypRk1a0QbdbpdarckjjzxBkmgWri9w5swbbG5tMjk5waAzIB2kCO2BiUm1Qjk33g9xVRqTdRdmljPnnNXG9iv6QqK0yh2R9kFXiLyAJM2cttpkcahgKZJEoSEDQm7ddhm31v2jnJ53k+OUnrC0U6WKlaU19u3fy9LNVT64fJGHH3yI9dYq0WaH9VabNEkJwwCtEjqdHtVKg/PnznPo0FEQ4MkIlWpee/MN9sztIfBt1KgwLk7UdnVmlY75Nlhw5hx40u5f5ii2w5AivNAStcyJmtFdu8/GjbnIwKW0DkiddYoaQb8b0w/6BEGIENa56WaxNTQGhFVBWKnaWFqj7HsEeNn1Z6pS2u02i4sLtNstpqZn8T0YGmoipI8UAj+JCcOAKAypViL6UZVBf8BAJ5DFpSoMWmlUav8vfZC+zCG671Wo1Oo0GkMWdGbpvjpN8PzsWlhrkFm8rhEotK0BNYIwqFOJGkSVGoPeNmlqMNpDK4kRztGq0Tq7j+MiZNOsbxOJwMseikhd8ycIk/VO2mMqs+8gTPZdYQAtLZTM7kVope15g7FJtR/y3kCpUqVKlSpV6m+efiZQWXQCAmxvb6OU4t57781v6jsA4sCAi3l0TjQHDvv9Po1Gg36/z7lz59i3bx+jo6MEQUCj0SCO47z/0n2uCL2A27obHYxw8KLY3+i22W2Tc0S616IoygGhizqFWzGqvu+zsbHB0NBQ7oJzkaZubBxEceCpUqngYiUd7HCwqNfr3eaIdI5KBzQdsHQXjm683Xi6n7nXi8DKQc0iYCwCOucKLPbzuZ+7cXY/d6Cv2ONXBHxFUOqiMh0odkC2OEZOxflxp9uu6GC7EyTeCfPu/KwDlW7/inOluL67ffZuKrp/i/C76By9m+6E3u5nWus84rjoci26h++morPYfcbNAxdZOhgM8ve5nla3jUXnLtyKWXXvdbG7Hybm9E44WYTmxfcU9cOWWXQhu/F27y/OWQcyi+dVEW6urKzQbDap1WoMBoM8ktg9cBDHMYuLi9Tr9bxj0zmF3cMMUkrW1tbwPI8oinj11VeRUnLy5Ml8jEuVKlWqVKlSpUqV+nFaO3sGL4rwqzXqQkClihf4CCEttEFbcEmA59nfoYUQKJ1mN/btH+MyLY2NxJTCwxjroEx1jEQifOH4DbnRDAsRPN/Dj2pUd4wyvO8e4tYWvZsJ2niAwBPu3RlUMJLUSEJjHX+eUK5aMVu+zoCZRCOQWWRkvLaB2rxJWNlmsL5I6Hn4UWSdnp7EKIMwAXgezZERhoeGqFYaREHI8ck2Z9dSuqni/e+f5dGPPczUpMfWdocjxw7R77zPUP0Q5y++Tat1nef+65/wPz7zJRrNEbY2N1BmwMbSGjLwGZvagTaaJE4I/IBUKRZvXKPT3ubdM3D16gLHTxzj8NF7OXbkfmZn97F7927+7e//3wgkg/4AlaZopdHajjlG/QAMvC15NfPdSZFBNGGdaQIbZ6qNc6CB73nZ+BnbYSntNZknPIwkc24KlNF3JsBi3bjSum5/Cu5TeLQaY7B9l8DNpWWOnTjMzM4pblxb4sr1axw/cj/vnn2XWq3B9YUl0lRRjSLieEA8GLC2scr85UvMTO9laXENT3osXF/lgw8+4N6DBzPW7maOsUDVWNepMRYsCshtnlJm7kqtrbNSZE2omaXYCM+Ocg4yLfF042qzSTOIlyr6vS4brS20usnq0BBRxfamer6P7we2Q9Xz8IRAeh5S2nsgnhRI6RNVK0RRiCcFSTuh3WlzY/EKNxevkSQx9VqVZrNBmC1rkARIKfB9jzCKCMOIKKySxBqlFUrbqOQ47pMkNXsdLi2ErkYRGEMQVGnU6zSadYKgkkFVd04LpJe5LwFtW2oxWmBIMcbPrm2rBJUK7e0NEpUyiAcEYZQRYoHOAKNy90SEsXHC2UBqrUhVClh3sDYqB5r2YHm2p9UYjLH7ZTsss5RkI1Cp7a0UiOyhB8WtuzulSpUqVapUqVK366cGlUVI6YCkgzbXrl0jjmPq9TozMzN4nsf6+noODKSURFF0m0uxCIFWV1fZv38/jUaDwWBAp9PJgZmDDQ4yFaGj61csdiE68OM+79Ttdm3ER7Wag5MgCOh2uz/gIHOgK45joiii2+3yxhtvMDMzw/333587teAWwC1Gnp49e5bl5WXq9XrumnTusBMnTnDu3DmMMTzyyCOEYZh/9m6OtiKYKsZvOkeogzzF14qxnm5M7oxDdcfRbVexF7MYvVuEccUOwSKsVEpx/vx5KpUK+/btu23bi/vg5Pav2G1a3Ha3zc4Beuf2F92WxfcWt6moOyFpcTk/Dli6sXFgzwHxH6U7l1lcZxRF+TLd9jq4/cPA52AwIAxDKpVKfv64uW+Modls5k7jO12Wbrtd32m9Xv+B+NcgCHKwXITPH0bFY1Ac0ztfv5uK7tsikHTb4L5jivPWzRm3vWma8uabbzI+Ps4DDzyQd2y6hwZcrOubb77JzMwMU1NTefxu0Qns+37+oMRgMKDVav3EY1GqVKlSpUqVKlWqVO/GIivVdwmaQ0g/pLJjB57XxMt6KDEaKQ2+D54nkZ5EiKx+Dp11ukmMySJBkWhhnU++DDFGZQBDI0SA8EAoD4SHdCGZRoHw8HyfsDFMbWoXzXvWSLcvk7StQ1MjkRjrfsscnjZcUxAIG/MqjH1Xho7Imu9sPKywQZqjFcORepsJv4+uhmil0CrGEAHKWRIxSUxUDRgfG8NPIQob7J3p8sntPtFyDdPcxebNFicfe5Qzb7xOGsfM7p3g/TPXqEQ1ugNYWb7Bt176Jp/81Kfo97sYo0mTAWs3lvFCj0qjgeq08wQVYwzfffVt+j3B4s3LDI9W2TO3kyRJ6MUJjcYoMzt38f0z32dyYgx8gUpSEm1IlLqra/HO/2tjQGh8z0NricyifMmclZ7xCuBNWOea1iAUOhtXd8kkuRXpa3KQbKGV3Zbbayw+rJwj0zZpWqIthGF7e5vFG8scvPcAC9cWWbi2wP699zI8MsT2ZpupHROsra4iRYDnGzqDLpU05P1zZzlw6F6CVXu844Hg3NkL7J2bJQhDG6MqRdadmgFcsooTMlBmRMYqbcwo0s55YzQGL3M4Zlufu1qzWFVjLKTMHIbCZGAMiJOEpaUFbtxYRAhBFEZ4vkfgewRRhcD3CYMKQeDj+yG+HxJVKkRRxMjIDqandtCoRtk1Z0Jrs8VWawOdpvS6W3S7bVI1QU36SGEIfOuUNkZbx6onMcKgswhWmYFbpRSDeEC31yHSEUqlJCrJD1AaD0ALAj/ECBdrm9130galE/vtoDJ7KqBUCiKx8FFrpJYk8YDBICJNE7ROsjPWuUn1rTHWInNSC1SaWJekS3oS7preAk7rsDQYUoSWpFqhtUErO7eUsoAfbTK3tsic5LcehihVqlSpUqVKlbpTP1OOYTGy0sWMdjodFhcX85v+9XqdarXK1atX6fV6gP2l8ujRowghOHfuHJ1OB601Y2NjzM7O5sttt9ssLS0hhGDXrl202222trby14eGhqjVavn/6/U6GxsbVKtVarUam5ubudNsenqaWq1Gq9VCa021WiUIAvr9PkDu5hwZGUFrTbvdxvO8PJozTdPc2dntdrl582YOee7spSwCFikl7XabtbU1NjY2OH/+PM1mk7GxsTzK9vLly4RhmC+nWq3SarVuczQmSZLDXRfnWgQnzt3ogJfbb+eQK/YSFiGo207n4HRwq9hpWOyGvG3y3MWlKIRge3ubF154gdnZWXbu3JmDZHfs73QXOt0ZFVqMyS0CaTf3ivPvTjDplnVn72XRIVpcp1uvg1R3UxECuwjZixcvsrW1xcGDB6lWqz/6hLnL+ra2tjh9+jRHjhxhcnIyB2/9fv+HgspGo0G73WZ1dZXdu3fncP6dd96h3+/zxBNPEEVRvo47XcUOXrro4Pn5eer1Ojt37qTdbufruVvH5N325U5ADNx2TtxtrH/Y8tz3CNw+3u4BhW63y2AwoNls3vYwgpsncRxz5cqVPMbYgUm3zyMjI/R6PW7cuIHv+1y+fJnBYMDu3btpNBporVlcXOTNN9+k3++zf/9+jh07dpsrs1SpUqVKlSpVqlSpDyvV7rHx/vuYaoAIQiaDEC8MEVGI0YGNVJU+nh9ZR5mQlscogcTGSVoIKBDSucsyIKAVInOVCc8HISwIk5lrzfNcuCVKJyiT4lUj6jsmIT5MurnJ5rk1hPazsFGdGdQ0GBvxqrVES4UUwvYlotEZ5LDw0mIIhGBmb4PH/tb9TFVSfCUQw8MQhKiki0kVpheDsZYrYazzbXzHFEvz81QrFap+yP6JGt0k4Xp9FyvLMcvXrzExPcP2pQtMT+/g5s0lltc8wsAnTRIuvP89xifGue/4MdaXb6CSAUmvx9r8TUbnJjBCIoRkZHSE8R2TrK60eemdVwlDn267zUZrnUE/ptvtkSZ9up0O1UqNajNkamYH169cx6TW2mr4EEDQWJepMCCFdeZhINF2DJVJs25Jz8Z1GuuqVdpYdolBKbLjbTtEDTo7zpmrzjjUeMvfVnR2fjjZeGEtXKKSXd7Fi5d56qkn2TE9wdrSKufOv8sDJ+/n1e9+m4nxMVQa09keEIYBKu1jUs3W5jbrq0tUa3XiQR8j4IPLN2htbjE+MYYQFsbqrFMVITIAaV2TIEB6CGMsbENk+2sQwrcgN3OrksFNt9cym7nOcSyEQEiJThXGRbpGEZVqhcEgZru7hVKaeNC3sM/dGzCGJEktzA8ims1hTpx4iEazzvBQE50kbGxusLKyQJrGjA5PoLWi096i1+3TrDWQnrCGZm1bKYW0f6SwkDZN+0jh4UtDksLWdout7Q37PaE0cdwnTQzGpGxsbtJuD2gOjyK9LMY2O++0VoCH1gaVphidYLCx0kZbl21rY52Fxau0NlaoRT5K29hWez/E5HG7QtiaVGVShJEI41mXr7HQVOvMNZ0BYJEBcnsfKMUTARjbtaq07aW85aLM0nrJOi6R6DT5iWZpqVKlSpUqVepvjn5qUFmEU85VVq3awu4HHniAbrfL6dOnWV9fZ9++fezdu5cwDFlcXOT06dPMzMzk7sm9WaelA4sOpC0sLHD69Gk+8pGP0Ol0OHv2LOvr69RqNTqdDs1mk09+8pNcuHCBc+fOIYRga2uLU6dOoZTirbfeyp1Qjz/+OJOTk7zzzjsEQcDx48cRQnD69GmEEBw7doyLFy8SxzFbW1tsbW0xOzvLkSNHclfW2bNnuXz5MsYYWq0WtVoNY+yTh/V6PYcyxYhV3/e57777eOqpp1hYWGBpaYkjR47w6KOP5u5B3/cZGhpicXGRlZUVduzYwdjYWB4/u76+zubmJpVKhdHRUSYnJzHGsL6+zuLiIlprZmZmGBkZQSlFt9tlZWUFKSU7duzIYeudsafuOHqeR6fTua338k5nqrsgS9M0h0BRFN0WC+tgmDvOIyMjVCqVHNw64OS24U7XnVu3UzGOM47jH4j7LbpGHUwrdl0W4ZJz3DmXaxGYunH4UW45dyzd5906vv3tb3Px4kW+/OUvs2vXrrvG0RadmkU3JcDq6irPPfccQ0ND7NixgziOGR4ept/v558pOjLdWP/VX/0Vb775Jv/wH/5DRkdHieOY73//+ywsLHDy5EnGx8fzMXPw2RiTA0ylFNVqlY2NDb7xjW/geR6/8iu/krsp3dy7m2vV/duN+Z3Q+W77eeeY3O11d8z6/T5SShqNBp7n0W63c1fvjRs36HQ6zM3NUa/X830puo9dhK2UkldffZVXXnmFy5cvU6lU+JVf+RUOHz5Mr9fj2Wef5Zvf/CYXL17k7/7dv8sXv/hFtra2eOmll2i1WrTbbV599VW++tWv5m7o4lgUVQLMUqVKlSpVqlSpUneT1ppka8Dqu2cJGyNU6k38WgUvDO0NfSEg6zAMvAjpeRhpkMJDizRzLoo85lIY60izzkTQFnfhGftOLQxoB0fAeEBC1teX4gVVgkaTxtQMg32H6C+9RryuEDhYaWMdZVZ6aVwkZIbBRI7FMpen0EgpGJlu8MjPnWJyxxieF1hXnLYdj36lgU5i9CBG92MLZwGR9cP3en0isUk86BJJwZ7hlI2Ncyxef4DIe5ujD50iqIToJOHQ4XtYWlxje8NgfI1SMW++9i3q9QZzu2aI+x2UEgw6XTaur1IZb2L0Bo3mEIEfMDYxxI7xITa3OrTbm6yvrtPttqnU6jSHh2k2R9kTRDSGQnYcmGB9pUW3u2Ghy4d0LQoh0dJAFl8qpXXV2Y5OC4OQBqGyPr8s19NeUgikwf4c99ItHHkLUppbPZUCflJUeWtfTN4fiYCV1XWuXF7i+PHjvLT6LW4sLHD03sPs2jnL2uoGs7vnuHTxApIQ42l6yYC6Viwu3mDPnsPolsbzfLa3usxfvsrI2HAWyWq3URvbZ2r/62VAS2exuj5G2ShkB2Rt0yq2C1FKECqLG7XuS1d0KWVg3cdaowVIKRBCUm802HvPIeZmD9gHtLVBpYo47pGmKYO4S5KkdNrbbGxukMYpQkqCwNXveCSpotfvsrh4nfW1FaIwotqogIQ47hAPeiRKEQovO472YQNjbt0P0FqRpgohFMpIpEjpdrZZXV9jo7XGYBATxwO0AqUTatUGU1OzDA2N4gc+xlltM1dvmiZoo1FpkjlThXUvaxs33Ot1WVtfwvcEw7WQdOc0xmRAXGnII3btd4vIwLXtYrXL8IRPohOEUdnsssdCmcx5bQSpSdDKZB2VtvcSLfPvIa1jhLQdt/b74kenUZUqVapUqVKl/ubqpwaVSZLcFtnp/nZxjJ7n0Wg0WF9fZ3Z2lmvXrnH9+nXSNGVra4skSdje3mZ6epp9+/YhhKDf7zMYDADr8lJKcd999zE5OcnGxgbtdpsnnniCoaEhXn/9dZIkoVar5ZGXJ06cYHZ2ljiOef3119m5cyc/93M/x+XLl/mLv/gLfvmXf5k4jnNQ59xXo6OjDA0NsbCwwPz8PIcOHWJ4eJj333+f0dFRDh8+zJtvvskrr7zC0aNHSdM0d7w5eFWMbJVS5t2V/X4/7yB0YLPZbObOyCSxv1h+5zvf4dKlS2itWVpa4td//dfzbfrTP/1T+v1+Hr3xla98hfX1dZ5//nlWV1cBqNfr/Oqv/irtdpvnnnuO+fl5jDEcP36cX/iFX6DZbObj647PSy+9xNmzZ6nX61y4cIHp6WmOHz/OlStXOH/+PFNTUzz99NPs37+ftbU1/st/+S8sLy8jpWRkZIRPfepTHD58mOeffz4fi5s3b3LffffRbDZzF+jly5f55je/yfHjxzly5AhvvfUWZ86cYTAYcO+99/LUU0/R6/V49dVX888tLi7y+c9/nnPnznH+/Hm01oyPj/PQQw/RaDSAW7/0R1HElStXuHz5Mu12m8nJSY4fP87IyAjr6+tcv36d2dlZFhcXabfbnDp1CoCLFy8yPz/Pvffey9zcHNvb2zksBOj1eoyMjHD58mUajQZJkrC2tsaBAweIoojNzU0++9nP5vB8bW2NIAgYHh7OoZkDwOPj43Q6HZaWlvA8j7m5OTqdTh5N7Pogx8bGuHjxIkmSMD4+zsjISN5j6ZyhYRgyGAx4//33WVhYwPM8RkdHCcMwPxcXFhYIgoCxsTGSJLFxRr0e7XabwWDAzMwMUkriOGZpaYk0TZmfn2diYoJGo0G32yWKIuI4ptlscv78eYIgYN++fWxvb7O2tpY/bHD27FmklBw6dIjl5WVef/11NjY2uOeee3jyySdzF68DkA4gf/e73+W5555je3ubj370ozz++OO88MILvPzyy3S7XXbv3s2Xv/xlpqam+L3f+z2Wl5dRSjE/P8/99990lJw6AAAgAElEQVTPb/7mbzI6OvoDINyBWdc3++CDD/L000/z9a9/na997Wv8i3/xLxgZGeEjH/kIzzzzDFevXuV3fud3+NjHPsbW1hYAX/rSl/B9n3/9r/8177zzzm0uZTf3nEpIWapUqVKlSpUqVeqHSasEo6G3tMXKmbeoj4xSbTTxwwAqTZS0UMaXNprVlz6BFxKnAzAgjefq+zDa/t4rDFjfo43DFNqCBik9ay3LwIiN9syAhEpQOiU04EcR/vAotZkZmvtm2exfRHVlAXWZzDuJ9a4ZbGefuOXqcl13fmDYc2Sa+x47ysRYHWEg1Sl+6GMSe11FMkAo8KKqhTb9PkKDSVM8D8IwIElT6tU67XaLWtUw1b1Cp7eftbUKm1evsPee/SzdXEJ1N7hn7xRvrLyHCHxAk6YdXn/lGwRPfZrheh3VGpDolN5mm1Sl9If6NJsjDA+P0GzUeeSjH+H1179Hkg7Y3l7H8ytMTc8wMzPNwUOHuHjpfSZGx4jTHmOTo6ysrjsu/GMkkFJgjEJq23F4K7DVAkFpLJy07jN7LEXWO4hJQQjb/Uf2AGh2DBD2GBvjnJfZGrNLkR8Mpf3RyvyJFlIZge/Z3tMkjrm5tMGRIycZ3zHG6tIal+YvcezoMc5fOMfkwfvYuXsXSzeW8QMfpWLSpM/K6ip79xuENHgKhJScO3+R48ePEkVe5oa0EDe/ljI2EtUaST2MSGxsqnPgFWKIbWZs1ukKCJkBNqOyqNXUxsVKm6hkhAChCMMK1WqTeqVKGAaAxGiT9UWmaJWitKbb7dLpduy1qvTwfY9afYhqrZLfB1havsmg32OoOUoYVLKYZkGqYlKV4LkHwh2HxbpqBQKlEpJkgJSCQAQkKmW73ebCB+/zwQcfoBJlPyckRin70HZ0hqHmKMND44RRiOdl+2Y0aRoThDWkNLbXVFjnI0Jm0FHlDtMkjYmzehkpPRAyc2UaCxaFwOhsnmGQ0qZQSZH1fkoBWljAiUSSZm5rTaoVGJGPJ0ba3kx1y/lrtLHeV+GhTOmoLFWqVKlSpUrdXT8TqCx23TkXpIuUdBBkZGSE+fl5rl69yr59+wjDkO9///uo7JcvF005GAwYHx9neXmZdrtNkiTMzs4yNzeHMSYHPM1mM4cR3W6XOI6pVCrMzMywf/9+oiji2rVrdDodduzYgZSS6elphBBcvXo1X0alUsljVp1r0PM8Hn/8cR544AG2trZ49tlnWV5eZmJigjNnzvDII4/w6KOPsrW1xdLSUj4WnucxGAzynsDBYJDHtLro0WJUqevIcO61wWDAnj17+PznP4/nefy7f/fv+Na3vsUzzzzDq6++yujoKF/4whdotVr80R/9Ed/4xjfyLsOvfvWrOXDd2Njg5Zdfxvd9/tE/+kdcv36dv/zLv+Stt97iscceyyGqgy7b29u0Wi2OHTvGiRMneOWVV3j++ef5zGc+w0c+8hFefPFFXnvtNe655x4GgwGHDh3iscceI01Tvv3tb/Paa6+xd+9eLly4wOXLl9m3bx8zMzOMjY3Rbrc5evQoi4uL/D/svVmwHdVhtv2s1b17z8OZdGYdzUJIMsJgBBiMwQaMf4xxbIwTj0lciV0ZKpXc5Mo3SaVykYqTryop11+JM3gIcRKnkEecGOJYOHYwCAsEQkIjOtLRGfc89LDWf7F6tbYUyODc/V+/LiPto917d6+1etfp/fT7vl/4wheo1Wps3ryZf//3f+fxxx9n9+7d5PN5nnjiCVzX5cYbb+QrX/kKQghmZmaYnp7mG9/4BocPH2bHjh1kMhleffVVNm3axIEDB+j3+0nUaqfT4ZlnnuHo0aOMj49z9OhRnnrqKT75yU/SbDb5wz/8QzZt2kS322V0dJTx8XG+973v8W//9m/UajUOHTrEww8/zNve9jaazSae52H7J1utFl/+8pc5f/58AidHR0f5jd/4DbZt28Y3vvENTp06xQc/+EGee+45/vEf/5Hf+q3fYtu2bfzd3/0dzz//PL/927/NiRMn+Ou//mvOnj1LuVxm06ZNfOYzn0mcyEEQ0G63+bM/+zN+/OMfo7VmcnKShx9+mNtvvz2JZC2Xy5w6dYpnn32W5557jr/4i7+gWq3ygQ98AMdxePnll/nsZz/L2bNnAXjkkUd4+OGHOXv2LH/0R3/EysoKhUIB13V55JFHKBQKfOc738F1XRYXF7n11lv58Ic/TLFYJIoiCoUCg8GAo0eP8oMf/IDf/u3fZn19nT/4gz/gkUce4Z577uELX/gCO3bsQAjB1772Ndpt0wPzox/9iMuXL/Oe97wHKSWFQiGJVH722Wf55je/yYEDBxIQ2uv12LdvH/v372dsbIy//Mu/5NChQ3zoQx+i0Wiwd+9eHn30UV588UX+4R/+gdOnT3P77bfTbDbJ5XLJZ042myWXy+G6Lrt27eLEiRP85Cc/YWVlhTAMWVtbw/M8FhYWmJqaolarMTMzw+LiImtrazzxxBMcOXKEarVKGIYUCgU2NjbeMIo3VapUqVKlSpUqVao3ktDaxKcqh9ZrK6wce55iqYZwHfITAp03wCMSAi2NQ9ERLkIayKcIcJRnohottRI6BlTauDJl7OTCgAmFAqkTMGRgiiIIQnIFkK6Lymryo2NUt25F9Ac0TlwgCpzYK0kM2GTcLRcBAjdORYnQOE7E5JYKb377fmY2z5DNZFAqQHouKBcV+Aa4KB/HzYHnQhThSBdyHrozQAcRUsLYxCaWL1xk08Qovj+gtXaJkZxPZeU56oU7uXjyNJvfdIDKpmleffkn1NefpdPaIF+sksnl0DqiOl7mzPkT7Nm1j0KlTLO5jooUg1aX7qDHBeEipSKXdxmhzE03H2B9vU6/12NyeoSxsTFGR0aZnJzgwuJppCNpN3rkcy5IUOF/DgItz5HE9ZMIA2yFgVdCOqa7T8VOwHicTf8fqCjCdVwirXG1IlI2+jUGkwqi2H0ppAFLNu70p239s32F2sZ6uop8McN6fY1AZdi5awcbq+ssX15i3/X7GB2t0WjV2XfdftrNHzAIAhxX4IchzWad0B/gSg+fPq4UXLy4zPLKZWZnZ5Aik8TcGugbu0LjPkqIjIs4jk01saRxNyUxpBdu/C8y7lI1AFjFJF9i4oS1UqAiHClw3AwZ14ylkALXcXAcSRyuG8f5hhSLBSqDEuCQcT0c15wLxvHbY3V9lXp9Ha0VbpxW67oOjuOiVGiiZjOx01OD67hkvTxCNgGNFhKljAtROTp2jUry+RJb5rczMjJCJucitCAMAwTgOhnGRqeYndtKbXQC18mghSIMB4R+SMYrkM1mkDKDMGelOS4h0DrEH4SsrV0kK0MiBUpppDIdkhYBa6GN7Tru9CTuwkVrQh2i415ahDAuYAQ6EvF8iNgRK2MHtTRzqzRCSzQREkmkFAgTCyv/d+1TqVKlSpUqVar/H+un/i3BxmjCFUel7XZcXV2l1WrR6/XYvHkzvu/jeR7j4+OJC846wxqNRhJDubS0hO2atLGwS0tLTE9PJ5GVQNK1ZyNBfd9PXGnWXWm7/mzsqQV7w9Gddp+t2ywIAnK5XOIEzOfziftydXWVSqWSPN/GhPb7/cSlaX9uoy/tuNhjHn5s3Zb5fB7XdRkdHWVsbIxMJpPA2H6/z9raGkopDh06hOd5gIHE1WqVTqfD008/zejoKFu3biUIApaXl6nVajz//POJ63VtbQ3f9ykUCglQBshms4yNjXHPPfdQKBS4ePEiuVyOt73tbUxNTXH58mVOnz6N4zjMzc0lrjsLma0rVSnFwYMHef/7308ul6PZbFIsFrl06RJf/epXGRkZ4f7776dcLvPkk0+ydetW7rnnHrrdLsvLyxw/fpz9+/dTLBa56aabuPfeeykWi3zjG9/A930eeughJiYmuHz5MtPT03Q6nWTdWdD3jne8gzvvvJMwDHn11Vd5/PHHefXVV9m/fz/9fp+RkRE++tGPMjExwWuvvcbTTz/NJz/5SXbv3s3XvvY1vvOd77Bv3z4mJyevinkdDAZcvHiRSqWSuOw+//nP8+1vf5tf+IVfYDAYsLq6Sj6f54477uCZZ57hS1/6Evfddx8//OEPede73kW5XOZv/uZv6Ha7/Mqv/ArZbJbPfvazfP3rX+fAgQOEYUg+n+fUqVN873vf49FHH+XAgQOcOXMGIQTtdjuBfL1ej8nJSW688UZefPFF3ve+9zE2Nsbs7CxHjhyh1+uxd+9e3vve9/Lkk0/yL//yL7zlLW9hamqKD37wg4yNjSGE4LHHHuOrX/0qv/d7v8cdd9xBoVDg537u5xKA3+v1knMum82yZ88evvSlL7GxscHS0hIXLlzg+eef56677qLT6TA5Ocnp06ep1+t84hOfYHJykq985SucPHkyuZnA/hmGIWfOnGHv3r3cf//9jI6OAtBsNpFScuzYMf7t3/6NIAio1+sIIRKX7OTkJEopnn766eRcGO5KtR2c3W6XdrvN97//fX70ox8xOTlJsVhkbW0tiSO2N1hIKRkZGUmc0W9605uS9drv95mfn+epp56i3W7/p/HAqVKlSpUqVapUqVJdK62dGMy4qGBA89RZ1kdexs164DhkRyYgXwSl0VEEwkHGvXaOcAAHIRyEVgbaCMf00KHjiEmBUBKJQEgHgYNSg/iaT4Iw17wiihDIuAPTPNctlihsmkOGCr9Zp7/YBmWgkWn/ix2VSdSoRIiQXF6wZe8MN751P+NTY8hMBq0UIogMQNWBga99iPARGRfRD0wkbTaLCB18BsZZ6TqUR0epr6zjR4KxsWmavQHr7RVmnBU2Vl9jrbydi2fOsPCmA+zed4B6vcWliytcurTCaHaS3Xv3snnLPGsrG7y2eIGF+TnKpYhmo2GuE3qa+tJlMhmYnp6hUMzhZMZxXRelNJlMDtcRdHptzp0/jyuzBKFPu9Pm4sXLqCuNI9gsFT38WMSuyAQSgdAS6Si0Nr2jYRihFGitcFzT6QcGRKKJOwTNKwsR17VoHfczCqL4OwW0QMQxssJiO2GB2/8QWYrYWSkk+ZJDdayEQ5HV5T6hn2VhfgvHK8fQkeLipUvs2H4dr548SWWkzPz8Zk6fOW06VBX0u32CwCeTcfF9iXRcep0eS4srzM3Oxd+TAFojcBDCuCYRJs5YaY0OAyIdIaQbOy+vuAJF3E2plbCWYvMaODGMv9JaSQzXrRMZpYyj0VcoxzXnE9o4FKWMx1IipfkOIJvJ4GYypstRK1qdLo16nXa7Sd7LAgKlQoQwdSlRqPHDECcI421EXAEaU+TYDaoiZaJvgYzr4ToeYyPjzE3NMTM5Q66YNSAzCgmjCMdxGR3ZxNzcdkYnpsjmcmiF6bKMQhzhkc1l4mhVjYo/G7QWaBXiB30uXxqh07wUxwSb2Fkzeg5KhRCvH7PKdOJilcJAR8cx6zrS5mYFHRl4GVkLZgRaBxCRRPKiRQxAZRyF65ibK7Q0pZWpUqVKlSpVqlSvo58aVFrYaB162Ww2gQhnzpwhiiKmpqYYHR2l3+9z+fJlTpw4gRAiAXue51Gv13nppZdwXZd+v8/CwgJKKXbt2kWr1eLll1+mVquxadMmzp8/z7Fjx6hUKiwtLVEsFhPXIpCAwnK5TD6fp9FoMDMzk/RU2hhN3/eTO+N6vV4Sm2kjHFutFkKIpIfQOiKHOxytQ9Ju0+12E1eX7UUc/vfhSNjhCE+tNf1+n4mJicSRarshXddNIkAtYLr55psZGxtjZGSEfD7P2bNnOXHiBK+88gp79uyh1+slTtIgCNi3bx+zs7NXxfRaSGPfRwhBq9UiDEOq1SpSShqNBr7vJxGax48f56mnnqJarSZgyfaT2o7NarWaRPc6jsMzzzxDsVjkwx/+MAsLC2xsbNBsNmm323z9619nMBiwsbFBtVql1zMdERMTE1SrVXK5HHv27OGFF17gr/7qr5iYmGDPnj1MTU0RhiHlcjmBU/l8nldeeYVnn302gV1BEFwFrG+55RZuu+02+v0+3/72t2m1WvzkJz/h2LFjXLx4kUuXLtFoNFhYWGAwGCRAKpfLkcvl2LJlCwcOHCCXy/Hss8/ywgsvJMff7/fpdDrMzMzw0Y9+lM997nN8/vOf58477+SOO+6g3+/z4x//mNHRUY4dO5YA3uPHj3PjjTeitU7iZrXWvPTSS5RKJbZv387mzZsJgiBZs9YFvLCwQK1WY8uWLWzZsoV+v5/M9913383s7CydTod//Md/JAgCBoMBg8GAxx9/PAHO1t07OjqK7/ts3rw5gep23dtzavt2c5fnuXPnqNfrvPWtb6XVanHq1Ckcx2Hz5s0cOXKEy5cv89hjjyGEYGNjI4nStZDcuqBtB6yNq9Vas7q6yqFDh5L3sy5oe65VKhW63S6DwSBxT9oYWTs+du57vR6e5/Hiiy9y00038eCDDyaO1yiK8H2fTqdDu93m+eefx3VdFhYWcBwnibbNZDIsLS1RKpWS8/p/fPGfKlWqVKlSpUqV6v9qDZQiwCXSDlJn0J2A5quvIDxJ5DhU0eTEJpDGJSalgYtSiNglFvdLEhoAFoev2lJBiTA8QJpQRuEIZCSRSBzp4joZZBz1aOI+4zhRFSEch9LEBJ4jCbpN1rvPx32VVzoQQaNdEBmXjI4YHS+z8y072X79FnJZjyjw0TKKXVkRQauNxMFxc3ijo0SdHmG9jlPIIjNZlN9HRCBdh0hohI5w3AwTUxO8dvYcs7OzzM0u0IoUg8vrjDWOs7wyxalXzjOxZSvVsXH23XgjZ86cZelbT7FpeoJt2xbYqNfxgz6LF06xXl/n4E23UJUOrfqGiaXs+axduIyQkrGxUXL5MhPjZVZXWgSDNvWNOt/+9uNcWFxiy/wMF5fOU99YpdnsmYhWccUpmVRGYn7uDDVBJDcpiwhHG6imdESkIlREEouplE7aPpO2SK3QgIp0DLquRPHa/ybdh1wd+zoMTv/bVyxa4GZcpqdHyRcdJidnyXklmo0T9AcR4+NF5jfPcOH8JVZXVjgwdwDX8+j2+ly/Zy8rKytEUYiTMU6+cDAg45WgFRlXHpJLl5cMnIyjgq8MlYGrKE1kcbiWSBHbFZWKYbyJDr1ydEkppdl+6DUtCNXCQHoBONLYUYMwJApDhPATqJlxMghpzrEw0ia6VDkEsStZOhkGfZ/19RWWls4ThT5OIY8f+rha43kuSkUEYWg6KON+R6UjAy/9AVoZp6cQ0B8EtNsNPM9jpFLFlYKsl6VUKjIyZuqItFZEYUSkFJGKqFSqVGplarUKhUIJjfn+aOAPcB0v+R5LRRFKY7aNNEEAKpTksllUrkTW9ePPjdiKqxVCm5UT6SAGiGaODDy2TmrzeSQ08RzqJNZVxy5MreObG4SMnZYxkHcyhIGPjAFqAm9TpUqVKlWqVKleRz81qMzn8/T7/aQXTkrJzMwMlUolgVX5fJ4wDPE8j507d9Lr9cjlcszOzjI+Pp5AskajQbvdZmZmhkwmw/T0NJOTk8zMzNDv93nllVdYWFhgcnKS1dVVlpeXE3dkq9VKgEuv10tiVavVKi+++CKnT59mMBhQq9WoVqssLi5y4sQJOp0OSikWFxeZm5sjCAL6/T5aa0qlEs1mk2azyejoaBITeezYMaSUrKys0Gw2E/h44cIFXnzxRW655Rbm5+dRcceBdeWJOCLHQh+lVLKtBZ+DwSABv7a7MAgC8vk8IyMj3H333QghWF1dpd/v47ouN910E+94xzt48skn+dd//VcWFhYolUrMzMxw1113JY5Au68Wktp9seA0iiKy2exVIKlYLCKESBxwx48fZzAY8IEPfIBarca//Mu/cPr06QR8AglktSD0TW96E51Oh+9///tJn6FSit27d/Oe97yHer1Ov99neno66c7MZDIJeNq1axef/OQnWVxc5OjRozz++OMUi0Vuv/12wEBXO4d/+7d/y86dO/nEJz7B6uoqjz32WDKfUkrCMExiRy0427lzJ5VKhR07dnDw4MEkIthG9FpnrR07+7NKpXKVc9fzzAVCEARs376diYkJjhw5wtatW6lUKvEFXHRVn+odd9zBnj17kvOn1+txxx138Mu//Mt897vf5ctf/jKlUokPfehD3HLLLYl7VCmVgL1er5ccm4XF9XqdUqmUnAuu6yKl5PTp03zuc5/j7W9/OwcOHGB0dJRXXnkl6aLsdDr0+/0EhoZhmNyAYI9x165dPP3004yMjPCud72LJ554gm9961sUCgXm5+c5cuQIY2NjPPzww2itKRQKZLNZSqVSAhTtTQVSSpaWlpL5DoKApaUlWq0Wv/iLv8iuXbv41re+xcrKCt1ulyiKaDQa/+E1hl3Kdm6Hwa4QgieeeIJ+v8+zzz7LuXPnkvH+0pe+xI9+9CMGgwE33XQTs7OzVKtVXnrpJb7+9a9TLBaZnZ1lfn6eXbt2JedRqlSpUqVKlSpVqlT/XUWAryUqDlKVWhE1OtRPnkR7BXAyaMfFKZTRkTKddo6LcEwcY6QUyDAxZglt80VF3Ndn3GZSODiOF/f9CZIMV6nMhlEMwoRGqZAgGoCAfLGI57qowS6CZp3GC68SdQ3msf2KKtBkipKZ62e4/s27qY3WkCiiGNDIIDTv0e7h5ktIqdGhj+4JZD5Pxh0l3FhHuz5SeuBKnFyeyPeJ/ABHReTKJUq5LI31DSbmptkRztNs+eTX20QXXsDfdJD1M2cJ+n1eO3uCsfEamzdPsXl+nla9zaDfZ/HsGQZasb5xked+8jxvufFmiDS6UWegFWE3YOX8RaKgz9TsZnLZHJVaHn/QZ/nyRV555RWWly6xvHSeTqdNu71O4Pu4EhSCMLriqLQuSosPHUnsntQ4UuCJDJrI9IMiYneacVpqTQI7DQAVqCu4Mu5ovAIzh2W7JRPaRvw6dqf+B0GwjiO47957uOHAPn783HNks3n8/gDPc/HDAD8QzG9ZYOXyOoN+H600pVKRZqvFti07mJud5+LFi2QLHlpHBMGA0eo4jbUGSpvr18ULFwjDADeTI7b1gVRoIRGx807G/1M6QllHJQKJuTGZOJ5Uo0Fi1n18QkjpJANgHIw6ngcXrXyk0PGN4qCFRqsQS4EHkZ90SIZRZG7GdwwA9bQmihSNRp3l5SUa9TUDNoUkikJQEIYegR8QBgF+EOBlc7H7Mz4WlLmBQJrzttfrcmlpCSdjOkFz2RxRFDIY9An8Po6ooYRGS4HSGlc6BGEP3x/E331opASlFYEf4muf0DdpQUHgE0SKbq9FMPDp9Vq0O11Cv0veVRQyBSQZlDbNs9bhKoVrIptxDTAWxnkphekAdaRd5RIhTMyu1sq4uiMVw0qzek0ycRz5KhxU7Py2nbamd1T+t9dnqlSpUqVKler/Lv2vQKWFJxbguK5LoVBACJHEptooRhulWi6XE5CltWZhYQHf95MuuF6vx4EDB5J41J07dyb9j3Nzcxw4cAAhBC+88MJV/ZRBEFwFjK6//noajQZLS0vMzMywc+dO5ufnr+qRLJVK7N27l+npaXzfZ3JyMnEyCiGYnJykVqslHYqHDx/m2WefZTAYMDo6SqlUot/vU6/X2djYuMqJZ4GJBTE2rmR0dJRisZhASuu6dByHTCZDt9tNgF+xWOS6667jiSee4Pz580xOTvLqq69y3XXX0Wq1aLfb7Ny5kzNnzjAyMsLc3BytVounn36ajY0NtmzZwtGjR9m6dSu33XZbAqDsfHU6HXq9XhJna92fdj6iKKLT6eB5Ho7j0G63E/B7+PBhJicnk/mP4l/s7fw3Gg127drFrbfeyp//+Z9z6NAhHnnkEcbGxjhz5gyLi4ts2bKFxcVFTp48yebNm8nn8wwGg8Rx+sILL1AoFLjrrruYm5vjj//4j5OeQQDXdXFdl1arRRRF7Nq1iy1btiTjFwRB/Et7kHROaq2Zn5/niSeeYGFhgb179zIYDFhZWaFSqbC2tkY2m00ArtaabDabrN96vc7Zs2eZmJhIIKMFX2NjY3zzm9/kJz/5CTfffDP/9E//xK5du5ieniaXy7Fr1y4+/vGPmw6QOBp4dXX1qsjgN7/5zdx3332cPHmSz3/+8/zgBz9g//79VzkP7Txap3A2m03cwRaydjqdxKUZBAEnTpwA4H3vex/T09OcP3+e9fV1XNdNnLX2bkz72ALEMAzJZrPceOON/P7v/z533nknu3fv5syZM/yf//N/eO9738v4+DhjY2NJVOuePXtYX19nbW2NkZERXNel0+lQrVZxHIedO3fy5S9/mZmZGaampvje977Hvn37WF9f58/+7M+YnZ3l+9//fvL8IAhoNBpJL6nt9CwUCvT7/STSWSnFwsJC0mH7wAMP8IUvfIFjx45x8OBBbrrpJqIo4md/9me588472djYoFKpJJ8rnufx8Y9/nMXFRQDGxsbI5/MJjLegP1WqVKlSpUqVKlWq/44CLYhiN5LExZUaESoGly6z5h5FeDlEJkNpUiBciVAaB2lcSCbPExVpHNfFkZIo0iht4I7p71M4uKaDT6gY5ojYdBb39mH7DBUq0AaGKI10HGQmQ8bLUp6eIertg06P5vHzqNBBYPr4xmer7Lt1J/PbZnCkRIYKQYjGwc1IVLePUC5uqYpwBQKFHoSoXg9CH5nP4ZQrhK06suQg3Cyq10aHAQhlOv08j9GJCZbOniEKxpiYnOIm6dDrHefShfOcPTtFJRew8ezTHHz3Qyzs3k9npUmgFI7WnHrlFUIdARo367K29hovHS9x841vAedVGvUN/EFE2PRZC9ZAOMzOLlAs5vEHA/q9Ntu3bqfTqhOGEY16g0aji3QFhYJDEEK7HYKOa0JjXgxX3JZuPO4ITUSEFBopHMIwjj0VkqzjEKqQSBmgqbROoKVWFjMm9s3/INOFaa7bVVxQaaJfLa18422veh0Bu3fv5OH3PhqBltgAACAASURBVMz6+iqjtTE63Q6LFy9TqYzT7w3odgRTk1MUijlUKOn3B9SqVdbWl8hnPbZu3UJ9fZ1cPksY+AghKFWKBsnHMbX1yxu0T75IdcdepFcA6aGFRhDFTj0HLeKQYSlxiCNvxfDeyuQaWiuBlNZbSuwE1CCdGNALHKkMmDc24ytgWCiEcAETeQpOfG3tgza3EigVEUQhKsoShrCyusTy8gUGgx6VUoVIRQil0ULR7SrCMCCbLVIdGSPKl9CK+MZ0L4alCiEcpCuJdEijtY7WMDk6hZfxCMOIbq9Hp9MhqAVIV8QxwBohNL7fpdtu0C+NxOeyZqO+xuraBv1+D4kmDAO6vT6dbp1ep02n26XdbtDptaiWimzfspVauRiPd3w9K000qxlXh4jQxAprY0Ighu4m5lXHkFGjVYTSKo6Btv2p0rycIHZnQqQjNAohpFnbIoxvrohIlSpVqlSpUqV6Pf3UoLLZbOL7fgLyLBRyHCeJaIyiKAEeFlhaVxtAo9EAoFAoIKWk1WolIMLzvGR7G+N67NixBDSurKxw55130u/3yeVylEqlBAhagFkoFJienqZQKABw/vx5RkZGuOOOO4iiiEqlkkRmSim57bbbEudcqVTizjvvTIDV1q1b2bZtG/V6HeCqKMj9+/ezf/9+CoVCEjnqOE7SjWkBULlc5oYbbmBhYYFsNkuz2aRSqXDzzTczMjKSxKy+853vpFarobXmtttuY3p6mh/96Ec0Gg1uvfVWdu7cycbGBs888wxHjx5lZmaGd77znczNzbF582ZKpRLPPfccq6ur1Go1du7cmTg3LeRzHIfR0dGrIEytVsNxnKTDz3Vd5ubm6Pf73H777fR6Pf76r/+azZs3U61W2bRpE67r4nle0m1Yr9dptVpMT08jhGBqaop77rmHJ598kmPHjvHpT3+az33uczz22GMJgNqzZw/T09O4rkupVEqcgGfPnuXw4cNUq9Vk/7Zv355EB1sH4PT0NFu2bOHQoUP88Ic/ZGVlhbW1NUql0lVxvdaF+853vpMf//jHfO5zn+PWW29lbW2Nc+fO8alPfYrdu3fT7/cTaJXJZGi1Wnz3u98liiJWV1c5cuQIv/RLv5REHVuH68rKCl/84he54447ePjhh/mTP/kTHnvsMX7913+dBx98kL//+78nm82yfft2fvCDH1Cr1Xj3u9+NEIJms8nhw4c5dOgQ99xzT+JYnpycvCrydTAwfTNbt27F8zwOHTrE/v37mZ+fT9Zcq9Vi06ZNZLNZut0uSil27NjB0tISX/ziF6lUKjzxxBNJH+vMzAx/+7d/y5//+Z+zf//+JI623+8n69w6XGu1Gjt27KBYLLJ3716y2Sw33HADvu/ztre9jVOnTvGZz3yG+fl5lpeXeetb38rHP/5xHMdJbm7odDocPHiQpaUl/v7v/x6tdXJePPTQQ0kf60c/+lF832dqaoqHHnqIkZERVldXKZfLfOxjHyOfz9Pr9RLXaLfbpVQqcffdd6O1JpfLcd111/E7v/M7iXvY9qf2ej02bdqU3NhgP6PszQPz8/PJa9obJf4zpfAyVapUqVKlSpUq1etKm7BVKUynHspEuUaBondmEeUcRWZz4Lh4I6NIx/TDudIxcaE6QkQGSAnHNW4ypVEmx9H00SERTsY40eIbF0XsWBMiE/f9+YRRQBj20RiAgpAIKZGZDNlajcrMZsJWg8HGBoOlJrm8y75bt3LdjTspFQsQhOY4VB+ERKOIWj6ZYgknX4S+jxoE4IJ0HJTW5jEOMpdDujmCZgcnF6A6AU4mh4PC7/dwdI5cuUq5VKSzsUFtIstIrcZNe7ew2jnJ0yee55iTR+o1Lr78CtfdfJDLZ8+x0m4xObuFTZMTbGzU0UKQy+bIZLKsbZzn5ZMF3nzDm8m6p1hdWaI/0MZZeXYJHWqm5mbJ5vJEQUQxn+etb72HhW07WFm+yJ/86R/T7axTGykT+gFELXr9MO5ZNOMvxBA8FODIOJpUK6R0DaRB40iJI6RxAGqFIyWBipCY/j5HCEIM0NRmit/AGymSPyyvE7G7U+srDsz/6upkcmqSRx95P81mg7PnzsffD0yyeHGNTeObWV25zEhllM1bJpnbPM+FM5fod/sUc3nOnj1Pu91mx7btnDl1hkANcLM5pBB4GQ9UhI4ilAoIu32a//4k2dYK+etvR5RrIIRpPDX0MI68He5zJIkQFcSPdYRCIt1MfO1lLMNKDEXxChOfbKJx4/5LZOIkljjgaJSSJsrUvHDsjDU3IKMNxA8GAa1Wj+XLS2xsrCClgxIKHQQAKO3TbPvxBEjGN01SDMoIoc0ciysxzkl/qFZoBVEU4vsBYRARBhHtToN6tUqpuE4ma+ClkFDK5/C8HFHYp9veQKsB7W6HxYsXOP7KS7TqTUI1IAgHhFGIP/Dp9U1SkgojQuWzdW4rem7zFa5rI15V3BuJiMGjTQJTcdRuHL2riWNllfm+KjLjY7/fM5fB0jxbGb+vjq3CEvP9hIo/B833Tul1c6pUqVKlSpXq9fW/6qjMZrMJ5LJOQhvHaMHAcIykdYNZx6Ldxv6bjW+1caNCCDqdThIhOT8/z+rqKoVCgf379zM1NZU4yKx6vR7lcjnpYLRddp7nUS6XGQwGSXSkjZIcfn8bl2rjLjOZTOLm8jwvcRA6jpMASMdxcByHfr+fjMGw88325gHs27ePXq9Ho9FIYl537tyZuE89z2P//v3JthaaLCwsXOVELRQKzM7OJk5BC/2UUtx+++285S1vQWuduCFtL6I9dq01d955Z/KeURRx2223Jc69ZrPJ29/+9iRqs1gs8uijj/LAAw8kYNlG/n7sYx9L5sxxHGq1Gh/5yEeS7sUbbriBbdu2Jfvz6U9/mtdee41ms5nEALdaLX7+53+e0dFR2u02mUyGd7/73ezZs4fTp0+Tz+e5/vrrkzm3ENjGxX7kIx/h8OHDtNtt7r77bnq9HgsLC4RhyHvf+17m5uZM0X3s7v2N3/gNnnrqKU6ePEk+n+c973kPk5OTSeyunTcpJcVikX6/T7PZJAgCPvWpT3HLLbfQarWYn59P5uCll17illtu4d3vfjfz8/M8+uijfPe73+XixYvcd999ABw5coQjR45QKBQ4ePAg2WyW66+/nrm5OWq1GrOzs/zzP/8znudx3XXXcd9995HNZhOg7nkevu8zMTHBpz/9ab7//e+ztrbGu971Lnbv3k2z2UzGZnx8PIkAvummm/jN3/xNDh8+TBiGPPDAA5RKJXzf5/777wfghRdeYGxsjBtuuCE5Py2M11pTrVb53d/9XQqFAoPBgO3bt/Onf/qn1Gq1ZB392q/9Gg888ACvvfYaMzMzzM3Nkcvlrlp/NlL4Qx/6EA8//HDi2HRdl61btyYxx2Cc2+12m3379iU9qwDT09PJ34UQDAaDpPM1n8/T6XSSzxAbl2vjYO2+WtfwtZ9Fw5Gyrusm/2bPG/u8VKlSpUqVKlWqVKn+KzloMkIgMB2OAlBRCEoQBSHrr55DFgqIbIaqBFkuG9iIiWiMohAhTLylcoSpl5MGeApMzKQUAkcYh5OI4YKM2yjNr9DKOKkURFEQWwIV2pUglHlO1iU3OkJ5fjN+fY16/yhzWzax5007DKT0ByYO1vfBAWQGEWpD1FwHXAkZFyE1BGEMmRwIB0SqCxqcfJ6g1UbrEK9YRkURQbOBDgRaBQjPI1uqUL94ibDRRhExMTPHnfs3s/zD05w5d4zanrfw0gvHKRSKXLp0iS4h7RMvMjKyifHRSURG0g984/yUgrW11zh9rsQtNx0k8/LzLC0t0u318Xs+l08v4vs+c1u24HlZKpUiQuRwHZedO/dw3zvewXe/+01K5SpKRaA1S5eaREEUuylF0hPpSDP+rhQIKQ2ME6ar0REgpInSjZTpCgxjJ6DS5mZl24MZqThe840wpTDONWkfmN2IOwUNaBPSuPLeSJVKmfe/7704Lrx0/EWWV1bZd91ezl24RK06RsYt0WldJAgr5LIe09PTXDi/SBRGFIoVwnBAvVVn167djI+Psrq2Yhy/jom41UqBjp10WtPvNNGnnmPQXCNz3VuQszuQXgYd2Qhc46o1Tl8QwjE9k1rGUaUx/LJ+UynNQUuzjpGuOR+0BiK00nGX55VrPCd+H601qAgQKB2hlXWkGrgptIqhXECjvsbq6iX8Xo9sPocKI+M+VCFBMGBjfYMgivC8HL1uh6AS4GbMvmlloKTZSQOgzXWpT7/fp9HeQDqC9fU11urLhEFIr2vqW6QUTE1OMlquUCnkyWYcwrBFp9VmeXWVc+dOcuLEi/TaPZQIyGQknpfFlR4OkHFcIkCEmWSJIGL0aIpBDUAVGq0U0hHoSGNDXM01r0bgGEelAoFr+ixtjKsyzu4ry04nRl4RH3+Iicg1AF2gVIAgjX5NlSpVqlSpUr2+fmpQaSGk7/s4jkM2m00iRZNi7RhO2HhKC+N6vV7yHLuNhW0WHlgoYaFfqVQil8sxNTWF53mJ885Gk1pIAVwFHW1/37Dzzepa2GDjZu32QOIUta42u0/WqWdfzwIP64q08DIIgiRWs9vtJvsjpUx6Ke1rWvea3S87PjaC9PUe23Gyj+221/45fIzXxlfafbbzKaVM4JJ109m+QjsPdlyGIzGHY2zt9kKIJBI4DMPEnWYhou0RzGazLCwsJGBZKUWpVGLfvn1s376dfD6f7IsFThai+b5PtVrlwQcfTECVnXvP87j33nspFApX9TuWSiXuv/9+3vOe9yRzZWHzMFC34Hr37t386q/+ajI21lG8b9++BKLdcsst3HjjjUlP63XXXceOHTsS9+6DDz7IvffeC5iLlFqtBsBHP/rRZI1+6lOfQilFr9ejUCiQy+Wu6tq08+a6LnfffTf33nsvURRRLBbxfZ/du3dTrVbp9/vMzc0xNjZGtVplY2ODhx56iLvuuivpcbVxzWEY8r73vY+HHnooWS/234BkzVar1WRsLazfvHlzsp7tetm+fTs7duxIjtOuLbt2h0G+XS92HVonr3Uzvt56vVZBECSfO3bNWVfwG50DwFV9kzbC1+6zPQ+GP+c8z3vDfUiVKlWqVKlSpUqV6vXkCQc0hHFLZRBh3IgiIlAOg07E2okTZItFczPs1BQq46KIAGmAgAiRMguY6EYRg5sYfSGlAZYaEyWqMHGOWkoigXH2SU0UhQR+iJIKx83gCXttLJEig1uA/MQEtW07ycoB+3ZvopiVqFYL1e8jMi5O1sNxzbW3CgYIkcFf3cCrRjjlMjJQKN9+JxAZYBNEKHo4pRKZSpn+6jrC7aH7IU42j8xqgm4TZyDIlcrIzDK4gkK2RLCxyubxUX7moOTQ0XO8+NpJsrv2snj2Nd52zz1896l/ph8MWF5ZpNlcZ3J2nkpljH7gI6SJ2zxz5gS9bpt3veP/oVx8hVdPHyNqdxgMBlw6dYFeq8Pcjq1kPA9JyMbqZQRT3P/A+1nfWOP5n/yYcrlCuVrF90PWVtrGWQY44ooRMON6po8QQYTCk1kCIhNFKkxUb5gARI0DRFqZedYWEr3xWkoua/SVGtIEEsWu3UjHUae8vndNSsH1e3ahlM+xF4+xtLzM5KYZjr18nDNnL7Bjx5tYX24itEDpEK2hWC6TLxRAKsrVEpEKaLealEsVZudn6fZaRDoik8nS7wyIIowbGBDSZRD4iDBAXT5Pf2MRZnZR2P82qNRQMcBFSAPGiOLxdIiUiRxFS7RwgRjoSomIXYsIx8AvqQyAFMLEICfDrFE6PmOiKHb3QUzQgIhIa0QMSzUSlKbZaLC8ushGY9W4MaUkDAM0IVop+r0Bfd98J9Kor9Ns1amNTCBkHqVVDPh8+v0eYRAQRhHBIKTVblPfqBOEIaV8gfX6OvVGh0sXlzl9+hSR1ozUStx12x0sTM9Qzhdxch5aQ6QUQmmE1pSLZYrZAm7GJeO5eBmXUEX4fsCg3ycMI/ygj+Ma2IiKIWXSbWr6bx1AK4dIX4lkVdoAWaUihHZARIQqRClQOoznVsc+VBk7ReNe1XgNG/Ap4jmzXbpOaqhMlSpVqlSpUr2hfmpQOdxNaZ1yFppZV9Iw5BoGLRYCAcn21sEEBiAMu6dsNKPtCrSvb51+FtxZR58FFrbv0MISC7fs61u4MgxTrBvNQoxr4aR1V1mYAiTb2uMbBnTAVXDGAk37usPvbXsq7TEMy46b/bvdD/tew32Jw9DlP3sN+3e7f3Z/revNuguH4ZEFgL1eL3GUDo+DhXt23O1rW1Bt+zDtNr1eL4nH7fV6yfPsc+16iqIoAbt2Du2YDzsroyii1Wol6zEIgsT5awHdsOPXOm/tmrDHZ0G1UorZ2VnGxsYSeGeBs4WsFqbZvw8Gg2S9Wkeq7Y+0TlTP82i32xSLxQQa2rkQQiSws9Pp/AfQb2FuJpMhk8kwGAzodrvJ8XW73WRerAPT/rxYLNLpdIiiKIlEtsdp3cPWdQpXooKtW9euPQt9Pc+7yuFq43jttnZ/ravX3pQwDOiH1+rwDQd2G/vnG8FKCybtZ4mdBzv3w+v/9f68FoTa+bFra/jnacRrqlSpUqVKlSpVqv+JHDCxnloCIRHgORJCFYNGSVTv0Tr9Kl6+RE4KZK2EznmIjGdcZSokQONkCjEccEyMLHHfpDDuJykkkYhwhEBJEzUrcRBSogBHRUThAJFxY8dlTLSkcZIJV5ItlSnPjDExvptNXoTyfaKBH3ftKZxC1rjKej6ZfJ6oNyDq+wx0g6yUOLksIpeBMEL7AUIKVKCIBgPTH1gq4uSzhL0+uVIFFQT0V+sIV6P0gEyxSGVinH6jS75UIWy3CTsttmwa5e7r+px89jSXXqtQLW7n4MHtOFmPr3/jawYGRwPOn32V2VmfUm2UjXYdL1Mg0iEXLp/ln576Fu+8637yeY8XXn6O9bpPFASsLF7G9wPmt28hV8gSBhsIJ8vmygIf+MDPcfnyIkuXL5Iv5KmOVlEqpLExILSw0pFkpEBI07OoVWhAGyGu6xAEEUqFePkMWTcPWuH3fQI/IlLawEohDDszzZOvK3vVJGNCKeLoXylsJ6RxB0b/yTWL60ga9RVOnjhOq9kBBy4sXmJ5ZYW91x/AcfL0gzVyxTzZrEcQhnhZl0Ixi3Ac8l4RR7iEQYiX9ZicnGLp4iKdfpd8oUCn00JpHyEi0IpQhDT9ASqSCCUQwYDo1FFaG5dwtuwnu+V6ZLGGlsavZ6+5TBypcQYrIZGOADLGmSpMV6M2xawoEYNJ4Zh1HPv2hp2pWsU3sRqUZq4bY0AstTkTlY5AaPywz3p9ldX1JQb9HvlcHo0mVOa7g9D3kY7H5KbNDPoDVOSzcnmZUrFKuTKC7/dot9t02h16vQ5RpMxY6IBef0Cz6dPurOBIQRgqIqXpdttsbLTRQK/bp9ftARrpOrEnU+IIs9by+QLjY6OgBU7GOHgFoBQM/D6ZjEcYBgz8LF4ui5KCUEVmiWllomlViCOdGEhHsf/aRZlFmFyvX+mmtHzXRN0KodBCojDbJtGykQGTxhGrEVoi43UqhIMSV773S5UqVapUqVKlGtZPDSotMHq9eFcLfsBEN1qAYb/8t3AtCILErTUMiiy4cF036bgcdmBZCGnhXr1eTxyW1kk17N6yvZa+7xOG4VWgzDq6LHSyQMaCKAuuLPSwQGo4vnYYUg4DSfvedmwsTLExnqVSKQEq1tVofyG0+zYMh+x7D7soXw9M2ucMOyythp2Z9rnD/7fxskDi6rOO1SAI8H2ffD6fOFTtvtj5tsdqx8c+HnaoDoPsYXhtwdvwfA+7PW0fpoVbr9cDOgym7Ht4nkez2Uy2s+DS7rONx7W9qrYn1QLaD37wg8kYRFFEEATk83k8z6Pf71/lCLTHEARBEjNs5zSTyST7Z9eKjfe142VdhcMg1J4zds0Pg3oLLC28HD6/LOSza9G+vh23awH/MDy0zlO733aehiOV7Tb2c8A6iK3L2rqOh28AGF67167V4Tm359vw671R3KrtsrVrzR5fqVRKblaw7zWsN3Ja2uMbjoe1Nym83jmVKlWqVKlSpUqVKtUbyXa2Ka3RAoznKDIxk0LjxF2D/tIK9cwx8jIiq2bITUzgZDyU0gasKIXUkoQJSIGK4y5l3PcnhYsQLooekQ7Mu0uFkCQwSyvQSpieS2WcVioMcR0HTwcUVIPJXINiViIijRIeIooI447MYKOD9LK4eQ9ZLAIOstVF9QP89Q2yI+PIfBZkhHRcwIEIoshHDXyk65ApFmhfvgxaIwONVyoiBPjtBiLyKW6aQgWXaDea5Is5olaT/uolrl+Y4RMKvnr6NGdOwdz0CDffcRsnTx7n5eMvUchU8DIeS5fO0z9zhq07r8ORgn7XRxTg1XMnuPg3F3j/w4/wjrc/yA+efoqLyxfxgw5rF5dobdSZ3TZPebSKHwTk8zlqIzV+5n0/xxe++P/SbNbJFgqUamWT7tTy6XZ8JOB6Lo6Q6Lg3MYoUfhAiZIh0FJVqnsrICMVCldAf4HguxWyJZr3J2bMXaLU6bxj3CtZNKZGGyMXA2qwwHcdvxgY246aMY2CvVRgplpYu02y3qJSrjI/Nsry8zPV79jM7vYOTJ89RyBcIPU25nKXf76EjTaVYIuO4SAdczyOMQkAzMTZOrVohiAJy+TyvnV8zMcPaxMAGgeJc6LErFJQchXQ8hNRE9WUGz/wT/ivPk911gOzW/chy1TgeBYYyAsTRxsTnkMk+Vmjpxt9hSKIYwmmbJRvH5yIERCB0gNYgtYgxsHG3aqIExMm4qxEN3U6XjfUVGq266YYVgqA/oNvr0u930UowPTNBpTzJRn2dS0tnOPris2zU1xmpbcIPejSbGwz8Pvlcnozn4cgMjjARq0prVKi5FtnZQ44iTRhGxkmqNSqOshXaXEtnszmK5SIqUkjHjI/W4AcBnvZMtLDvIoWD67hITD8qQscR0HG3rVZoYVzY5jUUOu4XBbN8lFJEyj62LkkLIQVCS/M8bQ0AdhWbjGLjDDfRx9j5S5UqVapUqVKleh391KByGFZYgNHr9fB9n0qlgu/7rK2tUSqVKJVK9Hq9BFxZCGEBoQWAFmZYUFGpVBJY2el06HQ6uK6bxE8OBgOWl5e5cOECu3btolqtJs4xgHq9ThAEbNu2jUwmQ6PRSMDnsAMOrrilht2MwzDGxkFaCDfsErPwwrrhLCzSWlMsFhMA4zgO6+vrlEqlpP/y2mjMYdfltfs4DHThathz7bEMw5lhl9nrOSqH398CJiEE5XI5ccsOOwltzK+FcJ1OJ3G9Drvt7J9WFkzbOR7uQAyCgEKhMFTKrq+C17bf0ELBYffm8JgBCZzSWpPL5RIAbUG1XT/D0NtCNAsp7f53Oh0mJiYQQtBqtcjlclc5KYfdgfbn9hhzuRxwxbFqoZeFlPl8PoFrNgrYvqY9F+zP7P4NxwL3ej2AxNVoI0rt+WQBuN3enjN2fu17DTtSh929dl4s+LTvZZ2LdqwtjLeuzNcD/cPg3q7La2Xn1gLYYWg/vN6vVS6Xo9vtUi6Xk3U1GAySNXktjB+OnH09l2Uul7vq3BiOj04hZapUqVKlSpUqVar/ibQQhEomsNKwSkOU4qY94470Bd3FywwygpJ0cHJ5HC+L0uZZxhUZxcARA1BMIyURIUIO/b6LiYiVwrgspTYQRwqBUhFaS9BuDBpMFKSIAmr104yqdTKDrvld2s0hEDi5HDrKGJIiFUhQQYATgSzmcYt5/I0NIqUIZQvPHQERgSOQ2QwiUqiBifFUvkLkMohMhs7aKtVNU7i5AoP1Oignjtl0KU6M0d1osLFRp1Ct4fa7BI0N3rQwzXKjyZePH+HZTMDMtnF2XH89L79ykla7heO4+FFIr93nzPGXmFrYTL5cI/AD2p02HbfNY//wRd7+1ru5/8Gf4fBTT3Di9Es02306jRYnjr7M2MwE0/OzrC7nEUIwObWNe+99iK985QuEvo/nFfBqHrURQeALVpfW0FoRCZV0gyqtyOQl2XyGkdoIleoI1fIoruvS7/fIZbM4rgMopmZHYHFAvRG8cTSmjiNNY1DtCkFomCXJJYqO3Zbx300L5tVSStPuBCjdZWpihrW1ZUZHR9i58zouXWyYSpFAEoYDPM8lCiLCcECumMOJHMIowHNcwPStFgslPC+H63goDX4/JIp7HoWKCMOARq7CuUGX3V5IxslAFAEhUmkynXXCF/+V9qmjVG66l8zcDqIEyrqEOgRU7JEU1niKbZXUMWQDjRASgYGVOrEA2nhSHUey6sR9qiIDKi2kE0LgD/rUG+usN9bpt3t42SxRFNDtd1hdW6HVblAq1HBEFikdlI44c/4sl5cWKZWeJ58vEQQ+nV6H6ckZrt+1j6mpGXK5kFyugOdl/uvPDGVjac2NBTg6vrnBQToSR0ockUHKKJ5wczODIyVaOoRCIh1wtA0ANvG3WmEgLvE4EJn0XJwEMioVonXst9ZR/Hmh0FqYmx8i+xkTd7EqnTizzbWyuRFDIMw8xXDYwThWTfduqlSpUqVKlSrVf9RPDSqH3ZP2y/v19XVWV1c5cOAAABcvXmR8fBwpJefOnUsAhBCCmZkZRkZGGAwGrK+vAwZUjIyMkMlkaLfbRFGE7/sMBgNGR80v9UEQJO42C1VsPKYFVjbu8vz584RhSLlcplgsJo7LYeem7UOEKxGzFrBY+DgcPzns/rKutOFoV3scNkbV9/3k+WfPnuXkyZMcPHiQUqmUjN0wWBx2jQ6/F5Dsh9Xwz691VF7rIns9QGk1HM9pLpz6NBoNwjBk06ZN9Hq9pI/TdV3a7Tbnzp2jXC4zOztLPp9Pokvtc+w4WMhpwZB1x1mYpJRKoPXwWFsYbCGbnVMLLO1xD8NkGytqgZiFS9Ylad22NkbWun2vdesN96raZZl7RgAAIABJREFUNQgkkNLGrVpoa52E9pgtDLSdhhYq2mhWu98W7tnH2Ww2AXx2rdt9tnNqnY4WCA7D0eG4V9vHOtzJarcdPlfssV4b4WrB/HCkq9am/9OufTu/1jVp9yGbzV4Vc3utS/ba9W7Xb6PR4OzZs+zYsYNqtUqz2Uxe+z9zMvZ6Pb7zne9w8OBBxsfHUUpx7tw5Dh8+zEc+8pHEfXqte9NC9GtdxkEQsL6+TjabZWZm5qpzO1WqVKlSpUqVKlWq/4l85RDo+Et7rBcu7iW0JEVLhAQ9CGife40o45IpFXByOch6IN0YLpqoSkdl0I7ZWmrT0Wd65Qy0kjgGT8QxmAIZwwVtHmnj0FQqMuBJKkb9ZSZ1gwyA9FAIok4bZ6SCky/gBhGRHyCUJuz2iZRGBau42TyZcoGo2yPs9QgHLWTXwS3+f+y9eXBc12Hu+Tt3631DYwcIEiS4iiJFipQsSpYo2bJs2Y6s7FbkjJNKpeaPVGpeMlOVydTU5L2pSabqpSqvamYy8ZtMYsex5UWKJ06szXYombYY2aIoieIOggQJYgd6777rOfPH7XsFypLjOE7y4tdfFQgQ3X37Lufewu3f+b4vCQGgC0TCRAs8Atcj8GwMXSdd6qO5uoofOIi2RDMFRjpPp7KKmdPQLYPsUB8rC8u8OX2NQwc3Y+Gh7A73bJ9goXaR5y+fZ23uNvoH+snmMsxcW8bQHSwBui5wPZuFa9fYtjNFoIFphrCk2Wnx/IvPs1pZ5YPv+zBDQ8N85+VvsVpp4LRt5i5dp7JSZWpP2ElYLA4xNbWLO++8m+PHj5HLh/GbfX1lRkdGWVpa4tybb+I6PkqT6JZGXzpLKp0hny+TTKZxbBspw6hPQzewbRfH7YQdhkHYCajpXheydc1nhBBO0wWmoSFUGO+pCxH2ksoAKcGXCk0QRgALDU12QV1XmnjLrQfg+RIZCK7PL9I/0Mdd77kP3xOYpkUqpdHp1CkVre4EZUkgPYRQBMrHbjl0Oi10U0c3LMxEAnSFmbBoNZ3QCQiR6Q7fbVGpe1SyBr4BhvJCsKh0wMEwDfA9rMoi7eN/hbX/KNbO29F0rdu1GrkmJWgKpTQ0TY9jcAVduIYW9i0qupBSdeNeta7DNIRpmtIIAj+EaVoIBVXsUNWwbYe1yjq1Rh2hCQzLwu50aDQbLK8sUKuvs2UiR6AkjVaD+YXrzF+/wfUbM3TaYaenH4QW1107HLZu3olpJlEiwDBNDEPnXcyusZSCQL2VLAV6F7SGLmlf+fiym1TVhbhhPKzoxtqCxA+dmyqMfQ1UQBD4CKEjFeiEcdDxZ0rda0I0bKSS3d5KgVLRJAmDoOtCpduNKrrFqJrS8AM/dIljEEgfZBT5KmI4KlUPVPbUU0899dRTT++sHxlUbvygP4JKG6Fj5LaLXFHLy8tkMhnS6TSNRoOVlRUsy6JSqbCyshJDpbW1NcbGxpidnY1BFkCpVMKyLGq1GqZpsnPnTsrlMkIIbNtmYWEBgEQiwdjYGKVSiZGREVzXJZ1Oo+s6zWaTlZWV2BWZy+Vi92fkRIsAUuTQilxlkbOtWCzGYGqjA3Jjt14EyjZ25pmmyeLiInNzcxw+fJhkMnmTmzKCk9G+jX7e6M7cCOg2AqfoOGyEmBtfuzEO9O3xltH2RsAtcqmeOHGCZDLJRz7yEa5evYplWWzbto0gCFhZWeHEiROUy2VyuVy8f98OwYDYbRftqyh2N4JcG6NEo3WM1uetXoS3OlAjl+XCwgLnz59n9+7dbN68+SZ3qmVZrK+vs7S0xNDQEENDQ3Gc6kZwGo3PjWA0cldGfZgRXM9kMjHY3ngORMc4Ol4R9I1co1Ec7DuBrgiMR5GyEahdWVnhypUr7Nq1K+5gjfoxoxjjjXHB0fGPej6jMREd28uXLyOEYO/evTc5azd2tUbbsXGMRccvAsEboWd0Dmx0GkbHfSNUjNbjnYB5NN4iULy8vMzTTz/NI488wr59++LzdGMMbaSN0NJxHF555RW2bdvG6OhoDMK/+93v8thjj6HrOp1Oh+vXr7O+vk5/fz87d+5kbW2Ny5cvA9BsNpmcnCSZTPK9732PmZkZAD70oQ+xc+fO+Hzq6V9eQogtwBXgM0qpT/6YlqmAF5VSR3/I5x8FjgH/Xin1ez+Odeipp5566qmnnv7rkN/tv4MQJmlCDx2VKvRUKjRCohfGIgZNaM4uYBZK6MkUyYFBREJHiPB+SRcaSoRQRREQ0hYIAi8ESmigdZ1nMuxGFN2/x5WUBNJHqhBTKDyMwKfsr9DXnAvBVxd6CNPEShaRukI6ATKQCAVGIgVK4bkeShP4bgsNAz2dJuh0kB0bz2gijNAVCgoM0CwdFejIQCJdDz2VwkrlqS+uURoewszl8ds2yBDUGaYOmkWpv4/07Bpr128wsWMLdr1BOpXiw7duofPqDJ3VFfLFMuVSH5evLSGVge375CyBEuC7DpfPX6B/bIxsrkAmV0DXNYJAcur1U8xdvc5DDz3MRz/0s/z9y8e5cOk8jY5PfbnK67XXGJtcY3LHJLlCntsP7MNzOlyfu4ZmhAC43WljmhblkX5cx8WyDDTNIJvNY+gWnqcY7B+hXu9QqdUQUqHpAY7bQeHjeS6BH4Txm1oXNIWmVTRdkEzpJBImqXSaRCKJJjQ810EgsB0Xp+PiuD6aEGG0qALXD1DexuSkt8ajpmkMDgywc8cuDhw4yNDgIJrIsbC4TDaTZ6F5A8euMzK0BVM3ECIgk8nTbjm4SlGrN3A9n0wqF0JzDKRUpJMZOk0X3wvvlzU0kAJdl+SLRVq1eXwriStBN41uxyaowEd5PhqKRODgX3wJVR5CG5okclIK9BDMCq0LFbvRo5LuckLy1zUHh4rvOyVKgdAMkH7o6lMKTegoGXTjlMPnuq5DrV5lvbqO3bGxzCSuZ9Ns16nXKjSaNQJPYpkpZKDw3Dara2s4rosMQrdqeKaHALTZatFu2ThOO4SEiO/7zOadpCQEvkQqv+tADBAYRDG/KIVSAUKFExIQdCcehBOhVRcKIlUY8xqornNSC0E2XSuuDGFu5PQO901Y+BmCy9AfqYKuSxW6dtauoxKBIEAJHV0XYUSs7H6WoKIJwUG3ezWUlME7bHFP/9b0z3GP3lNPPfXUU0//JFAZAaQIUiUSiTgWNAILQRCQSCTIZrMMDw8zNjbGzMwMlUqFbdu2xQASQkfmysoKk5OTsdtrcnKSVqvF9PQ0ExMTFItF5ubmuHbtWtxBZ9t2DCBXVlZoNpvs2bOH+fl5fN9n8+bNdDodXnvtNTqdDoZhxO9z9OjRGCDu3buXcrnMpUuXmJmZ4YEHHgDgwoULrKys4DgOk5OT7NixI3Z/7d69m3Q6Ta1WY2lpiU2bNiGE4OrVq6ysrACQTqc5cOAAyWQydrldvXqVRCJBf38/Sinq9TqVSoVyuRy71CLAE4FO0zSpVCqsra1h2zaFQoHBwcEY9HQ6HarVauxqGx8fj914EcyKXHwA2WwW13XpdDrU63UGBgYwTTMGtKVSiXa7zeuvv06hUGBiYiJ2r1Yqlfj50TpujHTd6KLTNC2OKQXirs6NkC5yXEbRohGgSqfTtNvtmzoUfd9nZWWFb37zm2zduhUIwVUUARodjyeffJKPfvSjbNq0iXa7HcPQjesVAa+N0apBEPDd734X27Z53/ved1N8bATmote83UXb6XRIJBKxMzXqzowcihuBagRjN7qSARYWFvjsZz/Lb/7mb7J169YY0MJbLlIhBOl0GgiB58bo3ejnCLI+88wzaJrGrl274uMUjYno+EVxsRs7GaPIUyA+R6P9t3F/Rb+LYnA3uoSjsRkB63q9Ti6Xi0FnMpmkVqtRrVap1+vx5IQoUjYaHxtB5dvdw9F7RNejyMWcz+djmHzy5ElOnjxJo9Gg1Wrx2GOPoZTiM5/5DJs3byaXy5FKpeLrw/vf/37++q//mueff56pqanYRbsxermnnnrqqaeeeuqpp57+IXUDHCH+aF+G7i4Z9rtFkZYKGUY6BoJ2JaB66TJGOgtWgmS/gRAJpArBitSDLnQIu9+kkgSBh/SDboelQENHF1ENAt3COYWmh52YUaVh2mvQ5y9iaAG6GfbaoesErSZSQdD2QNNQvo+VTCObLbSEQbovi0Lg1+sEHRtNGQjDQPkOQauNJzQ0I9mNJRUI3UDoLgQS6TlolkFusI/58yvkZIARgNdqd+9XBEG7hZ5UZAf7GB7KYALSdWi2XKorDTZvHeORvTYX3SpoUOor0l/MMzm5k7mrM+i1dQwhqCoBBCzfmKViJTEsi0w2RzqTo1js59LsJa792X/mvUfey333PcxgeZQTr3yb5fVVnKbN+TfOsLywyPbdOxndMs7ttx9i+/bdOJ6DbbdYXl7ACzzyuTyJ/iSWZVEuD7H3lgNIX1BvNKnXK8wvnCWVTOA6Dq4rkb5Gs2XTatfwXQfb9vF9RdDNaxUCdAWWqZNJZ8jmCmE6lNCRhM46JQW+H+B6NpqARCJN0krjug4LS4usrlbxPBkDNE0IBvv7ueP2O9l32+0MDvQRBIJ6PUDDQBJGffaXs+G9nibQDZN0Ko2dc2j6Dosr8yihKOYK0J0ga9sehVwfnZaDCmQIxP0A22mSTOgkzQSDSSsc35reZYg+CIF0XaTvh6nCloXltOH0ixB4aCM7QddCpygCtNAdSRRpKgTIAISOECqE910wG8a5hudIdP6hQNc0NLSuk1KBCGLXsWe7rFcr1JtNulWW3c9KqrRaTZSEdKpIX2mIpJVjrbrE+vo6MvDCWNnuaRYFrlarFa5eu0Qmk0BDsr62im3bP8Q1I+yFVLLrXJSg8BEi3H+aCN21QeCjG3q3axOUEnG8Lao7QVn6Yey07DotgwCQCBW6sKUi7v6U3bEX7cPQmRruf9BQUnVhsewGuxJOtNACkEYY6wuAhwo0hK7wZegEF4pufG1PPfXUU0899dTTO+ufFP260dG3sfMvghVRJ2EU9yqEwLIs8vl8DNSq1Spzc3NxVKbrunHM5MDAAMPDw+i6ztzcHGNjY4yOjuL7Po1GIwYjlmWxb98++vv7efnll7l27RpTU1Pouk6r1ULXdWZmZqjVahw8eJBiscjx48dZXl6O3ZONRiPehmazyfLyMp7nsbi4yKVLlxgaGqKvr48zZ86QSCQwTZPXXnuNXbt2xQDxe9/7HsPDw9i2zcsvv8ymTZvwPI9r164xMDAQwybLsjh79iy2bfPQQw+hlOLChQssLy9zzz33xDGgETjSdZ1kMonjOJw/f56TJ09SKpVwXZdCocAHPvABbNvmpZdeYnl5GSklmUyGRx99lFKpFLvlIhAYQSDHcTh58iRvvPEGnucxMjLC3XffTbFYjDsgL1++zKVLl8jlcrRaLZLJJPv370dKycWLF+MOw1wux5EjR+I41VOnTjE/P0+73Wb79u3s2LED13WZnp6mUChQrVZRSrFz504GBgbiqFLP8+LtNgwDpRTnzp1jbW2NfD7Pzp076e/vJ5VKkUgkaDabnD59Gs/z2L59O/l8nlqtRhAEPPjgg4yNjWHbNqZp0mq1WFpaQtd1xsfHY4CmaRorKytxL2o6nWZ2dpbl5WXe8573xO7XKB71nbQxPrbRaJDNZjFNMwaXmUwmdvZFwDpyUW6EhxGg73Q6sWsycn0CcexrvV7Htm2KxSK5XC6+4UmlUqyuriKEIJvNkk6nieKRI5i4srJCIpGgVCrR6XRYWVmhWq1SKpUwDIOBgQHa7XbsPlxcXKRarXLw4EFarRZvvvkmV69eZdu2bdx6663ous7LL7/MxMREPPHgpZdeYnBwkK1bt3LixAlu3LgRn+uHDx/m/e9/P6lUioWFBf7yL/+SmZmZ+FoRjb1WqxX/HMHXd9v3i4uLfOlLX+Kll14iCAKWlpbijtponR988EFGR0f5m7/5G44fP86dd97J1NQUDz74ILfccguLi4t86lOfIpPJxMB0fn6eVqtFsViMY3h7+onQbqD9r70SPfXUU0899dTTT76C7ifzWgQpAaTWBQQGIor3RA9xiRAQmLQWWuiZs2jpBEbCQjOMrlNSI6GZIQ0hjH1FSqTn42sOgi6IVGEopFLd+EtdR4PQfakkulSkAodR0SDhOViWiWZaYITxslJIhGkiJPi+g6YplB9OSg0aLSwJmq5hGDqkLALbQ9N1pBvC16DewrcSGJkUQhgI3Qg7Nx03XH6njZlIkiv2sz6/zOCYiWYaJAo5pOPiOg7SczGzGTbfdgt2o8bK6gpnL1W4WtVJJzVGR8dp2oq5ToOk0EBqlAcn2LZ9iusnv4e5dIOK77GmCVxh4Pkurmtjt1qs6UssLVynODhOrbXOV7/+FV574xQ//ZGf49GPfpxvf+fvOD99hqZts7K0xPraCoPTY+y4dRel8iDZXJFCNs/tt93BG2+e5ML0eUzL4shdD/DQgx+mVBpBCQikR2Vtlb9/+SW++/cvcXnmCoGvcFy/C8Ha+L6P5711nykATQPTMjH0NEJLoOsJLDOFaRoITeB4bQIfNEOhG+Ek1YSVImElyOYyKC3AcVrUGy6uo+Ll+k6Her1Bs97A7bTI5gaoVlvU6zUC6VPMJ+kvF0B0a1Y0QcKysMwEuhGwvLyAkIpcJvw8YmV9kUwuA9Kg0VgL+yl9RSAl7WaNbMrHbbdIGxqBkqDpGIYGmhGeG4GP9MPxpiHRDROaK4g3/w7VqCKnDkEi1e1kDYEamkKI0E0Yflddj2CApmsoGYQuQl1HSIVUIRQVmt49C/0QfmoCIXWk8vB8j1qjxtraKp12G8tKIn2fTrNBu90ikJJEIku5PMTw8BgEAbV6jXarRRB4G+BeFL8saLU6vPbaKWq1dXRNML84z9paHaVA10ToWnzXTlKJVAIZSJTe7dns/j50LSokAUJpoTmy2y+JlOH5FX8pCGS4vCDsjVVSIQMvdE/ylutUIVDSDyN3u9eW6GfQuoA8iqPtxlhLvxsDG3TjpxWaZqI0GY5PFe5rBeG2qHeuc+mpp5566qmnnnr6kUHlRufYRkedlBLbtmPXUeQo2+i+iqBZEATUajVKpRJbt27Ftm0qlcpN3X0RHANi0BM59KJY16g3TwhBuVxmbm7upqjPTqfDtWvXSKfTDAwMYBgGmUyGRqMRw9ZoO+r1OtlsOINwfX2d6elp+vv7OXz4cAx8pqenGR8fvwmiRMArmUwyOzvL6uoqH/rQh9i6dSs3btwgkUhw7dq1GHKOjo7y/PPPc/DgQcrlMtevX6dQKJBOp2M3W7RcIQStVgshBCMjI/z8z/88mUyGs2fPcurUKVqtFhcvXmR1dZWf+qmfIplMcvbs2Ti+FMIo3sjFFu3b2dlZzpw5w/79+ymXy3z729/m8uXLHDx4kHPnzlEqlW5ymyUSCfL5PIVCAaUU1WqVarVKp9PhlVdeoVgscujQIc6fP883vvENtmzZAsDXv/51bNumXC7z6U9/mrGxMQAKhQLFYpGBgYEYqEWwTtM0UqkU3/rWt3jmmWeA0Ek5MjLC448/juM4LC4u8sQTT9BsNlFKceTIER577DFOnz7N008/TTKZJJFIsGXLFs6fP89Xv/pVLl26hG3bfPCDH4z31bPPPsvzzz8PhC7JO+64g+PHj7O+vs7s7CylUolf/dVfZXJy8l17EoUQnDhxgqeffhrbtsnlcvzMz/wMu3fv5umnn6bZbMbA/M477+To0aM3xbBujGKNAP4Xv/jFOEr5Qx/6EB/72MdYWFjgySef5MUXX0TXdTZv3sydd97Jgw8+iBCC5557jhdeeIHl5WUmJyf5+Mc/HkNRIQRvvPEGzz33HHv37uWBBx7g+eef54tf/CKVSoVkMsng4CC/+7u/SyqV4jOf+QxLS0sxMPyd3/kdjh07xptvvollWXzjG9/gp3/6p/nABz7A888/z759+/jIRz5CEAR8/vOf5+6772Z4eJinn346BpTj4+N84QtfoFQqcejQIZ566inq9Tqf+MQnWF9f59lnn42vEdF5/Q8pApjRxIgoitcwDNLpNBcuXOD48eNcuHCBYrFIo9GgXC7TarUwDIOJiQmCIKDVasVQf3Z2lq1btzI1NUUul/uBoLSnf3tSSp3/116Hnnrqqaeeeurpvw4JFBoaUUOkUrL7wX3YVRm5ubSuQ0kAhlD4vkFrroZZukIiU8RIppGaiRIBga6jK73rzFQIJIGSeJ6LoVtIqcIOu64jShNhFGcgPYSmo1RAAsGEWyfVbqInup1/AkSgoaSLkUghTB1hgubq6Jk0+D6y1cGQBkIXYGqgGxjSBNXEaYZOP+F6KCVx16sI3cRIhX9HC9NCT2YIbBu6+yA3WGbttes0M0mKY2NI2yZot9GtBG51HU1qmLkcUKBx5QazyxpVVzA/v0a+1MeIYXL2m8+RNCwK+TQXzlxk3/6DbDp4mOZMgfSVC+QcjyvKx9fAMCwC30N6CkdKKotzDIyO4wWK+ZU5PvXZP+bIoXu55/6HKPX388aZUywtL+N1POauXmN9ZYXNUzuY3LkDXTNIpDIcvfeD3LL7APliiTvfcw+pVAbQ6dgufqCRSvdx193vZ9eu/Zw/f5qXvvMiF86dp9PqINDpL5UYGR1ldXWVSqVCq9XGShjks2mSqRymlUATFoE0wQOhKzSRxEyaRMHCgtBdq5RAEyaFXB+D/Q6dzg1cJ4xjlUrR7Ni0Wm1q1QqaMNGNPOuVdZrVKoFSbJookEiYOI4dAkcRuvR8z8fpOFTXa6SNFEnLwnUCrl6fxetAy27g+T5KKoLAx/c97NY6SctAegF6UiBlOC6CQGGIMIo1jGVVYcysrr3Vu+g7BFdfQWoaYuttCDMZwjMtqrMJQmdkdHsuVVjGGcWYCoGmwq5FXe9ODBABMoicmBqoIO5tdd0Oq5Vlao0KyldgKJqtOo1WA8dxMYRBKmmRzWbJZfO02i0ct/3W3u9CSk2DfCZLMpmi0aqzVqlTa54BFJ4XAsFCPkUxn6PebFKtdb7vnjeQChnQdY7q3atIGN3sy3CbhFDhuUqA0HQM3UDK0GmNEt1rThiV68uAQEYgNeruFCCCbldoNypahQCYbuenUj4gw6hXX3Z7QcPY6EDJ7r7TQWhI5aKEBGWgaYrAD/ezrlthvygBuhBvAdeeeuqpp5566qmnt+lHBpURiIygQOSUzOVynDp1CsuyqFarDAwMxK5ApRSu68ZupcgpFjnoGo0GruuiaRqWZWFZFoVCAc/zyGazMUCMuvB0Xcf3fVKpFKlUCiB2ZNq2fVPMaQQR0+n0Ta64CFLquo6u65TLZRYWFmLY6rou5XI5jpAcGhqKO//S6TSapsVxoFH0Z6FQIJPJ8NRTT1Eqldi9ezeHDh2K+w1N02Tz5s2kUinm5ubQNI1Go8Gdd94Z9wpGcBbecq/m83kqlQqvvPIK9XqdIAhYW1uL41Yjx9qBAwfYv38/2WwWKSXJZDLugtwYP3r27FlqtRqbN28OY2Q0jddff53t27fH3YiDg4Ns3ryZfD7PoUOH4rjSIAjYvXs3jz76KJqm8Ud/9EfMzMxw66238sYbbzA2NsYjjzxCIpHgC1/4AtPT0wwMDGBZFnfffTcHDx5E1/X4mCYSCVzXvSmWtd1u881vfpOxsTF+7dd+jXPnzvHUU09x9uxZcrkcQgiOHDnCoUOHOHnyJF/+8pfZv38/9913H6Zp8id/8icUi0UMw+BrX/samqbxW7/1W0gp+f3f/33Gx8dJJBIcO3aMo0ePcuutt3Lx4kXq9Trbtm1jYmKChx9+mKib9N3clABnz57lC1/4AuVymYcffpiXX36Zr3zlK4yNjXHmzBmeffZZHnjggZs6TqNe0Gg8R2MpirCtVCrcd999XLx4kU9/+tOMj4+za9cubrnlFiYnJ9m0aRPf+ta3+Nu//VsmJydxHIfPfe5zHD16lJ/7uZ9jfn6excVF6vU6qVQKKSVPPvkkSqkYKD/11FPcfvvtPPLII7z44os888wzdDod+vr6WFxcxHVdHn/8cUZHRwmCgNOnT/PLv/zLHD16lD/8wz/kqaeeYv/+/eRyOdrtdtz1WiwW4wjZXC7Hhz/8YR577DGCIODGjRusrq6yvr7OuXPnePzxx7n//vuZnp7m7NmzmKZJu92OOzmjffNuWltbI5fL8Qu/8Avce++9SCk5efIkf/qnf4rjOLRaLaamprj33ntjJ+n4+DiXL1+OY3MTiQTpdJpcLscDDzzAe9/7XlqtFs1mE9/3mZubo1KpsGfPnpvOzZ7+ZSWE2AX878C9QAI4BfwHpdTzG57zSeDPgV8BFoHfAQ4AedWdwvtuHZVCiCHg94GPAHngAvBHwOwPWKfDwP8G3EWY8vRd4H8GHgL+F+B+pdQL77AdvwO8DxgCKsA3CTswL/yjdkpPPfXUU0899fRftkTkItoYAtt1OgkToVQXUiqEElhC4AtBIDT8lqR++RqJbAk9kSBjmRiW2TVVyW4cZDjZUXo+Ej2MslQKCB1VSoQAR9M0Ak2gCDAQjMgWyfYqImWhmakujPBRykcqL4yOdMJIWc0y0aSChIWpa0jXI2i3ER09BEQiQEiFkUrjOhWUL9AsHel08Ko1hCigmd1+vIQJQhG4HkKGEMnKJGk2G+QcHxyFkcsifQ9Mi6DZCB2Ejs/SvIPrJum3PPKZJE5znUyxzIf3DHFyYRnrtime/MarJM5muGX/bey87yFmCwW0N0+xze1wzpf4gR8G43Yhr+O0mb92hYGRcUZGhnE9n9OXX+XUmZPcfvsR7nrvw0yff53py+eoNxs0m03OvXGKa1cuM7l9B7fcdhvZbKqb7lPA6bTQhIZhJUFTBDKg43TwPZ+EleDgoXvYf9t7OHf6FN/61vPM3bjBpvEtbN26nY7dobK+xlpljcBz8XyXaq1Cp+NgJdKYlolAWsJRAAAgAElEQVTt2EgPVBDgBzbIIHRfGiZGXMujo+tJEsnsTfdRUZej47a4dv0Ko8M7qNVr1KoVHLvBQH+efDYRPleA67mYaLRaDTptl4WlMG2mf3wAI2nRanW4ce0aCaOI63ajT4MQBrZbVdzWGmJgBN13SCgfgtDxaJjhuFdKhtBMSjSjG9vqe2AYoQNZenjnjiNry+hb96MPTCKNKAt1I5gM+0hD4NedBCz0EM5B9/OSkCRKFboQFT6oIHSZ+j6tRpP1tRXarRa6YeJ6HerNKo1mDaSOmUySNi2GBkdIZ5MkkgnGxsaxbZd8Pksyk2F5eRkUTIxtplgcYL22zJUrl2k0O1HyLIahsXNqGyODYyytLfLa6bPYtnfzNUMp/CAgCGTYVykDhAgNAZ1OE89z8X2FQKHrJolEKgS4Iox41YIAKUHTdKQE23Ww7Q7JVApd6ITwkzAWtgsPlZBd56REwyDADx2YXTAsupcwqYIQoEq6TtYAgjBIWimBEAqJQhPaW9c/FEGgQHRzp3v6idIPc4/efV4C+HfALwHbAB94Hfg/lFJfetvyzgEvKKXuf5f3PA3sAiaUUgs/9o3qqaeeeurpX0U/MqiMQFYEKoMgoFgssmPHjji61fM8yuUyuq5TLBbjnrtEIhFHhBYKBa5cuUK9XkcIQSaTiZfnum7sjIwiWnO5XAwzozjUZrPJysoK9XqdhYUFhoeH6e/vj+MmIwAZdVsmEglWVlZiYBQ5JaN1jtxlUXxnvV5H0zQGBgY4e/ZsDJYi92i0jZETcmxsjIcffpjV1VXOnTvHN7/5zRgWRvssn8+zfft2Ll26xNraGtlslqGhoRhWATF8jUDw6uoqL7zwAkop9u7dGzspE4kEe/fujXsbT5w4wdjYGB/84Adj0BM5PqPev2azyfz8PLZt88QTT8ROwaGhoRgaRwA3csJms1kMw6BWq8VutSAIyGQyFAqFuCfzxo0bSCn5i7/4C4QQ1Go1MpkMa2traJpGqVRicHCQIAjwPI9msxkD2shNJ6VkdXWVtbU1PvzhDyOEYM+ePXzjG9/g/PnzvPe972V4eJi9e/eybds2CoUCX//61zl//jyHDx+mXC6TzWZJJBJcunSJ6elpdu/ezcrKShyZe+rUKQqFAuVyOXZXbtmyBd/3efbZZ7l06RL79u2L4WzUxfhOunTpEp7n8Su/8ivs3r2bUqnEH//xH3P16lXy+Txbt27lN37jNxgdHQXCm6h2ux1D4wi8R/t8YmKCj3/84zz44IOsrq7y67/+67zyyivs27ePqakpLl68yMzMDO12m7W1NVZWVjhz5gy7du3i4x//OGNjY6yvr2MYBnNzcxw7doz/+B//I57n8Uu/9EuMjIzw9NNPEwQBn/zkJ8nn8xw+fJjvfe978c3s4OAgO3fujMfRX/3VX+H7Pjt27CAIAh599FFefPFFrl69imVZsSs5cohG+yyCg57n0Wg02LRpE0op1tbW6HQ6sTs5imn1fT+OPo6+fpCzMroWOY4Tj01d1+Nzf2RkBF3XGRgYYO/evVSrVRqNRjy5IIqpHhsbo7+/ny9/+cusrKwwPz/P6Ogod911Fy+//DK6rrN79+4f9ZLZ0z9dk8AJ4DTwKWAE+AXgGSHEY0qpL77t+T8LfBB4BvgTYPMPWrgQoh94CdgKfLv7NdJ97fPv8pp7u4/pwF8Bl4FbgWPA373Laz7Yfa4J/A0wDYwDPw18WAhxv1Lq1R+0rj311FNPPfXU078lqfjfQInQQ6kkmhAIGT0a+ioNTSCVwBAiBDXKwFnzqF25ipkrYmSzmGYCpVsEBEjlo+kKDSt2SvmBi+yCUCFA6/baeUKFzkqlk8OlUF/E8ZpkUyVU4BNIwjhIqRCmga6b+I6DQobAQ4RgUQCaZSL0FLLlQKAQuoWWSKKpABX4dNYraLbEtCy8Rh2RMLEyaTAFQtPQjHB90QRCauT6B1i8PEOpXCXbVwbAqzXQNJMAG+m6NKtNWnVFToe+pEc+myWXLVJfWSQ7OMytQ2VUs8GZTf1cuPI6CUPhewcxixM4ky3ElQsM+23mZYh40UDTTCzDwjA0luauUVtZpq9/kEw+z+ziNRafW2Tblj1MbNnJ/tIAVy+9yfLyDTqeQ7tR5/xrr7N0/Rq79u3lvUePkkylsDwHv+4TyDCmF91C0wWaFBiWiabr+K5HrlDi9tvvYvduByF0Ou0WnuORz5XYOrWLkbFNZLMJms0aCwvzTF+axu50qNVrrFeqdDwP3/OR0sO0TAgk7XrY8WmYLsmERbPVwfUChACjO+FbIbHtDitLa2zZZOD7LokEjI6UyWRSoVtPaWFFoy4QusDpeLi25MqVaVzHY2RkFE0zWVlZIp0s0W50OxqDgECC5zpUV+fRDEjnchR0ScYwESr8bEMqhaYCZGAjpIUuwm7UqLNV000EMnR8enW8q6+jN1Zhy37E5lshkQ6hXBDGGiNCZzJC0GX0XbdxAJHzr0vawn5KL1yXLj20HYfV9RUq9Qp+ILFMRaveoNlo4LgeqYSFbpgMDQ2zZfM2BvoH0Q0LM5miv3+cSnWd1dVlrl+bplarUC4OUSyWKTf7UTJg+vI0ruMjlSKbTTC5ZRvD/UOYCYuzFy59H6gM65U8AunjSxehTDw3oNVu0mw1adud0BCp6RiWRSKRDp2shsRWHVASoYGmGThum2qtRj5TwbRMMtkcQhjdfOGo71LgR5MaCEFjuHwNROjajNhwCHsVQqjuPXo3KlqF/JiuM1wiEUJHym51ihZe74TWi379CdMPdY8uhLCA54D7gPPA/wWkCe/ZvyiEuE0p9bsQph8JIY4B9wshdiilLm58QyHEEWAv8FQPUvbUU089/WTpRwaVUX9eBB8jt2AmkyGXyyGljCGM4ziMj4/HbsioVy8smi/Hz4tgWjabZXh4OO6sdF2X4eFhTDMs54764ur1OolEAqUU09PTcWzovn37YlgRxUdu27aNWq3G66+/TiqVol6vMzg4iOM4ccffd77zHUzTZGlpKYaWmzZt4o033uD06dOxA3JycpJ8Po/jOJw+fTr+Xq/X0XWdq1evUqvV4p7MarUau0Qj6JpKpdi7dy+nT59meXk57qqUUiKEiJ1pmqbF4KhSqTAzM8ODDz7IoUOHmJmZid136XSa973vfRiGwcmTJzl+/DgHDhxgcnIS13VjeBQdAwijV03T5JFHHokBnGEYMZjTdZ12u02n06FUKsXr5bpu3CG50QEZLVsIwdDQEIcPH8a2bRKJROzYjCJkPc+LeymjZUSOxaiHMYpCjRxskYs1gqqe56FpWvweG9cxilCNnttut1lcXOTEiRMopRgfH2fTpk2sra0xMTGBlJJmsxmvp+M4N/WsRgD93aJfV1ZWkFIyNDQU92mmUimWlpZwHIdisUipVMJxnLiHMxq70bZHXxHQ1jSNxcVFisUi5XKZarXK2toan/3sZ5mbm2N8fBzLsmLoX6vVyOVylEol1tfX49jgyMU4Pz8fxxFXKpXYpRt1L0aO5yiWOTqnK5UKlmWRSCSwLCuGytExic7T6FhFy4q6PaO44ej6EE1AyGQy1Ot1zp07x7Zt2+JxGoH1s2fPsrq6yoEDB2JH6LtpI0COwGYikcC2baamppiamuIzn/kMk5OTeJ7HwYMHGRgYoL+/H9M047H0yCOPcOzYMW7cuEEmk2FycjJe9o4dO0gkEj/kFbKnfwbdC/yhUup/iH4hhPg/CW+M/kQI8YxSqr7h+Q8DDyulnv0hl//7hJDyPyml/t07vMdNEkJowP9LOGv0YaXUMxse+2+B//sdXlMCniDsx7xXKXV2w2N7gb8H/hQ4+INWVAhx8l0e2vWDXtdTTz19v1544YV/8jIajcaPbVk9/fgUHZeeevrXVhjwChqg0MO4SSGQSkcJHfDRCONehdIRSIQKuyp1NGSg07yxhlaaxioUSKRTWIlkCAcIEJoW+jSFwo/64pBhD50M3ZURqELpGEjKbgW/toqRSCKCgMB1AYEKJIFykK0AM5HE7bTD3slOB90w0VMpNF1HMwyEaSDyJioIwFcgJaCjJZIIBH7gYqgw8tav1dEtE10ApgmmhqYMlNJQIiCZskBJmrUqyXwBAoUMfAzTAi2DdH0MSyeTDchkW6R1H0NCKpXG76RYv3GFwuAmbitmsDd3+MtVgyuXT+LaDgPje1B6ATUxRWFhnsb6KjUlQ4iIIJtK0pfPcqE5h223mLsxgzZvkMwVcF2bK7OnmVuYZmhgkonJWxkY2sSN6xdZraxiB03W1l2+88Ii506/xqHDd7H/jtsZHd+MYRq4rofQDIxEBsvKYKVSOI5Do1ZheXGeVquDZRkoFUYCSylJZpJkMkkK+SwDg0MIfYJb9h3i/Q9KWs0G165fZXZmhtnZy1y9OtOtxgHbtmm3O5imFfYrBh6ua6MBxXwGU4O27RAEklazhkwqTFPD0G0GyjqmoeE7HoZuxQNX0xWGLmi3AqYvX2R1fZVsKseW8Sk812dxaYlW0+1GvoKUPr7nUakt0ajMMTDaTzGXZ9RfJ2WmUYFEoAhcB6nCDkOUj2UZXbdngGYYRMHI4XAx8TsdqK9gXDpB4DQJpu5AS+eRKnQRorpdrEqi0KALZFECKf2uw1iE0aVKdmNaux2OgUejUWNlfZlGo4VA4Lge9UaDVruJpkyEEuTzebZsnmJsdBPFUhFNN9H1BLlsmeFOh+rACkPlARaWbhD4IXC2DI322BbW1m7QqrdA05jcNMam0TFyuSLVZgPd+P6J0EqpEPcJHaGZyEDhODb1Zp1arYrdtsNrhdC6AFHhSzeEm0EIDX1f4gcejuuzsr5GMpkgmU6RsFJYSa0bH6uFcbCaH5bpKtXljApkuE9FNy5WCAiUH0e3SgWa0vCUA2hvOVbp9m4qwskNIgTDGiq83kXgsqefFP2w9+i/TQgpnwF+SoW5wggh/j1hItH/KIT4W6XUS93F/DFwP/DrwH//tvf89e73T/1DK/fjuG/u/X0fqne/849Tb3/949TbX/94/Tj32X9J980/MqiMXGC+74cl613nXdSJGDn5IkWQ0XGcOOozglqRUy/quARiB2bkPkwmkzE46u/vj6FKuVzmwIEDMUCRUtLX14eUkomJiRikJBIJDh06FIOmqIsSoL+/nz179nDjxg36+/vp7++PodSWLVtotVosLS2RTqeZnJxkamqKTCbDvn37WFxcjN2YY2NjCCGwbZvp6WmuXr1KEARs2bKFYrHI3NwchUKBTqdDMplk8+bNcTzrxMRE7Cg0DOOmeNsIAiYSCTZt2sSrr77K2toaq6urNJtNbNtmYWGB5eVlpqamsG2boaEhMplMvKwofnejW3PLli0cP36c2dlZisUi9Xod3/eZmJgAiHsVI1fezMwMtm3H+yfaR47j0Ol0yGQyJJNJhoeHWV9fJ5fLsWXLFpaXl/F9P3ZXboyjjboZO51OfGwiyGgYBgMDA7z55pvcdtttLC4ucv36dW677bY4PjiCvmfOnGFubo4HHnggdslFYzSXyzE+Ps7+/fv52Mc+RrPZjEH7sWPHWFxcREpJoVCI4z4j2JVOp3Ec56ZjE4GrCMgZhsHw8DCO4+C6Lv39/fGxj8Zx9Ppo23zfj8+RaFujCNLoeGmaRl9fH/Pz86yvr7N//36mp6eZnp7mE5/4BA899BBvvvkmMzMz+L5PNptlZmaGVqsVj7PItToxMcF9993HsWPH+OpXv8ov/uIvUiwWuXr1KpcuXWL79u0sLi7S6XSwbRvXdeP9q+t6PKmg2Wxy5swZjhw5wssvvxy7l5VSnDt3jtnZWa5fv8709DR79uyJj0O73Y67ZcPImg4jIyMcPHiQz3/+88zNzXHlypU4VjkIAt544w1ef/11Nm3axObNm98VVAoh2L9/P+l0Or7G9PX18eijj8bxsR/96Ec5cOAAa2trDA4OMj4+HnfFRhBaSsnAwAA/+7M/i23bZDIZTNNkdnaWkZERBgYGgChSiHeF1j39s6kG/IeNv1BKvSKE+Bzw3wCPAp/Z8PBf/7CQUghhEkbQNIDf+wHvsVFHgCng2EZI2dV/Joy12fG23/8yUAR+YyOk7L7Pm0KI/wf474QQe97+eE899dRTTz319G9TIQ4LmwQDFK4SmEoSdKNZdSHRNR8wEHSdScgQCAiFUoJ2B9SVG2TKQ6TzeaxkBnQ9XHj0N7IAoQIC2XXEqW6nXNcVJTQdpSmyyiVfXyfwOmRySQiCbnddgPJdAtclaPso08Vz7HALZICeMDFzPmYiiWbqaNJCSyVASaTyCdo20vaQno+VzePbDl7gYegagd3Cb6XQtBzgIww9dFgFAqXpmKkM6WKJVqVFrtggaeWxctkwYXK1hVQuuWyGQ/fvxWnVqVfW8Nw2vtMhWyrT6jSprSxRGh3myGgfNBt86fUW8/Nvks3pFAd34etZjKk+pjpVZs6dY73TAl2x5q5RrdfRNIHqRoX6nofXtrEyKTp2B18FXLl6msuXzzA8OsnY6FYKfYOsry1Tra0iA0llZZljzz/LK989wdSOXWzdPcXYpq3k8nl0vY5pmiQzeTptl6XleZrNOppuABqu5xJIn3QmzdDwKOX+EfL5AlYiEQJVqZBopLIFtm/fxfjoBFsmt7JjYQFTN0lnM6TSGRy7zeXL55m5PEOtWkHXNJKJJJZp0KxV8KWPY0t81ydVSGB7S+hBd6KnobCSqXC0CkXSstANC9fxuXJllovTZ/Acn8GxAVLpLAuLyywvreK5Yc+jkj4y8Om0W1SWr+IHHfqHh8kZik26QBMqHPPSRRc6Sob7OZxcG4J2kKhAohshbEQoNB2EDPDtNoapI2ZfJZASbfd7UaYVdiwqDyXojvsghHCEDkqB7C4qPLe6gx0I0BS4jk+tWqVSq4Sfv2gmjeY69WYVKX1SiSyFYpEtE5sZHxujUMiF8F76aJokYYFhJNG0PiQuvnRYX13pTiKAdCpBNp9DyTDeeWhwhGK+j0QyhW7p79jZqAAZqNClSjc+2O7QaDdptlp4nhf2P2IiNI12O6wr6TgtfM/BD1T3swqB9ANabofVtXVKhRL5bAnLSobZvkKgCQ0pBbomkEEQrreuh1BZE0gZxskKIdHRw2NIAKLbsCs0lK8huhGvUkaWVroOV4WuGQQqQCpFIP1/zsttT//y+mHv0X+VcFT8VgQpu89dFkL8r4STdX+NMOEI4P8DFoBPCiH+J6WUAyCEKAI/T5hk9I1/zg3rqaeeeurpX14/MqiMohk3wsW3R4X6vh/Dg41utMgxZnU7FKL/R7GfEfiMfo6AUAR3TNOMXWhKKTKZDJZlxQDItu243zKCVUtLS8zNzZFMJmNYsnXr1hjobN26lcnJSTKZTAzfImfXLbfcwvDwMLlcjmQyGYObQ4cO0Ww2415B13WxLIvx8XFyuVzshIw6NKP30DSNVqtFMpkkmUwyNTXFwMAAjuPQbrdjqBfF0kaQslAocPjwYWZnZzEMg507dzIyMsLg4CCWZXHjxg3OnDlDMpnkyJEjbN4cJh16nndTNG3kNrvlllvodDpxp6hhGIyPjyOEYHJyktHRUVKpFFNTUzz33HNcv36dLVu2cOTIkThWNQJvUV+npmkcOnSIr3/96zzxxBPxsb/lllvYsmULqVQK13Vpt9vxWFFK0el0yOfzcfStaZpks1mmpqZ49dVXaTabMUjdv38/jUaD2dlZnnzySY4fP87MzAwTExNMTU3RarVu6kQdGBhg9+7dnD59GtM0GR8f59SpUxSLRbZt28bp06f53Oc+x9atW2k2m0gpYzfksWPHyOVybN26lWKxeFME6UZgtWfPHr7yla/wxBNPcP/993PixAl832d4eJhGo4HneXQ6nZucgRHIj9yTkfuwXq9Tq9U4efIkUkpeffVVfN/nwIEDMdC8dOkSSilOnDjB9PQ0mqZxxx13cOzYMb70pS+xbds2rl+/zuTkJO12m5GRET7xiU/geR5f+9rXyGQy3HHHHTz99NP89m//Nrt27WJ1dZVqtRqfY1GUL4Twb3JykltvvZU///M/55lnnmF1dZV77rmH7du3s2fPHv7sz/6MP/iDPyCZTFIul0mn07iuy/j4eNzzqus6e/bsoVQqUSwWefzxx3nyySfpdDrs27ePI0eOMDAwgBCC973vfezYsYNSqRQ7Nt9JqVSKhx9+mEKhEI/3UqnEPffcE/fHZjIZbr31VjqdTuwYBuJJDVGsb3R+RK5RTdPI5XLs2bOHYrH4jnCyByz/xfSqUuqdpvm8QHgTdICbQeV3/xHL3kUYPXNcKVX7Ae+xUQe637/99icrpaQQ4iW+H1Te1f2+Xwjxe+/wPtHzdwPvCiqVUre/0++7M0Z/oBuzp556ullHjx79Jy8jmsX441hWTz8+5XK5f+1V6KknoAsdRegykgqkEPhKoBAIIdEQIHXQdZTwifvjNvwTSJ3WukdzbpZCXx+JbAY9m8HQUxh6IkxxVFoIKwnvxZVU3c648P5KBjqWrjHuNjA7LcxUhoQRuudUEHZdSuj+Hezhej7SdRCEEbDC1FG+QmZ8jKSJIbsuNVMLmYchQAToSQtDNxC6wF5r43sSHROvuo4wTPRkAh0RAlR8hATdMkkXCqxXajh1G3Mwg5XM4NsdNGGgJy2cWoVMeZhcIUcqlWV9cYm1lSX6hoYpFvpZXLxBfXmRvpEJ7ts1SV6DY9fWsa0mlaVT5Io78bQ+rFya4kiVuQsX0TyJaYSxu0oHNA0DjQAft9UMK/U0DeX72I5L4AVMT5/i6vRZxoc3Mzw6Trl/iMraPK1mPbyXq1Y49crfc+H8m/QPjTC5fQdbt++grzwA1XVazRaV9VUCv41ppZCBgeeEk3Zz+SKl0gClUol0JoPZnXTs+R4Kgef4dDpNFufnWZi/gWGalAcGKJUGyeQyGGaSW249SLtZp1avYXdsKpV1Xj/1Mt8+/nck7A7ZbIbNExMMDQ0SBB4y0LAMi0CBL4Owb7SbTBV4HtdnZnnj9Peo11tYmsnI8CZWV6u0OjaBF4JxpUD6PnanxdL8ZezqKsm+HANDg5TtKun/n703C5bsOMz0vsyz1V53v7fv0re70Q2g0QBIkBBBASRBUqQQIEAyRpQlhR2WSEsWpaAdM5KXB094CYdnwmFP+MnhsPVgjR/GEkMaUhxKIimBEmU2QQIgCGIjlm70vt619rNmph+y8qC6Be7DIETVH4G4QN2qU3ny5CncU9/5/z8CM77myuIcz4dASDwpEHgI6RGEvoWVWiFKC3IO2uBLj0IVmCLDlxHZuWcpajN4R+6x3YxYJ6DtVh0DT2NsJyqgrM+PcZGlBaNGoLUiSUbsdzsMhzFSSNJ0RK/fQReK0K/RrDfZ3DjE4Y1bWFpYJgwjdJFbR6EnCEIP8pww9PADnyAQgCJNhggpkJ5Ho96iyAqkNFQbFcJqUJ778g2iUI15PRLaaBvJmucFSRKTqxxlCoyWaAO+F1LonCxNKfICpbDn/hgYCiEwGoZxzGAwJE0TokpIEAYWngrbdamNQgivBI5S2O9TjDB4Eus+HTtTGXd8au0hjIcR+vWIXZeyxfi5QlCoHK0VRk90V071s6Lve40uhPgM9gbfy8aYl9/gua4yxV1fY4wpxjfx/nfAx4D/d/yr/xioAn9gvlc/0Ovb+bGvm6d/31tNr3d+OE3n64fTdL5+eP37nLM303XzjwwqHUz0PI80TUnT9AYYdnOEZJZlpWvSybnJHIyc3KZ7njGmjOF0UMxBTwcmnWPNAQaghAwOjmitieOYwWBAGIbcfffdHDx4sHw/3/fxfb+Eog50OTi6vr5exkM6F12lUimjIB2kdK655eXlMtI2SRKUUqytrZXPDYKAkydPsr29zQc+8IEbIkvdeF3EqgNHjUaD2267jSNHjpTOPed6rFQqPPzww1Sr1TKO1/f9G7Y5OX9gOwg/+MEPYowpY3RnZ2cxxvDQQw8xOzvLaDTiLW95C4uLi+zs7HDgwAFWVlZ4+OGHmZ2dJUmS8r0dqD5+/DgLCwtcvXqVnZ0d5ubmOHr0KHme8+EPf5jNzc3SPeh5HkmSlIDO9XIKIahWq/ziL/4izWaT1157jWazyXve8x7uvvtuTp06xQc/+MGyT/Po0aPcf//9HD58uITVDlJJKXnkkUfwfZ+vf/3rxHHM0aNHufvuu3nggQeI45gnnniCZ599liiK+NjHPsbGxganTp3iD//wD1lbW+MTn/gE8/PzJfh26xEsiD18+DC//uu/zuc+9zlOnjxJrVbjYx/7GIcOHWJxcZFarVauW7ffkxGzDn6DdRPffvvtPP7443z+859neXmZj3zkI9xyyy14nscDDzzAV77ylbKL9N5776VarfK2t72NT33qU3zxi1/kscceY3Fxkdtuu4077riDF154gW63yy//8i8TBAEXLlzgXe96F5/85Cd59tlnS5frF77wBba3t1lfX+c973kPlUqlPA9mZ2f53d/9Xf7mb/6GXq/H7bffzokTJ8jznA996EPceuut7O/vl8egVqsxNzfHo48+Wp6jURSVx20wGHDkyBF++7d/mziOy95Sd17Pzs4yPz9fnhvfTUopVlZWABgOhyUwd7DVwXDnDnWfN5Pdl+49HDx30FIIQbvdZmZmpjz2U/3UdP27PH5t/LP9XR7/QeRe+/3e44d5zRs9Pj/++Z9+n/E0vs/vp5pqqqmmmmqqfyASQiKNQY3DLJXxLEwEMB5CqLG7yXa/aQQKicG60DAWpBWFYHhph8H8ecL2LPXQH8esWqhhmaaloVoX6CJDGPC9ABvKCst+QXt3By/0iZrNcU+gxgsAU2BMNgYJBpUpPOEhPUEep+iRJkdgigyTVjB5gVEav1FB+AEy0JiKQUofsN2Gwogx/BIwTMikRzA7C6aK9MdVHZ5EKKjV62wpRTCAkH4AACAASURBVD5KKPIY35OYOCdoNtBFhhdEpDtXqaysU5+fBQO71y6xdfEy84sLtGpVuqMe3WuXmF1Z5+dOHOfgyhbf6cQ8sZVSDXaIdYssm8GrHmR5dcD1rS2GWU7N2GhZ7dx3UmLQjLo9VjYPUa83uHD5HGmSMkpyhIq5Eg/YuXKa+aWDHNi8hYUlwbC3xX5nl1ynJIM+Fwd9rl45y7ef/BrrB4+ytnmIeruNkIIw8jEqpdAxRscII9C5TzzYI2mEJCMfozQa0NomWXX399jZ3mZra5tqJWT94GHmFxepVRtIT5JlBRioVKr4QQWtNJVKxM61FY7deoQoOEolrCL9wPYbSg+EV7r2fKPHnZU1MPDKy6f5xpNf4/r1LmjBoVuOUqnMsdvpjvsIDUZpjFZkccLW1fN418/TRlNttWDYJdg7x34tYm5mHikKQllFCMjzhNykhDKy4xEeSOs61FrjITHjOFLPFzYmOC/QnkRkMcOn/poQn+jQnQhpo1yNVq5IEXc6IEBar7J1KI8hJtp2asZxwmBoHYlKF/QG+8SjAdoIarUqGxvrHDl0hJWlFarVioVyUhDKkCj0ybViNBramF+Tk6cZWVGgsgJP+HjAyuIyG2sbtFtNlhaXaNSrFJlBSIH3BtzOGIMqlI1MFR4KEJ4kCCKq1Rp5XhCPRgAURYbn+fazQ2kKrVFFYdeyMiBtRGyeZPQGXeJ4SL1RR2qBFL4FtkZZhss4INfBXglogxFq7PC2wFlKG0lNGfNqgbU2BinEOIrXxfEKMMW4fxQbTz3Vz5J+kGt0d9383fok3eMzNz3+B8A/Bz7J66Dyt4EM+MMfeqRTTTXVVFO96fUjg0oXDTkJF8GCgjAMS+jS7XYJw7CM+nQuRRcF6/rrHBxwcME5Mic761xsqYMMLjLTOSyVUiUsy3NbSO7Gsbi4yPLycum8jKKIwWBQRoc6qOogq4uMLYqC4XCIELaXwAEPNzYHL937xHFcOhjd9txY+/1+uV3P82g0Gtx///0cOXKkhCbOSek6Gt1cuXlycbjVarWME3XjcNt1IGYwGJTz7LoQJwGZg4UO0vq+T5IkSClZW1srewjTNOXgwYOsra2V4HV1dRXP80oQurGxwXA4RClFr9ej2WyyurrK/v5+CXV7vV4Jv3q9Xjku3/dLN6UDwaPRCK018/PzPPLII6UDNYoi+v0+y8vLfPzjHy/XjXOJDgYDrl+/ztmzZymKgkqlwmAwoN1u89GPfpSHHnoI3/ep1Wr4vk+aprz//e/nPe95D91ul7m5OdI0pVar8Xu/93tlv+jS0tINcbJu7bmYUq01DzzwACdOnCjjcev1OkmS8Gu/9muls9PFyOZ5TpZlVKvVspvVnQ9Hjhzh93//92k0Gje8v3OIfupTn+KXfumXKIqCxcXFG5y3Dz30EPfdd1+5Tlxv5MMPP8xwOKRer/Pxj3/8hvf/yEc+wmAw4Atf+AIzMzMsLy8TRREPPvhgeT5prcvuzY997GPlus6yjO3tbWZmZjh48CDHjh0rI4udQ3hhYaGEx84x6+TWSq1WK8+rMAxRSpGmKY1G4+91q94sz/PKc9TttzsHXZfq5OfFZKeqO5ZhGDIcDsvPH+AGMCmlLM/17+bsnOonruXv8vjK+OfNTsjve4flhNxrv997TMr1YX6317zR4+593mKMee4HHNtUU0011VRTTfUPWGJsjzIGjJAoIwAPKQo8USCFGTsubW+lMqL8I0aP/90mVnqkPUH34mWixRWqzTZezSACjRBeCQyk9KGw15ZSSISEQtsL/9nRFuQpQaMOhUYrg9AFShmkL22cZVAhbNbQRY7nBUgBfhCiyVF5DDgnloUnwjN4YQUZhJiqRA1iRA4Cie95mMLD+OB5EUV3DyF9G0kbRuMeRA+jNZ4HutDE8T7NuE1BigwCpCdAQthskQ+h2NklWJijOtNmJkvYvXqdzm6HVruNUorhaIi/e5XW4garyyvUK12q6QWeOvsML+0qwtlV1lbupLJxH/XoZa5uXSQZjRCZwg99G/1a5Bjs3O1cuci+DMmUojvM0AZmBXjGoLKYrcuv0N25wNziGgvrh1ldW2DY3yce7hGnKUWS00s6vNT5Fq+88CzVVpuV1YOsHtyk3mggvZCoElhHm4Tu/nVGgz22ag2iSpVKpUEQVchzxc7WFvt7OxQaZmZnqEYVQs+3sbWmAJOQ51BkMcN4yKDXpdfZIooMtx27jV6/Q5YawiDA86QFSigbt+pJfCmQBlSheebpb/PUU0+yvbtPNapx+y13sLK8gUGjcwVI69rTmjQesrNzifTaGWSecnhxjkajRvr0UwzCEVcaPn7g0apWyHVORIAnfEJPjcHW2P1n3HWWtpBrfF1m17J1CRZxhspz8mGX9Mkv4FVbeItrILTtP7TUctxBat2F9j4A606UjCN+jf1eKRmnbRWFIstSRnGMKTyiwGdteZUjB4+wsrhMs9FACLs9D/CEtGslSYkHI/Z2t9nausr21lWuX7/EaJRQCWsIIVheWGF9dZWFpXkatSaNRotet4c3/i7jZhljO1pdd2kQhtRqdRbMCq2WJktSdve2iePh+Jo1IckSVKFQqqDQBQILEj3PXi8bIezvtU2LNlqgRGHnyYDAfqeiAKXt4/YxjZA+pnDHR2OMBcquE9RFJjOGpfYI2s8l1HitGA3GG7ePTvUzpB/kGr1702M368DEc0sZYy4LIf4d8E+EELcDc8CdwKeNMds/+pCnmmqqqaZ6s+rHclQ6uOaAWqfT4cqVK6yvr1OtVul2u5w5c4ZDhw7d0GvooIODbA4svlH32yQIde/nHIEOULntTvYmul5KBy3c8x0kEULYYvaiIE3TMtIVKN1bzgGqlCqdoZN/SLrxTro/3b653wVBUAJP5yp1LrU77riDer1OlmUYY8rHHex1AMs5zByIdY9lWVaCxkmA4oDnZAyvm1833w5YFkVRxmECpUPS7bP7dwcO3Ty5HkM3NilluX/OyejApZvDarVaAlQHySbXwOTacICs1+tRq9XKmNl+v09RFDSbzdKNGAQBvV6P2dlZLl26xJ/+6Z9y9epVjh49yvr6eglmJ52yDmCGYUie5zdAv3a7XTpV19bWyjG7Mbhj6+bZra0kSZibmyvBWBzHJShsNBrEcXxD56N7noPeYEFltVotY4vX1tbI87zs5HTuV9frOtl96WBapVIpI3bdNrMso1ar0ev18MZRPqPRiL/4i7/g6aefZmFhgSRJ+MhHPsLa2hrD4bDcfpIkBEFArVYjjmPiOC6PlzGGubm5Eiy6NeV+N+mYdjcruPO3VquVsbguejUMw3JduV5aN4/fDRA6JzRww2fA5Lpy69BF7EZRVMLWOI5pNpulA3rypgF3vrt+0ql+qnqbEKL5BtEy7x3/fObH2PbLwAh4qxCi/Qbxr+/9+y8p3+9dN/9C2G9G7n+D13wDG13zbmAKKqeaaqqppprqH4VsQ6VwnW6A/Xpf4AnwBUg8HK8xWDeSMmbCLTl+nZL0L/WoLl2k3l4gqteQnj+OkAwwwl6HISyoERJ86aPznEjHBL0u1UYNX3qYXFkAoRUqU4BCxRk6ABmGeH6AH0SgCqT0wJdolaHSDFMYBD7C9V8SIoIQGQaYSJH3OwhP4NfreLUq2hjywQgySb63jxz/XS3DCK0LC3+8gIMnbrfv50GRDQgaLYTwEQY8L0BIn3zQR8c5XiOgNjtHVuTsX7lGkAZUKxXyLGfY6SJlRH1hkdn2HPceDVmuXiZ89Rpf3T7HmaTLwfXjbKzcTWt2lU7vElfOnyGOc1xloDYKz7PXVyOVMdSQjUFOVwgqwlDF4EuJrxK8a+fobV1Cthbw5leotlapGUWcdBkO+mRZSq4K9vcHnD97juipKhuHDtOen2dxcYmZ+UXqtQZRaB2pWW5Tqbrd3fHNlaAKg5AJWTziwrkd+vuXWFldI4wijIEiS8cRmwrp2XZU35NUowZhmBEGOVEgxte0GoGhyDWZyQmCkFqjRhrnPH3y67z48osY7XP04B0cXD9EpVIFIymU9QYbXWAKiJMe29fOw7WL5HmC9gQszlHd2ae2lzCIoF6XaKPJC4XwCzINoedZEKYzUD4iqCA8D4zCqBwtsHBSKVAGkOR5QX8wQBWKXGlMepHRS9+gMfMh8EOMUbbq0hjMuEdRCA+lVdlZaTAYY/thldKkacIoHpIlFlIWmb22PrB8gGNHjrFxYJ3Z9izCNwht7I0HQqCzmEESs7Ozw9Xta1y7eond3V0uXj7LhUuniYcJxng0Gk2W5+9leWGZjbVNooq9yX4wtPc8CuHbnkijb/jMMM6ViMT3fGqVBlHUtp2Ug5RCK9JkRJYl5OPvdIpCUeicolD4XogUhjCqEM2GhIF1tQaBbx2U2ht/RvjWjWom3KZmHCuLsHDSPjSe33HEtPAxQqG17Z402uD2QIwjp42y27SuShu1+0PdSjrVPwR932t0Y0xfCPEacEQIccwYc+qm575v/PNbb7D9/wPbc/lJYHb82P/172HcU0011VRTvQn1I3/zPhm3CjZqdX9/n8uXLzM/P18Cgm63W3ZC5nleQiznKpt0ObnY1UkAOOmGcr9z/z3pQnO/n3SXxXFcQi/3vs55uLe3R6PRoFarlSDTgZ3JbblxTMbMOsg06ax0oGUyRtZBEzc+B+ocGHTPdUDPQUUHBx30gdcdkc7RmSQJAI1Go3R6OZAyCSUdRJwEYg7uOTegc565f9zxcY7AScB7czwtvN6x6PZpMp7XOeJufq57fweTJrtF3Zw5F63rsHTHfRIwu2MRRRFaa1ZXV3nwwQcxxnDLLbfQbDZLOOfWSxAE9Pv9Ejw64OlAtANxvu+XnY1uXJMQfXK/XESvg4V5ntNsNhmNRqRpWjpb3fy4eZ+cE7cfTg6QOmDmnMXuPZMkKc+DSeCbZRmVSgWgdMA2m80yctjdGNBut3nkkUe4/fbbiaKI1dVVNjY2yrXsxuDG7h530HfSbQkWPLp9dcdq8uYCd844x6SDqm4+3PtNAkYHP79XD6SbB3feu/2bhPHu5gUXAe1uEJBS8uqrr7K0tMTGxka53ifXphv/ZFTsVD8VtbEdFf+Ve0AIcS/wH2Hvvvzsj7phY0wuhPg32EjW/wH4vTd4j5v1NeA14H1CiIeNMV+Y+N1v8/f7KcFG1Pxz4L8XQjxljLmhR3MMON9jjPnKj7ovU0011VRTTTXVm0tSWLgljA18tchFIdF4QiGlh62ps+6p8bORQqCNfVzYCj5yo9GpR+f8BRrzC9Rn2oRRDeNJhBx3WwrbJycNtr9PKKQU1JN9QllQacxCktrePp2DkSidgR/heQEqyVCuEgHrdPOjAK0NKgOdJ2AKiixGjGwHnxKB7XOMQmToIxsBOlV4rRpqNMIMUrTKEb6HSTPy7j7Cs45Mo60ZTkgIwwCDhxQCEytUniICGw9rVI70fbxGHZOkoDR+JaQ1O08ej+jtd5lpNajW6gzjHvGog9+ViLah1mxyePMw/ySqcOzqFn/xWpezZ77JzMwqcwu3E82fIPTrbG9f5Pr+LnGuUECgNVUBiYaRMbjQytQYuoCsRIRCM49kVvpUhEKkO8RXu3S8Gl6rjddo0Zw9QJ4k9Af76CJGIkmzIWdPn8KceZUwqjEzM8/S4gGWVw4wvzxLrVmnUqlaAG0sWCxUgpQ+1VoN0BRKcfXqZRsJWqlRqVQIw4AgrOJ7PkYL0jxFKYhGCdW8QKkCYxRKafIiJUlGBKGPFB7nXzvPqVOnGPRHbBy4jbm5RWpRBSk9tAFhNAKJ0II8y+gNdtm9fIZmb4ckz9lXho3ZBjVPklzZRxUSEWgL37XCmAJfRGiTUxQGIw1KCKQXgOc6Vj20yvCEwHhj1yYGozVplrK3v03Nj8iMwvND0gsvUT9+H2J+yQI/rWzvKxJlbBSuZMKlrC3AtBHJGVmaMBz0GQ6G5DqjUAnzM3PccnCTzZVNZmbaRFFoHYGuz1FrkqTPtauXOXvxPNeuXWM0itnv7LO/t82oN2Jvv8soMYRRh2NHjlKYDOlBEAaovBgDT4PveRPn+niMxpBr10U5vj72faQR+H5IFmQYpUmzjMFwxDDu0+91yNKcURLbGF/PZ35uhfX2HEsL81SqNer1Gs1Gg2D8HRtAofKxY1vbzxohAQuMtU2rtjdQaD3+jDEolWHM625XITwQOUKPG0GNslHGRluoi/2uy3XoTvUzpR/0Gv3/Bv4F8L8KIT5mjFHj5y4A/+3Ec27Wl4FXsX2XFeAVY8zf/gT2Y6qppppqqjeBfmRQefOX9y7mcTgccv78eebn52k2m0gp6Xa7dDodPM/jwIEDVKvVG2I0HUxzYMFBSwdgJnsVJx2W7vkOgjjg4Z4zCXZcj6MDhd/4xjfY3Nzk+PHjJdiYBJGT7ivXFznpZnQgMAiC0p0FlKDPjccBS/d6FxPq9mV7e5tGo1E6LrvdblliWqlUbnCSJUnCaDS6AaRMukWds9U51FyUq4vHBQubJuMtHVhz25yMInXbmXSJOvg5CYsngegbRZe4sbjj4OCjcxe6MUdRVI7F931GoxGzs7MlxHIgykHBWq1W9p86J14URbz97W8vxzYYDMpYUQcHJ9eUG1OtVitjiifXXbPZZDgcljGywA0ArjyRxmvDwa8gCMooUaB0qN7c0+piiIHSSTgJMoUQJElCvV4vfzcJESdBpRtTpVJhNBqVDkY3T+6ccD+NMRw+fJjNzc3yOAohGAwGpdvVjTdNU6rVagnvXP+pP3GRY4wpYeAkOHXnoHNVuvXv1q/v+4RhWMJ3B1PdGCfB9xvJ7SPYmOInnniC559/njvvvJP3ve995Zy58+3MmTMcPnyYpaUl8jzniSeeYH19nc3NTaIoKo/V5DGa6k2h/w/4LSHEfVhIeAD4Vex97580xvS+14t/AP03wC8A/2x8cXVy4j3+EvjI5JONMVoI8VvAF4F/J4T4t1hweTfwQeALwMNQ3lyMMWZXCPHL2Au2bwghvgy8iL23eAP4eWyPZeXH3JeppppqqqmmmupNIuuQdH//u3ZKCyI94SHHDXpGGBC2G9HYVyHwxj4wQWFsf6VvBPFWQf/ceWqtWcKoRui30UKCEEik7ZUbv4cUkqCIaeQxzZk2fhiBF2LMwNqkigwT1AiqVQtThyO0sVGgUnpoJfAD22Wo0xyVR6gsRSuDimMKBKbQGOoEBmTo41cbjAa7qGGK5wdIIfHDKlolSGUoBj3wPCI/skmdQmPJpaYYFUSz9npYpxkFiqAS2U5BT+AZgfINOk3xGi2ChkdrfomiKOiPEtqtNlVdYxSPGIkeFIaqEETVBgfWD9KeabPWusTfntnlsYtn2dnbZnVhk4WFW5lpH2YtvsCp86e4vr9PrA0jA1q8/gedGB/FtNDsxSkDT9L1YZGCw5WQOTSRMPj5gEp3AP0r9Pw6SXOBcO4AMvTZ399iOOiRpQqlDbHukacp/d0u50+/hhf4VBsVZhcXmJtfoN1s0ZqbIaxERIEkNA5ki/GYPLJcoXVCUXhEKsLzFEYYC7m1QQoIQh+TFuSFosjtjb9pWjDoZnQ618iyjFZzmfmZKmEYILDuTq0NntCgQReKOE3o7F1jeO0cq3mf/VxxSWkqvsfcyiz+5auYTJMBWQYoG4FstEargsD3bXcp4ElNGieEQuAHcuyIFLYDUyuMURitMdqgsow0SRA+JDpHipg0iRHf/jvm3vVRRODbcQqJ0sUYXOoxfLPXpxKJNgVSCNu7aAyjZEiv18F4glrU4paDhzm8cZiF+RkqUQhk4+cKJGBUQTLq0+vt0u/so9MCz0h8TxKFAVEQ4PsSKRRJnHPl6mV293ZZXlzC8yTaGIpcgcaCSimQRqDd9wsG645MCvI8w8+9Maw2jJKYYa9Hr79HHGckSU63O2Rn+xqdbofhKEXl4+95NhUHV9aZbc4zMzdHFFWQvo2vta5JNY59tW5IKQRG5wgsHNfjzyozBo0CG18tjGfXBYW9lcFFvwLGCOuUFda9Koy9ScPeiFFgppbKnzX9oNfo/wp7bfxR4FkhxF8CNeA/AJaA/8UYc/LmjRtjjBDi/wT+t/FDf/CT3Jmppppqqql+uvqRQaVz503GOy4tLXH9+nU2NzdLOBTHMb1ejyiK6HQ6+L7P5uYmV65cYWdnp4RLBw8eLONiq9Uq9XqdoigYDAaly8m5/FqtFkmS0O/3WVxcLN1+Dji6+EwHbNI0pdVqla6qoijY3d1lZmbmBqekc4tFUVTGxjrXnnOBOSdZmqYleHJgxoFRB6xcfKWDkw4Yun7IJElKF5qbB9c96dxqDmAGQUC9Xi/H5/bVzdne3h79fp+1tTXm5+cZDod/zwnpYk7DMLzBNehg2c3xuS6y00HIIAhK0OXGNNkj6vbLzcFkT6eDei5y1EHHKIpKuAevu2O11tTrdYbDYQlPJ3sGJ4GrA57udWEYlnPqAJaDsA6+OsicZdkNLr4oisqeUQfdHICbdAY6gOxcoMDfg2luPJOORzeXtVqthM6T59DksXf75ICjg8fVarV0C0/Glbr3cGto8li5eXNrEywId7HDzslrjCnBpnN5umPl1rvbR7ffbu4c3HNrs1arle7cyTlwY3Fz5ObRrSd3Lk32zfq+X64tt97cenDntNaaU6dO8eSTT3L33XeXczwJPoUQfPnLX+ahhx5iZWWlBMlpmvLKK6+Q5zmbm5vl2tvd3eWv/uqvOHv2LA8//DDvfOc7S6jqoPDNYHOqn5jOAr8D/M/jnxE2HuZ/NMZ86cfduDFmRwjxAPAvgQ8D9wKvAL8LnOMmUDl+zVeEEA8C/xPwyPjhJ7DxNc6F2bvpNV8WQtwN/JfAQ9gY2Ay4AvwN8G9/3H2ZaqqppppqqqnePPKEQgkDxqMwAk/Y8Ffb1mbdjkIARtr4V8ZwE3ChrxpNjsZzgKrwGFzYptp+lajepBUGeK0QE1hAgDEICRiNpwtmdMJKq01NCjzfA2MIqjZGUggJnsDkOUJIKjNiDBgMSmm0zkEpTB6jKwWB1hTxAJ1Z5ye+BBmgc22dYr6HrFSJmg1G1/cRwiCrFUKl0CagIEZqTTHq4VdqeLWqjfyUEs8PUIEBT+DVIlSaYNIRyhN4vg9K2OdVI/JBH5GNkFFEpdGgkc7S0dv0ej1a9SqVKEOpnDxL8Id9PBkSVELaC4scrzZYnt3ilrkr/PXZLpcvv0Swf5W5xduIZtc5erBGo3aK7d09BllKpqzD0oyPjz/+RxeGRCnSXDPwBNeUYlZK1n1JRUNVeDQ9aBZdik6fwb7HrqyzsrgOC2sURjCKB4xGPZJ0HN2pcjxC0r2UTrfHhdcuIn0P3/eoRCH1VpNWu0Wt3qRarRCEAZ4XEEYhni/xfYkvPZAgMaRJRm/YJ4kzijwjz3LyLCdNM0ZxDHmAoiD0mkR1bK8pHr4MsN2p1qFbZAV5kTIadBhsXaDe32FFKc6miouFRiNYnm/TyjWmW5AY273qBYJmq46U1pWXZCOggS/tGvc9H8+TCJ0jiUCKcb8iqKKg7EQ0WBAvDFopBCmerJHFCfHpb1Ecu5tw4xgY+1rp2hDH166aYlyrKMadsRph7PlVpBl7vW1azTaHDx/h8KEjLM4tEFYqCKMwuY0C1sagdE6WFQyHQ7I0RxuD7wdooBpVaDSaZPMJeDAzY7sia7WQPEvodrtIISnQjEYJcZJgDHjCJ+f160mtFd1Bn53OLq39GdIst+ezgDSO2dnfptftoAqDJ0IwkCQZ/W5Mb6hw0+VfucbwWBfQBMH4RgClbYSvTuzcGFl+1igz9gyLsbtyIo3WxlEr664UBl3YvlbXV2kwGKF4vb9y7L4cw0rGN2BgpjcB/4zpB7pGN8ZkQogPAr8P/IfAfw4UwLPAPzPG/NH3eI9/jQWdGfD//AT2YaqppppqqjeJfmRQOel4BEpw42BAFEUIIZiZmeHw4cMsLCxw/vx5ut0u+/v77O7uUqvVuO2227h+/TpbW1u0221mZ2dv6IUUQvD4448zOztbAioXrepiJt/2trfh+z6nTp1iZ2cHrTVzc3PceeedLC4u0u/3OXPmDJVKpXRvORjqnG+dTodms8ny8jI7Ozt0Oh0AZmZmCMOQra0toiii1WrR7/dLYOmARbvdLns6XQ+li+70fb+MmnSw0rnL0jQtoysdTOt2uze44TqdDqPRqIzUdd2KtVqNs2fP8rnPfY6iKGi327z1rW+l0WhQr9dL2JamaekINMbQ7/dviKJ1EMg53Fwc587OTjnvw+GwdKadP3+ep556ine/+93Mzc3dEGvaaDRK8DTZ0ehg5Wg0otPpcODAgfIYe55Hp9Oh1WqVcbOVSoUkSZiZmSnBYZZlvPrqq2xubrK6ukocx8DrXaEOTA2HQ2q1WgmnHKCbjAh2r4uiiHq9TqfTKYGemxewAMt1M7rj5tyHDmJPahJOOhefg8Quttati3q9jjGm3N80TUvHp4N6k52Kbr05163778lIXM/zGI1G5fpyYwKI47iMyk3TlF6vV7p33TkMMBwOabVaZc+o266Djm4dOBesiy523Z5uDnd2dqhUKuVanHTOxnHMc889RxzH/MIv/EIJcR0QdnDYAdnJOXDHolKplGvZQdeXX34Z3/dZX1/njjvuKI+7+/nSSy/x6U9/mitXrvDtb3+bRx99lL29PR577DFOnjzJuXPnuOeee/in//Sf0mw2eeyxx4iiiFtvvZXPfOYzLCwscOutt5Zra/JzaqqfjIwx5+CGjKCPfp/n/2vsxcz3es4bHjBjzDXgP/kuL/tur3kC66C88clC/CtAATd3cLh9+s++1xinmmqqqaaaaqqfDdmYV2E793jdkSeEHse+WhclwqCNQuLhAhI19o8J2/SmsFvwEcJDjTS9MxeImnP4lQg/DPBEFSM9DBohBVEBIrPP/gAAIABJREFUC0mHpaxHkGcgBTpzW1fg+SBBSA9hNBTKvr5IbSSrFAilwfeAEC+MQPiIsIFWBcIPEKGHF4VI6TorNUJr/FqTsJFRDEd4lap1WGUK42sIQkSmrLNSeniVEOH5COlhioxsIIlaDYTwUcMRyvPxpAfajMcrkZUKxWiILwx+LaKStmgUCZ1ruwxje2MoeYxWBUWcUIQxfmBBcdSosVzd4H2tNkcWL/PNc9t840qHyxefItydZ2bhVlaX387szBa7e+fo9Ad0BwO0AYVBYocihGU6RhhyY9DaMPQE11NBy4Ml7bOsJW0JVc9QNxlBnBD3d0lbLeorG7SaM3jLqxhPkucZ29tbdHpdjNLoQqEkKJOS55JkFNPp9LjCJUAg/RDfF/hegO97hJUKGo03dtcKxslUQlrAhLHuRiHBM0gT4AcGTwRII8cgyYJrpMYoQ6FyQBAP+8Td61S717gl7ZEpwyuJYUsZYmOYq4cstqv0r+ywlRbUheBARTDX0kgKfCERRiGFT1HkCE9Y528Q4fsefhQgpGBsAUWpAsvcXcKOwSi7rTyL8aMq1ahC4EfUhEaffhq5son2fes0NVhHoHNTKutQRowfx14nB75ncVpesL60xuH1TZZnFwnCgCLPydMcpTSFttd9eZGRZjndXo8kifGlRNQCoiIg9CSBL5lptMiWsjF896lVq+NqohFCGApj6PR3SeIUgSQMIrIiQ42RoTaGvd1dLl26QOAHNFptosjevJ3lKYNBhiog8Hy8iketUrffdQUCz4Nc27jWXj/m6tYW67s7BFFEFFXseWgMRo0/U7Rzchr7uSMESAHGNuoa477vc+7aMYw0GmU0WhswGtupCRi7XWOyEi4D9jNJM462nuofun7Ya/TxaxLsTcH/8od8u7dg/+f3p8aY3R/ytVNNNdVUU/0D0o/lqJyECpMxqc6JNRwOieO4BGWu609Kyd7eHtVqlYWFBfI8p9frlXGVzlHl4EsYhtxxxx0sLS3x2muvsb29zcGDB2m32zz55JPs7++zvr7O8vIys7OzhGFIp9Ph29/+Nvfddx/nzp3jmWeeYWVlhUqlwokTJ8qxjUYjnn76afr9Pvfffz9nz57lq1/9aunwOnLkCO94xzu4cOECp0+fZmVlhdFoxK233kqe55w7d444jpmfn+euu+5ibm6ujHqF1+NbL168yP7+fgkBFxcXqdVq7O7ullD3+vXrHDt2jEqlwv7+Pvv7+7RardI12uv1qFarpfsxz3P29vYAeO9738vBgwdpNpulq9TNp4sN7fV6pUvNORmdq9O53LIsYzQaUa1WaTabJElSulOdqzLPc86cOcP9999fvtaBTufkE0JQr9dLR6sDhC+88AKPP/44H/zgB7n11lvp9/sl4EySpHxtp9Phs5/9LO9+97s5fvx42SX4x3/8xzz66KMsLy+X8zAJDl1n5yQYm+w6dQ5Bz/N45plnMMZw9913E4YhrVaLXq9HmqZlTG8cx+W8OMfrpJvVRe86iO4A5WQ8cLVaZTgcli5hF8M6GAzK2NebI3SvXLmClJLl5WWq1SoAnU6HarVKu91GCFGO0zkOhRClSzOKohLkh2F4gzN1skfSORHd4w5CZllWnuNAuV4cwHXHO03TEsJ3Op3ynHXHws2dA40OfgI8//zzvPrqqxw7doxms0m9XmdnZ4fLly+XIPfEiROlExgoH+90Ovz5n/853/nOd+h2uzz00EMcO3aMr33ta5w9e5Zr167xG7/xG9x+++1llC5YmL2xscE999zDnXfeSaVSIYoijh8/zic/+UnOnz/PY489Rr/f57XXXuPSpUt8+MMfBuD06dN0u90yBhdej/S9GVhP9Y9DQogaEBpjOjc9/nHgfuALxpjhT2NsU0011VRTTTXVm0OeMOW3uR4ag8QTBonBE4wjXscxjABlNOLY2QjjiE/7jycEPgKhfZKdjL3Tr+LXbHRrVcwjw8i+RilqyYi5/cvIdIgRAiMBP0DnKdLzwKRI3wIIIW3so8lyV0oHGoQfgJI2ojUt0IX9nQwrNsY2VRhtML4em6UssFAmx6/7FClkvR5+VAENUguIKmitUPHQwg3a+J4HUuCFAVoppOchQw8vlzCKyYwhbNSR2s6VH9ibMi2s9Kk06xjVZtgbsXd9nyhaoBo1KbIEncfkowFg0DJHBj7C92i0mtxWP8ri3CzLzbOcPNXnxdE2Z89s064vsLzxVhoH15kbXmB//zLd7j794Wjc6QeFAVd8og3kyhBoQ2ogkYK9POecL6kAq1KwWvFoRz7VQiFGPczFV4gNDGVI0WhSn1/jtqPHaDZnSNKU3qDDzu4e21tb5GqcDCQ0ngjt6tA5KhcUeY7AYzSIwTMII5DSQ0iD9AMkHr4I0J5GConlyQIpQRcaIQyM+wehoMg0OvcAjc4T/P4us71rHEl76FRxOjWcyTS7yvZ2VgKfI5vLqM6A64OMBemzEkgW6gqhQRUa4fuYIkEi8D3rGhSeIEtGqCynNT+HrPgWLI65mVIFFBrheRhtkMbH9yukgx6eL9F5jJA+gS8IetfIdy8TrBy2GF6ocb/lGLRhuxINII2NR/a9gCgKmJlpc2hzk83VDWbbcxgMnd4ueZGjCk1W5CitKfKCvMgodEGWabI8t9GtxqOQOVEQ4Mkm9cimOnnSQwY+fiAJQp9h3CdORyit2N/bod/vYvT4edJDKVeRAp1unzPnz2Okx9LiAZrNGWq1tu2KFAG1WhudF6RFSrVao1FrUanukaVDMIZCgVKaK9cucebiHMKX1BtNe54JMFqS5iPyPEcVijy33aVjro0NkbYuTE9KhJH2M8TYNKrX+yYlWttIV4mrDLKfBYLxTdNji6ftOp2waU411Q+m/3r883//qY5iqqmmmmqqn7h+LFDp4lFdzx9QdgU696CDmL7vUxRF6chyrkb3vAMHDtBsNsttTcZKVqvVEpYFQUC1WmVubq50w/V6vTIWdWdnhyRJythZsBCo2Wzycz/3cywsLJTjzPOcl19+mf39fW655RYqlQpf+tKXaLVavP/972dra4vnnnuO9fV1Op0OFy9eZGlpqXT5Pffcc8zOznLnnXdy5coV9vb2aDQa1Gq10hXqHIznz58vIzqvXLnCxsYG9913Hy+88ALb29u0Wi2CIKDdbrO7u8vTTz9Ns9kkTVM2Nze59957SxeZiy/d29vj3LlznDt3jrm5Ofb29rjjjju4fv06Fy9eJE1TlpaWuOuuu6hWqzz99NMcOHCAQ4cOkaYpzz//PFJKTpw4wfb2NleuXCldj0II7rnnnnJfrl69yquvvloCUgeEhRAleHNgEODq1av0ej36/T5hGHLw4EFarRZXr17l8uXLXLt2jdnZWdrtdnmcXRxorVbj0qVLfOc732FjY4PV1dUyQlYpRavVIo5j4jgu59vBcAd0HXCr1WolMHQAzq3Zz3zmMxw8eJC77rqrBISum9GBPtezWh3fBen2z0UZu5hb11E6GbfrIJaLoHUg0sHqNE1viKB1a7goCr70pS8hhOATn/jEDZ2cnueVLsfJKFUX5euiUV3fozGGbrdbgkatNaPRCIBGo1FGCTso6/opXSyyW8cuSte5HHd3dxmNRly8eJFGo8Fb3/pW5ubmuHbtGl/5ylcYDocYY1hcXOR973sfvV6PP/mTP2FlZYWzZ8+SZRmnT5/m4sWL/NEf/RFra2u8973v5bHHHuPChQsMBgPSNOW3fuu3OH78eLkvriP2ueee4/Tp09x7771cunSJT3/60/zO7/wO73jHO7jtttv41V/91XJe3bqs1WocO3aMt7/97fz8z/88d999N3EcU6/XWVlZ4fbbb0dKyezsbDlvTz31FO12mzzPy3N/srN1sqd1qn+UOgg8I4T4a+A09v+p9wDvAjrAf/FTHNtUU0011VRTTfUmkCc8pABpFBoPIRRSFGPsqJHCQ2P7BpUxKGMBpTYC10DoohUtaPEcx0GrgOGVmG7zNNXWDH4QEbYlSElgNM3BDqazS2EUflSzTrkitn2BWBih8wwh5NhJmSMKbeGhGtuyhLCdgXlu3XbCYLICITx0AULY1xkhQQqM0hTxCBmG+K2AqN1keHULnQ4JKgFBpY7xPdIiQ+gCnY5QsY8MPIgCZOBTJDnGaGQY2YjJpEBkGVpX8IQPyg7N8yK0l1H0+3j1GpVGi2Z7xGC3R2evy8rqAcKKh85TTJ5g0gpKDFGpRmiJ8cGv1llYXOI+z8czp5jbSnkujzi/u83w9N+yPLdBc+U4zc01+r2zDEd7bG9tM4gzjNI2pFeMHZbYn9pApg1K22uGDOhJwQVjaApNSxvawhCmhsADT6fsdrtcvnCJ0y9+i3qjxfzKCnNzBzhx61FWHnwfuSq4cukKV7euMez3SbKMPFPkyt5g6kkPrQoMHhLPwiJjkMq62XKRIpEooRFIjNIo38ImKQS5zvCxLr1QamTWx9u/RivuUElHCF1wPYGXEsWlXJMaSIGaJ3jr0VUansf+7oAVGbLkSxq+QudgtEerPYsE8izDC318bfA8H6UzDIY8S0g6gkqrhV8PwZOYQlOkCdhWSbSRCFEgvRCjBUrlZPEA6UUEYp7Q5IyunsGbX4NgDN+FKE19yua9YrRBGxvJitTU6zWObh5jvjlHq1lD6YLtzi5pnpBl+TiOV6FUMXYTQmEUWmmyNKdIC9IsI8tz2+VopHVJSxBaIoxGK0GeFhS5ASSFShgOU9LcdjzimdJ56KSUJh4lDAdDRtWEyM8J/JzADwiDGr4XobUiTFN0ociX1jEI9ms7jOIReaGQ0iMIKvQHQ3b2dyiUJqz4eJ6P1pBlMVmmyNOMQTxiMOgy6A9QCqQnrMvWs0HUvggsZBT2M4vxp5LUEUYa27OLQSIQ0t14ocepTa5p1+f1GzGmmuq7SwhxF/Ao8HZst+Wfj5OMpppqqqmm+hnWjwwqHexxX9i7SNZms8nFixfp9/vlF/6TsYjOddZsNgnDkJmZGZaWlsqIVAc1gdJd5zoeHQAFSseblLKMN33hhRcwxpSuRvdaIQS1Wo25ubkSNnmex2uvvcbMzAxHjx7ltttuQynF9vY2jUaDF154gdFoRLfbZXt7G4Dl5WXuvfdeGo0GFy5coNvtMjc3R7vdZmVlhUajwWg0KnsRh8Nhua9u+91ul52dHXZ2dsbxHzG1Wo13vOMdpePuiSee4P7772d1dZVTp05x5swZjh49ysbGBqPRqIxRrVQqLC4u0m63WV9fZ2VlhXPnzvHkk09y+PBhDh06xEsvvcRoNOK+++7j2WefJUkSVldXGY1GfPOb32R1dZV77rmH73znO3z1q1/lrrvuIooiXnzxRdI05aGHHuLKlSv85V/+JcPhkOXlZba3t0swl+d56Z5zrtokSXjhhRe4cOECQRAwGo146aWXeOc738m5c+fY2tri6aef5uWXX+bBBx/k2LFjZe+g53n0ej1efPFFtra2+OY3v8n58+e5/fbbmZ2dRQjByZMnefLJJ8myjFtuuYUHHniA9fV1zp8/z5e+9CUuX76MMYZ77rmHd77znbRarXK8RVFQrVb56le/WvakFkXBiRMnWF1d5eTJkzz66KPMzMxw8uRJDhw4wD333FOO5b777qPVanHy5Emee+45Wq0WDzzwAIcOHSrXrFvjzoEaBAGf//znOX/+PO12m7e//e3ceeedPPnkk2xtbfHud7+b2dlZvvWtb/HKK69w4MABnn322dKhfOTIEd71rnfx3HPPYYyh1+tx/vx5PvCBD7C6usoXv/hFTp8+jZSSD33oQxw/fpyzZ8/y+OOPUxQF3W4XpRQf+MAHeOaZZ7h06RK1Wo0Pf/jDvOUtbyFJEl555RW++MUvllGq73rXu/jQhz5UgmmgvDHh61//On/2Z3/G4uIiQgjOnTvHgw8+yG/+5m8yGAzodDrMz8+T5zl/93d/R6PRYG1tjc9+9rPccccdvO1tb6PVapUw85FHHiEMQ3Z3d3n++ed5+OGHue+++7h06RKzs7PEcUwURSVMdvt/9OhRHnzwQSqVCtevX+fUqVO0Wi2AMtbZxf26zwLnIHXOVvcZ5vs+g8Gg7Dh17tQTJ07wK7/yKzQajXJ9TnazTnbXTvWPUteBfwM8iO2ljIBrwB8C/8IY89pPcWxTTTXVVFNNNdWbQGbclmfwQAg8BBLwpEB647ZDPe5pN6CQ9ut+YZ2UCm19lWPiIkokYL2YeSLpnb1OtX2aoFLBDwJktUIz7VPtXIN4hKhVLbjKBUiDV4nACPQYKBopMHkGWttYUFMgfPl6KWNRgBYYlcI4mlbHI4yLf41CtDK2yxJjezKDwLo1paQy12Z0vWNjMgPr3PPqFeu6imNMkqB8Hz+csXGveZ8ijvErNaTKkaIgG44w3RHUK9ZlFwRIGSKCWdLRAJ1k+PU69fYszdkO+9d2idOYdnsG7UsbTakLdG5TZKQfILWENAcDMzNz3HV4jVRcxR9W8DzBma09zu+cJdy5wPzcEWaXb6E6t8LS8pDd7Uvs7W7T68cWOAnbrJhjkzO1sV6+VBkCAUYbskLT9QW+kHgYIq1Z8CVzUtDAFrAVWhGP9rl0tsOlMy/yra8/hvQj1jc3OXbrce658ziNegtlNFmmSDN7PZ6pjCROiJMUrQvywt68qvLMrhWjMdLgESGMsd2onkEaEEWCGcXIdIAc7OENO9TzEaEwJFpwNdOcTwxnU01sDIUBLSDAcGihxVKjSv+lS6xon5YXIDGMCvAjw/JKi3atSTrooNKYSlQHocfLWRLIEKVT8jghCCM830OEcoy2Auva5fWMSSk0nifwvCoetqKkWokQRY65egZ95B5kawYQNjpWGOsSNAYtxvBf2MoT6Xk0WzOsH1ijUWmQFxndYYc0VWR5gtKgtBqPQWKMAiPRWpFmGd1uh/5gxGj0/7P3pjGWXAfd9++cU9vde5vunsWze8Zjz+LxxM5qO05MEnASEFkhEiISm14En9gkPuVjJD4QCQkkpIAAKR9CCMFxHAeiREROcHAWGy/xTMbbeNzTM9PL3Ws5y/uh7in3+AkPkOcV8PLUX+rpnu66dU9VnSrde3/1//9HZDqlDPERBKqsKgpUSBSHNOM2URwSBTFCKozTZHlBkWdlmLNUSOlm21xuaxwEJHFUAkKbkeUj5MTiGg0CFSOlQwkFoaDdaYJcotWK0flhpumIwpQ3LsdRq0wDsmUljVQCq2fpT1ZUcbZpmrN+dZNXXn2R7e0xwmcbSzeLqi6joEvOKMr+UelTpcqbMWY7t2Ku1hqUCssrlSxvaqgrU2r9O3WOMiJ2AHwW+H/+a4dTq1atWrX+M/Rjg0qg+pDf/xxFEbt376bf7xMEAXEcVxGn/kN+3624srLC5cuXefbZZ6vOSe+W9B/8e8Dg3Zo+GjSOY8IwJE3TKlpyY2ODK1eucPbsWU6fPs0rr7zCE088UTncoiiqYmV9hKUHhaPRqHKUASwuLlZOutXVVRYWFqpePN9BuLy8zJkzZ3j11Vd58MEH2bt3L+fOnWNxcbECIkEQ0Gg02N7e5lvf+hZbW1vVuFutVuWC2717N0eOHAHgiSeeYHt7m6effprz58+TpikbGxsMh0PgNVeZB5VLS0tEUcTBgwdZWVnhBz/4Afv27ePuu+9maWmJLMt4/vnnK0erd2X6eF2/X7TWLC4u8va3v52VlRVGoxEvvPACWmueeeYZtra2eOCBBzh+/DiPPfYYjz32WBVx6l1uvuMxiiLOnDnDHXfcQbvd5plnnqm2/8CBA1y6dIk3velN7Nq1i5tuuqlyAXp3baPR4PDhw6yurnLq1ClWV1dZWVmp+iezLOPYsWNsb2/z3e9+l/3797Nv3z6+8Y1vcOHCBW6//Xa01vzjP/4jzWaTO++8szpuPr51YWGhcurOz8/T7XYpioKvf/3r3HrrrRw6dIiHH36Y+fl5Tp8+zcsvv8wjjzzC4cOH+epXv8q3vvUt3vzmN3P58mX+4i/+go997GMcOnSoinz1L8CFEPzt3/4tDz/8MCdPnuTy5cv8y7/8C7/1W7+FlJIvfOELOOe49957eeihh5hMJiwtLdFoNKr+U3+cHn30Ub75zW9y8uTJKoL2K1/5Co8++ij33HMPL774In/yJ3/Cb//2b3P9+nUefPBB7rjjDo4ePco3v/lNPvnJT/LWt76Vs2fP8u1vf7sCh4PBgC9/+cusrq7ywQ9+kH/+53/moYce4sSJExw+fLiad1A6RtM0pSgK3vve93LixAm++MUv8u1vf5vLly+zZ88efvqnf5rnn3+e9fX1yt27e/duGo0GH/7wh6vjs76+TpqmnDhxAmstL7/8MkVR8Jd/+Zd8//vf501vehO33HJLFdvqo3tHoxGDwYB9+/ZVHaQeLEZRVJ3PvnPTQ2PvRPY3RDQajeqx3rHqr2UAN998M5/73Of4zGc+wy233MLa2hrvec976HQ61Zhq/d8t59wW8Ev/1eOoVatWrVq1av33VeksKh1ecpaHKIVDCIkUQdnZNnN+zVoEZ8682Y1wzv8F1AxOqlnbZbm0RA8DBi+8QNLpEjZbtNU8rf515HSCUAHOWJwtwKcW5aWLUihVvs7XRRnPiC2/OYsIIsCWLkwXgjUQRFAUoEJclpedlgisLrB5gYxjRBKjgqh0XilVjjeKCNoReVpAIEA7jDaIMEDKFi7PsZMU19TIqIwqzScTgkaMmL2Onw77JO05RCCQUUIYt3D5BIQkCGOKvI+ZTggbCe2FOcaDEcPtPu3OHFGjgS1mEaBhiIoCVLNd9iSaWSSo1rRbHQ71tqDpGMcttJJcXt9kagsubzzHte2XmOss01vcw+LiCeYX99LfWmO73+f6Vp+i0EjrSqgzq/qTQqKtRUrQFigcGoMTMBWCkbGsOUEsJEFQHnvpBEqCNgJhHcIVTIfXeP78mM3+VeYXljEYrrxylcH2NgvNFu35Dq3ePO1GkzBKUEGE1W0KU6CL0nWpixxTWLJ8is5zsnEf09+iOR7SNFOULVCUrt7rBq7pElJuFoaRLbsVzQy0h8BiI2bvQpvmpSuIvPzsZmwNAmhHsHdfi90ri5CnZfSuKN2bUoRYfGVQCTadttiiwGldRvNKiZCidO16QObM7ERoYNIpQaBRjRZKSYIoJDFjdP8qsjs/O2dmQA6HEAHSWVAWqwV2FmGqZEAUxQgFo8GYwaBfOYdloMr+xdm4rS2BrzGW6TRls7/JlatrTMdj8lxTGI02mlBGCKkIg5Ck0WCuu8Di4hLddkCYSDAlzJRC4oSZ7RMzi0l1KClpNhJanTadTpcoUDhbkGcTrMkIgrJOCVnC0yAI6XaadFpNjBMYozE2RziBQBKEIWEoCYKYWckrOIMQkjiIkHFAkUkkgiIrGA0naPOv34grqn94jawyM187HwnLbL+/tqDAX+dq1frfyzn358Cf/xcPo1atWrVq/SfrxwaVHsh4+Z675eVlVlZWsNbSarWw1lYf7B88eJDpdIq1lqWlJVZWVlhbWysHEgTMzc3hnKscj74LUGtNs9mk2WwSBEHVzddut6suvXa7XcWmPv7441y9epXxeFz1MPqfoyiquhPPnTtHp9PhH/7hH2g2mxw7dqyK/Dx37hxKKbIsI4oifvjDH1aQFMrYzLNnz3Lq1Ck2Nzd5/PHHefbZZ7n//vsZjUZIKWk2m1XE5UsvvcR73vMebr31Vr73ve9x/vz5qpsyTdPKlej7706dOkUQBFXEqQeZHlJ615fvGTTGkKYpm5ubHDt2jCRJmEwm7N27l4sXLzIcDm/oNPRwMU3TCt54QNZut1leXmZjYwNjDKPRiFOnTnHy5EkmkwmHDh3iySefvME9uDP21f/u61//euVyu3r1KlLKyml30003sXfv3qpPMo5jlpeXKzh35MgRhBAcOXKEkydPIqXkqaeeqhyJH/jAB3jhhRe4cOECk8mEtbU1nnzySY4fP8673vUuNjc3+cpXvsLFixc5c+ZMFUnso2E97Dtw4ADve9/7qsjX3bt3s7a2RhRFrK+vs7a2xksvvcSrr77K8vIy1loee+wxzp07x8c//nGuXLnCH//xH/Pyyy+zd+9eGo1GdWy82/TBBx/kgQce4AMf+ACvvvoqn/zkJ/na177GL/zCL7C+vs4jjzzC+vo6zz77LL/7u7/LXXfdxXe/+12EEPzSL/0SQRBUEO306dP86q/+KsvLy1y9epVvfetb3HPPPbz3ve/lypUr/N7v/R4XLlwA4OjRo3z4wx/mzjvvpNPp8JnPfIb3v//9nDhxgjzP+cY3vkGe57z00ktcuHCBI0eOsL6+ThRFXLp0iRdffJGDBw9WgNBaS5Zl1bqPHDlCu93mrW99K9/+9re5du0a1lr+9E//lJdffpldu3ZVy0dRRBRFLC4ukuc5SZIwNzdXRcnGcczRo0f59V//dR577DG+/vWv86UvfYnf+Z3f4R3veMcN1xzfi9rv92k0Gly7do1ms8ny8nIF4/2c9jc9+OjX+fl5XnrpJf76r/+a0WjEkSNHqr7Q6XSKEII4jhkMBtx66638xm/8Bp/97Ge5fPkyb3/721FKVTdd+GhfP99r1apVq1atWrVq1Xq9SqxTQjJbfcJfNsAJZiDEMksq8u5LUEJinS1jYXEYDMpJVIUByt49AeAU0/WM/osXiLo9lqSj0d/A5TkqiRBKlV2TEoR15fOZAnDIQJbDc7YEdxhAlG5JoZBBjDMGhEY2WrgswxYaTOm+tIXGOItUIc4YzGSE7HTK97ooUAIZRUStFoPhBnarIOm2CaMEowtEUD6nmRbYNEWFESqM0FmK0yXQM1aQpxlJl1nnoSGwFmctzmqEgLDRohiNEc7Q7swzWRowuNJnMhoQL68QJjFCa4gUMlRlhGc6QRcaKwQqLnv4FrpdxGiAao+I2osYZ+liUmJWAAAgAElEQVQPx4wnGdqlXBtcYnPwCp2oy/ziPpYWj7JrUbNnus72Vp/t7W02ByOMcyhRHjvtIJgl6UrvNnMzGO0cTkKKQAQCJQWhk4QI4iDkwN69SGPKPsGJwUynrF9dY5qlrL36KmYwwDlD3wrGSpILAWHAwvwuup0OUgZoCgIVlRG+zmCynGy0jR1sMW8hsJaBs4wd9J1ks7AMjCPVmtQ4nBBYBBqQQEMJulHA/j1zxFf76InBIenb0uu7GAmO7Au4abULxYTpdEBWpDRbPXClu1QFilAFhGGCFaDtBJNnmCxExhEexGtjkM6VnabOYfIcYQ1Jo0MSNWg2W4RJRJA0SEdjTH8Ttc8hZVB6ka3/3Mq91p9ICdOsteRFTpqlbG5v8OrlV5lORtWNrIEKEYEkkDHIWbenUGVXZZqRTsqv4WhImmVY7Sh0jtHg3KzSKA7J84xWq8l8t4cKJEoJghBCVbpwQyEIpaQQBosgkNBsJHRbPdqtFo0kBmY34gqBNinKxWALnHBlB2kQIUTZKelchHUhwpURwFIEs2sPZTywcRitKbShyDWTdMxgMGQ07lPkOe7foImu+mfnL6p7KmY3UPjf/YgFa9WqVatWrVq1foR+bFDpoxjhtYhWH6vpHUnb29sAjEajyjXnHZJhGBIEAfv37696/KbTaQXidi73tre9DYA8zzl8+HDljpNScuzYsQq6HTt2jAsXLrC1tVWBT++obLfbFcQYj8f0ej2uX7/Orbfeyt133813vvMd5ufnuf322/ne977HaDSi2Wyyvr7OiRMnql5BP7bnn3+exx9/nLvuuoter1eB1TzPKzfmaDSqHHHGGHq9HteuXeP5559HSllFaTabzQrqLi4uMplM6HQ67Nu3Dykl/X6/Aj5CCJIkYTwe0+l0aLVaN7gZu90u6+vrZFlGt9ul3+9XLw69+3Fubo719fXKaeajdv3x8z2iPiLTg8TJZIJzroLNfruyLKvgrJSSra0t/vzP/5xOp8MDDzxAkiR87WtfKyfcDJR6gOSdbo1Go3LiAkwmE7Isq2Bfs9msIn53795dwV3nHFmWsbW1xfr6OleuXOH8+fNA2XW5trZWud98jGkQBKRpWkXJeuiUJAlHjx7lBz/4AVpr7r//fp5++mmeeuoprl+/zp49ewDo9/vcddddFEVBFEUsLy9XDss4jhmNRiRJQhAEnD9/nuvXr/PFL36ximJ9+eWXOXbsGEII7r//fp577jk+//nP8yu/8ivcfvvtbG5usry8zJUrV24YdxRFLCwssLy8XN2Z+Mwzz3Dp0iW+9KUvVWB7Y2OD/fv3o7WuoHwYhhhjaDab1XngY1HH4zGvvvoqX/7yl2m1WkRRxNmzZ2m321WEsp8PzWYTay1bW1tIKcmyrHKqWmv50pe+RJqm/NEf/RGNRoNPf/rTVcRrlmVMJhOCIKh6UPv9PkmSYIxhMBjQbrf56Ec/yoc//GF+//d/n6tXr1YRuD5mutlscvToUf7u7/6ORqPBxYsXsdZy6tSpKt640WgwmUyq/s0kScjznDiO+eVf/mU++9nP8vjjj7O8vMz73//+aj7t27ePn/u5n6tA8+nTpzlz5ky1D/y59HrXbK1atWrVqlWrVq1aP0re9ehmbspAWJRg1klXQkPr9CzmVeCcj71k9kgqsFImwJaxr2qHe0kIsEXE8KVtku4FohgCkxHGTZj1YGI0QqpyjVqDLJ1dtnAIY3E2R0YxIpAIGSADWUbTijLqVSQSCg1KlZGTzmHyDGccNtfYQiOTBKEClHQIYXBG42ZuOCEFcStisjkktjEqDEAEFNOUIIyRhcOlGS6xqDgi6/dLKBVGWK2xziKkKl2g05QMjVQhKkgQTmO0AyHJR9tE7XnmF3ejM9je7NPodGn3YkQjxtqCbNQvl5cBKk6QQqGLAlsUNBttpAyIVEA8uMZQTXjKCmSzQVrkGGspgM28z9albdqXn6PRnKe1sIc9ywdZWhxT2JTr164xGk2ZTFICZl2EtjSUCilQduaeFDA1JZ4OXdmlKLzrL7RcvPQKC0uL7NtziEbcxAnHeDRkMsmIgxbhfIwqCkKj6WhDpguckbitPtlkTJhECBlR2DFpOinrdIqCwhqccVyRigzIrWSUpWhjS+ek9cgatHNYShdlRwW0QsXu5TbdQcpWP6fvoCkdE6fZ3ZSc3hdyZLVJaFJMmlFkE7S1hHMxoQoBgzUaoUKQtnTgaoOzGqc1GIcKSsdhlmUIGSKlweqCokjRekIUzpMkEVEUggWTZUQqIJ/0y/UAQgSzE0hirQPhEDYs3cUOXOGYjqZsbGyxdvkya688z6B/FSyEcZM4bCCjBmGYIANFGDaQsgTM02mG1ZYwCGjECVKEpNMpusixxpDrEqLnRUGnM8HoAusMwhmUiFBC4YTFCY22Oc4KZtwaC6hQ0WolNBoBSRxjsaUR0pXealddFWQJvI0tI4dF+T7VaYlx5U21zlq0KXDWkuU503xKmuZMJymD0RaD8YDtrW0GgwHptJhdV2qsWKtWrVq1atX6z9WPDSonk0kFuZRSFbTwvYxhGAJU3XC+B87HuHpY5f+/M+rVuyh9jGij0aiW8RAUIAxDVldXK5C1d+9eFhYWKkiUZRlzc3M0m00OHz5Mu92uAOTdd99duTSPHj1Ku90miiLuvPNO2u02L730EpPJhIMHD1b9hwcOHKhg3NzcHL1ejyeeeIKiKOh2uxw6dKh6Xg9SkyRh//79rK6u8tWvfrWCu7t27WIwGFQAaXt7m3a7zeLiImfOnOHBBx/ktttuQ2tdORqPHj3KaDSqgIvvH4TXHK1LS0s88cQTFQz97ne/y+LiIq1Wi4WFhaqX0z92ZWWFLMuqCE0PDj0Y9U7HZ599luvXr9Pr9XjppZcoiqLsOJgda+dcdcw2NjYYj8fcfffdvPOd7+SJJ55Aa42aRQv5OxTDMCTLMpRSbG1tVTDZw0of8+lB1nQ6LSNrtGY6nVaRqGEYVm7Jd73rXdx7772Mx2Pa7Tbb29s0Go0q1tePwc8fv+/8XDty5AiPPfYYaZryjne8gyAIePTRR2m1Wpw9e7aKCt3a2qqAXxiGtFqtyh3ql/FwMYoi7rnnHo4fP8729nbVlzoYDCoIHMcx/X4fa20FvYUQZFlWQe0wDBkOh2itmZubY3t7myAI+OAHP1jBNA/oL168WMX9ejdho9GowGyj0aDb7VYRwnv27OHjH/849957L/1+H601vV6vild2zhGGIdPplG63W/W5HjhwgEcffZQ4jllZWaluNLhy5Qrb29s89dRTnD59urpGpGmKlJJ2u838/DxXrlzh05/+NLfeeiu9Xo8HH3wQYwwLCwvMzc1x4sSJqhPS32RgreVNb3oTV69e5ZFHHuHmm2/mLW95C8vLy9xxxx0cOHCA8XhczXPfJ+nPm7vvvrtyHTebzcpx6a9LPuLZf/k54sH66wFlDSpr1apVq1atWrVq/WtS3kUpfKukRSJRchaEKMpQROsc1nk8IKtg15kXDFc2VyJF2Q/n3Kw3bvY8AoGdCoLhmEaRo3CEiQIDIlAIGUBRYE2B0BaswVlT/l7Ooi2LKVI0wWmIGxAEuCxHBEHZVwnMyjMRNoAsBWPKmNMgxFmNCtsESYAgwFqNJCg9pEISNpoQjJmOpzTb7bJrUgqcNchQYbMCWWSIJAQpyCdj4k4ZA6rCEJsXOBUQxjG2KLAmR4UxzlhMniNVQBi1KKZj4kabhZUV1i6+wPa16wRSEcYh2micCNAY8smU6fXtEn6ZnLARE8cJUgR0211ujiO68RZLasS311OkCpFhwKQoSC24UDBEM5peY+Pla7TWeywsLNPdtcTCzXtxFPQHm1y9do3RYMj2cIJ1FmfLeFU363kUzhFIUcX92hm0Co3BGM3m+hp2OiSbTpCNFq35OYyBLDOgBI1mlyiOcZRdl6EMEE6X9lNbuhGLtMCpkDU7ZVTkaOtwBgqb47Se9aNS9k+WM5YQKkAZKUk3SoiFpDcX4sZT+v0M5STBDJCdmFec3BOwPBcQC4NNU/Q0JzWaKIoJZu5cEQYUJiOhCa48L2QYYfOZ7dSVfY0qCLDCkRUpsZI4p7AWXGHIBtuIPAWrac/NEcdRGT06vIbQBhcrjNVYSlCHkDjrEM7i0DjrSPOU0XTIxsZVrl9d49r6i/S3rsMsblbJEBtGyKCBDCPiuE0UNFCRwtmALM8IRZdOo0MSpSThhKHsgxjirEabMqpW5+XnZJPxaHbu5ozHI/IswxYGo8tqIuvKc946sMaWjmKrsVZjZ3+w2mCtQzP7GYs1EmtLwGjQGG3RRbm+QucUWpOlOVk2ZTKdkGYpk8mU8WRMmmZMsxytDTs+aqtVq1atWrVq1fpP148NKqNZv4UHEzudcGEYVi41KWUFgnZ+yO/BQBRFNwBMD7601hXw87GXHjjs7Mb0Uaw+zrTb7VbuLoDhcEi73abT6VRgzS/n+yI9rMyyjDRNOX78OAcOHCDP8wpEraysMD8/X8G1ubk57rnnngrCxnFMp9NhPB4TBAFJklTbuHv3bu677z6GwyFCCJrNZuX0PHnyJJ1Op3L5+SjNdrvNcDjEOcfBgwdZXl4uOxRmcbhFUZCmKVEUcfLkSebm5jDGcPLkSQaDAU8//TTOOVZWVjh9+jTz8/Pceeed/NM//RNf/epX2bVrF91ut3J/NptNJpNJ1ePngaK1ltXVVZ588kn+5m/+hmazWUFCfzw9qPQOy06nw9LSEk8++SSDwYArV66wtraGc46lpSXiOObxxx/nxRdfZP/+/ZWr1hhTOW3DMKTX6/Hcc8/R7Xbp9XoVlJxMJlXPZlEUDAYD7rrrLk6dOsUzzzzDoUOHWF1d5ZlnniEMQ44cOUKSJDfAMh97m6Zp5cANw5Djx48DsLGxwS233MLBgwd56KGHiKKIBx54gOXlZebm5vjOd77DyZMnuXbtGhcuXOC2226rgOpOGLq8vMzy8jLb29vcfvvthGFYQWStNQ899BDPP/88DzzwAN/4xjfYv38/9957L9ZahsMh0+mUKIoqgOu32ccB33zzzfzwhz/k9ttvJ4oivv/971fRrkAVEzyZTBiNRtV6vBN2OBxWMa6f+9zn6Pf7TCYTLl26xP3338+pU6ducKJKKVFKcfnyZf7qr/4Kay1pmvLOd76T5eVl3vjGN/L000/zB3/wB+zdu5e5uTmWl5eRUnLPPfdUjuvxeMyZM2d4z3vew8WLF+l0Otx8883cd999XLx4kfn5ee677z5uueWW6vmTJKHVajEcDmk0GnzkIx/hfe97H0opOp0OWZaxuLjIyspK1aO5c175iNckSVhYWKiuKR7e+muGvxZ5B6X/qiNea9WqVatWrVq1av3HJao4VzmLfS1/K3FCIqSd9SRKLGq27I6uShwOO4uQBenAvyKVO54DIIpDjh66iW4oCJxCKoEMY5w2gMNmGlukYJlB0llikANtc2QQ4LIpKk5KF1pWvqcQ2pR9eFKByUFIRBhAFJXOyKIoe/2ws0GJEoAyK2tUszFaS6vTZjIYo7PyRlOJpNAFIQFCOZzWCJEgEGT9MXG7h1QCgUDnmjB2EEuEDFFCkU9GSAvCWFCKMGkgXEy6tUmj1Wbl8H42Lr3CYPs6vcVlRJSwsbbO2ouvko1z0kyR2QCjLEJBmEC3p+h0WrRbTfbMLfOTrR4H56/zj5dG/GDLEAcBcSzJjCYHrBIU0rFZbNNf26J19UV6nSU6c0vMryyz68ReCp0ymg7Y2thioz9g2B8znE7QQiCFfK3Vz0FqHA0FLVHGgxaC0r2qLdM8Z3x9HakE02GOygxDCW0pUQJaQtKRklAJpIQAgbEOCVyxmm0s49SRWzebX8waT0sobnfMKAs0paATRwQqwBaaJNK0hgXzuSVWEbl19JqWY8uKffOSdjNEITGZxuoMbSwIQbPRJlIhTrjSHegE1pW1kzKQCGHAhmAMrjCIKEJKQSAF02KKpEFuCnCGIImJmi2kNQRKEgYSGYSM+luM3JhW8SpBsB/h5My4LLCm9IdaYWZ9rA6rC6bjEf3+FsPBFpPBEJMXaF2eE7iMAkHu+minUDIgDCOCOCaKOoQqwBEgRYSmdAgrGRKIECssTlh07hj1p6ytvUKWTWi0GggnGAxHXLt6lfFoxCTNSY2tHIzWOgbDPq9cuURhcsIwxliDdhqnHXmRoY1BF5pMF2gN1pT7utAZ1kBRGIw1FNqQzeqStDYUukwrssaW8LNWrVq1atWqVeu/iX5sUOmhjI8A9QDQRzp6RVFUwUoPOaAEBB4MeFCQZVnVR+kjQn2krHc3edjk4YV35O0EDR7CeLjgwVqe59W6jTEVtPGRs95xttN9592d7Xa7co0aYyonnIcgPrrWj8e72fz+abfbLCwsVO5QD7QOHTpUQS2/bBzHvOENbyDPc5RSVUSsB2w+xjLPcxYWFrjzzjuZm5urnKVve9vbKhDXbDYrJ+ltt93G0tIS4/GY5eXlCiYDnDp1qnKbOuc4ffo0hw8fJgxD9u3bx7vf/W4uXrxIo9Fg7969DIdD5ubm/pdj65xjeXmZ++67jwsXLrC5ucmePXtYWlqi2+1y+PBh7r33Xra3t9nY2KDX62GMuSFy1jlHr9fjjW98I08++SRf/vKXK6fcwYMHKyekUopdu3ZV4Pnd7343jzzyCA899FC1XXfccQd5nlf7uNlsVjD07NmzPPzww/zhH/4hZ86c4Wd+5meYm5vj0KFD1VxbXV3l6NGjbG9v0+v1WF1d5X3vex+PPPIIn/rUp9je3iaKIm6//fYqVtUDXmstvV6PD37wg/zZn/0Zn/jEJ+h2u6ytrXHvvfcynU55+OGHeeCBB/jJn/xJtre3+fznP8/u3bu5+eab+eY3v8knPvEJjh8/zkc+8hGSJKncfv4YfuhDH+ILX/gCn/rUpyqINj8/T6fTqTobpZQsLCxUXZ9pmrK8vMzp06eRUrK0tMSHPvQh/v7v/57vfe97FEXB4cOHWVxcrBzRQRBUHa/GGObn5zlw4ABzc3McPXqU48ePY63l5MmT/OZv/iZXr15leXmZ+fn56nh+9KMfrc5/H0P7sz/7s5XLOIoi3vCGN3DmzJnqPJ9Op4RhWEW5CiFotVoAlWPZOcdkMiGKIpRS1Xntt93fCOGBur92+Of0rkvvYvXXEb8//fWshpS1atWqVatWrVq1/qOyzuKcQjgBwqKEARTWWTBl+2QJIku5GaHc+X+BLF1glK43VzkuxaylsvRdtrpNFrttpNUEYYzv5TN5hrAGm2fYvJiBGolQQRVHKZXAalPGYlpAKKQUCKWwOLACGUQQxmW/pQSVRFjjZm7MAqECRKyQUYzDzDrzJEIEOFJ0moETSAHbG5v05hdRgSSIYkQxc1dmGTQSgkZCNtwCyt8LJzAm93sVgrLjUxqFsSlSKlQUlOMwECUtdDYhDmKW9u1m2u9TaE3cbjEeDijyDKuhyCUTEzFBgHJE2jBMDa1xn97cgE7SIElCbluZZ7mV8J1Lm3zrimaYO5pJgptOkSFI6TBKYZ1jaHKG/VdRW6/SuxzTSRrM7drF7iMH2Lv7ANujbYzOGY6mvHLpZUbDEZMsx5oyFljgaAtYEuX7jyEOU+QQhggFReaAnFBJhBIYC4V1dKSkIwSxs0gLoRMlHLeOMY5rwmG0o5hFuUbV3iz/72Y4XAloKkkvDnBOMi0MMp2wKiWHpaJLSCoMYeA4vgj7FyXznYCAoHS3FmWPqbWaXECr1SZpdRFqhkSdJYkScBrhIpABwgmUAqwFneNMUDotZYA2mpQJhTEU2RSQxEFEEkXEUYhNU2wYlxBvOCC4/C3k8S1cdgyIsNaU4N8JnHXlnJ+dQ2GgaCQhKqSMFnYSjEELRyTL/lYlJdaUEcbOWKQNkE4QyCYyKiuCKHKMKed2GCp0Dq4oY3OHownTLOXa9WsEkUIJSZ5pRpOCcWbQpfF1xzUD+oOM5194kSvrV5AywJgCbTTGCgqtMcaVu8qUDsvyfa4rXZnutR5JN4PftWrVqlWrVq1a/931Y4NKHw3q5aM5r1y5wurq6v8S77m5uUmz2WR+fr6CEDv7AT2Y9F/+7z5C04OwnX2KvkPRr8O7qBqNRhVV6QGLd5Z58JgkCUAF2vw2+b/Pz8+T53kFHj3g8PGa8FpkqAcgSilardYNUZIeanqIstOdVhRFBWillERRVD02iiLiOCbP88pNlmUZ/X6/Ap4e2LVarSoG1cPMdrtdjdVvexRF7Nmzpxq3BzOTyYS9e/dW0aoAN910E1LKCk4dOHCA/fv3V87DyWRSOV13dop6B9uxY8e45ZZb2NraqqJRlVKMx2N+4id+AijdrgsLC2itK6jqIVyz2eS+++7jzJkzpGnK4uIivV6Pj33sY+zevRvnHIuLixX86vf7HDt2rIrp9fCz0+lUx/31+/7d7343S0tLrK2tcfjwYTqdDtvb23zoQx8iiqLKGfqLv/iLpGla7aO3v/3tLC4u8tRTTzE3N8ctt9zCgQMHKrDu94l3Bb/xjW9kbm6OZ555BmMM586d49y5c1y9epWf//mf59y5c7TbbX7t136Nxx9/nCRJOHLkCI1Gg/Pnz1eA9B3veAfb29vMzc0xHo/p9/u8+c1v5sCBAzz//PPEcczu3bvZtWsXURSxtLRUzePTp0+zZ88eVldXcc5x7tw5brvtNubn5ymKgqNHj7Jv3z6m0ylBENDtdqvYWB+L689D33/6Uz/1U9x0001VhK2HzUeOHOHIkSNln8gMdGqt6Xa71fnl56U/z/2ND8ANzk0/H3fCQ38jgj8Pu90uaZpWj/fnq7+u+PVMp9Mbuib93H/9dWBn/+TO65Cr3+HVqlWrVq1atWrV+g/KIEvQh0NiCIRDSY2SEUJJnAvB5BhXQkcpbnS1+fhX76gs40FLSFmq/CkIYP/BRTqRJJASIQ2CEvw5fxNvOi2dkZQQyFk3A5MaR4jRuozdVAXOjlHtVgmPZs9p8ykiblD2XBYIJZFh2RuJCrA2I2yEZeQoAQg3A6x29v7IgBOEcUyepThhUUkMQmJtWvbt6RxXaKQMEHb22lwGBGGE0XkZJ2tCQOIwqCjEWYOTAqcCyDQmLxAyJIoCsnSIdIburiUcIUWuac53GY6GGG0QRrLQNBxZiugutYmbCcYanJRYGZBmGf3+OoHL6aiYNx/osL8z4jtrjhcmBWGjwSgrCB2ECrRwqFDiIkFRWK6ZjPVBRtzfIn7+h8wvLrK8ssLSvlV29RbZt2c3eZFx7fo1RsMJ49GIbDqhKyWhcThTEBQFSEHc7jAdjNmeTAmkIgksESUME1IQiTKmVQBq1mOqrWNqHS8Ly2ZumRiHoXTmutkkC6B0PcaKViBJpEQ7ST+zjLKUroBjYcCpdkgnluRSMdeWHFiQdGNRAkqR4YoUUxgkEoejkIIARSOZJ4ri8vOcKES48mZsjC3niAMpJKgQJwxYA86hhCSKSpie5hpw6CInUE1ynRMIQWQjnCgNvWEYMR8nNDYCmmHEhl7H5ctIEc0gnm/dLM/MOIpY7C5wcM8hlIO5do9XXj7P2qtXMVmBMY5YSXIo3bqqSdiIaTQWaDXnieJm6Vh2kKYTlIBAahqxmp2tKTLXZe9nXsYT+/eUhYXclDce2B/xPjMzjqtbU9zWtBox1L2RtWrVqlWrVq3/ufo/ApXeRbnzA/4sy+h0OlV8q+9YXF9fZ25ujk6nc4M70jv/fF9jFEWVG22nm8uvH6hcUj4W1vcz7gQQHnACNwBGHwcJVN99LK2HkkAFtjzwE0KQ5/kN7lHvKN35eA9hPGzx4/Uxs358cRwzmUyqbfPj8LGxftkkSSqQJ4Sg1+tVbs4oiphOpxX88W7BVqtVAcZWq1U5y9I0RSlVAVHvavNRrx4o7QSzHoj6SFutNcYYkiSpYn/9vvDblmUZYRhW4/GuuGazWcXp+mX943q9HoPBgFarRRRFVXTp4uJidaxGo1EF2obDIUopVlZWyPO8gtRCCFZXV6uYWK014/GYMAxvGKffH2fPnuUtb3kLaZqSZRlxHHP06NHKaTsYDDh8+HD1GN9h+MY3vpFjx45V2+SBWhzHN4B1/3zHjx/nlltuqcYghODAgQPcdtttbG5uYq0liiLuu+++as6eOnWKt7zlLWxsbJDnedV1Op1OSZKkinLtdru8+c1vrsbmbwo4ePAg0+mUfr9Pu93mpptuwlpLlmUkSVIBTz+ffTyqB5Q7t8cfN4A9e/Zw7NgxiqJgMpnQbrermwa8gznLsuoY+H3k1+nX5Z3Mfo7uvI74OR1F0Q0ObR/D6t2l1lq2trZucGp6x7S1tuou9eeVd//6L/93Px/8uVKDyVq1atWqVatWrVr/X6gMey37KANpkICUCqnK7sbCFlhbdle62dtzUcW/zjopZ78DgZi57MTMZ+l/jiPBrsUWgRRIVwJBUxRQzOpT0hFYcEWGk6Z0jwkNPhJTF7MBO4zJEUpgpymYaBbNaXEWBDNYGYQlSDUa5wwyDlBBgAgFQkoIJFhb/oyYRXBaiqwgjmKkUhRZRhhHmKJMNBKyBLUuz5BBWG5zbpFBhFSOfAYhZRiWfZ1RVPZiRiFmWmBMgdU5tsgIkwZgSJpzFNkYnaUQW2yRsbC0RLvbYzqckGtHGBSEcYwMFELFWFNQGItFYGWAac6jjaZwltG2JSgCzs0X7Ik0V5xiq93g5UHOcJKipKAVS5yAIpLkFnJjsVYy0Jatq1d5Yf0qrfPnWei02LW0wMq+fRxe2U10pM04naKNIcs0RT6lSDOiLEOJEG0LwtaE5nhMnmdgNCEKaQzCGjSSDEAalJA4UUa8DiLJ0GlCCpSzxFKQhGrWkwqxCpAiQGLJspz1omBsyj7HrhCcTQLuWlYcXQmZ77aJwgSJodAptkhxJi/7Q7EoXT6vEz6OiNAAACAASURBVCCRhGFAEsdEQRkFbPOURmsOFarS2Evp4hWyBNuIsrMTUyDjhDCIZj2PGqkAJ4jjgHa7jJINggCsxk6mKOvoJm30tU3k9Zi+fopYniUKFgBbnlez6GSHJVCSZitmz55VOu0mc+0ugpD+MOPK8BrOQaAsQlJCeWWJgpBGI6HVadNszBOEAcYZ4ihAKUuRW4yezt7DSpTKyAuNtQZjbXkO2te6KI0FKUTlgnQ7UKSPf975/1q1atWqVatWrf+p+rFBpQeFvjfSu/aEEFy6dKn68P/AgQPs2rXrBsedhyUeLmZZxsWLF1laWqqcfDudih4S7gSYHgL6KFbv+trZX+mX8b/3sare0enH4B/TaDQq+Ofl4WOv1yOO4xs67V4PPHwMpY+P9EDGr9/HT/rt9y7L6XRarc8DQg++/Pr8vi2KAudcBSL99oxGowo2bm9vV52M/X6fTqdzA0j0oAtgPB5X2+rXt3M/+/3uYzh9nOlOd6J3re7sAhRCcP36dTqdDr1ej83NTaCMXt3Y2EApVUWlGmMYDodVj6jffx4ke0joweNwOKTX65HnOZubm8zPz1cdnz4m1IOnnVG/Ox12Hi56F+poNKoem6YpQBWx679716vvMg3DkNFoVLlVd8J1pVQ1H5RSbG1t0ev1KmjqnGM8Hlcw3GsymVTniYf4Sqkb3MJ+7M45ut0uWZZVc9mDS39MgBtAoj93/HzwsNo/TxiGldPXg0h/PPz6z549y4kTJ6obBvwy/lzwDkk/lwaDAVJK2u020+mUOI5vcPt6d7bvSfX7EKiec+cNEf547oyFtdZWkNWfy/4Y+ePpbwrwNyHsvEb4n/0x88fSz7+d56L//06AWqtWrVq1atWqVavWj1LhDAaFEpZQgJQBUqrZ60rASpzTOCQOi0RBGZxaBXLKylu5o5dSMHOilT2QnV5MpxXh8hRrdOkeM6J0p1kLiNJ5aEvwgtPgZiBESXAWV+QgwVmBJYE8L92WSsxgpZqZKzOEKp/XaYOMAkQAqiVBKIQMEEJiKF/Tl8BSECQx6XiEndXDjPrbNLtdpCkdcU4phDRlvGYAQZjgrAHlcFIglCQvCgLtcMLinEYEEleUnlUpHEaCcZYQwDiczYmCBnHSxEUCo8sY1SiWxEEb50pnpnECFSqECkE2KKY5hdUIaZCyQZaPKZyk0W0wmIAZC1aUYN4axkyZ70VcbnV58eqAYqIJAoGUgkQIWpHCICicJM0NmbakpuDS1haXNzeJLr5IHChajQadTptubxEXhARxQpys0l4QTCdDhMnYv7p7BrAM6WSKVIpASJwxgKERN0mzlMl4hNYWKzXtMGLPZEw6mZJlBlNoQhlidOkEnGSasc7IdI6ZQbQAaAjBm9qK+/eF7Ftu0W0lBGGCLjL0dEKRp9hc44zDmrLXUSIxgcUoCFVMu90kDhWBCtAuL0FjGOKkxCiHwCCFQoiS1AmpqrlZwkVLEAZMx1OUKd25usjIpikiKN2XgZTIQqJaDWzqcGZKvv4irjuAUCJm87CMQy07X8u4ZYdUim53gThskk5z4uaLjDLL5qgcTygdUjlUaJkWBo1ABU3CsEUgI4wNMdZR5BnGZqDK9/+JC8gKiXESpMBqhbbgnChdp9KhnEO6WeyrgB+V0er/9NoVoFatWrVq1apV63+m/o+jXz2s8KBDSsnW1hZJklSut3379nHt2jUajQZBELC2tkaapkgpmZ+fB2A0GtHpdBiPx1VMaL/fxzlXAcIkSW7orPTuQA/+PCDyYAteg1x+nN5152HaznhV78ry8MQv02w2q9hS39HnI2qhBEFBELCxsUGapuR5zsrKSgVhi6KoOi7zPK9caj6eFl7r8vSOzUajcUMXpgdmHqx5eOXhUqvVqlyPPnbUwxYfebkT5kwmkxsia71r00f1epDkYZl3sHlg5vevj6kFbnC0KqWqKFAPVf3POzs8vYNzJzzy6/LHY+dY/P72+y+O48p9ClRzw89NPy98ZK0fowes/jl9P6kfjz8WAGmaVoDT71O/njiOb3DOemekH4vfRx7KxnFczTHftejnpId9r4fxfn74Zf0y3pXrtTMyeWev6875/vr17oSwQAXzPSj1546XlPKG6Nadjued8sv55wCqY+9vbNh5rHfuZ+CGLls/Lq+drsidnZJ+zEA1h3cej53RsH79r9frAebrXZU7Y2FfP/5atWrVqlWrVq1atV6v0lflCIRBCYFSAoma9eUVZaccN0KIEk+6ykVpsDhcBSndrHtOivK7ko6bDs3TThKELbBZWgJJY3HOIqwrXWdal/2RwiGcQKgQazIkIFSAEwFgcE5gswyCEGdBagsuRMQKbA4OpC0jXl0QQCiRIYggogKiukStGImztuy8FBLrHNYUREnM1sYGk9GAZtzAZClWagKhcE4DITJQOOOQgUAFCc5N0MWUIlOExIggBhfgDDPHZ0EYJUgrccqi0xSbG8KkgXIBVoaoIEKpABnGFNkY6wzFZEo2KRA44maTqJkg4gBlA8IgIAwL4iAgzcc4Z1nZ28SkGZEOUCKk0WxxZJjz3csD2nt6nL86JCssxlmEAJEJUIJQOhpxiEkceWHIbVkXapxlnBtGWc6rW32Mu1zeuK0kQdCk0Vuh0ZgnjhPGHUmgdFlzIxsY7citQQUCozMKApxro9odAiHIJjl5YTGuxTjdYjzcIk1zMt0vk3RcicgjoEf5fnHgHLEUvGMp4oHDEXuWdhEF5U3VWTqgmEzI0hxTlKCthNblZHcSCBRRAHOdRVqtVumOVQaXaRqdRVQQYgGLwRkFYdmvKOSse1WDsLPI3yghiRv0i6uAQxhHHCfEUYSw5dwIWgkqjMveV1u2uA4u/AB3a4YLJjjbwonSsOmsRaBwzmKdQ6JwQqCtYTCdcGVjg0vXh2zNDMZydv6qzCFkwfZki61RTnN7i2azQxg1kEKR5SlWp6jAEQhLUYyZTgvyLEXrshtUG0dhHNaBNg7jQLsb+yn/Ndl/e5FatWrVqlWrVq3/X+vHBpU7gQtwwwf/e/bsYXl5mfPnz7O1tcWuXbsq55mPgT18+DBRFLG9vU0URQRBUDkrDx8+TFEUvPzyy5Wjavfu3aysrDAYDLh69SrD4ZBut0uj0WB1dbVyrXkXl3d0ergYxzG9Xu8GJ2Sn06mcaI1GgyzLKpeWB1w7IYeHLDvhmO/dG41GPPbYY2RZVnUt7tu3r4Ij3qXpnX0e9oxGo2qsHh56Z6IHLd5NuBNAeTejd22+HkbthE9ABeo8WPKuNe9G8+vp9/uVs8yDTR/F6eNmfXyud4T69fvv/nEezHqg6yNt/TZ4YPV6x9r/7munfhQg2ul62wmz/N9+lBvO//x6qLcTUvnHvj6GdCec/ffox4kU3Tnmf+25/r3PX8eZ1qpVq1atWrVq1ar1n6fS9WiIFDOX3ez1vJAIqXAUGAfGldGYUpT2wtLvtdNR9drrfYuPiSx/pwKYm2siiqLskSw0zpRxmkpIHHm5BinLaE0UQoLFIoSadVSWSMbkE0BBGCPjpAQ/UpbRnkWOjGOcTnHSYp1GxHH5yGYDpzVI+dqoBWA1QkiElMiofE+aTaa02x0CqZiORrRacygjsMICEmE1TltUEJU7MAhBlDG4zuQ4M4uuVQpnfI+lwGmBUI4wiUhHA5yUiEQiw7jcLmugIcpOTWMJ4yY4iIIGUbfA6nI9AnC5xlmHQtKIGgQyoBE1ibKM4bTP2DoKB80kpNvrsbSYsDy/yfn1DeZUwnNDw7WxJkt1CZ2tQwgwWY7GoZQgUQLrBHGkSLWbQUMorEM7B9KS5kPGVwdoBw6FUjGokCCIUVIRBBFBGKEQOFs6BbUuKEyBNgatC4zVWJOjbQ6zhlJJ2WfZRhAhiEU5xwbO0VWCd+9JeN+xRZY6TaRSZNmYbDIhnw7JM4MuSjuucZQRsoFACUkYNoiTAIel1WwRxxGFMzgjiaI2EltOETuD8NaVjlBnQeeIICgBvNVgbBm3GoVIKbBFVrohTU42nRIHAUJGyCACqcBoMAX5ZEiWxgR7YSwvEfV2zZyUDpzDCl2eOWUeMUbnDIfbrF15hR++9CLb/Qw7i2I1gBPlD8I6xoVmO+0jt/rlDbBSoKQqo5qtJQoUUjhAYwxYY9EWtC2BpHPlPiu7Ocvn/7feodfv4GvVqlWrVq1a/zfoxwaVO2GOB1N5nldxk0mSkCQJ4/G4ctDtjIPs9/ssLS1VsbDXrl1j//79lfvwueeeQwjB0aNHefHFF7ly5QpJkrC+vs7W1hatVovNzc2qIw/+X/be9MeO6zD7/J2ltrv1vnBpkiJFiRJFyR47TsaBHcVLYsxAGMCYNx/998zfESDJl3wKMM7EsAM7iBMrsZU4diTZ1EKR4tLs9e61nOX9ULdKxZumFzm2807qIRrd93bdOqdO1QVY/bvP88C//Mu/1GCx1+vR6XTY399HqbKsfWtrixs3bvD48WMeP35Mp9Ph0aNH7O7usru7y9HREdPplO3tbc6dO0ev16tBWxV92u/3OT09ZTwe1xGXSinG4zHD4ZBXXnmFnZ2dGtw1wV4QBPT7/TO7Has1BGrAur6+XkfFAnWEbOWCq5yKUIKqbrdbuzCr89OcQ7M3tAKJ1fOVI/Tv//7vefbZZ3nmmWfqGM3KsVpFn1bfK2Ba7asCoJWjs9kzWMWZVt2NTWhYrXEFXCvAWO33LEDXBIfLALIZ/fu0vsEm+FyGoU03XRNyVtD4rLGqxz9LzfGa+16GsMvgdllnHcsvol8GqP5n6GlQtHUgtmrVqlWrVq1atfpvI+EIhSNQGiXlonPSlZGji/sYuwh2rCJehaB0XOIXaZCiBpUOUKVBD4FHSculZzdYXx1AnpVxrXisMyhn8DJcRLyW/X84j1AVsCy/pAxACXxhkSoqnXFC4K1BBLKEmALQAmcM6BC3qHSRoQPpsLlZwEOP0GXcpUDghQWpEdYipCbq9JjPHpHnAd1eH68UMqTs1MwLjActFd46RKAq+yhSLTorvcIZg7cGXIR3ZU+mUArhixKeFQ4Kg8synHRIEeCFQGmFVAqXZ3hhkHGCjAKcAeUVOtQESQeMIZ0NwTq881jrkEIRdgKiMCLUAiUUqc6YzGcE0yHRWsiFrW12Nja5dnjIv957zA+LDeZOIY8muPGc1IPFc2otubUY6zDeY4vSuaeBWAsKwFJGx/YiiRMCtCxjQ31BVmQIN8PZ0n2YpyXw8wvQKahiSwUhIIQnCAXeSaQHaWFFClaRFN5z4hxD78lxbIWa/+u5db7wzCpxILF5znRyQjqdks1zjPNYLzBF2ScaRgoVlhA8lgFJt0e30yEvyg9OO2+IdECyssZsMkbJoLynliAKUbpyvUV4wMvyexAusk4twksCGaKDgDSdl4+DLnGngxYCJUNcmiFjjwwCdEfAbEI+LVDDDdi4h/e3EKjScelLR2UJ7gU4h8kMh8dH3Ln3Afc+fLTojBWUgcmVfO18rIOgrFn8UDTe8B/9/DPjWj0/67etWrVq1apVq1b/7fSxQWUTUFXgoQJbFZiqXHlxHNdQbjAYcP78eYbDIW+//TZbW1ucO3eOIAjo9Xp1395sNuPcuXN0u12uX7/O97//fY6OjpjNZly5coVr165xcnLC9773PYC6g+/FF19kfX0dIQSz2Yy9vT2SJGF/f5/33nuPCxcuMB6PeeONN3jmmWdI05Q33niDoijY3t7GOcdbb73F7/zO73Dr1q0n+vG63S4PHjzgb//2b5lOpwgheP755/nsZz/Lj370I+7du0dRFGxsbPD5z38e7z2j0YgoiojjmLfffpvDw8MahJ07d46rV68ym80YDoe1w3R1dZXV1VXyPOedd96h1+uxtbVFURQ11Ku6CqvOR601URTV618URe3urNZnNpvV8bFVdGgTthljODk5YT6f112CVQxvBVqhBE1VzGzVAZnnOePxuO4yTJKEKIqYTCY10DXG1H2IWZbVEawVSG5Gd1Zu0mUQWakJu5pu3iZEbF6bzd8tb1d9b35VULi5Pme9fnkuZ2kZii4Dw+XXP22cp+37F5nDz9vffzY8bCFlq1atWrVq1apVq1YQSFBSo3VQdkG60smopMGbj2IfK/ekKn2OiAW2XODKxd7ERx2VCykt2NhZxZmMPJ2g81kJHp0DqbEmRwcKX1i8AClUCYecKSHgImnHG7/Yexk6i1QgJK6wSA02m0HuQQUI58B4RBiU2aVS4vIcoQOEK2NtZSBLh6WQJXCi7JgUQiJUwDwzRFoym4xITwO0TshHc2SkkQqULPdbgk6BVBIZhLjCYooC6xxqYVETSiD8YgWlwrsMr0B3YorRmGx+iOp1UHGMFR7nLEJIpFh8CNWCMwahPCQOqQOU1DjnUUmAyVJ84BBegIJOp4cXEp1OmAnFKJuhpxPWVlbodBKunD9HEse4f3vAWMf4Tz9PdjCm+PAYMU+ZFp6ps8ycZewNBrs4/x5nPCnlsrkCZs7hBXhlkbK8x421JNSS3FgcAushFOWpCBA4t3DhOo9Y/KydpycF52LJhRD6TuCs4kEmcUVOJgzXexH/46UdXtkdIKVjcnrCfDxhlqZMhhLhJUKXkaVR6Ik7EjR0ux2SpE8+nxCFHTqdVcT0GCiQXtNfW8OJgCIv6CQgtcKZvAbnrrAffVgYX/ausoDqSLSOCMKYuTnBeoFUAuEN3oEzIVJrdBTjPAjtCDsJdnqE2zdE11MKO0GrHg6HFGXXqvM5OIH3gtl8yuODfd774H1Go7TsXoXSfUn5oYGPoxZDtmrVqlWrVq1a/eL62KDSOVf32cFH/W9VF18Fo5quvOl0irWWra0trl+/zp07dzg4OGA+n9ediisrK/V2UEamVmONRiOcc6yurtYux2q8qpPuwoUL9Ho9lFIcHx9z584dnHOkacrDhw9rmLa+vs6Xv/xlpJS8/vrrjEYjPv/5z6O15i//8i/Z39/nxRdfrHscZ7MZeZ7z4x//mLW1Nb7yla9w584dvve977G2tsbm5iaDwYCdnR16vV4NpyqI99Zbb/H666/T7Xbp9/v89Kc/5eWXX+bSpUu8+eabfO9736s7Ovf29njttdf4i7/4C8bjMUVRcP78ef74j/+Yf/u3f+Po6Igvf/nL9Ho93n77bX784x/z6U9/mt3d3dqV+ODBA27fvs3Nmze5ePEiRVHwxhtv1E7RO3fu1NDz0qVLXLt2DSEEk8mEIAgYDAbcuXOHo6Mjzp07RxzHnJycMJlM2Nvbq4HTo0ePmE6nrK2t0e/3AeruxKpvNMsyjo6O6o7Lbrdbx8I2Oy0rsNh0Uza7MJvwq9r2LEcl/EfY14yVrcBzte8mjKwgpV18Qrg5xtOg6c9zKi5H1z4tuvWsKNzlY1qe61nfz9LPAp6/KUhZ/a6Fla1atWrVqlWrVq3+uyiOQ5wp4y69A+8NUgZIW8ZBem/xXi+iVz181ERZ3kfjkUjkwv2I+AhcCsAYQTaaMAtyEhzCgzVZCXucBQxYUY7vHV64Euh4gTemjExdxMH6kqLiZQmLbJ4vgFleAiQVlfCx6szUpTPTW1POSGgwGdppnFOlq9IDsoSJMtCoQJIkCaeHxwRJhyLPKJwn7nbohSHpdMyCVC5AYnlMMgqRMqCw89KRV9gSxmqNsJRxsa5ctxKAGZROkCtrpKMR+ckJwkG4so5XQRm563K0SErXqnfoIEbpCJxDKImSAh0GdTSuchY7zev1T6IOcdRhNlOMsil+LFiTik5vwMVunz/uJbz9k3s8fP8t7KVLuOduwTQjf/cDzOMDhPNYNI4yKtUhGeWekxy8l+RYDsg4cg4l4bmr59m8sEfhDePhAT986x6HqUVpjQ40233NyxfP0UXAaER+cILEofXCQRmCEJLJXHCQe/YzOLEFLnB85eI6/8cLO2z3QqaTEePTA2ajOVkqGI0D8kKytu6Iup5QByRdhY4C8IJIJ6ytbjPWmqKYYUyCxyKdpNdbRQUxs/GIopgj5HrpHZYaIQ1IgfNuAeUlwkmEEviiQBLhVYBSc6Kkg5canzvS3DGVOdJm6CjGS7De48pMVXQSE0QhJ49OWcvOY9RjAtFDCV1ieCGQ6IVb1jCeTtg/eMwH9/cxxtWxr9V7zNchy61atWrVqlWrVq1+XfrYoFJrTZqmT8SShmHI1tZW7aSsHHuz2QytNVprxuMx9+/f5+joiNFohBCijiR9+PAhq6urRFFEkiTMZrO6HzEIAjY2Njg4OGA6ndYuzTzPa9AFJQiZz+cURcGPfvQjjo+PuXjxIv1+v+5jnM1mT8SQCiHqnsxer1f3ZVYwq+qTtNZyeHjIjRs3uHLlCpubm9y/f5/hcMj29jZBEPDKK6+wvr5OmqaMx2OiKEJKyY9//GN2d3f54he/SKfT4Rvf+AadTocwDOsY2FdeeYXd3V1WV1f55je/SZqmfPWrX+XRo0d8+9vf5vDwkNXVVf75n/+Zx48f0+12eeONNzg4OOBzn/tcfW6qTsuf/OQnhGHIxYsXOT4+5jvf+Q6/93u/x87ODh9++CFBEDCZTHjjjTf4whe+wKVLl2pXo5SSv/u7v0MpxVe/+lUAvvvd7/Lw4UO+9rWvkaYp3//+93nnnXdq5+Zrr73GysoK3/zmN7l//z7GGFZWVrh16xbXrl1jf3+ff/iHf+B3f/d3efbZZ+s1LYqCoihq0FmpCRiryNXm47NiXc8CYWfFrFaOyQpWNq+fqke02XO5DBGfNtbP0y8bF1uN03zt02Dlx+m/rPbfwsNWrVq1atWqVatWrf7zNbj6LJM775dxpTJELgJXnRR477C+xH6wcMGJBdyrtfj//gJVOg9q4bgEj9aeKAxwAnScEEiJsB7vHTqMwBcI60t7nndY58oOTOEgLPfkvC+dljhUFOKcwQm/6Ji0ZRQsAuds6Y40HhlFYAwucCiRlPAuz/DO47wv4WKgQJZQVMgQpT0qjAjCBKU083S6+JvB4kOoYYCaCooiR6mqH1OAt0BlEyyBq8lTVBEuHHKu7BtUZUCuDAPERGPynCBMiAer5EJQDI8RwhMONkBHYC1mMsU6jxMFMs8p5hOEFFjrUCpC6wBLjlSqBILGoJAY65jMy/mHcQ8pNaPJCC8E1np63S7rG+t84uWE1ffeZf/xbaYP72LOXWLwv72IzXOikw/ojo+JhAQFOE+aFxyeFDweWtLCk2SaoHCs767yB198la0rz5FlBQ/uvcu0+B690wkvv3wTqUK8t4Sm4MVnXyKyhg/+v7/G7B+gi/Ke73AWMLOSY+M5shkjn7MxCPm/X9zldy5tI13BwaP7jE7GmNRgc0hzDV5x/lzAzoUBXsFsNkJqzc76HnmRMp1OkVIShQnzyYy5GBIg6a+vEHY6FLlhMjwC51BCIindvkoprCqLLgUCISnPN6Xz1lsPyqMCTRCEZfejlItuTI9xlmyekcxztIoW98IepQM6nYT7D/dZGyeY+Bghrpc9p2WuMYhyPJdZxqMR+4ePGQ6nGCp3s3/iHdi6I1u1atWqVatWrX69+tigEniir6+COqurq2WpuFJsbGxgTJnbv729TZIkJElClmW1c+/cuXOsr68zGo04OTnh+PiYvb091tfXOT4+5vbt23X86traGtPplPfff59Hjx7VkClJkho65nleg8/pdMrly5f5zGc+w927d+vI0woODofDGow2eyihdAUGQVBH0Xa73brbsdPpMBwO6zllWYbWGiklaZqSpmndUWmtrcHnc889V8fbVl2RaZoipaTb7XLlyhUuXrzIeDzmvffeA+Bf//Vf8d4zmUx46623ePXVV1lbW+Pg4IC1tTX29/d56aWXWFtbq12pzjl2dnbY3t7m7t27DIdDHj58iHOOixcvcvXq1fo85XnOn/7pn3Lv3j329vbq+Ng4jmsAXPVgjkYjhsMhQRDwwx/+kNu3b/OJT3yCwWDAt771Lb71rW9x/fp1fvjDH/KJT3yCnZ0d3n77bSaTCUopTk5OePPNN7ly5QqXL19+Ip61iu7VWj/R2dmMYK26LZuQsXr8tJ7JCqQ3t4WPoF/12kpNINl0QS4/buppkG8ZJp6lZtztz3NUVj8vf/08/aLxsR8Hcn4cPW1dfhmI+5ua6y8y9m9zLq1atWrVqlWrVq3+a2vnE5/BpxOmHz4AVyCEhAUUdK4o4z4X2wrcohlPLxyKFaQsYabCLyClKN2VCMJAEAaOydEpq7vrhP01FBJb5MhIo+IEYQy+MDjj8M4itEJoDXFUdlCmeelQVBJvHWYyxxUSHQUovYCN0oP1OFfm1QqvoP7wqMTbHO8dIHGFQanyvg5vy+5BIZBao8IArRWdTpfTo31C4bHeIrQseyeVYH56QqC3kGFYRswKjZQBQoVIofG2XLtynPJ4ZKhwNkd4jwxCVBRRzGc4Z1BhRLK+Reod+dERWEe0vo2My/tc4SwuNbhiTppOy/tEb1E6xOYhxjikDpFhgFQCLxVRnDCdzumEMWmeE+iyygZnODx+xGQasbmxRSeJubR3GaEt+bxAzB6Rv3fEaLBOcf46vtclmRyxmc0IpaCwOXtFyt0P73N0NGEwhd4k4MrzL/Dczf+djb1nSLOUla3z5Cph//gxL734AklvAxVGfO9b/y8i6XHh0rOo04fc/+bXwQhcIfDegI+QOGLl2dvo8tonr3BtY8DwZJ+D/X2mpxnGlpGrJpcksWBvJ2F1YwUnLfN8hhSCWEfEYUIgY+azOePJEIEBV1AMDf2tbaJeDxGFpMenpPMpnXilPM++uqhLQOmdg0DgnS29i4IywtcaoITRodKoIERkGcIZsBrpJcJbXGGx6QzvBTIIEYEkjjok0jG6u0+yQznGAoh7YUr2DWSmYDKe8fjxAWlu6/ftr/sOr4WfrVq1atWqVatWT+pX6qisYFwFVyrQVEG/KIpquDQYDGqAOwoJmgAAIABJREFUeeHCBbIsqyGec45Lly4xHo/x3rO2toYQgiRJasi1ubnJ6uoqSZLw4MED0jQliqI6DtZaW94YQA3XBoMBH3zwAfP5nMPDQ6bT8qajAotV92KWZbWrL45jsixjOp2Spmnt+Ky6NoUQHB4ecuvWLQ4ODvjggw+4fPlyPWYcx3X8avW90nA4rJ/XWj8BFquY2DRNmUwmDIdDXnjhBVZWVsiyjFdffZULFy4QxzF7e3u8//77jMdjpJS8+OKLZFlWjzebzej3+7z00kt897vf5eDggPfff5+bN29y48YNbt++zT/90z8xn8/p9XqEYUie5090iVZdk02QVzlPjTHcuXMHay3j8ZgsywDqDlAoweDOzg57e3u1S/XKlSv8yZ/8CZcvX37CDVtF+FbnroKXlcuxin2t4GMVJ1zNqZpj5X5sRsgaY55wUVbXXOXmbMLBJiR8mmPzLGi4/POyzoqdrSDpcrzsz+p2bO7jrLjXn+WMXD6Gp8XFNvdRrfcvq+a+z+r3PGv7p7lBfx6I/a8ELFu1atWqVatWrVq1WtbKtedIT49JT0eYSQoqAgnWVq4tj8TjsAhACQ84BIpFlulCvoYbbhFGKfAEoSMJDc54oiAonZNSobRA6jJq1mkPOsQVBcIJUAq0QIcKlMYEpVNNBho7HjG69yGr22uIVOBVgEwCgs4AGcQ468BYzCwjy+boJAbpSnBpBR6HCBbQkBCpyhxNpzMQGhnF6G5GlwHpeII3GcIWOGOg8EgZoFVElqXoMMT7olyPMEAsejO9KHsqA1PgrUNojfcCfIC3Hq8cMooReUGRz0onXxwTra8jpKQYn+KcJ1gZoLsr5XpEId6ZsmPTWITzuDTFTmY4X2LiDIcFkOAlCOXQQUAcBGR5SjeOGc+GxHHCPBuzv2/pJV16/QFJZw2pp2gv2Ouv4Rx8cOfHHKkYc/0FxivnOC/mrBZzeiYniTs8Xj8gyzNWHx6xcmGdzZ3zbF24SJYbOmub5MYgf/omP/3pewhus762zjQtKICkv8K5Vz7D4d9/nSSCdA5+7OgIgw0FNy9t8ur188Q+54P33mH//piicMRxSBBFRLGl103oDboESYC1OWmW0on7+EhgXY51Bh1qojBgko0JhcLlhtlMcu5ygogjjCmYzUfl34qiCCnLa66MJZZYY8A7vNFgS0gphMArgXce6R1SKYIwQccRbp4ihAdfLJy/gFDYzJb8P9AIERCEkkGvx+PjI3pqndxOCFQX23hPOQ/ZdM7R6SEHRycY+5u8v2tRZatWrVq1atWqVVO/UkclfORUa341YzQrUFm9pglmKhBSucq63e4T8Zbr6+tsbm7WUCnLMqSUbG5u1rDn0aNHOOfo9/s8++yz9Ho9pJSEYcizzz6LMYb5fM6lS5e4fPkya2trWGvZ3NysXZhRFD3RSbi+vl73LPb7fcIwJE1TkiThypUrvPnmmzXMnE6nPP/884zH4zoyNAzD+mcpJVpr+v0+P/nJT1hfX0cIwd27d7l8+TJaa6bTKXme1xArjmM2NzdZW1vj5s2brKysMBqNKIoCIQTPP/88f/VXf8Xt27f5/d//fTY3NymKol7jCjZWLtYf/vCHPHz4kM9+9rM45/jBD37AdDrlS1/6Uh0zG4ZhDfa89+R5XoO9qqNzMpnUnaCj0YjZbMbx8THj8Zjd3V2eeeYZbty4wenpKa+//jr/+I//yIULF/jc5z7HM888Q6fT4ZVXXgGoXacV2NZa17D2rJjV6rqo1rU6/9Xrll9TRfpWa1odVxNANiFYdQ0ud1EuOxerc1pdu2e5L3+WzgKGy2DvrO7J5W2b8/w4sHJ5uzb6tVWr/3/o8kDy0//n//xtT6PVx9C3v/1tAF599dXf6jxatWrVqtV/ruKdHVauPs/88DHjn/4Un+U46/BeLRClwHhK6CgNsvSlIRY9kmXAa9kZWf4rJRaoMgw8kQLR76PCCBVGCB2gQo1OQmQgytpLqUpXZZqD98hQI225Fx0FIGNsnjE/GdFd6dNdXaGYTbHelK7MUAMFSnnQoIIQmXrCbg8vPXiDkEE520VEKx68B+E93oCQDrxFRiGBg9XdTUaPDsA68A4ZKshKV+l8MiKOE1QUlkcqQIgymFMgkUKVMbPWIbxDCIUIJM5YpIggjNCxoRhnmDxD6gAVRcQbW3hbkI5OKbIZQT9FdXuIMEIEGoHEinwBJwMQduEgdeA15DmWgtSkGBSj0QkCRaAiunHMbDanoxOMLUHcvMhQ6RjhLb24z/D0hCz2rK2tcEUKVkanuPs/IV/dZn/9HIeDVVbzlLWoS98b+kWB9wVhp6DX7dJNukSJQ2jFzrk9Prx/l0ePHiKU5OHBMSsb2+Q2xQtBZ30LpWHQk6wMAg5WNE53uNIL+czFLYrJiHfef8j+vqXbj7lypcfaxgpaB4DDeYczBYXJyNIpWkjWB5vM05ST0ZzT0xPW19YRCqSz5IVldAqdOEAnCUJL8knGPJsgtUbroHTfelNWiSqJF37RqepRfhH3ikcI8NjSZSw1SkqCKCHQU0zmyEWKc4ZeT5DPp0ilCbsJJeQvE2I7SYdiMsKlEU4eEchueU2KBSQtDNPpiKPTQ4ajcd1N6X8DAPE3MUarVq2erva+uVWrVq3+6+ljg8qzwMxZwGXZLVaBtGbspvee6XRaOxKtLSM3lFK1O9M5x3w+5+DggAcPHtTRsRcuXCAIAjqdDuvr6zWkM8aws7PD5uZm3ZVYAbjV1VUAut0ug8GAmzdvkmUZq6uraK351Kc+VcPOCiACZFnGJz/5SbTWvPPOO6ysrPDFL36Rc+fOkaYp29vb9VpEUVRHvEop+cIXvsD3v/993njjDVZXV0nTlDiOAQiCgCRJahgaxzE3b97kBz/4AScnJ+zt7fHuu+8yGAz40pe+xGAwYGtri4ODA/b29mpoVxRFvb55njMYDFhfX+e73/0u165d4+LFiwyHQ6y1NQSuejc3NzfrfVRrWLksK1XnpeqT1Frz2muvEYYhnU6H/f19BoMBX/nKV3jttde4f/8+f/Znf8brr7/OhQsXUEpxcHDAYDB4wm1aAeMKQFbHU8HGJiRsuifPikltXnfVfM9yPeZ5Xh9XNf6yY7P6asbTVutb7W/5uZ+nZRfe8vuoutaXf39W1OtyX2XzWJ829sd1LrZq1apVq1atWrVq1eqXV7C+Rv/KFVwxhzxl/M47mDzHeYGz4LzHI1HCIUTpmpTV/9cFCOHLXj1ECSsX/213i9bKTi9Axz26vZju9jmiuIfQEVIK0BrHHFeM8dax/8593n/vEbu7CXtXr6LDBCc90iuccLhZiplmDC7sIKMAkeW4bIaZG1RSuhRxpozklI5otYvUGpSAUJfdlxa8tWXUJh7vDF5IkLqErFIjpIFAEvU79Mwq+WRGOp0S6ggznSN1QBxFpJMpnSAo3XeOEkYqhbcfJdR4ZxAiQkiPV7Ls9xQeGShkFCLTCJ/n2DxDSIFKOiTbFxCHj5hPT5kfPYJZRNBbIUxWSiemDtFhWLo8vcflBqxHSoEMQ4w1YCSFscznk/K4nUNREOiAIFQMRJfD40M2VlYwpsApC1KiQ8H+4YeEWhNFIZ0kJIm6DFYTCj/i4f4+d43mwfoWnQs36U8PWQkj8qMH6HxINp0SrwxI4ojV9XX6gz5xEpd/t1ASITzz+Yw0m8DRPlkGEzqIC88QCMWnpGMvgsP79zh8OCIIYm6+tMnmuVWME3x4/5hQFpw/v1sCSlugRMhav0s6HRJGIabIURLSYsJ4ArYwdDprpOmEk+Gc3QsrBJ0E5zx5NscYi5YhWki8cwinyvhjX5RuW+twWKQs6yNZxBrjFs5hJVBSE4UdhFBl/K63WG+YzUYEStMZrKKURuqgPM86ohslcLjPvX/5Cdsv9Yj0uYVJ2SGExBQ54+mUo6NjxtO0hJS+9Tm2atWqVatWrVr9NvSxQWUzZrPprqzgzVlqxnlWzrgqDnZlZaXuQjTGEIZhHYVaFAVRFNHr9VhZWWF7exvnHJ1Op96uih+tIFrlDozjGOccR0dH9Ho9giAgDEPCMGQ+nzMej4miiDiOKYoCpRQXL16s+xubsaMV5PnUpz7FK6+8UgOz+XzOzs4OW1tbxHFMmqb1vCr4t7W1xR/8wR/U7sy//uu/rmNUX3jhBXZ3d+vo2tlsxqc//Wm63S7vvvsub731Fuvr69y6dYsoigBYWVnhpZde4urVqwgh6p7NLMuIoqgGrDdv3uTOnTtcunSJwWBAv9/n6tWrfOc73+H27dusra0xHo/Z2toiz/MaziqlePHFF/n617/On//5n+O9591332VnZwetNS+88AJ/8zd/w7e//W2uX7/O3bt3ybKMfr/P6ekpt27dIkkSVlZWGAwGSCl57733+MY3vsGrr77KJz/5yRomOufI8xxjzBNwsbo+KsDWdFGe5WisXgels7Q6n9U11wSeyz2JlaNy2bW4DCs/7nul2t/y88vzaIL8p+ks2PmL9GG2atWqVatWrVq1atXqNyuddOnuXkAZKE5OyY6PMPv7CxZjQPhF36RHwgI/ijrc1XmQSCwW5z2uqqoAtLRcuLLH3gufJvYKLTVeKIQRCMp7J+9ShJLk6ZTjB4e8+8Epq10w8ylBFCNxCBVipiOyoxOSjVWCJCl7KQOBMLoERrZAqAipQghDUK78WZUY1VuHtx6pBb5QeFfURwSUYMl5BAohQ1SosFYQr67hLWSTMeFaTLS+hhyPyYuUdJYS9gqUd6BChAwQXkIFbL0vo2196aIUunwO6xChRkYhKulinceaHFEopHbIMCTe3AIlmZ0eUUynGJth5nOC7jqqE6F0gAw0IBBKgl1AZAMikOgMtPIIMWc8HZIXOXY2Lv82IR0qSJBJjEXRDTrkVuCtYZalGOf54IP7PHf9KkGQUDhLOpuzur1LHGr0vbtMHxwzjfo8Wt3G724T2ZTDu++ys7FHdlIQ91fodNcY9NdIkg6FtUjvEaL8O8Zw+JgH3/9npnsvova2WTNzXu4qomzMwYf3yGaOa88/Q5wkTPMp77z3iNOR5fz5NfauXCQIA/R0hikc3aiL0jCfjPGivD5lEII0WCvodFcQWnP/wyFCS9a2VxFRSJ5mzGdTnAMZKqQKQArwtnQTO7dw3ZYJSAiDDoPyjSMkoBfnW6ICSaBDlPJ4n5VpS95hPbiqLzUqu0m9AOkkQRgQe/jwvXusXL2B73ikkHinwIMxBel0zmg8ISvsf3BTVnfWLbhs1apVq1atWrX69etjg0o4u4sOStiy3F8JPAF7ll1iTZdlFdVZfQ/DsO60DIKAwWCAEGXXozHmiR7CCoZWYKuCnNWY1ThKKYIgqGFYFTs6n8+fAK9RFNURqBU0m8/ndLvdev8VyKogXwXfKkCllOJHP/oRt2/fZnd3l/F4zGQyYWdnB6UUu7u7bG1tPdFV6b3nk5/8JDdu3MBay8rKClEUMRwOOT095eDggBs3btDtdhmPx3XnZhiG9XdrLc888wx/9Ed/RK/XI01TpJQ899xzaK2ZzWbs7e1hjKmh3q1bt9jZ2SEIAm7dusVoNGI6naKU4nOf+1ztpLx27Rp/+Id/yL//+7/z9ttv0+v1uH79OufOnePhw4d8/etfxznH5uYmL7/8cg1PJ5MJaZrWEarV2jZdtE3YVsHJ6udqm6rbtAkYm9dXdS01r8MmSG+Os+zibLojm07g5jVf/W553J/3Xmk+flrMa1NP63hcdkf+IoDyaZGyrVq1atWqVatWrVq1+vVISEEwGKDOS9YnI+ZHB+SjEXaeYZ3A+kWv4yLSlMUjuQBxSgi8+MjpJYRYgBPH5mbECzdeoEMH4R3eOMCAcfhAYGWG8AUmzcgfH+OcZ2sDdrbXEIFGdWNEKDHDGdP7+4hA0t1ZL8Gkc4j63sjjzcLVGGhEIBcxqb4EqoueQKRDWI/XDmdFWeQI4EwJqYQvoz9FgPW2jHrFkayvMNzfZz6foEVIPk8BR7SakM9nRGwAIIVDaAHWlY5UZ/FeldGxtgBkCdKcQ+JRQYCPQ1weUtYaFlg5Q6suMooWkNTB6JR8XjDLjwkLS5B30XGHoBMjpETKACct4FGBQjqBCQS6KIikwicDTjkltSkDHSBSh7dzBiIiT2cYX2CRhCpAIOn3O5wenZLbgiAIAcFsfEqoBGGvz9b6Bmt5QdyNeffuvzMUMae9Pm+99zZ3JlNWti7QWVtnZW2H1cEKSRCSRRFu4Ty11vHg3nuYjqa7knD8T2/SCQyP1iSxtoQ6ZG29x2g04+6DhxTe0Uk6fPITl+mvrZXOUeconCCdTejFnRIo4sjSOQhH4CVB0CHuDiisZTSZ8OjAcGGjR3dlgLOWdDJmlk3xNieQg9L1uuj7xFeQUgAaY1ICHYK1+MKBFggpcM4gnEAKSRhGhGGEsAJrZngZYC0luFaqNGG6AiGCxf2/ZtDtYScH2HxUXtMyxFPgvaQoCqbZlPF0jLFuQSQ/6o5sAWWrVq1atWrVqtVvTr9SR2UFOpowqemoFELUwHG5t7LqFqxgSwUbK1dltc8KcFVxrmdFylZwrwJXeZ7X88nznE6nU7szq9dNp9MaMlX9l1XMaQU/oyhCCPFEhGsFOsfjMd57er1e7QSsxg2CgNlsVjs+hRDs7OyQ5znT6ZRut1v3Nhpj6ojVak5BEJBlWQ1nK+dlNd8PP/wQKSWXL19mNpthjKnBm1KKLMvQWtcA8uLFi2itmUwmtfP01q1bALXDdDQaEYYht27dqh2q3W6XL37xi0wmkzqSdjwe1+fxxRdf5MaNGxwfH7O5uQlAp9Nhe3uboihI05SNjY16Xa9du8bXvvY1NjY2aghdncMKrDZBYfU7a20NbyvVUT8LAFmB2qZLswkmK6BZbVedzybsqyJgm1HFy67KpjvyaZGsy2rC0+ZzyxHJy/Cxeo8tv7a5BsudlT9LZwHKFlS2atWqVatWrVq1avXrk1AapTR6rU/vwiU2X3iZ9PARo3feB1PAwjmphEMKsE6U/ZSUXxIocZ5AIcCXoa9BKLjxynX6ySre2jLy1FpwFodH6BjkHJd78uGE2cmQ+/dHuBBs7hBW4G1BfjhjfPc+0fYanc0NMBZnDT7LETpAyLR0V6oAhCz7/ZwHI0s3pZAlRZVlNKun7JGUhEAJplC6jPT0CwgkKIElAiEkMlD01leZHg8J+wnJoI+zDptnFD5FWAdaU1omNWUYrlh0VBpwUQlxpUAgyz5J60BKhJKoKMCbAltYMAWqKBA6QnV6xF4hgwBxso8rcow/xbopgenj7Qo66eADiVQVDBNIA0pqhALK1SYJIybWMjc5cdQhDBOkA2E9qTVYY5gLSZx0CZRmsLHK8fiQtf4KCIGTlul0WPZCCocxOaEasLu+wraVPDr+kAfv/4gHJubgwjWiq9c5mReoKIZsTreTYMxHf4eZPrqP+pfvEmcTNlOJNSFDGeJiidWWohjTX+mxt3WROIoIhKDXXyvvs4WmyFJGx49w6RyJLLtFpWc+OibSitX+KkEYMcsLRrMTPrgzJpsZdl/aQkaaosiYz0cU2QQpQqIwQQoJBpBldCtCgCg7Sa31+ECX0FEHCC1xRbYAmgIVRgRRUMbb+gLrwWQFPvDoQKEDvTj/pWOzfJ8YBmFMbCFLJzifY5B44UqHr3FkRU6apnjny2LYlk62atWqVatWrVr9VvSxQeUyxKlAUtX9V8VrVl+Va66K7WxGdjYdkFmWEQRl3EcFm5bBVRNmVUCuglMV0AzD8InI0Go/xhiCIKghUAVNK5BauSibwLQap4Kmza7N6nEVMVpBzuYxeu9ZX1+vI2vzPH9izOa6VcdZ7beCuNWaVi7J8+fPs7m5idb6P0C8alulFM45gqD8RGEcxwghKIqiBneVy7Jar8rlWMW/Vr+vwGIURU8AvjiOieMYKctPJBZFQZIkRFHEyspKHb2rlKLT6ZAkSQ0Tm+d0Op0+0U9aHVN1bptgu7lO1XXQdGQ2r6cmYK7OZ/OaPKufcvmarLZrwsTl6Nnq2mnOsRqrWuvlOTeP/yzn5LKztHpcXTfNa3gZrp6l5Vjb6vsybF12SjfHbr7ml9HP2r455/8K4PSs+fxXmFerVq1atWrVqlWr//Wkqg9D6oB4c4vexcsMnnuRdDgkvz9DCIcSBilACoETHi883oFEoASLjsqS61SBlOubA65ef6687ywyXJlbibdZGYXqHN7nmCwjn4wZHw95fJpx9VKMzXKc9Zg0Y3jvAcnGCv0rFxEe3CzDe4NQEpmEaNtZgE+NKzK8K+NQkTlSBSXkw4OUIMpOShFEsOgCxHpAgzeLFZFlqqdSCB+UsNHl4CRSKEbHjwmiLso7pFZoEZYQ0nnAIeSiWqO653F+ETtrQUiEVIthSigqFr2SIpsjrMJ7h7UFygcgBLqbIKOgdIaOh6TpDJvmWDEjM+CdIOypMlLXe7wqgZq0DiRoKfASuqJLYSzpfM4szwiiDjoQSBmDLZi7jMI7jDUU2QThJRNj6QYd4m5EOssJex3wgtl0hI46GJPibI7xkq21daJQcPfRQ05/+k9MJgfo65+mMIZQwvnLl8gKgxQS5ywuEDzOHN55Njdge73DSrdLv9un2+shtMBbSPM5xnryIoVeCU1xljydkc1ThIzLWFybI1WE0jFBN0aHCcZaJrMRjx+O+OADwbl1xerWCiAp5pZ5nmGtJ4gidFCCbucM0i8cwtYu+kYdUGBtBsSL2Fe5uODLPkkkOGtxziOtx7iCIgchTenUFBaHQPgFqBSi7ASVglgJ8mxYui1VWDt9rXcUhWGeFzj/0SXVqlWrVq1atWrV6jevXyn6FXgC0jQhUAX4znLBNSFmEyI24zebkKRyFFYRnRWUqoBJ9Rh4otOwUhNiNaNAK7AWBEENUJsgZxn6VMCwCUubEKcJwyrYWkWqNoFunud1bGzz2Ju9n3EcPzF2URT1GJ1Oh36//4Tzrvn76rmmo7ByHTbnVsGpZnzq0yJ8q+Ov9ldtXxRF/XMFjas1rxy1TRVFUUPHar5VBO9ZUabNa2r5/DTnvHyumm7Ms8Di8ljVcTUje5v9q02dBR+r55sQsrn9svux+brl7ZrHsPz7s8b5ZZ2Vy2o6oJeh5TLQ/GX1vzrg+7jH3apVq1atWrVq1aoVQKDD0onnJbITE21vs3L1ObLhEfPTA2Q+QUlQIgA81gvwAiE8wpeNlZXNqwqllNJz+Zkd+nEHjAHjsa5AKIVLc4gF3s6x+ZRiOGJ2fMqj+2OU9Fw4t4b3ILQgG46Znw4ZbG/iRnNkJ0GEAVppnE6xWQ6eBViyZMMUU5QfBA2iECSouItUAhlGCC0RIiihofMg3GLmZhHzCaLulFS4xX2/8BqhDNY6hscn6DBna3cHIXzpEhUOj8NX97o4cAYtJN6axVilu1MIgZOyNG4qiSTES1BBB1dMcN5g7ByRKmQUQahRcYdk6xwq6qJOD5nNR9i0wAcTCqnwPkdFMTqMkUGEEB6vSperkyCTmEhposKQ5wYnHBaPsOCMLV1+wmOKDFtkWDMj0F0EjnE6ZbCxQWIt08mYXtwlDLuMZ1MSFdKNuhxNR3SDDomO2F0fEKgJxs65c3rC2DikK7j7+BFpkeOLAg0kJyM4MfRWIQoESSfBGoMvLHFcwufc50gZkKcTismIXreHx1NYS5pOSHorKCUxwoOOSIIyKWk0z7DjEdPpkP0Pp9x9FIIXnN9NCDsdTJYznU+Zz2Y4A0E/QgbBwiLcvH+3WOthEe2KcCXTFrY8l1LgvQBXlE5Z6cEZbJ6TZY489RRpRpY7wjQHoZFKIvWis1JodBAwSLrMbY5AIGVQvqOsxzqHdQ5jbQn6F2HGrVq1atWqVatWrX7z+tigchn0LLvClgFPEyo1wVgFuqrXNZ1uFWCqYFazz7Dp4qzGbQLOPM//Q9RlE0guj9E8nub8m5CrckIug7bqNWeBpcoRWB1HBTir42wCt6bzTylVj1fFokIZ1TqdTp9wUjb30wR6TVdhtTbLc6zWotrfckxq01XYPG/LMKsJpiso2oSk1fNNwNs8b1W35jJUbF5fzV7J5rotX2NNgLx8XpvnaXn+Z0HCau7N55bn3lyPZTfjslPxF4VeP2+7aj2awL9yWv6yWn5PVtdh6yZs1apVq1atWrVq1epXlKAEbpT3Frrfo3f+Etn4lMnBQ9LZm8jco6SnAiVCOLwrHYrOL+5J/eL+BEGvq7h0+SIiz7CmwOHBWfx8DjhU2MGZEcV4Sj6aMjk+4fA0Y2OrS6AEca+PjiKGHz7EFwX5ZAoyIMAjA4XQYekElBpnPXZeYOYz8vGcbD7EO4cKNDrpEnYzgiRGOZBKg/JlH6Wz5bErjfe2hK9e4lyOlBovJNhFtYsUICBZ6fPowwOOHxwihaHT6ZH0O3hnAY1QCqEkOohxIsMLBcLhMCjnyrVTAdLZBSy1CyirEJFG2ghXCHDgCovQFpF7XFAed9jvIbVGDANmk0Oscdi8oHyBQHiFQGKdQ4SLdRIB3uXgPJ1OF+sN3nmsdUilccLWjYfOpBiT4p1ESEkYd0jTKfuP7tHp9imsZTw5JUxirM1Ji5TByhphnmFFCVuFGNJJAtJsRjA+ohP2OZpNeTxP6a+uMjx6hD94xPlRjioUTkDhwBiPLTJyNScvivJvJllOkWcEUhMOVjGFK6tGEXSTPsSAUDhX4LwktylpOiOdz8hmE04eG/YPQmZFxPZqztbuOkIK0smU6XyEMQatArQOkUIipAYlSweltaXzU/gSylexvq50dMpAY11ZzloyxDISuXxPOGYzj3IC6x1pOkeNIM4NOopQYYAMQggkYRTRD2NyD85bnDPgS1ew8778srZFlK1atWrVqlWrVr9l/cqgsgIbZ7nGzgJDzWjW6nHTIQkfObwq8NKMSm06AJfhaBWsWdoiAAAgAElEQVSDCTwBB5vdks3+wjiOa9hT9TlWka/VcS3H0lYAr5rnMjBbBnjNY2uuRROANV181XpUX2EYEoYhaZo+ASvDMHzC8RcEwROPq3Ga3Z7VNs25NNdzOVJ0GeA2z/3yMVduxOW43mXnbBNUVi7ZCpY2oV/TRdkEhVWc7c8ClU3gdtYaN9dn+fiWQWhzH03nbnPb5fN+1hjL2zfHeJqe9ruz3KRnHcsvquV1Wz6uVq1atWrVqlWrVq1afTyJRdukx2G8A62ItzZZz2+Qnw7Jjk6ZP3iI92BcGV8JHlGa8FBU0a/llxCeC3tbDCJNenKAZOEclApvcvRKH+NmeDvG5AXzyZzRacrMCi6uBfjCEgQxrrCMj0+Io5Dp40NcYbF5HxmFBN0EBLg0x8xSimmGSedYm+Oso8hniEIQ2AKsxecOnTtUJ0EoiY8kAo/wEqzDe4PQAR5L6Ye0lLcZZaSst24BdGFtc5WHD0bMZxmrWztILRcO00X3pPc4Z/FYPBohy9jWsqOS0n3pq75BgRAOAoVwATI0JSCztgSmBXgZUfpWBQQKHfToKIUUinR8SpFNMEaBW9zTAV5LhAjLc6MCnFPIAGLRXdSn5HhvsL6gcBYhI5wv8M6BNTiTYaUg6q4RdLsYkzIfWUIVkk2mpNMhUsBodExeZDjhyKxHCYV1kJmM+cTQZZ+NZy+wsbuBPhoSr27Q8YKTRx+iNteQB2OEE/hCo6Un7vUIux3yYg5OoJUk6HQRKkAIj9QKL8CnBiHB2gLjHJkxpMWc+WyESTOKyZzhacFoGJLagEh5rl3ps7a9iTGG6XxGmk7weFQYEEq9gMYGfFDCR1/WiDpblGASkELV59o7DzIAn4MvYab3ZcSv8w6XO5wTTMczpHyINQOsWSHMUsIoRiqN7vUIgpBeGHBS5GXLq1A4XBmvTNlVWfp1K79yq1atWrVq1apVq9+GfiVQuexaawKU5nNnRVU2QVATjMFH/ZYVKKv6G8MwfKLjslK1jyqqtDm3Ku61ek0VPdoEXk0XYTOatumgq1yJzT7DZRh71rE3j7GKem1uV43XjJBtgqcmYK1gpda6fk0FIZudms155Xlex8I2QWUzErU63mUXaTW/5YjUs3pDm65Ea20dL9uEfNW5rNa+uc7Nc7oMn38e8GteV83vy/Nrvvas+S9D96aajtHl6+As9+ZZ8/11Qr+PCykrLTtDn+YQbdWqVatWrVq1atWq1S8hKRAonCuddgiFSmKS7W36z1xjsH+PbDQkG46xzkGJHnHeA7KsWix3UyZnSsn5vXO4+ZTcjNHKlT2OKgJtKeZF6Sg0lmKeMh3+T/bepNeSJD3Tez4b3M9wh5gzIiuTmZUs1iCxqptsNSUCjQYpCpDU7I2G1g/Qr9AP0EJr7bTTToAECCAENrSipAbRbIrdHEpEFali15hzZEbEnc7xwcw+LcztpIXXiRyLLIH0F7hxTxwfbLyB8Puc9/0+ZL/vOD2xnG5WWNdgnSF2e4b9wN17jxgun9JfXKIJrGsJVztUI3GMhG5PGIcMBzWTU99sIGUXWhp6AkBK2fXmhJQi1jUZEkKGhuOYnZOAUUEwGNOS4h6MYqwlmcjprS0vPbrF04sbNh8+Yb31tKdnB+Cbsa1ipJR0yfGgKUZssiRN+Qwx2c2ZAmjCOId6DyEgE9SNY0Rs/spkOLfgVi3rO3exjae/eMI47Ij9JUEDGkd8s0aUXA8z7HPdQxGsixnERUWjkELEihKJqEbUZOBGMhmNicE7jzhPipG2aRFx9OEGjWMGcdfXqEkMQ0BiIuyvGPcj443S7H+M32754fmX2Hcjv/LvfpMfNZ7QXXH28BH+T/6IX3ntVe7fvsWqaXDeMqXiImkiw6Y8b+f4XFVBsRPnVbrrC677PePuhtDtiF1gfx3o94Y+NBiBV+5HXv/yQ6z33Nxc0YU9KQWsNXi3yi5Vydm/mgJqDDGRnaViMngMgWRdrlmqCWMECYoy/V4CEOPQIKCwWjn6MRI0EsdAijnJKpm8t9X53O5mxaY5xQdHUsmOTZXJpZv3jsGwQMpFixYtWrRo0aKfr75Qjcpj0a9zAFQAT13Tr4AqETlEutZgsMC34nacw7U68rJAs3Ecn3Ni1kCwBmsFZtaxqSU203v/nHOxjLHUsix1I8v5JSp1XuNvPj8FLNa1OUvfa0dpAarAIbo2hHAYSwGNxSVZ3JBlfkvfilOx9KfA22Oxp/V8lnvV4yhjm9derO//ItBYvy61KscpZqYGhsXJWdezrI/PAW7pbz33c+fmHDSX7/X+fBFML/c5Ng/za465EOdg9/MAymOwtKh2FtdzNIexn1b1HjjW/uKqXLRo0aJFixYtWrTo80kwqEzPFgaMsxjxcCqsX3rE2S9+jZv336e7+g6SFIsSVA9xoYoi098MgnNCd/U2N85ysm6xfoVbC+LLFQFUGfYD+8sLustrjEm89PIpJycnmBgRbxl3HcZ6XLtCVxuGbkfsbtAmkvaRMI6EOBDHjhgTMUWM8zjjcQZQSxwHQkoTRbWwd9jGYTDEVH0AEgNe0ZCjYJMxEEZQOTgfNSNCTNPw4JU7fOdPr/nw8RO+tH0ZtWZqYyp0qRbEZ+iWplhZEVIcMc6jIojkZ0wxNjs6jWCcJTUNabfLDk3jQQ3aBbSZnjuNQ4zFbbeI8xi3xl68z7jfkfYdpAzHjMlrK9aCHzGODGqNw6+ENJJhaRQ0BNCIanZuirWoOlIYEWex4nAGhIixFi8NERAxGLEM4x7rPFEHXOvZjIm4GkgR7Hs/Yd3eI+4C3/6D3+edt9+EsGf1Ts/LYcfdO1/m9t2701wIaRwyMLeGxJRCBROoNZAUxaIpkEbY7ffsLh+jYUQHZdxH4mgYgyUly0ungW984xHbs1O6fs/17hndfo/Bg4k457HGYGyDqKARUgqkNNVVVXKUMBZweY1T3k9qAqKSgTCSHZUpMQTFrwS8Aw3Tz8mYfbFTGyqBsO/wK09rLavOQZyiXjXlOqdYjHHY8nuAv5l/EhYtWrRo0aJFixYd0RdyVL5INRScR3jWMayllmGBV7WbrY4RbZrmAOAgOwPnkKyOOK0jTOEj8FRg5DiOh2jYuq0aZJW+WWsPEBA+iv+sXXUFDJZ5mbv4CkiqXZvFoVkiZ+c1LOso1xI5O5/Duq7kHMrO3aT7/f65tatBZelvgaJ1rc/6vLlzcr4WZU6GYfipqNUyv2UN5mCvOCxrqFzaLWC7XF+vWz3PNUAsfZ/DvmOwdg4Fj0Xf1u+VuSrjnbsr5/pZOxNreDp3P34RqFiPtYaUn7f25aJFixYtWrRo0aJFf9cVdcSqPzzHJUIGWt7gTk/ZPPoSZ1/9OvuLx+x/8h4pZiw5PcmWUFJKHKyGQMsNm8092vUKv91iGpsBGyk7y/qe0Hd0V5ekDppNw+37t7HWkBK4Tcvuw6es1k2GYd5h+uzmTCERxoFxGEjaE2JAU8SZVX7u0ASSa0VKBI2ROPTZmWYs4jySIBfXTOByjUqJmTEaBTTm8RiXazyamOtPmoARoWks7drx7GrP+dUld2JEY8rAyjCZTqdnQAHV8oFbprqYFshRo8IUJSoK0/OdsZ6kPUokqUH8RzVANQ75PGOxKw9sULmLGiHtO2KIIANiexKCtC2SQJPN13hH0h7xLdiEjIaUFG89Ig4xJsfWakJMniMjica1KEpKYEyDENAEyIimnpQmiBgtMY5oyqVT2G75Squ85Fv+9J13ePbeO8Sup0sjd2zINTZTwrQOjQElgeY4XhWb95bJYFfJABMUwRHZsdtdEPo9VoU4wDAmuqnO5/2znl/8pfvcefklkib6rmff9Yxjjyg0TTs9KwsYzcAeSEFIMeU9MrknkwZgRIyZFlIPC6qqU2Rvdk72Q677eX73HOcs3rlc97QeSxwJaY8ZNtiVp+0Cqe+RJpEQVCHKCJbJ6btEvy5atGjRokWLFv089blBZYGGBSzV9QbLQ1gBHDWELNfVtSQLFOm67gBJCpyaR3HWsbA16BQR2rYlpUTXdXjvn4t47fseYwxt22KMYRgGmqahbVv2+z0hBO7cuXPoR+14VNWDm7LUpyzjCCHQdd0BCjrnDnGrzrkDGFXVQ5+GYaDve5qmeW6OSn8LSC3uzxJ5W+JjS9+LG3XuRKydnimlA/Qcx/E5wKaq7Pf7Q98LqCpA1Xt/ALXHAFwIgRACq9Xq4P4s7ZVxlfXz3h/iYGunZ+ljabs4ScvaO+eeA6g1xCz7ruynAoPrCOByjznQK23P4V6958p9StvF/TqvfVrand+rBtX1e/No2zkArkFrma/6e5mPGqSWrxoqfpbI2bmbdv5VH5uP79O2UWsOh+eO3WNtzNuaO22P6di+/SQdG8u8jfqcxXG6aNGiRYsWLVq06EUyxmUEIjlqUyTHk6oCrcHdOmP7yqvcufr7fND9ITfvPiNNgBImJicyAT44v2V4eO+M9WZDs11h1+0B7mgS0tiTxkB/dUm46sAo29tnnJ2d0T29xq83GO8Y9x350UExCkYmQCQTJhVFo2KNxbgmx2MagxHBSHbcGSBJJIUOMY44Dki/BxNwsgFnMpTUTBclpewRVc11Na05uPtkyiRNMScaPbkxXF603L0X0Tj9X9xIrqdIl92JmrIrEgMhkWzCuAy/ZIrzVBLZemkRKxg3gjNociVldzJq5kjYPAeW1A9TnKuj2Z5hxDLKBbq/Jo1ddm2mbP6z09oiaYr3BYzBuilC1UVC9FgriMphvhWTI3CdnfqYiHEkjoGhu8GYFqVHh4EYYex7uqFnHOD2nXuwOWM8eYkkhjs+8WuPzgk3z9hZ2J7cI/RX/MXY8Owq8HoaMSmQxlLDUxAUndpWywH+5nmZfg8TE2lQRJVxUIaQ0Gg4PUk8fLjm3sN72Lal3+/o+h1DtwMBYxu8X+G9w1ibITuJOObI2+z8jRlcAkaElKYP47opBYnpA8PZUAlqiFEhKmKEobvBnmyxbo01Te5vCOANKpE05rmzqw2rOLLbX8HJbRAmp3KOnrXOYkQXTrlo0aJFixYtWvRz1BeOfi1Qq3ZIxhifc8HV8LFAo3J97cYr79Xn1o7GuQOugM8a0NSxrQV4zSHMPCYV+KkYV3geCAEH0BZCOACxAq+89wdQV9fHrCM163jVMra6vmbdftM0B9BWQGtpt/Sh1J6swVYBdnXty1Ljs449rdewgNQ5rKzPnUOpAhrr6NoC+WoAWF7XEa71Pcp1tSNwHts7X5c6orUeR93f+vy507R2OM4B2RzM1XutnF/fq57/8vpFQO9Yf48dm6/RMc3He8xN+lk0P38+hs97n7+u6+dr9LPW5+nHokWLFi1atGjRokVzpaSTYyuhKWIQEEfQmOsqrjdsH72MFSGFge769zGXCWtGknqCZoAnCN4ob/zCKbfOT/HbBrtqMSaDppSm59NhpL/esb98StKAO/HcunOH9XrDzbvPOHt4QhqUYehoty3ics0/cS2JXFcx1wXMEbUimtuY3HDWNqQw5tqPYtEEkmKuVSmSnZbWkhgxsgIi4iYgSYaImKkuYDIgY4ZQaI53NZEwDLx5JVx3Da/tUwaZNjsWTfkw5cQDRTJEA6poWCbHZ0LFojFB9tEhvkGCIinXusQyRbaawz2UmGtI2ga1FmOFxp8i1qDOEHZXpKHPvwdAJ/AmJAXbeIwRVBQNiliH9RaXLN41dFYx1hBTIKXJ2ZdA00hKgTgOpJCQmEB6iECE4WrHbhhZbdbc+9Ij1menfP/pjl0fePgPf53+3Z9AVL769+5zMQystyc8/fAD/ngcsY97vnbR8bVGuNM6vM11IZ0kEorqtD9FMM7hGg/WZlxuMvANQYgx4RTWp4bzszX3X7pPc7IljCNd13G9vyKOHUiL8w7nWpz4XFsSCEOCEECmD4STSOIm9/AU4WtchvjGIpqm2qSgSVFNIIYQwVklhcR402Giw2ws1iaCBqxp83NijKR+wOkpPgbGpz/C3H8F1UyojTQ42+J8kz9IcIRULj7LRYsWLVq0aNGivxl9YVBZYN8hymZy/c1BxxzazeNK57/oL/cu5xbNzy2xqXM3YB3pWjsw5/crfTXG0Pf5YaO4JuuamDWErF2gJY603KuueVmgYQF25Z61o6+em+LgrKNgyzV13cka9pbz6ujZefRuvT41zCxj6Pv+cG19rHavHgMxNfg9dqxcN6/3WPpdxlY7Cev+11Cxdhwec/vVcLiGpeU+NWis565cU++3uobqfC/W7sxy7JN0DEYeA4PHrvmk8+b3PQZMj7kzP4tq5+fnvceiRYv+ZvSjy8Tr/83v/ry7seiL6H9f1u9nqR/+d7/98+7CokWL/o5LpPq/vXVoimiCpNOHX42yuXuPtV2hu4Fnb/6A4f/9PhpNrvWIYETxCCdry6sPz2m3a+xqjV2vEPGkOKIjpDEQu8BwfU3sBnDK+mTF+uQMYy3dbo9bbYjDSBgC21snZN+aouLy9TEDM5Fcuy+XehREHCRIoc9gzzrS0GN0+sCtDkgw6OgJ7NEU8QCtgzQgvsnERzOwTHGcgKLm+FeJiPakGIlRiMlwnZTrngxFNceNkgRoII0ZZk2xnUkTOcg0QyiNAbEeSCVpNh/TBNZiXMrj4sA2kQRiyz0cOgxgRsQ1iFjc5gQxjt44hstnpLFj1EtiivjNKbLakGRAnEOS5LU3gvENPiXWrbJf7enGJxAScb9nIIJXvJ0ScVN2F4rJMbwaI3EMWO+5f+8Bm7NTXLvGbU95798+pTcXmL/4NhHl7q/8Bzx88Ihv/+s/4uluz+r2XVLsSVH5/tjzJPb8ezdPeLRd47zHSMyANSUICTTX6kwmYMTgrMVKA8EyhhEFfGM53bTcvnfG5uw2eMfYD9zsb+j7jpQirhWs8/jJSZlSJMWUx4NOAFIRtSSGPP+Jjxy4KbsmdapzmrN182qFlCbHpiIpkfpEny6RBPbEYVshxA7vGoSBFEaISqNKfPJt0vAtsCdTHVPBOkPrPeYFj7gLpFy06G+nPs1z8/IcsWjRokV/s/rcoLJ2MRaQVBx+dURngW/FbVeDp3K8dt7Nocs8dnLuXgshHJyOc1dZ7QqsAVYN5MZxPBzrug4ROdRQrCFniSWdOxeLauBWQ9kCO+dgS0QYhuFQg7PA0QLE+r4/uC7ruSrxsvX81s7D0pe6n2We6nmsgV0NhOu5mkPGOgJ2Dq7qe5ao1NJ2Oa+4Y+f7aO4mrduY1w6dw7J6TxwDi3OHZF2Dcw47567Oek+VPsxdqZ8m/vSzOP6OOQWPQcYaHh5zfh5zGn6c+/DTODg/C5xdtGjRokWLFi1atGgRiBqM5Kp/ouSIVhKkhGrEGkOzOsH5M4au4/ZX/x36p8/YvXtJxEwRleBFeHiv4eHdLcYAzoE4EoEUMuwhQBwiw7BHifhmhV+tcY0ndB1JLMZCvNmjmvDNGo35A7dDvyOGmJ2AGrF4xOVajSIGM9X1E+dzncUU0BhIMQMkHTsSypgSEhrQDUYs1oBpXB67NbnWJIrG8eCcgwwIxQqi2e2XROlToo8muzzDgKaUi1xqnKJLBcUcQJaGhNqICFN06eTSkww0U0pIlCla1MP0gV4kQy+szSm1KTv4jOb+kkawOaLWbVYgBiOO4eaCsb8m7C4hRWyKuPU2O03JkDLH8jpMbHF2YNWe0N9cE7Rj1B02CS45Ro0YaTBW0JQLembHqLA+vYPfrsC3GOOwbYNpLG8/ucGtRk7ff49oDe/+xZ8T/vK73CHyw8cXnN67l3/X0FjMdkW/u+av3voxG0bOT86wTQOS432xQGpAIzoqtB5jLc4yuS4BFN8IJ7c2bO/cw263xKR0/Z6b3SVpHDHe4+0W77Y46xAMGgIpKTGNeT+hWJmgsSjGCda0oMXdORUzjdlBiVpURpImvBhWVjBJ8t7VgAlg4w2DBUkr1LdYJMf/poTGQONazIc/YHf1h2xu/RZgMM7gvMP7ZnrWXZ5zFy1atGjRokWLfl76QqCydu6ViNESg1ofr4HmHGoVKHYMynwcPKlhSQ255i67+v7lq8CqGkLVULLcp65VWI+1QLgSe1pDrBrSFig3r2lYrnPOHSBiAZrGGNbrNV3XHcZZg7jawVpez6Fp7QwsfSnXHAN3q9XquTjbOpa2xN/O2yt/L/Uv63kurtM5CK3HM3dRziFjAaRlvur+vsjdWdoqQK4A53pflDU4BvE+ac8d239zx+Ix1Xtz3t9jYzgGX4/B7jmkrN97UZ8/qxvyGPhcHJWLFi1atGjRokWLFn1aKSAkFBGLEhGFmBJJATGIdeA87Z17nLz6Zc6efMD+4o/RXcaUSsJbw6uvnnN6usY2LaiQQiDGAR0TsR8J+z3jsGfcD+A8zcmGdr3FNI6h6/DbDaZt2H/wIZAQo+Bsho/BY0URPMY7rPOIswd2k59HLBjJ5sahw6shDT39sEOMJaZIGjoMitEcHWucIRkwajIIHEfEedTYPCdxSrIRl6GldTSNxzkhoowpZEApFjEJwSLWozHmmpUiiGtQk+dJY8pxpQY0jhOkzDUySZLbiGGqe+ghhfx1iBjNkFCTElOOJzUkDAYRRQGz8rT2HNN49DLlee/3pBhJYaCRu+A9dgKzikW84nyLTwOr0xMuuj3GWtrWgzOIXSFGsruUiCSFFLB2MwFPSMbgVmvsqmHfd3x4sWMrkRAjToT09o+5fXrOdrvhznrFkBL73Q3WOoyAxfJkfYc33/9L0vCQ27dv0aza/HycFGltdiBqBumgh8jVcQRjDU3r2Z6d0q5PQRP90LHr9gzjQIoDvjnFOcGaHPEbNBDHBKpEIg4QY3PcqxhEDRiba7ACaDjUXMXZkoubAWqCxjvMVghhYBwiMYJNEEwgjCPWGFbtaf4wgEY0jRBHxAh2aHj69u/hNl/FN1/Oz8cqWGOXZ9xFixYtWrRo0aKfs74QqCwuu+LWgwzEihuwaZoDyCqRsLXjsECounZgDaM+Lq5y7hgs9yn3nTsNC0xsmuanImALgGnb9rk2axhZ4F0dy1rGXcBX7cSr2yxu09rNB7nmZe3ELBDQe3+AmHPIVfpTOz2NMXjvn4OvdfRsDVoLNK5BYR0fW4BU3f/a2VjuUdZu3mZdE3Tuwqu/5tGsc9h6zB1b74saLM9hdA05j91r7tqtYWnZ08eg7jGn5qeBf8eg6FyfBC5fdM/5WOqamy9yYn4eHXNULg9zixYtWrRo0aJFixZ9vFQiiVzDEAFNgkKOVzWKMU2GgiK47Zbto5c5u/kquyePefzdn5CiwWJYeeFLL5/h2g2y2WYwuO+IQ0BHJQwD427H2HWE2CMuR80a57HbNeNFx/rWGYwj3U2HW5/g2g1+u8atXmbd98ShP8DI/KwDWItMBSE1BDAWDQq+IYWB2GUQOA43aBgy2AwjiR2hF3AGq4Jrs1VRnCcSIQZUbXYReodMzkvIMOp85YCREISUDGLL851MYFER02TYKilHw+pU59I6VANifI52TaCSwEZAkAiCRx1IkAyDVVE0O/gkg0HFYgAVQ0oj0qU8p6sVsvHgHSLQ2yu6q6fEviPGARFLc3YL01iSMYgkJAmu8bRxy7gecf4CQ8NmdY63HrWCaobAMeW6mCYlBI84wFnUOFzrUWt49v41z646YgMxCTZl02eOiu350vk93krC5bPHnN2+BylCTHSrc968HiG8TdM2+TncG1JMGVQL2YWqBk0Qx5EYoRuE9cpwcnrO5uwu6izDMHJzc8P1bscYA8atsjvRWVQkx8WK4K2f3JMGxYImVM3EjQWNK8QMOQ4Wm+FomupTiiVJBsgpjgwxEIcBawzOOmKM9EFJdsT2PbZZEaX8/kAQa7MD1jts8Fz/YI+99TucP/ovUD0nDIH9sCOmxU25aNGiRYsWLVr089QXqlFZoFQBbNZamqY5QK26rmPf94eY1RJfWtf7K0CzdiaWY23bAsfBl3OOcRyfczXW9yiQaxzH59ooDsOiup26NmUBgyVe9lhdSYBhGH4K8tUgtUDNpml+Koa2wNOu6xiGgZQSbdsegF+BpDWgm/+9Bop19GpZh9Ln2vVYvgoUrV2kJca3aZrnwKKIHNYuhICIHNZ5Dg7rOavB9jEXa7nvi1yfZe/Uaz+vBQoc+lSDxLLONUQtbZVjNdyeuxlLP+ag8kXuzrnm++zY6487Pv9ez+eLrv80kPPY8WNAsnZu1te9CFh+GjD7In0SSK37Nu/Tz0Kf5X41qP5Z92PRokWLFi1atGjR3w4JFgQkJaJmwJa/J0SzS08QjHGIN6xu3eL85dfofukJVx88Zvd2jyCcna/YhYa//NEl29vK3funtFPtROMG4n7PmAJDd4OOAWs8znja9Qmy2dBfv0tz3pBCYL+74fTObax3gGJ9hqXuZJ1BpQgpDAgu0y8yByQkNKVcZzMYZDQZBnqHGRrM7pow7iEpcexJaSr7MTkZrYLaMcd9iuSY2XEA68AKmgwiBmM93geiKimBhj6DqjSSg0hznUJMzE7MCKZ1iJgM2mJEZIqoJaIp/x3jDzUqM4ybSl4aM8WMTv/Hj0oCxEx9UtCYSCliEMwwoDhEFL/ZIMbiGsf+6oIw7oj7K6JvscZgGj/F2cbsSGwsK91ydv8R4+UFkcSqXWXHZEwZaJsMXtWCaEScwzYtyTvEe8YUePOHbxHHxO4qsB/3iDQkt6UbRlDlfBu5WG1IChIH+thzsrnFux++z9XocfGae90N2+0pJigpRJwz2GaV11eUYegYuo5uTMQkbE/WnN+7g1uviAL9OHLT3zAMO0Qcvt2A8VNUbEKNQxVSUkhkR6pJuW6nGEhjNkwSUTGTe1inoqEZjiO5jihiiQpiDM5ZCEIjBtMIfR8hlt/VKCkOxFK2JUzQUxWjyvWPlc69Txf/gGb9j7juL7m+vsm1L5/7uf3oT10iYRctWtvqEK0AACAASURBVLRo0aJFi/7a9blBZQE98+jWApU2m80BKhQnYgFzdZRnjPFQ+7F2w5U6jKrKycnJAdYBBydfeV0AXQ2zhmE4QMwSA1og6hxm1QBovV4f4GYBoarKbrfj9PT00Ocy7v1+T4zxENda2ihzVICW954QwmEeyvhqh6C19gBLnXMHIDWOI33fs1qt2Gw2dF1H3/c0TUPbtvR9fxg/ZGdoHTFb1Pc91lpWq9UBwpZ2Cmg1xtD3PQDb7fYw1gJUvfcMw3AYaw0n6xqW9X4oULIA3/K6OFwL6KnhZ+lXicK9vr4+QPEyn03THPaAqh5qjK5Wq8P45w5T4DBPRXOQNgecL3Ik1m7U+fvz+8wBZL3vauBZn1/XJ63doLWDt75fmYu6z/WxEslcg84a0NZRxbWLtv45L32p3bbH5nE+d/WxY1G4nwb0zSFlUe0inSvNHjhfdL96nsu+Oab636VFixYtWrRo0aJFiz5JKaUDlBOVicEEVBOkOIFGg2h2XNq2pbl9i83LX+L0jTe4evodZC80Zye8292iG+DW+SN+/FbHs+99m5furXn10W1O12t02KPOEkk0rmW1PcF4i1hLP/Ss3YbUj4xjx3q7wTiXgRgJMQYxboJCBtv6XJ8RBSnOwhyrqtYc6i9KAzJ4rM/Pk1zDuL8GMtjD7cF6sIJoC5rrVSZncqyqNcQ0YsRhnMU2FukVbxUVJcSp9MkhkjXDPGMEwWeHp7V5fq2BpKiO4CTXJyQhYrIjNMZcj1IElfIMYQGTS2VqJMWY3Z2JDLiMIekUP0teu9gHJHlM02KcoTk9wW1XyGpL/+xDYneZYaXL8ynOYqxik8XbhpWLjOszNAb2+57VKuDtCuMy4HMFuGEgWaxrUJvjgzWOPH7nbd5/9xkrdax6yzj22Lv3ufP1X+b6L/6cIfSsiWxbwxu/8Rs8fvIBH37wHj/6/vf48b/9ASvT8Naw4WwfOd3d0HqHRUjJYScYGFNid31JP/T0ncGI5e7dW6xPz8Ea+q5nPwwMYcwg2BiEXHMy72VL0uxgTROCtMYjJqBqUEnTXpNcX5TsMo6ax57ruUI5KEzrpWDEINaSYsSQOfMQlGGMhGEgNiN4jxgLEpDJKeuN0CaLsX+f1vwyXR+4vrri8nLH/PFuKicLkEH1X8O/DYsWLVq0aNGiRYs+0ucGlcdqBxawUTvcahdaAQwFeBW4VSAZfFRjsI5QLbBxfp867rP0o7zvnDtEqxYgBhmaFtdigV0FRhbX5dzRV6JYi+OxwKI6onUcR9q2ZbvdMo7jcw7L0m4BZfX4ynjm5+x2u0O/rbUHB2iBkqvViqZpDm7RAh8LVCrA5ZgDsMCnAmSK07T0pXzV9S+LO7OsD3xU97JcW8fLlrWpYeEcqJVj5fxhGPKmnKB02V+1w7WO9C1wrey5+f6sXZU1VJvXRD0WaVq/X94r+3G+bsccivM9ND9eX1fP6Xw/z0Fl6X9dS/WT2pqP+xjkm8O6+ns9dx/nCD0G7+r7vui6T7pH3Ydj81tHT3/a+9UfijjWvxf18bO4QxctWrRo0aJFixYtyrGpilGDiuTY02RIKpOzzKEixbyV3ZXrhvbOHU5ffYPT99/j6gdP2Dx8gztvfBXRhGk873z3z/nwvUveeXzJe+OaX3hwm/XecPfhK+yub/CnJ7jTM+y926SbjnHcY5vbDDc91q9pNmtMs8puMSNgDIJMNTQz2FGNaEoYSagKKYzZBZnAiAXvMSnAFG3r1iuwgjGWsbtEjSEOPehTEglNil01WNtk8Bghpoh4A9aQNDH0ETCcbzyNBMaQCMOIEUPEZBBGjnlVzQDMiJ3yXbP3TYwBjaAGsdMzkDLBMZsdmTA5LckgNcR8jdgMJc3kziQhwWQaJpCiggaMTvUbSymUZHFti73zEt1TCKEndDdYY6cPMHuEiHEJj2elEdmcM+5uGPsRj8U6ixqDSYImMiFzbqrpKWDg5vqSN3/8E9IYeeAa1n7EDCPXN9ekv/oedhyRxhH6nvMHp3zr3/81rN/w9P3H/Nm3/xU//uGbvP/kAiOG3/3hB5y5xMN1y0l7ltc8BTCGoR+5ubqk30WiCl96uOXeo0fYdsUYlF3XcbW/ZByVpOCsQUzKwLmU47GCpAwwjTUgCcGRVEETSRMWITCV8cFluCwGnJlAOWDMdI0CETWApPxeAGuEpMrYJcamZ7QNrW0P8FoaBwac9Ww2W259/R/i7z3k2Ztv8ezqGdfdzU+BSpmmH0Cnn4wFVi5atGjRokWLFv316QtFv5Zf9hewFEI4uPTK8RqY1VCpRMAWUFBgg/f+ADFrKFDiRmtH2LG6ivARfClAct5G3Y8CKsv7bds+V1ezjK8AzAIq6/EBB6fmfr9/btw1oJs75wpQLS7UAiFrSFdH2pZ7DsPwnDuuno96fupalnPQAzznmitt1SqQt5xbz90xSFxgYWmvhpT1ecWBWZ9bom/rvtbtlbWrHahzB2e9Z+Z7Yj7mGpAei3ytx1cDz2MQcf4zMT/2ceDrmGuzfn/+uvx93s6LYGt9rJ6rcn09Py+Cpcccp8fmo26vBsdzCPoiB2S9F48dq/tYf/80rsm56nU9NlcLkFy0aNGiRYsWLVr0s1BKirMuO/oQRCM61VMUMdnRqAkxFms8OIMMYLZrVncfcPbal5Ex8vDrX+XkwT26J08wN1fcMkrz8CVS67llDD/8q5/w0p2WpvVchTUbd0IUB9sV/TvPCEPEW8fVs6f4tsE4R0pDruGHRdMItkHITkdBEMmvtTgZU47jFFVUA6iBGDLY9C3OtRjXYsSBMYTumhzFGZG+I4kgkpBWkCjZsSgG7SOJwMXjJ7z/9o85PTlhuzY0FkjkKNYkiJHskjPT/FnBWoeYDEclG/kmwuSy2zKvwgQnBTQhBUYq2RmacuxrQjLYEjMd17xmdqpfieTx2uw2VRtIYkgpoDEigG09zfYWevNscv+VtRaMkGGga1in6f3tmr6/ojGG1qynuc2tJRxYl+fNeQgdj99/m5vrPd7Dg7OBxgubk5bLqISLC8RAFMvu8pJ7J6d859/83/zmP/1nnJ/f5vaDl3Bmze/97v/G1bMnpBj4o4vIr9Nj9ArnPWJaRAy76wtuLp7Rd8r5rZaXX3mI326JCPthz03X0XV7NJb0ohXGOqxd0XoL03o4I5gJEmf3qmTImCwiGWI6u8koMObfh6ACSRDjUR1RsqMxpiGXI1UhpIDGfEdijvEdBuj3I6tmIMUBdIMxK4xzRCCp4dajr7G+c58hwX5/w8XFBd0+r1156i5OT2FKoBV+CmR+WsnhzuX58rlWFvy5aNGiRYsWLVo06XODyhoCHQNgx0BLDUxKXcNDRyZgV7sKy3XFuVicgrVDrG3bn3L41TGxda3IGq4UKFLXsiz9Km0U8FpHjA7DcACSJZ4UONSUrN19NWQs4y9wssThrlYrVqsVIYQDqHTOHWJaC/itHaa1k9A5x3a7Pbgr67mvaz/WcZa1g7P+e7mmvF87GOvY1DLfBdrW8bJzQFiv+RzclvfLe/U4a6BVO3fnjsQadJa2j7kW53C59PGYs7W+vobf9bllLefv19fXQG9+3xcB7GM6Bs/mTsUXOQdr1c7NOdj8pD7UcLNcP98/x2Jk56D6GDyu23jRsfm/L3U/Pq7vHzemF7lSP64fixYtWrRo0aJFixZ9FilCSBGbAyhJJDAJlUhCwRqMsRgRRCxGLEJ+rznfsn30KrfuPeLBL7yOhhFrLLfunXFuXma/aYl9x82zC9qx543bD2itwb3yS9z62jdwYU/3wXs8/eAat17h8FxePOXuKw8z1MOAWMRIho6aUAIaM5BMSdEUphhMi2lXaBjQqDlGVUcQhxjFWDe5GTNQJCVElLHbQ4po7Ah9zK46ATENpBHwqDj2wyXf+dPvMe53NF8RrE04EVISQoyoTs+cIiRNucahBhCf60taCzaPJwPI6XQMGEE1TtG7EcVk1yWa40rJH1I11gMCJmZgG5WpyGOGk1OdyUwDJ5dpihlajgHrDOIMdrPGjnvSMEAIaNNk8AsY47CaSDbQ+jVWGkaFUSwmjPlD1MYRQiKZhDEQYo9E5eriKY8fv4emxPYMTsnPQi//vW/y/Xeu6C+e4WwLYhn6wNnpOf/6u3/Ar/+H/4Tb9x+yPTnjt/+zf8Y/+s3f4uLxu/zh//o/8b3vfZc/u7rim2PCGY84SxwDT9/7gJvLEXtyxmvf+ganmxUg7Hd7Lvd79l1HjAExHue3OToXjxgts44xHmNi3gtqpnmWybGrJMkQ02IyzLaTi1dTrnUZhwxuDYixhCQMmmhcg8egJqJDBueikZTyftEgpJDrwZrGIcaiwwhxBJv3SuwD19fXXD65YBwLSKx+LzK9Ux4nFSFWx2v8+BF6nD97aobTFa7U+hzNxxZYuWjRokWLFi1a9AVAZQ305jBi7lgrNQELoKvBYAEec+da0TGoVd4vrr0amNRApMSLlnuU/sydd/Xf1+v1IeZ0GIaDy3K9Xh9AZQ396pqT2+32MKYCPUs9xzrStjhGd7sd19fXz8XHjuN4qMXYtu3B8VnmcRgG2rbFOUfTNIdaoDc3N4f42Xo+ChitXYKlzmOZ9wJcy1cdfzsHkWUdimoHZ+1GrCFnGU+B03PIVb5qUCmSI3frfVBUA+3SxwLJ5nUV59fM71X6MwdV869jzrvapToHkscA2RyaAs/VoTzmaDw2/tL2sXvOIWn93jFXbQ1t587Lcu78527+fn1+Wffy78N87PX95zoGfetj9XoeG98xfRJ8Pfb6Reu3aNGiRYsWLVq0aNFnVQaQJuOJlF19GrNDUchQTVQyEDGKtdkJCIJdrdjcucPd9W2atqEbdqxMxA89wRlOz0/Yv3XJB13ktQe3uHfnDCPCervh5NYZ/uQB4eqE/ul3uf26I40DIQa2Z7fAGFTBaInUFFTD9P9gRWOOdBUzPZPJBPnE5HhYZ0kBRDS7HtMw9dtirKc5Pc+1BFNiGHo0RkJUwJISOK8YI+g4gDFcPbvi3XcTL91vWa02cPEMZyMhKUMf0ZBrGKaY582IwViXHaHGIs4hYnNfRDPIRLOTUtMUpSpMBDbHi1oLaqbalVOtTpF8j2wdRZwh9bm2JdYe6JVaIQ0xn6s5ClcR0pjrWlrfonGCvCmiBQyr4K3LEb6apgqZK2JMjFNtxpSUZCAyPY9aQxoHPvzgHcYhYi20DdhGwHnuvP4VntgPeffqCn/vAS4mwtUV3rf8g3/8HzOGPj9rNZbtySnON9y7/xKnRrn+7/9bPhgd335yhRjDA+vYXV/w+P332AfLG//kv+TBf/RPWe2eEN79EcOPvsf+rR8y2A51CTTkmqGuwVuL9w3WrbDk2FWDJUr5wPIUp6ugySKTcxfJJko9wPE0uVAB47NDN+0QsYSUcBpxGDRCGCJjrwzRkCJoUlKY3LOUD6fG7HhVJV5docNI1/dc39zw7OKSpM9DxwNUlo/eyzg715id2CMyhcJyaK280MmBWVy0Hx0XMvuGPF4gx0DrgisXLVq0aNGiRX+39blB5TAMz8Gu2iFZwFaJUK1rGc7BYw3Q4HlgUOJea4BR7lNgX4laLUCsBqSlb3PY1Pc9wHP1Ket7lK8CWAtoc87Rtu1zIMk5d6ihWY4Vd+MwDKzX6+cAXj0Ht27dOjgNi3uzgEpVPQDDEpObUuLm5oa+7xERxnGk67rD/Xa73VFHaoGVxVlZri+OzdVqdXCKFgBaQNTJycnB1VnqexY4XNcpLc7TOUQs/ahBaAHBNSAzxnBzc3OI/p3XMK1jbev9UvZRqedZr01xnc6hZYGidd/qdamjcOv2ahg5d27O3Zzz1y9yPM4dpqXd+vsxSHrMIfqic+f9q8FqvTZljuqfo/mHBOp9XK6tI4bna1/3qejjYOTHHZuP62cFE+fr80n3XiDmokWLFi1atGjRok+rpAEnDhWHyPSMIBlxGJOdfYqQpphQIw6DzdGTxrA9O+d8cwvfOILAxip2yJbBuO8Y+oH2pOGVh3fyM6MKzirp5pLYjIh1EG9Ynd3i6q13aU82NJs2w7uQSJIQ6xCX4agqOY5WMl0RcdMzUsigNdsrs2NNBQ3jRHMku+lSyvGprcfKKU6VpE8ZhpjdpcOAlRLrOdXFNNDvA11wrLYJZ1Z4o3gLIcE4RjRFUsy/czDWIwJiHGIcdtVAzE48MSY76NAJBAd0gpAmaXaxipno01THUkymjSq5dqbYnB5rXHZVToBSYgJ0olYG8Ta7SlMGbEYFXAZOxjusniAY0hiQCLjpmdSCNQ5MADEMIUM5VRgz/SVqQo3NEBTh6vopl8+eoVFpWmHdrDGNYzDK+vYd7psT3v6Lb9PevQvPnuX+hcS9B19ivd7k5zU/ORGnep6v/vKv8a1f/TV+75//Dk9Xp3z7wwu+mQaevfMh+8vI/S/d59Vf/VXS3Yc8O7vL9svf5LXf2vDq/oqr996k/+BthicfoLs9/eMfYnbX0O8mAmdJRGJKoJYkihHJ7skpalc0w3IlkXBYFTAQw0CKCWNz7VHVSEoBQwIRQjAQIuMuEHroA/TJYFE0QiKAiRmY+vL7m4iKkMKeYRi46fc8vXrKxfU19aO6naiiIYNKKyV29iNAOf0ITC7pTC6tTM+RClElT0GaSptK3nIZelZQcmp3jB/9aOV/M/7a/jlatGjRokWLFi36/62+UI3KotrFNo/UnEc+zgFPOVYgFzxfl3AOTMr587jHAlBK2wVAlv6V+xYQVYOPGvYU2FU7/2pn6NwRWNrpuo7dbvcczCngE56PxSz3b9v20OdxHAkhsNlsDvU+gQMALvBuvV4/F3lbu+UK0KvbqdeogMW+758DbwUwlZqUJeq2gNCyFqWNEMJhTeb9m6/LMQhUrq0BWXGYrtfrg5PUe/8cJK6dfQVW12te5qy0WcPz2kmrqmw2m5/aO8V5Wu5zDFTW61nmqx7zi9yXNUh8kVtyDiBrN3B9Tv3zVvpZXpe9Ws6try39PbbvyzzW8zf/OZlDwuJ4rWuk1hCzHt+ndUB+HNA9Fl1b1uKzau5KPbYun7WPixYtWrRo0aJFixb9tCbPlSSSJlQTUUsNyAItI4jJbjCNJAmT08zSrDyNs6zXHk4aVsGhMZBQdpdX0DTc33hOTreoQuwHNCnDhx9Cs6X7YI+mDh0ju4sbzu/dzbGnKaJxAHEkUSTEj9xtU9u5VmOYfGOCWo9SgGWO78ya/j8dJ2gXI9IK1jfI6Ul2MEZlTAEloiGQpEdtnhsBNCVGNUQ1GAtGA1sLBKY/FMEwGSUzXLUW46ZYTZPBrliXTyhjTPm1MQ6SYEQpVDCFlJ2OSoaRU/3DKcM2d8wajGHqcwJ1qNEM+xIQY15XyO+FEetajG8gDhk4xgyfjBGMnUKArcWIknZ7HA1JR6Imhjjm2ppGpnqMIzZ6Lp58SD8GjAgr5/FOUKd443HNlkdfeZ3v/F7LB9/5Ns30O4Vx3PHH/+Kf85/8V/81KQ4Y14ARnG+IYcDalq/84/+Uf/m//A7vhit2d86Rt95mfRG4e++U85dfJqpwc33N//g//M+MXeK1X3qFV157xL37d7n38re4/a07NN7hDHgraL8jPHmP4cP3Cfsrxv014elTdOig6whXT9HdDcQ9JkZiGHP9U00EURxTLdTUg1vlZ68JAsYYiCGS2DHshBRyHGuXHF3f0LqRmPI+Ns5jmwZpWgBSisQ0kPo94/6K/dWOi2eP2e32EzSFgwuTDCkbI4cPFwSr2ZWbySrGgp1qpLZNy8l2S9s0xBQZw8gY8offSYlEQsl7JiVlDOMUU5s9v0ayqzLEDESNTLVRJ5q5FCVZtGjRokWLFv1d0OcGlW3bHtxUx6Ici2uuPl4g1TwitECyeUwr/LSrrIZwJQq1uBkLPCpOSJGP6h4W0FVATukbPF+rrgZhx8BLHZsKPOdULE69OZCdu96KhmE49KeAteKkHIbhAP/qMdUu1XpeypyVsVhrD+cW6FUcn2VOx3HEe8/Nzc1zoLiOmq3vGUI4uEfLvBRwWea4zEuZo7oeaXGzlnPhI/cewGq1ommaQ/3Oruueq+dZxlVga5mjcv1+vz+02/f9AczVrtkaytbu03LvsofqfVucpGV/1PC6rHHtLJ6vRdExWHcMwJZ71XUe56r3ZL3PCmytf1bK8QKgj7kSXwQPa6A3v6buS615vz4OXB9r70Xvv+jYsQ8/fJKO9eHz3mMBl4sWLVq0aNGiRYteJBGTQRkGlUiEXKMPckSoZBAmKLH8f1QBoxgn3G5OcCEQLp6x8S3tdkUwglhD++Ahtr/h9sZhnM/PXN5ircM0FhOFy7d+yNpbGAc09GzOHmS3ocuuRB2n+M6UaznmeE43xaTqVG1QwOYYVyMOddPzRwqZ6GiO3NRkJugUMd2AOIfxjub2LYgRrp8yaiSGAU1gG4+xAjrgfMIYZQyJEPvsKAUwgm/XGRgqmMmpl+EoaIzZrdo4SBHRhJIhJWKzuzOVD2JqhmBAGPrs1jMNKQSMNTlW1kDsR6S1E7iVA7gS66cPjkYkOVRCJlYqiJme3TCZdKklGSGFmKNFk2BMwHiPWotIRFOuWYnNwaIhTIlOmgGraMI1W4Zux/7qEo1C44VVs6JtWqJNOfbWw4NfeJWz23e4ur7k/jf/Aav2BFmv+Mmf/BkXTz7k/PaDvOesxeCnqNrEvTe+zq2vfJP3/o//k7Xp+V4nfG3bcPel2/Rj4Nnbb7F+7Rt0O+Hx48A77/2A9H/9Jd5aVtuW23dvsT1bc3K+4ux8y63bp5ycbDm/fZfN/VfYbFecrFesvMWqYkIPw4DuL9HdNcPFB4wXTxmvLwnP3keefQhDl12wGrPjWLJzMab4ke0QJcbspNwHQ5fAJkPUAC7vY9s6jAc1hhgTUYXYjei7P2I3CBfPLghDRMhuT9XilCSDV19+NgWbDNut596de7z00iNeeviAO/fvcP/+I15++VVef+MNtmdnxDjQdTfcXF1xc31Jd9Ox7/bsbq54ennBs2eXXFxe0O1v6PcDzy6e8va77/D+B08xYyAkiLmYJYWFi1YZtEtFy0WLFi1atGjR31J9blBZw0b4yFVVO89qYFe76Mp7xRlWgEwN3GrYUkPP4q4r59WutxrMFcdXcSfWoKr0t4yjfl1Dn6K6RmPt+izRrAVO1TGZZXz1uArcK+BxDnAK3HLOHUDkvM26puIcptbnFpV5K/GtNdgsfSzzVM9H+b5arQ5w0ntP27bPRfkW6FfWo0DO+v614644GWtAW8blvT/0se5zAY8FPJc5L8fqPVXPyzAMz83JPJ50DhPLewWszuFhGVd5XYPKerz1nq/jcct59fc6SrjufwHx9b3re8zdl/Xazdd4Dv+PAcoXwbbPCu8WLVq0aNGiRYsWLVr0kYzJMaM53nJ6Dp1qQapO/69PQpJxcmtNzkEMVi1r27KyLUmEthHW7R3cK2ekMHD7jT3x2RNOVh4ZemIcMdbhz8/Q/oLrN39AuPyA1euvTHGTQuMbkFyzUcQjNk11J5ngpJ1qNhrEZnhJLMREwCqSBHGeNERUJTsJpRTiy/3XkGM/JVmM8/jzU2LqiPvrPEaNxEFR53LEprGs2sTQRWIUolr2YeTEC6vtBjGOKP1kfVOMsVNtTzfVp5zialVzIKcIGiKkQJxqGcY4gFhSzBAQDIl9hoJWEGORIeUo3m7E2AyvkrEfpTolsI3DSO6DJlADKeZ4URHyvEUlRYh9n+Gob3PSbMjRrhojxgrWeTT1ueYmQhILOpBQHJYw9lxePmHfD4hJtL5h1TYY5xGbAbJ3De1my93X3uD6O/8P4gz7MLAfO7bbE/qbS0Syo0+wyFQDVUNic36Hr/3Gb/L9f/X73E3XXJuGH7fnrPaBr7iep2/+W7b6m6y3K/gwoSkyBkPfB/rg2O871OwY44izFkPk7t01v/2f/wZXlx0xwts/+gk/+fF7bNYtp2cb7r10hwcv3eH89j3OXv8yq43n1mbLyhlsGElP3iO8/VcM3/mX6MUzph8gEokYFWM0x8ZGIUShGx0xOULKdVaNJJwzeX3Kc7MYIonQX9P81R+wkXPi5QUkPbh67bSFvcCt7ZbXv/w6X3njl/j617/B177+NV77xS9z+85dTk7PWJ1s8e06O2SNwZRilAA6OW41oSmRxpFx2JNUSQniOOQPdA+Bq5trPvjwMX/6J/+G3//9f8F3vvs93nzrxzkFC2GMORY6TT+CxaGdlg/LLlq0aNGiRYv+lulzg8raSVZe11GtdXRlDR7heYdhgSu1s612Os4hTAEx5d6r1erQVg2Qynu1U7C48Oo6enMQU+pX1uCwho614664+eagsu5rDRHrsdSuxDk0KoCuvFfms9SvLLGvZQzzOM8amJb71UC2Bsw1wCp/n4Oz+XulLmdxR9ZtlfmpYWfdjvf+uSjZeRxu6WvZA/Oo3XqNa3ds3f8yvgKS63ZqN2z9ur73vMbnfI7mcLhuu/RnHh1cr+/HORrnc/Gia+o1qftaj+1FwPJFfVmU9UkOyWWuFi1atGjRokWLFn1qJZOBkihyiI4URAVnHdnBCCSPMpCIU+KoZWAHTmlMQ38zkvqem3Fg3basNhvQEbty+FWDiuBWJ/k5oe9QBvoPPuBsinqNN3tWp6eIy0BFTMlQBUIGpLk8ZULEoDqikeygtHCweEmO0ZQ4PYdIBn7EmF2Qhlz7MgU0KhIM6hLiPX59Quj3/H/svXmMZdl93/c559ztLfWqqquqq7fp6XWmp2clRQ45JIeUCHkkU5ECRbCSSJEgybb+sBHYSOIgQBBAQoAgRmLAQRwrMRQbEqUYkGUZtEjJXEVaokSJ5CycjdMz01tNd3VX115vuds5v/xx3n1z+7F6ZjjcROl+icd6/d6995x77nmPPO9zv98fzmIlR6xCTx7/iQAAIABJREFUGYO1OVobZtqaLCuwrgCnEadphYoojiZAVxvj62UqfHsBoByKCIVDsChRPtbVCrawOKUAjVJ+LeqKEjCIMijdwjqwpcLZsVtSe5BpQotyFhMAWFzgoZYrfCSoMQo9DsYFix7X+HQCmMA7Z5VCtEMr3x8RUM75a4BCa+PPaewE1UqAAOdKysBis4z+9jbWCmEQ0opjgjBEh9o774zy9S4VHL73Hl57/mtc+tJ/JOkeYPNWlwOLh338qAjKlT4aVynvntW+9uY973k3X5idwUSbHG4bljsRq3splzf6nGuvcqgofYkcl2JdTl6MAAPOopUFsVhn/dQuU37wR3+IE/cc46t//iJxq82ZB85x8eI6Tz/5Gsop0EJgIAgVSRIRBgEzszGLy7McvmuBY8eWOf/A+wlm5tj9+EdpBQHOWsoSHArthKLQpFYzKhWpCxGBlox/owoCgriDCoOx41dwNvc1TsUSFjmLepujOuM5BbEJaLVbLM3Pc9+Ze3j/4x/kBx57D8fuPs7CwYPESTJ2Vo7nnA68k9a/wMTmWVtHqjH8F0qszYiSNmrym4Iafw84FgTuPnmKhx56hP/sp36aW2trfP3Ci3zxT7/AV778F6ys3GBnd49hVo6jgF//ahmn0DZq1KhRo0aNGv2V0LfsqAS+AYRUjsBph+V+4K86Rh1YVaCq7u6rg5jqeOAdaXWoVd8HuM39V21Xd/3VIWLd3VepDq3uVH+xglJ1cFWPDa1ch9O1BKfbrzsuKwhah2TVvlX/6+1NQ9D62FYgWCk1cUdGUTRpvxqj/Rx49bqGVdTuNNis14msX8M6vKwe1dzIc38XYXUuVcRtXXUYWcHhauzqoLM+B+uquxOrtuuOzOnrWd++Gss6+Kz3a3rf+pyZjvqtux+nVXfO1vdX6vUakPvBxGqb/VyVd2pvv0jW+g0H++mva6xp4zBt1KhRo0aNGjVq9G2RsihCX9+O8ZpCVXBDe6DhfDyodSWiNCjlgaXVZKMRLrBE4rBFSb7bZ7B9gd7yHHOzM2jADUaIlCirkdEQRQkzEQKEYYRWiixNSWIDFnQYooIArEXEIb5IHmItKggQZ707UAdYinFNS/GRsVJF12pE6Uk8qmDwZFPjUFiXY7MRWmlMmBAEHUzcIWilyGiE2AIxFnEpyrXQQcCBWcONm1AWDmUckYFuWxPFGilzJmG0JvSRrqGvpYmAK3KUCREx2NJSjNJxUqbywMhBmTqcS7DlYQo5wCCNGA5DhpkiLUrSsvC5n+KIlCIOHXMzhiQoiKIhJtgkiHaIghRMSFk6NBqjFSqMoShBFJQWZTRBt4Mp29gi87U+x/U7daC9fc959ydUsaMKp0CNI06LLGM07NMf9EH5yNcwTFBaYXSCViVBmGBEUMqwfPYspx99jNVXX4W2pn3sCKfO3oMJAlxp0aaEiX/Qz02c4677HmLpxHF2XtpEZh3OjvjwycNc2R7wZy++xOV/+S+4tQVpHqJVglK+DJCgcOKwtsRZwaqCKNDMzM/wB7//RQ4fOsKVy1d57VLM+z/8Tq5d+zSjfoktwVpNmgn9fgoirK2nvPLiBsKrRKHwy/8g4vhixGs3bnJifm78mRnXdRRFXmiKUpOXmtwZtNIoXaCMG8f1eqcj1iJWkRc5aTpklKd0yow4iXnHoWX6wQFOPvIoH/jwh3n0vY+xcOwYulobj+G9p9MWUOMaqHrs7K3WhjVYWT0Th7MFShmi7vzr3wcir28/rlWLWEwUEbfbHFhc4p5z5/mbH/lxdra3ef7ZZ/iTL/4xX/rSl3jhxRe5tbGLBbQwdjOPf3/49nxbNWrUqFGjRo0afc/0tkElfCMc2c+lWIdldZC1H+SsjlWBP2BSK3E6fhOY1CqsAFRVS7ByJIZhSJZllGU5cddNQ8ppVxxwW03FyjFZliXtdvs2wFrBs2l3ZHWuVf/rMK9yyVWuxOrfVX3Bqj7lfrCpXgexel4fswrG7dd+BaLqjsU6TKy7X+vxoVXEanUNq7qV1fnXt63er2BffVzq8bVVvytnZd11WN+n7tatg+Zq/7rzdj+AXI3RdM3Q/eZZ/bVpaFvvV30O1q/RtOu0His7fcz6PtOflzrk3O9zVN9uv793Uv14dZg53adGf33hbKNGjRo1atSoUaPvhLznTrDgrK8wpxQ6MD4zFOWjV12BOOfrLCpfFxFxSOkQ5YiwiGgCrZF0yGj1Jq18jwigLHBpBmWBDjRBO8KNSlyeYboxJgyweU7SbaMU4+hP8bzFaUwUI9bhyACNU945Kc6DN7EWseXYiTcGNZS+vwqwHrQC/hzFohxoZTzscYJzBShNmMwgpcU5X4dSRGPLEmUiZmdDrl7XpMMUZxVWFN22Lw/ity08LAW00oCvDymlRQctbJmTj0YoNS4RU4xrUoZdymKJ4d4iqxsl68OCzVFO35ZkYcwwt1gdU2oDylBmIwJKtCqIb+TExYjZlubk4t0sdAsCtcrM7B5x4giMX1trFfrahgBOgQYTBkggoASberenK3PQChPF3hlqxrDaOozykay5WBxCUVgGe7uUhUWHAQZ8XGwYE2gf4arCxFcR1YpWa4YHPvzDHH3gAXa3bnH2He9jd+cmINiiwISBJ7Z6nPijDSKOIIi49/EP8sXnniQfOtLY9/Xc8iIzPcvWXXdx/cbTXLt6gSCYJWodQOuERC+iTYAtBadKFIpCYLc/5K67l7n33ClOnl3mpWevgNL05rr0dzdxVigN4By2dGgjSGGwZU4UtrBOc/HV6xycmWN9a4PlVkyrlVC6AieQDjVpbsgsjGxIIZpwDA2NVpgwQoeRP09tcGlOWQppVmIlImrN0jt0irsf/gA/9vC7WThxgqQzg0NRFCXaeZesNnoCLWVcvxVVh5N1qddfEm991Cb0sLT6bKg60BxHFaM83Bbnr6f23wkmjEiSNktLh3jPe9/P+voazz33HJ/73Of4/B9/nsuXrzIYFWMX9NjF2zgsGzVq1KhRo0bfx/qWHJXV32lQWZblBEjVgU090nM/1980pJl2/E0DnioOtYJkdfBVOefq0bIVAKu73+D2uo51qFaBwzrkqZyhldtwOp6z/qi3FQTBbZCuGq8gCG4DI/u5OvcDt/X+1tusYGg9dnbaAVn9rWplTtenrNcMrbtjtdZEUTQ5j3q0anXcyiE4PYbTILM677r7chp818e3fo3qY1sHfXUQB7fHEtfPr95WfftpQPVGEHG//aZdnxVU3g8G7gfs6+/X42Onr1td033YD7zv5zS90/EaNWrUqFGjRo0aNWr0bZSA4IGCE++UE7E4J2jjoz9FHFgPK0C8Y1F8PGSg9BjKeaedEXBa+RqPe1vYOEKL8pGheuzK02CHAwIDyijv2LQlSiucdajSoiIPYtD4KFptwGjv+LIW0FCCs7k/D084x87LApQghfWwzXlXmAIQ77oUZb3rzFnE5tiRgDHo0KDDAF0EOKC0BcoYNIpuNyIwMOhntNuGdqCYbQVjqKvQonDi42Kr/vj6kiF5OqDMC1xZjtsUirxE9HH2dk5x+UbK9Z0Bm7rDQHcYKoMNQ4LYcOaRI6xe32Xz2hZhKyFqKfp7A4JEMXIBabFOmCsuvrbHTLnNyZkeZw6foNNeZaa3ShSC1RY3dpgqZ5ECX2vUOLRROANSiodd49qFPjjWn0qgFYV9fV1c2Iws3WU0GuAcREZjjEbrECUGbUKMUgQ6RANGByitCZOE+UPLBHFA0mlTuBlC00KPnbviytfXgArEOcSl3POex3jyt/85e6kwSkf+t4AwpN0vufvhR0gOn+K1lY+z119nZ3uFU6fuZuHgIqs3t1EoWi3DKPW/Qwx2M2YPxAzTAbNzHUxUMBoNafdiSlci4zqhZZl6J6Qo8jwjMAE6ShBXcPnidT78wZOINjgRSldS5iVZ32DTgMIpcgeZM5SiMEqB+M9KGLUwUQTK/2aQK8uuiVCn3s2B2aOMZg6Szc+zFc/iXnkZ9/LXEScMR32MCbwLWRviJKIVt0iSFjPdOQ4sLDF7YJ5Ob8YDzPqNxePPiMj4xnat/edl8ma1YX2f6jpUNy3gb2RwjnFRWHQY0O71uKvd5sjR47zvfR/kZ6+8zKc/9Wk+8YmP8+xzL5AVltJVTs7JURo1atSoUaNGjb6v9C05KmF/mFMHZfA6aKvAIrwO2Oo1JyuwVI9ZrY5TjxGt2qkDq6peonNuAherCNV6zGoVZVotAOrxplX8aAUiqzaiKJrUVpx2JFbnX3fvTYPQaXhZnVcFCOtjUO1fncd0vc/qGJXz0Tk3qcNZjVs1PhU0rByR0+9XbVfxudOuuzpYrs5j+m8F4uI4vu249T7Ur38FLettVIB5GvRW/avaqq7LfrB5GpjWgWG1TzX/pp2Ud6oVOg3Gq/7s586sg8b9ImXr2s+ROa3pMaqf33T/9tu3/pgGpNPnVo+7fSvab1y+GU1fu3rf9ounfSv9md7vrez7dp2T09f/rbTVqFGjRo0aNWrU6K+nRFmU8vUK7Tj6VWEIAhmDqnGcauW2Gsc5WiyiIWwlxEkbl40wxr9mtEZrCI3BEKDHcZcqibwzK4zIRjselhiDzUucVR4KjaMmpTQ4JX4brX0gqHaAGcNTC0YwLkTEIrhJPKyIQ5yCwEAJ2AJxgrgSLb6Ynw4CxPn4S3ElKreYOEHpgCDpImVJlu4RKI0Vh+AIooS5rrC1m9NthRztaLqRqYYF0b42I9Z5YOcE0VBmKa6UcR8MNrM45uhnJ1hZ67IySrklHXbah8icpTfX4oH7llk4NItWIWcfPsLLL6zzx3/4MloN+Ln/5nG+8rkV7r5vkYOHZ/jEb3yFzZs7pGnGzf4m2/mA51++zDsP3cWp4hjdmUuEwS3ilqIockQHmABCQKkQFwpGDCIDxDrEjZ20Gl/DVBl0GCNu5CGmCGWRk6cDrHNgNEYFGBOPg1tLFBYVJJ5xia/ZaYxBoTBxB+k5bJrS6cyTDft+GwLElhPXHuixu9Zw4K5TLNx9nJWvXyUvBRO0cALGZqQ72ywsHqTVnYNwhtmFk/ytn/8Jzt53gq89eZFRf8TJc8u8dmmd3vwscwc6zC/OkCSx/x0FmD8wT7sTo01AnnlnrCh8HVOlEYEw7GJMRF5k3Li+Qe7AhcHYkavIckueaaxVCELmQnIxWBSCQ7TDadizGaPdLfaGu1y3CddokXeOIqaDG2SY4hpsXsc6ixP7evSyFN5ZPHadBoEhCEK0FpK4TRQmhCZgbmae5aWjHF4+ysEjh+nNzTPTmyWIvftX7XPz8JuqWv8KoA2CQTGOY/YXl0Ab5g7M81Dvndxz9jw/9VM/zR994TP8u9/7dzz19NfY2unjnLzubm7UqFGjRo0aNfo+0tsGlVWNvzpsq7v5KhhUPa+AWwWmiqKg3W7T7XZJ0/S2GorVvlWk62AwuM3pWAeCnU7nNpdc3WlXQaqiKBiNRnQ6Hdrt9qSdet3IehRoBUzqDsgqMrbugKxcm9Ux6lCufr7TMK6Co9MO0unn1bbVccEvPqIoIggC0jTFWusL24/7W+9jPWoWvjFqdD8AXD2vzrGK1q3AaDXGdQhdj5mtH7MO9+qQddo1Wx/r6X7sFwlbH/P6+E6DvPqYVc7cyvUYRdHkuHUoW9XNrL8+fdy66pCsHlc7PdbTmgaEdWhWjWH9MX0Np/tQ/Z0GqHXVa5V+K5Cufg5vtm19Lr9Zm9Og/K3Cvzqk/Gb2u5O+mf0bZ2qjRo0aNWrUqFGjN9IEWigFyoyDS6vIRx8L6bAemljAOZxyaBWCpBR5gdMFojROHNoEoCPEjZBSsPkIIoMxAWJ93ChJiLuVIeJdW+UoR8oSrTQuzyhHQ1AaFUUESQsVBWNHmEZp7+RUKkCUQ2mFEoMrSw8dRYPx24s40A7RASoArMY5QSlBxPgakuJweQrWr5sCo9FhjA4TdF4gYsduuRQVt+j1Eq5eLSkPKA4kOUliPIC01gMt6+s/goAyY9AEzjpsLhQ52OIwa9snefnWiNXSsRUukquQueUu+Uafx//Th1g+Os/BYzN8/el1tjdGHDo2Q9QOOHb6CNbCPQ8foswcRmvuf+/d9OYTVl7ZYOPmFuuv7bF5c4kvb29xY3uXBw6dYaE3i1WXiY3DGQhFCEMQ68ZO2TFM1hpRgojFOlA4f11MSKBLxGhwGdYKZVHgHCgnaGPQxqGMoHXgPXNiMSS+HqMyYwefxZiQVruLUhDFLdLBHlk6IGy1/dppHMnr7Xf+unTmF1g4cRZ74RqRVjj8bxZKO/K9HbpHTtKdaZHmKYJw8eIq5x46xfs//AhxHJOmQ+5/+D5aScTzz32dtRubLCzN8NzTL3Hi5N305jo8/I57ScI2F195jTAM2FjfZnNzgMLR6XY5sDTHjbUblHnGzk5ObhXR3CGsTbFlSZ5axkU8KZ2iFO0dttpikoJBnPPCwDG8tsPedp+8t4B0u7TmFvz8zvZ8Tc2BkJf+mJMbkU2AuJLSFWgTEAQhxoREQUKrleBcQZY5RCxbeztcXbtK6+WE3swss7155noHmJ9dYHn5EPMHFplfPEjUilBTNzED47HnNnfl618Y4/Xl+L8nc12sdzorH//c1pq7j9/Nz/znP8fj7/tBPv2ZT/K7v/e7PPnM8+RZjpPXm2m4ZaNGjRo1atTo+0HfEqis4B28Xr+wXnOxAkXTINBay82bNwnDkKNHj5IkCVtbWwD0ej2SJLkN7HU6Hay15HlOURREUTQBWJVrEJhEk9YBZRUFOzMzgzFmAkXDMJy4O+swrF6jsXJm5rmPu6mf1zSQStN00pcwDCdjUoGueizoNGTbz2FXrylZAbZqrKvI2MqdWEG2Ch7XgVkFuupRuNVY1aHxNESstqvGqH6uFfirHKt1MFiP6q0AZx0+1qNhpx239fGpO0TrTtyqD3VXXnUe1fWb3q6aA9P9rDsf607Jev3PehvVcffTnd6v+lQf02m4Ou1CnXYs7hfnWumN+vPtAndvpDeCj9OQ8rsN894ujIUGPDZq1KhRo0aNGjX69kiNsz0FQZydFJMTJaAV4BAZrwMox4BCPAQUSxAZjAii9TgGU6M06CBBAsuYKyImRAceGKo4Aeeddkr5Go5KCUWaUwx3sKMhSmt0q0PY7hB0Oqg4RIeRB6FKgRKUChEpEesoRikuz8c1FT03EcY1KoOgOlGUHv//cOd5mBpHkroyx+YpaEU0E2LihCAfkqW5r89JSKgDZuY6uCt7jLIRoQkIA4VTGo1BrI/FVNpgxeKyApt7mCcCRanI0nt5daXDxb2Ua7rLQLc5ctcS21tD3v+j9/Psl67S6sbcuL7N5Ys7rK/vsLsxZDgouLV2i35/h4sX1ujORtx7fpm9bIRoR3s+5uipRR574jS3Xtvjj37/Oa5f6nIp22Z7bZPH5DgHshmG7aeZm7M4p9B5SRBoTGRQ4t2rYi3iZFyXU6ODCCcW7cau0fF/bJEiTiNoCBRGOR8rqyN8PcRxupRWKBPi8CAX7a9dGCW+FmYQonCUeebXZDgfLarNGKD6ORi22hy49zzqjz5PO4LSFWMYXTDcuMmx2RnanRA2PQB/7plXufeBuzn/wFnCUKNUCyWK/qBPYUuuXLrO7PxZDh5ZJmknDIdD5hdm+Omf+xHKwuGc8OUvPc2N69vMzc1w9p4T7Oxu8dFf/wNSW9Ifwa2NIdGhQ6SXnyeIZv1vTcbhSkUhGhVZZuMBLizZLUouK81eYhjFHrTOSIdemDAY7VGUOdaWY3emY5T3ESzKhAQmRsRhjMYEBlyJuBDR1c3fgipzknaXdmuWdqdDp9ul3UpIOm200ViEW7trrG2t+nkKHJw/yKGjxzl0+Bhziwd8hPFtqhWVfMP1p0Ipg1T7uxI0BGGI0YaTJ07ycz//C3zwQx/i9z/+MX7ro7/NlZVVrAgib/8m5UaNGjVq1KhRo++m3jaorDsp63/rsaSV6qCien1ubo69vT1WVlaYm5sjDEN2dna4desWvV6PgwcPUpYlzz77LKdOnSKOY+I4vs2xV0W1VsfXWpPnOVXEaAVSK5iWZdltgLUCWJXzcG5ujjzPJ27OOphM03QSoVrBtgo+VtCuAn71WNYgCCbuvaq/067TatyqYwJEUXTbeE1HeVYAbBpwToPGaWfffq67PM+/ob3qvenn08epO/QqqFaHvdOPoihuc5hW51yNxzRArNyk9XlWf3/aZTsNaiuIW/Wtftxqu2noPO0InR6Luuru0P22u5P7sZo3dQg57a6sX7fpaz/dxp368K24J99MbwYfv1v9eCO9nTYbSNmoUaNGjRo1atTo2ybRKNFYl3uwh/Vxr1ajtMMqGQMhAF0ZxkAE58DmObrdQkKDCRN0G6CFlAWOFJNE6MCgFJggAAXO5YSdGdyWQYmvI6mDEAWErQ5BYCjTFDfYIc9G2CIjaHcwSQviBIxBBQYk97Ueh0Oy3R1QgYdbytdfFOfQOsBh0VGA2AKlI+8XDRTKBpgoBtGI6yM2w+UjyoHBRAkqCFEMMTqmtA5XWsJEEYQBO3sFsRW0FsSKr5WptG9PHLYAm2ZY552d1oYMh2e4cLXLFZewsXAIrYWDnTYf/IkHefJPrpAOS374px/kS5+5xLWVXW5cWyPLMxS+9qWIoyhK7FbJxnrIa5fW0SogbGnuunuB9/zgPaxfGzEcWt7z4fPs3urzZ59/ia2tDl/c2uYd7S6H3Q+wLn/O4rxhMBySxBGxSVBaEwQhhQOPIwNfw1KBK0uUCEZpSryTsiiKcZ3P8RwiQIm/IVqUQkmA0SFGae/CFKGqa1gvipiPBiijydKhr4upqrhh7w6c5OoCi2cfZj4JCYOCrByCisiLgnz9JnGcMNvrEpghWVmysbHNv/+3f8xMbwZ3/CBhEAGOdDCi0+qycHCGvd0RcSthMMjY3lpna33E3FyPI0eOYK3lXe95gOXDhymLgjzLuHLZ0urE7O3lgGb1+i5HD97F6OWvEY72/I3oAi4WTJShHGwNFbdy2OnAILaMnOAGis7MLCqI2dnrkxcjyrIgy1JGgwFZlmPFgobQJKhAYW3K4vwS3dllQhOQxB2OLR/n9Kl7OHXmDEvLh+jO9ojjhDCKCILx7whaeV+qCM7533rS0ZBPf+7j/MnTf0z+pSGz3QWOLB3lHY88yl2nT9HudtHG3Fa6slZg8nZoqV5/oqq1rTboMBmD5pJw7NQ9dfIUf/sX/y7vetejfPSjv8mnP/NH7OwNxjcVNGrUqFGjRo0a/eXWtwQq6042eD0KNQiCCfyrg8TqEQQBBw8eJEkSrl27xuXLlzly5AgzMzO0Wi36/T43b95kYWGBxcVFVlZWiOOYQ4cOsbi4OKlJWQFJay3D4ZBut4uI0Gq1Ji7EbrdLGIbs7e1N6j5WwLICVSLC5uYmYRgSxzFKKfI8x1o7iZ+tOx8r2Fa5PCsQOg2dKuhYjUkFSPeDTd9wYWrxo1W71d8KxtaBSv39+nWZBnTT2wCT2NUKHtahcr3GY6X9IGS9H1U9z/qxKxhYxdSWZTlpq5pP1d/qUbk96/U8qzb2i9ychpf1azE9TvXtp6ND62M7DdjezFE5vd1+17nuMqy7jqf3rbtc6/tO19is7zcNWb/Xjsr6dg0AbPTXSUopAb4gIj/4ve5Lo0aNGjVq1Oh7J6XG7klRYzel8ZUplfWxsFYQKcG6ccRpiRu7LFECYUDUmSGY6SClUOxskKUjH6fqhODwUaJTZyDPsCsXcWvXEFVg2l0PFrWvdZf0OkRzsyh83cgot5T9IXl/i3JnC8lzZEaQ0qFbEVolHuAVJUV/iCssSo/Ld2BwkuMslK4ESiQFZSK0Sf2a0woa5etfJglaC+VQcEWB6/eJ5kLCpI3LMmw2QGmDswWBMnS7mvW1iLZxiFJIUaJ04GsJakNRFigM1gmCIstKiuxeLlzuclEUt+KDDEdD/tbfe4x2u8PuZsYT/8X9PPVn1/nNf/bnrK1tIK4EK+jAuxCLMsXoEAEfJysBaZajjWUwLBjuZVx9ZZ37fuAIrlT8wGMnuX5rl1HuCFoRW8zx1dEO71Jd5sv72ZRn6M14HMkgpTXTQhmD1iXOCsqV3n3qIowOcZIDHlaKeAhsbQFWoXSJlRSnYhQa5ywqBMbPMTFaBT4NV/x8E8AVGRtXLzF/4hQ7G6+Sj0aYMEI5i5gx0BzPD4DDR45xsmeQoqAsBW1KsiInSnco0xFzCzMYtY5RClGGm9e2+De/9Rne+4HznL7nBHPzXfI0AyyHDy2yvb3Hxvo6rXabmV6XxXNL2MIxGqXkRUkQRaRphrUFnXaLmdk5lG6RJIJSjtdWNjj10FF2rBDmKZlY7ExJ5hQ7fcV6ptidEW6Eln4uSKlRRjEzO4+omGvXrzMcZPSHKaN+is19fdUoVLgxYDTsogOYm5/B9AIef8eHeee73st9D9zPwWMHMVEIvNV1rB/HdqdLb2aOra1Ndrc3uKlv8Mrll/jilz/H8UMnefihd3H+wYc5fNfdRElc35XaXQu1L5HJf01eUMq7agkVUmSYICBRCYEJee+jj3HvPed4//s+zm/8xm/ytedeorCugZWNvuNq1sCNGjVq1Ohb0dsGlfUai/A6ANsv5rGCLdbaCRi8fv06u7u7KKWYnZ2dOCDDMGRra4udnR3a7TbLy8v0ej0uXbrEiy++yPHjx1laWgKYRLL2+32uXbtGr9dje3ubAwcO0Gq1mJ+fZ3Nzc1K3cWFhwd/hlqaEYUir1WJvbw9jDCsrK6yurvLoo49OImwr4FqWJVEU3eb2qzv5qnOtgF4F5ar909Qv1pIkuW3s6gCwHgdbHbc+tvA6NKtAaX3/att6LG21T/31uoO0Al7VtaniY+vOwnp867RTs97unaBf9VoF0Cp3abV9NSeMMeR5ftv5VGO737HqIFYpNXEo1mNW67Uz69e3fR4MAAAgAElEQVSqOqfpPk+7VyvV297PIXmn16tjVcB6P5dr9V5d+8HXelvTIHV6vOvbf68dlfXvg+8XRyU0rspGoJT6PPAhEdl3MiilLgOIyInvXq8aNWrUqFGjRt9/GsegKjVmlYUP99T4WpB4Y5RgPZiU8b/FegecNthiBMqhwcc+2pI8LynLnGRnh2DYhxuvIVtrUJZg7DhWVKO0ECQtdBigQ43NLC4tEFtgOjFxtES2uYkbjSi09jBVATh00AJxvj4iPkIWE4BWKNEoZb0zTYFyDutGuBwc3mmpTYAxASYMUEGCiUqsc0hRYAd9zMwcYatNWeRYB7YsMVGLbi/hpZWAkSl97cnS+nKeSmPFolBIWSDO18cUd4aXr3e5TMTN8BALd3U4d+xu4qTF7nbG2q0dPvOHz7K6cou8LFHGoNAUNicwIUoUIgpRgtMOVQFLJThXYgKDKEjtiK0bA8LA8MxfXCYg5P0fPk0Uxexu7XHp66s8v7rGe80ZdncyRJ5GaU1kNLqvibsxKgxRrgQsOA+qCTRYhVYG60qsOETGkbYK0HgoJQ5rMwITVTMLh0ZHCSIWrQwoHx2rAJsXrL38HAsnToNziCs9HBfx7jyf1utBOprW7BzJ4iLDGyuM8hGYBGuFfHeT4fYGSwd7ICVKaZwGZYXLr15n5coNDh4+yEd+4n2cvXeZrHBsbm7inCYMNJ12i1trGwSHwKgWN1ZX6c7MECcRtrRYW5JmKRcvXqc/SHFaowReW7mFef9DDOM2ty6/wtaoYLuv6aeaLSOst0vWSiHLBFGarHREcUi+ucuwv8Yw9cBVnB9CAUKlGOWQOUekIAoUsQkIdMy5k+/gv/rFX2Tp8CFMFLxJHOt+qm6cVpRFyfr6TcoiJwwjnBuiteHFy8/xyspLfO5P/gP3nDzHux99nFNn7mXmwFxtDSq1v7XXpt8eg2YdJT7OtxRCBEXC0sISP/mTP8W5e+/jo7/1UT72iU+yu9tvYGWj71u92fq8UaNGjRp9/+ttg8osyybArl7vEJhEqtZrFVbgq3IkDodDwjBkaWmJdrsNwJUrV0jTlNnZWRYXF2m1WmxtbbG9vY21lk6nM3HrVfCxig91zhFFEcPhkFarRZZlkyjYLMsYjUY450iShAsXLpCmKfPz8/T7fc6fP0+n0yHPc1ZXV9ne3qbb7bK8vMze3h7b29v0ej0OHTpEEATkeX5bDch6FGs9SrQCZJV7sHIHVuNTxa3WAVQFdepuQ7i9PmbdrbmfIw+4DdhV414HjtNOxwpelmV5W43NOiSddvrV42unj1OBwrqbs3Kg7nfMqi/VdlXbVZ3QNE0nYK+CtfXzrp9L3bkbhuFtrwOTazgd/Vp3m05DuLcac3onkFm/jvVHHQxPj/G0k7L+fNrVul9/9rtp4Lutvyz9aNSoUaNGjRo1atToeyKlEfFrOxnHlAIoUWhjAIdYX5NSRLzDTTxsQgNaIc5S7GwRKH9zZqubQGjor4/YvbVO1E3Q2+tIPgTcOLrVgjGAQpSDQKFiX9MOgWxziAyGJAcOoA4skG1vY0d9ysn6MoFuiDIaE0XYNEXKHIfFGIVoQUtAGAeUxcjHs7oCZwEDZe7LoiTtDjoIfW3LuI1G4fQQW2aUxYig1SZIM8o0RXCYwNDrRqQqp3AKZfBAUilysUg+vkkahVOGfNRme+8U1/I+mzNHGaUj3v3Evbz05Dqbtwa88MwKly6us7szwBY5Vhy4lN5sTKurKArxrk1RKONdauJkUt8R8cOolQeOP/SfnOfoyQVMEjK7PIMLFBRCtjHky598leHOUS78+cs83HqQm2uXieI+uq0pbQiFI45iEDx8VaC0Aim8q9EYnHZ+LiiFVgqHYEShnAYVIGiUClBGoZRQisXE/piiHQgE2sewOluyfellcCUOS56N6CqDyDihR6xHmuN1WtSZZfbgXQxvXiUrMyIVYVWJG+ww3Nrk6PEjmOhpyAoQjVNCWRYUJayurvNvf+ezPPb4Od75rnMkSczVqzc5feZuCmsZDjKMNhQuo9grabU7KKX5+oVXGA5SLl9a5at/cYXSKsSV5FnOayurXHpac+u1VVYv79LPNGmh6CeO1yhZGwlFCUMr9AtH6SAyIzr4z5oVcCI4VJVu67kw4PxlAwuxGI4dPMlP/Zc/w+z8LFqrcYLu21u/KhS2zBn09xBnx7VFFUWRIUBGwbAYcv3WVZ5+4UlOHzvLex/7EO949L0kHf/bmF8718ik1KFlvS3/HYMBo2JEG5QuIHf0uj0eefidHDp8lGN3HePX/9Vvs3Zr/W2dU6NGjRo1atSo0XdabxtUVrUXtda31R2sAJq1liiKJmCp7uzTWrO8vDypO6mUIk1TlpeXCYKAJEmI45gsy8jznDiOWV5eptPpTGBbdbwkSSaQqt1uMzs7y9GjR7l58yaDwYDt7W2UUuzu7pIkCefPn6fb7bKzs8PRo0fRWtPpdNjd3WVzc5Mnn3yS+fl5ut0u165dY2NjA+ccly5d4saNG5w+fZoLFy6wtbVFr9cjz3N6vR6nT5/m2rVrbG9v0+l06PV6HD9+/DaIV4G3qt5lq9XCWstoNCJJkttAZuX6GwwGdLtdhsPhbfCqGvMkSciyjCiKSNOUKIooy5I0Tel0OmitJzG5VS3NepxtdZ12dnYQ8VG6VR9FZHLcMAyJoojRaESv10NEyLJssn11nOoc6u7FOvys5kAFrJMkmcT0VttWIDMIArIsm0DXavwGg8FkHlVjVQHs4XBIkiQTGFntV3eThmE4gcfGmMmcTZJk0q9qjDudDoPBgDAMKYoCrfUEMFc1SesRrdXDWjuJEq6OV6l6fz/n5rTrslId6E5HDNeBZb3G6H6q15KdBsXTbdXb+GY1Hb/7VvR2APGbafr8pp26d9KdxvFOscLfC7doo0aNGjVq1KhRo7/8UuKjUgWLSAliEClR43hXEYfgHwrBlSUlpQcTpWDyAieCdpZotu3dVEGAxRJ3WojNkWwPiQzYEJHUuzRLUCaAQOOsQwpLpEN0olDGUA4H5NsDXOkIejOICPl2jk0HiAoIABVoTNxCRxEmjrB5BjhckaJMiFJjt5oOkciiXIizBc6WvhKnKynSIa7MMWFCEEYoWigFpd3DZjkmbBG129gyxboUcS1arYAyStnKxINVZ0nLHNGC2BAngjhHbg2j9CzPXdvienSY6ze2CdoBaze3OPfQQV67uc3XX1rFqpywl6MtxBT80t//Ue46Nsdo2Gd3J+PZpy6ws51x8uRxVq5ucOGlPZQYZmZiFg/3OHX2ECfOLtI73KNzsIsoxZVnNvnkx7/K1tYOgYGTJw5w+OwcZb9FWlouPn2J4+0PcH31E9x1zBIZR5kVGKMwgUapGGerNYfxdQ4p/YUTQUqLc6Cs8pUn1djFKoxdkRrnoChGBO02k1qTAtYVGBPgypzB2hXKYR+bpww215g/fLefc86vR3GWMQ0miBLaS0dwCCUlpfUPY3fp37jG8g98gM5MyNbuwLenjI+nVQAxmxu7fOZTz2BMyP0PHiMMFYN+yvLhRfZmB+R5iSoLrNNcvHydV1+9wV/86cts3tr0XFBHGBOgUSSxsOxW+PrvfJz165ukGkY59OOS1VK4MRIGhTByQjExhypihBwogGLsGo0NVIVkNKA1hPixSloh73rnu/n7/+C/4/zDj/j5VknkbcFKAQaDIbu7O+hAYUwESnCMb/QGVKnRSrG+tcbW7jrPvvIkpz5zL3/jiR/j/kfeSbfX89fZf4u8QUvj9eh4G6U1yoAOQDmDUhGHDx3i7/zSL3Pq1Cn+13/8T7h05bXXb3j/ps+uUaNGjRo1atToO6O3DSrrMZl1cAjcBmEqgFnBuupRB0fVj/xJkkzAV+XCXFhYoCxL2u32pL5h3VkIMBqN2NvbY21tjZ2dHXZ3d9nZ2SGKIubn5zl06BCvvPIKYRjSbrdptVosLy9z7NixiTNURFhbW6Pb7XLs2DGOHDnCV7/6VTY2Nrj//vsJgoDnn39+EkW7srLC4cOHJ3D1xo0bXLp0aQJJ19bWOH78+G1uvizLyLKMy5cvUxQFrVZr8v7hw4fpdDoT+JvnOZ1Ohxs3bkyAWwVab968yd7eHlprFhYWAO/ajOMY5xz9fn8CtFqt1gSuhGHIcDgEuA3yVa6+CsRVzsogCCbRrFUcbhXdWsXhJknCaDSi3+9z4MCBCfirrk8FA0WEvb092u02o9GImZmZCeSu+jMYDFheXp70s5pHlZu2AtdBENDpdBAR+v0+xhiCIGBjY4NerzeBta1Wi8FgQJ7nzM3NTeZL/TwqGFudc+XMrTtl2+02eZ5PoPhwOCSKosl51aNnq7GO43jS1rTeistwP2BXfd72i8P9ZrRfROz0a98O9+PbPcZ+4/Nm5zgdMftmbU8D329GjTP0L5+UUo8C/y3wAWAR2ASeBX5dRH5nvM0vAD8OvAM4jP/94lng10Tkt2rHOgFcqv27Pvm+APwK8Ed3eP83ROQX3qSvAfDLwM8D5/H/O/wS8P8C/1wqm0WjRo0aNWrU6K+EBH+TZunGayQ3LgsBaFH+mdIIzgNFseC8q88ojSmtr6foCsp0QBDEKGNwo5RyawtFjsxqJM/RcYw4R5mNkFBQ2sNGdEA5GFLGCaYdoaMQFUUIhjIdYtoxQbuNy+aQ0S5SZpSpoCODCiOfMBlFBEmbMvP1KilLUBoVmDEvcZggRusACQqMLZDSefBqh1ACTmHiCCWCCvzNtDhBxy2CuIUaOrAlkTEExrLnLCKQFkNyBaYMsFJAUVBmKS64lys3Q64Wlk0dQFCSW8dnf/9pjp7vEHYd935QSDoxYZiglGawt8fpR5ZJXEDUCbn7/DydXsDSsSXWr9/i3LuWOfrUdY6cPEt7sUV7oY1O/I2u1y5s8+rnrpCpjFMnDnDffTM896V1jAl59WsrPPelFaRU7O72CUeWxdY8yj3E5s5XCE1KYg3FcEBvYc7Xqxw7JiduudK76ETsuM6kjEGSxuKwrkC7CGdLX69TZaA8TPY5sA6P68DZkiLPyDbWuf7lzzP/4LspnUXsOP5VjeceTGoi6iCgu3QIE8YUVpG5DIci1LC5cpGTH3qCmV5Mcgt6s7MMs5S9nRJrNUorlBPSQcGnP/Elrl46yvGThzl2LCHPcuYWexRZRtof8cqrN3jqqdfo7+aIFUaDFG0CosT/RjTTdiza68yuPsm1m1vslmB6sF46rqSOG5l4SCseUlars3h8Silg8TGvkRaScJyaZAENuQPrAK04dvgQP/bjP8nx02dQCorSYkqL9mm4KGNeh5XfUCty3w88IsLW+jrXX7tOlBjcgiZpxRijsGJxrkShMdqgdIbWiiwvePbVp7n0r17hwXOP8KEP/QjnH3mEuNXy68/pWNhxO69fR/+QcRSzDgyuLFFOiKKA+fl5fuSJv4kJDP/0//i/eO75l970JudG35+qrWd/A/hfgP8Z+CH8OvnDwH/Er0f/NnAfflK/APxL4P/Zbz2qlDoH/Pfj/Q8DO/g17P8nIr/2Fvr0j4B/DPwZ8OMisjl+/T3AP8Kv4w8AN4E/AH5VRK5PnU91rNvW59LUw2zUqFGjvzJ626CycvjV3YL1uofTtQbrDq79Ij7rtRPrka6dTmfyHJhAswquVTCr2+1O3JEVSFhf97EWURTR7/cpioIrV66wsbFBWZasrq5OYKYxhoMHD07chfPz8xM3YgU/T58+Ta/Xo9frsbGxwYMPPki322V3d5dr165NImyXlpYmkaV5nhOG4cSJZ4yZuCD39vYmTsUK5gZBMIGCa2trXLhwgYsXL7K8vEy/32djY4PFxUWefPLJieNyYWGB++67jwMHDvh4nSSZAMsK+l26dIl2u42I0Ol0WFpaIo5jXn75ZUSEpaUl5ubm2NzcRCnF/Pw8N2/enECfdruNMYY0Tdnd3WVubg5jzAQUzs3NobUmTVOMMRNoWkW25nnO5uYmn/rUp7h58yZPPPEEp06duu29j33sYzzxxBOcOHGC69ev88wzz3Du3DnOnDkDMJljWmu2t7cnYDDP80k9zSiKJu7ZoiiYmZmZOC2reVK1WbkdK5dlp9MhTVNWVlYYDofcc889E0hcuVar+V6PNw6CYDJXqus8GAwmxw/D8BtiXau/d4JebwToqs9SFb1b3+7NnIKV6lAPbncQTvf1TkDvzeDhnd7/ToC+aUj5RhD3rcDPtxLz2+gvh5RSfxf4NfzvEf8eeBk4CLwL+HvA74w3/TXgefzCbBVYAD4CfFQpda+I/E/j7baBXwV+Abh7/LzS5fHjV4F/OH7tn9bef/pN+hoCvw/8COOFHf63lB8C/k/gPcDPvbUzb9SoUaNGjRp9P0gEnHKItYj1sZ5KK9AaJcqzJXFjR9TYFyXOGyfJaScRjAYgBW6U44xDYcFAa2kBU46QNKXMRhhAJQmMHNbuIcohztfvc1aweyMER9QzqHGNTLElrrSoICTszgKOIu+DzSlHKSpuoSODDgOCVoLYwkNX67yjshCsKzFao1Tha2paQSkDgUHZErFC6UagLCqYQWmDjrtIPsC6nMjMYeKEOC8oRRCtacWGdLcE5yiNoaAgmWnDyNcwDMMeW1unubI9Yq91nLx0qCgi6VmWzltc+wrbw4LBK4qs77DWEMdtsnSPrWv/mh/7yPsJI83KlStcu3yFjY2DHDy0jODQwQ5SbPMXn3qVG+sF3U7M0TM9Tp89yLHliBeevMWewF2PHOHeM8cZDAvs0HLphVWyQYYONVoUz9iMx7rn2Lz1Ar04J5rt+thcowmMwZUWl2ceE2gf30muxzU7fYyrE4XG4WyBtTnKBShbomxBoDSlROgkpl7X0LlxvUpnyXc22fjCZzlwzyMEnQRnSw+MdYgKQj/rBCrAObN0lCBIcHmKM97xm5U56bVLaK04euwAWxsj7n/oJGjFM09e5Ohdh5idn0NheeXl62zvbPPkV17l2acv8fVnV3jHe+/hhWdXuXHjFlmako4gKwpc6VDKkBVDWqZHHEScON4h3rmAfvmrXF/bYScHZxxre8JKIWwWjlhrRAmlq84YIkAjpGOQGGuYCcZxvgLtVogTSz8VrBNSEZZn5/gbP/wRzj5wP9YJeV4QmIKi8PHG1lo67TYmDnxdU62/gVO6cYmfsigoywJnHUVe8NprK2zf2iFKImx2gygKiVoJSSvBRBolJU78zQSBCQm0Hd88nvPFJ7/A8xee4ZHz7+L9H/hhzj/8MHG7NW6xBpgrR6yMaW19nSqCQvuaouKTqXozs/zoEx9haXGZ/+2f/O/86Z99haL8xhurG/2V0Wngz4ELwG8DLWAX+CjwM8AK8Ov4CfWTwD/HA8OfrR9EKfVjwL8BYuA/AP8amAMexsPLO4JKpZTGr5f/a+D3gJ8VkXT83i8B/wLI8Ov4FeAs8HeAH1dKvVdErvLm6/NGjRo1avRXRG8bVFprJy60CjRWcaFVXcB63GgFG/erq1fBkMrF5py7zcEXRRF5nk8gVR14Oufo9XqTmE3nHHEcc+DAAURkUpvyxIkTlGU5iQYdjUZcuXKF2dlZsixjdXWVJEk4e/YsTz31FP1+n16vx9LSElprjh07hrWWLMvY3t6m3+9z9epV5ubmmJubm7QvIqyvr08cdXVnXXVu9TGpoG3d1Va5+LTWnDlzBucc73znO3nllVdYW1vj9OnTEzB7//33c+PGDZ566ikee+wxer3ebTUwtdZcunSJl19+mW63yzPPPMP999/P448/zmc/+1l2d3cn7sT77ruPLMt48cUXOXDgwKSPDz74IHEcc+3atYlT9fTp0xw6dIjLly+zsbGBiNDtdjlz5gy9Xm9yLauoXq018/PzPProo3zyk5+kKAqCwE8/YwzD4ZBTp07R7XYpy5LRaMQzzzzDzMwMJ06cYDAYTK55BUQrZyUwmQdVRO8DDzxAURST8W21Wjjn2N7ept1uE4bhJFa2motpmpLnOS+88AKrq6ssLi6ysLCA1po4jsnz3H9oxk7TNE0n9VDrNUHTNOX5559nYWGBs2fP3uaqnIaUbwTEKuD2ZnGlbxTbeidNH/eNoOIbuT7f6PjfbiD5VgDhmzkqv9U+fSfOq9Hbl1LqPH5BtQs8LiLPT71/rPbPB0Tk1an3I+APgf9BKfV/i8g1EdkGfkUp9YPA3SLyK/s0/StjhyZ3eP9O+h/xkPKfAf9QROy4Hwa/SPslpdTvisjH3uggSqmv3uGtc99EXxo1+muhz3/+89/xNvb29r5rbTV666quS6NG32spEZwV74BzBU4cWgxGDGiHlNbHcAo4Z3EVeHCO2FmCokCKHMThxFJkO1DGBFGEmW2T6A6yfh1bWMQNobCQhEjZwpXi2YU4TBKjQ4XkKWI7/z977x4lx3WYd/7uvfXq7umeNzDAgCABAgT4gkhKoChZshTKlqyVvJIsO7a13o1fJ2vvORuvk7W1ie3sH8mJ9zj7iJOsN2ftzXE2ts6xraxjO4qsSJYoWhIpipT4APgAjfd73tMz3dVVdR/7x+0qNEYAH5Aok0p95wwa01V9q7qqBpjbv/q+D9VoErYa2EJj8oywESMaAco0fHyrNbjC4rIcggYIiVQBMoqRRnvAaY13R1ImyQRIZZBK+hJAFWCsxgHa5OhBH4QgiFsIJZFhEywgHSpuEmQaJwRGQCsShAJMoBBWkNBEFYIg6OBEzmZvG+eWLKthh00jEJGgMZMzf49hceUyy0/H2HQWaSN0lvkI0HYLOxjnZDfj/MElZGOdzV6fbdt34KzGWUt3rctNe2+iEQe84127uHx2k4mZSfrdnP5Cj689fJq5bWPs2DHOwrk1mu2EXQemmN7RZNv8NF/5i2OsrfYwOue8lVyKAhK3n43+EZptgwxDit6AaGIMhI/ndc7H/krnMMb6aFs3NEgCFAIbGZwzGGeQIsJYQ57mviMz9J+lIIbn2zoP8vIMU6QUvXXYWCdod7BaAw6pIpyn1QDeu+mgvW0OwpCsv0E4vFZtVhAWfdaXl9i//2a+9qUXaY93KExBu9Vgdts4kzMd8izjzrt2s7jc4oWjF5jZ3iQK4VP//qtsbA7YNj2GLnKslSgKtPEOUGctcRDwpkPbCbJz9J76BksL66znFiMd563lROYYWEiURClIiytoNhQesg6GEbChgMDBQDsGhee/QllyA9o6cgtT7TG+//u/j1vvuIs0zdns9QkDRRAG/naBAoo8RxuN2PTwt7u5weLCJc6ePcOlS5dZWV1gs7fBIMsp8hxrDYM0ZXV5ieMvHifP/E0FfdlnUxhkVxEGIY1GQmOsRRAJnLPksk+gQkIVURhfL5PrlIcf/yxPPv84b7nr7bz/Ax9hfu+eK59fCBAOnAz8jQ22QAgJ1mJtAdbXzSCG0c8mI4wiGkmDt7z5fn7tV36N3/hff4MvPPQVtNZ1BOx3p94B/Lpz7h+UTwghfhwPKb8BfK9zbnP4/K/i04M+JoT4lHPuE8PnZ/A31wbAg865L45uYMt8my3LEjwg/SH8/PcXSremEOI24F/hQeO7nHPnR173HuA/Ab8JfOQVzs+vtw/f0ry5/t3+iur5zqtTfbxenerj9er17Txmr6d58w2DyjKetYQ3JYQDKsBVgsoyZhSugI9R4Fj2+43CmxIwleOV45d/L3sWy57A0rUWxzFSyipatNPpXNUrWAI0Ywx5niOlpNlssnv3bpIkodFocPPNN9NoNOh0OiRJwurqKv1+n8nJSay19Ho9ms0mp0+fptvt0ul0Kudluf0oiqr42nKfwbs7Z2ZmqhjbskeyBG5bj53WmiRJmJub4+LFiywvL1f7OT4+zj333MPRo0c5f/58td2VlZUKsAoh2LlzJ5OTk5w4cYJ77rmHu+66i+XlZS5fvszOnTuZnp7mqaeeIkkS7r33Xo4dO8aFCxe47777Khj8+OOPE4Yhe/fu5dy5c3z5y1/m0KFDPPHEE0xNTdFsNjl27BgTExOMjY1dFf+a53nlZpyZmancpkEQ0O/3OXXqFI899lgV29poNNizZw979+5lMBjwpS99iXPnznHnnXdyyy23cOTIEc6dO0e73WZ+fp4777yzOk9f+tKXqvcehiErKyucPn2awWBAu92m0+mwZ88eut0uR44cYTAYsHPnTu6++24ATp48idaa22+/nZmZGfI858UXX6TX61W9oOWyXq/H448/ztLSEs1mk3379rFnzx6MMVy8eJEjR44wNzdHs9m8ppvylWoUYm91Kn8reinX4auJXX258bfqRkDfK9mHUVfptd7b1u3e6P7VjsrXlX4e///YP9oKKQGcc+dG/n78GstzIcT/iY+weQ/w/75WOzq8m/S/By4Bv1hCyuF+GCHE3wN+Cn8H60uCylq1atWqVavWG0dGWpyxGKexziLkMCFlGFoihATpeyx9sqTAOnBG07QFUXsMUv8BgrAOZwpsL8MVCY3WNEEgyIexjzJQICTZ+jJF2iXf6KLCcYzJCaMIAoEQChEqlGwSjHcollexRQZNgwgkMokJdItikCKcxeYpqtFABALnBCqJsNbhUN4RqXNAgfCwxBHhXI6QAVgNIkDGASo32CLHpBtIJEGjCUGA0wXWaVSUEDQsWEuepSQI4lBC0CQKYgIpMUbgnCYfWPr9eY6vbZDfdBC3sU482WP2UMqZ82vk5+Zpq0nGZgJ237yN+f1TzN00wcTsBCeeXeDRh48iwoALFy7Q7/XYvXsPgRJEjRa37NhJd2WFMIyY37eLu97W4OLxS5x+/hLHn1ulu7rJgYMz5IVFKUlrImJ9tc+JY8vs2jPBW952K1/43LNYBbm1vLDZ53C0j8WlZ5icNIShotASi/BxqQG4wmK1xeHdqRZwwndOSjecnwiJdRKJxegMPQRQamwMFcQIbf1rhAbpb6LVeYrRDozBdrsEu6nnQfEAACAASURBVCRCSixl/LBFIHACT0WFpDE1C2FCmhfI0DIWKCyacd3D9brMbJtictrPb52x3HXfbYxPjIGE6dlJFhYWIZzm2afOs+fWm2i1Gjz7wgWUg9vv3EVuLNI5giji/LlFTp9dZXJqklv3zaDkMpvPfpWFMxdZMw4hHeeF5cXcUVhHKASxgk3tW10BAiEIJAyMj8mNhKA1NKemFnKHX64thYVUQyih0WnTmphkvdulsbyI1jlpf5L17hpRlNBPe5w+fYKLF85y6tQJzl44zeLCAoXJfRWodUjlQaOPYZXoIqPILd31FV/N00oQQGE0xloEltQM6G30CdbWabRiWu0mMhQYJciFv9FaBSHa5Ayygt6gz3/6yp/xzHNP8L73fJjvfc/3Mz49fQVW+p98hPKuWoFDWouxOTiFNdZfT9qC7RFECUkScc+he/iHv/JrBOqf8Nm/eNh/fnONaa4U/rM6V6PMN6Iuc7X7EOCnh4//UwkpAZxzPSHEx4HP4R2Nnxgu+ltAB/jnWyHl8HXntj4HIISYwrsk3w583Dn3G1tW+XkgxMPL86MLnHN/IYT4U7yrsu2ce/18gl6rVq1atV5T3TCoLONXsywjjuPK6VZ2FJaRmY0yU59vhiyjEZal68xaW/UfhmGIMeYqZ1wJF8s41SRJqv0pxy3BYOnILIqCjY0NoigijmOyzPdhjHYRzszMVNu/9dZbiaKIwWDA7t272bdvH1rrCoYGQVA56UrIumPHDmZmZlhZWWH79u20223CMKziOUdjbdvtduW+LKEeUC0vI2C73S5nzpxhfX2d48ePc/r0aRYXF1lYWKDf77O4uIi1lsXFReI4Jo5jlpaWePzxx7nllls4ePAgzvluy6997WsEQcBb3/pW+v0+S0tLZFnG5OQkURSxf/9+Op0OExMTzMzMsG3bNg4fPsxgMODChQv0ej3e9KY3cf/997Nz504+9alPsb6+zs6dO1lYWKgiaJvNJlmWAb7Hsow+LeFk2UuZ53l1nufm5rjtttv47Gc/y/d8z/dcBchOnTqFtZZ9+/axfft2nnzySb7+9a/zlre8BYBvfOMbNJtNDhw4UB2j+++/v4p8/eQnP4nWmltuuYUnnniCRqPBxz72MT7xiU/QaDQwxvDMM89w8eJF3ve+99HtdnniiSe45557KqfkyZMn+fSnP83BgwcZDAYsLS3x0Y9+lIcffpinn36agwcP8sgjj7C2tsbc3Bzj4+PcfPPNPPnkk5w9e5YDBw4A14aU1+uF2BqfPKoS2m+FlS8H2EaXbx3zpUDqjYC5vw5H5eh1sxWybnVwfyvwtXZUvq70wPDx0y+3ohBiN/BxPJDcjY++GdX8t3fXvkm34Xs3XgR+9TrXUYrvCXlJOefefK3nh3eM3vct7GOtWt91eve73/2ab6O8i/E7sa1ar1ztdvuvexdq1QJAOUlhCw/07LBrTkpA4VwOSIRTIPIhdTDgLFJArDOckEilIC+G7kjfX2n6m7g0QUxOeSjoHE4XqGaDME7Ili8ig9CDUG1QYxEyCHAShJRIFDJuglrHZjkmGxAELWQU45ICJSy2yHFFjh2kyLEGQgUI65DKYJVBqOEczzqcdhiT4QIQElxQIEWIFACWIGhirKQYdDFsECtBkLRBRSAiZCAJWk10PyPTa0hjmO+0kFKBAesc1uYYo3HMc2bBwPQtpBpak5Kb3pqQiwHvuPf7mP7eHezcP8v0TROkPc2Lj1/i6LEV9IurzE43eO9H7mFj+SQPvvcHOH/qFLrI6G1mxK1Vzpw5TrPdZqozRRAGREnIzXfsYvuebew6uMS+2ydRCDa6BWHcZHUlY/dtExx/boWp2XGyTcOdh27hhefOobOcNaPI4pCidzPLq8/TSHYiQkna7ZO0IuwQRMogojAWh8HaHGcFTjiMFb5r1HpIKwlQIkAKiTYFcdL0YNs5f16dwqBxOGxRYIZfdn3VR/VakGX6lZDgrHfwOgBH3BonbEyQ9k9ggeYkSAUm63P0K1/mlre+g5//xR8lSx29zZQ0M2htyfOM/saApfOruEDRSELCIMAaw44d41w4u8LS0iqIEERBZ7zDzOwYFy+ss2//JJcuHCdZukB67Bib1qIFXLCWU9qhrUMCgYD+EDgy/D4UjoHxuz8WBUxEEokhyz2gU0NQuakdhQaEQxs4c+Eyjz/+dXCCPB/QWGlhjWF1dZVz505w+tRxLi9dxCFQMiBOGgShRIoAayxgKQqDNRpjBNYUaG3Is4wiLzz0Ew7rBK6waGuHh9pR5BYx0KSbA9bXNmi2mox1WgRRQBgGFFmKCiNU4HBGYQvLmfw0v/fHv81TRx7jfe/9CIfefJik6T8Lu2ruLkOGJkuMLjy6dBKhxPA4WgSSIAw4cOAg/+Dv/wraOh566EsUxTc7K5uNFnmRkxfZa/VPZK3XTk8557aeuPvwPvaHrrH+F/F1KveOPPeK59sj2g58GdgL/ETpztyitw0f3yWEOHyN5dvw9xvcBlzPFfmy+lbnzfXv9ldUz3denerj9epUH69Xr2/nMXs9zZtvGFR2u12MMaRpytjYWBV9WTrw8jy/ClJJKQmC4CrIAlRAsey2LCFn6ZIsoVfpQCxjTUchYOnaLB2MZWxso9FAKUWaprTb7crd12g0SNMUIQSdTod+v4+1liRJKoCotb4qerbsWoyiiNnZWfI8J4oims0maZqSJAlSysoxWMaDlvtfgsryvZXxtuV2yvcSxzFRFFVg9NChQ3S7XaIoqpyexhjGx8dJkoRLly7RarWq2FRjDOvr65w6dYp9+/ahlOLYsWO88MILbN++nc9//vP0ej0efPBBTp8+TZqmTExMVFG+ly9f5vTp0zSbTR599FFuuukmWq0WRVFw/vx5Tp06Ra/Xo9/vMzY2RhAE7N27lzzPefTRRzl79my1b2ma0u/3K5CdpumVC29LD+m+fft4/PHHqw7S8lpZXFxkcnKSw4cPE8cxly5dYmVlhSNHjiCEYHFxkdOnT3PbbbfR6/WIooj5+XnyPGdhYYH19XU+8pGPcO+99/LYY4+xtrbGk08+ycmTJ/m5n/s5Dh06xGc+8xkeffRR3v72t3P33XeztrbGiRMnGAwGTE9PMzc3x8TEBB/+8Ic5d+4cX/nKV8jzHKUUFy9eZOfOndx6661Vx6kxht27dxMEAefPn+e222572Z7HrWDwWu6/Ufh2rUjYraBu6+PWsbZue2ss7ej+XU8vBe2u9drrQcJrQcYb0ctF2Y5u76Ug8cvtY63XjSaGj+dfaiUhxF7gMWAS+Et8lMw6fiJ2C/5O0fg120uv6eHjfuB/fon1xl7j/ahVq1atWrVqfQdly/mvdT72VQU44R1Kzkqc0z660fnOR4vDOI3MB6i8wCJRkuF6Dt8l6BBGY3vruHYLh8DmBSbL0DZHtBSkfYJYInA4bZBKIIMAlKg6MIUAEcXYfoHe7CGjEBnHyChEGYewzu9/kUMW+OVBiFAFQjrfNSkDnC0wOHAaq3MCGYFVWOkdo1IKUAqVNLBao/MB2caqn/M3xvz7thaLQFvNYDPF5YLd0y2ksARhhM5TijxFEpHlHdb6sPs9B7lj1yw77urQnI+xMmBibJKFE+s88dhZel86ThA7ppMEvbzC8uqAleMR58YC4sZlDt1/gHzbdow1NNodzpw+yb/8zV9nzy0H+cVf/lXiJAEcCEHSjNh7xzw337ad/kbK0a/+FVkv59iJBS4vdJmYaTIx3aC7FHHr/ikWLq+zfLlL7gwrQtKUsyyuPM3sdot0mt5aFyGnUQokEuMszlpwIcKAsGbYXyoQFoxPdkVaSSilb5Q0hrARIZwbXhsO5wzYYeNp4SGiszl6bcmfT1OgVIg1GdIq77AVAicMAkHSbBO3O+hC4LQjG8sZCx0RjvTJL/LMqaMEnSmmb93P7Pw8M9u2E4+NI1RMELd44IG70drw3gfvp7CGtbUuc9unOPrUCZJEkTvN4pKm3YaJiQnuvrvg2WefpLdwkdmVMzhniEPB2cxwTjs0/pIFQWYdo42KDsi8oZFmIJhoKIyx5NrRM577KwGpdt41ypUaR+MsR59/jrF2g0tLF7hw4RIXL5wjTTdwLicoE7uSGBdYTC/HMoS6+A5SYx3GFsPIZonVhjwvcMNIW+MsxrjhngrE0CWLG96wLIHcMuh36XV7NMZixjoTRHFAVmygVEAQBoSBIrQNjLE8cfSrnD53mnc9+3188Id+hImZGa5Mn30ELipCJQHWpeg0reorcyeJrMNZnxsbBooD+w/y93/5l5FS8NnPPuz/rRrBlb10k9pM+YbVpWs8Nw6sOH+XzFVyzmkhxBIeEpZ6RfPtLZrDuzDPAV+6zjrl3PiXXmasem5cq1atWv8Z6YZBZbvdptfrVa65EkoCFUzr9/tXuerKSNOyLzDP88qlOOomLKGeMaaCgyXgTJLEZ/bnOc1m86qexxL4NZvN6vsgCCpXZfmc1rra5mgUbJZllUOzjGPN85xer0eSJNX7KbsVhRBkWUYYhpWjs+wyVEpV/Z3W2solWTpOS0BZFAVJkvg764ZOwyRJSJLEx34oVUWibt++nb1797K2tsby8jLz8/McPny4Olbl8fngBz9YuVsB7rjjDubm5uh2uwwGA6ampti5cycPPvggTzzxBI888gjbt29nfn6e8+fPI4RgY2ODp556iizLOHz4MO9617v4whe+wJEjR4jjmAMHDhDHMQ8//DBjY2PMzs5WTtVRIOyc7yxttVocP36clZUVut0up06dIo5jdu7cydraGmtrawRBwMLCQnXMVldXefe7383y8jIPPfQQb3vb21BKceDAAd7//veTpilra2vs2LGDKIoAqmuwBMLr6+uMjY0RhiF79uzBOcczzzxTXcNZljE2NkaWZRRFQbvdJkkSWq1W1Z3ZbreJooipqalqvDiOedOb3kQQBFy+fJlnnnmGI0eO8M53vpN+v185SMvrcxQYli7c0Wt8dB3gKphfQs6tQLEEbeV5Lr9/KdA3+ppye9baCgxfS9cb71rw9eUg3vWcnNdabyu8fKl1R8d9OZfpKOS9lsqbJkZBbjnOaN9ordeF1oaP88DzL7He38VPhn7KOfe7owuGPR1/6zXZu6u1Pnz8Y+fcD30HtlerVq1atWrVej3IgTUOO0z9cU4gUQhn/Of/w19XhQWs8qjBOVSxgXA54WSbMJ8g39zAGetfZxwylNjBgGxpCTXWRmV9zGYPhMFllqLfIyDAhQ5jHDKMcFIgVQAqRGAQUYDw3ARjDdZYhLWIQCGj0MeBWgvG4bIMAoUTAqEkAgnVl0IoC06C1RRaI3EIJVDKR5aCQQhJEDdwtmAwSMmzi4SNNlFrDBnE6CKj309J++tII5hthh5sKg3WoJzEqQbrGxEbgSSLFJ3pjOPHVrn8pT7aGabnm0zMNNm1K+a5ryyQh47FOKe7allZgvW1RdJ+ytRMzt1vOsvcrjlMromaCWGYMN7excTkQdY3Bly+uMT45BhREhEEyr8fEdDqjPGW99zFxeNnefb551hbDjj69CVOvXiBu+7bzd47ZpACPvvpM/Q2ljnVG/BAZzcXLjbZ2FhBdhLCKGaQDeh0xrBG4chxxmBdjnXWx75af/1I6RDSd1Q6J3AobD5AGEvcnvQRoDJAGIt1FieooKQzAufAri0TigBrCnAShfLXprP45FeNFIowadKY3o7VgiJzDLKMqcYEURQwxybLlxa58OQmz/zZZ9hEYMKIqJUwPjHOxNw2JuZ3MNaZpDM5zez8Tdy8bQaxY4a3Hr4NoQKQIRsbm1y8uMjTTz9PL13g2LFnuXMipmlTRBueXnWc1Y4MD9h8q+Y3z93M8KlQQBwINno+BLlvHWbknlRX/XG1NjZ7/OVXvgrOIYUhjgRhoJAKrPEuSK0NQvoeTQFD4OmQeCgqsf5HxFqMBWcsUgS02uP0epsYk2Gsv2FBCA8tBR4pWuOQQmCMI8s0g4Fh0MtJmjGNsQZhOEwyCxRFmFGEEYVuUujT/Onn/4hnnz/Kj/3oT3LHvYcI48j/Y1LNfxVho4FUgrSXkhU5Ugp07ogCHyWMcBAK7rj9Tj7+S79EmqZ8+StfQ+src976Jt03tK518taBKSFE6JwrRhcIIQJgBuiOPD06337mFW73KeB3gN8FHhZCPOicO3GN/QAYd851qVWrVq1atfgWQKUQgkajUbniiqJgMBiQ5zlxHFdAZjAYsLi4WIGkJEnodrsV/FlfXycIgquAZdnz2Gg0Kndk2UXZbDYrt6JSqopvLbdXQsDS4am1ruBiCWfKONper0eWZVVUbBzHFUwtxyvHLKHnaIxtVWQOFaAchUWla7AoigrqjILRrWOU3yulqrGu5YYr39/Zs2fRWnPrrbfS6XSq7ZUO1hKwRFHErl27Ktdn2Su6a9cuduzYAXiwV3ZI3n777Vd1gAZBwM6dO/nQhz5UOVG3b99eReCurq5SFAU33XRTFZtbxry22+0K6OZ5zrFjx+h0OqytrfHcc8+xubnJ+fPnWVhYYHNzk4cffpiJiQk6nQ5pmtJoNNi/f38V4bp7926efvpp/uRP/qQC0Lfffjvj4+NMT0+jtWZjY4O5uTniOGbfvn384R/+Iffeey+nT5+m0+nwzne+k5mZGb7whS8wOzvLkSNH2L9/P4PBgIceeohjx46xtLTE5z//ee644w7Onz/P6uoqp06d4oUXXuDUqVMcP36cxx57rIqaLa/j8nifOHECrTWdTqeCW6Xj+HoRsFuh2ihIHH0sz+3o9XAj3ZcvpVfibBx1JI5u/1uZzGy91rfC2uvt6+jjS433SjQ6Xnm8t45V63WjR4G3AO/npUHlvuHjv7vGsndd5zUGQAih3Eif5Jbl0SvcT/D7twY8cK2JYa1atWrVqlXru1PG5OCMB5U4ZNUrJ7yjkdHfMV0FRGI9QIoAl2WIQPlXCIu1GodGCeFhR9YnCANkHCMUuFCjV1awukAFCRhNEIWoIMA5EEohlQAXINwQWCBwusCkKVIppAqRgcBGFqG1/7jbF/MhwwRCgSYdQlbfbahEiDU52hkMFukyQtfAEQ7fkwQlEFFMKDpYK8h0j7TXJdMDwqjla2DyDF1YhIBYSYKwidMFWFBBhCahlzXQY3OcfXKF4+e/wfjuPlPmdoKszeZxy+rza7zj+w6STHZw6SZ7d46z0kyRep2lCxqjLRvdkKPPrLO6CuubPc6dWiULVhifu5eLp7fxW//0IcYnGkxMKG69bTu3372bqblJWu0GYxNjhIHEYEnTFd72Pfdx8Q82OXr0Egfvnqffz9i5dxrUaZxzrKU5otPBuVlW1k8TT0S42JBtaJqJP2/WaN9/aIyP8cViXHl1CLAOZx0Og8BhrcCanLA5htUFoDygFAJrDQLpI1+HrML21j2UdgJnDdbz8OH43ulnnUEqSXNyG06A1jDoCfS4d862pKYINIOmJtAOq6E/0KS9PmZhiZUTx1mTgkILnAwIkxjVTJBJg7GpCRoT40zunKOzew/LxRgw4LGvPUYiDXNxim7C0VXLucKSVubDl29HLBysDq6dlvNScvjPQUIpIIC88MDey1/3Sooh+/OPUkis852zEjFcLslzN+wYBa0L0mzZu5Gdd0DbobGyfC9SeJenc47SqGmNQ+eafl+T9DJanSZR00fNFhqMERibIkjouz7Pn32G3/q//ykfeO8P8eAPvJ/WeGc4Z3V+n4VExQkJ/vM6a4bza5sTqxikQzqIo4g7D97FL/6d/4FB79f52tefxtaA8rtV38BXoXwv8Bdbln0vPm716yPPPQr8MH6+/eevdCPOud8TQgzwXZclrDy2Zdw3A+8EPvUKh325+XmtWrVq1XqD64ZB5agrsYw3LSGY1rqCYmEYopRifHyczc1NjDH0er0Ktqyu+siX+fl51tfXWVtbo9ls0mw2CcOQ9fV1sixjYmKiAonldgeDQQUmy22V2xuFlqOxs6Pxq+VYJYwoAd6o+610T5YRs3AF4pQwtHRVjsKUoigqp1oJaUedcCWoHIVR5TpCCAaDQeUsLB145d937drF3NxcBamCIKDX613VE1q+Bq447gaDAUAFZksYWX6/ublZxc/meU4QBFWnZBAETE9PUxRF1d2olGLfPv/5f+kiHQwGnD17FmstjUajcjgGQcCuXbvYtm0brVYL5xyDwYAoiti3b191rEpAG4YhDzzwQAUjP/axj9FsNpmYmODmm2/m/PnzFEXB9PQ0O3fuJI5jZmdnieOYkydP0ul0iOOYj370o3z9619nYWGBHTt2cOjQIWZnZ/mZn/kZHnnkEZaXl7nrrrsqt+bly5eZnJxkfHyclZUVLl68SBAEvP3tb6fX6zEzM8N9992H1prbb7+9isTduXMnb37zmyuAvrKyghCCHTt2VLG+o+e3vA7K66kElSUg3wrYymumdOeOXuPla0ch6HdCJYAd3e9v1x2X13I8vlx87qsd/5Vuf/RnsNbrTv8X8HPArwkhPuOce3Z0oRBil3PuHHBq+NS7gT8bWf4+4GevM/by8HE3cPI6yw8JIRrOufQay6/SMErnXwC/BvxzIcTf3fo6IcQOYHLr+6hVq1atWrVqvXFltEYbjbYFUvgoVoREDBGSEw6LwVBgnUE4HyvZGPQIVJNi4QIy6+FsjjUWV2T+9+8ydcRKbDYAbRBWI6IEvdnDWEcQx+jNDcJm4sGFlAgpvfOxTBkxPt5VigCrPXQUyoMmBVgEzuhh8eTQsaUcIlRYbXDCR6N6p59AECCFjzE1pvDvEYV0OTIICAKBVJKo2cRs5phBhnEFJje4IEIbg8X3CiZBTiAlUgiEUphCU2SSNIvZjBtkeUqcpBx98QgT6TRhPmBtpcuuvdvYXMn4xsMv8qbdBTOdk2yfmWXf3ls4dWqR/ppms6v5wqfPoBQUeU4Qt+jMF+hwA8sOsg1B2huwcAGUyhhvbXDm2WWeObJA0DJsm4uZnFDMbpsn3cyZmxvj8qUFHIKli13WVnPSzT6IgDyO6BYF7bEdFOkJ5CAE7UBbtNUEws9zlAxwCLSzGOuwRvpjrXypHEoiUOhBD1MYjM4JxiZwzgyZscFfWcP5jCmwFkIVoIoMN+jDuO+pNC5HmfKGanElflgFtCanAYmxhjRzZPkA3YiIw5hWnNDp9HBY8gxCZWn5e9crqGe1ozA5eqAZ9HoIJ+idOc+qgdNByMrcTZylxdhkSN5d4827IuLBCs9tas4Z6OMjkEfB3muh0tnowPdX4pCFB4hS+C5YJUEI569tCRLvWDXGw0AlBEEAufbxu8YNjcjO4dyIE9Rd2ahzDLtJh+d1uNxJcMaRGRhkBemgS7MV0mzFREmEMRnWV9iSOIEQiqXuZf7oP/weZ8+e5r/8yI9w0749V96gA1AEcZP2hGXQy0j7KUUB2D5Js4US/ryHYcD9hx/gF37h7/DxX/lVzp69+Boe+Vp/jfrXeFD560KIdzvn+gBCiCbwvwzX+X9G1v83wD8Efl4I8e+ccw+PDjYy3/4mOec+KYTIgT8EviiE+D7n3NHh4n8J/G3g/xBCvLgFYiKEiIC3Ouf+cuTpl5uf16pVq1atN7huGFQOBoMq8tRaW/U1lm5KrTVZllUApYSI4+PjdLvdCgSUUaibm5usrq7SarWqnkWA1dXVyrU5Pj5egb9er8fa2tpV/ZdlTGcJHeM4vsqVGQQBy8vL5HlOp9OpehRXVlaYnJwEfBdmuf+jLrdRmFiCyjAMKxhadlWWwK6Mui1h59Y+vK1RkuXyEkiVcLDc3ig4KeNU4ziuIktLlVGipa7l2ix7FEvQWXZxjr6u3K+1tTUmJycrCFmC6bJLM03TCmgaY+h2u5w9e7Y6DuVxGx8f584776ziesvrpYSV5XONRgPw4HNycpLNzU2EEMzNzRFFEVJKpqenmZmZqeKDoygiyzLm5+e5++67WV5eJsuyatz777+/6lEtHbSzs7N86EMfqmKJy2PwgQ98oILa5bVVOlxH41GTJKHRaHDgwAGazWblmi1B+JkzZ7jrrruYm5urINfoNVTCy/IYbXXvjWrU0TcKyUtAOBofe73exddC5T6XkHIU5t+IruXG3OpuvJF9/HboRrdf67WVc+5ZIcR/B/wr4BtCiD8BXsTHvB7Gx9b8DeC3gJ8C/kgI8UngAnAX8AP4idOPXmP4vwB+BPj/hBD/EUiB0865fzuy/DDw50KIh4EMeMo592fXGKvUPwLehIerPyiE+Dy+72Mbvrvye4BfAWpQWatWrVq1an2XyBmHzgofrRk0PQgU1kMMpxE4pJA4LFjfTylMQUtvksgMufiMhzbWhzlIFQLSu+JQPjM2SxHWIhM5BJopUSP0iTvGEbUTrNYgFQaDUAoRSO/01BnOakANYRU4KUFrRAhCJpBnvtfOGpzWOD2cBziFQyOFxeIjYxUCjMapCGM1xmQoEg8jTYEzBhW3vLOy0cQ4MFajTQEqwFmLwxLHwlekmAFCJj6yVEiyrEmqHUVDUZg+ExMKuxxi0gYby10KnTExFtB84XO8b1+f6YkGg/V1kjhCt0OMc4AlVCFFMcASIsMA5zRZaulMBnRXCqywBEIhRciJFxe55aZpJtpj3HmoxRc/d4wXj15mfCLiwQf3k2Wac+fWPRwOJKLZ4JnPncPYAmM1gQxYzVKmRINeLyXPUhQhUimKzKIijTASoTyodEZgjcA6kAjEEE45C07nFM5fKxZHODGFcyBVgJA+YlgKgTMWmxVIJ0miBKctemWZYG6Xj3t1FqNzROAjQ7UxCAcIQ2NqwvegOkFROLIsx1jfYSmkI1SSRtMQReASi7OgC4kVQ9dnIYisQFtHpEE4h7ECYwWDXXv52nLG6ctHuak/ybQbUJxd4aTTnE4NuZQMjOO1ntV6QOmdjs6WLmeww7+YYUSrNQ4p8WvbwlAwcQAAIABJREFU8rVD0AgUOCi0h49DZ2q5TglaRxjlsOOy/IypXOa3ZazADh3XGrB9R57lDFJNu6NpjDWxDrQtcNZ3m0opGOiMx5/7KqvdZT70g3+T2+99E0GguIJhIYibNGWA0TmmMDhtsGZAEDaJcORomkmDt7/tHfzc3/5Z/tlv/hZLS8t1PeV3mZxznxBCfAj4m8BRIcS/x1+GHwb2AH/gnPv9kfWXhBAfAz4JfEEI8WngaXwH5SHgpuHrrre9Px1u74+Bh4aw8inn3PNCiJ/Gg9OjQog/B44BIR5EvhNYBA6ODPdy8/NatWrVqvUG1w2Dyk6ng1KKOI5xzlVxqkKICgCWMZhJklQRrCVUTFNvJCnhTQkGZ2Zm2NjYoN/vk6Zp1du4vLxMHMe02202NjZYXl6m1WqxtrZWxYsuLi7S6XRoNpvkeU6e50xMTDA/P08YhqytrbG+vs74+Dj9fp9er8fm5iZpmrJt2zbCMKTf75MkSQVc4Qo8LN1ypTOz3Pc0TTHGkCRJFUVb9lmORnaWTrjRWNitnXfltspjOQqxyu97vR5TU1MEQVCBvtF9LPethEejsbUlaCwdjCV8S9O0es+lWy9NU8bHx7HWUhRF1btZAs7BYFC5P6MoIgxDpqenOXTo0FVQrXQITk5O0uv1iOMYoIKD5fEc7ZksXZ2jEaQllIyiqIoZLrdfdk3ed999nD17llarhRCC6enp6lorj4sQoupHTZKEoiiqMUs4WZ6v0mVbwu/RztMynnj0nJWw8IEHHqDRaFTnvDy3ow7aElSOxqZeK6p01NlbPj/6mnKM8nx/J7XVwflKImOvp5eKbv12O0VfDXQsz8u3Gmtb67WRc+63hRBHgP8R75j8MLCEn0D9znCdp4UQfwP4x8AH8P/3PQX8ED6O9Vqg8neAm4EfA355+JovAuVE6B8DE8AP4gGjwt9xel1Q6ZwrhBAfBn4C+Engg8AYfhJ2Eu+2/P3rvb5WrVq1atWq9caTKQZYoxFOIbDIKnIzQEkxdFNqFBEGP78J9YDA5NiiQKYGhMBqjckyrAUZJ4RxBynGAB9HKZVANGJsPiCQIfG27YgQVKAQAkyR46xDRjE2sEgpsMb4OMjC4AKJCBRCenedUAHOWaRUOGFxVuKsRmARUuKcjxj1MbEKYQqMBREYJJZCawQRDot1AzDGwzNjCIQkihOCsEmjGaDzjP5gE6M1RhcIBEnTEAUO4Qy4AhkE6EwjZBMTRQSNNma9R6QkjaSB2HA4KQnDFjfvnWJqwmDNIs5mBEmb9sw0Z4wizyyKAGsNJkuRAowQqBCyTYsKBQLpOwi1xZERRBFjkw327J9lc63ggXfcytGnTnLbgV102lOsr2oGucNaSXdjwNrljNW1ngd4+YBoNmCz0GzTLfoDAXhHq9Y5/b4hSaZxpvBg01kMGVZ7YKVEmYHqcFZjne8ONbpARU2SzjjWGATFlR5FJxECBpsbNOKI1tgYOI1ZXUYqf06M9efWd1RKhPM9leiQpD2DHEaIZrkgzyw61+gAFJJASpSAKAoIE8DCIDf4qajDFg4ZyAq6Fbl3GA7a8xxvzHL52NfZP9sh7K1zdq3HgoJ1ASYUrKfax6S+xnIVIhx1bm6pYvFvDWuG1Y9DyGirMYZ/XrW/V9Cj2LLOlltyR/4cfU5Uz1XuTGPRxYAs17Q6DWykkE4iZYhUMcGwTvb0wkl+/w9/lw+ufYTD73gbcSOu3pNAooKYsU6botfDGIEV/vODQClCFIVztNsT/PBHfpTFywv89r/+N6T9rIoPrvVdox/Hz2t/Gvhvh889B/xv+MSiq+Sc+5QQ4i3Ax/FuzPcCq/hqk19/uY055z4jhPgv8PPkLwgh3uec+9owHvYp4O/hby5+L9DD31T8SeAPtgz1cvPzWrVq1ar1BtcNg8rSPQa+n7EEKWUXZAl0oihibMxPoMIwZDAYVB/2p2laAZsSDi0tLTEYDCqwJqVkdnYWpVTlluz3+xhj2LZtG1JKNjY2cM4RRRHT09Nsbm4CHqYuLy8zOTmJ1prFxUXGxsYIgoBz585x8eJFlFK0Wi16vR5CiCr6c2pqqurNLAFf2Q05Ck9KoHfu3DluueUWoiii2+2yuroKwPbt2ysYN/qaUY2CECFEBRFL6DXaTTgax7oVmJbuv9FzVI5XFEV1nkYjb9M0pd1uk+d5dRzK46+1Jk1TJiYmqnXLDtF2uw1QHes4jlleXqbRaDA2NnaVY7bZbJJlGUtLS9XxaTab1XWilKqAX5IkZFmGlJJut1udz/K4aa25cOECO3bsqK6nOI5pNpt0u12CIODgwYN0u13iOGYwGNBsNtnc3CQIggp0j8bpluBybGysco2W13YYhlWXapIklQM4CALW19crQNtsNrl8+TK7du2i1+sxPz9PmqYVuNv6tfX8XyvudSvA3OruHY2TBb7jkLKE9ls1eq3fqK51nK4HCV9qOzcCFq91fq61P7VeP3LOPQJ89GXW+Qrw4HUWf9PJdb734h8Mv641Xg/4+eHXtZZf84Jx/qL8t9QTqlq1atWqVes/C7nc4kyBkBKl4qF70ncQShTCOeQwD9I5C9rR3FgglIJYSoQuEGGIdBYhwRpDsb5KppdpjLWJO7O4RgsRN0D5MWxuUM0Ya/xNpk77bkMzyDGDAc46ws4YWMgzf3OokhIZSH/rFb53z1mDQyOU9E7QIAahcEWOzgc+qpaEod8MpQIsDqFCQiRa5whncAwdo1KiiwEWCUiUdEilcDIAIdADf6My1pEkEXHSGu6HjzH1bs8EbRVWBGAgChs0GzFZnoF1hM2Evzq+SnTnNpKdu3Aba3TCjCKepBU12HPzNrrdDfqDnH4qcVZhhvY3SQvYoNAZ2ACLJggSslTz9OPnmZ5qE8qA+R0TbJu9mygMiRKBsQHZwFJow8L5Lo24ibYG7TQiCFCdPsUCYELy3N+A20zaBNJhTYFzxrv5tMXoDFMYrBFI5V2NDhDWHwccWCtwFsKgQdhoIWWIcBJjNVQpUJail9JuxYTDGFOzuoRUAUWR+2tjiNOcczCMBLbO0Bqf8ufFWrQRpKlhYAoazhKGCVHeJBIF8dBBa5UiUAVaSN+xGWliFSBUCE6hGxlrWnFm9gAvPnWSW2fGYH2FtX5KT8A6jqTV8te2vdKMUP4y/VpjsiuORx/XWm7blG2yQlQdk6OvusopedU43zx46aO8Fp686pkti4bVsJiBQ+sCkzvGOg1A4/CfYUVBTB7lKNVgI13nz/78kywsXuI97/sBOlPjV+axAlTcRIURWb+H0QaQWAdBECElSK2ZmZ7jx3/sJzh56hT/8dOfwxlTo8o3kJxzp7jG/HZkucUnDv3WqxjzKPDfvIL1rjcHfghoX+P5Z/A38L6SfXjJ+XmtWrVq1Xrj64ZB5Re/+MX6U/tatWrVqlWrVq1atWrVqlXrOnI6QwiHUuHwplIJ+BtRfZeg8eDSWZwzSDegMVgfQkIgCL2dS5RpKhLVjDHGQjFAdxeQpoWMpyCFYmWZ7soyMxOJv7E1dwRjYFODzcxwO11ErJBR4D/NlgohFTKIUFGIkCFoO+y1VGAFQpVVCA5rDR7UKIRw3olXwkoZeReaAOkisBJrc6QM0IV3hJpBD5tnhI0EFTaRYYDSIUobAqvQziKEwjmBkBKbF+AEUsUYLci0xjmBcZD3BbOzE1w4YwmCiKLIeeprZ3nuyCXCSKICaE8k7NsXcdebNTftmeLdP/hW1o6dZOncIud7bR5/coVu9zzOpf7mZCmxyiGMwGoDgeOFF84TNQS337GbmekWWoMKHK3JJs8/dw7rDOOdhJtunmRtVWOswRpLGATIMKfQIYNBH507dJbhXMu7aW2BEwJnHMZa8lyjc0A4MAJrBUI4EBYhAg9tKRDKETUaiDAexgA7yp5JhKdbg7VlQinBWEQokFkfnMW6AlNo3PA4C4bVJEYDkrjZ9C5ZWeAKQT8TDIocazOQDaIwpulaSOtRnsQhVQONwSKQYQMlJIEEhGA905wPdnJiNWMucaxfXqafF0zdNMX6wiqyMOgsYzW9Gog14ohCG4otKVSv2c/qN31/pYbk+mtdB6S6G4uvdSOjlfGxQghwUBSwuaHRehNtLGBQKiANNwlDRRgEFDpgoAY8+o2/pLvZ5X3v/wBzu+arvRRi2D8bhX4LVuCsd3ZLIQkCiXWWPXsP8JM/+bM8feQop06fhxu4AbhWrVq1atWqVevV6IZBZa1atWrVqlWrVq1atWrVqlXr+nJpj6DVBHy9hsP6qFWhkNLhxNDJZgxOO2S6QTDYoNCGSPmIR6d9PCsWEL6PMG4oVBghlUIqBXkfG4VgDYOsIIhDim4OgQI8iMRqrM4xRuMsxBMTTO7fi94cYNM+KglRUQwWnAIhQpCBL+QbggqrC3SRe9A17NSUyoEVSOcjL313pkSIAivASYeTvjFPiB5kFmM0Ii/QukuQNImSMZxTGLOJovDvE0CEKE+8QERYq3AG8mxAMdCsXzbsffN2lmYH6DShSAfI0AMzY0Jyo8kXCm7aM83Jv1phcXmT+VvGCR45Sveh/8CeD/4Cf9W27NlvKUyfXmFZM32sDRHCeZAnBDjJM0+e4szJBXbvmWb3zTOcOblKtwcL57tsbqxy+PBeVBzw6CMn0QaUCDEMsNqgXIAMQWCwJh9eCwJjBwhrMaYgy1LSdNMDQzOMDjXgAoGTIKUCDMopwiAmGWsiI4VQAgzDgkUAh9GGdH0VqQsclihJkBgw1sf2OufHroI9XeVeFWGEDBrAAOscWQb5QFM0LVFUEMURYSCxVoLLfUqRdIQ0cAZk4FBB5KNw05QXVzXnJmYIN1ZYuHAW4oCDd92GbkourKzTMIbFTKNHYJgUgnZrjOX19e/MD+oWfStY7nqvfbVjlutbN7xXQYC20O87iqKPLjTOBoDAWOdvXrASgcQJeObYU6ysLPHhD/8wN996C1IF+J8qRxAmYFOsvpLQhYIgCD0UlyGH3/w2/uv/6mP87//sX9DrD7zr+0YPSq1atWrVqlWr1suoBpW1atWqVatWrVq1atWqVavWa6B8fZ04jFBRA+G8Y8pYi8Bhh242rMUZh7OWoNdFWU2Wa2QcIYIApwukcIhA4oQCYTxkUsPeQgvWFVWXZdKKvEtTgAgVQuI7J4XAFma4D4rMbhBOjBFNjyNc27s7jfWuvcLhnAEhQQmctTgp0YXG5MWwqsIhpMLqAmsNQgRI4UBItMmwrkBr7eNknUAogaCBMzlOZxR5gbOGItOoxph3dkYSmQ8rJgTDuFMBwsM8azNUECCspN2eore0QSQbbL95hTMLQJERqg3CIMTSRqdAFDA5M0a6nhMl3umXnj39/7N3n+2aXmeZ5//XWusOT9i5oioqS5ZtYTlKxmDAQNMwbaahTdONmWGOnuOYjzKfYV51221MA8YMYEIDxjZg5CDLkhWrFCqnXbXTk+6w1rrmxXokYBqOgQEhY9bvhVSqUu3a+wkvpHOf14k4y6LveP8TRxitF9z/yDuYTRd8+v/6I/Z312nmcxCPc5GyLFhbX2VloKxWLfQd6vdSaGim3H//Fo994DSvv7LPzvaU6D3RK0UdsK7ABYto2ugsymF6PJcNyuBTk7ANc/rQEr2kHdMoy4AXjCqiikSDtYZBvUI9WsPYEjBpn1IEDYAqoW/pDqaoKkVR4eoSCR7tuvR6ECX6Pp1/XQaUMYYUVGLRsk5nZjF0XmnbSBd66lhQVxViq+WaYoVqxMfU+EwTM5Gu2OJCc5ib021euvMyRT3lxmuvUK6vcM8jDzA6vMZ3nn6WYRMI1tGI569FeSLM2xb/T9Sm/G6my5O0BnmjXE3fKwd7HRp3iNFjTYGzJWIOiERUwVvPxWsX+JXPfpqf+7lf4O77700btMtTsLaoiGGGNTadE1YBhKIoUA1srK/zUz/5b/jTP/tTvvyVJ3NImWVZlmXZWyoHlVmWZVmWZVmWZVn2Fti/cYW1smBQVWDSWdMYA8aadN40KiH2+NgRomfczfFdk0IpZxABYw1qLRoDsjy2iQih7wkKxsS0eVmXzA8OCLFDjSF6xVqLKWo0drhqgHqP71qCb4nzFCKKNdiqwtoSYkC1J2q3PDsZIEo67xoMsW0JvifGtN0XfGpnii3S3uFy19KHQB9bvPZIL6l1JxYjFikKMEpoPXERUdeCj9jCUJYV5doYtQZjBGEZ0IbUbixcz0pdI+KRCP6g4IVv3uDRj5xg79o2By9c5IM/cIb3vf99vHLuMt959go7t2E0hlIqNo9tYY2w2NnHDsb03YJ73nWU7e0JJ8+epm08H/93c/7k97/N0SN3c+jIkEGlnLrnJJuH19i+fgVjI2fecR8Xn9/k7nc9xG9+6rc5d+5l/vOn/zuznTOU9hRGBC89o2Mt3YEyjEoTJhRFxDpL1EiMESMOMY4+Llg0HW3bESJpm3LZUBVVrIA1lrIYUpUFdTVmNNpI7UdMCoSFN0NH3y3oZ3MGxYiyqjGuIHRdCljLEtUUKJplYzSqRxVCVFQEcTX9MvT0ARYtTNspVWmoqxHGWqy1aPT0PhDpsUZBLAt3jD/bPsq5117j8PQc03nDZP8FBseO8q6PfBBbW55/+mluv3YD65XOgf9/pWAxRiaz2dvxlv2u9UbhNLBsV3plst/j+73UpBSTvmkhpNdWXVWEGLmyfYVf/uyn+Jn/+RM8/OgjgAVNr72iGtE38+UfkDZwjTFYJ/gQefCBh/jkJz/JM88+z+7uhLd+MTTLsizLsn+pclCZZVmWZVmWZVmWZW+BndfPY6saVw0o1kzaghSzbEdZNHapwegV7RaY+R26xQwRSwypdYcoYi2qXWrMiUVM6rOJQAwecSWiQj9pcOUADQaCR4p06lEsmLrEtuk8Z0w1TLTriX1A6IjL+5LGGExVEqNHQ0znIb1BQ48GJca0Vxmix5jlqUmvYEJqcgVPiB7fNfRdJMQIGlKYKhaMoSgrpDSgLd2iJy56ispgzRrlwFEOVlFT4GOH9hHrKmLsMWbORlFTm8CBKO94x0kO33OWprnGve8c088e5trFivkjjg8+8R5+4F99iJtXb/PcU9/h6tUbHG/v5ptfvoN77MOYrmPl0ArGRO7cusP21W1WNtY4c/cJfuqnSw4dOcZwPKDtFhw7cwJXOtaPjMEI1169zNrGBkUF61sO7D5Pfv0LrAzu410P/h+0szmDdUu97plfNqw5y3R3l3FlcS41D8VAOSiJMbBoZ7TNBO0gBrBoeg6tYpzibEFR1FSVYzBYY+AKynqEFAWK4kObdjyNoOoJbUc3X7A5HOAGNao+NTr7DqoqnfvUiAme1Oe0xOVWKgL1ykpqswpEFfoeQujxvqdZHDAYrFJYizGOXpsUfGJpWOHre0f5yjPf4mF3i9h2zL1n7cRRHvnY92OHNS995zlefe4CzkcaVfa7QIg5APv/oizbxaT3vTEQVVksPHdu7xJiZHWto++HoEIInroKlGXFle1L/Prn/xv/ofgF7n7wfowImIgxFldUdG2TgmcFDRFjFCORsij42Ec/xsc+9oN8/jd/j773b/OjkGVZlmXZ96ocVGZZlmVZlmVZlmXZW2Dn3HNUK+sMVtdw9RCpqpQ12Gq5D5haiV0/R/oWP9tD2kBVSQr+YsBYlxpvQdLv1UiMIMahKMYUGFemrcO+Y/XQsZR2KRhXIEYwxqEmYIcubT2qBwRxFvWePvRgLFYsaklnVzGIU4wI0Ua0ictTs54Qw/LMp0lnbLVbtgNNqn5pRFyJdlPQHt9FvPfLcFXpi4qyKFITs4xo8MzmPV3YZd0o1WBMTFVNJHaoFkTfYM2UumipQ8nm0RXe99F7mEw7rm43aHmV+95b8Pq3Hb/+6Rc5fho++rH7eOTRh3j3+9/F9rUbPP31p/jWt57l1L13UbnDnH3wbgpR3vu+D1JVNUTF4njXE++hHg/QoDSzFleVhODpg2c8GnP8npOM1kfs7e4yXB3w6usvUBWrHD/2wbTPWUa2HmjZub4gToaMDzluNjfZXHGITa+NEDzeB9q+ZTKf0zQdMURkuTWpATBpZtSWjqooqIZrDKqawhrscEC0Qt+3xOCxxiLqUIRuMaOdzamPDTCFQY1BCahvCXGIagqgKQ1oIIYe3wdiDMQQKQc1ujwHGlRoOkPfBFrX4tRS2I6qKHG2RkwDoaf1wit6hq++cJHVeJmhV873gZXDh3jkYx+m3Bjz0tPf4aVvvoB0y3O3ChKV3NT7u0lhJWgU4vKKawjCfOaJcRfvO2LcIgRltV/BDyODQcA44eL11/nsr36G//gfPsnZe86SbjIbjHUYm044W1tB9CAOawui7zl85Aj//hP/nieffIrLl6/lZyrLsizLsrdEDiqzLMuyLMuyLMuy7C2wuHyT3bUXqMYjpCwZHjqGlGXaqwxKDJ7eN4Q+Uszn9JMDSt9AtYKwTLQ0oCGgpA1CkQgoGkLauHQRMUAEKCjrGtSjEtOeY+GADqMOpMK4FHzGkMLK6HtUDRBQAxiLKRzGuZQfFQ4TeqSGUoYEVZhGYuhBDSqK2Apr0ilbEYvgAI8Rs2zLBYwIffSEPuL7SCyX4ZooWlh81xPmHTM7Q+0UWw8pnKUuR6hRTFnThxkl+2ww4CAIN67sUw8cRbfGM89c4J5HPfc8Frn0bM3lCx2/9ukXuHlrxokTQ84+eDc/9K8/xnR/wuc+/VkefPQRjp04RDms8W3PytYqIobB6oiiKvCtp1m07N85oKxLYgg00xlihGLg+NVP/Rf+8A9+j1deepX5pOTesz9PbU/RxdscebCjaSb428fYqiLdbJcYDigLhzMlfTfHR8WgtH3HfLGgXXiiF1AIPoXSzilV6RgVFYPxBqN6ROUcgsGUA6wtl6c+Q2rZ+h5Q+tmU0CxYXT2a9i0Buhbtu+UeZdrLDCHFTjHqcnMy/bgsy/R7VFG1dK3SNNDUHXVRI0QqV1MWBXNfENoFu3qYv7jUsL/3Io+vRC7sRczqKu/+sQ9THdrk6oVXefnr36GdLqgknTBFSc3enH79naWHTNEgFE7ApJ9dzAOGeWpBr3vQ9DwrkbJySGk4f+UVfvmXP8PP/dwnuPveezHGIWIoiopOA1FCev8qWLFgFYg88aEn+JEf/kE+9V//GyHEt/cByLIsy7Lse1IOKrMsy7Isy7Isy7LsLRAXLfuvv4pZXcGNVrBlTbm2DrbEIASF0PUE7RHf4NsZlTEYa9J+oHWo70g1Kk1tPWMQFTCyDCcVYw3RtxiNiIDGkJpRywYWakEiiAFnwKcztDFEvG9RD8bYFE4WICKku5+ApGanWIcdGkaloxyU+Lana3v6xZwQA1EgaESQ9LljUI2ICNYWCD1gwChWHaEPeNLuppL+uBAi+wczpn1g/ehdVGtrqVEaAyE0WOuB6xzym1yNht07Ux545wnK2nHX9Yc497UX2bjnJu/+gXt5/QXPlZctF87f4f6HDjHdnXLk5HHWj2zxiV/6JOIcK1sb+M4zXUyxkwZQpvsTZhdnVHVFJGAwhB4Gq0OC9nzzySe5cPE8v/JfPkWz2GR95fs5ffR+fAysHWpYOTZjtlgwu3IXRRxyetgw27mJkQmDYU30Lbaw9Is5dTVkPp8yn00IXokBiOnxMBacg6qwVOWIuiipXIEtLBoiWjjECF27IMaIjaBEJEaagwlGlZXxKiDpNRECdB2CIGII0eNCT9CIRggh4H1PjB5rHFEhYjACQYW+E0IHDIS6HFKXFViDE6HxwvlmnRcufp13jjv2G2Ve1rznBz/A8MQxdm/f4pWnnmUxXVCmwiitgpcUUpYitDmt/DtTQFXpfToBawwI0LQBpEFkiojgo6f3Latr6RsfxAjnL7/EZz/7y/zHn/8Fzt57N2moNr1H+76ldA7VdAbYWEOMkc31TX72Z/4tf/hHX+Tq1Zu5VZllWZZl2T+6HFRmWZZlWZZlWZZl2VtAVGhv7bH9/LeoVsaUwzGuqrBlCVLSdw1d36L0iC3QoNiyWI7QyTIwWAaUEnjzRKaYFDg5cGWFOIOoo15dwdYVsWvBFIgTUE2NywCmsGlzEiFGIfoI0WCdYpzDWAfOIjZlmqm9adKepgBRwFjcIG0fll2LH5b0TUvXdhAhdoqIpr1LVwBCaDusKSH2qeGphuA9UZQutDjjiDaFV+0Mmr0GX04Zj8b0CuI9KhZXWKy7xXr/AKN+RjMf0y88K6sVq4MC2xzl6tOwffUcp+4b8M4fWuWu9ZrNQ5ucuOc09WCAsZbheMzN6zco64rQeRYHE+bTOUVhca5g4/AmapXp/j7Xb13nO888wzPf/gZ7uzts79xhVN3L6TM/wWh1i6KyjFZh/bDhzp1bXHxlArtn0KkwZs6RsXJ58hp10TMab2JLQyQSokdNYDo9oF00aFC8N1gBrOCqwHBQMBiOGI5G1FVNUZVojHgCWqV2bFjM0BjpI9goiEb2bt5gZVBRDyvECSopzQp9DyKoCD40lLKCwdBHT9e1aIzEEDEmUjjoOyFKpI+CX84TCqRt0qJAUFQKpmxw/o6y5WasmcBzc3jPj7yPrfvOMtnf5cK3n+HmxTspaxfoFHqFQgQBtoBbgM8R2N9bTLOiRFLTMswDMU6IMTDsO2LoUQ3EVaGuK1QjL114ic/8ymf4X3/hl7jr5AnEgBGLswW9X+BciaogUTCmIGrPB977IX7sx36YT//XX8tblVmWZVmW/aPLQWWWZVmWZVmWZVmWvQVUI30IzK/sc/vllxmtH6Uer1DUA7yJ+LYhhB5jSopqDbEFRkzah0QQXYZMvlvuShpECjR61EScrUh3ZEFDOgkbQ3izySjiIPj0c1GX52ZjCi8RjHW4yiKFAY1p09LZdP7RmOXJWU1nZ2NA/V9+bI2KGIsrBWMtZV3RNQ2d6dDeYOhJbT5FJAWjIgbR9LmmnWFzAAAgAElEQVQQIio9TiwxgO8iIERg4S3BOLQU+r7DasBISYyeqtzHmgVbB1MuXl5hNN7l/T90ltMPHuKVV/couw3Y2+Dc127ji5e474E1fDPl8eKHOHL0CM2iYT6dszoaY3xksDpivD4m+oCPHRcuvM7lS5d48YVnef38q1y+eJ2DXU/EcuL+Yzz87sdZWV1hUNfYIj3Hu3d2eeHpHQZ6BLdznNBaNLTcNSyR9hZdd4XDm5G6MBg1xOhZtAtUevYne4R+ee41pvKrLQK2hLquGaysMhyuUlZ1Cnl9T2x7oisQ4whtBwiOlC5LjBxcu8HW1koKsDGghugDsVkQw3IrNILvOiIpzDbGoGIIcYFooFi29KKmzyuGtElqDRhbowHUpsD1TjjEte3XuG+gvLqn3HX/WY4+fA9N33D1/Dmun7tM4+Mbx4xplkXfNy4Wz9OC5j/5+/Ofu7g86xtVlt/bkL65YbEIhDBLW7IozjpEDoBVqrLGOcPLr7/Ir3/u1/jkL/4i6xvrQMSIpfMdxijOLUcwNb1/V9fW+OmPf5zf/d0/5MbN22/zV55lWZZl2feaHFRmWZZlWZZlWZZl2Vsg7QE6ILL/6gVub25Rr6zhqgFmuELsm9RkcgXl0KCmwpmALQuMKCohhTlCSrAADanNJNi0EaksG5iatgpZbg4ah1j7lyGl74hel6c/BQpJLU6N6ZRsaRHn0u8jnREN6tPX0PfLLUFFLGgwy31K0BgRU6EEispijKN0PaKerrUEHFIqDiEsAmDogqeLHoziRDAWbG2YzQNYaPqa6zcazt4didZjnUuNUDGMhoHL15/mvtFPcKdfsLZ1nBuvTXju69c5eXqV11/t6doFQ3sY8YfYu7DP7HDHM1/9GmfvvZ9jp09w+Hjaprx68RIXL12kX3QUZcE3vv7n/Mbnf5m9g31KOcqgPMWg+iCnjx6nLEfMdvZ5/WmPSou1PdVgTAxCM7W8910f5sd/6jFee/EOX/3Sa+xducZRbbh87Rlqs8PW1oiySg1T37U00ym9DyzmHVEhBIuKIEYpnTCua0Yra6zUa9RVjXEOFQgx0vcBygEiQtfMKashiEUQQlgwv32buzY3U4YtBoDoldC1aZs0poA1xkhEUI34EIh9IISAtYHSgjWRGE0KqlGstbhqQNS4fN7Ba8GFyZgNM2Nn0mE2Nrn/w+8hGNi+fIUrz55n96BFNb2O4zKPrJYnYA3QquaY8h8gxnT+FSG9v4Gui8wOGgzpmwq60BGJrIxXccFirfDn3/4yh7Y2+PjP/CyDqkJFKIqStm1w1i3PECuY9FE/8NgHefzxD/Cbv/m7+fnKsizLsuwfVQ4qsyzLsizLsizLsuwt4GMkYghaEGaeg1deZv/QUcrBkPrIEVSgdAZbVjgRvEnpjagnqmJVUQNYC5r2HE1hl/uVFiNpp1A1grEoAja1IXGKEsCaNE9pUzihqmnLUFJLUozFWIeUqVGny61C7QMxBKLv0aDpFKTEFIoCqd25PE1LQKLHOIOYAkqLV2Vx7So4T+FKYlRYhpxdF1i0gBrKyuOcwRaWso70XgnAbnBoExjWQ+pisGx2RQTLcWbcvHGRk+YsF5474NGPrPCz/9s7me73/NFvC5cu79D3PSIB34/Z37Osr1vqQc3WXVtsX7/JH3/m9zh57BSnzpxl4/RpbOH4nS98jt3byubqD7I6ug8jAxCH7z0aG6piDSOGshwSfAtzJbQdp7bWOXv6KPXQoUSK0nHXwFDFXWaL85xYh431VQpjUfXMFzOkUBZNIDQGH1LYZK1SFpGqNgwGI8bDNQZVjbXAcnvU+46mnbI+GBKix/c91kWCTw3WbjbF9gvWj66DNakJK0KISuy6FHiGFERHTX3Z1LKV5Y97DIGygqJV+qh4VVRMOhFqLMYs23YE+uho2kDtG65Ew3sffw/Vygq72ze5+tzL7NyeMtc3XjGpSTkwUBkIUVigb4aX2d+fLv8aVfAhNSxlGVh2fWQ+64iqRFWIqWE7HNZUVY2I5Y/+/I9ZXd3gYz/xo1gTsabAGEPXtxRFOhVrXUkMPetrm3zsR36EL/7JV9jfn769X3iWZVmWZd9TclCZZVmWZVmWZVmWZW+BCHgFRTAa8XcmTF47TzkYEQy4tTVM4ShsmZqKRlB8ajFpuo8pkk6FChbjXNq4dCaddjUFIg6tLWHSYguHqBC9XwZKjqgd4izGWaL3xKgYTfUrLUwKOkWIHoJvUB/wrSeGnuh9CsB8AGMxNv0+MQJqMA4UC+JBA0ZJZ2OdQwrPnZ2eomxYGaYg1YjgQ898DvOZw4iCKD4oJRExjkikx/HCrV3eP1nlTF0Ruz61xZbh6qgCzIscNke5dv0G29dGbGwN2Ll1wId/+G72fqNjZ2cHgqBa8NK35+zciizaV9i9s0vQlpuXr/PxT3yCqhrRth1/8ZWv8Ow3drj/7P9CaAJRBTBoFLS3SFVhnMH3HtEFvu0oSsvmWsG/+ulHeeyj97N/u2F/Epldv80HBpFbF16kNjscO77KeGUF6wxdG2gWHT5A1wS8N0QE55TCKFUNw7pmdWXMsBpSVQPUgKoSA/Q+0vU9drxCt2iIQdM5V3FEiUxv32FkPOVg2Yy1lth5fNsT2uUOpUYAQt+TOq5m2arsiTGm5mQZKaxBvGAQrA0UhU1BlnW4wuC9pWFIbHfYWUw5/e5H2Dp7F/PplO0Ll7h18SbToHiFUsAgFFZxy/afKsyi0r1N78/vZsurq3+3fxdJ55/T9eT0cwasNTTN8j0vjqKYY52hcCXO9hhRDvyE3/q9z3Pirrt4x6PvJsYOYyyLxQIrJcam1rYxBSqexz/4Ie699yxPP/388psUsizLsizL/uFyUJllWZZlWZZlWZZlbwGvFrBYiTgRpFemly4TS0fvDKtylnJ9kxh7RAO4ASb0iBSp4RYjmNSaUg1oEGLboeqwZYE1CkbRrkNMakxG9agqtihAIqYwYF0KG0SQGEELIhGNgdAGfD8ndJ6+8/TzKd63hJACDvVtamEGQZxANFhbIFYRazBFiTUFzr7R9CxSkIph0ZRM5x2F63EWlEDXe/rWEoMBG5kvLM5q2j40keihjwHVwN5kwcmtMaJ9Om0ZNO0tqmF1fJvbt1/ijH2I809dQww89uEzYODhRw7z1DcmzBcdRgyYIbdvRv7iD6/xo//TE1y6+BJPfPQHKMua7e1t/uT3v8Sf/sF5xvWH6DuP72dEIsYqEiJBwXmWO4pCu1hgrWVYGd77gbMcOr7Bq9/e5uJrt3nqi8/xQNHR3L7E7vRZzhxR1teGWCP0wdN0Hbv7B6gNhNaAClbAFUpRCYN6wHhljdFgRD0okLKA2BOj4n2g6ebM2wVuvIrvuxRQ+Yi6lFItbt9iazzEuZKUfgvRB/quo29bShSR1IpUY9Cg+K6n9z0xBEKMSOwonMFZKE1qWhqjy0akYAwpEI9KW2/ip39BvbnF/e99J74L7N+5w/VXLrM/97QKVqACKqcYAz4IfVQ6VRbks69/k78tA3yjz/xXf9mYN7+vIf16yv+BtGPZdgGdzLBF+mdjBJENygoU5fZkh1/93K/xv29uceLUXYgIRqDzDbUbgA+IswSBUydO8pEnHufZZ1/Ce/+Wff1ZlmVZlv3LkoPKLMuyLMuyLMuyLHsLKAYBHIJNnUj6/QV7r5wjDmqkqlgrKlzh8N4TbYGowQho9OAqEE07kWrARwgeIxYIaIgprHQFph5iqgoNksInP8fUJSLLbcsYAEuMEY0e37T0bUffNLSLKc10Rjud03dz/CKdfQ1BESIxsAyrLJKyNcRAUZcUdYEtLNY5irKiHq7iXEWIkcHYcf16xWjYsDqMRBTfKKBYFxBRYmeIRdpdrCpB1dJFxUe4fmvO/ccX2OFKav3FFiUFcqOBsl+9xGE9xfadq1x8ruLIyRXue/gIDz66ye0b+9y8NWVv7wCzbG0O1hxNO+O1F87xox//N7z6yjn+4PNf5umv3sZyAu9neB9QBcFhogMjuAiqHu8jhS0xzuIEPvaT7+SR951gutdx6cI2T/7xeY5rz3qzyyvXv8ao3OPI1oi6dBgMbTdjuj/BewUPPqbtP1cG6iGMypLxeJx2KcsKKxaNgRhTY86HlrZb4BFMVdM0cyQKIgaN6dfjwS4ba4P0nIdA8JG+aWm7nsr3WLGEGIkxoJpOASMGscuWbFQKMTgbSXFz+vjO+DcDLFFLiJ4+RPZ295lMJ9z9kceRwrJ/Z5fti5fZvnXAIqZnq5J07rUwQkjZOwGYqdLklPLv5a8+XG+GlpoCyNTCTD8bVMFHjAhK2iidTpr0HBqLMSUjHVI4B9bz/IXn+N0v/A6/+Eu/RFkJRVnRdR1lNcAAoop1BaPBmA8/8QSf+syvsru7/0/81WdZlmVZ9r0qB5VZlmVZlmVZlmVZ9hZQwEjAimKNpGDBR+a3F/gXX8DVKxTlAFu6FP4VNVYLVCOLriUYwRKRIMTgU4OxtriiQCUFfkpA6hIZlERn8aGj9x5mC7AOrEPSBCHRR8JigW8b5vOGZjplMblDN2vx80C/iHgfIaRgLKogVvGdYCRtUoqNqAkYK/SFx5YQo+IqoawLmuE+blAjxnH89ABbG3Zu9hjrGZcW54ThOOKsYNSwaAN9AO/BOqWyylwjqkIVm7SRaSyh7yAu71tqxLmSza2eq1e/zEPVj/P8jat8/Y+gmQdOntrgX//8I3z5Cxd47qkZrQY0eIxpeOFrT+FV+dY3n+I3PvNF+tlpCMfo+55ApO96CudQFZyzqAeMYKxD8WDgntPr/OCPP8jKxhpFYbh5bZc//4PvMJ613GMbzl/7CiFe4ughx7Gjhymdo/cL+uDZn89RG/GdwVhwRaSuDKO6ZDQYMhxvMBgOKQdDELM8rxmJwdP1Le1igTcgztFPJ8QYCH2fTgH3LUU/YTQewfKca+g9Xd/T+o4Q08nXiGJNCq17rxBZhrMGV9ZYEVwJRamUvQdZ/tg5Slunlqoqe/MJFy5ss3riBGsnjzKfTJnevsn1V68w7SMBKATGJp3tFQUn0MRUju1IgWX21xXO4kP8H06rvhE6/tXqZHrewBjz5j5lVMWIYIzgrND2io9KmPVYhGE9YjGbYZ3FWYsS8SHylSe/yIP3P8gTH/0IImCspW0WDAaD5QskNbUfe+x93HfvWb75zWdzHzbLsizLsn8UOajMsizLsizLsizLsreAYrCQgkoRZLnJSDB021P2X3mBcjhAqopqZYwFQox0szkvv/oK7aLnxF3rHN7coi5KqrrGdAWhm6JGcYVFBiX99gytKq688ipH7jqOCYqfTFHAlgUalLaZ4fuOvmuYHRzQzhZ0ez2+Cfg+0oeYuooCuJiCJftGeAXWpGanEnDRECNoC8EDGLo+4hcd7czjyhmmsmhRcOTogKoYcbAzpXdKVThGtVDWBmcq5vOGyayjbYXSWkxpmcaeFVOyUfRIuwBVgpSIzrFiMM6hXU9l4dDmDrdu/Sn3Vx/ixWu3OPf0EBHP6XuP8ugHDrO2XvLqS7ucf+U8Z+8/yrQ94NxLr/HlL7yO7+4mekPftCCCK2vUKqIOQVG/DH4IOONYWak5c3KTd7z/LqqqQNXzJ1+4wLlnL1LsNbxrTbj02p+Df4UHTzkefPAUaxur9N2c6XzKwfSAyWSxbL0pzillpQzLmmE1YDhYZVSPKIsCI0I0hhiVGHu6rqfzDTFGohmALYgoMXqUgugbpO+p+h7BpgjbB3zv8SEQoyfEiEYIfhk4i1luVnpUwfuebj6HGCmtpSqUzqQkzBnBFg7jLFaE1vfc2N5md2fKkY9+H8Eoi8mM21eus7O3eDOAXDFQmGUwqUpUoYkp3mrfjjfldzkRoXCpBd378GY4aU0KrVUVa9PrJy5fRyKSNj9j2jIVEUJIYaUnneyNCs4JB7MOub3DeGOEOCicUGoBBKbthM//1uc4c/cZTpw5iRFL7zvKWKDqMMs//+ih47zv/d/Ht57+DiHkoDLLsizLsn+4HFRmWZZlWZZlWZZl2VtA1SImIiiIQySkE40YYi9ML92EwfOE0rJ24gxDWwDKqB4yPwhcf33GzvUZdz+4y13HTmJnBxSUxNgQraNeXWFvdw+ZL5hMF6g3HD1yhL7raOb7xNiDtQSgmR2wmE5oJjO6SST2pNDLgYwMw6qiHBQUVYFzBc46jAHjKlQj0bcEn+KnGITQNfjGE3ygnfVoSOdHY4SmCajx2LrF9A3j1RHO1BzszYkGRsZhxGGtYVANmM49nY9oE7h2YNnvDfcNYWUsaK/0bY8zBjER62pUU8PRaWRYw/raBfYPHA9VH+DFl17kyZvrzL7fc/eDm3zfh49zMAtcvz5AvPJnv/cqk8kWhTlCv9hfnsJ0xBCInYegSLkMgkLEmMDJk1s89I7jPPK+Uyw6WF8rONhbcO7py/zFF19iq2l4/FDNxde+wmL2FA+ecdx99jgbwzFFrzgzwJeB2cFO2iNFKIqItUrlLHXtqAZDRqMVBlWN2NRm1eWJ1tB7et/jfaTrPaFa3t5FUUkbkoohLiYUy4hQvadvOmbzCZPZPm3wrPlAHzr6vseZCg0R3/eIEdBA8B1xuWFpjcUajwiIUYrSYE1BYQ0qkdl8wsXrB5QnTlIdWedgb5+DnW0uv36DRVQC6dzrYBmqyfJob3jj7wrN3zbE+C9c2y93ZpfhZAoiFd4876ogklqPIm+UHREDISrOWkIMxAghgrNgjRCXoeJs3iJWqaqSmZ2hwxFFUaAor908z2//1m/xS//pP1HVFUSlbRqqeoT6ACIYU/D4B57gM5/5HAcHU9Iz/NdJivr/yR+7LMuyLMv+ecpBZZZlWZZlWZZlWZa9BQRFNIUJBkXVLn9FiRi6OSzOXyFWFWJLnEZ8CAydYWNjle3Le8hCuHNjwXijYXVjixIHvcUWQt8psYtMdjome/scP7bGnatXKYZD+i6i8QCv0DUNzf6CfhEJAcQYhlsV5bCmGtcM6iFFWWOcS8EdikQIoQVjMK4ktB1RPWIsIMTQ4XtP33Y00xnNvKNvenwXoEvRWVSIviP2gWJQs3lkk4M7E/ZnLT5GhnWk75X53LAzrWkinGsCinJ4EBkOBviupVhMYLSKsWn7EhU09hhjqKqazbUeeIXJJPDu0eM8f/M6L3xRuHZxm62jm5z/zi0efucx3vnoGU6ffYjzz22zs3OH6d4qTav40ING2rZnZVyzubmB+p5T9x/i3It3uPfh47znw/dy6+aUldWSK6/t8vWvXGHv+mXud5FHT63z6vkvMj34Gg+crjh1YpPxYICitH1HEwJ3du8wmRzgXDq16gqlcMKgrqmHqwwHQ8rSYq2gRvAxBdwalBgVHzq8V7zv0dIixiDiIEY0RKIqtD2m74ka6eYL9vZ2uHnrBvsHBwxXhmmnVFNr11ih84HeB6yx6ayvsQTvKRAKF7EmnRV1IpTOUjiHsSUaYe9gwsTXjB++j6ZZ0M4nXL94lYN5TxSwwJpNJ4R7lfSxFJqYXhcHy8Ay++uEdErZANamfVARIUZNDyqkM6xvBIECRE3fAKHp3GuMESOpjQvLE84xtbpDVIIXJBoWswXWWKpqSFGSGtOqfP2Zr/J9Tz3GBz70IcQY2rajKCqsSR9fNfDoO7+PEyeOc3Bw/m+MI0Xkfzhdm2VZlmVZ9rfJQWWWZVmWfY84s2o493/+5Nv9aWT/P3zpS18C4KMf/ejb+nlkWZZl/7iMRApRChEMgqpBNQCCV0sXhW4/wLkLDMerDDc36BWcc5w5dYLrV26zv93i5o79SU9ob3Ph1pyDaLFOaGaBZtIy0JYH7lmhHq+gxmBEmc0WNGGOBOi7QOyEalAyWB8zWlulHtQUwyEYg7UWiem0a0qyAsH3xAC+ayEE0gKeWW5VWtRYXKEMhsJwZTXtJ85nLPbmdPOOrukxYvAhQhNR0+DGFWtbYyZ7cLDfM58sUISD2YhJP+BS13LdN6ybilGhOFcQOo8NPdYaQuyxy/+NYYoSVNL2ZxA2Ng3wKre2t3l06ye5MZtw7vkJV8/P6GLg2KmTlKOCE2slJ8+uM907RYxpt3N3Z8ZwVPHHv/MSP/2L72Jyp2PtyAiRyMvPTXjqT1/j1JlNXvzWHfbu7LKYNZSLjifGI1b8Di88/5v0k2e49y64+8xhBoXBAb5r8KJMZ/vc2blFPQhoVEQU46AuSkaDMcN6xGgwpnQlIMReiRIxIgQN9DESQnjjqSEuN0SNOkTMcrsTCD3iO7qu4c7tW1y+dIlb1xYMxsrm6gYmpJA3+PCXc58aEXEEH2lmC7qmBR8w6sB0iNF09lUsVgoQQ9vPuHn7gOLM3fjxiHa6z2znDjev3sFHxQiMjeCAg6AowqqFfrlN6VHmOcT6a9K+ZHo9Q9qEdW75PFtD78Ob25PLnDKFhhFcWRBiwPuwDDVT69I5C7oMMZeBp0aPWGHR+HTG2VrausVYg3MO1cjOwS6///tf4MGHH2J1fRUlEkKHtRUiDmOFI0fu4oEH7uPFF8//jV9P1BxDZ9+98n83Z1mWfffJQWWWZVmWZVmWZVmWvQUMHkRTC00knWNECVi8GjpVPIZ2J3Dw6isM3YN0tRCDZ3NtzP0PHec1vcbtbWi+dQ2i5cq85PW+pRbHilUePlnw8EPH2RgNEJR22nD7yhUme56tDUc9rBmOHfV4RL26QjkeYZ1FjAONqWUXBbWCqKKxRzWCETCW4BeoV4xLTSq8BQMIqV1pHEVZ4IqKQVWzurpFu5gyP5jQHDT0jacLSpgHYnuAGxesboyZ6Zz97chsUXC7r3i1W3DVT7AYrIBFiSg4JcYW6wPROBRFNG0taohgLMYoFY6N1QqJt7iy/Z+p68d5D/dxsw1c7R1P/s7z3P3YSc7ee4jNI0NiUDaPjRmtlpzwG+xtNxw9Nub0Q4e49MIdvvmli2weW6FdNBi1fPH/fhYNUC46Hhw5zmwql17/KuduPslaucsDZ0fcdXyNlbqEGPF9g1dlESJtExkPRrRB0NDRh0hhhLWVdYaDEaPBCmUxwJg3Ah5Fg8eLw2ug9y0+BELo3zz/iRGCdkAKHsUV9LMJpu24de0Kr792lTs3PM4qm2s1g0GFK1MjNfQB7z0hdoS+Q4KCEYy1xL5HokdFkeXQpCuVshSMc4TYMpvM2AkOd+YMTd/RzQ64dekm00WPBwpgILAXYCc6rMBAPb0KBghA//a8Jb9rGWPSKVcry1azQVBMIWkn1oKRdHbXh0DwEWssEaXre5x1xOix1lJVlr4PhBAQk9qYqgHrLK4whKD0XvHTQD1UZrMZxgqxtOm9L8K3XvwGX//qk/zwj/8wdlmtVY0paDeWYVXzkSce57d/+w+IMYeSWZZlWZb9w+SgMsuyLMuyLMuyLMveAiKKE4uQQkA0oppOMXpNgY0ARg3tjX0m61eZH63ROKaoHHefPM2KLdm7M+fgoOH2bstG7Oi0xhN414nII2dGjBHmt/bxMVLVFUdOnOTYKaWuK4pBhSkctqiAAM4iUYi+R/1yPzMK6lM4qTGiRjCmxISAcQXBd6ga8B0qJn3iCmIFlXSe0ohDEKyzDFdWqIcDutU58905B5MJzQKCKoQOqSPDFUdRVlw9p5zvGi77CSg4gUKEoEpAAUOzaKgHM2y9RogeNGDEYpwDEYL3GDGURcnm5iblYMb1W19ld+9lDo3ez9H6JHfUcPOpSzx1bpdJ27GyVbK+tYLvOkYbQ8YrNWcfXOP5b1xl+8oeN67f4dLrNwnNAXVRsjKz3Ls2YGto2bn5PN85/23C4hynN5RTpw6xuTZkNBggeIKJEIU+eCa7ewTfUpSGuLB0GESVQVFT10OG9drypGpq20bVdJ4zgtLTe78MKns0NBgJGJf2Ct9ohIo19L5lsrvDzsWLvHr+Brdup1OfR49UrK+vMxiMKIu0xdl2LegYjdB7j5SO2Pc0izl9aBEfUS+E5bVRZ0m7leKIMbI7PaDbOkpbWdr5jNnuHW5vH9AtL5GOjbBQ5YCK1Y1jLOYHdHEXn/JQOpbXS9+O9+Ty798tfU4hnWJOZ1UN1hmqskBj2qAsXGowd31P4YTew2hYMJ+3DIcDZrMZ1qRTr1JVxGWzEhRjDIghao8VQRTisrXprCFEmEznKAFjYcSIqirTLqoE/vsX/5B3v+dRjhw7jA8BZ0oCAYMBER577L0MhyXTafN2P4xZlmVZlv0zl4PKLMuyLMuyLMuyLHsLOAQrBiUgOBRPRAgY/HKjzwGlgDawf/E6k8Eh/KFVXO2ohyUnTt/FsaM9s+mcnZ0dLl64QrzqMCayUgqHDm8wMAPKI+Wbpx4xgkT5f9i7t1/Lsuu+798xL+uy99nnnLo3u5vdJFuiJJIi7cSOFTqW4wCOECjyJTIQPySPQZCnIC+BESDvecmf4bc85CFBAkMREkuQLNpxZEUSZVEm1SS7u7q66tz2ba015xwjD3NX0wjipEWyxICan0ZXd59TZ5+916XQVb/9GwNzBbRAMkrOCA5Oe++QOlbSxKEohiJqIDUwMe+Q4Ildj1jCtGA4VLW+Fiun0aEGloAJFJxXnO/wvmPYnNOt16zmC9Jh4nA4Mh8XVITV5oyLtx/zjeff4r13d2RTQo1NiThMQfNMjAM5HShp4ezMs2hkKROmgklGAO88oDjviN4R3Jr+9Y6buxs+ev4/8MHzczabr/AXP/UVikXemw48/+bCB7/7xyRNWOwwqU2yPvSUNBFxvH1+n7/w+IyHZwPl+IJnz36H3/nwn5GP3+bB2cwbn1vx+NE9Nus1AYE8o6YUClMuHFPBoZw/esh03DFPB8wKMTjOzjZszs4ZYof3AlawUigZCpmUhWKJXGpYWbTuNXXicA6ceEwLpSyIetDMd7/5Hf7wt97jMEUux8I7b695++23WI0DPtZdmNuszPNEKQ7td6YAACAASURBVHo6d3Wn4cuWpc4LdtjWPaWnNC92Rux6vPdMxz0vpkR+503mnJh3t9w+fcbtfkYxViIIcFs80t1ntTnD8pa8g4RhDrb6pxcTnsqncLq2hHqNvwxKzexHGlo6Ebrg6GIgxogLjug7ALIuBNfVNqT3+OBBFEGIUSiakNPuzyUl+i5S8svxvlpbzxgxuPp4xYjeU1ByUQw47Bb64JiGiRAdLvDxDsw/+u7X+dVf+VX+w//o72JFKN7wVjAnhBh4/bU3+fSn3+DrX/8XP7Lj1zRN0zTNj4cWVDZN0zRN0zRN0zTNK+BFAMWZRzkFfQjZTrvnMDonRFEMx+EGXry4IX36IX3pERNQQ0sN0ZwXnDNWTkGUtBRSSdy/9wCWjB97lutbSl6gZHCujmrEkODx/QopQp0xKjXE9A4VATJWAOcQ8zgDH3uc73AxoimhmhEXsGKo1bmglguqmWKGiZFtgrQgKRHSjCCEEImbkdXFWW1Vekc/nuF85M2HjtV3hTkDtXtK7wQvBVUHOLQEcp5Qm+n7M/IUKGQ0J4I4nHOUJSPe43wgBo8A8f4555vMg9s7nl39Kn/4z3+DSR7y5NGX+fLjzxBlQ16URRPgsCKE3tO5EaHw4fUfcfP0XT7Yf8S8/wDPHQ9XhUdvjNy/fI312NF5wWtCcIj3LEVZkrE73LLdHvjU66/hvGMmoDjU4Hw842x9zhD6OoYXQ01IBTJKKsqSF4pmiibm+UBeTo1cFOfrbkrNmZwWnAjiHU8/vOWP74TP3le+9JP3eOvNJwz9WR0rGiJ+7CmWUS2oKfN8ZL+/Y73Z4DyAodNUr7dTlu0D9MHRe0+xxG6/5bh6TNpsyPst880duxcHllPwNQjs1Mhhzf2H97jd7mGqjbvjKfzMf0rJoADBC533eAfeO7JabesWrY1UBf0RhZXeCTF6+i7QxY6+O8Oc0vmIiJBS4Oz8AueE3faOLgw4L6SSsB34GBjHFbtdbVWuxp677RZU8cHjREg5wSk8Dt6hZqjpqeUNmDFNC/4geOcJfiB0gpmR84Ff+81f4a/9O/82jz71hJwEO70ZQDBW4xmf/8nPt6CyaZqmaZofWAsqm6ZpmqZpmqZpmuYVcCKnNpcC9Q//5bR7DoQg0AEOpeA4JMfVDuZ5YZUzzvk6o1KsBo+lELxwtppYrQqXF5GrZx/Sucj5vfs4c8QH94mnQEhzokwTeVkwzWjKECJSDEGx0965l+MwXQgQYg0rnUdcDVT90NdAsiiGUVIhiFFKworhzfAYJSVUAyllFCh2SoLyhBMjOIfzHmeCzYFJj5yFzOfXgX96qziBKJ5eHJiwzEf6GHBWWKaJnDL9xcAosLs7Yg7Md4gYPhbAYZpxEnBkOg/e9/T9Ay4fZHa7PXfXH/D8+tv8zrvGpBGTDlyHuEjnAzkvzPNML4miezZD4Wwdef2RcHHZcbE54+zsgug8ohMh1FGZuSw1bMSxO25ZponX33hCPwwsy4x4wyzTh47Li3usx0tCqKFvESXlwlIyqUyklFhyIqUjaZ5Jy4yqI82JUjJnm7mez5xIy0wXeizP7HcHhmh88bMjb7z2AGfK8XBF0Tpu1ZdCyYmSM2ZGUWXJiTHV559zxtKWYgulGCWfwsoIpRSm3TVXuz3L577IMS3sdldM18+5upnJQIdQBPYWubx8SNd7pusjK4ytGVFgp9//2FXhk3+towaBTy4fsDk7Yz/tUAriXG29lkyaM/OcSEXJxf7UA0vvhBgCXewJIeC8EELHalihZnRdRETBPOvVmhAjhsASGFe1+dzFyDwvRG9oKcQYCd7AGfOc6v0m9deeJRXMDOfk5QpanHiWRfFTou8zKc046RBvLJr49ofv8uu/9uv80t/+JQTBuYip1l2Yw8BPvPMOIfjTuNmmaZqmaZrvTwsqm6ZpmqZpmqZpmuYVCCJ4BBFPMUVRijlAEDEcgBgFTzFHQbi+Xdgd9lyenyN9oEgN4MCIIXB2tkZ1YRg8TmDaHfnOt77J+dUV55f3WF+eM55f4McRLxDmFWFeKNMRzRkRj3MBcYY54TQfEvEOggM5BZScRsSaYJYxDOcDapngHYaDUvdS1rGw4ENmt73msOyQEBALCAWz2uiKCpjigN38gjllTI/8uYfK0znywZTx4nAiaBFKKqgqLjpKKiz7O8bLS7ohsLFLjoeZnA51kaIKIgXBY5Zx3oF3iCoBTwxCH+9x//Ien1oyu+2W/eHIUgrTdM2yGGoLFAcrYxw7YghsztdsNht6H4idJ8aAM6kDfH1ELbGkBZxnUXj+/AUxwBuvv40PgUVLTfs0EVxkNaxYn20IwaMIyRIpFQ7zkWk6ctzfMh2PlKzkRUnJSLMnZ2NJgayBrQopWR2PWxSVAighzfzM65E3X3uIi57DMrPdXbG72bObPeelNuzMoOhp7GsuFFPE1Qqlbe/Iy0JWI5nVS8/Bko9MObPz59wNK5Z54Xh1xfL8lm1RDKETOKqgYUS8Z05Hct6zlIWJOlF0/wMsp/yThJTRCfc2F/xn/8l/zlf/ys/xx996l9/5P36Pr3/j93n6/D0O0xZbK8fpwPF45HCcWZLWxu+fAi+Ccx7v6uzWEAIhOLquNpiDE7COYViBEw67LeOwZhhWbLdbsIwQCN5zvrkgLQspz8wp433dTRk85JIppWB1rSlmIKfRtzF05JJRA03GPB/r9/dGFI8B03LgN3/r1/jqX/m3ePTkMbkUvC/44On6gbc/8xnGcWC73f+pHLemaZqmaX48taCyaZqmaZqmaZqmaV4FAfCY1bGYVjf/nfqUQo0sjWKOZEIBbvbCbjqiWuA0+tXMcN4Tu47N+YaAIjJD6JnvFkwSLz56zvVHLzi7HLi4/4jz+49Z3Tsn9iuCC7iuR8uCqCAhgBjiXA0vOAWV5mooaWAlY84ggWrCMMwSdZVj3Xnn48tX4TFRiof5xcxhfziNm/Tg8sfHwhERBdWFlBeyFeapcNZn/o2Ljl9NtW0p5ijFM0+Zssq4GDFR5uMd8/aK/uI+3VlPSQVLDiFiLlNyJri6+9NJfV6C1XZoASPVHZhDZIjn3L+/qc3BsqDF8DGQC5AyYewRy6CFYRxwZngnmFrdz2mZIkIRI/tAyYWbF7esh4EHjx/hxChWEKmBrwsDqzGxGXsET1JjSUe2x2sO2zt2txPTvjAfjGXxHFLHsTimIizqOKpRrDbjznthXuprycuEdw4RiChvvHaGOc/z6w+5u7tjfzOzvTF24QE/261Z5plSMqYFpdQWYdG619R5ZDmizKRUyMXhPIhzTOXIrJ7D+ROOCPvtNcvdjuNdYj6dXxFhb0III09ef8C03HL9XMhZUeBI7Ra/yttN5NRU7hx//st/gb/1y3+bn/jpz/LVn/8qv/x3F56+/4yv/59/wD/+rX/MP/3t/513P/wW3t1hdkXRBcugr7hX+XIM69BH1usVIXSM45qhG+n6jmFcw2kn7Go1ME1HhvuP6LsR55QQHUhBJBK8o+87bq6vmbLicHjnUbX6JgKr31EEghNSKTgRcim1cekg+EDKRs6wpBmZDDeuMTKpJL7xra/zB7/3ezx68gjVQtFMtI6+C7z1+puM49iCyqZpmqZpfiAtqGyapmmapmmapmmaV6AGJ4qZ1Eal2cdh5ct+mOExM5JBwdDk+PD6yFtPjngfAEVQgg/0XY8HBg/TbksYep48fg2bF3b7A3cf3bF/MTPv3md3c8uDN17n4affxoUOH3u8BnBy+v5gWkBPzyaVurYyZyiKUU4VrPpzxUltKToBHC44hICZngJVoWhCgLIs4B1YxuEpeSGnTEqZkmtkW9wpvC01QHl9lfnCquebB49hpOKYF0cuBRHHlDJOhGl7R1yfE8czVhcrurFjd3Ndg1aJqCoihqFwag1aqUFr3QvqEAreMtEPKAlCD+LrZ6zAEOoxsYh3AazgfY8IZF1QMoqRckHNY+LI08xbn3kbFzvyMpG0Br5ZJ47HmVKU2EWKi2znA/N0xe3tkbvrHfutsj8GjmnkUDyLOfJpl2MdtlvPURTjcih8+kIZg0MMLCkaCwiUksi2470P7ri9PjLfOvZT4MXiWL2+ot+suVmOFM2YKdH3YI4lZ/rYEWNHzmAISY2chT4Y2QrTYhyS5/CZ+xyOR6btNXp74G7KJDMiQsIo0tN5z9Nn3yVGhzPlcArq06tuKwoEgVXnudhc8u//wt/gnZ/5LKHvQISw6nnncsM7P/0Ov/A3/zrPP3zOb/6vX+N/+dVf4Wu//Rt841t/QCnp+59N+wk5J8QY6LuR4Ht8qEFzP/T0w8A4DAxjz3574MH9h3gvfPTiBRfnG+62d7jgefLkDQTYbrfsdju6fsVFDGzvrklZ6fuu7h2doVghLYmlGMF7Uq6/FnXR1TdEoJSszEfBuRlxEGLEeSM4z26+4zd+/Tf4S3/5q3R9T14yORSc9zx5/ISLi3OePXv+ag9a0zRN0zQ/1lpQ2TRN0zRN0zRN0zSvgBOPWd1AKRiKR+00VhUAq2MXEZIpSQ0ReHGVORwPjN2q7rl0DgZBHETvGEJgiCuWdASD1bBmPNtwf7NmWozd9hrMWHYH8rwQ+oiTcmoD1n2ZWhRLuX5MlZLTy1WadfSruFMrsSDBIz4g4hAzTAwRAbM6ajUXtBiaFfEeHyLiahPPVOsIWAXNBcXQIlgWilEDzmCETvmp88Td0pEMkjlUjWVZEJRlqfv1un4mHQ6E2CMSEDFCdBx3RyR4XDeQygKlhnFWCo6C70ZC6E57QgvmPE4UFcOJwGlEbfQOKwbOoTnhQocWJeWEqFJQzIcaLk8T/dhxtjmHzcVpL+CBrIVUZkrKTNOWZcosZaIkJRdhOsLdnXF38MypZ1ZfX+/pmqihpOAwnMDglPOh8PC88NrDjodPzumjAwdFC6UUPEI+ZJ4fDtgEaQnM2XNU5Xyj/NRPPWJ1eU56f4cpmBk553otOldDaDUkZUwdRYWC4UMN1afJyMMFO79i3t+wHPbo3cRRv7fX8WBgztN3A7vtHYseyUu9RoVX26asE2qFzgvjMPK5t36Gn//rf41uHE4X9b+UPnroxp7XP/M6/8F//Df5q7/w8/za//Zr/L3/6r/g3e9+h/IK1y2KSG1Bdh3D2LMaRnyMbDaXxNCzOVvjnWPoa2hZtDCOax7cuw8CDx88YZ6PzPPMPB3pukjX9cSuZzrukTPhbntH0cyS0qk9WVvQ3tVz1YVAKoVSjKHvySVRipJTwYpHs5GWmdD5urdVEr//h7/Le+9+l7d/4m2yRFSNED2X9+9x797FqztgTdM0TdP8mdCCyqZpmqZpmqZpmqZ5BbycGnqnkZ1mggJqdto6KafmnLGc2nMe4fausDscOF8ngnOIGi56fIzgPOoDzjvcrMxl4VCMod8QVxtWFx2rszXqHL7rsQRFJlQUzKNLQcnkKfGyNFkzxwUJkeADTjwSPSKAqzvzas1MayvRAXi0FCwv5Pn0dyo45xnPL5CimC5YVswXLAZ8hDwLc5pJsyImtWVqUAqsfOEzQ+bdKbJo4HiI9H7GnSskYSoL+92e8WxHHFeE3iMiDMOaLg5kLUy7AyUvhC5iYqg6zAwtGcsLsevQYiCOYglxsY7RdB1kPQXHhqNQUPLxiDkwqSN7nVOW3QwqXN57xNmje1haOOx37A97ppRIaWKeZg6HiWk3Mx+N/RLYT4FDrgFiRhCrIaATh6eO6nQCUZReCmPIbEbl/jlc3j/j3sWG2LsaBJeCOEFzQpNHLSPHxP46ICZMpoQh8eb9wOfeepPXv/ATSNexzHNtj0oNkb13CEIIgVQM1UQqhZzldK4NsrDMwvLGpzjkmXl3R95N6FQ4mJ1GGcME9L1nygemlBEJzFYYhdP1/WoI4ESIXug6x+psw8/9pb/C2z/59vd+wumtAS//AfWSFi88eHSPtz/zBuPQ1eNRyisrVToR1uPAuBoYhxWxr3so+36gH3rGcUSL1gAx1x2tYIyrFcEJJoZ3cHY28uHTTFFltRq5u7slF8V3gdVqxeG4Y+g7bu+2jMOAmecwLYQQEBRPoHN1TOxxmuuYWIzluBCCICgiHUUcasaHN9/la//ot3jrc29RyCxLInjPenXGo0ePXtHRapqmaZrmz4oWVDZN0zRN0zRN0zTNK6AKznmKKmpC+Xj0pZwGehqFOuKzmKEYAWF3FK63W+6v77MaR0IMoIppOXUxBSdCCJHge9IxkaYDsR9xXWAczik4MKOkBc328S7KkhKWMzlnPB4nAYmhjoYdepzziCt1X6EL1HWUivOhhprOYyKgpY51XYSSamBiqrUB2A3knHB0qJ8oaaKgDL5jEcVJX0PcUihZydnA1aPysE98MA9kc8zFMR0D46CcxR5TmPeZw/aG7uwCFwKCIH0gaCBgdP3IfDwwHydEM8FHlpywXAADVdQclIS5gPcgEjFVlmWPOCOEwHxM4MC5CGaYguaJoo7LB48YN6s6kva4Z7/dst3ecru7YZkSx51yOMB+dtwtI0sJJJVTm7b2aQUjfBygKSLKyhVWvrDqM+dr5fI8stmMnJ1t6IcVNT4q9crRTOx7VDMlF/K8pcsTs4FSWJ8VXntt5I3X3+TR/fuMF/dI4sg5I64OlHXO4bwQYkBNKSmT80LShWKG8+A9zFlZ3Mj+bMO8JNK0I+8nSlbSKXQvQBbH43sX3O2PaFGcUzbUtuOr3GAoUjelBger9cDD+4/46l/+KuPZqqbw/+ovBAzz8J333sWCYcLHod2r4L3gvSPGjn5c0YWOy8t7DP1I10eGbmToe7rB410g+EjWjDude8ywYizLzP37l7y4usKGOk755vYWNSX0Eb940pJZjfXxdocj3ntM6xjeB+f3uN5eQa6HIXgwhSkZTAtGQYKrb0owSDrxT/7J1/jFv/VLDKsBLZlSCmfrTQsqm6Zpmqb5gbWgsmmapmmapmmapmleAZOMmcOMU1PP1bWJpxhEDTLGAiT047AyLY7bfWY373DOWMcNqKDLdNop5+qoy1D3OXZRKGKIFxhqsOYyaIZlmdFlJucF1QXnInJqUrm+x/lA7Dtc5xHnwQnOdzjfUYfSystlm/XzOETkNP4VEMNFCHhEM+M4YGqUHLGi0HWkPJDLhOaME0N7IRw96bCQyPhgWBFKLGxMeRCUbelYtGMuRs4L8Tyw9h3TsjAdJpbtDbHrcOOIUZuAILg+sF5fMi6JeT9xmCbcUl9vAlJaKCmhJMQVNE8QapNRFJxzaAbn62hbWya8i6w2FwybJ4Shw6xwPE5s7664vrrm5vaOq+vE4eA5zpFjDszqyKcxv1HAUXdnysd/FaJTBCM6ZdUlNr2yWTsuLiJnm5GxXzPEiISAuYCqgCkpzeTjTD8MaE51n+R2T86FQ1HGVeLho8gbb77Jvc0loesI95+wS4mcEt1qADJqSt+v8O50igErQtYazApGUUEW0PML5jiy3L5g2c9wKGQz0inWywIxRNZnHZDZLzNSMoMIe6nh2qsgp+jeOwjREX3P5z/7Jb7wlS/Wc/gJHmGZF779nW8Tux7QOib2FVUq7fRmBe9rMrg+2xBjxzB2dKHj7GzFMHZgcHZ+geZMzollzoyxw/eeOV2xJMU5Rxc6Vque6xfGOC6kJbPd3RA6D0tdKbs7HFhS4uXIacP46OYjSlGkp07GPTUntRhpUUIUmCYwT4w9mPFH3/o93nv3u7zzM++QSiKkQIyBJ48f4pyg+oqXezZN0zRN82OrBZVN0zRN0zRN0zRN8wq8LFBmU4rVUa/1Q0Yx6i7G0+eVumNPTkNhb+6U/eEa0YQDhnEEHxCrAYfEiHfCcXtFCAMhRNQJOWUsG3mZSHOmpCNFlaJK5wMuCKHviHHADx3OOcR7XOhqkOak7qN0DtC6Z9Lq+EnBnVpoDsiA4WIk2oC6jAueqCOqCyVnKIJaJpQezf1pn6KhZnTDSBpnpt2BtCwoRhHBsvIgKtsCkwU2MhM6h3g4O9+wJrPf7tnfXBHGM4ZYA1UXI2oFK7Wn6rrI2HUMZYOle6ScSEsmzxO5gJWMBCEdD+AiXgQfHF4c4sCktt7i2OF8xLxQUmJ7c83t9poXz+949tGeqxvhdo4cc4+a52Vn8uUI1zrw1AinHYlBjCBKdEr0hTEq65VysYms1iNnmwu6EIixtmVdCKgWSsnkkki5sBwnpttr1p/9XF29WJQ8zRxKZqFwPsDm4oLVuMaHulvU3X/M9u4O5wNdHHA4TA1xhnexxo1mZAqqkFKNqXOGKQvyqXssLjBt9+TjhM6ZyYx8ushFPH3X03Ue9Y7rNDHmjApkL+RXFFRCDeNicPR9ZLN5yJe++Of51Kdfq3tUP4Hd9o4Pnr7HtD/iTD6+S3/YvAjrvt6ruWRUtY6EBrzz9EPHMA44cbggrFcDx0MixJ4uLnhf97b2voO1o6TM3HX1GPjA0I/EWHDe8f7Tb+N9YM6JlDLOCTkrMQZKrvtex74HMUoBMfs4rS5ZWY6CF6MEw/uC4Lg53PH7/+z3eecL76BaWNKCD54nj18jhMCypFdy3JqmaZqm+fHXgsqmaZqmaZqmaZqmeQXEoKAYilJHf75sUiaUxWBBUatb/pwI7tS6WxLspwnNiVKM+6IMq3NCL3U8qxopTSCeVJTOKWoekqDZmHYzJR0RUVzoGderGlB1ntAHfD+CaA1zxCFSww6psy8RFMQDcgotgZefM8Wcw9CabQSPYLjs6rzbEsFFLNWxpPXBA6oZw6EUXAedH/B9IB8T0/ZISRmLictx5iJ7zIzoS23KdQPSO9abx3T9jrvb50y3V3T9gOv62gSVrgaVUvcrCiDOkMHTE+hMwFan1+IwMSznj0t0uJcnrh4TK0bRxDRPHKcjNzcvePbBDc+uEx/derY5ktUjCB4I4hAyXk77PIEgihclAMErXZcZozF0Rj/AZuxZrQbG1YquG/HRiGFAxCPSgXMsOTEdtqRlZpoPLPPC9qMPePgzX0S8x3JGRYmD4p1ytgkMqzXOBVyMiI/Ioycs04w4cGYUVZwLdL2jCz05zXWXJ4KZJ+lCysI8wWye8d4lh/lAXo7okslzZjmF72CYeOZUsAI3+yNzypyJocA+2yvZTylAEIhOiNHTdQMP7j3myz/7swyb/hM/ztMPnnJ1fcXhsK1t4dNr+mELztENkb4fGPqRcVwRYyD6QBd7Uq73y7heMawiznuGXlAR4mrEUHZ3O8bVCnELu3xH6DoO+wOlFPqu4/r6BXZ6Bd4Hjhk2Z2fMy0Lwyrwkcs4ALDkjUs+MKnU3pQhFjZwKOUHshJLzKYA3/uAb/5x/b/5FfHSUUlDNPHz4sDZEaUFl0zRN0zTfnxZUNk3TNM2PiXfvlM/8vf/xR/00mh/E/9zO37/KH/83v/ijfgpN0zR/YuYcqgWzGlIWhGRGAhaDdGpSfm+AZQ1fvMDZZUfOiX1a2M8fgss87kbiaoMLNRC05UhwgVKUnBaCD5gU8nzEOcUPAzEMxHEkDBHXBXzsAPt4B+Vp3ifOR0QEEVB9uasP6v5Ej5mAN9ACEj+ui5pIHW2bC6WApURKM6rGMk9kTWgpmAppmSlayEWRNGM4BE/RA9ovgDASiMFQOfJ0G1ivld4Fsk5MqWczDGzGFRI77q6eMe9vGbuHNVeyGooKASPX4yoeK7kuW/QKxZ2Ot9Z0xgvia7vQHGhRcs6klNjvt9zdbnn+4poXzxeu74TtEjnogJ3OlUNqS5KCEyO4QhTwLtN5JXqj6+vu0WEUxpVnCB2roaeLgf7sjOAdXgI+BHyIGA4TSHlh2m3ZbW+ZpiPTYWaZC/PeuHv6jCfOMa5XHO62jP3Ap98cyZPhA8RYd5s655D1GZydk26e1rC69zVkDhCLQyXhuw6XZszDkhNLErLCbhFsM7B6eI/906fMxyO7w4RkO3VqayiG98x5IWVlTgs9ikMYzjecmTLdbAHwLiBA1vwD319yagAGDzEGVsM5n33zHb70r/3MJ34M1cJ3vvMtnr34gGWZUFM+WQ/z+3i+3uGcI8aB1eqcruvx3tP1kdhFog+1Vbnq6Lq6N3W1WmGiqBa0KONqpJREiB7E4yThBHDK1fU1AlxdXbNabchpYRh7iiq5FFJaWK/W7A+HulP21KKMIVA01zdRaG08pwxuNkIoeJEacIvy3Q++xe56y8Xji1MrFO7du8R79//x6pvm/z/+n37f3H6v0TRN86PVgsqmaZqmaZqmaZqmeQWKKXUQqaAYZva9sFKVjL6MeWojDyGIEGNhXEWyTURTlly42W85G3d0Q49oh6XElOvuyb4bQQwfA8F3BO8R1iCCCx7XdbUt6eto17owsyA+gAdndTeliDvtnvw4pTyFlAYexHzNA62GTJqVUhJlyaQpMx/2LPPEsuxrKJmMkua671Bc/d7icQbeDzgP4juMnt1hz3I4EJzRrRyborx7F7DQcfnkHqKQSqIsR8LZJePFOfN0ZDnsiOsNMXisaA0dvWC5YM7V0bVSAyJKHcOK1HMh3oNYDSdLZj4ubG9vuL7d8fxqy+1d5vrWOEyOrD359PpfDr/1UoiidK7Q+3IKJpUQjKGHvhO6IPTjSPSRYYx0XUcfYh0z6x0+9IgIzgXEg5mj4Fjygf3uhu3NC47bmXku5AW0OIoq0+0N037HxaPXmXd/iOs6Hj/6FB89ex/vAzH0iBNMFbl4wIKgVkd/CoKWgpOAix1qCc01MnfDhnIKKQ9JMIHz1RlL6MhzYj4euN1n1mJkrdesA8xFoq9ji+clUbdgGs+3O65PuwuD6/jK5/9N3r/6F3zw7Ls/0L31MtYPQPSerutZrdf81Od/msvH9z/x40zHI+9/8D6319eknDH93sjmHyZB6njXfoXzjuA96/GMcRjpYmToY9052cVTg9nRxQ4XPc4F9vsDXgLiCj5GyuFI1wVKqq3n36Wf2gAAIABJREFUvhvAjNj3XF5ecjzuCd2KcRj57gfvoao4J+wPB7yrrWxVRUyYlzpWNmXF1HCulqeXuRC9EaIniKdQuNtdc3NzzebBOQC5FNarM3xof7zYNE3TNM33r/2fRNM0TdM0TdM0TdO8AmZCedmmNE/GUUxJpmTqbjrDcIATIYjDAf1oOFdIangKvQ9sDztu9tecbc7xEmoAmjO4AKfxnz4GfOcQO7UmvcMFj4lRFy9mNM11B16MuNP+Qiu5zj51DtNcgxJ9OaxTwFEbh5oAQfNCWQrL8ch0uGV3dcfuekeeZqxA7B3dMLJe93ThMWE14BCMgjlBVVHqyNWcCwiMF/eZzw/kZUZ1YR33uOfG7dQxrM5ZD2v22xdMuy3duEEQNvcecP3sPcphi/cRfIBimOXaUVXDXEFehiiOWsPLCiGgpuQlc3d7xbPn17z3dMf7H03c7TwlO4QOwWrI/HHn1eilMPjCGBaGqPQehqEGlF10xN4xDmv6fiBETz+MRCcEH3He1ccxV9uAwwiqFC0sxcjlSJoXDvtbDrsd+7s9ea6jbL2HbqjB57jsOV7fcPHkdZ5/+5tIZ/hhJJFZD5eErgMJmAn+8VtMViiaCKGrsXlWXOcoqZxGvirOB1y/IhVlVtip4QUePH7MtGSW3Z79nLidlWA1iIwCBYfiWI2B3d0WnRccgjMoRSmn5O+dJ1/iv/xP/2v++1/5+/x3/+Dvk9LyA91fDk5hr0ec52LziJ/98lcYz4ZPeH8a27stzz76iLubbb3GT/fkD50YzoNRCD7AyzHQqoz9iPeBfhjxLjCOI8HX3aTBu3rOVkLOhZwyJSkxRJY0450wjD0heJb7D7i6umI6HlkNa7b7O+6ub8AgRM88Z3JRzNxpL+ap8V2Pxilwlvr6FQqwzEY3GCHWnbU3t9dcvbjizc99GkFIS+J8c8l6NXJ7c/fDP25N0zRN0/yZ0ILKpmmapmmapmmapnkFzBQ1RQmnHZVGMSinduXLOMRETkNQaxzmg5AtkXVB8IwGQTpujkfu7/d4F3FS23fihFpNzGCG8x6RAGgNwxBEFciYU1zsaljmX8Zu9fuLC7VliGBqoK4+R8mnnYQTZc5MhwPTrrb59jdH5oMwrCIXDy45e2tNGAbCWNtdqSSW3YHjMpOXI+m4I2vdeaeWT/FfrCGIczgpKIWUEqB87olys/XsbvdcXtzjTO6TdnencbqG7yJdv2KZJvyq1NamaQ2BpOBcB0FxIqdg0LCkmEApibvba7793lP+6Fs7PrwVdjMU61iJQ0QJFLzUACcIdH4hemOMhc3K6AYlRkfE8F7wPjKuV/Rd3TfZ9z3e1/YaWo9l3V1piI/1486xpExKC1kzRTOHwy3H3S3zMYEJMQpxCKfgMzKebeh1RsoC/Yrh7Jx82JPCGtc9ZvPgDfpVhweki8RPv83tPJ92pSq6TKQl0HdrfJQ61jcVrMxkF7nawbPFOBRjHSPhySNu5iPH/Z5pMXbFWEnNtgPCAqgJmjMfXe0JZnjAO+GNx49Zbu/YHQ78/Ff+XX7h73yV3//uP8L9g7oP0XtXw+rvgwi4U0u3Cx2P7j/ip77w07hPOobUjI+efcjVi+fsdntKKZymof7Qo8rachacBLpuJPYR1ULXRRQlF2XlBed9DaVdwHtPH2vj9liW09jkzDB25LygBeIQ2R0P9X5wgaEb2e3vOEw71AqrcU0qhXlZKHravmngnMM5jxMHZEpRvDvtGzV4eRSWAnnOTEDfBw7zkWfPnqL2szjxpLwwdB2Xl+e8//6HP+Sj1jRN0zTNnxUtqGyapmmapmmapmmaV6CYntqUQjHIvAwpOQ19rTshPUKgBjff+1pDi5Fs4aw/JzjhmBaudld0XU8XO4yFw7QgQQjO1TahAqEgeHBa/1u+t5NSoqv/LgGzAnYKZUoN+BSwUijLQk4z03bL7YtrdldbUjFW64H1as2qu2Dz+j3WDy/pzzYQIpoX0jxz2N5x8+wFLz68Zn+7gyUh5nAiiKuBiATAGV480p3CMsuUUkezenOcIVxslMPNc/YXG84uL0mHA+lwwHcrSpqJw8D25hlxPuB0qKFkKajzJDvW7xkmJEY0Z3Ja2O63vPfhjq+/u+M714apB8DhGETpXaITo3NGdJkuKF2nbEZjtQqszkacM4w6ijP4GvoMYcU4ruj6NeIKolDKTCkZ8bFOnXUdznWYGVmVtN8zl4WSF1QLy3LksN2yHBbyAsPK08VA1w/E2BH6ntiPuOnI4B3Pb19w+fh1rt57F//aT/Lln/s7fOZf/4u4acfdr/9PLIcX8PAJeX8gdCPLNJPTkdKPiDOWeanBsYKIkFzgvVu4yrVJGsYetzlnufqQNE9QYFJj72B9GvuqZpSSmdNM542EnsYH1+auntq5b372bfbzgd/9g98m5cSj+w/oh8h7H3z48c/5k5BTmuhF6Ls1b73+WT712Sef+OtVladP3+ej5x8yTbt6X9oPN6R0Ut+gINQRqqaZXBZE1vjOE0Id+eqdo+9WIFp/XfCC94GsSt9FSins90f6rsP5FWpwd3tLLkaIkVJqyK0Ucl7weBweP0R0X98YEcSTUWLoqJOQC2Z1V6VzteHpxOHE6n14OsbLkuu9GhzTtOeDp0/Roqc3Owg5Z+7d++TjdpumaZqmaf7vWlDZNE3TNE3TNE3TNK9AOW0zVByGo5iRzCinTYfGaXwlEETwCE4MhyFmpFIwVcawYxPO8Grc7Xdcridi7Bj6M1yZKMuCiIOhrymL1HGvphnn42k/ZERqqfA04rKgJSNy2p+ZamCVpyPH3Za7q1vubg7kJTOuRy6fPOHeowd0q64Gno76GrSQi5H2Nxzvbrn58BkfvXfDixcZELpOGXshek/0tQHqvQP3srdmNcgRQUVwJuAh+q6O9fQRFz3HZY+fAnSBuSQ6SyyHHSF4DM+0u2XcBIoTVBOUgJZExljywpxn7u4OfHRz4N2PCu/ddhyzgJz2HAp0UriMM30snI+F9aBE7xiHwLheMwyRvh9ZcuJ42NFF6LtzhmGgC/EUANURuSlN9cy6DhcCIcQ6CrgUkmZyKUzpSE6HGhTmRFElH2fSNOPxjBeB9eai7g0U8BKIvqPzkc4Mf9izu37B49c/y/H6hrd/+W/w5M99BRcDZtA9ecLN736No8HxeOB43JPnmTTvyMMZpvW4B9+RdAEzTDxHlAXjaMZ6vUZWA8fvTGBKr3UQ7s6EtatXsRqsxhVrv2a3e17/oMmEpMoff/iU41x3mn7tG7/O7X/7Af/wN/9hHbtbMj47/qV8/hOT0w/Faks0xMgXv/QFujF+4sdIOfHuu9/k+UcfsSyZkvX7ei7/b2IMzEtCnKOPA9772oamBpKYIDhi6DBTQnCnMqNSitURrzmRsjF0I2ebFUta8E64vH+f29s7bm/uiF2g7gdd8ATMlMN8ZLvboS/fFuEEZ8bYdRyXqe7MLS+DytN5MD5OaosCGJLqyGFxQlHj6YdPT+G7IFYb2Pfv3fvhHrimaZqmaf5MaUFl0zRN0zRN0zRN07wC5WVDy+zjkDKbUlAQkFNI4UVOsWWlajiU6CPHZeZ2WYj+iBc4Zs9h2TPkAVNqs9IKZoKq1TGuppgpog4wTFxNRO3U5iwJLQlTKHNmno8c7q7Z395x9XziOCc2mzMefuoJ9x5e8H+xd2exlu7pfde/z39433cNe+/au8Yz1Bn7DHbbbqedOMGOE9kJMpYhiEgIRIQwgyIuEfcIJKQgIcFNAAULga0EbGaInQuwwVaaBE/tGNs9ne7Tfc6pU6fmPazpHf7Dw8V/VfWxHbvb5lQ3bv8/pa2a9tp7rXeoi/qt3/N0i65MlzUWcR5ByGkiBSVOE9MwsHp0l4s793j4YMd2Zzm8tOSZZw+xjRKmAWsU6zwCiJEnjU9RjwpYa7GNR8Ti2gbr3P6YCJpzGRUbM5AJOpH6gZQTaTL4rmXse/wikFMJX4gDIUxMeWK9vuDR6ch7p8KtrWcX/X5PX8ZRMtPWZA66kaNlYDlXDmYt886gIXB0dMLy8AiIZBW2/YrGew5mC7zvaBuHsftzKAJtQ+sWIAZrG7IawjgyTlvGOBBzJAwT09SXvZ8KMUyYrKSYaF2H71oWiwXOe+I0ohoxRvG2pWk6fGPJ92+jTcMYem689gmufvzjZDLbew9YXr1M++KLpOGci/N7nJ2fcXbxqASLfY8elbHEikG17CjNRlHnOMvKJsMuKS8fnzCmyDBsaQSGsYR5O2BQKNsgld20A5sJMTBDiECjEKfH21jh//jU/8Q/+JUZF+szAM4uzssuxvSHb1NquZwBEGM4XJzw6huvlf2qX6d+u+X2nTusVuekEMh5Xyz+Qz+b358xZfxy4xuc81jr9jsgM1YsbecxFlKK5BxxfklWpe0axjGw220RAecs3lpijmjK5JwYxwHNZZTwbteTVTEGFgdLVuszQhxZzg9xXhjHQD/25XVPQ9mPqUrKuh+NXI6nannjAJT7Qowwny3wNpNDQkV4+PABYZpo2hmqiflizpXLVxARVD/Ko1dVVVVV1Z8UNaisqqqqqqqqqqqqqqcgqZDVkLCltUguIch+vKQRwQt4Kc0+I4LbtyklJxZWUe8ZQmBjB5ZuzkTk7ukHLNrlfmRrZD47IKZATokcEykqSCpfB8AYdEcJF7MSxp6h3zJsRtarNWfnA6tNQmzL8zev8OrHjzm4fAnnWzSnsgeTMsqztLAm8pQYhx3rs1M2jx6xu7/mfD2SjeOV169y88WbtIeH2MYybLZM/ZYcE0LGOItxDbZpEEllp6A4RAxqTEl3kX2YmiFDJqExkaYRp0KOGbyQcyaF0hg0ux2IkENPyJF+t+V8teP+Obxz3vFodKgKwr5FaYRG4LAZODmKnJwYDudL2m6BtZaUE94q3WKOOmW33TFNA75pOJgf0TYzjLWkOAENtumw3oMp7Vm07MM0xjBOO84v7hFTBCNMfY/k0m4VA05LqDxrW/xsRtfN8d6RUsCIYExD082YzZc0iwOwwnjrbQ6/5we49dlf5/v+6l/Hdg3TrofHY1SN8JW330Il8ujBfdarc1rv0H5DuDYRp0SKqYSUUfHWg/OcRhgyRIST566xXl0wjRNGwcUysjgBAaWjXLfTuMKokgRWCEcocxFaLaGmAsPYM+zDMijBWIjxj3h3yf4lGkSFa1eu88zNG3+or3Dn9m3uP7jH6mJNjBCS8lHnbMZICfwkgySc67C2QTH7NvD+Ws+JlDIpRaxx9P3ENA542+A7B0q51kJCTGkmxxjZjT1N25CgjFc2jt3Uo8lipbQsh2EsLWrNNH7GrGvY7tbkXI59zrofBatP/m0SwJqyZ1Q1EkIiTwljA/fv32O3GVksARVuf3CL1fk5i8WczWb70R7Aqqqqqqr+RKhBZVVVVVVVVVVVVVU9BUkdYPY7KSHt//xxEGAAKwZT+oXIfm+lMxZrWxoNHDSJncAuBqwmjE2sQ2S1O2fWHZBTpAWwjhQCYbcF52HfqIwxPtmTOE07NqsNq/Mtp+cTZxsI2XJ0uODV10949oUrHBwdPGl3quYyK1Zs2ak4jaQxkOPIsFmzvVixenTKdDHRx8D8ZM5zLzzH1RvX8d0c6Vowwrxp6eIBKYwl77TCvlqJprQ/Jq48ZxFUSiOUbBFryohJLDhFBFIANJFQYo5spw3rzYh0FxixhGlkt9txtg3cvbDcWs1YBbOPiTONGGYGFjYyd4nLJxNXr805OljSdUucb8kp0PqOS8eXkZw5Wz1kPYyEMOJNRgyoscyaOb49QmgQmwg5M+62kDKN9di5BQ8x7hi3A6oR8Q5HCZsyEeMEi8cYh2s9zjc467HGYMRCynjf0s0PcG0LJDRb9OKMA+PpN2tOb7/PwYuv0CzmNLMZIoKxlll3xKY/4/TRA0IYsbOOcbsGobRWpQStzlusd2ANkyqRcqwXJ0fcO32PpJk0ggcaYAB6haU83lWp9AjD/voOwMTjOPGjtY/NscaUKakqPHP9BseXj77+76fKrfdvsVqds15fMMVI3hdiP8qw0lhTxus6t/+2GWsF7x0qMIXAvJthvS8BpJTAehh6Gt/RtB6zv07CONF4TwiJfhdIOWKNxXrLNE50bcvFRUDTxHze4lvLbtPjfMPQTzhrsdaw7XdMIRLj44WcWnZdWkNK+x2ZlHZpzpmeCRFlNvdojty9e5v16pzL104wxiLG8Ju//Rm8tx/dgauqqqqq6k+UGlRWVVVVVVVVVVVV1VNgRFEtnanwodGvQNlH+TigFPY7CMGSERNRsTjpcCZgzMQ2whgjM+vI2fJwfcHzswOyQs6RlIUwjkicEHGkHJjGnnHq6Tcb+l3k0Spx/0LYjo6QPdcvG77rtSu88vLzzJZd2ROpZZSkWA/Ggpr9DsXIsN6yOT8l7FbszreE7UQYFNMarj73HDduPsfy4ABxBpxFSZhsEO8QbzGNJadcgiBRckoIlrwfS4sKWRNkZb9FEyMlCLFiweyDn8GiZkLGjFqHNJY+GYa758xnlj5MPDoz3N003B9axlxabTGDEzi0ieNuZNkmDhbKwSXDQduWYNAqaMRaw8HiiKaxTENGxHOwuETj58BIv7tgvTtnCj3WeNp2gfWWMSgxBea+wTUtxhqyGnI2xNijWWgA27QYY9AsuGZeRtB6j7MWsR4vDmsNotC4Q1zjsa5FzL6XK4LJifbijONnX8LNFgCI7C+k/a9fePVNfvVXfp7NaoVvPOMwsL24oMla9gyKw/mOnCOaATGE/fW6WJbXdPrwjLZZcBYe0gIzgXWGUXiyZ7VBeEQma2kI94BXJfLRjlKFr65RDDkjqexNfPbZ55jPZ1/31+j7nvfee5ezR+fsdiNxP/M1f8SVSoPFOYvoV3c+qpa9kDklcoKUEikFYoyEKQAZ5zy+deScsc7jrUWw9ENfbhWU2eyArk1crC5wjaXJTWllRiWnyBhGdsOWjOCdxWRhN2xIMaGPQ1nKdSJASvtdsVn3LWrKGyesQTWTU8K3jqiJ1cUW3f+4euU6r732Cu/+n7dKqJrr+Neqqqqqqv5walBZVVVVVVVVVVVVVU+Batnnh+5blapPRj2KCK0YnAgWxVPGwDoUESWTQQyN2jIqUnoiiqqh85YIhBhIGhliIGdlGDbQ9wxhZLcd2PWZ843wYAv3JmEVDEuxvHiQef6654UXTrh6+QTnXQknxKCawJgyQjUG8hQYthuG7Zb16X12FxvyJpIj2NZx9Owhl65f4/DyCb7xJbWS/Q5OURBT9gZqQo1ln6x+KKyJCKYcmyRlPG5WNCc0aRmd2jmMhf38S2hbMorLCQWabsHhNeXdt854dJHYBcud3rEJLQK0Qvl8A3OrXF30nBwlFnNh3lpm7YzGW5rGk3PE+paFn+GsIQyBvt8yxQnnW5aLGU17BJevksWw3TxChhI0D1NPmCLzbsF8ucQYB2JBFGctxhnCOJFyxpkW6xosHu87vHUgpnyed1iVshNUE8ZaMAo5kI0DBCsGRQm33+b6m3+Gxcm1cs3lDFKuLwD1wq1b7zKNA87B+mJDf/9dhvU5c/MyRiwphPIYY7BNg5FyGi8dH5M0s171tMcLwjjSoCxFeIQSFaKAVWVAScCxCC3CCkWRx8OOn8bdRUaIWXHW8+xzz2OtlO9a0rff76YE4PzsjNsf3Ob0/JRxGAlBeSr5mmb2ayrLrtU4EUJLSlrCYSJQWowpR6ZxJATh5HhBv9lxdOlw/wYCcN6y20bEGBbzOZvNhpDKWNbVZsU0TBhjOTg4Ytuv2ZxvmEIg5cwwZOL+TQJd2+ybo8owTgiCNULK+fHU5dL4FoMIjFHJOaMiWCdMaeDOB3e4+drzrFZrVqsVn3jzuzm/0/Po4pSLzQUX6/MnOzGrqqqqqqq+lhpUVlVVVVVVVVVVVdVT8DgM2K9+22+ppISTAnbfZCp7KhW7DylVBVVlItMoOOuYy5IoIyKli2nFMKaRPAZSiqRs2G7X5NWWi7OJ9y4ct3q4EyLrnOjE8lLX8N3PKq/ePOTk+IS2a0vzcrPFdy228zzuUcVxZFhdsLu4YH3+gHE7ELaBnAyzxYzF0ZKDy0csTi7TtDOMZnIM5dGNQVJAjAejaEqle5UyOSZUE5pTaVdmEFXyvrGVsyLJlEDJPt7xlzHqwAKuhFHOeLLjSeNssZzjl1veuxM5C4bTaGlN2ZMoJtGZxMxnDueBo8PMwdIxb+a0bQkkrXcY02GNwbsW13bklEk5klJENXO4OGI2m2GdLyfYCa27zm7YcvboHmG342B5icX8ANe0oCVMU1XEtni/YBom4hRou4hzhtbNy0hOcRhjsY08abhpzgiQyRgMai1KxlBaeFlA73/AyXd4Dq5dRTVz8cFdFsfHNIs5AFM/8vDefWKcGLaR83vvsXnnXU43Oy4bAVFM40gxkVMijgNoGVN8cGnJMG4Z+oHQDqQhMEHZPSnKVpWIlCBYBZFyihLKbP/z0yzXqSpJYYgjn33rN/j0p1/ihZde4tLxJXzb4px7Etj+rgfy4P5d7ty7zcMHD+jHhCL7NxF8tLKWEbWaMgZ9soM1a2QYRtq2I8bENAWsN0xjZr6cM4aetu3ohwEjQr/rCTHQ+A5V5eLigpwT4zSSU8Ti0RwwxhBSJMWEs45u2bIdduQMIfZ4Z4kx4axlCpEPD+fVxwt098+7sQbIhJgQYd//hpgD/+CXfoHT4QFvf+kdfvszn+PF6y/zY//Kv8zMz5jCxE/+t/8ln/qVX0Y/6qWfVVVVVVV9S6pBZVVVVVVVVVVVVVU9BRZIUsKgWLqCZbce4DAYUawIXoTGRIASmGgmpolgPZNxNPtg0tsymtU6D86QYgDJbHYbkka2/cDdB4n3N5YvrCPrHBGFThw3W8f3vgxvvvIMx4cnNI0r4xxVcI1D9uNXxXrCENiuzrh4eJf+/JQYMtY1HN+4weLSEcujSzTzBiMG1YimQBxGMAbTecQ1GN+At2XnnaYSKoVYAsoY9yNmTWmZ5fRkB6aoKQ2vxmIah7cGcYKkgOYS+pGVnBMpZWLOoIr1lmeem/FgveKDR46AYlRpXGTeTBwtIgcHsGgNjW+YzTqsCNiI7RZlRK1GWn9A03WIceQUSSkxpUDjPI1tERFiiCVQHSMqgkaD9wvMzDCbLTDOknICNYgpr8+I4juP6y15UHJMeN/iG4czDcZYjDEY4xDJSI5kI6iY/d7OfS0PQ8qgAmQl9TvCV76I/IUfQcSwODrGNc2Ta3BxcAg50/cbtuOG0/du8fD+htV6h7V+HxansjvROXCODWW/ZLNcsF6tSBPkYUSSsgM6gTmwAzaqnFghpxLzXVD+bgasFcJTa1Syv19g1/f8nZ/+CX7+F3+Ol158jTe+7XVeeOl5bt68ybXr17ly5RoHhwfM53Ma7xFV3v7iF7l77wPOHp0To37kI18fSxohZ7I1GGv2Y4+FaQo4b8mq9OMAUtrXR0dHWOdRVbxz5Jzox8xsdsCBFy7OV6QUcM6w2fZcrNasNxtSioQ4MowD4zAxW8zZDT39MJBSIqaMNQYEcsqMOe/btwBCeDySGTCyb1im+DvOXnlekSlEfv23foN7Fxd87rOfZ7vreefdr/DWrc9y6dIlXnnuY3jT4b1lmuJTOa5VVVVVVX1rqUFlVVVVVVVVVVVVVT0FIiWsipS2UlIwyH7ca9lR6UXwJmGlBAVRDTkaDJZEIiXDoDucWIzr8DJDfGmvpWkkp4nNpme9yzw8NXz+IdyaAqMmBOGqbXneN7xxI/LCM5c5OrhEO5thnYX9+FWMIN6gapl2I9v1ORdnd5n6Ht8uOLpyxOHJEfOjY6y1paWWE5oSKGgM4Cy2m2FmvoSUSBnTmiM5lx2XMQV0zIR+S04R4yzWN6XJlyMaFCsJ27Q470ub0krZWamUrZUqhJwIGkvbUYUoBgwslgteeG7i/npiGB1WYOYnTg4jsxnMO0PbWLxrsdaVPZk5g3iatsHYsq8RbAkicyRRxte2zRxjIYyJaepLOw4lxIB1LZePruI6x9T3TGGCgXKsGld2kFqLtx3OtexiIGNwvsX7Gc61GCMlKJYSxKpI2SNoLIrZjxG2ZJRkymhcElhv0DJvFxGhOZjvr74yw7NZLPDWs91eMK5OefjonG3M7DZbRAw5p3IlmrJPNaOMAr01NAcLzh6dElUY11ssMGRoDRyIcKbKTpVehQg41RKE7a/tRCY95XtMgZiUzW7LvQf3Sdly7+EDuk93LOczFssFJyfHnFy+zDPPXOP6tetcObnCr//mp3lw7z6bTf/UQkqR0vjNOWNzCQvb/YLNGAMpOMI4YY3DWk/XKCknNAlJMpvtFmc9zjuUyHozMEwDmjK73cA4DoQpspgvuP3BbfphRMQwny2Y0kAMEzmXka+5LMgsby4wSsqKGFPavsKTkbhl5CskLVdV1sd/Jqw3Pc6WY57iKatNz/nZmpAj0yry6GyFs5a7z97j5VdeLfdWVVVVVVXV16EGlVVVVVVVVVVVVVX11GRUHWHfKrSmNAadQCPQSMJS/k5xZEpL0WpCsyEz4XNT9kdmxXgLzpN2a3JOrNY7zs+Fz9wzfKWPTKoETVjgkul4o2t4+ajnxhXD4WKGNbIfSVuaiBhBnCFHSvNuc8Fuc4qznuXxEbPlIbPjQ5pZW15OnMpo2pJIlR18jcd2LaZpEGsAQyaTYySFSBrG8hECKYyMw4409TjX4puu7MPUjHeeputwswbjFcllJ6cYh5KJITFNI+MwMIZY9u9pRlQRsWCFy1eWvPTMOeF9QQh4k+nmysGiYdbOmS0PmS8OMN6WECllVCPJO7J4Ug7YlJm5FlWY4kjjZsxmsxI8xUjjZ4gmYk4sDg9o96GqOsH6ljDsyCkgeExW1DiMbfDtDKOGGBXNlsY3+KbDIGieQBUSxc3AAAAgAElEQVTVRM5lSaRYXxqVxqAISYQkhphBxeDEkMXiLl3B+DKOVlWZLtaklGgOFjjvmLUzzs8eMe56mvkBm+1DttsV07gjI1jZ7w41BhFLA3jnOD485Le+/DbWeaTf0omw2W9VbAU8woCyzkpUxQEWYQZPuUf5OyVVNv3END0iDAOzgyXWGpbLS7TNAu/fKe1RDTjfYG3mfHPKnTvvE+JT3KKpMI6Rxhk0C6KCaiJMI52dA4YxTLjGo7SIFVLK7IYN3jmCcRgZmc9nnF/0WAyLxZzNekPXzcrXmbUM/YA1ltY1RDOSNDNNPcM0kJLSNZ4QM8M4MY4TxhhySk/2eCZ9klOW32cAJYs8CXFTUgQhpDLOd7k85PkXrrPbvkVjGvwYODxY8OD0jHtn97nzq/eIsQaVVVVVVVV9fWpQWVVVVVVVVVVVVVVPgdn/nLTsphQpjUq7b1WWj8d/bolqMCgxGEhgnGXKA960qAEkgc3kcSDGgdVq4uHDxJdPPV8aJrYa9+NlhWPT8LHO8dLJyPXLhiuXTshpYpg2OO+xvqHMezWgFiQwDT05JubzI3zT0i2WuLbFeg9S0gw1Fg37kNMZjPMY7zDeI86DCjllYhiJU2Tqe/I4EceBMI3kOGDF4tQgGOIwYp2hnc1oZjPsrCktypRQ61BjyVGJY2C36xmmLVNQYs6kOKEkrG1wxmHsjKYzPP9sy8WmJ44Ts0XGtZ7u8AjXHXEeE1+8f875lBhzonMNx4uW4/nIpZmhdYKNgX1JE+dmdPMO4x2aYLacYRuDRkW8xXqPxpGcH7fnhNZ1BGMRVdBECmUnofMtrm0xInjXMutmpDASU0RTxBgL1oC15dfGokYIWZkiJAKIQQXEtyRnCAp6cLQPiCFsd1y8dwez6Hjw/gc8+/qrHB5dIyaYLY4xNnL+6BG7sSfFSFaLaQymcVjxOGf3F6/BeOFstePk0jF69ojHA2Xjfofl462OPeX3ipABv7/2v5ExVcrKqIn1bkcIAeMMu+22hKzo/nwaMMI0Dmx3W7ZDJD3tRFUh5UyDklJgHMH7hizKNI0Y42jbSAyR3W7AmgaXc9lZagFR1ps1KUXa5QEhTKhkpnEEhBADMWecd+z6HRjDsNmy2w20viPZxBQCU4iICMYaRPcjqUvpFvb/ZhgDOfNkV+fv3i+p6P69DYZrV69yeHCJ2WzGvDvEecc09Vw+Fs4uzplCeMoHtqqqqqqqbyU1qKyqqqqqqqqqqqqqpySqIe7HhLIf0ulEsAJeFEtpBCpKUkt+HBwqNBqY1JI04cRgXEMWYQo7hinx6DTx8GLGu1Ngp4m0DxyOTMMbXcvrl0duPu84nB2wmB0yKYQQmEKgNQ6VjGAhZ6w1GCMlnHQePyuBHOSvhpSaS93KRARBfIvxDhFBrCutvziQpsi02TFst4z9lhQn8jCR4oikiPUe71q8cxgxNF2Hny/wfp8OigXXokRSSEzDyGZ1zrYfwCqaHaoJMQZHaVMaUcqkSWG5mPHCc4lbH/TMjpTsZvz2g4m3zm5x63ygPbjM1RvPcnz5Gt1sxrkE3u535Edr4uY+J3bkzWcu8fKVyywaj1gBa2iaFuNKK87OPCjkOD0Z75lD2ceJd8x8x9CvicNE1jJi1VlH23VohuXBEtu4EglZi2pTwkFXjqcaR4yR9e6Ci+2GmBPdfEnbzBDjSGlkO/SYgyOuH19/0o4TMWy3O85u3eLg6lWc91y6cpUwRdarRzxzfI0oll0oV6Vx+4dmRaWcVwCcRUTZhcQxSmMsVvaPEUH2I0HLNQ6NlJAyAFvY72T9xsqqDCGSc8JGy24csE9G0QIoKUNMiZTKGwietnLfG1JWpjFgrKMfdiTNtM0M7z1D39P4BiuGxnuMaVFNONeRUhme2/iWcRyYhpHdrielzGa7Y5oCOUZAmMapjP9tPV1oSTGQsmD2uymtFXIuoa4zlpg/dL4NT9rW8Wukt8dHl3CNsFptuXzyDIv5Icv5jG9/89to5w1n56f80q/+Er/9uc893YNbVVVVVdW3jBpUVlVVVVVVVVVVVdVToEjZ+6dCUsViEBGcUbwIlgRSWkoZKaGVQk5CVo/TRHaQcgIaxHalXRgDj85Hzi5abo/CWRoI+0hkJoabvuWF+cTMRwSPOIdg8FZpZwfkGAlMIIJtDKIZjMN1HdYIrvGIEUBKg08DmikNQQPWNUjTYcSVtEoyOSVSjIR+YNxsGTZrprEnDBtMVCQbvLU473FdS9sdlXC0MfhFh3EG8Q61BoxHVYhDZhxGVhcrtruLEqDaDvEGQwvGIhoRIKSAWMFgEWc4Pracbz1vnU58YbMizS/x8e/88/xz/9SP8tqf+gQn164xXx7gmtIgjNNEv15zfv8ud976Ip//5U/x7q3P82J3zqsnJ8w1Y2YGTR72+0HFujK2VQ1h6IlTwhjKbstoSBG2/YCVjG9mtG3DxhgUi+9aEIfrPGJBVUpgmSJgCFPg7ukHvP/ofeKYODq4TNPNCXFil3vGxQ2ufs/3cfzGxzl89bUn15ybd1x/4xWOts9wcPUYsZblpSOstUxxQlrPaAybYcJYB9aWsEpsObfWltGeTQMpE1Ii5gDm8b7C/ehg9pN/gQnFIxwgBJQV0OvjXt43VlZlioqkkqTK/nnur2aysh+z/PQJ+32OWUmqqJRmbUpCzg3GwjBNdG3LGEa8tez6Lc45RHqsc/jGEWMijBE0M04Tm35Hv+2xzpOzEnMihEgmIuowImTJJRxNI9MYy3P4UAApxmKljD/erxYlZX0SeP9+nHXcfP4mj84fYbLn+edf5mh+ib/8T/4Qx1cvoUDXeP6J7/sz/If/0X/MF774pad5iKuqqqqq+hZRg8qqqqqqqqqqqqqqegoUQ6KEJwnFiynjXin7BZ1EIO8/x+0fI2gWkias8XgFYSqNRYUQA6vNjrNz4SJ4ztJILBsjMQiH4jlxireZnIRhShzvR5Q23Yy28ex2peUYmHC5xbkG3zZY7zGSS8DjHRoj5IQYjzQW83iWrRWM9YhYNKcSrMZEDCOhH4nDSAoJYwzdbI7NCSszrHX4rqFpO6x3YKWEqK1HrEWMJe3biWEMDOuezW7DMPZ03QGztqWxvoRqj0OoPJESoAajiagJTIeZt8wuKV+4t+W1P/2n+Wt//d/kE3/pB+kOTxDZPxj50HK+xKV8lRsvP88bn/wE3/9XfoT3v/QVPv2//e/86m/9X7y5GLii0FrBZItkEB8xGMI0MmxXoMpsfgBB2fXnTFPAOYPGSOdbnGsRNTROcL4lhwSGEhia/dm3nnEYeXh6ly+//x7nFwMnxx2N94QY2LkFh9/1fVz79u/i7S99ll/7ez/Dv/Cx72YBT17L/OSI+cnRk+uwnc2YzZast2vmB8eo94zDQI4Jaz3WtyCKYDg4PKSzhlnTkHNp0T66f592iiwoTWD5XTsN837kqwFahAPgQvQbu6jyQ8qKRUUef3+RJ2NMv5FPST/0KyOQs7LbDTRtwvuWEAJkmEKL7mDezbDeMoUR54XV6hyDQTXh24ZpTExjwInjYLkk5sB2CzEqTeOwxtMPA8NuxzSO9ONATqVxLESyPjkchFjuT81fDW0V0PwH92AXsznHx0tufebLCMLLL77Gn/uz38u1Z6/w8OED5vMFyTtOLl/nn/7RH+Hdv/XjDMP4dA5wVVVVVVXfMmpQWVVVVVVVVVVVVVVPgaJkDImMRTAIDvACloCQyWpJWoIeVbP/GcYRWBi8CEbm4FviFJjCjvMNrDcdFxF6jU/2BS7EcWgaZjYhBrxX5m1H1x0RUsBqyzT0NO2MKUYkKGPsiWnCWMPs8BDx+wBSATGIBcw+mLSlSqeaSgMQJaVImqYSeARAwTUl9BRRjCk7OckZKyXsNN4g3iKzDuPb0jrNiqZEzkoYJsZdz27sAeVoeUA37/CNAzKa9kN09y0xIxPG+BL2qmMM5Zi8+ozjn3/xOi/98D/L69/zHbTzeUlpPtwak8dhpQVjEKOIBT9f8twbr3Pl5k3uvvOX+ZW/+z9y973f4KUZzD10tsPHlpgD/XaHtw3dfI44z7DZkJLSdXPabkacRoRIygGViHNASgiZMAwYbXHzOSqQQuZ8fcY799/n/v2xtO8uZdZhZHHzOzj+nh/gvQe3+dR/8O/z6O4d3vxT349tHALszs/pDg8Ra5+8vDgFzh8+QoxlPlvQDzvIyq7fYcTQth1GTDkGorSzBV3rabsWzQnNGetgq+D32WMZpwrxQ9d5AuL++naA6OM+4TfPk+/+DRjx+gdSYYpKTJHGCzkrKUbiFMg2ks4ji/kSgyOrstyPX4aMc54YElMccNbSNJ5hGpnGiSkG2qZlHAbWux2aM2HaokSmMGHEMKWAqmKsIceEd54pTABPxsrC791H+ftpu47z83PGYeLo4DLPXX+el197me1uxVuf/Qwvv/wx2q4l5Mwbb7zJjRvXeOedW0/jqFZVVVVV9S2kBpVVVVVVVVVVVVVV9RRk0pNWpQBGSshT9lTm/fhMIaugmP0WS8gqTJMhMNGoR4wjJ2UcV5xf7FiddvSxYciJvN8EaBEumY6rzpUBnALL4zlXrt5g3s0JacK7limMCIpzFrTFC0xxZBx32MHT2jn28Z5ESagxpfFHGU+qKSEWck4liB1HcsqgGWMtzXKJ5oCmiNnPspWs6DiBKNY34AxiPca1qBhyDiXojCWwzFFRFaxY5vM5s8U++DRKjplslRwyWIN9PKE25dK0TBljHUkF1zQ86wyr+/dYnZ5xcPU5nP/HnKjHwaUC1pU2Xk5YYzHOce2lm/zgj/3rfO4ffoq3fuFneN1sUZ1Qo6Qp0HQzlkcLjHWM/YhrPLPZEcaU8M82lmGzQuMAVvCtI087xB5jxJZm5b5Je3HxiDuPHnDr/Q1nF4amUT44E9743r9I+53fxi/8/f+Vz/3Df8T6fo9fNLRti3Xl/Gzun9HOl/ChoPLs3j2OFpc4aa9x985thuFLTHFkGHuMN3hny3PQtG+ELlgs5yxmbdmFGTPZCpMtuwtFYVLYGUj7C9YgZJQdymx/rTuU6SO+n/74UnLOOGcQMRiElBJTHPF4FosDsqayg3Lq2Jkt4zDQdR0HB5aUAqJCyCVw9N4yTcpmvaXxZUzzNAViioSU2W43TONE1owx5b511pBTxntLCLIvE5c3EiCU++9rZJXGGC4dLmm7hu/+ju9iuTjijTc/hnHK2d1HvPWFL3A0v8yVZ65jjGW5PODVV16pQWVVVVVVVV9TDSqrqqqq6g8gIu8AqOpLX+fnvwR8BfhJVf2xp/S0qqqqqqr6YyCrIWhpnFkRHEIjgheF/U5KBVTKXsDHvxdgCo5JFWtAnCGFLUOYOL8QVkPLqIaw77RZYC6eY9ty0owsXaaZGQ4vHWJ9wzD2+LYhaSRjMBl80yIqxJRoxDNOI7vNClXwbcCIKeNYrZBTREzAGFdGQ2YlhUSaAqoJQTDWIY1gJCHZQmOQLJAVEQOzGTkOYD3GOYxvyUbIIZJTRENGyeSY0JSBTDdbMJs1uM4iYlAVxEZMTojV0kAVxeJRKZsI1QguGzQmUMGPa+595Yvc+9i3ceX5m7j5cn+Ef6+SVxrUWsgOaxVrLSEKbTfj2//8X+Dg6lV+/b/7cV73PYd5ZO47FkcHYIWYM8ZZmm4JkgBDClNpFzrDsN7h/ZJ2uSOEkZynMvo2RTQEhily+94tvvTufe7ec6xSJk6G7/0LP4w+9wx/97/5Wzz64B5pVS6WFCIXFw+Zxh6AK6++iNgyn1dV2a1X/Ox//7fpdz3/1r/zN3jnNz/PT/0P/xnD+DbDbkCzYqwFFcjlemy6lsvP3CAl3e9VLUF4AkZVjAhRoFk43DqQkiICDYIBRkoQ/03uMP7/yuO7PasSY4Y8kXJiwZKunRNjwgh0HQxDjzEGayO5TwjQNJ6QIpITccgMfY+xnqZpmKaBXb9hs14xTQPkMj46ZUWsIU0R79x+DymEEBEDIrIfC1uar1/P+bLW4J1ns1nzz/zwj2LEcPOl58k5c7G64PR0xcHJkhRHsA3eNTz/7HPlTQ/f7FZr9ZERkR8D/ivgX1XVn/j/8HX+PeDfBX5QVX/xo3huVVVV1R9f5mt/SlVVVVX98SEiL4mIishPfLOfS1VVVVVVf7JFLf9Bvy/94aR8eEkYySVQUENW/WpoqaWpFkImSSAZQ8yZOAZ2u8Rm4wnqSAp5/8MgzMQxN8rcRw4OIpcvNxjfcefhPX7tM1/it774DrupJ2oqDc1pwjUtTdfhuo7GdaQpEoeeuOsJ2x1x2xO3A2mYiMNQ/m4YmLY9YbMj7nZoKONBiRkNmTRkciqhhHiHdC3JZOIU0WCQxiNNgxpLmgI5K6iQNZMT5JxRSfi2pZs73MyX8E3KSFZjDSKCWIexpeUlRsrnWMCYfUhYFim6nAmnD3j/7S9wevcOGqY/YBToPsA0BnEecQ7rbNnlZxQxlhsfe503fvSv8esrwyAWO/fkaSJNiqrivKWMp03kpKQshHEgDoEwDjSupVseEsaROI6IUdBMzIl7D+7x2S8/4CsfwL1JeRgTl998k+vf+xq/9Kmf4eGDB+ymhDMlqJxi5v0vf5Hf+Ps/zzT0+4RQCePIg1vv8Pd+8j/nwZ3bfHD7HX76v/6b/M8/91/w2a98jovNBSEFUi57CjPlHIgKzjgOLl9lEiHliBVBozLGzIjgBIxzHB4fYfehKFqOXAvMgYbS8P2j+KM96o+HnEtQOcVYWsgCKSamcWAKkawKWhq2znhSyIQY2Wx3ZRz0lAgxkbSE6t47smZWF2sa25C1nM+2mbNYLMiqWCMkzSCCNZaccxmznEtIaQRy+tptyvIChH7q+eKX3+Hv/NRPsV0PNLOGECfef/89hmnLanNOShljHClnTi5fpmn+cTXmqqqqqqqqr6qNyqqqqqqqqqqqqqp6Cr7akCxhpZWyn1Ieh5TIPnAsH6JSxqmq0AdbRqJ6T0w7duOOfqP0U0NWQ9p/TQPMxLA0joWJNFaZLQ1t49hsVjx8tOP+/cDF+oyT4xnPXb+JayzjkPE5Y8j78a6GzniICcWBM6RcGnWaQxlzmgIaIzkkxDpUIaeAUAJZHUc0BdCI2BLwpTARNj1WYHHjKqZtQQ1x6Eswg5Q2ZSoBiojg2gZjHc67sm9R98NzFTAeY/fHKUVIETGmNLZSQoGkFkxCsmByYDZtuP2Fz3L5uWe5dPUaB9efR8T9zjP1uMr6+MRR0iBrPc5HUspEyYixvPydn2Dc/ot8+mf+Nj8wL61Wrwa3D4JUQZNgLGhKhCngfMtseYwzhibNmFJgCgN+1iHOsdr1/D9v3eaLHwgPQ+IiJ5Ynx3zyr/wlfu2Xf5GHDx4Q1WK9wfuINZmUlHB2xs/+zb/B3S+/xbNvfJzDwxN8tvzc//ITvP3+F/ir/9q/jVjP7VvvcfuDW/RDQMQxxcQ0BkKYyCljjAEM3rc89+yznJ6eYhSuXz1kfbZmkzJWlYXA/OCA5Y3rvP3BKVDaloESVLr9QfR/xE7lk5Wh32J0f593jfnq/aIB6w3WOVIKrNbnpJSIoQNjsGLohwG0tF1zjqQMrff0w8But2PY7Tusbn/cBMQo4zhhxOI7xzhNTNNUWpS5NGQVMEaI8etrUwJ0M4dzwsF8yaWjq9x47jn63Y71xZoHH5zywd0H/NL//ctcvnqMtR6wLBZznHOMYx0EXP0e/wnw08B73+wnUlVVVX3z1aCyqqqqqqqqqqqqqp4C6wRJgqOMKG0EGklYMkktWYWkUkJK+WqrMqBogBAhNRmNmXGK9L0lZ1tGrQKCoRGPQ1gYR2smGp9p2wbjDOfrFY9OlZyFrlX6cU2KgewdYgzjNJQdhVnwfkbKAaNl36RGUImoKcFTiiOCkGKEpNimQ4yBKZFJxLAjhh4NEzkGcgTRhIZEN5+xePEmzdFJec3jSE6pNElVIZfGl0gZRWp8aVEa656MERVTRpTmnFAR5HFT1QiaI5IFJVKi29Lns9bStMINo5xfPOC9z3+OZ196he7gEn6+JKdE329Ynz9ks1qxWB5x6eQybTtDtDQdRQRnLdE6rHeknMjW8MonP8ndd7/MZ7/wKT5x9RBJIzIZkirGeSQrMQbiOKHiMFicV+I44J1H2zk5KjllFOXs4oz3Hgy8PQXOcmJC+XN/8fs53zxktx05uvoiJ8/My47Qe3dImw/YRWUmyurO+/zsj/+n5Lbl6PgSP/wv/Ru8/sk/y6d/+x/x7uc/zyd/6Ic4OrmK7zq+9JV3OV+t6PuBcdgxjQPGNuQYMcbgXMONG1f4/Ocdxhpu3LjO6nzDlCECWWB+dMjJ5ctk3Se7okSEAPj9hxX+SPNf87dgSPmYACllrCstYGst3dLR+hnQoJpp55Q3BmjA/b/s3XmwZOd53/fv875n6+2us89gBoN9I0CQ4i7uNCVbYliKlSiS7JJk2ZbLTiqxqlQqp5RYJVe8VRwpscvlVBJJLluOZSlyIkoitYMgIYoACYAgNgKYwWD2uXvf3s7yvu+TP07PEIIGAGGRAjh8P6iuxu3uc/qcc/tO3XN/53mevEtRFCTzGbGjSUUIymwyxXuHNQmDQY/pbEQ5nbG0sEwTKi5d3KXf62GtZVbO8N59tZJyngKrKt6/toPdKXKcb1hYXODQ4YN0+l3OnnkBvPKed7yLfftWOfH8CU49dYb0ri5N8HjvsS+amRpFl6nqBrDxem9HFEVR9MYQg8ooiqLomvGiORcAPyQiP/Sip38E+HfA3wT+EnAncACYAA8D/0xVP/kK614E/ifge4BV4CTwr4B/rl/j0BUR6QL/LfB9wM20f775MvC/qer//bXtZRRFURRF3yyKQ/uYvrCG1bYraS6KkbbqLwD+SmVk23ZTgEYDThXfQF0bQuFxVUnTCI2zeDXzVrKCQSgkpRBD30BiHUmuZHlC03iGQ2U8TjFWyfMGCIzLGjFCkuS4qsJohyS3ZHmGJ6UqxyQCBMU1juBLQhAgEIIDPNZmiG/abQ6KayrK6YimnKClm8+xFJLE0l1YZumGY2RLS20Vqa8I2s621ABiUxCPaIA0RRLbBhsibZWfBoS0PWLCfJBkuz1qQEyKOBBr0KYNFxWPV4eKJbXKwCq3qLK2fpFnn3iUyjd0ewusb2ywvn6J3e1NZuUMk1gOHznGjTffzuGDx0jTrN0Oa9vQuQFrE0KALFfueM97+f2nv8iRyYTVtMCYDGMFyQBVysmIqnGktgDr8N5Tu0AvSxFnUEnRoLgQGI5LzpWOc+oxqbK8uMwtb76Ni2ee5/jtb6W3uEySZhACm48/wvC5C3SM0jFQOSjLGj+rYTLh3/7cPyLpdRlNhpx88jHuee97kSTnwJHrOH79Ldz/mT+gSDu4piEEjzEBYyzQVtytLC2RZxliDNYaOl3LrBFCpaCGNM/BZLhwOfRqw/UxUAssIvP2r221ZfRVPiiu9jTi6S2E+ezIQJqmpElOt9uhLCtUPHknodctWBgsgCj5booPincNxlgm4wkbm0PyomAhGPJuzvZ2hRihaiqaSUPdNG2Q7AOXq4QTa/HevebKVWMsW1vbpLZDnnaZzHb54iMPUE09WVIwWOxSl447br2L3ekmDz74EEWnc023870WiMj1wPPAvwb+8fz2Ptoi6UeAn1HV3/ka1vNB4PuBbweO0F6zcAL4FeCfqGr5ktf/NFeZUSkiCnwa+F7gHwIfA1aA54D/WVV/4T91X6MoiqI3rhhURlEURdeS+4Al2jDwS8D/+6LnHqU9wflfgT8CfhdYBw7Snvz8loj8DVX9P6+y3gz4vfm6//386788X9etwN95tQ0TkSXgD4B7aYPRn6e95P87gH8nIneq6k+9tt2NoiiKouiNbM9db6Kcfh53aYQVg5UGkQAIPoBH22pK2vawbTvYdkal9+C8oXEVrgq4UmgaO59IaUACmRgyEnpGKIySp0rSFawIu9OS0TCl9jn9YkaaKNZkYA1VU5MkKWmak9oEYxOcBow1dHsLNK7BlTW+ntE0Ja6p2wquVNp1aDub0E9KQlNRlyWurAkhIA6yLKMY9OnsXWFwaC+m00XlcjWmR10ANQgNEgSZz4Q0Nm3/XxTEzDNJiwbHlSa6AhoCqoKYtt+lYAje44NQVhVlVVNroHElzreVqh6hW5Y8dv8un3/oi6RZjs3aKkkNStCAD7B+4RJrF85z+11v4fgNN9PrLrRzRm1CmmaoVjgPiaTsO3yEw3e+nS888P/x/mP7sGrpFT1ElbpqUEno9ntYY0EVmxgaVyMhQN0GShhLUMN4WrPrlEqVfiocOXaUJEu48Y63sLpvP0WnQ5rnjCc7uI1tpl5IUdJEmE2hdopV8C4wK2fUu1Maha88+TRNVdHNOgwGSxy/8UYeeeQBBnlO7WoUT9CAEdu2KLaGgwcP0et22zjYKEsri5iiYPvskEyg9o7xdDRv3fvVFsc1UKviUFalDStnf84/c29k4cq8WsEagw8NO7ubDHpLeJdDYajqBERI05Sm8SRpQtM0LAwG9A8tsrO9zXQ2oZxV1JVrg3k1dPt9qnpKWc6o64ayqtr2siFcmWnZFi7r/OfntW27MYbl5RXOX5gRgmdhsctwtMOXn3iczbUtlhf38I53vJ0XLp3h//g3/5J9B/Zy9uwFjhw9SFVX35DjGX3dHQc+R3sh7f9Oe578fcAnReQHVPWXX2X5nwRuoz3X/k2gAN4D/DTwARH5iKp+rdcuLAEP0P6z8qu0oel/Afy8iARV/devZceiKIqiN74YVEZRFEXXDFW9T0RO0QaVj6rqT7/4eRHJgWOqevYljy/Sngj9UxH5JVV96d9UDtJWUN6lqtV8mb8PPAT8bRH5ZVW9/1U27+doQ8qfVNV/+qL3LmgD1f9eRH5VVR99pZWIyBdf5qnbXuX9o+ib2upo6/8AACAASURBVH333fd6b8JVjUYj4I27fd+qLn9fouj1tnLTLZSjIc3kEfzUz9thWhzg1FCr4DWQAEGEgOIVKg0QoHRCP0DjoXZC6S2qBiNKAhTShpJ9KxSmJrFKlgtBhMk4UJYFiCExAQO4pqauJkia4FxGJ+9gEourPWICqEXEkqSW0FiCGCTQzq1U0GBA2lAw1CXT4TZ+Mp8tqYpNLFmaM9izRH//AbLVZWyWE7wjBId6R2jClWRLTNvGVozBmARjUzDtuq5EYGIQbLtIaFAPKvN5lSqob/AuUNY1u6NtdiZDhuMR08oxrRyVbyv+TAJZnrJlL3FOegyW97KwuEze6VAUPbr9PpntULuK3Z0hJ597ihA8N99yF0mSXJnpZ4wlsQnOedK84JZvezt//KlPcMtwzNEFJZsAWFSh0+2SFFkbqoqB4Gm0rXJLTDubUEPAB2V3OqUMSh3Aq7DvwD6O33IzRW+Bfm+lbbNrIOvmZIuL7AZDz4MNYALgBBFodD4PUQQvsLaxw9baOlm3DwoXLp7nrjvuJsGjDRhJwCuBNqgWVQaLiyRJQn/QoZy07YE7nYxNadu/jiYTpluCQVH50+1aS2AEZCLMrsWBk38G2n6kUQFrDARDXTdYyZhNZ2gQFhaWyLIOaZISPNg0YTKpKOttyrJiPB6BFzBtpeRsOsX5mtF4yHg0wnmP84EQAtYaZP5zRGhnvQYNr3m7E2tJE0PjAnknZXFpkbKcIZqwO3FkSQ0GnGt4+rkT7Fndwwfe8UF26xFF0aEs44zKbwLvo61Y/InLD4jIv6ANL/+ViHxSVXdfYfm/DTz/0m5DIvIPgJ+irZB8tbDzsnuA/wv4scvhpoj8HPAYbSD6qkHlaz1vjr/Lv7x4vvPaxOP12sTj9dp9PY/ZG+m8OQaVURRF0beMech49iqPD0Xk54F/BrwNuFro+Pcuh5TzZbbmJ12/QNtW9mWDShFZBf4K8IUXh5Tz9ZQi8pO0lZU/QFv5GUVRFEXRNaB/8CirkxmznS12v/Is2rQtX51aHILTtvFroD05byv/5vdBGY4DS31wDqqZwasFAUVJBTJjSMXQMzM6aU3eDeRJ0rYYrYQmZAgNiQ1Ya6mahu3JkMJaXO0oDuSISUEc9awiSQt0/leCZlZSj3aQJCPrdkl9oKkmlLMx6hQ/9dRjh6ghzQ1ZnpB3C/oH9tHdu0S6sIAkGYohKO0sxqAg8+6txiBp227UGosYizFtXSmqiDHtPD1tW+WKCJj5bEoxbXvXEJiVFTvDHc6urXHi4janNmesTTzrlTLzUKliRTicCTevCsOVhpE2qKSsrO7njjvv4U33vJNef5Fur8/6xXOcOPEUk9k258+cotPtct2RGxAzr/w081aw6hERDhw9yuoNt/DZrzzIf3n39VRNQ5EXZN0csWHeuradCRhcg4SAGAVrkdCgmjKbTdmZTGh8W12LMRw4fIg9Bw6ys7VOE7oYElzTgAaO3HoT3esOMj55Ct8YvFeCgijMRGm0/Rylpg0VTzzzNAeuO8pwZ5vzL5zhXe9+B90ioZt3QCBJE4Sk3TcRup0eeZoyWFhgc2uXbseCMTjaILSajknytmVx60+GkQJMFDoSQ8qXEmmPWmIMRVGQ5V26RUG3N0Ck/Zy0gbiSZSkhOM5fOou1CePRrA03xeBdw+7uGO9qvDrW1i+xtbONNYagbUgJSgjtVQF6JU3W11xNCWCspaprmrqhs9ih2+tShxl7Vg9w7sIG09mMS2vrzKYVlfM8c+ok+5YP8OZvezsnzrzAH9736a/fQYy+UYbAz7z4AVX9goj8EvBDtCNQXjYgVNWTL/PUz9IGld/B1x5UToEff3EFpqo+KSIPAO8Tkb6qjr/GdUVRFEXfBGJQGUVRFH1LEZE7gZ+gvWL0IG1Lmhc7fJXFHG0Lm5e6b35/76u87dtox/TofBbHS6Xz+9tfZT2o6luv9vj8itG3vNryUfTN6gMf+MDrvQlXdfkqxjfq9n2rGgwGr/cmRBEA6aBLsX+F5VtuReoZ0xOnafy87au28U7QNrxrZ1YKQXVeWansjmC24vA1NM5g1QCKkTYMyownE09hHYWFomNIJKFqKuo6RVSwAiYYJASsKjuTTYJTeuku/X6PpaWibUNphaqc4E2CwTPeWkN9Q687wOY56hrCrKHcmVJXHm0MiU3p7+lS9AqyTpd8aYF0uUdSdDFJBmLx3oMRcPN0xJq2klIEDNgkx2g7cxLTtnFVFKUNBYP3INLOvcQiojjfUE5nrG0POXH2PI+c2uHJzZKNSqlCAqYgiOBCQxUqfAioh+WpMMmFZKlLJ+9z0w23cd3hm7n1nnuxScJ0skvjl3jr6rtYO3+OsxdOcOHsGfr9BVaW9wLSBk2i2CTBAEWvxx33vJlf/fxn2ZjUHBm0cyqDq6Fpq+bEGII2NFWFqic4SCTB2pSAYTQbsTNWatV5A2DLwuIAVUNVO6YXL5LlOXVZMVhYIskMvdU+F08IuzOoPfNj2AazCUImiijUdcP5c+ep6xmfvf9+lhZXOHL8OupyTDEoMNj22BrfHnux5J2Mbp5hTUKS5yRFh/6g4Pnn13EuUM8qRniaoFxtVHsbuCuz9qPN6xFXvl7v+0pEhMS2VdBJbrg8xVOBshyjKkwmI7a21hDAB8NkMqGcTSjyDkePHifLM6bTCTvbQ0a7IxpXMS1rqqoh+EAj/krYqYE/VT35n1rgasVQ1g2q0Ov1KYoCP2uo6/a9E+s4e/YsVVUzKyueO3ma/UtH+eh3fZzv+djHeeLLT7GzO/wzHsHoG+xhVb1aac19tEHlvbxCUCkiPdrORt8D3AIM4E+MKL3aefbLefZlqjfPzO+XgVcMKl/reXP8Xf7lxfOd1yYer9cmHq/X7ut5zN5I580xqIyiKIq+ZYjIO2nnRCbA7wO/DuzS/m3wzcDHaedfvNTGy8zTuDi/X3yVt16d379tfns5/VdZTxRFURRF30S8abCDLoPrjmE9uPGEybmt+bTFF9/kSrjj5jGdApOppWwc4kGMYk0DISERQyoNhWlITSBNAmkWsJcDT2fxtWClbRNrjWKNkCKIU6Yzh3cTZk3NgrbVUkXawZiKclZS7m5RTXZZWNlDf2UvJrFU413KZIdiuUNHM4qiQ6dfkBY9TCpIUWC6OSbNMDaBJGnn5wXXzrQUwLRhjRGDiG2rFJlXSpJ8dc8lgKao1og1qAqIElygLKesbazzhWcv8MUzU57bqdlsGry2LWU9Dnwzn+NpSM28Va7ALDEEsexbWqLT6fDApz9Jlua8/f0fZjae8vjDD/PsM0+wb/8ebrv7zVRuwoW1c6xdusBgsIyxFmNSjAkE9YQQMMZw/OZbqTTh1NYuRxYGOOfAKVmegTFt8OxrfNPMQ8t5+Gots7pifbjNzjSgtNWfAnR6PbI0Y/+B60lsQl4UeO9I05zZZIUDB6/nSX2Cnbqde1jQXllnVOgBpYI3Qi4wXd/g4S98jt/7jU/xV370h+n2+0xGm4gE2lhcsdJ+v1xT4YODtpiV/XtXubS2xdLSoN1mlMZ5yiq8aur1tQ6j+0Z4o4WU0FZLOg9qFD9tuNCsISL0el2KIiWxCWVdMh2XzKYVjfvqsiJjzl1YByBNDSB4r3j/kjau8x0PL+3H+2ckwGQywVpDr5djrEEVZvUM5xzWpoDHWDPfDGV9Z43z58/x4e/4EPuWD/Pol7/0dd2m6Ovu0ss8/qrnvCKS0p5nvx14nLZych1o5i/5+1z9PPvl7LzM45d/KuxrWFcURVH0TSAGlVEURdG3kp8COsAHVfW+Fz8hIn+PNqi8mj0iYq8SVh6Y37/a5cGXn/9ZVf3x17C9URRFURR9M1PB5AX9PQcxDZS7OzTTLzHbnqIaruQ8IpfbaGobHCkYhMYLw2FgOQNrFIPBiicVJTcNedJgREiMkiSKzaVtMapgBawoRgwGMKa99SVhlnrEwKxu2vczBgikkuKto5SM3uJe8t4iSMA3jnJ7Bzep6K0sYbOMvNshTXMIAZOmkApi2xauWAvzOFbUEnwzb+OqWJPMw4y2YhIRRAWdp7YSBMWAePCCWkMInmZWsrG9xcPPXOLBkyVPDSuGrsZpgzGwkHRYSRXfNFSuIekLdhC4tBZQzennytg5/O6EzYtnyRenpEmfta0ttne3ySThzPkLrG1t41xJ1ikYrCyDGra3timrkk7RQcS0oWhojzVB2XPdEbrdPmeGFU4g00CWJSRZinOeelYS1GNsW21pqXGVwzvP7mzE5nDKsBJUhRzFGItqwAVPf7BAmqbtbMPQhkCd/oC73/Y2fufXf4cd15CLsJQIq52U2xcLVhdysiwhTQU1wnByht/65bN85EMfZf++/aQ2I7HpfFSoAm2lLioYI4gaeqEBCfT7HU48N2Qjb1/bKGgIBC9/6uMevbrLYSXolSByNt1FBIxtj2nwf7o964u/ruvXPmPyz8omtq0gzlOyNEMEdnZ32FjfQEQIPpCYjG4nx9VtD+NL6xd58KEv8PZ3vZO3vP1ebr7jlj/37Y5ek/0v8/jXcs77cdqQ8hdV9Ude/ISIHKQNKqMoiqLoZcWgMoqiKLrWXA4Tr3aV5U3A1ktDyrn3v8I6E+DdwGde8vgH5vePvMo2PUhb4PDeV3ldFEVRFEXXECMWg0EKQ7G6ysL1NxHKio3HnsDt1ui8Padp6//wqvMOqZdrKoXRbs7iioMAiTisBFIRMutIbCAxkCSKSdr3C6oYPFbbYMFgMcFgQ8CYhMJYBsFTzWdGBhcwCTR1w2T7EnU5pTNYpej0SNIU39TMdkeMLm2ydPgQC/tW8a4mqFDXdfsLV2axxrbZpDGgAn5edegd6gPGpoDD2BTRANJWhUnbHR/12raFFUVI2xl7Cq5qmIzGPHnyHH98Er6yO+DCaEYpM4pOyuG9R9mzcgCcoVNt4qebnN/aYs/1hns+3mXrbIcw/TbOnz7N8889xfZswvDCOgsTx/v/4nvpDJa4/1O/wcGDe9gdbuCagMeydvE0w+mIJMkZjUbUdUWn08EHj4aAbzw+OBSPKTJ63R6Xdi5Q1RWdPCcEZTYZ42uPtSlpml0Jm0yS4qqGEBzTcsz20FH7NqhO5pF15cZsrp+j6PXnRygQnEeMRYNy6NgN9BYXmW6sc8PA8tbjCxw9vJdBtwtG8I1nOt3h7HDEp5+6xPv/8x/inR95H6efP0XW3Ue3v0jQgK8DJk/mpb1tr1YjgvGBlAxRKHLh7AsXcE2gBkwAH8J8puKf78/UtUoVvHtjHkwRGAw6FFnKYN8Brjt4BIBqNuP4scPsDMfUVYOVAhFDCIEszWiamvPnL3Du7HnSrIO+rjW20dfgLSIyuEr71w/M71/pnPem+f2vXeW5VzrPjqIoiiIgBpVRFEXRtWeb9s9kR6/y3CngVhG5W1Ufu/ygiPwo8B2vst5/JCIfVtVqvswKbYUmwC+80oKquiYivwT8VRH5H4B/+NLqTBG5EQiq+vyrbEcURVEURd8kAoGgDUEDyXKHpeQYeZqjQRk/9Ai2hsS0FY+BtvVrQPHolbawTZNQVaYNBMUBBsWgtFWWeceTWCUplCAlaEpw7fVaRubhplXEBASPwTBIOxjTYKzivMc1NaONS4zWNnDqUBKyJIFEmM3GjC6skXV79Pcso8Fh0w4meJxXJEsIKMa2bV1VQUVRHwg+oK5tc2qMbfdJFLHZvODSohJQF+btXoWgAcXgnWM2nfHC2Q2+eKriyc0Vzk8mbFenOH78OB/+0I+xsLjApXNn8RoYz0ounj0HnZxBknH+4ojNXwkUg5rR9udww5LlxWXqJGdztEvuYe+RI2S9HrPJlI0LayQIN958C7PJDpvr57j45BMcOnYdedKjnJYM+m2QFILigyd4j/cNzjs6/ZyLZxsUQcTgmoAAaZ7PW95CCL79rnpFRPAKo9mI3angFBKErmlD6tHaJk89+kUW9xyilwvGGOrQUE/GqA90B13edPcdPH3fZzi2knDswB6Wej2ca5gMd9gaDrm0M+WBzcChTp+PfuRdTKxw9vmTKI5Dx46QpClKu53eeQwWDKgKVV1RaEXQhtGkYnPiMAiVSDvg3f3J4XPRtUsVZmVJwLNv9QDLq32qcsazzz3LxqV1rGkrfbPUYK3Bh4BBWFjskRWGne0dZtNdbGJe5z2JXsUi8D8CP3H5ARH5NuAHaasp/+MrLHtqfv8B4BMvWv4G4J98nbcziqIougbFoDKKoii6pqjqWEQ+D7x3Hg4+Q1tl+evAz9EGkp8Vkf9Ae8L1bcC3A78KfO/LrPYC7UyNx0Xk14F0/tqDwL9U1fu/hk37r4GbgZ+hDSw/SzsH5BBwO+3syu8HYlAZRVEURdeIxlV4H9q6wTSlu3eZXArKyYjNs6fYPbOFUTDSVlI6haBtUCUIVkCCpXYJmTS0zV8FI5AlniwLJBaM0XbuXSNIahE1GAGDR1VoakPwiqCIAYslDQ2pTXBNzXS4xWRri+A83UGf3mCBEGC2s0NwNWknYXHPahs+SsCIRxKhGAwQa/FVjaoheHelpSgarlRQiQhiBWMSRNvZdu01W4HgFDSAFYJ3oJamrllfv8iXTmzy5Y0VTk2W2RidZaZr3Hjj7fzQX//v+OgPfox6WvHkA4/yufvvZzJc4/T6SdbWLzCajJg0NdU5xQIdC/1U6I12WVxdYMMbLm5t8/iXv8Ty6j5uv/1u3vyW99D4mgcf+iO2L51muLvJ048/xmiyy7Hrb2krKWkDWO8cjWtwjUO9a58zCTMXCFjEQp512gpFVbx3qEJwrv1+uLYVbllOmUwd41Jo1BNo2/Z2CWw8d4ZDh29id2tI3alQhelkRFNVKO2yb3vXezj94BcBh4pnOpkwnQzZ2NxiayfwaBnodbp8722HScdDhiQMlgc88tBDLO5dpshSgleMtViTtK17xYBC1VR470iSlDxNyAwkCn7eVlgDV9oVR98KDKPdCQ9efJjReJfv+th3c/zYTdxxy5t55vmnefChL+J1PjNTlTRNuOOO26nLkq2NLXxQgnOv/jbR6+l+4K+LyDuAB2jPdb+Ptjf0j6nq7iss+wngOeDHReRNtNWXR4HvBn6Tq19EHEVRFEVXxKAyiqIouhb9VeBnge+kDf8EOKuqvygiH6OthPw+2gDzQeCDwA28fFBZAx8B/iHwXwF7gJPAPwb++deyQaq6KyLvB/4m8APAXwYK2rDyWeDvAr/7Wnc0iqIoiqI3Lq9tuGWTjCJfoOj0ESN0hgdZuu1WXPkl6vWKRqHRtpLyctPX+YRHUKEqC9LcYzVQGOhlgTxT8jRAoiQW1EJQg4onySBNlLJpgy9VqBvIg8EiiCpF1iMrelS1oxyN8FWDTYSi0yFNCkLTMN3eQUtHb6WPzVJ88CSpRV2DKXqIMQRfYzo5YjLcdIqTGTbNrsykNCZBDEhbAwrGtIFnUMRakHYmpzqPaxzVbMJXTp3mga9UnDO3cWk05OLOw3R7OXff8S7e/6HvZuXAYbbObpAv56wPL/GlJx/kSw9/gY3dLcbOMUZxtKEvQMcLHsGLxw13Wex1uLA14/Of/Qzv+uBHWd17kMN33ECSJJx85ks8/fALPPrE41y8cImqqdizfBDBzCsI26rPpq5wdYMGj/c1zayEoHjfgDqCb7jcGzU4h4qgAdQHhHbOZVlP2R03DCvDjMBUoQKu338dR6+/hdzlnH7uecbVJlU1o5xM2oDU12xtbDIdeu5++3sYPfmHTCYjxq5iPJqyua08MVGqouBH33SMQws9ZptrDJOU647fSD11fOrXfp2/8PHvZGVlH0k2I00yVAOWBCQwnVYs1Z5er/0+q0obokqbWqQK09j39VtGp1PgvEOlYjQeU5YlR687SqfXRbKGx5/4MlU9w8xbOk/LklB7jh0+gjWG4AJB4uflDe554G/RnuP+LdoLdR8GfkZVf/uVFlTViYh8aL7sB2hHnpwE/gHwv9Cee0dRFEXRy4pBZRRFUXTNUdXngI+9zHO/AfzGVZ66H/jFq7z++hd9+Xfmt1d671O8TCcsVa2BfzG/RVEURVF0jTPBYCQhzTLSNEOMAWvIlhdYOHocP63YrJ9ktlNdmU0p86jSXKmeVIxPUW9JkobEBCRRTKpgwFrFWAEraKN4rxgTMNYAHo+0IyOdo/GChBQxQpJkJEBTT/HVFAmCzYUkS1D1eOcRr/SWl+kMBgRfk3YGYBNMDhilmdXYXg4mRzAkRZemmrStXm2KMSmIafO6ecvTgENDuFJ1GbzHNw1NU7O9uc2Xnj3Np8+kjPJbWds8y9SdZ8++Pdx159s4fvPtFJ0eTVPyqV/5Dzz+2MM89MWHeOHiOXbqkpkG2jrNyzFvW/PXqLDjhVC3x6lja/p5xs72Bk888iD3vvktnD7xFZ5+5FE++3u/xR8//AU2N7bIchiPdgkhUOQFiBDwONdQzSq8b/CuwVUThsMRSWJIRNu5j4S2klRA1KIa0BAwSULT1KhCVTdsDqX9vsyndQ4E6ksXeOS+T3HDbffilwZ85uH7aFygaTxNAOM8dRPoD3p8/N3/GRee28f5tTVS63F14IWQsJFa/tqbjnHd6iIeoR7tYFcPkyYJ97zzrSTW8qlf+U3e8r53cOcd95AspBAC3nm8c5SzkqYJ5EUBCI22V/il0rYW2SdCKTGs/FbRNA1Zaul2cnZ2xgyHQ7q9Hja1TMZjbrvxRm48fiNVXXHfA3/EZDxlbXuNi2sXuemmewkIdfXS0YfRG42qPgV8/FVe84tc/bz5DG2b2Kv5U+fHqvrTwE9f5fGX7Sqtqj8M/PArbV8URVH0zSkGlVEURVEURVEURVH0DSBWSCQhyzoYawkKQT22yBjsO4g2nmq0w3R8Al+10yetCFbBzFu/piJYhERz1DR4UbwX6lrIugErhgSwJHhpCB7EBiShrc1Ui/cGVwvTqiHJPTYZYNMc7zxNNSaUIKpkWU6WdjAKiRHy/QfpLPWweYFqwOQZNrOoKiEoQTzqLEYCJhNUhTQpaMoK1zQkWQeRAALiQYwFhBBAVdG6pJlVTKcTzq+tc//TF3loo0+2eicbWydxssnx4zdy40130l9YpKobLp4/xdOPf4Hf+9QnuLB5iS1XMgX8nzzyCGBEyMnJyBkkS+Rph9xYrAxR2UAQ7nrTXTzw+7/Bp37tl6hdw4VLF2gax2BQMC3HiBpWV/fT7XfaGZohUNcV3tWU0ymhaRhtnmNnOGJPakmMYK3FiIIRNAQIvt0eIHiPSqDxjtFsxnCUIdLO9MtE2J9YjtmGnd0dzp54mju+/Tt58rltGg10i4zFQYcDK6ssLS8w6PWZSg0HDvPc0+fZVwij1PJsFfhLx1c4spTRhABioK7odnokqaEoCt73Fz/CdTcc4xO/9mu4iec9H34/jW9ITNvOtWnaSttuv2B1acDFS7skCkYFBBKUA0Y4F6CKYeU1r6kq9u5f4czZizRNycWL51jds5c0yXGuIUlTil5OkDCvCW/bAzv1aHCAZ3t36/XdiSiKoiiK3rBiUBlFURRFURRFURRF3wDGpogFaxNsaiDM27oaSBc6dNwK3WNHKTbWqc7uQLAYlHReT2IQEtoTd+Mt4lJMp2HQU5b6Kak1eO+ofc1UGxoPNlGMCmmqJGY+G1HBOUFKpek22KQkzQqCb2hGJaFU8iKl0+uTd3vYPMNmCbZIEJu0LUydRxW8F0Talq6ml0AwmCQlhBoFQhUITaCeNdAzGGtRfFthGTxhHva5akY5mbGxucaTZ9b57RNDLvh9LK3exsb2s2Q95U23fpCVvfuw1oAxDHc2ca7kjx/4Q06sn2MUPPX8WL94XqIgJCQU9OhIj9wskCd9MtshTwsyex2mswWdNSbVlNPnT9PpdNh/+DBBAttb67iqJDUZBw8f4/Y33UVRdNHQBniurnGuxjUztGlYP3OG0WTGbfv75HmBTbJ2RqcPBBQJCqIEH8CCBk9dT9nYaNiqDFu+IrOBG7opt6wIK4uWx3aEldtvY/9N1/Hee+5k7EcsLy+hogTvqMsps5nj/NZJzm2cIoxhZhJOe+W2TDjWNeQmJTeWCsGi2NS0bVy9AoG73nIP3cEA3zi8dxiTEHygcQ2NaxiPxuxd7bO8skhqz6NemRIYtPWipKosIqzFOZXXvFlVcWltg6psUIXnT54kSROWFvaQmJRyNqasG4J6QFFVvPckNiEEpXEVTz39xOu9G1EURVEUvUHFoDKKoiiKoiiKoiiKvhFESGxGkqQYNfjQtjoVEcSkmKKg2LOXwQ3HqSdPoVt1W7VHWylppc0IhYCox/qMoJ604ymKBMGDGtQpLhiCU1wI2MKQF0onbfDe4IPgVSisUjWeLBMSk+JmJc1uiVHor/TpLCxTBcdwc4el1WV6Wb8NKH0AA6IOcQ6bWkTABJBE8TrDzxqCF3zdVvBleYFvGoLW4AOaeLwKrvI01YzhaIvT59f53PNDHlivGJlljh26m+HkFAeO7OVd7/4LSFIwq8YE32BSGK9v8eCDf8Rzl84x9v5KFaUCiF6JKq0KKSmpFBgKwNA4R91sMSkVa4VBd5m9S7eR0GXQW+HixdP0FnqkmVJkKdmgT6+3zPve/1Fuvf0OrFgqP6MuZ7hZiS9rqBza1Jx+5nlc7bhhpYfxDVhHm0iCkYAkBh8UYyyoxzc1s/GM0xuBS67h+CDhHccH9DoBjEetYcV2WFgZkPQSjt14hCeefITR9ibTyYTd0YR61lD7QBDLSmrb6s2iw+JkzFFj6ducTpISxOC8R71ircUaaVvUJglJlrFn334wioaAa2qC8zSNo6lqxttD9t1wkF6/T5FbxtOGGUKhSjqfOprDiyLi6Fq0NBhw403X8dRXnmvnvqpwaX2LQ4cmhOAwRsnSDFRR0zZfFmNwrsHYFPVQzUoeffTR13tXoiiKdKzV5QAAIABJREFUoih6g4pBZRRFURRFURRFURR9A6RJijEGaxJqXxMaj3M1dTWjriucKrbfpXf4MPgGefIko60pqu28QiuQCBgBK4IEaKYZF7dniEwYZG21Y5JaDID1KIJYIS0snQVH2Vi8WlydgAaca6hDCQKz4Q4heBb2LdDft8huVfLMiS2efaHirrs2uPWGm0mMbQNJEbAGjJLYBJMajE0QL4gxNKWjqSoEQzHoY7OE0BjK6QRxNaijcTXj3SHrO0MeOb3NZ8+XPDtzmKTPkb13Mi03uOW2W/j2D30P+44eZP38OZLdlAtnnuEzv/sJLuyss9bUNPPmkpdv0IZlAZB5HaqVnEQKHJ4QJlgJBHUkYhFTMC0rNi4Ji/tSuotdDtujFFmPbqfP/v3H2b//EG++962849s/QH9hQNNUNHVNWU5xdYWrpmhomI62eOLxJ+ilwm37FsiSThvhWcVcSfAEEwQxtFWWjaMsHT5YjhUpH769y7FDyziFqpoyCcLhA7dwcfMcn/q3D3Pu0jZn1nYIoqCGNEtZXlqh6BdcuLBGOXOExrMwGnE4WEQS+gsDUAGxOFch1tLt9xAMJklIbYEoIApBCBoI4gGhLieYpmF3ewcThCLPKPKE0aRhRyEXZUHa4+2kDSvLmFRek0Tg2JFl3nLvXYxnY5595gxBldG4ZGe4gwaH1wDGkliDtQXdogu+IqhHHQQ8FzfO8eTTT7/euxNdhaqe4iozJKMoiqLoz1MMKqMoiqIoiqIoiqLoG0AFRAwqgbaqr6QqZ5TllLqscE0FqaG7utJWqNUl4clTlOMAgEW/WpWHEhC8yxiNPbmpyVY8mbGoQEDAWAjQBCGxhqzjyLJAWQkuCFUjdHIBMqR2MGlYWl5g+fABRuWEM+d2ePhEQAWyLGU02aXICwgO0YQgHq+O4Op2TqNvKyuXVhfpFYO2ytJawLfz6VxNPZsw3L6A+ITJrOSFS7t87nzJF3Ybdr2SZwMO7r8XwfG2d7+V7/nBH8HYDufPXsBIwtlTT/Hp3/6PXBhusaNfbfWqVynjEwwJKYX06Sf76ab78b7Ea0Nm++Rpn27eI8sSgi+ZlbucfmbI9XdmHDx8hNU9ezh67HpuvPFWrr/pFvYc3E+SWJpZg/eB2XRMNdnFVVNCVULwXHj+BZ47dY43L/c4OMix2HZjnKJGuPz3f9fUBD9D1JBYS5rV3LDYkOcF1+1fIMtyDAkBwUxG+J2T7KxvM92aMR011HVgz94+C8s9uoMFlldWMYlleGmDSelJgGIGIU0JkqAqYBKcBpp6Qirt+3oP3jcErQhYTGoILqAuUFcVxniacsKi91zYGULwdDo9up0cpERVGQE5ggFyC/usYa1WyhDTymtNp7CojnDNiOPHjnDuzEXGkxoXPGfPX+Ku2YSmrgjBtcG3gTxLmU3rtpWw8zSu4emvPMH5cxdf792JoiiKougNKgaVURRFURRFURRFUfQNYMWCGLxzeKeU4ynT2ZiqLCnLKcE7jBU6/QF51iGxGZaMS19+Gj+bh1wi7VxCFIPg1DIre2zZwGChQaxHxeAR8G0bxuDAicekkHYaqhqcB1+Bt2D6kBjL8p4FBnv2sDsbsb65xZdPBs6Xwr2HG/rdZXanYyazEdo01E4ZjabsTBybI2VnGigbQyqW4/vWeevdB1ld3INNDE1V4ktld3ON3e0thrsjZrOKkxvwBxuBk3WDtZBnHQ4feicaHHfccyN/7cf/LjffdQMXXtglyyyf+Pef5A9+61c5O95hVwMBUJ3PoxSl/U/aVrpYUjIKenTNCl27SpGuENIGIaGbd+lmXTq9DkWRYRSqaoILE9K6Q8fvYWAPcPzo7bz57bdTdLoYAdc01PWMne1tRttb1JMJzWSGNoFytsuDn/s8oW74rjfdRJGnZHlBcA7vGwRpCxa1uTLX0zcNaZrTVMKexZQj161QdHs0wVE1DcNywvpwk6b2LI8TTg4bXJKysGRY2tMjKzpo8OwON1GF5f0DFrKMvK5JEmHkBckCZT1jqh1QQ6+7QL6wzNAkhOBBBQ2CNRYrBghIUAwGVKnHIwY41oYj3GxGXliKbk41r6KcKeyiLFghzdrP+t4cNiphdo2FlSLtZ+5b0Z6FFW66dT+bG2c49fxXOHTkVo5et5+TJ8/hvDKdTHns0UfIigQNBucDIoqI0O/lFEXOvtVVvJbcd//9NI17vXcpiqIoiqI3qBhURlEURVEURVEURdE3gAQDKF4CVTWhrHapyylVOcP5AKptK9JE6PSXydICUaWZTNh69gyhsagGQAkKDYZahWmAybigs+UpVgWbta07AQIGQalqjzVKmoNNA84ZZrMEVU93WciyHoP+EqUr2d4Zcv7cjOd3c1LjWV0yTOqK9Y1ttnc8o4lhvYS10jF1bfvRwrSzEfcPDKsLCbULzMoZLrTtZcejXXbWLzFrSqpZzQs7wifXAxeaQJKAtR0OHng3JrEcuW6V7/8b/w3HbryeUCv9juG+P/pdPvH//BvOjnfYmYeU8wLTeeNXQARBMFgyenRYoGMGdLO95PkyibUgCZ2kQ25zkizBhAQNFpNmLA+WSDMhTzLKHcPTFzd47rHfZjIa8sHvfjdGLOPJiO3NLYbbW8xGQ8rdXUJZEpqaZx//Mo89/iwfveUgx/ev0Ol1EdqqUpMmaGhQ55DQtsWsGyXgyYqcheVF9u/vkucJk3pCo5Y8y+nSx5gdljspNx08xBm7S3//Clvb2xTdLkEVHzx1XbfvlYCsZGC6TJqace3Yl0JIDAZLknfw3mPzDuoD2nhIQIziGoeqItZg0wwbPMEHyt0xqXPsBdjYJju0j8XFDqkVGq84YCawVIA1SlAhCbBiYYgwnoeVl+tJw5/nD93X2bdqSJkmKR9433tZ3JPxx5/f4fQLF6kbWFjosjTIqGYN/YUuo8kufqSsLO4heEUM9HodOqt7WFlYZTza5sSpZzjx3KnXe5ei/5+9O4+T7CoLPv57blX1NmsmOwQyJBAC+BoIIrKFCVFeBBVBcQGXgAuLKCqigAjhBT/gggRfRJTXCLIomywKBDRhAgYR2YJigACZkISsk5npnumtqu7z/nFvJzWd7mSW6qrumd/386nc7nvPPffcc6sn9dRz7zmSJK1iJiolSZIkSVoBGQmZdOY6zM7PMjtTJynbHZIujWhQ0KTZGqE1MsHIpnFod5m97266+/ax97pdUFbJyiiK6qmlhHbCTLfBd6dGOW7TLBvGGnTbVRKvEUlRBkVRDTkajaQ1VsJskN2CznxSzpeMTozRzeS223YxtWeS63eNsLvT5ZhWcOueea7feSvX7yq4fhZ2l/OQycaiwbEjTe65rskpG1vc68RxTjhuExs3b6IbMLVvknJyN7PtGXbdciuTkyVlmdww0+DSW7tcPV8y0QKiwYlbzmakuZnNW+Z4wlN+hq33P4P5+WS+3eaS976Xv37jn3Dd3l3sLku6PX16+4iv9dyPEQWjTDDKBkZjHSONTRTFOGVZkpFMjE7QGh1jrDlBs9miaDUYHZtgfGIdzWbVT/PtOXbuvIE9u69h7+5raY3t5MyHns7IaJM9u/cwuWsn8/v2Mb93H+19s5SdWSZ33cpHL/4k6yP5wTNOYv3YOEVZkHTptkuyLIFONY9nUT2ZWXZKiGC+3aExOsZ8BM1oQtGkmU3GGiPM5ByT++Y4bmIzI6MtTrrXFr42PUez2aTRGKFZFMx1Zols0u3MEjHC7slJ9u6dpD03T6sVrN/Q5OobdzKxbiProkXRCLqtJp3ufN1tDYooyOxCZtWuThLRoGgG5cwM64rkxJODxvROppqnsHnDJjaNt9g4Ns6emX1spsNoAURQZvXEbgPYXEC7hHlgBBiNYC6TuUH90akv7nvqVh7wvfdl375JjjnmWK7bt49rr7uJ0ZExRsZaFBHVSNP1DRdRz3BYliVEyUgxzqMf8UiuvOoKPn7JZUxPzwz3hCRJ0qpmolKSJEmSpJUQ1Rf58/NzzE5PMTu3j/n2LGWWVNMXlkQDaEBS0m10KTauY9MpW2mUBU2uYOb626pkZzZpZ8FcwnxZ0slk1/QI1+3scvq6as7GJCi7QQSMjgZlBmUjGR0rKTtRPY2YBdNTs0zt3UV22uya3MWuPSXfnC65JefZNR9c/Z2SmSxplyWNgJOaLe6/scmpxzQ5blOT47dsZNPGTUyMjdNoNohmg/b8NNOTO5memqTd7jK5p8Ntk02umYfPTHW4pewy1oQuBVs2P4j1x9yTqclv8KgHP5WTtp7Grt17aE8GV/77dt504av51q7vsqss6XBHcjICytsfpixo0GSEccbYxGixjvHmMYy0NtNsjNIomrSa4yQNiiwYGR1jdHyc0fERyCqh2O4WdGf2sWf3Tdx8y9eY3HsVZXcfN922ia9/7auMjY/QmWvTnZmhMztLZ3oass2+PTu5+J8v5qYbbuGXHnIPTt4wStEtaZfzEEnQoNFqUDRH6Zbdat/2LN2ypMykXc7R7cwzPrqR9ePj7Lttina3w7qRMfbu28vOvQVzG9Zz1XRwbacACpqjI3TLLtmZIZLqKchmiwIoM5jvtOlmSXsm+ca+Lq3J3Ry7/nrueY9TaMYIzdYI3bkORaO4/b3X7XSgTBoBZatBs13S7UKjM8u9TyjZOD7CVPsWZrsdNm/axAmbxrnvfR7CVTu+xeSN15JlNS1qFFBEfY0SxiJoZzVUcZe8/Ysnk5Vrw/joKGeeeTpjY2NMz0yxfsMxTIztYmpqiunpuWrO19YYjcYoEVkNc1wkRVG9v+dmp/nmrf/D69/8dU6958mMTYzDrinuNKmsJElSzUSlJEmSJEkroOx2KDswNzvN3PQMM3MzlGWS2aVbJq3GGEWjRWTQKTuUnS7ZhInjj2ckRsj5Ocp9X6R92wwlMJ/JfCZdSpIq6Xfj5AQbJqegmTTbwVirhGbSLpNGY4JGa55Gp8tIK+k2OhQlzE0XfPu6HbQaBXsn59i9Z5zrO/Nc252jSfVk3GgEG6LBaSMtzjoZzrjXBo7fsoWxkTFGW2NVIq4IyrJgvj3Drp23sG9yN9PTc8zPFOybafCfU8lnZ9u0KZkognaZFK1NHH/sGdx461e45z3uyUmn3o/JXZM0Kbht97Vc+Eev4Mqbr2VXlnTuGOR1/6coCZq0GGMTE3EsEyObGWlsYKS5gdbIKGONccZaYzRaLQqCsfWjTIxuYGR8pE4ed8gomJuZZM9tt3DLrd9m595v0u7uYnykQUbJ//zXFUxMjNMqghZBoyxpRJdsz/HJSz7J5778dZ506ibOPmkTDYJud56iaFLSJsqs5tMsoD0/y+z8HJElrdEJikjK6RkaRYtmARENOvWQq3Nzs9yyew+TEycyedwp7JrazdyeSW7avY9Nx25kbKSkDVCWRFYJaZoFxx23kcnJvUzNJFlCN+CafV2uunkXTBRcu6vkgQ/pUGzoQhQ0m02invW0aDQoy4SyTTSqYWtbzLNl/SgTzSY5u5fRmSnGxtdx3DHrueKrX2TvzDzNTvVkb3MUoggaJN1GNczrSAmNhDbJCNCIYAOQmcwP9k9wqMbGW8zPdar+XSMignuffAInn3A8RRQEBaPNEcbGxtizd5JuZ45Go8n4+BijY+vI7LJ3b5uiKKqbJbKkUYwwO7uHjes2cN/73o+Nu27ippt3OkelJElalolKSZIkSZJWwBN+9mkx7DYcqBetQJ2/ddB7PIBznvG1FWhJfz39pf2t78yenx/Z36oPzQ89BXjLsFshSZKko0Qx7AZIkiRJkiRJkiRJOvqYqJQkSZIkSZIkSZI0cCYqJUmSJEmSJEmSJA2ciUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwDWH3QBJktQfp24s+MZrnzTsZugQbN++HYBt27YNtR2SJEmSdCQzbpak1ccnKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwJmolCRJkiRJkiRJkjRwJiolSZIkSZIkSZIkDZyJSkmSJEmSJEmSJEkDZ6JSkiRJkiRJkiRJ0sCZqJQkSZIkSZIkSZI0cCYqJUmSJEmSJEmSJA2ciUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwEVmDrsNkiTpMEXEztHR0S0PetCDht0UHYKpqSkANmzYMOSW6GB57VanK6+8kpmZmdsy89hht0WSJEmrg3HzwTPeOTj218Gxvw5eP/tsNcXNJiolSToCRMQc0ACuGHZbdEjOrJdfG2ordCi8dqvTVmAyM+8z7IZIkiRpdTBuPiTGOwfH/jo49tfB62efbWWVxM3NYTdAkiT1xX8DZOZDh90QHbyI+AJ4/dYir50kSZK0Zhg3HyTjnYNjfx0c++vgHal95hyVkiRJkiRJkiRJkgbORKUkSZIkSZIkSZKkgTNRKUmSJEmSJEmSJGngTFRKkiRJkiRJkiRJGjgTlZIkSZIkSZIkSZIGLjJz2G2QJEmSJEmSJEmSdJTxiUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwJmolCRJkiRJkiRJkjRwJiolSZIkSZIkSZIkDZyJSkmShigiTomIiyLiuxExFxE7IuLCiDjmIOvZUu+3o67nu3W9p6z0sY9mw7p+dblc5nVjf87uyNaPaxcRPxQRr4uISyJiZ93//3YA+z0wIt4TETdHxGxEfD0iXhkR44d3VpIkSdLRZZgx9Vp0uP0VEesi4hkR8a6I+FpE7IuIqYj4fES8MCJGVvocBmklvjeJiHMiolvHj6/uZ3tXg372WUScXb/XrqvruikiLouIX1iJtg9DH/8Ne3REfKjefzYivhMRH42IJ6xU2/spMnPYbZAk6agUEacDnwFOAD4EfA34fuBc4OvAozJz5wHUc2xdzxnApcB/AmcCTwZuBh6Rmd9eiWMfzYZ8/XYAm4ELl6hyb2b+6aGd1dGhj9fug1TXaRb4JvA9wOWZ+ei72OfhVNe5BbwPuBZ4HPB9wOXAeZk5d8gnJ0mSJB0lhhmTrUX96K866fEx4Dbgk1Rx0DHAjwEn1fWfl5mzK3QaA7MS35tExAbgK8BxwHrgDzPzZf1s9zD1s88i4vnAG4BdwEeA64EtVHH3dZn5M30/gQHr479hzwXeBOwDPgBcB5wCPBWYAF6WmX+4EufQN5npy5cvX758+RrCC/g4kMCvL1r/Z/X6Nx9gPX9Vl3/dovW/Ua+/eKWOfTS/hnz9dgA7ht0Ha/XVx2v3COBBQAPYWu/7b3dRvgH8T13ux3rWF1RJywRePOz+8eXLly9fvnz58uVrLbyGGZOtxVc/+gt4MPAMYGTR+g3AF+p6Xjjsc10t/bVEnRdRJXlfWtfx6mGf52rsM+DxQFnXt2GJ7a1hn+tq6S+qm6B3AzPA/RdtewDVjdXTwOiwz/euXj5RKUnSENR3TX2TKuF0emaWPds2ADcAAZyQmfvuop71VHd4lsDJmTnVs60Avg2cWh/j2/089tFsmNev3rYDIDO39u2kjhIr9f6PiK3A1dzFE5UR8TjgEuBTmfnYRdtOA74FXAPcJ/2QLkmSJC1r2DHZWjOI7wEi4unAO4F/zswfPexGD9FK9FdEPBn4IPDzQBP4W46gJyr72WcRcQVwX+DeeYSO9tXHf8NOBG4EvpKZZy2x/SvA/wKOW8196RyVkiQNx7n18hO9H0YA6sDocqrhGX7gbur5AWCcKjky1buhrvfji47Xz2MfzYZ5/RaMRsTPRcRLI+IFEXFuRDQO9kSOQsN8/z+uXl68eEP9pcc3qL4EOW0Fji1JkiQdSVZDTLaWDCIOatfLzmHUsVr0tb8i4gTgLcAHM/Md/WzoKtKXPouI7wG+F/gEcFv9Xcfv1HOgnlffQHAk6Nd77GbgFuCMiLhf74aIOAO4H/Dl1ZykBBOVkiQNy/3r5TeW2X5VvTxjBerp17GPZsO8fgtOAt4O/CHVXJWXAldFxGOXKKs7DPP979+eJEmS1B+rISZbSwZxns+ql3e6MXMN6nd/vYUqF/Ocw2nUKtevPntYvbwZ2E71XcefAH8K/Cvw5Yi476E3c9XoS3/VozH9GtX76wsR8baIeE1E/B3VcMxfBZ7Wh/auKBOVkiQNx6Z6uWeZ7QvrN69APf069tFsmNcPqiFizqNKVq6jGsbjr6jmSfxYRNxpuA/dbpjvf//2JEmSpP4Ydky21qzoeUbE84EnAF+mmodxretbf0XEs4AfA56XmTf1oW2rVb/67IR6+UtU33E8qa77DOAdVN9/fCQiRg65patD395jmfleqhGcdgO/ALyYaojhfVTfH636YatNVEqSJK0xmfnKzLw0M2/KzOnM/O/MfA7VhOvjwAXDbaEkSZIk6WgQEU+lGuXnRuAnMrN9N7scNSJiK1XfvDcz3zPc1qwZCzmrBvAzmfnRzJzMzKuoknCfp0pa/sSwGrjaRMTPUT1t+mngAVRDxj4AuAR4I/APw2vdgTFRKUnScCzcGbVpme0L63evQD39OvbRbJjX7668uV6ec4Dlj0bDfP/7tydJkiT1x2qNyVarFTnPiPhxqiTIzcC2zFz1T24doH7110XADPC8fjRqletXny1svzEz/713Qz3M6YfqX7//oFu4uvSlv+p5KC+iGuL15zPza5k5k5lfo3qq8gvA0yJi2+E3eeWYqJQkaTi+Xi+XG2t+YQLs5caqP5x6+nXso9kwr99duaVerjvA8kejYb7//duTJEmS+mO1xmSrVd/PMyKeBrwXuAl4bGZ+/W52WUv61V9nUw1lektE5MKLajhOgN+v133w8Jq7KvT7b3K5BN2uejl+gO1arfrVX48HWsBlmVn2bqh//1T960MPpZGD0hx2AyRJOkp9sl4+PiKK3g8TEbEBeBQwDXz2bur5LNXdeY+KiA2ZOdVTT0H1gaX3eP089tFsmNfvrvxAvTxS7mJdCcN8/18K/D7V3C2v6d0QEadRBSjX4PWTJEmS7s5qjclWq77GQRHxDOBtwPXAuUfQk5QL+tVff0c1DOdi96MaCenLVE+8femwWzx8/fyb3AdsjYh1mblv0fbvqZdX96HNw9Sv/hqtl8cvs31h/fyhNnQQfKJSkqQhyMxvAZ+gmhj81xZtfiXVE3Fv7/1AFhFnRsSZi+rZC7y9Ln/BonqeX9f/8d6g4VCOrf0N8/pFxAMi4k5PTNZzX7yx/vUdB3lKR41+XbtDdBlwJXBORPxYT/0F8Ef1r2+uh7ORJEmStIxhxmRrUT/joIj4RaoE3HeAc9Z63yylj++v38jMX1784o4nKj9Sr/uLFTuZAeljn00DfwOMAa+OiOgp/7+A84EO8L7+n8Xg9PFv8tP18icj4nt7N0TEg4GfBJLqxulVK/weRJKk4YiI04HPUA0D8iGqBMbDgXOphnZ4ZGbu7CmfAJkZi+o5tq7nDKoPHp+jmjT7yVTzRDyy/gB0yMfWnQ3r+kXEBcALqYbvuAaYAk4HnkT1Qf6jwFMyc1XfLTdMfbx2jwZ+uf51PfATVNfsYwtlMvP8Rfs8nOo6t6gCq+8A5wHfB1wOnJeZc/05U0mSJOnINcyYei3qR39FxLnAv1I9AHURcO0Sh9qdmReu0GkMTL/eX8vUfT5VsvIPM/NlfW/8kPTxb3Ij1Y2+Dwb+gypWPhF4KtWQr7+ZmW9Y6fNZaX3sr4uAZ1I9NfkBqu+KtgI/DowAF2bmb63w6RwWE5WSJA1RRNwL+D9UQ0EeC9xA9aHilZm5a1HZZT/0RsQW4BVUH0JOBnZSJUtenpnXHe6xtbRhXL+IeCzwHOAhwElUd9ntphoy5u1Ud9z5Ae9u9OPa9QSXy1rmej+Q6g7Jc4ENVEHE3wOvzcyZQzsjSZIk6egzzJh6LTrc/jqQGAi4JjO39q/Vw9Ov99cS9Z7PEZiohL7+Ta4HXgI8DTiVaojmzwF/mpmfWMlzGKQ+fTcRwC9SPW16FtX3DJNUQwq/JTP/YWXP4vCZqJQkSZIkSZIkSZI0cM5RKUmSJEmSJEmSJGngTFRKkiRJkiRJkiRJGjgTlZIkSZIkSZIkSZIGzkSlJEmSJEmSJEmSpIEzUSlJkiRJkiRJkiRp4ExUSpIkSZIkSZIkSRo4E5WSJEmSJEmSJEmSBs5EpSRJkiRJkiRJkqSBM1EpSZIkSZIkSZIkaeBMVEqSJEmSJEmSJEkaOBOVkiRJkiRJkiRJkgbORKUkSdJRLiK2RURGxAUreIyt9THeehD7nF/vc/6i9TsiYseBlJUkSZIk6XAZN0srx0SlJEmSjlhLBWeSJEmSJKli3Kxhaw67AZIkSdIyPgB8Frihz2UlSZIkSToSGDdrzTNRKUmSpFUpM/cAe/pdVpIkSZKkI4Fxs44EDv0qSZI0ZL3zUETEmRHxwYi4LSL2RcS/RcTjF5W/fV6JiHhCRGyPiD0RkT1lNkXEayLi6xExGxG7IuLjEfGDd9OWR0TEv9b1TdX7fN8S5e4RES+PiMsj4saImI+I70bEuyLigXdzjLs9x8XneQB9uF/ZhflDgFOBU+ttC6+3RsQxETEdEd+KiFimzn+qy9/p/CVJkiRJg2PcbNysI5eJSkmSpNXjPsC/A1uAvwLeCzwU+FhE/PQS5X8S+GdgCngz8G6AiNgMfAZ4MdXdkhcC7wceAXwiIp69zPEfDmwH5oC/AD4GnAd8OiIes6jsOXX9u+u6X081hMxPAp+LiLP6dI6HagfwSqrz31Pv8IQQAAAgAElEQVT/vPD6YGbuAv4BOA24UxAaEfcCfhj4QmZ+vo/tkiRJkiQdOuPm/tmBcbNWAYd+lSRJWj3OAf40M1+0sCIi3kgVoLw5Ij6WmZM95Z8IPDEzL15Uzx8BDwT+GnhOZmZd1x8Bnwf+PCI+npk7Fu33BODXM/ONPcd/MvBB4KKIuH9mlvWmS4ETM3Oqt4I60LoceC1VwHK453hI6nO7YOFO0cy8YIlibwKeCTwb+JdF234JaFAFhZIkSZKk1cG42bhZRxifqJQkSVo99gD/p3dFfVfiO4HNwFMWlf/Q4mArIkaAnwP2Ai9ZCLbquq4C/hwYAX5hieN/kyoI6T3+h4DLgPsCj+lZf/PiYKtefwVVMHZuRLT6cI4rpj7u54EnR8RJC+sjokEVcE0Bfz+o9kiSJEmS7pZxs3GzjjAmKiVJklaPLy4VxFANKwPwkEXrP7dE2fsDE8AVmXnbEtsvXaYugE/33Pl5t8ePiCfV81HcEBHthbksgB8FRoHjlqjrYM9xpb2JapSRZ/WseyJwCvCOzNw74PZIkiRJkpZn3GzcrCOMQ79KkiStHjcts/7GerlpmfW9FsrcsExdC+s3H87xI+IFVHN47KIa/uU7wDSQwI8DZ1EFXYd8jAH5B+B1wK9ExGvrgPNX620OXyNJkiRJq4txs3GzjjAmKiVJklaPE5dZvzC8yp5F63NxwZ4yJy2xDeDkZeo64ONHRBO4gCpIOjsz9wvuIuIRy9RzwMcYlMyciYi3Ar8FPD4ivko1R8h/1MPxSJIkSZJWD+Nm42YdYRz6VZIkafU4OyI2LLF+W7380gHU8XWqOzTPioil7v48t15+cYltj46IpT4fLj7+cVR3ln5miWBrPXD2XbSvH+d4MLpA427K/CVV8Ppsqjk2GnhXqCRJkiStRsbNxs06wpiolCRJWj02AS/vXRER3wc8g+qOyQ/cXQWZOQ+8E9gAvGpRXacDvwG0gbcvsfv9gOct2ufJwGOBbwKfrlffTBXUPbQOsBbKtoA3sPQcGwsO+xwP0k7g+IgYX65AZl4FXAL8CPAcYDfV0DaSJEmSpNXFuNm4WUcYh36VJElaPT4F/HJEPBy4nGq4mZ+murns2Zk5eYD1vBh4DPD8iHgY8EmqIOinqAKx52fm1UvsdzHwuoj4YeAK4L7AU4FZ4Fn1PBRkZhkRf14f578i4kPACNVdp1vq4527RP39PMcDdQnwMODiiPgUMAdckZn/tKjcm4AfpBpi5/9m5kyf2yFJkiRJOnzGzcbNOsL4RKUkSdLqcTXwSGAX1R2KP0U11MwTM/PdB1pJZt4GPAL4Y+BY4LeBpwGfA56QmW9aZtf/oBpKZhR4PtWcE5cC52TmpxeV/QPghcAM1dAvTwU+D3w/8J2VPseD8GrgzcDpwEuo7pb9iSXKfRi4tf7Z4WskSZIkaXUybu4/42YNVWQuNZesJEmSBiUitlIFIm/LzPOH2pijVEScRjVMz+WZ+Zhht0eSJEmSdAfj5uEzbtZK8YlKSZIkCX4HCOCNw26IJEmSJEmrkHGzVoRzVEqSJOmoFBH3Bp4O3A94JtX8Iu8daqMkSZIkSVoljJs1CCYqJUmSdLQ6DXgNMA38C/DczCyH2yRJkiRJklYN42atOOeolCRJkiRJkiRJkjRwzlEpSZIkSZIkSZIkaeBMVEqSJEmSJEmSJEkaOBOVkiRJkiRJkiRJkgbORKUkSZIkSZIkSZKkgTNRKUmSJEmSJEmSJGngTFRKkiRJkiRJkiRJGjgTlZIkSZIkSZIkSZIGzkSlJEmSJEmSJEmSpIEzUSlJkiRJkiRJkiRp4ExUSpIkSZIkSZIkSRo4E5WSJEmSJEmSJEmSBs5EpSRJkiRJkiRJkqSBM1EpSZIkSZIkSZIkaeCaw26AJEk6fBFxNbAR2DHkpkjSarAVmMzM+wy7IZIkSVodjJslaT9bWSVxs4lKSZKODBtHR0e3POhBD9oy7IasJVNTUwBs2LBhyC1ZW+y3Q2O/HZpD6bcrr7ySmZmZlWqSJEmS1ibj5lXMeGl18/qsbms9bjZRKUnSkWHHve997y1f+MIXht2ONWX79u0AbNu2bajtWGvst0Njvx2aQ+m3hz70oXzxi1/csSINkiRJ0lpl3LyKGS+tbl6f1W2tx83OUSlJkiRJkiRJkiRp4ExUSpIkSZIkSZIkSRo4E5WSJEmSJEmSJEmSBs5EpSRJkiRJkiRJkqSBM1EpSZIkSZIkSZIkaeBMVEqSJEmSJEmSJEkaOBOVkiRJkiRJkiRJkgbORKUkSZIkSZIkSZKkgTNRKUmSJEmSJEmSJGngTFRKkiRJkiRJkiRJGjgTlZIkSZIkSZIkSZIGzkSlJEmSJEmSJEmSpIEzUSlJkiRJkiRJkiRp4ExUSpIkSZIkSZIkSRo4E5WSJEmSJEmSJEmSBq457AZIkqT+uGayZOuLPzLsZqxNF9tvh8R+OzT22wHb8donDbsJkiRJOoIYN68Bxkurm9dn1TkS4mafqJQkSZIkSZIkSZI0cCYqJUmSJEmSJEmSJA2ciUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwJmolCRJkiRJkiRJkjRwJiolSZIkSZIkSZIkDZyJSkmSJEmSJEmSJEkDZ6JSkiRJkiRJkiRJ0sCZqJQkSZIkSZIkSZI0cCYqJUmSJEmSJEmSJA2ciUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwJmolCRJkiRJkiRJkjRwJiolSboLEZERsX3Y7ZAkSZIkrR0R8dY6ntw67LZIkrSamaiUJGlIImJ7ROSw2yFJkiRJkiRJw2CiUpIkSZIkSZIkSdLAmaiUJEmSJEmStCpExI9FxCURcUNEzEXEdyPisoh4Xr397+shVe+3aL+31esvWbR+Q0S0I+JTSxzrZyPikxGxOyJmI+LKiHhZRIwu07Yz6yFdr42I+Yi4KSLeFRH3X1QugV+sf726bldGxI5D6I+FIWRPi4jfjoiv1W29LiJeHxEbl9nvlIh4Y0R8u+7HnRHx4Yh42BJlL6iPsS0ifjEivhQRMxFxc0RcFBEnLbHP9nqf0Yh4dURcXR/nWxHxiogYOZw+XOLcfz0ivlK3a/vB9qMkafUyUSlJWvUiYmsdnLw1Is6IiHfXAVNZB1JFRDwnIv4zIvZGxL765+dGxJL/r6uDo4siYkcdTN0cEZ+OiOceYJteVB//8ojY0rP+4RHxvoi4sQ66ro2Iv4qIeyw+H+Cx9e/Z89p+eL0lSZIkSWtTRPwq8CHggcA/Aa8DPgqMA8+siy0kIs9btPvC74+MiLGe9Y8Fmj37LRzrIuBdwH2B9wN/AdwGvAq4OCKai8o/Afgi8AzgP4EL6zqfCnwuIs7uKf5K4Ir65zfUv7+y3udQvR74A+Cyus5bgd8ELl10vtRt+TLwPODrwP+l6s9zgH+LiCcuc4zfAt5ct/3Cet9nAp+JiOOX2ec9wLPq+t8IJHAB8P6IiEXtOpg+7PUGquvyX/XPly9TTpK0BjXvvogkSavG6cB/AN8A3kkVrE4CbweeDlwL/D+qwOgpwJuAR1MFQbeLiCcB7wVGgYuBvwc2A2cBvwv85XINqBOfFwK/Dvwj8IzMnK23PQv4a2AO+HDdnvsBvwz8aET8QGZ+B9hNFaSeD5xa/7xgx0H2iSRJkiQdKZ4NzANnZebNvRsi4rj6x0vr5XlUSTXqp/HuCfwL8EPAo7hzQnNhPyLifKoE3AeoYrqZnm0XAK8Afo0qKUZEHEMVN04D52Tm//SU/x7gs1Sx6NkAmXlBRGylijEvzMwdB90Td/Yo4MGZeU193JdQxbVPBV5ElcijTrC+B1gPnJuZl/W09R5UCcK/iYitmTm36Bg/DDw8M7/Us8/rqRKirwV+aYl2PQB4UGbuqsv/PvBJ4EeAn6OK1w+6Dxc5G3hIZl59N30kSVqDTFRKktaSRwOvycyXLqyIiJ+lSlJ+iSrY2VuvfxnVnaZPj4iPZOa76vXHUd012wQe1xu01dtPWe7g9V2q76QKBN8IvCAzy3rbGVRB8g7gsZl5fc9+5wGfoApyn5KZu4ELImIbcGpmXnCgHRARX1hm05kHWockrRXbt29namrq9p8P1MI+kiRpTeoA7cUrM/PWevntqIZQPTciIjOTO5KRLwceV//em6jcR5UIW/CC+jjP6k1S1l4FPJ/qhtc31Ot+germ1uf3Jtjq9vx3RLwF+M2IeODi7X30hoUkZX3cMiJeBPw41RONr6o3PYnqJt8/XRzvZuZ3I+KPqW6+PY/qadVeb+9NUtYuoErqPj0inrdEcvNVC0nK+hizdRL1k3W73l5vOpw+/OODSVIaN0s6mhwJcbOJSknSWnIT+z99CFXgA/DihSQlQGbui4jfA/6V6onGd9WbfhHYCPz54qCt3u+6pQ5cD+/6YeCRwO9l5h8vKvJcoEWVvLy+d0NmXhIRH6Z6qnJDZq6eTwKSJEmStHq8k2q41/+JiH+guvn08sy8ZVG5S6liwQdT3bT6OOCGzPxsnaQ6D6AervR7gE9kZrteN0H1pOOtVImxpdoxR/Wk4IJH1Muz6icuFzujXj4AWKlE5VLx67cj4lpga0Rsrm+KXWjrqcu0dWFuzwdw50TlUsfYExFfphpC9wFUQ8re5T7AvwFd4CE96w6nDz+3RHlJ0hHCRKUkaS25Yom7N88GSmD7EuUv487B0Q/Uy48dxHFPpJoD4zTg5xaezlxkIeh6bEQ8bIntJwANquBrubs771ZmPnSp9XUwvtx8HpK0Jm3btu32O0K3bdt2wPtt2LBhZRokSZJWVGb+WUTcSjW34m9QDTmaEXEZ8KLM/Hxd9BKqROV5EXEFcC53JN0uAX43IjZRJTCD/eenPKZedzzVEK8H4th6+St3U279AdZ3KG5aZv2NVFOKbKKaZmShrU+7m/qWautdHYP6GHe7T2Z26ut4Qs/qw+nDG5dYtyzjZklHkyMhbjZRKUlaS5YKTjYBt2Xm/OINywRHm+vl9YvL34WTqJ7CvI7qztClLARdL7qbulYycJUkSZKkNS0z/w74u4jYTDWizVOokpIfj4gz66crF+ab/MH65y3ckYy8FHgJVfLyTvNTAnvq5Zcy80CTVgv7nJWZXznIU+qXE4GvL7H+pHq5Z9HyyZn54UM4xlIWH2PxPt/pXVHPk3kcMNmz+nD6MA+yvCRpDSmG3QBJkg7CUsHJHmBLRLQWb1gmONpdL+95EMe9gmrI2HsCn4qI05ZpB8CmzIy7eC01LI4kSZIkqUdm7s7Mj2bmrwBvpUpGnlNvu5FqeNDHAE+od1lIVF5ONXTreVRPVO6iGh52od69wFeBB9VTfByIhfktH3MQp9Ctl42D2OeuPHbxijo2vRewox72FQ6trXd1jE1UQ+zOAlceyD7Ao6nOu3e+y8NplyTpCGaiUpK01n2J6v9n5yyx7Ryq4OiLPesWgqMfPpiDZOY7gJ8B7kGVrDxjUZFDDlwjol+BqyRJkiStWRFxbiw9aeTCKDnTPesuBSaAFwBXZea1AJk5A/w78FPA6cD2zCwX1fdnwAhwUf3k5uJ2HBMRvU9b/i3VTa+viIjvX6J8ERHbFq3eWS/vvcT5HIoXRMSpvccE/oQqHv7bnnIfAr4F/FpEPHGpiiLiEfVcnYv9fEQ8ZNG6C6hGMvr7JaZiAfiDiDimp+4x4DX1r73tOpQ+lCQdBRz6VZK01l1EdafsayJiW2ZOA9RB12vrMn/TU/5twMuB50bE+zPzU72VRcQpmXndUgfKzPdFxDzwHuCyiPjBzPxqvfmNwK8Cr4+IqzLzG4vqHQEenpmf7lndG7hefXCnLUmSJElHnA8AeyPis8AOqrkkHwM8DPgC8K89ZS8Bnk+VxPzHRfVcAmzr+Xk/mXlRRDyUai7Mb0XEx6mGL90C3Ifqpte/BZ5Tl98ZET9Zt++zEXEJ1VOZSfVE4yOopgMZW9SGFwFviYj3A1PA7sx840H1yB0uB74cEe+mGtHnfwNnUfXLH/ecWzsingp8HPhIRHwG+DJVkvdeVH15GnAy+yd+AT4GXB4R7wFuoHoy8tFU1+LFy7TrSuCrEfE+oA08mSpB/BHg7T3tOpQ+lCQdBUxUSpLWtMx8V0Q8mepu2a9GxAepAp0fpwow352Z7+wpf2tEPB14H/DJiPgY8BWqOSi/lypAus9dHO/D9fE+AGyvk5VXZObXIuJZVInTr0bExcA3gBZVIvIxwC3AmT3VXQI8DfjHiPgoMANck5lvR5IkSZKOPi+mSsCdDTyRarjRa4DfA/4yM9s9ZbcDJdUThZfuXw2XAK+qf168DYDM/LU6HnwO1VyXm4HbqBKWfwK8Y1H5SyLie4Hfqdv4GGAe+G59jPcvKv/xiHgh8CvAb1I9wXkN1U2uh+K3qObr/BVgK9WNr28AXp6Zs4uO/ZWIOAv4beBHgGdS9dUNVKMSvQK4dYljvJ4q1v1N4KeBvVTD7r40M29epl0/BfwB8AyqEYiup3oK87WZud/0LQfbh5Kko4OJSknSkeBngcuAZwHPrtddCbwO+MvFhTPzIxHxfVTB7nnA46nmLfkadwxRs6w64Hwi8E9Uyc7/nZn/mZnviIgrgBcC59b17qMKut4HvHtRVf8POJVqSNnfpfr/8mX03HUqSZIkSUeLzHwz8OYDLLubZeZ/zMx/p3oa8+7q+Gfgnw+ifTuonuI80PJ/RjXMbD+Umfk6qjj3QI59M1Xid7knIZfb761UyckDLT8HvKx+HUj5HRxgH2bm+cD5B9oWSdLaZKJSkrTq1YHMskFmPd/Im+rXgdb5VeAXDqDcksfNzO3AhiXW/xcHGEhlZhd4af2SJEmSJEmSpKNKMewGSJIkSZIkSZIkSTr6+ESlJEmSJEmSJA1ARJxPNcfk3flyZn5wZVsjSdLwmaiUJEmSJEmSpME4H3jsAZR7G/DBQczTmJkXABcc5D7bVqItkqSjj4lKSZIkSZIkSRoAE3ySJO3POSolSZIkSZIkSZIkDZyJSkmSJEmSJEmSJEkDZ6JSkiRJkiRJkiRJ0sCZqJQkSZIkSZIkSZI0cCYqJUmSJEmSJEmSJA2ciUpJkiRJkiRJkiRJA2eiUpIkSZIkSZIkSdLAmaiUJEmSJEmSJEmSNHAmKiVJkiRJkiRJkiQNnIlKSZIkSZIkSZIkSQNnolKSJEmSJEmSJEnSwJmolCRJkiRJkiRJkjRwJiolSZIkSZIkSZIkDZyJSkmSJEmSJEmSJEkDZ6JSkiRJkiRJkiRJ0sA1h90ASZLUH6duLPjGa5807GasKdu3bwdg27ZtQ23HWmO/HRr7TZIkSRou4+bVy3hpdfP6aCX5RKUkSZIkSZIkSZKkgTNRKUmSJEmSJEmSJGngTFRKkiRJkiRJkiRJGjgTlZIkSZIkSZIkSZIGzkSlJEmSJEmSJEmSpIEzUSlJkiRJkiRJkiRp4JqHuuOW0x6VED1rEoCI6Pk9gCAziaBeLpcbTSBpZAG7/4tmAXOdJpnJ2Mg8U1NdNow1mOmUjI+2SLoUrXWUczNkdGhEQRHB7Dy0GaGx4R40OtPQaDAzN0ujvYfWsQ+gLFpVu6Ik9mv/He44h4O1cM6HXuehH5uFS9Dza++KqF9Z/TejOlaUS7cjl1x99wKKsr6ai04l7yhC5p0PkNH7rql2yOj5+U7ntIyey9B7nOr9t1z/5u1lg/278vb1EbfX0VvvgfRVbx3VWdQnRxIEQQIlefs59/wdLVl/yR09VdbH6P3b2+8MFlq6X1sOpL0LgrKnxoBc+n2zcI6L909Kbv+LyyTjjp8Xfq/6oj7fhToSgi7HNqegOUqjMcrc9A1M7p6mm10KCpqRFEXQLktajSYjI8lcOxhhFBrJTNmi2xwlYpyiEcTsTmZHTqSIO96jWbdluX8TDqTPZm79xmH88UqSJOlIdOFLnpuZuX/8EEFRFERkz89BREFRNAgaRFFFCVEU1af+ovrs3/uJv0NJWZZEF8guZWee7M4z2gjWjbZoNgra3Q5zs3N05+eJbofotOl2OpRlkt2S7vw8ZbeknUkZDVqtFtntMjM9S9lNimjSbDbJAoKkUcLM3n3s3bePbBS0ihFKgtb4GCdv3crEpo00RkZoRpNOd56y26GTEFEwMtJkbKSKx+fnq3ZkdinL6vuCTjlPRJNGMcLcfIdOe57R0Qbr148xPb2P63ZcQ2euzfHHHcf6jesomsH4+DhE0O12mZ2dYX6+zcjICFmWjIw0KLvdKqZoNQig1Wow350hEroduOWWnXTa8xx77Gbm5maJskFmMjs/y+SeSaZnZul0k9nZWcYmRjn9fqcztXcPY6NNOvNdbrllih3X3UAErJ8YZdP69WzevIHZuXnaZTIy0mJm716OO24Lk1NTTKwbpdvt0J6bZ3LvLBPrNzAyMsLM7Bx7905xjxNPpGgkURQU0WTv1DS33jbFpi3Hc9xJx9Jpd7j++us4+cTjOWbzJhqNEcYnNjA7O01mMjc/z1ij4LadtzK1dw/tdpvv7pzkOzfvpSzh2E2jPORBZ3DisccxMz/Dxo3r2Tixjk43mZya5drrr4dyjrm5LtfdtJsbdu1hcu8MzWaDViOZaLW45wmbGBst2Ll7FrLk5OM3s2FigqnZeW64+VZawLqRJhOjTdatn6Ax2mTj5mMYabaYnt7H/Pw8o+MTFM1gw/gYWSbZbDE+Ok4QdLsdZmf3UHbadMoSutBptym7HQpKWq2CiYkJomjQbLVojY4AMDffYW6+TVkWNFsjdLtQdktGmgURDbplVjFp0SKKJkTQoEERDZqNJkWjCSRFFBTNJo1mq/r7azQoKKooO5NIKIoGzZERomjQnmvT7XQpO13KTpuy06bb7UAUVazb7UIZRAFFo6CIBpkldJMsk27ZJinJKIhGk0arSdFoULZLOnPzlO02Uf8bUr1KsptEl+rvJ7tQQDSqdmcRzHc7TE7v5dY9u7j+lpu5dXIPe6f30W23qxg8ivrfpISyrOLxWPhmof6mISEyqm8vIutvkgrK20P2sto/E7K4/d+l3pA6Eoq6sm79b+BXrps0bpYkSXdyyInKOyd87vxZo0pY3JGcueskXEFGlzJLojFONlsU0aE7v5eigG5ZUjTGaM9OUxRBlB2YmaRotqFs0hhvUmZB0GW0kXQmv0Nn7FhibAON2SkajVG6RYtmNKqUS8R+SYn9E0kH1w93JLiK/bqhN6m1OEl2WAnJ5VtDb+Kqak+d0Mre7RCx8J/991746VCbt3CYqPsYevqW23Nz+53/7Wm0uCOJuX9qLaAO4u+UjF0U8Ff13Xndgbi97EIKPuh5//aWyf3KLmRSs7fR2dO9d8pxLaQmq52r8CAoqL6sqE+X23steq/NwnGi57XQNvb7PXP/Xlx8nneVfNu/2+7I/MZCZm9Rv97572dR0j7jjuu73zuNOknZc63rZGXUCdvMYL7doUWTZmMvM915NqxvkVEwNxfMTHfp0iWyYGIimJlrEsUEs40xiqJNs9lirhilFU26UTDSKIiySzYa+12bhX8P9ntvLkpSS5IkSQej0WyRZZVQ7L058o6Yok5ARnGnGCmK2O+L//3Coaw+b0cGmSVlt0un06HsztGgSbcbBAVlt6TsdOm2O5SdeZifgzLr5GODbhQURUHRrRKGnXYHsiSzpNtNolF/MM+k1RqBMmm0WrRaLeY7XaIRjLRGmJ2dYXLPLqLVYIxkdN0Io2PjlJl0ymS+3SECikaDjAI6JVnfcNhoVTdClu0umUGz2aTZaDBL0u10mJtrMz4+ximn3JOpySnKsku37NAoWnQ6HaJo0Ol0gKTTmaNoVPFUp1MSVHfRlt0qOQsjEEFZJt1utW2+3Wau3WGuUzI/M0+z2aDz/9l70yXZkezO73fcHVssmXm32rqbwyFtbGSmT3oOvZAeQS+kR5HJbEyiyCG7m1V1l8yMBYsvRx8cQCAi81Z1s0lJRuLfdqsjIxwOhwMR5sd/Z4kJEcswhNEwEYqiwFmLRdAYUVUen5/pfKTzgXqzp24K+r4nxkTjHP/800fuHh7ovefh4Q3OGvquxZOoyoa6qLm/29N3P7Pf7djUBRHl4e072nPHpy+P+OTZ3++4393zv/8f/43n48Bf/acdYgqMMThnqOuKwlpSKDk8P3HuzhhrqcQRhgMijj54kghGDKenEyd/5m6/z89IChjb8+Fdg9WGH396ZLupMc8nWh9wgCcBCR88+3pLbR197xm6SCgH6sJw11ScuzOtQnfuUFH2ZkvyA31K9EPg1A4cWp/v1/2OsrDY0lNasMagKDFFjBEqW2JLQywdxggkjzFCUZSkpKQY8V0HAmEIpJBIWPoUQS0ihoTBjM+eEYNYk/dKpu8OEFVA83dBR7ta02j/JiWZ/J1QJps4e70mHwEy4LeWaAwBcr8hoSlb+hdnXx33NiChJMlQWmP+gruiQEQIgyf5SIp5PydphppABrvj2LP/sCIqOGMwhSOkxBA8p/bMl+ORx9ORc98SU5yB5OQcnOdHEDO6JqvONv+8NzH+8Oh82GUvTTXNThaqo6VvFntk00+cghH5N9oHW7Vq1apVq1b9e9C/GFRmvU5ibsGOjtFXl/df2/SPiDpS6km+xw89aKIyMS/KNOKsUFiwmrCuADE4mxg6IHlsVWcbwhVs2NLFA+HpkWhLjLpxERZBDEblKuLvX7Jgmo65HGvH/09Xc/Ky3dej+2Z4Kq+DpNdg3dweLnxIzdybTtRnhmdC9iWcovKYF4+/NAsvIgm/Am/yKWQBICeACHP44RIQ3VzSPC/Lx2sOtVYA3L8AACAASURBVBRELxTw6gkc21zPkb7o+2W04OVYnQa0HNuLSEu5vG8mqLj4VITbyM8JcC6aLaIrFyPRJX7U+Q69BN0vrmA2Hl5e6+1dfR2+XcFQ4uIduQKNUw9LDPprjgsyAnSZ76VBNDE9JRO8XEzP+Khkb08RxTnhfDrAEBmSUtUbUjxTVoKx9/hhIEkDmwc8BUYUG54ItmETTnRmjxXFuprkPdbln7/JoJrg8bwZlL7y/Zvm4CZad9WqVatWrVq1atWqWzlXEmNEzBgJpXGEjHrJcnPjhDiDAOWyXlYuOUoWNooRQa1BkwVjITpCjAwe0Ax9jMntg0+kIWI1YVQJKJhsL5gEse9BcjRXBhYZQsSYwAhiLdZZbAhI3yMhgTHUTQ0WDo9fKJsKYwxN02BdnW14MTgfMgSV0StTwBUWYyzWZCgiBmJMGKNYZ3BuQ9d1DN4DQrPfUG8qnh8fUUmEELBicc7RDgPD0HI4HNgmpakrQvQUzhL8QD+EHPVW1xhnSCEx9J7C5sxM/ZAx3OF0YrttcCbDTGtstv2coyxKjk/PDG3LGRi88nQ6chr6HOnnIsYaTseWsmw4dT2ucGyaEuipyg1h8PgQUeO4e7Ph4W5PCD1lqTy8+cDT0xNFUeJsQTc8UVUVv/vNPd998w3P5w4QfvfDb9htNjijiGag54qCvmuJ0XPsPBFDs9lweG7Z7e6Rp45BA30I/PTxM04cb9/ekULi3PUkTaQIpSsQTdS1o6qyI3hhMmrbFjXb0lC5AkHZNJYkylN7wliPswVOhLqoeO47+q4HLK4qkfORomzwKXEePM+njmN75nA88f5+y2ZbU9cFmDGKUQSNStUUWGMZhpSf4zhG7mkawXMG6saQ7TdN+Z8YYgq4osrfJ2uwxmGMzXl8lAzwQ37Gc1ooRSU/kySIpAzXjBlt7dFpWJWqrgm0DEPAWosURY7wrMoc2Wgd0Qc0eFL0RM2QNyWFlL9PiMFYAzhcbRFjMngdPClERPN3ArEjVLSjo68FSXnPJUnOVmQFWziwQtREFwYObcvT+Uw7hGzzGsO0LZHjIycnCYsYxWga9x1stow1XZimSgb0pHGTRPK4sLPdPO8vjPsqqprB77QfiIzQdtWqVatWrVq16qX+AlA5L1lgigTjNoprATpe62EJNyYjyhaY+78l+jP+/AThkcpakIFTP2QDxpbghNB7zgPYpBRaENuCASX5DmPBqMneXL4jmgorKY+VmyiuifNcwYZp0XbxeJ2vWXOk4gvYqNek7yW8uYVGhiXyyYvGa+C1HNcVwFPDnJhj7nIydA3zCnSCS8pshGZgaebzoIvzX9DmVUrTJWz9KqwcIWL6Cu2Uuc/RuJbJC/gyO/O5lzN2BR9v5vAVwKqL91+AuyuAvACPS2C76EiZ0ha//PhC1cbUrYv7bbjcu5zKVRdGwXUn022fnk4ZvSznObs68/J7Nz245gJpR0i+hMR57KMXJykbNTd5eV9ixUXqlsWEqIBomq91/q9eWuvlgyuaOW2qXMa5/Fin/Yrxr3xBCbCavZ0jT6TBMwyKKSu87Cka4csxUVd7TGEZipqN6+i8x6cNSN5gwdW4cCS4PZgC+haVTd6AGQmsKGMmWv2zUx+vnqGrVq1atWrVqlWrXpO1JSJxTHGacrmGGVROpVHGjX+mbCtTNpmLw+nFtU/nKgw6Zs8REay1KCU+JfxwwhNxxmGsYK1grIAVEMGHRIg+RzSKzWt/BU2JEHuKsszOoSlBDHlNbhwpKUXtqLdb+mHAh0TC4MqabV3yeHji+fkJW5Q0w5aidBgF4wrqqiSYbO0kDViZVvwRGWFjjBGRcaxEjDNUTYEMSgoBRSirkvs3d9lJMULbnoGItUqMkRAjPkRqprV9/tf3HiPC6XRmCB5rHOfTmcLmaLWh78c1fXbotcbiCsvd3ZZh6LFBMSL8+OPPaEpg4ewT/ZDY145dU7GrKo6nluPpxNu6oYuBH77/BpIn4Pjy+IjBce49ZdMQUiKJ8NOnZ+73O8RYfv/zM//1v/xthqimYLu9p6pq/viHf2Rz98DvfvOBTVly15Sc2zNqHK6s6M9njk9PdH3Hp8cjm6amLhyDM/jUMaTsCH4+9/zTjz/x/n7Hd+6evj8RtcAnGNoekkckUVYlhTVYK2xrx/uHe3Z1gVNPWRjOQ8ubuzvu7h0//vSJ51NHUXgK6yis5dgGfvx84BwTVVPiigJjEk6Ewgh+6Pn8eCL0iaFP7PcdZVmy320R4zDqUDzWWIwxRB+IKMYso5LNGMmXnWzNaPtZMURJ415OQMnPuLG5PQmSjk7BImhSQgwQE2osyYxO32JAzPwdFCRHOI5lh86HIzFGXFGM/8b0scZgCoOxJRotMVokJFLyaAjEMRoXI1hXUtQlYm1+fkPK50hKmpyO0xi1aPJvgrEGNQmJAtaAsxhnwQp9CnTRc+g7ntozp64jacSIgWnbQAzzj0gCM2bi0vG3ROffm8ueUf7dmo35/LeMsNOQoeq4N5TGfaWk+TvD5ZcL4c80tFetWrVq1apV/2H0F0ZULjSBkteiBF+J7LptN0WoKSCuxhQN1fY95vD3+OGAUUvc/w49nkibilC9wdwZqvYjpEQnYJsfciqZ0z+TmodcdwCh9C16+HFedE3A6BZQXqXzvAKtSzA0gkAEmes7LmElC2CVT3S5VJ37nv43g7mbY6Zz/iLsvAlFvKSyXUBFlm+N55wi+W67njzjRkD7NfTy8t5d0dmvHHU1kCX2vfkkL4ankc+36kLe5uPhwoZnCDYeNHnyTQ1nCPsK57yFUnOTsUtdRhOOg5m8CnWmpNlomNtMx89GzeUKr9n2BZUumszHTM/I127GDF8X0HQmn9dTNg/sKvXqMkpzMZ58H9J8T3TZh1xGdn3w+HJJKuf3dTRmuMwXejWWC7JnrJMBaEIM2CQ8tY7alPj9A0ksYHBJQZ6yE6erUTU8DyWVidRyzMadwmAbCtMTo6eolIIxvc9oXCW9bPIs5+E6tfPl+zbdTxk/01997letWrVq1apVq1b9R1ThSmLMsCSlSEpmjKxMSLqAyCQZU07xRq+VDrmsTXNkV17r5vSSGb4kYgyk4MfUooqozW6IRjBGGTQS/IARwVk7r2ONtVgrpBSxs9OkEsOQU26qIYVATAlXljSbLcErKg4pKorSshGl7Tq6fsh1CENJaSzEHGlYFHZMp2kQk+vsqSa8jxhTYa2MUVwjtNVE4QzOVnhvidHTp0hRFFhrGbqB87lHJFJUJdYYNk1DSJ4Qc6RbUkXH8ZdlzePjF74cnnm4u891JC2IWDQqZekoC4dqxFhLURdYKUlPPYVziIm0XYv3SlnlWptv7vYInqZy5Iy2hn5Qng9HdrsaaxIpCf4c+Xw88fbNO4yFth149+4NP//8BR+Uomo4PD2zrbY0Tc2X58fsyZoMx8OBqMpus6EqLQbh0+MXYgrc3T/Q9QOfP33ky+dPtF1P7yNvH/Z5voaOrm1xIhhVut7T9p44QmdXWkKKSCKnpR0UMUJZltzvN9zvHHfVht9+/57TqaU/B/qgtEPg+9LSVCX+bsPT6YyIIfiIYng6dxx8wJ17Pj+dacoKBOq6YrupqI4VXYicn48ch4H7zlGWJVYcZRlRIoqSSJCEvg/EELAWrBVsbSmLnEY4BME5i7hI1IimhIjBumzTxjBkUOdgskszp8vfi0TK9VpjTrWa7UNy7Vhj8rdSs92oCYq6JoRAdz6jKRIGiytyuuJcY7LAOIu1BaawmMLiQk4/HMwwAkmPCNjCZZB+7ucoSiKkqBmIjylfrci0aQaSMxOJyXtNxhVIYQiaCClw7jsOpyPH9kyIw5j21qBqSLPzcX6OMJOTs8m/J8bkvZj8AwMImFyfM0ew2jEo+oId8w6Zmff8pr0XowoqI6wcHSvWTESrVq1atWrVqq/oL6hRCcwGxOQN+fXN+l+LOJr5npi89lLygjCBavawdMMRXxaIQIFBhyPONfTNWxjOxP4zsvkGqgcYzqTmA0Y9OhZKV73AQaaIQp08xaZR3KSiGOHKBFIzGIq5neYPXo3Ge/HeAjhdEcIpGnU6t1zajue44MbJkJ1g46UrWQKzm1Fc7o65+mSei7nlwhB+pfbjv1Qvoc8linCJqS6ccTmWDJpUNKfrnepXjvMuExmcgNH4n2nW5Gb+X1zLkkEzQbZrfHrFYReHqIyplhapYaf2Os/6OIaxuPyi+OQ8Jy+13ITIf2cvUci1a67H/7I253Wb20hhmfLVcrETZjB8E8V7/TwtoebL9LbctPw1E0Rv/1jO8xzlaFEVukHx9XsknUhSwuiVXhrFplxrRURJmrDiGKJgTEFhn5HhkNP22Dtc/5lO7jC2ywbp4nquxv+aw8Wrb7z23V+1atWqVatWrVq1Kss6N6aOzFGMxsgYWZnAMDrMQc58MrpsLjL1XDlkzpocKXOqyOADIXhiDIT+TOxPuFpIKdcjTCoYYymKEl94fN/n1bwGYkgUZU3SiBjBGgMxMdVsSClhY0SBKGaMPDTU2x0hCd4nxDnK7ZaHukIfPzMMA23XUtUFRdHAWENTxkg1I0JROIIEUMMwePq+p64rRCwxJlLM0XGmsiRyKtjYg/cDKZkRlCSsgfP5RKPKMAwokWHo+dR33N3fUZcFfdfRe48rCqIq53NHVWTYFBG2dUVd15SF5dSegISxgisLRJWoypv7Oz59eSIl8IPnzdt7qrIgJeX5eCSmhIrjcGw5tgN3d3fsNw06gq/j4UhVlHx5PvBPP/3I+/sHqqrASOL9mw2hb/n5x49888NviEPH+XQgBCjLiqIoeXv/BovyfDjzj3/4AzjHbz984PDlCFqiotRNhabAt2/vqEsYBsVZYb+r+f3nz7RDx11d4zAYMQx9R10UHA8tm02NdZY+BfabLXVZcp+Ub+8fCOczd1VBHFpiafj8fKALgW6INI3y8HbHufe0bUtT1UQ1NGXF/QZIiedzx925o64KiIFtVbNrKoLC6dzl5y0I/8gfcSj7pqZqHFVdAIpYISH0/QBEmqZEUwGAGfePUgI7pvGNpAwxEUJUQgrE6IlxwJgCNB8zRVZmYGnHfi6ZfnIWWcWgiLOzs0BZlKQQM+iT7HiQhgGvAsYidsgpkosKWzistRjjsKXDFEJSoSTXgow+0nUd0XuIKUcmIhiFmC7RlSp5LyibqdmZNzsXmDH7asLHwLnteD4cOByP9EOPiGKtQBzbjb8fjHtu2aSNCJaUJqifQahaFhtOQrLk+pWaEeWUIWvOUjTtDS7t+jSlsdacmno1nFetWrVq1apVX9G/XkTln6kJxFyiGEfwMUWlyeQ/F0lisPvfoNphygZb3uHDM4V19NU9Eg1S1CSU2P2M2XzADE9IGFDn8iJqytiheXGlc/TgLU659lTN75gLAVMDxCvY88rVjf/mZSBg0OlvWbaZTjMZoOP7KjeQjfn9ZViX6CKF66uLvhmfsUzRO0svwGmKtsxG6xLe/mW6ikob532MY1uc4+KNl68rv5ii8C6AcBnFujiGKU2vLODb4jKVHAEr1+B0+vvq3DfzqCxutVwg3XxXhGw8LAd6g1tHW2C+uEvx+RtAOB0+hv4Kt97Uy9Hp1av8fN+M/TZamAlOXkDwDFMX7fMxF/B5Hfl5Oz/Le5kf0aunZoKzC6Y34eoL7Fz2n5UAI4qKkCRhYsjOC2ONHYslpBYtd5TR443DuJLJMZ2omKLGxD7Xvg0dYgps+4U+RNQGxLpf9eqcnt8XEcj8a3w7Vq1atWrVqlWrVv17li3KvI5N2RZJKWfmyTX2Uq77pmO9SsY18ux9KWN6ygxMrp0qc8TStK6OkvDBM/Q9cRiorSEFm+2L0f41haEsS1JZ4rsOH2KGMOQoL42RGCOYAjXZdjQa0TRgbYUkTxygT4Zmd8fu/o723OXoM1dQlAVVd+bYtvR9zzD0VKXFVgUpZQBiRsdLZy3WGNKY1jLDW8U5C+RosoQSx+hTTYoRQMYUr0NP6RwpQXtuSTHhY8KHCGr58vhM1MSHd+8IQREi/dCCy9liQvBUhcOWls2moSwrxCTEJJpmS1Nvofd4P2CcoShLuj4y+Ei92VBXDff3W07HA4VJvL3b0Q6eY/vMdrPhfr9l01TsthV//ONHzt6zqSr+z7/77zyeWx7u9ogodVmxrWv+7vc/8tPhwPdWadszp7Yjao54rcqC0/mJj58/8tRFfvz4if/pf/wfOJ1OlGVNtakJsaY7Hdnd7XFlmVOCJqXabtFDz/N5oBsU6wJN6Hk8PPPjP1d0D5CMocZyOrbEoGybDUKiKBx1WdONMLsqWkLwdN2Zomo4nTu2mwoVixjLpm4AZeg7vr0vebOv+PzcEjURkVwv0hm6kKF1YQ2kRIiRYxdxT0pdfabbb/lg9hSFpesHNnVBXRf4XklR8dHjY4F4RyIx9H2OvB1NO2MsaoUUlJgSIYGkSAoDySRQO0Y2k/c9Fs7rmc/ntKv5+2jGpE+aYX9VUThL5wdcmWHpnF84pfwyRUKIkCJpMCTrEFdgXI62LMoSZxzD4Al9rlk7lSFhduw2FK4gSgaVogEDGJN3DMSM9S2dRSz4EGmHnqfTiafjkXN/JmmOphRrFttP0z5EGqFj/oFRyZGqjAEDl4RoFwfnC2Yc96XGLFxp3jCZ9mhi3s9SATvnqR7t6RVUrlq1atWqVate119Yo3J89WdE3L2M2LqFIxdgYxQMkSGCa7ZIStigDPEjtqqJ1RvQCCbmdVK5xyZPaL9QNG9I7ROUbzGaa2FM9T/ywinxYpE0e4td1yW8XPEihe2vFrG7eJVNf9/yxJcgMp87Myr72uy9Mt6JysniZX7/UjpyjMx8MWa5jHP0mNWbPq6AKhlevQa/pmv8GvO5biuLf8ol3Su5EDyLj2R5dgUxI97S+S0dowqVxXy8qgyc5/4mGD1D4Rvwp7wKpxBydOfUh9yM+1ZzFOiig6t5fuWQRfN8baPhxBT7mD0wLwbBDfD8M1KqzC2XMHIJzb9yWdO7c5zulGpYGD2cL52rXNftvBwiV9c6zfuUandqaa0F0uxgYDCkeMLEiCRFmj2uf0TlHqwClmgTtQuceoNgaIps4GEttO0YEatMqXy+Oj+/9BmXWhyrVq1atWrVqlWrVt3KOYdOQC4IydgM4TSOqWAjoGNaRZjsRp1SL4qS/S0vjouzxggvEcGKMKRE8B7fd/TGMAxmTIPpUBViiMQUZnNEAWNzbci+G0jRY8eUsGLGepnjolxTAkKu5xeUUBRs7/e4ouDU9vRdy7apMGaM8gyevu8oC0NZuFxDMkWSWKy1M5xEEkVpSUkYuo5k8+fWChpyKtvClcShxw+elAKFK2iHgWHoQYQowrnrQSGkBGaCwRHnDMGCDjmysSnrHBGXIkVTU28rtrsNwXtEE4WrqOot4iqsT5RNTVW8p/eB1g+ElNg3JVVVEGOi7QY+fPOO+/2ef/iH3/P2YY+zBWXp2Gx3DClybDvqsuR86rnbbPjh2/d883YPKbHd3XM8H/n8+cD9/g0xJfp+wPee/a4hJeV0OqMqPJ17dncP/NX3vyHFDHDfvX2gqQr6k1IUBd4nnCupq4oYFVLL4XhiCIJPcGwjpR2oMPxsT4RUsn/Y8fR4YuhbbCH5HoZE8om6KtjU9zR1gR8Kgi94v9/iypLn45GqLNnWFXe7Gk3Kx8/PDCHy5q4hJOj6SPIRm8BZwRohecUm5e2mwncD3TCgVjj6yKenDH7f3dWkWHE+9xgcYHIqVcn3uPMBxWc43fcEI7gRKJdFiaaE954UEmIsmiIpBjQxpl4FjMGKw8hoayojvBtL8KScAhZVjCgYKJzL9VJTyrAQO9roCTTXnkw67ScJmhIxDhACxjkqAzZZuiEQQ66taSXbq1GnurXZTjZGsMaOqaLHyM5xQ0PE5rJHIvgY6fzA8+nI0/HA4XyiH3zGndblPsdIScb9BDEZJEoCJYDk3mVMiZsddfMe0uV/Y1rmcZNk2nswyiK6cvKAHn88xjYyzemqVatWrVq1atVX9K8WUfmrqV1vNvJv6228PEBI4YxJgaBKLQ4vgvU/4ja/Qas3gOZaAyNswkCqHyj7J0LyCBHxAdUjFs9cMHxEJrd15aZF4S+N6xIN+edd/8vPX+9jGT339T6/8r5c/7EEobdpOmUOL81/T5F4M0K8gqyTXgLK60i912DoKwxoglATXF1C1suAXl7eCLV0jjYco1+vru06VesFqr7obr5aYybQlJhgq8j1MXm80xzIhRHfNhrbXGDo1OYCAX8tZeqLAettzOLNEXP31/fltq7Nq0dfAekFn1TIPpOvP4eqevN0XNIKX9IGT+hYLuB/cT8WjuLTZc5zqKPreE6tm9PmJN+TzB6IxBSp4gFxW2RoicZAtQN/QN07IgMuGR4HRyWO3m4IYhFJlOFE8D57vBo3j2cyyF6bo18DkavRter/L/qH59d/KVatWrVq1apV/9/IWpujE1MaA7NyLTwZ7YQpLWwGaxdQoaPtqpoh5lQCIv8z43r8Aio1yghnBrq2pRKLry3EgDElYAgxEoPP0NQaDDnSKsUx0tEYDJJrO5LHJKIkybZSComEx1kl9S1Db6m3OxIVPoScqtRZtk1NVRSklBgGP8LYsV5gjKgajMkZh8Lgcc6N6/7EMIQMd5V8XMoRclihGzqG7szdbosfwcxus0WVXBvRR7CCWENTllSFoyodQ6fE4NlvN8QkNJWjqUrquqQsCkSUrjtRFgUhBETyXPkYqMqK/d2ef/inP9D7gC0sVemwFk6nI+Is33z3DdEHdvcPHAbP+dyy3W0pypr//nf/NylZuq4jYfmb3/5A0xR8eX7m3Q9vIfX0XUftCu52W5qypA2eqig4ns8g8O7NB07HEx/eveE3P/yAiOGnTx959/YNxkAMAWcs7flMs9nz5u1b/DBwPLd8+fyF49MT397t+GZv+fz8RAyR1gecK9AQePz4ibqpud83vH2zI6YBVLBW2O1KrLFE3+JcTjnae4/HcO4D/Y8f+c+//RZnE6pCZQ3FpmLT1DweBxKG7a6kKi3JexKGlAybpuZ337/n0PUc2hZMiXh4Pnfsasvh3II4eh9IPrDbNblWqikwklO8agqgOT2xTwo4nMspj30MBJ9TmlpjRms1EZOn6yIxKGVVI4XFXKoCzfDfiIDNEFKMRaxQlBXiHH5IqHWjjW5m0Ag2m7NjhKWOewua8r6LKwpIcHx8IviEMXYGeMa6DAsjMygVNI8NAcmRxnnPYtw1MUrUSDsMHE5nHg9HnseUr2jCicHMdvdYAkanEjkmQ1kmp2szO0TPWzKTo/AIIFWWjulTxGmGudmBdyyPRLzsL8nFNT1Pxr/qz+uqVf9i/cNz4q//l//t36z/v/9f/+d/s75XrVq16t+r/oIalX/6xvxsPP0ZUUcGSMkT1UMQtLTolyPSvM0F1ReAA8wYzaVYDKl6gPZnjNug/TOmrInqsiGmBiSiYl6c8/aaXqQsXUivzv/1Pl7rL7eZUrZe9/8y8hD+nNXcLTicjp/evup/CRwX0Z6/cAW/dvZX21xPyQj65pZy1egqLenE4Jb1J5nqR9xE5S2g3GsRuhf6NvsOz22X9Rgzr9LF63nIM1ydx7S4PbJwHrzqa8SSlxTHLCIWl60XM/QilFeu5sDM8/Pr8Oxr4O36PON9k8v83AL5275+OXJzOWlz6CiTd/h0HXNTLs1zn9NHOfpZDJQihLZF3X3+0J9QuyVQoJyzMWgqRHpi32LKEhFD1IRYQZJBLRgMQywRa9HoEVchMKeL/dp1/dpcrlq1atWqVatWrVr1mpxzpJQwIiRNpCkTomqGIYsIrin96ZTFZ2kD5PIc09pzzA40/mlMhotGDCnktJMh5MgxO1IYEc2F/DRHNsaUUz8OIUNTO6ZRlbGkxSK+M9fNSxcbXFNERBmGHlMWbHc7QsjRak3dUFUVxjnE5TF67ylLi6QIUYnJj6AnA9e+73DOYa2Zo0y9D/T9QFEUqGgeg4APnufDE95H+rajKixlUdCfWzQqdV3hQ8RZh3PFws5WqtLSDwP7XUNTVzhjSGro+z6nvC0KfMjZmnzoOZ1O7Hc7rK0AS+Eczrl8vmHAB89+v8MaQ8DgyorjueVuf8fDmzccn74wtD2uqsH13DUF33x4w5enJx7uH/AhkKJyt63p32959/6BfVlyfnomRAFb8O37eyQlvvnmLWVT0Wwbnp4ObDclVenyHFSbOV3wbtcgEmnbI5pyqtS7zYbvvnvLP/7hZwTNkY4+MYSe4HMtxE1VUTlHWWaobQuLS4lKG0QTzyfP87Hn5y8HkpSIFHx+PrApDW0/UFjFGst+3+BcgXGWJlqqsiNpIpLrKIaghBQRW9DUZY54TUryOfVwIcKxHXg8nPEDDMNAP3S4KsNqIhSuQDRHMJqxXqPGfJ8zHB/wcSBFcG76vhiMyemShTRm8NEZdGZj3iA2f5esKbDWYcbn1FihKCpEDJkp5qhjwTI5PE8lbvLzNn5Tk6IJiqLAiNC1Lb4PkCDOexg6RlBaTGHJLgQCGuZvoTFTCRRBU45u9CkyBM+xazm0J47nE973oBFn8q5BINvV+bcmjvtmZDt72gZgyjw27nfIcqdqfGHGLE+art4XEayOUHO8cBE7mv7jfsC0d6Y5gnTVqlWrVq1ateo1/ZvWqHwN/C2JxMVjVF60SZC93GQDekBPPyOmQIodaA9xQFx1AVuSAU7K8Vu4zbeE9ieIZ8QD4rgCKH/iuF8Hf/M7Yxu+0qe8+H+RcRH7Cgx6CfqWKUn/FFh5ffyl/7SY52WbqV+5gKRLaOPl5avwdKk0t/t1GH3Bk3NNR2CK7szpdfP7qukCuVm045I25DWQfH3PFmF6r43m9rq5IEYwiEKSONfMnNKtznULp/bLS1lCydEzeHntKmsEigAAIABJREFUL6bjTwD4U5+L28IF+E7m0PV363J9i35eAbzT/MzPml73NRl2vwQn8zy9NvIRN+qYvNZc5m1ZBTUbeZDGvrPnZz6vYvE+kMgR1L5/Rtweo894V2GIJASrBso7zPBIDNnrVcQRKQGPSpn7GQ7cPXzDoe3HK9erW/Pa9U1jvoLTL+Zx1apVq1atWrVq1aprOVuSJJAkZZsr5dp1LhniVLtSc+SiER1hpoJO6WEFGSOUbkt8cGMDTZGWOsKXGBOUAsaQopLGGpQxRsg9EUIg+Ug5gkJjTXbqHdNEGmMBm4OhVDHWYJ1gHIgbnYWdoWw2hCGAgjEG6wqksMTkiTER+mGEnIraHC0po03svScET1kW2S6wBkmGtus5t+ccTaeCaMJZ4XRuaZqKuirQzBcpCoOWwu5+S3vOtRYLV5JU8DFl4GQN3dADhrrZEuOAH3pMMjm6ToSmrLBJOD63PD0eefvuHVtrqZuGqqohJfoh8OXpyPsPD9w/7DidW+pqR9t9IsXI/d2OwQ/84fNnbF2xb2qaUqjLgr7v0CSEmEhD4ne//S3Ejnq7o6orDs9PdDHPy3/9m79CNdHUTYa22w3GFhyejxSl5XjsOBxObO7uOZ7PiICVSN+eiWGgdEpZWX73/Tf8/tMzfzw80wIVBiuWdhjYNSX77YayMvQxcO4DD/t7UhoQI9RVhcbI50PLf/v7PyIifPfmHmct3d2Wtuv5fOhJMbDdlLzZb3nz8IAPA2Itp/ZENyT6IeGD0OwqUt+jGrEI27KiqWrOfYeKxajFD5HzqScMiXYYaH3Pdrthv2lQzWmFjUhOWTx4xAjOCsbk5yqEAa8xO6rHDOeqylEUFgtoEIYhoaQctSuKFYctLMbYGZrnOqoWEYuM4DvGiLE5OjKnMDYLcz4Tvqlmo1iXwaa1oMLQtbmfSkgxZpsyZXvUACq5DmuGjAJqRgdpgxjNKY3JaaSHEOnCwLnreT6feD6daIce1YQxY9mjsf6mnUoBjfBQZczWNDtRp8UmgxkdK3KE6EVj+R3NlSqnZLCXLb6Jbub9ElUz/x5dfqdWSLlq1apVq1at+rr+X0v9eq0LbLocdw0QBUFiS4oBUcHV9wztAaSAcoM5fwT3A2pyOgoTp4jKjB6iKmX9gaR/IBz+gC335AXVmFd/Jg3yFSD3EmjmtKaGC9hJzBFjytUi9evwMnu0ThDmdv6meovXeg20TeO7wEa5iRLVqQbj3H8GkheoNcFXWbTRcdlpZu+3eRS6gHAvxnF9HdP5vxblOAG+C8Sbrmb09p36ml4v5uC19LgzmIPrezBe96WOJVfXNI9dBDQb/RmSzdb/DCKvjxrh7lgzZp5PbpvegFa5tIV5HX99xBJ8LaN6r0c096eLi1KRBTHUxb9X+p7/zm3zUQYlsHw2l69/MYXzYtZeRAzP/82GipmHvOhPF0+6CHM9To1EBWMahhCwpgLrUC9AiTVKQHFmNLDsBjscSPbNaD4ZrI6bMueP2M0HcBYrpzzOcWPol3QB2vMb47OmL+Zk1apVq1atWrVq1apJzrlcD0/iaI5datCJ5HStGrNjaRrTvxpJaIoYlQwMZwCZRiYwrsHH8MyUdKy75/Nxo/NhzAGM5BSVOsV9ZYMnZpipaHbwM7k2YTYhEzFMFltCxgjOKQ1t6QqMcxnWOEcMgaqpscYRYkAwWGdzGwwp5NqOzmRwkkK8wA1jUJRh8CAJEUMIOQKtqCw//fiRFAcqV5CCz5Gdowm/v9sxdAMpRZrdlpCUsi6wRuj7RFnUJDWcO09ZlLkWYVTafuCNMRBAhx51JWVdoyhFndPYHo4nzn3P4/OB3X6PxRBDIMRE1BZXFNzt9xRi8JqjEv3Q05QVhbH8/ONPDG3g7ds7tk1B8ELXRZ6PRz49PvHd+2/57rtv2DRbPj966roGAiEp1bbk/t0DReWo6g1t2yOu4O3dW47tQBLDrmk4n45sNhU5SlbZ7e5QhbbtOJ87fEh8eP+ew+GMJmUYYo4SRKnLksIatpuab7//hqI0nE4txhhC6On6nqE/c7dtOPY9j8eOQx942FZEf+a7dx8Qa/n4+MypbTm2HmsdukkYC6LKtmx42G/ph8jjl2dO7UDTFIjJTrClCPumoSkPhGDZlJamsNSFoykczkIQhZiIvUerksF7EhFrLG3bczqf2O12FE2DqtAPA0PviUZxtiCpUliHFYuRXO/RubwPouQUxGJsrn9prjOBpcmJwAjOZTDq/QCSMBQ5patJCCOUGzcjzLip4KylKCpSAj/0aErZGQAlTfsPMY0BmZojjkkkTTmmUjS/LyY7/Jr83EeN+BQ4Dx2H/sTT+cC5b0kpYMSM1z1GQGscv78GmRwOABkrXs77LLMjhCASL/tHC6frKavUxeo3F0A575lc9m2MGNK4xzLByl8qg7Nq1apVq1at+o+tvyj169eitr5yBPziokRevPbDEd93uHqDGoOaIn9qSmKxQ4YDUt1lUmNAVEhiERJOIagi2+8Jjz8CBvcCjsrLU1+N4breYZZetbmGnn86sJ3XcDdFxf9U3puh5DWovE1H+zLt6eX1DCvnfsYrXtT8XKwnc+sRsr2MsLwe9NeiHF+PPLsGjl8HRlM6kvTqHF0BSwHRMcXR0tNvcfVz0OM0nhE0y2hcZFN+Ms5fpgm+zNkCeLOY6WkRP9aOuf7wduyXGfwa9LpF6IiMtS+4GAYsAOrNc/p6OtwJ+t5e01j/4naObo69+uzFtU1mzzjjen0P5usYAfIEqUHmFLojYgYZIylVEe0wxT63FvLmjbHocCAVG5Ipsa7OV9AfiPUeVYPRjvj8Gbt9wDrHoIIzQtCXptLLiNxpPC8fvDWactWqVatWrVq1atUvKadlNRgV4uiMl0FAQiSSRHIEY0qQJkdOIU2MQEcnUk2Qsm2TJudW1RyhGJXgB8LQYyRRFwY3RmdpUlIIOUpTRiAJDH5AY06RagsDSYkhZHiZFOKlBmYOrJrWzQJicEVJVW+wVUlSxQfPptog1hBSRI0ACYMg1o1lXbLxEgbPMAwYa3BViZgcSdp3PWVRkVLAWtg0JWji86cvVIXDGcNuuwU6uq7l4e6OaAMxJna7Pf3g5zSbSKSs8v6BAiElMELTNPz8fCZFpXAFZ7FYZ7HWMvhcS/P5dOTpdOB0PvP8fKJ7N3A+t0TvSSrYumTTNONYE1VdcTydSZrwMXE4t5xOJ+4f3nB3d0eMPUVREXzPuQ8ch8iHbz6w3TT8+NOPiFjspqE7nymLijIIRbkBHCkmDk/PfHj3DU/Pjzwdz+x3DWVpMFJyPPX0fUCwFEWuefrp05mff/qZ7755z+nc0faex+dH9rVjt9/z5dMnlMibNzvu9jX/6bffMYTA8+PfY0Xo+jMpaU7BGwYOpxP90FGVlrbviZsdWMv9zlKWBX/48SN1YalLRwIO544YPW8ednz77gMfvzzxo/+Zp5NQlIbC5UhDrwFjLVYMzgh1aakKYVOXvLlrKCxsa0tSQTQSQmAIHtVINMq59XSdpygyiA4YjqczbdtS1yV1Y8AJJkRiTDnSETBWKMUgUoEUOY2rGLwPOdLTFpm/mQz37fi98cOAH3yuDelHQOnAicMYm+Hg9L0vHOISQ9/i+4HgIzF6SIqkbMurKkYNqjnKWlPI9m/I37U4OjQYZ5Fks4MBCR8jnQ+c+p7j+Uzb94QYZqhpxv0eA0RzcR5Wxn0SvWQikzG6UiYHdlWMtbNNnMZA8LzXtHC4ntJTz32b6dcBxY57Kvk3KO95mXyeP3G/a9WqVatWrVr1H09/UUTlLYi6rnkHE6yY/r4KoFoCtdH7Kh9vgIQRRWPE6ICTPfhnKlGwOde+lFvM6RNUOyCSxGFxecEnCRWDwZNOTzgL1kzjnU5sfmWR9BqcuoU6SzrzMpbudo6uetIpUu9PP+brusC+20On6MPrepVjktwrsCk3wXfZg2+uhTJCyj9pNK+M/zbybIlLX7uWxZGL91+LGk0sxzXX/5Qp0vByjReA+nKsV2mIX9QvfX1MeUqu6dscnSgXj8MJxuVmk/fka1P6WhrkmzNrBncTozRX7cZn8uqw6/qdy3l4cQ6dTI0rlMgyOvgXodwVcJwAcB6Tmec536+xDGiOAL3h6NmAmsY6nl8sQgvl++xJLglHycM2ch4MwVZIUqw/IgaiKXGFEocWdZahe6Io75FiDxKQlFP1DBoQay8nfnFJv37dK6xctWrVqlWrVq1a9TUZ42CsxShiiOT66RlWZpsrSa75iERyHbkMLZPkdXSucxeZasoL+W9VJcVESoEQBoLvMUBRFRRjNBZJ0ZRrIcaY6wCmFHPa2RARq0g0BB8JPoy17BRRgxGDscVou2boqmJzVGEEV1aUm5qQEiEEQhEoyxJHwVyDkzzsoJEYIlYgxUTXdSQjNDFQlCXOwDAENCacdXTtCSOGbz+856d//pnHx2cKV1BvGuqyoG3PuWyEscSQMGLZ1I7D6UjT1PjQUzQJjQGjwuAj7eAJBrph4Hw+UxaOU+sxtsRK4qcfP1E4Rzf0+JgY/ECKAd93pBRoqopT27GpSgpncGVBP3SYBDHAuQ30UTh1geP5zN/87X9m01Qcn1qscbgKQgj87V//NXf3e748PfHp42d++O4bnh+fSDESoicFz11TcXp+5tPjE5vtlnY48/T0hJqCH77/nm1t+Pix5enpwJuH73DOgijPzwcOxyN102Bstvu/PD2RYuCHdzu6KNRlyW++ece2NPzw7Xvudnv++csXttuGUiKnoaepN5AqymZDVQVQy+no2TcVqhXHY+DDuz1FGTmedrwRQ1WUDAN8+XICEymrE7tmm2t4RuHx0CHGUVc1hbUUhUWTUhUF3eBICF1MiLPU24ZNZdmliB8SYsa6hxFCVJzLUazW5HItQx/ohsS57UkhUFcVRoUUlV4ipSaUmH3cjQVTgLjZWTnGQIqeGABLfg6dIDZQuhKxucamsYaogcEPuZZkkpzWWclVGhWcK6iLkvZ04nw8EUNEAtkBOulcTgYRjBogIJqycy86eSjk/RgjqChqlOiVISbaEDj1A6d2oO0CMYAmueyFMKVVFuyc9cuMMdV5H8oYk8cz2duay9xMuaAmbnm9J2HmTFVJF7sGqssdktmZ++LKPf6myGuuv6tWrVq1atWqVVl/cerXF9GAi+iuG/K1eG2W4VSLjy+Lq6Sa4aK1pHJPkhpjPaV/JBCxxQPUe7R7hOYtJoGKR4zN67ruEymcaEh09z9ghuEGVC5fT+PMkPS1a7sck155L/fxpwPGCbjJn3HM1wDmLYC6bvMiRer0WhdF35cRf4wL5XzQeOwUZfnaqJbXvaiX8rWx64Lt3YZsvtb7Dch72a+5ef8Clm7TCl+AUt4keJka96pnFnxuMZ7pObkZ1yKwUGbcJ7cXcNWvLA7PY7gGYreAcTnOi+fifHW3d56XIP2mj6uxZYMG0jin43dBvn5PbzWdTeb+5otaNJrq3ej13Mo8M1y4+GIuACMhb7IYQ0HEFIaSwGNyOeK6rKAoSBFMzOmlJD7S947K1aT6Lp9ILUEShTPoEBFrb5wlfuEa/xTgu2rVqlWrVq1atWrVKGPNbIdclRNI5BSYU2kSSdnfMkkGKpJhoWJB4lj3LmVSMxoBUXONvZRiBpdExIzn1JTTwXqPEUMMyuA9pIT3OaJRfSBYi6gQ+9yvsw4RyXX6nAMxGCsYMbnkinGIsYQUCMNAtWloqppOevww5OjEIqfFvJhj2fbqh4HoB+wIYMLgOceBLeBsQTTC8XSkKgpKZwhk0LLbNHRdO0f43d9tMQaMCEVZkO3QSF1uOIkFtfhB+fL5mRQix+cDRVMTI1hbEbzn6fGJ/XZL17Zsm4bf//zPfHl6YltXiBgKY9httvih53Q6UtUFm7scSVgXOQo1xMDx0GJMQRzvpALWOH7z3fc0paNtjxRliaphOOUo1m/e3qHR8/nzZ5qmYfADP/70I9Vmy+fPn7nbNnz86Sc+fn4kieHu4R29j5RlRVGW3O1qnp8/8uXzZ+qqQYyhtIakud7ntqnZbXfc7RpC39NUlt98eMd2s+P/+sPPvH9zz8NdQ9UUNJs9iuD7M3f7hsLAnWkQMfQpgQrJOD5+eSb4xO5NjcXQth5xBWEIlKWjKSr63qPGMPiAjwP1pufbDx+oTx2mKDgdjsjpzB3Cviq5e6hIoeC8q0jJ0w4eTYlzn2gHZbupqWtLUQxEnWq8JmIINE3DfttwOGSYnFKJIhixlFVF5Yr8HYmKcwaNKQNDk2s3ZnanOJMBfEqKs5J9BGJAUVSETbmlrmuiKtaMNm5SjMvpXmXK7JVyVLCzjrKsCEPkeDwT+h5iQqJBo0LMUF2MYq3J9rGkEeRNPwyjM4IoGBlTQgt9TJyHLv9rO8LQozGRm02QMmeEUhnB6Wjn5lSvgAoGM0dU5rcmp3AZ9+Rg+pFZOoqn6TNlBLxpzCCV+592Ki648rJroeTfu9W/d9WqVatWrVr1Nf0FoHJMDznDngkYSV6aTLn05RKpdqk5Ny1+bjb3xwWRkiAOua4cQhmeUX1GzD2pKpDhETccCM0bTAi5mLorSWrQ02dEPeIcdVHhm3do90SSgBHGlBZTStBbaDkt7n4JPCwh1WRsCqqvRWBy09d1dGDSiDAVYE8vjvlzQchrbV6t4Uhe43+9T7sY7hTitmRO07UmBDu2y4bDclGaD0g3QbTXkWtLlPZr1/R1iPRL1718b2r7Cmi8asMYgfoaGL2At9zddO9eSSE6tk8v3uQV7jsBwWuwfAtSb9PqTkGbsmh7fVUToE3Z0BmjJi99TOedRmmuvxfzPMy9zYMXIUeHXq5gnJuXcDXpVNdm/FvS/IyIytXIzeKVSK6nocmQqGnkEXF7iAPbreXzsaEoC4aYx2gVMAMiEac1fTzj6IhqMfEIpgGxqArOlagG0AqZHvNXIO4aLblq1apVq1atWrXqXyoxY0mKcU2pmm2tJbyUvLDOEU2iJGMxMeb6lQiaco08jREfIaWYAZLmqLIQIxoDooozYzaTBH034EOudxfjaLsmZegDMSRiSOAjwUc0Kpu6wTgHCrYocYUDUYyzFK4AFYLmNJiK0nUt5lSws3vqqiIO/v9h702/3EayLM/fMzNsJJ10d0mhiMzKquququnqM/P//zNz+lRlZUaEQosv3LDY8uaDASTd5VIoIrM/zGncTA+RBGBmAAEee3bfvS/bXMaY1ZeqGGMonMUaIabIbr8nqWfZNBgR+r4DFZqqQTXRtS277ZbN1RVFUdJ3HdbBat0QY8RYoaoawFBWJTFlu04BrDPUVUmMA3Xt+OtP73i436JR+cMf3xKHSLVY0RQLdo9H1CtlWRMQHvZH2j5bc0K2472+vuX9hw8sVh0/vH3Nh/stV5trJCU26zWH3YH7h0dsVVJVJWigLC3rq4aruuCw3eKT8sMf/wFNkV8+3rNerZCkfPjlA2HoccsF7969Zxg8kYE///yJf/nTDwzDnqiG25sNx/0db16/4rE/cnNzTdv2fPr4CKZgu2/Z+IHN1RXv3/2IJnj7+jXrqwbf7alK4Z/++ArE0nWJQ3vg9ds3lBK42qwxznE4HDKh2VRYI1RNRe8H+q1nKSV//uWBu8ORzbLg1aZm3/Z8etyz3F6zf9xSVSWLuqDv9gQPYVSVdoNirMMVhs31irvHLcPQMVjB1oZ1Y3FSsVr+wPX9nv/463u6rkOxbA+euk6oOFKQ3I51ONczhFyvdbVc4L0nhpgti1WpnKGweR3Kx4BaR4HNz0tIuc5jVLBQOkdRZlLdGAGXLUtNEtQIzhmaZYO1Ft912cZUwFrJya6aCT9VECNUrsx1UX1g6AYkCWXRgFUkQoqRFEJ+voxixj/kXDTlpDw0grFkazDAq9L6gd3xwKHfc2x7hsETNLuRZRJQiElRMYgKRrMSc1qDu1w5OJGS5N+LM2mpT9Y8mFSYkz01UxN53S8vKZxtXy9aQlUu1gvktIYwY8aMGTNmzJjxEn5/jUri9CJjYkzgM6XcJSk5KZfO284US36VEBFCChhSzi/d/BPdw39Q1xatbkiiRBwMW4wO6PEdsVjhUgfVNSkVSDwSq7dcuGqcRv7ZuTyZLX155vTF+nwX275OKD7bpox06ctqzL+nSksmJub0fmLKLommS+L2YtNpInp+LRNhecoKHkkvOVHVF0QUp+2cJq5jn09vh1+12HwJv+WY6V58Sa04tnZSTU4E35Pjz42cbF5P1+SC/D4/Fs+Ug+fdL9SQ4+cXJNk5Nnhq5/s5YXk5NjnZrlxeEb3cUZSTpHUKJaZkguffu56/q3Nwk9tQTSMneSZ0L6ldMy68ZIvap0GRMtkPny7S2VpmHPwTdbDkXMyBkoIaGz03K0PvE0MM1MZCOFDETJwmW2KSwccHFnVDkgZCizcGHw7jRS+JBogeW5Pr8Hzh2X/J2nUmL2fMmDFjxowZM2Z8C2QsqZHnwNl28qxGShiTLVmTxGwDqQmiYE2eR6eL5X8dyUlNStSsEEsxQYyk6LFkwsWMCYJ+JCBRSD6OVpvZpjWORGgIieADVsxFnJPHlmIEI2hUisJQVBXCaEWLISSl7VowsFg2lEVBUmWIHt8H4khs1GUF1lCVFX1Zcf+wA1XqqsKagr4bSAmcs6zXax4edjxs9yyamhQCxkBZOExdYW1BVAHrsoOKGvpugGSoKp8JXYW6WnC1WvDXH98RvPLGD6QUKQrD9WbJX/6yJaG8vb5FY6JyjmQMi7rmfrvFR+X1q1s0JbbbHf/0x7fUhaNpagoLKQXa7ggi1GWBJthtDyxXVzhrSQghKs1iQVk6QsiKvbdv3mDUsTt2XK3X+K6n6zrW6zW/fPjIerHAFTV+rNcZY46p//rzjzRVSdd1GCkQcXx4uOfQev6lqrjfHTgMkTe3r7jdLEE9HZHNZokPynbX4YqC715d8/bVNWFoqYqK4+HIg+8JYcD0wvLmdSYFqwUxZh3eYbdlVZW8vmpo6orH3ZECgw4J9crmdsWiLvDtnm7wqGYrVVWhaz3WWEpjuF5WfH+7Jg4eQ8p1FUV5dXtF0yzo+4Htfs/NZkXb92wP7Zg3GylUEGNxRY3xkRASVSlYV9D1kRA8glIWlphyrKqSazGqARGT7/WUVZ9V4XDjXwgRo3Z8PvPz5oqSoqwpqxofE0kS1sqYn29yydgUc18JirKiqhpiSHTtMV9PsYhYxAi2sCQNaHRIyucEOpZyuVAhjla0IiBOUMkEf+8Dx35g3/Ycup7BB1KIJ0vpKSyfrJtVxgQF4imBWpnsXscalXJh9zq6m+loY3taMpiS2DmXczmto6SchKHmvA5wynVPObq2MgkZhHziM2bMmDFjxowZL+P3KypP1hLT++nFWW133vBlAuDycD0ptQwae4RAZRTpHrBqsWlH2g+Y8mrsXwh+wHZbXOxg89/wvkV0gOaHrMxUO+o9zUkNJnK2nv0aGfhrROGv1RP8tW3G2PPJX1yFb+3zy2TbefvlMfp0+jiSVjZPGHVSvD7t/2kNRzjVFRgJxjHHlzMJOX3fOmps09lKRGWc8P7vJSM/3/dlEvipVa6+sO9k0ftC35M1y2QhOxZdnGovTvfXpUrv3M8pDHnxHM6kNy+M8UxcvnRNdDp2HOO51yeM5mXkkdskXfDTerHftP3MKJ8ISpWnTOvFd3+qUyHnHiYCFiQHLvL0jrukzJ+cJxCNI2lPsEucHIlxx+O+ZFO3LCuh/2QIdk0yEYmeMOy5Kg1tWpLE0siWFC2mvkWSx6SWFDucelIExY7qzfN3MJORM2bMmDFjxowZM/5W5LzFTAJMzpGqOTk3JcbEyEySpKS5RKUoxtiL9M8pzjIYLEaVGLOCLKZAjEOeQRuDEQtRCWkgoZlM8TGryZKHFBn6PpOTFNk+VhNGDEEjDsUai2okxARBMA6CDbiypKqbKdUWrMWIwQ8DrShuucIWFqdCiIG2bYk+MJQFRV2RVAl+IIbIYXfAaKIsDEhEUiJFoaoqVssF93cPdG1HVRVgct0/weJMmWtpWkOKEWctMcF2twNRCmeIIZAQVssly0XD4diBMSRNBA2IVUIK0AsmGXa7HaHvcQauNysOfQchcnu94mG7pG072m6g7TuWV1dUVUnfZVvPwmRl3r71GFdwe3tNVTvKwrHbezZ1gzEFj48PGAEj8OHTB1KM1E3DQ/uJqioxrqD3nh/evmZzVbMNPZurBc1Vw//6X/9BDInNesmx/Qv/8q//g+Nx4OPHO9Y3N1gRCInKFTw8PrJqSgTPYrGk7zxd31I3ax4fH3It0K7l2A389PMdi8UCa+GH719nItpaYsp1QxeLBSlFXl+VmO9fYVUxxtFUFRWwWjqCtwy+xznFlo7GWcQr27ajKkt8TNmudfA05YKr9Zp3P/9E3ZT0Q8DHyEpgc7Xgh9e3rKqSuql4935PCIkUE4umQlFqYyhKg+kLfEz0fVYMh5DQFFnUBRHFh0BRWQRwChYlBo/XnNhal5bK5RqZ2SjVoGKzetGBGEtRNTTlAmMMIfisVDZCDBGNkIISUiSmiEiBK0tCiHSHPb4fEIWUUiYhRcAoxoIxmSjMy2Up15CFnOA93h+ZqDSog5AUr8oQBoY+2ysHn4uiypgorjoyi2Iwmsa1CYMmwQonJXUSvYjBL5zERpX05AZ16cAUx6A+15x1Y8LFuP4z2t6eEpMlu6NNv0VyuYAwEqAzZsyYMWPGjBlfwt+gqLxUSU1EVfbEP7M1T4/I/0yWN88USkxZXgJYkm9pyhofhaK5Ivkebd6gkr3/NYGNPbL8I8vrtxz293D4iUohrr4nTcoxUYySM9NOVpKcCBP4fSTj32P/z3f9LXUuv41I/TqZOmbeYZgUfmdC6YIlmkLjk23RqcWzUG/MkjvzdNP09mKCejrwGUH9KyTktxJgHMiGAAAgAElEQVSyXz7Pl/c914iZyNgzQfjZOHg2r352XfNluiArn5CUmeSbSMcz7SgnwpeLczyPUZ/cp+eRfDaEJ8ednsqL7zCTyuczOberFycmT/lL5Ty+8fROY5McCJ2tn0cyenz2n9jJTpazF+TfifDm8h493x9yulfyPWckYVTwGnm1ski8Qkxg6wuKsqB0jwTXMQTQ4cCqKjgGi5qKpbQch4FFDX3YIa4g0oBb4vwdQRgzWv9+vwMzZsyYMWPGjBkzZgBZ3cQ4nzSCMYaUQMb5f0oJyAowIxE1mZAUVaIqIhZjMlEZAaO5tl2yJpN0vRK8J8WQkw8128HGsRZejJGh9yOhl+iPLd73eX4+9pU0uzr6EBDpqZyjKJc45yDlWBprUGMwpaMo6txHijhnKIoCQelCj0tCSgHVQIoDbdcy9JYqekQM++0j2+0OI4KzBqEm+IRqoCoKXGFZmBrvF4QQshWtycSt94mkA9ZCWTUkNRhgtVxyd/eRw36PswbfDwxlhS2E17drYoqUpSOR2O8PuKKmWS4Z2o62bTl2LVESZV1wc73h0PUc+p6yqmkWzVh3Mdf3bKoKROh9RIzFkmt3WmdZLhtev75Bk+d4bFGgqhr2x45917G5vuX9u/fs9nvWNxt8DGz3B/75D//A9tDy9s0bXt9e40NAiayvF+yPLbvdjqpe8OnQ8/3ba3bHnp8+3fPT+4/cvnlDVZccDvD//sd/cn295rs3NzSFzbS2NdSVZbs7sDs80h17Bg/bQ8unh0eWzZ4//uENN7dvqFxBTBEV2D4+UrgKV5S8ud1QOct2d8QPHeurFQ/7A01T8nAX0DDgEFxTsd0NtG1PCgkR6IeeY9/RDkfECu2xzUQbjmMXKYtsKVxWFa/fbKgbgx88icihT8S7yJ/evqYsSlIi1/u0Ldvdnn4oMBicdYSx5Mzk6mTE4pwFI0hSjl0LYnFlRVE6nHMYBWLAqOZSkdaMfwVFWVHUJUPvMSZhTokFEKPPlrMxWyTXTQ0k2sOR2A9Z4azmREaKCIy1asVMcXNWSJ8shQQQQSXHpVGVFAIhJfrB0/Ytbd+O90amE/P/s05yLKyS622O6zvmZOMKWBA1pzU3I5FzRB5PicZ2TEqektQtozJVx+T2cbySO7hIrB4tYk+lgc4uUTKKHM6vZ8yYMWPGjBkzPsffUKPyklwYFWUn0uJLmOrhfU485fcJwYCFQj3OGpI6oqkz2RhbUEMa7nDVNWn9liIm/GTbaErC6jvMsEP8ESk2qC1JGlGxyDPC5FuIvueqxL9lYvW58m+y3fx9hOhvIeieHX150OWAPm9HLknp6YNLwnEkpsamTqpVTvPT8Y7QF9i+l8f9W+sDflsdyy/t+zKROxWFH6nbMeMwnd59ofXTPzo+C1mRKadM6rH10zU00/5TMACnCf2XyP7zOT67oCfyT3NplRfOXSdScfzC8iMxZV1e1JGdvi84jev0vZ/GdmFR82SMU1CSr9lLX7qcEhYuNsslKzq1lclOFQtpYOEsTo58OFiKwqHJMEQlamTFwKE/IkUFZsBKiWGfF17UIKZGYsTrcsw8TVQF+Jgw1o0B33TO52dBJ2taBaOQnn5Jc7A1Y8aMGTNmzJgx44tIaYo7pyzAnOypo6PJlFxqEZIYkqSRzEyjCjMTHnpSYyopTQooe1IKphixkFWDKRJS3rf3kaA5mvE+0A2BFBNOwLisjopFTjpNaVKjFRR1SbNYIEAkW2GW9YKiqXG2QJIi0SNGceVERERCUIa+59Af8YMnRs/gOyKRRdOwWCzovGfwgWPXg8Ss4AygvVDWJUVVsLha0PcdrnAYMvnY9z0xJZyDpVlSuoL97hFVj/cdXaes12vECr3vsQjLZYP5dD/W4YTtYcv19ZqmtOAFaw2b9ZrtDsraUVaO1aKgqC3GGZpFg1hL3TRs1ivQgaJesLhacug6RJWu6xHjeP3qFU2z5MP7D/zlLz+z2qzY7raUZYURw8f7Rx72B7q2549/WuGHgaapKZsC//iJ77+75epqxS+/vMNZ5Xjcc/+wx7iCru+5XV3x7t1HxK348HjMfd68wg+R//zpI/f7lv/7f/47qhZbLjjst6QY8H5g3x643x0YhsihjxzbA6UVlnVBabN6tw+JECJtd+Sw37LZXCNGuL6+YRg8h2NHXVccDi2lM4jCarnCGcNquSSo8u5ux8H3dNGz7w4YAkN3pBKDMQZL5GazRFNkewxcrxeUZZHJQ2OoipKUlLJyODW57qn3NE3NEBRjEzFCiIoxiaZyrJuaY2tIcSD6XBfVjM+FwdL7gbYP2KJi4Yr8DMWI9wPWGETMSVGICkYMZVFhjUE1jM8oMDoHpZhrYlpXsGwWOFty2O8JXYfGiKgZHakiJMVZgxGHTGSfkpMKTrFyHJO+RytVTaQUiMnTh0Df93RdzxAGYsqWsZK9oRHATGVZ0Fybcoz7xU6xf47/rRnfJz3VosxVbwwyLiCYMQ5XneL6bAeb19LS2GcmI1VAJ6J1XDNSZaxPC+dAfyRpNT2JuWfMmDFjxowZMy7xNxOV30L4wcSHPVWwPdk+TnQYs7WceASXPfL7HZqOmGCw9Rts+QfaMGDaO6RoGNoHbPWKEPeYZEjlLUJE/BYThIjHmOqLKspvVVT+HkLi623n8Tzf5Vv7+b37PSdfn+/3nKThGSn61LL3OfH3jJQaybPLTb9GLP66levfB0/PVy65p9NiwpSVfP5MLk7xkp6TJ7e1jIsQ04T93Of5SBk530ti8KW6lF8jpM8BwCXDd2kPywWxPI5Lc0ChY/Ylz+xthaf3wTSuc2nL6TvVJ0ecKOvR4vek1kXRnP89XuMzuT21/zLOQY9N2RLqZtmy2xmCVHhgoS1GCkyEh31PYwXSDglLkinpEZwRrEukFBFbQOowtiIlwTqHDoEkozXxC8+GTATq704MmDFjxowZM2bMmPF/KlJUxGgmQphSAzOxB5E0zT9NVlEaLklKe5qfxjjN88dWNLubSFI0ZtLDmaz6CiHifaLvelJKGIFuGAjeExGsLVGNiDEUpcUWBg0GMFjjssWjCNYJZVViCocramxRI7bEGIdJCRMF0QBiMMahKdCHHq8RP3jarkdUCSHQb7f0XcfVcsWb17f0w0AYekL0aIo4a2i7A64QNuWG1WqBtYYYA9Yahn60nNRI13aElbJY1LRmz8N2R4yGoR8w1lE1Ncf2wOA9Td1wtagY+g5WK1IKpDDQFI5YWIrSsagXdG1HUzb4mLLFbVlRlRXff/eWn37+ieXVkoftA9tDz01Rs1qu+OXdLwhC3+balNfrFV3b8rDbcbfdsl5f8fHDB169esP+Ycf7T58ISdl3R9ZXV3z6+JHv335H1ZTc3FyzXDT03ZHu0NHuB1aLxGZRk65XuLJmd2yxBBoXuWpq6jc3aOr5+cMHBp/49//xb9SVMHjPdr/n4f6Opq7ZHw7c3+9492FHSImmLDApsmocZel43O755eN76rIihoiIUlcNqORakFXFzc0N19cburblcPwry0WFkrjaXOGcwRaGT3cP3G0P7FuP94HDvqU/HNHhyLJpiENALNSu5P7xQB+VorSElBi8J6XIolkQE0jK5H1RFhhrSSYrfn0IeB+4Xm8QFGuUxbJBBQ7HSAoDRgQfBlKMVFVF0JSJ6hQIZcB7j3UDRhOFs1hrIQmaYlbrjjUsYwyYsdhNTn7NdsvGWKrKUdULnM11PvuuI8WQiUjASMoqR8nKUtIwGn6dCclMBE4Jw4mYPWWJPhDCgA8tvQ90IeGnurJM6zTmFPPnX5OsKDViplTfJ+sXclo3yNm3RuyYJK1EDJjsnGWM5oT6KVt5tHZVI6DmJABVzi5IJ4L15NykY63Msf/TGoj5LKaeMWPGjBkzZsyY8DcQleeF+s/tLT/f50vvL8mQyeLGoEjyRHHYBLQ/0pgSU22IkusiWkn43S95MlbfoGFAUkR3fybVNxQawBSoHqHbYhbfc6lA+60k329V9n1p+3MS8FvVnV/q50sE4rcc+zUC8/coSb9W1+9Lx3+LGvIlAvVLx7zUz7erLKfgdyTRLuxHZWTpFDNOyNNnc+wnPctYuVOfXePTfheE54kHy6SwvHBO33JdzypM5fJen15PlOlUEuO0O+OHlzVnT2rGy+fzKWEnJ3JXz7sgF9mZIyGp5GxvLr+Lidx8+bxOLjgnlarhZqkcWksSj1OPpEgSh8MDHtyGaAKDuaVyytq0dN7RaomYgsRA0gW1eaBLBWoFkQKJHlNUedyXxPvF5ZlkpXJ5OWbMmDFjxowZM2bM+BUkIqRcXdKci1SOiitGB5aUlUnjwv5EUoKS0qTokiexmQokzRXh8v6CsRBjdgzphp5j12EMOJu3ixtr80kmGK2z1HWJAn6Io1LKkZLSdUeKQnCFQdSCKM4ZxGXLWWNKYkpoTGjKSilTOIxG0tBhraWsKkIMmBgZOs/+cMCIcH17w2K5wQj40HM8thwPLSlGQvBoStRVQwqJNgRSjCDka2GUtm3Z77eUpUMEhiGw3R0gwXHX4tZXaDREnzC18ofvX/F47PFxwEePjx5TWFxRYsVgrKGsHM2iJqSItZa6LOiOe1xZ8fr1LRoifT9QFo7twx3L1YrNepWVeyFQOsenu0eGGPl0/0hdN6zqiofdI0Pfcvdwj6iSQmS93jD4fP0NSns8crW+oiwqtttHokJd5/Ovlg3NIpJi5Hq5wBUVafD84c0NIhv+/Oe/8OrNn/if//LPxHDk7uERovBw/4HbV1dYV/Lju0f+8vMDD/s2K9pi4KoqWK9WPGxbfv60pY3Cv//rP+MMvHnzisfHLYf2SFmWRBU2m2uqsuCvP/5I3dQsmgYRoa5q2r7jbtvy/sMdTiOvFyXbLnE47FFVGptYFo777ZHh0HG9WqAqdL5nt+9oh4TYmBWsVUFMjrp0GJOvjxApjSDWsDt09INnsW5wGEIcSApiDTGBMZZFXWINmFH5l0ayzVqhtAbVRIwRxJCSRQmZ9BeHszWFc0Akxkx2pshYVkVwhcNZi3UVztXstnva9kiKEZFsQ2sEUkxoGNAYRwdYg1EZqyWNJKExmeQf2zYxEqMH35O6I9539DHiI0Qd428jaBLMFJ/nI88qSs11LhUzugGNdTI1WzznGD7bFaMJMxGmJ0el0WXpIkk5b3CXnOP5YzhlNE/J2PknblxfED0tJSSdViVmzJgxY8aMGTM+x++vUfkZgTWSIRcTpuf7/pp6TkaSJsWADwNiKwwdUtwwJGGpES0XSEhgHNXihiQ1ag1a3SDmGnP8RHJLUrE4WWFoyIFTFkb9OmH2bef7dXyNmHtSp++F/f6e5OhL+/2Wsf2WMbxEuGrOtfsqGfucbP0tZOe3qC+/pd+MsQYnnIjzLCU8Zzxe7puzDfV8bspJJ5jIdi9mujbTWHghiXDMbhSRyU3ls7v064TudG9O28ZaseM9f6F1HLvK7834enp3qSjlYtHk8wGPFrIy7XdhFwsX0svPfx+mcT49w6ft5/oYZ2WoIEQrkBJ97ykYSNIQcYBFtUBkh2MgmQYRSx8Sg1xRu8C19LSaiENCbU9frSmHA31cYMqIpCNwNdrWcCqxKxdDO1n+ioyB3vNRz5gxY8aMGTNmzJjxOaZ5bRoL3L0UO4nIRYrglEA4Ka4u49CnM9CUAjqqL9FclzLFOFpH5rp61spYR9JhVXBWcKIYKTFiKdxImtiEMTbHBSqkqBwPHWIsNWase2dxKNaCKyyFKTHi8D7ghw5EKcuSlGp8DBCzrWu5XOKqkrZtiar0XU9d1xRVSbVoqJsrrH3A993pPK0YlouG/X5P13doivR9h3UlaKI97PmoEU0RPwwcDwecKzh2R9TAbr9HCHTtgR++/56mNgyhR5PHWkNTlYTe47uOmCLr6zVlUZBioihKnMt2sxqUm80VD58eCF1HaZbc3z/g/UBTLwg+MfQB7xNt1zFEz9AfeHV7y/awJXnPu59+oht6loslnx7ecSUbfvzrjzSlQeLAYr3BmJKUDPtDoB8CKSVerZZAtgJu24Hr2w3Rw7FtefuHP+BDx88//8zb1xuqEgYswUfevfvI7XrJ21ff8e79ewwJ1DOEgaQCKXC9ahAxJIR9d2ToO4IfKJuKGDM5rCnR9Z6qblgsl1iBoihZrq5YLhc4a+i6jsN+j0rieDyyWq65Xi6oDnu2redxf6RoHD5GVIR3dw8khZtlg7WJoMoQI0XwDP1AXZQU1lFXFcvlksIZ2q4jxsCiWmDEEkIgxoQtLF0f0a6jMAY01wotC4eI4jXX2yTmWM45S2ENKUb6rqWs0liTMUsOjbXZNtYauv6I91kZqkkwtsAY8vNUVNii4dgNDKFHDNjCndd3UgICqgOqPtekFTPWdMzkZHY1ys+UiiVbL2dyM/qO6HuC74kKimMMjHPCgVjMGMcnAJWsxEYxxNHNKlvAnlYjBMQkRCUTmyaNFrQyqiTNtOdFfvJIWKrlXA5IQdIYM5tx2ST/Vk3rFFOJIxnVmVOjxkyVNGfMmDFjxowZMz7H36SofIppRX+ciMiZtHheC/Ai9er8yWRhIzkrzlKgIlSuoesfMM0b1LjcliYkPsLyHwCH9Q9E/4itNkj9Bm1/AteQiRqLYlEzZqpNNp8XU6RvIvvkc4rzlDF2wc9MRj4nIdg3ZIx9iZj8rSrG5yTfl4i9iVwzxrzY5/Og+UtWseeJ6Jcnm6cC7V85l5f6fI5vtX/9LbaxL5N/Mv4/U6w5IJisTzL5lwONM38nmfE7Td0Tef+vkb35HsmNnF5zSn88NW7GkVwKMy/Jzi/a9Z73fNrn2NfZ+uXyybxQSJ5uYjlZ1Jzq0J6UhxMBKjkRgNPj9eK1fnoZRlL4dB0/vw/lYnQ2Gh52ifqmwWsiAC4JwUAlQiwcwXtCsRqDtjymzht6liyqNgeZEtBQolLh0oHAEicRz0jWTsTtlNCOXv5STJzyHF7NmDFjxowZM2bM+CaonmfOUc9k5WUskjlMOccf45yUkWRBIaVMRMpY2i6llBVKGhESJBiiR5PijKWpa6rCYUzuzxnBWUNhptIIgmjM45ACqwZX1DhXoikR/UCMuR5g0kwCRR8IZCIUoKobxBqq2mFcSdcNhJGcbOoFMcJhv88El3NE6wghE1quMCzNgsYuuFqtWFQ1j/tHjm1L5xONQF023N6+4edf3hGDx5UOJbKsSmIKbB+yWvG4P5ISeB9JMRGHgaFt6b2nbY80qw1X6wVpH0iuJkYhAkVdYJxQFI7NepOtO1FiiPgh4IqG3f6R6+tbtseex/0eUxh27ZFEoHaOh0/3dMlRrToWqyXH9z+zLAucWN59emBZV7SHA1VVk0ImeA7tkV/+45F/fPuaf/nTDxSmYOh7lssVBqHvPWVZ0DQ1SRO992yKisVixYcPn7Cu5GZ9Rdcb/u2//zObRUMcIg/3j/zXf/2VH97c8s9//I7huCMOLa9urrh/2LHY9dwfBgyWxWLJYrni4fCJZVnRDz3b3ZZlc8svv7ynqRcYY7nf7tkYIcUFYgxX6w1t37NaLdnv9gzeI8bynz++526759V339GsFnhNbA93ufyGFjSuYPPDWz7c7/MzYCz9EGgqR2Ud7SHQ9QPLBWANr2823NxsSCQ+vE8YUzAMSuwHLAriETFElOOx5aopKUuLUVBjOQw9kiLLosQTMeMaUNKIH9I55jUGIwaDRZzFuILee4a+yznLMas0cxFVB+owZUXwkaE7YiVRViWihpgSyQ+EMJD8gBCwJmJIiEY0GgwOwaHGwZjQrRJBI5oGkm+J/ZY09Pk5MwVqTCYSR6tnBFQtqmMy/hikGkDUneJxJY5J4zn+t2JOSwR2rJE7fTCmMY/K7qyzFDOprBktquPIZ8opIFZNo/uUGW1nM5E5rROIyWsIMv6+Gez/lt/ZGTNmzJgxY8b///E3W78+V8o9JUnyv5OC6rzvmeS4aA1QVASNA0VV0waF9T8iu//C2gVa3aLDIy626OIfyROqBNU1pn8gtg+wuMW5JTo8IvUt2c4jgthTfyf12xcIlek8npzXc271zPqc23nS3teJuVNT0+TwC2Tg14jC5+299PpLSsZfIw6/td/L9v+WWpJfIxi/XRH56+1+qZ3P9ztTzJMl60TCT45N49bz36QsVMlZhudBnF8/7+sZsSgTGfaEqLvoY7xpploW0wgmonMiCi/Jx6eXSaeEyhw4fPUZmNo99zPtL1O7U1LlxTOlF0zey+T7NKYxaUDO38Hz70LGNlTAiGIlEpPFiSPYnC1q6YlArK8o/JHeXZ2tcASSRnZDTamOQo/UAkdvsBLQ0EHqsWM/Mn5953N9mmihFz9dn9XynDFjxowZM2bMmDHjOUTyIr8CI8FneDqHnBJJn6fDnd6dp+SkFHN8myLEgMaAJo8mPyZBZuKtdBbRbMuakgfAWouRBJKTVp0tcm1MKVEKjK0oSoeRgEaLHyLGFjk2MVmdmf0kE0Of1XlVNVbES0oKAzH6XEtPYb1cQUw8Pu447I/ZxlMMPkXaw5GUBvr2yPpqTdMsuL7a4GyBIsQYicmzWJS8fnXDL+8GqqIE9ZR1na01teewDdn2VnJ9vpjAFSWVszSlUFslDC1hMGiMNEVF1w68v/vIP/3Tn7hqKqwtgESIA85WGGvYPTzyww/f8ekh8rDdUzcr+j5wPPRoiOy2B16/+o4+BHz0fLr/RNM0NKslYhyf7u6pqxJXlIR0pETYHo5YW7Bcrtgd7xhCzAnVefB4P+TrK4omJfjA+nrDx0/3bDabLMTTRCFQVSVFYXj303v2VcvmesVh98BVU3B93RDFs+8PvLpds91vubpy3LQV+7bler0iqkeM4n1HWVgqaymNpTsO7NuWqmjY74883j+yubrKJF+KVKXj9asbhr5FyO+L0uGMoXQFmpT7hy1iLX4YqJxhGALNYsmqqvmnN9fcXC9p+yNGe1bNFVVp2e/3rJYVdWlJIlxtVqzWVxyOLXVd4QpD3/f4ELM1qyr7wwHvI1YsXRcQsYidVHz5oZniT2cN1hi6wRNjyMS59yRXYJwd024NYhzH/ZHgWwpXnCyYo2YFZOEyQdh1B1IYsFawmBNRmZ/ldFIUSlIIHlU/jqUEk62gs6QxQRJIEYkB9T1pGNDgMWKxxmCR8XX+jYgkJI32raSTE5KSkCRjPJtpwSm+nhKgGZN6xdhRVABiztdLiWPSsJyTLEyuc0u0mciUbD8rMtWzPAfJFiE+ESSY/LsngnAmUWfMmDFjxowZM57j72j9yrP3cvHPSIuctl0wHOcDT3aKJnTYYoEdtmhZIUkw8UhsI7V1hNUf0ZQLlMuYSWbr10j/nni4p1jeknY/k8prjFFKTJ60cko3Owk/XzoH4Fw/BJ4RNONn8nSOJTzf4YX9nnCzFySRPh3Dl6/p1/GSeu/XrGW/1fJ2wtfa/xqh+FvJzC+pQ7+1JudvIY9+zeL28p7OpFq63Mp413ImwkHVTJpMnqgan/V1IiWnupgXrQJj7YiJGNTLo54NkrG3kxTw2fhHEvM0Ij0dY541papjxuSz/UcS9USmjltkfKb0/NFFvy/jKWEpn91HE2k4foCa/OwaIl4KEuA0Z4Gb2CLWoakEG3GpBVuPqsp8Cs4qC2voOouIsGo8lgKRnk6z5ZB9Plyd7qMLVenExj77+ZoxY8aMGTNmzJgx40vIrkA6zi9H1dKUfKjnepV6SlC8OHaMLRhJg0QmKzUGku+zTWTfE4MfXV2yc4krxuQ+P5CiRUzCjUTX1Ie1BRhBjMHamkgmbEQEbAKrJEnZMjRFoncUlYVCSElJJNBIDJHeD/hhQBAGHwg+sGhqrlZL+iHw0HcQPE1VZCWmgRgj+/0+qyBDpKxrnDOEqAzDMNb9g5g81jn80LFaLanKEhFLiErSxGq1oBt6hjaw3e/YXF/hipKyyIRe9D7X7iPRtQfKxYLjvsP3ieq6xjpL37dAZLfbcnN9S1WWWGtp6iXv331kc/OK79++5bjfYU1J5ztiTFRlzWF3ZLc7olH54btr7vqOyiWuN0s+PR7wQ8AsLaIea+DN7YYhDBQGrEDfdxRlRQgRY0E0UhYli6amqiq2jzs261uGYaBwcLNeYIzgPRwOR65vbsbE0cjr12usQEyJ5WpFaI+YFPnuZk3fJu7vHvjv//gn+vaAq2vKqmRjLG/frFktK/qup2kqEOHu/p6iKrI9sAghRFbLFa6wfOxaQoykEHn9+pZ/++d/4Od3DfuHI4umoDAWxZC8olZpO0/qPdeLih/e3LA9FKQEP3z3muWi4v4uE81Vle+N7tijYgghoYD3nq7rKEtLUzUYK4SQP7MmYuoK1Yh1glXFGUffDfQ2YG0m5QGCj4SQyc2UlDj4nDhgDK6s8T6x3+8xEjCiIAWozfautqAsG9r2QPQ91mRC2fuBFHOCLKpYNxKmPuS/oSfFHrUAAWNStnBltE4VQ9KApoAGn5MQUMQaxFqwDpJlMns1p0Wm/K85rT3YXMNSJqXjVKNSRsvXKVk5k6Q6Hj/ZuuZfpWz9LAKYSXmaSdy8b94rZm59JC25WMAw+bqRx2c0r2mISK6R+Y1rWzNmzJgxY8aM//Pwd7R+fY5Lxm7K8jpDn01SlDy7yTHRHrULjBiIMNiC0u+omhW+fAUakWygkTPDRImpx9Zvwd8RDx8xizXS3RFXt6A7nBRPFWR68Xoa8RdIvZHmORMUnJVecnGul+TnUxZTPv/sxc0v9/9F69UnzOfX1Y+/B7+mxHw+rm+pLflbyMWvWdc+f/0tY//aGL+EL/NRl/fP5TW5PMKgkp5+r6eJ/sWR42ejGc3n90FmPsf766klaiaBL+4EOYUfz875qfL30m71knY9HfOMiD+RoDwlVKd+z2O6VEZe9v8yLlWUX7L/FVXEGDAGESVickAUFRt3ePn3zD8AACAASURBVFtSOIU+4N2KOjwQUkG0bnoqiBGOcYmzHW1qiCosnFDEe4ahxSw8YsoTLSsX48uf6IW181xZY8aMGTNmzJgxY8a3YVJLppTO1VEu5uJnNeUFRFEmNWQ6JUrKSCIqmaBLKeCHnrZrSdFjjI5qs1xjUq1iDAjZAtZKAjVoinl+q4IRR1EUiElYK6QIxrhMetSZJIpJ8cNAHCK7g6cqC+qmBmtpk0GMJWikOxwzUYKwO3Qc2pa6sGgYqAqLWsE4i3WOxaKiqkuGbmAYevb7HU2M9CHSD4G+76mKAhEY/EDfDny6e2B3LPnT99+RNFLWJVXTUNcFm6sVj/FA1EjfHlitF1hRrHUcDy2DD1zd3HI4Htlsbrm5e2D3+InVUvBD4tWr12y3O3aPW+rSYcQTfc/masmnj/f85b/+TEyR0hWQlKieEAPXNxu6kIhRMZp43O5Y1DVDXUGCMCQWywVVXVDXJULi9vaG1dUVPnja3tNUQhqUZrRjLestm+sbXGEJwVM3DSC0x5blombRVKgK99tHyrpgtazwQ5+JIGNZNEtiCKjA8dhRlTXowKvrhv+n+AP/8MM1D48ldVny3e0VfuhwTvEhcOw6rpuK/fHIw8OW1682OAft8cj6+oaisIRgWCwaDrs9WubvdL1c8d58pGkcb25vuH98pKkKEFjWNU6Uoe9YrkqW6wYKcK5gtVhS10vKpqSsK1yZ60s6VxB8IoSAH/K4eu+5qkuMy8HqZr2ij4mh76jrgsEPpJhIMSehDn1AtWe9WZwSg1V1VOPm+1pVGUKiqEuMKzkcj3RdS1kI3shpkadwFVXTkFIg+B5j8jMWQiAFHZ8bxYhgTnF2yuri4EnRQ8xlRayAYnCFOe2Xgke9J/qQfyCsAetQVwAORtUkkBMcjIDmUkdMvw7CKaEBEUjmYh1OENIpvo3IuAYxlpvRMZoXkDTVqxyjfVUwyiguzZSomNweiprcdzqt05hpCeO0TiCST2k2I5oxY8aMGTNmfAl/N6LyTEpMn+jF589JI3NSYY1Hj+8zSWOMElMguYKgAeOPuKu3xOGIrV6PmViMmWAJsGP9yYAWS4wKIQQq8WgMDLJAZfWE4Hk6drkcygWXdMnWPD36rLKUC6XkqULl6fyfHK/AxXnnIPOZ0PJicjdtObX5ROT2lCI6j+9rtTf1CSn05KTH7V+vSSlc0lq/R/n5LcrFb93n91huvqTU/KqyVC+v6eV3k9+fJt9P1MIXClLG2biMlkgvMZ8nhvsL5zPZs4jmWpknDWQ63UPnZp/cTd+AFwY0kqZfiiIurt6T9zo9A3pWWaLT9RiDnRfvu6mryXJ4yvI+39uVFWxpgQGRBajBhnukagiSxmz0BJoIxZoi7ggp11WJKmASQRscHQnFqKX1iV1q8leXEmrHupljn3rxdMp0guOzl4O484+F/PZbccaMGTNmzJgxY8b/AdCk5GKS05T/PHFMaYwRTvEXTPHEeU48xj3j1DRpOpGUOu4njOqmsWljJFvE5gHkGpgoahSj2fbRWoN1FmMNKcZMlFhwtsSaCleWOOewYgkJ+s7Td57Q9WjXoTGCgPeKLUqwFh88VsAai0XYPu745AdUI01dsljUOOtwhaUoS4qioCpr2vZA37X0/ZHeK9vdgRACWx+oqoIhDJS2xIjh/tMDdWFZrZaoKre3VxyPR968vsVIrtNnLSyXC9BA4SxNVXC/3SPGERUwiX/9t//G/d0dwxD4+OER62qaZkV3HDjs9wiR9rhHbEHTlHy8u2O7b3l1s2FRFdBnRWlZldzerPn44Z5D27HvOjbLmqJe0A3KcrGkLCtcJaxXDcF7Yuz57s0tQ4g8Puypmit2+z3N0rG+uuZhtedqfY1i6YcBY6CsHNWQy9n0Icehj9sd4hxj2UIEWK1WGGv4+eePNM2Cq/WGqnD8+e7PXF+vKauCZV2gsWa/27NerXl8GNBkEHHsdgfKouBhu0cAa0wm9mxer9nudjhncc6yWNbEFDjsd8RhoCjguzdvKBC6rsgq2K4fFYaZeHv13XdUdYMaRzcEbOkIKeCcY7lYjGS8wVhH27UYIzjn2O6PhJSorGVpDIUz1LXjtaw5Hh3LpsL0MAweH8JJjaiSnwcUUkyEEDNBOan8ANRQVrnvvt0RQ0e0BSnlc7diqOsFBmi7PTGFTPvFbLeqJpOPhpSf8xQgZVvmU70UlbH2a0Ql4MxAMgUiJkeXSdEQ0TTaqVqHFDXGlVlNmfLaRU4EGFeJdCQpp5gbyDTpKHG05pRmfHZXyn+iJwrx9L/TCpMxY6KuIGlqM8f0ORFbszJbACzTDWhG1eW09gHZknkqKZMkzUTljBkzZsyYMeOL+LsqKj9LBJXpXwHsRbAFJ2LtUqEnBjQX+U7JUOCIh5+wxRKqNRp7tLuD5hWSJuf7SfE46ivVYMtrbH9HEMX0j2hKYC4ICMOXiQV5qrR8Rqd+dm5PyEy9JA7HTWPAOPn7XxJDl3TSKXttmjiOROW5TuAldJwoZruQy08/V4o+J4Qvr/uktDsTX+dtz0d4QdWeSOnfRxS+hJfa+nXr0K+38yXF5dcI1s+zmfN/PvsGniwmnL+Dy/tCxxoxUxvTf/U0tgst4/SsvHBJ9ZIIm/ZjMpY9bzhbk+pvSlV8yd53Il+fnudTS1Z9dh8/udMk29jk/dMLKtin39PlyeV9pvf5GkaxNHWJjza7zoQHBlexdo5hCBRVJnANlpASyIo6bjnINYXR0SonIjgkCclEiIrp96xef8f+4KGceEfJJOS4oCMnQvKCrn52eXVmKmfMmDFjxowZM2a8BI3AOcVP4aSwnJIvpzl2Dsv0NLcUATGCEUNSPc1DU4yEkEkQawxl5YghEoaB4D25akIkxmlOHkkJsELhLK7Mx1RFCWIJAYZjj08R5wKxjDQGnHMUrqAqSqoa2q7DtELsBuIQxjMC7weGY8DHyNXVkqKpWJeRFAc+HI6kBM4mQhgoSoOtwBaCGouqoa6XqCYG36Ka0JiVZSkqh+0e1cQhHSlcybKqaNuWqnL4YaAuS2L0qBYsmgKxUFY1KQVi6BEt2Kw32EIoK0tZvqJtW66vNjTf/wN9DHz8tOfHH//Kn/7xezbXVwxdT993RB8JQ8/rNxvEOX766ReCHzhGj09ZReeHiKrQ+UiIinVKGxxN3aB9i9GExBZ/7KjXb7HLisfDgUIUMcKiruj7I0VRAY66qWn7Iz5tsK7AUBKjUpWO2CwIwWMLh3Hw8dMdRVkRI2xWV7x5/Yqmttzd3fPu/Qf+/d//L1bLJUYS33//FhAOfY9aiysLDp+OvH7zjzw+PnB7vcKKx3c7tltlvz+MtsDC8djRAD///CPLZkGxWOFszdXqmv/66Sd+fvee9WpB1SxZLa7Q4Hn96g132x5JR0BJMWKNoyqXoI6uOxKSxUd4uN8iibHGJcQIRVnj44EYI23fcTy2JDXspOf2dqwVSaSpDKvFNdZYwv/H3rvHyrbteV2f3xhjPqtqrbWfZ5/7bBqERsEWOgQwofsi/4CCyCMhBKJIBBQQMEgIiUijiSQkmgCKQCMCCQqJtAh0E3n1BYUgogIxINrQzX2es1/rUY/5GmP8/GPMWVWrVq199jmXTt9zu77J2lU153jOOav2+I3v7/v7qRIjIyGmLOYLYvTkWUEk0rZdEgcag5FdzsYsK6mqBUO3wfcNxAHUgSRbsCxqSpez2azpmjUYiNGgohgH1hkkRiSC+oEQevAhkfkoGIua5MBsAGJIpKQLidAUiwJRhChCMAZsRnQZ0TrCGKkJI4gaiGP0oj3Z4rQvJDruTWxTmCTy1EzhW8dfIqPje011kt0LSBx/pQwGGX+TIiqT6jL9HhGTcjptge3I0JQPc9z/EpBRjKDTGE6hX0844YQTTjjhhHvwNeeovHts2rAfF0pyrM7xxYlgUR1wRIa4IbM5ZHOiFYQKigrdfAniHEx2iyyYorJacUSN2PIRZsjQ5VeIwwqRJ4nYmQiFLSl4FxORdHSMuisD+3kv95VuUwdxO7hJF5nWkjvN1l7paVA74mcaqkyetLtk8Mnj7ZBIlPsu7d7M9srfUgHuPk+hQu80JvfVn8Z79/yHyUk5tfE2eTPfNuTrfSTkm0jMtxnzm3JoHq9/SGbe1kHCPpU5qRPH45q8GbendSTG9Ei96d09ytj71LIfPM+JRLy/Ddk9sDstorDNcTFtyhxTsd5VWu6+nUaUEB3G5AzRgk8GprVzjFkTyTFGEW0RcSOx6TAyo+pvGPJzkIAiBBwuBnoBmktsfYFYhzWXe2PfXdhtGByRpNjcI52ZNovkQ/HCHwuIyOeB71DVt3tQTjjhhBNOOOGEE044DmOSSmovWkf6HFBNikuVQArJqokYULNd0xsrSAwp513mcNEnkiVG/NAi6jGq+BhAAjEqwxAwKmQ22aqiiXASZ3GZoSxz8iLHiAWx2EywDtq2IfhI9B7ve/reYI2hKAzOWCrJcW5BrCJd09EPPdoPKbciYGJAiBRFgTWCsRYxBj8MuMwmotBZiiwjczliM1QjXdvTD57NpksRUULA+wFnQE0kqhCGQNtckzlhZmf0bcd607DWNdYYjEIISt/0FHmdwp42HZvYpDC1IwlzfnZG33ds2hViDG3fUeaGm3XH5XsvyaqM+eKMSM66WSMoWZ7z4KImd4948d4LVusU+nO9aZJi1jouLuaAYbVpCR5CP4D2NE1Dvlgwr0ryXKgXNX2MKfKOgfOHF1y9vsY5w9C3DJmjrhdJ1WaUwSuvr6+5uLzEiaUoCpxzvHr1mr4fqMqKEDxqYL1Zk2UV67YjzwvKLAcr+KgsLs559fI1ZVGARpw1XMxrjChlXTGf11xdXmGsZbVuWG16XF5wfbPi7OyMtmkwzlBVFWVVIv2AcZbrjecL71/xo43jbGaJcQBrqLOci3nNpmkoM0eeW8qyBieItbRdRxgC0Sttu2E+r/Gxw6iQFzXGGNarJavVhrbr8b7HuRwfA10/4KxSZiU+ePIyIy9Kws0KH5U6L1HtKcsc7y2RiI+REDXlhhTD5KsdjaOcnWHFsFzfMAxN2mmJHsVinKGsKrq+odusEY0oLtl/xqTvWCSR7j7lmRSvhCER5fiAqmJMNtqOY+qWMayz1fE7bwziMshLGAzRZgTjCFNfo2O+MYl8nNyWJ4N0a7aNHvBGHKoRM5Kgu72dOP6NxKVMNno6q+rS/MdtLiWFfzbGJGeHcR/K7NnyYpIzBCjGmG2Esq1qU9Kx+ObNqhO+ziEinwO+D/idqvqdP7yjOeGEE0444RsRX6Oicj8Epdkj1uAuY3YgCZs+jaSFimA0EmJHu9kQxSH1u2gYQDLE+PRavYO2r9Dq2QFRIqPnqSIS0+Ipm+HrJ/jLL6OabcnMu3rG24TMMXJ1pzKbetsrdGsvf3+eu7CtKmOezj3S5pAqlb3RTX3fJob2R7wzXu/DXvAOjhFj07xgnzTaz+O5I6jehow5zDcY45i4/Q1E2QcRjj/UOSg/TNuH/Rwn64F9cutA9XiXzN2+23pDwt07leyNvXwTU1iVvfb27tatedxHqN4ufdjb7thO4Th1d/c5PXbddWuhyPYpPIa7YxlDQY9NpuDOSu5ytPOYMBDLC0QDEhSNGUb8GIIngnGg0JuC3A6YsGGwBRZLVIPRlrBakdWPUFsQjJIT6WJMuTB177Lemtb+D4PZesejILecFE444YQTTjjhhBNOOCFBxGCmnJMIcUtajmEQRxs24pPyKY4pQMxkH6b6GLBWEllpM8Q4+hDxg0cHTxxCIiRV8UEJE3FghegVZyyZAxFHljmKPEM16Z0yl1HlDpsZ+r7HYHDWbomQ4D0pb6bBGIMtMlyeYZo1UQP9MGCMkOcFfTewXC5ZzGZUVU3xiYr18oZu6HF5RlSl6wNFrtRVjjGC73uatiMEJcsNZw9mtI1j6DsKyWl7TxgCpigxJuWUDKEnz3OiH3DWJoIzprCzyVyK1POazXLN9fWKs/MZ3vcsl68xVsnygma94eb1JV03YDLLzXqNa8E5SxRh0w2g0DSvKKuMoq64uDjDsqYLEWIk+pRf0GDx3qMhsFltmD04S5stMeVEtKZIIXl9j4mepm0oZzOsFc7PF7Rtg1jFiPLs6RN8CIDBWnDWsV43VHWF1QzEYoBv+sST1LazvLxa8sWvvGAx/wzBD8xmOZvNDetOmVU1dVHiLJyfLwia2nzy5BlVXdEPHZvNhrZtMdby6vUV16uB84scsf1I8gVKU5DlGcYKQQN5lpFZYV7l9L4nKy9oh54yLwlEBiJBICQJIpkG2qZBRPBDJPge0UDuLFmeMXgFPFUNr15f07YdIUSC9xgN1LkhRM+rV69oqoLH5hERYW5L8qxGMcQYMFYRyZjN5rRtQ9f36TtgM8x2BywRbkU5o6rnrNsNXd9B1HGOFsjIizkINM2KoD3WGMQGJApGLMa4ZIf7RIQG3xN9Txg6YkjEK6T0RlGT86tGBRPSXpdLjrbicigEq6C2xyt4HH5UOyJ2RyCKubVHpCku7DgvRTRFM5P9vJbbjQabYhZp3Dq/y17Eo0Q0JoM47VuZ7R6H2RNrTmlQhGTzT/uBSVGZQhQnu34kakXQvTRCJ3x9QkS+CfgB4I+p6q/4YR3MCSeccMIJP+LwNSoqt5ondgTXXTIsld9XCB5TvQkQ0NDRdi0uLxEZsMNLtHyGSpaoOVuBXCN+jWaz1LdERM1eu4YIaNdA+xrrDNhxUbdVLd5l3mRkMrckokyR+vcnMIbPEWWPS9leix03JVu11djaXshP0jU6RohtPeFS4zteSGAvnOZel7feHrnye68jIXRQeJ8su0Vk3RreXt7BiXzd62wiVLeKTzlOWN+neDxOMB6Gsf1gIvJNYVzfpu8PowK9ZwTcJn5vk3DT/d+qKqd7m05uq8geCTmpKW/lKj3y6Owrmm/fm2ME6T55ffdegnLrMbvF3nPsQTtony1Nn8wXPVpvN67bpHx6TkePcx3D4ERP6Dp0/jTlyrCOIQRM5nlYeS5fDWg/IHGVyMosJ7gZzi8JMSIm0A8R6S4py2f4rIToGYKlyjK6USGpoyeByM6RIIokdeXeBHRKI4scOCuccMIJJ5xwwgknnHBCgrUpRGQMStgzsXRa/0JaSyqjxRi3NoIYEEkOs8YIKR+cJcsy8qLAGIP3gb7pCL7DCFgZ64hhisxjBIxJxmUMIYVVdZaUew56lMw6ynJGntXEEAkEbObAOrwmAi3GkNIsoMToiRoYoqfzPRahKmqiRvqmYaMwP0s5EbOLBZ2P9MOACHjvWXUNXfCUZcH87AwwrJc3RPUYK9TlnLbZEL2nngurvGGzbui6nmgsWWZAUw7LrCiYLxZ0TUPfgh8GyrymrHKqag4xkY954dis12yahqZpKbOC+aymaa4YvJLnJd539G2LCHRNx9BD2zXkmfCZz3wCNFIvKoabG/Isoygz1usGDZHY91gd8Nqhmkg4jR2GAic5gmWzaQhxYPAdhVaslpsUtjR6cmfxwVPXNV/8wpdxNme+qPnspz7F1eUVPjcIKfytsRYTPcv1EpfDzdUSI5Ev/OAP4vuOPM95+fwFAG1dUH/mE1hrsa4Cm+NclkLxZpaLsznLm0usMTx5/JgvfvUSEdg0N+R5zfLmmllVM1jHMKSQv5lzWCM8e3DO5fPn9ENgtelom5a6SnkMYwwYlGa9YW4FyTJ81/Ny03Gz3IAoIUbquqKucoYhhWe1ruPVq2uGvqftei5XDX0UPJbXyxX2Zs2zxw8oyw0qlvPzZM8Ovcf7QIwe47JxC8UQAiCGWV2jqnRdS+8HyqzgbPEQZxxts8aIUhQ5eZaTZQVZPqeq5jTthr5vyZ3d7hlZa0gq6EjwAe19Ch3bdmg/wKiiTGGYE1ktozN3Ct3qE1GpGZBjnAFJKmfJBqL3RE3kuxIRsdvvM6Tv+JSfVsQm5//xlyXtR1im/YbEQ452P1N6mkQmGlJIWtWw3fLakpWksbO3zyd7zteCYcuRjuF2FVKIWgw67oklYhPMPVtgJ3xs8LeBHw+8/OEeyAknnHDCCd+Y+JqIypRjbxfnfncuuVodqufuW5TIZKGJQYInr0qMN8T8Ib5tcKHBde/j8weIK9HyCWy+imYzkl9Z8po0QvJi69fQXWOHS9z8KeofYzQbw3vsyIf7Qr+yndEB2TQRkNu3creN7cdxAbgNcGEO2tub+/ZovF1G9urd4omE/cgeUzuT6nNHP+1I2X2C5dYMZSLW9o9Pqsgj12BbRsbF8f58hGNzfBvcVSceb+uDws0ea/PDkJuHn+8jMd+Y13IkfN9UdltHd/dhn6S71e9Ud3rahDv3c0ep65Zku19JedjyMTJTtobK1uQ5mOd9RPAud+X05MnoPz4Sz3cI8tszOSRwBUFDJBQg1hCIOCyF9HixPF5EbvoMYx1azIla4UOP8x2DX6Iuw+klgyyww5K8mtHaFPJIJOX4sNYRhwCj57hMJOn0PRmNri2XvD/1yZP0hBNOOOGEE0444YQTDiBCCsYRk2UXZZcvLqVzOMwLP6UPSetRYQzbOuV804w8zynzjHk1I25WdBrp+gGNEWcMZWaxotiR13DOYWwK7xpjoOs6xAp5ViBiiUHwIhQuo6gzFEkOgSbDmAwk4lyOOEMGhCEyDD0DgeCFoQ/0GrHGkWWpTtv0iF1RUZLnGYvFgsEHUCWEiIZA124IQ0PuTFJXcsbL16/YrDZcXJxT1hVhaFGExw9r2vnA5fUlvuuxxiESQYUYIzEGZvM5xhi6tkGDJ3c1+axCxOKHnqIo0Ki0fc9y1dBaT4yBalbRbF4T+xQR6PL1DXVdYdSSZZZuGOi9p2kGnC1AhXkNwQckJnXicnPFoi45szm+rvBhQCQSfUORn2MlMAwD3RDwfWC5fg1Ysqxi03m8H8iylH+zEoMf85D6YeD87JznX30f6wL1w4eUmWOIAQWqao5Gg8OQFzVf/OqXeOfBjE3bUpRnvHz+ks9+5gkxRsq8Zt146sUMEaGqC+bzGdH3LG9WKX+pg2dPznh11fDi1SV17lhdXXOxmKHqabsO1UBRFiln6KwiK3K++t4LXJZRiNL30HcN3nuq3KXwvyJcDx3PyodsbtZc36xp+g7rCsqqosxLCqc0JjCEQNN0+L6h7XqeX28IPrIJDVfrnvMiA2MIfiCqJ4bAetMw+JjI2Cxj07SIsRDBRyHPLdVshveBbvD43pMXM6pqgQ8DVjwuM1iTkWUlzlXMFudojHTNGiGCplDGYEElhSgOA6Ed0GEgDC3eJ2WzNTnWSLKEgwdJBC+RMW9kAGIiISdVYubSmK0F44k+btWSIlPaETOGVI17PxPj/g2T8zjsOzCn7bYp+tWktJwIzNFBV/byVLK3Vyb7e1GC6M7uj5Dydeou8pPo5HBstu1s9wnkdrStEz5eUNUN8P/8cI/jhBNOOOGEb1x89HiFsm9M3VPkYCHyps8ykn5xaLAWglVk8xVMXOGsw+YON7zAbl5gYotUj7Htq9HDK6JiGZpLWH2ZPPSIROzZp4n1J1DiNkzF7dlPyb/Te5nCVN4KVZmMyOnINE6OkZTAruZUe1zIcv912K+7O2dSHyaRNtvjMpGPt0nK7eutcrsxpndmHM9uLnexC8che/0mj1zZHZuuy617uF/H7NX54L8712KfmH1DubfBh+n3TXU/TH/7de+eZ3t9EqbXvft+cB/3jwk6aZjHz/sk+M6QODr2W4bG8blO0G1bt+cj0xzTm7vfa6bvSHqadl7iMoaOmeZ+Hzm9UyNPpKEVMOScnzvmco0zA5jAvMzwPtIEi9hINIqIIzcluDlZtSBDwff4my+iGghBgOTNbTBoFGzmiLEfN38OaeDjJKSMOWo/bqaWiPzrIvJXROSrItKJyFdE5K+JyK99i7r/iohcj3W+TUS+KCI3IjK/p/zvExEVkV+8d+xniMifE5Evjf2/JyJ/S0R+x5H6tYj8VhH5OyKyFJGViPxDEfm9IvLOXrk/OvbzzSLy74vI3xeRRlKuTUQkF5FfLyLfKyL/dOz3tYj8ZRH5OfeM/QfHv3MR+S9F5Msi0orIPxCR3yD3/CiIyE8Vkf9hnFc/XqM/KCKfOFL28+O4cxH5j0XkH41j+6MfdC9OOOGEE0444YSPB5yx2xCRIilEqTUGY5JyyRrBOsHZlI/SWJfUcsZhjMXYFG7VGJNIGGtwzmHdaCOXOTbLULWJMBwGAhAEohgUS1DGPyGqIUZDDGDF4bIC4zLAIMaRZQVVUXE+P6OuKpw125yYCjhryfMM6xxVXfHk6ROefeJdHj5+TF5XSGYRa8hKQ0RpOo/3MHhPDJEYIpmzVGVBmRc0mzVXly/ph6Roy/Oc9abl/ZeXrDc9wwDqFd83zGvHpz71FOcyQlDKvMSIkDmD7zvCMJAVjvnZAmcdzWZNs1njMkdW1jRdj4phPj9nVlcIyjB41st1Ct3ae/JMcFZxRsiylHOxKnMeXSzQMFDkDqHn4qxiVlvQFis9D85rDANnM8v53JJnSmaEuq5APcYqN9eXrG5WoBk3Nw3Pn1/y3nvvs1peMQwdghKGDj90PHn8gLNFRdM0lFXN/OyMsigp65Iu9myaNdmY1/L68hWGAd+vE/GVWaIYmr5FLBhrWa87gkY2zRJjUq7Gqqypypq26Wg3LXVVcTYreffJOdYJy6Zj1fSs2w7VdK2a9Ybl9RKrBhXwRni1WvP8akPnE+22Wje8ulzSDxFnXXqO8pyynpMVORHYtB03qzVNtxmJNENVz6lnNWEYGIY2qTTXLat1w3XT8/x6iRHDfJEIafUDmYW+b7m8ukYjWDGURUXfKzfXa6JqCpvsLFmWoyJ0QyCqoSjnOOcY+gZDILOWoixweU49X1DWBc3mmhi7FHZZUthmFU+IPcF3dF1L1/cM3ic1YuawtOHQlgAAIABJREFUeYbJMoyzo1g6JidZwIgZQ6Pa0SY2yRHBGMQ6jMtTGFibo8aMjrMmeTuMOWVVBBWLGAdmdxwxyPiKTFHPpldJvyNiRzvWYMSN5UdvCsa2sGDsuB+1t+ej43jHORhSv8bYcRzTMKb+xvC4270hy9eyBXnCDy1E5DtJYV8B/q3RTp3+foWIfG58/51H6v4UEfmLo81+M9rZP11EvnOs87kjdb5ltOO/ONrN74vIfyciP+5I2Tfa+yeccMIJJ3xj4KPnqNQplMzd8Jz7ELkv7OSdBhNxOGxwgGRzmH+S7sU/QuwC8sfEPKQFT/Ma4po43KDZjNh1SLwhKx4Q3TPC+kvYs08SxWHimAtkDJt6OIbt65Z8nM7vQkAyqry2pJ9MZMpdxdxU+k1k0DGl3bbP8VLszh0hQrZjPtI+B/pG2R1RZFR/ya02dvkLElR3HnC3Wx7buhUS9NasgV0+w2P3/oNwa96yP5sPKn8cH6b/qa376rxNvsy3UW/eDne6R2qLotsQonfb2V1qixLSEd3zroT0+VjtvWfrcNx3VJ5jMR0b2s3vdjjYwydzf266O5ieuVsE6OEYbnt7Tj2k5ys9b8EoPgRW4YyLShh8T2kbCpfzxeWMWQ6ZGtT3RPWI9jgcXjJ6LIs6w+YP6QaLqMf4G2LMUFeikuGNw9KPIbj2L9KBenIP23ys0+A/BhCRXw38QeA94M+RwrY8Bf5F4N8Gfv8b6v4y4I8A/wT42ar6T0Xku4DfCfxS4LsOylfALx/7+p/GYz8b+B7gBvizwJeBh6QQMr92bGuq/wD4PuBbgX809t0DP3oc63cD7x8M8/cAP2Ps43uBMZEoD8dzfxP4S8AL4F3g5wHfKyK/SlX/8JFp58BfBi6APzl+/kVjWz8O+HUHc/6VwB8CunF+XwT+OeDfAX6eiPw0Vf3CkX7+NPBTgL8A/Bng+ZEyJ5xwwgknnHDCxxDGpBCMabloEnEigLHjentMlDCqojh0Ek2tjA51ksgMkxxQxTjyLKcqcmJV0I0OjZlxiTeQlBtOGOtisdaBCIP39KEns6AxkSGqHh+HMfc7QIpsEgViGIiabGBjLDEoUQPGGmbzGecXF2j0eO9H8qbbprDwUVNozL5nvVrRdi11NWNWVThbcXm5pG0GHj14wGJW8u7TR9ysrnn5/nsYFZxzzOcFQ+gpqoKysHTtMGX9pO86zh9cEKPHDx5jLEVWQAy0zZoQArPFOdZmLJcN1kwRVRpywBY5nQjrdYfGQJE5hmZFXhZs/AbrypHUAYjMFjXOgqrDGg+hpSocJrdo7JnPF4QYeP36hszlbNoeRDAm4/LmisdPcy4ePiTLcl68eMmsKlgs5myWS/KiJM9zitKRlwUvLl9z/uAR77z7jGZzPebiDPR9h3M5V1dXiBHOZ2fE1vOwXiCh4sX7XybPLZ94cob6gabtuVpuaNqGZ5btfVQ1RAxZUTFbzJlVJVkx4wsv1wx4Vl3L80vlyfWGoe+5fHnJpz/5CTKX0bQdXdsjEc6Lks1yxSYOYC1DVNrVmncfPSQMPUU2oyoqQoDeB9ZtQ5YJVW7JM8MQAos8pxSHsGK1SYrMIQxk1lBkiTBHhYvFjLq0lLnBVSVX1zfcrDqMcWROmJUFVVmzWi2xYsirCpdZfAj0/ZDUt7M5Z4tzQhiIIdmQxpW4vMC5mrpe0LZr2naNkYiI27rUqipxVLwSxxg8YrBZnvz5Y0Q0oiEpJlU0EYsyqqNldEawOdbmWJuiA0Xjki0a0nMW40ggSnLOl2mPRsK4DyDEKRjRuE9jxk2alMpnF6p1Z6XLNmTsboch5TSZ9nd0irAlZmvnikiK3TrWm3JOGhjHMqViSr8jmKS+1DEKl4gZ3ZE/bm6+P6LweZLd+xuBv0eySyf83fHcHYjItwN/kaTQ+G7gHwM/kWTL/9V76vzssWxG2pf4fuBTwC8E/jUR+Zmq+n8eqXqfvX/CCSeccMI3AD46UQl80CLjPlLukMASETQqUSKEDrUeE1u0f4UTgzZfIQwbbFbgTcQheB0Imxu4eUFx8Wk4+yxDt8a0X8VefAbFjsMzCBlOJFE7B8TkbYLhkHDcZ07uzvUu0Xg/CXlfuYkcHaNu3G5bd8PTfbJnIpjQMdTHSOrsM5S6G/EuaNAYbmN7fBrrbXXb1M2UDJ298J/buLe3Z7TtBQ5zWR67bm8IG7o3z2Pcz4chBffrbEmlN5Dmb0syvomAPbzv95Zjuod712h83Laq3ENm8Rbs9tzeN2lXbTuAfa59smISGSeQNkqOjn1Hbus0sK1dsSMfdwTpFBr1zWTv1HK6hrfo7904AfYJWwGjSZXcB7juHA9KZZZ7Xq96ZtpRq3CtK0QL1NQMUmMFtF1TmY5e5wy2JIs3ZOIx9pxeCobQ4PqWIQxImGLfGETj4bDvYs/Z4W5o5a9b/BoS2fetqnqLDBORx/dVEpHfCvwu4G8AP19VX4+nvgv47WO733VQ7ZeQjJn/TFWH8divIlnCn1PVv/cB/f9XJJLyDwC/TnV3UyQpOO2Rof5k4Cep6g8cHL8EPquqXzro83yc0+8WkT+hqs1BvXdJxOxPUNVurPM7gP8d+LUi8qdU9a+Px3/sONYfBL5DVb+818/PIhlvvwf4BUfG/dmxj7fK9yEi/8c9p74F4POf//zbNHPCiOVyCZyu24fF6bp9NJyu20fDR7luU50TTvjhhrUGIYxrfYNBE4E3OhtOBEPyX0xEBuxZUXsm6RSa0RiLdRnOFSAOl+VUswprDDEExKSccz4q1grOWKyz2Mxi8ywp90LEe0V1IEYFY3HekkeX0j8YSeFejWHwnqZrGXrPEDx+CEmRZQVVIQYlLwrqqqTIU46/vO/oum47x67v6NoW4wxmsLz3/nvkmeXhowe4IqcZeq5WG+bzGdYJ8/mMIsvpu4EQAtfLNTEEyiJnNqupqxIEeiJd19O1PVVZ0LYtIpHQR7LCErzHd2uur5bMZ3M0RrxRNIKzOatuhaonKxxn9oy+a/F9j8SI79aURY4r0jXbbFr6PnB+MU/2SvAUTrBVhggEL1hx+L4ncwbF0zYD1hqKRxcpX+mN4eXrJZ/+ph9FVZcYY3j/+XOevvsMkUjmXIqDJJbc5eTOEsNAUZR43zL4gdD2QMC5ElUI3hOImMxQFwWr1RKXGTLrcMaCKs7lfPXFDVWVgQhX19ecn50RVVPeUZvUdNaVuKxL9p4a1k3PLC9Zbjref/WKOnO8+8lP0oWQiM9Nx3w252oz8P7NktxY6twQJVLmlrLKsUYpqoy8cIToWTcdy/WGZ48W1LmlzNKciZJI2jzDGqWPA/3QY4ySS+Cdxw9o2p6nD2bUOdR1QVEveP5yRTtsYCJfbUZWluhmRe8DZ1WJMRbfB9QrZVHx4MFDqqqk61b4kYQ3NkMkoyxnAGw2a2KMKVerpusjGLyPKe+lGpBE1hsBZw0aFdSjIaTwQjFF2BJjwKR4Q0YsJsuxWYHNSqwrIMsZg0MTRQlj/lhFUCM7h3NN9irp5yLF/lIdVZbp/YHrOpO1LVtbXkZ7d3Kcjjv7W8a29n6DZO+f3a5Pyn2rmvbVVGziUxHiSFKmfar0GyG3xnPC1yNU9fMi8oMkovLvqup37p+/RxVpgP8GKIB/VVX/wt65fxf4r4/UeQD898AG+HZV/Qd7534C8LeAP0yy7Q9xn71/FB9kN/9Q4rTW/+g42Utf3zjdn69vfNzt5q+BqDxUhR3HsXNHyTwBwoCRwBAsde6IUXD1E2x9Rr++ImYlIhnD5gVGLNXTbyHz1/Sd4C//MZkKPPhmRC2YcYQmogwEuR2mdLdI2hEih6SVHAlLcWvMexKwtyUoDw7cWqbtFJu783vyxCNtH5CGeyTV5H07jmq7oDzsT2XX7zTG2zlSpm4mkm4k17aN79NMhwviSZ12wKDe6ec+QntSGL4dKTjhWG7GQ6L8TWXfNK433d9j5Nwx4nIif9P58RmbCODtueQ5KXuheHft31b87d942WOsdyTomL9ius+ie+XHZ2CPEGe/tOxMlP27eOtJ2ucw33AN9q9PnJ6dbd/puzRlaU3Om8otcaNRiIJXl7xhu4bXy4yiqJkVwnD5kpg7ghVcEHyzIreeKI5W8tHj/IzQrAmhIxPBioHcYV1OoWt6VQ79S7fjv3U0eae/zff+6xAeGA4PHiPJRsPj95KUg98N/DJVbffqfFVE/gzwi0Xk21R13xD4NaSH75DABDgkBG/1LyJPSUTnV4H/cJ+kHMuu7pnb7z5mtIwk45eOHL8WkT8C/OckReNfP9Lmb5tIyrHOaxH5T4H/lqTsnOr8eySP0N+4T1KOdf6KiPxZkqpyoaqHq4Df/rYk5QknnHDCCSec8PGCiGDs6F8VpzxzYzKHcT2ZVEkpLORxxO26MyCIsWR5QZaVmKwAl2N9T57nBJ9ILFGT2haQzGLzHGMtMU5rd8MQII4LboMSvafbrMmynKwocCY5tPoYKfKcIisZgqfvBpqmpW1bVCVFPtms6Lqahw8fMqtq8jwncxkhBDCJLPXDwHq1RuNAmTn6vuP9997DWcOTp0+p53NcZpjXFX3viJlDFxUhBNrG8frlJavVBo0wP6vJcsOsnpHnOWKEGALOJbWpxsjQQYxC3w5EE7m5uQSNmMwRB0WjEIdAjJ7MCIt5ySoG1k1L9B1FlhGGHjHw4MEZLl9wc73i1Vee0ww980VFXRUUZUmz6disOuaVJ0bLy8trNusN57OM+WLGpm345Cc/jUrN//cDX2G9XnNx8YBnz+ZcXS+JChfnF4TB03YNIj3WKg/OziFCnuXIbM4wpHCjQuT84iFIpGsbor9gtWzoh5716obzswWEyNB7yjInqme9vuHRo0/Rty11WaZ8iAizekZ/dsa8nkMMrG6uMEYIKmyawJPz9Cydzec8Ol9Q5DmbpkH9QGGFT7zzlK9crhkGYVZZPvnkHDSiMaBDT3lWkecuEddquHp9TfRK5TK0D0Sv9KFjlW84W8xxTjirCp4/f8F16wkB1Hge1JbPPL7g3XfOWK82nM3mzM8f0XXCctVyuVySu4phEMqyZF7PcS7DZSXW2ZRTVAyz2TkXDx5jjKXrWtquwRiwNsNlFVlRs1ovWTcbnJlSrZhRwaiEEIhRidM3ySSCMIZI9BFCRD0QAzGk3JRGHGIYwzsbxOWYosJkNZLliM2JKsTgCZrUlKpmq34U45J60yT7frtVJBYjKdtlojZjIga3+wKTozWjA4OOjsu7XxdVMxrhMYVwjYqZ9rpG0nJyXt6meVFQ8Tsn63HPKKWnSc9V2m9SjO4cnD9GDr4nvB3+ZeDHAN+3T1KO+EPAfwD82IPj/ybJofnX75OUAKr6f49Rm36TiPzzh+e5x94/4YQTTjjhGwNfo6ISPsz+/H1qqynEjfpIZiJtB/HsCSIZEjqiD2T1I8LVFyAzZOc/CiM5lg0+ewff/L/Y/AkU59C8JGYO8jPEFKAxkR+3VmLTYmq32Dr07HobYmp/8m9LVNwhvqb6h23uk2XT+QNS8dZQmMhV9ozfg7YP2x3Lv+0cbinopqGOg9uqL/davEsyHrnv+20fJbluz+BtVJRvUkm+zX26j9T8Z4F71ZjCnhcjtxnnwzlsfRhv15dtedmWS8SfGRWPexTcdhMk7rjR0etx2/k+STh6R94e1gHJqzv/ykNMzyT7HuPjWHSaunLwTdx9O7bhYqzHSs+jec+XX52zqDpWHl4sk2fqzHREidz0Pc5a5rOMZZeRiSJhg3iPlQUMG/pyTjCCi45BlCxr6IKmlBxi0UNV5e3YtLeI4ztlv37xJ0ik3D8QkT8J/DXgb6jqi3vK/2ng3wB+H/CbDgnDEb8f+MUkYvJXA4jITwR+GvAXVPUHD/r/hcD/JiJ/ihQO5m8cKh1JpKEB/rqqrj/E/P72fSdE5F8Afgvw7SSlZHlQ5JNHqnlSuNhDfH58/Ul7x376+PodIvJTjtR5SlKB/ljg0LPz3nEfg6p+27Hjo8foT/7c5z73YZr7EY/J0+x03T4cTtfto+F03T4aPsp1WywWPzSDOeGEDwljzGh3KSm/nCanWlVEk20QSeq1+0wP1VQ+hLAN4yjG4rIUNlJlzLtuBJdnk9cfY1eQGayzKbykJrLCGEtUg4mQZY7MOgww9B0GoSxKLMLgkzIssxmZy4nGEOtInm9Yrpb4IZBnIBJAIqvVNcPQUZVVInIkhcmMqkn55z1d29O2HXme4YwheM/15Q3NpiVEz2JRUxUZ7dCzmJ/RNi1lXvHJT5UMXZfCvqqn91DnFbP5GVEjMXqKaEcHysgQPKKWvmvZbFrKvCBzFo0RYyI3yzXX1ysyZzCmoirzlINyVqLRYoiUs4qoitEkOrx4UFPVlq+8d8X1VYMJgsEy+Miq7TGSUXhls2xp2oHz0jHLc3wXef+9Fzx6513qmeP66jVPHj9hvpjz5PETVss17zx9Rqct62bF5eVzzs/O+PSnPk3bDviR9PJDR5FntM2GEOD5+y8xRpgVK0SUpt2gqmTGgEbERPI85/L1awSoiizNNysJPmAkolGoqorZbEYceqIa8rzER2XQQNv3VM7wzoOHrLuOPijPX1wCAyqe+Szj8cwR1pbH5yXf9O4FXTdwc7PBikEi4GMiYX1PZZXH8xwDdB5eX6+oFjOCHxBxrNvA5cZzuR7ofGRRZMxzeHhWcbaYUZYF3TBQ1jVZ7pjVBVVhuLzq8b2w2ayo6opZXZBlOcYZsizDiKHve6rZjLqu6duGvm/p+46yKBHjqKo5/eBZrW4Yhg6b5RBTHlkRiDGO6ucIErcmbowhkd4+QAhoCGPI2OlbnPa8xDqss0iW4VyOsVn6DrsMohIHn/LJokR2JqhsbfVkFxNHmxzdKiSVZMdO3r5pjyipOHf7KnFrZstIvqrGccvBsm14LD9FfNqZ/lOkrrEvgDFf6dYZmimn5ThnkUSy3rcXcsLHGZM9/L8enlDVKCJ/k7tE5WQ3f6scyXe5V/7HA4dE5T9Tu/nDtPVhcVrrf3Sc7KWvb5zuz9c3Pu5280cmKm8rE/eUYtwlY4593seUE1Fig7WKxIixjjYMGAOueZk84S7eoe86uvaaqn6KCxuW1yvs7DOEfonNSoyrgB6aFSJLtDhLqikxo4equc0OTqTOASH25jnvj/v+829q41jZWxTPntryQ4U45Qj5ebvQnfcTyXk4xkMcEpv7ndwKH7tV6x2lSm+1dzj+u+f3qavpGdMPdU3u6+9Yn/eVu6/esef8Q/W5u8npZfp373mcSMEdub0js++0rtP56VnYL2EOizKxzHLruOx9H3Rb8rDcXchWBXvbQ1P3IsnsnvLpre7Nae+JZMtopp0YAGJQnl1EXt5EOs2I5pwze81GLIjhenBk/pIsdNSFY7POyOw5IVqUio0BYzxzF/D9Gl+cESQS1FK7DLo4Xufj3uw7onb6TZu8VN94Yb5uoKr/hYi8JOWD/A3AbwJURP4a8FtU9e8cVPl2Eln35+4hKVHV7xORfwj8UhH5zaNa8FePp//gQdnvFpGfC/xm4FeSyM3JUPhtqvqXxqJT/otbysS3wHvHDorITyPlx3DAXyHlj7whKT7/JeDnk8LVHOKlqh7LezH1c7537NH4+ls+YIzztx33CSeccMIJJ5zw8cdEVOpI2qkwKittWhCPikoZ88QdX3JZYozEmM6FEAjeE2PEIFgMXpPaylkHJBI0tZ1UTRoj0fiRVBnX4yM5Ya3gLElxFQIheiabywdP33uMdWQC1grWOBbzOVnuWC03NJs1zaYhKthsYBg8kdRWjJE8czjnWCwq6rrkZrnGLjP6fsAPnqouyAuDhoHQe16+uKIuC4LCMFhcJmQukSjzswX1bOD6+oZu49EB5mJYnC0o8oIhDnifCCPT94QhMJ/PUBuJg+IHpRsa8lw4O8uxpsR3kX7TsJRIlefUdUFUR7vesFxuKOsKlzlubpaIBN595yFVkfHy5SXWGa5XK0JUnLGs1gPXcaDXnLIQvArrticG4eX1K7JyziefvcPN5ZLN8ooYeqwTLi8vEXEUxZyiD/jhBa+ev+BscYZisJnj6voSI4HHjx7ge5+eGhFEA81miRHFtx1WwGgECSzmZ1RVwZe+8hXysmboeqw4+n7AzKDvNsDAbLYgywp8hLKeM59vOF+UyHrNWWl5cjFHJSJuhhXDZrmmnFtc5pgtLpjVBZ94OOPT714wO8tpXvdIbqnqkgfnC16+uiQvDU+fnKHqefHyfVzpePzOA+oqJy9TDsem63h9fc3LmzUrH4m+592LnHcvzljMa5SM3oPLK7Jihs0KyqpmMV9wttqk79YQsZKUkNamLS8RwWQZ6nKKap6UvgQymxGjpHkXc8Q4rl48Z7NeJXWjsahVrEn7SBoVZwWJBh8VryHla/Ue33tiiIkg1oAi2InoE1L4V2sRm2NMhpiUq1LEoggxxtRmjIS934E7ew6Y7V6LMG7rTOFgx8+RSNSw55Q/lTejiR1hVFJuHc4ntaWBuN1PSIauOdwJ2N8/29+HUsCYrepyiiYlozr7VsikE74RMNnD799z/tjxyW7+VR/Q9sluPuGEE074EYavQVGZFjP3qc8OCaA3fh6T1dnYEsUgQfHLF2Qu4PI5ZvYMXEn0AesUXT2n6a4ItJjyMxgMaI+sn+NtjjEgzhB9i1l9AelXY/gJM3Y3LdIOSDu9S6oeG/t9x297kU0E0/E6qpOac6x7pP19mu42ubUjqg7JRtk/z8E6cCK8SDn1prXlfSrNW6wnW9+5qdIeeXZwzbaqvEOiEWDf8L5NxB3D7fblTv3dpTisf4v23X7+IBLxw+I+lfAHnd+KC7fXOC3a75L6bMn06ZpuqcPx+blVfvxX9w/oVFZ3ysmDGrtjt8nl8artPWu6z9btuP4t0TrqLkW2+S9FJi3mkXsguiMp9+6lSMprMU1NCVgcj2rPZsjoh0CUGjTSmIqLbMOqV4bNS6R8SCYtG3vGolLaYSBITgijUaeAyckzRYYG72qiKi4riM2AxR08OXLnMk1j3D2XHx+o6h8H/riIXJBCtfwCEmn4P4vItxyoK38m8JeBPysiv0hVv/eeZv8AKf/iLxORPwb8chLJ+OeP9P89wPeIyAz4qcDPJYVN/fMi8pPG8C5XY/FjKsc3Tu+e4/8RUAE/U1U/v39CRH4biag8hsciYo+Qlc/G1+u9Y9P7c1W9efshg55ci0844YQTTjjhGxbGJHVjhJ3/nygOkoOfktaopJW+6m17YD8ij7V2S1b6GPBhIMQAI6lhrcW4cd0fIt5HTGaxRokxEnwkhJSf0hiDkSLl1VMlxJjCv6oSo9L3Azrm1lOJhOjpfYeGlCIlswVVVSJiGPyAti1RA1YFEYdRS1RlaFri4KnqMRxs5ijKivMzz3q14f33vsJytaIKJWikKktqa1mupkj/AYyymJ9xNp/Tdx191xJCsmhVI+tmhXGC9xGxlqwoGeixGhGxlGVNUVf07cBm2QAejQND55lVOVJGbq49m5uGWPbUdUZelOAKfOe5WXtWm1eAT+SvzXn0+Jwn7xhWyyWGjKZtyUtHFxw6RIwmUig6oR2SYaMRbq5f8+TpQx49PsP7Du8zeh8py5yb69c8ePgUMYYnT9/h8sULvv/7v59v+uZvhgBd31EVDmcdLs8QCXzqU09YL1/jjBD9QGEzcgeZE6zJKfIcVSHPCooyp+s7Bu/p+x4NSW03P5tzsXiQQrWanqrIeHo+5yd+9hkvXr7k6cMaj+fl1YZnT58SdWDTr8iHBXmZU2YZn333KcPDmqrMeXXTsGxajLEE1aTAfPmaJ4+fYh4WrLxyMwR+zKxGNIVRLfIKYxyr5ZIwBDbtwKZNxF8foJwtEJOz2vRI3jM/v8BkJVleUJYpvG1VV1hS7kpjIWgi3R0mhV01lmoxp6gruq6lKixlOSNrWsRm5OWMV69fc3X5CugRUUJ0BOI2U4tzjqDJJtaoDN7jvSd6n9TK43fWTkrCMcSzmAyxDowDmyMufRZjUwhelRRONipRIca934vIdq9gi220q9HSHiMo7ZyeR+eHW1sJYbThzV65cV9va/OmPTMz7RttU9Ts9pImwWWcQuJuRwHWGMKYambqP4WdHfegTlbPNxomu/ede84fOz7Zzd+qqn//Q/Z3eoJOOOGEE76B8TUoKs3B57s5FN+Yv+0Wh5WWNX23wUoGfk1WPMUHj9eMPEQG2rTYz3NsMcMMHUELnMuJIsjsU4TVF7D5u1AUSDCY7ByVCJtrDLpHisjdcenu80cN95nII5BJUSZ768IDpd10vXak6e74/pa17p88hNymGI+O+4Cvu6PKO/h//lDtd5uAvD2YY8R0mmcqpyoH5YGtp/D0vIQ79Xck+D4puVP27drZb/vQ83jfI3n/vh4SmHfJxDfd/zcpJA/v8Zug23p7zPaWHBwNB/YUk3fI5y3teFydO4WE2is3PZvKjmRL52X/Uqa6t6apJA/NeIes3FcYMo147GNLouuxqw5vVGjGNODUhCLRIKVl5geebwYKWgosAYOq5cYvyHQFIjgCQ3aOmJyrQclNTh2WtBi8VEQ1BAKemsJ09L4HWxKtkvVLyKrk3C4kL9PpErBHqu+RlB/XEDaqegV8L/C9kn7QfyVJQfmn98r8fRH5DpIK8X8UkV+iqn/mSHN/DPhdJCVlS1JE/t571IhT22uSyvGvisgl8J8AP4cU3uVvk56CbxeR2YcM/3oMPwZ4fUhSjviON9RzJDL3fzk4/rnx9f/aO/a3gG8DfgbwPR9plCeccMIJJ5xwwjccjLHEMbeciYCZnAdlux5WBIlJbamYUXGZyMVECOzIByTlnTQoRAg+jHkg05LdWQNqJl9FjJFRMWnpB4+O4VexlhhTXjzd5uCLuKwA4+hDxCIggjWGvhvomg6xKUemMQOdPlvEAAAgAElEQVR5nmONpawK+qGgaTts5jBG6IceNBIl5e7LoxJUUB9wmaUoMjK3oCg+zc31NX3bs+lbhrDBGqXrW6wIi1lBWVUUZZHUnb5ntexAwVqHkMidtmnp2h4EyrJCxLBZt9xcr6jrktm8pCwsQg5rT/QWHzxd36U0EQh9P3C93nDhSy7OlMX5gpkaLq/WXF6t6HpPlhva8JrL6zWPHj1k3Qqvr5dUmaPODYtckLqkD4b3X12y6pSsLIlhoKwr2nbDajWF/cwpq4zQeM4WZ1xdXfHw0WOquqLIc9DIP/mBHyDGyCzPsUZG8k8QY2jaDZUTeiLq1yxmjptVQz9EvB+QzGCN8uL955RFRe4Mzgk+epqmQRUyV1DmNdZZ+t7jo2KcI8SeTzx7wnJ5Q1bWfOX5K+bnj3l9teT8TPF9T9O21PM51hqePX3MzXXOey9f8f+z966hum1pftfvGZd5e9912XufU6eqTp2q7k7TiEpQiYIhiR3xLvGLgSgiNBpFUUFQ0G9+ycUPgQSVGAkYPxjRaBBiIBGJhGAgEWIUjS1Jp63qruvZe93fy5xzXB4/jDnfy1prX7qqpbqq3v9h7bXeOcccc4zxjjnPeMb/+T/Pt1+/oWs9L85avKtZPWzompqzRU1UZTsEFu2CtmpZP/SEZFieK2IyMYx4a2nrBqPKy4tzEEsSg28b2ESquqWqasY4UqcaX3ts5fCVBc2oVTIZYw3GWpyvy96EGpZdBymRc8KYktvU1x3t4oyYEuv7NxgCKUMi0wgYmcIlW4uoYk15ftUJjDoppgVTpKyQ9zGOZuKyPEqCGFcISlchziHWgBFSVGKCGJUUE5pnZWZRQ6uZnYKLvV4Iw9nmP9w5ON4nkHl/RWTKR1v2SPSIYJyMXy1OCbMHvk4Ox3l6Xe1SAem0J1Eag2DYh3tVBFvITIGsU3ViSojrH5VQRD+5mO13+4HlZ3v4tz0+Me0x/NZnrvkrwD9LsZt/rUTlCSeccMIJP8Z4Pr7hB+D7XWDsrps5o9kdS0qidSNnWG/IeSCp4sRijMHXF0h7hhnuqdsl7qOfpXr1VWJ/hfU1xnnc2dfQ4R5LhThTwmmILTk7dqSQHJGq89/vUk2+72dXdvrPzKTTjqh7SlC+rf7HYyvTgpDDnye1vm/Q31VYduq8Z52THt33vbc6ars56JuyV0NOXnhPyMV5PMyu3J5kPDxnjkm+97eK5wbgue/iQ/G2OfPWufHcvJF31LN/QB61X5hJ2nks9j9TmUfk977OR84Fhx8OFJUqh9fr4wLljJidQfLs6YOzCsXImebRLgzsO8ZfJwJ1rjabDEH4/DYixhJyxWAWRNOSpGZUi3GKxAeSeLDVNK89oxrW5hJMR5tXeL0nJkAjG7ukljU2B7wpczIbu6OMn3P5/FE2rkTkd8rzHfjC9Hvz+ISq/iKFwPwe8N+KyO95pswd8F9RclT8PoqB88efuf/vEJHnHGRmT8vNVN9r4L+m5JL8Q/LIM0ZEliJywYfj68BLEfnNj+r5l4F//D3X/kER2YWFFZGXFIUmwJ84KPefAAH4wyLyOA8HIlKJyG//NbT5hBNOOOGEE074scB+/W9MIU6MMYV0sgbjDNZarHPlt3U4a4s60hrMZDfkKUdlzhmdV8oaEYkYo1grGDFogpSElJgcR81Up6PyFU1TQpt2XUPT1tR1VVKkCDhX0TQNdd3g64asEEIkjONk3hYnUNVC6q1WDzys7tCcqLxjUTcsmoam8jS+whqovMd7x3a74frqNTc3V1xfv+H1m8/51ne+xfXtDb6u+PiLH/FTX/uMs+USTdD4Buc8QxgJY8/D7Q39do2gVJUjpR7VgZwz4xjZ9gEjFm8rUox4J7z6+IJPP/uErqtZrzd8/vqWq+s1d3c9237EWk9Mln5QLs/P+OSjJV3tGfrM7V3g9feuyTHy5S++4md/01f5mZ/5lMvzJW3Vshngl/7f73B1tebuPvKNb9/znasNagzGBs6Xhp/+2hdYLlpef/45i7ZlsVgyjsrDw0AYIjklRAwXly/wVc1ms+H+7oauqajrisvLS7xz3N/eIsByuaRbnAGGHALb+1u2mxUpBXLMnLUdtTVojCyaikVjGMPIZrvC2cz5sqPrGnIuisqsCRHFWXh4uCOlyDiM+LoQvVaU864DLNttJI+ZfjswjpG71QPjsKHxkMYe8RW5avnFr3+bv/WNzwkBzrslTmHZVHztpz5FPWw2G7YPK86XZ2z7AV/XiGbGcWQcR4ZxpKorLs47Pv34kk8uOl4sLMvO0S5aFi/OuXjxgrppsMZhjUOzkGKi8p6mbqf5b2jaBd3iDOsaYrJU1Rlde8bqYQUIMWVCgkV3zouLS7b9A8YozhpCKOrZeR8iTxJHcYLzHuc9xji8cThrqCqLrzyuqnFVg3E1WRxJDTqRk8Z5rCtqSmMdxhZVZRYImhlTZhgjYUykmJEMpngvUBJXZjQlNE+hh/TQFj90bDaYyRpXU2xwoZDbiJk8GKbjIuiUKqmEJpvfV1O5aU/n6PhBuXkXzMwRzMRM+0C2EJbTOw8RnBjch+9infDDwQ1lRn31A8v/ZeBvA79TRP7JR+f+VZ7mp4RiQ98C/4GI/AOPT4qIEZGf/+AWn3DCCSec8GODHyD06/s37B+fPyLidC+qLFaPxTIQpMK2F0h1iYkj2l6S2wtyiMjmW5juI9QuC4FgFvhLT7j7Nn75CWIasvPksIGqIctknOl+oSVMoSfeQUy+qz/HIR/3x4t3mezC7shMVu7KmOeveTZkKQfn9oSc7Cv+NS3v9r51B4rAydttvhfMhuw7rpenQWKftv9toTDl0d/PqwFnFebx+JU69fECfFdGp+sOewrzpsC+7ufu9w5F6VvOvy/M6/uOvU99Vy45ksFOlJ3hQKi485J+Wx+Kt+PhOM9jmw/qndtE8dacibnpQZke1QPSHWTyKC2E5K5Xu6/+yQw4KDd7WR5Mgbe+J3bemgJGiwdmtI5GlGAamMhMgIqMtwZTnVGZnl6WE8c4IkBCQSxZLrEm4NMbNCcyFVkukPGG2/ASgyHkWOy34qe+b8vUx72zhUzesz9S5OV/D6xE5K9QyDuheDL+/cBfo4R5fQJV/aWJZPufgT8pIvUUQvYQfxT4vZRwrf+Dqn7zmar+I+BTEfnL0/1HigrxHwa+QSEnZ/ybwN8N/GvAz4vI/ziV/2kKufjPAH/xA/v9R6Zr/hcR+VOUcDO/heL5+d8Bv/st132Hkrvy/xKRPwP4qeyXgD+qqn9pLqiq/4+I/EvAfw78DRH588DfnK75KmWcXwN/xwe2+YQTTjjhhBNO+DHA7PM5K7rmCDQZs1NU7taS8+fd6nNa/x9EIskpk2Iix6KMEhRjDGIt1hZ6IoV04PQnIA4RizMZXxXiwTmPqzzWFKrBYjFid0SEtRZnfcl7mRxQ1HxihJAycegZxpGcMtZWKIKrK2zlEKGQNt6WsLIx0Q/bctx5rLWEEBkZWK/XxGGD6JLF2ZLLl+ecny9IOU4EqEdTYgyRoe8JccDbirPzBdYIlW9wvtnZPtvNmpACfeip65auaVksOprGsm4GttswkboZb4WuqdhsEpsIuJrLl5b7hy3rIdB64fb2lm2/5fzyBednLV1XAZaqbthuRl5/foOI50ZXfPd6TVLHi6UjpzfYquZLX/wYb5UYIwZPVTU8bEZevXpVyOecaZyjazvu7+64fvMGX3kuLl9QeUfT1IVAHLfUtcdZi1HQnFivV1jnWG8Cm1XPcrGkdgbfVRjNxJCpGnh5uSCngBVFNDH0W+q6JoSe5bIljD2bzYrl4oyu61AMOWZSGHl53pFdha8a7m6v6NqWu9tb3ry+5qzxGGOo6rYQcmzYbEdinBxVfVHQLi/OqJuG4eqWnIudtexaxhjxlaNr2xIJKWshuSycdTXjxTnD+oGF91TOMwyRulnQdQucc2XrxRg22w1GpIxVCOQcgIqm7bDOE3OgWyy5vDhns90wjj3LZcM4JqJaXpyfk2OAFKhrz6gZK4p3npgywzgW29kYKutBimLQ2qIOFirIhqRFEUkqksOikhYwBuM8MhGTxnrEFeJSjCWmxJgSIUZCisSUyCkjmsvzn9nlrpViHIOxzKGLik6S6c2x3xso+WmFmesEg5H53TJdNYV21d1+wRxRaL8HVfauyntovp+xZlKLTqa9TFfqRG4ebTsdRN36kTGbfzKhqisR+avAbxeRP0mxZxPwZ95SPovI7wX+PCVdzJ+mEJe/GfhHgT9HiZqUD665EpHfTdmb+Csi8heAv0GZWp8B/yAlj2Xz/08vTzjhhBNO+I2KH4iofA7HxNBMZjyzGpGZNin/aB4RMeSkGGkw3QXy+uuYpSP3PTJ8F7P8ChiHoqjMXmKO6vwzhvtvUi0+pl5+Qrj5Faz/KkaKB1kJQ2EP6L49efO2cJ1Hgr1D1dcBkVj6uCfMjOyJk6dknew7u6NyhOf5jT3bc2Cz7v+Qg2Tl78BxmSkr5ZMbHpAvcty3+X6P6b+jlr6VoHk0D/bf9qPzhySbHv8p+4Xzcz16dox3bRIgH5B4M2n5HPH4uB3H5/d9eDup9rZjz4aKffRpDsW6K38wNPLMVXrwb7nfwdE57Oo8MXfPnznog9kZOkejf9CwJzP+iB2lGF561Ir91Hr+cS/P2o5snrOk7ms45KF338nuvhkVj8kDJieUqjzXCioJm/sSlEYdyZ/TxFt69xIhotlhJKJZUFFUPN3FBf5hTY43oB5XVfjxioEt5ITaBkhPpsUTInvf2B8V/PsUwu7vA/4pSpjWbwD/HvCfqmp424Wq+g0R+R2UMLB/YiIr//jB+b8uIv878PcA/9lbqvkDlJyYvwX4RygGy69Mx/+Iqt4c1HcjIr8V+LeB30PxyEzAr1LIwP/7Qzutqn9eRH4XRQn5e6Z6/ldKDs6f4e1E5Ti18w8A/xzwEfDLwH8I/MfP3Oe/FJH/A/h3prr/MWANfJtCiP43H9rmE0444YQTTjjhxwNHDphSbBRUMYfrczhyiJNpPT8JIpGcMWKwU5CJnBMhDoQQ0VzyYKqxWGNx1mC9QXOJ4KdiCvEhqeSHrAvZ6KzHew+kUjeOqirEZFRFtISYdcbSVDXDMBLHQKZEOKm8o6krCoHpGENANWMNRelmLdgS4lTV0CxKuM2cEqqJEO4gR9rG0TQNiOHN9TUpJZbdAmsd/dCTFGrv6BYLjDWsVivISuUdOY2gijNCyop1Duk6QgokgX7b06+3OGvxrpCaiit7DkS62qK14ey8ARGSZnLMuKrl88+vCUNk2VU4sdzfPmBdhbWOpnWICnVd83N/18/RjyO3V1d845d/lfvNhhQraivkzRbDDR99/DGb7ZrtektKmW0fuL2/52y54P7mhto3tI0np8g49tzeXPHyxUtSVi5fXOKdAUk0dUUcI2oE7wsZFIaAaEYkYUyg6ypSdMW5NCecsQwxlb2KrLx5fcWLjz6hrtvJFs7c3NzRLBecLc8IIbLtNzhvWV6cl2g26vnOdz5n2G6pjDCEQE6ZkA1Vs8R5x+vPPyfnTNdW3K/WaMo46/DLBc57UsrUdU2OmRBGaufJVgkh0L16RcyZmBMhDKRxwKiSYmTVD3zxRYtGIY2Zs4sGay1JJ9s5jozDFu8tULMNA1YSSkJE6PseFeXyoiLnwGZ1hzGZECNg6NoFVoS+36CqVN6TY6RtarIIwzgSYy7co3F4VyGiGCa1pXNY41E15JAwGovzb1YMDsmKsQbrK4xziLPlx5b9qZAiY0wMw7h7xrTIoUuI1lye95wzs7pTVMhKyfsoszMwRSWpx/sLs5Fd7PHyDjKUVCiCIrvcl3tjfrd/J1PY2+nvUrPu2qC7PYBZeQqiQpJi5M3VighynD7zhN/Y+BeBPwz8E8A/T/navklxNH4CVf2LUtLF/D7gn54O/1WKPfwvTJ/vH13zF6ZoR/8uZX/it1Ns729TnKP/NCeccMIJJ/zE4deVqDxUTOpsWLFfsOw+H/JN0+8Q1tSuou+31M0LYkyk+gxW38I3S8zZzyCmEB05SwkfgZYuGGhefEa8/zaSz/Ddx4TNdzHLT2G4pdIHDFsS3TsVbkeKz51f2iFpd7jA2/fteAz2EQpnrm26lHmBmEUOIko+s1SbXNP2xI8cGK/HN33bQk91TwMJxUOutGdW57FfOT7CoWqwLEKPx+fdikB5Uu7tY36oKp0/zx3dL6T3g/J2UvSxgvXw3P76x8fn7xsKqcmzZT8k/+CvSVH3uKwenjowEHak3WGB+dhRhRz3U6aJNzOJjwnoQ/J2JkfnY/twroX4e9zUqc6DuoqaWJ+M8BOS7/GpHYnKpEzU3cn5OSs2l2DEgaTJCBtRWZbQU2IwIWD0muRbsm6IUmFcpIoroiubDjqHC5aEVcgjhJwQ05RwNDoixtCHBD4grp17t2/743kNWJGn/f4NDFX9Y8Af+4ByP/+W49/iLYpAETmj5IL8FYrn5HPX/yngT31gc+c8lr9/+nlXuV8AfuE9Zf4s8GefOfWXgP/iHdfdAf/G9PNeqOr/+b62HJT9+Q8pd8IJJ5xwwgkn/OjCmD0huXOSFbNz5JuPyX4pPDnkpYmwLCFds+SyfjZSCApVQhgYhp4wBiRHjJQchN5VIAnVkucy5ISxDls5rDM4N4WfdQ7najRnDAZjDWIsXiwGIYZI1kTKYcpzKWz6onQ8OzsvYWONIeayko8hYq3F++JcnOLAGHqqqsE7xxgSY+hZrR4IIaDW07ZLnHWEMeBNi0kDN5+/oe0q6rpGU2QbI8krbddwfn4OWpSZYRy4u7lm2w8lpK7zWONwfg4/O7Jdr4lhZLseEdmiahjGgRBGUluDyWzWW6qq4gsfvaB7UVNVBudhsx6ou5qzsyWoZYyRfjuw2m7BZHxVEceej199xFnX0dYN3/zWd3h4WO0UszEM3N1eYaqKIUFdV/z0qxc8bB4Yh5HteoP3no8+/piL85b1es1ms2IYNogazpfnjGHA2QrvazT2WGOovaPyls12RVsZvG3ZrB94cXlOCgHNka5Z0BjL1WbDxcuXiBiWyzNevnwJarDWcPXmmr4fqRdniPEMw4Y+DDTLM/qtJ6wTX//WFd99s8LkSNe0DGOPqx1VXYjoYRi5ubnm7OKCy4sFfb9l0VZ0bYNzlnEYMcayaDvi+oG2MoRhRW1rNCWqqkLHwHbTs1k/8LBa890313z76jVdbTAmYiTiLdTekFLAugoM9H3Pw2qN5swQI+MYccbz0N8xRqVrl6COyrc8PNzx8HBDxqL01E3NxZkjxYGUYskxqQYxBjXFzrO2kKxDSLRa7OGcYyG7TVEla4aUMpIzohaby3MXKftXMjkSYC2FyReyUJSUIbEZR/o+MgyRFBIpJEpm2qIyVVXIuWwTTU7Ds7PDniGc3iGad/s8OueyNPM1Ewk5k4dMykc9MMCn9w9CcfJVMzn7zm+0AyJzxzxO5ec/d21hUloWAYEKfMDWygk/ZKjqLwG/6y2nn934UtW/SlFQHhcW+UMUJ+G/9cw1X6dEUfqQNv0CH2hjn3DCCSec8KOL75uofKxGPCSl9qqw/f/DDtVaO5HcbjFjsP0txo6kMCDnS+KwgTSWUDT+HGOVMQTQgHNN8RbLh6ErDdXZ14ibbxONYvHk8QGkYYyGNjuy25NjM4ty7D12yCEdhHM9Ojfn3TtUtD1PUj1Ob3fIzb6T1pL94vAxoXusYXt676Pv4aAN8kid9xwJNpOEh99r8dx7nnh8fwjTt4dJPerscQeZSeJD0k7VIEcM9+P+PrfolYPjh+Tz4/vty+7vV9ox//5+Q3u+L5Ts91vH21SbT0MGl0l0/F1MCmPNu7F5Tln6ru+5EIiP585zLOph+JmpTfMzNxl68zyeN2v2/PxBH8nTRk1CpYS5ETyqa0zcULULsqnIaY0iBFlS2ztyHMmume6dkOxIkrgaOhY2ErUli6c3mTatsGIZY49rztDJkDt+4vLeEWM3uidM+NeBJfD7dJbsnnDCCSeccMIJJ5ywwxObQh6veSdCsyyQJ2ff2S5VshZF4pyrMqVMiEWpaAFjtRCVlQCWlAq5UdctXdtQtw1OzLQcn8JSTqq6kAIIVK5CsIxhS4ihrNFzyaVorKGuPYoh5oQJATCkXALNVlWFMWWdH2Nktb6n73vOz19gnSdlsNZxeXmGd66oF70nhshYRWJO9H3F3WrD+mbD8kz4ypdLnkdLRVV5sgQe7u9JGksOT+tA4PzyJVXXYYwr5E5KrMceIdI0hrauy4CrIeO5v98y9D0X5xXLV5cYZ0AiQ3A0TYuKIWdDv40IkU++9IoXTc0wDNzf35LjyLAZ2a4jvvEsl+d89rWv0tQV3/vud+i3W2Lfc7GssM5yt9oyDBFRWOSan/7sKwzDwMNqzdXrG7rFkuX5Oev1ln4zsl0PtG1RPYoYQsg0jce6SMojYh1ihW3YTgpaISQBsSCJcQy0rWGIgU3fc2kdrrJUriGMI2fnZ4RxJGWl7RY45zHOUrctIUcq35CT4F3PzfUNq/UKY5T1WGHyyBc+esVnn34R5wwP6xHvKuqqxWBLiFtfY41lCIkQRirvaCtLa4Sf/vIXuLm9Q0m4yuN8RRgTw2bL+mHN1dU1335zw839hvZFhxeHFYuvarB+Uj46xjFwd7/mYbXBmsyQEuPQoylz/bDmIma6tqVuWoZh4O7ulm0/ULUtUTPndYMlkzWgKNZUxWE+JYYQ8L4ohrfDQK1KzmVcrfN460AEp5CTIhiyVYQMOZNDUUWaKYyysQYz5XbMCpoy4xjox8h2SGz6wDjE8jyrojnDVJdmJcc4EX6U0K+TQnZHVBpB895pPOWEMXtScXa8nanIsjNSlNqFSiyOEPNWwmG6k9mmLzb7TIAaxKRpY2DacygvMTBTPk8AKXOzRDnLP1JOvid8GESkAypVvX10/BeA3wr8uckB+YQTTjjhhBPeiV+3HJXPETnmneTO3gtLKRp/R4vqlhjXaH+Fr5fY868Q778F8hVcTqjrsNKSczoSpgkQybjFl0n95yXUR/85qfkCWS3RVsis/lKdVFryTHv2fTkMsKpM4St2Px9AT8gxXTTj8PMhGaSThOw55duht9rzRM7+2JOchTtqVXZtOr5qX1dK6eDzwaL2oPS7lJIfiufmziGRNhNZM9Naipjvn+jT+Xv8MOJ0JjhLPsa3t33G29r1IWP1g5CZz5OI0/et5vgZOZhXpW+P86YecozPt+FI8Vm2S+CRcnNq2P7QETcsO0cFnVwsy/OgO6/LZ/tpLWd1YMsdkReoCCYHpL+D7ovkfE2yHoci03c9yiWNuWFICqYjSSYZxe4albCaSZIQtQzRY51FQkDnUDYcPFM7B4y8G4GfdIjIBYWg/BT4Vyg5Hf/oD7VRJ5xwwgknnHDCCb+BsIsqxKFD4WMnSnZrZaAke1ODmCKQQjJZtRAYZHKKpBxQIlkLgVE5R+Ud1luMcYhkvFXQTFLFuqKgc6YQGwJoUuIY6IctaEKkpakbRDK9ZmIoBKjmiAqEwjRS+Yo5n3sYR1abLSqK81XxJ86JnJUYE2dnl1xeXuKsL33ImSyZ7XrL6zfXbLcrmrri8sU5Te0wInzl048QTajCGAbe3AyYlHHGklDGSYVnraU5vyAjDGpxahDNKIqxluX5S9pFRw49282KlDLOV3jveFVXpLDg5uaaMQW6boFuIykFvHPEmLi/2dL3W9arDf0YOH/xkq989hn18oKbN1ekGAmbDV//+q9ycXbBJx9/EVu1+NpSVRUbH1mPI196+THdIhCzsu0zq3VPTpHPPvuMh/WWq+s7rt5c0y4WXL78mNu7e/pxxNcNTdMiBkLqyXmJsRYViyHhBCoESiBS+kFJKnRtgzGQ8ogJijcGL0oMCW8ytfegnqSKkrCVZdk1CIr1Dl/V1M2IaibGgcokalNIraGPWFWcqbDWl7yKIdItFlTNgmEYOG8d3ivZGL75q6+pvWG5EHyVGdKWxcU5r2/uOVu0tLVDdURNpmor1t/ecn2/YhsyYSIAK29pFjVVV5PTgKHGCsQYaNqKtvagEXIixsgmJK4eNti6I46Zs7Oa9fqOoX/AOdAku+vGGEgqGFeTciamkt+1cg3iHLfXt4zbnupcCcMGZwzOezB2CsuqiBWMyTgVgpZwtikVZaMaR7YeZx3YEnY5p0jIsOnD9JNKvswQ0TxOr4aSTxRVckxoDCgGjCDOkEnFGd0aIiATaWlMUUnaaT9FSBg15Q0ks9OwYnR+D5Qnee/AvN8zMbv9IMWiJaTtpOJMqohMUc4mrlTzvN9kdu8zM21AzXtwJ6LyxxJfBf66iPxPwC9R9pn/XuC3AbeUtCgnnHDCCSec8F78uoV+fUrE7EmuSce4W6DsbbBZTaVUeSDnFS6PeH2gNw5TddjcI4svEdavqV79DEaFLLEsih6RNBYli2Daj2G8Z7y7JcfvTZ5fB6TjAdnynk4deIw95VCeVQzKUSCMZ/C8YkxmT9mjJh0TqXue6anC76ikyO7mumv4vOg8btixMm9PUM6/dwTNMzhUW36/eCeRtzuk+7Y8LvIOwvNYTcm0aH6unnmTQB793tf73jC2ZQehhHV5pHB8W3ufhIA6OPaheBvJqY++47fXezxbDxWZIo/bti83/9o918xk8Dx2GXb5LKbnT/cbNUec9NHnY/pvDjUrOfEQPJlMpMZoJg13uOZjhMCQDd54KsdkAJVQOYNc0OgNm+zBGKyaEnqZjEoF5HK/8ECOkcWrT4lX30ElItnMDPkjxenTefITbHC9AP4gMAB/Dfi3VPXhh9ukE0444YQTTjjhhN84kGfNKaVECDm2DZ5zcrVSUodYY8jGYEQwha/AGUPlPUYU74ujsKZM1IBzhrqtsUaIMQGC5kRUu7OLckqEcYSUEI2kGHfpjukAACAASURBVNhsNohYIqnkq0yKtQbvPXkYSZqL7SNKVXmcr6nqCmsMijKOA1ktmjPSdSiG1WZNypOKS0t6CU2F+NKsXL+55ubNDcZZKm9YdjVt7ejaBhXhYb0iDhEU6rrGeYM3Stt4mqrFWEfOSo4DSSMpK03VUFU12bS8vrnn9mZdws0KdGcdTe2pfc3Fi08Yk2KMxVUWK7YI2VIiq+Xm+grrHHVTU3nLtt+wXJ7zxS9/GTKsH1Zsx5HNZsPN3T3dwuFdzeqhp26XvP7eNfFXPudLn5xTt1UZK1sRYuTzq9dcXLzk0698ysPDmr4f6ab8nOv1mq7rsMbSNh1XN2vGYYtzBiNF3Vd7h7OW+9UacYvivB0SWrVUFRjJpDjSthXOCkKiaRzOWdqmQvuhhPp1FSjklLHicM6DCpXxpHEAEbqmobKm2EyLhhgC64cNTb0mx0Bb15gc+PIXXnF9dY2q8rB+4Obuiq99+kVqD2gstKrzjGOAzrNoWiRD5Su6RhnDQIoREwOtUS47z1lb0zhL4y3DEPHOYSiEubWOVdfhjGG1XvFwd0+MAUtCVLGuYhh61uv7yewXxthTVy+I44CrSghZby157DFiadsFziYethuyJozAGDJjyFgXsS6TcyBrxjmLiEWkpBrRPDkUiBSHA1P2CMQISDkXYqIfE5ttYNtH+n4khqKcNJTfTE4JQlEH5xyKI7IKgithmmebfVZVSlFJHjk5GCHPDriH7yWZycTD99DU7sP3le73HATZnTdiEKOo7msWc2Dw7+6YAVOcpE0uuSpP+HHD94A/CfxDlLyUNfBd4E8Av19V//YPsW0nnHDCCSf8COHXlaicyRBjzNH2/XNk0rz+kQwJhbgi7srUSLxBMqip0axI3pJXr7HLjzBqyDPBsLt3xhhDyQRgkOqc+tKw+tb/tvPemhdg5miJtheDyeEiTObQtvty5uCasqbT489Scg3IJDDbRcuY7zHdyOwueGYcDxaJj0mtOWff/PmJonIWfBX2dzqmx2Xmvu7vcnTWiDtQZ7LzlN31/1G736ck/NBz7yLSyrm9nvX5UKf7PuzrfBTOVB9L9p5+1h2ze/gjR2Td4ZyYidwSDsnuyN5fC+H4PrXlE4Xs90FqPg79uu/32wjYxxaEKaFajm45GR9PxtVMz9NkWO0mpe7z0wrHde3C0OhjLnS6VNBkqK1nkAoz3CD1CzAOx4ogNVkNzloCxdNTNKEYentJHW9Yc4EzguTi3ZrVYCUx9D2ae9ziFaoJhxCill2heZTmxuqjHLQ/4erKKa/Ej2XnVfWnfthtOOGEE0444YQTfrxQQrhOEUneVgbKQnlaS88EhBEz/YA1Zd3rrdDUNVJ5KpsxkijpwIraydoa5y3OxSl6jyGmEoozhUhOgZQCkgsZ4xVSDIQ0gCm5LlWUpBmHwfmaPGwhMxFupoS9FMV7hxglhpGH+xV9PzLGjBhDVVeTUo2dWmvsR9YPa6yANw4rhsobmolUyykwBkdVN3TdGdV5yRVoxOArT7foWHQdookQBrbbDcPQkzPUVYOmxGa95vrqitubW3JKKEq3WNB15ztlXNVWnBmPGMsQR4z1pBAY12vqbsEnXctq/cBms0Uls+3X3LgrlheXdF1HH0bG0LPdrvje3Q3nywajhtvbHhVIUehz4PWbO4zA2fkLRDx+ym24Wm84W3oWi5a6qUhZuby84PXrzxnHHu86mqaj9i3bzZpF2+BcMahyVirnSX2PVErdQN9vGPsty7MGo3HKc3mGNQ6xlqb2VL6QfJvtmrOuw3tLyhGTC9mWw4Bopm7L/BnGLWfLJU4jkoSPL8949fICizIOW4xRaudLaFPgdr3hy59+xPXrz9GwxVhhHEcsma5bEJOnqRqcMTR1hQFaXxd6I0QuFg0Pm5HAwMJDUxvQoiCsq5qq8qScS/5IHbDW4pxDjMMYi6Qtl23FsmvxvuLu9oZ+80DbNfTDyHK5JOfA/cOGjz/6AtY4+mGLs4ZFc4amzEBANRGHmlWIGGNJWemHAZn66b0vxLEp+w5zVB5jXJnpqogtpGEmk1MhwMchsR0DfZ8YhlBywaZiB+fyz+TLoCiKpozGSSmshmkHDZXJGjUCxuwc1lX2dv/eVJf9jxza/2U/o0RbyiWiFPP5fS7d3YaTTkf1YL9MJ0LygKM8CiGrpQ6jP5Zm4088VPUG+L0/7HaccMIJJ5zwo48fKEfl8ycOf7+DgCkR9suiKo2s1iO1z1Tek1NPEkVcjeY1rjqH/BE5biFlvHPsolbM9RlDVjAUD9FsINgaXIMZtpOH23EzdSJLd8Tlo+YekpYfgiPeZTqwzxX5mGwyT4jQw/x8PLrnnMNPpnGdidC52ueGeyZP9yEr2efNnAzeQqruySrB7Cs9rPuwl4/dfJ/BD6q0PEbJT6n6/PfxLmLwaS7VmYCbF+r7PJRz+X19ulMVlmuZ5pHurisqWMWYEnQn6778W/O3HrTt8PxzfXtX/96dQ/Ld9byfHJ2IRZEn4zPjqN1zCNdd3onJIjoibsuEm42V/fw9NIYmI0d31ObuHlkSxiiMd+TqAuMcOQuWgd5cYslUztIP1/jqFSrF41MRkj1nmR4Y5YLsLCQlG0fcXFNnIbdfQFUJaqgqGHLA2v3r8fE84ui54RHresIJJ5xwwgknnHDCCc9DDmzPwwgrO8wRbaZQr+S8W1MbWwhKawzOWJzzqPdIjhOhkDAiVJWlaVrqqsZZi6ol5RICljGSxpEYRlIYSZpQVZw4MJGqEpwYqrqEkY0pMwyZMPagRdlpjBBjZAgJFDZ9T+g6nPfcbrbcPKxKmFgtKj2z6UFguVhQe0/Mgc04kONA01acny0QA672dO2CnDJowmLJUUk5sx17coyoZPJDot92PFiz67MYyzgW0ieMIzEr/Rjpt1ucNyxedCwXHW23wNY1la3xrsZVFSKFxEtZ2QwDtzd3RDWocWy2G7Z9xuAYe4WUCGaNbxyVV5atpfINlTN4b1ndrUAji2XHzc0DqDLmSMJR1x1XV9e8eHkJWnN+fk7KsFrdlLC5pqaqGqx1VFVNCBHvEyEONE3N+mFFiBkjDohYJ2yHDTknwvaeF5cvuLq6JYyBi4svownq2tN0DVVjqZuGpqloao9qKnkj6+Lw2Q8DddUSQyCOPdaV/YKUEhojZ4uO1eqGbQh8sa0Jmhjilip5mqalqmrWw8j1wx117ambJV//5W9gRLi5usVoYtk1vHj5iu16Q+Mdl8sWa4rl6LzH9GsWraVbnHF9c4/WjoWzhJiJCVJSfOOx1jNGJcRISpmmaaiqipQz/UMLY0/tHBfnZwzjlvXdNUpiHItD7fmyY3V/i7GWcezJwBgSi/MllfeMw4jzCTtGNA603ZKubQhhRFPEoHjvEV9yZwpFGSzY8t1Yg0qc1M8GJRNjJKoyhswwRrZDph8yYYzkrCWMbMpTEN8pslfKaM7EmMhJS0RonaMWKZIn1aWY/XsDdqb4vBfFoz2AJ/sCZn4vCXmnkJRdVYeO2/v9qoNNIXm8xzJvNx0Qo0dqyxNOOOGEE0444YSn+IEVlY/JvJn8Ozz2mNjSyegyRiYPsRFnBFVDVdUYGeicYLbfQP3HJHtO0p7q4muM97+CvfwpjOxJjJlYkSmuTgoDefs9/HCF6Tq2cSz5KPerqoMOTL9mL7PDUyK7haAWneaTfutxNbsjOyJxPidwrMmc63g3SfUEB7Ez867GA2+4x22aGqITmSJm/oLmsgcL1Pn4bhjkoMTRLZhjysqjMdsVewdx87Z+Hi6in5Y/HqsPuc98/vh2j+89h9R9rk2Hx/YEW0myOJOYsiOqFN3Vtcs5+gH4kByVbyMInyv3NmL014b9nBLZE7XPlYA572SZ7eWp3j9YTxSwHM+v2YTJhzN3Mnxmgr+8VywxJLJ6rG/2xKEmjDo+WfZc9wZJHuI9mgNqQOySbCqiW2DiipgXWGDcXHPegKs/4mabS85LQFxDGgZc1TF3/PEoyuPpeLK5TjjhhBNOOOGEE054Bodr4d3fIjA5UD5er8/EQGbvPFkuEYyYQmL5mlBVOFeBL+RJsVNKLjrrPLV3VK7kiwwhTHZtCSMZQyCGkZxHjLFYXyFZ6IeBcRwxRmhiRVXVtG2Lb1tCiKCGpCVXZQg9KQ4IwhgUVwlt2/LqsuLF+UcAjGPg+vqafhwYQ+Lbr6/p+wErSuMrrPHkLBjrWS46uqbB1y2qEDWVcKzO8bC64/7mntX9mmEY8LVlHGIhvi5e0HQtzlekHBmH9eRh6sliQSGFkfXqgXFUkEjrOmzT4qqGpJkYAhITWQsxZ4zQdA23N7eIZC4uFmw3WxaLlq4phBUKxngsUhSKdcXF5SXbV4Hb2zu+/vVfplu0OOt48+aKb3zrno8/go8vzxmHQN1mHlYr2q7DVxUA9/e3XL6oMKairmtSyojRKexnoq47Ygw4o+QUSuhcQJylX6352Fc0TU2/2ZYxjBm/bMlY2sUZTV1IWcSSc8AawVlHzJTIVBLZ9tuyJ6OZ7XbAoLzoPOdOwVl8bVjfbRk3I69efIHaNXhXYSuLi5baOPyiA5TNmLDiuL3bcLmo0Kzc3NwRQiangbY5Q0QYhkDdJFIMdG1DFovRRNd6vBdiElQMxgreVxjn0RiLOngcWXRLqqpiu77HSNnPaNoWb4WH2zdoDjRtQ86Zi/NzrBE0Z4z3bLY9MSuLxRlN1dIPG8Zxy3b9wN39LXXT4qsFIYzkFEGFFE0JxZwS4zhS1QJiEWMw1pR8rdZgxCIihJhIKTHGxLaPDGOkH4sDQEpTyOcporKiZe9Kc9nzyZmcMpqmmGJKsc/n/JiT6Vx8qScHYC37FOicaunQci/Wt5h5r2fewyhOxgb7zPtqdto+3mvYO13kuQCF9czTflFxJNjZzvOe2wknnHDCCSeccMIz+MEVldOiQ3VPcOl7CDeZScNpFZXDAESM8WSBlCvEVlSywsWvE++uEP8xuIq6e0F8eI1cfAnRvAthg2S0X5HCG3zyKCPy8u8kjRtYPzy9/7MNO/6YDvo0e7XNOCRjdVbXTZWITMTKcWzLolbcXZkP1GrvJquOCN/Hzd2p02Sn8pozcu4ukn09M0k0k6Q61/FIcqlzGwHRkm+krHgP2ynsJZr7Nu3VcU/xXuLsUCb65NRjdeTT8LiPy3PQm+Nj8zX7285FleN6Z0KyfJjW4Ptvm3mSFLXm2wnKub1vD1374YTkc/18jqA8/PtdBObz7dDd+OxD4h4M1NG8PDw3k95lPB6T+k/GSGdDZ5qRO9KcHSNotBhiVWXx4z05LsjG0IiSk+VikdgmcFKBWFK1AAwSRkgbUlxDVgwBCSMpjyxrMK4mhgGVmqZaIDqQgoWwAXlZPNgPxmTnvKC6M8BmV4YTTjjhhBNOOOGEE054F3Zr7plIkLfYDQcOqFkhq5Jn2xeDcx7vqyl8qAMpyq4SElSpnBQyJkWGIbAd1lPFSgiRftiSUyr5L4klj3suJF1UCCGw3Ww4Pzuj8hbvBWcyMWaGMTCERIgBNLFoWi4vljRtR8gB7wyuasgKTVfTdBV3dw9cvbmidZbzFxdUTVWimYQR1cjtakXISiZT5Yi1lqqqsM7iq5rF2QWiinPCtncslw3L1lNJpvIDOQXuN7EQOmSs8aQ8YnxN3TbEkBjGgZwNtloipiJhsb7GO19s9wQpJjqjtHVHypGurri6ek2OiS/+1Neomppx2KDZY2uLt4nKtBhf4VzLEAJID9bwm6qfRTTQr7eEnNm+ge++WXFxds75siGlkc4vWK9XnJ9/RIwjwzBwe3tL3TSIGHIueUOVzDD0tE1Dv+4RNeQUyJrIQMZQVwseHnrSCJcXl/Sbnkxk3W85vzgrIX2tMMQ1vm4JccC7GiOWlEaMMUWtaRxIwouh6mpenjf0Hy0xuuHF0nM3CDfrB9q2Zd1vWV50dF1NCBnJyvmyYxwDD3f3qAg32w1t62g+Ome13qBZqKqG+7t72varJW9qHPH+EjFCuzjHuJqmqvASimO2ZnJO0zMw2eFSVIrOehaLRSHe48jYb4gx4bynX68ZVg84X4z4RVezXHSEMOK8pa5rVAyVdSzrlj5E7lYPaOhZ399isfi6Q1VJU5hkZ2tiTIS4JmZlubA4X2MEkIzxisEgOASIMaE5M4ZAPwQ225EQlCFACLNzbrGkrUz7RZp3YV/JGU2xpJrB7o7lLJhEIZ4nQaWoYCjOCqXeed9tciOeycR5X2J+y+wcc4/3Sub9KhHIOmW6nPcJZPqstjhITO8yMYpmKSrPmRCdwsQ+8iA/4YQTTjjhhBNOOML3r6iUgz92f+tOFfeY6NmxdzuCo+QcFIQ4bqgEogrd4hPG8QZjGuTyN6G+QhTM9hp9+BbSLLF2S+7vce1ZMUa219Df4Zol0V6iuoLzny0027Da3ae0cI+nub6PSbK53WXhqAfqyLKAFFVk8hLTiWiZGcuZ3MxCoQ5nxedE0hx7tU2L7YP2HJJPc3mZ2zcTJhOJcky+lcXgrE4TfUpK6dxNATHmmBecFYIHiTb3ejJhsmb3pNLj8B0znwXojow9DJk5tf1JDsQjCuzgO/hwVeBjwm5PzJknx5+SmMfE+1s79eRUmceHoWLnsL6H+JA+vC0Uy/tIxcf1P55fj+t/27EjEo7SD9kR7vNce6YvUubw8fGJ2D7SXZo9qSdw+I0fkn0zeV6mYSFLVYoDRIyGtltiwhWRBpzHVzXLOvLNO88rZ9BAMQ41lfwhpsURIPVoTpiHa9QZTPsCYkStYDWhaShhdaxFU949C4nynM8GXJaiZJ7JVUTQfCIqTzjhhBNOOOGEE054it0qce8B+KxlIRMhuTM9VHcETUrTT04lhGSK5FxCtuaJyBCjiFZ4X2GtkEgM/YZhuyKEEoZSNRNDxgpY55CsJCCqIcXIOAZyTJAy1aKirQQnCZMtiBA0EELP2EeGEFFRRDy2SoS8AuOwtiINIykrMSVyzjjn+OgLn/DxJ5aubam85fPPX/PNb32XPkZyTDysApvNwNlZQ9dUjGNksbAII7W3+POLYl+jGGr67cAokfv7DSKKd7bY7JoxdU1Ownq14vPvRLIa6sqxWCxYdA1GoN9uEKSQgmYigxPYbLFi2G42XL1+zWq9xnvPw3oL6zUpRJw1+KSs4gbNt6SYaKoFy8U5rq2oas+5XLJePdCde37u8iUXr6/4m7/4S3znu29wX35F1zlW9ysuP3pFSoHz80s0C/d3t9zfXnF++WL67iONbxFvSXEkpwQ4sirjdkvoR7b9QFu19Ns1dePRpGzXW9q2xolgNDFu11hrECtoHkkxsFgsyFNO09q35JQRa1GE2hrSsOX8bMlt17G+v8bWNTcPKxbnrzhftlTOsOw6BEiaud88ULd1UfCmTGU8EgYe7tfop8VGtgbC2NPWHkwma4/zvoQYHiPWOVzlqLxg1ZGype8HlkkhQV1VGFEqb+i6Gmcd3hr69RaIiIOm83hnebi/RVMkG0vtF5wvl4QQyElZdOc0bQOm9DfmwNj3NL5iGyPqaoz1IBYrmRh7vHc451httiXtkPNkMjEMgBByxlmLc3ZSL5fnOeTEdhzZDJE+ZmJUkhqMcUVYLbnk95wN34k8LGrKiEz7PkpinwNJQMxUvKQ7Kds35RlABWOmvSgMgt1RmNMbB5F5P+tgt0wSZX+jfBYxpQbDjpAs95n2PCQVMlnMtAUgRdg99WHeL5pjiz3/9jvhhBNOOOGEE074gUK/yt6ImhcbsqPcpjKHhMleeVZoPyleZ0AaVlSVIYUM/gxJSso9od9grC0Jw+tXkCO6vUXimrD6Dnn4hNoI0lygL77GcP85lQO9/ClMyiBK0lwWZmI4CEgJUgiHw5yNOrXNHLT40VJu7lYxynhKCh2RQfMQCUcax8MwuYf1Pxey/0hhtyN4HssAnyGqDvi3Z8m+g3vPBOjscHeoZjtW0ukRX3cY9nVHArK/37tUlWKOScXdtRy39135G9+aL/GZ44/Jz107Dsi547E+/GaOYcxct7AfQ+bWM6tlj/r7js/vIhCfU1++69zb6jvE+0jT95OchyGM36YmnMdibtOBD8CBOnWuoTgDFFLcTOT4oYO5UcVIRRQI+orG3xL0/2PvTZocSbJsve/qYAMGnyIiKzN7qO4nfP2EwgWX/P+/gBtuHoXsqbqqOjNjcncANuhwuVAzwODukVWvi0Iu2o5IZjgAMzU1NQVEr557zhXe+cDNNvCPHz1CJlc1xBNViiR15RsvjiQVYiy3deBgPhRiEkeWEcafSY8jydWYaoO4DUIPmiaXX7kEZNPmUZkfi4zUb86WFStWrFixYsWKFf+ZMceMM87RybzYnRWW5wPmhFMgT0TkRFqkmIhpZBx6+q4jjCMpBGRSEiKKtYKRjKaEpoQAzjpUi4IrTHUljTOoLavYFFKpvZcDYSxETmdBHp/ohwHr7FRD0VJ7j7MVN1M9dxFDigERR11Z8mQZmmcL1brm4faeynk0a4nvjcGJ4gwMcSRGxWC5u9tiJdKdnqlrh7VK1pHTcSiKSgnsa6GuLdAyDgND6ql8Rd02GEotw5gNx67D1Xt+8+6Wut1iraGqPFVVE2Og63q6rqPrjmCkWIeeRvo+4KuKEAa+Pp34+PEj33/3HZJhGMcz+ZJ62LR3VN7Tjx0qEKY9grpy1M4jKE9PX8kp8MP33/Nwd8fXX/6IN4ndrubj50eMrfnhh7+m63o22y3PT0diysSUcK6irh3OeKw4+jGx2W5AIiZnxr6jrmr6/jP9kEkx8J1vETIhdLy7v8UZxTuhbhzeV9TNlhTAuw111ZYplzLWFrXiGCLOOvKkWDRYUkyEZDgcE8M48s5b7nYtN3dbTGVREZwR+tMJZz0xJsTBb97doTFiCLQe9g9bxmHk+DRwf3ODx2AVnK8YupHnpycqIzTe8v27WzRljDWM48gYekIcEFFSTOQstM2mfD50hNhjrGW73aGNoRtG4tjhrFD7mrZtSJoYhhHvPdYZfFWR1JZ6q5OFbNZMPwZub96RyRhRuuMTm7alqStiipgh44yj9o4cR46hx/sKV9V4ZxBjiTmWuHFK9I0xM4ZEygJYjBgwUhJr532eXMg9TRnVfE6GlalMkohgjEWMxViHMSWBYFY5nhNp51+eTNm8mBLdZT5WKAnXc1i+2Oq5lFWafoqmvS9YJlZP3ZWlIOCqUNIlXobF3pSuUfOKFStWrFix4pv4C6xfZ+XT+X/T+8ulx0z1XRMTzAolFBFLHg6IFyQf0fiZGEbqzS1WBsZPX2huf0ClLAZH69Ex4RzI6Q/k+78HhPTlH6lvvse47ZSJKgtlW1k8n0mGeYHFhetbcHPlX53JIGFWjJ3DyplUkaIRK1lmSl6QK+fjv7FoVNXpHFmsDPXC5erl2AvhcyHWZvvcudaIGDmfdyZkZXlfbyjzpgNkHhOds+MWz04u9rQsn+M5rtbzSrWMiU5tXpSYr21UF314qYJcTJO3CMdvKSyvyM3F+3p90IVC/zVSb6mOffOYbxFzy3+v+7a8D2PMC+Xi9Tlvka4viehvEZZv4Vsk6Z9Des73dHlucv6OXI5ZTIjlNc9ty2Isz9Tl+ZzZZnZqnbmuqMwnTJ+kHEstDkmc5Ja7qmO/6fnjx4zPT3hRNpJwpifZ35Bn8l0hjSf21SNBW6LfkFH26SPGelIeeHffICbRhYEuKkZK/R6cnX+pmFXGi58xzt/Pb9h2rVixYsWKFStWrFgBbydoLt+4pDyWN3SOD6GQlClOtSUDXddxPBzoumdIA40DRDGSEY3kFEhxRHNR/xlvEXF4l+h9sTgVteA85MwYO8YU0KTYLKSY6LvAMIw4e8JXjqZtaJoGjOBchRVhrk3nnUMUhtOJGDMhJIxzbG+2oInHLz/TDT1ZYbfdUVcNxhg+fHdPu9mVcnwp8/j4kS+fvzKOAylFjvJI3/dYC9tNizGCrytCChgFayw3N3usN6gISR0xJcQ69vdtsf8cOrqxZ7PdEWNkHCIAgsNZj60rvLfkGNltHZtGGcJI3yd+/Nvf8vf/9b+x2+9oqpocIzGOnE4Hng6PPD4+EkNkCB1Pzwescfztb/+OH77/nqp2uMpT1xV9dyy1P4n8+OMPdKdnEPjNDz9yOo2M/RFfbfj06Sv7m1ueuwPPT8+8e3iHcYK1lm44kHPACIzDiCMThkDlHdva89wFBME7wZoKTZ6mFtCi8ttu9/hqg3WWkBJNtUFzRNVQ1x5XV4QQsDHjvTIMB4bxgHUGcRXN9o6vXx4RU/N8OPGb9/d4VxHGyDgOVNayqRzOGB6dI8WB73/4nlPfE7ojoevY3bRgLE/xxH67paotdbtBbcXnL185PH/l3fsPNJstpt6gcURywjqLtfaiIJ7mi3UeNJe5rhkD7LY3PD4+M56eMZpwptQ/9d5yODyiCM7ZUps0K8PpREiBd+8f2Oz29F3Pzc0DOQzkHOi7A5tNgzMNfd8RhoB3RRnceEMMR8QYKt9Q1R6DK9/kiSAMQckYsMXK2Ikhi5KnWpCSJzYwZzCCasLMe1nGk0TJBoSMQRDrinLZOcQaMGDNtJ8zk5HGwOQqZZdxuVz2fooa+qUrmADmvD1VPrzYuqJgFgnnc7w+U5XlFHm9PTC3w8tdgxUrVqxYsWLFigv+IkXlmQx7gwCbbT/nItpzyHVZtJTlTM6KJaF4Rm3Yuzs0/p6Mo9r9Fb5+5HR8wm8eGA+/4G2Fe/if2LiB/tTR98+Y/Imq2qEqpImtK5anQqbYl8wLJpXZEqNYvy6jxGUO2IWAlbNmzCzJiqkdLmu2cp9yoTTztHgrhOhMBM5jAuh87GUs57YKUbPIQ1sQg7+qmJs5T1m8eHXMhdQ800C6GIgF3q6reGlWFkrUl5eaM/Lkqp15nXzd7jk779t3tiBoF+fNfZjbLwcy1+q8vWKEyAAAIABJREFUtth90c75fiZVJQsiTS99f42ZfL60Oi/U/1wrk5mshLLx8C2F5ZLQXPb11+bAn6rb+Wsk7VsKUzkHFvmNY+c2Sj3Ky/vz78CcNXlNVpe+XTV2fnNJjss0T7IqSTKSy8ZCFsGbmiwDIcLAhsGBTx1x7KnbAZUKUOJw4LaOQM0x36AkRDyudnTPn7A202lDznsiDW5TcSsDzzEgziFyMarWee4igAWEdDZaXrFixYoVK1asWLHiGi8TDqe/LnHDFHzMlTfmGnSycJiZCZo8kZUhDIRYavJZIqWGXiRFGDViNBFDKXuACDlnrDWTcrAlm0SMiSGMpDFiBWpXoRIYVRhjxFIIk5wiYz+pOUPEeoO1AzkrGKHd7HCuIsTEGDOqYKylqmq8q3FWIOeiIJtq6KUYsHWDNY4wBsYQGMee5/5AVEGkJvSJEAcgUfmaGBJVVeN8xXbfEoYRjRlfN8Sc8b7GOYf1DaWOpyXHzK0KWYUxBlJWfL0HUYaxRwT6oeN4TLRNg/cO7y3VZsPtw/uiLD2dCH1H6geQzDCO9KceZxt++PE9zlm6/sDT1y88f33ip9//K6SB7777jpAj3amnrir22y3PTyesAWsNnz59wifDDz9+z+H5SOhObDYtznn2Zs8wDEymm2hWlEwKA8Y70EzIIyoJgKZ2pSqit1iTaWqPMzU5B3Z3O5pNg0gh6DCFHLOuWAHnLDRtRUqJvjsVEjA7UsikpAxpoNpUtFvPT5+/YMj0w4mYI8Z4wghfvj7RNo5EAmOIOTKEkXa3BWt57k48Pj1zv99Chsoabvc79vt32NqTjSV9fmSz3eKMIQ89jkjMAdXM/uYW1KC51FK1xmCMopro+p6UFWMcznu6YeTr0xe8SWCUqnL4Suj7IzlEvPdoCqRx5Dl8JYTI7e0N++22kLbNFmvgdPjC8XhEpGgFT/2JYRyIOVFXFVVlUY1kUby1iBgyUiyYc3EJijkTUzErtr7C5oRmKfVQFTTn8r1Pk+IRQbElGT5ncgwlFo627GtJUWCKsxc1pSlKS7Fmiqkn5zKz/Hn51v6HnveGrpzQVCa3rXx5b849nraNXu7LzIed93mmmPlc/QlQk1amcsWKFStWrFjxTfy/UKNyenle2ChgF+TGDLMg/yiEXzbk3FP7gBiPEU9q9khzi3UV8fQTGiM+P6FPX2jv/wGpdpAHhqgMY6TWDr3/n8nGoeNX5PAz4j3i70rmmQpiQGSiTK76XdhKpRSgN8xV9ASVuVD7ZWWVVS4Ls4mquLhYznlkL+nBiezUJSE5kZ+6zGLjnPV2OXIisnS+3rJO5ZIUypMSjTf4wgt9loUSbE7Db+dLTAzdTCy9fK5ncuzcd70iK6+vJue+zcTvmbRaCvC+gXkhvejAizt545yXSsrFPHtL6HYmNOeF9fx6vvR8r8tjFt25fj2TembqQLpc44qJm49b9G06ZklavtnXP6Ge/B+p4/kS32pv+e/Lfr89Hq/7WP4xL44t7RRCODPXuSjjs6y5OquTS5tGFVWHsxbIbCrhfhv546On2bfkPhPUEFIg5UhjnjFJeeyVbVWxaRyfDxYxR2zOZDJfUw3uB1x4oqv/6lwH0+ZM3dSkY08lG6IKhlKr4/xdnZCnwrJmDbhWrFixYsWKFStWvIGXwqI5KVLnzfvpgKTz+nhSV02wSIkwdFZWJtB8rtMnWRDJOGPQpKQYyJLOMU1OiZAiSiJLIXtCCMQYiDkQhog3lqpyqHEko6j1SO0wRhiHnpwyJkNKI76yaB6xzmGcoJzY7S2Vd1RVIQWTgpGMlcxms2WzrUmhEJ1jSBy6jq+Hz3SnDl/VVM5hBUyGbd2QXaRpKzbNLVYsh2OxYG2aRD8OtG3AisEaS4yJpIJ1hpiVGAecq7EYxGaGfiAnEOOovCOEE8Nw4nQ8cDqdiDHQtDc0331P024x1pJyqRk45Ij1Dl87nHWIKLucOTUd1lsq5+mHEcXSbHZst3vG8UQMA4fnR3a3N7QPDwxdz08//ULbtoh1bDe3VO2O5+cnPn954v3De/p+wFiHWIc4YdM2GDFYawlDh9HM2Pd4uyGlhDcObyyjjmw3LU2d0FzUhb0G9vuW29sdm5ubqexKsd1FLG3jQRzO1agaVCGMIzEEnK+KorYfGIdIXW25f3jg8PREWxlCcBjnaZsWI2AsdMcDbfVASkLI8PnLgfv7PXVd03hDlaG2U93IoaOtHW1TU1ct1WZHyJnb2wc2bct46hj7jvt9xR//+BlftaRUCL9T39GPI1WbMaaoAlNKGLE450m+QscvbJ3BOTjlhPEGtNyPcxWn7kTqOuypo223bLd79rsdORust4hzPD5+pu9OgCGrYRh7VAVRoakcTWsRKXVjrSnzUBVUM4otcWUWQhJCNiQtNSutM1ixxdI5KWkiKq9iTCkEJprJyaDRkWMsLq7zYTM5aUrygUERay5NGDPtN1EITgSzTFJWnepXLhKur/ZFlvH//Ks17QsVTzCEEpdf9vdK/0p4PO9esdQoIGrXFN8VK1asWLFixTfxFygqZ8xLkFk3NTFfy4KLMlu9nk9BMahENPRsasNx9Di3WJSNR4wTquYGlR0aM8eP/zf+4be0LhC+fqG6/QH8bzDHn9DdX6HtA6aGnE9o9zMiFs0nRNzZ2vRSV1FLjUoE0UKqqWjRhU3E0GKpV+5K8tz5K8xcn3lFal20ZGZShS0ptXKNqY0FWXZh8haKNlmq9mBmJc1UMDFPry8qwvJ6qTy0Ys6ZuRcyTy838AaB+JaCTxbPWhfHnDndhSLu5d0or8m65XGqerbmXTYyZ/ldqQFf2iedCdWlEvJXFsILtehMwgos8wbfHIvLgv2lKpBCdWs+j1nOkxbvGwrIt95/qXhcEpl/irB8rX59w/L3DVXlS+Xsryk8r9tQXjyKN/t4JuXPis15CpY0AeXFWJyzMKeXZprbWojg7zcDHw9CP3pGU3O3TfTDSI5gMPRpR3j+iJNnvK94etqRZYvBk71HsyVJwliobUeIj0R3N83NjHEbJB4BwamS5JLlfjWW0//WcGvFihUrVqxYsWLFW7gkgioyrSlfZ2CWtW/OU/LeRFTmuUadAJoLEZXztPYupUS8NziBygk5JbJOasxMIUN0Srid1u0hDfTjUMjHifDoxpFDX95r24ab2w37mxZQDs8HQogIUojGGEHBNTVREzZDGCN9HkhZGYZEjMXG8vOXr1Tec393S1WVpMO2qbHT33f7WxDD6dTx6eNH+v7A7W5PW3tEIYRAoMPYxMO7DSkKYBFVjCvxtTXCfrNDsKSQCePAKAOnGIuS1NVUVct226IYsgpt3XC7uwWBdrsFMfT9QHc6MJxOnA5PhBgwzpNyIaS2ux2+rnHGkXMiHo8MqoClrTy77ZZh7AkaePzyyPEwktWwvxGquuLd+3f0p44QRhClqlru7h54fPzKv/7+D9zf3bCtPVVd83wYsd7gvWMYA2EcsWhRA2YttT6dQ7AMfeDYnbCibDcNaMUwDOQM9WaHM46UoK43VL4iYTG2ovIt1lWA0HUdKZfoaxh6rLPEODIOI7c3dxz0iaGLeNtws4W7+zvu9zeIteQ88O6uwbuE1p7PTydyCtztN7g88Lff3fLgIrtNRdtYNA9YUUQSMXfUssG5iqbZ4p0hx56YFN9uiFi8OHKGEBO/fPpCs3s41xxtm4a2bc/JvzGPYIpCdBwHTn3PZrenO5xwTrBkutMR1WINXDcV3nvGkPE1iDg+f/7C8fCIJxNjIidoN1s0jUQjFN1kLrVhEZyxOCMQx5LaWhusrUgylSGx4L1BpMJr2QebMmSnvZPJEnX6fp9LFqmSc5xqzZaalZetm2mvh5LUTtbL++etCp32vxQxpX3RZYL0nBx8sWxVVXShxLxQjfNGD+frloMmAvT8e2S4HKEwlUgSvbRkfy1rfcWKFStWrFjxnxp/EVF5JijlvBqCBZl3Jh5kefwFxjhCOIBqWRDHgfD1X2jDZ0z9A1K/IytkEkiirmtOf/zf0cphtn9N6J9w/TMuHRm//nfE3+M1ghGwDkLCdJ8Rsy3Xl4vVqi4WWOe11dJ/vywhpyXWTMzJ5YTrgYBXJI+ez/nVpZhcf/6KgJJJ5yjn3Lbp+JniFMCgMtUyYLn4nBeIXBHFZnnBhRJWJ+J2XovOGXbLvl3Zoc4MlV6uZhbtyTSws13mZU68pnWurEbnI14QV/NnSyXkeWH91ufn8bu+zut7X8zVM9H6mrB7eez1Iv/8KSL2fI/GFHvQohacCLq3yN9vkId/Dt62k/rzjn95Ty+JzWsLWHlxzrTtoq+J2LeIz2uykmn+XMj411N/2RdH1h4jnr+9Cfz8VFGbjmRaLCPPj4GbNuJ94kvuCcefcJsHLA2dv2NXZdo48BwhJ4eakpOacybZLXvpeUwnktmUDQxTY/RrCf4MZDWlbuX8/fsPKlhXrFixYsWKFStW/CeDnv93Jhh5sVYuvMQUoeZcyh6oFtvIiXzUnIv9a86MYSSNIymOeMD5ktAnGsmayVEZxrEch2LF0rQNvrI446iMKwScCGNMaBcIx1NxGBJIGuhGixGDYjHWltgwGYYx4n1F1eyIaSTESDx2ZVkvQsqZGAJDP/A5Zvq+4/5+z4d3d9zd3HB7c8O2aajutqSkdH2HM4EP7/aoNhgBTZkYBiyem5sdxhmGIZJixnmP8x5riiLweDgR+kKugeIqg4ilbfcghoyhqmtCivTdAWMtxuikZBPGUOp5hhg4dSf6Y0dOkXrT0vc9OSecszx++coYAs4YnIW6rRAxVL4mR2F8+gpGsGLZ77b0fcfPP/+R4/GJh/uHSXkH23ZHBkKIVHWFOIexnmNXiN5bY2mbhmEYoEklildDykLTbuj7I8W6Nk5zRAkhk4HBZOqmwtmM9x4Rg/Ueg8f5DdZWJW4zbor1hRKmGjAG56qiijOKr2pEHMZYYoi0tefd+z1jEJq2wXmHiCHmDKI4V2L/NB653TU0laPrjjRNzdFkjGT67kgcThhvqC1oGjCmKHCHscOSp30LYbfdcbO/IyVlu91w6E5ECgmf4oi3DaLQ+JqYExoTla2oq4ra3/HzL58ouyDC8djRbmqyBkTg9mbLfr+haVqqelPmiRH+8O//Tt8fud1tGLseVLi9vcUaZRyKgnHsOyQXtyQjGTGJlCMpK1Y8DoOKQSm1NI0o1io5C6RMVNBc7hEEkwvBWJ7DhTxElZSVHOf9lpJUgDA5hs0xuJz/TqpnYl1QNKeyn6YlSWL2EAOZEt3Lj89SbXnOX9eyZyaFb5xcuWY1pUwGaXLWJxiZiVKZ4ubym2bgvMGjssbQK1asWLFixYpv4y9TVJ6JBllwPuX1chHyFlEnmlGEMHa4aAgxUHmDr3ekao9r9mjzDkMpAJ7VkLJy8+G/gtuQwkC9/5EsoCK0h38ltncYuyGbjGRBW0sOJ8zQl9XVpMaaCVZFkAUxWZaxMzGTzwTfTC4tU1+XRMyFyDmbcZRrzCrOmYV5SZq9/HuRqHbx9Z+y2yjWrXMwa81sJ1sUiKpyXlTOfc05TzymlNuRl9auM9F86cVSxXZ+dq/IutLRmdhUFqTbmR9ckrqXe78oEvVy+NLa9NKrqzF62QMV3la4yWUc9I3zzudPWZfLa79sB9U3ibbzc3qDnLseo3nDYX78ZpoS1zapfw5hOY/bNXc7f74k+l6TlktF5st5+6eIzW/XwlT4hsrw5Ti8vOfzfZ6fzguCevnJmZROCJ7NxnI8BlKMYA/YaEgGsq/5HGtuvEVyxjb3GAaSeweqPA0eMTW7ekTzF06xJlEDhpCUQEPrIsc8glhQqExPyl0hLWU2uZn6NROs5wm/tLlesWLFihUrVqxYsWLCMod0sf7V8+vMud676jnIKcq5TM5KTJGYisKr63uOxwPj8RmjJ7wKXh3GldNzVMIYGYdAiImcM6YykIUYlJhKSQPjHNUUD1FZoEbIOAOQCcNAzJBTqU9prEespW5anK/pxszh0BFjQnMhWVNOxJQZQrGUjTEyDAOPX5753e8+cnN7Q1s53t+37G82GDfVWxwHKucxBsQ4nHfYykGOHJ6OZJEzYVikopk+9Yh0RSlmBKiwvkWx2KlcRAg91lYMpwCaqb0/J5XmHEh5BGMRI3jvufG33N/cIQjDOBLCiZgTx0PH8dgxjgGjSkojXx6fGMdI27Z8+P47vvvwATKElHm4eSBtAv/yr7/j//rdP3N3/8jf/PZvePfde0QgxUjtHf3Y0TYtp+ceVYuYilMX8NbQVDVxGHG+RjYNMZpCKPYnVCGNgTAOSE4Ya3l+LiSs85Zm05R6j94hgK8rrLXElBDrscZORFgipakUiVGMNdRVzdj35Aj7/S1fP/9CXRmaaoM7GYYhY71Dcyzn5ZIsnWIgpYxFebjb451hHAL3+z1dU9HWljSWGp21N3gvVE1NTImuH4nDCd84fOUIuaGpGj58n3l+eqJtHWHM3O9vubvZnONrnWraGIScFe8r2s0OI4n+335iu72ZyFhFUwSrvHsodq/GOaqqoqlrsli+fPrE2Hc83N6WeZsiu7bBO0/OkYRlDANjCIgGRDLWFDvYrJmskGIHnWJsRVIhpZK1XSxaTbGoVTPt3ZS9NNHyW1BUj4VQLF9kxYpD3eQ4lvPip2Sxl8JUKmhKFLDOYZ1FNRMTWL2MlepkN2tnp63SwrxvJABJmE1mi5HtZd/pklA+76nlyz7ZeX9GJocsOe9RnFPt15h5xYoVK1asWPEr+A8TlbNFIufafC9Jh6UNpXmDFDGogdwfMJsb0uGXsnjuPkN1T9Ijlb4jWUOKEX36J9z2A6a5J2vG+xPj8z9jd3+FWIdufkAO/0a6+Tskm4lEU3IeEecAJU/qxNnS9UJYTiQQqfSLBCrkM8kGL2mvK4XYgpSaRqVgGhedB+ylBed0yIWMKws8VT23cT5Dl0rGuRqAIBpBHFYcKY+InYPektkIU5bklDVnKISZnhemi3ua72GpTuQNMktekFMvSMqr0ZIFyTaNW+byeiYx9fw0XjTEoi6nMqn4MotZdm7tbHWyJBEn8u5NwvHFCJxrTS4W/q/JtWnzIF+I6yVRe77s/AymFEIz1ztVgPQmSfhtUrCQjVkpykwxZQ4bg2osn4sliiI5gVwMVV6rIAuB/Za167fsYOe/X80DnYOkOZiZ25v6eR7X/Mb9LhnO6TdE8mvWk/kpC6qRQx/o1GHahj5BV22xerGhDdGCKHn8Qtr8DVYEsCQBq4lDcAg3tFWCeKBTj6aS9XmSG9r8mU52qGTyZLNjTEkEOCcwLAnhc1D49nNbsWLFihUrVqxY8Z8cKtfrR7hO9Jzf05IImudk1Pn4XBSS83o8psQYRrqho2IgiGHQjKpBRQphAmAsrjIlBrS2fJaLDWzWRB5DqfEYRkJMGGNx1mN0KhliwFmINhMFvHOoQh+UGCPHp2eenw88H0/otJ63RGJO9EPAUlFVjjFkjkNP1meejke2VcWnz47ddsO2bdjUFmsKibjbt7TbCucNnz994fPHrxwPHZt9y81+S137ST3mOHUd1liqZsNuf4OvasiwaT3eOchK5QwhJoYQaZoNdd1inKMfT8QUqaoNzjtCDByOj8TYE4cToIixEznkqBrHvWtRaowq3bFjs3FYa7DGkVX5+vPPhBTIAtvtltv9DX/9N7/hr378gWEcGPoDv/yhY7PZs93u6MZnQop0/UDdVBy7niq11JUv6jeBFEeMs1hnSdkimqiqiqfTc1H1pRJFO+vp+8ymUVLK7LdbrLUY6wghUbfFSaZyFoyZkp6FlGKx6VVFjEGAlBKn04F205TYUTO+qfC2wW/2PH49YKyjblpEDKdTTwqRLgdS0kmxm0kx4JzDOuH+4bY4X+VEV1u2mxZra7xrS/mOpNTeYhBSFlQ8Vbvl3QdD0zh0POItbJuKyjkiStZE0ohNkHIu/XSem9t7vn79TE6ZpnE4ExEdySHSNjs2tccKOGvxttxfP/aIJr67vyOkzDiObOoaEcPT8xFry3d1GAcySlXVkJUUE0hGiKAZwZNIaEpgKgSHiEUwZXyVsi8wWbCqKGZSs85J80yuUaKZpHn6QbjUs1S0lBRauiBNey7l/ZI4ACC48qwpVsxzcvuUznyOoZV8MRab907mBO3zb9N1Snv5DZu8ymTe75vj9qLaLHsnJQlDhLK/pmvgvGLFihUrVqx4G38BUTl56yMXduYNluFiSXH9ngJGM+QTxn9PrR+pPvwvjE+/w23uMe0DyTpS9xXtvlDf/T1qKpRJYel32JsGff49tB9I1Q2yuYfjz7D/oSzGtGSwGTFgSh3KsjKbvPMXzN91hchyT6/r/V24xm/d158et2+r8F6rzszV+9cE00T4GY/REsaG0KOpLIRNZbFUpDnzTXVaa87ZbYVAPpNt0yL11T2cz7n0/4pwMgul5EUSdzlj5nnPJOJVWXWuj178q+cTy33PZ6lcPwhzoQtLEvKl7eVVruoszq/1Wj06Kw+XJF/ZU9AL2Uy5B51evqyVeTV0ZwXrgo5+YzzfPO9q3i1JUClPXgQdeqwMpOErcfM9joospUD9S/L8fO+/Qo5+67rzpsjruTs9lUVm5DUhPPe5kL/X9lZvk6DzPV71YzrGiMXattgeSSDRYJGJj1dUhbZOHKzDe4tJPb3fY0QxScgY1IKqIY2CkxucH2jMQI6ZU94xuh318IVe7sFYQozU3iBS6PXpJ2UKIKf7vUzVFStWrFixYsWKFSteQF/8dVkPL3FOgBXIotO6WEkoiVwsNk1x1inJt0xqtAg5o1pIKF81NK4m+VQICIGcE9YJKRfVW4olqXAcRsI4lvjRCMYarDMYSgwWEiS1xdZSDSkl+iHSdQNdP9L1iW5UurGoDT1KUzlCGHEOnArWKFtrGJNyfH4mNZ47s+FL3/MxFQXYpql5d3+DcZ6++4w1Sk4BJ5EP729p97tCYFFiXVXYbLdsd1uaZoP3NWARY0lEhtMJUlGhuaphs9vimw3GWnJOKAHDQOieODx2dMcjh6dHDk8HDqcTIUUy4H1FCJl2s8U6y6nveHw6Mo6JMWVESlL17W7DzW6LM0LWwNMn+EkM7x7e8/DuA7Y2HI8D3XPH8fEzn6uWu4dbmnpDu99weD6yud/QjSMpJ+rGl3zwnOlOB5yvSuJqLnUqK+9IGqmqmuHUQ8o0dUMICWMMxkAYTgydp262U63TQkjFEEp8bRwxKyEmUMVmSwiRICMxhqJiRWg2W4ZjwjhD62tSNqga6mYDAo+PT5ASmgMpp4kgzRyfn7m9vcVYy83dPZYAMXA8PWPrFuMbXLXBR0ACst0Wq9S+EI55CrjrquLp8Ilm07C/3aGaURWGYaSyNVRFzamaMK6idTueHh+pvUVyQKOUWpMxs9/bolQ0iboSchzphkxV1bx7/0CMQo6BrWkJwwhZaeoG1czx2JGzQaRGgZyHYiWboK6qyVbXosYi1oI4QoQxJdKUEq9GECwGM7u8YsROZGbZrzpbrGpJsNeJqJQiiSz1ScnnPQnVPPWnnJNzKQtUbKITad7nIWOkEKbl+PJ+znM8O1lPz+TjtO+iyDkneSZSz79Zai7p5ottwbLXpNPeTCFhy77InEy/YsWKFStWrFjxGv9x61e9tm2YCYbzx2+QN9ekiJJDQrISsi3FyP0NiRY5fqLavGd8+j1ODPLwt6B+UtMpqrM/v8fe/R3h8XdIDNTtA3H8HTKeyHUFUiFZMQ7ATPUM5WpxtejdtCibyZPXxOHLe/gfxctzDcUWQ6fLsyB53jrvimxTRTFYLYGFDl/4Mf8LtYUxWz6GfyBIADPb2ywJQuXaJnRBpPEGGbm85qwi/ZZt6EJSeFYvLmng+eO5RzrRxKpgJpJQL+0sesxUjGFBME7KRiMoqViq5AvReB7Xifhckpay7OsbY30mzqAUtD+3Od1TKcLwithb1ge9kLfLcX77u/HW++f5t+g7lI0GkcT/+lvDh9s9v/+3J/7xyxOjeUembAYUkvD19/FbtSTfvofFeL0gGQtmK9u3xm++3yVxeZkTxpirtkTm+rCZsz2MLOdc+e4aaxCN1EZ4NruyiUIuVjoxUWuPQzmZW3Z2xMUn1O3JolhTLIEyihpDyokQPLa6Z28/ksaPDMEhxtPoJ4KFPh6BO1Rme5yS4XpWBZ/n+IoVK1asWLFixYoVr6FT+ZHL6+v18SVptKyBDZdkQDWZNBEHTKSFFcOmbvCbHSkqpLEQZnleixuMOMQJKZaafM5aUk7kFDFqMdbTNA19P+LEMA4Dzih1NbmTpIwxBm+EHEZEImMXQCYrUW9IURgkEcLI0PdYaxkiDF2gspbYB7p+RCSzqxz72rJzJemwzobKZqqNo8/K0/GZX74+8k+/F7ZVxb6t2W0q6sqjWuxnN5uG7XaLiAcMVeXLen7MaI40rQVGYhjJCXKyVJv9VGsRUndgCD2Hp088Pf3C6fmZ49OBx+cDn770fD0ETgFOCbAOZ2HXOmKMPJ9+R1Il5EhWpalbunEk50IgGREaY3ECVe2onbBx8PTlIx///V+m8d7RNDViDMPxK49pIN3eUTUb6taRUuBh39JHXRBJAhqpvGUcAzEFLOCrihw7XG3xlcPFge2mojsdsWZLCF2JCVMPbEqNQQ2EYFCxpBRKXGQcMUS8c4z9gLGep8dn6roixkxdO6Ipc6u2jlN3wHmHMRVVXTHEgGpEyFhjGcJIVTlSyAzdEW72pBAw2xojHl+Db74izmLrZorHFWMsdbNHNVMNCadCiiOnwxM5DoSYuL27Z3d7T91seO4Ghr7ndneDzAS7Eay1iBqqquH+fo8jcTgc6Yby3Db9iHiLr5RTNzDqyH57x+3NBussXUhFVQz4rcN7z9gPdKeeqqpwrqhacw5EEpmEWIMaTxZ3TuYXMcXMeYpcI2Q9AAAgAElEQVQfAYzIWXloJ7vhmXQ/7z1REhHI5hwPz4pKM3luLWPynPO0L1RsfPOkwMzJlNIlCmRDyXHIRFKxCjbmnBQv6ER2TipuTRjstAcy7eNMey4s9gRmp6yJppxIzOlHTqYEcjMpK5UiIHhD2LBixYoVK1asWDHjL7R+lRdvTAsP5UJEfON8xZDSM96V2hXWO7CAlEVm//H/pLn7DVK/w6BEmWxLKYXOIeFw5Byob/6OdPw93fPvaW5+xBz+BarfIpKwfMGb7WS9ycyQXcvtpu4v6YZv1i3kNTn15v29UJYxqRivawMutYUT2faN61zaWhBLOZWFaQazeaB/+ne8E3QQpGqnYueGsy3qZMdZaniUwbgQWmZ6nV/08fX1X6lAKRyTnlnGuXXOmYLz4lTNpbbCrJSbesIsWZubuYgjywPLU7ZgsUIpbVhJxDAQYqRqdqClcP35+rxQu+mFjJ6JsOW9Lfv+Ektb3POx10mFi7bebmXZxhWZu2h3SUzPxy8JQWtrsiR6e0/VWKJ7Irrt1B7kfLn2q7a4nl8vCcM/h0R9STq+RWKWwCe/OQYv7/lc14Lyu1D+ytfHT98PI6BqIAcSJfNUjEVSxIcvnMyINQ6NmejfYfLPxOQRV5dgaaphkrTYOakmNm6gOyWibvAVeEmgFYNCGk/lq5GYnkOZpwYp7r/n+btixYoVK1asWLFixWvkc1KbLDMppwTcS2JfIRwKYTCHFwbBisGLkASSCNYamqbFSyINGY0WaxRIoIYcEqcUyHEk5QBGcdZNCZiKM7asv3OpR5ks1HWx3cwpkaa6lMaUvlgU66CPkX4ceDyeeD525AyaIpIjlQjOCre1ZYyJMSaMSLHY9DVDjuSQebdrua09WUfqumIcR95vt9y1Fb98PfLxsWf0MIxCSAYrPbttxy52pLElDD1NuyWrcngWDJamaXHeIHlEsHhjsc4QgHHsCOFI6I88f/qFp8+feX564tSdOB0DXw8jPz93fOqF52DpUyZJxhvY10IXDJUFX0FrBVFHykLQyL4xU+xc6gGKZhBhjAPdCB9j5g9PA94aKuOxZL7be75/d1NUesOeOAQePnyHdRUZZdSB7e5mmjiRuq4ZUonxKusI4wnjDN5atKoYTidcVdNmYeieqazBWcgpYa0jZ8EZU0paTMnAKWWcq+iHDrGCMY6YClmoKlhTCLocAjkHutMJ5yrqesPPv3zk9u4ddbOhrhtE4N27WzQGQohgIt4JJOH9uwfQRAwjKRdi3BvDZntLP3QYMaQQSWPC+BrraqyBph4QDMfTgBWo6xptW6qqJkaoxDCEjkwik7HTd8Vag7WQY0REaHe3xP7EqXuiHxKbtibGSEyBrjtR1dC2W5qmYoyZp+5QCNOqot1si4VyCqhAVVlOo+E09mgaqStLXW+Qqi1bLMZgfSHOcw7EMJByJIvDuhpjXFE8i0WMwVKUlzkrOSlYxYjBiila6Vz2Owwgdt4zWti7Tr8XkotqmCmROuc07ShFIhlscQZClTy5oeVUEh7UxPM+jkixls0Z1BRC0UzldgSDaLF2zqbEw2V3KU4dNBQadLKAZa5RSam/OW/cyLcEAytWrFixYsWKFQX/cUXlFc76NkAnJ0hzVsKpChYmX/uyYMEoMXQYMmE8UTd7yEqMPU1Vlwwzu6eEawYrs4oJRHJpg1xqR5Aw++/x3SP91z9Q33zAnH4ib3+gTzUu73FSFntnku6leg1K1ioTfTglhE3lHc/E2BWRc2VbcU00FSVcIQDlTIgV4ubMcS3UfuUa1xaarxWdWjJcp5oDZlrsGauIOJqmZdNWPKnFqCmFz4GkWjL4ylM49/W1qnDu70wg8aq/ZnHPqpTF6axinG7ZTITQzJeJWZidLmttMhWWn4gfnRa3RV05Da95SegyWYcI1kRal0qgMh7LPGjvEbXTeGbyOQ8wTw/SzMPImWWcCdiFinMmUa+W0vNzXQzAhfS9vK9M6/UrRlwu/8zzSSbieElcy/yMLrUcdK5rI/MmRsaoMKZSB8IhOMkEcZisZPI5QxK+TT6+9dm36lW+PP6lyveV2lfn+yqE5eU6Myl+nVm+zCQvMKALq+NpCAyCjQNBy1ipJiwJ4mek3TOmkuypKZS57z5Qjx8ZBVQ26DSfjJZxMmL4ud+xJ5FtTa8NhoTnRMygMZI1Idii3Jyf30z+L5SfK1asWLFixYoVK1a8gk4JsS+Xi3NWplxiv3MMmMt6+kxxGou1Dmsd3ldoVUPqiSNETWjOWFtiNc0BTZE4jvRjTybjjMNZi/UecRksxKQIBusqkljQVOLMTInLyQxhAGDjLPumYlMrhkQYE5+fO05DRwXsGgsqVMZzd7/neDowDANGM9va4P2OYRgBSFYQKsR59nXNOPYIwo/v73h3l+mGgCJs6oqbzQbHiI2B8Qg5xJKwmBUvJc7sBzg8Kr5uaTc3iHUMfWDsevrQcXg+8od/+4nnx56uG+nDSNTMccg8DpnHJPRaxq2tDG0l3NbCvjLsNg7vSmyZkWKVKkKXSi3AHKcSLRqQpBgVjBT7ziEKwxDokmVImT7B//Gpp/3dgYfa891NzXd3O348Hnj3/h2+bsp/o+DrpjjAKDRuU6JKlwFDCBHnLCmAMYKvDc55UnRo3rDdbYjjiCTB2GpKEBfEeGJMDOOIsQ5jC8k7jCOHw5HdbkdKkf3Nji9fP7O/uSt7DG1bHGW0WIk6X7Pd3lHXnu50ZL+/5fD0iFOD6omhHxFNOGeBNNXVLPNLEKqqQqQQpOMY6frATbPH+QoRaNoN1lpSHmnbDW1TE8OIMY7n52dc3ZJioG23WOOYY27vKkQqYjrhKsN22/Dx+ZHD4ZmmMjSVxRhhDBljoRKLNZ4hQooDGdhu9jRNi4ilOx0ZxpEwDJAjMQS8sVTtDc4KMUT6vsc7oXIGQyLrONmvln2Dyk8Wr6IoqcSRpuxLJRKqUozKxJR9BWNw4ibF4yIZuBSXPROUSScXopynckoQc2mr2MpOVrF5Sv6dtpwKqTn9Jmkqe2oKKpG5fmVOgppSQEhymWMikxWsznsUZlJrTns9MlvWlovNeyFzzFz2xi6/ZytWrFixYsWKFW/hLyAqF3TTmUu4KKOW1OXlUFmcYMhjT13vOHYjlfX0p884W+Fu/gZxFf2Xf6J+/w9kw1kdeG7nHOvJJOYUbPOAcTXd009sK0MenzFZmcsaXisov7VImvs/EzIzifla5cbifpnu96rdxUWLT/9sFTkrzqYxkpdKt3xu67WK0UxtUUg+JmWcCLubO1QPGNeCXivo5Hwvcr6fefxYEnKvxkUWz5eJpZnVbspcc1JLwT6uacjX7V0r+y6Wpno540wclsdszqTyRVlX6kq8v2sIfSA5pfaZmL4iA+T6DqOWjJly++a2F8TheSz06pOXdibz+J4tWK+I6tck5QzVy9y4PmVphTsT43nKgLy0ttAvnkdo+f1Cir2Lr2pU06yHZa5t81qx+Ouk5EvF5fK9tyyQ38J1+8sxLEHqhYzUy5x6Q0l6bmsxvKKKM462NjTdiaAfUBJIRMevqLvHy8CgN2B/QfOIFvklfX1HPfzC4C1WK5RMXs4thawWIxEVSAY0NCAetNS3EXuxL5Zpzovoy4e1YsX/7/jtjfnTB61YsWLFihUr/r+DvljjLjHFUFefTW9llUnTVHyFxJT6cmILSRCTMgRIQSBnDAFDWXnnnIghkuOUaIcWEsM4sgphTBgrbNoGMZYQBobugDGKc44UBUmKN46YAplE5QyiQlM7vttXNJr4SiBGLTUTcyLEiCHz/cOO08kTxkjWjPeW/f6eoR9ICDfbhqau8N4iodiOIpndrmG7KZa0deOxlWW/31EsXQOVc2jfMxyPjCmVPQJvC3kVEprBe0d37Dg8nRiHxC+/PPPxpxODGh6PiT4pQ4LDCMckjAptrbzfVtxWwm1ruNtVVJVBrZAQVCwxQMyJCsElIaWRKOOUXupJFHIo5TQlO5ckWStKLRlnhWANp0H55+fIf/8y0vzbgf/y84n/7b/Bj+/vsF2PhsTt+wpVM9Us1FIOB0PlPafTQCQChrZtOcZEjIHNpuF4PIJUKEpSS4iGcczc7rZYW2FN6Vffn0AcOSXGYZziPqGuK06nAzlFvKswtpCbQuLw/BVjHc7VVFXFMJzoT8/4yhPGgPcVlasYc6Kua5wVvPc4ayCZEn85xRqod1ucbzDeYSJgirGpMxZfb0q0LKbU1wTa3T1tW3M4HEljj0VoqxYzJfka8/+w92Y7kiRZmt53jojoYmbuHh65VlbVdPUCssEhwEGTIAjwEfhifBE+A294QV5yQBJ900SzN1bXNtUVlRm+2KKqshxeiKqZuYdn1UxXAyQ4+mdGhJmaLiKiagY58p//P4qKQ7U67vRdh8WRlBIqRtc1eK8Mx5EGJTSFKWdIie2shu1Cg5TC6XhiKsIwTphN9E1D8BtiPEJJxOHEcDoyTIlUjDEXttqxaVv6EEgZchHQqp7MRl2RUEWdQ50HlAxoqWtDdkVOLvawZsZizlpvXF1jMDO0FHIu1dK3yJxQXnlEk8ySfK6yaCNLJUpJLG5f5bwMVV9jBSul/sZkzuttNQnaEFlKtChuTjQ/HyvLKpDOMXZZWn7+/TmX31mx4v8j+KNb5W/++//u/+1mrFixYsWKK/wB1q/fP81YpiDCS9rqtfuqTc9IaMnxidAENEfy9rN67uAIN18RH35Od//HlLOkcankfaVSoxJ/GQh+Q//uTxif/wH57u8gDrVguM0KxCtca7xqIHHmDGsb522wqOCuydlFMboQeNcnm/t7fmtXZMaiypPzgcsEsU7w7NK2Jevt6pqvO2ACThUh45ueePiOzA4WvddCsJ3vx2KMemnskuG2nPQ1sVXsemJ5Ifuu1W4qWrNHSzlPfl/QbW8QgMBc9++y53nM5jbJMrsFlsoJKpkv32/oXeI4JYorSKg1Cq08kfIGce35+KU9l0y+q9u19Gsh565ev9X2a7z1DZAzOf02yWeLsvP1ma44r5d1VBcK8kKomlTrUhCc94TgWWp42kxo/i7r3nNbrtW/b/bjaoy+Zwxen+v7PlvGpN6P8sk+b5//8gyZKLHAKYJIJtKAZHT4Dmvf15og+TuSfIlTBzGBGQ6IEpjaL2iGf2JsvsbNamdbiHYxsipOJlQEmyby8ZHu9ofc2j+SUgL152fxwp++/UyvWLFixYoVK1asWLHgrTr0521ySeA7f4ZhpWCyvK/RQCllVrUVUpqIaQJStfq0gqVKFEYzIFMyGA5mNaY4RVx9reKqum4YMVFKnogxoU7JWogxnV1SzJQclecxcxhGpnGAlLBSKEVwqrRNSy6ZVAaOpyPBNby/2RBT4jhFxjgSErzbtjSNZ7tVQuNwoae3hjJ2OPU8nEY2m5537+9QUXwbyDlxd/OOnEbG0zPZMho84hzeG6oJY0CzwKg8HzI5K3HKDGPBTOn7Lcdj5BgLUR2nkjlYIZLpO+Gb9x1f3DTcNMJntxuaUAnhhBCLkAp4b2SrSrOQjBSNqEYsVlV5akwlMxTj+RgR8zhZ4o35Xjth2zs6lMOYeB4Kf/XLR573f8d/9Wff8JMf3HM8Dpg47m5vKVbQ0BBzwrtKPgXnyHEklYSo0fUtQ6kq167f0rZddaTyDZvdPX2/IVutM6lAzplSCuqE4+FQLVtnMi1bZhgGuq6vpVV8Q8oR7zwFZbO7xTeBXBL7wx7xHhcCU06ICptdT3w80W83CJG+bQiuwUmgaTzGhA+VEFVXLZTUCUKhlIkiLYiQUuI0jjOxF7jtd2CRLUYpmb7vCD7U70qqClNRV9WKIgTfIqI0PtC1TU2oNkgx0kuPWCKOR9q+I5dI2zTknHk4PNFstnjfsOsbShHUEs4GShk47J85nk4kMm3Tsw0BZCI4w0vCEHIxFvtWnOB9oEglKNV7TBXKvK5jrroELetD9jIGfxlrLjUt68KBqpJttmxNhkl1IkOq65OU2dmImQydVbH1Xtf1BCugphQpM8tpdX1Gqt9VdbIq5/UAEa3NNDuvz+l8/gtZyXnt4vwbhy7Z//8SP6krVqxYsWLFiv+f4l/I+hV4QcZcKK1FCXaxSwSYrSvSkakokg74r/8NOUecazBXlU/av4PpxLj/lnBzz+J3f01+Mp9XpMx14xSK0Nz+EUOJTL/6W/r7P8YjvKBHRPiEW7jm1uRCrOqsPjxPt6QSSTaTjDITjjbblp6VbEtYaYtf/7x1IdDOfZgpXWFm1ZZsNeGaSLqo0a5sPef+O6l2n5YiRQwVSHbZByrhqNfdXEhYOw/lS2p5Ie9Uaj+pysnLuL2ur/jyvK9z5i4T1+vbMI8HVxNam+m5M8l42VessOsbPr/rmI4faYJA68D8zPIlvH3kJF/XbGK4uh/zObnQrdf9XFSmLynWyz7nc1yTmEvL5WVj67iAuplkzQtV7C5juHRwntjXe3BNVM/3Xi4jZ/P+qo5hjHPQHF58Jy6q3U9Vkqr6YnHkher2ewjL6/3//Qk55Uy7imFnW+P6Xb0ep2u8eH+lqhSpNTOiCTo/HDI+YM3nZHUEM1JSShDaEGCMIFIzVQHwWPMlYfxAar9ABcpsOIxCzoHWEnZ6oKRH3O03JGo9kjE9o03PYgnNbAGrVn8TyidPy4oVK1asWLFixYoVFeckvSuHloV+XNSTl8S+1w4uIFqVUed0SyuXnFfKTFTClCtR6URQB23fEJoe8Q4KjOPEaZgIPuODp5TINCVMlJSEacgM00jOBVWjDZ5tV2v2mSRSqvHaYYykKZNSpiBEMyxlWu8o6ngYI2OZCE55//6GdoocnyIpJ1IpbJpKWsUUMUnc3d8xnCZyNj7fbECU29t3iFfaxrM/HCgGm7t7tAlYHvii7RHLlDyS00jOULKSzZ3n6P3Wz5aWgWHM6JhompYhJh7jxJiF203Dv/q84cfvb9i10G8C210HTklWk51zLjRW622WVCimNLkwji0aC2WaEK19iVPDh8OJDx9rf9sGbjtPr6BqiBqKEZzxrld2rXIYCz/fH9n/1d/zX56+4j/7ox/w+O0voLxnd3NPGiaa0BKLAKWqKmPtbxozTn21BlbBdy2bmw1hu6Fptvh2g28q0RmyZ0qJVDKiAdXA8+kZFaHb7EglMh0rSTnlTKfKMA5Eq0ST+i2bdoe4wBgnkEITOpqmYbe7oW1a0niia3tygW3XgRVUwbna95QTPrhKwKqv5yUxDXvEOSRYrQFaCj6081qE4rst03DA+Y6YJjZNhwFjmpBScE6q5WrSWnNzGnl+fiK0ga7vli8Z201D3zmcGNu+Y9e2tH1HUsdUCtvbHV1oUVVSyZQ08rz/yGH/ESsTUGtEet/iRfDiiNlxiomjjXhXVbAmDhOPlXlhwxnqqYsT6hBTimolV5dE46tFkCXhXKUqRJf4vtq3gjmBUtdGnGgtz1McJjVBIc/rbwigtZhSsVpCyEolKJekXczIlPN6TyGfry+akQziFDPFiczlecC5akW8JGLXVazak2I2J7LX2rdLuGxr3LxixYoVK1as+B34FyEql8lTsQspeSaD7EJXXoi4OgE67A9IGVHLhNAyTSd8W60wkFKzEO++oXz7t1i8wftAmokbNZsLc+uZ1KkXcKgWcjIsST2VQhFF7C1KQc6k0qV44MwNXcWU9cVy9GylsQSUC9G0UI9nteeZsavXWQLLZaPMNj7LxK1kllqFKpwJyQtJ5M4s2qJM81IJSIcDSwT1mPl5/3msLsNerWnObKKgS93MubtnOulK0Zgp5xIqV3f8xdhcAu56txei7HxrbB4+fUXoXZ2xNqsa3FwsZfPV+NZ/v/rijuASxXua4LDssRKRAiV78JFskQnPUiP0bB/LwgnKJ224vP8edeByb/S1+m95xi/vl2s6HKnk8z71fi+DcWVLfDV29Zmqz8ZCajNP8IXLsTEVlixJ75eMyJf9WWp/llJmwt3mr4qcL3WmQb9HMXk9FqWUt8fmk/2vF1leKzJfUsGX+pyvzzurSecfFCe5Ev7i0fEjpfsMZA6CODHha6ikDVoGRAxnbrZGcmQHGt7jx2/J3Zfzfa63NYvjeHwkRSXcfoOar/V82i35ORFU5zWh2u6Czd9/4HcPx4oVK1asWLFixYr/iFGWoHKJwWa71zqVvCQPLmSlWalzTtM5mbXMdeB05iln1ZOBFcFUZiJBqu2k1fqNAaFtW0LbkWIip2oHe3geEXVVlSgOUSGVyBgTKWViHPFeaBuHucAxlWozO0SGIQOO52Godp9aaJywDUbfKtuuRenQAiVOSMzcNh25AWcexJjGkdjUGDgeT8RNw+3dLU9P1XLUNx3ZjMY3NE3LzmAYR4Lv6e9ahtPDXJqhpd/cgBklZ1SVYRxxY+awH1E8bafkXAidR06e0G8YTg9kCn1j/OC+40df7PhiuyG4Qn/b0GwaplTAPClVhxbnPaogeNQ3DONEyEJ83JNNkNCjCaY48nQ8krKjGByHjEjGNg6v4MwIgBTDOSFo4d47to3yfMz85T9+IE7Gv/6Tbwj+hODotztijATnakKyKs4FzGfSOGHZ2Gy2jMcjTdMj2rHtKuHbtA2lZJwKKU2MpxHXtJg5hjEBgvOBEDqeDs9M48jn799TJOGcZzyNjMOA6wNd16Pzc+acB1PatkOluit5dTSbDVYSw3SiJAMyfgNYRiRQzGibQExV4elFGU5HVIzQ9agLqO8ggg8d0zhgRYixMAyVhDcJpFLj0kKtnVgtT2eqzKrLEwrdpuHufkOKkTQlrFQ3nd22Z7Pt8SFQcGCOm80GJ8Y4Hpli4jQO7PeP2HSibzxNv8GAFDMJAe+RJqDJKFEpWZliRCyjaqA1aTYD4pXG+dlNyiqxSK1zWhWHVMtVqWtEl7h4KTkyu3mVutZUZncgK+W8BlNLXCrOOYrVNpYXMTfkRThZyvw7U8vPLPUlrVRC2aTayuq8ViDFQPTFGo+YzWs1ylKkxpiFBdeOTOc1B5mVoytWrFixYsWKFW/jX8z6teZR1W16Xs6nkmPy8rhqOzHRNJ6AEccIdsJN3xG6Hgn3iAhZciUxP/sTht/8PfLFn+MW5dvMszipk9JiDkWJ40fi/rfw/DPC/Te43R1oVwmcRUU5E18LdSVX6sqFNBSAmZA683rnTtkVgVQnZCJzVtu5VuOsDzwrKQHcHJvOx5+zaC/nk/PEtLapWr8u769tbzmTTYvtp4jhm4BNjmtVq1xNUs+2s+d+2Jlorpvm8b2SfepyrTcZmct5X9dFfKk8nLedzzWfzZgn55VQLTITadnQpc9Xl+2C8MW7Lfn0keJn25SsSKk1U1JMqDqQPTHfU9Wpcrm+1T5+SkbOWYznbEV7MVZ27ucy9FfF7eexelFvcd455cyi3r1YwV4esoVDXdR6qtW+9Uyec22le2lPsZrNqb4+cwpz4PPSynZR3C6P7/I865WK91IP9FP71deWrqovyfPz6Mnb5C1nMvDS79f7ydX4vIS8eFkAUuFweCDefEGQQHIFLZmQT4yup1jmrnE8pgE5fQdiOBcQt6WYUnyH0MPwAde+J0nB44jP/w7vMv3N1yTxcz0gQ/wWS7+Zg7NLAKbzOJqwYsWKFStWrFixYsX3YolFKuY5+BIXsCR71uTRUvKswFSMOWEz13igUGOASiYmYspkMyQLHo+Kx7tKSE4xU4qAHNlQLSILzLXutNq85kLXBdrQEzTQSOB4fGLC2PQtm11DtsIwTuyPEw9PB56HiedxYjgd6QXuN4Gtb9g0gZvbDikJQWjbjtPxNNevg7ZVpmNiGicaPJYDPgjeCyUNpKlhu93ym19/QKdI2/U0oSWZ0vY3qAs19u+23Gx2pP0TMQ4UU0K7QctISROu6dA8stkp0zgxjkdSEZI5shljziSr5OrXtx0/+fyOz7Y9IQh939I2fo4ba73D1hlaatwl6nChwSzguoYYE+HWs9m8p9AR9xPT/lu0PdLZSJwmYjKOI4gKu14IczZ0thpPBO9xarTeaJzncV/43376Wx6OJ/7Nn/6AH36ZaYKH0JHQSnpmwWtL8YrZCArNpqO/ybT9juJafNvXdQQTUhRC5xmmEd/2VeVniZImRJXQbPCuIU8Fh6dkoQk9h9PI4XDkuD+y6TpEwGmDhsD+eGCIiX4TmIYjNze3+KYh54mtV8LBI2Wgazc4DTWWyxNliqhvKWkixSPOQ4wHhtNAGHe8C1ta76BU4lnUzbF0ItmEmdE2Hc63pFzIOWMCvXRYrikBKWUQpe92jKdM021Iec8UI2mc2G56mqal4MnFoxlC48GM0zAyxRPjdCROI12A0N3Stx3e19qwORcyQhPCJSG6KGpSbZRLrISdSbVqloxYTQJQFNXZ6lWqU5BTRZ3Oaz21Fu1Sl/YalcycV1+KUGZikiKkec3A5jUCRHBecVkpaSYjc61BWVJlJrNUotKW5SarSRIUECmIKc50rv85pz9bqdcoQkJwcq5UCcXNCspakmlJtC6zHW9dHdNVU7lixYoVK1as+F78s4nKOeYAKhG5kCOX3K/rFy8VVCJCmY6UXAhNz5iPVQHpNohF5LufYi6gmy+gu4OS6d79kPjxZ7j3P1nSvVB89dMvQjr9ljx8xBk0ORK++Qus2eE+/LQqKvVCpC6ulHK20KltXIiqCzUll44sSr9zp+T8sh6xZMCV6sfxwrLzQgTauYZjzVhboFoDojMxZkYtT3mtNLML2QYsNQpEwbu5/mSZM+xe8YovLTyv7p7I1QhwznK7vr/nU70mH+WFOPIFWfliv3Pm3aVWwXJ+m/9ayDKvtfh6Fs51Wa4JwC8+u6MLMCYh5wJiFC2YB/KiTjV6N/BsiyJR54DsMoYv2zxvp170XOz96rNzh7nU7FyIv8VO9fW9XnBNal/UkS+zG5dxLrnMz6DULEedR+pqnMCFeUYAACAASURBVG0Ze8C5gFeBEl8mCFxfX64YUZNzXdBlTK9v9EKrl7OK9yUBfT7md+Cl9ezS4rePudzb8uJ6V3tUglPAmYI67m/ueIoHUvCodNRWnyjujq83e9LBIypYe1/rmtqApCdczkQRvOsRdeTTA767ZXr6RV0k6GsGcKapC0Mopi1BC0aZqfTll2ImV69+IlasWLFixYoVK1aseI3FPWR+B3Ax6rEXQQJwSZo0m2tP5kwpta7gMk/OuZBSouRSrRpdJb1oG5JmiqVKUk2J4/6IbxpUPeqUbhuYxkjJmZgzGuOcHJpxCpu+pe+aGnKnRBBopNAKHGOiLQmv8G7b0bWOpmnIEhhHR+OrrWYILf5dR5wGCkbXBsxglEjjjSARshC6jhBaHh4+stne8u7+nsfnJx4fH9ndfEZwjmGc6LuOcdpzOiZub+5x/Q5EiGkkhAYzJanHpkTbKeMw4ovQb+Dj40fGqdrO7oeRWIxt7/jyfsvdJtC6zHbr6baKiZFRQheqJ4sYEgvDccIopHQk4xiT45SUREMyZT9mhgn6dsuf/fGfM6SR56cHDs+PnI4nYhqZoqPpPE4K5Dir16i1J4Eghc57vnua+Pm3D1CMw2HENy13t4bpiDrPhCDqCU2Hb3uEggsdm5v3ON/gfYfZrJTNhRACJeea3KowxgnFXyVBK0XABcfpeOJ5v+f+/T37w4EUD5COqLxjv3/m/fvP8D4wxcIwZoY4sd8/c393R9M0PD4dsJzxoYMCXVfrQwav5JyqMxGAZeJ4xFDilDju92xUMZsQNZq2Y0yRVIym8RQr9P2W8TRUy1gRYozLVwbm2q1xGmf1a1WwRhFKgo8fT5wOB7Z9i4njMGT64DFTXM5oyZhlrBSC84T+hub2fq7naTOpaDRa71We11VSKWdCMjGvAWk4f9UFwYuiWm1aKRmxgopHdCYB9ZxSfP6duITer9WJlyR6E9BSrVdVoRSlujIZJdc/Kg71Dk2Kxfq7YbP9a64Z83X9Q/K8vbon1XZRE/Dn3Zhdw8wUcfO6SZFabvMcExuzzrX+LXO8b+ch+b1rCStWrFixYsWK/3jxz7d+vSZjpBbhrqRXOc+xFiWXo5Il11OSMh7JcSC6ic3uPeo74vRTtndfof1nGBEbJ8rpHyB0aPue0DbEw28Iu69AHTmfyE+P5OEjzfYdhB2NDdj7n2DiyZKxkmeblgtdulhf1rnXGzafCxO0TBTnbS9qMc7HyawUMykzDWdVibkQl/N4iAnZ8qy2vBpDES6aywtpsyjq6qT0QpBe223Y8ve8n4qSymK8UdvyYho435MLWbk0oxJn12TmeUzOx1yueE2cfvpY1M9e10I8D+sVaTfzwvW6y/zVKmErUjWgqkqmTpAV4f39DULGqREc+ODAajbjYk1SMIIWupw4FT9TznJZEbAr6txe3OUXFrdmhnMKZuTCJfuZywR7GbvXeKkuvdxdO79a3s02v/Mxn9RgNT1z/XauR1MJ2ZwKZkpoAjDN4Y1dgoGFoJz7uQQ1lWibSfnr7+UVYXutcPyUPPzd+PS4S88/tX99+Ry+JLqVmtJpYEqlC+F5Mu52nlj2ODmxzx2ehvt2JCfHc2lrf0uudT/cjuJ2mGXEJmR8JuQRmx6Znn+J72+R7VdY2ZMtzfa5SqaQULxTYo6E0F65PyuUfB63laxcsWLFihUrVqxY8RYuTikLrmf7S1wnM0FQt5dS5/4lF1KcSCkSUyTnOZ6cT1FypkimSC1P4XwAhJwNN9fCy6mgLuO9J4SANQ1eHdNUzzsOtZ5iCI52s6ktUiEBogIWSQWGlBmmhAl0bcd2s+Wmd9zsdphAShFD6TY9rlHaTcs0CsP+hBQHJHKKFO9Q9WxvbjAX6DYbUjZOhxPbW8fuZsvD45FvP3zgq6+/ruNgsNve8fDxW6bxSNfvaJ1DpyM5TYSmxbm2Ji+KknMllk5jJuVMAYYxcoqRTOHdtuHdzrHbCje3ge22I7SBQq3vl8wtpUApmvBBCC7UGpjFE8eIJGMaJz48PDDpFtENeSxs7npu797x5WdfsH/+yIff/JqPH7+jlEw0ITiHWkGkVCJa67ZMpvfG13eO3+7hH799ZIgju23HH/3wK7a7LcGkusSQaO92dNsbUoxkE3y7QV0gNNWiNU4DWCH4KsPr2g0lRSCTUqGYw4qnFGU4jRye9+z3j+TNhs2mRQWCr8/Lfr8nmXA8DjQWmMaRnBPjEHl+PrDd1FqYIORSa5YG7xD1OBViHFnqVZZScN6BGDGeUDHarq1Ee6lEWMFo25YYR1RrsRrnPCkPqAuUYrMasToYlZygGJYmfOtIKYIlxAoP333ksH+mbQLbbU/KRuMCqKcYeOdJuSqRSzF2uy1NE1Cp5GoxI5eM5QhmxJyJxaqaUJSmgaZRSsqMKTGNudbgFAjeI84jri5IiVLdtUqiJKOozrVLFXXVvrU6ZS3rKtc2sMzxvSGlzNarl2WryzFLXF0Tu3POc4Kzm+9PxgqVqCzVOrdQScpSCqrVOtepQ1TJtqyLuPr50g6sWhFbvRZWa13quc1z4FzknGUt12thK1asWLFixYoVr/AH1ai8EB/VshPqpOiagrgojuTMTRiZaTqwbTw5J5p+izU9TftDnvffsg33SLdDnOJ4D/FEOX3A4kg6fajnSROSTrQ3X2KbP2V8/Dldv6Vs/gyRVBuYlVIyIn6Z07GwPjKzZlXFuGAm92QhtuRMplVyUq4mgIsMbiZo7VO15bU1qC5qyJmcWjz6L3RVRZkjomoBOo/yFeGjM7EkRs3Kkzq5VKqVx5LdJ6ozgXb95+W0cCHZFnLoWkV3GZHan2XT79HSnY+Y0+4wDL2aMF8P6Nk28zy+dm7DNXmmUgmrIsa7XU/jjkhuyOORx+cHpv0zYym44AihPtKqgksRsueS4ifz/3ZuZ7E6uUYqnblYpZ6Jxjp/n5tiZ6Jvua8is852rvHwWoH4kvSV87hc34/zJplVvZdRvBqv+qgtBe9BSMXmIEzxQZGpZkKDYDKTxLY8bZzPc/4i2KwavvpoITtfPCNcSMTrZ3rJ7lzeX+//Sd/Pz9HlWVzI72vy/fq4M6lpyy+I4nDEKfPIZ/T6wD4HbpuIL0ecKr86vaNRh3MZylTtcGIiWDknE5Rmi8UAac/mpiPrjjQ9kPOpst0aKNoCSsaxaQOPaYKmA7NLDY/5uTw/GytWrFixYsWKFStWvEIpi2PKpaTFeW5+/XqJ95ZSC1SrxRQnpvlPmsZZSZmxfHEkQSuR4F0giqvEA0JOGTBcCCCOZAXvHM4rnbYYPeM4EEKg6zpEhGEYiHEixaq6HIaJYRgYp5FkE4Ky3exoQ8uUEk6Vm5vNrOBLOC+IglPPzc2WOH0kp4kikVSEcTJirrPoqs5L9LsNGibGcaRpe253HePpkd9+KLz//Cuca3A+8O7dF6Q4kUtGXaDb3iFpIlPqPN4p3gLBw5gnQmhQ5zhOA4dhIuXMtlM+u2n4/K7l88+3hN7RdBuQZg6VKgnkrJBTApdp+kDQHS7sSKZIE7ERTo8nhuOBf/3f/Lfk7Pif/6f/kW+//RVd19P3W5BaUCIET5pmhZurMXIhY1Itf51lnHd4UVonfOGVX5bCz54GNn/3M9SMH339JdubLeIchieOCTOPOFfXKJyjabpZQTmRUmKz6ZimCe8dIoFMJGeh63c8P+3p+g7KyJQiJU+QM4JxmkZEIcXIw/NI/Hji/v49oekYThPeN2w3PdMU8b4hp9nONnTkYcJKpnOeKRl925BtgDThVTCnePXElBEtbHc7QtPVupdFKNnIVuj7DTEliiUsGzGm+uxbbZdBJfgwTscDQR3FBEyI40gpsN+PPD8d2XQtu+0GCjQhsGn7uoYiCsVQJ7imRX3AN7M7D+Cc4EVIqTDhiVNC8DVKFIfzjsxMwqviESw7SqlrHaoOM8EyeF+/1ZDmmL3W+zQCWN2vJhJzFWfLOQH8Oh4/lx5i+T1RREpN3taZzJxrTeacidNEThnnXCUvU6LYoqIEm9eSzAo5g3M6r80oATevORmUguFACkUckt35N8hsXqPSuc6u1bWrq8U0ipVPRQIrVqxYsWLFihUz/gBF5fmvOcaSV5+9RiWsilXapBz2tEEoU67Kxv0HTCa2mx22/wXxcaLdfU0hV4Km7SlpgnIi/tO/pbn9T+juv2HIII8/Jdz/K9AWR5oLohdkrjSHuDnuW4iqhZiZrRyvSJGXhcvPneP1fOqaoKkTR7309JX67IVd61yD8vJeZjuNS93E63qR9uoc9vLE55c1861mFlrxQEFFr8jHhbh82fb/kGniNdV53a6FbAIuar0zkfuKIn1jYvoWySXLRebT6JwlvNu0xHFk/913/M3f/DW//s2vOSVDwy03HPn8/Ya7zz/DNQ2NEyTLbLG73PuXyl5lYbAXArPapSxtyaVwjdfPykWteaYDP9n/rfcvH5GrETpzc1fKw+Wlzc/r4lhsnANTr5+S0a9JxMvAynl8rxWOV/T7m22/3vYiUHrj/n163PX343X7yguy8qVit1weBhOKgVkimXGwO271kVIiTWh42GcafkmblckrlAGhJ/ttzQhHa8B4fOQmfOS0+4robrmTB55jB82GjX3gOUV0OkEpZOdqKJr2NNyex/CKb5151DXgWrFixYoVK1asWPEWZsXRlfPJkvC7JEme91z4SpZ6cJlqa5krYTmNpKmq2czy+TgnrhIUBaDgvFJSPWHBiHEi5oSGQN96EGi6BsEhCjFFTuOJHAv75z0lJ1QTSiHHTBknGqDTGsvedg03u44iidDV+pFeHdvdHSlHUpwo5sgmdJsdaRo5HSvJVNWNBX+MNDbiWxD1qG8JEkkp8u72HcfTCQ0KYrjQkLPRdVtOBeI00PU7vG9qXcA8EuNU418piGQUq3Um+55hnBhmcqb3jrublnfvtrP606M+gNY1g2IKOZNzrupABDTgwobQ30LxkAe8wWmcGPKO3Zd/QUmF3e4vSc+JfDjy8eGJIUc06Jl0tiL40IKvsY3TgkpBVJD5vgmFG298edvxi29H/vG7I334DY33fKVC03c0jSfnTCpUxZxTurat6j3xFJtmMssTUyV/p5jJqZYOSTHivUMV9ocDoWm42d0xDAP9dss4ZXIcyDmz3x/Ybm7YbrbkUpjiQPCB4APjNLG92SHO1xI0qary+q7FubpGEbwnRUFcjed1ju1SioS+pd/eoW6sdsXKnGiupDyvsWQhp8g41PaklDmNIyEENFtVa5aCBA/OEdNULUxdrQXZ9i19JwSn+ODpNm1N8nV1rURVabsW5z3jOJHizCrO+cK5JFKsBJ7gUS/kDFkqEee0wYrHeXAu40MmpVTJwFkZDTY7/bhqmyqKqcPEwaxcdK7WgqxjJJxrVr4Vky/p7+ePbP6vnBPozYxcCmWO12OMxDyBCT540pQopcylgxaickmuL7g5Zs/z+ZeVApFa81JFQKXWwoVZSak1gWJesMgmIOXsILZU5F2xYsWKFStWrHgL/2yi8qVS6hUBdvXJC9hCEip52tPcBMZsbDctxzTiXYduvsZ1d7D/J4ZhT/fux0zDM/b4He2mY/Pj/xqfJ05PHzh++3NEJsLNl9Vh1c+V5MwwFSQbgiHO1zp9ulSZW9r3VlC4KL9e12N8qfhacF2f8PvrFM6z3FfXOysa52i1Zle+Ju4upM2bFrXzaNfMuULjPZivk0y7Jtau1X5cEUMXsvItNSCv7mm57iNL+8qslJvHbz5u+dTs02fhdyrorsZoYYUEwc0Zgumw5//6q7/mt6cHbt/fIwd4/O6BLzYDj79+QmLm8598Q3BCtmo/cuYBl7Fd+nS1ODDr/H4nWfdJGxeynpf37vuOf6u/n9TMpJzP972KRbkQ5OoULTWwE7siT6+uxVUPzwT4q4WR8/V/j5Xt7yMm37aMfetX4e3+n6+n5yfo/AxlHJSEWq3HMbHjT2+/429+OTDpFg2f4XeRe9vymEay3lPwiKXa19O33LYPDOULEhsyxjPv2bkPxOyx0uBdqDY8acQk03rBnYZLG1/cq5WiXLFixYoVK1asWPH9OM+Hr2KbJYlyweLoYmaUUlVQi2qyvk/kNBHjyDieiNM0+8OWqnKqAi2ceBrfkE0Qr5TMXEevEmWNGJ5aRy7FgZwhlszheOT5+UhKmeenAylluqAEVaaYeDgeETzbruXuruHuRththL6/pWt7slEJQjWCBrwLiHP4LlQXIcvc3W0p8UhJI7kIccqIVEKt22yxDNM0YRmenvdsb7e0/Zambed6ebUtJhDHSNfVGCEXQ8XjtZJKS+KvqpBSYr8/cBxHYsl4J2y7wLvbntB5zCvaBQSHoZVcM+aEZ89pjg2dayC0aGixSfCuw2nk+enI09OJf/u//6+U6UiZ9txvN1AaDtPIt08PnKapEjrUmpFmtQ6oF4/ECScZk2ptGoKjExAmxArT5Pnlx4m//c1HuqaSWLc3O27feXxjhNBUIgrqeod4soFqQLUhZaFpb2ZyaQKqirUUo2kapnTiNB7oNhtOKdJv37HZ3fPLX/6KvlGeHz+y2wb6TkASD48PSDG29x2iSvCettvgvOP58YmSJ2KMbPsWVWGKI4OcKGmqibXiaypqjiC5EuoYqOK1QdVRzEglM6UDOVUV5WF/YIoTpWROpwNTnK1aG18Jz7lGY9M2WM417tMG3zZ89uVnxNORxjnaTUPTtah3Z1JXpNoWpxRR0WpVO42kmFHnKQViNpKlSgrPCkRFCMHhgif4hsY3ODOaUOb6r5EYE2OcSCWTsyGSKgnp5PyTIIvqcFksszlp2RaL55dqSgCRus6FzUrHOQF9flkTApbfk6UupRkpJVLKlVT0CmqUlEk5zcndNW1bfL0PYoXi5XwtyGAyl8JUxNfE4nMetVJJylzmOFmweU2m9lffyltfsWLFihUrVqwA/kDr16sl+/Pcatl8vZh/3tvsnLHZNhnftEwPI3n3E/LzB9ruDo4H0viM9zdM5YnTz/8Pwt03hC9/AjT48i1H68nTCRdu8Z//51g6oacn7DShzQZpbxECiRroyWKhYVc0pVzad02snNWOV8UKf5ey7Lqm4yckz0IUni9Zp3ALFWblyq7HcWZL3ySAbCHbrgJdY860s1qgfZ4wF7FKVkrhkoW3ELBLny7nWpSVIkJ+g2w9U02vCCijZtKZLSpErdaz80E6E2EvNYxXhOh87hdKuisV6UIc1m01E9VhPH98ZGhv0WGksOFmO0Iy+qYjjpnjwzMlpVkfWa1KjLomcFF8vrhNiF0FBy9bezUCL8ncZTy895S5XozBp8/Bq/G7HtvX2wH0bEd8yVx8ue9s5WKKiRKaBl1Uo4CRzySyoFdq3UX96TCrtSpU5aWycl5AkRfX+35S8q2+vL3va4vXa6Wqvnp//f1avqjzni7ggGIJr8oPbg/8eg/93eekY8SK8fSU6LJHysR2+g2j6ylsiaff8OU7zz5+zUiLWCakEcmRURzK47xutEG0ZWz7+rvhW9j/CrOqCs9WcCx1VesTJS+bv2LFihUrVqxYsWIF8GkM9VYiZFXc2VxTrpBSJqdYVVAxntWUJVayckojOUfUMskyHg9odaEJvs7mTSlWrTwbJ3jfIOrIGcaYGMYT45BJpV73dBg4DAPHcWKMGT/UqGBKhZQjG1/YbHved56+Cbi5VEmmIE7pmp7QNjjvqxNKqeq9ftPyMA2oy7y/3zKdHJZHvBopR8ajsdnBze6GxjseHx7ZPx/xTWB3c1/HpCQaF5imSDEjhC3DaaJDca5a3IpC0A6TAReqyk1lYhqr7WW2jCps+5a+bQgOnBQoubq2YHXcz2rWWoPPhxZ1Xa3/KU211fXKVITffHzmn777FT/7X/4HtBS2wdH/8Ifc7m4IcUvKmfT0QCrVltOyw7IjaEvfKrQD5BFJieAVr0bjDclCccb9Vvn1XvjtaPzVv3tk17b8KEUa7xF19Buh8Z4ijpwEneN/NU8TtqiA845iieA7shRSGhGpGrcSI13wqBnDcGS7vaOU6sSUc0YESkns7u4AgRzZ3OzYn/aIOLq2q2FcMh4fH+brOHzbkkrGXEtWQTRUFaNotVf1AdEAZkynE4Wmjq0ZJY6oD5RkxJjr8z/uwSCnwvGQafoNMU10oa7zpFzYdIGSEinGukaRqz2riMMk45pA27aIVKWvE8MsVrKSjKonW2E8RVKs8bTkqkhUUbwoTkG94r2rBLY6TLWuceUIQPAOhyISKvGKksaRMRlOpJ5DDJVSv69LlsEck9c1ImEuBsm51IhdXLmqZWy5+g2pqmvmKquVTbXz+lcqc63WXInLVDI2zXUrRbBS61mKVJLUsuActU3ZMPGogRWHkfAiaKHWBRVHNkNyBnMgDl3W3UQQu14ni5VQX7FixYoVK1aseAN/AFH5xgTjBafwRhAmlawraeLdRkC3OPeEuI6cR8Q1WLslHT4gp5/Rd7dI/w3Pz9/BQ09z/xnx+SMle9qv/oLx6R+xcY/vbijtFlcKlo+k/T/hzCEhoGKYc7g3mvyyfa9sNaTWRnyLcHqpLFv6eSG0zipLWZSFswntXMfwrev/Xq9+sbMg7rxJpc5BpQZZaoJJntVn5apJFzvWiwZMqLPffJk4fi/JdGnj95FwcCEfl/GoZyqXDEEW1er8+nf3uEJn8nZRVip0TUP7/IHvJiWlE2rfcTid+DAqOyc0TYNXV7MHF5/UK1nnkrHMTGXK3KaLSPj14sGn43Dp9Wy384rQW/4tyzPCZfvrWo+v8fpcrxc0liEsZMYx1cxPD0xzMoDIVUJmvb6i5+xKmWulgHxyE+z6GbNLe99SgL5u+2si9vr9mXB8MXL130U5+33PFfN3B0CdR8TwIvzwds9vh0AaYdBbNuE7jgWkucdOTwwpYHIPpw+U0y/YbYVhuCenCScDpgE0YG5DNAF5R5h+Nn9bPE5kJnQ7OvXEklGp169xoZzVyZ90b8WKFStWrFixYsWKF6ixlFxn9Z6VT2W2tUykFMm5/jud61OOxDiS4gSWKrmWai3AYonGKcUJsURCCHjnq1WlKzitSZAmUm0sc2GYEh+fJg7PR2KK5FwYp8iYIqkY02R8jBNTMsQyt52jUQhmjOOAKGybFnUNzvWYKOoaUi40XYPhkVJjw5gmmqZHzDAXsFI4nU5kKQTfcHg68cuf/4If/PjH3NxuaZqR8RSZTifG00DTKfv9npvNzXl82rZjiWetCKHpGMcjOQ04B94J5vUqAl5sNQtNqPFbzgLFYTFXBaqbI7ZsFIxshg+OYopztRakupkUMmXKwjBFLE1IKeRinJJjGCKf3zaoF/Zjjz88A8KUM1GMU87sABcagiqSQCrrQ3AOJwlT8MHTeGMXJoax8O1h4q9/9S2ND/SbE9r2tH2PF18tPCVRcm1rtlzdmqTWe3TqUOc5DU841VrHshjqOhpniCo3u1uadkPbtDinIMrzfuRHP/qGru2YJqPrt3TdhuHxEUiMduJpOPHZ/X2N/1Kh3/aUXNWHfdOgZEQbnHdYKfjQY8VwtbIoU6wxvneebFrrOsKsilWm8cTx+MRmu6WUhFlg6wNxSmB13cW7+owPw7HajOqstAyB074gOLxvQIRskTweibkQQk9OmZTBLFfr1zTifcD5gMWqNvTeowoijuA9ITSA1u+WcE40WDSJtdxkff6dKk1ocMxrQ/N334phYhSjWtdqmZPT7bw2c/XLMa8hLInyeY7tC2W2ll0+PyspS03at1wqoViqshKrCfOlGDkldLZzBi6lhF7kS9c1p5r4zzn4NTPIV4neUvcrcpWMz6s1gmWNbMWKFStWrFix4g38gYrK30e2XZEzhdnK0cj5gAickkCMDA//N2U4MeSf0gejvf0x2v2A4hwWRzbdDacPf0l+9nh3j7v7munpF6go8Tf/J/nd1zhRkIyaw3mBfMJOv4Yy++vrpzUEr5WQL/sEr1nBa+JlOU7FXU1Kl1oC16TSnIYGla9bsuLs+jqfEj7fZwv6lqP/ufTknAlaqy66q9h3sdlYyBSZX1yIIs5Ky5c1K69JxU/tRi5qy08sQT9p5WXrxb5kIa/eUDe+Op87k1hCUeH2B1/yn/4Xf47/2Qc26cA03ZBvbihqpBL57LMv0DbgR52JuxqYv5jsL8rB+TafsxPfavn3kLPfZ1n6Rq9f7PO9BOSr5+u6fuS5dXKxQQWhZCOXXGtZsNxBvdyDJRCwUknqc2am1EDhk75cFLHndglnEvstMvL7ssPfzBY3O4993fZy/5fk5qffi1QmzOCb7ZGHU0ceDwyywSgcuOGGjxzGE56EIyP5QC5Gu/uM1Hb4MuG8MfobxBp0JrGzgJjQ+Rt8eubJ1QxkzDFi9J0wTgPS71DzIFbVy/UuVBXzihUrVqxYsWLFihVv4Tq+nF9bgWIZK7nWkkuzvWuq9pkpJeJUlZTTUGtTxmkgxQnLkWKFFAtSak3GmDJtcLg5WbdeIMFcDz5lyFZVauNpII0HrIyMceRwypzGQpFSSbpiZIxkuarARAnesdk2bLa+KuMEfONouxbf9KCOKU48PB5pmhbnHF3XkXPmOEWkGCqw2W6YpiOnYcL7ls/fb/nVP33k7//mb/nJH/+EzXZHTvD48B3Oez7/8iuapuPx8ZHNZouqZ5oifd8zpUTwATEIviGnAyUVvHqSFpq2xdRRKnNUCbs5GTFbIQO5CMkSNmcAx5JJVlWiVmodQ3N1OHNKlFwgK9MpYqlUe8wygSrJjOfhxPPpxP3NDTebLR9DSxyHWo5kVsg5D40XOhcwAqYZtYLX2bGITOcL1hVuN46PQ+EUHf/4PHDz2wd2XQPe0zQtbQs2K/6sZEpRRDxGJZ1Kznityz5mgg9NtWWdBpqmI6ZMCD2+cfjQkOd1hcPhhGmtISl4TsMz959/wThN4CeVAwAAIABJREFUeOcR4DgeiHEiY2xvdqht2XQBs4JIqUpE51HvKWSKTWiMGK5q/0woFDZ9S9t0xGKkbEynoRKJ3lfvnTQg1lFyRL1niglQxpTIOeGbQEqp9jW0pFRrLo7DkWkaCN5zOBwQhabvQBQnHkVJcSCmyDglhFBVkjGR4sg0nUgp04QO33WEpqWURE7VXte0rq3UeqDVNlbnZwVVDMUVaERn+98aW9ec14vbV8FQarxerMzP6LIepTPZbhfVpRml1N8OmwnJ+iefX1eV5VyDslxspS+f11g855fJ9uKqw9OyTubF4bSqtc9J6TL3eV7bsjKXbVnWt+a2AhSBxWVLsBdrECtWrFixYsWKFdf4g4jK360CnIt/L/vWYg8IQjw9cxiFogUnBumREGBzd4Pf/RFFAkXrBN21t+SD0r7/Mb59T5kekPaecNMDAruvSN/+FPn6zysno4LDYSVh6YT96h8oLhBMP1E9/fsQKwsuFrKXfYpVeww5c49L0XPmyfmsYJRqsXkmmEzmeemF9Pu+tvwuJdsyARSp9iF5Gqvw0vRCBi1qzyUgnhtxVt6hM2E4W4xc2Y0utrKvycoXY7S0d/68nBV9r0mwlyrGuv1TMvR1f02ECDQy0tqJxtXC9Z/94EfsPrsnjXvGcSCWREmRPEaenvfVYoS5yPsLZth4TQAuQ/S75sz/oYrCecObRORb57x+L3Kp3fDymOX68zerVCtS7xze6Xz3FkL+wrzKVd8XYe6i9r0+b913OdrOnwiXzM/vG4s3n41X75fg5/IcvOzXa7wkdJegzPH+zjPFzDhG+vTEJCDqsAxHd0MfRvwojKcJ8YWu35DcLVE7/h/23mxLciTLstv3iggAVbXBh3CPzOyq6u7qrp7e+okPfOAH8If4Cfwh/kcvLnYXyazKqhwjI8MnczNVBWS6fBBAVc3cPDK7qjksFs4KCzdTUwACAdQWrpx7zklaCTJxlR+otRJ1R9WAs7njmC2bLtNP7yi8JSvk4tl2PXpIzdaGplwWPKcZWwuuFStWrFixYsWKFV/B3CZ4qpPMrNlc1kItudkyptgIkzSRpjjbvk6keCSniVoytSSsNkvO4BzOGyWf7SK7vsN735STOROniVwySxxELoVxTEzHCYsRyZWSC2OMjCnjvLLtB1xwxBrJXcUjvL3d8vbFljevd1wNjikVUIeVwmE8EGYCTEzQloAHQCkV5zuc74BCniJ9cFztrkizUjSELd+8fsn7j3fcf36HSeL25UtiOnL38Y7NsGN32/IZ7+4+cnV1RRc2GK1ReRwfCEEIztN3O6iZKSXUeUotjNORaoWlpbOUjGE4VxESTpt9aSy55SOWRtRarYgqpYAWQ4ohrtEtqbTswWSVBBQMnbNA333+yMN44D/85V9xtRlajuTx2EiqXPAa2HWOTgyHUiSgkul8IThDVenFoTmjlrjqhMEJhwhTUX5/d+TF5jPilKvdFcF3VBQfhrbeIB5mZyhVh3eeEAL7/QM+bHDOEadDI7rEEPVUE0oppLRHnWOz23H3sOfFq9d03ZYpT1SrHI57cio419SEIkoIPQ+HIx/ef+DN65dUg5SbOtT7wNIZLADFsJpwwRgPE6HfYjWR00gIfSPIgJISpVaCb+rPzeaaaZroQ48ftpScmaYRK4r30KyGjeB7RDwqFeeUXBI3t9fEcY+4Dhd6kIDXHjNhmiZyjuRSAME5j9XEw/HA4bBnHPcIsBk2dJuB7XaLdVus6wldj0ieCdcWy+JdoLOWtYm2MQQT1CplJg+xOX5Fl5WW2Wa4Cs3taolMaff8uWdZTorKhWistthFlwtSsj7+suWrKYXrKbN2We8R6hxJ5Nxszyuu2QbPqtb2Jai6WVkqPFog4PxalXkNRuRJxS/UrzSAr1ixYsWKFStWwD+CqPwxJeXSLzXL41pn2GKziVLGIzfDNe/3GaeO0L+hjBNGj5ERf9Xa0Ew5fvwVXdjQv/kPYFDlG/KHX1H6G/qrb6HbwNUb0qffEV7+FDXFrNCiFTJqrQP0sVbw6yTrc4TLYjsCnB7iFhJNFlWe2ZxZ19DC7Gfqr0keUdE2B9KIQVvIF87E4VO13dfIn8Xe02YVZwhKVwXMIaV1fqpzp+zFZgiyXI+n59yKh6fPjHKyvm3jbw+zT1Rvj677TDZyqYzUuctw2c/82rzPS3Xdc1CreHGQI4EHpLbu3WIFNUHEoeLxFLIIxSnb3fakOFxyBReCdiFv5bLLj8evP82ROc/Hl/fQH1Na2jOv/5hF6uNj2KNtjDnjgcpiherU4UNAam5nIk3Fe1Lazuy8cbblNZt/Ph1KLv4/28XIzGUuv7hUWD5zzn+s4HiqJl2Odt7ux7e3Cg6H4Lh/yBTA+UDyHUVfkCq4vjUoZAau3D3GZwZvjOEGsR4lUVEm64muI7hCnz9RopB1i/mOWl3LkAnXSPwB33+DWCV0BX+4x+QFilDMY1bnvwHuR8e+YsX/k/jl5zUwdcWKFStWrPj/HuZn35lIoFayVWpJlJzIJVNSIuVITpFpOjKNR+I0kvJIyZESJ2pJUEvTWAmgFfWKE1DXaslajZRrU5VJiyCJYyROE2JGTIWH8cghjjwcE4eYMISrTYdQsRopCFfBc3u7ZRM8u21gs2nKST/0uMEQHLlaG69BSpk+DPRdT9/3FIGYMpvNht3VLfkIrmZqPtAPSj/0TKMSUwIcu2GLiOIV9vcf2AxtP4dxj/ae3fYaGTzjdKAbBkrNONdIlFIynW+Zh8UM9Y46JbrgePnimhB+IB8jg2/2rSLGMHSE4Ci14HwgaCDm1ISoALXVnM3mtWAFai7kXMlT4f7TR44PD1ANQam1RceM04iVyjgd2fUOFSPXDNpqO+9cU4EyW9K6Rib2naJqeFG2HdRxJMZK72BwgjPDTPh4zPz2wwNvrgfGw5Fh2KAhIGI4N9umqszrAAsJpZQidJ3HyMQ0ITQr4K7ryLWwf7hju7vCKozHyDRO/PTbnzJNkTFO7K6uOB6PxJjYXV2hXkn3GTM4Hu7Y33/mZz/9luMYKTnjhkAuhc63mBKprcZUNUqK1BzBeTadJ+VItdLqMBeARprVaogPuO6K4+ePXN/0NG/SzHF/x8EK3779tlm1iqJOqbUpF6tB32+gJkQ9TgXwCD0xZo7jZ2IaiakypcJ+yowxEXPmfn/k88PIYZwoBZzzXA09N1cDN7uB693A1W7g+uqaod/gQk/XD9Sup5YIs4LSq0edtgbXnKm5UK1QqmLabF+rCeZAXXMCW5qWVQyr0ixhRVpzeYVyIiOtZU7WWR38RFFZyvxvrS0rtRRKLrM17GWTtLSsSuZ1r1l57AScgjhtX6qIekRtdhJz6ExWq17+pftiten894+lXWDFiv/38cvPlX/xP/0v/0329ff/8//432Q/K1asWPFPHf/NFJVP7R9lJikXvrI9smjT7aU94eqGevcDu923TNOBsH2N7H6CdFet22vak+9/y+blP8dCTxWbd6eEN39F/PBL9ne/5vrmL+iv3jLd/S318AC7F41gMZ0VbW623aionAmFZUywxCCeicGFPFSZ7TmsWVRYM+9oHYqyZAScLTBMZxWagVwQm0supJ0OaY9IQQWqLMXEMnnPkz+PSLAL0tErdIOnxtJsN8oykMWWYyEjF3UhX3BDJ4Xj8s0S7H4iFx/nDSxjNzur82SeOx4RUspiLWt2zvVbXn+OGL74iUzBMfHq5QCuFTfiQNTYjwmrlcP9xHYbUEk4Z3MmKPP9Z0vcA2eytDFxC6F6qbJc1Ht88btLdd/zxOUl7NE2j8nL5XH9q5TCwhBeEoTLdrPSVQSOuXDlFB866oF2klYx00fbLlkTdioNLubnmexUMTBtiymyiG3/K/H1PNOn7zmfYVtcqV+QuqJKtUoRbQWsblvRX3ZUVYJUSs2YaBuvD4QK0RS0n5XGAbVKpRXryRzJfYNzE4EDpDuS21KrkKQjhB1pek/q3hDthjS9Q3eKkufL04rI2joG/usnaMWKFStWrFixYsX/77E8Ey+KJptz40qdrV5TJJVEiYmcG1mZ4kiMR6bxwBQPWIlYzYgVxArUSimZlNKpfg1zblwfAuoEHxxd54kxko9HyBMgbbtcGGPBsnGtyi4EQvDsc+ZhjG28ojjgelBe3mzx3iE1k6vHu4DTQNWKpEqtQq6Z4DKioSkM1dP1rYl4s9lwiBMyZCwXpIBIJWukpNIyI61QclMdOnXcjw8Mmy2b7dWJvO26ni44Doc7+n7DMFzjhqHVVTkiNAtXUSEE347d93ROW0OqgLiWK1hKRTSAbw5DpuDCgMaExHlutWsNwHPxXK2ynw783W9+z3/667/hw/6ObKWRlaJUA69KLpnPD3e8vt7M6wYVNXDaavOxNMVh8I6ggpYJVFEn9EFRL5RcMCLOOfquElwmmmM049N05GE8chz33NQbVFoGpHgl12bXi4FWOaltRbWRlpZBaMrI0GG18nC4p9RE8MJhf+Dzp4/87Nu3qMDHj5/wfWCD0oXA3d091ze3WDE+ffyI847dbsd26BCrvH//nuvdDu8GDvsDuhvwAs4JBI9g9F1HTDCNE2GzAavEHFG/aQTjMHCcxrYm4wOh2+C7cSaQmzq2qZELfdc1cs632tVMEXXkXAih53iM+NA1a94Kh/t7xuPEx4cH3n2+5/OYOKRCKgVqQaxSUiYnYz9l7g6RKbfPcaeO3iu7wXG77Xjz4oq3r2549fKWly9f0++u6fotXT9gVUiWcc7hXbs21ZQcG2mIVOq8PlYruKrgy6xYLCwOSGJtPcYQrDYFZTXDilFKbj/Pqsrl+3p6LTflrNn8WjnV3nV2cloatlXaXe5UZyWlICqt+V0bUakqqLTaXGdSc15R47zCZhfrEHpqsG/LYHWlKVesWLFixYoVX8X/fRmVl5ltS25jLZgUqCPS/RRLf0v4Z/+ROt5DOTaSgkz89HvEMt3bf4OYA83InAtnVLDC8OqfUw4feXj31wyv/oLuxb8kvvs5PgwQPIhrHWtVsKqov2jzYun0aozTKWfS7BwmbrMOdCak2qkpYmd15uzYAbRnMT1lLsrczXmhMlwUkLZkErTjq7SOTp7kNT6X+/c86TNTT3OWQZmfC0UdJ3L0gpY97fcJIXeCPlH4sXTwLQTZsr+lH6492FZbOuva98/jbCH6p5BYAGog5pAqxKT8/ofPpGnPq41jAjaD5xd/+4HdTlBXITtyjPz873/gzc+ulwtzOt9lihc7WjjnJp6Hs5BkFyN/pMqcZ8GM8wtfJ5UvCfDlXloe6eWC5D3v88nuFrLuQoWoohQrHGPkehCcLjmjgqij1kvV5ON81dPYnhD0J7Ly0Yk/GdeP4GuWuF9732OcyftFvfzc2MQaiVqssLHEUft27UTRkpt9kY3s3MinviM4T44fqd1LmiJ7mb95PsQoNVDsBtfBhs/snDGNn6huh6+VMr0nDx6x1BY/5kJxGXcjWP/4/KxYsWLFihUrVqz4pwczmwmURnTVUrBSSDVRUiTHiZiakjLlRIqx5ebFkRyP1HiklgnFcK7VEmUmv2ot5JiopVCjwxv0TnF9wDtPzplcEjlHmvuKUkphHCfGY6KWjAYHviXkpVIpZnTOsQlCp3N9IY6u70Fb1Imoo1idn9UrKtYyHWk16aYfKKW2+r0WqBl1Rs6GqWIZ8pgw8fSD5+7uQE6FzdBxOBy5ffmK2xA4TqmpysRxPDxQUgJxdMOWw2GkFOX69hYR8F0PxdOpI8YJquFcoO89L243hLvPWIVcHCUph2Pm+sbTe0epTclYZCYIFaoKsVRUOxTIZWRKR/7w6T2/efc73t9/INc610tztMncEAmQc57H30gi0dY523UOr+DEcFJxao17q0bXKSGcQ3RcF+hCpPPgHYzZqHhiquynQpWZZHKhNVPX1rQq3jc7UgTnQ1vXqAnRQIqpkVLeEfqOOE4EVbbDNbVW7vd3XF13DENARBjTyOvbG0oxpimR4kSOiY/7A/vDnrffvuHmZsvn+MD93Sc+fXzPNy9vSKXysD+w225x3uO8I5nH+UY+uq4ypXssRXwYKNOIVE+m4oKnjpWH+3s2w7Z13TpPLobzhpuzL11oYzSBjCA25zyWCuJJ+YjzAcQxHSPT8TP3+we+/7TnNx/uuJsi4jzOKd4Jg1cEh1cl+IJ6QCr3h8xxyoy5YlnRmnA1EyiEOuFrxouQcmR3lXEqeL/BnFFLplhFVXFO8HNeZyqVXFNrWMdTsNaM4Cuqc5O9KIq1a0tzGVpUkk1NWU+ErdWZrKxlzhmdGwAWJWVpakqqAUoVQxf3rLmH+bQWpoCjfd7tvLTX7svF2Hlem5vXvk621ghLypFqy+Jdlk2qXK6frFixYsWKFStWPMY/mKhU1R/9/Ym0aD+BBZRMiXs2EokakJJx3TUpHrB4QA93lE8PbK6+QXavAJmFSh5hyT9s9hIC+OGW6+GG+3f/J/3uZwyv/pLjD79g+PZfU0XwdmRzlRhcJtI/If14RAYtD2XnDL25OJA523IO92th4BeWnAsVOJNgwrKPxj81cq+RfUuW3SKWW/i+U6bk3JFm8nyn2ZcEz0zgWCuAi1UKUNFGzOlsEXJBVC4KwuXYC0faSOILEouzDWo7X70goGT5r+1D5ETYPrJ+PY3yyWSf3vv43J6zu61wsheJU2YqjsgGYwKFnIU3b3bN8jNlEKMIaC3EmprzrC2juBjRiWRcxvZ41OfxzErESwJRLlWhPPn+MVn3SGW8/PtEvfg1K9jTGHTu4b2Y/0V1WOts16JCUCEVTvfrko/aPn/t/M4E7dxZ+4TMftbWVc739ePr9+VYn+JrVsZfXuszib1kpj66JzBa12nrBjarOEaK3syjL6jzhHTAlQ8UhVoyx3DFJh0o40ese00Rw2nLHmH+nCACKuRacd2W3g7sdE+qibDtyGnEpYjWAiWDG1qhZdaI9NNfgRUrVqxYsWLFihUrHqOUjC02jKVQc6GUTKyJEifiNM1ZlBMpR2IeKXEi55GSJkqJWE5z16nOtp4FoTkAWSmUnBEqJSs1OUwhWWaaIvv9noeHkTFOFIMcK+OUibG0nEsRgsLV4NgOO2JqhOq2E17e9Aydo5aJFI1huyWEMGcPumYrG4WcKyqVXl17vjdhu7mmlEjOE9SJoQ/UpFTzTKakquQUUQfFhHFMbDaBbjPww/v3vHr5mhcvv2G20uHwkDiMI103YNPEMGyZjiPeB7qhwwS8V5zr8LWS4p5qCfWCD56gHitCTsY0ZspUyKlgGN5Jyz1MBUHwKlTvMPFzE27icDjy4XjgMEWqNeWm1VZLiGtktHOt1qpW+P7DO47jSC65ObqYMAS42jgGZzhtX4pRTOj7jqFXsIlajc57SjA2faJzqUV7NMqRaMb7+yN3D5HX2fCzarIWw6StAdQ6x1Q4ZYpxZpsKpTTVYRc8YGy3AykGQtdx/3BPzpCK45iEkkekVtI0Yc6TpomXL65JJXE4Tmx313ShQzFevHrB79994Ob2lqEPpBIBqDgqHVOqWPX4sEEUvI90fUcttSlABabpQCywvb5FNDBND4SuUEqrEc0E7wJYYXe1Ybvp5nUURy1tjUNdW78R36EGcdpzPBz58OETv/vDR37/+Z53x4mxFJx3XG0Er8rgHMH7tmrgDG+OXe8ZvNL7iXf3wv6QEJSt91x7x1Zb43GcRo73nxGMTpXkHLoRnOtbvVkXAk9xznDWGsxlllM20rC0+6S42UZ43mZ2BTPaJazVZvtXqDMRmWtp9tElU3L7e1BSaSrKXFsDf2lfyxKBic0xQsxE47w6sKgkl/WspTH3tGyyrDHNKwmnGKF5vcG0xSDRPtdt8LOT1aOG3xUrVqxYsWLFisf4Rykqnyr+Flzm0MlCalluxEo+su0cMbaiBNdjqRD6W+K7/8z1n/130F/NZE5F8FQqpobOieNLdp540OJ58e2/Z//h1y2v4uVb8t2vcC/+kuQ6LG/Jrv+CMAGw2a5iIRJrXcjFmcCxM6VkC2lqTwjDmURZusxsfu08Be0B02wm8+SS4WN+UJPWKWcLpdfUccvcPZ3zi4PP1jba8igymDpQh5Wlu6390yxWH+9seRitTVO67LFdtxOJtBBbT4gpFpXl4yGef/+Y7OP0/jMx+Ejd9xUspGq1TDZhe3PNq1zIxzucQd+D9444GpiS4pGboafbDoj0pzk8Z21+Oa5Hx+KxoPDx64/v9/P25w2+9pl4Dn/svU9VkI9el+U8BOcCtRaEiqg/DeeUE8tSFDQWc7F4WQj1M4H5mJC8LFKWabpUhn4NX8t5/bGfz/eZcWmI+4j4FQVzBKfUmuamgdYIIDg0P2Blj4Rrxjoi9q7l//gXdOUHxvwJ76/JgCNgUueicam5lLvUk2b7pNG9QGRCe6UcRnKesDTS+WZPtJRZhn7xOV2xYsWKFStWrFixAmgWorVSciHl1NRNOTHliTwTlDGOpGkippFcRkpK1BKRkufnzjlOxBYb2Uq1gtVCpX2NOZEeIsd4JHiHmDLGxGGKfH44coyRWozBOTonuG1oyjqpzaq173i5GRCUHCNCYbsd2G4HxHtUFOd71HUYDu96fAj0wzUxFlJKqPOYCGOK+M0GdX1zMikVS5ndZkOajO2mZ/9wz35/TxojNWa8wsPDZzbbHi/w+fNHihk3ty9w3rHZXPPdd79jd1355vqaruuoFXKZ0CQUgVqFPgScNiLuarflardl6Du8U8ZSOU4Tx8nI1jOlEZWenCEXI5WKuNYM2vL8Wl2S4sR+P5FzQdE2vzI72pxcbQAxFPB+oJbC5+NDs15VxTnlertlt9kAtcUYesVqaTmVYQPWajqziBk4cXRe8U5xuCZyw1GrcIjG3f2B+/t7+mGLlYI6Jc+OUc45Sq1oFUo1un5DSRPOe8wghB4NApYodcKbEKeRaTyyP7Z7RTCub69bBmjoudpdc0wHhmHg9WvHdNwT45HUCTfXN0zTO26ud4jCdBjZbneE0HIlc4yoQCkJasv0dBpQne8/5xBcI9qK4VDE4LDfN0IYwfk5OqYWtpsNXdfuRaw1VYsJqoEpZ0oVUszcfXrgV7/7HT//7gN/9+6BuzHhguPmasNWXFvzETmvqYjgxBjU8BjbIGw7RYjUVLBSUYHBK9fDwM1ux9AHRCoQSenIePAY0FHxvsepm2tHQ7UJRHUmCJvKsYWTLM5eS2+xybw6Y8talLVsSoOa53zKPOdSFqPk2fY1F2puNsu1lGb/WhuZDmBWwcmjdQWZC/+2BtZ0k1KtuVMtt/lpSWVuhD47vs6qyVYd22l9YWk6riyN43+CUdOKFStWrFix4p8o/uFEpS1ExrJIf6EKA2jU28LmNAJEhJoKrtsSk+D9FgXi4RPdZsf1v/ofOH7/tww/+beoVAq+2XeonrgLFcOdHqZce8BC2b7+F8T9Hxj37+nVUw/vMFNMPVbA/ELULT78bX8VWPLlFoLyRD4u5OR8Gl9zqjiTYZz2czFJJ9Vie667VJCdt7ucq7blonWz0/+XDrfTe8xagDlGp+BEMJmzOef5l4tBPyZ9Lp8zl2vE6UVjySyoLOo7nhz/JMy05fuzfedzvM1iB3J5v5xIrwsC+HKc7XG+0okwTZW320o8wpSUZIKaUKvHe6PkjKqQaubf/utbfjgon5J9sc8zviRKF+Lui+vIJcH5ddva5xSSz73+9LjPvf6IVP+SPQUEcULnPd3g4HNbsGAh9L/YVs/XYCbKFzWgXNzATYk7H/9yBuYCRuyx8vi583ku2/O53z0mh5fc10cfhRNhriYMPVzdXnOfjlTZ4WpT0Lr4CbNI6d/S5++IeotXbQVcD5O8JcTvSFnQ8AKT3IpAhCrtj4saVKlUPB4oIhyqw8krRCrV3s8W1S8xO+kxEVok7IoVK1asWLFixYoVT5FSpJZCzpkYIyVHckqNlEwTcToS40gcR1IaKTVSU8as4MVwYnPkyJwZJzK7AUGuRjWhmhBTU1Id9kIIrqkEUyKmjFIJIhQML81+0jllu+kJXcAHx243cLXbIghpalaxu92W0HWEYUMfetR5cEJKhSpQaya4nu3VrlWNZjht9XYcR/quZfVZbXVqtoqEQOiUF+ElofM83N03UmVMxFg4PuwZthvG6dAUqKWwu7klp8r19TWlZmLeo04IfsuUIzFOhK7DqjBNE11Q8IIPwsvbLT99c8uvvv+B7z7csz8adw9wmCrXGbxrvkImijltdq7WyDADVD1TKhgF58B5CEOH7xxMCarMtXfLH72+3fLmxSs+390z1sjD4UjnPNthyzevX3N9dY3WiEhqyjnAOUelUKTSabueljOX5I5IRRW8VsQqU868//SJn+5fcns7kXPCq2vZoD4AQqktykadR1SgNHcZJ4ZqqwSPhwNYnQnChHOZoTe2fQVxjWhHSTnS7bZI7bm5eUmcJn714RMf3v2Ol//ur+YMQ/AhcDgmajZwBaXQhY6SDay2czNFnSNnQdWTUwGB4HqsHAAoNWNkPr7/xGZ7w2bowEoj2aypIdV5qjXiFsB1QyOZY+Lh4SPvP37ir3/xa/7LL3/P7+4nDrnVoRuUoQgb8c2KWHRuPpWmwBUleKVXEKf03mPVkafK3UOcbXUVJ8rgA9thwG8C6hylFo7HA6kUBqv0XaXrejwtI7Vay6i1Wmdb4EwVwzk/E6WtNm3cbGMCzeS01tIaFaAUO+VSXtq75pxPn5uac9v/bDfd5k4u1jXa3ygxkGqIWlN56kJMtoUsOS8fIHZamGuLXPWyEX9uSJ9XshalpsnlOtiPO7OtWLFixYoVK/7p4h9MVIos7VOPFWVnZZSciCyYuUCFmg5o3xPv76hWGD/+PWH7gm77DaI922/+OdMf/obw9t+DK4DHSkK1DdWJfEHkCIJaJty8xfc7Ht7/Brn/BXos4Di3AAAgAElEQVT1FqxiLZGc5aHITv8/s5CPLC6QOUfyPH45UTrLJmf7zfNY3KxcvFCd2cUcfEHOnDvNjMcETiuWZuL0i/lddjoTOALeCZpbVomKo0pufXD6vHLutPVFJqXMc/E8BfeUpb3oxrtQXZrYY956JsYeKzS/JAifMptnYqsiKq3gtQmZ7VVEAk4i5maSLTHPo2t5hcxdil9M33J+f1wR+HVy8dL69ctz+Rq5+Ke8/hyJ9+z4ZvI4poIPA13nkIu79auEOu0aLT8vZPapUFnY64vbTM47YGHWVZVa6x89r+fu+a9lrZ63e5yF2j6b7fdjLARzOA8HeswrbrxrVr/9S/zcrVnmbWqNqG0wMWL3LX18R5ruqf2ufcplLp7QVjSaUXHNUqsWcD05RWqc2O1uOMQRMcHPfw+MubD7yqdmxYoVK1asWLFixT9txDi1rMgYmaYjJTViLcYjKU3E8UiKI3FqRGW1DLUpKIs2wsQ7wYeAd/NzqrZatAsFBaZaiRVyzORSCMkxBIfWgi8Fr47NEEhWKbXRCH1Qbq46dle72c7VYwKlFFzwbDYbrq6vcN6DC3jX41QxFfqNUo1WZ5dWSzvnsEqzhcU4HA+k6Yh3HrOEUFH1WDWmWBj6ns3mhpQL43Qk1I4pZh72E10/0Hc9h+PED8cfmGKmDx2pFMIwcHg4UovR95nQ3eJDz3gc8VdbQhfIJaN+y2YTyFF4/fIFL3YD7z8diVm4Gwt394mXryraGc41ZsasUGdlJa6pSKdUmXIlA1PKlOLpO892M/D5c5zL8mYZq86TK3z/8QPj8dCIZIRSM9VGChOxeCRHtI44Ar0XujDn+dHMXbd9wBQe0siYMrEYZVasqSiKknLm4XikUiklUUrBi8N3PeoCZi3LcclwRBSzPNvTZlBrtqLVsdvu+HT3ia4LuDGw3W54++YN7354z8PdPcN2i3aBmhOCcTweUFXUCa9evWKz3RFTJjgHJTJOxq7v2G4CzoNYJk0j/TAg4smxNRjHlGZVZDufPjTlaVMRw267I6eE89KIWmYRnzSC0witqR0jhA4DDod7Pnx8z9/85pf89a/+wM9/+5G744RoYBg6wHDUZpVKhzgPqo3Qnes872Q+P4dzDsmJW2u1aEwFMaNWaWRhzYhUgipOW2RRzpmUM3g/b2+YBUyUYpByIcZCjJlYCsUE1WY9q6HDOY8AVZuVqlhrHW/iyxb5UwsnO9eSCiUnSs7klMgpkUpqSspU0FKhVLS2O6w16GprerA56qdJEBDJgDZHsLo0Krc1GIqBW9bfoJGo1khwODmULXjayG9r3bxixYoVK1as+BH8o6xfH5Ehsqiy9PwgcsmXmCAUtHwG31OP79jdvMHd/BT29+CaMlP7K7oXb9l/+AXD23+JM6i+o7lTzN75JwJkVkdiqAZKFUS27L75l0x3P2f6/j+hDCfL1Xp6JrrM6jtjUY0tmXxfnOIz9pULuaR69r14qgz86vT9Ce+b65EWWT5nASyKyIUgrLUwjREfE2PxrTsPbVTKk4fDHzsPO/1uISEBWfZjp2t8tlG9JD5nAo96ksTVy2Msx1n+rbXt7wmZ9SVJ1zoIq4HUilcjdNAH8MURo1KLUktApGMcRx4eJlIqMwF1ouMeKUkfz8ElSbaM9tEMfeXnL4n659WWj3SJj47xnPryx3C652jd1Id9JOVWYCoCEjB7PuO07WCxKX5y/59O48nY7cmvl5f/iLL08tz+lCzLy/NbrvmjAZhiUlACRocrB5Lr0OMdJpmy+QapBW+JKANCwDlHrJFTm4EYObyli98xpoq4HeZaF6hYaQSpQC3t74qXQp4KaXpH2HzD1Yst+9/9hizNBmhuMD01N6xYsWLFihUrVqxY8RTTdCDFRI6ROE1M8UicRuJ0JMcjcWqEZU4TJU+0tjltuey1ovhG7lRDc8W5mUQQh/duVt7Nra8KNReOqcwZgwURYwiBm82GjXpUoQuNuPQhoGpQM2ItC09o5VwumVILne8R77BamaaMBkWsEUTqBA2ukTMlczxMiDpC16EKuWaO0zjHnBQ636imWgvjFPHO0Q0D17e3HDRgEqAW9scJFwqh66hj5u7jB7bba3zXIWmi77bkGHn4/MD2urK9umWz2ZJjxgz6vqOUjKgnDFt2V7e8ffmC7z888O44krJx2B/IccJph3YOUUVMUV/QLBzHPNcuLTtQDSgVcsEh7K426B/uKVWw2WRKVbjfP7R657JxV2Gz8yAj45joqQy+5RJ6F3DOU2vGqeBx9EGIOVJqIaZILIVUW23b6tlKFSWbEFOlWmtYds41NagZLnhSSgTnUedIOc3HmRohpoKVym53DRQ67xDx3Nsdb755BQIpJ4IvbLe+kezWcgf3+yNX1xu8V168+gkVx+dPzYK2Avd3dwxvbhk2ASsRMzeLA1tu4jge2W42iO8R16EstXsm9Ip3tDqt7xj7npTHuRm62Zd65xEczEpDVQfiebj/xO/f/8D//ve/5D//8nd89/7AIUHX97iZNLTZJjXm2uZUHapuzgx1zWZ3bgZAtRGWqlip3O6Mh33iOE6MNTPmRIyRNHm6LiBOGqFnrZ4sKVJywblK0dbkXmYbaAPUtRo+p5Y1WauhFbwzgg+Y6dJC3xSfNjf+Vtp5mLX91UKZcypryZScZtvXTLVmDdtybZem+IoYaCmoA2eKYjTbYZqycp5vTLDamokNPbkrVZO56dcoZV7jsJZ7uawHtSblZV3tuRW2FStWrFixYsWKM/7hROVMtiwEhoi0h5YnyrvlJ8Gw4tk/fOLw/o5UQV/8M6xENHSYtDwLqYbfvMKmI/bxO+rLn2BZcV5PrMDZQ79Zk9psISKWMOeoFgjX/4b73/+cTgumi/LPtTGftn9KVNqj7y/Jh+eIGpuVZSeiz84E6CXht7yfZZ6escW8JD0fj6mh2gUx+GR7713rAMXItnQEngPR/xRS6Vky6UJKJ6JU5nwCAbOnqrd2pc8qvQsibiEoT1Nuj+bzR/MOabkp0IqH17egV47DAwS3YTq0bkTM8N7ROcfNbkdKmQ/ZoXdLd+zFuYucMkXlNJo/Pi/nLc4k2lM14deIx9PLUln8hP9U+9in+2rzP/fbmkNcs/sNClIWgvnp/tp4z19L/XD++dlxfCGrPA3g0bh+7N567pyebnexy6WuOX3ffm+YOKwYwUFkhxzvAEGG1y3bBYfaJ0YdUASnnlpjIx+pSBVMK+PwhuH4PRNKZYNqaw5daO2CUHDU4x2lZIarn1JEMSt0ClIT4M8WNrLM7YoVK1asWLFixYoVj3E8HkkxkqfIOB6Zxj1pOjSCMh6I6YiVhNUClFmdGNA54mTRO1VrxF815bzkryxZiSqGcyAq5FRJpamvOq+otSZHcY6+U4auqcuc97gg+ODpQwDV2d1kcRupxBiRCp3vcL69nvLcDFgd3ndNiYdj6AP748gUR4I6hk1PBmqeyCny+TCxGXq6PoC1TMngN+jO6DvP1fWO6XjEe8f9wz05NrtXH4QYE2YTOTtK6ejCBlXjd7/+Lbvrz/zsz/6c3fYa52jzmSfG6UhFuboK/Ownr/jh856Pv/yOw1Q5JtgfIte5sr3uQIWYhClmUq5t/QHDq+GlkUrbvgNtJOHNdYcPQi3SlG1AKvOKgrUswkrFqXJzs+P6yuMc5BjZ9Z5+zp7EhFwq211P56BXwYWKxraGoU5AHUYhAH5WSmJGTManz/d8++YFpSRySWCG84HODRyPx6b0c57DGPFOyLnSqSeXSq0ZqYVaUrtWOfP6m9f4ELi/PzJsrnG3L9nf37G7umGcCq7rMJpC8u7jR16/esn+uCeXkVwi2/6a6fiJ45hAPNOUCJ3gtCenhDKS80jOi60pOPHk2rJcg+8auWWVkjNtipratVSh84o41+5V57DaImvG44Hf/uE7/tdf/C2/+MM7Po6R3bDj1WbArHBME8eSKDRFZq1KnCq1CH7ocNJ8eJ1z7XPkDPVNbevMI8WzG4xd77k/TOyPkb0KV13HdmgEoRZOxbiox9JEmvazGnRoa1XFqNnIpdW3oetxXhrZXFukiJmQs2GuuWW1SKKZNLSmpjbmWnpWRC4k5rK60ajSyjnjlkaitj8cUK3lpJo1xyoqOjfGa62zQIDWMMxMjmqG2v7+SNMosCwb1VM9fF4/uFwiWJYjVppyxYoVK1asWPE1/KOIypOW7kT8zdTlBQu1WKoahWKJkhKdeCiJbtMzpgeke4FoQKVlKxYMefnnpA9/gx4+M2xvG1En7cHsrOgrOIwyq/4ExzgdiO//Dpd/YHt1S94X0A6R9vvnVHDLOJeHJ0UoLGSKPFGanbdbSEpO730yQU+Udl8c74kN5nOkz6n/TJ4b81K2glNDpLYH+TrTLXNr53PZj89Blzk4Hfux8Wy7tu0B+Xw67bG07bd+eYynw5aWqYCcUjQfEcSXFrsLwSZAKYn98QPjtGcISkyG94Z6QbKnViNb4RgzUiqbbSATHu39C6tZOx3p8csX739KIpvZSSl8JrLP8/Hc3D5+aSkb/rgS8cdggJM2513nUKeoTMBm7oDUJ/tZWMDZ2EWglRPL9Vy6c5dzOtu6npoi5/2IyEycn+fpuXE/Jmq/Tsaf338m+xcy9hFqU0UWKxwf7mH4M7S/mi2YFaPOjQ8vWlarCuSMilLnQqxaRlHG7lv89DswoXYbwJp1VW12SoeHz0Chu/7zRtCLMeHxXol5RMLVuSNU7EfJ7hUrVqxYsWLFihX/dHE8PJCmlkE5jQfGcd/sXtORnI7k1NrnnBO8U9Q1u1fnPWaCE4dzSud9IzxEZnWagjnEPCUHUi44UTyeIVTKbA3pHGz7wDB4Ou/o+kDfdfSbDT50OC94r2yGDSGEmagUUk6YgaqboyMKTh0I5JjouoHNdttsKsWDzlmNIsQpIQbTOKHSSBLnhBSNcYyUmtkMQyPhUA77Qs2FapHd9UDJlWEzUAqM48hGt1xfXTNNE7hASpmYHtgMA69fbZniyHH/CXVNzRmcA3pUMkJhu3W8fnXFX/6zb3j/8RM/7I8cpshxijzc7QnOs91tkJxJqTQSz6wp0ypsQyBJI7l6cRSrXO0c240Sx3xuYzVrMSQqVKuoU16+3PL2mx2dq7ha2XTNllcEfPCEoPSdY9M5emfsuqZ0rLWRaVaVWsBph8PhhVNuaanG4TBxOERuXxh1Jvd6M2qteB8wEXItJ6vW3dUVIORxago+Kt47SolUq3R9x8ePH8kFNptrPn36gPc93ncMUhmnhOJ4/+4d3nlqqZRcOTzs2VxtSWnCrNL3Gw6HEYc1C1JrxLmrRucD3nmIEyKtlqs5Q42oczzsj1hNAHReqbkQY6Tvt/TdhqqK+A6rSrFMmY58/+57/vMvf85vP7ynRKPXnjfXbxl0SyyR++MD9f4TpURszrSsuakrVVquq7iM8y1WZy6P55gdRXtHrZXNxsN7JRUjZyVbs0EuOSLkZn2s4UQm5rEiFiGPVHHEAjErCU+VgJonhI7gPCAUm1dhTObPVFuPagEnwEx+W6mtgUFa/epUCepAK2jBpMXneKcth1PlYh1GqbT7yJ0azwW1hdBsylBVmQlNmV+j/bys8ZWl5m+E6Xmd7uLzcFpFYG5pXzMqV6xYsWLFihXP4x9n/QqPlVucyQ6Tx4SEIJQccQabFz8hff931Okzmo74Cm7YgF2RvSHmUCnsXv4r9j/8H5Qw4LotRrPMoCqqHpGW+SBiHA93xE+/xabPXG8H9O1/z+HTrynHv0GlgvlFyMZTAvGc0Xj24NdLS9NFMXXBmzSr1/M+nuLHVIyX2ZZPLVm/RuSc8h1ntVnLX1TEDKdzRqVzePFYaUTVojj94jy/ULNdWL/OsyOL6nBRUF4Qe6c8z9M+GvF2SS49zsK8OM5Jcfl0Sk/MNosK9DKv07tmXfSrX3/kxdXA77/bEzqj87UV/nlimhJ3n+6JU+RnP/mG37zXCwXjWRZ4UoU+Sy4Jy4P6o1cvrpc9efg+2wg/ns/2+4tzAy5uwudVrE/n7lnS8kygV2uFROg7rI6nc3yq2D0f43Kqz0WDXcx/63Rs57PYm5ow51B8Sd4+dz5fjPhHVLPnczo3Azyf0zkXTuIRceA8hoJvxbynUsxRRfGW8Z1Q7u/R8XtQj+iASTdnmhh182fo/jcUu0bDDa4YmUj6/D19J4TuisOsmjarVBybvmdKCQ1czM1ZobtixYoVK1asWLFixSUOx8/E8ch0PDId90zjgTRNlDJRS8RqxhSc83jn8d7jnWvPoDKrIVVni1BpVo0qlFLmmtsYasGykVWR0NSYGOSSMMts+o5N1xOcw3Udoe8Zdhu6fmgEjQrB94TQ7F+tgnpHyc2OspamopSuO9WiJSdSjGjfsvx8aPmD4j2l7kkxErwjTpFaIt4poeupueLUMx5jI03UqBV8GPh8NxHHkavtQNcPYMbQG1POfPhwoOsHSjziXMB5T+kqw7AhdAMiQhyPqDrUIDgIwZFzIbiO66sX3O4OzQL284GPD5GPD4Wum7D6njxtIDgUh+BIcZpJG0hxxKRSU6ZWQWojF3dXGz7fP1ATWG0qSgSKGc4ZL18N/OwnV+w68Kr0Uth6wc+NpVRthDMtmzH4gvNGTIVxrBwjjEmx6nl1+xJvwnF/h5DmxlMlxsLxOBFj4lqadk5VSCkyxcj2xc1s+VrBcsvRzIWuH8g5IaWS00iKE9UaQRvHERGHSub1i2sejpEUM4fxQE6F4wE+fHrPv/jzvyClyv3Dkf2YePHmml//6lc4hd12i3PQBwcUcjo0ZZ8MAIgo3neAMk3NBcdKJdXEcTogVvDBUy0zxQkMeufwzpPEgTlqqdQceX/3np//5he8u/tERUlWiRkk9Gz6K0KeQJWHaWI8tkxJQSilUmZlo845pSIeJwZaUWeoa00ETiBnx9B1BNfWYXzv6QdFfbOhzSk1e2BnxGpkmQipI6dEdBOxQjKlag9+h/jQ7J1LbSpOkZYryqyadmer1bYcY7MLWcsbhVbHq831vDVrXHzLuBVrlsBSK4qhpdnHikHBcEJrHpcLZaUKMisqMWnN7wbUQuvqb03ALflImpgAa9E+7TuEWSE6E5XLOkRr+F4L5xUrVqxYsWLF8/gHE5WNMDgTHedAyue950U8Nd6TUqKksdnGqMNKs0Dh4dfI599TN69wm2sk7KjO0b/9K+L3/4Xum3+PuNAC37VZWFQR4t33xOM7vG8ZCd2Lv6QObygiVCaQHmjWqOexfJ2EYn4InOkqRBZikbOyTB7bt55VYJdkE4CyWKIudNDT4/+YwuzLMS5EW53P52L+qxG8o0x6JhSps0rtawq2J5a1i+fmhRpSRC5sPL42ruUYLeT+6f6fEtayqGPnItds2ceSv8Byg7Vn4Sp0nbK7DlzZB+pReHk98vH9AXd124oxMwITf/F2w83NFeOo/Lufjfxvv95g2sLuvxz7+XqeSdGzxvJSNfjFtotW85lzfKySXfZ2+frX78Xn5/fJPjnfD8cxUavgpFmdSrVG3lG/2McC1cUKdiaYgbM97qXG9JI8/PrYlu8v5+FPtbV9PG/N5veS3H36XgNyNrrOEco7YMeBAO6WIPdMuiFI4U1/z/64QThQ+rfUMiI1oqUVvYjDXIDhLf74A1kCBkwP3zEML9Gww+pnNJznvFRBw0B9OIC8ejJXK1asWLFixYoVK1Z8if39p0ZSHg6MxwMxHqklsgQOqNCUkNqUW92SpXdRD7W8PCGEZhOpCr4WWjakgXOkwSGpKef60LWsPSpmGdUW5YE6Qj8wDBuGvqfruuYS5Dzqe9BGVDoV1DJWIyUncm0sg69C6PysOHOUCtOUCV0GVxBxeD/Q91CLcZzGlvvnB7Dyf7H3ZruyJFea3reWmfkQEXs6Y2Yys8hmVbPRVSWg0VBf6lqvoVfTq+haakCqgqSCyGIlycw889lTRPhgZksX5h4Re5+TyRIJSSjQ/8TJvWM2N/fYcPNv/f8ieE+UAXFQ+4r9rmeUESSBwtl5w+31luubHU1TYM1qvaZ1npubPV23p64U8sib1+9Z76/YnF1Q1TXd3Q6nI2OCzXpNiqm0BqnX5JQ52wgvn1/y8/sb3tx85M3NPb9/dY3XC5pqzTgWEFM1Hh8cIpntbpjgY8ap0QTBZYcDxlp5+eyMm9ueu+uuOE8ByLSV8OzZhhfPWmoPtRgrr6wbP/VCzFRB8FWiaj1tXVEFcAr9fqDbDuz3ke0+c7P1rDcvuLz6kq6/4/tuSx5HXHAomXHsGYaeMY7klFm3KzDY7fZszjaEUCClU8fQp9LOoq6IfT/1tBzBMpVXdvuBYcx4V9E2LeerNTf39zRNRUqZ3XZLXbeM/Z4XT58Rmpo3b9+SU+SrL7/ibL3h8uKcs03L5eUl49CRciSn0lNVKa7KmI390JcempUypkgVAjEa2Qne12y39zRajruUigszVBXmHCQlpURMAzf31/z6d//MDx/fEckMBrfdwH6buWr3XNaX1E2LeaXZ3XHfbxljJllxrZY45fIdEkJZS6vgNOF8xocpXlk9zkeq4AhekCzUdXHi1k35XpKNZBkbR2JMjCnhhh7XDWQco0HWGlcpoc14KVcVBhKZiBNFfU1wineOxFxAP119sJIwpEopYsgJcUqWCFqclSKCUyG68rs6cCIkH4gpFaCYE7PX0XIu7sspHtqk9AtVSjGumE2X0vJ0iaHASEtwxI42jW963GY35UNXpYj+5DWWRYsWLVq0aNFftv4MR6Ue3HYTfjo8cmigfSIDUn+LI6L5Dqcbmie/ZJd/RzfsWD39FW51jqVE7G7h/gOq4Oon1M9+Qf7wO3j2c7JVpGwMN99Dd0t98Qxtn5KHD9RP/wZRP1V+OSzF4rySPI3xxAU5jTjL0U1ZWOt0ElUIWukLoQ+BzLz9IkeYYlMcagExs4txhoCnwGUGjvnR+z1+/4c6QKQD+Jr+HQBqiSyJeFTKdsohinWyxFEWtaduRVU9gXSz2/ARpnrkwJOT+w6zeQL9Hm/PXAEo00J7PlRETuJJJzqZDx8sxcFnBuIx8/y3/+nfcXU28O2bW/7qr/6WzSZzux+w/R05VdS10FQjweBsk3iy2fLd+4r3u9MxPYRvchjLZ/pCcsLfp6HY5LaUyRaaMfTk2D+CusOe++Sx8vinJ+ifg3yfhX/HQRNzObZzNoIXpsLKH3U3Hscw9wmVR8Msx9jDz3r0XRZ+0kH4rwGWn3tN+fmpO7eMA8SERCIn4bYTzp48Jw17VkHJ4zss3aHhC75c3/N6dw5uj7ctQsa7GlxFCloAforkvCUMb5C8J9+8Z8xKe/YzaM9JOeISkCKikwvTQEODxHcHk26pbP1XbeKiRYsWLVq0aNGiv0Btbz9Msa97+v2OFMfp/LQ435wqXj3BVXjnUXWIKqIljUaZ3EuUtZvzDtHSzM57j42eJA6nHhy4OT42eOoqgDMc03s6hwsVvir9KCOlz733pecfInj1BVhowIWaUGeqnMgxl/hH73DqEHEEX5yNlinwVRyghNCQqsQYSy9D74XKOyyNhCAE7wChbmv2+8xul9nliMhIVdcM3cDtbU/TODL3iPO4EPC54n67J8dMXde8f/+aHCPrs3Pq1RpXe1KO3N/fErxj1VaQI2YjqonNpublsyv+6vkN13cdN3cDb292nK8dVaUECUgacC5QBSW1NTnFAluDUWXHOICzjDawu/R8uKrotgNjLOufdVsA5ounZ9QVqPWsgtH6TO0Vp0IdHD446lXFelPT1A5PhsHIyRj6yHY/cnsf6XPDixdf8eLpV7x+9z2iDnGQc4G7KRld1yMIw9AXJ2pW1qsVbbs6XK8pEbBGW1WEUGE5Qnb0Y6RpGoZuS9f1xAQuVFRty7br6YeBi6tnvPvwgcsnl1gyxmHgqy+/5ts/fEdwFe1qRVN5bq8/0NQVITQMo2FW3JRjSoirUUo8rQ8tMcayLVrcuFXt6e52ZItkoB9GzBJBS7JPqCukqkE9OY7knOmHPb9/9T1vPrwnpVgiWJPR9SO7PvLqw3tq1/Di6oraT65iUWJZQhOzkTIkAZwrrVXUEK/T9zMVh6EIDinHQKUE5zCsHBeupm5WNJUgORDjSEoZ9Y5gJQEs5kwfjcEcGhxOK1QrnAsgHpVAcDVOPRr85KcsVxnmvxFZBMvlOk5KCRElWXHlGqX/bHSlUCF7hxsdzjlScHgfSDGTJ1BpKZY+rkzF2TY5gpmvCR2zp2Zn5uGKX55Ltk8Liz8tPD9ec5ob/gj5pJh60aJFixYtWrTosf50R6UcAYcc+N/RVckJ4Cn3COPunk1TakddXZNjJGtN2z5ld/0H3PaS+uycjMO155AS/d0r0vABlUT+7hap11RBCJuX6PkX9O//idXmOTz/jyQT1AQnmYyQUywLMvMFvjBHVnIAMHLSL3COfp1dcjZHtJ4COmYwMS8bP3VJlr4ej++XCVwenzOfyH1Oj+M1T8FPgWcO1MjZ8E4wSi+N0eYdEks7SXu4fZYzs1PydF8WmKgPCNRj/vJT0Z7lCcf42B9/jjw6LiZHpZQKPmz2b05j1vKZnTW8evs9/dBw9eSKev2CbfcB1bH0aZl6nmx7IUX49Zu31I1n6BSRK46uz+MIZSauNt17Clk/cbo+jHg9YucjyPvULThv4eEtTyDe5+fR4AEEe7yf5kmbAVkuHBcVQSVSAHqewPmPwUI7ju1Aok+3ZHKKzlubP/0uH77+P+Em/de6Kg8bxXHOynfjBHhOT9HS5QRJiS6vaL0ydrek+gUX3LFq3/HuZs0oQhA/dbzd4ZPhiDhJmOWyuNOAtFeMrkbUsw6emCK5+4gzA9vjxGMSyFL6zFhVIwzknNATRP1TruNFixYtWrRo0aJFf7na3n9k7Adi3zPEgZQiXgSvgVJIqgVOeIcLrrHKb5IAACAASURBVIDIqSjVqUwwJ+M0TT8rVBymiexGkpbCWi8lKhajnLdiiFNCXWJUQ9USQoVMbQ3IiZzz5LZ0KCV2EowxZdIwHpyYVaiQqqwvdIKUs4NQ1ZEsES2X2EtxqHqC9zRNw/04cHNzjZOR9aoqEEYCoQo0lWfInuE2Muz27O625DyyWW8Yh4HdDs7PN6gbSTawXm3QVnj9+j3OK5umZX97Td/vcKHh2bMvefrlRekROQ4IUmAuioSM854XKfHVzT1/eH/Hd+9vefNhy6YucbuXl4527QneUdcVTeOIuWccwWJitNL/Dx2JFrloMt+8rBn7ge3dSFvXPLmqWbeBxpU59pKoxBHM41DaSqlrQavA2aZls66pXCkyHmJizMp+Z3y8SdzsFBc2PLl6Qts0jEOPc8o4QqRckUgpsd+P3N/esVqvGOrAWR0IHixH9kNZzOWUWa3XhODIORG8Y+yFs7NLchp4//49N7c3IMrzl18Rx4HtbkvdtnT7nvvbLVfProjWsT47Q0LFMA6sfM0YI7d312y3dzx//pzdbs97/cD5ZjVFpiaaKjwAXmOM1HWFSihAbQJvlhMxjqhGYhJiFDIeX61R3yBSoU4Y4pbr22vefHjFkIbihBTDiFhOpJy53d7ysWl5ct4SXE1wVbkOoyXiVoCcwVCyKKKgYjhV1FMilJ2hUoqTq8pRecU5K6/XEl9b1yvqRhASlUVsuqZhVmDoEDN+EHzyuOaCdvOEenWGC3X5Lk0uaqeOrAq5FKH74Kco2OJEnf/zpfqclA3NCdTjUsJrIqsrkbY+Ev1ISjUhRHJMpDRiOWEpkabvPzlPPynXYiwx94uxnA6eydKn0g7Xa8QMIx+rdg9gsqybMZ2u80xzwecL2xctWrRo0aJFi2b96Y7KQ2UeiJQ4iAO8mUHLCZDIYsT9PedNw00XqWVLvP4WZwEbjc36Emzg/vX/Rn3xc8Q71Hnc5hzZK/n+D6z8W8Zui7S/xLbvicMPrF/8B3CBbG6KHS09HgSwlIrDcmpKKA9gyGnIZ7k9R5/mKdvfqSsn9XMk6kEPcdwx9nUqzTt9z8NzZqeYHV7/EPDwWfjzsIfmNK86QdYMYkoQSJaJOaHiJpB0mv5/7Atw6pB73J+zWEI/BUw/5pI8zuV8u8zh6atlagAvJy7OUxUwV16jxrFS7zAORUg4U3777Xuqv/mCp89WRHNAhdMdog4VJRpYEghKFM+3P1TsdhFrM4qQT8Z6CpBPR3UAxJ9sqxym7nQzdJqEUjH4eOsezxMn+3UCyHZ6lJy4GE9A9eN9YJR4VJXyPuo8znti7MBJqXKUaZ+eHFgldsUeQdjjsXXwWH4G2Ao8PA5P5ofP3H58/x9zVp46kee5m0dVbhlZQE3BCVkSJnBPoGk3rIZXXK4Tr3crNN/QpPdUmrjLAyGO4BoGrQu4V1d63SL4/i21JMaznzGK40o/cNNfkgVCzFjaMgB+GDA8STIBLRWoWk/zbDza3EWLFi1atGjRokWLABh3e4ZhT4wDkQIXTBykTK0QVAjOU4cGr6VHJbm0H0EmF6VTvA+IKDmPBV6a4NVhwRNHgWhoMlLMCB4LHpEa9Q2hXlOFFh8qnAo5x/IvZaBAHTRjuQAcFUW19PAr61fFOY/zFd6HUmQ69arLOReggmDJGMZI3++IfU/KkRA8ITj29/cM+x2rpqbvPT4EmqbGpZFGDRcUXXs+ftxzfX1PzJHgldW6JY+ZlMGHxOpsw5fO8ebNe1LymCYsjtzf3zF0HV0cef7iC9arhpyFYTBCFbDpmkDbbvjFN19xd99xc3vPzX3i+3dbVm1g1QScKbWvUR+o8IzJE8UxSke2gaFPpATeMlcuUp/B+uuafmhIWTA1nB+pAngRgnM03hG84RsIjRCCo93UtI3DSSJFSg9AU25vO75/f8u7PeyoeXrxDFB23R13uzuyZSSX4tZoRrQS/zoOXeltKo6hG8C0ROLGARFlvd4wjCMpFpBnZJq2xUni/duPbPd71ps1Td0gAjH2OAfOO/bbLZfnLZvG0emKIWbevntFipFxMNaXG4a+p65aMBj2d4h1XJ59jXOB/faWVe2pQmBIiTgM6FQRm9NIiomEn64lZEpMcOnTOgyRUDfUzRqnARGPaGS33/L9ux/Y91vUJ1yGgDJfbtFkRCJ3+zt23Y6z4EGKpy9N62KxKSkpG2qGww5XB1QEVDFJqHMoCQkBX9WH4gHvHaGu8FWFrzzeg9PSNqgAUEgGQ0zUgxKlwjUXhOYMX7WgHhEPqjgtPsqkijrBOw9uLuae1pzTtmUrYFFzRs1hMaHeYdnIKZFTIqZEDhUpJ1Is3/WURiwmLCfGHIu7cvoOk9L0vuX1zFDSYrkmAGBGtnToRylWHLI2/b0qMFIwiRPr1OlaSVnb56k36KJFixYtWrRo0ef0Z0S/fnqC8eCex6AtZzTvS2RH17FZnzFoQMYOSYFUn6PNFWdnf8Xdu3/B9CmSE+PuLc36gvqb/8LKRbb31+xv3uDXTwjNinH7Gq0aNDwDF5Ap+zJLIOVM5dw0IOM0avTTSq4C83IusMR5PUArfeQYK6/V+VUn73+chYdsUyaHm/EA6j367OPU2QNoMz9WYFtxBqqU6AzVKVY1ASZYLu7KOZDjgXlP5nF+7uTwCIZ+vN/iZ9x9pxG2NjsyPwWhJsfg3QfQS6bgEMvYYTZPEauVGKLxHu8zbz9u+Zt/35Cn6jxMD3CzxPcq4h1p6Lm//sBKA3c8OWybiWNqqDBPyMHp+jmX6XFbT92wp47AU+h83L//6kpBkePMTwsAs4dHxycvQQvIJRNTIsWyUvUiSErMBQSn71fWWZMr8GTbD9s3Lz4ONPYIxh8O97h9nwPa/896rp4eB8fj5mHC7QkoPjy3QdIHDMWZEkX45vKW3b5i3N8R3YpUPeeyuuds0zGmDnMrTBqEVFaLBs3wGq08e30JSTEx7uwpl9VHtmNLCcPygBLV4/PIGBNNq2zHHt+uKFm79pNRuIsWLVq0aNGiRYv+cjUOe2IcGVMqhZVmU7uLEv1a5bK2dM7jnC/95CmFs5ZBnKLOlUhX5ZjSooLgEVchfsToEFHc1OvSeYc4OURXokaySIoFQEAm5oxAAVyuKhGwgKqfQGVk7s8HxU05r1JTKo6srusQEYKv8OJQAe8Fzb4s1yxRVTXWrhh2O+7vtoQgOBfIsQCu69stTRUIdeDsrCFFox9gu91ze3PP+eUZ3nu6fWKIHetVQ7vZsN3uUHGMYyoAy4Trd2/puh0vnj/n4uwC70qJsmpp2uE9nG0Cv/j6GW8+XPOPv3vNx/uedzcD6zbiwx3nMdJuaup1gwueQRw5O+oQoAGxMp+yG/F55KzKuAwpl36fzjmqUECbWKaqPM4LVRVoVg1VLdS1Q7UApzQm8jCyu+l49/qW271x1zvq+pJVc8bYD1xvb+l2dxDHUsRJJgEZz5CMro9Yylge2XcjzWpFjAUqNasVKSW22y1IceSt2pam9tzffUQUnjy5IKVIjJm69twNW5wqTd2Qx4Sbep++ef2G+65j3+25uDgnOM9ms2GshDhGuq6jriqCh8ob2Fj6nVoii8MoPVNX7ab0mRxHmJx547inbtY0dU3s96gYdVXRtGeEqgUNYJBS5N31ez7cXhNz6S0qoiQ1IpCsxCabGbuu5/r+lhA8NrkIU7Kpt6NMkcfA7PuzjFgBnmqGF4eTOe7V4VxJdFJ1eFe+Y+qKszIEhw/lsRnQxZzQmPC1Yq5GwwbxbbluIVpczt6XNTuCdw4nDgGSlLW1k3LVZV5zZgySobnAVVwmTc5Im376KeY1pkSafk+puCnJmTEXYDk/P6U4RcOe9LHMqfytsIxZLollWbGUyTkhWaZZy4jaBDAnaGlSXis2XaOS4mxeOOWiRYsWLVq06Ef0p0e/zqBDHgI6HsGeWWno2TTCmBN9b+Qvfwn+DOdL43EZtqT7HxhzRk0Y3v0j4tesv/kveDFc94bbMdPvO6rQIGdfQbUiYKThjrz7PZIM82usvcJ5B5ZxvuYkm/azgLKoxKh+AqsOj9oUUzNjJSmxGCeA7wGclNPbp6+zw8/TiNiHbswZhD6EfnPjcRUgxRLvM41tOw5Y37HPO6iuisP1QE8mjDeB0sKhpsdMT8b1+SjaTwClcTKuY4TtY1j3uVn+9L6yEJ83W2x+/WQsBMQcMQvRfYPS8er1B/7m2c+nbZo8tNMCXCgVpjc7j6jSuy9L1aDzlEjUed6nzZ8+54/3Cj1C3IegTvgU2j3+DhxdlXYyd4cxHJ98oHQHZ6KW/pMPYfnxWEkm3G5HXr2/5nbbIbUrAFsUy/M+/gxstoe352P92Or+eFT82Jw8ANEnEcU/VgzwU67K04ce/D2ZwXk5ECb46slSYpScwM/We6K2bMNzzp6OfNwLNu4YqgavK8Zuix92mDiG9iVqjkt5RV5fsIstEnskJ8QiJsagsHY3bLPDu8ioNU5WJCsu64qBu32PKMXBC589vhctWrRo0aJFixYtimbETPmXUklGUSAWCFinRMyZRKb2JWo1T+urlGJxVGY9AIVyfuxQV6JjcQ7xAbQCHQlqVI2nrgscc06L8ymlyVVVwA6ApVyiZ12BCOBmVsM4DsSYQBVVK05PBKzE00KJjW3bFTFGYsqTgUoRCeAzNgqqnrZZo5bwCpIbcu6JMZNiYn1+RrTMh/cfqILSDxCHkc26IqcC/W6u7zg/X9Os1txs79nvdyDKMAq7bUddOWLsOfeZyg3cvLsjdR35i8jm/JzaCnht64pQKzHC86fC3/37yG6M/Pq7a759vQPvCDWoT5gNGJFQ1wQX0LYmJqGqIDhjy0juHOu6wbvEqsp0Y0acK/BYHXUb8F6pvOJdpmkaQlUhrowheIdTQzSz60Ze/XDN2+vIx52QrWHVnpX41m7Lu/dv6LtdccKSyRjZlDHD/W7PmzfvePnFc1zlObt4QjJj7HvadkVVVWx3O1arFcGX6wzrdkWKW1IaWa1aRmdst/eHNVtbrwAhOJ1Aq2O73xGHPeN+z5cvXxIqR8qJrtthKZNSxjmHpYR3MPTbKcbUSHEAitNPtZocuQlIqELKEacQxx5ft6zaBtRheJpmhWpA1EFKdMOeDzcf2XU92RyGlsLoCf6LejIRw+jiwHfv39KNIyD040DO4NxUzOt1WobnQ2SyCZgKpiW9yHtH8AVqiuwAxanDaY1qwPsaHyq8V7wLpbDAe7JN33NveMq25MlBqb4q18JcwFSnYnQtnylaol91Lmou6UIHUGnAFD9r+Qgqj38jCizMKR3uJxsxzz0qS4xxTgmykXI6wEeb7i+PpXJfziVONxU3bk6RPBawicbixpwuJZWa8OM1gvKnzMgGWVKxAi9atGjRokWLFn1Gf0aPytNf5BNAeWyeXaJi0thxfibs+kucbvHVE8a4x8ThwjNGHRj6EU9Hc3EGlWPYvuHmn/8nLr/8O8b9t4zhS1bPf4Uwsn/7TzQv/wOWlKA14/olmg3Ge9LNbwpEHK7Ren1wrT0GTeWuYwRsWVQ9cgQeHz0lSg8ceGYzaNOjE+1kXmZX25STewBmBb6c9pDUaZQ2jWWGUkfgOCFRvnja8vH9Ndv7j7z9+JF4/T39/Qfaq6+pv/7Z9FlMYygntzM8Le8z93CYIRCTo/HzDsqHO3/+3wxd9XC/PHIUHo6FeU5OomaFqceiTFGlU3WxHGCiTvvHsPqM/f0t76/fcX5eelkg5WR+nmuR0mg+qLLdd2DGEFqc8+XE/vAfxzl9AMUeHr+f9nj8HMwsx8shWvcnHKmnjz+EdqdjORYBHEHoY8A3zY8Zef+Of/ivv+HN69+x6yJ27vnlr/6Ot++3dH1ZjKmefB/n43Eej9jh9jyEB3UHNjtzHwLIx9v4Y8fK5xy5x78Nj75Dn4D8U4A5HzcGoqiNeIRnq2s+DOesZMdNJ1y0Lc83PT/sL0iiOP8Gc+ck36LDe7j+TekJ06zZ7hIie0QrhqC43GIi3Jvh3ch5e8N+LAvJnAUTwXKiDoF8uysRu9N4/li07aJFixYtWrRo0aK/TKVU2nRkMohg2YijYa70nTRLmMUpVWVaV6mhJuTJPZlyQkpKK6VPpB6KbFUd3pdIymhTqzlfob7GuwaVCqgQqVCV0neP0n8uSULFiCmTU8foJzAiUmBELuDJuYBqWU8WA5rgvCtrOYqbLJuRY2KMEVEtvQdViDkSY8J7x9hFUhzxtadpA2IOzLi8uIIs3N1cA0KMAykp69ZT1Y5EYLvdYeo426wYh8T9duTj7R1p7BGpOV+v+fj+I23juLw8hzSw212z6+5Yb855cnnJbt/hvWe12qACXzw/4z//7c8B5bc/fOT3398SXEbcOc4H2HWkPmMMSCWEWmlqj1MrfeytYugceUxoUjQaJp7Sg9NTrUrvy1VdUVdGXYGJolqjJgRNuDxw1/W8fXvHq3cdH7aB3aBszi/w4qmd4257x/39NaQecqSUGpf1ck5GaD3BwX67JT95Cihm4L2naVu6fYdKiRGuquKczWkskLJpyGmg2yacCk0d6PZbnLgSFWsRxCMaDg7AFy9WNCvPOPRcv//Ian3GarOhChUKvHvzluDXjMNIziPBO2IUgluhKOM44H3GGMkWcdQI0DZrumEgxh4RKQDfEiEZrirXWsacuet23GzvSgypQDbFTFGgckLQ4kh0WkDkdujprz+UdjHjeOgHGbyndgEnimVIGE4F0wDOI17wTYNzxdWYcmaIxZnrfIWqx2nA+3BwQ4u68lgI5TssZX95Sg/OjC+u2zABSmYHs0OlJES5KQo2TXBSmPhe+R/JcilMn6+VpIybXNhM8c2zu9Km3zE7QEtLGW8TmDwBleRcfp+cpyVKdjzAyhTHCWJGkovkPJLjiMZMzh6NkSSZbEPpqamQssEUsassWrRo0aJFixb9uP6MHpV/vBJqdtupKHG44e72nt63OBG6239hTBF/7+jkd+SgrJonZH+GJiXVF7RhQ/z4a7bf/8/4+hx31RDvX2HOUW+es/v9f6V9/qsSfeF8OUnTGtn8DLFIuP5uckGCTNGisx4AFHSqXD2BShxdhwfoxgk4kVJpJ7PzT04h2ATshONtYcrmL+BWVU8gzARJJ6B3hDenkBJES19Kw/Hb3/zvxLs/4CWhuzdcbpT9uafv38H+NbL6ihLneXTmmZUeI3ayhYexTVs7L0xPYdLnd+4MXx9CrM8BvgcQS2QCkUfEaQdIepywI9TLiAlOAk2zIqRAqM7BEk7iBECnjZgAWl1XiF8j3lC/KQtlyvzPIO40xrVsy0+5AI/g7PjztC/lYzflaUwsEwy2g0P0cXTq4RNPWd3JfjjcPz9NHLL/gZW9w4YtX3/z7zirv+L//M3viPf/zPhWiPlnh+06ndfjPp/hsh0+WOw0yHiaJDmC00/n5addkj+mH48enudm+vadvPUDrKulivvL9ZZ3uwuaCsw8wSI393tcHfmyUfZdJIQW6Qac25C14fxcGfwzojPOZGSXjC57nLriQJ7ma0wVd3LJlX/DEI3op54/CMmfEdI1MJaLTSb8mBt50aJFixYtWrRo0V+48ljOq60k5MzrF0MQcTipcBLwovPKDadaYnR8KTCd12giikyuRRWHqsOFgNcKEUcfesyMuq4JdUMIFeo9GgIuFBcbVpKBck4IiWzFJYUIOWVEBSxjOYKUHnQkwznDLJLVF+gpNU4LrASbYE5pv5JynHrfGT540lB63jmFlAbiLpK0p2oqQrXChYaLp8/Y9R0VkaAtgnF5eU43DIxxxES5+bhjfHPDL/76r2hXK7ruHnJgHEeyJa4u1tztdry//sjPvnpOcAWcbu8+MPYdT588m6BqpF3VfOmecnnW8KSp+F/+j9/xj79/w798d0M2Qczx/GmDqhHTnqYu/RGdKFWzxjmP9w3jkEkJYsx0w0iiQKi2bfCTQ9Z5h1dQSaiW9i0BkDFx8/Ge3//LNd+/2fJ+p3wclKo5o2o2XFw84epsw6s339PHPTAiagVYU9YuXh1iShwT/X6H5QGlrOWruinRsjGSc6LxHkGIwwhWImRVBHGOKtRAxizR9x1DGqjqeup9CFjm/n7H6mxNypHVqqEzCL7GTNjtt1yenzMOkbv7jidPrxjGEUdCvaBY6cPoDUlagF6GlIoLMFuB7qqORMIFRx6NIabDmlgQUjI+3t3RDX05Ti2RDLIGsjokgPOCKqyrmk274m7f0fdl7SYOquCpqoq6DVTN9B1xZY3pq+JWdr6mqjwhVAQB1UjfD3RDRrWhCg0+BEIV8KEihBqnhgseFxziHKA4Eci5fNdxmFQlwtY5YkH+eO8LrBRBVHGuQEultBhRmR3PxZmoGGpTr0oy5uwBkDQrbkusRASXGOnJbWkUUDnDyKkQImfDUipFEWYlJtYSlsPBiV3gdsRiIlWJHAdiHEtRQxqIUckpk5NOfwdAU3GpFqfn4qZctGjRokWLFv24/owelUWfus6OIOawmBJh7G5wBHAbKn2Pb86x2+9pNudUT/6esToDBEdG1WFxT775jicv/468egHDB/L+hnz+S7x3mAnrasVw95rq+d/jpEC9dEJ6kgGhKben+Ix5zHOshx5cjCfsVSYCydxcfYaudojInHtAHp1n5XWPozMfTtaMhI7ORiaQOsd0ygTdzB5F6jI79srixsaBptpQrZ+yfvIl6/QHzh28vU3I9hWsvkZkPqmXiaPM7sqT7TxAMcMd/XQP9u3pfn2s0idlhkvCp8/4jE7deAccrHOB4OTom1GxotNCvhfhbPOcTkpEioibkkPKAktFCN7T1koyGOsvJ35ZYlAP/TBPxjD3cXy8naeO0JOBfwJwi1sRjoDSQEulNJPj8nBsPICGcpiG0r+Uw756/PmfgF9LBMA3X5DantWTr1H9wHp9y05WfP/DW/TZFxiOI5icwSKH/T6bfsvn6gMe+sBleeIwfdBb9DO//1jfyp/SY9flaX/W48xPczBVkj5bOz7c7sg2cLF2vL2FlAMqNR8Hzzo0PLkc6d7uSClC/5FVLfTuS6J5hmwIG9qq4wUD+z6ys5asDiwiJoxZiK7hqr7l7XBRFpdmZFfhvGHJEO8/KYJYtGjRokWLFi1atGhWJj84z5/XOzOUmUGiTLCi9KIU1JUeh3lKU3HqSh88H0q8pCimFFiYM3iHqMNSLPGbZPo0oJZLUa06EJ0iHHNxkKU8rWUURSfXnOBE0TCv7gyVXHrnqYIvvTRTSogIXhwplWhZUYdXKVBWwaxnGAeSKTFmsigExVli6Hu6fs8Znk1YY5I426zZWcZVNdjIOI6s2xbtImIJKsd+O3Lz7g1XT5/y4tkTfnj1jovzS+LQ4X3g6uKM25truvs9dXAMQ8KFluwr9l3Har0heI8qhFDjQ4OZ5z8ZrBrlH759y3ff37K77/jFzy549mTFeuWom8DQRwSjqSE45WxVMYbEmAyysEkV5j2hChiCqTusY7wr8+lFUDO6bc+7V9e8/uGaH97teHcT2Q41wV+wbi85azacr1r+8MP3fLz+gE7ut0O7DTGyCKNAJBLN40NNzko3ZBqvkK1AxziwalucU/q+I3hl6DuqkDE1hi6WZCMNdLuIuoCJp2k21HVNt+/ZbbfUPjMMPav1OdttTzeM7MaB7vojz55d0g8N++2eq8sNdVCcBsSMqgpYGuj6e0K7JlSlD6mpI1surjuMkUgiMg4Dqp5snpxyiWl1RiTRj/spojaDCjlP/lJVKhFar6yaimt1DDlzs98XgDzHKIsnTfPop2J3AbwoTeUIQYuDWCpMA+JqRBPOjGE07vYREUcdHKs60LaBaoKV6kq/V3ClL+NUWFBSoBxYuU5hxZyMIoTKI86hWsajzk8FBVYgJ6eg8mHBsE29I4+37RD9Ov/+4PqF2fTdN1yeXNzZSHk8PD9Pjsucy/vPMbClj2WBkjHFAi3HgEuRHMt9muIEKuMEoFNpw5PL7+n/g7+3ixYtWrRo0aJ/u/ozQOWcfV9uqboHcOVhlCOk/R2huWQ7dFQYNl4j6xdkv4I84KRc7M8Gw91r/PCO6uoXjLoqMSXVS0J4Qrr7Lal6gm+fYqsrwjiSb/+AXvzsCFpESwZ+zqjTEilDPiCxMsa5N+MEHWe4Sjnpfwgg9bBdB4A2xVccHJAPeNYc9/oI2pz2aZ8+2WZQpIIdXFkHb+MRYGHoBFyzZJSMa5+hq2dUzY7Q7chxR/AwaAEqJkxwVo7OwXzqmSu0aoY/crK/PonI/YyOPTyNOcjjk36WPDyZPtx38u94nMyuTjneN8XTqsHzjVHZnspfIC4hmkELLMzFUIkLysVmzaYJvKw6ftvDGGew/HBcE7X7BJQ9hmslMXUe07xPHvDWh9s8LTo+obYyOyv10WfOP/Wwr39KGUgyEKVmtCdU9QWd+0jdNOzjCks35NTj/LrMpz0I9GXuC3EcQ4kBlpPHjgT7c5vxeH4eg8Y/Dit/DGDOhQ1l0XXy+HQ4GALi+HCX4eklOM9gO+5lU/6a5YzHc7vNaPZ4b6TumrOzL9nznFJzmlEUI7IbHFsNrFzPhXSMCe6pgEAmsxuMNjiuwpYPwwongUDkfOO5y++Al9N3eHFULlq0aNGiRYsWLfpUOZdzbJECFcUJ3jmqqmbdVqxWLW1b0zQtdd1MALMk8DjvpiVEcUqpCm4q0JysUTCDhVRiVYe+p64bnHq8ONSVPo9zvKSIh6mgVSi9AQVwKod+ffM6KYQSFwulV7tzDgkTfIsJUSlrdeeJKRPHESPjvCIGFQ0xJtQpGmG77YhDT+UNQYnRuLndknE0bUtVB8bRk8ZMXa3Z3t6S9gMAuz4SgvDk6py6Upow0DaOFDfc3t+zvlgTnCMNA1+2L+j7jtubHc57hvEO8cJQN9zvOrKuaYLHO8XVRmhWPHt2RRWMdeX4y9uuAgAAIABJREFU9Xfv+e7jLf/XmNj1I188azDLtOsKFcgx430pgk25rNRxUHmhaYRQ1/STyzKlERXDC4gKLhvjvuftd9f8y7dveXM98GFndIMnVOesm3PW9ZoQKn7zh2959foP5NThLB/qqZMZg4G5EueKKM6HaTWdEcmMcSDl4jStfDkG+r6n7/dUlWfd1jhNjP2evh/AjL7rSLHH1w0rX6B5igPZIqhRuQLj1Al5jOxurmHo+ebLr1idnXG3vScEz1fffMU4dgUAqhKqAKkU84qVXqfD0OGrGlVfwFfOxFx6HcYIOY/gUun9WPlDmtPYd8R+j1fAablWgCOLkMXhguBqDyrs+wh5JBVsTJr6NMKID4qZBxKkoazhrTggvQpelcp5nE69IpOx3+/Z7QfUO3xw1LWjCg7nBHUgTqbidco+EYcTx5iL6zMxOZSt9H6tqgZxHoypEMEjU2ytaGlxo/P1CU6vIRwLDB6Cy+n3E0BpMEFHwFJxRmdKb09j+t0fIOUh8nWCi5aOcbApOXJOuBjJqSKFSIwFVLo0Tq7L0hczxxlwxsN7+EepSYsWLVq0aNGiRaf6k0GlweGkCT513xWKJyXSxjJ5vKV58g3p7i2ucWh1iek5uj4jt5egShoG+o+/Yd1ewdO/w0zxGAkjKYgF3OVfo9vXxLvfwtkvcBdfkK5/Td69RdYvwEoDcIeAJUQcaD7ASMNK9ekn7sGHi7ITs+T8jFJtNzM1OUKp4zM+Mw/HDzi+98kLBDA9fm4BSzOseug8RAwxgaygHnGAO8M52I8jK9+AlIpVrzqNbYaUc+meHnbgbLY8ADgUJH8WIH12H0/vc/pYcQfOkLPE/Zw+/on7buaRs1NVOEnRLDGxJpDEuLq65PrVDzxb3QGu9LKQPYcelwJOjMtzz6aN/Pz5GW9eV1xvH27P0Zk4g+0Td+UBQs73gcgRQpXHS5RMgZyngOrUh3jYgsnFOSHY2W352ec/nKvjmE6OU0pRgKNFfSCmmrtupDiGM8FXDNVmOnLyFGd6Un150rz+4bbmqZpUj/B5cqBy4jotUVCfHgt/zDX5ub6dn+sFmnM+OD3l4CI+KRxgrkwtWL9Wpd9nVCDlBKJEEiqO2w5eaEBM2dkTsgNMcWJTvw9BsqBZ2VrFTioal7h0OwbbM8aWRKAbOmiecBVuuY5ndLmlCS2y81B5MiPTAbFo0aJFixYtWrRo0QNtVi2YIjjEK8GVOMmqqmnrmrqp8LVDfZjiGiOWXekzNzumcsQs4b3HfMLnOBXeGnlyW1ahgsYIrsJ5T11VVFXAhTA5NQt4KsW2WkCEyFQIOH1WyvgZkjqd1lhS1hrOH1yZKkISYxxj6evnPLhAqFvMMuPYkydnZ+UDeehwKjy5vGTsKrr9PSLGZuWIlum298Qx4kNN05yxT1uGaFTNJe/ev6dqAuo9r968Z3d2zs9elDSmFAeeXq1xJnRdhnXN85fPub/5SKgD17c77m/3WIYPNx36/TVXT2/4xV//gtSuWDUNTh2rdgUkRCJ/Xwe++eoZ//DP3/OP377ln357zdt3FV9e1Ty9qrm8amnWFTEJ3juc+rJGk4z3kFJk//GGsYecEi4kVqsKZ0q3y1x/2PH+7Q3fvbrn+w97bjqH2ZqmPaNtNpxvLnhyfsEPb3/g9999C6nHWYnhnK8R5AyoFB+seEQc45AYhwGzSEoD9WpNzpm2XZcx7XaMYyRUSqgcyRJ5zICnbVu6/YAPgncN3gf23UBVeXKKeO9pVxu6IVMFJaeBs7bGXV1SffGCly+/5g8/vCWElrbxjNEwPNu7W64uzjFRQlUTh56YIt5JibL1HtFynI1jz939DcMQqds1XR9BHZvzpjgznSPHzDAOjGOParki4G3O1BJMDa9G5cE7o8+5pGPpSUsdK7DMa6AJUGnGS5zSpbTAd2eEIFQVhMoIIgxD4uZmR9cZwQWcU3zQcgy4UmyrOh0P6kF9KTLPGZ36RqoIqJQemVWFOEcyimNUjkXTMgNK1amYft7zrmwCn1+LH2Dlye1sNkW/AlJifHMWzEampFjMAtnKGG2O4s2JbAmZ4K7lRI4FQs5AMqZESnFyUBZQOf/LubgxUyqvtak/Zv4j1w0WLVq0aNGiRX+5+pNBpYp7CCsObrFy39QVkAQMcSSkSK6fkNI/s3r2K9R1mFU4uSSqZ7z5Dr+/Zf3sl+BaQEBPejZOFCuK4Tdf4eMd8fo3jOuvqS9/RXr/v0K1waoGZ0q0ERsHEhAQouXSr1ILpHzYUfIoEyZ32WHDmCnJ7DgTOJz8PXCGyUmPv8+5EQ+3T1yFNsOh2dH2sKfg3KeyTMHcazGBeajPycMHotvTVqE8z9d4PEZEcUfcOUFjm2GsPDzBnSNwCxM6gYp/xN33APRN9xyTRY7xpvP7nToWRaRYcueqwxN+N79j6SupxUEqDhkju76cqisRRBiGETcBWK+Otmqp65ZVW08n+BwqMI/jPkLCh9Gmx4GcOilPnY5HQ6YdnmN2uq+PoHk+fktMz3G+TqHo4VVmp1NwGFv5ZT4+Sl+JKIqjYsWW64/Ky82abEqwAQkbLOdy5M7geD7eZ7ZuVph1LvvpcGOqNs3Tdh7mKR8Zp3A8vn8MWP6YY/JxhOypTnuzzt+4B1M6jc0EvFNGS6zrzDAEStKugilJMs4yLbdUVcQ7hx9+YKy+wJwnYajZtN1GJk1zlOmi0dkZlYd1tcW7kW5I3PYRrVrOuWYbn7JyNRa7qar5R4oTFv2blIj8Avgt8D+a2f/w/+tgFi1atGjRokX/5nW+aqcUIkdkKjy1PEVelp5wNhhxzFP/wuKuchMwhFIgrKqIlFhYpLjahOJOE3V4ESwUODAMPXHoGCdQWdxaYXJoOqAkGWFMUbOlOLMURer0Wcf2Bs5V031M636ZerxDHiN97BGNOK1QUcR0Kow1fFVTm9CLQ0mEekW93hD7fYGvQE5WXJk5cn9/X/oFuoKOLq8u6PstVVC+/tkL7u92vL8d6bKSc8emNdpVxc39R95/f08fE0+enkMaOaNm6D+w63dEM7L1DP0ei1u++fnPCc9eYL5BtSL4hvPzp6Smpz3rac/OeHp+zj/85ju+e3vLh5uO5zc1L+8GnpzVNGvPxUVLcAlzmbYKaHL0w8D2Zk+3HUkxo5XSty37/cDrV3e8e7/jw13Pu52xS4q6mrN6hfOeEEqk6LubN7x9/wMu9iVpJpf43qwQDUwVN6UsqaUSL6oOscz+7p66PiM1A2dnZ4zjQIwFGm82G7puW/ZqNoZhoK09cUg4V9yEKWdiynT9QMpCCIEqNHx4+xZ1gdX5ObvtSEwQqoqqWXGz23N9d4tXWLdrtvc3BCcEJ/T7PU0b8OpQV5UI4JjwzjMOI6qe/X7H9v5u6lWZGceBZMKw61g1Z3gXwAWSjWTm/otlHeadwwtTco7gndDWnroJ7HaxRMMeCrgBjCp4zlYNTeVxpYknQokDFhWcd4TK01SB2iuaB+62A2/f3ZOjECqlDkpbl2IA79xh+0p0qy9rflHyVJk+53mp86AFUNo4FgOAhkPhtTop3yGkRDZzvI4yL8hFHhfJPiwGP16T4nj8mJSi9FyueWSTyU0JNsVT55Qxl5EJcKacISf87Lb0xfmaTiDkDCVTHAvczJkY44PnzGNIOf3RAudF/za0rJkXLVq0aNH/G/qTQeXnIj6PAGZa+GhGMtD9QBP60hcgjkhzzpgMN74njxu6V9+zWl3hXv7H42sP1sUZ7kBCUQtkNfAbqqtfkLffMg7nyNP/BvfxH5HzvyWpQtrSushadowmVOLKSeIJVPoEJM6xnEyurgeRmRzHwkMQ81mn4SMX3GdPyE7u01M4eIBixz6Vs8sti0AaUSIqFTHecP3294QqYk3FOHbkcIYzB6RpIXkyZgw7RAXNEPh0bA9PeuWRw/LU/TZDLDuZmCOqnX8eHYcP4kimn/Pi+0FfRihAjtnBl1A8m5Xxn//7/46ud4gUx18x+CXMSmWvemX1f7P3ZrG2JWl+1+/7Ita0hzPceyuHGrq6utrtxm2GboyEkGW64YEnDBYIJCzEqPYDTwZaAiwGGx544AEJaNEGCSEEUiMGCyNaDILiAVtYeKBNj9VjVmbevJn33jPsaQ0R8fEQa+29z7nnZmZnVbur0vuvurnPWXvtWCsi1j4VX/y///9b1Pz+r874wsWC7tdttD69X/NzGuu7/TqelteJY++OzzRv+yPjvwOxeThPxmDh1fGcfg4pZXL16BpTLZvDeYaQ6G3GwnaE9pYVBkT60OOocxAwfV4MMd2TznkYju9hPI9jMvJoPMZz9IFn/uMIx+Pf79f2vH/usQ1trvuZM4bvKHDFsnWxZLspMWHZBN5vK5K6bDfDQIlS2w1JQg7qnCNVjyi7ZwzlG6AFUcYqH+M0yUTQigeFPvYMqeHtKkDcQvcBoZ2htWMZnhFtnb9CaeDA/p5wwgknnHDCCSeccMJdrFerXMPRsgrRofiioI4BR6RwhlgmEE0Ecw4pMhHoXT6u6iiKkqqu8S7X9UspEmJHimNtOoukoWe7XrHbbSElqrKkbipKX+HKAl9UFL5EfQlTjcyxPp6OJU6cSiZV9ECYAHuiFFWIOdlRxSGFYiEQUyCFbp98S0yEmIklBEQ9Q0jEEJEIoiXOOWLXomqZTCtLzs4vaXcdQwwUDpqmyiq9PhBC5MnjCzZdoAuR8/MnbNZbYODi8oI+3vDe+x9wu1nzpS++yeLxYwLK7v1ntDe3PLpcsJwXtNtrfvObLdvNjsvHT5gvFviiog2JKIm68jTlHC8VgjIvn/L0esO7H+54+nJgXjqaRlnMlKYQ5rOCZdNQimJEhhTphkC/Dey6RNdfc73tue0St22iDTAMSuErHI6277B2R7tZcfX8ffq+YwjD3ibUqY57JNmeFKAolALFiWJJSCkwdC2b1RX1Ys7ifEnf7RBf4ryjqRtub1eoROqyonCOQhUnIZeWUcukpG9YbTaoZBKwqGs2ux19t+MLj2u67Q1dm5M5RWHXB0K4whFpmgpVaNdr/NmMrt8hVY3FSD8qKXe7DW4oKMqK1aYnWUu725DSQFlWWUmcIkXRsNnk+ppGfhZBGcLoBKQyKlnzuKRkKNkauao8s0XFet3TxgRj7CgKZeU4X9aczUrmHmZOaLxQquQxLQt8WeDLiqIocGL0/cCzj255eb1FqKmc0NQFTVPiCz/WlM3KZhlJyCn5elISjrs7436TEEKuEemKcp8ckBO1LacNT0SnjaG7GSLuoHK+t+9ynEy9x5QUr1llaeS6trZvc0xantSUemQZa4YbLWR9SkSzrKqcFJUpZTXlZA8bi/17MR7OyXUyj1Sa6RQ4n3DCCSeccMIJD+PbqFGZcYe4OlJYieYqcKqOtjfqek4aAoWAL2bshhuCLvHPf4WzN3+MuDgHSYgViExltg9EWF7ORWzMIEWVIZbo8vdRdi/or34DWf4A/ctfpXjzRyDO6FLBUDwGl+sBiOXF7ccSUHeUkPtctAcIvUkzdyD7MmG3XyHePe++9eV9Mgoyp3fgfA+Kx73KMqvi0jAQrSXFLQ1CM59TFi114wkvh5xRKCkTdHZ0j4wE1GjL+yqRdnR/+zl9mIg9Vs7esTYdsxSPlYmvw3G9ysNIT7M+/TcvyJMldl3kvXef8f1f/9twJmMmqdLUNUPfIWIUGEXZ8Fsvz3m6LikUdkfKyeM+3iFYX6vyu6sMtSNp4es+c/TpTHoj974nD5+95+cfaGd6/ERyZqWPhrfrXPfUO87OK+p6xjoWEFtiAJVzJB09R9NVZLoa+2fqEzMbZU9Jf/xp90jJ19UsvT92h/5Nnx2/+5aO2sh1OmQM1oMNkDwx1qjm2jqFOOa8ZKdLZrYGqRF7SZISad6kaD+gL97Ea0kkt73/KyOKixNhW5CAD3cNs2HHrmho1OFshysqhnaNSiSkgLripKo84YQTTjjhhBNOOOFBXLfbMXczqyIL73NSqcVc31FzWQnnMolReE/VVJRlJkDyWl1wTkZiIVsyDrEjDB0pZlmUpUAKPXHYkoYdFgJD6NDUY2WPCyWpClDleokq1UiCerxzqGYiQrBM/qjHFf6QxjrFkwZxLBuBKg7FcIhV2Q4yDFmphcuWm2Fg6LOSMYYBp4YvHN1uRxiMGHqGbsB5jzrBFyVnZw3X1zds1i1mifmsApftMNUpb54/4uX1huublrfffot2vaLf3fL173+Lj65v6Drj+Qc3aLGl7zvmiyXeeVLsQDyz5Yzt9Ypf+8Vf4OzxOW+9/SUuLp+wWJ5T1Q2qMPQ99TzxlS+9wbz2vPXhNe+/uOLFLvB81fPBdQIxCg/eQSFXlE5zn0eL3BBh1xltByEpztXEkG1c1SLEjiF0mDgMYZcChURK9RTkii9mmYxT0VzWQ4QQIxIF5wvUlQxDR3BK1w0MfczEtwkxDHjvqauam5trQgicny9zjK2gJCDivKCuYuhCJkZdyirIooBoaIK6rFivMwEehwGLgaqe450wryrUOaIl1qs1Z+cX3K6uUTW8c6xXV3hJlGWRn9E0AMYwtGx3u1wexbIqzzvJrliVY3neUFQOIz+XliLD0GEp4FRHt6w4hucJiYlShWXjeeNRQ98OPO83hJAj4qp0nC8rLpcV80qYVTBrhKZ2NHNPPSspGk9dF5Sl4NRIXcvN8yveee8Zq03Loiwo1JjPSqq6wO1j3BznTopDS/n7HEMYiUrJqs+hxwwCirisjDXSnUTjfYKAxtHeN+8FKVPyszBtHokc76bcxf3yOzK5Ptm4XbXPVD4kVNu4l3NMWCZL+NEWNo5ko9mkmAyZXA5xJCIjIdkdopKUyWdL8Z4T1QknnHDCCSeccMIB3zZRmfkou7MI0lGpFs2RnND3tyyqmtvR/rJX6G+fsVg+ovrqHya8+EV89SOYBWJdoElgrLnBSNCBkLC8mB4XU7l2oBCbxzTVgv76W2jREJ9/Ey6+D7WUrXHwQBiz1z4eMi4CD8TboeD3VEdx6vkxATUxLcfkyzGROVlw2PG5dy48qgfHc6bMU0X2yk61XKsREr55ROlLEp7L5Rt0q/cAGa1f3NjXcTFq7PuT/yf7uzsmVyflnsG4GL6bmXfXInVS+aVDO3cosSM16H3SaiRq90I0GzN0YbRxOXw213QExHCuhKJgtbqivjhDFLxzhD7gtCDQg3M4V3DZJKq5QzXmbMt7xOl9Jd+0CD+2pj3c6rRwT0dKRNn38ZjjO57rw3mHn48Difs2s+PDsucRD+N9aCFZzhQNJIIucKwpZk8I4RYjEplRFBDDGHmoMdWoPIhrs8XrPkg4mp+9BZSOfT5SNR6JMF95Jo5x/JyISA5O7r3/MI7J7sO4HojLTFJWpTC7OKOMLbvdAtP8BBZqVNzS2gW9GDPb0XKJKKSY6IsaX79B039IyxPQeiSSjakepslY1zMpDhjEY67Eo6xtgVpNYR1hHYghksKAanESVJ5wwgknnHDCCSec8CCmmnEOwRloys4ezmWLybKs8N5R+jLHf4VD1JMs1zi0mFWI3nuqKoJ4VBUvjqQesQCjdSMChfcEFYZs/4GkhFnE0kAcIIyxjU+ClopaIiWZQu78H1WcH+OzdFBZqSoMmbhICCoFoopTxeUqDHfioxgdguaEQKe02w0x9ISULWElRbzm+wwx4rzHELouMJvNcOpYr1dst1ucL6iqmpgCfTdwNp9zdbPi/Xff58tffILThnYIvPnGYwC8q7i+3fL06YaYHHVTk1LBRy9uKDeOL1wuOT9fcLO6Zb16gRHph55Hl49QV1E1MxYpYHbOfNbw5OKcr7VvcbXa8Nvvfci3rtY8u23Z9nCbsmLPixDHJF6RhHeKRU+Mmdgdwm5U/eVEbJ2Sis1AYib2RGkcuCK7yKgrs00wEA0ER+h7Sid4iSgRrx5LRtd3RGuIMWQCqd0SUmC7ukXVcXZxTll5hEz4eZfyM6me7bajH3LWZjChqhq8KwnDgGCEGJkvG1a3G5ZnS54+fZ/Hjx/jvKMfAt0QaXdbzhZzQuj36eZ93yFxh5Qec4rzU9mOHNcWviQZWZGbIr5wOOfxvmA+99R1nfc2zHBimXhPCXFTvcZcwkST4dSybbLBk0VJdzFnverZbgcKD+fLiieXM+aNpy6FpnQUZUFRFfiqwNclVZWTBJwzSD27zYr3n73kwxe3xCD4MjGrhLN5TV1WeVfAjGgRiKjlPRzDCJby8yA5Hg0pEiJZ4egqvMj47CeSBVQNjRHnPIIiallVieaYVtKoLD3gQaezcZ9KTHJsOx7bx9SS99LynwzZ7xdMWzz7OPwOaZkwn3CTDWxK2ERIWiL5lOcwJvw9onIicFOK93P/TzjhhBNOOOGEE/b4tojKiT7IHvx3bT0TDhVIltB+g58v6LdrfKGkm/coll9Al2+Br9EnP8zu6c9TXX4drROQrT2nJK9JpSc2VnIcrUtzBl1+r9cKefR1yvU7xJuPkJuYExldQSK3+RDu19k8Lj4+0TrHyr/p94lre21b49jcsbyc1FvHisqJsDxOhDNyQGeH/otlW9rCjKHbIOKJwxorLigr8EPDrttSz79A1ClpN/dHnb5atHxPxmZM5zMGlglDlbG24qu1CGV/7uEmxSZJ6GGOXlFVWi4ivydjx7fTSO4d6nMesv1EBYkOr11ebCdDbcygtIRzHrNMSBbekUTx0vGj37fgL/wSe3L2eM6OrWc/3r70rjrQ0KP2pkk7trc9TP60sL+jZ7S7ROg07NNnH+LwZP9wGKjmehKizCQRQ0VdCGezGZI8yZVY8pB2TMU5ZazFeLixnAQg+7kaSUcT3BhI2XhDAns72APJfSApj8frdRbB9/EQIXyf0H1obHIfHG2AGQ21j1yHAiNSWU8tHdeyABOcBfqguOQonBLJ1lpGyVB9mbr7Fi1fIGmZnymdLIIPAZ2NQeZggkhANRATEBzBFOfBYoswf3jiTvieh4j8MPDvAn8EqIC/CvwZM/tfjs75t4B/E/gJM/vGvc9/Pw/U7hCRN4GfAv5B4MvAADwD/uLY/m/8LnXphBNOOOGEE074GwynMLGA4jQr3OqG+WzBYnZGU9eZoBAYYmDYBUwHnHd4BVLEYkAIBAe+qFGpUF+MBFZev8ckJBNEPaI5/uvDgHpPGbK1Zy4hEcAGhBJiIPQQneKjQ1TxhcNUSSkiYjjNrkQJI1raS/z2JTxSIlkkDP1YvUNznT7xOWZKRoy5JMNsNqdrhV27JcZE4YSqrtGyYBgyYVP4imHYkWJPXXmqiyVd36Kq1PMFt7ct33r6HIA3nzyGNLC6+ohmXuF9tpe9utqw3b3g8ZMLvvrVN5BkvLha8cGzK4q6Ynm+QFQ4O1swP5tzfXVLDNeEIbBb33B+ecFyuaCuHGo1sXE8ebQgxMjt7Yo3Hs352vWKDz54wcvVjvevOzZ9IGC0veS5iEIIubakAk4Shfc5SdISZeEyeS3gLadkV76gUod3ZJITgWQMlhhIec5M6ZJRVx5LAZWUSex6qmdakKxltXpOMz8jkei7gYuLR9RlSUqBmAaUnJxpkojJCCECiplmla2v2W7XVE2F4rm4vKBrdzw6P6cfAl/4wps4dey2O5z3DF1PDIGb2xuW8wUpJi6Wi2wHrFCURSa91CiLEl9W+AF2XY+oEtOQyW5TLObnqCo9TT3L9rYm+f4kKy5NBOccSIKUrVJ9zDUUB0t4F7lYOp6ce25kYF4VPLmoWNZK44yFF5rSU9U1xayinNU0dUldV5ROcClgQ8fzF9f81nvP2Ww6Zr5hMXM8Op9zdr6gamp84VCneOdznVD1QLZxTjERLRHCQBzCnrwVDCSRUqDrDQ0R50q89zinoz2qjLVjj2rTTvssY1LzHcXkUdJz1l5OhOSUDHyvrqUc/i5xtC+wj9FlTEkf96ssGaSEc0ZKRkrZulZjToTIRKTf27+6eyRl/jtxvNd2wucFnyZmHs+rgD8J/HHg60AA/l/gPzCz//pee78EfMPMfuI11/zrwA8D32dmT7/jnTrhhBNOOOH3BN9WjcpJfSg2UjWTIjCnyJEsIRZw1tOnGWn7klkxx8+fEF9+iJ/d4sOMpAX1+Zcph6d06QluIiaRV655X52Xib8D+ZHm349rnrD+zW8Q+haj4KD0eyjb7NV+3SGmjgiZO3UUX3PeJ9Xsu0PmwD5wyT2+d/69vppFTF22uexuSNWbFM0FyZ7inSItpOIcwm5cpGbb0VfavYfX1Uy8a7v5cBsmuTD8oQLicbu5V3dIK5GxRubIO90jDg9k2KSozRm2Jko3KBsCrSTewsbsYKUbBlY3N9SFYlIjlihcxa+8n4vR7/WxD8zZfUwE60O2pAea7ni+j+fn3hjZmFW8VwYe+npftXmX+Lt3D5MUUmQMFAyViJNIdJFtKDg/m2EScGlNpMRZi5oRyTcgHD9T+3Tp455Ps3Y8GPvfReSoH58cXHy8zau8cs4DLewJ1On+J01yngrF+0jXKTN2iEbW6Wwfb83Z0umSyGiTlRIuOQY1khmu+CLV8AG9XGI6gzhw34XGxkznhMPbAMlBt6btr5ldfIkFL7la9yBKznE+4XOGr5GJw78O/AzwNvCPAz8nIv+Emf3sZ2lURGbA/0UOzv5X4M+Tv4BfBf4h4L8BTkTlCSeccMIJJ3xOUIjHeY/Tgrqe0dQNs6ahqgpEEn3f5gRbhJhSToxTh0pOzFWX46dsjRkIw4DXAhWPVyUFIUYhDBBCIMUB0UzihH5gt9sRhoEy1STJScbiEpPLSkohq7RU9yRIShEE1B+ig4lwEIA4WloSx9qVkutwhoRzY9KfJtRBgSMlj4qRhoGyqDARNqsburaFpJRlRdOUqPdjUiasbzteXl2jzoMKs1lFNWu4LArWtze025bbly+Yz2u0UF58dIs5hy9KyqJit4v8xq9KWCBTAAAgAElEQVQ/xXvlyZNLitmMpplhw8CyrigqpU2BqixZnF1ws7ohbW5oioIUW8JwxmJ2RlmV1K5BRRnSgIhj3ixYLm95vCgJfeDqdsfNesf1puXDm5ZuUPoI/Vivr/CeFHN8XXhP4QsKwAtZGekEp0LlPV4hxBzHpwjBYNeD9DBogCQ0ZUlZOEI/zocThpRAKkIfsBDp2x3z2ZJ5XbNoGqqmoN2uxmTaRDnWY7QwEIaBolDMPDEIcejpul0OB9WPROSGumwIYUCdUM9mOYFYlPXtiqrxOOeoqxnbzY66VLbrK2Z1RVXVFGVJCAPOVRRFRQjZ4adtO8q6HBOIc11OUSWEkG2SJT9fCRgsEUz2NSHVuZHQTVgUNEDoAyEO+DiwKIwvPvI8mtWU3tNUQukjTeGpa0fVFFSzgvm8ZjlrmJe5JmXqWyKwXd3yzjsf8OzZGh8958uKi0XJ+WXDfN5Q1Q1llb/bzlU5SV7dSOxlci6GgTj0iNlomCxYCsQ+Wyir8xRFJiRjgBjJcf9ITh7Ulfl7mL+j8kpMjch+P04lW0arKJNKWmUqgTTWmnWW2wEmh6HJQWza65OjTGpTG/8O5YQHVc1/DyRh5o7UkxHnDr/fISstfaq9hBO+p/CpYmYRKYH/Gfh7gV8G/iNgBvyjwM+KyN9hZv8agJn9soj8H8BPiMgPmdmvHl9QRP4e4A8C/+2JpDzhhBNO+HzhMxOVKkLab+xPEqxpsXRQsMUYuLl9Qdp+SBpK9PKC7foWSy1dMOL2BYVZzrC6+BrF9S+SLn8kL+Tk0Ob+ujrZWB7Uj3sLVhEUpbeKIRZgEdTQsZ7HK0zEa/CwfQbZmvXA+t3VgD1Aot5Xnd1vb+rdRAcJ90ibYwUmgDokRVK7xpujbN4gxYGPPnjJsH2GOIGGAzGlCvFANk6U3X3C9RiZZJ7Wo4frv45UOjwCeTE8ZfeNrXFM6t2/lo4MoB0d36tomSyE00jQCSElosHCBYbYM3R9tlkJ4FzkfFkR+47CRWZnb3CzXr1Kx90jzV5H0h5m5e57EzGZlbL3R2EkYqcTOZCUD1/jaOwmgvbo+TqMSbpD2itQu4CGHVs753bT8avvfEjoBpI8wllEfGAgWzndMaK90+5B0bpXKU/3YOPXxaYAZd/D+0PzIHn/ahdffX6O1caZFM+NH1u9Hi46vRrJyHVtglEMt0Tn6WQ5kuX5O1JKy1aXJCMrbtNA0ISzPJodgi/fZD58wK0a4mbIUeCUuz7+XRKP0564fU6fOqrl2wSgqFrs5gpIr8zzCZ8L/BHg3zOzn5oOiMh/SA7E/mMR+Tkzu/0M7f79ZJLy3zezP3n8xhjAVZ/UgIj85de89cMA3/jGNz7Dbf3Ni9VqBZzG7XeK07h9NpzG7bPhs4zb9JkTTvi9xtniYrR3LfDegQkhDKTU47zDOYfzgnOKiMsqJTvEQ06zyi3GRIqJYQg4HSi9ZptL54gxghkxJGKf7ReF3FAMkTQkQiQrLk3xEUQLnHrUZSckt1eo5Vp0yQlpMsyB8YfRukcz8RHMiDHhnKLqQPNaPsWBGHrG/GNUPc55Illt5mJAEbbtQOiN1BjeDZRNTVHWzJqGsvCEswvWmxXb7ZpkClKSCCwvGmbzkhcvrrn54JZZI1wsG8wiQ2vsUsv5YkGh8xw3DhueX3dcni9Y1gVh6OluB8q6oigbIoZIiRm0vdCHlpCMoetomobFYklZL/G+oKmFqD11cc7FckbojUe7Fbu24+rqlu/btXRtZHW7JcQEapnASkrX9ixnMyxG+mHIJKWS/3ljvmhoFmfs2p7tpmO7aQkh4VJERXnZ9iQ886bORPQQSCL0IZKGyLIu6bod69tbfFWxPLtg6DpmixmiCRnJ0rIsqcqKFAZC35NiIIQeEUfft0SLxARFWbG5vSUMkVlTM/SbvWtWuwuZSA2JxXIBFnh5/QKS4TTHrCIOp46qqkaFLqSUS7p0/UA/9KPVqI5aQ0e3a1mcz3BqhDDQh54ihXxejIilHLelAM5QcchIXIbxu1KKzwpWIuXME8vsSGQCRa3MmpKmqZjPa+pZRTMrqWqPV8FCR+wGNtuO997/iN989znbNvJoPuNi2fD48ozzxZK6bijLCld4RAvQItcmTWOdSovEOJDiMOqRx3IkaSAkiBIRNVwhiIbRDjeAGCpZnemcEGPaE5X3rV3Zfz0lb8mNey46/st7Qpn0dOLGtscyQZYyYcl0Lih5jPKewMPJ+xOMw97csVtVSgpERDKJqZoVmKqjfeypRuXnDZ82Zv6XyCTlzwF/1MzCeO6fBv4S8K+KyP9oZn9hbOangZ8AfhL4l+9d8yfH15/5pJv7pLj5O4XTuv47i1O89N2N0/x8d+N7PW7+zETlgVAaM6442CVmZILMwoDESCoLkgXEHHb7DsXsnJkmpPRQf4Hh+inOnaHLt/A3v0p/+UO5vB4jOaRHMRJASneujwip3dDefJOqe8Hlm1/ievcs14+zkcB4oB8fr+q6e95Ur49R1Xa/jTvj89Bi7rNkjx2pK7PzpdJ3N5hb4NffoutW3H70S2jc4quGyi6hqFCmGhbjvYxtTIPwkG2nTPrLsa/TAB8LPO+rRw8GsgJTlt4dAu+uzeeetNy/e/R6dCEDkmXqTAHUcJrotmv8smBWzRnmK4beeOvtC9777WuGNlIvG+qq5tnNih96s+Yv/1Y39nF6Ng9zcGz7epdAu3v/dzH1YXp/+syUbTgSr3ag2h5W3Bq6rwN5/Awe12jcs5Z370Ag9DvMXzAvNqw/+Ba/FZ6xbQfECcmdE9sdOg8IHiRyIACn9qYHIb3Sxf134pW+7084HqQH3n6gLikPP/8Ha5njJ2H6N52jBytaFVIyLAZePH9KnP8AImeIxPysWERdRHAklJiMyjvouhwsW7bVsjHRYlO9xXz4kDZA8s1esyk2voqSxLHdXJM4Z7b4EpYCSRRcTXYrCdhrrKVP+J7GDfBnjg+Y2f8jIv8l8E8Bfwz4z7+N9nf3D5hZD/TfRpsnnHDCCSeccMJ3GRaLGckghMhu6LCYcGqUpaOmQKUgBmUIgnceJx4ULIGlrC4UEZxCIhBCoh/jDefc0bo714q0MWF4KtERYyL0A3Q9w9AztIGiLokpoSKUOgNXZqccJ6jzCBWikzJL92vwGDM5lMlVTzESGrl+JViRidEYJ5ImogjB0kiiQBJBfEFRNzQpELotxJhrT1qg2+0YQo4Fq7rh7PwCVxZYTOzWK8Aoy4Zt3HH+6BF9/5yu29HXgbOzOYui4vpqTWi3nC0LUiyp6jl12bFre55tN7z15mMen73Fer0mmPHo0RmLRUXbdvRhoGsTtx/csqqveXK5gNDTzCJFmetFqhdUPVXhKRpyQqQvmDc1XbvCTOjbQAwDIUXQAudKdm2PdwIp0m07vDqqusJUKMpcX7RuFmy3LTdX1ywqx2bVEvqe0BulOgKOwhW4SREb8/yXHlIaKIoK75TLizNgQNQQ8YDHUo+K4FWxFIFASn0mKVG6NtA0M9puNxLjASeBsjLCcJPZR/XELhGGiIgbVX/C1YsNimexXLDdbvCuQFPCOceub5k3FTEaJpEhDiSLDGGNK6BuasCoSkc3tMCA9w0w3qdlkktSohKlkJEvNyGlTLR57ygKoS49cTD6FkI3EBRSUKIpwTncbMZivmA2qynrkqZpaOqSpvT4mNi2O26v13zr/Zf86jsveHbVU4vjbFby5GLOkycXzBcLinKyai0QLUEdSchWrzHkfyFb0WJGTEbbdbQBgkWSOMRFfAyEGFGXlY7OOZwmVB0xCiK5Viky7XtNfX91T0dGJebB9nUkKjUnQTgYFdCZSRY92MoKiopiqjmhfIQeCRLgKFo/3syZNo3GPZG8z5L3HCYFZpqyHk5E5ecNnzZm/mfJT8y/OJGU47kfisi/DfynwD8PTETlnwOeAv+0iPwpM+sAROQC+MeAXwf+t9/Njp1wwgknnPA3Hp+9RqXI6CyxN9YcjwOW30sYQ3eNU09z/hb97h2cDIQUcFHYRkcZClg/xYYWnJD0CWoD7vrX0PPfT9SUA64YMNV9hmlKhjifa9F1t8jtU2z7Ac38Ar70h7G0Rfh5xCnGWAviITXbvjufvGDaq9omNaW8nnx8qL3XkTbHgrG7mXH3jptktVi9xHSOnH+NyiLl8iv0L36FYvEYVu/QxSdUCs5y/QYZ73lc3+6v/4oCTkb7XMmRse6JRhsXmg/VJWS/aN7Xq7zz/kj9HKkqNd/Afizvj810jtmU8RcJSZGUCGFNkssx61eJKnhRyqJACt3PyXY7GphIzs2ciPPjepIPzc2rBNvd+z/M390ai3vL2DFYn8jYuzgQcHf6e5A1HqkJj+7tmA6WbHtjrgQ82zDDfMNMGvqwItuw1AQcYiFbOCE5h/PeQ7WnYUVQu0dLTuT2dF/jUBzb6B5Ovfsd+LjfH/pcfrb1qN8JuPe9MsbsXcGN1SadCr11OEskN6qHnTDXll2ao8kYRJh5h+xgjMZGYjRnc1oSevcmtX1AGyG5Ek1jLVKzXLdn8xGLeoHzFYmepIIDhuSpVOhCjxY1J3zu8FfM7KG0om+Qg64f5bMRlf8n8B7wr4jIjwH/E9kK9q+Z2afyEDazv/Oh42PG6I/9+I//+Ge4rb95MWWancbtd4bTuH02nMbts+GzjNtyufzduZkTTvgd4mazIQwBi4ZzRjHWsnOjsklEEcsJddECOIGYYwnn8qa/ak5y9GNCqcWewYzgHPuERCWv/Z0iMa+vxTL5oJLrww3dQIprisGDJQr1ILk24qTIct7j1efwUSRbWArZutWyktI5l+OdlMa6fJIVYSqo5vp0zheEIWTGNYVMRPZDVpUNkYSgrsBE2Wx7BKOuS3zt8IVi4hAxNqtNjunME6Kw220Z4sBituDm6oo33vgC7WaNOCVJQ1M1LBbKMAzMZg1Ohc2mI4bEsm6oVLl6ecPN7ZamapBOaLcrisJRNw0xCqXvcIuSrt/y7OUNNpLAqg3eN6gW4OscF8XI8rwg9pGu2zJbVNnpJeWub7sdhuLLGSKOodsRh5ah70E888Uyk4Kpp/KayV1NNFVJYdDtWhIx1wt0QqkFXhXFKJyy7XONxyEa3dBjRFLq2XUb6sUM0kAILdt2R+GVpmlGJZxhBGLq8QLDMODUUZYV/TBQlErbbhARblc3WIo08+XoVhNyzdDKkSyx2264vDijqEtW6xWFFoTQ05QFYYgkG7CqxqnHgPV6A1Iw9KPVsQiu8KjzuBhIMib1puyYBXkwhUAhUKkQUhyrPVr+PhUOX5YojjgkvESigpXKECNDcuAbfDOnmc9oZjVVVdJUJU1VUKgwbHasb9a8+/5zvvnbL/jgxRaisphXXCyymvLsbEnVNBRlgbj8tctJt3ZIEIe93WlMRoqRPgT6YaDrAlEGTD0uZaI5xDjaQzvMlyTN1qqiB+LRphRukYPzEeyD+inO1omk1Pzdz20Iqo6ggorLlrBuSm5w++vo+PfIRiFAvla21s2XOkpoTqNCkiOXpOm98be8j2Tjz+PhkxXR5w2fGDOLyH8H/CDwnpn98gPn/u/j649OB8wsiMh/AvwbwD8C/FfjW/8k2Ufuz9qnUIJ8Utz8SZ//tDit67+zOMVL3904zc93N77X4+bPXqOSUeWUlyYcNHLTS14xDe1NXoR2A84rxeyC8vYZvg9Uq6e4/kuk+ZexcgEGKQmp/iKFPGNY/Tp2/nVsiFjhEMt1CUUd6hxh8wzalxTAEDuKt/9WUvU439NwmwlFdRxTRg/ZU77uGHw8EXmfvHqdsvLTXHcitl4heV65n4iY4J3RP/8mcdghvkLnTxCUZD3OecbV6iGTjolYSw/e837dqCNxJoxaxkx15iw+e+04vW6MZCKGxp7o4c3972la0N8boz35l3JgfH7eoIs3WSwr+n7IwbrLVqBNU2Ip4RDEGV95s2JRK5lSenUO79vRPqQAnGbgLqn7cH+PLUMnKvShMx+yAn7IMvjBz43HnYAlRYuBMtyCOixCUXjaIWKb93HFjGxy6snWK7za9mQRbIwq0AN7eTfRcbR/5XDKa62AHzj+0LP/6ufc0XPy6mdlzNIUy5mYqgVNvaBIG/o+EUKJ+TmRksb1vIznJDNmGimLEsJLfO9AHE5KkhZErcCMgQT6JrP0EdswJ7km19/oVqTdGjd/gtMNZ2XkNgQ6czTaYSHgfIWEHnzzypyd8D2PZ685/sH4ev5ZGjWzWxH5u4E/DfxR4B8Y33ouIj8N/DtmNnyWtk844YQTTjjhhO8+XN/cIMhIUHqQrIT0zuFU9gm1jqkWpZFCJIlhpvuFuY5kw+RSk2KPWFZAOlXwjhQcSRRxLiuyLJM5viwBRxrLfISY6LqW3fYW8YY6w6vgvEJ0OaHPAcmIKceDKkpRlPuYNSvuIkYmrRjVlymFHHuIok4zgWmC9yVOC8ygLDybtWERfJFo+1t2mxXXNze4wrM8P6MoK+q6oapKtpusvDMztruWMHQ8ubxg9vYTdpsVjy4e03eBfjBeXG9YLBYEHfiN33rBG2+cc/noDK061tcr5vOGuElsVjec1R4Btp3wrfdvOJvP+NrXvkSyxGbXsnoOQ7vC4kvU4FIVqd1I/AiFLxDvUXGkKhBqT7IBzJFMQBNltwMTqnrB0AdsPsvWv8FQXxFiJIQOpw0WBmJomc0bJCXWbYuqUVU10gVKjeAMIVJ5xcqSddczDCm78lZK2w5stxuaWY23yG5zy/XNFRdP3qRuzkFhGFosRUQycWzRiIB6JcaAqKdrt1kROgyoKmVVcTaf0XcD87pA1VivbxgGw7mKsvTc3NzQDz1+ViNEbm9uUYOzsyVmQjcM2SqVSNd1VM6T4o4wbLKKNg50XUdZlsQYUAXnFUvZHSnXU4U0wK7tKetEUTu0KHCqeM3fK5zgtSSUEEPCx0glBb6e48uaomqo64KmcsxKpZBEu2n56MPnvPPuS37tWy94erVFovCo9DyZFTw6m3G2nLOY1dRVOZYXGsm6GEAhpISFRIyRYRgYuo4Ye0IY6Pqero+EEEmSSBJz8r0kNBW5HfVgtrdRztastt/POTgw6cHgaLQf26sumYhJ3dePdZqfWVwmJhXFPDjJCRNotm7O52cL2KzGzOeM4sj8uYl4tNExa3TiSlnGvVdYp3HOzCaS87CfcMLnCp8mZp7i5tfVk5yOX9w7/meBPwX8CQ5E5U+SHYj+s9/xnZ5wwgknnPBdj89u/TqqrGRvlnhMzIzvqRDbW8w6UtrhHVAWJL9Ez95AJOIv36Zvb9GksBZ88QjKhli9hYZ3YfXbyMX3kWK2sRSMcPMubrimqC7orECdUL79dUwqEEOjkHKlCQxFzDA90JUPkUOvI9xeZ2P50O8P1XL8pM/cJ3EmQur+dbOizbCuJcUWiQ3EDos9vlBo18T0YgxkU144yjEZp7yCibxKmSjUcfGrIiRSzmS0w7nCxxO6D6sIj5WHBzXjREdlx0+5s2I9nqdoKVt1YrSdEds1s5lRVcrQj9czoyxLdrstCbh6fstf/MXE8IMjqZa9Pqd18yuqvo+fk4MV6/F7x8+N7c1b92zgg8/aQ78fk6Cvt37dfxhLKWdXS0KspuAGSzCvlBBvCf3Aph8QDz50UM2mBM/9HOa2LAcTd6fq8GqHOTFLd2xyAVJKd8bi01gnT336+HMfVrxOWaP5vvPfn20QisVbaLfF+QY3XCHRE22gN8dF2dJIh+AwraF4g2gJrEViSzlsQSKGEqWk00uK/gVdMhh6fOqws7c4LxI+Jm43LaZQuAIVh7VdVrjGLSKfibM64bsbb77m+Fvj6834Oj20D/3/6f1gCwAzexf45yR/Mf4A8PcB/wI5Y1SBf/2z3PAJJ5xwwgknnPDdhy4EnCqiirfjZFLdkwlMxzXHcFguRSDJkJRJyySCE4cXRadzNNteIoITj/mC6DxYwApPCIEYsu2skfKiRTxqDheztWQaIoSQHYxSIJrPa/xIrtc+WjaaKKSIqJJiIo313WNMe5WUiI7ky0iskN2RnPfECCEGYuwhGfPZgrKcs9OS0EfqGYR+DWb0mw3r1YqqmnFxecH55RlXV7ekaMybmpYE0Ti/OCMNHd3QcXZ5gXMVV1cv2e02WclH4N33P2II4ErH/PySsiiRsqLrB9ohoRohwVfeumToW65efoS6kqpqeHS+QC8bVIzr7UBrt5BespjXLOY183qBdxVaZkWqKxSlwUxwoiQBDUpVVFRVQVkMxGR0fd7biGakvkdTx9D3pBApimIkMgO7zYYUeupSWNTgQ0EwQT05hnaQJLHrIxFjVymbbcusUZxG+n5FUS158vgRZVnltsd5LhX6LjB0A23fIaoU3rFZ3+BKT1EoKp5ZXTB0Ld57hq5DZaCuS3a7lsIp88WCbkhsNxvqqmA+q1GMdb8DMR4/eYyKEWNLCilb5lYzorV0/QrnlNDnZ6IPRl3ViHhStL0aUIxMpg6JfhjY7Dpu11sWqcgEeBI0ejSz4iBQFiVeXSb9zXBlTVnNwXm8L6lKRyEJ+p6bTcuzj674zW99xDvv3vDiZQcGl7OCNy4a3nqy5MmjBct5RV15nIMpYT9hpBSIMdLHhMVEiJG+6+i7LSl0pJDJ5GGItEMiUiDe4RG8c6QEMeZ9mVzLcyQKhcOe2zgOHLkt7fcPkKPjsicodSQocw1Zn4nKkZw0TyYt1SNKrlcriohltbfma6q4/KyNiexihomhpsQpixn2FrdTzvG+7M+dez3hc4hPEzPf3Dt2H28fnbuHmb0nIv8D8MdE5IeBR8AfBH7WzD767Ld8wgknnHDCdyu+jRqViclKEUscVJTTYiovTMJ2xcWioEsR52fI8gfxyx7/+A+gpWdz+5Ti7G+hrBfEfg39irR7lhc51YI6vWT34l1k9pi4/haatpRnb9MWM9LtU5onX0bKS6IJSoSkRIWUIjGmTFTKq+q211mzfmwdvU/Aq7aoxwTVYXzuv//KveyJyYPKMi9UsyVMal8g3QrVhLUvkDbm+g/NghBzVq26bJWS99BfVVAe1IEjwWiH4HJvzSEgabwXy0vxY07xIYLvrip0ev/wuT1nNh44Vu5NqsrxBgHyYjkZSsIpSFXhXIMrslJWTemjoWNWckwRxRFIJHE4PcgDp4B5P/5H1/k0qtq7pLaMZN00LoeBmcxZHmrroXF79fqHeTm+/nReEsGsp9CWhpbN+j22oSWKUHvNdqbWg8VshTMSfPuggaN7Hn+fJmevYj265jFJOd1ntgt6eJzuH8+bG4epfXVcJ+LT7hDJd8Z9eizG8VbJNWe3zJiXhvVb2uoJF77F0o635SnJCp52j/hyPSDRiCSSKkqFSU3vIpp6NLU0tkbClsRAuP2AVhrqiy+iDDmojoLXRHCeaFCGD+ikIqJI7E8ONp9P/JiILB+wsvnx8fWvjq9X4+tXHmjjD33cBUa7ml8AfkFE/hzwDvAPcyIqTzjhhBNOOOFzg5iMZAkh4T3kn+SQnicjCQg5/hLDieJQGG0jzRLJIDpBvM/Ew0hQMpKeooovSsoqMGSWkSoVWBwI/TAqIKGLRjCDW2G13nB+vuAyRM4i1CGQQqQsa7xXUko5aVE0h/2WyRSTsWagCm6MjaZyDtM+QIyRlIZM1mlJrmeYtw6GFBlS3k+oZjPMnrC6Voa+x1JHUbhcYqFdc/0ycHFxzrypWW9WiFOWyzm7bofbKEkKVOF2tWGxFC4uz6jqkhcvrmlmDSkYtzcr5vMaP3fUy5LFoiINLZv1jtn5OaKJoW9BImnoEYSXL9bUVcV85mlmM1a0eF8QB2O13rFrW7pF5Gw+pzBP4T1aVOAKItnZyalSSJEJXxLiS0iCV8CE0ikp3RI7pfQeX3m22zV9t2G72rBrA9GEOPRIDFRaUomnKJVN2+LNuJg1hLgihR4h183U2NPdXOFSz8UbFclaynqZnXkEUCPGjhB2qEaGbkPVzKmrghgC3bDDSS7ns9u1eAEh7eOz66urbFeqJZv1lmo2pzkr6IcOIdG3PWrGfLFgaDvUJXyR7XNTCFiRqKqKq5srunZLXZWQQMxQKRDn6fqBsmhQlETCNBPdm+2G1a7let0hYlSFUHmH+oA4l4m+keB0qqg3VBRfKiIDuTAQ0CubfmC7bXn+Ys07713xzge3vLzpIAoXVcmjWcObF0veenLGk8dnLBZ1rjFKTqZ2o3LZohFDIIaIxcAwdHTtlq7bQBhIKTIE6NpEOxjiJFvoWt63gpxUrQRE3fiHYIq9mbYH9iKBZOlwkOPYeUw/39u9TqpKh/fFHaISn9WVTrPdtJMwEpu2JzhlJCpltAoeC/TkP1Ume6VlTgi/m4yd9xTSUS709PCd8DnDJ8bMZrYSkV8HfkBEfp+ZffPeuT8xvv6VB9r/aXKdyz8BXI7HfuY7cN8nnHDCCSd8F+Kz16gk21TcIZf2GFO/YkcKLYuLitsXHYtS6d//RXarZ3hXEMoKD+ze/b/pigLnFzkDNDkKOrh5n1V/S9f9NZxbcv7Vv4uhfJObF+8wn80pvvS3E2RARxWgWQ7wFOiHsM8ASzLWRbyn/nuIKHydfevryKX7591//676zu5YXXycbepxm6o6KgeFlAKuPEfTjtStSaGnx1GqISEQUwILOFOQNGr9DkSaHanqzGys68ARlxnzgnRS1I3nG5k0zP15PXn76rFxjHOH7+g606hGxMh1SEcl4p5EZLxXTUhyqAZmZYn1A9tdizowzbVbnOa2RWHwxvc/MX7oSxU//9u53okYRFLm6yTXTwX2hNuneSbuEmtTnQUba3keCFi9py++jymkeNgW2A4BCQcrqIM9LqgZhJZ08/8xOKHvAqEfqOczJOVc6bkriJJrmURNh/tjSjKVO/25SxA+TEI/ZFH7OrXo60h7OYz88UggcqQyHKsAACAASURBVHf8789HfhQtb35YJKnPlsAktjQsZ+C7DU1llL5iPZTZTmh4F8oaJTDnioKEiRERoikRJfmSKDOSneGGG+LlW5zTESRiEWq3w3SgHzo8z+m7RCsdLZ7CV8husyf6T/hc4ZyscPyp6YCI/CHgj5OzPf/78fBfGl//GRH5L8wsjOd+Zfz8HYjIjwDPzey+Tc6Ujbr9jvXghBNOOOGEE074PUcfMtEHER8TfUgUzojeSEnwHCxSp5IHzrlMDIoRjZGwTMTQkYaBoihGlZTDOYcrshrTFR6XyqzwShEXI2VVgCVC1xMJYAGNxhCMYZPYWMQT8SmiqUPTDutqOlfmMirqcL6kKB1OFPUFkOtTZgvamGNUtZG8UUKIec0eBkIYiHE1KrsczhVUVcEwBIZ+IMSAFsb8fEkfAqurj9hsbrm8WHI2r2nbHd32/2fvTX5t27Izr9+YxSp2cYpbvhd2RNpOTBpnphFYCCEhetlAArmBAIk2iFRKSIhG/gFIIESibNFANFKmRQN6ICSDACmpMqGTKUtgO12kwxEv3ntx7yl2sapZDBpz7X32OffcFy+fFY60Y3/Sefvuvao551p7vznmN75vGGzVYsQyTRN+UWGt4eb2trjLrFqcdWy3PXVVkdUi1mOIvLy+QFSJcceiVpSBiOP69UvqNnBzt2HV1hip2O42DOOWV69ecnV1SQqZu/uOfR/L8kbK5JzIKeGTYxrv6Lotq3XNxfqKGoPB4aslYhwxBcQUxZyIRWyFNUplLVkt/X6PEcHaxDR0DF1g6Pf02z0xBdpVxWY3YcSxbCzZWpxzWMk0dcW2H4n7wEWjTCOlFimKsw5nHd55mqYqhGN3z8geTC7xa1assSRGlq1FrBBCwPmKmDPTNOKt4L3DqLLbbvDe4OsaVzc4VaYQaZsG6wxDP6KaqauGpra41Yq+u0ckFYVotiAO6w339/d471k4zzgF6rbBLSuigvMVgieRSoxo5tgzBsZuw7jd0XWRm11mPw50U+RNVJZTxvpiLWsrh/EGZxRrCwEapwwaSAFCyIxT4q7reXff8cW7nne3I92QMWq5bBxv1w2fXLW8vV7z5uUVl6sFdeVnEhBUDBmLqCFreSZSjMRpYBh27PcbpqEHitVyH2AMgpqmfK9U0DSTjjmAKYpnOSQtzNKAw3qJUDIFsupxy8FuVSkJAMeEAeRYO9bMZKoxDuPKc2HFgZMjaSlurmV7tH8tiQ8iRRn84CL10LbD+o7OCe1P8XQt7KFtZ/wZw9eNmf8W8B8Bf0NE/jVVTfO+r3hI0v1bz5z/fwZ+h1LvsgF+W1X/1x9DP84444wzzvjHAN+8RqUcVHGnKrNDcFX+NHRYHRm1JYwbzPIVIfVUfolfvsC//A5GWioryHjDeP8F1eW3cX7NuP8C6W5oX/4cS+mIYWK3+QE2fJflao0xhtS/x9bXIEK2xaZU85xnFuM8aTIfkKmPlXFfp6/fbL8PCM5DJtxHyNDT3Z47p4ohS2L1nX8BHbZM3Q3LxRVZE/vbf0BtF5jcYZ0nEzHiOLgSihy0lU8sZWe1XZnOfpxge6qGO/33sZ/Hvs3E2EF5SQlaQZ7p5/PWqkf5n+RZQZfJMRP6L/j0F3+R1nv2waJWSl3NOYAxaul2E//sX/xzbIa7wlxKmm1mD9d6IGif3qPnCdgHsreQcwdy70My72PneER2zszgI6XiPMiznvGE+uSUSQQtKs7grsn1X6C3I4ERs3BEOyExok4I1QJnlahlfE7Vo0/bdHIzvhIfU3h+TFF5+tlBqfmYzHy4z8KH5OTjsTwEZEWv6rCkPJExOJQutlw0mbX9ks+/2JKri1I/0i0QY3FEQjR0/mUJ5lTIpmSDOyDnPS7uGd1LHI4gK66bLXeDZchLnI6EsCNLCcQNI5VOqI5YgajDjx7AM/604W8D/7aI/PPA/0GxpPk3KSz7v6uqGwBV/bsi8reBfwn4v0Xkf6GQjv8q8Bt8qLT8K5QA7f+iBF1fAj8L/Brlx/Nv/Lg7dsYZZ5xxxhln/MlhypQEyww2ZXyeyYY8k17ZFnXkIwtHSg15MaiAmRP7NKVi3amKtQ4jGecKmeOEY91E6hqAkJWcS42+nCI5G4jlfLVRnIlYekiOFAbCaNE8EV03k5QeV9U4X4M2ZF8hucSZx9goRlIKJANCwCDFbjMnUgykODKNA6qpECFSYYzBWkdtLJINY0pkMs2ipus84wD3mx3LRVUsU2uPqyp8peQusN/tqOuKi/WKcRgZ+46mbUGVL7+84W47YOuW15cvwCnWKkbXqDhSLGrUxlcsXrSIRPrtDmMcF+srMj1ffH7Lfttxdb2mbmv2+55pHPEeFm1NykrjLH5WmsWQuLu9wZoN3rc0bY0YR5ZSv9KYCpIn64S1NVFgGrfE1BfiNEeGaWLY7cnThHfCKMo0RCQnmsqSEaIIzhq8tTCNEKeittRIaw2ScrFzDaDGY9uWftji0oRzNc46xJaYX9SQ1FJ5T12vcdWKBOy7Pd5bKt8wdhtEHZoCy2Vd6ldSxm9KU1HwNi0pKnVbIyjWOIqMVlldrNE4EcOI9xU5CfVyifGOaRxIaaD25cvhTKnrqbNrV1tXKEVxaDUTY2QYR3b7DXHscWLopsT+JnDb77loRha1o2k9zcLRNo66Mrg5yTjlxJSE7T6x3Qfu95G7LnC3C/RDSfReWse6sby5aPj0asXrqwVXLxalb0Y41luca0TGqASN8/0bmabA0O3YbW4Z+j1TDCQgJCUkj0qFt+boDqSa5hB9rh9bzl6+V2QOrlbHBOFc7JSzlt+AnDMcakFyWDKwJdlcDGIcYgVjCkEpzmKtwxk/1/F05X6Fso+xFhFTIm4zW8jODmVHReX8b5iT2+d3h3Tkp2ttxsyyS0qd3eeKBZ3xpxpfK2YG/jPgX6bEvH9fRP4HYAH868Ab4D9V1f/96clVVUXkvwD+5vzRf/nj7MwZZ5xxxhk/WfwxiEozv0IJpkr255H8kMQ4dVxfLqgdVNKzbCv2/i2NVFgR0s3vQhxRu8IsrqmvvsX2e38PJ5nFy+/Am18khw1p8vTDDdeVED/5Z0h2icmBNN6Rbv8IlR7j1mizRquLIhkzWuxXrP2g6t0HBNsTPK01+VVE5VdZwn5AXKKPFHwf21ee2Q5F0ciwI1Z7tL/FNi26eIPJiSbvybt7/Opn0HFfsuRm+4+HAuY8KCRn4uvB/vMQsHyomjtt48escZ+SYOVzPU7idVY1HljJw3T1aZ3EU5Xf4b3BUrsOLz19atndD/hfsGhOOAzbYZiDdcsP39/wz/3qL/N3fvP3aWtfMhSPk2Ug63FyPHOrj4jSg2L0KZ4qYR/2+3r1GT9K4h2er3kMj2Mph3t3MiYc9Yc4axAbSalC6gXGViTtkfB9nF0jxoNuMI6yICF5tlt5fD8f+vyUwP547cmn258+I8e+8fi5fl5BenJeHlSpz45jOQuKIc58uAUiysopb5YTyGua60s2oykLJjliCRgf8XpPkyODVkxyUWpxKLS6I6bA6F+WwC6WGi/vO8/rqitJD+mWXZgw1USipZe3ZGtZ1OD1SzYxPNvmM/5U4w+Avwr8J/NrTbGj+Q9V9Tee7PtrFILx14B/D/gHwF8H/kfg33iy728A36EQm78GXAA/AP4n4G+q6v/54+jMGWecccYZZ5zxk4HOJRhUIWfQNFu86BwnpUxJqzwommbrx5mwOSZaGoeZbR8NoCmRTEKSkqNFjQUtMaP3VbGPVS015VIiToFMJKklaim9oEbRKeC6HRZIY4dzFl9XGOcxzlM1NXWzIKUR41qMqTDWY6whpURKE1nn0gwiWFNUZiVZtZAexeI0ozlCjgQyiUKGqWZyjKRY7FdzUnJWhmHAyMg0GqYpUbWBpm24WF+wud8TQqSqHG9ev2QcI+9ubjBGWSwN05SxNjONIze3O+rWcXm5IsRI6keapiG5RNu21IsVzjlyDrTUXFyuGYeO3eaWbt+x2w+owuW64eJyiQL9duTus3esFp7rywYRJcSidF1oIk5bBEu9vEaqmiyCiCVGmMYBI4pzkbYS+h5iAu8M0Sj7MTKFQN8HUoqM04RxFWOMrC9WVFWFqhL2haC0ADiyUaaU2PcDt0YY0sQnorz95CVIITfjNKJpwnvPGMFXa5LxONeQVRimAeMdktJsVzpibcI7S9/1czwZUTH0/YhIZooTxnoa53CVBR0RTaSgxDBgNVJZoa4aYrZoHiCOeAO5rqmcZQwj49QzjhB1om4XGOvJqnhnwQbCMNLttmy3PSZmXrc1U8r8cBx5v4ncbBLeTjS1sGwtTSNUxhydlRTYT4n7LrLvoRszMZbvY22E69bzclXz5qLlW68uePvqkovLJctlg688Yj0qrpDdsyIViqXyNE703Y79sGN7f0e/vUM0gjiyWrIaEItxFrWmtCYXi+eS/JzK931OtFdVNINKRGf75ayKJp1/R8JMVKbZGnpOpma2Y+WgiiyKaGMs0Vpwtti9WjdbSDssFrEON6sp1dgjUSkHwvO4hmM4oSQflT850qwnROUxqVlKLV0jZ5ryzyC+VsysqpOI/BXgPwD+LUrMHIG/D/z7qvpff8U1fp1CdE7Af/Vj6MMZZ5xxxhn/mOCbE5WHKYYcjByLlWPJ/CpWrLHf8O1XLZ/dGoagxObbxP6ean0FF6/w9UWxIu1v6T//TWoyqwr6KNz98Pus3SVN+H223YrFp7/IZB3u9rdJF38etRVm+RqWGaMZnUZ0eo/Zfp+kgp1ui2UOZrYMMQ+zp0MfPqKAO0yofhRJeXqOpzglck7tLlAeffaIsHlK+B04q/ltVmUa99S3f4hrrshYjFFEM9XFz9Hd/z+4egVxR6YoCUUPSseDqu6k3YURPTVnna+px2t+lQXoQzMfyMd8IDwPRONhPJBZQfdYvHcg5p4jtE6vL2TiGHn5YgmayeL54Rc3vH7ZsmwXDGNHnODqes33P/uSt6sN33m94H/7bTcP64GYPQzxTKybj5Nyz93/p8/Mx0jK556pp+dVPTyX+mjbYZCOozWTooc7ZU3GWI/miBiDupqoGU+Nr1bEmIka8XFiskqWk/vJfN+fIZefe5Y/Rip+rF+P+vCxfZXjs/DQ3afP49NjDwT74XoGK5A087KNtH5P8hd8uRV8u2LJyG24BM0Es8VIRUie5IUq3yPTD0nSIpqI4khmQT3do9aWBgZDNPDltORlOxL1BUlvsM0LkrmY890zUTOLqiL3Z0XlnxWo6j/k8c/Ur32NY+6Af2f+ewp5su//RwnQzjjjjDPOOOOMnwI4W8iBCktlS91CjKBGSDmT8kxSzMopawXrLG62bCwTYYtoQkxGNGKKzqqoz2AmMx4SHQWHdYI0bSFDcyaGjATF2QHvHJrzMWYbxkyctnROaGpP0zbUy5bWLJFcoXOtTDFxTgLO5CTknItqMpW6gEaEAKSU5nYVC1g0ozmheUJzIE4RTRB9hVqLiMNbR3QWV1mCJKZuoKoWpX4hkd3dDbt74dUnb3n7ySfs93u224EwGdrVksXqkjQNVMayfttgvaNZLOj2azbbns8/u6HvR1Dl009fo6uGKUXGKTGOE95a2sbRtpb16gVvX7/ifttxMY10Xc++62Ez0NYeK5lV27K5vaGygpsVsc75okrDgFoykSlA7AeMGUBmghhlYRf0u5Gp7wn7jqHrSCHjKkeShMuOrJmGGs3KarHEe0OWyP1uBxqxXnAucVE5ogqEgaUXvIm01iNjTxoGRDO7MEFKWGcYpwDi2I23uHqibdfkcYcxYLNgjTJ0GzSMmEoJY4e3haQLKdO0NZeXa3LIuKoixIlp6hFTUVcNai2NQHaGPPUMwz1qhHZ5jRpLUiXEiBOHZsuUppJgaj37Xc8UIs47mrbByFz7MU6klNgNI5URXq0rjCjXvfDlfuJmzHSDsuky3EWMn0myVFx0UlZSUmJWoBB0lVFWjfBm1fD2suXN1YKryyUvX17z4uUrVqsVdV0hInPdUU9WISUpZL9GwtSz397T77eEqScOe3KaEGMw1uHm+qwxe7IttPJhHWHOW54XfTKqkOSQzKzz2oqiWYskO+tMWhaCsvxlyPmoyFQ4SUi3YMxMVhrEu2IXLRa8wxtXkuGtxUipWYkpNrAHC9kiUCgKTzmWbym/AYdVBjkoJeUhVjdHorIkW4g5qat7xp96fMOYeQD+4/nvHwX/NOV/kv+tqr7/Rzz2jDPOOOOMP0X4xkSloTh6FJxaMyrWQBZPnjYEm+iGiCGgeSLs3tH6BrGZ6f676NRhiLTLC1z7ikigDSPp/e9z9zu/QXvxEnf9hnT3OcEYcCv8zd8j1J+irsIopFLAA0yFrBZItrhwS5ADIWeZE1k/io+py57b76sUZM/t97DtsQ3G038fJWWH4yXzYK9bNoRpw+rTfxHSNKsmAXHotMfWLTn2iFuiJkOaVX+mTAhPZxEHBewDOSQPxNhcp/IpoXp4/9HxmZt5sPksBx76UN4aEZIeyO25+uUj8i8fSSyOeynjMJFdy27MvLxsSTnx9tOXmDQReLA7GSbLVSWkT3+WfbTALaIHFeVcE9Mczjq3t1z8+JpP+noYqwP5Wtp3Ytn6EUXucZueBAzP3fPnlIcHC95SUJRS2/QYxaAquLhlbNaIWYBaLKBpg9WRbGu8ZkIYkGZesDg+BnJyrsft+Zh69kda2X4N6Bxsld0Pxz5onfV0LACxxaIHnZ+3Q+bmQWmaDdYJr5s9VuDzzQt+6dORbrLETnmzhkt6+vFgp2UJmjHUTKbGVx02juAc3no6rRhZlaz1+TrlepF3veFFa6mbLWhEyKCCihKywfsWvb/7WuNwxhlnnHHGGWecccZPF2rncMZQW09Te5Z1RWMtzgjGCAkQzYgKmTIHLom2inWCEQtiZjVV+Ut5TvQzZU6dUsSkWOxgjSFmnXkNA9Yhrsb4iPMHxxHwdrYtTakkOqZEShk0FwvZymIWLc6AnctsSFYyiZz0GLulFAuJqZDyYWUgz8444JwtNQLzdEyYFGux1kBSUio1IzMOayLXFwsa+4r7W0OYJjahp101XF5eYFxNSpbNdocSqSrLFHruPt8g4llUHk2lL8uqLnapeaRpMq9fNuy3GU0gKdDtAnVbMw0TOSn9OBFGYbszbPcdy/Waq8sVF1cr3n7yit39xHZzB0TqyjMMEy9ev6CqPWNQvHc4W4EoGcc4RfbhHjDkKZJDoKkNYgTftHR5YpoCMRSi2ruaHAMYyKnEq6tlizAChqiRMUaauqaxFlsJ3TjgneHF1YK+n+g6QxcCdWuY4kC/h7GrGfdK0yxYri/Y9wMxJ7x3DNGQukhOwuXVNaoTOfRkMjlnVhfXdLsNKQTW67Y4upIg95g5kBaBprJE8YjOdSgl4WxR4MXocMsrVDLjcI+rajQadFJCCNRVTWUbtvsdTWtYLy0RwblS8TPHCAIxDXT7e9I40jphXVuWS8/1Zc3VfuKuz3y+Ddx0I92UmEIZR1TIooDFG6F1ysJaVrVnVRmuVo5vvVzx5mrFerFgsVqyWK9ZrJfUTUtVNYgU692QMyklwhCZwkTKgW6/Yb+9I07jrGA26PxnrMO6CsSSsyMf4/sDiVfi5Axzsv9M/R0WNxDIgmDImlEpRCUnf0I+rl+crjsplPUknZMSEEwu9stqDCSHmjlxwhUVZTTCYZXmQZgwJ9tzWCOB+YPjOo/ORKUYg4qZf7PKe2MelJViznUqz/hG+Ovz63/+E23FGWecccYZP3b8MaxfHyZWx/pzzAHTrBrsu1tC3ZS6lK6CNGGqNbFeY8YtzteYT34J/BpMRnGYmIj3v8f1m79I+vOfYOKGuNvB5XdofEU0ik7fwtz+Dnb1l1BnSGSgBEB6mFj13yPLwfrioOj7ev06ff2qfT722VeRWKd4nhg6HKNwLFZe3kpOuOqKGDus8aWfWckyQe7wfkEOHRnFY1B53tJz5uoeiMXZIuRQqJ0nY3B6/NPzHbYfOLlHJOWj8eE42TXHczy/X8kEPhB88z4pEjPkGBhy4oc/+BzCnourBgSstfi65v1Nx3aYGIJB84SVjEqxfMnM43FCyR454I+oHznYqJzcn+f6/7gPJ58fVYQfIfTmgXs6GicayxPy/GFLyhm1K1QEmzOJCYsDf0EaJ7Rek6cbMhmLeyCmn7TzR6klP7b9R1nCPt3n8Htx6A+cqFVn2fCR0p0Ho9yaud7t6ddClSzwYmUxsePL0NLaW4YOmqxE4P294eVFi9WeXi3WWjapwpolq9wTsyHVn5KxJITG7ljpji7VDFrNtyUBDiNwOwgvLl4SQ8+YAAs6B4y2KgtHZ5xxxhlnnHHGGWec8RSN89TO0Va+/DWeuvJYX+aoZCXrITEUUipkiDUGTRlciW/zHIsZscSUyFkxmsiiBM0kBe893reFMFAlZkhqULFY5/C1J8ZAjgEV8NZjjJSkYmNn9xJDTNCPETNMYMdS/9JWGBuwpkKlqCAP6iyVmSyZFV+imZzG2V62lKGwkrHGIfN5AFJMMIFOE5qLcm4MgTEkgjr6KTL2e+puYBwDi8WSum4RMq725Nkut/ZC14282+zIGun7PS+ur3n5xqEirNZLVhcNq0XFfjfSDROkEh2tVy1TmOi6wH6I7PuBnCDHnu39BucyTVPx4uoF7cUSYy0pJMT1DF3HMCpD3xPGnroS6trjncd7j3MGYwWRTOWL5adkIQxDIXw1k8LENERSyuyHCYPQNAv2saMbEmNMLBcVTktpi83dttwnI5CVhatprYNKiePEarkmTBNjjNSMbN/dU69X2NryvR+8Z5x6Lq7W1HVN0xisa6icRXQiTh3T0KGq1NWCGBPWW8S4QopnoXYVVkCMgnX0fYc1hsvLK2JWjANNhrHvkTQQhh1iTSEexWLx1FWNd4IJQr/viCkgQJgCYi3eOayzhJjp+mKVG8aBadgzxYFlU7FaNVxeLDC15cUUGIfIt7vIzW7iZjewmzIxlzqS2SSsmJmcdFzWFatFRbvwLBae1bLl4mLJYrGkalqqqsXXLc43GOsAQ46JGBPTONL3PXkaGceO+90tYeghw5hhCokYoK6LmhLr0CTkrKhIWa2a4+CcS6J/nj/LKiUG1ZPYfRZT6vwbQS52zjKv4+R8WLsp2xOHw0rSL7NiWxCygpFcvr9OUYlkKUTlcQlkXo/hoOLkwUlK84M44TSWF2MQKfUtVaTUvTQyKznn3y1jAIuYM1F5xo+GiPxl4F8BfpVS2/K/V9W/+5Nt1RlnnHHGGT9ufGOi8oCn6sCDGE40QOyR5lPG4R0L58G11NMfshoM5s0vE5vXgGI0QzLE7gvM8J766ttEtyoZeU2Lr16SNr/HYF9QrV6TnCdffwdz85vkV7+CsbZkRhpgJi1LlqcFYyk17j9GoH1IPMGHysqvImG+amy+itR6nvA8/utE0ZcpkcFI1bzApEQe99j1G7KA9DfI4i3T/g5JPcavEM081DR5SsDOCsETCafmQ0bkkW5+tu1fZYdaWv2A033l5L08c9zDMTPpPW8zB0sjY/HG8fnnP+DTN9eM/XvSGLi4aOeeKMZarAj7EPmt35rQWsqxKkWJNxOHckI8HlSUH9rZPtwQcxgxebTlaxGWP6pW48kdmBWHh/E6kOyPx/CggI12jR0/J9VvwQh+mgh+ieqIaCaOd1iq07MfH/+P2fl+lar4Rz3LX93npxme+vg5Ofz38OOhMmeHHrYeMkuPbDgKRIX7uCCaltfrzH207KQshBgnfNEr31q0NHliQ8bmkYu4YUgTWr8iZYc1iSkrfVrgBS7ryCpv2SbLlBuSphI4quV9b3jTRNZuzyYugTQHkwtq8/kHY3HGGWecccYZZ5xxxhmNs1TeUteepnEsmorau1ldZFFblJSaS0KlsQ8kRsjTbLkq5JzKPPeYdjln9h0sI1PACBjxiPeAxRiHWsVYhzG+bDPlOiEmBIO3DnFKToFceBDGKTNpYkp7wqQ0i4mqqvC+Qn2NMUUBifWI2KIEk4wYIcVSi9JIIqSJOEWMKEkyYYrkXIhVMRY3W9rmrExjIsRACJlpjFTeoY3H0GDJDF3P1PdUVcVuY8hiSep4+/YTLq4vsZVlcxfod5FV25Jj4PbdO2KMuFev8JUnZ8849eSsvHnzGu89Yi0yDoTpnkVb8fKqYZoy46jU9ZK68aQ00HUb1qsFjWvIFlrniU1bnFsuWvb7gXfvbphypnITdhy4XC9BDHVdMYwj4zCwaGqcjbgqMQ4jYUrkBDFk1qsWNcp207FYL7FVR7Pw5GnEiEdVsFaxs0vRsraIbdgPkSwZ5yCmkZQjk2b64NAusnITXf8FZMV5x/ViiXGOTT/iJdK64sajWVktL8hpZLe9Zxp7jMkYY0jOUzcLfFUfrX132w1GwPpCnsfQk/uIdw3kSNd1eGfLcy2Ccw7XNDSLK2IS7NSidsNuc4upIuTZEtY4JEdSmMgRxmFi6Ee2256QFePKGo+tLO1ygbl0hDGwngZeTYkpKCFmwpQYx4A48K6ibmrqytNWjrqqqNuapq5Ku3yFrxpsVePrBl+3GOvQbEgpF3vbYWTo9gzDnpwCY98xdV2xpk1KSKVcj/MVzlcghhCVKWWSeDhYp6ocFYoIiM5kIKBmXgug1KMVZY6NFclzaUw1s0iAB/el4yeH3wdTougsx0UmTfNvhslIKkrITIacSmL5kXvMx9qYqqA5zfUw89EJScxhX0Xkob6uiIBx82fz79yByDT2g+TpM874CH6VYhG7Af4b4K/9ZJtzxhlnnHHGnwS+OVF5VEgVHCmLWZkXpp5KE8m3pKnHVBEdPic0r5ma19TUOBGMZMYQ4eYPqJeX5Fe/XEqJq5BNguwIxuCv/ins+AOmm9/BXf45rLtCrsBufot89UvzpKfwGEYowZH1hb3UgWciTgAAIABJREFUPCuznnbhefXkI4LtCRH79N/PqwufP+a5z54ef7LlwCcex3uKE8YvsKtX9F/8v2hzhecemleQJ3K8ozINac5mO/jdftCGp20HjBHyyS4fI6E+1v/jiQ5c00f79aDMfHr8c9dUDAah8kpTZ3wNzlj6/Z5xGnidLktthlgm07vtHd/9XuDzrWEt13Othpn0PBCDT+/3k7GRrEfyUufGH56tU2XisQ85l+NOBuKo2hQpAcbJKDxvH6wn9+VAFh+e2tMxKv3IoqT6JWb4QXk1BieKMUrKGYximguURJa62Ek9098fpRz+GFn59Nivqk9ZPsmP+v9IwcoDdf5cYoAqyGxXWypDCiXI84hzEA2rRvmH76QEbaYEVDbDZzvD23WD85bU3bLnElu9JaWMSKkxCQ6rpd7O+9FjxLL2kQvTM0ywS45MA6bh5u5Lrl8vgJHNVJdFGTNwsbQfHcczzjjjjDPOOOOMM356UbuK2luaylHXFb4uJQyccTDbsyYFdWWh31iDs2BE0RSIYSSpknNRLRo1eGePc3vryty5lJc7qXVpLLiimBQtZUFSSKVsQQbJCUGwZrYdzdWcuFrsG5MWZed229F3I84amrqiriuwpc6mcRW+bqi8xxqLGAM5FhJnHAhTIIeI0YgzmTiNpJCIIQLCpEImFetI40tQkKCylpASi8qzritiHJmmHVbAEBm6MNvkCt/dbUi24ur6BU6U2kFdW5pFg3OOME1MY8+ui4xDZLvZk1MkvxioFxXGVVR1S4pKTgPeG2KeSP3Acr1k2VSESelGqOslMWVu7zaEaWC5qLi+bDGqqHW8ch4jyrjdM+zumUxisajJBFII1E2FbWpSFlKClD3WNSyWjtoJYZwYhsCL5YKu62cVn6VpWjQru/cdRiyursgxc7ESxDg+e9+BKtZaDBBTBiMMU8SYSL/d45xS1Z52sQAn9CEQUmbhPSnGI/HUjYGu2yE5EaeAponFYoG3hhBGEhnvLUaVVW2IGUKIGDtBVqwoKexIGFzVkGNisayxAt47vK1x4lFR2rphGjucM+TsSFPGiCHGgKsLcxamkX67ZdsNbLc7vFhCjIwpIkao6wZfN6RWCWFgNbPtRiw5ZaYpoBas9Xhf4byn8hXWCLV3uKoBsag4xDiMcxizQKQmR5jCSAgj+25D3+0Z+p5dv6frOlKMEBVjKrAKOSBq8L7CVJ5kIMSi7FRb1JQg8xpFmtcaTIl1j2sLc/6uHqpA6rzeAEhxGsoHE6I5Xi7ldUrNWYs5JhwclpSgqDmPDlqzklPn5PgHo1c9/n7kHEtdWc1zLcySZFDOUaL3Q0Rf6lEa7KE+qymkpLGurMcZMydmwOOVoTPOeB6q+uvAr/+Em3HGGWecccafML4xUfmI7DhMNoQySUfJ45ZVZRlyA3GiahuyrHCLNW71CSwuSVkZbr+HTxP+9S+QTHM8s0qhqNRk7Jw3mupPqatr0uYPie4aWb3FmYjZ/D758p94oHUkM44T3lSIyZANah7Unj8KjxVsp4TJ8+rKj312HKuPWMEe896OpGjJXjtm2jFP/1TARjQOGG8gT/j2gvD+N6nWb7GpZ1JD5RbYeAf2CqNKOqonn+njfN+yKe02s6KvCNtmDeGTATsqIg/zWx4UimXyqyUFkAebz6OC8jD5/ojl68P4PFitQslIFCD4l/g6YDF877vf49WLC6raUlWOMFqcK4F+ipH7Tcf1Ys3rl57f/yI+EI3IPL6n9+oJIXzox3yQ8KByhIdn/TCy+VQlOiv95CC/PCE6S6akztmTJ+c5rdtYoo1yKPmYJK0Us5ZiXVsiSBWHxWOaN1yk7xOrC8gekwLWeTTekc01aHwYbvPQ9mPbHvX98b1+uCfPE5DP7XtKWD58jwQVw0EZ+fhU+dF4lnHUR/uU8Xhou6AEhVqBLHhnsDYT51ouWYu9kiIYFTb7nitfoerBromiJSsd0FxUx1nk4TuAsJkcWS2rCq7YMuWRTisUz91WWV5Y1tKzCwt2eYXI/UfH54wzzjjjjDPOOOOMn14smhpfFUVl3XiqyuNFCiOhh5Icpf65MVB5i/cWIZNDJmmGGMhhgpiJKDkUJSRGMGqxlaMyZiY5Z3KgROWlhmROYME3jpSbQkCECdHMFEodyVIfT3FS5u99DIxjYApKmi1dm8qxWlTUM+FjvaNZLaGuZ0tHW6xrc2bsR2KakBSwKSBOSCmSckJJMNf7m0Ii5nLsGCJRDSIeKwYk4XwhHr3UDEOPAot6QdZAzJmhD4z7js/vb7m+XPP20xdUPmNzIIwDGEezaFhaS5iUtmoIscM4y5QSadywWK94/fYl7758z+1mT9s2vH7TMA090xRplmua5Yr9mFi2NZ9+8gpjLeMQGEPEu8yysdTOFw73qiWGK25v3rOblHW9wLdmjmssIQasZNrWYKQQQWNIIIqpHO/ebYkhsmx8UWP2kb4buLpYEkIkp8JEJQQRxTvBmwoQNt0W7yt2fc8uCFOEfjBcrBqWy5q6bdntOva7gWq5Ynd3w9V6xZiVkAJ15Wi8YO2CWLcgQltXaErEMOBUGcYSqNaVxwgs26bElnNdymW7otveEUOPrTw5QdVW+KZCJJJ0AFOUllXV4tyC3f0OIWCdQ9WQYmIaA/12R44TpIjkjBVBkuIo1sdIsR6tbUVdNyWuzIAoznpUM0kSooKIw1Y1la2xsyqT2fJYxJJyibxjnIoF8dSz2xZSct9tGaeBGCNxLPcDBOcsdTUT/Ha2dK4rxAqaS61KEQtqS8ivmROacI75D4yiMBvBQgaVCJh5CaWoWFUzQirHzEsIWQzWCFmVlOd1DAHyadL0A8FpRdB5LM3BzUikrFcwr+flXBSUOZJzJs2qyjl/eD5nPiYSqzUYLUQzOeGMI6dUkhpmNeWZozzjjDPOOOOMM74KfwxFZXkxHFRqBz5EMMbS33/Jm1XNZurJGqhf/QrWdDj/BmdrUr8h3H2X9upb5PZFmRzCMZPs8aXm7DMBFY958U+y3H/G/v3vYS6/Q7OEcfcHpPXPYZCipuw+ozUBiQH1NS7rTJY8Jl0+pig7rS94qq58bGH5mJz5OqTOo/3n/j4QNPN/DkTXgQg0xZIjxwFnwATBDPesVp8wdj9E20+olium4T0iRREWBcx8ng9rSzITVQdicf78yCV+SDw96t+8j3B4nemjmfl6GIcjR/dAUs4EJkdD1VMd54dkr5W5noMaUjaslpdcXnn+0q/8HFZqNAvBT2geEYn85V/6FhoC/93f2fEz00hQRaQ6smNHhd7xGnJs2pGIPWn/sd8Hsnru82n24Af3+wkbZ+ThGuX9KVUrM1l5UBw+KDNVHu7LIyh4AnXVlefarAndBvUjq8qwxLMNEyZ3xTTYPtS9ebATPmnrEzy97889Ax97Nr5KoXm4aPm9OAyIzOTgYZcDZfn4fh2eq4OtjVACS4OyXkQ2e4saRQmYBJmiKF7KfamlIRZLwMUfEtzbUr8VoQiP08P1HjqEAfox0csaZxOXfiQlGNPI/V3F1SqxsluGoaV156jrjDPOOOOMM84444wPsVxVVM7jK0/lLdYelFNK0pk5MIYSF5XYyApYY0oNRrGIRCTLTEyV4w1F7ZSSxSYDTkqgZuaEUy0xiDEl6Vc1YYzgvCXHiqSZHIu1LCjOgrVFsWVEqKuMESE4YYyZFAwalW43MpiId56qKSVXQj0WAsTYoubKkOIIRDSNqAZUS81NqzORpAajSgwj01jckMQK3rq5zp1gjUcU0ggiFlc3hBjph4mshYTxlaFVwzBO7Pb3VO8zV9fXGJtwTY33Dbttj3GWplmwvLpg3wl/+L0vubm55/r6kp/92U94+fKaxarls89+yJdf3rBaLakrhzUDfTewqBeMIXKXM2KK/WjtPN5A83JJiCMpQ8yZnJUUYRig63dkoG0aNEWmaUJFqb1n6JUcMnnKrC5XiBVEPKt1Q04OZwUrMA0Dq2XFbhgYQ8aKJyHs+4Eh9OhcQzJlZTclvAhRwZtMZROrhadtHE3jIE3klKkAiQO+bui2W242WxarJTl56spgxKEh4ivLNHQM3R7fGGLfkbNlubqiXayJYQSNjFPAWYsRy9iNpBDxzpZ4WQzGVGgUjMmQRnIC44qStHIWZywpFwWkWE+aBqZ+zzgMpFBIe2cMU5gIvqIbA0MILFMqMaIxOOcxYuZrghWDGFvsVFXKmpM12JnMz1JqJxrNxfo4JkLMpFTqu/ZDx/3dht1+xzhMqBaCsPYev2qKihGDAjEnDOCMFFJXhZiFnA0Y5qRwmcnC8l3PKKL2IVEaQSUjeiAqc1k1OR4zx8OH3w3gIZ6eV2UOiw3HtYdZ+ThbtKIUW1cpSdcP5Vfyw5qJZnKKaI5EzcX2NWckz6QqOqs9y7VUpChBjwnfQso6uw/NMfYs8fzK9YIzzjjjjDPOOOOnGt+YqJx1c+XNnHV5StCk7XdpXrR8ef+OCsWuPiFMd9TTdxnuB1zd0n7yyygOUeUoWtM5u+xIroGqkETK5FKKCmpcfJum3SI3v8emfs26qsj3f4S5/HmiE4bsqdyChW85cf8szf0ak6OP7fNVVq5Pia6n+3y0FuZh+0FCdxxXUzLqjIAaUhpxFz+PGpjS54gs8NffIe3fI/IWEcU6gzGJbMp45ROV2GnNQEQfrDfyHNMyj715vt0fjMGRpCwwp+ef9zuQmYg8GqfD7PlhKOTJ68n1bJkA15XDOM/q4hVvP/llNvfvmcZdySQ2ljCVCfLLixVON6idswxPxvhIOD6jkn1Ui3O+F4J5hog8YR05mfxzQsye3F9z5GjlhKh9ICYfE37PjYKcbJdj3c4xLdF8T5RrrFMsGVJgH0BThXM1OQ1MT8bzo/fzZNtzVsYfI+C/+vt0CHb0ySePn6OHl0JUflBH88mxqkKOQpDEhbd8795glJJbasCpsDQ3hNwiVU1ttiiWurqg0S/Y6WsMZfFHTGQWsJ608aCU9URJaDLs8oLLao/EeyoysRNWqwVt/pKQ4leMwRlnnHHGGWecccYZP61YLloqX+O8w7gSE+QUiTmRciEExBTyxNiSwJhyIVuM8YizZZG/AmMidi73IBTr05wzKSaCzRgSWQJIwlgLxmCcw2Vf6swlxVqHrzxGMpGExgiSMdbiqtl6VhxGLUYS1mSMyQRJhBAJMZCyUjlHCkroNxhjcXWNr1swhpwSVjO1V1Ie0RQZk9B1EyFELIozBsGSZ6/LceyZciapBeNxVY2KsFi0VB6cqXDi8VWClBjGkWlS8gTeetrLhhgTd/c9X97sEVeRsvLy1Uuatma1WoGUWophnGh8jbeeEGG72bNatnjv+Lmf/5T7uy0xZnI2WFFyHHl/+0NevLjE1xX3mz37XccuZZZ1Rd0ahGKt2/d7lsuWy6slL69/hhhKzcSUMimOdGNEs9BtJ4wzYJSrq0uqi2tubm7I47bUMm090zDx/vYOZyvCFPHWlDjJOm5vNkwhUlUOWxk0jBgKya0Iw5igLuO3XDaoZmKMyKiErIRJqcRQeQdO+ORbr3Dek1MgTgMawVqDMYoVg6nrEh9XjqgJlQAkrCTQxKK1aBacEYTEJMXa1FiLaRbledQIKKLKol0wTBPjNOKdcHF9QbfvmHYbYCTPpJh3FWHYkOKANUrlKrIK3RTZ70curycWxmBdhfEeI8XOWKyZ1ycsisEaN4fxkZQSKSYQgy13jnHqi4I4RlSFGDPT1IOO1E5wrSPnYs9cV1WpMCSlDmbXl/amDCGMRRVqHRkL9pA4Pse789rIgXBUPTg65eLkdLCvUkDy0WEKKeMmzDpGOYmnU1m/MCLkPJeQ0dMVikO8Xc6dOeYMz3s8xOWlVm4ia6lRmbNCAoMhcSAjy9qDInNZncNaijyc05iTVYyZ3Dx42p5xxhlnnHHGGWc8g29MVBbrjMJu5aNCrRBgWTM5ZrJpmULJ3HLtivt3f4Bp1zRxg7n6BdTYkpUlliSpZHumUo/jMJ+So28FiCmWkEYF1Qjmgvj6L7DsPmO7HahMQvffxS1/FrFSLC20qD71MOE77cNTwvBrZnc9a2/55NhTIuw5i9jn2gClvw9ETgkySgacYNKIWE/efx9xDr+8QNwS1DIO78nZofVFUZNpqXogj65RMnUPKkgjxSazKFVPSUc9JukdSdSn5BYHYukxCaqzkcmjsTg55tAvjsd/nNQ9PacxgrMZmPCVIeaIYjFGirLOOsAwhcS+z/zCtxouLiY+v20fE6ZPxvxx354ShloyAx96/JhkOz3frLI8VeTlnOdtnBCk+ajoPBC2crBmevp8cuj/yXWkBCaIRzSQtEHpmdwlohMwkDShbk3S8p1CPixZ/0ASlr/n7vGH4zMf8gxxWxZKHtSxMqd+Hu/jfK/1Iep6OB+Pn4InPPCT65YNTdXj3Z4mCZpfMWipB4MqjWR8vmOX1kT1fMt3pCAYMn3yVNVLLvN7tvESMdX8fXjuu6FEk+aaIYaQMzexpZVIb19Su8AQI01Vk1L4sMFnnHHGGWecccYZZ/zUo21aqqrCOosaKW4fudSAjKrFTjFHbColJ4xYsrUEZsJFLDjQXGLkrBFRwVjBigUpM+yUMlkTMSlYwTmPtR6hkDgpZXIETJ5JI4smixKxBqrKUdV1qXM4KyOTjdgYMTlSJS1EzExUOmMQjWXOnxJME75yqApDGBnGQC9CygmrcxyUFC9FdThMGSsJ5y3WOZx1mBTZ9xNjN6LThPMWTMKZBU3d4iuLsxlrIabEbt8ThoTMyb1iLcZ5zDhifCFPx36Ht3B/MxFj4vLqAudgUcMnby7ZdSP3N7csm5rr6wtabzDrhhAz01xLUFiQt8LdtuNChcv1kquLBTkbQlR+94/eFWLWGi4vaqq65e5+x263p21WxCzc3m0RhMv1mtqDNiNTSNzvBr541/G7f/AFi7bictnS9T05Wowa6rpiGiZQ+P/Ze5cmSZIsO++7V1XNzN3jkZFRWdU13Q3MACBmIMRASOGGC274h7nnngsuKBSCBDF8QDiDmZ7uqsrKjIwIf5mZ6r1cqJm7R2ZkAWgsx45IZkS4m7upPdxFr557zhnGESOye94RAW8aQgh06vQmDNkRIqUUrtctq7bSWmY9bRMoltk0Kw6Pz8TY4GRMjTZ1BAplGBiHkTIaXUzkcmBEIXWQlNgk2pQoxaqVpwtmYDmjEqYGaCG1DSl3JFUsGyLOWHK1bZVAjB2iiZiExoRsTrLCTQzsDo+1WZuRGIWi9fdcRswLm5UiGukH43AYyEOt11SEEKu7lEAlWDWBK9lqV6o7jLlQcs+YC2MxJoqZUsbaDGuFfsg8P+85Dv28ooJKzVkkBI4uhOLEEECMJkUU2B2Olcx3J0hEYqyftYs1gdqobNNaAeBWyXqvosbJFmtq0rdTn7OLTw5YdX3MTiOjvr9AtZn1UzRP/f+8dnXWXV40Ak+iAZmdw6TUTMz5lQISaid79MmRSMB8Xm1S8LreNo9NVFGd9qWTvTUQ+Hrz84IFCxYsWLBgwR9PVOrZslQFTLzmU7qTh55N64xhQzn8e5oYGB7+PW0Qwtt/glzf4+//T5B/Bt0NhVK97P2lmu+Co+Ss0oNq7Bhr15gLef0brto9w6e/Ie1+h8cNCYeQJiK1IOgvEpH/KRYUr5GTnyvPLrf5QpEmMFvxnP6EUzakTCHpOFPW5GTtj5D3P2HjQFzdI2mDuaPrXxG2f8dQeujeQT6CCGGiDau963wOa3EwM1SVFL6YLE6zUZmZyAsV4otzQLWkdS/MRKVPdiL1ZyUYbZo+ywsC86LrbtrP5yTiZU6oeAAK4zjS93vcpBK34lVNKYLqrFwUPAjvnwqfLFxQi1wQdnah1j09RS0a5nzDSVE3LSacrtkF+VvP4Ew2XqpH+fKx035PJ/nivuD0/Onc8+W9NJNoIk4TheI97gGXhIWIlAh+oFXY+4Byg9qu5rNekrB6zhk9XfYTYanTeSh8jku73HOb52XRc37MXmzm52YD5GLHs+XtfG2mMzqfQi5JzGrlOp+r/dByRceqbSneEM0oLtylAxKMT/0b3ANRCutGeR4bogDWM4xrPL7hTfPEw3iLesAoIOFkA1u8ZuSeLYrrdbG4QvwAZWSkJXtLnwUZPnxxvhYsWLBgwYIFCxYsiEmJqTZYulTrR9HJclIUF8OsWkeKZqJHzGpdnE0IorhE0BYTx0uuNYhUVxkCYGA21kh6C3VO72GqJWbXH8WAYrXWqfP1OvfHq11rVXQpGgNRAh4r6ZXMJvUmDOPAMNbcumGEoR/p+4L5yKrPdFHxPGAlMxYnF6dNDU1UFCdowFVrU6ArTiU1girr2NLEjmPqwY0QE16cw2GPqCFxQ1hdEdtIKGNtWr0CtFZpZkJqlJIz5kqzamm7FY+P29rE63oil552R66ubwgJDtuRx0+P9MOB66s13WpDbBuk7xnzQN8fERHevfsVxQpPu2dub1bcXF/VmqOLeBEePjzxf/31e+4fDnz/7o51s6FNgdRt6LoV1QHJGYYDbXtDGAv7IROi8vbNN1xfXfHw8ZGuueJqveLp4dNE/EBqEp6V5+0RpLBaBfIu4+bc3lzxc87snp5YrVr644HbTWQdK0k4jJl1t2I8ZA5hX609c0HdkVxIKzgeD1g2oigpBfq+57Dfsr65outamm5DLpUwDaKk1DLknjz0tFEZ9jtUoYRATG+IMdDERNHM0D/Trjc0zYaYOswDuShGZLVuKymeB/bb/ZTZqpgZKSW2ZcCyT2sARlIhpFqpmQl5LIzjER2r+lhTh0+Zii7VznTIBTOvKsnxiHvNYCylEGODBiphjoCNDOWIjTtsHEEjoyn9UIgxEYNjdiAF5Wq9Ikatny1zooIHwUOoCs+YkFC1h7Oa8bJBuT6Up+fmmt+mJtqpUdp9IjCnpva59n65zHFqePeJvZzXWmrdf9lgPe0br+fagfk7wexMjk7VsOvcvE49P/MaiZzVlNhFQ7LXyKWqqKzfOzLnbM4DWrBgwYIFCxYseAV/NFF5Uttxlj+5VzpqOO64WgeyNoz9nq67or37NX35qdpvhIR+9y+xH/8t/vbPkNWbEwkDX5KGs8LqRIZNMyqfOufcnTGskft/ge5+x/DD/8zYPyPrG86ZdpdUzdfxms3la9aYX3vda+P/goRDXkjILlV6J+LM5218CiTPDPv3rNtEiiuOZjgRZEQwdPUN8vR7QPFsCAETq51x07kS1bMKkNl+xF+M8fIYTiTRxYT2QkrJTMa9fi6mTj5RmHIWLvd3JuPOJBDyMgP0NJFWxz2SGuH65q4+NCkFmYhgmXaFCsNh5L/5iysIif/xX9vp+bkwmHv6LknDy3HMncyTAexZVShzB+LFvfGFVnF++py9+PkWX7/HzhmMnz9/uZ3ipBgxGyjhBqNBrODiNdcjNKzkESk7SjkiKV+Q1XV8p3eeruc81tdH/PnB+YnIPt8j07OXXPx8XBdKyHoMl9zly2M9q2jPg7xUn55GYSDa8O5W+eGYEIzv2i1ZE5+O65p3I84mGYNDsRZRodhIiMJoLVt9w1165KFfI9ohbhRRjEz0ycxm+t4xd/xEIieiGlkFMcjWEMPqF87ZggULFixYsGDBgn+oCBFCmFo3fbJvdCOooClRJFBKxs2IISIERIQQagyIWcZ8tmdVclHGUpvsmpRqQl6YiEccDYJGJcZACKESj64UK0g/KS+z4aVyBuqKWWbsB9whlkTjTmyF0EQCEUpBi+AFUK/5meaVcJVKNuac8VIwIMaq9FMzokOQSHYmtyXBrEYvBKmkrUmgeERTQpKwbq8Zhr5a1KoBGTcYDwNB9xTZkJqOHIHgrNZrci6MfWawQlqtGY4Dz5+OXF1F3tx/h2vh6WlL19V5v8SWGBM3b2557nbsnp/ACkjCpeVxd+CHn37H/e0Nas5xO/Dx4e/YHo+koCT9ll99c1XrUkZElG/v7/izf/Y9+bjFbSS2V8TY4mZsQkPXtYjA07Ow3+7Z7ffcvb3j9uYKkchu33P/zVvaVnn69DOxEZq247EUiA03m0p4b3dHXBPXN4kADGNhsMhhMK4b4831CszIJXDTtUDmaXcgaOI6JjabFcMwIAHaRtAAq1WiP44cj0e6AGaBEFvcI9vHR64sky2zHzOb9ZpDf+D6+g2HPGKj08YWKzVr1Kc1opyH2jBuhvWZ0DX1fpRK5IlPDcIEoibGYSSGyPPzMyEkDBjHQrGMilVOXnS6TlAscxx6jsc94GTLsLoiSL2ncbBSGCwzDpn9oafPAzE0E0nn5DgQUoOEFYaQC7grq25FiIkxO7nPlLEgBqlz1DOWnZIDsWkoqhSckCLatLh2ENv64RfwYtUV7NTY6zOnd3KyOpF87tS2X63rOfMKxFR41/USOFXcF2s1szNQVWXO60BM9f7ckHxuojaf393O6zAu2LTOEjROOZ/UpoAQTk0PKnO2JlPkULWKdZuISmGKeJKJm1RMDT+bMC1YsGDBggULFrzAH6+ovFCLzeSKI6DKcPjI488P6Pu/ogzPNLe/YTDFU1NtIEQxEuH7f4m//7eYJWR9daGefLkfOBNCL3IWT+RS3be6kDf/iF37nnz4G/Rdw5z9OBOd/ynH90uPf27p+ktZfl/N+Js7304EGhfnYOqgk2pGUq1BOuTuX5DzI21YYWIEQu1YtR0hdWg5YNKAZJJrzfbknIh4Io9wvkbGvnjsRCBfahNfknWX29cge8Amq9NqRHu6RiKXM9PzMbtfTLA/I31nW9qSM8PUyVjJykruqQpBzyrQocD/9L8/c/NGSanjFNIoE8F1cajnc3E5HrkoAF6O6ZfOmbujWrs/z7S48/mNfUnKne+bl0Tda/s8q00d7Jkx/qOasTgZv4RywEg04w7r3iEhQP84WR+/vG9f3IszJ36qgOzl1Z6erOpH5yQbgiYkAAAgAElEQVSE5XSXnj5fL470C6L15bn7/Fy+sI6d67faoFnf+6ID1RE0RtbNhv3HkWt/4ilfc7SEUOprXLm/Mj48RZIYIWi1HAJwoy8BkWu+6bZ8HAtFVrWms6qwlKnjcz5ns4V0yZHIiLsS/BGnYM13LFiwYMGCBQsWLFjwBSYlo4rgVm0ezZ15xT4EQTUiUu1aY6r/QqykQCkFciUBzlEQTnYjuBM1TA4zlXQQ1WqBqjqpOAGDGJSmaShjtbwsNpzJj1LzMnMuxNFRqi1nlISEiEarqs1sSFK8mZqGx8Rw7BFR+kEYBzi60XoAM0qpdajhjNnoh0LxWge0CiEVrIxAgFDVZ0EjbdtwdX2FNgl3I48jWLUOtSIMpWBjxiblnYxGiis2ty3HY8/h2DOWRGqEUjIPHz/ULHsJaBRynwlBSDFQxoxZxkV53PWM7NDtwPN2S3/IfLQHvn/3lj//89/yvNux7wsPn54Zx55+OKCqDONAHgs733N3/4bV7Vu22x0fP31CeeZm07JZNahGRhOKV+Vck1r6DD8/9lxfJ9pVA8OR4+HIOBopBYTIdv8z3767xqyw2lxzHDN393c8Pe15+PCJJkVWyXlz3WJWtXD9eCCtG0IwSnaa1LLqIiJe3WTUMYNAYPu0ZcgDbdMyHHvaZoMD7aqhWyWO+wNSMkGFoloJqzwQBLq2rUSiKsdjT6LQdC0hxWrJCqhVG1PzTNRmWmeoyuBi0HRrNKZKwCPstgeG40BshKjGWH1EWa0TucCQoc+Zbizs90fWqxZxJ/lAkoKk1XTfZPq+ZyiZoa9rCdmcgTwpmiGY0ahw7AUl4FRyWIPA0RE1YmpZr9u6dmOF/XFgHI39cazEK07SROyE7IFCQlLCVatNrghz/qTPDCXUYtdrQwKTs4/bvP7FpKKs/8zndYG6NuJzXNK8sc/N24qeavq6K/MAXt265sbkaZXmnFc5qSV1apQXkXp+NFXFcxA0xOl7Jdaxz+sY7pS5bp5qdabhmZ4GX5t/F0XlggULFixYsOAr+OOJSpjmJJNNqTJNjoRh/5F+Z6SuKvrS5h7rn5HYIaHDdOoos4B++1+iP/8biv4prO7O7/8FcSYn4uDzbcxANZDzFvv0N2zKB46rDWiqky05T5TgFf7k8z29QkZ+rjz8UvX5Gbn2CiH08jVej8Xr+KY+ttORzsSZSC3ysEx39Y5y+ANBVniomXs4qD3g8VfA33A89Ii2JEIlki6UqtMgzmfzs3Fejs9sYvTmczdPQi9/+svz4f7yeZ3O13z+awfgbKV53u+pIfA0sovzLRMZTSbFSNdEQgiVmPTazRtEcKmFhqpgNtbsCeqc+PPrdL6mZzvaL67VxVlz+fy6f359Z4JtJuwuf/86wXl+j88f57wQ8cV9w2S7JEju0XQFbohn3EY8rBEdMBvwcMVYRi60lKcx63QMPpOQ+Olecaqd8+W4fVZRTvfm65a602WeLHJfSie/zOD8HC+I/9qCWRWNxmmcU9mDe70nfvr5I82YeE7fYB7qPeCBDAQxrO85jtdoyjSqDDZb2joBYbDAx3zH2/aZx8ORnprPYrM97nQNzWeC1nACjexxe49LQw5vvrzRFixYsGDBggULFiyAWs9N1odmdlHnnefZqkoIZ5IyxkTQQAiKakGpmZBFFDwjwqlBss6btdZIUjMtJdScPrOCiaITgZnadip/Mm5HSjnPd1WguGE2MuSRZG19rSgQ0KCoOkmaKWfTiU1Dm1piPBIPPbkZsVLIOTOOmVK8Eq1kSuU6cXcGy5hX4rBNDUmVAEQZUTPGvlBKJoyJ0HaEdoWX2gwaohA0IdXBFcmwf9pR/EjbXfHm7pqma9g973h6zhQTbm6vSKnh4WHLj394oGsE9cxT/kgTFfOBFBKhW/H89ETJmS5FNuIwjhz2ew7rDbdv7tjkgueM28DHh09IaNn1mRQiAfjphw98enwiNomrdeLN1RV31xtCTPTF6Y8DIXZkH6CBm9sb8pAp4xENgiEUTQymJFqenx/45v4NXSOM1qAa+O67X7E7jhwOhTELKNP5FZouYQWOfeH6ugEJdF3i6moFaozjgVW3QSOMxTj0z0hq0BhJTYvEnth14E4IiRBXpMbJuWBkQowUGzDLDPstXgpt2xBiQmLkaftIHg/cvrnFNeKaaDa31DJsiqHxamFcHDR25FIVkrGJIIXb2xXD2CFSCfxcajRHyXN0Talq3hAImjgOBQmFgoHtiCmDwjBm9vsDORsiSvG6BqOiBJWpjnWGfuB4HGlSIqWIqjCaM+ZMkxIhtez7nlLqY1ZKHdeY2WPT5zWBBrCAE2vDwLQflYirUyaVp0yWtNWaFk6Nwid3Ja/NsF6JzXByHZobwM+oNtCT29RMEEq1lq6Rl16zQ3GggGpdQ5rfbyYWp0eCVoVrCFpzcDXVn6F+x6jU9RgXndSSDv6y1XnuARepsTxijpX63WL/oUWBBQsWLFiwYME/WPzRRGWZpGky2TrUdfqC0lCOW+7e3mPtDcfnn0irew79gbS6g6BE0zqN0YhhxPu/RB7+DUUVuttZO4lTqCULuNZiqE5uK/lRA8YVz08MH/5f4u73rL755+i7/w798D8QQ2Sekp3JGvmC+PmPJR+/htesYb+ujJN5GMyKSpltOWYJ2YnsUtxHRCM29sTVmtC9pf/w17Srf4q74P17QvcW1zK97YjJGhevNkB+PvpKQM0ETLX/EH19ojirFU+zzOnH6dqc1HXzRNmmY60bzjmIMwmGzM/XguC181Ttf1+eV3EwdXAlE9jtbeo+rsW0T+8noWYl1HvRKUxFN6UWOHAi4S6vxUv15OXe7YIce4kz6TgvMHxO9Hol0r5+y7wgLmdH3vNDdbHi8hzVRQ0/LSJYuiWVHWMBCWs8H/F4Ve1hUks6PtO7kdo73B2T01U8Ecc+dxtcdHWe7Wi+GDBcHN8lzvau8wMz4T5v+do99uVjZwXvdD6m7YS5gPKT8tNxzOHQ79j5d7Wz06CIVXJThY1mPm0N03o9YmggD9TPQ57GqBRzPg5r3qz36GFH7+u6AMScp1Gtd9y9Ki5lQGzAwhsyLWY1A3fBggULFixYsGDBgi8hU/ki1JQ3n+xCa4ZkJfLgND+emjBnFWYMqWbIiU8Nri0pxun97NTHq+5U7mWez1fXFXeHUK0aRWsdF8fIqBFnmLaq+wziaFRUnLHPOAOpVSQIqFTCRJUQQ613rCEmI6SWbt1jOU8k5UgeB/I4VuXjVEvE2BBVyaWqSlVDdcspBcXQWOffpRTGMtb3GwY0BqStKr0YW8Ys5OOAlXFSdBrdpqPYlsfHntVqzWrdsNp0uAn9MFmatkrJQhmOtE1kyIVPj1sMp1sZlp/pQkN71SDidJtrurbleBz5+YcP7DbHOoam46efHrGHZzbdCgnK1f07HKE/Hui6wOZqQymFn3564sPPT4RV5Ol5JKpwvW64v9kwWmY8bHlzfcVmc81uf+Dh4Znt7sDN1Q1RMte6xt142h0YB+eb+2/ox8LD8xGJDU3X0bQR1cT79x+JKRISrDYteSID395e07ap1r6TenTMxm7fo9G5edPStYmrzRXiQhAHN5oAZgfaNlZ3o8PIKjVYMVJsq52wOuO4p2Rhs25o4xuG/lCte1tl6AdCc0VoWggtHgJCVeXpOFLGA14G9rsHhIiL0nQt7UoZizPmgU2j2FEYFKQ469ggU05l6hpW65ag1XLYRDkMA9kKecwcDgOHodCmjiZGYqpqwZrXCp5HVDLiUpWXx/oZPAyHmmtpSt7uGcrIqutoYoeFQrF6T5sVShFCaGphPzUL1J+VqHR3RgeVKW/StTLs7pSJtDzX0+f29bkRvMw/meN15upTTt8ZtUlYUHRSb4KondWVDmbTd8NE0M41dxVnOqicSM4wWUeHkIgxEGNENKKTWruSo5z77+dyeCIt63eVUOYGYDOsjJQLF6UFCxYsWLBgwYJL/NFEJdPEYxbLBandf2KZctgSr2/ofaRRQconxu2R9fX3aGgn7kunoO5S7UO++UvCz/8H7n8Kq7c4tUCSF2q2SliGEshBGY8PhMe/w3a/J62vaP70vyenFcGPZM9ICMxRjxeRj68cypcE5ReZeZ8pDl97bP77TH69fP7L13OeGQI62W1UzERgrO9Vdmi6JsSOsNowfvoD7XqNpmssD9jxE6hUdak46o6pIubTXNQnO6A5d/EVNd+Jj5z2XZ+pxNAlTzW14E0NiWfHkQtVZJ2gnpV581ZziLxc/v0L16FIfaOAYMMByvPpWFQV82r76iGgWjt9bXTGseAWwPXFsc1n4HPyeN61n0/ISyXqq9f8a92A8sVzv0R0f80q+LV9zseiKH18S5M/4TZQ1EE7IoU8PlVbo2JId0WxAeL6okPTzqP0uab5LMP1pHSdyMPL+/yzsV7min55XC+Jz8/Vu1++7kxW1s+tYG5fXIkCxNBw/01D/rDHC/R0uKyqRY4Zt5uBn7zFi1MsElrFxp6ghrhO935BBLLBQ7/mttkSxh37sqG4TUS+EaQuKjXlgPoeQkMxxVWnTtilM3TBggULFixYsGDBl/BJFWVWpoiIavVa3U3KqYnTp2ZSM5/+lpoDKSCitdYWIYRI0IiI4tRsSxVqNuVky+k6kaPuBIWgik7zai+OxgZNDaGMNQOy6FTXTdmZGDn3iAZEI1GaiTytqiuRGukSGicUQ2Mi5g7Lxjj2xDRiNmBTbmWZSMdSCkGEkCrRYQYalZACUafm0xBRDbVJ2Z3c97UkDYHi0A8jlACSOPSFh8cBKwM3g7NeN6QwMO6PaKi2tRICq/WaIIntbs+QjeLKeOyJFK6vaqzI/jAwjIVeB9qrDZvNhq7bsFo1dJsR+/CJ3dMnNARWV1fc3lxRcs/d7TVo4qcPH3h83vLN21sUxcZM2yrNdcs49Hg+cncVie0aE2WfR0SEYSjsDyPFBStOl1rW71ZEFQ7PW7rNN5VU/PB7NuvAbr+naTt+++t3/O53fyBEBRfyONI1gSQj39zcsH1ydrsDrBpCjDVOJSplcLwfyUMmD5l1u2I4HvH9ERlLVcuNkIee3dMTEhpub6/puvVEvAVWXVcVlX1PPwys1ytiENxGzHu6rkVDqMpDV0rJrDZvic0VHqodb10UKIj1kPeoD/TjSGpajoehKh7NGYeRfV8YJwcbDbN1LkRVLI/EdA2iuCREA01SpBQMIWQjjNVadVYBpqaekzEXhun+gkqKOsqQC2aOuTJ6QYBV27LqWspYyDEg5hSzSfUIxalqZkmIh6qoZGrQF0HKXIsrIl6zNqeIm5rlqJPh1tx8MG3vYJNIQKWuZajMzfdVTT0V7qemcGxa96idyagGzHxqkK7fLacmYOaVH51so6tSVWMkxEBKTSUrQ7ywflVEQx0L57p9ruV9JjChrklN6wJeIqUsROWCBQsWLFiw4HX8Z2VU6kw2zWpAIJcDud+hb79j/PS3xKhou6J7/pnDh39Ds/5vkXZDUSd4Bk/VTtECev+X6MNfUVTx7hohnIk0lChOFqXv3yPPPxDGI+ZO8/1/Betf1RxGKbXTzBSRhsqondVjpwndZ3iNaHmVZJwnXa8QT5+TMF8QTpekzWSTWxVic0fbiZ6ZJrkT2amODZkgO7yvWYTF4fjzH9jc/QbPPW33DX7421rghtrBB+eJ7JxZ8Ivq0Zlf8/lA4dLWdBrqNGWuyladVIon29fp5+fqyBf7mQizS8Lwa+demBSAgATh2+/up7yWurtq2eLTOZuujQtKQeUItgZqZsu8AHBJSr6WA+nup0O5PPbz/TNNtGcV4i+Qrad3eIWM/CUy/DUSfIaJU3CCKLlZcz3+jGVqdodDE7RmRIwH0HtiOZJnJfLprNqJiP0is7I++FXybb5nPycsL8f6Ul1af5vtqV47H69hLuUu74XzOa/d3Pv9kTd33/J+Z9wyMnrPzlqKNrQRRqsWTIaw0QZsS6BMJZXikw2XApTCk3WsUmbjH9nbWwojLg2d9Uj5maCRPn5H40+IlUrEy2uU9oIFCxYsWLBgwYIFkM2qW80Uvl68Cq9UFFdDrKocZZpXutS5K0i1WKXmU5pZVVZ6dTWqNZeCTvUXcm411UpWzDEV4oZKQAlo47DuoGQOlhkxrFQFXZiahG1qdI1NoFs1hNSecjRNHSUStKnEYix445RS7SpbuyaPGcu5kkNlpOSePI6MfY9bJmqtDbI5OfeUsar8pAiqoRKzUitN11p7BhHatkNDoEyErsYOD87hcGR32LN9fmLVRK6v17RdR9Nk+v3Ixx9/QENDu26JQchDoe8Lnz49cr1e8e7dNd99ewvmuGeKG/v9lsenI+1qw3qzRrSj7YT9YUsc9pTiWIHDobC+bvjm3S3/+B//miBK3w+8//FHjnvnzd0b7r69J489w5h53u/Ybvcogc31muubazZdh0bhsHsGOxKnvMfYtJNKz/j23Td8+PCBpjG6oPz+97+nDD3XqxVPz8+4Gb/69oYmgnghBKXtVqhGDvsDXZdgNPI4UIYecRj7PfFmzdX6iu3zI7vnPCkDnaurFbebDY/bA7un2hi6vr0hjyPDMFDrPGPVNlAKu/0RVWjaer+4OYKSYiCQCQHQQMmFcRjrOpEkmiawHwZS7BjGI+rVWjdTSCkhbpQxk0thNGMYnZBqdqmGUD8bY6ZdtSBebWStoKpEIFCbnJFqPZoPmbE4KbVYMY79UD8zEpAQSSmRva+a5LHUxoKQMIFhUgwTA0mUUC2cEEmYR8wjxSdLVNOqMpS68hG0xreUed1lWtAQD5Ww9HmRYv5vWjNxqlxRnKm1fXL5qWS/TwTlSVQJJzsxdZkNu5gXe6qyEtzDaQ2vjrOSjyFEYgw0TbXBrSTlZEcdImEiK0/OWjIRrfMX3kWZX4UGU61shpEuFOQLFixYsGDBggUv8Z+lqAROpF31pheOxy02HnHb0x8OrLuWkK4pGmmDYj/9rwwCof01trkhtDeEtEJDAg9w/xekn/+K4r/FV/c4pU6aEA7bH4m7n4lNJBfQ9T3d3W9r9oFMdhZAdKBY7RyTOpErMqv45MXk6Xw4rxB3r0BlCi6/UCK+pra8fI9LReiM8zQTXF6f2NnU1eoeMdsT21/jkw3qen1Fb1v2D3/H+v6f4mSOsiHYR4p8j6mgfibvphGdx/DKuOtv9lIQ+Mp2OpXAMhXEs+LO5/Mzv/xEwH5Gjp7eu3bkfk70vfjb621RvYUDfQ6nTr6gMhXR545C0br/bJw6Kl/OlvliX68RhF9ezjNZ6VPxMNu+iujptZeq2vmxrx7bKyTp17adHxMR1CH5DrGCW1USDuWI7t8j7ZqVRrZZiOEZG35GpDt3S3pd7JiVtV/5OJyv70w8n07DmZyt1kE2bXfO+/wafol8fbHj6XMsM2n/yvbz/ZYNHvYt3617fvccSaFlnXZc6QFomGpH7tdPhD4QfKS1J8AIU26HS8IIjESsRPZDpFMn+SfwGzp5ou9/IjVvOYQNbpBLtY91P+d8LFiwYMGCBQsWLFjwOcSNmsMwRTvYWWWJn3Pjnap8ihoJEvhCnaRhUknObh4XdYyAqdVolMJEOE6bFaGYUaaszBiUlBq61QrLBTfjcBwoYyaIgQdUC0kjWKbkAQlhUnRVO0ilZsPX5tVY8wK1EpzmRggN4k62OWtyIDY93XqFWYFSEHeSFYYhUDTPBQAC1R7SC+41C1BVsOxkL2hMEANBAqmJxLBm3SaObeSw39JgeCkMwwiiNG1HCJHD4Ui/3RFToAtOu4qIXfH0vOMPP2Y2VytWXUvXrogx0AblsH/kuNvy/keht8DN9YoYGvpSszuFzHDo0aAQAg/DM7vtjiYqd29vuL274XpzxfrqmrEYT487Qrfn3btaQoQYMJz9fs/u4zNNakix4acf3rNeb9AucDxsEVWKQj9WZd0ffnwge6Db3HA8HpGYeHu7YTwcOez2qDipUdaryNWmRSzT746IBvp+z9gfCRoophwPI6U8kVKoDd5TM+bxcCCmxM3NDVEix77neDwSgjCOxmHfs9l0dN2K3XZHkQbzjIwZlQHzkaZZ06zuCE2q5HuusTYyKSFdjVwGCkZ2oe2uCNry/LjFSg8oGhNv3q5oD4HDfqDvR9wF1YYY6udkuz8wutOkVDMsgcGFYRgY+4EkAXN43mV2g3Ec9rgLq67h7m5NitU9J8ZAVCV0LW7GGDP748jhOKCjEGNVM7erNVFrRBHq5CKMuZKKLvWzerlG4czK6IlUhKnZoNbmimJybvD1uaV9bv7W6YMxqTNP/e2ndSQ5Pz63I0+NvVCYq3lHoFSLaGNu4q5KzTmDMoZU78OUqqIyNqfc3BjSpNo+RwvVLx+mhRuZv/TqOESqQ9H0uHlZiMoFCxYsWLBgwVfxxxOVs1nEBfck4uTDI+Ijm8b5sQykm3fI+g3h+td0b39DuvsT1v1Hjg+/o7gi/TPj9g+VH4uJ2N3Am3+OPP07zAt031Cef0T2P7G6uefYXBP6Z9pv/wzSLTZZccyqqOhaQ7opSFBmz1c56bNsYgxnPePUWUYlBU9daxd4QUKKcaZt5DTZfNXmdW6Wm19xMZGcw8srtO77NPmsP3VikpzaFamrN9BvsSYxFKe7+wv6ww8M40hzdcP4/BPh6o6oQnDFKIAhE5FyKZL7nIcTEbDpGHwa6wUZC7Nqcn71RCKJMuef1OwDvyD55t/ldGgmZ4VkvWhyvn8uxzKPF8U8E1AihVKmTJfTZP18DebmxBgjmFMytUq/kIqq1Kt9JhvltOfz9TurSC/tcc+ox31JnH1Nqfq1x148Px//dNzudv774v0v/y6yYQxviOUTQ3wD4RkrEfFAHh/J3NDqDSHeY2wpUqbPgtfOSq8Kyxdk5C+oHOXzY3ROBHV9rG71cpz2hVL18ni+tj+b65svxiCzGBccVCJWnCyFH48t39/0/Pg0srUN93c9n47ON/Ejt13hw/GajoCZcOAaPFV7ZDJijvpIDDsaMWLImApj6bHhI1aMsP6egVVdLHGBEKqyWa/B/DTmBQsWLFiwYMGCBQsuETROpKFNzX1zk99EOBoUd3SeO4sioaoKKxFY6zm3Whdatum9APFq52ozK1kJB7Ea5nGZf1IsY66Y16bP1DSs1mtEDCuZwZyxPyKeK3ERZ3vHmuke2xUxtYhXokLl3BA612LBalVYpsZeYar9YkNKEbeMlZGcx2oLGhKtdpRkuBWQjIpjuWDFsDI7mDglWyW3LKOW8Jgwqq1t17a0MXK1ajnsnxEKGoyS9xx7J4+1fuvajmEcKCWTYiLFRIyR0o9kDRRAkmKm0FyhTcdu+0iMiaYRPvz8kTYqd1ctI/Dp8QmC8m26JzUrUhMJOhJEGfvAh5+3bPfGzais1muubt7QrTr6w45h2NfGZYMU16zWNT9yeziAtqR2TT8WYmzZbZ9JKdKuGh4fPvHu/p7ruyt++ukDrgEJhZCU4ZgxG4khEkQZ9j2DKKkNDEMmDz3uI1274rA7EJvIvEZSXBA3LPf4YAzu5LHQdA0aAyEmxj7TblaM1tPEAiYcD4UYFBMhpoYkYCWzWm8I3YbYdZgbZhnRQrFK0HoxbByodsaBYRhITYtPTdlPTz398YCVXAlyVdqu5emQcStEAli1OjaH7W5gva73rRVjyMbxcCSIEGPBPRJCAB9AoGkiNzdrbq6uETdyqTmV41gIAilV+9btoTBkI2m1mtWUqjpZI46QbayfKwNEa1O1zA5Xfnaeqt0GtZlbpigWmTaz2gxuMrH1cHKomteVTmtvItMayvnf/F0xE4+nSlrmlRhBtcan4IZYJUqrx5DgQQmx2rvG2FSismkIKdLEljiTliEhQRGVSQE6ratM6wzzGFzntuMpzmlyMSqeCWGxfl2wYMGCBQsWvI4/3vqVavtpU+HjOOLOuHsgqaIx46Ohbuzf/x37558hG83zhylzzhnf/2/E7g02ZWZ46SnDlgQ1g+Lpf8GaFd/8+r9mfPMnHD/9Pd3b38D9P5q6SfM0N1N04rxGDHKGbHhIlYCZqqSJUjkfhJ/+myZwUyS5nI/yTCfa+fm5he0FMfnaObpgXKbCUU7PyHn/Pk9UL4hf91MnmroTbAQ3hu3vKQbd/a8RWdE0K4aHv2bcb8myJra3ZBccI1CzDl6MSfXEVp5sTKd225eE2ktV4WW3rswT4Atl4UzGnjMgLw57OkEnaxHmyybnfX1xxuuEXihEmlpAa73HaveqEQUGp+ZVzpdDATKbjSI+oNJOBK1f7HkmbedjPBOZnxNuX8uP/CUr1196/LXt/MXv83F/iZPt6UwSlx4PDTY+IWmDNzfI+EA/9EjXkF1ADtOHXCZ6fLJ81c+UrL9wDK9jLqJmYntecJmO4jOS+/PjOKtrL8hLXp7Xr9oH1z1MjZv1u2Qo8PHQ8qv1kR8OhU6ErBldr/nDLtDYQJMUlUKwHVGUUkaiZZIJFiG6185ShGRHVnHkU1GKFFrdcRVGXB2zhmIFrD7nLnj+jzxtCxYsWLBgwYIFC/5BIcREHvNZRYkR5trIHRVHrZJw4zDU5l33iQxUhFDn8SLYrJ60Um1gzcCF4jbZ8TgaqFmSVaKJhloHiE17d8OKIK6E0NC265pbaVoJT8vkbOiQMRvQXAlIqKRGdocUiTGeLTXxStRMja0hTKSqUxWYYWpqtUAMLSEZxcrE3wilVOWkeM20rMdlWBmxkrFSSUwbR8iFnA+4DoTUEpr1lKUZiG1TsyifHumHHtVC1zV0XeJ51/Ph+VMloqKwXkPXNah2PD4X+mzIqHRE3t6+maxBhauuRcRJq1XNNDzsaJMTtGG1WfO4O/Djj58IPPDu/orvv7+jeODx6UjTwmiZ7X5LyQPPjztUhW6daFKLiSBaG3IPh4H1KhEkIdcd+32PEPjDDx8YDsdqpdquGUxpN7c6otwAACAASURBVFc8Px9IMRLWcHwe6Hc9eZyuvTqYkWLkw8OO0UY26w3DkHGMXb+nEaWZCKh+GJCSuNlsUJyn52fGsTCOezxD0zU060gw47jb4W40XUPbJY7bLeJO03R0zYqx7yl5ZBh63AJpdU9KCWyq7UPNShVxnABeKKXmrI79E/1xQIOwvlozDANDX8nVccjse6EfhTJmUpMpWu/xFAIU6LPTxbbmYI4HXFr6XDiMIyKFzeaaN7Fml765vaZrEm5GP2TMMu7Q9wMgrGgZi2E+0rVC2zXEGIlBKTlzOPQMY6mZqqHBSUhswONpDWZeNzmvgjgitcn73Gytk2PX57E057UKYW7KPq8jndevJqvZqdrHz6SmuOPVO7mOR6qNcO2ar0plVa05sSESY7V7jSmR2qqkfEFUalNJyml/TIRr9Y61yrq64Do1SaOEaV/uTkarWnrBggULFixYsOAV/GcQlZWsPKnfADRw2D7w7vt3/PzhGbdM0wbK/u9ZaUd3taG9+RWS1qgK+U/+nORH+p//Gta/pr3+hnE8kp9+TyoHbv7kT/j483t2D39DHLc0qaFsPxDygDfXSFojoZnUioaZExCOfY+K45qAl2q90/hPBOtMuH1Jqpw60uQs43LXU0PcnBNwVhpSSTuHmdT0074ufpmUki8zA78kvsSVgiFewDPDx/8Hz876zW8QTZiMFBPau3/C/sNf0TYNxIRSbW/Vq9bx8+tWWTo7kY5nNd1UgKq+ULxdTpj1ksCUWnBWJWYNkr9UIAoyZbtfKO3cLybcfEGW1Z/OaZYtVBUbzg+/+1vubwv3d38BXg1oNcgpTH62UVFVbuKB3cef2K/+FSIt5xFVgvLyHpivwy8Rjb9ky/pLisnXCM9f+vvLe/DLx9UzY+4JIowG3t4gPlk8pXss/kSa7HTEO3L/gKzvz0TxKdPz6+rhLzM758fP3Z/175c/LzM+5yv6uXrypd1wvSb24j399J7nTNDTC06FnstMvAIUxlF58IY/WX9k0+zYbUf244qVaSU2p8/xujzg6Y5CxxiVjIBEjl7tslbyQBOcnd8yNFcknDc3Az88TFk5XuhCZNU9EdiiIfHlnbNgwYIFCxYsWLBgweTVMpEV7tXhJYTJlaf4lIsIbk7JA3lMWGyJMaEhVDvXqfYMla9ErGB5rPP/SbFU3XQUd52aH3XavxBQRM6OPSCYGcXBJKCpIa0qt2BjD6XU5I1smA+4em14JRDRqla02jQsVOLJfCZKHJVKgkCoJIrXbarjCgh2IjtEBI0NIoJZBsu4VZWnSCBoQWRAJOASKqmZB8zAhoJKRptQ8zIDpGbNTdcxHHt220d2hx7liNhIoz0pGZoUdeGwHTBxkgb2h54UIsed8qTKm7dvubm+ZhwPbLc7Hn78wO3NLVfrW8bxQJHAbhx5PhRub2+xYc+Hjw8MljGLiATuUmS9buh3D/gh0qYVt2/uaLvI8bBn6AfMq0Pn1arBxoEUWkxqRuBw7LledzznnvXVLX/z9z9xf39LKQeijvT9gTIYuR8Y93uCOI0a66ZFg/LpccdA4f3jnnZs2O4PbBrhtoscbaBZtxwOlQRMrbClR1XYXN9UG99irK/XWMkc9j2rdcP6as12uyWXI/2+5mmqCLk/cvSRmBqa1KEo/fFAHo5oWlUlpdU70rwS7VaotsKaWK0bnj59ODVxp6bDREmrkbIzhvGIjcY3Ny1DWfHhcQuqjNmRMtC0K4oqOddsy65LhInsN6u5mMUyISXW6xVNioxjYbfb8/j8zFicNnUMBRRD1Ekpsu42dayTqRNeGMae3b5nzCChIcRATE1VbKKI1Qp3bpie1x0qalyNmFzUxdPq2rmH/OLx6TUX5ObpsUlJyfQdc2olnmv0Uy09j6ESwu5OCKAoQQMSa+NBSomU0un3GBMpRlJMhBgn61eZ9v1lk3ttBBdcynl803eOu5M81IbfBQsWLFiwYMGCV/BHE5WnrAw7K9WKZei3/PZP3/Kv/+8/kGJg9e2/YrvfElNHiJGy/R1WBtQjdBusu6P99s/Zvv//GN7/O7rNFat3/xS1ke3j36LdO9qUYfNnsH6LYTDskP6Zsv8BKRlNHZI20FxDWhNirEVcqB1fPnecyUxSnZi0mq15svH0iS2ZJ4I2vWaeKdYJnr9QG3olbLUWe/PDiuCzak0m8u2EmSF8qSaT+bnTOTbEQX1k3P7E5pvfkg1MpeYsWK7FKZDSLbv8kRgaRsvVOkiq+vA0OZ59M2fl28lHU06E0GuZjcCJBBTOE+35tARRmiZwHDNus7WrTLPs+YhnpeXFUc5E1Ez0nk7/eRs7zecV18S7t2uOh2oRo+LYZAF7tn6t48w+omUkSmRgtiGZcxjOZOXlNZjvkdP5f4WoPW37FWXl1/A1AvDF8xeM+tesUUUEyxn6J8YE0n1DoObCFDJBetQKhIa29BRzjvtH4nq6n4BTdsQJUwfkf2DsnxOJp2NitkP+0t517hK9tIE9vS/n++DSani+JjJXWdN9Ui7uubrIEtBJeRyo295vDrxdK8/HG0qrrNeGoQy9kWSkDUov10SBxkd6T2RpUFNUBr6/6inHnodyx95bIspI5nGf+O27kb//0VCFVerxXtkfB0zK9D24YMGCBQsWLFiwYMGXCCEgQCnVMSQERVVwqarIYpW88QylP5I1EWNDim3NEpy7X00JCCIFN6GUAREIMdb6D/BJfakapnJsaqCtXrCVRFFwlUpmiiIhoY0Q3SiqiFd3nqAQoqAp1kZYCdWudFKG+hQpAUz1XN2vCAQNaIz1+cka0txxK1jJhFDHZ3Z2FxIJdc4vdYy1qJ9rvIJjpBjw2GEmlMlqVgWaJuFB63uI4SbcvY3gGfFMHo/kMbPd7tkfe5JoJazahOfCetWzP/YMfU/fNDw977h7+47r9RVde0XQT/zw4080bcO7b+95c/eG23sh/u3v2Kw33N3/GY+PT2yfn7larTjs9/z4/pGn5x2bzYr2TW2y/vjxI+OwRdwYhwErjgRh6Hu+/e5XaFrx/g8/0jSBMvYkHfn+V/c873v+8W/eElWwMTOMI8/bA5u2I8bAsd/SdS1JGlbtGlfhOD7z46fMD7vI/mlLq85/8e01TRLyMLLbHsmDk0vmTZtwG2naFZqUpIEYa8YhRcBg+/GB3B8JTUIJ5ENPj7G5umY8HJFx5Oo6cbVe0R+fsDGjNvL08WfW13dkFXxaMynFaqTL1E6bC6zW1/THI0MuiEZGh6u7d8TwxOFQEHosO/vjkdGMZNAfRmgbcoagwipC+v/Ze7MeWZbsSu/b28yHiMjpnHPHGm6xRDRYEsimhH4QIEGA3vXH9M/Ub1JTBET2UCjWdKczZmYM7m62tx7M3CMyz72NRpFCt5q+gDx5MiZ3N3cP2La111oho7ElaCZNie2u5SBw/zhgk6NxwDGmZByOR05jUZzuNhuGYeJ4GpgmJ7aKBMOANgY0BNKUydOEJUOkI4QeQgfawWz5utTJfl4SWRTVFO3jYo8sFOPXuX13Jjjrl4dIfe78U5rySz7nuSb/ATi1Fj+vLZQMTa2ND4GgEQmhkpMlm7KNTc2mbOmajhAbNCgxRFS0KLVnpagIii4bLArR8t2gMjeK1/UNC4itVkQrVqxYsWLFih/Gn0xUhnlSVMkux5E08Nmrjs0m0Eal30YahXE4cHP9Oc3tF9C2BAxyxscDh/uvkd/+azb9FstH3n77HZskvOwfyf6K+PJnGIn47u/J/hWh2ZHd0H5La5uilMonZHiPP/wDeTyAZVxLoeNWSMS5nPpI/PZMVTcTej53nv1At5i717iP86TQqyUpXrY3f8a5e+7CznPhyM7db8vU8lKdWS00cjoRrl8Suk9J05EQ+/rZAcfJh2/Q/pY2OMPwnra9AwlUc0xE/JxbInahdhOW/Mw6QjJbg+KYyNM8yWfqtplsMxFGq3mVxd/kTEpJIZWKNXA55Hl0S7ddfdHSaXg51IISSsktwrvHkbeHa24minJVFTUplkgq1Lk645R5u+/JvsOGCW23UCfLUrd/qWb1C0L1ySn6EYLyucLy+XOXasWPCU35+Djn5589vnxeqWzOJLgq4ies/1U5HqldqUC0I0l63A6k+Aq0QeQbwMr1JL4URfNxOl4WKuamg4XALtv9oTG4fGy+np4T3E/VlU/JWQf0omlAvWRmPLW+9eW0nDM6KNcKkFyLHY9mrjrl59cT3z8E4qsXfPPa6OTA16cdQcpCSrN9TxMynl7TdJ8SdGJjb7h/DIQW7jYNx70weWDbGjs5ks0xjGTK2w+BLz9NfPfWeH3ccBOEFAzCFcXuZsWK//z4xc16La5YsWLFihX/JWFWDoZQbBa92pyqeMlErDVWtgxSbF2nNNLYVBpTm0CQiBBKnWuK1Px5r5avKoLJXLs6qsXKcVZy4qW50K2QfWZn8gBKfRE04BoK2VfrghK1IGCCewYZcRGSW8niq0RHiLGSFwoUO1MRxVxAlSCVRrVcGnFDaW51L8SVWZorxEJwzkoxB7dQLE2D4NNYdjwI7kp2h1isZYMqMXaYgIiVx6QBcaZxAg1oY7zYbLlLE6fjwDRljjmjMXD74pZPGsUt0XQbTBvevH+LALvNht3dNT/rO969e8fD/Qdubna8/OQzRJTXb19zf/8elcDLV69wd/q+4bN4zabboHHD+/2B0/07PnmxpdWWYRiZRGm7SLaR27s7zJ0gxhdffsrjw3tC2zENxjiOtE3gdDS+++4tTQj0244YO6bJEEm8eHnNto+IQh4Tj4+J/Sh8dzA+DM62bfjipuF21xFjBleOp5FxNEITyrnAIUCILeqw/3BPt2mYsjJOic3mipQSkAhtOQdu5Rpp+oZxHJmmxIeHt7gZMUSOj69BWjx1xM0LCE1R8jGRbKxrJwFXYRwmYCJo4nA4kXOxAB6HEwIMpwGNke2mA1FUIGVDzQmWud7esNl0DMcD7hMxNkzTxON+JE1OE1vMjekwwCSlAcDgarflatuhYgxMNK3QdEqyzDAMCIqqkqeJnDIpGSE0tO2W0F3hoUe0XRSP5b7S6kY019j1RgTmhvmLFnXOjcNSW+HnVZq6HiWChLIfhZwP8xfM+bsGyjrUxbJNoVnPNficYalBy3pKCISmKfmilaiMNaOyqESLmjKESmpqzaisqu3y/aYXa10CUtTd57gXcKtq6lVQueK/EPziRvm3//v/9p97N1asWLFixQX+Edavs8qqEnfAKT1y/+YNb6+37A/QmZAswziQjm8hCjJEEpD2b8n7N+xuf4J99de49thpT/jm75je/Ya3XUv87KfINCBq5Bd/Qf7wb7HwKfH2FW5KlkKOqbZYe4vLLxE1+sPv0W/+PaqxTstmYozyl5/3/fKILv9bJo6XKrezJvKsLqxEzKzEu2RCBUK1UMUrIfeRz+bz/8qlxAyXTBBh9InNzc8Yjm8QD8R2W+wqdYT9PdpeQ4ioOmk4EWMpcNQCs++H1kOZO98WtRszZVk6XKnkZBGqeT1qX8bgvNPPiCm7yCVcDuo8FiJSSOPFRvc8ZCwk1A/lN3oZR5xv/vgHrpoDf/7n/835PCi10K/jJgYZHt5/y7Dfc/XVJ8u0+ZzJ+fQkzPa+Pp+/y8zQi98/ZmF6JuXOpN289+fT+uyxZ8zoU/Lvkkj15ddMspo7ErZ4foc2L8m1EmnzQNYNJkpQx5Mx2RH3CJZA2x/cN9zLAoTMBPvy3+V15e/5/2dC9rm17XNFJRT7YRUpHdRcXEUytwOcj/XyjnxCUsrTETQp2Ss5Tfz8kz1N2PDrNy3b3njzZiA57JrIT6723J/KPtt4Yjye0LDDiQyuYA277QPH0dhPGdcNj3ZFHhxFC3erAmYoyv5dx1evBr75oOQc6D1z9MtzvmLFihUrVqxYsWLFGVFjaRqV6l5TGzHdBPNi1YoLYoVU8FBIi5RGcu5qdlxb1Gch41lRM0RjmUtbxi0zGz+6Q3aQautYalJwKe43JlbyKnNNfa9ek6pOiIpZsVe1lHBLJQUvaCEsmoROAxJbQuwIbYe0SiNK1Kbso1AIS9Gi8vRc1KI1d1LMijWsKOZOIi/RFCGWfcXsogwvBI3QICiWE0ipL6IGJBSSNMSARCGKIgrTlHG8ZGmGFtGGYSxEZ7+NbG6K1e40DohGmhgwH7DsmGeiRmJ1hTkeHjGKCvHFzRW3t1fsrnak8UQTjJvtBnfYbLbFbnU6sNv27PcTf/jdd8QQuH11RxuM4/E9221HsJZ0mGg3G8iRt2/fsut7NpuO9w+PpJzo20jOI1e7a4YxM45HXr66JWpkGI7s+p779+/Zdg1tE5f6ezid2O8PpDQRFG4648vbwE9vO5REjA1pikxmPEyOHUdEH7i9Ksq5nDJNiOSUGY6Zrm1xLSrHrm9o24CoEkIgm3E4PdLEyHZ3RWha3DMSCiM1nvbEzkjjAW1vaJor0pTQGMu1RLEgFQrRfTwdCzFpif2HD5hBykLKmdgFJCrqymZzzTgmTKDb9KgGJst0KsRNR5oyKRuiStdEQiwEY07lmkAgp8xoRXM8ZANPaIDr7Q5HOA4nhtOAuDKdBsZprPdCS2y3hP4auis0NIhHcMi1SVaoN6KX5oCicM6FvKxLEnPTtpdvhPKFUQvx8lQlE0VxlUIqBq2t5bV+r2tWizbVrDbWzw3B5RmoVGhdv5IQUGkWIjLGSIhNIS1jSxOacg/EWJoSQmlAUJ2jd8LShAGC63mdzKryelnaosS2lMbx8P/NF+2KFStWrFix4v/3+NOJymckTXTI+3umnLD2Fcl/z/XmFr/+inh/orn9Cu4+Id+/Jj1+S9/foV/8JYSmZDG+/y06HXn1L/5XQntDkAO8+y0nT8SrL8sEdvs/kr/+G3K6I1y/KnkelAleqGRBKe6kdIEWL9AL8uicr7dM7BYP21oKzWyTyOLtf3HUF/8+HYfyRyUYZwKvquFk5h8Xsmemap7Zbfq5i65sv2aSDCNN06PdDY/f/R1xe416wE730PWEuCXt3xHE8RBxDUglBc8TXhYycMbZisOXv5ccQy/5KR/nGH6cp3gep6JyNLPzczhtE5hyLh2vi4bvYkQv9uNjS9RqLuTGtm/45Vc/5eXdDapCnonWSliqarEkaQMvrl/wobtjzj+5JFk/VkQaUUpHrpmxdB5fjM0Pnu96zCWnoXRMzsdzaRdcZaRVLVjJX/+YljsTg/6U1P5okwkPWwIZP/4R23xKdHA1krZICGTvkekNEjvC9gZIiHblvM7E+eXxzcrHj/i2czvm0pTwnEz+AcXpxQOlH3QhYJePOw/NfAsu19O5SJvJ849hkCJ31x3jaWLvLVs98LMXkd98l1FR3p+cTdeza4+8PvYMdgfye/aDkzc3bOLIZ5/Ct98FQu+cbIvKxE18ZByck27LgojlkofpRjblH153fPnJidOjMxgcs60F14oVK1asWLFixYofRKEhDDNfSAq8/N9SrkqjUrdlc8QMkYgScSuqQ7Myj1YtRI2bYWkqCkKbMNNSI9SJtVlmmlKZ+1d1o3pRGJpCxsg4EWOSTJqmUpvEoo6ConR0y2Q33NKT+iYGJYSOGIQmRoJqrT3L8eVsxQFnrqssk3Mq9ZI77mnuwiTnXIncYi27VJFWagERJTQ9Tet4znjOhfyxSviIliy9tsUlFoJUi5VlSpmUMnjJPGzaDadhYEwjqqCxpe97isQ008UtwzGW5kYTfMycxhOO0HUbdtsegnMcjhiZx4cjD/cH+k1gs92yfxiJSLFCTYkpDXSbhqvrawS42vQ0UTkeRzZ9yyeftgzTQM7Q9D3a9xwzZFfchBgahMDpNKECd3c3GC3ffvsWm440Kuz6wLYR1BLBA+OUSO6oBLax4Zd3Stdd0UTodm0hsszQSm6REzk7+6PhacQmZ3PVcnN7zdWLW47HIxkIUQkoaUic9o/0uw1oYLvbki1yOgyM00SjEGJDo4HheKTvOix7icbJiZRHJIbSzA2IZdI0IhorCa2MQ8aSMw6JcRyI3Ybrmy2iwuPjidAoaTJShpcvdvSdEKKiQUjDSBMj3abh8HhkmoymCfRti7cwJSuk7zAwpVxreTBzgjSlERoh+0ROIzYlLBV7XBHothtiv0ObW0J3h8QOQqhN7GVdqjTolpZ584xZrg5KgpMv1kqKihq9dJ9iWbtRCWWNIwY8lKYDFa2Zs5UgrOtW5uW+F6mt+m6UPoRc77tKb4qiWtZZQlCaEAkhVrvXmlUZi0o6NOW5EEoGrGqo3ydFQ3nZ2G3VxUxdFkezuWF8Jk6d0gC8YsWKFStWrFjxQ/iTicoZMzGRo5AP79l1PaP32HQiXm2w/RuISn78juHxd2yvPqX/8r8lhRYx43h4h73/Hd3N58SXf4UYuBiTtIRXv2IzfsPpzf+DXv+SsNkQv/iXpG//pnR9Xn1SaRTFJQATaookX7zzZSHblMXOtbZ2fUw7UpRlUHIxqtpseY4zAVc4pfPE7ExAXpJZl3am5+2ct3/+LMMJMs9M/byN4JDek3KklUC0idP739P0t2jIqPWkh6/h9EjsrknTVEpLrdtcOB/B/DwpDKKFMJu7+GbysY6RVvfAH8tJnFFyOc/Wuovd7UzacpkzOY/43CV4yVrxZKJ7+du9diAibLsGSKVDUIp9kqiUwluVRhpEJ67bDo2RPeFC7fhjtq2hFBO10L3ME1WZr5uPFYVeC2dxK/mPUtIl5pE8wylBMMuolVEQp5RsthCFfkHSna89WR4qhF4gSUDbF6AfiOM72laZuKL30lF9evyaLiRyKnZQOU+EUMnxZ8d/Ho/LomEmjc/X8uWxP3/vD5PM5fqbz7fN4+/U83f5ueWSEcr1MhP7pf/zgtyuiy8CTOqMj5ljs2PSLeLOn28aHoZM1pLvMRyFu37Dy+7E65OXTtCcuO0+0HcNv/vmQNN07NmUSzZ3DPSEOHHbHICRh6klpWJHZJ5wCfz++56vXgV2IfHwIfNP8FW6YsWKFStWrFix4r9CmBmWM9mskBdGJSwzlnN53g2zjGXDUiEi9aJh07Fio2qyqBZFAxrKHFRmtRJF7ZQrsZizkdK0qNU0VBWUCjHoYvVaaFJDsi0ESUKZsuA5o+KoJ7JONF1byVVZbDBVi+IqxkAIseybFFLEcXA7O/CYkT1VR5zZ+rXO+FWQmnGpTVtJx1KYihuuGRpDsDIuZguZ6VIUfsVyNmBW8iyDGinlQugg9H2PWSClxOl0woaBEARx43RMtE1DaDqOpxMhRLquYf/4yCklNpsb+r5HJSIuxBDYbHuurrd0/YbYdJyGidOYSCkTQgcW+PDunrYJ+NQAhciz9EBsQlGo5cTN7oq263n99gPD8cjVpkMo9YflzIu7l7x/fOQ//PrfMw6Z611Pt23Zdi1RICXlw+OB7bbnatfQNoHNJqAaOJ1ONE3HkI3NdsOw39PEwPW2oWuMITlNE9CoDNloLHM6HWmj0qhwOh65ub5GIkyTMWUjHCdUJ5IooW3Z9A3JJvJUznFsWnDBCITQMSVH3IhS6l7LGQVympiGR5DEdHgkjSPYyGSZtmsJTUtOmRgEPDONqWzHlSlNjFND5w0htDRtQ07O8TDQdg1tUBLG/vFACJGcIZsh833gghCJsdgNp1Tux5QccyONZR8RJ6rSdC1df0Xob5H2ltBeoVrI8fkewkreZPZcmpTdEEt4drInxIvSt6wnyHnJRs4En0hZr9HQFBVjDNVBa7ZXLhrUsn4hxQnL5/sslQ/MGeRc3895mWV9TAkSiBoJMRBjQwyRRiNBZ6vXSAyBEAIatMbtVOK03kui81pBcbiqSzRLQ3xpWZ7DhqqL1vKeFStWrFixYsWKp/jHra4LC3EQsnB4eM+XN7c8TArpRAzC6cNvkIc3tDe3bL/6n8mbu2I3M47s3/wDUeDqy79konRMljx1QSWibozNl2w/e8X04bcMx57+9meEL/6a6et/QyOK7D5HPINkXJ3gQsojpkAIZ7XWBSl3uftnOWCVk8lMvvj8RmaSRJ69d+EVK7F3qcCc8yEvKMfyCRckkbgt+xPmCZzMpFgpTs0gTwcaVR5ef4tiNO1PGN/9hv72FX54j3Yd1kX8/Xtie4tqqMrQQEn+uzi+Zf98UbsVUqoeb+19W47/4xN+/gT3ZZL6ZDyfkbkpF3JsPvQnZOEFkTof9xOSzx3RABiB0snZb3qCKK5abI20dOaKKiV7Bb4fG1DHJV/s3TN15MW/BiBaMlPqeZ85Y0GWz3GrXYtFYLeMqyxBEKWbeFYILiTnkv0pQKh/Uz7E/ckhX44Hfs5LLZ8zdy86iqNxwyZ8IIwfUBkZtUfJbLct0U4MaU+WLeQE5FLSVEL0iYLz+XmZt3bJl3ImUn2+AS4sf384s/JM4KvPJOT5dSW/lPP7nt+m9Rq1CzVu3bXSoGDCNI6Ebsfddeb+oJiOaL0MM87bA7zYtnzWDbxXQaYjhynwuN8j3Y6jb1D3Qja7gBgJ5d14QxeNu+2E2SOPx8iYG5CMiPLb74Vffh74vAl8+5YVK1asWLFixYoVKz7CNE3knCoZV0k1s7PiKc1qS7CcmMyZxgHbZMqc+rKJU+vfxX7SUJBQFI9WiRdxQvBKVKbiGOOGacTMSwPo3JArDmKIFjcdd8fNsWyL4s2yYXlE3UodlAfyeGQ6HYqTT+ihEh5N29G0HSE0xK4lxqY2c9bGw6rSxCm1m4GlhFmqDiWZGDo0NGjTIZU4URFymnArpGlRbualVppJG0FBiyY0hIC7F6VcyGQvJJRnUI30fWS73ZDSyDgVq9vYO9hUbHBDx3gaiVH46U++KMSbBmLT1ToxsbvasN32jNOJwz7RtLmQPGJ4FPBIHjObtuXu7orYNEXtGCOWjfsP71HPtE0kTcLxNNJGYfPqJdvtBhP47je/Ydv1vHn7gV//5mtElE/vU28WbQAAIABJREFUrlDLkIz3j3u6LrLZbdnutkQ13CaaxmialnFK7KQlqHIdA1NOjG5kc7KVHMbdtkMlkcaRYSorE2kAG52+i4S2xbLh2bBsbLc3bHdbLA24CDkl2rZcV23TYFMmyVQI9pQIbSA0sYxtHhhOI03bkitpF8Q5Pd4z7h9LnZ8SMTQMMiLByKcTh5Pz9v0jp8HYaiwEtGTe3j/gotxJIHaFJBzHRM7QdYGu7xjGU7UaNmzKdLEjNGXtwSxjk3Eax0I4OiRGQhSaJhI1FHUyTr+7oelu8O6G0O7Q2KIaKeaxYDo3IihqjqkjnhALVTWpZEvFErY2LHhQ1BMuVeWqZc0oqi45sBojhEKmqpxVlEuWZQaqatKz4tlQLceb57Zy0dLsLxBDIUGX7MkQyz0XG5rYEENDiE3JxAxhIUiDas2frU0Ide1AKespKrXxWKSOCBerID/WNL5ixYoVK1asWFHwTyIDEgEjMx0faD+94+1wRCWjfgQx2i/+JfHmFbbZECxzfP8NfnjD7rM/I3S3JVOj5k1C7bKqRFFwZ8yRcPvn7NJ7xjd/h1z9lO1P/weGb/8vCBnd/RRwNBumwuF4RCQSPICXCdRMuFwqHJ9PknwmjORsynlJvhTO5YJgk2f8khiyFEmy0H5zAPqc0cf8+MzIXGxjEdRxntw10rL94ld0aWS8/w6JSnf3BcP7X9PsfkIbd0zDnkG2dNM9EqSSa2fV5nIMcs4LvHwczhavIh/be5bHn9m+Lm+oNG4lruejvLSS/Y9+zpPn9NmrS/EpDjEIXdfSNW3t0OXczYegOEEhBogRhiSEWMZ+OS9SKMJFAfuEJCyknVE7mH1OeqgWRfUYC3E2n1sv1+uFheo8JqX+vyDv5hxMr+edOXviktA8785zqnjeZ1Fh4yc8v8e8ZSIwhTvS6QMxPhKaltGNU27ZyH3JmCHWAuKpDet/7Dwv16zMxf8z1eQPXLfPsRxVPahZr7qoVuubL27Li2P9+NOWz1MDV6KW854Rvrxu+Yc3Y6WLS4eqUgrE98fAz6+dru95+3DPMNwTu09IuShdvXab+tIoUK6VUzKOg9DEHdd95pqB/UkYUsQk8M13I5/cCj/79EcGYMWKFStWrFixYsU/a6RpLNaLIkst5uLFUnVuAnTBrLoAOZxOR5ruSAgdog0eIyKRWn0AZc5eiIySJWlZC6lIBtPSXAdELWSnFL9HFCGbkc1Kvem1dxLHhOosVDIfW49kGvKYIRtOUYGKZzxPuCruB0xaRDtOzVDy7dqGdrOj6/uiyJK5IdUoVJJV9WgmTadCXkK1/8w03bbsQyjxCllyqcU01uowF+UlToCqKK11jsw1ihKoZJAryUpEiWperHRFhLZTYkshSz3hrljORA0MzZHj/oHHh/uixMwOGE2rtN0GCYWkatoOpszpeGCouYZmmdAGLBu77ZZTmmiA3c0Nbd+zvz+wu75lGo9cX18T2p5szmH/CJ4whP3+xHa7Y7fp6dqOv/zLntN+z+H+A9fbDWlMaI4EDMYjdy/uGMeBtx8GcGfbN2yiI22xmzVrCpGUM2CYJDabUJSKU6G0NDiH44m22aIKp+OJJo0Ea0td3ERCdE7jIyrQxJ4Ym7IGEwJ916DBmaYRjYGcR2Q8FJvYEEl5KqrGnABjmkZyNsY0kvMEEmhiZHQhJSeGBvOJ779/x/dvTxBaYqu0Mj8XOB0z+3AiYTRtw+aqRZuAJcAb2lax7HgaEVHGdFbiikxYnmibDhPhNGQ0BGLbIOJMYwYPdF1Ht7tFm2uk2RLaHpFCXnslyENVLS4/5mQLuOVCYrpCVlwpv71ky2YvpLpCyVutPxoCYSYqtax4qAg2k/8imJdmAjUjW8YllO+ASua7SSULazZsiY8tBGQlKENTrV5jXKxmNSgSQnEp07IGofU7RJafun7HOeJFOK/xCJeNyR87MK1YsWLFihUrVlziH5lROYd0GwyPRAY27TWnt+9RycTmjsQdod8QNjekxxOnN79h9+JTws//qrzXHdeAXrCIM8Gz5EhWVWMOr2i+uIUPv2F4/Y7u07/G3v0thhK2n4JGjMzw/veIPJLtgHJdLGJQQp1I/djkaHahcJ6SNfPxni1BZyK17LNX205ZuJcyNioz+VeJofLkcozUjtdLOuqjDrMqDQuhIw0nNAaEHukiu1/8Tzx++/dEvSa04HnEdy8LxVmqsicitNJ7e+56myeLXBS7MFuC/FDHm1+8ppBGc6bD2bKUZ+Tox6Tk88/9OAdyHrP6/prraGbF2lZlKSxLcSEEmR8rE++gLMd2tg+lkldg80S6Xl8ipXs4SLFBSlbyJM7MtpwJRrHqojKfu0I0zhksl/atl2MxXyd+Xl5gzqq42MoT8vtjcrg8O8QrLLygz4+c9CXRR6Rrip2MHUguePyEIffozWeE4XUJuPeL7V6c1x8l7ud9MH/6mD8lJy/P7eXnLx3OlNyMmdydX+tyJvSfb3N5zRNSvXabe13IURA3NGSudhsev05EhFyvQ3MIEnjRPbKfAsnKOQvhjuwNWY1IgnyZ21n3x3L5UgiR7Ma7U0B8w01n3G4OHE6KZ/j+3cTu7oYVK1asWLFixYoVKz5GIQ1EtFh9IuQiKiSJ4TKTjoGIlww3S6TpyJQ6NLY0C6kigJ17I1UQmtqY6wipxC2K456XPRAp1owIS/OizNmY7qg4aLWCbQphYnmuWLQq7ATLiWSJALVhUGt4RAZGAiU6Aw9YHkmjQNOiTUMIRV0pZqA1UkWMRmNVhOaSUamhKC9zdU2SCddzvVXsbQthqbWOW4peqzET1HWGSqi4K0GLXW2MDWaFPXGn5F5OIyJGbBti7AhBCQpt16ChWIyG2IJODMOIeMu22xJiT7bM6XRgOI2M44Ri3N1siFFpu4bYXBGblmwDD+/fcv/6G0Qjfd9xtd2iNzuOp4H3b98VBaxnptPIF599wqYPXF2/5PrqiuPjCY7C6/0bVBs0KpJAG2G7uULIDOORzbbjs+YF797dczgeub7eYjYSG/DsHA4nTlNmmByRgLsQpMSFhBhI2RBXpiScRieKk5Ly+v2Rl5/c0W87PKcS9dN1JDuSp7GQuyGQ0ohNh6Iq9IbQFIITEbJFkI7YKTmNtGFD15V1lu3NKx6mAXOj6XpOj0em4cRogQ8PJ46jMXlmt4n024YgRjDBJeCeSJZpreF0KBmmkrxYp0rklJzD/sjxOBBCoGlKjiPkmt3a4qYcTwPDZMS2LRR4jWoJTUvT79Bmh8SeEENdV1GcWBrFtdbqSx0LbobkYkWsWsZVQqkhs0ptYCj3LbVuRgVVWWxXQ7Vb9aqmDJWoLOrqomQ0NXI2sIyRQCKmGSQhVmJyZnGAiha74aDV3rUhalGORqlWr5WQLIxm+V1IyXl9Y15Zml2zpHyHXKw9zctgs4PXEpCzKipXrFixYsWKFT+CP11RWSckUgkrtxN31y1JG4b7PxDDhubzXzF9//cEe8Xh+/9ADA23X/0Kl0hwrxYZTuOOiRYzzEr4zZ1Yc/epUzoxmRrk9l+wmT5wfPs3sPsKffxDUbhdvUKIDLaDsUObG1wT4m1VYNVdn4nES72azJTWGfaMQOKyCGKmp2Yu9Uy0PtXCXZIsT0moue3srPaUi5c76oLlE5omUnbS4TtMGtrtNTFGPDvXr/6C0+u/h+6GsPkc1eMSTh9QTNJCwIhdkMFL0facsLokKetRPlHO/Tip+mPk4w89/mOqyudqzlJk1umwKk3bFnL4YruqUgqIoIToBBXwESyjcnexvXmMaxEwH0+dRYtAEGhUS+j9fF6rOm/5nHn86sX6w8dqLF2D9sPK0vJ6Pe/HfwoWghYan3ACLQNZlKm5psl7TJy8/wPcvYBTT7RjsT2qx2LLdf7x+bvcj7n7sXCbP/SclEWO5blzVTIreks3aSVjl83JwnIq/ODIPG8SuPx8EVBXYCzZHenE1Q6+fzeW/fFCjbpkOjFeNHveT1ccM9y0W8Tfg71Bwuc0FjBd+F/m23jZvjvi1V7HHFf4MMAH67nqGj6/HvjwsOft6/Sfdv5WrFixYsWKFStW/LOCasByJfxcCsmhiqBYHrE8IThNKPN001iVhUZOVuoSS7g3FHvUGjVByb/Uqqw0AXFFJWMqeD6ru4JUYsbAJRUFlDqevFrDlobCoIUENFHclKBCCjWDT5Q0nnBTslCy7JqWGCJoREIDGherSDPjNJwWkrVptWRZxlBHxlHJZAbMS5OoiJX8x8oiZpswDLyoJyc3VKWSN6FYb9aaxK08hydUrH5m0ZKJFheVoIW8LZySYGbkNOIh4zmXbMIs9NsN2vRc91vavuf+3WumcSKIstveMJ4O/PEffsP2+prNbkfXNIx5oGVCYsDdOB6dx0MiNiOffPqSGCM3ty84Ho60fU/TNsSm48PDkfv3ex4/vCGqc319zYvPXvJ4eICcuNKO11//kf1+5OrqmhiEm5srtn3LY37EHve4T8RYcjePB0NiUdSejkeYIDSByZzDYc9hcD48TogKV31EPaHiiEJORVnZ9R1CxsmETYunzFXXMZ2OTMfHqkSNSJho2khKjoSO0PS4OKYN05hp+p6u27E/jTTSkSQgLqhH2q5HtZwnnSYaTYhH0nAknR4ZjiNt25BN0aZjtCPJFXUlDUYWQ4LQbiIqgWk84X1P1/eIKtlrVqM74zQgWvZ5nE7kYyqknzrdtkWkqFcPx1TXtox0GpAYafsN0mi5JypNZ66LilKUxUK11Pal/sfLvRXinD/rBEvknMhixYLZDQsOnqCqrUtTtqKhXOeh5mkG0RLxU4nKOcrFrRKVwUjZyBqro1I5fDWp96wWNXMQJAgxalVNQgiKRkFiUVGqKFGq1awJGsv9P2+7rGtZXVuSpQH5TGJerueUNZNSbudVUblixYoVK1as+FH8I6xffZ6XIK7sDwfaCCPX+HSi7bY0118wfP3v6N/8LVe/+F/Q609qhyjkUEggBZKASqUtK8nxhFCrxIaLIY1ABo9bdp//9/j733DQjub0RwwIu89A9lXytejWKrk0E4yXSrenZOXZm3POjJxlVs+YDLwSMhdvpWaOzLaiXBJXl+QfuPl5CiecKdLzRxdnkCmRbCS9+b+ZxsTVp/8dqg3ZQSWgTaD77C94+N2/ZnP3S3QaEMuoKFls2cdZXeiVCF7O4bzNsrO1s/RMUj7HTBrphRJuJnWEMyFXCMfLsfOFZHv6eZdjM4/Is/GrbHCMgU0tPERqZ6GV4uDyNKqUruAoednXs0xO6hDbxfYvVaRwyoZ57Tp2Fpvcsiu1kJdqnzsTbvP4LsTzU2LvTGpenGTmbV+QcM+Ofe6yLOSeUXjNieCJwKkUTNKT3QkmZN0SbEDCNTEPQMZoUTuQqy3v/O/z8X+6vywdkraQnOfzV6IcL1/vtRiqqsl6zlRCJSxtuZqWaM+LxoF5+wtJjhSCWqg2UTMJWvfDA6KJ21tHToGtjPz2TSR4xCn5Obeyx0V4PW5JDm0M3KnzrUGMPZvunofTDWqRrCXXp5RvXs4VUgo7KcfvUopWRUEDhzHzOoMm4Xr3T+KivWLFihUrVqxYseK/MqhKjaUvlqNmxUIxRCVkxVNtkFVFVUmZardYM+ZyLuRGNpBQ1ZGlANJFmVjm3RIpc1p3SsKl4FqoPCgOMkht0AQ81Gfq4yVUvpCrHgJRGzRMaFTa1JDHvqgW8dIk2kQ0CNnAibjBlFKNw6v1UjZK6qEhjUOodeFCjgYkRlxrRmcaASGETIgtGhtwJ2hEq/2tZSdbxnwihljGRAOqEZGmztkdcsK9qBSLE1SpIwtpqZhloER5WB6XWiOnxCQD0kS6tufFy0/x7Ey5kE7ttufq7poQWyR0jOORuOlp4jUae969fYti9JsGxzFLxCbgBrvtFfvDgW+/+Q4JgabtCep88dlnxFgUkvv9gTRkrnc7TqeB42ni6mqHeaaJQtCSwziNIzEIOSfaJmLJyJ643lwRb3aow+N+IiUlZeXhwTmkzDAldn3LmBIhCuRciFuc3a7HUkakYRiEYTiy3QQ2XcNwGghNxzRlmq4jhoCo0JTgQ2JguVZjWyyAzYymabA0wXSg7Xcl6xBnGI4lV1EMs4mubznsPxT2jVJvHj7cs78/EUhsmlKt3T88st317LqW3abBsnNIxofHR25C4NX1jqjKaZqYktM0Stsqx8OEZ2UYM9q2tNuOdtMUUp8T0zSVmrUqeBvdEKPQxIhogxHBA+rV1SkEYtMQY0uIoa4FsayDmFWS0pSsjltRM5YMWSuZqe44sWgUK1Gp1Wb1/FNVjtTauS5vuJUM1pwdqgL5siG9NE0rlosisty3QgjlO6TYv4ayriTF9nVRbl8udC0F/vkBkfLdIXKOd8HPyskZLr681S/W+VasWLFixYoVK57jH2H9evmHctq/5dO+4aiR4XjP9c2WD1//LbF7gX72c8bXv6aPPdZti03JxQRGLz9z4QZn4oblQZViLVPqsoZkCW7/jCs7MLz7NfLh73AJNKp4iMV+g9IxOYd7n9Vz9ZMvyJKZm/OLWZnNxMtC3FVSacli9PN7Z2PVef/98ijtyZjJ3FXmCyVUCblCiAhFrZrTnjTcE3/2V3TDI1Y8TQnuiBpuCiRCfwPTA+i2ds/mheCaMx7nw3p67i45I3kyNssALezq2d704u1PsZC0lwd7Scqdx7u83Pl4c5fK1nl8DbPENJwQzzXbBajB7iZlMi8a0ZDIuiNrRrVkoZSO3ZLP4hcZpJdHcUldi0hVDRY7WKMUGssJlvNpPu+pP/08uXh8JmsvxnjORBXOJOFT9elM0FUCvN4gOSVamyBnprit16fiJCAQxRA7QviKLr/FsvEwPBB2BoS6L2crqOfnYz6sWRFpT854PWf1RXPe6XKfXg6pn8/7opKez0YlMvGLUfuoaHlK4p4JTAeZOKaG7Bti23I6HUh+i2M0PtLrgYmeB2uJWUCNu3YgHSOqzjAGaHZ8uj3yzbFFcqyd1RP4XGRWctIvvhEu7KOzGO/TFS/EeRg7VqxYsWLFihUrVqx4jnk261bkT0LGq6gwqJKqsk/MkXihXtLZ6tXJZnPrbZlDy+wgMtcaLASDSMBciKJYCCXOwA2nqDOLI5IVwjAq5ETK5XFd+jBreIY7bpnsPWQjjxNpyqRhJI8Dw+EEeSqkIYGUSuUQmkjbFnVb2zSoCpYnEk6wvDS5arXMVIlICHV/vRI4hntpJrTa9BhiW4gVWGqjlMdKVEZkVrlJsaUkCuZS7S/z0oBasj0VKFmcZCXGoqzLaYJAPQ8lVdMIuBihcZSWLlyXrD/xkn1oSh5BQ8Pjfs/V9TWbvuN42BcnHG25f3fPcDwwnAY0RO5udnTbLY5yeNwDJU/w8DjRb3o+/eQV4+lEejiw6zrU4bB/pIsN92/vcXc6ETZR6Vpld92St4q5M6XZotZoxMiWEITNBhpvUD8RNdO1De7CaTRUnC4GPE04ECPEULJTLRspTbSbhia2RHOSZ/aDEyan7Xs0G4+Pj4V4Vie2JZbEcYIqnh/Q7CgvwZ1pTFXNa3TdljTsQSKbfoebM4xHxnFcLJFvugY1p4vlWo9kghpd23E8nujaQOw7VIqSN4RIdiG2LagXklUCI8aUMwHFCTzcn8CNnJwooKE4HqXsuHq5VmKDhq6oRmNHaNtiB9t2hDjbGheyfK56nZmoVMwUVcc9ELKWW5K8EJXzWpFIIaHLjy4WrBqq9aoAopXH9dr4YIQAmhMpz98BpWYNIWApk0UxC4hkVMv3ToxSyH+NCxE6k5xcrPl8TCterPdUYjKfS/aLtaXafX+x1nJWXK5YsWLFihUrVnyMP52onFVl5qXAmPYle2FUNA/0tz+lvfkSPxyJ7Y7uxc8Y//h/0n76K8LuBl/sGS+y8Z6o6i62NT9fu7VkIfNAJTNJR/fJXyKn3zF8/3+QHr6h0aYGjpfXK8XCceYD586up8rBucg7T79CVcLNSrdFmMc80Zr3EYr/bLWSuVDogS1vWggpvVBYzlkGNa/yvEtGOu4J/ed46FAdEW1QcXLNG/S0h/GR0F3j6UAe9+j2Jaqx7oTVjj77aDzPXW88ISCfE3bzublUuT4lb2Qh1c6K0rljtXzS/Nh5TCo5vBzs/P7zOF1OsjFn07Xc3FzRNPGczSBy/qGU1CoQvRSVackAPZNml2PhbmgtZIsqcLYILudbKuE2F8NlnGqBW0fAmAnHeTwvR/DZoNZ8mqeYlYP+5D2XZPqS61i7FyXvOW5/Ws6tsRDswfaMskEk4Yyc9AUSO8hfgzmutqg/53F+/nvpwuRy4eOpBfA8hLNCdx6yJ3a4Urq5fX7T/P5ldC9G4Mk1dO7IfDIel+8wr52uys3GeLO/Ahc24UCnAx/yDaBEczwY2eBum/j2cYuGgPvION3yjW34Ynfi3SEz5J4sQhQh2/me/dgiuR6DFbvqyR2Rp8TvihUrVqxYsWLFihUAORfFk1kh/nKGGB0q74CWBswxJcSMGFvariPGSNCL7PdK6hTlkzC7jyxuQZXwKLVLU8hMycXqtRaxTs2x8/NkXiQS1Jba3Fxqw20uqq+cYFIsT7gXxeMwPDIcDqTxiKVEEwMaw2IH23Qtbd/T9ltiUzI0s1vJonRfSBFnVm/Vuk9LjqWqFdtXN9ymombLCZhJy7KvKopIIUctZUwSYSZsVZCgFBOYWK0zjZwTYgmXss9iIESyZTQErvodyUaKOq2Qj9e7W3AnpxPDcGSaBsQEtNqtHh84nR7RsKONJb5l0+/YXX3B4+Mjv//jN7hNRIGujTRdi2VjOp0YxhOWMu+PJ1J2Xt5c0baR/eGBNJwQNUKUosA9wYfX73h1d8fty2vefv8tfbPl9uV1UcemkTQODLmMddsq/WbHOMGH+z27TcCycdPvyDmRpoSZgOZCzLkyZSF0AbeJEB2NwtW2J3aKq5M903c9x+HEMBl93wKKS8DcSOPI1dW2kPDTuBBUpam4JZshDtmEpt0xHh9JZKTpyCSSDZgJXaucjnCcJmJQ9ofEMGWajRCCIiFyOiXev3tPjIEYmqKg1eKMpE3AkrE/PJIsczga+4cBRbi62tF1HcdhYBomQoDYNGx3EVEYxhE8E5q+/MQebRq0KYR6iIEYA6pcKCBDJSop4wHFAcoVs1iJyoyFSjS6LfehyPxbCMpyfxQb2HnsdF6hWNybzM5kpaiCJEqmbIklMbPa0C2Y5fPaWChjGIJQ3GTlvAagSxFcGyEo63RLo/5Z0Yk8W0eY9+/i+29eHXm6grJixYoVK1asWPEx/lEZlYUnctwmhsfX/G7/gSGegMz2+gtOpwPNZkfQnhga5Kt/xel3/4aYf0F3/fkiSSsWq3NW33ly85TIKK89P5pKMeNCFDDPpP7njLuJcf/vCNcvi/JSpNq8zO8/K+HOCi7/SAj4gxMod+Z5W2Uq6n+qDYd+TDJJtaBd6KsL1djl9ivLs2y5TPSUcRy4+/LPGD58Dxjb3SsgE03JeSQP9zQ3X8D39/h0ZDgdibcA0wVRCwuzW7twF6JxUZLKx8f8jFj6SFnpzmKnWwnIs4Xr00+bCcmnFq9Ucopnr31KXlO7Cc1hzBlUl2wEFVBRXEvGwmyNkgSSOGpUJe7chTyzanDxn3oG/fISYKEkpRDzoSp6ofytdSwvlYPuzuVF8lQReDm0T8eNZ9P5y/ErTQHV39aLBXKSDjm+h/blmRj3iUDGwgaRHZqOOEY+HcDBMEQi7pXs96fX62Uu5Lzd83D50/1SqoVVIXEvr+tSmNmTsXxuKxsWReml7ezT+/TyfMn5Kiz/E602Toldt+G3b1s+2b6HsOH7x7tKOnttMhBue8NDT2akaQIpjcg2ox75er/li92J+/HE8dSRNC32NT+WoVGKs0wQMCKNTT/4uhUrVqxYsWLFihX/vGHJyTUL0q1UEzmXTLiwEBLld0qJUu4EYtsuzXwpjQxjwBAaIMZQlGvoWQnlc2OtnUkEKQ26WI2TECG7Y5bJ7ojJkuWIF7PY0mcrGAnPGUuGTRN5mshTwnNVNwbFQsPs/6gaaLuOzXZH2/WlZsuJyTJeM/cKKwKmToyx1BAhXNQSev7XQlHjhWLpqlLiF4pdUlVNaqB43+RS77mQPBNUy2sIS3Os1diKGBtytd0MWuJFwEhjYsojXdey29xwGk6YjQSXqng0VDOKQZ44nB5xBW07rm+3hGiMw5EQItvNhmmaGI4jjrO72vB4P4InrrZbEKHrN2x3V2Rz3r5+S4yR7dUVbd8xDBOHxwPX25a27RlOJ077PRHhy5+8Ytc3DMMDd7cbgmqxBU6y5ArGrqFhy35/YEpGCGX8csp0XYuIk0dHcibliU2EQYVk5RogJ4YJokppkrZMOmXMha6L7A9HRGHTb5imsVjAOsTYsR/Geo2PxNiTsxAbJWWh6+/QZoM2DUGM7AKx5XB8oO+2dP0NNo0cj3ucRNspXWp5ez9wGCemPLHtAl3XYOaMU2IYKNdBcA77E7ExJJzos5McDvtTyU6VFpFM30Vub69KvZhTWc0RAc/EtsSeaNPQ9Vv6qxu03ULsSg7rZaN1Jdd1/lFd8iVnorIQioaqoQpmM8lYtne5FlKdXVGZVcZUW9YziTivl82fURSbRs7FB2xeS1NVNGnJqhTIUrYNhrgtZKhKQJnVlMrzNRyfG+orOVpu9cJemhuuXte5ziTm3BRRcNl4DdQGgxUrVqxYsWLFih/Cn0xUagmeQFxI+cTj/QdsSnS3LY1As/2Ew8M7mu0LYhtICsEC26/+Ffs//A2aTzSvfgFWKSJzZruLhR2pk6BlYlaLC1dZrCQLkVSIjvHt70hvf03oA42GczfXJXk0f97lwcjzPMozEVd246y3u3jLxaTtqYbuTPrMHW9+cSzzJi6IqpmgqcdccglBPaLTntBsuH55x9u26qzVAAAgAElEQVQ//D3p+IG2f4X7iXx6T3/1eenGPN7TRYXQl+5RCSyZiMu+6MXxXnTH/YBibE4X0Jo1+dSq9SJHcCHhLtR2dciXbEXOJN3zz7lUWP4QZoWmWcJT5t3rN6TJyumcMyrlPNYAKoaO72hpmeSaiytl4WoXNWslGmfKeX6Nn3cdmYlO97oAoBc2S5fWtbV4qMpQW455pkDPn38+4WeC+rn967LAUPd/vgrFFWluyt/Tt1jzCogE2zP9v+y9WZMlyXXn9zvH3SPulplV1QsaDYAkyOHQAJI2kkYmaUzSkx7HTJ9HH0HfYz6DXvQ6T9pGy8yQ0pAgNjYaXd1dlZV5l1jc/ejBPeJGZhVIM8BMIxvG3yyzbt0lboRHRJof/y9HbnDZg4ugHte9IbLBbT8i5Yi6pig5PzDm0/lc0qQiU/DTdZ9n4nJxqz69jmzhAp3KlufSg0IiXg/06XU0j1uuhc+CzC3vjmQTkikPj2e8XBjSx9yf3dw/FTK5/q347NZ4+6hEVYIXxhTBPGYRRfnquOXTm55Wz7y5bMhqiGWmjj7T+Fglow0pZGnKJO9oXf/+gK5YsWLFihUrVqz4B49h7EkxkdNEVBo5KS4D3lfXnhCagCZHStDHiAwD6lvUFcFlShHGodYeHnMlprKQHVprvMmxNEn+KkGaIhDROscVDCfU+XjGciKnVB2MGcu1h14q9U62XNpCKIj3BLaIKt4H4hgRAd8E2maDimfs+5kYNCCJQ1RxvsGH0s8PVcQcvr5WBLYTaULZjyo2FUqLD1TmvnoT4VGInOI2LeVJdact1gIMA1ciTBHBuYADxjGRJYMoIXiSjYxjRxMaXty+oB8ujMORnC4Mw5mcUnHJ5USzvaXd7hljJOeBTbvDZUiUSNPz6VR4VRW2QWheHLBUCGIzCCbElHl4eIeRuHtxAJQvf/4Fw9hxd3fD0PfkONBdLoTgabYelzIqjmazJcfi/Bu7jqG/sGk8KUfGmPEukLIw9gPiwXtl2zaYKOeuoxtyIcUJeKc4K4Rv6ala61yF7a7BknHpB2LObPcbVFqOxzO3d6G6fpU0Gsfzkd12U1yTqfSIfLxcuNlv2d2+ImtDylr6nDpFcBgbmo0wjhdC+zHnYwcM9N2ZrhtLH05fznUyx6Uv1yaWCJsNUh2BZCEmcN7z8O7C+ZIITcBSifMNTrjdNYRNKLG+KeOdEMfSBzamkZwN7wO7wwHfHqAJ4AKGVs3wlLRlVbS+ED6LLsjzKaGojM0kHsiZ+n+wSRq7WCcpccRWHJqiiE7bvZKVuYp8J6IypbToVVu2k/PVoZmY6vQqRrCyliIzWanlP5V4fd4GqNxD0zoH88JONpvvreVaR6qP5/WEXEXXIiW96olAe8WKFStWrFix4orf3lE58RQCqb/QNFtefvYp37z+NU6FsL2h/+ZX3ASPaIPLxc2FZfbf/3P6r/9v+OqnNN/5fSwVpeTUdFyo/QehugIpkyAn82ROxWMkwLh8+7fkb/+C9sV3ufnD/4r7b39ZJoi1r9+SMKvztxnXWFlZPvn0tXrAE4k68yoizz5aU/cnommxvUJW5VpAPlWRyXI7ZvXYDZNIxvC+JWfj8NEnpMs7LumC5BG//4S+e0s+f4OlHm32kO9Lc/c6hVZ54oOre7l47rmibeF2nOiepWmw7Gud+OrVRfkU9t7j5/0Hry6634zpM4qhztjtPT/43itu9m0h7FBE3ExwL5vOTw5E7xQoxbji5mtmPu1MY33dbasvzKRzfeccv7pQCU7Rp0uoURyfi5GcCporFfj0Q0JVcgpXQr6Ojy4YQauEczJFm1fkfKIZ35LEI9oiznBcUBsZ+keclgigpj2QU4/qgVSVsc/PwZUwv16D0zE8IVHzM8J+IvSfxL4sXKBM5O/ySrx+1xNT6vQd0zafLbVcv7T8jMno+4HzqSFuFQVyTrOYQU0Ri9zuPT/9ZixKWhfIsZt715bIZuOrR+XlYct3b3p+/dgAnkws141Ri7yyN2qGiZI0k7Jyu30e57tixYoVK1asWLFiBeQ8kmIixkKklZYSE0lU3FOIQ4Kn8aUIMVWc95gqjfe4EHDeI0DKCRvLlNzV9JhSb17dg1Mc7LKlQ2EMp3l7JUJccV1RxbNSCZCUIilHLFexa4lQQbJDrRyF5TKN9lKIH5FCmuShx3IsnjIFUQcEIkIcSz/MTduiUmhVFV/6AmqpPGJKVSBaag6j9AoEUHGQKwG0SITJUwsVqeRJradEax8+tERfGrXnZkbVEYInk8pYOo9HIGUulyNoZrc/4ILRtgFhTzJDxdXtO7IZQs/xeOTh/lu6y5mbmxs2G4cD4tDTpX6O8BWM7jIQx8Tj2zeEEGg3W7xTukvHOCb2hx2vNjcokTyOOBX2u4YUI8FvkMbhnSOknuiKMzKNF/a7TSGPacjnC93lRBw7QGm94KT08IxmBDWSlD6MPiiWI4/nAVXPdiN4FeJgXDQTNr4mFEW2hx3et/R9jw+evu9pgmI24v2GrWtIOZHMMV4GclLGIdGHgTYbaRzwKeEbZRgS7W5DTuC8ktNATEMhX1NmjBnLFDctI2KCmHA6XUix4XC7x5xDndL3A00QtpuW7W5HykY/Dtxs9+z3jhgT5z7SdSPdMTKOEbHMMPQoShxHUsq4EGj3Oza7HRoCpq6uMZR6UStBKeRyA6YEvrpQqURlJRopz5TrlKJizurLFW02i9NlIQsu6xg2k/biCildtl2qY2WKfc3z/V3u4bIbKvWeniAZYllImNaxVOo+zk5NmxfKpqWzyRiAVHFDnsTr08pGNS5ATVlarIVZcXhOa0uzyP3Z0tOKFStWrFixYsUSv72jsrIxTqE7viXFgbuPPufLX/4NOx84v/0FIWeClTgVk6KATOJwKbP7+M9I735K9+Vf0H7+Z1iemB/m4srqZKtMeIxkBqKoGDmNXN58wfDV/85m/5LDD/9rrNmRLZFiRneeEsXB7KCcYimeEItPBGM2P2eL99e3UuueJ6Tb8rHVKNiZYLoeEjPR+YyUqZueyajrN9ad6DvG8xvSeCxKwO0rLt/+BG0PyHjGxON2B3h8jZy/RcMWV1nkKXZWJrLWjJyZJ7TTUU57uaCUZhKzTDyv42SW6nFPx/t8DN4nJj9ESC6dlX8XaucSMGUYQbWpxUIp8EWs9n6ox6m5xChtdsSxZ4ogvZ6HK2k2TfKX7tmJeCy7Nx/0laSkBpvW4Zsm3NM2Z7fpJI5cEKDzBuo1OY9V/Q41rs5O47qNZ5sRyShGUiNIQ9AOP3zDGFtM72AcSCpsdsJ4esDpLQkPlkg+I3nqW3oloZ/sYi0uJsJwJuTnnyvd+mQj1xErBddy5+e3Xa+5idjMNrkmbWJFy7Vni++YlBHz+XCYZZrG89GLW46xJ+d3HG1Dlgax0jvU5ZGXd3DqICZoRdEQIGYmy+rVIyq8eTBuN8rnL3pev/UkhJFEKevL/ZTnx4ldcHz3JtG4lahc8f8P/Pzh/TjtFStWrFixYsW/P4hJcVLmTCKBOJTSwiQZOHOFrKO0snBeUedBPd75BeEIpcVknsW4TkpNVL6ozONFBdHSakHEoa7Mv1MqzTAqU1lrKcG7mtuShZy1ztcd5Y21voW6rUqsWiF1NLZQHZvD5cSlO0MeUTF8jcL03iPEMo9Wh1mktxGzDZZGYhzLtpxjmpsXR5nUGEwtRK4IIgGTyd1W3Fmp9r0U8biaKlT2u/YATLl83gnO+Rp7W0hV7689+kpp4kENzSOnd2/puzNNG9i0AbHqwvOOmDou53f0lxPEiMXIYdvy6u4Fu9uPaXZbHt69Ybh/S+wvmBjtptQoshF0p6RLRz/0xMEIux3BORrf1GTbhNMN7f6O/e0t59MDcbyQUyLFBGL4tsEn4TR0iBo+eBAlZSOboK4h6YANGUkJST3ZSpsUISGS6YeREA4McazhuZnRlGGIDP3IHoe9u4CAD8pGmBNvtocdrgmknHAKiBJcuRBjyiQzDrc7WkDUuJwvbPZ74jCSZSCa0FgR9KZYCMo0dAQvdJZpfIPYMEei5hjZbTbc3W14+WLPbrfldBkZhohzjmbTgnM0rSLiyRej60Z2O486h9MIaQCDZltqz1Gs3HMWcI2yvblhf9gTmpYsWlYSaruh0kcyAQ6zxOQlJJfWNCV5J83rCKJaReMyr6c4Ke+bnYpYaWNTxbvFUZmrs1HL2kYlKiex+OSmnEhDEXddU/Fc7xtq7Z6KaDvnWNYATFGqsHghZhCZ1uGqQ3uBeW1MasbQpPKuf0tm1fcsHriucUxpU0Z+T+C9YsW/T/z8IfMH/93/8Pe+72f//T///2BvVqxYsWIF/E7Rr0KSjKJ0D18XhxZG7Huau5dsP/p9Hu//N05vvyC8+A6NB3KcG42bZNyL77M5/prhF/+a9vMfY1Pz8YXxSiqhkhGcCDFnLm9+zvj63yIGL374z3CHT7EqIiOPYMOsDJsoFpWn8Z7vfVHF1WA56VCZSazp+aefrr/FZtWZLN6XzUoxV+vHiaiZlK1CIWzKfHZS09VprxmhbWgOrxi7Buk7GB7YfvxHdPd/Rd8nbl7+kKyOoJ4oLSG9JasUNSiuTAhnwndyl9riCJbHO5FGV8r0SiTK/L73I0qfbmfZ63BS+j0hBJ+9f9rGhyJo55gSIs4Zzk0RwQrimd2ddZKtEnCuFBAitzWCVMv5YVL8XU/9E9J5PqkLGeHi+SVpVlTIy3PKxFaW05incmIR7SuLxwsso4OXV6OKkGsxuGQqxRxeH2hHZVAlxpHoPmXsHnDxNWGzZ+sCZ9tC3LMPHV0q23F2R9GCPt2PyXn7hGS163UyXdfT4D0/ivfOYx2w6TpmpuCv51+eDJsxKTJFZFZBX7df3nkdqXJdZwMJgdvNntdd5sYnVI48DIFIg+L53svMT77KeIRosFUPuUNyYj5ZVqQCaolTp6QY+O6rgV+9E3wyzNyC+M84oHEjd5tERJG0e++8rlixYsWKFStWrFjhNWN+aq0YcLiaPAI5CWpgVuI6zQwNDh9afFMSSooDc6oZHPiAOq013hTXWLY3x0fK1DeuONKmOjXniBGnwhkhlrpPM85VWtIpmsFFJac0S1sVAbW5dhGgyYk4DFyOj1gqvSzj2KGWiap4JxA8TgsRObmtQMgGubrQzBTB47yrhE2pHFSszNfVF2emlPpCpdStVomecty+kMIUt6RzAaTG2ObSj9CkOEmdujkZSLNeC0Q1LEa8F7wPOF9I5ZRAzchpYKhtSJwEGr9FvNEAooUw6vsTw+UB4ohIZrffEnwRW5/eHbGU6foOlUQbPOohDRfi0CHOIxpKD8fGkceB+29eF/ebGcEpu92Gpm2wOHI5Gtkc25sXpWdoTHTnE7EbUa/c7m94uDzSdz0hgPdw6TrGfgSDm/2u1NaqhKYQYpYjm0bZtA2+UTR4mhAQg8tpZLPp2Ww3xCyMXcIsstu3mArmDEtG0+wYhhFM2ARliAlLkaCQYk+zv8OJZxg6JPb0p3vG4YHgjEt/IcWeFDuCD8RkIIndVtjuG4IPWIKhH3BkdltHNqEJnjFn+q4n58gYI13qqwC3kIHb3QY1Q0UYU0bFI+rZHnalJ+V+jw9NiRg2Ieci9M5mmJY1CTMlZ0Wzx7LHzJFzQlO5l4rYXmf1s87rMNe1kEnsPK8HzWtQCqRy36vjmgz2bBWrCtChrLe46d5iEhVDiZhVDFfvdUfOZR2jlNZW7g8SZm7WJVwTk8p9XpKi6j4v1wds+rskk+F6rvNNPrC+cdU/r1ixYsWKFStWfBC/Q/SrVZ2V0Z/eItoQL+8gjzT7Pf3lgeb2cw4fvSLf/zVn/5LD3WeAkiWiJhgeDr9H4xu6L/8v2u/+KU4bkKJ61Cnz3rnSF+Gbn9I//BzXjxw++RG7T/6AXKMyTCvBIYqliHNFsThHx4pciZEPzJCuEbDln4kyLP9WP90zYmqefFUSRZ+RXtPnmSaik0utvppnB+f03VMPjjK2KSV80yLqSDGCdcj2BmeOl5//55yOX9J3I4ebz8g3vyZHJQ0dIkLWEWXq9fHkxL1HJs4TZrnGmy4/IotJJ3V71xjPDxOMz8d1Ob5PCdD3Sa7yeCpgc21Q3+K0RfBFIVn3S11xVJIn1a2RsxFjQtQVhWLtL5kpBJPAfF0UQu7peaUqasWm6mHSO9YJuk7dCqfxXFDe0/5LLmSlSNXzWuU+p46N15iUckUsVIlPT9e8g1IJcSSTuGXwe8gd+DuiOXzIDLInjUKQC/0oyP4TxvQW33yCXL4gm2fZa3X+EqP2Y7QrqT3t36yYXI7P8+tkQeNaJRDnc52faQKuFP/0fj5IZC+uESsFzzQeZpkskHE8Hnu+GQ/ctT3fnBuMDXehp3EnLtHRNjdcLhFEyFKiksTKYlGcI2YzkhO5StVPY2Z8K/zeR8av743TkCh/ZDIbVbwcab2QvePrdxtu3IkVK1asWLFixYoVK54jNA7vhTgmkgmWhHFMJCvuOCdCCIoTSDljUckplz5zbYns1FDn4tUtKLPwVWvaR3VS1Z5zc6KOlH6KMhukirsrW4l1Nco8vaQbCU4cTgQUsi91Vamjah2US12jIkgybOhBIiF4dNsiNjKokdJYyEERopV9VnX4oLjgcE3A+abEslbisBCDfo6/hFrfU+upnIGhkCO5jIKoAlr6XdY+l3kiS5DisvSFiIypwywT4wAqONdgJsSYiutTBCSTFfr+UlyhlshDEVp7pwzDiXG8QIqoBrxv8V6JseN8/5ah6zAxfGgITcumbRGBMUZ8COwPxtCfQB1OA977cjwjJAmMUTgeH2kaiFvHrm3xraPrRpw4wuGAmRIjpDExjhHnFKfVseY9YdNgsWfoe+KQCEohzFRJKTMOiTwkYgZxCe8bHs8J1YCIw6uQzIjDiGt3nPvMpevw1TUYzrn0lxSl63p2m8Dx4cT+9lCrN093HlCvDMOIZc+YEs47Yu6weIbjA5vdHa5tJsMicexJ+VzWX7LRbJoStZuUu7sbnIbCcedIjOBDwCwSXFs8gBoJIpwvA5dLRL3j9naHOsPINKEFIMYS82ooLihNuyFstmx3B3yzKWlNlGu/ZB/XvrKWq7A3QlYsjaCOnKrgW7TU0aq1Fy3UeK+yFkUlIqd1q/mOXBJ4V6fk0l05FdKTuNcW90dJl5reN62tGDkLzmldddCSZlR7TZbjsiclfvWHXv2UVXS86KI0JyBN6x7X8CVhdnzOW1uuu1XX9gdE2ytWrFixYsWKFRN+e6JyioGxSHe6Z+uU0/2vEE1snHD+9V+ACZfxW7YffR/Ov+TLr/+aj77/H+N3mxIvKQp5xO0+oXEt/Rf/J9vP/imu0aLswhNtoPvqZ7jLtwzjSLv/nP0f/BB8U4mtUjYVQipBTsQckRAqcVknde8RdrUnoC0dbROhWB5P/TCnj82TycWE67m7bIq1mMNc5UqULroNzsTnE/K0qtXK5BxSOrFpm1LUnl/jwgHX3qCyJerI7vZ7dO5LHr/+OZIFf/iM+M0bDCWIlsiXJyQjc7THErPy7QnZ+Ixg5DoZXvBVi8eLyFtVfhNxudyPv+s5WUzmp/McgpJTnCNDp/GU+bMTcWqEIAy5qgcVJC1bvF+7hC6ny0+OtV4b0zyeGj9kC3XhfM1ME/S5KK7P15O95Ofma02E5QhM+/HetWbXvohMr2sh2Fwuzw8pE2wgt3dYSmAnTn3EeIM7fA9LiuQRDQ1xIkjn0eI6hoBWt+WSnJ7LqCdu2uWO1vtgigJGy1gxLaTUa/4J2b0gZut1ZPOAL56zSpzOg5Wv25juT8uQI193DR9vznzVBd6MLTZu+EcvIu/u37F1wjk2gBBCg/GOnT4StCGZx6Iw1vvRzCGWiVn4xdfGDz7OvDtl3pzhB6+Uw87zxVeGti2v7xvMEuc1bXPFihUrVqxYsWLFB5BSruLRUvvmVNiBnBIWM1FKvKN6V4SDyRi6jhhzjWJ1tOqgDQRfnYM6M49zfee9LzVGJe10bvt47YmXqf31KuFx3co0369kS+21VyblSpJcXZlFGFzmzLkQngmMSE4jFnNxLloufeMt17n6JH6kFh1lgp9zJVOttH1R52qLhbpX2ciWKlEZIeUqpKwuUnEgHtyVnKSawxIGKRWRIpTxMcNUiXkk24jXgCVjGAd8cGgu+ytSBLNDP2IWyTmSYyalHqeG98rp9I4cI04NpxlyTxMEQbl0J2JX9s+JI2Y4xlhjcIUxCpGRELacjh3d+UIcMw/3R4ZhZH/bop+8YrO54dIlTo8nNpvislQ64tCTYsQ5z3a/53x8x/ndO5wovmnYbHfsD7ecjydO9gh4un6kuww4dTQbICb6ocS/ZlOGZKjCuRtwzoMpTTRElaZp2O02iJbC93g58fLjV3g1umiMXSJsxvpeD0TEO8ZsjEMixoEX2xecjmfCxpNTIeO37hVmypgc4DmfepwoMStq0HcnYkqMKWIkxphpdqHWjEbjPZfzQELZSEO73eBTJF2Gmfh23pHMaDcbYk6MltlsdqXFpCmhaWm3e1yzQZ0vdXAu96yKzdyeTKxeTqCpXhcjUlq8FmduErIUUk7Nz+Jr1EBLL1mVqdWQzGse5T4uN8eV+OPJ4/memPan3vc5Z1SnNZqJ0JT6nKCmWNYa9VwJySoUzoCz62emvwEiNRxWFFfXO5hIS661vdXjKKtftUGKTGsYdZ8WazwrUblixYoVK1as+LvwWxOVE6mTxgtjd+TlqztyPONM2Xz6jxiOb2nuvsPtzSeE3Q02jujhHfn0V3z782/Y3H6KDztCuyGGHa7dsvv8x3Rf/q80H/8pOMf5/qcwvsFkQ8Tz4vf+BO9fkF0q06FldL5RGpqTsJxrVMZEXM2+xvlX0WZOqtSJaILSqLxsUp+wTOUZuBIuytN41Ov3zRt7MvGUbNf4/kpIzmrRehBTE3JUyWNPwpG++UssDWw++hPM1V6GUpR67f4zhNccf/mXbD/5ERYMFwCT0vuEXNV4PHOrXc/h8vUlnvRcfEYsLp2SH4p+nR2aS7dknTxfJ6jvf67q/56Qiq46PYe+AysT8eIaLQpa5xxY6YEiCo33bBrHMEhp+l6LaleL7dkL+Yx0e3b012ObOUebf099HywvFMYseqFOiwLTdhfxsFP6rnCNUnlvPOpHpGY92eJaDDWuycmJYTRUHdnfYbXYTn6P7wUNt0g81kWRQmbGGtHsuJ6XiYBcUqXXsZnGquzVFMV77dn5ATetZDBZHNd1ZOaDyNdzMJH0JWtmKpKMiXS+jvr7MFEOh5YwCOc+8m5s+LTt+Obcgirf+WTL//ITx8YN/OHhyKuN8Kt7wamjN0+OQis9EowbLbG9pbetY8hCisqX7+DVLvFdO3K87Hg4npD2hrf3kDUjZoz5d9B8rFixYsWKFStWrPgPFmnMTK0QircrYVbqWR+kzJun4mdyW0Vj6HpSKiVurvGnwbd45wihQV0hYVRrCwOpRIgqk5tpFq3mXIjCXObuOReiNMcRy7H8WAIp/S/NSp1T+lAI0RJmhoojATlF0jhWIrJEsVqOpX9mKnkyVCGpiOI0zL031XucKs55fHD40OBCU0hK5xY99iZ3ZIYUC7GbUyEscyESczZA6xjU/Zar0HGKh52KcBVFXXWUWjkbEgSXIdfjFwR1AcwRh57j8YFxuOC90jYNU0304u6AExi7CzkPtXYT2nbLLsM4jPNY0XccDltUPGMc8T7ifYOScDIQY+Td45nHS8djN/Kr48Av7yOtf81nHx14ebNDpeV0GhHLbIKnbYoTNXYdLmdevnpFCA193zN2PbHvwIx2s+dyPlUiKZOGER880gS6oSOh9GMmizKmRN8nDoeGw3ZLcMWZ60UYu5GsiZvDnrb1jOPIptlyIdLcBNzGMwwjQZTdYU8/jgxDIuXEZtOWKFgc4jyX7kTKxpAizeaGLIHzYMSsiG/Rds94PjOOpd1LjJnjeSykuPa0mwbXtmzbBpHIZTTikEBHLFPcnylzOfdstltEPTmVmnbqD+ucx6mn2exomk0556IL0bGV66ES80oqgnSTcq2ksboor5LfTGm+gwH+SnCqeKY+lchEUC6Tteo/s1h7STzKUh0+C4UnYXFZc5nclzKLxp0r60UK5LkNjs1rE5aXiUYsBA3lvlGp6101ScsqWTnzlvAkGalou20+zrLMUP/PtPtPe1+uWLFixYoVK1Ys8TutrhuZrjtiaeCjFzt+8foBp0bfX+iPjzi/5zEbHN9VNWeGfIO0He/e/Jpmd4s9OPLwDRYHtps9WOb+i3+B96+4+e6PuFyMm09f0X70AzAtkywLGAmZiLhKdGSUNEQsZdS1XINiFKlZ/9OkczaEGVMaB5MerCgol+TjRBxV21SdYJbegVeSqrx/+jUP0vW/E4E5MaaL75B5wimQS4E4dPfw+BW7z/8J1j+SXTli0zz3SEyWCa4tRd3wgA8vkRxKYUd6QqROk+LlcT0nL6fXluTkh8jI6bMf+tyH3iPzYU/9DBafnfZhQQouHX3TZFrEMFGyUSJcRWaSdWoAr1Im1WIRnzPRwrSFK2F45ZFZnLon5OhEUFLbS2Su4zSRlNM2tM7Wn1NppTepFaLVZP5qqhpT6hU87dCTMZPrbtr8WnlyyIKzM10K0L5E1ZOL7ROzkaDgHQwiqL8lpF8yZui6EwTBURXG72EiB6exf59AnQqUOYWVp2T2TFLXY5jvo8XvQkhPpP00FjUe15jFAzPZ/4GxnfYlZUXVaIKiZ0dP5qg7XmyORLdHXeBVc+TTO/j1uw2/ODlecCmx0nEkagvZQ+rpFVQSTkZURvY+0+4Sh6CYb+hCZCsPSLghW+DQGo9DURBfxg8TqStWrFixYsWKFSv+YSPFVDR6VnsuxuIuDOoRp4U80YlYdGVh30NQR9hsaQ97wvaGdnuDNHGsTb0AACAASURBVC25RnOSM0QwLXPpsXROB8BUUCb3Vq07c64uyFTcjimS41iJv0JYZpl6uBfJYU5GzplURafJSjxtTgnJ5TUsk7FKXkZSGou7MkVSTHOPSJPaO1IUkSo+9Q2+aXHtjtC0iPOo89UNF4oz1BVnXPAN3geaVnEuIF4R50p8rPdV92hgGUv1e4lXUjaXfbJcewlaKssTeWrhUuqSGCNaKEZy7mmbQAiBzab0mkyxR135nu5yxte43ZihbbaMY+J8OuOc4oOjbVuapmXoB87ne9qmZbfdM46Ry+XEdrel2d7iwz0pZk7dwOnU8/W7jpvDjsNuz7ZJpHRmv99iOdM9PkAaQIym8TRNiew9HU8cHx7IydjuSmystg4JwuV4woeGobtw6Xtce8A1Qjx1bHcbjqNxOg3sdzccdp5NE+i7HvWgLnNzc6DvO8YcYRTOfc9hr/jqWhT1+EbBe6I57h9OOL9hf7jB1BgtE1ygaQ8kLvTjCVeYecah4/HxHu8ym9CSUUxbwobSz9NALJMsMQ5FmDwMHfuDY38TaBKl7Umj2JDZ7ltyLtf6MI7EPNKnEpMbvCs9P1Xx7YamaXFOi+uxxruWmyhTWsjUeGRKBGx5Schi5KyQiwuZpLPbsQiNwVxZt6DGw5b0IjAtIut5DWAW7k6X4XKx4gPrDHD9zCwIp7bGLOSyVNGvSKnNS/RrxnKeHdY2O7PtumAzP5zWAxayYSsrZizWaqZQVzGwOaX2ycrKlVC16/MrVqxYsWLFihXP8Ts4KhUM+ss9+10L3vFw/8DBezTdk7p7JL5gI1u0dbj2ltC2OL8h8T3EKfHdF5wfLtz9/o9JGI/f/JIwnnhxt+Grr75k7E/cfvYD0tDRf/mXJIMmBGh2aLiB0OLCDmrkhYgy9BdSynjfzG4wnjj0bFavPSdX5nfYMtqzHm85aCaX3DT/mtxgZsxxlxMpU+Z5E5E5Te+WfSCrpm0586wEj4oQhzO2/YTQHugt4bUqRm1Sz0G63Jcirb0lm9EP7zhMTQWq4m7phrRJXjp9F09Jxd9ETn74GpiI3sVEdPG5J30M57fkp0ThkuBdjpoVJ+zsTlVh0zbsb/dF6ShS+kBWtR9VMVzclmVC7F0mJSv9EqcJdaXEpmGYFYTz+Fy5S7OnfSiLLPf6rvk6gBpxshwbmeNQsDxfAYtDnh/a4qXpvJpdX1yOiQl4DJfO6OYPy5Wdy/2YrXSpcfHEILdofsDklugOiG7g9AVG6cM49cqcFy7q/i0Vx9dBqWM27fj89gWheK1c5uvfcq7n9bq9PK3SVKa3OEYX98Nz4vw3kJTz+1HGoS9SBBkxM7rB4XXH79+8wc73vGgiX33rESd8GspnvFN2rud2F+lHYZCWMYOaI2bPJSrd2PMiJ3JuscvIwI5z7/nsY+HL+4HGe+62mf1HG3bNSlSuWLFixYoVK1aseB9dTGU2nBJeS8sSVcEHneMZfdPgmpbgPT40mGsxdZjBMES6x0eOb+5JllEf2B9u2e0ObLc7mhBwNe4V6sw7G5BBS3yjCqCCmFY2oVY0UiIrLSs5lb57xjXlJ1LjYmvNkFIhKZWSUGLOkXMqxKUUZ2M2h6VEynold6zY2VIcyzEoiDoklm9oRRjSUJ4TR/QBnENQ1DmclshbRFDvCC6AOkRdcZKq4urz4hR15XOqpT70vkVdg4pDat9OzIoDNMfCM+WROHaMgyennpx6Wjw5CHEcGPsH+suApUjjHcIAFulypvEtko3j/QMpGaHdlihZjXjnyAm8c7S3L0B9IcgA1wRII2M3IDpwc3A04Y5N2/H67ZnufOJvvxggv+J7n31MtljckNqSxyJe7s49xEzjG9Qp+5sd2YQcR4ZLh4jiXcCHhvPlhA8te+/ox5GxH0hDJBMxt8F5xXmhT8bjuxO73a4IYBPkrKToSWZk9WQcXRa07zm4DcMQiSkSY6aTxHnMfPTiFtc2jENPTIZ4Rx9TIahdIGVPP1xI/RHvCrl2Op3LFdhsOZ3OBHHc7neoCQ/HC5aNFBMpKefzhRcfv2KzC/jzwGUc8eoJrqHrB8yUFDPJMt4ammaDCw4VB9oUwnvRA9IJleA2qGS1zb0pa5sTA5NSs+c4kMm43GApIzlh3lA1XCUFs+Xy2AKqNQ2qooiuly1hntXh9U4tzsTnYuLrOouqFMKdclPn+hldLPvMTuoqNJh63V63W/UMGK5uuBx3XfuopOgcHftkl6vQ2q5/f0SXUuWywjKtdaxYsWLFihUrVnwIvzVRaWaoc3SPb/jxj37IL371DQwDzcuX7H/wn3G2f8fNZz9gt3tBHE7k4YHueCZZRKVBXIM0geaw42/+9f/Ixrd88vt/zngeeEy3fPef/DOOr39CjMr+O39MQthixNRB6rHLA+k00McOsxEQxB2w1NUomV2NjayNw+f416sb7kOxpksH5XJqNT2a+aP6+ZmULBLORc/Jp9ubH88MFNUgtyQRy29DcAJpyHz6e3/E49tf0YYNaiWW1qTEup5P3+C9p2lecIwDaTzSX3p2CE4FyUWt+nQfjOXM8kMuyCVmgnY+79Oelp9rLInNgyPzQC1kgViNEJlpwPrSNUR08YXIYvQNgWxs25bPv//92hujbl50fnch2TKmRnYN49BgrioLs1TC8v0QUamE7nwYC8ftTLrZcv+u5+p6+urM3J4xawtS+PlYPyVyn4+9vf+/er2UqNmAjSdcc0uuZKgTQcaOIQQ0dTA22HjEciDbANKAjYg25SozmHo+Pr/Wl8d8jezNlfDVQr5OxL0ZgjK5ROfAW7meY2pBM4sHljXYB8QC1+P+MAE4ReEmEWLMWDIURwa+czvwnT2Ief7Nz86c2OFyJNX7c+czoWm4DMp93LGlRzgRbceAx8S40TP7dgBt6YYecwfenst5ezwr/8kfO/6Pvx4YY8vx2PHYnT+4nytWrFixYsWKFSv+YaOQFCVaNKWMOI9vtmz3e3y7Q32Y3VU5RcYYSeeONCZizkQDnEfEIyakMXM5PRZnFGC2pWmaUgvUH79IgHlSngi1vyO1q4k9mZYDhXQsAbWlb2SN0cw5Fz+YK700iwO0/GQR0rwtIyUFLW7Fqd6T2emYyQLOC1jCxUz2CaeuuMGg9LSUQnZoLfym1Bmzss3JPSpmhSyNxpATEq+xmsVNNuUf1bpHFdHq8FJFmxKlK67Bh0C7f0FOsUS2pp48doz9mfu3rzk+vEEs4m5u8b4hmbDZtDgtUaiWOkSNTCSlTAgBy8IwxGKbbUrELepQHLv9K8bYs/NjrVWPNA1s9ntevDiQcuZw2HDYbpAUseQQgaAJv/N4F0B2pDhgkhBX1j28BMJux8VdOJ0upH4ghEDbthxPF0RhHBPqA4OVJouboMQhM1w6Ns0BdUqqMbuY8ni8kLJBUrLLeK/EMRG8Z7BAHoUmbLhcTmARM8U5wWzEOcM5jzrHMFwwaTBzaBDEjOAcKXjIme48cD4NjDlx6np2jccnYxhHcoolhlU8Xh1eA+VSrlHBaSTmSLsJbDYN/ZAYY6pOyiJWFXHFTRkC4ly9Kabo4OKeJBtMTuBF+tMkaCeDEaduJpjWNQcr16dzhuVM8hmXM9kXknBJUuacy5hUMl3euxPLF13XX+p3TQsDs8i33hNUknV+neK6tsxMuNbesTlnqE7LzERkznzj9fPTdy4JzaprntYwroLs6wqa8lzEPf27spQrVqxYsWLFit+M395RiZJzRNOROET6PuEapWkbTt/8jNw/MLz7Cm8DVrs50hwQi4gI3emB7qvXtJK53W+5//pLfvKvfs3h5ae8+v4f8/j6J4gK3f3POH7512w/+R5IQjUUR6EaiEf9DRAxi4z5hOQzYhnxYGiddOYnpOA8nVoI0mbnly0evwetarZcp2HvE5wfolU+5Fj8u+JWzQqpJ7lDwpbty084vv45bntA2z1ixuX0FU3Y4NobxhjJJDwZk4apj+DkNOTJnuU6jVcyH96Hp/v9TLU3H/LkvlvE6L43ZAsV3zT1fqYCXBbHy96eE/mbyTgrBXCyTEqgvvadVEeySD25FEGix0umdcpZQa1ExVJjjDQn0rNjfkLPyfXcTIS0GqQnxza5Yq/O28l9uXTQQpmkL4/474rH/TCmlYWnJGL0twQisfs11rzCSwPpghGRdEDwZCdI7sgxk4Bmc8doEaxhIig/cNLmY//Qc8bz8ze9WJ+ftid5Hr+ZwJ1WS/6eY35+v3zovSoT0aqkbKgOfLLPfO8u8PrR89VZeHX7MYO+wWImyyuiSzgB9ZFW3zJIz85BHg2lo+GBYMImGMFvOXaB0CTu7vYE1+L0wq5tySL85G8zf/pHW15/M/Llt0I3hN94PCtWrFixYsWKFSv+4WK7bUo2ie6qc3KLuoBZpB86uDygVki5bEbMRrLS1w5VNJd2Cs47pGkQBIeiKTJeTkjO5BhxIRCcL1GcIeBEa8VWa0umuk2fCEuzFNelqEcRjBFqz0qn7uowMyNbrk6pQu6UMkVQV3oJZlEc4HMGK61aErVnZa5CRykRmbOuVQo56nyN2aQm4hi4+WiL01LVIa66IplSkq4SU6ESowaZBJbJFkubDIs1Chf81BEGgYsQncfMSCmR00jOIzGNbDceESHFkZubl9zc3jEOFyz1WO5pQ+DSDTwcH2gaj2DEoUTfhuAZxg1BC+lpk8MuJ7rLme1mg3hPjCPD6ULM4Dc7CIldCOz6LeMwcrjdE4LHO0F9Ytu2SC79Jvt+xCGFALycif3AGAecem7vbmm3Add4xiFy/+1b+qHDFIaonC7KiJQo4SQwRPa7LZdx5N3xhCFsUQ6hIeXM46VH/QYxpXvsub3d4w1yyoz9iCXldBnYti0qxqFxkDLv3j3gG8/di48wah/IHDke34FzbDcNsTtC6mm80rTFOXs89RjKkISuGxlirNdhIc6dFmKuu4wYDU2749X2wMPxzDiOlaQsZPREMqoGms0GwxWBgPN49cV5XOv5TLnOc12TsdoLtfRjLaLmPPV+zFZThGIhiVMm5YxqKk7gVJysmhPeNXjvK7noUS2kpZliprPI4PkazDKt6qm497qm9d4SC+V9ud63ljMpJ1IaSTnNhKvI9b3XfpdT1V82OAVKZRbrPlbTxBblfxER5MVx1KcX60fL/V6xYsWKFStWrHiO375HpSTEEvdffY3sjO3Nd7g8PPLRq0854Tm8+C7bFx/RvvwMRyaK0ACXrufh13+DF+WzH/2XXIaR41c/5fM/+zHt/gXD8Wv60fjosx+ivgUyj2/+Bns4c/OH/wS14ilTJ1heur6ERGJ8+Fkhz1xTvGdWFJiT+0tkMVlaqtNqlj9MBGRRhc1EiUwqzKtS7DlUr84wmwql3zR8H1CTTb0xFLAUQYtLTM1x8+r36PsHNI1I7mnCDvFbusevYbzg8UVpq6luJwBpPqYpsmOmUxfOShGdCURZSN+ekpZUzmzx3HR8ldyTZ597Qq3Zh7yMzFK7mdSa9m9S5YmBBUjfkiTy7v6Rjz49MIWk2GIirKIlMjdlsimOgTg8opvPSAKai2LwOflVvsmu18NEqhm1ebyW3VxMsmWSJk/X1RMKL183XLc7xarMx/r+SDwb9+nc1Ml/VQMX3i9j0hL9HidH6L7F3B4hQXuLSi6q0+4NPtzW4jOT/R7SgMjuycm5ft9Muz4Zm+tTtaAxWZDc9oGfxemVicRdRtZcv+fvixde7OWTx6nubzYjdx3/+Hs7vrlP/O294jXzH/3JHX/7uuOT24bz6UiyN/jmgCps3chx4xj6E3nzkhHPEPfctEeCbzieFfpH9jvhodvw7WuHMSDJYRpLf1VR/vZtxz/9kxug4//54ndq97tixYoVK1asWLHiP1AcPv4uORvjODIOHd3bt6Shw0lJ+XCqiFegCCxTFnI0oqXqfPSIBCAQtCW0DVpjYcUgxgETI1RBbbZMAMR7nGolFKoady6xKlmJIq5UL1Z77TlnZXumheCwkUJTJMwiFkt9lNHqxqpk0ORMc9WhiCAuYjKQxUGq5EeKSC4kk6oQh0hOpR+manG7qfOITzgXoQVfIzOt9t5Lk1MsCw6H+OKMEzzZ0hztCokcY62lMoiQcnGKiihNE5BQ+iR6VXxQBMXUk5InxYEYR7KlElfrPV73WGwZuyOPD/d0lxNxjJweTuQsjGNkGC68/OiOl9sX0LZIjlgc+fbtmYd3DwSnbFpDvcMHTzYljRHvFb/xGIm7lweasEW9EscBi5Fds6FxDpNMSiOqRne+kIaIaoM4z2FzoNltiWlk6AZUN+QodOfE6dTTDSP9UBJ6RI3v3O0ZEzxeOmKCYTRcE/DOkVCOneD9hq4fwA3cHnY47zl3I8fe4xRudh6VTEwD4pTtpuXcd4wxcz4OfPSdW/ooQGLoOkIINE0gG/gQyLEpEbApEWPCeWGzCbywG7JlRsmk2BKHQhpqvZZTzuUa9zVGyQTnlMulIyfDuwZUaTalj+dm09C0W7KUcz4R1xNxnm2qaAsBXuJSKetOUF6pZHrpX6kkS4j44rKUjMYEmsA5vEv4lHA+kFwhwqf+kOUefhoHq6qz6HwmKrkKo6GuI4ldy+Pp8SQQr8Rq6dFp1ck91p/Sn5YM6gEp3yNPF8iuq14TQblY11gaAKZFkiylF+fzNa7JDSpzqtZKUq5YsWLFihUrfjN+J0fl2J8Zu0d2n3yHd+6GPmZ48X2G4xF/+xL1DU4CpjCe3vHtr39Kq8bLz3+I0fD6V3/Bpjnw+Q//vPagEJrtLft05Nsv/i3b3WccPvmc3as/opMvePh3/zMv/vA/xZxQ6ozacXAilpLVxxnvGkSmQJhKFsnVQTf3KpwnTgsWaXGUM6kHM1t3pfsWsZmyULPxdKL3nPyZE2Dfo6umpucwpIgmYTh9TRqPZMu021uOr/8K5xRrNuThgmtafLsl5YH47he04aZOOCeSUuY9ECDP0jbqTtRj+sCccfnUlYiciM/33//0mK/bxp7SeM9Jp6ublPJeBamqxWDQugdu3BvGc8//9C//Jf/NP/9vaZp9IVilnJ+pn6WQaZ3jI/c1l8s9zm6w7uf45ruYOZIzJC+IsiVBiV0PbEkqPhkInpCrcykjS8Pgsm+DzYXF8qp42p/0CQuKSL5+fnLhCkw6RqcQqQpjt6dthTB+xWiCixdiUiR3BHoal+ku3+DDp4h4LJ6RcJU9lst1OnblSkVfz9XTvSvPzLSz2JPruRRsUx9YmHp51ENheT0+vYSm7Uzk5fML8um1M20lAn7fIruP+auf3IOVgl/Dhr/85YmcPCZ33OmZbx8TiVBij4aeS6/47YY4PLCRntN4x9grjVw47O94dwnY+JZgmaQ3JNegdahSFrLCv/o3D/zoH9/wX/y4ZcWKFStWrFixYsWK5+iOR4Z+YOi7El2JlThVk+JWlBILOTm0UsyMQyJmA/U4Z4SgSFPqCcURfFuqkJyru2nq41jqX8uRGA2rfRqF+n1Sk2GkiA/BIzmjTjGJZBTMla4pORJzxHLEUg8pQi4tF7Jo4QmtVADOFcejU4dzvvTFVIdLEaeu9DaMA3lUMo5kfalNY2S8dGWgVEAV0UJ0+ral2WyL2BHDLBYnKp6gvsZu6uzwFFGyJXLtKahSq2tR1AxcGZ+gcnXQqeCcJ4QSS2pmeCe1tk8MfV/iM4HgHTlHuvOJrKBuQ7O9wYUGSwPn44n+MtJdIojj3GXs/kR/ecP53DMMmcfHM4+nR5KNvLrd8eknd7y4ObDf70h9Io2RXbsnEwkOJA90l8QmtMScOT++owOGri+9Pl0AgbBtOOxvq0M140JLkw09n8kxkd3A/mZDH0eGi3HsRlwwGhU0RSxBysb9+YKpww0Z8Z7Hc8fh4NmqMJjDIsipuEX7lLh0HYdty9glmgDbfcswRMZBOF/O7HZbnAtk8/RRCE3DMHQMYy7nsd2QsscIdJ0RvCJaXKoWx8qUZYZxBBVC48An9oeG7a5FG4d6UM24piElcNERGscYB+I4kFHCNuB9QxNanPMIrq4/FFfwFGtqU9xrhmRGylO1f03UsqlmlVL75lydy2aUFCeHSQQXSD4TU8T7iAXDLIEUwtK5UElXrT1b6/1bxdeqco0+hqvbUarwV+p+WSFIy9+CsoZSImzL2KVs5SclYhrJqSZsmcfy++J6sUV0qxkmVy/2skr/f9l7syZJkuxK77u6mJm7x5IZmZW19lLdDQKD4QzBIUUo5NM88H9w+Ms480/4QhGOgCBIUATTALrRC7qrKiu3WHwzM9V7+aBq5h5Z2QClhzKQEdiRigpPD3MzVTU1F7167j1HpSTaz0Y8E4k5e35W+WaZ2l9235x7P85fsGDBggULFiwo+L2JShWh7x8wNZqLFxzf7GgFmtUT7PaWlo7Yrjnu3/Hu658TQuTjz3+Mth1vv/o52h958cUf0zQtEOYAxIlD3DUf/eBPONz+ije/+HOuPvkDrm6+x0MIvPzZn/LRT/4VLsSSCamALxmZeCOlAc+J9HJSMyaZfCgKcTYZCnynsnEmok60kkws5/T3c9KxnGQ++oPVmu8RlifCxiaqiBot4szXrLctoWuIqw2mA9470uEtT178kN3tNxzu37K5foGLTcke7FY07YZhdwfqsDAtQE+yHY+6ae/5CT4agLMmUda470vTnoat5Ns9Iubq4l2mYT7L+Duv2IQTL3g6r6KVhL5Zwb/4dCDnHftdRDfX/Ov/8b/n6nJTA4OyOPbiSGfVgIZhkZptnFk33xJiYptXbPVTJop5JuTsbIQmInuSWHl0Q6dFuJv9HQWrZGnprNSgoXhc2BzMnM8Jm9Kfzwfg0fifqPSJs5vu4zTfNuzQnMjiaUNC/VPS9pZhuKdrA01ckUYhtBeEdADbMqSh3orpGqcZINOo1GelxDaP56+dzdkpIXsaOA8Ybr4v06x73Dt573wfwkRwTsNzmr/fof/F4SjZq23bkrPhfMMPPobffJPJebq3wn1e0/Gag14x5oagjuNxxwt7wxgCR3mOZOUy3BNWK95tY5HICjc4NZw9EMctozSM7gpximgm4fgPP9vx/c9XH+zNggULFixYsGDBgn/a2O4PjGMipwwGwTuCj3gplXMpJ8Y8IpLICsOopDEzZkN8JjaOENtCCniPVaItujCrjHjni9Skc+W1K9dWVU6qQtWrcaqupMiqikglO3zxOaze81kNyxk0QR6KdKtNJOspZdcZxc/PAVPyqICKJziP95HkR5LzJHGIFL9Gy6kQuMMRTbkEjs7jY0C6VCxEnEfxJdYzR9N1CIGEoCQcRjKBdKbU4lwheaT4EfrQFPIlCEUFNJM1oTljauRDz7g/ghQytI0O70o8GnwZqjGN9MdETgd03JHGI5YG6AfS4cixP3DcD/THsp9xeX3F04+eFfL00mMpcn97T9rveTscePsw0g+J1cUFzvds7x9om8DN82e4tiXGDTFGYog8XV2SUiKNPaojoom1lgRWJyU5WdXwQcg5s1qtMTVSzqyuNpgJei/0b99xPPTs9gO3e2Pf73n+tONi5dAM+0FJ5lELEAIpAb7lfsjc9331tBSaYIjLjGPCW/HhLFWucBy2rNcrokvkZGwf9jx/dkNOyrHf0W2EprlCfODNm1vCmDAbcRIY/YY0jug41GfFCN6jCiGs0GyIHwjeUWw+jRgjzkX6Q4/tB5puVeajOJIJ9/fb8nwEYdOssDygKqgErAgoV6WgSvBxkkGd9mxO8ajN8a+zav9YyUAFVCvRL0WFR3KZY94Hci6epU1uSGMihOIvmkOsUs0ej69EJXUuMqtSPbaMefxa9aRaNFWBTlZCmpWcMjmV759pzjupXxAIRVnMUWqJ30u+pkT/MmXmS01art8n06icPGGrL+yUGz/JmcmsObVgwYIFCxYsWPA78XsTlU4H+t0tq8YT1x9x/OWf03jj4fYl+bDn2O/Y/uIviOtLXnzvD2lXG7799isOv/kPPH/xJd0Xz3FmZOfwlcx6XIXlWD35Id3lkXff/A0P79Y8+fRLwvdbXv38T3nxoz/BdRucl5Ih6RKaBdORjCEhwiRQacXZvCp8lCzLSmSeE3AFZ7VeovNbUs3Gz5lIneu6HhObwBmRMzNxZ6TkdFxZxLk5jU+KnI0J2idC+6xI2HrPOOzpVs8Z04HVxz9hrZnj7p7m6jliDv/mb2D1GTHtEE8JOi2fyEbOKuHMSlYtZ92ZSSubm1ea9X6bP1ALNxOYp/fm8awkpUyZf2effSS/OhGDWiR/BOH2kPjfftkQ9IanzcgVd7x79Zpnz39IxvBe0MmisvKUggeXGfQKWT+FFHjgmiFdY5IrrXpaJk/E3/vtOMnDTsvzco/mfEI5/c0x3+wi2zvJwk6m9nNF7hnpSyUfZeIs3yMuH/PFp3E3wSMcuEDjiugUGNimlnYV0eGB5NZk7Wm6S+4H8O2ndOMbLD7Hjt+gNcCYruVqRnWuF57u0uRZcU5mTk37EL16mjRnB/8OnM8kZ4XyPUVF5/PEmMKa705FRQ1SMpxXkIBq4iefP+d//bNbnHdozgjlm+DgbojpNWN+UiSVxRjkksFF0IHL1RG44t22yNuIGGqCegEuyQpejjzr7hhzw92xIYojk/nlb45/f4cXLFiwYMGCBQsW/JNEylZsGLTKRjoHZLwrMUHOhVSyrGQVspa1uZNTDGfU+FWkxEricS4gXmb7C+9deU8czhkiflacmYLCSUioyF2WC0hNNoQqvWqC5kJqgOG84LWQl6o1VhApbZgrqQTFkXNdt6ueossadhiC1DYHMZJpbYsHUSSUCjLvKpmqCbVEsZwpJGLSHs2K04ibquE8+OiREBDv8dP+AIW4mdJZc0qMmkAT4hTTXBITHTgXiU0kuI4YARRxRV5WxHGxvirFfZbI45HU7xj6Lemwo2mPhGNAZE9KR459IqXE6lp+5gAAIABJREFUu9dviFG4vrqiudjQBMemiVxt7nj5Zsvdrufl1+947YVnTzY8vwk83G9x/ki76tj7UgV4++Ydaexx3nFxtcELYIrmka7tiE1HP44QGkIQxqyFYDaPDxFzjhAHNusNx8uRd9vMMfe8Oirv3hz54Ys1awfZG5pGvPds98owpHLunMkKaVT8aFgrhCBFphi43R1Y+cAxCt57RstF1tY5jrueq2vP/u2ebPAsXDJKxnlo2o67u3dYjjiKt6Hiudse6Fph6EdySjTRY5bRupvhJCDO4331s/RC6pX+OJLNQEplZd8nhlSeszT29OOBMQ207Qopqe1ky1Xe1Wa51JxL9WGufqKqJcXZ1XDVVY9VhOLpKlYsZiyXHx1RHQrx7zziAz42xNCRm46maYAW54oymFL2A5wJWVNJinZFllbVCvlfv0smO6MP2afMBOXcF0o/ciblXDwqp8QFPmBSVEnFaR+kbGec/D2nBISTklTx1aWoVjPtiilVmhce7QnIHOt/OF15wYIFCxYsWLDg95d+9YH7t2/o2hZrL0m7ezZdZLd9x+HuGxje8tEXP+bpD/45u+093/7d/8nl9XOe/eRfgYDHUK/4bGUBxMmjsSxiEkZZXD//4r/kuPuWtz//v1l99AXPv/yvePPzP+fmh3+C2xQJUM0OEWPc3rKJEW89uOo7WbNIJ/mXWen1/cXSzC5ONGQlOKfs01N6WTn8jNT7LsFS+zIlq3FaUM51bHWRN1WQSQlBMYyhf0PjW0wz+9uvWW+uAaW9/LgEfhHaC89495Lm4hkQ8d1z5ParQpBJJqP4smr8TjXaSb708ULxJGt7qt77zr0/I2tnu5NK7JxXX5oVEm8mxc69FB6d5wQvvpq+ayEdVVEcBzY8C+9oYoMXj4kvQarzRV5EpsV5FUUNHbtdy2V44EGu0KyoOLxMPatkVO2xYo+IsA+RqHOG4Rl5JjPTOGUinxF9nMZYpvPM9/o04tM/ZsJ8Cqxn+s+Yo6F6TwRHMGPjErdjS8uB0QWke4EO9/hwwcaObFOCuGEcDCPhXagCshNJe05Nlp/Zx3MegKk1H5gL9be+90bp7wfm3WlU51c6bZ4Yp3GCOgds5j9PbSk/qoq6ks0avSCSuV45xuw5jAkjn+5Y0ZlBwxOe8HdoVHTMpCw4PXC5Nnb5kmGs4+0A8/U7wzATshhmG+6Ows2V8dHVwDfvDuyHFdnl7/RwwYIFCxYsWLBgwQLvDAkOc4V8c1LIj1G1kHCAMyOlogiSTQgu0oSAUsiLcRwYhh58BB8JoUW8o4mxyq66SiLUiixXElPFTcTDRNhVckGmuE/QyafOCrlpCpalyLCaAwIhNnhfyNashuGBUrE4rbezaSFkk2KWivKkFUlK1VxJv1L5h0RMjNYE78EGQfNIkhL2JCmykdEUVUVyRkLCdMBw+NDgfCzVoxTpTWqV4Vgrx0QEF0KJhmtbJmbTS8SHkrobAngnpaqtCayaBh/iHOQ6sdK2sUfME9sLvO/wsSU1HWnY4Y+FPMPBRhzrzSWxWdGu10QXGYcjIz2h9WwuA+tD8SPsxxFcIHYtzfoCcY7jfuDNm5f0x5627Xhyc8X19SXrVTvHQMG3tO2GcexJhwOmmbE/IC4QmpZmdVkStNPA0PfECOvLluOxoVu1ZD2gPvL1w4j6A59cFpUmCR2HIdGrITEyOmF3OLBqGq7WEWfgTWk0ARlMkDSybhpyUvbDkT4bsvOIQHTKw8OOrErwkddfvyJGT0ZZb9YwJsgt4zjQH7eYW7E9DNxte4ZjD3gsH9l0wrppy1x1ZS9qzIbrExIcfW+kFLg79Dif0ezwLpBVGVNmk1fsjwOy3dNZwPlIVqsSwDJLv6Zc5FNz1iLTOj/DNcnbTTKvJUY8EZvlOsOopJxLAr1EcAHXtAQ1EI9L0zPpmXYLrHpSiimmHrzHWZEsFlFk2u+AuWrRTOrey0ROnqRfT0Rl+Z7JmsrP5E/JWRKEFDloc6fMb6tyr2VPYhqD8rdSfV1+T5KvcrYBMMkwn/aQTinXMm9p/AMZzQsWLFiwYMGCf7L4j/CoHJDhFd0qkdNIGhKuVVoH7ef/BTef/gC/vuG3v/wLutjwyY//GO87IIPE4qlgJRvNyZRtWcmfSYrGTtr3q4uPaH78jIdXf8u722+4/v4fcffVX3L14ks2V89RDwNCNkiugbhmojdESlbXTJrMlX02r6Nme/R6kJuq3iZaZGJepv5PEjnfHZh6kffeP5NLnfjOssirazU3fVTBCXlMuM0ld1//JWjGbZ7hY1v8DlzxBPHicZef0D/8BgsOF9c4d8CJ4oBc/QHOK/ZEhFx9O+aM2trg8yafKgr5YIXc6ejzDp+Pz3Tu6gYqnB13IqPmu1I/mkVrZmKhDwVHFqUfWnIUxFf5XhQnFO8WSjajqwSeiJEMAon90JIjOCnelIW8cqdOWSXKKjdV7wATNfdY/rRSzHJ2D+vftKQDz9I750Mjc1XtaY5NxbqTT+X70+V8Pj6uzhUar4w6sg7F66PTA6OsmGSaXLjC9I5sqWRq6xYkInokSCLZAFXmaeraIw/SD8zhSdJ2Om4mNyfiUOoxU2XwTM6ef+b8/k/UZt0oMa0P3zQeNl9FkOI9Ow3p+WscRvHkQYUff2/FT395Xz5bPTezGSrCmjueP3HcHr8gPvy6zM30ktXVM7b9hiFPm0UetSn7/Kw/VuePGa/vAq/E0/mWzz7Ks3fNggULFixYsGDBggXnaJuSVFt+ii9jGo3BEmYZL6UqsnjJKWMu8YYXEOfRlDmmPZphTIYaeBeKZKQvnpCFrKQSGiVBVGr1JZyrBwFV4tKVssrqgVcrpwgIgvOKN600hdQ4R3HeilymwuQPadnQGts7hIyguXhZyuSL6X0NtgoRio24CEkEk0R2kI+F6JSUi4QtDu8KIemaBudDqRJVGPseY8B7T/QRF3zlVUa8OKIvsqkSXFW7MfC18lRKTOlcISrbxheJURS1Mv5j6gHwUiRqzaq3qAcRJUTBh44QBLoNur6mazZcrNeM2hPjGnEd4iM5jeTcs1oFRD2r1vPpx1d4aen7RLu+YHN9TUoj2/sHchL6UXhzN9KnA83rOy7WkU8+esrVRcO686xXKzQ3BN8Q244QHaa+SJ/GgFokpQHLRR425xEh4tsNm4ueZ9cbHt4MOPG8fDiyH3peXDelzjBEcp9JQyYjoJFWIisdedp5NsGXCkjnEC3VuC704FoOg9CPPfiGISd8E3j38jXPX9wQvXHYviVsNmwfdqTDkWFMHHrDBc/DQ8+Yj+yPPePYF3sXTaiNuNgiQyKoMdY0VxNIWRFGDocj213i7WHgeBzYrC7wTcduMMa+52Ldc7FuidYTOBK8I3mPc01Nmi/ViyEX0i/lRM7jKe4UmTcL1CYPRwEtvrJWJVZTSowpkzOYjeAiXjOmuexHWD5Jo0oh7suGhAdTvPeYTRKw9bcxSznPiQhM+ymVpDwjLAtBmWs1ZcJyxvJYvGZVz5Lwy/6JEzcnRZfkAjuL+2vE7eS0l1X354qnZvHVrN8SJeY/2/M6y9k/5Wd/oBp0wYIFCxYsWLAA/mOkX2sA0q4/4jhmvI2E0BGvbsjJ8/b113TxFc8+/QHd+kk1tZ8WRnkOlkROlWPTv+srkEk/3zBzOO948skfMPY73n71U7rVUx5e/xoZj6yef0YwR384omOGsJnJHsQRHHgHoxa9fpkIkvf6de6h6CZyyj5US3aqebMPnGeqrDsde1YhN0tuWjETrySmApbrInPY8bB9xeXHP0LTSAxd8XucSVbFquyIa9ZoHiAn2rjGpASIM+Um8uj6dXTr387OeWKT5mOm49RKxuHs7Xmi0s4+JPVe2fk/K4l1fsHTpaa1+ckH9ESDSc0uBIfzcLVuYOznzzs5GcoLUoN5B0PGZWHVRIYhMzrDqsk9dsoSFGoDZkattMVTKFI9a6hNzKROc6SOgEzVgDb/Op8Nc5WkgOmpkrF4pVK9J98jwsWqBPDjOeSkbAKIC3QoknvUhEEu8IzlcwgZo/EXeLtF3CWiichbcmoxPUwtO8ntvkcC1iLkE4F9zrNOpOocvNhJGuY0Wx6RlOUOlnus82DW+6xaSOw6B+Y21dl6Vrz7Xf7UjOCU1u1p4z3rFj59tuHP/vo1KlbuoHm8JT5b70hhxdcPgWSw8Vd4eYOLLbtDR578Rqf2nz0LZnp2Hwr1XrJeHYMJX702LjZzGLZgwYIFCxYsWLBgwYwogkouP07IHrJW/7hcXCa9EzSXWMNMSXlEMUJscC4i4sg5Mw49HCM+7PEhzJGYYVUu0uGkJG5WcaBCMlKIhbJ+91hx02Ne3E8EpxkZwbsAfkogdKCOsqoviaSuLo7VqiytnYIEEVdJRWoFV3mfWrmZkxafQDOcgfMRUyN2QgyBEFti05ARDmb0xyMhjbRtpFutcF5omwtC2xHahqZpcdHjnCf4SIhlvAQhmWFqoCWO0jxiOZXxzUrwwjAYvfWFSBIIlcTMlhlTGVcToetWtF2LZchpRPOA6h7nC/nUrDaF7JJMCA3eT/fNs9lELGeaJtCsVxwOA29e3ZNVicGzf7jn/u4Oh2N/yDzsDozDkeP+yEM23M0TXts7ZFxx88PPubh6Cj5gmhGBfsz44DBXKjU1HdHhUNpoiSxK3Ky4EMd2N7Budny0dgzieXUw3u4VIfPsuiMY+BA5jImcejYCN87zydUKb5koviZaC01s5zkAmTYY6o1Mz4MlxIwgDcOh57DdsVp1DMPIxVXxqRwVtrcP3G73DCjHNHAc+lKZpw5VxQfFW8KtI6ughMbTdA1d16CpkIoijv1h4OFhz8V6zUUb8V45ROFIJMaG2LbEtsWHAM4RJIKUakWtKkkmucoayyNyv1QQMu8hYVUJS9y8HzDvnWRFU4kuyQqWcSjqBXWO5ItXqhMjCThRMg3imJ8l5xzOKWah2gRR2zolv582bR55Ulaisnhi1irKKittOSNqeHfyo5yS+ScJZ62kvpyyzCsReSJsxZ1LwJZeO3fa25N6LgHOgmjea/aCBQsWLFiwYMF38HsTlWM6kMc9YfUZd9t3OMlcfP5H7L7+ORY6XvzwX3L94vOycFWdtewLYTX5ZMx0VT3rOVP2HvXnirRIFodvN3zy5X/L7vY39Ntvuf3655iOdC9+SM7V43DSeKFkSvoqT2GmZ6xZtf6eeKapSfX6j7wD32tPWXhJJZrOcU76nD52zgWe/+msKYWoNHAoud9z+clPaJ5+jG13p4Pni0WCKf3+JY1fY3GF5T3joLSTEKeUzDx3RljqGdE4X/isa1MlnMyLS3uPUDwFw99daJ7LxdpM8Fl9r9ySE705L15ngu+7K9eJeru4iPzhTz5h2G+L94r5+RxeIFMzADMEAe8zV13Lbt9zSEyJxbWNU7Wsnfp31jO1yRK+dFymdtQ5ck4+MhGNc9/O57POvShDUKVxbSLfJ4+X0+AWv0Z7PN5S6bFaUYkZnjt29jFGg5dxJkhNMl6N4A5gAWyL+DWa14iHfrs7ZyF/J86lZOZ78Ugbt/xvkpF1RpGNmSnGevemiE3ltIlS+1KqRc9mlJ1GTab7VMnc99tQCFtjSPDu3YGvf/stTy6e8PLdiFnG5bKNspI9Hz0beXdcc/8QYJYjFhyZfNgjq3z2aMV6jcTfN0hT9mtGEK9s90vUtWDBggULFixYsOC76MeBPCZMjeCE4APBQ/QJ9a6SCZAQkuUqxQglec7o2kBoO5xvcCEWmdDgwUqlVhoHNKdqiVEIlsmvMoZCtHlxuCrhIzUIO08uVZvUjYrkZLFCcLjYFK89C0gu14NcYhZTxHKx3tAMmilqmVYrwhwSPPgiISu+yJY6n7HsibElG6xvPiI2Dd75SiYWf0sfI027om1bQvSE0OJCKHKdOsl0wpgFHUZS3mGqZxVioDV9N+fqR2lUSc8yXl3Xslp3xODxNbE5SO2b1lRMMzRn7m8fKoFUfmJoUFWGcQ+qJBXi+oJuc4VzobRxGIiiiGTG4UjKgvSCJ/P0+pLw/LLI9Frks8++ZL8/MGx7jscjr1/f8/K14+v7PW+3O7y0fPJ8xTgcefvmW0Js5phczRG7Nc6vGI8DlvuyVxFa2hBprGUcjqgKL55f03WR337zjvjNnpUbuD+O9OnI2wcjSGAVHNfiWEXj+SZy3UVaM8SDk4xHahVvJjgQlHEYcWJzvBd98fk0y6Ttjv3xyLjvGVTpLtZcPL3mzZt3aDYaUULqiTbic49YYMhGn4ysgXsDL4m4NprQEVzEJOK7QNNFwkYZXYQYCS4SgqftAp/GJ2SDbtPSrTp8KL6fLgTUis/mJONqUhSpMsUESMTPCavFTqfMS4dgTguZJ0qu5N2ckF3lltFcSEyjEP1pwJJDvCsSsk4wX/dnFEha5o0r+1nOFb9VtSINLZMl0XkFo5wRlapnP7WiUhNJR5JVv1emRHtBrPjRlj0wQ2v/Sr9KPxSbk/fnhAekJkPIiZhE6iNXXr8fRRt1jwM5+VcuWLBgwYIFCxa8h9+fqDzuaUTwqzW7r94QnZD6IxY7umaFG/uJwijrmkoInheOPSL1pn/blI11ImVKAqYDMqHSboaxefo57dULti//mld/86c8G7esuswoCedPFU5eoJHiejn5Jp6TY4WkPLVvatNEYBongmSWyKjtnSowHymEciJgJm5pInYKMVpdPQT89HkEZ9SFMUjwNO0V+2+/pru4qlWJCZEWtRGfYexfEeIGfCCnPTlljvtbOqjL65kHrG20uY9TFmwZ3jMh10q+fijlbRoT7ERiPZKIna91Cnrl8Snmv55Xytk8XoDp48y7KrH7cN/zq198xZf/wx+d3bfJCF7m++fEilF8MsZ0ZBisBkwTrVbPO2d+GmdGomUBPt14rBKRE3E7ySad6kmZ+z/NAzuf4EVktk6i05q8yC1NxKWbFvdTpS0T4Ucl1mYKuPTbJfqDw4USTIkoU8WsqMPLLb1dE909TR7pMRyxyERpCajN++/emPN79PdJskwVlJOkFJRKW5ukUu3ROWz+0UoY28yVno9d7R2T7WchNOe65UdktoMiMyXCMSWGNPDjzzv+r7/Z4rTUbn58cY+PHb95t8HUlxGSsgnzbOPYiZBMuIz3pLxil1ucpXKHxD0iSL87BjX7VBRT9+GJvmDBggULFixYsOCfPMYk5FGRnHBBcLEpJI8LiDecenLKmMtIEnJ2NZJzKAE1j3ctsVnhmoZmtaFrO0IIOO/nOAgKWYGAqiOEsp4O3qPOztarU9LmibQs4arDTGepVl/X9xocaE0MxVAtMqhmiulYLBAsoXlEtZIpFvAxlorQ2JYKwxgR5wvJ4VxVVgKsSN4WSdyecRg4HI7sbh847l+Rhh7NPeI9q82apmtqHO0IPuJdQMWhUsizEBuCD4i4Gq+UXkcX8b7QTkKRig3O18qyktgsZoxpJI0DOY01XinVaYIyaAaDIBGNLQiknDFvxGZF4wOq1b8TIXaBnAayKoSG9uoCabZYvKUZR0JwxFg8MXPOpP4AbcYEnj7blM/5zKZr+ezjGy6vL9kfEut1LKRs9DRNh6aM98pweFdsZNSxuXpC26xwEgjeMaYj7WFHs7qj2ezxcU1wr1nHe+72nncH4f6gjOOB5zcrPlqvWGOsQiD6gBcgV0ud6l/qK1lnlvHkKSLG8kDnAsaID0KfFXMJz4jkhB8EfRBWqadtIjkN4BOJzFXnQIQxGccY2OPIEghO2GwiVzdXrK/WOB/L1KMQ81cXFzgf6PuBJjbEriFmCmHuQS2TxwELEcMXD0jvS/yv0/NgJbae5k5Nfi/zyH1HqUqKjxFUdZ5JWtjcJLsMzgveFYJXLIGNYAGzhGaPuuk5UPDlufKc2SKZYnicK9Ymru5JTDtpdrY3kytRmbOiOZ+91kLUK8WPct4/qYR+Jfi17hd5OO212KQKZbja3YmMnT4/JSeXPY4ay09trF80JblZzkP/BQsWLFiwYMGCR/i9icph/44omeg37G9/Shfg4x/+N/z213/N5tPvMx7uePu3/w9Pf/Qv6kLlRMhN5NYjgvKMiGGqpJrIsuoNV0iy4qVQyMMSjDz54o958uwztr/694yvfk6MHU7ifNrgioTLmOuq6D1CaKKepHJWhTs5qwqrK6xTVehEWhq+ZrGpUT486Waed6l8nHMZjFLlObklVlqxLpBzzkSJrDdXYIn93Ruumg0hNCSUFmj4hn3zFAsrcn+HM8FLxpoOcxGxQoaayGMOZVpc1gY+buIpW87s8T2ZCMhzmdCZeJ4+L5Ov3+N7eX6XT7TVWYOm998je09lhSVLMTYtIawQL9XKswSkZdzLvx2OjHA8JiyWBf4sLyzMXouP2jCz0VOO4eP7Ph9v731u7tFkOCn1/PbosDmYMTC1eQE/j8dp2Ge51JnEP5PKnV8YqLsmpHfEsKFnNUvketthsi79doJKi0t7LPfkZHSrp/TSI/X5qE/bI6rw8X07v8PnfbKTtOtEHD869DRPvPFeJXMh66fhPFVV1pk2k8NTfeb7E6NWXcrkIulpnNI0gbf7PU/DjpsnyrcPV9zfW5HSmrJ7TVj5zOYi4nwgjQPb4ZrLuOXaZ7b9psjGWkmMqNOP73CWUrNCqxSwfneIFixYsGDBggULFiwguAxei+SiACg521mFkauGlL4kIuZMGpWUjDSOKEICWs20tqHtOpxz+BjxU3VVJQ1MmQmV9yuXdPKIr+GqiMPX+LWQEK6q4dRkTYn1wELcOBKT65xpAufwTvCxyEN6F4hNQ2g6fNPiw6oqBilpLJWf49Cj40A/HNBxJA8D47Bn7Ac0JQbtGQ89/W5P3x/JY8ZMadvI+uqSxID2nhgarGkhKplU/CdDwIKiOLJVP0onsySuGWTNIEbwELwnBCH6YiGCKWMaGccjOY01ubnERWqFFA1SiUyqxC7Fs9O5iABJhXa1wjnHeDyQjkeSJcyM4Bzjfsf+7jXowObiAhcjY1LMPKnf47FS3RkiogPpMrFaNbSNp2nBB2HVrQuhejjAXtimHRfX11w8vSHEtpDLFkCEPCQMUCfEbk3oIqvmknitrJ5l/OYl66e3fPXNK+LtPW175O5hy/4wMHYtEkuVa8oDKRuQCeLwIqgKuRKYReLVkXLGSYnpLGfEDKfQOU/0DtVEo4mQB9xBcTZgQ1+8FDXjMRrnSar44Ep1Z+zYjQMrb6ybSLNq8M0KkYCmhOqIiMeFwGq1Zr3alIpCK5WJZiU5XFNikAMSA7FW54amRVxAFXJWcIr3ca5IZLIvwk7Sr0w2QlMA6BAXCiGpzM/gtEfgvS99CULw4KU80WIe0YTlck6t+2NOrUhD+9J254tUcyETzz0sT5nnOkm8apGTLj6VlaTUQlQWGxo3J3lT90hKpfGU5FBkXJWTf2VJzq2VlJzS4EVkJignGdg58V9OOwqnHYC6J/j4a2nBggULFixYsGDG701Ubu/ecL/L7H7916T9HXG9IXuwPNKI4+J7f8z29iWv/+rf8/xHf4JrVmRTvEnNSDuRIacqvDPSqpJDs8wmrr7tZ6IHrbVmWXCrJ6w++WP8y7+EbkNJjjPMwUUoxEjKJbgSZ1gllLwYzhy4Qh6qTcQhc9sexXhmU7lXIdAEgkGuC7XTguxE4BSUtrppcTv7b2qtuivtdThS6jGX2d7+FjtsaVeX7B6+ZXNxg/iGZnzNp8+e84sHx/HhNZoe8N0lQ78vWXaWS3ZgHa1pWFNVHpEaiE0dm/0Az7p4TgpJDVjPK2FFSgXolIVbFtbnhNL0WivRzOzbOdcjnsrqTvf8nO2yiUymZP+Jw4dm/rM4N3OMZXoUwjJ4R8qG+UJMQcmSNZvEWBWkSAlP1bTlPQeVSDxnd51NfT6N0zRWk9/ph6R9pwlk01hPpNdZFer7Hq2Px+587oBV/wtHkaIZw8dIfkvrElnWmA4UMaYGRwYa0jiC7TC3RoYtNB3kEfGCTZsNZvM1TrPBMDtVmn7Iz9KdEcrTY/GYZD0nXpmJeDs/ZyXOrVZOTkI28xysAdsj1dn5PSkVjXiiW/Hbl3u+d3WLix2/fO2LTI6r/jcYCcEbfHRp3O4bXBA0Z6IY9+MFm3Dk2fqON4cLdBK6kVy+s6Zg1JiJ1PMbvjhULliwYMGCBQsWLPgQuigkPBhkVcasmEJKA6hVCU2PeY8geAmYNzKZlJVxPJJyYhgGhn7Ae08MHcFHiOEkv1hjDe8rkUElGESKz9xEQp5hWo+LK1GXWk1eFYAEJnjnceIRWVWCo0RU0zUm6cyUMjomhjSS+j2W70tUbYqNmZSG4pWnRk6JrKn65w2IjjjLeBSCQ7uIMUIQvI+4GMnjSOp7mrZBWi1VnlmJTYePAecC3iKiviQVJi2+nzKpCTmcgxgd3ntWbYMIJB3IWuMLLbK1TbcCy6ShZxgO5XdKjOMO5wJKw7i+IsSI9xRfSh/x4tk+PJCGPaYDzkEIDU3TkVImbi54fnVJHkf64xElExpK9Wl7Q95cFmI3J7onI5uPBvYP9ziKR2bTNoQg2DiQkrF9uGe9vsQ3nuN+S2xGzITj8UizvuDi6gaRBnAcxxFcUwlcYxwPrK+vMOfZXF2w+s23hJdvEHXs+4G3Dz227ggo6Ihpxjlh5SNN8HhTVkExKf6WmVRiInG1ylZxzpPGAZwUWdNsiBrjwwHnS5xfFXbndOdsI+Y83q8RCXgEazzXl47r60jTBIL3ZT8Hgdo/tMd76NqGnBPDmNntjuScCeoI3oE5got43+J8i/cR7xu0xolRTzLIVknKiciD0nZTJZPRrKSU0JwQSZjLmHfgSzUjVuyPvHP4EPAhEGMsxKUrcayQixdnzSA2ivww9ZrmiuyrszJ3rZLAcJacUEnGrEqeCEotsq+qqZKWxavV5JQGXMa+qFGJTmS+MSsGQkUJAAAgAElEQVSc2STqWv8/fY9M0lzlqPn/kxrSeUa7TYniZ0e99xW0YMGCBQsWLFgw4/cnKu/f0I+Za/FIznSrZ6Q0Ers1yYF52Dz9hCyJVz/933n2+ZfEmx8gJLKESthVOYv5/2fkGLU2b1rr2LlxeF1AuZKJqscth1c/p3UjF+trMAjBkdUICE8beDeWReBJRb/INjrncGYomVxJlfdrPUt7Js+8srBzVQZErBqMqxafAzl98hF5McliVsLD13OeLmKYCN4UTUe8RPa3X+EzNG3LZvMxu1e/Yhi35Oun3P/qlqEfkbZ4lZAOjPaO2KyKBKqVvk2lqQaFaJnIokq4TDIcZw3l/dXjSQb08fuTJ8Ipw5BZXvb9CjR57+Nz0aHp3I7za0yzwUxrpm9itzvO/grONVhO8zWn4VUTGjMuushtAtOMhIzmQJlv4xzIl+tI9Vo5I1ZrM6aqQWS6/yeScpKHrZTeWSfPu3ki7KajRAxXiS9jqlC1E2n7aIyrT4xlOFF4hRgkgWTMP6XXe1bcgRtJ7ikr2ZNNiTbg84jEFju+Rnxb+prT+d2tJOuJfBMrQQuP6PrzeXB+h95//buOP80XzvvNRGaePXPzMef/fi/1smZ3m3lMhNd3Rxr3ivvxirvbIv8j6Jw5XsRvDYIxjjve7jZ4H6Hva96BcEgdOXterAfeHSN9tjn7+pyEnwjVJcZasGDBggULFixY8A/Bu0CWUtmUknIcE2MyLI9oVqIXQq2icy6UZEE5RR7OHB6HUyWNPdvtAyGWqsoie1mISWAmLswMV60eplW3iDtJU54W2jNxUYRqyrm8OHwsPpOYYZYxBc2JlPtCNA4JTWOp4CKjmsCqeo+Br56ZuVZq+RDIkkAV8YGQSwydfGlbSgmnIC4ARS6zsrv0hyMpDzXsyFg2soEXwUfDZ60kjJJtRKxWgboatzkhxoB3oJowg37siTHWxMhS8QhKGgaO/Z7hsGXsd+TxSBr7mpwqeN/i/UCyRLy4xklHGgZGOzIcDxy2DzgRVutLwmYFBA67AecdrosMOZOS0nSXOEukdGQ49qR+z9Dv8T5grkj+5iylUtVHVD3iV/jGQ2hZ+8iUbztstzAm4qUntB2r1ZrheODd/lesVxdIbJEQ8RJR8wS/IraOpx9dEbo7vn35EvWOi6snjOrJsqUfB/72bs9+TFUWVBgt05C4io7nq8ina2NliVaM4Gpcboqvex55LNWOZfKAU6iZvOiQmRLQlZqEXMlkc4rJCF4QrzzddDx9siJ2K2J7iW/XCA61A8PxwJh6hnHEN5HjMGDZOPYDDw87cjaub66I3SXiPaMJoSacp5QYk5K1OmvaWYQrZZ+nSBXX6tw5/1aLDUlWgiXymBjHxJhb8piKHLCe9n+8d4QQ67Pq8cHXymer+yGgmsseiTdEFecU81b2daz4VZoIxSzI8LVyuigcWSUkC0FZ/CkLaWl5kmnWMp5TJSSPvS0RrZK+zHzi9O1QKiFrHHwm+ToRmZPUax25iet8tH+yYMGCBQsWLFjwD+H3JioZE599+n3S1QvsVz/l4mqDDSNNu6ZxocQQzlivn9P+sGP/9u+QMXH5yY8RG8qClXOSzM4WN+XfrlabSa2qdFIr9+r7qT+wffkzJN1z/ckf0l09Y9j9Lc/ckctWuBuM68Z4uoFv3yqp6JAQBRrvCXhGlGRGMkNnXsYxy3pM5JOVDDKtmXVZIfrJfUIxOWUBntWMMZM406+6unVQvSBLn0rVlwOn5HFP27XgG477t1hK5MMbunVLq5HD/Rscjma9QXUgHw8EH2h9JvcjTqpkieWa8CYz6SOuBqY1eJtptkluk7OmTy/OeLgT9zT11k6FZVZN3s+XohMJC5V6ru1hIv8qMTzFyqV0sh4liAuYZZwWWZe3395x87nDhRpkz16cMp9ZnWPTZba39xw04ImYH8s11ZWs3kekeMkunCo7p3tYqen5PhZye8peLIminJp7Nmiec8L35ONp8/VKFeI5KXwat/do4kfSqGKCZQjOCDEhDHhaNn7geMgcj1+RWBHcSFivuLkqQdL+ONCPO0RXqEbed6icaogn4vm0yfE+CXnewvdJ7RPxeIK+9/cTefuYiDz/7GNiXKbszkdwc2CLON6+vmfPin7c4L0jm80E5HR71IQXqwFza5JBlADaU8t1UVV6H3l9TLxYHbhPKx72Die5BIWPuNgPsPEL/rOCiPwQ+AXw78zs3/wnuua/Af4X4H82s3/7n+KaCxYsWLBgwYJ/XAyqDDmRx0LqDUPmcBwYsxLEFQ9IEWI0nDPUlCABzJcKRAch+kIkimL5yG73FrWB9fqKpvpVTv6PZlZURVQJwSM4xLRKlBZ/yLnSsiYtOucIzhXlFzVyzoxjX6qwsmJaYgrTjFYpU9VcLBOcFO85J6CZujwHqKRJSTx1UHwBnQdNmBfMOXxVjTHxWCr9j40QgmMcB4Z0wKQkq2oyhpRpktLi6JwneY9ZxlvGW8T7gFhAfCjylSZIElQHzEFsAl31CQXPkIt3YW8Dqd+Rxn35GXZYLhKwElqaWIiynEvsm3Xk7u239Ptdub6PqAnXN89o24ZhTBz2RwRHfzxiaoQgOKeIGEdKUq2mER17XBBC25AHyIOy3+9ousj1zXNMS7ViDKAqmLT4tmUtsZCbTYvvLhhcoDFwLrJaN3QXFzTrp6hRCFA8SY0xZbQSnRJuMAKx2bDf7vnmq29pXr7i3e0dIp7duOeYjTHDUY0+w28OmXg38IOryJebwEdR6FwuVYnVpFBVUFOcy4TQlF0TLYS2Zq1qR8Xix3woSd9A1iIyTN17uVit+N4Xz7i6uUJ8YFRXKjPJjDbiAuxut+zujrTrhvVqzXFI3N1veXu7RcWTmxW78UBsWprRcS0jbZcwyaUdVmw9zCalKCj7UVVG2Xmcr1KodQ9FrMTLDkF8wIsnWMAam8nDaYPF1WpEmX+fKUNhZT+ptoNKDKrWeFYUr6Vtvj5XrhKNzpXnPU9+lJWknKRfk45kHZlsWE5bPEbGCqGvE8FsdZ9EcOLL8VKfZbFpA4uz1If5XJOM7EmOlrNc5tM/VMr30IL/b/jHiFf/c4CI/FvgfwK+NLNf/uO2ZsGCBQsW/P+J35uo7I9Huo8+5X5/jxfjOPRsf/EXuNWKzhTGPRkA4+LmC7ovb3jz65/x9md/wdMf/VGRscBqVpi9t2A5LWamRVjJFlScC6SxZ/ftL8m7b7j++A9onvwzxAQl0ffG6qrhJ9eBv3sY+OLKc3Ph0G+FDmPdCJvGMaTMLpXAMWdQOVFdzNVkjwk31VSJkfp3ddVIHII4suaTNKbJvPDk/HfNNnNOCALgGCVhpkV6Fk/OO66uPydsnrC9e42OO2K7QXCYbWkufsJ42OEub+jEkQ93DLe/oumuGccDTgq568+5lCpROvvpzf0AKRo/9ViZPThPd8LOXp8PyYmsnOtU5ZzsY87SnSVOJ9JzrsakehGe2jOdprybyhxyb1jFEfI96XhLd/kcxIM7OSVMa2cRR7AtzXDPYB5rPsG5WORgK7FZ2m+nuUW5pxM9+YiVrR2XSlKeVz7O6rWnBELE8nzucpCrLyv9LWfkLqfPTQHCY2rw1NqpvNN5kKSkUTDXcBkyb/srnL/CxwfGNODiBTkru2NHbw1uHWiHB4b4lE2+5yAGJsz+mdhcZavnpKEVSdzzrOvTvWeWizqN52ls5r9/5/WHyM/5qO++86gKczpKS9stgwXE77lZX9O/O7AW2NPQ58Ak8WzmUMl89jzyV78R1CdCjJgeaiarlCxeLZKv32xXPL/sWT+JvLz3lXo+6+Gjttg5W71gwYIFCxYsWLBgwYwhZ7Ja8ZzMiljGu1wSYLWsZc0KcRhDqbhS8fhQVU5MiN7jvUMtI5ZIxz2HlMjDSGzXtKsV7WqNc4FQk/WM4iPofNEDcSIE5wgxzrKRIjJXVA1DIqdCckzefJMEpdZEy5L06hG0Vk5KrdhyiFadHdWiNkQhS0pYVaoqJ0sR54qfpulUzSnFbzMEzGXIMAwDoDV2DjgxlIQlI2nGuWMlRDMuNcSsaFC0UXwosTAiZC0xjw9KDA3iA31SnApYIc4EBRtBMqA0bcfF1RO6dlN9AZXj7oHj8YH+sCX3O8QZmhM6JNI40Ktjc/WUw/6B2zdHxBQfBM1G8VD0DE7I/bHGiwGco+k6NtfPcRiH7QPD4UjWkXbV4XzLmIUmrhFTEgIuUKRODQkrNt0GHwIhNDjfEtsNPnaMY8K8J1upvB2HhFq5Jz5EmjiRqT3OB57e3KAGl9cX7B4eisTwtij1HPrEYUz45IsMMcJePD+9G7g9Zv750xVftLCiyI0mAecjQsC7iNCgloEE0/wyAU+J00wYqcnjIaChxcWGdtPw7JMXXL14QbfZ4LxnHHryOJQEZXUcdgMP9wd2DwfMQ4htERBSZdM6nt5cc/30AnOeIRsuGKOO5H6PmZArUeedx7uA9zJXCeIyUDLSzSDXrYAiD0slByepWMqxUuReg3eIlKriqep5qs6ctkXUTuRo1hLj2qSFW6stnfgpWi+7d2KQDHG+VHZakXUtJGWan2fVjOUzEhIhixGqJ61YKtdyATMtpOUkp0uxmpkI2ympQeTc7odaeVkLCk5v1WEQSo3y5IxJSWhYsGDBggULFiz4Hfi9iUqxTLN+wttf/B8IkNLITpUnrfBu+y0f37xgvbnk7vVvSqZXNp7/4A95ePVbvv6rP+PzH/1LtC1+gx6HMSKEU6WSGVQvSYcrhvGaOHzzc/Ltr7n65Es23//XKAlHRCXhzWF5QK3jDz+C7z1p+YNP4GevRz67Nj7eNByz8ptbuB2UpFoWVHKS8XhEDJ0RfY/kO+txqoYTqxmiQkYYZoLK6tLsBKvj5sQRnMc7RXPNNKzEmBclH3b4i4/Lgvd4S+xWaD4SuzUufoSpx7sV++0rfHeDKuzvX7F6/hPS9pvifSmnijK1iUwsEqllbWtEXMmCrZlvTihSmTOR9l41KBPfZvNIieksHVJ+6UxTTgTkXG1ZzzDRPfMydSJ+p0HCVdlfwyms5BVB9zjf8M/+6/8OcS0pZ2JwJainBuPOUCkeqDQr4jrRPGzR/ivG7gu8ecY6LsjkNTFVP8r0H3MB40RIGngp0kJMRKKUwPpUcXtOsJ3IxpJpWb0lzypAZ8quXmyqXJwqGeXsXFbHb555CpmWLI7LMHLIgVEN0wO4DW27YZuEF+EB3IimBnVXOLZIvIR8j6nWtuU5UDphHtEyk2fZ4rO+ylmf9cME3jkee1z+/UTm+7+n16fK1DIezgwTB+L57be3XD3/hFXT8XYvtE1ixZY+N+ytSE0/6RQlsq8SRM4HzFL18/TzBpHWS7y+77i6GPnyBfz220BCyVK8Oac7Oc0Vv8RcCxYsWLBgwYIFCz4I+X/Ze/NY27b0uuv3zTlXs9vT3HPvfe++tlxVdpXtJH52HBvhViREcUAoEAgECE0wCCQEwkIJwRJGyAKMrED+SIhkCsXgWDRBEAEmIbHKMdhJqJSNq7Fdz1X1urrvtufcc85uVjPn/PhjzrX3Pufd56r3JOwqZw/p3H3O3mutvbq97/zm+MYYFK5MtqaqYCLqSoykLDlFCZoy5tBUk1krIElZ6L2iMSSyQ4Wu9ahEWtPTeE/Rt9Shw2ukKmsoKqwtcc5RlhVlVWxtYKPSds121zTVKNu6jEykCKIWEd2QGEN1aMSkOkJSm62abA0rW4VcilzxGCvbXtZUbKIhpsw8yc+Jwew2zKoj9C02uKQyVdi0poogEtCoxL7HAyZETOnxfaCsR4mI2eR2JvJUnMVYQ1FVlGWNsYqzLu1S9AgeHyzTo0NGowlg6JqG5uIxl5cPWV0+TqpHgcIWjGYHyQa3WxGtIVrB4qhHFU3fYERxRXI4sqXFNz39ak3fNbTdKjfAWkxRM7clZw+fELs1hkSamroCY0ENsVda3xFjj7MO66Cua0xtMWZEWY8xrsbHVNs2IaJ9m66n74nLJWIcVT0GYzHOETGIFFhrGE0m+N6zuFwgmrb93EvPc3F6ka6TE+6fXRL7HmcjYyuUxtIET6eOR53y6vma+XGFcQIm55oWFSZmtWLXpbkNDL2mGh6FGJQOQ2OgFQjFCFOMmM7nHB4fcHA04+j4gHo2o6pHuQG6oJc1se8QiSwuO85OL9EIoz7V+kVpmExr5ocjDg4OmM4OwDr6oBhXUdYzMAU+RnofiWGo11NDQHLzsjuN1JIjRdI8VQiRkHMoNfhsuRo2NWswJjUNWJetfNlsZ7AiNmJTPavZHpmIKNmGNhIDiQw3+YOpyhAHM1jsJmIxLRvDkEeZfjSGTa0vG3VnDuyRbUWum3+Hnwia5t9EJWdVmvzeQyDSVaimLy7J82rv1pL8m72yxx577LHHHnvs8f6tX0mWJV1zSemErlnjTM2oPqYaCZd3P4Pe+mB2gsgDstAxO3qGcjzhzVd/mVsvfoRqdpAC2IfsAkjjPwMSUraG7zsWj95k/fBVZjfucPwN30NpSzRGyqKgkkBdwNgJ9obnpWPhzvTX+cA33qZ4/uu5fTfwkTfO+YXPKZ96EFi2Hp9JocGqYstUDr1gWxJqs1MSGQZo6ZmtyktI+SLBJ8WiCqiGDam5ZfpSF1shaaDbZ+ucjf2HREy/RlxJuzyj75aMpjex00kiZOmJouAMs+ltmuUDmv6CYjzPNjc9EiNqtqaXmjvtYCAPlUKU2gorz7Z4HMSC2182Y8nBAdSwtTEV2WotN2rJgWSTgeAyVze0YcU2VB3b0Wx6TORpwMSCsTwh2gmVPmA8OaZVpShqjC0yoZftWTPZKaLMRxZbHtAHxbonaDll0t+js3fQaIgS2RCUGjbXc/eYjUo6z/lcpAJec/dwIlI9Q27p9hJv74fhcNLNIDmzw8hgEUOyVtLUgbxrkXqFkINr6lxFpMNoSWFBo8H7lJkSZAQKTRQmVaCJFRIWlMWYgKVtA1W9RGyfOlnFDvQ178DwWcz37OZp2epo37HKb0JSDkXb0LV91eb5y5OUu9sZkAjFiIplZC2tVyjgaCI8WFQYU1BLz6FdsQ6OF2/VfOlhzE2xhig2fZpjD1qRCOPNWSdK4HxREfrAy89H7j60LNcRcvSrGa6NBD704uypx77HHnvssccee+yxx9/fEATnHNZkNRWCiMeQGjxVE5vTti1oTDauYolR6LuQa5qAjwERmwkSwboiWVfaRHA46yirmtFoQlUXOOOIMdK0aww2O8MkAtRkb1ZRUGO3BAq5Ftk05KVqyyQ+JDd7JmcTMZoaYnfqBoOAsXms7FKdT6pBY7aWjCIYm9bXmAp/lYh1kRANSVqW1GjOeXrbYVyHKQtM1+G7Dt8lZWDXt4TQIZ2lqEcYUvRJtCnzs66njCYTqrrG1Q5nDcEHgvdEFVxRUhZjymqEOEfXNVyePaJbPaFfn4O/JPgloxrsuEbV4ooKI5a2azCVoVmtKDDUZZ2VniW+71gulgTf4DuPKMQQWS0uKJwjiFBXjvFkkpSivsc4xboK38PqckloniAK1WTO/MYzjOcnBCDGnmgcYDGmImpF3/a0qxV932KLktnkAIxDXIXUDrFlun9QJKY8yeXqgq5LDZy+S3ashzducnB0k4vFCjEPafuAWVzSrj2xjyy7FmsDziSVnALOWta+5/6yo5o6nLEUpiQGgwaP912O7zGbxmhVISi0UWgF1qagtSW2GHPj6JDpfMLx7ZscHB4kZWlRI6ZC1RO0xYfI4uICiUpVOCajmrIsGU9GqEZK5yinE8Ra6vGMopolC2WxGFdTVmMwSVkbpUclKRm9pqbVZJNsMSbZIgsGR9g0D1elwYdA13eIafHeQ0hNwBrzZ0T7q9yf7Hgu5ZxIHYjc7EWWpoyStayRyNAhrTHkJTqG/NloItbmWJsA0afPRAyRGAbiNCkrh8/nZl4O2Z2N2UxVCQOXmeZxdpXX5HkPGb448sPGderKd97mcK79Ftn4Qu+xxx577LHHHntcw/smKo0qzfKC2PaU05K+nGKx2HqM1hOObx2Cbzm9+wWmh7cZT+aoFIgodTXnuY+8wt1XP83hwS3md17MYePDmEggJPuI83u/wfLtVxnNjrj5Dd+FqWeoBloNmGjo8XhTAJ7aRZ497PneDz3iwx96jeJ3/RCx+AYO41/is59s+eKjSB8kKTgHO0kGQk22o7S0J1tl267IcqPISwRPzOSJMSk3MBqhizGRKHkkN1BBRgURQ2GFwkFQCMN7a+pO1RjBL1g9fpXO9zg3wU6mmCgE8ZuOUiPpvarpbfqHj4i2BByFS6QaWMgD7hhjJlVNHvgG7owsZ33Kdhha/CSCVXb0gImg3OY0pJMgg8XIdWJuOEk76r+BgHsaiXU9o1GztZGTSIxCySNaKsT3zI8NYgq6iwvK6iYSI2IthO2AW0j7H6PgfUANjMaHLNpzdPQCdX8fNSd4VYLCvAqEICz7Yb+HAfqw//kYYrI5sSZNNBij2cJnICKvkrSqW+pvyHysRDiohYdN3Gw5Xjsvu0rLa2dqyxQLaAhY01PZnvVaUFsQQ86xIVm4LILjcLRGjCPImEIbogUlUESbJgZ0e+6vXZjftNdx58ywewWffn2f/ve7/f6Ov3fur7h7rnIxpBoJWG4f1xQzw6/fdzw/DdyolYdtoAklK3HMXcPx3PGFt55gGUEMRKr0WYktKrMr6titFjhw2Qa6u/DhF4X754aHpz3GOEIITMqWl+6MgOo3OWN7/HZARH4f8EPAdwEnwCnwKeAnVPW//zLrPgv8MPCHgTvAOfDzwI+q6t97l3X+GPCvAq8AY+Ae8IvAj6vqJ77M+x0B/0ve139fVf/jr/Aw99hjjz322GOPr3KY3FBprSEWDul71Ocx9TBpn4f6vvf43hOj0HmlaX0iKESSvWdRYYyjKGvG0zlHJyeMJ3NcUWSrTaHvWvpujcFgjcE6g5MC6xxiTSYgcwSHJKJUxOb6Loe36NZ1R/NymNStJ7mBUwfFFRHVQFTNNpVDfTQ412TFZUz2r8aaTWmjMSLRJxJHI8TkjlOII6ol+oDYClt4bNcgZoU1gjM9oe/pvU8kDSmL0hYj5jducnTrJnU9RsXQ956272ibFePphNFsinEFqBCDRzWwXF4QfZeIxfUCYkM9KiFMiKEAjVjrwFiiJstXZwu6qNTjQ8bzE2xR061WnN5/nW75GCEwqiuisawWLevFihiSja5xBmvTNetD5PTBKdBjJClOrU1zEb6PKA7rzlhcXmCLgqIs8WVBWVeMSGRRFIcrJ4gb4YoC7AixDlcVhBBZrVdUVY1zI4LvWa5XaAxMxmO6PtJ7ZTo7pO96oiqTyYRmsWA8GtGsO+ajMSFA7yPiBENM2Y+hQ2yi3Bc+0iFEDYTgkRAJPuB9JATFWEUkK3DF0KnQuJK1LVmJRaTgYDLl6PiY+dGUyWxGNRpTjyZUZZXuzxAAQ4xKWZT4do3vG8pSmB/UVGOHMSbnhaY8VFuUFKMxUQTEYmyFcRUijpKARoHY0ecc1hiVKAHxATG6yZQkzwUkx6r0/KgeUdU1wfe0XYsPgZiVloJucimHuYpkuZozLEnnJUZN+auarWCjQTGoWERNmocgK5jzvqkqYm2KLdFk8RqCx4eemPMqY0zbzl8fVx7Jn93UNCE79X1Waoq50pmcPuu5UV2EjcZ5h8jc9vu+Q2+Z3aNAjdlxMtvj/UJExsC/Bfwx4MOkL9pPAX9OVX/6KcsbUp36J4GPkq7uZ4GPAX9RVeO15RX4OeCPA/8p8AeBWV7nx1X1L19bvszb/wHgm4BngCXwybz8zzxln17Lv/5u4EeAfxx4jlRv/0he5vcD/wHwrUAL/C3gT38l52iPPfbYY4+vTbxvorIwhsXFvUQYGbD9gs4HmscCrkKXN5ByxNHNW4TujEfnb3N48jK2KhAxlKbi+Y9+Gw/f+FVWn/8Mt1/+SO7kNIToWT6+y9ndz1KVNbc+/B0U03kaTIVEQJkgqAnYYAix5TI4et/x5M3IP/gBi7nznYTiw5j2EzR3X6Wqj/ngLajOPI/XysqDDzBkAsQrJhZbmkKEnBOwQ9BsBJiSB5RJIWYlUtlszzOQXjpsMZGcBqE2UIuyzB10m/dVj40Bo8r08AUoxvTtKltoCDJ0tmXyz4qCX2OsQ7qW4C8RTMr8uEIkDgPUgEZwOAyexm9b/HTII9jscH4tK8cSR5TOytZ98xpJmX0wd4Pft916g6rOcFW5ppvBfuocFHyEGRd4Y/Fac1Lcox6fcNEVxPYyEd6bdbcFw5DB2TUtl5cdIp7O3KLgLp2+SHRzjtw5j5oDLJFbB4bLBXiNtH57/YdjlaFj0ICRVGykDkMhsiWYd4nJRAPvIIt2fYisvLlCRpp8zmImOjcdisOp3h3EJ7+kfK2UsV2yamdEW6PqQAKKZ0i8FwKlKehJ+acNI1wpFHFJ118Si+NE9G5jRtleFNm5b4drPlxr2d4b20PcTGAksnmH6Ny5R67XJO+mnhz+NmxXUpQYwuZ1k7NqUh1ksVY4Ppxh77XcuzDcOQrM1LBuIlEMt26WvPbA0WjJzK7och6lMQLRg9u5jpreb7g+Ismi6DNf7PnoyxXHsylv3V/zHa88z/17j/j11xuOxnfZ46sHIvKDwF8gfRz/KvAqcAv4vcC/AbwrUSkiHwD+LxJB+bPATwMvAP8k8IdF5J9Q1f91Z3kB/mvgXwAeAf8T8BB4Hvh+4NeBdyUqReRF4P8APgT8CVX9b9/XQe+xxx577LHHHl+VcDZiSRl4qOCtodFIR8CIYK3BGsGYnPUWI953dF2g94EgJpGUtmAyPeT4xgnj6RRFaPqO5uyMwhVURUFRlOmnTFanAhCVaCISQ85NNGmMv2UtSD3DuVF3KE3JaikEze5HIprUlRvCJdd70ZDsIlOtGNFcC6Q7f7wAACAASURBVOYtqcFITIRkjJnoTMrMVFLFRNBYTTEexiBqMCaC8RibGi0xESOKx4Bx2JFlNJkyOzrh5Jk7jGeHeB84e3LG3bffxuCZTmYcn9xifnSHgOXyYoFvzkFSlEjhLKgnhB5DpB6PKNyItl2jvkCCp6oKQtfS+S7HeRi62DM9foHxwU2a9ZLV6dsszt5Gdc1oOsJEoW1brCsoKs+Ukr4P9F3EiiVGw8WTBU/OTllfXOJKw61nbjOdjdEYePD2Xfo+ELzSrNdMDw4Yz6Y0F4tEZM7nEAOBFrEFha1wRUXEJkLICm3boQr1aIIxSQXaNmucdUxmByAWHxsmkxIfFFtUNM0abVum8wmr1YxV16Z8TYSzds160TEphJEVHI6oSmkNx1VBbRxopI8+E9HQ+6TkDCE1GiuWToSVdZxTURYjbs/nGGuZziccHqXjrKopZZmUj31QVFP+oisqympK7HpsoUznBxRVxWQ+xpZVUkKKoe87okJQpfM9ZTXB2AJjLBBTZqYkMlOMxboUnxNjqp9To3nKoYSYFZOZeCfViCKCsw5XlIxGJTHERHZqIKpPTfgiyS452xFrnntK5Xci+EPweB+IUfFxyKvM+2Ud1pbYoiRah9UCY01qeM9zVTHmbQSP957ge9T7bb29mS1J7mDDvogMKkpNsUsoyXkqL212CEvZaVd+mr3SU3B9DkCvzLnt8X4gIoekGvUVEhH4MdLUyR8E/rKIfJOq/vC11f4bEun4JvATpMvyR4A/T2qU/Wef8lZHwC8AT0i17iHwTwE/JSLPqep/trPsMfBf5OX/T1It/CzwjwL/u4j8oKr+xFPeo8zHcgz8deAC+GI+zj8K/HdAlx/fzvv6i8CvfLnztMcee+yxx9cm3jdRWdUGwpqoytHx85jDm8RmzfzwJlLVtM0S6da0qpi+x6rntU//LY5vvUBRT3B1TWEqbj77dVycPeStz/5tnv3AN3G+vODJvV+lQrn98rcwPr5N9NkjHwUCqhaV1AUWTVIXiglUpufbvk64fTTiyeuWg+K/Yv2lN/jCazN+5TXP/RV0EZxVRgjeKD4KPpqtikq3lpJkgnBQ2g083oYkyyO7EJVehUqgNErvoOuznceVbtVkszIuLM4GunYgqDLRaYTeN4zHU0Q7+kYxRZltQhUX0w6IEWJQNCwwpsBKDW6BYFitltQ564QcvJ7Ly7zXEKTn7jpdRyOGEOOOOnBQ7il6jZDaEJ4MBNYOOQUbAmsoXrfD4ryupMH4kMs46AqjDBrGgAbLRM7BCl2YIBI4cmtaPeSVF2reunfJ152cMZqcpPeQtI2BOM5HRdTAqCi4YM7UvkFgTZCaRiMn43MerA74/AMhRs83HBm+eB7x0QJhOxbfbi2rKZNaVSNJZamJsNTBQjjdNdnSRvOxp+OOKizblMWS7FFyLosqQw2/wxPmLuecwZjvSyQz23iiVkSp09OZ6ExZr4k4PxhFLjtLZcBKT1SDcsiagponDKpYnhpov8OYDkSj7BKKTyEph7+HbspNUXR1jd17Zdd6OXWvDkpdzUpJ2dxfGwI0LxdNzquRiEdploHO9+mMG8fbT3qeP4rc7QwSPXdOxvziZxpCKLgIjoNyyfG45QtOsCw5mZ5jxGBMSe6HwIeCLkQ0CG0IqDV87nXPd3/7nO/6fXf4hU884HOvXfDBWzCaTJ9yHvf47YCIfCOp6LoAvltVP3Pt9ee/zCb+SxJJ+cOq+qM76/15UhfnXxKRl1R1kV/6QRJJ+f8Af0BVz3fWsSSC9N329fcAPwNMgB9Q1b/xlR3lHnvssccee+zxtYSBlCuMEAtL52wmGkwmBARrLS4VUogpqEaCrWrK8QRb1IgpaDvPo9PHLN94HQFG9ZjZbI6ZTFA7QXFgUh0aRXNGpE11ac5ujHEncsKkejA1pg71i8lkwra5dNuGKJtlVLKbjETECEZzE+Sm/ksZl5uGVd1WDkpA1KCarFoVybVRqvNVDKgQCJt5AKMWqxWmqDm4NWY8O2Q6O8CWJV2z5uzsjNdf/wJo4ODwmNs3blNPZyjCarXm9NHn8V2Pc5aiLiirgiAG71PevHOJFIJA1/dYVyG2QoiEbk3btkQfkXJCNZ0znRwQfMvZw7fo1+dI7CiqEldajEK7uGAytYTgMaYk1iWL8yUYw/z4BAWePHqA9SueefaYZ196GWMtq4tzVss1ZV1ibWC9WiRlYX0DYyLWQQyBswcP8e1dqnpENZkynt1gJSmD8uDwJlaT44tYh+8CQTtEhGo8o3BVilIRqMaWru8hdhiJlK7AHh6xWtacSMnhyQlfev1NFquGg7qmW60ZGeFGIdwuS2prKUWpDVQCohbN9XjIakqc5qxGh3eOhS24iJZoHePplIOjQ0aTEdPZhMl0Sj2ZU44n4AqMc6ABDYL3nhg8ISq2rCnKgrIqqcIIVzhsWWNtmZSMq0uCQlmNsHZQ0LKps6MGokREdWPLbExyoUoWqolp3dSnkq1fh0bl/NNmdaVzKY/S2GwbKzbPIWVSMM83RU3EomokasqpTQrIpD71ISlcoyb1ohiHdR7Xe5xzOFfgnKNwRfo8k1S43ieiMm5UlUNOZW5KyGSpMSblY0qOiM2Kb1CMkc3cVarVt99hwvD9MJCcV+cRtovr5o+ddmQAzBXd3h7vE/85iaT8U6r6Y8OTIlID/zPwZ0Tkf1TVX87P/zMkkvKXgO8ZalgR+WGyalJE/rfrKkmS0vF/AP7pQXEpIv8J8PeAHxWRv6KqX8jLngEvqepbuxsQkQPg/wZ+TER+SlXX197jWZJK83tVdbmz3hT4i6Qb87t33YlE5M8C//Z7OF977LHHHnt8DeF9E5VHRyMuFj1WhL5fEx7fR6kQu6SKFpURkpqxCFHpgmU8OebJ47fwzYquW3FwdDNZmxY1/eouX/y7nwHjmBw+y/iZD6Ah0Dw+xZQWW9YYUyDi0iDJDF2ggdIYDkeW56eO04eWj/1cye8vhJtvPubRkwPUCQ/XPXcXuVs0F2lDNOKQFxizpM0OtN7AwMi23NrF1n5S8UGJAtNS6LH4PhB1O8BL3akpL2FeR9aeHJoOg+wuKISuwVZjRrMT2gevQ6gpilHSUUpIKjjfI36J2jFOClpaTLOkjD2unIExGFFCjJtj2qriNFvDJt5LjElkG4ng2mZQ7uCaPenATu021V1RxV3Tzu3SnVfzFxXFYkIkGg9aUMsToghNnKEEJtKDNHzdBz/EyfQtfvFTD3np5VUyViRdqx2aDAWKckwMkWIktKuKm5MZRi94EmpCrOgUTspTTtsDRIQ3LzXRkxKfEv6ebV/z/WIFuhjTPZRH38Me7Jbv29TJIUXznaSv6KDAzAP3TAZq3Kr5dOdsakx3YfABcSVTc8E6TGhUsTg6DRhRDurIsosokQKDiR0ijojgdEGwY4x2BOot4cz1495e0+t3/vUMzevLv0Mp+S5/76otyUUTkAnLq8WPDkWiEYgDVZ4sbdRA00e69QJ0StQOBO6eC88c9qgWXF4aSrPizqzBiXLZ17zVHGLNBaELxEZZdIpaxdmOkXXMRy2jyjEaWcaFMD6oOJiPefH5Y9587TEv3mqZTyqm40M+93r7jvOxx28b/nXS/23/0XWSEuB6AbWLTGL+w8AbwI/tvqaqvyAiPw38cyRrmp/ML/2b+fFf2yUp8zqB1P35tPf6A8BfAS5JReP/++UPbbPuU+1ngY8AfPzjH/9KN7UHcHl5CezP23vF/ry9P+zP2/vD+zlvwzp77PHbDY021X0RrDG4sqQaR1gL3qeoDjWGsi6p65rJdE41PkaxLJZLFpfnLE9PWS1XNG2bGnVtgXUFMXo631DFEozBFSXOFRSF21hWCgYxiZBIpESudWVHVJnJUiHmMfpVomGjnGSoDQZWIhEgaGrojDJUQFxpipRNx29q8hQsSkRsttKUlANvY2oKVYkQND06hylKpgfHzOYHlFVNH5XlYsnDx2eszh8TQ8/B0Q0+/A3fiHEFF0/OeXT/HsvP/xqh7ymKknI8oaxqCjfBGkvfR7rOM5nUiAhd1+ONYiQpTwtjierpu4bgO4pyTH10QD09xneebnnJevEYiSuIa9aLBXVVY+opGiLHzx6wXi+QEKmkYLVqOJrdZjqb0zVrLh7fpyyF6fwWz77wMs46zs4eAR5jlHpc0/ct0URu375BWUCzuiT0HRo8glAXFX3fUMYx1kA9qnF1Uk926xUQMfUUMRYfIkJStgbtMCEp7rqmS5mlxhIAcSa9FpWyHmGsMJ1Pmc9HXC4KlqWjIjDCMC0LKmewkhS2ZmjeDYGgBq/Jh8iKIQhEZ1hKyeMm4J3jcD5mOh0xno6YHswYj6fUkylFUWHFIhhC32PN1qI0hoDvuxSHYgFrMOKSUjLf0MFHjCuSktE4+t7jQ2oMMMZhsClf1TgUyUrGdI+LGKxNal6NyW41hJDrUUCTVatGze5cXbbFNRgx+fNX5oxLkzlCQWyeuVBFxRN8/lypZPtXMnGZGnN91KyqTLEzwadzZl1P4Uqi9Rsb5dTPHFJ+aUjWuzGGnE+p+bjYqLbJzd7krMythWvKETVGNra12/me9HFOBOduduX2OyR9Z2RCU4dnh7aHtL48ZR5hj68MInKDVIt+YpekBFDVRkT+FElZ+ceBX84v/cv58U/vNNqiqsu8/N8A/hXgOlEZSGRo3FnniyLy50h2rP888B/m51vgHTW2qp6LyMeAHwe+ndT0ex0/tEtSZvxjJJXlTz4lQuVHgH8JOHjKtt6BL1c3fyXYj9l/67Gvl766sb8+X934Wq+b3z9Reesmr7/5BsbB4TMv8fDxfSajEVUZEF2DVjgTcWJgNMYW49QBVnwIUwiLi4c0F0tmhzdpL9/g5OYB9uXfRbu6YDo7wc1vJsuKvqdbPsFfCDGsIXpEXbKPdcqoLLDTCb4f88m7a179pZZvf+UOl33JZz8Hl6s1t48KHEJhA01I2ZBDdoZs2LbtIGsQ/GlWBg7KrzzE23SZoVsqKsbIOgRmpuCoFtpeWHfZUFYGw1Zl5pRZZThfJyJRsr//QCCufIctKlClHs/wsaN5cpfJ8U2cWGLfoH6NLeeIwnJ1Qbh8givGhOgIvqGQSExl5pY0yyNLMdmOJ4Q0MA0+kUSqO7rLLQbibpMlMJCUw17rOyncK3Tc7kB0Z7A6EGRGIxhFvKUwS6yNrONBzgGFaXHBdDzH95GzxxcErZgdzelDR+nchmQdrptXw8p7jDFUNegystabTOUeK7kNQBMKgoyZuksWfo5Xj1WTA+4HdWQevBOxIjjI1r1XMzt3CchNQT6U7zo4q+ZlZCfrRfP2ZKu8VYbmwx0V4ebuzFdSFWLPOhZUVJTukhAcDanArm1P50t6bxAbkKh4U1LGc4IB30VseYgNbdaOxkHU+I6LuCEvd2WR15Z7V3Ly+vW//vgu6wMYY7Ld8u4bk7tRwTi3Yw+bOkCrsuClOxM++xYIBkIkoLRdx0duLpkfdTxzYuniDR5ddhQXDaMu8uAi0mqgcIEpkVHR0/WBRgvOF8KTi4gxHd/80RssLy2/9CuvMx+9zfGNmm975QMsl2uK0YjZQcMeXzX4zvz4jiyMrwCv5MefV9X+Ka//LKk4fAX4SRGZAN8M3FfVX3oP7/NHSYToq8AfUtU33se+7rHHHnvsscceXwPQkAbbXsHHgCVlRsZCEAfGlYync2YHhxTOErqG5eKU0DX43mM6T2kMdjJlPB6nGlUMQQ3iHMY6knox1ajGGqxNJMlQhhjNPGHuOt1UwLolKUxWc6bmyExgMNR7uzVzzKq0vAEEjE2mkjK4pOw6pQwnAsDk5sQAmkbympWWogISNnVJUdfY0lHVY4qqpvee5cUlDx++Rbc6xzlDPRpz+8NfT1lPuHjyhDc+/3lOH75Nt1omksZYqnJEX5S0fc90NseJ0PuWonSUVUXXdMTgKSuHKwuiV2KItH2DtZbx9ABXTylGU3zf8OTxQ+g6NDRYgT46gtSM5jVWDaaoKSY1Xd9RjEsqDH2EGzdqYu+5eHQP7ZbUtaWsjhmPZ3TrSxrAVQVaFZiqpr1c0Peem7efoZodJDLbFlixlGWBjx3LywXTcsLk6JhiPMVVE0QMTb/GuQpVg4RUP4ZmBWLQNpF3GpQ+RKpRjS0tfd+l6x6Vpl1TOKGWgoUGprNjpvOG8dmK2i2wYY1zgiVsnI1ElaipkTR4pQsBHxRXlOAMagVvK069slLlxnzEdFwynU45ODimnkxwoxo3mlK6AtGAhI6gkbZtEpFtE8lmbEHUSN93WAtGHCFEfLvEuQIZLEuN0q3XhBAxzuKKbI8rER8U1Q6MI+6QhZvPkTF5O4LNXcjBe0KMmyxLVcWQo28kqS49kRgCzjlKVyFGCD4kF6n8+TSYRFyqgegJJqIhEDU36OYaXdUnstSQlZgQY5qGioQsDFBMVrDGIQs2KyRh0yuQ8mnNlmBMxKW5QkqabBmMMVsnqN2czdTxkBylRLbzFJuGBDbzKTp811xrBH+qodMeXym+neTNqyLyI095vciPH9157ltJN8THn7L8z5EIyVee8tobqvrFpzz/cRJReWUdEfkm4N8FvoeklKyvrffcU7bV8HQb12/d2b8ryOTnLwPf+5T19thjjz32+BrH+yYq7917wmp1Tl0YbDFFu/tURzPGsyPEFIh6eg0E3xPWC/rLU0J7QfQeDQ1+3YFTHr/+CY5PbtHXtzCdw5gDTh98CfPwTUx1Iw1qiakbDoM1FcYoThQhsO46lo9XRDXUpaGqLfPDOfcuI3fPI00QutPIuJTstj8UWrsEWkwddbCxrtwWZFuCZaNE3FHSpV/SQLIPhqaNvHgk+KDcDakrbiA4rURuToSqUJres9Ua6sYqo2+WFNUYawKFg2l5A183XDz+EvVkmgqu8pBuvaJdnuJGY3AjsBHpLymLApsqSmLMuR+bfU0dbCZ39Wkm0nYzFt8xbtyQkrn7due4h+O6yj3pFbtO3bX4BLJ+dYe4goihtmtKs2YZTzKl22PUclCvueiOudU0HDx3i+r+GcvWM6oiZnPd0k4JYEnWJ5MR9K1FNXLe1Ry6lpqWDkthhM4XlLZnVq247GqMyVmZQmKyd8hFJ5LtX82OHW7SOqpeG3mnsmJzNs3uiSQV/oika5AoSaykHJcowxXYnj+Ti4nUDZmLgQhCxBNZhwmFdBS6onIWVcdl14GxFAiuFEzbotalrkxJ9k4aQ/Z6IWfJbP1ndyj7zXXaELJXOqvfSVIO1/tpikuz89m6jusWwqJDN7du9iPmLlYx6R4aPocIaIxMJxViVhxXHQdFi1iDoaA1E37jQcmqrziYV8wmBbdPLLOZ4+efnBHWkX/kj3wPhXjOHpyzXCxomsCrb51xenrOnZsV4j2mgA9/8DlOzxu+9Ts/wBc//5hgLN/24oymt+84pj1+23CYH7/0PtYdOjOfqoLcef7w2uN7fa9/gFRI/h1SVsh7gqp+29Oezx2j3/p93/d973WTf19j6DTbn7f3hv15e3/Yn7f3h/dz3maz2f8/O7PHHu8RnY+4wlFYm8g4Y5lMx8xdhY/QNg3rZsXFG6/hCBSiycaysJiioCoqXLQYU2RVUsqMVDUoJmUglhUihhACfd8BuiEqDYJzjoFk3FVCbX/fuu9sxJJXXoetltJkcpHN9jbDdpIaS9VsaoMYE/GS1h2aNgVjcz2qQ4AFWFdQ1TVVNUJF8Z1nvV5xdnqXrllhRDk8nFHduY2q0KxWPLp3j4vThzTLS7TvIHisUaxNilLfr1HvMVZoVwvadk01GVPFGlWhrAyT8QjnhLZtaLs1DmEynjI9OMa6grZtefLwHqvlGbHrKGyBWEMfPCEo1qV8QmMdgUizOKcsa+rpMc4WlH1H21zQLy8xBrwt6fuWsnIE6WmbBdVoQlXU+Aj4SOc7pgczRgdTbOGys1RJXY3o+hbaNaNJjXN1ykb0AS0ipiypXI3veoQA1uFDwLqKoEpVJRthQaiAGCKhC+m6GIgi1KMpqhB6T+FKRvWYsqgoqoKytOgqEBA6EgluNZNTmixIOx9o+x5nM2loLcFa1mJYdh1HR4c8e+OEmzePGU/mjCYTyroimmy7SoSs/pMouLJO6ta+wfcdIXT4tqFv14ikptUYPOvVClDKssKVjsTkuVSVi4BRgiTmPhGBKVpkaBSOcVunbog5hnxJi7XJrjgERTVZq8ah23io/GM6KSF4WlWcdVib7HBDCGjI7l5ZAWqdoxDNBGSewwkpizXkrmHVmEhKBPVkdWPMETJpzifVyiHP3MTtMQCIwYpNps6DKtJkmlFS84C1NpGVYrlu75oIzWRpu0265IqicqjQt03c1zucnzLXtMd7xY38+O35592wm0tzAJyqand9IVX1IvKIp0eV3H+Xbd/b2S4AIvKdpIZeB/xN4K+SYlgi8C0khWT1lG090KdNDm23/eX24cviy9XNX8k29mP233rs66Wvbuyvz1c3vtbr5vdNVMYgqAaqusJOphRlRT2dMz46yYMcRdUhhWBCGripVdrVgsv7X8CvLjHlhNnN5wgxsLp4wsFkyvj4FpivZ3H2Nv7iMQfPfRBjK5CYB0sGS0x5G8kRJpNtERNOGS0cLzxT88VFYO0jQWHRRkI0CIqRSAyZ/Nkh0Ixo7mDbdpeS9XobG84dBabIziB2k5GoXHYQQ8FLh4bLJrLoPYrFaKAwhhePLU/WSh8UJ8n2MwxkYFS0XzGqwS7vUbVLjHRINDjjeXj3VynKQyS+nrvcDCFcENsHaBS0SLa41gjRbxV6qGI0poGh6laxRx4sDuTTRsE3kFPp3+0AVHc4xoFcjdtBqMhmcL9LBV8deWxpvGGw6sKSyrVc6jEalGgiRh0ju6CQlgfrkt99eMDhXLh1eMb6Ykl9a7whAZNaVVJnIsr9x+c8WQhCg4gSYslFb6hH54RwMxGhGmliSSkNc9ew8BWOiFcIkgjdCBgM1gjWKMZA41MLo0Hoo8cixM2RDV3GmzMLm1d3DlpJeTB5KC9GCKTOyFTkpy7I5ISqG2VsRFMhkZbGQerkxHBQ9jguWDdwVJTE0GMlUuJxeol6wXUNnR7Qq2BCj7pAxGA07Oybbsj67R5v1Z2b53bJyetH+C52Lu/2/Oa9SYWZianwu75eyuJUoveIRIw4okRMCLRRuHz0mFeeW7Fua5ahJkrBh1+YsFg1lKs1vV/y+J5ymju/ywL6ztMsV/y1n/lFJFjKwmGccOek4iPPl3zJFXz4g7d4+xEsLjpeeq4ixBF/7a9/MdkXdZZPf/ohz79w9Jsc2x6/xXiSH58Dfu09rjtYtz7zLq8/e2253fd6L/gzwA+QbGtERP7krq3OHnvssccee+zxOwfeGJyrqGeH1KMJqsL6csnF6RPadkXXrPA+5QeqNQRjoO0pypKyVIwrwFiwyQrTWouzBcYk8kONTUq5GAi+SzWvAtbmwtbgg2A01UtWZENKiBhEsvoyVz8JWyIzYUNNQEqSz8/bXCMPjY1ZyaYRyTEnxgiKScqqrLAUm1qIRYXSlhRlRVWPEBtpm5bF4pK2WeH7HqMwqipObt3GFI6L8zMe3n9Ac3lJt14RfEOMPcYJairKmNSC6gNtdhEKElJ+X7OirGoswnQ05ejGMaqRxeUFfddhnGEyP2A6P6AeTVhfXrB4eJ/14pTQLTEoqhZqi4mR4Dv6vqVTYTaZ0jZLsEI1mjM7PCEY5cmjt6FrKKuaaEtW7QJrBFVHu04WouOj2+maYvDNGh97bjxzC1uUhExIu7JmPJml69d3VJMxGiIxWmw5oRrNUFPTND1tv4Zc8xYRyjLZoI5Gk+S8FMH3nt53CFA4S9d7uqandDUqmu6RgaCyhmpUUdcVo/GYy8tzQq/JQjUGvABZkdh6pfVJzYpLP9EWtK7k4XKJOsvBfMatW7eZzmcU9ZiiHmOdoXQOVOnaBluUKW+VrVJTRPBdz2p5TmjXdM2S4MPmftbsiLRcLKjrGsQQo1CPJpQywroaVJKSEVBRQswtubt97Jum60QQJsJyOy8iNvlihd2JDUJ+PTXaR831PYqPHmsTMRk1Rb1o73NzfFJulkWRiNmsYPTeQ8iZlrqdcYgaUJ+doIZpGELabqIy87wZ2LxtMXbHilZyHqfkXFab7HDF5UfJGZbD8sN3xM76ki2byarLzRxRnnOSqydU8vfCO2cO9niPGGrQP6uq/857WOdYRIrrjkEi4oATEql4HbffZXtDnbwbefLDwAj4flX9+LX3+PdIROXT8G43xLDtL7cPe+yxxx57/A7D+yYqbT1HEMp6hEYoRhNsWVGWFWJTF6XNxEcsDM1yweWDN+hXC0xRcvTcR5ke3sTjEZTD42e4PH+b+1/8DIe3X2J2cJuuqDl97ZOc3PlGZDTJijefCp0+Kdc0FzgqCsEzn8OqFS7bHh8TgdWFNGhz1mzUgbpDqA3kkjXg+0DvA87ZrbVFVnTtZlJuCEuUGALWWIImi5O7l8J3n1QsDz2feyR0MaCi3JxYXjwwvHWaMqRrC2qEVRcICnVhmJctN298gKJ2tKsCsVMeny/Q0TFTKtrVI3Al9eR21pQJrlsjtqQmgAn0bZcK3GiTreqGZ9xRAZJsXXb/Nkletyk7FWDnmIcztTFu3XT45eWzXedQuIpuFZdJeKib8javiYYlhT/jkufBKEYUYkQ0clSfc7GyXPTw4O4jHukZ7XrNZFrl7QpIYJcMVHWMR2OiNdyoSi4vlWhg4Q941j9gbQ8pSAWTdELna6pixUkdeNyMMJLPRyYrRYTSOpyxqYCJmvM/Ad3muyQyeCdPckcxqpu7bHh1UAYKNiscRVKncUBThozuEOeD70o+72J6DoqeSMQo9JJsX9ZdTR96uvVjKuews0Osrimrmi4IhQakf0LwEwRPH0E2OTJ5367kQm6PQgQI5gAAIABJREFUYag1lG2BsSEpd+1uhe399Q5b1+Fe0d26ZdO9HWOyyUl2NfqO1zfvmbtsVVJxiSpiDbdeuMnPfvqcPiYi2dHw0a+7wd/51XOCOJ6bN5wvDE0sCUEIGphE0D7w5LLAR8eoinzLR084P1/ziV9t6OOENx5f8vKzjps3xnzpgedTv3GBhnTeho72hxcP2eOrBn8b+L3AH+K9E5WDfet3iYhTVX/t9e/Pj58EyNkenwa+WUReeQ/2ry3J/vWngH8RqETkTzzl/fbYY4899thjj69x3H72xdQk6z0Xp49YLS/wXUsIASMGYy2OKtsyJncYjUrfdqlBz3aocdi2Q6RIWZSuxNoSrICkutVbR1Ur1iRXGRGXs/G2VrDGDjl0W8vH4WcgYzaE4zsaFbdPXX1lh8zMXbBClm1phDgEf6Tq1ViTbDirEmcLrDGEPrBerlk3C7zvMUYYjSfJqtM5+r7nyeMzlpdP6Ltk5Rmjh8JgTIlVhwuBED1RFd/7bLMpGDU4W+DKkno85eT2MxzevoVzlkf37/Hk7DEGy/HJTY5unFBPx7TNirff/Dzt8ozYrwntmuh7ur6hrEb07ZqoHhGoqwnVZEbbdZiipp4dIcZx/viU5cVDQrtCRLlE6fvIumkpC8ukrhlPjqlGY9qmwYdU1xajCdP5EW23pusaxAij8QzjRkStACXEgFJhS4M1BbgKtQV932HwVDY1tIq1VGWBitC1DYuLc8RayqoGJClAfWTV9nS+ZzwaEdTT+0iIlmTqI3S+YzSuGU+mlJM5i/g2pg+IMVQmUuQ5mWAMy9AT1VIXBaZ0RGfojOWsj5y1gRfuHPPii88zOzhkPJnjqlG6bwyIK9M9Gj2h7wkCIQYsEGOP79Z06xXriwv6ZkW7WhJipK7HWOfoY2A0TucIBWstffCs+jWhN0jZU9iSwiTSPql9h+bfq9CN1armcz5wPILJES7W2kQixqxjzBaw6YNiNgRjckiKiJHcAJ/mFYLXNKdggGy7WtoKWzi6zmNytmYM5E+PouqJmrJckUxixtTerBqyKjJnzlqHlWKHkMyf+SGH06bvH+t2iEiblZQimyaG7XfElqQc5tCyz9GVeZ7NE8P3RfZ/1eQP/V6+Pve4ir9Lmvz67vewzi8B/xDJkvVvXnvte0hWsp98ynovisjLqvratee/b2e7Az5EUm1+/Cnb+d73sK8Dhv35XuBjuy+IyAFJpbnHHnvsscfvQLxvopJyQlmUHM7mtItzxvUEy2C9mVSGUaBfLzh98CZ0KyKO2c07zE+eASwRj1GLGCAGJvNnGM2PuLz3FotTw/Htlzl66ffw6Euf4vDwJdz8JiYoQSOS7TJ3WDLa3jMfFTxcWtqQuuMQwQMahmxBQTR3uAlbj3xNnJfvGrquww+eGCK0qwYFRvUMW6QCLESPKIQQUqenMbjC0XcdOp/w6Innm24bXrt3Rt87XDnihYOS0UhZ9IqVdH5EI9MCChFGhbAeG47GFRctrFtLiAuiKZC2pagPcLPbNIvHrJePmR5+AC+Gwimx96itUZTz04dQzSkmo2QvEtOx932HNS51lYaIGLMh32IIiBicc5t8ko2O70qRmkedukte6tZCVtmQnXKVjcoWsGkbKSNUqLq3cPGMeXnKqKzT8DtEfIgc1GMuzhfM+s9z77W3+I0WVosVzkY0Bowx+HC1pDBGuHljxNwsOX2y5LA2GG2YFA1F0fGR4/s4AVdaQhDWveB9TxsCi77E+7SLqZ84qRYrEymsofW54EHoM/04UKSKbloJ05h8ONar2tLUYbglbK2AIaaCxoLkaxU0Fy2a9yYxlrnosKz6ikYrQoSDUc/jVYGGNePSUhTPsgoW13gmtbLuR/QxEIpblPEh0ZwwKt6iM4EQ0yREsmhKHZtPw5akjNuP3K7tbT72IftVc3G4W/Lt5m5e23omKVPeR6q6dmyDYZN1s91WUkun7wGDR/F9j5DU0wH40IsHfOGtJW0fMCI8vCy5M/XcW2Uy1MKNckzXrCntghduH3M8H/Nrnz/j9NwTNWBU0OgxxYTP/PqCo7nhO75xzhv313zp/jp9rxj+P/bePOa2LD3v+r1r2MM555vuvXVruF1VPXe721MSO5bBQDrgBCEGSxDAFgECKCQIEEgI8U9EhMQcJASIMaD8gSMZBUgiIyWxUITjDBZtNW7b7W53t7u6q24Nd/qmM+y91/Dyx1r7fF+1q+N2BRSndZ7SqfPdc/Y5e589ab3reZ/nQXJ6j991wN8m/DfAHwH+mIj8RVX9wu03ReQDqvrGe31QVd8QkZ8BfhT4N4A/cetzPwT8BHAO/O+3PvZfAP898N+JyI+q6uWtzxjgeVX9DVayqhpE5McppOU/QyEr/+lvkY15wAEHHHDAAQf8HYrN5QUpBebYB2dmjxkFYuHzTN7bqWYUVSElJaSIMpEVrPVYHGpMUZtZC7PyyTravsdag3OepB5P+YwYg/ct7hZRAYAIVkptWyITpDRC1kbT4pBUFi3E560a8XaZV/8tgMqt2lFKw6VSI1SswzUNvm1Aaw02jIRpR45lLO1bz8mdM4xUG9btwOVuwzQNpFjUh8a4oiCzgmYLqSkWnDZhciKmhBCJJiAK1jYsFkfce+lFTs7uEVLi2fklV0+fsttcs1wd8fIHP0K3XLLbrrl4/RsM20uMBsiRGAIxBPK4Q6VY8DrrUBwxJnbDxGb3hLP7L6EIjx9+g2lzTZqKMrJrPcN2h8aMGsPq7JRuucQbxzAmxrTFGIq1qnW4tmOYRsZk8M0xfb/AWg/GYWxRCTq/KKo4sWSUMWayeHy/LMcjZ0QVlZtGUes8jTgyME2Jtu2KOtd7jHHEmAnjiEHw3heFZI61URYQ5ezOKY8vnxGc5ckYiCly1lqWrhBc26BcTYll05CcI1pPVLgYIxdTpu+XPH/veY6OTlgsj2i6DpViKWp9OS9DiJVks8QwlVzKlIlhYrs5Z1g/I4xrhk2x9A1TpPUNrmsQLcS02AbFYn3Hoi2EYSELI0kTVgXrPNZSvjtGci4+Rjr/p1RFZTmnY47sL1tK/WxLps4tG+Oy3yUrSFlnSqleblLnycDYYkcrkijqyzIHIllwtsGZFtd1BJ+IMRGmQKy5mKk2MpRczUzWWCJfNUEuaudsSxbmTEZrrZtNfd1YKapQIxhDbWgox3lWWhsjiKlRNEZqNm5pRN83JEhtYa/vzc65pjb676lLZT8XdKAp3z9U9ZGI/CTwB0XkjwH/gd62ogJE5CNAvpUv+T9RiMr/UER+j6pu63IL4D+qy/yP77E6C/zHIvLjs/OPiHwI+NeBCPzPt5Z9DfiEiHyvqu4zJ0XkXwR+//v4qX+OUnP/hIj8l6r62Vvv/XFu2c4ecMABBxzwnYX3TVSOMRHTxPLsBZ6NI6tuQUqxZOlZRxx3XLz1OlMcMCK0yzucPv8K1rlbZIWgRFQ8iEFU8dpx58UPMY1bHr31RY76u9x98L1cvfMV7HbN8rlXQCJZ50y4QuCICpoGTlfC67tMRPcFlQJRBM1S8xupasJCseVcFJYxBYbtFnLpbm1aT0qROG7JORO21yCFBIlJi+otFxtOax2mWuvk3Y6/thP+6O9t+Z7nRv7PXw6ICN/1u0549rTh8gL6pmG9SzQm8eJpz+nCs4sTvx62fOXRFevNmmnziEW7wPWntKs7DMmwvj5nt56IA+x2v0yUJeHqCUt/QnRCJ4YxG4Zph+v8nmGaScMQi8VISomUEm3XFTUogGZinEp3XRmxklO8pSQtezzGG9FPyVEsliJ7ixSohLCSqkpu7uLd28ZWCssZhfZjXEjL5WZEyIhElrJhGJXT44aTLHzPJz/Acbfmja9f0XohVSsb9CYFEsApWDGcHRnurTrWV48wbcvl9YBO4LcQowdt2MXELnmUnhdOLmi05ETqXJwDrYGFL2ThkCLWyD7CstgqVZ3oPuNx/p+iNVMDciHy0GqaZEqxXo+NseAETCqD+6hlcuL2VTITxoaybDQGYua0j1yNgs0DyUTWscebTOczu7jg/Px1kreIHGEwpaPZjuX812qaOyfc66wRvsX/31LhznGg7zoZmD+r7359VlPWwo6atXk7i/I2aTlb66AzITnb7fBNy9y8kOfzqJ4GU54QI/WchZdfWvCXf/4tUEPSiXGyPNoY7iwCj6MlJ2FSTxbhuz5+j/MLw1/9lUuc3vSSL1eZl+4f84WvXJNi4smV8NpbAx98acFnfvdzvPF44suvnXOQwf32gap+QUT+FeC/BT4nIn8O+DIl0+MHKdY2n/mbfMUfAf4q8J+KyO8DPgu8DPwBSm/CH1LV61vL/0lKV+sfBL5c1/cYeAn4vZTi8I9/i21NIvLPAQPwLwH/m4j8E6o6vp/ffsABBxxwwAEH/PZDzkNtZjRYC84bDI4YCukQo5JTJkyp1jilYbG2jBJTJKhizUTjGrwtFpHeWNQoSgKFEEeGoSq2BJx1ONcU68aZXKhqSvZRD4WMKCopU11rZo1UJVf09nMZ5s/5l4qWfkUpoSmz7HKvvHIW7yzOOIyxhBgZNrtiw5oTguKdxy+WtF1HjJnr6yum3Y6cAinFm3rTNiQp9QzZYeY8vtp0qzmTU0BMLHa7pqdfHfHc8y9wdHqX9WbHN15/g3GzJoeRtuv40Ec/wer0hGePH/Hmw9cgR5wxWFFwQsq55PIZj1+2LJcrrLWkMLE+f4cwDHSrO9x9/hUunzxm/fQhcXdNShExDus7rjfrkqGYM03TEHY7tusNKSt9v6rWnMLx2R2yWNaXO6ZpR98vEb8kmJYhRqYwYaU0IXvvcYuWxtl6bIurktiI7o+3IaVMSuW4zE2picRqeUTrW2JOJU4nJZJmjGtwrmFKgZADrmlJU6DrlnjfE/JTjlYndEenvDk8YQqJBGTrGFLk0WYAFRrv8L5hk4Xz3cA6Ro4WCz7+4Q/y8iuvsjw6RVyLsR5jHSFOhBBovCenwPp6vVcsarZoSkzjjjQFckw4a3EOxFmWRx0xTcSQEONJKePbnqOTU4xvMa5BrCVpBrFY64tBbEpY52iapigvQyCGVBu5y6k8N8vmXG1gK0lYzklIIoVgNQ6ppCA5QS7L3eLpyhxJVSpmEsaA8a4sp6VNWrB1rqBkY3pvaHxLajJjmAghMYV6XcRESqEoi1WKJWyO+7kGZ1w97nOzb7GVLdbRDmNl/7e1BisGu7eJvaXCFrNXgv5GNaS+66/ZQavePG41NZf7jznQlP9f4F8FPgb8exTC8ucoWY4vAd9FqXd/HPgagKr+aRH5x4B/EvgVEfmzlCPzY8CHgJ9S1Z98j/V8Hvgh4BdE5C8Bp/U7ToF/W1W/emvZ/5xCSP6ciPwvFOvWHwB+BPgzFCehbxuquhaRPwz8FPBXROSngLfq93038LMUNegBBxxwwAHfYXjfROX6/BxrhCE5rp+8xbY/o7necXG5obUJGXfQNbS+4+z5BxjXkWMkG/OubEOjAinVIUulBzI0vuP+Bz7OcPmId77+K5zdfZUxXnL+xuc5fvBJjFRLGZW95UUeR/yxZdgFtK2B8HNhlXPNpCzFV6rB5zf5A6V7L8aEaqZxhqZp8HZJax3b9RU5RSypWH+KMobILlWLzpRx1iIkpjzxzjPPL3w58ff/SMuzix0XG8+rH/X84t+4pMkGnxa8eCa8+lyDEPjqOwNfeHjBo3ciyb+BmS4xYtC0pJdM30VyjBgVfOOYgmebjliwJukGcffoHEi44tn2EtcsSV0oWQgIKkLjm2ITorlkScTI3LfrnRBTGfSL5ErAGkJVi+Ya7B5jZBwDKaVKztZBZw2+b9oW50tWSYwRzbkoH2t2hBFBxUAKpJhxVtlh2ewMoh1ZEqvG8WQUThYTD69XPB5XfLR7ngdHDafHF3Rtw9WQmKsIybnYo2op5p+dr7naRIxb8sb4gDQ60MCHzNd5eH3Cq3ctF+sW3yS2Q7H79cYAEYNFVTBVEbzw0Llq31tSQ4pZcZ6LiUpYp4hBsdYQajGYs1b7WNBU8iWToUw8GGi8x4qwcErr4XxXyErRouZESn6p7hlCobWZ5++e8Y1NZtUpuylhQiKLQ3VZqP9kyWo48plxV/JZmi4zpUQyDUZ3WKMIIyIeo1rzNWrSRCUDZ8WiqZTgDSephJwQlbnmIGXd/00tgt9FRKZUW3HnIo194VINnOukTEZuFzx1RmSe7JhfK/skoerIWpJknzzZoalYML906nh2HdiMeU86J01cj4I1HWfLLeux4d69nkfvKJ//4lOudi0GS6pNiS/es3jX8ytfvcSqQavyMyX41a9d88VvXPOhF3t+39/zAucXB6rytxNU9X+olqz/FsWe5seAJ5SC60/+Jp/9dRH5AUrWxj9UP38F/AXg31fV//ubllfgnxWRvwj8YUoB11KKqb8C/PnfZH25FmIDpfD88yLyY6q6+6385gMOOOCAAw444LcnGt9CzsQQSCEU4kBArMUoWKNkMUQDkgsBUgiLapeqptTLOWNzRkwix4kkxfbUuQbrPMY3eFdIzNL0l4pdiyQ0T8RQSIhsXc2oq3avtT5UKAo8am4e3CImbhoOZ9vH/RheKqmpVNLNYL3DG7MnhMZxIoTI7L5irWWx6LHeoTkTQuD82TkpTHtSCDEY48q2qZBRbM3wKwRMJYQExORCDgoYbzld3OXu3RfoVyfsthtef+01Li+eIimzWB1x9sFXcK7h6vKKN3/1C5AyxpR6y3YWNRBzwtsGoaHtjlkd30GMYX3xiN32Erzj9M6riLQ8e+sbjNsLchxQ72m6JTmVzNDFclmdYhI5R3YXW1QcbdexfvoMEeiXS55uN8QUsc6zWB6xHgMia5quZ5rG4vZiHIhjeXRCEiE5xZjS9K0q6JRIedzbdMaYa4NyLkpU6+hXS1RhvdkWe1yxheTzhhQzcb0pTcdWWA8DKWQWyyVJRxZ9ywv37/Ol177BlBSs0IhAgstJuZqgd4bzoFxJ5nIIbIaJe6c9H371FR48eMBytarbq8SYcJjSUEsmxkzjO9zKMo6F0A7TgDUZyQONBekXTGOm1ZbGO5q2I04jYRyK65UIqgEl4X2D744wTYNiqC6upS5OgZQz1jqstbRNV5S4KVSSUvfPKSWyVtVlLspJzQoGMpZstM51FBtmFSpxOPsLzXWz3LhXaVEcO+ery1dtFqg5l6nOCaiCsYbOdjhXiHMzjkwxFOcwVXJMezXnPG9grKnfZwopWhuHjRissfUe4DD7jEqLEVetoatSe86xnUXScz1+25Vsf6ebXaNuvXJLgaki+7mCA94/VPVKRP4+St35E8A/DnQUsvLLwL8J/Mw3fezHgf8L+BeAf7m+9qvAf0ZxI3ovnFOiVP4T4A8Bx8AXgD+hqn/6m7bpL4jIP0Kpn/8pIFFsaj8DfJjfIlFZv/PPiMg/CPy7lPp6pBCUPwz8OxyIygMOOOCA70j8LRCVj3FGubi4ZBw2eNOTxkvC2rE2ZcC01Bexi5b47BrVS8I01sGQYbHo2O12LPpl6fTLCe/LILHxxRLGiLI4uke7POP86UPylFgdP8fV67/E8fOfwLiWJIrRYmGa8wYDDCGC10pQ1GJKlFRoGABSLIrCMpoqS1lr6Rc9AqWbTAwxZ9RYbNfDNGJ1ojVK2zj6psGLJURhPQSuExi1dIslbSN85enAP9Ae8Y/+iOf1JxPHp0eIWfPJF3o++ZGe5056vvpG4ue/uuNLb19zuRnQvMEmy6igySI+46YNffR0pgdfLFAWbc8wDoy6xEniqBlYtM9xfl1MSY2ttrSxBLeL88TakZpzxhjB+5o1UAe0jbWFZAKgFoOuEFSzRZBzDSGkYsUzDqiWjk7v/d7WRLMj51RJ0puxaK6FJPuitqynsZbGCEnA4+jNhuu8RMwIaoo1KkIME943hGGH5Zg5LB7KIN4awCRynvCmx3ghpFi6enNAsVxNcD5EVo3gbccQd0iMdNYUMpGMlaoUFVi1wlFneLZOiEl4EYYhoimhWW4mGnJ5JgtGMxoCmnLJfxEtBYFADJExJsRAngymsZy0HUO0nHSmFpJK0Dw7qDCnsRoBZwQxntaM7EYlB0OwC1QNqqnaGltEYBOVhRFG6Zi0AzPRuh0aDWjASCYbRSnk9F6xWJWVzijOlm5MjWlvSRur5UxKpVvaGoNoroUQVUUby3kkddJCzI19a53gqNzovngzYlDjynxIVsr4dt6u+XlWYppq3xOKnDIbNusJXIduM5/88IrPfvFpKQ5lImGL3VISHqXID3x4wQePLa+/GXEGUogYbUEiVuD+85ZxNLzzZMCKJUt+V1ElVSj79Ycjrz18yEvPL97vrfSA/5+gqn+dUrh9q/df41u4D6nqQ+CP/hbX95OUzMm/2TJ/CvhT7/G6Av9afRxwwAEHHHDAAd9BCHF2DYEwKTElrDW16c/QdAbrDTZlNBeFlVAb/HIiWcMUIjkX21iR4raSc0Ryqd+MCI1zdG2L73pc05amUlNsNaGSkZUcMWr3zimF9DPVGGZWROVKd8BMUt4Mm2Y6onrkmKLgMrZYhqpAnALDOFW71kLqiBG8b+j7DkQYh4HhakOKUyGAtFQ9Yko7aE5U0kfIdY+o5NJYmhMpV5K0xmoYY1kenXB2/znarufq8orXXvsq43ZDDhN91/L8Sy/jmp7H7zzi+vqKOA1YZxEVcjZ0fVPIJiKtazBicF3P8uSUGALri7eJ05r+6A7d4ojN1RVxfIaYWOwznadfLgtDkxLeHZFScSQKTKXZt1uyWCxZnz/GqtK2HTGM5FSaPUVgfXWOZsHbljAsydZju47F6V3Q0iQatyPX4xUgrI5OcG2H9x3eGqZxZBwGmsaDCE3nCbG4Rm2uN8SYsWJJklAVVosjNCm77abYz/qGECONd7hVw7ibyCmyPFoy7AaeOzvj62+9xS4GzrNyuRuZpozzLaPA40kZpx0mZx7cO+N3fvrj3Du7y/LohKbtipWoFttSFYcxrtSaWSEmrLP4donNgTBl4rhBU0BEadoG74+IrS+OTRga02BNwzRusd7RLnpElJRGiJ7W+9JQbVtSzkgY2Y0DSTM5xkJYGofzDuMsEgKqgZRuGmVTKspnav1fmnNLTAgmQ7ak7LBSrweENDfjUkh8TDmfSx6kQ6wF6/DWFuWi2NIAILbU1LnYwsY6X4YRvHe1aV9RIkFjdfcpGZVGBCPUuYPbWbSlbje2WLlaa/eqSakNAHNm5T6vcs6jFLlpNJ7tXr/pjvBeZdVc79/YRr/nYgd8C3yrelVVJ+C/qo9v53sy8F/Xx29l/W9SIkq+nWV/Gvjp93jrZ3nv+veD38Z3/gy/kXQF+Ofr44ADDjjggO8wvG+iMo4jrRd266do3KHpGY0VIguwKyILnq23cL2ma3p826ApEZPirGG32ZBy5Pz8EhSc87XrL6GqtN5x9/l7nByvyBmO77xCildcvvkmdnHExdtfxPb3yOYI64Su8Tjp8EZIsoKYSTnuQwRTimQUZ+x+oDQMA+MUsM7RLxZ4Z0s+hymE0W6KtRBIYBzNosFbMJrItljDHi8dXd7x4DhzunS4tuEyNDy7ToTR8vTrl3z89/8wL+52iHmHT3264Xe/sGDzZssv/NqO/+d15ekW+n5JShPrTUt/7yP43Q4jhr5zLLxgc2DYBXZjYjcEVBNWhN5monhOT09ZtYFH2bM4WiBiCHFiHCdyysXOJCZK8kJR8zlv6doGa10tNGt2J1S1KXsFKhSicRhGQhj3lrc5KyGEvYIyxlhJTaXvu5rLUMhS713d94UMtVZwAsmA2ozLhrNuzcW4xFvlwf0Vz15XkiZEFYvgTLGjDWkqmRYIOeWi1NRScN05ahGN5OBIww7jW1LMoJFxO/IwdHzvKxN5iBwZeJIC1gRS2qB4snpyVqxRVkZoUMYx4lBihjBOpZDMoJpKwW9MVe0VYtRLIU8LNa6QZ6tbh7qi7ktJudwGxpCwvuW4M7ROmJLU5Yu3kuaEGIMTpbPQOmC6Zp3uFN9Yco2ILF3LxmQ0wWqpOG3p8khAiFg0HaEyVluYEXD1WN/kP5aomvK7coKUpXSNFrEzIgbvAE1FaauKd4WRLPkeaU8uQj2PxCDWoLXTM2edGcxCQ5d2y30mhrhi1ZxTIufAPvNyflCvbRXEJo6Pe5aLjntHpnTiiuf8Oha6XRXRYkt0/8jywVd7njxOvPV0JI9TJd8HkBWNBJ57vuHi3LAeIoiWiZy54WFPjM9K7oAV4e13Nu/3VnrAAQcccMABBxxwwHcwhnFXLCXzPPwtnXp7u1WxeG9xTS7j3ax7N5ucCymQY2QiMyXFoXRSLFV92+AaX+1d2ecWGuOL0k5taeoTg0ghC121cpRKqDCbNmqa7Yhu+ZvMRA3M4+D5/8YarGlK3p4pKrNxnMiVnKQ6rtimwTlXFWew3ZbMyVJr6N7mEmo+vebSkFpeKmquEpJI1vn9UjskVZxzdH3P8ekx3nuurq546+HXmMYBUmTZLzh68UW6o1Munj3l/OuvE+NUXIFsVXvljLcOo8UNqO0aRGB1cpemX7C+vmB38RgxmcXZ86DCZn2BkIslbYjQtpyc3ilWptNI4xumMTKGNYihXaxw3ZLGOi4ev4NtDU3bYmxPYz1d0xNjZDtsIUWmcccubLHtjnZ1xt0799AUGLY7cswlY9A6jGm43q4xuy39YllUrBmWqxVJFZNBxeCsYxw2xBhKT6hRbFvmAYZhw3Y70LYtxliGGLCmEN/r9TXTFGlcw3a9wVjP2dkJy77n6jqwnRIhJSzQIUgV8h43hg8/eJ6PvfIyL7/0AOdbjPMohQizps4LqCJSIlhCmphCqs2o4LzFYDF41LbgbPlxGHzTIFZJMTONE6bxNGaBca6S9KVOzmlgGimNtO2Kpu1ZNCus8+yGgRBCcdaSvCfonCum3jTWAAAgAElEQVTbKALDUBW9uagr59p+VhwX86Nc1ZaZJDMBKIXEr9eL1KYBay22EpXOlXxQ4yzWuUJUVutnixQXrJxRieRY8i5jhoiA8zRarh+jE1OGkGqtai1iCxFqrcPW68/O+8aV7XCuKCnLHJgtcxrvcjOaa/Tbd7T5fjFrN2/e3BOX1Sra3P6wfvNSBxxwwAEHHHDAAe/G+yYq87TBOIOzgrYeZ3qCXWGaHskOS0KNwxmDc4YQptJ1lqWquNhbMoox5BzJWvMlVLmOgfTWY4btjqZtySEgrac9e4FpuuZqPWCefgma5wjNEYuuwe7ewbwIbz96TDZrUkw3ar5KKJmZbqhjppILkrHuErfvKCtdj1l1b5EhInTesehbVqueYYxcbrbI04TExBdc4OVjz3e95PnER474e39XT3Nk8fZF7OmnyS98H0afcv/4/+DJX/sb/PTPCb/4JlwNE13fc3R8l4tpZHnyADTgzMTy5D7eeJZNRIcNSUaiCKNOOGtIcWA7Go4a4eVlYBct4xhJXaTvVxhnSSkxpsRQB+EqxTJHg2ECgndY4zHO1WLNgzWMUyx5FkDTlG7FcRzZbjd75V1KlajKkRBGQIjhxqJzt9tgjN1bpjhn6PqeRd8VSyASxiS2j7/IyfKIlVmTY8ddt8L5iQ8894Avv7XDqHD17BnD6RXGCklbhmHNYtUXFaGUgl6spz+5S9ju6FcduyFCKlmqOWc++updLtePeHaZeOudjk+/sGXcbLGLu4hYWtMyZiXFkRQTbaPcbRrGKTKMCe8cu11gmlLpnkRQEjkLZrY9Ea3WKIq3QtZayFjZqxZjtdAVsWRgExJN2GKycNR5vHgmzaBCmiZizGAsfW9YNp6QE1k6WqNEFaIKIpEy+jdohqOF4K1hCA2NGck2kCIkMiIOVQeVVM2EUu/BTVFyi2iM9d8pzzT3jX0wFOullOaCpVjVlImOWqSgaIrVdng/3VE+L0Kd2QC0dJUK5XvrtWgMkHPZxqq0lJnENZDVkXI51604PvXqEV/8xtW+SQEsrct8+EFPyvCLv3rNmA1GMx++7wk7GMNA3+84Olny8K1E1FJso5kEGKnHknk/FXLXUYpWPdRbBxxwwAEHHHDAAQe8BzRTlYdaamPr9zmI+7iMeYxcSRuRkvlYXFVKfpzJqTiUGEOkRDe4SqAYAzElxikgNiI+oupKraJaamAxoKaqKrlROs0OKFSF4qyqrM2ns22lVnmU9x5rfanxNBNTJk+x2LCq7lWQTevxrUfJxBAZhm1RWMZUSBhVMFJJx7IvJJcYlpkEorrwmHmDZ56IjMWxXCw4PTlFxXB5dcX11SPCsCvRF85z56UXaNuO9dUVb/z6Vwp5qbnIzVQxClCyC1Usxjr6rsO1DUd37pFC4uLpM4bNJc419EdHkBJpu0awhJwJ2WCbnkV3B2c9YdzhGkPICbWGfrnCuob++IwwTWwunpU6x3U07RLfdCiOFCMxFleenKFfrIBMFstqtSKFyLAeAUVTJo0lfzKjtMslq6NTphhBHI1vGLZbQhyYhl1xWTK+HH+Bru+L0k6FOBVrXuuERGYXRqbtjn6xYrNeYw34puF6vSaEiZQTMYzcOVlxFSNP11uyGpwY0gSdsywbePX+HT71sY9wdnIH6zvEWTAlskdyIcZUEikHUg5YI3jrCrkqhmHcEANYUyatXNMRdULjhBUPOZEolrUOJUfwnUewpKzkmLGSsRIxNpI1MoYdY0xY53FNw2KxYLcbGceBlEoMUDn1Dc55mqYt5yCmugYVO1fmJlrJqBFSvYCF0heggMXUWB2p8yw32Y/WepzxOOdL07h3WFNsV0VubGeTmuLchCFrIGchpYzG4mBU7h2KcxbRBleV2mZWS1qLdZWstL7kUbqybrFzHqUrRGW1rX23evo2EVm2o97VuKnqS3ODVPejd6knZzbzQE4ecMABBxxwwAHfBt43USmawJRw85A9jV9Ce7S3kFEVbLWkiCnvVXnFkjQyjjf++czqrXxj7aia2Wy37IYBXzvAxBi8d2As2d8jqWDHh9h4xC49TzMNXIwj6+uJJJG5M3O2uxDDPqeSuj4RivUOQkpKSlPdVqk2qcUG1hhhChNZE7txQGvovJMMKbMTuN5EHl7s+NzrGz51z/ODnwx87Pd8F9p9GmNWqC5AFjy9zOQ0cbdxjENie70jcsVue8Hy+B794pRt3DBsHuFWL7IeBpYpctwWi04yrMNETBZL4k6rvHSW+PxDh9hMHEauxoHl6RkoLPqeaEdCLY5FE1T7zjxNBInkSaqlSCGONUOMmUxGxNC2LXG2y+Um13O25AT2SjpTJHmFBDN1cKpKyBBCYNhtsVIUlS/fTzx48S6/+PXMKyfHPN6s6BY9kuHhw0um6JGccAQgIyKEGNleP+P45GR/jiUFsY7WOR4/elpIaTFkSXX7lK+/ccn1tGSjylffyawWp3zy3nO025FFN3DvuGc3GK4ls0nKqoUXTw1ffCvgTaSzwpOQy3nKbDFkMEarzUohtMSU/WPQMgFhDSFnUswEzaXLtSpVlWIdExB2k7LycNwoY8gEqXZPKZHjiG09C98xBGETPH0TmXJAUkdUKRkWOdO1yqJxnK8TXSPEYGnYoeKxJhHiRLRLJMeiAN0Tj/XanrMk6/G1Vvak9HxdlPcLSS1Sr6v9a1VFynwtl+Jllune0H1AzojorS5ts7e7nS2gDEIWA5IRo4gKqlWhSckB3Y5F5b1sHcu24bOP1hQnY+UjLzbcPen46msD55stiCvEshi+/jRy1yhpN9GeNbz5aCzHRii2PAiQKzF9s+WpTqxkrbY7+V2/6oADDjjggAMOOOCAA4CibEMT1pRaWHIZ3xoRUg6wjUxTrI2yILZmMNaxszFC23rsTIA4jxFf7VETSkSsYsUQU2k21ZT3n3cipd6dSUlRqI41qraOvWd7R1NLZVPJwaLSxBicKSqxHEu8SKoNxiqC5uJwU4gYQ9N4clSG3ZaYQyFrC2ML1hSSsnC3tT4QkgoqhTwRzVQvl/04W6Usb5zH9y3LoyMQOH92wXZzTZpK/qfznuWdM45OTrg8P+fxo9eJ04SmWMf2tdFSMzhbVK1W6Pue5fGSo+NjfNPy9PETxt2arAHnG7qjE3IcSNNEyMIYi6NNvzotOYM5MY4bQhoxGFIouYGrs3sslic8e/qY3dUz4rBDFdr+CGk7Yq05bNehrsG1S9q2raRgwIgnTBO73Tlt15NzJMUS9+KMIabMuL5iXF+QMbhmQdt2gJBiKso+EWKR69I0DTkrwzSgmphCZLk6IoQJDZFhN4AVrtdrTk/vYFzL5nrNer3Gd54YIjkpfduz9BvWIoVkNMrSW+4vel48OeG5e2ecnd6h65e4tiVr2pPxKQYMYLxnt9vinWHKoezHBILHuIaUAzEHQgy4Gm1jjJBIpDCgOeBNUduCRXNxxzKiTDmi2RaFckhYSVgSWUemOME44lyDtw5pO8ZpYgwTKRZl8TiNWOvwzrPoO6wYtkAISkoBs5+/yuXaMZZ5nmRujFehKBhtyX80pmRSzgpjVxWO4nwlCqXGm5TvNVlINRs2q0FzJtmScxlUCTU/UzRhjcH7ttowmxrP43DO4ZzFesE6W/52NZeyKjxLNmWxf9V5KgfZNx2LSq2NC8+/py9NrZFvNfSicqO0nAXbB57ygAMOOOCAAw74NvC+iUoVgzRLpnhF175ExOByIQ3UGKSSgKp535kmYqrKSVGN9bWbUctMVhbcKBlTtbsxphRfMRfCKnNG069Y6mMkvsHxMnI1KZmIakfx6S9WHUounaim2DjqfjvKduncTclt0qTqx6RmZdSu0pQiORbFWKRYfBgrkCKXO0vKkef7hNxt4exlJD1DZYmkc7TzfOQHF7z4gY63Xhv43JcNv/Iw8Y3zJ+iwZWu3jOMjUirdpcP2q7R+hTTKh06hlQmbHetgaGWLaywP7gl3Fy3jONI1hiDKFODq/IqYMo0TGit0VhBKLmc2QohKpOQ4FloNDCVLMMZEzDMhWbo19/mFpuwZ1VKM3t5fuWY1SrUM2mcy1AZYNDNNEVOXGWPk1Zee58HFWzy8ELZhpB0nnBGCenabDZu1ZVpnmvsrxusnuMZjBFIY8d6huZCphqL+9CaVAnJM5GTIGpkzVKZUNsQZw5feUD7+nPDhl1b0y8Tbl5aHQyEHe5v50GnD/ePIZ389sGos1ihoxAskLZalmnPp8rTQeVssU1NCMWRMIWZjJiSqnauSRG6sdSvhmSnKvZTh7kIYxsRuk3CpWLnmZLjTgpOBIWSmqAzZcNwphoEpCSFb2gaO24brTcB7ockNeVxjMXRmy+XUojFhvMXryJCFLImZrCzkZNofyzxfa7VYum0FM5OSpXP69nX8TSQlN9fau9/n1rPuu7nnF029AjXP0uubCRupF6fU+0RWQ9NbPn5/xV///A40c++05VMfucvDtyd+6UsbIgGxTZkMkXK9awLbtqAju2FCcSUrs5RmeyJyzovZ/0ZAVKvl7s1vO+CAAw444IADDjjggNvo+wUiGWukWFymdONeEnJxF9Jc4zTAqt3bwyJFHeWtwflSulvjsLYFDOKLGsr6Btu2tG1fyA9TLGXLw+1tLItbSc2bQ/Zj2NlFiNl+dZ9rZ4q9ZR33x5CK9eY8PK81n6lkiDGlltxtt8SQUUqT656pEBAskGYDyTKmRrBS6tGqIy2kyGxFK2CNpV8saLoWVFlfXrPerIuNqxYCd7no6ZdLYoi88/BthmFTyC0xaK3l56ZKZ8u4H2Po+o679++zPDpmfb3m4cNfZ5p2eO9o247lYsVwvSZrsYzdjgMmBVarJWIN4zgw7jZAKDXuMOJdx9n951GFx++8jU5bDIpznmiKOk1wqFrUOqxv6RcNMUbWmyvIgjEdtm3xnaGh5pHS0DrLsBvIaYIU0DBRIjE8JkdSmjDWI9aiCFMImJjZrXeoJqwziHUsT044Wh2x2+2Yhi3jsGPcjYj3LFcnDMPI+tnTUj97jzeOzXBN7xsWXcdqseBqs0FUWXYNJ33LWbfgaLHg3r27TOPI8fEpYZrwjSu9qylWVeaETy0iic3muhCQMdZzPxGmkRQnijtvZhwimhNQPiuVIE0EckqICE3rwPtSu5liKawYsoLJWkhIAcSSSYxxIPpCRvZ9X44dJT4n5YhMgcmMuMbjG2Fle4bBsBu2ZY5Li5zZUq8tsViZSUBTnq0rSkZb7VdtIQ9v27EacXvbVRCMrWrrVOYWrCquxGASTarWsfN9QvdKT+eK+tV7T+MbGt8UYrQSrt75fTZluY/cZFHOzyo31+qtSn5/Feebt/eNvHtL61vvlT/k3f8+4O8IqB78og444IADDvjbg/dNVJqs+MUDxs1jcjzHmiOy7TEqZDMXX2XZmfBAShuoiGBtHbR8E1FZ8O5cxNLTKdXqpi6vGQPEbNiY+zTmnEW6ZFoLMQpJJgyzlWWh4Mo6ChmDFAJEZCZobjL62H9uVoiVPI+sRc2oKZPjTNwp1hSLkuyU00b50e+2fOaHW05WDdc//5dY/c5iWZpXfzfW/Q7e/vyf5bOfy+yyoW2E3/EAPnjH8/jC8tZguB4GtmFgSi1DMqh7TNcZ2ud6usZx1EV2047BCN4Yvv8DCWMnnmwj3kAjmSEHQhQaJyyM0BiDaMkt2CXYBSWkPCcoFiKvWnMaI8SsRTXGTM6m/XG5na2is2XQPEi9pay7eb6x+i2lZ0Jnsisq9xYR1HG9CyCRcRTUGZzpMGRyAhVLEktOEylm+q5F0wBuURR5KeKNYdEuWPQNOYUyEVDPPWMEkhR1Zs1lSShfeCPy6Zdh0ZX9tOiKj6d3lu97GRpTjEZfWFnevi65iM5UtWZOOAOrxtC3DrQo7xKeccpsp8SUTS2+lYQSciqZEiqVZKM29SqK5WI7cKfPfPy5hm1UximiYsFEPnTqeXQdql3xFtRznlqOekdrE72dOOocV7tI54rVjGsMu+sdT4eEzUrMEZFE1g6vA1NSVBIWsz/Xb/IlZX8N3jQR5G95nGfy8t0E5f7qvnWNz4TozXsipXkgayKnzE1cTlkw1SmLvfGMQm23Zc5RjQFWi5bteM7f9f330Gz53C9fsp3GUj1lxeiN2lXV0PpMZxMhZRZMHPWW9XCjGGb/W76JjKwd3TNRecABBxxwwAEHHHDAAe+FMBXnlWyLa4jWLDvIpJAI1bFlzmc0aHX0MTX/0ZCrciqlEnvhHFWJ1WB8g2s6TNPTNB3Odzjf4JypdXBxUCm2jvMDQCrZMVMQpTaxzpY4BqiuKnnvjCK3loPixOMbX5uTA+OY0eqyM4/nb9qQ69C+eKfs989twVX9dsTM7jNgnKXrFiyOesIUWF+vGXebEvOSE844fOM5OT0lhcjF+QXb7baoPDHMJrqFrNS6Uabaezr61Yr7L7yE9x3vvPMO588eozlgraFte7qu4+LiEmuUru8YhgGyw3dLppyIw44YRjRErLWM4wCm4d79B1xf7xjX53gDQS0pG5KWKA6xjnHcsV7v6BYrTu/0oKZGjSjLxQLftKScKCkbpigRrWXcBXJMeOtpj1qmMJJjUZOqEWIoZHLIiRAK2RdTIIwbjBW8X9A0DQbh+vKqNCmHiWk30XUdrmlJKRC3iWG9oetbxjFwfnFR5kGkNJ631nLatqCRk67lubMTlm3PslvSLZfstls262uarmF9vcV7j7PlxEiqxO2uqg2l2PLmLc77otxNEzEOpX6lOEGJZtrGQpoIIRBN2Y6UEs46srY0qljnAVNVjq5Y+yJF2SvVK7mej1MIxJhom5a+X2JdQ85r0jBU5fAEQ2mQ7tqWvu2wThjHwDgGspRmXiMWO+eGWrNXTDpXiMrbSkqpfxtjC2E+k46wJwpVy/yBoJCLi5MRixFTbVvLOjSZYhF7iw40pqgni4KyrtuWhzXFZnYmJmXOWqnKW+Bd33UbpXHg5pp+ryWLbfV8ZWtVMR94rwMOOOCAAw444DfH+yYqvTFEsQwJuu4EiQOS3iS291D1NfbhRnEVq0WoVIWULcK7/QDpRkHJniTRSgIYNYXMoVpNaGHIVALGQI5KYuT4RLncBcBiNGOs2Ufg3ZAotfdLC8tQ3SX37707PLyoKbMqlmKLQ67kl+peHZrzRNc5Pv1ix2c+ITy4C7/2Szveut7SaOAffuVzbH7tbdx3T7TLkYff2PLlJ5ZHaxhGiDlhUY7bgY41TZs5NpGNRnIonjgiGy6vN/zIRxyPt47OZb7yjnDSC9/3Ufj5L12yFEfMkV0KOJSzTjhdGgzKkBKXu8jVLrFLMCX2hG35WYrW3BJDGSBnYM5VLFmTVfs3e4TOB6V4uOyJXbilpGS2Ar5dokKhnoTGw8M3nvDVtyNoGYpLEpy1bIdLYnTkFBkn5fHbb9NIoGkc2vWkaYS+w5h6PhhDSomj4wVowoohpUzKgs2KsMMbR3aCE8UZy5NL5WtvT3zm+wMfvRPpjPC1mFhZx0dfUb76hrDshJeO4fVnEW9KD7A1St8Ylo2UzE+UMQljgClEplgG8d5lokLMN+e/1ZLNMUNT/Y6UCDnzzuXE97zU8snJ8uVLIMHSN3zqZcdrv7jFmsxCwNhE9hMmC6eLzPNHmfVuy9mpYURIQUsGps3csVcMU4YYCLkhGceYB6bscHiixFvk4Q3ZeLuRYJ7QuH18bxSzsr/WbxN3N2rb22Rf7clU9tfc7XXOZPm+gWCe4JD5nK32sFqJUxUijq99/QnPPXeP7/v0GV/4SuDJs/O6ERZ03rZUJ4jKa3dXigaQlJiiJcaJ0165DkvGEEuXNe/+rTOKBTB1+w5k5QEHHHDAAQcccMABvxHX19dAjYgQgISZCYha91rrS19dTnhrMK44ARlbVGFQsixzjEwpUiw8tZAe4jEiNMbirKXxDl8fMxkyf5eKoFR1Zd0+EVOjUhwiJZc+pQnJ764H5nq6EKi2WmwK0zTVptZ84xhTox0EqbENNzU3CKVCneuIuSYo/xAtribWObq+EIVZM5fPLhmH4pxS3DYNfdfSrxaIdZxfXDJtt0WxCpXspPx2LRaaqEIqTdfGOu7df4G79++x3gy89rVfI447hISzln5xhDOOq4srrBUWR8cMu5FpyHjfoQLDLpbvjgbrWhJKuzzm+OSMZ8+eMW7XNN4RNRPiSAojBosYy+XlGs2Bruvo+gXb3RXTOEE2tE1LzJFxPTLGESMe8BydHJFjwIihWZ7gvWcYdri2pTnqiClyvbkGDHEYcNbSWodKwhjPyb37Ze7BOjJwfX2JMQ7NyjCO+K7Fti0xZ5z1jOOEcRA1Y4zl+uoK7xxXmzXDNKEp4A10vuOFe/e4d+cEZy137zyHsYZ+2TNOA13v0RQIOUDjcL5kTGpOhFRUqFaEKU5sN5f4pilRMcaSMeRpRFMgpohvj7BNh1hh2m3RWdkopeE1xgS2wYgjq0WqB6vWvvnSmBsRqipRCyG/jTt8k+nanuOVBQzr9TUxJXJK7MaJ3TDStS1d61kuOhoXmdKAptIYbX3JhXTO4a27ISqdx7t2nxspeyLTV0tYs5+XQco25pwLEamCMUqWug5rsfkmg1KcxUhGKJavxhqkrsO4G4K03AdMvWfURghT4pVuSErB3vSgv6vC3c8V1PkfUVAz+xDx7rmD205Et2rob0WAHnDAAQcccMABB8DfSkalM1gEiRnUkbu7pDjQ7B6DPyLZRck71FT5vHwzMFGtJNhMepRCY5+dUdZQXy/EZXHpuLGisJrJoli9wqqQ3SmLLvPoegMmoVn2pEdRPeVbdjdFDQeQ8lzo3HSG3lhSFgsRZwymkjQlX3AWe0UaZ3jxyPHJF3peObW89izys19SzneRKcMf+CHL7o0r/teftXzstb/M933PCTFb3jiPrIcSvB5iUbptdsJWDVYczgreeZxRUrZkHM92QtDE/RPPi2cNjy4jHzzNnN3vePTzPV2fCLbhXlZePhWOW8P1KLx5FXl8NXK1U2IqOSJGICmo1k46KPkNVe0456Ygs9Ku7K93d8RGwM7xIXtVas6p7usbhd0M5f9l782aLMvO87zn+9Zae+9zcqys6uqhGj032GhAIChwkBGQHBRlmyHZlu2wwz/AjnD4zjf+Bw7/DN84fGn7ypIohymaFClOAkmAGLsbPaCHqq7KyukMe+81+WKtfTKrADAc0CX3G5Fd1ZmnTp6zhxPrW++UaqRmOR/LpqWVgV9/NbJsIlksMZQB3WjDC/vn3LtlyMPA1aUvvQwxYZxlHLfVmQhIrucpcLi/x+svLjl/9IivPFdIZYmevbbhl17Y4EPkeL+jUaERIYQARnj9lcDBA8t2tOx1wu3nGv7yHc/LJ4bDtgwMy1ZoNPHckStRrxkeriOnm5F+LDFFIFgDKZZzm3JGBVpThiRPIsapu1WKKrKSvSkLW5/49HLkH37Zcf5XwhiEF48sz53AaszcOYJFkwkZXPbsO+XIec4vHP0YuBp6MAbrOkIyhGxYbS1jDhgMRrek7Fi0iccbIaZYumdgRzaW6/8m4XhjwJDpSpAb53hySd78t5MzOpFJ1Z14TV6qmqfut4nMzMRdzeV1b+1OQJBT2dq5MSnFmNn2nuef3eeP/vIT7j8KGBGSeFK2NTqKnciBlDEu0Vk4XSlKRMiMqeFiEzhYrOlsw+W6dmjurv3pMyWT5fqYzJgxY8aMGTNmzJjxszAMAyEEBAqJaIv4M1PSeianIaqlqsQYmsbtXIVpEtXeEMmlVKJiQ96U2U0N0TVYGoyZyIgnIyhLNON1nYFImTcLwZhr52Ti5sr35mPJFEeYc6QUCVMdCtdr8mtmo0Rv5vhUatFEakhNl0FAUhXECpFCMB4s92haSwyJq8sV47Alx1jnesUo7B3so9ay3mwZNufEUKplVEscbcoZMVoKNrKgGFJOqIBpGp59/lkOj4559PkjHj9+RAoDhS9yLPb2UVFWqxVt23B86xar9YZ+GGm6jpQS49CTUyDmWJ2tJT6UnDl7/JgwbElZQCwp9IzDgBFBjGG73mBV6A6OCSlzeXlOSpGm7XDGklJmvboq4lZRmtZhnWGz3ZJipHUtYyXP2q5FjWG76UkhIdGwurpEraE5PKydnxZViw+xRg1n+n6oexyR7XYDCmpbQkzlWkgJY4UwJvIwkGNm2Tj6YSyuyggpBdrGcbDco2tarHUsFwuaxlFyhDJN05JFcW1DDCOiig/hxtyYiKGIU4uIPTH0VzS2Q2wJb0117jPGlNnaGlRbbMp4BgwZ4yxiHFLdlKgtexmVlQ85IrEK5GvcMnUfSoCUE9vtBu9Hum7BwcE+mUQ49/Vei4QkhBSJacGiXdC2HQ5LTL7Mq1aLw9c6rNVKEhai0NlmRy6iZhffuiMLqXLeugcmdU/GqJBUCJVQrGnFGFWMCtkoCVNTywoxWSJdy+8y9vpPVMpz3BDmk6fo1olfvMFUTg+oiuHda8vTg2V328uNR+9UxsDNkXkW986YMWPGjBkz/ib8wkSltYYwrMnGFpJDDGKWBHUwPEbHDak5LKRAXQBOsY/VP1WHrKcjI8vz7yJai9a0oiowpTgMGwZSPqCnQYG2iVxtfVWgQY5l1aUqaFayZOJu2JrIj2nhqzu35dRVWV546QkpUTdKDIEYEprhwBme2Tc8c+DYDpE/+2DgwWpkiIozmZPOcu+W46+/t+E7n1nOesvZZc8XXzQcLzNXq0yo1FZrS7ysC0KihyyYHMnRlyhWGnxq+MEngf/styIP7q/47a8v2Vtk4t4JK5+5vRRee6nhmQNDiIbvfxb44PGWT87KolpQjERCvg7RzDeWlSJ5t1CfStFvRmCyIxivz4lMbsmcgUhxWSamWkGti+7y/LKLTEUgxMjlqLz13C3+xbfPybn8W0nKm/dg4TJnq56V3+ftt16mS9iRZO0AACAASURBVJ9x9vCyqlCVYbuFWxlCiRvWnMiAEYukyNIpJwtHH4XHl1skQx/2uX/qeHCqtE7ZbwXXKA8ebXnlSwe4fIlPijjFHit+CLz5nPJ4BXf2hLsHmeePHJ2xfHQ+8uNH8Hg1EjFYo/gIQxTGEBlD2nVRlmEjoyazFEGbomYexkwfPZIdxgitSZjG8PAKlvsN33wr8u2PEn/3VdiitEbpLIBy1FleOHQs7Jr3Tx0PrgJDjhx0R2yjEj1Ys6W1wmolmChcyoIjCayz5ahzmNqNqVnrPZp3jtmfRVhO53FSSe+IyBvDyKSivo6RvSYgrx2ZcqOP9ubP61V5Y0/jJtk9PVf5zKC+jkTKI7fvnLBaJe7dbXn5+QN+/JMtn5z64gpONTx22ugB7h0KpyvFR4ux5dqOKZJUuVgp+93I3VuO++cZUon7jbm4QUXybuiao19nzJgxY8aMGTNm/DyEFHYJMzF6bHU7kQuZFmIsDkKluKGsxViH2jKDpto9J2ow3u9mLGNKz10RnCZiiAQfGPqelMDaSOkjNIiE4oI0BmdL5GkR+8UqMp3iGXONgp3G+Fz7LpWmaQpB58fSY1/nAM3XE3ThLkqlCKkm7lAJSpEyg+bJjjU9tvypaujaBV23YBhHLi8uiCHVTs+0c37apqHb22Poe7ZnF8TgyTEjWTEkUhUmkygZPqYkqZAyxliWex3PPPc8gvDxRx/Rb9fkELFiyQLt3gJR2GxWLJZLTu48w9XFJf26xzYtgx+RGEgZEhZjG/b392nbjnGz5fLstMzStmOvabGauVhfVJLK4WNGuiVdt4SUiOMGSWC1EM0ZGDYD4zYgCnbRMPrIOK5oGleSjsiMQ4+iXJyeE1MokagI603PYrnAupZ+8KgpUbyuKecz9IU4t86iWoXbKPvLfUQNm82Aj57WGbbrLYNPNKYhhUjKic0wMAXbLJoWXGZ/WbpRc0y7DlbnLMEHIpnee7oaEZwmwWmCJHXfQJScAyn5QuABxipIIsRAVhBMiUROCQmFAHbdAW6xqCSblPtKFNssUNvWhlRBcmkEvU71Kcci5oiYsl9ULvpEP2zpfc9et8f+3l4hni/OyeMIZGIKjKlHAoguaRYNrSyLmFYSRgzOlfnSurb2Qpb4V60xr4UsNMUFObkpKwGYdiIB2QnKVQRjlFgdkyYqzio5WVQy2RSxtFHFWnPdSWlsve+vXdAT6m1X92iKaGCSHExk//TAXNnMm0TmdAzLC7/playCZfINkvJ672l2Vc6YMWPGjBkzfh5+caKyXUIOaIokP2LcAquUqE73LDle0I2PGOwxSRqESb0pOzVncTLCNVEBMV4ruAoRUYemKtpyucdKT8oto9wGKYXqkpXjA8eqL10MiCnPU3sldVKc1cR8aw0wkW6RFDNS+wV2srKcy6JQBWtq1A2Jpc00KuxbDwgPLkfWfWDlM5qlkIFGsV0g9I7vfgLnY+T8M/jwseHugeOl28IHj0dCKB0cJnqMZLoGDhsBIjEI4joWneWwE/aazPJQuVpbXnhFWZxYumfusfrJt/naG8d86Q3P3qj84APD77w38P37iX6EtrHYBGPINfrk5oLyOoYT2B2DiaC85o5uuOPy9Tkhh/p007I21uggrQvh4licHHFm931QTXx8lnnl/mNyFny05JyxkllaQ7TCpd/j0ytHsksWus9wkOmHNctGiHFkHDacPv6M/VvPoM7gY8IaCKkh5pbV0OEMvHwCrz8feXDaIF5YD4YsGTEZP8Kn9485eSly+40Fx0cbxuMGzIaj5cjLX1jQv7PlP/+6cuvA8OHnkT9/P/D5RUJUuHXgWG3gYhu48AEfysCdshBz6aHJKe9Uw6KR1goLpxzsS4mjzYnNMJLF0LYGbSw/+jTxH/6j28TfveCXv6Z86zueg33hxUPhjdsNR63y7sM13/pYWG9XbIKQdcFFEm53hj4qF+vI/mJNKyu22pVoG3E4CUTv0dyQpnulEvRP9kxeE4RP91JO9+i00XDz51Ov5e4xTxGV18/5s4hI/sa/T/dmvqHsTMlgxPPCvSP+4rsP+auPHnDvmSW/8dwtPnyw4ScPAxJSiXKVjDPCXgufnkWWohhJJUo4deQc8GQeb5Vu9Dx/ZLnYKKttKBsfubrIJcya0BkzZsyYMWPGjBl/I5xzQMYagxGwtsylKSVEE8SIzaCSsEax5ro7Ll+HDdFoh3MdGFPmRxWsWoxxYCzGgkgkJY/3mZwtKUVstrimLf12qqgowYfS4ahlO+B6rT8N6OX3T516AOMwln5NUk0rKSvhtNMqFtFrnkgLnYjJyYFVqlSkioPTlMAiSte2WOdIKXF1dYn3HlJCUhE5J1GatqFtWwBWF+f40dfXw5SOC2hxnubJoSf19yliDYdHxxweH3N5ecb56SnBj4UENYUs6roWVcNmu2F/f7+QlFdXbLYb1BmGYQs5ohTy1tmGo6Nj1BlWl+f06xXZKCKukK57DRePHiKmhdwUEs0ZFm2LqNBvejAdri0EW1ZDiok+bNGmuPB6P+CsxRpHCB4IrFcrmqbFGFtcnFK6Foex5/D4AGMattueFD0xZJb7+8SYWK9WWBWsdYixJJQhDBjXse2H2ploQBOj98QQUYSUI651rM43hBDxYURNphFH1ziWXceibekWHUhms92wMC3GCDF6JER8Dhjn6v5MqnU6ldhMkRK2o6hYslFMtkCu8a+xuoELkR9TIueAEYNtO9q2o3RQFrpc1WJdiyYIKZf9nulGkloxQt3TiKEkgck0w2fG3uN7T7fcY7l3gLWO0/NTRu9LF6UWoj/lSM7FOelcVyqH0OJitFLdjYWoVC33klFT92GuScObbmStnw0AWaUI8CcnpanxrqqIkRIRjSGncs+ZGu1afo/u7vfrqNcbny07WrLs7+xStmTqmLyBnNEnJt8b/skq+o81tavcitdka67/HupuQ/6pZ58xY8aMGTNmzAD+HYjKZPcY/IjrllgZyf05o+7VaJGRpPtsc0sTH4MsiHaPyR05OSszkNMUG5GLA7IW3t+MgC0v1NPKhpgt23wIGIS4W1SRQHOg94LYSoTecGmlnJBc+jAgl/50MXVBDN5HRBK7KSeXpatVoXVK5xRSLERFghwC26BceU8/RHIdVkIucSrEwJ2jhs/XIz85K12UfUycbSP/6gfC689Y9tvSqZmSoMEz2JG95YAf1+wtD3nuZI/jpZAl0ofES688x9e/csBi83vs/93/GA1H8OJ/xcHtf8FvvvRHrN9/wO//v8o//37P5VZwVrDW4KOhHxIiqbjKtA5r07mYSMpJ35bZ9XA+2SEI+alzk3cE5eTKLJEjzpVBOISi0E0pVcVuqlFEhcw8W0ciBrVaVJoJXjjJPLgSnr+TSLalsx7EkX1ksdewXCxwmog5cXZ6xh/96Q/4J//RsyQyGj0xDqx6z1UfuX810hrQvUxnhddfcHzt9cC2Nzy68mw3cHzoWRx1XPzkEXf/yTdJR99j+fw32L77+7x413P3rbvceTFx/iDwb/8q8v7nia5xvP2C8OlF4qNHgcfbxNbXazgVkrIMLiWmKaXreFREGMbIWhOdFQ4WhhcODL/yYsvJoSOJ49MLuLgYyCnwj//xCYvnj7nzw+/wX37zgFeeT3znu47f+cszPj7P+KSMuSOLYo3QiWUTwdnM8dISQiLGjkZB8cSccAzELJA8KRci/5qYvCYtp3M6kcvXrufpnF+T3LuoqNpD8yTpOWmsJyJ8p7l+ihC93ih5gryU6Xm1uCin/5dyTL3A2I+E7cCnn2157YVbfPsH56hb8/KzHd98+5BPTj2fPBrxXnj2luHxOjEmj7GGpRh88oiGqm0ohObGC+HM8+xtR9c5Pj/zgJI1Vi90xcxYzpgxY8aMGTNmzPgZaJxBVUpvpC39dVJTZlIM5JyK5jNNxqpC3oQxkGKpKYlwg/DIpQfPWNQ0iDHVqWUxohjAqOBMcXa5tsXaQpLlnPAxlJoPvVm7UpCl0BHGGJxzxanpAzHGG48t8/puFgAKsan1b9S6lvI9yYW8KW+ydAUWyWHpoWwXHXH0DJstwfsSyQn1EZSexeUCEaHve8axODoRnnj90zyzE9caAVHIgjWWO889h2taHj34nKuLx/VxZnr1NF2HGqXf9uwfHHDnzjNcPD5nu92gAkPfl3Mlimj52j88Rozl/PFjoh8hK2obnLUcHR9zdv4InzJZXSE3jaFpFzjnuLq4JGXBtG05iqKMITBsh0LUGccwenzKtG1LzmWG2m43OOdIqnTdghAzIXrG0dO1C2IUhn5LypFEYrk8IMXM6ekZi70DIsLoAxoGUkwYLXN4FtDGMPoRa0uHZAoUYjBEjMI4DFigEUFah1XFWUfXLAr5qYa9ZUe/3dJvM8vFAmMsYwhogk4tamAYh7JnIkUYnhBGP5bpsDpxxSk5e5CEqIVsylWXC9EfUyCnWC9Bi3NtJRoLmZ4A4yzETIhS9zamNKhKoMn13Fn2iwphPZH5V1dXpJRYLve4deuE1dWqCJCdYtVgbXErSu2OtK5ELhs1tYPS7O5VqZ2QKlprV0riWE5p56K8SVjKFI8sxQtKVgRFpXyGpFQ+J0QNWaY9Li2/u/ZR3hSQ3+yanZ57dxymfTORG8lGuWrTpw7KJz4pyjEjlX2CXObzVMnfpNXBmhNJBCkM5RP7czNmzJgxY8aMGU/jFyYqs1kg4znedGTZY9EIEq8IwRClA/FkFXy6jeWSJpzS6xGSDZMPqURBTA7GspgRElnL8KKiGAk0aU3Khq3skyiKVJGIUBZ5ZUGWIGRiNOVd5VRiMKbF3TT0pWlAEtrGITWuJkVIORSF3+T+E6FzhsOlwxol+YSPmcGHMgDEQqypGoiRxpXug+xh0Wb2WsvDy8D5JtJ7ofeCKvz1Z4FlA3eXyv0zYYxgwhZV4ewqcIpFLhMfPN7yzMLw5gvwd15qef2NLW27Qe1zqN+Hl/87cu4w+79JOv09vvftDT/+3HPUKq1AH2A9CuuQGHwkxKp4rarCQhRPhJPsTkWeXICFmSTJjYXp7nRJfZ482WLLD7MSQthFCBW3WyxDRJHWklKNeBUIOTAOgkizI5MXTeLTs4izFgng7EjyA8ZmbAaxDZK2KMqYPNRI31YsIQckbPD9imHMPN707BlY9w3P3B65OM/8nZcTz+wPvPVVw8GxQ/ah9w7OIa49vPbfI+2rtC98zOv/9A6GNZ9++yHf/xHs7wn/4EuW8yvlLz4c+fHDkfUIPpRrK6d6CdX44cJbppo2NCkOi5M15aLw3Ho4X0c+ODe8fifxa28o/8k39rn9XMvh8w2Lt/4HYtzya//FEac/+j7/9+9+wl+8L1yOJRJ4xKCacFJ6RCYieNUHrMKRQlRLwKGSaOlJMSCxKEJVnorn1aI0paqPSxQTpZcxl3uzOCYrmT31wVbtZbmFJmL2SVdkJlVVM0zk9/RhMA2NwI1Y2Ol1lcfLFCWT4KbWM2TBp4y4zIOryMFx4rVX93n3wxXvfjry0f2RZ+80/PqX97m4iGQ/8oOzgKgQsilu6xCQ1tXfkKq6WogInz6K3D4UXnlhyWcPPbGqXJOU82jngWvGjBkzZsyYMWPGz4Ax4HbOxDIfqYAVJRtTXY2ZHMsclkIihpFhHIghkCvJUvrnLKZpsK5BXOkmFDE7h2NGEWNpmpa2W6CmxHEOYSjRj9ZgjC2uRzG7xKMaj1IJF0WNJfjSSzilHBUH5iRuVAo/8ZTLSijCwhJqWeYDpRJAZb2vWmo2msZBymyuVjtR646oyhlUabsO5yx9v2UchnI86+yauY7JvBlpiVz/TqPC3sEhRyd36H3kwf379KurGjWaUBHAYJvSI7jtew6Pb3F8fMz52WPGwQPghxGZBLuiWNewd3BAjInzx2fkHFExZKOodRydHLPerOj7HjUNqEMlgzHYdsFmXforjXUlnhZHyiXmFEz5fsh4n1geHJRuyQyD94AhZ4fIgqtVjzVFFKyi9H1PJmJqT6M1DSnBxfkFi64lp8R62xN9wBqlsYaUA7axGFeib1OmRgh7ttuRxb5l6D3BJ4IPqAittTSiLNoFQnkf3aJFrWJtw96eZbNZsWVkb28PJJByZL1e0TQWyZk4juU8UVKXDEIYyn5MyglDSXtK0ZfHaSHxUkw0VjCVVM8xkUIkSMI0HSqQkiekhDNgnCOiEEKdYQvpl6dkKeqUmUuqVYLdfRBSZr3ZkHJmuVhyeHBEipEoheB1xmDbEqVsrcE6h1GL0UpYmhLFOs3nMkXM1uu1BBNpnbPr/PyUeEC4djiXr/oUUkhJMdOeTiF9n3ZO3kw9UjFlD213/1//bCcSlt3dXNOLnprnb3ylKqoQipNay11C3rmpr4XHT9fLzJgxY8aMGTNmPI1fmKhELDFFnDhUlW0yCEc0rseGK7x3RNMRNZHSASEPdPGc0SzQvASosTCVuKkkVq7uPUuiyRdISmxljySmEhyT00uKSm5SY2piTFt8qgpKrl1bVTu2i51IMZG1qO+sM6CK9xEfphiMiGjGGlh0QteVCJYhJcYEG58K6ZcLKWMAlcxqHHHWgCSWjdKPkct1pPcldtUnkJh4uIr88L7ndtex38J6O5JCRLUjK1gRDJmYRh6uhEfvZr79Qc9bH/Z8/VXlV//BLbj32yhdeY+rf8vmg8fcPez5h1/xPDiD9x4J7z4wnK5HhrGMP5lU1Gwp1UVxdbpJHZpvOtwmZe/OLXdjQZknh2WhpkRqO0EVAEqSG07MGrsjcj1AJ19+lg0Jg/c9h8ZwETOHbWY7FpJMcibkQD8o6eqMcBgQiRijZARnYHmwz2uv3SvkWqKcO7OkO3iGh+cfk4KSVNhsA1dD4ifnAxfbxL1blh/e9/zSc4kv/fKa4zeexRz/ffL+ryDtN0kk5N7/iBl+l+GP/w/EwK9+44C8Gvi33xv5iw8ip+vAEKpbNGdiKl+hkpQpU6JaciEqp46GSTNZ5tziSg1Z8THxk4vM478e+N7HI7/5FeHvvfINknsNtRDtt/jR9/+ETZ8INPS5Qayifdk0iGhVJZsy5PaBZ28v6S8TXRfZDGUQH1KL4gk5YDXhq2NxMjYWQabsujpKh0jaXR9MhOtuSKGqmtP1j6fBr8bCTiMg9Zq5zrGalNA3XJe7+/z6MTlzfR9Pjs7676YBK/iEVYMzwo8+uODrb9/h/CRwetYTkvDhw5H7n3u+9JJw9/kFdtnxo4+uGLcBbSxp7bGSGCSj6E6ZOm26PFrBwbDm9Rf2+OzxyMW6bG4YSkfqjBkzZsyYMWPGjBlPw0j5kgwhJMLg6zK2zKOFGLyenWIskaZKJqZYZpycCDlVIqPMv04MmiJ2Ii6MxbUdi+VBJVmAGEBS7TUs6STT+nZKxpmaVow1qJZ1/TgMSE7XAY/5SfdiwU+v54v6WOscKbtkHdFCWjpnsbYhpsDQD8VBmapQmDL/ZQFnHbYtUbDb9ZoQQiGm8lRbck2gPEnGFCJRJWOt4fj2bdpuwWp1xeXVinG7RaSmLdX5xzUNrm0Zhp6Dg/1CUp6fF0drSgzDUN5pnQ1s4zi8dYt+GNiu14UundJgRNjbXxJiYrPpsdaR4jQXQdsu8SHhQ0DUknMsx1aVnCJGDGi5NFKMLBb7AHjvUaREjyJYhdXVJcYYsjWE4InxuuIm54RoxntPCCXONqfMenOJH4tYNceyX4HCQdcSQpnbY8zE5On7DTEGQvDkHNmse4wYUgw45xAt0beQcG11D1otCUpiaNqOYRxw40ht3ygi5TFitMyrWq+TmDPG1s7WYUANpKRYq3U0DEBxOqaciamQgFL7HWMK5DiSo6VpOlQtOQz4mGiM4pySUt4do5QT065RjhQnoEgN8ck7R6SYStyGwDBs6dqOrm3JWq5BqwbTaO2DdFhnd0QlXPdPZpHSlXrjWi3pQFKvwymIdarfuUEO3rjHClEuO1F9NoaQMylFJjLzxk25k/lOv+/6vn3y3i2O0voKbtzrktk5UYEd0Vv2gep9OAmMRavxAFLd+5k+FSaiMt1IY5oxY8aMGTNmzHgavzhRWYnAabGkQCQwhgZcS2M3xHCJzx1qWyQv2bKgTee0XNGbAxAhZUfxWKYSRqojTd5iUqJnwZjs9VJKCykG07A0ESVCDp7V1pOlknc3SQzZsRzknEsEac37FxEWnSX4SAgByBgt0bCNNeztOVxjWK08KcF2iIy+Ltgmsi7G8utUaoxm5KCzrMZCaq7GSEi1XyAmYsj85BQ4AkdCCfRxxPsDrAk464lJWKrjaC9zuFAOW+X5o467x5d0By2Ml2QTyPEdfP4WzevPcBy2xPsj6XHmcg0qAycLcMawGRKDCGNMOyJJJ8I3T8RuJmNuEFA3j/VEYMLUNQJUFWpd7mZIkuq1IZN58MlFKoWCSjmiOWGSoiLceybw4weJe88ZfnKaMDKSsfTDyGbI9KsNcgAxByIZFz39kPjz73+b9eUVRjve/tKb5JTxuWG5v0dKkVahD46cI6SinDwfEvec5eOzHts1LL635uT0Ac988V9ivvrrZASLBU7I7pu0b294/s0POfvTH/Cj9zyfnCoQSFmJJHKNb1EzOYHzbhiTlMnZPBGVMg0iUI5ro1J6UbQ4ivcby8mR5ZWv7JFMgqs/QZoT+ocf8uZX93n51UN+6V3hD78b+c5n4G1mDIkshoVVGgcxKi/fO+DB5xucjzgNWBxjDihK6zJog2ZfnLE33J46DUB1kBCZCMYSYZtShpiI5Dq4FBVn3hGVT04f12MXu3vmmv8Tnnx4JTd/aoipnZSE3efPEz/NufaPZBorrEf41g8e8e996Q5/svFsh4jkTFIhG+EP/mLFyYHyq188Yuszn3/4iLPVWHuChF2w69SxU12kl94wfLLmC/cWHB1YPrq/RjWg0vysD8kZM2bMmDFjxowZf9uREt57Yi59gSnGonZNoZCYtjgdJ+cVajCuLdGRxpJiycLJKMZYjG0KkedajC2ztmsXtN0eKQv9doPaQiJZ61BTOvWsdXU2NugUiyqFJLXWFILKF3LSVOKmOCBvilCviY0niUJurN1rUg+lB0+MKXGVTVkv99uelMLuOUSFGIoYWZTavVgiWMt8DmKUKfr0ZsfdkyQl9UUoi70lt26dMIbA+dklYRiIfX/tYNNMjMVJ2HQtfozsHxxycHTA+dk53o+k6Ak+1LciSFZsYzm+fcI4RrabvrrTMiEEMplFt6TtFpydnZXjgEW1vDfbOFQbtv15ISOzkFMhd4qb1ZQ9ETVEEq5xWDX0fkDRXV+kUcs4jkDCeyGokmIkVdJ7TAlnHT6E4pLMnhgD69WWGAoBbjQTQmIMkcPDI8LgS/SqGgRhHHtyChhJ+HFL9CWmuMR8lhnWWlNOtZod4SYIqBCTxzYKWMaxR03dN8hVqEs576KpXN8hEGJxhRZRcoTqNVVTROMp+nI9O1Nep3WoNYWsVMrjU09KFmNajLbEMOJ9oGkanGvxIZJSIKZcCc9Ux04FVazo7vpWLWQoteNRptQvVZrOlfhkEUyjWC2OXGMVo7Ymel1XmbCbf2+kFu1m7et+yJSfdC3WS++nRQI1ovbGN5hIxpy17u/UWT1R6pZUdiToE/s708fU5HqcRAO7j6/rpKQi0E47YnO3h1D3iHRyVdYtOJXSs7szDMxuyhkzZsyYMWPG34BfmKiMOZFxACRMcempIStoTAzSYUzLMveEuCLKAkHxekxMPW08I+ohoRI9RhXLChcHxtywYVEWcblGyFDUWlNfXlnn1ujJCNZ5/KiVRJOSl/8zoixEhBgjQSFlS86BxhmOjxpi8PgxoFoWZq4RDo+6QjCK4lG2gydn3f1uoazNjFG0snVdY2id8HjteeYocbVJ9GNx2YWcIEYuosWZnj2jNA30fSaGTIxKTuBcz/k2sPUWouXL9zL/wW8IB6+dQP+Y/PBfoi//MnCIW/59wtUfs159l3feD3gfefWOpXOFhAx1MSmSMCIMQKixpFXiVlx+tc9hWkdPi9gs177U8jzTHCpQSU6p37ym4PKO5JmceqmcAEhCK5GFrrBq+PjTgaOTI1676znZa3jngeKMEIZSyJ5QNiQ224BYwcSEMcLJrX1eeeGYDwfPF+7dJQYPCDEEDvf3IQuWkXVQbFZiTphclIU+RF64lTjZC+S84ujZffSVf4pu3wXzEkmOQZeoeQlu/Sbm4/+Zrokc7hs6B1iL1YzTRJh6VnX6Q0ipXBuiuSqXbyDvvImICAHopPQtHiwM33iz4de+bPngBwN/8cd/zG//14+5+uhz9OQO/9c/OydFTzb7vPFs5KUT+OED5aOzwMoLy/0SK3V0F+6f9lxtPbfU0o+GxgZMVLIEYlDGJDQaiD6hFFdwcVZed1VIvRjKUAIx1fjkVIjLnVAgxxtvL980THLdQXlT4fnUn9ePng7Rk9+brrsbl1d5yusHxqis11usBc3CNkS+/f45X3vtmD/54SkhZZ49gouLzBgiD86U+6en3D5uODYGo4G9zrDpA8ZQBsBJ3Vr7aHIMDMbw/odbXrhr+cpre2xTwz/6999++o3MmDFjxowZM2bMmEGMiZgCPiRiTLtIUgEwgihl/lTFmOrkSlPXXnFLRTKSLUYsWIdqIf7a/Vu4pgNgtd0wuc5UHFlLjCgYkDoni2AqiahqcLbUqvgxVAdkJRNEkR05+cTCfpd7UpKIpvX5lJRUH1bncNXSdSkIwzgwjkMh96Zpcue4rB1/tQ9xs9nW2b/MUanYSqm7ArseSyoRsiNFreHW/gGL5R6ryxWjHyAmxmEEKWJkQRljIQSbpiHnzN7hPvv7+zw+fUQcS41J2LlRC8Hj2paDo0OCj9VJWeI3Q/Ag0LiW41u3OL+83BGc5Tgo1li6rmW12mK0kF85FSGmVYOPEbKUqF4ps5nREturTM47W+NW1wAAIABJREFUreeruP6CT+WcVQG5VVPEwGKIMRBDpGsXrC+vaqQsKGXfRQRSLO5MSbC92hKjxzWuElEJQ3E6xuriNCREwVVi0hmtROXUtShEInaq/0gZ4ywSIinHck2pVhEsdbvAoJrBmrK3IoJrLVkKAammkJC2aUokMBljDRjQ2v9YrkWDikVMIXtTCpVotIQY8CFgrcO5psyz2RcBbk47l/Hk5hWR0vFoqzDAmNIvasFai9oSreqMK85LB3Z6nCkdkiXmFcjmmniM9c5R2R2D3Xw7uaJVCfHatZgnMvPG58l0X8okNK+VLDknUEGJpFScrdN1LKpIlN29Wp7fXN+vdRcnpfo66wxcZNSpipVTIYwpZOV1jG7ZDxCVWt1Uol9l2iOaPm/qPfqkGHnGjBkzZsyYMeMav7ijcjjF4snjORK3lKLsshicojMSSo/QWMXFKzZREFsK3FNe0sbHIE1ZAIaepEtWeZ+YDSWoFFQzUmMYp3DSlKluwLowIrGwsPaRvHMIJlKWJ/v3qAI2gRgSIcYy/OTMyck+fvRcnJVIChXhYK/h+HjJ54/WYJUQSkH4FI1ZImengVIxkksPRmuISbjYegiRzZCJAXwsyjZJMObI+TojnUFTorGRmAYihhgSKS+4tfQ8f5h4+57h6/cMp6eJ//P3zvjle4lf/29eIuc9Imdo91vo3ciq/x3eewDf/TizjRuWztEYYWEUXOkOKCNqxqeMj4LkRBB2KlnJpXh+xy1xvRienJYlpuT6AdP3RErMj0xskhTFpOzoS6nEV2TZwK3Ws+23fL7y2Mbx6h2HcxnRRPCZrTfEXBjVPjg2m3MWR0eE4OkaWCyWWGB/oXTOgkzxRJkYR2LO+KQ7Ui0mGIJHVbncBN5+MfOFZ6/4wlt36E5OuPrj/529OwfYr30R5FPEfRVUSau/JMS7dF+AL7dXPHfc895n8N59ePfzhgerQMploI25HmURNJfhU+s1O5F/O3dgPVZWM11r+OIzji/f6xjGwP/yzzyrkPmle4bzj+/zb/7wil/5NcuLz+/xZ++u+fgicXWZMGnkcB9OFobb+5b2YMn+kfLOB5dse0/OoI3FjhHjyhA7RqExkRwbhFgcxFIHJTLkhGatPZtlCCmK01zJ+aqMnJyY8ASJWDYtnp5AfjpeZnftVEwk+I27dae+fPqxcB35WojRov3GOhatJRERhIfrwPHjDV968YgffXjByT788NNQ3p8kBOX0zKMLQWLmlRcdX/vSCT94f8Vnn2+BQs5mKUO8SL2ecmZIDV95+wUaZ/nWn3//539WzpgxY8aMGTNmzPhbixBC2egPxTHmGoNzFskJNWVtbK2p/XUl9UaN2fXMpZixkiErORnENiz393FtyzgObC83iEwdeS3WNVi1GGNR1RpDyY2JrHRmihpSCFV8SJ0D62Ny3AmAYacd3v19JyKss45UQm4XYZkzTdNgVBm9J4xjIR6zoJJrmUt1Y6nQ2AYhM46+VKKIIdbZbkdKVpFkIaxkJ4ycElqsazg6OiLmxOPHZ5ASSmQMY4nqhBI1mopA0zYtYixd17Hc2+P09DFxjCTvd32IU5elaxqWh/vEGNmsN8RU4ktzKqSuMYbjk9v0fc+47QsRK0KNcMK2jtFHUi6VHYKUJCJb40tT6X5UawgBjGh9j4JzIPjirpVrEmuavQ1ahONoEWsbKfGuJHIYyX7EqqC27IvEFFFjsUZBDTl7UhzLsfYeFdDGkEIGLURgY1u8KJFyboy1YEpqkGhxVqaUSv9prgRXzIhRjKkRpDWFq3SiFFJOjQHNqFFKt2l1XgoYLX+KGBrXgkKKAWOnjsVCJEIRzE69iyq1GzVnjDGkDOMYyFmw1mFiYBzrPYmhzJUlRUhMIdfN5ES2pWPSanF6GuMK4Vn7YlWVYoI29Z4t3ayq1VI4CbeTVLIv1J9bJhNy0QWnafzdORB3Uan12p/u3WvB/jWBGCsZXKpgy1zsvSfXza/SMZsxppCXxfFZ5mWkeFdzpsQU57hzTE5a45wzMcSdaDnl6+twOvZTN2ZShXTDKVrFDkmUJ9TMM2bMmDFjxowZT+EXJipT2JKTkvwWiSV6RGrHXG2hqzEZghclG2hJSLrEk8i5wTYRGy5IQyLbQ1LeYGSLmWRlMi2sKF0X5UnLOCRKmn4OLExm1fsy2tWuh7qEq6+4DDNlMMjEDGOf0UMHOdN1wvP3brFafwqjYi08e3efw6MFDx5e0rWOR/4K0YlxyjTO0rjS5WGdluExekiRde+53AT8mNiOmRDYueyA0r05KJ1JGAJOhSgRJeNipGtb7h13fOV55WS55Z//tTBYx6snni+8Hsir/4cgHjn/I/LiOeL5BzS95ddeDhwu4J2Hjk8eRT4fImMsi2R7Y12oksr/m8rc1sFxOm4iUofWVPotJxErFDXqjoySnUNQYDdsStXlSTL1OsgopcuxDH6eo70DXn1lyU8+DxweORbNSArKm7cDTauQPftmjdlT/LDikkgfr5CwJVSlZEgBJSJGi/I49KTtmu3Fh4z9FkzHngQ6DSiO5+407LnEqy/A197a4+B4wcfvRR7+64/5wgsH7P36f0q2x+T3/if0pf8Wmjdh+zEP/uDP+Pjzhtzs8cyecrKfae8ljpfw8Znh/rny+VXiYkxsQ2L0qZCWIqSYuL5SqwOZhBBpnXDSWV48UTpV/uCdnsebch13VviNheN7f7Xmg0v49F+t+K1fXfDeJx2Pxo6rccWj08Tp1rDXRA4PG778rOXBo4GYA/tOMI2wv7SsNnA1GBYmoNbgspAdWJSlKilLjXUpEa7Bx9KzmcrGRbwhfpy6M65RiVepf68/ezoC9iYmsvImafnTvTc/5cP8uUgpQTKEEFgslaQZImjyvPvJJV99/Zi3v2B4fDmSU2TZCI2N7LmENRkbIytNvPfOfcQ84vWXnyGNnj5ENn0kRyArMQvGWv7e11/hjZdP+L0/fI/PPr/ga1+58//jVc6YMWPGjBkzZsz424aYEoJgXSE3msbirC2EXQ51LZwgl5SikDNoRHIhPDSX+gq1FtcsaLoFwUcuz05JaUCwuGYfqXOpMYqxBuua4q5Uy+S0NEZxzpFSJNXex8T12nxyUTEJGKfu9vpeRBTVVISsO4kohXzimrBwjWP0nmG7Zeq7lzorpJRLNOT0WOcI3uNDuI6GTNdzhADESMy5OPNUqji2/FRVaRYdBweHXF2tWK1WqGpxKo4jOU1y3epoE3Cu9FJ23YKma3n86DHBe6IPqJgyWzB1UjbsHRyUnsK+J4ZQXJEZYixOwcOjQwRYrVbs3KaZMoM3DaqGvt8AhQgr0aK6m390F18qIOW8+9FjTImBNc4hKCF5jLHEWNKjtAqzQ1XFmpyJpXQRa8pWT9c2ZNFpbEc1FTLSWRJgjRAVspgSZaqFPPV42qYhkXGmwRpHqlGtiCBGyElKopYpR9hVh7CIoElqxLAUohTBGUOIcSeSpdalqEgVxKbqLp7EvpXYrXHFooK1TYlkrddjuYeuq2xMfT5ftiUKwZsSwzDStB2tawkuEfOAVIG6qivXjLX1HikEpTO2xCxbWwQFxmCdw7kiAFCtRGf1nIrk8qV1d6SKuTE1rCcVEjDGWPelps5YfVIpXjHdOzvXJNeRqynGXYdo8J6UY9m/0XKPxZRJsYp6k2BMRk1xEheBejl3E8lciMpCjeZUiNDr/skieI4x7iJib876hbAtJHWuHL1qOUc51WSi+nnys2b+GTNmzJgxY8YM+HcgKo21GLsgy6TmK7rIMmSVxS9MZIUSRNFUSMcY1jgTsLrHVehIxtAIZIn42CA5oLlEYeZKmmkKO2Vi6T4oC7s6ErHfwXYoi9ccY43tmHyXdeTKshuQkKIEG/rEM7db+pXni1+6x9Wq5+H9S/YPGl585Q5qHHsHe2yGhKij7SwpBJaLhqbNu/iV0XuGPqBJSCpsRxiGEjE5hrqIryrQsh7MeDLrEZYmYDG0oqgMHCyUu4cjR53nwzPLn74/sNcmvvnVJfSJd7438uzdn/DXP/rfODmM5M3vc3R0mx9/Av/mncwnVxGbldbCkVq2o2c9RvogVSWXqyNSiam08U09knVpSsr5xkhaCN+pO8EYSFWJOQntdv+ZnHn1n5q8IuWOXAlRW52ERgOXm578ICC95+rMsbjrcNbwxgtFBRh9YI8rjhfKRx+c8kmC115+jm2/YXnrmI6MZI+VokhGBXWO7djzyYMtp+fntNbQGKVzAWvu8OZJy+vPCnfvGNYb5S/fuWLsB954oeP2ccRuvkMis/ngjOXJH6Lj/0ragi6XXGxHPv1kzZ9swcdMZ4VFoxhJnBwqTSPsr+FqtKyGSO8TQ8qMnsn8W9SaOeIUFs7QOcEa+OhxYOUHfEyIAScGA+zZBd96Z2CL48PTNc890/D6iw33e8U+29GSWK822KbhjS90LBdCoytevCusN5l8S7DRsLpY0ZnAgLDEl55Q22CCxYhBE0QyPgRCjIQ0KSqpisrrLpgJNzthYp76KdmpQW86Hp9+/M3B5on+jqe+97PGmCe6PqbhHiFmCN5w0DQs5ArXKl2jOI1sVw955US5fbzPrxy1NEBWS7tcIM5w+fCUTz//Ds/fu80rL95h01/xZnuEcZamSTx8eMXjszW/9OZzrK9GLj57nz//+F06Y3jjnnB1cf4zXumMGTNmzJgxY8aMv+3IGFzbVJLSYa0pRJEkciokSgiBLBByFZCGRMajxuLcgm7vAOtaUgxcnp1CTQZSTWBKxYdMyTcRMLXCQDOJiFFH0xTXoh/HMutJieqcYhq15u9cO7vyjozUiRxECiHDNakyRVAaU4ielBLDticEX8Wa+aeUhwJYY1CEcRyJIezm0ZKIVGjFFGMhTVLdBxADOaOiJQXJGPYOD7HG8vjxGX3fY0RxxuLHkrADNRWlEkcZaLuO/f19VJWLs3OSD+QQS0KPmmr6K07XZrHA+0D0I3H0u5lmek2LrmNvseD00Sk5Va9ovnb4Na5hGPo6KptKyiVKrGyJ6FRjCumWEk4tKUWMdUzdIrkKSJ2ZyM2IteV1lkjRgBUlxkgO0LYNxhZCVFxbJcSZ6APWueJ+1HKcVS1dt2QMAWsMU5SnMxZjbSGVKcQdViAVglaskuOUglXcdFKdwEomGUXqNYGhnhdDzHFHUmciOda6kepi1XIRlOdIoe4vlFhcxdZ0p/rvcznGO8FtiggBa1wR28aAisMYg4+Jvu/p2oau60hEfKwRsWqxWghI6ypR6SxWLdY0WGOLaECrw9JIqf6ZYm9/jrR2ikdGpNYSTa+zREJP7233WTExfTf+P9c0n5QjMdavUIjIGCPBB3wYy70CoJkQIy5FckzElIgOjI2Imh2BODktd07lXFOgJO+Sk266Jnev5wZR+XRH7BQte5NwrSGw0wGZicoZM2bMmDFjxs/FL0xUjiGjtgMtHQIlFLWWq3PdFXE9lQQ6pzS6RkUZZcn5EEAbPB0+Gjq9pLGwzYfErHVJMy37puiPa/WdzVoUfChdt2W7bUqMSaZENebSQ6FV7Tap4BZ7XYngQQlJcW7B8aFjubB84xtv8a//6Ee8/Owhb7/1Cu+894CXX32B7//gM5b7HdYKRwcdXWvJZLabgfVqICVTukZCKENRzKQ8xb06jBYX57RQkxrbMobMwiSMWtpmj4VtUbGcj5mHW2XrI3f2W1zT8mC15P6DDb/11jEP3ocffthyKJc4XZLTPieHI1Y9V6vAeR8KuYj9/9h7s1jJsuw871t773NiuENOlZk1V1f1QLKpbraabKmbM2ENFCkIkmHYgF8s24AhGAYEPxiWZcDQk6EHP9iAYMuAZdAvFvxgQpAhUaYlsSVroihzarKH6qmqu8asysybd4jhnL338sPaJ+Jm9aBmkcxuttYHZNW9N05EnCkCZ51//f8iTMVmi0DNdXLFTQFAdXecRFrXXtvnMhULooQgzPqeGGDMhbHYUtMsS3u+tItXJSCkuCXXjqqBSLJiuCpH88RxLzx1PXLvbMs4rujTNVQDQSodhZwqy5lFyXR9R5TMwSxy9tYdysU5KQmnbz/gq2+c8sydN9AQoCind++wSMKVRUdRJYSOa8fCc1cDN64UtqPy0psztlVYn5/wxPFVzs8Lv/35c37g1m/z1ov/jPX2KZ584jOML91huQgcXV/w9knh7lnlYgNntbDZ2lxRBVIMzDtBJdAJHMwCfQxscmYbYMwtoidASibYxmBC8WpbWI+QydY5XZWNCIe9cLZWPvdm4ca1wEVWfvkLW37mh2ZcOYws549R6wkXRVjOBFke0B1c4+3V2+QMb7x+wXasPHYlkWXOVg5JfabvlFQrmxpZzkZWF8omKzlncq6UqlNT9C6K9VJ50c6Nh4XF0AToXWPAOwqQr1foXH7s8s/SOjanLBz9OsvK/g8gFt801sqLL36FeV3z1PEFw2gRx8O2Yx4Sb5wF4iD8xhffog+B1AeWXcd82ZHqQJ8iecwcHFzh9q2bHB70xFlP38/47G99hpOTL3FxPvLgYmS9FUZNrM4qEpUf/NBTX/sl6TiO4ziO4/wbTynmVgoxEWJnYkEMCJUYLHay68tOdCg5m7MpRLrugIPjawxlYHN6Hx23aC1ECdY0OrXAqqXNlDyQQmejCkpBtBA6IfWR7bA2Iadds5sLLqIqRLHRFS1Xctd4uhMiLo0Bmeb4WewpSDBRC2A7bHfur2k83STATXViCIGQArVUhlz2Lkq119qLNVNlYbVpUN25KEWE2azn8MoV1tstp/fvU8bBXHspksehuSKbg6s9TwX6fsbR8TEiwsk9e55qBvbiHVgc6WJxyFAG0GrxtezFGaXQ9ZErV484uXefcbD3J+ybMFPf7aI5bV/Q1qk1Ujen4xRzioBowOrzJkQGiyANEil1pJZCFzpUhaIjuRZr4k7WvBujWtyvBBOku4hgc1IFi/yNIUEwPTuIULTQ9y26sxRCbCJnO761mKtzcsISIiEJpJZsgxDTNNfRzieixRl3KUKwuY8xBEKNbSapuVy1tpmIMo2JsYTQYBm9TdQNKBaxW0prmm73dybnq2qmamWsW9unsScXJde8m4E6DCPjONL1c5aLAzbjAGpRyCkE+j4Rk81V7bpEDNHiYkNEQkSENuNTd2KrSBP4pkheWsTppXJ4d29F2vK02ZI7cVH2C8rDQt80h7LW2oRKm3Wbx5FxGBjGod1/ylSFLhSkRS6XWSHVSq5KzKm9v+zcnBL262npWkqdviDY1947URJa9HJ7jjQHdxPaJ8E6tPNKxBy/kzgpwYVKx3Ecx3G+Me9aqMzZLkKhbzn41u1moRtThGghEEih0ocVlJGzOmPUK3Zxo5EUhFTPKATOyyFz3bKUc9YsdrMqlSZITnE0YgKaipBECQmuzIQ7FWazOV2weJUuxTb3w+JCxrF1nxXryrSxEYX799d83wef4M6dU/7kn/yj3D9d8b6nr/Lcs8/w2usnHF29xldeusPBex7jycePqLVy/+459+6vGDMmeI4DdcgkVWqLTU0xMFaxDjx0N7vRetgqASWFSAoDfT+j6yzyZJULOlYkRpZ95GIInG4KsyvKyXlApPKbX4A7F8rdbaDTGWcb4QeegaOliWZBKmO2ojC3bZXmUrU1aG7T5jKd5mxKtE7TbesW7WIiRKyrcTfjRNmOBd0M5NIKORG0FgiRw17449+f6CMsu+ugTZyLkc0gbIcNTz52yPHyOlIrWQ8RicxTQsRmH8RohUF97zXAuvpsPiC8/Jv/snUBw73TFV/+6ts8vVhTS2hCtvD+65EPP/V+uhjoIsRoxWGVRClKKZnjg0A8uM56Gzkdex6/dkRYr3n9bsetW3NWr57z1S8WvvcF0LLhhccrX7yXuSiVzVrY5sg2jwzaukpF6fpIn5LNLg2BWRfouzZgXqabCDarJMSOda6oZLqkdJraMbHi9WieeOOs8mAbOShClMor90deegteePI5vnBvw/s+8DT97A6bs5Hnnn2CTVGuXD1iKPCVV7fUqKRZpp8n+rRkvoSxdPT6gNUqMeQL8pApJVyKabEu76lbsgpEDTt35eRIpkUF7wqY5l2etoFL/5946HednnXpdZX9Z5xWNzUh3Mp5xb5lYjunAa3UYNNXb9y8yrYc8PnP1d06BoGnn+z59CuF64eV2zdu8umXH0CbT0sYmIcNx1F55bUTPv/aZ+3PtfCeJ2c8/eQ1PvPi25xcdLBIfPyH3s/Lr53ya7/5KsLAH37fbX7tU3fe7Vep4ziO4ziO813MsN0AkMfMtkttzp3VC6lFtU5jM0IA6RJpPqObzYkxsTq7T84mMoaWKKRa6EKLm2y5OKWO5k4rAc3QhzmzNCconJ3ch9YoGWPcO5tCu+aXKV2nNoEhEKdr9eYAk5Z2Ytf/JkR2XUdAzEU5ju3afH8tv5+nOLku7b3LOFj9hLn1Qoxoi52cZIxas0XG7l5valwWFodLZrM55+fnbFZt34gQu9hmgpapkNiJlBGQ1HHl2jWKZk5PTs312epMCW38SbU6fL5cMowjqsq4HXY1XEzJatMQODo+ZrVes9msWzOyTUyc1jemxDAMuzpmp5kCiOxSoLAjuHN+qu4rnxgDqestMnQwAVVUKLmaqCj2eEDREBDprQwKYrNI22uFKpRgrrqpCbW2A6oqELompgqS4u5njUreWkRQjKnNGZV23wCouQl4Jj6mvmvRriYOhhigCVixzfO0c11MgJQCVS2GVLGfZTrfmte3nT/TuWRzEgtBktXZRLSaUFkRimYWfWcN8sVilGNIdJ1QaiZqpe9nhNhBLc0NHOg7+2ymlEg7odJmUZqAaMLoJDSDlZRRQnN1Wn1c3uE2fNhSfEnslmLJW21u5GQ+fmdrb51iV2ullkzNW0oeGMctw7Bm2A5tTmVrfo4BCZGSIeVK6vKueT+2eZoxphahq01AD7v11Oa4pp0nkyArIhD36zXdHwrNqTnF9MY4ibhix5l2zgSxmayO4ziO4zhfh3ctVJp61eJetaJhuupWFJsv0YXAIq6QvGI7JrZyiNQKIUMbXD6qEsMxHZmk54wlkcOCQ1kxypyt9EjTHOxitiIhkaINcZ8nG8DexzW5ZPouQTezmJZZJCZ28RlCT62Qi5C1o5RKFyIPVltWp5ln3nODzWrLn/rpH6GXEZFjrj92k34e+NEf/jCHB4GXXnqDr7x+wrYmqgbOz1ZcXIyUXElaCe2itWQhUBiL7IqaeinKIwUhSSSlAoxUmTGWwDQjsEoi1MSqmuhZS2K9tc7I9XbGb3515PBK4Y37hbsPCjeOI5+/W7gy71nMlTTOqMG6DzugZiUXQKf5IAK7uZPa5lEqNbcIz1agTtEnakP6mC6bowizLhGkMgwFbXG/wsiVRcfH37cghgKIdfO2zsJKYNRgJbUU6+SsEIOCtCKnOeRUM1R2saOqNgMkRIsmAkwsl1box4SguxiYeR9JwWbCoKltowm5qc3UGDSSNTDrKsdLWJ0ekFJhsYhc3MkUOeD0HPpZ4Hi5YRkD9wrUAKGPRImkWk0AFmGbK5tc6SKk2GJwpg7kktsNgTZHpNhz+pSsGJ1iU1pv9PJwxt11ZWSgqhV4Y1G++ubIDz4353bpuf7sDWIXuTjd8J4XbvPiF9/i4Noh49trnnhiyVsnG67dvMIzT2442/asN4H7ZxvO1rDdbMmj2o0C7fYRLuhuLIygrUFAd45mq55CW2YvVu5nZjQBkan5Wned0g/FtsKlKmz/2ZB9C/el4q4iTaC0PlXbRxnogz2qCOfnhcPDOQElq33B3TgYWYYZw3bL65vM1UXg9rWeN+8OFKmEAlkDGiIMA6FTHrvS8z3P3+DkvPDPfuMNcg4QEl/46ikvv/LrfPD9T/InfvR50izwz3/lFe6cbn/n36GO4ziO4zjOdz1nFyvSdkSaUBNisGbKFJsoYjf2Z32kn89ZLA7QqpRxw7geEFWSVGoQZDcTz0Qew67Hw1SX10LXdcwWS/IwUNZbFCWmfudRDCE2B58SJLZZlvFSgtGUkNSu+bUl8DSxMoRI33eMNTPmjKrVh7s0lBaxSns/VHcuvTy2uRhiIhRNhJIgoM1huZt5GZooakVITIHl4SEonDw4IQ/jrv4L0WZLVpo7j1aTiAmrxMCVa1cA5ezBCTVXQmt+brY2c/IFOw7mhC2UXHbCYQyxNWtW5sslIoGL83Nb3+b6a9P4LHq1VkrO065rh2tyz5lwQ7CmXCr7dKJi+1tESF1EtZJz2R9voJJBlH7eIzFSc26uP5t8GKI1LdPiUTVYS3mtdTdDcTcDMmob62L7OiSb2YgqRTOp76mltqbW0ARGba7cAFqt8Tm15ue2XErJxKm22dMonyk7SxA0CFX2Mw+Vsts/trW0W07FMrxiQjFXocS426dWi5p7uVRlK4GunxNDJFeLRk4xmVDWBMF5n6DF8aaU6DqLZrbPpLkpd87Ndr9rqtv3d0aaQIelSk1CY61q81zFHLKqD0uQIibaKdYIYM5SE49V666GLmqJR7VWcsnkYq7anAfysKVsB/J2IBdr+FYiIXTEqJS8QcaRrh/pYkdIk0CZ6GaFWk2ElWD3XyahfDp+4bIDMzR3ZPt/oJ0Dk4syTsu32brTuRibaC9ht92O4ziO4zhfj3ctVIZgkR0SbfZjwcSooEIIykxHqp4zjIlhKxRGImuqVLrQAxlSj4pdwIz0BOYsZKDmDStZ0sUVCwa28YigCU1i3XAixDhFp2aSgGpmMwZyqGhoef+jIhKZzSKzLtJ3kRg7qgixUxazJUrHWEfevH+fn/rjP8BXvvI6H//EzxJDx8uvfpo/+rFPIHLByy9/iV//7ZcZSSyWc1595TXuvHHKsG0dm1pRDeQWU1K0suyVbZFLHZ1i6y5KFyEEE4XGodLFQEkrtGYkHFBc2+qEAAAgAElEQVSlZ9RCzuZ6nCJvjmbCqw8CL75Z+Mhxz2snIxdrCLNAuLvg5jXhxuGc06HQ5UIREzdzyub+1NpcfWDNbPuuv1Jr6w61AinXympdmdVEl+yCU9WEvySQ+kTplLE5Qc35GJj3YoJnu+Cd6lpRi+4RVVozbZvLoaRgF7WKUmQfFUQUlLATuqZ0l6kADlLpQ0AoKJEuVkKEUqbSwWZY1GJOVxBqFUqFUsViWiq743Lv3shYI2VUHpwV1jnw6lsjt27O2GwCz9/ueGs9shoyQx7YZhirFUPTvNQQAkUFLYpmE18Dtq1aK5vtCAgSdJcKIxJaJ6fF5vRBOLzSMQyVqzdgcdhzIJF8kVnVwIsvX/BTP/pBXnz9Ph/76A9wcX7K408+w6c+f5fnP/AM//TVz3J04yo/9LEb9Cinb7/J+ZgZxy15HFhdZMq4IaRI30MuidgclJfZRbbysBtSWzSMElp0zaU5FpMzsi1fazUBk2n+hRVxU2wrtFk0uxsbOp2cTegUpiRY0QSxcK1TtnnLqnbtfDSRfbMauXHrgL4T5hKomvmpj97i0198YHN9CLz4+prve3bJxTaz3rTzQiASQSofee8VRi386mcesB0zUTokWTyXhTxV3rp3j83qHE0dP/aJD3D/5PzdfpU6zu8pzx17l7LjOI7jfCfx9ukZKUZmsSOFQBcCfRcYo9BFJaTEYnnIfHmDGGdcnJ1T8kAMQheDiUYJqtnv6CXZ9XKFKtbMaAKm0KU5B0fX6PoZ64szSz5q4htiYqE0p9M0Q9HcUInJPcXk5pNpbEPYOQFjSjsBYjMOJgDqfkiESIvqZB/ZSnuezdZrjZutKVa4LG5Oe2zfvKiYQBRE6GYdy+WC9XrNerWyurWtdWyzAqdaRiw6yZqFSyWGyPH1K6SYOLl3nzzmNuIkWNRlbbWaQNeEwVoyVKXkvHOYhWk/dx0HB0vu37tnomJT4oLF0lAR+n7OerN6KCqTS/vJNk1aDV52j9WardFVxMRGbTM6acdRLRVKEbrZjBgipVrc52yeKFpt3miIjM3lOo1qEZUmJEWo5pC0GFWL49Viy1mU595dJyLUOLl+rWEcoUX6AgRCiqSuOeuao25y1U2uWNuI3dnSbpFIE1Ptnoe94F7w3rlirSBt21LJY4HO4kztDSJax109uh0GRAJ9mpn4Vyupi8TQQXN0pmiipAikFOm6GTEFm596ySkozQ041cS7WY1abZ8qFulM3Z3HAbsHsRcrZbo9sVtm/8mZRGWlttCfunsfWv1cqbVQaiGXzDgW8ljIOTMMA+M4UlRRLKVqcjqSAnG7pU8dsUv0Xc+8nyOhIh3E0JkbubkjxSLJCDK5JQNpiu2dnLExmvgtUz1vguQkVE4pTbu4WKaZpLXNoHWcbz/PHQde/Ks/++1eDcdxHOcSvwtHpc3XsOgQ6DQSQqWTAbYnDMNIpm/uqC0pCdR1a0QL1KLEtCBIap11oBpY64wudfRlA6VnFGHBCSUeM9YepZqPMwdUc4s3qYzDmvUwIGFLLokShXGI5JzQGknSE2aB5aHQzRbMFzNms0DfJa5fvcVTT9/kqVvP8oHv+RgpLZktrvLe932C7fYBv/yvfoHzi8wzTz/DP/0Xn+Kzv/0Vzs+HfVehWCdoUCFEpY+JLgYO0wAUjg8s+rXv7KI4j+ZOLDWDJMY6sikDIjMSiVm3IBEYrGZqok6h72DOjLfOYQiJoSSyQAwRZeBsWNOtjzlazrmRt5ytI6vB9pdFxoRLgpIVKVUrNStjUYZSLHIFmrvORKLVJhPEujJjKxRVtc3fANQubFHQCF2nSLBqYipArdN1ajY1wVYCLRKXFkkzFZawK06mPkWxouiyAxSUa1cO+MgHZvR9h4gSJdnjrSOwtuKvtve1gsKETGVy7FVSUsYKpyshxMrFCk421hV4nhf0F8Kbp6+x6GZcXQqnqwHVnlw6FMilUHXfDZyLtLgUI4aIaiY30c6Kw9YxqmpdibFSamAe4OBwwXLek7rErXng5pXAracCm9qzDGuKDAw64+knnuDw+hO8530fQkJkefAbPHvrNvojwq3rV3j7zbfJ4znb7YYHK+H0rLJaBZARNFMyiMZdp2doAmFtczD2na20okr3v1QFKbsu6P38yElltkLOYn7YOy9VzVA9GSeBJFNoVZ3MlK1blVaQBgpi0Twp8tMfv8ov/fIrxNpTsf3X98Irr73Baq1ItHsTR0uh73uu9x2SKl3pKD289Oaax64k3hwDgyoHfWAZI+uh8tKbZ5yshCggIVGwrm87LQtPX58zqPLy62cogZde/hVuXT9411+ljuM4juM4zncvU6pNH1qMqVZCtZmDoes4Pr7GwdERYyncv/sWUjKpS0gMZI1ISKB7MRJMBKhqzbHWxJuYL49YLI+oCherC1DamBGbFxjaqI+dgHBJiKJdg1sT605pYT+n0MQJm2EItYwmUk7uzqlyk/3ztIlTIYQWx1ovCaT7uXWlTjE/++jMaQjE1Ni6WC6JMXJxfsFmu2770fZGbK66UgpTLOfkDFRVYopcObpCSh2nD05bLb6fvSkaQKwONSErst1uEYExtzqguUztNeHw8Ij1+YUJr019mlyfijkJa1W03S+YxL4JVXbzAad9tBuFAUjcizla4LK6paqUUuz8CW3+Z3PrTnVmkEDJhZj6JnIVa7qc3HDR5l3uojrFmk+tfp7SgsLuXFNVQpzW30S+ycFqwUk29ialuBNsp7rSXkSs0le1ZKTJOWovd0nI1d1dgJbdxRRKVRVqKSQRtFbGbPHBfT9HJCKSMMGvIAJVC3kcSdFcktY73uJog61jSsFmULbo15TSpZmL0aKYm6A/HT4J7f5Ccz1qNRdkDM25is2UtGZlQYvFg6mE3flzGYsMnsYSKbVcqrdVrCGh6q4+r7WQy0jO2QTLPJLHkZwLpUJlBMZ2LyJCtGNVup5+1puLOHZmAAC6EIldooudRftGG2ETJBDbOTZ99i//m4TK6RhJu19D254gbQ4mrWt911bgjkrHcRzHcb4+71qo1DYPQFUIWpmlARnvU0ZhoweMZSCGDGUkxL4NAB8JpJ0ApdViYi2oQ0z0QMgKRWYW6VrOybUnyDkzmTOEg9ZAqoQKNWiLaRW6GKkhQGlRpghsBySfU4cl5xcL4r0z5rOeg+Njnnv2Bi+8/yZPPnWDw8OrDJp56spzhLhEBLqwoMiWD3/wE/zmb/8yP//z/4ivvPKAcbQOtVotQkYpJmq0QfJjVcY8cj1Z9GuMiUilaKGWSs7TrI1AppgQWXqiCEWUmCGkSpBIn0rrDgzMuwCD8NrJQCmVbamsNpU03EPHkXONhLN2YVrOyGNgs+nI2OyN2XKBaG1uQ+uSHXOlltqG0le76GZfmExFV6kmxjEJs5YvdDm9pEWAQBeEPKwJMQJWRNtsiamIrKSYmpNzJIREbbMyq9Zd42TrqWwzUJtEPQlgrQM1BVhUm8kZxMTAKIJqYSxKyJkpLtScfXbBb43CitAhoTDrCttB2YzmMDzfJHLNBIUaKidngTv3j3n2+Svw8j1K7Zj1G87WFscKUKhtRotecoBacTHYGYs2B6vWggQhddi+VqjZOiJzhp4LYsnUruf42iEHh0vms8haOh6/seDw2k1mVxZ8z3t/iLfvv8ljNz7IavuAj//Ij/HY1evcuPp5vvz5z7MZR/Km8PbbZ9x5s6eOSq5QdU5BiLq61Bk6RdKUqUQG9t2cu+J7ckdONzfqw9XWZSflw3+/JFReeh1BmHqI2y2KVplO8UJ2DuaqxBa5c3W+RMKM7WBzTWIorAcoWbgYMmOxAun6ofDanS3LOVAHtgTCEFjFyulF5WiRuXI8Y9EL5WxBODtjGDdo7SjBiuAQOiAjUrl1NXKyrpxeZDQoSRVC4s6JR786juM4juM4X8ssRhNxRFrNIqgE0vKAG7cfRwRW6zWatwQKsbflgwhalVoKUJFQLQ0GWsxiQqI5xA4OrzBbHjGOI1qVbmooFggpIKFrgsPeTWm1fGugLe9QT5A2ysFcfX1MFj05DiihqWeWDqS7+Bx75lQLTAJinhyJYS9O2nI0ZVMeqikvi3IxJJYHS6oWzs5PKTk3Qc6cd9LqhFLMyTZN+5QgzSUZOT6+Qpd6zs5PGYYRoIkol+UxiJ2JVMN2sIQcizZimjcZggmB8/nCokW3WxN9LE+pdeRaPG9KPcPW6oOHBWEbYhFadCg6OUfZC6stItccorrbNSYSm6NOmuBcS2lz/7BajhZvitiIjL6jlIIWq4O1CYYxClqDxdPqXmw2g64JW5MQGcTqecVEOjFrJiFgdbxUCLpz3yHsjvWu6bXFmEqz5u7qSbjkOK07VXKqTydxjhaN2sJrUS2UcWTQAQS6tGhOwCYUNjG0opRaSClZ07jYtqcUdtG0sQn4+3+xifnBErCaS9AEa1vTFCOlNjesWj2s8rAYjdg9EG0OWATa8E52HbutLhYmAd8+GFUrWqbHFSZR1F7M5nHmYudDzpTSRMxiM1J3Yq+OaLZZpWCpVtr1oHY/posds35GP5+Rou2L0CUCAWkjbMxVOjlkm2ArFtusTAKrHT+Z4q+o75Ak25gYoQmXjuM4juM4X8u7FipFIoTALAz0+QGb1UiOV6CbE8jMoglAVN27o9SiEwlKkDlFTDRp15GtGNLdRWUsypYrxDjS1YLKhqWuGcI1KpEaBM0XpG5gPYKQyKGzC6RoAqqUM0ZGxtWGg/lNUhcZh8JXvnyHV155k1/7tc/wxM0jfuqnPsKf+tMfJ8YlUNB2MTqbHfHg5HPU7Rkf+v6nWB503Hn1jJOTc1ZrYRiL+ftqpSBIbY49VWIqnI+B1WbTesmq9ZFNRrFqnX6iHapCPw6UWLh3Ec1BKDaDJMRIwtxm5+vKg61SqrI6L6zHwpU0sGHGkBOpVup4n3m8y+Hsac63FcnKLK6QMjMTHCb0SrWLVeuqhE4SpVicrsV0XhKpaC63GKklW2SQ7rsq9/8X8qCMo5LE5kvYjM5KKdm6NFGGYYAgdJJY15Ggbe5Ku2gXMXumREWrUKVATWgxMVAC5FqQLnJ6YfM5EnNCVAqBkiu1ZmJQiiqIdffZ6IeKtMzXHJTUWdfjeitsy0DMiW3ZMA777r91ybx2WlieKCF0dCFyPlygkttcE2kxJkLadTg3MX6quaQVXpd2Vy32dxUxt2qIiCg5Kw/Ot6zKirsnW9ZnK55/csmtZ5/hvc9eQ7urdiMjBN7zwh9BYscy3uT9L/wob73xGxAhHB1w9sVX+K0X7xDPR2ItlDqDkhGtiGTMDauYsfNSfKtO5kn7LNLOafvw07ZJHyo+v/Y74nJx+vDrw34/WNzvXtgN0W6MaL3k1BQlilKqFcebIixnM+5sCkEVCZGj5cDVQ+XHfuI9fPH1z1DGLbnOePVe5YO3e2BAKlSpJOm4ciA8dnTA3TP4rVcvePa4kLUQJVFrQCzJCh1HZqlw5UB44wGMo8UIUQJFgLrv/HUcx3Ecx3Gcy/RJmKYK1grMlxxfv8Hh8SHr9QVl2NDHQN/ZTDyJEFPX6ovJgaXsZiFgAiZJWCyWHB5dB42sz0+IKRGlsyZaFA3BhE1V4mUxZBIRWsxm1RbJqrIXGELYzejbbre7xsXJscgkXrWa1WoHbWKdOQRzzkzRrNJGfeybGfcNjKa0TR46WgRrz3KxYLvdstpcPBShOkVxSgg2m89sh01EsxpGYuT4aEEMibPzc8ZxvOTos9fY1bohkbqOYdgiMaAlo1oIEvZX+WIpRfP5jLOzc9sHMtWue9E0pLDbtofiU9vW7Zx5uv952qZdzOqutfvhx6o2MTFaQtVOFGzzJG02ZaKMma7vbVtyNtcql5pCxZyFtNEkEiNka1ZN3QwNkzuuzSiUsLtnE2ObiZos7Siyn0k57dfdNj8k0rIT3iahcppHKlPTLJOIaU7bkkdqyfa5aedHrTZPsuRK1sJmvUGWnZ3foWs3leru/JjMialPdpyiNAelzWpMKe0clja/cRLULzt/99syOXFjSyQqpezO6SkyNzTXZZBp1M00DgVr5m4NB1ONvLsfJkJsMz9zKRS0vb6NTimlUrJSitXmuWqLe52kwObwbL/nqs3hao5SxGJ7Y9fR9zPm8znz+ZxuMTdHpQQkTSLtft7k9L2xF2Ind6QJtaElbe1cwTqJyjY4ZTqRXaJ0HMdxHOeb8a6Fylm3JdUVuhpZxQVhfpNZ11vHZ7XOS7COUWGKvpgUm4AEpQjkKgwlNIlrf7M/EFGxeZNFE8oVkmwpbJnXuwzBOkYh0R0sGMsWEKRkRkmkPFJ1TUgH5LKlSzO29YwyXGPMI1ULYdjCwXVuPXGd93/f99LFA8q4JqYFFHMyjmXFqJGnn38f0i0IUTicJd56O/Hg/oazszWbzUAt2q6JlWHM5KwsUuHtiyZaYdEaddc5N4mVGZGEksiqJA1E1qjMdw7CXAohVqLCxbDhbJ3Z5MhYBpJCCkds15FNzhRNSHmL7vCYbRlb/EikVlivh3axaH1sU6xOrZMD1a7rSxtCT5thWau2mM+A5AISyHWkq9FEuiZEa7uILzVQtHJ+WgghUoruCkErbAWRQgiJoazQovRJgdS6FlvxLQGthZQCuUKIW9AEUkhRqMVck7kUqD0pnKNq7smxZPq+UorNhLCOUKWL0aKPgKyVpJkQIut1ZczCOo/kruNsk1lv7RjlCqKFB2t480FhO2YWMXFGBbViuzLF6mZq6xas037Uhws0nboQdeo+VBMMYyCKXchvQ4/qSC6VMW95895IKRf82kvnvPqVQ97/wY/wkY99lMXxk83xZ3GuSuTG7e/npa++yG/96qd58Ut32Z5vOEihHasRkYqSCVIodUEXRuvEnObJaItdwsTxernZALFsm+n8eUfx+fAcy4fFu4c7qC+/5u4j0d6/zbdoUUbTsrMYuagF0cLppnC06AgPshWWVM4vhHozcNxnhnXhqceE1+8VDhcDR4slSZSCcPNa4PFrPW/cH/n1L1/w9LXAPCk5R2qpaBlNiFRTZOd9YTGPvP1AKNVuWIySCTW1QlW/Zlsdx3Ecx3EcB2CoVoMVSdy4eoMb164RgdXJCUEqqbm4Yoo7JxvN0YVMMwXVxnDUFqmpgfnygO7gkNXqgjKMxBjJMRJjanMEO6R0Nn8y2XV4aDMp93GlLamo1WpTLGeMHXSBUpVhGK2ep4mfu/gb+4vVeMGEJjGxptZKLlOqzn52nTmwwt6FOdX/O1OlNSjOZ3NS13OxWlnNP4mUrf6ozRVa1bxbk+Aq0JJ3AoeHR1RRzi8uLD6zlF3D8EMKYRBiiuRadsk+peznawqYu6xF0K7WG8ZsyTuioCKoTuNOmmCnShCoTWje18KTALYXvURkP1sztOXYi5ZTLGzVSoi0WtqOXey6yQtp+7VaQk4IHTFNTki7/xBCoGiLFW5iW8mlOQgTSjHRKQYItPhaKNXck5Pbckq8Mb037M6Lh4S8r4N57fZzUO0cKPuZptVGokxiZalKKZlazDkoMh2RYNGlEtFijaZ5tHsqISZiSCZ+RmluydhiTE2cJJjYGttnZZpRCVNTwF6glJYydTkqedoYExXNNTzVrNPzJ2/vdKxDiHa/pVYTmHnH66m5QPdiX6uxK2g1x3PJ1uScK5iBeEo5CuwlfCUQWi2vNn4lBBBzWIeYiLGj63pi6kh9T9f1pJToYiIGu1ey3/7LzQ3Tx6x9znT/mb0sUtq9o704qe27QxWbB+s4juM4jvMNeNdCZV1fUPsZY3+TbnlIIpLLloC52KYL18D+YtZy8i3EX7UQRZklIWZlPb6j686CKYk2tQ5FGJhTJYGumekJURLreMg8bTnfKLVm8uaUkoRe1hQ5ti66MUN/jJaR7cUFqokQR67fus0Pf+K9/OSPfYjt+RH/4pf/KR/7wR+iEJh3S05Wr7LoDvn5n/+bvPy5L9PPI4eHM47mgXq8oQ8XHMwGzh4M1BKQKpQibHPH+aAczgtvnSe6VCilWNddveRSE5BaWi+azbjMNRJlRtA1Ju0mAh0pWmzJybqyGUY0FDZ5AZpZM6cPmaqFMVfiIFxEYdQ2ClBs9qDWYPu+iU9Ftc1VbHMogEDaR9E0MU1oF5WtO7ELwoeen/ErXxjsT7vrzUANFm3Sd4XVes2IkLoFOQ+t41OQKlSB9facT335hF6EP/TeG8Ruip0RqhYU4dNffcDxMnD7uCcmK9Colb4V8RerNcdHC/K4YVtGi5VNMNYZIwfmwpSMDjZroXaJB91V5mXFchEo0rO5eJNNHrnYjmQVoiin54WXTjJXlz0Hi0iazXn1QebaY3CyqsRQmAcY0kitgUFrc2sKWev+Yl0fLtRMwNQ2k9M+DlMoimqltsJpm62LN2PHfV4DZRypY8/J/Qd85otf4qnnH+Pxp34AkrZiT5q4W3nhufcgf+Kcx37jRT7zWy+RLzaEC+WAFadF2JZEXxNbhXkoTPbB2kTTuuvMnDo9Yde93Xoh36nNXXZY2ukjX/P3h2ZeXnreflkr9KZi1wp3RQtIUBZJGEc4WxWOD6yA77pA0Mq2BFarke0gXD+AWntW24HUDRwsrnDzQFkcBtarxG99aYPNrlFeOVFuH8H5CrrQsS2ZThaMWjnqTJi/f2YRV7U5o2NNbVpu66L2/lDHcRzHcRzn61A1sZgvuH3zNgfzGZvVGTWPpGSz1FPX0c16YoomdoUOkrkQTXTsLG0nSHNkJRaLI0QCZw/uUcYt1EpNCQmREjpS7Ki5I8SEhEQtHTl1pNIRY2fz9BA0RGsOVEzoEui7DpHAMGxMAAt7IacqLZnFkmQs7rFFsQYhSbC0kVxaVddqgmDCySToAK1+sdrC6g2bL3mwPKTWyurivEW62vJRgokuCEmVYnmgNqpjJxAJIpWj4wMEOD87QwjUUhFJ0GYBMgkmtRKTJbbUUkkSGcfckoPsOl/FhL+u79EC43ZNqNZQrDtHpTU5KkKQRC7jTsidFJ2pwdFELhO4lL0r0lan7oIzzcFpL5NzJgTQGgkxNBfbNPpEUS1N4Iw7YdTmJ7aabhKHwzRrUigEVDMp2lzOFFMTkmQ3ezDGgIZCFEv9IaiJc23TTBRr80AnYU8BafNIac25mGClk3grtBjjaGKvmtsQZV+HtqZqEQjR9q0Jc+b0DEFMfxclly1JZogoqUvUkgnStisluhSbY3Ka0xqaYxREEikJtRYThKt91uxOykNydfscBHYzcER3UbEWU6vWkB0DhNQE1iZqtmblUhUoTHGy03mgqhYNO81ECQFps2BLzVQdqTVT2r/axg5J20/a/kmwNTdnpn3GY4ykECEkpH0nhBiRGNEQiNpm5saExmm/mwhtKV+1pUNNzt6KqNXFqmo/i0UMU6FQoNSdc5ZLQqYnETmO4ziO84149zMq4yHrcMDx4VXrIswrEkJoF9NSWwegmIsuhNwudgJEhWoOtBiU0JsQebG1wseu3pXQ4j+sw6yg1pbIqmwZwlX6tOYonLAIifUwUiUyFEWGuwyz6yZSFtk5s/rZAVrvkmTB8+95ng9/5DmOjzv+wS99jis37vHsEwvePv0c/+qff4o//EM/yL/8lV/kuSdf4IlnbvKLf+cfU7aZWipdsgvnlJSD5RKhMAsW46oaSMzpqjJPECSzTAmNgoSEqnWXjbVSKmzHEZUOWnSH1IhEqDJDZKDWDX3KRA3UskXqfa7Ol2xyITMyZ8VTVyJPXEkUEvPuLldnI9ePTolyj5wjp2PP/YvCm6fKmyvhYtVzdyUMORDFIlds/sQ+piagoMHmZkYIrVhTiYxl5O6DniRQp2KEfWdlCBZbdOvWguWiYzZbsDq7MKFWbJ5BrYXTiw1f+Oo5N64seeHJa8QQscAasHImcGeTyNvK+589NNE7BuvKawXp+XrgcB4spkctLvdwHtB0wMUQrXwOglaL40nzQ372z/5HWI0bOLvzMi/90s+juXAVQQlorly7UrkrI32qHB7MeOJa4v+Vu1ysBlbbzGJeiJqZ9TZ7dBhsToU2ka9VrtOn5aH4nqk4nzpZRay4LS1CNJcpcheQjGpkyHV3zj3//if5oz/y41y7/gSvfPlf8dR7f5BAYL19QNLEWLZ88TOf4fTkhOPFgu/9wBPkiyUlnPHa2x0zLsi1wNBmzLZO2KkLuYrsiqUpvQUuC47WQa3v+Jtt1r4DdBJjLc7mUsf0bk+0/8q+cJFgzy06zbXYi7hjgeWsQ3Pl3umW2weRFCPzKGwGK+yHoVDrwONXA59+fbDtyYokeO7WAc/dXhJi4q2757z5YGA7ZpaLOauLDd9z+xbf9+T7OducUbF98/qJ8trb5zxYF043yqBQiwm6nUAN8OyNA77/qeW7/CZ1HMdxHMdxvpt5/uknuHrlKrUUzk7PoFZS1xOkEmOi72f0fW+1a6sHtFhVJNEaW1WssTX2M+bzBbVkVhcXJohNkZhaiWpuvtKiWUUrgWoiVS0Uq8ap2sQWhYASQiKEQNclqip5GMxBJzbuQyfPVhMqmuayS8wJlnFpTsRdIsreNfbOERP7xse9kJFSx2w2Z9iODNvhoUbHSQiDyT2oiIbmJqw712EMkcXRESicnp2a2Hap1ghBmqhitVVMCYmQh0wMkTyO5oS7bCETc7x2Xc/q4my/PrBLVplEuRj29XTbQXvRs7lGbdmpGpK2XpFay04QDpiYZ4KjuQmDBHQ3L1GsiVJpCUJ7198U2TnNrFTduzhjmzUamkAtEptgFYh0SK3mVJSKhECKqZ0jbeaklP34F6Htq2k929ER2UXRtoJ25yTdOyfNc2huykkkD030svtBUaxZWmJq+3RKfbJ41ZQSVEsFmuJZp9mYJkQKXdeRUnrHLEqbpWmO00k8j80JvD9X7Vjs138vUu5Fy50g3Erk3eRNhShCbdG605GOwZyWuafy4ywAACAASURBVLbP5PTIQ83fX9sQbEk/JqLWUqmlUoq2j/7kuraUskhoY4xCa0aYZks24Z197V5Ki65NSmlS53RvYLorI9rSt9TcutRqI42qtCQui6QuTEKl2s9V22zUfbOBN/c6juM4jvPNeNdCZQmBw8NjQuqo45ooEGPdFS0hTMXAdJUVLl3gCUEiWc1NGKSw6DrWA1ZYVbVYE6xTC4VrVxLn6wsoa5BjxhAo9SqiAyldcHGWQLeIWNRoxMZ7g1Iq3Lw657HHhAcnh9y48Rg3n7jCyy+/zWY7MF/M+cJLrzH/6JOsV/f50pe+xJPPHLJdnfP//L1/wE/+9I/w9NM3+cJnv0qKwjBWhm1mGLe8nk+YdYE+CrOUKDoCga6HKEfUeo6OQq4zuu4msRNKrkQJxCAMmlFJaF5B3UCIUKa4XMG67S5QlFJnzDjjB55bcX4xsN709Nc2/MU/rhxfO+DLXznl+WfmhJjYrlfEzl6nizNyUbSetqiQyv/2D9f80qeU28eJ44PE9aNEF6oVW0AK1tWKWCE762bM5jMkWWxJHy/IGsm1st0Kf+c3hDFXmy8ogEYCgb5fWsduO44SmwgdAKkESSaWSbTOUsGKarEL6ySRHNj9brQZIEWR0Le/2axIiQEJ0URtLLq0VEGqXXDXcQubM6RfkLoDDo8fZ358hbLZMl5sLB4ngITIYg6dBEKyruKsyulm5HxjornJVYkYmiC261pVIFjh0CqOIvqwTrfDyv798bbfa1WqZIKsQIQQO24/vuSZF57igx94ji985rPce/CPuf34LY6u3eKNV17k+Rf+CL/+63+boxu3+eprr/Dip77IvO+JsiUwsljA7RtzVnPlYrbh9CwzrC3HZxelo/volv2/r3VGotrigy9VVTJ1vrIv1HYOSp1U2t2WT8WSFb3719E6LW9xykHseOdc0V45WvZcbEaObsxJ4ZzDec96U6jANhcuzjMXG6WsMv/ujz7DydkJR8uexw8Tf+jZQ96++4Bnn+v4pU+dcDgLfPxDt/jVz7xGoPClO2cs+8BTV4X3PnWNL79ZuffggpOLzKKLXE2JwxSY9UJIQgrKsitszt7+1r44HcdxHMdxnH+juH3zBsN2Sxm2pCgUIjH1pDYrD4FSizmRarFaCEGjoK2ZVENgsTxiPjtgvV6RhxUWOQISo82kDNHckjEBU5SsRV4Sxebl0eIn1WYdCiZgzGYzQMg5Tz2JlxoGddeLuLu2r5VW0GHuNhv9cVmkvMzDs+qbmFebe0+VlMyxuF5fUMYWG1mnGZiyMydOok7dlRRiLkLMxbZcHgLC2dkpokKM0uoJWhbK1HzbmqZjJJeBGNJ+duZu2wMqJn7N5zNyzuRiszy1Ws0I7ERSaHGp1vLI1AR6uX91chjSGlV3Pb8qu1mG+y3b77sUOyanY5BIKWW3NTG2GaFi+ya04zI5KwmtWRw7B4oqhEhQiyQNbSZjiDYuJUqkSiWGJug116M0N+TkA1SZnHzsInMvr/hDcuzueKm5cttxtUkzk5u0eUmnERzYOS1qLsFJ2JvKyRgjNUaqWq2IKhICsTmAQxBS2guVaYqBbTG+MUTQ2oRKMdE2yM4ZGdoYnMsi6zTH9bLIPInUNjXERLmqSoh7QVur7gRkghJauhWXXmfatl25Xaco2CaM7tyM1uCei903owmzKSSCTvHNsQn5LSY5hCaiQ8mVccwM40hKHSUVci2Ett0xsjve9pk1wbuaVdJ+r5bGVLQ5O1UpUtFS0aJUMrU0UVWH/XDKwNd8NziO4ziO40y8a6Hyla984bv+CuMnfmL/8x/7t/7it29FvkVu/A6W/cv/Mfzl38P3/q/f5fP+zL/m8R9+l6/7rTIHPvq+P/11H/uZd/z+p/7S7/PK/C649eSHAfiRP/YXAPjwH/5z387VeWT8D9/g7//lt/Dc/+xbfI/v4MPuOI7jOI7jfIfzX/2v//C7vm52HMdxHMdxHMf53RD+9Ys4juM4juM4juM4juM4juM4juM4juP83uJCpeM4juM4juM4juM4juM4juM4juM4jxwXKh3HcRzHcRzHcRzHcRzHcRzHcRzHeeS4UOk4juM4juM4juM4juM4juM4juM4ziPHhUrHcRzHcRzHcRzHcRzHcRzHcRzHcR45LlQ6juM4juM4juM4juM4juM4juM4jvPISd/uFXAcx3Ec5/eGl0/rt3sVHMdxHMdxHMdxHOc7lpdPK+/5S3/nmy7z0l/92Ue0No7jOA64o9JxHMdxHMdxHMdxHMdxHMdxHMdxnG8DLlQ6juM4juM4juM4juM4juM4juM4jvPIcaHScRzHcRzHcRzHcRzHcRzHcRzHcZxHjguVjuM4juM4juM4juM4juM4juM4juM8clyodBzHcRzHcRzHcRzHcRzHcRzHcRznkeNCpeM4juM4juM4juM4juM4juM4juM4jxwXKh3HcRzHcRzHcRzHcRzHcRzHcRzHeeS4UOk4juM4juM4juM4juM4juM4juM4ziPHhUrHcRzHcRzHcRzHcRzHcRzHcRzHcR45LlQ6juM4juM4juM4juM4juM4juM4jvPIcaHScRzHcRzHcRzHcRzHcRzHcRzHcZxHjguVjuM4juM4juM4juM4juM4juM4juM8clyodBzHcRzHcRzHcRzHcRzHcRzHcRznkeNCpeM4juM4juM4juM4juM4juM4juM4jxwXKh3HcRzHcRzHcRzHcRzHcRzHcRzHeeS4UOk4juM4juM4juM4juM4juM4juM4ziPHhUrHcRzHcRzHcRzHcRzHcRzHcRzHcR45LlQ6juM4juM4juM4juM4juM4juM4jvPIcaHScRzHcRzHcRzHcRzHcRzHcRzHcZxHjguVjuM4juM4juM4juM4juM4juM4juM8clyodBzHcb5jEZH3iIiKyM/9Hr6misgnfwfL/2R7zl/5vVoHx3Ecx3Ecx3Ecx/lO5zulHhaRv9LW4ye/nevhOI7j/P7gQqXjOI7jOI7jOI7jOI7jOI7jOI7jOI+c9O1eAcdxHMd5xHwfsPp2r4TjOI7jOI7jOI7jfIfzL7Ea+u1v94o4juM43724UOk4juP8G4WqfvbbvQ6O4ziO4ziO4ziO852Oqq4Ar6Edx3Gc31c8+tVxHMf5A4GIfK+I/C0RuSciFyLyT0TkT7xjmT/f5lb8eRH5aRH5pIg8EBG9tMzXnVEpIrdF5G+IyJsishaRXxeR/+Bfs04fE5FfFJEzETkVkb8vIp/4ZvMz2nb8nIh8VUSG9n7/u4h8z7vfO47jOI7jOI7jOM53CyLyZ0TkH4jI6yKyFZHXROQfich/+o7lflBE/t63UpOKyHva337uG7znJy/Xzu1vX3dG5bSsiPQi8t+IyOfaev7ct/J4W+ZpEflrIvKl9thdEfnbIvKx3+XucxzHcf6A4Y5Kx3Ec5w8CzwP/HPgU8D8DTwD/HvALIvLvq+r/8Y7l/x3gp4FfAP468Nw3e3EReQz4Z8ALwD9p/55oz/3Fb/CcH2+PReDngS8CHwJ+CfiH3+A5P92W7YD/C/gC8DTwbwM/KyI/paq/+s3W1XEcx3Ecx3Ecx/nuRUT+E6zufQOrG98GbgEfBv5D4H9sy/0w8PeBHqszvwB8BPgk36Am/X3g/wQ+htXefwu48608LiIfxerp68D/ja3/Y8CfBf6JiPw5Vf27j2IDHMdxnG8/LlQ6juM4fxD4ceC/U9X/YvqDiPw1TLz86yLyC6p6emn5nwF+RlX/3rf4+v8tJlL+96r6n3+d93gIEQnA3wBm7X1+4dJjfwH4n77Oc64BfxObj/njqvrpS4/9IeBfAP8L8NFvtqIi8v99g4e+F+CTn/zkN3u68w7Ozs4A32+/U3y/vTt8v7073s1+m57jOI7z/7N372GWlNWh/7+rau/unoFBbioSBYKiBEXwFuN9kBOjEoPRmMsxiYgaDRJjAucX4iVBY54YT2IM3mMkJILXeCGKKEQdUAh4QVAERyGOHCKgKDADM9299671+6Oqh6bpnp7u3r1398z38zz11HTVW2+tql3d06tX1VuStAq9HJgEjsrMexT+mptsiYgAzgTWAM/NzHOntflj4G0DivVg4BGZOdc7LO+1PiJawEeBPYFjMvOiaesOBL4GvD8iDsnMicUENV/ePB9/Xx8O86WVzc9nZVvtebNDv0qSVoM7gDdOX5CZXwfOAfYGfn1G+3N3tkgZEW3ghcAW4PQ59jHTE4GHAF+aXqRs/BPwvVm2+f0m1r+cXqRs9nM18D7gURFxxM7ELUmSJEnaZXWBzsyF0wp+TwQeBlw8vUjZeAf1iD+D8PodFCnnWn8c8GDg7dOLlACZ+SPgLcABwLF9jVSStGL5RKUkaTW4IjNnu81nA/Ai4FHAv05b/tUF9H04sBb4cmbesYN9TPeoZv6VmY0zs4qIS4GHzlj1hGZ+1Mz3ezSm2v8CcM0s66f6f8xsy5s7Rh+9fv36uTbVLKbuNPO8LYznbXE8b4uzmPO2bt265QlGkiRp+Z0D/D1wTUR8GLgIuCQzfzKtzdRIPBfN3DgzexHxFepi4HKbL/eebf1UbnzwHLnxYc38F4BFDf86X9483/b+vj4c5ksrm5/Pyrba82YLlZKk1eCWOZbf3MzvM8fynTG17Xz7WMg2sy3fr5m/bJ549pxnvSRJkiRpF5WZb42IW4GTgFcBrwYyIi4C/k8z8s9i8tjlMN9+Zls/lRu/YJ5tzY0laTdhoVKStBrcf47lBzTzmU9C5gL6ntp2vn1MN/U+zLm2mW351H6Oysxv7WRskiRJkqTdTGb+G/BvEbE39TCvvw6cCHw+Ig5ncXls1czn+nvw3ouIc4e59xzrp2I/PjP/Y6H7lCTtenxHpSRpNXh0RMw2HsH6Zv7NJfT9XWArcHREzHwyc/o+ppva35NnroiIgjqRnOmyZv6URcQoSZIkSdrNZObtmfnZzHwZcBawL/BU4IqmydNmbhMRJbPkqsBtzfxBs2yzF/d+fclyMTeWJN2DhUpJ0mpwH+Avpi+IiMcCL6S+G/OTi+04MzvU7wBZB5w+xz5mugS4HjgmIp41Y90fMHuC9y/A7cBfRsQvzlwZEUVErF9o/JIkSZKkXUdEHBMRMcuq+zXzrcClwEbgqRFx/Ix2JzPL+ykzcwv1jbpPiogjpu2vBN4KrOlD+DvjXOp8+pUR8ezZGkTEEyJi7YDikSQNmUO/SpJWg4uBl0bE46mLhA8Afov6hpuXZ+bmHW28E14DHAu8uilOfmXaPj4L/Nr0xplZRcRLgc8B/xERH6dOtB4J/DJwPvAs7h5ah8z8aUT8BnVR9bKI+ALwHephah8EPIH6XR1jSzwWSZIkSdLq9Ungzoi4DNgEBPXTh48DvgH8Z2ZmRLwEuBD4eER8ArgOOJo6t/0c8MxZ+v6/wPuBSyLiY8A4cAzQBq4CjlrG4wLqm4Uj4nnA54HzIuJS4ErqAuyDqI/zUOqcfOtyxyNJGj6fqJQkrQY/oB5O9TbgFcBvUg918+zM/MhSO8/MW4EnUT/1eDjwauoE7w+Bf5hjmw3Uw+xsAI4DXkV9B+oxwH83zTbP2OYL1MXMdwGHNMfyEuARwBeB317qsUiSJEmSVrXTgK8BjwZOAl5MXUj8M+CYZlQgMvMS6gLmf1LfKPtHwAj160sun63jzDwTeCnwI+BF1Ln1pdT58O3LdUCzxPEt6qLo31KPoPRi6vz7MdSvWvk94NZBxSNJGi6fqJQkrViZuYn67tEpM4e0mdn+LOr3duyozWxD6JCZNwMnzrHZXNtcTv0E5T0bR/wd0AO+P8s2m6iH4pEkSZIk6R4y8z3Ae3ay7TeY5cnJiPiVHWzzfuqnKmdaP0vbDcySD2fmvdouZH3T5sfURdnTdqLt6cx4VYskadfhE5WSJC1CRKyNiL1nWX4C9dOfF2TmXQMPTJIkSZIkSZJWCZ+olCRpcQ4CvhkRF1K/C6QFPAp4MvWQOacMMTZJkiRJkiRJWvEsVEqStDi3AOdQv6fyGGAUuJn6PZd/nZnXDzE2SZIkSZIkSVrxLFRKkrQImXkb8NJhxyFJkiRJ0nS+01GStJr4jkpJkiRJkiRJkiRJA2ehUpIkSZIkSZIkSdLAWaiUJEmSJEmSJEmSNHAWKiVJkiRJkiRJkiQNnIVKSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwFiolSZIkSZIkSZIkDZyFSkmSJEmSJEmSJEkDZ6FSkiRJkiRJkiRJ0sBZqJQkSZIkSZIkSZI0cBYqJUmSJEmSJEmSJA2chUpJkiRJkiRJkiRJA2ehUpIkSZIkSZIkSdLAWaiUJEmSJEmSJEmSNHAWKiVJkiRJkiRJkiQNXGvYAUiSpP44eC/vP5IkSZIkaS4H71XwvTcfN+wwJEnT+BdNSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwFiolSZIkSZIkSZIkDZyFSkmSJEmSJEmSJEkDZ6FSkiRJkiRJkiRJ0sBZqJQkSZIkSZIkSZI0cBYqJUmSJEmSJEmSJA2chUpJkiRJkiRJkiRJA2ehUpIkSZIkSZIkSdLAWaiUJEmSJEmSJEmSNHAWKiVJkiRJkiRJkiQNnIVKSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwkZnDjkGSJC1RRPx0dHR034c//OHDDmVV2bJlCwDr1q0bciSri+dtcTxvi7OY83bttdeybdu2n2XmfssVlyRJklYX8+aVzXxpZfPzWdlWe95soVKSpF1AREwAJXDVsGNZZQ5v5t8dahSrj+dtcTxvi7OY83YIsDkzf77/4UiSJGk1Mm9e8cyXVjY/n5VtVefNrWEHIEmS+uJqgMx8zLADWU0i4hvgeVsoz9vieN4Wx/MmSZKkPjFvXsH8vX9l8/NZ2Vb75+M7KiVJkiRJkiRJkiQNnIVKSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwFiolSZIkSZIkSZIkDVxk5rBjkCRJkiRJkiRJkrSb8YlKSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwFiolSZIkSZIkSZIkDZyFSkmSJEmSJEmSJEkDZ6FSkiRJkiRJkiRJ0sBZqJQkSZIkSZIkSZI0cBYqJUkaooh4YEScGRE/ioiJiNgUEW+LiH0W2M++zXabmn5+1PT7wOXe9zAsNfaI2CMiXhgRH4yI70bEXRGxJSK+HhGnRMTIHNvlDqbL+nuU/dePzzwiNsxzHsbm2O6IiPhoRPw4IsYjYmNEvCEi1vTvCJdHH6639fOcs6npQTO2W5XXW0T8RkS8PSK+HBGbm3jPXmRfCz73q/lakyRJ0sIMM6fW/IaVu2vn9Ov7Z0afT42IXpMHvqmf8e5u+vn5RMSjm++jG5u+bomIiyLi95cj9oWKzBx2DJIk7ZYi4sHApcD9gHOB7wK/CBwDbASelJk/3Yl+9mv6eSjwReBrwOHA8cCPgSdk5n8vx76HoR+xR8QzgfOBnwFfAq4D9gF+DTig6f/YzByfsV0CPwTOmqXbGzPznxd9YMusj9fbBuBpwBvmaPKmzOzO2Obx1NdmG/h34P8BTwceC1xCfa4nFn5Uy69P19shwAlzrD4SeB5wdWYeOWO7VXm9RcSVwFHAncCN1D+PzsnM311gPws+96v5WpMkSdLCDDOn1vyGmbtrfsvxd6GIWAd8C9gf2BP468x8XT/j3l308/OJiJOBfwRuA84D/gfYF3gE9d8WfrvvB7BQmenk5OTk5OQ0hAn4PJDAH81Y/tZm+Xt2sp/3Nu3/fsbyVzXLP7dc+16t5w04GnghMDJj+TrgG00/p8yyXQIbhn0Ohny9bah/hdzp/ZbANc0+fm3a8oK6kJTAacM+P8t93nbQ/4eafl41y7pVeb1RJ06HAQGsb47j7OU+96v9WnNycnJycnJyclrYNMyc2mkwn89ic3enwXw+s/R5JnVR+TVNH28a9nGu1qmPP9+eAVRNf+tmWd8e9rFmpk9USpI0DM2dUdcBm4AHZ2Y1bd064CbqP/LfLzPv2kE/e1Lf4VkBD8jMLdPWFcB/Awc3+/jvfu57GAYRe0T8b+Ac4DOZ+ZwZ6xK4KDPXL+oAhqSf523qicrMjJ3c99OBLwAXZ+bTZqw7FLie+qnBn88V9ovpcl9vEbE/9ROHFXBgZt4+Y/2qvN6mi4j11Hc+L+iJysWc+9V8rUmSJGlhhplTa37Dzt21Y8vx+UTE8cCngN8DWsC/4BOVi9Lnv+FcBTwEOChX6Mhp4DsqJUkalmOa+QXTf+EAaBKjS4C1wC/N088vAWuAS6YnVE0/U3dMTd9fP/c9DIOIvdPMu3Os3zsiToyI10TEKyNiJZ6nmfp+3iLityLitIj404h4VkSMztH06c38czNXNIn+96gT/0N3dt8DtNzX24uAUeBjM4uU06zG660fFnPuV/O1JkmSpIUZZk6t+a2E3F1z6+vnExH3A94HfCozz+5noLupvnw+EfEI4JHABcDPIuKYiDi1eb/rsc3NGCvCiglEkqTdzMOa+ffmWP/9Zv7QZeinX/sehkHEfmIzv1exo3EU8H7gr4F3AP8VEVdGxJFztF8JluO8fRj4G+Dvgc8CN0TEbwxo34Oy3LG/rJm/dwdtVuP11g+72882SZIkLcwwc2rNbyXk7ppbvz+f91HXml6xlKC0Xb8+n8c18x9Tv8bni8D/Bf4O+E/gyoh4yOLD7B8LlZIkDcd9mvkdc6yfWr73MvTTr30Pw7LG3rxg/JnAldTvVpjprcCTgPtSvxPjcdTvvjsK+GJE/Nxi9jsA/Txv5wLPAR5Ifefx4dQFy72Bj0TEM5dx34O2bLFHxNOok4+rM/PSOZqt1uutH3a3n22SJElamGHm1JrfsHN37VjfPp+IOBH4NeCkzLylD7Gpf5/P/Zr5S4BDgOOavh8KnA0cCZwXESOLjrRPLFRKkiQBEfE84G3AzcDzM7Mzs01mnpKZl2bmrZl5Z2Z+PTNfAHwc2B84dbBRD15m/kNmfiYz/yczxzNzY2a+BjiF+nfLvxlyiKvFHzTzf5qrgdebJEmSJN3TzuTuGoyIOIT6s/hYZn50uNFoFlP1vxL47cz8bGZuzszvA78PfJ26aPn8YQU4xUKlJEnDMXX3033mWD+1fK731i2ln37texiWJfaIeC71UKY/BtY377NbiPc086cucLtBGcRn/s/U7wY5unm5+yD3vVyW63rblzoR2AZ8YBFxrfTrrR92t59tkiRJWphh5tSa30rN3VXr1+dzJnVee1I/gtJ2/fp8ptbfnJn/NX1FZib1iFkAv7jgCPvMQqUkScOxsZnPNZ78Yc18rvHol9JPv/Y9DH2PPSJeAHwMuAV4WmZunGeT2fykme+xiG0HYdk/88wcB7Y0X04/D15v9/YiYBT4aGYu5g8eK/1664fd7WebJEmSFmaYObXmt1Jzd9X69fk8mnp40Z9ERE5NwL8061/bLPvU0sLd7fT759tcf3e4rZmv2cm4lo2FSkmShuNLzfwZEXGP/4+bp9GeBGwFLpunn8uo71570oyn2Gj6fcaM/fVz38PQ19gj4oXAh4AfUSc6359nk7n8UjNfqXdzLvtnHhEPA/ahLlbeOm3VF5v5zHdXEhGHUv/i/UNW5rlbrvP2smY+57Cv81jp11s/LObcr+ZrTZIkSQszzJxa81upubtq/fp8/g14/yzTxc36K5uvL+xP2LuNfv58uws4JCJmu9H5Ec38B0uItS8sVEqSNASZeT1wAfXLrF85Y/UbqJ+U+kBm3jW1MCIOj4jDZ/RzJ/XQkXsAp8/o5+Sm/89PHw5lMfteKfp13prlL6L+pfoG4KnzDRkTEY+MiPZsy4G/br48e+ePZnD6dd4i4uebYUuZsfy+3H3H5Iczsztt9UXAtcBTI+LXpm1TAH/bfPmeZtiRFaWf19u09U8BfgG4OjMv3UG7VXu9LUREtJtz9uDpyxf5c2rVXmuSJElamGHm1JrfMHN3za+P3z+vysyXzpy4++8D5zXL3rlsB7ML6uPns5W6UDwGvCkiYlr7I4ETqF/h8+/9P4qFCfN0SZKGo/nD/KXUw2ScS/0H9scDx1AP3/DEzPzptPYJkJkxo5/9mn4eSv1E0VepCyHHU7+34YnNLzmL3vdK0o/zFhHHAP9JfdPWmcD/m2VXt2fm26ZtcxbwHODLTfsJ4HDqp7dK4H3Ay1dqEaRP5+0E6vcjfoX6qbSfAQcBz6Z+R8LXgV+eOZxpRDye+tpsU/8CfANwLPBY4BLg2Myc6Pcx90O/vk+nrf8A8LvAqzLz7TvY71ms0uuteW/Mc5svDwB+hfp6+XKz7NbMPLVpewj13Zs/zMxDZvSz4J9Tq/lakyRJ0sIMM6fW/IaVu2vn9DvXndH3CdTFyr/OzNf1PfjdQB9/vu1FfVPv0cDl1Hnx/YHnUQ/5+urM/MflPp75WKiUJGmIIuJBwBupiw/7ATcBnwTekJm3zWg75y+FzVNuf0ldHHgA8FPgfOAvMvPGpe57pVnqeZv2S/OO3KNw0hRffh94JPUvimPU5/nrwPsy8z+WdFAD0IfzdiRwCvAY4EBgL+qhXr8DfBR4b2ZOzrHvI6jv/DsGWEc9BOeHgDdn5rb+HWX/9fH7dB/qoYoSOHBH76dczddbRJxO/fNoLtu/t3ZUqGzWL/jn1Gq+1iRJkrQww8ypNb9h5O7aef36/pml3xOwULlkffz5tifw58ALgIOph7v+KvB3mXnBch7DzrJQKUmSJEmSJEmSJGngfEelJEmSJEmSJEmSpIGzUClJkiRJkiRJkiRp4CxUSpIkSZIkSZIkSRo4C5WSJEmSJEmSJEmSBs5CpSRJkiRJkiRJkqSBJSx/WQAAIABJREFUs1ApSZIkSZIkSZIkaeAsVEqSJEmSJEmSJEkaOAuVkiRJkiRJkiRJkgbOQqUkSZIkSZIkSZKkgbNQKUmSJEmSJEmSJGngLFRKkiRJkiRJkiRJGjgLlZIkSbu5iFgfERkRpy/jPg5p9nHWArY5odnmhBnLN0XEpp1pK0mSJEnSUpk3S8vHQqUkSZJ2WbMlZ5IkSZIkqWberGFrDTsASZIkaQ6fBC4DbupzW0mSJEmSdgXmzVr1LFRKkiRpRcrMO4A7+t1WkiRJkqRdgXmzdgUO/SpJkjRk099DERGHR8SnIuJnEXFXRHwlIp4xo/3290pExDMjYkNE3BEROa3NfSLibyJiY0SMR8RtEfH5iPhf88TyhIj4z6a/Lc02j52l3YER8RcRcUlE3BwRkxHxo4j4YEQcMc8+5j3Gmce5E+fwHm2n3h8CHAwc3Kybms6KiH0iYmtEXB8RMUefn27a3+v4JUmSJEmDY95s3qxdl4VKSZKklePngf8C9gXeC3wMeAxwfkT81iztfwP4DLAFeA/wEYCI2Bu4FDiN+m7JtwEfB54AXBARL59j/48HNgATwDuB84FjgS9HxFNmtH1q0//tTd//QD2EzG8AX42Io/p0jIu1CXgD9fHf0fx7avpUZt4GfBg4FLhXEhoRDwKeBXwjM7/ex7gkSZIkSYtn3tw/mzBv1grg0K+SJEkrx1OBv8vM/zO1ICLeQZ2gvCcizs/MzdPaPxt4dmZ+bkY/fwscAfwT8IrMzKavvwW+DpwREZ/PzE0ztnsm8EeZ+Y5p+z8e+BRwZkQ8LDOrZtUXgftn5pbpHTSJ1iXAm6kTlqUe46I0x3b61J2imXn6LM3eBbwYeDlw4Yx1LwFK6qRQkiRJkrQymDebN2sX4xOVkiRJK8cdwBunL2juSjwH2Bv49Rntz52ZbEXECPC7wJ3An08lW01f3wfOAEaA359l/9dRJyHT938ucBHwEOAp05b/eGay1Sy/ijoZOyYi2n04xmXT7PfrwPERccDU8ogoqROuLcCHBhWPJEmSJGle5s3mzdrFWKiUJElaOa6YLYmhHlYG4FEzln91lrYPA9YCV2Xmz2ZZ/8U5+gL48rQ7P+fdf0Qc17yP4qaI6Ey9ywJ4DjAK7D9LXws9xuX2LupRRk6ctuzZwAOBszPzzgHHI0mSJEmam3mzebN2MQ79KkmStHLcMsfym5v5feZYPt1Um5vm6Gtq+d5L2X9E/DH1Ozxuox7+5QZgK5DAc4GjqJOuRe9jQD4M/D3wsoh4c5Nw/kGzzuFrJEmSJGllMW82b9YuxkKlJEnSynH/OZZPDa9yx4zlObPhtDYHzLIO4AFz9LXT+4+IFnA6dZL06My8R3IXEU+Yo5+d3segZOa2iDgL+BPgGRHxHep3hFzeDMcjSZIkSVo5zJvNm7WLcehXSZKklePREbFuluXrm/k3d6KPjdR3aB4VEbPd/XlMM79ilnVPjojZfj+cuf/9qe8svXSWZGtP4NE7iK8fx7gQPaCcp827qZPXl1O/Y6PEu0IlSZIkaSUybzZv1i7GQqUkSdLKcR/gL6YviIjHAi+kvmPyk/N1kJmTwDnAOuCvZvT1YOBVQAf4wCybHwacNGOb44GnAdcBX24W/5g6qXtMk2BNtW0D/8js79iYsuRjXKCfAveNiDVzNcjM7wNfAH4VeAVwO/XQNpIkSZKklcW82bxZuxiHfpUkSVo5LgZeGhGPBy6hHm7mt6hvLnt5Zm7eyX5OA54CnBwRjwO+RJ0E/SZ1InZyZv5glu0+B/x9RDwLuAp4CPA8YBw4sXkPBZlZRcQZzX6+HRHnAiPUd53u2+zvmFn67+cx7qwvAI8DPhcRFwMTwFWZ+ekZ7d4F/C/qIXbenpnb+hyHJEmSJGnpzJvNm7WL8YlKSZKkleMHwBOB26jvUPxN6qFmnp2ZH9nZTjLzZ8ATgLcA+wF/CrwA+CrwzMx81xybXk49lMwocDL1Oye+CDw1M788o+3rgVOAbdRDvzwP+Drwi8ANy32MC/Am4D3Ag4E/p75b9vmztPsP4Nbm3w5fI0mSJEkrk3lz/5k3a6gic7Z3yUqSJGlQIuIQ6kTkXzPzhKEGs5uKiEOph+m5JDOfMux4JEmSJEl3M28ePvNmLRefqJQkSZLgVCCAdww7EEmSJEmSViDzZi0L31EpSZKk3VJEHAT8b+Aw4MXU7xf52FCDkiRJkiRphTBv1iBYqJQkSdLu6lDgb4CtwIXAH2ZmNdyQJEmSJElaMcybtex8R6UkSZIkSZIkSZKkgfMdlZIkSZIkSZIkSZIGzkKlJEmSJEmSJEmSpIGzUClJkiRJkiRJkiRp4CxUSpIkSZIkSZIkSRo4C5WSJEmSJEmSJEmSBs5CpSRJkiRJkiRJkqSBs1ApSZIkSZIkSZIkaeAsVEqSJEmSJEmSJEkaOAuVkiRJkiRJkiRJkgbOQqUkSZIkSZIkSZKkgbNQKUmSJEmSJEmSJGngLFRKkiRJkiRJkiRJGjgLlZIkSZIkSZIkSZIGzkKlJEmSJEmSJEmSpIFrDTsASZK0dBHxA2AvYNOQQ5GkleAQYHNm/vywA5EkSdLKYN4sSfdwCCskb7ZQKUnSrmGv0dHRfR/+8IfvO+xAdhVbtmwBYN26dUOOZNfhOe0/z+nsrr32WrZt2zbsMCRJkrSymDcvkfnH0nkOl8bzt3RT5/DGG29cMXmzhUpJknYNmw466KB9v/GNbww7jl3Ghg0bAFi/fv1Q49iVeE77z3M6u8c85jFcccUVm4YdhyRJklYU8+YlMv9YOs/h0nj+lm7qHJ5yyikrJm/2HZWSJEmSJEmSJEmSBs5CpSRJkiRJkiRJkqSBs1ApSZIkSZIkSZIkaeAsVEqSJEmSJEmSJEkaOAuVkiRJkiRJkiRJkgbOQqUkSZIkSZIkSZKkgbNQKUmSJEmSJEmSJGngLFRKkiRJkiRJkiRJGjgLlZIkSZIkSZIkSZIGzkKlJEmSJEmSJEmSpIGzUClJkiRJkiRJkiRp4CxUSpIkSZIkSZIkSRo4C5WSJEmSJEmSJEmSBs5CpSRJkiRJkiRJkqSBs1ApSZIkSZIkSZIkaeBaww5AkiT1xw83Vxxy2nnDDmPX8znPad95TvtvFz2nm9583LBDkCRJ0i7EvLlPdtH8Y6A8h0vj+dtuV8ibfaJSkiRJkiRJkiRJ0sBZqJQkSZIkSZIkSZI0cBYqJUmSJEmSJEmSJA2chUpJkiRJkiRJkiRJA2ehUpIkSZIkSZIkSdLAWaiUJEmSJEmSJEmSNHAWKiVJkiRJkiRJkiQNnIVKSZIkSZIkSZIkSQNnoVKSJEmSJEmSJEnSwFmolCRJkiRJkiRJkjRwFiolSZIkSZIkSZIkDZyFSkmSJEmSJEmSJEkDZ6FSkiRJkiRJkiRJ0sBZqJQkSZIkSZIkSZI0cBYqJUmSJEmSJEmSJA2chUpJkiRJkiRJkiRJA2ehUpIkSZIkSZIkSdLAWaiUJEmSJEmSJEmSNHAWKiVJkiRJkiRJkiQNnIVKSZIkSZIkSZIkSQNnoVKSpD6LiIyIDcOOQ5IkSZIkSZJWMguVkiTNEBEbIiJ3sH5TRGwaYEiSJEmSJEmStMuxUClJkiRJkiRJkiRp4CxUSpIkSZIkSZIkSRo4C5WSpFUtIn4xIj4SEf8TERMRcVNEXBARvzmtzQkR8fGI+O+I2BYRmyPikoj43Rl9HdIM+fq05uucNm2IiPXN+oOBg2esP2snYm1FxEkRcVkTw9aI+GZEnBwR/p8sSZIkSVrx5svDp3LniDh9ju3v9TqVJm/PZn5cRFwaEXdFxG0R8e8RcdjyH5kkaRhaww5AkqTFioiXAe8GesB/AN8H7gc8FjgJ+GjT9N3Ad4CLgZuA/YBnAx+IiIdl5uubdrcDbwBOoC5GvmHa7jY10xuAVzfL3jZt/ZXzxNoGPg38CrAR+CAwDhwDvB14PPB7O3fkkiRJkiQN3gLy8MV6HvAs4JPABuBo4PnAMRHxxMzcuMT+JUkrjIVKSdKqFBFHAO8CNgNPyczvzFj/wGlfPiIzr5+xfgQ4HzgtIt6Tmf+TmbcDp0fEeuDgzDx9ll2fHhEnAMyxfi6vpS5SvgN4dWb2mjhK4J+AEyPi3zPz3B11EhHfmGPV4QuIRZJWhQ0bNixquy1btvQ3EEmSJC00D1+s5wDPyczPTOv3j6lvFH4XcOxOxGneLGm3sdC8eSpfXkl5s8PMSZJWqz+kvuHmr2YmRwCZeeO0f18/y/pJ4J1NH/MmOkvRDOv6R8DNwJ9MFSmbOHrAKUACL1zOOCRJkiRJWoKdzsOX4IvTi5SNdwDXA0+PiIP7sA9J0griE5WSpNXql5r5+fM1jIiDgD+jLkgeBKyZ0eTn+hvavTwU2Jd6SJzXRcRsbbYBvzBfR5n5mNmWN3eMPnoJMUrSirN+/fpFbbdu3br+BiJJkiRYQB6+BBfNXJCZvYj4CvBg4FHAD3fUgXmzpN3JQvPmqScwV1LebKFSkrRa7d3M/2dHjSLiUOCrwD7Al4ELgDuo36dxCPAiYHTZoqzt18wPA/5yB+32XOY4JEmSJElarJ3Kw5foljmW39zM77OM+5YkDYGFSknSanV7M/854Ls7aPen1IXCF2fmWdNXRMTvUBcql9sdzfyTmfm8AexPkiRJkqR+29k8vGrmc/3tee9pfc10/zmWH9DM75hjvSRplfIdlZKk1eqyZv6sedo9pJl/fJZ1T5tjmx5ARJQ7WD/Xutl8lzoJ+6WIaC9gO0mSJEmSVoqdzcNva+YPmrkiIh7Cjp+KvFee3uTmT26+/OY8+5YkrTIWKiVJq9W7gS7w+og4YubKiHhg889NzXz9jPW/Arx0jr5/2swP2sH6+0bEzHddziozu8DbgQcAZ8y2XUQ8YLbjkCRJkiRphdjZPPy7wGbg+Ii437T1a4Az5tnH0yPiV2csO5n6/ZRfyswdvp9SkrT6OPSrJGlVysxrIuIk4D3ANyPiXOD71MO8Po46KToGeBfwYuBjEfHvwI+ARwDPBD4K/NYs3X8BeAHwiYj4LLAN+GFmfmDa+scBn4uIi4EJ4KrM/PQOQv4r4CjgFcBzIuKL1O/1uB/1uyufBLwWuGYRp0OSJEmSpGW1s3l4ZnYi4h+B1zftPkn9d+hfps7Jf7SD3Xwa+GSzzXXA0dRPcP4MOGl5jkySNEwWKiVJq1Zmvi8irgZOpX5i8rnArcC3gH9u2nwrIo4B3gQcR/1/31XA86iHY52tUPnPwMHAbwP/X7PNRcBUofJN1O/UeA51gbEE/pU6oZor1k5EPBf4XeAE4FeBPYGfAD+gTuDOWfBJkCRJkiRpQHYmD2/8JbAVeBnwB8DNwIeB09nxDbqfAP6J+kbe44BOs+zPM/N7fTwUSdIKYaFSkrSqZeZ/Ac+fp82lwNPnWB2ztO8Br2mm2fq7C/jDZppt/b36bJYndbHzA7OtlyRJkiRppdvJPDyBNzfTTIfMs+1ngM8sNj5J0uriOyolSZIkSZIkSZIkDZyFSkmSJEmSJEmSJEkDt5ShX7NvUUjS6jfrUJ+SJEmSJEmSJGl2vqNSkiRJkiRJkjQ0mXkWcNaQw5AkDYFDv0qSJEmSJEmSJEkaOAuVkiRJkiRJkiRJkgbOQqUkSZIkSZIkSZKkgbNQKWnVqqqKO++8c9hhSJIkSZIkSZKkRbBQKWlFu/XWW3nLW97Cxo0bycztyzOTM888k/e///1DjE6SJEmSJEmSJC2WhUpJK1JmctNNN/G6172ON77xjdxwww33WHfFFVfwmte8hssuu2yIUUqSJEmSJEmSpMVqDTsASZrNjTfeyGmnncYHP/hBRkZGOPDAA7ev+8lPfsKf/dmf8bOf/YyqqoYYpSRJkiRJkiRJWiyfqJS04lx77bWceuqpfPCDHwTgsMMOY6+99iIiGB8f56yzzuJrX/saEcHee+895GglSZIkSZIkSdJiWKiUtKJ861vf4rTTTuMTn/jE9mVHH300e+yxB5nJN7/5Tc4++2w2b95MWZb3eNJSkiRJkiRJkiStHg79KmlFyEyuu+46Xvva1/L5z3+ebre7fd2RRx7JHnvswa233soZZ5zBNddcA0C73ebQQw8dVsiSJEmSJEmSJGkJLFRKGrrMZNOmTZx88slceOGFZOb2dWvXruWwww4jM3n3u9/NRz7yke3rR0dHeeQjHzmssCVJkiRJkiRJ0hI49KukocpMNm7cyEknncQFF1xwjyIlwAEHHMDatWs5++yzefOb33yP9fvvvz+HHXbYoEOWJEmSJEmSJEl94BOVkvquqiruuOOO7dPmzZvZvHkzd911172mbdu2cfnll3PJJZfM2te2bds488wzueiii9i2bds91j35yU9m7dq1gzgkSZIkSZIkSZLUZxYqJS3Y9KcaJyYm2LhxI9/5zne47rrruOGGG/jhD3/I5s2bmZycZGJigsnJSSYnJ+l0Oveaer3evZ6inO6WW27hE5/4BL1e717rnv/85y/L8UmSJEmSJEmSpOVnoVLSvDKTqqqYmJhgfHycjRs3cuGFF3LRRRdx9dVXs3XrVnq9Ht1ul6qqZi0qLlZVVbMuP/zww3nyk5/ct/1IkiRJkiRJkqTBslApaU6ZyebNm7nhhhu49tprueCCC7jwwgu54YYbhhrX6Ogor371q1mzZs1Q45AkSZIkSZIkSYtnoVLSvVRVxU033cRll13Gl770JS6++GI2btzI5OTksEMD4Mgjj+TYY4+lLMthhyKtKAfvVfC9Nx837DB2GRs2bABg/fr1Q41jV+I57T/PqSRJkrTzzJuXxvxj6TyHS+P52zVZqJS0XWbyk5/8hHPOOYfzzz+fb3/729x8883DDute9ttvP8bGxoiIYYciSZIkSZIkSZIWyUKltJvLTDKTLVu28KEPfYgzzjiDG264ga1bt5KZww5vVpdffjnXXHMNBx54IEVRDDscSZIkSZIkSZK0CP6FX9qNZSa33HILH/3oR3n605/OySefzLXXXstdd921YouUALfffjuvfOUr+fa3v01VVcMOR5IkSZIkSZIkLYKFSmk3tXnzZs477zxOPvlkXvKSl3DFFVfQ6/WGHdZOu+666zjxxBO56KKL6HQ6ww5HkiRJkiRJkiQtkIVKaTfT6/W48soree1rX8srXvEKPv7xj7N169Zhh7UoV155JX/yJ3/Ceeedx+Tk5LDDkSRJkiRJkiRJC+A7KqXdRGYyMTHBWWedxTvf+U6+973vrfriXlVVfPvb3+bUU08lIjjuuONotfyxJkmSJEmSJEnSauBf9KXdwMTEBNdddx2nnHIKX/jCF+h2u8MOqW+qquL666/nhBNO4L3vfS/HH388o6Ojww5LkiRJ4n57jWUSQFJEQQT3eBd8RFAUQQQUEZQRFBHUTZKplkWRRET97yjInFqXQABBERAERcH2tlVC3dlUT0HE1DZ1u6l46k2CAqi2LwuqqiKbvqebuW02+5ra9/ajDCiJ+lijPhdENtvf+3xMbVxlcp/RgsPWjfKAosfarBgtgnYBe6wpGSmCrXd26PW6jLWCsTUt9tp7DWvXtCnpQVFQjI1SFUG326PbS8qAEpjcNsHkRMXYHmOsXdum0+3RmZgkJ7uUZUG3m/RIuj0YHW0zNlZCu81kVTKZSTk6ytjoCFsnJ9h65zaqu7ZRTXahStplQS+TO8eTbb2kbLcZbRV0t07S7VYwUpKtks5Ely1bJ6mqgrWjyYH3XcMB992Dol3SWjNGBGybSKpekASjoyXtqOiNjzMxPkHVTXrdionxDmURtMqCcqSk1W5TVUln2yT0emQB7bHR+prJiiIK2s1fgrqTFUmPslVS9ZKJTo9eNwmSIpKyLCnaJWVZUJDQ61ECI+2gtWaEiqAz0aHKgla7pIik6vboVUE1tgfjtNm2ZQvtyW2sW9OiPdqiHGvRHhsDCrI3SWbS7dT9RlFfb9EqSQomxjt0JzqMjI7QLoNur2J8okOvC3uuCUZHR+glTHYTAop2i6qCbdt6lAWsWdumKAqyl1T1dyEURX1+OhWdXtIqe4y0R4j2CFUVdLuTtNpJWY5QdTsEUBRtYuqajYSsyAqy2yN7PbIsoWhTAZQFFQVVr6JVVIy26m16nR7dyV5z7bcpy6TdLmi1oCjHiPYoEQUZBVUGnV5SVUlB0C6TcnRNc07G6XYmiaIkAiIT6FGWJWWrTVm2oCigLKE9QtlqMzI6Wn/GVdKd2FqfjyqZ7HTqflojZPaoel2KsqQsW0RZUoy0qerDpVdB9ur4y7KgbBVElJStFmW7pD0ySrTH6ra9DlUGVdWlCBhpFbTabYp2mwOfceo9f5BIkiRhoVLapWUmt9xyC5/61Kd4y1vewg9+8INhh7Rsbr/9dl72spdxxx138Du/8zvsueeeww5JkiRJu7mcKhLG3X+b317Im16gm5oCoGqKfHX1r65ZThUWp7YLMnvNVlkXkYAkIOPuIuG0fUy1nSqC3iNOErIumOa01tt3Oi3emOVYYtpB5LQOpoqbGdm8d6ZuFNx9HDEV91S3GZQBD1w3wmFrC/YtKtq9iiIrWgRlD6pJ6EZS0mNkJFi31wh77DHKHmvrAlAvW6zZZy+qqsddd05Q9Sq6Ez2qXg9aQaebUJb0esmPf7qVdlTsOVZAu2R8a5dOAmWwdk2bkdERuq02WZb0CKIo6PXgttu3kNUk7U6XKKAaKen1oKpga6fHnRM9JjsVayogSzKCbJVURcnYaIuqKmi3Yays2H9dyYH77UHRbtEaG6XbScYnO3R7JdlqMzJS0ul26Y2PQ7dDJJRlQVYwOtai1+2SdRmO7sQkUQRFkVRV0GqVBEnSIytojQaZFZMTXSKTVqsuqo1PVmQGoyN1UbIo6s+l15Ta62JoUEZBUQS9XkXVS7JKyB5VJ6joQVnQKwq2TPbY1ukx0u2ydm2bolVCJkWV9LZto9utiICy3aIg6U12iFZBOTJKp9OlMzlJu1UyumaUKivGx7t0uz1G2iVr9hylKAu2jU8yOdGlKIN2u0WvUzHeqShbwWi7RWYBGRStgqpTkVkREbTaBa3REdrdiqo7URcgK8iqS7uEItpkRl3or3pEFpTtgiDpdTv1dVwl2esRdaWRXkJFUPUAerTLpF007Yimv6DbTdrFJGtGxmi3yru/c6Ogm8H4RJeJyQ7tCEbG6htwe1VQ9HpkJGUkZbsuEEZAt1N/bkXRBqCqkqqqIINWmbSKEnpJt3MXWXUhgiha9Q0I2RQfcxIo6+ONJHOSoqqvm7I9QoyUlBSQoxRlSZVJ9jpkc4dCqyhpj41Rjq5jcrJDd7xH1e3WcURSFfXxZ/r2KUmSNDsLldIuKjO56qqreOtb38qnP/1pbr/99mGHtOw2b97M61//esqy5IUvfKFPVkqSJGnIpp4QTOpnuu5eNr3gt31pThUb2V74u/v5xKYKuP1JxqJZnttLlQFNYakuRk3fw4zdNQXQpkySU8XUu5/irPeQbH8IMqIuUOTdLYqpAPOepc+IoJjeTwRxd9ny7hjy7iLtVOs92iUP22eUg9aUMD5Om2SsCIqEkaIHVVD0oGjDnvuMsW6vUdojLdoFUHXp9Apae4wy2enS7fSY7HTJHmSnQ7RH2ev++1P9+Fa2bu2yZXKSkZGSfda2aVU97hzv0MmC1miLsbVtyvYY3XKEKgqIirIMxrdNsm3rBGNljzXtgtZIm6JVsXlLh/FOxXgvuXO8olsla8ZGaI+2mIygW3XJblJkBd0kC7jv3i3ut65Nu10/sVkUJVu3TLB1okuvWzEyNkLZCia2jVP2uhSTXSIDaIp8BJ1ej6IoGRsbgawoAnrdioiC9kj9wZcFRJaURdDtVlSdLq2iIKMuclVV/dRb2WoRVY8kiaIgexVlJkWvolWUjIy0gaDT7ZG9+joroqCiqq+LoqCqYJJkcmKcdq9iz5GgLFsUZVCWQS+DqldvXxZBVhXdXlIRtIsWXVp0MilbQbtd0OtUTE5WVJmMjbUYWzNKWY6wbbJDp4KRsTatAiY7PTrdLu2yTRFBp1fRyqAoSqpO0uv2SIIik+bByvrBw3aLzCCKirJsUXU7UHXrwl8EREEUEFnHEFFAlGTVo2wFZasgi4qiV9CpIKKiXRb1E87NzQRRtCiLkqqapN0uGWm3KIqCTreiKAqKsmSy02WiC5Od+vu2aN1d2ieTbmcCKCgDRtptKKHTDaBLESVB0Ot1qbJLRpuSpMyCyPqYsjdJ1YMsC6BqnhatoCipArLqbX8SsixbRLH9/giKKCjLNhRlHW97hF4PuuN3Qm8SqOpzWhZE0fx8Kwra7VGiLKiqDp1Oh6Ku4kqSJN2LhUppF/XZz36W173udVx99dW71FCv87nlllt429vexhFHHMHjH//4e/0BSJIkSRqUejTUpNj+yGFt+5OI039XbZ5ATGiGZ60X5tSm0TwtWeX28mTTePu/I6YKfz3qEV6LetzGKO7ur/k6pp6eIqnI7YVFsoJpZcWYVsDcPlxrs78qILKOMqY9jjk1DG29qOm7OabImKq3bh9ulqyLmfuMlhy931oOHIOyM060erSzgMx6qMym2LVmrGDPvdcysrZNZpf2aAt6PVpjayhGR6GAiIK77urSjZKxEiZ6cN+D9mekFUQr6FQVe60t2HfPNr3JDndO9Ohmydieo/8/e+/7a0t21vl9nmetVVV773POvbd/uNt2x8bjH9jGdmZgBiZKpISMRlECmihSFPEHRAghK+KVHcDveBME4g1vzFsjW2gkgwBhRUZIE6M4k5lANEggGw+2YQC77e7bfe85e++qWms9T16s2vuc9jgJTCZc2l2fVt99zj67qtauqlU6+3zr+/0ybHskJWYiczFCbOO/OYwcb0Z6nE4crU3Ovd5nHk/GsRjHsX32eu7pK7yLHOeKTTNam9MvBsAKb76MXKQm4KWbpNu4AAAgAElEQVRthxCZZmMcZ3KudCFQjyPlcGzRu9L2f81NSNQg1AKiEQmKq6IIVgraxSYgVoNaCBKIgRb16UIfA6hg5lR3gkKKTbis7lDbyaveHHwxhCaAGjgV1FEJ7RwwQyS0yFOvi2tO2fZKZwVViF2iSy2qlBAoDpQZr4WcIfQdaOF4LBQyfUpA4HCY8Wp0Uek2iRQT2eDmOFNLIUUlqpCzYW70faI65FLRENvbmI1afREFA1CIGEkCmOEihBghRqyU5VwOuBUUb0Impzhkxb0uc7BFNQeEWipS2/mpomC1iaAqGEoloyjbix4Nkbk60zQj4nSqZBOm0sYYQiDFds1wK4hG0DZnUgykZT/W6phXgkYMZc6FagViE8/NDZtnTKVFyppTa5uPIoabY9VPE5haK1YyMfW4QykVQsC1EiQRhw60a2MSo+83BIwyOrU6NReQI16NmDroQEICc+rs5HxA5lWoXFlZWVlZWfn2rELlysp3EO7Ofr/nl37pl/i5n/s5XnzxxSc9pCfCH/7hH/LLv/zLvO997+PevXtPejgrKysrKysrKytvUE7i3vl7v41vFZHbuNdF8HPx5t5aXm84YnqumTxFwp5iU9tK78bCGqBNDFwsmnJH5Dptt6mabV3tSzmP7/QcYhjKa8MaTyO4EwcrpzhXOTuwlobM5rg7ia3uuLT3CItuueyDLgpv3gbesQm8kAoXVhcXqlBrhdp2QEqB+/cSTz93xZyNcSpYrYgWuhQhBoKChsA0ZfpOibkgEnjh7c8iNvL4pT02TTx/v2PoI8cxczgaFjq2u8hms6GknqkKUynNSVoLN4cjYpXLTvBcKbMxT5VX95nJEx4iRgagHzqqQB5nbC5IbR2lKQjbIfDgwQZVsFLoukQtlTFPzGUmBLh30TGOLQJUXRB3PCpFwIrjXomEc6ehqlJyG2u/3RCCQClM+0wI7XhYLiQN0HXLCeFNKDPwUpoTLiakFsqUqXNuQmCXSEma6859ccEKbq3vVFOLSXUxlIAVo48BMxAJdEMgpISEiIYAXaILkTruqeOBQNt+nisIdJravp0ngsB2k9hsOzQI0+wcp0Kt0HcBq3DMrZ8x9i1aVioEVapBtbqcfUoIgophgKqCNzVWRZf9M7f5GNp8OwnwtTbR0/029lUpy2nfHKRNwG0Cb60ZdyMlsBQpi4twGCIxRLJDqcv+FmWuUL05W1Fp4mqBxNSEVXVClxiGjtQsshSrmBd0GW91obQKUboUiDFAhZIngiqSEo6isV0DzAxzpXoF8/N8RSPmCq6YVaQaGpuI2bkTuw6nx+YR8ULXd4BjZcR8ibl1iF1HGHbkqTAdXl5EUcPL+Fe5bK6srKysrKy8AVmFypWV7xDcna997Wv8wi/8Ah//+MfZ7/dPekhPDDPjV37lV/jRH/1RPvShD62uypWVlZWVlZWVlSfCKc6Vszh5EitvFb2TzNdcc34WARFBW9Uc4i041m9Xt+iMi9Pxjmjp3gTO1jF4uy33uz2Tr42YPTVFntZ86s1b/FdNVD1HznKb2Xp2gN72Yp5/8z699LQ2kZOpchFo21YfbDredZl4SyhcqnGlilQYZ0PMEDeiCCnB008P3H/mHrkWjlMmdh02g7bkSYIotTi1zAwpInMlPXWfTVIU5aUXv0keM5ebiFXn0XUhV0O7nsuLnjQMZIRDMUouxBCQWrm+uSEfZkJt5tQpl9ZF6cqxRmKf2HSKVei6hDsc9xOe21ETDFXh3sXA1b0BCR3ESEiFeZzIuZJrE+UUYx5n1IVOZZGKfdnngVpmum7pS8QJauRSEY10SZtwW50yZXDHHLw0l6xXiLEdC02RuEnoNOMzmAsu2s4mcfqho+sjGiOqt2eG5UIp7bwAcHNSH3ATrBgxxObKdKcfBF3+6pTnGU1KUMhWkNQRVJmubzjeTPSdstn0HI+Zm/1MAi7u92w2PcWc/XEmZ0ej0veRUoxpNlIX0S5idivyW53JpQDNgdt1EakFoRJjd44nDSHgtbZo4kU4NGvHzE7zSIQ8Z3JpwmB7bTsqJWdUI6JtbtScyXOmupFzglAJqmyGDq/GsU4QIjEGShVKrs2RGhQRiCooAa8ZqRWkIMnYhK4dW3HqMr4QlshdwM0IUelSjwZHa8arUasxjTNqEFNCYqQ6lLo4SVNq9mcVRBOYYcVavHKIIKAqqEZqLoQ0onGAENAQkNQ3R2mdW/dn1+OEs6PZEfI0o6eoWTvFX6+srKysrKysvJZVqFxZ+Q7hT//0T/mZn/kZPvWpTzGO652KDx8+5Dd+4zf44Ac/uAqVKysrKysrKysrT4bXRJwC6DnWVc5WyvYToXXBNQnKz32VIku75SlydZEVdVnxuTHynBF7+r5JSSfx6RQTe9K82katRXxq6yk8C5TWOhRxwXTRMhZ35rlhUm6dkt8WaeLr2f25RM3qInymqLz93sD7rgL3S6b3yi4p4kYuhldHxemCMmyUp5+9oNsOPHp8IO629BeRWmZCUlKvBHH2h5l+SKgVjqVyce+C7XbgcP2Y/c1IHjPR4XisHMcWbbnZ9Wy2Gzz1TK4ccqHUyhAj03HkuD9Qxok8FfoUOc5ONRi2HdtuixRj0JmLXcdYB24eHyiHGXIhqDD0ERHn2We39H1sPYYhEEQpxcmlkufCZuioJbMfDcyI6iTVts9UmXJlHkeiBtydvouIKoepRd6mvodasHkEN8SdYsbQNcHpeDTcDJFMSBFNAvOIlYqZoxqZ50qdJ7oYGDaJuNk24ckdoVDnEatG6DpcAu6V1AXcIJfMPGVKhX5I9F0AA8+O+wGXgBXh8PjA7E53ecHQd5RidF1gs+mo2lHcGJJztYkMfSTnwmEy5rnQ94GYAtmMY3FcI1Gb4y+EgAalzKWFDQukoPSR1qNohoRwFslVWgyyLqJbXTpdFaHUcppwzFOmmiG0iSCAVyN7Ezhd2rnqZs2GqUrJxjQXUgzs+tYZahRi3xNSZC5QS27zIAWsKXtN/KMJnl4yIQa2QVF3yjxj0vosVcNyTUgtolXb+wzSnJBeMjW3ntQilUBu0bXVMFFqbfMzdpEQl4hcrF0flouNqLR9qs25aw55mom1oCkRhx0StxhKqAUIgBBSj1llnkYsT4CQy4y4k7rhr3zpXFlZWVlZWXljsQqVKyvfAXzxi1/kIx/5CL/1W7/VopFWAPj0pz/NT/7kT7Zon5WVNwB/+tj4rv/xt570ML7z+J/XffrV/+mHnvQQVlZWVl6XSGixnSyOxVPs6+n3U2lS5NKLB9xpi/RF5Tw5ElkciSJLB+Sp01IAbw4ptxZz+dpo19uY2FY/ebu95u7U12qNp+pLlyUh1M83/jlL3+bSVdmGJUusq6CvEWG58xoWsasJsxdd4P1v2vLurdKNI5TMbogoRjVHvNIrxKTsLjqefu4C0cD+emIaCxcDuAtG4HKXIBcOx4xoZJwzaZPYbXvq8cA3XnqFecotPrU415NjqoSUuLjaMmwGZo/cZCPXiajQqXLz6JrpeOCZZx+wvXiaRy8+5JVXjkwGV/cu8C4yTTOdODENjJY47Pf4cSJaJQ2J1CtX28hwsYEQqDTBy6ph2ShTRsxJCvv9SFUhFycBkSVONSilFtwgxkRQoe8Vkdb1GBLUnDEz3GAIi8/Vne2m9VfmuVKs2XMFbW7bnPGpUIqhsaPkTJ5ncEW6Ht1sqCE20bpkLGdqdoIqjhOTtt7KXJjHyvE4Yzh9CgTPkCuy5M6qCjlX5jHj7sylMM+FcG9Dn0BiaK7QULjcRdLFBWLG4ViZSwUVNrsel8BcK07AFeZs+LHQR0e7RLVALRXc2HSBKI4s0avVDHMnhh43a05GVSQq5RRpW2ZqrctcVHI25nle4oQTwR23JuqFFM/CojXD6nLzQLs5oE9KCs3WXK1F2kpIzNkpuRAUYlCKtczWkBJBFUrBvY2hD22OWymtTzIElK65N02pHpEYSCoEqXi1JiqKkL29R1UlmzOPBQnWnJKLo7RUIAilBGrNaGhRvyIRMILGduWy0oRYDHeliwHRdn2IKRDuPdMcqJ6p0wEzo+YZy1O71sUOQQhd+P94RV1Z+ffDt35uXj/rrKysrDx5VqFyZeV1jLvzpS99iZ/4iZ/gt3/7t1eR8lv4whe+wJe//GXe8573POmhrKysrKysrKysvAHRO47Jhp9jVOWO2Kjnl912Pza34hLRuoiVumRbijaxUTm5Fhenl0oTI2nPtVWeuilPAqQvPZGnONdFZUGa4HnaMLdRsWa6CDGcBdCzgOq370lP/ZfnSNlbN6VKk2Sf23V8z4Oetw3GpTqjVYY+oFbAHa3WnGY75anndlxue3Ix9o8P7A+VbrdBA4SgqEGdC+JGCErYDnTbnmjGzcNHzFOhVCMquCnZBU9KPyR2ux5NHUdJ3EyFcS500bFSOB5m1CvP3L/Htu/wXNgfK5WAROU6G8f9nvE4U0wJydl1I5onkiuh7xi6wNVlYrjYMC+OOZHWJVkreGkdkEG0OQyHyDwXJChYxTRSKoj0XFxe0qcBUk/qBqqBbrfEkMjZKdUpVuijEi2jNtEFx22mjBPV94Q6UvOISaQi+FzaeaeKlYxZO0Y6dGg3YKKLQ3OiTHkRwQLVA11QApU6z9TcRLAQYRNji/e11n9pZW5RuAhWM6KtS3EulZALYRDCpqOYUOeJbZcZ+p5qgcf7zP6Q2WwSw7bDNZCrEEPAHMQqQQ3LMFuLwGVxNiZVtGROHsk5t97ILkXcJkTCEhFb2zkeE15mvDSxTiQ1Y2EAFSegqBXyqSu1iwQ9zR9ZhE+o5uDKbhNaNGttvayqAXNnHkfMjC6l5mQsrS9SMKgVy04UZdMFgkbMpTkhF7FWxJlzpljEBGIPGiNSa+uANKd6iwSWFJZI2jZ/c8mQhb43Yj8gMVFFmeYmKqoKEkPbN0ERVQgBDxHX2ATaXNA4YN4iXUOvaBrQ2FNLJY+VMh0o0wFBqaUgYqSuRyVidfr3dGVdWVlZWVlZ+U5jFSpXVl6nmBl//Md/zEc/+lE++9nPLl0aK3fJOfOZz3xmFSpXVlZWVlZWVlaeEHetivJvPbYI19teSl/iUQ0/d0rKIiie1qdLt6PquZkSv/PzcyuknMTOU5ugnk2W58bBU7Wl+/n/Vop5GzOrLLGvLKLMsp2zfHpXeH3N+/PbXkqBLirvfuqC914Il57pcsaKMKjjuYIYKQiSlM0mcfnUhq5f+h4Plf1U2dzfcP+pSyxP1OOesOkZuoFxzjx49jkoI3k6crg5chgzKSi71HEcMxkh9JF7m57UJ4ookyQOU2aaZ6jOOBWkzty7t2PoIopzfXPNYV+5OVTmqTKWmbmOTAZjcUyNS4OdQ82GiXPZN7GqqjC6ohpxy5RaqbVFsAYVzCoqSr/ZcKyK9ju6e2/i/gtv5+q5N9NdPcvuqfsMV1fE7SVpGAgpIjE296oo6Cna125jfa1Sc6aUTDmO5OPIdL1nfPUlpodf4/CNP+fw4l9g+28i+QZVIwQHBe17pAvgFRsn8uHYxPQu4arEqAgVahOkzZx+CMQo7f0v8rS6t15FMyQlNlcX3Oxn5mli28V23KfC7IKmwLYPdEHIY+UwF8axEKIQYyAXI3TK0MWlz9PoNBI7oUol6G3EcowBM8PcyKbMpeDmdKnFperyublY239NUJ0QSpshZrgUNESSNkG85MpcHMQJUVv3pznihplTilGqE7vA0Ad8mb8xOSqBUiv5UNFgpK65C0uprU90cVCXuRIF+q2Suo5q4Nlwq4hIEy2tOW7RSojh3B3atidUax2WJgaakNBjpVLyRHVHasZj1xzQtKleq+FihLhBtMPc8FxIKeHWRFhJ2m6CyBk3MARzUF8cmgTydE0ZD3iZwJxqFTcjdhFNiTpmDtev/jWunSsrKysrKytvJFahcmXldYi785WvfIWPfexj/OZv/ub5TueV12JmfPazn+XDH/4wMa6Xu5WVlZWVlZWVlSfDt+tMD2eH4in+tQl/Zk3ksLNUyB1HYnNVNvcizQ3p3DojTzGtJ8HqvNlT9Kze6b9keZHj3Ea53j7ftnHrjpTz1+f4WBxFlzWcpFfOYujyUi77wAee3vDOnZDyROeFzo1pMmp1LreBIQZUhK4TtkPE5srkgcNUcIEHz14y9AHGayxXttuBmAKy2bLrMvXxKxzHkZuHe0JUtn1EHW7GjHmg2/Vsth0ikaMrkxnVZtRBaosuHcQYUuBi2xGD8ujVPcdDYbzJlLFSJmMuziTQDQmRJjzGXJgrhChcXSTuPRgQDViMhBCaQzIXypQB6PuBKhvi1fNcvu09PP133s32TW9h+6bn2d2/QvsdlPncS+qi5zjS14rfd47v8rQuIrMOQnKH+7aI1hHVBJ7BM3mc2T98hfnhN5le+hqv/tmfMH79K0h5BHWiHh9BNkKIVG/bTl0klIxgSEyIBDpxaq3kaW4Vh+ZoYImsNSQqomASiZ1zKUbIkMdMroUhKpsUUEnsbyb2NxOoMOwG0MBUjS4GUpfIs1FKIUqLa1UB7SNWCqIQgyCtcJFqSjFDVQii7VFb32bOBQwkCqFWRNr5W/Pcvo5L5G118gxTNmIQIizxyrc3G5gZpVRiF+j7hFuLhw2hSZBzNkqBFKFLAReh5Nxc0CIghiOkoGyGQOq65mR0b72RqjjKbEt3pgopBIIKngvEFvlbrM0ltyaWIw5BcW2Ozs7bDQ3FhDrNqC3HUAOSNmhMzQXqSjVr8bJuYEKw5uL2mEAV0Q7X2Loux2vMlPlwDdMRCQGNsY1N2s0PZZq5eeUbBF0ToFZWVlZWVla+Petf7ldWXoe89NJL/NRP/RS/+qu/uoqU/y984Qtf4Ktf/Srvete7nvRQVlZWVlZWVlZW3mDcFSj9HJHK4oZbRMezSOlLz9viVOMkQN5drrki3Q0zuXVdiiz9g7So10V4acLiScSS1352cOPkmzz9f/7e78S8LqKnLf2UvvRktjU2G2V7O68VY33xij01BN571fM8hX4aGXBqLozZCUG5f5nYpCaOxKiEFDhWmItTx5F+SNx7sEXNqfsj7rDZ9pg5MUXsuGd/feT68ZFprsQU2CSY50opTiXQbTsudgNFhOscOJYMOEMQjseRWivPXPbkceL+gx11Hnn55YnDcaaWFqepApKEEAL3hgju9OLILPSbwNVFz3bb028Vl0DsO9TA5gkzZRqB3Vt403s/xNXb3sNz7/0Au2eeQVKPRgWJbY95hVpwCecdLQSWskeQxNlKd5vFe9rpTfhezqHlBGmuOM+YnRx8ibhJ3HvrFnnLWzH/EG+1gtfC8eErvPzlP+b4b77E46/+Mfmbfwp2TQqKUpvomAuoElJHFcNrxmmuwNBFQmjnWkiJarB/PBJSpu+U6pUpG7U4u11idzEgqtxcTzx+dQSM3dUWNDA79EOi7wI5V2pdBMXSxFfVgIuSukQUQ7y5kXM1qjspLl2wy7mlKmBCVCVbATdiarGseSzNYmiL6G7eREYz+qEjCpRamoMyVzS0l7sI/aZDMPI4YS702wFNifE4NZGyT6Q+UIvhxdphCgEvBRFnGAa6LiBBaG+tjaHrW0xvzhXR2HpLvYIVvLY51qJv63Izg56vIerSBGVqe98aMYfsUEsmuhE9ELqAhoS5NYekBiTE1m+5iKnmFamOJiEOA3EYMBPm/YGSD4QYCSEiacC8HYfYdZhF6jxzePwytRy5eva5f5fL6MrKysrKysobgFWoXFl5HeHu3Nzc8LGPfYxf+7VfW0XKvwKvvvoqn//853nnO9/5be9kX1lZWVlZWVlZWfmb4LbH8babEtrjUuuHeRMrT8+flguit8ud41pt6aG8fd3JRSmLQ7KJlScH2K0T7CxuniNDl2jXb3Xr+SnPdVlucWWetionmfVbtDJoXXtvu0i8YwP3fea+OledMh4LU3Z2SdkkZUggQQgxkLY9XZ8YjzMXQyIMkS4qKSnTfgQEz8bxptAPkZuH1xyPhXmqLYJ027G92HJ4fMRMkCBsdz3DridL4ibDfs6YGcEKD8eJzgq7INhoXN2/ZB5n9vuJm5vMmI0YAy5GFSckZYtTcqFUpwvCs89v2V32ECKCUF0IUZDanHQ+PM/FOz7Iu//D7+Ppd7yT/uo+GvslsvV8drT3RgDtIDRXHRJbV+Btoent4+nwnGpA/fY5/PaI3z0ysohgmIFVvM54rYjNuAja9Vw8v2P33JvhH/6nlKJcf+ObPPyj32P/pX9OeelL5MNDVAJehdkyIrf23dRHNEJYImmnAuNxRoOyDYJNmelYqQU2u47NNlKrsb/OPH50oO8iw3agEDAT+m0iipNnwzWBCKUUzKRpteLEsJx1IjiRuc5UmuBtGCLQDf0i3gqok4shGkhJsOqUUiiV85yxUnDPiCrbTUKF5sIUJcR2/pe5olHo+h7DONwUrFYudgOxT1RNaHR6rXSbnlId89wOlhXcDRWhT4G+U1yUWkFVW1eoCi5L56wqKUQQIU8FvLbOVVPGqVLrRAyBmJY+SQlYNYJkgoBHpZhTXam1tsjb0KExtflbZlzatSdEb8K5KvM047Zcs0JCJaCqeK3k40jN0xJlXNBBkZCWuFpDY7uCTfvHiM08eOYZdvee/n+8Rq6srKysrKy8cVmFypWV1wnuzn6/52d/9mf55Cc/Sc75SQ/pdcGjR4/43d/9XX7kR36Eruue9HBWVlZWVlZWVlbeoJyESpHWM6lyEqeWjsg7QuHpBjs9ORbl9MrFRXknqpVl+bN6yB2R6hQDuywrctoWd2JfOS8oKIihoosC1sQd0bvC5GnDt32VcNuziTsXfeD9D3a8Y2NclBkpRodQZiMJ3L8/kNQBo+sDw66jv9iiSRn3I7tNRIdEGiJiFZsmggizBeK2oxOYDjP7w0SuRkrK5bajijKNheJOSJHdxUDsO2ZJ7HNhP86IQc2Z68dHujyjUZFdh2jg8as3lFy4vi4cZiPGSACqC/0QseKYGSkGanSuLhObi54ClFIQIn10pnnL5rs+wAt/9wd4/v0fZLj/FJoSSLjdgw5IbKKkRogDEsOtKOkGVsDmJiR5BTeklnPMb1vN7dfNdhuAgKsCoQmdGpowqsv2YgQiQr8cPkOq4yXjdYbathc746m3v52n3vEu8v6HOL74Z3zzX/0u11/6PfZ//kWST0DFvLlbNUDsAlYqN/uJXIShC3SdMmdnngyNkYvLQB+Ecaw8vjlScmVIkRgD+9GJvTfxFyjjhEgAIM8ztTpYBU0EvZX7qzmiQtp0SDbMKiF2pCCkmJq4mCulZEQDQQGMWps7uViF2m4WmKfMMChDUtQr1dqNBBoEjW1OiUe6FEGcOVdMA12MaGydlDF0dBcDVm3pwxRC7Kn5ABgpJrqUiFGxZXbFIEQNEJTqRq21bVcV3NrfAJZrxTxnxgq5ehOGl95MYkQ04l7xahAETUrwRMllcWoOxK5HQsSrUeaxnZcx4hh9FEJKlOpM84zbgc12A2lDHidKPlDzkTRs6fvNEvGqlDzT8mCFeX9Dno+Iz1xcXrK9uAdif72L5srKysrKysobhlWoXFl5nTBNE5/4xCf4+Mc/zn6/f9LDed1gZvzBH/wBX/ziF/ngBz/4pIezsrKysrKysrLyBuJbEz2EU4SrnL8+6X7ityLl3aX0jvfyblQry3fnaNiTle5OHOupI+70nC/iJHKKjT0t08RTRFBpMaPfrndSFjefL//pWaxsrwkiPLdNfPBBz5t7Y1ObsJSrgQpdhAf3OsSdYkIMkZiUYbtBomJW6buAhBYZatPc4l0zZDNSp2yHwOF64uYwYQZ9FDadYrUylop0gd3lhn7TU4hcW2Ca5uaIqzDNhfHmiE4jw67j/tOXzBUeHzLTcWbKRkHR2OJo97Ow6yCaU6CJl32g3ya6oSOEJswlj6SrZ7h6z9/n7d/3H/Hg7e8gbneIKKDLflJcBNEe4rYJhrqIkrXAeHMrFNrcXI9WwctZWMZad+Gtk9I4y8h3TihfYoWbyqxIs8Uh2jXhMvZNHE09aIIYkBSBDZghpeJ5xusI82NiMq7e9jauXvjvmK7/S27+zZf52v/xzzj8ye/j+5cQNUJSHGm9otW42PW4CzeHEUHpusjV1YBX49VXDjx6PBG7yOVlT8nweJ8ZdomLbVzEUiGESMlGmadmiBRhURmptRKkCXQVJUZBVQkonS77dtkXbgYKoUsEqy0OVwQvjhUnuDPNlblWhl7Z9olSKtULGgIpxDb7qjFselSEUgwrlaHr2QwRM28CadMHQSNuFaUgGNUyCnR9T9/3iATmkrGa6ZKTtAOpTLlSEYIIMUaqGbkWzJpzuFalGuCVbsmgbaG3NEG7ejPsqmAGXh2JQkodsQ+klNrrzdGgmHeUeabWmVgNRRh2yvZyx2yXjI8eotMEacN03DM9ekgKQrhv6MYJXRP683HGyth6O/NEUKHbbhiGHrxgNfx1L6ErKysrKysrbxBWoXJl5XWAmfE7v/M7/PzP/zwvv/zykx7O644vfvGL/P7v/z7vf//7CWH9cLSysrKysrKysvI3TxMmHeUk/nkTCoUlr9NQ7oqQnLJbb8XApZPSTyrVab1+Kx6K0OxftNhIvyN8+hLxelcJPRn4VJY+Pzl5N0/j9rPgehbC7sSMyjLQPsC7r3resxXevHMCzuFgiChJhIskPHPVkTphrk6qMM1OdqPsJ7qa6LSJR4GCeHN2jjcTjnKxDZQp8/jlicOxIAK7IeDmHGchpEDaBPpNRzfsmDXweMxMeSYK5OytM/A4sUnwzFvvMwyJ60Pm0aFwHAvHLMR+yzbC4fG+iTw4JQupa92Gadexvdy0aFEziinDM2/nTd/zA7z1e3+Ayze/hRD7xdnI+diJJDxumjAo0pyS8w3kEa8jXgtuuYmTbq2r0gzMcG99ir50TrY80FPiqmnJDswAACAASURBVN89Wc4HVUSbSCo0sVKbaCkSl8cW7ymha+Jl7JBug6ctEjroItJF8C2Ugs8jXkYg011sePp938OD934Ph298nb/4vf+N6z/65xxf+jJlvEHcudj2uAj7MePejtXFNlFy5sVv7Hnl8czFNnJ1kZiKsZ8KmyHRR2UeM3HoSH1PzaW5KL3pkxp1mTeKqGG1IjHQxQQYQSKpb2K70X5eS0ZjpOt6vBpWFauliZdeqaWSS+vfvOhbx6YZzMWwanRdIIgTAvR9R4yBea6YVYZhQ+gTxQO5gKaEqJLL0hvpoEC1JqqGLpBiwIFcMlYKMQaCQy4zc4XZlRA7SIpXw0vFBYpFppIRd1KMYGC13XhgDrVURDJIE001ds1laYUuRLp+IGy2gJCnCVmcx7HrmVLP4TByPBxxK8SkbHaXhLShlEouB/w4Mu4PlMMN6eICMyEfjng1JBrT8ch8uEbF2N27ou8HhAraujN1bWJZWVlZWVlZ+b9hFSpXVl4HfOELX+CjH/0oX/nKV570UF6XPHr0iM997nP88A//ME8/vfZirKysrKysrKys/M1wMlTe9USeRMrbr+6UCsLJ4Lh0TjoVCCdh81sLCTm97k4f4dkpuUTJOrhY69/z0ziaX1IERMMiRraRIHdclOfxgWoLLT39e9JYFeepQfm+ZwZe6IGcGUjUqcVA9snZ7YQH9zetY9AhBOfmOKExEjplmgqWKzLEZjAMTUDKVdEUUXPGm5mcK6U6KQpR4HgozAbDRaLf9aRNh0viiLCfMqVktjEwzZn5cKTuj7z1zc9y/6me437Pq9dHXn00cixKTR1hE+jFKYeJMhsahE0fSFEhKdtNTxoSKSilCj48y9u+/z/nhX/wn3D5pucQDbgGTgfTUdCExE179AnGh3g+NHHS8tlN6VbPDkqvGbeKWcGsgBXMDEyWblI7H/fTeeK3R+r2uC4qdPta22NoQppI6xRExuVn0pyVmtA4QDcgaQtdc35KusDtAikzNt5A2aMqXDz/At/9w/8txx/8b/jav/xfePF//S3CK39CKSOG0fUdQyekIOwPMy+9MvLqzcxuiFxsIuNUGIuz23UEjTw+zlzuIkOM1Jwpc8VrJcZIDAGXJkwaQrWAxtA6QReHb3MyKu5gpZ3/GpQQ2hzS0GJUrTheM2bOlDMhBHbbfnE+GtUcJFCB/VjY9MaQehxhPMxUM7qu/UmtlooAfUpUUXLJIBAFxAzLGUHo+q45RGuhlIIapBAIoXVITrNRcEI3gEamuTZnrcNsylwFCKRwinpWihnmFVfBlrmNFBRBveAOGprAHVRQaa5XFdAuEEPCVeh2F9Q48+ilr3MzF/SY0f6asDF2m0ieN0zXN8zXD+mSkvqe2A8Yirkw7w/cPHyZcf+Y+5cDnV8QpBK3Wwg7Sp5aDPHKysrKysrKyrdhFSpXVv4W4+58/etf58d//Mf5oz/6oyc9nNc1n/nMZ/jwhz/MU0899W9FcK2srKysrKysrKz8/8HZlSjOWdk7iZdyGwVrLCZIP+mUzt3fWP3uP3e6KUXvdBPaXWOdnBdsrkc9Oyfb00vs7CKA6ukHZ0vnHSH09LQ3d2Z70hEXksI77g/8wLM9l5YJ6mxSJJSZWgpP34sMfeDe/Q15NsYxI7VFhF7e3y5jcMJYqAXyVOj6yDS1uM0hBEA5TBNlKqROGFJgmo1Xb2YM2Fz2XN3fsr28YJbI9bFwM01EhYsUeHR94HgzEs3YbiM2HTjuZ1yEnA22O7pug7qxtYnDKwembAxDYDtEhosN3bYj9F0LcM2Vohc8eP/3884f/C+495b/oAl7oucwXJdTL2SPiOO5CXteJtxOomQGK3idsFLwWrDaYkCtFGoteK04LabU6nLsXHCvd8J5lwMnd6JfRVuEr57OsSZWagjNORsiGjo0BlQTGpqIic5N5MtHmCOqAUJCuh3SXyLdFlKHpqfAHmDTEZlvEJ/ZXCT+zn/2j3jhe/8Bf/G/f46v/e5n6PNfst0GvFZefeWGl16ZKcV49sGG2AVuxkLqI/e3kXmu3IwzfQwowvFmaq5Jd7rgaLDzuWq1Ms8VCYnQ2+I6LABYCGjtmHMTd2OfCDGi0kT2eS4cD0eohXnO5LmSYmDTRQKGLfcBtBjXNreGPtD1gbkaXieSCFGMmg1zIaZE10e8aaCoKCJCmTI2jQSBzdA6NU0Vs4BipNBE1LyIpaYRjQlBMDcQKA7zXJiroiHSx3YbQUUZS2HKtd3A4IGWBjuDCF2IRG03GISQ2plZSju2kgiizaEa2nx2m9kMAbt/RRkPTLUS9gf66qSU0OLYfESsEMIODREJESFyvHnMeP2Yw6OXGKTSa4fYSLe5ZPP8e8hZyC/+awh3Ll4rKysrKysrK3dYhcqVlb/FPHz4kJ/+6Z/m85///NIns/Lvyte//nU+/elP84EPfICU0pMezsrKysrKysrKyhsC4Rykurgh/fT9+ff7RU3krkYod9ZwXhRcz58LRBbRalmyiWRLNOzpNct/3K4dxxbFUpvbTE7OSwfTxaV3alRs4qS3jXGn7pJNcD701MDfe6ZnUyZwZyNCrMb2ouOZ+wOO018MjMeM5UrC0T7SbztS37Z18+hIyU7qA90QybnQ94mkcNjPZIlYhRhaZ984ZW4Ojmni6l7Hg2cuiJuefVFujpkpF7ZJoRQePtxz2B/ZbSPf9Y63cvPSK4zjjJfA9Vi5oeNgxq6OxHFuwmFxQoxsNpHtbmB3/4LYD4gKJTvh+Xfyrh/8Id707u9Ghy2qJ4Fy2Y8iy7GpMD3EbMZrvo1wLROWZ6zMWJ2oecRKpuaMmWG1YKU2l5wt+xxZuijvfia8Vb2bU02XHlEQCRj1jngJqKLSOhxRBTmgGgghElJE44DGDtHN4sg8YgKEiOQDMr6KhB66S2S4ao7L7RYZNvg0wnyDMNNdXvFd/+i/4s1/7/t58V/8M67/4LfZP/pzHj7OqBpveqZDNVA8sLu/YdMr+TjhDpdDQsyYxhliIvXhLLapOKJKNSdnw8zbvIgR0Xb+ExTMOO4PVFVS12JaY4gtHrV6cy4WxybDDIY+kVRwq5QCBQENlJxxKpe7DSlFcs6IwDAkVBK5FMSMGIWYInmu1FrQLqIIYzbm6UhHpk8RN2/iswhRAxoTXgsZZTSHrid1O0opzHkiuGNoi0eeDY2Q1BFJmEZmMw5lJNeZECMhtijimh3E0BAJGk55uZi3ONrASOyUEAIq1uJYNZFroZZCFxTtNlBmylwJdoSukvMMNdP1G2LqEFGsFHKpPH75JY6PX6KvR+49uNfmSxrQboPESJ0nCIrL+ifIlZWVlZWVlW/P+lvCysrfUg6HA5/4xCf49V//dXLOT3o43xF88pOf5Md+7Md44YUXnvRQVlZWVlZWVlZW3hC8tksSwBBOAYjSnsDFb3XLUzIsgi4OspPc6X7bF+k0V+NJ13Q37Cx6Oi5LDKYYuC5rO3VKnrYlmC++PJezwHnajqvcCpk016fiPN0JH7yfeMfg9PMRcadMldIH7t/v2C4RrtWN8fqAVei6QLcbcBVCDNTqPH50ZBwL9662RHGmaWK32xDEmcbCca6YGxebSM7C9cGoCN4Hnn76gsurS0pUbkbj0WECh02E8Zh59eE18zjylrc8zdWm59GLL3PcTxSHR7VSNxsIwsV0oBtnyljYl+bA6/vI5mJg2PbEGMEhh/u8+ft/kLf/w/+YzdV90MjZgiqL29SsOdosn52Tbk3g8TJh+UjNEzaPzPNMzZlaFhdlNcwdr80aa0u8q/hy3MTPsby3CTEKVNxic7ku4zgLprfKZYv9FcVsCSAWMFWqKjILqkdCSMjF8wxPvYV6/ZeIF8QqUgOiFUJF8oSMr6LdBWzuQbdFNhvoB3wckfkxQmZ4+k287R//1zx+39/lC7/5TxnGf8HlUKglU6oxbAShMl6PdF3k3r2B6TgzThVzIYki6tRacRdSFGox0EiMAqUSkpBSxGNANOFlJk8juukYNheEsLgGDUopVGvxp5vYxLsUAlaNea6U3IRhkQDBGfrAMCQqwv4wEVCGTUAQsgESSENzqeZilLxYXnPrxVTgagh0mjA3zA01p18ExGmamapjQOgSErrmniwFKZXqkGuk5EIUWq/lcnxNoCwW2xCa2KwhgIY2z60Qo6Ix4ii1ONBcyuaOaFkiYAE1JDkxDXSmjPtrmJurV1UoVpt4joBEqhVKmal5ot4Yh+tryuNvchlguLhPd3FF2l5C2pKngr/8NeZ5JsShxe6urKysrKysrHwbVqFyZeVvIWbG5z73OX7xF3+Rhw8fPunhfMfw1a9+lU996lN85CMfedJDWVlZWVlZWVlZeQNw62U8Za4auGOviemkCVQnuyJNJBQBPbkk8cXpCHeUzLbKO92T5+eFZcnTt9bGIK9ZcnF1+rnjUliyK5fl3VnEz7ZEJ/Duy8h7doFno3GhxrBEcXYb4cG9jqTO8ZhJfSSPhdgpKQjaReImEoJy83jm5maiivLMC8+Qp8yrr95wtYvgznFsHX67bcArzHNlMoEQ2Gw7Lu5vCX3HdXWO+8pxmkkidCo8fnzkeHMkJeG7vvsF6s2eF//ym2QXKgHf7rA+kbzSz0e0FqwaxSr90DFcbLj33D1SjOS5UD3QP/89vPcf/xOe/u6/j4pBPdLEviZUii+RmzY3gbLOeK1QZ7wcqHmkzEfKuKdMEyVnSil4McwK1epZnG7OyVM0ry69pHob6StyGx+s8SxMt4bCkyAuyzknS/ZviwY2qefeShdBanNXiggmlSIZzX9Guf4aKpGQhBA7NG2Q2KFWQANeFS8zMj+GtEM2D6DfwnYDfY+PR2TeQxTuvf2dfO9//z/w4r/6P/nqZ/8p/uqX2ewUq8Z+P5OikvqE10otjqo2kS1Yyz11oXqlVif1HRojVjIxBWIX0b4jbHaUXJjziG42pL4jhK7NlFIotTah3wyxwjAEgiasZGabwR3RQK6VUgpXsfVnFncOh4IBMTjjXKA4sQ+kLlJL4TjNaEiEmFrHaMmkoAx9IMZERZlru+Eg/V/svXusZdld5/f5rbX245xzX/Xqrmq32238NhnbDHjAJsbMtBk8k9hgHDFSNJEBTVAGK4oUYgWCYmUYgzDCRpGStGcsP4JjBSZDDAxJmxkDNjYBwRB5GBsnELAHY7uppqvq3nsee++11u+XP9Y+595uunnarqa9P1Lp1t1nP9bZe52tOvXd3+83FOG/j4nVEFGgch4RyGnAMDyQ8KRYPntOikidY8SHCnNljF5hUbfl8+kd5jwpJUIQqmpWXI3iiENinSJuyMzbBlfVxCFiJogoFZnghLCYU9XFTdulTBoGvHeIA/EOJwGCkPtNESe7Nc3egiCOvUqYzWrqvQPcbAG+QoEUM3l9ClIBqUTpTkxMTExMTEw8BpNQOTHxBMPM+OxnP8sb3vAGPvnJT97u4TzpeMc73sG3f/u3c+XKlds9lImJiYmJiYmJiSc7Irso1m3w63l055Tcxr7aKFCWP8I24rXEXp55K4sTsoiaZ5Gv5yNmt9LjmYNSwPQR6+rYiCljtyIyeietyF6iZZkXx2EFf+2g4lkLOPBK68CJEoBmVrO/V7oOj0871ATJGTHHLDucMyrn6Tolx4HVJlHtz7j7riucrjec3Dqldp6cha5LgLG/3zJ0mZMuEc0x22/ZO2iYtQ3Z1ZwMmZN1jyrMK0hD4vrxCu17DvcDi7Zm/fAxt26u8HVDe/kix31Ps1iQuw2+3xCgiCcGdeNpLy64fO0iTe3pNwOpPuSOF30dT3/ZfbQX78RJhtyPHZ/jOd45J3ssx9IrmXrIG1K/JvdrYrdk6HrSUERKzcV1VzTgMj+2ztmiR9r49zweq0wQkd0a2wm0qz4dm0e3paS7uWJy5uY96zktqreho2Dld/NVNSMp4QRSdEWE8x2+DoR6D9m7B9ENLq6x7JA8FFGyXuDmF6BewGKB1Q10SyxvCDPHU176tzi695l85kM/zcP/5hfpNrdoak9de3Ic0FzeRzOvi+M2xjEutQi31bxGnMA2Rnfs6BTv0DQwDBvMOcQHcs4Q12gu58/5qjgms1JVDufKZ8FVFd4Mb6Axkwdj1gTa1tNnSCa07QwRJaWIiVDXgbqtyDHRxwHB48VBHsr4q4qm8YgIWZVk4H1AgscQVkNiGBLihaZqimM0KiEEnKvosxFJiIEjjW7mMdjZFE1p1KodIQjiAuYEnGNAcAJVW+GrGVkVjYqpghMsKeINnJI1ly7M1KMIddhQh8CsrWHWom58MEJLH6oLAQkVWTMnqw3JBma1Y7F/RNSWajbDz/bBV+RsWMrgBK81WCLbgHNTBcvExMTExMTEYzMJlRMTTzBOTk74zu/8Tj72sY/d7qE8Kfn93/993vGOd/CGN7wB7/3tHs7ExMTExMTExMSTGhs1w7N+Rydy7lUrgqNtXZeGPGLbUZZ0wplIWV7zbuyrHBd5d+7VUfDcIrZ1R27DSs+EqyJUbdUu22mcMopYjYOnzYUv3/dca5SjxlGLoCnjENqqwsRxss6IV3wVMJXiGjUlm1K1NZtVz+km4T1cvecO5gdzjm+dsry14mA+ZzhdgWUODlqcONaryMm6OCn3D1sOD2dQeTZUrAdltRkAoa2E09MVp7c22NBx911HBFFuXD9FzdPu7cFsxqof6JZr+pMVtYNZWxWHHYYLnvmFfS5fu4AOmU0fsflTePrLX821F34FvlmUa5h72IqUlkb3ZIl5JXdYimiY48h0p9fpV6fETU8cevIwkHNGVeGcexZGIVFcEZnPiZHFSym7BOGtaLWN6t3q0uLG9tOd63Z7eR1Y3sUDy+i0lHFOlrkBSN4dDxVMUhH9tESjZpfw0ZHjQN0cEOoFeYg4J+Uc+oRoRIcN0iyQ2UVoZrA4wvoW+mNEI3tXr/GMb/o2qiv3cv3DP0XoPoNY6W0Ug1B7ZEwHFe/p+ogq1E3AMmiOJZLYIMwafNOSYkZTh2B4ESQlLCX6oUdChYSanBNZlbr2oIkUFe8rEkY2zxAHTDMX9mt8cAxZcaGiaWokK7HrcBh1U+HrgKWIGTRNWyKTNeOcMWsqquBJKdOncp5DJXjnSGoMychWPs/BudJdmhNV1WIi9EMkZ8P7AChZFe8gIDhfk0zJqYiXzgccDicOxCFVwIftPALVDAh1cKCeYOUe4ZsaXEXOmaypOKhjwtYdmjM+eNrKI/Wi3KHUSEMcn6bIoBkcVL7C50TanOLqBt8egK/JVmav5Yyz8hnTFIt47us/221zYmJiYmJi4kuOSaicmHgCcXJywpvf/GZ+4Rd+4XYP5UlL13X85E/+JN/8zd/Mc5/73Ns9nImJiYmJiYmJiSc52+7J4ob7469tGyyLC47RqTcKVWNXpBvFJds64saNhXMxoOe6Lc8tLtKWyFb3HKNCGSNG2YmURcTS3T7NYD/Al+97nn0QuKOGw8ZT1b50zyGE2hPVsNqhllnUASfCMChVEOoqELxjedyx6TLzo4Y7n3IFHzzXP3udPGR0UFR6Fq1n1nqcGsfLjnVvmHMcHc6YzWsGhc0gdFkZUs/i4JD53h43PvsZ1rfW0A3M28D61oquy6g4Llw5InvhxumaW8drRI1awFeePiutF/pBcYuKoyuHaMrE5ODKc3jWK7+Fi/c+CwkNiAe0RL2aYTqUeFdNpX8y91jsyLFD80P0Jw/TLZcMmzU5DuSsaNazybB1yApjfCyMIbujqCzFPbh1OmLYbj07Z6McxWwt7rUyc7b7MWx0Vm4lz+2FtdGJy3lhU85Jp6pgioli6sBlVDxqSnrwt/GhwlcNvm7wVYtYhVPFXEYsImmDDAfI7AhpWwgB25xA3uDbOV/28m/g4tOexqff/17Sgx9HXEbNkaJiFAE+JkWCQ1TIWXEUlyc+0OzP8c2C2K3JQ0KIqBlOPGpS3JgUxy86YC7gqyLRqwlqOnYtQrfuceJYtC2YEqPi24Zqbw8dIpYV7xx11aICQ694X8TqnBLOjFAJs7bGOccQ89itKszbInwmhd7K59A7UHXEWERX74o7OiYwFF95LCreCVVVHIhuvP42KFnLOfDeFyHWF3FXnMO5unRY5ohpLA5GJ9TeIWZlm3MPO+ACKQ5YH0kqdKsl81mgXRwSQo1IxoWaoarpTk+I6xVikcsXDmiCx9sAIvh2HwsN4FBVTAcq3yJ4LJeOS7cVZicmJiYmJiYmHoNJqJyYeIIwDAPve9/7eNe73kXf97d7OE9qPvGJT/DTP/3TPP3pT6dpmts9nImJiYmJiYmJiScpMjretrGvsuumPPf6TlWUbZglNrrndg2VOweePOLvWwfkVkA7z84pueutlOK+4nxR3CiTjnGxbnT1OYPLjeP5M8e9M8e1VqgcOC/kpAxDRgRSNiQ49maevXmDD4HlMlK3cPlCS7/uOL7ZEbNy8c59Ll45YrUZWJ3cIg8RrDi+5o2jkcxmPbAejD5DaCr2FzVh1tAT6LNxuupAPHXladsKTRviak3qIgfzmqEfePhUObi4x8HRHkkct07X3DzZsF5FFnVgbzHG1JpxskkM3nG0aBhiwpKn/bIX89y/883s3XEX+FAcauiYwZsfEfNaOig78rBBuyX95pRhdUq/XpH6box5zUU61PH6U2JBZZv5K8X5ZjKq1uIQ8ZgWMdHcNsJXz+bAGA+8zfWV0XW51S+34qRsHZjid3NwG0Isj/htFK6lCFpnkyiX955diQtNCnhUIWfFp0gIPb5uoW5wvi4xo5qxHHFxXdyV7T6ydxHbnMJwAj5w+PTn0P69/5zf/1f/nO53fwVLPaGW4jzsImoeH5SgFBFUDd8G2v050iyIwzDGwGY0ldzYrEqMGe8c4oTYDVSzBkHRIeIrjws1mCPGTN/3VAFms4bUR/ouU9eOaj4jZ0GHRO1AKk/OJYZWfBFSc1QsZ+raUwdPSsoQM6qGDxVN3SAO1ptIyj2+DviqJcZIHIbibvSOIYG5SN0GfAiYBYxcnKrOo9nIaSgPMjhHCJ6kiqZMlgHnShdliXfV8ZaQqXxAnCebIaFCcyapYX2PBANfg0np7xRHg0c1Ejcb6rpCKsH7hpzLsn69REw5nO+h3Qk+OHB74CvM++IMz4lsVu4jVlydpoZoRlEk/QVvpBMTExMTExNPeiahcmLiCYCZ8dGPfpS3vOUtPPjgg7d7OE96VqsVP/VTP8WrX/1qnve8593u4UxMTExMTExMTDxJkdEJWTont+oSO1GpiINbq2SRKRmFTQUwG9sjZUwLLc442/VTjk7Lc5Gtdi7/8yxhdBsFO4pUUo7ltvGhYjgBJ47WwdNa4blzzx017NclxjGbUPkABqkJBDHaxrG337DYq8nJOFkNhDZw1Aa0j6R1xJxy9doFvA987nMnxK4jjN13TRPY3wsEEU5OBpZrRcUx32vYO5yBC/QSWA9KHyPgmAVP13Xc+oM/IPeR7rTHA6enkQxcuesyzX6Jej1drchJqcS4vNfSBOPqnQtC5Vj2SrO3z8zDpaMFqsLieV/L8175TcwuXkEk7LxngmCWsJwwjVgeIA1oWpP7FXF9TFyv6DYrhvWKoetLP6LmEq3JWb+kSOasS9Kdi2s9Jyrvsl71TLDMW/frtq/Uc+bEdTvRcuu6dc6xDYvdxsUKbtdBujXfnp+rj8QBmZ2oqSCWMUlkC5h6NEc0Dfgc8XEgNC2+mmGmJQpWM5IjLm5gdhGZ74Ovse4mOKG9dCdf9uq/z6c/dIkbH/0AuTtmGMp2ljIoBD9GpTY1oQnFQZo6iAN5iEUYFMGyknPGY2g2NIGrAjmVfsQqeMzK+89qaM7Ma4d3gRQVNRvXgX494LwRfMnVTVaE6uKGzGRVHMKsCYSqbL/uIyDszQJ1Gxgss+6hj0pKisUB8Zk8RCoyUgdi9GQcVeUxVeKQwJUzrmakFNFUBFFfBXBuvJeMBZJSrkupO01oVsQFgnPFfbq9p4gb3bWgeMiGUOJcvTPqKlAFQakhKeSI8x58xfpkyfH1z5G7FQeLGbpJ6LDBuQVSV5iryvw0yJrwPhDqOUYufZrOl7RYsxI1OzExMTExMTHxGExC5cTEbcbMuH79Ot/3fd839VJ+Efm1X/s1HnjgAZ7xjGdQ11NXxsTExMTExMTExOcfN2o/bicDbXNazyQpNwqThu1Eyq2pLcMu4tUEUCs/t2IUsFsgJbp1F+MqsluvaBpnbjzDcKPIWZyWEMRxqTKev1/xzHmg1YQ3pe8MH4Sjgwbvy7p7+xWVCFVTXGCqjpgTYolahNQZJ7c6fDvjyuU5QzKu31wxrAdczvjGsVhUHO1XpEE5WSubHnxTceFwQT2vic7TZ+Fk3YEZsypgzjhdLyEm4pAIIdBIOU/VrOKpT72CeeEPb645OV0zmy8YdEOFcDQPHB3VxBg5jZ750SF7s4a9WaDfZGZf/jKe+w2voj24VIQdRgEQwyxjOkBOJfI1dVhck7pjhvUp/fKEfrVm6FbFRZnyzvkqozC8jWWVXWzrbiqM16FI0rbLCi5RoGKykxt3syIrKhlxHnEekzGyd4x2FedGhyRF0DTZidfFwTsOwNw4d3YZxDvnZVnZF4el6HguttG0RdgTLU5e1RJtq5YJOeKbBc4asFjejyqSOmR2Gdo9xF/GVrcw2+Dnh9xz36uQ2T6f/Ff/GxJvEExRlNgb9SKw2GtJmkgx423ARBg2CUUI3mEpkbPhTFDbCvRSnJQZfCjuQpXSH4kqTRMwgyGWdxwqYTN0pJRY1DV1AMvFQeyCA2ekPiIYdahoKvDO0afMkAAHTeVxVcWmy6xiRsQTKk8yYbkZMDE0RmpTWEfMOWbzGRYq1uuEmOGCQgiUpGAtn1sfSsRy1p2Z2oUanEMRLIEKIIonl/jc0UVbBGmHc4I4281tSxEEmqqhrgNeFKs8ioAENEPfJCdnNgAAIABJREFUbzh++GGGbs08BJwpQ7dBfIVIwBFwVQNVjakVgVPAeY+J381hHZ/MEDvv5p6YmJiYmJiYOGMSKicmbjOr1Yof+IEf4AMf+MDtHsqXFKrK2972Nl7zmtdw7733PiKCa2JiYmJiYmJiYuLzgdiZiRIY3ZGMMaLKWd9k0ZJMZNdbWQRLK5627erblQEnW9ddEZrkXD9lMVieOey2PZRYESh3oxoX18C9LbzwqOJZFyoqVTYrZRMNCYHDCzOCKd7DpcsznCn9KpV4TDGUTLfpESdYTESE9mABdcNDJwPrk005ohOaynPpQsOs8qyXPcsuk0xo91uOjg6QqqETYbnp2Ww6gvcsase669msI1VWUlQOj+akPvFHG+PgjkMODmYMAjeXHZuoNLM5Q98TUuRgr+ZoryEZ9BJwdU1dOw5njn4wDp73Mp75ilfRHF5k2wu5jUZFM2jpoUQjFjdYvyJ2p/TrW3Qnt+iWS2I/kFMqgk2xP47Ot/HCWbnINka7FgFUdw660h25jf/dXmwZo2d3M2qMEh4FJ1Vk7DE1FdwoXO5smudSgneO3J2z1u1WObd3dhttHZpbid2Us6DZ0qNpkjE8pg5TQzWhKeJTorn2fKCB9ecwU8wyohGnF2F2BPsXYXUL0im+rrj7a1+O+ppP/ez/gnQPYQlCgLYOaE50XSqCIRSxEUcI1Si0e/rcs14OYErT1jgBVcP58R1IQM1RN4HghZwyQ8r4OqBdpNskVMvx6krQmEgp7npWY8o4EZpKqKryftddRHE0bU3dVChCt4msuozzjrrxRSO2zKJxgGeVHX2fyucmGcknvHagRhOEYB4vuTgTpSqdk5pJVuKczbQ4al35hA9xnHMeqhCKiKxaxEjdzjGPhIBYKg8b+IBZuRs5R/HmasYk411xoS5v3WSzXKObEw72F1SuQnOPhAZX1Zh34Dw+eAgBHQac295nBpwL4CtUXZnjzkEeHv9mOTExMTExMfElzSRUTkzcRoZh4N3vfjdvf/vbb/dQviT5nd/5Hd75znfy/d///bd7KBMTExMTExMTE09CzqRIOycCbZ16Z3GbRZTc+dhGcag4IW0b53puPzaKko/ooNzGgJY6xN1ezuI+beemk11PobHn4Pl7geceBJ6ycBzWjm6TyWmMkaw9sR+YzRx78wrtI12XiWqE4PEOYp9KBx+g4mgXDetN4vRkNbrgEnXwHOzVHCw8qLJcRladYt5zdDBnvr8gmtAlYzVETpcbFrOa4B0nyzVpGAi5uMouXZozxMQmJa5duwChYpMdfUyoCbNZQNcdQSP7+zWLpqJLGdc2tE3N0dGCSoyT456LL7yPZ73iP6Q6vFi6HOXcddEirlkeIPdY7Mj9KWlzTL+8xebkmM1ySRoSmrci5eiCM8Mk7nRBG6M6xUYJVMqVMbXReitFULKttXGM9TVFxD2i33Q3a3bmyHF2qY5CVihi1m798+tuhU4tLagi40x1nHdzjov+hHjYUXhVA9IujthUMVX0wd+m3b+M5B61CtEiVmIP49KA7F2GxQVsbVg8JdQN97706wkh8Ml/8WM0w0NUAn2fGDTjgkcwYsw4XyHOjfHIkDKsEyTnSkRtjsx8wEzQaDhRCInae7w4YkyYKpVzxKQMXY+lSFs5fOUZBiXFSOUN52oUqIIjVA3OSg9mn0skb9tW1E1FMui6RIxG2/gyvlw6GtsA4gJ9EmaVx4WWhNJlxZwn2hgNLQ41xakgvjSIppQREepQgffkrOUOEjx5vN6K4U0wzahFVBwhBLIlTBNSVcW6nRNOPC4EnHelR1QCopTjhhKtOwwd5jzknkUjtHWFSSBj+CrgmnZ3N8pJQTswxfmAr+vxoYqEOIfzLSkNZe4/QnSfmJiYmJiYmDhjEionJm4TZsb73/9+3vrWt9J13e0ezpcs73znO3nta1/Li170ots9lIkvYUTkg8DLzUz+tHUnJiYmJiYm/uqglH/3F8FpK1kWdxrnBDFl64DbetbOiZfnlpV1zsTJbSSoWHE27rIejZ0Tz6T0XJZDbCM8hQq4oxaeO3fcGWChmb5LbCTgnNDMaurKM58FDipog2DR6BMkg2a/xTtBUfYPZ6zXkRgzXo2hU3JWZpWwGYoz7vKFGfszx2aTOV0OxGw0s4q9/ZaqnbHOcBodJ92GHCN18OQhc7w+YREcVVKaWaBygZObK6SuuHrtEtE8J31iuVzSD4Z4odZEZZn5/ow+DpxuIoujfao2cOnCARoHTpeJg2e/lGf8zb9DfTCKlON5KjG8GbHipNRRpNT+hGH5MP3pKFKulqQhoyWnEylXkm03KaajedFtMzgxUXRnmBR2fZUUh+TW0ehcGK/hOXfluf5RxuOYbQXMs+WmGTRjziHeEKnOidOj3G3unPu2jKscbxSyZZx7oxC6+zmOQWSbsTo6MHMez1sgW8T0mD6u8PWMUC9wVbU7P2qKqCJ7l5HFRWwdsLhEQs3dL/5qKi985ud+jP74OsF7mqZGLeMdSCWlZxEhOEc/KN2QCKHEjfZDwnslZyNr8ai24giSSTEyREWcx/mKISVil6iDI9T16AoVxHmq4BCJZFUqZ1TegSldnxii4nxV5mMd6PqBLiZEKpqZwznH0EfEIMjofEyJlKCqHD44SIk985gPZCtCoyCIE+q6QoBsRlbAlevmRXDeE1OClMiaAfA+YJrJKYEIPniSQhq7NL0aIkVIHCcmliOWeqhsdBELlhIxDoQ6sHfhArlpyOsbpX9ynMcZwY/3lqyKDXF0eIIPFVjp15QkoB2uosxFFO8nofKJjIjcC3wS+J/N7Ntu62Aeh+l788TExMSTl0monJi4DZgZH/vYx3jLW97Cpz71qds9nC9pHnzwQd785jfzrne9i7Ztb/dwJiYmJiYmJiYmnkSojkLO2EuojxCaxv/QZ1sleU70GbsKy//FbiM8HylObhETRIoAZDr2z2Gl+1LgvNAlUtoyZ854xszznJmwJ5nDNtAGoQ5GUwdwDheUvbljb+YhwWZQ6kWNYOzPa3LK4GAxX3B6vMIQApDU8GaIGTlm2lq4cLTPrPZsNgNDzoS2Yl4F2llAfcXKNRz3iZP1BjFYtA2nx0turdZcamucDuwdNlhSbtyMhL0FB0f7dDFz0nWs1xtOl4kqwEIFUmJxNCdmIWZYHMw4uLDgcF4Tu57NZmB+15fz7Fe8mvroMriqnN+tmGwZ0YTmCDlC7MndCXF1k+7kFutbN9isN+TYoymPJ7qIjCWGdRQsRYpbMm+v6+g8FAFR3Ci4iRs7RbfXSBzmx4hPceDGSNidaOjOxju6LrcOW9v9tBLnqZksxWXpvC/XVs6cvLuw11GY3EbeCnrm3t2K4I+IjuURcxnZRo1GxAJqipmhWmo3gtYEm29DZ4EltszI4g6YH8AKSCtcvc+dX/E15Jj49M+9h6BL1BQ/OiotA5IRBzE6TCpCZWz6npiN2ukuYrkKnrYR6irQ9wPZQTMP5ODpBsP6TC1K2zo0GoPaeH6Kk9EHRx08QRTNmRiL+FmNUa/OwWoZ6WKkbSuapiZrZOgGxIyq9uRspGiUXXtMlZSFEGaIKUm1dM+WTy1oEQDLeyjCpHOlK9TUSNmK2Cq53FrMkACqYz60CHgbz/0YQ2wZpw7f1HhflX5arPRIZkga0ZRI/QbxjrbZx6UOzRvUSvetqzxSzcH5nXtWMFyo8G1L6jo0xVH09qgpeegJKeGCR5OhTELlxMTExMTExGMzCZUTE19kzIyHHnqIH/3RH+WXfumXbvdwvmDM53OOjo546KGHiDHe7uE8LqrKL/7iL/K+972Pb/3Wb8V7f7uHNDExMTExMTEx8WRhFCgf2QN4Xpgco113IlRBdxvYmZr06F1vHXIi2BjbqZwJn4aNIuYogAEO42otvOCo4k4PMy9UCJWAR2nrmqQwq4RF69ibVWyWkSQw259hXjg4nHFyc4lIeX1YdqCQuki719I4Yb0cyEmpKsfhokJT5mSTMctUTc3BXoMPFX1ydFQcryPLdcfMexoPx6dLhpNT9oJn0QZmiwVDv+Gkh/mVC0jdcNoPnJysaJqa2CdaMRYOKozm4h69D/Sx5/DSPtfuusKidqyWK4aYaC48jS+775uY33EX4qtHXhlLpY9RE+iAxR7tT4nrG2xOb7I+fphutSQOCcu5RL1SxBwwRIvMJ658rzDdNk/aOX1PwLnt9EB1dLq6UaDGQEuErIzCpPOCOje610IRvSj9jOe9Ra4cdHvEcTJEsEzWEkHqQkDEj1GchqMIimdRsWX5zkjJeWcnO0F0N0d3IcfFOWqawISMnbmCRxupH4/IKNKz/ENYXEHmB9jKQNe4dp9rL34JaXXC5z74z/B0SIasGcGDKJrA1xWVd/RkTB3zYIgKKRZ352zuqZtQoozNUXkh50jMhiTDW8KLotGhZtRtoB8S63WiCkJbBbwYiqAihNrTVDV1XaEmnC4H1n2irj0hePq+Jw6JKjh8VZGSkVIiVL44drMQcxHynRM0geVcxMhQEVWIQ8RypKordLw+dagwJ2RLdIMxxEgIbieKe1+uddLSR5lyiVvOsYOcCK64OOs6IAKahrHPNBBjZOg6ctxgmjjY36MSQzdLNBvZ/KiHC945qqZm2GxAM75uSvyzCK6uEDeK6GZY3nZWeizG8SGN+jFukhMTExMTExMTk1A5MfFFZxgG3va2t/He9773dg/lC0YIgde85jW87nWv42d+5mf4yEc+wic+8Qn6vr/dQ3tMrl+/znvf+15e+tKX8rSnPe12D2diYmJiYmJiYuJJgo6uo63gtJN27Ey6PFs2ikPlt1HH3LrvzuJEz7bcujP13PrbZkobI0HH38VYeOH5h4G/dlRziJKTsWgcp6c9wcPe/owhKtGM/XmgqRzHxz3rLjM/aElZmTU11z93zBChckrsMxqLANbuzcgGpzd7YkxcutAybwJ9HxmGjBNH1TbsHczQnFhFYU3gxvGSOGTayiOqPHzrFOl67rqyz/5eQ7/sefAPb6KzOYd3XCApHK82pG6g2wxoSsxMyJpoZnN82xCdENc9Fy/sc9fVAxzKcjmQkpL9gjv/xn0c3vsMxJ+d8935NsXyMIqQhqUNw/oG3ckNNjdv0q9XxK5HUznvbrzGu+uAQ5xH2BoRbXQojl7CsauS3fU657I127khRwUbG+Nfc9oK075EkjpwPmCj8Ij4seNwK05vXZZbF5sWh25OJMs4V8Qx2cW9CpjbRYM+It5VBBNXXH3YKMq63TTcbTMeczd8S+DBzI8CbJn7wcBVLYwSrlv90TmxMiEkXHvI3f/+ffTHN7nxf/8cppsi6uaMSfnO6UwRi7R1+a8tjYkhJ5wTDvZaXF2z6XtMhHrWFJ+ogjfFqZJSJIpDGkczr8hxQDTRNtDWAUGJMeJCjQ+eKhhVE8jZWG0Smcz+xT3IRrfZYDkRQkCcZz1kNGeq4PGhImePSIk/NUvEvgc8rirdkyaCaKZyEFzp/ox5KNdHHcmUpBDzKELbKFqLh2SYc8UhiWApM6QOZ5nKOYI4mioQXMBij5ERqTE8KQ5s1ifUwbE3r2mDw9JACjOiCUlLB6aLCaQv9zLnivPUFRen5ogf37cZ5GyIg/nRERL2OX3wU3inmE3/BTkxMTExMTHx2Ey5CxMTX0TMjPe85z289a1vZRiG2z2cLxiHh4e8/vWv5xu+4Rv44R/+Yd7+9rfzIz/yI7z61a/m6Ojodg/vj2FmfPjDH+b973//k/q6PFkQkb8hIj8hIp8RkV5EPici/1JEvvXcOt8mIj8pIr8nIhsRORGRXxaRv/84+/ygiJiIVCLyRhH5XRHpROT/FZH/9Nx6/5mI/Ntxn38gIv9Izv7359H7/GoR+eci8qCIDCLyaRH5JyJy1+f/rExMTExMTEw8EXGuuM/KHx7RL7jFzsVwGnamXI7rjzrl7qeDEt04dlpuA2PVSrSsbXsRx248TLkUhJdcrPnqixV31AY500iGFLl8FLjjyoyqgbqGg4MZm27g+h+tWfVKddBweHlBisqNP9rQRc+qT2y6xMnxgNUN9ayh63qOb20wyVy9c8FiFhj6iKlQtzUHl/c5vLBPUuV0EG71ysM3l1iK7DWBNERu3jimiZGjWaDSzPpkxc1Nxh8dMb94xEmXeOjhYzbHK/rlqogqq4gqXHrKnVSHhyyHROo67rp6gbuv7hHXK5YnS/rNhm654eAZX8G1F34lrm7LBWLb71jclGjCdADtMe2Jmxv0y1tsjm+MIuWA5rKemGKWMU1YHjgTBkfB09LYU6kUv2sRG4soqqVLcnQblutmo4ito7C5jQ6G3dQY19es6DCQ+w2pW5G6JbnvIA8Uq952021k8PZ3HSdLJg8bNA0l6vb83DubkCNlPFYm9E50l9EJvIukPX8uR7XSUsZy6U/MQ0/qN6RhhcYNloYiCqcVtr4OeUBmR6MIV+MXF3na3/oPaJ/+AtQ39FnoFTZ9Yhh6corjuTNUE/2QcCK0i4rBhIdvboiD4UNDzEVErkJFFTwiQqhr5gcLZvt7mAk5G/NZ4OhwgfOBLhrJHC5AXRtVJQxD5mSZMIW9xZymCWQt77WqK8wHjtfKctVjamSDTa+k0WmLM2KMLDdrupzJOGLM9JsOTYk6CE3TFOHPhJxh00f6IdIPQxEFgRwjQ4xEVYacS8+lr6hCRcDwmqm8sGgbFrOGuqkxU3KMiApOKmIayCJ459mbVcyaGpwjqSNlo1cYzGE4VBVNSup7NKedSGrlxoOqkVMsPauWqKpAPWuZX7hCtbiEc4HgJ6Hyrwoi8lwR+SkRuSEiKxH5iIj87cdYrxGR7xm/I6/H790fPv/dfFxvb/xO/MuPWj4bv3ebiPwnj3rtH47Lv+ML8y4nJiYmJp5ITP9KmJj4ImFmPPDAA/zgD/4gx8fHt3s4X1Be9rKX8VVf9VUAzGYzvvIrv5IXvvCFvPa1r+VTn/oU73//+/nxH/9xfvu3f/s2j/SMk5MT7r//fl75yldyzz337GKPJp5YjKLh/UAGfgb4HeAO4KuA7wL+2bjq/cDHgV8CPgdcAv4u8B4ReY6Z/bePc4gfB74a+D+BCPxHwD8VkQi8AHgd8LPAzwOvBt4IrIE3P2qc3wH8U6Afx/lp4FnAPwBeJSJfY2a//5c5FxMTExMTExN/NShuSjjvlnwE58QgGLWicw673Wpbc+W4P9utYudclOzEJmdG7Yynto4XXqh55oGncQ7vjKPDGkWogmMxr1iebkqkJkq33uC9J8wbLl45QLyxWvZ0UVgloWmVtvas1om68uSk4MphL+7X7C08gtCtM0agmjv2DlpC8GwG6N2M7I3UrVgEh1nNreWGYbWh1sj+YYsm5fi0J3pHuHCRMKu5dbLh+HiF9gmGxOG8gk2iT8bFO/YY1FjdvEkVAk+99yoXDxpOb5zSdxk12Kwj8zufyT0veQXV4gCR85GvOvZSZiwnyBkdVqT1LfqTm2yOb9GtNgzdQE5FqHTjdmjC0gC+RmzsdzRFNRfnmm1jYYvMnEVGp2Uao1sdxWlZ3K9C6RjcRrNu/yAO8R7IxX2HG6eOYhlEDM0bXPSIdzjvkTHideu024qeMvZJAmQdUM04XxVTpmzl8HPjGSef7ObjtjvVSjfl1lW5y5rdtkQyOlSLDzNhIHrmLh4rPEuvZoetHkIWdyDtIdbdRMKc5tI1nv6K1/Jv/teHcOnTVEHISUcTp9B1EcXIWqJZvXcMRYvHeYeEQMajBjWKd45hSKhlZntz2llLTCXetWkb6gBpyPTDgDjPbNbSzoqrte9h1UWc98wXDYYxbDoCkTBv6AdjlYSBzKx2OOfI6jDviQopC5aVfkioQY6ZPm/wgBNDlNLv6j0Zh4Ty+Yoxls7X7T3Aj25aofSoqsON7l6PQ1OiEaWtGtqmwtUNOWdStynXNzjSMGBkLly+gi4WSH9MNgcmKEV8NQxcIOuAB/CBrIpoESSlbghVXaKqc/kseF8ii3MyupNjchJC5ch5thPNJ57wPB34FeDfAv8EuAb8PeABEfmPzewnAESkBn4OeDnw/wD/IzCnfIf+CRF5kZn9NwBmthSRXwO+WkT2zex0PNbXAs349/uA95wbx33jz5//wrzNiYmJiYknEpNQOTHxRSDnzK//+q/zxje+kU9+8pO3ezhfUJxzfNd3fRdVVe2WiQhVVXHt2jWuXr3Ki1/8Yr77u7+bX/mVX+HHfuzH+MhHPsLDDz/Mer1+RAzWF5vf/M3f5P777+dNb3oTIUy3xycaIvJ84H8CToCXmdnHH/X63ed+/ffM7Hcf9XoNPAB8j4i8zcw+8xiHuWfc9ta4zVsoX7p+FLgFvGC7nYj8d8D/B/xXIvIWM0vj8mcDbwM+Bbz8/HFE5D7gXwL/PfCav+B5+I3Heem5f5H9TUz8WfjgBz/4ednP6enp53V/E9M5fTy252Vi4gnBTjzcuiC3ix//3707X9o51ySjSOnc+QjZ8vSW2ZlIKSJ4My43wvMXFU9p4K4Z1CIELzTe8JWQk+dkNXCyGgi+OKac8+zvB+YHLftHc26drEmDggR6lzi8XLM/a/mDz5yAROZNwFnCO8/+Xk0THDFqkeWCZ7HXsHfYkqJy0mWStERN5DwQEFZ94vhkRVBYBOHy5QvELnLrdM38aA8/X9Cb4/TGCevjNRYz81lF09RYNqII80uHLJORT25y8WjGtauXmIfA8a0VWSGr0i970sa49ndfzuKuuxFXbe2J44lU0IxpLH/ihtwtGVbHbE5v0a2XxL4jxwHLcYxkNdAI/XJ0vlaodaOZUEdxkhLNuXMcZoCxD7JcNx3DOWSMQQWK8GjbfspxNgiI8zhXBEtxvoiR4kAUE1/6BwFJGU0Jhr4430KF+Lr0Eoqc17/LnNRMNsVpxoUacecjhz3bDlS3Fce352w78l395lYy1zOR/ZzDVHMko2cRs6Mo6gAVQdgg64dLDGy1h6UVUh9ycO+zeeYrvpl/98B7kP4m89YjTsjiWSdY41hcugjtAZ3CYv+AS4cXufWZT6HLhxGUShRLifUQcc4xn7WId2w2CUdiVnucQYoDKWXaRU3TVjRVRcrKZmPErPi6om4rUjbQROVA8Qzm6XWgDo5Z3SAWijNUKrqUWXYJzRlBUCvXIeeMZsVVFQ5ByCV+WQeyL/Om9My6cb5pmV4iVPWMgJLiUE51NtQGXPYEyeWBBlXS0JdeUHFsvbBDX9yobTCquCSR6LOSxthi8+Vm4uoK7wxNeYx5BUuK5h5CQJ0nO1+cyWbUzo/3O0NcRd8ZZqeIKx2rKcY/8VY58YTh64AfMbM3bBeIyP9AES/fJiIPmNkJ8N0UkfIB4NXnvg//I+DXgO8VkZ81s/9r3M0vUITJrwP+j3HZfZQb44c4EyYZU4v+JvB7Zvbv/iJv4s/zvXn6d/Sfj+n7x1+e6Rz+5ZjO31+e7Tl8In1vnqJfJya+wKgqH//4x3njG9/Ib/zG4/076cnDM5/5TF7ykpc87usiQgiBg4MDvvEbv5H3vve9fOhDH+KHfuiHeNWrXsVznvMc2rb9Io74DDPj/vvv56Mf/ehtOf7En8o/pDxg848fLVICmNkfnPv77z7G6wPlKc/AuS9Bj+J7tiLluM3vAR8Bjsbjfubca7eAfwFcBp7yqHFWwH/xaDHUzH6e4rB8lYjs/4nvdmJiYmJiYuKvPOedlNvOwqJZ2bkUWDu3xhlOBDeKOd45vAhOjFIPV14rvjoZ1y3bzBy86GLDyy7WPGvPc3XuaR3okKgCNG1D1yurVUfXRRxCVkOcY75XcfnuCyz2G248fErlPTjPBuWpdx2y39R89nM3CZpYOI8Xo6k9h/s1dRCyGVI5XHDsH83Y22/o1pGby8Q6e07XPbEfGIbMw7fW3Hj4GJ8ybSM0tWe16lkTmN39FOToApshszo+Ia46msZz7eoBVw7nDElJdU1z5RBtA/16zaXLhzzl7it4B5v1htRluus3GD75IPKpP+LC3S/g6ov+eulG3IqDIkUV1Ay7CNeePCyJm2O65S365SlxvSENxUlpWrooyREb1uiwRrONImcqca7FK3kWA3uuodRMi5hnjKLhVuLT3bUvzsUS42s6jksTliM5DuRuQ1yf0i+P6VcnDOtTUr8kxw5NA6oJ1SKCpViicONmSeqWaOpLzCyPSiJWxVJEhw0WhyLcmlFkZx0Nk9v4Whsns2wHvIuEPXsTMgqc5c1azlhWNCVyGkj9QO47dOjKmHYxsGtscxPqGUgNFpHmAldf8FXc8cKXUdctThwJjxxd5vTgKg8tLnO6fwd651XCU+7FLl/luPHEa09j8fwX468+gyHD6WogxkQ7q3C1px8SebOiQnEofRcZukSoHIv9OXXTsBkSp8tYeljbimZWEaOShoHKC75u6SLEfkMThFldEaqAicfE0cVIH20X22tYEY6BCmVROWZNKF2WVSCLJ2Yjp0zsIzlFvBdcCIhzhKrCB0/wjsoH6qousycPOM3ULlNXAfEVXT/QbzakzQpRLQ/jjvOocUZAOH34Osvjm/RJyCa7WSgieCfUladuZohrSDGWCN+UyTGTYi7ifYpITihaPh8KznuqpkZ8KNPD1+UBgYm/ChwD339+gZn9a+C9lO/F2wduv4Nyg/svtyLluO514B+Pv/6Dc7vZOiPPfxe/D/gN4H8H7h4f+gV4EXCRyU05MTEx8SXDZBmamPgC81u/9Vt87/d+Lx/4wAdu91C+KHzLt3wLTdP86Sue49577+X1r389r3vd6/joRz/Kr/7qr/LLv/zLfPjDH+bGjRtfoJE+Nqenp7zpTW/i3e9+9xOyT/NLnK8Zfz7wp60oIvcA/zXli889wOxRqzzlj21U+NePseyz48/HetJgK0TeDWyf9Nwq9S8XkRc/xjZ3AB549uPs80/EzL7ysZaPT4zS6E/2AAAgAElEQVT+9T/v/iYm/ix8/dd//edlP9snHj9f+5uYzunjsb8/PQsy8cTgvBC17fQ7L0puXXU7c9/291EAEjPCthPQgRN35qYsdqvdtgLseeOld+7xVG/MnDKrHYdzV774O4+vfHHfoewfNFQBvAhN5Qh14MKVQ7puTbcc8Ainm0TVeA7E84fXT9l0AzMzsibmew2HB4FFW4HzZCtddV6EqqmpvefGrTWng6fPgcEGWh9YDcbNm0vWx2scDlcLASEDrp5hdUVWZXNrjfSJfrXBOc+s9ixvrumjsjFHM6voTzqcRa5dPuDKlUNyjHjNcHxK+sNTONnAYMT2Avf87VdSH1wYnWUF1eL8ExQ0YnlA45rcLxlWJ/SrU2K3IQ09GmMRGTVjW3Ez9SiO4PzY8+hGgW7sJUVKRK/ZKPIBtp0TspsJpkW4NhkFRCvbFyetjW7L4lrDdIz9LW7brGM3ZuxG96YDB95XOF8Eq+J4c/8/e28aLEt6l/n9/u/7ZmZtZ7v33K13tRq6aQk1WoCRRg2CAcHE2CGHB4eR/WWwWSwiHIAGf/CHcQyEbSxkwoRmAkyIMJtpAQYpEDIxwzKMJJCQkJBZpG51Sy2pt9t3OfdsVZXLu/z94c0650iotfaqzl9ERZ1TlZX5VuZbdW+eJ5/nIaZIDB5jW2zR9yAaC2qO3b6981FSdvqJXTkfc3ztypGZ31s6yiAW1V59PTn/e6cvKyEzR86m6BEgSJ6XzqzibSXH1PoFtCVSzdD6KuLWMNMzXP+qf8L+pz5Oc/HjyPYpdkabNC4wxuJGFYVJjGcFKRmSKuW0Ijm48c7XsPv4K7j8Z/cwkQavDrpEKeCmJWCpa4/3gcoZxpMCEVgsPV0bqEqHc9lV6ruASYGyNESUZd3RRcUalz2RMUfzhiT4zuNDwBVjivE6XdfQzOdoikydMB07XFXik6XtPLYYoxro2va4MzQJhRicza5TTQnvA048tigwJjtBXcwXIljrQBxJPcZYrDE5odi3aKcghsmoxKgnJGGxjEQUU5SQApUxGJU8B/s5kFIkpSywYy1Ji9y56dvcwwuElNAYMEWBMzZfOGESgiWhVLMZ4/LMV/FtOvA08tcnollP8h/JVSgvFZG3A7cBj6rqfZ9n2f/Q37/0xGPvB2p6oVJENsjnrz97Yvl/AtwPfOfnrOfL5ss5bx7+H/3lMZx/fPUM+/CrY9h/Xz2rffhsOm8ehMqBgaeQD3zgA7zxjW/k/e9//zMaafp0MR6Pee1rX/sVxaaKCGtra9x999288pWv5PWvfz0f/ehHefvb387v/u7vPm2Cparynve8h3e84x38wA/8wNOyzYEvmZVy/PkiW48QkVvJUTNbwHvJUav75EiZW8gnV59XTVfVz1cgu7o69As9d/Ly4NP9/f/AF2b2RZ4fGBgYGBgY+Bogdwwex7miYIUs7K3Q4zhOEUi988r2qk92S5qVEbDvpcxRnIncb3eqMNw5EW4wgbFJzKYl122PsXjWNza5ujPHWkFDx6lTU0jKZFaQuojYLFTtXN6ltAYRS5ugKhyx7bi03xFT5MzGmNR6qtmItZljUjmCTyQjYMCVJdO1KV3dce2wY5HG7NYtGhsqZ5g3Dft7C5pFjU3KZJwdd0sfWT9ziihQL2rmBw0mRESVsnKgsLNbg7VY4yBGwvyAjbWCW15wIb+vtkEO54Sru/i9ltApMQreOs5++3exdfsd4Mre5dgfiD6SdOVaJHZoV+PrRe9UXOTI1+DRFEkpICn24mIELLYaoWI4PsKrg92LdJqP11FU6tFEyAJgFimlF/KyvzZre+FzRM2+DzJlsQk5WjILobKKXfUoSqTLc89YjHVZ1HIOMUWeXzEQjWCKEufG2fm2EkdVQQOpS+ACtihBHLnL02ZXYO/nze9zJWbSC7/HgvyxkN67RMkmVgj5PXeCmCzEW2NRCYhpod0D4xA3Qf0BUm0wOn8b5+/+Z/zFPZ/BUGHHM7RZUpUlYoVsdk2Mx2NMMWF+cJUYYf/aw9z8im9jsvUvefidb8H6lrE1TEaGBHRth/cdRWGpxgUhwXKvJSGMJ2MKZ+iamuQ91lnKqsB7ZXfR0gVwJndYGmOwxhxF3xqFQgSfIsQWYwRrwCiMK0NVlURr8W0gxIgtBVuUpLYlhcB4XOVvAVUsyqhwOZ6135uSYv4+QbHSN4NGJYQG0YS1DmsdilIvlqDKaFyROogaiFgwBWIMUaFbNiBQjSwSPGodMXpCiNm17UqwBVFC7ruMeU7HFLOHuLDYogBMdgD7SNSASMJowWiy9RV9hw487Vx6gscf7+83+hvAxSdYdvX40dXfqtqJyJ8D3yUiZ4BXkS/g/VNVvVdELpKFyl/s75WvQqgcGBgYGHhuMQiVz0KOol8+537F0dW1J3JaTv488MyiqiyXS97xjnfwUz/1U3zyk598XoiUAC9+8Yu56aabvur1OOe44YYbuO6663j1q1/ND/3QD/GzP/uz/MEf/AFN0zwJI/3C7O7u8hu/8RvcfffdvPCFLxw+X88eVpGs15N7I5+IN5LFwh9Q1V89+YSIvJ4sVD6VrATNjb67Y2BgYGBgYOB5ishKUiA7z2RV56YYIJ7sq+wFrJNuO5W+r0WyO81IryFlfx0ITAzcOi24c2LZLhJrlWG2NmY8stiUSFj29pZYUQpRtHQkVZwzxAidj2gbcc4SfaBG0KIEEotliw+Jwlg2CgOtZ1watk+N0RToukgUizXCaFJSlBX1suOghf3O0jZNFmVT4uKlQ7wP1I1nOik4f3adug3Uy4ZyNGJ/URNDxLQe10VCgvFahSkcO3tLknFMphNsCFRGOXV2ne3tNSR6wrU5ZukxdUs4jDStEsQwu/l6bv5H/4hzr/lPKU7dgNFw1KV4LB4GVD3EQPItoV3SLfbpFnO6psZ3LSmmLGSm2LsGLSCIq/IB6o+ZyGrdvbDISp+M/YwwvXCZo1RzV6X2RkTtBWiQ3n2ZZ0/qJ0ZceRqBlZNRj9arKYLEfv7YLCBKjuJM0ZN8lwVBZ7GuxLgSY4ocx2qyO8+WI8S4vLl+OxoSmhRbKGItOQZWjjso+xHpUWclRy7QlVKrq55NzeWcqoqmRAz+qKtSxGLE9Y5QAemg3UXKfA2gxgaqNc6+6C4ufMt3MG+uMNvYIulpQvA4I4xHJVVZUZQGa5XJbJOubTjcW3Dpvvdw/d1vYP/Bv0Hv/VPGLgvWqQtYYDYpKaqCpgkczmucK5iulZRW6NoOVaUoC0SVtonUTSS2nqSCNw7nLFVVYgqHbztMjCgRU1msqzisO0z0zKoc2erE0AXovLLslNBFpAhgR9jCYjRRuOyG9cGTQqQoLYUt8MGjMaCpj4K2lpAiLkEKkRgChRWMtWgKBECMxWlAY6RLQogdrioZnzpLxDK/dg1RRVLCGsFgCd6TQgtiUGNQY1GyqzOFAMbkeGrrEMDZgqIoUHHEriEaEAxKpF3U2Gr3K/kaHXj6OfcEj5/v7/c5Puc9/wTLXjix7En+A/DdZCHyVUAD/MWJ5/6piFTA3cBH+xjZgYGBgYHnAYNQ+TSimk88mqahaRratv2sW9d1eO9JKR39vlgsiDFS1zUp5SsDrbU45xiPx4gIs9mMsiwpioKyLBmPx4zHY6bTKZPJBGvtM/3Wnzcsl0s+/vGP80u/9Evcc889z6pC2qeDV73qVZw5c+ZJE/aMMUynU17+8pfzW7/1W7ztbW/jzW9+Mx/72Mfw3j8p23gi3v/+9/N7v/d7/NiP/dgz1pk58A/4S+AVwD/lCwuVt/X3v/d5nvv2J3tQn4e/BF5OPrn6f5+G7Q0MDAwMDAw8S/mshkKR/v/J2keBZlbiFKs4TU6kZ2peySokNPcaZhHIGdguhBdtFNxYKJsVbM5KNrZmaILDgyViHQd1y3RasT4r6NrAYtkxnZZU4wojiq+V6CO1jxhrSSlSLxaYwuJDYlwUOJMorGE2K1mfFaQUcu+eMYgTRrMxVgyHB0sOvOOgCfguMbKGg2XNpSuHHBy2rM9Kbrr5NLNpRYsym5Vsbk7Y31tiQmRjc8rVx/fwqkzOnMKNHTuX94mS+/m65YLNScmpc5ucOjXG7x8S5i2nT1/AbcHFj9zHcpmY3HgdX/ePv5W1c6cI09NUZ6/HjDeg3jkhsPXOv5Qg5cdSt8TXe7SLA9qmJnYtGkPub9TQK4s2Ow9tgZCjYLPI3B+7owjVlZCYehFPgHjs6FSAeCRMr9yX+VXpeBHtI2PFHj9GjoddzRslHj2Tl+3fplk5GoWIIkmyG7XrMNZinMPaCudKNEVi6DBuhCtP9glqFru6hCtKxLlefPqsRspjQyWSJ62mE5+A1QTPgqWoZmFVlSSeKIIxFjGS3YnGImJQ6cAfZldlmCPFjGK2zYtedTf3ffg9JPVUhWVUTahGYwrnMCnSzA9QDinKEQal6TxXH36M8/UVbrz7dVx55EOEZkGK2SlYOsEVhsXCs3+4pCoMa+sVIBzuz1FVphNLiommDSQsuhJGjcEWjmpUURQFvvMQE2j+PJmiIAmMRXEOJlV2MNZdovMQiRijqIHQBYpRYFRNUddhnMtioJIdks4SraPtGlLTYkuDKwussTmSdaV+o2AsKSViihRVRTmaou2S1M9VoUCxvXivVJVDihHO5mMQcCTfAWCtJaqBmF3OhISVLKiHtqUwBleWGBLEDpzNDtH++Kskou9o9z9fQM3As5CXicja54l/fU1//xFVPRSRTwK3isjXqeoDn7Psd/T3f/05j5/sqXwl8D5VbU48918DbwCmDP2UAwMDA88rBqHyKURVOTw85NFHH+Wxxx7j8uXLXLp0iccff5ydnR12d3e5du0au7u77O7usre3x3w+J8b4xVf+OcxmM9bW1tjc3OTMmTOcP3+e66+/nhtvvJELFy5w/vx5rrvuOs6fP89sNsMY88VXOvAl0zQNf/d3f8cf/uEfcs8993D//fc/00N62pnNZtx1113MZk9+muXqjzrf//3fzx133MGb3vQm3vWud1HX9ZO+rRVN0/Drv/7rfM/3fA933XXX4Kp8dvCLwH8H/CsR+feq+rGTT4rIDar6CPDp/qHXAH9w4vnvAX7waRjnvwV+GPg/ROQBVf2sLwQRKYFvVdX3Pg1jGRgYGBgYGHgGMUgv3HAU/3rUX6hpFeh5rOWwEjWzxNObzfoawOOFplZ40YbjxZuOdZtwCuvTkvGkpG4CbRfwUZgvGqbTAmtgd79hVDrObs8YjR0pKcvDlsU8kFQpqoJ5E/BdoCgsRWGZFobJ2GIkd85NR44QEl1SkkI1KpitTWnqlmvzSB0Llp0HVWaV4ep+zSOXDlguGy5ct8U33HqGLngO5oGtjZLYKld29iAkUkxcvnrAYbDst4HQtLBYcLi3QBHWR47Z2LJ9ekYZG5pPH7Bx+jzVWcPuJz/N4X5DdeE6XnjXizh9/Rb+yiM89lf3c/Y/+W+xowqtr2VHJH0Ur5LFRw1ZSPRLYrugmx/S1Uti1xJDyCKmJoh6JDiDIqJZezMWxfSuwqNwU7LL0XMUf9o7CnMsaOpnR+9C7C9qFlktm0hH3aURxPVxqoYsbvZaqEoeu+ROQUR7kTLmraYjP28vJPZxrYCGSIyRiCdYh3U5HlaKQPIOW1a4YgS2/7ORJqJvMSliiwoR17tLjwXIPI68HT0531ePcSzCK3nsKQZEyDG01mV3p/GkXrwk1jkCVhzqD5HRFhvX3cr5Sw/z2EMfR4CyKimrETEG6npO8IkYU+6ErOc0i3260nDtk3/J2rmX4hFi5xmVgrN5fyyWHU3jmVSW8bhEo7KsW0JIlIWl6yKEgBGLqwqSKYgxMS4ctrCINSQfiG2LANblDsvkO6yNrJWKEQvG0CVD7SPee5xRCluQCkfUgE2BZIvsMHUuu1h7N7UpcjekaMLYvL/EWKyxWOcgeITcKxlTQlJgNK4wBtAOsQ5NvWvXVYgT/PIQO5kxXtsgzPdxVnthPeVeSjEkyeNIIaC+RRDK0lFUFiOSHZjWELoOnR8iZejneI6CdUVBMV2j88+PpKmvATaA/4kTVSYi8gqyiLgPvKN/+P8C/hfgzSLyz1VzqLOIbAP/6sQyJ/nrfh2vA84A95x4bhXz+j9+zu8DAwMDA88DBqHyScZ7z4MPPsiHPvQhPvShD/Hggw9y+fJlrly5ciRGppS++Iq+TObzOfP5nIsXL3LvvfcePW6tZXNzk9OnT3PmzBm2t7e5+eabueuuu3jpS1/K7bffzmQyedLH83xBVfnLv/xLfud3foc/+7M/e1qcfs9WbrnlFr7hG77hKRXBrbW87GUv401vehMbGxv8yq/8ylck7H+p3Hvvvfzmb/4md955J2VZPmXbGfjSUNWPiciPAv8n8BER+X3gAXLM6zcDB+QrN38B+AHg/xGR3wUeA14MfC/wO8B/+RSP8z4R+W/IJ2UfFZF/B9xP7rG8iey0vALc8VSOY2BgYGBgYOCZR8xJj2R28KFy1PCXnZW9dCN63GUpkjvheu1pZbVTYMsKLztV8OLtgutOj3FJ2bnWEKzj2oGnbhPlyNE2Hc5AUVpSVAonbK2XWAPLg4auTcznHVGE8ajgcN7hxo7zF9aQmIhtQCS/bjorIELj8/+9pSyoJpaytBzsL6i9Y6ljmtgxqQwaIpeuLXno8QPEKN/0kgtcd+40e7WnaTtOrY2ZH9TMD2qsKGZUskiGJgS8RKZbU2IX0M5TWWFaWE5vVGzMCordPczSs3nd9Rw+fJFLe4fY06d5wfd+G6dvOs3ikU/w6J/+FfPLC0Yv/ses3XQLxvYOv97NmB2L4bib0jeE9hBfH9I2de6l9F2ORe1jSuWEGJdXsjomfUxvbunLsa0aV0WMvYFTT4iSsT/u+ffjmdHHpOpxjKoeuRJ7AVQjkPqfjxJnQc3RCFbiYR8O3PdInlxXOuGENCCRFAMpWYKvMbbJMbB+RCo6bFnlSFjrsrAYAqqaxUrjehdwP5DUO4hFjxylIv07U3rx6tgJuoqwTTESvcfYJotvzmCsQ1NAxKJhidgCQgPlDDPZ5uwtd/LIgw+gpeb40dRhxRJ8ICXFGsEVFhdGCPsYMRw+8gDh8jXCcoklURhBsTSt4iNMJiOq0tA0Hl83uMJQjQpiVFJMuKrEOIdKjkA1KogkUEO3aPHNEpC8nLX4kEX7wuXPfIxZHPZRSQgq0veFJpzJYqAzliTZrYxAYQ3WVEdOYNM1TCThJhOcKxGjGONQjaTQ5aBVVYIqo0IYlSUpRRBLso7UtH30dD9fjcE5ixQV0QpJhOQ7VLJQac2RVRaNnhgaRATnKsqixNoCJCGpw9iSfMqTj3XyESRgXIk1BnHDBfPPEd4D/KCIfCs5lvUC+RzaAD9yot7kfyenHb0O+BsR+UNgAvwXwFngZ1X1z0+uWFWjiPzH/jVwwjWpqp/pXZovJOdlv/upeXsDAwMDA89GBqHyK2QV45pSYrlc8pGPfIQ//uM/5t3vfjef+cxnjoTDZ1q0ijGys7PDzs7OkcuvKAomkwmz2Yzt7W1e9rKXcffdd/PqV7+aW265BWPMkYNtcJF9Nqvj3rYtH/jAB/jFX/xF3vve97Kzs0PXdc/08J5Rbr31Vm6//fanfDsiwgte8ALe9KY3MRqN+IVf+IWnRPyHfLzf+ta38qM/+qO84AUveEq2MfDloapvFZG/B36S7Jj8z4CrwN8Cv9wv87ci8h3A/wz8M/K/dX8D/OfknsunVKjsx/B/i8jfAP+SLJ6+FliQRdPfBX77qR7DwMDAwMDAwDNPTgFVjJJ7+lSPWgdVVo9x5JUT6AVKwRiD6Z11BpCkXKiEu7YKXnSu5PoLU8bAxSstYVSxXjl2FktqH4kpsr1ecub0mHZRU41LZiNL03R0LfgucW1vyWw2QWMidIHtM2O2z44pxXCw17BoYTQqWN8YgULd5q476xzjWYUVw8FBTRMK1BqKQlibVBxeO+TTj+1yWEfOnar4uheeQ63l4t6ccWmYVSMev7iLlcTIWHYXgTS2+LYlqWU0HRG6QN0GNkawNi3ZnJRUXQePHmCCwYfEQ9c+iZlOOfstL+f6F38d6eAij/7pv+PwsX1ikwjllOvuegVuus7xnz5WvZEJ0dy9SAxobIndkq6e4+sFoetIMTspRXvhkeNVyEr4k9zZmN2Q+cnsctQjYemoonQlVKI5+nSVAtyLjjn+tXdWauxfIYixWeBbCZj99lPqhVe1WSqUHKmahUsBSb0onoW81Edw5vN8jiJoc4xr7xoViKlDY3YGhrLG+VG+VRNMOc7vN0JMS2wxQlzRi7fHoupKidSVun5CjD/KuF0JsKmPto0R6z3Rtoi1iO2yW9VE0ACae0Fp58hog8m5F3D+pq9n7+onMKbAiMGVI2wxJoYl1hmKsqAoC2KKQEuUMYsrVxkVYF1B1EAXEhFlMnKAsqwbvFdKJ5RV/lSa0uYoXFk5QYHUISmhqaT2Hr9cgiRsURL741iWRf+WlRATbWdou44EOOtIQo5fNRacRRSib/Jn3zmMkRzHa/pjHBMmBRCDUcVaxRqT92uCaGx2NTrDdFRRuSysp95tK8bm6N6kWAPWgBiHtjUpBMTaIzE1HyJDlHzhQfRzTPIURYUpK6xRrIAtS6IPhKZGTIcbr1GMR4iBtl6SYgMyomsbgg9f2RfpwNPNp8hJRv9bf1+RnZA/rar/frWQqnYi8t3AG4H/CvjvgUA+9/5xVX3bE6z/T8lC5QHwoc/z3AuBD6vqkBU8MDAw8DxiECq/BFQV7z1d19E0DXVds7+/z1/8xV/wR3/0R/z5n/85Ozs7pJT6folnN9579vf32d/f59FHH+Vv//Zv+bVf+zWcc9x88828+tWv5u677+ZbvuVb2NzcZDabMZ1OsdY+L4VLVaXrOg4PD7l8+TLvete7+O3f/m3+/u//Hu/9c+KYP9WMx2O++Zu/mc3Nzadtm1tbW/zMz/wMs9mMt7zlLSyXy6dkO/v7+3z4wx8ehMpnEar6fuCff5Fl3gd85xM8/Q++yFT1NV9gXf8C+BdP8Ny/Bv71Ezz3d0/0ui9n+wMDAwMDAwPPXXJUqDmZ7MqqnXJlhpNVMWG/vBGwJotJqGBRTpWGF44Lvn7dcMvZCbfcvElcLLl0taWmYHMkdIsloWnYHBdsTkpKm9C6ZmO9JHWJxy/WeWuSYyensykxRKIIp7crzp2ZEbvI3n5DiInpesXmxpS2bWiaREiKGznGa1MSjv3dOV1yuLJguj6GGLh6cZdPPrRHp8qL7jjHxtixM28o1sZcf36b3auHPPTw4zRNYjIZs9N0dFEYGcNkc4MQAgd7C1LrWS+U67cmTFIkXT2AZSQlYekj0cDGC27khpfegWPJ4+/9Y5qrC/zCE7uUReDNM2zd+WJMMTqRNyp9n2M8dj2miPqW0PQiZdtl12CKOao15vhXMa6X3rLQZlZ9o6toV+0l6JVId1QguVom9iJXvmWrrB6LkL23UqMnqc+Rs6YAJ0eTRWPfZ3nkvowry212Nq5ESkz/mtgvb/sdkI6clkdjk9THtyY0CSKRlHpBvWlyBG7RENuOYtxiqwnGlahC8C2GiHFVP5uzEKqriNmVBnscAns075Om/vfcq6hEYvCIz92MJrSodRANRkzfDerQ0CC6hrgxF265Fb94DHHKZH2LFAPT9S1EDFY91lZAZGNjA7Gwdup65o99mKp0RK80XSIGpSwgidLUEaIyKgxlmf/+kcRQlCN8UELoMEYgJDQlkiYa3+GTRSgwRDTlz6xoQpwgxtF2kdYb6qDUnWJJGKtZ5DUW6yqSJnzbIrGjKkuEkOcmghQ5itcnSGrQFIhdS7IJV42wrgQV2haSMUxHltLlaWBsgbUjfNdCihjJjlshC5CuNJByVK1UJWFZg3VHPl5QmuUcYsN4NKGoKorRGqJhdckFUo7QJkJssCZSTtdIyTMuxqTQgXNIMUbDU1fdMvDVo6qf5rPPlV/3BIuefE0D/K/97Uvdzr8B/s0TPPcjwI98gde+5kvdzsDAwMDAc4vnrVC5csU1TXMkPq5+Xj3eti11XR8JVI8//jgPPvgg999/P5/4xCdomuaLb+g5wOqqza7reOCBB3jggQf4lV/5FcbjMd/4jd/IN33TN/GSl7yEW2+9lQsXLnDu3Dm2t7cpiuKZHvpTymKx4OGHH+ZTn/oUH/3oR3nf+97Hu9/9bq5du/ZMD+1Zx8bGBq985SufViFbRJjNZvzET/wETdPwy7/8y8zn8yd9O9PplJe85CVP+noHBgYGBgYGBga+9lESotL3F56UuXp3nazEzGOH2eqVKEyscvt6yR1rBVtW2d4ouPGGdcLBnEcfr9mtE0FbJlsVJkY2ZwUbaxVVZfEhMFsfZ9djJ3g1NLWnrByzSYGqUs0cp7dGrI0di8OW/f0OZ4W19Ypx6Wi7QBuhS4nx2pjCGQ7nDbW3oJaicqzNHGG54KGH99g/6JhsjHjZbWfRtuHSpT2mGzPWRhVXHr3GtSt7iDq0gKtznyNpS0NXt7TLBg2RdauYStk+PWWtafGXDqGDZVCSCG7iOH/n17F2aszu336E+vI+sQ+38V2EXijbuP3FlKc2s1tt1fF5VArKkeNRUWJY4us5vq4JvssuP83RlyQQsqtReufgqnOylxb7bsYsHKrq8TaO/uaf+uPfb/G40JJVDGzWDCPqG1JKmKJCsLlTcCWa9tK2HBVP5ujWPAZzoiuyFwE1ZXFv5bSklzmP+ixjFtJTPr/KkbG9M5Pc56lRCKkmBk/olrjRkmI8w1XT/M66PMeNG4FZia8rCX7lqMzry+bKXLq62ns5DjYLuzEK4tssVLoiC6LiUBMRidkCiIKfI9U6k+3rmcxOs39wia44wBaO2foM1URXz7FWMG5MOTKISXTLOaa+Suc9wec41KKE5GtCzNqwoTgAACAASURBVC7HojRoioSkGDGIdSQsKoqxBRpaVCzRWJaLltZ3VNOKYuSIbZaBreS957tEEs+yTXQefMydj1GFGDxVUSKuQKxBfMJqxBhIMRJixBihKF3u8IyJ6D2WiCsMYgTnCqwxGGNoArQhMKuEwkJMETUlNkUw9shZa6wjJp+Fy6M5qkhMaKWozfOrKHNPZjM/wBKZnTqNEZPncfTYou/FlAJXjfLFAd5gXYGRhBvNoBjRzue082vYpNgh+nVgYGBgYGDgCfiaFyoXiwUXL178rNvVq1c5ODigrmuWyyXL5ZLFYsFyuaSu68+6LRYLFovFUxYt+Wymrms++MEP8sEPfhAR4cyZM9x4443ceOON3HLLLdx2223ccccd3HbbbVy4cOE53+HXdR0PPvgg9913H/fddx+f+MQnuP/++7n//vu5cuXK83IOfKmcPn2al770pc/Its+ePcsb3/hG9vb2+M3f/M0nPW75u7/7u7npppue1HUODAwMDAwMDAw8P8gazXG/5MqhJBhEE6YXLnNz35G/DFHl+rHh5dsjbl4rKDRi1TIaTdh5fJ+dazU7h1nIOL1m2CjhsA2srY+xRvAIZVWws1MTRUheaRrP+nrBpLR4EcpxxdntMVp7Lj42p0vKuCjY3KwQlL2DGo/BjQqq6QjBsrfXsegUV1oKp5TOcHBtyWceusphrZw9v8YN56csd3bpvGdzNubaQc3VvQWpizmlB0tqWsAwHldo9JiUKExiY6Kc2powGxU0n75C2O3wHXRJMaVlPB0zmRa0jzzE8uMNoY3EpCszX97DCWI5YuNFd1KMxqhYROVYrOz3b9IsMK5iTn1d47sO9RGNAdUAKeTDtxLIJB+tVVCvrNJ1RI8FSu2jQWUV17qKhZWjZVaStapCUpQAoc3uMyziKtRYVBPa94IquXrG9L2GR1UtmsD0AiWm7zo1pJV30dDfr1yWpn+dgEloMr2gmEVNjB4JlhCz804FevEs+o7Q1BTjmmq2DkVF9B2iihRFjjM+ipNdjetzPxXHvZ5HHuOU0L4vM3qPLTpSDBgbQHM/pqzidv0Sqg1kfJqt615A0xyQErTLlsnY4Jyj3NhC1GOMRdXQtgtY7BP3djGtxxqLs9m46pPBFkJVGBKC91COKlw5xnvfd1RGNEYQR0hC0wVUhPF4ROGyGF6Myzy3YiTG/GnuIrRt7uCMKV+Q4ApH4SaYoiBpfr8Giy0smgwpap4jkr8fogpdl+Nlx4VSVRXFuMJYh4/gYySqMikNzmRRU40DtYQQMUXAlhUYg8GQpCB2e1ijBI1ZKyYxWd+kmm4xv3oJfMtofQs/j4xGI1xREboWI4qRVdeo4KxgnCXJBBWDJiXUC0prEbOG2hIfEpqWlJPRV/V9OjAwMDAwMPC1y9eEUHkyetN7z1/91V/xvve9jw996ENHfZErQXK5XNI0zTPeHflcQ1W5fPkyly9f5sMf/jDGGGazGZubm6yvr7O9vc3Xf/3XH7kv77jjDra2tp7QYfd0OO++UCSrqvLYY4/xsY99jHvvvffoduXKFfb29tjb26Ouh1iSLwUR4WUvexlbW1vP2BhuvPFGfvqnf5qPfexjfPCDH3zS1ru+vs4P//APP+dF+IGBgYGBgYGBgWeGY7fkkfeuj13UI5Eyh2QKpnfBjazy9WsV3zA1bFeGsRHUQwyRxx7d7Z1dQoqeC6enXH92gsTI2XPrxCRc2fMURUJ8YOv0BGcdD+/vsX12jdJZHr14yGzqWJsZ9i7NOTjoKCvL+nrBxqTi8LCmyYmo2AqKqsC3gd29moDDFiUheArruHJpj2vXWg4aZXO95PxWwf7ju/gIo8qyv9ewc9gyctlFJn3NYDUqKQtHfVBTOuXUWsmkKliblozblvreK8Sl0qpBS8OoKqjGDiuQljV+0eXE1D4dCJFe3Ml7Wde32Lz5ZsRWvVPwhJVS6eNWU3bH+QW+PcS3DTF0pBSOBEREcg1kLwyuXJXSx6/mqNccoapp1b14ZHfkyH15ol/ySLLWlMU5TTkSM2bhyxQjVGyO/QwhP3/kAk1Hc+goOFXz7xjTh6v2crf0/ZYpghg0SXZdGpPFWxGImoVMMdlZqdkdqRxHD2fBrB9vLwjHriOFfUJXM5puYsczgiaMxhy1a/o5L0DfpbmKfT2Og6UXMumVeu1drJEUO5J3aNGCLVETMSaiao6Ppa+RcsJ0+wbcp+4ldHPK0TpJhaIoaet9RlWR//7TLBmvbbI83EG7LotoAp2PpBSoRlV2QYZAIFGUFbacZN1XEnGZ/4ZkrCUZR0j52BUud0lGFE1gTRYKU0xoijmmNWYno4qjkIgYwAjafw+gCt6jTsi1qHmeOEmIsb3A6Ij1EqLHjkqKwmJRumZBoMCWFVPTUUwMkRIfBIwQNYEajBGMc1mIRqnKElc5SFlQTTEiJo/ThpbJaERsFsTFAZMqi+a+qUkhYkvXi+QWYkI0YASqtRmhK+kOdqCPOS5wGHG40RhLwprnX5XQwMDAwMDAwJfGc16ojDFyeHjIAw88wNve9jZ+//d/n8cff7y/6i0OLriniJQSBwcHHBwcHD323ve+F2stzjmcc5w7d47bb7+dO++8kzvuuINbb72VG2+8kdlshnMOYwzW2lwU39+OrgqFz/r5pOi4OhlV1aNe0NXPKaWj4x5jZLlc8thjj/GZz3yGBx98kE9+8pN86lOf4hOf+AT7+/tHRfFHhfEDXzYiwvd+7/c+4/2lN9xwA29961t59atfzeHh4Ve9PmMMr3/96/nWb/3WZ/y9DQwMDAwMDAwMPDfJRroT8ZfSd/et0N5h2Ws6WyV808aI6wvNHXtiSU2H7wIRsBa2N8a0dcf6qZIbzk4gRsrZlMMm8MiVJU3jObMxYlSUVOOSRy4eYMqCLiiX9pb4lJjExKWLBxjnGJeWzVMTZmsVe1cPOVhCksh0fcx4MqKtPXsHnlRWGGuweAoHly/u0rXC7rxla6PkzNTx2EP7zNuYhRJJlOMRFksMicn6FDetOKwjy4OaOK8xKXJ6fcKpUxO21if4z1xm/tAuoRMaEcppyXR7A+eymBOXHb6NxJjPD2NSxAoprGJVhahKdf31TLZPodb0bsbeCaknxERVSJ7oW2Lb5s4/H9CY+jTS4+NmTojNqxhTQRCNoJBi6I9vHzO7Ei+198tqVviyczCLfpJyD2aKHiGhZgTW9MJlR4q+F61yLOpKb139vOqq1L7rMfUiZhZSQawFcWgfK5x/F9Q4RCxqTBabFESUJApGkJjFzCQgkvdf1myzM1WlF3ljIjWe6DvKdkm1tgVUqNKLa0UW4qSPtj2WJ098QPrj0MfUEnMscgqeGAM2eEwRQBNJI6Iuu1jFgG+Q6SnceIvZ1jmuXllgY6Ioi1zROZ6SfEsMHWIcgsVffYT1UYEl0TTZKVk5Q+kMIWRB2Gjevl8ssqiYFFLsXapC9HmfazL4lHBGwVoSkdB5oslu1aSGkBIpKRr7bkgjuMLiVdCYEKs4Y0jWkUQIUfFdoDSaBUHjSEmxsaFSjxkVjEYOI4blYkEUYW1zCxNrUlcj5QjjyvwNYwSxlpiyiG9MAvJ8s0VBORoBls6HI3d39IGiiJSjKfVygeIRV6LR44yFssBag3UON6oIPuZ1hxahYnr6LKil3b2ItgcU0VNNNihLhxjTz8WBgYGBgYGBgX/Ic1ao9N7z0EMP8YEPfIBf/dVf5T3veQ9t237xFw48ZazEvq7LBSEHBwc88MADvOtd7/qs5ba2tjh37hznzp3j9OnTbG1tsb6+zsbGBhsbGxRFgbWW0WiEMfkkfiU4e+/pug7vPfP5nPl8fhTPe3BwwN7eHjs7O1y7do2dnR0Wi8XTuxOeh4zHY77927/9mR4GIsIdd9zBG97wBt785jd/QUftl7KuV7ziFfzgD/4gp06dehJHOTAwMDAwMDAw8Pyjd6dhMIBqju7UnLeIojjghTPHN22UbBKZVY6uTejSk0rYPj9hNik43FlysL+kKi2nNie0bUDKiiYUXNyrqX1kOimpKkNSw86i48zpGQc7S/YPW0rnwARCMhgrzEaG9c0xGOHy1QVtMGhhWNuYUY0LlntL9mqlnE4RTYyKLAoeHjQcLCPLOuCMIqpcutbSxETwAmWFFpa67ZjayNhYlnWLEbi2v6RtlI2RcHp9xk23nWOrEq79f59keamj7hQmFZOtdQpRpGvpdhckH3uHnyHpccVjSlmwSwqalGgNZ26+BTMaI/K5nXh61CWJJkgxi1ldS/SBFLJ4KNr3Pn6WOJlYNS9q3zsKkFLs3ZJ9BKueeI2uIjJTv14DGiG1pOD7KFED1iG9QJdiJKV4JHYCiJqsm5ocOau9izKPwfYOSttH0fbRtEmA0E/B0Dsqc0ehShYp1brsthSHWIukLLjlWWuyKGlWFxD3LkDtncASIQlRPc18n9AsGW1sUky2smO4XDlZjztaReR49/SC7ioSOcfP5j5OTQaNnhQ6NLSYooKUEJPFyhxr2iu2xZTZ9hn2r36ahJI0MBnNcDHSJAVp6dol2h1QNfv4puWg7rAmMR6ViAR8vUScZTyb4EPA121222pCrOs/w6sLqhVRizUJXJETdK2QfCKG1LudFZ8SqZ8WGNAoJI1ossToKZ3BpIgP6Wh/FKIgiaossc4SY0fXzLEijKoSVxSELrBoa0Ib2NwYU0mkaRtiEJJzOFMgps39nrYghkRKWYwUY1ERYuez/motqFA5izFCSr2zsjA5ljYqEiIpBFxlcVWZL1YwgqinnE4wxiJojk+2+2ACPkJqG5IGnCmxVZVFePOc/RPkwMDAwMDAwFPMc+5/CavIzne+8528/e1v5z3vec+RMDbw3GB3d5fd3V3uu+++Z3ooA08CL3nJSzh//vwzPQwAiqLg+77v+7jnnnt45JFHvuL1bG9v8+M//uPPWO/mwMDAwMDAwMDA1xK6qqnsO+dWEaCZqYNvmFhefrpgzUQ2ZyUjK+ztGw4XAaqCaemoDxqCT2zMRhQFVLMR47UZu03i6tUF7aLhxjNTzp6e0dUt3hk2xoaD3SVNUWJGBq0b1qYFReUYGWVtOmLZCa1MWL/xOpY7j2L8kqJ07O401NFRThxd2xz1SSYZsbtc0sZINXK0UVmaivEI2oOaamuGHZX4+YJT6yXiDYfzlslsjXIywR10IB2Tacltd16gapZc+eDDNLuB2iuhKlk/u8VkfYy/fA2/aIhN7NN0IGnInYmSU0WjxiwWkR1byRgmFy5g7efWN6zEtpUImbsoY6gJXUPwLZoC2Xm5Mvul3sWoWaDC5jVJ6gXPXi0VATWorgJ9VxqjOY6nVdDYobGF0KEiiDF5meizbtq7J1f9f/QRrrnjNIt4qW4IzRJjbBbvEJKPvUAWEWezMASg+XdTloizCI4UWsRodlTGAjUO4wpUHWoEjEOS9nGt+T3lAcR+FxpEVi5Pg5DVuOAj9d4Osa0p10/jSLhyQs6WXfV0ZuG2b/w8/nyQELVZDtaExEgM2VGZYoeJAbEBtMgicy+mEiOUE6r1bQo3ptVIvZxTjcY4V1JOBB88rpxy+OkHiXvXmO8tsSly6tQUMQ7vI6W1lKMCNJJCh4hinQONBAyxCyAG6wrEJKIPfXwrhJRo64YUElZAo8tCc1odd8Vg6DQRQsSKzTG4IRE04GOEGHHO4CQnVFVlibOWrl0iYnBlQVVZgsLussUUjvWRo8TjF/vZ2Whddsam3MvpnCMJOMmataaUk3+tJQExKKFrKaygrsSIw7qS5DuS77IDtChIPrsqTVlinSGpEFOCBCNJuPEYO14nhYiva0JTZ/emVawovj0AZkjMEb4DAwMDAwMDA5+P55RQqar8yZ/8CT/3cz/HBz7wAfb29p7pIQ0MPO957Wtf+6yJRhURbr75Zr7t276Ne+655ytahzGGN7zhDbzuda/DWvskj3BgYGBgYGBgYOD5xKo1cSWSHcszikU5XxnuWiu5eSScrmB9XDFySlN7QoqcPjPGamJ+sGBjNmV52MEYLnzdecrxmL3aMN+9hvE1t54dc2Z7SkjK43XLTbde4PJjO8wZ46bQ7RwQvWe2MWJSGEaF4SAY4topWJux3xwyrzu2nGXvsCNVY6hbmuUSg0II1F3koUuXOFhGJqOStglo4SgMJBXK9U2CKt2VPSqrLBpFg1JHpVvUxPmCUpUL59c5f6pi+cAjHF48JHQw7xJmOmLj1IxRKejhHG0bYvDEXqRc1TymXvhLmn8W6fv4BNx0ncnZbYwtspevV4mPY1856kZUza696FuIHlm5I1kZ9uTI1ZiPWjoS3FIeSC+c9XGkGvq02Nxgucp6lRRJviF1Td9zacBYVCNJPaJCu1xiyxGIIYaOsKjREDEoyXdgDckHunkHURGzmlWCrsapub80K4GSBVYjuNLiZqPcpxgDRqGoSqQqkKJCixLjHFgHJnciSt9lieYo2GwKFpRcNCoqYI9dn/Qdj81iQfCByeYpRMFWUwCMmqNPg64clJ9FWu3k3FMZAjF4bAho7ECrE32ZfcStb9ByjB1tUE42CPUuthoh1hFU6Jo5vmsYjTZoLj+GWbTMSmVclRQWuramLA2j2YgQE13dgiquLDDWkXxCfQDVvg9UMTFhnSWJ0sYAEWwMGAyCJcV8zIw1aMgibEoRgs8XKsRIUiWRMKnI8wElhoCRhDGG2LVI4SgKw2hSYYuSpq6pg6caV0ytYWQTmpQueCK5A5TUO1LFEmJEXBZ2VRUJiagtXQJjSqwIVmOOIg4OH1qss1TTGWorQnMFa6CYraGaI3VtWaFdCySMcYRmibWCjKaItRgRnFVSYTBlnm8JQ9cGxMdVZvHAwMDAwMDAwD/gOSFUqiqLxYKf//mf5y1veQtXr179qmIdBwYGnhyMMXzXd33Xs0aohOyG/M7v/E7e+c53Mp/Pv+zX33XXXfzkT/4kk8nkKRjdwMDAwMDAwMDA84te0Dly2WXBbWKEO9ccL1pzTFKklMjIFJgYmS8DXYRTp9Yx6omt4lvl0vKAjTPr3Pbi65HQ8diVQxrfUdYHvPCmDTa3ZjReuba35Nbbr8c3kc6NGeuS9uoh9SIwHZX4NpCMcHUZaaqKtvDMNh1nt9cpi5LdBz/NqBrhUov6FkmR0XTMYtHw8KOHNF1iOqnAB0KC0Hr8pGJUVsRFze5+Q0nehrMWKSyjzSlRExMT2VyfcHqtIj70OOFaTfRCCxTTEbNTa7jSEPcPCLUn9D2CSfs+RsidfyKr1klWjlUjBkWwkw1GG6eOY03hSBJbOSVzRaWiMZB8R/Q+d0JqyDGrJJBVbmcvUiE5vFdj31+56rzsj6/0cb5Jj2NNY8ziZbskdTW+7XBlmQWklJcJi4Zm94Bu3mAKC8YQm5bYpn49KbsnJe+DGLUXt8xR76OsfJxJENO7PwXESC98eZq6wxqbxUyBzgq2sNjSYSqHm0z+f/beLda2LK3v+31jjHlZl305e59bVZ2uqu6qprkYVwApiRvJIlLbKDiGIIc4GOOn5AWJBx7wgy0hIfVDHiIjvyBbUfxgv7iFEIKEJKZFYkWNwdAYA0433V2u+zl1rvu2bnPOMcb35WHMvasttS9EHOp0ef5arXP22fusNdecay+dWr/9//9xsxlSR6gazOpS++pGATZWnkIuiVbclVssXwO48vyO3Zb1SWIWe9r9m7hmUc7n5dm6rG0dU6flSuooPR2mRe7lnNCcMU2IZtCMOR3PN5hGkCXOz1geHHBx9h71bIZzjjREhr6Ix261wZ/dZ1klmqYmq6JxoNmb07Qz4pDQlDEVnBuvnSkpZ8wghHKsmoYiqM3I43inIHhfk7MSYyzX35V63myg2SCVquGqqjEcg2ayelxMtHWR1lK6i9GckCB4H6iaBlfP2Ox6Vpuexd6cRVvjcw84FE+KO5z3+KpGfIVzgjlHigNkHauEDVNDh0gC6sqQqqbyrhxrVoSMeMhDhwSjqitCXSFSoXkY08Y19WKJaqKqKuJmS79elyrpECgCsyLUc5wzzFeQyrnVmBCnf/IvsRMTExMTExMfCZ55UamqvPHGG/zsz/4sv/ALvzDtUE5MPEN88pOf5MUXX/ywD+PfwDnHpz/9aV577TV+4zd+44/1dxeLBZ/97GdZLpdP6egmJiYmJiYmJib+Y8OEUVYWSXOjgv9kP/DKwrNwkNVzsN/iY+R8VbbjfKg5OemYz4Vum9kl44WXb/Bn/9NPkDcX/OEfPeTB6Y7nrrW8dPOA49vXOT25IIrxyief4/TBOQ8fr1i4Usea1VjOAnUQ1GDVJ8JiATGyWXW0R5HNxZa0WVG3NdbvyhadGuI8ndWcn57QeEe7DPRDZj1kxFfsXz+iaoVhGDi4ccBFNLYXicWyJjQV2XtiHKgrx/Fhy5zM7ivvEtaRpEJyjlBVNEGg3zFcJMhGGhK5uClMxoVIKSk+GxOWAM55smlJWQrkuqLa20fmtyDvECt1rvBBVamRQUtST2NEY8SyjiLZLj0YZQ9Sx/bVUY2ajbKtCLOSoLwUmFyl5kwHdLch91ssRlwIVCEwrHbsTh9Qz2pSVPpVR+oziIdtBEYZaw41I8eMqwS7lE2jllQr+5NOuNqQlLGWlcviWCc4VxJ7zjnUZ5wDdYIz0JzQwZBdJK57fHWO1IFqucQv93DVHPNFgIn3oCDiudzsBB2l3GU9rEPIgJBjz+78lJwz88ObhNkeZqUu9euTrpdJUNN/cwvUNENOWE6j8M0fXMfx8ZkmxDJa1bRHd1g8eGuUa4KZ4L0nuZrVvbdY5g1t5Ugxk3JicbCgWczo+0gcUhGROQMVMWayDgTvqCpfhLcZppBNSVYSjErZsDSFmHs0l/OhaqRs5KSIJoIITsqWo688ph4XI358SqsWgS5AVXmaWaCdN4jzbIaB7a5jNq/Zm1WIZrKWa65VjaSSoq1qX1Km41nKMePC+DxSGPqhCG43Sm3v8aEi64BYxgXHaGEJdUuOEYeWmuCsaEqIDdSzOVlb0voUIZfa2e0F1axFfItaJqeMSsK7UES7d2guSdmJiYmJiYmJiW/EMy0qzYwvf/nL/MzP/Ay/8iu/Qkrpwz6kiYmJr+O1115jsVg8U4lKKAL1h37oh/j93//9/+BUZdM0/OiP/ih/7s/9uWfu8UxMTExMTExMTHxz4txlxajSYnxiLrx2UPHczFOJUgXH8c0DwtDzzjsbQlWBV9Qr85nneL9hU3mOD2d8z3/+Kv35KV/+w7u8+XDLq3f2ee54Qds2vPneY5YHLcfXljx+7zGPnqyYAY8ebUkiXD+aEQzWQyabMd+bIU5xCKvtlu79+/g2MMsR2W5pgid3A5s+s91FsBWLgwWhGpDZgni2JojDty1IJEfH3vVjzlanbPpI5Ry+DiTvccDBuKdXbTryw3OqnTIYpBCogqMOxdMVI2mkmEhZS32pQM5KBrxz42yjXFWsFkHpRu8lZB8IVYWLay6TjgVDpKS+rhKumskpojmNO5FfJ8/KF+BGCXhV6wpX24M2JjNFxypTy2WHctjRn54QN1tC09Kvd8TtgHNG3BUpNlwMpAw5jwJSE6pc1dQaRjYhZyBmnBQBhhurb3GYZATISalrP+5oljSgcw5RvUpXhvHdHyfgneArwXtHloQPUqpBB3BdJG16wsUKP6sJe4f42RKp5qgLpXJWysqkAaLywXblKHIRh5iQLdKtziEbs+PLGtgiNS9Pc8mjyljpWr5f1KzU5aqiGkfxO6Zbzcp5tlzqduOAuIpq74AqNFR1A+JwXghVSzd05PPH1LUjao1Zop01+Dqw3ezIyRhSwnK51prK3uZlFa4ThxNDzIE3HBXeSmLSuQpLCfKA9x7nKyCXa5a07DxKkao+BELlwYPljHNKjkpKCefB+4qq8lRNRTNr8VVg22e6zZpl5VjMAuRIioaaYjkjPhDmS5wN+PG85Zwwl8f90yIvnVO8r0lxR+UEh6Kpw5zgNCHek7KiacesqjAzQqgQF/E2gBey+bITGyM+eNLQY27cWdVyfULb0HU9cbtCpKRRJQRwAde0aHqm34KcmJiYmJiY+BB5pv+V8Pbbb/NTP/VT/Pqv/zqqT6ci4vDwkL7v2e12T+X2JyY+ylyKymeNEAJ/42/8DX7jN36DX/7lX/73fv3169f5a3/tr/GTP/mTHBwc/Ckc4cTExMTExMTExH8MCCBm7HnlzyxqPjUXDlvHohHOzxNb55D7pyzaQAjC3n5gtgi0+y1x27Pedrzy3S9z7WjB+tF9zp/sWO8yzx0vef7mAXXwfO3NR+wfL1jMGu69/Yi+H9hvPA8f9+wILFsHKXPRJbKrOLh1xHIhaD8wrJX9ZUvb1Fi/wbJCgserHVVbcbGJnJ53HL9wnfb2Md3piidP1mx74/r1I87Pzrh++w57+zMePnjIapWoRVi0oaSx4o55U9OitCr4R+f4wRhMCAdLGlG0H3BVhVgmDYmUSgWoiaDZyg6llLOZsl71uIpcyq0i367GYdqA84amHc63gPug79VVkJXyVohgquRY6l8tj2kv+6Cml3H3UrhMKXoMHaVZ+VUuBaVGiD1pdU5/vipJ1POO7ZMTQlURaiEJWC4CMiUjp1LlmrORkpZNSAEVQ/N42wLiBbSkYTW6UqFphnMecYA3ooKIjj906SAJauVjLzCo4hGCg+wMrw7vM8GX8+x8uS3nwHkjdR1h05PXO6q9GX7/EDc7KrW1bqyF1cs9zPEUOwURZEyhlnpdo9tcAMrs6Cah3f+gixe7kpMfyGPKjakUeZsjqj1eE6aGeLscugRLkDaIVJB6YrelthbTCjGlXRzw+OE56eF7aA2uCVSzGjPYbkt6OQvEbDjKeUg5Ic4joSJnZVCjbSskCOIdznm0L6lPnxVzmRwcksdUqSqVK8nIlBPqAOfwwWGa0VQ2SVMyhiFRV56mIx/glwAAIABJREFUqanqQF0JoZ2hGNs+k5Ky1zraIGTNpCzkrKiU9GcrhqsrcswMqeyrGlx931jOZQtVFfGCy2VJ04lAHrAEvqowF7is4E1RsfU5VfCgmawZdTV4DzhytwM3YL6kRI0i0HNU2K3QodQoI4akodQse4c4h4r/E3x1nZiYmJiYmPgo8UyKSjPj8ePH/ORP/uRTk5SX23p/+2//be7du8eP/diPPTUZOjHxUWQ+n/PJT36Spmk+7EP5hty6dYuf+7mf4+TkhC984QsAvPLKK/z0T/80r732GqvVivv37zObzfjUpz7FnTt3ODg4mNKUExMTExMTExMTf2JUZjxfwauN53alNOJJauwGw8Sz3UUWbUtWuHF7yXK/Yr6oGXaRVHn+7Kc/yXIvsDo5QxVWqy3zRcWt547IBm/fu6AHAsL7bz0mBKPxjncfbFjtlOPDFm/Kujekatg/WHB8PMPiwKOtovWMRV2xXZ0zE09MidNuoJrPON30PLzouHnnBscv3OZkt+GiS6x6pR8S95+s+NirLxF8ZnNxSh4iebPjuFKW84Y6OIIPBFNmziH3zvHRGADahipAXnU452CIpFQShXmsvrU+juWiCs4V+eXdVZqxuEvBzMimOFypFR2rPwvjFuL4tfgaNIHkcWMyo7kv6TTnIZfqVYHRmI23wbhUaQY6ikpLRSTqQFqfE88uGNZbqkVLf97TrTqqytHOm7Ee1dBBGaIyREMVYtKrfKeJx7RIWZGyHZhVSyXpUNKlCmRNY2WooCScuCtL67yUFJ8r1aQyfs6cQzCyFEnq1XCqSITgBe8FVxnBG04El4vgTCpoGki7SL3ZUR3s4OAaUu8joR5rXD0mCZGAqRRxCkXoyrjfqYluc4GJMb8mJVnpLqXV170PM6ZUy0FnTANmaTzveUxS6njtFdGhXE+3j3iPDzUBCHv77DYDOW1h19EOWySuaY6OsMqjScAZue9RSnowJiOnAXEOw5NSRHV87jgpScfQjrWpsSRocypVuKJ4X6x5GhIiYxrYRnHrPDkru36gVxm3K7UkhL0DEUIdCG1DUqPPAs6xNw/4lMvG43hNXN2WxKy48pw1IyXQ1ONDjSD0/Q4XGrIZTjzeCZV3V0lYEUotK5BzxuEJdQMiOCdUvkJ0IMZYzncdCHWLd0aoK1yzJGePxU1JtQqYCMOuI8ehxHcVUhw3N72gZgx5qn6dmJiYmJiY+MY8k6Jys9nw2c9+ls9//vNPTR5+13d9Fz/3cz/Ht33bt9F1HSEEhmF4Kvc1MfFR5MUXX+TOnTvPtNh7+eWX+aVf+iU+97nPkVLir/yVv8Lt27fLmyGMlU1c/jT2s/s4JiYmJiYmJiYmvjn5jhm82AiHXtibBWrL7LVF0Pga2sojlqiqhqPrLfOZZ70eaPaXPPfcMSFk1icrdDAe3D3B2gV3Xjik32x59/1TqgyVwqP7F1xb1kQVkl8wuERbZ/pdpGkqDl98nsYPuDyQhh2rdSZSqiR35xtq59ist6S2Yf/WISdPtlwk4VPf9S1UwfP23fvEPhG7SKPKct7SHuxhQ8cQle16x/r0nJkTFrPAtcMZYIjCLEX07ikhC5sM0tTM2oCLmYxgKZNSRtVw8znLoz3W9x+T1cqmHqXqUq72IstCoWEfCDq+Ll3pq8se2Q+SlBjgod6H3CO48qdaKjQRd7Xvh1FqRS/bX+1SdkqRl2OaklGe6W7Do3/5NWJXEpLiz5gtG+rKgSnJFIueYUikDDFDSuU2Ix4TG5OTjmgZzUbWsVIWwcTASqLOuXG3Eivi0wTvcjmcq61KwwQqN6YzzagrT1X5sjc4rnR6H0ptrBpelYAWhyuGD6Ue1jkplaK5VPJqfEJYr/H7+4TDm0g9u6reVReLtDIP4/X4YItSQaFfr3HuMe2B4Jt5+fqreOV4nq1skIq4UjWayzUqdbgl93e1a+nq8ZqlklqsG4bVCmZHzOcNbM/YvflFjtOO5cGS3ZPHyOER0QIpJ2I2shq5G4qwrKpSzZoSSTPiAuIqMhCcI2ommyu1xSmPMtKN18oQZ3jvQY1MRseKYk0ZA5Kv2A5ls3LW1qWi1inOC0Zmu9sSzTPf36dtK1zsyTmQUVQcCrjg8a7GUgYcOQ2lsliVGIvQNDMsDlRVqaL1vsI5xbyhuWxHOh/IRnl84iGXqaW6qSHuisTXUkEcBNz4PSi+QpzDVw5zM1THmmEEzbHsyjJ+nBLlppW+62ESlRMTExMTExP/Fp45UTkMA7/4i7/I5z73Ofq+fyr3sVgs+Jt/82/y7d/+7QDcu3ePPP2DaWLij8VLL73Ec88992Efxr8TEeH4+Jif+Imf+Ld+fmJiYmJiYmJiYuJp8Z37jqUXlrVnXsPBoiV3mYs+st+WGspZ7dk7bLGknK8yNz9+m+Xegm61puszm7OOh48vaPb2uH5wwO70gvv3zshdh7jAbK+lCZ6LXSRcu0bGcHlMfIkru3j9BX5R6iyfnEeSqzjfbajMaEXZ7DqWzx1Rz1vuvfMQ11R856t36PvIe3cfkXeRFqAfaJzQLmv2D2p2cWB1ekHadDQIdeMxcQxD4mB/zl4e2LxzinTKzjwuBJoguFh28TArO4QmuKqmWbbsnpwQ+4RqSU0qgujlIiJFZsn40dcFJm38nNooEe2DPlgTQaiQKqBD4INPXNa4lluQUQCOd4ShyKUwtFSkphrGUBJ+mulPTkm7XGpYA4TaleQfZV9y6I2cMkNSYjbMuSKwxJWEY7YrIVQkE+jl4zLjMjCZlSsppJR6T2RssrUiXZ1zJYUJqGPc14ReM8OQ8d7hHYRKCALeX25FCpZLDaqXknFUMYKX8ZRrOUYDHTr8MKDdlur4Jm5+XLp3FcQVeWviyo2Mlb0ipcqXrPSrU5wP1GM6EPzV+b8UkFipNvUuQa4wzVcJ10vVWm68COmyVylUdUvot9Suw8dT0DXzamD+0qv0d7/CfG+fzekJMcyIrqLb9XRRcd7TNh5fedTKXqgBdRuomgZftSTnGJKRSZhqScOOu5aihozvKWnOJVE51vZeVqMOyUgO2soxq6CtS5XvrK3wlafbdqjzzOYzau3xEtBQ03c9OSriA65uqZqyIRmHyNAlTABfF4HadTgXCN7hRAkhlNcBDNNMVTmiCIqSchH5TV0jvibFntop9bwh2Zzh4gy1srOp3RYlYrMlmgbEQd0EUhYkl7SkiMOp4qw85qzleexUyaNsJj6d9/gmJiYmJiYmvvl5pkSlmfHGG2/w9/7e3+PBgwdP7X4+85nP8Jf/8l+++vhzn/vcVPs6MfHHQER46aWXuHXr1od9KBMTExMTExMTExPPLM/NXZntM2NW1xCVblDEQdt69g4blvOa1bqHWc0nvuMTOB3YnJ4hXtitI++9f8qt529x7foBZ+895PTBOZvzjuX1OUeLmq6LXGwz7e3btK2yfu8hNQ6phPn+nMVeoK1qJCsnq4FH28S227FfOzyZbVSawwUnZxu6x2tuvfwSh4uaB/cecvJki0YldD2pSzgzZtf3mV8/5GK1YXe+giGzVztCcFTBgffsH+6xnwe2rz8gbZVBHdIEagyXM4aRdUx+WRFVZsb60TkxJuxSTHpXRKFIqQSV4h9LVHA8yZcbiSKYgA5p3OobDZ7YuJ84/j3XIi6M6b1LN5ZLulJLtSiEklKjbFSaKeRYpKam8n8M3a7YPTwhBFeCg64kL3OEmDPDUNKRKSu7pCAeUUe28nhTvmx4ceO2I6CGk8vFwLEi1IMTwzs31r6OlaFjQnKMTqJq+DH9qVaed+KkCFiFISdC8OQsJf3phKp2iI23a0YQwdtY21qaZxEE5ww/bmyaaan9TPeorkfc4gbm6/Gx+CKSHZe5V2RstEHK4+lWp7iqIeCQ0FxJ53LVxws71uzq1XUZ63rH47HxeYHlq13RMFti3QOq/m3C8Uvcv39G7Abu/PX/nvv/x/9G/5XfYnlwgJ6uGTC2nUJKhJlDXNGfQ9SSpDQjZ8VTEp5qRs6ZlHPZsyxPKMQy3kNWV/YnpUwNoSDBoSrEnMiaaLxnVgtVAziPw6gCbHaRpMK1gz1qBykl0nZLNGPY9UjOhKqhqgJejJQzauVYUjZMMiIl2alSqn5d1YAXvHNo7vF+VqpdTfDtjKo9ZFiflueaE7zzVN7AenxzgNULrFujOWJkxBniduP3FPiqQcQhwSNmqGYkVATn8DgUT+o7coo4geAdXT+97zYxMTExMTHxjXmmRGWMkX/wD/4BX/ziF5/afSyXS/7W3/pbtG2LmfH7v//7/MN/+A+/7qcmJyYm/n3MZjNeeeUV2rb9sA9lYmJiYmJiYmJi4pkldqUqUg1CUAaNWO042m84urmPF+iicvyJ5zk8WtKdn7HbduzWkfN1JJN58ZMfY1nXPHjjHnffOmEbjUE81wQeP96Qmxl7L1yndpHNvcdIdjgnLJc111+4RuXh9GTD+dmO004YnHBtXqG7jq2U5NP9u+fQNly/sU/jHG+9eY/zkxU+JtIuIjHRzlruvPoCg1Pu3XvC2ZM1e22NU2M5a6iagLqKwxuH1N2azVfvkXfKNkFoAm3jIEZCVZM1k1NJUhqKGqQulxpRxrZQ58ZKVvs3/nu91IKO0w2XyUoBy4oLgWGIaEqAfpC6/MBwImEO1QwZNmNsUcdkZRGQjlCqVRm3EBFMI5YTYoppRHDo0DE8viBvY9k1VEMNNCkxlYpXRBiSkswQ78kqaM6oOpx31G3ZpSSX+ttROeJ8qU51UNKmztHWgrhR3Ho3pk1L0hEb5ZgVcWlqo8hz5JxLJa4r8hKK1M0xl53LpDgHQV2pIHVGFlcqUM3QWAKT3kOMqVSbmsOSAj2WHhKOOsLBcxBa1BtCEX2GK9dIDSQXcSkQhx3d+Qlz73HFevH1FbCXO5SqGdP0gUA2G+tY68shUS4reQXwoWK77UnPv8T6dOBf/fYf4e6dEqTn+f/qv+N+3bL9g/+Hw+uH6ONzUgVDVTOolvZYlJwywSneCSI1OVESnc4XQailirgKhnOGRiXn8dyKw8kocqV8nC0j3jOvArUTnFNElBAqNA1sNh2umXF8bY+AoRqpF3vlubLd4axsaDoBNBFTIg2KmaBaKmizJULVID7gfcCFClf5US5nfKhIKZKygg+ID4Q6wHxO29TkFMEl8J6421G5wHy5INUeHTosd4TZAjHQ3ZossyL5RSA0hKoiJ0eWDMkIIRDmS3bbGf3ZY8zK9zih/pN/kZ2YmJiYmJj4SPBMicrXX3+dn//5nyel9NTu44d/+If5tm/7NgDW6zV/9+/+XV5//fWndn8TEx9FDg8P+dZv/dapOnViYmJiYmJiYmLi38GNW/u8+2jH2aqnqZWXnl9SzzyzNjDsOtxixp3v+ATeEqfvPySZEHt4fB5pD1peeeV5dH3B2195l9PHWzZRsNpzUAUeXSRmhwcsDxry2Smr9UAfE7NZ4Ppxzf6N67TzhrffesxFl0jqmS8C15yxOl9TLVpcH3n/rOPaC0e89IkXOT855fWvvs3QDUgX8QZeAV+xuHHIKidWj0/Zrnr2msBeUA6O9qjnLQTPbDFDNmt2r9+DnbKLgBdm8wrJEedckRZ5TIWlsqF4JSKlJOXMCaGu8ZUr7w/kcZNQMyWnB2PsckQQhGzK0G3RmBBzyKVMYUxFMs4iIiUN5hwiRRaKlWpTcx50rHwd61ctRciKkUECaXvG8Oic83efEHxJsuVsZANVIamRzcgISSCXXB5q4OvAvK3RZOSY6YeIE6EKDsNw3vC+pCadCL6qcCFQz1pcU+Oco5q11O2Mqm0QL1hWdruuVKYOHXHX011sGPqeOGTIaSwAFTQDKDkqimA6VuSKYnhUPOIcg5YEpTcj+PHEpVKVq14JTrAOLPVoPi3JxGs3oT0EEmYOZwriMJfHFCTgBMERux3D+px6KYi1yCgr5VJYmiImo6C8TLra111/xoRteWQlVes4vfc+3f41Njvh9X/xJT7+5D0e/pNf4OZf+Ks89wM/wv26Yf3Ff8KNWzcJT0550iVy3aJ4Yh9xovi6ItQVUlUoHtVS+ZuSopapgse5IoRxQopKzuUxqkCJkxpiidqXa0jO+BJfJLRzTIvE9k3F0bUl3gu7zRaLCWwN1Xy8XlossRlDt6N4aU/fJ2Lfc6mss4vM5kvMDEeiCh5xHqcZdZ6ce5wTxDs0Jmx3gTfDBi3X0Fw5dgzpe3wdaBdzbLnHsDqjqgLOBbrNlrzr8NGQ4PGNIMET6gpyTRp/+KDeO6A5usFJ/jIhbumz0obqabzMTkxMTExMTHwEeGZE5TAMfPazn2Wz2Ty1+9jf3+dHfuRHWCwWqCqf//zn+fznPz/tU05M/DE5PDy8Ev4TExMTExMTExMTE9+YL717wbqLvHpzxgs3Gmb7AS+Oi13k+ss3ufXcEZvTNeePLwhV4OxioIvGjY/d4tb1BevHj7l4uGLYDAziuf5cgyVjEx3X7hxT0bO59xAdFOc8+wctxzeWHBxfY9spX/rye1wMZQ9xr6moYsem71keLjlbDexUuPOpO+zvzTl9+JDT95+Q1wMNQhwyEaiamj54TlZb/PkKiQP7Yty8ueTwcMFqOyC1MGsgrk7Jbz6k6mCdDPOBWeOoAJVSTxqHiOooyJxDU7pKUJoqOIcXh3hBnBCqAJWhGWJfUnVql2KqlIs6udwDBO16hm5TNiVpyoUY02jkDBiWElCSiuMgIojHRu1ztYhpApYQjSha6jX7Df2jU1bvneOdkLOiKmQrPjVjqANcINQ1edsTu4QCVR3wTug3OzQlRBxNE4qk1ExUpW1rqrZhcbzP3vUjltcOWB4ds9ibg8s0s33ysCPt1riqKWnIqiEOA9vNhr2DQ7b9huBmdN3A6uyUuMs8fvtdzh48RPsIOZIqcFKRYh53FQWNuewzhoB3rlTpOrmSyWYlORoEoilByh6n7GDIZ4hm3HWP1MsincllUhTBrNSTXlW8aqLfrPB1i8MXRenCWPmax2RoQjVeSUtBEEuARySUa/LBpCiIEWOmzcLF6ZrzN99CvfLGP/ltnPdc/y/+G25/5oe4HyPnv/d/cfTCTdzJmkddpNPyfPIOfBBc3ZRELw4zR85KyhkToSGgOZOzltpcX85L0rJF6ihVp8576sqXWllLiBkulERxzJn5/j5tUJwOGA3e1wxDJHcDDEUmixmYkocOcw5CS0qKpYQXw4lD8GMFbiS4irr2iDN88KWGeDC8D4TgEO8xTUg0nPOk3JcqZhwuA05QLTuyJitCuwdNQ84JJCHNPjmmUn8bE6orXChV0ykCeEyNvLvAm2O2nJNzzcJVoPFP4VV3YmJiYmJi4puRZ0ZUfvGLX+TXfu3Xnup9fPrTn+Y7v/M7cc7x8OFDfvEXf5G7d+8+1fucmPiocblP+eKLL37YhzIxMTExMTExMTHxTBOC41uOGm4f11y7uYf1PeukvPCpOyxnNSf3H+KcY7k358HDLTKveeXmAZuzHfffvkcdhAePNlz0xtH1JZoyu3rBYB08eogOCZch1BXLazW3b+4hoeHh4xUPHm8YXIOvMo0TbHuBBc9yOee9x2vCYsms8qzOt5ydnJPP1kVejOInmeG9Q2uHwxg2Ww4qT+MdrvU0s5rtoDSLOWIJGyJy74xqB9tByeKZNx6fI8O2iMHLWlI1yKrgpfwKWE5YKVUtflBLGq9MAZYUmIyVpM4Uy2V78nKychxDJHUdu/MLLGckGJdpOyRD7CgDgSU5Kb6IPmCsSi3Jx8tEpWGIxqvPkXu6Bw84f+eU2nsUIUYlZ4g6rmI6hzlhfu0IzZHN+RYffNl9jIk4bivWlaeqPM4LzgmhblncPOLohZvcevklTCO527F69JDTr73Lk5hJcSD2CdK4CegcqkXWiXcYSqgrQlvTLBfMj29wdOs5ZgfXeeFbP0EVajYXK+5+6aucvvsu/eqC2AuaHZpL3W1Wxg3OgDk3ymCICczbZYPuuH2oCCVR6E0YzrZU3EWOn0ea/dIZa4CN+5tuTEmK4MSR00C/vaCWQHG7l5qYsY6XkopVLTlKKbumYuU4BI+QyjWzsiWZhoH9oxt8+Q/fhbMVclyxu8i8/r/+M1Lfc+sv/lVu/8Uf5G7OnP3B/821Vz9Jeucup/2AVXOUzJA8bHvqtsacY+j6sssYPE5kFI8CVhK/YhlPSeeKLzLWGThXzpNYKn/uA1kc224o3xvaEXcREw+yI8ZhTPYWOVnVHnEBTVrSjr5GM6Q+IlrOpQtFfkPCYwSfQRW0IcVMHBKmOu5bgg9G1oDlodQdG2QrPyCgquW5WjlEFIsZ89uSVs6JnBQfKlzb0iwPyNmw4QwXGlISSD2qpbN4GBTJF1SLJVXYI8kjAsNTe62dmJiYmJiY+ObmmRCVMUb+0T/6R5yfnz+1+5jNZnzf930fL7zwAqrK7/zO7/Crv/qrT+3+JiY+qoQQ+N7v/V6apvmwD2ViYmJiYmJiYmLimebW3HPtsObmS9fI3YA/vs6rt/dJ2y2nD045OD5gu9px9/Gaw+cOuHU45723HvLktOfW4Zz33z9lk6GpA7s+E5Zz3JCod1tkyLi64tqNOddvL6l9YBMdJ2cD210iUkFONF2Hdj1SV7Cc83gbWVw7xDRzcdHTbzoWlvG51JcOjG4JITmPOYezTBOEo+OWg2t7dFHJTlguZpATqgF9cIqsIl0ykvPMZ4HGl3SWZSNrEXTZDKSkIjXFUreKlRpWRmGoSuxj2Sr0ZcPwapdStSQqL2sqEXS8bdXMsFpx8eAhz+VUqlpxjJk+SD2EGfgAmSIqfVNqOgF1ZY/Qxv8VaTRWjlokXVxwce+M4IuQin1miKXmVQFcqZP1VWB9ckKKuew+5lxkmzm8h8oLzjuCh/2bxyyuL7h26xZqkc3jx7z7O3eJ2x7NiawgUmpY5fLReIcPZVMRrzjxZNFR6kVsm9jtOvJqSzy/YPEizG5/DA2Og5efZ3HjGG//GWf3H/H+V77KyVtvEXcdmjI5GSlmkFKta1p2IfNY2SvOFbmb7SrRWiKxHukTcrZG5B7+WKBaAOOnxZeNTxHE3Pj3IPU7fLUtUloc4jxQKmbFAapXO6RXltRGu0xJ2JY0oWKayz6pwDv/6o+YS8YI5GRsLxJv/p//HIDb3/+jPP8Xfoj3uh1nX/ttbrzyLejbb7GKA8kHckxQBQZ1pGEg9z11HfDBl1QtpZUrqaFqxaWLQqjxZlROMM3lz63UFYuv6E0JsxnX9q7huxWaIq6agRNit0Nz2a4c10kRJ8SkxCEhVQUK5IQTI2rZINWYqCrwlRvvj1KLrEpMCc2Jug4IsYhNU1zwaBIsKUPOGB7nEz4EnIBjIEiFqxvMjJh0fJyK5ogXIQ8bnGuplteY3/4YhAO2548YukR3cR91dXlexgEnHbO2RmSqfp2YmJiYmJj4xjwTovJLX/oSv/mbv/lUtylffvll/vyf//NUVcV2u+Xv//2//1TF6MTER5Wqqvj+7//+D/swJiYmvgEv7Tu++j/+pQ/7MD4y/NN/+k8B+L7v+74P9TgmJiYmJr55ef6lBdf3WjZnO/ZuHrB/0HLx4BQB+i7y1lunZBLP3TlAkvLGH91nc76mcTVvvvGY+dGc68cNj84T83aBrtdsHm3YDZlbN2a8cOeAoxsLTIWHJ5FVTHTbyHoXcQbDxQa6HbP9PZobx6y6dakYXW+JCXw3cM1S2b8LnjALDLu+JORmLTduHxJ3G0KnLI+XHFw/oNgrx2IxQ9NAcA47PSO/f0GOjoRjfjAj9DuIDrRIShDUtHglA9VRBopcVYqKkyKjRK42AE0NJ5lQezKQ47hSOFaKqpYIqFmpa439htN376Kxw2xZ0oZjw+tl9aSEORK3uKomhKbIp1GQluNi3EeMSM5F/vU9w8k5kktSbhgyMZdknyLgPOJBjbHetuxiWsxg4B3UjZTdyeCp5zV7R3sc3DpC+w3nb/9r+k2HSKmyrTCkdvjK40d1XBKHgsgodseNRrGy9VmqUceHKuAsYhcPOf+9u5x5T71/jCyP8Is9nvvUn+Xg9jWef/Uv8ejuW9z/8lc4eeNtuvWa2DusGFKyZsQSfkwSmhiKL7J5DL3aeB1yAsjI+Qrx7+OP7oC05YSho2gsv7dspYY0ZXLf4UJJLwpyVblb9jO1/F1xmPgxQTte8/G8XEZqvfdoirz75pt89Xf+BX+mKvujmgwJrsjK//23yf3A8//lj/D8X/ph3vnH51y88zo3X/kU9sab5JRRcfiqRnNGhx2VczQiiGXUlJQyOEriOEHKRrNc4KoWiz2C4lRAS5LS1Q27aAjGvA6Qt6VK1XnEe9TKk8p8IGYDyThfanCTKl0WRBOVz3jAh1CkrhkaE9476rYpqdgUoamIsQdzzJqG4MombLfZUueGal6jY/1sTDY+n2pQK1uyEqhmNeYrTCpC5ZHdajznJTGZh4GUOjQ6wnlFcyDMlgu877A0R2OHeg9ag10gvmVYr57yK+7ExH8Y0383T0xMTDx7fOiiUlX5whe+wJtvvvnU7sM5x2uvvcZ3f/d3A6VmdkpTTkz8/+Pbv/3b+Z7v+Z4P+zAmJiYmJiYmJiYmnnmOFzVPTjr2bx0xdMq7qzOO9gK7rbIeHMtrDbeuXePJ+yfcP93RiKCDsco7jq7PWK17Vn7G7NoecnGO7gYyxvPPL/nYi3sc7O/R58Dji4FVp1ysNqgEZnsLnrx5l+0u40OgT0J9fobudnR9kTq1c1ROqJqGrQrNvGV7viZFJVSBvb0ZtrogRGW2bNk7vsaq62hnLU1Q4nZHqDxpsyW9+wTNji4rs+M9Do+WrO9uUcujzPJly9GKYEo6SiYp7wkgl0m5In/MiqBEpWxXDhlLJQnmmoBYIA9lu9AYJaXZWB0rPH7zLeJ2TbU8Aq+AL0ZNY0m4hVmRRKHGt025VQEVAAAgAElEQVSpfDWKGKMIyzHqiaGgsLn/GKdl17IfjJSspAwR8DLW1QKuVOWmFLGseAfBB6pQqoBD7WmXLXvHe6TdmvV77+Cd4L1j0XqcU1wQRMp7GeX3JU7pRuN6WVcLpRr3Sug6X1ygaVF3ahgOq6pSS9udQX9BPgvcv3hEODgi3b7g9ic+wY1PvMLZ3Xvc/YM/5PHXXieuN+RsZC23w5gyRRx6GaJ0UpKVKJdnHwTpQc7WuOox7N9CpB4TqspomMdAbLnNNBRRKS6gVwnY8oQw03G/smw9grt6vsh4jRgF+PbsFHLm/t1TOF9RL0oiEQfijBAC3Sbz5q/9LtYPPP9f/xh3fvjHefsf/8/s7r/DrU9+C+nL/y/ZHDYMiBg1MqYclTwk0nguQuVLlW/Xlz3OFPFNjVUehohqwo+9xH2MVFVNJZB3m/JD+lnxVRivq0dChTlPToKlrkjyUMS/YQTn8HVF8GDicEPEiyJ1qQ++PCcqHu0jThOhqvAmmEHq+1KHbJnUb+lzua6aE04c6h3ilappqOctrlmQ4oBva0JYMFjEcgJfle8RVxGJdOsV2P2yp9nMsGzUdU3KVr6384CrW7I5Th8+eDovtBMTExMTExPf9HzoovLk5ITf+q3f4uLi4qndx2Kx4Ad/8AdpmoYYI3/n7/yd8g+miYmJPzY//uM//mEfwsTExMTExMTExMQ3BU82mb3rS/q+p557bu63nDzcEHHcvD7jYNHw5P4TdoOxV9ecnW5YHC+43nienPastca6LVys0BjxTeCVjx9y7bhlNp/z6CJzuh3oNjvOLnaE/RkLZ6zfvcduHUmuovIw92DdQEoOHSIuZ5LzVPszdqEimZHOL4hdpp237HYdcb0mBMfBrX329mf0Q2R5sERT2Q5s2oru/IL+a/doe2E3ZHxTs3+4YDg5KduFeZSR+VL8ldLMy2rV0VsW4SRFnORRYnnnyZrLTqEImsF5h68DjMnBHGOpo5Qi6VLOVCHw6I032Z2cMDt+HglVqQoViqRMCXyNuAqpWqrZEucdWMbIYzZPx/rMDOLImy2r904ILtAPiSFJEX8imPcl2ZgN8WVjs9uVDcHgHbWHunZUtSNUjnbZ0NSevDqlDg6/8DgnOF+EpHMe512Z53TltkXALI+/90XemhY3Nd43eJxzqGYYa3JVbSy99WVP0vki1Sxjmwek9QMevf81Vm99icOPf4obn/oujl56hUevf4W3//k/Y33vfXIs24RpyFfPa3dZ3WtfN0OpUnYUxdCoZJ9J56eEuoL5dZwPRW4iV2L4UlxqiqShw1elGtQ5X2SryPirK5JS/PhnNno5w2RMXGqmv7hAzPH6H/4RbeypfI1mIxnIoOO+pCN2ynu/+WXq41/l5vf/dV78b/8H3vxf/ifC4/e5+fFXSa9/lXVO+KbGVw04iH0kxoFQ12Wfs4v0MZGzUjmHdjsGG6hCBdlwJHAVuyHhnNHWDh0yKSec97gqkBN4TfhQo6GCfos4RzYjJytPQRxVcFReqNq2VBAPA+iAC0IIYUwVW2nPNUNV8F6omppsEPsBE6GazUgpohoxCZAGnAriM03jmC8WhNkcRbAYMd/iRDBTXNWQgdA05XvafJHUVYMapCFjOaGpo5kvaPeWpBzYPnlAik/YdYbF7Z/Gy+7ExMTExMTENyEfuqh85513+N3f/d2neh83btzgM5/5DAC/93u/xxe+8IWnen8TEx9Vnn/+eX7gB37gwz6MiYmJiYmJiYmJiW8K2hA4Xw3cfG6fhYN//dYZ9Ux47nhGWm145/EF9byhO1+zHRJ3Pn6DiycXPDiPnA2GSwN1ygwKs1nNnZcPuXFjj80m8+7jSDcY/XrLRTL2bl4jbC/Y3D+nHzxSN+xVwvG1hpOznpiVPG4O1rMGv1iy87A937Jeb7lx/YCDmwvOHp1w53iGrzw3PnYT54zNLjJbtKBKqBvatmE4PyHfO6HtHX02zHua1jE8OkFjJucxoSgAmbJwN5Z1XiXrSnJORFB0/NrCZUrQJFMknJBjqcisFjNcWxNiRIeB1KWSuDRwGNuTEx6//R7XXv4WqNuvuyKG5R0S9sE3iJ8TFvv4piTmBMNMQEuSzwRcGli/ex9PEWRmRSKaUapKncdyxvuSgoy7iBdwwVHVnlAJbeNo2kCzCEVgOmG2COAN713ZPqQkFEWsnBcnZVNwvN2shnNyJS5Lny1lX9MFVIq4dObLHzsHRtmVFMEqRSgVu2agTksyUhP5/BFP/uCU3aN7HHz8W7n16qvsXT/m/T/8l9z/g39B2vYkL8SYSyUvZZLRBYeaouYQGc+dla1TiYbsIm59jq9nmCzAlbegzGRMuBr48jg19eRU451HTUcxKeCKXBRXIeKvJOx4Q+M1KTuVq5NTUnb/H3vv9mNZep/nPb/vsNbapzr0uXtmOM0hRyRFibJEypSs0Jao0AkoB5EswzCCxAYcwAhymav8CblILpJ/wAECOIiuJEeSZdlhKJESdRhKQ/EgcmY40zPTh6ruqq6qXXvvdfq+75eLb+3qkSMBlKB2i4P1DBpdXdVVa+21djWm6qn3fbnzJ9/hihO2HyKlRECQNlBWuTa1Wytv/fpXEAxXP//PufUL/5y3/9X/ys2Xp1x/4TZy7w4NHkFJXQsx4ky+f6HrcmIQMBopCgEStCGnH31JwtMlZbqYYYl5WzUGjHGI8WDyZwQk1ApqLKE2EDvEGlJMxK7DWUvhHW6Spfr54wcYAVtNEQ35+oghhkCKPSKWoiipygKKKZvTc0g5KRkj9EExEnIKNgaM91TzCZOdHVw1BVsQ+wYjCWOFvutyb7FxGGqsVaSc07cRazrsbEZMiWZ5RkpHiMmp4GpS4ScLQrJsHh7gqorJfPp0/qEdGRkZGRkZ+b7nmYrKGCNvvPEGb7zxxlM9zuc+9zmuXLmCqvJLv/RLTzW9OTLyfubnf/7nuXnz5pMvDEdGRkZGRkZGRkZG/mKM8MLNfUKENx6usaXnSqmcPVgTRPDecnpwCmXFjf0Zxw/OOO08beypz1dMRWg0Mp16Xry9z9UbexyfdBye9qzrllC3rOpANSvo7z+gawNKQTCJslTmhaHZdExLS0yG4/OOIAYzmRCbmnrdEmPihReuYqae7vycGwtLMZ1y60MvcPb4mLqDajqjCz07u3tYetrNKcWmxpx3dFHpElQzhxclNZFE3i9U8hZlUkg8qWnNO4vbZcHt63LVqSp5Ay8OLUia3x6jIsPWpfie6c2ruElBe3SEPjonxB5FiH2gD5FHb73FSz+5xkzzTuWF4UsdpISYErzHz/YopjvUHJBU0TQkKVGMBprDR3TLNku5Xuj6kFOUPqf7NAYM5C3OkDCiFGWuep1UhqJyFFOP8yb7HjE5UecYpCRD0i/vV6qQhaTNIk9s3us0DPuN2+QcW1GZQA1GLFm2ynBN88cdQpTkAU2G9J0BDKqRGHLiVTTQHd7h6PEBOy99hL2PfJIP/tTfZXH1Cg9ffYXVw0O6VgjdUOGrishQ22vIG4vkrUwrgsaI9pDOa0xxjOyWYCxKJGk++7yvmYbq1I4UeowLedNSfX5ykDDOgfHkddJhp3P7OaZZKqfQcXZwj/PNOcuDR3zQG4zIxYSlAiFGTA++cKQE7bly59/8LmZScfln/iuu//1/wqN/+39w81N/i667xcnJI+pOSDENct2QEoQu5DQtihfFSk54Guuz6BNDCD2Vs1Qm0oVE1/TIUJtL6CknFaZ0hNAjalCy9AZLygYUkxwpRAIBV3TEbon3DmMi5XyRz6vd5GuRBLAY53DekBBi1yHDcyvEnqaL2JQGwaxYK8x25pTzGeJLooKEHsSSktJv1iCCKyLG5l3LFBOpC6S+xpcGW81QN+Xk3jvQRkw8w+3vEZqObnmXvj4nxYi1FlfO/7r/hR0ZGRkZGRl5n/BMRWXTNHzhC1+g7/unepxf+IVfQER4++23+fKXv/zUjzcy8n7kypUr/OIv/iLT6fhTkCMjIyMjIyMjIyPfC06E47NEmk+YlRvS45qDR4mIUhTK4SZw6fo+tm/57luPSdUU1Y52uaZIoCZx9eqE55/fxxrHW++uOV63xD6wWjXUm57SgjtvKKznuE20MTCZOOZesQKrKDTJsqlbgrF0YjDrGouyP6uYXdqhDTVFVPZ2ZxSlZzKreHR4jPEe7yCkyJVbzxPXp2CEy5cu8fBP7iBR6EiUlxYsJko4a4gKW8eY60GVmBJJZagwhW10Mqm+J0Q5bNoNSUKFYcMQNMW8v5gSMQQswuzGDfCCdUK/auiaDtVETBFrLPf/9A3a9Qq3uIwa/0RtpR5iN4gvh6n2mOxd5fzuHVKs0UGoiiqxXrK5/wjvDaFTAiknAF3eSxQEHR6UilAWBm8NZWkpS6GceIrSYrzBDruTkLBGEJdlXUJzolI0bxVaM9S85l5VYx0qipG8w2jMUAs7pCMRCwhiJVfcYkkpgGw3NiVvW4ohxYgzPj/GmLL0KywmJoZxSzT1nL/xTfrTR1z6wU9x/Qc/xnRvh4NXfo/VwV36OtB3kZiUEHNaUdMgVtEn4hJIfSK1kbRcYSZrMDZvg4qipHyfNadIU8qyMYUC6wqQ/HYjLtevOg/GDII7S8PtciYaiV3L6vAhh4fHVG1PtZN3La3ohQhPUen6iIjgnAWFzTLy5i//P/jFHtf+zj+kPz/l8Pd+hVuf+Wn0u4n+dEXTheH5GrHeY6wjpYgzQuFzFa9YTxRoQ49TZWIsTpSubuj7RDQWYx3O2ZwotY4YIykpIUSQQfBHRZzHuZLY99B3WGshJWJ9jjUW7z1VabHza6yOjtHNGd45kghiErFv6SQLViTvfsYkWNH8PHSCLyp8WWAmM9qY8H3KT6WhkjmRUDE45whti3VKSgbteiTV0PeoWGzhMNN97Owcaz3hbEkMPX1qaddLNDZIOaWLQGifwr+yIyMjIyMjI+8HnpmoVFXqun7qNaw7Ozt86lOfAuCrX/0q77777lM93sjI+xER4bOf/Swf+9jHxjTlyMjIyMjIyMjIyPfII9lnf7ekvXefg/tLSmfZnRc0m551nZjOKk4Oz+iNpzMVut5gY6QyMFtYrl6dc+25K3TJ8u7Biserlq5u6ftEt26oSFyaVxSm5PCkoYkwKS3TMldrnvbCKiTarkMiOAeVhRCyBOuSMqPh1pUdfFlRTDx927FuWmZ7e6S+BQw7iwXLu29inGW+s+Do1W9horDqA1jHpSszukePSL3kNk4AY4gxDDJpEJMp15Aikncgt19biMIgJ0XZqsL3fO0hpDRsFqZE3DQs79xhcnWXsDofAn0GyGLLG+Hwu2+wunef6ZUbqCtA3YXk0rhB3BTEgZsyuXQNN6mIXY0M9aVopH98hi8soU55W9PkhGQccospKRpyHWrpwFlhOvOUpcV6KKYFdkhOGpszkZi8t7itcTWSk5TGWLLoixgDxrr852Gb0ZBTfCKCpiF9OtTEorlCNqYAKM56NEXEmiFfaVDVIXWZNwzFZGEWNUtXMMSYhZkmoT95yMk3/4Ddj/wYi6vXcX/np3nwym+xvn+Pou/peyV2EFPKzycZ7pkVkDQkDoUYItIJ5vwY6yvUVCg67JIKovllA2iIaOhz8tIYVAXjLKaYIsble2aytLvoCdYEGulWS5YPj3j06JwpPU4KhGHvMj8dwULoO0KvGDO056qweRy48yv/ho/sX+XmT3+ON++/yeOv/yFX//bPEr/xTR51j2i6gIohhh4jBrUGNYZooTMWYwv6tsM5YeIMRpS2D2hUrPc4XyLG4qzJkjIBIT/PUgqoGvq2R4CyKDG+yInJGDCEXKkqBo01qJLaGrGnVJUlyBwTW1KMdF1D3/VIUaBiMdbnz53Q53RtOUckUs3nqLFEwNiC2HeIWiKGEIWUWsrCw1BL2yVFQ6LwQrFzmW5dI1ozvXwd9j7O+vW3qO+/hkuBUB5TTjpcUeGKBW0fiW3INbIjIyMjIyMjI38OzzRRef/+fV5//fWneoxPfvKTTKdTYox861vf4tGjR0/1eCMj70f29vb43Oc+x7Vr1571qYyMjIyMjIyMjIx831DEJas3lrz7oEaNxSKc9cr+tQVh03H4cI2bTohAd77GCYhJXL084fpzu+zs7/J4kzg4XnL8eEUXhKZu8W3L5bljdz5jc9Zwb9WyDgmMoSrz3uG9VSJowpPQoFzeKWmCsqk7YoxMpwVXL025fn0HNyvxvmJ5cgbGceXKFTarcyazOaHveHz/Llahb3qatw8o7RUmVzr0/IBJaWkOjohtFlw5OWmIaUj0pZyKjOiwO5gTgzA0sV6YzSw5ZUgCbt/2npJPxAiqib5tWd19RHdyjsae2AY0KUYMKbSU04rTszPufPVrXHr5ByiKKZiIDqKO2IItwXrEFvidG1S7+7TLU9CIUSVtNnRHp2ifq2uzTDVZEJIrXAk93gllaSkKw2TmcAW4wuELg/UuPx7Aum1KdJCqotjCgqbsIk2uNDXW5PnO4VrlKU8B3LDPOFTCbhOdGkEMYgxOh+sPiPOoGU5bQVLKaU3ApERKkoWogoZ8j8QOKU1rSRoJZ49YfusPWHzo40yuvsj1H/0JHhevsrr7Jr5IBB8JPYSQb2FMQ43tICA1RVJypC6R1jV2tsxJVrWQ/WG+JgMpdmgq8mOKAtbgygrjK8S4vHEpFpU+17kOFbSo0J5vWB0dc3z4mLkDZ3IdK2Yow5V8D42xJCCGhBiLDMnO5btL3vnVX+Glf3qd5/+L/5q3/+X/TH3vO+zf/jD16RFNm/W5sxZXVWzawCok+h5SEopmw6UiMS8rjBG6PhJ6zWISKAqPis0CmbwhqsaQeqWvG9q2wxqlmsxJKpAixjuMM1gzxTqLdY6u9TlL6jwpBMR4itmU1CS0h9AaTDkfkrl5N9RaBTsh9i2TaYErpiCQQk/hchVu2yhtF2lTvkZuqGEOfU8USES8gaSWtq6pz8+x3WOmVy9hJkseP3qbVDf4EDH2CHvF4wtPMd3BScn67AT69Nf9T+zIyMjIyMjI+4RnKiq//OUv0z3ln6j6+Mc/jrWW1WrFO++8M9a+joz8FXj55Zf57Gc/mytnRkZGRkZGRkZGRka+J+rDE4KBxc4EFcGUhr254/T0nE2jyLSiCS22a6mMxRWOK1cmPH9znyCOg/PE/YdnnC9r1k2k23QUXc21/RlWIicPzzleJTYYvBWu7RY4bzhZBUIXKC1MJg5XOs6TgASmU8v1a7vsTgvOlh1tSPgEj49OMNbhNXL++JidS1fpNkvatqWczdicnFAZw+Ykcv2nP8aDf/drFLMZ09IQVy2asqhKKcuIiKIoUVMWaUPiblvDuRWTkEVcSjnlpkMFqbx3X3CoiNWUK1YB+q6nbzuM2SbrhuPFhEkgKfLmH7/Kx/7+z+Dne4jNVa/ZWPW5klIcakrc7DLz6y+wOrxP6jog0D4+IrWRmCAmGVKIBiw4BO0D3iiT0jKZecrK4irBeMFYwZsc2BQFLFgLiM0ri0aygxRBbAEacNaTZEgaGhAx+bHJkDQ1Q8IyJfBZWOZLbbHGkFLMstLaYdpx2LJURWPKdaxishh1LgtKBpksbkisWlKMuY5V86ZlWJ+yeuub9PU58xc/TvEjf5uHGlkdvIX3jr4PxE6JCH3I0tCIzZIwyiDLIHUBXZ9jql0Qj6aEWL2ocWV7LjHvIBoiRgRXzZBiMiQpI0gY6m4HCZsCqVtx+K1v0Kwb1icbrljB5gs8iOAsgRGwhSeFmHdTY8JaEGOJMXL0jXuUv/yveOGf/Hfc+Af/DXf/z/+F5//eNfZeeJn69a/TIviJpzElxylQR4U+UMWGvZlhtypJQEiKDlukSMJ6j1ghRSWmLE5FAliha4S2aXGFZzKdDtcm5iRmafLGa4oQImIVX06R1GGdy7JTs2DGV/S9kvyEYjJDMcR6hYYNQsBVnmq6oNrbxU8vE/oGFxOpa2nWDW0UNnWHas9ssYNg6dsGxeAKwVlD7HM9rYlLmuUJYXWCNd9iuqr56I/8MJv1J3j02lex0kAKhK7BdiWJHiNg/DP9FuTIyMjIyMjI32Ce6f8lfOlLX3rqx3jppZcwxnB+fs7h4eFTP97IyPsN7z2f/vSnuX379rM+lZGRkZGRkZGRkZHvK6RwdK3SIlyZG6wmjh63ROvxpXJ2vGavckznFdNFweUrMxbziuNl4FHdUzcrlsuWTROg79mNDbN5BQrHpz0xGdYIWNibGIwqJ+ueuotYA+W0wC4WlCrIZkVphWu7C0TgdN1z6eYV+thzdt5RVjPQiC8sxJ6ju28zmUywRcX5esVkOqV58z7z2Q6nr/w+IVVc2p3gQkeflDQ0uYoRYtJhnxISgywbkpHGKILJSUoGgTSISVUdmky3L+e/Y8VgvCWGgFEharoQmZqy7cwuSobjJ6ZTz7vf+TaPvvtdZjduIb7CSESNzfWuqQVb5c1EP2V6/SWq3dfoV2cQOtrjMwRLjIGY21MxLle4EhU0MJk7pouSsrK5RdY7xOb0ZK523SYidZCOCWNtrhwVwW7lIx6M4IzkWtQhtYnJcjQ/NAESWJMrYDE5iYki1mKGhOD2Gsrwsbb1ujJsW8YoFxuXSYcKVQOScgLPis0COQlqc2AxNiv6o/v0O5coL93iysd/lNCsCOeniBjUZUFsJZK2A5UoWIemBCmSYiTVDbbf5CSrcTlZKYoQUc2LndvaXRRs4fCTXcSVg2TtEfEXFcGqEU2B2NQ8+NNvs64bpI9MpzbvgIrmbU6eVOyi+R4qSkz5vhiTK2Jjl3jwldcoL/9fXPu5/5bFj32Ogy//e577/D+kOb7P47MlJ3XkKJ5TqyV1gX0CNyYwrwxJDSEqMUV8UWDn5ZB6TaSQiDqkFNsuJxoThBDxRYkrPEkNKQUK5xARYt/TNQ1OBOvA+R1cMeyCxoCmLLFT3xFTQqzDOYGiJHYRIZESJGMwhaeY74At6eoVblJQXb7O5nxNu1yS2haRHi+KxJqkBdq1JFtB12Lnc2KC/nyDdo9RDKjh/NES6+9x9ROfwc8Em36Q5vgBOMmblgnEOaqZH+7xyMjIyMjIyMj/n2cmKkMI/P7v//5TP84HP/hBjDG0bctqtXrqxxsZeb8xnU75/Oc/P2y+jIyMjIyMjIyMjIx8ryzXkaU1vHy1IqxqHp4FGhF2poZQN+zMHFVVUE0st27tMpnPeLQMHLWRR8dL1nWk6wK2brhcgLGWx5uASKLwHlJibpRp4YgpcXzeYwvL7rzEWGGlFieKdDUvPL/HpZnj4PCMYjLl0qKkbmowjsl0SujW7F6+TL9Zcr7csLhyjaSRLsJiZ4/V/QM4qWm1p1FlOi/RVU3XB2LUQXpZ0pBsfJKbNDyJTkJSht1E0EE4pvREWmbR9mSbcrtpKVYgSK6DzWOTQ9Iyvz2xrQIVujawWMw4OVjxxu/8ITc//nFsOc9SUvM4oaYEBIxYVBx+9zqLWy+yfniP/rSBmJOP1tosQ53BGoOGACEymXlme45iYjAo1husN4gTRFIWmuRtRLF2SIcmrBv2Iq0d5GVOExrJ18xYezHdiW43LYdrpoIYh0r+GKKKSK76Ve+HHUqTBW6IF9WnpijyJqjm6lJSQjWfo6oMdbTkwGaMw3FAo5LIG5xxfUJ99zXcdEGxt8/i9oc5f+PrpKbOaVPJ25spH2bYoRRSFFIENJH6iLQrqBZZXOsQNwUgIQqi4UJfF9MFbrKLMcVQg6sXzynVHk09aKR+/JD7336NpgsUQGGzHN4K3pTytdpKc7bPtqFmV7cbqKqEFh586Y/Y/egPcuuz/zmvvfltzr72Za7+2N/l/Lf/LWvx+QCrll3t+cC+pywdSQpCFEIMWCsYu93FdMSux6hiROj6ntD1tCEiJuGLCucLokbQhBWDc1kix64ldS1YwVWLLPz7BgFi6IhJEeOIKoS+wbgCax10LdKsSaHBOqGc7eCnM9Q6uqZGYwSzoD4/Iakyu3qNbtNgJKcw+65Dpc1VympIsccVBcXugvPVhvM7rzEtLUkNbRc5PjwhfOMVbDnDGItf7NCHPqdpgfliRh+gr8fvyY2MjIyMjIz8+Twz8/D2228/9YSjtZYbN24gIrRty2azearHGxl5PzKbzfj0pz/9rE9jZGRkZGRkZGRk5PuOau750Nxweu+Eo8cNMQSKEEmbjspZZhPH/t6U55+7yvTydQ7X8O7DJfcfnHCy7NmcN8yaDZcdOGcpL80pph5SJIZcjbk7KWhD5HQTaFQxxrBpW9q2x/ctWq/58Ms32Z1YDk9qplf32Nmb0bQdviypqpK+WbFYLOjPl7Sblks3n6fwgoSAAbr1inTvhMoWdCFhnGW+U2BECV3Me5RiSChqJQugoZJVNMsiZRCTg8bKZCUlYnIN6sWvJ++TUkJTIvbDruX2P32v3BySeGQZlJIyWXiKSvjOH77C6Ttvk7qGpJFtn6wIoDFXyRqLFHPmz73EZP8y/dk5druOKWCM4LzFOoMzwnTHM9v3lDOHLxx+4rFVgSstzoG1WVpamwWrdTa/zTusFZwrL5KVxsnwy+ZKVvvklyuKiwQqYhDrslhLEWKPaMxC8WLHUnPSThLi3CA9s+i0zmFMruDVfKcQshg11uTjuLyraa1FvMN4i/UOY/P1Cssjzr/7x9DXLK4/T7l3FestzgrWGbw3lJWnKCzOWaw3uCJ/DDFCCoFUNxjtBtmck6nvve+kDlKPdY5q5xJSzoZtSgEsKpLPXwOkgPYdx2++xenBIW2XmNp8j2T7CLd7p8NWKsOxjLFYGRKOMVfBRoUQlfqo591//X8jm7d47uf+ESfvPIbNPa599EfZ0Z72vGbWrLm9X1BNCnQyJRUVOIcvPbbyaB+JfaSvG2JIWWK2NfQ13WZNahu8sTjrEAPOWMqiwheOmELen1TFFw56MkgAACAASURBVB7nDM4JsWvoNjVtUxOjkLBZ/DuPme0RbZXlYLtGUFw5oVosKOYLjJ8MG6+CGE/fBupNQ7dpSF2dhbozJOuHBLFFigpST4wBjR2XX/wAL/3UP2J646OoJmxV5dQshmbdELuWZnNOCm3+HDUOxGCswRZzUhw3KkdGRkZGRkb+fJ5ZovJrX/saMcaneozZbEZZlsNP0KVxn3Jk5K/A7du32dvbe9anMTIyMjIyMjIyMvJ9R9G2PG4jfVC8tXgj4EyWW6Xj1s1LXH3hJqGPvPXghKOjM46O1pzXEa1r9kUpPLipx1QFRydrvFgu7U5p6yYrN2tw3nJzd8JmE3i8bqmmJZOiAAl86AduUK/XdFj2r+7Tti2PVzXz6ZzU1qhYqtJx9uCQ6f4eiyvX2JwdsT5ZsmoT08ozaWqqticaS0iRCkP3eIX2oGoRSRczg64qs2TpAppHBHNS0ORNyifpyT9b97p9GeQ9V3DQmtk0oYN+sgyVqkN2c1j9ww5SUbuA9xWLheX+4SNe/93fY/+DH2RSlqiYnHBEgAApbxSqKSn2brP/4ssc/+HvISYn/iyDcHMW+oCfF0wXlqIUrDdDclKHFJ0gJiccxRgwuVpUzLZ61Qy1rAbdJv7Iwk6GTcUsBYekpYJRC2ZIJ2pEjM0CtChIMT45loBByAOdT/Y9RXW4ihaxDk0BcTb/3WEPVFGMcSSRfM+sYJKgMb7nWiUgkeol/ck9/KVbzG8+z7o5o6/X2AQpCW3b4bzBJIMOoUkxSsSgMZHaBtNtiG6GEZfvnJKfD8O9FyLFbEqxuPKk9pVcdwuSRW0KaAr0mzPe+uqrdE1Ls+m5avLWqbFD0nR4T0WHjVMGYTsI7iG+muK2nlcJvXL8pw+Z/uavcuu//GfMf/inOPrKl7j5i/+UG/fvkjYPqHanIImEJ0ZHiJGisPhiSgw9fepJdTfsmlro12hMRE0YJ1jjMc6hmqWz9yXWRELfkWLEGI8RxXoHMeTPDWsJKe+XxhhzPWyM2Biw0zm2rEixz1uQ1iLO4ssyJ15DnwUtOXkcVUHzxwlnJ3hf0qvSdw0uJWxhmMzm1NLSbU5p6pr29JCquEw5n7E8MrgEtqgwQwIUI2gSui7LcowlrGrqtsVJymnekZGRkZGRkZE/h2cmKr/5zW8+dVG5WCzw3j/VY4yMvN/5oR/6ofdUL42MjIyMjIyMjIyMfK8s+8TO3oRm2dJFUCvM5iWzecXzL95g/+o+Z2c1b739iPv3H7PZBNbrFtN27BaWKLBzbcH6vGF5VOO9xVlL7APeZbF0WrdY5zg5b7HGUnlH6YTpzLDYu8Ry1ULpWUxKuk1DTIbFZEboOyazOe16Saew9/yLWBs5P3jA6SZvDe7sL7Cxo37jhFIcXQRXFsxmnrTuiMMen7GGPkaqF57n6g++zMkb3+H8nYek2KMm67iUtl//D8m5CyGpw9uz0MyNqebPZi4lS05FQYdEoA6rlyZXyw4LhwhZaC5P1+xf2uHBwSO+8cWv8KGf+HFuLvYGqVdmWaggBFTyZqIUcxYf+ASXP/JDHJ7/AakP+EIwzmCHc652HEVphmSkYLzNwUAz1LxKlmRYGdKk5K1JuThVkHy+WZDm8lMdko9mqM0VyS8Z5y6Em8HkCtOU0BQww3UVCzH0WDXgHIiiKVfiGpGcuERy3a3kylkdKkj9ZELuZk15AtMXw7UO4CySIKEX9yX1LeHxAX6yw+TqTdLqFA7uELoWQ6Ish51Ml/c1k4KRXL26lZXabbDTxJOS2EQu0E0IFnGOyaUbmNkVMH5I1+aLq8OGpaYAfcPq3h2+88qrWGMxsWFSbpOSQ4Iy5RRfTlEOghzyDubwda4OdbDbHVVVSEG4/ztfY/b8F7j5mZ/hjde/wfmrv80HPvWTmN/99xx1PVEsMUG33oC3GFugYkgYohq2jjd1HbHviQiuKJjOS9ou0Ld13qd0Do2BmDpCHxEUMyRwvS/om+H+ljMKl38QQOlJGFKKpC4Ap1jrEBVcVWDLKu+q+orQG8LmDCcGsUIfEmpS/qEB8aSY6JtzfDmjU4ihRTY9y6bjfLUh0mO85/4bd0jfeQ1SAbYkxh5M3o51FHR1TdMlQlSSKCkJECmrisp7xD3d7wGOjIyMjIyMfP/yTESlqvL1r3/9qYvK+XyOc+7imNv/+RwZGfne+eAHP/isT2FkZOR75O1l4vb/+GvP+jTef/zG9981vfM//dyzPoWRkZGREWBalXTnfa5ptI6d3YrrNy5x8/Z1rHPcPTjnrXcecu/uEaFNpC4wiy2XFiWdgvGOR8dr+iRURU5YGWOoo7JqA/NJQRLHpokU3lNVjr3rc164dZlN09EoXNpfkELgfFUzn83xfcN6vWG2mNE0a6rpjMl8Tn1+TLdas64TRgyL3RnRWtq7p9g60UVDcJ7JxOAMdOnJFmUfIslb9n7go9i9OfMXbrJ+eIR2WY7l5BoXNZwXW5QMiTubpZagJM2JuFwVGi8aklDNe4vGDtuWw9YjQ5Hs4D2tWITA+nTN7s5lSm84fPc+3/7il9h78TnmvnwiK2UwhykCFkyJ33+Baz/+GdYP7rK+exfjDcY7bIwYZylLwZcGI9ukJIhYrJEshoYwpHUGsE/CjYZ8/ghCQqy9+IFQGRJ++XpEjB2SdsNjUrFozGJPifnva74OkKWmtQ4NeedxiKiiKT1JupmhXnW7H2oNfjYBBCO5olNizN83Ga63MUKSoXp22HkUlFAvSZvHML0M3uGrEtFICgm1QgghJ1KtYBTUFflxpJ4UldTU2LhB3eIiDZrtqCLGUs53qS6/gPETzLDJyZCmRBOaejT2hPVjXv+d3+Lk3gMWZYFRKIaaWmvMtn04P+/YJljzK/Iht1upZLmr+X3VQEiKnsO7v/FFPnzjOa7/7D/g8F//78w/9uPMb96mvvtdWhXaXjFicWWJuDIrV5PTlbFTUtuiMRL7HvE+19CiuEkJtWJJWGNp6hYNG4pyglibN0tVSBi6NmCMYn3CTSsoPLFV2pjAeugbJAlYg3EGcR6MI5FIXYtEwbpiELg9agwh9hAj4pToCuKmpVk+wBnB+ZKoUAdh3cHUJLTvWR0/zp+TVnCuGj4HE8Y6Yhdo6lNCVIyv6NWSNOKdxSI4Z7NcHhn5G8B7v24ev24aGRkZ+ZvBMxGVdV1z586dpy4O35uo1OGnDkdGRv5y3Lhx41mfwsjIyMjIyMjIyMj3JY/PemKCycRy9dqMmzcvsbO/z9nJhoOTmrfvHXN0eEbqE0XquOQNi8WEybygawNNmyitYeqHnJ0oddfTxIT1ljoom76n8paiMtx8cZ9pUXK67qimBddmE5o+YF3J5aszlidL8BOmOwWbTc3l69ewotTLJWHTslwHrMsibVn33HzuKvW379AlaEMWZ9NqDn2XjVxUYgIVpagq1g/ehnSFsKpxZUUn/dYC5e3IoQZ2m6JUsnzMScmUd+1EhjpMgxGTa0PjsD2p+VgMH2MrAbffW5ChDhYRui6iQFU4Vm3H17/4FW5/8kf44E9eQbzNCUpboCkO4hMQg7oJs9s/yvVPv8OD+jdIXYOxYHrwhaWcOIwfEpLWZflnbM6AiiLWDPJy2OQUixhBjIIMtbDWIUaHYw4JRIb9yKjDjqJ5ItZkqGEVAbGA5o1G45AU0RByetLbnJpUwYghWUFjQjCkmHLlqbH5fVA0RQQ7JC6zJEwhYmzePgTFuiLvXhoQFWxSNPZsHtyhuukoJhU6mUHoiRJJJLzNKT2FQc4aKB0pZnEa2x4XO3C6DVViJKEasd4yv/YCbn4VsSVqXBZi25YfJT/G0LI5OuCNr/4pXgxd21OgFCbLa5789SyVh9/NdstTh6cm233PoZpYsxIdwrus7q04+NIX+MA//u85eeHjPPziL3Pt8/+C9cN3CH1CjeKLvCe6Pag1Hu1bYtugfcJ4hxPADY1fKeKMUsynAHRNS9f0w16l4KzJO49S0ncdYoe61r6mYEIS6JIlmYKUasR6kvEYAetLwBE2G3AG4yaQOpwxqEZCioReSSlXL9sSJpOKLijtZokpLMl6Qsyfl4tpgUtK6HtihBiVtm7wvqcqi3w/my7vX5LTu6nu6DXv6rrpFJGEqyZ07SgqR0ZGRkZGRv58nomoPDg4YL1eP/XjTCYT7NCBb4y5eHlkZOR759atW8/6FEZGRkZGRkZGRka+PzHCdOq4ffsyV67tIsZytFxz/8EJd+6esNkEJPRcrZSpNdQNrHvog8Go4K3gvaGYV9AHjk8aXOGpSk+vQlEV7OC4dmuPy9f2WJ6tWbcds505zlhOlxvme/ssdhccHdxjur+A0LNaNVy9eQ1Nka5tSAjndct8NkWNUqeCGy/con7rDdJZTR8TCZh6Iaw2pJCIaViHlPx7CD3d0Qn0LbFpMClXbQYYxNuQ8tsm2wZBKbrdEIQni4JDsm0QSs7kDTwRQ9pWvr7n557zx86vywE9JQRIybG3W3K66jg+OOZrv/bvuHL7NrtlBeIwpkCMGxKVWTSCQ6bXuPTDf5f28UPOv/0qtBukUCbzAlsYxOX0p7Fm2E1MQzJQ/gMRafIv82SD0wwJQrEu19RqzOegERWHGEdKAWtyilCGbUXjDBojKZKPK5LrZsVl4aY9GnKqLsvXAMYOl3TYbdzW3RoDUS/qZcU6iJGUItbl9zd2yCDGHpG8cakxYIb30dgTNmeYosA6Q3QGKxGJDAnIIW9rHImccPSlJcYAUaGtkTKhYjCiFwnOyf5VqmsvIcVskLIAFmGoc009xI7QLHnn1T/inW+/ycIbzpYNEytYyTugaSvIh+eH6LDhqToIyWGTciu5hyNpVNTmrdMYFaJw9MrrXP7oF3juP/3PeONf/m/Ew2+y+5EfI3zrK7TFFFuU+Vp1NdXOPs16TexDrj7OZ47zZU61WslpT0BDS9BEFzXLcGfz59Ow4xq7FlcOzxfJgrY5XxJdQbPpsU5x0wUae2IKw56qpesD9abFFZ5iErHWEKIS+56AQWOPdS4LclWozzF9jVioN+fUXZa6E2ewzmJ8Fs9GBbwjdR1N2yIitF3gdNNgrWU2qQgozhVZjIqSQqDbbGicJ42TMiMjIyMjIyN/Ac9EVB4eHtI0zVM/TlmWF3Iy7xGYp37MkZH3G2OicmRkZGRkZGRkZOSvxuX9CTc+sM+NG5dYnTecrDY8Olpy+GBF10R2XGJvYnAW+mRoSZx3wg9/+CNw/w2adct0d8am6eh6pZyXHK0TxsNsUXLj1g6X9yqcOB4+XBIFLl/epY9K3QYWu3u0mxVHzYbLt16k3Zyg1nJjb496vcYUEyaTXWR5zM0PPE8SR1NvoO747qt/wuTeY+Y9BBWsM1SlgS6iCjENlaA5R0VqezbHJzSnZxhr0KSkkC42ErdVrxd7k5rYTlXmRKTmdUl5UsupQ2QyDguNMvw9MWZI4uXWpOGtIOCMYARSSNy7d8zLn3iOw+MN5+vId/7gVW7/yFf4+KXLVNaj4qHM+5Sa+ifyUyzu0ktc+eRPo5sTNm+9TuEMrjKIHTYoVZ/Uv4rNMmmocEWyTMRYZDjHvA2ZBW2OnW2je0N5rRmEpzWYtE07DjWtoojxqIKVoQpWA/Rh2AAF1OTtSXLCUzVlqWtyrS5GniRHEcS5XKMaFUmKWIu1ZtgKTflj9AEjFrE59Ym1uYHXF3lLsq/zQxPBOUdMEVtYUkgILstlk7dDEQelIXYRjRHtGgzpIgWrKG6yYP78R3Dza4jxQ0/wYOlQSD0aW2KoqR8f8M3ffoWu6Sl3prR9Yr8wGLOV3ebifopkqQy5qvRClqte7F4+keP5aZWGWKUmqJeJd3/zt/jIv/gI+3/rpzj84he59c/+B9bf/QZiEz1C6hq8ga5esX1E1hekOCRujSFpwKpiRUgqtG0PBryzFJMKa4eKXRFUHCn0+Xyi4obnSt0GJApoICWLFcUUBdpFFMNm0xOTgq8wNtfkRhX6IPRtDyJ4Z/GToaYWGfZOQSZzlqfnSOiZTSeklGg2Dd55Cp8lets0SEpIDGjfgrX42Zz1qqE7W1KUJcXUMZ0WGOuz2I6J9fLsiQ0eGRkZGRkZGfkPeCai8sGDB9R1/dSPU1XVhZy01lIUxVM/5sjI+wkRGUXlyMjIyMjIyMjIyF+Rj33iA8z2ZpwenXK+CTy8d8z9h2vWdc+EyEwsqo6khrN1T28N1yrD8tvfoCwcxjlOzmqMKN571slSTAKlRK5dnfDic/vce+chZ6vAdFKyszMldBFbeHZ2FyyXp7iyYHdnh7ODd6kWuxgHm/MzQgep3ZA2h6SU6JKyd+MG/VlPvVqyC7iQCFEICSalZTKpaNtNFiFA0DQIRehjyHWt28nBJMRB0pncu4kmzVJIsqzbiqGMICZXc+qQhtsKpCFO9uTCDqm4ixjlNpGpirN5PxJR6lWD2IIbN3dYvXnMZt3yyq99gasf+TC3fmSCN4JYD64C4yF2w6kYsBWT5z7B5R87RdcrZHOA9e5C/OV60ZykFGNQ0iAnh/Makn2CAWNyvaoM0jClbafrkKrM10iTwFATq2FInQoXe5w5SZqGhGoCZy6ug2x7SwVUA2Lc8P2QBBrIKtfmBOewLaiatyhTihhyNahgho3MQZiZrSCWLDC3sskoxBbxZU6PWrCFz7WsJg3VwIKmiLUFanJtrHMuC2lVjPYoLtfjimXx3Ieorn0o3w+xwwBo/uFzTTFvU4aGsDrmna/+Ea+9+jqL0tE1PZIUbzRnL2XwvuRkpBlkbhoerwzXdPvsE7F/5p7oUCssVkgxp37P3j7l4Au/zrW/94957et/SPOtL7Pzw5/h9I9/neiVFCN9H0ltTzmfY12BkYg6QaxBEawKhRNCiDRNFuPOW+ywVyrWItaAxuG88vUT50mpp287QjJoVKxz+NkCQ6KoCqR09E1LjBFXesqyBJS+C7RdT9dFLAIpEbseaxRTTPLnZIrYaoqLFlsusLIkdi3iPSRDaDtiDAQMSR3OAljEGLz3TFxJNVtwcnSS5WrsKeyESERTIqhFokHHlrORkZGRkZGRv4BnEjE8PDz8jyIqvfcXorIoCiaTyVM/5sjI+4n5fM50On3WpzEyMjIyMjIyMjLyfcl0WnHwzkMeHZxz57UH3L23JHYdz+94ru9MULHUUTheB/zU89xuwUQCVqCJsNx0WGfpjSFNKiYzy43rU17+2Ae4cf0S9+8csa4TuzszptOSuu4oZzuUiz1WzZrpzg4WePzgAbPdS5A6YtPQNIF6tSGslvQhsGk7qvkOjw8OafvIpWvXkJMzTBL6lGVkWVrq5YoYY96TFJObUkVISWHrplIipm315ntThlkmbqWbDrJxm6pkEJwpJrJPUoxsrecwZMh7/vgezNAFq2iWVNutyhB58O4xz33oFpPKgYH7b77NK7/8q5zfe5vQNKR+k8We9YixXHybRCwUe8xe+gku//jPUl6+hjiHtRbrwHjBesFYg/G5ctM4h7GC9Q5jtuIpe1YjWVgNcUuG/td8XOvAFBjnh61Khy0n4Ip8ToO0E2MxRZl3MH2JOJ9Ta9YN1bOa5R5mqNQdRK8KhDRUig7noAx7mFlmquakbEqKpnSRfhXJ+6G5otaAcVmUakL7ntSu8jZi4bHWDjuQOVFqnbuo8DXWYJxDnOT72wckdYgkRITqynXmtz+BmVxCTAFmqM2VoZ41BQgtqV9z/uBdXvn1/5fNZk1lDXXXU4pQ2JwqFcllwvZCUuogurfPoeF1Q2OwKBep34uEcEyk7DVRFVInPPrj1wnn73Lpxz/D8e9+mcVHfwBTXMKEDlJCk0GblrA5x3gPVrDeYFDKaUE5n5JEabpA33ek2GPIB1GEGHtUE1EhxZCVqSYQQ5sMXchvCzHviE6mVZaUBvAVIRpS32N1SDIbSxehi0rC0IVIECFJQbtp6OsV7WZNUiWZglCvmfiELypwFX3MFcCmKFh3yqbpSbFDUySoErH0mmuDjXGU3lH6nNJsmoa+61AVFEOMiRT6v+Z/YUdGRkZGRkbeLzwTUXlwcPAfpfq1qqqL6teiKEbhMjLyl+Tq1av5C8ORkZGRkZGRkZGRkb80d9454uRkycG9Yx4ebzCqXJsXFAZSiiy7yEahmnpmAiYlduZVTnGliLeWRjxalJgUmM8LPvzRF/EOHt49IoTIfD4Dk9OLl65ep9mseHR4TFktOHt4gCZl7+oV+qZGxBCSkhSq+Qys4KczLj/3PCdHx7hizv7lPc7v3oVlT0hKHxXvhLIcxKQdEmIiRJSYslgU1RxK021aT4d61yf1mtY8mWYZTFgWmkpOAw47ghf1r9uKzvxOaB63HGo6B3mpT7YsGSZfnMDWfB7fPaZYLLj1/D4i0Cflm7/9Ct/6zS9SHz8gdTXa1qAG/DxXjg6IGJhcZvbR/4TFD30Gv3MZ4w3G2kGiWYzNaUbrHMYJxubXGZtTl8Z4xOV0Y96rHFKVNv+ZQWIyXK9cNxrRGJAUIHQQAxJjvq4X18nQN5GTkw1KTuyJdRhnsc6B5PrdoXc1iz8rQAIZ0qnDnqckvTgXkZywVBGMc1laWocdPraYOCRHDeJz+k+sXFTDWmcHUZu3J63zWJOFtXFD/W020vlxAX62+/+x92ZNll3nmd7zrbX2cIach5qBAgooEBwkkSCpiZKooVu27GD4QuHwhcNhR/hnOML+D/adL9wKh91qq9WURJGS7CZFSZwlUuKAmQAKNVflnGfaw1rr88XaJwuSqGg3SRUD8H4QQFQmTp6zzz47Myrzyfd92XjmBbL1S4gtuqFRC9hOnrbEUBHbBc3kkNe/9HVe+fbrrBQZ2kYaH8ktODlTkBgxZ8I6CfVOU3b7lUqSsiGCEt5xtaUb6Ts/oLs868OGB1/4EzauXSTYNWR2wOov/JeYNqDYtEfpcnzdEqo5zmVJXrskK2MM1E1AQxL/xaBAncNmFpvlmM5qS/Q4axFjiVFoQ6AJinVFkt/GpnPaRXGr+YKQnnSXFDUEHwlqmbeBuo1dQjb9Qr8rB6jN8K0nqmU+nVBNT9GmwoolhMhiUdG2SogBNY68KCiLDFcWSD5AsiHzNjCfnBLqGm0WaFsT2oa6rZk3aXuz9RHfNgTf0lbzH+vX156enp6enp73Do+9+tV7z97eHk3T/LM/1j9MVI7H43/2x+zpeS+xu7vbb7v29PT09PT09PT0/JBMjic8vHfCZFqzMcoojeAVsnLA8WJGPiwYZMJi4XGlgzagmTJeG7IIkdYHMt9SliXbl7Y5f3GNB2/d5vi0Zbw+xgos6pZ8OCAvCk5PjyiGYwa03Lt3j+sfeD/N0QOmx0e44YjTkzmD0Sqr22scH+yx++TTnB7tsX/3Lpu7uwTgdP8BZlIRg9KEiIhlvFpSDBzzGQSvhKj4riozdlWkdHWiKa+WxKmYJLBSSi8l1USWSbaUlovI30tZ0slIlgJz2fy63HJcThYCZxJpmQAkyRtn6ZKAQtu0HD6sePYjz3H71jGzeWAxr/jap/+E9Qs7XPvlAeWmQaxDBttIvgKtQvBAREyGjC4weO6XwRia738VFqepldQ9WulE5Gx/Ujohm3pbLYJPFaqPbo367n1Gz54qKBp8dx8m7RMqaIxoCOl7M6sp/WjyLo2oSRZ2W5kxhPQaGDA4YvRJ1HXJWBC0e12N2LNzHEObNjVNOuZU85qlt9H0ti4ToYIR26X9kgAzXaRWOmFKBA9AqjHFJBlqrMWVtkvFKrYcs/rMhynOP4e4UdqyFNNdT2mLUUON+ppQT3j46st85bNfpA3KytgRFg1VE1grLLa7dpxZSkrpSoFleemk6/CsXviRBEeX26h0prNL/MqyVhhiEI5f3Wft2W+zfv1D3P2T/4tL//3/zPQbF2gnD6l9l9rUmFLHLgdtcHmB95G29UQVnBVclhPEgXO4rMQNV6gmx1iBaCwhBoKaVPWqJDnpHFmWJLcrh9ReCT5QTReMbYbLHJiCECKVXxClxdqM0AZiiNjugorqwTlEMowdECqI3pMNBuTFkGrviHY6TzWu6ihHlnxYEKOmJG82Yjqd4qwhYtGqJjYt1liqKtL6lqALsiyH3NP4gBWlGJY/ri+tPT09PT09Pe8xHruBmEwmHB4env2l8J+TdyYqh8MhGxsb/+yP2dPzXmJ7e7tPVPb09PT09PT09PT8kNy5d4pvPFc2cwqNzOeBJggPpnPKYcZaFok+kFtAI2vn1hiuFMzdgNY5yjJndSPnqeu7bKxYbt24R6WOta1VfPRU3rNz8RJOhHlVs7W7Qzs7phiW/PQLP8Xk3g1OT2eQj6jrmrIYMJuecnhwwMbOBfZuv433hkvXrnH48B7Hew8RMtrDGajg1ZAVljwTmklF7ARlWCbSOoOTBFB6zoISNSSZqKlOU2PohFF8JCQBH7u6UdVuF1BSAPDMKunZBmb6mGUta6rjNF08z5hU+akkN5hZS5FnZ/Ly9ms32L5wnp3dIcaAimF/74gv/Z9/yL0Xv0M7OSRUJ8TqCMQh2RrYHCVVtKpxyMoTDJ79VcrnPoGsbIPthhCtw7gs1Zwal9KmGlAiKknMqgIhENsKDS0afUqbaoTQCbEQ03nq0ouaOkcR0u2EJAVjaNHgCc0CJ8raOEsyL3piW0P0RPWpbrXIMcUA3JCmSSJT3lGHGlufHJ1ZJj274tMQk+IL/iyxKtadVcsa67rkqEspTuMwWYZYm2SlNYg1WNvtjhqbEqXGkGUWl6VKWOsK1p/+GUZXfgqTr3W1sgawXRerR0MLoYXYMju4z99+7gu89dZddtZyxHuCRgyQGVKSVRRrU+o2JXtZ2t4zUb6sxF3W1GpcXrnaFb+mCykur800FEoIyuK04cFXvsloZ0Rz8w5+/7usfuiT5BrQLmFsckdWZsnfuxJTDFGXE1VxzuDKMon3GLESMc6QOSErnigcGgAAIABJREFUcmKMXdJRCMYlzZvZ9FrmrpPiDslyFt6zmC2S3GxrFGgbT9O01POGZjHFETtxGrCZwXvPbDIjtC0hKsZ4hqtjTGZxuSMfDBmubjAcjhBboAiL+Twln/MRIQTUN+TFACeO9dGAYVGAtkhsUbG0tWd+OuPo6ITJtKLxvktP//N9re3p6enp6el5d/PYReXp6SnHx8eP5bGWg+SQROXW1lYvXXp6/iM4f/58/znT09PT09PT09PT80MysoEr5weMVkoy5wgCZIbSCAOjZEYonWBzw4XLm+By2vE6ja9ophUrm2OeenqX6mTCrVsHqC0ZjgcsqhpVWF9b4+TgPm1dMTSW+zducu6p62xur3Lv9ZcYrZ+jqhrmiwU7l56k9jUGYVgW3HjlVawdQLXg1suvsLK2jrOWeu8QW8e0NekjViOZWJrKEwJdzSiPtgPlUQ3sMg0pyw1GOsG4FBTSVVOeJSWTNLNCd6+K7aRj2kPsekLj8oymZGYKccrZfas++rMgZNagPpw9/unBMXdvPuDSk7sYSam3KMLN77/Nl//177P/+qv42TGxOkLrY7AFUmxgXNHFNw1Ijlm5THntVxk894vYlZ2ucFWBgMaQko2kylhBkKhobCE0qIau/hU0+LS/iZ4JySRqLajSdluFaKpA1bjcV0zP3yzTkFFTparNUtqxS5sajSmF2bZY09W9ugxXjLDFCFyB2AzriiRD1addx07qiREIoZvRNF1iMqX6UgJRk09MZafEGDEuxxhJ9a7WvaOK16b7MZL2O4uCLM8xgyErz36E0VMfwww3weRdknL5/WdIQjfUxGZBc7rPa3/5Fb70+W8wLDNWsozYBhoPFiEz4MyjXU0xkhKsUc+uRZCzhGSaNdWuNngp81I6N8QuBSzv3ENNQjm2kdPbx7ST+4yf/xiHf/avGb3wSYwMyDLIV8fkoxVUHKoBiETfkJUDitEq1mZEVbwHYyx5URK8R2MgKwZEFRofmFctTdOmCt4spxyOyIYjohjqumZydEQ7X1A6KMqCalEzn89pu+s+yyzRK2E+IwuBwkQIgcUsbYr61hPaFt+2hOgZDocYlxN8i5VIUZZkRY4brFB5w+R4yvTkGF/XaFsxygK7l85ji4LaN7ResQJr44zx1ibGloQIVevRKAQVqvrsE7mnp6enp6en5+/x2EXlfD5nNps9lsd6p6g0xrCzs9PvVPb0/Eews7PTV7/29PT09PT09PT0/JBsDh25tewfLDhuYWNnhYFRVnPDqLSURUYxGvDkMxcJWcnBvGb64ADTRq4/f5Er51a5f2/CSRUZb6wzGDjaxrOyMmY4GnBycsra5mba2ssLrn7weQ7uvsXd2w9Yvfgk92++SZ4XbG9tcHDnLhIs09Mph4cTzl+4wP7d2yxOT1hbG3F6eAQhIqdziBCjYJ2hLHLaqkJVCDHVfIokoROBqCkFaYx06ciljOgqNruqUOCs4nUZtzyTnWiXvAPRSIxJtJ1ZoqVn0uXjK3mep5RcMk5JmXUbhZkBK2d2FKJy46VbXPvoB9neGp7tD3oVXv3r7/H13/s0R2+/jp8fEeYP0foQTAHlFrhxt/sHKhZZuUR+7dcp3/8vMBuXEZcWdcSYRzuTMSRJZUgCTJLkW1baGpuh3fGpdkLQGDR6xJjuZxmgeJSYhG06gRhru7dj2pwUSUJPwNrsbDezqWraxQytF1gaygJUPSoWY3IwGSbPU92r2K7utRPHLgObEqIaI9IlHcVYTJYjxhF8SsMaZ7E2pR/FCOIsWIOxButcEs9o2ow0qfaUYsjaB3+J1ed/A7NyAbGDs11KwQIKoUV9RWzn+MURt7/7Lb7w7/6Mk/mCK+dWaOc1okIdun1KazpRnWQuQjrHYrprMl2f2snsqMpS/5ru9RWS7Ex+vNvuhO5aTB8HAq2w/83vsHb1PNM33kKndxg+/+uU1Tx9vEsp2xgDwXvaRdpvtCbtfkaNkMK4hLYF4wgKtVeqxtOETu6rYou02akSiQomczRNoDo9xTYTjAQQpW081eSURd0wWzS0vklHGwNFbtPndOsJPuB9hStyfIj4piK2nqaq8PUC/JzCKcVoxGC0wmh1yMruJbzJEL+gbRqqxZz56QFlppy//gHGO0+DG3SvryHPM2w5TOcrKr6NzGcVTbX48X1x7enp6enp6XlP8dg3KquqYj5/PAParhusX3Lx4kXW1tYemyjt6Xm3s7Oz0ycqe3p6enp6enp6en5InDhuP5zR2oyN1YzYeMZDRznIiAgGQ+5yjo6nzOYeEzyrG0OevrpLqCru3D0muJzV1SE+RKJaNrY3mRweUm7ucP7pDe7e+D7nn3sfw9UV7t67x+jJD+J0ykt/83esjbdAW2YnJ2Ayjo6O2Tq3iyGyf/8B49EKoko1rVkZjChKy9F0TghKUKUoLE5SPWn0XaKMR9WtihA1dAlJ6UROV9fKox3AJPDoNixTg+iy7tV232/IMoEJaaMxvTPt4tl3bApKSvj5tk2PEfVsCxMRRNN9OpP8qCfVf9578zYnh+/n+k8/xYN//xKtpl3F4OG7X/wGg9GQj/72p1i7ei3VgqpFRttIuYlWBvHTTowqMjxPdvWXMOWQ6o2vw+EbaKjT0YsF9V11aUinxth0TowBNWcJSTWKOJueg2oSgl2SEeOQTgaL7ZKr+ki+irh0XtsmyUaNqZ6TJI+LwQAxEGNI26fWIK1HmaPa7Ui6JCsFQWNMlb3WIRogeoidGEWhS8kKaRPTOMcyoYiCdY7oY3q+GtLz8hGxmsSoTfWvaktWrn6U4ft+Dbv2JLjRWboxidz02DHUaDsnLCbsv/Eqn/8/PsMrr9/hfU+uU+aGSesxKiyayHppsSbJcmPTC588X7rGltdV57TR5M/eUfuaBDjdrmVK95p0odJJZFVCV3McI1T3Z4SHNyk3djn4/P/K1r/4Hzj52u9REoiSPn+iJtluMfhqwbJe1jibkpFNTZ6D+Jpm4Qn5KlWATCyI4KzFGoN1lqiapGebjnM4yLDGECKEVmmjUM0X5APBqpJp+tzwKCGkzxXjHGILbOaww1VCmKKxpa4bDIJzFucskRbjAjY3BO/JR8LK2g710X2MgbwcMZ8teOPl1xhtHuBjhteUdLYGbAHFcICqJwRPRCnynKzMfyxfV3t6enp6enree/xEROVi8Xh+i+ofCpbLly+ztrbG3bt3H8vj9/S82+lFZU9PT09PT09PT88Pz9sHFYO1ks3M4qsmpeXKDB8jonAyqWmkwhhDnmVs7G6yuz1kcjxh0ijDjTEiGS3CcHUNfM3+vQesra8R6wU3Xz/g/BOXOT494WhRY8shJw9ucP/mbTJTsJhNcOMB9aJhUc24eu1ppqcnHB8dUxY51XRBMSxBUvpvtneIVEpAaDUyzhxZbmkWgbisBI1JRIbu31TBCqJpE1A6ySLSVZUC3eBkqiqVdDuMQR71ahK73UAlCcellOvmFDGkHUU0YpwjeJ/uWbrG2U6aRVWMQOEMpvWYCBGD+shLX/kuH/zoM2yvv8mDgyo9DkpVN3zjT/6CqMrHfvtTrF19hgzSQuVoGxlsQG3RZkLEJ+GVr2MufJxBsUHz9jfw976H1qfIchdxmSbVkCRfVy2qGtLzFIuophQlBlXTiUqfTBgpVWqkK5hV6URaSl7Svd9kWSc+H1XtGtJ50hCXjbHpdVuer24bUySm2twAWIuzLslOk+GGGbFNx2Kc7appObs/kZQwRQyYiAY9S5WKc8SmTv/LGWIEcQYdrFNc+SjFU7+IWbmEZON0jmIAOhEbAzE0xHZBWEw4vvU6X/q9z/K1r3yXnbWc55+/yFvfuYWqUgXFALlVnIBBUoJTkngVlX8sKrtr6+zbXOmsZbeDGrWTr93z1a7/VZb1td39+Xnk4df+ltVrzzD79ivY/+SU8spHiNMXiVnJvGpx1mCzfLl6CaI443DWUFc1UR1gCL6lms/IVjOMy/GLU4pygCvyJH2lQJwjBMU5JSsyjMloAsQWIp6oEZeXWDEUWZdLbReECLGuwDpiW+AyhxVDOz0htA0+KjEtYVIWWdr8lFQnnI8KwODbmtwqoSyxtBgBZ3MWTcvBgyNcXmJi+rxrQ2QQlcEgw7kxTYBQLTDWpBrgnp6enp6enp4fwGMXlYvF4rElKsuyxNpHfxF64okn2NzcfCyP3dPzXmB3d7evfu3p6enp6enp6en5IdneHaGLislxnWSPbVk1OU3jqSOsX9gkqCGGwNpagUN4cDDHFQUbu0OapqXxgYtXn2K6v8fJdEY5XuXgZMpoa5OLzzzL7Tdf5+bdkyT6Qs366gYb4zVmxxMGK0OqRU25tsmV5y7x8MarhNpjESbTmpXxkHKQ0TZJMISjCdIJwSJLFaq+bolRzupXY4zoMm22TEi+85cbRbHOEaJPKUl9JCCXlavdzc4qVUExIvgQU6Kt27rUpRVbpjG7GUzftJ0I7B67q5BVjWkHMioDZ5KwwyTJCty/cY8nn3+K93/8Gieff5FFm7SjRVgsar75p3+FKHz4t/9TNq8+ixKw6jGjczBYR2wOzSkaFun4sxVk5wPk5TpmZRd/52/Q0/vgm7NjxVhiDN056hKHYlOlq0iSad1TWErK9HQMS32bzmHatBQxKegnSfBpSBFBDRGxJklOY9DuedvMoj6dY/UtYrPuwNIGqekEnbFFuq+uqlfEYYuS5aJj9+qRtiOlk5WKELrjN8n3iaKhwWBIE5Fp/1FWL5I//fNklz6CGWxDNkyPpSG9zhpQ9eAbtJ0RFhOObr3OV//NH/Dv//TLiFU+/rGnULXUs5pC4LTx5EbIjeCki9B25ypqEurpWlrmdemOOyVvUw3sMgX66BJOO6DLOtjunChkLknQ6AMxKouHE0YbDwlNzfylP2f0wm8y+8KLqHqyLO2ISmiBVJFrsiwlRzWQ55am9jRNg1dlUXkGcsJwvEmrJXlZEE2q4w11RTNN9+lcDs4RfJLTPkSUwHA0JraejAZjDbHx+KZGnGBcRkDwbY1oSz5cp1XFNy0GMF3Fbx1aJDNkeZGqYiX9XK2wJTEKIUQkLFAN2NxBY4lNxez0hGFhcdYSo+KbJtXMQtq5LDKISmjCD/ultKenp6enp+c9zmM3EE3T0DTNY3msf5gE293d5cknn+zFS0/P/wecc2xsbPykD6Onp6enp6enp6fnXcv0cM5k5jHOkpcZGysDZgvPcGuTjYsXCCrYzHFuZ4xKRpUNGW6uMxoXLKoWyUrOX3mCw7s3mU+nGFdwXFWce/pZRoMBr37vRVxWsjYsMD5yYfcca4OMxeSUwXhAUzfsXL7I+mrG7Zf/DuNj2gE0UJY5LrcY67DFiPMXdjGLmsxZmqZNe48xolEQY842KIVl8qxLmbHcZtSUpkQJbYuGSAwxSTRRxADS5dskSbczEYmgEUyXZEv/dPWoXX2niJx9jy+yzLWddXd2P93oUp1WyK0hFzCkWlVF0RB56Rsvcum5Z3jq2nbyWkCIildhvqj46z/5S77xu3/A/qsv0hzfJ0xuoZPb4D0UI2Swg+TrIK5Lf+aY1avkT32S4vn/HHfxpzHlOmJd2nN06RxLV42bnmHs0qEeMfZM6GoMy2nCtF3JMkUZicGfbSSqpF/IjmfpRnO2A+rV0OiApg2phjaCWIsx3Vao6VppI0iM6bW1NgU+VdHQEtuK2C4gtsSoYG1Kq8aI2BxxWXef3aCjpl3Itm3T8zQWrCThmuXYCx+gfP9vkj/x85jhTuoG7bY8JSZxF6NHfUpS+sUpx2+9xld+99N87o/+ismi4cPPn+fq+65w/+YetBHVyNQrAydY29W5xojGR9XE75hATbK8q2PVZTq4S/EaEaImxxu6PcoQIzGE7jaKsRBDJPjQpYpTmnF+eEo5GnP4+T9k48ktJFslJ6VlhTYlizVgJAlb3zQ0i4amqgkhUAUlqMFlaXM1t4ZiMCQETeLe2pRsrSq0rgjVnLaqCK0n+hatZ7SzCdX0mExqnAmMt9axK9upFjZaopqUtLTCoMjQEAlVQ2g9Do9Rj6gnNjWL6YzZbMZ8PqNdVIS2oqkr2tkhg1IYrO/gbUHtU0LcZUXar21aDIq1llnVMq/q9HlVVVgCuROKvK9+7enp6enp6fnBPHZjF0KgbdvH8lhZlv09KWmM4YUXXqAoisfy+D0972bW1tbI87yvfu3p6enp6enp6en5ITldRCKCNUImoEXB5etPoFnOw9M55bhkbew4nTW0MVBkhtxl1B62LlykzDPu37zJYHWd6bwi5jnv++DzHN6+wZ07e1y6fJkQPOONVZ577iomNIQ2oCo0bculp5/AV1NO9x5QlmNmPu09GomMVka0rafyEbWG+6+9wexgQdv6VCkqKY0WVfFnNauafoogepZAU41nulFJEiiiGGMRUnLQFY5zH7/O+esXUgqvE4TJJ8VOSy4Tksv77XYtkbTrCIBJiTJJUtNAl3zrpKl0aUxVMmfJM9u5uXSnEWV6cMxrf/cG7/v4c6yPc2Qpnbraz6qu+NaffZm/+p1/w4PvfYfq+C5+codw+jbUczRzyGADGWxjTNl1qVoot7CXf5H8A/8F2fv+JWbrKuQ5KoI4B9akvUZnMMYlQWm6kisNoAGxaQey69JNH4OAGEyWzqUS0usgXVWsJPlojAGNWAOEirxwuNx1SdSUZLM2S/WsMdLUbRJ42iU7LWDAlgU2LxBjiSHQLCbpzIkhLhOxMaT0phE0eLwPRCJ5/mhvVIyF4Qb50z/P4Gc+hb3wM0ixBibVnaLSSWiPhhZChfoKvzjh+Ob3+eq//SM++wd/xcGs4cpWyUc+dp3DhzOOH5xiUBY+nabCdJuOsAzfEjvJqF3KNsZA6N4+E+0xppRf7P7csfwJkqBp87L7N91P0uhiTSeThfq0wgwGNHcPmX/ns7B6iXB80h2MsnS50Xua6YLoG1QjTau0MW2WosJgNMSVY3xUfBAWVUVd16j3xKZNqVQMbV0Tqor5dMrk+JhQTWlmpzy4dYtmOiGEwPHeAbOTA1oVQtsSmhoEnOt2QkVpFdp6QT2fMz05oZotaJuG4JXFZEE7nybRCgyGQ5zLEGNTglPTdqxFKcuScjBIScq6QgnkmcVZIRdlmDvKImc4yBiMyx/9i2pPT09PT0/Pe5LHXv0aQvoL4uPAdr/1905eeOEF8jx/bDuZPT3vVtbX18n733js6enp6enp6enp+aEJIeCDQY1huLPG6saIB3unHNeeJy6soz5wughkwwGr4yGT+YIYhctPPcvpw1tgSp547jluvPI9Ni5cZvvCNm9+70XyYsy4EB7efJuV8QrRt+wfnTAej5hMZgzXN9ncXuPg7h0GZUZQSxuEldWVJG+MpWoaxmvrVNMJ2lbY2jMcD2mnFaAUneQKIaJqMC7VOmrUbm4xAgYxqbq26zntUmxKCKmGFRG8V+qZJ7cmfZwu9+pSTWeSS+HsF4016lmN51ksLiad6ZcROSRtBnYjlcvE39KAOgtDJ0xa0sfEblswRG589y12zn+Yp5/ZZfrtu9QtZzOaYGjawItf/Q7NtObn/6v/jPM/9dOUKPgas3IRhutQjsDmSD1B2ynQAhlm/TrZYAe7/iTh/rcID18nzva6BKXFiiFqQMQSJSKRlM706RyKA42CEZuqXTGIdUgMiHUQOzEctUtJJkEZ1aNisEYwtkvzeddthQoYi3Yvk3MWk7mu71TS/Z6Nfab0amgDGlMNaAwNJh+SGUFjAG0RnyR8DIFIhsY51rpU4epKzPoV7KUPY899CIZbiOQpzXu2pUm6bWxSmrJZSsrX+fqnP8Mf/9Ffsl+3rOaG569uUYwHvPad1whVQ4ZyVCuZSaLSmq6Gtqtr1S76q90manpn96Dm0eMvpaV01bC6rIjVToR315dqqtcFumsN6PZQfe2JoSLf2OLoa3/Byq/9Nxz88V8jw5KszHAuo2kC9WyBxkAUTxBH3SZpKia1GdnMQlayqGoWszkaGsosIxjBty2igWo+AxW899TBEJqabBCpolLXLe1iQZZnYAXnCtosx88n2CxPVcoCYg2mGDDKFA2eajbndDGjcN2WamzJigIJCm0k1i1BT0GVpmlxhWU4GqII7eSEsJgiqkRjqNqIkZY8F0prcURcZhHSJifhHf26PT09PT09PT3v4LGLSu/9Y0tUGmP+kaj8+Mc/zvr6OicnJ4/lGHp63q2sr6+TZdlP+jB6enp6enp6enp63rVsjR0rGwO2Luxgcsvd/QXlsODa9iqzeUNAWNvcxGUZs/mc0eY240HB0f1brGxsU8+Oufndb3Ph6jP4Zs4b3/omK+s7HOwdYJ1lNBqzd3hKPhyRDccsQuDcpfNU8wV7N2+ysrnBbDbH2oLcCZOjY1w5whWWwjhOj04oC0deFuwd3OCJn/k4t7/+FXIrjFYKtG5SiixCiAGNsRNaj3YL6XYll9IHup1CQCUl1dR7Dr/3Zne7lHJcfqcedZmETJuX+sgEpfvCICYlOFWW959uI12dqUFSJec7amBFDIPSklWelq6GlCRa55MZL37tJZ794AXO3Tvizv0FPi7LZtNmpW8jb3z3VRbTOb/4XwvXf+sa0c/Rozew7XkY7UKWg9tAmkHarvSLdAj5Jubch5Hxeczm9wkPXiQcvAnVUXoElW5P0yEGYvSIOFAP1oFJAtCIQ7rK3RThW9bhCpiUr5Soqd5VHEQgStpDjTHlVEVQlSTyXFcdqymJqkaSzEOA0IlMQU26zxgDBoeIZTGdY8ThxGONRTuBbJzDth5rM1QMWm7hLn4Qe/HD2NUrqBt2yVEDmEcpWg0QPBoatF3gZxMOb7zC13//M3zus1/m4axiYC3nR47L1y5wvD/lwdsPsN3znzSBc4XFmuV4qmAyeSRc9R9IsS4MKp2gXN5keR1qJ7IxpDRxd5Hq8rZdLbHoo3JiUUGjUO+d4oYr1HcPKbKAG26gzRw7WKdtGnwb8U2LJ2LyDDUFRioQxWUGFcHXAUJNPW+oFxWjwtHWDfWiSa9XKgBGxRCCgkQG4xGBhkEeWL80xlpHVQcwkeH6mGx0mfnhPtEvaH2gHA4INsNXc7IsZ7Q6ZLS9iz48oZkcYCxkIpR5gWhEQiC0NZDRRsFZh1WPWMvK6iqhHFBPJ8h0QojLz//0OeYyg6/njLbWyNcvMj/YI9azH+GraU9PT09PT897mZ+IqHxcicqyLLHW/qP3ffKTn+R3fud3Hssx9PS8W9nY2Ohrknt6enp6enp6enp+BLavbLB5bp3T05aT04qtzSG5dRzNGmyWsbW1Tl3VzGaec09coZkecnhvj5Xt8xzt36UYrfLsCx/h1isv47Kc7e0dHtx9wGC0xmg85ODwgJX1FWIEUwzY3Vnnwc2b+BYGozHzaUVRFvi2JQSDsYbR6pi2mrKYnLC6uUk1X1DPa3TRcPTyt6lmC/Iyp53FlCZDwdi0/6ddraaYrlLUPEoiyqM/Lrf/6NJqyrJ+VVMCkK5CsxOISVRajDVE1U46dokzSduBYgRrTbdBGDHGdmlK6TYvQ5KMBmyWNgJLlyooTVCMKirS+b7I4f1j7q0PuHr9ItX8JgenLT4uZaAgCo2P3Lt5l+/+6Rcp1tZZP7/CeOc8eagx7QwzvoCUK2g5gKxAmgXaHENIv5wtw/PYYh2zcRV79AbhwcvEo7dhcYjEBjAQA8YWSepqep5RIbP52TnXtu3OZ9qUVEhJTI2oMUgmaIiIRFQFjRERg2QOQkgfaw3RdzuX1qIxJTG9DzgxmCxJ0eBbiClVOhgPaKsaEwVfBaAhH2dojF1lasAYS/AgK5tkO09jz38Is3ENKTa6alq7NH3QVQOLhiQou03KerLP3qsv8uV/+1k+/4VvcrhoyJxhIxOuP73D2vlzfOerr1DPakaiHDcQEQYWXDfPeSYPJb2+xtpuIzV2m6bpIo1ot4W6lNfdtWhAVLHdFqpq2vBUMd3OpHTyvasjhpTybWG+N2e4ocQmMn/zawyevo7bf5O5b2mrlhAgBKVFcOqwdNeyKhKUKIEmKlpV0LaMRyUxRHxTpd1XMfhuLzSKpa5rVkYleZ6hIafI5iiwqCpUoMgypgd7lGuecnWN0BRnu68heCxCNZ+hxjIcOIbDnNxtoG3NMDfYbEBsW5pY0wQw6lPFskRgAKHF2kg5HpJnBpc58rZhNl8Qq5qVsWNl+yIH9x8wOTwma6DMHNr/fKGnp6enp6fnn+A9naj8Qdt6IsJv/dZv9aKyp+c/wMbGRl/92tPT09PT09PT0/MjsH7pPAeHE2KMXDm/gW8bTuuWwWjEeDRkf3+fcrzJxafO8+DmWzhXUI43mE/n7Fx9nsJ53n71ZTYuXKFZzHn79Rtsbm7h25b5Ys7K+jqL6Qlb5y6RFTkP79zEWYu1hkhgUDqiCLYYYI2wvrXN5OiQerFgbWON0+OTVMt4dEI7bZnPTgkq5C5VhiZnl4QOIZ7FzzSGVLNpuqDfsoq1Mz8pqbas2NRuPzFVc6pqclbdIOVSWIYYCfroMUSWN0rpNjGCzR1GBF+3SToKWCNne5md6SPLbbKbGhg5Q9UGghji8uCMEKOyd/OI1Q9c4Onr52hfvMfxIhAVQidZo1dibLn9xhuE//1fsbazzft+7RPsvu85BpsVtplhR+cww520RzkYIXmZtizbKRpqxJaY4UVksIPZeIZ4cpOw9yrx6O1UCevrbnNSwLgkbUlVtdJtQBqb5K5o7M490G1XiunOtLGpNza06bURgJhkJyalWI1FbCd2TdpGLEYlUWN6XwzMqshhU7JbVmhICdroWwpnUo1x67vXxmJsQShWKXafITv/fsz6VSg3EVN014Z7NDpKl8iNgRhrtG0IzZT54QNufvMb/MXv/9989ZuvcdJ6CiOsW8P5tZyr77vC3r0jHr79EEdK2D6sW3IDpQFxJAcpAAAgAElEQVTXPf/lZqmInKU9H6UmNW1zdonI9P537FKeBTG71CSS3DeCLFPCdIFVlW5NNSVwUQUfaOce4yzTr/01G7/w6ywmc2RlDCoE3yCFQyuPtg3GZYAQmoroMqIojQeJgcyABk9sY1d33CIkSRgRfAiUmcGhNNMZoWmwFlpJv0wwGJbEGIitMtk/pBjMGa6tYawj+pa6rvABkLTNOj14iBXIy5JidUzb1MS2JR8WtK1lNqsoRXDOUbeBZlFTDIco4KuGqEI5GjJwK2SNMt3bQ60yrxa0ISVY4+kpwaZ93J6enp6enp6eH8RPZKPSe/9YHivLsrONi3fyiU98gtXVVU5PTx/LcfT0vBvZ3t7uE5U9PT09PT09PT09PwK37x1xbneF9SLj4HhOrcrW+QtkmeHOW2+z+cQzjIcF9+/fYfPKNerTfTAZV5+5zMHtW+xPplx87gPcfulFTk4qVtfWqNuKrEiJp9PDE3Z21jnZe0Bsasbra2lnz1iq2QxF8OpQAiujFarZhOFwgHOWoMJ4VHJycEgeWuqgkFvyQcZoXCCLRRIxyKNdytTTylLVpHrNroI1vjMlac+aN8/mITWJtmXCMpEeIcalNJIk6JaiaSmXuprX2Eawj9J/agVrLbFpkw/TlCz0TUREMc6yMio4rhZIWntEDURVIFItGvbuHHL52jmefHKT9o0DpnUgdtW2QUBUOLh3xOTohDJ7mzuv3uCDv/pzPP1LH2ftiaco2gW2OsWMtpHBOpplMFxB/BBpFtDO0FiBGmR0CTM4j9m8jk7vEo7eIh68RZzeg+oUYgtWkpBUMOLQ2InBTvKKGoL3ZzIyFd+mtKVqRLIsiTmEGIWqVRBLKRGxJr0WIUCoMHmJakxiO6REalkUbOUZg0yxzmCtpNdeIVOS0LQD7Mo2dusqdud9mNXLUKwhUoCx3e5oJ0RVQT0xthA9GmpiU+Hnp5zcfZNX/+pr/D//7gu8+PYDGlUyI2wXGSuZ8sxzFzF5xu2X3ibULTkwaSNTH7lcCLkTnEja5ZQkK5fNr6gmF6umc6VdDrK7/pa7lPBIcnImgJO4DEHTpKUsa4gfXfPW2rTNqqAqhODJxkPakznGRuJ0RjRQRUvAoGqwksRzrGeIMdisJAiEpiV6jxPFS4avGozNERTfthTW0AQlqmFlnKNq0RBpvCe0LfkgxxiHMbCoQ0oRiyV4j/ctTVNTDCxiUq658Q2x9RR5joowXBlh85KoAUTwqvgm0Hhoa4+zmnZVMRj1TCcTYjSYcgRBiVEZb26yPlxldTCkajyLao5aR5bamVksUsVvT09PT09PT88P4rGLysfJD9qohJQU+5Vf+RU+85nP/ASOqqfn3UEvKnt6enp6enp6enp+NK6eGxOBe/sTZDTiyWefZXH4gP37h1x8+jonhw+pmxFXrj3H/RvfZ/38ZcbjEW98+1tkK1tsX7zAi1//OsVgg9WNnOlkxoUrlzk62AdjOXfpPCf7exixDMarqAiZc0wPD8nGm+w/vMdgMCDPCvYf7rN96QL4huFgQKinVFPP5tYa+w8PMGJpW082GmCdEFTxIRIxhLhUiikhuRQ9qmfrlF2qcnmbVJ8au6DeMumYUmj6jgTkUgp16Uv0bEhQTCeUTKoy1WCwLr0t1pANMsQZEGE2mWNUEGew1hBCS5bnKEqZG8pMkohdJkIxQEQEFtOGyXHFhesXmc1qbt+bMmsDkfQcfGdcm1rxrTK/9ZCD3/0ct19+nQ/85ie4+IEPMtq9gmtOsdUmZrADwxVwFtwYwhBpKrSZQVggxsLgHDK8iNn+KfTyHnp6g3D4JvHkFsz2CfUxQjhLoUYxIAGDYGxXRWpst2PZpVXtMkWaTivGEtuWoigwVtDYdrI5niUw08ZlSAlEI4iPWIEVkypH021Nqo+1BTJex6xdwW5ew6xfRkY7kK+AZKmilCRPI4+knsYGoofQoKEmVBPmJ3s8fOUl/uazf85ffPFvuTNJUtxaKBEcgYvn17j6oWvcv7nH5HACUXGiHNQBJzCyhkwEZ+TsPHUvbhLSvGMzVf9h41aSlsZIJzfTfWgnIelSwimF2tUfx7NLGJW037l8WwIpfdt6wNDcv002WmV+cogfr6fzHiqMs1gR0EAbDIuqxYiSGZNkqzWoMdhFS/RTRAUrSVK2bcQQaeeRLDM4V+AUrCsYjEqwGbNZ3SU8wTgwTrprtyHEVMAcvBK6hC0SiVHR2NJWM5qgWJuqh5tFS9U0NPWCsixS1bIraJsFISgxeOLxPhqFamZpF1NclmPznCam1340LrAyYnZ6QtW02Kb+4b6Q9vT09PT09Lznec+KSmPMD0xTAuR5zqc+9Sn++I//+Owvrj09PY8QEXZ2dnpR2fP/K0TkvwX+N+C/U9V/9SPcz/8E/I/Ar6rqF38cx9bT09PT09Pz7qRqAtMqsHruArtXLrB/4/vMTlvWtra4d/Mtzl17lsy03Hr5u5x/8mkm92/y5p09nv7pjzA93uNv//IrbJ2/ROYizjq2dre4f/8eW7u7zI4O2bt/n92dLY4PDlDJmU8mSIS28dzfv8X69io+KoOy5Mkrl2iqKa4YcPLwAdoscAjWDGinNRal8ZEizxAbCUHJioKmbs/qL1MOsROTy++ll/5n2bNpJEmj9Ec664OYzvBoJyu7qs2zas5lalBSmlAkxTBFLGpSxSuQZE9hkTLDDQrayTRtDaZxQvLxiFB1gilAkRnGhWNa153ItQQfOqeXqmBnx6eUQ8vuExtUlSceLJj7VEXbZUZTDa5GTBRCaHjxr1/k7vdv8IFfeIHrv/JzbD57nXLjAq6eYKo1zGALKcZo5mAwRPIBtFVKlYVO2Lg1zNoWOn4Ss/sxdHabOLmFPb1FnNwnTg/R+SHTekDe7jPIfNeGaxBjOyGniHFoTOk+DI82GcUgsUKMQ5zFGJfqV5dOT5evj+nChIpzqUK0bSImH+BWN7Ar5zHrT2LXLiHDHSjWEVugYrtkZ6qCPdsoVSVG3yUomyQpvQeJHN9+g+9/5ev8+R/+Od9+5RbTrlJYRCkwjATWho7rH7rC8eExhw8OaeY1uSrYjMOmZWSF0gj2rLK1S1MupWJ3fUp3TYgsz1R3iQLGdilKTYnAZYqy+xBQSalcTRXDqco27bYKiqpw9iOnZP2IdcBYYfL9NxhdfZ7pg3sUGzlBDU09x7cNWIM1OUGhaRoKZwnqEeOIKpgAxioxplzsoquALQtLE0ISqCmejHUGV+RYY1gsFmTGkA0GhNZjnSAYPOm4o/cYlyN5jm0DmQXrHOqVuo4ErWljJIojxkDT+nQ/xqBGQBw+KpWPKX3rPaFqUnY2d0w14mzFoBxgBwMsioplenLMbDZjWGQ4N/jxfXHteez8uL5f7unp6enp+UE8VlGpqo+t9tVai3M/+OkZY/joRz/KhQsXuHv37mM5np6edxOj0YiNjY1/Uvb39PT09PT09PT09PyHmXvLlfd/CEPF7VdeZWN7lxgnTKqaZz/6MR7e+D5mfYsrz1zjxosvk6/v8jO/8Ru88a2vcLo35fKlK3j1bO5sM59OmM0WXL76NA9uvEEwOecuXuTh7VuMVsYsFgvWNzY53DuCwYCnLuyyt3fAys4FtrfX8U3N6toad195CaMR8ZFgMkbDEYXJaWhoQ0BVsVmGWKGt2rMKVxGISTGyTEKiXULPdPWjSKpfXd6q26BMG5UQNd1WI933Gtol1B7tWWK6XUCRsySctZZslGFLRzYsyVZHmBQZoz2dnMlOjGCMELvjiT6lBVcGjqNZiw8BK4Yyc1Rt6GppI8FHTg+nrJ9b58ozOywWd/BTpY7puCIQIJ03LDFAG+Dh3oyTz32ZN7/zGh/45Y/y1M+9wNqT1yjXd1MdbLGCKTdhsJqEpR2kDUsfUF9BWKQaVskhLxBXYkcX0e33Y5tTdHGELvbJqjnx+DZS7aPVFKmniAbU14gmeSlAFDDGduLXoFbB2yQixaLqU5o0psXF9NJasBbFIuUaMlijdZvkq+fIV7exK+eQ4TZSrCKdaNKYkoNJUnbbmCIQQxKTsYXQEH1D9DW+mlKfPOT09h2+9OnP8aW/+FvuHE8JnQxUY3AKQxXGBTz/wcu4wYDT/QmTvRmh8gwc3Ks9HiE3SmEFZ1MaUro9ThGXBCX8ve9ltUtLSrejasyj2teonF2v6Nl/UJVUESwBs6yLRYgIEpefDyn5G0LAtEp0gjGGMFvgxgO0CUgzR90gSUHr8Ap1GxEiQ6Op3jUoRiMus2hsqeoWay1NiKCRlUEGDpxmKIIaQ+UjLs/RGKnaFmtz2qZB6zlgiRT4GNPns7ZgQtqwHJSY0lFXLWCI6vFtjYilaTwh1FhrGOQFmhe0TYUxltBJ/cI52hiIRrDlgFhXxDbQao2aDBMVFxpcnqHlCC1yVouS0ijGNz/mr7A970b6X+zt6enp6flBPFZRGWOkbdvH8liyrO/4J/7fuXPn+Nmf/Vk+/elPP5bj6el5N7GxscHm5uZP+jB6et6t/C/A7wI3f9IH0tPT09PT0/OT5fL7rjPbv0m1aNm5dIXTwz2ytW1WCuHOa69w8dnnqU4e8tbLr7H1xFVCCHzvL7/IoCgZjgY0MbC+s8G9W3cYrKyzvbvLg9dfxDeRWX1CdTIlH+QEV3L52iX2799l7f9l782DJbvu+77PWe7Wy1vmzT4DzAJiABDiApIQSHMBKck0YymiWZJJyXJKihWVEydOylQpVFKMopJVdpxylVSKKCVVCUOXbKdUcUUUXZJVVmRJlERKXEAQBAmAA2A2zGCWt/d2l3POL3+c2+8NGQAERWAwGN1PVVfP6+Xec0/f1/NOf/v7/R7cT54nTMuau974Rsarl9h85gzluOJKXaIQFpYGVGmPAydOMLl0hmpc7sa1ljW+Bp0YMETRsAmIlx0xUlQb3yow75VExdtjj2V0RkbnWey2VEqh255Fa9pOxfmavRUo9fznuZikNEqDTjR2MSfpFQwOHCLp93FVCQJrj5dA2zOYWHwIoNv95El0uxkY9g2z7UDwQppbBKEJ0lYOKrzzTDan9BcLDh1dojmzhqoVdRt7G+ZiIAEkuvEkCGUlXDh7hWuXf4/Tn3+Ee979AMff/GYWjtxGvnwb4mrU5Cq6WG4FyxyVWkgHqNAD51CuQpqqjW1NIV1GJQuo4iCIw/gKOTxB6hHUY6TeQsoRoRqhmhmhKZF6hGoc4hqCr0E8SimCj5mlypg43yZB2RRlE0gG6GyIyoaobIAullH5Enk2RNlevKSL8xc6Wg19HQVKnbYCpY4uTV8RXEnwDbiS0JQ05YTZxlXWzp7hsT/7PF/49Jd44sJVJk5il2rrhDUi9JVimBnuu/8Y+27fy3R7ymhzwnhrgkXIh322Nz1WNfStIjWC1bH3MYriEisx/Xyou2L5TnywCKYVKUXmMca7AiYyd122t7Xn906ssdrxjLbPjzGzoPCNoEwgTQ2+FJor58iKPvX2iHqoY7+jNlSNw/tAL9V4pRlPatJUSLPYKxlCILGGxsXfsdxqfAg0lWCUImBojCcrCnSaU05nJCb+7mSpBQLUNVo00zIgeDKtEN+wsLRAr1fQuAAkjCclgYDWGufr6Cxtu0UNAWMTxFvqskSqGcokGCC1FjEJQWDWBKrJiDS1iFWU3qFqgzClvwJLC4toEkxTYfr5S/4e29HR0dHR0XFrcMtGv1prSZLkee/fu3cvDzzwAJ/61Kfw3t/AkXV03PwsLy+zd+/eV3oYHR2vSkRkFVh9pcfR0dHR0dHR8cqzdfUixWCJpKfY2Nxg//G72Dj3BNvbcPjYMS489mVCA3uOHOHZ8+eZjUv2LC6wPdpk323HGQ5Srl66woHjr6EarXPtwhksiplokiQFIywfPUaaac6fOUd/3yGapsTVnpV9e5ltr9IrCqbXVlEE8kFOb3kPFAXHDh/l6ulHqTc3EBd2eiONCPWkxlgThcXGIS7s9FHGQEpphbsYLylK5ubIKFjKXNSMEa/zONDrc2JbXaiVeeZdl63rso0TNVajE02y0CNfWCJfWcD2++g8I+31oaoQF+I427FJ40ACQQSbpQiQ9jIOJSmTaoNRGfDeU2QJoXTUjadpPDaz1FVFUiUcvvMw5bTh2We3kQaaAEL83GAeeRs7O6Na6zxMZ8LTj1/g8jNXue1zX+G1Dz7Ia3/o76FG6+CmJMV6dFhmC5AvotJ+dFlmGSpNUTKI7kpXg6vA16AcIg3oApUMUb0D7Tw7CA1WfFTmQohdkL6J8bK+htZpKXMvoDZRaDMWpRMwGaITMGn8WceeSVH6ur5Js+OeZB7Pa4v26AW8R/yM4CvEVYhvCE2Jm42ZrD3LtSef4MkvPsKX/vxRnjx7he3G00ir97WanwL6ouhruO9Nx7jzvnu49sxFqmnN6qUtqD2FVbBvD6tnz7KgFUOjyI3Gao1W0vZMapTEgswgvj0bQIvEfkWt2v3JTqelqN1CzbmYrnbGJe04r+9e3TnJdxyYQdoYY6UQ55EmRuz6rQnGgExnJMsrOC+Ib0iUQmkoq5pZGUgMJMZSeyGUUwa9HBc8znu0gJeAF4U3oKymESiKgqzXI4hGpzmNq1ES0BIwaQqisEoYZhonFgmOIs0JVcl4fRVMBigq5yE0OKWwyqCMJk0teV5gtEVCdEMrpXF1gwqCKNAqwdiUvNcjGyyxcSlAM0N8jQSNRxDvGIynLO/dhwuGcrpFCHR0dHR0dHR0PCe3rFD5Qo5KiELmG97wBo4ePcq5c+du4Mg6Om5+9uzZw759+17pYXR0fEcopY4DZ4B/AfxP7eVdQAZ8CfgFEfn3L2I77wF+FHgHcBRIgKeA/xv4ZyJSftPjf57niLJRsWjpj4EfBv4J8B8De4AngX8uIv/nX/ZYOzo6Ojo6Om5OFvccoKorRIRhv8elRz7P0qEjJMFx+pFHWdh3AKXh/NmzrOzbz+GDhmcvXuXY695CU26zdvkKR+54Dc88+QTNtCTLckb1BG01aM3S8iJXzn4dMRkmK3j6sdMcPHaMPNWMVq9QGMWzFy+TJCnD5QVUakiWVugPMp798uforRwm25fwjDuDlVZ88R4dDNoYmuDxLhDrD6WNwiTGsrYCpFa7jrOd+FclGK3xLqANMe5V5p2TrSsTdkSgHdFSKayx6NSSZAa0Il3qkS0OMUUPW/QRHYUhnffQ1gAhinAibfekBwXaaOoquv/qaYUtEvYf7DM9t01deYw2FLmhrAOzaU2SW5RJmIymKC3cfuoQddVwbXUWjy/sxoVKK8Yi7AqsPnYdjkc1Tz7yFOtXtpn5Hj29zmB5keWTx+itHCYZLGHzPirpR9GytwxpjjIGtIXEoqQHIcSLq6PjMpTxZwkoPMrkQIy/jaJfmM8q+Kqd71aF221ohB1RuB25gp3SShWFZ5RGqbhtaQXMqMpFgVTcGGlqJDgkOEJT45uSerzB+Nolrj31NKc/9yUe/otHOXdpg5ELBL279+hajIpgBuQGThxf4siJFTauXCE0gWvPbDLenFAgHLzjCOeSPloChVb0rEGraJZtT8e5LI7MJWQRNPNo2OikDEF2PycSonhpFcH73XmSAEpQEgXFOM55Z2o7YdI6cdt5U7HAMrosvQelqUZT9HARtbUNLuBrh9GB1FgChnpWU1hBGZj6GCGrRZj5eD4n2mEVoAx1E6JommYYAfEBX9e4JqBQGG0gCD7AdGuENQbvTfy98w1ZlmCKgnJaUY0n2FyY1jEO1yaGJOvTlBWJtWRpRmKi89OVJYKnNxwy3oJ6NsZaRa0NqfIYCRT9FH34INOtTZrpCOeEXHmyIqMQj5ptoU1GCIF6MvtLvpN2vBy8EutlpdRZ4Fj74x9e/7mtzH/Z4uN6wH8DfAi4k/j28RXgV0Tk//pLHG5HR0dHx03OLStUGmMwxjzv/Uop7r33Xl7zmtd0QmVHxzexb9++TqjsuJU4AXyWuLD534BDxAXPv1NK/R0R+c1v8fyPAHcDnwF+B8iBtwM/D7xbKfV9IvJirflLwJ8BNfBviIvAvw18XCkVRORffDsH1tHR0dHR0XFzU4ti8eAhNs48wbjyHHvd67ly9km2J45j97yW6WSby2fOc+DgIXSomI3hyPHbefaprzJc2cveo7dx8aknSYslmmqdKmjyQY+8GKATy7Vraxy95/WoesSFrz/FiaP72dy6SiYLNM2U0ayiGPZZXNrDaDbj4MlT+NEqVx7/Gov7DtE0NWtPP4MKErv3dHQxolSMcG2i+KK1jv2VOvbzyVywBIQQnVdz8Q7Quo3P1K14FEIU9bRCZB4RG9oewdAKTK2I1DopTS+hd2Bf7KTs9zBpQkATphOqasbwwAnKK2dbQSnGz8axmjbGVkMA5xxpL6csG1YOL7M+mrG22jCdVeS9nMRq6jownVQMrUFhmGyXyEDYe2iBqvHIVo1C4b/JTTl3K8bkWon9nC7gQ2BjdY0Lf/HvmWxsUI8rDtxxhONveC37Tt3JwqGjZEv7sMUQM76KSgbofAGVDVBpAVaB0WA0KrFADxWIjksfWhelj67J0MS5VRLjdMWDTlsZsu0UldiuOBfjaAWw6Iadd03ORc+2d7J9vhLX9k1Od9ya0owRXxG8w1cTpuurbF66wMVHH+eJLzzK15+4wMVr24yDRLdtK2oHQK5zUlqEBW14/T0HuPfNd9C4Btd4ttfGbK9PMCIMeil3/8D38Sf/+++SaUXfKDIFqdFo2vNHBNV2Uu7qia0bUKKYPheVY0dqiK9dq92qNpJ4xxUssTdTmfh6hvb8nndbBq7rVA1ExbSd3yBCYgz1tGQwXMQ0QqgnWFsgXnAI3tXkqSK1lnEjWG1IDTSiSURIMw0mp65LyrIhBEWwMTGsqRyqCYSyQhsDNiWIUDUVtQsoEezAYooeJknpFxlVE6hnUzAWUT1GU6EODdYoUp2BCCbJCb4kNIZZ3USdvKkxxuDKKa6p4+nnHImU6FQoJ0JTl2ASiuECAGldk/gKKw2pSpiuXQNrSIsl0l76kr6/drxk3Mj18i8Dfwt4kCiQnv3mjSmlloD/ANwHPAR8nPitgL8B/Gul1L0i8tG/7MF2dHR0dNyc3LJCpdb6G8rTn4vDhw/zute9jk9/+tM3rDuzo+NmJ01TTpw4wWAweKWH0tHxUvEuomPxZ+Y3KKV+lbgY+1+VUv9ORLZf4Pn/ADgj80/edrfxj4GPEh2S32rxNucNwP8B/P35Yk0p9cvAI8QF3rcUKpVSX3yeu+5+kWPo+CvAH/3RH73SQ3hORqMRcPOO79VIN6fPzXxeOjpeafIs5dJXH2LvkeMcXNnLkw99gWRhDwdvK3jmqa/TX1zh5D33sPHsBfKlfUDD5voGd9z3FlbPPsaZh8+QZkNWr5yjcWASy4lTJylnYyoPd7/hjVw6/VXqWc3x19xJORlxMFmgmmyRFAPylYPs2bfI1vomJ+67j2tff4Rqe0rWW+DKuQsYpfF17JQMEtv6AELt8C4gOtrgQluXIvMuytZVpnX8t1K+FXxaEVJat9vc6qY0wQekjX5UOopIIqHtrlRRFNJgUwNGYYocm2dkS0sYa6lGW7iypplOsf0eNh8wXt1A2ZRQe4yxKOL2BE0IniTNUImhnJX4Wphtltxx1zG2N5+ibALTWU1epGSJpqkcTelQhUZcYLQ5pTcsOHB4Eee3CKMKI2CSBKxiMqlaV11U3oJIK8IJxium44ov//lXKbIUkcD62oinvnSavQf3cNu9pzj8untYPn6cffe8FalWUaNn0WmBSjJ00od0gE56kGQoa6F1OpIYUFG02tGLQ6u4XRdtGmm7RHc6FonbQbX5q7uO0PhCBwg14qbgKsSX7aVCXB37L12Fq8bUo23Ga5dZPXOWs1/6Gk88cpqzF66xMW0oQ0A0rdVREdohSTtXWkGKsGQMb/3uE9z93fcwWlsjuIbZpOLyM+u4WUVfK97wt3+Y6Z6TjNa2SRT0DaQGop4e2n7JKICqdkKiyzD2QqpWTA7tyReciwJfO0fzs74986MgaS3Bg2++0ZUpIUYexz5VdgX6ENBGt12YrUgfNGE6Q4tgG0+tPY0TtPdYE/svq8ajfMBYRagcqTX4qiFdyLAL+5icOc+4DPR7CYN+xuaoITQ1s6Co65pBYTGFx6uEuvKI0vT6PZI8QxG3i0nIrSEYoSwd08mMra0xIXjy1FBPamyRkiUJeR5FS+8d4gOp1ZjUUtVRCHY+YHX0xIbgqaqAqWtsnhGUI88LfAhYHbDK04igncaoQEZDHdxL9M7a8RJzw9bLIvLLrRD5IPCJ6xOIruOXiSLlR0Tkf75ueznwSeC/V0r9GxF5+IUO6sWum7u/ob99uvXHd043h98Z3fx958zn8GZaN9/SQuULOSohui7f9a538Ru/8Rusra3doJF1dNzc9Ho97rrrrld6GB0dLyVbwC9cf4OIfEEp9a+AHwc+wAsIhCLy9PPc9UvEhdff4MULlVPgw9c7MEXka0qpPwPepZQaiMj4RW6ro6Ojo6Oj4ybn4hNPcOptb6fausxjD32OPQdux5cjnnn8SZYPHiVNA9PxFgdO3smlpx9jsO8oB27fw+WnT8Osoqk8G5NNjDYMh4vsPbTCpYvPsLC8n4XFAV/73Gc5cuwYS8PAtfPnyPIEZWBhZQVlErxyTKczekXCuc99mtRmVLOaarrNcNjDB8dkOgXRKC2xP09kR2CCKCg6fHSmXe+QpI26bCMwW28hEtpITaXbGMwYoal1FKzmKBXFD4VCGUOSJ4gWTC9nsG+ZYu8yOrWAZ/TsszRbU1zVEELA1h63vY67ehV869xUgAcxiqyf0zQNSmmaWYX4ONbp5ojlE4c5ftd+nvjqFZwLlLOGrJegBcpJiU0MJjNIgHJSY1PL3v19ACaTiuHyAJNoqmmNJ4pSgV3X4DyG1WBwTYM4rncAACAASURBVGDiZqTGIDaKtpcurnLl4jqDv3iE2153L3/9v/trbD7+EPgJ+Z4V0oUFbNHDZj207aFsgrJZ7JJUCUrHn5VJQNno/Iv5urvlj/q6wbQORtT8xWojZYNHQhN7LYNDQhVjXX0TXZPexc5JF2Ndm9mIerzJdP0a6+fOc/GJc5x7/BxPP32Rq5szxt7jkB3RWbdz46VtNRVpzYeKRGAp0bztu4/zxne9iSsXniF4TwiKydYUXzVYhL233cab/ouP8slf/ec00xk9LeRGY5RG0RoZ48m0GykbPFppdCumxy7J0PaqttG27XkoO2JluxmiyBlCYDekdm4dFpQxSJj7Kdvp1Wp32lOLeBeFzcTQ1CVGacpJzdgbstSSpAneBwIa1zQ4hFnpKIixxUVeUJWekgkzMeR5QmIt43G1E5uM8iz0MwZDi5iESgwhZIQmdoX6YBGT4+pAwYysX0CSgVdgHMYYfO0YlRVWCWo8I/RSfJGRJEmcq8ZTEeJrqS1Ka5LEIq5BQozLbSpPr0iYVRXOVyQSKLQhz1O8q3E+kBQJ1hqoKqy+ZT+CfLVz06yXlVIrwN8FvnC9SNnup1RKfaTd3t8BXlCo7Ojo6Oh4dXHD/0r4pi/YvGwYY7D2Wx/egw8+yMrKyl8JodJai9aaEALe+xv2WnS8uuj3+9x7772v9DA6Ol5KHhKR5/qK0B8RF1738QILL6VUn9iP8QHgFDCE3c8ngCPfxlhOP8+3US+018vACwqVIvLm5xnnF4E3fRtj6biFefe73/1KD+E5mX/j8WYd36uRbk6fm+Fw+EoPoaMDgHve8Q4uPfYwjpRDR49z8YknCBgO3XEyOv4GKwxs4PL5sxx/83sIs2uce/jL9BeWWF3fZrC0ROYcxWCIsYZr61c5eNvtbK+ucfn8Bqde/0Y2Lpxhexz7K4dLfYzRJEWf7fGYoj+k3rhCXU7p5wO2N7bANRw8speqaVhe3kN5aZVSCU0IWKNbh13sgUTHqEzTKLxX+BB2uvqU0q1LLXZSxvWlauNdidswbQxrK37O9U+lFMbM4zZV3BZCttij2LOI7RWYIgNpaCYloayZrm3jZw3eBZJKcJMp5foG3rUuLe+xicVomG1OcM6jEovtZajgkcajUayevcrd73w9q1f/lCtXptSNI8wgzyxaoK4deRK/9Bw7LxV5kbN3P2Sbmq3NberaRyFOxchcLYowb+qU2GHpZdfl6FzAezBJSmgcDmCimGyu8ZmP/y9cefQR/LRkuHeBvSeOsnx0P8P9+yiW9pAtLJD0Buish04ytElRJkEbC5gYe6tsdJJqhVJJFC25br3fCpQyt7QGjwQXo2NFkODjxTeIa3BNhasm1JNtyo1Ntq9cYfXcea6ee5aLT1/m4uVV1rdnjBqPk932S9uGWsUOSkGUat2eCg9YJfRR7OunPPjXX8eh44e4dO484h0GTTWu2Lo6pplVLGYpD/zD/5ZksMyTD30Zo4RCKwodHXpa2R03JSGgjCH40Lof572SXHcdhUeF2nH7zo2oczE3Cu1+N4qYKKjP+1OD7IS+thOrCK1QrrUiVE2c5wAiAW0s2iiaSYntFxglhBAI4gmiEWMxxpI4h1UKYxXaeionVJvrpIlGZwVbkxmp1tAmAudpik0s48YTvGCMUAxS8AZtDaJjv2uSGAIwnZTYLMUmKb0CajuJ566E9sUKJOLwjaKpG3pFTu2FyaRCpYZ+rkiLhDTp4xtHWVV4pQnAZFqDNWRpQp5lpBq8C3gXgECWGbRJaaoqnnMdNyM303r5fsAAopT6+ee4P2mv7/lWG3qx6+bub+hvn2798Z3TzeF3Rjd/3znzObyZ1s03VKgMITCb3Zjy7Ov/OH0hlpeXee9738vp06dvWeHOGMOpU6f44R/+YY4dO8b58+f57Gc/y9mzZ7l8+fJNZfHteOVZWFjg1KlTr/QwOjpeSq48z+2X2+vF53uiUioh9mN8N/Ao8Zug14B5Xvj/SOyZfLFsPs/t81X7C0cBdHR0dHR0dLyqeOIzf8TigdvJdeDsVx9j5chtLCwN2Niesv/Ua9m8eJrZVuD4G+9n85nH2Th/AXGBtStrZL0cJ4p9t99G0zSUjXDnvSe4dPoxgqTcdvwo1556gqpsKIqCwUIfk1i0Noy2x6SpZfviWZLEYJKMyfYWg8Uh+SCncZ7BwiI6SXFtnKWIkBUpWkeBRluDFCnZYs7m09d2RUmRnfW2mseICm0MbBQkQ9viJztOwxjCuWPwE3DOkyQWlRhskZD2M9I9S2TLC1GkDEI1muDHUyaXN/BTR1NHYUY3gdnmNcrNMSGEHWdm8EItHuejzORrD6oGkyA69lXWq+usXVjnTd/zBv7wtz7HpHQ0tSN4IcssSjcYq7GtWBmaQPABYwy9YYaxhu3tknLmwMd5CAp8mHdWRm1OAVoUSGAepTEZlbSaGY0LXHjsHNcuXqOaVUzGJeHJ85jPfZU8z+gNU5ZXltl7ZB9Lh/cz2L9Mb2kP+XAYOzvzAmMTTJphkhRlNEonaJMgKiqG0VhpWkNl7K8UCeAhhIrgGryr8VWFm5WUo02mWxuMVrfYvrzG6sUrXLt0latXN9ncnjKtA6XzOMC3HZ1zR+HciCvznse2s1RU7G1MFfRQHFrKeOs772Jp35D1y1cJwccexKph/dlNtlZHFAh3f9/f5K6/9aNcO3uaq+fOY5UitzH5NrV65xw08/NuHj0s8/5IWlV8/qrMz13ac0ahjCY0vhXndwNglRK0MoTgo+gr7bHK7mdM88hcUfMo1Ph0Y6KAr1ODRG2RJHjyYcF4VuOdx6BIEkWWpVR1QGlPnqeYVOGCAScsDRJqYEsyQiVU9Ywk0fjgqYOiamI0c54XpBp0miCiaEJAa7MjQNdOmMxKrDUkeZ/ptMT5+IWDNDWIF1CBaR1wZYnRGmMUYlL6ywNEBVJjSKzGu0AQRz4oqEQzm23TVI5eEljMErIkwTUNvnFk1qCd4GczVBEVVjebvrRvsB0vFTfTenmlvb6/vTwfXVdRR0dHxy3GLeuotNa+KEelUoof+qEf4td//dfx3n/Lx7/aKIqCH/zBH+Snf/qnuf/+3f/jvfd85Stf4Q/+4A/4zGc+w0MPPcTZs2dfuYF23BQopXjDG97A8vLyKz2Ujo6XkgPPc/vB9nrrBZ77fuKi6xMi8p9ef4dS6hBx4dXR0dHR0dHR8ZysHDnOaH2d7e0ph07dgw5TpnXNgWOHePqhz7D/9hNkPc3X//Q/UAyX8aKoMRTDgqTIyVLD+upVhvsPM8gDT3/p8wx6A/JMc/XsUygXGBQZxWKOaM2srGL/XnBM1tYYDgaMt7YoJ1MO33UPWa/HdHOdNBG8c8y2thivbbYyokdphbZCcOAbT7anz+DwCqNn1lC1w2gdRc3rOg+1UoRWmRMfexr13Dq503spiN71oikF2lpMmqC1wiSGZJCTDnrYLCW4kunqBm7SMNsYUY0qgvOEEKM20Qbl67hfNEigTaMFiU4v2r1VZdWKZ7Hj0QfPuS8+wZs++H3cc/8JHv7MkzQ+uh5daKgaT+08/V5C3ktROop+IpDYBN3XKAWJaZhMm+iWZNdFOf/EI+zIYzHyNCbCxijcEAQdAs3GNnpzvBsZqxQNinE1QbZGnL+whn7kSdLEkucJRS9n0M8pFnr0W9G5tzigtzjA5Clp1ifpFWijEXTsTVR6xznomhpXldSzinpWU0/HlKMJk60R2xvbbKxtsbU5YTp1jMuGsgl4ibJz2DmK645t/uXw+XFLjPlVEmNWQyvs5Qp6WnP0QJ/77jvK0sqQcjxFvEMbRfCB7atjrl1cR3thuHeRt/yX/4ik1+f8Vx5lurVFqoSBNaQmnl8xXrjtmGy7UIP3mB03aRRKzbzDUqSdC9mJUI19pu02pE3P3cmFDWhiqLHMXcLtua9bERZAS7xfWxOjaFV0KUoQkuVFZG2DJMR4Y5318XUJykQREQ/iKRYKJpUnlQTn4jxvzxoa73FaaKqGXGs0GmttFOK9J08t/WR3np3ApHTgS/qppUYxHc9wXsh6KY2H8eYEHYQ8tWgbXajOearK4ZwnzRU2TdBGUwz6NMpSj8b4aY02QpJYbJrSuIBKM3JtWSwyrIZqMmFcVaRAYTKUMTgnhNkUlaRIUfzl30w7Xk5upvXyfF+/JCIf/jaf29HR0dHxKuaWDoh/MY5KgLe85S0cP36cp5566mUe0Y2l1+vxkz/5k/zMz/wMR48e/Yb7jDG88Y1v5PWvfz0/9mM/xte+9jU+9alP8Zu/+Ztcvnz5ebbYcaujteb973//Kz2Mjo6XmjcppYbPEWfz7vb6Sy/w3Ne01//Pc9z34Hc6sI6Ojo6Ojo5bm8tffwKdDbj9zjvYuHKRfcfvJLGOS08/zcm77mL90gU2N0YYUaxdfpbeYp9i0GNpaZmynDGZ1dx26m6effKrTDbGHDmyn9Vn15AAYTplYXFAklvSXp/x9ph8uIgbb6BcYGl5P5ONVQQ4cOIk1WSTrWfPkwyX6Q0GVLMtbJahlSaogA9CU9b0BilaB4LRJAtD7KCPtjq6Fr/JNaeUwnsfb0OhjYnOQgFNjEOdO912tE0F2miMVQQ82WBAvqePZAlJL0eC4GcVEhTl5ph6VMd4yyRBKkcI4KZTRk+fJThBG9O65DxBBCQqlr4txJQQHY6h9XnWTaBRNV/5ky/zlve9mavPXOP82U2CCOIUlfM0zlNVnqELDPo5NjGEVgizWtMbZBitsVYzGpWUtWBFoxEaFRCJ8mQcSRQ6oz+zHZMi9jkGQO1+YVrmj2/NfYIQgqKsGsaVQ22VrY9RUDKPJlVYY7BW0c8zhss5dS1UlYsxvLQimxK8F6qypmniMTY+zpMLMd7Dt8JyGxS72+WoAqGVnOd68Hx8SJxfUQqj4799W4eplaJQsNJPOXFimbu+63aSIqOpmui2lIAKhunGhCvPrOMaT6YDd3/PA+z9rvuQ4Hni85/Dz2ZkWiiUYI1GKw0xdLc9oXZnUF3nj0TFeN75+bfTSSkCAbx4VCtsirrOhYlCgm/jiXdfGRG1s2GlIPgAWqN07GyMJ7tgseADbjLBFhlhY0y1NSEkKcYmeO+p60DWS+kNLXpxD5vnLrPQTCiyjG2fsDWe0bMKQ4USwQdPTymcsjjnkSBYI8ymJTqxUYhFo5uaqmqom4o6KKaTirywiMpRoullCdI4NDoKu9aCtqRpgfM1IVTMZhWJjT2gyqboJGUy26KXarRNKeso0PesZpBbMqOZzmqm5YwssxgdRfvEKGy/j9gU7xpIu/CYm5QbvV6ev+k91wnxOeLbzDtfYJ8dHR0dHbcgt6xQmSQJSZJ86wcSXYff//3fz6/8yq+8zKO6cVhref/738/P/uzPcujQoecVbbXWHDx4kAMHDnD//ffzoQ99iI997GN88pOfZDKZ3OBRd7zSrKys8L73ve+VHkZHx0vNIvBzwM/Mb1BKvQX4MeI3Nn/rBZ57tr1+N/Bvr3v+SeCfvcTj7Ojo6Ojo6LjF2HfyDlRwbFy7ysHjx9m8fAaVFBw6fpIrT51mNhoT6gaTFxw5eQfZwiKGhtOPPMJw/xH2HTrCpdOPk+iMo8f3Mh5t018eMh1POXD7bYhAPlxk7dpV+gsLuNmI1FpCqJlsraHSlAPHT1COt7BpQW9PdDRVky2UTcn37CEf5oyvboOAF4VODKoBkxpMv08y7KNtXE96kR1nmkjbwzfXIOcOMx3dZCiFUTqKXiF6HJXWaBMFTdNLSHopJk9IhgNMkROcw01L6q0tmq0Z9faMpor79B7SPKWeVUgTmKxtRUec9wQCJrEEH/BNaMWy6EwTFAFw3tOgaIJQIYyfvsjjj6zwune9ke2tP2dtrdwRFsUJ5TT2Yc5Kx9JCQdpLMMYQgkMbTd5PMEbHDsPtmqqKHZgpBkd0FErrwFOomPOvFGqu8qko6Om2D3Fel+jx7RxDVOCi288rQZSPKicAu5G90gREwebMUZQVde2pm7Ajss3Fx6grqt1gXpkLj218KrsOwx2Xpwgewct8nHE+59ZYJbvPoxUog0DfaAaJ4ej+gje/47UsrCwx3d7CNz4+xntAMRtXbF/bwpUl2gcW9/Z4/X/0DqSZUFZw5cnHyLSisFAkmqSd87ZRkhAEawwiglYavVMDNFdZ2+mKZZY7MubuY6SNJmY3/VUErXX7OrR+Y5HWXTvvqYzncUDQEl8LbVp3r/c756Og0RiaaUnoxc5OFzz5oEfez1EKqrLmwJ4Fcu3Y3m6wChaLBKtiXDFGo8UQlKWsGpQErFHUTlAq0FQlWIPWSYyWVTCpBIUjsZa69DRugmYUOzpFKKuaxCqSIDilSLQhyxJ0kjGpAtV0hq8blLGgNVmaU5Uls3LKuPT0c8tyL8NIoB5N2JpUmDRBmpps0EdphQ8N0jRgUoJOaKquo/Im5Uavl9fa69u/+Q4RuaqU+lfAf6KU+h+AfyIi3xB/p5S6AwgicuYFxtXR0dHR8SrjlhUqlVJorb/1A9l1kX3sYx+7ZeJfT506xc/93M+9oEh5PUophsMhb33rW7n//vv57Gc/yy/+4i/yhS98gc3NzZ2FZceti1KKn/iJn2BhYeGVHkpHx0vNp4H/TCn1APBnwCHgQ8RPfv6+iGy/wHP/LfAk8GGl1OuI3ya9HfgB4Hd4jsVVR0dHR0dHR8ecarKFSgYs7Vng8tOn2XfiLvCOZ7/6ZcrtGRWKxT37aXyNyjPKzWs89diT7L3jtRQ9z1MPf5GVpUVcPWNrC4p+AeLp24RGBCWB7Y1VsizFzcakicGXNdiEPQcP4F2gnJWkxRBlLa6akRYZdaNZPHiEZjpmvDWLXjkF1ugoPBmNJAm9QwexPYMtLFCjAGNNdD2G0DrVoig5j8wUaeNZ5w402Fmbz+M6tVFopbF5TjrMSPoFvnHUW1vM1rbxk4pq0uCbKBh58RCEeloTAmgbCI1DG0NdNVFkDTG6NhCiuOIluiQD0Q2pFI0LVCFQeaEOnof/9FHe9YF3cd97Xs9nfueLjMfRFRdQsbuvCbhQ4ZrAosvpDzJ0YkEprAGbWpSJrr6NzRlVHfc5nwjfuhDnK3LFPK501/Hnd5S06GKMvY600amy0wk6j9edb0sTuxBRxJ5GEYIPjMd12w+p2pjeuRA53+/cMakIqt0frXtTWiflvEh0R4TeFS8VrXyqQCshoKlF0O2+jMBAK/b2LCdvX+Lk3YdJi5TJ9taudugDEgRX1Uw3p4w2plSTmsTAnW//LipX4TbOsn7Vc/axxzEKCqNi2+a8AFTm89n2QyKxB7U973Z7VHcjeJVWyDw+uJ1FCNGduhNVHA/dzKOKRQjttqIYGsVvJRBU62wNOsbGJpYQomgctEb5sOPwDc7jRUFVk2Y2/i4gqGSA8Y40NVRTj00S0EkUI7VQiyFNAloSxCh6/QREMx6NUQK5Tijyglntcb5GfKBpPM4rrIbgHSiNck37ugdEGzAJwXuSJJC0Lk8rIC6QKY3XGu88Go1qPOW0pHSaaVnRVDXFcg6pgrTHVinUlacgkOQGqhqdGio0UnmUG2GKHOpOqLxJudHr5T8kfkfinyqlvgvYABCRX2zv/6+AO4FfIAqWf0rs0TwM3EPsrvxRoBMqOzo6Om4hXpyS9yrEGPOihUqlFHfccQenTp16mUd1Y0iShA9/+MPcfffdLzr+do5SCmst73jHO/jt3/5tfu3Xfo0f+IEfYO/evS/TaDtuFk6ePMmP//iPf9vnTEfHq4AzwF8jLoD+c+CDwEPA3xSR33yhJ4rIBPge4F8D9wL/NfB64B8Df/dlHHNHR0dHR0fHLUBiC8qtDTZXN9l32wnWLp7nma8+wmR9jOotcPiOOwlKWDpwgPVzZ3jmwlXu/O63YsKEjStrHD52DBcCgpAaYTBcQJmExQP7EK0wWYZSAaOFXq8HojC9PsXSIlVVIRJIixSthcn6ZeqyxNuCw9/1FrZWr1FOK7S2qNYt54OPMa9Gkx88yvC2Y9heQTbsgYohptElFscUzXQ6dhOqKNiZnWjOuWjJjmhkE0uSJiRFgjIKZQ0269FMxzSjbZrRFF821KWLbkRFFBslCnUhhLi7EGhmdXRoSWgFqbjDINA4R/QqarwIzsd409oH6gDToJh5xeZ2yWf++GH2nzrFm979WrJc70SlBlGxX89DWTnW1qasrk2oa4cxKvZ5GkV/IWPlwAKLSwVFYTBa4YLQhCigBaF1JMZLaF2p33wtbZ6u7LgSW+EXjQ+xhzCE+G/vofGCC5rGayoHTVA0onBB4Tw4ERzxtlqgBmoRKhEqCVTiqSXgEBwBT8DPxcowd4TORU3aSNV5R2W8NKJxrSvUAjmKPanhnuN7eNvb7+TuN9+Bzix1VbYuW413Du88TdlQjitGmxPG2zOMhuLgEqsozjz+BGunP8/lr/0Zs60RmRL6JgpvunU4Gh07OLW2rfCoQOu5XN6Kr9edGyhQ7esb5iJk+4XsedeljscYxch2G1q3EbI7qbCgBFG70q+0Yr2vHcoHxHmKYUG2vBzjkhGk8QQXSHMLWYJHI6LxvgEFlbKoLCMd9DEiNAJb0xqNsNxPWVgoKLIkRjBrTV4UaGOYTWdQVyQGQhMdwNWsROGxVpNYTWoCWRI7NK01FP0eaaJpmoDzgkkzGueZVQ1N45DgMAR6eUqioa5qJqMp5WSCAZYKS89oJlXD6sY2WgUWEs/AQhIcmfWUdcm4bBjPGmaTGeXGBtVk/LK913Z8R9zQ9bKIPAb8OHAZ+AftY//xdfdvE2Nj/yGwCvwQ8GHgPcAI+EfA7/+ljrSjo6Oj46bllnVUaq0x5sXn3y8uLvL2t7+dxx577GUc1Y3hgQce4IMf/OB3tA2lFHme88EPfpB3vvOd/PEf/zGf/OQn+b3f+z22t1/oy1Qdr0Z6vR4/9VM/xYkTJzqhsuOWpF0MvWABq4h8AvjEc9x+gRh781z8/35hROTngZ9/jtuf95dLRH4C+IkXGl9HR0dHR0fHq4/L585T7DnMyv79XHryNH4yoa4DgwNH6Q0SxuMRC3uWuHb+DP09e9nb7/PMY19hcWmZIrFsbW1hdXRdZnnCZDoh7Q8ZbY0oih6hmjFYPAA6UM+mFEsLIEJVViSDAVm/R7W5ShCNSnL6ew+T9zMe/n9/j2JhH+Nrl5hNKzLFjtiolEGpgDQOUQalDRgdHWWEVg+ax3/KjoAzjw+VICDtl4aVtPGnAaUMTe1I8wzby7D9nKSfAb4tkQxoUYQmEFwUzIDoGpRWFKW1RypF3fid/ktpxcrohmvFtBBwweMDVD5QiWbqAjMHMyd4FA1w/sw1HvriWd76jjdTTmq+8CenqRtBCDgB5zRGC94Hmq2ScuYYLmQMFwvy3ADRjbe8MmCwkHLt6ozxxjSKlAiiYrir0aBax96cue4VVIweDdc5+uaPk3m34nXrtPl9oXV/KqJTcP6XqbQaWlBxe3G7O1vEz92RonaSZOePi05PdZ1YquYprzv7k9ZqqRUYhEQpCm3Ys5By5517OHryMADlrEKb2F0Jgq8bmrKinNb4smG0OWXjyjZahOHBJc40sP7ERUySU/s/4fIz2yQS6FtDP1EYrdpjMVGU3KmM1ATfxC+rzyNpoY2lZadYNfiAbudRqbm7dO64jA5UNRckUTvPg9YVHNrYY+ZuYlBtB6aaO1EB5QPVaIJWDYhglCLVkPZTGmuweY80SdDteVtWDUFDYjPQhv5iQhhrktQiohEb41onZY0xliSBoHPqskEHR1NXmDxGCVe1R5qA8yV51ifrZVSzklnj0QIGh1WBRENloGo81Vb8jEdbCwhaCybLcU3NrAlMZw6NYaGfMBz0wNUoo0h6BapWFFLSW16kns4Y5hYxKeujGU1TUvuKpVwIVmOTW/YjyFc9N3K93D7nXwL/8gX2VQO/2l46Ojo6Ov4KcEP/Sggh0DTNDdmX1vpFOyoBhsMhDzzwAJ/4xCdiB8CrlCzL+MhHPsJgMHhJtqeU4vDhw3zoQx/iPe95Dw8//DAf//jH+d3f/d2uw/IWQSnF937v9/IjP/Ij5Hn+Sg+no6Ojo6Ojo6Oj45YhG/aYjde5cmaTZjKhcp58sERoJqxfrrBpztq04ujdr2V09SLXLl7g5BveyNalc0w3ZmRFxr6jR9tAS4X1iroJpDbFVxXWJIw2ruK8sP/kSdx0A2NTsoWEJO0xWV2lv7zCZOMay8fvoty6xrVzV+gPFrl87ilW9u/DJoYQ6ijQiNBUDYSA0QnF8jLN9iY6t61g0wo+IUaPipIdl520pYa6jSEVQCsdRUStUApsYrGFRRTYLEVrHV2SQdGMK2abU1wTopNv7jAM8/jU3f5E5wMuRAEoxpJqzNz55j1BFF4CLoCTGPU6ahrKAKUL1EHh8FSiqIPwB7//BfYdXeG177mfyXjGow+dp3FtB6J4go+9iCYovGuoS8/25oyFxZSFhR42SbCJRRuowpRawAMimiBgjSLLLGliCCFQ1oGmcbGvUknbU7krVM4/2xelduTFOXFarlcko9tvJ5i1daLO+zGvFzy/4TupEsVm9U1VjlGf2x3H9aKpUgojYAgYpTCts3GQaY4eHHLsNQdY2NMDPN7H2F1lDRKgqRsmWzO2N8bRTTmpmI1K+qlluDLksUbz9dURB7ymOHuJtfEIGRl009DLhMxcFyOso+sT3XZIhhA7JZk7HyWeD+jYoSpxLjW0bsmwc8wiCt1m2ardmYUAykgrwl8/3X53InenPJ6nUY1G0GhRENpzP1EMFnr4xR5aLMYYJHi0NoTgSQjUXvBSkfcGiPdkqSEvLFWw1OWM4AI2S8lSi9cQnCUxOV6ifLy+VRHQuMZBEBJtKKczbPt755oqnn9imYxnmMSS5RllWUIdWFjsk+Q5wZX0FxaZjUukqvEBvDIY8WQKSZKyUwAAIABJREFU/GxKFcAFx8A5BnnGsG/RvT55lhGCZ6sx2EJhM08YTePvQJJQ0VUKdXR0dHR0dDw3N1SoFJEb1gFprSVJkhf9eK01J0+e5MiRI5w7d+5lHNnLywc+8AHe9ra3veTb1Vpz4MAB3vve9/Lggw/ypS99iV/6pV/i93//9xmPx7dMt+dfRe69914++tGPcvvtt3duyo6Ojo6Ojo6Ojo6XkN6wwNqGajJBsgF7Dy8z21zHpgWzckY2XOTQkX1cOf117GCJ17zpFBe//jhN6Vjct8KeA3uZjbdRWjMezch7fVQ5xlhLWdWsXlsn7eUcuvMU1WgTYyzBJCSpZXt1lf7KXra3N9h/8h6unf4qo40ptsiYbm9x+Phx1i5cpC4bcrXb6SdBMEZhBvvI9x2C+kp0z2miZat14e2Kh4I2ekdQnJcYmlakRMVoUFQUhEyisUWKsgbvPKAIsxnl1pRq5vCNBzTaGFxodhyFIgERIckM3gdM21MYlShw3kMbFeuC4INQuUAVpO2kjE7KRhRN65ZsgsKjmExn/NZvfZa/91Pv4773vY2ybPj6o5fwYdcpqiXGoSqlY/SpC4y3KmbbFXmRMVzMmVWO8aRuxdMoBAoKH6D2gk0VvV5GmgXWtwKuaXs853M0d/HNud5N2W5z3mEpMo9kbZXJlvmaTuZy3NxUyHWC43Xi8o4rcWcbrYOw7WQM7TYVYNqLVhoN9NLoojxwYIHDx/dSDHuE4KKICGgDzgUm2zPWr4xYX91mNm2iMzEI+5cLlvf2We0v8PiXz3LbypDJtOTZy1tkiaJZU2R4hknsdJxXZwY/HxffMF+6PTLVhhPPHx9nTu24KXc7LGVHYI8ZrbH38xv6KVvXZFvZyVyaj12esUNVKdnJw1WJRtk4n6Fx6FSjrSYrCpoiQ3kDEnBKM5k5wCMmAYQ8TSnrChU8yf/H3pvESHred5rPu3xbROSelbVXsUgVtVErRW2U2tMajAy3Dbgt2GobcM/ABwO+eebgk33xxcKcfBlgfPShL4OeS4/lAboBtyRb8tBaLJmUSBZZVayNteUakbF8y/u+/zm8X0SWpt09IkWyxOL3EFIyK6MivvjiywQzn/z9fkYxLWsaX6NtglEKrSxVEHCe3BpIAk6vcO/1e/F4lcJqhVVCnmlcEEbDKUEplvsZSmvEQ1U3mNCQZClKG7R4nGuQxmKVpSornHfUAVxQpIlhgCK1MCwdVQN5ZiinDT2lqKQilYBXhnEDpatxdYMSocgtvSzumE6rTlR2dHR0dHR0/PM8sr0L82+y3sjtz507x+OPP/6uFZWbm5v89m//Nmtra2+LcJqf06Io+PznP8/nPvc5vv3tb/OXf/mXPPfcc1y7do3pdPqWP27H28djjz3Gn/3Zn/HpT3/6YR9KR0dHR0dHR0dHxyNHVYJrBNNbY7mXMB7uk/eW2N65zxNPfRRpxlz7xx9w9qlPYWzgxk9ewBY9Vo5vMlhboixn5INVhsMhvZVVQlmyvLrKaHub7dt3WV7bYuXYCpOdO6gkxRY9VKipS4fKC6bTks2T57n70gtM9vaoKs/GyoDeyS2uv3SF3tKAJEuQSROljIIktbiqwtcKs3wCu5OTpEkrzAQfAkYMgShpNKqte40bfyJR5YQQWrOjFnuLaA1WYZIEJG751dMpfloT6qOKV6UE33iCF0R8FF/tNmBQFoxCXLsxGNpYG4oQoJGYuGxCYOaEMkDlFaUX6iDtXqSiCYFGoAqeBsXVm3f5P/793/E//dv/nk/9ymeZld/i2pV9VLSNRw/TPmZuLSeODxAvjEZTdu7XTGuPBMHqWNVZh/jcvcC4DByWJdZo0kTjgsJL22TbplW1xLTgfCNRi4pVqyHKyRj8U20Fa2RRzjpPX0qr6NS8Vjbeap7Y5AGRyaLZVNHOirZiuK1HlSM5aVQUclYrstSw0ktYXsrY2Oxx4uwWKoHgmli7qmK6cTqpuP/6kNuvHzAe121FLxglDDLN0noffWyDv/3OFfr9jNMnt5iOD5lWJZlJ2bl3m0xDZgwinrZD9igGil7sfJp2u1F8iNeQRK0YCGhlWt0c5vHTeM22iUza28bdVWmvO9XWw8ri4/NK2fmJm7+H0vG+JEZpdW4wSYKEOgpSNJP9fczp0/hqTJqmTGZTVJpTlgETHGmeUDYOmyb0egm110wPG5Q0rA4KlDLUTaCeNRilyVONE8PhZIa2FldWKKMxGlyjmZZNTJUGaIJQp4EkAe9C+xzj589gOUdcaJ9blPyhqqmDUHoY5JZcB5ppzaRqkKBIEoM4j2gYjaekVpMHi7MwaRyzOuCbBuUdS0XCtIxfN/I8e4u+snZ0dHR0dHQ8ajyyotIY84Y2KgFOnTrFhQsX+OY3vxm/CXsXoZTi2Wef5VOf+tQbqrz9eR/zi1/8Is888ww/+clP+MY3vsE3v/lNvv/973Pv3r135Bg63jxnz57la1/7Gr/2a7/2sA+lo+NtQUSu8V/ZxOjo6Ojo6OjoeCfY3xuyvDTA1TOaTJMkGV4pnnz6acavX+Nwb8iZ9z/FcPcWKE1vaZlsZQ1rYFrV4AOHjaM/WMZXEzYeu8D9yy+xt7PHsbPnUARsUZCurdJfWWbn2qsM1o5zsH0H7CraT7h+/3l80xAwnHjiMSb720zvHpIXA6azmgZI2/9ico3HCxiboFQfNTiNynJML1/IM6U1aIVuxxQDPzXsB4AP8yXDuQBS6Da0hgdf1gTXEBqHm9TU4wpxbY2njulMgodWx6l2K1CI3+sjUb4456CVo6DwQWiC0EhMUNYeZgEq51GJiWk/oa2E1XgRZiFWwDrgey9cJfs/C/7Nb3yaz/3aF/D/4dtce20vbjcuNg2j8CtnDu89y8t99sYN96clTQCswnrIs4RJ2VA7cCKxChZoQqAuYxZSt7uPiKKXahrnYxJwXimq2lQfghL9wOYkD0hGgCMZLAu5Ns9GygOVqOqn6mUXxbAq3lgt7o1FTeo8o6iBIrGsLScsDTLS1LC61mf92BLKsvg5RAiKctpw/84+d26P2Nud0riAMRqNkCbx9Tt2Yp385DG+/e2X2Z5WaJ9y/x8vs9JP2VxK6fWXqQ9fZdkqlHi0aTOn7fP2Id6nivFGJAg++JiqVLGCOARBK9AmXhu0JbtaKbTRsdaX+QpnFOQhtBWzCNJKzOjbdbvdGYWknr8G/uhnRwGQ4FHTgElMfO0aB8ZQTSqKUJP2BohvSPOcO/cOSLRibW2AMkJRFIhoZgHKqiHPLEZrytrRzxNoaqwENNCUJVWA3vKAqnL44EmtQYVAM9/jbJ+DCg5XBRQZIORZEl9zH0A5YpezIriA95qyrFBKsdpLWO8ZqkYz9lNcgCxPKYOOstQITaMY1p7ZuCQZGMYzT1XWGKvIjKLxnrox9K0hU+/Mz6o6fja675c7Ojo6On6ReGRF5RvdqAQoioILFy6QZW1P/7uI1dVVfuVXfoUTJ06844+d5zlPP/00n/jEJ/it3/otXn31VZ577jm+/vWv84Mf/OBdvfn5qHLq1Cn+9E//lK985SsP+1A6Ojo6Ojo6Ojo6Hlke/+BF7ly9SlL0OdjeZmXzBFunj7Nz9VWCWE5/4ClG4xHHP/QxmuE2noS8SAkkzO69zvhwRr9IqRvHyuZxbvzkedy0YmV9DWttFCehwo1qdkdDVo6fZffePfpLG9y7+hrLW8cIzqFsyuaJU+y+fhNXzkjyPvs7Q1bWl9HHVpge7OJRBO/xIUqaMHUoOyDp9Un7Sxir0Y4oZ0JoK0sl5sWMXlSzikhbFRr/CcT3Q4j1kmpmwIIpoalqQi2Ii7uXIbT30SYoJUj7fojJQW1AGTCCr5vYthnmKUDBhYAPCtdKS4fC+UAtkJoEJw7niRJThFoCvt1qDAgN8K3vvUjwNb/1G5/l2X/9BfgPf8eVK7sPpAyFgAIPd++MKUvPXuW4MXVgNJlWfODxs0z2dlFNQ6pgkKZUTWBWhygtVdx+bBa1rBIrZVXAeSGoKMK0UmjiFmeQ+VYnR4KTIxk5r3ZVwgMC8mhgMSY0wSq1qIQV5qnByLw6FR6QljrWiWaJYWVgWV8rOHZqjaJIyIq4M4pSBA/ltObe/TG3buyyvz+jdrGOVxlDZYSK+DOa950/wdjCq9++xLSOqddEYr+wE2FcO/Z3x7i6JreaJLXoVuDG6ttY07p4vjK/HmPs1OYprmpiulRFAXyUI9VAiDXGc6k7//82balUmzCcB1Db63pe02tUTLaqxXlq465tyhgECR4R0Mbgg6BE4RtHIx5lNI2DQZ4RmgqaitTmiHMcjCtmjccqxVJqqJVlOq2YTWYYFVBBaARCE2icZ1gOUcqQGEXRi4nFvlKMh4doZWgEtAiT0pH7hiLTJFZQacJsWqFxpFlCg6Iso2RsKs9yrlkr+jghJinTBF9D1XiUBdGGytd4gRLNbBZIZUYgVtuCxYmF4FnqpVgRZpPZz/X1tKOjo6Ojo+PR5ZEVlcaY+I3bG0ApxYULFxgMBu86UXnx4kV+/dd//Q2nSN9KtNacP3+ec+fO8YUvfIE/+IM/4Pr163z961/nr//6r3nppZeoqgrvfawB6ngoHDt2jD/+4z/md37nd0iSpNul7Ojo6Ojo6Ojo6Hib2L5xjSCa8nDC+Q99BKsa7r12mc2zF0h7KeNScfZjn8A3JYMPfIJ6tIfUNTvXX6GZ1vQtZL0BmfFcf+F50uV1eisGrSyKQGYtk91d8vVT5LlluHdAf7DKncsvs7K5xXjnHv2ts6ys9Ni+coks6zOZ1Azv7dAfDDDacDhtoqRRGoNCvEe0UI0O8E5hV0+Sr/TBtsFJNMg8Hxjl0NH3dw9MsIgsZE4ILspKF/CNQ0YeDXgXbxtlo0JCiKlBCa0M/WnhFnygKkvyXgra0LgGPz8OCVG2onHB40RAW5yKYqeZVjRe8KJx7aSga32VnyceFdTe8zfffYXppOLXvvxxPvPLn0L9p+/z6uU9XAiYBypWp7ViujfjVhXYrgNOCSD4+yNU2ZCIpZdoPvT0+7n848vYcYkLirrdzGxCrGYVJRxW9fyZtNuWskiR6vZ8Au3Oomp3P+N5lzZRKeoBzdgmKo9eGc2RtWyfgxI0uk1jRiunFXEP0Sh6qaFXWIrcUhSW/lLG8kpBbyVHa4NC0zSB8WHN7vYhr9/ZYzRuqBqPQ/AaGqWog6dqz3ViE67d2yObVmgn7ElAWY1SZnHNCEJVTTEhUCQGmyTQNATx86tssekpIu2eZqycVUbR1A2aKLaPzmOIFa0Sk5hz4a7ajlzdJjWNUQspreevRiuM5wnheU44tHWpSqJENdbElKJVmMTiHfFzpW2PDaIQlTCdNSQKlooE+inWxvTn7v1dGm8ICkyvYNoIzpcYYxHv0eKZzRwhBJxoDkYznIMiN4iGEHzcD7WK1c0NRgdjlHMM+j0OxzNsonESULWjLhtCUJjMICGAsYzLgJ9VrKeKgYXDg0MqDzY1pKmNu651g/WOuiJuzEpAW4NKDa4J5ImQJppx40iyDKsVKnhq18Ab/BldR0dHR0dHx3uHR/a/Et5M9SuwEJU7Oztvw1G9PaRpyu/+7u9y/Pjxh30oQBS+eZ6T5zkbGxt88pOf5E/+5E+4desW//AP/8A3v/lN/umf/ond3V3G4zHj8ZjpdErTNA/70B95lpaW+KM/+iN+//d/H2ttJyk7Ojo6Ojo6Ojo63lYU2fISF576EIc7dzmceS58+llcNcEUS1w4fhofPCY9Rj3eYzwcIb4hXz6Gd/dxjeCbwP1791g+cQZXjhDn8CogXqimwmDrFG46wtUps1nN/d3r9PKUyeEhx9/3YcqDO+xcu8Py1knu3t6hqQNbZ08xnlTs7R9QLPc5vHmAboWMdwFjhHq0h2sa0uUtkuWVKGFUTDfGHcKjjJqEWO8adyrbqlbVbkjOkSiApAkErzBFAuJaMRUrNEObnpzXkh5Vlca3QaAua9CaqmqoXYgytO0EjduTnsrH3clJ7aiC4CXQBPBicCEuFzYSqFHEgllpBWlMOlYifOcn17h/9z7/8pn38bF/8XEGq1d44Uc3qOowPzoEOKwCB3VbrypxO/Lq3T20ErJEs6JSLpoBe3VgMOiz1kvZ394j81B5oQzxuBf6S6I0S43Btum8+R6iUsS9TuapVR3rd6WtdQ3xz9vZSZAoOed/pubiuP14gFZMahKryBJFP7dkmcWmiqV+Tpob8iIjKxKU0djUAppy5jnYG3PnzpB724fM6oZGoCaKYafAi8L79vVTiqAgSwxhWlI7hxLNoQhpmqNRWK0JaLx3lIcjMqNJU4tSMneMhDgDGXORIiiOanRFYjJXt1OUCzFLmx5FodvkYwjzBKqgUYR5xSvhv6jIPSq/bRPDi+yptOK4TWUGIAhaGaQRQuPRqSHgMHlBcMK0nhA85EWKUYGsv4xYw8HeGHSCdoFEB5q6IogG7yHUZCZ+fiVKURM3H7VNSHGkOtYYh1lFMuhRTWtcqBACeWZJxLO8lKONxmvNbFxTlxVuvuOpLXVZY0JgrUhYLhQexWjS0CgoxJP2CxIDXkNqNLV3BIQi1TjAuYZBkZImMKniNarbNOykrqgqz6DXVb92dHR0dHR0/PM8sqJyvm3xRllfXyfL3l0D3ydOnOA3f/M3fyGl0/yYjDGcP3+e8+fP89WvfpWqqrh16xZXrlzh8uXL3Lhxg3v37rG3t8fe3h6j0WghMecis+Pn57Of/Sx/+Id/SJIkD/tQOjo6Ojo6Ojo6Oh55Np64yKCfsXf7dXrHz3LmAx+k2r/D4OwT9NY3CdWM2XRGU42ZjUekeUY1qbn88itonWCbGYQdkqzg/ssv0e/lnDh3mno6oaor0mLA3q2b9FfW2Ln2KpOpoNKUrDdg69wJDm69hspSBifOc/XlSyRac+HDH2R2uIPfH3LhqY+w+/IrjM1tcIK0qTcAZiPcbIZaWcEOlkh7KZNR/OVSaZNsSFt1qYAQJRuiCBJlj0hok3eGIIL3MSWZ5gnBtYlJ324yWhW7UANRiEqsgvUhbjS6EEVmCAHthFnV0MRpPZSO8cHQCs0mQBkCVVDUgJN2J7J92xDwcqSxRCDM9wdb6VWJ8MLOlNF//jGvXdnkM888zmcGOf/43auMDmsC4BGmDRiBHE2DRGmjozwsG2HWVPz7//gdBonm1NaAtbV1Rnf2sQjWQAbUQeGRo3Qo0MsNK4ME07aKSpte9SHE+U4JR+fJC00TqJuAk/keY/t6tGnUWOGqMXr+8xLi42cJqTXkuSFrJWWSJpjEkKUWZWJCT7dpRe/h7u0RN27ssX0wZeZdFMRA2aZTVbtHGiRWtGqtCVqRaIVtGurGYRQ4PJVKWE5TxGhUm4qdekVdOQaZwVqD0gplDN55dCsg535wfl4WBa4yF+gsUqjxeNqdVBTBB5SOjzeX6rEyt02oBuHoXlS7VSnoNm05fyw9r81V8XHFxy1NCSE+9/YGSmlqH6hnFTpJSDUYq8D0GE4rvGsw2rDSy9B9AMdw4pjWM4okI3hhuD9mqZfiBPYOS4peQZZolEkwRmGB1EJiFLXShLrCaIeiFcwEtLEcjhtc4zDG4AOMZw1745Iis5zZWCKzAe8aGq+xPUOi49/Fe0wI5NYwm5QMcoUkCXjHdFbS7xmshYNJjQ8aay1VVaOsYLOMPkJZdrNAHR0dHR0dHf8876io1FqTpuk78lhvpvoVYuLszfy9h8lXv/rVh7JN+fOQZRlPPPEETzzxBF/+8pcREeq65uDggP39fUajEZPJhPF4zGQyYTQasbe3x+7u7uLt4eEh0+l0ITPnty/L8qgiqOOn+PKXv/yOfQ52dHR0dHR0dHR0vNcxvuJgZ8bZT34GpGL72lXOPvM/UE/uMD3YxU2GmGyJot9H6j53rl7mtVeucOfWAcYkXHziFCoEDu/dYXlpiY2zpylnY5omoIxF4UmShMPt26xsrOIYs3n2HP1Byp2Xf0LWX2cyCfzo+e9xemuTtbPn2Nm5TxJqTlx4nOsvvsTrL15lxSRo5QgCwUTBlJp9Rnd2WX/8DHZphaSXopm1FZa0icl2P1K16TZl4vdiStrvyTTeh3ZrkSgdVayP9K6VQtJuUSq12Gn0Ph6LF2nFY4iSk1gROyvrVqgqnIBp05xOAk0QnKgoNhF8kJjsCyrWkdJuV4YoLsNcT7WJOlRMJfoAZRCuVh55bZud7QOe/vjjfOIzT/DC915jdlhhlMJYWJIo6aYexgI1gIWi6DGcTqmcYlgLo1s7XL6zQ2YUqUChFb1WvDUhCjCj4vEflo5+P6XILYlViI+iLLEWL7GCtmlcW0droJVjjQ/UjeC8iynAdrrRGE1iDEmiSEyUjtZqkjQhTS02sWgb61K1Nov6UxDqOuCcYzgqub8z4c79EZPGUytFg4r7orRab7F5qTA27lsGrXE+kAZP7eNKpAQYA0kvYW2tANEkRlF62DkcISQ473CNovJxZ1FL/LmSSMCLtLuVURhqpRAVk4ZxX3KehIwXa+vS2/fbrU9tFscsStDSSvc2sYoEQptKRUUhrPT82lftFqNGqfaX5LVu5Wib9JyPqKJwVU1TNdimolhbQrShdIqyclg8iQgaR9YrqGpN2TSMJh6XTDFaMw2G4X5N2Xh0CCSJJ7OWgJBbhVcqJoyrGpsmNE3aymLPpIzVy7iAEkVmBa8sVA7XfjL3taD9DGcLpk7RzxOKJGE6nqHn9+0Ds9qTpBnaCs45ZmXDUpGQ55ZxLUyqwNIgIS1yxqMxqU5JtFDh6Rfvrp+1dXR0dHR0dLxzvKP/lfBmU45vhjdb/WqMeceO8a1gMBjwe7/3ew/7MH5ulFJkWcbx48f/iwpbaYfrm6ahruvFW+893nuccz/1tq5rxuMxBwcHjEYjDg4OFqnMB+VmWZaMRiPKslx8fP6x6XSKc27x+P8t3k1S9Etf+tLDPoSOjo6Ojo6Ojo6O9wx1I2w+fpHrL/+YrL/KyQtnuffDr3PzxRfZeuIpLDPu3x/S62Xs3nmdqhHu3h/TuEC/yNi+eZPHLpwiO75BUvQZ3r9H3h+AsSxvbdGMD9FpoLe+RjkrefJTTzLdv8fozl2OnT3H3Zv3Ge0f8vjZ07jguHXpBU6cOk7SW+HqCy9ESdPvU42G9JVGRGH7Ban2yKzCjQ4hXyVdPU6+NkCbA3wT2hpM0NZGmRME01ZqzmXiUTVsu5UY2gpT0YQASgcEjTYGIRBc3L0MPuB8FIxBJO5HhljNGSSmBL0LbQWo4Of9pfPEocR9RCeq3aKMtwm0W5QiNCJ4FF7FhKWodnNQ4o6ga9/XSnEgwjUnMGmY/D+vcnJjidNrfbzzKC94IzQokl7O7njGfhOQ3jIf+/zHePWV13jh6pSgaStxNWUTqFwUXomGfhKFZRMCGkVBlGkzJ9zYnpBZTWY0VmlsosiMxRiF1orQJgCtBqNjulVrS68ArVO0jgLPGIU2Bq2jDNaamJTUbTJWaYKAqwRRDWVVU84a6sYzmVZMZ3F38rBqmPpALbEaFCVRCGqw7bZkENU+piaxGpsmjGc1hcTXFQGrYh3s1GiOrRacOr5GP01YGRTsjktGr4yZjA9ZUhoXQBNfb4NCicSdUIlyMcrlKCmN0a1Fb2uH29RlGyptq4nn+jKKaq1Vu2MZ612DhFi/2xpKpdv7EgCNzC29llZux2tSaYVNTespfZtm1ZjEUNcOEUj8jH6/hxaonVDVDYmxpMbQVDMaD7WrkCShEjDW0gTPYSXMvALiz7lEaaalI+spUqtjiFQCjfMoa9BeMMpjjaGuAlprKickKpAlCoVlZ1gzmlYk1rLZ1/Qzw7QSmumEvJ8znVWkQZDgcWiCaxdgtcKFBlEWSTK0JFRSMz1saIIm7eVkgwHBgzIpBgh1yerKgMOZf1u/3nZ0dHR0dHS8e3lkf53JWvumkpGz2Qzv3z3/8fSVr3yFc+fOPezDeFtR7f5JlmU/Uy3vXBz+197+rB+rqmqR5pwnNofD4SLBORqNODw8ZDweL/784OCA3d1d9vf3qaqK4XDI4eHhW3AWfn7Onz/Pk08++bAPo6Ojo6Ojo6Ojo+M9Q2+54NoPn2N4UJJtbnGwd4dyOmO4O2EUrrKcBq7dvM3+cMbKoB8/dv+ANAS8gfc/+wmqwwNqX1ONRuT9Am8sW6fOcv/qyyRpjsoKlNZsnTvH3q0rSND01k5ysD8iLzLWtzbY397HlyUffOZTjLZv8/rV1yj6fe7e28NohSdWYYYQKIcz+ps5IXj2f/gC/OYvYZY2yDeWo6hQOkqqeZoytHpSEUWQ0nM/tBCLMq/YJG4xGptgrMV7j8ktUjbxfjy4EFqhGNr7iCI0SLtFuRCKgraW2jnwAaWIAlIpgo9VsY0Igbih96CkDK3AjFJ13hY6zwG2tZ4y/xM4CMLrDrwR7M6IjdKwZuLxSIhpttCUHEsUK8YiBRSTQw5v3mUNKK1C2SiLGg0qRPlatW/LROGFWH1qNSbEOlktUHqPVQ6rFLpUKKrF1qRibuCA9rVRirbW1WCsIjWG1CikrT1FSdwV9Qon8SzoNvE4F8S19zSuFX1ollf6bB5fYffm3bjr2SYY4zakQql4W6sN2sQUZZGn5EXO4bTCB0clULepSKXApwmPnznGieNrrCz1yVJDliScGfSpvaO8do86zGh8QAVIdJSbXuK1iggqCBZFEI9Wc4kYBbdRJl53bTWxBDlKeyrQSi+Sv6rtkQ1tna7WQGhf/fneapjrzTZhKUf3ZY1qN0IDwQVM2iZZDTgXC32NtdjU4D3sj0qCrxbPe1ZVNMqCFqQqkdqxVmRMjWFvUlKLR4xGq5iaNYmlSAAV4uZq49BasEYjAbTxeO9i57G2cdNWKQJCkqVMZoGgNVkvR5yQKKFuoHQNyijCrCTRljRx5L2ExmkaFz+HE6NwjWdaNRSrXQDfAAAgAElEQVR5PD1OLE5D2s/Qeb9NTDf0cksAjMnY3ptQNu+eX/Lu6Ojo6OjoeGd5ZEXlm61+HQ6H1HX9NhzRW0+/3+c3fuM36PV6v5D7lA+L+bn4ec9JnuesrKxw6tSpN/x3vffs7u7yF3/xF3zta1+jLMuf61jeCn7pl36p26bs6Ojo6Ojo6OjoeAcpZ56s6DGoS0b3rnP9NWFpcwXnPX5/jzvDCbt7QzSeW/dGuOmUTBuOXzjBYxfPMjwYsrS2geOA1WOblJUDV3Pr0gsU/WWmVcPGxhJpqtm7cQXBMp02uPIuS0sDQpYw3j/AKsVjT32UOzevUx4MCRju7wzZPLbOeDph5/VdllRM2GmlaMoGjWZy/YdUhwHTX2Nw6jTWvkjjogzSxqCNpqlc3P0j7ju2gbZYranatOR8D7KNtomAD55sKSPJLRPfoERHgRY0tJJSEEIgShYh7l8SdxpBsTJYpm728CEm3wKKxguNQI3gfJSX843K+b9Lq/lidSeLxzraH4yblVrAAA7Y95AT+FiecDzVpIq2MraVnkGRGXBB0VQle8+/xNkE1rTmUGDsYeQFh1C1YkzaPclJ7XG6XT4MgZ6K54CgMAosGgPYdv/RiLSZ1qN61vjGR0nsQTVR3qLm+dejm3pCmzA88pzz6tb5dmeSGPq5BW0YucDBzhinDKmNVbkKjTWKzChWlhIee+w45x8/QTmrOTiYcf3mDnjYH+2hguACeNoUZJaxvLUGVlHOSrQITW6hl1Eo4cLJ44TVDSbf/yHBVWhjcL6Jx9UmSQ26vTZiUtUTf+nYtDLWi18ISFBx5xKF8x5jTXzN/HxLNZ4FrRbNrW1KOL7I8xpjaROZ0l7EIoJtbxO7jeO/m9TGayoEROv4QatpvGY4nlJj6GcJVlXUzsbjNhqPMAsKrQQ3nnB3WJEnll6R4p0nOKiDYznTpNYymc7wwdPPLAqFtQatAlqZ9pcFFOBIrW2TyI7RpGHmIMkSBgg4T/COqRMwNv7ighfyVGEzg5iMuqwQrVEECqvYmwl5YVFJEl+7sibPE5Y3VimnNXXwWBWQJv7iQukcjRPSN1561tHR0dHR0fEe4ZEVlW82UXnjxg0mk8nbcERvPZ/4xCf44Ac/+K6qqn2vYIxha2uLL33pS/z5n//5L4So/OIXv/iu21/t6Ojo6Ojo6OjoeDfTzKasnTzL6sktVvcPkFv3GI6nTKYlgmJn75DxwYTjKWSVZ62fcvGpx3B1w6wS+ksFh3u7nPrAh9m/c5Pd23cpR2M2tjYhNZw6fZpqNGS8P6T2itlshEGxcfwEVdMwORwxWBqg0h43XnkJrQ1l6RgdjDh++hSNTti+PWLiNcfQGBGqac3y6jJawB/cYHx7m7WV4/ROn0WlGlW1kiYIdeNiwkxpNCHKmhAWW30hhFbyRNGjVPyfKAOJwuQZSd/QDzDcnyAEnAux5UgrQrtdGbwsZKcP88JTGB4O0cbQND5uUErAhVj56qUVnIGF0PKi4mxgu1QozINz0VCpVh5CG6RTMdnoJDqo40ZxvqcZpFF6xbRojGSKgSQITkUplyEURrMaNFMnDBvPgcC+14wQZkATzwqiQAcVn7NAJfEI5zORViBBRWEZYm2sbY9Xq0XD6UJbRuZ1pfNkYFtRygPSmFh1GyVl3PIUILWw1M+wNso5o4RZ7Ui0pl8kDHopg15BllnyIsXmlt5SH4Xhi7/5FZ77m29z4vEn+dv/6z9F6Uv7GCLoXo7qFexOKsa1w9oEYx1SBowC7wNp1uC8Z+UD55m88DJVE8Ws1jG1qFWsAtYSN0eDxJreuXCO+5KCbhOn4YHUpGpleWiv23naVz8gLEHFKmMVLxwloJS0zyEssrdx3qi93NvNVqUUznmSIkXCPNFpaIj7kP0igyagJODqAImimlWkqSWIIi/6+GqCyTP6E4chYJ1DK8FbRY5B+cCkLAkS0AGcdwgWCUJqNVXlmFWB1ECe6pgwdoGyFqZNTZpYMiP0LNQq4ETQOlB6RQb00rhjWVWOuq4p0oSZKJyD4BRZkWASi/NCg7C0tkyiBO0qcIFBqjDG0jQwGU/R1lIUlp7tfsG+o6Ojo6Oj45/nkbUWb3aj8urVq4zH47fhiN5ajDF8/vOff+RrX9/tnDlz5k1dh281KysrfPSjH+2kdkdHR0dHR0dHR8c7yNLaOo14eqsnOHb+IrPwD9z/4SWmoymzYJkMZ/Qrx/LaMsvHLKfPnSD4KY1Eyen6fTbPX+DGKy+zsr7B6rFjvD6ckuQDjp1c495rlwl1ibIFIkK/3yPNC2bVjFDXbJ44yehgn/LebVbXN7l/7RphVrK+vsruzj537w05nFSIKGbe0VNCcJ5yXJOqBr97i/GVq6x/9iz5sVOkg4zqsMIfab4HqjHbZJmC4B8QQ8xFEfggiApYHxj0l6gmU8qxoEVRTqY4HxNvSim88/H26LhRyTxlGYWSIEgTN/N8AC+BBqEJCheEEATvW0GmYvVrPGJFUG0tLVGAhVZgzUt5tBB3EBEsmobAcQWfHCRs5ppEq4UZDNLWgqqYhDOtRJzX0zqtyZWipwwDHeg3gV0PQ6+ZKKEWwSswWmESTe2FsoHcqIVEdMQ9zpT4QxwTwKPQ7VSiopVysDjnbdFrPGftpuOCB2ptfbvXGVOJQp4YttYzNtcHbB4bUPQyHv/Qk0ymFVcuXUMJLC/18CFw794eo8mEIhTsDyccjvu88r//Oz7z332RL/zb/4XR/i7f+OtvR6FmDKurBTrL2J3VDGuHR5g0josn1jm23KNsAq6Z0dQ1giEYg+73aEZTitTgQ1ikQ6MEV2gTBaZCoeILEYXovBZXx13Lo3bfuZCMMVytdLut2UZ9aSt9VXsfKqZcZd7chGZ+MlW0p6hEoYIgLgp8hUKlBlycFdJ5SjkrKdDUzrFcZIg2zGYNMpkhSnMwKSFJcdWEfk8xqwJFkaCDJ7hAPavo9TIqEcazMlbX4jHG4OuAMw7lDI0B7zxWa4oiIUktk2mN9zAsHTpAiiMEYebjzqzSQpIkKAFpGhSa8cxTJIq+1bE6OASGTU2aJqRaUTuH847ByhJZkWKCUNcVPQNWK1Sa4twMqwVjAqu9FGu66teOjo6Ojo6Of553XFS+UxWl1to3XHM5nU758Y9//K4QladOneLZZ58lz/OHfSgd/w2OHTv2CyEqP/rRj7K1tdVVBHd0dHR0dHR0dHS8g0waob+0grjA3//Hv+HVV14DL6hgmW3vsp4Yeis5a2t9jq33CE1F4zWr62vUITCbjrl9reTUhYvcfOV57t+8w+apM6we3+D21VexNiVfymmqiiTvobKc2eEYEUVv7RijvT0IniRJuPfyS9ii4NSF81x69RaHwzFFnrE3C9w+HHEyN/QtIIpqVpMMEnQYc/MbX+fcs/8zyepJ+purHN65E9OEEH8RUtFWsUaJs0jtyTzfBqJ0FIcAAq6ucfdHJGlMpBmTgNIE8YhEaRQk7lkGmctJtZCUc9kURHDtWy+CE0UZPI0cCc2Aaj+uYvqufR/m+5RH9yet3BIFun0iVgk9gc/0NO8bWLLExGratiPVSBSarRNDKYWReC68CE0QLLKoa01RFEqRIIsdRDGaWoSm9rhWIbp2k1Pa+F8tcUs00ZCiiY2jMe03l3cxSHi0tblAxdf16M+krdE9SjsqEbRWbKwkFHlCL0+wieXpf/l5nvn1/xHJN6jrkrqscY0wPdjh5vN/y+6t17h9e5sb1+9y/daQ6c4Bn/ncZxhsnuGZf/XrvPSjlyFRlCbh2s6EYVkxSBOMURzMGvYnNT987T5nNpY4sdJjpUiwdaAJDQfDER/cPIYbXmdWOTKrFpW3Mb0oi2tDqyM5qdW86pWja1AETZSSSqu45wmtoIyJyYXqbf8sCmyJL+ziXM4lvbTXv+CdtHuhgko1xmrcrIw3RZMdP8nsyjWmwwmb6328VjgP3se/55uGWRlwwwMGgx7jidBbKkAZrHOMhhMICt8EfOMxWoN3US4LKKMxSmGtMCkdiXasrBSkRY/prGHqYVgGUgUbfU0vMQwbF6OgSseEZaJYTi21i9XKiTUkVuMlMJlMUUax1EuYNh6rDMpY8sRCCDR1TeMDBQGjo/wMIlitSVPD0iAnRUjy4s19Ie3o6Ojo6Oh45HlHRaXWml6v94481ptJVN64cYNLly49UPfxi8uTTz7JZz/72U48/YLT6/V+IepWn3nmGTY2Nh72YXR0dHR0dHR0dHS8p/BNyQvf+Q5XL12jqj1Lm+uMtu9zrJfywY+cQgFFv4dTCUtbGxxsbxMSS1CBvNfjYH+Isjk//rv/jLUJH33maXSW8NpLL3LsxElmwwNc09BfXkNZTVNXoC1p3mc2mdBfWWe8v83263dZ2TyGynJeevEqInDmsZNcv7PLrJwi4pkFCBgSo/DBo1SCSQz+8o9oRjV2+TjLZ7a4/5M7aN8mEtvUodaxIlTmnazzNJ8IouJ+Y1usGpNwCppZQ1kqrNWEMIvny0VRKaLbHUtptwdj8g9asaQ02igq5+e5TupW5jVB4dotSs9cxkmbjIv7hUFkkTAU1APtqG2ysn3Mea3q+1PNx1YSVvo2CiynUDrWhiJtPWgrA6OwbN+KQhMrabWdP0a8zxph2sDm8Q0+/OHjfOO7l7k7rHEqijU7F5CiFtLXEWtsgxIyUegYp1zISdrXBAQlsVJ2/lwUEhNzqq2tZZ4wlUVlaZFq8tySZpZXb+xTbI9ZP32F8x+9zPrFdYr1J+hlGd55qldvcDj9Hq9cvs/lK9fYvj9itnfIcqq4/uKPufz9v+flS7fYPLvF1rEBaVEw/PtLDGcVB9OKlSLl9HLB7rRi2gRubg/Z3huxudTHakXV1NRVg6w1fHhjBb+zj3Nxy9F5wRCisCOm+4pEo7SOknK+4dm+xotaVxVrY+eidn5eFQqjdExIAkHCIh08v5oX1brzPUt0vJvQvqjt7TQG8YLNEsSD+MCta1cpnbCUWIaTBmtD3HdMNL3BEof7IwozpckSJtOKtFcwORhz4uwJylmJMZpaNbgAzgeC99Cmk+smPqd+YamrQKYhyy1JmlB7z8GkZDhx9KzQ10Iv10wqhyjDrHZsrSa42mMUVE2NNgkahTEBlWSIKIILmDShqSuWipzaB7IkwTkf5Wlw9K0l1DUuOHRqGCwPqOqG1aUC1zjILNOqenNfSDs6Ojo6OjoeeR6+QXmbeKOJyhACL7/8MpcuXXobj+qtIcsyvvCFL7C1tfWwD6Xj/welFCsrK9y+ffuhHcNgMOAjH/kI/X7/oR1DR0dHR0dHR0dHx3uRV577HjaxfOjiaZrplLt393n6g2cYLBlM1kfrQJKvoI1m/84tZqVn9cRplAS2X7vB8cdOsb+9g04yPvbFZ7n56kvs3dvhzNkz3L92lcRmbDz2OG42ppmOyYo+DkdzeIA1ivu3buHKCWff9zjTyYSbV28w6PewvZS7e4eMJjW9LCMMHOO6waNJrCYQCMpgjOBGd9i7dImtD21SPHYWk/wTtQeMRgVBK4Nvk5BKSysaY9VokEBAoY1GKQguoIyGEKIM8oJr5g2dUUCBXuxQ+jYZGdq0m/dCQPDBI/4oYRkkCjxHwCM0XnBx1RDmRbVxiBGY5+GkfTcer0LFdGVbE6qJ+5TrWvHZZcvGkuXUkyfZu7nP9HCGipFGJBi0butt291Io03c6BTiNqSOMjExiiAeF4TMKE4t9XjqC09wZ1iyN/OLhKcQxexiB7MVZQhHclFBGqKEo/07ar6ZCfF5tO2ni/CmsHjWzB9L4vZiz2ryxHB3ryTslwRRTL3wt996njt3/zfe9+GLnL7wJDZf5vaN2/zkB9/nxvUblM7z+vYBYTRhtcg4eX6DnVnFv/tf/4jQNFireP3uAR+42OeXn/0Qf/uDl3n+2g47kymFNvSswdpY15uIYjSconRMOGoUV+4d8NTnPoVxr+CHBwgKLxKzkSpuRgZi/e/id9XVUQ0xrXg2Jsrtefo3+HhBaK0X51VE0EoWJ00t6mOJe5McJTGjpBS0UVFw+njdKBwKjZvWGKMISiHekxd9xjOHaENuAwUeXfSp6oa1tQHjPOHw7iGTmacvM5SC2zfvcObJx5F8ifK11/FNjcLHJ6Y1VsfdVaPBhZjILTKN+MBk2uC1wTnYSBWrhSa4QOk9Kk9wM0+aGsS7mJwk7oNa3eC8IumnTLEMd4fkCSS+IssN07pBmQTtPEuJoQmBpo5blst9w6QSijRlNKmiIG4asjyhdI5GvbHWs46Ojo6Ojo73Do+sqDTGvKEk22Qy4Vvf+hY7Oztv41G9NfT7fX71V3/1YR9Gx8/IysrKQ3388+fP8+STT3b7lB0dHR0dHR0dHR3vMCsb66yuDpgc7JP3LVsfeQy0YmVznbquyPrLTHb3qMoZJutx/PQJyp27HB6OWVpZYvvOXdZOn+PcsQ0uffc7LJ84w2MXn+Dmy5fprW1w/PwZ7l15BYJj5dhx9nf3SNKMvDfg4N5terll+fTj3Lv5OofDIeeeOEdlMq5euYauPetWE3oJmfSo9w6pnCdVkFpNOa3RmSZM9xm+/GO2PvTLDC68H53/3+hSopyxBtf4B2peNaqteQ0EAhoBkl5CkSUcDmegYTpxqNhoynxI0fmwSDmqechxkRSMom+R/punM4lCr2nvK7QpzPnjOvF49f+5z/Zv+zZl2dqsn3rd5vffA57uGy4sJ+TKsHNrn2pcxsSeUYRosFBax10+dDwPAcTP60SjUIrJxoDTGtGBrJ+xcm6D5350gx++tk1Tewxxc9Kro6SetNWyoX0CClCiaIgicr6HqVAoFWtt588otBOi8/TgvPJ2TliIS8XmUsrprWWev7lHCJBZhQ/CwWHJCy9c5vqVW9jk29QhUDrPxsYKXsPV1/fQwEeeeoKsb3HiGVUlvTwjIIynNYjw4is3OHlik0++/xyJSnjl1n3q2jEr61ix255ziMIsVocaRBn++rs/4t/88pdw//g9wnB/kRyd3wakldrxYgmtpNS0Ire9OqV9ySXEnxmF4Nqq2CgiUQrf1sjGC0YtpLUsrklZXDLxJWnTm/qBq0gblA8obQnBU7mY9q3KmjRL8UpTlcKknrK6tsxh6RFlKZZ6BN/gnUcpqOuGmy9ejY8lHmUVvoIsMRgNxibYqony2zmWioTGB2onTJuGxtcsZ4bNfkLlhdGsJs8Tyrqml6UYLRgTz8U0KMQFtLH0exad92imTfwcFUWvsJSNo6qELFFk/QKlhF6i8bq9vnSg6BdMZg1pqlF4TFGwdzBCW0tu65/5a2dHR0dHR0fHe4tH1lwYY35mMSMibG9v81d/9VfvmtrXj3/84w/7MDp+RlZXVx/q4z/22GNcvHjxoR5DR0dHR0dHR0dHx3uREyfWqA932dhcZXVzjXwwoL++RlmWaGU5uH8fAWaVJ5Cye/M6q2dOs372BCFNOfXERZSruXP9Ghc+/BHUdMxrP3qevFeQELj2/X/Aas3y1nGmoxErm1sMlpfZuXWD1dVViv4KN65eRSnhzPveRynClZ+8jHU1ywPL6dMrrK1lDGvHlZln4qNedC4gSmN7GYkO7P7oOUIV6F/4GMWxZVBgjMVmCdqaVsLF9F/jQ5v4iyYnL1JsZkkGfWyqQSuM1VGStXWxR9+GyyLpOK/alFZOzv/Rbd1nWNwqCjkv0MtTQBOQVsKBDxDmkhPaFF4Ue6Hdo4x9rEeCTwFGwROZ4gPLhr7VSBDK0ZQQAtoqemsFa+dWWT2zzGCzR281Z7DRp7/RY7Dew6YGrRWasJBdqq1qdYnFDXp8//oe3331LmXj5jnH9oc0gle0O51HdbRHZwhCUNRB4dqzEPc6A16ihHW06VMRPPE1CQo84BCcEoKKr5Mxijy1pHmK1nHL0xhNamLCNk9TDsuGRmvGtePYRh+vDJdf2+XkyS2e/vRF7JJl5h1l7akrx+nz5/nAM/+CxnvSJMF54dLVu1x65XWq2ZT1IqOfJvSzBCVCFRwz31AFh5f4mrvg8cEzdo7/l703i7EsO8h0vzXs6UwxZ0TOmVVZVekacJWrqIJyA4WN3bTgWjIP5qHV8MoDPCAZCSEeEJP6zfIDQgZdCd0HrnhAfVvCuhf6CkzbTXNddrrmOSvnITIyhjPuaQ33Ye0TkdXYyLSzMtvF/qRUnjjDWnutvSMUcf7z////+V++hvqRZ4hWN6hcWId3jZNVhGM2rhEY5fzKEDjrcM6FyFzrg4BMEJGVCh2pUoJUoIRAzvdbBLlaEcROJUWIApb7GmYTDRyuVCFCN6OU4bwjw/XpgFFZ4wR0spi6qLDOUXtBlkTMckNZGoyxiLpkcbEXJmkE1LKqqCtDmsYsHV4nW+gTR+GcaWHpdjRKaQRgbIj8LUvHZFqTCMdiR2LxzIyl180QUtGJIrRwaOHChwq8J9aSTpqQJAoZpRSzAlGXZKmi24mpraUyHi0k0jm0MKTKga/R0qCwCCTFaEpGTS+VeJVx49Yu08KSCUenNVS2tLS0tLS0fA8+ko5KKSVZln3f/Y3ee/76r/+a8+fPf8hHdnf4whe+8C+KtW25v9xPR2WSJDzxxBOsrq7et2NoaWm5d5wcSN75j63j/m7xta99DYAXXnjhvh5HS0tLS8sPL9Yajj5yhvFwSHdhFWsMVVmDSqmNIe0u4JwhTms8hvUHT7G3s4OtPcuri4y2b6HTHkePHePquW9hjGPp8DGyjmZ8e5vDDz2IjhPK2ZTB2hqzvV2q8ZCl5QXK2pAP91hYXqG/tMblS5fJt26zvhDjhGSwsoSKIy5uF7y1NSWvLHuRZtUFkcVWBmM0OpLkV98jv7lJ9/gaK2cfZPj+txFSEPdjpAZbCYqZoba+kcckOIg7MTqWJGlKNZ1inA+ijA29es7LILy5uSzZRMbO3XUiiJBBXGyiVUWIkcWF/knrHNZLDB5rDWmsmOUG27gRmzzUMOb8LQLBvkg5j0x18x5DQOJZVoLHu4oHT6xQjWYUeRWci0qw/vhpjn/ySbJDa+CCE1TqBKkVxc5ttl9/i6v/8Aa2LpvY1xCDu7y+yPT2lNwr3t6d8dZujsGD9KHP0oHkoCOzkcD2RSsa5+g80tUSnHpeBul2P+p0P911vp4D4W4u1tKM7UX4urKOk8dWuTWccu32jNo44lgTxRrSjMnekMRUHD+yyPWdgjffvcpzzz7B4oJmOBqCC1GtqCAKn3/3fRaWJmRphPWO2oGtDYudFCUt+czsdz8qmk5S4bHe4RFoIRsbo0B6mJQV/8ff/B1feP7HiEZ72DoP4qvzGAHah/hY7UBJgVLyIK5Vig98KF3MT/xc/pUChTjY3Hm3J0GcDJGwc3Vy3vXZVFN6sMYAglh7kBLrLADOWiyCUmpEnFBWNQ5PUdYMIsU0r4GKtJMiBcRpRFXULC51mUwKyrICC1LDdFJQu23Sbj/EAntDUdZoBUIpEJJpYZkVhl4q2egoOmnY19ujgihSlBbyskZLSBNFFGmKvEZrSSI9RVExtIo4qdCRoihqqsIwsRWpjkiUQCcRSjiU8KHbMo2xVYWOU4qiIgKSSOO8YDqdIJOE1TQi0xb7fb5H19LyYdP+3dzS0tLyvx4fSaFSKUW/3/++n3/z5k2+/OUvf4hHdPfo9Xp87nOfu9+H0fIvoNfr3be5B4MBP/7jP/59i/YtLS0tLS0tLS0tLXeP4z/+0xQ710jjRfLpHknao57cRkUJTirSwSL5zk26S0t0ujG3b27SXT1M1u+zeekiKxvHcfmI62+/QRJHyEQxG+7i6i5HHj7LcGcT56C3vM5w8wpaK7pHjrN9/SbGGhYPrSGyAVcuvI+bjDhyZIW02wHhGU9qvvnSRd69NiRWiiiCofeUzpNIhXMudFbGGjUdcuv1Vzi58ZMsP/o4V//2HMY74m5C3FPkOyXaCeppFcRB6VGJJltIiVKNMTWVc1SVoa4MzrrGJQn7AiUHXYx+Hu3adD76Rk0Lca6uiUMVeG+D61CEWM+8tMgkDqJjI5nOfZeycbdBiAx1Isyzb+e8Q8hKBDzR1ZzoaqTWCK3x1Egl6Cz1OPYTz7LyxJPo/iJSZ4ikh+wuQ5zC9Abd9W+we+Emk+H14AAV4JHMathxgrcnJW+Na0rn7xDN3IECSRAsHTCvXZwn1armCy/EvphpPOjGASiaPsp5j2JYYqNyzp2uNGKl93gvMc6TG8fecMYnHjlC5K+T144kSxgsdqhqw/Ez60gl2BxWvHNli7OPHGVpQWBcGc6ldWSJRscJdVUSR4JyuoNUKqjCwmOdZ2mxS991GY+32M0LnLEIBIlSIDy1DesWXmCbeFfrHVoIKlPyF//9H/jU6SOc2r2Fr6umE7Vx1Uqord3vCGV+HTnfCI7hnrCv4ZaUCubOzH15sol9ba6ruUrsvA/xqFIg/Fz4Fiilmo2mucIkKI+3nlpKnNJMxxV4G5yqXjCZlAjlSDuKqiwwCJJI08kSiFKMhSRWVLUDZxHCUxcl3tT0F7pY0QGfMy5qXFWBlExNjbOO9Y6ikyk2hwV5XeAEpMogIx3eG5BQ1J7aVGRaEilBWXuK2hELwTQviAuJsJZMC5Isw9YVUiq8M+hUU9UWkFSzIlxsJkdKjdcRFYq8NKhen54pWF5O2ZsapCl+8B+qLS0tLS0tLR9J7qlQKYT4F/VG/s+itf4XCZVf+cpXeOeddz7EI7p7PP/88xw9evR+H0bLv4Asy+7b3EtLSzz77LP3bf6WlpaWlpaWlpaWf81sXb/IO29fJlGKhx88xuaVSwwOHSZb7CPrnJ0bt1hcPYTJc3Z39lg/cYprFy5z8+JVjp45w+0bV6lHI9aOr1PWDmU92jn6/R433n+P5fV1VJwx2bpGt5tROclwd4coS1g59ACTyYTRxffJTEF3ZUDv0GEclklR8vbFy3gnWUGmxGEAACAASURBVO8nrMSSizs5l/KSByNJPxJ4A3VliFMBZsbOy9/h2PPP0X/gY8QLGeXmDFM6uoe6eOewxlHVCoxEaImUgjjtYG1BmZfk45q6NDgXBCsAhMA5S3BSBvHRNjGvjiZOliAizUVMEE2/ZNNJSYh39YS+yrwwyMbVJppewhDBGsYO7kQRwmMbsa/xLQJB0DoTC872I3qxZHRjiA+Fkyilcc6TDwvKyQyZ9VFpguiswupZkAqfb2Otw1iLF6HnEQnGwdbOhLcmNe9MDYWZm/qCMDZ3UUohUPh9F6lv7H3BJdnIuGLeohkiR30jTio/3yOaR8NL7nSOBjNquEN4Qh+jh51xwYWrW3z6hcd5bhAzqyUvv3mF2ljSLAFv6CRdtmY5Jw+vkGawuT3EOYvw0EkiTp0+yaysGW9vEmuFlholoSwMZVmyO57x+vs3sVYwmhShKxJYzBSPHF1mNCvYHJdMKkNRe7xzmEZstt7TTVLGVcnfnr/Kp46tcHo8RDqDcE18a+PMdB5wFinkfp9lcEeGzRBC4J1HSLHviBUiXGdKNa8JJaFhdhful3i8nBdUNi5fwnxzQVmKpkfVS7xw5AiujwsyFZHXjlh7Ug2xcHQ7GuuCiC60IK8t43GFt2OiSNJbXoLRCFs5EIrKGoQTVKUh7WoGCxmlcTgD29MCDCxnCikEO+OCUelQUqGFJEo0AoehBpVQFRWDVJOlGq81s6IkSiKyTKKMIM9LOrFC6ghrPcgI4R1aCYzxqDimmBVIKdDCo5Wg8jVRnJB7i0wHqCJHe8PucIapPYn6yLZPtbS0tLS0tPyAfCSFyu/XUem955VXXuHP//zPfyi6KQF+/ud//p7sYcvd436dLyEEzzzzDIcOHbov87e0tLS0tLS0tLT8a+eb33gRLxOe/tGn8JFi48zDZKvHWDyywdU3XyJalGzfvEAUJSwfOsSVd99j8dAa670O77z0HWTa4+zTn6DIC5K6wtcVcjZmuLPH0QcfZLi9hd0bsrRxmPFkwnQ2I+v2SZKEnc1rVMMhqYbeygJSa8qyYFLDtSs36GcxKi9QkeD8xPHepCDzsGM9S94TCSjGJZHukHVTJm+/xuzmLfpHNxgcO8To5iWcrXF0iLoddGGIjITSoVONs4Y6z6mrknxYUhYmOBmbzNW511EKjfMOkPPUTeBAmPPeh95E5xsx78DxBi6ImEJgrMN6gQ1+PCQglaSrFcY7dBSzOS2buRorYiPnuUbAQwiWBDw+iFhKJM6BkA4hZNMd6TDTkvP/z9cZXdviyLNPs/roE+h0BW8suIL6xkVufuc19q7thnhQJRBaUZaWC5Oa96aWaSNS+qYXk8YJOX9XYt//uO8CZN9luO8MFKFnMWhmB5Gud2bpeCH2x5pLscJ7lG/cl819Fpga+OaFXV668Y88eHKNhx9/gvPDC9Q3xjx+fIlkqcs/Xtwjr0PvYVE4vKgQOBb7ESoSXLlyhSyO0ToiiTX9foeqqphqw3haAeE8ORvOQawV3lkWeilnPnaWzZ0RN15+AykkEgPeo/E4KTDO4vHEQpBby9ev3Wb54eOs3byO8w7rg9tWIKmNIdZ6bigNZ855RKOTyXn0rZR3CMBB0N6/tGTwXOJFEDSbsaRWwW3pgj/XWRfGaPor5+fDWYeXgklhiNKEaWEYdGK8s3QiFXoqa4utLYNeHK5YqfAq9Iom3Q7TSQ5IlFLUdbhoauupjSOpSsaVIC8deVkhgaVUstTTTLxnVgnSOIiUSmnymvCBAi9IvCGONaWzRFZinSSvPToTICOcN0gBhfFIUxErSaolcRTcrgZBVVREWhFHElvXeCmJlKbGk3QWyaTDJRH5uCASnjSWVOb7/9nZ0tLS0tLS8q+Ley5U3osIyu9XqByNRnzpS1/i4sWLd/0YtNYsLy/jvWdra+uujLm4uMjzzz/fxIq0tPzzSCn5hV/4hRA11NLS0tLS0tLS0tJyz/Gqg+4s8c1XLtLvpaxuHGdFDvnW1/9ftq/cYLoz5smnf4REeG5dusTGqVPksxnDm5uc/fij6P4yVy5dpp4VrCz1GO/ukfX7rJ9YYfvKRaSM6R5a5/r1axSFYXVjBSUFo+0tfFkwGHTIel2yThcfRVy/dpOtWyO63YyejigHKW/+40W2c8N6ljLKK26WjqOJRgiHEJBtrNJPDNWFPa5/+1uc2XiBpUdOc/XFC5gSnBE445BaE3c9UlucI0TMSkk1rHB2HlV64Peb/+ca1c0TnJay6Vn0vnFVMo99dc394YXeBWVvLiEJKfAu9CP6RnnspjFHD/UYzwxX96YYH0SgeWSnv+NYPIIIeKQjOdKLQoem83hnUUoHscoHaTPfHnL5719k683znH7hGsee/1Hk1beoJrtsv/wtLnztHNWs3o+ddUKwXXveyy27NkTShnDXhoNSyfmK8fOGSeHRc2F3XqMIjTPQ74u7bh4NO1cmD4oWD4Q0Qo+kE6EHtPZgm5xYg6cCbF5z883r/Le3riGlYDWL2SkcL71xCxkrTqx1qWtDmiiEEKRRxPM/9SneeOUlTD4FaZFKEaUxWSejt9CH7SGLRc14OsVZgdZQ1RbjIIoihqXhq//1RYqiwliH8VDZ4NQUQiCdRyGojEEqCd4xNo6/vbzJv1sZMBjuILwM14/0aKkbN6pHikZwlHe6TUOPJT44JIVrRF3fCMuE966cbYTy5kQKIVCRBuFxxiOsb7pWLV40EbdxI75bC7Fmd1phpCbVkjTSxEpSGIOOU0bjglQLiplAO0FZzuj2O+hOH+lqBr0+m7d20EJgvUQIh44ktbXsTeHCbkE5q1mKJauZph8JSmtIsoTaeSovMM4hY4msPVEcUZQGZyFKNLEUJEqyN63JIkW/l1HMclIlibOIvHRo71gcpOR5SWVARxJvDFkSgYDKSyqpUUiccaRJSupKpNJYLFknwgmJLeu2kqalpaWlpaXle3LPrV5aa6Iooq7rD3WOxcXFf/Y5ZVnyF3/xF/zVX/0Vxtzdj3UtLS3xuc99jt/8zd/kq1/9Kl/84hfvyrhPP/00a2tr7S93P2QkSXJf5l1aWuJTn/rUfZm7paWlpaWlpaWlpQVeeuMC49lbaC3JkpjlpdeJXc3O7ozVVPPQkWUmN67TO7HBsYcf4OaVW3hbsXHsOKPJjN0bb4PUPPjoI1x84xWiqEOn32Xr4nv0V4+glOLa++9jcZz62BPUxZidq1fodDLiXoaOY2SaUOqU27e22RsW9PspqbZMc8k3zl1gZ5yzkmiGs5JtYzlfwlnj6WUKKRTlNEdLTdTVlJfPU+18gv6Zj6F7f89sOCFd7QIOpSKEsEjpUbEGL5neHlEWFmMs3h0IiELKA5EScE3vpPBgfejQmxvdPDQCZxAjhSOMA9D4Ap13zO/yPoh5znvGtWXmPFvDMWUd5EGHwHo3tyTuj42HtUjw8EJCpiTWWBwudCUai5SglQ7uRe8R3pHf3OKd//R/c/NbL9NdX6IYjti7eI1iPA3HIwQGz96k5O1hzaZxuKaT845CQ2jEw3mvosDvx9vO+zrnHz+d+yBDH2XYj7BiiSUIl2H4Ru5sInKDMzM44rwLvZaG4Op0HMTD4kGJA/fh1qzkxjs3yDoZz584gvEWgEgLThw9zPbuHq+dOwcE52AaK7IsotNN6S8sUOZTkk6GF2PSJKGYVdTW0O9niLyiKGpq56iNxXqPFqGTVEuJscHZW3u3HwGMD8cvlWRzUnIuifnJrIsv8yYiGOraEsUSIZp+0EbE9b4RcoXAOVBa7mfiCjxSKqQKzspwnR182F5IUCrEueJlcFK6IDd7QEiPiiK8s3jlwBuywyfZu30eGQuksyylnqkFaz3KGHr9GOEcVipMURHhmY0mdPpdol4X42pWN9aYjiakkWI6zpmWNd46dsuKCsWg26FLhcIxrUEoSTUtKWqBwTHoaJRWFEVJnTsGGWSdmF5XU9SC3EAUaeJUY+qatOnF9M4TR5pUyhBj7AXeGaxUeOfJ84LayRBR2+8yqiq6WZeoLsFCUc6IYk1lHaYKMcxyLsi3tLS0tLS0tPwP3HOhUinVxFZ8eEJlHMdsbGx8z8e997z66qv88R//Mdvb23d17kOHDvFrv/Zr/Mqv/AqDwYDbt2/ftbGfeeYZVlZW7tp4LfeG+yVU/szP/AyDweC+zN3S0tLS0tLS0tLSAmVR0400KolZWeqgrOHW1pjD3YQTKx06meLYA8fpLnTYvHyVNMtIO2vc2tqmqgo2jm2A9bz70kusHT5CWZTU+Yz1Bx6kmBXcvn4DFaccfuABxpMxk+sXWVpaobfQBVtRVJZZ7bl97RLD27sMFnoceeA0e8MRr730IodX+hxdW+LvX7nMbmnpacnQerZqx1Iqkbam2B2TLqyQLmTMrr3D5OpVeqtLZEt9Jhd2yYdTokxjigpT1DgL0nvqfEZdWay1QX8LVY2YfUURvHeNfzCoYlKGiE7fqGZzDZEmItU6t99TuZ/f6T3ehdc5uCMSFqal5e3L2+CD82s/9rVxJjYj4fFoITidSQ5loYsvdGTO41MdzklqLCGuVqKlRAqJKwt237nA9nsX9t2czodORYSndoLbheVSYZg2HZJiLgo2xz/fEC+CI3Qe8Vo33ZNSgPKNB9PfEfHqfWPGFI0QBPMJvA/9nAejN/GwzZgOfyBSNuKn9CFO1uGbflBP7aEUgkePLDKrSpwXSDyLCx0efuwxXnn5FVw5pdfvIQQsDDJWVxdZWBoQJz1Go4y8voVUEqU8SaKxToH3HOp3GMqScV4g8az3uzx0+hjnXr/IqCgReOJI4kpCpK931LZZm3N4AeeHEx45tsrRsmicpQ4hBbVzwR3pZegk3Y8SbmJwRej6REAUxZi6Dtq1DK7dEE/r9p2UQkhEJFFxTDXKwXmcC6Km1hohQ69llKZ476lsxY1ZSSE0sRZ0oohSCuI4AVkTaYiTFGs9u9OCxW6MrGtk7SgmOcVkxmC5T1k7okhRVjVKS2wp2Slqbs5KelqTdjRxJJlVFb0sZpwbpPBopdBCMOimWCFxqUXEgC9xOPZmhqqoiaIgvte1RXhPYS1lYRAClvoJkRa4xkHrnMZIgOAe7XUSogiM9CwOBvh8FrpfJfSX+1SlwVYG4x3dTkyb9dTS0tLS0tLyvbgvQuWH3dnX6XR46KGHvufj0+mU3//93+fll1++q/MuLS3xe7/3e/ziL/4iCwsL5HnOa6+9dlfGXlhY4PHHH6fT6dyV8Vo++nz+859vY19bWlpaWlpaWlpa7iORgD6Wfgx2OEFZwyPLHQa9hLUjK5w48yDj7dtMJ7ssr63hVcTOzpBYC9YPb1CMdpmOJiwvr7K3vUtn0AWdcO3KTbyxDNbWGaytsHnxImVV0V1YorfYJ+t2GI5zbu3dopxOsfmMM2dOEnV7vPfuBd59/TynHziCs46vvXgeY+FYR7NVWMbGcqWwHMs0UeSpi5o6dyT9CL+7y/VvfZPTn/0kq4+cZOv9bYq9HOFjymmNNR5vPEhHXRqstaGTshHC3DwLVcz1NMm+kRCaSFTfaJNBELT7MloQlqyb+ygbqyDB7SaasT0e27g1vQ9CIfO591sZGyenOxDpBgJOZBoFWA9IGaI/raNJfUX64DR03ge3pZIIKZruzeBOPFhBGL+oHdcKy67x+/Gi4aDnYiP7HstGk0Xg0UBNcD6Kxhmp5nsnaGJN52ItTTyp2Bd33VwUhXmILL7ptAzdl/7AnbmvCDeHJiTWe3IHOZ7lbkYiPcPZjCxJOXF4icc+/glefeUlirykl8bEcUJ/MWN5sc/a+iE2jp0kihJ2bm8zK8asrvYp8oJRNQNnSJMEaxxaCrQUWAtOKL71+nny0tLREi3D8WotqWqLQKAEeBXW6b1nYgzvzSqOdrtQzGiCW4NDV8ggZM8dpfLgmpNK4CVI53HOIrX6oIAsmqtMgFLBfatijXMm7JcIYqfHhU5NrYIT2Dmc8GSLS5wfzqi9oBNrrHfktaefKfpJjBAWLSN2ZxVxohGEvkyhFZGSeGvJ84Kk+fBxhESKiOm4Zquw5HX4xhkXBlN7BqliPCmwXpAlEq0gShSz0lDVnpgaJQXGCoTU+52aiZbgBbnxTHOD9IZYBZHSW4v1MnS8ao+QmqqoUFrTX0hRUUxhBZHSxBhMnFBMR6wu9XBpH5sP8R7SpOnktG06WEtLS0tLS8t3554LlVEUEUXRhzrHxz72MQ4dOvRdH6vrmt/+7d/mq1/96h39GD84S0tL/Nmf/Rk/+7M/SxzH+3N9+9vfvivjnzp1irNnz7axrz+EfNjX+3fj+PHjPP300/d83paWlpaWlpaWlpaWAz5+dJFPvPAsN99+m9dev8Lqco9eIlg9ssHasXWuXrzIysoqi2urFF6xu71NL4npDfo4JemvH8fKTcrdIYv9PslSn2uXrpHFMQuHN/DWcOX1l4myAb1ORhpr0k7G1tYOW5u7VLMpi4tdVh88yWhS8PK3XyVyjh/7scfZ3Rnx0uvvs5JFDKKIN2+OkIBWkvcKyyNlTU9FOOeoZhXq2AZia4+dN15j5cmPs/7ss1z4b68ym1REqcYaj7OOvKjoLvagqrGNgTFEu/oDJc4fSIbO7+uNCCEaByNNZKcFZBMRG6yESkjs3PEoQz/mPO71g3/hB+nPuSAQWt/EojaPHTgMg1y3nkgWIoFxB2KjF+y/FizOg0KglQximPV4GURE70J8LRAERCGojeF2ZbhaOio/b8UMCqVs3o8IepdHeYFq9sQ2zr8IsARnJbIRFZs1SD+PgAXRxLy6Rnr0/g5xslmx378VnJIffG+h6Wtk3l3pmXlPSRD4nnloHV9P8ULTTSSdbp+9SYFz0OumLCwOOHzsKCeObrC4vEB/YYW1k48g4wX8298muXoVKXbodxOEqcnSjJXVFba3J7x/5RYgsB52R1OEgFTDkaUum6MZZe1QQCwkptkzhcCK4Fx1znN+d8LHjy6yJkAKuR9bG865QHjRRLaK8FijcUvrkZHGe4cQHqlkEDR9uGakFwjpQcrm2vRIpTCAkgq8BRkcr/Nz65xrhGy4dntC1MuogTSJUEohvUUIjbOOoijpxJpYacq8onIO6yTKWoQSSOsxRUHazahqGOc1VVWz3IlJEoW1lol1pFJR15ZurFE6CKtVVTPLDbE2SOOQWlJbQxwrpLMY60Osa11RGxiVpokrlix0E5wHrQRCKrR3VE5Q1zVaCnq9hG43Ya+wCC9IqBEqoZjm9LsZQmdMdsdUsykxUBUO62z7QeqWlpaWlpaW78k9FyqllCilPtTxP/OZz3zXX4DyPOdP/uRP+NM//dO72kt56tQpvvzlL/NzP/dzH1jbm2++yY0bN+7KHCdOnODUqVN3ZayWe0uapvd8zhdeeIHl5eVW2G5paWlpaWlpaWm5j/zUv/sJ3n35O9y4tsvZj52AcsqhE8eJYsn1q1c4efokaafDeJajqDlyZAOkYDaaknVSbr73Ht7W9JaWsULxzstvkS2u0F87zM6tGygXeuHqcoL2GpmtcfnCDfa2tlA4lhb7rJ0+w2gy493zFzl+YoPjxw/z+stvc/XSTR48scJkXPLSe5usdGKqWcVmWTH1guulYz0BVTvKSUFdOtLVLsWlXa7+w7c58+nHWTixzOTVLYpJhdISZxzOWPJxjqsNztj93kAvguvwgIMYTik8zofewDsjS/1+WeVBdGkQKT3OCbzz+zGeQRBtsk/nzs3GrmgJ4p+dH8sd/4JoCAs62OlqHxx8uLkwGCI9fbBfBsecFxhpggiGBCGQUmJdcHFKGYS/qfFcnBm26kacFUEslTQCpZsvLzj3aFyCCKiFJ/aSTHiMOIhmVb6JLb0jwtSLOzJeG8QHbogD2+rcfSnANg5CP+/J9FB6z4ywD0LAUq/DQ0czTh9e4K0LU4TuMhqOyGdvo6Qg6yQsDPq88G9/lrWHnkZ1VwGN0BHOWsx7bxFFCVGSsLg04PSp4zz7mZ/HkvDK1/+GvdEYkMx2DVII4kiBUFzZmbLcSYg1WFdhncdYh/U2OF5hf6+nxjJSCYekIk4jfF2H88J8j0BK1Zw7jxJz16WnqixKgdYKEHhrAAmuES/lHW+bWYGzFqTAWIPal9sPBG/wOOcYTQp26gpbKnpIYuWJouA+LG3NeDcnjTXaB0dnXTtq4xHCMXOgLXT7MbWDfFQwKy3jaUkXT5pJSLpUzlKMSoRzGA9WagZdTW0NRW4ZdBRZFlMWNc55jAHpJUVt6aSKSWnBQmUd/URTWEsWKRQVvU4Xbx21CX2V1lockn4/o0Zyfbegk8RIU+J1RFVVLHQjdCzxMkKJGo2nqgzOOhIl6PXu+VuQLS0tLS0tLT8kfOQclVprPv3pT/+T+6uq4qtf/Spf+tKXmM1md22+Bx54gN/93d/ls5/97D8RYP/u7/7urswRRREPPfRQ20/5Q4r74F/jHzpRFPHJT36SXq93T+dtaWlpaWlpaWlpafkg7734bTYeOMXK8jJ1WbN85CF2Ny/hbcoDDz2IcTV7eyMWFnrESRAUqrxCRxHTnT3iWBIP1pgMZ5jacPjYUbprq1x6822q0tLLEpyuWFtdRMQpVy/foJjMWFnOGCwvMjhykrdef4f333iPhx99iMMnjvPmue9gbc1TT51h6+Ztrl3fZbmX8PrNCddygxSSyjvOF44zmUFLiRhO2b64yfqZFaJ4yM6rLzH62HGWTp3i+mub1KUhjhOmVQ0eyrzCO78fgeqZ90424uTcWChE8AF6se+I3E8znauITZukbwoWRSPqCe/2ozp94y6UBMGoaRe8w0PIvogUeifnDrjwpFhAXwfnpJeSuJfhrKPKS7xxzbEGYVHgg0PUhT5D5YPzUwjViIISlUiEkNwalVwoPDMPSorGaRncfL7plNSNG7RJOUUKgSGIq6WAfrNZ++KqZz+SdC70ikbcnDtEQ2zpfOVNzO2+5+/Aaek92EYLtl5QOU8pwMxfiuD0xiq+Lvix/+0/oP+/1/j7//IPSKWQTiJUTXd9geXlLqtnPkG0+uB+AacAhPYsrB0limPirIND8uBjT3H8Rz9H1OmRdTJGkylf//p3mhxeT1VDXuYk0lPWkrIWKK3wVYUWYHyI2t1fjfMU3jASKaITobXGWIuWAuFcIybPRe1m7b4RhhEI4cGFHsb9fQ0nYl/sFo271lUWV9dgmmu4UXyFlggFKlIgguB+fVizXTr6sUcmkEQKayzGSvK66cJEMJ0WRCJcR5GC0niclxROUEwtg0HGzu6UreGY5SQi6yh0Ggd3p3d4DYmXKCGoakdReZyt6SaCXr/TrB9meUnaTcgLQxRrhmND6SWFsWg8iRIspBpT12RJQlUU4CSFcyRRTFmVSK0pLYzLmshZpDckvS7DSUEn0ZDGeKmwtSOONaQRtXNoL9CRYDiu/qd/lra0tLS0tLR8tLnnuQsfdkfl6dOnOXPmzAfuc85x7tw5/vAP/5DLly/ftbk2Njb4nd/5HT7/+c9/V9fc3RIqe70eTz75ZOuO+yGlKIp7Ot+JEyd49NFH70vkbEtLS0tLS0tLS0vLASc//iOMxkOEjlg5coTpeJuF5WXWTxyn9IKyciws9ImyDmVliLIUqSKwht4gJV3eoC4NZjYjjWJMVXD+W99hePM2djZBOMuRjz1MtnaI61euMdvbZdCVrBw5TPfYGc794zm2rm3x3E//BJ1+l9e+8zJLS13OPnKK2XhKPs1ZXu6xUxhyD4tao4RHScGm89yoHbUDay3V7ozZ0GK9wI332HrtXTqHD9NdTBEO6sLgLVgH3s0FoeB+FHPhSorgNmzEMed9Ezd54AD0TUhp+PPX4YXYd6vt/03sg/To97sVG0ehuCPgdO4kPJAog1D6AXEzTNwV0BEC5wXxoXWO/ZtPEi110N0EEWuQCqQENf+nsISYWGMdxnoqY7Au9GwaIamTmMuFY9t5rHTUTeSoBHQjWBqCSBk14u1cXPViHnHqiaQgEqHHMVICJcMnzqVwKAFSeJQSSBnGVs0csvEUzj1/+6m7QuAaN6WVYc7aQeEchfDUzTFoD10hGMgJKwsGnOep536SRIXuRONKlpd7WFcTaU2U9A6iaO+4sXTsLIOVwwwnM6b5lBub1/jmf/7fufXaN1hc2+Chx55kcXHA8eUuR5b7CDypFnzikXUWuym5qRnNclItSSK1vxbVnFUhQEvBpKqRaULcjUm6CZ1BRmehQ5RpdCSRUhBFUXBOyhBH3GTd4r3DGoe3DmcJrknnwgxNHyne451tXLW26btsrr+mD9U5hxEeG0VcmtXYKMID/VThvUcnmsJ4hDVkWcpknIdzlmhKIK8cSgpirUKErHHs7Ywp84qNXkqaaJJeBzePorUSXxmqoqC2nsoZhnmJVwlpp8u0coxnJaNZiVcRHsFqPyaNPEJaBOF7PVOeWEmEkmRpEuKN45TSWOJIszvJkUKRFyW70xrtLLE3JFnMaDRFW4Ot6/3O1zSReGdIsg5Sp3gU+czQidr3tFpaWlpaWlq+O/fcUamU+lCjXz/96U9/QAj13nPr1i1+4zd+g5dffvmu9VJqrfmDP/gDvvCFL5AkyT95fHt7m1dfffWuzNXv93nqqafuylgt9x5r7T2d7/HHH+fBBx+8p3O2tLS0tLS0tLS0tPxTrrx9ntWj6yQxbF+/ysr6IeLBIqPpDC1h/chhpFSM9obESrO7uUkUJSRpxnQ6Jh/uIqlYWllgNi0Y37pFP1Us9pehM+D4k09BnXPtjVfReFaXu6w98BDb44LX//PfcOLoKg8+dYpL779PVeScPHmIKEm5cuk60jsWV1d499WLWCQb3ZTLezN6WjGqHTdLy7uF4rB2xAnkkym33r5KpyvRGnbeeJu1Rz/D0gPrTM5dxRlPpDXWVljmYptonH6eKIrweIy1OBvclPNyme/l3QAAIABJREFUSusbx6QAhcTjsXe0K9KIlQgRXHF3dDDOc2Jd02EJohHkGsmzEeeCQXMulIh9fVMAPSVQAgoL6z/+b9n40Ye4/s6bxA50XFHPKkxZB5eod0g8Skm8C1G0FjDGIqVHKkE5Knh/OuX8rKbw4EQQG2MJ3gkWE8moFsy8xeFRIiiGDo8VwV0q8XSFbLosHftS7n4abnPjwPiHDIml4Zlz5+h8L8SBK9M1AqX1YFwQJ8smIld4SIFEhM7Mf/PsWR46VrJ+6iy6c4Ks22VaTnj60SOsb6yQV6H3cffauyz31z+wtwBxf4AebFBXhvFkxutvv8Pk3BscPfciR0+c5NVXXmdvZ4dDgw6V8dzam9LJIkajkiSNSKLQUbrU77CbV6jSYEVw2epmDQ6PjyKibp+0A04LhK3oDbo4Y3BTQ5mXOOPQkUb4EGfqrN8XVr2f96MGxdhJgVLyQOS24K3D2xA3K2UjAMvmugzKJd4KdivLTiPCi+b4lJQYPL1uSl3W4AULiz2srdBpjFIRtiqxtaU0hlTCpHaUBiSWQb8DSYpxjmlRU+cFKYIs0UDErKhIIkWsIY0lSnoS5ZlYSVELUuVZ7GbgDFVuEVJhnUM4SKIIZyviOAHv8Foxzmt0pMkrS6IlcSSZ2YiucHRjSJMOZWnopglWhPfI5rG6VVlivWO0N8MUFXVlWOhqCnv3KphaWlpaWlpaPlrcc6FSa/2hOb2EEHz2s5/9QD/lbDbj13/91/nGN75x1+bJsozf+q3f4pd+6Ze+pzv0xRdfZDqd3pX51tfXOXv27F0Zq+XeU1X3Lt4kSRKefPJJNjY27tmcLS0tLS0tLS0tLS3fnRMPP0BdT3HWceKxxxiNhszKmoiStY3jTMYzRtu3AUEhJWlvgThOGN7apCpLet0E3Vlj+8Y16smETq/PyuENdKdD78QDXHvnLa698y6ZKxj0Mg498ihbt0dsXrjI40+cIeukXHjrLbJOyqmzpymKnM3L11nqpUzLir3bE7qRRhrDeFahhMQ4R248Ugjezy1nE88gjhHOURcl0foyCsv49i43XnmP5aNHkK9ewdhgNtxX/7xoIl+DsFMbE5xnjbomxIHrUQJIsPMuxSauE+8QPrgD3Z3Rps00c8ckTfej+B+EO5h/7UMEZhMZKmlEuSamNJYiOCGN5ZX/6y+59N+XsePbDBY7JL0OMlbIXGNKg69MI1g5kB5rCeKrD/2Vxgn2asvFqWHHNmvCB0HTCTSS1bVVZldvIX1YeyfVTAsTOjx9iIRdEoIE9mNshQ9iowxb2+iz+zm2jYwpkcrh7MHi/f5jYXOc8BgPxoceyhqomz2LfRAoIxEiaFGStZ4k63VJV08z2REs9XsI53jhZ36Kw2d/hJsXL3Hj6lVuX3qbhVNPo7LOvPQSCAlX48mY2sGs8OTjMbc2t7ly+Qbmm6+xu72DspairPBeUFmPVpJpXtPvx2gpUdKRVzVShPMkgERoam+Di9aB9I66qiEVJAsZ0mhkIlFpCtIhlCTpxEgpyfcmmMrgjNm/YOYRqfN4YJzHzT9z7O6MLvaIpoNUKBlclVI2jwlq77iwk+OyLn5m2RsXLCSa5aUIoTVWQG8hwxsP1iGjDHRMtTNiUhgKFwTRcRVE9sVYI9HUlaHfFVRWEmuJVZK9acFiotFK0Us1WSyIMMQY4jRld1IjhKQfCxZWBnilqH3EZGbIOglyVpMJSxJBJ4uonaWwsHVryvKgR16WwWGqBFMjibwjFZY4DutQSlF7T5wkCOHRWjKZFERKkI+n+LrC1g4tHHvTkrIsf9AfqS0tLS0tLS0fUT5SjsqVlRUee+yx/a+rquIrX/kKf/mXf3nX5siyjF/+5V/mV3/1V//ZCNtz587dFYFKCMFzzz33ocbltny43Mvo17W1NZ577rkPiPUtLS0tLS0tLS0tLfeHqpghhGT15EmuXHif2XDE4Y014v4KW1cvsbczQeqE/sKAJEuorWO8dRuNpdNJqZ1nunkNMxkSZwOSQZ+o3yPu9Xjzb/+Gq+dvgnMsPHSMlbMPcfnSFXZu7fHwjzxGJDxX3n6LI8cPs7i0wI2rm1SzCStryxTWoaVkYQFGwymphCyOuJjn1A66GnIL27Xj3VKykVgWdejYG90uWDmyQDncYvj6OyxtfILloytsX97D2tBL6ZwFEZyRAnDujmSjuY7p/R1CZSP+2CAgeh96IPe7FudWQOayZnAZStF0DfqmQxKQPrjiVNNI6KC53XQa+rk/MTweoljBeo+RAsa32ZluI5XE1pbuoEuSRsSDiNhYzKzGFsFhaazFILHOBScagsLDzcJxvfLMZRmBxzmoAIkjH41CRKvzdLTE+dARKQAlPR3RxMM2Iu3cOen8fBv8fozrwc7OhWEQzRbN42QdhLhXPIYgUFY+9FFCiHmNhUDP522E3yyKEErhxYDx5fO8852XeOLxU+zsjBBRROfwY5w++hz11/+SrasXWXnvHJ2jD6M7A6SQmHzGjXdf4t3XzrE7nlFUnsm0IksThpOCndEIYz2RkMRIaicRUUovdvz0jz7C1mjGcFwyKcaNaCgR+KbX04dOUTwaQSeJGA938FmPdLELJseUBi2gzHOSTkTUiyknJTKOkNajdBB153WT3gVBm0aoFfvRwjSbH8TJ0L8a7hOJDE5gFRyThYg4PzHcmuVYF7ofbw9n4DxHOit0dIiDVYlGCIm3jlRLGHSxMwvUjIqKQTdCe0+sPFNj0ZUj35sAnrVOzJ5WSCXxxrDU18SRIvIOLSLihQ7XtnJq4xhEiizR2KKgFprdWUWdV4gkIYljBr4E76gNqCRme3eClJK94YTlnkZ3EsYiwxUVXWVAafamhizVpGmMihJmoymLPYWzmjqvmeUTlJYIBFEiGI4MdVWTZvEP9PO0paWlpaWl5aPLfXFUflii25NPPkm/39/vrfjGN77BH/3RH1HX9V0ZXynFZz/7Wb74xS+ysLDwzz73zTffvGtC5dNPP/0Dj9Ny/7iX0a9HjhzhmWeeuWfztbS0/K/FpZHj1G9+9X4fxnfl4n/8uft9CC0tLS0tLfecrNfFCs17b7yB9J7TDz9MORqyfekSaa+L1ilxHCORlLOK4eYNltaX6WYL3LixRZrEUFV0Ol36ayskS0tYKbny2svU25usLqWcfu454kGPi6+/inbw+FNPMN7eZDS8zakHThAnKVvXrtHNYvorR7FCk9YFWMuwLHHO4bXk+iwnUxLtPUPjMA6UErxXWB5OJT0tkcaQDycMtUAlCjGbsvXOVfobS+xc2cW60Hsn/EGvZBDSQlTnHfa+xnFJ46AM/82jS4OpUob79l99Rx8loITAWoLrkjtTXX0jZYbjEHe8ct+wORdQESgfHIQORdyJ8cZQ1gbtYDrOqUtL1ovpLS2weuokdrxHMRxSjGcwKSlNTbNqrBfsVp6rlWfPB5lW4JFz16MHg8cSOgsXE4VQMCkMniAcJiIImtYH0UwdmCbv6ERsYke93zeWujv21TWRt85DJTxWBgdlBdTeUzfPjeYOSikQwh84LxsX6qAbsTMc4rxD/9f/xKyc8dQnf4LXv/MGk9EEnEPGHTaOn+bGpYu8de7vWbn+PugU5yXFZMTl829y89plytIwnBaUVUUqHMK5xiEJOpLEnZQ6d8QInnniMJ/591/g/ZffZWv7b9gcTphVNZUDhcIIR43DNqK3c7B66BC8t8l0lKOjCJzFzipcXTEYdIjShDo3VNMcMwuuWGeCAi7nivV8/fvRwsGRigvCpbcOIcJxK6UQsSBe7FJPSryzeKm4sVfxfu6oZEUkJd5JXCqZVYbbm7uM9iIWlnr0F7po6dDS46VCRILBUo8bV7ZYjAXdVFJWcGs8oxNruolglpcsLybgazqRJBskpCpc8/1Y4i1EkaC2AmEcC9KghOLmqKaTGkoXvm+cEqSmphtJlFTYCqTWXNka8/+z92a/klyHmefvLLFm5s3l7rf24r6IbFEWtVCi1aZa7bbHGG+CDXh5kOEBZl4MeGB7HuwB7L9gHsdvA9gzwMzDAO522+iGZdmWLVmSRYmLSBaLS+116665x3rOmYeIzCpaGpticZHU8SOSlTcz4pyIk1GJyvvl931GaaTvM2hrOqFkZDV2mtOTJcpTJLklCjS2tMzTApEaokCRpCWWGc6BpyTWWqTyGI9zlJT4nZDENF+obvjBYPG5ufmM2tDQ0PCDw/suVHqeh++/N9+i+vCHP0yr1QLg6OiIP/mTP+Hy5cvv2vjnz5/n937v9zh37txSDP1epGnKrVu3sNbe9ZxSykao/CHn/Yo3UUrx8Y9/nLW1tfdlvoaGhoaGhoaGhoaGf5nCOnavXaIEzp6/n+nwGJvleK021jrCQOEETCdj8smQjVNnCFdirrz+BlJIKFKCOKS7voFe6bF37Srzo2PsbMTW+fN0z97H3sGQN//pOe55/FH6KxHXnnuBQMHZhx5kNp5yuH/I5vl7QGum84xQSorCJ53M6fcjJiOP0gq2Yo+jueGay0FWzjpj4cA6XpkbVnVJ36+6GGejGXHoIaRl/MYVVj7+IFHPZ7KfImTdEWnd0jm5UAkdIOoeyduPV6LGwjQphEBLQWkX8mQdFYvEOsPCC2kXnZZCIJ1DOYESDu1q0VCARCKcZRHnuZQ6RR2Jeoers0TQ31ljfjzi8GBM6SzKOUprsM4izvw4//Z//l+49Td/xpUv/wWtbgtuHZOUU3COsijJjOUgM+yXlnzpAK3uCCeo6gwdx+MpgRJs9WIuH86w1jEFxrXzUtUCog9o4VBUrk+5cF2K2/m21RqL2olaiZOGSpQsZeWgtLZyU1buUgidIBCgpaj7GV0ldLqlBopDsLa+TrvdJckNFy9d4dHHH6OzeZ71sxm7ly9w/9E1/GiMoCBsRRwfH5CmCcoLyPKcw71dDvaP2T8YcXV3H+XHGKvQlCgp8JRACY/zq22MkCRJwumBx0/+hx/HxaeZJxcpZglKSPKypHBVhC6ijmCt3ZS+k6zGLWxeYI1ksjdGlA5hDL4HpjDk8xwpJAKFtUUVE4xDyvoyrF2/i1jdStF2SKUQQmBLU7ksEZX7Vzi0r8EKhHSU1jEzlpeP50xt9cpLUQlzzhi0VEzmJTKzTGcZveGE1dUWqh1hihysQwc+p8+tM5vnzIZzjLHsrLWIPcgKgw+UeY4fBbRaIfk8QXiVgFqWltiHUmvSvGQl0NjSkFhLUhgMkijwkBIirWlLU0UOJwUy0BxNU3I/otsK2FrxSadzxqlgNp4S+wbp+5jc0op9srIg9ALKNKUV+aRZ5QrGGTxZ9ba2Yo+9cYExllbLB9/n9WvH78r7akNDQ0NDQ8OPHu+7UBkEAVEUvevjep7HY489RhzHAFy4cIGvf/3r75qbrd1u8wd/8Ac8+eST/2qs5nQ6JUmSd2XeTqfD/fff/66M1fDB8H45Kn3f52d+5mf+RRG9oaGhoaGhoaGhoeH949atPZSvCb2A0a1raKHRWpFnKZ3uCsbCbDTB17B67h6OhxN2r11BlAYvCrAWWuubTNKS0ZXvIJMh2g9ZffQJ/E6bV1/4DmWe88hHHscKyTf+yxfZ6K2w9vAD3Lp6hXQ6Z+3kKSajCcYUhN1VZqMxwxtXWNs5QZqFaO+Y9VhzOC1IraEtJXMcaWmXgtdLmeFcKqquSmew1pGXljjysEnO4Ru7dLf7JMNdypS3CJSVHiSWZsiFw1JKicPWghPL54Woo1mlAGsrd6YQOGuRQlZOQ6qCS4lFSfCcoHSuilOl7qp04NztLw8LUY3naregqy2Iot6nNI5pWpLlltKJah5jcUKhjSG5dJVv/B9/xfGLX6V3/0dYWy2ZDv+e3E7IjCM1lknhODCOsa1EQYmtj6eeC1Cuiro9vdplb5pQlhYEBA66CDIcpYAMR+rcorJz6S6VVCco70jTFThs7YdcCJKiXgeJQDtHKEAjUGJxzrXFs1KHK0F18auOemxlLft7U8LYo9+PafcGJJMJ61unef6rX+abX/pLTp0/T2lgb3/E0WiKlENCX6OEZHQ8ZG9vj4PhGCM1Rnm4dI7yJWluyErLimfZ6vkYERCVCR87v87uhde48p++yNHhCJvMMKXB1n2niyhg4UA7QSQEm70uvh2T5hnZTJFbi8LhKYdCMzueoX2F1AqTldjSoWTlkpTyDtG3Xm95Z1+ltfX6gFSyFrYd1gpQHvlkjlAWi2R/VvJaUuJ5HsJBoByr7ZBeK8BToup7NJYo8pFOMD6aIbMSHcV4ShD6EiM9/LZiOi8RLkUqyXCW43uKyFcI6VBKkacp1lp8qSgLS5oZlPKZpIbY06hWwHCUk6YFvqdphR5lURD5khVliGIfQ4kOPZJZRq/bZnX1JOFsD1+VZFJhcsNqW5CViiTJCTxFVhQgFKYs6Pc7TJOMPCsIwwAs5NMpYaiYznPKNKc3aFEi2T0c0x907u4NtaGhoaGhoeFHlvddqAzD8D0RKk+ePMnp06eXIuJwOOTw8PBdGdvzPH7zN3+TX/3VX31bIpCU8l3rCPzIRz7S9FP+kDObzd6Xeba2tnjqqafel7kaGhoaGhoaGhoaGv51Nk6cxJYZB9duEvd6mDxnOpkT93rMZ3OyNGN1bRXPF7z22pskFrqxT1vllcDl+ezeuIE0OSudENXZxOtvkhnLG996lk6rRWt9wM1XLzDcP+DEqRNsnd5m9/JlfK1pr29RlDl+ELGyts7u1Uso6XHmsQ8zPDjkcG+f3kqE72tanmMzCtidp8xN5bDLARwMC3glg/XUshFoisIgENjIIwg0ya0Dos4JgraPNZYss8g6j3XpYnQWISQIh7W3BaBFsKtwtXCGoDasVRGugireVYB1bpELi+R2tyAOlBQoVwt4C/tkbdqUiMoxWH+cl65yDN72bDqcddy6foASYIVASpCycmbOS4MbvsCL/+fzWCGZ0kKdCbj+5g2SeU5ZWuZlyXEJBwZSKvFQudvht4LqFzCREpxf7TDNC46nad2TKQhweEIQ125TCxhEFRXrKmek4w7HX83iNxSyDpr1HMhalKwESYcSlcu10tgWnZfVHIuSz+rlWsxdNYH6ShCv9EiTY8L2FqUIeeXF51jd2Obm0Zz9r36bB4+nFHlJUVqmkylxpMlKyWw6ZTiaMZslzNMcb7DJ/R95htf/7i/w5ZQkKwiE4UOn13jqqY/x8rde4ETPZ13D7osvkY1m5JMcH7BKVKKttBjn8IwksNDxNYGWeAKy4QwtJLYsEc4iZeXCxTpcCaUpkbKshEi1UMPFbSflIqrYWKRerG2l6jprUbJa4YW+q3xFPs/QXnW9zHPLxeOMqVOESqC1QApBFPmoQNFuh7gkR2ErgV1rrFNMjxOiAnIBtgworWMyL2j5miQTZKmhNBaNZZ45dKDIC4cUjsFKyGyaIamE8mxmkE6RmYzSOdIyp9fvIrWHK3K0r2hFgjj2ORolGFetlxKW0JWYwyuMswKHxBhD5InqGixN9UUBXyCEAlMStXyOxjNcKQgDD6Uk2WxGHPvkhSGdZ2xvtEid5HiU4LXbtILwbt9SGxoaGhoaGn5E+UAclWF4+x8nSimklHfdI3nu3Dl2dnaWP0+nU8bj8V2NueCZZ57hd3/3d9/29u12m3a7/a7M/cQTTzQOuR9yJpPJ+zLPT/3UT73l71ZDQ0NDQ0NDQ0NDwwfL6OCQK5eucv7MCbLxkPFwTnt9g6woiQLNYNClLB033ryCb0oiLYmwhHGMP9jkwsXX6cUB3ZWIsNVBdwYcD4dk0wknTm4RxivcuHIJ7VKe+OSTZNZy8/o14s4K1lry0hD5AQWa4eXLxJ02YbvH9ddfJ4wDtk6f4fqbV+h3AjbSFge3puTWYRAUtegnXSUQvpKWnPKg40liCaUxpHlJp60RWcHRlUM6a23mwxQhwS2DZaqYVlmLPLbuXgSqLsWF1LaMh622F1A7KGtXpKg6JyvByGFqYa7qVqzjX5VA2npbquhXWwuRlewkkM7ilp+xHcZV0anWOYrCYJXC8zw8XxFHAZ4H+TRjPk8xRoAU3Hruv7L7TYexOaUVFNYyd4Jh6Zjayvkn3R0ioqtiVlc8OL/eYW5LbhwlCCXZ3ljj1v4+OFmJt/U6OQTOgRHV8d3JQvoUd6yfuKNXsTb9sQjKlVRCpX3L/pWg6WrVs9Yr8YQkdw6LI26vMB2NyUzC1iP3M5rN+epXv4lFcXDrGN/TvPjiqyAkvX6PE9snmE9uYYoSBXRWOlzZHSKUx7/59E8S9h7iIPgrAgODOODcaodf+R/+JzYf+ATu5v+KFVPK8THFPKPMDYkxXMksN9KSpO5X1MLhhENKi4dDWcu9p9ZI9g5YcQZrBXrx+rqFCC1wtXtUSJYuUknt3KUWwJ1DyWrbeWbwpCTwVC3ggnS2uorUbQ+rkIo8h91JwYVpAconUBJjDUEckOYlsbSE3RgX+2iXk+aW8SQlinwK6+hISZpliIllllmwllk5JfYlkScJWiG5MUwzS9wKEXnKoBuRJiW+FMyMJbGS9V4bkSUcjTLakUe7HdDptnBWUBZzen2NVT5ZliM9jbYOEWiSucH3NdcPZ6SFQGBYCUAIjUOgNRgjsc7DN5ZOJyArDdI6hKzic6fDMZFXCcKTWUa7HVIYweFwivFCunGLtiq/7/fQhoaGhoaGhv82eN+brKMoWsazQiVcdjp3H/9wp1DpnCNNU9I0vetxz58/z2//9m+zvr7+tgVD3/e577778Dzvrud//PHHG6Hyh5x3SzD/1/iFX/iF92WehoaGhoaGhoaGhoa3x+jwiNM768z39yiynLjTJi9StKeJW22m4wkH167iC+iGsKINK70OBBEXX3wJM09wRUHcX0V2Vjm8tUc+HXPq/Fni7ioH1y7Tbcecvu9+DvcPuPXGm+zc+xCq28WFMZ3VdVA+RTpnbWcLGcTs37xKd22D/sYOx/u3UErSG7TITImWUODIrUNa0FSikJEwNo7nUsOtzFR9iNaSzTKKXBCEHiJNyCYZXqCXTsaFACRqsdC6hYcRKufkQqQUy0edq/srFz2WTiCRVb9gLUriRBXdWkeAysUwjqqnshbrZC1YLhB3/F+KSsSzQO6q8yyNoygthbGUFqJBj7NPPMYjTz9B3OtQAqWFxBjGRcGkdKTWkTqYlo6Jc2S2UgRvi5QCLaCnBU/ev03Qjrh8mKCURQvHeHyMql2j1VJUvZkCh1LgS4EnRP0neIC/vInb9yX4ohLpdC1OVgKluB2ZSu1QrW+udrxSdy/iqn5MWT+fZjMe+9B9nDp/khOP/jhStTm4NeSNi5eYTOeUzlJYix9HhK2Y2XRUReeaKh64zHPCOCTutHnkI59kfjhmp+dxYmuNfuD4d08/yYP//teYXbuOmhyiBcxmObOsZD8zvDQ1vDBMyd1tUVsKBThCIegrQQfDiUGXYjRG13Gu1bVQic/GWYyzCx0SZyv3rHAOqQU6UkhV3ZYOYCdoBx6Rr3DGVq5L4ar+VQHKE0itkJ7EOJiXljfHORMkXt3t6qRCO8cg8giVYjaeIKQDPwCh0VIxTUsC3yfPS8LAr2JaBdjCEvqaTqyJY4+irKKW+7FG2ZzVbgjGUBYleVlikEjlEQrHZJYR+4IgUPhSo8oMr8zorQR4a1tM5gWFq66lIPIYzzIKFHvTHMI2vpSsxhIpFXlSooUj8hWBrymLgtw45vMCXCUax5FPWZb4WiKVJJnldCKF9BTjpGCaOQatmBUPAq9JC2toaGhoaGj43rzvQmWr1XqLMBlFESsrK3c95gMPPLCMlLXWMpvNlt8MfKeEYciv//qv86lPfQql1Pe179NPP33X7jYhBA899NBdjdHwwfN+CJXnzp3jkUceec/naWhoaGhoaGhoaGh4+0RKYqZTVlba6FYLPEWnFdMKQ8bHY0aHI4IgJJCGuNOltXOK0SRh/+p1Bq2AB+49xbmHH0RGbS698jLpdMrqzjZHe4dcfuUVuutb9Dd2uPnGa+STIf2T57h2+SqT4wlhHDE+PmI+GrFx+jTGQjYd0x2sYY3h8ssXaPd6rJ8+QWu1S9gK+NDDO2x2IrSs3Gu2duVJqnjLSxlcSAyTooptNdaRzQv8OMIPJMUkwfc9PC3xlEQLiSdVLTLKpUtSCHFHP6WrfjGxjGqtnY/U90VdqlgpagvJc+kSFHUhpaNyy0khb++37B6s3IfiTqddPV7pBPP6VwfWWgrjSDPLfF6wtzsmp8fWg48QdTooT7HSj/G0pnCWEkeOJbOO1AmmFoyt1qvqoqxEyhVP8NjZdTKt+c6Vw0qEXHRKliVSgvYESlXnIGR1ygvBsoqhrf5Ud9xfbEPd31idK0vLpISluOsW8a6LmwNha+enW3gxayGz5ur1a2yfOccz/+EXmd06xhMhUlRzKSVJ0hLjBGVRMBqOMNbijKMoSvI8oywKMCU7J05y6uwDyOGbfPTRszz5ofPct7NC5GmyoynX/uHPyWYzRpOM8bzkKIcXp4YXxjmFdayEHpFWtP3KdRoDO1qxGXk8fGYVkyfoLEFKVV1n4nYnKvW1ZU3tvBUSVT8vfYGUqhK+Xe2urJ291tTXp6oigOViTOUwxuKcASEorGQ/sbwyy8mVJnUOqxU4CJSi0wpY3+7T3+ghtSbPDba0FM7iK0GRZMiyoEirwOBZktOJJHEgCANNaR1lWdCNPTxZ0l/xmReGJIPSQSvShMrSlpbR0YRQC8I4YjIvETjKImc+nzNMHXvX9zGFoUgznBCkSUm31QIpKLwWs1GKliUFDmtyPF9g8xItFVoIWrFHpx0StGKkp9CtFpNZgSsKfE9g8oJuJ8SPNAbJdF6w1o9ohwLyhPx9qsVpaGhoaGho+OHjff86k+/7DAYDtNaUZVUyfredlf1+n0cffXT5oaMsy7uO2xRC8PTTT/OFL3zhHQn60haiAAAgAElEQVSOn/vc59je3r6r49jZ2aHX673j/Rs+eJxzjEaj93yez3zmM8Rx3LhvGxoaGhoaGhoaGn6QMBlrO9sUpUHgoQEvjrhx9RraFHRaMXY+pr2zg+z02N/dJZ/PGLRDvE4X1V5j72jM/HCPzc0NvE6Hg2vXcGnKxtYWRZpy5eqbdNc2sBZuXr7I5s4WVodcv3ydE2dOcvr+BxjevM7kYJ+VrW2syUnG+2yc2kG0WpiygMBnd14yHk+YpAW67qcUCFRlakQ4R4HjO4njpC9p+QppDXlWkGUeK5sdhjfHZEmBFBKtIC3LSlBcRoxWghlOLB2Hru4JFLLqDXTUImIt0i1iTAGklFhrayHKISy147LqdyxN3WPJUtesREpR91KKynF3p68TYFhaMk8RSFkJkBZsaTHHI771V1/i0rd65OMRnfVVHn3qYZ7/8nMM5ynWgbWO3AkSHFktgEoq96cnBP1A8fB2h2tHY65fqvoEKwGxFghrQU0AUtZ6rQOhFnWcgkWLpKg7PIVbrF29lkK8JcK1rvFkIeAuehUXLFspayG3TptFAMXSfSlIUsOlqzd57N/9Ei//45do+xDGIVGSEscRUkuEs3ieqtxyZYGmpCwLpPKwWUa3HXLvEx/FJo5TbcFH/7tfJp0lTC5fJbAJt77yf3H85nNMZzlHk5zDzPLy2PDyKCW3ll7oobUkLwWFMfjOsakkPa1oR4pz957g5RdvckaD1mp5HpKFM3Vx7dwRlFuLkia3WIqlMO5svd4ClNY4Z5bdqVJKpBRYIevI2Opam5Xw+rRgIjW5pTpWY4iVYJIbjkZz+l0fPwwJnGJ/OiI3hijwmKcFqy2ftLRYKyhNQSdUCGfQOsKUBZEn6a7GlGWJ9kMmk4L5PCXwPPxAM51nDLox+wcTBB6psUiboyWkhaU0Dqt9JkcJg0GELQq0khSZww8l07KkwMOOJ3RUgUaQzVNWViJ621uMbx2SFwVCC6SncVojlSRa6TI8nuN5GmENxhikpurGzByzMmFt0CH2BdlsjpIwTpro14aGhoaGhobvzfvuqBRCsL6+ThAEwLsT/drv99/iJls4Ku+GtbU1fuu3fotTp069I/Gn3W7zhS984a6O4dy5c4Rh2IhPP8QURUGSJO/pHEIInnrqqaafsqGhoaGhoaGhoeEHjIc//nGc9sgLQxgotOdx47XX8bWmu9JG5HPW77kX2e5wa3ePcjal14nobG9jwpi9G9dI9m5y8twZgl6HG6++TOwpzj7yKMaUJLMJ/e2TGKHxfJ9z50+RJznTgwPOPvAwujXg+S//AzdfeYnVU6dRXsTseEyru0nU64O17O8d8Y3n3uRoOOdwb0xpqo5KKRfxqFUcqMDhJBwYx3eSksPcVslDEuaTFBtExL0A4SzOWaQUKCFr1+Tiv9rJJxZyErWqVgtlwqHEYl6HEgIFeFKgZe2KRN3uXayVKC3lMrJU10KgAtTi+GvRatHfuHh+IRhOrePA2NqRWR2btQ5rSvLZnOHuLnlRkCQFb756yPFxCkLiAOOoHJXWYepcVUEV2brd0vzCZx/F73e4OcnQwqGEq8RKBwqBXGSxusX6iFqcFEuhbRFjKxd9isvHKxHN1W7R5e8Olm7COgK2dqpKAbruZpSO265Vd1vIXJoQnWOSGW5cvklycJPzDz3OzqOfohO1cA60p2i3I9YHK2xvbGCKHGkzOp2IXrfDRq/D6a1N1rs9Hn34MdzRAfee6rP28FMkhyVqdowdjrj4xb9g//ohN48TXh3lPHuU8e39CUlR0gs1my0PrKUsS5QxbEjBQAmkMJw80aFUMeZoRCBBOIu1Fpavd+X+rNamui6stVVPqmMp8tZ5r9V1V4u6zhlw1WNSaYxz2KWrUoCUWKXZnxdcmGUUdewrxhIpgXCWoJoQay2udEwnc8okox1ojKXq27QlQgvmecEg9GjL6nrfH844npUIIZCypHCCm3tzpIPQ9xEIDg4mmFJwPEzJjeQ4yclLSxwq4tjDD3zmRnN4nFBaQ5bl1RcDlMDzFKOZJSsEZZozCAWtyANriD2NzAuObuyRJ2nlntQKtMbisEoynRb4UmKMwdlKtLVOMJnlTGYFrSAg9j1MZsmmGbfGGQdZ9m6+vTY0NDQ0NDT8CPGBBMTv7OwQRRGz2Yw4ju/KNSiE4OzZs8t+SgBjDPP5/K6O8Zd/+Zf57Gc/e1dj/Mqv/Ap//Md/zJtvvvmO9l8IlQ0/vEyn0/qD0ntHt9vl/Pnz33c8cUNDQ0NDQ0NDQ0PDe8uFF18jz6acOXeWcj7n5puVSLmiCmw6J1rdZJxaktkEr5jTW43RnTWmmWV0sEe322btzENMhofsX7rM2uY2m2dPc/XV18nmM1ZPbDMdjel22xRFwWiS0equsN6K2b1ykVvX9zh7/yla6w9y/dJlFJKNs6dpra6hW22S8ZAXvv0iq+0Wp3opzkwpEkMsJFNhMbWjsayFMOkgd/BKZtielwTSZxVLWRiGNyeceHCTIrnOfFxQlLaKMkXWLsoqPnYpJC3iSGWlVVZdlmCxy77EZeSrvS02ISzUkbTWOWQteGrp8JykFBZfQLGMkl047OoI24VgWguaDocTghu5oyUdfV8hjKN0FuugtAZRQF5aXDJidDymtA7jHMY6CgspMHf18QgIFJwfxPzEpx9kf5LyjQu3wNnKqYfEiUooq45B1F2brj5Vx+ITpHSLDslFf+fifF3tcgUQ1RraO6Nt35p8Wilv1bauFuncctNqXieqdYC6D9JV873w0kW+9Td/yeMf/zRlEDDoxty4KZhMUrrdFoN+lzCQbG8OGMQh1pZkpJw+ew/TTHFvoHnoxz7Jt/7zX3PqZA+pQiaX/gmKglu7+xwejtmb57w6THljWnCQFVgcg8hnI/ZRUpIUOdo4NqRgQys8IQg8CNt9Lly4Scfl1au7EGGlxAlwzlY2VVzttLV4Ui7jgoWrtl1YeK2siiydYHl9OiEQ0qEWIjEC7QkKa7H9NS68eZX9UlLgiLQj8hRl6egHkl6o8DzFZJ6RZZLZaEwv9hjPc5QEpRVWKoSxbHcqQdaXgnme0/YMcRzhrKW0HvNZSj/U+Lpyg2ZJwaAdoKRknFpGmUEozWbXxwmBkoIb45zD44ydfsBK5IMApRxBoJnlJcILEFlOL1DMk5R5Dr6whFphrSUShswTaCVwQuJKgxcFzCYJrjRoIVA4stKCtRRCMM0ka92QQDnS2Zz5eEYmJceZZefExrvxttrQ0NDQ0NDwI8gHIlSeO3eOdrvNwcEBcRzT7/ff8Vhaaz72sY+h9e1TsdaS3cU3tc6ePcvv/M7v4Pv+Ox4DYHNzk9/4jd/g93//99/xcSycpw0/nEyn07vuSv3XWF1dpd1uN87bhoaGhoaGhoaGhh8w5odDzn3oQY4PbrH/+iViLemtdemt9/F660zGQya7h8Ra0Fsb4PyQa9d2MfOUrbMnifur7F67ijIZZx98EB11eO7Lf48xJe3BgBtXdhms98iNI8stg6014k6P+XiMlJLHP/0JUmM43L2FlB5nP/JR/ChEKcGz//hPXH75VaZHQ2RpWe+HHExTCgflPCdwYB2kZtFpWAloEsHMwIvzklUl6HgBPoZilpLrAff8xCpvfOkFJqMcWzqQjrKqtEQilmJYpUOKZU/lwj4o7MJ7udhocWcRzcmyh1EKWcVz1mqkdJUuJZ1DI5fCYW2YW7oIl/mo9bgWSCy8nhrukZKNQGGNozCV+64wpmrGdAInLI5KcLU4cgSZdZRUbkxfO9qeRvs+f/vsFa7cPMZYi2LhtayOCQHO1V2JVAKqq52AktudkYtDdeJ2nOtt3G0xd1n0uch+rcW2OgfWiduiJFXKbi1QLh6oFsfdMb6xlis3Dvj217+GFIJ2d0BgE85vdrl+OGM6mTOaTAm0x0qgefhDj7N/sEenu8n2v/kMr33za5z78CeRQUx25ev4gzNc+eL/w83nv0YyK0hMzn4hee4449VRQlpfKIES9AKNrzQ3k4wsLdiUgk0pCWunqe+FHBaSvTevc6ol0FKipUJYg3AWVfeiqjpSWAiBpHb4WrCLdS8r56SwdUTxwvvrLEpJnJDYwuAFAqFl5aR04G1t8dLNkjfmBqM0oYJQSTwliMPqZ2PBWsF0UhL7c1YHHbJ5SqQVWluMc7iyYK2lq9hd4ZilOX7oI7SPAIxxjA/mCBwzYxgXFommLGAlcqTGMk4LlO8RShhNM4R1FIHEZSWn1mM2VjRlXuB5Cit9JvOSxArS2ZS1bkia5igl6MQKV1QSrVSCHFCeR5JawsChwpiytCjrSJMUGWrGmcFkBqEhjNr0Y4MGsiRnOC+ZZRYRa86c2USa9/ZL3A0NDQ0NDQ0/vHwgQuW9995Lv9/n0qVLBEFAHMfveCytNZ/61Kfe8phzjjzP39F4vu/zh3/4h29xaN7Nsf3sz/4sf/qnf8orr7zyfe0rhGgclT8CTCaT99xRGcfxXYvqDQ0NDQ0NDQ0NDQ3vPtv3nOG5bzxLkCd0fMX22R2CVosyGrC3N6KcHNOPBH4YczhKOTq6yepan417zpIWhtdffonNrVX6/VMcHx5y5R++SqvXR4ZtlKdY2xxgUFhnWT95AhWGjHd3MbMx/e1txuMxo8MDeuvbbD3wYGU605pXn/0qb7x0EVWWnDy5gfACXnnhNdbigCTJaWtJakqcqyJSrRBYV8WqLvojrxWWF5OSjic5HXskWcbeS1fYfPBpNh7eJ//WNey8EiGdMzghsBaQctlD6ViIjZUIWolqlTOwNlIiEdiFoCmonZcCJSpHo0TUzsqqO1ADhQDl6gjYyqZZOQZrB2Ol60ncsq2ymnNq4ZVZwaw0nIg9QqmQSpCmJZkVWCw4t3QcWicwQFF7QT0JkZII67iyPyK3DifFW2Jn6wmRou7TrJ2jonY9VuKhqNZZiqXDj3o9WLhNqe67umfye30/diF3OuewS5fg4snb4y4dm//MiumAJHfkRcFzX/tHVrfXUaag7SnuOTUgExJb5CTTMR/98CfZ+sTPk375z1g5eT/+4Dz9+BWyw13G146Z777C9LUpF75zkZvXrjMvLJeHU14fF+wlBdZC5GkMAi0cYaC5MU04nhf0BGxKiSckUjgCJTn/6L1888JN1iiItUJLgbMlctHp6SxKSqyt3JCL3lCl6hN0Dmfq18eBkA7ta8q8rJyrSiKkQxiDVCC1wqkqPjc3joMr+7x4bcq+c0S+xFcSJRy+quaZWehqRVYalBNE7ZA0zZjnJYGsrntjBXGdQVwYiAJFgUB5Cmct2jlmsxxhHXiSeVrih5qjWUpLao5nJbPE4jyPWDk0Dk86okjjJGxFIa1OwHyWgTFYKZlNZsyth8tyupHP8TilGylK4/BEiR8JpFLkxlWxtYApDaoVMZsmhL4HpqC72mYyz3AWlBRs7QzIJglpmpIaj8ksZWgEXivk7M4q6Syh9YH8BrKhoaGhoaHhh4H3vaMSYGNjgyeeeALP81hbW7sr12Cn0+HDH/7wWx6z1pKm6Tsa73Of+xzPPPPMuxKjKYTgzJkz/PzP/zye531f+66srLC6ulrFkDT80PJ+RL/2ej2iKHpP52hoaGhoaGhoaGho+P554dvPE2YzOh5snNgi6q+SITm4foXi4AaDtk/UXeXgaMxsMuHM+VNsnj1FkjtuvPY6J86cpd1d5bUXXuL6d17l5AMPoaMYFa8w2NomL0qUkKwM+pS55daFC5TzGbrTZTadIcqCex55lJ3778eUhvbaNse7u1x87gLZ8Yhuv09uBdl8ytbmCr2W5PSgRSAFWgh8LVBVciaayoVXdSJCBryeW16bFQxLgxCC7OiQi1/6Nv2HH2Pt3IAglChVu9pqgbPqjBSVoCQWnYuVXXDRl1j1BVb7vaV7kUrE447dEFVkLMKiBMtOS09U57B0F7rb3ZS67msUtftQLvohgdQ6XksM3xpm3MwMVkl8XxH6Al8tjrOKw82tILeC0rlKRHSOrLBMCsPcOFCSQEviwMPJStRcRNZCLUqy6Pe7/fNCL1yqj7WiKOu9xGLLhSWy3uythkux3HKxtvVgdaTpco+3OisXEbH15ofjGdO0JBNw6eI1JqM50hV0WhHtKGIl9ui2feLeOvhd8syRTyYcXXyR+fVnKXdf48KX/m+S2T6X3niFi5evceE45cvXRvz97pw3JykIRS/yWIkCfK0Axc1JxnCasoJlRwpCAZ5wxFqwc3KTQxswvL7HyVgRKInnqSoiuD6N+pJCSVn3jlqccxhjl8sqZNXFKiRILbFCYhFIWa2XNfU4WiBU1Y1qncN2urxwc86biSEMfEJPoSW0fa+KWFUKX2nKWsSLfE06SUgnCaKw+LLqMO1HirYvkMLhKYcSltVIoVwVp2ysRErwIp/xrCSKI/ZGGYHSWCxpBkZqOoFiJVS0A8lK26MoSqwxxO2Q41GCsY6jWcHhcUZhPZSFji8ZzRKKec4sLZBSoZRDh5p5YVBCEPoeQgp0EDCe5riixGRz4nZIbgBraUcBvbaHzWaURcqsNBxN5kylh27FnN5eB6GIAx9vpUkMa2hoaGhoaPjefGAq2Oc//3niOOaee+75rue+nwjLJ554gk6n85bH3mn069raGp///OfZ3Nz8vvf9/6PdbvOTP/mT3/M8/yX6/T4rKyvv2nE0fDBMJpP3PPp1MBjclSu5oaGhoaGhoaGhoeG9YSAdax2fjbNnUL01dg+m7N88wE2n1ec9P+bG9X2wjvs+9AD9E9vsXbvJ4dU3OHPfOex8yvN/+w94Lmft1Dbz+Zi4HREq2L1yFSk9wk6L492b7L/xMp1eB3+liw5C1jZWWT+5jUExm8xYPXMfV155nn/64pfI5yVn7z9PkUzZ3OjTX+vTihWn11sI54iUpKUl0oGWoAUYUUWbOiFBQFg7EJ9LHa9PS2au6kqcX73KtRducuLjH6a/1SbwJFoplBRoKVCiEikXN+ooz7pJsPr5TvHN1Tch6nTYyhe4FDlh6aJT0qFrsVJLh4fDQyDq/sulEGpdHQO7EPCqcRbilkMwNI6XZyXf3E+4llp0FBKGAU4IMgOZEeQOSuconcM4Qe4EqRMU1UHRCX2e/NBD9LpdSlNtZ4VAex73nTnByc21WpiseyPd7eDVWvesHax1fyUC5yoBcqH6CmlrRyZ37HvbObkQHMXyJsDVLsJ/NtcdWbvLZ7LScvHyEIViXuTkUtFb7XHu9AnW1wYo38OUMDm4weG3/47h1VcZvfFtXv/in3B46wbf/PJf8+yzX+EozfnO1T2+fWPIc3sTbiQFhXX0Ih9PgZaS3DjmRck0y4is4YFOyBklWJGVSBz6grgTs3r/Ob7yjy+y5Tla2lWCIxIlVXUt3OEIxdnlZ/IqSreOw3VgjcWZSqjUkU+ZF7fjdherrDTIqrPRCUis4/WbQ54fp8yFqLoZc0Mv0MShR2Zt9VpZQ+hptvsxLV+hZRWnGoaSyHNEvkBZUwml1tKOPAJPojyFcZaicBR5hh8F7E8LotBnkhS4soqDNcbh+ZrVWBN7kiLP6bR8pNJ4viRuBcwnKZEWFKWh3QoR7YgkK1jxBQWCQCkGXZ84VISRR9SOyWRA1I7RoVf/xZOk84yWAGUMSMnecE4ymuIJiSgzBI7JuODwKGcyKcmkRHdanNocVP2paUbgK/b2knfwLtrQ0NDQ0NDw3wIfWPDCpz/9aT72sY/x0Y9+lK985SvLx1utFoPBgKtXr76tcT7zmc9812PvVKj86Ec/ymc/+9m39F2+G3zkIx/h6aef5rXXXqMsy7e1TyNU/mjwfjgqNzc3v0usb2hoaGhoaGhoaGj44Gn5gnh9g4NJzsFrL9Lrdljth8SdNawXMh5OWFmJOHH/vRQlXPz280SBx5kHH+Lw5i2Orl/jzIPnkNqjxGet32U6PCQdj1ndWCXorHD90lU6rYD+iZM47SOlIoxCSjSFgLDXI+6u8spX/4rXvv0iyTRHt2Jm4zHn7r+HZDpGYVjdXCNLS1a7KXvzAlE6Yg3josSJSuzLFyIhkFpQwrFXGl6cQUdBtOLTcSV7z75IPHia+3/qKS78xy8z3JsjBJSmktAMFmGrzkhXi3CujnR1YhFQWomRRlSPY10tVFZipqw0oqX7UAtJ4Rxagmcq56KRDmMFeS1eqVrAsrKOj61HgzqKtT43AJwjt7Dv4GhWcDUp6CiBV7sOrROUWOYO8jqCtT5SpITVTsjZ7VW6/U1GF96oxMZFzKvSPPqxT/D8s9/E7h3U4uFi3tvuxmoVFse06NWsHpN1HC+1wPld3KE5Lu7aO6J7F2IlLOtBa2dldRZyGTPruLJ7wKd+7F663ZhJmmD0Jg9/5qfZvfY6z339a1x64xp5ktMfvMl8uMv+rZDZZMQsKXnj+iG39of4vuPaccKNUUqSW5QQdALFIA4YpQWHWUlaWkRp2FKOT5wYMJ2kTPICKQEJIzRPfOrj/NnfPItOppzpaXxdXQumLFGLq9NVbapVJ6pFiuq1ds4hlMLZcilaSgleHFAWBiWqtlBjHEopjCvACTQSpMA6yVHieG53gokCAiHJC0Psa8a5RZQ5bV/XFybYskA7jdEK4xS+AoUh8DXGWEpTogsP6Tk8abFSkqcWax2BMrRXOhwNZyil2B+lRFrSbXmV41MqfOkIPYWUgl6vjXGgjcNrt9gfzujGHnlhSQpHKRQI2FzrkU7GmNLgS0cUVi9+aWBWCrQG6QXoIiMrBdODMYEnMZ7DCzSTWY40FtUKSNMCTwhGecnBcYaUgqkSRO02p1Z7CFdgC0PkGw6P5wjZZL82NDQ0NDQ0fG8+sH8lRFHEH/3RH3Hvvffyta99bfl4v9/n/Pnzb0uoFELwzDPPfNfj76Sjst/v80u/9Etsb29/X/u9HaIo4td+7df48z//c27cuPG29lldXaXX673rx9Lw/jIajd5ToVIIwc7OTiNUNjQ0NDQ0NDQ0NPwA0tk5wd5kwt7VPfrtmPV+TGdjnVkhmI+OWV1fpbexye7NA46uXq2cjf0ew4N9TDphsLHO0aTE67TorQ04Gh7i0ozO2iYlgsPrNxgM+nhhiLEGjKM/6HJwMKTVHbB53/3sXnmDf/rr/5ejazdor65iXMLOxoD+Wh+cZefMSebTMePDYzylOZhUrqcVTzEuispFSRX7qqlciCkWWQtaiYOXcsMgcbSVQESaSGRc/8o3WTn1U5z/7BNc+MuvMz0qcFicM2AXsa0grMA5u3RKGmcRQt4hXlb6XNUtuRDtKkdc1UtZOd2kE3i1VFgK8AArIXegKm2TEsCJ29FSjkqccg7pFsGrlXjpuK3eFcCRcQyNQwmBB8haYC0cmIXzsRZXfS/gqU/8GD/zi/89f/Uf/5wky6vnLZRYhO+Q5YzZbIpZHIuoj+stmuNt4XQhJIp/dmz1rjgn3rLzW6XLeuVc1YW5kILrZXlLJ6W4vXWVmivgeJzw/CuX+fTHHmBtbYUgCJhP5pz50E8w2tsjPTrm5q09Ll26TuRBFEZYKdg9nHLx5iGiNIjEMkkMUkhaoUbg8KRgkhvGWUmWl7SFY00LdgKP5GiMLEvaoWJUOsZO8G+feowvff0ldq/v8WQsWNGVQOxHEWUyB6puRylFLTrWvZzOYWX1+dkaU11LsoqF1UHtmMyL2tULwjmksOiWj/IUtjQYZ5lk8NzejNcTQ+prpII49HFYUuvoeIrCWrSsXMn3rncIfSicox2FiLJAmupC9KVBhR5eqIhbXtUPasDmOcpBPFhh79YEz1O4vGC1o6t4ZeuQyhEHPvuTjK50dH0YZYZACKSwjA7ndNsRJs+wBko/QAhNT5XMxmN8JfC0IvAhiAIKJxDGEoea0klcmlEA6WROK1bM0hLPKsqigMIQtgJmM8M0ydFSMC8NEycQfkDc63CiG+MJg7ElgSdIU0MQhQwn76yiqaGhoaGhoeFHnw8s+lUIwZNPPkmr1Vr2MCqlePzxx79nn2On0/kup+N9993HuXPnvisq1hhDknx/kRKPPPIIP/dzP/d9xc6+XYQQfPKTn+Szn/3s2x5/MBg0jsofAYbD4XsqVK6srLCzs/OeXLcNDQ0NDQ0NDQ0NDXfHrYNjxntDtnsx587v4HcHXLmyz3h/nzP3nKO3dYKLL17g2sU3OH3fPfhBxMHuPgKFjNqMZnNiT1ImCdcv3SAvLcFKj93ru0xv3WJ9Yx0/jrG2BOvob29z/fIVWisd1k5sM9m/wcUv/w3J3h5bJ7bI04T7H3kYISXDoxFrJ3YQykMqH60DDg/HbPVjtlZ8tHT0PV1Fv1IJf8JVoot2layYUbn/cud4IXG8NjccZQanJMVkyKv/6W+hfy/nf/xDRG2JX/dVaimRshLmqttCHqOOg10qf3UHpVvGvsrFNqKK7Kx6LBf5sJWw5iuHFg6FwBcOr0qrRQJCOKoWxNuinRBiGQUrF1G0ctGjeTs21SLILUwtTAxMjSNzDoPDCrCicnLO05y/+/pF/rf//T/zj9+5RpYbbClwVuCsw6K4ObLM0xJXuzOtBYOoxkFU4ieicpzWdZTVJ8vqaGpz5m0hU7hlZ+dys+XW4i33b29yWwhdiJR3LOXyc2ZuHd/4zlVyYj7+8/8jD336F9l98yXs8A3O3XcvD33oIdbXBvjKkVvH8XTGzYMp1/fHOGNpxyFCa+LQx9caARSFYZzkDKcJUWk4owUPhJpzkUdPw8MPbfLTv/7TqEGXYyd55plP8PqtlBdeu8yOcpwOZSUIBl79WqlFcPDSoXr7HATOLi6petGsA2HQHY9inlLr1QgcUju8VoiQElMYnBCkpeCNYcaL45wRkrQ0FKUhKw2zwlJYkErR8v8/9t48SJLzvNN73u/Lq66u6rt77nsAzAAgAN6keEkQSVEUpZVMS2ttSHLQDsbKJsPHhpYr2ZbWWqEjtBcAACAASURBVIVi5QjTEf7D4bVlrUPWruzVrsQVJXJJkeBNQLhBkLhngJnp6Zm+68zz+/xHZlb3AANghsAAAyqfiJ6eqsz68susmprKevL3vg6TNY/9HZ84yxjEKbXAJ0sMrlYom9FsODQaNVoNh9aERxxm2Ezoh4bMQqvlMewNCOoOvVFE01dMT9UR38P1fLwgoJdaPNfH9zRuvcEozMiUw/pmTKvuohxhFMPQKkwq1NOIcBjT8DU1R2jWNW5QI8mE1Gq0Ulg0khr6o5T11S6eqxkkFs/VpEmGMoZa0ycuxG2aWoapIQ5qZL5Pa7LNnmZAoDKshUArBoMIr16jmxhct0pUVlRUVFRUVFye101UQv6B0XVdgiAAwHEc3va2t122bMm73vUu5ubmLrnvx37sx8aP3cnVJiqVUnziE5+4pmJQKcWnP/3pK06+dTqdKiX3I8BrISoXFxcrUVlRUVFRUVFRUVFxHTLY7LHQCdh39CD4Ps8+dQrfFY7f8SaMG/D9e+4mcCw33XaCMByytrREvdmiPwzZHMTM7NmLOIrhxhISdhn0Q86ePkuz2WBh356iRyJMzM5Tn57h/HPPsnDiNiYOHuPM6Wd58tvfII4ydh09hB8objxxA9pGTE43OHrLSQb9EVEc5z3mNjc4fHwfxw7NELiKduDgKk1TKzp+XiLTisVXeQ/IjDKRZ3EQNjLLfcOMpwcpq0kGCqLlszzyZ3dRP3A7+99xDL+hcRyV96ksBKEWhVaqEI6FNCxKuyosqhCSIqAFVJmUK/pSlmJKUcrH/IsOLXlvTU8JPhYP0FgcEbRYci2T35evL2ib39bFslxsFvOwgrJ2LPfK/KW1uVgs048GS2Ytq6sXeOSer3HqyacwRSnavHeh0OsN+cJff4GllXVMxlhEWpsvz6Va2a9SYWzu1TBsl3s1ZQ9L2dFfspSX9hLhWEq7cSnY58Uo87K4ghh5XslYO+6T2R3G/Nsv3MPyxSFTN7yboW3w8Hfuwgs8Dh45xKED87ztHW9ibnGezMKz59dZWh+yPshY2hxxvhux1g1JoxRJUnxjaBnLLoH9jmKPp5kNFAcWmtzxntv40G/+Pj8YTLAySvjFX/gJTp3b5Kv3PMgEluN1RcvL+1qKWMQYHC24WtBKxrLb5k9O8VqzKEz+nCIoRwjadeJhhliLNRZrigOsckFs0gwLjJKMs1sp910csI4iFTWW5VGSYawQZymBMcx4iklfYbSDF7i0GnmS0NFC4CqadU2cpRgSGi2XMMpoTnigNVGY4dZc+oOIesMnSSyBKziex4WNESYxNGsO/cTSGxpI4vy1trKFTWL6Wz06DcFxFGGUYAMH8Tw8m9AdjrDGkGSWUZoRF+nlNDWITRmFKd2Lm/S7fYa9PvWaS3eYQmZxHAeF4DcClElxPZ2noAWGKEKrmJxrs7fpERCRDiPqEpGiGWQOT55ep7c6ZLObvJpvrxUVFRUVFRU/QryuohJygVemJbXWvPnNb76sZNy/fz+NRmN8W0R417vehe/7L1jXGEMYXnlJiaNHj/IzP/MzP9wOXAU333wzd95558uup5RiYmICz/Ou+Zwqri3XuvRrp9Nh165d12z8ioqKioqKioqKioofnpuO7+bAm27GtNpsbvU5fNNRjr/1Drr9IY98/dtMTs+z94ZjXDh7nqUz52nOzROTi5GJdoet9S20Evbu3Yf2NMO1FTwD07v3kGEYdDdoz8zS21jnzKln2XP7O+ltrfPXf/gvOPfoozTaHXYfOcLM/ALTM3NEwyGL+w8yv+8Qz/3g+4hJcTyfNImYnJxAaxfX8Zlt16g5iqlAaLpOXl5TC37eyDFPPpKnLL2i5KgVuJgZvjfKeHIzYiM1aFcRLp3h4X//TaZufwcH3nWEesPBdRWeo3M5qfOejo7kspLiIkwlkvfik7zMqpa8J6YSmz+OQjjJ81KWFFITcAVcEVxFUa4VKPo7ll+GKMChEKaS9zXMJWVu8ES2exnuTCOW7Mg3bucTpRSZFlOkJC2FrCylI4ItJaWx4xCpxWLMtiC0ZvsH8t+ZAZMVP9ZeIizLHpQi5hJJWUpLOxaaO+YqYMRiVF4i1ZLP0RjB2FycGmN5/Kkz/LN/9Bke/urfcOPbfwLlwMVTPyBJIvYdPkCj08Z1FYEfgDGEgyHZcIQMQxiFNLKMts24qeVzUyNgt4JZBU0NDVdYmKozs3uOU+fX+d1//Ls8+K27+OjPf5hvPfAs/+Huh3Ct5Ziv2R0oHCW4SqFEk8VJ/pznrSTHr6Oyb6gVEFGFzs5ls193sKLJRjEms9gsLxmrfI1bCzBYVEOTWlgdGB5YGfB0KsQIWuUp0zjLi+Q6xjIhiiaGhrY02k2MUyNNU5I0peFrlLbEaUpqLJ6nCZo+3dDgeQ6D2HJxfUicwfmVkDATlpb7RFGM47qs92OyNH/ytwYpaQITDjga4n7IhK+ZbgdMz7aIRbM6SDi7GROmQhZHiChavkvDy+fuBQ6um0tMqzXdfozYlMgq1roxqRH6YUaWGrTK/73EymF9Y0SGw3CQkBmIlCJxXBqtgDnPxbcJGUI90GyMLBc3RnQHIX6gsa6wEV1d5bOKioqKioqKvzu87nUXRIR2u00QBMzMzHD48OHLih3f99Faj28vLi5y7NixS+4rMcZcVaLyE5/4BO12+4fbgavAcRw++clP8rnPfY4kefEryVzXZWJiokrJ/QhwrROVU1NT7Nu375qNX1FRUVFRUVFRUVHxw9NYPMTpcxeQeMjc/DyN+V1srG/RXz7HDW86QXN2hrOPPspgq0trepYMIR72aDRqrC8vUW/UkEaDjd6QWqPGdLuOUQEbqyuYNGTfDScZ9jfpra9y8l0/znNPPcbDX/8GU+02B2+6AeWA6zhsnV8mjVN2HTmMyVI2lpaY37ufUSZkYQhJQpIkeE6K61s67Tq7hhkZQ9aiEb5WxNaQFCJNBLwyBUiRZLRChuXJxOBHgr8ZE8w3aKiM/lOP8diXJrj5p9+PzSzPffdpwmFKZgWMwmDynoEWwJAVNlBKCVqUmkUsilye6UIgpiZPdpVJQEUuqBwF1gjGWjwlGCxp3h4zT4KKRduiJKrNRSuSi79SYupxKdZtAQi53DTFHK0VxFp2GsxyOoadycv8uNki2piXuS2HlHFScnyPBWPK3SpVaDkPW7bpHD9+XJiqkKsWNb7P7igRmws8OxZ45WbL/SzHtTY/duP8qAWTWb7z4EPU/qff5eO/+DFO3Pw2suEK9ck2j3732zx3Zo2z59Z49uwq6xs9JgV8V+NrYZjZvPQpoOMUk2X4SnBUnjRMRPH9tZgzZ55Ea83733wje296P3/+53fx6DOncazliKe4oaEJHHAKeWyzLE/HSv4aFKXy16jNBbg1WX4slMq1sYDf9LCuQ7Q5HJtjUYCyiO+RJBlB2yeOMzaHKd9bC3kyMhjfR6XZWE7nCdiMmqvouBoUnO8nuPEW7UZA6sAoSpmouZjUYJXBb7jUW3XW1vrUWj5nL4wwcUpiLYNQcCV/5bieC9bQDzPq9fwi9jC1iKtoKEPNVUxM+Iix+K5iK7GcOdfHBdxOGyeNSKKQRq2GR4rCUKvXSIAsM0SRQbKUeBQTCGwMDfEgoeUrYgMmtfiOUPMVbs3h4rl1avUaSytDNIqtKCFrNAiaNXY1PLxsRJhCveETGejGGXEYM1fTWN+lM9/i8If+3hW9b1ZUVFRUVFT83eN1F5WQl68MgoB3v/vdL+hDCXnvSmPMJcLn9ttvZ+/evZeVeVeTqJyfn+djH/vYayYFT5w4wXvf+16+/OUvv+g6nudV/Sl/BLDWXlNRqbXmwIEDTE9PX5PxKyoqKioqKioqKipeGd+77yFanQ5HbzlKOIo5/djjNHRKa2KCjY0e5545ReBoGlOzhIMhNRTDrSFie+w9sB8beFxcWsZ1NVPtDkmWEqUZ84uzaLfGoLtBPIo4/t4P8dC3vsZ9X7ubw8cOc/yON2GtJQ17bKwsUWvWmd2zn9WlJZQSWp1pRsM+kiS4zQbO3DReq85wEGKsMFgf4QcarRVTvktqLN00Q1QurBzJJZcxeSlVgKTI6qXAM1FGQyze6ohjky4NYP3hB/lBvcbJD38EJ/gyp77xfegLSWpIM8iyPAWIzftDWlMINgtaC8bk/SS1KKzNk4pYk5eDRZGRpyjFCmINGeTiUdl8LASjLGIg2lkK1VpssQ8pgkZhtvUihZoF2RayxuYpM7Ojd+a4lOqOv196j4znXX79kI37KBYrFmKwvJ0LxFJVFmNJKS7LFOd2Cdf8txTzL3talkYzl50YmwtUyftqIpcKVcoUYilN7aV7k6SWr977MIJhtP5Odh3cxepmyMGb34Ko+zj91Ck2Nnt5Gd0sw2aWJDMECiYbDtZkTLYDtrYitkYJMdA1cGEUE2aKNx3Zxdvf+06ePLXGH/3hn3Fxq4dgWdBwsi5MeOAowdcKR0uRNM2Phes62CwDm5fyBfIawIXw1lpwPAWOJuknSFY8f1oQUejAxRiL9oRRL6Q7NDy5EfNoP6ErClcpxAOTGjzHydcFAlEEjmY1trikdASSMMQoaPoaT1zcmibwXYxSdHshz23E9C4YnCzFq/msj0ICrZh0LIFysBhia1EKag5sDRO0F9AQg+tmNFs+fr3G+uomiXisdRPiOIN2gzCyqFFIvQ4mHmGUwmiXYRTTaLgsbUY4rmbUj2n7DhthxupWxELLQ1yhQb7Nmg868Bj0Y2badc6uh4SxwfNdQteh1a4zH/gEJsZoIXAcwgzW+jFRGDNVd0hdRRalmF6fs/fczZH3v/R7ZkVFRUVFRcXfTa4LUdnpdKjVarz3ve8FeIE0bDabJElCFEVAnq58xzveweLi4mXHu5oelR/84AeZmZl5TUSliDAxMcEdd9zxsqLytUh4Vlxb0jSl3+9ftufqq4Hnedx6661V8rbiukZETgNYaw8Ut38V+L+AX7PW/tHrNa+KioqKioqKiteCznSHG972VoaDTZaePkWr02Z2YZGt9Q3iwRYzi9OsrnZh0Md3hCgcEtQ0M3uPk5qYtbPLBJ6mPdkijg1GhIUDB0mShI2Lq0zMzjF34ij3/tXneOzeh3jH+9/NwoH9DDY36K2uEg36zO3Zhe/XOfP4E8zvy0vIhv0+XhCQaI3TaNGcOcK5HzwEkjA90yKLE9Z6Aya7iu7AYrK8NGums7z0qM17MSrJS6+m1u7oEwlDAw+HFk8SHLEcafvUs4jVe77L40GdG+78MMrVPHPXowy6Sd4fUAxYhatzoZdhMNYikotDKYQjhRxUFmxRwjXvlVnch0EJZEUW0JNCtqkiSWgtKYCVQs4Jpniskh3msNiWsbnrMsV6lGLSFqVkC7tni1hnntvLU5pSykGbJ0HLPpVSJlPLrGQxVrkfpiwiW0QwzThXuR2NLNWllHZRtnVpWULWbochczFZzJ/idrnvZcnaPFy4ff663SezXMciVojjjC/d/T1Co/nZn7oDj4i7v7GK5/ucuO1m6s2neOzx86ys9YniBM8IbU9x08m9OMqy94ajfOPrD7JyYZNYFLun6pycnGDh6G2kwTyf/8vP8/SppwmTFMcK0xpubzrMB7kkd1Re49Wa/BA5WudHRwRRGqzJl8H4+GoRRFmUo0kGMSQGi0U5gohGfIWVXHlbYxmMDKc2I+5dD7mIBq2x1tIKPLZMzDBOCfKmqRgtnOlHBI7g+BpHgCwjUIqagjSOqNdqDOKMLItJMyEcpXg1TRLDRjhkcabNBCmBsrieZrUX02wEiLWMEovnunTqDkosMUJoYPPCBnXP5fS5PlYLzXYdtM+55Q1mA+jUfUQJjlasbY0IJnzWujGO65GkCZ7nsDGMMQh7ZibQWUjd01hj8Gua+kSdlZUeSjRrvXzemQjrItTaDabrATVJyFC4ojAGNnsRaRQzUfeJTcpwfcT+xUm2eiH9Rx55Re+nFdc3zz/3v4L1DwCngH9prf3VazStioqKioo3CNeFqJyfn2dxcZH3vOc9KKVwXfeS5RMTE2RZNhaVBw8e5H3ve98L1isxxozXfSnq9Tof+MAHaLVar3wnrpAgCDh48GB+wvIiAst13dd0ThXXhsFgcFUliK8W3/e57bbbrtn4FRUVFRUVFRUVFRWvjMO3vYmVs2cYbW4wv3s3aMvqap8sDGnPzdHtDai3JnBF2OoOaE5N0uh0WFu5QNLv4ng1XK/G+vqQZjNgcn6R7vo61hqm9+0jspp//y/+T8hSfuyjH2Rieob108+wtnSe1vQUh04cJwojNtaWmZyeYGvtIq7r0pycQhRM7tpHHI948EtfZN+Jk+w6eTNZOCCTBzkchiyvDsgMuAoaWmFSS2yzvLSqlGVZLRqFLhoiWguRGCIrPDgyOJLiaMXhtocXx5z/+tcAy7EPfAAbxzz73Sfpb+SC0BjIjAGlEAuZWDJrwGyXV7WFFB07u9zRoWyZ+8uTk05RilYseCpPf1qBzFqMFSJTlFFlezxNOWZ+21rQ1ubyTkG5USsWYxgn9UpJWUxnLBHtdpgRa4uLskuxSNkvMl/X7Cilm0vUXA1mUg6yc3wo2i3CeIRxcdhLXoNWdvzAOG057t1YLDDldq3dTmmWYxTSdfugQ5ZlfO3uB1he3+KT//mvcvTwAt+771vcf98yidVY1+PQsb384PQFbJpw8s2HOPHWk5w9c46Hz1xgFHh0ZifotJsszrZRtXnu/tYDPPrks3TDIRiDRmgJvKmm2RuAqxVaBC2C6zjYNMMVyQ+ehswaHCyi8tSrFAlYpSxaK5SCbJTlx6you6sdhXgKqxVa56J2ODQs9RLuWY84lQmZAtcC1jCME5TWSJbL9IbnsZlktB1Nw1U0XU1TQU0LNV/jiqFRq9HtD0mNTz9MefJ8l5nZBodvOsCpx89wcqaBpBm9Yf5sJolBa00tcOmOQhzXZfdCk63NEZkVBlFMzeQJxrV+nCdJfR/ijDRaZzGAiZpmFCc4gU+WGoK6z9YgIc0s/TBkbtJnc5AQWc3u6QYuEA/z14jjgBFhbWXAKLX0e0NcR4NWZLU8yTk3WafjC6ORhcTi1hSj0RDRmpqriJMI0Yr5mQ7rW0McLLGuLrK+nqhEYUVFRUXF9cR1ISoPHTrExz/+cRYWFuj3+y8oe9rpdEiShNFoxM0338wf/MEfcPvtt7/oeFfao/LYsWOcPHnysuVmrxVKKRYWFuh0OmxsbLzoOp7nvWZzqrg2DIfDayoqgyDg1ltvvWbjV1RcI/4d8F3g/Os9kYqKioqKioqKa82z338UR1la7TbDMGTlwhozc7OIX6e72SeLh2i/xmYYMb9/D8tLKwyjIVkUEbQ7hMMhtr/JRHuSVmeG1bPnUFqz97Y3c/7U03zn8/+BhV0L7Dl+E9rCxccfY9DtMnvgMAtHjrJy9lmSwRZzu/Yy7HWZnm/jaIVxfeqtKfqDLaLuJrf9xAeJUstzp88y4Vuak9Mo7zyB7zLhaxxRnOlHKMDXgpU8HSgIaVqUI1VlD0iLRlAWutbwcGhREoMxHJoM8OIBy9/8OtbEHPuJD+PPzPDkF77LYDUiTnPZZmwuLiV3k0VqchwlLNKK45tYcpm0XaYUxpnFwq0FYlEmF1Sl4AQhEVvIunGOsRioSCyKyrdXCkYlGKtQ2oABUxrAMr1YTMwWZWW3a8xSCEG7rRPLdcqtFrel+Ht5cbNVl+rHUiWOE5tSpjTNdupyPJ/tR1E8Z+XBK0XqePpi8mM9tqFjwzp+7LbEzPf78See4Z/8d7/PjceP87E73867bnor609/j3i4yQ1vfQ/9L32bi2ef5bm1EfNn12nP7qf3zL0025M4bshGL+bRJ06zdPF+umE8lqLaqkJSKg43NI7K56a14Hkak2Q4Yse7irGQgdIKUXnS1lqTJ2WVYG2GzXLhrZTaPkZKgasRk2vcKLGc76Xcsxby/ciQKY1DLtANilGa4jk67wWqNL04Ybru4muh4Sh8a3CUYqYT4PqKNEwZDAek2mV5fYDNUuaaHu2pBo26z+HFDjqMGCUpw1FE4npMODDVrrE5TDGpUG9qtroRo1GCSWNqvoNkGRthgtUarxngGYNNE5ymj9IWR7us9kIkzZhuBmxubKGVINoyP1HDJgnzUzUsHkQjHFcToZAsw6kHRMOIUWq52EvxEKwVVpN82b5OkwkxRIOIwFW4niIzglEeKk7RjsXJLJPtgM3uiCxKMI7Cza5NtamKioqKioqKNz7XhaicmpriU5/6FI7jkGUZCwsLlyzvdDpEUcTNN9/MH//xH7N37978g+VLcCV9AW+66SYOHjz4iuZ+tYgIs7OzLCwsvKiorPjR4GoTla7rkiTJFa9/yy230Ol0fpipVVS8blhrt4Ct13seFRUVFRUVFRWvBY16ndk986yePc9gvcvMwizD3gBjUlrtJoljcfyAfYcPs76+yqi7TtBo0WxNsLmyRmbh6MljKO2y/NxpmtPzzB08xN/e9Q3OPf4EJ950glq7AWnCaNAjSSMWDu5H11s8+q2v4SEsHNjL+vISvuuQaofMr1FvBqwtL9GanGDq2I2sL59n+cnH2XX0OFkS0RvETC7Mc+KGEGvO8djZPp7AhKNIROhagykTiUUCz2R5X0MtgiPbEmw9hYfDLJeOKuHwpI9KQi58526sdbnxI+/hBkfz9BfvprsyIgyFLMty4WctiKKs8WmKZKFW+d9V4T0ya/Nyr0XvSBgXSiUrUp6O5I81Aq4VjMqTmtbKuA9kKQZVoeQEwUiezCz1oC1Kz4oVjGy7xp1lWY3dmZXkErknItvS85JEJNs2clzGtZCLNk9xFoVMywzoWFKOs5ZSlnK14/0vvxlRdse4hQxVxSHenmiRMhQ7Lh9bytBxhdnt2ZKXus1LFj/40AM89MiDTM8ucGj/buo24rHzX8FVil2zM/RHMQ88vkz0yBJL59ZZWd2iPxwSJRlxlo3TpgrQxtLScGugOd5QBNrgKMl/tMKk+e0yVKok/66llKyS5XudlyY2+WvCArpMWApKC8p3yIxFWYsOHJJUc3Z9i3tWRjwwzOhaaBTCWClFkhlECUmaUvdcEpOhDNg0pRnU8JTFU0K9pggaClcEr1FnZSNkqxchCEMDnbZPY7JDvLaFQ0YvjsiyjMmGi1uvoU3GyuYIZS31mkMUJnSjGMcRAi9PWq6s9zHiYMSlZizKxDiBQ5rkctbXhsmaUPMVURYR+Bqs4CrwHYNon5oSRlGE4wnhMKGhhUGWsL7SR5SmO4gJE0jFkjoGt1Vj13QHdzikl0RM1H1MkuVyPQhwcUiyjCS2zHTqxHGGhwVXAEWtdl18BVlRUVFRUVFxHfLStu81QkRwXRcRodFosH//frTW4+UTExMcP36cz372s+zbt++KJGUYhi+5Tr1e59Zbb2VqaupV2YerYWZmhrm5udd8uxWvLb1e74pKEAPs3buXn/zJn7yq8T/ykY9U/Skrrgsk578QkUdFJBSRcyLyv4rIC5rtisiviogtelXuvP908dMQkT8QkedEJBKRp0TkN+RFXuwi8nER+bqIbInISEQeEZHPiIh/mXVvEZF/VWwnEpEVEblfRD4rIu6O9XaJyH8vIt8SkWURiUVkSUT+RERuusy47yv26bdfZI6ny34dlzsOIvIhEbmr2IfqMuOKioqKioofIWb2LrJ0+jnCXp/W1BT9zS2szWhOzTCIDG7QJOgs8PRTz7J+YY3FAweZ37ebJOwz2a5z5Mh+kjjh/OlnmT9yE1MHjnD/177K6OISb33n7TQm2+gspbexRhyFtOcXQGueuv871D2H6X17iZMIxxpcP0BsTNBokIxGTEx2aE7PsXHmNOHGOsfueBtRkrGysopSQntmgV37d9FqeAQKJj2hWQhCTS4jtcp7/JnCYrl6uxwr5OlBg2U9tTwcZjzRi3l6M8T6DiQjLn7nqzz6F9+mfvwdHP9772Nmf5ugpvIynVIKKNAqL9upRFDjpKNFKdAKVJHidCX/cZBx/0xXFA65QHWVoqaFuhICLdS1paYsruQi01GCQzleWQo2F11lX0xlLbpIRUoxP7Xjk2qpKHdWSt2ZYpQdAvAS7A5fWPTStAJGil6T20YyL4FbSFdTHG4zlpT5H9baQsCWzwVj+ZgLRsbHpdwXVchckULmlfsNY7GpGO8KFOVjSy1sjWXl4jnuvfc+vn7vI3z52w/yxW/dx5e++Qjfvv9J/vJv7uWLX7uPh594lvObW/SiOJd/FElHC46FKSXcUdMcb2oCR9BK4SiFLuSkWDvOdpbi1VqbC21jsdagJe8tWgpbJYJC0J5GPEEclZcVtvlRixLLsxe73L8y5IFhykVjsQpiA0o0qbFosbgiNF3NKEloeh6LTY897TrWZHgaOvVcJGaJwaQ2F3fWorXD8iDCa7hM71okiBK6qxucO7/JIBRWuymxuLiORltDO3Bo1ZxcOipDZ6JGUPdBIIoTEBfxfCYDBSYBpUgyixbwtLA1jKg3A9ZHCV3RZPU6yquRWUua5v9W0zTFCRwGw4R206U24WLEQWmXzUGG0i6tuov2XLxmg72Ls2AsozSj6TsgFsdVRJAbYlfT64W0aprRMEIlCTgKVztMzU6RZlf6zllxrSnOXU8VN3+lODe1O85RveIc/69E5Nni/HldRL4sIh9+mbHbxfcB54rvB74vIp96sXP6FxmjXpzXPygiAxHpi8h3ROSXXsFuV1RUVFRcx1x3lzN5nsctt9zC4uIiZ8+eJQgCbrzxRn7lV36FxcXFKxIz1lqy7KU/Ac3MzLxk+dhrSafTeV0EacVry9UkKn/9138dx3H4/Oc/f0Xru67LnXfe+UqmV1HxavJZ4FPk5Vz/dyABPga8DfCAK40Wu8AXgV3AXwMp8LPA7wMB8Ds7VxaR3wM+A6wCfwL0gQ8Dvwd8UER+0lobCtlECgAAIABJREFUF+veAtxN/t3N58hPyiaAI8A/BH6rmDfAe4B/DHwV+LNi3KPALwA/IyLvstY+dIX79HL8AvChYn//N2D/qzRuRUVFRUVFxXXAqWfO0Gm2GLk+586fp+Z5uHWPpfPLLMxNEqcRy08+QbMRcOiOO1hbXeW506fZvbiL2cU5Vs+cZRSn7LnlLWyuLfHE336TiXpAfW4WXI+6q+hFIfVWi5or9Ld6pKMB+w7sZxBm+LWAeqPBcKuPX2+ia3XSJCao+7iNJr2V8/iBz9TCPMunnmbt4gq1ZgfP1/i+QxgnzEzVOLrQ4MnlIb0kJNACqSUxwhCLyfLSmo7O+zaKWDKzXVLUKbJ/a5nlgVHe39LzYg52fHScsPytrxNv9bjp5z/ADX9/hmc+90WWvn8RhpaEvP9gXhJVIdpijGCNGVcl3e6fmMu3tMgQqjJhaHPRKcZgsXlvTWUhU4gYjMoTfGGhFG1pDIsUoy70oWIcOCzCi3ZHA8ptYVY6SWsFKZKJQCEA8/uLIXbmIi9NYO742kOKjUq5QpnapExabq+7c4ztkbdRO+cM+CLENheeZb9OVYyUz3+7Mu141jvkpR3/lFuyqEuWKCyWFEs2tlQWpcpUablvealgD2HOgZvrDntrgq9MntBVGq3AUQqK9Ox2JWBbJGALkSsWV+u8Z2rRW9QiaK3QjsLxFeJpbGYhStCOIrHChfURD62MuHeQ8VyaP+HWWAJtSYzBiqVGLrjDzOIrTaCgE3jEUYzjOLTrAWhDmFgCz1JrOSRJxvL6iHNDw9R0g32HFnBGCckohDSjU9dkroPfalH3HPq9ITNNF5MZkgSyLMVzNZ6Tlyje7Kd4nofyHKZaLkma4DmCNSmBIygUiYV+rDh9po+uudxweA6xdbpPP8Vk28dxXYabfYauwq83ac/WyZIBq2uDvIxykuI7eZLYahfjCfPzM5gsLzU72awhWYSnBXE8uus9Jlqaixt9ppoBaZrhiBAayLII5XlcWOvStCkV1w13AR3g08BDwJ/vWPYgMAX8L8C3gS8BK8Ai8FHgr0TkP7PW/h+XGdcDvlyM/a+L2z9fjHUc+PWXm5iIdICvALcB9wN/SP6W80HgT0TkhLX2t65udysqKioqrneuO1EJ8Pa3v52Pf/zj/Omf/ikf+tCH+OQnP8n+/ftfNklZYq19WUE0NTX1uvX3a7fbLykqrbWkafUB7o1Or9d72WQvwMLCAr/8y7/MN77xjSse+8SJE+zbt++VTK+i4lVBRN5JLimfBt5qrV0v7v9NctG3CDx7hcPtIj9JutNaOyrG+R3gCeC/EpHfs9Ymxf3vIJeUZ4rtLhf3f4a8D+ZPA/8tubQE+BVy2fmz1tq/eN4+TALDHXd9BZi31vaet96twLfIxelLXkV6FfwU8FPW2i9c6QNE5L4XWXTDqzOla8Ndd931ek/hqun18pfAG3Hu1yvVMX31qY7p5SmPS0XF602r3WI0irjnmw9w5KZjTO2d5+wTT9HqTDJMLYP1TeZm5pjcs4vTTzzBypmzHLvpBoKJFk8/9hjtzhSHbjzJs489AmnMLe94G1ub66TDIVmasNYLsUnMzPwszz31NM12m9mFOcAwO93E9X3i1NCYniEOh4QbazTabazjM9jYIGi20J7PxsoKUZjSmZzFCTxGiWJ5eZlGvcae3TN0N0PctYimqxAsjli2Ykua5i3+rLVYk6cbozS/2qxM4RXFUrHWspZaHhilpKtDwsRwdLaGnyRsfv9BHo0jbvj4T3H8P/mP8T/3l5y9/zS9bkKWWTJr88SWFazkoqtMcYrkyce8Cm0uLV0lZNaM5ZU1FhGVJzytyUvTKosYBWKJsUUYz5KpbZcnhbjLy4sqrDV5MnFHonCsA8ukZ2ELS6lpi1Uu6e94meuvRW0Lz2LA4s/cFo5FZbEtVYyjKITSzmHLUqfFCKq4b1vqFglJijK3ZanaUtCSi9jxmDvFaVlYVnY+vzlqR7FbKY2u3R6jLKcrdnssZXNd21LCPkc4XtfM+uBrO07FKgGnmL8jpSTOBaV2dP4cmXw/dXFMbJbl5V01aEfnfS8di/YdrFZkaYJyhETgQj/ju8sj7u+lnE4scZEarrkKVzlEWYKnFJ6vGaYZdcfBU5Zpz2JtRoai4wijOMVxFL6rqAUeq1shnvYwnkYyOHHyIGHfcP78MoGGhudgUIijWZhssr4+QCmNxpKECUlqqTlCrR6Q2QzHWrTj4tUDFibrrG12SZIMR8CvubiuJh4lhMOUpe6QkedxZPcMtYk2E81psvOn8QOXcBBS7zTYiqCjXUzYp9uLQTSDMGaUGNpNH8evsR7FNJsthoMBge/QziJIQ8RxyJRHf72PVor19YjJukdmE1SaYZy8j2ZreoKLGxHTdaeQ2BXXA9bau4qqP58GHrTW/vbO5UWFov3W2rPPu79Nfk78z0Xk/ynP23ewCDwDnLTWRsVj/gfgb4F/KCJ/aq39+stM77PkkvI3rLX/fMe2A3Kh+k9E5N9Yax98qUGu5Ly5+vz8w1Gdf7xyqmP4yqiO3yunPIbX03nzdfkpYWpqin/6T/8pDzzwAJ/97Gc5dOjQVUnKcdmPF0FEOHz4MDMzM6/WlK8Kz/OYnZ3Fdd3LLo/jmK2tqoXbG51ut3tFovKjH/0oMzMzTE9PU6vVrmjsO++880VfPxUVrzG/Vvz+Z6WkBLDWhuQi8Wr51M6THWvtReAvgDb5FZgl/2nx+3dLSVmsnwL/DflF5p+4zPjPP5HCWrthrTU7bl98vqQs7n+IXGK+f2ep2FfIX1yNpKyoqKioqKh4Y3H2zBrf/fJ3uenkUaZmJll64inanQ4rm1v0ul32H9xLa36W5546RTYccPOb34Rbq7O1vMSuffuYnJ/nzGOP4roec/v2M4ot7fm9tOZ30dtaw9WGoNHg2SeeYqozSXOig3g1GpMdkiTDJAntud30exFbFzdpzCzgt9qQpfiBD8YwXF9jfekcJk2pt5rE/T4/+MZXGPb6uJ5P0JlmdrHDXMtluuYx6WlcpXAcRc0RtMrLTSolJBkYJC8Na0EXftGYsuBoXgb2wUHC9zZGPH5xROi7eL6h/+SjPPRH/y8ryw4Hf/4/4sidtzK9UMfzi5KfRZnXvFehwhGFLiSWqFxKKhEcyZWgFhkv1zqXcI4StCg0ClcLnoa6gkCBr6AmFr8oL6sKAVoKV3ZINtmOSW4LyrHRK8QipSssdV5J/ndDXr51e51t8m2UQtGOhacpgorbpVpl2wJeIiHtWAzm8y/Lu8p2KVqEzMhY8MnYqu6YR3F/WRZ2+8eORa5gd5TptYiYcfCznPv2Hm7LWrGgrVAX2KMtJ324uaGY9S2eyiWlFoWrVZ7cK56/Uq4qim0Wx0SJ4DgKRwnWGpQWtCMEnRrac1COoAIv7x+a5h/9QwPnuinfOdvjb7sxj8eWkc3L6ALoQmoH2iUFemmG0g5Y6HgKjaCBmYaHozVJljE74TFdU2htWF6NuPfpTZ7bTNg/N4mEGatL5wl8l1bTww8UoTG4riYKY1wHUlGExlL3XGaaHu0JD2NSBmFCYgS/VqOmha2tPr1+SpyCFYVRwlY/Jsssge9QawQs7p3H6oAzp5fpLZ3Bb9QYdEfUJ1qYxLDbF0yvT39riKMUq70Rq/2IoN2gXgvoRkPaEw2UTVHaoZWEtALBagd8j+dWRiAO/UGMXzz3voDjB2QIrqcJQ8OkVmgzwpHqgvw3Ctba6PmSsrh/izzhOAm85UUe/plSUhaPWQf+x+Lmr13+ITkiMg38MnDvTklZjBMCv0H+dvL3r3BXKioqKireIFyXicqyV2Wj0fihHj8YDF5yueM4vPWtb33d+vuJCLt27aJWq5EkyQuWV6LyR4Otra2XFZW+7/NzP/dzuK5Ls9lkZmaGM2fOvORjXNflx3/8x3Gc6/Kfb8XfPcoa2l+7zLJvAlfTiWTLWvvUZe4v/1FMXma7X3n+ytbaJ0TkLHBQRNrFydSfkl8t+uci8m/Iy9F8y1r79OUmIiIfAT4JvBmY4YX/X86Ql7p9pdxztQ+w1t5xufuLK0Zfn5rmV8D73ve+13sKV015dd4bce7XK9UxffWpjunlabVar/cUKioAeOrh7zE53ebC+RX6G13aMy3W1teZ6zSZ37cf4zisXlhiarrF9MI8F547TxB47Dl2HGNha22VyelpMmDQH9GcmmN1dZ140Gd23xGee+oZ0t4Fjhw/ghVDZsD1ApI0oVb38ZvTnH/yMbJhF78zi3Y9kv4Ar+6TpIZo0GNtaQlXDPVmi1G/i7Ipt7ztDhpzuxAt9C+eZ9TtcnB3D8dVnO8lbG6M8E2CVUJihFAMUWpJC2GkJU9VluVJIRdvZUZvM8uTlbENSUVx84EOU+2M4fJpfvAv/4TBh+5k//t+msb8LM986W5Wz2wRjjKMgay0dQqs2U7nWcmlmLb5drOiDKiSvIyp2hF+NOOaqXkfwqAs7yqCGAMIUVHGdSwHbSHtxunI/PGXFG+VbaVZ7PX47jKJaMnTkXkpWRmnGHO3aHc8dueQMu5tadlOadpxolSwZWKyWEfxvLqwRSlUKXKPRvIEaSk+8+Tozgu+7bjsbJmsVDsSn0ZK+Sx5edjSmRYatJj+uJRs+TwpBG2hJkJbYE7DoqeY9oSGK3gKdCGjlVi02tEn05ZlY4sStOXzBoXIFqToT+kGDl67Thpl6MBSm59mtDbExglYQxgZzvcS7rs44t5ewjOJJS41bil9RRFl2bhfpyd56dm6JySZQSuXmis4GgLXoxUI022Ppm/ph4ZBCl0se2Y6zPouq88tQxJRm2zRaXosr/WZ7tRQrQnC3gAxgu9pRIN2LKMwZtqv5UniOMU6GpOkDCJLUwstX5Ng0VrlJZgdj2gUEtuMiakmuuZTs4YmEba/RTIYIK7H+eUN5jsBaZYSDSKU4xBFMTVPmJ7tINplbaPH9MIMwxQy10W2BkjD0h/GSK3GmaVN6p7HKIpp1xQJmv7WiJqrSLOIRqNGt58w3dGYmsNgK2FxV/V/8xsJETkB/CPy1iiL5BWKdrL7Mg9LycvFPp+7it+3vcxm30IRki/6aD6f8oLhG19mnCs6b64+P/9wVOcfr5zqGL4yquP3yimP4fV03vwjaTperj+l1vp1609Zsri4SK1Wo9vtvmBZHMdsbm6+DrOqeDXp9XpEUfSS65w8eZKjR4+ilCIIgit6czhy5AgHDhy44pRxRcU1pl38vvD8BdbaVERWr2KsF3vjKy+91ZfZ7ovJwvPAPvLeGFvW2ntE5MeA3yTvC/kPAETkceB3rLX/qnygiHyavNzMBnk/jufIS8Na8p6ZtwL+VezXS7H88qtUVFRUVFRUvFFZOLQHz8RMTjRIlUeSGY7deJh6a4JhnDLq9ZhZ3E2jPcFTDz7CRGuChcOH8wTV6gp+rU6WxvQ2emRWOPP0Pfi+Q709w31f/zbTDZ/jJ4+SaQ+lNIHnYlG4QYs0SVl59knqnuVimNLKLJgEp9FiY2MLz/eJ+z0angZdIzW54MFzqLU6jMIhmysbDFaXkXhErdVibXnEqV5MYgRPKayGyBjiDLDgFgm/1Nj8arUdkosdZT5FhL6x3BcmjFb7UG/xkz/7E8xHS5z6m7/l6T/7d/TOvpNjH34bN/2DBZ79wldZ+t4Sg14KSV7o1JS9CosysGVu0WDHpWDzBKTkwlQEMHkMb+zjCrWmipRflo9ni7KiI5tfdVemEtkxTplMLBORZX/K7cTgDjNalKzd3qYt2ynywuuni9Kq5TbtjjGlXGP72NpiIDF2LFBF7I652e2Vi9umuDsrtqOsoIryr0YKwVweHVsmMm0uKgvh7Mj2ciNCZu3Yi5ZpylK65mJWcAXqCE0NHaWY1JZpVzHlKQInH9MppKCjyHtNKgWZLV43eQpVF8KwFKx5alblZX1VnqzEQrQ1or6rzpFf+hijQcCpf/3/YdOMYZxxbivl3tUh9w1STqeWuJiztmX52Lzfqa80IpZAKTwRWo7CVcKEl4vUMDNImuF70AgEm8R0U8WFzYhNpdg9P8G87xGHMSubPWpND3EV61FIc7rFMLK4w4RMexBlTNQdPKUYjSKUHzDINP1+hOcH+I5COx7tuks6ikiiGEFIrMLRLoNBjzBK8JoN2vWAJAppW4PKYrq9AfWJJhdWu/gC/VFKFCX42qU3DHEdzfRkE+N4rKxt0ZnukKYZiRvgjlIm65Y4isF12by4yd5dbTa2hjQdhyDQrG8OcYp/f44SomFMsybUmh6rKyMmWjWWV/svfJOsuC4RkbeTXxTsAH8DfA7okr89vAn4GJc/J1611l7uS9nyvLd9mWU7mS5+v4UXT2wCNF9mnIqKioqKNxg/kqLy5VJsWmtOnjz5Gs3m8pSi8nLEcczFixeJ4xjP817jmVW8Ghhj6Ha7L9sr9S1vecu4BLHneTSbL/9Z6y1veQvT09Mvu15FxWtEGf+eJ+9FMUZEHPLk4QtKxryK210g74/5fBaftx7W2u8AP13027gD+BDwXwJ/IiIr1tovF3P+bfITqduttZeI0KI35vMpy8a+2P+pHV5cwr54nfKKioqKioqKNzyO0uzavZvBKMRTwp69e6FWpzfokw0GzO/dRxjHPHb3PSzu3c38oWN0t9YJN9fQ2ieKIzQxaRoxGg6ZmQzIjOLc9x/k+P7ddHbtZpRmtDsTaCDNYkSEzY11WjVNq9PGb7aYcTfp7N5HFMX84IH7Wdi1C8IugSeI32BrcwiiqPkufnOa1Fgk2cJJN5ltOyTNeR4+8xSDXkjLGBxfWMsUwzTLPwgVpT+tzROPtpA94xSgLcqOyqWFUEcWHooyRs8uY7/4MD/2joN4cy3ilR4XvvkVBhcucOLjP83RX/pFml/9Mk9//Xv01yMkyaVVlpWZvrI0qsUaC6JQxuS9HJWQ2VzAYQSRstypHZc7ldIaahCjEG3QxmJNLkFNsY2xaxyrVy6RgXZniFFyqSfFg8qemjvLvEp5bBgfmO08ouQJwvKDpinkmSqkZz7c2NDmPTHHicftTONODyrFHEsJmjvbcv+LscvU5o5OQWXCUNn8eQYZ96BUSoq9UuPHSvF8Y0Fj0UrhA4HkScqWhinHMuUpGkoIHEEpW5TmFbQSXEejEEyWoRFEFVlQa0EMWmvECgqDUnlKVCvB853xHmQGnMl5+t0WF+76JmJi+qnl1EbMfReHPBxaTiWWSPL907YsYZuXGdZAagx1x8XF0nAtLhlzjRpK5RfJN0SY8DVHd7n4nsNTz21xfiPC6Xgc2jPFnCucv9CjP0joNF0yP8B6Dnv27CbOHHpr6/TWuyix1B2NxSWzKUprwtQQj2J838UTS5hmmCyDQGNwwFUMt4YoxyJhnEvaZp1W3SUzhkkT0wwcNjcTjOuwvNJnsuaSJBlpmCEGYpMgWuPWNKm4rK32aLcCjEnpaR8ZRMzqBEVKc7LBandIzXUYhSF1R+E5MOj18bXLyIKjFGIysIZ6zWd5tUfd9+mHGf2tF3ThqLh++S2gBrzfWnvXzgUi8hlyUXk5ZkREX0ZWLhS/X658XLn8f7bW/tdXMd+KioqKijc4P5Ki8uUSlc1mk9nZ2ddoNpdnYWHhRUWltZbz58+zvr7OwsLCZdepuL6Jooher/eSvVKDIOC2225jYmJifPvlEpWO43DHHXcwOTn5kutVVLyG3E9eNuW9PE9UAu/m0hTkq8kDxXbfx/NEpYgcAfYAp6y1LxCERb+MbwPfFpEngf+b/ETry+RitQP828tIyiaXL626Ufze+/wFxVzavLiorKioqKioqPgRZnH3InHYp+kHzO7dTZIZ7GiEZIbFo0cZdjfZPLfEkRtPELT/f/bePFiy677v+/zOuVvv7/VbZ1+wDECCJCRSViRZomhapc2SHEleGJVcrooZp+KUo/xhJ5VEleWPyJXNseVSpVylpRIppUo5JUuRaIk0JZoESEqkCIIgwAExwGAw29tf7323c07+OLffG5IzA9qkQGB0P1Wv+r27nnu6p4Hb3/5+vx0G27dpNDWqETOdFwRRxGw4QTCcPnuG2WjEdDjgkbddQhotsrKg3WqTp3PiKPQCnRJOnNhgMhwxnmaUbkpn/QS3XrnC9rVrLK32wYyJG13CZovxwT6qzFDioLmOMznKOZIA6C4T9NbJ0hEnl18jOtdhNEp4YWeKaIMW3+8YiDBzjqJ0VV+gd9B5l53cqc0dfUtrIfIVwJezkuyFZzncuspDXeFcPyEucsYvPscz//yQ8z/6Q5z7gb9K68wmr/zB0+xdHZGmxouNxlKyOK/yca1YtKjKOWiP+h5VJa7pyoXp3HFHZIAXJAPxsqQTMOKwIhR3qI/OOeydBsWj61m4J/EGRncsYd6pT3rxtvpTFr5HL5S5RVQsXo9bbOfwsatHh3L+bwtHYxU5jld1LCJd5ehYLARGvFtUqutXi55PqmOoSmSuol8NDuMqfbBSa72YV/VELpyN4qpQWaqoVn/cACECInE0lLCkYTlUtAMh1r4bVCvrI4OVoJ0QB9oLzIXx46s6SsX5eF5VzYfy+blQXUeQaIJmhMkLtBZcbjh44VXGV38N5QzT3PLyQc6nt2c8l1pulf7aVCUUL8avFF60FqEXeZGwFQYkkWY5CciNoTSK5SSkFTpOLiWIc7zy2ojhpIR2wlq/TztLGU8M6WiOKCF3mt5SyPmLp1jqb3DrtdeYzebgLMudmEgLRZnSCoU0aaBmKVG3hy4LjHW08pzclUQCe7OUWWaJQkVpBa0VOY4oiJlbR0cK4lgzGKWoKOFwd8RqN8HZ0s+jhqw0JEkIxpDZkHwyo9dLyA2kOiKWkCU9I5tPWdloMZoZVpKIsbFEAq3VDru3h9jMEDQigqr7dZ5BNxH2BzmlcYyyOc7AynL9Rfw3GYsPT+92z/4wcPDVImXFe+9zzAD4buATX7X8+6vHZ15nTH+Cf2v73tfZrqampqbmAeOBzI58vY7KM2fOfMtjM0+cOEGz2bzn+ps3b7Kzs/MGjqjmm0mapneN9b2TM2fO8Oijjx69FuM4ft1e1lOnTnHp0qVv+eu3puYOfq16/K9FpL9YKCIJ8At/huf9lerxvxGRo2+eiIgG/hf8f99++Y7l3y0id/t2yEb1OKsed6rf310Jk4v9Q+Cf4IXMr+YyPgbnJ0Rk/Y59GsA//be8rpqampqampoHiGI8oNeK6W+sMjrYZz44JAqE7uoah3v7zMZzTjz0KEYrRocD4mYT4zRZZlHKMdnfo9Vq0lteYTZLcQ7Wz1/ANToEUUSv18WZgiSKcdZSFiWtbpc0Lxnu7dJfWaLZ7XC4s83e3g4ra2v0V5c4dentEDe5/dIVsuEBvbU1ppMZh7sDJrv7qCLDFiVRu8tgZ4vxcMrmxTNcuHSK3moTpRwNDatJSDfShHIcjqoU+OTNO6NAFyKaQykfD5lXy3QlyF0rDZ/cP+TZ2yOeuz7hwAREnYh89zpf/r9/kxd+509ILn4f7/rgz/LI+x6l24+IAkWgFFpUFReq0LoSsxSIWB/nKf7Tc1W5EgMthGGA1lUPYuWi89Gj/jFUQqAqIVHckUjnL8Qdxa56sbMKO63yUp1bhJ/KkVIpC9lQqvHJsfdRsRAffcekiKviZjme16NtF0Lj0RH9BzsL6yWVk9Mdq6k+3nVxDqkcj+4o4lThvINQQygQ4SNaeyIsiaKthFg7QlXto4QAh3YOjSPAC5I+3lURIZWD0tEU6GrYDIUzkWI9ViyFQiuAWEOgVSVS+jmPIu3n3NpKAOXIvSniKtHSC5lSjTtUQtQMiFoxtigJkgCVhISJJopAyoJJaXlxP+MTt6f8aWq5UTpKvM6pHcSuev71QlivxGrnaEQB1jlCgVlpGJewnxZYY3jkVIfMGa5en3J7mFI2Q06tr9DOZowGYwajGUudgOX1JQhCHn3bo4wzYXljmQvv+ja6vRbdXgLOUhoHKmSUGeJml6DVJdQRTocUViitodeOGRcFaV6SliUSR6SFY2eaM5wZxkVBJApXGvKsIAgUg/GMiye7dJqaUALazRgdKOJQYxVkopkXhmYcYpwwJCCfWhqjA1qh4dSpZUaZIwLmzhE5Q6ebMBpOCSNN1GqilaKVCJPC0m6G6DjGGUcSa/LCgDh08DU5xzXfWg7x7xJn77LuVaAvIu+8c6GI/IfAD77OcX+hSjFa7NPHOzQBfvV+OzrndoDfAN4jIj9f3d9/BSLykIhceJ0x1NTU1NS8xXggHZXW2vuu/1a7KQGazSbr6+v+W5N3cd3duHGD7e1t3KLEveYtxdcjVJ4/f56HH3746O+vJ/r19OnTnD9/vn5N1LxpcM49LSK/iI9Q/aKI/Av8F+N/An/jc68OyW/0vJ8Ukf8J+Id3nHcK/DDwBPAU8D/fscs/BP6SiHwCuApMgLdX2x8C/7w6rhWRfwr8l8BzIvLb+M9q3gf0gT+qfr9zLIWI/BPg54FnROS38P99/QHgVvVTU1NTU1NT8+eQjdObBEnIaGefVrdD/9RphodDZoMBrVaMCVsYW1Jmc5RWlGUGRc5kOCGKhY1Tm6goZrB3QLfXIYwTRof79HpdiqLAFCUSaIoixxpDa7lPmuc4Y+ifOE2JACHT8YgTJ06xtNRERQ2uXb7Mwa0tmlFAf2OTNJ0y2ttl/URIq9FBNxLi9gZlWdBXwnw0ptc5wSQJefXaLpudBk2tGc9L5qXDYlDiCAIfcWrMV+hmXlhTPk6zrOx90ZHLz7suS+C2gdm8ZGDnTArLxdUm652QOJ1y+2P/msHVqzz0oz/Mxb/xd1h65KNc+d2n2XtthOQ+5tM6vPKkFs5Dwag7XI2uciBaU7kO3VHvo8I3TwrHsbXWQYGPjjXi//an+MpAVdzR4SuNy33FuuOgWKlESS90KhEfPVsNm8otuIhyde5YNFs4K63N55viAAAgAElEQVQ7dk6qyuGJW8SvyrGzsxrLQlutDuPPXx1WLZyYsnBBQuggFiEWQVcBsC2EAkfuhMKCsUctmwTiBcpFNKyuhOEYaGuhrYWOcrQDIVqIipULVwmV6xLCMCAKFK6k+hzEi5AL16aW6hz4cTnnEKUQsTT6DYwI5axAhdovN9a7awUGc8tz+xmf20v5QmY4qF6cDm8lW8y51n6OGkoTakdYuVKnecF6I0REsMYLqCuJ5tx6i2GaM5oUHBbguk1W202WydkazrEGwlAxb3SZDiY01rp86dqQF750nS9duclP/sQPcOk9386Ny5dx4zHMZpQSIlGD+WhEZ6mLyQpskSNpRiMSRpnjxu6E1VaCFcft3RnzMqXdaROHEZ0QQmswRUG7kTAYp/TaCQgkcUBalBRFQe4c03lBSyLCZkJEiCkzTBwSl5oll9JqhDS7ATcHKUlhUI2EcpJy5vQKN3aGhBLQbGjSzBFpyyxXxALthqbEsbTSZj+16EjRDCxpUX59b5w1bwjOuYmI/DHwvSLyG8CX8S7L3wH+d7wg+ZSI/D/4SNb34FOT/gXw0/c47G38P/8visjvAGG17Qngl5xzH/86hvafAo8A/wPwsyLyFLANnAQex3dXfgB/X19TU1NT84DwwAmVzrnX7ajs9/v3Xf9GcfHiRZRSd42q3dnZ4ctf/jLf//3fTxiG34LR1XwjpGnKeDy+53qtNefOnWNjY+No2dcT/bqxscGJEyfuu01NzbeA/wx/U/P3gL8L7AO/BfxXwLN/Vid1zv0XIvIM/kbmb+Fvgl7Gf1vzf3XO3VkS+0t4QfI78TdXAb4785eqba/dse3PA7vA36muZwh8pDruf3+P4fy3eCfmB4H/CN9x+Zv4vssXvsFLrampqampqXmLMskMbjSm22rSPXGO7e09WktLrG0mzKczIqWhSImSGK0DslK4cfUKymjOP3YRQ8j+zVusnDhJ1Goz3N+hs7rKdDSk0WwShDFZOiWbpgTNHrnTKAwozWh/SNTpsP/aywS2JGw75tOM2dYO2eEeq90mUW8FGzQxs13WT2zSbIbo1hI27mKcI2q20QKtXp9r166zPTQsL7ewacHtHZhmhlYgZFbjcpjjfL8lXuxDwFkvWirEO8YQ9JHZrxL8qk5Di2PghGfSkrGxTIqS8/OEcysJLbHMr73IF395m4P3vp9HfvgH+faH385rH/oQNz5zheFBSlZU4pTz5xVRKCzWWi9GSTUoNFh71OtonbtD4BNK58icY26hWDgmnRfnDFXkqqtiYCuR0FWZrscu0kXH5ELUvMMlWfU3LgRHWaiQspiLxfLjhYJgAY3cOW1HXZWLDktXhcnCoivyDkcii799VOrCKaqrKFmNEAKh+LjWEHUc6Soa4xxG/DyUTmMW4quAxseBRkpIFDQFYi00tCLGEQWKUByBOEKtEByBUgRaEYWaMNCYvMRZiygv4mpR3u1Z9ZseOU9VFRMbK1be/gjz/Qlmf/9oLkzmo1IzK2xNSp7bnfHMuORKbhnYRbSYHM2JrVyu1gmxQEvjz60g0dBrJAyLktgaGoFiOVG0I82tvQlrrZCRtZRRyKXVDvPJnNuDnHlq2FgKsN0uV7dSIhymhCvPX+NwOCW0c1778gt01y8ihcViGaUZWiwoxcpKm0Y7wTVCppMAbQ3Wlezuj2jHAcaUbA/njNOSCxfX6S4vo8czVDljNExZX07YP5zSSBJMYcldyVQ0psiJoxA7zmjHAZJENFVIZA3TToewhF6Qo7VjaSlhlFo6WqMCxXQ65+zpZXYPZ7jc0FlpMp1lBIFmPMtxTghDYTQr6XYDbo9T0sK7aJ0rKcr6C9dvQn4W+MfAD+HFPwFuOOd+TUR+DH8P/DfwAuaf4L+0e5F7C5U58JeB/xH4m/hEoleAfwT84tczIOfcSETei7+v/g+AnwISvFj5EvCf4+/Pa2pqamoeIB44oRKgLO//La2VlZU3aCT358KFC/cUKsuy5JOf/CQf+MAH3jTCas3Xz+s5KpvNJk888cRXiNBRFN03DjgMQ86dO/e6YmZNzRuN87bwf1b9fDXnv2rbX+M4LvbO5ee/etkd6/47vOB3t3W/iRcEX2+MHwY+/HrbVduWwP9W/Xw1f7v6+ep9HP7m6x/dZZ/zd9n+17jLPNTU1NTU1NQ8WKTjMd1+n8bqCvvbWwRJh3Z/mdKUNFodcIrCCaPDXW6/cp3hYEB3qcn5Rx7CpHNMMeTs2x7HBRHWwubj306ZjZlJQu6gLFK00rT6K+TGYIucPMuYlyXNXo+dV19FpWPWzp0hnc8p05JQHOvvfBd56RgfHqAmByRa0T9zmuk0wwQBnXYCCLYsiZod79gc72GnUx56+6OcOrlH+dlX2BpN6SQBVoTcOuaFJVy4GXGU1n+6rQSc9WlBC+HMOW/zk4VoVyl0FkcuipcKx9jmjMuS0bzg7GqL9UaIzgZc/71/yeFLV3j0J3+Ic3/9b7P5XS/wyr/6Q259/gbzaYFYHy9rHFQnqRyUXpyyR/2NgohFicM5hcNhLeTOMTeQOTB3+CEtDot3Xh77Fu/ol+QOFyNevFSV1uijWheJSe4OMdILnkftHtUc3emMpHJW6qoo8ki+rDbxIqUg7ljldNV8Hnktqx1EfDzvYsSqEimDyh0ZA6FzhEoRyULWdYSBf56MPX7+hGNXpCBECKEWInE+AlZDgCPRCl1F6ioRRBxxEBKGQhiEYA1FVhwJqYrKnamqeOBqH997KWgtRJ2A5nqf8daY8uAApX20qLUFpVHMHFw9zHh2L+Xy3PBSYUmriXPVc+QNlNVrYjGrzpFoIcOLrp1QkRUlhQFjLb1I8dB6g+GkpBVoilCBTni4GVFOptzcmpJboRPDoNTYUUGsDY1Wg0bQYHd3i04zYLUdYDLL3ovPEktKJiFxI6Gcl0QuZz6fEmRNxCi0LUkl4GBvSDMKKCxcP5yTiXD2wiaNXpv8cESbnOlkzkqvyXSWs9puMs1zFI6tifVdtKFiPp3SbMRkyqJFE7mcoQ6JrbCsMuZpxtpam0HqcPM5/fVlbt884NRml0kBtshptWLGgyk2iJinOcotuk4VUQSjzKKccKIToHBMs5CsyL4J76o130ycc1eAH7vHut8Ffvcuqz7O69/T/73q537nfpWjr118zbqce3/GUFNTU1PzAPJACpWz2ey+6xuNu9WUvfEsHJX34hOf+ASDwYDl5eU66vMtxnw+Zzgc3nN9u93mySef/IplYRiSJMk992k2mzz++OP1a6GmpqampqampqbmLUJraQXdbPPqy68ShxENHXP18pdwWYnNc3a2D2mIQVzBZDbj1KkNuusblMbRXl1l5dF3cLh9m3KWMZtNSW/t8cqLl9ndGbC+3OHd73kn0ugiIoSqwBnDYDxExy1efu5Z2lHI5vnziFZESYl2IaUVRgeHHO4e0u20SNoRQaNFEcSI1TQaEdlgn6jZI2h1KYuc+WhEd3mVpeUVbNIm7i5zflSQl47r2xNG+Rwl0A0U1llSA3Pj3YaVDokShygvCjl3LKJZ551rpfNORS9rOJxSHCjFs3nJ0OSMMsPpbsLpfkwvcEyvfJ7P/eJV1t7z3Tz+kz/ME3//STae/le88vufYu/akDyD0hqcXZzTS3Y+OrTS/mwVm1pZE62DwsHcCqlzFOIoK7HS4tcrtXBUVu7FSlSUyhW6EBG9YOmVPsEhyu+zcAv6jstKLFR+DCLueH+vBsId4qbXJd2RIxPhyBWKA9HeSYosOjEXwqU7UgP8HHjx0Yt1yndOOt93ECnfRRiJ88Ii7qjbUylHeORKlePeTPHRJrES38HabpJPUgLlCJQmEOu7LcVHv8axZnm9Q5k5JoeTSjD0z02gFeKsP+dC3MX/rpRfHzYDwkbC5PbQ95AGi+fFEq31mVvFc5e3eGZnxuXMcsv45/XOW2nBC866qtvR+A7KduDPE4uiqyErLVEgLMcBSaSJFYymJRGOKTA3itONAJvNGc8MS4mi0Yg4yAyJVpiGYvPMJmEGn7l8gygULq4nvP/7nmCaaX8NS010mJDZGUEsjGaWxjij2ctpNlukLiTdGRDpgMLAOE1JkoCVjSWUbmD2puhiRhEqOs0GpijoNgIkgKAQyiQmTic0ek3294esdJqMM0MQhbQbmrEOIVOsBmOsKJY7IbnSmHTCymqX/YMJ/W7MIDPMxhmdRsRoYojihOF4TqcREAUh42lOO9GYUGEmOf1WBGIZp4ZJ7rDFvT//qqmpqampqfnzzQMpVN7NoXgnrVbrDRrJ/XnooYfuK1Rev36dz3zmM1y4cOENHFXNN4PZbMbh4eE91ydJ8jXPq9aaOI7v2VvabDa5dOnSN32sNTU1NTU1NTU1NTV/NsynY2689CLnzp8k6nYIm0Jkhel4wI1rt0maLXSgCcIGj144QxjHBElC3F2mc/Iin/3IR5iPB2RFytr6KrevvcrtW4esrXQ5eXKd8WTE9PaMRqNJ0kgYDw8o85LicMDZk2u0eysYMWjliHTMbF6QFoZAlfQS3yWnkyaZcTRbMUGkEdE0ek2yzDHe3SEOFYGCpbVVxocH7Lx2Ay2OONacWGuyvT8l0sJKEmCcY5ILhbGEWuGsozReoAKw1lUam6CUozJVklp7FAVrFURKIRaywpIijErDQWkZl4bBPOfMUpOTvQiVD9n+2IfY/cIXeegn/ioPve8D9N/5bm79649w7RMvsHd7gC19/6WtImlFCc54t5dZ2BLFUeLILcysIzVeOHVV56UXKd1RrKyt1i1chQvEVYLsUZYrRy5SZOHirCxErpL6xB5HsuJXLDoTj8s1Fyy8qu5Iq/RiaWWLBBbqoVQiKOIFSeWOD6kFtFM+9nXR+yiWUHw/ZSgQiu+alMoFGYiPQ7WAstUxlH8MxPdOavzvgTEoXa1TPmZWKwi1otkKaS13yFPLbH/so2UVKB8wWw3f+ehVEZSoSiQVAg0qBGct2WSOijRaB7i8wGroPX6Bm1nCx/7NZS4fzHkxs+wbH9d73EG6eM7ckXjqnBecG1qIA83MOJaDRWAx9BohhYWNVkASaMQWlEnILLM8shwSOseogOE4Z6MfYZOIzQSkFRN3enRCxedeucnQFJxaifmu9zxCY/Usu1++iY4CdBCiXEmYaGaTgnRaIrFlNjjkxMMXGL5y08erjnKmViAIWe+3meaCzoc0I0FpSxgEKGPotDRZYShzhcQNpoMxKgwYjlM2V9pM04IgjmknmqkxjOdwKswoq47RXAfMd4asLzc5HM6IowAbaGb7Y5aXm4zGBcYWDFNHf6lBFCcc7A2ItUOFAbM0px1pOt2A4dyxP86wJay19Tf4jlpTU1NTU1PzoPJACpWv11H5ZnFUnj17Fq3v/z9qv/Irv8JP/dRPEQQP5FP1wDKfz+8rVPZ6PTY3N79meZIkBEFAURRfsy6OY06dOvVNHWdNTU1NTU1NTU1NzZ8dg1u3eed3fgdWArI8IzAOgyJotDlx7gyT4Yj5NOfi2ZNY42M1l1fXUXGb55/6KK4wCI63Pfku3HzAFz+7T9RqcubRh7hw6WGmB/tInlKajDwtcEWBTWdcuPQoOJhNRjQbEVHSIs1SrJSE5IQ6YvmxJxiOxsyynEar6TsbnRB1Ogz397AuwNkSayyN/grZbIIONb12RGkca29/DKXg5EFGYYXDccpBFS3bDoWy9AGpYeBwViiqjkeNF++UKJxAWgmISpSP9KzEwNJZFv5Cg/CSMWzPHY8Zxzi3jOYRp1cb9HpCObrOi7/6f3Dj6Se49OM/yJm//h+z+b3Pc/2P/pCrH3+eg+0pZWVptM5yh47ohUTncJULNDWOEvFi5MJJicOKj5JduCmt3/kO5+RCaq2ESa8WfoUIeRQYK8diJSLeQejkDqFysUElgi5slgufpPNj8mm21TEXLtWqb1Oqskw5irlduCzvjGsF5bxjMqpESu+mFEQ5gsW2lQs1cP4qtHIECsIqzjVQQqgEjZBEGoWlu7FMPhujJcBZQyMJscZiC8vg1hDlbCWQSvWaoOq6dIgodOXYVAuhNAAVChIIKtC40oK1lKXBYLHdZZ7+0pRnL7/Ai/OCq2nJvHKXLhys4qp+SjnWdS2CEkcrEDpRxMhZ/5pXik6sCEVIC5iVJZMQ+ssNbg0t2gnv2GwRBbB1mHM4zglDjWl0aImFVkKsFEFZ8PzujFcOJvSSgO9+8iKZ0dx88TLj7QO0cmxePEOnv85LL7xIU8V0w4DRaMpknLNze5v+5hmu3t5nahUzW3JhfQnrDN0m6G5MnkOgNPPxnG4zhDDyDs/MMDwcopUmnc44s9FFlEJy737NrWFmQ/qRRbSiEShcHDAep/Q6CbuDjDgQnAoYDGZ0uyHDeUmeFWRKI0GEDRps7wyIsIStyIugSrG+3mSUG8ajGWUJipzO8tI35421pqampqam5oHjgVS/Xq+j8n49gG8k3W6XtbU1JpPJPbd5+umnef7553nXu971Bo6s5hvBWstgMLivYH769GmiKPqa5UmSEIbhXYXKKIruKm7W1NTU1NTU1NTU1Lw5eejJd7C3tc3e7R3OXDzL2FiK0lAUlnRegBPOXDjLeDQjCjX91Q22r1/nYOeA1BTMZnMeeceT3L7yCq99/k+5eP48m48/QX9zk8H2bfLZHKdCgjBgPh6jlHDhbW+nKFOm27fpLS0RxRGlE8SWkKWEWKJ2h72t24xGc5ZXVsgmE5L1TYJGi+logE6W2H/1KqtLCa2TJ7EOTGnAKDrdHiRtbm0dYHTE2VPLpLOcvChQSmgEmuujlNCB1ooUR2G8S1DUsRjnUJTGi5lOINFCEAhlYTEGDF7IEqmEQifs43gmNeyXjrGxDNKSE8tNNroxiSlIX/ocz/7iS1x753t45Md/kIf/1j/g9Ps/z2u///u88okvMdhPyc2ij9AjgHWKHEPmoHDi3ZR4MdLgBWQjVM7KRZTqHU7KhYvyKHJ1sXwhTh5HmC50RSrhVuxCMFxEk6qjzscjnbL62+uhixhYqRyetjqcHM3XUfBrdbJABFlE34ocuRYFKqHQkYgQ4qNfQ0UVhyqoynkYVe5JwRGpyjmpvKgaKiGoomLDKjTK5CXOgBODcpZ8nuOs8w7K6ryBUiixR3OokarD0h9fKSGMFM45dBwQdkJMCq4sQCAvLbkV9gx86Qu3eWmc83Jq2Sl8l6hTCxflsVtV8JG6qsqBtTgSpWhphcWgRWhrITd+jrX2+28mmjO9mLDdIB3mnG0oDqcp2dwwm5eYQJEstb2g3UiIS6DMeOraTbbmJWu9Fk+e6tBtt2n3+wz2h5hyGzQYNPu7O2xcOM+1yy+TFoa8cKw2NdPbu8ynsDvOSFoxl5aXsUVBWRQ0OiHjeUmAwWUlq8sNwJHPUqyD2SxjmlqCwLLabTLNSv9casXUlAS6yWZsUSKEzmKTmMHhlJWlJpNpTqhAxYprN/c5sdRgf2xpimFuDLlTNCPF9GBMQwzNRsRgmhELrK42meaO4d6EIrNoLOu9Flv783/Xt9KampqampqaB5wHTqh0znHlypX7bhPH8Rs0mvsjIjz88MNcvXr1ntvMZjN+/dd/nXe+8511N+FbBGMMW1tb91wvIqyurt513cJReTfW19ffNCJ7TU1NTU1NTU1NTc3rc7izjeQ5jz/5ONPZDGchm48xJcSB0Eh6pJMRzWZE2GxxuH2LMDBsrvUYDw542+PvYHpwm2C6x/v+/b+CDRqUZcng2isoZRAVoIKAYjpjudeht3GSyfAQV+T0N9ZwBibTkjABW1ra3SZWxehmQoLDNizFfMbKyTXmaQa6yWCQsfXCp7j02EWaKyeYZyGaOZg5cRxgSHjl8pfY391npb+MdBvEMZxb63Jzb8Ioy2gFmkAJg9JAFVO6iNv0VRdCaVzV7yheEBEocnMk4GnxApWt4lUVXswrHVwrLHvG8nBpGRWW/UnAyeUWq60AnU84/OzH+OPnv8D6e76Hiz/yfh79uz/P6fd/mmu//2Gufvoye7tzbGFxVsidj301olABiDU4Q+WerAQvHFYql6XzkbVwLFAu7tUXj2rRWekWkaPuSIzUolBHsazePeqdmV54XJTDeDehVPt7XBU7u3BoWgQr6iuiZn1xJV40FYU4dySCyqLz0vkoVlwlLi7clMr/HiqFwhEsuhu1eJelHC/zTkqFXnRZVmNV1iAK7HxWOSXdkTNStFRdk15w1dVHHEp5kRV3HJWrQ0UYa7RWlKV3OZZzbzsunKW0wrgQXh7mfOlwztXC8lpuSY3gRLA4ymo6xB2bUh1VhC+OALyL0Am59dL0SqiIdUBeOXkL5zjb0vRbIZkTJnsjOoEmnVsmWUZmDN12RNRIcMbQW+oSlxZtZjy7M+H6pGCpnfD4eoOVlRbldMqtWcZ0MuPkuRVa/RX2phmDvX16yYjlMODAOjrNkCiMODyccrAzZ21jma4YNBlzUagwZDLNaTWbTMYz2pH/nCubFzilKbMMG8cUsxlrzQQJArK8pNsIGM8zpNmmqy1xAKGy5CpiZ3tEv9dg73BGK1ToSDEYpKy2YoazkqaCMoIpAU0VU85ymq5kqRsxKUsERb8TEiQBw0lKkRkCYKUVkFpHXtSfadXU1NTU1NTcnQdOqDTG8PTTT993m3a7/QaN5vV57LHH+MhHPnLP9c45fvu3f5uf+7mfq2M/3yKUZcmtW7fuu83S0t0jT+I4vqtQKSJcuHChFqtrampqampqampq3kK0kpCl8+fY3xngxCLOkpeGtbVlhruHBOJYPnUSK5Z5VtLuL6GwzCdzTjz8GKaYEAQxp9/2Lg4PhmTZgFgbgjhhNi/JTEmn02Lz9Aaz4YjB9k3sfEa738dohbEWTIbLS0DQ3RXKWYqyEIQBrW6T1toJnAiDLOTaZ15kTR3w5Pd8BzpKGN94mZefuczSybOsPXQBExjm40M2T22yeXKdLC9AWx5721n2tg8ZzlP6eUmoFLemGVZ8XKjVDlf6INfCevFPKS/8eTeeYEov5znnUEphbCUtiRcrQ7xwCb5z8NA5Pp8ZtkrLxcIwmJec6jVY64T0WoIqD9n71IfYe+aP6T/57/Hwj/8Al/6Td3P2h5/h2oc/zJWnv8TB3gxlNPO0YJ5bckBrjcbhnK36KR1Wqo5KFoIkLETXo1jXIzel8+LgHU4+jRdqtfKuxRDvKASwd7gmF4Lmkf+v6sX0+/t5C9TCG+gFUa9JOu+edP78CyemOHvkUARX9TH68etKiAwXsa8aGuIIBQJxvhMSL0YG2rsmVeWwVAih+FhYESFQd8wDXoRUdwiUikUf5mK9O+ot1ZXQq/C9pVpDEGpU4AVHiQOEEpylLEsKK0xLx9a85PJ+ysuzkldLx56p/JKyEJd9LG5w5Gmt5qCKzlUISdWjWTpHKIp+FBErGBqDKH+Nl5Zilrohtw7naKcIIkVpHLnJfG9nEpI0YxrdgMZyH5nOCUzO9UnJ83tzeu0GT6zHXDy/Qhg2GI1n7B8esNQPufDOb+NgbHGDG/SVRaUj5rOcWDlQwuE0Z5oWLHWabC63yGZTZiMDIkxmGb2W75Bsh5rCWSaDGXESkU1SCHy/5omVDnOTUZSK9VbELM/Iwpgl5+dalKDaLYa3R6z0GjiBpoaoFbO7NaYRCrmxNLQQtmOubY/otlpk6Ywk0HQ6AVMHaS70GwGdqtfSlI4g0gTW0V/p8NrBDFk86TU1NTU1NTU1X8UDJ1RubW3x0ksv3XebN4ujEuAd73jH626zs7PD7/3e7/HBD36wFqreAryeoxKg1WrddfnrOSprampqampqampqat469DY22X3tKmnqQEfoAM498ggHt28SRBFLm+voIGQyGBA3GwRRhC1LVk+dYDZNCZWmt7GOUyGNZoSUA1TcJi0MRZqRxBErG2vksynT8QhtSvqnTkPSYDaeUU4nNJMAY7zYlo4naFGEcYPG8ilU0ubWrQFf+MTHGNy6xff/0PfRXz+LtZayKAk7HR77C48w29/nC3/0b1i+cJHT59YQW1KUlv2tVwhUg9XTp8mV4lFRyJV9DrYmIIpYabAOJZZMQ2HcUZyqq0Q0nMI6A1TdlUow1h1HvuLderYSKUvcUTdkhuOacezOHacLy8PGcWoWstaNObXZpuUMZAccfPr/46nPfJzV7/iLPPojf5lLH/wHXPyxy7z2sT/kpU9+ifLVQw6zOdZYcuOO+jR9V6XDVALfsZOSIxekkkqYdA5VSWLqqAty4bD0XY4hEIsjEt/FiYCxUsmNVEKtv25XnWghshkEZOHvPI7DpRImRY5DZhFbdTH64+pKptMoQuW8M7IaeyRCorybMlbeaRmiEOWF0FAJWikvyi2urxIcVRUFq0UdXacXL/04AuXF2YXhc9GHqUSBdT5WVbzDUmshDBQSBKhAoaIQUxSUWYmxjtw45hb20pIrg5RXJyWvlY7rpWNSPS/hQqSt5nARdyuu6r8U/wzp6rrjQJgWlk4gLIWKRihMSkMcaJYjxSPLISfW21zZHpGIJomE7WlJrBTWWXQrohMGhDG0V/pEpeVwmrMzy/j0jQFNLTx5psuZ08sQdbhx64DB3gFLJ7q0NzfZGzpMKQTzKaFYZoVB4Wh1EnYHMz/HgSaKQ9J0Qre/TD6fMzicEIYxg8mUTiMkbkYc7E9pNRoMhnOUdRSi6DQDrIPJPGCtGTHJCjKrWWnHdLRFiaOx1OLWjUO67RbD6YxIHFESsH84Ryv/b7YsClprPV69PWaj2yAtCsQ5YmWYFZZBCi0MS0sJw0mOyf0TEsYRnUhhtBArRbtTf55VU1NTU1NTc3ceOKHy05/+9Ot2VN5LCPpW8MQTT7zuNuPxmI9+9KP89E//NP1+/w0YVc03QlmWbG9v33O9iNBoNO66btFRebd96tjXmpqampqampqamrcWW6++TNJoIUqGuKAAACAASURBVNmMVr/L+plTXHvui0y29jn/7m9n+fF3cvvTf0h7qQOiSNpt8lIzODwkjAMaa5voQEiHQwBMkDBLM9LxlFaoCKKE0WDI4bWXSVyKCduUElEMDgisodVNfMQqik6vg81TVBDTPPEwZvkiz/zOr/LJD32Yb3v323jvB34U3exgjCUbH1DOZ7SWlxmZAFlt8kjcAR2jVIhBcMWQE2dOMS9ypuMZpYGgFbO+2mJrOMfgBaDCWPZzRebKo97HAO9oA0G5O3yEVRSqEo56Il0lFi4kjkXIqamiQrU4MoGXS8utac6FzHAhKxlZ4dGHTvKOv/lTLEVzvvB//l/sfOy3uf7UH7H25F/gkR/6Ac7/tb/Phb9yndee+hif+pcf50+f3faimPNjW4zXi5TH8a5KjnsnvcOQo27KRf+iVH2Ri/jXBCEWR0MgVqCVu6NH0i2KKP25jvoTq0BX53CWqpdSMJVI6YekqlmiSn11OFmIpZWrEe8cRCy6Gl8goJUQO2hqQWkfxRqId7iCJRCFVn75sWOyui5ZXCdH51pcv6pcklqr6vxe5dWVo06c8+sCIdCCaCFuhTRXuqTDFJsVlPMM6yylhZlx7M0trwwzXpuV3Cwd10vLwEIpi8ZOwVRzJjg0VCIyLCTk0jki7bs3HZCVhpZW9AJNoCAzjkaoUc6ymsDKUsSNwzm9MERsjrMhy4lif1wSJJpGFLO5HNA9vcF4kJEVOS/dHPLK4ZTV5QaXTrb43r/0bm5f3+ZwZ8DVm3vETeHE2hqjg5zJ9c/T72kSHZCWIdZZ4lBzME1xFozWBAQMBhnKGs5cOM/hJCeZpIxmGb12hHOag70pcdxkOpoTiDAVIQwiolCTodkMFWVZMAdOrCyR2AJbZrTXltg9mNJutRmMpmhn6C41GM8LsBrBIhjW13vc2J2y2W0gEbispNdQtJKInVFKK4DzJ5fInTAbTdAKRBTNxL8nHB7mGOeOIoxrampqampqar6aN49i903AOcdTTz1VxcG8NTh79iztdpvJZHLPbay1PPPMM3zhC1/gve99b+2qfJPz9Tgq7+XqvVf0K7y5Iotrampqampqampqal6fpNFlNp2zfOIcS5urPP/xj1FM5lz6ju8k2LzE7ovP01heRiUx3bV1dl+7wWhnh9OXHiPpLVFkOZPb25TWoIIIgpKwLIgSwaQzBrcydOhoBtZHwc6n2GuvsdpvECUBBBoJQ9pxgzCJkEaTsH+K6Sznud/7ZwR2wF/7wI+wfv4CJZq8MEwPDohDR3d1naxIyWdjslKzsXEKESHLC8SWxN0eZVkS5V523Dy5xtaNbTpLORc2W+idKaPMsj3NcM5WsZ9CIlTyhyNSYEqHqErmsz5C1VjHwmfonYpgZSHs+X1B0OJdc0a8VDV18MXCcL20PJQP2Z7CvrzAhcfPUiyvklhBj6fsf+Yj3P6TT9C88HbOve/7ePgv/jTvW91g7xd+mVduzSkLL6qUiP9ZRJUeZ4hWIs5x3KvmuKtS4/saFyJlJI5EoKEgUVUnp1NHoqd1Xvxz4o5Ev4VIS/UoWrDYyi0olYhZST93jAu82KmlioUVQTnnxUkA5T8I0niRMKoiTrXyca/KgcJWzkeHUr7rUh2NrbrGKvrVOUeg5KhbU2tBB5pKGaxicX3U70LU1KEiTgKCCHQjJOw0MQjZ3FHMchCLEcW4gL1pyfVJwbVJwVbpuGkde6WjAMpqjoNq7vOqPzSgihyuZO0Q7+INqw5O6wRxjlagWKriXrVAJw7QCpZCxcW1JoeTnMhpYnGkEnJrmGGcJYg0SafNcJaxcaLLmcffwSc+9qfceGmX6+OUdrdFO1Q8fGad1Y0Ntvcdl69fxYWaVrfH4ctbnOkqOq2IMIwgSLDzIVEg7I9KnFNYJYRKA4Z0nhMax5UvPMfZd7yb1w53WdWKdluzvTum125hiowgUBhTstRpgNZIqGkphZaQwQxOLSXEgaOYG1Y2lhkOc5IoYjqeE2hhrdvicDSjyAuUjpjlBaurCVvDjGaoaXcDXtuesBRHrPZjppOCtW7E+nKIaje4eWUPZUqCKCQOLd2VJa5tzRkeTFhZitgb399UUFNTU1NTU/PnlwdKqCzLkk996lNvGaFSREiShIcffpjPf/7z99325Zdf5umnn+a7vuu73lTRtTVfy9fTUXkvsfl+0a/dbvcbHltNTU1NTU1NTU1NzRvHweGApf4aBJrP/f4fEIhi48I5dne2aWcz2t0OEsY0V07x3B9/hmI84u3f8W6SpT7TvR1GW7fpLC8RL62wfeMGJk05e3aNvVevMp/PSJRG2YDhpETHTQKbEipLo9fB6YggbpKECiUBKmkQJB0m+9vsXnmBM6c7dHuniZY3mOc5gqWYHBCKo9HtMxkMsMagbEE7cugoIJ3OCZRGgialLcmmc8JGi6jfotnv44qMOAzQ2hGEms+/fOh7GbV37gWhkDsht45IKXBeHLNVr6PDgVtIXpVLr0o8VQhGFo45LwAeR3x6McxHysKBc4zyklcPDnj1qd/i/GcjNloR3VjothLaSw49z5i+/Fn++PLneOo31jn1rou86/3vYeX5K1x+aZ/bgxxTghWFc4YCh5NjTVCOKzTRzsejsnAzOirnIsQCIUJLOZKqj1NX8alavJDn5PiKF7eK6shlejw/iOCcYJz1y92xcHjnpyCLrsiF1KmU8v2PVQarFjlyVQYCgfKxqN7waL2wKAuBUaGqdeJc1Sfp51+k6ulU/iKUVPNgbHUtDsGilfbni4SoERA1Q8JOhIpibGbJB3NsUYASXKQYzh07k4xrg4wbs5I9I2xZy55xzKoLXbjzNFVMr3NVxKsfuG9ldSjnXZehQKQUGu/WbQZCpBWpKehGMe1QaGvf27jRi5jkhlYYMpwWjK1lMCmYFgbdCHh4o086mbK+0gIMuneSl177KLeGM1qNgJYyXDrRwQYRL1y+xWc+d5lhnrPaaRMPhpxebxK1IlSjgQ4CDoYHqCBhd3sfa4UwCoiSBGUKVOk4tdJgMC7Q85TRjSucfOgcs9u3mM6nbJ5Y5mB/RmkMzlmSJMSKI9CaUEFWZBSiWGlHaCWUWU67EzIYzgiVJk1LrClZbmkGk4yihFYzocgNS+2YwcSgrGH91DKvvDakoTSn1hLGswKnhW4S0Fxd5gvPb+FmJc0YjCvpLrfZHWRsbQ/paCErBZvVQmVNTU1NTU3N3XmghMorV67cN3LzzUgYhjzyyCOvK1Raa/mDP/gDfuZnfobz58+/MYOr+bfGOUeapuzt7f077X+v6Ffgnstrampqampqampqat6c9NdWmc8ytj77adZWlrE6YDSZceLMKUQrkm6PLMt5+U8/Ra+hOf1t30WQNJnu3mS2u0ezv0yhAm58+SVmwyHf/j3vYbg/QHf7LAcWk5ccziydtVXK4QFxp02zv0rc38Q6R6ADRDQqUEjcIU+nFLM5a2fPE7daSNjAiiZUCpPPaXaXIQgBIWiEiAlpNtZRSZfB3i5RGGHFC1lBHNJoxoxHY6JWl+FowIlHHqO9e4tGrDClcPogJdtzKFfS1IqdtCRUvkcwLQxaKawDcV6Mc3KHm9Ad9ys6oXJNcuTKc85VaamVVLeITq22sc5yaBzPmpyrecnZ+ZyzkWZtmNGKA5baEZ2lkCXnGBxu8/If3uDFMCFsx1x87AynpjNu3jrg5iDnMIXMCUbkSBx1wpHDUJSgcGh3LBIG+E7KhgiJcjRFESrf8yjiKqHSC4f+mpSPgXXuKDJWZHFNx+5FEJxTUMXkLq7fVlKlVC5CVbkMBQFnK9cqlei4iHl1hEpV8bVf5X6s+kKPuygX413E31brFCit0QqcdV6kFFddJ4ShJmwENPtNmmtt4qUlsknBbHtIvneIQlCBpow0g2nJ7WHOtUHKVmrYNY5tKxxYy9w4Sll0eVYCsfhXi6nGpKvoXOt83LHCUSqIqWJnnd+2FSkivKuyFwmtwNJPIgIldBsaUwnA07SgcIqre3PakabdTTjVb9HTlkmomVhNNjb8v7/5Ibb29un3GnS14/HTfSbGkW2NOLx6SCSOfq/LKeace2iVImwgZYnDMR5nBEA6z1hqNphO50RRSKDxPZ6hZn9/hhZIrePg1jYrmyfYSS2BSri+NSbPHFFgOLHWo3CWWWbQCkbTFKcUrUT5OOEiY3mtw+EwpdeMsGiyvGC1lzCbG2ZFTqsRkhcljUQzmeTYrGRts8PN3SnKOS7+/+y9SYxt2V2v+a1mt6c/JyJuxG3zZmsbyHzUe4mAQSFVITwoqWYGwaAkJkbACISQkYwRonEJISQEE4QRDLAoIQETBkWhwiUZyXq2n/1sk3Y6u5t5+2hPu/u91qrB3iduPpxOX3fp9GV/KWXEjbP2Prs5eZTnfvH7/S/20KMe+WqBrCt2njzg5RsnlEmJD9ROMg59CuVx+86cQMDurMfhScJepL57b7YdHR0dHR0d39c8UqLyC1/4AkmSfK8P45vC8zyefvrph1r72c9+li9+8YtcvXoVKeU33qDje8Ldu3cxxnxL275dorIsy2/nsDo6Ojo6Ojo6Ojo63mEWd+5R5zmXHruGFQ5jBZPJFGNrxjs7bJZnLA5PuPb0U8SzPWrjWB/dxaQbvEEfpKLezNFVwjM/9AMsjk9ZHx6zsz8mryNWeYGxJaIoCJSktgIVDRFeiKxrHAIdxqB9qjyjStf4viIaTzHWkWc5UkrqbI3vewjlYYWiSBKKpGY0nVFkG4r5grIsMcYSBT46UFjrsFIx3tuhzjP29vfQYYjne7jKkaQ1l1YFzgmO1hk3NyV9T5EYS1rbZtaia8Sd286jFGDctrK0SSI6BzXNAtWucTxIVLrzGYWcxy23icttW+vCOFbW8UZpuagNlz3Fblowjnx6vYB41CceGdJ1xmq+4pWjJSoO6Y1HPLsvmZ8lHC9zlklFbsFs51We5xgfzIhUrSTUAgIhiKQjlgJPuGYuZFuZSnuMUkrk+bzJJhHo2n21QUW2+rGxlQInG0mp2nmerq2Cle0S6x7UszYutKluFW2SUrb71qqtfG2TrbKVltu5l2+eNynb81VSIUSzRrimoFY6i7ASYS1SSpRyhLHEjz16eyOcVujeiCp3rF46xqzXCCmwQpJbmK8q7q8Kbi0r7heGY2s5s3BkHZltnnd73xGiEcKtzK3bG769FkaAdO2Lg+Y1c95otL3+7T6noWLgK6ahIvYltrYoLBLJOisRUpFXlnE/pFKOSxfG7IaO48wQRzFJUVHVmiy7xRP7fQae4ODiHjfvHPG+916iwKe8f0ZZGR4fOJ559j2sE8OgN8AkKeVmhakKUBpZFSAdUS9E+s38UOck89OUKPQpqpKep+jFAbdefIlrzzzJ5z7zAkfzHN9ThHFILRx5Bb6EVZJhpCIKIoRqXm1BP2CVOfqBIowjlouE0aBPul6z3BT4vkealfRCSV5ZjHH0+z6LpMTmhitTn3g25MYbC+qs4JmnZrx284TjwzmycsjAQ0kYzPq8emtJvs556sqQo2WOKSv2Lo++3bfUjo6Ojo6OjkeUR0pUfulLX/q+E5W+7/O+970PKSXWvv1o8SzL+Nu//Vve//73d/Wv72Ju3br1LW/7djMq0zT9lvfb0dHR0dHR0dHR0fHOo5Vm9/plyqqZ2+Ypn7IomOwfgAJTZFx87HGC6QWKLCU7O8FTglxqjJNEStGfzBgdXGJ9doZJVuxe3EP7ktJO6JHgmSN8BUaEGKcZTEe4MsMh8YcTisJg0zXOVfjxAOWFlFWJsxbhLCbbEMQ9jHHYMsdUBleV9Mdjlsf3yc6OsU4SjkZoTyJdRTJP0J4kX2WEV6YEocbpATII0UGIrQvSLKPImvmUx0lOoCR5XSOcI1ZNNacVEmtMkwa027mLjRzTbTLuzVWvTdLyQaqy+QTdpuzaWZbufF5joym3KtE6xxzBonLcqiv2SsPlwjTC0veJY584jNifKrKkZLPJWd5NOEUhfJ/xIOZgItmkOZusJi9rjBU421bWbtOV7fH5ajuXUhCIpgZWSYGWshGcrsn8iTaCKdoe2e20R+UJbO3OU5TQ2jnnsA50a24fnG8jSNsL2CYzmxmashWWklaWyvYay+3sSNnO23RNdWo7exOatbhm9qQUql0jcdY1c0elQGmJxBINQryhz/DShHhvQl0rikKw+OoN7OZ1BGBwVA6SvOYsMxwmNXfTiqOyScCeWFhYR+5a6dhKymbeZ3N9tYOyFdRSiFauNo81mT1xPutTCfDaWaCaB/M5BxqmvmKnp+mFCiHB8xWer1gkFVlhOckrBlogNTx5ZQ9fOM6qmp3dCXlWs8lKpLLsjXqEUqAUnK03PPH0BVQUUcxTfE9xEFt+9H/5MWywQ/HKVzF5Sp2XjXD1JBiDUw4jfUye43RALwhZJDm9yMNUNb7vMxlokrQgjgJu3TwmrZo5o5GWDHseRihyW6ONxVgIegGBr9C2JvAlp5uSUeRjhOb0ZEUgLaI2VFbRjwNMVTMeB9RGUaQZoSdZpQVoj4EvGe6M+PLLc6rVmqeujjleVJzdXzRzWDX4Hly9NORwVXB6lnBpHJDVhiotuDgLWHzH32E7Ojo6Ojo6HhUeGVGZpilf/epXKYrie30o3xRSSq5du8b+/v43nGsI8A//8A/8zu/8DtevX38Hjq7jW+H111//lrd9O1G5Xq+/5f12dHR0dHR0dHR0dLzzjHcnVLapSi0Kg9Il4XBEBcgiZ+faY9TOI1vOcdkSoTQlDlMbeuM+8XBEXcPi+B4uXTHZmVILRY4GWRP6PtH+PkUBdbJiZ/8qnucjlMQfzMiWJ2AtUmu030eHPYpkjZASW9W4uiaIe1SVwVmDcBZPOQwBt196kUHPY3V6jO7v0MOihMbUNTiL1xuRLpfUtaR/6TpVluGEoKrAqhHDyZTaQF1bnqkM+Y1T8trhbFPXWeJAOAogtQ8SchKQrYxzNIJPCNiW1mzTiOczGd9Ut7r91V/R1noK16QHLeDEueokcfBqbbhdGyaF5EDXXMwKZr6mH4X0eorxtM/+lYgLP/ReXvn057h9a86ibipvx5FHb6eHVo4qL6kqS5ZX1LVFIgh9RSBA1hZpHVqItplWnlemQjvjERBCtrJSnp+ZcA/mRG6zm669AG47INOBk65Vck3CUcrm+gr3oJ5VtDW1kkamKdFUtgrRiFPZzsbc1ss227QpynYHUkiUcHiqWev5GhQEsWZwMGZ05QLeeEplNJu7Sw5fOqQ4PUXUFusslYXKORZZzUlWcX9TcT83LIzjzMGxhZVz1LapsW2k63lWFitAOYeHoG4lJdv6WUQzExSBYVurC8YKhHVo3QhLJSTSOWaRZOYrro09RqOI40XBNFAkleP1+ymFg8oKfOFQvuLxC0OsNazrmqeu7aGs5Hi+odfTDOKQoahYFIJ1VfL0ey+heyM26zXOVOzpmgvXdlhvMkRyhHAGWVusLcFUBKFHRYXWmrI2SKURFk7PlghnyfOCnu8RBorluqAfSw4XGSwKdi8M6IsYZy2bwpCvM3QvRguPsXKIAHQcQVlSSI0fgNKCNMkJfEWW5lihUb5HlZf0I40XBqwP14TaUUrIUvDqioNru7xxtOHs6IzHdiM2WcX94zOM8NDCIaVldydiic8bd44YBppwHHHz3pILkcQbxPy3r57yv39H32E7Ojo6Ojo6HhUeGVF569Yt7t27970+jG8aIQQ7Ozs88cQTDyUq0zTlL/7iL/jd3/3dd+DoOr4Vvhui0jn3fZcW7ujo6Ojo6Ojo6PiPznydMBz2qfKMurSo0RhrHdrVDPcvkW4yFrdvEvoWKzyMEihp0H5MGPdZni4oN0uy+QmXn3oPzhNsTpbEoSX0wLiQ0jiEXzCbXSEej7B1htfb5eilL+H5PtFwRBBF4DeSUmmPKtvg8oRgNKbKMoRrFJ/yA6qyxFZrLl7apcgrBoMY5/v4SpBnOQ4Y7l8iW87ZufY4stenLnOEdBRpQrU+QzmHDcbEQ8toumawKnhiv0azJilrkspQGEdmLaUQ+BrKGjzRCCLjHLIVdVKAtZzPSoSm9hQ4n1G5nUwp2mThefquvQ9WNPJLw7nwk05QAfet5aS0vFoZ9vOKg7RkZ62Y9AIuDq5gw/fw9PMhsfcZVqcrNnlFVRk2JyVoRX8cMRsH7B6MGPQUF568zrUf/p+orWL51S9y+sprzG8ecnp3TpkbnHHgJMJu5y02/9hWU1rEeVa0mVEpsO5NqVEpzpOl5xayvR5CyjaP+aBethGgzYzGbapTtqlO3S7aVsEK2UhT4UAriRZNp6pu04LBIGRwMMTrhYyvXcSbznCqx+Yk4eS1Q5LPv4zZzFEYjIDaQZYb0tqyrizHac3dpGJlHIvacWIdp9axdlDTpCG38z+da6pqpWvqgD0EGoFpXw/bilzhmvmlygmscE2i0m5fLLY5b7kt57XsBJqJJzjoKcaTiJvHGZ6Ds0xyvClxSJKyJpSC8chn0u+zzmpUD56+vo8sDbdPzji4OMNUhp6rEVayoeDylX02qxqzXoCpCauKvUsjBrM9rj77X1gvEuqspEjvo6TAG4RkWY51gjDyqUpLkRakScooDpgvM7SWhL6iKkv6sSbJKiKtMMKwN4ywzjA/3VBWJdbTOM+jpxzOVizLmqvXL7O6fQeRr+mFPmVt8HzFOsmxtcTzFHlW0ev7CK04PlwRKnC+IskswlieuDJmmZWs5xk7PU3YCzg5STlJHJ5n8F3FwTjAhD5ffvEIz9RcfWzCy4drBtIyng744u0181X9HXhX7ejo6Ojo6HgUeWRE5c2bN7l///5DrX23pS53dnZ4/PHH+eQnP/lQ6//u7/6OX/mVX2E2m32Xj6zjW+HmzZvfcM3Xmzf5djMqH0Zkd3R0dHR0dHR0dHS8e1C2piwKPC0wQoMUjMY9xpcfY3Fyl+XN1wjCHmXp8PoRvoRikzE52OX08BhTFQyigP1nn6Moa05u3UEEIdpTCDy0p4miuKmt9AK83giHT5kmDGdjJJJgOqE2gjpZobWHrXK0p5DxLmWeYooMYWqEpyiLCpuleIFPXVcozyceDqitwokmtRlM9gHBcHcfFfWQXoBDUKyXCFeiqXjlhRfpD2I87fACQeQr9qYRF/cG3Lh1wsmq5GhdUBWOSEgcBqkgb+VdIyUFQm4Tfm3csplW2HwVrpWObfquRbpGbm39XdXWn+p2niVua/WaxJ5yjRbcOHjNOm7VNf2yZjeruLj6IuMvf4VpL8bTNZFUDCONCx1COqqiIl+mzOcpJ7fmOCXZuQG3jy5z8OyPsv/8/8x//j/28cpbZK/+V9I7b7B89RXWd09YH83J5hnpuqDIKpwTTc2rEzhUc262FZnOIaXEWMBuZzU2p2Id7fzJVmy2f97WwQoh8KRsEpFaoIVAyEaKNnMQG4mplQLpkAqCSOFHHvEoJtrpE+1OCaczgtkuhQnY3FuyON2w+vLrpPePkEWCqStM7ahwFMaxqQyL3LLIDSdFzbJ2rAzMrWVhBUtnKZ2gaiUtAgy0srY5F+EacanaWtcaMK2gFTRzKZ1ok5QCNA8SpBaDlhIloXaCWApmXjOPMvQVm8px91aKqA3KV9w82zBQCpwlknBpEhNFAfc3a3ZmPR6/sodvLEeLFfEgJFSCURgwX1Qk1jKbTtBKcZisCYsKXziGE4/e7gErE/CZ//tfmE1iTGUwDoQpKYxDCA+oqYxFWYsrDZ6CytUMxz2qNCfLcob9mKQocUJhPMmsH1PVhvkiw1aOXChSAvZrC8JwmllyYHn3DhqD50HdRpbLyiG0QhhBllXEgaI3iDk8XhN6Euf7vHxvSejgB5/YpUCwWaUMfYiimHtHG9aZYRBqlBQM/IDZ1QlfemWBtpbrF0fcTyu80nBxf8DGwNFpiu+r7+bbbUdHR0dHR8f3MY+EqHTOcevWrYcWle+2ZNpoNOKpp57C9/2vK7DezO3bt/mnf/onfu7nfu4dOLqOb5ZvJCqdc2w2m7d8LAgCPM97y21effXV898q7ejo6Ojo6Ojo6Oh49+P5AbWxqCgmjgSj3T36+9c4vX+X5Z1bDMcTTk5WTA4OMLVFKsn06lWSdcL6bM5sZ8zw4DKnJ8ek81PKpGDs+WgvRPgKKZoqUR0EBL0BFkVydorvewipCHeukm7WFOs5YRxRlylCKmQ8pq5yqjxHOoeTGqSPKBZ4nocxDil9ZAD0+7ispiorbG04vXOPYDhGOkmdFuieT11kWGMIBnsE/SHvk4aTo4Tx5cs89p9/hNnnPsPR4QpFzWQW8cUvvEFZGQoLgXUEEha1QbcGTsht4edWKjb/sm+e18i28rWxVsLRpDDP14ORbS1oK/csW7nZsBWcgmYeIkDpYN4KtRtVxUBV7GYZe0ow1pKBlHhK4WlBFGj6fQ3OIh1UdYW99yo377zOvf/n/yLqDdHDA6LdPQ7ec5XhwUUG73mCp/7XMb4usPkKs55jkhXZ2YLk+JTN3RM28xX5MqXOK1ztqI0BKykKg6sNzjVVscY5jBNosfWuDypchRBI6ZBC4WmJVA5PS5RSeIFAewodSLwwwB9E9HaGBOMh3miEPxzjZEiRGopNI2MPv3RIdfIKJtlQZxm2qqiNwVhHbixZ7chqx6asOS0sZ4VhYxxrA2vb1LsurW1mT9IkHC0O2yY+Gw8tMW32sUlXgnYCIRx2m6B80+xRuX01OCi3NbrtDdVCEm1rcgX0tSDSMAoEg1Bze1WR1xUVcJqU+EKQCcfYk8z6Pga4nyRcubzDhWGEV9bkpsLvx4yHEX3P4+XbJzhPcGF3ii8cJ/OMHVMyngaUnkc0ijlZrtmcHTP2Cmq/pCotypZUFsqixg8kQkiyvMDWljASrGpJ6IcopZs1ChbrnMhrZqwOfME8KTi9vWQ08BGBxnox/bzGMyV3AMAtPgAAIABJREFU1iUGxaVZD5Vv0Bo2eY30PUyRI3SAEB5+aIlCTdwLODlZIazBKMWN2ysCCU9dHrC2lsVZTiQdo0mPxTLBWEHoazzhiCPNhYsDbh4XlJuCqzsxCZaT+2uuT0J6kx63byd4Up8ngzs6Ojo6Ojo6/j2PhKjMsoxXX32VNE0fav3Xk0TfK7TW/PAP/zD7+/sPlcZLkoSPf/zjvP/972c6nXbi6l2EtZY7d+58w3VvJyqVeuvfMjw7O2M+nzOdTr+tY+zo6Ojo6Ojo6OjoeGcoywJjBf1hj52DA9Rgl+XRfZZ33iAajTk9XdEfz1icnBL3Y4LemON7RxzeuMHVJ55gcHCJr3zhBaoiYaANPWUQLsLpCKUVmAqpPILJJcCSn9xDCoPnhchwSpGtKDenhFEPJSU67FNbQW1q0uN71GXBYDKiTBNckuEFAQgFxpCnKdFwSjQLEIsFZV4wmMYsX7lDluT4/QF+3GczP8VWFcFghFAaTED/8jP4oxPwRtTGMts/YLPcEMW7VFXFs+8zmH+7gxI5m8JyVDg0AidBC6gcbOtc5bYa1TYy0rkHaTohmkRhO76yrT1tMG3qTm7dSBu122pO2e7Hiu0zNTRCs3m8FHBkHKfGccPBwHOMhWGqakZKMMxLQinQUhB4Ck8pQk/hS4snamR1hjk6YXMEr3xZof0AqT10b0gwHjPc2yUcRvijPsO9J+n/0H9h+mMa37dIVyPqEkyONTU2X1OtU8r1mipNmgRmXVOXFSavcMZgnUH7PjrwaKpwBVJrlKfw4gClQ3S/hxfHCC/ESYUpHEVWUSwLNquU4tUl6emLFKcrTLJG1iXGVNSVwWExDoraUhjHurSsS8uqNKwqR2IcmYG1taysY24dGwslUAHCNclHR5OElK6dJbq9D216VrX3VNMIV0dT77qdxinaOKndCmnRpi5Fsz/pBJ5q7qmHoKcUE08yCppE7KK0bPIaTwtWlUMIiackkZagIDOOzLM8eX2H/X4Pl+ZsrMEf9NmPJGGg+cqNQwoB12Y7hIEiSUpGJieKFCsDg1GM7w9QZcZ0qomnO2AFUZ6ymheUtUU6Q1WVzStXSawTaC3ohx5FYdFpwtCX5EVTW3tvWTGIQ9alo6gEy8IgtKEX9xhIjR8YsrLEOcmFcYizFqUhySx1LXBVSm80ACNwNkdYy2g6ZrVYM+hFbPKKs7Ml2oPxrE85GHNy9xRd1cTTHkebijSzOGsYDkOU9NibBtxflSwP11zoawZDnxdvLbkyDtjbj7i3zDk7S4k8QVV1orKjo6Ojo6PjrXkkROVqteKll1566PUPm7x8J/nxH/9xfuRHfoTbt29jrX3btc45PvWpT/HXf/3X/MIv/AJhGL5DR9nxjVgsFg9VLbxcLt/y557nvWWiEiDPc27dutWJyo6Ojo6Ojo6Ojo7vE5TyGE4H7D/+BGlhyA6PIF8gtCLNUvrjIbdfe53J3gwvCDk5vI/JM5569geQYZ/P/r//QhQo9vZG9D3NxvhElx7DUUOZI5zGH08o1iuKzRngGOzsYqwg2axxZY4XxkjdJCaTzQZMjRDgRz7hcEi+XlDMj7D49OQEISvyJCVZp3jRgLIoyRZLikqyd+0q/dMFxWaJvHqVzfyUwBPM79+jSEvGsz4qHhD0Z3i9HfLVCQiDDIc89oPPsj4+YlLO8J3gPznHrTsLPv3SCYGSSASlNRS1w9Ak6qQTWNFUViohkBLsuVl0ONeITMn5j5oZhu3MRVybvWtll3SNhFQ8SFW++dd+twJN0aQT6zetKYEjA/edQ9eWPjBRMJKSiRIMCkMgIVYSXwl8JfCEINCSSAk8CVWVoaoMk62oz+6SvdaIU2MdKggJ4hihPPwoxPkBUvmoOCQcDoimA4JBj2AwxZ9JpFIo4fCFw9QWW1WNpNMaC7jaYCtDVdekeQZzS71OKDYLTBPnQ5gMk+dUSYHNU4QzOOuobH0ulWrryGtHUpkmMVkb1pVlXTly48itILWWjYPEORILmYMER21BtTM2pWhlo5A4Z/FskwS1Dup21ui2xndbASsQrcBs7gdsZbQ7r4jFNaJRimYGqZQCXzavCx/BQAsmoWYvVpRVxfHaYgyMIo/MOsq6xlcS5UlGsSZWkqjnMZkNuDbp4ztHoRxxP2YaQe0sb9w6xI88ru6NiUOPe6c5M1mi94bcuX/GOFYUWcbB7ohLz/4Am9ywXq6x6w1JmgHgexIrBEXt8D0HKqYyKb72KNcFHo4w9MjSDCE1m7IgDDSFg8VpwuzCHnHtKIXlicmQNMswSc60HzPsCdZpQeRrCiEJVJMdLiuLNTW+UHixTz/qsV7lhMqReRHreU6gBMb3uHOSMdrdpdfzGYR9ThY5WWbIC4sWgrI0XD7ocXddsTpJmMSaC7s9Xrib0hOCy/sReRhw/8YJwjlCCZ7ufsm+o6Ojo6Oj4615JETler3m9ddff+j138zad4rxeMyHP/xhFosFn/jEJzDGvO36+XzOH//xH7Ozs8MHPvABPM/rkpXvAubzeTNX5G1wznH79u23fEwIQb/fb35r9N/tJ0kSXnjhBZ577rnv2PF2dHR0dHR0dHR0dHz3mOxNmFx7ivnpGYevvsZw2EeEAeF4RplXvPqlr7BzsI8X+Ny7dQtnSi5eexwR9PjsJ/4/enHAY9f2cOWa+cri9/tk8wXTi/t4okJGYyprcK4gGsR40ZA8y9jMT/H9AE9rpFI4JPn6FOEsfhShwh7WSo5vvsqo7+OiiKoW+P0+CENdrIgjjdICX0eEe2PSTQFCsv/0e3HegOTsmMDTFIVhMB2wOjkkjxXjvetYpanWS/zBDlmypH9wiXv/9mV00Gey6wh8hQ0iTlc1e8Mlw8KS5TXHucUIRx8wpqkGNcI1KcpttacARJOwbGYwglJgTSMWZVsjuk1JGmjnOTapzXOpyXamY7MPQzsbsf1qhEPSVJE6GplmME1yz0Iu4F4Nh8LhW4fvHD0BAykZCEFfQSwFoYBASrQCTwp82daSehAogZauEbBVil1mKCGoFgKl2uynE2xwSKkAifQ0QqvmPNX2+N80sBIwdYVk+5my+ZlqT0zI7YxLixMS6xxl7bBYKtN8n9WGtLJUBja1IalppKRxZK4Rkbl1ZEDqIHeQWXeehHVCNvdCbGeIPkiq0gpE2d5LsZ0r6ZoZk9DMDRXtDNLt/bO4VjSLJn0rGqkpBVjXJCqVBB/w2urbgRaMfUnowWFWE+MYR5pEwLys2bgmDet78NSlEZM4pCgrptOIy6FE1YZVUtGPPXztOElKyrxEeIrRoEcgHIfHKV6ekPuCo0XJYDDE95rXbTDs0b/yDOZ0xfr0yyRJQp2VYAr8wGNZaOqiQvnN60ypgHSdEWqHLxWbJKMuDVBxYRaTlIblImfS9/BcTqgMO8OQ06NjxqOYwf6ANK+xRU0kAFsziGKU1tSrnMhTiKqksLB3ccxikaCosHHA61+5x8hXeJ7P6SYhMxIR9CB03Dk9ozaGoqiwSCJfcHmvz7J2zI/XRJ5idxbx2iKnWuY88dQQPelz48UzyqwiUIrcGvxOVHZ0dHR0dHR8HR4JUZll2TeVkvzMZz5Dmqb0er3v4lF98zz33HP8yZ/8CR/72Mf4+Mc//g3P6caNG/zmb/4mp6en/OIv/uLXTeJ1vHMsFotvKCoB7t27R5ZlRFH0NY8NBgOklF8jqzebDZ/73Of42Z/92U5Kd3R0vCXXhpKX/s//7Xt9GB0dHR0dHR0t0ewSh6+/yvyNG+xcuoiK+1iluP/KqxTpmutPP0blLPnyhMDU7F1/jLJ23PjS5xhEPvuX9/GCEPo9JgNDNNrBj2P8MKI0PnWSoSQEUQ+hI86O7mOrnDD0wVqQjYiq0xTPj/HjqEnMlTWruzeIgwjnxVivYjDqYxEgQlQ4Ai1QfogUjkrFVCYn9iOk7pEtzqiSlKSoUK3IE9ZQrlNsXWOzJToaIT0PmZfkizmjoeD0/hl+PMQbelR3jphNIn70P13h9N6Cl26vSCqDLzSJMeQ4irZsaFvp2obqcA6kbOSbBKwEY0C1sy2t3U6ybCRY7Rpx1VSGNjMRoZFfAmhDl03laCvIFAInbDM3s41rek4gXSv9tlM0HZTWUSFYG8c9Z9GykZSBgJ4QxMISS0eEJJTgyyZt6YvmmCWOQKnmfEQjM30t8aRsqlClRUmDQiLKopGNrkmYKinaWaUGY8G6RlBaC0iLMY3s3KZKK+soa0vtHKWDtHKUxmKdozBN7WllLZUTVDQzOzPnyJwgd7BxltIJStuIR9fef9teEuEkbpugbO+daa+Xc+C77ZUTGOvO75IQ20rf9u44gWtF5/b+OAGeA9tKa+ccTjR1wVo6tALjBL5zjD3FwBMEniQrDcLBINakNSTWsa4FUgq0lgwjTT+OWCYJVw+mXAglk0mPxXyDp2C5yjG+j+8MOvYYD3r4OuBsnTLB4PohN47W+J6HbyzxtMdpVvH63TmJ+SJ7OwM2yxWeMXihoio8yrL5vC96PkdpzU5QI/IcawxR6JMbgbGG/jDAU1D7AeuzORcmYSNvlaQ/65GVhjorGF2aUeqYbH6L2STmZJETKNCBx8lpApUlCCV5aplOIxaLDYE0hLMBL7x2xjjykVXOPKkJQsXVIOL0pdfJipKTVUEceBgBgTQ8eWVCqX1ObhwRasnFScStTUV6kvJD1waIvs+XXpyzmKeEWuJpQWkE2vO/c2+uHR3fBt3n5o6Ojo53H4+EqCyKgvl8/tDrb9y4wV/91V/xS7/0SwDvKunzzDPP8JGPfISf/Mmf5A/+4A/45Cc/SV3XX3f9jRs3+O3f/m1OT0/50Ic+RBiG76rz+Y/GwyQqoUlH3rx5k2eeeeZrHpvNZm8pKsuy5KWXXuL09JSdnZ3v2DF3dHR0dHR0dHR0dHx3OL35Bvn6mNnV69gwIlmllOslnrKML18mSUvqomAy7tObzkiqmjJbMdvdJasM0yvXAIHyfMIgwI+HSE+TpwnFZoWwjni2gzWGxZ2voqQg7vdxWIRSWCfRUhLEEUJKrDEkizlUGb3hCItGUGM2cwrloXXdpNfqplZWuhpTliglCXohpi6wRuBHPUwyx2UbrIYySfGjiGKTsbh3m+nlKwg/Jj07RNQpw90rFJGPUJo8KUk2OZP9PaLxGFsXTKdnWHcTheNwVTSyTUtsZZACqlaK1cIhZSO2dCu2ahzGgFaNvLP2gTxrNdd5Us9uE5jt/RGtFHM41LmQFK283Aq+dtYlAkmT8mx3ff48ym3Ti6JJdzrYGMcawSm2EXRKoJzFE7QpS4iEIBaOQAhCYfCFOD8+T9Tn8xillE2KkCZ9KdpMqAOkcCghkU18EWMtlbXYdr1zrpGHwmFccy0ra6kRlM5hrMA6gRWOopWSuXPkQOKgpElKmjd9zpVtRWsjElsl7LZJzeaqmPaa4ZpkZS0e1LU216zdVxORRWzvQbvdVlKKxn4iXFMFLLclsaI5PyUEnmy+0u6p7wkmoSRUEosklo69vsemdGTGsbHNQWlP4SmJEoKirLl6MGMWCKxxHB6u8AJBLSQ29tnpBVhhsdojiCOSZcGoKnBacrwpiOOQunQsNinv+/FnWb5ym+psQ7L875xsLhL5mrqo0VpQ1YrFMgcFZwlc6ClMnuGp5v6leUVtHH7gE4YBaV5xdnfO3rTHYpPjaUnka7LSURcle7OI08WK2X7MZDbm/tkS3zbp6Tv3l2gBw3FMuinpx5LaCVSVMbo45rV7KWVWMhKCpYPMws4gIrKCdZEgrWUUCvpxc62u7niYuMerXzlCWNgfR9xaZxydFPzQhZhUWl57bYmtHZ6zjOKI43WGkD5JWX0H3107Ojo6Ojo6HiUeCVGplCIMQ5Ikeaj1RVHw+7//+/T7fX76p3/6XSX3hBAMh0N+6qd+iueff54PfvCD/P3f//3bbnN2dsYf/dEfkaYpH/rQh5hOp++a8/mPxsOKyvV6zWc/+9m3FJXT6RSlFFX1tf8T/9prr/Hyyy93orKjo6Ojo6Ojo6Pj+4A6WeD3RlRIFnfvUyxX7F+cIYI+63VKKGA2HRBOZ9y9c4w1jv4gxpmKnf0r6GhAXSQIqVB+H9WfsLz7OtlqTeBbPK2p04QsSRlMp3ihhzMWh8I6sLYRaa7MsSiyzbJJ6g3HOKlxRYXyA3oXDtDhoK0QBVdlRKNdrDVNWlNJatPkDJVWYA3ecIfxYIhZL+lPJ6ggRGhFMB2C1Czv3cBkG3rTXaSWhKOLeGGfanWIP4hJzxbMj485Oy5xUnH98V2kc5TVnCKpqZxFeJLKWaSD6twbOmQbrSxaCSilwNmmArTe9rq28yq3KUkDeAgUzTqxXQRvkmygnTgXmtaBaNeKNsUJbBtZz5OBrq1flaLdnxRY07hO2iRg1aYuM+fYCLDGYV1zPFI4PBrhpqUgoKkv9RB4wqEwaDiXs7I9xW0VrqQRk9Dss0k4NtemblVsiaVqr6PBUdIkQWugdLZ5vQgoaGWic63qbOSfbq+W4cG1su0llO22nD8m8NsmWivaSt32Y3LdVraWwqK2Edm21rURr81rcFv7C40Ilq6dWyrahKZrUq9aNtdK0zxfJGAn0milqKzFE5bHJiGldUSh4P6morCWyPMxzhJ4AmkdE1Wz05PsTkcUixVVZahx6KHHhV7MfJ0Qej69YURylrIrKqoATvKc0f5FXn/9mM1yw+xin3vLAlcIxvUaJyTJ3dsEsYdEkRQVtxcFZ6uCQaS4vtMnT0s0Fl9KEmOpjEVoQRz4LNOUooDdnT5ZVTGIPTwt2WQZFkG/F3B/XROpCk/VZMEA3y4ZT/rcP04w1jKcDlktcybDEKskdWHZm/VZ1R6r+SmRsiys5iipGIYeI+1YbHLmuWUQSuKJT+AHHAw91CTmC//9Pq4seHKvz8pajucl792LmV3q8283FtSlwRlH6Cs2WYU0klVVYaX9Nt5NOzo6Ojo6Oh5lHglRube3x0/8xE/wj//4j5Rl+VDb3L17l1/7tV/j9u3bfPCDH2RnZ+ddJfeklMxmM/7wD/+Qf/3Xf+Xo6Oht1282G/70T/+Usiz5jd/4DS5cuPCuOp//KJRl+dCi8lOf+hQf+MAH8P3/sf5kZ2cHef4J+H/ktdde4/Of/zzPP/88Wj8S//l2dHR0dHR0dHR0PLLo6S5VZag2K3yXc/Dex7DS5/TwkADHeDIm2tvn+O5thCkYxhGBhnjvOiqKcXWJK0usDGCwy61XXqJa3me6u0MYBQg/pioKwuEAISBfZ1ipQRi052OrHM/rUQPZ4pC4P0DoAKRuKkajABVF5JslejBESUu9PkP5PWokygsQYYStSqSSWGsRKsJR4IUBXjhE7R400tMJVH+KkD7Lw9vMb7/OMFK4OMJojfRCdDxFRxN0dJev/tfPM71yjZl1lKnHYZaxfzAmKwzyaMNJWpMax6YGpxzKOmIpUVKSVpbUueY5tcNa14rZ5ro34lHgtZLS0tS1KhzO0kpKHqhK8eBnzrXdpE6itppOOKQQWNeKOylQgnZfYFFYZ5C00rT9TCiEa2paTSvhZCM0rW0lpoNKgLSNfMsNONNIUtHO1WRbldp+vN/OdnTtwQuaRKWSrWx0oGQrCW1zzBaDBUoeiE7Tzo6EZjvV9Mlu84rbp8MKCCwo8eC8EALTpigFUMtmRub2U6wHVDiMbJ5ftlfXimb+5HbeJO1ozS1uKzXFVpY2f2mleVD7a0VTK6vb66wFeELhnGWqFSNf0PMkubFgLNf3YsqiZmEEKyvIjWUn9CnrGhv56Nrwvt2Axy+O2N2fkS1WLNcpxlj8UcjUjzhe5iinUFJg1ykXyLBIbp4uePbHnufOSrJZ3yKcRPQnOxy+/AY71Rm5EvT8ECUcHrDJa27ePmOelly8usuVnSF5kiDqCiksZWEwQlAJx94oJK8MxkouX+yxWhVIKQlCn5NFgRAKEWjmBuJ+j1FPcfdwzYVLe6jdGcvlirou2Zn1qYqMcc+jEiCQjHuaQvoc3V0S49gIj5unG3b7EdeHHgZY5uCsRUhFkRkuDyT+pMcXvnJECFy6MMAEmjdePeXaKODylQF3lhWysHhKNhXQtaN2jmVtkKHm+v7oW3of7ejo6Ojo6Hj0eWsb8n3GwcEBH/nIR/jVX/1Vnn/++a8RP1+Pk5MTPvrRj/Jbv/Vb31AEfq+4evUqP//zP/9Qa/M858/+7M/46Ec/ynq9/i4fWcdbMR6PH0oQV1XFpz/9aV588cWveWw2m6GUeoutmnms//zP/8zx8fG3fawdHR0dHR0dHR0dHd9dVpuEbLNBOhjMDqhkwPG9e4TKMRqPEP0hi7MF5aZgPOoz3umjB32cUtTZhvzsmGKxoDfd4fVP/zP3vvTf0E7ghQHGC6kqg/J8lO9j8hxHRV1kOGObuYeDMZW1lOmSwXSCCmNQHjrs4492cMon3+QM9q4ihQVbY01JWdYEwwnS9zG1oS4LpJJoZQCDCnqEs4vIaIYIp1gZgT9E6Yjk+DbJyW3Wx4cIL0ZQ40yF0B6oEGsM0gv5wR/5Abz8jGq1QaLpD0fEgwH7e0Ou7g04GIb0tCRSMPQlvieJlUDicO08wlA3sx63Jk/pVkgK0Epgm3AeYTsv0lnOE47bWZTQSDglm2Rjk4xsJKN700c7u3V0rV1zrbRENkWnUjQzD41pBKEQtDWtjXW0opmfaIzDuFYFigeiFGjrTJufNclH0VTeArVtflYAmYPUQonASYFTYKSgllALQemgbq48BoETgrJNItZshWXz5BqJJ5q/Gtr+BZFkKwZFM5eT5noY0YjVuikXPv9zs03zjS+aOZmmrclViCaV2la3bq+hbatdJU1KUolGZ1bCUYkHlb1ayPNUp6O5N75qLK0SoEVTAzxQgpEvmIWayoA0liuTgLquqZXkflqzzAuGvmYQaHqDCM/CkwPJU0/ssH95F9+PWKclVkoKz2PS77MqC6qsZjoMCJTHVJRoH16aF8yJKHWf+/eXhAOf4XBEdv+MPdZYqYjCAOksEktaWu4cLXHCsTvrcXEUUSQ5rqzph81rRyiBko6Lswhb1/hS8vjVCUlVAwaE5O5ZzuEio/ACKivo9WL6/R6HpxnZ2RpZ52TWQzrH7mzAelHi4cisJFlmTPsxRmnu3znD5Tl4ileP5uyO+zy9GyO05c4iJ82b6lmD5vHdPqMrE/7t5TnVOuXaTowJAm68seRyL+C9T405LmB9nKCVoiwtcajxAkVeW4SnmUYhNv/6Y406Ojo6Ojo6/mPzSIhKpRTPPfccH/7wh/nLv/xL/uZv/oZf/uVf5urVq99w2yRJ+NjHPsav//qvvytlpZSSn/mZn2E2mz3U+qIo+PM//3N+7/d+jzRNv8tH1/Hvec973oPneQ+19oUXXuATn/jE16SA3y5RCfAv//IvfO5zn8Parjalo6Ojo6Ojo6Oj493M+mRBIMALPGrpWJ0c4nuKvcuXoTcgrwxZssbzFOOLl7HBBOHF5Osl5eqMuOcxe/IZNqd36AVw+coeu1cuY1VAVdQIAXWeYcqCyjis8PHCAOUJVBCRJSuqZEk8O8B5MckmxQmJHkyoiop0sUArSbpaIj2F9H20rxEIkkWKc5IyS7FVhRfGyCBG+T5SKZyTCO1TVxVCabywhylTpHKEHuzt9EnPTqirGhUEjZSra5J1QkXI5InnOHjyOnvXDgh7PoEShIEkikP2dsdcGMfs9X32eiFaSoaeoBdofE8TakUoJIEEbSXCiUYKbmc8aoEUFiUgkBKlHNY2taJbQSddI788JdC6SSEKmvpWLVvRSJvua3tepdxWogKItgq2fW7ZVO3KdlsEGOuaytw2Nmhw1KKRj1VbRytoRJ1r+2eFaOtVHcj2uZrjaFOJNDLSCIEVovneNVIvkhJfNccpVTPPclvXCg/qYs8TlaKRiaZNUNa8ab6nA8816UiAuq1mdaIRqNsJks3a5juJoLYCc/6czexLiWhqWrc7hvOfbX/R17pmeqVoTa1CEEiBsE3tbJNOdXhKIJ3DF+DJZl7m1BNMfMks1M21cJaDUURR1JTC45VlReIg9BR9X1JoQV7WPDOSPP30PjrsY2tYZTlVbUDBwWzAKktQUjIcKIwxDGxKZQ03lvCpl87Q2ud4ZcmSQ0ajAeZsxWXfkNUW3/fwPZ8w0FipOT5e4ZwlryyXxxFZnlJnBdiKJCuxKJyDvdkQ4xx1UTEYRNybp5RJja81q8yQpQV7w5DY1kw8iKhZLdfECvZmMUe3T9FlyqAfUVSW2SzCBQGmqJj2fLKi4v69U2xZU1m4s0z/f/buPEySqs73/+ebS+3VXb3SNPRCA7L9oMFmR7BhHAF1lKs4joqKcx1QQe4jDM9Vx8sid37CjCg4qIij4ggDOAviMiiOisgiCAIu7EiLQGNDL9XVtWfmuX9ERHP6dGQtWVmR2dXv1/Pkk3QsJ06ciCzq1CfPCS3o6daes1vkrKx1fU6jI05tLU6draYl89tUnNOm3z7dq8FNW7Ri1y4Vulv1zHMbtGhWUfvsNVfry61au6ZX5YrTwOioWlvzGlZe6/pGtUVOXV1tass7DaU83gYAAECaIUFlorOzU/vvv79OOeUUXXbZZbruuuu0YsWKcfcbHR3VTTfdpE9+8pPasGHDhKbuzIqZacmSJTrhhBMmvM/g4KCuvvpqffazn9Xw8PA01g6hPfbYQ5dccokWLVo07sjKgYEBXXPNNXriiSe2ueeWLFky5rSumzdv1qc+9Sn19vbWrd4AAAAA6m/hvE61z5qlSq6owS39arGiFi9brr6hsoaHRzW84WW1V8pauGSpRio59W/uU++GTRrt36KuuQul7l3Vu3GjhjdvUkfnHM3ebbkquYLKQ0OyUkmjW3o1Ojyk0dGSRoaGVB4tqVBsU0tbl3pf/KMq/VuUyxW1ZXO/tqwnQ2jSAAAgAElEQVRfr5aObnUu2E29a5/Tnx7/tVpaC+pb90cVCwW5sjQ6UtHA4IhefP4F9fduUO+GDdqwbl0UuKmocqmifHGWrNgu5QoySfmWDrV0zpMVW2UtXSp27aKe3ZaqNFJSvnuBOhcuVa7YpVwup+HeF6XhzSoW21RyHepctlKd8+eprbNdnXPmaPGrVqhrbpe6u4paMKdFy3bp0ryunPZe0KHd5nSorb1V7S1FFU1qzTnlKk7RxK5SPu9k5lQsRKFWIS+1FqLpVkujUvLERRdPl2pb94mmjK1U4ilXc6ZyMgIwZ3FAaMrnTJaT2ltMHS2mthYpnzfl81HQGNUhCQiTVC8ZZxhx8bMXK9LWZy7m42dhluOpUEtSHNRJ8Zy08XMenSoWTWubqzi1WnRGLbmcKjLl8jm1tLWoo7WofP6VEZ35XDTNaiEOHlvicvOKRliOKgo/X5kKNlJ0ikaCuih4TEaU5pxTq4ue/ZlMTRs9M9NUNqfRXBTCxqchF4+iLMttfb5lUp+ckiA1ahNTNHqzIKkl72TOyVlFZctJZmrLmfIVqWi5OKw2zS3k1Zo39bTl1dESPaO1o62ogeGyKvmCfr1hUBtL0oK2ouYUi9pSMQ0OlbT/7IJWHbhYr1q1UpWhYa3v7dVLmwY1OOrU1d6hjQMj6ujoUGd7u0ZHcuocHdXwwKieeG5I3/3lH9XRktOLGwf1+6f+oJ7uHhV7t2j32ZLrKMgUTz2rnAZGpE0b+pXPm4ZHy1o+v0PlSkXlUWl0eFh9m4dUbO/U4NCIZs/qVP9oSUMDI5q/YI5e2jSk/vX9WjirXWvXD6g0NKoFnUUtmNWqnraCOloKGh526nRl7b6gQyOjFQ1u7lNbW14Do9F1H3Q59Q+NqqMtp0ohr+fXPK+B3n4NOtMfNw2pra1Tr9pljgrt0sv9Tv0DZVXKTh35nHbrKap9Qbd++/R6DWzs09IF7Wqf06nf/X6D5hdNK3bvUm+loueeWa/RSln9w6VoVGzZtGmgrC2Vijo6OtVtTsXWnEpuRv0JEgAA1NGM+y3BzJTL5dTZ2aljjjlGS5YsmdB+w8PDuv7663XllVeqr6+vqcLKnp4enXjiiWptbZ3wPps3b9YXvvAF3XTTTRN+biemLp/P65xzztH3vvc9HXbYYeOGlY888oguvfRSbdq0aeuyJUuWaO7cuWPud9999+mcc85hClgAAACgiRXbuzVSqsiVKupq79C83Rdr08YtGundooF1L6urrV2d8xeqnCtqdHhY659/XrmhPs3ffXdZe5cGejfJjYyou3uWWrpnyVpalS/k5EolVYaHlMvnVSlLg72blVNOxZYOyYra8vI6lQcHlW9tV7k0qo6i1LNgd3XO3V29z/5eQy8/p1lz5kjlsrp3WaJcvi2aotJV1Lf2BbUX83KDver7w5Ma3bhRmzf1qzxSUb7YFsVZlShsKpcqyrd0q1Iqa+Ozz2vLn9Zq08u9KrlOzVu8UKVNGzXYNyxVnEaHhpUvtKqte47KI6MqFNtk+TbNWrSHFizbQ4v22kvzd91Ny/dapj33Wa7lS+bpwH121QmHrtDB+yzSsvmzNDtnstFhtTinQjw+sJgEWDLl4xGVZlLO5eQUjWjMWTxqUX6oGIWMMqdKOQ4r3Suv5BmSZq+EmSZTwaKCKnGIKHNbpyR1Lhr9l4unTc0lD2JM5ni1uJ5S/DzLaHElDgkr8cjIKMCLRl4mE+mU45BS8TS1rTlT0aThUkV5Mw2WnToKBZXKFZUqOVVcTmWXV8VM+Xw0crStGAWjLYqCxlL8/EjF9bF4pGlR0cjJUXMq2yujOhXXLy+ncjJ6Va8869OcbR2daYqmes3HZW0tw5LjJfPdRm+VeMpeSSrmo/XlraM3K2rNReFxSy4aSVmqlDSvNa/5na2a09aiXbvbVB4d1fyuNm0ZKmm4Ij3bP6oR5zSnraB5HS0azkktltNe7Tkdvmq5unfbTRW1qdTaJlduU+uWAc0qOlVKJc0q5lVQTv29w5proyqNlPSnLWXd9fuN6ulqV09Pl9pa27V53UsafPYlLV3YotlLd1eha57aemZr/tz52tw/rI29gxrJ5dXbX9Gei2bJ5Qoa6h9VebSsoUpOKrSor29ECxb0aPPIqAb6Slowp0ubB8qy0VEt3aVHL23uV3dLm5Yv6NbCed3qaiuoq6uogZJpdjGvpbv2qH+woqH+UXXP7tKLazdo190Xa8A6tWHDsNo6Zknts7R+w6AGBstqa83LtbTKCm1a1N0u5Ut6uU/q2zKqSs7UkjPtNqdFNmeOnnxqk1qU1y7dLeruadfjz25Rd6WsVy2fo/5iXs8/26tyqaKRcjTqtlKRhgbKGnKj6prdpTmtBbUVpaGhskaHkrG9AAAA26o+bGsGyOVyY45MCw0MDOiqq67SkiVLdPrpp09q3+lUKBR08MEHa7/99tNDDz004f1efPFFXX755VqxYoWOPvroMacTRf3kcjkdfPDBOuOMM/T0009r/fr1Y25/0003af/999dHP/pRtbe3K5/P681vfrMuv/zyMff71re+pY6ODp1//vnac889J/RsTAAAAADZOfLcf57UL+n7TFdFPF37j71+zhGn1Vbuvtsvm19DOePPiQQ0zv9sdAUm4dBpKPN101AmAADAjE6uyuWytmzZMql9NmzYoEsuuUT33HPPNNWqNvvss4+OOOII5fP5Se3361//euuUtshOPp/XCSecMKGph0ulkj772c/quuuuU6kUPVz+rLPO0ic+8QntscceVfcbGRnRN7/5TZ177rm67777VC7z7UQAAAAAAAAAALDjmNFB5eDgYE3Tnj777LM699xztXbt2qaZArazs1OrV6/WvHnzJr3vnXfeqS9/+cvTUCuMZenSpTrooIMmFC6vX79el112mb773e+qXC5r+fLl+vjHP65zzz1Xc+bMqbrf4OCgbr31Vp122mm65ZZbVKlUmuaeBQAAAAAAAAAAGMuMDir7+/u3jlCbrIcfflgXX3yxBgcH61yr2piZTjrpJB188MGTnuKzXC5PaspY1Ec+n9dBBx2klpaWCW3/9NNP6+/+7u90xx13qFKpqLOzU29961t15JFHjrlfqVTSU089pXe/+9264IIL9NJLL6mSPMgEAAAAAAAAAACgSc3ooLKtrW3CIVFodHRU3/nOd3TLLbfUHHbWW09Pjy644AKtWrVqws/PNDMdcsgh+sQnPjHNtUOavfbaS8ViccLbP/roozrvvPP0y1/+UpK0ePFiHXfccero6Bh336GhIX3mM5/Rhz/8YT3wwANNc98CAAAAAAAAAACkmVjatYPq6urSwQcfrAcffLCmEWZr167VN77xDR155JFjPiswS0cffbS+9KUv6bbbbtNjjz2ml156SRs3btSmTZvU39+v4eFhDQ4OqqWlRT09PTr22GN1xhlnaOXKlY2u+k5pxYoVEw6VEw8++KDOPfdcff7zn9ehhx6q17zmNZo1a5YGBgbG3Xd4eFg333yzXnjhBX3yk5/UySefPOkRuAAAAAAAAAAAAFmY0UFlPp/XRz7yEd18883asGFDTWX87Gc/049+9CO9//3vn9TIuOliZlq1apUOOugg9fb2anBwUENDQxoeHlapVFK5XFapVFIul1Nra6sWL16sefPmKZeb0YNnm9ayZcvU2to66f1+8Ytf6Pzzz9eVV16plStXqqenRy+++OKE9q1UKrrnnnt09tln66KLLtJ73vMewkpgJ/GHzRUt/9j3p/UYay5947SWDwAAAADAdPnDZh6XBADNZkYHlZJ04IEH6h//8R911llnaWhoaNL7Dw0N6Stf+Yre9ra3ae7cuU0R+JiZWlpatGDBgkZXBeNoa2vTihUrtHbt2knt55zTHXfcoQsvvFBXXHGFDjzwQD322GOTKuOZZ57R+eefr6GhoaYJ2gEAAAAAAAAAABIzfphdLpfTO9/5Tl100UXaZZddairj/vvvn3RIBEhRqHzMMcdMap9cLqeFCxfqiCOO0GGHHaZisajDDz+8ppB83bp1+vSnP61bb72VZ1YCAAAAAAAAAICmMuNHVEpSe3u7PvShD2nRokW65pprdO+996pcLk+qjFqnjgXe+c536pFHHtGaNWvU29uroaEhOedUKBTU0tKirq4udXd3a/bs2Zo/f76WLFmigw46SMccc4yWLVsmSVq1apXMTM65SR9/zZo1uuGGG3TkkUdq4cKF9T49AAAAAAAAAACAmuwUQaUkzZo1S+9617t06KGH6sc//rFuvPFGPfTQQxocHKy6T6FQ0N577603velNOvzwwzOsLWaSgw46SF/84he1bt06DQwMaGRkRFI0crJYLKqtrU3t7e1qb2/XrFmz1NPTo3w+v80IypUrV6qjo0NbtmypqQ6bNm3aelwAAAAAAAAAAIBmsNMElZJULBZ1wAEHaO+999Zf/dVf6YUXXtD999+v3/3ud1q7dq2Gh4fV3d2txYsXa7/99tPKlSu1yy67aNasWero6GiK51Nix5PL5bRkyRItWbKk5jJmz56ts846S5/73Oc0Ojo6oZGVuVxOhUJBBx54oD760Y9q0aJFNR8fAAAAAAAAAACg3naqoDLR0tKihQsXasGCBVq5cuV2oY8fSBJOohnkcjldeOGFOvTQQ3XjjTfq6aef1tDQkMrlsiqVipxzyufzyufzamlp0a677qp9991XJ554oo477jh1dHQ0+hQAAAAAAAAAAAC2sVMGlYkkhCSMRLMzM7W3t+vUU0/VqaeeqqGhIfX29mpgYEDDw8OqVCpqb29XW1uburu71dnZyX0NAAAAAAAAAACa2k4dVAI7qra2NrW1tTW6GgAAAAAAAAAAADXLNboCAAAAAAAAAAAAAHY+BJUAAAAAAAAAAAAAMkdQCQAAAAAAAAAAACBzBJUAAAAAAAAAAAAAMkdQCQAAAAAAAAAAACBzBJUAAAAAAAAAAAAAMkdQCQAAAAAAAAAAACBzBJUAAAAAAAAAAAAAMkdQCQAAAAAAAAAAACBzBJUAAAAAAAAAAAAAMleYwr5Wt1oAAAAAAAAAAAAA2KkwohIAAAAAAAAAAABA5ggqAQAAAAAAAAAAAGSOoBIAMC4zW25mzsyubXRdAAAAAABA9szs9PhvA6dPsZyL4nJW16dmAIAdGUElAAAAAAAAAAAAgMwRVAIAAAAAAAAAsnKVpP0k3dfoigAAGq/Q6AoAAAAAAAAAAHYOzrmXJb3c6HoAAJoDIyoBADUzs5yZXRk/W+I/zazdzI43s2vM7BEz22xmg2b2WzO70MzaUsrY+mwKMzvVzO4zswEz22BmN5rZblWOfZiZ3WZmffFx/tvMjqr2rAszO8XMrjOzJ8ysP349YGbnmNl2/z80s2vjclaY2UfM7NfxudzubbO3mf2LmT1vZiNm9kL8772r1Hm2mX3azB43syEz22hmPzSz10227QEAAAAAmAozWx73e681s33N7NtxX7zfzO40s9dPsJya/w4QLHdmdruZzY/LW2tmw2b2OzN7f51OGwDQZBhRCQCoSdzZuF7SWyV9QdI5zrmKmf1vSftKulvS9yW1STpG0kWSVpvZ65xz5ZQiPyzpzZK+I+lnko6Q9A5JK83sYOfcsHfs4yTdJikv6T8lPS3pQEk/lfSTKlW+VFJF0r2Snpc0W9IJkq6UdJik91TZ70pJx8bn8l+SynEdDpP035K64zo/Ep/3aZLeEp/nL70690i6S9L+kn4p6QpJ8yX9paTbzOxDzrkvV6kDAAAAAADTZQ9J90j6jaQvS9pVUX/8VjN7l3PupnH2r/XvAGmSvvOIpH+X1Crp7ZK+ZmYV59w3JnNiAIDmR1AJAJg0M5urKJw7WtLHnHOXeas/LOkZ55wL9rlE0iclnSoprZNzkqTDnHO/8fb5V0nvlPQWSd+Kl+UkfVVRZ+UNzrlbve0/KOlLVar9Rufc00GdcpK+Lum9ZnaVc+7elP1eLekQ59wz3n4m6V8kzZJ0mnPuem/dOyTdKOmbZra/c64Sr7pMUUh5jaQPJu1jZpdJul/S583sh865NVXqn5T/QJVV+461X73cfvvtWRymKfT19Unauc55utGm9UebpkvaBQAAABNynKTPOOfOTxaY2VWKwsurzexW59zmMfav9e8AaVYq6vOfmYSbZnaFpF8rCkTHDSrH6zfzu3Pt6H9MHW04NbTf1CVt2Ez9ZqZ+BQBMipktU/TtxsMlvScIKeWc+33YOYl9Ln4/sUrRn/dDythX4vfDvWVHS9pL0k/9kDJ2jaQn0goPQ8p4WUXRiMmx6vUPfkjp1WFfSff4IWVc5k2S7pS0j6TXSJKZtSgaablF0sf99nHOPSnp85JaJL23Sh0AAAAAAJguvZI+5S9wzt2vaBalHkn/Y6ydp/B3gDQDks71R2A65x5R9HeI/cysaxJlAQB2AIyoBABMxj6KvlHZKelk59yPww3MrFPS/1LUkXmVoqlRzdsk9ZmTikYVhv4Yv8/xlh0Sv98ZbhxPPXt3fNywXvMknS/pDZJWxOfgq1av+1KWvTp+rzbN7E8UhZSHSLpDUbt1SLrLObehyvaf1CvnVpVzblXa8vgbo69OW1dPq1evnu5DNI3k23k70zlPN9q0/mjTdN3d3Y2uAgAAwI7kV865tKE1t0t6n6K+atWRjFP4O0CaJ6uM3vT/PrBlrALG6zfzu3Pt6H9MHW04NbTf1CVt2Ez9ZoJKAMBkvErSXEkPSfpVuNLMiopCt8Ml/VbR1C4vSRqNN7lQ0ZStaTalLCvF73lv2ez4/U9Vytluefx8yF8qeu7GfYqmbd0Ql9+jqENVrV4vpixL6rC2yj7J8p4atwcAAAAAICvV+tdJf3h2lfVT/TtAmrS/DUjpfx8AAMwABJUAgMn4rqTHJf3/kn5sZn/unFvvrX+Los7Jtc659/s7mtmuijooU5V8s3KXKuvTln9AUUh5sXPuoqBeRykKKqtJm76mN35fVGWfXYPtJrs9AAAAAABZqda/TvqwY/VVs/g7AABgBuMZlQCASXHOfVrSRxVN/XK7mfkdmr3i9/9M2fW1darCg/H7a8IVZpZT9PzIUFKv/6hTvZI6rK6y/vj4PRl1+rii52ysjEd3jrc9AAAAAABZebWZpc0BuDp+fzBlXSKLvwMAAGYwgkoAwKQ5566Q9CFJB0j6mZktjletid9X+9ub2QpJl9Xp8HdJelrS8WZ2crDuDKU8n3KMeh0i6eM11uFxSa8xs1ODMk+VdKykJxQ/R9M5NyLpekXP6bgk2H5PSecomhbnmzXUBQAAAACAqZgt6QJ/gZkdKundikZT3jzGvmvi99XB/vX8OwAAYAZj6lcAQE2cc1eb2ZCkr0q6w8xOUDQ17FOSzjWzAxV963KppDdJ+n7831M9bsXMPiDpB5K+Y2b/oSi4PEjSn0u6VdLJkirebv8i6XxJV5jZ8ZKelLR3XK//lPSOSdbBmdn7JP1I0k1mdoukxyTtI+kUSX2S3uuc8+vwMUUB5tlmdpikn0qaL+kvFQWYZzvnnplMPQAAAAAAqIM7JH3AzI5Q9MXcXRX1k3OSznTObR5j32n/OwAAYGZjRCUAoGbOuWslnSZpmaKOzS6STpD0r4pGW56jKEC8JN6uXse9XdEUMrdLemN8nHZFU6j+Pt5ss7f9C4pCwu8rmjL27LjOH1YUINZSh3slHaboXI9SFIQeLekGSYfF6/3tN8Tb/YOkeZLOlfR2SfdJOsk598Va6gEAAAAAwBQ9o6g/u1HSBxV9ofZXkt7gnLtprB2dc/3K4O8AAICZixGVAIBxOefWSLIq625QFM753l2lqO3KcM5dJOmiGo57r6IRlNsewOwzksqKRk362z8i6c2TqNfpkk6vsn2yzeOS3jPWNsH2myT97/gFAAAAAEBTcM49Kukt42xzraRrU5b/UXX4O4BzLrX/H687XeP00QEAOyZGVAIAdjhm1mFmPSnLT1f0LdDb4m91AgAAAAAAAACaFCMqAQA7oqWSHjSzHyl6FkZB0iGKpnXdJOm8BtYNAAAAAAAAADABBJUAgB3RnyRdr+g5lcdLapX0oqSvS/p759zTDawbAAAAAAAAAGACCCoBADsc59xGSR9odD0AAAAAANhROefWKOUZkgAAZIlnVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwVGl0BAABQH8tm5fTEpW9sdDUAAAAAAGhKy2YxbgcAmg0/mQEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkjqASAAAAAAAAAAAAQOYIKgEAAAAAAAAAAABkzpxzja4DAACYIjNb39raOveAAw5odFVmjL6+PklSd3d3g2syc9Cm9Uebpnv00Uc1ODi4wTk3r9F1AQAAQHOg3zx19D+mjjacGtpv6pI2fO6555qm30xQCQDADGBmw5Lykh5udF1mkH3j98caWouZhTatP9o03XJJm51zezS6IgAAAGgO9Jvrgv7H1NGGU0P7TV3ShkNqkn5zodEVAAAAdfFbSXLOrWp0RWYKM3tAok3riTatP9oUAAAAmDD6zVNE/2PqaMOpof2mrhnbkGdUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMicOecaXQcAAAAAAAAAAAAAOxlGVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAABNysx2N7OvmdkLZjZsZmvM7AozmzPJcubG+62Jy3khLnf36ap7s6pHm5rZn5vZ5Wb2YzNbb2bOzO6czno3s6m2qZl1mtm7zexfzewxM+s3sz4zu9/MzjOzluk+h2ZTp/v0fDP7r3jfLWa22cx+Y2af3Rk/+wAAANhxNbJvXK9jN1qj+m1xf7na6xf1PcvpVad+2u3jtElblf32N7Nvmdk6Mxsys8fN7GIza6/fGU6vOtyDq8dpu+S1JNhvRtyDZnaqmf2Tmf087t87M7uuxrImfS2m+x4051w9ygEAAHVkZntKulvSQkm3SHpM0uGSjpf0uKRjnHPrJ1DOvLicV0n6iaRfStpX0lskrZN0lHPu99NxDs2mjm36bUXtNyTpKUn/n6S7nHOvmaaqN616tKmZnSTpVkkbJP1UUZvOkfRmSYvi8v/MOTc0TafRVOp4nz4laYukhyX9SVJR0iGSXitps6TVzrkHp+McAAAAgHppZN+4XsdutEb228zMSfqDpGtTin3OOffPNZ9Yhup4H96uqE92cZVN/q9zrhTsc4Sie7Yo6d8l/VHSCZIOlXSXonYfnvxZZadO9+BySadXWX2gpLdK+q1z7sBgv5lyDz4kaaWifv5zin5+Xe+cO22S5Uz6WmRyDzrnePHixYsXL15N9pL0Q0lO0keC5Z+Nl189wXK+HG9/ebD8nHj5Dxp9rjtgmx4l6QBJeUnL433vbPT57ahtKulgSe+W1BIs75b0QFzOeY0+1x2pTePt26os/5u4nP9q9Lny4sWLFy9evHjx4jXeq5F943odu9GvRvbb4uW3N7oNmqEN4+1vjyKZCR83L+mR+Bhv9pbnFAVGTtLHGt0+WbXfGOXfEJdzTsq6mXIPHi9pb0kmaXV8XtdN97XI6h5kRCUAAE0m/nbTU5LWSNrTOVfx1nVLWqvoF5OFzrn+McrpUvTN0IqkXZ1zfd66nKTfS1oWH2NGj6qsV5umlLtc0jPaCUdUTlebBsd4l6TrJX3POfcXU650k8uoTWdL2iTpKefc3lOuNAAAADBNGtk3zuJ38yw0ut8Wj2b7mXNudU0n0ATq2YbJiErnnE3w2CdI+rGkO5xzrw3WrZD0tKLRgnu4Jg16pvseNLP5ikYYViQtds5tCtbv8PdgyMxWKxrZPKkRlbVci6zuQZ5RCQBA8zk+fr/N/6VBkuIO1V2SOiQdOU45R0pqVxSi9fkr4nJ/GBxvJqtXm+IVWbTpaPxeGnOrmSOLNk3+cPDrKZQBAAAAZKGRfeOZ0odshn5bj5n9tZl9wszOMrNmb7NQ3dvQzN5hZh8zs3PN7GQza62y6Qnx+w/CFXGo/oSikH3FRI/dANN9D75PUqukfwtDSs+Ofg/WSy3XIpN7kKASAIDms0/8/kSV9U/G76/KqJyZgLaovyza9K/j9+1+IZ6h6t6mZvYBM7vIzD5jZj+U9A1F33b8WO3VBAAAADLRyL7xTOlDNkO/baWkr0r6e0lXSbrHzB4yswOrbN9spqMNb5T0aUmXS/ovSc+a2akZHTtr030OfxO/f3mMbXb0e7BemvZnIUElAADNZ3b83ltlfbK8J6NyZgLaov6mtU3N7GxJJ0l6SNLXailjBzQdbfoBSRdKOk/S6xU9P+Z1zrknx9wLAAAAaLxG9o1nSh+y0f22z0vVhAIAACAASURBVEo6RtICRc+zPEzRc+1WSvqJme1Wy3EzVs82vEXRLDe7Kxrlu6+iwLJH0k1mdtI0HrtRpu0czOy1ioK03zrn7q6y2Uy4B+ulaX8WElQCAACgqZjZWyVdIelFSW9zzo2OswuqcM4dGT//ZL6ioFKSHjCzExtYLQAAAAA7uIn025xz5znn7nbOveyc2+Kcu98593ZJ/6Goj/K32da6sZxzn3POfc8597xzbsg597hz7hOKvliaUxRaYuLOiN+vqbYB9+COgaASAIDmk3wbaXaV9cnyanPv17ucmYC2qL9paVMzO0XRNDjrJK2On3mws5i2+9Q5t9459yNFYeWgpG+aWfvkqwgAAABkppF945nSh2zWftvV8ftxk9yvEbK4F/5Z0TM+Dzaz7oyPPd2m6x6cK+ltivu3NdRrR7oH66VpfxYSVAIA0Hwej9+rze++d/xebX74epczE9AW9Vf3NjWzt0v6N0l/kvRa59zj4+wy00z7feqc2yTpHkXT3hxQazkAAABABhrZN54pfchm7be9FL931rBv1rLopw1J6ov/6bfJTLgPp+sc3iepVdK34n7uZO1I92C9NO3PQoJKAACaz0/j99eb2Tb/r46/WXeMpAFJvxinnF8o+mbZMcE38hSXm0wD+dNwxxmoXm2KV9S1Tc3s3ZJukPSCos7uzvgMxazu0+QZHKUplgMAAABMp0b2jWdKH7JZ+21Hxu87wgw6034vmNk+kuYoCitf9lb9JH4Pn10pM1uhKDz6g5q7Haer/f4mfq867es4dqR7sF5quRaZ3IMElQAANBnn3NOSbpO0XNJZweqLFX3b65vOuf5koZnta2b7BuVsUTT9Raeki4Jyzo7L/+HOMLVmvdoUr6hnm5rZ+yT9i6RnJR23M9yTaerVpma21Mx2STuGmZ0p6TBJf5T0m/rVHgAAAKivRvaNazl2M2pkv83MDjKzYtpySX8f//O6iZ9NY9Sxn7ZHPF2pguULJH09/ueNzjn/C6U/k/SopOPM7M3ePjlJl8X/vNo552o5tyxMx99jzOxYSftJ+q1z7u4xtpsR9+BkmVkxbsM9/eU1/lzL5B60Jr6HAQDYacW/TNwtaaGkWxT9UnCEpOMVTadwtHNuvbe9kyTnnAXlzIvLeZWib0Hdp+iXubcoepbE0fEvKjNeHdv0NZI+EP+zS9EzEdZJujXZxjl3+nSdRzOpR5ua2fGS/lvRF+i+pihAC21yzl0xTafRVOrUpqcomorpHklPKZqSaZ6ib4weKGmLpDc5536WwSkBAAAANWtk33iyx25Wjeq3mdm1kv5C0s/j7Ycl7atoZFZe0lckndnMIVuiTm14uqLnIt6paPTZBklLJb1B0XP+7pf05+E0pmZ2hKJ7tijp3xUFxX8m6VBJd0n6M+fccL3PuZ7q9Tn21n9T0mmSznHO/dMYx71WM+cePEXSKfE/F0k6UdF99PN42cvOub+Nt10u6RlJf3DOLQ/KmfTPtSzuQYJKAACalJktkfQpRb9AzZO0VtLNki52zm0Mtq36S1z8jb0LFf1Cs6uk9YpCtQucc89N5zk0m3q0ady5+LrGUO2X6Zloqm06kfZUyi/XM1kd2nSppHMkHavom5JzJQ0p6sT8SNKVzrm0PywAAAAATaeRfePJHLuZNaLfFgcr75V0kKJQpE1Rm98v6SvOue9M6aQyVoc2PFDSeZJWSVosaZaiqV5/J+lbkr7snBupcuz9FY14O15St6KpNm+QdKlzbrB+Zzl96vg5nqNo6mEnafFYz6ecSfegmV2k6OdXNVs/f2MFlfH6Sf9cm+57kKASAAAAAAAAAAAAQOZ4RiUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAA7OTMbLWZOTO7aBqPsTw+xrWT2Of0eJ/Tg+VrzGzNRLYFAAAAAGCq6DcD04egEgAAADNWWucMAAAAAABE6Dej0QqNrgAAAABQxc2SfiFpbZ23BQAAAABgJqDfjB0eQSUAAACaknOuV1JvvbcFAAAAAGAmoN+MmYCpXwEAABrMfw6Fme1rZt82sw1m1m9md5rZ64Pttz5XwsxOMrPbzazXzJy3zWwz+7SZPW5mQ2a20cx+aGavG6cuR5nZf8fl9cX7HJqy3WIzu8DM7jKzF81sxMxeMLN/NbP9xznGuOcYnucE2nCbbZPnh0haJmlZvC55XWtmc8xswMyeNjOrUuZ34+23O38AAAAAQHboN9NvxsxFUAkAANA89pB0j6S5kr4s6d8krZJ0q5m9I2X7UyV9T1KfpKsl3SRJZtYj6W5JH1P0bckrJP2HpKMk3WZmZ1Y5/hGSbpc0LOkLkm6V9GeSfm5mxwbbHheXvyku+3OKppA5VdJ9ZrayTudYqzWSLlZ0/r3xfyevbzvnNkq6UdIKSdt1Qs1siaSTJT3gnLu/jvUCAAAAANSOfnP9rBH9ZjQBpn4FAABoHsdJ+oxz7vxkgZldpaiDcrWZ3eqc2+xt/wZJb3DO/SAo5zJJ+0u6RtIHnXMuLusySfdL+ryZ/dA5tybY7yRJH3HOXeUd/y2Svi3pa2a2j3OuEq/6iaRdnHN9fgFxR+suSZcq6rBM9RxrEp/bRck3RZ1zF6Vs9kVJ75d0pqQfBev+p6S8ok4hAAAAAKA50G+m34wZhhGVAAAAzaNX0qf8BfG3Eq+X1CPpfwTb3xJ2tsysRdJpkrZI+njS2YrLelLS5yW1SHpvyvGfUtQJ8Y9/i6SfSdpL0rHe8nVhZyte/rCiztjxZlaswzlOm/i490t6i5ktSpabWV5Rh6tP0g1Z1QcAAAAAMC76zfSbMcMQVAIAADSPX6V1YhRNKyNJhwTL70vZdh9JHZIeds5tSFn/kyplSdLPvW9+jnt8M3tj/DyKtWY2mjzLQtJfSGqVND+lrMme43T7oqJZRv7aW/YGSbtLus45tyXj+gAAAAAAqqPfTL8ZMwxTvwIAADSPP1VZ/mL8PrvKcl+yzdoqZSXLe6ZyfDP7X4qe4bFR0fQvz0oakOQknSJppaJOV83HyMiNki6X9Ddmdmnc4TwjXsf0NQAAAADQXOg302/GDENQCQAA0Dx2qbI8mV6lN1juwg29bRalrJOkXauUNeHjm1lB0kWKOkmvds5t07kzs6OqlDPhY2TFOTdoZtdK+qik15vZ7xQ9I+TeeDoeAAAAAEDzoN9MvxkzDFO/AgAANI9Xm1l3yvLV8fuDEyjjcUXf0FxpZmnf/jw+fv9VyrrXmFna74fh8ecr+mbp3SmdrS5Jrx6jfvU4x8koS8qPs82XFHVez1T0jI28+FYoAAAAADQj+s30mzHDEFQCAAA0j9mSLvAXmNmhkt6t6BuTN49XgHNuRNL1krolXRKUtaekcySNSvpmyu57S/pwsM9bJL1W0lOSfh4vXqeoU7cq7mAl2xYlXan0Z2wkpnyOk7Re0gIza6+2gXPuSUk/lvQmSR+UtEnR1DYAAAAAgOZCv5l+M2YYpn4FAABoHndI+oCZHSHpLkXTzbxD0ZfLznTObZ5gOR+TdKyks83sMEk/VdQJ+ktFHbGznXPPpOz3A0mXm9nJkh6WtJekt0oakvTX8XMo5JyrmNnn4+P8xsxukdSi6Func+PjHZ9Sfj3PcaJ+LOkwST8wszskDUt62Dn33WC7L0p6naIpdv7JOTdY53oAAAAAAKaOfjP9ZswwjKgEAABoHs9IOlrSRkXfUPxLRVPNvME5d9NEC3HObZB0lKR/kDRP0rmS3i7pPkknOee+WGXXexVNJdMq6WxFz5z4iaTjnHM/D7b9P5LOkzSoaOqXt0q6X9Lhkp6d7nOchP8r6WpJe0r6uKJvy74tZbvvSHo5/m+mrwEAAACA5kS/uf7oN6OhzLm0Z8kCAAAgK2a2XFFH5BvOudMbWpmdlJmtUDRNz13OuWMbXR8AAAAAwCvoNzce/WZMF0ZUAgAAANLfSjJJVzW6IgAAAAAANCH6zZgWPKMSAAAAOyUzWyrpXZL2lvR+Rc8X+beGVgoAAAAAgCZBvxlZIKgEAADAzmqFpE9LGpD0I0kfcs5VGlslAAAAAACaBv1mTDueUQkAAAAAAAAAAAAgczyjEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCCoBAAAAAAAAAAAAZI6gEgAAAAAAAAAAAEDmCo2uAAAAmDoze0bSLElrGlwVAGgGyyVtds7t0eiKAAAAoDnQbwaAbSxXk/SbCSoBAJgZZrW2ts494IAD5ja6IqhNX1+fJKm7u7vBNUEtuH7N5dFHH9Xg4GCjqwEAAIDmQr+5RvR3akO71YZ2q81k262Z+s0ElQAAzAxrli5dOveBBx5odD1Qo9tvv12StHr16obWA7Xh+jWXVatW6Ve/+tWaRtcDAAAATYV+c43o79SGdqsN7VabybZbM/WbeUYlAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIHEElAAAAAAAAAAAAgMwRVAIAAAAAAAAAAADIXKHRFQAAAPXxh80VLf/Y9xtdDUzVD7iGOzSuX12tufSNja4CAAAAZhD6zVNEf6c2tFttaLcJmQn9ZkZUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBFUAgAAAAAAAAAAAMgcQSUAAAAAAAAAAACAzBVq3fGrX/2qy+WinLNSqcg5p1wuJ+eczExmJuecnHOStHVZ+N+VSkWSlM/nt1uWy+VUqVRkZsrn81uPk5SdbJNsl6zP5/Nb6+KX49fNLyM5XrFY3K7OfjnJtmHZ4TmGdTSzbc4zaTf/WMl5JP/2z8EvJ5/Pb923XC5v3TYp329j55wqlYry+XzqNr6kzonkXJJ29dsjTdiuSd3C5f61NTOVy+Xtyk27Xkl5/v2Q8NuhXC5v3S8pJ1nvHyNpj2Q7f7+kPXx+vZNtk3MI6+q3abjcbxf/3JM289vCv6eT4+Xz+W3KTLYpl8vbtWmy3L8n/br495V/DL8t/M+k/9lK2s5vm/D8/eXJtU/KTepdKBRkZiqVSlvvVb9c/xr5ZfrXPlzm75N2nZI6JfuXy2UVi8Xt2iTt51HSTv69nGx75plnbv/BAgAAAAAAAAAAVdUcVPrhW/Lv5D0M6aRtQ5tq5fmhXBI2hKFKWG6yLAkm0oKmJBwK6xpulxbW+ev9+iTHSgs2wnMNg0s/2E1rj7Acv35JUOrXr1pQ5NfTv1ZhyOq/ql2fMNT1w1b/PMLjhG0Ynkt4TP98wmOHAWV47mEI6oe+aarV2W8bf1lafardP+G1Hysk9rdLC/jDc/KvhV/38DMTtpd/3v61STuf8F5KPl/+tQ7DvLSgO7lGaV82SAt6/evhfwkhvAb+Ofj3sV+/tC8E+P8OA/Jq5xJ+WcFvDwAAAAAAAAAAULua/9Iehhz+8u0OkhIYVAsewlciCS/C4NBf5ocH4cintBFl451fWuiZFtKkSTuHtPVhwDpe3dKC02rHqVbHMLSpVt/xAsawLmOdaxjUjXe8sF7++VQLmtNGNlYL3sIgMAzY01S7R6u1cVrIXK1N/bqE5+Wf93jXKwx5/X3Twsdqn9cw9A/3T6tzWGa1dWlBvr99WlA73jZ+eD/WZzRsf/9cq332qpU50Z8lAAAAAAAAAAAgXc0jKpORfcmIqGTaRn9Ulx+q+KOcwulSw22S7dJGTYVBRTjqKu34hUJhzJA0qUda6Jc2ii2ZHjMczeWXEwZCfrCU1Dkpzw9akn8n2/n19Y8XtkG1sDJps3Cq0+RY4fn7bR4ee6zzCtvQF47cTJZJ2452DQOutOudtH+yf3JeyfJwGtTk/vTLTTtGGHJWCwKrtUFYvl/n8BpVK8evd7Xt/TZKC/v96+cHl0kd/GOGU7P6+/lt77dh2Hbh9LS+sN39KWX9z2o41a9/7tVG3fr1CkeVJuWONTI3KS+5X9JGnob3Rtpnzz8/AAAAAAAAAAAwOTUHlUlYJ207oimcSjH8Y78fnKQFNcl/+8uT7f33cLrRJHxImyoy7XmJyX5hgJl27PD5iUnw55cx1miztPV+0BsGtGlhSBjyVQtt/bqHz+pLay8/DAuDOp8f1DrnVCgUtptqNFkfSisrvEZ+gBWerx+Y+aGzc9s+19Gvj39u4RSdYRAXBl9JGyfL/FAtPJ9weVoIn9zbaUFZtfNPhM999T8//ufJ538W0kI0vx7VAm6/zfywOwxm0wJnvwz/85E8Q9R/pqjfNn5Zfhjtt53frv5zX/1rHQb9aWFn+DMj/HyGQW34uQivYVobAgAAAAAAAACAsU1pRGX4x/4w9PKlBWJJQFAulzU6OrpdGBEGWX64FT6rMSlrdHR0m/3DYznnVCqVtlmXhI7VRnD5gV8SshQKhW3C1WS7pNzweXxp7ZCMQk1bl9Q1Ge3ln0/aNLjhMr9cPyROe4ZfGM6lhV9J2X5AkzZSMlnuh1T+NQiXVQtGw5Aol8ttbVP/PP0ALW2/tPLDQNYPtaoFtuG9lixLu7ZhqOi3S1ooHYbv/jVOq38YMIfPrwzXh8GeXwc/6A3bPqynf+xq7eVfG3+9f/y0Zz76YWE4Ajq5b8LjpZWT1kZpwXwiKddvG//+9X/O+KM3wy8UpAXCAAAAAAAAAABgbFMKKqXtRzqGIUuyLG2EXLIuLYjx9/MDJ3+5f1w/cAhHO/lBVjg6TnolWCuVSqn7h0FEGApVG7UWjijzl1cLuNICXf88w7au1jZJgBe2U1jH5Pz9cM2/HmF906asTQuE/bYN29sPH/0QKlzv1zG8hknZfsgchmd++X5QFY6MSztuyN83OWYYloX3hH9u4TMU09okDJKTdvbrGQaK1UZNhsFeGj9UD69DGNKmTe/qB/t+HcPQOtwu3L+acORl+LlPmxo57fz8ax5O4xreD+G2/ufXueiLA8l18j9fBJUAAAAAAAAAAExezUGlpDEDlfC/k238YCUZzZX8wd9fH4YS1UKxcERUMhrLD53C4Cufz29zzDBc8qeddC6a5jQpJwl1xqpX8t+FQmFrABo+v1NKH0EXjkYMwxA/MPP/7T/b0A+F/NF/YfAZBm9J/fzRoH49w+vmh4H+NQ/b1Q/z0qbRDUdm+vdIGAT5bRZew7QQLZz2NTmWP93oWCG0vzwMC8PgLS2sShtpnByz2ojbJATzQ7FwGtOwTmnPZk228afr9ff171F/Wchv36Td0j5j4bUK6xO2Q7UQPQw1k8+GP4Wz/5kJz9c/Z/96h18E8Ns8rb3C+ifrRkdHt4anaeEsAAAAAAAAAACYmJqDSn8EWCJ8Xl84Win5434Y2CWhQzgST3olnAhHM4Uj9cKRVma2zb5+eJL2TLpSqbR1XXgu4Tkly9LONdxe2jY89c8veYWhTxjshCP9/HMIR0D6YaXfVmnhpt/O4b/TwrtwVGAYVCX7Vwvw0oLdRKFQ2DqiNWzL5Dz98tOCobHCMl8Y1qVdx/D8qgVr4bVP2jy8hv7xkmcwJtI+D2mhZlp4XG1EYhLiJp+ZpDz/uY7h8cM28j+X1b6IEF7/8FySz6A/VbRfj7Rw179Hk23D7f3j+W0btl94n/jTByf7+5/T8OeOf52S69HS0rJduJv2jE4AAAAAAAAAADC2moPKcNpOPzzzR4VJ6aPA/BDNHyklbTutY6FQUKVS2SbcSQKFJMAoFArbPWcyn89vExCGgUO4PAzx/EAoDIfSRlmF4VYYevnPmvTLSsoIgyN/FF2ybalUUqlUUktLiySpVCpt00bJuSX7hNfLLzupd9KuYTDlS8r0R8Amy8Pgyt/eb2s/DPK3Sd7DAC0cfRuOlPOP748ATQK68H4LR+D57Z3cB2GAGIZhybrkGafh1K5+W/hhmH8PpU2VmnbfJZJr64f+/mcu7csBYSDsn3damBveG/45JOcYXpewHmFQ6J+PP3rVbxv/eobrwi8cJGUln6HkiwX+9LB+G4TTtqYd17+nkrKSa5tsFx7X5weoAAAAAAAAAABg8qY09asf1vjhiB+o+NNYStuOBPNHjSXr/LDGLzcJIgqFwjYj4ZKXH1CFowurBTd+UBmGK35gNJHReb60bcKpZPP5/NZQxA96wpF1/ntY37FGmiX8IC0MM/0gKTyfMNAKRx+GgWZyjn57hM9JTMKgMMgN2yjZJpy2MwzqkvMKR9CFQWna1LDhen/En1/nMHD2g0Z/1GoScvqjH/1RhWGAmjY17sjIiMxsmzA3Cen86+BfA79MP2hOPhNpI2rT2si/5uG1D8POtM9Z2j0W3nv+yMxkeVhvvz7+zwz/OvrHDANn/3qlrQtHSofXNO2LCOGXHCb6cwAAAAAAAAAAAIyt5qAy+aN/OEpQ2jYwSAviwlAwbeRcEtIkx/Cf8Zi2Xxg+hkFMtZAqkRaqJcvTRsr5oUrayDC/jZK28UMqf58wrKtWXlJOEtwl+yTPzEsLVPyAJ2nLMLBMGxWWFkCnnVNyjaTqoZEf+qRNkRkGQ374F9YzHMEZnktasJcWqvl1qzYqLi2s9oPAsP2S6xVORxoGfX754b/TyvXPJQzJwrA4bK/wvMPRlf45haMaw7LS2iXteGGI5395wa9/Eib608P6n2l/tGQYGIY/D8JrmHY+YRv6ga4fjoefv+S+9evvv9LOGQAAAAAAAAAAjK/moDIMPMIpI6VtR0yFoVH4HD8/dAqnW5VeCS3C0XXJfsm//SlTw9FfyVSp4bqkzmH4kDZC0A+S/FAlbZSdH3omI+78KWv98/dfaaMEwxDID1nSgrxqI+j86T3D0XjV9gnfpe2n2gyD47Ryk3/7gVTYvv718+8HPxT12yAtpPLDuTCo80MoP6ALR9b5+6QFiv424XS6YZjoj6b02z6cZra1tXWbNvLrIGm7kDcMLpPwLvmMJPd7Uq8w+AzPxQ9a/ful2mhl/9r6o1KT0DwMdNOeX5p23yXHC59pm9wH/ghN/54I2zhthGzalyLMbJspdpPt/fNK9kkLP/2AHjs2M1su6RlJ33DOnd7QygAAAAAAMIOZ2emSvi7p/c65axtbGwBAI+XG3yRdWviUhCTJv/2RUkkg4E9X6YcsfjCSlOEHHmEIVi3EC0eRhcFlsvz/sffu0ZZdV3nnN/fjPO67XlKVS7IkW7JlHjYGbNoMA3ISQrrDiJukYzLSCaF7pCGdTnrQSScN3RBMIAmEpEcPIAxwOgGSAWnSCTGE9gMCVgBh/MTYjvWyHiWppCrV69Z9nnP23mv1H3vPc78779q3SlcQWWJ+Y9w65+y9HnPNtfYZtc9vz7lsvzYyjdvtA5NN0xyI+rTpazX1bR/A4/H27eHHYNP6nMfDNqu0fQZV3Ke11YLhlN16nlNzMrjkvtlvFoql/JqaP+sHLaM26Ph4HVrgmrKfwRX7yM4R26y+q+v60Ei9lM9Sa8vCPBXPhY1CtNeDvbZ0Leq6Yz+XZYmyLPfZZe3m+bIR04PBYN81yZG8/MBCX3u8phiwaj+pdcxQnq8v3YeWU9xaQJp6sKAPOrPPbVv2YQz2AddzuVwul8vlcrlcLpfL5XohEpH7RCSKyLtfaltcLpfL5Xop9KJSv9p9+RT8WIho05jaSDaObtP3nNqRISL3Dxzck1GjrTgyjKMOuX8GURxpyO3rfoE8Bm2bU1OqL9SmvhShDJJSaVAZ4tp0rn3j535ZFgpbP1ioxuDOwiQbDcjiflORhLzHIIMgG5XH60D3IrV/DBjVl7Y/HrceUz+xHRyxZ8fNIFg/65zZyDwej426ZX/xnB2WSpXHwTbxWmQ4mQKdKQhpoZxNtcrrwEapsp9tWmDth+2249TrmT9r37pXK9uQejDB+ltl1x/bZiGlRpuqPXVdH4iItP1waliOLtX1w+mPXS6Xy+VyuVwul8vlcrlcLpfL5XLdvI4MKm30oh6zqRktaFRYZCFCX3SXhSH6yvDJRmvpcd53juGJhWMMLLntVMSatbtvTzsGiBaycKRZKv2oKjX2PkBrj/VFaFq/WVhlbbN2pmyxcwhgH8Sx88k+5bmw0Myugb51YSP6LJSza5CBs563qWy5Xba5LMt9c8Z2MEC14+PxWOClx22EJo/FrkE+nvKnHTunHLZjTs1Naux2zlNzxXVZPFe2LV47Nv1zauzWtlSq5BQctj5JzQ3X4WsoNS4L210ul8vlcrlcLpfL5XK5XC6Xy+VyvTAdOV8hQ0n94d/uTaflND2jHuNyWkbPc5uc6pH7sFDLpne1qSmtXdy+/hVFsS+VJaczzbIMRVHM/1T62fbB7TBg036sHzj1pY3041SmNq2mhZupVJXap44vBcEsuDsM9HD7qT9rh7bBfWq/qdSp1kfAXqpajUDVujZ9qu2LI/9ijAci32yqV/WlTXurspF+Fm7ZqED+P48jkQAAIABJREFU49S0nKqW/9QvNhVwyl92jiwoS8Fhaxf7wNazc8p+4gcAuH27tyVLx23n384XX3eptW/BcB9ITQHcVApqO8cWYrJ/7PzZteN6ZUlE7hWR94rIVRHZFpHfEpE/nig3FJHvFJHPiMiOiGyIyG+KyLsS7UUR+dAhfX5GRCoROfMHMSaXy+VyuVwul8vlcqUlInd292w/LSKvFZF/IyJXRGRTRH5FRL6kK3dKRN4jIs+JyEREPiYi70i0tyoi/0BEHu7KXRORD4rIHzPlfhqA3id+b2eD/t1H5W7q3jMxlteJyM+LyPMiEkybf1xE/n13bioiT4vIL6qNIvINXTs/1eOzoYhc7v6G5tw3i8ivdffUExF5UkT+lYh85U3Ox20i8mMi8nhn2xUR+SURecvN1He5XC7Xy0tHjqjktK8sC7hSkIRhZArWaFkb9abHGZ5wH3xc2+ZyLAucuLyNnLKQSNNGWlDC41EYwrL9MYBh6JGKEmW7bXs28kzL8R6Seo7TXPJnC5v60tja8Vh71O66rveNQV9telar1HqxUZ8MIFO+sD6zII9TwKo4da/1hY5TU4Wqfxg+2jVkoRy3x/61wLEvLTH7OnUNpNaeBaXWvxba8vsUAOZUxTzOpmlQluW+tWL3+tS2OM0rz4P2o35L2WzTx9rxsx+0fesnO/d911Dq+6au63m/OkY+5npF6S4AHwbwGQA/CeAMgG8G8H4R+fMxxp8HABEZAPgggK8D8BCAfwJgAcB/A+DnReTLYoz/OwDEGB+SFlK+Q0ReF2N8hDsUka8G8CUA/m2M8bn/HIN0uVwul8vlcrlcLtcB3QngIwAeBPDT3edvAnC/iLwNwAcAbAD4eQDHAfw5tPeKr4sxPgUAIrIG4AEAXwTgYwD+LwAnAbwLwK+IyP8YY/zJrr/3dq9/CcB/BHA/2fJk195N33savbYbyyMAfhbAuLMdIvJ9AP4OgK3OhqcBvArAVwP4CwD+A4BfAfAYgHeJyHfEGK+b9v8MgBMA/nGMcdq1KwB+qhvPZQC/AOASgNsAvAPAwwA+nrB1LhH58q7v4924f6Hz338N4LdE5JtijO87rA2Xy+Vyvbx0ZFDJEZIKUSzA4QhDlYVe+l6jyDTKUMul9r3TuhrNaMFNCqgxXLQAg4GO3a/Owki1k8dtgauty2XUFxy1ZyGghZ8WnNgxpGBxCtjZfTiB/Wk3LTSz85RqM5Xa1UI1TjtaFMXchxZsatRnCvJZv9r+bHSbPZ9aI5ze1qa2tVGqFhzyWkmBSluH1w77JrWfYh+oSwFetcNGIfJ4dZ5simXed5H7TEFL3qtRoWVfFG4K0HM0bN+1x3V5TCkf2HXL/mfoaK8/7ZO/b/i6YPvsGuJxcGQ1l3W9YvS1AP5RjPFv6QER+TG08PInROT9McYNAH8T7Y3i+wH8qRhj3ZX9PgAfBfBdIvLLMcbf7pr5cbQ3Zt8G4H81fX5b9/qTuIFE5BM9p+69mcG5XC7Xy0n333//keptbm7+/hricrlcLpfrD4u+DsB3xxj/nh4Qke8B8HfRQr9/DeCvxhhDd+5XAfwLAP9L9wcAP4QWUr4HwF+J3Q8YIvJDaCHdj4jIB2OMT8YY3ysi62jB3v0xxncnbHqh956qtwP4BxZiSpst6O8AeALA18QYz5vztwFAjDGKyE8A+GEAfxHAj5n29T72PXTsf+jG8jEAX89wU0RyALckxsd9F2h9vATgHTHG/0jnXtW1+89E5E6Foz3t+H2zy+X6QyO9b9b74Ju9j/5Cum8+cupXm/ZV4UBd1/MoI46S6oNIDN445adNH8rtcTsKH7hfjqiyew8yVO0DgnbPOwtWePycxlMhiwI3TgGr9dUXZVliOBzuA74WyrEP+qLcGC7ZdJQMilMgxwItbt/CRoU7DKp43Gx7XdeoqioZxVdV1bwNC9w4Nau2o2W0b5t206YbTfmkrusDKVc5nawen06nc7u1jpZTu9UmPs5rkFPUsk0W/ul65ePWbvZPCGFumx1j0zSYzWYA9qIO7fXFoFR9ba8vniu7Jux7XpN2neV5jrIse9Mx20hsTffLaYpvZJe2xdeX2seQk8tzWmdO48zfOTa1tE0LzWmZ+XvLgkvXy17X0d6EzhVj/DjaJ1DX0D5NCwD/PYAI4G/ojWJX9nkA3999/MvUzHsBPAfgW4XS4kj7tO270D6p+h9+X0ficrlcLpfL5XK5XK4XoicB/KA59jPd6xDA31JI2ennANQAvgyYRz/+BbSRit8V6cedGOOjAH4EwADAt7wAm17ovafqIoDvSxz/693r37SQsmv3Gfr4UwAmAL6dy4jI69HC0w/F/RmDtO1vjyYCM8bYxBtnEPqTaCNBf5QhZVf/WQD/EMBpAH/0Bu24XC6X62WkI/+6zuCAgUqqnAViFrYB2BcRpmU4TaNGPdnoNYaVFsgxEOEoPu5Hxe1YMNg3PguguHwK+DCUZdv4HLdjQVIKVAL7oyLZd9y2rccRg3Y+rd3cDkdkWohl69kUvKmxperZ9lJzYP11ozniqDobXZcCdly3D+imjqfsA/anHk2lve27nlKQPAXxdIwK0+yasnUskOfriv1h+7drS8tw+xZEap3UerB98tyk7LVRwQoTU2PVsgoROU2rtpWKNE3Zx2mUdewpf7leMfpkjDH1SNH9aJ8MfbOI/AKAuwGcjzE+lCj7693rm/VAjLEWkX+K9snVP4P2hhZon0wdA3hPtF8OCcUYvyJ1XNonRr/8RvVdLpfr5aT77rvvSPWWl5d/fw1xuVwul8v1h0WfijE25tiz3esj9l4xxtiIyEW0qU0B4PVo07I+EGO8mmj/1wF8N+he8TCJyDJe4L0n6fdiOurwv0ALPj9wo/5jjFdE5F8D+BYR+eq4F7Wp0ZQ/QbYuot3S5GKM8Xdv1HaP3ta93iEi706cv6d7fQOA3vSvft/scrn+MEnvmzWS8mbvo7+Q7puPDCpTqTEZFFpw0Qd7gINpMlPnuE+GMAz+OBWlygIbBU99EVu6tyLbrtJxcXpMO57YRQIymOEUo1peI/Fs/ymox/V0DApXFNSkwA6PPwVTOO0pl2FYG0KYQ2SNJmPIlfJBURS9ENHukWkBGSsVfcdtqm190aY8ZxbMpSCbRvL1nT8M0KmdvMci92nXVB+wtH0wjOY1xMftGrE+4XSq7Hvex1T7UujH/di1q2OyaZd5Xrg99gcDXlXftcTj73ufSr1s/cQg065t62v7HWS/a9hOBqKuV5wu9hy/0L2udn9AGyGZkh5fM8ffA+D/QPs0qoLKbwMwQ/ukqsvlcrlcLpfL5XK5XjrZfRj1odPkuU41gLJ7f9R7xT69mPYuJI5p2Wsxxt2btOHH0UaAfjuA35Y2Q9BfAvA8gH9n2gWAA1GaL0Anutc/e4NySy+iD5fL5XJ9gelFgUqFBHZfuxQYs3CHIZiNprTRhiy7bx3bYfvqA5IKL6w9FpgdFjGmx+2einyc4UZRFPt8xHA3Fc3FAIbrWHtSQNeOnceViljl8epYbKpStkej0Bg6WWDGoJbnSt9be+14rV8sxLJzxHNio9943rmOjo1ttvOjY+Nytn8LxvrWEdvC/TDw4rWpEYA2DbIFiLZvC9X6IhHt/Ohrat9JjUrkyGb7sACPz+71qvZbaGs/q9jnPD59b+3jcgpqtf5sNtt33afq8Rrmhx9SoNb6y/WK1K09x093r9exd4N6uqfsGSo7V4zxvIj8EoBvEpF7ARxH+8Tpz8cYLx3dZJfL5XK5XC6Xy+VyfQHoSPeKf0Dt9f1osQ7ghIiMbwZWxhg/IiK/C+BdIvIdAP5LtEDxh2KMlWkXAM7eqM1DpON4Z4zxl15EOy6Xy+V6GenIe1RauJKKquJ9AVUKulL7+DGAse3oZ93/kPcd5L3+eA9F27eNMtMyWj8FL+xehSlokYJmCvzsHpU8LrVT21CopO8V4vLeeQpbGAza/UItrLIRYdqftqM+KYpi396CWZZhMBjM9+jjtoAWGg8Gg31lNCqRo0nV/rIsUZblvLzWL8ty/pnH3JdCVF95f08GjbznIe8xmPKplrP9cD0eF/fL9mg99V8KpvE1o/7Rfngu7R6L7AsGsrxfos45Xwtc14Jzrm+hcwr+8XsuYyNAbepZvpZSDyLYaGgLpFnsG+snvY5sn3qNMUBm2/vWm4X6+qrvrQ0WzLpe9vpyadPrWN3Xvf5ubNP9PAbgrIjckyj7ju71k4lzP969fjv20uX85BFtdblcLpfL5XK5XC7XF44eBrAD4E0ikopyTN0r6o+kB35ceJH3nn36HQAC4E+8gDo/DmCENrLy29BC0PcYW7cBfBbArSJyU6lte2wDgK85Yn2Xy+VyvQx1ZFCpSkXUAfvTUFqYpD/wpwAKp2/V4wyIGK5pRCa3oZ8VQFmIdxgIYxsZROg41T6uwzDDwi2GlGoTR55Z2Mb1UtF53GYqEo+hk61rYVnfHKWAJ39mwNUHtQ6DjNof+4Yhmc67iiP2bESbjT5NAUwen/1jQGbhr9ql5Yqi2Ac1U/AqFX1n95bkfu18aHm+prTdqqownU5R1/W8PZu+tA9O80MACu20vvWl9q1gnufHPgxg++M1kXrYgH3EPuH+uLyN2rTlbFtahx9ksH91Xe/zQcoOXo/WBpvm1Y7P9YrRKtp9JOcSka8E8N+ifbpTU9v8c7Q3dz8sIjmVPQnge6iM1a8BeARtqpx3AXg4xvih388BuFwul8vlcrlcLpfrP79ijDMAPwtgGcD38zkReS2A/xlABeBf0qkr3eure5o96r1nn360e/3HInIg+jF1DO3WJdcB/G0AXwfgV2OMjyfK/Uj3+pMissonRCQTkTOJOqxfRAtm/ycR+a9SBUTkbSKycIN2XC6Xy/Uy0pFTvypwsSkxgf0wz+6Xx3vgcVsqjj607fJ7W962k4rqYqDE7VlYwW0zFNUx2/IWPikw1XEwQLXtc+SWtZGjyjg1rYUsqTHqcbaRZaPrLIhR+y2AsmAuFS2ovrB7AALYF93GbTII5ghB9hMrFcmrZVPRfPqq/aTSAtsy7BuOguS1aaMQ7TpJpVflc7ynpf7pPqkW9NmUuww0bT92/aTmnv3Mc8vn+TqyMK+vXV4PN1pnvC5sPTsHKfCq5y3wPGwt9H22tnMZbl/L2O8/1ytKvwHgL4vIVwF4AG0qnW9G+3DPt8cYN7py/whtypt3Avg9EXkfgAW0e2ncAuAfxhh/yzYeY4wi8hMA/s/u0HtsGZfL5XK5XC6Xy+VyvWz1nWgjAv+aiLwFwIcAnET7oOoygL8WY3yCyj+Mdl/HPyciFYBzaCMW/2WM8RyOeO/Zpxjjr4jIDwD4bgAPish7ATyNdhuUt6ONavxWU2dHRH4GLWgF+rMC/d/d2P8igEdF5BcBXALwKgB/BC1QffchtlUi8qcBfBDA/ycivw3gU2ijVG8H8BYAr0F7n75zs2N2uVwu1xe2XhSoBA7CgBS00+MWhPRBNZXdI07bYRikdfW9whwGUinIwpGHtl3bJ6ez5P54TNwXywIWe65v/zsL8/TP2q11LXziY+x/C2Y4Ta31R189hsMKhXQPQzsmCwkt2LPg2kZWqh0K71Jj0Hopv/D882e7bvSYpve18Mva1reH4WHg2a7Fw64NOz6N1rXnU+smBU3tuDn1MtvAffK1zddXql/un8Fyai1wP7r2rL+sTw8DoNYee33b1NPsZwby1s7UQwl94+VrwvWK0BMA/gqAH+xeh2jT6PzdGOMHtVCMcSYiXw/gbwD48wD+OoAawO8B+I4Y4786pI+fRnuzOQPwM38AY3C5XC6Xy+VyuVwu10ugGONVEXkbgO8C8KfR3jPuAvgogB+OMf6KKd+IyDehvQf9s2hhpgD4LQDnXuS9Z5+N3yMiH0YLHr8RwCKA5wF8HMC/6Kn2z7vyzwFI7h8Z2x9NvkVEPog2Rey70N5TPwfgN/vqmTY+LSJvQjvebwTw3wEIXRu/C+B7AVy+qYG6XC6X62WhI4NKAAcgWwqiWYBp4QIDQoYNXDYVGWXr62eGNXxe9wG0f3b/usMio/S8BRgMfRjwMeCxEJQhCcM4u9cdgz0LtLQuR/txuRTwtLDMzpMFd/qex80Akced8j2fs2VTdVM+5JSjPDY7Tp1nC5TsuFIpgy2YtYCPx8N7Q1o7NKKUfcapRtWGFOxK+YLnxc67XU/sO22ToWQK3Nl9Ia10PNZu/mznM3U9cPu8ljQdq14PDFn1WCqtagrUcjSwvS7YxjzPD6R/7bte+LyF0+zjuq4P2Oh6+SnG+CTam0HVO2+izgTA3+/+XojehDZC89/EGK/cqLDL5XK5XC6Xy+Vyuf7glLgftOcPO3dn4tg6gP+t+7uZ/j8G4I8ecv6m7z1vNBYq9z4A77sZ+zrpvpP/LMZ46A8hMcafRZsC97AyP432Id7UuefRRqZ+5wuwz+VyuVwvUx0ZVKbSKzJwsfCHgYlNecrRiRbiaX2O/NNjwP499WwkVQrsMVDh1Jv62YIeCyQsoLPwVZWCpewL9QcDMAY2DH9TUYEKRiy80rYV8NhIOZvu085Fyk7rcwskAaCqqgN1eC/LFGjj/iz0tu1bENY0zb79ItVPNrWrBabq09Ra4L011VecvpbH0Wcn+07btLCNYZi1U0Tmc5vn+fx9H+jksafWsY7Xwnltn8srKOTrkKM4uZxtQ9vVfm3kpcJhfc/Q0KZQZT/zOYb+PCaGz+ybvv1c9ZzW1QcEUrBax2vnVechFfXtct2k/nb3+mMvqRUul8vlcrlcLpfL5XLdQCJSoI1wrNGf9tXlcrlcriPpyKCSI61sVBuwP2WlBXmp/fS4jsKDVDQW7xPYt0+hBTJcHuiHixZocnScBVYcFaZ2cd9sK4OfFOjSVwZVDEgUajJEUihkU05agKv1+8rpewai3G+ff1U6Ht5X0cJh7oeP24hG61OVhaU6Frs/Kdtto1VVNoVvajx9aWRTIJ7nksfEdXjs3C/DUR6LjchkP6T2OWW7bNrZ1Lzb69b6meeJr20eR190dJ8PeOz8wAK/8nWWum5SvkylTrZrTNu214O2z8Dbzqety32wLbaOy5WSiHwp2rQ1X4F2f5FfjjF+5KW1yuVyuVwul8vlcrlcrrRE5O0Avg7AfQC+FMCPxRifeUmNcrlcLtcrTi96j0qGG/yZy1lowXAA2J8WVY/Vdb0v1SLXtxF9NmIuBboAHIB7NwIeKZDFx1NpJVPwJ/Vq4YbapZGjNgJP/caRlHYuuLyNqrNjYRCU2k/Uwhk+xlBT50DBIEflpeCNtdu2a/u2MFr9xFCSo+TsOBm2cX07PtuHLWvbtPZa//cBamuPjeK0oNeuTztO7a8v+jeV/rUvojTGON9rlH1rr2m1m31v9/G01yqf4/lPRdLyOZsy2a4r+/ABX2e2Ld2/1q5zXkvqH96r1Npuo25Ta8Dl6tFXoE3TswHg/wXwV19ac1wul8vlcrlcLpfL5TpUfwztnpBXAfxT7GUHcrlcLpfr901HBpUckcSRh8D+iKWUbNQW17MRSinoxcAgBcYsSOJoxDzPD6SI5DYtMEoBIa3PkCSVYtJG2nH7qfSV+qepQjlSzkby2WhCHgP72O6nqG3x+O2egqk0lhbiqayd1gaej77+bb990XmpNZWCyQzoLDBke6zvU5/tmFKA3PojZQvX1fecrjY1nzY6MpUC2EJEvn5SazllO8+t9RHDQZ63VDQ122Wjcjk1Mz+kwP0BSEJDC8Wtb/SzXYPWLk7BqxHANjJU+2JQyRGXKv5O4T5drsMUD9l/w+VyuVwul8vlcrlcri80xRjfDeDdL7EZLpfL5XqF60VHVFpAlxKnuAT2R8EB2AfTGLLYlJjabyrKTvsJIaAoin0AoiiKfalfuU4fAGHApGCSoxltffWFHlNAKiLzff7YbgZpFmAxTFXZCDGFRanUoAzALCjrg1QWyvA5rct+YdjL4FVlIwhtfzxuO4aUj23ULac8tUA4BbtToJj9yilYOf2rBY+8ryivL147FmBpJJ/1gbXHQi89x4CN/Wft1PH3+Vr3QLURgVYcocp96bm+ehaiq10K9Xjf2dTDAOxXXrtcxo7XwlX+rrF7wHJZ9o+C+qIo5m3zeKuqmtexMNR+t7lcLpfL5XK5XC6Xy+VyuVwul8vlunkdGVSWZblvn8gUOOQIQf3cBysUfmmbCuu0HL9ylCH3xWDDApM8z/elv7TAy0Zf2WhNAHMAym32QVMdq41KszDHRhEybLFj43LsQ/2s/rIpNu2Ytc+yLA9EJCpgTUUY5nk+t1shkPU9gzC7FyHPowWJ1icWMFk4qLJQluszyLNK9W8BWCodsI3w7Itq7BNDPob9are1T9P92nWkbaVgN/ugzwYuz/6y/mVAzLbzdWOBtF2jPFabGpbHreO14NECe9s/r+vDUs+m5saO20J3C5H5O+RmfO1yuVwul8vlcrlcLpfL5XK5XC6Xq18vOqKS31uIA6R/xGdIYaPwFDIw0LRAKQUZD4MjCs9slGIq6s7CFrbJ1rPRgKk9Fi3E0b76UsOqz6w/+8Bjaqw2ui6136UFOXqsaZo5qOxLtWpTkFoozP3wvLEtKbBjwZL1uQVxbI+FbRZQ3YwNdmyp9KJ63MLTVF27Bvh9ChDzeRvxadtJAVKGbLZ9CxztetJjqQhmPZ+y/7B5s1GPKUBt2+B+U+vA2sbzrhDRXl88H/pwgX1wwNrL9tkIUesbl8vlcrlcLpfL5XK5XC6Xy+VyuVxH05FBZQpWWUBjoQeDPN0jTlONxhgPADKN2rPpHy2gAfZHoNnyaq+Ws8cZjqai9izsseAlBYbYlhTsTEEZLpOyXY/3pUpNpQdlf1mwYyPWLGxiqMR7ktp54Giz1P6TKWiZgmU3gkB2zdm2+0CTBbd2vDbtKgMsCwZT7XJbKbs08lJt4899a7pvHqwNmlbYltd+eSy8dtkuO2eHQWq20wK+1HymgKCFshyZmgKlqcjV1DpIrRlOA6upm4G9dNMMN7lPtjF1PfUBXZfL5XK5XC6Xy+VyuVwul8vlcrlcN68jg8q+PdkYdjAESaUM5Ug8CzdtSlR935cW1PbHEIX32tO+DoMcNqqNbeTIMwswFIYwNLRgydprPytAsfBWfcWQK7U/qIVS9ridtxQw5Agyu7djCrCyH+1elSkwnNpHMRWxl0qFmoqys0DR7ofK6oPF9rONnrP7fHK/DNmKokDTNAeidy3MToF3Bne8jm10JkNjBs68V6b1sV4DFlCn0r0ykLTzwv3YuUkBfAtK+frn+eC6nHI5BQT52tbroa7rffurpsai5zmldMoutoMfnmD/a7nDIoRdLpfL5XK5XC6Xy+VyuVwul8vlch2uI4NKG02okUkA9gETC/e4DEd+cWSVAjsGTnbfRAY4DF9UHI2Zgp62PNdTKTxRCJLnOeq6Rl3X8/0qbaRc0zQHIGUKpLENFpzyeC2w4RSeaqv6in1tYaaNkNP2U0ql7GQdFhVox8fwKAU5Feza9WQhH0e/qf12T0K2nyNH2V8856m0xNxvCoryvqM8Dk0tbOef08VyeR5Xqi/rK+t79pWWt3CS66WicPvWXl/aZgtQdQ1pVGdqf09ri31vIbz6j+cs9UADPyygdfmBAW2fQSPv4ZqKPtZ6+v3F60rtYEiq3wOcptrlcrlcLpfL5XK5XC6Xy+VyuVwu183ryKCSUyYyUAMOpnzUchwZxqCSgSaXTcEwfq91GCIweLERiFw3FdXHIMxGg3FZhml2/zoun9qz0o6FYYueE5F98IfhlY2WtFF6PHYGNuxXhjMWBNtIQAtLLUCzEWkpMGkhFftey9tIWa6nbdnIVvaJjaRNwVWes765tXanQC1HsqZgr/WvBZMMkxm6qyxk5rKpNMN2HfbNIdfrA8IWXKb2ytTjFn7b9yk7LVDW47oO7Jj1HLfDIJPXoL0m7bWj5VO+Sekwf/E6CiHs++5wuVwul8vlcrlcLpfL5XK5XC6Xy3VzelGg0kaH8Tkb5cQgQX/ct1FSh0XypcCKBSOp6C8A+8ANAx/+bMGHtsn749n9LxUK2egxm+62L4WpvteISPadtqvtWD/b9hnSMLSyfapsFFgfhOS+7HyxHy0kteVS4Frt6AOv/HojkGlttudS6yZV35a3dvXtU8rAXMurj/l6SNlhQb+FbhakWcgJHEwta/vhhwRUvLb7IK19b0G8+iQ1ButL7stCQxvdzGX7UiQzzLRR03zMrjm+9hh6an3+brNrjm3laHLe/9LlcrlcLpfL5XK5XC6Xy+VyuVwu183pyKASwAFgAxzc/zEV6WQjylgMsFL9AQfTWKYiHFM29kWBKSxMRchZsKiy4I4jrKy9h0WdWUjCUVoMcy185GhJBjYWRlqAwzCRU2D2QVULsSyItMDMRv7ZNmy6UZ4ThmkWtNm+1H4FSzaq0NpnQVTf3Fkfcr2U7exnrWvThGobmtaUIwjVJykQy+l/2VYWH2P77XFeA3YuU6lq67re5xduw/r9RsDVzmfKLl7DFk6mICuvLT6vc6Hg0PZr20kdT5WzEFploz5dLpfL5XK5XC6Xy+VyuVwul8vlct28jgwqD4tYUwhU1/U8OtCCwj5wYWGAvlpgYlOlcrkUXOP3XMa2kxqnTR/LUCJluy3DEXfqA5uek32j7XBaVAuCbfscxWmj/fi8tmH3/mPIl4JNFnSqzdw/A1a130KzPt/zWPrmn9viSLo+mMzj5Lb1nIVRFoilUoeyT1JgnPvpg202OjiV3ljF82QBno7fwk/2k4WUKWDM9qSua4V+1n99EdDqF5tmmOFuyp/6PrVfJffZB5V53mxkMkcn8xh4zlKphfn7xq5lHmtqHbhcLpfL5XK5XC6Xy+VyuVwul8vlOlwvClTyHpAWPjGQY2CVSgerQKIoigNlFVQURWuqBXD8Xtui5OpEAAAgAElEQVQE9kddWkinUIfhjoINhjE2pSWft2CFgY9NY6nj0H0n9RjDJi5rj1uAm4pSYyBpYZP1t4Uudlwc7cdK+Z3XgM6VrW+jT1Ngmcdq/WuhoLVd5wrAgWjG1HxyWmLeWzC1t6q1i32ha9euaTsOC7EtFGR4m4LSDLD5mtF+bHpivnZSvmSYzO03TbNvPH0wkGG51kn5nNeE9bmFuGyT9b36SMdso4HZ16nUydym/R5g/9s5Yft57OxLC4BdLpfL5XK5XC6Xy+VyuVwul8vlct28jgwqbUQfsAfZ+uBOCh5pPT1uo5YYHnAEXV9Unq3HfVnw0gf/bBSYrdMHK/kYR8KlUlfaNKYM8FKRbtZfFrSk7OW+LdCz8NJGiVn/Wbt430XbXsoOPWZTaKb2/+SUp3YfRDtfFkjZ8zz3DJ5sZB+PT9e2BX8MCbk8Q8NU/30QK7WvItezQDl1fTBUTcHzvrnlftlOuy5sulvuh8tZO/qufduX/e7ouw7tOkr1wQ8kWPjIEczWfl5jnG65z+bUdedyuVwul8vlcrlcLpfL5XK5XC6X64XrRad+TYEcPs/RcqpUpFcKSDEQ0igsLa+AKgXStB0FaRa8MazRPtguC2zsWAHsS2ebOq+ysMf6QaMP+4Bg6lgqmsvW1/HbKDMGgOwbBsAWlqWOWyDJ9tq6fE5tYBCW8rN9n1pXet5GStpjCibZDo4ctNBPfcdrTucqBQrZntSY2B6e+74UudaXKViYgr02BSlHq1q4p+UtxLQpie04U2O2kF774rXdB0TZVjv31idsk10v6kfdW5PtsNGzfVDdpoVNRQFbyGvXg8vlcrlcLpfL5XK5XC6Xy+VyuVyum9eRQaWCHmD/j/YMJS00TMEpLpsCHymwwhFxtq8UBON2bVSUtZ8/25S2nH6S+1FfMBSygNRGinG0Ix/j8TFsZEjJkYEpuMf+tODSwhgLcFN7AHLUm8692pHn+b4UvVxWz1lwpOK9BNnWoij29c9phNm/Or9cn+fY+sH62I7L9mlt1voMvCw01vZSezHqmC1k5jVq1zH7nNcQywI07oP9x3VTbaWAovVnShaWWkBoU6iyn9WfPFYLAVMpee2c8Fpgu9jnDB9ToFfTVDNUTvnEjvtG/nG5XC6Xy+VyuVwul8vlcrlcLpfLldaLiqhkcKDQSUTmgAo4mFY1lXo0BSYt8LSAgOFjao85fa/76DG0SUVUcb8MKjgq0UZ66XsL2iycsoDOtt1XhmGXTU+ZijazkWccaWZhJPvdQthUtBhDPgtnrD94DYQQUFUV6roGAJRluQ9iMmiyEYY6Bp4vfu1bMxZUso2HASULQRVepQB8CpwpuLXzyeCbwR+DaAul1R5tI5W6lMEoA3T2Td86LIriQKQhrwcej/WZBfipvRwtFE+BdGsXX6d9fuF1yVI7GZoPBoN5VKxNgWx9aMdtz9nrIOVTl8vlcrlcLpfL5XK5XC6Xy+VyuVwvTC8qolJfGSIwuGDwYSPUUsDLflaIwvsh2mg0LaPHGWzYaDIGD7ZNrsc2c7uc/jMFyxjmqRgmWeDKKT91/FrWtmMhl43g088MBBn+pKJJOcqSy6j4c4wRdV3Py+k5BURq+/b2Nqqqwmw2w/nz5/HpT38aFy9enNctyxJlWeL48eM4c+YMTp8+jZWVFSwsLGB5eRlLS0tzmKl9pvasZNjHc6DneJ9JHrf1BfvXwjPrZ10nqSg6XsM2IjUFxVLpj1Pg2dZLwcpUdDFHVFpYy/MfQti3ZrS9lF0p23kNsq0W7lpAmJozbt9CXgWOXD4F9jkCleG32pD6zrHXuK4z+91mUxLzq0177HK5XC6Xy+VyuVwul8vlcrlcLpfrxjoyqAQOpnxUaJWKHuRoPhttyXBQpXBAUzHqMX210I7r8HkLFTlii8vbKMOU/dwG228hIEMia7f1D/uCx8lRqRY2avmUD+weg/a89smQ0qartXUtQC3LEsPhEHVdoyjaJXT9+nWcP38eTzzxBC5duoSNjQ0899xzeOSRR3D16tV9fRRFgZWVFZw4cQKnTp3C0tISxuMxlpaWsLy8jJWVFaytreHUqVM4efIkVldX5xDWRjZauJyKMLVrwI7Tzim3bX1my6bep9aNBV4qm6aV67L6IiUtKLSQz5bnflNj6IOSbDM/ZGCjglPtWHhprxP7AEHKVgtj2SdsA0eW2jS7qWhJ2xfbaCNHub6ds5R9LtdLoTtWMjzyg3/ypTbDdUTdf//9AID77rvvJbXDdTT5/LlcLpfL5XK5XF/48vvmo8nvd44m99vR5H77w6cjg0qNWFOQmNqbDtgP82xUnIrrAdiXZpVTSKZgIdCmsUztkcfl+iK5tEwqIsxG1TFkspFgFmj0gY6UXewvm/6U92e8EWBjH6bSoFoIlQKfKf+q/WpHWZYYjUaYTCZYX1/HxYsX8cQTT+Chhx7Co48+ikuXLmF7e3sOFjnNq7Z7/fp1XL16FY8++ui+8RRFgdXVVZw6dQp33XUXXvva1+Lee+/FXXfdhYWFBTRNM48A5PnU8aQiDg8DaX0AUcvb+bbzyL62kZTsf9uW9lvXNWKM+4C89b99IMDC5z7wn5r71Hqx+zr21eEyDOr6YGffGHh+UhDV9sM+YVjI/uf9MHnuUg8QMPjseziB7edX7p/77BuDy+VyuVwul8vlcrlcLpfL5XK5XK5+vShQyVF5LAuAGCBpPQsAGWQwBLGwj0HcYWAtFc1oy3H0VAq62ChGaz/DRNsWsD99rB0L22JhDJ9nGyz01boMaBg+9fnZRrKl0vVy/ymotLW1heeffx4f/vCH8dGPfhRPP/00JpPJHDKXZXlgPm0bNpouxjZV7fr6Oq5fv44nnngCv/Ebv4F77rkH73znO/HGN74RKysr+/Zk5PnmaD0bucdlU1GHdm5s9Jz6Scdn12cKlPF4rS19cx5jm+42z3MURTGHvZoCuSgKFEVxAGyrdO61vK5THrcdO/vfrkl7Lel7jaTlNnk/S54DCwUVztq50vOp/SS5vI6ToaOmcrZrNbXmre9T69KCR7Wbr/vUd4rL5XK5XC6Xy+VyuVwul8vlcrlcrpvXkUFlX7SgwgWGIzZasaoqAPsj0CxMS6VEtZCC+1WAoOX6UlLaiEWGLFqH7eIUlxZ6MHxVn2h/9pzCGRUDJWuPrW/BGsOyPiiqZRmqMjSy/Vu/sS02PexsNsOzzz6L973vffjEJz6By5cvYzaboSiKub28ryTLwiaeH7VB/V7XNSaTCR588EFsbW3hsccew9vf/nacPXt2Xl/7Y1jMbdt1aYGu+pP774Po7F/2XwqA2fEw2LIANxXx1zTNfK/OEMIcUFrAp9Ix2FS4h/XHDxpY8GrHwNe73VtVZecgFbXIUJL3gOzzEV/rfZGLFhjyGrDRj+qnPkjL3yv8naJ7XvLDCdqXrkOXy+VyuVwul8vlcrlcLpfL5XK5XC9MLwpU2ihGGyGnx1X843+qrIoBVgoccT2GEbafVFSbLWPhi46N7WDYpGCC39t2GQwdBmK4be6TQaOmOdV6HCknInOApfDX2qufOZ2utpPa+4/3+GP4pvU3Nzfx6KOP4iMf+cgcUvI88PjZV4dFq/XBJ52T6XSKxx57DBsbG3j44Yfx5je/GW95y1uwtLSE0Wg0B3g2ms72Ye3gcfK8MEyz8E1lU+ty+9zHYRAzdZ6hHsNtC1sZqGk0obajkX/Wv/Z64whIa5f1nfWRHXsKQKf6taCc4ayWTUX28j6tXNaCfHvN2vdahh9C4Ho8HmD/9WDn1frA5XK5XC6Xy+VyuVwul8vlcrlcLtcL05FBJbAHIiy05GMMI7gOt5GKurNwz0JKBmHaH4MJW9aCCI2OsvDF2pgCPtZm+57L2XSwFtoomGHoyUDE7r/HkW0MZ2y/dtz8uQ+MAtgHuWy7dV3j8uXL+OxnP4uPf/zjuHbt2nyOGSbxHFo/9kW6Wj/yZy138eJFPPfcc7h48SImkwnuvfde3H777SiKYt530zQYjUYYDAYHIBq3z+uTbWS/2le7FlLHdZ7s+kvVsQBU7VEYx5GeajOL13QfMOu73vjatBDP2mzbt3ak1ra21fewgL1Gra/suuVxpkAwX/8cZatRr31zpe2nvkcYoNoHElJjdLlcLpfL5XK5rL71i07EpqoQASDLMCgEZZfNRzKgbiLWt2uEOgIZsJbnKMsMGwBiluPUHXfhzN2vR7mwhEc/9mHcOioxvO1VGK+s4dq1deR5juWFRTz28KO4/NBngabGaDzEHXedxd1v/Up8/EMPIM9KHD97FlMZ4PqlK4gbVzCKM5RZQBTB1izitluP43WvvwuXt7bwW598FMVwCYtrK6gnWxApkec5ZnWNK5cuYf3aJsK0wqmFAm+8+xYUeQEpx5jOphisHMO5Bx/Bl77jG/D5T38Wu5eewS2nVvHGN92NfDhCJhmWT92C889fQb12F+qlWxHiAPfe8zosLC4hQiAQtP891/sFgQgQEYEYESVDDEDWnmr/EUDQlc0EQAQgyABEyQBEiGSQfeX3+ojd//3zTJBJBszvU7K2pe6//CJx3nYIEZ975GGUgyEggtGwxOJQ8OjvfQyf/NAv44tPjfElb7gLTYzY3JkiZgU+9ch5/LuPfh6XmhLTrU0sryxj4/omxgsjjBeXkSHD9//AD+G1974RO5MJhsMRBsMRYgiYzSrs7GxheXkFgjZT1Ww6RRRAshyxaVBVFep6htmsQlVXmM1mqOsGoWn/qrpCU9etH2NEiN1WGnWNENoyMUaEJqDpzoXQPhwbmwZNExDRZaSSDBCgms2Q5QViaCBZhhAjQlO193whIMSIGANibOdQQkSAtPOJ7l4dsZ2P2Pk6AkHv96Aub+c/z3MsLq0g5CWq7XWc//xn8dqv+Fq89U1vxOfPPYMrF57GdDpBbKJO8p5ihCAiE+maDIhR0MTYrZ6IiADErLMpdusOCHFvuQF7dgIRITQoiiGK2OD08grWz30O5/MlrKysIERdM0AIEe2ERcQoQGwbbdd3+5d11wAkdrUEkAy5CCIaXdVt/b0SQIY9X6G7XtoV3l1Heh/f1p3f38cAQTveIsuwuLyEW8+cwNP/6dN44Nffj+b6BawgoAkRj1+rsF2M0CBgeTng5GqB9ctTXNktMSpy/Kk3LOPWPODJ53fw/zyygVlWtAZFIMT2Ot7e3fUbaJfL5XK5XAd0ZFBpQeJh0Wq2Tl3X+/abTNVLwUZ9ZXjAMCcVWcntWrHtahODEwtxrH3WLoU/qfSSFoooTOHzh0XBMaC0UWC6j6Gtl4I69r2NSLX7Gmqbaq+mY7WpbC1I1rYZfKZerZ9T9ipQy/MceZ7j6aefxgc+8AGsr68DANbW1uZzeO3aNRw7dgxnzpzBwsJCci40CpFt13nRNcB2pYAbQz5OoWrXLqc37Rsvr50UoOuT1svzvLcf9nUqFWtqrdhyvD7sXpwpAHkYFEw9GMAPHPB66QOoqXTINmUxgH3XmAXEKV/a+n3Xm31AwOVyuVwul8vl6tMgD5hMA2Y10EhEE3LEEVAiIo8ZAoDFYQYMAIkRa3mOK1WNaRUxiTW2H30MC0vLOPXae4DBEDLZQZGVCCGiLAqEJiLEiGwwwLEzp1FkGYbDARZPnEBW5CiOH8f1zYArDz6GYrKFhRIYjUsMiwyDMkeUHLU0QIxoQo26qhBDg6aeIjZVB4paqhdDgxgDyhhRxQZbuwGXLm+jLAssDifIcsFgcArl4gKywRhLCxnK5RKjUYksL9r/P4eAGAMky9DUFfJMUFftfeYcCMY4hxrAHmsiLgSg4z3gMlynfZ+JdHimg5QKvrSs7JWNEGTSAqIWXmIOzmTeu/bRnq+bGgWGyGTvvirLM2RZjgCB5AXqyS5C00DyISTPMYvAZGcLywsjZJJDEFEW5R4kE2B1ocDuTo1qOkNWFGiagGk1Rd00aELYsybPgKZBbGo0IQAdEJSOgcXQwj31VwztydbXgiwKBBGS56ih90GhBcaNoq52TmImyJEhIiDLu98+6gZFUQAQhK5TiWE+L6F15x7Vi0BUKtc23Pq3c3bsbEMWkWFeBUBo20F3D15PsXX9KoaDAWZ1heF4hLKZYHv9SgdcA6Lec3YwUNdOJhEN2uutXWv7QaEgIsamq9b6oL3vkznQA7o56MYREBCqXcwicGU6wz13vAZPfO5BTMcjFFl2AHbGKIix0ZXa4tCAzo8RmWAOE0XCnp0AonT3uLIHd2OUdjyiDm992s0oIcu9T7Fb3JnknXMEIhl2N9fx+NYm4qxGPdlF0wQ0AK7t1FhYW8PqoMD25iaevlTjwtUGdRUwyCqMM8EgyyASsbFbo4bsrUWdZ7hcLpfL5XKldWRQybBAf8DnfQn7oEsKbqWgTQpyAPv3ruO9E7kfjpbU9uxegn3RZ33gwUbJAfuhjYWyPCa2VaUpXIuiOAB5rA0MjrhNbUehoYVqdlypqFLrY1t3frOVZRiNRlhbW8OxY8f2wT21QwEggzztn+FWn13st5RNvL6uXLmC3/md30HTNPiqr/oqnD59Gjs7O7hw4QKeeuopVFWFe++9dx+UY9+2N1P7AbPt175PRfsxxNIx8r6GCta0DPtdIWMfHNN6DPdSwJFT7LJ9duxal8Eejy01RzzOvrWRAu4Mae3+qHZ98DVpobCNNLbfBTqP/PCCgvs8z+fvUwCa+7fpnjnlL9vFx1JA1eVyuVwul8vlYuVZjqVxQF5FbM6AWR0xaADJBVUI2JkFILT/Nz1VFtiNQFbmWMoCsqpBDBWajWuQCOTDAerYYLq7i7pqMF5YxGxWIUZg/foWti9dx+LSIkZNxNLWNiCC6xeex3PnLuDs6giL4wECBHUNxKZpI70yYFrVmExniE2DpfEQedZRrhA6LNNAJEdAeywiQrJsHpVYCOZRaHUD1PkQO7MZmlBDiqIFFpA5LMmyErkAoa5RdhF4VV3PwRAkIw9qPYKF+tKyoz1YqSBS/wCIRMzRpHSha2gBpgJY6YhlkNAezwRA1oJKBZldB2xfLh3sgrorADGHZDmyrLtfFkFoQx7bewnJUGUZsqbGaHQM06qGACiLogNZAXXV4MnLm5hsz/DRz34GUg6QlwUkNEAIGC8utiBR/Z9lGA1KvPrYEp67uo7dqkaMAaGq0TQ1JLTRkbFpUCKgbgLyDsy2AKyLrIwtLGv5XUQTIuomINQdXJZ2NcSIFl7VAaFpkJVla4sIQh3QxgQGdD20gDR2MC4Koij0U7Wxiy2sBPaFLXZzqMByHjUrGY4vjbEzbRBDxGg0Rl6WWBmV2N4MaEJADC2AVyiLbn3ValeMiKEdf7tmWltakwKxVP4NqIZEQejORwC5CLLYlguhwcb2NmTtVhwfj3Dt+jpWVo91a6SFdTHI3I8RrV/1ktPbXULELYREBpEwh61zHqkuyzq/xw6w72H9vX/n0Ffm49/rozuaAWFaQ4oMG9s7yPOIwUCAqo1krpAhC+32RFkEmibDmdUxvubWEguFYCUXVI3g6m7dotxu7udRpHC5XC6Xy+VK68igUiMQgf1pNO2+jRY6AJgDGK1n94dUAMGwhgGkfuZ96xQ21HXdpiEhGxiQ2DYtaFObU2CGx8MQyEZa8XgsxFBoqRF97MNU6ldOXal/Oj5rlwW/PAYLp7QNCwk5ktJGk+V5juXl5X2gUufFRuPZSDbuI5Vmsy/Cz8JZbv/KlSt44IEHICJ461vfOt+v85FHHsF4PMadd96JsiwPQFOOgOS++lKrMsTi/Ud57Vmf6b6RFtKxT1LQ24JIuxZ07mxEo9qW2l/VzmNfWlX7amGe+tFGqdp9I3lMbBPPp40Qtg89sH95DaX64c88P7q/K/uJy2g9nisA+8ZnwbKe02s89QCDy+VyuVwul8ulkqJACBGjQcS0CQhRMBjkaBCwvlOjrmpkkmEAQcgFFycVckQMC8GgzLtUmgHTyQQSaoRygGvnn0V58hQuPnsBC0urGJxYwcmVJeTP1ZhsXMHGpYAT4ww5ApZGBZaGOZYXBlhcHCIiQ563cWFtlFmGKpYAWni5sLiIrBwgkzYCUpCjCW2EmUAQ0KbJRBQMywwnji9iOCzQVA1CXSGEBk1WIlQV6mmFYjBGduI21FEgdY2cHqoM3b07oOlIA6JkbSRdBw/36I1SGSEEQ+AKfE+s/IZg1x5unL8XaaP7WmCpZbO9z8J1tche9CXQtPcDQBfV1nbZ3tu1AFayDHmWIzS7KIoBBkWG2EQsLi5iYzJpeywERZGjbtpG6qbGB9//frzqllvxsz/697G5eR3j5WWMRiNkAJq6wvWrV1DXTZt+Nctx8tSt+N53fz9+7od/AOfOn29hqmTIsjbVcA2gLEvc9yWvwebWNr76zW/AZGsTV65u4PqkwtYsYrdusDNrMA1AHVv726i4Ft4WeYZc2ixHZZkj7yAzsgIxyxGyvIWZkiFmgnG2B4dFBJLlHRjOWr/kWRfh2N17df7NpZ2DOJ9LaUFeN0NFUWK8PMDyLWex+cSjQATKLEcYH8P45GnMzj+H3ckUIbT3blHaWVVl83WgsZERErs+YkfAFdwBmKdMjRGSM2AFMgA1AhBlDnhDXeGZ7QpffNvt+M1HHsFmOcJ4NOraAAShg3fdqpaIRglkyIBsDy5KFEACsjmwJ1BPEYvttSJoELAv7FjXf9y7gnTke9dQOzYFyLfdcQbHww5+/dwOsiLHogwwymrMqgYbW+tYWiqxVkZcFWAnz/CqE4s4vRoQmzaatq4Dru42CHQFRtmPpl0ul8vlcrmsXtQelSmgZX+0Zxih73VPwb5ILFUKXjG84chIBjYciZaKJlT4d6O+YoyYzWYoimLepi1ro8O4TF/0GtvB5RnYWIBjQZJNx8lt2gi9vmiwvgg5fa+QTd9nWYZnn30Wn/rUp7C7uzu3w0ZBpqJC2T4bXcqw00avpfzGwOnq1av46Ec/ivX1dZw5cwaz2QyXL1/GU089hXPnzuHs2bNYXFzcV9/6jcGjfuax2Ui+vrGmPnN7qfHYqL0UxGRYZuvbFKoK3Wy0ZCp6kMeWuo44OpHXjbbFcN/alro22R/cBq99tq1vL0wLLvmasPu48prua4/bYnu5nAXndv9Ql8vlcrlcLpcrpRqCqg4YDfIuZWP7/9xZCJhO6xaaSMDxUYmtpkEdApoYMS4yFLkgK3JsXF/H8NLzGGSA5APUF57F0uoCwuVzuPD8GCePfSVG4zFCXiJOK4yKDKMiQ56XWBiNkBc5ZlWDYlIhiCDPMuRZCyvqJmJnGpA1kdKEtpBr/v9vaOrJCIkRwzxDJhGjEhgWgrLIW2ATm5ah5AWK4RDbARgvHwNCgbqqUUiGBu3+haFqUEu7pyHm/wffgxn7/6cezet+tRCMfjOAEGyKEN28T9mjMlDpovj44LyfPbCp0YtqmO6nqOCohU1AjAGCogNy0qYfje0ctvcTDUIURGTYmU0R6xrjxUUsrR5DMRgAdYWmiWiagMtPP4alPKCpdtHMtlHtCrIww6Db9qOebGJnZxuFbkGyMkZZFJhdv4jdS+e6SMLWyjwDqqZ9KPmhbB3HFwY4ObwL4+UCd6yN0VQ5Jju7aEKByxev4vKVq9jcrXB9e4pn17fx3MYuJnXAIGvX1driEMeOLyIT4PrOFE9d3sLGLKAKrUcWBwUGIhgWgiLP26jDPEdAhiovWxid5ciKvAWdXSrgjhx3gDfvJqyFoTuTKXaqFmQvLq3gj3zDN+LC5z+HE2fOoqkqlEWOZz73u/jMI4/juScewoP/6TOYZTlmVY0QgcUMqCXDoiia7H4z6vrNusXRdJOZZ3srMaMHdHPpIm47GJtLhhAipjECor9DAZ/IcrzjrW/Dq0KF9z/wGyhXTyDLBJLnyCFAFrsoyRbcztOwRm1/Lz2voPsdRdpLEx08BoBBLsgFgGSoYptqd542tlu7kPZ9lnWQVmKL47u2mxjbc1mGkyePA2WJa3mDpqkw2Z1hVAIha7+PVhYKLA9zZCGgzNvrYmmQAaGCdHvBTusG67PugfQ5FNVI1eQl7HK5XC6Xy/XiUr8yIAOwL70q/7Cv7220Hkcz6jmGRzadZV+EGUMFtcsCEmsrH7PpHRlYKPhgUKlKAaw+eKvj53opMMU2M8TiNi3Ys1F1FnLaKEYLA+1YLJDSvSGfeuopPPDAA/jEJz6ByWTSC+gO8w+3nxozR/ylUupqGR1HURS4ePEiNjY2cMstt6AsS1RVhcFggM997nMoyxJnz55FWZbJtaQRgnY9sZ9Vdi4YaNo5TEUCWvjF73lObfpTtpVBI9tifcVluE7qmuH56gOlqflMAVA7r/xqj1sfcBtazkZRp8RpWnmOtQ6n3GX/aj99YNyCc44oVcDK8+dyuVwul8vlclllOTCtArIiAzJBDMBmI1ifBCAAy2WGYwsFVso28nI5B2aTGQYDQRUiZlWDGCe49vTjGJ84ARQZhhJRSMTSqEQ1idi8cgl1BpxYKLCNHBu7NWZ1hbqqsT2psDtpsCNoI8IQuwdxBW0AXxuVNaUtExTY1XWDIlPIkQOxQogR16YR0gTUNbC9O8NinmN3FlDVgnFWoEKGSRVQIcfiaAkLC2METNv/b88C0NQQBDT1DJmgjXyL3b2E8V9ERNbFwGlEWOiOzwGidNDHgMYuyGzvEOaH9S1FmXWRaQQtJWo0Hg7UaKNK0dm2/z6njUQFptMZtjc3MW0aVLMag7zE89euY3d3gmFRYGF1FXlRAoIuPWwOSLu/4hve8MUYLyy2cKzIIXmGqmkwret2b8KiTS87GA4wHo2QIeL61iaWS8FaGVE3aKFw6ACwtFGxT5x7FuXtt7bRkbmgLEsMRiMMF5ZQlEPcfvdrMNvdQT2bYXtnB08//Rx+55MP46nLmxgPSiwNCtx++hje+uX3IEx2sbEzw3t//ZOYTJt2YketpHoAACAASURBVDLg7lMLuPfUAmLdYFY3mFWh3atTCsixU+08FwXK4Rj1dBdARF4UANrIwp2dCXanUywtjCAA6qrGpx98Flev76CBIK9OoKh3cUv1PDKcRlbkWFpaxoUnPotnn/g8snqKYb2DcryIrYvnsbG9g8HyEgajMY7V66irWdtOnqHMMmxOKmzVEdM6YDd0Wbi6eV8oMqyVOTJp97YEgEwyjJfGKMoco8EAn3/mMp7dqVu42K2LIhd84OlH8PYveyPwzEO48mSDKgqqTDrgmWNQFu3DCJB5tuMYIuoQ2n08Edv0rlEjErsVGCPqELE5neHk4hCLXUrV53dm2MkGGObtPqIxdOu1i2YcFBp/HPdS1gLY2J1hcXGAQTnEl73963H18QexfOZOVLMpiqxp95UNAU0TEQRYKHNU06YDujnGudrY3itPZjV2QvvAQ5xfw901In7f7HK5XC6XK60jg0r74z0DMIZ6DGE4SouBk4IiTplq20hBSgsILACzUIfPFUVxIKKMpUBjpCk6kIaJDDssgGHAYkEll2P7LBBNpdHlcwxlbbSk9YUdg4W1LBvlN5lMcP/99+P+++/HZDJJpjJNjY1Bm7arY9L51sg8nlfeW5AjMHlPR74RnE6nOH/+PIqiwGg0QowRDz30EJaWlnDs2DGsrq4emDObUtdG4mnbPIc6tsPA1GHgluea7beAmuvwPOTdE7Q8P1apvq1NKWirdvWBPV4X9iEE7YPXJJfn653XB0c/p64HC237yvJ65HS7dj5TvuX3PDbrE26THwBIfX+4XC6Xy+VyuVxAGy21UzXYqhogCuooeHoz4moVsRID7lgQLNcRW7HB9abbgy7PsV1FAA1iBmxPJxjkmyhjhWrpGIp2ZzuUSytYHOXYvnYVcbyI6c4Eu1XAzjRgd3cGie2+clmZoShyDEcDxBAgWZtWM5M2MiuPbeRVUzfIsjbiqoV2AZKXiKGZA8EQ0aaCbSJ2kWFjElCOBXV375aXA2xXAU9euo7FpRXcPg7YuHYBdTZGMR6jbqaAAHmRoZlWyDJp24fGMGocW+zAD+PEzjbY+2OlOHFee++MdFFlcT+EbItTmb16+/9r3/Xf7a2ooCiG9r1kbRSZoLunQ0QmXQrUEBFmE4TpFJPtXWS5YHN7FxmAleVVSJ4jSgbEgDwDQtNGF9Z1jY1pwCxO9vZPzIB6MsGsrjFaWsJgOEI93UUmgiIvgHoXv/zvfwnHRhHlsQKzKqKKbYRgVQVMm4gmCjKpsVYEFKHCICsxHI+AvMBsexPjpTHyosBwUECyDKON66irGV5z23FkscEgz3D21CrO3H4ar3v9XVgYDbB+dR2f+sxDyLCFnWmNBsCr1hbwlW+8C4ura5jtbGHj2jqqqkEtQ+ys3o4ogmI4RDYYIdQVBBH5YACJAdevb+LJxx7H4mAJt73mLmQSMd2d4LEnzmG0FTFpgNGgwMLiAl5z+m48uQPUVYUQgelshtWlBWQY4p6734A4XkK1vYHRsMTdZ16FheUl3LnzOJrJFA0Eo4URBgXw5HPr+OzzE8wADATdfEaUIji9MsIbTowwyNr9OwejAmVZ4sTZs1haXcbC8gp+7t/+Ki7uVJjH2ErE6nCAO4t1XPzcA3jN8QJ1KHB10uByKLAwHmM0GuHk2hqWF0cQERRZG5kZQo3ZrG5BYtbu9VnVoQWPMSLP2t9DdqczPP7sBbzldWewGGaYVTU++fglTFaP4/jiEDG0e45CBIvjIUbDHBkCQt2gzAWhqTAeFRhlER//3DO47ewaJBtiZTzElas1dnd2MZlMceLYCvLJJk4sr2Bx/TrWr+yiKHLsbAfErMCwLDCWNu1r7IDlbNZgFlqIKQI0kaJD/b7Z5XK5XC5Xj44MKvWHfI6iTJXRV96XEtgDBhqtZ/dstFFc9q9vj0ZOH8nHLZDg9wy/UgDI1ld7U2BJxfA1BXn4cwrGWICU8h3XVf9ZGKVpa3mubBmGU3pegbOm6T137hwee+wxrK+v94IfuwYsTNJXhlUM6TjClteG9mMj5uw4Qgioqmre9oULF3Du3Dl80Rd9EVZXV+c+5L0mVRx5pyDwMBjN9fh9CobaNcjH+wAowzBuo67rfetH6/EasdCN0xzbyEvuxx5Lpee1dmo/Omc2TSxf+9Y/PHb2ufqa14jOm7WLy+g1mbrOtJxeu3as1o88tzyXXE6v7ZRNLpfL5XK5XC4XAEgmqJuIpm7hXxWBqs7QxBxNE1E3DVBnmMaApu5AFzRqEEBTAw2wvrmFMJvhRATQNJCqxnBxDc88/gxedfwYnn36PMb1DBIEa6McuURIBozKHBKBug5o6gZNE5BngizPkWUtcIsxQ8xlvqdf+/9doMiKDhFmiFEQ0abxXMjbyLcgEc9d3W7JnkTUQTCQAtfqHI9fGeCewSl8+eIEsd5FFivk+RKaokSWdQ8WNjNFgxDJCJBiTgs7boS9aMa2DINI4/EDn1u4qP/Xl0TpSC0dLMNwszUhzuFmluuelt39Q2znvI1gBIrRGOXCAja3d1HNKqwUgmFZtJASghgiirxNx1tngtAIZnWFzz/4KZy59TQQQgd5MowWFiCzWRuxNx6gnAyQxTY6bnNnF5/6zffjTSsBEYIQAYQAQYZBLihzvR8qcOzYIhaPH8fiYvtQdqgrFFnAYGEREUA1mwJRIFmBTAoMBDi+VGB5aYzbX/tqLB47idHiMhaWRtje3cXq2gJeHRuEWYUGgrtffRInTq4hK0cYFBmqqsa4HECGi4hhhCg5ykEJZAWyQQt0pRygmlW4eOEyxmGK0eIY5WgBmQRk9QwnxjnylQHOXa+wuriAwWCM6WCEZmcCiQGFRCysncSJpkR96fM4uQRcHC9jtLCAE8cW8dWvXsaVbBmvO3YcmE0RY8B4ZQmjcYFRbIAg2K0bXNmtUYWIYZEhjxGvuWUFb/niWzAINZppjUwiqljirre8EWu33Io8z3H/r/0mLm22W+NUdcQsRNy2NsJb7zmOrKrRxAz5aISnL2/hAhaxtLKKpZU1nDi+htWVNQzKHAgNAtproJrOAAQUgjlwnFYzxAAgK1Dmgs3rG9ja3cFbvuwNKDcvYbK9g3PPb2Ll3tfj7LElNNUUTWgja5ePLWJhVCLOJgCadi3EGmurC4i723joqSu4444zKLMhytEQ8dRJFOMxLl6JOHv2FLaenWFp7RjGAPJrUywPc2wgQzkaoywyLAwLSDUDAlpgXAc0APKiQAwBusdne/988EFrl8vlcrlcLuBFgEr9sV+hAEdDpkBCCjIyaFMYwTDORrPxfnYMNm26U61jI6Es8AP2Irp4zzkLw2xKS27LQg9uIwU6GNJwuRTosJFitm0GJ7Ycl+mbFx2HQiJOu6ptF0WBqqrw2GOP4cKFC5jNZvuiPi3gOky2nIXK1hc8z/az9S37s65rTKdTbG1t4cqVK7h48SKOHTuG0Wh0AEJaX/NaZLsA7PNNan0eButTULSu67nPeZ7sGuHPNso0BdosCOdrk4Gxjqmu63n6Zbbb7h2paZVtOtZUdKUFySkgbe1mqGl9lipvwb1N4WrTyGrfqdTQfH2zb1QMUdk3fQ8quFwul8vlcrlcQAuYGgB1BIa5AFHQBIEEQYgB01qA2AKFqg4oClHu1+41Jy2zyyFYWygwKoFsFrF54RmMTtyKV589jauX1pFvXkYV2/0Iy0ELJxECBmWOIs/QhBbG1U1EEyJGWYaOSyKLDULTpgkVAFleoGnafSlFCgAVECMg7X1BHSJmQVDFgNXTp/ClX/s2SN7+37kYL+GbXn0H6nwRzdYW4s45nDqxgrppcHVrigEimrpBNWtQT2tIjAh1DUFs9+ATgoJ6fxXjPPxRulS10h3ey/Yqc2C453xA4ea8rb0THQDkHSe5P8zTb3Kje/GeAZDuYVfEbq/LtnwmAskyhLq9XyjzDAuLY1QBOHvrcdzyzDbWY8C0CSiLAlkUVE2DyWyGHIJQN3jVrbdidWUZQEQMAVlEB5fzNidpVqIYjBG71KkhBOw0U1ydRNyaZ8iKBnVsU28GACI56tiux8vXNvH5py/gNa8+jVwCcgjqADRbm5hVFerpBEUWEaop6tkOdusKk6pBuTvDheevYmka8CX33tneu8V239KACMkFEgUyGCIfLyOTDFKMkG9uY3dnglDlyBZXEfMcWZ4jhoiyLFBNJxBEPPPUMygnG1gcFpiOFpCjQZs+lB5qBlAMSiwNgLtXa1y8HpBnOZaWlvDgs09ha5ZjXA4xGy6grqs5ZK/LEcpigNXxKgaoMBgPMVhcQDPdxcL/z96bNUlypWd6z3fO8SUiMnKpzNpQKBSWbvTCXkg22N2ShpJIyWjGGaPZ2Pwa/QTd6hfoSle6okky6Wo0Y6RIDtnsZjd7IRsNoIBCrVlZuUTG4n42XRz3KC+HJ0hryIwj0l9YISM83I+fzcP8xOPv95WGd986Yr1e8/6TBaIUk0wzM8KN/Qn71w7YmRiUEkJds1xaCmXJ4oroNDsTxdvXp3jrWW0cnsg7t3a59/p1wnpF1BlBZVxGxfFZpArCrb19Dg4P2d07oChyovdpjscEuLXR6OggBEyWs15d4lwApSknBYuzM2Y//zl2tWR56bh+sM98Z8a9t97k7tEBvt5graW2Dq0t2hhmxT6CRymHAPN5weo5KJ0x39tjmpUsRWEme0zLAmOEmzevYZ89YT6fIXbNdL7L67f3eXFRU8YCDBSSQsKmiwZCE/ZV64xADT5dN8oYtPzaP0GOGjVq1KhRo/6Z69e+S+iDmT54a6FSH1L2gcnLPBjDoKsLHYYchV1nYx/Y9SHCUPlt6NkuiOmDjr6DsAVM/fb0c2p2YUi3TkPt7gOTLjQZgkFDjrChvvs8p9cQJOyes/3cOcdHH33EycnJK8ddBSn7IPaq7X33YX/fvjuve1z33EPAyHvPer3m2bNn/PznP+fatWu8/vrrn6lDH1YOQap+//aPucol2N9/aE4NjXcf+PXr158b3TpeNS/7oK1bpz5467ap+3k/zGkfnvbP2z1nt91Dc7n9N+Sa7Ne9u23oO6XbH919+hC8u99VQLlbZhdg93PejrBy1H8u+vgi8Ob/8H/8U1dj1BfV/zWO4f+vNY7f/2e6/z/+m3/qKowa9YWlFIhSnDpPHoVpLuSZpiDDbCoANi4wMZoqBKwVdvImJ55K8EtI96X37t5gsa5hvWaaCWb1lPOVxZ+u2S8UHiGqFGrR+oDRBjEZWoTaB6yPZJmisoHaBXKTytciCZTWluA9CY5BAmAeSPvFkKCflogRuHSwEc3s9uuIzhGVgmYW11KZ6wvBfRgo8wlutcD4Ghsim9WS6Gp87QDw0SccuL2lfnlvrURS/sbWGSmB2Cae7P8mAd3ork292bogo0gHUfLStSktzCNl72uOffUx1JfHiCQgR5PPcBt5lmb9ZQyIsKpraCCOC5AVBZMykhclce1YXJzjfeTa/j5aQ2gezA7Bs3PtZjqnQAw+BfttHKc+BLRS6DzHVmuIkZ3ccLbc8HwTuDmB3Agq0EByReJgEa08y7Mz3v/J3/DG4fcoZhO0UpjSEGIkU0CeA+CqyCQTcglI9GgJxNUlsdCEYAFBKY0WIVQOV1lQQnV6Qrw8QLIMjWJiFHpasrGRWiswGUoZogS0MbgKHnzymLOnj7g+CXg9YXd/n0wiPjgiito6JASIKV+qqATlG7IOonjx7CFxdoOgS9bMUdQ4b1lVwhO/y8FMs3N0jXmhUUYTvKUOHpMb6nXkfLlBNefwSpAi49puThEdGoOmeeCgyNDKo6LD2poYIloCooWdiSFEyJUmimF+/QABLs6XbBYLHn2yIKgT3KLGv+MJdw2Z1riqZn50QGkiojTaZIh15OUEUYq8KBBxaJ1CNqdIxpGDiWK6c8SNu3cof/KQ2TRPaFdptAmI8/gIRVFQ5IL3kdpGTKaAFG42KwsO5hO8NVjv8NWC2mRECUwnJaI0d7/+DdZ/9xMmzyscQjaZ8vbtt7h4/ikZdXoo2AgQGtAvzbXbrJWbvJxDD3ePGvVPoXbdPN5rjho1atR/Pvq1QWXr0hrKFQmvgoL+9iE3Wl9DIK7veoPPugS75XcBTNeZ163zVQClH0LzKgjV1qsPNPp1H4Ji3WP7AKhbRj/EZzdMa9sHfTfYUN/369mFLv36d9tureXRo0dcXFx8puzPAzRDcGmoPkMwtt9//fL686LfvhZUPnnyhB/96Efcu3ePGzdubHOOthD0qjEeAppD5+m/7razO45D86eff7R/096tU3+e9vunf2z3GuuHu+3Ol/ZYY179KujXtxsWt+u0HKr70NzoAs+h8LNtOUN17ObKHIKN3fr2x7QPOa+Cmv2HCvr168/LVv2HJ0aNGjVq1KhRo0aN6kprhTGKUjmIAcFQ+UAdLHOJGFFsAhwoQISli5RZOjZDErBEiAL5zhxtL0BF8okmCKjK40PAas3Cgg2RTEDljuA9HrBAVQfmLqBMYjuVS24+QnJtQnpANUIClyqFdzWAi5HgarxLefgktj43WK9rCIGgHCZqRAneO9AaMQoXYLPesFrXHMwLFJF6ucBWlrpK8M1bi8Qmd2bsgMIIol6aIVvmCJ99KFnkVedju397QPo0vvxka75sclhG2Z4nNuftl/dKyY2D0zlHnuUgJAchzZpdUh5AFSPWepYXC2Z7GjE5K+dx3uPqmnq1IuzspLVWjMnd6Dx/94ufcuPoEBB8G5K3KdttNmRKs95U6JAcoVVIIHZZecJEMErQkn63yYg45wmBxrEX+PT+Jzx5dI97d28TlSJIkys0OKIP6CzB1igKk+WUmUG0Yb6/x2RSNtA69atSUOQK7YUQFUWRYZrwtqIUeZmjAWpYG4OTZlhiBAUnp6c8fvAJO9EyzQqOQ8bhZEaMDvE1cbMgeL+FzHmeU8Wcj9cFta8IzrFeLtm/+TrBTMkXnzDTFQ9ViTaamzsZ3zxSLEQoxYKzEDV4h1EeHQP2csVqWeFjgBjQLlJXEWMUGY7MgDEKQaF1QZ5PUCbHby4J3qNDIDZA3DtBO0dYLonlLiYDI55ZabhzY5+ocq4dzjjYnbJbZihruVwtcOsCWxp0pogxYLQCPCoGjNaQJXduHQLO1yglzHZKjm7dY7ozw6MwIjhbNfM4IgQuzk8JumCnnCDB4TYrhBJRCls7TJ5TFjlrr4geclOyWW1QSigMWOdQJktgfLXm2YlDdq7zX//hv+Wv//h/RrHBhUhByn0bmwcbAqHJsZqcvH3D86hRo0aNGjVqVFdfOEdl9337o33f1Qh8JuTi0A//XZjRvh8CC13A088b2HU99YFJF1x292+P8d6/Esp1KMRpe75+yNg+9Ov3TR9itWCoDye74Vy7+/ehVx9ODgG3fijPfp91x6SrFmxprQkhcHFxwcXFBdbaV8KI/kMaAmtXgdmuhqBR//N+ud1ztsd671ksFlhref78OdZaiqLY9kG3H4dAYndO9+fsUC7IIXdgvz1deNh3+w21tT/Gbd275XZD9nbDwQ4B1qvGqN/eVkMhZvv17ueL7bajD527/dd9iKD/4EG3zH5o3KvGb2hMuvv36946qbvl9NvUnrd7LXXbOFTfUaNGjRo1atSoUaNaaYTSKGYqhTZN3rjOA4sKNg1kmiuFx1O5gJlPuPXma8x29wgI1abibGXRlSMWGRgDPmCjULkmH6WG/UJhY8r5GGKk9uB9glPiPS6Ci4L1kZBFlEqhaGvrsNYnEGM04gJEj4hCa8H7kGBi1ISGOBgBby0heGJQRNqQpx6UYHSG1obDw32qh57gAzF6vN2gRRFo7sEB00Y3QvAhQdA2nV3aJ6HGxl+KSHJvpnv3dj3TwsqGhElvbbX9H4nOtiSzcX2pbv68z3LP7sHpP4nYuiYvpwlUakWUZm0gKR+kCFSbms1qTVaWLNaGpy/OCVmOrSu8d9TOsl6uWa9W7Mx2sM6ykytmZYYIBOdRjavWaIWrKjZKcXn6gvmkIBKpnUML3Co1pfbbEL+bZFol+IAITX5ShVZpLbNz7Uaal85hN2t8XWNtRajBuRrrPHWIVAFMAJ2XZOUUrYQYQwKISsjLjOAcwUeUykDlgBB8E+o3KlzUqCbULSiUCqxWGx48eExmV8xnGXVUmHKHzARC7Ykkh2qmhboZl7IoKI1mv8iRGPACRZ5hgxAwaAErgrcWJQplFGvneXy54s9enPHG0Yz9SUBCIPpIyEveeGOOVooXVlHkGdE7ZmWO1TMe1wX6PKLChsvlEmcsM3/KbDdSRov1EF0K2RoQfAwonebg5mKFnxhcgKAMR7ePmO0dsnd4wOHhdfaPDsm0Zro7YWMtxmjECFo8KkawNVLkxODSbwxaJWdnXaMzQ1HkBHvB4sWKGkVuNCE4tMlRISJE3OqCMxc42nsbEyOYjCzLCTFyuVyCTt8VOsuJXlGUGXblmJQZO5OSTZUc1iLgEfamGc/WGikKvF0jRbo2JKbw0cTmt6oGiseY3OFpvf1rfpGOGjVq1KhRo/7Z69cGlV0o2YKSPgzoQ7s+eOw6pK6CHf1ccF0w0AeffVjTd35169jCjy68a+s1VN4Q8BGRLcxrX/fBX7u9C0OG8mZ2AUkfpHYBT/f8fXB1VX8MgeH+tqGxEhGqquLx48csl8vPnLvvULvKSddtyxAY7ZfxD8G67v5DkLMLruAlcO4CN2PMFgq3Y9iHXENt7devv18fRnbr3c/5ONRXfbdgd79+n3fL7oYjHnIe9udf9xrp7tOFd92xGgKP/TnZ7Z8hmN1u64cc7tY3hIAx5jMAsh2vbl7Vq8a+m0N0CCL3wWt3fvT7q+vEhlfncHuefyy4HzVq1KhRo0aNGvUvT1XjWEyGSaHygRAlAUIPwUdERU6tY88kV6SPkGUZ09fucBFKbu7vsCPC8x/+NTfZEKYFtXN454khASgbofaBZdSIggMJeOeZ5JrCCDiIWqh8MrLlOjn1Iim0agSq2hFjIDMKawyiM6JoRJJrLqAIDaRrc0qu6xrvXBOCE2I0eF9DVIjWoA3T+S7T2TkmrqkqEDHsHeyjz55DjFS1bdxjKS+naLV17EECJOmWu0sPk78yRl4iTBFSWNgmZGrjSI2NSbP9i7Trq9atmQBKlPgSYMqr50vnibS/WihSLj5bb7b7pfVJgsQigiiNyTKKkM7lfGRzcUG9OKNSGc5aYgwszs+pq2UCvpMCFwK3732ZIs+28DRBKo2OkeADq4tzvLeEkEGMTBVkRvHlawZTL9Exue+Uj1TWJzdpFKoqvd6/c8jt1++ii12yIicSMKsl3lq4OMWuV4TaY5crqosVF+drVBAuL9fM9/dREonOsl6vERRKwChBUJSTgqzIaALqkseSWHkykxFFpTmrIlE0Tx89w0RPFCjLkucbxxtvHDVhdBMMFtE0KVaJIqlP44rl8TNiLDF5SV6WPPzlT9l/8xvUrqSuKmTxjLdmEeXW/PXf/pTz5ZqPouMX8yn7e7vMd3fZn8+Yv/F1ZpOCb33VEFFkRrG8XHPpNDHCiXdIiKxOnvD3Hz1lWdX48D6iNeW0pJjusrd3iNYZz04vWDw9po6wDA5dO1wdOT6veboKuNKifWBfG2rv2NiAMRnlfEpYXGJDRDlLQGNdzXxnAqJQSqdZpxTROTarFXmekWlBfM3i9DlWFEZpJKZ56hq6uLO7j8knZCpiN5YU3dkTrMNuakRn1HUaA+8cFAYRS5ZpTKapnEOpgEJQecZ0NmGu5sSqSt8DMYUYRprUSry8fl7+ZqWTu3JcO48aNWrUqFGjrtAXymTdD6/ahz2t+m6wvqOuD7Ba114fGg5BuLb8q6BEW34LOdr3rdp9h3IHwsscli1w7IOyFk62+14FsfpwagjmDTnf+mCvrUsfFA2V24da3bKvCt/Z7ZuiKFiv1zx48CAtQAYgVbcOfYDYH4sh0Nt36g31xz+mn1r1HZJaa/b395nNZsQYsdaSZdkruU37gK07Zt33zrlX6tHWoQ/eusf22zkEW9vj+nkZ+/3WL787n/vgsbu977Jsy+n3Qbfcq8Bz+/7zQGS3Lf3ws5DcxO0+Q9fBENDsAvx/zDzv1qEPoLtltNuuCifbvdaugpP9hwtGjRo1atSoUaNGjWr1px8vuBYjBDASsVFwIYW8XAeoA2QRLmxExcCt3PDh2lFWjtxkKVyr98TLNfuhJuzN2GxWGCJRCYVRKcyo8ykka4CoZBtulBDRWqU8hEphVIJuoQGbmVIoJdjKUdc1zlpyY7BGE0WwLuUiFNVEGGnv1Ul1X60dzjmyzDQfhwTzJMHYKApdlJSzGX5lqe2GLBckK1L+Ou/ZrNcvfydoA7I29XzJDZOXcgsTm20JRzaKKZBryzTTPXp7/9/c2zefxVTFZLqU2O6WypRtcbQwlO1x7bnTmsLWVdMnL92cSitA4yPExuVm8oLVckUpjtdLYaEzHjvLxrkUIlYE0ZpimtatH330ATcODxGJ5EVGRDftFjKjoXYIglEKLYqdXNASyXQgSNo1xEjwqf5ap2C9OQpRmrffvMPh0S2EBFuNMWRFmcDo7gFZnuN9alOZKfamGWWREaxjs96QHLuBqkp5OFUDx6ICnWlCSGFHkQRufdgQlEFEJaeuEnb2jjhcOk6fPgGjWXnPMmh2d6asawtKISESYmxctmkOTHLDchNY1S/X3dWmYjKdUWYa7Io382ccvl3y7n/33+Kcpd6ssc7hake9WaYwxsqwrDyL5ZIaRTHZI88LJiZQmIy9aMinO9TLCxBYmw2ZW7NYrqitY7OpOa8tmILjpaeq16xXSzIDT07OOFtcELxn4+Hj05q6nPHGNc/J+TnPnj1GaaHcOeDoxg0mWQLfIobbb71LMd/BvnhEVVconeF9gO3vZLBeLsnyrAlnLNjaoU0BBHSWNQ8TgLOWs/NLrr9+g3kbEwAAIABJREFUgMSIdykMMEqlsbfpgefl5QY1mWGd5dwF6qpiaiDYmtpDOd/DG0O9qTldVuSTjE8e3EeCh+AJrXu5cXi3uSljTKOmREEAF9yv/2U6atSoUaNGjfpnrV8bVLbQoXUjXQWX2n2HQMIQFOiqC6T6MKILHPqwZwjY9GFUC0768KZ7bD/c5BBgHIJd/X5ow6jWdf0KOOo6Hq86Rx+qDvVd15XW3dYPZ9kFwH0Hax+qtQC2zfXYdZb1QWEf8PXLG+qvoTb1NbTtqnMPHRtCoCgK7t27x/Xr18nznCzLyLLsM/Oh2/bumHbn3ucByaE52C2z3bcLH7tl9qFa//XQ+35//ENwrvswQb+fhuZ2O+ZD10nfndjv+6G6DtW7P0/6ILdfx/5x3fp0Qxr3QWZ/bPvfCW07+w9HtGPTBdL99g5dT6NGjRo1atSoUaNGAXz8YoU1MJfATGnqAD5ECAGH4oUXoovsZsKZC6w13CoNc2+Rp8foEFk9sphpyeXOnGmsmUxyFIHaevIs5a/ThJQPMkS8b9YF0aN1AhIKMApCgEDAiKTPGsAgEerKoRC0SmDJ+JjyFioNKrnNPAlyEpvyki0UnZeN80uRTWaIUkQfCKISSjEG7zzOOo6fPuNaCETn8L75t73fT7AwSpPnERL03KKXVum+P2xhSGz4pfAyXWUXIL4ElpF0HmKCulu8uYWWL/cPsbNW6Q6spBC1ztkmDGzaQZrPzi8vOVKCr2t0ptjdyVltalZOc3On4PWjG5z86jHVek0IHq0UgeQ8884RNwvE7VDkJZPpLojGB0ddrdnb3+Ps7By1WqJVWrcXBu68fhez/pTlesPSR7KYQsDGIHhJwE+jeP3Wdb76rW+h8hyVF/hqSWxscMFbordok5GVJbUYHi49LyrhQHmOMkVmhKALEIXoHCWNIxWwLmIrh60tImn+VFWgWm2w2iDTJrSwGPLrb/P+Tz/kZw9f8Pp+wZfuvsnrOrkutYoEn0LVojS6mUcgTKYzVLFDXs6IL04RpQnecnjvXaIpePbRYzJ7wm//zh+wPxcIHpF9YnDbOSEIojJWVnG6DITgEGXQJuPmjQPi+hQXFLqYEeMBEir0O7f57ehTHxFZnp3yf/+Hv+TDx+fYzSaFUw6p7KqusTbZeW1ULCtHyAJRAriK5VkFRC5Pn3P8yftpPkpyMX9w/wEH16+jqgt2SsOkKFDZhMl0h7IwBODFxQUooaodRFiuVogxVMtL1GyefqdrE7w218/y8hJvLd5aYggQFXVVU5Q5kyJnHTWZhkLg6aImKxIA3diUl9bZmhyP+MDFs0f8/INPebfwDacXYkjfO6va49vwy0SiqDS3QkDLZ1OqjBo1atSoUaNGwRcElV2Q1zr9uqFKu8BgKIxkH6Z0QyoC25CpfXckvIQHbTl9uNCHNP3cim04yW5ZfUfoVfkhr3Iydp14/f3yPE9PXFo7CEDbv31nV9uvfVDb1q/bD93P2nr0YWgXmnXHpQ/eutAny7LPgKQhXQUuh6Bdd/vnldPf3tanLEtEhOVySV3Xg8cqpZjP59y9exelFMfHx+R5vgXHSimMMRRFQZZlr9Sx3w/t6344135OxyHw1ndkdsdrKExpOy5DOV+7uiq0cjs3hiB39/xXPWTQH7shGNy/vvuAsQ/uhurZ76f+90Wrrnu0D3qH6t62bQiW9sPf9r9rute/iLyyvdvvfdB91VweNWrUqFGjRo0a9S9bMcIqggpC5iNV8ETJCETWHhwKasdOlsDcygcuvGcNvDnJKQ4OiTGQFRnrjx9wfVYSgqdaLiA4DFAaIAilhpnA2jf3yh60yRIEkwaQ0sJAaNJQYky6762tR2U5SqVwr1mmcU5AVArZGUOCgLEBn4DznnpTU0YhSIKESmQLFaPSGFOCyRMA0wqco1qvUAGCc0QfcHWduEZz+97exQs04W0FaeO4ksBLd79I3ALK9Oel67K3emcLL7cAMr76adyeBrq3+c3pW7jrvcdZ26lHhJhCZFZ1xRJHiJFMa4qyIChNSaCcFriiQGtDUU4o8xwPVNWGuqqpq4q3v/R1iklBXk5QqyUSA7aqmU4KLpZr6vWSeabYLTPqGLhzuM/vfP/3uP+n/yvH0fHRKvC16Zoyd02OUoEYKDLFtYMZRampL88I9QbRgqtTiFVnLQTBVRZbeyZ5wb4R1q4m9woVUz5ICY6PH19ytnLUPuVmFCUUuZBlCUZCxNkKX9uUt1QrtMnxzkMMfPL3v+Di0afcvnaN/aNDbnz9PdTihMsXx6jG8hpRBOdYOc/zTcqxqvOCXbNhRwU+Dh5tMiZFwf2//yk33vkNDg5vcIfIdHefrPRIkwvVbZZE7wgxuYR1OUu/L0Sol+dNqOBInglEgyxOCOs12c41gpN0bWjQIceuLiF6MiN4uyG61G/Reza1QxMxzUMCPjqsC+Q00FSl6yQgSIgJ1DuP0YZIxcLeZ3PyAIkBo0CJIoqBLEvRiVTGkydPoCj4+a8eMJsUnDw74XRheHz8nH0byIwmBs9ms0EbQ6Zav297TXlCNFTWU+RTssywdhqPxhsN0TMtM3y1obKOGCzGGI6uH1EUAeUL9jcbSh0IMWyvnUBk7QI+avT2Ak65KtODESOoHDVq1KhRo0YN6wvlqBxyVXV/6O/u24Z37cOY7t/2+CGHGrwKM9rtxpjPlNkNxTgE1tr6dV2CV8GabruGwFAI4RXg04cbIQTqut6eqw9CunC0+7rfR10g0oWU/e1Dx3XPdVU+vv44KaWo65rT01NOT08HcwL2+7Tfj31Q1B2Tbt2uGvs+7MuyjKIoODg44NatWyileP/99zk5ORmcf1mWsbe3RwiB+/fvs1wuqaoKEaEsS46Ojnjttde4efMmRVFgjPlMv/Xr1q9fHxj3c592+6Kbi3EI5vf7pg9Gu6GH+/C0e510c7EOuUCvet8ee1UY1O4xfbdlP0xre+4+IG9f978/2jo75z7T7/BqHsmhHJpDDxp0YebQAwbdtvXBZ3ech8YoxvRARbevR40aNWrUqFGjRo3qKyBoIpmKBFKexwh4DzEGQkx5HwUodMJqTieSGPOCcu8aMTjKyYTl81OywmHragvSRIFSgoSAj6Al5Qvc2MjZxSWxgTTENiKSIiZDJ0oEY5J7MQKXVc2Tpyfo6IlErE+1jSIE36w9CYSQYF0ELtaWf/8ffsC9126i84zKe7xobLGLn+zyxqrG1jUKlY4jpHyXzhGjJDehMcTgmsCeSd3XLXxU7ZsmT+ZLkNg65KRhjwnHbG//JTkmt/CxyUmZPnrVpUmUlEtvu1m2YWLT29iU1bowuzVOOxmleHNvxmuTkMZGhCzP8MqQWYtS8O7NHX72SUkIgfnePuv1Ko2rrSEEgl9TS6Qocpx3EByTyYSLyxXLFydcy4V/93u/y9OTS/6fn/2KuHeH8uAGq6B5/zxwugrMo+JuFlI+yZjWk+/cu02hIu7ylKrOcCZDmYzgHYICUVjvcTaQZUJZKvZ3Mqq1YXeWkWnFcl0TQsSvN1ycnvN8YdlsImVU5EZhMg2xBaQRbTRFWRImEy6jR2tJTlsf+Z3f/ze4esWf/6e/4Ae/+JS7O3A42UFCYLO4SP0uirO15+kqEpQizwxRIGpNDBGlM1arFavzE6KrmU4ypmZGURboiW7yc3qoN2mexRSOFhECGu8qRBQxOJQ2QCDGQIwOxKK0ISyPwVyDoAghErwjBp+An/fEkEK3xhjItRB9xLoUBrkOkTpGSpUMu4SI0gpB0Ai1DRAj3jmy3KBxBOtRIin8rggOh9us8TGFwT1+cUFUir91FxS55vxyw/FmyocfKiaTJxRFTpbluAhv3DmkKHJKFVh7R2ZSDlgRsLVltleQGUNwgvc1MZ/hnSXPCoz2+AhiMnyMrDYVl3nG3fd+n4OH77P64C+IIX2DKWPIjWFZn6fylcZoQ20dSNPnfPY3iFGjRo0aNWrUKPiCjsrWkTQEdfqwoP3cWjsIDbTWg2FbrwJvLezoOse893jvXwE6LUhowcoQBOmrCwC7zqwu0GtBp7WWsiwHc+h1y2/b3dahn2Mzxohzbgs5u5Cn7ZtuG7p16kKjfru653LOfQa0dR2ZLWzSWmOM4S//8i/54z/+Yz766CMuLy+3+3fr8A/1ZTeE7ND+n+dEa+tRliXz+ZzJZML+/j537tzhrbfeQkS4vLzk/Pwc2zzJ2nXhKqVYLBY8ffqUo6MjjDHcv3+fuq45Ojri4OCA27dvIyJ88sknHB0dsb+//8rx3T7pg8puH/fHawiK9UF7tx/70LE9vu8E7sKz/jh0cz/24Wi3nu3rPqDrltkPUdzNaTrkGO7Wvb1u2rnZtrsPYWHYLdqfE/0wzf28l/38tUP93oev3TEeAo3da6nfZ/3vlq7jc9SoUaNGjRo1atSoVyQpn6OIYD1EidtQmapBWwk+pPvmXKsGloGrK7QxeNccI5oQHN4FQvCISj/8JydiOgYEUZABDz5+SKYVOoKSuIVmIGgd8SHgPCitybRQ146HHz3ATqZUXgiVI8/TA4Mi0oRZfdk0A9Te88kvf8Xu4hijFbauuLSBjZmxKG8z26t4uqfQRYb3luAsEHE+IhiCcxRl1uR1DMSoIIaXwFJUym/XOLNeQZgNUHxlbRKlCQEbE5yV7ro8gcg2PGtbRpQENWOkyY3Z/AbRufePLYZswGgkjUmWZS9dajGNhRK4tVdy785BcpmFgNKCiRqkhhh55841rv/dUy6WK7Q2zHd2cdWGMs9BhANjCUrYNVC4JarcoVouKZYLvrY/463Dfa45zWwy4+LaHs8//ogf/uSnfLiAFyvHvnIcGljEjGvGM80UPkay2RyNQ2mVYFkDxXWWEUOaE9GuCFVFKGekqL+ayaQgn5TY6Hn87ISoS9566x650bz/s5/w6YVjgSZXmktHE/ozoPOSaNcEwDmLDz6B4yhcXCz46d/8jLw0TKjYc6fEKueN7/4eH/zoz1JnKw0SCTHgGzfwpJywcDmroPH+RYLsywV3v/wbGJNx+ugZx/kSk2WoNv+oCCLNb0kq2+Zcja4i1qv0YLApyLIijb8ISmdgSmJ9Cb5Cok9zLgZi8PgQ8CFADAgptG5zyWN0uh6FdP2HmNyaBE9QoKKgFNuHGLwPVHUkKkUQhdGyBfNRVDquncXeY63D5IaqtnjrOLusWTs4fX7MuRJEdAKc+YTX7xxRWUeWg2ghy3QzBrCxjqLIMcYQAhTisJuaqt4AOc57bIDoI2cvTnl6/JypXOMtpVifnaCix8UU3lW0YTYpqGMkMxoFuNDkKSU9mMHAen3UqFGjRo0aNQq+AKjsOxC7r1tw4JzbOh67n3WBRz/EY7tPt8wufGmPaR1mQ861IXdkF6BcpS6I+Ifa3UKRNt9ht959oNhCjaschV3w2A8x261P//hWXZjVB0j9/ugDo+7+LVQUET799FP+6q/+ih/84Adb51j3mP7frtrckLdu3eLWrVsYY3j69CmffvrpFpYOzZ/ue6UUZVly+/ZtvvSlL3Hnzh2m0ynT6ZT9/X0ODw+x1vLkyRPOz895+vQp+/v7zOdz1us15+fn27ny6aefYq1Fa83FxQWQoK33nvv371OWJbu7uyl0j3Ps7+9vQ8H2QV+/j/shdPtjNgQl+/OpC7m6ZXfn1ZAjsT+n+nDz8+Zbt/xuPfvzp38NterncxwChN16dSFt/9zd991rpv990r5u1V7L3XN3IWq/zleFch5q6+f121Vu5FGjRo0aNWrUqFGj+hIEFyJoYeMDNZLyIoaQwpUq8F5wAWwIKGVSuMgQqTYVQkTnGUHA5BnerWmje2zXmQqiCwiKtQusHOwVmnB6glOK0gjZrECJBgJKXt4ThxBRkkDmJM85ONznwemS2mqKaYHRBhdBtCI0kE9JQICpgpmGN/cz9qcZJs+wtVBsKjZ2w3T1IbODI4Kr8LECVIIk3iCZIrcB72ryvECUaXJfRqSJ4ZqYanIuhhAbx1pEiW4zTiLSONkktb/BwgAolaBhuyQQaVyPsg3++nKcWpjyEknSWjZVuy5oYGkb2DbTmp2dHaTJwSdNf2pjUEajO3BMa42ENB+UgvlsyjffPGR1fsZ6s2QTIW5WlOLB1tRZSV5MePfWHsvHBRd1xV4mvPnGLbSzrCXyi/sfcLnZ8OzFirV1/PW//9848QodFV8/UNwsHBcVMNnl+791j1/83Qd8+MGH3Lx+wNn5OXs7U7KiQLFBKSGESF3Zbd7RanXJermGmKDcpqpY2RdsJCc3gXKSobIc6zwPFzVvHk05mBjspuLjZwt2ZlMOdgqyWUZ9ebkF9jEGvA+cPHvKow//lnv37vA73/k65c4Rbrnmh3/+J5Tap3ShREQJWqSZp4rppMSECh00IXiyLMMoxflyzf40YCQg3pKZDFG2iecrmGKGlzUt/BNlmEwytE6/6VgfyfMmrLApMbPDtG9wmNkBqCYXZ/ofShTep2t1C7olQUpiuibrALWPeCBvHnLVWiFKvczjakNyZcaYQu9KjpFIkOTCzmge9m3mTtCCj5GpUYgooqTvGGm+V0KEEB3eegIZmUqPRMQguDa1kEpr2MoGprlB6Sy5v3NDtIEYAkWRQVzhfcrLudrUXLu2SxE9f/HDH+FPj/mqkm0e18sq8Mmy4pEzHB0ecnz8rMk9C7WtUKJQagz9OmrUqFGjRo0a1hcK/fp5aiFB190Fr7rNuq61IWdme44+RGlfd11b8BKeDIG6PpDoh8Tsf94HhN1juvkb2+1DoKcPXfphXNuy2n27IWSHXKWts7LfD/26fl75V8HP9nUL6D788EPu37+/hZR9V1r3HF1oGWNkNptx/fp1XnvtNQ4ODrDWsru7y/7+Pi9evNjmauz3fVvebDbjtdde4/XXX+edd97h3Xff5fr165Rl+Uq7rLV885vf5OnTp8QYuXnzJtPplIcPH3J+fr4t9+zsjBcvXqC1Js9z8jxntVrx+PFjQgjs7u7ypS99idlsxs2bN3n77be5fv36K47Kz5tPrfrOvCEnY3f75wHbIYjY1xCIG4J0Q2Cye/wQPOzO17bsdnv3um6PG7rmum0eCnHcvS6G5lP3dXdb39HZ/e7oQtG+07E7Dv2wz0PAst9X/X7obr8K1I4aNWrUqFGjRo36ly0RCCK4CJsAlojo1uSVnGUR8FEIIdEOrRVZDDz44AHPXqxBKSwwF8f1ewfoLOX/UxLRKt372iZkqQ9go3BWe25oBSEiotAqASIi+OgxSlBKQBJ000oQoyjnOxTrCvFgvceElFcwdHM+xtYlBpkISqf8lXgHMZIpIS/A2Mimtnzy/ALta67vaJTJ0HnA5Blm4wnWobWhsnUTFzOdBWn+ISlcbGxATBtCVlpo5AkNNJLt+qJzbx4bv2NsQ7+2rkySfbKFj9KcN778A511uSQM2kQMBUj5J8tZ49Yjhc8MlijJCYpWSEx9q5uol4pInhl25lP+8F99g9/91pf507/+Bf/nn/0YbM33f+cbXN8tWdSADeR5xn/xm1/lxz9/n4fPTvnhxSXziWE/08zLnOdnCzbeshbYWMs8L/jmO/sc2BeoKHz17h57h0fcvxSqKHjneHFyxp/8yV9x8+YRt1+7xd3XjyjFJGdtnkFQROupN2vq1SWL5YqL1YaJD1xsAtnePtseioIPgUUdcCFQqMhrN/Z4842bXFyuOX5xSaVyJlkBkm07zzrPs6efcvNgzn/57a+yN5+hdw6YHN3g0a9+gguRk1XNJkTc5TrBQASthUmRsaPWxJgiCu0dHBK84+mHf8d094A3b9/mwBm0UduxR4RsMseUOwTvkmtXFJMCptPkhI0hNsMfiaKRrIAIEjOIKcxruoaSMzCKZm09WiuUbbbH0ExfIc8k5WENgQCYLMNoRWYMSpsEHZvr2HnIlMLaSD7T5DrVJ4RIlqVwzRIT8CSmkLCFhlwiqJDmYmYwugkl7ZNT22QZ8905e9OCYDdbjq9I12xVW4xS+AC1i6xijlEJsOdaYZeejfW41YLKWnKjWdeOTz94n8OpR00DsfmuWKxqfr5QnNnAzaniJASM0ljviN7jcTjGdfOoUaNGjRo1alhfyFHZQsK+W6rd1oKBPvAZCrfYhyztObp/W9jWBYZ9ANR1enXDdvZdmt1jusd1z9+W3w3H2nV5dcvrft6WMZSrr9+eLlS6anu3zl0YcxVY6udAHHKm9c/T37ZYLFgul684UPswZ6hNAPfu3ePb3/42MUaeP3/Or371q22I3G47umW1Y7W3t8c3vvEN3nvvPb7yla9weHhIWZYYY9Bas16vWSwWbDYbjDHcunWLr3zlKwBkWcbTp085Pj5ms9mQ5znL5XILYLM2+XyM21yISilWqxU/+9nPmM/nnJ6eUtc1ANevX39lLD9vDLtzaQhM99vcdzx253J3frd904K1ruu1DwO7ZffPOVT2Ve0YOq5f36sAZx+etnVstxljXtned1j3+6n7oEP/X3f+dsPAdt3a3vtX2tyOY7c/h0LZ9uF7F84O5Y0d81SOGjVq1KhRo0aNGlZyRSGwCZElgonNfS4JYqmQ6EGbKzKBLYVfLqhWl0SJbAKUOxPU2+mBSq0N0b9c02hJIVELnaBnusdWoEGrFMaUGBF0Ah0ErE8OtRSeUnA+OanyLCPXgcxkVDZQKpIzKvjm/lcIJBBSe/jVSUVEczjPcM4TQ8BoxW5hiJslDz74CK0MB+/epsjSOU2WU+Q13lu0zhDvUS2gbJQMlSl0pygBUYkDJUtomz2yWVO06/lm/SudEK+xxWoNtGy2b/NWxpT/MhIa92QqOTRgUaR1WzZlxNi4Xj2LxTnFdIeoSM427xNajTGFUo0e7zUxJueb1kJuFOWkSPkRQwEqY1NbPHB4dAOT5VTPPiaUUy5Waw4L4ff/m+/xw7/8IfcfnqBFqKoEmLRW7GQTfGVZes2//lffYW+eIatz4uULbh3tYmZzfvLnP+PTZzU3S4W2nvMXZyzPFxw/O6F2X+OtN26TaUv0Dq00og26FKLJmE0KHp9XPF9Y1quaNw+OoHHABr+hyITv3Z2yMyswWiOhBr9hd2rYmxWcnFzwycNT1vk+pb7G1ChWyxWzXPFfvffb7O/PUfkOB7fvcv7kI5TWrC83/NUvH3P/yXMOy+TaU5Kui7woqM0OzgnOPceFDavLS45uXCfXkVCvsbEJlxxiw7+F0FxfUenmOohbFy0xgBKkBdoxIu16l5dr4u3cVAn6Ols18yiFp5WYHMpCmg9GAUpQosiNRjcuYWkmlMoy8jwj+OS8NLlCN3PeaI0TEKUwMV2DIBiTeKPWCjFC1jg9U5hkSXNYp/XpZHfOdDIB8URRaKMhWgiR4CO1deRGs9nU1L5AhxovWQotLbDZVNRRQCmqoDldVPg64qOmUGCU4IUm76bwzo5w/2nk8cklThTWu+2Vl4Jdjxo1atSoUaNGDesLgcoYX+aiG3ILDv3438031/2sC2CuAqDdPJbwEqK04Vf7jqx+eMcu2GjDY7b1aZ2EfbDSd4C2f7ugpLutLbuFS2kRqV+pX9eR2QdGXQdj39XW3a8PN/uhONtz9KFXvw7dfukCtzzPmUwmaK23UK9fhyGnXpZl3Lt3j+9///uICA8fPuT58+d88MEHr4z7EICdz+d85zvf4Y/+6I+4ffs2RVFs9/Xes9lsOD8/5/HjxxwfHzOfz9nf3+fo6Ii6rvnkk094+PAhdV1TlmXKF9K0yxhDURTkef4KGFVKYYxhMplQ1zVPnjyhrmucc3zve99jd3d3e/52LLv93x33fn8Mwa2+g3AINA5B4Kvmc1u3Iejc3bdbj/62LuzrPggwFJ65O8e69euHVR0ClsA2h2zfMRxC2OZo7eec7fZrv539ueuce6XO3TEYgqvdOvbzg/b7qL9f+7rbp6NGjRo1atSoUaNGvaoErTIl5AKrENGiUIlkoLUiesGnaJK4CDoIJlMEG5jkyX7pJeWxIwo6L9CZwUePhCYtioAYha0D2iTPYJ4pHFB5wHlmpcZGT4pEm47xyUqG8+C8xVmL0gZRNcvVkjIzxCLDO9vAm5DgCynvXiSioif4gMkMikBwMUFNIh6F80IVLV40SACVHkI1WgjOEnVEa2mZYqfnIG1ptsaUCw9e7psgVOzdkzdAUtJnV92rJzOlAB5Eb0O+ioDElyd4WYPWnZeO9z5QrZfEGAgx8OjhIx5/+Le8+9YbySXrPCFadK0I3qMbUCOA944IGALV6iKF2tQKkylQisnBESKKy8slTx8fs3+xZvfGDb4+38N7zycPHzGf77B3sM90vsvTZyf81vVD/vvf/13OXxzz2p3XePHihJ/++Cd8+MtT7i88y5BzuYm8M6mYxED0gdOTU/7mB3/Lp4tIuTdnGlb8xq0dJEZWyyWXFwsqG6gqh69qQojMJgVAkz/VE4IwK3MkBKrQjFFwxFATxFDmilvXdljrkqdnJ5zWDlNM+OZvvMP+fIaIZlM5tFacP/00PVQqwvff+y7XfvY3PHr0YAsCURpjMgI5Fog+pHClRHZvvwU649njJ8z2c4TwMsQyEINP0Du9aaZHfAmyGxCYSGVI862Zgi3QblaBQKTarHHWEX0kxgTolQiTrF2/CsTAqkpgMzeCBId3KTdlVAYiZEWRpqCLmNxQ5hnBppQ5tfUUWeOG9una9VFwMWCkgaohOSJVg1QVaZ3qQqCYluArNpsK7zxVbdE6ooMHF7EukKnk3hSJzAvHyWWClJkSLlcVtnFfrmqHIOzs7PCGmVBWz5K7OoI2it3ZDt+4eYM/+/ApT8/OMdo08yQn04YYQ5NXd9SoUaNGjRo16rP6tUFlFx70Q4N+nltryC3Ybo8xcnh4yM7ODs+fP2e9Xm8/7zq7IAFErfUrjql2vy6QucpZ1s/j1weoQ4CwbetQGM8+6OsIggBFAAAgAElEQVTu1wVa3ToNgao+7OqX2wdjXSjUAsV+/3YhTrevr4JbLUBt//XBWF/dhd/R0RGHh4fM53NmsxkxRu7cucNqlXIbnJ2dsVqtsNa+0s7JZMJ3v/td/uAP/oC7d+9uAWlVVVxcXHB8fMzJyQmLxYLj42MePXpEjJG7d+/y5S9/mSzLePLkCUVR8NWvfpX5fP7y6eIGfmmtybLslT4TSS5dY8wWcs3nc46OjjDGbF2Y/bFs57u1Fmvt9lz90KJtH3YBWv9aaOdfF8q1anN6dvcbcjB2AXu3fv0Qrd1j+vOtnUP9uTB0ru62tpx+mNVuSNbugwHdudR/EKEtZwgAd/92gWq7/ZU8PZ3j+3C2+4BAv2+629tj+2PV7eNuP48aNWrUqFGjRo0a1VeDwVCi0Eql8K7NLfbW0UeLPhKw9BG8DWiEZe3QShERbAj44NGSIaITi1NgCs3FEnABEYUmGao8KaSkUgoxGosQJcHQuvbMCkUQwfrkjNo4j7WOrJiilGNS5BRlsXVJ0qA8o0BQhJhCpl6bKG7MDZNMCKag2kg6BiH4mNyKEiG4BCp8RCkh00JwFUE8qonSmeBhZ83ZMkpCCjvbuB2JKRRoFEFJS5+a9W2b33I7AlvfXLNFoAm5u32/xaKxOQuvfPqKYqSJ0tusA2IDvRyXzz/G3twjIsQQGijmE+hFE71FCXjrEpwlcrG8RIhNOF7H7rzk/vMFmU4guF6t+fjiAXmec/f6PkpFMq2w3lLVjnJnjzt37/Kb3/ktlhTs3H6bOJtResXu9deYX1S8ffc2GYEPP33KB2u4piwHJlBE8BdLTp45Tp8sMIuH7PzmdS5enPLk+QWXlWNdeS42KcRuEHAxoGlycerUO4t1jVaQabN1pSqTJWhpIqZQFCbn+sERvq65XK65WG6wGK5dn7F77Sab8+fU1YYQIs7M+f4f/juKWcmTP35Am7gjNwqjhMNsxWVMa8xpOSHYmo/+/ue8++3f4s27r7HjFikfomhEYoJkrS02pvkSG+is2rmhJLkiBQiS5lxsZ04ASS7LEDx4z+ryEhG1dWaGEDE6uT5FpWs7RpVCFzfnSaFkU4k+RDINkNy2okBplfKFasG5gG2eYJAGuMcQCD4SAmgkOSNVwMZIkSVHZWzIqvcBRaCuK3QDW41OOTej18SYyo8+ErTGRcUqTvBxTZYZMqOpKosNUFcbHj87YW1mfOs3v8+3f/Nb/Mf/5X9Cwib1Y4xEnaMkYkPTH/Gl4zmZMs0rjulRo0aNGjVq1Kiufm1QOQTyhlxLXbjwefCwfb3ZbABegW7dnHb90I5XhTMdqlcXYnahS99F1R7XLa89/qrzds/TQqqh9g3B3L7rrt3eb1e3XkOvuwClry7g6o9FF7qICFVV8eDBA549e7bdv1+f/vjGGLfAT0Sw1rJcLvn4448REb785S9zeHhICIFf/vKXvP/++ywWiy10unnzJl/72td4++230VpTVRXL5ZLj42MePnzI48ePef78ORcXF5ydnXFycsJms+HFixfkeb4FYe+99x47Ozs451BKsbe3x507d1gsFpycnGwBaX9OdNtRFAVVVfHBBx9sw85mWbatV9vWoijY29sjz/MtaOxCwz4EHALIfWjZH78hSNyHfZ/n5uuWOeS27G/vXzv98odAdXdOter2azvX2mt66Lrr/x3qn/b8Vz0o0G9Dtw79BwS67ese0w2f3O+HqyD9VQB/1KhRo0aNGjVq1KjYPtAnCVgGka2TKxm7EsSQGNECudEYrdBNuEkfhI31KQdlAGc9WUmbSpEYU1jMjU0gLwhcBDBNOMs8U00evIb5RUGio8ggNHVaOpDg0Zlgawe5gAhaZwk2huSEUo1DMcaUW2/tA1MNhU4hTZ0NuBBxoUkTE+MWxsbQhrhtUosoDTpFRlLShG5tIGSkyQfZ3OLHkFob29yTnwGZLXRqkGOzmzTbI13c2OaqbPFle0+/fbMttrvKamGmtJY86Xg9m+NCjIjWKYRo48xr8WiMARcSQBYR6toxneQs1xUvzpcNXBV2r+9zcOsmx//xP7G/O+fujRvsUPP05AznLA+fnTDfmTGbTTlfXFIazePHT5DZHvLLT3jj0lFMSnbnc3ZmM7LZNcz0Bd/91m+xNyt57/SYH//ox/z4Fx+yMYb9vRk79YIcx1wCzxcr/vc/f5//l703j7Uku+/7PuecWu7+tn6v92VmenpWcrgOqZWUTFOWbcWIEENJkAQKYCRAkn8SIEL+SADZioHkbwMJAiOIEwNK7ESyKAkJTUPUkBmK4pAczuZhz0zP9N79+u333bWqzpI/TlW9ejX3jQRSkaykvo3Gu0stZ724537O9/eL5iOkThlrmER97NI6UTYlGx5yZ3vIwWRGb3kFECwv95Am5fBwjhaQpd6hi85QMkA4D+pNTtadDGgPBgzW15lPZ2zee0Bv4zEe3vuAvZlmd6wZWsmpnX3GiWE8naOtxQm/uRVnyRAkTmJMhggUk/GQSFqETolbAXHURQhw0pUgTQgP50CC8GFarcvdikU/F/0vBMg8VKn1GwCcOOpwGcUEUYyzFiecH+tOYq0hM44QgZD+v8WBFAQKAhmAFKhifjj/GSAQpGmGkxIV+Lk0yzSZyzcE5OPY56G13o0r/VzIDKQWwtypbXwqWoy1xHGEwOe9tdoi8roqT1bJrK+Ptg5jwAk/P4PA51VN0hRrLePhiFGScZgkBGtnONx5hDYp2lkyY5lrRzcI0ZlGF2PeahD5JmHn8g0aDahs1KhRo0aNGi3Wj52jsu5cWgR/qsfDcXAHR24sIQTD4ZCDg4MSeNWBYPV4rTVBEHzIIVeFgHUn2iJnWh1aVctYv3YRurI4bxFAKu69KBxuvQ2rf+uvL4IrVdVBTL2NFql+narLr3D+3b17l3feeYetra3SjViHrycB09lsxnQ6JU1TJpMJt27dYjwec+3aNT772c8SxzHLy8sMh0Mmk0nZTmtraywvLx8L/WmtZTabMRwOGY/HHBwcsLOzw2g0QmvN8vIyKysrSCmZzWbEccy1a9d49OgRDx48IIoioiii1WoxnU4ZjUbs7+9/yIFbHzdCCG7evFnWazAYcO7cOeI45u7du2Xuzk6nw+XLl/nkJz9Jp9NhMpl8yOVXf16dK/UxUAXgJ82pal/U77MI+lWvucgRWL9OHdQtgqrV/q6HEK6XvX7OouvX51G9LIvGWbXs9bm6qJ0XnVe9/6K/1bLV3ap1yN/kqGzUqFGjRo0aNWq0SFI4jBNMjGOeA7dj39uL7/MUEU4MkYIg8I7JwDikdig8OLDGenhYYjKL8tFhCYSjFeQQROeITHjHpNaW5V4ILocu0jsrnYMQSxD4HH5ZmoFOkNJDtUBJ0tQ7z4xzPi+h8+91lPBhI4XDOkeSZt4NZ7wrzTpHljkPaJ1ACO+kFMJ5MOkgFoKJUDhjS4bhDZKVjYo5XBFOVcCgf+Cc867KwtVYeduWMTs5xkdK/2QBjYUHvj5T5yIV3/3BiaPzpRRHZSiArKOEo2ByJxze4aYNydyQaIvRGoRib3+f8XiKyescBAqpQnqdmH63Ta9zltNnz3P64ADhDF/9+kvc3x3TbUX04haf+fTzxBJG4xn9vuXy6R5RGBDHjm5fcHZpg/2dR+wPx0xSjXMdfvqv/zKf/qldvvbPf5dPXO5ycdDh4rkx/WXFW99L+eHtmL1JyGg6gyyl7TQuGYFU2M4S24nlD/7o+3zuRYHurPPsX/lltt55g71bNxBAu90lyQxGa0JpSDOLNoLUaGZyxu7ODgejKb21U6wurzKfz7n7/rvcub/JWEtk1MYlE37w8h8yGx8QKkkoBBKBVAonA3azDuPUpwrBgVAxF699DCcUt+/e59nLZ4rOKCE2zuKcyR8XVt1ijDh8pFabbwDI+x3h3cDu+CkISZZpsjT1YNCCw29sn6WWNIfVYSBJjIekgQoJhMX4u2GNYZpkZNrQjQNascLimE7nOCfItEWFEuNAOg+7ET43qhM5qMRhrEM7iPBztOqq7LTaCBkgA0ngDDqzHvxLMPMU7QQOiSNAKU1PaA6TFGsNaZoxn2cYY9mfpqysn2ZvZ0w0WCY5uMnBYcJcGCIsVihOhYqD0YQUf01ZmXguh7JCNBt8GzVq1KhRo0aL9SODyjqMLH7Mr4KZAuxVc87V8/wBH3JJFiEg/UJNl7ClGkqyDisLmLMIbNbdbQXoKZxxxbUXuevq4SuL1+uQog5eqsfWIUzhLqs+r7ZHHbwsgjgnvV6HKIUWvV69hrWWMAyZz+e89dZbbG5uHssnWHW1fpQLbj6fM5vNmM/nZFmGlJLxeIyUkjNnzjAej9nY2GB5efkYdCsci0XdgyBgMBhw/vz58nkBGXu9HufPn+fq1as88cQTLC8v8/bbb3Pz5k329va4fv06H3zwAe12m/v373P79m2cc2xvb7O9vX0sRGjR3lVVx4+1losXL9LpdAiCgNdee42tra2yTVZWVjhz5gxPPfVUeW499GgdMFbDDhdtf5LjstpPxfP6/FnkMqxCSvhwOObq33o/VudwNcRqdSydBCuLuhR1XFSmRarPgyqsLOZ6tYzVfLV1kFttw3q7VvPF1uddtQxFf1XboBpKt74Jo1GjRo0aNWrUqFGjRQqEIBEc5e5D+SCmDoT01EsKgcWiHWAt1iqEkGUaCAc4Z9DaoU0ePlVItPaQQqByV6J3WwkhmRiYJ4Y16++TR14lM4400R4ohZJeO6TXCphnlkmiMUZ7B5mUCBUQRC0iY7DWA0qRh1UV+HKXKf1yFmSth35KOpwVWGvycLYCY2yeC08CklAJtMlQMncjAhRgKA/CenztLfNQnFQCueahWoUEcRQW1pXv5N/1S0/lERwuiGbxTnlFcXxN4k8Tx1yWLq+/yIGpcKIMuVvAVWeNfwGBs2CzFCF8Pk8nwBrN9vYWaZoSSYhDHxEojmPOnr+Msw59eAg6od3pIFTAaDLjwe4BgZScW+pxf6h58okLfOGnn0IFilarQ9yKabc7WGfZfLTDx5+6SJZMuf9om7v7ltE8w4z3eP5qyH/8H36MVnwaO3kTZ0ZcuniZL2VDHt6f8U//7yd45cY21lnagaSrLPbeFgf7jpf++F1uHwb87C/8TbodyaXPneapn/0bhK02h3vbvPHaN1iNFBuxYTZNmMwzdh3MI8H9+w+5fuM2QafPs88+x1ooCcMOP/PXf5npdMr9Wzc5ODwk0SmdXp92Ky7bPZAegK2pKZkTPhRy5PNR7uzscPrcafqRIAokwuXr7Aqs9i5byhEkRGU95/w88USt6GhbgZne+Syc8U7GNCXTxve1y8e2kuU8sDiEsRgLLSUR1mKwaPwGACkkgUgRyhEoibP+tzCbGiwOo/zmA6zPgVrMOWt8PSTWh4x2fjNAoGT5uWKNB6L9pWU6rZYPGesyJtOEOJLYTHsHZw5wk8wyHk04tI4kydi5eYev3r7NbDjEJQlf+/bbrK+s01sKWV9bY/O97xHi6CkYp5Z2rGgJzVv398icKIMtV6eab9dmg2+jRo0aNWrUaLF+rByVdVdRHZxUgU0VlGitPwRbimsCH8qtZ60tj6/n6CtgZRUeVHPcVcFJ9X5FuRddD447vwrAWhxffbwIUtTh06LjCwhadYQW9aiC3SpEWtSufxp4WC9DtX7VPgyCAGMMd+/eZTQaleU8ydlWB6UFMC7yNiZJQpqmDIdDHj58yIMHD8iyjNFoRJqmxyBlHMfHAK5SqnRD9no9Op0OSZIghOD8+fP8/M//PBsbG0gpCYKA0WjE97//fe7cucNkMqHf79Pv98myjBs3biwErUW56wC6qFMURbTbbZaWlgCYTCbHcjgWrtHpdFqGhK2P+aI9CuBbhezVvqmO2WrZ6nktq6r2ZfX9AjCf5Awsrl2dt9XyVsF03alYbbOTgG8BSE/K21icX9y37tatOxiLa1bHX9VVWqhejpOAfXXMVoHkovavXq/a7vU5uqh/GjVq1KhRo0aNGjUKpCQpctzlwFCKIq9i7s5zPsSrtgYlAmzuSAyUh5VKeEiojWU+TehpDxrTzGC0IRCOQDpCKbBAYi3OCUIpGGvBXmbpB5J2SzCeaQLh6LQDVBCghc97l2hDqh06c0jjwFicLDxloJQHcdLh8+2J/Pu0cCTGQxQhRenuNMYxmWbMUuPdW0KSJhoGAiEVKlAo4Uh1ilDSOz0pYKAgJ0a+3ZxFCJ/froBM3vXmQYiQeV7KYy0vOArlWoSEPaIm3hnpg8z6e7ryeOFE5Xn1ikd38fXN8+4VtxMSbQTOWBw+nK21BawxqACCMMwBp2KeZAwPx2hrCaSgHSlWV5bptGLU6ABjod2KUEaQOsF4OsVYi3XgrENKRZIpWq0+l68+SxwopAQhJCpfm4cqJFlbQ8+nSBEwn9wmHd0nCiRPPXmJqBszmyuYK6IgIAwtIlbEXUunJxl0ItLJnEEUsjUcsZsJZBRgTEo63GXz/X9JkhrmSM5duIwdvcPeg7skk4RJqLhjHdY6tu8+YJJaDjPLo70xw2lCPEkh6vPiL/41doZzUheQ2ID22hkyEaB3d8imQ0azlMR4R55U0jd+NsK4Ls46WnGH0f4O4/1tNjZWOH36FK049t1SrPFym2T+a4wfa8U6r4Bn1pbjpXDKegjuKBPL4nzYYmHRxkNMZ/3cTI2lHYeoMCS1EucMKpKcj1qctqCyOSaHddYKAnx4VpwjS1If7NlZHA4pFE5rtLBYJ/M5YcH6kLFhIHM4bxHCu4qt82PDGodzfq5EoR+DKgyxswntOMDaDOMkSZJihESnGUZaCDpIIXHTLbLRiGGSYLFIk3LnwQ6PPfEstx48Ypx5cNqOFW00EwTtQHJ/c49XHx76jRilS1nmmxls7rJsNvk2atSoUaNGjRbrRwaVcBwyGmOOgTU4+oG/gCbwYYBWhyX169ZBS/U6dXjxUVrkTlvktILjLi4hBGEYlvWp1qUaMrXqvKyqHoa26ggrgE4VVFVDn1bbqFrHol2DIChfr+fOXOQOrQKWos7FMXEck6YpP/zhD3n//feZTqfHQNki1R2DRT3SNOXg4ACAT33qU+zs7LCzs8ODBw8QQrC1tcV4PAY8DBwMBgwGA5xzJWQMw5AgCAiCgHa7TRzHhGHIxYsXOX36NM899xytVoskSVBK8eyzz3Lnzh1ef/11NjY2ePzxx1ldXSVNU/b29krAWDhH+/1+uVu12m9aa6bTKc45Tp06Vbo/i7bpdrukacpsNuP+/ftl7ss333wTIQTnzp1jc3OTw8NDnn32WZaWlvjud79Lr9fj8uXL9Hq9D82T6lisQsIqbKxCwJPmR/G8Cuzq86rubKxC9fq4rQP8Ksysh88t6lF/v17uRaC9CDlcPa5er8LxXNyn/llRtFsxD6ttW3VdLqpTFZRWr1edR9Xjq/dd9JnVqFGjRo0aNWrUqFGhQHqQJgPQab4udYV7UKKEQAmPQUIhiKQHJVprpBAExfdSJ8iwZFnm12koBIYgAIv0sA+LdIJIANYys44OjiUFp9oBnZYgVpEPM4oFLM6AxcOtIPQQxJep+O4vUFL5IKbO4fAQVeZQdJo5hMvXnlIirEEKS6Y1kVLEgxAHzCxoa7HOA6cgVLTbLebOoMq1kUMiMAXMcM5DW3JXKB4WWgpHZ441hTyKy1m45vJjhMjDd1J1Qx7HmuUjUazZqUBK/6R0e3JkyBTkm3Ur/wrAVZwrnF/7SSUhM6jcRWudYD6d0em0ff9LRzdWrK6dotOKaUlD6gRRGBFIy+7WPtr6Xo8lhNK7+5QMeO9A8bnwHJfPn/EGTmcpYpVGG3lFnOXSJwyfNVkegjahww1m+hVeenWI0mN+4jlBv68gESihePrxS/SXLnLn/hZ372+ytXNArCRCQtTvIzodbj24h7ACZebc3LnP4WRCFLdYGaxireHeux8QDXq8fXePQbeNEY55kgAQhTEf+8Sn2do95DCxHG7tc3h4SD9NeCYKeThY5/RnP81rL/8LrFAIZX2uRRQ7WZvERWitsVYjw4gLl68ghOJgOOLUylLeF0WnO+/GLYZWGZK3eN+WQNJhKSOUlhZem0NEf66zPrStcJBqg0NyeqlFpx3z+JPXONy8y63NXaIwQOCIKdbgxSjx/eeMz1HrXAa5a9k4R2IyUifptGIP/UwOUYWfr2Go/DwUMg87LLHG4KTMQ78arBOY+YjhgaHb66G1QRtHqBSBUrgsw0n/+1PqBIfbmwQrp8FonDXe2Wx9eGYdRRzsbTNPEl556Wsk965zCoOxjm6kEMZwfWvIXmIqjVrMR5/r01nrIW+jRo0aNWrUqNEC/Vg5KoEPAQf4sPtp0XlV91lxneL1Okgs3q8eW3WiVc+vAqCq62nR/eqAdNH1627QuntqUbnqwHNRHeAohGcVUFbDddbrU69XFUhVXZP1NixeKxycxWtBEJT33dvb44033uAP/uAPuHfvXgmOqu1TVx0IFf3x6NEj7t+/zyc+8QkuXrzI1tYWjx49YjqdEkVRGb51bW0NpRTr6+usr6+jlGIymZTuygI8FddfW1tjMBjQ7/dLiFQAzXPnzvH5z3+e7e1txuMxu7u7JPkCKE3TMkRwt9tlaWmJJ598kitXrtDpdMoxFMcx0+m0BJsbGxsEQUCv1+Pg4IA/+qM/KvNjdjodnnrqKfb392m321hr6XQ6rK+vM5/PkVJy6tQp1tbWOHPmDHEcl3WvzoF6/xavFf1VB5X1di+e12FyNQzzoj4r/hZzo97P9flVP2YR3KuWuz6Gq+fXr7UIpFbLW9R/UT7R6rmLQk9XAWUVBNcdpovAfnUefZQjt1GjRo0aNWrUqFGjk+S5lGJ/lmCFAplHIKEw8AmiQCCdzy0XBKIEcFIJlBM4ZwFJZsmj8EhUEKJyCBdISycQYARSQowg7ORrVCmIwoBut40MAtJAk2qDzTJfvkAhnSNzEFqHNRrrHEpJ4laMcz7XpA/X6nNR2twBaslzTkqBCELSNCPTGokkiEOCAgwJgTYGY3zOSiUFMowInICZK0GjwDsdPRB0OOshjpD5Bs4SUYoSNvrv/KJ0zBVg0le+AFOuds4Rh3SVR2UIWSjrSyWnXnG+r5MHWIEKOHJsgspzi3pw6z1kJcQVvq2st18ymczpDgYgJLGSrHRj+oM+UgqC1XXmM00UTOkN2mwfjFlqt/jM1bMIs8ZklnB3a8TO4ZA3X/4GP/tTP83FCxf8OsnmWRDFUclBgHTIwGEDgxAZwnQIRItzazDdTpknAtVW7B1qMhtA2Gcy22d/54BsluJmc649/wxrp/oYB5kMGM81MYJWt4/qD+iEMbfff4/h4TJtJdFJSjKecDieIaSi142QQhCGipWNMzzz8Rd489XvsXHqLBtLPeaDNv0fXue5q89zbppxH4cQFul07n4NmGUW4QwGMFojVYCSMbI9wLmM0e4u8rGLfq3ojhC1y/tT5E1ShD0t+9k5wJRjpxxAQpSQ0I9TP+6y+QybaWTc5lf+6ic41YmYzDOufOqn2H7/TW68c4NWr0er3UE4Q2Ys08mMTKeYLONgOCazIIMIFcW0223u3r7LznjOIFQYa9HOoFCkeNCKhUxrnAVhfcjXeWpBKVphQBTI3OWpEKRsbu1hJhP6gxndKMBqTdiPEEr6eV1sONcCNztE9paZZUnpNhVSEAWK3to6CkvU6/PJZ5/mnYf/EmccxjmEEoxTw+Y835icw1SHB6n+ebH5t9ng26hRo0aNGjVarB/LUVkPtRiG4bEf8+vupeqP/lXnVB0yViFh/b26k6t6jQK61c+rgpJFoBFOhpBVwFHPf1ctQ9EeQogyhGtx3fq9qm1Xfa84v+qqPAlkVeFJNaRo3V1XvVc1XOZ8Pi/diKPRiB/84Ad885vf5O233ybLF611l1697lVoVLj/pJQ8ePCAlZUVPv/5zxMEAZ/4xCfKcLJSSrrdLlevXuX06dM451heXubMmTNEUUSWZczn8xKqVh1v1lparRZSSiaTCcaYcszFcczVq1d58cUX+Z3f+R3eeOMNlFJlW3a7XZaXl+n3+6yurnLt2jWUUmitSdP0GOwtnKoAOzs77O/v8/DhQ15++eUyfO3TTz/Niy++yNLSEleuXGF5eZnBYMDly5c5c+YMWZaxsrJCt9vly1/+Mmmalk7LOiCvtmW13+oQvTqmT3INVudkdc7VoWDdbVkHdIvyd9avs2jOLHI6FmOv+rlQPX9RqNZFwHBRLtji8UluyzporZatep+T5lsVihb1KI6vgtMGWDZq1KhRo0aNGjVapNwgibagAulZiAMlJVoIjHWEkWBjEJJOLfPMEUsQGCQKoQRS+JCqyiq0NkgBYRgwFz5MqRKCOFTk33wxQqBwCOk3xwZRQKINvTgidMofQ4jLQ0UiJLYAP05gnERKQRgEZMZgjUaGPgKRRGAcOCxS+ntLYDZLCAKFcJAZgzACCrAoBcb6ULV55j50loGAeZZirSE1JgeBuUvMecebUiHaGo8ZnXe8iRwq2fx4UdxH+PYVePeZKOHkkTxjLMJ5HndV+rUEIAp8KSpAi5xb5c5J5/NQRnHLrwUc9Lt9nnn+Myz32hzeCBHCl8MWa4ZK4FjnJEkyodVuebDkAKlo9wZoAXo8xs4ygjMdVBRhhGR5ZYnPf/wyOk24u7nD5vaIZD5nMj5kf38Pax1OFaFmq55RSRH0VAiBdKCkRTrQqUFi2RkrPvjWAYN2xOadCR97ooOIuijzkPPsszHQ3MbnLu30O6jeCjsPtlhtS7S1jIYjRomhHQWsbJwjSWYYnRH121w4d4azvZYH5DhWBlOmmeXs1Wv0eh2CMGJ3NMOpmKi1xL12B/ZHpBvnuX33PbJUkxpHph2BEoTSMHx4m2zpcaSUdDpt9m5+wKP79zi3sczVx84TBaAN070AACAASURBVDIH/AVcrjheqXBHUbBohR9R+QR1eQuKPMtp7i7EFmtZ0PM51hqSoMWLX/gia21BNp+DsJx/4Wk+/vGniFcvELR7uDxnqXMWk6Xo6QHDB7f9WBcKozU7wxnfmg1xOmGWZEy0RajQbwgQDmvAOJhnfk1qHFhrmBuLDGLCQOGsAym849lk/OB7rxFGEavLA5b7XbrdmLPrA7rtmK2Hu7hAIoMAm0nCwSpBHGEyjXQ2Z7feYb02aLF17w5rF5/m6pNP8frvTWkVDlNr2Z46xlb5z5Mc8BZAt9xckH9uNGrUqFGjRo0aLdKPnaOyeAwnA5YqPKy7FYvjF8HKRaCzDkiKXHmFFjmeqs7FRQCxek49dGUVAtbrWoWE1XIuen9Rm9SdZwVUs9aSJMmxOqdpSpZlZU7OOiQs3JGFC7E4ph66Mk1TptMpW1tbbG1t4Zzjgw8+4P3332d3d/dDeTGr7VKFsnVHZjUkrtaaO3fu8PLLL/MTP/ETrK6u0ul02NraIssygiDgSu5mDMMQKSVRFJXuyAL0FnURQpSA0jnHbDZjPp+XIWFbrVZ5zJUrV1haWiqBYwGYH3/8cZaWltje3iZJElZWVpjNZty7d480TZFScv78eaIoYjqdYowhiiKuXr3Ko0ePuHXrFqPRqGzPIiRtmqa0223a7XYJVrXWzGaz8rXZbFb2Z3UsL4L1xdhZBBnrY7N6Tt19uQj4Vc+p51qtjtn6eK1CxkVgsepUrI6Vk5zBVefjSW1QHX/1zQB1yFqUvZjnRRjq+hiufv7U23oRiK8fUy3jIvdmo0aNGjVq1KhRo0Z1SUBISebwIU6dR3VVT99s7njgDJdOxdjUkiQG4QTSWayRSCxRS9LuCKY2xRrvmLMO7/hyDu0sVluMc2gAoQik8mFh8S7DTOvSNWjxee1DIZhlBqH89+HMGLqBQsRdLAKdZkewzjoPHK13birr82IiHJnWHkEIgRPWgx7pgVCe8hJjHIGSOCRpkiLDkO39PUxwi34YcOVa3mYi905K6Z1ZVuOEpMhbWXxlLwO6CipQBAowQhkEtvY7QXlYHub1+NWKJv0QzKxGtHTOh/9stzsI4TPvxe02p9aeQeg5UikPypzBpAlYkwMyyXK/C84R4JCBKi+tHSRpwkiPmAz3cC7g++9sE4QKl8xR+xMu9bvsPDygFYdICVGg6HQ6bD/axDmLcLKsTYFoXUHHi3dyaCfQhFFEpzvl2ccFzvZYbjnmF1vs7cy5/c473N3cxcwzH2o0DBhPZ7Q6AzrLZ7n97kNODVqsqIz5wQFf+NSTfP75J/j9r77E7//xLYZumStPf4FnXvhJXv79f8zB7n3G0wnjyQilBF96tsvN929w9/3r7O3uYo1maXWDdqvNwd59zHAXPR+yMugxncwRk5R2HCKDiKVT66Q2INN5iFNtWOr3ieIYVEgQ+d8IrPCuSYdFFHkmRe5SLtrF4cOcUoGTzodGzhvwqPWK6zn/W8U0taRxi6gV40jzMKw+36qfJCqH5oBSCKeQKkBIQdzZQljj57GeoyYPsKM9siQl1YLUQJiDVOsEVli08Q5KFSgCAUL5ca6k/2yRUvi5Kv18y0xCNk8Q8ylb9yGOA253I7rtFpPxlB3X5u3bO3SWO2Qioh2GZDr1qWFd8RsBZPOEpdVTLF24QuhS5klKS3i0q51jJwVdCWtbzieRbwrI4f+i9XajRo0aNWrUqBH8mKASjoc3rULI6nH1H/g/VIgc8CxyNBZgog4K6rBzkQurCkPqwLDupPood1j1cR0cVVUHplXwWHeAFWCpGl42CAKSJOHBgwfcunWL3d1dAGazGVtbWxweHuY5GI7nBAyCgDiOifOE8bPZjOl0+iGYUkC0wkWYJMkx8FeFOx8lpRStVovV1VUAptNpCfuKc4fDIa+88gpKKa5cuUKSJGRZVgLAosxRFJXORzie77AAua1Wi1arhXOOJEkYjUbMZjM2NjYIw5Asy0jTtLxekduyuGa73UYIwe7uLg8fPuTatWv0+31ef/11fvd3fxcpJdeuXeOpp57i5s2bfOUrX8Fay4svvsgXvvAF9vb2uH37duk0LcpXlHt3d5dvfetbCCH40pe+xMsvv8ydO3f4uZ/7Oa5cucJv//ZvE4Yhzz33HOvr6yWIrQKwIkdq1QlZbc8CUC9yR9bHdtGPYRgeO68O/xe5OOtwsKhnPexqHSAWz4v36+O+yEO5yIlZ38BQD3NbzI86eK+GMi5yWBblPckZWfyvwtfCQbsIAC/a9FAA9EWhrhs1atSoUaNGjRo1qko6h5QqD32YRzdxDiGOcrUFUmAzw9Z2wqnlmNaSInTQiQOCADInGE01hweGloux5cZV7wJDQDtSaOf9Yon2ASxFKEEEOCEQEpJUo6TE5qFkC9AphcRaQyilhzbO4ZAIZ8BZVCCxCJwztBQ4WXzv9wBGIgikQArQec49UcBD6R18OoepDoE2muHBCCXBJDPefuddzNTxwmd/kjiKELg89553XuYrllrL5i4tqpDyuEOyOKc884gNU8T/dE7krlcPoHxo0CM3ohOFL/PoGq50dwra7Q4ZEiHyqDXW+tC9wl/FOkHQ6iAyDc7grOXKxXNkxtDpxExLmAjaOmaTOSMmTFt9rBG8+t0/5uHt97h4qk86T/g7v/Q5jM4IpIdTmTVobZhOJ75MhVPQ5VUq61ysvSot5DQmG6FTw+2bYwZ9xeMfb5G0Qg72UrRxPNyf8v6jjLjVglOXGAdt7o8c6605KxvLaJvx3uvvcW865q/+whfZuHiRi2dPc/nUHq89DOgvP0/sztBeukxvsMK3//h7JKng1FqPF57/GA9ufcDm7RvYIKDbHXDq0jU2zl8kCiXCOnSWcPXZF5hPp4yHe1idksgOutPFTBKM9WN0cOoMojNntH2Hm9u3OXfxYg4jbQ62Zd6XeeMUjeHyMMN5n5dr5HI82dIdWIbSFRJrIcsMw5kh3GgTCnwZk6wcPVEUECNwVueu2fz3GSERzuW5JP09nANnDDhHZjy0DpTw//MoxFnev6m1xFJRuI6NsziZ10OAsQ6hDX0liIRgbvyY1cZC4rDGkE4SJvOU7dmI7yXwyc+ss3Pnfdq9T5Klc6yzlHlXpUCokO6gz2B5jUDPKdzSzkGSGQ50gC0Dvh4NMf87gTuaf41+bAkhrgA3gf/ZOferf4rjfxX4n4B/3zn3j/5fLNqPJOF3hHzDOffFv+iyNGrUqFGjv1j9yKByUajEKpSsho6suvSKcxe5JasuskUOMTg55OQip2Qdkp7klqq6quqAY5HTq+6OXOSyrIe8PEkFKLHWcufOHb773e9y/fp1dnZ2mE6nAGRZ9iFXXh1SVcGc1posyz7kzCvauu7WKxyRBSxbBGgLmNbpdFhaWmJ5eZler4cQgsPDQ7a3t8u6FjBnZ2eHb3/729y4cYO1tTWWl5dLl2HdSVc8DoLgQ87KYmykacrOzg6PHj3CWstgMGAwGJQwrnBXFu5Lay1BEDAYDMiyjOFwiDGGOI7RWrO/v8+9e/cQQnD58mXG43EJl69fv04URXkomQ7dbvdDrrswDJnP51y/fp3vfOc7tNttzp07x3vvvcfdu3e5fPkyxhiuX79Or9fj8ccfPwa16sC7Cuyq/VPvkzpMP8l5WQ1TWu3r+rg+KaxvfexXYWL1/WLc1YFd3TVdPaZ6v7pbt16mRWWofsZUx1AdNlbnafXYaq7K4v36BovqNavvF48LN3e1XRs1atSoUaNGjRo1qqtcj0lwxuGsQ+UQyTpInCN0Aisch4cZMwcb/YhZkpKkFrQhFArhHFlmQAjCKAYpcNrnfRtqh8kcgRTMtGWsHfuHCZHSPLneJsCHIDXW4HNcSow2aOdDuDo84JDGorMMqxLiOCKV4LQHEtIJAimReV2shbnx8DEIQxygVGX94jyENQ6cAa39WlQbzft37iOtJW21mM9Cdne2sMZgXG7FdBZrLM5qhFI5XPKA1QOmI97oOVzunswBoRA5uCldpzmrK02YkgJJOgQih0BHnVayTIo/zjkEPk9n8UbcaqPnaaUkuZNTSIzRCCkgX+torbFOcf7saQ7Gh6yt9JgeziG/prGOVGdkTrM/mkEeaUkJR68V8ODggOl0ThyGjOYJUeDXI/PZhK1H21hjKQLMVt2jx0Br0SYChDDAjPvbY1r9NktrEa+9O+Zwd85aELO2soqUD9k9NHzuqSdgssMkmbN16wbTuzdIZUR3eYPZ+UusxyGv3E2ZvzWBx/8K11ov8Nr/9jVay22mbcXt25vM51PisEc3NqytrfBgf8jD2++ys7XLw61dojji1TeuE8ddgjBAxi1sGOJQhN0lev0Ba6urrEXQjiOEmCOFj6z06L0HHMwNYTLi9HKXQCmK8K1OOA+hnW8QB1hjmM4S0jRDZxnaOFZWBsRh5bcqATiZA19X2WoAzjrSNGOqDeu9Lko4trd2eXdzhEOQGsOp06d44UwOJfHj0FqLkB5elnkgsXloV0OaGWbaQSBoK8F6V7ESg9aChyOHtY5OIOjFijiQCKAVOFaUoqMKK7CjHxnOn2qxM0m5M06xxt97aizLYYRSvg7GWJ8nUymkCrFWo9OUMj4uIIRi+fRlusxpD5bY3z/AOYsTHqhOMsfU+fDRvnE8fBUuz8nqjuahkE0kokaNGjVq1KjRYv3YjspF4RKrP+4X79V/7K8ClmqYyCpsKM6rOymLv3WwUg95Wf1fPa6quntrkauqWt6irIWDqw43q3C0Dkmqx9Trcf/+fb7+9a/z7W9/m83NzdKxVYUi1XvVAU4BJ4trVt1eiyDxR8HTOogtYJ9zjiiKWFtbYzAYEAQBURSVjsXt7W2yLCvhldaara0txuMx8/m8LEur1Trmkq3XtfhbANzCMXl4eMje3h6z2Yw0TXn99deJ4xghBHEcc+rUKbTWTCaTsm+Le1TddgcHB7z66qtsbW3RarUIw5Dz58+XIXfjOC77RGvN+vp6GQ626iQsnMAPHjxgMpkgpeTevXsopVheXmY4HHL79m3a7TZra2tliNrqOKxCxOJ5VfUQptV6FHWsw/s63KyGRK2Pv48aoycB0vr96hC0aPe607Net5OAePH3pHJW76m1LtutDvGL16ufDdX5UP3Mqda5Xo6TAG61XkUbN2rUqFGjRo0aNWpUlRIegknpvYcyDycZKUliPPhSOILcySdx9AUo4x1XLQROSkIlSa1DZwZrDDIMfWhJMqSSxFKSobGeaxIDPQXDzPDgMOVMP0JrRxwKLA6lDJGCVAucE4TK5zFMtfGAMQiZzuYkSYpzIndhOpTKHYgIrARh8W4xa4ijgMz5MJXGOJR0uXNMlm5LZx3OWEhmaCuwQcjVc5eIgl7+HRt/L+dwxW8IoqCGAAUwcjn4kEdApQIKXeEMdZbi3SMnZVXVdXG+9qgSqdw9eZSXEu+6FH5N0Gq3mBaRd8p1hUTkjjeTeheltTkIlpLeoM/mzg7xmSWcm/g6+7i5TEZTDhnRtmMiqXjh8lkmfQfC0Gu3mM4TNrpt7u8MUUrghKTX7TLZvst8NqXbbeWjyFXcg0ft55wP15lmGucscSB5bKXFdOjQQ0t6oImmBhMGPHE45rPJnE1nWe6tsn24zc7OkI8vB3z+iUtET36OlSc/wXiWcv/BPd569wbv/J9fxyYjtg/mtMMO73//W8zvXyfUmqjd4uqFC9isS3tllYd33+eHr71CK5QkacI8TZjPd+gEIcvtiMl8TtDtsfnwIfNMkwnF8vIqv/S3/jbb9+9y/trzvkulhGRMV8asrC6xshyi5PHfi0qPrADhHC7L2Hn4qMybCoJOt00cRMXoQjhR6dccdlsD1mK1JkszZhksLfVQwtHutlhfztg9mCORaO1BuxXKj0lrcM4ghUQns7yPjiL9YP38OLcx4HOffo42hrffuYFU0IoUz6x0sNbxwqUeCIlSwtfderenlJJIgTWW+5tDhokjkpJASDJnCaQkVtAKJHEgkfkgV1ELFbU5+9hVH07WaFReX+scTgpWV1fQj24x27zDd966SxQqlPbg9CABXaylC7rvvCtVCgk2DworOHKlNvrz1D8D/hh4+BddkEaNGjVq1Oij9CODynoI1zqUWAQyii+KBZiqu8uqYV4LCFSHDsWxsBhWngRWir+LgGm17AWMqsPNOrxb5OasHmutLUNQnuToLADHgwcP+MY3vsHXvvY1xuPxsfZcBIdOco3VXzvp3osgbN3RVgcxZ8+eJQxD0jRFKVVC0TiOWV5eJo5jsixjf3//mLMyjuMyT+PBwUEJPgtXZdEXRY7KAj4VIWGFEKRpymQyYX9/H+ccq6ur7O/v8+qrr3L37t0ynGyv12MwGPDo0aPyusYYDg4OOH36NHEcMxwOuXv3Li+99FKZ87Pb7fLUU09x9uxZrl+/zp07d9Ba8+jRI7rdLsvLywBsbGywtbVFu90+lgfTGEOr1cIYwwcffIAxpnRwxnHM+fPnuXDhAp1OpwRr9XG0CB4vgpRVqL9oHNbBf/XaVWhXuGcL6FmM/eLcuuu5uE8VBlbB5CLVoV8dkn+Uk7M+DuuqhzWu1r8+Vxdde9Fnw6LPibqzsrpB4E8bKrlRo0aNGjVq1KjR/38lc2AkZYB1IIXEOIcR/l2wBMKTMZ1DJSVAOEs7DMiERFiQCjDgnN9cGQgJLk9NYCyBkmQItLFE0gOMJId+aaIR/ZBAAS7P1WfA4EgzgwqKXJbexZimKTJNSOczjLEEQYSxFuss0oC2eb2kd311AkFmDCEBiCP/nnGCJHM4m5EaylQQOMeFjQGIgO1McebZFxjuTwgClQNdyO1w3hFXLge8exPhnWQid3e6HCR5wFhQxmINbythPI/xziMDZFFil+fTc+KItbjiveKcIxgppSAIIgoM5nBoawiVL6NzYLTx60Ptw5C24xAnBEpY4lZQ8lCbr6+00YzHQ/pr6wgUz68N2N9Z5dYH77C6uspopjm9PCDNHN1ujFUpRIbZfMJodMjq6jIGhzUarVOM1jijy/XTbD7nvZsP2D/Y56ev3uPUuTZXT0ewNICOZvYgZnw7YPsH+zx26x2em034a0uCmzev80o25cqVM1x78We48MJPMhyOePWt6+xvbTJPHO9vSpaWVhCHd3n4wR0+/dwLvPCk5eplwZV+n3DlApv377CzM+LOvZvcN5qd/aFvWGuxSHrdPnGg2JyMIYpRUiH6PaLxGDNLGbQCep0unL+EdQJtPPhe3jiPJmC2eZ2H813OPXbVeyedyBm1LUPi4gApCAKFER7UC5k7a6XvN1F0uqiMGuHHnAOyLCVJNYmDQb+LcIbJaMJ4ktJpKew0Q6iIQAWo/HRrrffvCoUzGVIIhAwAh5Ual7t7LzxxiZ/5m3+Lnkxof/0PmCcJWmuUkqRpQpZmpMW4svlvAM5x+fkX+PjVK6STMV/5ra9wuDlmdXnAVrLPNHVI57gaKJSAobMY62FkHLXIJoc82t7hwvmzmCxD5uPZOkfQ6nCuB+/cSfj5L/0i29/8Z9x+fU4oLdI4hgaMtblh1buh80mCRHiXdN72zcr5z1/OuSEw/IsuR6NGjRo1avQn6UcGlXAcgAAl6ICTf7yvuyWrquaZK8DJIjdWcV6Rn656TB38VOFn8Xq9fNVy1GFo8bgAX9VyfRSwrF+/CjyqZU/TlFdeeYWXXnqJ6XT6IRdoFZJUHYd1eFOHNNXzq6rDmkXHV2FocWwYhjzzzDPMZjNu3rx5rL1arRb9fh+lFO+99x57e3s450q35XQ6ZTgcliFdC3hZtGWr1SodaVmWleFWhRBkWcZ0OmUy8Tk3ijCs3W63LGO73S5DrBbXDMMQKSVZlqGU4uzZs0RRxOHhYemaLADoYDBgeXmZfr9Pu90mjuMSSj3++ON88YtfpNvt8sorr/DVr36VjY0Nnn76aYQQhGFIGIasra2RZRkPHz5Ea818PufSpUt87GMfI01TOp1O6SSt9mfdGVkHaNX8iQXkrY6Jk8ZyFa4X/4tr1a9f1LdwotbHTh3m1cF9dSzVtWis/UkbDapAvhjz1ZDF9TF70kaC6saDemjjaj8Ur9fLXL1H9T51kFv9fGn0r76EEFfIc3oAvwH8t8DPARHwbeA/c869JYRYB/4+8EvACvAm8GvOuT+sXOsc8HeAXwCeAFaBHeAl4L92zr39Eff+deC/Ab4E9IC3gF93zv3+n3WdGzVq1KhRo0Z/cSo3uTnI0ow4DLDGMMPihIcexnnnpclDMTohIIMoED7foRQYCxZRwgXlrHftGe0ZmhBklbWAEIJYweM9RbcdImWe1905PPOUWOvD0AoV4DKLtQ6LD83KfIK1DiUVQSBwxoenjBVEMjcc5nkpi7x45DkBpcOHk7XeSRqEErQPS1s4/VrdLiJsE49Swjim1Su+2xdtVov44sAK/D2EpMh/V8i5/MrClbkGnfXhPoU6Cn3qKlBROJHDFYHIc326o+yUZRmK453woFTJfF0uj8rpj84Bp3OAxVnf3kWYUKQk6nYwmabfbREodeS4BVS+kdmmKZYQbTRhOkPPJ1idIdIZd+4+YHPzEWmmIVK0ZMpzz1/h/MXHyPZvsx+mCOHI5mPS+cQ7AIu1kdZk2rARK5aWLKE4wIiMobQICYwgUZrpxDK4KxkeHMJoRstont68weNCsp1NefjKd7j/vT/ind0hD88+y+nHr7Hab2Guf5ed8RZdNyOZKd57sEEadJhLw85hTG92m+mjm8yGB9gkJUszQulI0syPbWOYpwnTqUYbQ0sFhDJALK2SdXrINEN3+gxnCY82H3HxsT4qUMStmDSZ46IegZmhZyOUVHmf52Og2q8iB81C4qzNXZK+fRyRHxeiIJr5yHECpADjHcdZmjFNUhIL3W4H6ywbZ06xftofn6Ua11nKIaV3R1sJOIlUAVZrpFQ4Zz0clxJtDKiAs1eeoHXuafr9kC9deQ6XJlidp/YxBms0FoU2GTpJyJI5Okvprq0z6HWZ7j4gmaeIqEMkBb1Oi07L0ZvMuKwtbu5Yl4KeFAxCQdxukY73mI+GZOkazhgPdIWfH63ldU5dfoa3f3gTbRybjx6h8Bucp0nGoQn86HcChcDkwYalyH9bs65gw5V+aPRnISHE0/g15c/ijfQ/AP6ec+5rlWN+lRNyVAohLgC/BvwicAGYATeA33PO/YbwyZRvAUvAOefceEEZ/gHwnwB/2zn3f9TK9mvAzwNn8bD0HeA3nXP//Z+ibgHwHwD/HvAs/vfrd4D/EfjvnHPNjzCNGjVq9P8x/Vigsg5I6k6teojF4nEdgJwUPhWOwlYW16xCyyqcXAT3qvChADz1ey8Cm0V9qjCiep86ECkeV4+vHlcNw1p9TUrJW2+9xeuvv8729vaH6lGHJ3XgWc2xV4c8RR3qfVWFMIv+1hd7BTA6ODjg6aefJggC7t+/j5SyhHRRFLG0tMTS0hLz+RytNcYY+v0+SZIwGo1IkoTd3d1jfWeMOQanizYp6tdqtUpQWTg4kyQ5ds4TTzzBM888w/7+fhlmNU3Tshy9Xo/Pfe5zzGYzAL785S+X0PSNN95Aa814POb1118H4NatWzx8+LAcM845rl+/jjGGdrtNGIasrq6yvr5e1iMMQz75yU9y8eLFMgysEIKrV69y8eLFMk9rAQsLl+ciN2ThAq2PxaIvq68tAnP18MeFFuWFhaNdzfVxswgg1udX9XE9hHL1vKJP67lq62O2CiTrLud6narP63O9+t6ieVitXz0cbb0PquWsHl+dG9U6N/pLpSvAd4AfAv8of/6vAy8JIX4C+CpwCPwTPID8N4H/SwhxzTl3J7/GzwL/BfCHwG8BY+BJ4N8A/jUhxE85515fcO/LwCvAB8A/zq//K8BXhBBfqsLQRo0aNWrUqNFfbklc6TCyxhDEMVI4ekpyqD3AwDiE8u4lh8NJyaPEMbcZG12Fs96FaHEkGT50qpSIHNhZ53NeGuvIjEdxWWa9w1JA7BxCa5zzLkcnHFKBExIVClJtmaWGeaoxxtEzjkAIZJ7nz7ki5KnAmzFzLOcscyOQgSDNLGmWuxeL/9I7rTLtSDXMtcZah5AKrWJU1PW/SDgP6Y64X8V6JUT52MNI8iyDxfdyf46zDistAuWfO4vD598Uovqdv+qyO8pS6cElPmzqMZaSb3R0uTNW+LKKqvOz6s4UAicEGskk1fTbLVABWWZxThK1OhzMpywtdREqz3+Y51B01qG1YZ6mDFoSbRRu6iCdstqJCUzLb+AF1laWuPL4E1x+8mmWTq0TRi1Ih4y254RR6DfVevrp7bgOiEOcAxW0mE4VgbIoael1DEiBcpJ5pDDPDLgVX2M0ugrv30S//n0GB2Ok1tj9A66GiqVBl890FL/lJgTJPR47s8T6JyVvX/+AH9zeZdA6xeWz5zm3vs5oJtFIho9e4lI7Y7ivmaea8SxFSUUYWWazhHlmiSOFNsY7eHHIQOHGY8w8I4jadHsDsmzONPEhc6OwRRgEtMKA1BnWz57lTKL92MXhnMnzVB45baEY29o7G8OYMPB5UEXumhWFk9K60iGcR//FATrLSBJNYiHJHO/e2+XyWpdI+nvIdojsxAilkEVQYmGQQYhSAUZn+bD23kWBJUtSjApZXTtFHEf5BgaFDCJkq0PhPNXGIQeXEEGYbw5w3jFqDS6bwOE+g0GfU4FhQsxnnniadDomfe11osMp1jpk5jgvBBd6AWrQZrs3oBW0MUaDNb7trP9sMTrhe6++xqODEd/65h+y9fART37yU1wI57z07TcZpZpMurwcrgzz6tf0R+3nGkj5Z63H8Btt3wT+BzwM/BX8mvXfds79k486WQjxGeCf49ei3wR+G+jgoeCvA7/hnDNCiH8I/F3g3wL+Ye0abeDfATaBr1Re/xvA/46Hp18F/ldgGXgBjzKlGQAAIABJREFUDy8/ElQKIULg9/Abgt8BfhOY4zcY/wPgc8C/+1HXaNSoUaNGf/n0Y4HK6o/2VdhQhwgnvf5R11wEHuuvL4KNdfhTPeek8046txqachEUql+/Dv0W3aMK44bDId/5zne4cePGsWMWqQqE6vnw6vc7qSzV4xdBmEXtU1xrOPSRIp5++ml+8id/krfffhvnXBmitQCWV65cIYqiMoTt3t4eQJk7sprfswCaBcgrHJdaa5IkodPpIKVkMplw69YtZrMZg8GAU6dOEccxAJcuXeLy5ctYa4njmE6nw3Q6LcMHX7hwgeeff54333yTDz74oASWALu7u8RxTKvV4t133yWKIjY3N5lMJoShX9y9/fbbTKdTHnvsMQD6/T6rq6slhC1cm/1+n263y87ODvP5nHPnzhFFEcPhEK11mc8zyzJGoxHj8ZjBYFCGu60DsOJx0T7F6wXsq8O5k/r1JPANR7CyCgLrY62+GaE6Lupj86T5tAiYV8tT1L9ep+qx1TrVwyLX61S8Vw2BW0DxRZ8/i8DqonpUr19vz0VlafSvvL4A/JfOub9fvCCE+K+Av4cHmP8U+I9cvlNTCPEvgP8F+E/z/wBfB04750bVCwshXgC+hd/d+osL7v1FvHvy71bO+U38Iu4/x4PPEyWE+P4Jbz39Uec1atSo0V82vfTSSz/yuaPR6E8+qFGjPwdJCZIi1yIeTOZuIyG89yhUEAWSTFuUkERS0FUW6STrKz1m0zmzydzjDOew2kehQYgyR5+RkrmFUBw5l0JgqB3MDafayhfGOTILJsswzqGNY5oZEu3Q1hFI6fMlCvX/sPfusZId953f51dV53Sf7r6vuffO3OHMcMjhQ6Qk6kXKlle2IXu9WiuIo0WQBzYKst5gN9oNsMhjYSTArvM0svkjCBJnsdnNAsYaiR0j2GRjbxbyWhJtPUhRsh6kJYoiOeQMOc/7mHtvd99+nEdV5Y86p+fcw56hRAqwaPVXGHX3eVTVqarT7Lqf8/39sF7j3BRvocgDoTEqoD3nZ8E0A/7xntjo4KysQnnakKMyUoIrgaR3HvGOlk+JVBvl8uAK9bcfzPS+JEKzn9i16CyBQoJU3kw/Y4V4ggN15moMUPR2ikaZtTV8Aqo1EOW6pryigEIrwFKtZ6ry1OyzLwFleJHZ64iYbzx/g1/88KNop3HOoowh6vTIhtt0l3rk1pFmBeJDCNuisEyHR0zGlGGCDcPDPgcHBxRFTpJ06MSK0xurnL3/fk6ee4CllTVaSYu4nRAlScgHqjXaGEQZlDbBMesht46isETtDu6oHxy13pTrTcdkYjkaOg7bf5Gzv/QpBv0hw51rXHvsvUz7feKjEeKElZ//i+zlY7733e/ykfc+jrc5+ILV+x/l3vfs8nPSQ7eXWd44x8qJJfCeKy95/vizMfe//0PclBdoX9mhP7jCuChY7nXwypK0hOWlZaajI8ZZjhYh0oKLE5Z7S2xunmRrc5O1lVU67TbgKVwIhVzoFt3eKieMZ/Tqq+EhWOvCiJTg/FgYXwFtDPicqLdJFBmsPcJL6bgVEFeHa57Z8k880+mEcWpJfYDiw/4QNrrl7HFh9liHyzK8NuGelIAs83Efm6cYX4HTcCcVeUEuhqM0YnvguWcpgH9t2ogxpa3Y47RA1EPpELIZP0Op5GmGV4ZkuYuaDCisI3cWK8J0ZYXljRP4/oCjncOQR9Z6nGlhdIvOUoe9cR/tw/dSgcd5x+Rwh2c++3tMiNnd20ZlIxznaK1YJpklK3KssihlZgZUQVDKhHvClw8FSPjeWOiHpp8F/gfv/a9UG0Tk7xPg5T8Ukc947wfzThSRmAASTwCf8t7/dmP/2drHfwz8KvBpGqCSAEZXgf/Oe5+X524QwKIBft57/4W7lH0n/R0CpPz7wH/svbfluRr434B/X0T+qff+d+9Sxve1bn47vzV/HFX9vl702w+mRb+9NS367a3pB+23H6V189sClTAfiMwDDNX2eeCvqaYbqg4e5h3brOvNXFfVa+X+bAKZ6th5UKIJOZp1zcvh14RAcRwzHo959tln+c53vkO/339Tp1y9nvp1zDumrsqldjfNAzH1cfXezxyRy8vLfPSjH2U8HrO7u0sURbN+LIqCpaUltra2uHXrFoPBYBZyEwIsOjo6ml1jHVLmeU6SJLNcj1X/WWvZ29vj5s2b7O/vkyQJe3t7dLtdWq0WZ8+enQHAakyrEKciITTraDQiyzKuXbvGxYsX6Xa7iAjj8XgGEIfDIa+++ir7+/uzawK4du0ap06d4uTJk+zv79Ptdmm327NxrBySSin6/T5f/OIXmUwmfPzjH+fChQukacpoNKLVamGtJcsyhsPh7PrmhSOdB/2ac7MJIO/0EEB9Dt8N8Ne31dtRbbvbPTvv3q/PnXnzrH49ze+FOwHzu4VYnVdP3ZnZ/Fy/Tjj+0EWVe3Jenzb75E7AdKF3hC4TQGJdv0kAlS3gV/zxcDK/DfwG8IFqg/d+Z17B3vvnRORJ4OMiElWLtppeA36tcc6/FJHXgZ94C9ey0EILLbTQQgv9iCpkaQuQQkuZv9F5JtbivMLjmKBIxJepET1KoKcg0p5TW+vs7h/hbYFNLQ5PXoRwnqJ1CG86owMSnHleZs4+IYSWdQjB9CR479AitIyCFkS5YlTAOLUYAefKyDfeIR6sA+sKIES+BKHikVoFT5jRirjdYjzJwHu08ihxtIwGBJ+HkJm2KFDKo5wi0kIrUoizDKYZV7d3iDtLOOuZTEbgQhvCNQoohTYxJmqhjUErPQvBqiSsO43W4fe5d4iA8YKqQrVK2TeBViJKob0P/TSDKR7vA9SiWqeUrjqprS0qyCklVJ0BLoJj1YpmOM549dVrPHBmDWcLWt0uYgy7tw6Jk4hEaWxhq5SYGK1otVtMJ3t4H9HSigdWYHXlJE4Z4riNMhEmNsTtBOOPiFwHX0Tk0xRrFV4EVbooj46GpFmGiMLZAlso2q0eykQU6ZjuqsUWKXFc4L1CeUinnsnEoCVhbEdM2ifYeOIvsH/zCtdvXue+R9/P2qPvxWUTZG0L6yx+0md46wCLQSdLLHdPsLp5KjhQfcprly/xJxdf5bWR45Unn2b75k0OhiNGac40K5gWFufg8Q89jrY5B7d2yPZv4YF3PfAQD5w9zcMPPcL5Bx7mhZde5aXLNzhKPYkKoXiVwDjLiZVmPBxytL9fOmlvQ+xqbIK7MgBMrUDFbUzSIz28RivWtfvotjMQH1y3SLleRZFPU9LcYlG0q1Qi3uElhBRGwE/6ZOkRKH37oWMd4b1DlfNLcFQ41BY5YjQ+j+j3Lfdmf4IZ7eFOPcE0WacVCS537B0Z1nrQKoGi9+VcRMjSjPRoyNHRZDZ3bZ4xGU+wG2vsC4yBSWoZDyacWF6m3Umw117FLK1jsZxSHt1SXJkEh7UzQlHkOBzpKMdQ8PorL5GsJ4xSiy2fK3ClE/P2l18AnY6QXRbvUYuUKT9M9Qlr15m8918Xkd8C/gohWtBv3uHcXyJEFPq9JqQsy7lae39DRP5f4N8Qkce993X492nAcRxg/hVgGfj1JqRslj1PEizwf4vg0vxPKkhZnmtF5G8DfxX4FDUX50ILLbTQQu98vWVQOS+XY901OQ+oVKpvb0LJecc1w1Y2672bw2keMGyWV22rqwIZ9fx11XFN+NPcX6+n2l59NiY8sXj58mU+97nPcfPmTXS1mCrVzOPZrKMJrpogtwlW7gSQ69c6r/zqfeV8HAwGTCYTTp48yQc/+EGee+65mUsyz3OyLJuFXa3e18O6eu9njsIK2hVFQVEUs/fW2hnUS9OUfr/PYDDg1KlT9Ho9tre3eeGFFxARHn300WO5B+tzSWtNnue89tpreO/Z29sjTVNEhMlkgojM6uv3+7TbbQaDAQcHB8fmgtaayWTCwcEBURQBcP36dU6cOMHW1tYspHA1tlEUkWUZFy5c4N5772V/fx9jDO12e9Y3IiE36ZUrV46NcxzHnDx5kjiOZ/CzCevuBO/vBsvmzVUI92tRFLP3ddXnTb2OZi7NO9VXB+RN53X1/k7n3QkKVmU2v2PqxzShZ73td8pFOe87qOkerYPleQ81LPSO1LP1RU+p6+XrS77hkiwXRduE3B0zSQhr8zeAJ4AN3vjf1Q3gxvdRN8AV4KferOHe+8fnbZfwxOiH3uz8hRZaaKF3ij72sY+95XOXlpZ+eA1ZaKG3IS0gEhyUkQ558RBPSwlTWz0458lsICqZdXQiTaQVsRbaRqMjMwMu1kGW2wCBtA6Qwnsi8SSKkMhRoMCTFY5pHpxNznniSKPEh/CvMxeiQnDExmBdCPeISNlucF5hvQ/uNA/tqPztXEKc3HqcBDenF0UrjkL6jrQgiVSZhw+EAJWy3KGwAeZ4h3IFsXI48bz40ou0ust4LxRZGlxoSjCmhYkilIlQOkXJEUgtBYwShNCvIrdholKhvwPM1CXQDE5UrULbtDFoEcAFJ2IJP7UyaK3w3uFsAeVDsMaEvxEoFfJwZoWlnvcyhIgV8tzSimPSyZh0HCGiaXdXyPOC7Z1bnD69Dr4cx/J8rTWttsYYsIVDRxFZ6yR6+SRtcSixGOWJlScyilhnqMl1dFrCWDRV/FxrHd3JkMR5tInKPohQrhVceIC7JVzLUrSx4LsUeZvxKGI8uMrUPc0kzXn5uWc43Nshm07JplO2v/cttl/6IJ2VDUzSRSmNMQljIlrdVSQ9pN3tQbJS1qvRccLF7z7PTzz6EBef/ybbRcbq6hqtowE30z7iNcudhO7SKtPD7fBwMwpbFHz7T57n6u6QYfcs+aZle3eX/sEuxfgIaZ1GiWBMxM5rL6FaHe7fPEF7dQmtFDM86R0ipnTKli5L7zEmwtoRo+2L4D2teJmZ91YAFN5byniwiA8gGyDPMya5RYzhPefXeNdGjJGa/7JaI7ocsHjv8Fk28+ZqFZyYt8PJesaTKbTaPPTeczy8pVGT5ZDH1gvFpMBaQ8soYinDvAJgZ25gxOCLCfl4GACl80zGI9Q0YzA6YpjmdMTjsoxobZloaZlT955l0O4wvVmANmTTMXaacn+iOZwWjLxHt9p0TUGkYu4/ucKVK1fROqKdtFEqRN4SuO1YLVUUGQ4VAKbUwkcv9MPSN5tr1lJ/RICFH+TOoPIj5etnvs+6/gEhvcmnCXkjEZHHynI+472//DbKbuphgtPzZeDv3uFvTxPg0Tcr6PtZN7+d35o/jqocWot++8G06Le3pkW/vTX9oP32o7RufsugsvqPRZXHD4679+rAqP7H/Du5DEWEPA8JwsMPf3XMRVUHBvPKupPT6U7Os3obqnCsdbBRb1cdPjYdXU0HZB1ONl8rmHXt2jW+9rWvcf369VmI0mZewGY/N6+lCUvqupOLrbl9HnCaB7UqWDkajRgOh2xubvLII49w69Ytrl69iqvCrZQhW6v8kHmez8a0CYGq8KzVHKlUhUn13s+gXgUF2+02+/v7XLp0Ce89H/vYx9ja2pqd28xdCjAej3nppZfeANsqUFkB0slkMnNiVvNEKTULDXvy5EnOnj3Ls88+y/PPP0+SJJw7d27m+nzhhRc4f/48n/jEJ+h2u/zkT/7krO44jnnsscfY399nf3+fwWDAxYsXeeGFFxgOhzMAds899/DJT36S++677w3zvAnVqvuqcv/V8zs2QWF9jJv3VRNcNudHNV7zQHYz92x9js17QKEJ+SuHY7Od9TZW5WmtZw8O1MPE1r8b6n1V3VfVnKr6uCiKY/dp8/x62+vz9k4PJsDt0LkLvePUb27w3hfluL5hX6kCiKoPIvIfAf8TcAB8Fnid8JCyB/4SIQdHa045h3cpX91h30ILLbTQQgst9A6Ul5A7UomEMKEKcJ5Ia7QVBEsHSLQwLo9TJXyrwlOaTpvMWrSCzEGeZXjnUDq6nddSgnOyJJd4hFgrloHYhM+WAP4UpvzN7MGVuSuLDIXgFYg2IQ+e0XhcKLIMv+p86dAsf/+mXhhMIT/MWOtNiTRMplnwiAnBcecFJ6oMCxtYRXhotEC8x9mcTrt9+9pFEfeWQphVH+BjFfHVWluy2OCkFBHEKbwUKNElFC4dpR6cOMKFl4FZA7ua5a48thaQsF9BCUKrUbwNRJUEABbel2tLmIHkEJBDEccG5yzd3jJeBKM1cWeJLMsYH41QeJSnDP0bwrW22h0G/RScZuv8I0zynFtHR4z1MniPzXO8KwAXIK4PAExJCB+scShv0Vi8y9AYtHgUlkgcxjtMlBIpT6SgpYXDyWpwxCrBaEG8Za2rkMGzrOG456EIefAelI6Co1RpRA6w7hZ25LEoCuuxDtK91xhMciY7r5BGbZJ2AkB7OuXPPXqOzomTGF/QTRI6p85y8ZVXaMcxj9x7mp/7yQ9gPPzhzSnOBeftg6fXuXelxXMvf4Pf+dYz/E6ry/LaOvecvod77zlTOn0dWTYl0oJxOdPRuITPt/tntlbz5VhJcDJ7AGvxSqG1Qcpwyvgy3UrlxfQlTUSoSGOR5YwKh4kSTix36HZNOX2knLOUdZQuzpnrsZpSwUbrnUekQEQzGoewvLrVIUoiXOshvAcdKbplgBZbOLqJxo92cRoKr/Be4UWjtSA+Jz0akvsAqz0KbwsKD1Yk5J9UBp902DRC/9Yho80ztO65Hx8nuMEe42nODQKMdz58B03TKd0Tqyg8WjxFkTPNi9KJTGlbFaqAzODx1mFLkBqGwOJYOCp/iNq+w/ab5evKXc5dLV+vfT8Vee//UEReAP6yiPztEpD+B+Xuf/R2yp6j9fL1IeC/vMtxvbdY/kILLbTQQj+iesugsvnH+ibkq8OGan8TItbPr4BLfV8dvNQBRQUwmqEcm7CgCSSrY+Y5verhHuugqp7nrnpf7RORmfOtqq/pKgVmbY+iiP39fb7xjW/wzDPPzEKA1v814e6dIMndxqF5/U3o2Oz76nqaDrR6fxVFwXg8Zjwez+DhBz4QIiBWsLKCi6PRiPF4TJ7nb4BQVZnW2lm+yAoU1/u2Gvfl5WV6vR5pmrK/v8/169eZTqc88MADbG5u0mq1jvVBvb6qnOl0+gYAXvWtMYYkSWbjW6nT6fDQQw9x3333cfr0aVZWVtjb22M4HJJlGcDMQfnoo4+yurrKfffdx8bGBisrK6yvr3N4eIiI0Ol02NjYYGtri/vuu4/BYMDS0hLb29tkWUan02F1dZWzZ8+ytLR0zLXXHLvmWNXvFRGZQd55jucm6K8Du6pfKpA3z21Y76P6XG/C0eacrM/VCjjW29h0Sja/J+p1VNC8uq+qbc0Qr9W59fuzCWabDzM03aL116azut4XzZyxC/14SEQM8F8RFoIf8t7faOx/U2fkQgsttNBCCy30Z19WgiMRIHWeqASJIRykQ7xHKSEqQ1VWv1ZLzyJ4RztpY63HGA3iyQpLUcK2CiJqNAJMLYgqsytK+J1sCL9hc+cD4BRKSFf+9vUepQXjQ0jXVrtFhuCdxxUWZWK8zwBPUThiFeoBaAksK8+y8SQtgxLBFh7vLEXuQg4/hAKwZQjNKIrC2hrQkSFNM0y7C86ipHQ7ajXLFZjnGW7WMbXf6gKKEi7hEdGltSvsj6KYOIpmcHJWYBku09p85oCUEm6KvHGdUEFOKUGTSIh3q2brpDB2AVKF5gTHZQDARrfQWhMnLQ53dwKc9b4M06rRcYROHcsrG4hvkSSOSeE4Go5Is4yCcQhF6lyA0s6B9zgXHsgM8yS0oyjAOoVIu3SUEkL4unIdKKX7UgDnEHElWAvb8RaFQyvBCGhJ8N7OAJXWYCTH4DFaiLRHK0dLC0Y8lhA+uKWnxCrA9d6SIzq3zAs3hiUUzxkM+vg8477z93Fjf5dXblzniQfvgWzMSrfNpz72Ln7+w++il7QZD4Y8/+0X+dw3X+Hrr7/Cs1cu8crGaR5813vAOfYPh9z7wHtQSnjtpedZKsZcubHL5MQSWsAIRFHIAxrWjcEpm3tHFEeouEuUJGjtsEWOlnKtV94nzroSWroQithbsjxjUng2T3RRxRRbtFEQHMTMpmFw+ZbOyWpuORfAZ4kwseXYjacZrc0uvd4S1kJwgTpcIRhdgnMRWi1BJOR2xYMRCbkri5zM52TjEUWeM01zCpWwu7fLFGEtiZkeDBnlnnx4xLVJzkrcY/WUYCZDpN0hyzOOlOAzS1RyWfFQOF+GeLUoH9yaNi8gPENQYd9aqN3yu0wqSFnuPOa5XOht6tQdtldP89/p4Vu4/eDsmR+gvn8I/M/Ap0TkN4F/lwAj/7+7lP3tH6D8SlW7/5n3/l9/C+cvtNBCCy30DtXbApXNcJEw3/nXdDje6ZwKPDSBXx1CNF2Addhyt7Y266rew3FABW90ltVBSt0B1ryuppuyup4qPOnh4SFf+9rXePrpp9ne3r4jWJ3X7vrn+vY3K2Pe9c/bV7nPmvn56sfdvHmTGzdu8Mgjj9DpdDh37hz9fp/xeDxzBmZZxmQyQWtNFEW0Wq0ZyGkCMOcck8mE/f39GYBaWVmh0+mQJAndbpfl5WWUUty4cYNXXnmFoih44IEHuHDhwmwsoig6FpazCc/r412HddV5IYSPmTksO50Op0+fngHMLMvo9/sURUGr1eLhhx/mwoULtFotNjY22Nzc5PTp05w4cQKlFJ1OhyiKWFlZIUkS4jjGez8DluPxmMlkwqlTp8iyjKWlJU6cOMHGxgbtdvsNY12/h5qaB53rr02IX4edcByy1cF4c6yq/Xe65+80Z5pzrt7eyo1a1zynZP3eq8/lei7NCkjWYeQ8sDjPGdosqwnX622c15/176eFfqy0QXha9P+ZAyl7LEKwLrTQQgsttNBCQOFDrsgqxCOlszAritJt5UEUsdHEziPOYRRoLSVQFLpJOwSs9B7tocgtzlocctu/pDxGA5nHWkesFU6C68/6yhVWOjV9uVbyAdg57ykcKK3Qvgql6vGuQFQAh86DiKcTK46UIlcuGBWBjoZuJESmfHAST5GBVoK1wfFpEVJbgjKtsTa0E+9wRUYURRR5+SByCd88Hq2EVrtdwo/qN7cw+/l9bK2hQrsDIaJygZYrEKhyDpbyuBL+hd0yO1Juw8/Z+8p1GfYrLcStdhk2dmYooxw0RDR5bnE2RIWJ2m200UyGAyIBURGgEAVGaWKt6PV6AQpLzsH+AXle5pf0jiopqBLBax3mglbhKnxwx7oyWaCUadZdETx9Hn/b+SYeZ287QnFlX0ugUlV+RXEB7HnC/LDlA63Mrja8qtKl6gPSClFS8RitQ9tcgQAtY1hLQge2IsNr29tsbG7SSjqsrJ/kq99+la9/5xVaCpLI8NVLh/i1ERvrLYzqYh78EL9w77t5981Dnn7+Cjd2dnjtu1/Hes/1117m4x99nDP3XuBDj1/gZFejjELr0nmsJIRE9tW61WGdJ4k1yVqXwnusG+OnBWPJw/iWgJoqxKoIvihw1pIXBb2NLf78Tz1GEXc43O8T5VPiKMw/pRStyKBVeCCB8n5XCiIdnJdewthRrkFHowl7Y8fuUcHNwyEm6bDa6xKpAP1sEWbgcDgm6XXB23L9DbkH0YIvhDiKKLIp40nKZJIi+QTtPV0EmSoS60jEQQRRq4Vq9yiUJ2FI6lbJshSrDeDIrA3hZMoIYHFkKPLpLC+rdSHXbfW/ACk9tTsnzMPZJ1lgyh+uPiQiS/6N4V8/Vr5+6y7nPlO+foIAIL8f/Sbw9whOyilhLfzr/o0pTZ4hhIn9BPD732fZdX2PADs/IiKR96WdeKGFFlpooT/zetuhX+sOrWZ+uaazqwmR7gYi69Cvfmy9rno76gClCSSaoKUKtVptq9fTbE8TrDSvs9n2ehkVPAPY39/nm9/8Jk8++SQvv/zyXMA4z/FW/9w8rn5Mdd1NGHwnYNUcO2MMSqmZ+3AetLp06RIvv/wyH/nIR+j1eiRJwtraGidOnEAk5F2soGwcx4xGI+I4ZjgcMhqNjtVXvVprOTo6muVvTNOUU6dOsbS0NKuj3t4LFy7w4Q9/mPPnzx8DWlW99WOttbOwnHXnbXU9nU4HYwx5nh9rU7fbZW1tjWvXrrG9vc2JEyc4c+YMW1tbLC0tEccxSZKgtWZpaQmlFIeHh1y7do0sy+h2uzz00ENMJhOuXLlCu91mbW2NPM+ZTCaMRiMuXrzI9evX2dnZmeXG7Pf7PPDAA/R6vbnhjpv3xbxQqvWxmzc/K1VgrwKBlZrQrT636v3YdGU24eI8mN7cXt/fhMvNc+vHVfVVY1uVWw/BWvVB3cHZHP+qTc37oQ5Fq/ZU51fOyubDDQv9WGqHEOb1cRHpee+PAEQkIjxpuvGn2biFFlpooYUWWuhHQ4UHER1CpYrM/sCfZxnoCPAYJWgNrTjCZxlGa4zRZahUR6cdY6KICIfWntxavC3Ispwsy2m1NMqHclCKvAgAQ0sAem0T3HIBJpUP3pZ5Mx0O70BQOFuGkM0KxIQcjiHEq0WLQ4mEEJsGJPfhHO9DyNrUcjSakLRivPVEKniqjAkAMXcEIITHOYu1BThb5uqztOOIQTqZAUo16y9AAlAVqZygzFyOs1fKdYEIWgJYtRWErKHK2yEqQ25IE4U8ilV/UMJfNeNaNTxaWzs4X5G/slAfQvsqCWtSh5BnOd5axFna3R4eIZ9OA67xt3MLGqUwWtNut9E6RIVZW13maDRimqbgyghQEtBgCC9b4R9HMOgFZyQS2uZdAMu30VD5dwJfugNLgK5KZ61D8OU+ow2VTw4ErTS2jGpTuVGFANucSAiV6wXrHVppnLMBmuJxLmTgtB5WWhoxLVpas3n6Ph545L288tJ32Lu1j/egxRMZw9pSh72b2/zBlzyPPP6zJEtLZV8tEa+d4cO/8DjaFVx86Tt88ck/YOoHXD+Y0DslPLXTYSlplaH0V4szAAAgAElEQVR1g3tYi0Mp0HiUcmgB5R1aKzTh3tMiwTWapgiCUR4jDqMVWoUxjZRDeYcYxT333cPG1gbtdgtFGWFIwsgrMYhWARJ7hyiPKIP1Hm8JcNwXOF+OnXNkFn76Zz/CyGoG3/4SF1/tsb51hiSJQ7uiFtporIX8qF3+XStGGYOzluFRikQtIpVz5foend4y71pdQ7QO90LhcUrjy/C9TjSiI7zpcdV1WV57mJuHOa7IUQLTwlFYcCi0BKd1krRwR2OMFjLrKJw/9qDAsbulume9zLYtHu39oWsF+C+AX6k2iMgTwKcIrsR/dpdz/zlwGfjXROQve+//z/pOETnrvb9a3+a974vIbwN/Dfg1QlDtfzyn7N8s2/U3ReT/9t5/8c3KbtRTiMj/Avwq8Osi8p967yeNMk4Da977797lGhdaaKGFFnqH6W05Kq21x0Bh3f1Uva+HbGyCkqZjap6Dqw5AKvhX39cEX9XxdTA1b3/9Oio1IV+1v769KruZN7C6JgjQr17O4eEhTz31FJ///Oe5cuXKsT5ptmMewJyXa7DZ7nlwsXkdTXjcrHceUKrXs7Ozw2uvvcbe3h5RFNHv99nZ2QFga2trFhq22+3S7XY5PDxkNBrR7/cZDoeznJPN+pxzZFnG/v4+eZ6HxVoZkrXdbtNutzl37hyrq6s89NBDnDt37ti51Vxq5vqs+rkOtOrXniQJnU6Ho6OjGaCtjq9cj51Oh9FoxOXLlzk4OGB/f5+9vT2896yvrzMajQB45plneO655+j1eqysrPDJT36S/f19Pv/5z7O8vMwHPvABjo6OuH79OoPBgJ2dHV555RWGw+Gsv1dWVnjiiSc4ffr0XCBYn4/z5v68OdOc69W59fyQ9RCmTTA3b17UX+eNZx3uz3MxNucg3H7QoBl6uN7u+n3dhInN8utlzqtn3v0zD/I34Wz9mpr1L/TjJe+9E5FfB/5z4Nsi8rtADPwccAL4w/L9QgsttNBCCy30Y6ypkxL2hd+51jk00I4MuVfB6SYB5GitKLRGVJ2BeZJWBHFEkU5DGFVrw293gcPBlKVuRBRpvDa0WoqWDnknlVEUCjIvjFPHRkcjWmGVwlpXghQIUS6DF0oEojgmdQX40FYlATVoL6jSbeZnv8mFwsH+FDKnUdaTTTOUB5QiMhJCoHqwVkKKPCXEJTzVWpPmOdoYrLOhMUpXVDL8Dgec81hnMaWLkGP5JUsnoQS3pteqBlBuo0pfhmi9jUzKdSPByVrlzwuhXVUJ8247Mj3VmkHPAGAFUKviKnemdZY0y3BAq6VJugmTNEWcDfzV2bJ+HfJueo82GqR8KNMrssKxf+sWSadLbAIwO5oWdBNDJ9IUDqYutDfWBqs8RZ5jtD7mEp15PkWwRTB9Kgnz0uJCblJfu/bqmkTjncUWeRgXY9Bl2NTKI+epz1VwLgDYKlyqQkBBYQucU2RpinY5o+EhLz7/HEeDW6WbNsc5z3BScNguOLOxxOXtbS4+/8c89P6PEMdtRBROe7wXCi8knR73v+u93H/ved794Y+ye+MGhV4jszpQZu9njuXS+Dm7p6ggrgchQN4Kkosv/5UQGO9nILiCxILCe4OScI2Ksl/xaHFosYDDaE0kLjikCWFyI63QpfMwNgqjDFoi1EaHFaNCXlHJGN26xESrMGdgBkOrPK7aaAKANnhblP3tOXfuJGfuORFc2BJCOAfQbRActigonFBYz97AceMapIUmd1lwzpYj66X8bipy0sKTZgVZmpfXGvLVanU8l+tsNvjb74/Pk8Xa+YeoLwJ/TUR+EngKOA3824Q0u5/23g/udKL3PhORfxP4A+C3ReTTBCdkG3gU+PPM/3vxPyCAyjPAP58HHL33eyLy7wD/FPhDEfkM8CfAMvA+4Bxw/5tc238LvB/4G8AviciThDCzJwm5Kz8K/B1gASoXWmihhf4M6S2DyiYMrMOR5h/466q21/Pw1d1ddVhQvVbgrx6CsemQapZfBzLN8urOr6bLqoJZzWMrzXOPNdtZnW+M4fDwkK9+9at89rOf5erVqxRFMTePZdX2ejub9ddBZLOfq/PuBE2akKnaVp2bpulceFOXtZZbt25x8eJFBoMBL7/8Mlprzp8/z+bmJkVRcOvWLfr9/mx8jTGsrKxwcHBAmqbHwHYTkhZFwXA45Pr161RuuKIo6PV6GGNmTs1qe30O1OHUvJyhFVyqXJZFUcwAZz1krNaaNE3p9/usr68zHo9xzmGM4dKlS+zu7nJ0dMTW1haXLl3i+eefp9frcenSJa5fv06n0+Hg4IBvfvObDIdDrly5QqvVYjwek6Ypg8GALMsYDAZMp9NjQDHLsln+xfqcredvrQOyOzkh6/OkCTPr4LACuNWx9brrc6sJOOtl1efuPBBaD8faPL6CzPVwyvPmXh2yW2vnOofrx1VlNOd6/b6typr3PTXv+poPDNShbhOAL/RjpV8FdgmLtU8Tnlz9LPB3gf/6T7FdCy200EILLbTQj4jSIoTljE2MVTm+zAGovEOhUUoQpXDeIgpyIia5pR2Xa2wPkdGYdkIxmiAKCusQhF7SZm1tiXQ8xkSasXVMM0tbK7QJ0FERQnsaCbBQoxAsUqZhiGLDxFnyIvxmj5UBY5A8uP6UUigdynJA7tVtoKkE52BZQ6wc7UjotGNio/B5gXO1NYkXLCGCqRCgrEcQbbDWokWF3I0lbAmOx/K3uZqhNvwxQCmgqqCSAUQGb+Bt+donKQPIlkh2BqaYwdoAD0WEPPcc7l4nHfWx1rG6eYqlEyfRplW2nTKcari2CoBaa8Fp8txj8+CCjJKEKOlyeNDHlH8L8d7jbIF1DusKvHM4hCzPKQrLcPc6o6Mhu699j17X0I0jlpMeT/3hF/jo++7nwx9+hO2DAb/zxZeYEvOJJx7h5d2UK1euIiYiimOiuMWZkxucP7XOld1bWK85udIltZ5CNEYLK0mbzBaAonABTlXhd7VSwWWqIZPgDNZKYb2FKuelD7kLheDidd4TG4PH4svy8B68wxYZnd4SD7/nfWzeSnnx0iWUNjjxxBJRZJ48L9jpj2nHPbbW2tzYfo3XX+xw3yMfxMQRHuHw4IA4aTNJp3TWz/CuD/wE165eZTIa0lteC2PryxCkUjLvGlqd5U+snLMAXs3mi/jQ7gA5q/VhbY1aOUrx1P5CFeaTs4BC+XCPeFvOtDzktwwo0xHYqA1dU+awDHKzWRsMvR6FA1fNTWb7VJn/UsQiOMTbEJZVKRSqBJshlHR4wMCiBbTSaByR0YwKwzQ7YrWrwVnyPCMq+wYCnDZaoYxmuWU4vDVFBEwVbawKX1v11+zcAMm9ENpUjcWCU/4wdYkA8v778rUFfBP4b7z3//LNTvbef11EPkB48PYTwJ8DhsBFgiNy3jnfEpFngQ8A/+guZf8LCe7O/4wAPT8OHBDCuv6976NtuYj8JUIezF8G/lWgR1h7XyKsw3/rzcpZaKGFFlronaW3Ffq1Dh2bIKLSnUIvwnFXUwWm6oCwCeXqZTVDyjYhXhM8zIOa89xb9XNgfpjXJsBogp0Kqm1vb/OVr3yFJ598kmvXrs3A2Lx23qn9zbx888BwU03AeLe8gvW+aDpbm1JKcf36dT73uc9x5swZnHOcOhXyd0dRRBRFM5DYarVYXl5GRFhfX2d/f5/Dw8Nj0GnedRdFQb/fJ89z+v3+LGdlt9vl4YcfngG9pnO32Xf198aYN9TnnGM0Gs1AYJZls/Om0yn7+/sAtNttvPfs7e2xs7PDeDymKApGoxH7+/sMBoNZCNitrS2yLEMpxfPPP49SitXVVay13LhxY9bOCkjGcXwMBK6srBDH8bExrNpeAbr6fVYH683xbwK6er/M66/6trpj+E6uwea8n/e52ca6e7MqY978rl9HfVsTvNaBZZXvshmytfkAQr3+6nurWda8+62eu7UJxe92zyz0oyfv/WXuEnnIe3+3ffc1PhfA/1j+a+qXy38/SN0fu9O+hRZaaKGFFlronakQ2tETR23yIgWxiC8fSNWCE03fFnS0YJTGRELuHarwIA5rgxur1U0Y3LSYyJBnIUelUkJkFDoxoISllqLjLUXhcD6EqyyjwSKi8CVgQSt8bglHCA4wWpjmnqyo2heAoShBozBS5swETBRhrKB0WB+vRIYkNiTLqyS9LmIMgsGLYpLnaBV8fT3ridc66G4La3NyE4EXdBTjbI7Bo12BcgEpBdAJ4kKePymBjqC5nRfvNrSsIA7elY46hzhXkqrSb+ZDmZ5qXXobcmod1mKI4O2Ulp+w3PFobThKJygd33ZNwgx4hveUwNOBmNn6oRVHaG1QUcxkNCRkKwnwunAepSPWV5Y5yvp4gTzLKIqc8WRENpmws7vLa6/u8/i7H8ZqxWS4x+Fum4ODE3z3hVd47ZWXmRJx5dwGN6/vc/m5r5Bah5RA1z5wnkkv4tlXrhLFMf/KTzzMU994mXHuObO+zCd+7qf48HseYHt3j9/77DO8cmvMxGnQhsgYVNzGxDHGROg4Jo5arHTaxEbhRFGgQUdoE1KxKK1I2m18mY/UaE1YzgnJyjoPfuQv8Km/+ss888Uv8Rv/x2+RZimTiQftMJGncMHXut2fcs9ahwunWly8/ALKRNz3yPsAWOq2ERXydCZJgvXQa7dCWF2lZhjS1/7P14BaYMs1GOgD4Pal7c+FKYDHhTlIcDDOHLcOnNzO+3k7DLA7DkhL2FczFwYoKSE0b9U+7+X2e/QxZ2eYowqp/+muuoZyLlfwvdrmqwuZwdVyjT6zlYZ9Sgkut3Q3V0g6inz3JYz42/C2vO4sy0CHUNQT62n7sB0BraClKB8yCPekm90dVd+WEPPOy6yFfgDNWVN+8k2O/yfAP7nDvteB//D7rVtEloAHgdeBz7xJvc8D/96blXmn9bcPk/d/L/8ttNBCCy30Y6C3DSqbgLL5x/76652AYHNbvfw6RKkDp2Yb6mU1Ycm8uprHNPPdVdvnQa55UKK6tspVefPmTZ5++mm+/OUvc/ny5bkQpN4/VRnNeuadNw9CNa/pbsfczf3VdMXW26SUot/vc+XKFc6dO8fy8jL7+/u8+OKLxHE8CwdbuRCVUrRaLdbW1uh2u7O58mZA1FrLYDBgeXmZKIowxrC8vMzW1hZJksycf1Wb6m7JPM9n2+sQrw7Jqj6ZTqdAgJErKyusrKzMcmJaazHGzFyQlROyOjdJEs6fP49zjvF4zNbWFo888ghHR0cA5HlOHMd0u13yPGc4DPnNtdbkec50Oj0GH0WEXq/H+vr6MSA5795o3kvNvmyOW1N1ONqElfVz5s2dJvCfd7/X65/nXm6CwaaaYHIeCK23qTq2OdZ1OFnf3wSgzVC39XbcDfI3y1looYUWWmihhRZaaKGmlI7wWRocgmICPEMCdANEafamKaPMcXa1RbebIC4i0g6fZXjRKNH0ljpcsZ4YyzQrgqtSV94wwXtwVsiKYGATD84LWnuMUrMwjoUPaxIdm5DP0gsmyul22qxGMQ7N0uoaS0oTRwa0QeuIkyJIYWlFmmnhyH1YVxRFgY4ier0uURQjKgoPMxtFllt63hK3kuAjcwWiBIkjVAlqlHMwOiLr32K5HcH0IPyG95ClE5Q2jCYTXF4QxRFGa1qtmE6ni9KaVhThRZEXBdY6jNGYqMV4OiVWCufLsLVGz0JVBnSjsLbAIQHCKbkdchZIR2NwOZNpn42te0mnqnRh1tdXJRyqnGIVgPKeonDBfeg8XhkswvToCIUiitoMU820vUTe6rD5wKOM1GWSKMJ7ixLBxAneK9JBn2l/j8S8G6M1eNjd3efw5g1WDKwvL3EwsazrlH074L2nl3hld8g49/TaMTe2b3LzRs5wktPzju1bh4yGA9730H34uMfWA++GrfewtTnl/MsRr+/doH94iOhbnFjeZ3qUcWtUYL0mMsJ0OuCv/1u/yOPvOsuly1f5X3/n99kb2zIXawBYojWiDEpHaGNQWhMnCe7nfoG1ex7g8q2UCTGnz9xLf3DEZDrFWkekDa12gF5plnN9f8TGSoe8KLhx+SXWT50nOtVl4/QZJoN9sqJAoi6tzhKnT27y9a9/A5yn8K7moCyBYRmitUJ4ZUxXLLV1LOC8QzwBwpfhYx3BEVqNeeCSfubcdL6CiuWckGrNOiOK5anlutGHsKkBRlbQvISaPpTsyn1VnlA/Kyu03VPC1GrezSBltU4tnaNlm6xzKAkuZnz5Ny8b2u5zx/bBEdiCNMtpl1dqATEGYwyxcSRG4YoQMhrnKKwjiQz3dCyj3DMoKiB6+y6pXl153X6xdn6n628SnI2/5r2f75xYaKGFFlpoobeotwUqK1VPC9b/qN90S9VBRT235d0AQjOXYjFL4B4+a63n5oqEN4ambULVZq7JenjN6l/luGrClSYcqYd69d5z7do1vvzlL/OFL3yBGzduvAGw3A2gzgun2TzmTuDmbsfMG7fqc71v6mXUj627SZMk4d3vfjdaa771rW/x+uuvs7y8jDGG3d1d0jRFaz3r0zRNZyC4gnPz3KD1tmutuf/++3nsscdYX19nfX2dU6dOYYyhKIo3QC7vbzsVK6hdgcV6X1afqzCyURTRbrc5c+YM7XabCxcusLa2xuXLl5lOp1y7dm0WtrXuwEuShM3NTW7evMmVK1e4cOECTzzxBJPJ5FjezAqUVSF/q8/NMMZV2+pgrXKP1uflvL6a5wxuugeruVXV0YSAzfDB9RCv9Tqrf8065+VRrdrRnPv1+XYnN2gzfPO8hw/qZTVBaT2caxMszgO5876DmvO/+Z3RdIovtNBCCy200EILLbRQU4WzIJYsn+AIKShiLN6rkCOwyCicxSrhsfc8ijaKiII8z9l7/QoIWOvodRPERBgd4EEIcGpQ7S7EbZSJSUyOTDK0Mei4g4lbmFYIAxq3e0zzjCgytDo9Qp4/j3Uhb+ba6ipxu4P1LkA7QBQMj0ZMh4e0223ibpfcOYrpFJtnOA+Ft2BhPJngxuMSmObEsUG0YXVlFRMZXJEj3tKKIhyeLE+ZjCdoHTE6GjAeH9GONV5ppuMJiNDrJgymGbu39lHe0o4jOu2YiTG4lVXa7RYqaeFFUVjL4GAfpSDprBAnXYppTpGOUKKZWkeaW1xR4BV451Fa0Y7bTPEYrRlPJqANS70lisJiiwzJUwa3bkD7RAmnAF9BsNvgCZESOIGzFltYWrFhkjusatEfjjnKNLq3SfLgvbw0TJnu7oSHnPduEbfatNoJWeHIrUenI+x0xEqvxbIssbm2jJXgToyiiPc+9ijjdMo3rmf4kcNlY5LJTVbXOkyznFZniXu3Nriyd8CJlSXWVpbYOLHG2soqD59+kGdvDrk+HHPxkuNfPLnL/ed73Bg8xtqJdxF3HEjBqTOKE2ue7313wK2+YIzlow9d4xd/6ae5cN8WJ1/4Lr/xf30Gm6fYau3pQVRwUubWBlAL6DjmK0/9Ea3Ot3jxhe/wMz/z05w9dz83b2wzGPRJ0zFKKyIdUUyniNZkecbVnQMEsJMjvvL53+VdT3yMg+2rdFc3sLlFxcLR/j6vvLjL/s5NvnH1KjqOQ5QrE2GURhtNbAyRCc5PpfQsP2pY35mQxlIEJSEXaBQF4I74ACxLVyJSrhXDHVKGZy3XkSVHlFr+y5qVsixLzfyefkZNbzsqK/tldX5wW1YBjCvwSA1ClgxVPN7VgaiUDtBA0pWEa6m4aQU+RWA0PGCiNBaFs7YMg1yutV3BzkGfQgxX9g5J85w4DtDeuZCjdrWt0WKxJThV1X0hs1aXADXA2IXeWRKRFQKgPAP8deAGIVflQgsttNBCC/1Q9bZyVMIb/6BfqQ62tNazY+GNYKYOOqqy5+WGbOabbAKQeQCl2jYv9GTd1VX9SK1gaBWGdl6OyyZkrV6LouDKlSs8+eSTfPWrX2V3d3euo63ZT/NATrO/vh8X17xtb3Z8E/7Mq6/el0opJpMJe3t7vP/97+dnfuZnuHbtGv1+n6OjIw4PD5lOpxRFEZ6u1Zp+v8/u7i55ns8FYM0+rfojz3O2trZ43/vedyyfYhNg1/t/OByyublJq9ViMAi5w+s5KKu6l5eXWV9fB0K42SRJuHjxImfPnmV9fZ0vfOELTKdTVldXOXHiBIPBYBbSN4oibt26xVNPPcXTTz/Nzs4O586dOwa761CzGudqrtTbU7/26hqrPqrum3ouxTqAr9R0J84b8+aY1qFdHWDW3Zb1+7AJUuvztmpbE4jXH1ao1918OKDZjubcq6B30yVZr6fptKyD//r75vfFnaBsHdxWYzAPUtbHdqGFFlpooYUWWmihhZryXvDW4myBs5aiyKEGRay3xCZCK8VSp02yFGPTlNx3mI5T8t5p9t0SvRNdPvyxDfAe6x39pENRWNx6D6U03aUVVj2kaY5ICH1qtEJpTdJJUEoxPbhFblNEBFvmvOt2OyCKNB1xlI4hn7LUiRhnBUWek06n2CLDZglZu8MkS5lMUrzLb69tdIQbjXC2wBhN0ooYF6p0pXn0eIy3ObECzxKCIs8m2CxlUozIs2kIKytt8mJCMU0BSyQFRQFic4wR8AVZDoUtUEd90jTC+x6iI46GY4osxyEMB9fpJDHeQ5q5WW7KNEvxzqGMYTqZkOc5STsiigxahPEkJcszbuoIHbXY2NigFRu8K3B5GpxwEsLpztZTNedeFXrT2pBTUMcx40K4PlIcjQuu+hO8+uI2h4cDlnodOnEMNkeJMCocuRemaYq1OTY9wqajEFZUyvyPRQ7A0SQlLwociv7RiMOh5drBKlkWHK/vf/AeHvvwT9Jb6vLwez/Ayto6WeoY3Dxg77sX+aMrL/LKzoB771mjf9gmSQxn719l61ybtZUuNnUMBxkvPn+L1aTH+dM9/HRC/8gy9vfx+T9e4cvf2mVNLpMWBVoFJylK0W63SNotlDEo5+gPhuTWkiQtJD1kNNjm2Ruv0u0mPPbex9g4dZqbezsBZrkcJfDg+S3S0Yir27eYZjneudDPrgCbs/v6S6ANiKfdTtjfucLF772E9ikvfuupkDfSe1omzL/ceQzl2i4QSbQIojQosGKwhLC1RmnaWiHGoJTGmOAOjYxG6QA/k9LZW6hqm8HoEOJXG4XRBjE65IIsUwO1jEaUQokGASUquIsJTmcllWO34ptVWFcq+olINedCGGZ8yOhKtRaeLWmDCzRsq/JaVmvmKpOkC3V5T2QM4j1ZnuNdcFkqBOtDGNgiK7Di2Lm1T9d7vBNaUXA9Iw4tghKpUsmGBx28C7lLJZQTaV3aPxfr5neg1gh5JVPgG8Df8t4P/3SbtNBCCy200J9FvWVQCccBSfMP/ZWjrAIe8xxVlSqoA/MhSh3MNCHJvLrrYKTKXdcMT1udUwGIJiydB0Gr7dW2OqQcj8c899xzfOlLX+LFF1/k4ODgjlDp+1Gzvqaafdi8tru1fR6crIOleUDLOTcLw9rv9/nqV79Kr9djc3OTJEkYj8dorTHGMJlM2N3dBWBzcxNjzKyv543bPEjrnOPVV19le3ubbrfLdDolTdNj59bPj6KIJEm4fv0658+fJ4oidnZ23gCVqvcbGxssLy+zt7fHeDxGKcXW1hadTgdr7Sw3ZpZlTCaTWT9VUMpaS7/fZ3t7m4ODg2PhbpuOyfqYVarmQT1caT3HYn0ONMH4vDGvQ7TmGNfh3jzn47wHCOrXW783mvOu+myMmfVLs6xm+dX3Rt2xXAeKTYDZ7PsmsG6Gbq1/b1Swt66mQ7PKfVs/pzkG9e+RJmReuCkXWmihhRZaaKGFFrqTljoJeT5Ct9tMcgc2B/Iy/6Mito6llsYpE4CDgzxNyZQmWV2lSE4wzjVRy2AcHB31ybKU4XgEIhgFUdQizXNEPHErIcsmiGgKgSy3jIZCO44oigyXZ0yOjgKMEMgnId8f3jKapLQ0tMxqgKsuQLfCgpecfDIM4TYhwAmtyF0ATK7IA8wpsV2kg6/KZlNcMcU7R5y0GQ0OiYzBlaFgp9Mp6XQawku2uth8glIOYyLSLEeVkMi6EFVHW0urFZNmOUVeoMWho4h0MqUoLFmWE0cKpTpY7+n393G2oJskrG5u0T/YZxbG03vG4wlaK5a6CUoJ42lOrHI6bUOeZxgxmCRhMnO6VaDnmKeOkibhnGdaFLQ7XU7fcwa/tMofvbjD1ZvbuGwanHwopKUpfEE3bpGOxzhirt3YxnrPqGijoiUKp8hzi1iPiMZJGI/hNGWae7RWLCdtrLO4wSFtp2hnghnk7H73MoNuh0naxh8cYvcOOLPRob3SpbNqKLIR3eQUN6+OOPfwPVBkrK12OLG5zOpazOuv9TlxT0yn26bXPcfwMOVgZ8zrV8coE7Nzc8qJU55TSzGRwFEhFFEH3YoxynNqpYO3lnanUwIsh9KCijSTowlf/9LvM5lMGB4dkRcFaV6Ay1k7sczDDz/I5HCP4ej/Z+/Nfiy58ju/zzkntrvnnrVlVbGKxaXYZJG9uFvdxEgae2RpZGCgmYE99hiGbcAPXt78ZPsP8D9gzIMB2/CLAC8z1lgatVs903tT6m6u4tJksdasyso98+6xncUPkTcZFbzJFrphwMDEFyRu3oi4J06cOHFRcT/x/f4m5Mc5mbMgwfM9Wo0GfrhGr9NlcryNkpDGE1qhz3QyxVMKX0nOLbb4w1sXyZOEdz7Z4u5hSssXGG0Y55rUOJyQIBXWGmZev1wqrFJIm5Mae4LV3GlNVKWKGFZPQqrdSeTtZ7OhoIsFhFRSEPoeC82AyBeAwiKKOGJRgFHpeSg/QEiFVEX0cMHzJCBxFMA/CEKUJ9EOPNWg02qQZSnCCwjkSb1YqZC+wpfeZ27GwlCJQJ5A2gLUSk4empeS3vIS8cEu2ugTeAnOWZwFpTw8Pwc8WmFAlJsCQmqHDSRCSDMT8tcAACAASURBVKRwSCEJFEjncNaS2RMDgpOEviSUooi7/eLn+Gv9/1Du8zUxa9WqVatWrf9P9GuDynK84hdBw6r7rayqG6oKL2efqbY/D7SV3Vblbasxs2V32DyoU3bCVcFQOR5yBuWyLOPhw4e89957vPvuu9y/f/+09mHZSVp2X/0qVfs5D+5WYWR1jKuOsl8FPquQEj6DuLPPeZ6H7/vEccydO3dYW1vjpZdeIgxDpJRMJhOGwyH9fh+Ay5cv02g0ePDgAXEczx3zqtuuPF67u7vs7e19LmKzGlFrraXb7bKxscHt27dJkuQ01lVr/RQANMaglKLRaOD7PtZaBoMBt2/fJooi3n333VPQnGUZg8GA4XB4Gt86mx8zsDiDV1rrp2DeWfCvDArLDswqPKsC8Xnntwzs5s2R8v6qrubyeZ83t86KAZ4Hl8ugsQwiq/Oy3G71fM6Wz3tooLzvap3ReevL3xnzHmJwzn3OOV1tp/odUHZSnrV9rVq1atWqVatWrVpVRc0QOS5cU8rzC5x1GtlY/HLfU5bMZsSTEZ1ehPMEcZrRDCJ67SaT6Zijw31MlmCsxRpNrg04h/IESZ7hcEjlFc5Nq8GBlAqkIss0kpO0FCC37vRv5Vl8QHo+UViAu+FoShiFaGuKGE+viM+0uKJupTuBkNbgi1l6pSqcdMpHSRBSYiyEgY9QApOb4r7RUwgEudZIoQk8D4KAwFcoKQh8nyxzGOuQwpFnCc5xAiUlGoM2hkxbPKnIc4vvS4TysFmOEKA8n3g6PXGgWZSSeIGPCiI8P8CZFIejEQUIKdF5EZfrS49Ww5KlCcI5rDV4foQXeEgjcc6CUJzSHGZ4snhrnWU0OGawu8kknvA4dmze+Yg0TmhEAY0wwBjDNE9BCdphwItXL7O5tQXOsbm9Tb9/RGPtGRbaHWyWFTUEtcHZonalcTDJDA5Ft9vmhYvn2Nnq08pi0AqMQVnwpY9bu8KdwRT78BEXl9Z49psv0GlLtvIpvtUc7T7m/LXnuXbF8rVnI4z02ds/ZJx3yEYTNIUTbugcVgg2nl+hszzFipBOu8/W4wzZbOMLi7Q+zSBA55pMpyTGsbHcJd89ZuI8Qlk4iwWCZugxHezx5vf+L8ZxRmYMvufRaESE0vJo55AXrp5n4+iYyTQh00WUru95dFotVpYu4IIGxmiU8ugtnEOFbbYffMLGufP4UZPFpuGlF65g8xxjBa9eNlzRA6bTlJER3D+c8sFEsGtAupNSRkLQaATgtWm6IfujBOckHraArcLhywIkpsZhXOF/FLYEqwX4ytHwFe1Q0QgEvjr5XcVZdG7QxmKtwCoBnkInEuPsyW8ERYSrNTm5KepTSinwAx9tLKm2dBdXUSuL9Pd3wFlakSLwi/t9qQKkF5IZS2wcTQ88p4mnCbmGRDs0AqQijBqsXf0Sw6M9pPKxeUaWpXiqeNzAAO1mkzjPWegtEZqEaWJQavYdJpDC4QnwlKApwBrLNC/qa/pADvhS0QwEzp7Ut6xVq1atWrVq1Zqj36hGZRkmzqBDuTbfPKfRPLfWPOh2FqCbB9zK+5+33yrsmQf2ytvNc4OV+yxP4jtGoxEfffQRb7/9Nu+99x4HBwdn1t07a79VGFmFINU+lpdVge08B1tV87avQtSqA3QGZn3fRylFnudMJhO2tra4cOECq6urTCYTHj9+zN7eHr7vs7y8jFKKg4MDdnZ2GI/HnxvLL+qfEII8zxmNRgyHQ4Ig+MJj7fV6XL9+nZ/85CenNSNv3LjBwcHBU6Ayz/Onzke73WYymZzWlkySBCHEKYQ2xtBqtU7HZvbqeR6Hh4eEYUi32yVJEo6OjlheXn7q3Jadk2ed8/J2VRfuPIhYPXdlQFg9f+V+VLetPgxQ7c+8BwuqfaoC8XnXzjwXcbntmdN2tm21/fIxf9EDC/PGoOpsnQeR5y07a321jXnnqFatWrVq1apVq1atmaZxQksKYqvB+YDEIEgtnKQ2orVDCwFSIkURPymlZRLHDMcDpsMjjNHkWQbO4nmF60tYV8BPYwl8HydAKQknde2UAu0saabx1UmiiVUUNfRAKZ8syxGhj+d0ATsFxHFMnqWIk/sF3/fwvQCpirqTgmK/xhg8L8A6hxIO5Sl0bpDSEjbaZFmORKN8D+FSokYD6ftYbUB6WONQUtJqRCAVfhBifFG4J7F4ykNKW8BZq5CicGq6kxjd3BrSFKJGRBh4+F6zcHMGPp4XkGYpjSwv+JGUjPt7BEGAMaDSHOs0gVKAj/QC2o0mWZoRBC2cClBSEYYhRqdYLREUcZcnjKYwZroiKnMyGnK4dZ+j3U0++vRT9vYPinhZrclyDUKS28Lo5knBs5fO4SvJB3fuczSc0OotYLKM/nhA2D1H5lLiyZRQgvAEx8dHICSvXt/g/s4eC0srXLu8xvWNLd746/t4fsSVjRcI2xHTdMp94TN5/AAlJRvXn+UgtWwNNW0TkOLTakXkWczWk0f8cqHN3/2tHgvbD7m53kLv3OeHe1PM1St89eYq0zhHG8loPKV7vsFx4jjYixmOJhy4HlkEnrU4N3tIXHAwmhJFIRvrS/zy4S5Tz6PhCazRCClohD5xmhOoAr6CI0tTjgdDbt+9T7fX5uqVDZ7sHDCZJkRS4UmBLyGcbCGDK/jSpxk1yJMxxCPWVldYb90ijWOUPcIgebgzws9zLh3dxSSaxUbEpbU11vWAmwstkudu8XB7l4/2fI7iBOcm+EGDtrK0fR9tNMNJRitUhJ7i/GIDXwqOxwkf7cdkTpzWixQCWo2AK+eXWeg2abTaeHDq2DR5TmAdzjic75MZy0gbDodTJqlGSIUQFqM1IPCUBQHN0McYyzTJCRtNWlFIo9li8eoGMj4g04ZGZ4lWu4d1glxbJvGU+GjI8lKbyGUkfspwMMVOE5LM4Hk+2AiXTTna36R7/lnyPCtgvJM4BwZBlucYC9o6lC1A7enBiqJGZTdUxLkmdY5JXrhMnQOFwPcEoe+QUMQmu9qYV6tWrVq1atWar18bVJYhI3wGFs9yOs6DHlVX2Gw5zHcGlt/PtimDnSqkKwPKeQ6sctvlPpT7NzvW2bJZLct+v8+7777Ld77zHTY3N8my7EyIepaqsKkKZaqaNzZVyDkPeP4q6Flufx5oKh/37PPGGIbDIWmakuc5e3t7PH78mMFgwOXLlxFC8Oabb3J0dITW+kz4dda4QDHuu7u73L59m5s3b37uHJbdbY1Gg0uXLnHp0iXeeecdlpeXefnll0/B6mzfM+ejMYbkJGJoeXkZz/OeAt3WWoIgwLnPYk1nbcwg9fb2Nu12m8XFRY6Ojvjoo4/48pe/fOrUnEGyKqQsz7cyXJs3L2ZjXW2nGpVahmXz4mOrLsPqfKnWhC2rGlM7D+CVXZTlNucBxzL8LtfBnI377GGHGUgtO1XPej3rwYLq+pnm1TmdNw5nAeDyPP6bzutatWrVqlWrVq1a//rJ6JzQV6TCIIWPrwSYk+hU6ZFrwzBL0aKoy97wBVmoIMvJ0wxfFvDQovGUwrlZvKTFCMdomtCKAqSQFBXrLF4YkmsNzuAsCCzOWpASB/ieJHcOP/TRaYpwBiV9rLR43kkSjXMIawiCgMAPcEJinSvgqFJgDeLk3gibFaUSnMZXFj+IUEpipCDyI6JWi8SLcYBxCkcBVkM/QucxUkpyB+MkJ88dVgZIIQi6i+R5jhAxzk0wEmSjiVMS7ySKM3FgEo+o2cKPfByCPAjInUBLS7iyjNE5w9GQbDxAypxet8PqpWdQQpLhIf2Ig90tGqmls3qJ1uplnAzI+1sYHYPWGOtwGASqAFMnIbDCGR58+gl3P/lr7t39FJ2n5LkhnUzQeeGKc07gdE7gCTqNgMtXrnP1+vOMjvcYHB3x3PkFWs0WzTDicH8bc3ifRAoavuL58z2EWCCeTDBGc/XGDVYunGecwyD3CbtrrC5fxLY2WH3+WYQdsL35Pm5yzOrKGl/62us8+/xLfOd//1/4Vz94SLOzhtYxwqT4vuCZcxEvtARv//wONzoSMc348O4237vX5w+fv8jismBZhkVkrYwYjWL++//hOyysrPLaN/829w4z7j28x3DQRwmB7/s4Z8l1zpODIb5aYGO1w/3dPpmIEEiEcIShj7MCFUgiaxmOphhnSVLYPzziw0/ucWF1CSN9lheXCHyPdhRih3sciYxQdImUw1OQDPq0A8mFXsA/+O3XefjxJ/zT7z7i47vbPNrc5+X0MdpacglBnjDc3kWjWA9z8sBy7rd+l1eyHh/d+YRjpTD5kG66xbNLbdLplA/vPOTCcpdWw+fWl67Sbfg8erTN8IefMjWKODeMssJ9fHltgZe+9CK9hQ7WOoTwaDQ7dBaWsMmYKI8h1STS4/tvfcBhnpNJh4qg1V1AGIMni9k1HBywe3DA1AVcXllkdUngtxZ45au/xeVLF/CyI9K9TxgnDuU3Wbz8EktLK+gsJZlM2N/fpRFZXDpAJ2N2n+yy+2SXD+/toAKFpxRSga8sAovOU5zjs3qYErIsxQGj4RDrC6LT+/uiDq6SEu/kwQcBNJQgO4GcoSrgpCdBCYd0DlsniNaqVatWrVq1ztBv5KisQsaZS2sWiVl2oZXdiuU2Zp+bF4larYtXhnBlUFoFfPNchfNAQhVKVEFdGYDOatdJKRkMBvzgBz/gxz/+MVtbW6RpeuY+zhq7GZSpAqVqP84a97PaPWsc5oHav2l/qyB51tZgMMA5R6PROIWRjUaDvb097t27x3Q6fcotB59BtHnHXT0OpRSbm5u888473LhxgzAMP9dvY8xp7cput8vXv/51dnd3+fjjj9nZ2SGKoqcAmJSSdrtNp9Ph+Pj4NNa1GvE7i3idgc3yPIvj+LRuZa/XA+Dx48c452g2mzz//PN4nnc6v8qgS2uN1vpz10L5uKq1JKvL5zkWy+N41nVTBXbVepLV83EWsCv3q7ys7KYuQ7/qnJ3tr1o7tnw9zNbPrsHqtuV5dNY8rkLSsou0+nDCvGujDExnY1U+L9V43Fq1atWqVatWrVq1qrJJihcpFBIlfS4udpmmMaHNOX/+PIPRkOxwG2MtR/0huDWsMUgE2lrGwyMCcnKjkV5AljmEKVxXUil8X9Jqt/CCkDzTaJ3hiZPyFLkh1QZhLNr3wUCmLdPptIhYTXOklIxTg0xjnCuiG62SZLlG5xlhoAlDg3FFjGzo+yx0OywuL7NzPOCD9z7i3FKPr3zrW6S5YefxJg8/+IROu8Hq9RdRrRYjY/no53+JJx1Lz1zH80PIUszeAxYW21x45Zto1WC4tcni8iK5dsQ5pH4b60HQgGBVFc5NWdTF809ehRRIIRFKYoXCOosUAqmKmp++EnhGE4TbtIM1MieIwpALFzZodxfZ6U/RIsQPmqx0I+IkIVi6RO4Uw2kfl09RsnCVWmNBCoQt4KPvKUJf8uCXv2C8/4RLXQ9PhSdpROfAgbYWIRUqCJBKIYXC66zzyu/+O9x++yccHh8SZClCSJzyaXfXECokNg4bRGzv7jIZHnPt6hWmBt7+xYfcevVLfPfNO/T/KsMLVwgvv8xyt8s0PmCw+xHomN7CEi+89nXObVzj3fff4907D/ij3//b/M43v0F/8zYrQczOYEL3coeNF9c4v7SE8hXKOl4Mm1y41CeYDrn70w8RvkSEAUjFJE6JR2P+7r/3R7x4bY2fv/dL7m8+BATa2KINr7iXxlq2DoZcXmlxYbHFvf0Rnu+fuAYFVkpwYACLQxuHcZpGJBn3R9wfTwmAhVCx0FCEkcdakJAmMYP779HpLKCGOzSjBvghzWjK0lKHvVDQH2d41nBxbRnv4QOclDQbHp61DLUjc4KWzmgOtvjD//w/ot2K+PPv5ui1m8R7j0iH27RDRToeYL0Qg0U4zeZQ0zUeIxew3G3Q1Q5ExN3DGKskr11b5nLXJ7p0lfGoj3EWJSWSjM7CAj21RHw85F/99G0+erTPwuoanW5EkqZYnSMQBL1VhtubbB/2STJLnA+xQvDy1XMoE/Pw049Yv36TF1+4wXSng84N5iQGeeXSMyz2FhAC9PSYyeAJyWSAyWNa7U9ZWlri0ZNDUqnwlIfnN+msXcWpAHuSPhX4Pg0HRkYsLC8wziy5BV+PsMn45AEEeVJ7dPbbU3Gt+VLS9AvHpRRF3GvhRXZYKZA1qKxVq1atWrVqnaFfG1RWXWBVB2L1B/1y7ch5kGOmKkypArLZsiqAqwKDs5yXs/flv6uuzfJ+Z23Natk9efKEH/3oR7zxxhs8efLktNZdue/l91WX1zyAehbIq0LdeQCzepzz1lXdlfO2mwd8yv3Isgz4rKaftZbJZALAc889R6fTYTwe8+GHHzIYDEjTFM/zTsHQTDOgWe17FWbN4nWHwyGbm5sMBgNWV1c/V0N0BpTSNMX3fW7dusXOzg4//OEPTx2PM7fkDDomSYLv+/T7fXZ2dk7nw6ytbrfL9evXWV5eJk1TNjc3T0FkGbDN2p3Nr9FoRKPRYGNjg8XFxadiR8vwe/Z/efns73mxweVtqvC5eh2U4Vp5TKWUTzkzZ/Bv3gMC1TlafV91I86Wl89N9fopH8fMSVlua15EbvnzSqnTz83gd/lBher2VThbdVaXj6lcp7IMS8vfM7PvtHnX898U+NeqVatWrVq1atX610/SZvheg15vnenhGOErFns91kLFv/X3/10ePtnmL/75/4Yej4hTzTh1JDkYB4/3Dvl0+5DVXpvLGxeIjeBoOOVob4+mJ1haXqTbXSBTTcaThDAK2Dnos3V/E5MmeFiUAF8KmpGPkJKGJ4ualQLsiXtKcvLvYCEQSuEvLpKdPAyaSVCLC3RWzpOnhXvzwqVLXLz2HMcf3uHj9/8Z3tXzXPpH/yGDxDDojznc2aa12uO5518kFx4HR8eMD/dpedB76UWiVofREEbxCNVWLKyukooGvTSm5Qk8r0GWa3IRcjDKMNYilY8o3V9LqQrnFyClQJy8d+bk3+uycK7a3NBgSqvj46TCac10NGQy6jOdjCFaAuFI4glbh/dZXC7uOZPUYp3DOsgtGDR5loL0MKaotDce52x/+i7L3YjVxWdByAIQaUOWpUipivqY0iPOckyukaOY0ePb/NP+/0w30LSCiNEkIx0OuHN0TJZMufzatzgcTBCJYfPgkGl/j9Qa4kyzvb3LJMt4/be+jBh/RKgu0o+fMMkNyXSAJxxRq82l61+iu3yev3zjR/zL736HwfEhf/bd7zPILC/efJmbf+fv03l4n//jn/0ZP/jpG6w8c40L62s0Gk3Ora4QBT5r3YBeI6ThKxq+j4sTfJvge1M+frDFeDoktYp2d5E4jknjSeG6VT6h9NA6J00TNvdGKHkylrmmEYUgBFmaM5wmTJIMZy1RGLG2skKn1cKXgraydGxKk5wwU9x4/hlcs8Nf//xtDgcTjNnE9z7m0sWLnLv8HOu3buL11tl4+Wv8w7zLj372AUv7v6Q/TGifO8eL5xVqdMzmXsaHfYvXFtxoRzS7XTxPADmvfuN1Lqx2sVlKniXkScy/mUyJp2Pi0YDxoM+of8Ro0Gft2WPGwxHJdMwzj3bZH8esrCzhRgdM93cwUYOotYCzFu0ooLr0uX33Dnee7NEJQ7LxCLG8QCOKCuDuLPnwEK1zAinwo6BwK1qHDBr0FARC0996iP/SDWTYJlQxw0lK4AfsP/oUz/8S7WYDi0V6Hl7UQXkBnd4iUW+V69e26CeGRJvCGWk0qCKitqi/CpEfEaxf5o/+/f+AR3fvsvHMNb7/x/+Ee8eHSM/j2QsL7BxPwIF1BZj0RBELW8DI4nw7JQoYbR1CSJT8/G+AtWrVqlWrVq1a8BuAyhkQAZ6CIlUAMfuBf16kYtXxVI7dnC2fvVZhRNmxNc+tVf5cGZLMgzvz4F4ZvnieR5qm3L9/n7/8y7/kzTffZG9v76kxqO673EZZZ4HKWf/mwdvq9rPXeZBknqtyHhicHVsURac1Fkej0VNuvnLfrLVkWXZap9K5ot5ju92m3W4zGAzo9/uMRiOyLDt1n1ZhmZSSPM+fgk3z+joDnFprHjx4wHe/+11++7d/m/X19adAV9ktKYRgYWGBb33rW/i+z7vvvsvh4SEAQRAAnLpfZzUp2+02vV6P1dVVdnd32d3dZWFhgZs3bxJFEXfu3GE6nZ66NsvAyxhz2s6s7fv379Pv9+n1ek9dE1VQB585IWfXSBUaVkHzWX9XAfy8a2W2XXmOlh3D5e3OmjPz5uBZ/aiq3M682rSzz83O7TzIX72uy9vO1lev8Xnwt9zXctvVsZ3ntqw6RKuvtWrVqlWrVq1atWqVFQnH1ctXSK58ne0f/kuEsJxfP8eFpQ5B1OTixSssX7pG/5fvkeeaJDfkBgSSUZJxb/uY9obj/FfP8+jgkGbk8+h4xHIv5OaNZ7lw+Tqis8bWw08JnGGl02Gl0+ajt97BTGNS4Ng4WqlPM/QIIh8JOOuQOLQuAk09BTiBzg2ecwgpcdbS7bZZv3AB6UdopQnDgIXFBRphiB94GATjJEMiWOy0eObKZd6SAUYbnLAkaUwkwfdCHDF5MqXRaBMEIbmFPM9xOiNodYiiBqPxhMWWIfIlIRrTCTkaxnACPwQn/x4HxAkgQRburVn+pMXhCQBHPtyiHSYEvUUSDU61EUqz//gOnhfQvdLBWIkzGdnogKnvUItXyI0kTTMCJciNI89i0sM9kB5CSrS1JHFMMh0V9Qe1odkIQBTxp0JIEMU9RJLmkGrk7hHxcEjsBJNfvknfTBmnGfd2+/SaPkaFhIGHkILO4grO6iJg1loODvZJjcVhmY6O8Yyh03BE/oBksEN7oUWr4TMYxaysXKK9tML3/uLP+dnP/orhZEwj8Njf2+Mv/sWf8uZPfsLK8ioHgz7XLl/gmZUOD8cjHn76Hu9/dJ/e4hLdToveUg8JBFKx0YlwzuM4l3zyZMjeD77LuXMXCFptVtfOEU/HGJNjjCZQEoElQOGJkCxLSLLCWeeEQFvHcBIzniYkWVEXsdlocfHCBdrNJr6ShPmUjkloK4sF9jUcfXyfjQvn+PLLL7D15Al5rhkPJ+xsPWQ0GvDKreuYaBHdMPSnMeM0o9HvM8ihkY5Z70YsLUuEMXwyshirkO1lvO4qeZ6wun6OViNEKB8ZKsKwSdiZXclFHcpiDlLUJjU5RmtMnqGzhDSeEo+HTAfHjMdjpmlOkiZMk4TpaEg8StC+YP25W/ynL3yVqNkibER0Oh1azWbhBD6Zy0bnOGa/tQFC0ogifE8hlIcftWi2Oyy3fws4iWoGEAqhfJTnQdSg1TuHtcV99/LlL5Nrx/VXf5/R/hP+9I//J3bzKS4+wooInSZY58hyzQTHwsIKzd4C/sIKl65fR4nCOSmU4pkr68TjuxiKGq1SgC8EOHHSH1l8v5zUZZVSICW1o7JWrVq1atWqdaZ+bVAJT/9wX4Uds/XVCMsqjJvnhiqDqHkAoAzP5rkFy7C0Wtev6sib58r67CnNwtU3nU65ffs2P/rRj3jrrbcYjUZn9r1cy7Dc35nKNTVnfawe6zxAMw9Ilv/+IpflWW0ppWi1WqytrTEajU7rTZYBZblPM4hZBl7T6ZQPP/yQb3/723z66aekafoUpCz3Z3ZupZRkWfZULGz1+Gb7staytbXFt7/9bZRS/M7v/A5LS0sMh0OGwyHLy8ssLS2htWY8HhNFETdv3qTT6bC0tMSDBw8wxhBF0Wm9yiRJTsfd8zwuXrzItWvX2NzcZGtri7W1NV577TUmkwkPHjx46pg8zyPP81NnaHl88jxnPB6TJMmZtVnL52s2X8pQbOZ6rIK9L4LpVbfyPHfgDNiV26lGtJ7l3Jx3vZT3X/5M2Zla/lz5IYRZO/MczNUHCcr7q0atnvV3FbSe9d1UHaez4OivAsW1atWqVatWrVq1ap2lxSjkhVtf5TYrheOPonzEyrlzKCUQQcDy+kW27n4MRmNtYWmSOIQUPNMNef7SAv2jXdxkRJ4mGGswRtNeWEJiUVGD6STBa/oYk3FufRHvG1/h9rvvMRyMmOaWo4mmZwR57ugGRWSqQOCcBSRWFbUXpZDkuUF6Pq2mYnFlBc/3ENJwMJygdvd45tkXcFnC0kKPwPdRzoFOWVjowPoajWYDyNnb2+Fob4f19fP4gY+dDtFJjDE5vlJ4QiCtJVCSaZbg+QGxs8jE0vIypLVETtL1FTGOzBQQxLmiRqcTAk9C6PsoX6FzizEWnMMDstEOYbaHUAoheiREpDRx9hgdT8g8S5RMydXJfYJz6DThcH+bOINseExv0SOzAp2m7D74BOkVD8DmWpOlKYGC0AMpBLPbA6kUQRiQZjnTUYzux5jhmDgZMx0P2Ds+QCiHUo5pbpnmGdlYs7QQ4nkKpTwEAQKBksX/4GiFIV++9RrGGmKryLTPweGQe4+3sXaVpW6L8TRhPBnx3e/8C+58+ilZmqHznCvP3wQseztbHB+O2d7aZWWxS+PKJbzeClex2P4AZS0LvRY6S9jezWj6gvXA5/6R5s6jfXKvTXf5PIdPHuGsYf3CBqvnLhFPJzhrSKYT8jxhud3g2Y0Vnuzs8WQ3R2tTOHadYzAY0Z8kWIo6h82oyaULF2m3W4S+x/nA4seayPOJtWU/NYShTzNQJHnGKMlotNu0BERhwGKvickM3/v2X+DrKdnhDi2X80Lb8mCSYJygqVJWFwM8IwgagqWGoOdJuhcvFy5iFdHuNknzHGM/q6R4MuMKp+GJHBRuXs/H8wK8qEkItGZrT2AdOJwpUp2s1hit0XlKlqRkaUqaJqSZJtcWc9ImQiKUQnkBfhgW//sFePSkQiqJkBIpTqJXhTgBlKLURzf7D2ctzjosRRRvlhuabYMZHeKwCC/Ei3rEFOAV57DOMElz0icP+D//1/+RvLWGamCNdgAAIABJREFUpyckSYwvBKm1eI2Abqg4Sor2MwcSkEKCsyghyC2k2iCVouFLFLWbslatWrVq1ap1tn4jUDnTDHbMA4NlR1MZ7JwFEuZBvbPaLwOz2boZIDkrtvEsR1l53axGoRCC8XjM22+/zY9//GPef/998jw/cxzKffsid2XV5VWGleVt5oGQs+BXdR/z4GV1/GcRptPplCzLTqNMrbVPRbRWYWW53XfeeYft7W0mk8mp27IMrMqgCj47p2EYkuc5WZZ9bsxm4z+DizNA+MEHH3Djxg2azSZ3797lk08+4Q/+4A+4fv06h4eHPHz4EM/zaDabSClZWVlhaWnptO9VADY7nkajwdWrV7lx4wbGGMIwpNPpoLXm0aNHbG9v43ne6XyZTCYkSfK5sQzDkPX1dTqdzlN1DcsQrnqeyu+rsK26fh4Y/6K5Mc8BODsX5Wuyep1W+1Jur+pELIPHeXNsnsNzXn/nwckqPCw/ZFD9XBVazhuj8vfIWWN31vdV+QGEKhSugWWtWrVq1apVq1ats7Syukbn4jPYzSlCSHJjMdoglGQcp2wfDPk3XvkSW5sPSMePEVgcDus0HV9y4cICUTNEZynSWkJPYYVglGQ8eXifyUIHNRjx3ttvshLBhSsXCcKIhU7IS199jY/e+5hkZ5/91GJiwzTOsVKiHaz5gq4v6VuDJzX+iZtrmhxzbmWRc+dX8H2FxLK1N+D2h59wtddkMhry5N4HBL0NpOdhjUYCwlmiKCAIfLApybCPSSck8QhPQe4cRht0lhCEDTqNgFZDEU8nGE/TiJo0GwIrJKmb4pk+wkFgwWLIbYQTEudsAe8cIEFKTh5KtVhjsFaTj/cJki2aocDzPXb7CRMihIwJrMNkGTZJSSYD+vExejJE6AyBZXK8x/FgTGimuKVl0jTBOE0yGSG9AOcoYk2zHBuERN0GylPkuSbXBs/30LlmtHdIsnuMnk6ZTAf0JwOsyYmNo+H5eFKcnGvIDXiepBH44GB0vIuHxROgpKTb6fLyV76BloqtRw84Gh7zyzv3GY7GTCZThuOYV5+/SiMKef/99zk4PEacwO52FDEZjTk6PiDPEpqBT7vZZDqcIp4cszNJWL5+hUsafs85HgxynkwcSgmunL/AjaUOx7Hh7U93mZoBze4Sgc2ZjPqMBh1WVla5+uxzSAGPN+/jTMra+jLXb1wnDBSj8YQsN2jjcFg8KbC2AFhBFHDxwgV63S6+p7jYUqzJhCkRiTEcG02nHdFst7m4cYVWs8FkcIAxOUHg011fIU1i0iTl+GjEL/7qbb762pfo336b0fYTJqlF4DDaMTzWdHuS/SMIgHajyYVXvoKUBeTe/OR9vvftd/iP/6v/mqvnVov7R6OL34Bm99FCIFUR6SuEQAoHp1jTlV5P7leVh1KgvAAPCHG0Zlx85tI8uU81xmCsLerEao02GpNrTJagE0tqzOlvOI4ictVRxCCLk1IpUvlIJU/6qAqgObv/dWCFQHiFa9eTCoRCRT1ckoI1gMNYS24M9A8wk2PWvvICgZKEoWIhVOxkhvsP98mdxLmiz8Y4DBYpHEluyQGMIww8pHCEShUR03UQUa1atWrVqlXrDP3GoLL8w321vttMZceg1vopUFAGD9W6ffNgXzkytAoGy46rMpSo9ne2fOawrDrcZqBsPB7z5ptv8oMf/IA7d+6QpulT285zmcH8upFVkDLPWVmFMOW25sHcee628n7Lr+XxnPVZa30a1wrg+z5RFJ3GnFbbnX1+Ns55ntPv93n11Vf52te+xp/8yZ/w8ccfPwWYy8Cz7BoMggApJVrrp+Cy7/unLs+1tTVWVlbodrsEQUAQBCwsLDCZTDg8PGR/fx+lFN1ul83NTd599102NjZYX1/ngw8+4IMPPmBxcfH0XMdxTJZldLtdpJS0Wi36/T79fp/XX3+dxcXF01qXq6urp/29cuUK3W6Xfr+PMYZGo3EKKmfn8Pj4mPPnz/P7v//7rKysPDVmZ0WizubzDMKdBSLnwftf5dacd97PguVlCFdt94uAexlcVvs6O6ZZn4HPvZ+3j7LrshyNW3bfngVgy23N1pfrcJbHuez0ngcaq/HT5fE561qtVatWrVq1atWqVauql7/0AsoP6LYVrd5zZKNNBsMRj/YHfPTkQ66sLLNw9QWu37zFo589RjhD6Ck8CU565EajxInLUgg8KTBCkuYZ46NdPJmjtEXrhNufbjMajnjuxWuoZptW5PPy17/C3o9+RngwYsMTrCrHz6c5xhUxjU8SSz/LudEMcVHAk1yz1vC5emmVwPeIAskkzXhw7xF2OkG0QwZHe/iLXRqhh1OSVBsyrdE6R3gRzSjEnw4JfY+JkiipCHwFSoBwWGcxOiXwJZ4nSNMJOs3prS4QRJAbh3VdtPAI0mOkSwhMTIuIievghIcxgCvca1p7IAV5lpJlMXZyhEp2CFo+QnlsDx0Hkylx2keYnIuLAZ6zWAfj4RGHB33aShNiybOMWI/IkimCFJ1NGQ8G+L7C6AwnBM4V97TWaLSGPPfxPcVJMijZwQC9s4fKxqTjY4ajEcbmZNoUEbWAr8DzBDY5RVpEYUAj8vCVoNtbBJsjleSZK1e4+sIrbB0csdILkCLn0dYB0/EYZzSBFMRxzCcPdwgDn9F4jHMOJSVg6XY7HO4/wWY5gaeQvoftRuxv7fLn77/P7z53k15nwDTqcuXWRTqP7rG4e8TRYMRKfsxoa4fhKEZPJ2jnGPaPkUEDz/fpH+7T7nRZWTnH8PiIu5+8j3KawWjKQX/C+fPn2d07ZDyNyacZaV7URpRSgpAsrayyvLJGqxGxEMCGH5PFOVZJNo+nbJxfpdlocOmZ6yx02zy6+zEmSzHG0ep0SbMU4yTNdgfjYDAc8KMf/oTzHY/u+Q3E5ibN3JHllv2DDJNBpyXpjhy967c49/I3cDLCuT7SafZ++SY7jx4QuYzMGJy1mDzDnCZPWaw1hTtSa4xzSKUIwwZho0EUNQijiCiKCP0Az1OnbtvTu84S1yxQdVG/UgkfiSsckEGAX+Ke7vT16QeDrbM4Y7DGYMxJ36zG5impNRhti+vNFDVXtTZobTje30c2erSFIrCG4SSnESoiVexIO0egPJxQrJ1bx8VDIl8RtAO292Ju393GKcVSpHBOECqHmt2Ta4HVjsBTnOsGRBJCX4It+lKrVq1atWrVqjVPvzaoLMOSsjut6qaq1qY8CwxUXXUzVaMwtdZPwYvy58tgch5cma0vw8ny/mbuPd/3OT4+5qc//SlvvPEGDx48OI0Lndffqluvuk0VbJT7Ng+kVuHHWWBlHliaB6rOGg/nHGmano6L7/unYLG6zzKkLDsFX331VV5//XX29/dP6zWWAWy5juAXOeyklFy6dInXXnuNW7dusby8fLrfWd9mbsnpdPoU5AMYj8ccHR3x0ksvsby8zI0bN2i1WgghSJKEOI6J4xitNVEU4ZwjiiI8zzs93zOnZKPRIAxDoiii1WoRBMGp63R27J7nYa3F933CMMTzPK5fv85zzz1HGIZPgbVqXG4VEs47l1V4Phv7KnA+67xX51O13XL/ZtfE7HyXQWJ5m3kwsNz3qqoxr2VoPa/f1b9nx111MX8RhC1/32itn+rfvIcjquNWrqlbraVZ/Y6qgtNatWrVqlWrVq1atapauXyNOMt4+GAbJQIyF7J/OOb8WsK57gLP3bxB0Ih44bkb7Hy4hAKUBE9IfE/hS0c7DEiUR55rmlKCVLjcooRDAU3PEQU+Yxw7T3bxbc5zt76EQbK82uOrt55j/c594sNjclPEoi57gp6veJxYekHANGpw7twCoTa88tx1/EARepZRZnlw7xEmS1ECtDZYrclzTUuAVJI4T0jiGBmcw2qHRZAkGd1uj3GSkmYZSabJkow8S3HOFgBISLQ2KAFIiZQCXAFqNGBswMQ06Xjg2SHCTsjzlDxYJtVF/KovwZOQ5Smj4QiVT2mLEfgS6Qc8GaTcf3TEeDLBGUPgSVajCwS+IDcZk+ExaTyh2wkJsEibo1MHzuCcRTpLOxSFQ+wEjM78cs45rLFMpglLK+fIj8dkD+8zHfdRTfADzfA4Rtsc6UBJgaRw4SmlCDxJIA3SgVQnD3oKgUXgRQ0wHuvnL3Dt+nU+vrfJ3t4u41FA6PkEJxGxUinaDR+soT8eMkERBB6eKmJCPSVpthpI4Wh2m9jU0o8TUiFonOuQDnL+n7sf8Upvgd/9+le4+87PWLl0mUtBg3/777zEk9vv8Wff/zHLvS7fuLrAVn/CnYNtnPThxA26ux0wGR3zwXs/R+sU6QcMhmPuP96h+exlNi5e4NHuAaOjEZMkK9x6zrHY7XLl0gbd7gLtZsS1KMMMJ3TOb3D/zkOubpxnqddGCsnx9kN27yfoLEMJSavVxOYaaaHTbBCFPtl0zETCsy/d5D/5R39IIDT//J9o7v34R7gs58m+5sm2IUmhu36JW//4P6PZW8DhEFLRjHxakcSzCdnhQ7Y3H3BwcMBoPEHnRf1NbXTxu0mekiQpaTwlzVJ0btAAsqgRKT0fL2wRtTq0uj06vSW6C4t0O13anQ6dbpelhR5KgEXhed7J71ECJWbJX0V0q2UWJXsiMXsRSBR4EqkCFK5wj55MVRzFtQZgwTqLNZo0zYhERrfRYHv/mEz6WG1RnmKhFTCMLcY5wijEA85dOI/d2kXgWOhENA+mZFmO8RwuVEhP0VVe4f7FYQOHcSell4Qj9FVRn1JI6ud8a9WqVatWrVpn6dcGlfPAXPXH+nmRktUf9ecBtHkAprq+DHJ+Vb/mwcTysjIYUUqxt7fHL37xC374wx/y+PFjsiw7dYPNUxU+lfdVrpdZBnYz8FTdfp5TrjpGX3SM83SW+64sa+0piJtFwFbbmO1nBnGCIODq1av4vs9PfvIT9vb2PjfW1XM/21e5zmO32+XVV1/llVdeYWNjg2azSRzH7OzscHx8fDr+s/hVrTU7OztFgfrp9NRdeXx8zP379xmNRuR5frqfZrPJSy+99FQM7Ox8OefIsuy0NufM7bm8vIxSirW1Nba3t3nw4MHpsc0iSK21BEFAGIb0ej1WV1dPIWgZos/GrQq75o1LGe5VgWB1efXaOkvzzmUZfFYdjlW4XQX0Vbdh+fjmvZ8H1qsQ/Kz9n/X9MA/6l8H1PNh6Vp/n1YmtHmt52Tz3aK1atWrVqlWrVq1a8+SCJrcfHbJ5ewudxiA8BnmPx9sjvr6+xsr6IkZ4rK+ucuHq8zRUEZMqpaAZStpS0YgUzklSKbBaF2AFQUNJ2krTlBYpPeLconPN3u4h7p33ufL8dSbjkFajwQsvXmf30RZH23tcEZCkFm0dEfBC5PFxbrFO8PJz12l2OqBTpgbefPdjzjckSgicEBxPY4TwcE5g8xwhFGiNMDl5moIKCRsNRKuBUj4Gweh4j4YyyMAj9DyEc6ggQDvFaDTgvHNEvWUEnMR0FhGqcZKSJTmxMCw3IpyNkdkAaTSjiaM/mCBtTrsVFc41HbPakYShh9dosjtIeLxzxHTUJ4kTcBZ8nzzP8Jo+Os9IswSTpehc0PIMuctRsrgfFg6ayhJ0Qg6GRf0+RFFnsYBADmsdB0d9drd/gUxTmp0I0/LpkpCnGf1JRg9RxNMK8KQgENBuhfQiRWIF8jBGCkGa5hymOc0sZ5wcQDYCL+DtD24zmU6J4wnT4SGtVoNet01zNOF4MMRKSbvh02t5+H6Ac46FxQWSOCYIAobDKauLbX7nb72O0/An//efMTka0720QLgYsP/pLvf2hzz8859webqLmmTIXpO3Pr7DqD/lOBfs7o0QRrMzmDDJDPZoj2ajhe8H7Dy6R/9wB2yOF4YYbUmynJ3dfZSEdDrlycGQOMuxpqhp6HkBV595louXLtPtdrh19Rx2/zE7UhL0Frh4RXBxqYUzluHgmHga0/IUzW4Pv9FENgK8MEApgVIeaZYRNNuIcZ8URdBu01CCv/df/Jfcu/USD997j/xwGzOccunKNV76h/+Y9RevIcwAnCXPMzJt2do55I//7Hv8d//tf8PrX/5bOJsVMcHWFI5Aa07mgMVojckzdJaSpwlpMiVLEqbDY/Z2tomThCRJSOI+6ZN9dh47doQk8H0azQYXLqzzyXtv8e237pP5bdrdLr1ej4XeAr1uj4WlJRZ6XbrdLr12m2arSTOKCIMA3/PwPQ8li5hXeeLMPAWaroiVLaaqPUGYgpNKkkyHxxyNJuQyIHMe2o1wNiPwFW5qiu11ziBOePf7f0o03WdNSvwwZKXhcZRojCv8oIkxICS+AE9AYi1SSZSSeFKgreWkCGdxDdaqVatWrVq1as3RbxT9WnZRnuWUmwfVyuuqzqbZ8ipMqq6b52L6VdCy7O4qg7QZpPQ8j/39fX7605/y/e9/n+3tbZxzp2Cq3NY88FcFIlUAOQ+IVGtvlp1k8wBLebzmOdrmwZPq+mp9wur4zPZfrTNZbnPmcuz3+7z99tu88cYbxHF8ChPLfShDXmMMeZ4X9ReModfr8c1vfpPf+73fo9VqcffuXb73ve/x+PFjdnZ2mEwmpxG97XYbKSVra2ssLy/j+z7j8Zi33nqLn//859y/f58HDx4QBMHpefY8j2vXrvHMM8/w/PPPnwLI8tiUodms79PplIcPH7K+vk673ebw8PB0jpTBXZqmSClP+1OFgOX9VF171Tl01rJ5873qIKyC+zKEK1+n8yB4FZiX50MZZp7lXizDwfK1XL7eynNba/258Zl9fnYtlKFtNZp23jjMtinP7XkRrVWg/0VjOw+GlrevblerVq1atWrVqlWrVlWD1PHe+w+Jh0dYq3HOkhjBne2UC4ub3EyGuGiBRuTzwssvkz/4OatBjpOChq9QODwpkE7gC0d+UtsvnhqkNbR9TSMUNNttfOHQArQTHB31MR9+wsXnrqEaTdrtLs88fwM/bBA83iLxM3YSg5YeW7mj2VRcvXSRIIrIsxRPOW7f2cLTBi3aqChEGkimYzxP0VlcJQx8osDHTovUnek0JmxKjPQwSc7g+IBkMqbheQSNJm4yKOoTGkOea0apZjyagHWEjTZSeWg9ZDKJGU/GTMZjsiQGk/+/7L3Zj2TXfef5OefcNbaM3Cqz9iqyWKyiRFGLtViyRcnohtoe25LQbTSmMd0YzEujMf/DPPdDP0/P8jKYeRhg5sEea2AYastdNGmJiySKO0UWa8naco897naWeYiM5K3LSEqQHuxB3y9QFRF3OfdsN5AnPvf7+zFs+FzcaBGEltBl6AC2B9ukyRSxssRyZ4n1pZBIWRrNmAe96cwtlmVoXeD0DDRadbTulh4cOdccAqM1QUsySXJ81cLhUAJ8CgprsM4i5czlZq3FOoO1DrBMp1PGoxFxGKIQeAh8Z5jkliyzRC2JUgKEQiqBZ2Ftuc1aN0Y2Mt55OEIKxXia4SuJ1pZGu0M6ceTTMePRgPFkQp5N6DQi9vYPkUrSaTXpDYa04oBG3GBlbQkEtBoxS6ubvPvuWwzHEyTQWTnDne0hni/ZfOJJdh89pH+nx9LqBmdW10lGj0jTCa8P+uyOe3hpzhMXzpKjOUwKRpOMTqPJ5uo6D3d2mY6GTJIhQag42N/F9z2U7wNgJRhrGI4m7O/vM5kk5EUObpZXUeBY7q5w8eKTnNrYJAp91s+c4917W1z7+rd5/aev8Pvf+Bp7Wx8xGYxoKo84iomWlwhaLYSUaKMRgOf5SM9DGsvS6jI6z9m//4D/6X/9P4migGYUsNztsvYH32W53UTqnLH1OFANHrz7EUJ5XDq9RkNqyDN2DwfceeFH7P67/56NbguhAlSokHYWZlXOGgFCoHA493Ec1+M1oXNcdRY5XzM6OwvFOh0z6u1xuL3Fg9vv8+G7b3D34TYP7nzI9jhHCgnOoZ0FPnbYxo0Wse9TGEPcbLCxskwzivGbbdaWu7RaTZrtJTpHgLPZbNFqtWk0ZpGilOcz6B1w79Eup89dpOkLDh7eZ5BkZJMEFXcxusCTEufNXM0WQeArksQy3LlHL0nQSxGHFrKwQZFPMDgsIJyYhX11jsKCRSCtA3W0jrcOkIiaU9aqVatWrVq1PkW/VehXeNytWAVnZTAHjwPDqjtqkbOq6uSaX2MettLzvON9VZXLXwSG5gBn7pCTUjIcDrlx4wYvvfTSMaSsws5yGM6qqgAE+AQUqzrKqvsWqQqiPs0h9utsK5+7KN/hfHu1rVXoKoTg/fffx/f94/ydVYdf1S04HztrLXEc89xzz/Hd736XwWDAjRs3ePvttzk8PKQoiseAZhzHnDt3jlarxdWrV7l69SoffPABUkpefPFF/tN/+k+MRqNjCFaen8453nrrLc6cOUO73SYMw+O6LXI5SikZj8e8/vrrdDodptPpMfycz5U5gCuKgr29PVqtFkEQfCJUMfBYXtVF0LDc93MoPg9bWh33MgRdBMuqY7AIYi+69+afy2F951oEOasgtKxPg3bz6837sQwgq3Us93O5vuU+rsLz+XnzULbz/eU8qGUgXx336njNy5y7Ncv9f1Lu0Vq1atWqVatWrVq15vrl/UMOt3ewtsBawIJBo4uCX97Z5fr7b7J25YsoqTh1aoM79yIKHI1Q4vseotCAQwjAFKgsJfIVw+Lob1AVkBATNNs0fIUvHEHgURhLfzQlefdDzjxxgTgMiaMuF65cBikZ3LtH7DRxGEPs87Vrl1FBwMHBAJdlszyCKJZOnSf0fSLh8FbXSYaHhGFE3GwTxw2iMGRsLJPJBD/NCcMAP4wYpTlZrmdwws3dXjNXJlLOII7wyLXGak2WJnhBwM72A7buPmA8HFDkKRLLUrvBoIj5IBlxbr1NI/BY7/o8e/1JfnnzNq1GTCcGigleFPPR9iH37+/h+yHWzNagWmtwIJXGuKNoLM4cwSCwRYHvCXAGrEEcAbXAg0l6FCVJHK2ZAHsErqx25FkxWx94Hto4Il/SiRvsDycoKVlux/i+otAOpSSZhc3NU5zeWKKVaOK3HxD5PqlzaATGOopcM+gPabdbLK+ssL39AGtyltpNtDHsH/TxfA9fSVrdNTpLK5za3DyCQoKd3V3yPGcymbCysoZGkqQ54/0Rvt+ks7TC4f4u+XBIZ+MMjc4qOpvSaLQYZTlTl7J77x6elFgniIKQ7to6rWbMbq9HnuUcHuyCNUhn8YTCzFPteB42N+gs5czaEofS8uAwxwFR4CMQPH39s1x56irLS12UcNy5u03ixfT6PT735a8QmjFFXiA9D6/ZQLQUMvAxJkcYgTxaUyrPwwpBFEfkWU6nGTLYHfEXf/4Gh8MxQaBYasc88fTTPHP9KUSR8/N3PqQTe7z2xnt0lzv8D//2e3z+TIMLp2awP89TJkn68ZxFzFyU4uiBbMmRf3HmbBZu/rm8Lv4YWuJmcNNax3hwyIPb73Pzvfd4+9YjhlZRWDDGkjuLpwRKzECvdYJWFCFtQRg2KHo9BpMejPaxRYEKQzY++wSqB8OioG8FCA/jIAgjhIB7g5SdiaU/HpGmOe12m1WRs9IMkStnIB/iggam0GA0TiiE59GMFYV1nDp7DmMVSS7YGhrGgxFW+jTidXybMbEFLQUNbwYhi8IgkHizlJQY6wgjj0DNQh7jTo5UVqtWrVq1atX6L1u/laOyChkWqZz7Dj7pVpq/X+TqWlT2IkBwEvwrg6H55/IrfJyfr9fr8eKLL/LKK6+ws7Oz0L1VBazl10Vutmpdq66uXxc4zmFJuc7VY8v1WwRYfxWwLNexCnUX1Q2g1Wrx6NEjkiT5xFjNP5fhJHwckjMIAn7nd36H73//+/T7fX70ox/x5ptvMhqNjkFU+VpBEHDu3DnW1tZYWlqiKAqWl5fpdrs45/B9nwsXLqCPktq3223yPOfhw4ecO3eOL33pS1y5cuWx+Vh2fs4hFnAMRr/2ta8hpWRra4uzZ88e57Scw648z9nf36ff73Pp0iWeeeaZ4zZW5041FOyieVOG6uVtix4AqDoly3O9HAK1DPbKc2DR/FsEDOf9VJ4X5XqW82aW53u1/PJ8OAmOlx9CqPZLFTjOy6o+EFGFhmUIuaj9n9bm+Vgu+rzowYpatWrVqlWrVq1atar66INHcATJhFQgLNIprHM8HGp++tNf8Pur52gsb3L39n3cdMRISOJIIpSkSC3OWKQ34x2+5xGEIZm1JNqxn0maMcSBTzv2MbnFOYPBIZ1A5jk7t+9ijWPzLHS6qyyfPktqDOnWLl0/4uqFTe7vj+jv7bHcCInaLYKowXLDQ0rQwiPNDVEYsNxdRQcd+sMRYaNNFIYMrCGbDsnyjEniM0oKNOCMJo4aeMJg/QZJPvtbPmp1UUJghZrluisK4jjGOUvvcJ+dh7fRRYGvJO1mk0YcYAUMxiOybMqls+t0A5/1bgPvM9fJtaHpxhTZhLv7E9597zZxFCKb6nh9qM0MoFjr0HmGZyVSgQxCYAhYIt8j8i39wuDcLP9m6El86WbwUgqEUjg92++QFNYgpCLwQzhazzQbId1um+ndXZpxwKXTK0RxQK4tQeDTn+Q0GjHNdodUZYSBx5mVDncOJjhmALRIU2JfcO36dd58+206zZDdwyn3t7dRQmLThGJk6C4t40dtHj16yNPPfJYzZy7w8st/z/aDe6RpgkSQpymHvR6D0ZDBYIjneYRhiEWxu7vNJBnTaHbQxpLnBU4I/MYSge8RhjFLpwOcgzzLGOeGsxevAJClU/r9Q8KogedppJsF7zU4hoMBaysd/ukf/C53727xd69+SKfdpne4j/ADvvaN57l08QJrKys0w5D333uHfPc+L/3kZb77x9+hP0opEOB5CAnFdMzt+/cR0uPC2VM0Wi2MBeXmD0ZrsrygtdQhHgieuvhv2B5KhNzBmT67D8cos0X/cMid3TFCLSH8L+CX3aujAAAgAElEQVTEMqO8wzgTTHNBd2WVZALjwegYPQoHR6vNj/93MAeTHyPLYzx5vO/4JwGlEErN3Io6J0mm9PsDbu5P6CezuS6dm+UxFYK41aEZxcRRSDIZM0lSCqfAFownE6I44itXz7Ox0kY5gTUFuiiQQhGHCiUVjw6m3Lm/w9b+ISoIkTimkxFjXzJJAs6sXEQ1uuAFOAmdU6uYNCNkyjTN2R2OIWqQJbPWp+MB4yQharaRQQNtAx4UKZGZsOlbljyBc3L23WMhNYZASaaZgUAhxSxPa61atWrVqlWr1iL9xqCyCinmP/iXHVllqDBX1QVW3rbIVXWSe6wMKuYqH18tv3yd+T+lFL7vc3h4yAsvvMBLL73EgwcPjkFPtexF8HIRjKm24SQ4eBKMrZZXrvMi99oiQLoIQi0qf9F7Y8yxE7QKkefHGWMYj8fHLsY56Cs70OZzZO4OnJeplOKb3/wm3/rWt8iyjL/927/lZz/7GcPhEKXUcXvKwDRNU9555x3CMOTy5ct86UtfotVqMRwOCcOQL3/5yzz99NPH0KrRaHDr1i1eeOEFvv71r/Pcc8+xvLxMmqb0ej0ajQZhGD4G/gA8z+POnTu8+uqrPPHEE1y6dIlms4nv+/i+j5SSOI6J45iiKABoNBpcvnyZjY2NY0fnvP5zlUP7njQvyk7KRSqD6+p9dxIYLAPyRfN50ef5OJXhX9VhWA1PXJ131fugHNK1fM2qyv1UfWhhft2T4OFcVVBbBqiLHN7z94tczmWd9OBBtaxatWrVqlWrVq1atebKBiNg5sbzPAHOx1iLlQKtLXfv99l46zU6p5/i0S9+xqWVDE2MdRKpfNJs5jhEWYydwTGDoLCO3jgjLhx2nNCMYxpRgMaQFo60MCAFHmBSzYPb90hzzYUnPfygwamz5xg7D1/6PNifMNjdYb3psX72LJM0I02nOKtRQhB11zF+wEGusckQ/+4jrj9xGikcYRAQ4HCFxjrBdJqAm60FlZR4foxJx0jpz9Z6SKIwRvk+QdRgbBxFYYgbLbTWFEVBOhnhSUkUNwkjH4RAG02RF6TThLdHY65eOs366iqdOGaQCnojwe5ewt079zFFThyFCCmQSqG8AM+3SAS+H86gksmQJkMKi2D2d74SjshTBFYewSeJdQ6p5CwvpXVo45DSRyiHlBaTaTor65giJUvGmCJjbWmFoBkzyQ1SSpqtBq1WgyRL8ZUkMwKlZuFgJQIlBSvLS9w5nAKgixQ/XmLz/Ge4+dEt7t/bQnkhgfLIdUGzGSMV9LMR09GIob/L733j9zl97iJ37t3nl++8RZ6Occ7i+x6r62cJm036/UOS6ZRWu02aJORaowtLMhwzHo5RYgZiZdgkCBVFlqHzjGQECNBZxjRNKQqNH81ctSvrm+RZSqo1gVJImzMYDhiNRyAsD/uaKG5x9bOf5+tf+TL/x//2vyCjDsurG5y/eIlnrl5GmZy3fvFT3nrzTVrdDocP7zEZ9HBOoAIfrKK3/Yi9/QGZlbQbDXKjCHyJQyAFFDonikKacYhxU6Rs8F9fX+XK9Ws8OBDc2nb0M0NrTbLcMnSWIg57kiyOSZrr/O29Ae+/qTmzskIx2aZ3eHiMJZ2YwUoQj5km5/vFxx+orgqdEwjmrkqD0SnWaIrcMEpyxtMUKQTaOaSYwU7jHNIP0dZy2B+A9CiylDQrCI6O6XaWuLjaJhIOZzXaGuJGTBBEWCG49ajHW/d6DJJsFqZWefiewpeCPJ1yf+LRMgLpAiLh4ZxhMEq4fe+ANM+ZZhrf8xmOUoyd5VZNsmzWHiEBR54lZHnBwEiGOVxuClZ8CKQgL2b2cT+Y5a7EWayDyvPbtWrVqlWrVq1ax/qNQWXVIVaGGmWnF/AY1CiHQi1rEQyZl1vetsi5Vy1nfs2qq7AMPeb5Bg8ODvjpT3/K3//933P//n201p8Ia1uFPSfVoQo+qu1atG9RG6r7qk6wTzt2kX4dcFkFOr/q+DmoLDsM51BzDifL7rj5OVEU8dxzz/H8888TxzE/+tGPeOONNxgOhwvrDbOxzPOcmzdvYowhCAKef/552u02xhjOnj3LU089xaVLl47rPx/f8XjMl7/8ZdbW1oBZ7smbN2+yvr7O5uYmURQ9Vn/P83j06BE/+MEPeP7551lZWSHPc0ajEVmWHTsy51DROcfS0hLtdhvP89BaL3ToVfu5OnZV12y5/YvmV7mskx4E+LTPiyDbSddfVO8yLCzfX4vybC46pry9fE9VHaQnwcJy7szq/pPul+p3S9mFuqid1f4un/vr3Je1atWqVatWrVq1almjZyFfEVgLvq+QVlJoh0UyTCS+1mRJSrb1IW75DAiJVIowCOjlGq0LZDgLCSoFSCXIHYymKcZAkecEcQvPU1gpCaQjUAJnweGBEGS54d6dB0ySlO7GadrdNU6vbzDNLeYgpROHXDjdxXkB2XSfZDrBF5IokIjkkL2hJS8crWaTm3e2uHCqi5SSIPBx1oLRNBoNtNY0Q59MSnRekBNgdTGPm0pRFEdoR6I8H20gmU4QOHI9y+HprCaKYuIoQiqJs+Yo190s390kzfjgo3s0G02Ww4iOsqilLg+298EJPD/EDyL8IMLhEcVHcFFKwjAkiJqkJqUhFdoZnBBoJ8mylKYvCQqDFzQojGWQODLngzJYl89ckX5EEAVkWYY2liDy8FSTZDrBE4Lz5zbZ2d9nmua4NGc0TYniAMlRGgz58XrCWYtzUBQah2Tp1FmUH2GM5s7WbXq7DxnuP6JVFCwFPmNjMHmO327SbDWx2vGN3/0GT137DK+/8QZv/+I12q0mXrfLYHCI8AJQiqIoyJMpTqekI3vUvzGe8mg220hTkE6HTPOUhqdYWe6yudyh62uKxDAcTZFK4IQk1zm90YT+dMpwYlCeRPkhBQKXZ2idYYxm/+CQF1/5Bf/tv/wT3vh//l+2PlB02i3i7imSZMp4mqKiCJMYQl9hs4Tlxhp5nuJMgRASX0mmSUIYxTzx1FU8PyCOfJwx5HnOoD/AOIcXhsQNO8uBKT2UH0EnYGnZcf26QzqHS1L8OCZPHV5kGR+O6SVTpMn4jy84HiU+YjAiL3Ie7OwcQcaP9cnVvT2ClEcA0/GYq1Ic7ZpRb4fRBXkyIU+mDCcTpoXGk5I0n/22ZqzFCsHS8iodX7C7f4jXXMYTjixLMEZjPUnUaLLWaZJrR+Es1hiMtuSTEX5sSArJ37+3xUQLtNaEUYwfBKyubhB7jmKyz8T52Dxlf/8hZ85dZjIccnjQI80M00wTxR6RUmgLRTIhExIVNmiEjiAImCbJLEzw6CFJocmk5EOreG7Np+ksypesxD5CcJTLc5Z3U5s6SWWtWrVq1apVa7F+K1BZdTxVf/Cfg8kyHDHGPOZgW+TqW+R6qoKVRe6t8r4q8Jjvm19bSkmv1+PHP/4xL774Ivfv3z+u2yKoWH6/CIBU9auA6kluzWr5i2BIFexUjysfs6jPqoBm3i9lkDMHTlXnXLkMpdRjDsg5nJzDyvL15zkpr127xve+9z2EENy4cYNXX32V0Wj0WMjQchvKcMjzPJyb/WHcbrc5ffo0QohjF6IxZrbwdY4sy2i323zve9/j2rVrhGF4DLgGgwFBELC6ukqz2TzOCznvg+FwyN27dxmPxwyHQw4ODuj3+wRBQBAEpGmK53nHuU5WVlY+0c/wcb7Jal8sAte/Logvw+QqODvpXpnX46Q5chJoqwK7qoOy3N5FIV8XuRkXQdJqDtnqnDupLxbB1nJdq/PnpLlfrkf54YRPa3c5/HINKmv9Y9LFjuSDf/9f/UNXo9ZvqBs3bgDwrW996x+0HrV+M9XjV6tWrUUqshxnJUJKcEd/Z0qFUqCNZaI1t7Z2Ob0/4RIFFAbjYGpABSG9RHPQn7IWLxMqgXOCOAhwCNLCzmCOpxCBj0MhpSAIJF0pcA6sE6ija08Kx2jngDwv0EZw9tx5cgSrnSndjsfy2hL3DkdIa/GPwlTiwOmcrs4J1i+xsnGG3mjMzuGA61rjBSHawrTQOOmRJWPa7TYjJUnGQ8aBRRQTMmMojJlBS+YpJRSTzDCdpmhrSZIpoe/TabdpNZt4QQAwg09u5nEESzOOeOrCOhJLr9+n3QpZCQKuP3kWaQoO+xPCRpswbqJ8h/RjtLb4vk8URXRWuvjpI0yegHNIMYsGlReGyDcEXotQttCJ5d7Q0IiaNJe6yP4DnLEYaRAqxBhw5mhdpDwQik4rZm19nbd+eZO00OhU82B3iBSCZuzheQohHMJqjLXkRQFC0Nk8x7pbJlreoEAxGvTZ375P/2CH1SDg9OmzPByMEXLmImxEDVZWVtncOM0TV5/mzbff5s3XfoLWOY2lFYyU+HGTbDrmYPsuAokfRERRg7jZJowilC3oKMNyu4mQHoF/nt6jbXbGUzzpMUg0g6QAM8s1qtMprijwfJ92s8HSUptxXnBweMB03CdoLhE1mvgeKCXoDcbcu32LX95+RCtW3H9wl5WzT9KIWwx7B9y7e5u11VV69z/i5z//GakxdBoxWZojlE+eZkyTjHHvAGMcVhhW19a4cuUyO1u36fd6BFJxOBphkpRxUpCmhrgd89Qzl5nKVV7tOfo3pwzHBk91WVv2aMXQDA3dZod2lKIsFIXFY8K0yNlPCw56g1m4VyE4Kf3kY8FeSy/HbLLktnTOYnRBlkyYThMOekMGqQHPI1Q+Fy8+idEGBzSW1njm2hV6D+5w8+49LNAIPIoiZ2nzEv/6v/lXyIfvYkYP6fiGorAkmWYymXB3u8cLH+4yzA2+p8i0IW42WF3dwPd8jJ3ihxKvmLl6gyAEHMY6lB8j0DTCGCkVFoEtCjw/ZGVlDYwmKwqKdMrBsM9wPGKaZEgxWyePUsNuIjkfzlyuuTEzt+uCdXutWv/QqtfNtWrVqvWPT78xqCzDrSoAKTumyj/yV51VVZABnwwHWy63vL0KDMr1qQKGKkjxPI/hcMhLL7107KSsgtfq+SdBykXQqQpBysd+mtur2r9laFI9rlqf4ycyT3CEfRpMKQPHeY7Dah2qYzN3Us7h8xxQVusxf+95HlevXuX73/8+YRjywgsv8Oqrrx47KRcB0Wq/zbclScJgMODcuXPHdS4fY4xhMpnQarX4/Oc/T7vdPt7f7Xb50pe+hJSSVquF7/vH5UopGY1G7O3tIYTgzJkzHB4esrW1RZZl5Hn+2BwTQuD7Pp1O5xNwtgzbyyB0Di7LgG8RvCs7N6tjXC6nGga13JfV+bRoDpXHqwxAy/2+KFxrGS6Wc3vCDCiXz6mGiJ5fe5H7cn58GRyXw+GW6+R53mPbyvUqX3dR2dX5tSi8cfnVuY/D8pb7v9r3tWrVqlWrVq1atWqVpe1RvkMnMKagyHdptjZxCKwz4GDr0ZhL8iFNJUmdw1OS3lRjDXiJ5da7+zSDZXwlMAiacYQQgqLQCMA6OwsJKQHhkJ4/c5A5AU4ipUAKH6EMoRJ0T20QNJs0Ap+Vc9dpXP8cT5xt89Nf/Azz8BdIOcuVhwPhzc4XNuezFy9w5YtfZGea89qNv+HDm3fQSLxmizsPd4kebdNQDuFHpHnBwe4urDiEM6A8ssKQpRnWGJwwpNYxzh2j8ZjpZAzO4HuSVruN7wdIqXDOzkLfitmaylOC06stWqHAFwW9XDI+0GysCpqB4uLpLlEUEbXX6Syv4oTEODkbA+nhKUkrUnh7ewTWMXYzF6cVoA0UrkBKi/QUSAXC48O721w8exqpFLowuKLAVyHaGCwzV6SVEikVZ9bXEFKQTDOMEUxyzf4gQUnYWGnie/M0Gw6da9Isx2t02ClimuvLTJKU6eiQ3UdbJINDNrurfPH5f8bKmXNcGQ0YD3tIHIEfMugf8vTTV7h55y7vvfk6F05vkqVTelnOcDCg1Wxy/twplqXGOofWBcZKMmdZ6fqsdlcJgoDB/g6Pdh9hVAOTTJDjPm7HkQKZc2jfR4XRLMeikvh+NAtbKwReM+Jit4uSMBxPOTjso1GcO3eR9aUet+7v8Nabb+OKnDtbW/jBfT773Jd59PAevV6PlbVNPnjjde5tfcRgNKLIUg52c5wpCH0PipSlRsTKqU3Wzl7k/JNPs7SyyqXLV2ivnuLRnQ958Yd/xc5BD4HAWcuZc6f4zrd9PJkAEmMCstSSFQJtJM5JnFGMEsFArJAklq98I+PuLxN++G7GoHCMRn2sdaA+Bo/icSb5mHNSPLb9CKofL3Utzhp0npKnE5LJhMPBmP4kRXo+DkF/nBIGASAY9Hr85OVXUZ6PCtt4gPKaOBxKSH7wg79GCgM6J/TAk6CEIPBbTHEsn/LoIsiyBOEFNBpNsBasJckSdGEIm10acZPYDzDO4fsNFBO0MTghacVLuCIDIbFAYcEaQ5qmDPo90jwDB1LOwski4EzLY11ZrJ25pwHsEcSc5fCs3ZS1atWqVatWrZP1G4NK+CTIs9Y+lqcQFjuc5p/L5cy1CKiclFeuGqK1Wrdy2FiYAaMwDBkMBseQ8t69e4+F6yxDpEVQsNruRfWrAo7y+0WgsgqqToJDi661CD5WAU0VElWPzfP8EzCyGqK3fG4ZUJddlOW5UAZZzjmeffZZvv/977O+vn4MKff29o6BVNl5W+6TKlhSSnHv3j1+8pOf8MQTT9BsNh8DW3PH5PLyMtevX6fVaj3WBt/3WV9fxxhzDLrm81YIwZtvvsnLL7/M2toaTzzxBO+88w4ffPDBMcguAy2l1HG413kdqq9ll14VYFfnRLmec+g3r1u5zDKkrN5P1VCoVUhYLqt8ny6qZ7V+1ffVufVpx5VfF+WdLbe9Ol+r28rtqLZ/3ncnfSdU+3/+uXxstV+r9215LKrtrVWrVq1atWrVqlWrLCEsxjqccUhfURiNzvqgOmBnf7dOs5w8hp0ophHGhErN1itScF5Y2klOME1Jug2EKYh9xWoU4qxDG0PgLH7kY4SHNgLPWYyVFNahhMMXs3yIVgVEa+v47VUi5VhfWeXJ332e7Z0eqd4n6CwTN5uMBgcAKCXxlQcOplmOGfcYpBn3t26xs7fL//UX74AtkJ0VXnjjPV7+5R2eunyZ5UaEH8eAI8tynM7Q2qCdxBjHaDwlCAzaQmoM08mUQW+POGqy1F1mf+cRQkiEFAinEMzcl6HnsdaJiaQhS6dMCxjYNu2ldQZ5gW9GBFjOrTUhbhCvrGPxKIxBawMIhDN4niBqNLCZxVpDURiUdExSjfUMIgKQ4KDVDLlyboMw9LlXFBitsMKhgqNxxaGNRgqFVB6nT60wTXOipXWc+AjjHKO0wBsKjHH4voeVPlZrkqygl/usX36W1IWkScJo0OPh3Y9QecKTpy9w+jNfRAcN9g4HCAF+cwWEYJrNQvjeunuf915/lTCMUcunaePw0imnPZ+LVz9Dp72EwqAkxELTCRzpNGEw6JOnCf3DfSapYXuUM+rvEUuBzQuyfA8PQ2EtuYWCGSS3UoLyQUlaS0uoo0hDUSPm8vmzHO7v0jsckSQpm6fWWFvNUH5AHPpkeUG7s0wU+Ax6hxjr2Htwl5vvvs1wOCDwJMW4h7CGZrNBux3RXFnj/FOf5epzX6CzukFr/SxKOKb79zjc3cHzPf7gj7/L6y+/xKPdQ7ory1w6f5ZWoBGuQBeGQDr8wNDwJUEgaMaCKFAUuSPXDmMFUaT4RZzzV3+tkcLS235EmhdEkToCjkdrv/l9Pcs8CQiccOUYr0fvS0c7sMbOQGUyZTIeszdMya2jKSVSSJRUKHn0IC5H0cjyAnt0H7hZHGeMTTjYzY6qZBFSfXxd67A4EAKBRPpthBRM0xyY/XYRNDcQRYYXNSnyjGlhiTxHnqUkRUHge2jpE0YRMgww2mCso0jGOKsRGHzp8AQgJWEYE0gQNud0xCwfJbN6SEq/Nxy5oWtWWatWrVq1atU6Sb8xqPw0SLjIybcIbFRVBl1zVcOTVl1czrnHwo8uylk3h6e+79Pv93n11Vf58Y9/zP379ymK4hPgolzv6r4q7CjXfVFflPctAhtVkFs9fpE7slpuuc7lfdV+qMKeKvyqHlcdt+r+OaQsu1GB4/6eA6kvfvGLfOc732Fzc5NXXnmFn/zkJ2xvb3/C+VYNu7tIUkr6/T43b95kOBzSbDaP22uMIUkSJpMJ58+fZ3l5mb29PTzPo9PpoJQiy7LHxnxeJsCdO3f44Q9/yP379/nDP/xD2u027777Lnfv3l0I0OeA9syZM6ysrCwc13n7qmNfdv4tgsqLwiiXYemicT8JhC9yepbHfxEgXnRPlDUHpVXAvAg+lttRfl9+wKF67epcXfS9Ub2nygD0pD6av6+6IsvlVbdX211ty0nH1qpVq1atWrVq1aqFm+Vns87hWUkYrpLle0jfxzmLJyxtmfOw28Rvt7i6tEZSTNFJRqcRIwKfFW3AaFIcSghW4ybXlMIzDsUsNOpoNCI3gnE+C68ahgGKWQhG6UAJib/cRcRNjM44tXGG0+un+PIXr3I4Mfz8Zz9HH27zxBPnuHNPMT48xA8jRlnBeJLQLwQ//NnPsG+8QzYdkOQ5uiiIo5BWM8APIqZZxss/e51mo8H5U+tEfoc811BkYCxSgkOgjUEZDVICgv5wyHg4xOY5oe8jlX9kYRMoz6PV6ZAmCW3fEUpDmk4ZjQsOdM7KxjJhq0MQxST9Rxjdg3xEJBXJIUQrl1DKwzmBsR/nAtTGgjZIzyIQGCDNNdIYClVgPYu2FuEcm6dP05/kwCzdCU7iBcXMSedA6wJPBfhKsba6wnDYo7W6jhCKZhggpWCc5mRGEwSKdruFUSE7u4Y7oxCjAsajIf3ePrsP7tDEcenJpzl19XMIP5i5ZPl4PXewv8O9Wx9SZFNkkfHMc18mbncRUqCCCHm0RhNCMUkyAJabESurK+h0yuHBNh++/XOkTvjn/+a/4/7NWzy6+X8Tak3XV+RSkFuDEgKNJHEaUVhyB0JKZCfEi2K+8rXfww8j4kZMoTWtWPHowRa3721TFDlOF3iBT2t5jZVmg2vTjM3TZ/A8n6XlDnEY0pge8owcsGULWmFI4AyN0KPpSVqNFqcvP8UzX/s2G5eeRHo+SimGO3fJkylxHHB6Y52trbs0Ol3a05Sz585w5tQKgbJYY4kbAmsdvUwTROEsF2ohiH1L6DvCYL7+K/AUdDshRmoevP0Kr7/5Nr/33NNIZ48dgsevxz7Kj1+ObvjShvla1WKMJkvGJJMR9x7usTNKEc7DkxLlBfiewjt6WNwBzhmcnJfiZuBeCHBu5vQEhJjZPYU4SrXCzH1srUEqDytmYHAGOQ15PnN3OwfCb5CnKWlu8WOPrNBMsxw/bGCzHGSE7/sEWEDhhz5xGEIxom9TIgxDI/E8BU6zHitaHvgSpDjqG2FBSPzAx2qDNgZt6wd8a9WqVatWrVqL9RuDyjlsqYKJKmxcFHpxUVlzLQKbwLHrruqyOqmc+bnz83zfZzqd8vbbb/N3f/d3bG1tnQisquXPocwiIFsFmIvcjIvel4HHSRCyet6vckmedM6i88rnVOtQhT7VsuYgqOxcm8PJ+TaAKIq4cOEC3/nOd7h8+TJvvPEGL7zwAvfv30dr/Yn+/lXQu1y34XDI7du36Xa7x7kr8zyn1+tRFAVKKbTWPHjwgMPDQ86cOcPa2tpxvX3ff6zM7e1t/vIv/5J3332XZ599lm9+85t8+OGHvPXWW8c5NKsAT0pJt9vl2WefZXNz87G2l/urHCJ0DnYXtfdXOQnLY7wIolfH99OAeBkKLyq/3DeLrjt3fFb3LwKWJ+0rOxfL16u2uxxutwoyy+eVc8yWQXn14YaT2lftqzJILte5ev0aVNaqVatWrVq1atU6SdYanLU4JzFGEoctDB0awZSpFiylfdpmjCzWaYUx3c0rfPTeq+xsbfHZq2cZKsVZpTBWg5DgCqJQsLQaEsrZ36Jaa1ya0B9q8qkkd9AwliCQCGtx0nLq7Flod0nShCIx9Hsjzp27wFK3RWNJ8O7tU4wnKZFf0F0/xd4o4+HhiCRNCMIGIloiyzM8q2l2lmE6ZTgeMs4NuZ3QiAqiMKLbXSLNNe/fvc9uf8hSd4nl2KPtC6TyMbrA6oIch7MFvpIUukBJSZ4XxFFEo7PKZNRHOAtIlB8SZVOUycmmCVmWc3+QM9U5wmuydmqDMG6gmqfIC4sb3GE6HsJkjM4ywvUrWCuxRuOsIdUFgTFI3CyEqRcQxw08O8UTKcmR09Xo2cO50+kUWxikmH22zqGKAick7mib50O7ERJHIY+2E6LmGn7gE6kWy23JeDQmSTU7g5S+DdmfCkwrYJIVpMmQg90HDPe3aVvDtWc+w6Xf+SbaWeJiQuBnCCEonMetR7t8+M4v0KMeZ9bWeOILX6excgqHwCGBo+gzgMLRcoblRsTS+hKREORxkzMbZ/jgxf9My/O4/aOXaEaKJwQMPY9xoVFCsOT5OOPITAFW4gmHdo4Ehxc2uPj0dcbjActRyM7uHlu3bxL7sL23j8OxsXmW69eukmYaWRQcHvRnYFp63L/7IeNpxjef/6fInQ+4cqpFfNdntdui04qJA5/O8grLZy/Q2jjNvZvvkg530TIgnw6JfEm71UbnOQ+3bnK4t8vwcI+l7jJrDYka3aNvfXAOKT2cEOSFw7NNhFQYTzHUEinAWIeQEiEVUjp+99ppRrlFO8XrP/jfOaX+OaudJlIqpPKR3sz9KJUCoRBSzUChELNyOAp7Ov/nwBrNZHDAwYPb3Lv1EbcfHdBthIjMIgDPD/A9D6XELOepnIUqdoIjV6KdZbsU4KydhXh2wJGrUzC7lJQCIRxGH23gaF0tZvlmhVPYo3Wv73nEjRZBZNHZdNYGY9CFxhmD0foot6QDCvI8ZzoeU0wOaDrNuXbA+wNDniWEnmCz4RN57ihf5eyh7sw4/E+D7tMAACAASURBVFaLS9euEAvLwcOHbO8c/oN8D9eqVatWrVq1/vHrtwKVVaBQdjZWjyu/n4cVXQQcyueVj4GPc+BVwVk1v2QZSJQ/v/vuu7z44ovcunXrsbx35WPmYKMMJ8u5AMuqQqYqODoJMpX3VT//uo60av+ddI3q+VXoWX09CYRVHXrV/IhVl5rneVy+fJk/+ZM/4fLly7zzzjv88Ic/5N69e48BpXn5ZXA1b1M592G1XYPBgNdee40LFy5w9uzZx8IOCyHIsowsmz09+tFHH3H37l2uXr3KxYsXjyHlHGANh0NeffVVbty4wbVr1/izP/szxuMxf/7nf84vf/nL4+uW6+acY2Vlha9+9at85jOfodVqHc+pk2DbHKZVYfZJkLa6vzw+VWC3aByr8K06jmXN+6J8D5dB3LzO8/1lcLvIXVjOeVqeT1XYO79mNVRuWdX7c/46/z4oj0/1fXnMyvUu/1vUJ9X7qnqvl+tc7qtatWrVqlWrVq1atcoyTEAYPE9iHOTFBOckUhvOmgENPSQNI3Qj4mDUZ5qMETiWl1qoqMk+kpsYhLNEQuALhxQCPclpRAphHThQTrPuO6xJGWuBKiQjG5IHPptrSwTdJZwDEUckuWUyHnF4sEuW5+yPNE1f0ickO5yw1G1x9dkv8v6tB+i9XTxPMuwdIqxBC5/xaIwzmmbUwFiDNpZJrknyMVYXeEoShwFplpHt7TMOAzbWVjHtDYZWovoj4mYTh6KxtILymxinsEVCloP0AhxqFgITmI7HyMKQGR9T5Ey0j/MCnC3Y2dsjbt/hchhh8BCNVbR16MFdfKspBttYZxGd8xg7cz9Opj2WQyiMwTlBGDcJGm2CfI/IdxymBi0thdH4VrMWekxtgTKzvJPGWooin4G3I6emw7K+1MZazXCSErdChAOnNaeWlvFszv4oZc9EOG+TxvIZhv0+o0GP/d1HmHGfJWfBl0TtFuPRGCnhc2uadpChPEV/kvNB/z5ROuSPv/okT119EqN8tBtghaKwksxAYT2KQtCcjgiSAfuHHodv9TnVXaexfob16ZjPx0tMd3fov/4LbvuSgzRDGsOm8omUB0IimxEHoxFTq8m0YGw1LK/wL//tv+Pu/Qf87NUXuXPrJs0g5Pvf+z7rnQb//j/8BwSOg/09RqPzfObaM1hrOBgMyLIx3U7M7o4PxQE/feVFnnxmjY1lha8kQRzjlJqFXC0Kdu7d5M77bxPGDSwOz/d57qu/z/nPfYGoEZMnCcl0yP7eLoEf8vTnv0qy8xEHo5x+UuAJQRh4+BI8KZn0cgSztD9KCKzJsEWGEx4OSavV4l98/zugfITyUH6ESm7jUoF24JzElX8nERKHQkg5g8RSgfQQ0kMoiZA+QiqsKdi98x4f/eIn9A8O+NzldT5jYZQaBtrHa3YJmx2KwpHlFiMFeaExzmGsxdjZA/uOWR7VmdlYYo3FujmoVCDcsctXHLmVYR5KdhZ+VhyFZVX+LCQyypvNXzc7rsims3oLMWOdR15e52YPXFhTsNT0Oes7HowT+oWlG/g05AyVu1kEWoxzWAephgeHU1a6LVrnr3DtjF7wLVmrVq1atWrVqvVbgMo5bKzmEIRPuhHhcTfefH8ZdJVDYZZVhhplN1O17DJ0KDuw5m67ra0tXnnlFd5///3jnJSL4M6i3JCfBn3Kqjq2qiB2EUSsgsEqGKnW89PASBW4lCFZNZff/LhFYOgkaFYGitXrzcuYl7exscHv/d7v8eSTT/L+++9z48YNtra2HssNOVcZRJbnxHyOlaHyfF+SJNy+fZvpdHqcK7LT6XDu3Dk++ugjHj58iO/7XLp0iWazycsvv0yv1+PZZ5897hPP847b0Ol0+NM//VOuXbuGc46/+Iu/4LXXXjt2U86vO59PQRBw7do1nn/+eVZXVx8DefO2GGOO51q539VxKJ6THYLVc6oguwrS5irDs0VzahGQK4/ton1lUFi+PxaFfy6DwOocXpRftdz+KnivOibLKs+XeZ9W82wu6osyJD4JXp6U/7I8LtVtJ0HmWrVq1apVq1atWv9lK8sHCCEorEAAuR7jOcuqF9EsCm4JD6NWOXw0pasyZJ6yublOdHYTLQV7SjJGspEWNJzFUwLP9xikgvE05VlXIFRAZnI6TR9ERJwarkwN/Txld61D4/QGVucoIbHWZ7g/RHZiXnrhBS7/7j9h5JpgNYXf5M7uHc46n8tnn6bdGhF6HkWekmrNYPchZ89t8mh3lyxLkc7hqaO1t7O0Wi1wFt+TCGZrnsAP8DzFKMnwvJhDp9jfGeMYo6Qk2LzCgZK88PKbrC530EjG4ylJWpCmCdo4nFA4Z0HntBpNjIzppwP29g8YDfvcunOLa48e8ewXvoIfNPHiFYQfkO7dxGZjumaKSPdITMwkzcgGe3BaEfg+SEFraRklAyLpEfoWkQmsmQHYaVYwGo9xRUaeJ1gToY1GFzlKzPIDWm3AGTbXukwmUya5IwJOLTW43G6xFEs82cXJIUkYw+nz3Lp7l73tB6TTMSpLOeV7TBHkzpEQkG0/IAwkcn0FJQHreOv2HoNpzleeOMUXP/ckylcIZ3BopJiBsXyqSQc5RaKZ5JZ3HmxzuLPDhjF43UPaoxGTvV1IJuxORwzynK6UXEcS4uMs5DgKDwqtCXEgBQJLgSVJUv7zX/8VD7fucDjocy5u8I3PPUdn+RTXPvs0Tz95mYeH/aN1esC/+Ff/Gj3c43/+j/8jUil6B3sM+oeMJgkEOY0v/BO0TAl//ojm0hqT6T4BhmQ0oLvSxegxbpIyGk1orqzz8N4dTHKA0lMKKxiOhty5fZvu5iU6q5u89vYWifaOnYZSCqSchUgOlAB8lBQoAcJafOmhsChhUcy2+7LAEzm+nxBI8ITFl4ZACTw5C6fsCYdUEuFm6VCkUAjlzUzPCJx1OATWOYzWNNIxz1y5wLUr5zHWYZzCCYlBYcXsvXUC42Zr1iIvyAtDVhhybckKTZYXJGlOmmsKbUkyTVIUpLlGG0FhLYUWFFqiDbOcokfr1kIbjDtKpYTA9zymoyEqbmJ1gRUCITzCOCbPsyNIOXOEOuzsvXXEHpxrB7QVXF823JxYLjUFzlhyM4Ogs74X4CzJaMD4w4wHjZgoimkvLf8DfAvXqlWrVq1atf7/oN/KUTl3xpV/6IeTIVwVMM6PmZe1CJAtCrl60nXm2+b18jxvlsNgOOTHP/4x77zzDpPJ5DGgUQV71dx28+PmgKpa7/L7RXWt1rlc7zLcqTq2FrXt09q9CDjOjy3XrdrHi8au+nkRzCrDq+oYnj9/nm9/+9t87nOf46233uLGjRt89NFHxyFZq31eLqO8T2t9IjwrioKDgwMODg4AWF5eptVqoZTi8uXLvPfee/z85z9nOBxy+vRpkiQhCAKiKHpsHlprCcOQa9eucfnyZT788EP+5m/+hhs3brC/v38MQctjBXD9+nX+6I/+iI2NjeO2V+tYblN1bp0EnavjMa/np51TvWY5pGp1nlbDqJbLqp5Tvm8X7VtUfhUgVh8wWHTdar+U6zrXSXO7Gpa5DByr4LO8v/q9tQjULjqvOnd+nbyqtWrVqvX/sffmPZJc97nmc86JJdfK2rurV7LJJtncpJZIW6Z0bV7p2sZggOsZjz3AABcD3PkU8xHmixiYfwbjgeGxDdyhTUoiKUoWxa1Jdjd7ra6qrjXXWM8yf0RmMTo6q6mx5l5fW/GiG5UZGXG2OCeREU+8v1+tWrVq1frtlXQaTwqclEWYSSu4KBVndMo/ZmMOvQCVjVCjlIWuQNoJnWaI9JskyZixszwc56wmOYoCkPjK0fQU4xx8aXAuRzrBwcjS2k/oeYKGUJy+cIrJmXWMzZDOseAU929sMpxERIFHdDRm9959Vi+/Qrq4glUNrt24QbL/gP/4H/8Xnn/pVe7f/oqHO9ssrp/m/YMD4vGY5559nlt3bhONB0RZislSmoGHsC2EF2CcI/Q8VtfXyZxkMh4zHsc4G9HwPbzAJ89zPCXodhfQsSFOUg77Q5zVRR5E5ZFkhiyOWFzo0lxc4vDwkOv37jE8OiDPUqxzSCkwOK5//hnJJOJbr71Bs91lobdKo91m9+aHDPsHLDhoqBa7/TE2mSDEClmeY/KcoNsCJxDOx/ctCoPROQUb1aRRhMQgrMFZh9UWazTKV0DhsFQ4Tq0t83B3m1RbjNYEznCm4xOEAa1uF6/VZmv3gK0bHzIaJsSjPh1rwGpod7BRjLMOLTx85eGwGFcA7r1BxM+/uI05OuS1//4HKCURrgjv6cw03GfmcLnPJLXcerjP/tYWC+Mx381zOsbi7e2wuXmXW5Mxqc65EAS8eXqZ5YUmylNo50h1zlAb9mPD3iBCAy4vwFgXSRhN0D//gDUsvrUMrGB5aQ2b5DzYPaK9sEQjCGk0W6yt9vjg3X/ghRdf5IXnLnHr7Xd58cUfMBlH7O/tFnk5c8HGs88R+IpJHNOQCicczcUVXvn+j9i/8RHbt2/gryzTO3eJj3/6Np1OSDOUpEYwjBM6iyt86/mX+eDdn3E4yrAUNkMxBclCCJSURWhWV4RjNqbIGzsNkIoQComHEwVkU1LgHIU90ZnCpUjhSBRTv6+Utsj/Ki0KjRIRnijmgicdgS9pqAJ0Br4gkAGBsHieIFQCKSzC5njK4CmFc6LIR4kDC7mRGHyEcBhXuBWdkxgLdgo2rSuAsjGOzIC2jkwbstyQaUdmLFmmmSQZkyhlnBSvM6/BWOTgeQzGOUZnWGfxikSyxXU8s/sQIJAYZ+gEkq4nENZwZrHBSs/hspRR7LCicHp6qhhVbUAJBybCDCO29+De9sE/x9dwrVq1atWqVetfgP7JoLLqbqzCkNnrqnup7GCCx0OgzrbNIMQ851LZdVeuuwwfADzPI0kSrl27xieffMLR0dFcSDZ7PQ+4VF1l82DGPEfYSeVUNS8E6pNcb9XtVefak447qT3z2lYts3oe5uUnNcbQ6/V47bXXeOWVV7h+/Tpvv/02N2/eJMuyYyflSee+WtY8OFU+Lo5jrl+/zvnz51lfX38k72i/3+f+/fvcvn2b5eXl47/PPvssr776Ks1mkzzPyfP8GGr/4he/4G/+5m94//336ff7tFothBDHwNRaS57nPPXUU3znO9/h0qVLGGPI8/yx8zYb6xnorIYPPgk4lrdXwf48J+CT4OWTHh4o71PNu1iGe/PyOpZD/M6bW+V6qq7KWZknrb2TcthW4WMZUFZdmGWwWh6v6nfKk+DrSf04aVsNK2vVqlWrVq1atWrN0/OnlwqPkRJoLVCqxdVE80V/n10EYBE2xgvAKY/R0S5ttcCCb1jpOloNxbaEndxxUUg8IQlwnFWwlWg8q/FEisOxJx3jxNB0MDi/zML5DbTNwWra2iO7u8NemhLFEzqxxFjD3S8/ZuHpK9y+9wDf5Cg/II5TnjqzzNXLV7l+6woffPgRX336Ec+/+G3u3fqcvYc7XLxwgd39Ax5u3aXbbtLsLBJrSx4NWWg3UM0mSRwTNtusLi2i/HUcYKwlGg0RTuN5PsJZgjAkzTKkkKigiQE8pQh0Tm91lWGccOPjXzEa9ou0LziUKsbC93w8zyc3htu3v0IIeOnbr9NqBnQXVlh+6ts8vPEz0p179JZWOb/Y5cGuQDQ6oHxMnhTuMeWTpwqtLdoJdJ5jnSvAT5IVQTSPQ1pajNGooFXkDrSW0JO020129w7Y3R+xsHq6uMbA4fseuZNgHCsLHY62j2CS0XKGi6tNbu/nzCqwroid2ej0CBSYaZ03d0e0goDff/151tYWAVGArVwhch9Ji8NxxBd3bvPg9k0Wk5iXfJ+ecQidY3PLzThiU+T84NIZfufUCqvSJxjFiEFMfpSSxglRljHAst/02Du9wNYwYX9fMxKSXDhUEOA3AoLAI44m3Egybuzs8j0R88WH7yOA733nWzxz/hzOGd596//mq+ufQJawv/OAv//7/8Swf0Ca5TQamp3tLTqBZaHT5qsHW6w+cxqFJI3G7B0ecuWHf0Lz/b+jtbDE+GAPdMTh/hCkwvohfrPF0voGm3fuc+cgQTs1zRMJUtgCWDqwGJwxSDl9mNZZjLNF6ORSrseZ8keuDQtIWEgU5QPCSayY3VIr3S9xgBA4Z4v/1sG0HLAIAUoUQVUFDiksPg6JQUkIlcOXFk8YfAmhEnieoukZlLB4wuEJUEoSSEfLk6hQokTRCWcdILEWipIbhbPTgnaQpoYPbk645UOeGY6ylMPdTTJtSJKoCN27u4lUCqk8FpsNtLEYk7FnYya9Lm0hQFiaUmB8jzjTxVoAhHDgBIGvsNpgtMMaB8ZCPv7/8+u1Vq1atWrVqvWvSP9kUFl1I1bBVhV8wKOOrpkDrZp7bva6CkjmActyXVVgqJRCKcXW1hbvvfceOzs7j4GNcrnf5KqaBxBn7S/3YVb2LBdhuW/VPlQ/q9Zf7ec8/TqfPQlYVp1n1fGsjkMVAJXHZnFxke985zu88MIL7O7u8rd/+7fcvXv3MSdl2W03q68a+nfeuSi3R0qJ1ppPP/2UVqvF8vLy8Tn2fR8pJcPhkIcPH+L7Plpr9vb2+Ou//muyLOPcuXP4vo8xhsPDQz755BP+8i//ko8//vjYfRmG4SOA0lpLq9Xi6tWrxyFkq2CtGvp0BipnAHVeX06CtWVV11EVtpXn2iz8bHl85x1brq+8NuaFPJ0HUMvlV8MBz96X51f1mFm9J83Lat+q4XXL3yez9/Pcm/O+q+adu3ljdNIaqvazVq1atWrVqlWrVq15un80Js0snqfIc8elcMIgy3igU1QQoKchIp3ySJTPcDTiwmLAaiCY+E209MmMYWRyjCvApvQEi2sNlvSQtjG0Gh6hdQRtn6Sp6C31aD93ntQZtM7RGrp3d7g7GNG3GQiLto5wHPP5rz5k+cr32HvwEM9YVtdPsX/vFp99+BF/9PLrPPfMRXLpMx6M6bRadLotbn5xja2tTZYWVxAb58mzlDTLcUazvLKM8EKiLCdKR4jBaJq7ziGFo9tdQEoFwsNYSDONyzRGGzQOOxqw2O3QXF7lKM+4eecWo+GANC0clEoKWo0WnvJI8pw0SxhHETiHkIIvvrxGnqb83r/5Ic1WG6/ZoXn6RbK96wwGAxaXQ9bXV5gkmsWVcxwdFQ4vIYscg3GWY4wiTlNy6zDWEWt9HIKzeGDSYczseqfAT51Q4hzcf7jPrTv3WVlZIdWGPDfTh1stzmjSzNDyJD2R0epIFjo+4lAgZQHYJOBwjPsHeNKRri0xtJZbOyPa2ZgXXngVhwLXQJoGIlf0+0NubF7j5vUvaQ0HvOL5nA6bNLSlDXSWFrg2OuL+YML/cPYcb/rLNB5kiHQMliJsZw7SCnAStMXPUxa1Y+2pFW5FEQcxTFZXWXzhLC8GO6z6MVsHbZ4ZKh7GWwwGQwY7dzijRjSfPsupi0/zztt/z92tfVTQpn+4R5rEjOMHZFkBfv0g4PqnnxLKnJX1U/zi0+scrC9ybqVFq91h68uPWT99lnNXXqF35jKTWx9y7/on3DsYMzECP2yysn6GPDH84sED/IXV43nmnAMhEMLhBFjDlBOKaXBSh3TFKwTHr6UQSEkRwtUV0K84x1/DSnsMJV3hsJ1d/xdGyKkjkQI6OzPdW3x9zNQ5Of0HFO5YNw23KpwF57CznJMIpBBTnOqYXq1znJMSi6Toty8dnipy2foSPKEJlMMXFl+BrwS+gDjLaKuUXCp0npJrXfQFgxSSNJkULZOSlvaYxBkGEEqyO2lyvl3kZ7VCIKTEk5LUfB0iFlHkqLSmWEMCS9sTxF8HoqpVq1atWrVq1XpEvxGonGmeu67qRIRHw1KWc/nNO362fR6gmcHBKiApf66UYjwec/PmTW7evEkURY/BzSoYqzo4Z9vLZVf7Ve7LPKfVTFWgMc9RNg/qzINbVQBaLfPXcXdV+35SnbN9q32vjtPi4iLf+973eOONN9jc3OStt97i7t27aK0fC/dahZJlsFSuqwpO57Vhe3ub9957j2azSRzHKKVoNBpAETo2DEN6vR5SSvr9Pj/96U/58ssvuXz5Mmtra0gp2dzc5J133uHhw4dYW+SYMMYwGo2Ow75KKWm1Wrz88stcvXqVtbW14gJrCs5mDtCq028GOWdgvtr+2dqYhSuuzoPyGqmuo3K42fJYzo4/CZSXgV4VDs7+lgFm9TzN6q2ej+rfMqws71+eO+XyT8pnWwXbs3GbB12rEHJeOeVxKs+38jHGmMe+L8rbqoB3nvO0Vq1atWrVqlWrVq0oBeskzno4nfHcs4rrd3MmtsFKK2SsMzJt0NZxEOdsbh/yytke2mgGWYJAkuaGSaKxMsC5CX6gOGx7tFZaeDonCDy0dnhScnqlx9PPXCicVTonygz7dx+yEeXczzO0KH7TDiUEzpBubREPDhgNDml3u1x86mnu37rOWz/+Kd/+d/8dYW+ZpW6X33ntKnt7Z1k5dZqVpTU+v/YRw/4R1hosEk95PHXxHEF3mWgyIYkTkiQiS1LSZEIr8AgbbeI4IwwD8EJyY3BZkesvTnKcSem2O4wzx8G9B+w93CwIk3M0fB8/8Ekyw3ASIazDCYeSTPtfhPPU2nL77i08z+ONN3+EH3YQKiQN1uj6Pp9ev0VveQVWljh3+Rz9rAj9qbVlmAEJTIxX5I70W0SpQWlNqi3jJEfroMBFxk7zEIITjtCT9Ad9hpO0cGGmKQKBtgYBeNKyuthiITe4POOuEEgP9OwBbk8hZo44HFIU14j9/ogDKbl3f5M/fv4M7dYqgeyicsXo4JBPb93gy9s3Ef0jrkifZxotloRkdbHD6rk1FpaX2Nve4/+4c4/XRIN/Q5tmKhF4oAqnLy5DCg2ugHpOCaSVdITH2tIG3rOGzwcC9ewpviOucVocst6CU60Vlg8dt+/dwbzzvxOGbQ5yyeHwNu//6nM+uXWHWBtiFC7PSbUmzTXWWKwQGGAyGXH75i2ef/Y8Cw2fW5t7rC5cIFxao6UEu5v3WHjhMgfb91hf32Dj/AUGYp+1ThdjLcOjPve1IUohPBrRajbpNlugvOK8CoHwPZwQWCGnMBBm/sZCBQKUFGFOJRJrZtea0/CwX3PGAg4KgShMhVO4LHBTUummKFNQhEPFOQTT6//p+bUzwj3L/zgt22GP80oK6wpAisQeH1O4FRGuqOdrZjr1ZxZ+TzmFpjOXoxQSIQrXpRSSsQ5phW0G42INewLSKbUVsgDmQil8KbBGY50twr9qw35iONtWxTi4Yn/fEyR5ES42t2IKagEpUcaCEASBxDfzH8yuVatWrVq1atX6jUK/lsOWnhSKsQowZqq69mbAoOqigkddXzNAMQM7s21VUOD7Pjdu3OCDDz5gNBo9BmPKr6tuxnnAFb4GqtU+aa3n5sqbV0f5uBn8mOd8q4KZcpvnAZ95OsmROA8cVV16J0HR6jhZa+l2u1y9epUf/ehH3Llzh5/85CfcuXMHrfVjoW3ntavcljL0+6Y+OecYjUbEcYyU8nhOCCHodDqcPn2aMAz57LPPGI/Hx2Fab968yUcffUQYhgghSNOU0WiEMQbP8x6ZYzMoFwQB58+f58033+T8+fNorY9dkuU5Ul0H89pcfl0Fs1VoXR7zeed9Bs9ma6EKd2dtmvWpDEarMLjcptlns/5XXYzVOVBt87z5ddLDCOUxmNeOmSO2mg9yVu4MhJfbN+9BhHLZ5Zy480LRVsuslmWMeQTAf9NarFWrVq1atWrVqvVbKidpNBpoI1iWHpPNMfupIPWWcKljsQlHLsU4Qe4c/SjB8336GQzinCD0cQjiLGeUpTSFQSC5GwlUDh0h6SmFsJblxTYLG+uoQGCSnNgIbt7Z4VvLiq3YMRQOJQROCKSAIyxbyQSdZ5AO8Vodnj53np9Ij0+v3+AnP32PC5ev4PkNzp5apdHqsL66yumz53nx1W9x+9YNbl3/gsHgiHgyYRBpFsKMVmeB1dVTOARJEnN0uEc0mTDJM3qtDueeuoQMGggEWZaSpAn9fp9h/4BhbJDS4nkeo1GEJx3tMCRoBGR6eh9AgGWaWsMJrNP4noeSkGuLNpK7925j3/o7Xnr1OzQbDVwWMUxTWq02WZwwGY/5+PNbaIBki0w7DkcTmkEH4YesL2ZIFaATR5TlSOUTNtpcXjnP/Z0dkjQD9zWQigeHfHXtY3LjwAqyNMFX02sqawg8jzTPMHmOVKCkQ2vLJEqx1uFLhRQSnEEiaC4sIYzlYLhL7gU83Wnzuy//Ho28hRwOGe5s8f98+ivuPNzmkhfw/U6Pp5pNTp9dZenMGqHzkYcx9uYRH127hhdl/Puzl+isrBeOPT0NN5trcAUc01Iy1o49rek7QxIZlhOH993vYvYTfr/7ORf0gGgMtx8anJtwazdllOYsHN6h21jjfniGMy+/zOVOg3v7h4we7hJFCeQpWZozfXwXnGMyOGQQSLRO8QPBubNn+fknX3BnqYOvbnFxbYH9rS08qTl38SIj00SunGMhshweHDIYxuzvR0ykYTEa8YJJOaVCXnvuCqGwWGew0gc/IHeW3GZkuSHPNZmzZE6QKUnm+eRSonFkFiLnyIFMCLQowsDmTqARGOG+9jSKAkk6W/THztySrnBXztyPBTC0x9ARCudm4Tos6LRzM1z6NXmceSgtDvHI9eb0/sB0jxnAnN65KepzAofBIhBulvnSokVxvHaKYWqItCZJE3LrmF1qKynQplhfTiq8ma9TFPTxMMrIV0JCMY18hEApD4eGqSs41paJhrZfOI0lEiUEyvvmh+pr1apVq1atWr+d+ieDynn53eY544BHAN5MVRA20wyglPepQpHyZ+U6y2UbY9je3ubWrVtorR9pa/n4alnz+lLdNitrHjSZjU0Vcsxzfs1zq1WBRxXw2AfpjAAAIABJREFUVCFjeVt1HMpllNtYbXd1HOb1aR6QMcawuLjID37wA/7oj/6InZ0dfvzjH3Pz5s1HwFIVWM1r37ywvPPaNO+42fktb282m6ysrHDmzBlu3LjB/v7+I/BpNBod7z/LUTk7J+VxLDshm80mp06dotVqMZlMHnOGlttcBfAnQcuTANdJc2HW3mrZJ82f8hhWoeG8XLHl8qpr+EntnjcW89ZluR/z4He1ryetzfKcmoHY2X7zXNbVMrIswzlHo9E4bvs8qDpvLpY/n9VXh4CtVatWrVq1atWqNU9SNWg2OoxHGeflhINRRux1cM5DY7ATw2pL8jC1aANpbpkYicwkQhThMZ2AJM+JozFxUxIIxcOJoxflxHmOkJJh7ji1vo6wmjhNibTlweYuYRqxZrq8HWXk0iERSASelHRCjziNUUpyav0UD0QfnU7oLi7T7/e5+dVt9kYJiwsLbGycwgoPJQTtdoeFdovnn3uO7N/+iP7hPlsP7rO3s81wOGQymZBGE7Q1aK1pN1t0mq3it7UUDAZ9pPg6pCU4ek2fUC6jjUUbw8rKKtvbm8TDfbTREEVIKab5/xyeUlPnm8EZR+4MQaCQSoGQCCkZDft89tHPWe+1WOu1cU6z2vRY7i0RhD6eB/3RhKOHd8mMpeErFjsdrEtpBpLUajIhMFZgpOLlK8+x3G1zpjHhk1tbJEYjXBEyNR4csRMPMC7EWEOapUUeRFvcm5AUDzjnpnBYKlFcX8SZQRuHVKpwss22j/q0lCC1goO9fX7n9Aat/hAVbWN2ttl/cB+9u8ubjQ5/sLHBU5cu0l1aRo0SxG4MNgPpMxpP+GQ04Nu9JU6vn0KoaeJLZOHC0zkmz5jolL417DjDrtEc4Rg6y43NbfyFNt/+g9e4mt9GHPXYGnTZenCP/cGYGIXFEiWalhzz7R/+O4604Zkrlzl/6j32Dg8Z9I+wRiOUxKZZAeWUYBJFPNja5vR6zoOwwdrSIhdWF/n4i6+QWQbRIsunN3i4t8fB4IjJwUMmk4hhf8RwOEYsnMe2W4gox0YDkqNDlhYW6N++wdMrywjpENJHToY4Nb1etBbhLNIYpHNIL0B2F6Ddg3iMTSJMnmOcw3geRhTDpY0jk5BZQ2odmRAkQpEKQQyk1pEgSKQkkYLIOibaMraWCEkmizCpUnl4nsKbPghcpHN002y17hh8z5y6TCFkIVHag2n4WPcI3pRTYDm9c4DE4abrxjk3dV46sjTGSgUO8iw7BqUz0Mrxda7ETF2gM+fnKMo4Si3r/hRuOodSHr6S5AZybTiYaBIhiY1j0ePYSYoM/3N/5daqVatWrVq1/oXqNwr9Oi8kKPAIUCi/L2tensLZvrP380BDeZ/Z6+p7gPF4zMHBAePx+MRQqfNcb9X6nwTKyiq7vapQpdrOeWBmXj3f1P9541odh29y9c1rQ7nMKswqt7/VavHGG2/wwx/+kCzLeOedd7hx4wZpmh5DwZOg6EltfhKIrbZztt33fYBjl5yUkjzP2d/fP4bWM6fk7Liyw7Dar3lgPcsyjo6OODo6YnV19REwVnXofdM5r8K7al+r0PFJ43DSvlWQP9NsLZShbXn8f511Ou81fA1Qy22tPtBQ7feT+luGxfPmeRUwVuGyUuqxY+bN8Xnvy9uq/S0D+CrYrlWrVq1atWrVqlWrLOkF4Cwdk7FgJnyBw/qLKCcJ0Sz6HmOd0vQlce5ItGUwjml22xghUErie0XYxsRaDlwDvT9m6AxxKthPBL1EcpArklwjhWSSOW7tDhjnho3OMuNU4m+sc1oKwjBASklDQLfVpLu8xOCoX7g2R0d0mwEvXL7MzhcfkUYDDg4CxsMBURQRNlv4vo910PIVvc46K8sbXHnhefwwxGQJSRIzGgyYjMdkec54PEFrzXg0Is2yIm+dNThn0dqQpRm51ownEcN+n+F4xN7eHmmacfbCJe5eH+KspXSlgQO0sXjKIwgUWhuEkAih8NTsPoVgGKUMJzFHh4rJcof1XoPEWtLREa1OC2MNcZoRpTkIQeocZDFCShpBiApDPByeJxChz9VXX0Q9+DkvXhZMjgyfjRKcACVBSkvsAtwsgo3O0cZiNOhMI32H1gatDWmWY4zj1OoCg1SjhjlKKJSUgEAB53sLvLLaw/oNPr9xjafjCD79FeQWFUVcEQFvPPsCZ8+foxU2EOMc7g8QUkHQhjDAacP+aMA4z7jSaCKDoBhCqyFPIU1wacwkiehrzaHVjIxm7CyRc8RAMhrzrVdf59U3fo9mpJn8/C2iKKcX3sPrCrQzjDNHf+QQWYLZ3qZ58RL9ccL3f/d17u/ssHs0xDlLEDYROCZJhickxlgyaTg8OmL3cMDemfOsNxe41Eq5/tU9BoMRp/tjFnc20VkRMlbnGqGadNshOhnTWj2Pl2rMzm2iJObQU/QWNb4oPIRYjcg0zhmEmeE2gbAaaR0SB4MDUApnHRiNcoWDsWBwAoPDcxYlBA1jwU1RoBAgJU75YDXOWqznYX2fTMDBwR53dna4MUl5YGAPR6481q48x/feeJE8zciMQzuBEx65tqTakltwQpFbi7YU/10BTItsj0WbjHMIJ6fYcqopOHRutlaKULDWzVZP4f5U0qMV+hwMDe44tYuYssji4QElJaGnUEaDm8FG0NqwM9GsLvnIaT5NIQonZpRrJpkm0uB8SSAFStgCaCKQjZX/HF+ztWrVqlWrVq1/Bfong8ryTfoZcKiCoPKN/ZnKYRmrx8CjwOAkd9M8oFUNu3p4eMjR0dEj4TlPcptVwdI3gcDqPvPaXc5d53neI/n6ylCr2oZ5LrR5gGqe0+uk99XtTwKG86DRvPqazSavvfYaf/zHf4zv+/zFX/wFn3zyyXGeyCoQqrrcqnWelHOw+nre8efOnSMMQ27cuPEIqL527drx/KrOweo5ns2hMuws15emKVtbW1y7do3V1VWWl5ePc1Q+Kf9oua5ymOJ5IXXL4HEe5C2vher5mhd+dZ4D8EmgbXYeqk7K8hhWYXz5/7zzWC5zBhCroVZnQHHmTKzCzSrMrIL0ch/L3wPlkLfl8bDWEoZfP8n5Teuhut9J/axV678G3R1anvpf//qfuxn/anXnf/tv/7mbUKtWrVq1/oWp22rhm5SzTIiFYeK1Ub5HiOW0MywGkt1EshAGxFlCkueMohgrBfgBEsfvXLnAxXMb5Mbi+SGBVLzx7eeJxkNsK+DORHA4HOM5h7PQDHxevbSBlB7WCkyecDUIEMpHSA/P88kyXUAaYXHZiDxYQqcRkefz6pUrbH7xEXevf8aFb32f0WjA4eEh3XaHxZUVMm1YbDcJG+EUgEiabctip8VCr8fGmQ2sK3CHcZBkhiRJGQzHJHEEzhInKVhLlESMxxF7B4cs9A/Z2z8g1ZbB0R6dTodWp0cWTRCiACJaF9DECYdxBk8EhGERXtKTMPOSRfEE3/NoNBr0FlcR7QUmwtFsODJf0Aw7CAfKTGgCGYosy9g8mpDlGWEQ0O0tstqAQFpyrYkOtzjdCfE8H9/3cUiEcKwvdvDSlFg2i3CegLEWqXxyL+TANEi1IM0VeWKJckUjCHjqzBIxgntHSQGkpeRMr8e/OX+GVzbOIAeH/M0X12jdvcWyJwhyRzfLOdVos3TqNH5nAcYGMUkgCKDVLGiSCou/ccJu/4BlT3JxYalAVlIUeT+zAlJmJmeQJgyNKSClNURYxs4xFhLVbdNcXsRsvg/nLzDWHbyHP+a5ZzwaXctHH+X4DUESW6TR3P7gJ7z0yne5d/cuV7/7Oj95910G4wipPOIsp9PpkKSHhWNPODJtGEUxmbYkt66z7Yec6bY5226RxAn3HuzRH7TwBThrGMYp/cywcWqV852YnZ1dBnGEn47oGcPDyZgLM1fgsXF0+kJYkEWuSozDSYtwYgoeLUI4nDe9frSuAOROT9eVATt1PToDbnY9bHAOnCtyTRb3ezRxFBGNR+jJBD2JMQ4WhCBKc4LsPBsdgQmmYV8RKF9icoNDIqUCKTCZxViDdQJjHXa6r7GQZjmZceTakhtHZh1xapBBo3BmG0tuHblxTOKM/dgglUJKhfR9glYDZZKifGumq6bAuFJK3DSvpHUW64p7F1IUY5hby94oJen5tEXh8nROEAYeqbEkSiJk4R7uW0GjKWZZOHHZ4L/QN2+tWk/W3WEdFatWrVq1/mvTbwQqq9CgCiyr0OH/i6puzXlllGFTGQw654jjmCRJgMeBTbltvw6kqAKTar2zfec54Kpw4yR3WPW48vuT+n/SvlWICo8C4m86dh4gLoOtMAx5/vnn+fM//3OMMfzVX/0Vn376KUmS4HlfT6nyWFedeVWV54k5fqJvfujN2WdCCHq9Hm+++SaNRuM4zG/ZSVeeg9W6Zu2y1h7D1XIYz1n9s7kYxzG/+tWvePbZZ1ldXX2kP1UgNnt/0vyoug/nuThn+5ZdkNX+l+FddbzmjXEZsM2g7GzNzs5dtVwhityhQRCglEJrPTePaHXel+dM9buhXE91TZXLmLW7PA7l9lfzVs47v9V1OA9+VvshhHgErJbnbzXk7pNyqtaqVatWrVq1atX67ZZLI3o6YYGcWxYyP8SzGV0bcWo15MUXnsLd32cYRfQzg3GWSaIJQgNSY7RmY3mRpYVFoskED0sYBhgDK801Ak8S5xpUEVrS5pq2rxhFMdpMME4inCVKE7Q2ICXWFeEZsRZfCSb9fbyzZ1hcOsVR/wCnHWvrZ/jFB+/RW90gXDpNnmfsxvskaYrn+TjdRihFluekWcZy3sMZTVu3j68rpJJoB0mSM4kS4jjGGEOc5ZgsJ9cGY2QRflN5OOljnCzcZAZMnrB86hy7m3eweYwnJdIPyE2RC09JhcMiRHEtZ6xFSvCkpLXQpdnqkBvL1t4eO3t7LC32WFpaodvtkuouSyunWHlmDSk9cp0RTcZs3rlBfrhLqjWKFp2uR8dmTHJNOh7iehZtJcaCsY7A87ny3EUe3DIcxRIpLb2FJRaWNpDrF3iQpGzt7BAnEVprdJojkSw2uqhmi1MLbdqtXRYaDa6++m1+97mXWPN83OZtRvfu8ODBNr9vDKdswHrYZnFlEdXpIjwfhIKFBfB8kB7T5JdFqNA8w2UJoyzhlO/TCv0poMwKJ2WeYrKUYZIwtlNIqTMmzjIBJs4xERYxGKImQya//D85+OAIfXDEQs9j5WmJ1zQ0vtQMDi2hEBgHt7cesHzzK7yFBrtHA773+lX2B312+xM8CUL69Ba6TKIYISS51kihcDhybUiyEbfimJ1GQMv36LZa5NoQApuDMTLwCJXkzuYDoqUeeZYxjjO0cby4ssozEuQ056YCsKZwmc5ApHUIJcBTuMxgjMFOw/FK8XUoYlvKKikQ09CxBuFAOIWTFOMMSGvBqWJPZ8EKfCEIZPHXFxAISSgkWuQ0myFgC4eiAE8pwKHCAOcszhYtwBMIAyCRQhZQlOm1cWBxQmB0jjPFa60hbPrF58YcA9PPr93g737yJVp5GATL5y/z1OlVtBUoa4iSBDd9sEAIQSv0SXON8hSec0jDdHwsM6Q5STL6qSUMpg8y41DKR4oMJCgcubEEvizydFpAgc2i/xJfu7Vq1apVq1atf4H6J4NKeNRhVQWX89xG88DN7H0ZFs32LavqFKtCjKrCMCQIgkfqqJZbds9V6y07yqr9Owlalvs6zxlZbkO5/U86/iQ4Wz2m3J7qcUopfL/4wZplGXmenzi2J0HS2ThIKXn22Wf5sz/7MwD+4R/+gZ///OfHORvLDr/y2JXH4yQAXXUCPknOFXko/+AP/oDXX3+du3fvPlJH1Zk4G/PZWEgpybLssTaW3X9VSKq15s6dO2xubnL58mV83z8Gz2Un4klAqwovy6oCvPK2Mlycd66q41v9rFrurH3Vcsvgb9afGaBrNpt0u1183yfPcyaTCUmSPFaOlBI1zbdRnuflcZ6pOj4zaa0fW2flfpXnSxWGl/tZfl89JyeVN297GXaW23xSjtJatWrVqlWrVq1atWZqpyO6NicG9qdAxov7vLwR8urFNm17yMYLbf7uiwm7Y4VONHGSo7wEl2SkqSZvSsaxJUtS2h74soMnit+innP0AoX2PFKtkSrgaDhEGFe4+9w0BKazoHOMtVgLThQ5CnNjufXVlyzpBrmGjeUVVs+/zlEEewf/F+/8p7/ipe/+gMX1c+Ta8jCa4AcBUdQCY3HOYo0tckU6h3UglUIbg7WWOM1JkoRJFJNnOUJAnCToPCeOE/K8uD61OifLMuIk4vhnuXMEYZOV0+c52LkHOsVXAql8Mq0BhzFg8iJ0q+dJlPBIdY62AidiGs0my4tLaK057A/Y3nmIEAJfCRZ7izx35RWC7hKtZpNmq0Pgh0ipMGiMNuRW4ktoeY4kSdjJJwSNkElqwVranQ7L6xts7x0ibczqQpvO4jL91CG1IY5SRnFMlsRgHSbPyNOUPFB8cPOI773c5eqlZ/nBy7/D2WYLebiPPDrE7D0kEh52/TSbD+7x1JkLNLuLiLAFQQN8D4SERhPC5tcQ0jlIItA5ZAnaGpQrzjV5PA33mqC1pm81W0pw02twNBriu8JJObGWGEeMIE4G3PjZT3Bmm67rs9bWLK62scbj2k8ND45AaEHbc+wnjiE+n//y5/zRf/ifuXn9I974vR/wy48+5mgU4ylFlmd4foAjptttEY0naG0RzpE7i+/5NEKfdqvNqdVVgjwjmox4EKdMsowsSji73MNzjs3dQ1xhfkQI2JSKRNgiKus062OxwxQ0WoFzhmg0ZPtwnyRKcDiU59EIAlpBg3azRcNTqDwvwKYUU4hXIEsAZOE8nBJFJALENFekAydEkW8UgXWO3BUP/vpCIHBYa9C5QQqBHzSwVhfM03790DZiep+Irx9yFkKBm2WydNPK3HG4V9/3EA48T6KdQQiP0BNIm5PnKVmeoi1YnXO0c5886LLUDNDGTPNhFrDWl44cCqgrxTHAnDYMgSXLNbtRzlrgI5xj+qg5Siq0zgFB25f0fIG2jsQIotQy1vUDvrVq1apVq1at+fqNQGUZSpVv3p8E4aqArww4qkBpHmCZByiqAGwGVnq9Hr1e77Ewn9Uyq87Nb3JandS22et50LPaXqXUYw7QecDzSZDySeekvG8Yhsf1aa0fC5H7pPrK+8z+v/rqq/zpn/4pi4uLvP322/zsZz/j6OgI4LGQtmWIU4ao5W1V0DMbkzIorIJL5xy+77OxscHrr7/OuXPnuHXr1mNjIITA87xHAFN5jpRVBuVlAFWdD3Ec88knn7CxscG3vvWtxwBcdbzKgGwehK9CtPK2cn+rmveAQHk+VaHvSWt13oMDZVg7c6g2m016vR6NRgNjDGEYcnBw8Igrswwry+C2OobzHjioQsl53wdVMFkdn3lr8aTvmTJ4L5dXLqP63VE9plpXrVq1atWqVatWrVpVrQtNSzo2M4PXWUEagcgGtKTHUwuKTlPgLQd88JWhEQRMMk1mDHGaEIQBxjl2j4YMEkc2OQJrCPw9et02zVaLOE5JognjJMPHsaQCliS0jGOU5xiKCCAWx0AodtOEPM0YaMcEhRSCS3KH0xE8/fQlljvLXL5yhb2x5eHmXe7e/Ec+fP/vufLKd1k+dxmHJYkjsiQpAKW1RQhVJWk2QhAS4yDPs+MclWmWMYkmWG3xPEWcJGRTUJkkCVmaYq1jNB6TxhFuei2Sa40AgrDJ6sYF9h/cIclThBQYbcmtRk6vrz0paYQhyvMJwgZpltEfjLBHR3ieN70utAVfEg6kxziK+PDDXyCFZWV5lY3zl8A5Gs02YaOJRbJ9MEa1HUb46IMJB55ABz557xl6AQwHQ9758AuUCvBaIdILaDUFk8mEweCI8WjIaBIhTI7OMpzVSIqQuP1+RM8t8aPvv4I3GGLv3MQ9fEiYpLSjhP7aGaLxIdvOka+s0eouQaMNrXYR6rXdBuVBkkIUARJMVrgpkxjyhFBIMgyJMwylRywFtxa73JRdPj7Y49BvkDUMO18c8X2ghSN1jkRA7Az9POPjG7dornn0rEDkjiiNkDJAZ4o40sjMsRgqvhwKjqKEgy+v8drOQzyp2N7v88pzl9nePWCYaqJ4RC6KaD5KSnrdYg5nxiCdYHlxifWVZZZCn2hwxO54zCizaGcJGw3WmiHCWjzPI89zMuuwSDzpuD3q86kQnFlcB6bhXC0gC6DoAJunHOxsoY2h22zQ9DyCRoMgaOI1GviehwREHKPjCKFUASGtO3ZQIsT09QxQTh9wnULDY6A5A5M4pBR4zmEcWCUQUuIpickTrDVYCrBZDsFagEM5hZNF6Fs7rdcZg5ldqwpRgFnhsDbHucIZqk3xUEKSmWnIWoEF/CDEFwIvDDGmeHhhJiklCpCSwnlqXZGHVZSMAgasdeyPMpIFn5ACADs3vcfgpgUg2Ekdk9yRGov+Ne5n1apVq1atWrV+e/UbhX6tah4cqTrN5kHGcp68suOpmn+uXPZMZQBUBiGdToe1tTV6vR6DweCRcucBo+rrMvipgtCq+626f7m8arvLuQ+rLruT2lN9/ySoWB2LmVMuz/Pjp/NO6n95bOc54J577jn+8A//kGeeeYa33nqLd999l93d3cfqKtdRHaMyzCrXXQVRVVBVBXee57G+vs7GxgbD4ZC7d+/OdUfO8oOWw8lCAVWrfTTGPOLqndcPgBs3bnDx4kVeeeWVufC62o5yHfMg8eyY8hgB3wj75sHfeaqOXXm9lcsuO2Kdc+R5Tp7nNBoNgiAgDEMajcZxmVEUEcfxI3O3OgeeBNerbSi3tdq3eWNSHddqffPm+UzzYOO8Y560vn+dsa9Vq1atWrVq1ar1261saRVzuMcoUCx0QzIjQLbxwjZBd4HGgsKFIZ1myFNPP8Vnn32OswYlPIQxSODzzYcYd8B4MsJZSzsIOHv6NBcunWJl7SyXm03Otbp0kojTjZBQKFLlcdQIse0OSZyy++nHPBgcEB4c4IZ7fJ5l7EqPhWYD7WDr3i1arTZnz2yw9+A+Nh3QarY5u36WvcEB1z75Jc/kOYvrFxDKQ+eaJImIo5gsy1BSEgYBcZaT5po8TYiSlDRNSeIEk2fT39KOJMuIooQojtBZhrWONE3J84w4mjAej7G2+K2tpsDDDxqsnrnI/s5d0nhSuEmlRKjicwfEaY5IswJceorFbodE58RxTBpFBJ6i227TbrdwrghNu9DtsbS8ivQChLNYBGmu2d/fQwjJrnRsLfSQCE6vhfjNDsnQMBqnbD24R6gkFuguLZNoy/7OJklc1KWtYzye4KzF5hk6S5kxLKszfu/MOa52lhFffgaHBwSDEb04Zb21QPv8M5zqLnE0GXPpwrN01zag24XuUvG33SlclEdHkOe4IIBxH9KI3CbYlS63iHm/1+Wm76NfvsKXhzts7hsuPX+Bz7/8kvaZVe7tj1j2PMbtBr+MhrwkBDkQOxgKSWRha/sh97wup31FV0gmUcZwbGh6lp4s4O9O33LUVyhr2Ykm/OKdt/lv/qf/kU8+fI/vXn2N6599yscP9ggCn0mcEAYhmdYsd9okaU6gAk6fOcOZs+d5cWOFX7z/U7YGQ8apRnkevYUui80GLk9xFoyYpjWxBqZux7byeLYRomaew6nTcgYOnTWYPMO5jEYQ4EuJEgLlHNIapLFFKkvhkJ5P0GzirCMxugCIU9fh8dXljFcWaBNEsZ+VRS5LY03REgGeEAidk1iLavgIa6afF25kpFeUPy1YUHTAOYMTAjd1W+o8Q+c51jo8P8AaC2J6Pa8USoLJdZF70hQPqhutUUKQF53AC0K6vWWk8hkdbhdRoqZ1SgnO2SI0tBO0lUA4V4zTFLp6UqANjJOMg7TFum9Jc8cgzdmLcvYiS2QcCFn4L23huJyaRmvVqlWrVq1atebqN3JUAsfQaR6EKoPJ2U19pdRjLsJ5MGi2b9nJNINIZefeLFxlGSjOANW5c+d44YUX+Md//EfSNH0M2FQBxkkutapTbV5uy3nQYh7QrPZxtl8VsswDV1XN+6wK/NI0fQxGVferQp8qwFRKcfr0af7kT/6EK1eu8N577/HWW2+xvb39mGPtJAfcPHBZPQ/V/p4EjcpjZIzhl7/8Je+9996xK3L2xGwYhvi+T5ZlQBFSVEpJEATH8LYKUGcgeubqrLYd4PDwkM3NTQ4PD+n1eo+1sQp8q+GJy2FVy2NQdf5VddJ5qq6lk+Z2ed1UgWW5jtl7a+1xqOBZXsryeput5Vn42/KDBuVyT4Kj5baX21WF97PcnDMIOtteXjfVusv9nue+rALH8tjNG4/qtid9XqtWrVq1atWqVavWTFE8JPUEuQzQkyHSC3BSMkxTMmOJcoVzGusEk3hSpOmwlkCAEkUeO6MtmU7BgrAOjGG4vY092OeFjTNcPf803TXFOE0RFpKXXmJ0+iwHgwH7d26z/dEv2b9xnaPDA3KdETpY9yWthQ7dtRVWl5pIFzAZHrD9cJfe6SN6oeOFl57nVqBw4gZ70uP6px9y6bmUlY2n0dpijQbrUAKM1vSHI4JG4WbEatLckKQpWZIULi0lUZ5HkmkGwz6T0QhPSFAKnCPXOWZ6jeYpiRVBAXGYQg/psbZxkYPdLZLxAKUECIUXNHAUefmEKNxq2kqyvAh5KYHFbpvFxWVyrYmTlGYzpNnpIZsdBnGKNQnGaPIsY9g/oBlI1k+fRTuHUD5e0GB3nGP6e1hn0UbT6iwwHA4Z7u6zezTEOEez2aLTXSDJMpzNwVnyLEMhWOy26A/GJEnKDxZ7/H6jhfz8U/zxmKXUsNZq09m4iFheRXQW6DVa/IflVeh2oLNQ5KNsdQo3ZW5Ba7CG/PwqAwEPz3RYunSOH7/3M9Yuv8DPfv4OP/6qQX+SIpMJThjuDQ9I7goaTZ8w9JGs2lCqAAAgAElEQVRKcDCMWTqzzu7hiKZ2LAIRoJXCOdC55oudMboNLpM81ZAkiWVsDJ4NeZg5frmT80MvYDdPueHgo88/4c3xv0cKxVg7XnruElsHR9wYRTgLmTYoCSIIufD0Mywtr9FuhjRDn2eef453f/YusTb4vs+FU2sol6OTBCEEgzQD5REoiTQW6woA5hlLy1MIwZQmTh2KzuKch1OKPE8A8JB4UqKkLLyMYnbvxuKcKFyKQiGUK8rTRV7UR+WOnYzOgXDTMqwu3MbOYSwoIfGmUDOiCI1spvNaiKkD0drjdQDgnMG6AmJardF5jtaFo7LIY+mQQhZOSWvACpAGKWdQ1mKsRWc5kyQvICEOIRS+p9jZvMvCmYsF9HTHHs4CaFqHdg5nDJl1x05PJQTSFX0W4v9l792eJLnuO7/POSczK6uqq6tv09NzBwYzA+JGECQoEqS44FrapWlJD/IlNuzwfR8cWtsP+y/4j/CDHxwboXCEHeGQJa21liiJMikSIiUtCRIkBoO5Yu4z3dPddc/LufjhZNbkJLJBmeQTN7+BQXdVZZ48efJkRZ/61Pf7c2Ta8NHBgscYniw0M+2wohwZ3wfnKp9bLI/SqlWrVq1atWr1cf3coLIK644CfNBch64KhKrtlW3VQUMT8CxVjeusQjFjDKdPn+bzn/88165dY3d395m+1gFG2a+6qttU+1hXU5+rY1L9Vz1WHVCVAKipTmJTP5sgbxPoqvapHnf5Se1KKTl27Bi/9Vu/xcWLF/nggw/4xje+waNHj56BS/XjNUHdo8atPl71vjUByzzPefjwIdevX+fWrVtMp1PW1tbodDqsrq4unX9aa5xzS9BWarFYoJQiSZLlNk2wve4OLP89ePCA9957jzfffJMwDBuBcX0sjoLP9TlZhfDl/nX4WO9vk3uwDkybIF61ndIdGUURYRgCkCTJ0lUphGB1dZUoikiShDRNn4GJnzRXmyBs9fem+6XpXOuRyXVHdVXl4/J+cs47cevHrjo0q+0HQfAxWH2Ug7sFla1atWrVqlWrVq2a5IYDpBB0c0Mym5KkKWnu2M8kh9MFBoNTgr255qP7N3FOIxxEQhMIQSdQREGAdX47h+CVfp9//pWvcVIbVou/T+3hlHh0QGYyPrp3kw+nM+7ef8Ds4BCT5ahQ0o1DOr0+EsFwJWZ75zjhSh8UWCtx6Zi9h3c5OPciyjnWV2JWV/s8JuDs8RPcc3Dj6mVm8znHTp1Ha1+n8cA55os5H929SxSEqKCagiKKONUYhCDNMnSu0UaTZSkLXcRSGosQPj5TSknUichyQZrlYA1SgBMSk1u2tk8yjXscPnmEVILBcA2HZDqdYHWONg5cjslShHCs9FcYrG0wnk1xWcrx4zusrm8hg8CDLOuDQmezKVJJtndOgLPs7j3h2LFjqE6XxSJhPp+RJCmz2YROFOBUh9l0xLHtE4RRjBB+/ZmkGWm6wFnvfJNSEeBY6/eZHIz5bLfHb29scWw6Y7h/wE63z/DkWeT6JmK44WFkEEDUhW7fA8qtLZAKghACAbv7MJtBGJB/7jXupzO+/Z3v8u+f/ByPVcbt69d5Mj5kNDokM3Dl8k9Z7YZ0I8XuoycIm2GMZrLI2Vrr0o0CWOmwezDHCIETYAJwFsBhU8vuOGWsLKNVxXZXY3O4v7BcGVk2rWInFITC13RMFiPe/eu/4rP/+B9z5fK7fO6zX+TDa9e59WRMkhtObJ3itddeZzgckMxG5NmCQECgBCurQ+IoYtDrMow7yNzXksydZZQaxpMFGxtbhCInkL6O5HqnwwtZxqODQ46vbhWkTOCEd3ziHMI5dJaDU949iENSxJyWOM4JXx5SiMLh6ME3QoDzjmCW/5eFy1LgM2YpHJdF7Vbr0M6vGwMHc2OYOYHNMuazKbJMc3LWj7MUlG5KrTUO66NXXRGtaj2UpVh7Gmtx1t83xjmENj7w1vrj+1IuhkWae5AqACGJpGScJghj0cUXAyicn0qKIubWn44fuuJzGJ9CixMSW3yU93iS4oSHl8Z5Ymwr+yKKz3zK98Nf3ltrq1atWrVq1epXTL80UFkFbqXqYKL8eRSAqwKcquOs7maqw6Q6sCn37XQ6XLhwgc997nO88847jMfjRrhTbbv+uMmZ9rP6fpTj7SiY1QQxhXjqKC2BTB0sNvWn7lg7ql9VIFq2DxAEAVEUobUmz3O2t7f5+te/zltvvcWVK1f4xje+we3bt9FafyKcqbsp6/OifL4eAVv9/SjAWT4ejUb85V/+JSsrK3zxi1/k9OnTnDhxgn6/z5MnT7hy5Qrj8Zg333xz2eb29jYAe3t7S9D5/vvvF/FCfgzqtSLr101KyZMnT7h27Rqf+cxn6HQ6HwOQn+TCK1+vXt/6udVBZFP9yqY51VQXtAlqVvtpjGE+n7O/v0+apsRxzMrKCtZakiRhNpuRpimj0YjhcEiv11vC4uo91+SYbAL49blZhdrVmN5yrKvvL/X26zVxj7qn6l92KMfqKOhYfz+p97+p3VatWrVq1apVq1at6jJIstw7o0TUIc8WdHt9bBgwyyyxsVgZsHCSZJGgjWMynbO+uknqQDjLyfVVVBCgpCJC8Bta8rVU0tnZQicZKZADqYuYbq2y1hGYP/w/uXXwhNBBLAWZhEEUsLm2zmBtnd7aBjoMSTDsLRY8Hh/wZDJlf3eXsLfGseMn6cYRp7fXeHh/ldn+AWu9GOs2uX7tKslszrGzz5NnkKRzwlkHozWhCpChRCoJtoA8DsIoQgYBxliMc2jjazUCaGvJsxzwIEZYgwoCAgtRGGK0wOgcIUGogEWyYLA6pD9YZffhAw4PDul0u/S6PbTWLJI5zmikgri7goj6PHq8ixKG9fUtxolm+vARWufLOpi51pgsYXNzk4Pcks4mrG1ucvvhHtY+8u64sqRKntLpbZOkKSoI6cRdcl3EchqNznIEljw3SBynj28wnc4YjWe8FoT8l5vHOL1IOR4q1o+fItg6jljbgt6qrz+5MoSVAXQ6vg5l1ClyMwWMJjDah8m4oD4G/vwv+SDWvP+jH/DVt87z4vMD/tX//m3SyRMPuIxl9+F95PoK/X6XhbX0Akd/bYjY3WeAZfRoRDcMMUIwByIhMQgkEGjNSpqirGOh4eouXAEyLUisjx59IQ6ZGMctBIEUrCjNlR//LW/+06/jrCUNe7zw3PNceTRmLRrytd/+D4mimMnBI7L5lCiMEM4hhCOKY4a9mOk8QTiLcZJxknAwS5BBSBCGrPZiIiuQ3S5vf/lL6Ic3WHnwhPXDOd6755YAzWfF5t5lmGcI4aNMRQHnABAGUAjn8B5CAAnWFQCzWF/yFLb5SFnngaIrH3sXoXXFPHfFOtlaUmNJACkFOtdIbQGHMXlhABVI4R2h1pjCDepjbaUUT49rDc6Bo4CMfkOckDgEzmqc/w4BOi/muBBIB6iAsBNz4vQ5gihirPPlGXkGKjDGLuNyRTHtHIKFEyzKuNuS0TqHMa4IhfXb+/VxMax4R6p3YUoPdVu1atWqVatWrRr0C9eoPMpJWN2mfO2TnFFVeHCUM6sKBerwsxoPW/5ujGF1dZVf+7VfY39/n5/85CfM5/OP9bne1/q5VQFWtY5fE0Ct7l+HQlW42gSumsatHJ/qOFXrFjZBrqPgZdl2CYKUUsvxWl9f59ixY0gp2d/fZzQa4Zzj+PHjfPrTn+bOnTt8+9vf5urVqx+r91hv/6jxqZ9vE9xpglhN+5Wg7Pbt27z66qu89NJLnD9/nhMnTnDt2jVu3brF7du3cc4xnU6Xzts4jnn++ec5ODhga2sLpRSPHj1augmr87OMOK1GjZb9WSwW7O/vPwPomsBmCbqOgtTl3CqPU339KMdeOQfr/Srvp/L61EF/vY/lvlprZrMZe3t7S6fpcDgkiiJGoxGz2YzxeMzh4SFbW1tsbm4Sx/FyTJtAbv1c6/dU2Y8ySrYKBpvu8/r+1fOtt/8Phfr1dprcs6XqMb3169L0ntWqVatWrVq1atWqlQxC0ukBgYR+bwAIpIW4H5MiSY3DKIl2qnBxSaZWMZYrZJkB51gfDggCiRIBoYWzI033YIK48gP05IDVN48jXl7h8Xt3effHjjdWe5wWOa/GMaPZHKxjlme8PVxDEbCfZWjnsEHASthlszfkufVtnsymHExHiN072M3jxJunWHEhp0+f5UcPHqDTBb2gw87WMe7du4POEnbOvIBVAZk2CKOZW41AIMMAFUaoICTPNWIukIFCigCkIskSnNZ+G6kw1kMb5yxhEKJUiLEQxTFZUc5ESoEKQoSUJFlCICWnzp7j8PCQ2WSEznOCIKTXWwETARanOkxnc0IB/eEWs8yi9ZSnmAmM0eg8YzgcMkkt88kBw+GQeWbQeU7hK0MIiZIBUS8g7q2AWKDzjPl8DkCeZYShQnU6TCZj0Bknj22wc3yDW9dusT6Z8d+srvKKdWxvbhKtbcBgDbGyBlvHYf0YdFcgiCDuQS+GQEKS+VqUaQKjA5jsw2LmAWaaEj65z6P0CVlH0hUjhnGKnu8jreHE8U10nrM/mtNTigHQ0RnHjaA73uPl0YyB0cxTzSGWUQEqs0CgrGPFCTatped8HGgZp6odPh5UQF8KzivFB9axJyV9ZVmRhnS6y/v/9u+48MqrvP/+T3n51dc5d/MO93UPJQOyNMMaS5osCAJJWHyR99atG2RaszAG5RzTacI8zXBALCQnttYYSMeMkNVBn52zz9FZUew7Rax3l/gQ51heZFzhtjUeBhYeSpbVGYt1HRZhC+AoAOGqpSN5JlJW2OKxLGJN8fUknfOQ0Fl04YB0xjG3hqSAeM5ZnJTezetEJaHIedeidRQr0OXxlp9VFH0QrlyLFp8LKMCawmkJxlgs/jp5WIi/B7GMJlM2uitF1LKnj0IIgkB54y4OKQSZ0RjnoTVOgPSuSbN0Trri3vAjKYUf1xJWClH/rOsXfENt1apVq1atWv3K6ucGlSVgaHqu/EOkCnng49GWTeDkKNcX8Aw8agJAVWhQggelFOfOneOtt95iNptx5coVtNbP9Ke671Gqg49P2r7s/896rhyjJiBVB1PVdspzq4/tUW6+cr+6iw6g2+2ys7PDhQsXWFtb4+7du+zt7eGcIwxDrLVcvXqVd999l/fee4/FYvGxcWlyvdXhZX3s6rUyq67B+jlUr2sdHpVRpb1ej06ng1KKd999l29+85scHh6yvr7O7du3ee655wiCgL29PVZWVpb1Knu9HoPB4BnYVx6rOt+awHyTq64c2+q5V5171f6X16B+H1XbrILq6v51MN4EiMv9qud2FKQ3xpAkCUmSIKWk2+0uIWb5zWEpJcPh8Jnjle009aEKYauAvXrs8hyrr5V9ro9xfWzqx6/CxJ81/+t9Lo9bvVb163UUvGy6fq1atWrVqlWrVq1aAUxGI0yaEUQBaZJgs4xASVQoSIViMstJxQBNBEA3EPR7XWbTKc4YlCjoiBOoQBI7w44B4SSCgChQiK9uwm+eRV5+zHR3gphb9OGU1TRn7CxTYOGgawRvX3iRaZbycDzizuGIvZUVstUhvcGAU9vbHD95ghOb23ywN+VbP/kp6XwM+YKXX7pAFAYEQch6N+Tdy9e488MfQvo+/ZOnMVGXzFkPPqzBCoEKAqK4j5USKX1dPkcGxd/7GlGsa339P2N8ZCX4enrG+LhLCURR9PTvdiHpRB1mszHjyZRur0cnjhkf7qN1ijGaMAoRMkJnORLDxuYxEidxJkXKoDiOW8Zc9uOYuD9kdHhIFAbE/SHzxQIpFbI4F6kCwjAgDEOiqEMnDDHGskgSer0uq4NVDkcjxuMDdLZga3UFqeDBtVu8dP8h/3mvz8uDVVa2dhD9PiLqQBzDYAib27B9ArTxQMgaODj0cHKxgGQBeQaHezA9hNkYkhlkGUGWcVolvLOw3L7zmMs/usorJ9d5dO0RcaroTuf0pprhKCXKNF2jWXEQCr/+ybEkSnLgYF84RoAZRGST1Nd+BPqrK4xGU3BgsNiijqMCTgUBEYK/MZpUOF4aCFYcpFZz/d3v8vpbXyKdLRCrWzx/aoeD+1MQYKzBCcFiMUcpQRgoFvM5f3LtOswX6CTjMDc4Z5FScGzQYz2OSPKUWdBl+9wpkukBVz+4zG9++Qvs3rvLey7l150tiJirOAMdJs98VKr08a6uIGmlyc+V5kTh41Y9zK6sLZeQ0uLKyNflC+U2Yum+NM6icQgUuJyptRgRIKVAqtCvPzFIW6xhpVhCVREESOtASFQUYXRezFlTRKoWONaBtcUX2vFRsNZYrPEQ2VmHth4gCucQMsTmC54c7LG6sYXWmY9eLmBtFEUEJmOWGxCSHIVQIMual8WxykhXJbxjWkj/OCjiaykg9lLFEEnRrp1btWrVqlWrVs36hRyVJYyogokmuFRVFcAAH4MLdchVBw7V49UfNwEGay1KKd544w3m8zlZlnHr1i3yPH8GUjY5tj4JTv1DHZFN51B9rgkcVR/XgRTwDHg6yq13VH+qx42iiO3tbd544w2OHz/ORx99xOXLl5nP50gpieOYu3fv8vu///vkeU6e5594Xk2Aqd6f8tpX4WwdTh819lWgFAQBnU5ned2VUsvnSmhVAunXXnuN3/3d36XX63H58mWuXLlCt9v9GHiqj2H5WukcLOeSc46NjQ3OnDlDEATPgMR6Hcr6fK2PV308m4Bz1UFbdxBWx7rqUi4fN21Tb1sI7zTd2NhgsVgQRRFbW1vEcUyn02E0GpHnOaurq2xvbzMYDFBKLdst26jXwayOXwk9m2BiHeQ2uSR/FjxsqiXbdH2bgG8JvJves6r3XH08nfO1T4MgWI5Hq1atWrVq1apVq1ZV5XlGLwo4trnFwXQByqLTBStxh87GcdzBY0QQEyqJkoILx7c49/zzCKk8dNAe5GVZjgI2AktfT3DCr6lkFMHm87D9CmrwN2jpENZhBdxTgie9VdLpHCUgTVLU4RPW+wPWzp7nYidknM7Ydxa3vsZw5ySrx45jtWW42mV4ep0PppLcrRA4h57PGc1mJLMFr53c4fjDE+zfvA7TCc+fOMXzw3UeWcvlyYSJ80DFhYe4IMJEXWwU4aTCFjX/hFQEIsA5gTXGZ0kK/7tbpp1AEAbgBBaHtWU6UEAc98jSBVmmETjW1rfI8oT5bI4xDomHP0EYIuMuXeEThfI8x2iNc9rXI3Q5w40tdBGbuTpcI4g6RNogoqefNWhrCJSk2+miwojR6AApBRubxxBCcni4z+HBE2yeEkcKm2sWN27zT+cL/tn6Oqd2TqAGawilIIp9Hcoggt4AhIL5AnQOkwmMRx5OWuefyxaQJTAdezflfAbpAmZTsJrXT2xydzLD/i//hhcfPOQL2tGZJYTGgNM4K0mtYyYUiXRo68jx88QgQUAfQeRgQ0nMoMPjSc4h3kmZ5xopBN69591yZXzqi4HitrX8xFo6oeDSuiGdO+7PYPzoI65efp/zn3qZD6/f4NKrr3Fn/AOsdSgpCaMIbTST8ZTJZEKmjY9bdYbVbkRm5qgg4uSgh7SWztY59h7cJlYRGztnuXd9xOTwCWMN69vb3N3dJdNPYRnOLoNNrc6xxZySQhZxpAKKEGLh8NGvzi1hoOPpF7Gt85GywokKhCvWjqXt0nmHo3Ue5lopfbs45g4IFHGng1QB1uRLOOqM8YVS8XUwnbMgAlbOvMbgzHmuPX7IdqiwuzeZP76DcwZrPUo12kNFZ70D21rvpPRw0mKsRkoHVhCGIZ1Ol2Obx3w9SmOK70E4QNIJQ/I8w2iDUt4rmmuDtk9hrGeNxdpZQCcMSo/p01qUooCuwoGTiEB6QCvadXOrVq1atWrVqlk/N6iMouhjLsP6h/VNzqaj3HPV3+sAo3R8BUHwTKzjJ8Vz1p1SQgjefPNNgiDgz/7sz7hz587SJdYEA6sgrfr4KAjZBAubzrt+jtVxqkKUOpyq9qMKm6p1JpvcXvU+lO3Ecczp06e5ePEii8WCd955h7t37zKbzZbH88XXNWmafgww18eqBIXGmI/VIK32/Sho1wSHqmNWfSylZDAYsLa2xmKxWPZLa02WZcs6m0oput0u58+fZ2NjgzAMieOY+/fvs7OzQ7fbPXKcqn0pncIlcJNS8sILL/DFL36RMAw/8XzrDtPqPK1C5upcr7ZRn0d1R3K5TQlQm+ouGmM+1l45X4wxhGHIsWPHWFtbQ2uNUoo4jgnDkM3NTZIkwTlHFEXLyFfwjtAsy5bO5epcbOpzHWhWgXW1v1WYWe1rdZtyu09yM9YdnEfB1LIv1Ujk+ntUvZZrOQ/Ka980j1q1atWqVatWrVq10jonjHtMZnO2VvosdAdpu/TiHrbTwSiQNicQMIxCAmX56OZ1AinpdmPiTocgiHAOgjCk5yDWDqEEIlRAB8YL3PQxxlhkt49ezMicI7x4ntNv/SOu/uG/Jh7tc7zbRTgJ2iIWC4JYsn7mJOvPn4PPvYXdm5LdvoO4fo01DF9cW+eluM9iPKK3scJtK/njP/i/6Fy4xHrc442d4wQbQ0SWc7oT8XzQwwQhPzGGy4f7PM5zZsxJhGARBkzCDtMgYi4VSRgg4z6y1/dARXroghD4GoKqoB4Ci3eJASipUIEg1xlCSuLuCsYYFrMp88WcMApYW98gSxOyNPWxnipiPJ4QhhFBEBLHXVQgUUp6mGUdQdQhnUyRKsQhyQunmc41nTBCSO9KS5KU+SIhCEO6cQ+EYG/3MfPFnDxdoJyj2wkJnWH9/gP+W6X4jdNn6G9tI7p9CCNPyjqxh5NRD4yFx49B7sFsBvMxLCaQZp4K6RR05h8nc0gTXOrBpUtTrDWcurngvzIO/XAfjSM3jtwYtHNoIcicJne+biNSYoTFONCAtg6N8P8E0AtJ5xlZATKtg2SRIpxFFrUJpQMRhgytZVtJ/iDNORTw4opgp2dJFewnjseLjL///vf4r3/vv+fGh5eJz3+Gs8e36PU6ZGnKkwcPGR3ss0gStNZPP8sBEhFwanONjhCMZguS3PDi5g798SEu7BB1h8RRzHSWcPknP+Uzly7y6O49ZnMPVEsJynV9maylKCyBlJDS4WGdBaRzlXqLDoss9ilcmgJKoFjllFZInNBYV/BlZ7CumMsOZtYhlWJr+xgb21sEysNFo7UHm0aDK2AwDmsFK9unmMmQu07R3TrHqa0d3PSAPF1gTI61DpTwtV2ROGH9wZ3DOoU2miTTZc9RoXcmrwyGYA1pnnl4W7gis8WcPHdc6HcZpxn3tMFAEY9bjmd5n3pQ7Zyvu+m/TOAd0BJRVK2UhGFAECii7gq9Eyd/2W+xrVq1atWqVatfEf3coBKedTNW4x3haFdh9fUqmDsq/rJ8vcmpWf9X3a8KNMu2V1ZWeOONN3DO8ed//ufcvn2bPM+fAUl1sHGU466qJvffUdvUt6tDp3r9yfoYVMe4CmLLfZugZR0Ex3FMr9cjyzKuXr3KbDbj8PBwGftZAqTSAVc6GKvAtHoNynZLSFmPzyz72LRvfYyrzzWNQXmeJaDM85wPP/yQ8XjM6uoq/X6fGzduYK0ljmOEELz77rvcuXOHJEnY3d3l5s2bKKWWUcD7+/tL2FftT911V87T1157ja985Svs7OwATyNc69e7ac4fdR2bIOVRtUCbtq1e+3o/mq5X2X6apoRhyGAwIAievh00OTPrkLCMhW1yedYhXxVSVyFtHX7X501T/6vjUO9jk4O16f6sA8vq+TXFQZdtlMerQvMS+LZq1apVq1atWrVqVdfpc+fZ33tMOhkxTxOUlFgH+4cHvKC2mYgIZxUBFm0y9HzCK599A02HRZKwPx5z8PgxJ1c7nL50ieGDCV0psUYjNrdwOoe7GfzpFbL7lkAq0iQHKwhmc9yHHyLmM4R1REEInS4MVqHfhUEXcWIbd+FTZJlCXr5MZ+8BYnEAm0PE1grr/Zh1uQk6IwoF/+Nv/ybdCxcJwggxHSHyDBYpzgKZxu6P+Pz2Gq/tjVhMpiR5TqZzhBTkFnad45Y1XE8XXE/m7E5GZL0eQW+FIOpg8aDGx1gW6TbWu8MQAmeLSEsEUkikkoRhyPZKxN5kzGS6IEumhEFAf2UFbTRWW3KtyfMUrY3HJ4JlxKdSiiDPsc4RRh3mSYrKfBytdQajM0QRWbnSHyCDAGthkWboPGc6GaGzhEgKwlAhJmNen874FxtbvHR8BzVYRcR9D8ZUACrycBLgcB+mU/9YZ941mWeQJ5ClYAxoDcbi8hx0htMGl2foPCXPfb1RQ4Z2kAswTqCVREtBbh3aWTIgR5AKQSYgt5IcR+4sBocRrqg7KbC9kPn+jEwIXy9RgLYWBSAkwlqMc0hjeDEKGBvLuziUgFe3LSfXYH8Mgwju6YDF/JCDgzEvvPgqu4cTLrz6aX564wbXP/yAx7sPyXNNEEaEkY8/ds6SJhlZmpHMNc4aFLDINR/dvkm/12eRW6RUdIMOu6MDnuw+JHvtVYYbG9zRByycoy+WJt3lms2JACXw8a/FHPASuAqOc0UVS/+Sjzp1oljzuqLhAlqKEmw6H13srMM471otnY25tUwRoCRx3CEqytbkyayoP6mQQQlVS5Dq67xa52tLWgudKGRtawujM6zRHlQ6W8S/Fmtmq30NSaOZKsdKJ0A6XzczCGOm+48ZJZadzTWM1pS5rFJAL5QkDtJQMU/9+UmeXTNLUY6RH7vcGJQInq6vCzOllAolBWEnZmtnB7U6ZDwa//LeXFu1atWqVatWv1L6uUFlU+Rq/UP8OoRrer4KHergBp4FeVVYUH2udIw1AYwqbDDGMBgM+OxnP0uapnzzm9/kzp07H4MbTQ6uuuqAo+n3oyBn/ZzqkLK6bxOgbepLE4SptlF1vJWAb29vj8VisYSRpWOwCnqrLrjqsarQsNHx+uQAACAASURBVDq+TTVI65CyDu6axq0+T6rbOueYz+ckSYIQgtlsxv379wnDcHmOpcsvSRK+973vobVmMpmQJAlxHHPmzBnu37/P1atXSdP0mVqb5blU+1OCz09/+tO8/fbbXLx48ZmxrgO2Omz9WdGiTUC6CaQdNU+aYl6b+lF9zlpLmqb0+/1lfGn9vilhXB1SlnOi7lSsf+GgqS9VWNl0rKa+1u/DJrhbHYumLw1Uv7hQXt+m61Y/h6baqZ/0ZYBWrVq1atWqVatWrUptrg3Ye/yAnrL0uyGUEMPkaONIVIjTGmlyUm2Za8dUw0Jn7O4+YTo+JF0kbJzdJO4EBGs9rugFjx7fYPPcWeT2Cbo3LPryjCvyOehPmT18hAOi2/eY3ntErA39QDEcrsLKCvQjOLYKF1+AtZNw54Dgxt8gwwmc20BE65Bb2L8Ht5+AUuAUvTSFfgfu34ascPc5C7nx3MYaVCBQXUXnWMiwt4pZaLIkY7qYM12knBSS887xH6iAQyH4sTb8zeiA64sZyXADF8U4IdBFTTxV1LdUYeAxknRobQikxCdphiAsWioyI4rIXEOaZSRZipISpQI6cewBigVtLMYZnLEgBMZosiz1EBSHNRYtcoSQyEARqMD/LiRJmqKKda+1lsV8Rp4uCARgLN3DA/4TJfnPzr3A5sYWIu5B1AUpwWpfgzJPfEeMgTwHZzyhSuY+5nUZ95ricg1W40zpvCuiWHWONobc5B6IKYkRAVZKNGCE8NuV/xBkBYzMKJyUhYNSC4HB+eciicGxyB3G++UQsKxj6CgjUGGA4JxSfEsbHiJBOqaZvxbrK5pTaxJ38nm++k/+CS5POHPpNf7uu3/FnfET7t66yu7eI+/8M4bcpYDAFfMowDJP5gjn6IYBIu4x7AUcP34KzJz9O/fIkxn24UO6HUWS5dy8cYPz5y9y4+DvuJnnvBpEFLmmOONhHsuCiuUarnBVihJSPo04LVd70hXrwOKJZaKpc0tHYbm1c/4cbDG+VkiUc8yNIcMhZUBvsEoQhFid+34ZjXOWsj5lWS/SSf9Zl9EJwjoCk5PN52TZAlOU5fFRyP6AZV1N68oWwFlDLywcl8Ino4VS0e92sNagK597SCmIhCNSlpXIMMUW7km/ryjH6KmRFD/tHRqHkkt+i1CS1ZUB2liOv/Aia8e3uPXej8lk9Au+o7Zq1apVq1atflX1c4PKOhwrVYeVTQCxClrK7evgoNp2k2OrbKuMXqzHo9bhaBVqDgYDvvSlL5EkCd/97ne5d+/eM7CzDkDqQLHev/8/Y9QEW8rnhRAMBgMfXbNYfMxRB831/Kq/188hCALCMFz+LGtNZlnWCGCqEKs6bmW9x/p41EFRE7ypQ8ijoGd9jJrGr3ruZTthGC7hZXWeSSmZz+fcv38f5xyz2YzFYsHq6irj8Xg5d5IkWbZdxn6W86GEnnEc86lPfYqvf/3rXLhwASHEMpqm2u/qdSgXr9XandVt6+CyOvb1OVyPNq4CwqPmU/1nUx+aomSrbde/kFDdtuq+PWoO1a9b9fFRMcJ1Z2j1vaL+e93tWX2+CbpWj31Ujdp6vdHqvtXrXIe1rVq1atWqVatWrVrVZQ4fc3K9z0D0iHorvladtqhQsTCCxIV0dEIQ+i8NLtKcxWJO5gIybci0QRuHyTWTvUek/TV+sGHZmT3h0oHi9HxMr9djHnc4PHkCtz/io+sfEiCRzkOSQMD5bszJkycQqz04tQUXX4KDBG79PfRz5LZEGAGP7uEyAy5AzHNfD1EKIACjPYFJC+CWzovo1KK+pBKgNCQ5Ig0gdwTWodb7dEPY6ndJU83+fMGD6RirNZ9XIV8JA67mGX/1+AE/DEJGK6vYTowDMqNRUmGt8bXxhPJQR3jHm8N34WCaIKQi7HQ8fCTHWO2dlDqHVBTrvdBTF0BIiS0AkaNcZwukCjy7cmCtB6Og/TGdgCzDFvDQ6pxQOESScnE25X9Y2+DLZ84R9gcIFYIMwTjIU3Daj6HRYK0fQ535x1rj8syPZfG7tRptPEwy1np4CxhnC/ejh4lGCeh00TJAW40u1nHaGjS2gJK+JqXGkTlXPBa+HQGZ9fDS9QOSRUaOwAmBUAV4c8bDt6IOogIudgKmxvB957Chdwr/1QPFe/uOVzYjdtbWefEzX+F+2mGoLe/96Z9w9cP3wWYMeh3iTuxTnIwhy32MqSk+dzi5MeT1cyd59ew6H1y+xoPuOXZOnSHqrbJ77zpZNidJE1RvleHmGqPJE/Yf3udTl96muzbkyv6YS0R4LGZ9PUhrUDgfX4uEEudJv41D+uuLr0Hp54MHl37KiKccs4SepbtSKA/vrHcDG2fIrSlqNTpGxqIRBEp51y14R6+ofC5QRKU6Z4r5rbDW0Y86vLK6wUBKzDzBWbdEqRKHKdyUlJ/HCN9J7+7088YWwFFFEd21LbpCsZg8wVizrOGppCDAEnYk6x24LxxSCYqA1+X5Vj7xKf7v0MYQBGExjv5ZFQT0B31WBiu4xZyVTgftji7d0qpVq1atWrX6d1s/N6g8Ku6xDlKqH/RXQUbZRnWbsvZdFaCUqu5XwqNy/zKys/p6uU/ZXgmeStdfHMe8/fbbAHzrW9/i0aNHz9TyawIrR0Gz6vmVv9ePX4d7VSBVnncURRw7dmwJKReLxbKdusuw/rP+r4Qtg8GAlZWVJYDL83wJ2IwxTCaTZa3OEt7UY0Q/KZa3eo7VMTgKWDUB4Or+R0HL+jUo9w3DkDNnzhAEATdu3HjG1VnuW0balkrTlPv373PixAkuXLjAtWvXEEIsazGW41COUxRFXLp0id/5nd/h/Pnzy9er4Kze5/q/EmpVIWZ9npSqws2m+pJ1IF2+VgfAVQdhEzSsAlQhxBL41q999T6tu2Pz4puc9WtVv2blcepjVo5x0zmWj+tAsO64LFXdp/pcfW5W92uC4iWUr59H9Tx/ni8utGrVqlWrVq1atfp3T3m6oBPGaCnJjWOW5uyN53RtxvnzZ4lUQD+ZE0UBmTWME8P+4YjEBhyMp0ynC/RiTjA7ZHsIh+M5ezbljs34/uObdBB0Ox2slXTjHiura0RnTyAORkS7uzidkQk43u0SrPXg7DE4eR4uXwf7GNasxw0PNSyEh2Y72zDokc0zxo9ieocjupMnPuZVhZDlPsI0zX0sqTPedhY7DzFTBbn2bkHrQQYEiCylqwQnV/vsxBGjxYI74zGj0YQ1FfDPo5B7VvNvdmf8XRhx0B9gVIgNFEYpRGVtYqxBVtYGpnAcOmdxooBswkNHW34J1VmcyQGJzjN8zzzMEQKEVCgVeBBqfHQlUDgtASd8LT5rwWkCJbDCEozHfN04fu/kWU6trUMQIVCA9GNgFn4fk3tgaW0BJzPvnJQ+NpM8xWYpWW7I8tTXmLQGU2AiKwRGSg8npcAIiXYWowKsUh5o5tpDRYePdHWgnfWQ0rmiHqV3WWocWbFNDmgpcLFksZuRCYEV3i1njPVOSgTOWiSO1UDxopR8WxvuK+VjeAUYbdDRKpd+7S2+/PqLvPP+Hd796X16vVvMZhMyneGMJrYRm+tDHj/ewxmL1pYwkMhA8tXPvc5vvHGBzdUus4PHPLh2nUUQEYQdoij2UatZQppp+mefR2RzxDxBG8P1mx9x+rnz3B69y50s5YIKPcDT+TI22FNof3/6ZZwFJymptxPOs0tXRsCCEAoncn+dnI+BLbcXsITnTnhAaIwhtw4hA6w27BsPel2oiMLAzzeKGqkV9IewyKKmpSt+RkJyvNNBW0OeL8AZhChYqVAo6XDFNcdS1HotmpOKLLdY57AOAhXw+N5HdDZ2UDrzX44vDt8JJSsBHmjind9K+Oha6wSm4LLL0FcnfH1L4bDGoZVBCQ9zrTFMFhkqjHl4/RpOCJRUONGWTGnVqlWrVq1aNevnBpVa60ZHVBUiVN1NJWAoQVIJF0soUq0pCc86Iavt1uFjU53L6nb1mpnl82EYsrq6yhe/+EWklPzFX/wFu7u7R8Y81tut6mcBzKaf9eeUUmituX//PtZasix7Zrs6fG06Rh2cNIFLYAktsyxbRr5Wj9PkaKu3XX+9Om7V69AEH+uQrbpttZ2mfarbKqXY2NjgC1/4Akop7t69u4S75TkYY5Z1SMv9sizj9u3bvPzyy7z44ousr68DcOXKFXZ3d+l0OvT7fQ4PD0nTlEuXLvG1r32NixcvEkUReZ5/DIY2nXP9mpfnVo5/HVyXULC6fxUkNsWrNl2Lpnun+lxTHdM6/KtCzjoMrffxHwIRq/1ucnE29aMOHst96mNdHYvSJVs/l6qLsslJWZ93TS7L6vtY2ZfqvdOqVatWrVq1atWqVV13DucEgSazgiTPSdIMYw3rocTmGUIFTEWE7EDciejIgMksp9uP2Tm2jdvcRDnLcE2xIlMcGuEyplmGNZZUwMHCgBNcOrbKZ/7Rr/M4DfjWn/4Jd3Z36UrJr0cxl3aOwZkTuJVjiHf/HvopBAb2cg/OcgGJhtV9EO+zmA/5s0dn+OFDS/5gj39mFry+0sHJMlXGgFTebalB5BkiiBAi9rUVoxAy7estZql3YlpASkSgUMBGHLEWbDBNEz4aT/jpbMaKVPwXYcBXrOGPs5QfRh2S3gBblDKRga/f56zBWRDKE5tc51hT1JW0tjDLSZQUCCE9jMSvxbIsw7Mc5yM8RZFtufw7XwLFesoVEMrh64taDdYQKolZzIgOx/zL4Sa/u7VDL4yKCFzhAWWWeppkvWMSnS/dlE77epPgcKqIA9aW1MAiSz2UsgZjjY9gFdIPoQMtPZg0gLY5zoEtomCttR7IClG4L0tAaQtoWcS+lj/x22nARpJcQ2IcBu82dc7XWUQIhIUOfn30chQyt5a/FaCLuN2OCvjCZ1/kt7/ya5zYGjKezbB6QTId0YtDOnFMmnTIjGY2nxE4R7JISNKMuBNgjAUc954cMBgMCJRfE0ZKoJTl8a0rDE9dIhAgtGa+v4sYHzAYDhhOZxgneXDrGmfe+hKuE/HjZM5ZFRJaD9KgdFI6DwpFGfkqvTGSku+58j9KT2U5H2wxT5YQUxTYzhVbF+tjYy3aWXCOzBhGzmGFQIYBURj6+0DqMkzXv1kUTk9rvGsV0fGvGuubxyGMXvbJ18a0IAI/f83TFCycQyjfv7SoyyqQxFFIPl14J2YBb8vz7oaCWDoS60hzgS5cpxaBFK487eUo+T4WsNc5cq2RYVhs50iTOclwg04cEQQhKl5B9Qa/pHfWVq1atWrVqtWvmn4pNSqrTqujavbB0WCghJfwcfdePVqxHn1af9wEAusQpQo0tra2lrDynXfe4aOPPloCvDogOcpBWT+36rF/FuQsYVp5LmmaLl+rg5q6o7D6swnkAsuY13LbqqtPCMH6+jqz2Yz5fE6e588AqDoc/CQ1wdqjxq96/Grf64Cp6bpWj6OU4ty5c1y8eJHxeNx4DerjAn4OjUYj3nvvPYbDIY8ePUIIwWg0IkkS+v0+J06cIMsy8jzn5MmTvPzyy8Rx3DhGVahYzq3qOVTvEeAZmNZ0/aogsP57VfVr0hSHWlf5Wt052wSU6+NYh3zV/ev3WJO7sQlGV6FoE7isPt90PcuxDILgmflWvTblc9Vzrd4/RwHWpi8DVMe6HMfWTdmqVatWrVq1atXqKO2O5yCSZd046zwwywVIHHMNiVFoJ3hxZ5MvfOEtwu6AKFRoY5lPx1i9IHSGe3t3WUwmhM6BsyjhEIFEyYBICGJpGeL4w/c+5Nqdm0jpQAV8x1kuKcm5oE/n6o+gn0PifJ3JrHT3WegmcHof18u5evgCP747YSuG97rwf1x9zNqZTe6ePUEWhBAo1rdO0DtxkTsfXmd08yono5xhrhnIhNXFgm6WEqQZwrqidp0FGfisUbyDTQoYhAGvrA85l8ZcnU748XzKhgz476KIvzeaf51n3Ip7ZFGEyMsvfXqotYzjpGSNFonAMy/nQZTwTrdAKZQK0XmGkKqIfS3QlStdYhYpFc6Kp245HEoVkZzG4LIE5jO6izmfivv89n/0n9L74Y8RkwPPcKT0gFZ71ybW+HqTDshTnC5cjzi0kORZRqa1rx9pDKnRWCnJpcCiiohXhxESp0KM8FGcLghxIsQ6S55lnokKhylOvaxnaQAjPLS0RZ1KLfCA0jly4TBSIFY7zEcLUoSvSek8W3aUayNDX8BAKc4JyV9ay00pscVa6dULZwlw/Ks/+jMe7Y+YJhlGKD7z+S8R94eAYD4bMx4lJIspW2urbAy6bJ7Y5K1XXuAP/up7vHzxAj/4yYf86MY93rp02l87QAYxK/0h/ZU+80c5Vmtmo31WpQSj6R4eMHsyYuXkOh/duc/6iVN8uPceD0TMWbyb1gqBkAIpBBIPsL1B0BXxpiyTXJ3088IDWn3EWrUMRC1ygl2ZKOVLvOoCJE61Zuo8v1ZRh0DJoralxYnSmOl8bGx5jAKeOyF8tGsBSoXTOOxyzEGBq3wGJzykLrqHsI7MWO+2lJKo02Xj1HOIqMfB6BG5c9hi80BKtLU4IcmNJacAtSWQ9B1bgtsiv/bps9Y7cGUxMtYYst4apz73WU4dO0aSaUa6/YJvq1atWrVq1apZv1D0KzwLoeqwox75WXU2lYChfK1ssw7Gqq9VQUL99fK5MiqzKa60BChVR5tzjs3NTd566y3CMOSdd97h1q1bzOfzI2Mjy+NV263//kngp2mfqluu6oI8amyaxr0Oj6ttV/cr9w3DkE6nQxiGRFFEkiQkSbKMvqxGftZdeEf1pencq67ATwKUnzTO1TbL/gRBwPPPP0+n0+HJkydLQHjUOFfbM8Zw5coVnHOkafrMfNFak2UZURQRBAGTyYS9vT263e4z51FeryYXX73vVdBeH69qe1X3XtNYNjkQ6+6/evv17UonYH28qm3UoWf9Ojed21HnU22/CRJW2yn71tSXEmoeBbCb5mH1tU+qJ3nUvGwC9dW5Uq+t26pVq1atWrVq1apVVf5v0GItJQTOWJSSBEHoAYcSWAdSBCRpysHDm4RRhHOQZDlpmtBVguFghTzqkfQkq8fXOLC77D3ZJ3IOpQzOwf7BiIdXrnDw+IBcG6SvuseJfpevnr9A9PAGKANzC0lexJI6D+WshU+fgtMDFlnEj3YvMp58j7gzoBcrsu0tbu4/4cGFU4T9PoPjJ1j78m+wfunT7H5wi2/8b/8rO+wSd2NMuoGYLxjOF4T3n3DmYMKnoohhDkoXtR6hAhI97hgEkjdWh5yLQt6dTPnxYs6lIOBfOvgjPeJ7vT6TqIfFgxdnLQ6Lkn48hfBASkkfrWm0KCI6PW4MVUBuDEEQ+DWCNT4S03pHnBACJeWyfqA1pnC8SYyzCK1hPmVzNuVfDHocGMW7VjNBMFzZwB3uI0wOabKER1gD1uCMLepdZuRWo6XCKEmaZ+TakDvja0U6S+587UkrFFr4yNASNiIKmNbtI6IOxlhMnpCLHCsETgQYZ/EjAxbpayYiPRjFVxE0lMcAlETGilmSMUv98xTnLTAoKZaG2FBIXunEPIlCvmdyUu2jcw2Of/vBDbT2saRSKAIp6HQkenqAWOly8+5d5vM5CMcg7nLp0kusZ2PydM7moIsQgtc+dQEzPuCv//6nfOb5HRACax1CKfqDIZ1OTJ5n5NYwy3K6l15C7N5DzafIh/dItobcvnqFY1/4AnP5Pu8mc05EXaw1gK+3qKQkEMVnFAiUL366nIcI4cF6MQ9cCcOL5zzQ9BdDuMoLOJzRHhBbi7Ye2I1yTVY4V6NuF1UsJ521S0ejK6yJArd0bQoVEUQdtCkcm85h8rRghBLwkcWluxIhfNQszruJhcE5S6bLdb+P593bP2Bzp+vjj105CnjnKhAEkiTJ0cbhRAlVSyD5VP5+Y2lFtY4iwleB8zG72egJcSdmbWuLg4cPCGS7bm7VqlWrVq1aNesXrlFZhRLlh/ZNELPumioBT7l9E2CoQ7o6LDgK4BwFHer19qr9Xltb4+2332ZlZYXvfOc7fPDBB8xms+V+R4G0JjVByk8CcNXfq/UJ62NXP8ZRx6rDsCAICIJgCXHrx1ldXWV9fZ0syzg8PGSxWDwDqEpwV16vKgD6JNdZFWrVwVUTpPyHqLpdEAScO3eOPM+5devWEkRVoW/ptKuPYR2MlWMRhiFSSiaTCd1ulyRJuHnzJt///vc5fvw4cRw3Arv6uFR/1qF0FcbVH3/S+FbhaPU8q3O53remPtTPu/56tf1qvcbyvq1DwSb42OSsbgLp5fHqsbZNkLA+buW+5TafBBer41O/n5vmXv3+aoLB1eO3atWqVatWrVq1atWkMzvHMU4Ujihfky5QgkEnJAwjXBgzd/tgHFmWY6wgtBZhDV2REQWWAIfMJnSlxEWCOO6x0jvJ3uaQxSLBaM1itkBKhVASIf3fq7nRXOj1+J++8Dle7xswKcKnjfpY1jTDGZjnhifScOrNryPFDfaSTeY3R3zuq7/BT975f4lzSRgoDkXElw4NwcEu155/mW/+9feY/d//DyfPnydQjtlkigGSJMU6x5NIYs9tce35Hd4LArZmC557dMj5gynDRYYsQEtJWwQSIRybccTb4ZCbsyk/nGd0tOE/jiKem0744yjjca+PlgrPVx3GaoSTYARCOCwFgHQWq4vPIXBY5zBGE8jiC5DOO1NxAqRAIj0UE0/XLZ7BGGySEI4nXMwyfu/YkH+0PmQ6mdLfH/GdP/0D/r2102xbgUtSsEU8rnDFmipDC0HunAeTOB+zmmtynZNq/1yOQOOwKvBgUEqMFNg8wwqJRfh40F6faHsbE4KxOdp2yHW3cFBajLFoY31srHO+zmQZI2u9489ag9E+ISc3juRgwSwzJMVaSroSn4kCgAowlp1AsRYE/M3zZ3ny0W2yxYwo7hA6hxSCQbfDqxee440LZzh9fIu1QZ9+r0uaJPxgIFkd9NlfGIZb21y/9gHnX3+dn37v2/zt5etoIdlYXeHLb7zM//xH3+LukxGnuh4iIiR3r77PyZc+g1SKKIqxu/cQq0Nw3rW7enjI7oPH9Acxdx7vs7Fzgg8+usObJmDVOe+SFBIhFEKogtEJH8MqKK2NHk4WsPAphKxCOlF4TksGLsudC2Bn0dZ4N6ux7GuNxcfsRnGEKuqiOlskay0dkRJnzdJNKaTCaF0cBIQSOJsXzl8DQpbVIot9/P0jXAHXBRhryYoylCIIEGgOD3YZbh5D52llf4ijAJwlCiRz6wG3Xz8L7wgvB6BySI9LQYqna3rjLLLojwwCVByDECzmMxZJc6mfVq1atWrVqlWrXyj6tQor4SmYqcOGEgKVr9UBZtUlVW5fPUZZz7J8rlTVbVUHkeXxy5/V1+oRlqWiKOLNN9+k3+/T7Xb/P/bePNqS477v+/yql7u/fZnlDWbBDICZAYiFILGTIEDKlKjNsmSFThRLin0ky7EVy1vi4xxJ9knieIkTH8lrtFlZpBM7lrWElCjSlASKK0iAgwEwg9ln3rxt3nL320tV5Y/uvtPTuG9AgoQJ0vd7zjv33l6qq6qr+7zqT39/P06dOkW73X4dCLqddoOZo1xuo7bJwGm+ztm6UcCy2B/FNmX9lwGevCst6z/HcYbuymq1SqfTYTAYoLUmDEN6vR6u694Cn4owbRQIGwXasrbspmL/jIJ8eQA7NTVFt9tlc3PzlnPqOA71ep3p6WmMMbTbbbrd7i1hcLP+zbtwS6USMzMzQ3AbhiFbW1tcunSJbrdLqVS6pa75ULrZ+Rh1nvKu0mI78/vm65J95oFk0aWcB2ZFKF+E3kUoXByro0BhHsTly8n3W/FFhSI0zUP3rA2jYG8GxfNtK46tYrmQuBqLQDV/b8jXf1QO1nx988C02KdFkDwKmI411lhjjTXWWGONNVZeC/N7EOWmzqSbrilXFFqVCcOAMIqSHIqSuLqUifGJcYkwNsJXlkHkoMXBd3wMhtDE1KsV5qamaNQrBEGECUKu9QJs0MFzFPu9Ej/74EneNa2QqJdY8sQBDbYf0O4HnIoi/mAwYLEe8Wcv/D/YyYAz1x+g24H6xCxt7eHHms71dT4hIS9euMwgHjC/fy9X15q4pTqXrlxibeMGeyZcnLhHu90Ba4ijCGuT/Hhnwpg4itGxZtoX7u9FPKs1R5SbPpQwqUsMRCk8FMeqdRa9iM+3O5wedLnL8/kRa/h31nKhWqNHOkdBsDoBKdZCFMcpALKpI89gtU7n2QZMcg6UShynievSJj7D1GFGmr/SFYg7XaTV4r0O/PihRe6arOH0QiZrdb7TCL97/SK/ub3NM40FFvs9xBqsJM64Ya5JRxEYQ2Q0xvPRpQqDQZfYUQSRIbY2gZGui3U9YgW25BKbGOo+puJhXBfKVSjXaRkY9AI6vR6DIBlDoTVEOplTJq7KBDBpm5Sv4xgNqdstAUnWWLSNE8elAseCi8URizJglWCsoByXKRNzwnNZ3rvAWc/Fr1SYBmJt2DszSdlVfOh9j/HYfXdT9pwEnA8DhU6wf888guXs1XWcw/fTaTUZqBJz8wucvXgJbcBxFAeW9jPhKy5ev8G+IzOIUrieR2NqmlKpTBwG1CanCHe2iI3BNTFYSy0IKHfabE1Nc/XMGR559F28cv06Xw57PGYNiuR8uiSALclLabDWIOkozNyTCkkgNkJir0zslhY7dOkmoyQJ75rki0zn9CYmNBptNZGJ2dYGA0SA7yfOX5uFLZbkmhRlE0uiSmChJBg/cSymQ1JHMTaObkJNmzotJQlLLCSQNKloMtajMCQySRhf1/Uplavs3bMfz3GIo3g4nxUSF2lkwdPQiUnC5KbHVrlsncMKpWZlRTKnjtNnFdqAchJ3Z3V2gUqtAVoT9Ps017e+fjfXscYaa6yxxhrrW0pvGlRm8LAIZUZBqlEgoAgD4ObDfV03pwAAIABJREFU/jz4yZSHE1kZRXfVKEda9ll0juXrAAzdY77vc+LECSYnJ9m3bx+f/exnWV5eHhlWNF+33TQKmo6CVEWQNMotl693HgoXnW1FB1p2rkSEOI6HkM/zPDzPG0LIPGjKYGYeUBbrXOzrUQBzVF+8UZ8V1xWBdCatNcvLy8OQtZCMyziOmZmZ4ZFHHuHJJ5/EWssLL7zA5z//eS5dujTsl6ztIkK/30drTa/XG/ZTtt51XTY2Nnj11Vd54IEHhq7KIjTM1zdbn4d4+bFQ7OtMwzBEBTiWqQjf8scrgsVi3fLhluHmmB/lNs1D31HXl+M4uK47HFvFsToKRBbrnB9nWbn5tuT7Jr9Ndt2Ogv+7jbHdwGf+uPl6FV3co8Z3/r51uxcQxvrmkYj8MPBLwI9Ya3/5ayjnZ4CfBt5nrf3k16NuY4011lhjjTXWN6nESeCkpA/2szmCgl4YI45FOSoJu+gkL05WSw6luI0Tg3USl5SjXKxVDKKI2ArWLVHxPRr1OiW/Qisa8OLZl+k0d/Abkzxw5E7+fKPCU3MTqPBmiEeLEEaGV4OITzqWiwoCcTlWF9Ta5zDbPV561fCJ09ssTpSYO3CIiel51qTK+Z11rtdrOALtq9eZnJzh8P3v5Mtf+iKrm2e4utwjjGPCIKQ/COgHIXGcQLPh3Caxg/E7IvyCKL67WuEHa3WOKoVjbeIUs+kc18KE6/DeiQnO9Lp8th8wbQwftobf0TEvlKv0XA/luCiV5m0EhmFXrcVoi7UxCVIStDFoY/CUDGGPMTEYhkhNlAIDJgyIwoC5bpcfnKzxg3fMM6sE6QUQa4hippThA40av9dq8ltxzMNTi9zR7ePYOAm1amJi1yNGktyQpQrGc9GOy8BYYqUIlYN1PSj7mEoJU/GIXAijgDBy6AWabiukq0NCFRJKi0gsmJvtzKCZiIO4AG7SfmOwjotb8jFhSNAPCKMYHcdYUYnbMo5xS0nak1hrjBVcDK6nsFpjDJR1xLs9j2h2itPzk5xfXsdozV0Hl/jAu9/BfccOgtFM1Gs4KpujJfkSh3UUhYhh/0ydV66c5e53PMiXv/B57r7zHjY21ji+5DNXr1BSMFOvsN3qYZlN5p+ez+T8PvxymTCOqU7OstVuES/uxbt2FsHiAPe6io+2mrglj61OwOTsLC+vrXHCwrQkIV8dcXAU2DT8q5Oed1JYl/FDk2JWRRJaNQGMYK0Mw6FmbbNYrHIxykEbmzpaLX1taNsknG4kUC6XUWITGyK5uTMWbTUiN8OmJjk0TRIi2lj6YR/HmpsvNUACTTEpW399+pg4igh1AuAd102cnH4JxBDFYQpCk3HjKYgigziWII7Jsk0O+WR6D0teCLBDi6klfZFcKWKTzJW9UhVEUZuZpVqt4hhNv9els3Ll636LLUpEDgEXgV+x1v7wW37AscYaa6yxxhrr66I3DSqB10FHeD0QyP5BKoaCLO6TfRb3G7V+N5BTLL8ISjLoUXRX5tsTRRGe53HkyBHq9TqTk5N87GMf4+LFi7eFQKOW7QbtilCr6LLL6lWEYUWNgrl5eJJBNmDXsK0ZrBIRtNb0+32CIBhuOxgMCMPwdVBuN2dgETTltx8FvW7XrlFjIA9olVJsbW3h+z7VanXoiLTWcuLECd7//vfz0EMPYYzB9322t7fZ2Nig3+9jrR1COq310GmXjYFerzfM36mUotvtcvHiRY4fP069Xkdr/TrHXXGsFaFW8a/Y1jz8L0K7UWC9eO6L/V28JovnKb9Op28YF8/jqJCs2XjKwOeolxKyc5RfXgxvm7W52LZi3fJjddQ9oAgZ8+0d1e582OlRYzLf78Vyi9/zY3GsscYaa6yxxhprrLGKEkCJoBwHiySQgeR/23AQMDVTo+15OGnuueZOC5meYGAFYgdlLK5YOmFIjEMrhH4cEGmL4/isNiM6rau0drZZb7bYbveoNJv80F1H+fZ9czh6AHECO6wxrIYdPmYNL3mK7b6m0+nTjQw3XIttdrBVjecJ9xw7xJ6FKcqTM7Qih/qJe6m++hLdnRu4JmB6Wri6sc5zv/DzxNGAQRCkYVgTkONV61QaHlYJrU6PXrsNjlArV4i1pdNucjGO+flmm99od/jTtSofrtRZUoJj4zTaZZJT0BXFyVqNGVfx++0exho+ZC01LJ8tV2lag/g+juNgbJZPL3sBOE5cZun/7ybWaB0TY5EoyVtpAVLXmSJxtplBH6/T4b2+y5+/cz8nZydwogHSHUAYY+MYdDI/qTuKZ2sV/rDX52PNNe6dW+Jws4kb9pI5puMQGYsWhVUK6/lQq9PvtNCuYOamsI0akQO9IKLdD2gNIjphTGQ1rggVUTSMZUYsDc+lUa5QshbPprlPVQIVo7CPjWN0WrfYWAZA1O3TN5q21nQwdEXo2wSidUURaI1RQmQMWil810/AlwilKOYhR1GanGL9mSe48uKXqOousdE8+eAJ3vPQCYy96YhFUthrU/qbQnJJ4Vul4lPf3KJSu4dyycdWJ5menWXKJPlbrY2w1qAkcSsaLGIGXD37GocffBQlQq0+xYa1dLtdKlojCLGO2Vm/gVcf4N91N5dee4X77z3OuZ0mr0V93i0Kq5ykHoAoEJyhI1CUwqY5KU3OWWtTIicIjmWYw9NKCgbFARMTmRijY7S1hDbJA9rSmj6JmdmIUCuXUCiSrKNZmFaGwBOjsaKwOob+BuZ6DysOolxER9igPbyx2CxscZpP1KbANAGYyZw1jGJik0BF1/cJ2tusb+5QObCUPA9JGoAIOGIJDQxi6EYaQ24+n+uHFE1iU5Rp0vpnIZUB5vYuEfc6NKanKLkO/U6bQadNtL3xdb7DjjXWWGONNdZY3yp606CyCACyzyKIKQKZNypvFKjMlIWyzG83ynE16nhF6FV06OVde1EUUSqV2LNnD/fddx8vvPACFy9efF25tzvWKFiXr/cbabf9io6vfN/k9xORIWSL09A3+b6NouiWenqeh9aaTqdDFEX4vk8URXQ6nSHIzModBSPz9c7/FQFaEezt1sZR/ZqX67pUq9UhRM3O6dTUFI7jcPToUU6cOMHExATdbpepqSkWFxdpNBr0er0hnMwAWD4EsbWWfr/PYDBgcnIyebM0jllbWyMIglucwPl9sr9iPtZRY2a3ULD5eowCtsWxMWobY8wt0HPU2BjVx6OuhbyTOD92s3KzsKvF8TgqBPOoELSO44wMwzwK5hb1Rtf8KBducYyN2q8IQYu/82D1K7mWx/pPUj8H/Brw1r8yPNZYY4011lhjva0lChyV5NnTRqN1lORC1IYojEApnBQSlF14+coNuN6h5lrm64YgMrhKOLfWYqIxQZwCR2sTWBBbRWnQ5v0PHyZ0G/wf/98f87CJ+fD+PXhxnIR5tYYo1nx6c5t/p2MuOy5BbNBWUrBnON8yDPplSnbA3oU5mv1pSvUK3cgirk+n1SUMBvQ6O8RRxHOnm/SiJGSo1ob9ew8wvbhEZ2eTB9/5COVqHb9c4tLyChdOv8BD73yYXiycefklNrZ2ePnLXyA2htDCeQ3/qNnm9wYBf7ExyQdKPjWjcSTLoJe48faWy3yPcvj9Vosr2vCoNvjW8ly5ShNwShUc5SSwSSwolQDaOAlvir4ZZSYJAWsw2uAqB891E0ikY6TT46iO+KF983zwwBwNDBL0YRBAHCd5BI1FW0tkDJEx+K7wRK2MOwj41PplNg7exZF2D2/nBojCZJDSccFzsCUIDywwiGO63T431rbYGQSExlARYdF1OO6XWfIbuI6iE2taxrJuLGeDiPUgoB3HbEcBfWMIAddz8BxFxXMxUYgTa1ydwNhJ36UexlQiy6QoDiuhgkW5gHLoYekIbHke21pjrEFZmERYclyoVjn/8P10O2scnYRKoLgUxannzoCOEzimDeI4CQjMz7nS82htAvyWZhucvXaBYyfu4+KFcxy8+yRnXvwCKzd2qEnERmvAowuzKdSHsudQrVUT114cUStX0nl6RBCGONbgicfecpmTccyrnS6eD33jUm5McCaKeUcMvhIgAZYqe7lX0jyYSqGsxaibYU2NBURQJDkjUQqFxeCA1glcVJKGCU4dqloTWkMMbBlLJEJI4tAslfyhEzYDi6mpMYF/NnGiggUTofvbw94T0uc+kgVizULIktY3uSdgTFKuhSCMiYzFWEFcn5JfYqoxkYz9OEWuAo4SHBECC1pbgtgSi6XsCIYEMGOy2ia5YK1NEWlCWpP8n1isKBy/wuzkBKX6BCXXodnt0ms3CYLuW3WrHWusscYaa6yxvsn1pkHlbgDGcZzhsvyD/CKsgpvgMQ8PstCu+X2y/XYDN3nlIULefVYEDru52vLurTiO2draGoYDLbrKRrnI8v2zW/1G1Tffp7u53253vFGALwvbmoHK/PfMEZdtG8fxMCdlHMd0u12iKBrm/itCt91A9Kgx8UbfizAp73wtti377bouExMTdDodtre3WVlZwXEcJiYm8DyPRqNBo9GgVqvR7XYJggARoVarDc9vHjwppWg0GkNXaX4MVqtVgiBgY2ODra0tFhcXbxmz+b4onstRUHc3SJspn5M1q2uxj4vXVv442TU4ytU5qk5Zea7rvs4FmbkPi9dNHtZmIZNHgdBR11oRCo8aF8U+yV9/2f6jcoPmAXD+XpIH0/n+KO5zO7icb1M+/2c+bPJYYwFYa28AN77R9RhrrLHGGmussb7xEklCQVoT5uZkAzCGMEyApcVi44CqGHpWo1wH31NUVUho4ySnnlginYAlUSpxrVlhc6uNMhF/+OJFyrUGfhzzQLXMxPQc9DpYE7ITRPza9Rt8AkvXL2GSrHqgVOriEl4LHD69Ns179++w1xtwNi4z0NDpR6w1V1i9fIHW1hq9Xp9qrcbk/AJL5TKPPPk+nFKFtfUNVBywdOBpAusQ9jpc39ji3Kkv8di73snsgcNcW15mp9Pl+pVzWKOH+e9EhHK9TnvPXv6ZX+Yz7RY/aoU7rcG1cZIrUQyihAnP44MTDf6g1eblQY+jJpmrfLpap60jxHpA+iyCpI9EQKxgMSiV+TQ9wOAohe84+MrBH0S801q+fXGKB/fMstgooQZ9pB8kkDKKsdqA0cTGEBlLFMdERojRWAMP+Q4N4ONXzrA6v5+79+yjvH0DR4CSwpQUkQOdnRYb3Q5b/S4m1kyK4i7XY0+pRsl12FaWZaW4PNtg77vfyefOv8ZLV66xvLnD2nYLXIdKpcJWu4nvKPZOlOlbxXd853cxUVVcu3KV7a1tOu0W11c3qM3OUS1XeO2V06hI846lBaYc6N1o4kcRk0qYcRymSmUWlGKqVILBAFOpsDYzQe/wEgNf0V3boatqqJqhnuZCxaQv6xoN1iDig+tirB5GDk1yPtrUtShUqyVqzRYT8yfgtVdRjTmq1TrnLy+ztnodrz7JsaU5rO5gsFi/wvwdd+J5HoMoZqrs4/gekePQ1pq+hQkMZUc4YmG7uUXn0GGuvHaGI4cOcbXT4YIOeVAUSgFKSAaGgBJiktycw7yMyRXC0EsoCRYUSfKhqtTpiQhiLTgOymQuVkOoNYGFbW2IsQQIRoRyySeN+4q1SX5MG2tQkrogTbI6i9gjcUZLU09j4ms0KdS0WShW0jmuycLAJttHUUScGIrxvBJeqcq0X0OHXWKdPutJrxdfCaFK2hMYg0ajPH/4YgTDrYe+TbKzi4ARC2JBFO3tTWI7y12TEzhY2p02QaeNNbfO+ccaa6yxxhprrLEyvel4hRnoyofOzIdUzWBY9lnMuZgHZPl1RSiSaRRohATq5J1TecCQr1s+vGfRGQWvz/2XAZXV1VXa7fZwebFe2bL8ut0chLtBylGgq/i92K58W7L65uuenaN8eNMgCAjDkCiKho7KrO156BPH8XC7ItAaBUmLfTCq7dmyfJ3z5z2v4rkulpeFcp2fn6fb7XL9+nVardYwH6fnefi+P8wx6XkeURQN9ys6A0WE6elpnnrqKU6ePDkMlwvQ6XQQESYnJ+n1epw7d47t7e1bHJV5ZX05CmoX+yHfF8VzXOzXIijPfhf7qajiOcuO/Ub7Z1A7u27y++brppQa9mlWZjF3bL4eu53ffLvy5zrf7gzCZiA2P57y3/MvG4x66SF/vyjeO/I5X7N+yAPOfBnFcNZjvf0kIodExIrIL4vIPSLyGyKyJSJdEXlORL7tKyznfSLyL0XkZRFpiUhfRF4SkZ8WkfKI7X8mPe7TheVWRD4pInNpeSsiEojIaRH5ka9Ts8caa6yxxhprrLeRYh1jTPKyKNbgYHAdF5QiMgZrNFobTGzTvIkGlYZ1FDRKLBVXqPoKJYmzUCmFJw6e47BvaT/WL7HRtyxvtnm4VmbBcdGeT+TWeanV4++v3uDX+n02LWhRJLQzgzQOBqFr4V9dLvEvzu/l+oVVtlaus7y6xeZOm9XLF9haX6FSKvG+Z7+ND//IjzO95zDvfPgRVLnB9k6L186dp7m1TrvTAR3SDyNe+fIXOXbkMJF16TZ36HU6BN0Wnlhq1TKlso9yHJTjUKnVafcGdLXm0t0n+Kd3HucLx07S9crEYjDWYrQBa6h6Lu+bmOBBV7E66HJHr80jvQ6NMETHIdZqREnyIqaoBD4pGYbhRZLfruPgKQdPxxzsd/nbdyzxD55+lO+49yh7Ky5Ot4t0+xAE2DDCRjEmjAgjQxBrBlFMEGtCEychU20ydzhs4XsrZZy1a3x6Z53LE5OsuB6XBgGnt1t8Yf0GL66t0G21uNMoHik3WCxVeUUpPjJX43+rCf9y0uMPj8zjfOhJ3vtXf4I/9df+EkcePM7Mvnlqk3VmZiaZnpkcRlGarZW48847+Z7v/z7uOnEvM9Oz7F86wD33PcDjTz3JwQNL3PvAQ+w/eBC3XmXpnkMce/cJ9j16kvbBBU5NVXhh7wynjuzhlfsO8/LD9/DHJw5w5Yn7kCcewFuc5UZrh23xoVJjYs8elg4fYKu1w5XVDYJgkACtLO+iiRErYE0STjf1DlpjUOl8a76m2Fi5xqGjd7O8ssreQ0dpttq8euUG3/7kO5ms+Gk4WQVxxMVXThHHMSXPo1KuUiqV6ff7LEcRL8SWl8KY5zfW2Whts6/fo9/to/sdbKmGKpX4shh24gH9OGJgojSEcoBGgwkxUYAxGoNgJOGFTurmBTKil4aHTRZIuhhx0I5DJJaBjulZS98aVoxlG6GPgFhKnoPFYNEYo7E6nctqjbF2GMr1pmvaQRw3BYBpSFdJoC8Ysq+SuhqzkMfJObAEYUycwmLX87ixeoUbO9tYrRP3KwnEVyIMQk0QWwaRJrRJ+Fvll9MwrwzPYpa7E7LjGjCWWCfOTRNHtHduMFAu5cYkJhjQ6bQIux0Sx+h/fInIXSLy90TkCyKykc7BLqdzsqXCtnen87b/s7D8cLrcishThXX/c7r8mdyyS+lfTUT+gYhcSY97TkT+pnwNDxJy88pFEflFEVlL57h/nNUtd9zLuTnnD+xSXklE/lsROSUivXTO+0ci8qcL29VFJBSRTxWWV0RkkNbrhwrr/kK6/EcLy2dE5H8SkVfS+XVTRD4+ao4uIj+clvHDIvLBtO1NERmT77HGGmusbyG9aUdlMT8fvB6u5bcrKg8tRoHD/Db530VXWP44RRCSL6Po6irWM1uWQQnHcQjDcAjBgNdBmvyxdvu9W1uK7Rm1Lv+XP+6oZcW25vsnA5aZq9B1XUTklryVWW5GrTWO41AqlRCRW8K+3q49xToVtRu4LJ7vUeeoeDxrLdVqlaWlJc6fP0+z2RyetwxMZm10nORN0wy+Zsuz8owxzM7O8uyzz/LUU09x5swZbty4waVLl25xmGZ5KU+dOsXRo0dZWFgYOlKLDtD8slHguti24rJi6Nf8Od7tWinmSMzOb348jjpHxfOSvw52A+/FtuTBZP4aGeWOLl4XxTExCi7myxa51eU5yn1brGu2T/4Y2fJR/TMKQO9Wr6Kzc6y3rQ4DnwZOAf8C2Av8IPAREfkz1tpff4P9/yZwD/DHwO8AZeAJ4GeAp0Xk/dbar9RWOwV8CgiBfwOUgB8AflFEjLX2V76aho011lhjjTXWWG9vOcpBbJKPzqAxOgajcZQQxRFRFKIcB03iOoujiFD1sUpQFai6Ng0Nm+TGc93UMShQclyO33cvq3OTCJaVlXWay2tc0jFfvHqJTw00n97apC2WyswscRjgugrluGgjRNoSxzoBSCJsa+G3Viyy2sbKqxilMFozPz/PzN0nefKJx/GnFnnhxVOoQRO8KhXfoVMqUbYB9z74BOVaA8fx2Ohc4eiBfTzwyBOAYKxms9ViYarO8bueptlq02432dzaYuX6CuvrG0zUq+xdmKdcKbOsXH4+6PK99z7Mky9/ielBBweLkxITXymenJjA7bT5g96A/dbykIUvNCZo42IFxCYhPRUKcdzkpUelEFG4SlBa43aafMdEnf/qoUfZX/Vh/RrS6cCgD2GIDUKINejkRc4wjgm1JdKaSBtiY4ntMFhnEuLVUTSM4UO1Cl/SAc9vLFN1PGrWEoUBk6JY8MtsYvgPccCp7SY3rGVx7yL7ayWMdimVffxKhfWNDT76m/+W7WabbrtNtV7n+MkZrl6+woF984RBn+3tJgOtePLxx5mfnyUO+jz61BOsr64m64KQvftdtIWDh4/gimZqegqvrJid85idnqLf77K53QbHYWHvHI16lZ1Wk+nZafxqnfXlVSYmG0xPT9DrDdja2qFSKdPstvmD57/ERKXM0X2LHD24hIgG6yXhd0WR8Mq0h+SmA/PK5Uv88epFvvf7f5Bzr56mtPco5UqVx99xNyf3T2KifgLsBMRxKJXLCAncdz2PcqlMOOixd6pGuT9FO4x5OQiJlcd8t4NZW2Hi0EGuXrjI/qUDLPf6rLgOs56HK6BEJaTNdRCTOBuDMMDaAINJ3LhpPkYRhVVCZA1Gx2R4RIwG5aJVTLvZ5NrONhcGA7pK0TQx1xF6CEgSArpSclPiJ1hjk9DLwJA4WotN3ZA3w7omeNDapM423c5keT9hCInJskZasEYTRCGRtRjA90uoOMb1XOI4JDR6mHfSwRJFmtBYdGgxqYs5xsF1XXQcJe2FoVOZFFhqDMamc2YL2Jh+v0e9Wsctlen3m/Q6bYLBIL1KviH6PuDHgf9AMqcLgZPAnwO+S0QettYuA1hrz4jIMvBMoYxnC9//qPB7kJadlwf8LrAP+AgQA98L/D2SOeXPfg1tyuaVbeD/BmaA/wz4XRF5jGTeOwP8dlqPDwO/LiJXrbWfyQoRET+t43uBV4GfB6rA96fbP2Ct/VsA1tqOiHwOeEREGtbazNXxBMm8NuuLX83VM+u3j+eOeRD4JHCIpB8/CtSA7wQ+KiI/Zq39VyPa/P3AB0n68p8DB7/SzhprrLHGGuvtr68ZVMKtzrhRwK4IoPJlZPvvBvjg9iEh84DhdjAwX6fsmPn1RXiR5Xbc3Nyk3+/fcqzb1asIS3dr02775ds3CrZ+pUAkv10GKrXWQ7dgPlRm5p7Lcg36vg/cBE1Z3soMbI6qa7G+ReD1RnUsqgjmiqpUKuzfv59z584RhuHwmK7rUqlUKJVKw21FhDAMGQwGrxuP+/bt46mnnuKxxx5j3759KKW4du0a165dG47LTqdDqVSi0Wiwvr7O2toaURQN8ysW4WE2foqOyXzfFPsy/zkKnhf7Jn+82zkj8/Up9n0WYrbohC7Cvvy+u8HH4vVfrGc+xGqxHnmwmy8332/58vLbZfehUSC0uKyYV7S4L4y+F2Xri/lxd6vXWG9LvQf4h9bav54tEJGfI4GX/1xEPmKtbd1m/58ALtrCBSYifxf426STuK+wLvcDvwD8WAY3ReR/Bb5MAkTHoHKsscYaa6yxvoUUhX2MTnL5aaOTXHdisRqi0GLiEFcptJIkT1wKczSW2Co8SfcTCLXGNSa1MaX5JTHUK2WMWCYbVYLFaV7WmlPrK/SNxYil4rtMTlVpdRNIhwjWKqyJcZQgjgOp48vaJNecUqCtZXHvfk4+8DCuXyISj8GNdQadHZ549DEWD9+F63psdV7j3nvuYunwMYyxBGHE+vVrPHTvO5iamcdYS6/X4/r16zz15FNM7b2DbqdDv9fhzLnXiMJP0e1X6LTbnD33Gusb69TqDfr9AVfrVX6/P+CvlMrcEQ8SUqKTEJiOKB5rTGBRfKLbZtEYjjuK07UJ2pEFMThKUDgYA8pReI6LwqJ7Xeaw/NgDD/Oho4cpdbZg+Sp020mY12CADSOINVrHRDomiGJCrQmzsK/WEhlLbBNLmxUH67jECHEcMrDCAdelPFHlbGzwjTA1Ocmnt7e4pPtsW4sGep5LEMUs7pmnWq/RanUJtRBoYWVtm/WtF4liQ2QcvOokR+48yqVLV6hPTHD8+N187vlTrPQj7jpxkmAQcPXSeaq1OhNTU0xMT6OUSxiFgOW1184xNTOHU6pTnmqg+z12trYxymdxcZ6S5+I4Lr1+zKFDh6nUJmj1A1qdHUqewjgOZ1+7yES5xOLiPO12mygcEIUBDb/EkTv2Yk0GzhIXoFLJi6061ug4IggDmq02v/+505zdjrnv4Ue5867jrN9YY37fEqtXLtLq9pibrCYhTZWLU6pz4OjdiAiDMEKUS7VepdPtszRXYsnUiDVEQcQN8ej7ZVwXBqEh3FqhdOwIpnSRLwUhE5GhJkJFCb44uCI4ksx7PcdNwrCmMDXWMYNum8groU0CMuM4RCTNw2mTnJGdaMDFzS1WBn2axrBhDF8MNUH+GQmKSqmcwsjUIYlJwrwag9gENpo07OzNYK82Y5hJuFmlEGsSgGqTlwDSIZjMydNQrFhLEBq0tVgcXN9nenoScX1am9fRadhpSfNMWq1xRTGIkpCwWBj0B0w3KoSdOCmsKIeJAAAgAElEQVQnhZ7WGiC5Z2ESyCoIjiSRapXjUl9YpOS79G/06Lda6Ch8w2djb6F+FfjH1togv1AS995HSOZ0fyG36hPAD4nISWvt6XTZsyTpPa6l338mLWMaeBD4pLV2UDjuPuBF4APW2n66/c8CZ4G/IiL/o7U2epNtup8ERv6ETU4IIvIx4F+TANlPAU9ndRKRXwX+kGTO+Sdz5fxVEkj5EeC7rbVxrp6fA/47Eflta20GYT9BAibfQ/ISb9Y3GvgDckBXEjvy+4AL1trLuWP+Cglk/LC19tdy20+RAMx/IiK/aa1dK7T5O4DvsNZ+9Kvop7HGGmussb5J9KZBJdwKLYr54oqgEm4+8Nda75oXrvjAvwgURzmgRmk3eJSHIqPCc+ahThRFdDodwjC8peziMYugpNiWrwQ0fiXL8/UdBX6L7c5gWBb6NctDmC3Lb5flrvQ8b1hmvV7H8zyMMfR6veF+X03dR4Ha3aBasQ27tS1rh+/7w7rnty2VSsP8nBmYiqJoGM7WGIPneezbt4/HH3+cZ555hnq9ThiGzM/Pc/z4cZ577jk2Nzex1tLtdimXyywtLdHpdLh48SLHjh3j4MGDrwNsRZfdKICWd1vm+28U5C62vbhfEQIWwegop+Co8vPX7qjzMaqe+fW7uUDzdS6GUM1vP8p5XRwju9V51PWwW5uL+xXHZ/Y7c22O6qviPWmsbwo1gb+TX2Ct/YIk4Xz+LMlEbVdAaK29sMuqf0wyqf0TfOWgsgf8lM05MK21L0sSPuc9IlK31nZuV4CIPL/Lqnu+wjqM9Sb1yU9+8i0tPws1/1YfZ6y3RuPz9/ZSPnXDWGN9I+W5CisOxqZzUAEQYqMJoxgThVijQQTlOYgE+J6LtZYgMrhiCKIkHCzWopSDqJshJx2VgEffVUxOTbA2CAiCPjoWRDTKWlzXJQhjgjAewgmLwlGC7/nJ3EWl/x9bi+t5TE7P8fATT9O3PmdePsU9Rw5Sr1aoT06xvHyVO44dR0pVojBka3ubxXqNa5fOU6lPcOnyFRwdsNFq03ztFVzPpx9GTFdLVKfnMVon7rJKhU5zh6cee5RWaHnl9GlWrl3h+uoKSq1jjeGG67AzO0fglfmvXcWJsI/Kud0cUTw2MYHG8vudDvPNHZYcl4vVOl2tk5Cv6QutnuNAGBDubPHA3j38jb/0U9xz7RrOqc/DYADdHnT72DCEMEZHEZGOGcQxQRwTxjoFlIbIQIglVoJ1fAyCdhS2VGFgLd0wILQWHUXc6Ae87CquNWp4ZcX5OMT3EhetiTWe5+J5Lts7bcpln2qljEVR9kpYHKLYsLXTxojHPfe+g7Mvv0S1Pol16wz6O/SDgLvuOs5d95yk3WmxudVkp9lmdmYGCDFGszA3xYtf/CJnz7zCvgNH6MaGb3/qWS6c/hy+DWh3HFq9Aa0gYMLCvn37qVaqRFZx/tKr9HtdutYSxganUuXoiWNsbm1hlYNfr7O9ucXVzR16n3kRJYLv+yjlJo47rekPAq6vb7G21Wan06EbWSIUC1N1ti+f4eBj7+XcmZc4cugg8YXzXF3fYW56CiEA5RD1W1y8cpWjJ+7D8xS+77J/fo6zzQssLexhYd8U1YkpqvUJypUavucTxRG//UcvMFmf5PrlZeYX93BhZY36vr1UjSEeDIhaHWzQg0GIG8e4xlASoWQNFQtlEbrdNtOzCyxNT1PWETrSGJ0A7H6vy3a3zdVWk3P9PldMEu71TC9iJ3U8uulU0lWKiu9gtE5wpNZpqFcwImAV1prURSoYHaPj5EJPACS4rgM2C76ahWBN57dIki7SAmkY4ijWKFG4jsJTitXrV5jeexgdR2mu2rRujsJYgxFFZEiNmRatQ7Sq4zmKKI6T9xnS4yGC6yg0JoHTaYhZQXBLVSbm5igpxY1um0GrlTyf+QblqLSpW3LE8t8TkdMk87m8Pg78EAl0y0DlMySQ7grwkyJSs9Z2SUCcIucYLOgvZ5AyPea6iPx74L8E7gZeenOtogf89QxSpvq/gF8EpoGfzINTa+0ficgl4IFCOT9Kcup+KoOUuXr+XeB/J3GeZqDy48B/T9I3eVD5PPD/Aj8nIndZa8+mx5oB/m1WrojcTwJG/00eUqbH3BGRnwZ+A/hTwD8t1PXffzWQ8o3mzeP/2b96jec7b07jfntzGvfbm9NX229vp3nzmwaVxYf8IvK63HR5MFEEBfnt8gAxA1FF19btoEARSmRl5tdndc7+slx3RdCTh6ndbpd+v39bN1ix/GLfjII7RfhRBE+76Y1gZjE0bR7U5Z2S2UQt76bMcgsaYwjDcJiDNAOVnufhOA5xHBNF0euOnf9dhGWjYN3tfo+CUfnvWT1XVlbodDqvcwDm86cWw4VGUUS5XGbPnj184AMf4MEHH6RcLg9hp1KK6elpjh07RrfbpdvtAkneTgDf93nllVfYu3cvBw8evCUMaf4vD8fyULgIKfNtHpULsdh/edCe3ycP//Pb5cdZ/nfeZZt9z8LiFh2Ho87PbuM5G3Ou6w7PRf6aLr5AUDzGKFCa7VfMC1oEmUVX6CgYPgo65q/V4jkrvoBRLKt4Hsd62+qL9mZYmrw+SQIqH+Q2oFJEasBPkgDNu4AG2ROBRPu/irq8Zke7N6+mn9PAbUHlWGONNdZYY431zSMdhwmQSEGjwSICDgZRQhxHJP9uWpQFoy06TsBkJ5YEAEiSqc8ajQFU6p5KIJyDJQndWK9V6E/WsC1Lv9dLvFLi0Ykttt1Dm8SZpY1FJAZcgjhK/n93FFiYqNW4912PU61NoGrT9Dc2aPiKu+65h4m5RbqDGN8vcXVlhU6ryU5zBzvo0nbqRPE6ByYaBGFItd6g1e5QqWhcL0aApUOHCQYDwnBAFARs7+wwN9Hgznvuo93tU/J9qrUKFy+co9ncwRpLrCPCtVU2HJdrtQo/XSvxgGNxtUVhMEpwRPHExCQDCx/t9wi3NthXKrHsegRpTkQfi27toHe2+M7ZWf7iY0+x9+xZ5OI5aHfAGBho7CBK81BGSR5KHRHEhkBrQg0RitAYYgHtlrClCtb3iR2X0Bh6RhNZ6PplzoUhnw8DzgQRse9yR6XKtbUbWJLnEaRziLLvUvI9jh5ZwlEOm9s7DMII1xHmyrO4rktze4eDR44y2SgzMzfD5PQc5bLPxSuXMRbanTYvPP88J04c58xrl9i8scEddyxx9M5D2LjH/Pwsr756ls2tLeYX93N1eYXnP/tHhM1tfK/E4lyNBYFuEHDp4jKTE10c5XLx+hphHIESSqUKU5UKd9ZqlHyPxfk5RJJ51NZWk/V2B3Fc6iWfwEYYk0Q+clQStnV6epLZuRnmpxq8cv4az5+/znc9+SDH9pZZW19lbs8Bzl9bpTG7yOrWBn1KONJBlItSDo44uCbAE5OCtwGuYzn27nfyzHseRVmLiTU2TnKJxoMBN7a3uboBl65d4egzT7K6uo6eqPPEu+/HRBFxpAmjKIHQkWYwCOkHEb1ej9V2h+bONq2dLdxylQ//me9jQmnMIMAOBphen1Kni2o2MZ0u7qBPdeUy577wCrrs4YVJyOAMKCpHUfYU1mqMNUOwZ1I4STZ/TZ2T1ljiOEruHaIS8GsFsRZtQSSdn1pBlBqGjkUS4KnjiH4YYUie9XiuojvoY3VEFIaA4IhgsHhKEWuN6wuhTsLPln0PcUr4XgVT1sRxexiQ1trE0a2NRZRCWYNVSd2tCKXGBPXpGSSO6LY6DDqtW+by/7ElyaT+Pwd+mMSJOA04uU3Cwi6fSD+fJXH33QsskEC6q8BfI3EUfoSbIWI/wevVtNaeG7E8P/d7szpbnONaa7WIrAG1XV62XQYeyX6ISAM4Cixba18dsX3Wpgdzyz4N9EmdkyIyCTwE/H1u7bezjO6bx9LPSRH5mRHHnE8/j49Y97kRy8Yaa6yxxvoW0dfkqCwqAwO7was8mCw6rPL/sOSBxu2Okf+eB4l5OFc8VhFEFAFLFg5zMBhw48aNkaDydlCiCHbyELXYH9n3Nyq3CIWLfVOEMll9M7jmOM4t4CiDknlQ5fv+sN1BEGCtJQzDW8JjZnBzVB2KbcjX5436azdAO6qPIHFM+r7P1tYWg8FgJCgGhuc/g9JZ6Nvjx4/zxBNPcPz4cSqVytBxKpKEiJ2enuahhx7iwoULdDodlFLD8eD7Ptvb21y7do1er5e+KXorWBdJcnsWncWjxsOodudDIufbn+2ffyGgCL2LLwaMGu+Z8uM6v76Y77U4dvP1HAXwi3XPu0uL7c1cv0WNgpD5do2C4MX2Fe9Ho7bJlt+uDtn9Y1QI3t3G6FhvOxVDxmRaTT8nd9tRRDySidW7Sd52/XVgA8je2Phpbubj+Eq0s8vy7O1VZ5f1Q1lr37lLXZ8nmSSO9Rbp6aeffkvLz954e6uPM9Zbo/H5e3up0Wh8o6sw1lgAWG0QAVGkIRbTUI5KJW4olYRNVK6DSeGVoywoh64xdEMhDiJ8GxFZ8OKIOA25WPLK4AjlWgMT9ih7wszUJMY69EJDFAY4krmuknCuSkHZ9dDaYIxGmxgdGwbdkIW5WZ7+4Hdx4UafqNVmcnrAgTvuoERApTHJxo1NLl++hOPA6up1ep0eOo7wXIcwjBkEMc1TL6ONTnI3Bn2CMKJSrSWhKpUiCkOs1ShJ8m0eOHyE/mCAIzAzM8Ps7Cw7Gyu4WJrtTpIXMoqIopjnw4C/0fH4H2YavNt3wBiU74MVPBTHJxq8MDOF2+yytrXOsT1LbHklwtYOrWaTehzxX7zrYT78J3+A2vmLyOVLEEbgVLDEUKoTdfv044B+bAmMEBghRAi9Cnpqiv6ghzYxlMvYSp3IcQmAfhjQDwLWLbwUa14xmnWt6RmDdhT7ZibZs2eBa6sbKNJnIiYJ+ynAvsV53vnAfQyCAatrG6ysrmF1hLKaTrtHZzDgpVOnuHz5Esff8SCPv+dZzp89xXPP/SG1aoUoDPit3/kt7jl+NyfvvY/PfOazLK+sMVGvc/Lekywvr3H52nUcx2WmUeLOu+7h+Rde4tD8JFXfo2/BL5XQUUi17FOtlnEac+wEq1SqDbqtmGazTa8/wHEE35+gMdEADM2dJtMTDWZnJtnfqHPi8EGUI4mzT1KARpYWRRgM+nz5zGWm6mWOLi0wVfV57dwpFu9/L6e//CXuv+8+1q5d5sy5i9y9r4Hj+aj6JIfvrqHCbTr9EIPglCax+gLVepVqrTJ0K0MCADGGpz70NL/0Sx/lyKEjaO2wsDDD2WvLzOyd5ejROzl+9A7QGhtFxEGADiLiKCIaBERhRBQmKXBUyWNmaQYESr4/hIoTCPPWcsRCHAd86WO/ycXVVQ6Ehs7AECmP6X1LycvWwEKjgjV6+BxG6xhBkpcZ0hCvQG4emloqsViVvOQgQnIPMSBKhi9BQDr3tQlMNNoyCJOw0WXPo+SX2XvHYZySx1YUou1NRyXW0FMuFb9EbAYYm9ShUfYolSsEUR/HVUNIamziatbpbzV85pHe18o1Jho1gl6HfnuHqN9LQeo3BlQC/wvw3wArJPkYl0lgGyTw8mB+Y2vtVRF5DXiviDjcmmdxlWQu+CwJqHwWaAGfH3Hcr3nudxs1b1P27dblnwNn8+CVXbbPlk9lC6y1oYg8B7xfROaBx0na8XFr7SsiskLSJ/8s/bTcCipn088PpH+7qT5i2eqIZbvqjebN4//Zv3qN5ztvTuN+e3Ma99ub01fbb2+nefObBpV5F1JxeQa3RsGYImS4nYOs6BzLr9vNrVc8bgYZMkdWBjwyx10eygDDsKK9Xo/l5eUhCNsNOhbbV1z2RrCuCJqybUctK+5XbF9+eR5SZgAuW5+5ADM3ZbVaxXEcwjAclpUHbfk+y+o0Cli+EXzNzkGj0aDRaNDv91lbW3udq63YD8V+rVQqVKtV1tbW6PV6QyfgbuMqA5We53HgwAHe9a53ceedd+L7/rCfsrLjOKZSqXDo0CH27t3L5uYmURQRBAE7Ozvs27cP3/dZXl7m1KlTPPDAA0MIutu5GuUmLLbJGJO8VcutY3o3IFxsZ1ZufqwXIXzx2KOuk3y/56+7/LWTB3jFlwWKkLVY32Kbitd1sfx8G/OgPWtjvr55d+YoOFx0W+frmAeuxbyqxWssf8zieRjrbavFXZbvST93m8gBfA8JpPxla+2P5FeIyF4SUDnWWGONNdZYY401Uo6TwElRgjgWQZF5rJJ8lS7YJOeddhxQ4LlukpfPEUwQ0eoGmKDLxMQEynHT3JRppBkEJZYwitjqxWw22zSbnSTEq1VobVAqyUFprcEY0OEAnUbKiaMAjOXooUM88Se+G1OZor9zlfseuo+FfYdohRpjFS+++CL9Xpso0sRa0x3spP8TK3QYEeuAMAyxxqAcB2PS+bajgPSlSCSdg0a4rovWhkHgoERQyqFSKrOwuAcbR1y7egkE2u0OcazBQmwsp4OAv7UR8w8XpnjQd9AmxBiHZW04Wy7x507ez5UXX+Bfr17nyOYq7z52ku1DR7ly5jR33HknzzzzLJVXX4OtTYg0Vlxwk7luVKrSm1ygi0u/22agY0LXJdIGOzFFYAWtQLsexvUIPJdeHNOMIy7FES/FIVeNZqAkCaEZJefJ8zxO3nOMlc1m0j9KDXN5irWAYmF+ll6vQ6/XR0cBLhqv4rPTajK3sMi+hT7NTo/NnRbd7oCzr5xm5fpV9uxdYmHR0t7Z5uqli5y/cIGH3/0Ix+6+m26rBTqg09yi29zkgRN3EQYRvdY2nWaLXiicXt7G0wMOzE0y3aijdcyeuWkmFu9gpRny6OPv4cKrL7K+toHFIx5ErK5ssHljm+mZGQ7dsQ/MDq5fplyt0er06PU6uMoSRRptLHFssFan48VlpzPg6naXxdkpFJZBrJmrwPrqCnfccYTrG5s0pma5trrJgcUZqrUq281NtltNlubq+H6Zmg/7909x+ayD63kQR5gUiCYQEXQwoN/cplG1DCpzXDj9ModPHOHSZz/HZ158hSsrqxy68wCT9QpQoZTNO40Ba7Bp5CRjEnfjoHmDs+ev8I4HH0DSEKYZ6hMluOKxcMdhPvhtgnE8cDzE9RDPB1GIcilLgDZx4o7WMdaAMTo5Xnp9kIJIozUmjrHikE03ncyJaXRyB7GCUjn+pxJntNWaOAoJY43F4rkeYiN6nTZ1v5w4vW0WqBVCA+XpWeKoT5SGVY6jiHanw8SspVKp0e/3iOIIa1IQSvp8KZ0mCwor6WsRtQa+69Lb2abXaaLjKGnjbV5if6skIgvAXyZ56fRxW3AhisiHd9n1E8CPAe8iAW6XrbXn030+RwLq9pGEEf1tm0vt8U2kbB68Z5f1ewvbZfoECWR8lgRUDkhyYmbrvl1ESsBTwGlr7fqIY/6ktfaffJX1HYeyGmusscb6FtbX7KgsPqDPQmjm/4rwAHgdrChuX3Qr7QZGi3UZBbZ2O1a2vtgWx3EIgoDr168PQeXtgOrtlEGOfNt3C/GZ32cUAN4NBBbdZ0WIkl+XhXLNXISZOy+DkNVqlXq9zmAwoN/vD8PAZu0ogt3d6j/qH1BjDK7rcvDgQU6ePMnOzg7PPfcc29vbt4C02wEgay1TU1MsLCxw4cIF+v3+0A2aqVjHDGL5vk+tVuP/Z+/NYy3J7vu+zzmnlru9+959+9Kv1+lmz0xzFu4UKWlo2tosWYKWyIoSSFBkO46QwLAQJEGgREiQIBuiP4wERgLZAiwk/kdyEsOypHARORRFcobTs/VMT8/0/vrt211rPefkj7p1p7rmviZFmpLI3C/wcO+t9WxVeKc+9f39zp07h+/7o3yV48o+NTXFY489xsbGBru7u2itR7C3UqlwcHDAq6++yuXLl6nX6+8B0ieNmZPA9Ti4WxwvxTYct18ZphXHWHmMF2FmsX2KMK/YFuV6jdNJ4zX/K0LYMkA8qZ2EECPQXqxfXrdx1/JJY6947nJ9TgLrZRA8Dsh/s9fERH/p+oAQYqo8KQWeG35efcS+jw0/f3/Muh/8dgs20UQTTTTRRBN9b8tzXRwpkMMccFD4H9NahNW4ClIlQUg8pahXKwiVwQQlMsAYa4vAUq9WyDLUWYwQHB3skkQhYRDS7Q2IogQsWV46B0DhKAcExHFMGIUE/V4WPQeLkorTa6s89Ym/TurUSPs95qdrrK6fIUgF927fpNvr4iQxcRyTJpkTLIrC4bwyc4VprTNj1xC0wPAlYOWgkwQhJJ7vEccpWI0UVRzXy1xl1iBEtl9ruoXRhjCKMKlGAp3+gDjOgllY4Hqq+Y39Dr+10uKCI7iTJGwol48tncK/9jqPY/nF1iwvC8Gi5/Hh1WXU2fOIowPEn34ZpANSYizo1BInmjBJCZEMpCKQknh6hkG/TxwFyNmlrO4mJpWSQZoSJDFHqcubccybUci+NcRpipICJdyshyw88eQHSFLNmTOnufrG57BYHMcFAcZa5LBSgyjm3sY2URTR7faYnWnRaE6zs7eDELC8tMxTz6xx6twlKtU6QZxw984tLly4SK8fcGr9PDdvvgVIjI6IB21caXnjtZfY2thgeWGWtaUFnnrfWTZ3Dzju9piamWVrawPheHiBJHEFvhDU69Psd0Nq07NUXEiSmOnWXAbSdIzVKdiUOE7YfLBFHIY0WzN4fhVpDXgetUYdR2UQ3egEncQkqSaMUnY6A1JtWJqfptPvo7uGyBj27rzJpQ//AM//4f/F008+zo2rX+OdB/tQm0IIm8E3XBBZyNL3PXaWa1//OtKrIoTNrIZkDk4hFFIq1s49xuXLm/zenz2g3pzmMJH8xE/9OLdfe4G4d8Q719/kA5fPgAAhFZkrUWVOVyGwUiIdCQgGbQ1SIJUFBVkYVoMVFosDKE49/UGWn3yKNNGkSebKTJOUNDX02ke8/MINllaXUFZjjM7adBRQNQeU2Zxcpxqd6qxKwiK0RkuJEGBt5tQ2OvsTAgQKayxSZI7HNE1IjKHqSnzfRSYh6aCNbc6MXtgWFqyAFEm90aC7dUxi7HAFJEnCzvY2p0+fxu0ck+oEI3IDp8WIoSmcIjCVVGbm8V3Fca9L2G5j9fAZhPp2DITfss6T5ZD84zGQ8tRw/Th9lgxU/jBZmNffK637DeDnC7+/62St7QohbgLnhRAXrbVvlzb51PDzpdLyvL6fJgvl+mX7bj7Mz5KF2f37QJ33ts1Xhp/fD/x5QeVEE0000UTfw/q2QGUZOuQwx3EclFJjQ0jm25bz4I2DlGWQcRK8LIZ5LYObIowpOsvK+TTLMCWKIra3s4lCvv6b0Ti3XHl5Gfqc5LArQ5STAGXZGZdvlzsn8++5sy9JktE+rusyGAyQUuK6Lr7vU6/XRyFNi3kpi22ag65i/5bLVa6/tRbXdXnf+97HJz/5Sfr9PnEc89JLL3FwcPCQY/MkwG2MYX5+nvPnz/Pmm28SxzGVSmW0XV7PfAzmy3NXJTDKyZiPhyIkhQy2e57HlStXuH79Ovv7+yOY2+l0qFarBEHA3bt32d3d5fTp02MBYLEtimOv3O/F3IrjxkOxDYrjtBiuOIfJ48Bu+TjF8ZG3WQ4Ey67jcnnLLyGUczjm5yuHpz0JdJ6U+9VxnFEfFo8fx9kDkiJcz7cphmct1jEvR/69mI80vybGAeBimxf7IF9Xzjc60V9pTQP/BfAf5wuEEB8im0C1gX/xiH3vDD+fA/5lYf/zwH//b7icE0000UQTTTTR95im6tXh/6YWIVXmolSCJDUZqJQKKzTGWoSj8NzMWWiUx/GgQxTF2DSmpgSegIrvYxgSASE5Puhk/89aje9VUK6HMcP5hzFYA3EcMej36Pe7pFGExeK7DpVKjZmZGT7x13+EWLg4wrCyfookjnmwu8vG/fv0u10QoKOYJEmJwpB+r0uSREiVOTaNTrMQljYLTSmlQCgHTykMBoFBKQfPqaKUwnOGsEkphF/JoKRJiZMULFkuxNYig34fawxGSDqdLmYIOwyGl5OU39ht89PNBkY6/NRsC+7dYWBSHOXy/kaDJ2p1HFfh9PuI/WMY9LCOg7EpSWyIkpgoSQnjiDDoE+mE2ECQxIRxhKlUsdOz9LvHGK0JlaITh9xLEq7plHtAIAXK8QjDEFcpPN+lWm/Rbh9y6tQZfvpv/zv8wb/459y+t0l/ECCVxHEVaZKitSExBiEdTGpIk5RKpcqdew84c+4x5pdWieKAMEp44pnv48ozz+Iq2Lj2FV742msgPKRUNKaaKOVw8eL7qFWrHO3vcv/2TdqHu4S9I5YWWhwdH1OrVgmDgEEYsVit02sfEwx6rJ25wHM/9ENMVeDWjXfYb/e4f/M1fvXv/h1MHLB6ap1qfYokirLwvWlCPOgS9toMrEEpSdWBKAxwHZ+3jj1828zGu9VIoxFpgO9JXFdwlPbRxrC2doqF1RUqChxpqdzZ5bjdYe3UaQ76IY3mNAftDh979gnePJQsLizSPthmbXkRg8vb2326tsK9jU2CC8tINXwmJCVCWqw2dNtt3tlJ+Ws/9ZP4gyNu37rJ4nyL49Y0cTjg6tXXeP+ls3hKZi5JAVg9BO7DOKtD8u66Pn7FG13b2ZRTFSxeFqkEnnRxPReoFp4JaBzb5+bte8wtLoDN0/AM56LDUKvYDPxbsnlqagzCACJ7USEZPtewWoO0SCEBixUCa1NAYrAYq0mSFIRkbaaB32hQqzfxhSS0dvh8JwsL7fk+s1MNVJrQi7K5doZmM8dlFPTp9QMq1Rqx1tg4RJN5MbOAs5mUkFgsWjpMz83hYQl6HZJ+H6U8apU6SRx9R++3J+jO8POTQghlh85HIUQD+N85+bno58mq9x+QzSeLwO1zZPPL/7Tw+7tV/wT4b4D/UQjxM4X2mSeDsfk2Rb1ENo/+SbKckv9HYV3eFv9Z6TcA1toXhRDPAz8thPgVa2352BBFzb8AACAASURBVAgh3g/s2IedmBNNNNFEE32P61sGlTkoyL+fBC7KkKIIKfN9888iOCqHmiwfKz9n0QlWXJaDm/L2J7n0iuWXUhJFEYeHhyOo8edtm29mmzKgLdYvb69xx8y3K9ZxXJ2KkLIIhZMkGYHJKIpG0K4Y9jZXtVodgdsoik4McVoGkidBt2q1yvr6Oo1Gg2azyQ//8A/jeR4vvvgiu7u7D4ViLe5fBENTU1PMz8+P8jrkOTWr1SqQwVcne314tH8Ovor9X85jWuyDPEzs2toat2/fptfL8qMcHBxw5swZms0mnU6Ha9eu0Wq1mJmZeQgA5/CreMxx0Lncr+Vcl48at2WnYXEMF6+l4hgog7a87sVQyHn5874eB+2KfZ1/L4LxXEUQWYbZJ4F6KSX1ep1Go/FQWF1rLYPBgE6nQ5IkJ95PirC43EbjrqO8zYuhYb8Z8F4M1zuBlX/l9UXgV4UQHyULSbNC9varBP6etbbziH3/JfAO8A+HE6arwGngx4F/Nfw+0UQTTTTRRBNNNFa1io82wzkB2f+fSkiyaJAS6QpcLNYxCL+CcBwQljAKieOIKOjhS/BdhcDiOQ4oJ/v/UynSJEEJgcDJgjgWXpQcDAI6x0f0eh10EqOUotFo0Jhq4tfqOK7H+69cwZ87RWfjLq1zp/HqUyTG8uD+XbqdLjrRuJ6LEIIkTTg42CMY9DBGD0PaSuIwxFqNjmNAo4SgUqlQmZ2lNd2iOTOH51cBS7VSJQWicAi9Yo0QllSrLFytAb8imGpO02i2CAd9GjrFlYp2r4cgC3NrtOFLUcLOYZf/7fRp4r19DBYpRBaMU4MTxsj9I3SYYv0qWogs/yCW2EIQRcSOQ4AlCAPCfpdUSpieRZyeI4kijjfuEklFR0huhhGvhH22jCFVEs+v0phq4lWq1MKQOOrTnJnFdX0OD/f4oR/5EY4Odtnf2+ZWr5e9kKkclFAEOiY1GmEtSWq4v7VNEM1w7vwlzpw9z8LyOmvrpwj6x2AMgzCg02njCME7G7vcvHUbLRQzc8ssLC4TRRFzs/PMz83iSsu13sugfPxqldZ0kzAY0On1ODg65va9ByTW5/SZc7iOx3RrDiUlOg3ROuK1V66yfukKruuys7dLozlFrV7P6nWwRxjFrD/9LK/86WfY3TtgbmGWVBuqFY9OP0VP14lCAzbFDkOLWmqQWCyCez1BamFPT/HqUR1hU5qupOOdYuvubZ688hRf+dwfcenCee5ev8Zbt7eJ3SauY0FHeNUKSsLduxuIapOv/ulXeLwe4SqHwcBw2Ak56obsbm7TPW7T68Qc37jH4soytbTL2188RJIQdLpETky3nzAzXX93Hjh6eXqIKG3meHQrNZZW11GuPwxjmoWZlQzni1Zg0GT5OMVoPWShWtNwMJx3a1JjhpB/+JICEmsSjDWY4fVrtMYOfwuG4FQXjpkmGCEQQo5goRAZYjRp5nhNh6GhrRDoNEEoB6sNOndUImg2p5lrVhhEIakehnQdYsjsWUFC++iAmqfQVuB6HjqKsMP2sZZhftDhcwHHo95qoaOQQbeHjhPqjRZzU3V2tze+4/fcsqy120KIfw78beBlIcQfk4HHv0EWsvRl4Jkx++0LIV4Fnh4uKgK3PwMGwCKwB7z2navBd1z/E/CjZNDxFSHEHwA14OfI6vc/WGu/VNzBWquFEH8y3AcKENdae1dkLs0LgAa+MOac/zZZe/62EOI/Ar5Kls/zFPAUcIXMqTkBlRNNNNFE/z/Stx36FXgICriueyJwyz+VUu8Jf3oSQCxCmKIeBXLKEHBcOYrbFGFKvlxrTRAE73H5Pcr59iig+SgAOQ5SjqtDsX7jQGz5XMV2yZ1kxWPmdcuPl6bpyD2ZO2KVUvi+T6PRwHXdEYyLouiRYUjLy4wxeJ7H0tISc3Nzw5wkmsXFRT796U8zNzfHl7/8ZW7evPkQICs72nKHZw4Oi+2Rf/d9fxTiNletVqNer4+F68Xf+fe8vBcvXuTOnTu8+eabQBb6JI5jXNclDENee+01rly5wuzs7EO5P+G9uRDHwa/iWBgHnst5GMfldMyXqTFhVIrg9KSXA4rXWDG8anFcls9fdDqWx2D52i46P8twsNjPkEHmfMx5njcaJ8V2S9OUIAhGx8z7ZVxI5fJ1UYTS414UKJa56LjMtxkHtf+8LzJM9Jei28C/D/x3w0+f7C3Q/8pa+0eP2tFa2xdC/LXhvs+Rhai5BfzXwP/Mu+F+Jppoookmmmiiid4j6XrILIoiwtoMQugsd6MUKoMPNnNiCesgEURRSDeI6Xa7iCTm3GwdPMVhL8EYjeP6ICQWgxjmpMNatMleSh30u/Q6xwSDPhjwXYepmUWarVlqtTpCORirWZxfYP70RXb2dpmdmcKvT/PW229zfLyPFGIYptWSpglSCtpHRxwdHYJNwJCFloxClDBUfY/luRmWl5dZXjvF6qnztBZXmJpq4VYqWXBLkwWtdR2FNoYgCDlqt9nZ3iEYDOgP+lkevDih2WwQLy4RRQPiNMExhlazSZwkpLqHQJBqzR2d8tvbW/xKrUZTgitdLBIEpNYSmwQ5dI8lJnOkJY4gcqsEvR5hv0eCRvsVkpV1bKVGYg3dfp/j7U0OjOV6HPBmFHBoDSngeC5TzVnqjWmUk4Ua9aY8PM8lTWI6nTaeV+HS41f43d/9XY6O26Q6RQgwFhKT5fnM81UmacqgH1JbqVGp1Dm1fpqjvQcsrqyxfvo8ngmZWTvH5q3rzC6ucfrSU1xuRzz/hc/T6fYRMgPXFx87T6Xi0WsfMzs3TzjoEfYilFtFui6ebzBWIIfwylHZXGdtZZk3Xn+dRt2nc9AmijUf+ej3ESWa3Z0tPM9nEBxTQ7C8tk6/c0jFUwwGfZAK1/OxVpCmGuPUcV03G/zW4LgeQkhSbbNcjECSZrFKjXQJU0A4JDFoPAySQZgwNz9PNzK4XpWd4wGL50/jkmLTTXSSAILZ+QWsNvS3Nnj+CzeIO312jo456HZJwphaqmlJB0+ndG7fxz2zjkwDegfHpCisI3DqNX7/+Lc5dfki8+urzK3MMtWs4fvZy8+O6yKVQkiF41eYn5rHSpWBPAtghte2AWOQNgWTgjFYk2JtPq+WBP0BUZySxDEOmjRNMuZohzkfDVidX87DXJX23fm0lAo1vIdgAAtGDPPA2jx4bJrlgtWGNDUZtLcglEPcO0BagVZVtDFk2WNBKod2ZEgGAdpYrBXILJgrDO9b4aCLK6dQQiDdCm6akoxeUs7CHGfuSov0K1Rm57BxRNTrILRFKUNswXf97/Ad90T9e2RzuJ8Hfo0MLv4/ZK7I33vEfp8lA5VvWGu384XW2lgI8SXgh4DP2+/iN5eHdfkbwD8kA4j/IZACrwD/wFr7f56w62fJQGUHeHHMugvA16215fyWWGs3hBAfHJ7rZ8giHSlgG3gD+Ed8d8PfiSaaaKKJvgV926FfxwHCfF0ZWBUf7OehIcsgsgwLxsHGMiAb59oqQ7pxcLB8vlxxHI/CkhbdWfm++ec3CyjK/7OUAUm5LGW4Mg5UPmq/cruXIVUOX/I3apVS9Pt9er3eQ/ko8/2LYUXr9TqVSoUwDOl2u4Rh+BDAGVfOvAyNRoMnnniC6enpLIzJ0K26sLDARz/6UVqtFi+++CKvvvoqnU7nobLmx67Vamit2dzcHOWMLIdwLTpI83b2fZ+pqalRnxbLOa790jTFdV0uXbrErVu3uH79+qhNj46OmJmZodlssre3x9bWFsvLy6NcmSfBsiLwGgcvy+UoXkNlQF6G5uWxlKscWjU/9zjwX+yz8vg56bo9CYSmafqQi7NY53HXXt5H+XisVCojKJ3nia1UKiOHbz4O8nMEQUCv13vonlF2p5700kOxTOU2KH8fB1gnOSq/O2StfZN33/g8aZvfAX5nzPL7ZJOncXpP51trfxP4zTHLTxwo1tpfBn75UeWbaKKJJppooom+++Q5LkiZhTA1GscKjAuQgZtUW5TIHFtKCZQUJGFAEmniYMBc1WFxroFyFJHpkoV8zQhG5rQSWAFxFNI+OqLfOSJJIqwFRynmF+aZmV/G9asImfmkJFCtVphfO0uUaOZmZrAm5a0bb9M93BkeG5SS9AcDdBqBNfR7HQb9NoNuB99VVDyXpVaTlcUFzp05zdMf/AinLj5JZCXb27s8uH+P169dYzCcZ1Y8n+nWDMtLS8wvLtOcaTE7N8/ZM2cYBAEHB222th6wv7/LoNfL5hU6C2d5sLtNFPQxgHIdkihGSUlsLb8fhqzMzvE3EVTTGMdqHCNRykCaQhigVUxsIbGQOJLYS4ilJG1MYXyPRDlESUIQDjgMBtzpHHMtHPBOFNLLkn4ilaJen6I5PYvnVcgAjUEAxmQgVgqBTjUrp85w894Wt2+9g9YpaggpLTbbdjiPSNIM9hx3e8RRQNWDNOpRbzRoNGcYHCWkW/c4DgdsPtjh61/5Cj/xs7/ARz/yUV576UU2trZwHZdGcwbPURitSdIEoRTh0CE3MA5XPvh9vPK15zlqd1Ayq8fNt2+QaE3Nc3jn/i2e/lv/Fv6VD3Hx6U/wwQ98iEG3zYMHO/T6feYX5onjY5IkxXEse9sPUK5Pw6nSmmrS7nQJU5ephXlsGqFcFyMFOgnxfR/lKdJUkmpDEmUvhOuwi6KFlQ4gkNLSbM1y5/ZNHnvsMi999UucO3WK+++8Q9A+xky3iI3i3u4uF56AFc9lxhp0c4bdzQdcv3OPXpiyoFxOuQ51Y/BUShJH6BQ4aiNshOz2R8AvOTji7sYmGy++jpqqU1+YZfnCKdYvLFGf8nGrFTxX4jguru+jvCqOX0G5FZTrIpSHcjyU6yGVM7RhKsBBOlnEJ2sM1mq2tvY57HQJBgFVB6zO55oWY/NMldmYwtoMhA5DOBs7vEcYnS23DO8rFiuyUK1aa6SQ2CEEDaOYJDVY5VKp1qjWKgQxmDh7gd2K7H6gBPS6XcIwQNssxKwVGaDMZzo6TQiCAUopqq6P71dJB/3CPUjA8Fpw6k1azSnS9jZRr4tSEmmz0Ma1Wv07fs+11t6hNEez1g6A/3z4V9ZzjzjWrwO/fsK6H/4G5Tj7iHW/yZj54jerbzCvfNR5nztheQj8t8O/b7YM/4gMKI5b9/fI8ns+av/uN3vOk+bpE0000UQTfW/p34ij8iSVgQG8++C/6P4a51Isg6ayC+qk/IjF8xb3zR1S48BnDnNyB+FgMBiFfS2Wu1zWk+pc3r6ob/Si1ThIWV5WPlfZJVapVKjX6/T7faIoeg+sLQIX13XxPG+0LHdKFkFU/rtWq+H7/ignZBRFJEkyApnFMpeVg8rLly9Tq9UeyhEphGB6eppnn32WVqtFrVbj2rVr7O3tjcLU5u7P+fl5lFLcv39/BCqLLsb8XOX+ykPdlgFUOeRpsX211szNzbG+vk6r1aLdbmOtpdfrjcLPPnjwgBs3brC2tsb6+vpov/zcxfFV7LcyvCuO5XJe1XHtOm58lXNkjtu+fC2WHZTFcuf9Xg4tW7ymysct5ossXq/jrot83BpjcByHarXK1NQUjuOM1nW7Xfb29vB9n8XFRarV6qgf87GRHysIgodctuNeBBgHdscB/mKdxsHbok4a8xNNNNFEE0000UQTTeT5Xgb+jESQgwzx7gN+q0nCEKMtxgpS6TAIQgb9EMdqzi8vUKk4YC2+k3mgrBAkJnvw3+91OD46JOj3MGmKHOatk1LSqDeYX1rB8WtDsAGQhWtdXV+nExnWZ13cxjQP7t4h0Zo4NaSpRkiR5YcPA4JgQLt9xMH+LiaOcJVkqTXF2dNrLK+scfHxZ1laP8udjfv83//4H/PWm9fY39+j3e5meSdN5g5r+h4V36VSryOQzM3Nc+XKk3zsE8+xevoM586eYnVlkZ29Azbu32VvZ4darUaj0cSvVtndeoDpHmfzByGJkhgFPP7Ek1z6u7/Gg899iZUvfwZvmBdRaQnGYOIILSWJkKRCEWtNmmpSoUiEJQoDBhYOkoS3gx6v9jpsJDGJEFglkUJSrTVoNKbxKhWkUshhPwaDIAu9KyXKcQBDkhouXnqSF194gXDQQ4rMIWctIDLgCeBIiXAgMZYwTrh1b4NTayusrq0y05rHdxXe0gpHwGuvvcTdjS2Cfo9XvvZntJaW6fe62CjieG+bOApxlCRNNVEY0e/1sNqQpknWdnu7GCFZmJuhUpum6vtsD7qcPnuOQWefleUlWq1p7t26SbsbcOPN66yuLOD7Nb781RfxPI9z59Y5v75Go1HleH+XSqWK1pa9w2P8ah3XrTHoHSH77cyBqByE1ehKDUc5I7hO3CVOInr9fgZ6zXA+b2J85dBNYiID9WqFWCg8KWnv7TJXq7Oy2MJLLCudQ+qNGaxf4+V33uDe5g7V1PKMVMxojRrmmLRRDDrNXM29HnESIbRBZZ2RhVRNLSQdZLfLYG+fGzdu8nZzitrKErUz6zjz8yjPQQCeSKj5Cl9opADfETgin8/6uI6DVC5GZLlLkQ7CcRHKxThVzl54jEEqsEJh0zi77vXwmQpAmmKFHYZzJstlalKsAem4pDIewkiBkJkFU+gUO1xmRDbOjNEMgoBupAmFpW4NCAdcBxMcwTDsMFIQD/pYnYAFbSzDlJhABiutyHJRRnGI63osNGcwYY8kSYjiGIYhYB3P4/xsHb24RKPi0dvsE/V7pEnI9Mw8QRji17/zoHKiiSaaaKKJJvru1LeVo7L4mT+oLzquii678sP+3PmUO+bK25TzxBXhRx6Ssbh/GcCMK28RkBadhnk58xyNnU6Hzc3Nsc6zXN/IlVWGoePA0knOspPqUT7+uFx6xpgR1Cm6Dsvns9YSxzGdTmdU71qthud5xHH8EPQpuh+NMfR6PQaDwcg1V3bXlctpjMF1Xebm5lhaWsJxHOI4fqjPcuh08eJFlpaWWF1d5Ytf/CL3799/KB/h2bNnmZmZ4ZVXXhmFqK1Wq+8ZI3mOxaJDtAjd8uW5Y69Wqz0E+Ir1Wltb48knn+SFF14gDMNRea21OI7D9evXuXjxImfPniVJkodygOa5MYsgND+/1noUsrTcbnmZxzkp8z4pQs0yTCwuKx83L3exXYpQcdyLBcXzuK770HVXvsaLYWFzwJyHe87b96TroAhv0zQdvTSQ5zTNQ0vn/Vtsk3K/lUPv5mUYdx86CeqWw7+Oa+9imSeaaKKJJppoookmmqgopbLcktjMUSeGgMua4f/QQCokYcrQ5QVhFJEEfean6kxPzyDTbuamkhBHEUYEdNpteu1j4rCfwQo7fBHPWIw0IAWVagXl+UPzVUYqjYWq5zIzv0pva5v6VJ39bo+dvW1qFR8QCKGIo5DBoEe/12P/YJfO4T4Sw8xUlfPrq6ysrHDqzAVmls/wyltv87V/9s/Y393CGo1OLdoYKq5Lo1ql6rl4noPvOCDAU2CEQ28w4AtffJ5EGza2dvnYB5/lgx/7BOtry8zNtbh79z7bWxu4no/nZS/Y7mw94EgcEg0G+J7Hpz7xCX7p7/wa2w+2OX76CrJzxOy1q8gcxJisLTSSxFq00aRSkhhLpKAjBJvBgBu9Lm+GIfsmJRFgpUQqRbXaoDY1jednbYMdziutxXGy+YVUEmE0UgoGQQRAmmq2Nm4j5bv7gMQdRo8Z9PtZCGApcQSkScJxN2D/8JhKtUoYxnhejebcEvfu3+Po6IBbt2+zujzP27ducOMP/zX7B0dYnaKTmJmZGebm5rBGc3R8RBDG1GoNGnWfhWaN7a09TBwyVavQWjlF2O9htCbsdzja38GvVLj29S+xvbnBYUezvbnBD37qU3zoIx9FOD7b25usriyyurpCt31Er9unWqlgBbTml1lZWUVKhdYpaaqJ4yxMcTb3NSRxlDmKdcpUxUUYQ3d/E9bnSLWlWq2gbIq1gpmpKht3b3P24pO8evWrnF5eYuf+A8TRLiu+z5nmLHUj2H/nDb5y+yY7x23WE8OHpWRKZmMv1YYEhvlILbEGGQ5ItcUZviigRI4qLUIqjDWI1OBqTbqzR3//kPbNe5jFRcTZ84jFVXAqiJ6g7rskqUaiIU1QjsKVBmW7SB2jTILnO3hoXDSuAsevc/n8Or5McB2FET5CKAwCYyyptmA1SWqGzxU0eCk2TUnSBKstJkqxJkEbA0aDTZEIHMcZzlcFYpg4MkpBuS5oQZRYqmmCIyVxHJNYi5ACx5HoNEU5LtZkLygIIcBmOSqzeLRDEIlA6pR+v8tMo06qE1Kdkg7nzc88foFfuNTkhWQFi2G310VFA5omoi4NSI3W6XtvkhNNNNFEE0000UR8G6Cy6ELLf8P40K1FFQFGOc9dDhfKTqiTXIhFR1wRRpzkoCoet/i7mIfScRyOj4/Z2Nh4T5jH/JwnQchvRY8KwVmGJ0UgU/wr7iulpN/vc/fuXZIkGXvOvF/yXI95qE3f91FKUa/XycNpFl2lYRiOnJD58qKbMi/nuPMtLi7y2GOP4XneqM/GgVhrLbOzszz33HPs7OyMXJV5/c+dO0etVuP555/HGEOr1eLSpUskScKNGzceOs44SFf+LNZ3nAtTa83a2hrPPvss165dI4qyiWe328XzPKanp9nf32d3d5cwDPE8b5Tf0/O8Uc7F4lgXQozaIM95mQPOctuUnYhlGFkMf1p2aJbrD++6b4vXS17e/Hou5pDN2yBfX4TjxX3KLyWUx0J5/JavQ2MMQRA85PTNl9frWZ6TXq9HEATv6ePytT2u/uPaowhQy+2aj9tx19k3Ou5EE0000UQTTTTRRBONZDIHpBSKLJWcwA7DtxpjsMaSGEWiM3hihaTf6+JLWDl1htRavCRFCIvEsrG1TWJ3SJII33GYm5mh0phia2cPrXvkMM1TDjOtWXy/irWgc0dfmjA7v8DucZdG1SdIDJt3byGBVGu0tsRxRDjo0un12NvZpt85wlWChekGly+dZ25ukeWz72P7qMfv/dPf5v7dO0irs3x+UrE0O8/sbAvf94iTBKs1fsXH9zyCVPPWO7d54twClXoTYS1N3yX1m/zW//K/8tRnPsOP/s2f4JkPf4TLly6wsDDPvXv3qFSruMqhVq1RqWzQ73T5yR/7EX7xl36Jw+MuzraksbZG9CM/yt3dLRZ3NpFWYI0Bsv/ZEwWJMUSexxGG2/02r7ePeScK6AvAcYZOQEW9OcPs3BJerUGaxCRxhB2G6hWAdBQYi+u4GKtJdQaWBkFAvdHk3sY92od7IzepzedvJotMZBjCUCmxSZZXME0TOt0eSZoSRAHdzhHT88solTlz5+fnabd73Ll9j063h0WgHIdIa4Kgz1SjRhSF6FTjeS4Hx8f0jvaI+x2CaEAQpxx3+jiiy6Dfx6vWSdIErMatzeB6FXqdDo3GAu+/8jg72w84c+4xPvSBZ4CnOdp7wPXXr+J7CqkExmiEkPiOwpUSJQUGia8kdc8BkeVVzIykImNeRtOsV3jh5VcJo4jVhTkcKXAdcASZu9BYbt4+RFUbVH2f1PVROqXz9js05pdpBAOOd7b4k80HbIQRZ6TDT0w1WZKZ+1WrJBvHxhJqQyAlfQxBlBIZQywlWsphTkWRQX6dZLk7yUKuSgSO0ehOm3jQJznYI11aRp+5hJmeZZBkOR6l0EgLcUIGDXWS8UM8kq5EIkjCFITAcyNsmqCNxrFx1u7CUnEFrmNxTIqLRgmLR4IjBY6SeNJS9bK2RPhYO5x/C4WxFo0CkaVN0TZzP2ptaZ2b4lPrT4Lrsb3fw5udo7uzg04TpGXo2hTUm9PUPcHxQYznSIyV2b0CizKSVGt85VBTEKWaoNelUW/g+VWqaUqv38NxXT5+boEg6OEsLKB1QtjvUjEhMgmIjnepmJS4f/gXfQf+Ky8hxAzwD77JzX/HZqFtJ5poookmmuh7Tt8yqBwXXnKcsyn/Pe5h/0n7Ft2OxfMVARK811VWdKGNy1uZb1MsY/Gc+TkODg64f//+CGAWIUaxHo8K+fiNIGtR3yhsZPEYxfC1ZbiWwzBr7ciFWAS3eZvlx8wdhTnoTZJkBCx9P0tyHkXRaJs8V2AeIrcMi4p1KZ6zCPtc1x2Br3xdGRo7jjOCh0XYKoSg0WjgeR5BEOA4Dp/85Cf5+Mc/zttvv83NmzdH5TkpH2GxvEUwXnbEFY9RrVY5deoUKysr9Ho94jgmDEOCIGB1dZV2u83Nmze5efMmH/nIR94D8opjRimF67qjvsidgVEUEUURg8GAMAxH4WPHjZ9xELuoohMw77txYY/zZUopHMdBKfUel+K4NixeO8VrbxwwLDtJy1C1+H0wGIzC63qeh+d5o2201nS73YfC/DqOM3LV1uv1h/q1DHqLdR4XbrcMtnPwOm48l/eZ6K+u7Jj8JBNNNNFEE0000UR/kUq1RggwwiJE9tAfhvMNa8EapBy+3IhCOi7Cwvxsi6m5ZaLOPjpMUNKgjaU36FOp1FiYW2RhcZFqfYrDdpck3sCSzV+UkNRqdRpTM7iOh1ASYyxCgBB1jKrg2xi/0WR7Z5ckzqLGGANpmtDvd+h22hwcHNBrH+JKwdJMnaeeeB8zcws0F8/wtauvcPPG6/QHERXfpd0JmRKCZ95/menWPEiFsVldpRC4ykEoRS1NuXL5EhVXkUYxvc4xBxu3efIHfpSvf7XOtevXOT7c58UXvsaP/tiP8diTT1G7fIlao47n+yjXoTk1xad/4JM89+lPY+OA+vIsnuOxubXDH33+M9zcecDPac0pJbEpoCAVgp6x7AE3B5qXd7e4p1NCOXShSYnrODSbc6yeOcf09DyO4xDFId1eN5tH6BSVpjiOQipJkiQ4rku328baDDwmacrC7Dxbm/eJwgFKZiE8HcfNXLTWkiYpyma5NpWSSAzCzfIN3t14wKnVRVzXIej3CAZd9vd26fX674mjwQAAIABJREFUbG1tMRgEhGEGOpWjmJufxVGKmemZbN5kLJVqlSTN5klzM9MoqznsdKl6Fer1Ku1Bj0q9ibUJzYrCq8/y4z/zi7z8lc9ihcMHP/Qh4jBgZfUUUfeQIIy48/abHB9sc3x8RKVWx3cU/W6H6tQUYTRg895t1tdPoeTwEZOUICQCMYwjKpAya6P5hQVWlxbYOjqiHyWcWprDWlBSkMYhrnI5d87j+v3bXL7yLK+89FVWVpY5fuU14l6fmVTzZ1ub3BkE1ITgZ+fn+EijjqMUUilMqoe5MCNirQm0oactnTShpxM6QB9IhCDRBmGzPLHaGISVQ7AK0oKnBL5O0e02URgSHh+Trq7jPfY+nMYU1irSOELqFJ3GJEYzAuNp9iwjFQqtDUGaYE0WGpisRbJwrwOTOX2TFKs1whqUjZEYEiOQRuNi8BxwpcEXBinFEBAbKp6i4ih8J3MBu47CE5JGw0VJidYBAQF3Nu4RRhadxshhbFfpuNQbdc5NObzZ6YC1xKlBD+9fUglqrqKlsjy7QaKJooBer0Nzqonna2pa05qps6xSBpFE1KdJooC41+fs3AwV+mx3OwQGlHC/k7fb71bNAP/lN7ntnwB3vmMlmWiiiSaaaKK/RH3LoHIcKCm7voqwsAgAihCyDAaKGudyGpdLMAcg4/bPy1oGjsV6CCFG4Tm3tra4c+fOCJgUHWTl+pfhXNkp9ihgMs7p9ygHZV6WceUZV58itCyfo1jGYvjO/DNN01GI3PycOSAqtmOxfmVgWayH4zgsLCywurqKUmoURrYMCvPveTjWdrs9cjDCu06/OI7RWuP7PhcuXODs2bNsbW091G7F8VX8GxemttyPuYohSJvNJu9///vZ2dlhd3cXay1RFBEEAb7vs7m5yfXr1/nYxz6G7/sjx+k4p2Ne19zJmIeH9X0fx3HwPI/BYDDKF1oG6uVxU3YJln+XQwTn/VocA0VncrFNyq7CcW1VHuflMfao66c4XtM0JU3TUXvloYXz7fP1xTKeFEK6rGJZ8roXIfm4+9K4epfrkLflRBNNNNFEE0000UQTjZPO5x/oLPyrzkKEGgsWiyMkFc8lDgAUQip812Vh9RTSdek7NQIxhUQQeIpTZ2oszC/g17K8f6nWHB7dw6QJArBCIpXLzMwMXq0GUqKkQiqwxuJVa4RJwsLSMr1IE3aPMRaMtaRJzKCfhXs9ODyke3SAktCaqvDU44/Rmp2lOrvC81/9ClevXsWTFs9xWZuf5cL6Gt3I8s6d+6z2e6ysncF1PZSjEDLzqmlrsIBJY27ffcDB3i69MEQKyZUPd2gtLHG80WFzd4+D9le4c+cuP/+zP82Hvv8HuXA2O169WuPDz1zh9LmzBN02rpI4jku94fOZz/8xn/vCZzlsH9Mxll9ozrDoCUJj2TARbyUJyeo8X9/c4SgOUUoihIPjurRmFzl15iJTM/MoKag3GiAU084srn9Ev32M1knmhEwTlOtSq0O/18X1PLAOSRziuD71xgz379wCMuClhMqcfkKDUpg0xWKpeC7VikvoSKIoBgW9QchXv/4qF8+tMz3b4f6DDW688w7GQKvZwFUK11UkcUyaWgb9Ac1GnenpaSwQBAMODo/Y3drCdcAVmkZjijPnL5MmMc25JTq9Pssry+w+uEsv8fhbP/fvkvb3Od7fZv38JaSU1BsNpLQ06k3u3PgK1994hYrnUKtWkcLS6xzTabd55doN1ldXiLttnnzqGd7/gWdxlCRLiCqzBsBm8E+KzMWnJE89cZm7n32eG2/fZn1lEZVRdLzqFABTMx7O7XuoWhNPKVSzhXAlN7YO8Os13jKGMDXUBJg0YS+NqbtVpmoVGsrDSU3mXoxCojhhkCQMtEsvTThOU9pa05XQxxIZQWJA2nzOZ8AMnbNC4g4hnR9GVJM9uof79B/cx3vqWeTyKhiNLzWpsmBjDC4IgyNTYiNJbeZytsYiJTjCoNMs9yRSobAIkyBMNAwBmxLrLEWMtg6pzQC3DM3wxQYHM5qvS5QwuI5FYHGUwJESTylqTpA9czEx+31DPwjAqYHRVFyHWCe4nkdFWU4v1tk7qNIeCExqCJKUOLW4jmK5pjBhzFaUEluwJqXX6+A4LhXfR+uYQT/g/33tDmeWl4m8CvGgSxJ0WZzymfHn2LuxQSfSXHjszF/Urfe7RpOXayeaaKKJJpoo07eVo7IMRfLlJ4G3XDlQGJdXsgjC8t/j3EvjHFzF85VDYJYdlkWHF7wLG65du8b169cfgiTj6nCScghyksOs3DYnObPKQKgMKU9yCpbh6qNgavm8xhiiKBq51Ir1L4f2LIK4ceOgeJ6FhQWWlpbwPG8EKcdtVwRGR0dHdLvdUT8IIajX64RhOMq7Wa1WqVarAKPy5AAwB61FMFmGT+XyjgNOOTCr1Wo88cQTXL16lf39/RGo3Nvbo9ls0u12uXXrFltbW5w6dWq0bxEG53XL61TsJ8dxRjktc2DZ6XRGYK5YzvyY5WuwCNnKzuLyPkVprUeAsHicvD2LMO9RALjYtuXxXsz1mJchd+UWwXruohzXZ8V+ys+Xt9s4wDiu3XKVr5e8jOX2KYPM4v6PgpgTTTTRRBNNNNFEE00Ew6fPQoCxw+glkGqDsZDqFC2gXqtgjMWaFFdJWtNTVJotpIDG9DT1ZhMhJC0rQPJu6gYh6AcBYfc4y4WIRCGp16rMLS7jV+oYK1Ay/79eYl0fiaBSq3PY3iTWKUmaEkcROk3odjq0j48ZdNtIYZmu+jz1+GM0Zlq4U/N89aWv8/LVVzBJwmEYsdyaYXllnenpKZ586lk2upbnP/MHdN++wZnTp5iencdxXKRSBEHA5sZ9NjbuMQhCUg0pCldC+3ifpdV1jh/cRClBkkQ82LzHS1df4v7eIc99/ye4cPosH3r6Cq7r0O92UFKBVOwcHPJH//oPeOvGDRKThVl9M435rcMD5h1FbC3HAqhUmW13eeKJ9/HCq2+QpgkzrXlWVtZZWz/H0to67U4Xl4iZhqBWy3IIRr2UxdNLWKvxPJ9BEIKU7O0dUPGrKKno99uE4YDW7AK9XhutY4TMBoCQAqkkynWIk4Ruv48jJdNTNaSjWJyfJUpStncPca1mZnaa2xubsLHFysoy58+dZW62Ra1WRQnJ1u4eL7/yBsftHp3ugHa3z9qZ80RBSL/bRknB0vIyQdDjYGeTrZ0DpluzrK+tcfb8JdI0ptdpU5+a5YnLz7K8vMz9Wx2W106TGIXjKKr1JjOtOd659jLt4wPq1SrKGRolrSYMQzZ3DkmilO0H27jS8PILX6PZmmP97FmUtAhhkOLd1CPWWvJGOf/YY7ReuMqtO7d49ukrLMw2wQrAIBDoJCbY3+StWHHxyWe4cf11li9e4u3gGofnz+J6Av3WXY6N5cUgwHM9VDrAlw5nT5/mtBLIOMrciN0utUGfNNGEacJsmtKOYzrGcuxpjqOIbpIQao0VWehUYwxSCIQ2CGuwCFxhqFhJRQiqezscPf85gouPw/oZpCJrHATWJMOwrFkIVWk1DhGJlaRaIqzBWIM0WX5HbIq1Bp1knyoZYK3EIpFC42GxIstza5Fgs1y0FkuUaAwSR4vRDUdKiyMtvswS4xrlIqRmcX6O7f0Owho8JXGkQFoD1tKoV5mr+4RhhHYAJBVHMCXARCmHkSGSEs+xxNqSDl2V0EA5HkGo+fpml+tpgysfAtU9xg563O8F3A96HGmHrpHU5xf/om/BE0000UQTTTTRd4m+ZVCZu5GKIKMMDMsuJngYIJbBQRFSlsHaOBljRiEr0zQdhRQtA7uTXI35srxsvV6P119/nXv37r0HyIwrc76+eOxxwK4IaE4ClsXty8coh3sdp3K7l8t0EiAt9lsRIFtr35NbsXieMgAt919+HICLFy9y7ty5UVjRcdC5WNc0Tdna2qLX642O43keS0tL9Ho99vb2UEoxMzNDtVp9CDTlk/ZxkLycZ3EckCq3Uw48rbXUajUWFhbY2Nig3++TpintdpvZ2VlqtRq7u7t87Wtfo9Vq0Ww235NrcpwbtgyWPc976NxhGNLr9UZhd/P1RRhbPFZ+vCL4LfZPcRyOy4U57kWBotu1rPwced8WXYnlsK8nvdhQPlYxdC1k9xqt9ShXaT4mis7fMrgtX2f59xwaF/u7WOZ8zJZdl8VjFq+PceN5ookmmmiiiSaaaKKJclmRpTFItRn9P2ts5jfLoIKDkhKpBNZqfCXRjkQ5DhaZAQoyfMO7LAIhBLHW7OzuEAYDrDHZagda0038+hRmODcw1hBHMdJqao0Zqo6i3etxbmWWtxD0en1SnRIGffr9Hu3jA0waU3UVly+sMTs3jz81z5s3b/Hqa9dAJ8SpYXW2xQ98/ONUG00Qlo07d1hZWeWXf+VX+cPPfJ4bb7zAmaDP6voFOv0+b731JsfHR3i+hy8k3YNj4jhCYLl/9w7zFz7AK4kmDALsEBQdHOxzTAX/C5/j7//6f0KkLYNeD+U4KKl4sLXJZ/7oX3Hz9gYzs/MgbyBFxrx24pidJAOFCMGU62G8Bv1Bwkc+8CxXX3udpaUVWrMLSMchikLiKODs2jStmqBe8xHKQZo5qp6PEJq651CfWsUKyZ++0GUQOwwqFcKwT5KmrKwvs3H/HsIahJAIMXRVKkkUR3Q7fZI4oTEzTa1WY3G+xen1ZTr9gEatQhLH1GpVOt0+Tz5+iUvnz9JoNHFdF6kkEqhWK6Rxwv5xjzv3N+l02gwGA+7dv0+/12aqXsP3KxhTZX5hCcfzmJmZpzcY4Ph1tjYfMDM7y7m5Raam6uxsbXLj7bcJ+gH1WhWjNdPNJjv373C4v4PXaLG8pkjDLkK6BIMeU1PTKK9N/6ALQMN36fRDXn7hReYXFvArHuShTa0g1SkCi1AOynGoVBs8/cRlrr5xnRevXuVTn/xEFlJXCBws11/4Klevvom/MuDCxcdJjYVTZ/jQxceo9/d4p3/AO/c2Cfoxr0UxF5KEOSuIU8PtzTv0wpipWp1mo059ehZvbgkvifDCkPogoGUt7X6X6TBk2vM5GAw4jkIGaUJiDRqBgqzMVmKHEWylMf8fe2/6K0ty3uk9EZFbbWff7rn73t23d3aTbZItckhaluTBjDSSRhAsSx7NYGY+DAwb/i8Mw18MGzAGtsdjw4OxRhhKo4WSuIgUyWaT3Ww22dvt23c7+1Z1aq/KJSL8ISsP82bXaQoUoLGg/F1cnHOqMiMiIyILFfnE731RkOZsjEKab71Jc2ebxosv4DSqaCzjQUhiDDqJMXHqdI6TBK3txFsKAgchLEJrsDp9P4lIjMAmFkfEaKvQJu1FIyVSTtalhhRsaovWFoFBW5lCcSEQ1hJrjYbUjSktQifEcRoG1+gYgUVKgY5ijJQEgcu5+QoHnT4khoqSuELiCct+L2YsFZ6wGGNRypJoSzweMBSWwA9wlMIaSRw0sAJ6nTbtZpMHR4fptRmLkA79MPrr+ugtVapUqVKlSv0N01/JUVkM7Vp0KWX/8xCs+P40Z1j+uDyMKTq9suOmOZ3yTrKiMzCrK3vddV2iKOKtt97i4cOHjMdjHMd5pB358vP1TAOuH9XePEgtgqLT4FkRrBXryLdlWv1Fh9s0ODqtrNPyfJ72dxGWWmtxXZcLFy6wvr5+An7ymuZgS5KEra0ter3eSbme53HhwgXCMGRvbw/P81haWsL3/akwOQ/H8tCrCIzz7T0tT+VoNGIwGNBsNllYWGB2dpbhcHiS13M0GqGUotfr8dZbb/HSSy8xMzPzyHUVAWq+b/P3QNb2LE+n53lorRmNRoRhiOd5BEFwkucy3+58Psp832ZlRlH0oWvM91kWArY4t6fN+eI8+6j5mb/OrJ7iWOXhYTGM82lzLYOV1qZ5RLMNC0VNmx+nQf/ifMgDzNMgcwkpS5UqVapUqVKlSp2m0XCMkhKT+y6tToijILEWKQRKKiIdTUK0aow2WGFSsGEFQpICOJvmfMTCaBxx3DpCYNLwqgKqlQqLy2s4jodONP3xgOPWEcfNQ86tLnPu+hMkxuJL2Do6pnV4cPK9dhxGjEYDdBTiKMH60gxnz50jqM2w32zz2vd/wLDfI/A84mjIzUs3qc/OIZWDVAorLIdHhzRGA371Fz7PN86c49U/+yKHzTQXYRhHVGsVhNXs93o0O10SrfFdl4cbO3zquc+CUMRakyT6pN9+7rM/w+c+86k0P95onDo0peT+g3v8xZ9/hWZ7SLUxQ10qVpeWcJIRia7QbPcm0XjS/KDDcEy/28JaqPgOj9+8zv0HW9Qbc3hRhVarybDf5d1Bk/m5eRAW34GFuTpROMT3PFrdPg+29pmZmWNxbp7d9+/huj5JnCCFS6M+RxS+N9l0GuIqgXZg0O0xHI3TjZBSML+0SmIFl86vc/36NfqjMa7jMh4NwcLNx26yvLiA6zgo5aKcCagUoMYujcYMq2cvsX7xBq+++m3mFxaZm5slDEd0+0PkYIRNQsb9Yy5ev0WlPsMnP/t57r37JkI53N/Yplat88ziKnfev53mzjSWt969TaPqIk3E/s5Ddnd3WD9/iYtnr3Pv9ltsbG7QH8d87LlnuHLtKr/3H77MwcEhvqNwpODh5ib3793nwsULOK6LUmmKHSUFUkikkmA1xsCTTz7JB/cfcufOB1w8f4Frl85jrOHBe2/zta+/wuK1p3ni+efAcXnps5/j/JlFVgLN97/5DdYun+XMgy0+GLU4tIY/HAw46yWcCwKuK4d42McJR8h2k0BIZmuzLK1fYPbGDbzGLJXBAP/uu9QPd6m2jwmUpOo6tI2mZyxjYyBb91qdhoFVAkzqUFYYAqDhCqqtfVqvvsriz36e5SvnsDoN36pNGuI1jBPC8ZhwHBKFY+I4Jkl0mu7FxpgkxjGaUIeIJMFxHOIwBGMw1iFBIIRECzEJ0yzQpK7KdNODBTsJsysFsbFIBIbUua1tQhJFhK6H0RqLIQgUw1gTWkA6GAtrqwtc6gy4s9fBFxIdxRzElthzWQhclBAYowkTTaQtOjHESYh1HOYXFpHCYmZncawh6veoVgJmzp2jXq8xW/FxHZe5iv8f7bO4VKlSpUqVKvX/b/3UoHJa/kmY7iyc9to0SJcdU3TlFeET/Bj85F1SeefctLKKACd7LYNM3/3ud9nd3Z0KC4vtz6tYT/6a8/X9pHJPA0DFfp7mgpvWvmK904BwEaaeBmCL9ZzmkMvXrZRiaWmJs2fP0mg0iOP4kXYUy86AYhRF7Ozs0O/3T8CW67qcPXuWZrNJq9XC933OnTtHEAQncC1fdx5SFvswP1eKcy0P1+M4ptvt0mq16Ha7aK05c+YMy8vLHBwcnOR1bDabzM/PU6lU2NnZ4fbt29RqNSqVyiNQLt+WzI2X9Xt+DPLtklJSrVaJoojhcPjjME858JovN+8AzPdtvv6iazC7f6bNifz5WbuK7SuGsc0fUwT9xfHIu3iLwDwP9IX4cajY/GfCtHHN93n+GoqbJPJlFe+pfP/kNzWcNs+mQc9SpUqVKlWqVKlSpWKdECeAEDhSgEhzNQpr09ClQhLHCYLJRlHhYq0Bk2Cth7YWaw3CaqRI166J0VirOWoeEg466fGkIKhaqSBdn53dXY6bh3Q6x8RRiCMV9Rs30vyIymNrd49er5eGkNSGYb/PcNCj320Dhlrgc/XiWVwvIFEB79z+AaPRgKWZGp1xiFSC773zPg/3Drl66RKXr16nVq3iOAohBbv33uPzz15lbfUf83v/9l+TDFvUGnVa7S4HzWM6/TR/ngW0NXSHAwJXYpAIoahVfRbn5/jc5z7PL/3S32MwDAnHIY7rghC8//57vPvWm6AqBFWLjGL6/R4SgaMUgecghWC/2SFJohO42zpuolyPB/uWxy6ssrKyyO7WfYJKFcdafM8nwRIah9gkRElCbTSkH49xPcnmXosHG0ecPX8FhECoAJ3EOJ7H0vJK6pczFoRAmzQyjI1gOBzjeS6NepXBYMzs/AJx/zhF1lZz4dw5hEmoBj7La2ssLC7Tah2zu70FWIyJkMLBr1apVHw83yMIfJ65+jh+pcZx6wDXdanXKuhKFS+osL+9yfb2Do3ZJW498yLDzjEmGtHvtHGEw7lz59nZ2UEISxyFWGt49vkXqVUcDjbvsXNwxDgKae5t0NrfRI/73H//Hk6lwdb2AWfPLPO5T7/A73zxSwzDiPl6hVE0ZHN7mytXr4AFbTRGJ4iU9E3WUIYkjlFK8uJzz/BHX/lzvvb1b+DIn6EiNF/98tfYaXbw1zpcf/IZPv7i82y9/zbt432GKmBmYZb+4SFKKgwG5VXYawR8ef+YhTDkn587yy0BxnXBGMZa024fsdk5orZ5j6WXPs3a3/3PaWzdpP61r+LeuU2lL6mNBVVraccxXaEZYkmwad5XqRDolAUqhSB1NlYRXAgcqp0j9n7/DxA/+wWWb17F99w0RKujCFwHE3iTKGAJno0IR0MGQ4/IQhTHOMohjiIGwyFSWKIoJIpiksRgjUYnaYShRBtibYlijbaCGEFkRQotSdfaWgg0k/Ur6brVVeCLhJGJ8aTElS6NAEwEEkMYxVQQ1DwX36T20SECVXWZ9x18mTq6BQ41C0ZYtBUor8Lq8gpr6+vMVHzG0qM+PODsrId64RaEQ6wVCCzH3QGdbuc/xsdwqVKlSpUqVepvgP7KoFIpdQIIiiAEHoUWeRBUdO8V4cRpoKz4XhGqnRaK9jRQ6DgOw+GQ27dvc+/evRN33DRwMQ2OTDsuf93T9JcBjEX9JKdk/pjToEqxndPqmQY2P6re/Jhk52RjXalUuHjxIgsLC1Oh5mljHccx7XabMAxP3nNdl+XlZZrNJv1+n8XFRdbW1k5yGhbbOK3vitCsmMc0D7uiKOLw8JDd3V3a7TZJklCv15mdnWVpaYmZmRna7TbWWgaDAUtLS1SrVY6OjnjzzTc5c+YM6+vrJ/k0pZQ4jvOhcMRFcJeB83zbpZTU63UcxyEMQ7rd7tRxKwLH/PXlQ9gWrzlfxrTxnHav5t8r9ntxLpy2IWHaOBXzaObnSHYNGZjOh149LYxt1qenQcnT5nSxXcXff9LmhVKlSpUqVapUqVKlII3eo2ONFZAYi7UxsTGpq9JNv4/GSULgBySJxTEhQgq0SXAkOFYSa4NJWSRCGKwRDMOIo/0DrJl8352Azv5wzHvvvU0URQgsruezuLrKysoq9aV1pBQ0O10ODvbxPB+LINYxo/GYfn+ASSIEsDrXYHZxESeocn9ri7DX4bErF9Gx5lLgcfbCZSqL5zjudInDiL2BRfbaLNR86oFL7Che+fY3WZut8S/+m/+Of/2//0t6+w8ZhRFIhe+7VKtVXK/KaDwiMmCNIdIapSSri/P8i3/6T/mV3/xHdLpDjNY4jouxlrfe/D791h6PP/MC9+49wO7tghgyOhozGPbT7+gWqoHP3GyDZruThsEVacjKo8MDzqyf4/2NPZ66cYnbDzfZuv8+q+cuEQRVAJrHzckawbC7N8QajTVpbkaEQ6d7jNFpDkYhBOPRmCvXbqZuRgFSSHzfw5ESsMSxpl7xWFuaZU9KHOURC4vrKrrdNoGvsElINNLEwy6Nc2cYuwKJZntrl3EcMTMzy6WLF7l8+SKtdg+lXHzP5cWPf5w7772L4zhoY1FSouMxC4uL2KuPEzQWcByPfrfFG699l/4g5OL1xzhqHjI/O0Mcx2zu7pGMBzgY7NwMm5sbNGp1bDzGCI/D7Q3MsENNKXr9Hp1mm8uXr7Iwt8S59TUebG0zY30cJdnbSzf1Oo5KAbxSWGwaghcAiR9UMSbh3Nl1nnrsBq+//T5/8e3vMCsS7m/tY2PDw3ff4Ufff51r165y+cbjPHjfEMZ96o0FOr0Q7Tgo1yGJIi7W5ritYKRjmoMBkevg2DRMcowgEQIXCIc92l/9Yza/+00W189xbn6VhRtPsbh9j0rzgEBIKnKEH0e0tWZoICINtSqVSiG00SmkFhKrHBZX61R7I6qDiM0/+mOi7qdYfepmuga1Os0/m0TEUYgBIh1jdZobUugEG4+x1sFTAlnxSLTGlRB4DjpJN0cbmz4n0Tp1d9ps8y6WJE7Amtx6Oc0jGWtLbGAYxYy1wJgEaTSVikdVeWg9ILQaaUyadzUacdzpIaRlZCVBo4bnSJSwKOXgew4gCGozNAIfTwmiMCLUYwbNA+qLc1TR6N4e0mikcsAkuErR6XbpHfdp9YZ/vR/ApUqVKlWqVKm/MfqpQSV8GArmX8+UwYHMfZaHHacBhaJbr+iEmuaOyo4rlp8HC8XQm1JKXNdlc3OTb33rW7Tb7akwMjv/J4GW4uvTHI2nuQk/Sn/Z4z8KGhXbNK2Pi9c2LfTraeVNA19BEHDz5k3m5uZOQnTm68t+5iF2FuY0ywGZjZnrutTrday1jMfjk9CvruueOq+mQbKPArXZNRhjGA6H7OzssLm5SRRFVCoVarUa1lrW19c5Ojqi3W4/AjY9z8Nay+3bt3nuuedYWVn50JhnOT+zfKrFkLTTwJlSKl3Eu+4jEHfafMq/lt9A4DgOlUoF3/dPhYp52Jcvq+j4LIaXLYauPU3Twi7n78d8WN5pGw2y47MFWBbqNX9c/h6ftmGiCFl/0nwuvp6/luJcLlWqVKlSpUqVKlWqqHEYoY1O3VVCIki/z7rKwXEkQjoYa/Bdge/HOEkKKeIoAjdBKQchJI4UCCnwXBeDYNjuQDwi8BwEAiQIBAKNErC4MM/8/CKzC4tUggoL8/PoyjyuF9BsboG1aWhKrRmNhiQTkALgK8n59VUcxyU2io2tLTZ2D6h3ugz6Q77wqZdYaMwwX3e5dfFxKnMLDGLBg80djvZ3CAcJvi+4t7lLc8/yjz7+Er/2W7/N//O//k88trLOaDzGU5Znn/sYXqVGGMe5blsjAAAgAElEQVQcHjbxKhUEktlGnf/y136NX/ovfot2b4SwpG3Rmm9+46t86fd/l+du3eKxp55juL7OcDjAWIs2qRMNAdpaXAmzVZ9wHDAYjrA6JVdRHNE83GP1zHne/eAhT928zOvvvM/R/jbL6+dxpIO1BitlCoSUi5Uu1mgcX2KNJgqjk3C+iBRkzc4vsLuzg+c5RMMEncRYIfE9h+efvM5wNKbVOubMyjJ+4DPqWMajIc0kot1qIZWDUoruoMeDhw+xJg3zqfwKZ9fWWVldY3HlLJ12k8XFZSIt8IOA5ZUVwKLjIa5ycD2fQb/HcDwmqFaYnZulWq2w/aCJEYpmb8TBa6/z8U98gkG/TxSGrK+tU6sFHO5tsvPWfYa9Njoa4SoXIRzev/sQkSSszs2x4Gm27t1leXmZG489xvr6OncebBLGBs9R9Lp9RmFIVXiAOAnVK4QEBK6jkMICHo5y+eRLnyDS8GDngK3WEePIgNHo4ZAffPMbPPviCyzUb3G0u0n7+JDzZ5apL8yzsLLEw90mwyhk0QrmfJfWKGGoNWPHQcYJu9GYP2u36UrBhaDGc7NzrOsY7+iIzv4+W8Dy4ipXGjMszi7jKg+3c4RnwSOmjWCQJITGpMARcxJiVUiL5zs01heZn1/l8uWb1H7vi9z+xte53z5m9uZlhKMQFrSO0TpJy5g4po1OSJIEoROi8TCdc0lMYgXaWIw1WAtIMInBVRJHTDbVuw5SpRsUHD/NfZnmqRU4gE8aKhqdMB6n4WA9x0WiEaKG0BorFA3lE3iK0SiCMKQ3ihgj8Go+vpqsixGsrK2zWnNp94dYC8loyNgaQg1xOKZ/eMxRs8Vyw6ei0s0XcRwRxgnjWDMcR3QGId1QT/+gLFWqVKlSpUr9rddfCVQCj+SEK4ZfzcOGDGgkk5j7eViRPycPrYohHDO4k3dH5evOjj0NdmTvZ21TSjEajXj48CG3b99mNBp9CBRNK6fogstr2vlF19pHnTfNvVU8/6MgadERl71eLGsasCsCv2LZ0+rLVOx/IQSNRoMLFy7QaDSm5oYsugellMRxTLPZZDQaPQLKfN8nSRLCMMQYg+d51Ot1lFJorU9yX2ZlZkAwq0spheu6J4AvOzZrR37eZcogmFIKz/PwfZ9arcby8jLj8Zj3338/3VELNJtNkiShUqnQ7XY5PDzEWsv8/PxJONbMUZm/3jxUM8actN1aexIqNwONmXs0SRL6/T5RFH0o1OtHweD8uBbzLxY3EhTHdtp9l9+oUHRsFkH4NBf1aRAyu+7stWyMsvHIxrh4L+bnfTH3bb5fpjmOi8C2CHOntfkvA2dLlSpVqlSpUqVK/e2WMel/SL9Xuo6D77qTlA6pyzLWGl/EeA44Ns2B5ymFX6mQaIsjQclJXnmg1+/ROtxNoYPK1jSKarXC3MISjbl56vUGQjkgBNLCODbEdoCjJEZHSMdBOQ6JTgijiHA8Rk/clAszVWYX5vCqM+w1O+ztH+IICGPN6twsC0urJAb2Dw45ODxECsHMTIObFy7x5PWXuL99wN7mA5546lnqtSqtseH6pcv83C/9Or12m/29HZJoxM5Bm8Dro42mUangui6+6/Dzn3uZf/Drv0GnP0YAjusyHI/5kz/+D/y//+b/YnNjg92tba7duMGFx5+l1Tqm3W4zHA0wOiZlh5Jo4karVjxGUUQSp88TDJbeYIB7uMfi6llu39vg2Seu8/qP3qNaq1NtzKN1gu8H6fd9pZDGkFgQrodOYhCgjMVxHUbjEbOzc0RhzGjQQQmJjtMcg5V6wMrSAgszdRYWZrEWapUqipRAKddHKME4CvE9ged5AMSJIU5gfm6G+cAnMg6+H7CysszS6hl64x9ihgOwGtdxWF1dY/vBnRR2Og6D0RipJIEXcHh0xJf+6PepBj5+rUGlFrKwtMxxp0Pr8AAlBOfPn8UkCmEs7aNDeuOYK4vrOHbMK698i93DNguNGerzqyzVFBvb27zz5htcunKFubkZrLUkRlNzFVEUY6zA8wIQEsdRWMsE1JNCZZ0gpcJxJPVajc9+6hN8+evf5iiopm3Y2wPg4Ttv8fv/57/C/+1/TDC7THR0AH6V9Yvn2N3dZ2amzv4gpNfp8/j8DN8aNRlbi1GKWEhec1y+n2gSa3goFL31s6wLycVwzMrhEX6vxfBgh/3DHdaqM1ydmWGh2sA1BmUtvhB0haWnDUOjSYQAJSf5QgUkmqgfMXs+YPXpxxDbNxj90XfYeO0N9rsdKtcvohw5WXMnWGswOsFM8rDGxuCo9B61xqCtwdrUyWutRSiJZAJGhUApgdZ24hBOwxlbKVPXqgV4dO1vjIfvuHRbHTrhiLlGDUcqhCe5fmUWISRRFGOtoR0NkfMrBL0eyvXwPQfH9fB8n5mqzyhOUBiOO12OOn1CbUA6SGsZRDGdfo+jIwfPESSJQU82UEi3ghc0mJ1bZdkL/to/g0uVKlWqVKlSfzP0U4PKPJTMoEEac19/CFrBj2GJ1vpDECmfpy4PFYogIQ8Him7OopMuf16morvOdV0++OAD3njjDfr9/iPHTwM++WvP158/5qPanddHwcY8cMmDkyKELP6e/Sw6Wot1ToOV+faeln/0L1N+1t5KpcL6+jpzc3MnkCkPuIp1ZuX2+322t7cJw/CkTM/zqFarHB8f0+v1UEpRmSxk8/MoUwb7ijkYi7kNT4N72TkZHASo1WrUajWCIGBmZobV1VXW1tbY2toiSRLG4zH1ep2FhQWGwyFvvfUW58+f59lnnz2Bifm+yvqh2JcZNIzj+CQnZaVSORmXer2O67qMRiNGoxFxHD9yXtb2/PUVXcfFuZKHjdP6KevfaVAuKzuDiNPuH+BDDtJ8P+ed1MX5kT8u+2zJgG/RhZrvw2ljWhz3Yq7SaXA2ey8bv/zv+TaWKlWqVKlSpUqVKjVNljQXpZQSISVSTjZKkrrlLOka2aJBQpI+2ceaBCy4SpIYwzgMGQ26tI+b9DodTBLhOhLPrzI3v8D84jK1RgPHDTDWIKXAUWmoRq01vu8hpEuUaOr1BoNBP815F8foOCGKIqxOcIRgdXGWoFrDr89zeOcB/X4f33HojcZcffw6lVodISVxFFGp1XArNQb9Hrdvv0ejEvDkrVucO/8pVmcq3HzicYJqjVFsWTlzFmMM/f6AnZ1t3vrhD3nwwW22djdZnqmiZtr88s//LP/8v/5vsW4VAUipOO50+YMv/jv+3e/8GzY2NvBdh52Dfb70pS/xm2cvsH5mjW6nneYsNAa0QThgBVQCF9/3MBaanR5CgEJijaU/HFLpHuMurrKze8iTj13jzbff5/xFhV+pYXWS4kQpUzAkBUanYTCNMbj+5DlIHLMwv8j+3g5GxyQmwYo05OmTj13n1mNXaLV77O/tc+3qFVbPX2F7Z484mmP14k2G/T6H925z8eIai0urBNUqjuvhBzUGvWOstVQcDy+oUqk3ODrYY/3sOR48eMD2gzvMLyxRrc8gpaBSrTIcDLDW4DrpdSslUcphGEYY6XPpyhUcKXFdB2ENg+GI7f1D9HiAz5D7Gxv49SUqtRkev/4kN24+xr/9nd+j1x3i+AGV2QYvLM3yymtv8s4Pf4hyFBaD1QZHOQgpCSpVglrtJDQupI5gay0mSTBGpuFTpcBzfOrGMD7YpjsSNNYvMgxjjlotkiji1e9+h7ULF/nl3/gNovGQZqvD5ceeYG9jk+WFOXrDkAeDIZ9YmOXdakDsOlgBEYao4rO4ukKr1cIKQS8M2a3XGC2eYe/sWfy7H3DhuM3MsMeo32F30OWiX+FSUGFJCLwowhXgigQnMQysJck2tjoSjKW/38aO3mbw4D5Rb0DDdTnnxGzffp9hEqEurGKFBZsCRp1otDEYrdGAFkzgeuoENsaS2MlzGZMghMR3HaRMAaZAoKREYImjmFavj1+tM1uvIoREMnmuoxwEGq0layvLaGMBSxQneJ6XPk9RikrVQRuD8OpcdX3CUT+t26ZzHWuIxiGdTo/9VhsrJI7n4xmNQeK6HsGMy8zsDAqLdFxqFY964OEIUJU6nqPQRpBoc+pnZalSpUqVKlXqb7d+alCZOckcxzl5aJ8BliRJPgQy8y63PJzIlIeTH+UazI4tQpT8e9NUPCaDK3fu3OGdd955xEV1mnvwo6DntGOK9RbLyru98mUW8xieBl6ntXUaUCqCydPcltPKzJ9b7KNp8Cf7e35+nqeeeop6vX4yJ6a1Kw+Esnyh9+/fZzwen/RBtVpldXWVZrPJ8fExQRCcANCisnPycDL7uwiisuvJ51bt9XocHx9zfJzuys3AepIkDIdDjDGEYYhSiosXL3JwcHDiAAzDkOFwiOM43Lt3j3feeYf19fWpgDTvKM3qz8Bo5qhUSuE4ziPzJDumVqud5KjQWhOGIWEYnrxW7BPg5Nj8xoDsZ7bJIH9uEaQW50oeiuavK19n/vX8/M73f/H4/BgW76msTXnY+FHgMLuerJ+nOUeL91cR9Gb1FI/7KOBfqlSpUqVKlSpVqhSQhgUVP44SUvFdHNclySLCWEWiDaNxNwUWBhCCKIpRiWY06NFqHdE9bhFFIUKA73nMLi6xsLjEwsISfrWKVA42Tc2IS7q2sBO3lNaG/Vabubk5emHMaNAFJGEUE4UhcRQyDkdgDZ4jWVmcpxJUGYcJreM2Ok6QVR8Hw8rKapoD0VqqtRpXH38yTVGRJHS6x/TbbTrtLp/82ZepzsxiLAzGCWEUE8cJ1mgksLayTPWlTzC/uETCKxxt3+fFlTm+8F/9FigPaywIwe7eHv/+d/5v/vAP/4CdvX1mqgFCSqxJeO/OB7z7wzd57lOfYXFpCT+oAgKNxSaGwHURQqKEIPAcapWAURgCAiHAcRStdouZ2Vn6SZ1Kb8DN61d4/+59rl57HKMkJheCU0qJUAaJxJEOlSBAJ4Y4CqlU62x/8B5gECbB8wL0OOTK5SusX7zGwfGbLC+v0um0uXn9BusXbjDTCBDJmNbeBk898zEu37jF/PIyjuMAkoPdDeJwSJxoRsMhe7Hl4jXD3s4OVjoct5ocHx5w9/Y7PPn8J/B9n9FwgNEJ/iQqULrJU6F1QhzHeK7CWk1/MCJJYpSUzDRmuHz1Km98+yvs7u4gkLzwzBOsLc6grUcwu8rf+8Vf4u4Hd3lw5x4ri4vUG4pLZxa5c+c2ifLApiFdHSmpVmrMzM7guh6O6yBhEjYVpBBY30MYg7Vmsga17O9ssflwm94oQV1xWb54iWEc0xr06eqYP/vql7n5sRd56fnnePv1b2K8KpdvXOPd9+4wSBIGRy267Q5PLs3jKg8jIRmNaLVH3Hjp77DYqPAXX/0Sw26LauDSarXoOgqWlmhfusJaq8Xaxn2qvS6DUY/t2OGKH7AiBDKySGtQysHRCUNjiaXBJCl4HMcRUadPd1eSaFC+w0zgkhjL7oMNRoGLna+hrT0JuWyMRmuT0skM5k6WlUJYlLXoJEnDC0uFEgLUZA0qBMIajBYo12Vhfi69J6xBIEFIEGoCPtPnF8JxUUqAdAikg7GWRBuEtlhlQRh8JcFqvIqPsQaTGLSJsVYghaU20+DyzMwkjLXAUalDNn1mIUGA77kTOJ3eJ1I5OE7qEveVQH/4EU6pUqVKlSpVqhTwVwCV3W43LcBxTkK5GmM+BCoz56Lv+5Mv3Cnk9H3/EUdcXpm7axrsyMOFPGDKH5eVkS8PfgwAM2ixu7vL/fv3aTabH3IKZudNK2+a+6voeCyC19N0Gsg87b082MnX81FwtwgZ83Wcdr3T2jTNUVcsKytjZmaGa9eu4fv+CTzLO2+Lx2f5QsMwZGdnJ/0yPWl3o9E4gYLtdpuZmRnOnj17Mu9Og1x5IJV3Dp7Wh9Zaut0uDx8+5OjoiCiKECINv5M5PKMoIgxDfN9nbW2NWq3GcJgmhB+NRnS7XWZnZ2m1WmxsbLC1tcXi4uIJcMyUwUit9QnEzc9ppRS+7z/iDM2Pteu6J9evtcZ13RMQNxwOH8nvmZ2T9X/eHZh3K2aOzOKY5/+eNo/ywDJ/L+brzuqcBgHzZeevs3j/TNtIcJpbND++eRXvmeLnSbFN2Wv50MLFTQQ/aWNFqVKlSpUqVapUqb+9UjJ1s6XfK9PcczaKUpAgwXVd3CDAjQw1GYHnMRCW7Z0d4v0jRsM+1mhc5dKo11lYWmZxMXW7OY6DVKlbTUqB56QOKazFaINOuQjKUZhIo41lOOyTaI3A4ghBJASJTjCTNZrnODQadYLaDMftAe1OF4xBW0ujElCrz6TrESlZnpvHUw7GgqMclhaWWJ5foFbxOdzbYtkaZhYW8bwAP3JQShKORlijsSbNt7m6usrLL38GX77Mx178OFoDSQICNra2+D/+5f/M1//8a3R7fay1DIapa29+eZFLjz3DG2/d5saTT7G8vEhjbg7HSXNJam2IE4OVAk9KXMelVknhTBRFGRNCKMHe3jYf+8TPsLt3wJWq4vzZde5/8C5BtYrv+Tiuj5TZulKBANf1SMIRmWM1ihOG/R5B4DIKIxDpptTvvvYa9+/fxTo+n3zpJVbWL3DzsSeZnZul2+2w9fA+4dUnWFhcQShF8+iAwA+YmZtnb+sBYnzMhcvXGOkah4dNbr/1Br1hyNHRPrs7u0Sx5v3b71KtzzA/v4A7V8EiGI1GSKkIKhWsMSRJjOcoLJI40VQqAWEIURSztLrG1t132dveoH3cwZWWw8076N4hK+uXWDpzjqWFJRrPzjDsDpCOyzCB555/mgcPv8TOURvPUVQDF60tC2vLOI5ETcKj2snmZCkkQgIIrEjngEAiSNh5+JDBYIS1cPDgLo1zFzh36RLi4UNGYcj+4T5/8id/xNPPPMvqmXPs7h9w9uJl1paXOGh2OYw17w1DXl5aY1ypwHCAVCBNwp0fvkrjE5/h8cdvsvngLn71Gjdu3GR38wGddpt2NCZZXWK76lPb3OJ6v0fU79IZDVlVLpcnjk+JwBXgacPQWkJrSYTAGkgiTSJTd6QSLokReI7HHJbQGMIkIWWMFmEtGBDZOl0KLBpjBMZmrssJ0AQcxxKFFq0kSspJ8sns+YbGColEIiwYqwENxpCIiWM1qJAkMUlikUqCsOkYWIu2Gm0nbmHSONVSKqRUKF8hE4lONEaCJwVSOmm+XKWw1pAkBgmMwzGuH5AkBiXSzxOpFEpqTBwhXRdXqsn4lypVqlSpUqVKfVg/Najs9Xonrq/8w/zMsZQHDK7rkiTJSf65OI4JgoBqtXqS2y4DntPyFmblFcOtTlMeRuX/Z+dnAEhrzZtvvsm9e/c+BF/y5eQ1DQpm52Zt/kkwcBoIOq2efDs+yvVYbFvx/dNcj6dBndPg37T3i+0wxuD7PgsLC8zPz5+8lgGlbK5kIM2d5GfJnIJJknB8fHwSKlRrTaPR4PLly9y9e5d2u82NGze4cuXKI6AyD5mK/ZmfN8Xfi/1ijGE0GtHr9QBOYKHneSf/HcchCAKWl5dZX1+n3+8zGo1IknSXaqVSoVKpsLe3x/3797l8+TLVavUE0uXzUEZRdAJu832ah2R552cGJotuRM/zsNYShiFJkjAYDE7CsUJ6DwZBgO/7j9SRB+7FvLKngfoi7C0CwryKc6noaMyOye7x7DNkGhDMg8ysvVlfZv1UzJObH+O8q7eY/7YIL/Ptz19nEfRm11SqVKlSpUqVKlWq1DQJ6WCMRWJQTuqystbgKnAcD20MgesxP1PDGhj2xyRRwsFxB+V4VIKAmYVllpaWqTdmcV0P10ndU8ZolOPieS5SpbnilKNIjMEajSMFFd9LXVleBSEVSRRhjcEgiJMozUspJhsOBfiexA98lF+l1drkuN1BSUi0YaFWneTCM1T8gIXlFcbjMZ7nY4HEWpQUdIYRnYcP2d/eZnFhDr8xh/DqdEch48EAJVOXYjge40vLM08+RmNmntFonDpQraHfbvKNr/0pb7z2KlEUYrFYC2GUkEiNiWL+7mdeYlRZ5O7d+zz17HOsrZ9DOS4miRBCIqTAVS7KdVHWoBJBreITJzp1tBmDKxVxEmPDPi999gt87y++ys2zCwwGfe7dv0+j0WDlzGXGwwHGJMRxQpLEYA1SCLSF8xev0B8OEIITSDgcDjl/dp3nX/g4L3ziU1y78Ri1WhUpVXrtYYg2lqef/zjPfvyTxNGY0WDAaDQgHA158MF71OeXOdoZcOf921y/cZOnn7jB3QdbDIZ9BJKFhQX29g/odlpsPLjLL/zir7KztcGDOzEbDx8wM7dIUKkz6HdR0kF5KVSt1OpIITk8GLG4soonNB+89yadTps4jjlqdRmMQ156fpb20Q797hHzS+eQrsvVq1c42jsgjOHizadYW/0eW70dqsolcBWDwZgnr17Bc5wUkGYbWW26ZvI8DyEna8eJq1VYw+a9B2loUinphmOOHtzn3MWLLJ5Z52Bzg1ES86Pvv8b3vvc9PvvJj3O4v0uifM5eOs/2zj7bruRQa44O9nEqFYakPE9HCeiEH77+CmdXFpDKY9DcZnnpZV7+zN9hf+shd99/j+2tTXpGM7xylVgoVnc2WdraZBxFNCVcRLEkBdJaHAcCo+lZw1BDIiRaCKxyQKauysRYEiUZr8yR1FN4Dim0tXZyv1mDTQyRjhFCYq0gNgnWgLUCK8BJ0zwihEUJUjejIQ0VLURqyBTmxHkJBm0mm5GtSHPRSgejDbG1+CIF7cYmYDRRYoA0DDCTtuE4pP7XdF1sACsUcmL6TBKNGUdoC9JRCFdQqQQoqdJNAkma+kY6Do5SaW5Sx037pySVpUqVKlWqVKlT9FODygw4TAutWYRmSZKcQILMQZY50zJnmO/7JyAogzhZWRmshEfzQ+YBTvZeHkJl7ZoGPbrdLrdv32Zvb+9USFcEmNOceJny4KPoAMuXly9rmjOrCE6mOdiK4PAnucamgcVpoDHfhiKAKh5ffC8Pbs+cOcP169dRSp249DJA7LruI33rui6u656MewayjTEn8yADn9m8qdfrrKysnMyL/FzIxj4/J/L5DfMOxHz/Zm7fIAio1WonALVWq9FoNJidnaVarZ44IzPQfuvWLfb3909clXEcMx6PcV2XdrvNw4cPcV2XWq32CLDN8lpGUYTW+gTS5+cs/Nh5OW1M8uOqlCIIAhYXF/F9n1arRavVOgnRnL8nivMve68YHjXrvwwqZ23Mz7Ps3po2r4vwMrv2aa7L/BzLNjVMm5+Z8nk/rbWPuLNPczlmYz/tGrL3i+GAT3N1TrveUqVKlSpVqlSpUqWKcpRIoZkFhEUKgRAKIRQWwFpiY9jrxURRQmeo6ccuc4srLC4uMzM7hxcEJ47MxE5yAQoXV4CaOCmtzL67GlzloKSaQIw0/OLQCLCCSn0W+m0MEEUSnaRrJawBLL6jiOKEwThmb++QTruDN4EWjeVFhHTQNk1JoZ0aYa+T5rETKcCI9GQdK6Crh3SHY3yvieNIhONjpQtSYYxFWMP5c+v41RkGgyHGpjn03v7RD+D4IW+9+T0GwyFCpDn8DJN1ELDX6fDf/4//A5/7wn8G0ueJJx7nxs1rNBaWOd4bISdrjmqjgXR9ImOQUYKrDL7vMBwlRHEE1sF1Xd599y1+4e//A7rdF9h4902evH6F4XCYrqmGbdbPX8EaQ5Sl2rBm4ipTzC+u8PDBB2Ato0EfncTMzM3zm//kn3H10kUuX7lGHEd028f0B0P8So3zFy5w/caNNGTucYtur0ur1WQ06BOHY6pBhXqtwsr8U3S7XY6aLQb9AcmwR9jr4rgVqtWAs6vz3LvX5tKVq2Atc3PzPP70x5hbWqXbbpHomNgLsMaSxBrHC1hbW2dvewPX8zh35gzf/dofEEVjVleXGPR7OI5k/7DNfrPDC8/fonV0yNtvv47yAh5//Hl8z8OamAd3buNXPJCC2VoFjCFCcfn8GaSJAYGB1JFnJ88QTILruCnxshYjLeN+l729QxACjSCyljiJOdzfYe3MOeoLiyRHB3TaLb7x51/hxRdfZHZhiWa7y+XHHufO2++zvrhApzfmu90BtzREtRqBkviO4qmbV9h++ACrYz7zwtMcDyO++Lv/hk81/1M+/fLLfPLll9n+4L00vPDBET0vYHT+IvcQXG42We0dMzCaNSm4oBSBtrjC4AqBY6EvIHEUWjC5Ry2h57IxP0NvzsckOgX8wpyARmN+vNnVmAw2gjVpDsr0dp883wAwmthOnJAYLOnnikRMQksbBDEI0rCwljS8axSmXS0kSEWYRCDEJPSsRicGpCKJ1UnYWBEnaU7NbA08+YcAI0jznvoBDpO18mRjhFEKKeTkmUl6o1qbbkoQSYI0FpMzJZQqVapUqVKlSuX1U4PKOI4/BNryECD/oD/LXZk95M9gSPZaBm6UUh9yTWXKQ4NpACIPCvPHFcFMFl707bffZnNz8yTE6GlAJDs3+5kHM0VokT+3CF+mAcxp9Z3mBizmyJtWV/71094rnpsPK3pam6aVe9q1a625ePEiTz/99AmY9n2fIAgIggDHcR4JQZo54jzPo9VqcXh4+KHQsJnbNgOYQRAwOzt7Ul8GD4tANw/Ri6FOIQ3jmu4A9giC4ASoep53As7r9TqNRoN6vU4QBCeAM4PrN27c4Ec/+hEHBwcnoY/b7TbLy8tEUcTBwQF7e3vMzc1RqVTQWjMajWg2m/R6PZIkTWRfqVROys7GJeuHaXkZ8/2Tn/NKKer1+kkuzQyGFvso3xd5WJmNSQYUM9Cc3dvFUMf5ufBRMLsINLP7e5ozMx9mNfs730bgkTC1WZvzsLoIQIvhYfMgdNrxxb+z9k77TCnOvVKlSpUqVapUqVKlMmVrAGEtynGQjouwBikkGXYIfEHsXcDVmnnXwQqFTmKUkghE6lTCTsK8ksIJbOrODBOsGeK47omz0UzUIucAACAASURBVFqNSUkFjuORxDFSugjlIG264c9OgKJUchLONP2Om8SGcBSS4NIfjUi0xmLRsaYy2XhqEczNzCLrswyPDtN2ThxzZuLKihON0YYQiBODFKCcEEcJotjg+wFXr13DCeqMRiOwECcxdz+4zZ99+Y959Ztfp9PrAQrX8Ui0wZgEJl6vJEl4uLPL733xd7l16xmaB/8J6+vnWV5d5XhvIw296rosLa1w/sp1br/zIw73dhkYQ+C5CARRlJAYjdQJ3f6AV77yJT7zS7/Jn/R7bOxs8PFnn+Rr33mN7e1NPNdn9exFkkSjXEmiYxzHxXUDtNGE4yFgGY9HRInmn/32P+HmjesYY3nrhz9kFI5xlMPK2jq3bj3J4sIsg8GAw4NDjlstOp0Ovd6Q4XBANByg45DWYUTgSlzPYXVlmVgLtrd3cHQfqxRGC6xOuHD+POtnz+O5is2jAyrVGhVXUDuzRpRoOu02nXaT0VBw87FbHB7sMRqNuXDxKrd/8AqDQZfZuQXG4RClFI16jVq1yubGFmfPrrCyvIDyArR1wJp087GVbO4cMk4s0nHxPZfRaMzi6jqekvQ6HZTj4CjnxA1rgdhqknDikJ24eJu7O3T6fYQURMagSddrOknY3dliZXWN2swMg16Xt37wOm+++SYvPPUY777xHZYurHLh+iUGoxH7nR4HzQ53w5AbQQVfKdaWZrmzs8tSo87d/SbP37zE+Rmfd9q7/Kv/7X/hm1//Cr/4y/+QX/2VX+G3z13gq3/2p3z3tdcZRGPCmVkerJ+jtfWAc3s7xOGYHopLSjJnBTWb4GBxpaCvFGPHQScxR4HPK46DnW0Q2JgAi9LJ5G63qXORyVoUJg7H1G2ZGRmNyTYPS6RMSb0UkowAGkvq6pUKoSQ2K3tSprESYzSJTcO/YhLMJPSsytbUJoWZ0his1lhhSXNNpp9N1qQw3nEUWIFl8syANFy0FGnZUqSfaakjVlB1BGE4JkaCX8Vx0jKNgAl2LVWqVKlSpUqV+pD+So7KPITIoEbedTUNjOTdTsWceB8FAU9zLRWhwWm/Z7DCdV06nQ7f//73OTw8nFrXadAu70Cb5iI7zYWYP66o0wBHHq5MUx5gTnNzFts/7b2PcoF9FIzNv14MQdpoNDhz5gwrKytEUXQCeFRh51zWV1k+Uykl29vb3L9//xEQ57ouxhgODg4YjUa4rkulUnkEXOavLz+HinArD+ey8K5hGFKtVqnX64+AugyO5qFl5vpMkuRk7s7OznLhwgV2dnY4OjrCGMNwOMRxHKrVKsfHx7z++uucO3eOWq1Gv99nY2ODjY2NkzCxtVqNJEkIguCkvny7M7dnHtjlxzvvlsze9zyPubk5tNZ0u90PzZUinM6uuziHi3OruHkgD52L8y0ftrnocszD9zwczcD1tPmfB6DF/LTTNjFM+71YZt5xPQ245uFs8fqK87lUqVKlSpUqVapUqaJ810U7DtbYNLVcJmFxHRclJUJKXNdgdPrd1HEVSjWQQBjHJHFEHCdEo4ggSHNaWkTqfkJgJmABJjkxpUIpQTQO082UOiHUCX7N4bjdwZh4Ai04gSAgSbQlSmIc10OjEKQHJYlG63Qd5bqKxEJnOET0+mgr6A1HKAFWJ2mIWzEJSWkM8TA9N0400nNxPReDQMcxOxv3qNbqeLVZUB537tym12ly+doNvvPqq2jTw3ElGIPrKBJt0JM+kkoRVKqsrp/n5tPP8qMffp+Xlxao1xrYybpjpjHD3PwSszNzeEE1zcupBL7roKREa4MwKfAVWL716nf4ub//K1y6coV3e3129o546bmn+Nb33mDz4V38wKdam03daHGCki6Oo4iikHA8JBoNcYXlyuXL/MynP027dUScGJrHbaQQLK3M8dQzz7K0OMd4HNLqDOiNYmKjsNLDDWrUpMLzKoTjIeNBj72jXdrNPdCaF559ms9/7tN859XvctxqETgVVi9eYW5+kScev4GOhly4cIF+p8Wbt9/EIrhw7Rary0ssLS7S7fYZ9rt40nD58iUOdzbZ3rzH0soinuuhdYNBrcp4FCJ06qj906++ws9/4ZNUqxVcBINeG6EUnlOhuT9kEMZYJDpOw4g+eW6dQbtF6Co818VxXcAipfrxes3+OPKRkJL9nW3CMEEISWzj9PaQEixEYUjz6IiFxSWMMYwHfX7w2is88/RTLK2eoT0YceuFFxjHCZ0wZmwkxqvgfP4LVB7e49K4xTtbu1TXrvC5ixdwTILVCR+7eYnj19/hnbd/xP17d/j217/CP/y1X+fjn/4Mq2fP8/WvfoXDVgsUNFdXaTUazO3tcbY/YJBEXLIOZ/SIKhZXOThKsufK/4+9N/2RJMnT8x4zP+POszIrs+6uo6v6mp57ekRwuZd2l+Rql1qtROqT/ht9FwXwmwQSIgSCi11pKWiwInd2VpyZ7Z6+u7q77qzqOvKKPOLy8MvM9MHdoj2js4fALARSgr9AIjIi3M3N3c0D4fHY+/74uNHk5wpSz2MVQafZZHQ0oBW4lPgPUzwUkaoYhDYlaGQGdQswWN7zCoExhaNYGFPGI5vSnamQRhcOZVGsqw2l47KYf5Cr4rnWpgSkeQkci/OiAGXy0gGpkKJwwoJA6i/BqpASQzkBWpnCyYnEyMK5LaQD0iHWYNwA35E4srxXVzlxnBE2Wv9vf+TWqlWrVq1atf4/ql8ZVNpIyKrzseqEqkIPCwPsOlXAYp2VVTeUBUV2O1UAVYUeFg58XUwjfBXmZFnG9vY2Dx48IIqirzi97DqnQY7TXIrzrqqvAxjVfs2DzF8GDOeXt+Ck0WjMXHP2GFXBymkuydP2bb7904DTL+tztT0pJZubm6yvryOEmDn64jgmiqITMKraho1YffjwIVtbWyfca+12G9/3efz4MVEU0Wq1aLVaX3EBVv/sdqpRo1WQnGUZSZIwnU5nN0h5np/qzKzWbqxGs9o41FarxbVr13jy5AkHBwdAMbs3iqLZMbh9+zY//OEPWV5eZjqdMhwOZ07ORqMxA5OnnQ/bP7vNKsSt9q16vdh1u93uLLI1iqITY+I0R231Gppfbh4cngb4Thtr1eNf7Xe1r/PLV7dTdWjb/a+e46rjc37igz1+84B0ftzOb6u6fvVvvlaoPT6ngctatWrVqlWrVq1atQCk6xdupRIOICRCOCUctN+xC1AoRAkSlEY6Gm0ESIHjOgVYRBCEAY1Go6x1WOAN4Th4jouQDsIYpJBkSiPdYju+E6JzTa4UAkWuCrcjWoM2ZQ08yPIcpTxc1yucWgiMLpxURhiUVugycnI0mTJ5eBdfGvywQaoU2hiMUriuRBoNJfTwPQ9Q5HHKZGyIk4Ss22E4iuh1mrS7I/wgpO3myG6LIPC49vLLfPTuCJUrXCnBLaJsv/X6N1hZ38ALG0W9Tkdw3N/j6e4XyHzK+ZUOzre/S5rmdBaXaXd6+L5Pb3GV/e3nZHmO0AYXSRiGTOMYVwikFAwmEX/9F/+G3/jj/448jni0FRBNdnnztVu8896HPHv6mMWlNYwxxMkUbQS3Xvsm8WBAliZMplN0mvC7f/8fsru7R7+/TzydopWm1enw6muvs7LUYzSJGYxj4hxcP8TXoI1GSoF2JbEsQK/vufR6HRaXlnn84A5/84v3iSfHvHL9MnceSBrdVZyggY4OePDRT7l45WU2rr7Cwc5jNjbXSTNBo9FkNDjCKM3y6lmSOOL+80fsv3jC/u42jivxbaKOMQyGI45HMZfOLuFKyXA05NN7j7l19TwqzQiCNs3WCo4UTKIJwyghV4pUg9to0vIdBsdHBIFPGBYO3MIDaDC6cFFqkxeO37IG4uHhQeEQlIK8IGK4UqBMAciSZMo0mtBbWEInEbtP7vPo8WNev3GDzz/4GSuba/zOf/WPOX/tNm/sDZCTEc7xLk90hMg1Ny+u88mTL9h482WydIrRhnbD5zvXzvHjjx8yjCL+/b//a7Ye3OHX/s7f5a3f+gf87u//IW//7P/m3r27eJ7HRMJ2Z4nds+dpHPVZHQ25PnW47kmayz222gF/FU15mmvSKCbOcgSgDBxECVNtWPQk1hGsSm+hIySm+ChAGFNEMWtwHDk7PqYEj0aDlGXNSgQGB0wZAysNwhQxsJgiArq4ZTVl7LTAkeW9rSlLMinAE3huca3bMFqlNRqKGqy5Aoq6tCARsvgcc0onpzISg0S6Do5xSgArwHEKaKoN0hUIA9LxvnIPXqtWrVq1atWqZfW3clTCl7DBAijrkoMvQYGFCBa4VOvv5Xk+A5UWulkn27yzqwo4ToNy867NKlTTWhMEAXt7e7z//vsMh8NZHcSqquvNx8nO/19tex5q/DI3ZHXd6uNpsPW0R8dxaDQas5qN1b7P78vXfRH8ZdB1vt7oafsyD2fsci+//DIXLlyYHRdbg7G6zDxU9H0frTW7u7vs7e2dOOfr6+tsbm6ys7PDeDxmZWWF1dVVXNc9EcNaHS+23Sost6/ZfhhjZstYQHkafLIQzB5rC9ctOLRRt5ubm9y9e3f23v7+PsvLy/R6PQ4PD3n48CFra2v4vs/a2hqLi4v4vk+r1ZpBODtubL9snGlW1kGpHsfqsbTXgAV31tnseR7NZvNEf+fHiT1P1TqeVZcifHltV897db35663qojxtPNu+uq574vNjvs3qJIfqflevg2rd0WpU7vx1UHVfzr93Gqg/rbatfb0Kvauv16r1n4IudiX3/vu//x+7G7Vq1apVq1atUlJKtFIgi4hVx/UwRiMLo2D53d1DWiBZfq9USoMQeK6LQuB7AY5TRC3m2iBUjpACz0JK10VrQ5rnTJMEZUzhoNIFLMyFA27x3dl1PDKdgSwgSPEdWJLnaub2ktKmp5TxkAjiJMFzHIxwmGaKX7z7Di2Zc3bjHItLBbxyXZ8oUWR5gsoymo0Q181wBbgS3DyHaEiUjDF+k+nApbM4xfddut02vVaHZpDxxquv8/DefVQc4WAYRRopNUsNl2+9dovdwYS9/h57e0fs7zyHZIiUhtD3aXghly6c59LNN8hyTTKd8s1vvMGN69dJ04TD42PQmmmcsrO3g1KKpcVF1jc2Obe2yjdvXuXWtUt8+Pkj/uRf/ynhdJdXb91kZ2ebhYUebqONznKuvfwK0yShv7eDUhm5UuS5YnXtLMPRiDROSZIUISWXr7zE5uYGk0QRZwYvCGk5Lq7n4joOUhh8R5LGEmE0qIzcCAI/ZKFznnPnN7l35zPubD1n68kzNjfP8vzJQxbObKCTIcPDHfa2n3K5v0+v22BjdZHW0jlyPM6sLqNUzsKZCzx//IA8HuG4gjAM8N3iPDfbbaJJxMbZs6ysZJh0WgBnKUlyjUaSGkE8PKbZXAajiSYRUVrcR46nOdcur5PFEVqlqDxE5xm+6yEscyvBujEGrRS6jAFNptMCipUQT5Tg2KgC3gKMxqPCfeuH7G3v8PmH73Pr5ZdpdxZ49GSHm298m+/85h/w8tE+n/zkz/nL9+6z9egZl5eX6C0v4WYJnz/Z4cZ6D0dIEHBmqcvrF8/wzsNtUqV4sbfP22//HHfpLK9df4nvfO8HLC4s8N5774LrceZsF5XnTNxlDlotPhocsdBdYLkXEkUDBkZipKHVDHGShJ39I+TqAsJxwPM5jCZ4RpdOyvI+WxZ1Zh0pMaa411SmALpF5LMoU5kL16Q2AmGKiFYjVFEF1FC6IIv3dAl4rbOyIJ1mdg4QDsIRSMpJ2ErjSBdpijYKt2XxGWSEvQeWBVQ1Nump+HxzhcCRxQQFpQGvqGUptUEjMLJwTxf1Nw2Z+rI2Z61a/zF1sVvHENeqVavWf2r6lUHlPIybj9wEZvDAwhNb5y4Igq/Uu3McB8/z8DzvKwDytFjGatSsfb3aJ9umEGJWC1MIwfb2Nu+9997M8Vbdn3kQUnVRzS9rNQ+37PvV9ap9qq5T1WkOyCoUqq6fZRnj8fgEnKm2Me+IO63d+ddOc9P9suXntydEEft669YtLl++jJTFDNWlpaUT61fhWhVU2tjTyWRyorbkhQsXuHHjBj/60Y+IoojXX3+dGzdusLS0NDvOruvSahURIvNRpbYtWxtTSonv+7PjaONpLfTMsmzmlrTgvepotLIgUUpJp9NhfX2dlZWVWa3KKIrY2NhgcXGRra0tPvzwQ65evcrVq1dxHGdWGzUMQ4QQJ2Jy4WS0su3T/BjKsmx2bJVSOI4z2yff9/E8b3ZdtVot4jg+AYFPg27z26+er/k/2w/bXvVanQfhp52X6uvzkxDmx5sFtlmWnZjoYNtKkoQsy07UQK1+jtj9nXfz2rbn3aF2vap7M8/zEy5y2249K7RWrVq1atWqVavW18l3HZzyuyTCINDld1iFEbLwVQlJnqfkeeGzko5A56qIhTWFQ1IKgSNdfN8polPzvHBOCUAULscg9DBSkkynFHGbAlVGPkpH4HkeK+tnOdzfRykLPjSOIzFCFoAEipqDYVgAFikwaKTjMBiOUCrHCXxC6bC8uszTrQfsHHxCKwzxpWB9fZ1ObwHf88mV4jCOSeMpgefSajXx/YBmp1O4x1RGFk0YZTGJcXica3zP4eqNq3zz1VdZWFjkzp073Pn0E8ZPHrG+uMD5qzcYxknhjFM54+ER4+EhoQPr6+tkWcbi4iJCaob9bYJ2D8eRNB2H9lKAUppz6+uzviht6C0ucHw8IBqP8FyHv/nZT/EDn4YX8N3vf5ef/uVfcmZRMo4iRoe7fOetV3jp6g3a3Q5/+md/RjQZobTBdSTN3iJ+EKBUTq5yjNa0O22uXrtGIwyIlaHhuBijyR2JFIZ8OiGdDIkmI4zSIAy+7+K7IYHvgDH4gccP3nqLu5/d5vOPP+bBoyc0GiHtZouP733G8OiQ5dUNXhykXH3pIo7UrE4y1s+/hOsFJHlGt+mxk0d0Wk3aDZfNjfPs7GwTuA5r62cYjcbs7u0iXYc4iwh9l27Tw6QJRiscCaPRGO+cj1EpwyhiMk1IlabTbNANPOIoQjiSPE1IIqcYd65T1jIs4JiQAokE6RTOSqWQhdkQIWQ5ObiMQBVlTVataHa6vHHzBlu3P+DDv/kZr735ba6ev8TBwYBJlGDiL3h852M+vP0pt18c4DXaeCsdhMm5trnC+1vbrLY8On4BKqWQXFpbJnbbfHRvC8cJ2N4/YOfZExYbLv/uL37Er//nv8sP3vohv3jnbaZJCqaoFdkIXFLPYaA1k8EEL2ixcGETVEZ/ZxuRG3Qes30wIHTA05JOt000GCAMCCPQRpHnZnatYid0U/RNy8JZKSqsEWHKWpQaJEWctKGoV2t/PxIU0bHGRr0WGbBGa7QGKQ1SGCSSXJuidqQp6oUqbRDlpArPd0FDrlUBmd0iThaKiQzaaDItcCjAsgCMUsV5FWVfyozpIua33JFatWrVqlWrVq1T9CuDSutImwd71nFmf8S3Lq2qQ8oCS+uqstGVzWYT3/dPANAqQHNdd1af0PbBOt1sjKbrurO+ua6LUorJZEKe5wwGAx4/fsz29vbMwVbVac+rjrzT4h1PA3zzjrzT4kntulWAUz221f9Pc3BGUXQCNtnaoKdBovk+zu/Xaa9Xn58Gk6rta61pNpvcvHmTCxcu0Gq1UErh+/4MsNkxYCGSbc/WgkyShPF4TJIkJ47HxsYGL730EsPhkCRJWF9f5+zZsyfG2Wlj8+v2wfO82biovhaGIdPpdBZXa6FUdeymaXpi7FXdv1evXuWLL75gf39/tvxwOJyN7/v37/PixQsuXbo0A8xVJ+Vp56Aak2zP7zwws25Le26qzk97DB3HodPp0Gq1ZiDTPlbdpPPjobqf9nxVxxxAmqazvtg/2091ymzJqmOy+jxJktmxrda9rI7hatRtNd5XiCJi1267+hlix4ltd35iQxVgVt3V1X2x2/I87wRQ/mVjsFatWrVq1apVq1YtAMdzkQZkee8sACmdAmIZU0IYXbqmygmB5fdUleU4jkZIhzRTuLnE6KLunxDgeW4Rk+lIjFEYLVF5hjAaR0pcx0WIsgSLMegsZTIck6Ux0nExSFzPZxpHIIpoyTTLMQYC18F1i3unNDF4Ao7HE1SWErZ7NJotrt9ostJtMIki9vuH7O3t8fz2x/hS0gwbBA44QiCNwvMDHC/A9z02zl8kCBt4UiAdidQ5ITmOUiglePrwMX6jwcbyApd/4+/xnW99h795/0MOnm7R7C7QPzzG0TkHu7uMDnbJs5Rxojnc3ebGq7cYDMa0uiHjQZ84GtLsLNDsLuP6IaKMrURArjV5lrK384IsU2htUFozmMRMp1MO+/tkyYSr16/x2ScfcXlzk6NJTKfd4t7d2wyHA6LBPkanGK1wHZeFbpOGLzE6x2DQWnH+3AWWVlYRUtByivuULIed/i73Pr/Di90dpkmKynPiaIwnBYu9Nutry/iug5AOjUZAuxXw/e9/m/HwmP2dHVrNBs8ffsrWo0f0hxnRvR16TY8k+hZr66ukyRThN3jx7CndVoPAyVDpiPPnz6ONodlZ4tbNm3zy/tuErkvzzCpKZRwcHDA1hjAMaIUZ0fCYu3fus9htk+c+jXabnS8eMBpPEFrhOZKzy12MzkkzjVQCo3O0nUSqC2CZKo0o66JK8eVEd6XTE7+RFA5DgVLiyzqOBlyTceHsKkdPO9x9dJ933v4Zly7+Me12g4/f/jHJZMCjB/d4ujvgws1vcrC/y73+gPMLAYudFptdn8+e7vGNiyu4gBYFPP3WrescjyL6wwlpHHH7/bfpdjrs7zznn/7T/4F/8k/+W37wgx/yztt/w2A8AZ0ziSLChWVcNMpAu93hpStXWF/uEY2GPH2+zeHBHs+ffcEkjvG0xvFDtOPiAoFDGZWsySuTfgvboyjqRRa+yALqCoHG/jZROKsFpohwxjonS2ppCpgpEBijwQhcUdSyFbKYnKAMSKHLz44iKpby/6JmpsaVLtKTiOzL+phSFBAzNwVw1qr4DUJIieMUsF7oYgJFEV0tcUQJYZFIWScR1apVq1atWrVO198KVFbjDqv12yycqjqbrLOr6kaqOuvso40LnQd7Fk50Oh3a7fYs9nEwGHB0dFTElZSgE5gBMBv5muc5Dx484MGDByeccfM6DRrZ/bXvzwOUKmScj720r1lV4Yrd769zOFbbm+/LaY646pf7anun9e808Hoa2Ky2/3Wxl8YYut0u3/72t1ldXT0RUzrfrn0+D093d3c5PDycQSO7TLvdptPpzEDUwsICvV7vKy7AeQBaPSZVwFY9/rbWZRiGM+AYBAFBEMwcnvY1O5YszLJA04KxtbU1rly5wjvvvDPb9+PjY6SULC0tsbe3x9bWFteuXaPb7Z5wA9rzUj1/1f89z5uN/+oYsvDe1te07tQqELZuSxsFWz3+Fs5V3Zj2/dNAZdWZXB07FgxaaFd9fz7KVSn1te5R28d5t2Y1ojcIgtlnSbU+p4WG9ryddr1Ulz1tbNrjO++SrNY6tevbMXoajK1Vq1atWrVq1apVy0qKAji4vld8J0WUEbBFGRSMQQqQTgEj8lwBBiFMsbIooIQrfUCTKo02GUHgF45LKQqgISDLUoQxuOV9d/E9XmMwKCM5OjwiM0UtSoRCGIGQfHmvIAXTNCfNFKHvEjQ6BIFPNIZcaQ4nU/o7z1jdvMCLwYSn9z7l4qVLhIHP0kKXKxc2ieKYw+Mhe3v77BwdQJoiUQQCQtfBcyXZ+IjembP4zR5BGOJJQbvVIGj4qCxFphPyPKU/GeG3OwjP59e+923EW99hd/sF3mTC1oMt9nefo42i3Vvi+OiYD+8/I80Vy+tnaXd6SMchz1JGR/tkSczC6gZe2CJXeeHuc138ICxiRgvUU8AdAeQ5r964wr/60z9l/85n9FYvEna7rC9qbn/2GZMoIoljtMqJJ2NcR2Acl8FwhOMGLCytMB5NQBgWV1aYphqijIbv4jlw/85nPHi4RRA2WV5ZJU1iwJBli6RJwnBwTP/Te1x76TznL5xjaaENJmcwmHDuwkWyacT6mRWevujz8jf+Mz67v0X/89sIFTGIYs65LpPJhIf37rK385zlhQ6jw20cNL4fcOGll2ktrBJFU85dusrj+5+xsraG7/n0ul2Eymk19zkaxKRKMI5z8vSYl259j167ySf7uzQ8SFJNrxXQ9CQqS5DSxdjfe4zGKEC7uK7EcVykELjl+HekwACNRnEOhDK4EjTlPbFTRJkiCrDpS8XTR/fYOzjkYDzhvXff4Zvf+g6XNy6y/ewJN165SToZ0O8fczjoc/7SZeLJiHuPHrLoG9ZXl9h/9IIXxxMuLrXKy8uQDfb47ptv8G/+7Y9x/ID9/T3e/sm/5fqtV/jo9o/5Z//sf+S//uP/hu99//v84hdv0z864szZcyTRiPHgEOOFDIYD7t5/gDAvsdxrsXZmCSkK5+PW1mPSXBElObkWKMeh7YIjQGtVuBq1xkLKLyfpFqDfiLIWrRElkCzvY41BUP6eJL50O9rqn7oywRaKOFaDwRECe0csvlwapYqakkpoXECpvCheKwRSlMlEgqIOpi5qjkoHivq6AmMUSaYoXLGAkKBFWe/SQTouyvnq5P9atWrVqlWrVi34W4LKeVei/d9GUlpgYMFJ1YFZbce2FcfxLNoxSZJZTKwFRfYGyj63YCVNU+I4JkmSEyDDQqYwDNFa8+zZMx49evSVfalCIftYhTWnOSnt6/PQpgrFTnNGWidf1RU2D07m4eP8diyksmCl6uyqQrt5IFgFeKeB0XkAW4WV1X2outXs8263y82bN1laWprVzbRfsOe3YfehCo4sqKy2bd2xURSRZRme59Hr9eh0OidqF4ZhSBAEJ9qGr68xaqFeo9E4AexarRbr6+sALC0t4TgOYRjOnLpKqRMA7vDwkMlkglKK8+fPc/HiRS5ekdjQXQAAIABJREFUvMjDhw9nIDNNU1qtFo7jcPfuXa5du8Zbb701A+3VeqvzcLrq5rOPVXhnr7EqhJ1fzrZlHZz2+Fi42Ol0ZvHMdoLAaeO+CpXnndRhGM6uX3uMquC1GuVbhdjVvlZhpj3vVaBqIWsV3FbBuYWIQRDMthOG4Veuqery8+PfLmsfq+fBXrvVyQXVOr21q7JWrVq1atWqVavWaUqTqPh+KwrAoDFFaqMjCQIfiSxAolagTRETqzTCkbPv91DUryuSVAoXIrIAAE7pcHKkxBUCIXLSvCwdYcAPAlzPhzQlUTm5MjgCclOABmEKcBr4IY70mKQJ0ySGbEpnYYlGEHJsBEpplNZsPdvFXdvjr//yL/i1738Hzy++cwsBnqcIGw16vQ4XN9eJ05TjwYj9fp/D/T6DOEJkGZEaMEkUZzcUYWOdVEH/aIDRhtCVdDst2p0WRroYo8imE2KTgZQsLPRoNQK+ePIIo1N+59f/Lm/95u/xv/3orxDplDSJ6CydobOwBBimSYxRRRLNoL9Ns7OIF7aRQYAUkiAIgcJlppXC84pan1oIkC6//uu/yb/45/8zO1ufsvqtt7hz7xHxdIzSmiyOC+Dp+XiejzYGz/fpdnv0d3dQqphQminD9vYOi4sLZK2QF48f8fndO6wsr5KmCVoVNQBzVaTjqDyn1Wzi+x6f3dsCpejdukKa5+z1jzgcTsmEy27/gCSJ2Vxf49Kly7x28yoHBwe88cZNeq2AaDLm/Y/e49KVazS6PabxhMngGNdvsHf0DktLy5w7f5m1jfO4juTJozss9BbJ84xGu0tnoYfc7eNIjzzLOMxdfu/GDfr720ymQ5q+ZDAxNH0XdFFP0pUGo3PQObkSaAl5WtRfldLBLSOIPddFOUUEq+8VtVZTo9lYXmAQRRxHxSRZp/IbTei7jAd9pOchhOTZF1t8/OF7XFj7bXq9Ho8fPSHJNAfHIzpr58iSiDhNuXz9Jl9sPWQ8nLK+1OXRi0OW2016YZE3q9IJSysbXFhf4fHuEUoZBsdH7OzucmHzLHe3vuBf/PP/iT/4R3/Em29+k/fe/QXjKEIZgRN0CAKXZiNgb2+Xj6djlloNMJo0z3Bcn9WVZZ6+2MZojasNzYZHYhQNoRGOgycNxsgC/gkxc1IWELKIfy1SX01BCoVBY9C6iFwFgWsMRpS/vWiDopjnUKStChQajEZTtlHWpi2OgK2Lq0q46ZSgEVRevOs6Bm2KbSplilhoivI4juOAKProug4CUU66yFBlnK8UBlSO4/7KP0HWqlWrVq1atf5/rr81qLTgouqOsnGQSqmvOKQsIKi6l6wmk8ksYtECS2PMLK7TdV2m0+nMkTWdThkMBkUsy+Eh4/F4Bq1c153VSFxfXyeKIp49e8bR0dEJ+Gb1dc/nwaF9bf6xCjlPA4Jf51Kr1sc7rR/2tXmAZGFR9a8K5uZr7lVdZdW+V9uff+8/9Lzq6ltaWmJxcXEG5eZre572v4WGSqkZqKz2qdPpEMcxjx8/Jssyut0u3W6XIAhmbkY7lqpA1EIkC29tNKodc1VAbF2TYRjOwOTKysrMwVmFvRbA2jE5HA45ODjA9302Nze5fPky3/3ud9nd3WU6nSKlJI5jDg8P8TyPx48fc/fuXb73ve+dGB+nnccqFJ0/d7Zepu1bNU656qKcj1yuRu3Ou07t/tm27bLVWp3VPxtfa0GejW+1buUq0K6OWbt9CxytA7sKJe12bV/mx2b1s8FCevuX5/ks6rnb7eJ53gygzte9tcdSaz0Dt3Zsz9d/zbLsK3DTqgaVtWrVqlWrVq1atb5OUjh4ro8REiNMWRsyBySu6yGkRGtV1KB0JQifQBiEcMi1QudpWduySDIR5fdkpTSuW5Y3cByQxXd2x3VwtEZ6Rd1Kz3MxAkLPpdtdIE4zjtIEKUAZXbgHAddz8fyALEqIJlPi8YjllVWazQZICSrn6vlzLF+6yo/+j/+dX//em1y+fpPj0QTHcYvoWOEghcFRGnxD2NB0Oh3OnV0jSTKG4wn7/T7HhweMdE66f8gyPt1mSLfVxGhFqjR7gwlHk5ROp4PnuaRxxMFeQndpBel4BJ7D8pmzuAa+8YPfYqm7wD/+oz/k7v1HDA76LC50UHlCnsS0GxLXc4miCMd1SaIhGIUfLBMEPp5f3C8YrRBSkucaY/Ts3mB5cYF/8A9/n3/5L/8XPnj3Z/RWLzAZHZPmGUk8RSuFwZArRZ4rtOMwjqazkiaBH+AFIaPJhGg6JZ4Mee/nP+GNN79ZRHDmqqjdBxhd1BFUWqPLMiS9hSVu391CaUW312J3t890MsH1GkyGBxijOOy/oCsclpZXOLe5ged7COnRWwj4wfe/hwA814GwAKrRNOHF86f09/Y4PDqi0WjS7fQI20vs7z5ncXmNNElIkhjHkayf3eDhg8dcuHqT5YUOP//kbYxKcTxJmmm6DU0UTfF8h9BTGK1Qqogs1QKKGowSr6y3KBwHzy3+XNdB5zme59BrNvnmKxf56PMtBtMMZQxOCeKEFHi+h+O6hKGPFIIknvLR+7/gyvmz+ORoBV6zy0JvAdIJ6wsN4tYSW188Q6B4sX+ABNIk45Mne3znyhqeY0BIpocveO3WLbZe/BVIhzjLONrf5drVqzx8/JTh4Jg/+Vf/K7/3X/wBb37jTT748AOOhmOEIxgNjjg8UCgjyYlJsxwhXV66uEl/bwfhtzizssrO3j6t0ENPU1rdBmka0/TkDD5iTFGzU4AUAoEuJi3gYrTmxB2nkEhZ/lZVwkdtinqXRoADZMqgisqRBegUEldQ1K+kqAGqykZFGclbhMia4hxicB0HaYp416KGbXEu0AooALTWZubMTJXCdSijXgGjS7dn4f7UdSJRrVq1atWqVetr9LeazhRF0aw+pHW02dp3FhwI8WV8pxCCyWSC1nrmjJwHDhbIVMFBmqaz2FgLJieTCcPhkDiOabfbM1eljY51XZfxeDyDLnfu3GFra2vmGrP6Onehfa+qKtSpvjYPyebbOa1dC0jgZOynjZkETsCqeVhpQc5p7c871ubjN0/TvJOy2t5pzsRqH7vdLpcuXaLZbH7F1XfaMahCVAsq9/f3OT4+PnGc19bWmE6n3L59G601Z86codPpnHDnVtuz61b3cX6/q27LKmS3cMxGwDabzRMQ0Do6q+1tbm4SBEF5A+3R6XS4fv063W6Xfr8PFBGxw+GQlZUV4jjmyZMn3L9/n9XVVYQQJyCd7VfVgXiao3X+vSrQs25aO1HAtmcdh/bYVcdKlmUkSUKSJGRZMfva87yZk7Qal2vdmPY6A2axuNXjXoXB885ae83YepHVyQxVl62NpD0N/s/XSbXHIYoiRqMReZ6TJAmO45yo6Tnv6K3WmLTjwX7WVCGpdYlXx5wdu3Wdylq1atWqVatWrVpfJz8Iy8l4HghBpjR5npFneQE0yGcRrb4f4rsC1w/L79MOWZ4TTcZgNK4fkGc5GI0QLlqBcgx+UNSt1BqUiQkDB1EpX2C0xkinvP+GpN1lMh4hpEBSbMf3PcJmkyye0O/3GY3HrJ/ZoNNdwPVcAk9w4+o1/t2P/4prZ3psXrzMYDRib3cHo3LanS5+EOJ5IW7TQ0p7T1hONkxT2t0J6+trZHmO1jBNMuIkYRxNmA4nuFLS9F2aoU+Wa4aTiCRJiaMJuSswjkeaZfiOg8lTzq6d5f7WYz759DNUGtNoNGh2FpBeA+EGGCNxTIonFJN0hBAtEC5ZEjE5UmTRkM7CEmGzS64kEpBeQJalqDxjMo0wWrO+usIf/qP/kj/513/CZqdJmi6RH+4X92EqL6BOrsAoMLKATaaI9HUcB1ROu9vEIPnovdtEkxFP7t9h4+IVhPSK+M88J88ztC4nhmqFVjlSSBrtDh9/fp8rF9aZjEbE5QTRNM0QRpHnE8bH+/RWN0lzTTKMGAlDM/QIPInvSpTWSDSdZkjgeRizyWg45vjomOlkQpLD4c4Ljva2EdInSxLSaUKcpgyP+mhjeO31V4kmQ4aDYxwpmGqJ5zkEjgCjyDNFrFRR91AbUp1CWV8yB3JROACFlGRS4jgS4UgcKen0WvQWewSuIfBLoKmhuM0q7sE8xy3ijilqKmol6B8dM4oSrp5fJ/Rcslxx65WXefzgAfvbz1lqh1xYavDXDz5nmiRlHVLDuD+g125wY72LYwx5PGFl+TzrSz2eHw5Jc41KYrywyUK7yf5owmQS8ed//md4v/+HfOO113n3g/fZPzxGNrosNUKkyUniFIHi8LBP8PJVLpw/x3AwYhS6RNGYo9GEXqdJqg3RNEMIj5Yni0hoxwFRAERhyshXB4zROALSHFy3iMFFgDGqhIQFpNSmqOgpyghZV1JMIABUCcANAscROBQuSxs5W8TKFuBSYorjbxS5KaJkbf1WpMQxDrkuXMAqVyAcPN/D91wcYe+tNUYbXCHIVYbGxZWFA7xWrVq1atWqVes0/cqgstfrzaAGfAkbLKS0tSHPnDnDSy+9xOrqKlEU8fTpU0ajUXET0WzOgFMYhqRpyng8xnEcVlZWZtBACEEcxxwcHDAYDDg8PGQwGBBFEcAMFAkhZjMXbc28o6Mjnj9/zrvvvsuzZ8++sh+ngbl5EFmFG6ctO/9atY1519p8/OS8O7Na56/a1mmvVbdZBUJVGDUPRauQat4lWo21nD8G8//bR601q6urvPHGGzSbzRPtVNutHq+qA9I66g4ODphMJrM+SSm5cuUKnufxySefYIxhY2ODRqNBkiQziGXbmI/QnT831WNlXZQW3tmxUz0uFpZZYDUejxmNRrM20zQlTdNZjcf9/X1GoxGTyYSFhQUajQZxHM+AWRAENBoNnjx5wk9+8hN++MMf4rouSZLMtlc9V/OA1fbD/l+tU3la3dEqYLXXpK3faMeIrW8ZRRHj8ZjxeEwcxwA0Gg1arRae551wOdpJCVWwaGtXVmGkdUbbsVg9B1VoXO1zdV37ehVKz7tD7bLAzL1tndR2363zttFonOiLfbTOySiKZmPTfu5UYWsVHtuJFDZ+ugaVtWrVqlWrVq1atb5W5X2p6zhoA0ZrHAQ4hdMxz3NyleM7EtcpshqN0WSZJvAMruvgewUE8MIGURSTxmU4pAajDDpXqNLTJI0Ap/g/y3NcUdRizJUi8ByGx2OiyQSV5yXSMIXz0nVpNZtMJyFfvNjh9fGIC5sBS6ubdFuPCIXip++/z3A05lzbxagcIR16nR79owHCa3D16jWOdJNnn79L4Dl4jiRotvC8AL/dwbTbGEp3Vp6yBGUyS0wUTYkmEaNoykF/ACqn6RUuPFQRh3qwn+H7DUQjYDKJiMgY3b9PuxESug55HONKyVQW7Y7HAz7+5BMWGz7nz22iVIzOE4TjkPkBedhEmJxm2KDZ6aHylO7yKgf9AyajFK0UWiuM1lze3OC3fvu3efvnP8dvdAsLGgWQyfOMPC8mRDuBg+c5uJ4HWeEyi5MYL/HI04ydZ09Z7vXwWx0eP3pAo9Ein5XPUOWQkbNtIw2B7zOJUg4OB4g8Jk8TcmXItUFSJtscH9BZPINw/SKWNsuJohiVpzRCn7NrK5xZW0VIyTRO8JodFldycqV4cu8z/PYCT754jMkyGv19xqMx0+mU4WjK/sGIS1df5srF82zd+QStUoLQ5eA4pxO6SFFObIbSiafxHAfXcQFdwNeyDmOWUzpWBa7rIJ3C+bux3sP3XFSW0WkGCGMwFnoVVK64noQoQJwsIotf/ca3UWnMg3t3aYQevlPcWzdbLZIk5unz57TCgOtrC9zbPiLKNY1mmzyJ2RlMWemErHdDJIZ01OfVm9d5/tO3MVKSacVkPGZ1ZZn+KEJg6LiSOz//MUvN3+HN11/n3fc/IEoyjNG0GiF5HDMYjoiiKUeDMcudJp1ujzxL6XS7jCYRUZQwEKAyzYthwqWFBl553Rd7W7gloYhuxQi0dGk4oI0mL+GipASWpSFT6PIenQIIS748fsYRaC0LhyOycF0aCaWrsvwVAVmsUNx7U07sxaAN5TYLYOlQgFKEKKKSFeQU9SmlLD5XtNKz95VK0VJit1SrVq1atWrVqjWvXxlUtttt2u020+l0Bo6sk8/K8zxWV1e5cOECvV6Pfr9Pq9Wi0WiwtLREu90mz3OyLKPT6ZBlGbu7u0RRNAM3tuZkHMczoBJFEVEUzSIex+PxDD5VnXZW0+mUR48eMR6PvwIM/0M6bZnqa1WX17yz7zRVHZhV8Fl9rMbBzsPJ01yO1b7M12esxoBW932+/9VtzO+XfX0etNp2FhcXuXbt2qzmowV/1T5XHaFVqCqlJIoiBoPBiRqJUkouXLiAEEX9SiEEm5ubdDqd2XizQEprfQKGVcHlfF8dx6HZbNJoNGbHZP5Y29eqcCpN05kbGIooUBtBCszG52g0YnV1ladPnxYRQiXUHI/HSCk5Pj7m/v37vPnmm3S73RkMq7o1rQt4vm6lvb6M+TIO2QK5eUgJX8Yw23WazeYMMloYZ7dpIeVkMpnVeqyCwqrr1I4J+3rVBVytPToP+6rAvlpTs/patY1qDdb5a8i2ZdevAl77WTR/zuwxqTqY7bIWWtu6ulprwjCcTaaouk2t49Z+Ltk6pbVq1apVq1atWrVqzUtKSZZn6HiKlA6e56KERArIVY7jSHw3pNVqQTmJU0qJFAXYzMqJjUIWkKERhkUbeVY6+jRxmiLKewIDCF04qrQB4xb15oQQNAMf4fo4MibV6ew7tVIKozTNZgM/bNIfD9jf3WNt44CLV65x//MPefH8OUl5v3bv6TbbTx6yceVlBuMJy2fOcPDsCd/8oz/gQRSw++QuzdBjb3+fvbuf0Wu3WVxZww9DfM8v6ttpg8IgHWc2GXJpYYFc5UyiKQeHRxwdHhFFQ6RSBJ6g13FxhGA0nOB6AQvdLg3Po+NJfEcgDZhoRJxnOGFI2Gjx0s3X2Ns/5MN7j1nttVhfX8dVKTqKyOMpSTRmPBrQanc5c3aTaOjx5N5HrKxf+nKyqAGtNK9cv8phv88v3nmHXGmMUTjSIUqTIr5XCi6d3yQaHuBKD+N6KGNQWUoyjRkcHzE46tNruLhokkyjzZSnT7aIplMazSZKaTqdNmkck2Upa+trLCws0O126B8e0/HyAkoJp4gLNqKowalj0nhKo+0jShciAnKlGYymxOk2STRiuRuQZym+69H2A3y/wYNoyPtvbxWuXcfleDDgoN9nMJpgtKLZ7vD6629itOLF9nNCX6K1ZDJNaHsOmSqBmqDA5bpwBXplDUpD+dsCZYKQgUyDNgZHS7RRSJmjdXlvL8FzBXkGGIEQRW1XbTRSCJQ2uI7L2bPrXL1wFkfnfHrnAavra1w5u4JSRyyfWWF41GdvopkcR3Q8zUsby+wej8mEwGv08MgZRDktP6fXcMiiYy6du0Xbe49xbpjEKR6a1TPr3H38BQYIPBeymI9+/le89fd+i1du3uDD25+SZhkvBoOiFqPJyLOURw8fsmNhOwbH9Vnq9djtHzDE4Ipiwv4kh+VGEccqhChTYA2UFSQRAml/qzAOQpa/02gQwpTxzRIc667UBQ4UElHGRhsjkI5Aa3suitqTQhR1QKUwSCEwWpThr4pyEyUoBVl+poiypqUUIKRBGIlWGbkSqBKOOlIWbk5dAmzBDO7XqlWrVq1atWqdpl8ZVOZ5zqVLlwjDkL29PXZ2dmZuSAtQLKzI83y2TJIknD17lo2NDYQQDIfDr4DDNE3p9/uzenOtVmsWR9lsNnFdl3a7zdHREcfHx7Mo2CiKvuLG0lpzeHhIFEVfgXunuRRPA5OnRaaeBvyqdRmroO/rYCB81aV5Wh28KkCr9uc0mGjdXfM1Iq2qQHkerM67S6twbH5fq87MMAxZXl4mCIIT27UQbL5WoV3G1iLd2dlhOBzOXHG2L2fOnJnBvzAM2djYoNvtzqJKhRAzF2b1uFUh6Lyb0+63hVrzbr8quLTLu65Lo9Gg2+3OXsuybAZKbYxxXtYRuXTpEltbWxwdHc0ce/v7+ywsLBAEwcy9ePHiRRqNxmzbVUdl1XladRPCybqm9pxXz5d9bl+ztSdt7dbq+bSOS8/zZvvRaDTo9Xqz/tpjYl2m9hhWY36rz+11X43/nY9+ta/PO0nnHbf2Pdte1UFZPWfVY2HPQxAEs1joJElmnxHT6XTmhLTA2YJJ65SN43hW39b3fQ4PDzk8PCRNi1o5Z86cIQgCjo6O2NvbYzKZfOW6rVWrVq1atWrVqlUr8MsJhlmG5zkI6eIKgeO4KF2WclAax3HxfB/ZdEoYU5Z3kBKjC/ejVpog9AiETxzHpFlaApwCUEhR1o8r69JhNFmuEaqIiJRA2GggRyMcR6IsUPL9wlkpBYsLPQ5VztaTx5y/dJmrl67y8cZFDg+PSbOsAHOZ4v2PP6O5fBatNNs7u1xdXyZsdzFHBzRccFyHTq/LzrZHFI9ZCy9w4eotRqnhyecfIdIRQdjADwMcx0M6Esf18KRPt+vRaoScPbPKeBoxGI4ZjceM8wxnMsFzJMvtJoHn0gtdfKe4N0qSFKMVnijcadINOdNqstrtMNpY5eh4wPufP6T/4jEXzixyYXODXq+LyTPyOMLVOWE0xfWbuK6DG7bQg0OkFxCNBgiT871vvk6aJvzkr/+KPJmyvHaeNM/wpCBJYzwp2d/vs75xDpUrsjRlVP7mEUUj0jQhy3KMEJw9u8bg8IBep4PveUjXIVNFrUwjBGmWk2cKYQy+7zEZKozMZ8BHygJS2ljP0fAY1w8xJQA2WuD5PlmWM41i7h/3+WR8SJpkZc3CItczV4pWq4UUEDSaCK2Ips8YxxlBs831m6/zyquv8/yL+0STIYstn2cvBsz8ccagjcCmehoDidEFiJSygGxSYFQB0i1HLWCvKeJGReG0xBg8BJ6QJLKAmhIB2pBlxT2gUjlK5RwfHfHZx+8z6u/RXNnk2vXrLDR9QNFuN9h//gWdpsfh9iH9aeG2Xeq28T3JeDwk1xpvqcvRNEEKn1YAOok4t3aGu892SDLNeHDI+rlLuEKQ6gJeyk6XdDzi83f+Pa//8Dd45cYNPrp9GxAMRiOk49PpLSClwyTTLHd7tAKPg71dEiVoNJsMRyPCwEcqRY5DrDShUwJFKByMorzn1aJwTRY+xZm51JTnr3CfgitFcdmr8rePWX3I8sNISBynWEYbjTACRxYgFFPEFeeiBKNGFhMJyvtsx4gCXKrivBa/R1DaOTUYXbh8KSpiOqIYD4Ii/rlYRxTnslatWrVq1apV6xT9yqByf3+f5eVlbPSj/aHfwh/r4ErTlMPDQ8bjMYeHh3ieh1KKvb29WZymBVdKKaIoIo7jGWQZjUYzF6Z1dzWbTZaWljhz5gzb29vs7+8zGAxIkmQGcSzImU6n9Pv9WZtWp0WCnvb8tOVOA5pfByLn9cvA4DzQqbZXXfbrgGrV1VVtt+pcs+4xOAm8qrBv3kVZ7fs8NLNtjkajGXSqrnsaULXnOwgCJpMJ9+7dYzgczt6DL52PSZKQpilhGCKEmNUfjOMY3/cZDAYMh0P6/f5XzsE89DXGkCQJ/X5/ts/WiWsdip7nnaiPCszqT9qYV3us4jgmSRKklDOHXbPZxPd9zp07NxuXtnbi4uIijUaD4XDIBx98wMWLF1lcXCRJEqIomrUdBAG+75PnOaPRiDRNkVIShiFBEKCU4vj4eLZte32kacpgMJhNGFhaWqLT6eD7PtPp9MvZ0ubLONvBYMDR0RGDwQClFJ1Oh263S6fTIQzDGZycr205X4PSOjRd153Vwqye99Og+Gku29MAbXUcz4/X+fqpdnxXXZLV/ShquaQzB6mFmkKIGaAcj8ez66nT6aCUYnd3ly+++ILRaMTS0hKqvJnv9/tsb2/PYqhr1apVq1atWrVq1apKCGgEPrLVwpGyiICliG3VWqOVQskyCtNxCheS0QXg8f3SweQhhAMUP/YjKJOHJFmeo3SGMOA4hRMTUbqqRFEr0JT9MEC31WDc7pKkOa5jSJMMVzrguICh12nhSNgfjknSmA1Xc/P1b7G/84womuAIgZaSJ3sHrD54zI1XXmP37m3WXv8NtPS5f/sDJntfEGxeoRn4XL5yjRdPHjLYf0bvlVu0ekv87McvGO5s0Ww0aLY6tDttHNejGYY0Wl1cP0A6El/6LAcevU4brRRpljKZJownU4bTKe40QTcCFjtNPFciRRGVKyVonaFTAypGCIcG4LRCWtcvs73U5emz59x7+0O6vuSl8+ucv3AODITTGK+9yHR0zLkrtxCux972cx4/2uLyxiorZ9d567vfJGw2+b/+4v/E0SmXL1/l+dOHNJstjoYjbtx8hfE4YpqMyNOMyWQMQpCmCtcNGQ8HpNOIpusxPuiz9OQRAkNqNJ7vIZpNTBAirr+E6wWUFju0MRitESUkksKQ21QZDXESk+cKRPl7QcGqMFqjdE6eJiRJTqoUtoYgFFGdMs85ODqk2y4mhkdxRqPV4syZNV6+9RrtdoPnz57Qabm4vst4MqXhS6SQBWAsRnsJzQEDaa6RonBpug6Fk9aA0EXEqOOWk1OVBiFRypCmORoIHMEkL6JGi5qUMJ4mnFls02h3cBwX7TV4sPWC/v4u4e4xr7z6Otf+zg8ZD4/pLSxw/fpL7PYPkUIzTjLQBhk0+fbNl+k0Ana2X7C7u00yzRmOfS4st3GPd7m4scb9py8wjsPhYMClixAGPsk0YZoqYg0tKRiMBjz44Kfc+O6vce3iBW7ff8Ta+ibxZMjouE9/GuM4krDZ4OLGGkvtkN39Pv2DA7JkyjTJCHyPHMneaMrZXogo41RtpquUgORLl6wWZXxr8dSUDkZ0MRZEYWtFlG7IYugUUbLCUI4NiSMkwhTRxAJQpvBJSqf8ncnY9w3a1sDEFCZPZdCOl0dRAAAgAElEQVRKYWQxMcIpOgIUNSmNAaMU2jg4wjowDUpBnUNUq1atWrVq1fo6/cqgcjqd8uTJE4IgmMW/Oo5DlmUAM9hiIzHjOJ45m548eUKSJDOwaAHKfH1G63abTqcEQTBz4PV6PVZXV4HCfWlhgy5nnVajJbMsYzQanQBMVlVYAr8cMFbXmV923m1o36/uy/z/84+nLXeaI/I0Vbc1H/1adQja51UXYbXPdnv2PMxD1Oq2qu8dHh7y9ttv02w2Z+fCngP7aMFRFVyFYUgcx7z77rscHx/PYJMFf1mWzZyweZ5z//79GbjTWs/GV7PZ5NmzZyfibav1P6sO0PF4zMOHD2exrTautgocu90uvV6PRqNBu92eRaRGUcRwOJwt6/s+xpgZDLfHR2vNtWvX6Pf7s/1SSs0iivM85+7du9y7d49Go8FoNOLTTz9lOBwShiGXL19mbW2N4XDI/fv32d/fJwgCLl26xLlz5zg6OuLOnTvs7u7SaDS4cuUKly5dYjQace/ePZ4/f47v+7z55pu8/PLLs7qeVWgcxzFHR0fs7+/PwObq6uoMelbrS1q3ZfX8zNejtDUb5+s6fl3E6/y1Zpepjsf5mNZqLc7qWKwCy6oz065vHbSu69LtdvE8j1arNYuQnk6n5HnOYDCg3+8zHo9pt9snoGfVfTkajXjx4sUMOkdRNKsfWqtWrVq1atWqVatWVQJAa6TOcVwfo3OkKECT7zsYXIwp6lhah5QpoSNCIv8f9t7sSXbszu/7nAMggVwqK2vf7r73xu4muznkcMQZkppdmpEs2WGHrVCEHeHwm8Nv/hP8atkvshyhUHiRFdbqGWm0jcjhkBwOyd7v7bsvVbf2ysodmVjP8QNw0HmTdXsoKsJShPG9UbeqMoGDA+Agow4++H5/aFSauSGlZSOtbG5BHjVqyyyuUUqB0AJ0grQdLMsBMpChDalE4SQpDddGLC5ycnKCEJm7SloSR1aQUjAHBJage7jPW2+/xS988Q3ahzuEYUj39ISq1yCMQ4LxiIE/YnN9Fbe1wkcff8j7H33McOcBv9Baxqo2EAKWN84x8Uc8evKY6sKYKzduklw4TzAJOTrYpb29Q61RhyTh2o1XkFFEFlkp8KpVLCubZ1i2hed6rC4tkChFECUM+gO2O0NkmtKsVmg2qtQsh7lqHZmnyURxzHjkk/hDbDTXN1a4srVBZ+jzbG+f2zvbDIKUd39hnSAMkXJApeax2HDw5ja4/f6fsnN4xO1PPuSLb7zC5rlzvP36LZ4+ecSDu3doLizRnF8kGPt0ul2Ggz7Ccqg4DmmqOD09xR+H2LbNwvIKfveYJFXEcYyfpIzHAUG/x2ueTT+KadRqVFyHdnMOXWtgeR5xHGOJfC6eE8gkikhV5nCDDEorrTMonaq8rmDGkKSAOAoRUmJjoVIB+W0BKSWTyRh/PKE/HNJoNEmSlKWFFpZV4dbrb/Hk3gdEoc9Co85J+xQdJ0jL1FUE8n5pMrhmQClAqhKUAmlZ2TiVFlopEpViC5HVZhV5ao8AISVzVYdOGIDIgRua8STErVR568vvEGmXMIkZ9boEYchwEvLk+S5vTyLWNi5wdPCMm6+8wr37D+kOhgzClL4/Zjjq8/xwn+uXL/Prv/FbNOIxf/cf/kMOuh26I5+rUcrW5ZvYUhADveEYrRRVt0J/HKKBUAkarkMaJ4y6bZ589CdcefOr9AYD9k46KCFwvBo6yhzR/V6P3cMTNpdbLC60SKKQ4cBjEgyJ05RJlBCFikGoaNqQoBHCxNzmD+zm51EIsIQgTVX+6SJIptKGTL1KLXIn6tS0Ow97zZy0qcrAYw4qdb6+yM8igJBZzK75WaRk4NjKXJIid3kaYGrljk4FYMkcmmYxtBYCLXQxJkuVKlWqVKlSpWb17wQqDw8PAV6ImjQQycQoDodDut0uSZIUQMC40dI0fcHpNx3NCZ+5tgyEMLGgvV6P4XAIwNHREaPRqACk0/DROKeiKHoBrp0FDY2m4db097Pen23vLGfm9HI/i84Ck7Pbetk+mBqC03DHgMrZY3vWvs4uPw0VZ5ef3rY5twbkTJ/LaThpXpsGYGEYcnh4yHg8Ltq0bZuFhQWGw2HhfqzVaiwsLLC4uEgQBACF47JWq+H7/gtRowaUTW/TcRyq1SorKysvOOmCICiAuhkrlUoFz/NYX19na2uLRqNBEAS02206nQ62bbOyssLc3BxRFHFyclL0odVqcenSJfb29rhz507RBwPAPM+j1+vxySefsLS0RJIkfPLJJxwfH+O6LnEc4zgO3W6XTz/9lOfPn+N5HpPJBM/zaLfbPHr0iO3tbWq1Gmmasry8XLiXd3Z2cByHS5cuFdfiNLw3580AxVqtVgDaWXepAZbToNK4E6fjW83X9LmehpImOvZlY3sask+7Yc3nw+c5mKfXmXVnGkBrnJTmQQbjpp1+QMLATbNdoPicUkpRr9eLa8y4aX3fL+qAlipVqlSpUqVKlSo1K9txM9dZZibLoJKKsZ0KUlrYjo3SkigKUeqzuYuQApWmmXNOSmwrL8MgMhKRRTpKpC0QafoZXMjXJYcI2d+1Mo/W1KRSUa3X6Y9O0OQwRCssy0GlCZZlI5zMffVs/5iod8KlG+v89m/8Glc2W/zjf/avifwxouKwtbXB3Tsf85XXrnFwuA+WjZeOqG5u0h9PcJPsYUGn6hHHEUe72/zu177Oq+/8OQadNkpaPLh7l52Hn/CTH/4xV9eXWFlZyY6DEPQHAyZhhCDJnXkWwnZQCGxpUatAbXkBtTRPmChGQ58jP8QZj2jWUubrHrWqR83zsICKYxFOfBh3iSYjWpU6X751lejmdQbjgKOTDs25KqkSjCY7TPyAX/6Lf4W33v0qVc/l9p2AP/hX/4p3v/g2ly5fZXVlmUcPbNY2NtHC5tnDO0zGPv/69/8x3/qN38KxHUKyeUgU96lWPVbW1kElaKWIgjGb66tE8w26px1OLEHLsqhkdkkaq5so28GxHY6P2szP1VGTCK0gJSXIHxZHgBQCx3awTGkNHaNUmo0RIYiTCLTCsjJILiwnc9dJgVKaoBfheh6EEU7FxpYw6A/4+jf+ElVbs7P9iEa9gtKC9mEbR5K5PBG5bTMb76lWaC3y7eTuOq1JU4VOFI6VRRtrAJXFiyIyB7HWijQbujQcK3P65WNBCBj5PkjJ2rmLeO+9R7/Xp90+JggDmssb3HrlVZ4+fsQvvPsOB7tPEW6Nyxe2OGqf0vAGDMeCOEk5OTpmudVi5+CAVy6f4+tf/yXef+89bj/e5YNHR3QigWMJgihhHEIYJ9Q8FyEGIG3sapNETZAq5nTgE6c7ePUWt27coD/6gOFY47pVbDHGnwREQcCzZ0/on9ap2hZKpdRrNYIgxPcnuI4FWjFRmqoGR2i0zq51mTupM5ekJs0JocxTzLTKXNbFQ8E5jMwZZP6fAZRZ9KrWeVQs0mTu5u5asymRu75Vfq4yh7aUIHRepzI/T8q4MsVnsb5yau6eQVONFBZSKM6odFSqVKlSpUqVKgX8O4DK6XhEA0CmXUyj0agAi7PgaxoOTIOz2ahO44QzriazrG3b7O7uIkQW7WqA0zSokFLi+z6DweCnHFyzYG4alhidBR/Pgpgvg5CzoHP2+2x/zgKjZ/08vc3Zfpt2Zutezm7zLKA6+/tZ+zbtSDXncmFhgevXr/Pqq68WDtbp8zgNnKbPn6n7+Pz5c+I4zuqv5O27rsvGxgaDwYDDw8MiSvXtt9/m8uXLhUO22Wzi+z61Wg0hBN/+9rd/ah/M2DCOvbm5OS5evIiUkiRJirjhxcVFRqMRg8GA4XBYRIB2u10WFhYKJ16SJIzHYxwne0LZOH1NlKrjODQajaK+4dzcHKPRqKgVmaYptVqNyWTC48ePefPNN2m1WkwmE3q9HkBR21KIrAbncDhkMplwenpagLMwDJlMJmitGQwGCCFYWlpia2uL4+PjwolqgNw0xDXuziAIijaAwhVtgG69Xi/gnBCi2NfZ2pMG3pm2p8fUtMN3FqDPjtXpMWqWna6LOTv2Zseqcd4aKDmZTAo3t6nFacBlGIYvuK9NX6rVauH21VoXtSejKKJarVKr1Qrwacb67GdHqVKlSpUqVapUqVJGnuchpMxgEpmbLE0TLEEW0ZqkCEviVhxSlbn/kjSFNJsf2dLCkjKPexRY0satVLAtmziOM3iX2zClZZOqFK0UlpW7oETmmJIiczQJKVloNjg97eC5HkkUkyb53+Mii5sUlo3taGKd8uMfv89/ev0a1y9usVZ9F43i7//DP+Dm1Wuk3jy37/wr0s4Bv7u8hjW3yLUrV2k2Gtj5fMlYr9ZWV3n/3iP+7t/8H9m4fAOdJJy/8QZzFcErt15hb/+Qi5vz2E4lc6BKQXV1lU63x6NH9znYfY7nVlhdXmZ+YYlaYw67ks1NLGlRrUhqyy2EZeURoim9JGUSKGQyouFZzM3PM7+4SOgPEN0T/EGHbucILSyaC2t4y6uE2JwOhwz7HRJl0e20matVOL+xSqpe5cOPPuHugwfsPH+OFpJ6tcor164yDnzG3UWuXbxMmkQ8vHeP9XPncSrZ/CKMYyZBQL1WY2Nzi87JASvLK6RJhNYxjWYVAQSuR2tzi3qjhuXWGfkTuifHVBybNOiQxEk2hiBzL1oyG19a4NaqOLaNRhArlbkdBQihiCd+Fiecg2vySNVUKaI4oFp1EcLl6LiTpWGFCZfe/HN84+u/zHd//+9RcySeW2P7yTOSKMSRAq1AZdVNczCeuWC1glhphNRkJVMlSAlaEydpVks1h6vCkln8cZLi5HBTofEcG0tAogGZOTX98YQoSQmHHbROQVh41SqTKOHixQu4UZenT4549Y03Wd04z/HxLtduvsLdh09Zmh/SGfgEccJwNOKk3WNppUd4YZNQWNz4wttYToOP7z7m0bPnCAFJmt2nOPUn1KtVJII0jki1ZBwnaMDScOqHeNsPaLQWeeXaFX7yyV2CVBElAqfaxLMESRzTHYzoVzyWGjX64w7YLk6SMhyHeJbI2o0SGjaARmuFnX9uqDxdVedg0ABBS4LQMofGGWQ002tpMmDNdFsJFJ9FywpDG8mc2UqnJCqrGSqEBJH5K2UOnKWQmUNSfzZvzzln7p7UBbikmB/r3HVp3MA/XeqoVKlSpUqVKlUK/h1AZRAEL0StTgMxAxTMMmeBr9kb+8YJOOuIMu0bcGMAk6m5Nw3rpiMjLcsiDEOGw2Hx/svg4Fm/T/fxrP6fBQtfBiteBv1eBg7P2vbPKgNxzgKsP4uzcxpqTu/b7P6ac3Xjxg2+9rWvcf36dYTI6pVOvz/tUDMutek6gwcHBwV8M2PAxJyORiMODw9xXZf19XXq9foL59i42gxQOms/Zx2hJrrTOPVMDUPXdVlZWSnqq5ramFLKos6j67ovOA+r1WrxfX5+vtjPWi2r67G8vMy5c+d4+PBhMX6N69Q4JsfjcQE0bdsunMGe52FZFvV6/QU3ozk+WU0aq4Cxtm2ztbWFlJLBYMDOzk7xvoG0Bsqenp7y9OlT7t+/z8nJyQtuZHM8TOxtq9Wi0WgwPz/P0tISzWYTy7IKx+V0DOz0wwfTr8+CRfPwwVnX4PQ5m4X3Zny8rPboZDIp6t4ad+xoNCqgLVBETne7XXzfx7bt4rw6jlMcWxPrayCzqXFrXjfHtFKplJCy1H9Q2h4oLv33//Tfdzde0LP/4bf/fXehVKlSpUqV+vcmIUUBZoSQmdNM2gU80AIEeW05rXKwI/I6hJlr0rLtPMI1fxCTbI7mOA5pmlBxHCzbASFIkpQkiTJwoVJEXtMwf+QvK3fhubQWFgjDkEE0wbItUpXNobXgM0ccmk/3Trj/kz/ll/7j/wJUymvXrvL4S29xrjXHTx49xKs43D9o88Mf/IBv/tqvM7e6ShzFWT3OShZ9itIordjY2uJv/eN/xF9b2eRL3/xL3LhxHdetIJIxJ/0+9qiDFjaJTvHcKpZlcW/3AX/47T8mCsdUPY/V5SWuXjxPohTRxGdzY4OVtXVcr0bFq2HZFWxbU6/ZKK2xbJvJJKQfxZycDHCFYrHVZH5xlUbNYzLqkSQJveEJg84RjuvRWt5g9epNhONy8Hyb2lyDTq/DjQvn+Z2/+B+xt/2A4WjI0ckJvj/k0zufsLpxnuXVcyRpgookj3cP6A97bJ2/iFdvUnOrJApsKfA8l5X1DYbdUzzPxXKyVB2lwalWkRIC3yceDOj3BvT9AM+KGUzGeUyvIAoDtM4eGK84FbSwcN0qaRIQhwFjf8Bk7BNMJlkikda0FhY5f/kqraVleqfHPH10n163h++PiZKYZs3DsiRRqNi89hZ/7b/8r3n84fc5OdlnYc6j0+nQPjwqbiKJPJLU1KlMlSiCRLUmc+lJgRQay8pcfmnuyFOpQlsC28ogpkpTkjSDmwCuI6lXbKI0wbCvFMnKtbfodEfU5lqsWhWa83Ocp8KFS5d58OkdHu8ecPn2J3zlnS9ytLdNbWmJC1sbHHd6tBpV+n4AKMYTH2FZDEZjJsEELSyuvnaTesNmZ/sZu6c9/FAQp4qne4e07Iy9xXHI4yePWJqrs9GqYekYx7FIk5Dtu+9z88vf4PzaCg+fHzDXrBCOR3iWwyhMSJOEVCZsba4xX3M4Pj6hS8pg5GNVXaJE4wgYa4UjNUIJUp2gVXa9W3ksLqgCCEqR3wMhrz1JVsYSBNmSoIRAaJXH8wI6L5mT5+pm01mJiYHNHzWGHHoqdA5LdWHUNEBUo7O2kVn9SZGndKFJtXFZ6s8gNn/2PalSpf6/0PagtPeWKlWq1H9o+rlB5VmadjxNw63paNjpL7PsNIicdQnOxo8aTbc/DabMcnEcM5lMiijPz4OBRme5EGfbfxl0PGu5l23rLAfn58ksf1bc5ctef1kfpmtXzvblZUDZrDfdroFG9XodpRT37t0rnK/GbWYci7Ntm5/jOObBgweFO9f0vVKpsLW1xePHjwuXYb/f5wc/+AGO4xQ1AaWURFGEZVns7+8XrkzTzmz0q9aak5MTxuMxYRhSqVQK8BYEAfV6nYWFBer1OpVKpQCjSin6/X7h3lxfX3/heNbrdS5evFi4+AysXVhY4MKFCxwcHNDv9wu4WqlUmJ+fp9PpcHBwwMLCAtVq9YUar1LKF4CkAWNxHBfAzESpmuNq3JzNZhPP814Ae2ma0m63efDgAQ8ePODZs2ecnp4WjmTTvnFIGmel53nU63WWlpZYX19nY2ODVqvF0tISnudh2/YL8NC08bLrdXoMwmdw08isa9zY09fJ9NiddkNOJhO63S7D4ZB+v0+/3y/GhQHDBpAa16eBmlrrAjgax2S1Wi0csGYMmdhY3/dfiLOdrotaqlSpUqVKlSpVqtSsKraD5VRIkwTLtrJ6i1qj0ySHDRlgyOJOwXFssEEpnUEDUwPeJJXkwEEKmYEDJUg1JHFUzLMc287bzMtwkEFLmTup0JqVhSajkQ/SYuSPkDJza4KNSuNssSTFqXh8+4P7XL75Yyqb12itXeRrXxry3oe3SSd9NrcuIHXC7ijihz/8Ie+++w6WVydNFFqn2E4FLQVCS7YWmyyev8KPvvsdfuu3/gK7zx7z9PED7t+/R7fTZWFhkcPeNjcubTH0R/RPDpl3Ur709lsstOZZX12h2Wyys/uc3/+Df854NGJzaZsvvvUqcaJxrAqra6u0Fhapzc2DzOaAri2oew3imkeSpHTDkFFvhIgjrCih5qSsL9YR0iJKFb3OPt3jA3RjgU8//BHrK0sgBa+8/i5vVleZbzTYefaQBw8e0O31efL4AQvLayRJTBhOmAQTBp026RD8YQ80uI7N8uo6V155izBQWJbN/OIK3U4bkhjLcjLnrFIcHx2hNfjjkDhVuFbCoHNUuOmSJGU4GFCpOOg4ztyTQrL37F7mTlQJSuUxoFpg2Q41z8W1FcP2DuP2Nv2hz+HhEVpk79crFSbBBITN1vVX+ev/zX/L6OApn3z8AXMNjyCM2Hn8lCSKsnWsbPwhyKOGTRXFDEzJfKymiSIVglSIHFTlfsDMZEyaJGghc0CuIIedQsC8a9EPE1KdQS6BZmFxkddu3MSq1DnaecTR6SlrqyusLi9w984eh8cdvvf97/HmW2+zsr5Ff9jlldde5fHODq2uyziMieIY3x+wMFdjcaHFqHdCrz9AVmtsXrrMSs0h/OA2vXFMBLSP9ok8GyFBJKCSmNFkwsCzaFiSps5qdYb+kO27H3Ll1hc5ancYhhFxorCtlKrnZmlGcczQn2A7DnNzdaIoIAxCgighSVMCUgZRwtZ8BSE0kM03U6VQQmCh8jq22blVObwUOSAsIqBNvVCR48Gp6Wr2saMpAqOlwBIpKlGkKouVznjx1D0xJEiFLSFVoLVE5sBUaxPla1Bn5u7MhqtEFvfzsljgUqVKlSpVqlSps/Rzg0oDhT7PuXeW23AWQgKFw8ro8wDeWY7BWfhp23bhqjoLjpwFDafbP2v7nwcWZ6HpWYBwFja+zKE5u95Z782udxbYfVkfZ6HPdJ8/D4YaKaVegFFPnjxhMpm8UH/QwEpTB3K2f9PnajQaMZlMXuhnpVJhY2OjgJhSSg4PDxkOh4RhSJqmRdyqAU3j8fiF2FEDsQykM6AqDEP6/T4nJycIIVhYWMBxHI6Pjwuw2Gq1Xog3NU7QNE0LiGdcfAayTrsHDXxzHIfV1VWuXLnCvXv3CndeHMcFGLx7927hkjQxp9PQ0PxsvpIkKcCa67rF8TVgzdSENTGn5uvo6Ij333+fjz76iP39fXzffyGm1zgkgcJJKoRgMBhgWRZHR0dsb28zPz/P8vIy58+f58KFC6ysrNBoNAp35fS4Mb9Pj38D9ozDc3o8Gc22Mz1WpZQF8B0OhwyHQ3q9Ht1ut4CSBhSfJbNtcx5NH4yrN45jwjCkXq9Tq9VecHZOtz0LU0uVKlWqVKlSpUqVOksVz0NrkLadg0oLhCSOJUKZAE+BY2mUtnLAmMUzaqUzcKAVQmXgQSmFZVvYtoPSWZSrPfU3s7SsDGqkGRg1sDNNszhVy7JRWmE7DkvLS4y3/SzSUQoEMnNXItAqAVuiFXQjzT/4g+/wl3+nSmt+hc0L1wniFCyH3sAn9Me0mlX2RxF/+J3v8eW336C5tIxOMhddxatm9fXSmC+/+w7/4O/8r/y9v/03ufmVX2ESh0xGpyAkiUrpdDpYUY+V1WWqrsN8c4Nrl87lNTQV9x494p/9i3/JaDCkUa/xxS9/hXrV46NPPuT53iGWEDRrHqtLS2xtrbO6vkmrtUClVkcICynArUjsxSaaeXx/jt3jPaKjNq6OadY95lstUm0R6gk0q+y126RxyqhzzNb56ywuLdFYWuXuziEHp0Pq8ytZ2YnJmGAyod89IfSHiKpDLXLwajX6oxEj/zGpUpy7+hp2xcW2LVoLS8RJymQ0QFaq+EHKOIyo1zycik3UO6Y3HoM28akpnfYJJ+0Oiuyh2ebcHJ5nY0mB53o4jp0jQTJnbaqxKy5e1SPVmnb7iKN2jzBOs0hiCY62UNi8/Yvf4j/5a/8Vae+QP/z+d6lXbUgjdp89I5iMM4fe1DwOKUiUApWByUQpUgUSiRQaQQ7Mc3CGyL4LrUiFAWw6+57HjJprouk5yH5QOPOCyYS//3/8HZy/8pd57cplnn74A7RwuXfvPrfDDzk9bdMfjUg/+YiPb3/Cl167xcn7e6ytrLC2tMTu/gnnlhpIrXneGfGdP/ouFy9d5ObVKzx49IjuwEdUPeTSJrduhnT9T3jeGxMnKXEqjVcUnSoUmnZvhG8JJolHxapRdTSD410Gq5u8fus67925T+p6jMZDXNtCpDFhrNjd32feq6BVildxqHk24XDCOIzA0oyimHHiULfJwZ7II1YVShWe1c/uKRmDgNIIrfOakOTHnhxYGzeleCGZVZA5X5Uo3srmyEJkIBKwhAWWwsrXsPLputSS1CyVQ8qMb2Zg1M7vqSiyObP6t3hYv1SpUqVKlSr1/z/93KDS3JyfBYBnxaDORjie1ZZxJ8Fn0aDTEOAsJ+BZ7j9TL288HhfxsC+LPv2zoOHstmb3ZxrAfR7EPGvbn/feyxybs/ty1noGdL0Mip61r9PLntXPl23Htm1OT0+zyWTuwDMgybgppx1zs8fTAGoDvU27nudRq9WKWoye55EkCcPhkMFggNaaWq1GGIYFyAuC4AVIaI7D9JeBfWEY0uv1XgCK7XYbKWURFWxqG6ZpSr1eZ25u7gXgaVkWrusSBEGxnNkXz/MK6FWr1bhx4wa7u7sF1IzjmPF4jOd5tNttqtUqly9f/inYbKBtrVYrju+0+9Ecl2mn4Hg8ZjgcopQqoGwcx9y+fZv33nuPnZ0dwjD8qXPxst+nXbLGuXh0dMT+/j5Pnz5lfX2dc+fOsb6+zvz8fOEAnR07047G6W1NOzinndXT43J6/EVRxOnpKfv7+7TbbYIgKBy80+Nq+toxbcOLjk/HcYplp52TZlkTBTt9TZmxOt3nWZhaqlSpUqVKlSpVqpSREFnsoXRyl2OqUJh5Ulo8VJuisCwHIQW2tEnTBGlJbFuS5gXqLGlhobFtC8u2SZIUkUcySpvMaWVqyqFJkxSUwjZ/J0tJpeJk7jetubRVpT8YEcWHSGkRxjHhJMayLaRdIVUJaBtbwn5vwh/+m+/yzV/9FsvLiyh9E8ep8ODxDp3ugCCYsNjwSGWFP37/DjfOrXDj1is4FQ9pWehUg0546/ol/s25q3z/hz/ilbe/xM7OHkfbj1g/d5nD3ac8e3iX1ms3aV2/hrCyBzlVqgjDgB+/9z7f+d73CIKI1nyL3/3d3+X6tSt88vGHnJ72ieOUQKX0x2N2jk95/94D6m6FhWaD9aVFzp8/z9rGFo35BYRtAYpqzeXcxecGTPUAACAASURBVMtE0QajwZDuoEf/ZISlUyq2oDVX5/LlZWK7zscf/ojrvs+117/ErVde43fClI2VVdqHu2w/eYTQKZMoYDwa4lZsUq3pD4dMgjGLyysMR2OO9naQwPlrr2F72fzJE4KV5RU2N1axdIzf7zLyxzx9+ggpbdxGE0tkDjZ/1CdWKZWqi2M7NGoui/N1GvVaHrHqZDGpSYJG4s0vY7sNhBD0T/bZ235MuztA5GMMBLYFdq3F13/zt/mt3/nL+Cd7/JN/9nsIFWCheL7zHJKY+bkqvi+JwoQ0zR5KtoWVz5M0cZLF1xrnZxZ5nM2tbJmBy9zMh9Iii7EVAkvo/LugMNwJaLgWTdfhNIgzh7EU7D3f5r0ffZ8fff87PN49wq5UqTgOrmMRhCHjICQ+POB7f/xd3n7zTeaaLbr9EW+88QbPnh/xZP+QNNVULYvdvV3+xt/4n/iFd97h9ZtXmEwC4jjGrTgsbV3gDX/M4MO7xLZTxKVKMgdpHCXgWFi2S6JlBmHJnNJ7D27z6le/xbmVRR7tHlCpzjEJAiq1Bo50CCPFcTRBCkUwGpJqqHoVRv4E4TlYtk2kBFUNQht3ZB66qvM4V62xZHZMBGTuSp1kdSm1RlsWUgikFAhN/sBD1svi3pX+DCDmH1Ygss8Zsr3Bys+hEGAJA2vz+bqByzo7b0IY56bIQWh2zGwkiVa5s7ucN5cqVapUqVKlztbPDSpt234BIBi4aFxt08sZuGIAxLRLydzoN+2Z96ddlgYEGFhg1p91WhmwEMdx4SiDFwHZbG28s6DgWU7RWVj4eY6ts36e3tZZ4G52Wy/b/sv6dFY/Pg8+zsLWs1yqL4ObRuZ8mHNu4kinQZtxnc3WFjRtGlef+d1xnAJCmlhSz/OK+otAEdlpgJP52fO8ombgtKNv2jkIUK/XOXfuHHEc43keQggajQaVSuWFKFHf9wtXqOu6hTvR9NNsz/d9giAonJJLS0uEYUgQBFiWxdbWFsvLy5yenhauvNFoxPLycgFNh8MhSZIA2ROMxtXoui71er1wPBpwaFyVjuMUx9i4WM1xj+OYvb09fN/n448/Zm9vr3CFzoL/2bE3O7bMsVRKMRqNGI1G7O3t0Wg02NjY4MKFC9nEf22tiM+dXse0aVyb5jWzjWnoZ67T6XETRRG+79Nut9ne3ub58+cMh0NqtVpRQ3T2Gp3ex+nPlunr18DT6dem65+aY2xgpem7abeI0ypdlaVKlSpVqlSpUqXOUBwECCERMkUIjcpJjbRspO3k4CHJo14VttAIy87nvBqtNJaUpArSJAYp0ArSSKF1VkeO3OUlEfl6+d/2UiCdSgEeBBqVJpnjUqVY0ubc5gqjQZ9gMsF1HCYKVJKCrbAtixRIVIojJPf32njf/QG/+PVfYmV5ARDYjsvO3iFHJx0GvQFNL+XatSvsdoYcfP9HvHrtMqsb61hOBSGg6br8uV/5ZX7v//zb3H3/R1z74le5tLlB1aty5/4DPvr0U/75d3+AZQle/eJXSIXkyeMnfO8H3+fx9nOUVmxubvEbv/FbNBzFez/4NvcePWUcRKRKkaRpHombgZRhEDMKe+y1e3z04AmeY7O1tszW1gZbW+dYWN2g4lXxag1cr8byyjJJmhAFIb1+j2edHvu9Xc5trrPYnOP2+3/KyUmb19/5KtV6nb2dJwz7PVJgMh6i44CK41BxsvsZ++0h7dMe1zcHbJ3bQAtBv3tCevc9Ll27ibe6heXWufrKF4iGXfzugOEwoD8cMBz0mV9YRAqLOBhAGlJzbTZXl7K6knFMmiaMx2NUEmecycApJO7cAsF4TDry6Z4ccnh4wGgcEKdgWSlSZNGscwub/OZf/et861e/yeh4n+/8yz9AqQmOpTh4vkcSjnFdG1u6KAVSCsIQ0lRlNUh15vpNNSRJ+hlUy8JHkTJDbY6VQTXHAiksUp1FgWqtSbVGIZCpysCbyOJkW1WHXhiT5DUR4yRl9+iEVy9tYFuC8WSMP1agUuIkKeKNP/30Nnfv3ef6+Svc/fCHbG2e48LWKn4YMkwt/NEYKz6hNxzxRz/8EUfdHl+4fglbZoDfciqcv3qDLwyG7HSHBEGIFApNNr7mXIf5RpWGa7M+51K1yRyHQhBPBuw8uM2Fi9fYPTgisSuINEYlMZNgQr0xh7QFS60GOqixf3DEKMhqufpRim3DOErwpKSaw1tBBhGVcSZqQapy56TI4lotM3cXFlIKbJmBRaWzcyGRfEaCs+vD0hJ0kse5UgBXIQSWsMgPZx7patbMz1GGKXO3pipcvFrrvNauzMC1yFq1cmBZqlSpUqVKlSp1ln5uUNlsNosITiPHcYq6bgZeGcBj3HZxHP8UVJh2QU1HUU4vmyQJlUqlcJAZeGEgjZSSarWKbdu02+0CcMzCi7NA5LSm3z/LZWl+/lkiK2aBpHltGg6+rA8va2d2/enfzdc0GJp9f7r9s/bDgJzZ/kz3wQCn6ehL27aLmorGHVupVGg0GgD4vs94PC7aNDGmURS90CcDntrtNsPhECklKysrvPHGG0VU5/b2djFOTOTM0tISFy5c4NKlS1SrVZIkKaJZTVsGNF68eJGLFy8Sx3ERG2qiZI0T1Pf9YvvGGWpchWZsSymp1+tFzcMwDLEsi1qtRhAERV3DarXK9evXOTk54fDw8AXnnuM4jEYjnj17VoBOsy0D3w0Atm37hW27rlucw8lkwnA4JAiCwqUYBAHb29scHR1xfHyMEALXdQsQOn1+zwL3s5ByelkDRjudDr1ej2fPnrG2tsbFixe5cuUKly5dKmJ1zfrTDzFM13mcdipOj0fjCh2NRpycnPD8+XN2d3c5Pj4uQK655s3YmB3TZzmGp/dh1t1pPjfMuTZQdxZUTtfILCFlqVKlSpUqVapUqZdKALkjSWsBWmFJiWPbSNsiTVKkthCWlVd2AynArtgUVf80JEoTiSzGM02TDHZKGyGyeoCp1sQqwdZZPUvLEtiWg1eto7QmCHwqtoOQFvFkjFYpidY0vQqrG2vcv/+QOUvgujZRqHMIorFthyTOd0RY3N4+QH/3j/mFr/0iayuLVFyXarXOQqvF7v4xJ+1TDg+OuHJ+g9Td5NO9Qx49P2BtaZ7V1SWazSZfefUyd974Ej/6+A43X3mV1toWGnjz9deIwgk/+egO//pPPmA0STkNEj65e5fhoI/Wmopj8+bNK8TDI+4dHnB40sGpLdJa8Tjce4rSpr5nVvsTrfLIUUGQKvwwYhTu8/TwiFd7A37j4lXCMMAPxgitcb0qbrVGtdZgfnGR9HxKFKdEUcJOZ8x4OOHkow+IxiNUdZ7xcECaJCT5HEGphLrjgtZEcUKSQNXziCchxzvPaS4tUnVskjjgzofv0R98lxuvvMnVC5fp9YdE45ClxRZH+09wPY/RoE+nfczO9lNsKbh+7QpxklJxnHwc2AgEYWRihCFOU7xqA6KE3UePmF9YZH9vn1RBFKconcV3pthcev1L/O5f+c9485WrPPn4PT756H0mwQAdTzjY3SUa+7gVJwNPWlOtgmXZaMaEQZyDSvK44Rw2IvKak2BJQcWxsKXAsTKXZZKmKBRCgyVAC0GSRxwrc9HksGvOtXCEINXGjanZPzjmtSvnubi+wsO9E8JYEYcRiUrxajUqbpVg6PMnf/J9bt3469Tqc/QGY1595RbPdg8YjRKWV1dZXqyxt3dIZzhhd2+fOAh4/eYlmvVGFpcsJZeuX0M8uMe9/TFKq8wxKKHp2dxareNZIoe0mkRnbkutNKe7T1k5d5nL5zf49OketuuhJSgdMhkNmCSKquux3JhjqeljyTEDnTIKY5oVhyhJ6QUar25PxeGSjWmRxb0K47VUWdyrkBYV28ISEi0UCE0cxUQpVBwTswtKZ98NzEdLpMicmmIKQ5JDytyqnQFSA0zRuXtW5YAzNy/ozFWZQeg0d2tahct7+t5CqVKlSpUqVarUtH5uULm+vo7Wmrm5OSD7g9HzvKL2nanl1mg0CMOQarWKEILxeFyAJAO8pmsAGhek53kEQUCj0UBrje/71Ot1oigq6iGadk2Nw0ajQZqm7OzsFK8Z+DALB2dBnnnN7MvPolkgMvv6yxyNnwc5P88leRY4fVlfz+rPWX37szQLdNI0pVqtsrm5ied5RTu2bVOv16lWqwwGA3q9Hs1mk9XVVaSUdLtd+v1+AXwsyyog1/S5MQ6909NT+v0+9Xqd9fV11tfXcV2X3d1dTk5OCIKggLLz8/Ncu3aNt956i3PnznF0dMRgMOD4+JjRaMSjR4+QUhb1MBcXF7l16xYLCwscHR3x4YcfFjGpxiE67Wo0gE1rzWQyIQiCwuFrxvlkMinAuYH4BmhJKbl16xaPHj3i8PCwOI6j0aiAve12+4VrwUS9mrE+DdAM2Hccp4hKDcOQwWDwgtt0Mpng+z7dbrcAa2Y/pl2nxqE8CwrN79Ou1elanObLgN3t7W3a7Ta7u7scHh5y/fp1NjY2aDabhWNy2oFozp9p38BnA7HH4zHHx8c8f/6cnZ0d9vb2iv2rVCovxPpO93M6Qno6rvfzIpGn64IaF61xZU9H65pIXwOZz3JAlypVqlSpUqVKlSpVKK/DZ9sOqVIILbEdGyElWuUuJEn+97LMXJAILAQiLwaX+ePAtiyiNCVNElSSImX2N3CaO6BsWQGl0CrFtqwMRsUhSAvbcjJHWhRlkFS6aCGIo5it5Rbh+BzD0ZB0HGA7dgYmlEKnWb1MpCTVGdy49/wE9b0f8uWvvsvywjKeW6XRmGN5cZGj0x6HR6c8O2wzXx3x1vULWI0WewfH3N45QSR7bC23+M1vfYN/9H8f8qc/+ZCvfq2OVfFodzo8evSYX37nTXYDl8OjbdY2znMxTHh0/2PmvCpXLpxj6/w5bKdCPVRcX7vK4tp5bt+5w3gyZNTvkiRxdmyFIEoTVBKhZVavz8wN6p7HlYtb+Kf79DqnDAZDRsMhaZpQr9dZWFmlubBIfa5FpeJR9aosLi6QKMFg5NMZh+w++DGxBj8McWybqlslmCRUvAZzC+v02nssthxWFi+zvLSMZdlM/BFSWtTm1mhtLbJcqbN14TL1pRU6gy4f/OSPsFTK8ekJqUoIwogoSnh6cEq3N8KrN2jN1ZhrNKhUHGzLxrGtzJGYKlItcGwIwoAHDx/RG46w9w7xPI9GzcN2LKSwaa1d4J1f+jW++a1v4qVj/p//63/npH1IzRWMRz32d3dJAx/XEWgEaZJkscS2k89/qlhSEgQRYRiT6sxp6QqJzmtVmvhXSwpsKajYVkbJrPwBUQ1J7rjLWVjuxsyktMa2BHOuTTCJIX9/MPI5PO2xtdQkjBMOOkPa/ohma4XlxQW67WN6gy4fffgBT375V9g4f4UHt3/C+QsX2VxbZjA5xKvWWW6tIJOYujfiqNunbVW4/WCHd964jp6M6Y98vGqN1c1zbB91GarsoQBbCPZPBzTrVa4ueFm/Uk2CRqfZcUCljEY+Vy5f4vi0R7s3IhiHJEmIUlm91k63y1xlIZvz68/Wi+IYB4mUFlpIQH0GCoUix4JZlCoZdRQakjRzs9pSIiRIlT3goEz0q8jAsAHLOo+KRmuUNjG9WRQvZDyU3B1rzop5SUiJpbN9Nm9kUDLbgCVE9nlB/tBA3qAtPivTUqpUqVKlSpUqNa2fG1Sam/T1er24iW/iJk2dSBOZCVncJmQxnLM140xbURQVrrJpZ6WBPtPgxMAJ13WJoqiACKPRiIODA3zfB16s5TgN3D4vhvUsF+JZYG/WkTXt4Jxu6yx9Hoj8WeDHbNuzDtU/K7b18/pylttsun/Ly8t861vfolarvVAb0PM8bNum0+lwfHwMwPz8fPHdjBHbthmNRi/UA4QM3i0sLHDt2jWePXtGr9djYWGBzc1NKpUK1WqVVqvFwsJCFm+Tj5G1tTWWl5cL95tSCt/3uXPnDkmSUKvVijjZOI6ZTCZIKVlcXKRSqbC3t8eHH35Ip9MpxrLv+wWoHA6HOI5DEAT4vl/A9FnAbhzAYRgWQM5Ar42NDVZWVnBdt4CGo9GI9fV1qtUqx8fH2LZdHOvp2pAGlBoHahzHpGlKpVIhjrMJWxAEBYg1x2U8HtPv94sIW3Osp0GeAY+zwHL6d/P+7JicXSaOYzqdDsPhkE6nw97eHrdu3eLq1avFOTT7NO1SNDU/pyHxYDBgd3eXJ0+esLOzQ6fTKeqQGke1AZrmWE3Dw+njNj2mjUPT1BWd3qfZ/TEOW+OOVUoVkbC2bdNoNIq+lLU2SpUqVapUqVKlSp0l27HRKkWlMVJaGYg0czYhESIDloj84TkpsSw7c2bloAcEUmsQULEEStqkliR/CQuJcCQgSEUM0srAjxZokdWLy+YuGkeKz6JRVQI6pVpxOLe5zt37A7ROaVTrBHFMMAlIdVYTU2cWLBAZsHxy1CH83g9554tvsrBxAc/boNFs0lposb62wnGnx8nJKc+P+1jHbTZWlrh5/hUSaXNw0uXauS2ufOErPH9+F+vuNo7rIW2LG194F7di8d/953+JH995Srd9RKgdRDjirddv8c4vfoOLV69zfHLKw/v3cVyP4dBnZWmR/sY5jrQiDPzMcSYEWimCKGI8CVA6xRYWlhA0qxWOdp6y8/BeVvc+TjN4kzv7LHmfiluh2ZxjYXmFpZU15pdWqTaazNdryNYcyaTN4XKLKBxhS40tBZoav/0X/ypvf/mX+Fv/y//M0fNHDH2fmudyaWsNZ2kTt+KytrLGL/7qb7K8dY5w7HPngx/z3T/4Jzy8dwfXdREVD4QmSVLanQE3Lp9nkmikyJJ1pCVxhYUGwmBCEEbYTgWN4PD4mON2H6vi5ZG72ZwrSQXL65e58caXeeerv8TGcouDh3f49M7HdE72qTqKzqlP+2AfkYR4lkCpBCFtbCtz3aVSoWwnv+cjEEKidIoOUlLj/JMgtSTV+TxJy2x9NEGSZJA+d+SBRmuRQy5dmPjyYY+UguW6Qy9MiBTZGE8Vj3b2ubi5wkKtQhQ6HOwHVD0PkUyIo4jVlWVWmy6P7n7CpV/9dRzbZeAHXL50nu2DY6qezbVza3SeP2Jlvk59bp7l89c4Ptjj4fYhl9ZbxEmKqzVzi6tc3Fqn//g541QTK43rVqhU7MyRqDInpVLZL6kW1BfXiQKfnf0jzm+sctof4c018Yd9VJpgKc1o5HO738WyHeJwgkZh2xbjMMbBRQtFqBRzTh7Lqgw2BKE15PUptdb5ZwWoVBGlKoOXIi2OZ5KmSCFRxYPH2Vem7NpWeW1Jkf/7DCBn14Qmg87kLk6zrkAjtAITO50/WGEBDlZeH9OUwCznzaVKlSpVqlSps/Vzg8rBYIAQgmq1WjiX4jhmPB4XDq8kSbBtu4hQNHDGgBYDegwYDIKgiAc1QMO49qIoYjKZFG4m13ULwGHAKGQRo71ejyiKCnh4FoycBZKz7xu97P2zQOdsjMVZrs3Z9qfbOOv9s7Y1q7OA5r+tw+vzgOb0MfA8j83NTV599dUi4tTsuwGF8/PzzM3NMZlMivUWFhaoVqt4nofruty7d684l9PbabVaXL58mffff59+v8/Nmzc5f/58ARBd16VWq70A3cx4qlar+L7P3t4eh4eHRFGEZVlcuHCBRqPBeDzGsqwC4J2enuK6LhsbG9i2je/7BRQ30bVmbBlAOAvAzLan66maKNggCIovx3FYW1tjcXGR4+PjYkyb2FxzDU3DzyiKivhYrbN6nqZG5jS4N+5D27aLa86yrAK2wmfAfzYedRZKnnUNSCmLCF/jJp0dZ9NjNIoijo+P8X2ffr9Pu93mxo0bxXkwIBEoQJ9Z3/d9Op0Ou7u7PHv2jP39fXzfL87HtNNxOpbV9NM4Lc1xn3ZMpmnKcDjk9PSU4XBYbH8amE7XvzXn3XwuOY5T1E61bRvPy56eNZC6VKlSpUqVKlWqVKlZmeREaWVOSq0FqUpz8Jjd9FcIpAYpMthg6rtJzN/ZGqUyB6VtuaRKYduq+PteaI20snpwpHkbjo0Q1gv15TQKlSqygnSZM0tKARoWGh7nL5zn4cNHhMEInRXGw5IyA5t5/T+NJkUQpyl7nQGTH77Pm68OuHj1Ol5rnnGtRr0RsLq0xPjCOYZ+wOFJm8Nel/3OThZH6zjE4xG/+Wt/ngcfLnBucwPPq6KASRASRDGdw2OuXlyneusKv/ytb3L7g5+wUpe89c677B8ecXJ0SK3eYBKExHGEY1u05ltE4ZgoaJDEEeFkhEpjBE4BbMIoyWolRgF7e2NjG8vQjM6dYyI73skkYBIEHJ20sR7cx6t4zM/NsbS2xuLaBsFkyDs3z7PkZi44r7VKa2GFpfk6x9t3+dq7X6R9eYso9HGEwLEt7IpHnKbsHDyn+w/+N2r1OqedLvcfPGRvby+bb6VdtMjmaJZto5AcH59iWxYHQ+j1+lQcB52maJXiOBb1Ro0gHiKE5ODwhFQ4NC1wpIVbbbK6eZFrr77FjZuvsrS0TOfgGb/3b36PYDKiImJsEvrdAd32ISJJsK08QljagCRVKUEcIxAolQJmDiWo2DaRiHP4mMEtobMAUZUfW9e2iJOURGmETnNolRksEVnMqwGXZsxmEbKCOa9CsxJxOsn9e0JwctrhpDtiaa7BaX9Ea67OUbfLZDBgabHF5vIcLoqjncfsHxywsnGeZw9vs3XxCsv3HrN/9Jx/ev82lmOzsrJM03HZXJun/fwJQVSjOwppzdWy/kvB5sULHJx02OuPQWvOLzXZqlsIrTJXI2SgWjvo2hKLF2/w4Q++Tegt8Bf+/NdZ3D2kOw6xBSAlrucyHPokaUp9fpFWzaLdHaKEjdAxQZKAJRgEkqolsfManQpVQFxB9lkhEDkUzpyOxWePzo6VJrt/kIrM0W1qTwop8vqSAmFZCK1z52UW8SrNe/kVIsnAf5b2mwFpQeayFmT3ZgQCpPnkM3G9Ii+NKVBn33IqVapUqVKlSpX6+UFlHMeFewk+i1BxXfcFR55t2y9EWpqfDVSoVqtFnUsDSgx0StO0AJVJkhRwslqtFoC0VqvheR5SSsIw5NmzZwXMmY2pnI2ynN6m0SzUNK+9zF35ZwG+2eV+Vkg5u/2z4ml/1rjZs9yVs9udbW/2Z7Pu4uIiFy5cKM7JdHsGoNm2TbPZxHXdF+JPXdel2WwWccCdTuenjlm9XmdlZYXBYIDv+7RaLTY2NgjDsHAR1uv1IgLV1JK0bZsLFy5w//597t69y/b2NpVKhaWlJcbjcRFR7HkenuehlGJ/fx/HcWg0GrzzzjsopTg4OEDrLMa40WgUy5takpZlMRqNCuA37Qw20FwpxXg8ZjweFy7M0WjE2toam5ubHB0dFesNBoNiO5PJpABt5riZ7+ZBAHPMzXsG1Pq+X7gSDQzs9XoIIWg0GsUDA8ZpbMbLNOifjmWdvmYsy6LZbCKEKPowPTamweU09AyCgCdPnnB8fMz+/j6vv/46169fZ3Fxsfg8mHY6TiYTDg4O2N7eZnd3l3a7TRzH1Gq1AsKahxWMG3J2m9Pnw8S4GiVJQr/fp9vtFrU8Dag0x8GyrCK62gDP8XhcxEybByaMw9YA4SAIfmoslypVqlSpUqVKlSolLQfbyWJWtUpJVZIBJpnNH6SwkFZWjVIDiQJEdsP/s/pvWeSktOwMSCqFVgopBHbFQQgbYTnESZKBAJ3HbkqRP7CY1bUs/sa3BEJLtM5iJbPtaC6uLhElivfff5+KAK9WJ1WaOH8A1JICbSk0Vg6iBKNJxA8/us/O8z3eevMLtDbO4brzxFFMPU5YXoSL5zaJ4oQwjjntj5j4YyZasO7Z7M41qTTmcWs1mnNz1Oo1qlWPxdY89aqHVilBGPGNb/wKaRzx8OEDjttdEDZREhLFEePJmCgKkQJa84vIRcn+86fEUZRDNY0tLeYbHkGc4ukYnaaoHMOIvKaiKc0nC7CrM3ipMzgzjseM/TGHx8dYn97BTxSrC03iKKZac1lfWWZOhpwcPAMhmIwGpLkz9XgwJAkT5hcXiKKEQeeIqudQqbhoNI4Na+srxIkiijJYO5mMiaMYISRxapNoASpmOApRWpGkKWma0Go0qAcJKneuJbjU6/PMLy2zee4i12/eZGNtAyktTnaf8sGffIdg/P+y96Y7kiXnmeZjZmfxPfbIjMzKpSprryI5I5EzIqVuNFrE/KAkipfQcyczVzIzlyAIlP4IIgZQC+jWQopUbVm5L5GxeoTvfhYzmx9mduKEV2SRrGk0hOZ5E4lY/Kxmdhxh/tj7fmNSpUkjWMynTM5OKeYz8O2lS+NqKhrtWsi7fTHGuWuxpEmCkgqBdcC4LP1Ycm0qBUSRJI4E2hhKa5xT2FqwrhpiAFjCunZ3YMvB8ACNlYStdsT5sqC0Dtjlec5nD57w737/QzqdhM21AafnU6aLJdFkyrWNPqXUTEZnPPjiU37w/T8ievoQIyLefvM2J+cjhtM5i0yzd+sOP/7zHzF89iVP2pKjxZzD04JWskUrjhAWut0+t9/YY7R4jI27LGWXhycLEpsTCTdWtEjZvPshd+/e4tEv/5FXZ1Pu7cXkiwU393YYPnyKStvMRud02i3SdsJy7OaUysR0Wilal+RY5oUmTSMmi5z1tE0cCQQGP4u+WHxgXH1MrHdfe7jo6lh6t6MQzk3p43W1B80Xi+1tzV0J+HGkfW3dsKDCQUrjYLMQSCv9+QKWdM+KMNa7a4V3Yl84Za397RbUN2rUqFGjRo1+d/SNQeXOzg5xHLOzs4NSCq01nU6nAnqTyYTlckm/36/iN+EiCjS4x9I0reBMgBUAaZpWoDI4K9M0pSiKChwZY+h0OiRJQqvV4vDwsFqFCJedgEGroO8qSLn68yqMrO+7Gtf6ukjZ1/28qvpxroKgv8nPq2Dz6+7x12l1+62tQo2SoAAAIABJREFULW7fvs3Z2Vl1/DrsqUeWSimrOODhcFjtI6VkOBwyGo0unSe4MkOUaoj3VEpV7sher8fW1lZ1j/P5nK2tLe7cuUMURTx69IiXL19W42Q2m10CTTs7O6yvrzMYDHj16hXPnz/n2rVrfO9736Pb7fLzn/+c0WjE2toaW1tb1fgCODs7o9PpVPGvwdm3WCwuQb0A3oKrOLh8O50O29vbVWSrtZbJZIKUkn6/z3K5JIqiSxGwASDWnaPBXVkHdsvlklarhRCiilgN0Ljb7V4CoHUnawB0wUVYdzfW+ybLsmqbuupgve5wDP+LouD8/JzFYsHp6SkHBwd8/PHH7O3tVe8XZVkynU45ODjgyy+/5MWLF9UzHEBxvXZnFEUURXGpTcK9TSaTrzhGg4qiqGJfA+gO0cUBdAZ3ZB2Ehr4O4zCcL1xjAyobNWrUqFGjRo0avU7OaaTR2mCs9tGuCqEUUkYkkYuPtNZBB4vFCuVAj4wqNxRYtDHOdiZq4EgI4ijGSjcXS+IIbTTGWEpt0Dq/mF9KiRIudjM42IyxWKOrOcA7t64jxHd58uihK39gNUWZo7VAKkVkY5QEESkUltJajLa8OFsw+Ydfcvv6Pm/de5P1nevYXpes0BitWZNurnRr77oDs1JhrOD2vXv0um1aSUwrTUiShFJr5rMFeWmIkpS1NOHZk8c8fPiIZaEpck1R5CyXC6bjCfPpjCzPkVKxs72DEPDsyQPyIgdriSNFp50ghWBvvcf0/BRrDVJID8w8RBHWwxS8s9VFWRorKshifeyltiWRhcOTc16NF+Ra8/MH+wy6LXa3Nrm+u8X6+hqdToe1bsL25i0Q0tXK1Jb1rTWW86lbZF2UWFMSA91OTLrewQjJdL5guVwAkla7S2ewQavdQ0rFfJmRZzlalwggbbfoDzYYrK3T7/WYDo+YHL1EzU84eaQ5ePg557M5UkKnHTFoCYrlgrOzMxbjEbrIEQIiKZFKYUwtNYgLZ68QAiV9W1hQsSRtJXQ6KaWxFEUtcUoIYinISk2pnRNQCYH2dRNtLWYUYfx49HM44Zy8UjjHXrcV008KzjKNq9lo2T884uD0JuuDAeejGTevbfP88ITxdMZ0kbMRRywXcw6fP2T/9m16vT6TWc77H37E0xcvmcwzZrnmiy8f8fCzX1HOxrQjgR4vmZQFj1+UfPj2LYxxkbvX927w/MUrRlbQ7SScHJwyXixRUhLFKR/9/rfYXUv5xd//jNlywb3tDl1KDp884M0PvsWz/UNOtSWK3KLXSAowhmwxJ0kVxjhHqgaw7nOVaW44XUS0ewlSSOe/9uBQl67NhHKRrDbEuQqD8G8q2gbY6OvdGudytX4xg7aunqQzszo3qxTC1dG0BozrG2vwv8NXyHTO7GAOEFK4OFrAIv0CC0KHOvhfWwzQqFGjRo0aNWq0qm8MKoOzaTqdVo7INE0rJ2Se58xmswpuBHgQauiF+n+tVot2u105vkJka4iQDNGLo9GIdrtdRT4GeBTgZZIk7O/v8/Tp0wqqwK8Hc6+Lf70KZP46XeVK/HXXcdXrq9ezepzf1MH5ddf5dfCyfq5w/gCgNjY2uHbtGpPJhDzPLzlmQ5Rp6O8AKuvHFUKQ53kFD+vXEsbBcDgky7IKfE4mE6bTaeWgDDApz3MmkwnvvfceN2/eZH9/nydPnlAUBVtbW6ytrVXbj8fjymU3HA751a9+xXw+59GjR3z66ackScK3vvUtlFL88z//8yWAF2JEQ6xxqHkZ6hdOJpNqEhcgbYgXnc1mDAaDaowGAHp0dHTJKRkiYENkbB0Al2VJlmV0Oh3iOEZKWdWdDA5LIUT17J2dnVXPTh0YlmVZHTP8HMBycCVeBdSNMRVkDqC0Xsux3rfh+3CsOrgNMa6np6e888473Lt3j8FgwGw24+joiMPDQ87OzipAHcZPcGmH+wmLFELUVf09o96WAW6G2Nf5fF6Byvq4C/cyn88r4Fm/hwAnV9ssxOAGt2+jRo0aNWrUqFGjRqsStVp84W9mtxgzQqrIR3uC1QaUAwYyfOjvIZk1Fiuc48xog7Xa+y/9fBHQpQZbIoX17kB3LmNdjGmoWQk+8tHXm1PSJcEGGKqQ3Lu5Q7Zc8uLpYyyQpC10UVAWLv7VWOGcnRqyvEApQzuKmC0LHrw84WA45vr2U67v7rB38ybtwQZWJRTaLYw0WqOAVqxIkghlDLbUyBSSJAYd0ZUKOZ3w4tlDnjx9xmyeYawgq39GMB4xGp0zm0zQuqTTadHvdXnw5efk87Grp2ddTUMlBZuDLvPzM1dPDzDWALLmPgtOQF+rT0UoAQqBEb6PrNvP+KjeWAnSKGJZlMzzgnlecjRe8OTVEYmCSCnWOi067RYb/Q4bGxv0Bmuu1uX2FlGcgJDOcbpckGVLsmWGKQrSRCCRKGFJYkHbLliLO6xvbtIabDr4ZCWiVvsUBJPxiP2nj9k/2CdutVhbG3H92g47G10UlulkxOHhCF1mRMK6Nk9a3g2pkT5e1AoHz42+mB+F+9fGIiUoGVHKgm6n5efrGXlRIhBEyrkqrTUYIArRn1IgjPMJC3EBgSW+O7wLz7gCiRhACctGJ2JSaErjxnxeFHz+8Bl/+HsfMuh1KbSmm8acFgUHw3PWem10WTI8PuLn//W/0Nm4zu61HUQiuHPzJgdHQwZ9xav9A/7qb/6ej95+A5GmbGz2GM8WjOcZs3lGrxUDlrTT4Y0b15k9ecHx4T5KCja6baJIoGTE/OV9Hr0oWW9F7HXbru2s4fx4H/P+t9jZ6DOcLljb2OD8bEhRlqi0xSLPmM1ydJEjQ3yugKzQxAK0lQ4EArq0gEEJfEVPN3Y1FmFBexd2Fdhaxb8aF/OML00k3HuTNZYS19dSOGersda/bzg4jYfHQgqUf905KR3MlEK6/aqg2AAt7cU/68ZOAyobNWrUqFGjRq/TNwaVk8mEOI5ptVokSVL94RrASQAuwSEXwEOo5RaAQnBiBRddlmUVOAj19eq1+UKdwQDHAshZLBYcHR0xHo8r0LAaS7oKYb4OEob/rwOZrwN9r4uCvcqVeZXb86p96xG29XOv1uerH+d1uuq1AJ6+bjtrLdvb29y5c4cbN26wWCwq12To+9DHAdrFcUySJNVEUkrJYDBgNBpRlmXlZgvH39vbY3Nzk0ePHjGdTtna2iJJEg4ODjg/PwdgNBpVDr1Q+/Gtt95iMBhUbshut8udO3fY2dnh9PSUwWBQAURjDA8ePOCzzz6rXLzj8Zif/vSn/Pmf/znvvfceAD/72c949OhRdW1a6yomNo7jCjKGGOI4jivQOBwOOTw85PT0FCEE29vbFezqdrvcunWLs7OzKl40yzKm02m1/3g8ZrlcMhgMKlgaQOTGxkb1HAXX5NraGrdu3eLmzZtVTcvRaEQcx1XbB9gZxlCIlA19nySJW+27tkZZlozH48opGoBggJlwASwDlK47MevbWXtRT9YYw2Kx4PHjx4xGI46Ojrhx40YVA5znOXEcs7a2xmKxQGtdAccwvurPvjGmip+ug/FwX/V7DUB5Op1W7ysBRIZrrbsrw3HqDtTg4gzHDGD+t3UpN2rUqFGjRo0aNfrdkXPuCax3Pzpzk3SgQDpnpDCeOdnw0b4PgrUWJRUyih2skc6p5GrBgTYWYZ1r0lqDEJJIKqJIoq2bJ5tSU5YOQgrvapJG+BhOiRDS/23vtxEWrOHt23vkRcbTx4+ZnJ/T6/VBKe/qhMxmYCyxTVyMrLFk2s03JgIWr4Y8Ozyj8+UTrm2us7OzxcAv2mx1e6gkRamIKEmr2pzCFpwfveLk5JRnz19yNpmyyErKUoMQLBcZ2mgWiwXTyYTxZMR4PCLPMrrdLtYYnj1/xLOnX1IGWBZHDuJZTTadUBa5d54J76D0rS1CaT0HYVXkFj2a8HkADtAJ/71jPgZpBYNWzLws0aV2ANMDvVLDMs8ZzzKEOGe3k/Bq/xApJK00od1p02q36fZ69Ac9Op0ea50O8cY6Kk6wWIrSsFgsmc1nLjJ3OOJ8npG2h8RxijUgpcKhQImKI7Qu2dy7xt6tPdppBKYkWy6Znp9RGsv+/j7Zcs5bd2/T7/RwsMugywxd5JRFTr5cUGgHJLUxCANKXgxU4Z14WO3nkzFCSKRULBa5m1tZi0SgkSgPwqwAYSVIiyQ48Kwf+8K3q2t34eu3IkAIxXpLMJyXnGelf7bg1dEJLw+HXN8ccDw8o99tM5ouOBuNGc832eimTGczSqN57zu/xztv3uHwyee8de8eXz56xoPnL1ksc5azguFkkzRO+e4f/AH/8J//jiJJGI6m9Nub1bzx2t4eDx4/Z1Zo7u0M6KTunmMpSCOIVYKwhlKDNi4Gt8wXHL16zhs3b/DscEhuLBGWEldfVlhLv7eGsAXjyYhskZHEMYV2bsR5UbIoJO3IgWvjyGG1yABhfX3Q8B5SrxDpnJAivMEIKshpjHH9Y12VTV3t52FkwJ0BTlbHrH8mVlvkjvsxODt9xUqMNb4n3QKARo0aNWrUqFGjq/SNQWU96jJEPgbYWId5AUSmaVo5m+pwKk3TCsbEcVwBkXDMAEGDGyzsF5x87XYbIcQlN9bqddZBgjHmSjfY6j7136/Gp65ut7rPVS7I1x3ndW7Gq/R1EPR1TtCrzrd6nN/UNfree+/x3e9+l3v37l2Cv+GYcRxfuvcQNyqEqPrdWssvf/nLCv4EWGSM4fbt2+zt7fHgwQPm8znvv/8+77zzDlLKyp0YIGVwVL799tu89dZbaK158OABeZ5XQO/atWt0u11u3ryJ1prj4+Mq7nU6nSKlrFyIv/rVr0jTlB//+Me8++67PH36lL/7u79jMplQliV5npOmKVtbW1X0aBinGxsbrK+v0+l0Kih4fHxMWZa02+3KERhA5c2bN3n48GEFDouiYLFYsL6+DsBwOOTp06dVrUulFP1+n42NDfr9Pmma0mq12NraAmB7e5u9vT0GgwHL5ZIsy4jjmPF4fKmmZOiP4HQMtToBOp0O169fr+qB1uFwWFwQYGxYOFB/lsOzGeJmgzu2KIoqsjeOY7IsY7lckuc5h4eH1Taz2Yw0TVlfX0dKyWg0qhysASSG572+wKHf71fu6jiO6XQ6FEVRuSbB1aacz+dMJpMqjjc4vcMzEb6vA9EAt8P2oR3D9gGI1hcMNGrUqFGjRo0aNWp0SUK5D/eDS08IB18MUGqsdpBACAcIlHIJKtZ4kCAEKIkUlkhF6ODOxLrXpPR1BBVI5WGAAz5Sxg4MWEPhF1oK4dxXCJBWIIT2OMPVqnOkwUV2fnjvTaK0xef/+ilRJLFCVvM4TUkpFZADFllIlIxZZkuEkNhYYKOIpYaXZ3OOZzmROiSS0Eki8HP9NE0x4CGfpdCWwoLWbp5Z+AWXWIOxgmW2ZDIZM5mMWSzmaKNptzusDQb8yy9/zsunD7HGpZ3EaUw7SV1U6XJGtshR0tfqCwuUcW41qRRKOeBqhPC1Kd2CTWucWy2AH4SrphgidFMl2e53mGYlyzyn04oxZUmkFMq6z0Dy0jBZlsSRxArDfFEynS/cmMBFoqo4Iokj2p02/X6fwdqAbn9Aq9Olt9EnurZdJdYIKUBEWKOrBdwuLrTAaMgXJbPpOccvz5lO5ySdDm+9+SbbG2vcvLHH2fk5g06KLXLyPEOXBbbMMcWS0i9+tUZXcZ4OjLvI1TD1KbVGSZd2pY0kiixRHKEiyXwO2bIAKZAuO7ZyFgcY79rfVADduY8FEouSLmDUbWcrWHmtlzIrDLmH9UVZ8umDJ2z+/kfc2NlivsjodlLGsyUHJ2cMejeJVELc7TM5esKz5SmxzTg+PqXfaxMhIOkyiCPmkzlzMefFwy+w+Yzp0mB1h3xzQKQECEG72+Pa9ganLw7Zn5bsiJT1xLlHsc6hKJUkVQJVBsgK48MX3H7rHbb7bZ6ejInTFvNs6RZ2ZxkTPWNr0GFn0GUaSRaFwRiNtYI814xzQyxCzUm/SME7UrEG3zXOTW0BEepCCu+grlKj/Qbue1fv9gJumrBQwo8xFzfr+sZF0grXH9XRZXVNIoBoY9CEz6ZcnUobtmnW+DZq1KhRo0aNXqNvDCpbrRadTod+v1+5j6IoqsBUcNOFmNZWq3UJVAbwGCBOAJMBJAbXVJK4OhXh51CzMrzWbrcrkPXy5ctLMbN15yFc7aAMv199rV5rr666S/MqvQ5KrsLDAIx+E0fWVXGcq9eweozQjl937KtcnVcdM3z99re/zQ9+8ANu3br1FUhZd9CFc0dRdOl4Ukqm0ymnp6eMx+Nqv9Bnd+/e5caNG/zN3/wNi8WC73znO/zgBz9gf3+f/f19ptMp8/m8cmOCg6e7u7s8efKEZ8+ekec53W63Ot/6+jq9Xg+A5XLJy5cvGY1GLBYLQpRsmNj94z/+I0IIfvSjH/HDH/6QbrfLo0ePODk54fDwkPl8ztnZWQVYO50O8/mcfr9/Cc4G6Nfr9UjTlM3NTdrtNsvlkjRN2d3d5c6dOywWi6/EIydJwvn5OZ988kkVN9vr9RgMBqyvr1fwvt/vV47KdruNMaZyJQaQ3+12K4dlUBRF1VhKkqSKW+50Ouzt7XHt2jWEEKyvrzMejyu3Z1EU1TMdwN98Pq/cicFVGqDeYDCg1WpVrsjBYFBdT4hfDW0znU6rerTr6+vVscbjceVcLcuSXq9XvXcEN3eoZRuc2P1+v/rwZLlcVq9Np9PKTVl/jwjvV/UFDmFMBkgZxnNob6BydIa2bUBlo0aNGjVq1KhRo6sklfIOvABjAmRwQYmmgl7OXengmPGwwFCUFiWlrylZYLSugSKLtL5GnIoA4eJMTYhbdE65WAmEjNxxjXN0Aj7V0QMEH3kqlXQ1LrVBWssHd96g3+3yya/+FWVLLBFYSxTHlNqSlyVCwnIpkbIgUgrsnMSmGBMTK4VV1oFHLNpIFr50Q1TmiHmBDRGTfnEnCHSReyeWIM8zjClZLN1i1SxzDkMB9Ls94iRhf/85JwcvKYoSYQ2tVkq30yGJJMVs4qJxlYQoJokikiRFRZGLw7RgdIm1LpZ2mReUWuNMZREiuojJNEZjPSRz7jGDFNCLFEmrx3yZkyjIhGC+yBwQVqAsZNqTJEEF7cABJg2UeUGW5YwmMw6PToiERCpBFLlUmbSV0m61SOIUFUfESULSSkniCCHcwnFTlhRlSWEky8LQaiXsXtthe31AL7Hk0yH5YklcLBkfn1IWBbp0NT8xmtIYVyvV+uQcHyOqrXY1Pf3nHEIatNFo7cZ4JCVWQqQEcRQRxxGzKKPIC/DxsQ68u/uFiwhdawxKOgce1jh0WcE2gTXCO4YFa+2IjUXE8aIIBkHORmMePX/F+3dvsNZrA4LF8hgVRSwXS959+326Eew/+pR/ePqEdpoSxQmjyQQZR9x444ZbPK/nmHzOp//yC44nSwZraywWSya76/TSCGsdddze3SZ+echSC3R3h5EuORye0FaGbizotSJacYyKlJ9HGiajKaPJghu7O+wPp5i0jRAjhDVEQjDPc2Z5TNtD845UYDQa9+wvC4NJ3GICFwENxmqEFJWbUVSLIWQ1NrWlcq46dyPuvcfDSVej1VTuRyHw9STD/NYvdMfBdMdBReWAdbjyAm56I3gY2s79aS8Sy7DNvLlRo0aNGjVqdLW+MagMqx+D+6j+wX9wqgUnZQABWZaxWCyI47hyetUBT3DJ1R1YAba1Wq3qvCHyMUTG5nnOaDT6iqPyqmjV+tfXOSLrrsN6nOVVx1o9Tn3/unPxdSBj1dm5CjSvckr+tnGTr3NPvs4purpvaP+9vT12d3cvuedWo3LrgHc1bjdEAz9+/JiTk5NL1yaEYGdnh42NDY6Ojqo6kzs7O5ydnVUwsQ5ENzY2eOuttyiKgocPHzIajUjTtHLpSinpdrtsbGygtWY0GlXOxnBt4ft2u02n0+H+/fsA/PjHP+YP//AP2dvb4/PPP6fb7XJ2dsZoNGI6nVYw0FpLWZZMJhPm83kFr3Z2dtja2qogV5ZlVQ3Efr/PRx99xOHhIdPpFKCqedhqtVgul5yfnxPHMbdu3bpUl3U+n1ewP0Qlh2sIsaghCrksS7rd7iUQGpzIoZ3Ozs5YLBaVK7EsS9bW1uj3+8xmM46PjxFCVDVlw+KDwWBQRakaY+h0OpXbEagWFwSoG/ovTVOA6vy9Xg9rXVR06Ndwnna7XbkjQ8StlJLxeFwdP9xbiHedzWbV2AzvDcvlsnLh1sdQeK+q/xzez6IoqqBuGJ/1iNnwWuiLBlQ2atSoUaNGjRo1ukoBMiJEraacRgjpawqGhbUCJaUHWcJv4+MyPda0xtev8yBSCOVrBUofM2lRSoKIwGhXCxCNUhaFi4C0xoUwFkXpIj2lcBGifm4krQMdzk3lPjB459YevU6HX/ziF4yPD1hMp1zfu4FMEvIsZ5nlqNLN0bVS5HlO5Of1eZ6TpAlKxXTbbdJWi7J0ix3LUlLkhYtUDZDKX581JaXWRJHyf8/PyXIH1aRStNI2cRIzOz/lxfCUJ4+/pMgLD9Ei8qJgXRiKuZtLtHs9Wu0WSkZIiYPGfppskYgoJkoSkqSNUBKlnJtMCMizjDKbM59OmU8nbl4Bvq0F1hjQmo21Nt3BBuPxiIQla4MeQsDRyZBQa3FZGlJ1OT5TCgfiqqsJhltjUBbyskQuc2azRZXtqYF2K2ZjvUunlaKUqzlqkUQqIo0jOq0IpQrsbMjJfMgpoLVb9FsUpZ/juCEplQNkBkXExecHUkkHLo2s4Lm1wtWnFAoT4LgFhMQgiWLoqx5pnJDnBXleUOQ5he+/UIOxumUBuvrMwnpQ6o4rpag2EpQIJDu9lElWMne5pxhjePh0n93NdW7u7ZI/3Wdvcw0bKZ6/PKC38YLEbHH06gXHJ6eUVtJOYqaTMUoqOhSI1hqdpM3ZqwnDyQxt/DhazpjnBb00otTuenr9PmvdNqPlgtPDfdppyqvjIbk2KCyJkqRRxPbuHp12grGgVcr6tOSt3V36zw4ZzecMBuucDIfuubSG6WTGUrh6qlIIVKQoco02hkVp0VYgraWw7r5D3UoA6xdCSC5+5xyrfh7rf+eeNXAVQGUVRS2D+9H3h9/TAXVr/TPj6+ViL5yV1l68PwXXrA3vdx6aWvx+IGVjqWzUqFGjRo0aXa1vDCoDWAkgQ2tNkiTs7e3R7/erD//D5GQ4HHJycsJsNiNJkiqaMQCl4KjM87xypXW73QqC1mFo3QlVliWvXr1iNBpVxwxQIcCZ10WhXhXRWo9xXIWRq8Cvvl/956uiZa9yL9b1OqhaP/9VoHX13Kv3e9XPX3eOq6SUYmNjowJFy+USoKrZt9o2Af7VnWrBJbu/v8/9+/c5Ozu75PhUSlVwO7gdA5wO9QoDAA9OuXfffZfbt29zdHTE559/TpZllcuu1WrR7/e5desWe3t7HB8fX+qL1dhPIVwtyXa7zenpKT/96U/50z/9Uz744AOstUynU3q9Huvr6xwdHZFlWQXhQ9xqAPP12obL5ZLRaFQ58lqtFq1Wi52dHba3tzk+Pq5iVOfzeVVPcz6fM51OuXXrFp1Op6oHWpYls9mMPM8rt2RwmIZ6sSGqNgDmKIou1agMsC0Ay9A/AXCG/nCrmS9cmOE5DVAzLDAIoDeAyeCQrjuolVJVXG6AjED1zHY6Hay1FYjN/SrrOhQP7RhcjAECB1CZ5znj8fhSFLVbcZ1V9VFDlHSoexneS0Id3bAAIlx/OE897tUYU4HXcH+rCxkaNWrUqFGjRo0aNQK848nxJeldlFIIhJD+71lQKnLgMvz96d1jzuUoq9pz7rXgv3QwUVgczBESrKnqWOJrYkoZFpG6qE6LSwlRUhBFMcYKX4fRzY2KIkcIi4oSVBQ7aITl2nqPP/qD7/GvD57x6S9/znwxo92WdNptSmM9/MoxRoHw57IWbTRyqYhUxHIxJ45iytKViym19i5SSxwlzsTlHXVlUZDnGRZBlrsFmkYbet0uHT9vHI3O+cUv/olsMa9q9CVpTK/VYpktyOdzoiim0x/Q6/VJ2x2SVockbdPudNy23T7d/hqpn0dKKSnzjNnknPPjI85ODjkZnzI9P2O5WFKUJdaAEYCfQxgg1yXj41O+893/lZPTNsPDV9zY6tJqJygJk0lGVuTkWhMJgRLWg2sfKevhUI0R1hxwrs9LbYikA1KxELTSmDSJEUpWRjWtS7TRLHMXwRtJD8e9O9NaQ57rak4oPNjEw1IlfEyxdU5Jay3Wz5vc6wpdG5/CWgfahBurSliMKTHaoJSg00lJ05g8j8mXGdN5BkXp7shfmhQeklVAzcF6l1IqQGiwyo16aekkgs1uTDbJKK2L5Z0vlnzy8Cnf+/BtdjbXWCwz5vmS89mMT7+4j8lvYo2m3Vuj0x8wnc4ZHQ7pxZoIB4bPjk84HY5dXc6yxFjBzuaGm8OmLUrtargmrTbXNvrsYZhmJfNiwaDXISs1pdZoK7D9DVq7b7C2NqDbbrGxMeDmekqv32Fr0GIyn5MmCdJa4jiqanNmWUkcKfJsSZrEYFyd0NJoci1pXcpOXVl4b6G0uLupPjtyONJaG8y8zkUpZHWMKsk1RPPaGkh3B6n6GmHRxoHOcEABiOp9xO9rXR3Xqk6mX2jx2yy4b9SoUaNGjRr9bukbg8o0TStHU6jL1+l0GAwGbG1tXQIMWZZxenpauZrCB/51IBGgQZ7nFeCpamj46Me6IyxAsNFoxBdffMH+/v5XIGMdSL1Ovw4Q1n+/Ci6vOnbdRVn/efW4r6tr9zp4eNXvXxcze9W+9esKk5Lw2te1Ubj2OI754osv+Ku/+qtLIC7EbIa6hAH6BLdfHMdVbC/A4eFhVZ+xfs/tdhuAyWRSQaPJZMKrV684OTmpYFMYD91ul3fffZckSdjf3+c1DR6FAAAgAElEQVTg4AAhBJ1Oh83NTXZ3d7l58ya3bt2i3+8zHA6/0h51mB7AXJicPnv2jL/+67/mRz/6EXfv3mU2m/HFF19UsDQ48cqyZDweV/UVA3AL47weOxyemTzPiaKI7e1tBoMBx8fHlSsyPA9ZlvHs2TOuXbt2yalYB3WhbUMdyADfQnsHkBhiSgNUjKKogpr9fp9ut1u1bagZGdyHrVaLOI4v3UdwHgY3ZACYATzXAWPdNR3+h2sLADDUlqxD1Hrt0tBmddd2uNeg0NbhHsK9d7td1tbWqjG76soNP9fjiusLDcJ5tNbV//piiPo2jRo1atSoUaNGjRqtygQXJHgnmYt4FUJezOP8f+NyWX1NOPf1oq6fwOjSx8hKhIoQwkEG4d1UQioCYMD/eaqswJgSIRRKgFUOcFolMdYiraXUljLP0b6Mg+MMJcaEOnXuOte7bf7o9z7kzu0b/PKXv2J4uE8SRSgVE0uFTFpVchKi8ODNkrZSjC4xpmRuIF8uEdKBjSSJUFEMCIrSOe6sheVyUS3WFFIgZUSkJGWRQxnx4uVTnjy8T7aYURYlCEmcRGz0OvQ6KWmyzvrGDtvXXSpQt9cjSRMX+xkp56yMEjAlaeLmO9PxOafHB7x6/pzD/VccnxwzHk9ZZhmlLhHWcsF3XD0+YzUhjrMtLevthPTmTXQ+J8/m9BLJ//zuLaK0xcujU548fUU2X9CKvK/NglDC1QsFPw7c7y0uKjWMBevwEJH00MgYlJLOSen3EUIhBWiL/xzFogQkqUICpbEoITHC7SuwIJ1zV4lgM3V1FkUV++lAJCgHNkOYqAAREpWkJIqUaxcTUSrto4Sdc7LdTinaLeJWRpa5BbdFaSjyHFNe1L3EerhlQ5xpLcrUgDHOqbfdSZhlJeeZqWDY4ck5D18c8t6dPdamU8pzi1IR56MxT/cT3rx5jUhYlNHcvbmHkDHzyQTZ3cToAjM54VpLcD42LK1hNB7Ra+8SK4XAIqVFCoWIBZ12i44s2O5GGAuZ9m0uFCpJuHH7LTYHPYQpMYsxsxePefaopPP9H9JNE9dHKKI4QusSCWRZgVSSdixpRymzpSt3k2tLywpybUmi0EwXzlpndnSxrxg3GgnvBNb6upPOBek4okFYt70lQERRjetALR38tn5MhEXmPt5VuMhXZ5NUbnGDj+y1rCykx9cpxVbX1qhRo0aNGjVqtKpvDCpDvboAeOoAp+50CnGuSZKwsbFRwRigcoIFyBCApDGG2WzGbDarHGrL5ZKiKOh2u5diX1++fMknn3zCwcFBdW2rbsKvg33hax2k1H//Ohdlff/6z18HDwOE+W2iW+vX8ptq9R5Wf77qmq+CqXWgp5Tiyy+/rGJZQ38FgNXtditAbYxhPp8zHo8vOWPzPOfly5ecnp5WYya0yd7eHlprXrx4UUG1yWTCcDjEGMP6+jqtVounT58ipeStt97i7t27TCYTZrNZBdSCk3Jzc5Otra2qhmo4V5IkbG9vVzVVA9gKUaShrmUcx3z55Zf87d/+LX/8x3/Mxx9/zHQ6ZbFYVDGncAHIgtuy0+kgpSTPc9I0pdPpABfPS2hzpRR37txhf3+f09PTCtpNp1Pa7TZCCA4PD5lMJqytrbkYJd/e4TgBjgWwGJx+9Zjcust31U0ppaxcoas1RsM+9WjnOqSrw8I6jF8d93WAuPq/7matj8HwfWiTcJz62L1qXNeve9XluAox68evbxeuvR6VG97jVq8hnLfuvmzUqFGjRo0aNWrUqC6lIkdYrA9aFH6+xoXT0RqLED7xhfLC2eS+eGeSV4Cd1rnkEMYDRRw9kNIDCA9ILWjjCQYuGlL5qFhh/fxBQhRJrLEOyAFGWxd/GsUublVYVOSA3q2tAdf+w7/j/tNXfPrLf+HJoy/ZHHTZ2LlOK21Bmro6l/7v59ls7mI8vZO0LEus/8xgNodIKefuNC72E+liL9NWShLHSKFASHRZ8smv/hmbT1lmOfPFwsHONKXUmu1+h9vXN7h2bZfB+ja71/YYbGy65J44dhGXHsJorcFknJ2d8uLkFdPJmLPRlOH5lKwELVrIzjqRluhiSJEXWKOJlAe3CIR07te8NOSlJlKSfDHjxt13mI/PmA0PidMOvV6Posi4tt4hEns8ePgSTHkBm4yvEihEBZCkr88oRIA9Lmq23UqJlKIoS0orKAvtF3Lb2rwMWomkzC2lMQ7yWYvR4EJzLEp6qIiL+PWDC8DXMHUOSotBCBfzGoCsri90DvNOPwcTSKwypFGCFS7GFuscky6ONqXQJVqXLJc580XGcu7gpTbgSZsDo9aindkU5YEq3vmrpGC3l7IoFyzdOl6MMTx4/pL1focb169hxQlpmvDi+Jyjk1NaacKtnS3miyWFGXLvzdvMMsPj5y+xRYbCQdxISqQ0aF2CVCSx8o7F8PxCEifoovBjAVoqzGc1wsyZPP2EmV35XEZGzKYz1tYGJPEp02VGmqTkueu76WxGt91DCBfLGitB5s2RUsBSWzqxx9bWvSlUC/Wte7atDGbKMOf12NFS1XxV1D/3CQv9L79vBWiOkCisd3TXo2Hd8UCgrI+o9tdpPGwWPjoZDys1tfexRo0aNWrUqFGjFX1jUDmfzytoE2q6lWXJ4eFhVV9PKVXFSSql2N3drSBkcCkFwDKfz5lMJoD7A3OxWDCZTCrwtVgsWC6XFfAKAOT8/JzxeEyWZVdCxqtA5eug3evcj/Vj1Pepw52gOnipR5vWz78KO39TF+br7uN19/Tr7nP1uq76HVD13c7OTuXuq4MwpRSdTqeKhgXI87yqfZimKUmSMJ1OOT4+vgR8ArR7//33Mcbw+eefY4xhY2OjgkTb29v0+30WiwXPnz+n1+vxve99j+vXr/Pw4UOSJOHWrVvs7+9/BXbVr9NaF1H6/vvvV8eu1ykM8C2OY7a2tkjTlE8++YSyLPmTP/kTvv/979Pr9Xj69GlVszE4A4MrMAD0EJdad0LWAVocx2xvb/Py5UueP39e1apcLBb0ej3a7Tbz+ZyjoyPu3r3L+vp6Ne5X4Vz9a/1+g/s0wLQwPledhFfB9zrgDKCy7rytg7kAMeuQsg4uA8i7CljWr38VmIbrWN02bF9vi/qYft0igXDddRfoVYA0bBeOH9qwPo7qqte5bNSoUaNGjRo1atSoLiGkczJa66vHCazV4dUq6tKEfFfHZy7oAiEiVLgYT6mcE054mIR0kFO4yFdrNYEmhLqHUklAVscLDk+l/N+xQhIH1xWuXmVRaoRUlNp4N5lERRF5llMWBVJI3r99jdvX/iOfPHiLR/c/5/T4ACUl7XaH5WLG7t5tZJyijcGYEqxAG+1iRo27LqVkVZcyThP/2YLyCypxrs0kZTg85ehwn+H5mYuQVTEISa/TYaPfRqFpR2CyOdOzIcV8hp6dMe2v0el1STtt4riFFJI8WzAZjxiNXfkYGSd0+2vcvH2Hm3cjlouM46NDnkyHzCcjbJnT66aAqJKhsNaBF2spjPu+KDXD8zFvdzu0Wykzq9nc6PPs+T5RmtJtx6z12uxd3+Jw/9CNi+Bew7kFhbBEAkBW8EgqnxbTSel1WkRRKH9hiSJV1RlMIoUDfRJrS9/HyrsShY/+pQLGwSkb+TQcC1hrUNZ66KQwtvRw0Pny/LBzYMpYjM9vFdZgSlsRL6U8mPdAzfgxIIUijWNMJImEII4jOmnKdLZgvsgoitLB1VBr0TrOX0IVdQwSKSz9VLHZijiclWjvOc2ygk8fPud/+egd9nY2mc3nWGt4ejDk8fNXRFJxfWeTsiw5OT7mgw8/4O7NHf7+H39FpjcoTUnaVajJOe1uh73rO3SSGOv8pT6u1tFKbSxxJJxH0AqMWycAwR1b+WDBSoFFM5+M2N7ZoRU/Y7YUrK1tcHR8QF6URK0WZZ67OpV+cYIUDgxr62Chws9VPfytHNR1BFg9534RrndFSh/J6qtHumMQgqSda1bgXLWiFg3r6l/6ubKHowKQUmENvmWEj6AGZZxz11gXlYtvNwHIlbl0o0aNGjVq1KhR0DcGlaFuYHBKtlou5mUymTAej2m1WnQ6HYQQzOfzCkyGGncBFAUQUHd2BedbgBfBKRdq6oV9ggOzDhLqqsOYVWD5dSAwbFM/xup2dbhSP+YqwHndMVeh5VUAZPU49eN/XVzrVeCxft6rfn/VOcPXKIq4ffs2b775ZlWHMICe0A8hkje0awB3AeKEuqTn5+dVvGk4vlKKu3fvorXmwYMHCCHY2tqqoGioZ/jq1Stmsxm7u7vV9rPZrKpvWb+PcN56fcVwbdvb25Wz7qp2CttvbGyQ5zmPHj3iL/7iL/jJT37Cxx9/jLWWJ0+eXDrf18HR8HrdhRiu7ebNm7zxxhvcv3+/gm8h5rYsS549e8aHH37I9evX3eTSO47r469+7tA3dYhch+ar9VNDO9SvtT6GQ4TrVbB+FXDWx2YYn/X9r3qm6v3yur5YfVbr0HMVoK4+Y69bqFDvp1CLczWqt/79KkS9qq0aNWrUqFGjRo0aNVqVkAKsJFSWdA4jdfE6DkYglHdAXsCNgCGEEA7SVO6nACoDpvD0CAevHDq4qIdZ1agDwLvclEQK5V1vIQJUOqhkLZFy8xVjBXlRUGhDnrtYVyEVUZyi4hglC77/nQ/59ofv8/nDR3z2r//K6ekh5ydHRELSX1+n3e0xXS5B5/S3dpFSEUcRo+EZSdpCxTFJHJHlC7LJmPZgncV4yPHxEQ8fPSRCu9qQ1vrahwnGGq5vDei3FMK66EyEYJGX5GdnGCxHJyfEUUQkrYO7UiKsq58Jbq6SJAlxErMcDylLNxebLTJGkxlHwwnjyRxrHKzd2uiDSBlPZuSFxmJRQtBOFNYqSg+Bet0WvX6XoRIUWcbz5wf0+j3Y3SSJFbtbA05PTtF5WUFGb4IjkgoVKR/pKonjiCSJ6LQS0tiNGykEFlWBxuBaLAuNEKBNUbnYjIdb2mikFERCUE2fhHPNYksMwjt+/bzQWjTO9SpFMPI6u57wDjshFcq7Lq318ychUFJhjBtnfheUEK7mZXUtoCJFLASxUijloOViuWQ6d/VIrTVgfJ1OabHGjflYhYWsip1+m4VecL4sMVgiKZnNF3z2+AXfeecOa90283bCaSvibJrx+PlLl+h0fQdt4fGzl7z/9j1+8D+9x/H5mFfHQ24MlnTO+3Tabe5c38DmOYUuQQiM0WAFWbZkOl2yM2g5t6eHwVIIjHcvG/8UB7BnLcynY6I33qCdRFirkVGCMJYkjpyb1pZkec5Sl2AtsZQUpSYrNHkkyAqIpEQpfD94Amhd3VSBA7vGOpcu1sUFB+eno9be9WitA6DG/T5StrpWcH3m1k4IV4PUY01tHQwXbt2Efx+SF+9b3nVqjX/PsxeLI8ISjUaNGjVq1KhRo1V9Y1DZ7XYRQrC+vs7W1hZSSs7OzqoP/fM8r+ISQ029oiiq+pL1um5lWVZRnK1WqwKPWZZxfn5eRS+G+nlA5dY8OztjuVwCXwUavwkEXN32N9Wqa+sqV9ZV29QByetA5lXXvnqsVdhaByvhXKuqn38VDH2dizRNU3Z2dtjY2LgEhcM9hD4PAKl+jHq8ZlmWHBwcVP0VFEURb7zxBicnJ+zv7yOlZHd3lyRJqrGTZRmffvopUko++ugjdnZ2ODw8RGtNq9X6ioOx3v5hvIV7TNO02n71nuuOwzAe0zRlf3+fv/zLv+QnP/kJ3/72t0mShMePH1cgNYzl4CwMsaohBrYOCENflWXJG2+8wb1793j48GHVdvP5HCFcvc3hcMjBwQG7u7tfAXT1e62Pp7rTsA4t61qtw1gfT3VHZrjWVSfnVQC/fux6O4QxUneU1q9nFbrXx2c9OjZAz9Vz1fep38vqwoTwczhm3S0a6qImSXLp3GH/cN+riyKuejYbNWrUqFGjRo0aNaor1NhzkLD+d6OtXjfaIK1fYIupoCTS1WgUHhoEkGh1ibc3udeMxVjjwZdz0Ulfu1AbfzzhwFXwcRqrqzp0Qggw5cXfvkBZuDrxSkjSVoQhIvaLheMoxgoFiQNh6zF894O3+fjtNzmfzPjFp1/w8vGXPH72FGkKpouMSAp2z4ZYKUmSmP39A3a3N1FxTFkUTGZzhsfHtDstirwgL0vyssBo7eBmHBEnis1WjBKWbmSw2t9zFAGWSEVIJVC4mo3LvEDg4RgQKQnSu+BEyXyROfhi/H9tKli8vtZGKsVoPGWRl5yP5vS6KUY7UOf6UhDFkkhJdGnZ7Kfc3O7z7FmXojDcf7LPeJ5RWktv0EWpNq0kZmtzndl0hpIKIYV3yYYYXFd3MokUcayQQhJJ5740xiAkSCvR1qfa4MaXMcY53HxWcDVbFAJrXO3PAJLcWIzcax64hn0swt/fxXxKCYH2UFT7OFITPgMxEqWcu1dKN9+TKkJ4UBZJAQqM8TG3wiBRICXSutqlSRIhlSRJIkAwnS4ow/UIKniKgEIbF40rXDzqXj+ltJZ5YVB+/ns0HPHl8wPeubNHv9/jxjIjKwzLUnP/6XPa3Ta7W1tIIZlnBfmyoJcmvH1jB2Mthb7ObDanWC7RRmMNKOnGiBCW+WLJ8+EUpSQbnRjlH1djrIO0UmKtW1zgpqGuLWfzOSKKabdbKCEptYN5eamJpGJZlHTbCa2oRZYVzBZh/Nqq/0uMf8ad09F1kotildVzbn1/+6hiv/JB+O2lh49CSIxwEbHa+oX4/j0iuC2DG9zNp328bwDQVeSv69/gy0bga6e67yUBejZq1KhRo0aNGl2tbwwq19fXCXUprbVVLGW9Pl5w29XdTXVoCRfQYNWBFQBHiHsNEbDhtQA8g8su6HWQsA5ergKMq6pDoFWYdxXUuwoerep1MOOqa1516K1eU11XAaOvAyevu/6rthHCxcwEh2uWZV+5pgCIgtsv7Ff/Pooi5vM55+fnl6BV2HcwGHB8fFy5cfv9PnDh3H316hUvXrzg9u3bvPvuu8RxzOHhIYvFglarVZ17tY9XwVgAeXUgudqGdQgXXI9CCJ48ecLPfvYzfvjDH/LBBx+gtebg4IDgCl1tk3BvYayugj5wz9HNmzfZ3Nzk5OSkquGapilxHDObzXjy5AnXr1/n7t27X2njVei86rIM5w+qQ78APuuux/A1QLzQTgHoXTVWV8dP2C5ca3h+w3tBfZurYP3qOK/fV/24V/VZOH69nubrxnb9mPX3qdXI5tfpqme00a+XEOIJgLX27n/Hc94FHgP/j7X2P32D/f8D8DPg/7TW/h//DS+tUaNGjRo1avQ/uKT/sN5Yi8A4OOQdV9bDhFIXCOsiHkNU4sXfzWB0KDTn3WXaRXFKb1lzjjz3vTEGjJ9vaV1BTiEkxmjv0FQgBGVRoE1JrASxihAqQluwxtWQDC4xrMVoS5wmRHGE0RECF+8orI9DNQZTlsQCdta6/G8/+H0mv/cx9x895b/8579jdnwfKURVr1IgKErNbDpyTjtt0ViWWUZW5O56vUOu1IZ2rBh0Y+LI1cwTQmI92EUqFM6hF8UOWCohKvAolQTjYG5pLbYwF5AtLPSkNhexDnImKmJ7PSZJIs5HExZFgZ7oymUGkLZitjYHtBJXVuLenRv0YoEpcwptmIxnTBY5WVmyPl3S73UpPIyKpQOrUeRAoMdBDkRKN/8SVqBUgFTu3Ma4uF+LcI5D5bYzNsAhh4uUFKgoAmGR0oGkMI6kEsjAz/EwHIvwPNA4XuUcd9pWANxKByuNwTlNpY/89O0nUURCIqxxtSyFRVtFpCTCepelisA4EBophcaNReFBaCRx9ycIlLKKyA2gXoT5t7W0Y8m1TszLWUlpvNtTWJ6+OiJNYm5f32JrU1NawbPjc5al5ujokLPhOR9//DFJklAgWBQF1hisBa0NSka+VJF7jkutsUJilktG0zklgudnM5J4jY1OjMTVBHWuUVevMVy2NgZjwSyWICPSJCGJY+ZFQZzEzPMlWpcURUmuJIkQtNOYJJIMxxrh5+9x4sZ6tfYBEDZE0lItcZBCOheqlYCpoKX1ENJU1NCPEw/CBRdzdVdT0h/P9y8ezkuHpQmZriZAZQ+jdaDibmD4rqvXQ/23ISHEfwL+L+B/t9b+39/wGE/gv+/89ndBzRy8UaNGjX739I1BZa/XqyZP8/m8+qA/TdOvbLsak1h3Nq2CgeB0q0dzhpjMemRmkiRkWcbx8bGrK7ECLa6CkVeBwPrrq9vWAWTYp379V/3+qnjI+nXVoUv996ttdVX7rZ57FZBcVRNzFSy9DsCsus/C1xDbqrWu6oQGGWMqJ1ocx5egVh1+SSlZLpdVLdHV47daLaSUFEVBlmX0ej36/X41FiaTCffv36coCt58802uX7/OdDplNptVbtwAzbMsYzgccnR0xO7uLteuXatqp45Goysh2KqDsN4nwbF5+/ZtAH7+85+TJAn//t//ez788EOstZycnFT3Xe+bupOw7kgMfRXicnd3d3n33XeZTCYUfoIWYo2jKOL58+e8+eabfPTRRywWiyoatj5W6xC/riiKLsW7rvb1KsStj9v696sO4Kuel3AdYZtw7wHU1iOY6/+vAq6rEPl1+9avbzUWt963qzVCw/XV34OCy7XuAl29vtUxUn+m/0fV/1/I16hRo0aNGjVq9Lssx73MxQf9LmfR//3oXE3WAw5hnVUtAA4llQeMFm1KD+bCgsio+uC/qiuHwHoiJRytcZATF+8aYBxYtC7RpnTRsFIhoqiqk3kBJNw1IF3oozElUiqM1mhdhjBblHQ19QrctQrrwEgvjXn3zhso8Uf8v0XBq8f3wWjvuHIwUBcu3tRYB0yk1WAMSkkSKWklEZ1+iziWtXDJi3mvkM7FJ6SLqqwWQvt4UqSo2t8K1yZSCrQHXlgH7KypzbXxkEmCErDeS8EYzkdT10+ePikk7SQmjRRKWJCCNFZMpjmTyRSpXP+WxqJzzeloyo0bNzDlkrzQzJcF3bYkRvloTXw9QCqgY627NiEcfLKhViDi4gXr3HRYS6m9gxd3f9K77ASickhK5dosUrJyUBLAUv3EwrU51bgx6FAC1dZcvtJFkIbx6qJBXUta6/olwHIpfb9EgDUYDVGkkAKyPCdkxbqKim4cIJyT0R0vzEuNr+npxupaO6EUiqNZTql97DHw6MUBsZJc217nhlIss4wXwwmlgVcvXjKezemkKYNOCtYvKvDuZBPaBkMZFrZKwfhsSGYcGM5Ly4vhjFj16CfSjwxXc9aNN+mfZ/dQZ4XrOyVc1K3UhrV+n9lsRqENxsBimSFtTK8dkyYxqZ9PC0AJhZKGijMKP2asfxZ831lhqz6rnhU/uA1urLs2de8fwrsj3YIK133GO61NNd4sQmg/X3Zjxb1uHCg3rp20duOk9NcURw50ymDrbPRvQg0IbNSoUaNG/9b0jUFlq9X6SsQkXDjpVp1d4bWrHGD1/cP3q7UYgwNMCEGr1WIymfDo0aPKTXmVcyqco/711+kqgPh1ELN+nqvut/76Vdfw2zqxvg6c1nUVkFv9/VXganUfpVQVx5tlWQWfwv3UazEGl1v4H8BdFEXkec7Z2ZlfkXjh4ovjmPX1debzeQUSW60WW1tbbG5uYq3l8PCQ58+fs7u7ywcffECaprx48aKqgSqlZHt7m1u3bvHZZ5/xxRdfIIRgbW2NGzduMBwO+fzzzzk4OGAwGJCmaeUQhYvo0/r9hzjbcL9JklSw8p/+6Z9YLBb82Z/9GR988AGfffYZx8fHlGV56Z6Dk7EoiktjPYDc0I7b29t8/PHHfPnll8znc8BFJy+XS9rtNpPJhIODA87OzipnYh2ihWOHuq+hjUOf1qFmAHp5nl+69/qYWB0H9cjZ+virn6M+vsLzX39m68deXaAQ2iy0eX0sug9hLhzV4XjBmV0fu3WX7Coor7/31GOnwzEDjK8vJLhqXIdxX19s8Lpnu9G/Kb0EPgBG33D//+r3P/lvdkWNGjVq1KhRo98JWQ+AQpyr/0va8SXh3JJGa+dmw14CmjrUm7QXtSfBwToZYKI1rm4eoFTs5i/CAQLjIWmSpDg4WlZOQikjlMLBLWMxRemuQ/D/sffm0ZYk913n5xeRee99a+1br1XVe7e6tdnGixCy5UVeZJsDPgYEyDMMwww7DIvhDNjYzBkGM8wwcDjMcPDIYJsxqy3bMrYWWkaWZMuyLFlN9aLurq59f/XWe29mRvzmj1/Effmy36uqrpaslnR/51S/93KJjIiMvH0jP/H9/iiKEleUCJbmoij6RFWaEKjGYxBoQmN2ogmSOPEUzuF8yuOX6uD9LK976D52LSzw6d/5DKeef5aVa1cIjdnKOkBMzkVZQK+cZVCWFIVQOEOTlkEzJjvLNFdxDg+TPI2C0ARFQsA5620EXOqDDFuUNBcRZ7keNRpcE+sHSTkRMwUKan00N9tnY1Sxurae6mCWppqgsqqpElU9F5fWWdsYMTvoUexZYGV1SNnvsbQ2plEDc6Oqxpc9xnWgV0BZeFBrK2nRpOQ5S7rrLgEl55ypb5OSVhK83LTpNAjunDdLYNRAaAKU1n6ZtNFN+mYTVPtJDlRNMNPGsXMyyYEo2N8m803zwRi2wFNxnrpqGOtm+picUxME7wymCUKvV6I4BnWf+aApD6hQeKEJkaYONE0gtqZek8ytAvtmCpoIl9dGhIQY66bm2VPn8c6xb88i83Pz7BpWNLUtCr66vMYvfvDD3HfPXRy/5y56PZ9ychrs16QM1Qi4yHj5Gs+/+BJ3HNxLuHSVtY0xG1XDpdWKcnff+KutCNi0GE719M4xwmBu4QxqhtCk+aqNAWOLDcvrI8Z1w2yvYK5XsN4YfEc05X60awiCRzbtcdkUMmY16sSLNf1wqcd9+kRqohLVIdK2phbSjNryXTqd2MqCQeeQEqAmHIplco9SKiMAACAASURBVPWmHJU4GT8oiHicaPoce03FfwQ+Dpz/YldkGtOYxjSmMY2v9LhtUJkVR+2X+rAJdjIoyGCgnccwR97WhgJtoNOFMbCZm/LcuXN8+tOfZjgcvkxF1gUjN1ISto+9HZiZ+6ILeLrl3QwG3Wj7dsrMttqsDQu3q1+7jO3a2QWq7ej1euzbt4+FhQVmZmao63rS320AVhQFTdNMwFNW8jnnmJ2d5cyZM5w7d46mabYAq36/z+HDh7l27RqXL1+mKArm5uaYm5tjZmaGa9euce7cOTY2NnjDG97APffcQ13XXLx4kdnZ2Ql02rVrF3v37gUsB+X+/fs5cuQIBw4cwDnH4cOHJ0rE7lhr51Ps9kFXGXnkyBHG4zFPP/00RVHwzne+kwcffJCqqrh8+fIkx2G3rO1gVu6/Xq/HwYMHOXjwINevX2c4HFLXNaPRaAJxz5w5w9NPP83jjz/O7OwsVVVN+htILxDscc7b29AwP0t5f76PbSVgfla7CwoyGG3XuW31mwHpduMoP/sZLHZtZvN18mdJ9/50VaP57/ZnRzdXavcabTVmBrVd4Np99rYDkbkfc5+1+3kar+1Q1Rp4+lWcv/Fqzp/GNKYxjWlMYxpfuRGaGnFCME9VNGqyg40JuJiNqU9zaOdNURZVEdUJWPTJ5jV/v6+qMb2yRMWhmG0sNIhzaDQwF6OBlroek2gBLkMob7aNGRzEEBHxFIWfgKysLqursc3vvCfGAmKkV/aJ0b4PW9UKs8bM341V0ZR3c6YQHjx6hHvvOsiVa2/m0qVLXLxwgetXLrKxskRsRkkFmvrDSBYaM+RQ0DTnT6zEFKPthYSarHANqkmCMzFhGyeWJ0+cM2jn0vwiGIoTJxSuMLBX53QbpkQVEVyh7Ns9z2hcMa4bUFNKjquGJkSihzJ6QjHL9Y0Ra8OhWeF64cD+XcSg3HF4F+oKkEjTVCwvDzm4d9GQkSbIG7INrfE/50i2rDKBkiEpZp03ZVsTMpi0k/K4cpngSV6gmiF4ei8AiMpEqSmatiVVpQGxPNdJOtKoEytUSOBJQINS102yk02ONRgoLhz4dOO8LwixSQrPtOA02DMgAv2+w/t5ev0+46pJdshC4QtiDFy/vsLGxmgCkyMBp84UtcDBWc+4Klium8mYGNcNz750loe94447DqO+ZNxEyv4c66Mx3hecX1qj4gKH9+3GhxEzgx5FYdAthECoK5aXrvLs8y9xZW3EMEbuO7KfF85fYW2jYqMOzC8uEjbWGE8W1ca09MBUpFVwxN7AlLbEBBqth4vCLI5LHKujmrn5WfbN9lgbjqmVtJDBnlPVSBSh8Dau87Nuc9yktAUy01cylJ7wYZK4OA0PGwN2i9LnREKsitkGm+JX0hjyeJ/GQ5pHFwg+KqGIlKUpUu3ZtH7I9ZCXZy36ooaqLnP7i1mnMY1pTGMa05jG5zFuG1TmnJQ5sm1ihk+9Xg/YhBzD4ZAY42R7znnXBg4ZIBSF5XfIf5dlOQEj3nvG4zEXLlzg0qVLk2NybAcpu9u6asjtzn0lsdPx28HK7UBhF8Z293XLa8OR7UBY+/dbadNOx6oq/X6fI0eOMD8/T7/fn4DBrkotn5OtM/M9E9lUwJ46dWoLJIoxMhgMuPfee1lZWeHSpUuUZcmePXsYDAb0ej3Onj3LU089xfz8PA888ACzs7OTPJewqYjLsCxbyS4uLrK4uMjs7Cyj0Yg9e/Zw5cqVLTlP4eW2ou37kffDJoCfnZ3l+PHjnDlzhhMnTlAUBd/8zd/Mo48+ytNPP821a9deBt7z3xmoNU1DCGFi85rrcvz4cc6fP8/GxgYiMrHC9d5z9epVnnnmGR555JEtFr8Zsub+zFa4+dnM6sp2m7qKwS5gbB/fhojd+9y1V+0CvXyt/Jxn2NjOSZvbn49p34M2vMzWwrkfc7ltS+j2mGy3o12PNlDN53RBbj6/XV7+HGsrwNvtfKWfGV8qISI/DPxQ+vPdIvLu1u5JHg8R+TbgLwBfAywAZ4D/APwvqnr9FVzvDwP/PfBGYIBZzv4U8GOqOk7H3AmcAj6jqm/coZxfAt4BPK6qnxWRo2xjXysih4C/CrwTuAuogYvAx4AfUdUX0nFvYwdbHBF5APhbwNuBA5jq8gPAj6rqc51jfxjrz28E9gN/DXgdMAJ+BfifVPXsrfbXNKYxjWlMYxrTeO2H5YhMOQXFtExNDGgMOOfNFtM7vDhU2ot5IUn1DA4pE20byTq2qsaI9yCmzjJgaHo6VJPGiQQjTY0VEWKsDdRNYIVPsEKSbWUEHM6b+ktJtpxqUGrQ7xNdQV1VqIZJPkjvHRottx1qir8YDVQ4DcyWnrsO7uOOA/sIjz5E0wRW19dZWVljdW2N4doaa6vXGa2vUg3XaMZjNFnUxqY2eBc1QUqSUjV3SfrerwCeSFLEZUATFV86iqJEBJpQIQLeY3BHvCnwYoNzgnPmjuN9ARpwTmwRb7OH6ytr2fSWRkqKwQK9fo/CO1xvwGh9g6oaM9Of4fAd93J0MIO4gn5Z0PfK9eVlFvY1zOwvkfEqVdig0UhZlvQHc+b2kixw0YhqSD8T+EnKXIlZRWmdEEOyVcXsXYsiO8lEHG4CtMrCQbJGzRa8gkGqrNQVQAuDUzFiOSGTwtAVkvIi6mRsaQLuiWaa/WuKqEoMEeeUoiwovceJI8RAVTcThXBRuDTEHNovKcqCJth99IVHg6PYt8hKr2BpeYjGMHkuJEpqp3BgviBuwNq4sYUBogyrBCuPee47dpSZhV2UvRleurjE+Qvn0dCAeNYqZdCb48rZMwwYMihL0EhdjYjFDGMVVBwXl9aZLQoeuOsgJ89f5fr6kBfPXeXOXX3qRvEeWxCQn1vxrFawe2GRwkmyp7VHqj87SxOi5aes7ZkeFA4Rx56FWcbjihAtX2vEbIyzujEvJojqzDpZlJhkvi55SOfcp4gtYhjXDU0kvXvzlGVye4IJ7Hek3Lc2MNLvBrmDmiWyzae9wdakoHUhTMaJ5VRNFrOqqIZUty9ctOd9wN9L/94K9IFPYXO8X2kd/wPskKNSRO7C5mvfjs0Vh8DngJ9X1R+9hbr8kVT2C8C3q+pJsSTEH1bVt21z/HuAdwPHVPXk7bTnVqN1LYAfEpEfau3+RlV9st03wAXgB7F5+qKqyk5z7NY1ngR+n+rLb7qIfCvw54DfA+wCLgG/BfxjVf3ATeo+AH4S+APAPwX+nGrrA2ca05jGNKbxJRu3DSpFZAId2yAiK8TatpdtWJGPa8Ob/PK/qwJrQ5Q2OFlaWuLy5csTS81uvXJ08wJ2j+kCwvb2ncps13O7c7p17p7X/tkFRG1w1D22e35bIbZduTupvLa79k6hqszOznLXXXcxNze35Z61rX5zdCFQe//a2hrXrl2b3H+w+zM3N8f999/PmTNnuHbtGoPBgAMHDtDr9VhZWeHkyZNcvHiRN77xjRw7dozxeMzS0hK9Xm8yVtowLV+z277cJ/m4rm1xd6zkctvjNo/p2dlZjhw5wnA45JOf/CS7du3ia77ma3jkkUd46qmnWF5enigW2/eqDfG2u2d33nknu3bt4sqVK5PjVlZWmJ2dBeDixYucO3eO/fv3T6BfGyK2AWAut67rSV2y4rL7HLatVdvqyXw/u8rBNgxs54ZsP+ft/mtHbnv7mAxqu9dvW8h2c1TmerTb0h5b7e25P7pQNo/jNtxtw8y2KjYD09xm59xEKdq2t/0yjCeB3RiE/DTws619vw2QJjU/DFwDfgGbZDwB/BXgO0Tk61R15WYXEpEfxyZBZ4B/D1wHvhb4UeDtIvItqtqo6lkR+QDwrSLyuKr+TqecI8C3AJ9U1c/e4HqzwK8B9wHvB34ee7VyL/A9wL/DJpU3qvNXY1ByAXgv8F+Bh4E/CnyPiHyzqn5im1P/NPDd6ZwPYxO07wdeLyJvyFB2GtOYxjSmMY1pfOmH8wWiEd+z7+J1Y8nbsq2n+DwnVpio6ZKiMsHDQFa2uaRUgqZucKL4GCiKHj7lmBRtsuSQ0hcGEELAO1NRmlAwW8laiCjOJQ9HMWjqfUEMNUlmZUrEyRyjoewJvbKkqe187x2OAjTi4+acSwDnzG0norhoIEPUMRgUzA/63LF/n80xfEGIwaBNExiOKqrxmNFoxMbGOnVdUY1G1FVNU1fU1Zi6GtM0dbITNVgS42aqjNA01h0iKS9jAcSktrM2e+fxRWlttGIoipJe2ccXHhGlcAVFryC6gtW1Md6X+NLatWfXPIOysOvEyIWrLxDqwD0PP8jr3/Am8A4NEY2BUI85WNfcffx+1ldWWV5eQjXivVntzs8N8M6hGgl1bQtcxyOaekQMMbW5IjYVaEAwK1kSOLR2mg2viCKSXXEsd6l3WVyXwWICWpohrxl4SrImneQ/FZ0oKkXV7HqTKjLbEmuMRIHS27lNhNA0BFJOxaisbYxsv5MJxHKOSb5EjZaH0jsBbVKO0bQoVmxR++KueXr9AWurG6ytbyTQOsFxzBSOA4OCqLA6rkmaQtaHY545eYb5PQc5fvdR5ud38+Bjs1y6vsZnP/tpRuureCeU/R6Hjz3C2tJlrl88ST+OcAI9gWN3HuCZ0xcZjmpOXV1hUAj3Hd7HyctLvHR5maXVHnM9oeeFfQuzFEaDqYKwEkuO79uPS88QCM57Su/xGqk1UPRmCNWI5bUNJEYWZ/sU3u5BhsEG0mUClZ0XSlfS75dUVYX4Itn85gXa+f1NZFw1UDX0EuT3ztTc/V4/We/a8+Ocn3w+2DzaUXiXYGcgNA2RiHce1YiG5Irmgj1/MSAKGiNITApthc77gS9gHMMWn/4O8H8DR7D51i+JyB9R1Z+50cki8lXALwN7gV/FFuHOAo9ic98bgkoR+WsYVPwo8N2qeu3VNIZX2Z5tIs/r343NR59s7TvZOfYPYouAfwn4Z9h8+bZDRP4O8LeBtVSP08AdwNdj8+gdQaWI7MHm0N8A/A1V/Xuvpi7TmMY0pjGN11bcNqjM1p755X6v13uZbWQGA/klf54sdBVQOdqwqQ0j8nHee3q9Hi+99BIXL17cAi+68HE7SLnd321g1AYTubyu6uxGZbSP3w5k7gQzukBnu/La27v7uyqz9nVvFaR226tquSIPHTrEoUOHKIpiAoZVlbquX1bfrISFTdBXliXD4ZDV1VU2Nja29DPA3Nwcx48f5/nnn2dpaYn5+XmOHDmCc47nnnuOF154gcFgwAMPPMCRI0e4ePEily9fpizLCVwKITAajbbkLdwJfuf8jG2w1s5X2AXFsHVcOueoqgrv/cRO9kMf+hAiwtd93dfxwAMP8Mwzz3D16tUtILkNEvM9a9ehKAoWFhY4cOAA58+fZ21tjRAC6+vrzM3N0e/3WVtb48SJEzzxxBMsLCxMAGKGZe32tNXO3XteVdUWC9/8LGeAWNc1RVFsgcFtyJqf81xuF8q2lZDtfm0/8zHGyRjq5n7M9zGfnxWouazc7qymbPdlWyXZrkPu8y7Qzve3PXZULRdP/sxq21m3IX3b6rhrP/3lEmorKU9ioPK39eVqwm/EJmofA75DW+rJ1grMvwP8pRtdJx3732A5Qt6lqsPWvh/GVIh/BvhHafN7gG/FJlZ/pVPcH8Wcn37iJs17OwYp/09V3VI/Eelhq1RvVGcB/iWwCPxRVf2p1r7vB/4/4F+JyKP68hWe7wC+ug1ZReSngT+MQdJ/c5Nrf3KHXQ/f6LwvVjz55JNf7Cp8ycTq6iow7bMv1Zjev9dW5PsxjWl8sUNDmi+FxiBjyu9GniMEU80J4LxPCrEMk6Jl73OeUizHoPcecSVWZJ0gV5qXx8Zwptg5E5VcYbkMNQEdXxRm9ahmLWvWoPZqIMaG0pdJ7ZWsYUUoix6ac+4JNCEg2piKEkCVUDc4p/iiJNQVTYx4sTpAsFyTTtBoFpJFaXA1JNtXCQ0C9LxjtleyZ37e5k+T+U1Sk6op9Jqw+R0+K1CzMkxjoAmBuqooiqLzfiIvHLXzDFT2EMlgRRL8U0j5P7N9qsZIHSJ1HSbQ2DuhXxY0oeHy5WXG6qibwP59e9m7d3fK06cEhZBdcEKg3rePpjqS5iCWBzHfP412DGqWqjEEmnpINRqyfO0yK0tXkWiWtd55irJAXIFqhBgQjdQhYGrenOvT2mGKzIgj4sQjGDgUjUmTKGa7K0LUaBA09YuKEgIQGxShaYKxJ1HKokAUqjriXTY1NYWkpOvWTSCEZH+M4JzlBW0ag6Gbz4ghU+ctn2PUaDlInUG90nlKZ+VvjMY2n9Ocr1SZ6QkHxdOEyDjEiV3tcFTx2Wee4+j9j3D/w/dQeM/R4/fxxBOP88lPfIJTJ58nNg1KZHH/IfpzC6xdOU+9chmtI3vnZ3ng2HGefeFFxlXFC5dWiKocPbiXwewC5y9dZrWKFCJc31jmjt1zzPQHXFoHv7jI/r270dAwqkwprDEyrsaYTTMUScE4Pz9DCIEL11ZZnO0j2Dgz2O7BO7yYVbTzBc6VeF8wOzNnCxfSHLUsS5z3eG+peuqmoW4CqgbDSf3lJgDUxklIFrMhL4ZOn0tqEmkb0yFajl3NGSolLYKo0KDpM06x26TJungTgH6B463AP1DVv5o3iMg/weat/0xEfmmnxbRpLvhvMUj5LlX96c7+u3a6qNjD9o+AP4vBzXep6ujVNoZX0Z7tQlV/VkSuY/PpJ7vz/E58BzbX/0+3V/XNEFNS/m1Mifl7teMmdJO+vReDpfcDf6w9/77BOTecN0+/s7/ymM53bi+m/XZ7Me2324tX2m+vpXnzbYPKnOcuq5Z6vd7LoEEb/GQ1VwYWWcWVIVsbpLXzBrZVXxmerK+vc+3atRtCue3UX10Q1QZSO0HE7cBVu9yucqwLLrcrv634y+W369k992bRbcd2UHS7Nmx3jXY59957L4899hiqyvr6+kQdC2wBQdm6E7bmB/TeMxgMWFpa4urVq1vgYb7v/X5/Yg27trbG/v372bNnD+PxmBMnTnDx4kXuvvtu7rvvPoqiYG1tjfX1dQaDwZbrjMfjCWzq3ocMyNtwLLfRLJOqSZva96N9XBty5fPKsuTQoUOcPn2aX/3VX6Wua97+9rfTNA1ra2tcvXp1Ms7b/dyGXTlyHQ8fPszZs2dZX1+f1Gk8Hk9ygL700kscP36cmZkZqqraYj3aVUpm2Na2ZQ4hUFXVBMZlsNiGtxlUZmvaXOd8fhvqtcfuduAv1yvfp/bznj9Dus9PbkN7LHX7q31c+++iKCjLclJmhqjZijiPwW7O3C7QbsP/fN8zsNyuTm0w/BUWfz79/JPasXhV1feIyF8A3sVNQCUGQhvgv21DyhQ/ik303sUmqPxZLJfIu0Tkr6tqaB3/bszC9V/fYhu610NVK6C6yXlfj01wPtadJKnqz4jInwXekv79aufc/0s7SlDgn2Og8mu4CaicxjSmMY1pTGMaXzrRhMrsV8EsSyc2mT4pHyXhHIOGlqeyQNVgVYxqILM9P0nQzntT0lnpWFka0WBWoTibh2iMdimY5Dt04hFfIGmfL1z6vusneQF9USSA6pKNJOT1Vw4DqzhHbBpQU1VGDWgzxgH9ssQIhwE9kv2kdwagYkyKR2egzDxGoaprVAtKr6h4Kz+BMAMroKUnBFMqugRlct1sXudASpgdJFAok7pEDSjO3GKl9d1eBOd6+FQfjdDUI7tnCfJGEfplaXabdUyqzKRsE0/USFUHvPPMzcwyUzgINUqkGMyYZW69OTerE7SEVp+Ehtg0k/FSh4A2NWvXI8uXz7GydIXRuMJjlqhl2WNmZg7vhaoaU9dK00QUn8ZXWvhdKk0daGJEvKkobUpj9sKWp9Ol3JRpjibOEk1GaGIk1sFgpghB00J0EWK0PIfeKaMA4zokrKyomr2xEzGLUrG+F1XL95lyiqoqTdRJ7kpRe1Ya0rxSSTlWra9mZmdwRZ+FuuL68jobG2NT8mHWtDOu4NCc4/KoZjhuTE1cOOqg/NrHPsbinr285a3fiBPHvtJz9/e+k2c/9wKf/e1PcfbsKZq6xvd6DPYcZqOYoR6tUYryukcewPmSk2fPMR4OOXNtHUF55OFHOXbfAzz97PP0ZxcYj9Y5M9ygHzz0Z7jjyF0c3L2L8foSG+OaENIiZudtEYBzhKYxwO88CzN96n7DaFzhxDHwnsI6yp4/AZ8WQSTHVlx00CgxWN7RWJf4sqTITkgY2M65KNFolsExUNf2WaDB7KlFhNjUk/d+IX1WgOKd2POjEVx6N4A38BxSft38uUQSF6A4bu0d1+chloEfaW9Q1d8UkZ/C5ou/n50Xtr4TOAq8twspUzlntjtJzJL0p1PZ/xj4i9ssWL3deDXtebXxc58PSJniz6Wf26Y8uUHfvgF4HzCH2eh+8PNUn2lMYxrTmMZrKG4bVLZVjl3Y2H6Bn0FWfsnfBmlthVUbrrVVZ+2ysnpreXmZtbW1l8Ek2GrxuBOsa0OR7WK7crtl7PT3qwGfO513o3q2Aed2kLJ9rZ1UX92+d85x9OhR3vSmN3Hs2LEtlpzte5OBXVtV1u7/fG+vXbvG0tLSy9paFAUzMzPEGNnY2KCua/r9PrOzs1y+fJnTp08DcP/993Pfffdx/fp11tfXKYpii31qBnHdvmvDp/x7e1uuX1VVk7a0bU+zYji3O7cxH5uvefDgQc6dO8dHPvIRyrLkLW95Cw899BCf+tSnuHTp0hblYhu+dSFfLmv//v2cOXNm0r6NjY1JjtDl5WUuXLjAYDCYgLe24jFPsrv3qA0psyqy3RddyJnzY+Zxk+9tG9bNz88jIqyvr295lrv5HHP5bQVkBpXt+5bL7yowgS2QHJiAx9yPuS/y79365uvlcrtQOo+pfO+zVW4G0m3b3Lbis60i/gqNr8Og4PeJyPdts78HHBCRfap6dbsCxCxYX4/ldvyLO3x2joFH8h+qOhSRfwP8SeDbsEkLIvJm4DHgP6rqlZvU/cPAWeAHReRNqYxfw5Sj4YZnWrwp/fzQDvs/hEHKN/JyUPmb2xx/Ov3cc7MLq+qbt9sutmL0Tdvt+2LG2972ti92Fb5kIq94m/bZl2ZM799rKxYWFr7YVZjGNCzEFID2u0t2jdlVxODZplLJVI8azQLWwBkghZ3rBO8LQlI4mXrQ0yRlpZ1i3p6GI0HEE13OVwcTvWayay2KpMoSRyzyAspgIDVZe3rvaWIgNoEYG0QSyAsRbVqLUZOisWlMIZi/r8dJXawPUE0Wt1CWPUAJMUxy9jlnoDbizNLVuQQUJR2Q3xM4IptzGKMsUHif+lwn6lJThAXLVRkcrshzBMtjqQmWOZEEdQUkIt4TQ6pbVISIczDolZuqw2iKPXFCHYXQREKI9GdnqRFwvQSRBY9ZcqKBKDZH7PX7KXemma3m+6kKMdSsLl3hwtkXOH/6Ja6vLBtoRCwDqSpV06BrazaPKfv0FxaZ78/gC1u4qqHBoTSNWemGqiKEBiamwgaqXFRTdSb4mHML1k1DCIadVKHwmnJM2py6iTavGlY1oYngLL+hL3qU/RkKXyDe0yv7iDPQXlVjtB5TVSNCXdPESJPkxJH0Tsgun0Dupj5TEj8VVUKyHN29OEe/3+P6yhpNndx4iMwWcGBQcCUq67WpNZ3AaDTmPz/5JEXZ4zu+650AeBHe+g1fy5vf8Dgf++jH+PjHPsrVq1ftOezPMA5wpRpSnT7Pww8/Qt0EljdGOBzX1q/z4uee4/jx+/iaN7+R5144SVEsUM7O433BzGDAIw8/xO75Gc6e/RxB3AQG98ue5QJVqJpk91s30C/olY5QOygM3NuzFtFGCTTU+XOlqlKO2fS+RewekaybQYgY+PfO5rYuPVch5AUM6d2TmoWyXStYjsz0EWZcO6Bqn01OwMvmvTHLXlt0kfua9nx5+9dkX4j4LVXdTiLyJAb23sjOYO9r089fegXXmwE+iM2P/7qq/v1XcO6txKtpz6uN3/g8lvW12P+EXgn4fAvwl4FV4K2q+ulbPfFm8+bpd/ZXHtP5zu3FtN9uL6b9dnvxSvvttTRvflXWr11lYI62feN2drAZTnRhSRukbadwCiGwtrbG0tLSBC514WOO7eq2XV1vBDPb8LALlrpxI9DYblMXLHavd6M6tqFjV4XWbXcXnt6ofl3I65ybwMFerzeBW1mVlwFSBtAxxsl4aCvVMpS7dOmSfcHvXGtxcZF9+/Zx7do11tbWAJiZmUFVeeaZZ1haWuLgwYM89NBD7N69m2eeeYb19fUtyrg2mGq3oT0m2rkzYRPGdgFdN8djO+diuy/zvwxL5+bmJra0H/7wh+n3+zzxxBM8/vjjfPKTn5zYuOYycx3aMC7/m5+fZ//+/SwuLrKysjJRfGZQurGxwZkzZzh8+DCHDh2a2Li2y86Kwty+DJLzuMgQtgs624sDura4bfDY7UdVnahS2/2ar5ntZNvAvJtDslt+1961Pa7a57SfhTZIbwPELoRv5+vM/ZTzj+ZxnvsjW1q3P6va/7rj5isw9mH/H/mhmxw3D2wLKjEwJ8CBWyinHe/BQOW7SaAy/Q63MElT1RUR+VrMmva7MeAJcEVE/inwd1W13rEA2JV+nt9hf96+e5t917fZliXhv2t+SNOYxjSmMY1pTOMLH94XBifJ87KU0y8pDF36Dh6yPWiEqJvffTWC92neIymtRII2MRpoMv5nUEIEXIIgiFoOOUCThakglnfRmY1pTPVSiWYXKwY3fbJQZbII0XiH9yUIRFVCU08sPJNeERS8d9RNWkibrikJnOR5i2RYiykhBY94nQCbiRIzykRFGdTUch6H4CkKISYwomiym4yTPJNq1BMXA857JDrUKZrVl87hiwjikotNUoiqEkNlgEUtP59OyhU0GFh1zmCeIozG9cT+tWkqQmwo09wozz/EeULTABFxbWeUVQAAIABJREFUBf1eQR0iGppkvynQjOmJElRZW7nK5bMnOX3qJNeWlm1OhdArzOYTV9CfnWd+cS/zu3YzO7fAYGZAv1/gW/0YmhoNgRhqmz9W4zTnCcTQEMdjRqMhTVMT6gaNDSE0E2vdJihNiGl8KSE4xJNsY6FI+RCLsiTiLHenK3CuoOiVCVh5vDcFnzjFU9KI0oSaGBVHSArXjLyMRsaoSQxrY1sVogDR3HOq2hSBkl4lzczOMhyO2NgYo5gF7Wzh2T9TglOCs7ytdV0xGg35jV//ONVoyPf+/u9l1/6D9ErLOfpt3/pNHDh4kP/ykY/y4gvPwbiiPxjgi4K1uuFzpy7w0MOPcuLEUwQcMzOHWRsPOXHmMotrgfsfeICTJ1+iLw6ictd9D3Hvkb0Uopw/f4lGQaPlqaybihgsj6Ok52V5dYO6rhiUJYUI/cIxMxjQmyhT7cnyiEFGwdSN0exaQ4hJ8RoJTaRRA7+T510tx6V3Ds3vilx67FQJSXnpRGmC2fWSHksnSlSz0nWiphYXWyQR3eSxsQUZYuPEyea7lN+luLjD9gvp564d9sPm/O1lir8bxAK2YHQFy235+Y5X055XGxdufsgtx25gSV/uonSjeCPWvx8Fnv481mUa05jGNKbxGovbBpVtwNZV8dV1PcmblyFDG4jkfe0yulavsGkv2laznT17dmL72oVvXSXhdsrF7nHdv3eCmF214HbHd8/bDp62cxa2j+ue071WF5R267FdHW4EaLt1bee3dM6xe/du5ubmtqjj2sds10fd7XlfV1GZ7/fevXu56667uHDhAisrK8zMzDAYDFheXubFF1+kaRqOHTvG8ePHJ3aqOT9kLtt7T1mWW8BYtx5ZEdfNjdq2r8391VYj5rq2oXwbSuWyVZVdu+x74alTp/jgBz/IwsLCRI164sQJVlZWJlBVRCYwLF8zb/fec+jQIe6++26efvrpCWisqmoCIC9evMjq6ipHjhyZQLk2KGvDxnz/Mpxs90+GctkON7evbencVibmBQZ538bGBiIygaXtZ1hV6ff7k7a2YW8uow0622CyC0uBCVjs5sZt35fu50Z7/Ocy289QO4dm2446161rX9sGo7n/utu+AmMZcKq691WWAfApVb1lNaCqflREngO+W0R2A+uYdeoVNsHlzco4A/wJsRv4KPBNWC7Mv40tGP5bt1DvwzvsP9I5bhrTmMY0pjGNaXwFhthrfHt5n5SSLinOYoiEUJvCDiaKQPvdISTlH3lBoKKk79VZpNn6XitCsmc0pOZdKzejc6Z0k2T96B1NSPBCTaWVrTaNDKVriksQwixJDS6a8i4CMcSJktJMKRIgU8tx54tyk2CSlKPemVoPkirL4Qo2oSvQhJoQU19hcEZ1U32qEogBYrBciTEpQV0CJhmEumR/a9zLkfOBWmrQSAyBGCu8WO4/n4Bvo0oIyfJSc47DpPAUDMyR5pMiNCrWnwTERWb6Hm1GBlE10tRVUl8aVOv1+oBQFg58z8ZIPWZ96QpXz5/m0sWzXL22xPpwhAlolaI/R392gYU9ezlw6Ai79uxnYWGRQb9HDDUiukWwZlDYbGvRlBuzqYkxEJpgeSY10jQ1TdVQ1RVNXU1gZlVVNOMx49HQlI9NIMaAw9qQxXLiDH73eyVl2cOVBYXvmeoWpakqRhvrjMZjQqiRdJ9tzpaHu6MsxaBqGgWqmnJdOrNtTe2ZwExf2j3wJKWyUqilOPH9PkvXV1lbH+FTXsc9/RKdXaCOSWEYImtra3zmdz7D6vJ1vvu7v4vXv/mr0NAQ64aH7jvGwQMH+ORnnuK3PvEJLl86z2i4QVna3HR1VPHA/ffx3Asv0Z/fxWg0IISG1RrOXLjIfcePcvnaMguH7+GJB+5ibjDg+rkXubi8gYq3XJ1liYaGOpqFqjHYyOLiInvmeqysGc/ZVXp6Ltve2ji1Zy4tzM4fCJrTtYRJHtegNS7YM05UogaCOoOOBMQpqi5ruxNYFtQ1aXFBxOnmdufAaVZNQnQuKS0t3yiq1MEWXYgoRQE9J8kI9laMaz4vcWiH7XnudqM5Wl5UeucruN4l4E8A7wX+s4h8q6pu56Kj7PwedrsFrjleTXtebexEl/NLqFfSnuvAPhGZeQWw8p8AB4H/AXiviHzvKwSd05jGNKYxjS+RuG1Q2VY7ZpWW2bw0L8sJ2FYoddWB3e1tANG298zqr5deemmizttJKbgd9Gv/bF+/Xc52+7eDne2VYO1jusffSp26x20HE7vwcqeVaF0V5Y32d/sg7y+Kgr179zIYDF4GQ7ez+82QCDbzU7aPVdVJXsn2vVZVDh06xAMPPMDTTz/N9evXJ9d94YUXWFpaYnFxkQcffJAjR45w6dIlxuPxFtDbVlHm/KV5tWrOz5j/zgrCdr26asO24rCtBmz3VVYOttufwdbCwgL33HMPp06d4n3vex/veMc7eOyxx2iahs997nNsbGxsgYXd+5ifmf3793Pvvffy/PPPT643Go3w3jMzM8Pq6ipnz55lcXFxYoGan7u2NW/btjb3RT6ubama713ePx6PJ32az+9arwL0er0JqGwrn3NZuew2pNx8ibLZ3zmHJDD5mfuj/dnQVmC2r5PvWVY/5rZv9/xnKNpe/JD7eDtVZYazWdnahpdt0LyTrfKXSeQbuJ3S7+PAd4rIY6r61O0UrqprIvIU8JiI7FXVa6/g9J8A/i7w/dgq0/1Y/scbKSG3q4MCTwFPicjPAqeA7+XGoPJT6efbdtj/jennb72SukxjGtOYxjSmMY0vr2iatDgPiCpojLjQUBSeEJUYTNEn6Z9zTH4XMXDhXIJ/E9lislR0Pm3KWr+04I+UI04DokKWm7lkFdqEgFMDjIq5mQhJMpnsaAv1SOEBl+YBOYdenewbHRqjWYhuWWDLBBL6BGBb5q8453HqUJcWMYcm5dBUvC8Jara2ojJRiZLgqReX8jgmR5bJO4n8vT3nS7Tfe2WPqHlbRMQWUYvLOeYVXzgKsXoaMDYIZwslFQS0AV/YfQlNQ1BTtVqbI03QBFcN6Igq+xZm+NyJE4TRkCP3HsPPzCGAL8yGNjQNToSiLCFGlq9e4MVnPsuZUy+xsTEkAM73KOf3Mr/nEHv2H2TPnr0sLC4wOzOg3ysovMFujYHAZroOU8YlaOk8ZuOrOOdpgqkrJ+9pWmlCmtAYUNXsilMRqoo6LW7VaPPh0IyJsUZDJNQVGmua8YiqaqirCgV6PZtbORFi0zCqa6qqSTCX7ACMF5/Gk07AZUgw2caipLFkYBEMkMVUhpeUp1EjiAe1HJcLrk+v8FxbXWfp+irrwxqRmqJp6C/up+iXhNgwHG5QlJ6z587xH/7Dz3Lp/Fm+9uu/gd7MDCtrGziUN7/uEe67926eff4kzz77DEtXrzBcX2V9fZ3B3r0cvfcoq6sr9ChpgkH49fUhZ66s8tjjr+fo4d0UQKE1zz77HE1Rok1tYLUo8GGECNS1ja2iKJjrF5TOs2d+wHBcszBjC6SDqgHOqARq6mAq4wzgRZSY3bBCNOWzxmTpG22RgQpFXhORoa/Y+BBJ+S9xprJOT29M6ki/5Wm2BQAxya2NwJkCulfYZ5YtsrDlFTEyAdO/C/EmEVnQl9ulvi39/BQ7x8fTz28H/tmtXlBVPygi7wB+EfiAiHy7qn6sc9gScHf3XLGH9A03KP7VtGenuNE8/1YiqxG2a88i8OA253wc+C7gHcB/vMXrqKr+jyIyAv4i8Isi8k5VXb+NOk9jGtOYxjRew/F5A5VtsNiGO928f+39bYDRteNsQ7IMKdfX17l06RLr6+tbQMeNQN9OUC/X71ZgZf59pzJ2uu5Ox3aPabelXZcu1M372sBoJyDZhafbRbfNqsrMzAxPPPEEd9xxxwSA5fvSrme3Plk51y47555cXV3dAvhyHDhwgGPHjvGhD32I69evc/z4cWZmZnj66aep65qHH36Y+++/n16vx9mzZyegsjs+YCvg7uY+bf8LITAajSaTuO1yFbaBaxvEtuFYu+/b6r/FxUWOHTvGyZMnef/734+q8uijjxJjnMDKNgBr93+GZzl35+Li4gSOZfVeWZaMRiPOnTvH4uIi99xzzxZYmoFaLi/XD5j0WxfAZTCXn09gC/it6/pltsy5zbn83Ie9Xo9erzc5Lh/bHue5jfn5z0rR9lhu35/2vcl5LfMxuU1tq+Gu6rWtjmyPzQw+u58RGcp2FbjtRRPtfd1n8sswlrA55j3b7Ps/gO8E/rmI/EFVPdfeKSJzwOOq+vFtzm3HPwT+BfDjIvIDqrrFGlVE9gDHVLUL/f4l8CPAH2fTDuc9N28SiMhjwBVV7dro5NWqGzcp4teAZ4C3pLb/u1bZfxD4vcCzwEdupT7TmMY0pjGNaUzjyzNE7IW9SIItsmn1KgK+KBHnKcsC51JqhpByUIqgyXrRpRyVJBWV5bNMC/nUbGCDqlnNOk/Uhqaq8d4lYJd1bKaAs3OaifWmdwXOu8QpkxKvCahaCgcFCDl35qY97UTZ2fpP1GThGhs0Wk5BnJuoJ3FCjHZc4QuiCwY9YzA2KA7nUw5MDEoFDThRpAHnM0A1QItGCm8guG7lpW+C4pNla4jBnFlUkRAsf6MILqeM0EjUgMPydYrLi7ENroaQFl8nVZuqWdnOlj02RhV1iDR1w6iqKUQpC8edDz7Gi6fPcfL5D/B7vulbKWdniU2DqM3tVpcus3zlAlcuXuDKtWusj2qkN2Dh4FEO3HEH+w4cZs+ePcwOBslC02w+NVnn2hgBTcpR7xOQtYE3mUs513q3gClry6KgqhvLd5pUihpznkjFiVLVNXWdVLKpLAObDTHUhDrQNBX1eEg13GA42mA8GlGNR4yqsak8MZgYmkDTRIxjWQZVy42axpsaiU8/kl2wjRFT/VrfF94RM3gDVCVZKZsiMKrRMeccvZ7nwJ555mcGXFve4PrqGsPRiOiWuGPfPsrBHOPxiPW1VSRGmqbiP31glac+e4KvevMbeOh1T4DMs3TtKgWBh47dxfF7jrC0vMrFK1e5eOECFy9cYNfcAlUALWvm+gMWdu1h3/793H1kP3M+4p1j0C957pMf49zyCMWgJM5Tes/qkqV8URTvHBHh+uoGdb9gflAyO7/AHYfvYtArKL3NezXNcUejIaONdarxkLqp8arEaGrKoBFNsDf56k5AoapiOXOt30SgyHkqiSTtd8p5qWmRA+DAq405n9+xqFgOS1XGavfYO8t/K0mNbffkdxVU7sJccv5q3iAiXwW8C1Mf3giS/TxwEnPu+cOq+q/bO0XkLjVnnpeFqv4XEfkWLAfjr4jId6nqh1uH/AbwDjHF5a+0tv/PwL1foPbsFDk1y3bz/JuGqq6KyNPAN4jIo6r6X1O9PDa/n9nmtH+Mgcr/XUR+Q1W32OuKyJ3dba3r/SURGQJ/A/hlEfkOVV25nbpPYxrTmMY0Xptx26AyK47aOf3yC/62Yivvg62gJL/4z1942+VkMJPVYiEENjY2uHDhAsvLyxN41i5/OwjYBhBdKNSuVzu64G67Y28ER7tgs/uze63tzumW2VbIbVeHLti8UXTr0+2jwWDAkSNHKIqC9fX1yTFtELYlz0YClDFGZmdnJ387Z3k+Ll68yMrKypZ7nq89NzfH3NwcV65cmeSerKqKK1eusGvXLh5//HHuvvtuhsMhKysrk3HVVjPCJshuK3Db7cp17uZBbI+JNqTL7e2O03Y/t6FVW71XliW7d+/m6NGjnDp1il/4hV+g1+vx6KOPUtc1J06coKqqLWW17U9zmbt37+bYsWOsr6+zuro6gZF1XVMUBVeuXOHKlSvcf//9W+5fVpK2y+/mbszPVQZ4GZDmY6uqmtzffK/7/f4W9bT3frIKFzbVjjMzMxRFMQGsbdVjG/4BEzvenWB/N69nu7/aALF9P9vq7TZIbPdFtpHNQLe9gKJ9bvvzKdc3tz2D3Pxc7rQY4ssh1BSPvw78XhH5KQy+BeC9aqtGfxD4X4HnROR9wItYTsp7gd+Hgbp33OQaPy4ibwb+NPC8iPwypmrcCxwD3gr8v5jdS/u80yLyn4G3Yzkef0dVb3U16bcAPyYiH0ttugTcBXwPZmPzYzeps4rIu4H3Az8jIj+H5cx4CFNjrgJ/XFW/rCn2NKYxjWlMYxrTuHGIkwRdwJSQBhrte2ee26TtMVB6T3SWLE4Vmro2MFUUKH6iYHJJkhYTiIsxoApeIuI9GUpohHFd40UonQEFCYo6MXVWzLaZaYGjZFVlUmCpbsIFt2lN6xIw886jEpOCTybtEbFcnFHTwsKYFYuW51AkzQVSFksVZ9AM6PcKxBc0dZ2glJK/9kdV6joQm1H6OylKNZpaU4Si10PEJ2eYhqJwFGUf7x1eIAbLL2l1zs5APoFSA3bOeUzQ6YBAVLN49Wp2syQFmnOefq8gDCuc2L3ZGI7QEFiYm+OBRx7hc0/9NoKysXSRqxfOceX8GdbW1tgYjRk1wmB+F/vvfR0P33k3u/fsYWFulkFZJhvbnH4k2D0SIThBY3absXunMVBXMd1D61fvDPRZ3QvQSBOC5Tolgc+iNDVoUyMO+p6kQnUURUnomxKV1hw8hoZQN+m9TUNd1TTNmNFog1A3VOMx48psZOtqRKgqZDym6DcowdR8MaLYvXVObPwCTe2oQ0h5XTVpvkxNK87gtUcmuRBtrhiIKYeid97GbQRRhxdhru8YHCiZm+lx6foqo3HFpdMnufPeY/SLHuMQWFtbp6prRuMxa2vrnD53noMf+w3e9IbXc+yBh+j1e1y/fp2mGjFTOo4eOcA9h/YxfvRBhmOzys3vK0oHEhs0NPiyx0zpOPmZT/LZkxeJ4gjVmKapAWHQ73Fm2dZoeqDWyML8PHvnBww3howaeOTh+7n7nkMUTiDYu7Lxxhrr4w3ieJ04Xrc+TgsK7LPFFNQZ9mpeMKGmeCR9Jol4vE+pbpw9u+T3PiGiGmyBgyZj5gQrTb2txGiwOaYVDJaz1SCpi1aemjCZnKv2dyl+FfjvROT3YAtMj2AuPA74UzcCXKpaicj3Ab8C/LSI/ClMCTgAHsHmnju+S1XVXxeRb8Lmie8Tsyp9f9r9D4BvA35ORH4GuAZ8PTbnfZKd3Xpuuz03iGewPJx/SERq4CXsDv8rVX3pFsv4MWzB8a+JyL8FRpizUAl8Gnh9+2BV/RUR+bsYmD0h5mZ0Glss/Basn39gp4up6t8UU1b+HeD9IvIOVV3a6fhpTGMa05jGl1bcNqjML+czfMjb2irL7XICdvO/wVb1VBtkttVOGdK0c/u1owv7bnRMe/92cHA7uNktK5/XBV9dwNitU7c+XdjS3rcdyNxu+3axXRtuBikznPLeMxwOt+QSbfdDG8y0FXxte9F8Ty9evPgy21dgAszqumZ9fZ0QAlevXp1AsjvvvJOHHnqIoig4ffr0y8ZLG0LlerTBVnt8dgFkthrNx7VtPtuArg3c22M69xWwRe3Yhuf79u2jaRrOnTvHBz7wAWZnZ7n//vsJIXDixIkJ1O/1ehRFMbFJzXWam5vjnnvu4eTJk6ytrU0WAmxsbDAzM8N4PGZ5eZnhcMjs7OykL9o5HHNf5TZmUJktUquqmtzXrEgcj8dbFKXtcVqk1cb5/DbIa+fYbMPIvC2X037G24C0u0Agj5c2hG6P03xM+/d2Xs3uGM//2grh9iKJLqRs34v2AotcRvvzbbvPhy/D+GOYevIdWB5IAc4An1HV/01Efg3489jk4nuwVZ1ngf8H+OlbuYCq/hkR+SUMRn4zltPiGgYsfwz4yR1OfQ+bk8WfeAVt+mVs9ehbU50XgfPYhPIfqupHb6HOvy4iX41NtL4ZeCeWI/NfAz+qqs+8gvpMYxrTmMY0pjGNL8NomuwQ4vBeKbxHxUEMlo8uGSk2TUAEAgFECE0wsOZNgei8oBpTLkbLVWn5+gTxjjooMdQUhcd5IQSDpC4tLo0hUDUh2cgqsTF6UHpvdquQYEQEdcTQEDUr4Lwp3xCzkxUzjXU+gytQyVI4U09JynUnrjAryRbkcr6HRrV/xkDMBjfanKWqaqAmp0BTDLg67/CiFGVBTHMT+24eQUrLvSlYn4kz9V3hEdWk5jSLzGw1Cpqsa/0EFot3iILzBso0zVmiJhjr8kLVkPJbBsYrS6xdvkD0A+YZsVA2bEhg9eoFTr10Cq1W+OgHfp7V9TWq2u7b7PwiRx//Og7dcRe7d+9hbqZPvywJ0dSlGg0whqZOc6UIWI5NI9CbINk63CX1bTOB4dYPNvYcJMvanAbFLGv7g4JeWVCNJeUwdVTjMRrrdA1TV3rn8IWnLHuEGAllY2MkRkKwfpxtdk3e2cSmoanHhLpmuLHKcG0ViYGmGVGPR2i0vqsbg+iuKABBix7DuqIJAVTM3tXZnBFJ9qHi6JclIkpVB8Z1RVM1ZiOsUKAEiTZ60r30CAf2z7L3wEFWR4GNKrK2MWT3vnnmBgPW1tZpmtqA5bhiY32D6yvLnD5/gUOf+E0eOHYvR4/fx969exmNK4Yb64xGQ7w2zDilV3iiBzCw63ozFF4Yr1zlM5/4bZ45fYkKD9rQ1I0tEChKmuEaddPQhEBVVwx6PUqx52dupk9vYR+vf+wR5gulGo4Yri2zvrLEcO066yvLbGwMqZraYODk3Y7bXByRFMoighcQ53G+wLkCX5T4wnLA5pUAEmvG4wpozCa2ETQrl2NEvTNb5qR0zg+okBYuiCBizxyT6+dHTjc/a77w8SI2r/x76WcfS8nxI6r6yzc7WVV/U0TeAPwgZgH79dhC1M9hysabnf8pEXkb8AHg50XkD6jqL6aFvt+byvhDwDo2//x+DL59QdqzQx2DiPz+VOb3AQvYrfoIBi1vpYwfF3v58peBd2NuTD8H/E3g3+9wzt9Ki4X/PKaunMMWDf8m5ph0s2v+iJiy8u8DHxRTp165lfpOYxrTmMY0Xttx26AS2AKBMkhov7TfCRa2IVBWN8H2KsQ2IJqfn2f37t1cu3ZtAsdg09oyg4YuLLwRSNgJVu70d7vM7WK7fTcDoF0r0XYfbFffbjk3Apc3alu3zkVRMDc3N5nwte1Js5KsDS5hU/WWla9txWUIgWvXrjEcvjzP9eLiIv1+n6WlJUajESLC1atXWV1dZdeuXRw/fpw77riDjY0NTp8+vUVV17ZaDSFMrt0Fku3x2QZS3f7M23NZ+di2Oq99fAZv+bjcP7nfchw6dAjn3MQG9ju/8zt59NFHqaqKU6dOUVXVxF41qw/ztcqyZN++fezfv5/r168zHA5t5eR4zOzsLEVRsLy8zJkzZ3jwwQfp9/uTZ6oL/MuynDxn7b5pW8RmiJkVlu3jsgqxC//aqtouyG6DzVyvDB3zNfMktv0Z0B6juT/adry5z7MdbS4/n5cBeAa7XejZbkMX4uefud7Z+jg/B+3xIiJboOeXO6hU1c9hEG6n/R/hFi1OVfXoDfb9AvALr7BuP8nOEDMfc5I0P25tO4FNqG7lGk92z2/tewYDubdSzg8DP3yrdZzGNKYxjWlMYxpf+uFcQYzBwJ4zUObElI0xBrNHFYfkNCgJLEW13ItOnOWZC4EQIqqRwnvwHpJaCVV6RYn0eiCmwmwau2ZoahTBJ1vHDDqjRhxC0SspxWxQo2pS6ikhJcX0TlIOTAMRk5x0GhNETTAsgQnNuSXVFIfpVHzK02kWpZ5GG8th6TzjUXbczwqwZAGbvu975/G9wuxkNStHMwgtCU2k8FnFmdWdBlS9M4tYSf0ZmiYpEBVVm+eE2mCg85v1zXlFBSjKHkXZT8pVRXFU1YhIoB5XXLxwmbULp9l18A56WtPTmkojLz77XxmPxqwPVyl7PVSFojegN7uL+x55nMceex1F6cm5QqNuznkDmhSpQIw4n48zeGlzl6RUc4JD8V5o1NSWztmcRmPEY3kfFRtbIZhNsDN5KU1l+QwlBlQkWRSXqFMKzQt1fZYw4sVUq0h/AtgBmhAITWPWr6MRTe0J1YhqvIE4sfEbAfGoMzVrWZo6VxBGwxEhQK8/Q987nO9TlD3KXg9xHnGeoujhvFAWzqx7xex+x6OK9fU1NkYjRqMhdWVzeYOvHl8UFL0Bs3ML9AYzqC8YjgJV3RCBxfk5Ll+x90yj8YhxXdNvBlR1Q1XVXLx0lU9/9gT79uzi0MED7Nt/gNn5OfxgniZEmsbAdQg1TTVifeki50+9xHMvneH6MKB46tDQNHXKk+qZm5/h0kvPE6JSCtQIVYisDsfEpmFx126eePNXcWj3PM14SBwp4+Eaq8vXWV9ZoRpvWFkJWseY5rQuuQJlWJjyRnpv/WCpV2zckMyVHZIUsBVNE0CDqSNtFYKNTwGX571i90xF89oEe3btkyKpLg1wxgARU3VmtfbvRqT53vfc5Jj3sEPqEFU9hTn+3Ow6R3fY/lng8Dbb3wu8d5tTfoAbqwlv2p5XGqr6CWzR73b73sMtpFVR1X+BqSq78bYbnPM+4H03KfdJdp6D/xg3cUCaxjSmMY1pfOnFbYPK/OK+a5HYfmGfIUJWbnXzvWX41YYJIrIFPGRY1Ov1WFxc5OGHH2ZjY4MzZ85syTGXz+3aRLbr2oZW7b93att227aDjjcqa7syunCxbS95szK3U0hud8xO57b7pwt2Z2dnOXLkCLOzs1tUc11Y1M0HORgMthwbY5zAnpWVFYbD4ctg1t13383u3bs5deoUo5HZ9tR1jfeePXv2cN999zE7O8v58+dZXV3dAkIzHMswajAYbNnWho9thVyODCQzbOv1epPzsh1pBnabeT02x277Wr1ebwLGqqqajPV8/sLCAnfffTfPPvssRVHw9re/na/+6q/Ge8+FCxcmbcoQLQM97z3z8/McPXqUy5cvT/ooA0bnHOvr65w8eZJjx46xuLhIXdfS8xeeAAAgAElEQVQTpSawBS6DPat5f1d5mMdbPqetes4K1DYUFDGb4PZ4yEAvt6FtAZu3ZwvZ9rOf1a1toJnLBSYq0fZzkxWo+X5moLgTyM9t6Pf7LwP8uY8y2Oz1elsUqXnst9uYLXa/EiDlNKYxjWlMYxrTmMY0bj9CqM2KM0FFFcElAhYNX5q7ZTB7z9J5oth37kYjguUjNEvPNI/DLDDN5TOBzFjj1REQQlMTUQrnkASY6hhxrkk5CiXVySWLzf+fvTdrkuS4zjaf4+4RmVlLd3U30CB2oNEgQFGUSBuTaCRlWky6pTT/aOanfP9BZrqRROONzCjKpDFxEcUFjbWxNNBLdXdVZkb4MhfHT5RXohrUQEOb+WbiGNpQVRkZi7tHWno8/r5vBRG4+n034lyoufIRKthU5aKr8LTmB2ZVkBUcpQiu2sAigpNSVXxQjSjVgrLOR1JKkCNg9rJV8cfZXFPBYKGkSGnmTClGUlb1YOc9YItShZQjgmVZFpxASnlqu5wzKar6rmjrk5K2jxNPWKxIKSKi1rYpRSSNakHrA13nWSwuE7NacF578Qbb5BlPPoUyslwsWT37Ao9PRxZXr/Lcc39E33Ws9vY42D/g4GCf1bInjgM5KWCd+A+ObrFAsDxMtWzNWXMDxSRqKAgOISggLFkzPVMFZpLp69wrxVHBszic6P+7UK1x46Bt5Xylnno+vmhfpKQQTO1ipbLKCM4RnGPRaRvnXPDiiUBOHX0X8VKIQL9YElMkjj05JfocKXkkjRGpaYib9ZZ7pwOnYyast1zZX7G35+i7BYeXjyDo//u+x0upatasmZkx6nOBvRX7my0xpslGGKe2v13X0y8WhH5Fv1jgg0fEM8TMZkg8fnzK5aOrfHb3Lg+OjzX3cbNmu10zjiOr1Yohjtx7+Jhfv/chwcHSO1aLjr7zCndTYr1Zc3q65eHplm1KjI07zzhGYlSL28WiZymFRyeP2Y5jtfYVLh0ecrTfI6Xw4utv8nuvPI+XwpAysWbXlpJJKRLTmTVzKdqSNpZKUbWyL1XWmCOp6LgfB7WkDb2jCx3BB100UBLjYDmogiuZpL2r9/O5TzZT51b75WLjUg+nKuhSAXxBfM3YnafOc80111xzzTXXE+q/Zf3aZuu18APOIKVtaxBEV2+dATNTsrX7a99nYCTGSNd1vPLKKzx69Ijtdsunn376OcgHnweNuyq89u8t2LjovQazLlImtrDjScd/Ekz8bdv+NvjxpOPuXs9FyrHd/Vt/7O/v88ILL3Dp0qVz6jdggke7gNTAXd/3k8rN4M44jjx+/HgCa+05vfrqq1y7do233nprApkG577yla/w0ksvsV6vuX///rksQzvvVh3XKu8MUu5a8u7+3MJXg1523q19bTtmWqvZXUDf5hzCGTwLIXB0dERKif/4j/8gpcRf//Vf841vfIOUEh999NG0j/bcDNg999xzXL58mU8//XS6V9brNfv7+zjnOD4+5u7duxNcM1BqoNnau1VsWh/ZNq0K1ra3cW9tsQu17fzsAYNZ4Hrv6ft++ptBQIOE7bhqYe+uHfSutaxtbz8vl8vPKbrHcTxn7duOh928SvscatvD9gNn+Zm7n09d150bx7ufe3PNNddcc80111xzzdWW85rhZjmCwSsQ8uJYdD0FGKPmUEJQRSOFPGVHusm+0Xun4LBm9eUCJattpBSh+KIgpKgCb4wJJxnvnFrAmtJRzmIaxpgRUR0UmH2k4AMIFTpWC9SKHVCcdvYdfZpZVqDmbOFhqtatpTDmsYq7HLnam+p3fqYMyiKaceed0IUOKPjgJvUWqAVqyWmyYkWKxkji8U7bymPz9WbublC22qqCKlq323FqZ5HA4eXLrPYPeXh8j836lFjsvFWNGDpVeOacqqWtcLjX8cbX3+DR6Q0ePTzmzVf+gL2DQ/YODlg6iMOpztMqqDGlaMqZgq/tqvuVqrotJStANLZTXV+pqkrnHL7T8dIHT8aRhqyGuVL3X+dXY4rVJhgoBe8Dvu/ovGekWdBcVaaTWlNUQZpSIZOqBWs9L/Q1SqrqXwDNJPXes+iXRKej5PDSJfrlinFUO9HlYgE5E+O2QvACRXj2pjBmSHiOH54wDluOtyeE5Lj+zDNcuXyJ1XJJSZFhuyamyPp0zZgK0gX2L/UcXCqInM0Bxdni3YD4Dgke7zSXs0hhheOKC6Snjrh+eo27967w7rvv8tEnhZgScRzYDBtSznQhEHzAec8AnBbID/W+KFkzHc3uNBVTLms/xJiIcaRIoetX7C97br/7FmPKdN6xzapwlRSRHLh8eMhXnz1CNifkxRIXPKFf0O/t0y+W+K5HxpEUB50XT/rfelvUHMlJIqyrHXC+o+uX9P0C8Z7gA0ImxpGYqarHUhclFKSoqtfu3VI/y5CiiLlAzApLBbGPq7rAgHpsZ7fqDCrnmmuuueaaa64n1n/L+rXN8muVZnA2IWihhP2+C+TajL8WMgAMwzBBzlIKi8WCN998k77v+fd//3c++eSTc/mALdTYBXZt7W7XKiWf9NoumNz9+YsUmrsKzPbn9rVd0NjWRQByNyevBZO23e41XXRu1rZXr149p15sIaDBqPYc2/43haONg9PT08mytIW9IsIrr7zC4eEhv/jFL9hsNpNl55UrV/jqV7/Ks88+y4cffsgnn3wyqSiBc3akbYYg8DnQtgvE2tzK1jrYoJypf1toZ2OzhVvAWfZGzmy322lbUywatO37HhFhsVjQdR0/+9nPyDnz/e9/n9///d9nvV7zq1/96lx/9n0/wd3VasWVK1fY29ubsj6HYWB/f58QAqenp7zzzjtcvnyZg4ODc9fdtkerJLR2aG1SWxVza8ts/WYQ0cBjq2A0laGpKA3wtgDX+sq2aceofY7swsRWGbu7eMH6wrY1hWYLK1er1XTu7bi1Nt699sVice7eMihpfX3RvZNzPvd5Nddcc80111xzzTXXXG2lZNauMMQEZSBUaBa7QIoREctITwo0U5psSA3gucoaxDlVyI1jVTAJKefKoDzOe1IsDNsBROi6gLPv1jEC+v3Yi5BrLqB+r1bwRrXhjKmQs+6j5KLnVlV2zvuaT+mqfW2uJ1oXi6aMq/mI5DLZQWaK2nWCXif6g9qa6jYlZ7qun85JXIViJU/Zixmzv3WAKtlEoKSRkhL4jkIhhG5SdtX0TxyOIqKQRhxjUrWhuqBGTh7e4+GDu3rOEhTeJFV9LhY94zCSXMQLhL7XRZrjQEqR60cLnr32PCkOiA8gwjAMBO+Q5XJSmhrABSF0Xc16jGqli7DZbnXeIlByxgUdCzkltWstBRfCZCE8jENtTFtAqbmn3ju9Nh8oKBzOBVXKjSPSBbxzdH1PHAZtKwOoucLpolmXwXnEuQn+mup1rNavIqqoFTJegOAIdJQCXdezj5BKYYwJ7xzLxVLnzqU+yxFRa1cfVJ2YMylnhpjxLhCCJ7hqRew6OgqMkeVBj+u2KOh1xLGOGVdthissFVedhpy2cWpUf1T1cXe4Ym/RsbdacnT1Gvfv3+fR40fcv/eAlCJpGBFfnYlQ5aGr+5PaJqUYaC518W4ipkiuat9+seLg4IDNZ7f58NO7xJwVzC86jg4PCA5SjOzlUz7+5f/B5uN3uHzlGqvDS/SLPVZ7B1x56llSCfj+EeuTh5r5mWK1Z9VzMZ5IUSBbcATtFlxdgNCHjq7ryWXUz6mUKNViOpVS71OH89Sfbb8VPIqAA18SsahdtBSh1BtcpGA21uCrlfEXL+Sf68uXaKbm//pf2bZoJMlcc80111xz/b+qvvTTdXtwbwBiFw7BmZKyVSy16jGDHpYFZ0DSrB5b+GYgKefM0dERX/va1/De87Of/Yzbt29PYMiqhR3tPi4Cik9SGbb/b/d5kZpxF2juvra7D9vuIpXjb4OVu2B19zhPOr8n7c/KlJEG8gwQGgAyCHTRebfjAXR8fPbZZ2w2m89dj3OOa9eu0ff91Hd937NcLnnmmWe4efMmXddx79497t27N40FU+/ZccaaJXIRfGzbqlXetarHXQtbU/W1mYzt9nCmLG0BZpvruJuLaW2Rc+batWvknPn5z3/OpUuX+Ku/+itef/11Hj16xPvvv39uTFh79n3PU089xbVr1zg9PZ2OMY4jXddNqsw333yTq1evTrC47SN7T3u/tVmRbR5nCxljtdBpFZcG7+w9bc5km1/aKi5boNzex7Y/e709j1Yx29qy7v5rz7uFogaP25xMawOrXXBrf2uhaWs/a/uwcWDn3/f9DCrnmmuuueaaa6655rqwnCkis8KQEBxZHDllUkyQ1ba15EwIHicOqd89XSl4BB98/V3hTS4goVdw6HyTRYlCzAoKxev+zhxnpH53FmLWXLpSqp0oCjmC9yRStULVxYt4wfmunvNIiQkhICGoqhMgJ1yFTaDgSrPqhCCOQl0gmCKx1O/bVSVafFdhaKZIIcUBg3jkQiJXKHqm0AS1ymVSWoLzPdI5StF2lZzofCBSyDHhnNrC5gLeB/AF5/pqm6rzu81Y6rF1HuzwlOIVNBWhiAJDnKMM29q+1SZ1HClx1HMRR4wKEEMILEKoAFgtO3PKhNDhvGMsVU1bFEwKYuI4CjpW2rlm8IGcIoP6stqGqKKRmhspQARRuKfWrZ5hVCvfmBIZ6IPHpYGUBmqwYHWAzWe7LpByIlRl62TrKaWZA+qGGUeRjBTNUe0WC5zz09wrpUjB4Z1j33u2262qiaWoSldkUpKG4FktPTnDdjswZgX1ITi6fqFqyQJ7q9Wk/sw1f5O6D4PfIpabqiDRi1oMp5Krhaq20bJzPHP1MgfLjjsH+3z44YeMg85jT9drTk9PKFURjDi88xTReaQXoeSax0j1RBX957wn9CuuHR3y8du/4uPPPtPF4NuB7ZhYhYCXwtGy47IXehInDx9y8vAhn3x0m8VyycHhJVZ7+4Su49LBir1lx8ki8PDBfbbrU0ouBBGKU4WrUCj1uvWe1P4TXQ1BHteM44aYR7bbDcMw1uch2u9JdFyLmLDajHq1H/wk2PTg8nQ/O+/xPuhiBRw5q5KWCkF/l1VKeYfp7vmfv/4vXs83gf/tv7jt//5lzmeuueaaa665fpf1fwuobKFB+5Dfvoy2KqvdvDpTUwHngIHVrgWpKa6Ojo741re+NSnWbt++fc5idBcqtvuw160uUjxeBC1337+rWmzB0EX7vej19lgXgcp2+yfB0F3V5O5xLrru3df7vmdvb28CLi3gMhvXyT6lAYamTGtrf3+fhw8f8uGHH07Zim31fc/BwQEiwsOHD4kxsre3x5UrV3j55Zd54YUXePDgAY8ePZrec5EFqAEqYFL4tdUqTXftOVsQ1SoQDTwZqNsFe3Z8U/CZ0rRVI9q52TYxRrbbLXt7e+zv73Pnzh3+5V/+hb7v+dM//VP+5E/+hH/+53/m3r170zGt7Z1zPP/889y9e5fbt29P57FerwHouo6HDx/y4MEDnn766QnWGZCzaz49PZ2ur4WJBmZtv2324u6/dsy0AHD3frd22e2XFgwa/G3bCpgAeXvu7X1sgFDq6mRrJ2s3A6HW5m0WJjCpJk1F2drX2v7acdOev+3TxrABSuvzueaaa6655pprrrnm+lyVam1ZnzUPQ120hyry8J5UNIcSCsOwJQRPGhNjTjgfcSOICwTva15jo1gsGe8FCR0pqnKrlIIXtZxNxaRjZbIwHaNmX+reVDGpqjNAqtVnSfisisngPS44vIPsBClVDllQ8Fo0MzKmhKRELtAFrxCHQiGTk6oiRcCL2tqa9auTQiZDzdBDLFNe7SR9CKpKLTUrz1VVofPVNrTQdz3Xrj1NLIUH9+8ybjcTRFSlYpjAZvB1IXXJqorLhVRU8eWdU7AGkCPedyBONYpy1p/67EKInLm3mBWsOA91/iziIBdcUsQjpdAHT3J6HWrjKmqxmku1oRW8aPajvj0rBC4FciZRIOux8jQnU6WmdosjpUxBlbZDipSiizZzVWaGTudr22FgO9T5NjJlntp4cXXeBwrBc5Zqo6vKTe9U+ZpTqZa8el4K6eq8k4yI12vwakFcYmQRFqwWPeMwsBm2CsPETdmHpSK/0HVkVJ2sY1xBcyngnZkCU31yVR2L6JhUoam2ZcwFl2Md59WdSoSSEjGr+s+q857rVy9z6WCPp68/5O69Bxzf/QwH+K5ns90wbDaknCaFbFQ0qPPJnPGhxzlVDO/v7zGcPOTTd3/N7U/ucDpuCeIpIvqcYG/BXoCjkOgqDsxVoTiWyDg+5uTRY8QL3nlCp/dXjontMGh+JQWkI/iOLtQF10osVRGZC3HcEscBJ8IpNT9ykjiXqT3VqjqQnd6rej9qrq1+rNWcUAoSPEvvcD7Qdx3dck/Pr/ZRKYlxGNmu1a53rt9NlVL+B/A//h8+jbnmmmuuueb60vWlQaWBhV3l065FJDBBkRaQ2N9btddyuTy3UtAASqvUay1hQwh89atfxWwa33///XOqP6tdcLcL8FrIt/v6rkrzSe/b3ceTgOXu+5+kdNw95u62FylGW4C3a7nb7uMi+Hn16lWuX79O13VTzqABp8Vi8TnVIDBBIJm+uJ63Lv3oo4/YbDbnXhcRrly5QgiB9Xo9KeW89zz99NO8+uqrHBwc8J//+Z/EGLl27do5KGbHtdW9dq7DMLBcLgE+B1Xbam0/W8VkKWUCrrvtafuxsbcLQOFMYdjaptoxYoysVqtpLB8eHvLJJ5/wox/9iBACf/Znf8Z3vvMdfvrTn3Lv3r3peGYrWkrhmWee4fDwkOPj43PKQ2vHt99+m6effpoXXnhh6iuDzAZbh2GY7k9TjFpb2j1oOZIG+1arFQDb7Xa6r+zet7Fh19yqJFtIa+e6CwFtfO6qNS3bMsY4ZW62/2wbg5Nd101t3/ZZaxds/WZt16q92+szNXdrFWvKUVDgm3Nmb29vakv7zJlrrrnmmmuuueaaa67dWm90gaEAcRxQF9LEam+PBJQcKUUoORG3Cd/1xFgz50StLCmFrneM+UwpNm4Hzb/0gRSFXDJxHCuEOYuxcKIwMJeq7qp2njoXGslZgZ/O5ZMqMrOqLEvwuOzIccBHr+pNUcvLItWqNiu4K9ly7c7mSymNCkJLJlVw5UpBjVQjY7Q5vsLBnBOufof33hY0F0gFRKGTA8R7pIJYyXoepcDx/XtqgyvULFBVkyVbLC2e4tTitpSMFIj5fJSNcwIpTfaw5DTBJ0HIKVJSBm+wTnBetA/J5FLwMJ1DKeCbcD5x2h5CURfSIkg9bp7aUkFySUlhqesmpSGuqLKwZEqmqgKhJAWL3mvOpYuRIY4Er4rEghDE03UekDruCuICKY2I86QMrloBu1CtOjUIlZSzWqmKI48jsSYgjqgDb679q/1eYWVxIAp0XQE8iOtU/egcMY50ovajBc49/3ESGONYQXMheAd44hAVzuYR74NajYotBMhqjZwilFwXCKjqeIwRcMQK8YO37MoMLtBX1eg4RnKGvg90ZPrOs1p0XL96xJ0rR3z06WeMmw0nx5FNd8BiucdmfcKYdG6+3awJXQ9SCGHB5f0V9z/9mPjgDu+88y6PtwNSCl48rus56BwHneOZA8e+LwRRoHqWGpunhQEiBUZhJCPDqNpWUVgtKoNFnNq7iu/woVPldBFVNRZVGedciFLHj+i+g1P1JM5NCmsJTjNTDVAWvW+GIROrMtmFQB8C/aKn63q6bkG/WOg9US2jSylISbow4Lc8/5prrrnmmmuuuf7/W18aVG42m3OWhwYmdq1f28w4gwD2GnDOahPOwKApLs3K0sBkm2OXc2axWPDaa69xeHjIL3/5S37605+yXq8vhIBfBAVb6PQkpWQLAndB4e57v+g4u9s96bx2j/fbruGi9+/+bGBo9/jPPvssN27cmLIM7Zpa69cW3tg/s0A12GSQZ7PZTArB9jq6ruOll14ipcSdO3fO5T8+//zz02sG5BaLxbk+N7jU9odB1eVyiYhmY56enk4Q1MCUXY8peVt1qG3TttdyuTynxmtzOlsQbCDVYJ/3foJ1rfLTtg0hcHh4iIjw4x//mGEY+P73v883vvENfvKTn3B8fHwu7zGEwAsvvMDrr7/OT37yk0lNaXa8IsJ7773HzZs3uXnz5qRKbMelKUXNqtUAr/V/q4xufzc1rbV/25YGUVuFaQsCW0Bpx7H72V6zXE9rs1143Farbt3NpV0sFueAYdd15z4/DGy2eZMtuFyv1+SczymE22uy8W1qWwO/7TXPNddcc80111xzzTXXbg3DQCETx0SKEeeE4APbzYYiG0pJVZnY4bxnGAcFh6LKvHJOySSqOHx4jN9bkWVBcYVcssKHGAlB7SgrsayKxvp9PKf6PbjOD8XhJVNKjXPJqo5ySiQoRRjrd/u+K3SdIgwRzf+LtlDQef27c5MSL+U05fZRIHQdoVtUC9WEM4tY51VpCRMwNViSiyjIqwo1IZ9tUxTSOQ9OPM4JY04KMzOqgix5giWtIiyXOiemuuVYVqd1mq9QiHoMEc13pIApLqvVqEJHBc1qvVpIKU8gDOc0x7HmahpQKgXSGFU16hT25GrHGrolw3ZgSIkiXqHbECc1W84KW3OOOB9Y9p3mC9rpi4B3eL9ABErwtV/kbB6H5qPmqqZNMapKtziFZClqvqNzOKcav5wy1ckY8jSqGFNV5lGmXMRxjJo96pxmjjqH4OpcSudhQ0wMMbJcLHFex4FDKmC0dioMgypCNW/RnonU7Mmqup2eFYhHuk7tb4uqPQuiMLQUYkyU4lBGXjNT61j0DpZdoIgwjJFhrM+BSmHReV74ylNcv3bEo5M1H318h/c++ICT+3c4ffSQ5cEl9rol6/UjVv0R68fHHJ+ueZBGPr13n02dt4tAzIXVcsH1wz32JOJLok+RIoIuj9WxqHpnMVGkPssRVeVSpOZRno3cUoA0MqSEyFB7R2GkJsPWPNhAXbxQs0itYZHJQjiV2jZmX1s011JhekJQ4Cslk2PU8y4FR2YsI8FXe+uUiKlaysZ41rdzzTXXXHPNNddcO/WlQWXf9xN82VVVtkolOFMUtuChzYoz9ZQpyOy19uF/q+SyY7VKuOeee47VasVqteKtt97io48+OqfG2q3/KjBsIcuuSnL3+i46TgsI7b27qrLdbb/o2O172mtr4erucS86z10F5tWrV3n++edZLBbn1Gb2u4Ek63cDlNYHrfJQJxPDBH/acwsh8NJLL/H48WPeeuutSfV36dIlbty4wfXr17lz586Ue2hjy/a9ayNqr7XXZTaeLVw1laWBwnYs7YLQVjVqoNTatQV1NibbPFXbt0E9A42t4hCY4OMwDPzsZz8jhMCf//mf88Ybb3Dr1i2Oj48npWDOmevXr3Pz5k1+/etfT3a64ziy2WxYrVacnJzw4Ycfcu/ePa5cuaJZH814aYGr2Za2qkRrtzafslV0tm1l4K5t84uslVsFbKsutXvA2sHGkfVD13XT54Blj5qisYWidmzLVvXes16vJ3ht555Smra3MdneW60C1/rYoKidf2upa/eF9b0B47nmmmuuueaaa6655tqt4DS3L0k6i2FwTiFUSYg4CkLaDDiPqqBiVFvHvEWk4LsFY/2OinPky0dkEVUPDhEqrBEfGMeByIBPmu/oJFOc08w4EYRc7T8zJSe8E3BqjemcgpQQHKVYGmHNnUeBm3euZhQmUqmOK6LqKQARpzauGLwC5z0lRSQEuuAopVrC5kLXBWJKip3c2XzZVGLT3DMOCms6KGOqSjKgwpxS6pzQKS7Tczz/vT+XpBmgyvEqkyk4cWf2qzHivUNElXmCUOq8RDP3FPmopehkOlphsFR71WpjaxmS6vlagbLalSoEFFLKSEnkrCpGj8LeRR8I3cEEd7bbgRyTKtzQ+U5Mmm1aLPdvAsNlgq4C+BCIY6QUFN6lMgE+hVc9qYzEOII4+m6BqWC7AD4InTj80mI01OYXcxUqmeBdHQOi1rQVrGs0oYIt6TweHXsxJYXJObPebNjb26PvF6oKtpxJFQxqH5bawhV0isCYIkHCmTqyAe7Bq4NQygqFweHcGQB1zpPiqFC83pM5q8JWFY9CX5WuIjCOGe/U/njZH3C4t+ClF5/j3sNHvPf++7z7znt89NHbnDx+SEq3CMExDknvpy6w7HtEMgvfswrCwhV61rhSKAUFp7mC7GrZ6+wZUM2VTFmhq+aNNqOuckap95yTM2Bsf6PekymZlWvt/5oNaj+XXFQIiwF5HSOFCilrXqw79xwtqlX1uOX05MzWmVI09lRQlXgxXfFcc80111xzzTXX5+tLg0qzsmzLHuC3KrrW0tG2MWVZC9p2oaLBrhaCARdCEgMR165d4/d+7/fY29vj0qVLfPLJJ9y/f/8c3LqodiHfLnS8SEVp13LRvr5I9fgkcGnVvnf3fFqwuLu/i85799x392V/67qO/f199vb2pve1uYPApJ5dLBbnIJepFtv3jOPI8fHx59rdoNIrr7zCer3mnXfeoZTC3t4eL774Iq+88gp93/PJJ5+cU/ztgiWDqG0eqZ2PwTH7m4EtU0220LFViJqy00Cc/d3e07Zjaw3Udd2kBrZrNdWqqR3N0rhVKo7jyHK55NVXX+Xtt9/mRz/6EavVim9/+9vcuHGD3/zmN5ycnJwDpk8//TRPP/00Jycnk2qyvcYPPviAW7du8Ud/9EfAeahqQM3AvkG9zWbzOZjaQkYDeLvWyy04NMtnu+4W5LaQs1WXtmPPOccwDNMYahWppp5s+3xXVW390Lav9YupJJ9071lfXHSPtUDUPsfsM2lvb29S3LaWunPNNddcc80111xzzdWWExhjgpzwXSB0PTEmnHeMQ6RkdQ5KKn2ipIyI5hWWDCF4oH4fn77Dqr1pmbL8UKvQrJ9dFrcAACAASURBVMqzgrB5/BAv0PU9IpovaJAuhE7nEuNAcQ5xnkXfq/KqVPBX9VwhOErW798Zmx+o6s05DxV6Uq1OxZSSQHYKSFS1J000RSCmTBH9rp9TQrwjp4pE8ghItRTV3M1cqtWsyejQTEbvBe+DQpyimX5eqo2qzesmNxzIUmp+IwoLRfABSlFoaP93Aimr/WooniIeyUDND9T91ecUojSmpDTZ0GZsXiFIqVmViPZtKZQKRH1QgGw5pt57zfErhc4HpJqA6qLPhBRzeumIUefe4zAqtDVw7ITQ9dM8KnhV6MZqtZtyxvkATvCSEd/R9Zq7qONPJninSkjLsEzg6qJnFH055xFtQGLN0uyqIs/UsKY0JY4UlbvivS1wV9VsHEf6xULBvaiKT+piUefLBBSdc+SUSLngvdRYyjrGxLBxXeiM4TnNIs0x4sRVu1OFiLlkPG6Ck84LBV08kPOIF2HZdzhiBeOadbroPYu+Y2/Rcf3oEt/42te4++ABt29/zPvvv8+nn3zEOD6APLKicNh3BKc2wF6K9msRNDVVEO/0mjFlY5lsk/WSyoTIC2cgmqJJpBrf6iZb41TvY+f02lJ7XxeD+aWyxIJU+9wiqmZ2om0LTv9zgdD7Og8HxOniAikUUcWxgmRXbXd1wYMqUiGWTEozppxrrrnmmmuuuZ5cXxpUGrgwkGDWm/Zg374UtxaWu4q11h7TgIUBHjhTgRmIMXjZ2oWKyLR9KYXVasXXv/51XnvtNd555x1+8YtfcPfuXR4/fjzZTcKTlZS7sPSi/7fvu0ixuQs5L/r5ot/b/V50rBZEXgRDv+jcL7pO+/3y5cscHBxM/WZwytrbwFGrPmutXttc0r7v+eyzz3jvvfc+B29KKSwWC27cuMGtW7f48MMPEdHMyjfffJPr169zcnLC8fExq9WKrusmq862dseSKdq89xwcHLC/v4+IWsA+ePCAzWYzqRANWrYQDBTqtdmK1o6mTNxV8e1a2lpb2n3RQs3tdjuB+d3/Hxwc8PLLL5NS4gc/+AFd1/Gtb32LGzdu8POf/3yCnZYXefPmTe7evcvdu3en/Zv69O7du7zzzjv8wR/8wQRX7XwM6prycMr+qJDROcdqtTrXrlameLTzNtWoPWgQEbbb7QQcx3Gk67oJ0LYAsM2NtNcsB9MsZnPObLfbc2N0sVhM17GbPWrX5r1nf3//HJy1frLPIAOYppa0z5t2YYTBR4OmBkn39/cnKNmqZu3Yc80111xzzTXXXHPNtVsuLOl9ZgBKyox5U9WCDucdvn4/10hKVXpNC0FFqrIKinjNQIyRnOOk43MATqM6ShpxoWYN1n2O44iUQuh7MhkfArkUYkqkrMq24PS7eY4j3XKJ912FOYUcM5pRFwg+UOQsA16KnxRb+t1dc++cLVoWwbIkjazkPKEZBXKGWbMCLFWEGbBTiFlKxntHmCw9FSSKDxRyhTkeoSoiF0u1pnRCiolMpuRc21EBTNctQTwpbtCwPYVuZvWq5+EgqCqw6zoykMax9pM7O28p+GrxGlOuz0C82sFKYUy59pP2Z98FVbSimZteZLKPTUVlhOL0/ZILLgS6ZUfKmRR1nuJEFHgWEOfpREi5ZpPmTCfQd92kLE2xLkQtOmpCQdWkzhFcpqRC7x1jqQs/vWaGFtAs1TqWQvCqkC1F1aHeK4SsQDSlTMw6vqesw3oOuQiujnFTl6r9aAYRgsEu53BketeBUO2CdZxIvXayZoxCm6NZwOkxoFFiFlRKWMe0c1VRXBRu5pxrv0lVJ2ZKSToO6nh1lu9qi1glqPWv1+zTZRdYhas899Q1/pc/+D1O1hs+u3/MnU/v8OntDxhPHtDFNWJjvpyNeRc8vtoZmxRSbV3rGBEUhlMqHFTkmFKZrHAnHXHdzxmUzCi+hCL2foBczXMVvUtV8npbQ2/POfJIHCvod64qgT2I4IOn80GzQkMHUpWt1dpXfJiiUxBhiJmuLiKea6655pprrrnm2q0vDSoNbphqyywRdyFHq0azai0h7fVdJZWBD1NjGpBp7TRt/33fnwMaBiWuXr3KSy+9xLvvvssvf/lLPvzwwyfmV7ZqK/i81au9Zn+7SN3Yvv+in79Iafkk8Lj73l2F2pP202530c+2jXOOp59+mqOjI4DJgrNVLk4WRfX9raWqQctWwfbpp5/ywQcfTHCrvZ7VasWVK1eIMU5ZjFevXuXVV19FRKY+stzS9hgGiHazUG0MXb16lT/8wz+cjnPnzh3+7d/+jZwzDx48mOw6d9Ws7d8MahkEbP9m17C3t3fh2LD9GLyy/dgx2mzN1m51sVjw4osvknPmhz/8ISEEvv3tb7Pdbnn77bfZbreklOj7nldffZVf//rXPHjwYLr3NtUqx9r07t27XL58eVLBtuDOQKAd11SCbTvYPWfZsC2Utn2YBbApaK19rI2Bzyki27xHu4+tHQx4WrXAvB1bwKTktb7w3rPZbCilTOfVjnezj22BpoFGU1+2+arWly3sNTvhdiGGLZBo1b1zzTXXXHPNNddcc83V1jCOxDgQhy0iTkFPfXDficc7wTIinQsEAQm9gpyUSXkkl0xwakVaSmHc6v6cqL7KBV+tGh2bzaggL/gpb867CifETapEhVeRkhPZebanp6RxpDs5YbXoObjyFHGMVVFXakZjZBhH0qh2s2YDK6IKP3u8EFOsujBT5glOnNqYxhHf9YCQqnLQOSFlatZl0fzDqg4MPqAXogAx9EHBqagqL6Uz0KXgTPDVxjbjKd5VODeqWkwclETXdxQcY3KQoe8ULg5DnvImlXfV/kkj4gI++AlSqurNI1Vx5jsh9HWOkyNjSqRRF1pnERZ0iPMMW10gGTpPShDjONlsegciev0pqVLQZbV87YLDuwVCBdC+Y1WtgrU9AjnqXH25XFBKYhyjQi/vVUmbMjEmIFWQ5Uhj1txBKaqsLWfOOgrOzeGoMIyJrugzm1KVkk4gO80kdMGTowJYMWgmZ/Aqp6iKvWo3bFatKVfI69TClaoYFudI4ioEr9a2IgQR1bYWhXG51OcbOrhVpWttKmofLK7Gt7iqmCxqk1oQEKcxjE4gJ8aYSSlXy2SdywowxHS2cFYE73Id56FCT53/7y07rh7uc/PF54h/+A026w2PHz/i+N6nPHpwn4f37rA9fYzLEaeaSJ27FlWTmlLSFT2/ZPmrFbaKSIWUqhsttb2o2xTAV7iZsv3NDIrrMyOxxRDN4uvChC8VDHs6J2pnbPgzxqqu1ntK20OtjHF1gTfVpnrc4Hyg6zt8gbRNv8NP27nmmmuuueaa63/m+m+DyhZgGDxoFWMGWezhf9/3kx1jC6KsWkWXKZZae0ar3Tw9EZlsSa2WyyXPP/88Tz31FK+99ho//vGP+fnPf86jR4+mbS5SIO4CyV3l5O7ru/tqr6P9e2t52W63+/NFqskvAp0XAciLtr1oGwO6fd9zcnIyAaX1es0wDPR9z2q1mmBTq64zkGXXZv1469Yt7ty5M/1usKfrOg4PD3HOsV6vOT09ZX9/nxdeeIGXX36Z4+NjfvGLX/D48eNzajY7jl2nKSL39/cBJjXv3t4eN27cOAfOPvvss2mMWd6kWQDt5m22tqJmb2vb7kIzA1e2Hxur7d8tO9HOxfbXAtA2C/LZZ5/l3Xff5Qc/+AHr9Zq/+Iu/AOBXv/oV6/Wa5XLJ5cuXeeaZZ/j00085Pj4+B/26ruP+/fv89Kc/5Vvf+hZHR0fnxqrdpwbubIHB3t7elAu5C+ra+8IAn6lqTeVo19LaOtvYal+3drAx06pQ7ZjWD9av7UKH9v5rszJtny2QtH/WPuv1mhgjBwcH0+dFO5bsc8n2Z+1QSmG73bLZbKbPmPYzpwX5c80111xzzTXXXHPNtVs5jeSowC94j+8WjZWmqgL1O6gCsuI9TlQp6YInxcwYB7brgVIygiflRK7fmZ1TtaUgxKzQJgSFecSR4IXQdeACpKwqyphYrzeIDwqRnKeUEdcvGFPGF2HYbkk54bKnSMHnVO1nUaiTdBGxoHaZQkF6m3vkap+q35F98JNKMFXw5kPAF130KAaKUrW0FVPWaZZeqXazMSsw9d7Rdf1kbYnzWCZkTpFUEviA8wt8X1VxWTRHEQVqw+YU5z196LTdUyQsPF2/YBw3SFG1n6sKx4IgOVGkEEeFLV3XsbfS+BRxjlBtU3NKFKd2puIC3gVcVf65Eok2f0qCeAVMKUVVSVJUDYuCV80GTAQcUjxedF5Z4kjfdWqPmrXdggjRlKGlEEfNBZSquCPHCqkSJdXcQVEyJRXmlRLPbFNLocRR7YGlZoBKIaZIjINaCTsHOAXETueBvtP8VG0Yy0OsLjTWlhUwFnNrKnodVKheqvrSO49DLY7HEieYhkjNcBRcsecbNidTiJeT5nI6p+plVSLa60JwjkJCcOcWsmaBHCwvslQw7yhkVcoW3YcPgi91IXDOgMNJtSfOqY5loXOOZbfP0eEeLz73DEJhGCPr9QmPHjzg+N5dHt7/jPWjR2zWp6S0Rao1rWavehAFormUuv6g4IpQ6t9NjWmKZBGZ2kmkkPUt2v+l6AKE+njISX2mZH1ef9aeVdUpRer9XNXHpUDxFFDlc4kTWPa2HY4QNP/1VI/ETnrUXHPNNddcc80111T/LVBpcAOYgIBBnb7vz9m5tuqkVq1m1WZPDsMwgYFWAWb7NjtZUGtOUza1GYVtVt3+/j6Hh4e89dZb0xdQ+LyKEi6GfLtqqYuApb139+8t4NwFn219kdryovN6EozcrYugZ/u7956joyO89xMgzDlzcnLCOI4sFoup/a1/TVG22WzO2cQacHr8+DGnp6fnADQoOL5+/TqPHj3i/v37pJTY29vj5s2b7O3tce/ePVJKrFaryc7VAKDZm9q59H1/zg50sVhMQNVsQw2m2vVaP7ZWsgbUTQVox7N9mmIxpTSNZ2uLNsvSLETbrMsW9rUKvNYmtB1bR0dHOOe4desWP/rRjzg6OuLNN9+clJWmKH3llVf4+OOPefz48TnFoCkL3333XV5//fXJztf+2f1htqzr9XoaH9be1gbtvdv2gV2L3e8GaVvwDZwD2HbfW7tatW3bKmfb+6vtF9uP2QHb2DN4arbQ7X1nKk6Dx3burfWt7dOutR3P7Zix8WfAtj3HNqd0rrnmmmuuueaaa665rFIcVcdUVDFJTmyHLZRC7z3ZCTmOiDjG7aCMI46EfgkC22Fb899UlbhYrdS61Rbo+Y6UE2T9rq82nFlzCZcL+qwQkNBRgqqsHh4/oOsD/WKpKqgCwYeq1sqTtSdA6AJDPFusmnPCuYLzQZWbvi4+Ljo3N6tO12S9S/GUqCAu+KCgJ6tqznmn9rNe4UYu1X6TjCRVWeaS8UUXSIvvoGZkSo4E5xHn2A4JUqRQiAkoCV+2iuXSWKEWpDxWG1JH5zydF7KrKlcE56DzauupGrqCuIUqUFNSTuMV8jgfVJ1XsvZhbQ8JHoqj6xf4NADCOA6kYja5QNF2yqnOkczat0Aoag2qKkDqXEUdh5yoq9VmTMio1+WcJyMk2QJUoJWafjN7UJRsS1Un5kysSj7vhBA6HHWB7QS8FEp5p+A4ZbVSzRnGnAgBFr3a0uac8N7pOHd2DAO9NcMUJqgmzhEWKzoRSo5qa0uvp1jhZEoK/gSZbEtzydOcD6lzanFV4arKTy86zmJKattaYVtunqOklCqkq4JjmLIclyEQK+yLoOrYZPanUtWINTMyO1xOxKjHE1OKVtUtojauuWRyTDgvrBaB/cVlrl2+RHrxBcYxEcfIyekJD+7f4/Gjh6wfP+D00UPGzVo/R7KqXjUsUzMtnQTsyVKpEFNZbo0OqudgalKVfcKUc1sfExVEla11LDgRagplbWtqWwu5Wsvq/WKDuVRIWY/rNCtVRLdPOdcM09/Fp+xcc80111xzzfX/hfrST9dbtZgBEHuob1CihSQG6Ez5ZFCktZoE/VK82WymzMFWlWVwYjcnz8CCvXcXHrZ2sga/ngTw7JwMirTQ5L+iUtwFlLsQ9KL37p5P++9JEPVJ570LYZ+0je17tVpx7do1Dg4OzrXlLsCz322/m83mHIwDBZE2gbX/2/Y5Z/b393nxxRe5d+/elLF45coV3njjDTabDcMw8NRTT00Aa71eT+PMxpPBz+VySd/307hbLpfnlJt23PY8WmAHZwpHg3IGp6wNl8vlufHQ7rMFXS14DyFMAN+O1YI1A6wtmGv39cwzz1BK4datW/z93/89fd/z0ksvAfCb3/yGYRi4fv06V69e5f3335+Ou16v2d/fp5TCvXv3+Pjjjzk6OppUpK2SEs4sWu1vrf2rtY0pR+382/HYwkVrG/ub3eemNrX92T7hTIFrlq279/mUe9MAR9uP5WBau3ddN0Fz++yxY5lq1j4vWqUlnNnT2jFbG+tWEWz7MEWttYHdG+1n2FxzzTXXXHPNNddcc1mlOCq8cgrkKDqvGVNCxOFjJMWMD+BChxOHz4UYR0rJULJCJB/wNicrha5f0HWBUgTJQkmw9IEN4EOH73tEFLzkUvApksYBcY7lQhcb5pRxRXDe0Yeg9o5FMwB98JSk6kDvhJIUbEGFICmq8lM087LkjFT7TxHwAlkgpajg0qnDSi6Z7XpD8I7F3h6CKvHUc1KVmsXmfUXVl855KOaGAq5US9BcHZiyqlGdoPmaiKrp0JxLcqaQiamQciaEflK4OqdglAKlfr9XKKx5oL7TbfEOV3MnHQpfvHfkkojDlmG7xjmh75c453XOWbL2cQiMKeFLphS1dx2GLQkh9D0iHi/CGEdIUHJH13d0oWfYrBljItCBaEYlFPo+1IW5kWE0t6uqaAuBXGC5UjAuzpGrbWqpkGkYBhJlUkrGmElpO9kSI1LfA12wxeMVvongJOBCqfMmzfP0XaitpwArS1Z7VjE7UQWwpbIt7wPeO8iJhDBuI4M9zwBC19f5oKojNQ+0LnydFpiqXauAnpcLajXsvapiq4a05ExMkRSjwsgMY1TLWwd0pSM4N9n9IoVeNH/TOY8PnuCzwmZTgdZHLll0EUHwaoec4kguaikcc6xK05qzWQo5FTIRFxQySsn0vWfRe/b2ep566io5RcZR/603G30+cnrKwwd32ZycUOJIHtakcUusdr8gFSiW6vQsFd5CypqjKsU6w2ygBYqbrHZxej1ebF+6rdT7XopUW9+zHNqiEksznq3WvmoFq89XtG88qtyda6655pprrrnmuqi+NKhcrVZTMLbZJ9q/xWIxARrLtLtIxWhgwGwlTQFnEMIsJFvAtGvF2aqbgEkx2do/tvs2SGXbGMCxv7dAahf2PcmSdfd9u5DRtm9hTLud1e5+v0g1uQvPnnTs3WohaN/3XL16laeeeopr166dg4HWN227Wn8Mw8BisficyvXSpUvcvn2b9Xr9OdtXA5U3btzg/v37fPbZZywWC77yla/w3HPP8fHHH3N8fMxisWC9XuO9Z7Vasbe3x6VLl6b+bxVvpqCz/rdxY9DSfm/HpvVDOx7tGux3U4sajN1VDhu4MghqY93aoT1HA32bzYblcjnZmxp8s3buum46j6OjI55//nnef/99/vZv/5a/+Zu/4cUXX+T09JR33313auvDw8NJhToMw9RWq9VqgvJ2L1r+q533er0+Z40qIp9TR7bQzhYULBaLc4sMTF3ajg2758xS1+Cj1UUWtPa3VrXZqjgNDu6qV21/BixbYBhCmDIsrX9bq99dKGrjHqDv+2nMt3awbduYirW9trnmmmuuueaaa6655mpL4V+q2XlVNZgzndO8ShGgCwTvJjATx5E4WqZlAATng8IXQFCVWc4JJ47OewhBoWZwdKEjl0JOkZhGggukFGsGoCrP+q6r0KegeXQZ+03ICkM7X/MDCzmqWk68KgjFhWr/OapVpMHCaW6mc4xU5XclR5bLJUOGzemGZR/AaXah956SHSIVtpgKrKjyS/95RNQKtwgK+YJeV4oRyQnXLXBFcw4tWzN4r9vXBa4BzcwsFeBi+ZBO8zZLipMlJq7OQXJdlJ1iBbsKccbthqFkxkGVjCF02ndpS0rqPuOdp5REcI44RoVFopmWoGDLe0ccBlUAxkgeI3G7pl90k6LNOV/tcKvDz2ZN3y9YrZaaQ5nr/NYpJOzMmSorVDZFZdf3apNbAt1ipbmhOZFzmdSG00Jzl1jW+VWMcYJ+bmpDqVaeBSETnNTrU5vb4By55lh6X7NOUUvRIlDiljHa8wyHCwEKDMM4AbMzeFjAqYoXUSBbctH91P+rArTg6/somnuJOEq1kc3e13zFQugLm82acRxxqfY9alUs7eJz5/ClUJweq+9DfTZlisSs51cBrDhHECHFBKL3ZYpRFxWQoQjbMRJTwitRrGOuQr2idq5dCHQhsL+/h+BxXSDFkXFQhe12u2V9esp6faJxJacnxPUp43ZNHLeajxojpSRKylPOZCEjBVKpqsjp2ZE9U2L6vQquFXJniCVPtrF67rZYXlXVnVc74FLUolfEkanPwnLWz4O55pprrrnmmmuuC+pLg8pWNWfqsdbiVUQmFROcQTqzaDSg0wIEgxum3jPFnEGJ9ktzayVpfzfw2P7fwEKrkjKI55ybMhPv3bs3AQeDFe21wOetXX+bgrE9zkUqyVZt2O5310bTjt1ace4ep4Wararzou1sf33f8+yzz7Jarc693kLb3f3bvxACq9Vqsum1jNJbt27x0Ucffe76nXMcHR1x48YN/umf/ok7d+5w9epVbt68iYhwfHzMo0eP6PuezWYzvT/GyOPHj8+B6TZTspQyAWgDk3Y+Bq5MVWvjzyxSW+VoCwtNtZdzZm9v75wK08aPwTSDmTYet9stlt9oasJWxWvWtNb+NrZ3bXKPjo7IOfP+++/zd3/3d/zlX/4l3/jGN8g5c/v2bZ599lnu3bvHo0ePpjGxv7/PH//xH/Pd736X5XLJgwcP1H4JePjw4aSibMeFtYu1UWtRu9v/do12zm3b2f1p7WtAs1Wr2iKEi7I729xTuw9MCW2g1bIkQwhst9tJtWn3iZ2L3fu2b+urFnDa362/23vR+mm5XLJYLKaxbeAU1NZqu92e6+O55pprrrnmmmuuuebardAvyTkpoHFO1XpOcaBzjpgyTjJ9r24uw3bLdnOKOKHrllCgX/R1bpwZx4FSInlUpVwJHtIZKNCFeQr3cilopqVmFHZ9p/lxXqpCzJNrNmFOiULCydk8Xa07R3zowDtz7NTvzmJ2r5sJTEwOS9XilAorVOkXGGPBBc9i0VMExhjxJVDqd3hQiCdQrVorXHEKaFNKSE5QEhJ6tuOAE1UFZnG4ksmpUKr1bClZr6uUajvrKnBJCkFjpriapyjg6gLHaaGxD6Sc8E7noHGMhDo/KamQyWQE8XoN4zAQzYZUfJ2beLWRdRA10Y8ggX61QLzHidO5Z4qErkOoEEyEMiQKhdAFHIkgCl0RRxaFua5k+s4Tx1EzI72rpEnhWarXIwhFHDlmFl2nqkfvcMtATqUCvaLgMulxBV8teisop87d6nUpYDZXojrmfAXNgHceBLwTvKiSUKQQR4WenQ9q+VuVeTnBMI41G9RRYiZ6CM7hBYJXFa3mWpZqT+vOngU5RaExZ9IwqHqRTMlGEKFyTlWxOlguFmpRiipDhzESCtW2FH0fis+DV3teSlUnkhlTmcie4EDOlJMiBUmZnGNVI+u9Kc7jQ0cR8J3HgSofq2WrqoUzznUEFxAlgjpHDoHlYqWLBeo9krKqs1POxDGS4lg/R9asT9es1yfEcSCOFWYOW+J2w3YYVAldMgV9BnZ2HlCkqFpSTEVZJoW25WIKCtvFVYjtPMGXCrFrnmY222HP+SdUc80111xzzTXXXGf1pUFlGzZuZT+36id7uN/aSrZAwlSZ9qDfAFgL7QwimMKp/d2gAzCBqa7rzsGTNofOAIWdXwiBg4MDnHN89tlnkyIMPg8QW2hp72/31QKT9vX2PV8ENNv3nFvJ2PzNtt+FlU8Cpu257B5ntVrx+uuvs1qtOD09nYDuZGVSLVW7ruPk5OScMs/6whSNzukE68GDB5N6cLVacXBwMKk2v/Od7/DKK6/wwx/+kJOTE1577TW++c1vcv/+fR49enTueg04mUpvu91O52aqSbNmNavgFmjZfk5OTqZzNcjVjjeDd9Z+wzDQdR3Xrl2bxqbt34BuO64tJ9PUhwY51+v1lJXZjpHtdsvDhw8nG1gbt62aEPQBw7Vr1/De8/bbb/MP//AP5Jz5+te/Pt1f9+/f59atWxwcHHDz5k2+973v8b3vfY833niDx48f86//+q/cuXNnAq0GGQ3At0po679WmWhw0fI6W4BuilpTU4YQOD09/ZyKtW0zW7hgoLlVR08rnBtbZ2tPU3+aUrbNKN1ut1NWZqtutHO3Nm8/B+y+tnvCLIsNfMKZxayNM7OObtWTBnlbBfFcc80111xzzTXXXHOdq5zpuh4RVRTlkhQBTQo5BTvjOLDdDtUq1oPz5JLoOp1vnJ6ekONYrVULrlPL0JIL3gcFQlLhQFEYIllwvtq/phGXM0OFMDFGUvAslyskBJJAyWpb6WxhZkkKn4atqqWqUpMCTjLBC2NG7VlDP9mz5gpynHfEUiqcVWtS7xxUJakIUBIlO4Zhixev9rZVOZrR+awX/a2YfWVS5KdBkRUMZlXxSRBta1TRJs7R9T05VScVEVKMVe0FOdccTae2rjknUsp0oauA1QNCzkIRYRgHvHcUEUQ8fQiErme7WTOULc45+k7nnTlFks2/StZryjCWSB86gg9qk0lBfEdOGe8dXb+qKjwFqDlGTrcbteP0geVySfALtXQtBSlq44svuJoJmVIhpTxZ4wqFvl+hgtpC33dqaUvBSa5qwKI2tXDmtiT1+UOM8fadmAAAIABJREFU4BzeBYLTzMGUtB1NnZpjpuCnBaQimS4EpBRiKYzDiIjOC4NX5WWKqapBddxuhqg5paIaX1/0OooDV8wWuC4wrWMgJx1DONVrlmJZlZpJmZIqCZmeszicSxNEXfZVgVx6xAfNex22+G6piwsEhas5UlH9ZKPbPpfR83G6jziC6D1QBFyGnIZJxWxL0l0FzrnaBIOqTbuuU+DpBO9tET5nwN55yAUfegKFnBPBBzrnoO+Rg/3ps6DUezCnxBgHNicnrNdrNsOWHBPjsGXYbsk5klNVbKYEeVQQXRKlzt9DzdvNqej9J6og1axPtZAVqlLcVf2mqPVsqoB5rrnmmmuuueaa66L60qCyBQD2e2vz2eZGDsMwKSwNNBiY2FVkGbRprT0NaNg+WrBhQKu14+z7flJ/GTQxJWerqLRtvPdcuXKF7XbLgwcPzu3byva/a/Xa2ojuwsO2rZ4EDHfVmhfB34v2uwtDd6vNXHzSe7uu48qVK/R9P8GWruumdmvtSIGp39rjtqpEA3qgwPno6IjXX3+dN954g6997Wt885vf5Ctf+Qrf/e53uX37NtevX+ell17irbfemhRsBrcMLLV5k60lrankDJxaX1gftWpYA5Rd153LTAQmxVwL7kydaOMGmNR8BtttTJtdqo1fU1naedo1jOM4ZW22NrTee5bLJfv7+5N9bKtYfOqpp9hut7z33nv84z/+I/v7+zz//PMcHh6yWq3w3vPBBx/w8ssv87WvfY033niDZ599luPj43MgtM1uBCYI20LxVn1s6lBrxzaL1MaFqUmtfQ1q2tgzValB3PbeNCjY7nuxWExA1Mab5VEayLWxZ9dk72+VkF+0sKDNJLV2NuW29Z99zli+pfWTvaf9LMs5fw5gzjXXXHPNNddcc801V1teHGNK5KTwwk9wItL3C1JWdaEu2lNAlquFqaMwDBuKzS0WK6SUatdYEB9UUZhGvNd8PgU3sarCHN45tqMjDVsQ0UxD7yAlzXAkATWOhY5h2Cp48IGS1BY2hI6YYwUsqkKMKSmsEbX1xHtyioi4KcswKL3RvDz7vq5nrvaaVT0mJZNDhbmcxS1Q1IaWei0l15zDAviAzYSFqgCLCd9pe+RS6ABHtZys0NN1i5qrmVC7TYV9Ker1iKjda4lFga8IzoELgUSuoMvhnMdVVWS/WKnirhRyHFkPttA24Z0qOc3+VJyvuZuZOA6kFFn2PaV4xBW1gc1F+6gA3jNU61DvNPfUe6/q15wZYySVjCt+UrFae4k4UlXqMY4w6MLU0C8IThRwIgRXyZIPuOAJsS7+LoU+eMYYphzEnFLtE1cBn0JKvCMncKKZpCKFlJOqT6vCt+8X9MHp7zGRat+NMSqswxZsa9am1NdTTiRhsi7OFTpL1mcUUiA6HQk5qxK36/rJmlRcBYxFoV5MCh2dQNcFteB1Du8DcSiUfgUUxhhrbifgPCVlSvUGVvxXx78TSko1wxSKE1w5M7t1fUeMgkuJVDKpJByaWxu803za/5O9d1mS5LivPo+7xyXvWZe+At24kCZeTTSJ0gtIC22+N9ButrOc1TzC9zjajGkhmbZaiZKZaAQxpASBaACN7q6qrLxnhF9m4X7+5ZmsBsmW2UebGT9mQHdnZUZGuHukVeQvzjkgvY8RszEaViH4CG+BFE/MaGTGqXob3c8h9sMGlRyYOvZkxu/QHLwC6moEExTqpsU0jhYQkPpH0027zkXwH9INxjaOl0uP07HZ2wNC8BGgI85JvJ6GQGHvHbyz0M7BpLVSVFRUVFRUVHSf3hlUAncl4gRHjI4kZNJaH0UsEgIQ4ACQL/4JRwgeCTNOuyNzsEkgNRgMBCLQeRfC3cUNt9V1nWyLohOPzr/D4YD1en2vYzF3WObQksodoKdA8lQ5fPt9QOTbICifkz/3NJb2vuflgI8uNvYa5p2DjNjM+ygJctu2PQJFm80Gm81GINtsNsN3v/td/MVf/AX+9E//FB9//DG01vibv/kbHA4HXF9f43A4iJuSTkjGrXI/c5dl3jdIJ914PJZ/0+XH7Y3HY9nPHCYRsHId5oCN/+12O3ke1wr3KQd0Ofzm2iPIIuDc7/e/BdL4vnSfcuyVUkdQ/fHjx3DO4YsvvsA//uM/4m//9m/xgx/8AM+fP8eHH36Iv/u7v0PXdXj9+jW++uor9H2Pq6srfPrpp7i9vcWzZ8+OIGs+5/l5lt8IsFqtsN/vMZ1OBaxyveSOV54LAI7cpXQmc90AkFhZrnn+HMBRVC9vKjgcDgK/edNDVVXi5qT7ta7ro+dzbjif3D/CYx4Lt8l9oFOYjt2805NzxXnhZ47EDFX/rY/SoqKioqKioqKi/48qJCgSfEguKB+7+BCgEWGTV0DwXeREpkppHj2sc+i9RzsYoh6OYh9lXaF3AbY7xM5KZZJrKsYz6iq6GL2u4a2FCgGVBpqqQh884D1MVcFUEfpZa5MjSqdIzQgsgguoawWnIqyM7k/GnloA0ZlmjE4xq7GL0hgDmApO6h2i4yo4D2UQYaHR8CECL600nHcRSHYOpqpTlKSOEa1IvXgumied1oAxKQKWqUJI3YAR0PR9F6Fm8LAB6O0WlTFQpoL1PnbrAVAqxMhPME0pAMqQFaG3LkbfapXmLF37aJPiPw10VcMYjQoae9fH2FltYH0AlEdlkoNOx95D0E3rHXa7XYS5popzCEQQ5B2cD6gUUJkKCAHDdhAht9HoDnug69G2Pu1yBR1Ucs5Gx63ygFIpVUj3cD5CN2ttAmtx/LSOLjhnI+QySkOHAGUUgqnQKJXifoGDc/BpP4OKXZNaxUhZXSE6CLUCQnRLqvTazsdYWVNXaGodQV5AjGj1HlVdo5UbWnsYFftbm6oCgoPte3HAhmhjhEfqSAxKQKaPRFYcns4d0DQ16KZUiNd0PqRY4+Q0tAmem7SOjE5gMsR1CBed0FxjcW0ingPaMB02uSVjd2yMeo3bMUYjuABd17BaAen6UqUIWqg7F3DwHnQbV1WqM+nj9ximbtI1KJKL1qFPxx0dmYyUNtFd6r24ZhkD7K1DMFXs3AwOIagYQat0Wl81GucRF1CcT4X4XUpEriquT2djpLQ2sdMWiPuTjg0xFDlGznYduj5+p5QGrqioqKioqKjot/TO364zhpEQIAc6OaghqMghGqEQlYNKwkqKoIrxnUB0s1VVhdFoJK/nn4QPBFMEQ8vlUnoJKUIIwtLJZILxeCzA7ttiWvMISW7r1HF5+rrTx07jWu8DkjmczZ9/6pQ8fW0OVe+DnG3bYjabCYQaDAYCJvkYx5J/V0oJvCGI4hhaa7Hf77FardD3PWazmTjVGIPKffLeYzgcYrfb4dNPPxUQSncbI2XzY6arjnGbOWQ87SMlUOOxs0+Q65LrbDweHzmA8y7FfH8ILbkPfC7XLDs18w5U/peDdsJ6vp4AVSkl+8j9zB2OWms8ffoUVVVhsVjgm2++wcOHD8VtOZ/P8eLFC/z617/GdrvFdrvF559/jp/97GfimH327Jm8H4Fe0zTiTOQ5RUh6OBykT3MwGBydzwSavDmA8PrUbct1kd/I0Pc99vv9kcuSY8JzkTGrdLjyT76O3Z6ErQSF3BdGTY9GoyOHL9cVPx/4Op5PBJhco1zjeXcux4bzws8mvq6oqKioqKioqKgoVwCvgVNPoKlSh6KOTrI+xkHW7QDKVDA+1Sg0Cq7vobSDUtG1F6Bgbfy9NFQV+sMBpg4ISqFu29SLp9C2KSVHRbelVoANQI0Gfd/F31+bFofDPjr9UgejqQxsiBGOpjFwvQWQOvWMgQ8BFhFwaFOhMpU4E5U20KZC8NE5VbUDBJ+glndQWiX3Yew7hO1jD6O6c7opY2LHoLXRGepjtGStDaBjP6F1HRSQIkXjtQlUhE/KRaeprggbTYzeTFAKKTL2YG0EgKmnsVIqOso8YEx0h1nnYa1DMq1BWwuj4xhUGvBKwyPAd/sUZatR1Q16AH23h1YO8BEexqY/FaGmMtDwsM7DIbprnXMwQaceUEbRKmhECGySS9ZZC40aVV3DWYeu62MnYHIwugRC4VN8aBXjQr3WQHLo1oMKVWWgE5ULziYnXXKqxlJRgYkIQIBHcB6OsZ0hwCgN5y2cjc/v0/cGzqsUL6tTlG6A1go6RZ7ud3sYBZi6RlVXMIj9k9bZ1JOZYlUBWNsjeBt7HY2BUfHcgKbTNcJor+L6UKkTkQ5ZXpNGl3I8D+JaA3pA+kuD17AqfX+io/tXewWkmwactYDtoPTdjd+dPUQorHXsZPUuOQotWMQYr49DchjHcdMpHpWQL37PFc8Lhei8jQ5HG6OMGWKrdHzMpfMp0VFnkydVKaj0OlUDcBF6BmthqjqC44B0TgVUlYFz6d8hJFc0gHSu3rmGI6zV2iQAG8TtqlUCucFC6zqCZCD7rirCVGtt/JxIDsuioqKioqKiovv037IB7fd7GGPQtq3AIbqfKLqvTvsNc2cZO+j4xT9jF/f7/VGvHcEUI0IZX3naR5mDnv1+D2stXr16JdvjPvEXVwKOqqown88lAvY+UHkf9Mvdmzmkug9eEuZQp5GweZTsfa7KHEjmzs78sW9zcnJ7s9kMH3744ZELNgfBdI4Bd2633FlmrcV6vT7qDV2tVthut+JKffHiBdbrNX7+85/j5cuXmM1mGAwGuLm5wWKxwJs3b7BarXBxcSGRp7kTNR8LRoISeOYuPT6fYIkRr1xbfA2Pj8dLGM3uRrovQwhYLpfi2CS8y+e5qipxchKqcv3n4JRwfDKZCPAEgOFwKOuZ50fXdUcQjzHIdALP53NorfHq1SssFgtMJhNxGH7++ef4+c9/fjRPy+USt7e3uLi4wLNnz8RRyTXA+Fqec4y63Ww28p456CNM5E0K+ZzxeRTngM/JYXDbttjv99hut/L+/PygIzL/HOEaYxwvXZ+MCCaYHAwGAsfrusZgMDjarxxU8/OD/ZTcN/7HtcQe1BBilO1kMhGXJx2wbdvKTRNFRX9sfTjT+L//5//4Y+9GUVFRUVFRUVJTN2gGQ/Q2/n5p+x5GR3AS4QUQo1UraFMnOOOiC8sbtO0owZN4Ay+8R9/tYxQkb9zUGkZH2FZF29dd5KUBfIoMVapCVdcxRlYBdd0geA9TGfjgoQEMBw2cNXDOImiNEDSU97AhpcsoBW9iv6H8vl6lKg4VgKoCeGOtdzBVBegqATctPwtKwVR1hJdaw/YAvEdABGrRhagQ6ws9ggsCJbVCcsV5VDpBSQUoXcEjAhmEeH0WPADPmFKfHJ2VwJfYt5e+azANtNHwzqFuapjKgx1/ybwHAKlHtI4AMZg47kah0oBpW9TGYLNZoXMudkEqjdrUcZy9R9dHh618NwGkuYsRu8pAxoHQKCB2fzofY1edi5BSaQXrXYwZdS7OfVVFAGpj/K1KXYl3N4vHyFejY/RohNQVTBXHg/G+SimJ/zx0B3EF100T+w+1gQvRRVrX0fkZr2Wb5NJ08ABqlVy3KZK18wEmMVWtKwSdvi/RKjqMQ4w1VUDqq1Ti3IxgMaQQVB+jS7VCoxVCiPDVh4CYGhxji4O3UEZHJ6tS8C51nSKuL2UMTGVQmQrGqDjRyqQe1LsY1eAtnLXo0k21zjmEBPt4LkQQl0CfMfDWwjqbnKZ37tTY4WoEBkfTZ3T1KqgUB2uAoGBdD1gL72w2BjauX8T1oxAhZUCAs4A21Z1ztO9SFLCSNRhCSjJzSGvcx7bU4MT0GIKGQg0g3owQfIjvplWsA4VPzmkLpa2scU33pvcIITqqK6XjTQDq7juJoqI/pj6c6d/9pKKioqKi/6V6Z1BJmMXevdz5dhq3CBxHt57CNcIh/snXE0oQ+vAXeYIhOpsIjggh2K3H+NH1ei0uudz1RsjBn9V1jdFohOFwiNVqJft3Hzg8jVfNHYw5aOO/6QzNQerpa94W75pv89Rtlz/n9DWnP89BG0HlZDIREEcYR7CUv44giR2S/NnhcJDHr6+vpeuSgPj6+hoA8KMf/QjX19f4p3/6J3z66adYrVb44IMP8KMf/QjL5RLL5VLGkeCJTk7CLULlvM80dwASRNMFSeDItUNYxu1ut1vsdjuJkyWc5brinOXvy7EZDAYYjUayzk/Hn2PJCxgeF3sc8/mny5BrhufEZDIRCE/H49nZGVarFT777DNcXV3hzZs3sNZis9ngxYsXACBz1LYtDocDXrx4gcVigbOzs6O1TJjI84xuQ0an5n2ZdJ8ywpb9k4SzdBzmLuY8yrZtWzmWPHY1v9GgbVtx2ubnEJ/ftu3RTQt5TGwIQY6Fc8ixGI1G0h2qtcZwOMR4PBZIyYjf3Emc31TBz7npdAoAApV3u51A/BwCFxUVFRUVFRUVFVHD8Qi6qiOQgENV13fES8XoTOgmOt98hG+xDq9CO6hgtEIIPjm1IugwVYtKG3R9D28P0akZLEIAbAJcxsQbHmvroEyNvrNomjo5zjycTUCwMhHg1Aqu62H7PYKzqJt4w561fXTqJScVQogwLbn+jDFQ2iRHIjssYyyoDR4GIULK5ADzLn53IL1/yUFWVQZQVUpkiYkqUBoGAZ6RmDpatoJGhFLJkelxd62cthg7A6EQnIc2WbxmitbUSsVOScSOzFixqaG0ic64vk/v59MGUwpU18MFDx96IMFZ7z1c36Gqq9SxCdRNg8oHKBWPLaTo1b7vIJPv47VuVUd3p3cWjvG5LkQQW1WANlAJmIYQ0PsAXSUHW4jAEdoA0IhJriEB4SDwTmsgZu9GB12EioH5o9JPyNd5n1yaKY3IOQ/vAypTxThho1Elu6mFiu5N72HhUyxuhNImXX8DSJG/BiYBNB8Q3ZGI61qnqFStItjSVXxdbz1HDN7Zu55DF8F2/KeCCh7QEGju40EnYO3hoKBMSsXRSKAv3gRQ13WMftXR2ai0gfNxP3WKIXbWoks3rcafxZhfOpa1UinKOECbBI5TdKrcYJ2+F4CpABd7Wr2G9I2ygzI6LAOUCmiMQe8TQPQuAs1EPJVSadw0TDuMPwscAw2v4vOD71OUa8MkXIQQzw3vU/QvPJSqoFS6GTuk7yxCiK5WrdJNAClM1qe9VRoIKnZl9ikSVpl4AwOQXKIRdpbg16KioqKioqK36Z1BJV1JBA15JGrunqTDi1CGv6ARPjDW0XsvzyX4yJ2ITdPc7XSKecwhGd+Pbj8A4nSq6/ooZpOwktCOsIO9dISV2+32XnhIePdtjsvcYXnalfdtrsdTKPq2x3Pw+G37cR8EDSFgOBzi4cOHAh0JdzguecwrwQ2dfoSGhH7GGGy3W+mc5JogwFZKYTgcwjmHf/iHf8C//uu/4uLiAtPpVCAcL17y/lG+R77G8nVA513eg5gDQYp9hVTuHOV2CcD42jymlvCN6zV3CZ9C6dylmzsCuQ1Gzebdn3wvuvnoBgSA7XZ75MIdj8fQWuP169d49eoVNpuNAHk6COkSHY/HAmu/+OILcSLzvfKIXUJIglS6KwkB6b5kLDLPbY4RASCBMR2LHAOOD4+lbVt5/9xxybVF0Mn5434ROLZtK1C1bVs57tx1nEfU5mPctq24L7l/XIO5e5ZzzM+THDLTyUpYfhrFXFRUVFRUVFRUVAQAAQY+ddzxi/0I5TSCXPOmbj1nY5djZdIX+xYuKHiP6JoKHk3TJpcXUNcVnFHouw7oepiqhgcQnIvwRim4ACA55jzic+u6QvDJqZd+h9ZKYWeTa7KK11zeO3gbgZwyVXJfVtElGQBtFAyBilZ3YCM9plOXY7xGd4CPv99rHcFhPLAArWJ8rU5xnrY7JIdX/L07eI9gdHLIARGDphuhtUlOtHSdHxysc6iCSq4yB2+TS1ABATrtd4SwQARjMXYW8LaHdzaRmBSHCQ8gRnwqbaB8PL7gLFLwJrwCemvv9jGwKsLAu5AiMj18CDHSVWsZN5O+Mzi49D2CC3AuRGOs89A+fv/ifDzOJl2n+xBw2O/hbMBwVEPpuA/xup3fCaTrew8oFdJYAT5FvRptUFcazkU3X9yulWs3S2ccVAKHHr11YDSoqQy0MbGLUylU1sK62CsZuXaI61ErVFqjNgrea3gVg04Z0XoXcaqYQhuvz5IL09kewcSYYpVwnlcB1sbXRaYcT5QQAK1VOk1i3Kr3yXmYok6d7WE9UBkDXaX4VwAqRdfavkNAyjJFQHfYoe8OsN4xaRUu3EHh6K51UFrDxIzVFPWqYOoawVTw3uHQd7A2RrdGt2F99D2DQnR4AoC1LoFoFXths+884rVvctAqQBudrk0BeBc/E5SC0SHtZwUFDegA7fkRYtK8xxsjkPpHlQKqSHwBFT+bFAE40hNCEADJv3sP6KZO7lqIMzqu6R7OBSQrZlFRUVFRUVHRb+m/5ajMOynz6NIcOlRVhe12K+Amd1Hm7isCRsIbQge617gdbpuQg/GMBDB0edGBNRgMjqBT7uzkvtPRNplMxIF1dnaGruve2lXJ1546HXPl8Pa0d5NQJH8e/55vMx/f+5573/vl+3MKWgnlBoOBQC+60RhnSQfiaDSSbkDOkUnRPDye6XSKuq6xXC6xWCwEaOX7T3egUgq3t7eydt68eYN/+Zd/wfn5Oc7Pz1HXNXa7ncw/+wgZmZp3KhKYMVqVa+LUMZh3T+YAO+9m5BwRPDrnBFJznTIalsBTay3jwn9zbBjvSuVxrHVdi+uXkLaua4zHYwGnhMKbzQa3t7cYDAYC6XL3I587Go3w/vvv482bN3j16pUcA8+P7XaLX/3qV3j27BnG4/ERcOMx5LG6XPN0p1prcXV1deREJYjk2qbDNHcp0xHadZ2Mfd5XyXMzn7eu6+Rzg9vmvPPzgT2Wu91OnKNck3RWc/6dc1iv13LzBKEx421z1zP3kReKjIBlb2vf92jbFsCdc5zu7RyEFxUVFRUVFRUVFd0poHcW3sUv9I1JjiuwPiICJJ/ARYSIPkZwGpPiPBXgXOxzdA4wBp2zcAk61loBVY0QFGzXxT5H59HWNZRht52FRoztRHIpqgRGrPdQAaibNrk5o0urtwq6jkAtMocKgI8RrSECkKBNdt0bYze1SjdhBiSoGWKvonNQwUPrGL8ar+0VbN8jBA+ldHTdsf89xDHxySEWoFI/HyI5gYLzaRwBIEQXIJCSnQhh9V0UrkkuSdun61aloQ0QbIQ+0R0WgR+7FXW6vlAJoPngANfDgjfURmAXbJyjuua1TEBVx+jQ2D4ZUFcVYt+fR3A29iomZqviKkhhnhH0BgTY4OCT8zFSo/S9AQKqpomAyfvovJTIVIDWOecDtPeoKiTIGHsYKxNjc/uui7G5fY+u72HTdaZLx+ChUNcmja2CJRBMc5SSd6P7NUWcOhVjT41OWDEA1kVgHB2KyZanI+SL12KpNkfT8udTjKuHMtXdTeDeJsenRlUZWBfBqVc84wIswSxC3C8foLyN8b9pfAJiD6y2PVxvoXSFqq6gtUvXxHE9+ATwnI8xwSHNGb+DCgmSKigoneBpcowG72GUhtEawdl404JS0CmOeVDHG+6hANd18ZxyNt5EEKKL06ZeR/aXmqqONwoohaCQQLFBZVQas9iN6Z1LcFPDqxDjnxMcd5G3xs5MHSTul25vr4KcSyHEha8SFJXve5Lj1CeXpzGVwEloeqEjRIWqY9ds4ZRFRUVFRUVFb9E7g8rVaiVuRcK+PBIVuINlVVWJQ4xOpLx/kG42uunyuEwCKwKOPKaR7ifCA26LwIgA5HA4YLVaCZTKXY65q5KgipBuOBweOQx5TKfKt8d/3yf+PHcA5gDwdDv59k/jXt/2WD7u+X7nP5tMJjg7O5NxJwAbjUbiquP+0MVIx2oer2mtlXEioCMEI7gJIWA+n2M4HGKz2YhD8Pnz5/je976Huq4xHA4FIHFfrbUyfwRUwF0/Zh71mjtWbbqDlPvA+ctdlHwPrhU6KU/jg8fjMcbj8ZHTcDabybo77V6kc5MAj+NP2EvXMPeLkJIu0dVqJTBQKYXBYICLiwtxEG+3W+kFJeQjcHvy5AlevHiB169fy7oh3FVK4eXLl3jz5g2Uir2d7N9kfCqBoHMOm81G3n8wGGC9XmO1Wsm4bbdbTCYTgXg8P3lc+/0eq9UKm81G3iOPe+WfPE/pjAQiyByNRjgcDhKpStfvdruVzxBGsuZgnGNLsLvf77FerwWsjkYjWGslnpifEcPhUI5lMBhIF+h0OsV6vcZisRDHKOOp86jb0xsRioqKioqKioqKiqh91yH0HXRVo+t7NKhg6gbeOfTORXBj4u/ZVYo71SZ24sUOPJ96BgGjFHZdh8pZHHqLfr9H0w5i32T6XT4ohUrF340DPPpDFx17dZ2gko9gJ0SYokwlcaeV0aiqCJFcslZVlY7vreN1ig8OISh459AYg6pp4Xz6/bjWst/GGOk0RNp/ldJejdbR8RaiazN2TkZgqbVBU2n0LjrxVJWYpI/Rss7F7wy0UqiCQTBVcuAFeMQIysjKkptT6RQbCxilxcnmEVL0anTmORuhltYa0BGY2kRzUo6M3HyqpReQ/ZUB/WEfHaG6Qrffx1hYbRBTWevofAwWVdWk6+wInrxLW/JOroMVYtSm7RXqpoqRotrAIXZz1orXToiwWWkEHlu6Do2RvAky++hIPPQ27VeM7YUCvLcIAPrDHquuQ9f10CZeb1VGI+gI2YwG6LisTQXrY6dhhKLRqdn76Dg1dQUVHEIC5t45KBUAraOjk2tPR1genE1JpjHqNIJwD9snB6hKHZUprjQuJCOAutI6rhHE2FoAUCZGrgYA/HZGaQAuAkfnU+pPimX1/gCtLayNr+q6GP3L+hGtFdp2iM7wpmObXMMaBoBVKhpvk93SGJWOI0aiQsX1ZINK3xkYNMbENeRt2sG0tnwE1fARODrbJYjaypgplTmTUx6r7XsEFzv/lNrDAAAgAElEQVRubW/hQ4yNDrwZWsebH4ypYgowApy9q2qKp0Q8D+KNAT4idsbaVnEtxM5Uj+BNihdONzAkMKu0hk5rNX4eqRgjHCDzU1RUVFRUVFR0qncGlTlYOHW00a222WyOIkIBCDjMYxu5HYLJPMK173vsdjt5jNCGAI3xrjlwAyBApO97LJdLrFYred0pqHTOyT5xf9q2xeXlpcRf5v2Y3+aezMHhqfLXnHZA5jGnp72H9wFHPn76WL7N03/zv/Pzc0wmEywWC4nS5D6xj4+RoYz9bJoGo9EI4/FYXHYEwHVd4/Xr19ILeOr6/OijjzCZTPD5558LXLy4uMDDhw/R971sjw7BHAISjPK98o7JHPrxvQj/CBf5Mzo1tda4uroS0DQcDlHXtcCsuq4FhDEGmI8NBgPMZjN5f64zwjrOG+NCc5cx8NtuX8YR07nHKNy2bY/GmdCecce5q5VzdH5+jsvLSzRNcxTXyi7J9XqN//qv/xJ3Msd4NBrJuBPwDQYD2YYxBpeXlxgOhzJHbdvi/PwcALBcLqX7kTA4j27N3aH8OZ2adEXyvM3HYrfbyXYJVQmc+Rlyuu457oTDdMFeXFwAAPb7PXa7HQ6Hg0DZ9XqNzWYDADK+eRw059U5h9VqJeuAc0pHb+moLCoqKioqKioquk/e9rC2h/YOVdXEONJ07WuURt3URzfQVun3WAUAWsMjOpZs36ffp7Uk4TR1g6YdxOvedCNgVRmkMjv01sE7F3vobHTKaaUREVnsTqyqeG3hjI4OLPD6U6MyEfR4F9Ad9qibJrkMDdqmiVGg3qNuaphqhD7FpkanlofXEUqGBNC891D5daqpUIWAHhY6pcIkTCIQSCkF+ADnHaBN7LbkTYI6HgvjPY1K4xhSOKzRyakZIRdUdMKFEAGfDwHOQ9ycARHUmOCT+9GkmyxjD2iMILVQCrCps1PrCKaUbmBMBQQLqxVqU8WezBDgvYX1FoGvh49uyeDjHKf55chYF52VldGwKZqzbaroaPMO1nYxgtcYOB27HbXSMU5Ye1pQBaJW2iCYCP8YwwkfnYsRpMX9qOoGyhh0hwO8jy7dpq6iU1AhjpF3sbMUGsYgroGgk2vSI5rwYgxwqGo03qHv9ui6Pjke72CsgkGlqwTa0vdKiOAtgOtBwaRxjtf2PoGzCCe9TzfLI4LOCFNTOiki9HTp+UDszBRbn1IxsjbEWN4IRON61ypC9O6wR21iT6g2GnVloNQQvXPw1sZI0wCJzCUY9fz+Ja3V3vfpO4wK2mg0VQWjk/PVhwSjVQKHKa1HpSXuHfb7HYbDgHowgqlreHuIYD377kcFD+s8OqaCqQAVPLy36LyFqRuYkJzdVXQ3RgNrHJMABVNpeNuLg1mlMYkUMvVk6uSGhUJlUhcqohM5Ho5P+xbHgS5rRadsUVFRUVFRUdE9emdQOZvN5Mt6gobBYCAXWXTH1XUtUIRAjuCPnZDAXfQmASaBZR7JSQccgUIOpfL4RuccdruduMIASPzkfZAxd+2NRqMjV+V8Psft7e1R5+Hpa++LawWOASH/fQoR89hcuUMzi6Pk607fM//zvm3mrzv9GaEWI06tteJeI/yjc5VuOO4fXZOETUopbDYbfPnll78Fjwh5vvOd76Cua/ziF7+QMZ7P55jNZtjtdgKz8rHi/hCeEobnQIvvTyDJNcN4Uq6l6XR6dPyr1Uqce5PJBG3b4nA4iNuXsaP5PFRVhfF4LOCzaRpUVSXwq5cvDu7gJdctwRb7FwlFCbj4pcRoNJI4UsJzQjsAErd62mtJeH5xcYHHjx/jyy+/lPGkU9Rai88++wxPnjzB+++/L68lDM2/HOE48z1CCHIMSim5MQCI0b88x/KbCfg63mjAOaIDlrD1NPLZOYebm5sjZy7XJ28u4NpjfC4A+XO/38sxs0uTPaZ0n+Y9pnSK0tVKUEoQzDVGN+vV1dVRzOt+v8d4PMZoNEJRUVFRUVFRUVHRqZyzsR8y+BTRaQFjojPKe3jr4LyLsYlNAx9iIVx0/nk4Z9F3nfTsAdHlZ+roePPewdkuxVICtossoGlqaFNBmwrWh9Rx5xP8qKCqCBD7roM2WgBesAkqhj4533yyokXgppSCaZvY7acUYGKULHyfoiV1ioQEqrqK8Cg5GHlN70J0i4WQokwjRYRWCt4FeOUjzKtMHDfFDr0IFgFCs4CgAaXje9oQXXTGKDgfoy8V7q6vnfMwGVAJCFBBHUE95wJc8FA67k+Mu1R3EaQ6djIOtI7jk/x6dWXgg0LXp6SeuhGw13WdRINqrZKTMvYZxojOHkDssdRKo0rfg3gfwWaMko29mXTRKWWiGxUB3nlYKAzaFsOmiW5HH6KzzsYEmr7rIiSlq1FpuITV+uTcVSpGD3chjo0PPsa3mgrBBZi6QtAquTdjQqsKARoeyhjExOLoAK6qBt5Z9DZGESsdOzW1qVE1GlqFdM0a4aZRCkGpNAaME1YyvkorRKqcziPl03cHqbcxIEWv6gQtIzDsXFxnQcVj1ipBXaOg03cLztm4BEOEoM71CcYi7oPSye0Z11b8O+A04H1a784DpoLzHioWoEIhJIci0moDKqNhqggEY8xwci8qnWCejzWOPvZYGqOhhyMAKdmobmBUhIHKK8BbWBtvwkZwgIrxxkoBwTvs+wOsTSBU9XAm1a6o6JI0hjfwx/MovtDEaFuV3JQSKRvXRHw8JCip0px7aF3BGAWdzrE4l8kJm1zBd/7WoqKioqKioqJjvTOorPNfnhM4IUjIAZtzTiAFwUUe8UoQQRHc0FmWg6885jGPAu26TgAWIQTBkzHmKK4RuD++1VorLjyCOaUUzs7O4L2XbkXq22Bg/pzTx3MwyX+fujFPxzAHIzmkPIWg+WtPnZf568bjMabTqTyHXZ6EfgS+BFQET8Cd65KgaTweY7lc4osvvsDhcPgtKKqUwvvvvw+lFD755BNYa3FxcYHJZCIXjNw+t8kexhxeA5AIUL4Pn0/YTaBFMMXnjcdj+Tkvjum+vL6+FhBV1zXOzs5kG1VVSRcmx3S/38M5J+BstVodRZKyP5IgjK5fQj+uM65bAEfnDc8XgnE+3xiDyWSCwWBwFIs7HA7leB89eoSPP/4YL1++lPONc1VVFa6urvDmzRs8evToyDXK59G5TMBLKLrdbgVA8maB5XIp51bet5pHqnIdGbkAdDLfXK88DgJERvoyqjW/MYHbms1mMqY85/m+uauS2wIg0a4Exjwncgifb69tWzlGay2ur6+x2WxkTfLmCwA4OzuTNVZUVFRUVFRUVFSUqx2OERJwCoi/g+oQf89HcjdppWAqI7+PaqVTbyBg+/i8uq1jZ6VHdETpCBkAAE0Dd+gARpJqwDqHkMCUQoy7DMGjrpto01IGSmk4F+NcNaFZiJ2FXbcHvE9xpgCCR9cpjEcTuD6r21CxWxAJYgARgKjKgO5PeAulFYyOOa4hudx45egTlPHOQun4+7dRCilLU9xh3gcBO3SEhZCAilZAcJGz0ClmKnjn4XyEkErFvsYYE6oTmApQ0Cn+NkaJOoTYR+mjOw/pGjKmpcaYVutj/59O4K/zEQBXJjn2vI9xtN5BaRVTPFWEisrHzkUACVSz71DFWF7bxwRRbeAD4F0Ej87HTs/haBRvrHROInqDD+i6A4w2sbczhOTmtXC2x/7QIwTGvsZxr3SMGfbOw9q4n6ZWGAwa9C6g7zt4X6FKEK9yDnVVox024NcNIcSJ1CrAVPE7IucdwB5JU8WeTxW7WeP3Mh4edy5W532E3lql6FCV+hirCGSDTybaBA0J4nRK0krXg4y/BeLYRWCp4byLkFip6GBMoE4FD61MxLWmQgge3tPVG+caWkMzPSfNvyIMBGB9hHVKK+igI0T0ATZaIeHTmGvo5DyMva3sP43OxfR9jk9dmz46SeOfERaapsF4MEBVa9j+AGsdAlwEpzq2myKdQ3Aung+I55yqPFwI8aYJKDgd4PcpZrmpZR98cGnN6xjrq1IcLxRC0IDtEVRs/VRyj4FPN2EAIVi4kAB/itUNPvveKgRWYBYVFRUVFRUV/Zb+Wx2VhA2EDNvtFiEENE0jDqX1eo26ro86Kglz8ufkMZ+EinRV5f2C/DldVYPBQIAK3ZSncbP8WQ71CIcIdAhJ6PYkmMpjLhmVygtI6tRFycfug5T53/keudPyFHy+bTt8PqHvfd2Wp6JLlA7C3JnH3sK+78VVSBda3q3I+E8C57qu8c033+A3v/mNgOT82IwxePz4MQDgP//zPwWoNU2DxWKB1WqFyWQiDkrOr9ZaXJEhBOkVPBwOWK/XAgurqhJwtd1upWuU6wAANpuNwC52EHZdh81mg8ViIdseDAZwzmE0GgkIJRyje5Lrku91e3sr+w3cuR7597ZtpQNxv9+Lq69pGtknPpfA7NQ9yrHPnaRc14xqZZejcw6ffPIJrq6uBKo55wRofvnll5jP53jw4AG89xI3y3Mr73ms6xq3t7eyxji/ucvUWiuxrnkEM39GmApAYn8JPBk5y57Ovu9lrIAIpquqwmQyETcvga3WGpPJBMBdbDQQIXbeecoxo5NTKSUuWo5zXdd49eqVOIJ5rHn/JmOs5/M5nHO4vr6Wzyd+/hUVFRUVFRUVFRWdSiWQY0wFaMB2HWqV4EeIEYzG1Oj6DpWOXYMBGkhRrForNO0QpqpiQmYFeOcixAgeddNCeY/hoIXSBn13gFKAddF1hc5GF5fRMKaGMibGa4YAa/vo6kIEoxHUxJjV7tADwUMbCwWNqjJohwMEBVg6+WwPpUzkrd7BVDWCipGovusB3aPvY1SqDoAxAbpWERwld5t1Ljkv75yLSkcHanARMMX+u7hdZYx0GobgIwjT0flobew9hI/ONAAxmhUpvlKp6FA0FTw0govXz84HaOVTFCpQqUocl7RfWtvBKI3IiSMJ1caQNaeYUZfcjhouRFjo+uRkTdGlMQZTo9IBRhtAJxDnXARc3scOT2jARWep623qGPVxAcSjh6kMtA/obXS/OusQjE9/72Gtg3UezisE00R3rFEwKZI2IELD4D2MVhiMYi2K7XtY10VIrjSq4BPIinDZpv7GCMbiNalXCkYn96Lv0aXXtk2s1rFBwfeHFJNqUlRsSFGsyaHnUxencwjBQZsAhRj5K+dTcloyBlal/1sHaHMXN6qCz9y9IaWpxs5U9mQ6bwEEWX/eWlRS8+LgQ7pOT45RDYWqaeGdhessemVgDIDgpesxrhcvbk2lUxytiuiTxxxChOFxjUYo6BmxCyarmtixWml4G+Jaj7ZaaBPnzkGjrWoExi4rBR/rJmP/rY6436Q4WWUUjFJwTkVHNR2z8Mn9GB+P5se4lr2L69orJTcaACE5JdN3VukGCgUApoL2Pt00we+3VIp+LdfNRUVFRUVFRffrnUElgR57/Phl/WQyEbADQEAJ++pCCBLPyB64m5ubuzsyE4gZDofYbrfSsUeAw+0ROqzXawwGA7Rti7quBb5Np1OEEKSfkl1yfA9CPgDyd8IkxnryPZqmwWQyEShzGgP7NlB5+pzfFeX6Np1GveZQkjDqbfGyuXNtNpvhu9/9LubzOd68eQOttUCkPHp1vV5jNpvBe4/VaiVQkHGb6/VanIKDwQA3NzcCD0+PdzAY4OzsDPv9HtfX1wKo+77Hmzdv8PXXX6Oua8xmM4QQxAk7mUxwe3sr+7hYLMTpuF6vpWewaRrsdjtxYAKQqN66rgV85VGudCC2bSvQixDTGCOgjVCMHZkEVxwvxrUSmHIezs7OZG1zn+n0I5xr21b2h67N8Xgs8DKP4s3XDJ18PAYCyrOzMwyHQxwOB/zJn/yJRJXyHKRL8tWrV3j06BGePXsm4JBAr65r7HY7cUnmvaB8jMc9HA6lD5Pxs4x2BSD/5johtObxnHay8nVN02A8Hgs0rOtaonsJSgnR83hiwlvuJx/PuzbH47GAybxbl5B6OBxK7DEB8ng8xnA4xGazgbUWs9kM2+1W9o2O0N91DhcVFRUVFRUVFf3/U//b//5/FA9RUVFRUVFRUVFRUVHRt+idQSVhCYEOv/DPu+YYJ0k4xRhJ9h7msZMESMAdNCPoILzRWgvwpNuKz99sNgLkCEm47dVqJTGgOSw0crdcVN4LyLhVAp7BYCDxjnwOwdy3dUTeF+V6n05fc/r306jZ/LHczfW2CNq2bfHkyRN8//vfx3w+Fwdl0zTYbDYCowjCOF6Ea/l4cb/ybkPGs+axs8YYPHr0CIPBQKJzCXhubm7E0QgAb968EfCotcZisZCIUzp1OSeDwUAiaQmS27YViEmwTMjEeeQx8O+EbUopjMfjI7cf12YeOVpVlYAvuoQJijlGo9EIT548wW63w2KxkPEi5Mw7PyeTCUajEbbbraxfrvv9fi/Pp0uT8L7rOok+pROSa/7x48f4yU9+gv/4j/8Q1zNvCpjNZthsNthsNmjbeGcr447pUN7tdrK2eT7y/U/dg/wMIIjlPm23W+z3e3Hmcp3wJgNrLYbDIYbDocSrcl/o/gTuOjSVUnj16hUGgwHOz89hjBGnbw7m2XvLuFy6JvP43rZtsd/vMRwOZc3c3t6CEcGj0UjAOG+OMMbg/PxcxqOqKlxcXEg0bR4DW1RUVFRUVFRUVFRUVFRUVFRUVFRUVFT0++udQSVdfTnMUUodRU4SNBHk5M5K/qxtW3FcEZblr6FTLndd5VGOdFARFhBccX+4bYLLU1BI+JUDNzrhCIAI1waDgbwHXXg5oDuFkqe6r5cyf/y+f79tW/m+5zrtqCS4pKMy7/ejCxW466mk+5TPofOtaRpxoo3HY3mPw+EgkI37y/FumgbvvfceDocDXr9+Le9JNyFfQ9BFiAdAXG500I1GI1kTdLzyveq6lv1nDOt4PMZ4PBYYxXhXAOLUnUwmCCFgu92KMw6AbJ9gjcBwPp9juVwerQHu13a7FYcj4TydhhSjjfNoYq5L/ozjQPDPNc9I0rquMZlMBOAdDgfZprUW0+kUT58+xaNHj3B1dSURvQRpIQRcXV3hxYsXeP/998VpzHGjK5lglq7HHNoRWNOBzHOE6yUH2Hxf3ohA4Mlt0rnIOF0+l++xXC5xOBxwdXWF+Xx+FJHLMWQ0MACMRiPZb/6c64Iwk+uIEdMcV2utOEoZo8tj4PmU92SexiEXFRUVFRUVFRUVFRUVFRUVFRUVFRUVFf1hemdQSYBI9xWhIEEZ4dFkMpGYSgIIwhdCK+DO9TeZTKCUwnK5BACBLHS7AceuvdxRRxfgcDg8Aoh07RF4fptLkTA1B2eEIm3bHvUZ0mFHGET4cbrNU33bz37Xa06BYP7YKaTMX8cYVAI5RpBqrTGfz6XXj8dJByyjMjn2+XtorfHZZ5/h1atXvwVfCd+eP3+OxWKB3/zmNwAgEGg0GsmcLJdLVFUlcDHvLmS8cF3X4oxt2xaz2Uzmi846gleuCaUUuq4T6ETIFEIQVyYf43ZygMWuRCACqslkItCL655gnTBLKYXr62txCRLoARAw2fc9BoOBOP24VmezmYyLMeYIMvL9OEZ8zmQywWazkbnmjQAff/wxvvrqKwHEdBYDwOvXr/HLX/4SH3zwAWazGfb7vcw9gTwjca+vr8VBTOjHMViv1xIBzfOYcJXrheck1xQht7VWumk3mw22261ENhMy0hm52+3E4cpuyKqqMBwOBWb3fS+R0vP5/OhmBa5l7hvjmwkoZ7MZtNbY7/cyFnVdy1okECZ85WdYfgMFo2eLioqKioqKioqKioqKioqKioqKioqKin5/vTOoZJwkY1HpXHz06JFAGuAYzuRwLIdKuXOP8Ga/32M0GokrijCCLiYCRbo36WhkTGXep5e7P6k8ZjMXXZV0fxF4EGgNBgN5LaHb4XCQyMwcVubi/r2tw/L0sd8XZp6+Jge4eaclITChLsEM41/pchuNRkdxuzlIoztuMBhIFOlqtRIX7enYNk2DDz/8EKvVCi9evJDOSnYHdl2H0Wgk0HM+n2M6nUocad4byLkneHzvvfcAAMvlUhyMhEkAxO233W7x7NkzHA4HOOcwmUwEonG+uCY5fnkUKcEuo1tzuM51sdvtBHARkOauS/Ybeu9lPwhJ+Rw6jC8vLyUKtqoqrNdrbLdbNE0jc8OIXjofc+flZrPBbrfDRx99hF/96le4vr6Wdb7b7QTiX11dYbfb4enTp2jbVm4kCCFgMpnIuqZrl+cg53k0Gsk6Yk8s11Me00soSSDYtq0ASEJOnsd0qJ7eHHB2dibORs513/dyvvOzhI5JnmcEutwHrskQgswXz2eOMd20hNAEzTwHcnEsxuOxgPOioqKioqKioqKioqKioqKioqKioqKiot9f7wwqt9ut9LlNJhMAEBckXWaHw0H64Bgb6pzDbrfDbrfDfD7HeDwWYKS1xm63w2azQV3XEsnJ1+dQh32HOXQjSCIQyiEUlUe98u/3QTa66hg1ut/vcTgcxJW42+2Oeu+MMeLIIhSh7uuavE+nMPNtz7nv36fdlvmfdMk557BcLjGdTmU8t9stVquVgCrCrK7r8ObNG3zzzTfiIKWDjQD47OxMnHH5+HFf2rbF8+fP8dlnn+Hrr7+G1vpo/NbrNc7OzvDs2TPpa9RaY7vdSnchQSmBFmHd9fW1rMPNZiO9opxTwsOmaXB1dSU9l7vdDiEE6Rdcr9fY7/eYzWZwzuHs7Exg6XK5FBcl+y/ZT0mAfnNzg8FgAADiZqTjkpGxo9HoyLHJ2NqqqrBYLND3PcbjMW5vb8XdyXGkW5KdjnR6EnzyPQjj2GF5dnaGx48f48WLF1itVkc9osYYrFYr/PKXv8R8Phcg1zQNvPcy/7e3t9Llmd9skK9jnn90WfLGgdy9S/jL9ZfHOrNXcjQaHbkV87hlfhYQbAMQhychewgBs9lMwCJvouC+cf0TEtMRTdDKMeY6owOZnZ509xKGGmME5OYu8aKiP7Y+X3p89H/+X3/s3cB//c//8cfehaKioqKioqKioqKioqKioqKioqL/F+idv11/+vSpxB8S+tHpRcBorcXhcJBYRD6PAGq5XMI5J+4s9h3S5UfoQHcTXZt0Y41GI5ydnYnTin13k8lEYlpvb2/lfQjQTrsd7+t1ZFQooUR+rIQz2+1WHHKEooSWjJZ8m07h5SlcvC/WNX/89LFTAJp3U7L3cbfb4ebmRsAVodJgMMBisZCxGo/HMMZgs9kIaOb88N90tl1fXwuUO93/4XCIR48e4ZNPPsH19TXqusaDBw8Eej548EBiYHMYRtjHOTgcDkfjv1wuxVkJ3Dkb9/s9NpvN0TxXVYXr62vpMCTsZDRxPn6MEV2v1xIvut/v5Tl8f7pr6fAkiFwulwI9q6rCdrtF3/cYDoc4OzuDc04iTtu2xXq9FmdqDuQIyfb7vfRscnuMcT0/P8d0OhWQSzDHrsfhcIjvfe97ePnyJT755BPpvHTOoWkadF2HTz/9FB988AHee+89WSeE7QAEXHL90zlMaMhzmaBTa43xeCx/J0QEIPvN83k4HKJpGmy3W9l+foMAb0rg/OaRrNw3umDp8N1ut7i9vcV6vcbhcIBSCg8fPpTtOeewWq0EkPL13B4BMD/HuD+ElzxeRhETdPNnRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUV/mN4ZVNJ1lbuKCAQI6QiccohFKKG1luhH9uHRbUUYQZhGhxn7BQHIcwiD6PYiNKSDc7PZCGD6Njfj26JheUx0TBGkEZrmEaoAZCxyNyCB5X0dknw817c5Kt8WGXsfwOR+ct/zfk5GpTLmcrfbSQck3WkPHz6UWF9jDK6vr6Wrka5Bdnbm+064w6hZuh7H4zEePHiAyWQiMC+HkXnsLp2sjAM+HA6o61qgFaM/6V7NHYN5Z2IeOdw0jTjp2Ik5nU4l4pYw9ubm5uh9uq4TeMt1q5TCdDo9Wgecc3ZS5uuX+8m1wXNhPB4f7c/t7a2AX+89ZrMZjDHYbrfY7XYSy5vDvPwc4bxrrfH8+XM8ffoUn376qcwPzzm6Qb/66itcXFxgNBrh5uYG6/VanIyMwM3hMYEmzznCvpubGxkXAmLOF8eBIJCv4RpkDC6jcAHIXPLzhVGwHBeCRALOvu+xWCzkXKRjkzcU8LHNZnMU6Uy4yz5KAliOVdu2GI/HWC6X4o4ltM5jqL/ts6WoqKioqKioqKioqKioqKioqKioqKio6H69M6i8uro66iIkdMhBXe6IIrzIgSChFqFD3rvH5xGWWGtxe3sLAOLw2263uLm5kffJYz/zbr0c0J1Gpeb7c/rv/Dl0UhGUAJA+O8IjgkmCo7yLkQCV7/O79DZ4eZ+zMn9ODnLZZ8gYzdlshtlshul0CgBYr9dQSglgYqyr1hoXFxe4uLgQpyP7GtnzSHDJ8Tgd18FggAcPHoir9XA44Pz8HA8ePJDuwDwqly5CwiTGlxL+0aXLY+H77Pd7AcnD4RDz+Vwcb9ZaLJdLmaPxeIzBYCBgku5YY4xAMnY8eu/F3UgQdhpDymMmWORYE3YxzjSEgMViIecAwfFkMpHX8tgYKdp1nUBiriGea3zO1dWVzAnHknHE7Hh98uQJLi8vJSq36zoBbofDAV9++SXef/99KKXw+vVred3hcBCgSpc0XdPT6VTGiVG0hLtcP5PJRMaYaySPniUwpaOU48TPD96AkPdG5jciLBYLcT9ut1sZA4J5zjfnkfvKGwXycePc0kGaA1POCR2UdFdyPLjWft9O2aKioqKioqKioqKioqKioqKioqKioqKiO70zqDwcDhLHmkPB3W4nMCAHQoQD+fMJNxlF2nWdRHdeXl5KjCSdWHR20WW33W4FrBDOMLaSAGu1WglEyTsg6c46dTiegkq6pxj3SZhBKEnokz/W9724FdlvyH29z314Gvf6bcqha658G3GIyQ8AACAASURBVE3TSAcjoW/TNJhMJhiPxwIECdwASG9lHmNLGEVQNBqNpLNPa40vvvgCNzc3Mm7cB+89JpMJnj17huVyKfPbNA3Ozs6kZzSPLM2dnuxlpGOOsZzz+VxgFsHg5eWlQDxGl7I/dDKZ4IMPPhBHI/eNfYWMg+26TuaG65euz+l0KqCODs+6riVGl649wnOOXQ5TeZxc/3QbEoA659D3vcwl3YyE9DxmnjeDwUCijnOX53q9FkjK+Xj//ffx4x//GP/8z/8sNxJwfwDgiy++wNOnTyV+mesnhHDkRCTMm81m+PrrrwVcs+eUQI+fA33fY7VayZjkTtztdgsAmM/nR+t6OBzK5waBLN+D0a/sn+V+5p89nD9jjMwxgSLha+6O5pojFG3bVm5GYG8lu24JSVerlZzn3Aeuq6KioqKioqKioqKioqKioqKioqKioqKiP0zvDCrZj0fnICEREGFTDl8IDXKAwNcSimw2G6zXazjnMBgMxFFGyEHHHeNYu647gjuEWsPhUN6nrmtUVYWXL1/K83IwSeB1qtMITT7GYyAgIRRjnCgh1mAwwGg0AgABKwSubwMaOaS8L8Y1fzzvw8vBqjEGw+EQw+HwyNlKxx4BVR5NSgce3WnT6RSr1Qq73U6AztXVFebzuUCnzWaDuq5xdXUlUPF0n8/Pz/H9738f6/Va3IR0Ap7uO6Ee14UxBvP5XCDrdDrFaDTCdDrFYrFAVVWYTqdomkYcfxwXwsG2bXF+fo7BYID9fi8wimOQ91rS4cd9I3wCIJCTADWHrk3TCMgkXFwul1gsFgL9CEidc0eAjHB0uVxKz+F0Ov2tflXC0ul0KrB7sVgAwBEg55ycn58LuPTe48GDB/jOd76Dn/3sZ78VrzsYDI6OaTKZSB8su1cJHTm/7AelY5drjvHKHC/vPabTqYDJ0WiE9957T86Z1Wol0JjHwphguhyrqjpyc06nU1hrJc55PB6La5URsvnaZqdq13UCPff7vUQx85zN45l5XHTe8ri43Txyl9vmZ01RUVFRUVFRUVFRUVFRUVFRUVFRUVFR0R+m/5ajks6ow+Fw5Gqk240Ak+4xuuMYH0rgQ+dh27biXCQkJGAimGIMqdYaDx8+xH6/l3hJQhMCobZtBcwQRBAy0KXG1+axr/ljjLIkAGMfHSNI2WvH9yeQAyBOLO4PHWr3Qck8tvXUZXnqoOQ+5rGUhKUcTwAC8gAI7COYMcZgNBqhqipxmuVQlc4zdvgRIG02G4FZdFye7hsQ3XLPnz/Hv//7v+Pq6gpN02A+n6OqKqxWK9m/HDzT0UnAtFqtMJ/P8eDBA4mDJWjt+15AXT6ehGyE0Iz8pMsVgKwFQmOOA/eBLtgQAtbrtfRH5s7M0WiE0Wgk4I19oHSi7vf7o+MjVOf8bLdbrFYrcf5qraWfkp2NjHz98ssvZczz9cd1rZTCeDxG27aYTCbiciSc41z8+te/lpsJQggYjUbo+x5fffUVHj58iO985ztH0bpcW6vVSm5I4PrJoWsO6kMIWC6XuL29RdM0MhY5PJ1OpwL6GKtM8Eu3Ks+rfJ1ynXCs6dDkGE4mEyyXSwA46rXkzQl8j+12K89jHDA7SPnfYDA4clNrrQXMUrzpgp2fRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUV/mN4ZVBL0EcIQjBBi8Mt/isCAMa50IOV9jnQx5X11BAUEfAQ0dLMRRAIQYMBt0tmVu6i4jdN41/tAJY+F+87jJgAhMOn7XoAmt8uxqesak8kEAMQhyPf9XeN7+pw8tpadenVdSwTvKSwhSB0MBnj48CFms5kAH44HYQu3v91uj+CsMQbj8VgcdpwnRnRyPvlc7vNoNMJ8PsfXX3+N6+trTKdTPHr0SMblcDhIdCkBFMeFc0bXH8EkwaJzTlyLjHCt6xrz+VzifhkjDEAiRTkH7Dvk+1lrBWhyDXP90U3ItUmYyuO/vb2V9cxjGQwG0kfJHsT1ei3gkq5Abns4HKKuayyXSwHkbduKs2+xWMA5J6CZ+8V54jwSIgKQc6aqKlxeXuIHP/gBvv76a+x2uyN4aozBy5cvMRwO8eDBA0wmE5l7dlISxPJcYHwzb0rgvPPvdGZyH3ges0+W5w0A6VHlnORxqjzPuNZzYEpQzGPlDQH5/PHGhdFoJPHAvKGC48f1zJsaOD90neafI1w/Ofg8dSkXFRUVFRUVFRUVFRUVFRUVFRUVFRUVFf3+emdQORwOMZvNxP3U9z3W6zUmkwkmk4m4oPq+lxhH55z06BHq0JHE5xJs1HUt0AWAuAABCPxZrVYCj/KoUzoErbUSVUnlIBK4c9URAuZuSiqPi81dVjk0fJszcz6fYz6fH0GoU5fkqcMyd1aeiu9HqJTHpnJ/OF78czKZ4PHjxzKudK2t1+ujONkcJjPeljAt77z03uOLL74Qdxwh3e3trTyf7rNXr15huVzio48+wtOnTxFCwOXlJRaLhbja8g5AgiP2WVZVJa5GbpNg/Pb2VsDSYDCQaFiuHcIqOuR4nFxrBGObzQa3t7dHHYkEwFxz+/0eh8NBjpeO4sPhIC5eQtvLy0sBmuwBzTsnGUWbj3vTNDg/PxcgyV7Ouq7x9OlTgW6MhOVYcS3SAUoHMp2TdFQ+efIE8/kci8VCQPDr168xGo3kWHPYyb7X3EnM7k/eiEAwCQDr9Rrb7Vbm4cGDBxKLnMNnigCc85qDb84/Px94rrHjk/NJh6TWGjc3N+Lc5H/j8VjGiPPFc5DOU563Nzc3EkU9Go3EdZk7vFerlYwV95nxr6WjsqioqKioqKioqKioqKioqKioqKioqOgP1zuDyt1uJ04ourQmkwmm06m4kxh3ScjAvxMkEVKylw+ARFvm7kT2xhHe5J2BBB0EonxvRpre3NwItMuBI4AjIJk7JgkvcnhGqJG7SPPeTTqtclfWcDjE48ePMZlM8Itf/OLIuXifozJ//X37Syca+w8J3d4GPRl3SuhHODccDjEejyXalGCREb3D4RBnZ2cIIUgPJXsICX2++eYbDAYD/PCHP8R3v/tdDIdD/P3f/z2+/vrroz7AxWIhgO/58+do2xbD4RDT6RRv3rzBer0GgCNXI/9NdyIdcITfjGHdbDZQSmE2m2E0GmGz2UgfZg5xCagIr+k0zB2kDx48EAfw4XA46l8lRNtutxJbXNe19EwOBgMMBgMMh0MB7QS6dV1jPB5jPB4fuQ4JHQEcRRAz8pXriRGqOTTu+17W4evXr+X84LEul0sBapvNBtvtFpvNBg8fPsT19bWMkdYao9EIP/nJT/DXf/3X+N73vod/+7d/w9XVlZyHhH/r9Vr2lzcUMBqWjknGu97e3soNC7k7ervdilt0NpuhaRosFgs5HrpLp9OpjEUeDUxwy9fmnyOMgNVa4/z8XLorV6vVkXuV8z0ajcQNvV6vBaTy/Tk+PO/G4zG6rpNzktCUTlm6O4uKioqKioqKioqKioqKioqKioqKioqKfn+9M6ikc5EOMIIfgqX8i352+d3e3mK/30sM6H6/h7VWugvX67XEunI7jP4k0DwcDuJeuri4EDBHiMKuvq7rBFg55466DBlTeuqCpAhHCGPyTkiKLraqqgT0EbbQ8ff8+XN89NFHEkV62qeYg8lTcJlH0uYgkT2Y3L/TaFrgLk43d7POZjOBgIzXPTs7Q9M08m9CYHYkcn+Hw6FAurZtsd/vjwDwzc0NXr16JcD6wYMHePTo0VGHZVVV4uYEIDDu8vJSjoNuTo4VHZGMnjXGYLfbSbch52y/3+Obb76R/Tk/P8fl5SUGgwGWyyWWy6U4B/f7vUDx5XIJpZSsR47ver3Gl19+KWuXEJCALoeTXIPcLuHgfr8XkFdVFR4+fIiu62QcZ7MZZrOZHC/jbQktCd8IPfu+FzDLuFSuD4JV9pAul0v0fS/OWa01njx5grqucX19jZubG0ynU/z0pz/FX/3VX+GnP/0pnj9/DueczCtdrMPhUAA5z086Yne7HXa7nTgpeTMCj4H7T4dzHvNLKL3ZbDCZTAQg5z2wfD1/xtc0TYOrqyvpr8zjnhl127YtPv/8c6zXaxkLxusS3uedn6PRSFzJVVWJi5M3UTRNg/F4jM1mI/t2OByw2WzEuVlUVFRUVFRUVFRUVFRUVFRUVFRUVFRU9IfpnUEl4zOB6Hikm4yOMfYQMjb0cDgcRUnSgUVHFmFi0zQCLQnKCAa4zaZpMJlMMBgMxC1FMJQ/l5GahBEABKLmnZI5KMzh5SlYJHjNISLhGF2cAKRb8cmTJzg7O5OI09whSrBB5959rki+P52ThHk5SCXYpbjveQ8jf86xZvSo916ALmM26SxjzGoet0s3JONM6f57+fIlXr9+LdGvjx8/xrNnzwReErbl3Yjb7RZaa8xmMyyXS3kfjjv32RgjMJXQidDIWisRqnQgDodDXFxcSPcmOxMvLi6OYBsdwQSJOUxjryjnO1+rACR2lOcBgT17NQng8x5MxiPngJtO3Lqu5Wd0DDJqFIhgmYCW4JSwlpCaEaeEoM456b5s21ZeR2D5Z3/2Z/IfHbFXV1f44IMPsFwuZc1xXA+Hg8wXoeTZ2Rmstbi9vZVI1t1uJ89llCudiOyRpLtxMpmg6zqMx2P0fS8gkt2ZXP908nKNcDw4Hzw3Li8vZQw4XlVVSbdnPjaMruWNFufn5+LU5VwppfD48WNcXl5iu93K+c0bMq6vr+XcYB9qUVFRUVFRUVFRUVFRUVFRUVFRUVFRUdHvr3cGlXQ/0YlH+EdIx0hFOiMJlBg5ent7G3egqqRrEoAAIsaWEuLRDUf3Vg4juq4Txx1h6H6/h3MOi8VCOioJGHPgCOAIiOb9kKcdkbkjk45RghXCFEKt9957T+Ii6c4C7uJb2WtJ4JjvH98379sjgOS+87X39WLmr2PEJeeI2wLunJXcFwJezi3F13Iu2UvKfWT86tnZGTabDf78z/8cH374IT799FMsl0sBrARRuVvSe4/NZnO0fQLm4XAosb6MIQ0hYDabYTKZHEV65mA17zskYGXsK+ebblkeex6nGkLAxcWFrCduB4A4W+mwpAvPOYflcinQm+9JByHBez5vBJN5nGgOpfOe0XyuqqoSt+pgMEDbtkdrbTgcHq21HNZPp1Ocn5/jL//yL/Hxxx+j73sBk0opXFxc4Pz8XCJVeT4xopeu5sFggNlsJl2Ww+FQ4CTXBddRDtd5jHVdi9MagIBOzicjnAk5jTHiXu37HpPJRMaG/55MJvIZwdje8XiM4XCIw+GAw+Fw9LrD4SCwmp2WeTQw93E8Hst88fOJ6/Xy8lLms6ioqKioqKioqKioqKioqKioqKioqKjoD9M7g8rcHUVnHcENgQXdjzkYYtwlY0kZn0jHknNOYIr3Xjr1GBFJ59jt7a2ABAIhvp7vvd1u8fr166OOQkIPurPo2CLIyeHlqdMxV94fmfdSeu8xmUzw9OlTeO+xXq8FPrVtK72FuWMs3yaAI1gF3PU15nGguTM13w77IblfBDUAjtxsw+FQXKncPqNJCWMIgDkOHNfFYnE0To8fP8YPf/hD/PjHP8Zms8GHH36IR48e4cWLF/jggw8wn88xGo3w5s0bnJ2diYuQDry+7zEejyXGk5Dp/Pwc2+0W6/VanHCEpIfDAcvlUo59v99Lx+ZiscDZ2Rmm0yk2mw2cc1itVvDeYzAYYDQaSUdk13XSL0lIS2hIIM4o2hwc0o1L9ykdgQRYXEuEk9vtVgAY1yljZAkDp9OpAE+CV8bOAhDXXtu2ODs7k3XP6GV2VW63W4G77HUEION6e3uLX//613j48CEGgwFWq5UAbULn7XYrnZIAJJ71tMeR2yTsJcCsqgpd12E4HMqNC8YYGQPnnPSf1nWNs7MztG2L5XIpsbo8r3a73ZFj8vb29qgbl/Ow2Wxk/tgDynOONxOwK5PnAONxb29vxfmrlMJ4PIYxBtfX17i+vpZI39lsJt2Yl5eXMre8GaKoqKioqKioqKioqKioqKioqKioqKio6PfXO4PK6XQqkKOua/w/7L15tCTZXd/5vblHRkTu+d6rV9VdiwRIQkhGmBGytbRo29hgs82YMeAxghmwDXjA9rCYwSAOcwYGD2D5cAy2sdjFwLAZGzAeN7QYs8wwNgJaqHpRd1X166q35BpbZkQud/6I/P7q5uvX6qontLR0v+e886pyibhx40Z2Z33i+/3WajWJWgQgLknXdbciGAlV+I/7hEC1Wk1AwXq9FuckARD78ur1uvT1xXEs7yeEiOMYQRCgXC7D932EYfi8GE7TUUlHnAn+CARNuAncjVXlYwQi3Bb3U6lU0Ol0BBx1u120221Mp1Nxlpqxnaf7KSuVigARduLRucl90hlpwq/T21mv16jX6/A8Tzr5HMfBaDSC1lp6NQmYCY8JKnksnDM6W9vtNqrVKpIkQZqmuHjxIj73cz9Xeg7p8vuiL/oivPnNb8Zjjz2G973vfQjDEK1WS7pD6/U6siyTsSwWC2RZhlarJUCakZ90WfLPWZZJBCrBEmNpgyCQdcnzWywW0W630Ww2xeUJQEAp1wQ7GSeTCaIoQpIkAran0ym01vA8D81mU8ZsOgapKIrEiUp4uFwuxXl6uoeSPYqEoWmaIgxD+L4vcatRFElPJQF9GIayjswbBszOTM5DuVzGzs4OwjDEzZs38cmf/MkyttlshkajIRHNACT6lWuSkb10YXJNeZ4n1xmBL6/vYrGIZrOJbrcrkJs3L4RhKDHO5r4ZXbxcLuUmBu5/sVjIvBQKBTlfBJaMy/V9H6VSCaPRSDo86Qydz+fSz0pIz88a3jBBwBlFEbTWaDabst5d10Wj0UC1WhWnq5WVlZWVlZWVlZWVlZWVlZWVlZWVlZXV/evcoJIuxziOpd/NBAhxHCOKInHPZVmGIAgwmUwwn88FgtFlRcgXx7G46mq1GtI0FQBzfHwscJEOKQJFwiQ6yeicowuQTitGRdK1eNqdSPF1dG3RaQVAXHaEHISkdHXSjUXIorVGEAQCeRgdScACQMZApxdB1Hw+F2ho9n4SIBHA8DehFyEfXWUci1IKo9EIWZZhPp+Lcy2KIoRhuNWnSIBo9v5xbAAEVvG1o9FI4Bnnq9VqYW9vD4eHh5jNZojjWHowoyiSqFATVBIaMnLVdMryNzsuCbH5+Gw2kzUxmUzE+Tufz8WFSYctXaqnwRj/XKlUpHORzy2XS0wmEwRBAN/3BZSWSiVZz2bkMLtbuWboBmTsKaEiY2zZX7parRBFEcbj8Vbc72w2QxAE2NnZETdgFEWyf8Jo3ijA6FQ6nQmRn3vuObzvfe/DK17xCrlWG40GDg4O8Md//MfiDg3DEI7jSLQsHcJaa4lrNaNxObcE8oSXdItOJhMUCgWJdgWA6XSKk5MTZFkm+xuNRs9zmhIy0onJeadjlteV2ZtJJy2vNzoxq9Xq1nkywTEBulIK0+lUnuf1y/kyI5ItrLSysrKysrKysrKysrKysrKysrKysrK6f50bVNINWSqVJHqRMIsxlIzXNB15s9lMHqNrjjDRjERlfCzdiYRFhJwEdfP5XFyFBIl05LHn8LTTEIDAPkI+swcSgIBLAlS6y0znHI/JhF6O46DRaADAVryp2TNIQEpIyv2xa5EuOEJLE4JwTOw35DZMdybdZezQazabcmx0pXEO+Gc6PDmPnONqtXqm04zjdl0XnU4HruvKezmvjLktlUrwPA87OzsCSukw1FoLlOX4GAdK4Ok4jkAyjpfQiXNGoLper+G6Lmq12tYa5T7Mrk92JfK4uQ4Jgwn/CKrZz0igzSjW1WqFSqUC3/fleAlRy+XyVvwo90l4yWuF57DdbsuaAXLQF0URKpWKwEKeFx6Xua44Xt/3EQSBxLFyfdVqNfR6PYxGIzz11FOy33q9jk/6pE9CpVIREM3zQQcn3dDcFwBxGdKdy2vhrBsBeAwE6avVSuJUl8vlVqwvndLNZhPNZvNMEM2bIPgeniPGFJtdofy8qVarchxAHqPLc1iv11GpVOTaMKOTq9WqgOksy+RzzLwuraysrKysrKysrKysrKysrKysrKysrKzuT+cGleyeY/+d2dtHJ129XsedO3cAYCtOtF6vS6cjewIJ5RjlyG3W63WJZQyCQABVpVIReGGCs0qlgn6/L5CCcaUEJmZMKrdlOjRPR8QSuNRqNXktAIFXjBY1IyS73a441+r1OsbjMTzPQ6lUEuhJsGNGx/JxIAcf1WoVruvKnNMtCUDGQSDL80AYt16v0e/30el0UK/XZZxpmsJxHJRKJfT7fQGArutK7yFBGkEQIXStVkOlUsFkMoHWGo7j4MqVK3j1q1+Nl7/85eL8IwTiXB4cHEApBc/zUK1WBS4TfhFK0+XJmFICa7MLlfCIUJBj1FqLG5dxpISe6/VaonTp4DThKF14dCJGUSRrhrC7WCxKjHGxWMR8Phd3IKFwtVqVOapWqxIb6nmevI9gbLlcotlsbsW3drtd7O3tSfwp9xtFkQDZ+XwOz/PQbrfFmQhga/2u12t0Oh0Bo+12W663YrGIixcvYrVa4caNG3jsscekb/Hy5ct44xvfiJ2dHdy6dQvj8VjWPNc04S/hMZ3MZhwtYR7Xs+d5so6VUuKuPj4+RpqmcmNBHMdbMa2MWKVTlT2SnU5H9smOVd5EwGuWn0P8rDG7YcvlssyX53lIkkTiq+l85Vy3Wi15nDdMDIdDccYqpcR1a2VlZWVlZWVlZWVlZWVlZWVlZWVlZWV1fzo3qDQjOAmmGFNKKEGXIZ1ShHuMhw2CAFEUCdyhM4quLfb3Eb4R4NRqNdRqNQENBICEBYQUZlwoH+PzZtQjgQrhBV9jOizP0unnCEWbzeYWcDV7MIG7ELRYLEpPHqEY58vcHl13hFB0us3n8y3HHrfN7bXbbenZ4/sJlwg9GY/JfdFlyfkiBHIcR0DfeDwWCNdut9HpdM6MsOV5m06nODo6EofcaRdpmqZbkIowls41ut0IwjhGwkTCJXYr0uEHQNYNo0Xn8/mW65BAiu5NRgSb3YdcF+x/pKOPDlMTmhO+A3djebnWCckrlQr29/fRbDZxdHSE0Wgk628wGGAymSAMQ3H4EbwxepTQslaryVzW63WBsiYk5bgJEAm/d3d3MR6PcevWLQC5M5bOzYsXL+LmzZs4PDyUKFrGN3MeG42GzA+P0XVdGSfha6/X24pZdV1XgC4B+mKxkLnk+ef1sVwuJWKYsaw8r4S4AAQ4pmkqcJNRvabzMkkS1Ot1Afs8p4wFLpVKcv3yJgh+VhCUcl3TQb1araRb1MrKysrKysrKysrKysrKysrKysrKysrq3nVuUBnHMarVqvzDPfsFl8slarWa9Fd6niexl4RAtVpNwBfBFkECnWSEGPV6Hev1WmBnpVKRrjrf95GmqbiqCGKAPBqUANSEaKdlOivZDUjAQxhBsEkYSADL583YRzoA1+u1gCTG2hKqEbYVCgX4vg/XdQW28TflOI5s0+zEJEBL01RgGR2N7CIkkCHMJHDrdDoC8gCg3+/Ltgj2uC+eL46ZUaTs7lytVgiCAKPRCK7rnulUZNdgo9GQ88loz9lsJpGarVYLu7u7EplK+LxarcQlya5CdiASZrFHkB2Ei8UCzWYTly5dkshh9hUSuHKNcP0xnjdNU4loLRaLAr4Gg4GccyCHg4zV5Xlj3CqArQ5Dc92aztIoipBlmcS3BkEAz/Owt7eHwWAgjsNqtSr9mvV6HcPhEIVCAY1GQ0Afz/dgMEAURQIteS74m7DzZS97GcbjsWz32WefxWAwwIULF7Czs4NnnnkGQRAAAI6PjwXGEZTSCcm1Sbfh8fExSqWSjHuxWCCKIhweHqJUKmF3dxdADgk5ZroTlVJot9tboJsAEoD0YrIjkp2m5mcAAHFompGuZqSsGb+8Xq8RhqFEFHueJ+eOnZt06PL6580SURSJA9jKysrKysrKysrKysrKysrKysrKysrK6v50blBJuEDIx3+4J9iazWZwHAd7e3tYLBYIwxDT6RRaa4kYJVxxHEfiMpfLpQA1rbVAnNVqhV6vh3K5jMlkgvl8Lt2PvV5PHFEA0Gw2BaKaIJGgkh16ZrxrpVIR6EE4yS5IQjuzk9J0U5rdkIyepdOK7rB6vY5isSh/5w9dl4vFQgAInYUUY2dNkMofwhqeCxMisROQUNJ1XXFxVqtVpGmK0WgkPX50FjL+FYDEr3IMhEFZlqFcLuPk5AS///u/j+VyiZe97GX4hE/4BJTLZUynUxkXgVSj0RCXpNZaeha5ntg1Sbckx1woFBBFkbgeeb44JrNTkmOcTqdYLBa4cOECKpWKrBXuiy5OPkbYR3ekCdRN1xyf41gJLU3HLPtDCUjpvOMxFotFhGGI+XyOIAgkYrXf72M+n6NUKkmX42QywWQyEccxI265TlerlfRacp8E1lxzBN90QhLeV6tVdDodAaa3b9/G9evX0ev1cPHiRVy6dAmPP/44kiQRlyj7HaMokpsEeMyck0qlIueDoJHAj+5eAkdGC5vnlj2UjUZDbnrg+VmtVpjP51s3QpTLZXGQApAoVsLP5XKJOI6RZRmazaY8zvNBsM0bJ3huTDd2qVSScRBiEnLzM8XKysrKysrKysrKysrKysrKysrKysrK6v50blDped6WW4xAikClUqkIhCQso/uNIJNAplarwfM8OI6DKIownU6RJAkcxxE4ww5FM7KVTjuOwfd9LJdLrNdrBEEgUZWEfgQ4hHzAXcBkglfuk/sioDrLNWVCSv79NNAkkDGdlPw5vS3G3tKdSucfnZE8PjOiljCVfYHVahXtdhsA5HFGxcZxLABzuVwKqGQE6mw2k+cJmugsNCNnCVWXyyUmkwlOTk7wwAMPyHHfvn0b73nPe+ScNRoNAbDz+RyNRgPtdlsgEmNT5o+A/gAAIABJREFU6SzUWmM+n8N1XXieh9lsJmNlDKzneQI26ZQjJOQxm85N0xHHeeN5Y/RotVqF4zgCpwqFArIsE0hlRsqyr3E2mwnMpZMPuAv1zGNuNBqyTTPy13Tscru+72O9XmM0GgEAGo2GAGaem8lkIrBwPB7LOuL5I1jjuqKbkuuo2Wzi5OQEURRhPB7j8ccfx6d8yqeg0+ng4sWLODg4wGw2ky5Rzi2jfFutFjzPkzXquq5EARPu8TqgS3o8HgusJPjmMTGylf2bnFNCQ14zvB7YDUq3NtcNcNeNnKapwE/CXPPGA8Jh3qwQhqGAUbq7eUMBbyQIgkBiZsvlsjh8raysrKysrKysrKysrKysrKysrKysrKzuXecGlYQodNwR3JgOpFKphOFwCMdxUK1W0e12xb3FHkF23LHXkm41wkPCBUKjJEnEbUW4Q1jT7XYF8jA2MwiCrf640z2VwN241mq1KsdgOhf5d7rpTEcjx0CQqZTC8fExKpUKms2mRLLSwWmOw4Sc3A5h0GlYyYhauvjMsRHI0Z3ICEutNabTqfRCHh4eCgA2wQpBDqEkt23Gr8ZxjGKxiDiOkSSJnLd+v4+rV6/i8uXLeOCBB+B5HpRSSJIEv/M7v4Pd3V285jWvged5uH37trjYfN9HvV7HaDQSSGme22KxKPuhC5DQkZ2cdMASwjHCdLlcihuvUCggDEMsl8utPlO66giS2+3286JAwzAUcEvIyQjQJEkEcAVBgNVqhW63C9d1BZS5rotGo4HRaCTrZ7FYwHEc6VBtNptwXRfj8RjT6XRrbLxu6FSm85UuSbqNb9++jWKxiMlkAq019vf3ZRyc01qtJpCQ57Rer8t5CIIAYRjixo0buH37Nvr9PnZ3d9FqtRAEgcBpwj06EE3AP5/PsVgsxF29WCwEnprQdjweYz6fbx1ro9GAUkriWtkJuVqt5NybfbIAJNZ2sVhIhCxdsoSxvOZ83xcoya5SziXjdAm3eQMEXcDVahVJkqBQKGB3d1dupuANFIy+tvrYlVJKA3i31vqhj/RYrKysrKysrKysrKysrF4aUkr9KIAvA3BVa33jIzsaKysrKyurj16dG1TyH/aXy6VALnYILhYLcffN53PpjiRQoiPSjFklVKFTj12JBJQEeQSZhIJRFG31FLKLznVddLtdASmnRZeX2VG5Wq2kx45OSsbQmlCWxwBgKwLW8zy0220ZOzsb+UMIBtx1d5qPmZCXsbAEcgAE4JquT8636WjlHNFpR1DFcXC+1us1ut0uhsOhdI7W63UBk4wRJZRTSmE8HosbtlgsotlsyjwTpBGq0UFI+ERY5DgOwjDEZDIRgOi6rkDQMAzhuq6A03K5LM5AABIlGscxXNeVmNQ4jiUKlpBwMBhgOp2Kg5Nw3Dyv7FNkTCshImGc2XfKeWN0aaVSwZUrV3B0dIQkSdDtdtHpdCQqlRCZ7uL1ei0uQ26rXC6j1WoJoJvP5xiNRhJjS0A7nU5RLBYlipagdrlcwvd9gXMEduzL5DoIgkAAKADpFW21WgjDEEmSYDAY4Mknn8Tly5fR7XZx4cIFnJycIAgCWf/ValX2x45SXlO8Nnntco0TKvq+L9d/s9mUaGZ+HnCc/Kyg63S5XKLVaqFUKmE0Gkl0rekY5fwR8NN1TVfuYrFAEAQCUeni5DybUHd/f1+uoyzLcHh4KP2rvAmh2WxK56d5M4SV1f1IKfUogLdorZ9fomxlZWVlZWVlZWVlZWVlZWVlZWVl9TGuc4PK4XCIWq0mMI5Qi+4/xmiakGwymWA8Hm/Fip6OMU3TFPP5HFprAZ90VTEGktGZhEEEd2maCmj0fV/gE51zpoORgITuQdNVyYhSM/qVkPQsRybVbrfR6/UEINVqNfT7fXieh4ODA3GPmVDG3IYZR8oYWI6Dv/les6PwdIwtAAGJWmtxsC0WC4lgZVdgu91Gt9sV6FSr1eD7vhxDo9HA3t4eoijCcDhEmqbiLmM0pu/70sFIh1qapqhWqwjDEKPRCFmWod1uY3d3d6srNAgC2VapVILv++J6azQa2NnZESC1s7MjDtP1eg3XdeH7PuI4RhiGAilnsxmq1aocc7VaRavVkohOpRTSNBXIRLBFYEVXHbsYsyxDr9dDo9HAcDgUmElXKqNi2cPKjlDuZ3d3V8A9zxPXLbs+HcfBnTt3cHR0JO5Bgkczetj3fXHFOo4jMJIdj6VSSTpAuYYYkdrpdOR6ZP8lz6XjONL7eP36dbzyla/E6173Oly8eBHPPPPM1tjZ83jnzh0kSYJGowHP86SzkeevWCyi1+vJdb+/vy8uR84HP0PCMMR4PEaWZWi1WqjX66hWq1vdpexo5edKGIaIokiAcrvdhlIKvV5PXI5m7yyv61qthlarJeuG4JXrhdsx3Z+8MYKAm+7LZ599VmC3lZWVlZWVlZWVlZWVlZWVlZWVlZWVldX9qfDiLzlbp/9xnk5DgoadnR24riuuSsZo0n1kgkO6yAgACAxNp+RsNsN0OsVsNpPOQDrEAIgDDsiBIfvp6Mw6LTo0CSsBSL/jafcnAYbZRcltmLGthC58LZC71m7fvi2gE7jbY0lYc7qzkgDSfA8deIRoZpTser2WHkRCm2aziXq9LvGnplPQhEUEOfV6fStyl3CUoGw6nYrrjhCK3Zb1eh3NZlP6Qtl3qJSC7/vwfV/6NbMs25oHszuRsbc8VhNOlUolAUyEYoy0TZJEXKXsuySwLhaLcF1XzlGxWBSQF0URJpMJ0jTFZDLB4eEhBoOBxL2ye9GM/uU4GMlKp2C9Xker1ZKoYrotuQ4J4Tmu2WyGOI4xm83kfPD1juOg0Wig3++Lc6/T6cg5ZYwqnYqMTaarj5CasaWMKgUgXbG8NgqFggBfgtXbt2/j5s2biOMYvV4Pu7u78H1/671cw2Y/LYEoHZDsnozjGMPhUFyn3IbWWqCp6YK8cuUKdnd3JfKWj3PuGfPK+SdE5GeDefMDITLXk+/7cqMDXZ21Wm1rTpRS0kHJY6BTOwgCBEGAOI5lXkejEYbD4Xk/Sq2srKysrKysrKysrKysrAwppT5XKfWIUuqOUipVSt1WSr1bKfXVm+d/WimllVKfcOp9P7Z5/JFTj/tKqYVS6rfO2NcXK6V+Uyk1UUrNlVLvU0p9q1Kq+gJje4VS6keVUs8qpTKl1JFS6l1KqU869TqNPPYVAJ7ZjEsrpW6cYz5+dPPea0qpf6CUur4Z64FS6vuVUo0XeN8lpdQPKKWe3szjUCn1y0qpTz/jtW/f7OMhpdSXKaX+QCk1U0odK6XeqZTaO+M9j27eU1VK/S9KqWc2+3m/UurblVKVD2YOzzj2v6eU+qPNuB6933m0srKysvro1bltQARVBAmEF+VyGa7rolKpSJwrHWB0PZlxpWYPotkNR0hIYDmbzQR0EjzRcUgARLjE+FKCBkI64K6D0eyeNCNg6dycz+fipDwNUkxAyW0RNFWrVQFG4/EYR0dHmE6nW1Gqp4Gl6Ygk5DEjYvk84aXZeamUko7MLMsEkjKykmCo3+8LJFMbxytdrdyf6SDl/GqtMZlMxH3GGNdyuSxwkwCIkGc6nWIwGKBarWJ/fx8ApDOU8JXxuoROpjOUYJUglZGijPnlfune5PFyfZhuUkaCBkEgfaFZlsFxHFmfjUZDeid5PgmuCN4AiDuXY+MxE/ayO9M8T0AObtlzSIcnj5XwGcgB4+7ursTsuq4r8JfRwVEUCeA1uxiBuzcPEP5xHUdRJPNrRg7Twco1NhqNkCQJJpMJnn76ady8eRNXr17Fgw8+iNFotNW1CUAAKeeAkcC8XnjdlctleJ4n0bx0SRLKnpycyPY4PyZw5HngOeW64PXOzyHCaAAC7uv1OhaLBXzfl0heOooByDnkGqM7m2PmGHjeoygS8BnHscQSx3F83o9Sq3uUUuoKgGcA/BiA/xXAdwJ4K4AegM8E8FsAvgrAfw/glQAUgD8B8E4A/0JrvT5jm68A8I2b918AMAXwOIB3aa1/8B7G9A0A/jcAvwvgr2mtR5vHXw/gGwC8EUAHwBGAXwXwHVrr26eOh9sy76ixfZhWVlZWVlZWVlZWVh+XUkp9FYB/AeAQwL8FMACwA+A1AL4cwD8H8AiAvwHgYQBPGm9/ePP7zymlalrr+ebvb0H+b6CnAeY7N9s8APDzACYAPgP5982HlVJ/UWu9NF7/lwH8AoDyZmxPAbgE4AsBfI5S6q1a6/+yefl3APh8AK8F8I7NtmH8Po++H8CbAfwsgH8D4LMAfD2ANyml3mgcL5RSrwPwH5B/J/31zbh7mzH9J6XUF2itf/WMffx9AH8JwM8A+PfIv9d+OYCHlFKv11qfnPGenwXw6QB+DsACwOcBeDuAP6uU+lxtuD7ucw5NvQPAmwD8CvLv16sPPFVWVlZWVi8lnRtUEgQQZmmtJfJyOp3i+PgYWZYhDENxQRFsTKdTBEEgwAfAVgxslmXisGy1WgJcFouFuN3YFxcEAbIsE9DpeR4mk4kAEm4HgAA+jpeQiPCEcZsEKXQUckxpmkq8Jf8bS8DH4/M8D1prJEkinYKENOYYCBhNZydhkglcCDXNv/PPnDsA4kokjJzP5zLPnufBcRwBQIRVBDDsyaTjkC459irGcQzP8xBFkfQrslexVquJA5bbpcuMzj86QLlPQizz+AgElVLwPA9hGEqUMGNky+UyZrOZrKcoilAqldButxFFEY6Pj+G6rrgYCW0J/qIownw+3zqHhKaMh+V5pgOP8JW9q8vlElEUba0lukwJr8ztM8bYdB9zffE46axktGu5XEYYhgjDEEDugmw0GhJdq7VGo9GAUgonJydb7lNzXXE9OY6Dbre7BeI5fjohCVKfeOIJJEmCp556Co899hiuXLmCS5cu4cknn8R8PhcY2el0pNeRzlquOwJUXkvdbheVSgXD4VBgcq1Wk5sX2N25WCwwGo1w584dcddy277v4+TkBEmSSM8o3b5KKTQaDYnFVRtn6MHBgZwrzjevG2U4MNnbymuQkceu68qNDoTz/Lyo1+uYz+cCSudz+S5g9aHXywD8PwCeAPBTABwAAYCfAPAlAJ4F8MMANIAvQP4l9o0AvtTciFLqcwD8nwCqyL98/TSAFvIvkd8I4AVBpVKqAOCfAvh7yL9gfSm/ECqlvgLAvwSQAvjlzXg+AcD/AOCvKaU+Q2t9C/mX0+8A8DYAlzd/pm7c55xYWVlZWVlZWVlZWVl9rOhvA8gAvFZrfWw+oZTqbf74G5vfDwP4oc1znwTgIoD/C8BfBPDncRdMPnzqfVBKvQ05gPtF5N/pZsZzbwfw7QC+Bjkgg1Kqjfx7YwLgzVrrPzFe/2oAv4f8u+jrAEBr/fbNDaqvBfBPtdY37nsmnq8/D+DPaK1vbvb7j5B/r/1C5DfLfufm8RJyeOgBeKvW+t3GWPcB/D6Af62UuqK1Tk/t468AeL3W+g+M93w/ciD63chvDj6tVwL4ZK31ePP6/xnAbwL4qwD+JvLv6/c9h6f0OgCfqrV+5oznrKysrKxe4vqgHJWENqYDrVQq4eTkBIvFAo7jiDOMUITOJ8dxkKYpxuOxwKdKpYIgCBCGobgXZ7OZAE4T2tGpSWhD1yKjMdlx2el0ZJ+mA5Fgj1GdpvuuVCoJeCGkIMAiJDF7Ltnx12g0xMEFQODUarUSWGO6KOkaM/smzd5Mc6ym6xI4uyMTgDjGXNcVsKqUwng8lk5JxpnSccqeSZ5XQloeg+u6GAwGCMMQaZpCa41yuSzHS9hExxtjMSuVCo6PjwUWhmGIk5MTaK3RbrdRKBTknO3t7UnELGNgJ5OJODcZ80lQynllb6njOOh0OgJHx+MxoihCs9mE67oyz5y/xWIhEbLsJSSkoou3UqlgtVohDENordHr9QQK0kVH2Lazs4NSqYThcIjFYoHDw0MBaOxV7ff7sm7UpuuxXq8jjmNZh/V6XeBbEARyHURRhDAMMZlM0Gw2kWUZgDzatNlsCqAm5E6SRByg7XZbolubzSYWiwUGg4GsGe53b28PBwcHmM/nGA6HuHnzJsbjMbrdLnZ3d3HhwgXpAiV4pouYNx7wOqBT14x7Ho/Hcjx0MBN2M061UslTQZbLpThPj46OEIbhFgR1XVcioFerlcwze0SjKEKj0RBXJedwtVoJGObnEdc/r38ACMMQg8FAXLCE5bwuPM9Dt9sVeMw1afVh0RsBfJfW+lv4gFLqi5FDyj9A/mUn2jz+rQDeDeBLlFK/orV+1+bxHoB3If9v4GeaX9o2z196oZ0rpWrIAekXAvgBAF9Ht6ZS6hORf0m+AeAtWuvnjPc9jPxu1ncA+AKt9QTA25VSDwG4rLV++71OgFLqP7/AU6+41218qPXoo49+pIfwkhRvULHz99KUPX8fXeL5sLKysrKysnpJaoncmbclrfVg8/tplUeovlUppTaOPcLIb0OemvMwtkFljByEUV+32c9XmJByo+8E8LXIb3h9x+axv4X85tavNQHbZjyPKaX+FYCvV0q96vTzf4p6ByHlZr/rTdLP5wP4is24AeBzkN/k+7+f/r6rtb6tlPoe5DffPozcnWjqJ0xIudHbkUPdL1FKffUZcPM7CSk3+5hvIOpvbsb1E5unPpg5/J77gZQf6Hvzer22/89+DtnvO+eTnbfzyc7b+XS/8/bR9L353KAyjmNxVDGacb1ei7OIYG48HiMMQ3Gcua4rzrgkSQRIuK4rEA/IgRujIRkTWSqVMJvNxCFlRqSanYkEJcViEYvFYgtSEqgyfpYRkmbMJB1v5XJZwBwdpI7jbHUW0hXa7/fheZ4cP91thJiM5TRBGcfG/TH6khAKuOvYBCDA1XyOj/M5wmN2Epq9fowBNTsTCS8dxxEn4PHxsRxXEAQCouheZbcm+yLpSCWEo8PQcRyMRiMZb5qm4rAl5Gu1WqhWq0jTVM59EATi8uSchWGIfr8vHZTtdlvOJWGZ2YPJ7ke63xg7y31QPJYsyzAej9FoNNBqteRYJ5MJSqWSOBJ5TnmuZrP8/2U5X4SY7XZbXMbNZhPlclnGzkheAOJEJZSfTqfwPA+e5wl45HyNRiMopTCZTJBlmcxNoVDAbDbDaDRCoVBAq9UShzBvKAiCAI1GA1EUyRojECaY393dxbVr1/Dkk08iDEPcvn0b169fx+tf/3rs7+/LuqhUKhLnbDpVGfvKKFrCdAJ/M0Y1yzKMRiPMZjNcvHhR4noJdRkpHIYhptMpkiQRAN9ut1Gr1XBwcCBzOJvNcOfOHdTrdQRBgCRJ0O12USqVJMKV0JxAmp8DdHPymgUgjt31ei03H/A6pqO4WCwiTVPpy7T6sOkI2+5DIP/iAwDfTEgJAFrrWCn1TQD+I3JH47s2T30ZgAaAf3b6S9vmfQdn7Vgp1UHukvxzAL5Ja/09p17yd5HH13ydCSk323xEKfXLyF2Vvtb6o+f/BKysrKysrKysrKysrD569FMAvhfAnyil/g/kN5/+9hmRo7+B/Lvgn0F+0+pnArijtf69DaR6GACUUn0ArwbwH7TWi81jdeROxwFyMHbWOFLkTkHqDZvfr904Lk/rEze/X4m8huRDobO+vz6tlHoWwBWlVGtzUyzHevkFxspuz1fi+aDyrH1MlVLvQR6h+0oA73mx9wD4T8jjWT/VeOyDmcP/94zXW1lZWVl9jOjcoLJUKm0BKsYmMpaV/6hPCJWmqTj5ZrOZxHESkNGpSGffeDzeimSkC5Oggy4oup6AvG+uVqtJjCYAcUBRhHrs+GMnIx1gPC7GpBLoEGbQcUUoZ0ZFlkolhGEoEZ6Mna3X6wAgQKpcLgucJEQFcrhp7pP7O+2qfCFwye1kWYbpdCoOTtMdyDnhY2b063Q6xXQ6RRiG0jM6m80wHA6lo9KMRPV9X5yUdI/SpUmQDUD2Q2iotcZ0OsVsNkOvl6d2zGYzOQcEqYwuZaRqqVRCHMcCxXiO6bLk+UjTFEqprXVFME3Xn+u6CMNQei+5FszXAdiKVeV++BjhPCOGuf4JRTnHxWJRYlNNNyj7QzkfvI4YmUrQyd5TwvwsyyRyl1Cb7+XNAwScjE2mo7Zarcoc8SYBwrd6vY4LFy7g5s2bmE6nGA6HePzxx/GqV70KvV4P3W4Xzz33nLhjGd/K88UYaF7rjGeez+cSMcvPDq01ZrOZHDtvMmAvLbdZq9XQ7XYFCDqOI32is9kM9Xodvu8LVE7TVAAsnauEk0AeMczjJhSt1+syB+wtVZveU8JLupvN6OTVaoX5fC7XtNWHTX94xt2brwOwBvDoGa9/N57/5egzNr9/7T72uwvgtwFcA/A36c48JX7peotS6tPPeH4HQBH5l68XurvzRaW1/rSzHt98GT8rIufDroceeugjPYSXpHjHm52/l6bs+fvoEr9TWFlZWVlZWb20pLX+PqXUAMBXA/gfkUeOaqXUuwF8g9b6/9u89BHkoPJhpdQfAngr7kK3RwB8o1KqiRxgKmz3U7Y3j/WRR7zei7qb31/5Iq/z7nF759HRCzx+iLxSpIm8ZoRj/esvsr2zxvqB9oHNPl70PVrr5eY87hgPfzBzeHjGYy+oD/S9uVAovM7+P/v9y37fOZ/svJ1Pdt7Op/udt4+m783nBpWdTkdgD+MdAUgUJx1pjUYDq9UK7XYbnU4HWZbh6aeflrhJxkgSUBHgEQCZDkPTdbharSTOMoqirZ69MAzFTWXCIQBb3YgEGGZXJeEGt0dISWBourFMCGi6+szI1zS9++/phB7FYhHNZlMAJN2mJqwxXW8cI2Ga2W15WpxLOvMYy0sAWqlUttxkhHjseDw8PITv+6hWq6hWqxJBGsexADCzW5COVx5zFEVIkgRxHGM8HqPVask8r9drOI4jXYaM7kzTVOB1rVaTPkw61ngOGSm8Xq+3YCojaQnG6CLl/HNsBJJca4wjLRQKaDabAsLjOEa5XBbQTsciIRUhsukc5LkgQGU/qdr0SDLilq5DQkd2q/LY1aY7kRCP8JpRsaaLj2uVbkSebzNelWvZ87wtMBlFEer1uqxj3kBAdzSdjLdu3cLt27fxqle9Cru7u3AcB3fu3EGWZQiCAL7vo91uS3clYTxvWOB8ZlkG3/dlnkwAzGhdgt9qtYooirBcLuE4Dnq9ngBwxtYyBtZ1XYmIpaOWx8TjNWNqHcfBZDKRzyTf9+VaYK/sZDLBbDZDu92WbRI2J0kij9G9y/dbfdh01peTJoCR1jo7/cQLfDlqbX4/d/r1H0B7yF2YB8jvDD1L/NL1DS+yrQ/lF1crKysrKysrKysrK6uXtLTWPw7gx5VSLeSJNl+AHEr+ulLqFRt3Jfsm/8Lmzx3chZG/AeAfIYeXz+unBDDd/P4DrfW93uzJ97xWa/1H93lIf1raBfD4GY/vbX5PT/3+PK31L59jH2fp9D5Ov+eW+cCmJ7MHIDAe/mDm8Pn9V1ZWVlZWHzM6N6is1WrSgzifz8UBNRqN5HF2xxUKBbTbbezs7GA6nYrjkCBRa41qtQoA4lBiDx/dWYxapBOScIPwgbBgOBwCgHTSHR0dCdAhlAO241LZQUfnH12GjHRcLpcSAbtarcQRye2wZ4/QZrVaYTqdiluLkaqMjWXMKfdfLBZlzKVSCev1WqANIaoJLvkYnaCnXZWMwbx69ao4EAkIC4UCut0ulsslhsOhdCIul0vM53OZD8aLEq5yDgCIY5YwygRe4/EYk8kESilx07I3UymFXq8n56xarUrM6mQy2YrpTZIEjUYDs9kMQRCg2WxKrKpSasu1S6jt+76MUSklgIzdkASrHCNdn3T6cp3RiUmXI+eXAFcpJVHA7IP0PA+FQkGiVTmv7EusVqvSJTmZTNDpdMQV6LoudnZ2kGUZjo+PxXlKuDsej7FYLNBoNOA4DqIowmg0krhSAno6kukU5Dyu12v0ej1MJhNxQ87nc/i+LxB8NptJd6PnefLnk5MTXL9+HQ888AD29vbwwAMP4PAw50RRFCHLMgGwdIMS2BMscmw7OzsoFosYj8dQSsH3/S3HLqEk55ewtNFowHVdTCYTAfB0rrJ3kpHEdAHTVUnHL+OAV6sVBoOBOD1934fWGq1WS64pHgtjrU0nMGEsr8fVaiVdp1YfNp315WQKoKOUKjPKh3qBL0eTze+LAP74Hvf7hwB+GMCPAvgtpdRnaq2fPmMcANDUWgewsrKysrKysrKysrKyOrc2Maa/CuBXlVIF5LDyzQB+Xmt9qJT6EwBvAvCXN28hqPxt5NGtDyN3VI6Rx8Nyu5FS6r0APlkp1dFa3+0temH9HoD/erO/e4VsvKu5eI+vfzG9BcBvmQ8opa4BeADAjc18AXe7ON+EvL7kfvfx46f20UQesTsH8L4XeM9PnHrsjciP2+y7PM8cWllZWVl9HKjw4i85W0mS4LnnnsOdO3ekEy4MQywWC3GT7e3tCfSZz+cCvyqVimyHkKHRaIibkEBwNBphOp1iPp8L+DRhFv/On/V6LRAsTVPEcbwV/whgqweTj9EZZYI/syePkBTAlmOMoG5vbw/dbhdZluHo6AhRFEk3XrvdRrvdFociozkJUrg9OuDMbfNYfN9Hq9VCr9dDv99Hr9dDp9MRYGNGwLKjMkkSlEol9Ho9+L4v88PjNuchCAKJU6X7UGst54wOP0LCarWKRqOBarUKx3EEVK5WKxwfH2MwGKBUKqHf78P3ffi+j2azCdd1AeTRtFEUIQxDrNdrAT2MR/V9H/1+H2maIkkScdgS3M3ncwRBgOVyCaUUPM8TMMi+wtFoJBCJ/YSEx1mWYb1ew3VdtFotdDodXLlyBZcuXcLu7i4ajYbMEYEqXYsEj2b8brVaFScxAWGr1UKlUkEcxwAg56pWqwl0LZfLcF1XgOtqtRLwu1qtEMexbJ8xyIPBAEEQwPM8XLx4Ed1ud8shy0h+lPwvAAAgAElEQVRX9r+6rotarYYoitDpdARUsreT3Y+8hggMCejDMMQTTzyB4XCIZrOJy5cvS/9mp9OB7/uYTCaoVqsCfHmDAQF3sVgUgMoxMiaXDl/C9Vu3bgkg5OdEEAQYDAYCQtkd2Ww2JUK2VqsJaKbLkp9RN27cwGAwAAC02210u7npLYoijMdjPPHEE3jqqaekT5UdukEQyFjZF8obLEz373w+x8nJ6aoMqw+z/gD5f8/efMZzb0b+5ei/GI/xS9tfuZ+daK1/EsDfALCPHFZ+4qmXmF8G71UrAFBK/Wl9cbWysrKysrKysrKysnrJSin1VnV2aSRTchLjsd8AUAfwdQCe1Fo/CwBa6xmA3wXwRQBeBuBRrfXpWLLvA1AB8M6Nc/P0ONpKKdNt+SPIb3r9dqXUf3XG6wtKqYdOPTzc/H7wjOM5j75OKXXZ3CeAf4L8+/CPGK/7NwDeD+BrlFKffdaGlFJv2HR1ntZ/p5T61FOPvR15ktFPn1HFAgD/WCnVNrZdA/Bdm7+a4zrPHFpZWVlZfRzog+qoJPRgHyC7Dgm7GHHZbDYxm80QRRF838eFCxcQRRGAHODMZjOJ7+Q26IBiPOZkMoHneeJkNF2ItVptC8xkWYYwDAVsUSaco1OOsZ1pmm45CPkcozUJgxjtSjBUrVbx4IMPCvhhrCmhHCErnaF0ctE5yjGZ8JD/P0a3IGV249HhGEWR9D0CELclXamNRgOj0QjL5RKe52G1WglUYWSm53niSnUcZ+u4tdY4OTkRoAXkIKfZbG6BSoJjwmjG5i6XS3Gc8rgZu8rez1arhYsXL8r5dRwHg8FAIn0JuQh0CfWOj48FSnFeCAO73a6Aq8ViIdAriiIUCgWJT+W6BSDHR0hLIMvOTToyGTnMuOM4jrfchbw+isUiXNdFo9HYAvHFYlF6VD3PQ7FYlLjcNE3FnZemKU5OTrBcLuVcZlmGVquFRqMhEbOj0Ui2xRsFuD74OnZUEnwCOTDmOWasMtdekiQYj8eYzWY4PDzEwcEBLl++jH6/j4sXLwpEZU8mISRvNCiVSuK67XQ6stbSNIXjONI3SufmbDZDpVKRNTocDqG1Rq/XE4BdLBYF6nLdcu55DBwHAHFl83OCzs9isSjnnOuZj9HhTGc0z+94PJbj4XtrtZoAWvbkWn3E9E7kd8p+l1LqIa11AgCbL13fvXnNvzZe/2MAvg3A31VK/bzW+vQdqZe01gdn7Uhr/XNKqQzAzwJ4t1LqL2it37t5+gcAfBWA71dKPam1fuLUdisAXq+1/r+Nh80vrs/c32FbWVlZWVlZWVlZWVl9zOkXAURKqd8DcAN5l+SbAHw6gP8M4D8ar30EwNcih5i/cGo7jwB4yPjzlrTW71RKfRryLsz3K6V+HXl8aQfAVeQ3vf4IgL+zef1QKfXfbMb3e0qpRwC8F3nqzwMA3oC8DsSMXHoEeTXIv1JK/TyAEMBEa/0D9zUjd/XbAN6jlPoZ5Ik+nwXgtcjn5XuMY1sopb4QwK8D+BWl1O8AeA9yyPsA8rm8BuACtsEvAPwagN9WSv0sgDvInZFvRH4uvvkFxvU+AO9VSv0cgAWAz0MOiH8FhtPynHNoZWVlZfVxoHODysFgIL1w8/lcABAfq1ar0n3I2NH1ei29cOwoJFiK41iiTgkXGMs4Ho+RJIk4tug8BHIAQSDG/QOQrj7TRWh2S/IxAFv7dRxnC1SedjyevqmrVCqh1WpJv2WxWBTQZ7o02TPI2Mg4jrdceHwPwSl/00VGMR6Wbkv2RQ6HQ+ly5PsJr8IwxHK5lDmhY41OSEZbMiKTzknHcWSeGHPK17fbbQE1BGt04PG13CeBHdcKALRaLQFaBEV08jFGl52JBFuMruUccCzsk2RkLueJvYME3jxHPCZGktIVx+0zNpbni9G9jEU1YXWhUBBIznVidpu6rot6vS6QMo5jTKdTpGmKdrst54Mi9HNdVyJtGR9cLBbRarVkX5zbarUqTr8gCOR4ef2x15JOShPYFYtFNBoNdLtd2QejegnogiDAk08+iStXruCBBx7Agw8+iOPjY4GqXLtmn6t5fdRqNdTrdcRxjEKhIF2avObpTDaBOSNY+TkCQM4Jo5cXi4U8z5hpvo43LTSbTQHKxWIRk8lEui/5wxstlFIyHs5FkiQIgkBuZuB6YC8r18FZfbFWHz5prd+llPo85HfLvlcp9UvIv+h8PvIvmD+jtf4p4/UDpdSXAPg5AL+plPo15LEzDQCvQf4F6eoH2N8vb/b3iwAe3cDKP9RaX1dKfQVycPpepdS/B/AEgDJyEPkmACcAXmFs7hEAfx3ALyilfhXADMBNrfXp2BwrKysrKysrKysrK6uPB30zcgD3OgCfjTxu9CaAbwLwg6fqPh4FsEbuKPyN7c3gEQDfufnz6ecAAFrrr9l8H/w7yLsuWwBGyIHlPwHwk6de/4hS6jUA/qfNGN8EIANwe7OPnz/1+l9XSv1DAF8J4OuROzhvIr/J9Tz6+8j7Or8SwBXkN76+A8C3aa3np/b9R0qp1wL4BwD+KoAvRz5Xd5CnEn07gMEZ+/h+5N91vx7AfwsgQl6B8i1a6+MXGNcXAfjHAL4UeQLRc8hdmN+tzb4q3P8cWllZWVl9fOjcoPLWrVvo9/tot9vS+cd/9De74czoVoI+AiOCLMZrApCoRdd1JapyuVyiUqlI1CfBFJ1UBHTcLgFdFEXSLWlGdZoxq6dhJXv/6DQjDCIYJYgxIy0rlYpsq16vCzSi25TRpXxdGIYIw1BcdgSV3PZisRBn2ulxAhD3F0FOpVKB1hqHh4dynHS7ttttmXeCU7oICWjMyFt2hgIQR+psNhMnJOFMu92W82aeOx5boVBAs9kEADkeumHX67XEqXKbdNxqrVGr1bC/vy+RoHRDmrDI8zz0ej2ZiyiKxKXKaFmukeVyKSCrXq/LsRBw04m4XC7luPm+9XqNfr8Px3EQBAGCIMBqtdqCxVwzjAwlGCTwm8/naLVa8jyjgcvlssSkOo6DTqcjrj3+dLtduK6LMAwlYpXgrVKpoNVqodvtbkXHMqaXoJ/HSBjH88obCrrdrrie2QHbbDaxv78v/ZHXr1/HtWvXcO3aNezv76PVakkXqQnwCoWC9KKy75Tr31zDXNccV7PZlGhdAtByuSzngNcf55rHUq/X0Wg0sF6v4fu+OEfN185mM7le4ziG53niZKXTkmuAXbXr9VpuAqhWq7KmeGOC4zhyXaRpakHlR4e+GMC7kXeW/O3NY+8D8L0AfvD0i7XWv6KU+rPIv+w+DOAvIe8tuY67ETUvqM0Xzs8G8G+Rw87P0lr/vtb6J5VSfwjgHwJ462a7MfIvXT8H4GdObeqHAVxGHin7jcj/u/xuPL/fw8rKysrKysrKysrK6mNeWusfAvBD9/jaCV6g/1Fr/bvI3Zgvto1/B+Df3cf4biB3cd7r678Peczsn4bWWuvvRf499172fYwc/L6QE/KF3vejyOHkvb4+BfCtm597ef0N3OMcaq3fBuBt9zoWKysrK6uXps4NKnd2dgTg0A1XLBbFMZckibjBkiSRnrfxeIxarSYOuyzLMBqNtpyCBB5ZlmG1WqHVaqFYLOLo6AjFYhE7OztYLpc4ODgQ0BmGIYIgQL1ex3q9Rq/Xk56505AEwJZbkuBmuVwK1KLjbLVayevoKGSEZavVwtWrVyVulnDoypUrGI/H0tlJOMtjNnskCWQIKoFt9+fpfkwAMk7zGOiIJNxUSmE8HmM+nwvAajQamM1mEvlJp6LrujLfjUYDpVIJo9FIYB+Pjf2ZBMH1el2iL9frtcRwMl6Urk4gh0aO48DzPIGdWZYhyzI0m010Oh1UKhVZD/P5HJVKBdVqVZymjNvl/BwfH6Pf7wMAwjDEbDbDyckJJpOJRJkyjpXAGsgjbwmdisUixuOxuAwJqwlDS6USBoPBVnQvuzV93wcA6XhMkkTGzWNOkkT6Da9evYputyuuSELCJEkwnU5Rq9XQ6/WwXC4xnU4FnJXLZcRxjOPj/MY1Xmvs/6RzFIBE54ZhKK9lP6brutBaYzKZ4PDwEK1WC57nYblc4vDwEKPRSI6B57ZWq2G1WmEwGODGjRs4Pj7eim8eDAbS/bm/vy8gdTabCdCnw5ZRrezc5LYJl9M0xWg0kn5KOh5LpRKm0ym01gK4K5UKer3eFnidTCaYTqeyPk87p5VSEsO7XC4xmUyQpim63S6uXbuG6XSKg4MDAdaj0Qg7Ozvodru4c+eOuJDNiFzOVbstVQxWHyJtvsi84JfMTd/IP9/83Os23wvgb93D687cr9b6UQD+GY//Me7xi5TWegXgWzY/VlZWVlZWVlZWVlZWVlZWVlZWVlYfVzo3qOx2u9KHRxhnRpYSVHY6HQGPBD+Mp6QTEoBAtjAMUSqV0O12Ua1WxaHF2FjGbNKpWK1W4boufN9HEARbLkeCM27f7Hg0gRfHTlcdgZbZcXi6Q5Jurm63u9XNl2UZgiDAdDoVV+ZgMIDrurI9pZTAKAIyrbVEXNJpyDkhPGNvJx2K5mvo3iMcNHsdGYHJcdKRx2OlM6xSqWB3dxflchlpmgq4u337tgBoOgcJlNl7uFwuMR6PpZeU3Yie5wHI3ZB0MvJ9cRxLhHC73cZsNsNwOESz2cR8PhfHZ7VaxXq9RqfTQalUQhRFWCwWW/M9Ho+li5GOXPZFEtbSKcn5M+E1n6MzlxCTvZWMGOY+CWc574RldFISBLPjkg5Anh9GwRLWEsoDkK7TSqWCJEmkDxTIwSPPJeEw+yg5vnK5jGvXrsl2eJ1GUSROWN/34XmeXKfsFwXudnQC+Q0Jd+7cQRzHuHHjBq5fv443vOENuHz5Mm7cuCGwvVar4ejoSKA8ex6TJBF3Io9puVxiNpttRfry5gUCdcbIcr7L5TK63e6WE5YQmJ8JZtclI33p7ua6bzQa4mrmsTcaDSilcHh4iDt37qDb7SJNUyRJIq5hXg9cU3EcA8h7MKfTKYbDIaysrKysrKysrKysrKysrKysrKysrKys7k/nBpX1el1iGguFAhqNBjzPw507d8SJOJvNpFeOMar8Iayh44sgiPGag8EAs9kMvu+LO49Q4/j4WOJf4ziWbbXbbYnMLJVK4pIE8DzQSJm9k6fjX/kcISfHvl6vsbe3h6tXr4qr7eTkRGI/x+OxOOTYt0eXHl15q9UKYRgKvCVwBCCdd/P5XDoW6ThjfKsZZQvcjWnVWktkKLsA2Y3IKM5CoSDOtCAIxCFKsJhlmXQxTiYTid+lE44OPbpBGSt7cnKCQqGAdrst8IdzkCSJQCs6X2u1mkRujsdjiX2lG89xHHGPcl5O944S3JrAme5QHhtdlYSDi8UCURRJ7GgQBNKxSmgcxzEWi4W8j3PM9czzcOHCBXl+uVzKPjlfvu9vrW26jtmtSNekGbvLuGH2mvLctVotgffm/uhqpXuRYLTRaGA6nSIIAonFZbwugSHPX61Wk85MunmBHNAOBgNkWYbDw0M88cQTePWrX41er4fd3V3cunUL8/lcjpN9k6d7VgnaObd0frIL1fd9iVfltU2XKKGw4zji0A7DcMsVSwjONcobFRgbG4YhxuOx9Hear8+yTLoreS4LhQIuXryIYrGI0WiERqOBLMvkfbzeOGY6WK2srKysrKysrKysrKysrKw+kJRSb0PeMflieo/W+pc+tKOxsrKysrL6yOvcoJJOM3b0AYDneRKLSDAxn8/hOI784z5BjOmGpLOLLjRCiCzLJH6ScZJ8nE6+1WolcIKdc3Rdmd1xJqg0Ox/5myCS4y6XywK/2Cdogkp2JDYaDbiui9FoJM7CIAgkfpTvP91jR/ddEAQSkWvCR8aGJkmCNE0FThIsEZTQKWiqWq1iZ2cHvV5PoCmdb3QLEgYBOQgynYuMUaVrjee6VCrB931xNhJUcj0MBoOtGOByuSyO1iiKZE4Ir6rVqgBRQiff9zGdTrc6OglSzV5TukUZj8t58TxPHKIEnDy/hGcEaQSqHBOQw0j2qnJNc67p1DXXDqNwF4sFJpOJdD9yLXEcBIh0y7quKy7DLMvguq44I09DeHONMDaYEcIEb4xOLpfLSJIEcRxvnWuuf0JdgjzXdeUa7XQ6AmAJbTmno9EIYRji9u3bODg4wKte9So8+OCDePrpp/H+979fXKwcBwBxOvJzgHGsjFeO41jWXpZlCMMQ0+lUPi94rgnbgyAQmEiXJHtQtdayv1qthnq9jiAI5Lj5w32zW9V0bNMBDuQQmO7d+XyO/f19ZFkm1xy3TbcurwMrKysrKysrKysrKysrKyurF9HbALzlHl73YwB+6cPR06i1fjuAt9/nex76UIzFysrKyurjT+cGlScnJxJnyahTAhg6wxzHESekGZlKgMOoxjAMMRgMBJRlWYZWqyWQ6uTkRLrxGG9J4NJqtSR6kq4ydhDSbQds99Sx85Hdlabjk2ClWq2iUqkIsKHTippMJphMJnjwwQcxGo0EoKzXa4zHY4zHY5RKJbTbbdTrdZycnDyvK3O9XgugMyEkx1mtVgVamd2Tq9VK4CV7OBmHS+Di+z5c1xXYxfcRJDEqlD2OhG7z+Ryj0QjT6RRAHnGZpqmMq16vY2dnB+VyGbVaTeYly7Ithy0B7WQykcjaOI5Rq9W2nJLs/avX6+K4o7NPKSUQkkCWkJNRwjzndMcxFpXzuVwu4TiOuN4KhYJ0SxLyrddr1Go1iQpO0xSVSgXNZhOlUkncnb1eT5y6dGceHx+jXq/L/DQaDXFLci0DOTxmzyLdpqbzkGu/XC5jPp9L1yeBHc8bYdlisZDriMfqOI6MixANgPRY8rqhm5agnO7SXq+HYrGIyWQCrbXEB+/t7SGOYznH169fx5UrV7C/v48rV67g+PhY1udoNMJisUCz2ZTYYa5TXgu8PgnACQOzLJN5JnCczWYYDAYSFZymqTinCR05N1EUSeRytVqF4zhot9vi+OQ6A7Dl2jRjY+kyXa/XODg4kMjXw8NDOYYoivDcc8/B932BvhZUWllZWVlZWVlZWVlZWVlZ3Yss4LOysrKystrWuUHlbDaTeEg6lcIwRK1Wkx5AgrLJZIJWq4XlconhcCjvo4utVCrBdV0BO47jYGdnB5PJBEEQYDQaIYoi+L4Px3EE1BSLRTSbTQE9nU5HQCRdlqdBJYCt6EzGXNJ9R9cee/AI+LhdAs04jnFycoLnnnsOcRwLMKILjSCNUI+uLbrNAAg4SpIExWIR9XpdHIKMVjXBHN9jgtbpdCo9fVprcYYSEK7Xa4FGp+N0eWyMFnVdV8bEfkrCIY67Vquh0+mIq42gktGmo9FIjiNNU3G57uzsSIwm41td10WhUMBoNEKlUoHruuJOZJ8gHYT1el3ctOZ88RzS5UmXnud5AgE5J/V6XaBlEAQYDocolUrioiXIbDab4p6sVCpoNBoCN5Mkge/7iOMYjz/+OGazGVqtFvb29vDggw8KgGXfJeNtC4UCDg4O5PHj42NZM5xDpZTEmgJAr9dDtVoV4M7Y3SAIttYcQTMjl9kbS3BO6F2pVOR8lMtluamAjk+6gqfTKcrlsrgOL126hOPjYxwdHWE4HOLxxx/Hp33ap+Hq1avSVTkYDOA4DgCII5dRrYxmHY/HMu5arYZLly4JzCYkTpJEOia5zrlednZ2sFwuMZlMJA6WPZI837xGCUG5Lk9OTuTa53i4hhnJGwSB3BBx7do1uZGAkDxNUxwcHKBYLEr3ru/74o62srKysrKysrKysrKysrKysrKysrKysro/nRtUNhoNgQmtVks64DzPg+/7EnPZ7/cxHo+RpimSJMFwOES328Xu7q708Jk9favVCoVCAY7jYDgcClDY29tDp9MR+ESHHh2DQA5PCZ/iOMZgMBDHFQGGGQVLJxZhJZ+nA9CMC6VjjH8HIFCRgJLxpnSwJUmCw8NDNBoNdLtdAbgAtrbH42eUKQEZ4aTpRjWdleZx8ZjonpzP5+h0OkjTFOPxGFmWCdC7dOkSCoUCDg8PBeIQ4LALsVQq4eTkBHEcYzabSdQq3ZrsmCTQTJJE4K4JKM0oUAACX9mryNhaE2jx+OjYJWSO41jchexENWNxgRxMEVYybpiQjy5Q9ohqrSWuOE1TiRmm45MuO8aTEqYRyr385S9HHMcYDoeyzyRJoJRCu90W1yqjbdM0lXXVbDZRKBQwm80AQCJE6VTe29sDADzzzDNYr9doNBoyl5PJRFyetVpNQF+1WpV5Zj8pgXCpVBK3Ix2dQA5DTYjP2GO6N0ulErrdLnq9ntwwcHx8jKeeegq7u7vY3d3F3t4eDg8PZU1yXd+5cwdRFEkXZRzHCIJA1hPHZt68wP2z83S1WqFUKmE6neLw8FAih3nu6RDlzQS+74szut/vS++p67oIwxBhGErsb6VSwXQ6xXg8FvcygXoYhnLDAONe6cYEckcmrxPeNGFlZWVlZWVlZWVlZWVlZWVlZWVlZWVldX86N6gkuNJaYz6fC6SqVCoCObIsk6hQRkd6nifOR0Y00jFGsGV2wLEbcG9vD6VSCUmSCCxk11yz2YRSCsPhEGEYwvM82T9BJQABjoRaZqclISAdjARupghTzpoLRoTSqZamKTzPkw7ELMtkX3T5AdiK8aSTcbFYyLg5ByZgNUGp2bnJuer3+xIBCkAiPgmcSqWSxMV6nodutytj537pMiWAZLwueykZH6qUQpZlCIJAYk0Jjgl4KpUKFosFxuOxbJeAiXNOIEUXG92npVIJs9lMujOzLJPIWUabApA1yFhWrg+6Gs0IX7pd6SJtNpuYzWZyjoC7kbeMxj06OpL5WS6X4qJMkkTGQHjO88+ew/V6jSAIZIxcbxwHuxIJ6RiR+uyzz+L27dvo9/soFAoIwxBKKaRpKrGsk8lEoC5BJSOX+RyjadM0lWheQmY+R9jLuUuSRCKY6Uat1WrSI/nYY4/h5S9/uUTAPvnkkxKBSsBHcLtardBoNFAoFBAEgfRgDodDLBYLTKdTceFqrTEej+UmBn5muK4rcbiu68J1XVQqla35YxQrx8CbHwihlVISNc2O0EqlggsXLggA540HBNxcB1zvrVZLnKOMbD7dEWtlZWVlZWVlZWVlZWVlZWVlZWVlZWVldW86N6gkJGSvXq1Ww3K5FFiQJIl0Ve7s7AhkJGSI41ick4RjBACz2Uygluu6Er3Jnj0Cnvl8Lj14cRxjsVig1WpJLGStVtuCemb/I52JhJUmACTMJKzgewhfCNboIiUkJJRkT2an05H40iRJBKCYDjZzP4yapcuU0JfgkmOmTMci3Z+NRgN7e3sol8s4OjoSuEjXJ2NHR6OROMgYJ0qoyJ7O6XQqPY7FYlGclIwSJdRLkgRHR0filCPsYawtYzn5PGM06ZbNskwcoHRcMiKW0JvgivMVhiGiKEKz2ZToUs5Xs9kUdytBVhAEACCwzTz35XIZSZJsgSfOM2NbgyCQaFoCQfZ40m1J+GpG/Xqet+UCdRxHYFmz2US/34fjOAL0ut2ujDeOY9Trdfi+j1qthjRNsVqtBLxyu4R2PM+FQgHj8Rjz+RzlchlBEAioKxaLEn3LPk/OH92HjUZjy/2ZZRl830er1ZJxPfXUU7h58yYefPBB7O/vY39/H0mSCBCma5bngdvnMVWrVVnXBI2c9yRJUK/X4bquxM8SKJsdmyb0ZwQwI4RXqxUmkwkcx5H10+l0EMexOI/pBm+1WhiPxwKdlVJoNpuYTqeyTnn+6M4EIC5lAPI5YWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV17zo3qKTzsVgs4uLFi+j3+7h16xaKxSL6/T7K5TKGw6E47JrNJrIsw3g8xmw2ExAB5KCLII/gMooiaK2xt7cHz/MEglSrVbRaLXieh+l0iieffFKAQb1eR7PZxMHBgXTzmbGo/CHU42tMJydlui9NBySBJ91Ww+FQ4iY9z5NoTnbXDYdDiekEIPuk+GfCSgKbLMskipQAjT2aBIRnOTwJrJbLpfRXdrtd1Ot1pGmK4XC4dYzsv2Q0L7s9gyBAkiQCCwnEarUagNy1x0jXOI5xeHiIMAyxXC7RbDYF0NFpaR5Lo9HAZDKR1xNqp2mKq1evot/v4+joCFEUSY8lIeR8PheIZvYspmkqrsJ6vY7RaIQ4jvH/t3f/QZfV9X3A3x8X3BBYYV0lSN2AEIVqDak/oqggaGLRVLH+iDPRicTGkDbEToOdMZmphTTxR6YmVq3FJDW0avyVjJI4VUxEFCHGYipTU0UlgrEubFmWdcEFoXz7xzn38XJ5nt19nr333Pvsvl4zZ+4+55z7/Z7z/X7v5X74nPM9xx577NI0oqM7SEdTuB5zzDFL04zu2rVrqa5RcmrUz0cccUQ2btyY3bt35yEPechSYnXUR7t27cr27dtz+OGH5/jjj1+6s/juu+/Orl27lpLmo7sTt2/fnptvvnnpbuDReSXdXXo7d+7MHXfckaOOOiqbN29eujN006ZN2bVrVzZu3JhbbrklRxxxRE455ZSl523edddd97tIYOvWrUvTm46ew3jkkUfm9ttvz6233pp77rknW7ZsyZ49e3Lrrbfm3nvvzZYtW7J58+alOxJHz4Y97rjjsnv37mzbtm3pebTbtm3Lzp07c/TRR2fr1q254YYbsnnz5mzcuDE333xz7r333qXP80033bT0LM3jjjsuGzZsyI4dO3Lfffcttcvtt9+eww47LFu3bl1K2I8+H6PniI76fzRF8yhBOJpqecuWLUvjevS5Hk2bu3HjxmzevDnHH3/80t28o/LuvPPOpbtI77nnnmzevHlpjI3uFB3dCb5jx46lu3FHdY9/pgEAAAAAgP2z5kTluNH0o0mWknrjS3L/ROHknYHj07GO1o/WjU+XOnkX5CjhOEoUTCYh92a8nskkw+hYxlvpmSwAABPgSURBVPdbzighMr7/+HMwk9wvITpZ9r5M7jt+R+j4uvHnOI7WjSdZR+0yuX6yrsnzmDRez2T/jT/Lc/LO1Mm+HfXdqH3Gp2lN8oBt43VOjo/xf0/eMTuerB6vY7zPxrdPtsXkNLt7O7fJfh69juoa/yyMP3N0/DMxWdboczVKoI9/lsaTceMJ68nk+mjbZB+Mt8N4/42P3cm+mxzD4+c2uit5dEfl5JgZP97xdaPzGu/70fvHx+z4OJs8hsljHd8+Kmd8ut3Rd8joLuXxZfR9Mj4GJj9jy31+AAAAAACA1VtzovINb3iDW4hIkpx88sm54IIL5n0YzNEJJ5ww70MAAAAAAADWmQfOHQoAAAAAAAAwYxKVAAAAAAAAwOAkKgEAAAAAAIDBSVQCAAAAAAAAg5OoBAAAAAAAAAYnUQkAAAAAAAAMTqISAAAAAAAAGJxEJQAAAAAAADC4w+Z9AADAdJzwkAfla2/6mXkfBgAAAADAfnFHJQAAAAAAADA4iUoAAAAAAABgcBKVAAAAAAAAwOAkKgEAAAAAAIDBSVQCAAAAAAAAg5OoBAAAAAAAAAYnUQkAAAAAAAAMTqISAAAAAAAAGJxEJQAAAAAAADA4iUoAAAAAAABgcBKVAAAAAAAAwOAkKgEAAAAAAIDBSVQCAAAAAAAAg5OoBAAAAAAAAAYnUQkAAAAAAAAMTqISAAAAAAAAGFy11uZ9DADAAaqqHRs3bnzo4x73uHkfCmu0e/fuJMmmTZvmfCSshf5bLF/5yleyZ8+e21prW+Z9LAAALAZx89qJd9ZGu62Ndlub1bbbIsXNEpUAcBCoqruTbEhy3byPhTU7tX/96lyPgrXSf4vlxCTfba09at4HAgDAYhA3HxDxztpot7XRbmuz2nY7MQsSNx827wMAAKbiy0nSWnvivA+EtamqLyb6cL3SfwAAsPDEzWsk3lkb7bY22m1t1nO7eUYlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAAAAAADA4CQqAQAAAAAAgMFJVAIAAAAAAACDq9bavI8BAAAAAAAAOMS4oxIAAAAAAAAYnEQlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAAAAAADA4CQqAQAAAAAAgMFJVAIAAAAAAACDk6gEAAAAAAAABidRCQALqqoeWVXvrqrvVNXdVXVjVb21qjavspyH9u+7sS/nO325j5zVsTOd/quqn66qt1TVp6pqR1W1qvrcLI+bHzjQPqyqI6vq5VX1x1X11aq6s6p2V9W1VXVhVT141ucAAADr3Txj42nVPS/zimn62HWl5fPTPcvpm1I8f+U+2uGHVnjfY6vqQ1W1varuqqrrq+riqjpiemc4G1MYb2fto81Gy9aJ963b8VZVL6mqt1fVVVX13f6Y37vGslbd/osy3qq1NmR9AMB+qKqTk1yT5NgklyX5apKfTHJ2kuuTPL21tmM/ytnSl/OYJFck+R9JTk1ybpLtSU5vrf3dLM7hUDbF/vtour66K8k3kvyjJFe31p4xo0OnN40+rKpzknw8yW1JPp2uDzcneUGS4/ryn91au2tGpwEAAOvaPGPjadU9L/OMaaqqJbkpyaXLFPvt1tofrvnEZmyKY+7KJM9McvEKu/xWa+3eifc8Jd34PDzJnyT5+yTPSvKkJFena+u7V39Wszel8XZikvNW2Pz4JC9K8uXW2uMn3reex9uXkpyW5I4k3073vfS+1torVlnOqtt/ocZba81isVgsFsuCLUkuT9KS/OrE+t/t11+yn+W8q9//LRPrX9Ov/8S8z/VgXKbYf6cneVySDUlO7N/7uXmf36GwTKMPk/xEkpcnefDE+k1JvtiXc+G8z9VisVgsFovFYlnUZZ6x8bTqXs9tt9aYpl9/5bzbYM5j7sou/bLf9W5I8r/7Ol4wtv5B6ZJILcnr5t0+s263vZT//r6c1yyzbT2Pt7OTPDpJJTmrP5f3zrr9F228uaMSABZMfxXUN5LcmOTk1tp9Y9s2JdmW7gfMsa21O/dSzlHprgy9L8kjWmu7x7Y9KMnfJTmhr8NdlVMyrf5bptwTk3wz7qicuVn14UQdP5fkfUk+1lp7/gEfNAAAHGTmGRsPERPM0rxjmv4Ot8+01s5a0wnMyTTbbXRHZWut9rPuZyX5VJLPttaeObHtpCQ3pLtr8FFtwZI6sx5vVfWwdHcb3pfk+Nba7RPb1+V4m1RVZ6W7c3lVd1Supf0Xbbx5RiUALJ6z+9dPjv+4SJI+oLo6yQ8neeo+ynlqkiPSJbZ2j2/oy718oj6mY1r9x/wM0Yf39K/37nUvAAA4dM0zNl7vcd0ixDTHVNWrquo3qupXqmpR22rc1Nutql5WVa+rql+rqudW1cYVdn1W//qJyQ19Av1r6RLqJ+1v3QOa9Xh7ZZKNST48maQcsx7H27Sspf0XarxJVALA4jmlf/3aCtu/3r8+ZqByWB3tvv4N0Yev6l8fEBQAAABJ5hsbr/e4bhFimtOS/Jckv53kHUn+qqq+VFWPX2H/RTCLdvtAkjcmeUuS/57kW1X1koHqHsqsj/3V/eu79rLPehxv07Luv+MkKgFg8Rzdv+5aYfto/TEDlcPqaPf1b6Z9WFUXJDknyZeSvHstZQAAwCFgnrHxeo/r5h3T/G6Spyd5eLrnWT453XPvTktyRVX9g7XUO4BptttlSZ6f5JHp7ug9NV3C8pgkH6yqc2ZY99BmduxV9cx0SbUvt9auWWG39TrepmXdf8dJVAIAwECq6kVJ3prk5iQvbq3ds4+3AAAALIz9iWlaaxe21q5prd3aWrujtXZta+2lSf40ycOSvHbYox5ea+33Wmsfa639n9baXa2161trv5HkwnR5mTfO+RDXi1/qX39/pR2Mt/VPohIAFs/oqqWjV9g+Wr/SvPzTLofV0e7r30z6sKpemG7an+1Jzuqf+wAAACxvnrHxeo/rFjWmuaR/PXOV7xvKEP3+h+me6/kTVbVp4LpnZVbj7aFJXpxkT5L3rOG4Fn28Tcu6/46TqASAxXN9/7rSPPCP7l9Xmkd+2uWwOtp9/Zt6H1bVS5N8OMktSZ7ZWrt+H28BAIBD3Txj4/Ue1y1qTPN/+9cj1/DeIcy831trdyXZ3f853g7reczN6thfmWRjkg+11taSMFv08TYt6/47TqISABbPp/vX51TV/f5b3V9t9/Qk30vy+X2U8/l0V509feIqvfTlPmeiPqZjWv3H/Ey1D6vq5Unen+Q76QL6r+/jLQAAwHxj4/Ue1y1qTPPU/nVRZ5eZeb9X1SlJNqdLVt46tumK/nXy2ZWpqpPSJZRuymK23aza7dX964rTvu7Doo+3aVlL+y/UeJOoBIAF01q7Icknk5yY5FcmNl+c7kqw97TW7hytrKpTq+rUiXLuSDc1xpFJLpoo54K+/MtNPzld0+o/5meafVhVr0zy35J8K8mZPm8AALB/5hkbr6XuRTLPmKaqfryqDl9ufZLf7v987/6fzXCm1W5V9ah+2tJMrH94kj/q//xAa+3esc2fSfKVJGdW1QvG3vOgJG/u/7yktdbWcm6zNIv/D1JVZyT5h0m+3Fq7Zi/7rdvxtlpVdXjfbiePr1/j99VCjbdawHENAIe8/kfHNUmOTXJZuh8PT0lydrppF57WWtsxtn9LktZaTZSzpS/nMemulvpCuh9656Z7psTT+h80TNEU++8ZSX6x//OodM9m2J7k46N9Wmvnzeo8DmXT6MOqOjvJX6a7OPDdSf5+mapub629dUanAQAA69o8Y+PV1r1o5hXTVNWlSZ6f5Kp+/7uTnJruzq0NSf4gyfmLmHBLptZu56V7PuLn0t2RdluSH03yvHTP/rs2yU9PTmdaVU9JNz4PT/In6ZLDz07ypCRXJ3l2a+3uaZ/zNEzrszq2/T1JXpHkNa21t++l3kuzvsfbC5O8sP/zuCT/JN2Yuapfd2tr7bX9vicm+WaSm1prJ06Us+rvq0UabxKVALCgqmprkt9M9+NqS5JtST6S5OLW2s6JfVf8gddfxffv0v3weUSSHekSXa9vrX17ludwKJtG//XBzR9lL1b6Uc+BO9A+3J/+yzIBBgAA8APzjI1XU/cimkdM0ydefj7Jj6dLmvxQura+NskftNb+7IBOagBTaLfHJ7kwyROTHJ/kIemmev3bJB9K8q7W2vdXqPux6e6COzvJpnTTb74/yZtaa3umd5bTN8XP6uZ00wy3JMfv7fmU6328VdVF6b6XVrL0+dpborLfvurvq0UZbxKVAAAAAAAAwOA8oxIAAAAAAAAYnEQlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAAAAAADA4CQqAQAAAAAAgMFJVAIAAAAAAACDk6gEAAAAAAAABidRCQAAAAAAAAxOohIAAAAAAAAYnEQlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAIe4qjqrqlpVXTTDOk7s67h0Fe85r3/PeRPrb6yqG/dnXwAAADhQ4maYHYlKAAAOWssFZwAAAEBH3My8HTbvAwAAgBV8JMnnk2yb8r4AAABwMBA3s+5JVAIAsJBaa7uS7Jr2vgAAAHAwEDdzMDD1KwDAnI0/h6KqTq2qj1bVbVV1Z1V9rqqeM7H/0nMlquqcqrqyqnZVVRvb5+iqemNVXV9Vd1XVzqq6vKp+ah/HcnpV/WVf3u7+PU9aZr/jq+r1VXV1Vd1cVd+vqu9U1R9X1WP3Ucc+z3HyPPejDe+37+j5IUlOSHJCv220XFpVm6vqe1V1Q1XVCmX+eb//A84fAACA4Yibxc0cvCQqAQAWx6OS/FWShyZ5V5IPJ3liko9X1cuW2f8lST6WZHeSS5J8MEmq6pgk1yR5XbqrJd+a5E+TnJ7kk1V1/gr1PyXJlUnuTvKfknw8ybOTXFVVZ0zse2Zf/u192b+XbgqZlyT5QlWdNqVzXKsbk1yc7vx39f8eLR9tre1M8oEkJyV5QBBaVVuTPDfJF1tr107xuAAAAFg7cfP03BhxMwvA1K8AAIvjzCT/obX2b0Yrquod6QKUS6rq4621747t/7wkz2utfWKinDcneWyS30/yy6211pf15iTXJnlbVV3eWrtx4n3nJPnV1to7xuo/N8lHk7y7qk5prd3Xb7oiyY+01naPF9AHWlcneVO6gOVAz3FN+nO7aHSlaGvtomV2e2eSX0hyfpK/mNj2z5NsSBcUAgAAsBjEzeJmDjLuqAQAWBy7kvzm+Ir+qsT3JTkmyT+b2P+yyWCrqh6c5BVJ7kjy66Ngqy/r60neluTBSX5+mfq/kS4IGa//siSfSfJjSc4YW799Mtjq11+XLhg7u6oOn8I5zkxf77VJzq2q40brq2pDuoBrd5L3D3U8AAAA7JO4WdzMQUaiEgBgcfzNckFMumllkuQfT6z/wjL7npLkh5Nc11q7bZntV6xQVpJcNXbl5z7rr6qf6Z9Hsa2q7hk9yyLJ85NsTPKwZcpa7TnO2jvTzTLyqrF1z0vyyCTvba3dMfDxAAAAsDJxs7iZg4ypXwEAFsctK6y/uX89eoX140b7bFuhrNH6Yw6k/qr6V+me4bEz3fQv30ryvSQtyQuTnJYu6FpzHQP5QJK3JHl1Vb2pDzh/qd9m+hoAAIDFIm4WN3OQkagEAFgcP7LC+tH0Krsm1rfJHcf2OW6ZbUnyiBXK2u/6q+qwJBelC5Ke0Fq7X3BXVaevUM5+1zGU1tqeqro0yb9O8pyq+tt0zwj56346HgAAABaHuFnczEHG1K8AAIvjCVW1aZn1Z/Wv/3M/yrg+3RWap1XVcld/nt2//s0y255RVcv9Ppys/2Hpriy9Zplg66gkT9jL8U3jHFfj/yXZsI99/nO64PX8dM/Y2BBXhQIAACwicbO4mYOMRCUAwOI4Osnrx1dU1ZOSvDzdFZMf2VcBrbXvJ3lfkk1J/v1EWScneU2Se5K8Z5m3PzrJv5x4z7lJnpnkG0mu6ldvTxfUPbEPsEb7Hp7kP2b5Z2yMHPA5rtKOJA+vqiNW2qG19vUkn0ryT5P8cpLb001tAwAAwGIRN4ubOciY+hUAYHF8NskvVtVTklydbrqZl6W7uOz81tp397Oc1yU5I8kFVfXkJJ9OFwT9bLpA7ILW2jeXed8nkrylqp6b5LokP5bkRUnuSvKq/jkUaa3dV1Vv6+v5X1V1WZIHp7vq9KF9fWcvU/40z3F/fSrJk5N8oqo+m+TuJNe11v58Yr93JvmpdFPsvL21tmfKxwEAAMCBEzeLmznIuKMSAGBxfDPJ05LsTHeF4s+mm2rmea21D+5vIa2125KcnuR3kmxJ8mtJXprkC0nOaa29c4W3/nW6qWQ2Jrkg3TMnrkhyZmvtqol9/22SC5PsSTf1y4uSXJvkJ5N8a9bnuAq/leSSJCcn+fV0V8u+eJn9/izJrf2/TV8DAACwmMTN0yduZq6qteWeJQsAwFCq6sR0gch/ba2dN9eDOURV1Unppum5urV2xryPBwAAgB8QN8+fuJlZcUclAAAkr01SSd4x7wMBAACABSRuZiY8oxIAgENSVf1okp9L8ugkv5Du+SIfnutBAQAAwIIQNzMEiUoAAA5VJyV5Y5LvJfmLJP+itXbffA8JAAAAFoa4mZnzjEoAAAAAAABgcJ5RCQAAAAAAAAxOohIAAAAAAAAYnEQlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAAAAAADA4CQqAQAAAAAAgMFJVAIAAAAAAACDk6gEAAAAAAAABidRCQAAAAAAAAxOohIAAAAAAAAYnEQlAAAAAAAAMDiJSgAAAAAAAGBwEpUAAAAAAADA4P4/jpVmhvJ0JkkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 917, + "height": 914 + }, + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb new file mode 100644 index 0000000..dba7fb6 --- /dev/null +++ b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb @@ -0,0 +1,1107 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Prompt Engineering for ImageNet.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "66a1639713ae441d8a9b873381f9d774": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_610b775178c645e2b4663b77cc0c67b6", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_412dd15f0d8542f5ab2730f8616fb582", + "IPY_MODEL_5e6315f36b4e4eeea5c6294b024e0c97" + ] + } + }, + "610b775178c645e2b4663b77cc0c67b6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "412dd15f0d8542f5ab2730f8616fb582": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_085d5388abda4202bfa66d0c088452f8", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 1000, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 1000, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f75124b64aa147c693c67a78f8e3a231" + } + }, + "5e6315f36b4e4eeea5c6294b024e0c97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6e5676a054874243b55fc6d120a07d01", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 1000/1000 [16:51<00:00, 1.01s/it]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_dc6d1416c01a4047935ee15c3fd2eb1c" + } + }, + "085d5388abda4202bfa66d0c088452f8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "f75124b64aa147c693c67a78f8e3a231": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6e5676a054874243b55fc6d120a07d01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "dc6d1416c01a4047935ee15c3fd2eb1c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "84f80a7f3e764346969a347b0f71b24e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_392656f01b2945f3bd7903783ed8cc96", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_8e47a435519b4ce090879b4be2f61f99", + "IPY_MODEL_41b1ed6b0a9745c1a595377670b15ff4" + ] + } + }, + "392656f01b2945f3bd7903783ed8cc96": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "8e47a435519b4ce090879b4be2f61f99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_179b8ae1eb7f4a828f953e889b141725", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 313, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 313, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_d8708e8414fd44f4abd6590c9b57996f" + } + }, + "41b1ed6b0a9745c1a595377670b15ff4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_800e30f5b4f24475a2b0046da0703631", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 313/313 [02:31<00:00, 2.07it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8764308b948745f1a677332fd21fcaf0" + } + }, + "179b8ae1eb7f4a828f953e889b141725": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "d8708e8414fd44f4abd6590c9b57996f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "800e30f5b4f24475a2b0046da0703631": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "8764308b948745f1a677332fd21fcaf0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "41a4070f-5321-4fc4-bd4d-0b5c1f476d56" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 14.9 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 18.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 9.0 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 4.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 4.6 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 4.7 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 1.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=90ec193331444b2c4ff1cd81935e7de42065b89d304db7efac67bcfd87c27873\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-hqnbveqi\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-hqnbveqi\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=fda43d2b80cfb2b33c2d43e23ea5f53293a9a8b48d5f9e341de527f6adfbf5a3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmmplf44/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e10d4f17-8fa6-4b75-a18f-f0c38990b5a3" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "import clip\n", + "from tqdm.notebook import tqdm\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "Download and instantiate a CLIP model using the `clip` module that we just installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "09abb234-693e-4efb-953f-e1847ba95758" + }, + "source": [ + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cboKZocQlSYX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "240acdd0-ca62-45db-8418-9e4ef73e8aff" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.6MiB/s]\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "785019a1-1f40-45b0-e349-b0d4ec3173bf" + }, + "source": [ + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LhO3OtOmF8M4" + }, + "source": [ + "# Preparing ImageNet labels and prompts\n", + "\n", + "The following cell contains the 1,000 labels for the ImageNet dataset, followed by the text templates we'll use as \"prompt engineering\"." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "R2HbOZrqa0jF" + }, + "source": [ + "imagenet_classes = [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eMQSCuBta2G6" + }, + "source": [ + "A subset of these class names are modified from the default ImageNet class names sourced from Anish Athalye's imagenet-simple-labels.\n", + "\n", + "These edits were made via trial and error and concentrated on the lowest performing classes according to top_1 and top_5 accuracy on the ImageNet training set for the RN50, RN101, and RN50x4 models. These tweaks improve top_1 by 1.5% on ViT-B/32 over using the default class names. Alec got bored somewhere along the way as gains started to diminish and never finished updating / tweaking the list. He also didn't revisit this with the better performing RN50x16, RN50x64, or any of the ViT models. He thinks it's likely another 0.5% to 1% top_1 could be gained from further work here. It'd be interesting to more rigorously study / understand this.\n", + "\n", + "Some examples beyond the crane/crane -> construction crane / bird crane issue mentioned in Section 3.1.4 of the paper include:\n", + "\n", + "- CLIP interprets \"nail\" as \"fingernail\" so we changed the label to \"metal nail\".\n", + "- ImageNet kite class refers to the bird of prey, not the flying toy, so we changed \"kite\" to \"kite (bird of prey)\"\n", + "- The ImageNet class for red wolf seems to include a lot of mislabeled maned wolfs so we changed \"red wolf\" to \"red wolf or maned wolf\"" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "toGtcd-Ji_MD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6eb0753-2bee-4144-abe3-fbd23f35f555" + }, + "source": [ + "imagenet_templates = [\n", + " 'a bad photo of a {}.',\n", + " 'a photo of many {}.',\n", + " 'a sculpture of a {}.',\n", + " 'a photo of the hard to see {}.',\n", + " 'a low resolution photo of the {}.',\n", + " 'a rendering of a {}.',\n", + " 'graffiti of a {}.',\n", + " 'a bad photo of the {}.',\n", + " 'a cropped photo of the {}.',\n", + " 'a tattoo of a {}.',\n", + " 'the embroidered {}.',\n", + " 'a photo of a hard to see {}.',\n", + " 'a bright photo of a {}.',\n", + " 'a photo of a clean {}.',\n", + " 'a photo of a dirty {}.',\n", + " 'a dark photo of the {}.',\n", + " 'a drawing of a {}.',\n", + " 'a photo of my {}.',\n", + " 'the plastic {}.',\n", + " 'a photo of the cool {}.',\n", + " 'a close-up photo of a {}.',\n", + " 'a black and white photo of the {}.',\n", + " 'a painting of the {}.',\n", + " 'a painting of a {}.',\n", + " 'a pixelated photo of the {}.',\n", + " 'a sculpture of the {}.',\n", + " 'a bright photo of the {}.',\n", + " 'a cropped photo of a {}.',\n", + " 'a plastic {}.',\n", + " 'a photo of the dirty {}.',\n", + " 'a jpeg corrupted photo of a {}.',\n", + " 'a blurry photo of the {}.',\n", + " 'a photo of the {}.',\n", + " 'a good photo of the {}.',\n", + " 'a rendering of the {}.',\n", + " 'a {} in a video game.',\n", + " 'a photo of one {}.',\n", + " 'a doodle of a {}.',\n", + " 'a close-up photo of the {}.',\n", + " 'a photo of a {}.',\n", + " 'the origami {}.',\n", + " 'the {} in a video game.',\n", + " 'a sketch of a {}.',\n", + " 'a doodle of the {}.',\n", + " 'a origami {}.',\n", + " 'a low resolution photo of a {}.',\n", + " 'the toy {}.',\n", + " 'a rendition of the {}.',\n", + " 'a photo of the clean {}.',\n", + " 'a photo of a large {}.',\n", + " 'a rendition of a {}.',\n", + " 'a photo of a nice {}.',\n", + " 'a photo of a weird {}.',\n", + " 'a blurry photo of a {}.',\n", + " 'a cartoon {}.',\n", + " 'art of a {}.',\n", + " 'a sketch of the {}.',\n", + " 'a embroidered {}.',\n", + " 'a pixelated photo of a {}.',\n", + " 'itap of the {}.',\n", + " 'a jpeg corrupted photo of the {}.',\n", + " 'a good photo of a {}.',\n", + " 'a plushie {}.',\n", + " 'a photo of the nice {}.',\n", + " 'a photo of the small {}.',\n", + " 'a photo of the weird {}.',\n", + " 'the cartoon {}.',\n", + " 'art of the {}.',\n", + " 'a drawing of the {}.',\n", + " 'a photo of the large {}.',\n", + " 'a black and white photo of a {}.',\n", + " 'the plushie {}.',\n", + " 'a dark photo of a {}.',\n", + " 'itap of a {}.',\n", + " 'graffiti of the {}.',\n", + " 'a toy {}.',\n", + " 'itap of my {}.',\n", + " 'a photo of a cool {}.',\n", + " 'a photo of a small {}.',\n", + " 'a tattoo of the {}.',\n", + "]\n", + "\n", + "print(f\"{len(imagenet_classes)} classes, {len(imagenet_templates)} templates\")" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1000 classes, 80 templates\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aRB5OzgpHwqQ" + }, + "source": [ + "A similar, intuition-guided trial and error based on the ImageNet training set was used for templates. This list is pretty haphazard and was gradually made / expanded over the course of about a year of the project and was revisited / tweaked every few months. A surprising / weird thing was adding templates intended to help ImageNet-R performance (specifying different possible renditions of an object) improved standard ImageNet accuracy too.\n", + "\n", + "After the 80 templates were \"locked\" for the paper, we ran sequential forward selection over the list of 80 templates. The search terminated after ensembling 7 templates and selected them in the order below.\n", + "\n", + "1. itap of a {}.\n", + "2. a bad photo of the {}.\n", + "3. a origami {}.\n", + "4. a photo of the large {}.\n", + "5. a {} in a video game.\n", + "6. art of the {}.\n", + "7. a photo of the small {}.\n", + "\n", + "Speculating, we think it's interesting to see different scales (large and small), a difficult view (a bad photo), and \"abstract\" versions (origami, video game, art), were all selected for, but we haven't studied this in any detail. This subset performs a bit better than the full 80 ensemble reported in the paper, especially for the smaller models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Loading the Images\n", + "\n", + "The ILSVRC2012 datasets are no longer available for download publicly. We instead download the ImageNet-V2 dataset by [Recht et al.](https://arxiv.org/abs/1902.10811).\n", + "\n", + "If you have the ImageNet dataset downloaded, you can replace the dataset with the official torchvision loader, e.g.:\n", + "\n", + "```python\n", + "images = torchvision.datasets.ImageNet(\"path/to/imagenet\", split='val', transform=preprocess)\n", + "```" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "moHR4UlHKsDc", + "outputId": "40731297-edc7-4cd0-be75-ed426c8fb005" + }, + "source": [ + "! pip install git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + "\n", + "from imagenetv2_pytorch import ImageNetV2Dataset\n", + "\n", + "images = ImageNetV2Dataset(transform=preprocess)\n", + "loader = torch.utils.data.DataLoader(images, batch_size=32, num_workers=2)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + " Cloning https://github.com/modestyachts/ImageNetV2_pytorch to /tmp/pip-req-build-0kih0kn2\n", + " Running command git clone -q https://github.com/modestyachts/ImageNetV2_pytorch /tmp/pip-req-build-0kih0kn2\n", + "Building wheels for collected packages: imagenetv2-pytorch\n", + " Building wheel for imagenetv2-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for imagenetv2-pytorch: filename=imagenetv2_pytorch-0.1-py3-none-any.whl size=2663 sha256=ac31e0ed9c61afc5e0271eed315d3a82844a79ae64f8ce43fc1c98928cec129f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-745b5n1m/wheels/ab/ee/f4/73bce5c7f68d28ce632ef33ae87ce60aaca021eb2b3b31a6fa\n", + "Successfully built imagenetv2-pytorch\n", + "Installing collected packages: imagenetv2-pytorch\n", + "Successfully installed imagenetv2-pytorch-0.1\n", + "Dataset matched-frequency not found on disk, downloading....\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "100%|██████████| 1.26G/1.26G [01:02<00:00, 20.2MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Extracting....\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fz6D-F-Wbrtp" + }, + "source": [ + "# Creating zero-shot classifier weights" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "66a1639713ae441d8a9b873381f9d774", + "610b775178c645e2b4663b77cc0c67b6", + "412dd15f0d8542f5ab2730f8616fb582", + "5e6315f36b4e4eeea5c6294b024e0c97", + "085d5388abda4202bfa66d0c088452f8", + "f75124b64aa147c693c67a78f8e3a231", + "6e5676a054874243b55fc6d120a07d01", + "dc6d1416c01a4047935ee15c3fd2eb1c" + ] + }, + "id": "sRqDoz1Gbsii", + "outputId": "312b8ebf-3961-4903-d8cb-3b7a94cc97b6" + }, + "source": [ + "def zeroshot_classifier(classnames, templates):\n", + " with torch.no_grad():\n", + " zeroshot_weights = []\n", + " for classname in tqdm(classnames):\n", + " texts = [template.format(classname) for template in templates] #format with class\n", + " texts = clip.tokenize(texts).cuda() #tokenize\n", + " class_embeddings = model.encode_text(texts) #embed with text encoder\n", + " class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n", + " class_embedding = class_embeddings.mean(dim=0)\n", + " class_embedding /= class_embedding.norm()\n", + " zeroshot_weights.append(class_embedding)\n", + " zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n", + " return zeroshot_weights\n", + "\n", + "\n", + "zeroshot_weights = zeroshot_classifier(imagenet_classes, imagenet_templates)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66a1639713ae441d8a9b873381f9d774", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1fZo7hG8iJP5" + }, + "source": [ + "# Zero-shot prediction" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "j4kPSZoShQxN" + }, + "source": [ + "def accuracy(output, target, topk=(1,)):\n", + " pred = output.topk(max(topk), 1, True, True)[1].t()\n", + " correct = pred.eq(target.view(1, -1).expand_as(pred))\n", + " return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk]" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "84f80a7f3e764346969a347b0f71b24e", + "392656f01b2945f3bd7903783ed8cc96", + "8e47a435519b4ce090879b4be2f61f99", + "41b1ed6b0a9745c1a595377670b15ff4", + "179b8ae1eb7f4a828f953e889b141725", + "d8708e8414fd44f4abd6590c9b57996f", + "800e30f5b4f24475a2b0046da0703631", + "8764308b948745f1a677332fd21fcaf0" + ] + }, + "id": "wKJ7YsdlkDXo", + "outputId": "ab824854-38e4-4d37-ad40-2a7ce3c5fd43" + }, + "source": [ + "with torch.no_grad():\n", + " top1, top5, n = 0., 0., 0.\n", + " for i, (images, target) in enumerate(tqdm(loader)):\n", + " images = images.cuda()\n", + " target = target.cuda()\n", + " \n", + " # predict\n", + " image_features = model.encode_image(images)\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " logits = 100. * image_features @ zeroshot_weights\n", + "\n", + " # measure accuracy\n", + " acc1, acc5 = accuracy(logits, target, topk=(1, 5))\n", + " top1 += acc1\n", + " top5 += acc5\n", + " n += images.size(0)\n", + "\n", + "top1 = (top1 / n) * 100\n", + "top5 = (top5 / n) * 100 \n", + "\n", + "print(f\"Top-1 accuracy: {top1:.2f}\")\n", + "print(f\"Top-5 accuracy: {top5:.2f}\")" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84f80a7f3e764346969a347b0f71b24e", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=313.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Top-1 accuracy: 55.93\n", + "Top-5 accuracy: 83.36\n" + ], + "name": "stdout" + } + ] + } + ] +} diff --git a/CLIP/requirements.txt b/CLIP/requirements.txt new file mode 100644 index 0000000..6b98c33 --- /dev/null +++ b/CLIP/requirements.txt @@ -0,0 +1,5 @@ +ftfy +regex +tqdm +torch +torchvision diff --git a/CLIP/setup.py b/CLIP/setup.py new file mode 100644 index 0000000..c9ea7d0 --- /dev/null +++ b/CLIP/setup.py @@ -0,0 +1,21 @@ +import os + +import pkg_resources +from setuptools import setup, find_packages + +setup( + name="clip", + py_modules=["clip"], + version="1.0", + description="", + author="OpenAI", + packages=find_packages(exclude=["tests*"]), + install_requires=[ + str(r) + for r in pkg_resources.parse_requirements( + open(os.path.join(os.path.dirname(__file__), "requirements.txt")) + ) + ], + include_package_data=True, + extras_require={'dev': ['pytest']}, +) diff --git a/CLIP/tests/test_consistency.py b/CLIP/tests/test_consistency.py new file mode 100644 index 0000000..f2c6fd4 --- /dev/null +++ b/CLIP/tests/test_consistency.py @@ -0,0 +1,25 @@ +import numpy as np +import pytest +import torch +from PIL import Image + +import clip + + +@pytest.mark.parametrize('model_name', clip.available_models()) +def test_consistency(model_name): + device = "cpu" + jit_model, transform = clip.load(model_name, device=device, jit=True) + py_model, _ = clip.load(model_name, device=device, jit=False) + + image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device) + text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + + with torch.no_grad(): + logits_per_image, _ = jit_model(image, text) + jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + logits_per_image, _ = py_model(image, text) + py_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1) From 67d69df0b2c7417d7a48bbc680f28270c7219ba9 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:08:52 -0700 Subject: [PATCH 125/197] Add CLIP --- CLIP | 1 - CLIP/.gitignore | 10 + CLIP/CLIP.png | Bin 0 -> 252444 bytes CLIP/LICENSE | 22 + CLIP/MANIFEST.in | 1 + CLIP/README.md | 193 + CLIP/clip/__init__.py | 1 + CLIP/clip/bpe_simple_vocab_16e6.txt.gz | Bin 0 -> 1356917 bytes CLIP/clip/clip.py | 244 ++ CLIP/clip/model.py | 436 +++ CLIP/clip/simple_tokenizer.py | 132 + CLIP/data/country211.md | 12 + CLIP/data/prompts.md | 3401 +++++++++++++++++ CLIP/data/rendered-sst2.md | 11 + CLIP/data/yfcc100m.md | 14 + CLIP/downoad_clip_models.py | 24 + CLIP/hubconf.py | 42 + CLIP/model-card.md | 120 + CLIP/notebooks/Interacting_with_CLIP.ipynb | 925 +++++ .../Prompt_Engineering_for_ImageNet.ipynb | 1107 ++++++ CLIP/requirements.txt | 5 + CLIP/setup.py | 21 + CLIP/tests/test_consistency.py | 25 + 23 files changed, 6746 insertions(+), 1 deletion(-) delete mode 160000 CLIP create mode 100644 CLIP/.gitignore create mode 100644 CLIP/CLIP.png create mode 100644 CLIP/LICENSE create mode 100644 CLIP/MANIFEST.in create mode 100644 CLIP/README.md create mode 100644 CLIP/clip/__init__.py create mode 100644 CLIP/clip/bpe_simple_vocab_16e6.txt.gz create mode 100644 CLIP/clip/clip.py create mode 100644 CLIP/clip/model.py create mode 100644 CLIP/clip/simple_tokenizer.py create mode 100644 CLIP/data/country211.md create mode 100644 CLIP/data/prompts.md create mode 100644 CLIP/data/rendered-sst2.md create mode 100644 CLIP/data/yfcc100m.md create mode 100644 CLIP/downoad_clip_models.py create mode 100644 CLIP/hubconf.py create mode 100644 CLIP/model-card.md create mode 100644 CLIP/notebooks/Interacting_with_CLIP.ipynb create mode 100644 CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb create mode 100644 CLIP/requirements.txt create mode 100644 CLIP/setup.py create mode 100644 CLIP/tests/test_consistency.py diff --git a/CLIP b/CLIP deleted file mode 160000 index d50d76d..0000000 --- a/CLIP +++ /dev/null @@ -1 +0,0 @@ -Subproject commit d50d76daa670286dd6cacf3bcd80b5e4823fc8e1 diff --git a/CLIP/.gitignore b/CLIP/.gitignore new file mode 100644 index 0000000..321f181 --- /dev/null +++ b/CLIP/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.py[cod] +*$py.class +*.egg-info +.pytest_cache +.ipynb_checkpoints + +thumbs.db +.DS_Store +.idea diff --git a/CLIP/CLIP.png b/CLIP/CLIP.png new file mode 100644 index 0000000000000000000000000000000000000000..a1b5ec9171fd7a51e36e845a02304eb837142ba1 GIT binary patch literal 252444 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%0A|F7fvQOLDQFPf3 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

Rp5@H-63rPkl?5M!`%e$q5M^(XmdeOwiW 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%0D+{l&4Elf+RUJ>DPlT<0vI!uxp-LitG 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

nj;X-C@gua07)qPBmS6kxKbsrp_1VbHQ%kr&^ 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�J#6HekB- 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%0DQu49$GwTP{0?>4l_B{}_v8!N|W%zC&9> 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

brXZX@VYhc!=SFxwhp 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 z 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

B0o?DtF!VT!YjrDC^S2?RV?P>**rUM?tSk)et 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 literal 0 HcmV?d00001 diff --git a/CLIP/clip/clip.py b/CLIP/clip/clip.py new file mode 100644 index 0000000..cedac5f --- /dev/null +++ b/CLIP/clip/clip.py @@ -0,0 +1,244 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str, amlt_root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + + amlt_download_target = os.path.join(amlt_root, filename) + if os.path.isfile(amlt_download_target): + if hashlib.sha256(open(amlt_download_target, "rb").read()).hexdigest() == expected_sha256: + return amlt_download_target + + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + # Use an amlt_root for amulet. + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip"), amlt_root='/mnt/default/pretrained_weights') + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/CLIP/clip/model.py b/CLIP/clip/model.py new file mode 100644 index 0000000..232b779 --- /dev/null +++ b/CLIP/clip/model.py @@ -0,0 +1,436 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu1(self.bn1(self.conv1(x))) + out = self.relu2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x[:1], key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + return x.squeeze(0) + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.relu3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=1, keepdim=True) + text_features = text_features / text_features.norm(dim=1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/CLIP/clip/simple_tokenizer.py b/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000..0a66286 --- /dev/null +++ b/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/CLIP/data/country211.md b/CLIP/data/country211.md new file mode 100644 index 0000000..4cd0960 --- /dev/null +++ b/CLIP/data/country211.md @@ -0,0 +1,12 @@ +# The Country211 Dataset + +In the paper, we used an image classification dataset called Country211, to evaluate the model's capability on geolocation. To do so, we filtered the YFCC100m dataset that have GPS coordinate corresponding to a [ISO-3166 country code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) and created a balanced dataset by sampling 150 train images, 50 validation images, and 100 test images images for each country. + +The following command will download an 11GB archive countaining the images and extract into a subdirectory `country211`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/country211.tgz +tar zxvf country211.tgz +``` + +These images are a subset of the YFCC100m dataset. Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/data/prompts.md b/CLIP/data/prompts.md new file mode 100644 index 0000000..6d8aaf7 --- /dev/null +++ b/CLIP/data/prompts.md @@ -0,0 +1,3401 @@ +# Prompts for Image Classification + +Below are the class names and templates that are used for collecting the zero-shot classification scores in the paper. Each dataset has two lists `classes` and `templates`, where the string `{}` in the template is to be replaced with the corresponding class names. For the Facial Emotion Recognition 2013 dataset specifically, we used multiple class names for certain classes. + +This file contains prompt data for 26 of the 27 datasets shown in Table 9 of the paper; the text prompts for ImageNet (as well as other [ImageNet Testbed](https://modestyachts.github.io/imagenet-testbed/) datasets in Figure 13) can be found in [this notebook](https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb), as well as how to ensemble predictions from multiple prompts using these templates. + +If you are viewing this document on GitHub, use the table of contents icon at the upper left to browse the datasets. + + +## Birdsnap + +```bash +classes = [ + 'Acadian Flycatcher', + 'Acorn Woodpecker', + 'Alder Flycatcher', + 'Allens Hummingbird', + 'Altamira Oriole', + 'American Avocet', + 'American Bittern', + 'American Black Duck', + 'American Coot', + 'American Crow', + 'American Dipper', + 'American Golden Plover', + 'American Goldfinch', + 'American Kestrel', + 'American Oystercatcher', + 'American Pipit', + 'American Redstart', + 'American Robin', + 'American Three toed Woodpecker', + 'American Tree Sparrow', + 'American White Pelican', + 'American Wigeon', + 'American Woodcock', + 'Anhinga', + 'Annas Hummingbird', + 'Arctic Tern', + 'Ash throated Flycatcher', + 'Audubons Oriole', + 'Bairds Sandpiper', + 'Bald Eagle', + 'Baltimore Oriole', + 'Band tailed Pigeon', + 'Barn Swallow', + 'Barred Owl', + 'Barrows Goldeneye', + 'Bay breasted Warbler', + 'Bells Vireo', + 'Belted Kingfisher', + 'Bewicks Wren', + 'Black Guillemot', + 'Black Oystercatcher', + 'Black Phoebe', + 'Black Rosy Finch', + 'Black Scoter', + 'Black Skimmer', + 'Black Tern', + 'Black Turnstone', + 'Black Vulture', + 'Black and white Warbler', + 'Black backed Woodpecker', + 'Black bellied Plover', + 'Black billed Cuckoo', + 'Black billed Magpie', + 'Black capped Chickadee', + 'Black chinned Hummingbird', + 'Black chinned Sparrow', + 'Black crested Titmouse', + 'Black crowned Night Heron', + 'Black headed Grosbeak', + 'Black legged Kittiwake', + 'Black necked Stilt', + 'Black throated Blue Warbler', + 'Black throated Gray Warbler', + 'Black throated Green Warbler', + 'Black throated Sparrow', + 'Blackburnian Warbler', + 'Blackpoll Warbler', + 'Blue Grosbeak', + 'Blue Jay', + 'Blue gray Gnatcatcher', + 'Blue headed Vireo', + 'Blue winged Teal', + 'Blue winged Warbler', + 'Boat tailed Grackle', + 'Bobolink', + 'Bohemian Waxwing', + 'Bonapartes Gull', + 'Boreal Chickadee', + 'Brandts Cormorant', + 'Brant', + 'Brewers Blackbird', + 'Brewers Sparrow', + 'Bridled Titmouse', + 'Broad billed Hummingbird', + 'Broad tailed Hummingbird', + 'Broad winged Hawk', + 'Bronzed Cowbird', + 'Brown Creeper', + 'Brown Pelican', + 'Brown Thrasher', + 'Brown capped Rosy Finch', + 'Brown crested Flycatcher', + 'Brown headed Cowbird', + 'Brown headed Nuthatch', + 'Bufflehead', + 'Bullocks Oriole', + 'Burrowing Owl', + 'Bushtit', + 'Cackling Goose', + 'Cactus Wren', + 'California Gull', + 'California Quail', + 'California Thrasher', + 'California Towhee', + 'Calliope Hummingbird', + 'Canada Goose', + 'Canada Warbler', + 'Canvasback', + 'Canyon Towhee', + 'Canyon Wren', + 'Cape May Warbler', + 'Carolina Chickadee', + 'Carolina Wren', + 'Caspian Tern', + 'Cassins Finch', + 'Cassins Kingbird', + 'Cassins Sparrow', + 'Cassins Vireo', + 'Cattle Egret', + 'Cave Swallow', + 'Cedar Waxwing', + 'Cerulean Warbler', + 'Chestnut backed Chickadee', + 'Chestnut collared Longspur', + 'Chestnut sided Warbler', + 'Chihuahuan Raven', + 'Chimney Swift', + 'Chipping Sparrow', + 'Cinnamon Teal', + 'Clapper Rail', + 'Clarks Grebe', + 'Clarks Nutcracker', + 'Clay colored Sparrow', + 'Cliff Swallow', + 'Common Black Hawk', + 'Common Eider', + 'Common Gallinule', + 'Common Goldeneye', + 'Common Grackle', + 'Common Ground Dove', + 'Common Loon', + 'Common Merganser', + 'Common Murre', + 'Common Nighthawk', + 'Common Raven', + 'Common Redpoll', + 'Common Tern', + 'Common Yellowthroat', + 'Connecticut Warbler', + 'Coopers Hawk', + 'Cordilleran Flycatcher', + 'Costas Hummingbird', + 'Couchs Kingbird', + 'Crested Caracara', + 'Curve billed Thrasher', + 'Dark eyed Junco', + 'Dickcissel', + 'Double crested Cormorant', + 'Downy Woodpecker', + 'Dunlin', + 'Dusky Flycatcher', + 'Dusky Grouse', + 'Eared Grebe', + 'Eastern Bluebird', + 'Eastern Kingbird', + 'Eastern Meadowlark', + 'Eastern Phoebe', + 'Eastern Screech Owl', + 'Eastern Towhee', + 'Eastern Wood Pewee', + 'Elegant Trogon', + 'Elf Owl', + 'Eurasian Collared Dove', + 'Eurasian Wigeon', + 'European Starling', + 'Evening Grosbeak', + 'Ferruginous Hawk', + 'Ferruginous Pygmy Owl', + 'Field Sparrow', + 'Fish Crow', + 'Florida Scrub Jay', + 'Forsters Tern', + 'Fox Sparrow', + 'Franklins Gull', + 'Fulvous Whistling Duck', + 'Gadwall', + 'Gambels Quail', + 'Gila Woodpecker', + 'Glaucous Gull', + 'Glaucous winged Gull', + 'Glossy Ibis', + 'Golden Eagle', + 'Golden crowned Kinglet', + 'Golden crowned Sparrow', + 'Golden fronted Woodpecker', + 'Golden winged Warbler', + 'Grasshopper Sparrow', + 'Gray Catbird', + 'Gray Flycatcher', + 'Gray Jay', + 'Gray Kingbird', + 'Gray cheeked Thrush', + 'Gray crowned Rosy Finch', + 'Great Black backed Gull', + 'Great Blue Heron', + 'Great Cormorant', + 'Great Crested Flycatcher', + 'Great Egret', + 'Great Gray Owl', + 'Great Horned Owl', + 'Great Kiskadee', + 'Great tailed Grackle', + 'Greater Prairie Chicken', + 'Greater Roadrunner', + 'Greater Sage Grouse', + 'Greater Scaup', + 'Greater White fronted Goose', + 'Greater Yellowlegs', + 'Green Jay', + 'Green tailed Towhee', + 'Green winged Teal', + 'Groove billed Ani', + 'Gull billed Tern', + 'Hairy Woodpecker', + 'Hammonds Flycatcher', + 'Harlequin Duck', + 'Harriss Hawk', + 'Harriss Sparrow', + 'Heermanns Gull', + 'Henslows Sparrow', + 'Hepatic Tanager', + 'Hermit Thrush', + 'Herring Gull', + 'Hoary Redpoll', + 'Hooded Merganser', + 'Hooded Oriole', + 'Hooded Warbler', + 'Horned Grebe', + 'Horned Lark', + 'House Finch', + 'House Sparrow', + 'House Wren', + 'Huttons Vireo', + 'Iceland Gull', + 'Inca Dove', + 'Indigo Bunting', + 'Killdeer', + 'King Rail', + 'Ladder backed Woodpecker', + 'Lapland Longspur', + 'Lark Bunting', + 'Lark Sparrow', + 'Laughing Gull', + 'Lazuli Bunting', + 'Le Contes Sparrow', + 'Least Bittern', + 'Least Flycatcher', + 'Least Grebe', + 'Least Sandpiper', + 'Least Tern', + 'Lesser Goldfinch', + 'Lesser Nighthawk', + 'Lesser Scaup', + 'Lesser Yellowlegs', + 'Lewiss Woodpecker', + 'Limpkin', + 'Lincolns Sparrow', + 'Little Blue Heron', + 'Loggerhead Shrike', + 'Long billed Curlew', + 'Long billed Dowitcher', + 'Long billed Thrasher', + 'Long eared Owl', + 'Long tailed Duck', + 'Louisiana Waterthrush', + 'Magnificent Frigatebird', + 'Magnolia Warbler', + 'Mallard', + 'Marbled Godwit', + 'Marsh Wren', + 'Merlin', + 'Mew Gull', + 'Mexican Jay', + 'Mississippi Kite', + 'Monk Parakeet', + 'Mottled Duck', + 'Mountain Bluebird', + 'Mountain Chickadee', + 'Mountain Plover', + 'Mourning Dove', + 'Mourning Warbler', + 'Muscovy Duck', + 'Mute Swan', + 'Nashville Warbler', + 'Nelsons Sparrow', + 'Neotropic Cormorant', + 'Northern Bobwhite', + 'Northern Cardinal', + 'Northern Flicker', + 'Northern Gannet', + 'Northern Goshawk', + 'Northern Harrier', + 'Northern Hawk Owl', + 'Northern Mockingbird', + 'Northern Parula', + 'Northern Pintail', + 'Northern Rough winged Swallow', + 'Northern Saw whet Owl', + 'Northern Shrike', + 'Northern Waterthrush', + 'Nuttalls Woodpecker', + 'Oak Titmouse', + 'Olive Sparrow', + 'Olive sided Flycatcher', + 'Orange crowned Warbler', + 'Orchard Oriole', + 'Osprey', + 'Ovenbird', + 'Pacific Golden Plover', + 'Pacific Loon', + 'Pacific Wren', + 'Pacific slope Flycatcher', + 'Painted Bunting', + 'Painted Redstart', + 'Palm Warbler', + 'Pectoral Sandpiper', + 'Peregrine Falcon', + 'Phainopepla', + 'Philadelphia Vireo', + 'Pied billed Grebe', + 'Pigeon Guillemot', + 'Pileated Woodpecker', + 'Pine Grosbeak', + 'Pine Siskin', + 'Pine Warbler', + 'Piping Plover', + 'Plumbeous Vireo', + 'Prairie Falcon', + 'Prairie Warbler', + 'Prothonotary Warbler', + 'Purple Finch', + 'Purple Gallinule', + 'Purple Martin', + 'Purple Sandpiper', + 'Pygmy Nuthatch', + 'Pyrrhuloxia', + 'Red Crossbill', + 'Red Knot', + 'Red Phalarope', + 'Red bellied Woodpecker', + 'Red breasted Merganser', + 'Red breasted Nuthatch', + 'Red breasted Sapsucker', + 'Red cockaded Woodpecker', + 'Red eyed Vireo', + 'Red headed Woodpecker', + 'Red naped Sapsucker', + 'Red necked Grebe', + 'Red necked Phalarope', + 'Red shouldered Hawk', + 'Red tailed Hawk', + 'Red throated Loon', + 'Red winged Blackbird', + 'Reddish Egret', + 'Redhead', + 'Ring billed Gull', + 'Ring necked Duck', + 'Ring necked Pheasant', + 'Rock Pigeon', + 'Rock Ptarmigan', + 'Rock Sandpiper', + 'Rock Wren', + 'Rose breasted Grosbeak', + 'Roseate Tern', + 'Rosss Goose', + 'Rough legged Hawk', + 'Royal Tern', + 'Ruby crowned Kinglet', + 'Ruby throated Hummingbird', + 'Ruddy Duck', + 'Ruddy Turnstone', + 'Ruffed Grouse', + 'Rufous Hummingbird', + 'Rufous crowned Sparrow', + 'Rusty Blackbird', + 'Sage Thrasher', + 'Saltmarsh Sparrow', + 'Sanderling', + 'Sandhill Crane', + 'Sandwich Tern', + 'Says Phoebe', + 'Scaled Quail', + 'Scarlet Tanager', + 'Scissor tailed Flycatcher', + 'Scotts Oriole', + 'Seaside Sparrow', + 'Sedge Wren', + 'Semipalmated Plover', + 'Semipalmated Sandpiper', + 'Sharp shinned Hawk', + 'Sharp tailed Grouse', + 'Short billed Dowitcher', + 'Short eared Owl', + 'Snail Kite', + 'Snow Bunting', + 'Snow Goose', + 'Snowy Egret', + 'Snowy Owl', + 'Snowy Plover', + 'Solitary Sandpiper', + 'Song Sparrow', + 'Sooty Grouse', + 'Sora', + 'Spotted Owl', + 'Spotted Sandpiper', + 'Spotted Towhee', + 'Spruce Grouse', + 'Stellers Jay', + 'Stilt Sandpiper', + 'Summer Tanager', + 'Surf Scoter', + 'Surfbird', + 'Swainsons Hawk', + 'Swainsons Thrush', + 'Swallow tailed Kite', + 'Swamp Sparrow', + 'Tennessee Warbler', + 'Thayers Gull', + 'Townsends Solitaire', + 'Townsends Warbler', + 'Tree Swallow', + 'Tricolored Heron', + 'Tropical Kingbird', + 'Trumpeter Swan', + 'Tufted Titmouse', + 'Tundra Swan', + 'Turkey Vulture', + 'Upland Sandpiper', + 'Varied Thrush', + 'Veery', + 'Verdin', + 'Vermilion Flycatcher', + 'Vesper Sparrow', + 'Violet green Swallow', + 'Virginia Rail', + 'Wandering Tattler', + 'Warbling Vireo', + 'Western Bluebird', + 'Western Grebe', + 'Western Gull', + 'Western Kingbird', + 'Western Meadowlark', + 'Western Sandpiper', + 'Western Screech Owl', + 'Western Scrub Jay', + 'Western Tanager', + 'Western Wood Pewee', + 'Whimbrel', + 'White Ibis', + 'White breasted Nuthatch', + 'White crowned Sparrow', + 'White eyed Vireo', + 'White faced Ibis', + 'White headed Woodpecker', + 'White rumped Sandpiper', + 'White tailed Hawk', + 'White tailed Kite', + 'White tailed Ptarmigan', + 'White throated Sparrow', + 'White throated Swift', + 'White winged Crossbill', + 'White winged Dove', + 'White winged Scoter', + 'Wild Turkey', + 'Willet', + 'Williamsons Sapsucker', + 'Willow Flycatcher', + 'Willow Ptarmigan', + 'Wilsons Phalarope', + 'Wilsons Plover', + 'Wilsons Snipe', + 'Wilsons Warbler', + 'Winter Wren', + 'Wood Stork', + 'Wood Thrush', + 'Worm eating Warbler', + 'Wrentit', + 'Yellow Warbler', + 'Yellow bellied Flycatcher', + 'Yellow bellied Sapsucker', + 'Yellow billed Cuckoo', + 'Yellow billed Magpie', + 'Yellow breasted Chat', + 'Yellow crowned Night Heron', + 'Yellow eyed Junco', + 'Yellow headed Blackbird', + 'Yellow rumped Warbler', + 'Yellow throated Vireo', + 'Yellow throated Warbler', + 'Zone tailed Hawk', +] + +templates = [ + 'a photo of a {}, a type of bird.', +] +``` + + + +## CIFAR10 + +```bash +classes = [ + 'airplane', + 'automobile', + 'bird', + 'cat', + 'deer', + 'dog', + 'frog', + 'horse', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CIFAR100 + +```bash +classes = [ + 'apple', + 'aquarium fish', + 'baby', + 'bear', + 'beaver', + 'bed', + 'bee', + 'beetle', + 'bicycle', + 'bottle', + 'bowl', + 'boy', + 'bridge', + 'bus', + 'butterfly', + 'camel', + 'can', + 'castle', + 'caterpillar', + 'cattle', + 'chair', + 'chimpanzee', + 'clock', + 'cloud', + 'cockroach', + 'couch', + 'crab', + 'crocodile', + 'cup', + 'dinosaur', + 'dolphin', + 'elephant', + 'flatfish', + 'forest', + 'fox', + 'girl', + 'hamster', + 'house', + 'kangaroo', + 'keyboard', + 'lamp', + 'lawn mower', + 'leopard', + 'lion', + 'lizard', + 'lobster', + 'man', + 'maple tree', + 'motorcycle', + 'mountain', + 'mouse', + 'mushroom', + 'oak tree', + 'orange', + 'orchid', + 'otter', + 'palm tree', + 'pear', + 'pickup truck', + 'pine tree', + 'plain', + 'plate', + 'poppy', + 'porcupine', + 'possum', + 'rabbit', + 'raccoon', + 'ray', + 'road', + 'rocket', + 'rose', + 'sea', + 'seal', + 'shark', + 'shrew', + 'skunk', + 'skyscraper', + 'snail', + 'snake', + 'spider', + 'squirrel', + 'streetcar', + 'sunflower', + 'sweet pepper', + 'table', + 'tank', + 'telephone', + 'television', + 'tiger', + 'tractor', + 'train', + 'trout', + 'tulip', + 'turtle', + 'wardrobe', + 'whale', + 'willow tree', + 'wolf', + 'woman', + 'worm', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CLEVRCounts + +```bash +classes = [ + '10', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of {} objects.', +] +``` + + + +## Caltech101 + +```bash +classes = [ + 'background', + 'off-center face', + 'centered face', + 'leopard', + 'motorbike', + 'accordion', + 'airplane', + 'anchor', + 'ant', + 'barrel', + 'bass', + 'beaver', + 'binocular', + 'bonsai', + 'brain', + 'brontosaurus', + 'buddha', + 'butterfly', + 'camera', + 'cannon', + 'side of a car', + 'ceiling fan', + 'cellphone', + 'chair', + 'chandelier', + 'body of a cougar cat', + 'face of a cougar cat', + 'crab', + 'crayfish', + 'crocodile', + 'head of a crocodile', + 'cup', + 'dalmatian', + 'dollar bill', + 'dolphin', + 'dragonfly', + 'electric guitar', + 'elephant', + 'emu', + 'euphonium', + 'ewer', + 'ferry', + 'flamingo', + 'head of a flamingo', + 'garfield', + 'gerenuk', + 'gramophone', + 'grand piano', + 'hawksbill', + 'headphone', + 'hedgehog', + 'helicopter', + 'ibis', + 'inline skate', + 'joshua tree', + 'kangaroo', + 'ketch', + 'lamp', + 'laptop', + 'llama', + 'lobster', + 'lotus', + 'mandolin', + 'mayfly', + 'menorah', + 'metronome', + 'minaret', + 'nautilus', + 'octopus', + 'okapi', + 'pagoda', + 'panda', + 'pigeon', + 'pizza', + 'platypus', + 'pyramid', + 'revolver', + 'rhino', + 'rooster', + 'saxophone', + 'schooner', + 'scissors', + 'scorpion', + 'sea horse', + 'snoopy (cartoon beagle)', + 'soccer ball', + 'stapler', + 'starfish', + 'stegosaurus', + 'stop sign', + 'strawberry', + 'sunflower', + 'tick', + 'trilobite', + 'umbrella', + 'watch', + 'water lilly', + 'wheelchair', + 'wild cat', + 'windsor chair', + 'wrench', + 'yin and yang symbol', +] + +templates = [ + 'a photo of a {}.', + 'a painting of a {}.', + 'a plastic {}.', + 'a sculpture of a {}.', + 'a sketch of a {}.', + 'a tattoo of a {}.', + 'a toy {}.', + 'a rendition of a {}.', + 'a embroidered {}.', + 'a cartoon {}.', + 'a {} in a video game.', + 'a plushie {}.', + 'a origami {}.', + 'art of a {}.', + 'graffiti of a {}.', + 'a drawing of a {}.', + 'a doodle of a {}.', + 'a photo of the {}.', + 'a painting of the {}.', + 'the plastic {}.', + 'a sculpture of the {}.', + 'a sketch of the {}.', + 'a tattoo of the {}.', + 'the toy {}.', + 'a rendition of the {}.', + 'the embroidered {}.', + 'the cartoon {}.', + 'the {} in a video game.', + 'the plushie {}.', + 'the origami {}.', + 'art of the {}.', + 'graffiti of the {}.', + 'a drawing of the {}.', + 'a doodle of the {}.', +] +``` + + + +## Country211 + +```bash +classes = [ + 'Andorra', + 'United Arab Emirates', + 'Afghanistan', + 'Antigua and Barbuda', + 'Anguilla', + 'Albania', + 'Armenia', + 'Angola', + 'Antarctica', + 'Argentina', + 'Austria', + 'Australia', + 'Aruba', + 'Aland Islands', + 'Azerbaijan', + 'Bosnia and Herzegovina', + 'Barbados', + 'Bangladesh', + 'Belgium', + 'Burkina Faso', + 'Bulgaria', + 'Bahrain', + 'Benin', + 'Bermuda', + 'Brunei Darussalam', + 'Bolivia', + 'Bonaire, Saint Eustatius and Saba', + 'Brazil', + 'Bahamas', + 'Bhutan', + 'Botswana', + 'Belarus', + 'Belize', + 'Canada', + 'DR Congo', + 'Central African Republic', + 'Switzerland', + "Cote d'Ivoire", + 'Cook Islands', + 'Chile', + 'Cameroon', + 'China', + 'Colombia', + 'Costa Rica', + 'Cuba', + 'Cabo Verde', + 'Curacao', + 'Cyprus', + 'Czech Republic', + 'Germany', + 'Denmark', + 'Dominica', + 'Dominican Republic', + 'Algeria', + 'Ecuador', + 'Estonia', + 'Egypt', + 'Spain', + 'Ethiopia', + 'Finland', + 'Fiji', + 'Falkland Islands', + 'Faeroe Islands', + 'France', + 'Gabon', + 'United Kingdom', + 'Grenada', + 'Georgia', + 'French Guiana', + 'Guernsey', + 'Ghana', + 'Gibraltar', + 'Greenland', + 'Gambia', + 'Guadeloupe', + 'Greece', + 'South Georgia and South Sandwich Is.', + 'Guatemala', + 'Guam', + 'Guyana', + 'Hong Kong', + 'Honduras', + 'Croatia', + 'Haiti', + 'Hungary', + 'Indonesia', + 'Ireland', + 'Israel', + 'Isle of Man', + 'India', + 'Iraq', + 'Iran', + 'Iceland', + 'Italy', + 'Jersey', + 'Jamaica', + 'Jordan', + 'Japan', + 'Kenya', + 'Kyrgyz Republic', + 'Cambodia', + 'St. Kitts and Nevis', + 'North Korea', + 'South Korea', + 'Kuwait', + 'Cayman Islands', + 'Kazakhstan', + 'Laos', + 'Lebanon', + 'St. Lucia', + 'Liechtenstein', + 'Sri Lanka', + 'Liberia', + 'Lithuania', + 'Luxembourg', + 'Latvia', + 'Libya', + 'Morocco', + 'Monaco', + 'Moldova', + 'Montenegro', + 'Saint-Martin', + 'Madagascar', + 'Macedonia', + 'Mali', + 'Myanmar', + 'Mongolia', + 'Macau', + 'Martinique', + 'Mauritania', + 'Malta', + 'Mauritius', + 'Maldives', + 'Malawi', + 'Mexico', + 'Malaysia', + 'Mozambique', + 'Namibia', + 'New Caledonia', + 'Nigeria', + 'Nicaragua', + 'Netherlands', + 'Norway', + 'Nepal', + 'New Zealand', + 'Oman', + 'Panama', + 'Peru', + 'French Polynesia', + 'Papua New Guinea', + 'Philippines', + 'Pakistan', + 'Poland', + 'Puerto Rico', + 'Palestine', + 'Portugal', + 'Palau', + 'Paraguay', + 'Qatar', + 'Reunion', + 'Romania', + 'Serbia', + 'Russia', + 'Rwanda', + 'Saudi Arabia', + 'Solomon Islands', + 'Seychelles', + 'Sudan', + 'Sweden', + 'Singapore', + 'St. Helena', + 'Slovenia', + 'Svalbard and Jan Mayen Islands', + 'Slovakia', + 'Sierra Leone', + 'San Marino', + 'Senegal', + 'Somalia', + 'South Sudan', + 'El Salvador', + 'Sint Maarten', + 'Syria', + 'Eswatini', + 'Togo', + 'Thailand', + 'Tajikistan', + 'Timor-Leste', + 'Turkmenistan', + 'Tunisia', + 'Tonga', + 'Turkey', + 'Trinidad and Tobago', + 'Taiwan', + 'Tanzania', + 'Ukraine', + 'Uganda', + 'United States', + 'Uruguay', + 'Uzbekistan', + 'Vatican', + 'Venezuela', + 'British Virgin Islands', + 'United States Virgin Islands', + 'Vietnam', + 'Vanuatu', + 'Samoa', + 'Kosovo', + 'Yemen', + 'South Africa', + 'Zambia', + 'Zimbabwe', +] + +templates = [ + 'a photo i took in {}.', + 'a photo i took while visiting {}.', + 'a photo from my home country of {}.', + 'a photo from my visit to {}.', + 'a photo showing the country of {}.', +] +``` + + + +## DescribableTextures + +```bash +classes = [ + 'banded', + 'blotchy', + 'braided', + 'bubbly', + 'bumpy', + 'chequered', + 'cobwebbed', + 'cracked', + 'crosshatched', + 'crystalline', + 'dotted', + 'fibrous', + 'flecked', + 'freckled', + 'frilly', + 'gauzy', + 'grid', + 'grooved', + 'honeycombed', + 'interlaced', + 'knitted', + 'lacelike', + 'lined', + 'marbled', + 'matted', + 'meshed', + 'paisley', + 'perforated', + 'pitted', + 'pleated', + 'polka-dotted', + 'porous', + 'potholed', + 'scaly', + 'smeared', + 'spiralled', + 'sprinkled', + 'stained', + 'stratified', + 'striped', + 'studded', + 'swirly', + 'veined', + 'waffled', + 'woven', + 'wrinkled', + 'zigzagged', +] + +templates = [ + 'a photo of a {} texture.', + 'a photo of a {} pattern.', + 'a photo of a {} thing.', + 'a photo of a {} object.', + 'a photo of the {} texture.', + 'a photo of the {} pattern.', + 'a photo of the {} thing.', + 'a photo of the {} object.', +] +``` + + + +## EuroSAT + +```bash +classes = [ + 'forest', + 'permanent crop land', + 'residential buildings or homes or apartments', + 'river', + 'pasture land', + 'lake or sea', + 'brushland or shrubland', + 'annual crop land', + 'industrial buildings or commercial buildings', + 'highway or road', +] + +templates = [ + 'a centered satellite photo of {}.', + 'a centered satellite photo of a {}.', + 'a centered satellite photo of the {}.', +] +``` + + + +## FGVCAircraft + +```bash +classes = [ + '707-320', + '727-200', + '737-200', + '737-300', + '737-400', + '737-500', + '737-600', + '737-700', + '737-800', + '737-900', + '747-100', + '747-200', + '747-300', + '747-400', + '757-200', + '757-300', + '767-200', + '767-300', + '767-400', + '777-200', + '777-300', + 'A300B4', + 'A310', + 'A318', + 'A319', + 'A320', + 'A321', + 'A330-200', + 'A330-300', + 'A340-200', + 'A340-300', + 'A340-500', + 'A340-600', + 'A380', + 'ATR-42', + 'ATR-72', + 'An-12', + 'BAE 146-200', + 'BAE 146-300', + 'BAE-125', + 'Beechcraft 1900', + 'Boeing 717', + 'C-130', + 'C-47', + 'CRJ-200', + 'CRJ-700', + 'CRJ-900', + 'Cessna 172', + 'Cessna 208', + 'Cessna 525', + 'Cessna 560', + 'Challenger 600', + 'DC-10', + 'DC-3', + 'DC-6', + 'DC-8', + 'DC-9-30', + 'DH-82', + 'DHC-1', + 'DHC-6', + 'DHC-8-100', + 'DHC-8-300', + 'DR-400', + 'Dornier 328', + 'E-170', + 'E-190', + 'E-195', + 'EMB-120', + 'ERJ 135', + 'ERJ 145', + 'Embraer Legacy 600', + 'Eurofighter Typhoon', + 'F-16A/B', + 'F/A-18', + 'Falcon 2000', + 'Falcon 900', + 'Fokker 100', + 'Fokker 50', + 'Fokker 70', + 'Global Express', + 'Gulfstream IV', + 'Gulfstream V', + 'Hawk T1', + 'Il-76', + 'L-1011', + 'MD-11', + 'MD-80', + 'MD-87', + 'MD-90', + 'Metroliner', + 'Model B200', + 'PA-28', + 'SR-20', + 'Saab 2000', + 'Saab 340', + 'Spitfire', + 'Tornado', + 'Tu-134', + 'Tu-154', + 'Yak-42', +] + +templates = [ + 'a photo of a {}, a type of aircraft.', + 'a photo of the {}, a type of aircraft.', +] +``` + + + +## FacialEmotionRecognition2013 + +```bash +classes = [ + ['angry'], + ['disgusted'], + ['fearful'], + ['happy', 'smiling'], + ['sad', 'depressed'], + ['surprised', 'shocked', 'spooked'], + ['neutral', 'bored'], +] + +templates = [ + 'a photo of a {} looking face.', + 'a photo of a face showing the emotion: {}.', + 'a photo of a face looking {}.', + 'a face that looks {}.', + 'they look {}.', + 'look at how {} they are.', +] +``` + + + +## Flowers102 + +```bash +classes = [ + 'pink primrose', + 'hard-leaved pocket orchid', + 'canterbury bells', + 'sweet pea', + 'english marigold', + 'tiger lily', + 'moon orchid', + 'bird of paradise', + 'monkshood', + 'globe thistle', + 'snapdragon', + "colt's foot", + 'king protea', + 'spear thistle', + 'yellow iris', + 'globe flower', + 'purple coneflower', + 'peruvian lily', + 'balloon flower', + 'giant white arum lily', + 'fire lily', + 'pincushion flower', + 'fritillary', + 'red ginger', + 'grape hyacinth', + 'corn poppy', + 'prince of wales feathers', + 'stemless gentian', + 'artichoke', + 'sweet william', + 'carnation', + 'garden phlox', + 'love in the mist', + 'mexican aster', + 'alpine sea holly', + 'ruby-lipped cattleya', + 'cape flower', + 'great masterwort', + 'siam tulip', + 'lenten rose', + 'barbeton daisy', + 'daffodil', + 'sword lily', + 'poinsettia', + 'bolero deep blue', + 'wallflower', + 'marigold', + 'buttercup', + 'oxeye daisy', + 'common dandelion', + 'petunia', + 'wild pansy', + 'primula', + 'sunflower', + 'pelargonium', + 'bishop of llandaff', + 'gaura', + 'geranium', + 'orange dahlia', + 'pink and yellow dahlia', + 'cautleya spicata', + 'japanese anemone', + 'black-eyed susan', + 'silverbush', + 'californian poppy', + 'osteospermum', + 'spring crocus', + 'bearded iris', + 'windflower', + 'tree poppy', + 'gazania', + 'azalea', + 'water lily', + 'rose', + 'thorn apple', + 'morning glory', + 'passion flower', + 'lotus', + 'toad lily', + 'anthurium', + 'frangipani', + 'clematis', + 'hibiscus', + 'columbine', + 'desert-rose', + 'tree mallow', + 'magnolia', + 'cyclamen', + 'watercress', + 'canna lily', + 'hippeastrum', + 'bee balm', + 'air plant', + 'foxglove', + 'bougainvillea', + 'camellia', + 'mallow', + 'mexican petunia', + 'bromelia', + 'blanket flower', + 'trumpet creeper', + 'blackberry lily', +] + +templates = [ + 'a photo of a {}, a type of flower.', +] +``` + + + +## Food101 + +```bash +classes = [ + 'apple pie', + 'baby back ribs', + 'baklava', + 'beef carpaccio', + 'beef tartare', + 'beet salad', + 'beignets', + 'bibimbap', + 'bread pudding', + 'breakfast burrito', + 'bruschetta', + 'caesar salad', + 'cannoli', + 'caprese salad', + 'carrot cake', + 'ceviche', + 'cheese plate', + 'cheesecake', + 'chicken curry', + 'chicken quesadilla', + 'chicken wings', + 'chocolate cake', + 'chocolate mousse', + 'churros', + 'clam chowder', + 'club sandwich', + 'crab cakes', + 'creme brulee', + 'croque madame', + 'cup cakes', + 'deviled eggs', + 'donuts', + 'dumplings', + 'edamame', + 'eggs benedict', + 'escargots', + 'falafel', + 'filet mignon', + 'fish and chips', + 'foie gras', + 'french fries', + 'french onion soup', + 'french toast', + 'fried calamari', + 'fried rice', + 'frozen yogurt', + 'garlic bread', + 'gnocchi', + 'greek salad', + 'grilled cheese sandwich', + 'grilled salmon', + 'guacamole', + 'gyoza', + 'hamburger', + 'hot and sour soup', + 'hot dog', + 'huevos rancheros', + 'hummus', + 'ice cream', + 'lasagna', + 'lobster bisque', + 'lobster roll sandwich', + 'macaroni and cheese', + 'macarons', + 'miso soup', + 'mussels', + 'nachos', + 'omelette', + 'onion rings', + 'oysters', + 'pad thai', + 'paella', + 'pancakes', + 'panna cotta', + 'peking duck', + 'pho', + 'pizza', + 'pork chop', + 'poutine', + 'prime rib', + 'pulled pork sandwich', + 'ramen', + 'ravioli', + 'red velvet cake', + 'risotto', + 'samosa', + 'sashimi', + 'scallops', + 'seaweed salad', + 'shrimp and grits', + 'spaghetti bolognese', + 'spaghetti carbonara', + 'spring rolls', + 'steak', + 'strawberry shortcake', + 'sushi', + 'tacos', + 'takoyaki', + 'tiramisu', + 'tuna tartare', + 'waffles', +] + +templates = [ + 'a photo of {}, a type of food.', +] +``` + + + +## GTSRB + +```bash +classes = [ + 'red and white circle 20 kph speed limit', + 'red and white circle 30 kph speed limit', + 'red and white circle 50 kph speed limit', + 'red and white circle 60 kph speed limit', + 'red and white circle 70 kph speed limit', + 'red and white circle 80 kph speed limit', + 'end / de-restriction of 80 kph speed limit', + 'red and white circle 100 kph speed limit', + 'red and white circle 120 kph speed limit', + 'red and white circle red car and black car no passing', + 'red and white circle red truck and black car no passing', + 'red and white triangle road intersection warning', + 'white and yellow diamond priority road', + 'red and white upside down triangle yield right-of-way', + 'stop', + 'empty red and white circle', + 'red and white circle no truck entry', + 'red circle with white horizonal stripe no entry', + 'red and white triangle with exclamation mark warning', + 'red and white triangle with black left curve approaching warning', + 'red and white triangle with black right curve approaching warning', + 'red and white triangle with black double curve approaching warning', + 'red and white triangle rough / bumpy road warning', + 'red and white triangle car skidding / slipping warning', + 'red and white triangle with merging / narrow lanes warning', + 'red and white triangle with person digging / construction / road work warning', + 'red and white triangle with traffic light approaching warning', + 'red and white triangle with person walking warning', + 'red and white triangle with child and person walking warning', + 'red and white triangle with bicyle warning', + 'red and white triangle with snowflake / ice warning', + 'red and white triangle with deer warning', + 'white circle with gray strike bar no speed limit', + 'blue circle with white right turn arrow mandatory', + 'blue circle with white left turn arrow mandatory', + 'blue circle with white forward arrow mandatory', + 'blue circle with white forward or right turn arrow mandatory', + 'blue circle with white forward or left turn arrow mandatory', + 'blue circle with white keep right arrow mandatory', + 'blue circle with white keep left arrow mandatory', + 'blue circle with white arrows indicating a traffic circle', + 'white circle with gray strike bar indicating no passing for cars has ended', + 'white circle with gray strike bar indicating no passing for trucks has ended', +] + +templates = [ + 'a zoomed in photo of a "{}" traffic sign.', + 'a centered photo of a "{}" traffic sign.', + 'a close up photo of a "{}" traffic sign.', +] +``` + + + +## HatefulMemes + +```bash +classes = [ + 'meme', + 'hatespeech meme', +] + +templates = [ + 'a {}.', +] +``` + + + +## KITTI + +```bash +classes = [ + 'a photo i took of a car on my left or right side.', + 'a photo i took with a car nearby.', + 'a photo i took with a car in the distance.', + 'a photo i took with no car.', +] + +templates = [ + '{}', +] +``` + + + +## Kinetics700 + +```bash +classes = [ + 'abseiling', + 'acting in play', + 'adjusting glasses', + 'air drumming', + 'alligator wrestling', + 'answering questions', + 'applauding', + 'applying cream', + 'archaeological excavation', + 'archery', + 'arguing', + 'arm wrestling', + 'arranging flowers', + 'arresting', + 'assembling bicycle', + 'assembling computer', + 'attending conference', + 'auctioning', + 'baby waking up', + 'backflip (human)', + 'baking cookies', + 'bandaging', + 'barbequing', + 'bartending', + 'base jumping', + 'bathing dog', + 'battle rope training', + 'beatboxing', + 'bee keeping', + 'being excited', + 'being in zero gravity', + 'belly dancing', + 'bench pressing', + 'bending back', + 'bending metal', + 'biking through snow', + 'blasting sand', + 'blending fruit', + 'blowdrying hair', + 'blowing bubble gum', + 'blowing glass', + 'blowing leaves', + 'blowing nose', + 'blowing out candles', + 'bobsledding', + 'bodysurfing', + 'bookbinding', + 'bottling', + 'bouncing ball (not juggling)', + 'bouncing on bouncy castle', + 'bouncing on trampoline', + 'bowling', + 'braiding hair', + 'breading or breadcrumbing', + 'breakdancing', + 'breaking boards', + 'breaking glass', + 'breathing fire', + 'brush painting', + 'brushing floor', + 'brushing hair', + 'brushing teeth', + 'building cabinet', + 'building lego', + 'building sandcastle', + 'building shed', + 'bulldozing', + 'bungee jumping', + 'burping', + 'busking', + 'calculating', + 'calligraphy', + 'canoeing or kayaking', + 'capoeira', + 'capsizing', + 'card stacking', + 'card throwing', + 'carrying baby', + 'carrying weight', + 'cartwheeling', + 'carving ice', + 'carving marble', + 'carving pumpkin', + 'carving wood with a knife', + 'casting fishing line', + 'catching fish', + 'catching or throwing baseball', + 'catching or throwing frisbee', + 'catching or throwing softball', + 'celebrating', + 'changing gear in car', + 'changing oil', + 'changing wheel (not on bike)', + 'chasing', + 'checking tires', + 'checking watch', + 'cheerleading', + 'chewing gum', + 'chiseling stone', + 'chiseling wood', + 'chopping meat', + 'chopping wood', + 'clam digging', + 'clapping', + 'clay pottery making', + 'clean and jerk', + 'cleaning gutters', + 'cleaning pool', + 'cleaning shoes', + 'cleaning toilet', + 'cleaning windows', + 'climbing a rope', + 'climbing ladder', + 'climbing tree', + 'closing door', + 'coloring in', + 'combing hair', + 'contact juggling', + 'contorting', + 'cooking chicken', + 'cooking egg', + 'cooking on campfire', + 'cooking sausages (not on barbeque)', + 'cooking scallops', + 'cosplaying', + 'coughing', + 'counting money', + 'country line dancing', + 'cracking back', + 'cracking knuckles', + 'cracking neck', + 'crawling baby', + 'crocheting', + 'crossing eyes', + 'crossing river', + 'crying', + 'cumbia', + 'curling (sport)', + 'curling eyelashes', + 'curling hair', + 'cutting apple', + 'cutting cake', + 'cutting nails', + 'cutting orange', + 'cutting pineapple', + 'cutting watermelon', + 'dancing ballet', + 'dancing charleston', + 'dancing gangnam style', + 'dancing macarena', + 'deadlifting', + 'dealing cards', + 'decorating the christmas tree', + 'decoupage', + 'delivering mail', + 'digging', + 'dining', + 'directing traffic', + 'disc golfing', + 'diving cliff', + 'docking boat', + 'dodgeball', + 'doing aerobics', + 'doing jigsaw puzzle', + 'doing laundry', + 'doing nails', + 'doing sudoku', + 'drawing', + 'dribbling basketball', + 'drinking shots', + 'driving car', + 'driving tractor', + 'drooling', + 'drop kicking', + 'drumming fingers', + 'dumpster diving', + 'dunking basketball', + 'dyeing eyebrows', + 'dyeing hair', + 'eating burger', + 'eating cake', + 'eating carrots', + 'eating chips', + 'eating doughnuts', + 'eating hotdog', + 'eating ice cream', + 'eating nachos', + 'eating spaghetti', + 'eating watermelon', + 'egg hunting', + 'embroidering', + 'entering church', + 'exercising arm', + 'exercising with an exercise ball', + 'extinguishing fire', + 'faceplanting', + 'falling off bike', + 'falling off chair', + 'feeding birds', + 'feeding fish', + 'feeding goats', + 'fencing (sport)', + 'fidgeting', + 'filling cake', + 'filling eyebrows', + 'finger snapping', + 'fixing bicycle', + 'fixing hair', + 'flint knapping', + 'flipping bottle', + 'flipping pancake', + 'fly tying', + 'flying kite', + 'folding clothes', + 'folding napkins', + 'folding paper', + 'front raises', + 'frying vegetables', + 'gargling', + 'geocaching', + 'getting a haircut', + 'getting a piercing', + 'getting a tattoo', + 'giving or receiving award', + 'gold panning', + 'golf chipping', + 'golf driving', + 'golf putting', + 'gospel singing in church', + 'grinding meat', + 'grooming cat', + 'grooming dog', + 'grooming horse', + 'gymnastics tumbling', + 'hammer throw', + 'hand washing clothes', + 'head stand', + 'headbanging', + 'headbutting', + 'helmet diving', + 'herding cattle', + 'high fiving', + 'high jump', + 'high kick', + 'historical reenactment', + 'hitting baseball', + 'hockey stop', + 'holding snake', + 'home roasting coffee', + 'hopscotch', + 'hoverboarding', + 'huddling', + 'hugging (not baby)', + 'hugging baby', + 'hula hooping', + 'hurdling', + 'hurling (sport)', + 'ice climbing', + 'ice fishing', + 'ice skating', + 'ice swimming', + 'inflating balloons', + 'installing carpet', + 'ironing', + 'ironing hair', + 'javelin throw', + 'jaywalking', + 'jetskiing', + 'jogging', + 'juggling balls', + 'juggling fire', + 'juggling soccer ball', + 'jumping bicycle', + 'jumping into pool', + 'jumping jacks', + 'jumping sofa', + 'jumpstyle dancing', + 'karaoke', + 'kicking field goal', + 'kicking soccer ball', + 'kissing', + 'kitesurfing', + 'knitting', + 'krumping', + 'land sailing', + 'laughing', + 'lawn mower racing', + 'laying bricks', + 'laying concrete', + 'laying decking', + 'laying stone', + 'laying tiles', + 'leatherworking', + 'letting go of balloon', + 'licking', + 'lifting hat', + 'lighting candle', + 'lighting fire', + 'listening with headphones', + 'lock picking', + 'long jump', + 'longboarding', + 'looking at phone', + 'looking in mirror', + 'luge', + 'lunge', + 'making a cake', + 'making a sandwich', + 'making balloon shapes', + 'making bubbles', + 'making cheese', + 'making horseshoes', + 'making jewelry', + 'making latte art', + 'making paper aeroplanes', + 'making pizza', + 'making slime', + 'making snowman', + 'making sushi', + 'making tea', + 'making the bed', + 'marching', + 'marriage proposal', + 'massaging back', + 'massaging feet', + 'massaging legs', + 'massaging neck', + "massaging person's head", + 'metal detecting', + 'milking cow', + 'milking goat', + 'mixing colours', + 'moon walking', + 'mopping floor', + 'mosh pit dancing', + 'motorcycling', + 'mountain climber (exercise)', + 'moving baby', + 'moving child', + 'moving furniture', + 'mowing lawn', + 'mushroom foraging', + 'needle felting', + 'news anchoring', + 'opening bottle (not wine)', + 'opening coconuts', + 'opening door', + 'opening present', + 'opening refrigerator', + 'opening wine bottle', + 'packing', + 'paragliding', + 'parasailing', + 'parkour', + 'passing American football (in game)', + 'passing American football (not in game)', + 'passing soccer ball', + 'peeling apples', + 'peeling banana', + 'peeling potatoes', + 'person collecting garbage', + 'petting animal (not cat)', + 'petting cat', + 'petting horse', + 'photobombing', + 'photocopying', + 'picking apples', + 'picking blueberries', + 'pillow fight', + 'pinching', + 'pirouetting', + 'planing wood', + 'planting trees', + 'plastering', + 'playing accordion', + 'playing american football', + 'playing badminton', + 'playing bagpipes', + 'playing basketball', + 'playing bass guitar', + 'playing beer pong', + 'playing billiards', + 'playing blackjack', + 'playing cards', + 'playing cello', + 'playing checkers', + 'playing chess', + 'playing clarinet', + 'playing controller', + 'playing cricket', + 'playing cymbals', + 'playing darts', + 'playing didgeridoo', + 'playing dominoes', + 'playing drums', + 'playing field hockey', + 'playing flute', + 'playing gong', + 'playing guitar', + 'playing hand clapping games', + 'playing harmonica', + 'playing harp', + 'playing ice hockey', + 'playing keyboard', + 'playing kickball', + 'playing laser tag', + 'playing lute', + 'playing mahjong', + 'playing maracas', + 'playing marbles', + 'playing monopoly', + 'playing netball', + 'playing nose flute', + 'playing oboe', + 'playing ocarina', + 'playing organ', + 'playing paintball', + 'playing pan pipes', + 'playing piano', + 'playing piccolo', + 'playing pinball', + 'playing ping pong', + 'playing poker', + 'playing polo', + 'playing recorder', + 'playing road hockey', + 'playing rounders', + 'playing rubiks cube', + 'playing saxophone', + 'playing scrabble', + 'playing shuffleboard', + 'playing slot machine', + 'playing squash or racquetball', + 'playing tennis', + 'playing trombone', + 'playing trumpet', + 'playing ukulele', + 'playing violin', + 'playing volleyball', + 'playing with trains', + 'playing xylophone', + 'poaching eggs', + 'poking bellybutton', + 'pole vault', + 'polishing furniture', + 'polishing metal', + 'popping balloons', + 'pouring beer', + 'pouring milk', + 'pouring wine', + 'preparing salad', + 'presenting weather forecast', + 'pretending to be a statue', + 'pull ups', + 'pulling espresso shot', + 'pulling rope (game)', + 'pumping fist', + 'pumping gas', + 'punching bag', + 'punching person (boxing)', + 'push up', + 'pushing car', + 'pushing cart', + 'pushing wheelbarrow', + 'pushing wheelchair', + 'putting in contact lenses', + 'putting on eyeliner', + 'putting on foundation', + 'putting on lipstick', + 'putting on mascara', + 'putting on sari', + 'putting on shoes', + 'putting wallpaper on wall', + 'raising eyebrows', + 'reading book', + 'reading newspaper', + 'recording music', + 'repairing puncture', + 'riding a bike', + 'riding camel', + 'riding elephant', + 'riding mechanical bull', + 'riding mule', + 'riding or walking with horse', + 'riding scooter', + 'riding snow blower', + 'riding unicycle', + 'ripping paper', + 'roasting marshmallows', + 'roasting pig', + 'robot dancing', + 'rock climbing', + 'rock scissors paper', + 'roller skating', + 'rolling eyes', + 'rolling pastry', + 'rope pushdown', + 'running on treadmill', + 'sailing', + 'salsa dancing', + 'saluting', + 'sanding floor', + 'sanding wood', + 'sausage making', + 'sawing wood', + 'scrambling eggs', + 'scrapbooking', + 'scrubbing face', + 'scuba diving', + 'seasoning food', + 'separating eggs', + 'setting table', + 'sewing', + 'shaking hands', + 'shaking head', + 'shaping bread dough', + 'sharpening knives', + 'sharpening pencil', + 'shaving head', + 'shaving legs', + 'shearing sheep', + 'shining flashlight', + 'shining shoes', + 'shoot dance', + 'shooting basketball', + 'shooting goal (soccer)', + 'shooting off fireworks', + 'shopping', + 'shot put', + 'shouting', + 'shoveling snow', + 'shredding paper', + 'shucking oysters', + 'shuffling cards', + 'shuffling feet', + 'side kick', + 'sieving', + 'sign language interpreting', + 'silent disco', + 'singing', + 'sipping cup', + 'situp', + 'skateboarding', + 'ski ballet', + 'ski jumping', + 'skiing crosscountry', + 'skiing mono', + 'skiing slalom', + 'skipping rope', + 'skipping stone', + 'skydiving', + 'slacklining', + 'slapping', + 'sled dog racing', + 'sleeping', + 'slicing onion', + 'smashing', + 'smelling feet', + 'smoking', + 'smoking hookah', + 'smoking pipe', + 'snatch weight lifting', + 'sneezing', + 'snorkeling', + 'snowboarding', + 'snowkiting', + 'snowmobiling', + 'somersaulting', + 'spelunking', + 'spinning plates', + 'spinning poi', + 'splashing water', + 'spray painting', + 'spraying', + 'springboard diving', + 'square dancing', + 'squat', + 'squeezing orange', + 'stacking cups', + 'stacking dice', + 'standing on hands', + 'staring', + 'steer roping', + 'steering car', + 'sticking tongue out', + 'stomping grapes', + 'stretching arm', + 'stretching leg', + 'sucking lolly', + 'surfing crowd', + 'surfing water', + 'surveying', + 'sweeping floor', + 'swimming backstroke', + 'swimming breast stroke', + 'swimming butterfly stroke', + 'swimming front crawl', + 'swimming with dolphins', + 'swimming with sharks', + 'swing dancing', + 'swinging baseball bat', + 'swinging on something', + 'sword fighting', + 'sword swallowing', + 'tackling', + 'tagging graffiti', + 'tai chi', + 'taking photo', + 'talking on cell phone', + 'tango dancing', + 'tap dancing', + 'tapping guitar', + 'tapping pen', + 'tasting beer', + 'tasting food', + 'tasting wine', + 'testifying', + 'texting', + 'threading needle', + 'throwing axe', + 'throwing ball (not baseball or American football)', + 'throwing discus', + 'throwing knife', + 'throwing snowballs', + 'throwing tantrum', + 'throwing water balloon', + 'tickling', + 'tie dying', + 'tightrope walking', + 'tiptoeing', + 'tobogganing', + 'tossing coin', + 'tossing salad', + 'training dog', + 'trapezing', + 'treating wood', + 'trimming or shaving beard', + 'trimming shrubs', + 'trimming trees', + 'triple jump', + 'twiddling fingers', + 'tying bow tie', + 'tying knot (not on a tie)', + 'tying necktie', + 'tying shoe laces', + 'unboxing', + 'uncorking champagne', + 'unloading truck', + 'using a microscope', + 'using a paint roller', + 'using a power drill', + 'using a sledge hammer', + 'using a wrench', + 'using atm', + 'using bagging machine', + 'using circular saw', + 'using inhaler', + 'using megaphone', + 'using puppets', + 'using remote controller (not gaming)', + 'using segway', + 'vacuuming car', + 'vacuuming floor', + 'visiting the zoo', + 'wading through mud', + 'wading through water', + 'waiting in line', + 'waking up', + 'walking on stilts', + 'walking the dog', + 'walking through snow', + 'walking with crutches', + 'washing dishes', + 'washing feet', + 'washing hair', + 'washing hands', + 'watching tv', + 'water skiing', + 'water sliding', + 'watering plants', + 'waving hand', + 'waxing armpits', + 'waxing back', + 'waxing chest', + 'waxing eyebrows', + 'waxing legs', + 'weaving basket', + 'weaving fabric', + 'welding', + 'whistling', + 'windsurfing', + 'winking', + 'wood burning (art)', + 'wrapping present', + 'wrestling', + 'writing', + 'yarn spinning', + 'yawning', + 'yoga', + 'zumba' +] + +templates = [ + 'a photo of {}.', + 'a photo of a person {}.', + 'a photo of a person using {}.', + 'a photo of a person doing {}.', + 'a photo of a person during {}.', + 'a photo of a person performing {}.', + 'a photo of a person practicing {}.', + 'a video of {}.', + 'a video of a person {}.', + 'a video of a person using {}.', + 'a video of a person doing {}.', + 'a video of a person during {}.', + 'a video of a person performing {}.', + 'a video of a person practicing {}.', + 'a example of {}.', + 'a example of a person {}.', + 'a example of a person using {}.', + 'a example of a person doing {}.', + 'a example of a person during {}.', + 'a example of a person performing {}.', + 'a example of a person practicing {}.', + 'a demonstration of {}.', + 'a demonstration of a person {}.', + 'a demonstration of a person using {}.', + 'a demonstration of a person doing {}.', + 'a demonstration of a person during {}.', + 'a demonstration of a person performing {}.', + 'a demonstration of a person practicing {}.', +] +``` + + + +## MNIST + +```bash +classes = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of the number: "{}".', +] +``` + + + +## OxfordPets + +```bash +classes = [ + 'Abyssinian', + 'Bengal', + 'Birman', + 'Bombay', + 'British Shorthair', + 'Egyptian Mau', + 'Maine Coon', + 'Persian', + 'Ragdoll', + 'Russian Blue', + 'Siamese', + 'Sphynx', + 'american bulldog', + 'american pit bull terrier', + 'basset hound', + 'beagle', + 'boxer', + 'chihuahua', + 'english cocker spaniel', + 'english setter', + 'german shorthaired', + 'great pyrenees', + 'havanese', + 'japanese chin', + 'keeshond', + 'leonberger', + 'miniature pinscher', + 'newfoundland', + 'pomeranian', + 'pug', + 'saint bernard', + 'samoyed', + 'scottish terrier', + 'shiba inu', + 'staffordshire bull terrier', + 'wheaten terrier', + 'yorkshire terrier', +] + +templates = [ + 'a photo of a {}, a type of pet.', +] +``` + + + +## PascalVOC2007 + +```bash +classes = [ + 'aeroplane', + 'bicycle', + 'bird', + 'boat', + 'bottle', + 'bus', + 'car', + 'cat', + 'chair', + 'cow', + 'dog', + 'horse', + 'motorbike', + 'person', + 'sheep', + 'sofa', + 'diningtable', + 'pottedplant', + 'train', + 'tvmonitor', +] + +templates = [ + 'a photo of a {}.', +] +``` + + + +## PatchCamelyon + +```bash +classes = [ + 'lymph node', + 'lymph node containing metastatic tumor tissue', +] + +templates = [ + 'this is a photo of {}', +] +``` + + + +## RESISC45 + +```bash +classes = [ + 'airplane', + 'airport', + 'baseball diamond', + 'basketball court', + 'beach', + 'bridge', + 'chaparral', + 'church', + 'circular farmland', + 'cloud', + 'commercial area', + 'dense residential', + 'desert', + 'forest', + 'freeway', + 'golf course', + 'ground track field', + 'harbor', + 'industrial area', + 'intersection', + 'island', + 'lake', + 'meadow', + 'medium residential', + 'mobile home park', + 'mountain', + 'overpass', + 'palace', + 'parking lot', + 'railway', + 'railway station', + 'rectangular farmland', + 'river', + 'roundabout', + 'runway', + 'sea ice', + 'ship', + 'snowberg', + 'sparse residential', + 'stadium', + 'storage tank', + 'tennis court', + 'terrace', + 'thermal power station', + 'wetland', +] + +templates = [ + 'satellite imagery of {}.', + 'aerial imagery of {}.', + 'satellite photo of {}.', + 'aerial photo of {}.', + 'satellite view of {}.', + 'aerial view of {}.', + 'satellite imagery of a {}.', + 'aerial imagery of a {}.', + 'satellite photo of a {}.', + 'aerial photo of a {}.', + 'satellite view of a {}.', + 'aerial view of a {}.', + 'satellite imagery of the {}.', + 'aerial imagery of the {}.', + 'satellite photo of the {}.', + 'aerial photo of the {}.', + 'satellite view of the {}.', + 'aerial view of the {}.', +] +``` + + + +## SST2 + +```bash +classes = [ + 'negative', + 'positive', +] + +templates = [ + 'a {} review of a movie.', +] +``` + + + +## STL10 + +```bash +classes = [ + 'airplane', + 'bird', + 'car', + 'cat', + 'deer', + 'dog', + 'horse', + 'monkey', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## SUN397 + +```bash +classes = [ + 'abbey', + 'airplane cabin', + 'airport terminal', + 'alley', + 'amphitheater', + 'amusement arcade', + 'amusement park', + 'anechoic chamber', + 'apartment building outdoor', + 'apse indoor', + 'aquarium', + 'aqueduct', + 'arch', + 'archive', + 'arrival gate outdoor', + 'art gallery', + 'art school', + 'art studio', + 'assembly line', + 'athletic field outdoor', + 'atrium public', + 'attic', + 'auditorium', + 'auto factory', + 'badlands', + 'badminton court indoor', + 'baggage claim', + 'bakery shop', + 'balcony exterior', + 'balcony interior', + 'ball pit', + 'ballroom', + 'bamboo forest', + 'banquet hall', + 'bar', + 'barn', + 'barndoor', + 'baseball field', + 'basement', + 'basilica', + 'basketball court outdoor', + 'bathroom', + 'batters box', + 'bayou', + 'bazaar indoor', + 'bazaar outdoor', + 'beach', + 'beauty salon', + 'bedroom', + 'berth', + 'biology laboratory', + 'bistro indoor', + 'boardwalk', + 'boat deck', + 'boathouse', + 'bookstore', + 'booth indoor', + 'botanical garden', + 'bow window indoor', + 'bow window outdoor', + 'bowling alley', + 'boxing ring', + 'brewery indoor', + 'bridge', + 'building facade', + 'bullring', + 'burial chamber', + 'bus interior', + 'butchers shop', + 'butte', + 'cabin outdoor', + 'cafeteria', + 'campsite', + 'campus', + 'canal natural', + 'canal urban', + 'candy store', + 'canyon', + 'car interior backseat', + 'car interior frontseat', + 'carrousel', + 'casino indoor', + 'castle', + 'catacomb', + 'cathedral indoor', + 'cathedral outdoor', + 'cavern indoor', + 'cemetery', + 'chalet', + 'cheese factory', + 'chemistry lab', + 'chicken coop indoor', + 'chicken coop outdoor', + 'childs room', + 'church indoor', + 'church outdoor', + 'classroom', + 'clean room', + 'cliff', + 'cloister indoor', + 'closet', + 'clothing store', + 'coast', + 'cockpit', + 'coffee shop', + 'computer room', + 'conference center', + 'conference room', + 'construction site', + 'control room', + 'control tower outdoor', + 'corn field', + 'corral', + 'corridor', + 'cottage garden', + 'courthouse', + 'courtroom', + 'courtyard', + 'covered bridge exterior', + 'creek', + 'crevasse', + 'crosswalk', + 'cubicle office', + 'dam', + 'delicatessen', + 'dentists office', + 'desert sand', + 'desert vegetation', + 'diner indoor', + 'diner outdoor', + 'dinette home', + 'dinette vehicle', + 'dining car', + 'dining room', + 'discotheque', + 'dock', + 'doorway outdoor', + 'dorm room', + 'driveway', + 'driving range outdoor', + 'drugstore', + 'electrical substation', + 'elevator door', + 'elevator interior', + 'elevator shaft', + 'engine room', + 'escalator indoor', + 'excavation', + 'factory indoor', + 'fairway', + 'fastfood restaurant', + 'field cultivated', + 'field wild', + 'fire escape', + 'fire station', + 'firing range indoor', + 'fishpond', + 'florist shop indoor', + 'food court', + 'forest broadleaf', + 'forest needleleaf', + 'forest path', + 'forest road', + 'formal garden', + 'fountain', + 'galley', + 'game room', + 'garage indoor', + 'garbage dump', + 'gas station', + 'gazebo exterior', + 'general store indoor', + 'general store outdoor', + 'gift shop', + 'golf course', + 'greenhouse indoor', + 'greenhouse outdoor', + 'gymnasium indoor', + 'hangar indoor', + 'hangar outdoor', + 'harbor', + 'hayfield', + 'heliport', + 'herb garden', + 'highway', + 'hill', + 'home office', + 'hospital', + 'hospital room', + 'hot spring', + 'hot tub outdoor', + 'hotel outdoor', + 'hotel room', + 'house', + 'hunting lodge outdoor', + 'ice cream parlor', + 'ice floe', + 'ice shelf', + 'ice skating rink indoor', + 'ice skating rink outdoor', + 'iceberg', + 'igloo', + 'industrial area', + 'inn outdoor', + 'islet', + 'jacuzzi indoor', + 'jail cell', + 'jail indoor', + 'jewelry shop', + 'kasbah', + 'kennel indoor', + 'kennel outdoor', + 'kindergarden classroom', + 'kitchen', + 'kitchenette', + 'labyrinth outdoor', + 'lake natural', + 'landfill', + 'landing deck', + 'laundromat', + 'lecture room', + 'library indoor', + 'library outdoor', + 'lido deck outdoor', + 'lift bridge', + 'lighthouse', + 'limousine interior', + 'living room', + 'lobby', + 'lock chamber', + 'locker room', + 'mansion', + 'manufactured home', + 'market indoor', + 'market outdoor', + 'marsh', + 'martial arts gym', + 'mausoleum', + 'medina', + 'moat water', + 'monastery outdoor', + 'mosque indoor', + 'mosque outdoor', + 'motel', + 'mountain', + 'mountain snowy', + 'movie theater indoor', + 'museum indoor', + 'music store', + 'music studio', + 'nuclear power plant outdoor', + 'nursery', + 'oast house', + 'observatory outdoor', + 'ocean', + 'office', + 'office building', + 'oil refinery outdoor', + 'oilrig', + 'operating room', + 'orchard', + 'outhouse outdoor', + 'pagoda', + 'palace', + 'pantry', + 'park', + 'parking garage indoor', + 'parking garage outdoor', + 'parking lot', + 'parlor', + 'pasture', + 'patio', + 'pavilion', + 'pharmacy', + 'phone booth', + 'physics laboratory', + 'picnic area', + 'pilothouse indoor', + 'planetarium outdoor', + 'playground', + 'playroom', + 'plaza', + 'podium indoor', + 'podium outdoor', + 'pond', + 'poolroom establishment', + 'poolroom home', + 'power plant outdoor', + 'promenade deck', + 'pub indoor', + 'pulpit', + 'putting green', + 'racecourse', + 'raceway', + 'raft', + 'railroad track', + 'rainforest', + 'reception', + 'recreation room', + 'residential neighborhood', + 'restaurant', + 'restaurant kitchen', + 'restaurant patio', + 'rice paddy', + 'riding arena', + 'river', + 'rock arch', + 'rope bridge', + 'ruin', + 'runway', + 'sandbar', + 'sandbox', + 'sauna', + 'schoolhouse', + 'sea cliff', + 'server room', + 'shed', + 'shoe shop', + 'shopfront', + 'shopping mall indoor', + 'shower', + 'skatepark', + 'ski lodge', + 'ski resort', + 'ski slope', + 'sky', + 'skyscraper', + 'slum', + 'snowfield', + 'squash court', + 'stable', + 'stadium baseball', + 'stadium football', + 'stage indoor', + 'staircase', + 'street', + 'subway interior', + 'subway station platform', + 'supermarket', + 'sushi bar', + 'swamp', + 'swimming pool indoor', + 'swimming pool outdoor', + 'synagogue indoor', + 'synagogue outdoor', + 'television studio', + 'temple east asia', + 'temple south asia', + 'tennis court indoor', + 'tennis court outdoor', + 'tent outdoor', + 'theater indoor procenium', + 'theater indoor seats', + 'thriftshop', + 'throne room', + 'ticket booth', + 'toll plaza', + 'topiary garden', + 'tower', + 'toyshop', + 'track outdoor', + 'train railway', + 'train station platform', + 'tree farm', + 'tree house', + 'trench', + 'underwater coral reef', + 'utility room', + 'valley', + 'van interior', + 'vegetable garden', + 'veranda', + 'veterinarians office', + 'viaduct', + 'videostore', + 'village', + 'vineyard', + 'volcano', + 'volleyball court indoor', + 'volleyball court outdoor', + 'waiting room', + 'warehouse indoor', + 'water tower', + 'waterfall block', + 'waterfall fan', + 'waterfall plunge', + 'watering hole', + 'wave', + 'wet bar', + 'wheat field', + 'wind farm', + 'windmill', + 'wine cellar barrel storage', + 'wine cellar bottle storage', + 'wrestling ring indoor', + 'yard', + 'youth hostel', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## StanfordCars + +```bash +classes = [ + 'AM General Hummer SUV 2000', + 'Acura RL Sedan 2012', + 'Acura TL Sedan 2012', + 'Acura TL Type-S 2008', + 'Acura TSX Sedan 2012', + 'Acura Integra Type R 2001', + 'Acura ZDX Hatchback 2012', + 'Aston Martin V8 Vantage Convertible 2012', + 'Aston Martin V8 Vantage Coupe 2012', + 'Aston Martin Virage Convertible 2012', + 'Aston Martin Virage Coupe 2012', + 'Audi RS 4 Convertible 2008', + 'Audi A5 Coupe 2012', + 'Audi TTS Coupe 2012', + 'Audi R8 Coupe 2012', + 'Audi V8 Sedan 1994', + 'Audi 100 Sedan 1994', + 'Audi 100 Wagon 1994', + 'Audi TT Hatchback 2011', + 'Audi S6 Sedan 2011', + 'Audi S5 Convertible 2012', + 'Audi S5 Coupe 2012', + 'Audi S4 Sedan 2012', + 'Audi S4 Sedan 2007', + 'Audi TT RS Coupe 2012', + 'BMW ActiveHybrid 5 Sedan 2012', + 'BMW 1 Series Convertible 2012', + 'BMW 1 Series Coupe 2012', + 'BMW 3 Series Sedan 2012', + 'BMW 3 Series Wagon 2012', + 'BMW 6 Series Convertible 2007', + 'BMW X5 SUV 2007', + 'BMW X6 SUV 2012', + 'BMW M3 Coupe 2012', + 'BMW M5 Sedan 2010', + 'BMW M6 Convertible 2010', + 'BMW X3 SUV 2012', + 'BMW Z4 Convertible 2012', + 'Bentley Continental Supersports Conv. Convertible 2012', + 'Bentley Arnage Sedan 2009', + 'Bentley Mulsanne Sedan 2011', + 'Bentley Continental GT Coupe 2012', + 'Bentley Continental GT Coupe 2007', + 'Bentley Continental Flying Spur Sedan 2007', + 'Bugatti Veyron 16.4 Convertible 2009', + 'Bugatti Veyron 16.4 Coupe 2009', + 'Buick Regal GS 2012', + 'Buick Rainier SUV 2007', + 'Buick Verano Sedan 2012', + 'Buick Enclave SUV 2012', + 'Cadillac CTS-V Sedan 2012', + 'Cadillac SRX SUV 2012', + 'Cadillac Escalade EXT Crew Cab 2007', + 'Chevrolet Silverado 1500 Hybrid Crew Cab 2012', + 'Chevrolet Corvette Convertible 2012', + 'Chevrolet Corvette ZR1 2012', + 'Chevrolet Corvette Ron Fellows Edition Z06 2007', + 'Chevrolet Traverse SUV 2012', + 'Chevrolet Camaro Convertible 2012', + 'Chevrolet HHR SS 2010', + 'Chevrolet Impala Sedan 2007', + 'Chevrolet Tahoe Hybrid SUV 2012', + 'Chevrolet Sonic Sedan 2012', + 'Chevrolet Express Cargo Van 2007', + 'Chevrolet Avalanche Crew Cab 2012', + 'Chevrolet Cobalt SS 2010', + 'Chevrolet Malibu Hybrid Sedan 2010', + 'Chevrolet TrailBlazer SS 2009', + 'Chevrolet Silverado 2500HD Regular Cab 2012', + 'Chevrolet Silverado 1500 Classic Extended Cab 2007', + 'Chevrolet Express Van 2007', + 'Chevrolet Monte Carlo Coupe 2007', + 'Chevrolet Malibu Sedan 2007', + 'Chevrolet Silverado 1500 Extended Cab 2012', + 'Chevrolet Silverado 1500 Regular Cab 2012', + 'Chrysler Aspen SUV 2009', + 'Chrysler Sebring Convertible 2010', + 'Chrysler Town and Country Minivan 2012', + 'Chrysler 300 SRT-8 2010', + 'Chrysler Crossfire Convertible 2008', + 'Chrysler PT Cruiser Convertible 2008', + 'Daewoo Nubira Wagon 2002', + 'Dodge Caliber Wagon 2012', + 'Dodge Caliber Wagon 2007', + 'Dodge Caravan Minivan 1997', + 'Dodge Ram Pickup 3500 Crew Cab 2010', + 'Dodge Ram Pickup 3500 Quad Cab 2009', + 'Dodge Sprinter Cargo Van 2009', + 'Dodge Journey SUV 2012', + 'Dodge Dakota Crew Cab 2010', + 'Dodge Dakota Club Cab 2007', + 'Dodge Magnum Wagon 2008', + 'Dodge Challenger SRT8 2011', + 'Dodge Durango SUV 2012', + 'Dodge Durango SUV 2007', + 'Dodge Charger Sedan 2012', + 'Dodge Charger SRT-8 2009', + 'Eagle Talon Hatchback 1998', + 'FIAT 500 Abarth 2012', + 'FIAT 500 Convertible 2012', + 'Ferrari FF Coupe 2012', + 'Ferrari California Convertible 2012', + 'Ferrari 458 Italia Convertible 2012', + 'Ferrari 458 Italia Coupe 2012', + 'Fisker Karma Sedan 2012', + 'Ford F-450 Super Duty Crew Cab 2012', + 'Ford Mustang Convertible 2007', + 'Ford Freestar Minivan 2007', + 'Ford Expedition EL SUV 2009', + 'Ford Edge SUV 2012', + 'Ford Ranger SuperCab 2011', + 'Ford GT Coupe 2006', + 'Ford F-150 Regular Cab 2012', + 'Ford F-150 Regular Cab 2007', + 'Ford Focus Sedan 2007', + 'Ford E-Series Wagon Van 2012', + 'Ford Fiesta Sedan 2012', + 'GMC Terrain SUV 2012', + 'GMC Savana Van 2012', + 'GMC Yukon Hybrid SUV 2012', + 'GMC Acadia SUV 2012', + 'GMC Canyon Extended Cab 2012', + 'Geo Metro Convertible 1993', + 'HUMMER H3T Crew Cab 2010', + 'HUMMER H2 SUT Crew Cab 2009', + 'Honda Odyssey Minivan 2012', + 'Honda Odyssey Minivan 2007', + 'Honda Accord Coupe 2012', + 'Honda Accord Sedan 2012', + 'Hyundai Veloster Hatchback 2012', + 'Hyundai Santa Fe SUV 2012', + 'Hyundai Tucson SUV 2012', + 'Hyundai Veracruz SUV 2012', + 'Hyundai Sonata Hybrid Sedan 2012', + 'Hyundai Elantra Sedan 2007', + 'Hyundai Accent Sedan 2012', + 'Hyundai Genesis Sedan 2012', + 'Hyundai Sonata Sedan 2012', + 'Hyundai Elantra Touring Hatchback 2012', + 'Hyundai Azera Sedan 2012', + 'Infiniti G Coupe IPL 2012', + 'Infiniti QX56 SUV 2011', + 'Isuzu Ascender SUV 2008', + 'Jaguar XK XKR 2012', + 'Jeep Patriot SUV 2012', + 'Jeep Wrangler SUV 2012', + 'Jeep Liberty SUV 2012', + 'Jeep Grand Cherokee SUV 2012', + 'Jeep Compass SUV 2012', + 'Lamborghini Reventon Coupe 2008', + 'Lamborghini Aventador Coupe 2012', + 'Lamborghini Gallardo LP 570-4 Superleggera 2012', + 'Lamborghini Diablo Coupe 2001', + 'Land Rover Range Rover SUV 2012', + 'Land Rover LR2 SUV 2012', + 'Lincoln Town Car Sedan 2011', + 'MINI Cooper Roadster Convertible 2012', + 'Maybach Landaulet Convertible 2012', + 'Mazda Tribute SUV 2011', + 'McLaren MP4-12C Coupe 2012', + 'Mercedes-Benz 300-Class Convertible 1993', + 'Mercedes-Benz C-Class Sedan 2012', + 'Mercedes-Benz SL-Class Coupe 2009', + 'Mercedes-Benz E-Class Sedan 2012', + 'Mercedes-Benz S-Class Sedan 2012', + 'Mercedes-Benz Sprinter Van 2012', + 'Mitsubishi Lancer Sedan 2012', + 'Nissan Leaf Hatchback 2012', + 'Nissan NV Passenger Van 2012', + 'Nissan Juke Hatchback 2012', + 'Nissan 240SX Coupe 1998', + 'Plymouth Neon Coupe 1999', + 'Porsche Panamera Sedan 2012', + 'Ram C/V Cargo Van Minivan 2012', + 'Rolls-Royce Phantom Drophead Coupe Convertible 2012', + 'Rolls-Royce Ghost Sedan 2012', + 'Rolls-Royce Phantom Sedan 2012', + 'Scion xD Hatchback 2012', + 'Spyker C8 Convertible 2009', + 'Spyker C8 Coupe 2009', + 'Suzuki Aerio Sedan 2007', + 'Suzuki Kizashi Sedan 2012', + 'Suzuki SX4 Hatchback 2012', + 'Suzuki SX4 Sedan 2012', + 'Tesla Model S Sedan 2012', + 'Toyota Sequoia SUV 2012', + 'Toyota Camry Sedan 2012', + 'Toyota Corolla Sedan 2012', + 'Toyota 4Runner SUV 2012', + 'Volkswagen Golf Hatchback 2012', + 'Volkswagen Golf Hatchback 1991', + 'Volkswagen Beetle Hatchback 2012', + 'Volvo C30 Hatchback 2012', + 'Volvo 240 Sedan 1993', + 'Volvo XC90 SUV 2007', + 'smart fortwo Convertible 2012', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', + 'a photo of my {}.', + 'i love my {}!', + 'a photo of my dirty {}.', + 'a photo of my clean {}.', + 'a photo of my new {}.', + 'a photo of my old {}.', +] +``` + + + +## UCF101 + +```bash +classes = [ + 'Apply Eye Makeup', + 'Apply Lipstick', + 'Archery', + 'Baby Crawling', + 'Balance Beam', + 'Band Marching', + 'Baseball Pitch', + 'Basketball', + 'Basketball Dunk', + 'Bench Press', + 'Biking', + 'Billiards', + 'Blow Dry Hair', + 'Blowing Candles', + 'Body Weight Squats', + 'Bowling', + 'Boxing Punching Bag', + 'Boxing Speed Bag', + 'Breast Stroke', + 'Brushing Teeth', + 'Clean And Jerk', + 'Cliff Diving', + 'Cricket Bowling', + 'Cricket Shot', + 'Cutting In Kitchen', + 'Diving', + 'Drumming', + 'Fencing', + 'Field Hockey Penalty', + 'Floor Gymnastics', + 'Frisbee Catch', + 'Front Crawl', + 'Golf Swing', + 'Haircut', + 'Hammer Throw', + 'Hammering', + 'Hand Stand Pushups', + 'Handstand Walking', + 'Head Massage', + 'High Jump', + 'Horse Race', + 'Horse Riding', + 'Hula Hoop', + 'Ice Dancing', + 'Javelin Throw', + 'Juggling Balls', + 'Jump Rope', + 'Jumping Jack', + 'Kayaking', + 'Knitting', + 'Long Jump', + 'Lunges', + 'Military Parade', + 'Mixing', + 'Mopping Floor', + 'Nunchucks', + 'Parallel Bars', + 'Pizza Tossing', + 'Playing Cello', + 'Playing Daf', + 'Playing Dhol', + 'Playing Flute', + 'Playing Guitar', + 'Playing Piano', + 'Playing Sitar', + 'Playing Tabla', + 'Playing Violin', + 'Pole Vault', + 'Pommel Horse', + 'Pull Ups', + 'Punch', + 'Push Ups', + 'Rafting', + 'Rock Climbing Indoor', + 'Rope Climbing', + 'Rowing', + 'Salsa Spin', + 'Shaving Beard', + 'Shotput', + 'Skate Boarding', + 'Skiing', + 'Skijet', + 'Sky Diving', + 'Soccer Juggling', + 'Soccer Penalty', + 'Still Rings', + 'Sumo Wrestling', + 'Surfing', + 'Swing', + 'Table Tennis Shot', + 'Tai Chi', + 'Tennis Swing', + 'Throw Discus', + 'Trampoline Jumping', + 'Typing', + 'Uneven Bars', + 'Volleyball Spiking', + 'Walking With Dog', + 'Wall Pushups', + 'Writing On Board', + 'Yo Yo', +] + +templates = [ + 'a photo of a person {}.', + 'a video of a person {}.', + 'a example of a person {}.', + 'a demonstration of a person {}.', + 'a photo of the person {}.', + 'a video of the person {}.', + 'a example of the person {}.', + 'a demonstration of the person {}.', + 'a photo of a person using {}.', + 'a video of a person using {}.', + 'a example of a person using {}.', + 'a demonstration of a person using {}.', + 'a photo of the person using {}.', + 'a video of the person using {}.', + 'a example of the person using {}.', + 'a demonstration of the person using {}.', + 'a photo of a person doing {}.', + 'a video of a person doing {}.', + 'a example of a person doing {}.', + 'a demonstration of a person doing {}.', + 'a photo of the person doing {}.', + 'a video of the person doing {}.', + 'a example of the person doing {}.', + 'a demonstration of the person doing {}.', + 'a photo of a person during {}.', + 'a video of a person during {}.', + 'a example of a person during {}.', + 'a demonstration of a person during {}.', + 'a photo of the person during {}.', + 'a video of the person during {}.', + 'a example of the person during {}.', + 'a demonstration of the person during {}.', + 'a photo of a person performing {}.', + 'a video of a person performing {}.', + 'a example of a person performing {}.', + 'a demonstration of a person performing {}.', + 'a photo of the person performing {}.', + 'a video of the person performing {}.', + 'a example of the person performing {}.', + 'a demonstration of the person performing {}.', + 'a photo of a person practicing {}.', + 'a video of a person practicing {}.', + 'a example of a person practicing {}.', + 'a demonstration of a person practicing {}.', + 'a photo of the person practicing {}.', + 'a video of the person practicing {}.', + 'a example of the person practicing {}.', + 'a demonstration of the person practicing {}.', +] +``` + + diff --git a/CLIP/data/rendered-sst2.md b/CLIP/data/rendered-sst2.md new file mode 100644 index 0000000..d27454c --- /dev/null +++ b/CLIP/data/rendered-sst2.md @@ -0,0 +1,11 @@ +# The Rendered SST2 Dataset + +In the paper, we used an image classification dataset called Rendered SST2, to evaluate the model's capability on optical character recognition. To do so, we rendered the sentences in the [Standford Sentiment Treebank v2](https://nlp.stanford.edu/sentiment/treebank.html) dataset and used those as the input to the CLIP image encoder. + +The following command will download a 131MB archive countaining the images and extract into a subdirectory `rendered-sst2`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/rendered-sst2.tgz +tar zxvf rendered-sst2.tgz +``` + diff --git a/CLIP/data/yfcc100m.md b/CLIP/data/yfcc100m.md new file mode 100644 index 0000000..06083ef --- /dev/null +++ b/CLIP/data/yfcc100m.md @@ -0,0 +1,14 @@ +# The YFCC100M Subset + +In the paper, we performed a dataset ablation using a subset of the YFCC100M dataset and showed that the performance remained largely similar. + +The subset contains 14,829,396 images, about 15% of the full dataset, which have been filtered to only keep those with natural languag titles and/or descriptions in English. + +We provide the list of (line number, photo identifier, photo hash) of each image contained in this subset. These correspond to the first three columns in the dataset's metadata TSV file. + +```bash +wget https://openaipublic.azureedge.net/clip/data/yfcc100m_subset_data.tsv.bz2 +bunzip2 yfcc100m_subset_data.tsv.bz2 +``` + +Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/CLIP/downoad_clip_models.py b/CLIP/downoad_clip_models.py new file mode 100644 index 0000000..296e50b --- /dev/null +++ b/CLIP/downoad_clip_models.py @@ -0,0 +1,24 @@ + +import requests +import os + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + +save_dir = 'clip_models/' + +for model_name in _MODELS: + url = _MODELS[model_name] + response = requests.get(url) + save_file_path = save_dir + os.path.basename(url) + open(save_file_path, "wb").write(response.content) + print(f"Wrote model {model_name} to file {save_file_path}") \ No newline at end of file diff --git a/CLIP/hubconf.py b/CLIP/hubconf.py new file mode 100644 index 0000000..520b354 --- /dev/null +++ b/CLIP/hubconf.py @@ -0,0 +1,42 @@ +from clip.clip import tokenize as _tokenize, load as _load, available_models as _available_models +import re +import string + +dependencies = ["torch", "torchvision", "ftfy", "regex", "tqdm"] + +# For compatibility (cannot include special characters in function name) +model_functions = { model: re.sub(f'[{string.punctuation}]', '_', model) for model in _available_models()} + +def _create_hub_entrypoint(model): + def entrypoint(**kwargs): + return _load(model, **kwargs) + + entrypoint.__doc__ = f"""Loads the {model} CLIP model + + Parameters + ---------- + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The {model} CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + return entrypoint + +def tokenize(): + return _tokenize + +_entrypoints = {model_functions[model]: _create_hub_entrypoint(model) for model in _available_models()} + +globals().update(_entrypoints) \ No newline at end of file diff --git a/CLIP/model-card.md b/CLIP/model-card.md new file mode 100644 index 0000000..6db1ca4 --- /dev/null +++ b/CLIP/model-card.md @@ -0,0 +1,120 @@ +# Model Card: CLIP + +Inspired by [Model Cards for Model Reporting (Mitchell et al.)](https://arxiv.org/abs/1810.03993) and [Lessons from Archives (Jo & Gebru)](https://arxiv.org/pdf/1912.10389.pdf), we’re providing some accompanying information about the multimodal model. + +## Model Details + +The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. + +### Model Date + +January 2021 + +### Model Type + +The base model uses a ResNet50 with several modifications as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. There is also a variant of the model where the ResNet image encoder is replaced with a Vision Transformer. + +### Model Versions + +Initially, we’ve released one CLIP model based on the Vision Transformer architecture equivalent to ViT-B/32, along with the RN50 model, using the architecture equivalent to ResNet-50. + +As part of the staged release process, we have also released the RN101 model, as well as RN50x4, a RN50 scaled up 4x according to the [EfficientNet](https://arxiv.org/abs/1905.11946) scaling rule. In July 2021, we additionally released the RN50x16 and ViT-B/16 models, and in January 2022, the RN50x64 and ViT-L/14 models were released. Lastly, the ViT-L/14@336px model was released in April 2022. + +Please see the paper linked below for further details about their specification. + +### Documents + +- [Blog Post](https://openai.com/blog/clip/) +- [CLIP Paper](https://arxiv.org/abs/2103.00020) + + + +## Model Use + +### Intended Use + +The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. + +#### Primary intended uses + +The primary intended users of these models are AI researchers. + +We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. + +### Out-of-Scope Use Cases + +**Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. + +Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. + +Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. + + + +## Data + +The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as [YFCC100M](http://projects.dfki.uni-kl.de/yfcc100m/). A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. + +### Data Mission Statement + +Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. + + + +## Performance and Limitations + +### Performance + +We have evaluated the performance of CLIP on a wide range of benchmarks across a variety of computer vision datasets such as OCR to texture recognition to fine-grained classification. The paper describes model performance on the following datasets: + +- Food101 +- CIFAR10 +- CIFAR100 +- Birdsnap +- SUN397 +- Stanford Cars +- FGVC Aircraft +- VOC2007 +- DTD +- Oxford-IIIT Pet dataset +- Caltech101 +- Flowers102 +- MNIST +- SVHN +- IIIT5K +- Hateful Memes +- SST-2 +- UCF101 +- Kinetics700 +- Country211 +- CLEVR Counting +- KITTI Distance +- STL-10 +- RareAct +- Flickr30 +- MSCOCO +- ImageNet +- ImageNet-A +- ImageNet-R +- ImageNet Sketch +- ObjectNet (ImageNet Overlap) +- Youtube-BB +- ImageNet-Vid + +## Limitations + +CLIP and our analysis of it have a number of limitations. CLIP currently struggles with respect to certain tasks such as fine grained classification and counting objects. CLIP also poses issues with regards to fairness and bias which we discuss in the paper and briefly in the next section. Additionally, our approach to testing CLIP also has an important limitation- in many cases we have used linear probes to evaluate the performance of CLIP and there is evidence suggesting that linear probes can underestimate model performance. + +### Bias and Fairness + +We find that the performance of CLIP - and the specific biases it exhibits - can depend significantly on class design and the choices one makes for categories to include and exclude. We tested the risk of certain kinds of denigration with CLIP by classifying images of people from [Fairface](https://arxiv.org/abs/1908.04913) into crime-related and non-human animal categories. We found significant disparities with respect to race and gender. Additionally, we found that these disparities could shift based on how the classes were constructed. (Details captured in the Broader Impacts Section in the paper). + +We also tested the performance of CLIP on gender, race and age classification using the Fairface dataset (We default to using race categories as they are constructed in the Fairface dataset.) in order to assess quality of performance across different demographics. We found accuracy >96% across all races for gender classification with ‘Middle Eastern’ having the highest accuracy (98.4%) and ‘White’ having the lowest (96.5%). Additionally, CLIP averaged ~93% for racial classification and ~63% for age classification. Our use of evaluations to test for gender, race and age classification as well as denigration harms is simply to evaluate performance of the model across people and surface potential risks and not to demonstrate an endorsement/enthusiasm for such tasks. + + + +## Feedback + +### Where to send questions or comments about the model + +Please use [this Google Form](https://forms.gle/Uv7afRH5dvY34ZEs9) diff --git a/CLIP/notebooks/Interacting_with_CLIP.ipynb b/CLIP/notebooks/Interacting_with_CLIP.ipynb new file mode 100644 index 0000000..1043f23 --- /dev/null +++ b/CLIP/notebooks/Interacting_with_CLIP.ipynb @@ -0,0 +1,925 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Interacting with CLIP.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "1369964d45004b5e95a058910b2a33e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_12e23e2819094ee0a079d4eb77cfc4f9", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7a5f52e56ede4ac3abe37a3ece007dc9", + "IPY_MODEL_ce8b0faa1a1340b5a504d7b3546b3ccb" + ] + } + }, + "12e23e2819094ee0a079d4eb77cfc4f9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "7a5f52e56ede4ac3abe37a3ece007dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_5e6adc4592124a4581b85f4c1f3bab4d", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 169001437, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 169001437, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_4a61c10fc00c4f04bb00b82e942da210" + } + }, + "ce8b0faa1a1340b5a504d7b3546b3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b597cd6f6cd443aba4bf4491ac7f957e", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 169001984/? [00:06<00:00, 25734958.25it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_161969cae25a49f38aacd1568d3cac6c" + } + }, + "5e6adc4592124a4581b85f4c1f3bab4d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "4a61c10fc00c4f04bb00b82e942da210": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b597cd6f6cd443aba4bf4491ac7f957e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "161969cae25a49f38aacd1568d3cac6c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "YPHN7PJgKOzb" + }, + "source": [ + "# Interacting with CLIP\n", + "\n", + "This is a self-contained notebook that shows how to download and run CLIP models, calculate the similarity between arbitrary image and text inputs, and perform zero-shot image classifications." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "4d9b51f8-d255-4868-97f6-be0a67dadfae" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 34.6 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 20.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 16.4 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 15.2 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 7.0 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 8.2 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 2.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=ce00f21233e5e1a5c3e84204d651ae0c17403484418c330c69ebae7297ca7003\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-tbmjxrgj\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-tbmjxrgj\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=9059060f3a406b8268cfcbbf03647ab9b59e660d03f86c6120a9dd06f2b82cec\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-7v3mrcvj/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "70a44964-883d-4fd0-b95a-2c7f2b19aca9" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "`clip.available_models()` will list the names of available CLIP models." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "11779e1e-8bdd-4167-c18e-d26bdd6b67db" + }, + "source": [ + "import clip\n", + "\n", + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "f06fd2fd-6126-475b-87d0-b10aa3b7da49" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")\n", + "model.cuda().eval()\n", + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.0MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "21slhZGCqANb" + }, + "source": [ + "# Image Preprocessing\n", + "\n", + "We resize the input images and center-crop them to conform with the image resolution that the model expects. Before doing so, we will normalize the pixel intensity using the dataset mean and standard deviation.\n", + "\n", + "The second return value from `clip.load()` contains a torchvision `Transform` that performs this preprocessing.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "d6cpiIFHp9N6", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "880cb98e-1e5e-430e-8b59-4bf35fa554f9" + }, + "source": [ + "preprocess" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Compose(\n", + " Resize(size=224, interpolation=bicubic, max_size=None, antialias=None)\n", + " CenterCrop(size=(224, 224))\n", + " . at 0x7f3a24ffb440>\n", + " ToTensor()\n", + " Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))\n", + ")" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xwSB5jZki3Cj" + }, + "source": [ + "# Text Preprocessing\n", + "\n", + "We use a case-insensitive tokenizer, which can be invoked using `clip.tokenize()`. By default, the outputs are padded to become 77 tokens long, which is what the CLIP models expects." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGom156-i2kL", + "outputId": "050b0ce1-caba-47e1-f4ac-dba994599718" + }, + "source": [ + "clip.tokenize(\"Hello World!\")" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[49406, 3306, 1002, 256, 49407, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Setting up input images and texts\n", + "\n", + "We are going to feed 8 example images and their textual descriptions to the model, and compare the similarity between the corresponding features.\n", + "\n", + "The tokenizer is case-insensitive, and we can freely give any suitable textual descriptions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tMc1AXzBlhzm" + }, + "source": [ + "import os\n", + "import skimage\n", + "import IPython.display\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from collections import OrderedDict\n", + "import torch\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# images in skimage to use and their textual descriptions\n", + "descriptions = {\n", + " \"page\": \"a page of text about segmentation\",\n", + " \"chelsea\": \"a facial photo of a tabby cat\",\n", + " \"astronaut\": \"a portrait of an astronaut with the American flag\",\n", + " \"rocket\": \"a rocket standing on a launchpad\",\n", + " \"motorcycle_right\": \"a red motorcycle standing in a garage\",\n", + " \"camera\": \"a person looking at a camera on a tripod\",\n", + " \"horse\": \"a black-and-white silhouette of a horse\", \n", + " \"coffee\": \"a cup of coffee on a saucer\"\n", + "}" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NSSrLY185jSf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "outputId": "06451963-5ecb-4ddc-d0a8-24e9b110af7d" + }, + "source": [ + "original_images = []\n", + "images = []\n", + "texts = []\n", + "plt.figure(figsize=(16, 5))\n", + "\n", + "for filename in [filename for filename in os.listdir(skimage.data_dir) if filename.endswith(\".png\") or filename.endswith(\".jpg\")]:\n", + " name = os.path.splitext(filename)[0]\n", + " if name not in descriptions:\n", + " continue\n", + "\n", + " image = Image.open(os.path.join(skimage.data_dir, filename)).convert(\"RGB\")\n", + " \n", + " plt.subplot(2, 4, len(images) + 1)\n", + " plt.imshow(image)\n", + " plt.title(f\"{filename}\\n{descriptions[name]}\")\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " original_images.append(image)\n", + " images.append(preprocess(image))\n", + " texts.append(descriptions[name])\n", + "\n", + "plt.tight_layout()\n" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1116, + "height": 351 + } + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEVKsji6WOIX" + }, + "source": [ + "## Building features\n", + "\n", + "We normalize the images, tokenize each text input, and run the forward pass of the model to get the image and text features." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HBgCanxi8JKw" + }, + "source": [ + "image_input = torch.tensor(np.stack(images)).cuda()\n", + "text_tokens = clip.tokenize([\"This is \" + desc for desc in texts]).cuda()" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZN9I0nIBZ_vW" + }, + "source": [ + "with torch.no_grad():\n", + " image_features = model.encode_image(image_input).float()\n", + " text_features = model.encode_text(text_tokens).float()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuxm2Gt4Wvzt" + }, + "source": [ + "## Calculating cosine similarity\n", + "\n", + "We normalize the features and calculate the dot product of each pair." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yKAxkQR7bf3A" + }, + "source": [ + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5zvMxh8cU6m", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 831 + }, + "outputId": "22bca748-ab42-4888-c9da-8f22c21c6185" + }, + "source": [ + "count = len(descriptions)\n", + "\n", + "plt.figure(figsize=(20, 14))\n", + "plt.imshow(similarity, vmin=0.1, vmax=0.3)\n", + "# plt.colorbar()\n", + "plt.yticks(range(count), texts, fontsize=18)\n", + "plt.xticks([])\n", + "for i, image in enumerate(original_images):\n", + " plt.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin=\"lower\")\n", + "for x in range(similarity.shape[1]):\n", + " for y in range(similarity.shape[0]):\n", + " plt.text(x, y, f\"{similarity[y, x]:.2f}\", ha=\"center\", va=\"center\", size=12)\n", + "\n", + "for side in [\"left\", \"top\", \"right\", \"bottom\"]:\n", + " plt.gca().spines[side].set_visible(False)\n", + "\n", + "plt.xlim([-0.5, count - 0.5])\n", + "plt.ylim([count + 0.5, -2])\n", + "\n", + "plt.title(\"Cosine similarity between text and image features\", size=20)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cosine similarity between text and image features')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1038, + "height": 796 + }, + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "alePijoXy6AH" + }, + "source": [ + "# Zero-Shot Image Classification\n", + "\n", + "You can classify images using the cosine similarity (times 100) as the logits to the softmax operation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Nqu4GlfPfr-p", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "1369964d45004b5e95a058910b2a33e6", + "12e23e2819094ee0a079d4eb77cfc4f9", + "7a5f52e56ede4ac3abe37a3ece007dc9", + "ce8b0faa1a1340b5a504d7b3546b3ccb", + "5e6adc4592124a4581b85f4c1f3bab4d", + "4a61c10fc00c4f04bb00b82e942da210", + "b597cd6f6cd443aba4bf4491ac7f957e", + "161969cae25a49f38aacd1568d3cac6c" + ] + }, + "outputId": "ca7a0e3c-e267-4e6e-8a1b-bbab3c0a2462" + }, + "source": [ + "from torchvision.datasets import CIFAR100\n", + "\n", + "cifar100 = CIFAR100(os.path.expanduser(\"~/.cache\"), transform=preprocess, download=True)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /root/.cache/cifar-100-python.tar.gz\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1369964d45004b5e95a058910b2a33e6", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=169001437.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Extracting /root/.cache/cifar-100-python.tar.gz to /root/.cache\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4S__zCGy2MT" + }, + "source": [ + "text_descriptions = [f\"This is a photo of a {label}\" for label in cifar100.classes]\n", + "text_tokens = clip.tokenize(text_descriptions).cuda()" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4z1fm9vCpSR" + }, + "source": [ + "with torch.no_grad():\n", + " text_features = model.encode_text(text_tokens).float()\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "top_probs, top_labels = text_probs.cpu().topk(5, dim=-1)" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 931 + }, + "id": "T6Ju_6IBE2Iz", + "outputId": "e1a155dc-474d-409c-e03d-d41b804648c3" + }, + "source": [ + "plt.figure(figsize=(16, 16))\n", + "\n", + "for i, image in enumerate(original_images):\n", + " plt.subplot(4, 4, 2 * i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(4, 4, 2 * i + 2)\n", + " y = np.arange(top_probs.shape[-1])\n", + " plt.grid()\n", + " plt.barh(y, top_probs[i])\n", + " plt.gca().invert_yaxis()\n", + " plt.gca().set_axisbelow(True)\n", + " plt.yticks(y, [cifar100.classes[index] for index in top_labels[i].numpy()])\n", + " plt.xlabel(\"probability\")\n", + "\n", + "plt.subplots_adjust(wspace=0.5)\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 917, + "height": 914 + }, + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb new file mode 100644 index 0000000..dba7fb6 --- /dev/null +++ b/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb @@ -0,0 +1,1107 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Prompt Engineering for ImageNet.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "66a1639713ae441d8a9b873381f9d774": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_610b775178c645e2b4663b77cc0c67b6", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_412dd15f0d8542f5ab2730f8616fb582", + "IPY_MODEL_5e6315f36b4e4eeea5c6294b024e0c97" + ] + } + }, + "610b775178c645e2b4663b77cc0c67b6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "412dd15f0d8542f5ab2730f8616fb582": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_085d5388abda4202bfa66d0c088452f8", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 1000, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 1000, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f75124b64aa147c693c67a78f8e3a231" + } + }, + "5e6315f36b4e4eeea5c6294b024e0c97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6e5676a054874243b55fc6d120a07d01", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 1000/1000 [16:51<00:00, 1.01s/it]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_dc6d1416c01a4047935ee15c3fd2eb1c" + } + }, + "085d5388abda4202bfa66d0c088452f8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "f75124b64aa147c693c67a78f8e3a231": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6e5676a054874243b55fc6d120a07d01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "dc6d1416c01a4047935ee15c3fd2eb1c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "84f80a7f3e764346969a347b0f71b24e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_392656f01b2945f3bd7903783ed8cc96", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_8e47a435519b4ce090879b4be2f61f99", + "IPY_MODEL_41b1ed6b0a9745c1a595377670b15ff4" + ] + } + }, + "392656f01b2945f3bd7903783ed8cc96": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "8e47a435519b4ce090879b4be2f61f99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_179b8ae1eb7f4a828f953e889b141725", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 313, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 313, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_d8708e8414fd44f4abd6590c9b57996f" + } + }, + "41b1ed6b0a9745c1a595377670b15ff4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_800e30f5b4f24475a2b0046da0703631", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 313/313 [02:31<00:00, 2.07it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8764308b948745f1a677332fd21fcaf0" + } + }, + "179b8ae1eb7f4a828f953e889b141725": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "d8708e8414fd44f4abd6590c9b57996f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "800e30f5b4f24475a2b0046da0703631": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "8764308b948745f1a677332fd21fcaf0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "41a4070f-5321-4fc4-bd4d-0b5c1f476d56" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 14.9 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 18.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 9.0 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 4.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 4.6 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 4.7 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 1.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=90ec193331444b2c4ff1cd81935e7de42065b89d304db7efac67bcfd87c27873\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-hqnbveqi\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-hqnbveqi\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=fda43d2b80cfb2b33c2d43e23ea5f53293a9a8b48d5f9e341de527f6adfbf5a3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmmplf44/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e10d4f17-8fa6-4b75-a18f-f0c38990b5a3" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "import clip\n", + "from tqdm.notebook import tqdm\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "Download and instantiate a CLIP model using the `clip` module that we just installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "09abb234-693e-4efb-953f-e1847ba95758" + }, + "source": [ + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cboKZocQlSYX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "240acdd0-ca62-45db-8418-9e4ef73e8aff" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.6MiB/s]\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "785019a1-1f40-45b0-e349-b0d4ec3173bf" + }, + "source": [ + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LhO3OtOmF8M4" + }, + "source": [ + "# Preparing ImageNet labels and prompts\n", + "\n", + "The following cell contains the 1,000 labels for the ImageNet dataset, followed by the text templates we'll use as \"prompt engineering\"." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "R2HbOZrqa0jF" + }, + "source": [ + "imagenet_classes = [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eMQSCuBta2G6" + }, + "source": [ + "A subset of these class names are modified from the default ImageNet class names sourced from Anish Athalye's imagenet-simple-labels.\n", + "\n", + "These edits were made via trial and error and concentrated on the lowest performing classes according to top_1 and top_5 accuracy on the ImageNet training set for the RN50, RN101, and RN50x4 models. These tweaks improve top_1 by 1.5% on ViT-B/32 over using the default class names. Alec got bored somewhere along the way as gains started to diminish and never finished updating / tweaking the list. He also didn't revisit this with the better performing RN50x16, RN50x64, or any of the ViT models. He thinks it's likely another 0.5% to 1% top_1 could be gained from further work here. It'd be interesting to more rigorously study / understand this.\n", + "\n", + "Some examples beyond the crane/crane -> construction crane / bird crane issue mentioned in Section 3.1.4 of the paper include:\n", + "\n", + "- CLIP interprets \"nail\" as \"fingernail\" so we changed the label to \"metal nail\".\n", + "- ImageNet kite class refers to the bird of prey, not the flying toy, so we changed \"kite\" to \"kite (bird of prey)\"\n", + "- The ImageNet class for red wolf seems to include a lot of mislabeled maned wolfs so we changed \"red wolf\" to \"red wolf or maned wolf\"" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "toGtcd-Ji_MD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6eb0753-2bee-4144-abe3-fbd23f35f555" + }, + "source": [ + "imagenet_templates = [\n", + " 'a bad photo of a {}.',\n", + " 'a photo of many {}.',\n", + " 'a sculpture of a {}.',\n", + " 'a photo of the hard to see {}.',\n", + " 'a low resolution photo of the {}.',\n", + " 'a rendering of a {}.',\n", + " 'graffiti of a {}.',\n", + " 'a bad photo of the {}.',\n", + " 'a cropped photo of the {}.',\n", + " 'a tattoo of a {}.',\n", + " 'the embroidered {}.',\n", + " 'a photo of a hard to see {}.',\n", + " 'a bright photo of a {}.',\n", + " 'a photo of a clean {}.',\n", + " 'a photo of a dirty {}.',\n", + " 'a dark photo of the {}.',\n", + " 'a drawing of a {}.',\n", + " 'a photo of my {}.',\n", + " 'the plastic {}.',\n", + " 'a photo of the cool {}.',\n", + " 'a close-up photo of a {}.',\n", + " 'a black and white photo of the {}.',\n", + " 'a painting of the {}.',\n", + " 'a painting of a {}.',\n", + " 'a pixelated photo of the {}.',\n", + " 'a sculpture of the {}.',\n", + " 'a bright photo of the {}.',\n", + " 'a cropped photo of a {}.',\n", + " 'a plastic {}.',\n", + " 'a photo of the dirty {}.',\n", + " 'a jpeg corrupted photo of a {}.',\n", + " 'a blurry photo of the {}.',\n", + " 'a photo of the {}.',\n", + " 'a good photo of the {}.',\n", + " 'a rendering of the {}.',\n", + " 'a {} in a video game.',\n", + " 'a photo of one {}.',\n", + " 'a doodle of a {}.',\n", + " 'a close-up photo of the {}.',\n", + " 'a photo of a {}.',\n", + " 'the origami {}.',\n", + " 'the {} in a video game.',\n", + " 'a sketch of a {}.',\n", + " 'a doodle of the {}.',\n", + " 'a origami {}.',\n", + " 'a low resolution photo of a {}.',\n", + " 'the toy {}.',\n", + " 'a rendition of the {}.',\n", + " 'a photo of the clean {}.',\n", + " 'a photo of a large {}.',\n", + " 'a rendition of a {}.',\n", + " 'a photo of a nice {}.',\n", + " 'a photo of a weird {}.',\n", + " 'a blurry photo of a {}.',\n", + " 'a cartoon {}.',\n", + " 'art of a {}.',\n", + " 'a sketch of the {}.',\n", + " 'a embroidered {}.',\n", + " 'a pixelated photo of a {}.',\n", + " 'itap of the {}.',\n", + " 'a jpeg corrupted photo of the {}.',\n", + " 'a good photo of a {}.',\n", + " 'a plushie {}.',\n", + " 'a photo of the nice {}.',\n", + " 'a photo of the small {}.',\n", + " 'a photo of the weird {}.',\n", + " 'the cartoon {}.',\n", + " 'art of the {}.',\n", + " 'a drawing of the {}.',\n", + " 'a photo of the large {}.',\n", + " 'a black and white photo of a {}.',\n", + " 'the plushie {}.',\n", + " 'a dark photo of a {}.',\n", + " 'itap of a {}.',\n", + " 'graffiti of the {}.',\n", + " 'a toy {}.',\n", + " 'itap of my {}.',\n", + " 'a photo of a cool {}.',\n", + " 'a photo of a small {}.',\n", + " 'a tattoo of the {}.',\n", + "]\n", + "\n", + "print(f\"{len(imagenet_classes)} classes, {len(imagenet_templates)} templates\")" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1000 classes, 80 templates\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aRB5OzgpHwqQ" + }, + "source": [ + "A similar, intuition-guided trial and error based on the ImageNet training set was used for templates. This list is pretty haphazard and was gradually made / expanded over the course of about a year of the project and was revisited / tweaked every few months. A surprising / weird thing was adding templates intended to help ImageNet-R performance (specifying different possible renditions of an object) improved standard ImageNet accuracy too.\n", + "\n", + "After the 80 templates were \"locked\" for the paper, we ran sequential forward selection over the list of 80 templates. The search terminated after ensembling 7 templates and selected them in the order below.\n", + "\n", + "1. itap of a {}.\n", + "2. a bad photo of the {}.\n", + "3. a origami {}.\n", + "4. a photo of the large {}.\n", + "5. a {} in a video game.\n", + "6. art of the {}.\n", + "7. a photo of the small {}.\n", + "\n", + "Speculating, we think it's interesting to see different scales (large and small), a difficult view (a bad photo), and \"abstract\" versions (origami, video game, art), were all selected for, but we haven't studied this in any detail. This subset performs a bit better than the full 80 ensemble reported in the paper, especially for the smaller models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Loading the Images\n", + "\n", + "The ILSVRC2012 datasets are no longer available for download publicly. We instead download the ImageNet-V2 dataset by [Recht et al.](https://arxiv.org/abs/1902.10811).\n", + "\n", + "If you have the ImageNet dataset downloaded, you can replace the dataset with the official torchvision loader, e.g.:\n", + "\n", + "```python\n", + "images = torchvision.datasets.ImageNet(\"path/to/imagenet\", split='val', transform=preprocess)\n", + "```" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "moHR4UlHKsDc", + "outputId": "40731297-edc7-4cd0-be75-ed426c8fb005" + }, + "source": [ + "! pip install git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + "\n", + "from imagenetv2_pytorch import ImageNetV2Dataset\n", + "\n", + "images = ImageNetV2Dataset(transform=preprocess)\n", + "loader = torch.utils.data.DataLoader(images, batch_size=32, num_workers=2)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + " Cloning https://github.com/modestyachts/ImageNetV2_pytorch to /tmp/pip-req-build-0kih0kn2\n", + " Running command git clone -q https://github.com/modestyachts/ImageNetV2_pytorch /tmp/pip-req-build-0kih0kn2\n", + "Building wheels for collected packages: imagenetv2-pytorch\n", + " Building wheel for imagenetv2-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for imagenetv2-pytorch: filename=imagenetv2_pytorch-0.1-py3-none-any.whl size=2663 sha256=ac31e0ed9c61afc5e0271eed315d3a82844a79ae64f8ce43fc1c98928cec129f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-745b5n1m/wheels/ab/ee/f4/73bce5c7f68d28ce632ef33ae87ce60aaca021eb2b3b31a6fa\n", + "Successfully built imagenetv2-pytorch\n", + "Installing collected packages: imagenetv2-pytorch\n", + "Successfully installed imagenetv2-pytorch-0.1\n", + "Dataset matched-frequency not found on disk, downloading....\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "100%|██████████| 1.26G/1.26G [01:02<00:00, 20.2MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Extracting....\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fz6D-F-Wbrtp" + }, + "source": [ + "# Creating zero-shot classifier weights" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "66a1639713ae441d8a9b873381f9d774", + "610b775178c645e2b4663b77cc0c67b6", + "412dd15f0d8542f5ab2730f8616fb582", + "5e6315f36b4e4eeea5c6294b024e0c97", + "085d5388abda4202bfa66d0c088452f8", + "f75124b64aa147c693c67a78f8e3a231", + "6e5676a054874243b55fc6d120a07d01", + "dc6d1416c01a4047935ee15c3fd2eb1c" + ] + }, + "id": "sRqDoz1Gbsii", + "outputId": "312b8ebf-3961-4903-d8cb-3b7a94cc97b6" + }, + "source": [ + "def zeroshot_classifier(classnames, templates):\n", + " with torch.no_grad():\n", + " zeroshot_weights = []\n", + " for classname in tqdm(classnames):\n", + " texts = [template.format(classname) for template in templates] #format with class\n", + " texts = clip.tokenize(texts).cuda() #tokenize\n", + " class_embeddings = model.encode_text(texts) #embed with text encoder\n", + " class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n", + " class_embedding = class_embeddings.mean(dim=0)\n", + " class_embedding /= class_embedding.norm()\n", + " zeroshot_weights.append(class_embedding)\n", + " zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n", + " return zeroshot_weights\n", + "\n", + "\n", + "zeroshot_weights = zeroshot_classifier(imagenet_classes, imagenet_templates)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66a1639713ae441d8a9b873381f9d774", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1fZo7hG8iJP5" + }, + "source": [ + "# Zero-shot prediction" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "j4kPSZoShQxN" + }, + "source": [ + "def accuracy(output, target, topk=(1,)):\n", + " pred = output.topk(max(topk), 1, True, True)[1].t()\n", + " correct = pred.eq(target.view(1, -1).expand_as(pred))\n", + " return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk]" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "84f80a7f3e764346969a347b0f71b24e", + "392656f01b2945f3bd7903783ed8cc96", + "8e47a435519b4ce090879b4be2f61f99", + "41b1ed6b0a9745c1a595377670b15ff4", + "179b8ae1eb7f4a828f953e889b141725", + "d8708e8414fd44f4abd6590c9b57996f", + "800e30f5b4f24475a2b0046da0703631", + "8764308b948745f1a677332fd21fcaf0" + ] + }, + "id": "wKJ7YsdlkDXo", + "outputId": "ab824854-38e4-4d37-ad40-2a7ce3c5fd43" + }, + "source": [ + "with torch.no_grad():\n", + " top1, top5, n = 0., 0., 0.\n", + " for i, (images, target) in enumerate(tqdm(loader)):\n", + " images = images.cuda()\n", + " target = target.cuda()\n", + " \n", + " # predict\n", + " image_features = model.encode_image(images)\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " logits = 100. * image_features @ zeroshot_weights\n", + "\n", + " # measure accuracy\n", + " acc1, acc5 = accuracy(logits, target, topk=(1, 5))\n", + " top1 += acc1\n", + " top5 += acc5\n", + " n += images.size(0)\n", + "\n", + "top1 = (top1 / n) * 100\n", + "top5 = (top5 / n) * 100 \n", + "\n", + "print(f\"Top-1 accuracy: {top1:.2f}\")\n", + "print(f\"Top-5 accuracy: {top5:.2f}\")" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84f80a7f3e764346969a347b0f71b24e", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=313.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Top-1 accuracy: 55.93\n", + "Top-5 accuracy: 83.36\n" + ], + "name": "stdout" + } + ] + } + ] +} diff --git a/CLIP/requirements.txt b/CLIP/requirements.txt new file mode 100644 index 0000000..6b98c33 --- /dev/null +++ b/CLIP/requirements.txt @@ -0,0 +1,5 @@ +ftfy +regex +tqdm +torch +torchvision diff --git a/CLIP/setup.py b/CLIP/setup.py new file mode 100644 index 0000000..c9ea7d0 --- /dev/null +++ b/CLIP/setup.py @@ -0,0 +1,21 @@ +import os + +import pkg_resources +from setuptools import setup, find_packages + +setup( + name="clip", + py_modules=["clip"], + version="1.0", + description="", + author="OpenAI", + packages=find_packages(exclude=["tests*"]), + install_requires=[ + str(r) + for r in pkg_resources.parse_requirements( + open(os.path.join(os.path.dirname(__file__), "requirements.txt")) + ) + ], + include_package_data=True, + extras_require={'dev': ['pytest']}, +) diff --git a/CLIP/tests/test_consistency.py b/CLIP/tests/test_consistency.py new file mode 100644 index 0000000..f2c6fd4 --- /dev/null +++ b/CLIP/tests/test_consistency.py @@ -0,0 +1,25 @@ +import numpy as np +import pytest +import torch +from PIL import Image + +import clip + + +@pytest.mark.parametrize('model_name', clip.available_models()) +def test_consistency(model_name): + device = "cpu" + jit_model, transform = clip.load(model_name, device=device, jit=True) + py_model, _ = clip.load(model_name, device=device, jit=False) + + image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device) + text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + + with torch.no_grad(): + logits_per_image, _ = jit_model(image, text) + jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + logits_per_image, _ = py_model(image, text) + py_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1) From 4e6b23ac92bdf5049d9d9290e81db264c4e9bd8d Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:21:07 -0700 Subject: [PATCH 126/197] Add big table script, use v100 --- scripts/run_adaptation_experiments.py | 2 +- scripts/run_all_experiments_amulet.sh | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 scripts/run_all_experiments_amulet.sh diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 34f5ff8..d191901 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100-P100\n") + " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/run_all_experiments_amulet.sh b/scripts/run_all_experiments_amulet.sh new file mode 100644 index 0000000..858bfd0 --- /dev/null +++ b/scripts/run_all_experiments_amulet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +declare -a models=(timm_vit_b16_in21k clip_vit_b16 dino_vit_b16 bit_resnet_50_in21k convnext_vit_b clip_vit_l14 bit_resnet_101_in21k) +declare -a datasets=(waterbirds living17_nonorm domainnet) +for dataset in "${datasets[@]}"; do + for model in "${models[@]}"; do + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --amulet_option=run --sbatch_script_name=run_rtx_sbatch.sh --freeze_bottom_k=2 + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --freeze_bottom_k=2 --amulet_option=run + done +done + From 433a59330c8d7e0595c8dde579df2a2971313537 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:21:07 -0700 Subject: [PATCH 127/197] Add big table script, use v100 --- scripts/run_adaptation_experiments.py | 2 +- scripts/run_all_experiments_amulet.sh | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 scripts/run_all_experiments_amulet.sh diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 34f5ff8..d191901 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100-P100\n") + " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/run_all_experiments_amulet.sh b/scripts/run_all_experiments_amulet.sh new file mode 100644 index 0000000..858bfd0 --- /dev/null +++ b/scripts/run_all_experiments_amulet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +declare -a models=(timm_vit_b16_in21k clip_vit_b16 dino_vit_b16 bit_resnet_50_in21k convnext_vit_b clip_vit_l14 bit_resnet_101_in21k) +declare -a datasets=(waterbirds living17_nonorm domainnet) +for dataset in "${datasets[@]}"; do + for model in "${models[@]}"; do + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --amulet_option=run --sbatch_script_name=run_rtx_sbatch.sh --freeze_bottom_k=2 + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --freeze_bottom_k=2 --amulet_option=run + done +done + From 698bd430323561b8fb291d3b8767cfdd5687db63 Mon Sep 17 00:00:00 2001 From: AnanyaKumar Date: Wed, 7 Sep 2022 15:21:07 -0700 Subject: [PATCH 128/197] Add big table script, use v100 --- scripts/run_adaptation_experiments.py | 2 +- scripts/run_all_experiments_amulet.sh | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 scripts/run_all_experiments_amulet.sh diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 34f5ff8..d191901 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100-P100\n") + " sku: G1-V100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/run_all_experiments_amulet.sh b/scripts/run_all_experiments_amulet.sh new file mode 100644 index 0000000..858bfd0 --- /dev/null +++ b/scripts/run_all_experiments_amulet.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +declare -a models=(timm_vit_b16_in21k clip_vit_b16 dino_vit_b16 bit_resnet_50_in21k convnext_vit_b clip_vit_l14 bit_resnet_101_in21k) +declare -a datasets=(waterbirds living17_nonorm domainnet) +for dataset in "${datasets[@]}"; do + for model in "${models[@]}"; do + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --amulet_option=run --sbatch_script_name=run_rtx_sbatch.sh --freeze_bottom_k=2 + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --amulet_option=run + python scripts/run_adaptation_experiments.py --experiment=fine_tuning_experiments --datasets $dataset --model_name=$model --partition=jag-standard --sbatch_script_name=run_rtx_sbatch.sh --optimizer='torch.optim.AdamW' --freeze_bottom_k=2 --amulet_option=run + done +done + From f005701bdbac164d65e23ee3b77301a78479a14c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:00 -0700 Subject: [PATCH 129/197] Automate results collection a bit more. --- scripts/fine-tuning-results.ipynb | 260 ++++++++++++++++++++++++++ scripts/load_models_get_layers.ipynb | 103 +++++++++- scripts/run_adaptation_experiments.py | 2 +- scripts/summarize_all_results.py | 224 +++++++++++----------- 4 files changed, 480 insertions(+), 109 deletions(-) create mode 100644 scripts/fine-tuning-results.ipynb diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb new file mode 100644 index 0000000..bec93f7 --- /dev/null +++ b/scripts/fine-tuning-results.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", + " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_results = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_results = np.concatenate(cur_results)\n", + " table[model_idx][option_idx] = cur_results\n", + " return table\n", + "\n", + "# Add table to make TSV and Latex tables.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if std_err_table is not None:\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", + " print(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", + "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 2 is out of bounds for axis 0 with size 2", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + ] + } + ], + "source": [ + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" + ] + } + ], + "source": [ + "# LAMB and LARS results for CLIP ViT-B/16\n", + "models = ['clip_vit_b16']\n", + "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['Lamb', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[97.026]], dtype=object)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_row_mean.to_numpy()[:,:-2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f00a5e6..beceb6e 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 6, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,12 +22,31 @@ "import importlib\n", "import timm\n", "import torch\n", + "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", "importlib.reload(timm_model)" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "import sys\n", + "print(sys.path)" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -45,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -174,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -196,6 +215,82 @@ "get_layers_freeze_test(model)\n" ] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch_embed 26.6946963982087\n", + "empty_ln_pre 0.0\n", + "pos_embed 114.1449203491211\n", + "cls_token 11.814652442932129\n", + "trans0_norm1 10.727939400443407\n", + "trans0_attn 51.44874777832921\n", + "trans0_norm2 28.292761646663003\n", + "trans0_mlp 76.65611477620195\n", + "trans1_norm1 11.67158919875855\n", + "trans1_attn 51.968497785989186\n", + "trans1_norm2 16.081294584238012\n", + "trans1_mlp 72.49136824958491\n", + "trans2_norm1 14.588461930309668\n", + "trans2_attn 47.43609999667546\n", + "trans2_norm2 16.750402005493847\n", + "trans2_mlp 73.4898046975493\n", + "trans3_norm1 17.127796509537827\n", + "trans3_attn 46.12080652841503\n", + "trans3_norm2 16.560562623359647\n", + "trans3_mlp 73.75539281539531\n", + "trans4_norm1 16.38613601236467\n", + "trans4_attn 45.396057461621595\n", + "trans4_norm2 15.56170805432499\n", + "trans4_mlp 74.04262678751516\n", + "trans5_norm1 15.666596993058972\n", + "trans5_attn 45.22580724285582\n", + "trans5_norm2 16.125041315399216\n", + "trans5_mlp 74.32087040062893\n", + "trans6_norm1 16.50691386925591\n", + "trans6_attn 44.89644589636653\n", + "trans6_norm2 16.870073778570866\n", + "trans6_mlp 78.20890488715406\n", + "trans7_norm1 16.66077125665377\n", + "trans7_attn 45.82781002989781\n", + "trans7_norm2 19.266974095400364\n", + "trans7_mlp 81.80467684677028\n", + "trans8_norm1 17.5644882043329\n", + "trans8_attn 47.610578568992075\n", + "trans8_norm2 43.14843316111718\n", + "trans8_mlp 81.65995954456746\n", + "trans9_norm1 19.72671889415036\n", + "trans9_attn 48.02174698323452\n", + "trans9_norm2 65.44239677355796\n", + "trans9_mlp 85.10741788908027\n", + "trans10_norm1 23.690038485002656\n", + "trans10_attn 47.81185122297828\n", + "trans10_norm2 173.51592363743683\n", + "trans10_mlp 96.2868619031599\n", + "trans11_norm1 29.018153114479592\n", + "trans11_attn 53.61129902293072\n", + "trans11_norm2 24.21393277393142\n", + "trans11_mlp 84.18814129510835\n", + "post_norm 48.72875120683025\n", + "head 17.718359892033757\n" + ] + } + ], + "source": [ + "# Get model grads and norms for Timm ViT-S\n", + "layers = model.get_layers()\n", + "\n", + "for name, layer in layers:\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " print(name, norm)" + ] + }, { "cell_type": "code", "execution_count": 3, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index d191901..3df2523 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-A100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 07c08b5..25db1d0 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -1,104 +1,120 @@ -# Unlike summarize results, this summarizes results for many experiments at once. -import argparse -import pandas as pd -import numpy as np -import json -import subprocess -from pathlib import Path -from collections import OrderedDict -import os -import shlex -import shutil -import uuid -import re -import glob -from pathlib import Path - -from summarize_results import get_result, summarize_results - - -def remove_replication_info(s): - idx = s.find('_seed') - s = s[:idx] + s[idx+7:] - idx = s.find('_run') - s = s[:idx] + s[idx+6:] - return s - - -def get_all_results(val_metric, dir_paths, output_metrics): - results, best, dirs = [], [], [] - for dir_path in dir_paths: - res, val_values_list, file_paths = summarize_results( - dir_path, val_metric, output_metrics) - if len(res) == 0: - continue - res['group'] = res['name'].apply(remove_replication_info) - grouped = res.groupby('group') - means = grouped.mean() - counts = grouped.count() - counts.drop(labels=['name', 'wandb_url'], axis=1) - stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) - stderrs = stderrs[means.columns] - min_count = grouped.count().iloc[:,0].min() - if val_metric == 'LAST': - best_row_mean = means.iloc[[-1]] - best_row_std = stderrs.iloc[[-1]] - else: - best_group = means[val_metric].idxmax() - best_row_mean = means.loc[[best_group]] - best_row_std = stderrs.loc[[best_group]] - best_row_mean['name'] = dir_path[5:] - best_row_std['name'] = dir_path[5:] + ' (stddev)' - for best_row in [best_row_mean, best_row_std]: - best_row['group'] = best_row.index - best_row.set_index('name') - results.append(res) - best.append((best_row_mean, best_row_std)) - dirs.append(dir_path) - return results, best, dirs - - -if __name__ == '__main__': - # Higher is better when we pick val_metric, so use it for accuracies not losses. - parser = argparse.ArgumentParser(description='Read logs') - parser.add_argument('--results_dir_glob', type=str, required=True, - help="Folders where we should look for tsv files (glob syntax)") - parser.add_argument('--val_metrics', type=str, nargs='+', - help='Metrics to use to pick best (higher better) row and checkpoint.') - parser.add_argument('--output_metrics', type=str, nargs='+', - help='Metrics to output.') - parser.add_argument('--output_file', type=str, - help='Path to output results, should end with .tsv') - parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") - args = parser.parse_args() - # Get all folders satisfying glob. - dir_paths = glob.glob(args.results_dir_glob, recursive=False) - dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] - output = '' - for val_metric in args.val_metrics: - results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) - output += '\n\n\n' - output += f'Early stopped based on {val_metric}:\n\n' - output_header = True - for best_item, cur_dir in zip(best, dirs): - output += f'{cur_dir}\n' - output += best_item[0].to_csv(sep='\t', index=None, header=output_header) - output_header = False - output += best_item[1].to_csv(sep='\t', index=None, header=False) - output += '\n' - output += 'All results:\n\n' - for result, cur_dir in zip(results, dirs): - output += f'{cur_dir}\n' - output += result.to_csv(sep='\t', index=None, header=False) - output += '\n' - - if args.output_file is None: - output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') - else: - if args.output_file[-4:] != '.tsv': - raise ValueError('--output_file should end with .tsv') - output_file = args.output_file - with open(output_file, "w") as write_file: - write_file.write(output) - print('Saved results to ' + output_file) - +# Unlike summarize results, this summarizes results for many experiments at once. +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + +from summarize_results import get_result, summarize_results + + +def remove_replication_info(s): + idx = s.find('_seed') + s = s[:idx] + s[idx+7:] + idx = s.find('_run') + s = s[:idx] + s[idx+6:] + return s + + +def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggregation_metric=None): + # summarize_result gets a table where each row is the results for one *run*. + # We now summarize the information across runs in a *single* experiment. + # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). + res, val_values_list, file_paths = summarize_results( + dir_path, val_metric, output_metrics) + if len(res) == 0: + return None, None, None + res['group'] = res['name'].apply(remove_replication_info) + grouped = res.groupby('group') + means = grouped.mean() + counts = grouped.count() + counts.drop(labels=['name', 'wandb_url'], axis=1) + stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) + stderrs = stderrs[means.columns] + min_count = grouped.count().iloc[:,0].min() + if val_metric == 'LAST' and (aggregation_metric is None or aggregation_metric == 'LAST'): + best_row_mean = means.iloc[[-1]] + best_row_std = stderrs.iloc[[-1]] + else: + if aggregation_metric is None: + best_group = means[val_metric].idxmax() + else: + best_group = means[aggregation_metric].idxmax() + best_row_mean = means.loc[[best_group]] + best_row_std = stderrs.loc[[best_group]] + best_row_mean['name'] = dir_path[5:] + best_row_std['name'] = dir_path[5:] + ' (stddev)' + for best_row in [best_row_mean, best_row_std]: + best_row['group'] = best_row.index + best_row.set_index('name') + return res, best_row_mean, best_row_std + + +def get_all_results(val_metric, dir_paths, output_metrics): + # Get results for multiple experiments (each dir_path in dir_paths corresponds + # to one experiment). + results, best, dirs = [], [], [] + for dir_path in dir_paths: + res, best_row_mean, best_row_std = get_experiment_aggregate_summary( + dir_path, val_metric, output_metrics) + if res is None: + continue + results.append(res) + best.append((best_row_mean, best_row_std)) + dirs.append(dir_path) + return results, best, dirs + + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir_glob', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metrics', type=str, nargs='+', + help='Metrics to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + # Get all folders satisfying glob. + dir_paths = glob.glob(args.results_dir_glob, recursive=False) + dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] + output = '' + for val_metric in args.val_metrics: + results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) + output += '\n\n\n' + output += f'Early stopped based on {val_metric}:\n\n' + output_header = True + for best_item, cur_dir in zip(best, dirs): + output += f'{cur_dir}\n' + output += best_item[0].to_csv(sep='\t', index=None, header=output_header) + output_header = False + output += best_item[1].to_csv(sep='\t', index=None, header=False) + output += '\n' + output += 'All results:\n\n' + for result, cur_dir in zip(results, dirs): + output += f'{cur_dir}\n' + output += result.to_csv(sep='\t', index=None, header=False) + output += '\n' + + if args.output_file is None: + output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + From 18b3a62d3b461089304c8f4780ce0ccde2acdc9e Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:00 -0700 Subject: [PATCH 130/197] Automate results collection a bit more. --- scripts/fine-tuning-results.ipynb | 260 ++++++++++++++++++++++++++ scripts/load_models_get_layers.ipynb | 103 +++++++++- scripts/run_adaptation_experiments.py | 2 +- scripts/summarize_all_results.py | 224 +++++++++++----------- 4 files changed, 480 insertions(+), 109 deletions(-) create mode 100644 scripts/fine-tuning-results.ipynb diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb new file mode 100644 index 0000000..bec93f7 --- /dev/null +++ b/scripts/fine-tuning-results.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", + " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_results = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_results = np.concatenate(cur_results)\n", + " table[model_idx][option_idx] = cur_results\n", + " return table\n", + "\n", + "# Add table to make TSV and Latex tables.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if std_err_table is not None:\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", + " print(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", + "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 2 is out of bounds for axis 0 with size 2", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + ] + } + ], + "source": [ + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" + ] + } + ], + "source": [ + "# LAMB and LARS results for CLIP ViT-B/16\n", + "models = ['clip_vit_b16']\n", + "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['Lamb', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[97.026]], dtype=object)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_row_mean.to_numpy()[:,:-2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f00a5e6..beceb6e 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 6, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,12 +22,31 @@ "import importlib\n", "import timm\n", "import torch\n", + "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", "importlib.reload(timm_model)" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "import sys\n", + "print(sys.path)" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -45,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -174,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -196,6 +215,82 @@ "get_layers_freeze_test(model)\n" ] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch_embed 26.6946963982087\n", + "empty_ln_pre 0.0\n", + "pos_embed 114.1449203491211\n", + "cls_token 11.814652442932129\n", + "trans0_norm1 10.727939400443407\n", + "trans0_attn 51.44874777832921\n", + "trans0_norm2 28.292761646663003\n", + "trans0_mlp 76.65611477620195\n", + "trans1_norm1 11.67158919875855\n", + "trans1_attn 51.968497785989186\n", + "trans1_norm2 16.081294584238012\n", + "trans1_mlp 72.49136824958491\n", + "trans2_norm1 14.588461930309668\n", + "trans2_attn 47.43609999667546\n", + "trans2_norm2 16.750402005493847\n", + "trans2_mlp 73.4898046975493\n", + "trans3_norm1 17.127796509537827\n", + "trans3_attn 46.12080652841503\n", + "trans3_norm2 16.560562623359647\n", + "trans3_mlp 73.75539281539531\n", + "trans4_norm1 16.38613601236467\n", + "trans4_attn 45.396057461621595\n", + "trans4_norm2 15.56170805432499\n", + "trans4_mlp 74.04262678751516\n", + "trans5_norm1 15.666596993058972\n", + "trans5_attn 45.22580724285582\n", + "trans5_norm2 16.125041315399216\n", + "trans5_mlp 74.32087040062893\n", + "trans6_norm1 16.50691386925591\n", + "trans6_attn 44.89644589636653\n", + "trans6_norm2 16.870073778570866\n", + "trans6_mlp 78.20890488715406\n", + "trans7_norm1 16.66077125665377\n", + "trans7_attn 45.82781002989781\n", + "trans7_norm2 19.266974095400364\n", + "trans7_mlp 81.80467684677028\n", + "trans8_norm1 17.5644882043329\n", + "trans8_attn 47.610578568992075\n", + "trans8_norm2 43.14843316111718\n", + "trans8_mlp 81.65995954456746\n", + "trans9_norm1 19.72671889415036\n", + "trans9_attn 48.02174698323452\n", + "trans9_norm2 65.44239677355796\n", + "trans9_mlp 85.10741788908027\n", + "trans10_norm1 23.690038485002656\n", + "trans10_attn 47.81185122297828\n", + "trans10_norm2 173.51592363743683\n", + "trans10_mlp 96.2868619031599\n", + "trans11_norm1 29.018153114479592\n", + "trans11_attn 53.61129902293072\n", + "trans11_norm2 24.21393277393142\n", + "trans11_mlp 84.18814129510835\n", + "post_norm 48.72875120683025\n", + "head 17.718359892033757\n" + ] + } + ], + "source": [ + "# Get model grads and norms for Timm ViT-S\n", + "layers = model.get_layers()\n", + "\n", + "for name, layer in layers:\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " print(name, norm)" + ] + }, { "cell_type": "code", "execution_count": 3, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index d191901..3df2523 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-A100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 07c08b5..25db1d0 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -1,104 +1,120 @@ -# Unlike summarize results, this summarizes results for many experiments at once. -import argparse -import pandas as pd -import numpy as np -import json -import subprocess -from pathlib import Path -from collections import OrderedDict -import os -import shlex -import shutil -import uuid -import re -import glob -from pathlib import Path - -from summarize_results import get_result, summarize_results - - -def remove_replication_info(s): - idx = s.find('_seed') - s = s[:idx] + s[idx+7:] - idx = s.find('_run') - s = s[:idx] + s[idx+6:] - return s - - -def get_all_results(val_metric, dir_paths, output_metrics): - results, best, dirs = [], [], [] - for dir_path in dir_paths: - res, val_values_list, file_paths = summarize_results( - dir_path, val_metric, output_metrics) - if len(res) == 0: - continue - res['group'] = res['name'].apply(remove_replication_info) - grouped = res.groupby('group') - means = grouped.mean() - counts = grouped.count() - counts.drop(labels=['name', 'wandb_url'], axis=1) - stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) - stderrs = stderrs[means.columns] - min_count = grouped.count().iloc[:,0].min() - if val_metric == 'LAST': - best_row_mean = means.iloc[[-1]] - best_row_std = stderrs.iloc[[-1]] - else: - best_group = means[val_metric].idxmax() - best_row_mean = means.loc[[best_group]] - best_row_std = stderrs.loc[[best_group]] - best_row_mean['name'] = dir_path[5:] - best_row_std['name'] = dir_path[5:] + ' (stddev)' - for best_row in [best_row_mean, best_row_std]: - best_row['group'] = best_row.index - best_row.set_index('name') - results.append(res) - best.append((best_row_mean, best_row_std)) - dirs.append(dir_path) - return results, best, dirs - - -if __name__ == '__main__': - # Higher is better when we pick val_metric, so use it for accuracies not losses. - parser = argparse.ArgumentParser(description='Read logs') - parser.add_argument('--results_dir_glob', type=str, required=True, - help="Folders where we should look for tsv files (glob syntax)") - parser.add_argument('--val_metrics', type=str, nargs='+', - help='Metrics to use to pick best (higher better) row and checkpoint.') - parser.add_argument('--output_metrics', type=str, nargs='+', - help='Metrics to output.') - parser.add_argument('--output_file', type=str, - help='Path to output results, should end with .tsv') - parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") - args = parser.parse_args() - # Get all folders satisfying glob. - dir_paths = glob.glob(args.results_dir_glob, recursive=False) - dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] - output = '' - for val_metric in args.val_metrics: - results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) - output += '\n\n\n' - output += f'Early stopped based on {val_metric}:\n\n' - output_header = True - for best_item, cur_dir in zip(best, dirs): - output += f'{cur_dir}\n' - output += best_item[0].to_csv(sep='\t', index=None, header=output_header) - output_header = False - output += best_item[1].to_csv(sep='\t', index=None, header=False) - output += '\n' - output += 'All results:\n\n' - for result, cur_dir in zip(results, dirs): - output += f'{cur_dir}\n' - output += result.to_csv(sep='\t', index=None, header=False) - output += '\n' - - if args.output_file is None: - output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') - else: - if args.output_file[-4:] != '.tsv': - raise ValueError('--output_file should end with .tsv') - output_file = args.output_file - with open(output_file, "w") as write_file: - write_file.write(output) - print('Saved results to ' + output_file) - +# Unlike summarize results, this summarizes results for many experiments at once. +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + +from summarize_results import get_result, summarize_results + + +def remove_replication_info(s): + idx = s.find('_seed') + s = s[:idx] + s[idx+7:] + idx = s.find('_run') + s = s[:idx] + s[idx+6:] + return s + + +def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggregation_metric=None): + # summarize_result gets a table where each row is the results for one *run*. + # We now summarize the information across runs in a *single* experiment. + # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). + res, val_values_list, file_paths = summarize_results( + dir_path, val_metric, output_metrics) + if len(res) == 0: + return None, None, None + res['group'] = res['name'].apply(remove_replication_info) + grouped = res.groupby('group') + means = grouped.mean() + counts = grouped.count() + counts.drop(labels=['name', 'wandb_url'], axis=1) + stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) + stderrs = stderrs[means.columns] + min_count = grouped.count().iloc[:,0].min() + if val_metric == 'LAST' and (aggregation_metric is None or aggregation_metric == 'LAST'): + best_row_mean = means.iloc[[-1]] + best_row_std = stderrs.iloc[[-1]] + else: + if aggregation_metric is None: + best_group = means[val_metric].idxmax() + else: + best_group = means[aggregation_metric].idxmax() + best_row_mean = means.loc[[best_group]] + best_row_std = stderrs.loc[[best_group]] + best_row_mean['name'] = dir_path[5:] + best_row_std['name'] = dir_path[5:] + ' (stddev)' + for best_row in [best_row_mean, best_row_std]: + best_row['group'] = best_row.index + best_row.set_index('name') + return res, best_row_mean, best_row_std + + +def get_all_results(val_metric, dir_paths, output_metrics): + # Get results for multiple experiments (each dir_path in dir_paths corresponds + # to one experiment). + results, best, dirs = [], [], [] + for dir_path in dir_paths: + res, best_row_mean, best_row_std = get_experiment_aggregate_summary( + dir_path, val_metric, output_metrics) + if res is None: + continue + results.append(res) + best.append((best_row_mean, best_row_std)) + dirs.append(dir_path) + return results, best, dirs + + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir_glob', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metrics', type=str, nargs='+', + help='Metrics to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + # Get all folders satisfying glob. + dir_paths = glob.glob(args.results_dir_glob, recursive=False) + dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] + output = '' + for val_metric in args.val_metrics: + results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) + output += '\n\n\n' + output += f'Early stopped based on {val_metric}:\n\n' + output_header = True + for best_item, cur_dir in zip(best, dirs): + output += f'{cur_dir}\n' + output += best_item[0].to_csv(sep='\t', index=None, header=output_header) + output_header = False + output += best_item[1].to_csv(sep='\t', index=None, header=False) + output += '\n' + output += 'All results:\n\n' + for result, cur_dir in zip(results, dirs): + output += f'{cur_dir}\n' + output += result.to_csv(sep='\t', index=None, header=False) + output += '\n' + + if args.output_file is None: + output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + From 9f14e306150afe41685297c24e4c9cc44a49a0bd Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:00 -0700 Subject: [PATCH 131/197] Automate results collection a bit more. --- scripts/fine-tuning-results.ipynb | 260 ++++++++++++++++++++++++++ scripts/load_models_get_layers.ipynb | 103 +++++++++- scripts/run_adaptation_experiments.py | 2 +- scripts/summarize_all_results.py | 224 +++++++++++----------- 4 files changed, 480 insertions(+), 109 deletions(-) create mode 100644 scripts/fine-tuning-results.ipynb diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb new file mode 100644 index 0000000..bec93f7 --- /dev/null +++ b/scripts/fine-tuning-results.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", + " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_results = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_results = np.concatenate(cur_results)\n", + " table[model_idx][option_idx] = cur_results\n", + " return table\n", + "\n", + "# Add table to make TSV and Latex tables.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if std_err_table is not None:\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", + " print(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", + "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 2 is out of bounds for axis 0 with size 2", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + ] + } + ], + "source": [ + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" + ] + } + ], + "source": [ + "# LAMB and LARS results for CLIP ViT-B/16\n", + "models = ['clip_vit_b16']\n", + "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['Lamb', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[97.026]], dtype=object)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_row_mean.to_numpy()[:,:-2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_get_layers.ipynb index f00a5e6..beceb6e 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_get_layers.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 6, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,12 +22,31 @@ "import importlib\n", "import timm\n", "import torch\n", + "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", "importlib.reload(timm_model)" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "import sys\n", + "print(sys.path)" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -45,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -174,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -196,6 +215,82 @@ "get_layers_freeze_test(model)\n" ] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch_embed 26.6946963982087\n", + "empty_ln_pre 0.0\n", + "pos_embed 114.1449203491211\n", + "cls_token 11.814652442932129\n", + "trans0_norm1 10.727939400443407\n", + "trans0_attn 51.44874777832921\n", + "trans0_norm2 28.292761646663003\n", + "trans0_mlp 76.65611477620195\n", + "trans1_norm1 11.67158919875855\n", + "trans1_attn 51.968497785989186\n", + "trans1_norm2 16.081294584238012\n", + "trans1_mlp 72.49136824958491\n", + "trans2_norm1 14.588461930309668\n", + "trans2_attn 47.43609999667546\n", + "trans2_norm2 16.750402005493847\n", + "trans2_mlp 73.4898046975493\n", + "trans3_norm1 17.127796509537827\n", + "trans3_attn 46.12080652841503\n", + "trans3_norm2 16.560562623359647\n", + "trans3_mlp 73.75539281539531\n", + "trans4_norm1 16.38613601236467\n", + "trans4_attn 45.396057461621595\n", + "trans4_norm2 15.56170805432499\n", + "trans4_mlp 74.04262678751516\n", + "trans5_norm1 15.666596993058972\n", + "trans5_attn 45.22580724285582\n", + "trans5_norm2 16.125041315399216\n", + "trans5_mlp 74.32087040062893\n", + "trans6_norm1 16.50691386925591\n", + "trans6_attn 44.89644589636653\n", + "trans6_norm2 16.870073778570866\n", + "trans6_mlp 78.20890488715406\n", + "trans7_norm1 16.66077125665377\n", + "trans7_attn 45.82781002989781\n", + "trans7_norm2 19.266974095400364\n", + "trans7_mlp 81.80467684677028\n", + "trans8_norm1 17.5644882043329\n", + "trans8_attn 47.610578568992075\n", + "trans8_norm2 43.14843316111718\n", + "trans8_mlp 81.65995954456746\n", + "trans9_norm1 19.72671889415036\n", + "trans9_attn 48.02174698323452\n", + "trans9_norm2 65.44239677355796\n", + "trans9_mlp 85.10741788908027\n", + "trans10_norm1 23.690038485002656\n", + "trans10_attn 47.81185122297828\n", + "trans10_norm2 173.51592363743683\n", + "trans10_mlp 96.2868619031599\n", + "trans11_norm1 29.018153114479592\n", + "trans11_attn 53.61129902293072\n", + "trans11_norm2 24.21393277393142\n", + "trans11_mlp 84.18814129510835\n", + "post_norm 48.72875120683025\n", + "head 17.718359892033757\n" + ] + } + ], + "source": [ + "# Get model grads and norms for Timm ViT-S\n", + "layers = model.get_layers()\n", + "\n", + "for name, layer in layers:\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " print(name, norm)" + ] + }, { "cell_type": "code", "execution_count": 3, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index d191901..3df2523 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -303,7 +303,7 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # Check if the dataset has additional setup operations, and if so add it. # Read and fill out the jobs section. job_header = (" - name: {}\n" - " sku: G1-V100\n") + " sku: G1-A100\n") if args.amulet_cluster == 'sing_basic': job_header += " sla_tier: basic\n" job_header += " command:\n" diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 07c08b5..25db1d0 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -1,104 +1,120 @@ -# Unlike summarize results, this summarizes results for many experiments at once. -import argparse -import pandas as pd -import numpy as np -import json -import subprocess -from pathlib import Path -from collections import OrderedDict -import os -import shlex -import shutil -import uuid -import re -import glob -from pathlib import Path - -from summarize_results import get_result, summarize_results - - -def remove_replication_info(s): - idx = s.find('_seed') - s = s[:idx] + s[idx+7:] - idx = s.find('_run') - s = s[:idx] + s[idx+6:] - return s - - -def get_all_results(val_metric, dir_paths, output_metrics): - results, best, dirs = [], [], [] - for dir_path in dir_paths: - res, val_values_list, file_paths = summarize_results( - dir_path, val_metric, output_metrics) - if len(res) == 0: - continue - res['group'] = res['name'].apply(remove_replication_info) - grouped = res.groupby('group') - means = grouped.mean() - counts = grouped.count() - counts.drop(labels=['name', 'wandb_url'], axis=1) - stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) - stderrs = stderrs[means.columns] - min_count = grouped.count().iloc[:,0].min() - if val_metric == 'LAST': - best_row_mean = means.iloc[[-1]] - best_row_std = stderrs.iloc[[-1]] - else: - best_group = means[val_metric].idxmax() - best_row_mean = means.loc[[best_group]] - best_row_std = stderrs.loc[[best_group]] - best_row_mean['name'] = dir_path[5:] - best_row_std['name'] = dir_path[5:] + ' (stddev)' - for best_row in [best_row_mean, best_row_std]: - best_row['group'] = best_row.index - best_row.set_index('name') - results.append(res) - best.append((best_row_mean, best_row_std)) - dirs.append(dir_path) - return results, best, dirs - - -if __name__ == '__main__': - # Higher is better when we pick val_metric, so use it for accuracies not losses. - parser = argparse.ArgumentParser(description='Read logs') - parser.add_argument('--results_dir_glob', type=str, required=True, - help="Folders where we should look for tsv files (glob syntax)") - parser.add_argument('--val_metrics', type=str, nargs='+', - help='Metrics to use to pick best (higher better) row and checkpoint.') - parser.add_argument('--output_metrics', type=str, nargs='+', - help='Metrics to output.') - parser.add_argument('--output_file', type=str, - help='Path to output results, should end with .tsv') - parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") - args = parser.parse_args() - # Get all folders satisfying glob. - dir_paths = glob.glob(args.results_dir_glob, recursive=False) - dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] - output = '' - for val_metric in args.val_metrics: - results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) - output += '\n\n\n' - output += f'Early stopped based on {val_metric}:\n\n' - output_header = True - for best_item, cur_dir in zip(best, dirs): - output += f'{cur_dir}\n' - output += best_item[0].to_csv(sep='\t', index=None, header=output_header) - output_header = False - output += best_item[1].to_csv(sep='\t', index=None, header=False) - output += '\n' - output += 'All results:\n\n' - for result, cur_dir in zip(results, dirs): - output += f'{cur_dir}\n' - output += result.to_csv(sep='\t', index=None, header=False) - output += '\n' - - if args.output_file is None: - output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') - else: - if args.output_file[-4:] != '.tsv': - raise ValueError('--output_file should end with .tsv') - output_file = args.output_file - with open(output_file, "w") as write_file: - write_file.write(output) - print('Saved results to ' + output_file) - +# Unlike summarize results, this summarizes results for many experiments at once. +import argparse +import pandas as pd +import numpy as np +import json +import subprocess +from pathlib import Path +from collections import OrderedDict +import os +import shlex +import shutil +import uuid +import re +import glob +from pathlib import Path + +from summarize_results import get_result, summarize_results + + +def remove_replication_info(s): + idx = s.find('_seed') + s = s[:idx] + s[idx+7:] + idx = s.find('_run') + s = s[:idx] + s[idx+6:] + return s + + +def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggregation_metric=None): + # summarize_result gets a table where each row is the results for one *run*. + # We now summarize the information across runs in a *single* experiment. + # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). + res, val_values_list, file_paths = summarize_results( + dir_path, val_metric, output_metrics) + if len(res) == 0: + return None, None, None + res['group'] = res['name'].apply(remove_replication_info) + grouped = res.groupby('group') + means = grouped.mean() + counts = grouped.count() + counts.drop(labels=['name', 'wandb_url'], axis=1) + stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) + stderrs = stderrs[means.columns] + min_count = grouped.count().iloc[:,0].min() + if val_metric == 'LAST' and (aggregation_metric is None or aggregation_metric == 'LAST'): + best_row_mean = means.iloc[[-1]] + best_row_std = stderrs.iloc[[-1]] + else: + if aggregation_metric is None: + best_group = means[val_metric].idxmax() + else: + best_group = means[aggregation_metric].idxmax() + best_row_mean = means.loc[[best_group]] + best_row_std = stderrs.loc[[best_group]] + best_row_mean['name'] = dir_path[5:] + best_row_std['name'] = dir_path[5:] + ' (stddev)' + for best_row in [best_row_mean, best_row_std]: + best_row['group'] = best_row.index + best_row.set_index('name') + return res, best_row_mean, best_row_std + + +def get_all_results(val_metric, dir_paths, output_metrics): + # Get results for multiple experiments (each dir_path in dir_paths corresponds + # to one experiment). + results, best, dirs = [], [], [] + for dir_path in dir_paths: + res, best_row_mean, best_row_std = get_experiment_aggregate_summary( + dir_path, val_metric, output_metrics) + if res is None: + continue + results.append(res) + best.append((best_row_mean, best_row_std)) + dirs.append(dir_path) + return results, best, dirs + + +if __name__ == '__main__': + # Higher is better when we pick val_metric, so use it for accuracies not losses. + parser = argparse.ArgumentParser(description='Read logs') + parser.add_argument('--results_dir_glob', type=str, required=True, + help="Folders where we should look for tsv files (glob syntax)") + parser.add_argument('--val_metrics', type=str, nargs='+', + help='Metrics to use to pick best (higher better) row and checkpoint.') + parser.add_argument('--output_metrics', type=str, nargs='+', + help='Metrics to output.') + parser.add_argument('--output_file', type=str, + help='Path to output results, should end with .tsv') + parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + args = parser.parse_args() + # Get all folders satisfying glob. + dir_paths = glob.glob(args.results_dir_glob, recursive=False) + dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] + output = '' + for val_metric in args.val_metrics: + results, best, dirs = get_all_results(val_metric, dir_paths, args.output_metrics) + output += '\n\n\n' + output += f'Early stopped based on {val_metric}:\n\n' + output_header = True + for best_item, cur_dir in zip(best, dirs): + output += f'{cur_dir}\n' + output += best_item[0].to_csv(sep='\t', index=None, header=output_header) + output_header = False + output += best_item[1].to_csv(sep='\t', index=None, header=False) + output += '\n' + output += 'All results:\n\n' + for result, cur_dir in zip(results, dirs): + output += f'{cur_dir}\n' + output += result.to_csv(sep='\t', index=None, header=False) + output += '\n' + + if args.output_file is None: + output_file = str('/tmp/' + f'res_{str(uuid.uuid4())[:4]}.tsv') + else: + if args.output_file[-4:] != '.tsv': + raise ValueError('--output_file should end with .tsv') + output_file = args.output_file + with open(output_file, "w") as write_file: + write_file.write(output) + print('Saved results to ' + output_file) + From 062253b01acf10e301df07d08badf668a458eb90 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:26 -0700 Subject: [PATCH 132/197] Log parameter norm, so we can compute gradient normalized by parameter norm metrics. --- unlabeled_extrapolation/baseline_train.py | 40 ++++++++++++++--------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 516bdf5..fbc3bc5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -264,20 +264,23 @@ def set_requires_grad(component, val): _normalized_grad_layer_name = 'train/normalized_grad_layer_' -def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): +def add_layer_grad_stats(net, loss_dict, config): if getattr(net, 'get_layers', None) is None or 'no_log_grads' in config: return layers = net.get_layers() for i in range(len(layers)): + # Add norm of the weights. if len(layers[i]) == 1: # In the older version of model code, we just return a list of layers without names. - layer_name = 'train/grad_layer_' + str(i) - normalized_layer_name = 'train/normalized_grad_layer_' + str(i) + layer_name = 'train/grad_' + str(i) + normalized_layer_name = 'train/param_normalized_grad_' + str(i) + norm_name = 'train/norm_' + str(i) cur_layer = list(layers[i].parameters()) else: # In newer version of model code, we have a (name, layer) tuple. layer_name = 'train/grad_' + layers[i][0] - normalized_layer_name = 'train/normalized_grad_' + layers[i][0] + normalized_layer_name = 'train/param_normalized_grad_' + layers[i][0] + norm_name = 'train/norm_' + layers[i][0] cur_layer = list(layers[i][1].parameters()) if len(cur_layer) == 0 or not cur_layer[0].requires_grad: continue @@ -285,10 +288,16 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): loss_dict[layer_name] = Accumulator() if normalized_layer_name not in loss_dict: loss_dict[normalized_layer_name] = Accumulator() + if norm_name not in loss_dict: + loss_dict[norm_name] = Accumulator() grads = [p.grad.detach().cpu().numpy() for p in cur_layer] grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] - grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size + # Don't divide by batch size, because the loss is already the mean over the batch. + grad_norm = np.sqrt(np.sum(grad_norms_squared)) loss_dict[layer_name].add_value(grad_norm) + norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer] + norm = np.sqrt(np.sum(norms_squared)) + loss_dict[norm_name].add_value(norm) num_params = np.sum([p.numel() for p in cur_layer]) if num_params == 0: assert np.isclose(grad_norm, 0.0) @@ -367,20 +376,19 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) - if not check_exists_value(config, 'no_train', True): - opt_loss.backward() + opt_loss.backward() assert len(opt_loss.shape) == 0 loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) del opt_loss else: - if not check_exists_value(config, 'no_train', True): - loss.backward() + loss.backward() del inputs, labels, loss # Collect the gradients at each layer. - add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) + add_layer_grad_stats(net, loss_dict, config) if check_exists_not_none(config, 'max_grad_norm'): torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) - optimizer.step() + if not check_exists_value(config, 'no_train', True): + optimizer.step() if batch_scheduler is not None: batch_scheduler.step() num_examples += len(all_labels) @@ -389,9 +397,10 @@ def should_log(log_interval): return num_examples // log_interval > (num_examples - len(all_labels)) // log_interval if should_log(config['log_interval']): for k in loss_dict: - logging.info( - '[%d, %5d] %s: %.3f' % - (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + if 'grad' not in k and 'norm' not in k: + logging.info( + '[%d, %5d] %s: %.3f' % + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) # Sometimes we want to log the test loss more often to track things better. if 'test_interval' in config and should_log(config['test_interval']): stats = get_all_test_stats( @@ -716,7 +725,8 @@ def set_random_seed(seed): def update_optimizer_args(config): if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop']: + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb']: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. From 75a7a76a21900325ab7c539548bda4dd8620c303 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:26 -0700 Subject: [PATCH 133/197] Log parameter norm, so we can compute gradient normalized by parameter norm metrics. --- unlabeled_extrapolation/baseline_train.py | 40 ++++++++++++++--------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 516bdf5..fbc3bc5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -264,20 +264,23 @@ def set_requires_grad(component, val): _normalized_grad_layer_name = 'train/normalized_grad_layer_' -def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): +def add_layer_grad_stats(net, loss_dict, config): if getattr(net, 'get_layers', None) is None or 'no_log_grads' in config: return layers = net.get_layers() for i in range(len(layers)): + # Add norm of the weights. if len(layers[i]) == 1: # In the older version of model code, we just return a list of layers without names. - layer_name = 'train/grad_layer_' + str(i) - normalized_layer_name = 'train/normalized_grad_layer_' + str(i) + layer_name = 'train/grad_' + str(i) + normalized_layer_name = 'train/param_normalized_grad_' + str(i) + norm_name = 'train/norm_' + str(i) cur_layer = list(layers[i].parameters()) else: # In newer version of model code, we have a (name, layer) tuple. layer_name = 'train/grad_' + layers[i][0] - normalized_layer_name = 'train/normalized_grad_' + layers[i][0] + normalized_layer_name = 'train/param_normalized_grad_' + layers[i][0] + norm_name = 'train/norm_' + layers[i][0] cur_layer = list(layers[i][1].parameters()) if len(cur_layer) == 0 or not cur_layer[0].requires_grad: continue @@ -285,10 +288,16 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): loss_dict[layer_name] = Accumulator() if normalized_layer_name not in loss_dict: loss_dict[normalized_layer_name] = Accumulator() + if norm_name not in loss_dict: + loss_dict[norm_name] = Accumulator() grads = [p.grad.detach().cpu().numpy() for p in cur_layer] grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] - grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size + # Don't divide by batch size, because the loss is already the mean over the batch. + grad_norm = np.sqrt(np.sum(grad_norms_squared)) loss_dict[layer_name].add_value(grad_norm) + norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer] + norm = np.sqrt(np.sum(norms_squared)) + loss_dict[norm_name].add_value(norm) num_params = np.sum([p.numel() for p in cur_layer]) if num_params == 0: assert np.isclose(grad_norm, 0.0) @@ -367,20 +376,19 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) - if not check_exists_value(config, 'no_train', True): - opt_loss.backward() + opt_loss.backward() assert len(opt_loss.shape) == 0 loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) del opt_loss else: - if not check_exists_value(config, 'no_train', True): - loss.backward() + loss.backward() del inputs, labels, loss # Collect the gradients at each layer. - add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) + add_layer_grad_stats(net, loss_dict, config) if check_exists_not_none(config, 'max_grad_norm'): torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) - optimizer.step() + if not check_exists_value(config, 'no_train', True): + optimizer.step() if batch_scheduler is not None: batch_scheduler.step() num_examples += len(all_labels) @@ -389,9 +397,10 @@ def should_log(log_interval): return num_examples // log_interval > (num_examples - len(all_labels)) // log_interval if should_log(config['log_interval']): for k in loss_dict: - logging.info( - '[%d, %5d] %s: %.3f' % - (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + if 'grad' not in k and 'norm' not in k: + logging.info( + '[%d, %5d] %s: %.3f' % + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) # Sometimes we want to log the test loss more often to track things better. if 'test_interval' in config and should_log(config['test_interval']): stats = get_all_test_stats( @@ -716,7 +725,8 @@ def set_random_seed(seed): def update_optimizer_args(config): if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop']: + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb']: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. From ae0925613d450a31d68e55c449602368cb577685 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Mon, 12 Sep 2022 22:31:26 -0700 Subject: [PATCH 134/197] Log parameter norm, so we can compute gradient normalized by parameter norm metrics. --- unlabeled_extrapolation/baseline_train.py | 40 ++++++++++++++--------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 516bdf5..fbc3bc5 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -264,20 +264,23 @@ def set_requires_grad(component, val): _normalized_grad_layer_name = 'train/normalized_grad_layer_' -def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): +def add_layer_grad_stats(net, loss_dict, config): if getattr(net, 'get_layers', None) is None or 'no_log_grads' in config: return layers = net.get_layers() for i in range(len(layers)): + # Add norm of the weights. if len(layers[i]) == 1: # In the older version of model code, we just return a list of layers without names. - layer_name = 'train/grad_layer_' + str(i) - normalized_layer_name = 'train/normalized_grad_layer_' + str(i) + layer_name = 'train/grad_' + str(i) + normalized_layer_name = 'train/param_normalized_grad_' + str(i) + norm_name = 'train/norm_' + str(i) cur_layer = list(layers[i].parameters()) else: # In newer version of model code, we have a (name, layer) tuple. layer_name = 'train/grad_' + layers[i][0] - normalized_layer_name = 'train/normalized_grad_' + layers[i][0] + normalized_layer_name = 'train/param_normalized_grad_' + layers[i][0] + norm_name = 'train/norm_' + layers[i][0] cur_layer = list(layers[i][1].parameters()) if len(cur_layer) == 0 or not cur_layer[0].requires_grad: continue @@ -285,10 +288,16 @@ def add_layer_grad_stats(net, loss_dict, config, cur_batch_size): loss_dict[layer_name] = Accumulator() if normalized_layer_name not in loss_dict: loss_dict[normalized_layer_name] = Accumulator() + if norm_name not in loss_dict: + loss_dict[norm_name] = Accumulator() grads = [p.grad.detach().cpu().numpy() for p in cur_layer] grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads] - grad_norm = np.sqrt(np.sum(grad_norms_squared)) / cur_batch_size + # Don't divide by batch size, because the loss is already the mean over the batch. + grad_norm = np.sqrt(np.sum(grad_norms_squared)) loss_dict[layer_name].add_value(grad_norm) + norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer] + norm = np.sqrt(np.sum(norms_squared)) + loss_dict[norm_name].add_value(norm) num_params = np.sum([p.numel() for p in cur_layer]) if num_params == 0: assert np.isclose(grad_norm, 0.0) @@ -367,20 +376,19 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ loss_dict['train/acc'].add_values((train_preds == labels).tolist()) if 'model_loss' in config: opt_loss = model_loss(net, inputs, labels) - if not check_exists_value(config, 'no_train', True): - opt_loss.backward() + opt_loss.backward() assert len(opt_loss.shape) == 0 loss_dict['train/model_loss'].add_value(float(opt_loss.detach().cpu())) del opt_loss else: - if not check_exists_value(config, 'no_train', True): - loss.backward() + loss.backward() del inputs, labels, loss # Collect the gradients at each layer. - add_layer_grad_stats(net, loss_dict, config, cur_batch_size=len(all_labels)) + add_layer_grad_stats(net, loss_dict, config) if check_exists_not_none(config, 'max_grad_norm'): torch.nn.utils.clip_grad_norm_(net.parameters(), config['max_grad_norm']) - optimizer.step() + if not check_exists_value(config, 'no_train', True): + optimizer.step() if batch_scheduler is not None: batch_scheduler.step() num_examples += len(all_labels) @@ -389,9 +397,10 @@ def should_log(log_interval): return num_examples // log_interval > (num_examples - len(all_labels)) // log_interval if should_log(config['log_interval']): for k in loss_dict: - logging.info( - '[%d, %5d] %s: %.3f' % - (epoch + 1, num_examples, k, loss_dict[k].get_mean())) + if 'grad' not in k and 'norm' not in k: + logging.info( + '[%d, %5d] %s: %.3f' % + (epoch + 1, num_examples, k, loss_dict[k].get_mean())) # Sometimes we want to log the test loss more often to track things better. if 'test_interval' in config and should_log(config['test_interval']): stats = get_all_test_stats( @@ -716,7 +725,8 @@ def set_random_seed(seed): def update_optimizer_args(config): if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop']: + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb']: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. From f23b88a05812203234331835555928c5b372ceef Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 14:24:58 -0700 Subject: [PATCH 135/197] Add more wilds support --- .../adaptation/datasets_fmow_all_nonorm.yaml | 54 +++++++++++++++++ .../datasets_fmow_all_nonorm_weakaugs.yaml | 51 ++++++++++++++++ configs/adaptation/fmow_all_nonorm.yaml | 19 ++++++ .../adaptation/fmow_all_nonorm_weakaugs.yaml | 19 ++++++ ...s.ipynb => fmow_waterbirds_examples.ipynb} | 49 +++++++++++++++- scripts/run_adaptation_experiments.py | 58 ++++++++++++++++--- scripts/run_sphinx_sbatch.sh | 3 +- 7 files changed, 240 insertions(+), 13 deletions(-) create mode 100644 configs/adaptation/datasets_fmow_all_nonorm.yaml create mode 100644 configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs.yaml rename scripts/{waterbirds_examples.ipynb => fmow_waterbirds_examples.ipynb} (99%) diff --git a/configs/adaptation/datasets_fmow_all_nonorm.yaml b/configs/adaptation/datasets_fmow_all_nonorm.yaml new file mode 100644 index 0000000..c3627fd --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm.yaml @@ -0,0 +1,54 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..1c053b6 --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,51 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml new file mode 100644 index 0000000..f47dcd6 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..ba1c101 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm_weakaugs.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/waterbirds_examples.ipynb b/scripts/fmow_waterbirds_examples.ipynb similarity index 99% rename from scripts/waterbirds_examples.ipynb rename to scripts/fmow_waterbirds_examples.ipynb index 9f08e33..86576a2 100644 --- a/scripts/waterbirds_examples.ipynb +++ b/scripts/fmow_waterbirds_examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 57, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 57, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,11 +22,56 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from collections import defaultdict, Counter\n", + "from wilds import get_dataset\n", "\n", "import importlib\n", "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FMoW" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'\n", + "super_dataset = get_dataset(dataset='fmow', download=False, root_dir=root)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "super_dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Waterbirds" + ] + }, { "cell_type": "code", "execution_count": 35, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 3df2523..cc55661 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -881,7 +881,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -896,9 +896,39 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') +fmow_all_nonorm = Dataset( + name='fmow_all_nonorm', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') + +fmow_all_nonorm_weakaugs = Dataset( + name='fmow_all_nonorm_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -941,6 +971,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'domainnet': domainnet, 'fmow': fmow, 'fmow_all': fmow_all, + 'fmow_all_nonorm': fmow_all_nonorm, + 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1611,9 +1643,16 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ## Functions to spray dataset on jags. ############################################ -def spray_dataset_jags(copy_cmd): - for i in range(10, 32): - cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ +def spray_dataset(copy_cmd): + # for i in range(10, 32): + # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + # f'scripts/run_sbatch.sh "{copy_cmd}"' + # if args.print_command: + # print(cmd) + # else: + # subprocess.run(cmd, shell=True) + for i in range(1,9): + cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: print(cmd) @@ -1621,23 +1660,24 @@ def spray_dataset_jags(copy_cmd): subprocess.run(cmd, shell=True) + def spray_celeba_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/ananya/celeba.tar.gz') def spray_fmow_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/nlp/wilds/data/fmow_v1.1.tar.gz wilds/data') def spray_imagenet_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_dataset.sh imagenet') def spray_wilds_jags(args): - spray_dataset_jags( + spray_dataset( f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' f'--datasets {" ".join(args.datasets)}') diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 101a759..4257aef 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,11 +4,10 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH -t 2-0:00 # Print execute commands in the log. set -x -conda_env=`whoami`-ue +conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh From 87201c516ce4b97406b9b8ed0abbc645b6ce00d1 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 14:24:58 -0700 Subject: [PATCH 136/197] Add more wilds support --- .../adaptation/datasets_fmow_all_nonorm.yaml | 54 +++++++++++++++++ .../datasets_fmow_all_nonorm_weakaugs.yaml | 51 ++++++++++++++++ configs/adaptation/fmow_all_nonorm.yaml | 19 ++++++ .../adaptation/fmow_all_nonorm_weakaugs.yaml | 19 ++++++ ...s.ipynb => fmow_waterbirds_examples.ipynb} | 49 +++++++++++++++- scripts/run_adaptation_experiments.py | 58 ++++++++++++++++--- scripts/run_sphinx_sbatch.sh | 3 +- 7 files changed, 240 insertions(+), 13 deletions(-) create mode 100644 configs/adaptation/datasets_fmow_all_nonorm.yaml create mode 100644 configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs.yaml rename scripts/{waterbirds_examples.ipynb => fmow_waterbirds_examples.ipynb} (99%) diff --git a/configs/adaptation/datasets_fmow_all_nonorm.yaml b/configs/adaptation/datasets_fmow_all_nonorm.yaml new file mode 100644 index 0000000..c3627fd --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm.yaml @@ -0,0 +1,54 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..1c053b6 --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,51 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml new file mode 100644 index 0000000..f47dcd6 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..ba1c101 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm_weakaugs.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/waterbirds_examples.ipynb b/scripts/fmow_waterbirds_examples.ipynb similarity index 99% rename from scripts/waterbirds_examples.ipynb rename to scripts/fmow_waterbirds_examples.ipynb index 9f08e33..86576a2 100644 --- a/scripts/waterbirds_examples.ipynb +++ b/scripts/fmow_waterbirds_examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 57, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 57, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,11 +22,56 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from collections import defaultdict, Counter\n", + "from wilds import get_dataset\n", "\n", "import importlib\n", "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FMoW" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'\n", + "super_dataset = get_dataset(dataset='fmow', download=False, root_dir=root)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "super_dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Waterbirds" + ] + }, { "cell_type": "code", "execution_count": 35, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 3df2523..cc55661 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -881,7 +881,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -896,9 +896,39 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') +fmow_all_nonorm = Dataset( + name='fmow_all_nonorm', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') + +fmow_all_nonorm_weakaugs = Dataset( + name='fmow_all_nonorm_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -941,6 +971,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'domainnet': domainnet, 'fmow': fmow, 'fmow_all': fmow_all, + 'fmow_all_nonorm': fmow_all_nonorm, + 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1611,9 +1643,16 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ## Functions to spray dataset on jags. ############################################ -def spray_dataset_jags(copy_cmd): - for i in range(10, 32): - cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ +def spray_dataset(copy_cmd): + # for i in range(10, 32): + # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + # f'scripts/run_sbatch.sh "{copy_cmd}"' + # if args.print_command: + # print(cmd) + # else: + # subprocess.run(cmd, shell=True) + for i in range(1,9): + cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: print(cmd) @@ -1621,23 +1660,24 @@ def spray_dataset_jags(copy_cmd): subprocess.run(cmd, shell=True) + def spray_celeba_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/ananya/celeba.tar.gz') def spray_fmow_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/nlp/wilds/data/fmow_v1.1.tar.gz wilds/data') def spray_imagenet_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_dataset.sh imagenet') def spray_wilds_jags(args): - spray_dataset_jags( + spray_dataset( f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' f'--datasets {" ".join(args.datasets)}') diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 101a759..4257aef 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,11 +4,10 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH -t 2-0:00 # Print execute commands in the log. set -x -conda_env=`whoami`-ue +conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh From 2f833dbaa94edd0e3fd69e3aeee11bb63d30a98b Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 14:24:58 -0700 Subject: [PATCH 137/197] Add more wilds support --- .../adaptation/datasets_fmow_all_nonorm.yaml | 54 +++++++++++++++++ .../datasets_fmow_all_nonorm_weakaugs.yaml | 51 ++++++++++++++++ configs/adaptation/fmow_all_nonorm.yaml | 19 ++++++ .../adaptation/fmow_all_nonorm_weakaugs.yaml | 19 ++++++ ...s.ipynb => fmow_waterbirds_examples.ipynb} | 49 +++++++++++++++- scripts/run_adaptation_experiments.py | 58 ++++++++++++++++--- scripts/run_sphinx_sbatch.sh | 3 +- 7 files changed, 240 insertions(+), 13 deletions(-) create mode 100644 configs/adaptation/datasets_fmow_all_nonorm.yaml create mode 100644 configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs.yaml rename scripts/{waterbirds_examples.ipynb => fmow_waterbirds_examples.ipynb} (99%) diff --git a/configs/adaptation/datasets_fmow_all_nonorm.yaml b/configs/adaptation/datasets_fmow_all_nonorm.yaml new file mode 100644 index 0000000..c3627fd --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm.yaml @@ -0,0 +1,54 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomResizedCrop + args: + size: 224 + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..1c053b6 --- /dev/null +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,51 @@ + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml new file mode 100644 index 0000000..f47dcd6 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml new file mode 100644 index 0000000..ba1c101 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_fmow_all_nonorm_weakaugs.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/scripts/waterbirds_examples.ipynb b/scripts/fmow_waterbirds_examples.ipynb similarity index 99% rename from scripts/waterbirds_examples.ipynb rename to scripts/fmow_waterbirds_examples.ipynb index 9f08e33..86576a2 100644 --- a/scripts/waterbirds_examples.ipynb +++ b/scripts/fmow_waterbirds_examples.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 57, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 57, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -22,11 +22,56 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from collections import defaultdict, Counter\n", + "from wilds import get_dataset\n", "\n", "import importlib\n", "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FMoW" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'\n", + "super_dataset = get_dataset(dataset='fmow', download=False, root_dir=root)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "super_dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Waterbirds" + ] + }, { "cell_type": "code", "execution_count": 35, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 3df2523..cc55661 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -881,7 +881,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -896,9 +896,39 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') +fmow_all_nonorm = Dataset( + name='fmow_all_nonorm', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') + +fmow_all_nonorm_weakaugs = Dataset( + name='fmow_all_nonorm_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -941,6 +971,8 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'domainnet': domainnet, 'fmow': fmow, 'fmow_all': fmow_all, + 'fmow_all_nonorm': fmow_all_nonorm, + 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1611,9 +1643,16 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ## Functions to spray dataset on jags. ############################################ -def spray_dataset_jags(copy_cmd): - for i in range(10, 32): - cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ +def spray_dataset(copy_cmd): + # for i in range(10, 32): + # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + # f'scripts/run_sbatch.sh "{copy_cmd}"' + # if args.print_command: + # print(cmd) + # else: + # subprocess.run(cmd, shell=True) + for i in range(1,9): + cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: print(cmd) @@ -1621,23 +1660,24 @@ def spray_dataset_jags(copy_cmd): subprocess.run(cmd, shell=True) + def spray_celeba_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/ananya/celeba.tar.gz') def spray_fmow_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_local.sh /u/scr/nlp/wilds/data/fmow_v1.1.tar.gz wilds/data') def spray_imagenet_jags(args): - spray_dataset_jags( + spray_dataset( f'source {args.scripts_dir}/copy_dataset.sh imagenet') def spray_wilds_jags(args): - spray_dataset_jags( + spray_dataset( f'python {args.scripts_dir}/download_wilds_datasets.py --root_dir /scr/biggest/ue_datasets/wilds/data/ ' f'--datasets {" ".join(args.datasets)}') diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 101a759..4257aef 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,11 +4,10 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH -t 2-0:00 # Print execute commands in the log. set -x -conda_env=`whoami`-ue +conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh From b07ff7488615bcaa2214c5962e96cd73cddab4ca Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 16:27:10 -0700 Subject: [PATCH 138/197] Add layer wise tuning. --- unlabeled_extrapolation/baseline_train.py | 37 ++++++++++++++++++-- unlabeled_extrapolation/models/clip_model.py | 4 +-- unlabeled_extrapolation/utils/schedulers.py | 23 ++++++++++++ 3 files changed, 60 insertions(+), 4 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index fbc3bc5..13b2bb9 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -25,6 +25,7 @@ from unlabeled_extrapolation.models import resnet from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils +import unlabeled_extrapolation.utils.schedulers as schedulers from timm.data.mixup import Mixup log_level = logging.INFO @@ -494,7 +495,15 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None - if check_exists_not_none(config, 'batch_scheduler'): + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + elif check_exists_value(config, 'layer-wise-tune-cosine', True): + logging.info('Layer-wise tuning with cosine decay.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) num_training_steps = num_batches * config['epochs'] @@ -510,6 +519,7 @@ def main(config, log_dir, checkpoints_dir): 'num_training_steps': num_training_steps, }) else: + # TODO: does this update number of epochs? scheduler = utils.initialize( config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. @@ -533,7 +543,30 @@ def main(config, log_dir, checkpoints_dir): if 'l2sp_weight' in config: weight_dict_initial, _ = get_param_weights_counts(net, detach=True) - for epoch in range(config['epochs']): + num_epochs = config['epochs'] + for epoch in range(num_epochs): + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + # Get number of transformer layers. + num_layers = len(net.get_layers()) + num_trans_layers = (num_layers - 6) / 4 + # Get number of transformer layers to freeze. + num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + if num_trans_tune > num_trans_layers: + num_trans_tune = num_trans_layers + num_trans_freeze = num_epochs - num_trans_tune + # COnvert to number of layers to freeze. + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(net, True) + # Call freeze. + net.freeze_bottom_k(num_layers_freeze) + # Print statistics about number of parameters tuning, layers frozen, etc. + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 0bd894f..14c3238 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -131,10 +131,10 @@ def get_layers(self): ('layer2', visual.layer2), ('layer3', visual.layer3), ('attnpool', visual.attnpool)] + if self._classifier is not None: + layers = layers + [('head', self._classifier)] else: raise NotImplementedError - if self._classifier is not None: - layers = layers + [('head', self._classifier)] return layers def tune_bottom_k(self, k): diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e31d09b..18d8832 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -1,6 +1,7 @@ from torch.optim.lr_scheduler import LambdaLR import math +import numpy as np # Code adapter from Hugging Face transformers implementation. @@ -18,3 +19,25 @@ def lr_lambda(self, current_step): progress = float(current_step - self.num_warmup_steps) / float(max(1, self.num_training_steps - self.num_warmup_steps)) return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + +class LayerWiseSchedule(LambdaLR): + """Linear warm up and then cosine annealing of the learning rate.""" + def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + self.num_epochs = num_epochs + self.num_cycles = num_cycles + self.cosine = cosine + super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) + + def lr_lambda(self, current_epoch): + progress = float(current_epoch) / float(max(1, self.num_epochs)) + # num_layers_tuning = int(progress * (num_layers + 1)) + # assert num_layers_tuning >= 0 + # if num_layers_tuning > num_layers: + # num_layers_tuning = num_layers + lr_multiplier = np.exp(3.73 * (1.0 - progress)) + if self.cosine: + lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + return lr_multiplier + + + From d5944735e8921cb2df1ed0d1a16e685ea0ba78ce Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 16:27:10 -0700 Subject: [PATCH 139/197] Add layer wise tuning. --- unlabeled_extrapolation/baseline_train.py | 37 ++++++++++++++++++-- unlabeled_extrapolation/models/clip_model.py | 4 +-- unlabeled_extrapolation/utils/schedulers.py | 23 ++++++++++++ 3 files changed, 60 insertions(+), 4 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index fbc3bc5..13b2bb9 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -25,6 +25,7 @@ from unlabeled_extrapolation.models import resnet from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils +import unlabeled_extrapolation.utils.schedulers as schedulers from timm.data.mixup import Mixup log_level = logging.INFO @@ -494,7 +495,15 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None - if check_exists_not_none(config, 'batch_scheduler'): + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + elif check_exists_value(config, 'layer-wise-tune-cosine', True): + logging.info('Layer-wise tuning with cosine decay.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) num_training_steps = num_batches * config['epochs'] @@ -510,6 +519,7 @@ def main(config, log_dir, checkpoints_dir): 'num_training_steps': num_training_steps, }) else: + # TODO: does this update number of epochs? scheduler = utils.initialize( config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. @@ -533,7 +543,30 @@ def main(config, log_dir, checkpoints_dir): if 'l2sp_weight' in config: weight_dict_initial, _ = get_param_weights_counts(net, detach=True) - for epoch in range(config['epochs']): + num_epochs = config['epochs'] + for epoch in range(num_epochs): + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + # Get number of transformer layers. + num_layers = len(net.get_layers()) + num_trans_layers = (num_layers - 6) / 4 + # Get number of transformer layers to freeze. + num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + if num_trans_tune > num_trans_layers: + num_trans_tune = num_trans_layers + num_trans_freeze = num_epochs - num_trans_tune + # COnvert to number of layers to freeze. + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(net, True) + # Call freeze. + net.freeze_bottom_k(num_layers_freeze) + # Print statistics about number of parameters tuning, layers frozen, etc. + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 0bd894f..14c3238 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -131,10 +131,10 @@ def get_layers(self): ('layer2', visual.layer2), ('layer3', visual.layer3), ('attnpool', visual.attnpool)] + if self._classifier is not None: + layers = layers + [('head', self._classifier)] else: raise NotImplementedError - if self._classifier is not None: - layers = layers + [('head', self._classifier)] return layers def tune_bottom_k(self, k): diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e31d09b..18d8832 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -1,6 +1,7 @@ from torch.optim.lr_scheduler import LambdaLR import math +import numpy as np # Code adapter from Hugging Face transformers implementation. @@ -18,3 +19,25 @@ def lr_lambda(self, current_step): progress = float(current_step - self.num_warmup_steps) / float(max(1, self.num_training_steps - self.num_warmup_steps)) return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + +class LayerWiseSchedule(LambdaLR): + """Linear warm up and then cosine annealing of the learning rate.""" + def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + self.num_epochs = num_epochs + self.num_cycles = num_cycles + self.cosine = cosine + super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) + + def lr_lambda(self, current_epoch): + progress = float(current_epoch) / float(max(1, self.num_epochs)) + # num_layers_tuning = int(progress * (num_layers + 1)) + # assert num_layers_tuning >= 0 + # if num_layers_tuning > num_layers: + # num_layers_tuning = num_layers + lr_multiplier = np.exp(3.73 * (1.0 - progress)) + if self.cosine: + lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + return lr_multiplier + + + From 72c60d6685a198c2113743ccabd2bc43612b8b00 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 15 Sep 2022 16:27:10 -0700 Subject: [PATCH 140/197] Add layer wise tuning. --- unlabeled_extrapolation/baseline_train.py | 37 ++++++++++++++++++-- unlabeled_extrapolation/models/clip_model.py | 4 +-- unlabeled_extrapolation/utils/schedulers.py | 23 ++++++++++++ 3 files changed, 60 insertions(+), 4 deletions(-) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index fbc3bc5..13b2bb9 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -25,6 +25,7 @@ from unlabeled_extrapolation.models import resnet from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils +import unlabeled_extrapolation.utils.schedulers as schedulers from timm.data.mixup import Mixup log_level = logging.INFO @@ -494,7 +495,15 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None - if check_exists_not_none(config, 'batch_scheduler'): + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + elif check_exists_value(config, 'layer-wise-tune-cosine', True): + logging.info('Layer-wise tuning with cosine decay.') + num_epochs = config['epochs'] + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) num_training_steps = num_batches * config['epochs'] @@ -510,6 +519,7 @@ def main(config, log_dir, checkpoints_dir): 'num_training_steps': num_training_steps, }) else: + # TODO: does this update number of epochs? scheduler = utils.initialize( config['scheduler'], update_args={'optimizer': optimizer}) # Training loop. @@ -533,7 +543,30 @@ def main(config, log_dir, checkpoints_dir): if 'l2sp_weight' in config: weight_dict_initial, _ = get_param_weights_counts(net, detach=True) - for epoch in range(config['epochs']): + num_epochs = config['epochs'] + for epoch in range(num_epochs): + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + # Get number of transformer layers. + num_layers = len(net.get_layers()) + num_trans_layers = (num_layers - 6) / 4 + # Get number of transformer layers to freeze. + num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + if num_trans_tune > num_trans_layers: + num_trans_tune = num_trans_layers + num_trans_freeze = num_epochs - num_trans_tune + # COnvert to number of layers to freeze. + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(net, True) + # Call freeze. + net.freeze_bottom_k(num_layers_freeze) + # Print statistics about number of parameters tuning, layers frozen, etc. + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 0bd894f..14c3238 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -131,10 +131,10 @@ def get_layers(self): ('layer2', visual.layer2), ('layer3', visual.layer3), ('attnpool', visual.attnpool)] + if self._classifier is not None: + layers = layers + [('head', self._classifier)] else: raise NotImplementedError - if self._classifier is not None: - layers = layers + [('head', self._classifier)] return layers def tune_bottom_k(self, k): diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e31d09b..18d8832 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -1,6 +1,7 @@ from torch.optim.lr_scheduler import LambdaLR import math +import numpy as np # Code adapter from Hugging Face transformers implementation. @@ -18,3 +19,25 @@ def lr_lambda(self, current_step): progress = float(current_step - self.num_warmup_steps) / float(max(1, self.num_training_steps - self.num_warmup_steps)) return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + +class LayerWiseSchedule(LambdaLR): + """Linear warm up and then cosine annealing of the learning rate.""" + def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + self.num_epochs = num_epochs + self.num_cycles = num_cycles + self.cosine = cosine + super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) + + def lr_lambda(self, current_epoch): + progress = float(current_epoch) / float(max(1, self.num_epochs)) + # num_layers_tuning = int(progress * (num_layers + 1)) + # assert num_layers_tuning >= 0 + # if num_layers_tuning > num_layers: + # num_layers_tuning = num_layers + lr_multiplier = np.exp(3.73 * (1.0 - progress)) + if self.cosine: + lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) + return lr_multiplier + + + From bbd330665c7d354467a3d2a3221f696433447ece Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 20 Sep 2022 18:16:58 -0700 Subject: [PATCH 141/197] Layerwise tuning --- configs/adaptation/camelyon17_weakaugs.yaml | 19 +++ .../camelyon17_weakaugs_highres.yaml | 66 +++++++++ .../datasets_camelyon17_weakaugs.yaml | 46 ++++++ configs/adaptation/fmow_all_nonorm.yaml | 2 +- .../fmow_all_nonorm_weakaugs_highres.yaml | 77 ++++++++++ scripts/copy_dataset.sh | 4 +- scripts/fine-tuning-results.ipynb | 126 ++++++++++++++--- scripts/run_adaptation_experiments.py | 131 ++++++++++++++++-- scripts/run_sphinx_sbatch.sh | 1 + scripts/summarize_results.py | 2 +- unlabeled_extrapolation/baseline_train.py | 71 +++++++--- unlabeled_extrapolation/utils/schedulers.py | 8 +- 12 files changed, 499 insertions(+), 54 deletions(-) create mode 100644 configs/adaptation/camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/camelyon17_weakaugs_highres.yaml create mode 100644 configs/adaptation/datasets_camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml diff --git a/configs/adaptation/camelyon17_weakaugs.yaml b/configs/adaptation/camelyon17_weakaugs.yaml new file mode 100644 index 0000000..890e273 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_camelyon17_weakaugs.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/camelyon17_weakaugs_highres.yaml b/configs/adaptation/camelyon17_weakaugs_highres.yaml new file mode 100644 index 0000000..ec9ef91 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs_highres.yaml @@ -0,0 +1,66 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_camelyon17_weakaugs.yaml b/configs/adaptation/datasets_camelyon17_weakaugs.yaml new file mode 100644 index 0000000..47dc593 --- /dev/null +++ b/configs/adaptation/datasets_camelyon17_weakaugs.yaml @@ -0,0 +1,46 @@ + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml index f47dcd6..2a815a4 100644 --- a/configs/adaptation/fmow_all_nonorm.yaml +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -4,7 +4,7 @@ inherit: - datasets_fmow_all_nonorm.yaml num_classes: 62 -epochs: &epochs 5 +epochs: &epochs 20 batch_size: 32 batch_splits: 2 save_no_checkpoints: True diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml new file mode 100644 index 0000000..0bb0fd2 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml @@ -0,0 +1,77 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/scripts/copy_dataset.sh b/scripts/copy_dataset.sh index 6141572..bef4daa 100755 --- a/scripts/copy_dataset.sh +++ b/scripts/copy_dataset.sh @@ -105,7 +105,7 @@ ACL_STRING=${ACL_STRING: : -1} # Remove trailing comma if [ ! -d "$dst_folder" ]; then mkdir -p $dst_folder mkdir -p $dst_folder/tmp - setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder + # setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder fi a1=$RANDOM @@ -129,7 +129,7 @@ elif [ "$dataset_name" = domainnet ]; then echo "Copying DomainNet files to $dst_folder" cp $dataset_src $dst_folder unzip -q $dst_folder/domainnet.zip -d $dst_folder - setfacl -Rm $ACL_STRING $dst_folder + # setfacl -Rm $ACL_STRING $dst_folder fi fi diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb index bec93f7..17fe75a 100644 --- a/scripts/fine-tuning-results.ipynb +++ b/scripts/fine-tuning-results.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -94,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -102,20 +102,38 @@ "output_type": "stream", "text": [ "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", - "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 2 is out of bounds for axis 0 with size 2", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", + "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" ] } ], @@ -199,7 +217,6 @@ "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", @@ -228,6 +245,77 @@ "best_row_mean.to_numpy()[:,:-2]" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" + ] + } + ], + "source": [ + "# CLIP results including all optimizers and and layerwise method.\n", + "models = ['clip_vit_b16']\n", + "# \n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" + ] + } + ], + "source": [ + "# CLIP results including wilds datasets\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index cc55661..c31d57f 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -929,6 +929,51 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') +fmow_all_nonorm_weakaugs_highres = Dataset( + name='fmow_all_nonorm_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') + +camelyon17_weakaugs = Dataset( + name='camelyon17_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_eval.yaml') + +camelyon17_weakaugs_highres = Dataset( + name='camelyon17_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs_highres.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_highres_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -973,6 +1018,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'fmow_all': fmow_all, 'fmow_all_nonorm': fmow_all_nonorm, 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, + 'fmow_all_nonorm_weakaugs_highres': fmow_all_nonorm_weakaugs_highres, + 'camelyon17_weakaugs': camelyon17_weakaugs, + 'camelyon17_weakaugs_highres': camelyon17_weakaugs_highres, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1087,6 +1135,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +clip_vit_l14_highres = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-L/14@336px', + }, + bundles=[] +) + scratch_vit_b16_clipstyle = Model( kwargs={ 'classname': 'models.clip_model.ClipModel', @@ -1202,6 +1258,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'deit_vit_b16': deit_vit_b16, 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, + 'clip_vit_l14_highres': clip_vit_l14_highres, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, 'convnext_vit_b': convnext_vit_b, @@ -1380,6 +1437,11 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if args.epochs is not None: adapt_name += '_epochs' + str(args.epochs) if args.optimizer is not None: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [1e-6, 3e-6, 1e-5] + else: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.no_replications or args.only_one_run: num_replications = 1 @@ -1390,6 +1452,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) @@ -1419,6 +1483,22 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.optimizer is not None: hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) @@ -1565,6 +1645,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] + if args.optimizer is not None: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 if args.no_train: @@ -1572,7 +1656,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) + else: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1586,6 +1673,22 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) @@ -1644,14 +1747,15 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset(copy_cmd): - # for i in range(10, 32): - # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ - # f'scripts/run_sbatch.sh "{copy_cmd}"' - # if args.print_command: - # print(cmd) - # else: - # subprocess.run(cmd, shell=True) - for i in range(1,9): + for i in range(10, 32): + cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + f'scripts/run_sbatch.sh "{copy_cmd}"' + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) + # Exclude sphinx3 which belongs to Chris Re. + for i in [5]: # [1,2] + list(range(4,9)): cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: @@ -1812,6 +1916,8 @@ def fill_platform_specific_default_args(args): help='Tune bottom k layers (if not specified, tune everything).') parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, help='At what epoch should we unfreeze all weights and fine-tune.') + parser.add_argument('--decay_exp', type=float, required=False, default=None, + help='Higher decay exp means the learning rates goes down faster.') parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) @@ -1819,6 +1925,13 @@ def fill_platform_specific_default_args(args): help='Don\'t run replication runs, only sweep.', required=False) parser.add_argument('--no_train', action='store_true', help='Don\'t train model, just collect stats.', required=False) + parser.add_argument('--layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--layer_wise_tune_cosine', action='store_true', + help='Gradually unfreeze layers, multiply by cosine lr', required=False) + parser.add_argument('--warmup_epochs', type=int, required=False, default=None, + help='Number of epochs to run linear probe for.') + args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) main(args) diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 4257aef..45365b3 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx +#SBATCH --exclude=sphinx[3,4,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index cc456b9..4816144 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -24,7 +24,7 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': - output_metrics += val_metric + output_metrics += [val_metric] # If needed, compute the worst among all the test_accs. # That is, if the user is selecting for this metric or wants it displayed. # I guess val_metric == 'WORST' is redundant given the previous line which will diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 13b2bb9..cea1ab1 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -30,6 +30,10 @@ log_level = logging.INFO +non_sgd_optimizer_names = [ + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb' +] def reset_state(model, training): if training: @@ -317,7 +321,6 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ net.eval() else: net.train() - logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), 'train/acc': Accumulator(), @@ -411,6 +414,10 @@ def should_log(log_interval): wandb.log(stats) reset_state(net, training_state) train_stats = {'epoch': epoch} + lr = 0.0 + for param_group in optimizer.param_groups: + lr = max(lr, param_group['lr']) + train_stats['lr'] = lr if batch_scheduler is not None: train_stats['train/batch_scheduler_lr'] = batch_scheduler.get_lr() for key in loss_dict: @@ -495,14 +502,24 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None + if check_exists_not_none(config, 'decay_exp'): + decay_exp = config['decay_exp'] + else: + decay_exp = 3.73 + if check_exists_not_none(config, 'warmup_epochs'): + warmup_epochs = config['warmup_epochs'] + else: + warmup_epochs = 0 if check_exists_value(config, 'layer-wise-tune', True): logging.info('Layer-wise tuning.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, + warmup_epochs=warmup_epochs, decay_exp=decay_exp) elif check_exists_value(config, 'layer-wise-tune-cosine', True): logging.info('Layer-wise tuning with cosine decay.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, + warmup_epochs=warmup_epochs, cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -544,29 +561,42 @@ def main(config, log_dir, checkpoints_dir): weight_dict_initial, _ = get_param_weights_counts(net, detach=True) num_epochs = config['epochs'] - for epoch in range(num_epochs): + for epoch in range(num_epochs): + logging.info("\nEpoch #{}".format(epoch)) if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. num_layers = len(net.get_layers()) - num_trans_layers = (num_layers - 6) / 4 + num_trans_layers = int((num_layers - 6) / 4) # Get number of transformer layers to freeze. - num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + effective_epoch = max(0, epoch - warmup_epochs) + effective_num_epochs = max(1, num_epochs - warmup_epochs) + if effective_num_epochs == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) if num_trans_tune > num_trans_layers: num_trans_tune = num_trans_layers - num_trans_freeze = num_epochs - num_trans_tune - # COnvert to number of layers to freeze. - num_layers_freeze = num_trans_freeze * 4 + 4 + num_trans_freeze = num_trans_layers - num_trans_tune + # Convert to number of layers to freeze. + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if config['optimizer']['classname'] in non_sgd_optimizer_names: + num_layers_freeze = 0 + else: + num_layers_freeze = 2 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 # Set all grads to True. set_requires_grad(net, True) # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? net.freeze_bottom_k(num_layers_freeze) # Print statistics about number of parameters tuning, layers frozen, etc. - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') - logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -580,14 +610,19 @@ def main(config, log_dir, checkpoints_dir): if "full_ft_epoch" in config and config["full_ft_epoch"] is not None: if epoch == config["full_ft_epoch"]: set_requires_grad(net, True) - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params - assert(num_trainable_params == num_params) - logging.info(f'Full FT {num_trainable_params} of {num_params} parameters.') + logging.info(f'Full FT.') + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + # Add number of layers frozen to train_stats. + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + train_stats['num_trans_freeze'] = num_trans_freeze + train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. if not check_exists_not_none(config, 'batch_scheduler'): @@ -757,9 +792,7 @@ def set_random_seed(seed): def update_optimizer_args(config): - if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', - 'torch_optimizer.lamb.Lamb']: + if config['optimizer']['classname'] in non_sgd_optimizer_names: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index 18d8832..e258707 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,19 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine + self.decay_exp = decay_exp + self.warmup_epochs = warmup_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(current_epoch) / float(max(1, self.num_epochs)) + progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: # num_layers_tuning = num_layers - lr_multiplier = np.exp(3.73 * (1.0 - progress)) + lr_multiplier = np.exp(self.decay_exp * (1.0 - progress)) if self.cosine: lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) return lr_multiplier From 9c00b9ad62882e23ac0e88bab5baa126a27377b4 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 20 Sep 2022 18:16:58 -0700 Subject: [PATCH 142/197] Layerwise tuning --- configs/adaptation/camelyon17_weakaugs.yaml | 19 +++ .../camelyon17_weakaugs_highres.yaml | 66 +++++++++ .../datasets_camelyon17_weakaugs.yaml | 46 ++++++ configs/adaptation/fmow_all_nonorm.yaml | 2 +- .../fmow_all_nonorm_weakaugs_highres.yaml | 77 ++++++++++ scripts/copy_dataset.sh | 4 +- scripts/fine-tuning-results.ipynb | 126 ++++++++++++++--- scripts/run_adaptation_experiments.py | 131 ++++++++++++++++-- scripts/run_sphinx_sbatch.sh | 1 + scripts/summarize_results.py | 2 +- unlabeled_extrapolation/baseline_train.py | 71 +++++++--- unlabeled_extrapolation/utils/schedulers.py | 8 +- 12 files changed, 499 insertions(+), 54 deletions(-) create mode 100644 configs/adaptation/camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/camelyon17_weakaugs_highres.yaml create mode 100644 configs/adaptation/datasets_camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml diff --git a/configs/adaptation/camelyon17_weakaugs.yaml b/configs/adaptation/camelyon17_weakaugs.yaml new file mode 100644 index 0000000..890e273 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_camelyon17_weakaugs.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/camelyon17_weakaugs_highres.yaml b/configs/adaptation/camelyon17_weakaugs_highres.yaml new file mode 100644 index 0000000..ec9ef91 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs_highres.yaml @@ -0,0 +1,66 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_camelyon17_weakaugs.yaml b/configs/adaptation/datasets_camelyon17_weakaugs.yaml new file mode 100644 index 0000000..47dc593 --- /dev/null +++ b/configs/adaptation/datasets_camelyon17_weakaugs.yaml @@ -0,0 +1,46 @@ + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml index f47dcd6..2a815a4 100644 --- a/configs/adaptation/fmow_all_nonorm.yaml +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -4,7 +4,7 @@ inherit: - datasets_fmow_all_nonorm.yaml num_classes: 62 -epochs: &epochs 5 +epochs: &epochs 20 batch_size: 32 batch_splits: 2 save_no_checkpoints: True diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml new file mode 100644 index 0000000..0bb0fd2 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml @@ -0,0 +1,77 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/scripts/copy_dataset.sh b/scripts/copy_dataset.sh index 6141572..bef4daa 100755 --- a/scripts/copy_dataset.sh +++ b/scripts/copy_dataset.sh @@ -105,7 +105,7 @@ ACL_STRING=${ACL_STRING: : -1} # Remove trailing comma if [ ! -d "$dst_folder" ]; then mkdir -p $dst_folder mkdir -p $dst_folder/tmp - setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder + # setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder fi a1=$RANDOM @@ -129,7 +129,7 @@ elif [ "$dataset_name" = domainnet ]; then echo "Copying DomainNet files to $dst_folder" cp $dataset_src $dst_folder unzip -q $dst_folder/domainnet.zip -d $dst_folder - setfacl -Rm $ACL_STRING $dst_folder + # setfacl -Rm $ACL_STRING $dst_folder fi fi diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb index bec93f7..17fe75a 100644 --- a/scripts/fine-tuning-results.ipynb +++ b/scripts/fine-tuning-results.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -94,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -102,20 +102,38 @@ "output_type": "stream", "text": [ "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", - "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 2 is out of bounds for axis 0 with size 2", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", + "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" ] } ], @@ -199,7 +217,6 @@ "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", @@ -228,6 +245,77 @@ "best_row_mean.to_numpy()[:,:-2]" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" + ] + } + ], + "source": [ + "# CLIP results including all optimizers and and layerwise method.\n", + "models = ['clip_vit_b16']\n", + "# \n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" + ] + } + ], + "source": [ + "# CLIP results including wilds datasets\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index cc55661..c31d57f 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -929,6 +929,51 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') +fmow_all_nonorm_weakaugs_highres = Dataset( + name='fmow_all_nonorm_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') + +camelyon17_weakaugs = Dataset( + name='camelyon17_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_eval.yaml') + +camelyon17_weakaugs_highres = Dataset( + name='camelyon17_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs_highres.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_highres_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -973,6 +1018,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'fmow_all': fmow_all, 'fmow_all_nonorm': fmow_all_nonorm, 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, + 'fmow_all_nonorm_weakaugs_highres': fmow_all_nonorm_weakaugs_highres, + 'camelyon17_weakaugs': camelyon17_weakaugs, + 'camelyon17_weakaugs_highres': camelyon17_weakaugs_highres, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1087,6 +1135,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +clip_vit_l14_highres = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-L/14@336px', + }, + bundles=[] +) + scratch_vit_b16_clipstyle = Model( kwargs={ 'classname': 'models.clip_model.ClipModel', @@ -1202,6 +1258,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'deit_vit_b16': deit_vit_b16, 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, + 'clip_vit_l14_highres': clip_vit_l14_highres, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, 'convnext_vit_b': convnext_vit_b, @@ -1380,6 +1437,11 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if args.epochs is not None: adapt_name += '_epochs' + str(args.epochs) if args.optimizer is not None: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [1e-6, 3e-6, 1e-5] + else: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.no_replications or args.only_one_run: num_replications = 1 @@ -1390,6 +1452,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) @@ -1419,6 +1483,22 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.optimizer is not None: hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) @@ -1565,6 +1645,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] + if args.optimizer is not None: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 if args.no_train: @@ -1572,7 +1656,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) + else: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1586,6 +1673,22 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) @@ -1644,14 +1747,15 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset(copy_cmd): - # for i in range(10, 32): - # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ - # f'scripts/run_sbatch.sh "{copy_cmd}"' - # if args.print_command: - # print(cmd) - # else: - # subprocess.run(cmd, shell=True) - for i in range(1,9): + for i in range(10, 32): + cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + f'scripts/run_sbatch.sh "{copy_cmd}"' + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) + # Exclude sphinx3 which belongs to Chris Re. + for i in [5]: # [1,2] + list(range(4,9)): cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: @@ -1812,6 +1916,8 @@ def fill_platform_specific_default_args(args): help='Tune bottom k layers (if not specified, tune everything).') parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, help='At what epoch should we unfreeze all weights and fine-tune.') + parser.add_argument('--decay_exp', type=float, required=False, default=None, + help='Higher decay exp means the learning rates goes down faster.') parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) @@ -1819,6 +1925,13 @@ def fill_platform_specific_default_args(args): help='Don\'t run replication runs, only sweep.', required=False) parser.add_argument('--no_train', action='store_true', help='Don\'t train model, just collect stats.', required=False) + parser.add_argument('--layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--layer_wise_tune_cosine', action='store_true', + help='Gradually unfreeze layers, multiply by cosine lr', required=False) + parser.add_argument('--warmup_epochs', type=int, required=False, default=None, + help='Number of epochs to run linear probe for.') + args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) main(args) diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 4257aef..45365b3 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx +#SBATCH --exclude=sphinx[3,4,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index cc456b9..4816144 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -24,7 +24,7 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': - output_metrics += val_metric + output_metrics += [val_metric] # If needed, compute the worst among all the test_accs. # That is, if the user is selecting for this metric or wants it displayed. # I guess val_metric == 'WORST' is redundant given the previous line which will diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 13b2bb9..cea1ab1 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -30,6 +30,10 @@ log_level = logging.INFO +non_sgd_optimizer_names = [ + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb' +] def reset_state(model, training): if training: @@ -317,7 +321,6 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ net.eval() else: net.train() - logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), 'train/acc': Accumulator(), @@ -411,6 +414,10 @@ def should_log(log_interval): wandb.log(stats) reset_state(net, training_state) train_stats = {'epoch': epoch} + lr = 0.0 + for param_group in optimizer.param_groups: + lr = max(lr, param_group['lr']) + train_stats['lr'] = lr if batch_scheduler is not None: train_stats['train/batch_scheduler_lr'] = batch_scheduler.get_lr() for key in loss_dict: @@ -495,14 +502,24 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None + if check_exists_not_none(config, 'decay_exp'): + decay_exp = config['decay_exp'] + else: + decay_exp = 3.73 + if check_exists_not_none(config, 'warmup_epochs'): + warmup_epochs = config['warmup_epochs'] + else: + warmup_epochs = 0 if check_exists_value(config, 'layer-wise-tune', True): logging.info('Layer-wise tuning.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, + warmup_epochs=warmup_epochs, decay_exp=decay_exp) elif check_exists_value(config, 'layer-wise-tune-cosine', True): logging.info('Layer-wise tuning with cosine decay.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, + warmup_epochs=warmup_epochs, cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -544,29 +561,42 @@ def main(config, log_dir, checkpoints_dir): weight_dict_initial, _ = get_param_weights_counts(net, detach=True) num_epochs = config['epochs'] - for epoch in range(num_epochs): + for epoch in range(num_epochs): + logging.info("\nEpoch #{}".format(epoch)) if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. num_layers = len(net.get_layers()) - num_trans_layers = (num_layers - 6) / 4 + num_trans_layers = int((num_layers - 6) / 4) # Get number of transformer layers to freeze. - num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + effective_epoch = max(0, epoch - warmup_epochs) + effective_num_epochs = max(1, num_epochs - warmup_epochs) + if effective_num_epochs == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) if num_trans_tune > num_trans_layers: num_trans_tune = num_trans_layers - num_trans_freeze = num_epochs - num_trans_tune - # COnvert to number of layers to freeze. - num_layers_freeze = num_trans_freeze * 4 + 4 + num_trans_freeze = num_trans_layers - num_trans_tune + # Convert to number of layers to freeze. + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if config['optimizer']['classname'] in non_sgd_optimizer_names: + num_layers_freeze = 0 + else: + num_layers_freeze = 2 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 # Set all grads to True. set_requires_grad(net, True) # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? net.freeze_bottom_k(num_layers_freeze) # Print statistics about number of parameters tuning, layers frozen, etc. - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') - logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -580,14 +610,19 @@ def main(config, log_dir, checkpoints_dir): if "full_ft_epoch" in config and config["full_ft_epoch"] is not None: if epoch == config["full_ft_epoch"]: set_requires_grad(net, True) - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params - assert(num_trainable_params == num_params) - logging.info(f'Full FT {num_trainable_params} of {num_params} parameters.') + logging.info(f'Full FT.') + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + # Add number of layers frozen to train_stats. + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + train_stats['num_trans_freeze'] = num_trans_freeze + train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. if not check_exists_not_none(config, 'batch_scheduler'): @@ -757,9 +792,7 @@ def set_random_seed(seed): def update_optimizer_args(config): - if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', - 'torch_optimizer.lamb.Lamb']: + if config['optimizer']['classname'] in non_sgd_optimizer_names: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index 18d8832..e258707 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,19 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine + self.decay_exp = decay_exp + self.warmup_epochs = warmup_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(current_epoch) / float(max(1, self.num_epochs)) + progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: # num_layers_tuning = num_layers - lr_multiplier = np.exp(3.73 * (1.0 - progress)) + lr_multiplier = np.exp(self.decay_exp * (1.0 - progress)) if self.cosine: lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) return lr_multiplier From 627836f5af4d3f11bb1e089ef6e873de689ede7d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 20 Sep 2022 18:16:58 -0700 Subject: [PATCH 143/197] Layerwise tuning --- configs/adaptation/camelyon17_weakaugs.yaml | 19 +++ .../camelyon17_weakaugs_highres.yaml | 66 +++++++++ .../datasets_camelyon17_weakaugs.yaml | 46 ++++++ configs/adaptation/fmow_all_nonorm.yaml | 2 +- .../fmow_all_nonorm_weakaugs_highres.yaml | 77 ++++++++++ scripts/copy_dataset.sh | 4 +- scripts/fine-tuning-results.ipynb | 126 ++++++++++++++--- scripts/run_adaptation_experiments.py | 131 ++++++++++++++++-- scripts/run_sphinx_sbatch.sh | 1 + scripts/summarize_results.py | 2 +- unlabeled_extrapolation/baseline_train.py | 71 +++++++--- unlabeled_extrapolation/utils/schedulers.py | 8 +- 12 files changed, 499 insertions(+), 54 deletions(-) create mode 100644 configs/adaptation/camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/camelyon17_weakaugs_highres.yaml create mode 100644 configs/adaptation/datasets_camelyon17_weakaugs.yaml create mode 100644 configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml diff --git a/configs/adaptation/camelyon17_weakaugs.yaml b/configs/adaptation/camelyon17_weakaugs.yaml new file mode 100644 index 0000000..890e273 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs.yaml @@ -0,0 +1,19 @@ + +inherit: + - resnet50_transfer.yaml + - datasets_camelyon17_weakaugs.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs diff --git a/configs/adaptation/camelyon17_weakaugs_highres.yaml b/configs/adaptation/camelyon17_weakaugs_highres.yaml new file mode 100644 index 0000000..ec9ef91 --- /dev/null +++ b/configs/adaptation/camelyon17_weakaugs_highres.yaml @@ -0,0 +1,66 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 2 +epochs: &epochs 3 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/datasets_camelyon17_weakaugs.yaml b/configs/adaptation/datasets_camelyon17_weakaugs.yaml new file mode 100644 index 0000000..47dc593 --- /dev/null +++ b/configs/adaptation/datasets_camelyon17_weakaugs.yaml @@ -0,0 +1,46 @@ + +root_prefix: '/u/scr/nlp/' + +train_dataset: + name: 'train' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'train' + root: 'wilds/data' + transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +default_test_transforms: + - classname: torchvision.transforms.Resize + args: + size: [224, 224] + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'id_val' + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'val' + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.wilds.WILDS + args: + dataset_name: 'camelyon17' + split: 'test' + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/configs/adaptation/fmow_all_nonorm.yaml b/configs/adaptation/fmow_all_nonorm.yaml index f47dcd6..2a815a4 100644 --- a/configs/adaptation/fmow_all_nonorm.yaml +++ b/configs/adaptation/fmow_all_nonorm.yaml @@ -4,7 +4,7 @@ inherit: - datasets_fmow_all_nonorm.yaml num_classes: 62 -epochs: &epochs 5 +epochs: &epochs 20 batch_size: 32 batch_splits: 2 save_no_checkpoints: True diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml new file mode 100644 index 0000000..0bb0fd2 --- /dev/null +++ b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml @@ -0,0 +1,77 @@ + +inherit: + - resnet50_transfer.yaml + +num_classes: 62 +epochs: &epochs 5 +batch_size: 32 +batch_splits: 2 +save_no_checkpoints: True + +model: + classname: models.imnet_resnet.ResNet50 + args: {} + +scheduler: + classname: torch.optim.lr_scheduler.CosineAnnealingLR + args: + T_max: *epochs + +root_prefix: '/u/scr/nlp/' + +# Add augmentations, and change normalization a bit. +# The difference is swav augmentation has a 0.228 instead of 0.229 (lol) +# Probably doesn't make a difference. +train_dataset: + name: 'train' + classname: datasets.fmow.Fmow + args: + split: 'train' + regions: ['all'] + root: 'wilds/data' + transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.RandomHorizontalFlip + - classname: torchvision.transforms.ToTensor + +# Change transform (e.g. centercrop), and change normalization a bit. +default_test_transforms: + - classname: unlabeled_extrapolation.datasets.transforms.Resize + args: + size: [336, 336] + interpolation: 'bicubic' + - classname: torchvision.transforms.ToTensor + +test_datasets: + - name: 'id_val' + classname: datasets.fmow.Fmow + args: + split: 'id_val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_val' + classname: datasets.fmow.Fmow + args: + split: 'val' + regions: ['all'] + root: 'wilds/data' + - name: 'ood_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: ['all'] + root: 'wilds/data' + + - name: 'africa_test' + classname: datasets.fmow.Fmow + args: + split: 'test' + regions: [2] + root: 'wilds/data' + +early_stop_dataset_names: + - 'id_val' + - 'ood_val' diff --git a/scripts/copy_dataset.sh b/scripts/copy_dataset.sh index 6141572..bef4daa 100755 --- a/scripts/copy_dataset.sh +++ b/scripts/copy_dataset.sh @@ -105,7 +105,7 @@ ACL_STRING=${ACL_STRING: : -1} # Remove trailing comma if [ ! -d "$dst_folder" ]; then mkdir -p $dst_folder mkdir -p $dst_folder/tmp - setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder + # setfacl -d -m $ACL_STRING $dst_folder # Set default permissions for folder fi a1=$RANDOM @@ -129,7 +129,7 @@ elif [ "$dataset_name" = domainnet ]; then echo "Copying DomainNet files to $dst_folder" cp $dataset_src $dst_folder unzip -q $dst_folder/domainnet.zip -d $dst_folder - setfacl -Rm $ACL_STRING $dst_folder + # setfacl -Rm $ACL_STRING $dst_folder fi fi diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb index bec93f7..17fe75a 100644 --- a/scripts/fine-tuning-results.ipynb +++ b/scripts/fine-tuning-results.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -94,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -102,20 +102,38 @@ "output_type": "stream", "text": [ "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t71.2\t56.5\t76.8\t0.0\t9.0\t6.0\n", - "CLIP ViT-B/16\tAdamW\t74.5\t63.6\t76.8\t0.0\t9.1\t6.4\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 2 is out of bounds for axis 0 with size 2", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Living-17 ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Living-17 OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds OOD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet ID'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet OOD'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_output_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstd_err_table\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mIndexError\u001b[0m: index 2 is out of bounds for axis 0 with size 2" + "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", + "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" ] } ], @@ -199,7 +217,6 @@ "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", @@ -228,6 +245,77 @@ "best_row_mean.to_numpy()[:,:-2]" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", + "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" + ] + } + ], + "source": [ + "# CLIP results including all optimizers and and layerwise method.\n", + "models = ['clip_vit_b16']\n", + "# \n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", + "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", + "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", + "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" + ] + } + ], + "source": [ + "# CLIP results including wilds datasets\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index cc55661..c31d57f 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -929,6 +929,51 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): slurm_data_dir='/scr/biggest/ue_datasets/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') +fmow_all_nonorm_weakaugs_highres = Dataset( + name='fmow_all_nonorm_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'test_acc/africa_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test', 'test_acc/africa_test'], + config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', + bundles=['fmow'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') + +camelyon17_weakaugs = Dataset( + name='camelyon17_weakaugs', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_eval.yaml') + +camelyon17_weakaugs_highres = Dataset( + name='camelyon17_weakaugs_highres', + val_metric='test_acc/ood_val', + secondary_val_metrics=['test_acc/id_val', 'test_acc/ood_test', 'LAST'], + output_metrics=['epoch', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + linprobe_secondary_val_metrics=None, + linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', + 'test_acc/ood_test'], + config_rel_path='adaptation/camelyon17_weakaugs_highres.yaml', + bundles=['camelyon17'], + slurm_data_cmd=None, + slurm_data_dir='/scr/biggest/ue_datasets/', + eval_config_rel_path='adaptation/camelyon17_weakaugs_highres_eval.yaml') + landcover = Dataset( name='landcover', val_metric='test_acc/nonafrica-val', @@ -973,6 +1018,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'fmow_all': fmow_all, 'fmow_all_nonorm': fmow_all_nonorm, 'fmow_all_nonorm_weakaugs': fmow_all_nonorm_weakaugs, + 'fmow_all_nonorm_weakaugs_highres': fmow_all_nonorm_weakaugs_highres, + 'camelyon17_weakaugs': camelyon17_weakaugs, + 'camelyon17_weakaugs_highres': camelyon17_weakaugs_highres, 'living17_noaugs': living17_noaugs, 'celeba': celeba, 'waterbirds': waterbirds, # This dataset doesn't normalize. @@ -1087,6 +1135,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +clip_vit_l14_highres = Model( + kwargs={ + 'classname': 'models.clip_model.ClipModel', + 'args.model_name': 'ViT-L/14@336px', + }, + bundles=[] +) + scratch_vit_b16_clipstyle = Model( kwargs={ 'classname': 'models.clip_model.ClipModel', @@ -1202,6 +1258,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'deit_vit_b16': deit_vit_b16, 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, + 'clip_vit_l14_highres': clip_vit_l14_highres, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, 'convnext_vit_b': convnext_vit_b, @@ -1380,6 +1437,11 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if args.epochs is not None: adapt_name += '_epochs' + str(args.epochs) if args.optimizer is not None: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [1e-6, 3e-6, 1e-5] + else: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.no_replications or args.only_one_run: num_replications = 1 @@ -1390,6 +1452,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or args.freeze_bottom_k == 0): hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) @@ -1419,6 +1483,22 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.optimizer is not None: hyperparams_list = append_to_each( hyperparams_list, {'optimizer.classname': args.optimizer}) @@ -1565,6 +1645,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] + if args.optimizer is not None: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + elif args.layer_wise_tune or args.layer_wise_tune_cosine: + sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 if args.no_train: @@ -1572,7 +1656,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' elif args.only_one_run: - hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if args.layer_wise_tune or args.layer_wise_tune_cosine: + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) + else: + hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1586,6 +1673,22 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'tune_bottom_k': args.tune_bottom_k}) adapt_name += '_tune_bottom_' + str(args.tune_bottom_k) + if args.decay_exp is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'decay_exp': args.decay_exp}) + adapt_name += '_decay_exp_' + str(args.decay_exp) + if args.layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune': True}) + adapt_name += '_layer_wise_tune_' + if args.layer_wise_tune_cosine: + hyperparams_list = append_to_each( + hyperparams_list, {'layer-wise-tune-cosine': True}) + adapt_name += '_layer_wise_tune_cosine_' + if args.warmup_epochs is not None: + hyperparams_list = append_to_each( + hyperparams_list, {'warmup_epochs': args.warmup_epochs}) + adapt_name += '_warmup_epochs' + str(args.warmup_epochs) if args.epochs is not None: hyperparams_list = append_to_each(hyperparams_list, {'epochs': args.epochs}) hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) @@ -1644,14 +1747,15 @@ def lp_then_ft_usenewbnstats_experiments(args, num_replications=3): ############################################ def spray_dataset(copy_cmd): - # for i in range(10, 32): - # cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ - # f'scripts/run_sbatch.sh "{copy_cmd}"' - # if args.print_command: - # print(cmd) - # else: - # subprocess.run(cmd, shell=True) - for i in range(1,9): + for i in range(10, 32): + cmd = f'sbatch -p jag-lo --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=jagupard{i} ' +\ + f'scripts/run_sbatch.sh "{copy_cmd}"' + if args.print_command: + print(cmd) + else: + subprocess.run(cmd, shell=True) + # Exclude sphinx3 which belongs to Chris Re. + for i in [5]: # [1,2] + list(range(4,9)): cmd = f'sbatch -p sphinx --cpus-per-task=1 --gres=gpu:0 --mem=4G --nodelist=sphinx{i} ' +\ f'scripts/run_sbatch.sh "{copy_cmd}"' if args.print_command: @@ -1812,6 +1916,8 @@ def fill_platform_specific_default_args(args): help='Tune bottom k layers (if not specified, tune everything).') parser.add_argument('--full_ft_epoch', type=int, required=False, default=None, help='At what epoch should we unfreeze all weights and fine-tune.') + parser.add_argument('--decay_exp', type=float, required=False, default=None, + help='Higher decay exp means the learning rates goes down faster.') parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) @@ -1819,6 +1925,13 @@ def fill_platform_specific_default_args(args): help='Don\'t run replication runs, only sweep.', required=False) parser.add_argument('--no_train', action='store_true', help='Don\'t train model, just collect stats.', required=False) + parser.add_argument('--layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--layer_wise_tune_cosine', action='store_true', + help='Gradually unfreeze layers, multiply by cosine lr', required=False) + parser.add_argument('--warmup_epochs', type=int, required=False, default=None, + help='Number of epochs to run linear probe for.') + args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) main(args) diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 4257aef..45365b3 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx +#SBATCH --exclude=sphinx[3,4,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index cc456b9..4816144 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -24,7 +24,7 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': - output_metrics += val_metric + output_metrics += [val_metric] # If needed, compute the worst among all the test_accs. # That is, if the user is selecting for this metric or wants it displayed. # I guess val_metric == 'WORST' is redundant given the previous line which will diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 13b2bb9..cea1ab1 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -30,6 +30,10 @@ log_level = logging.INFO +non_sgd_optimizer_names = [ + 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', + 'torch_optimizer.lamb.Lamb' +] def reset_state(model, training): if training: @@ -317,7 +321,6 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ net.eval() else: net.train() - logging.info("\nEpoch #{}".format(epoch)) loss_dict = { 'train/loss': Accumulator(), 'train/acc': Accumulator(), @@ -411,6 +414,10 @@ def should_log(log_interval): wandb.log(stats) reset_state(net, training_state) train_stats = {'epoch': epoch} + lr = 0.0 + for param_group in optimizer.param_groups: + lr = max(lr, param_group['lr']) + train_stats['lr'] = lr if batch_scheduler is not None: train_stats['train/batch_scheduler_lr'] = batch_scheduler.get_lr() for key in loss_dict: @@ -495,14 +502,24 @@ def main(config, log_dir, checkpoints_dir): # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None scheduler = None + if check_exists_not_none(config, 'decay_exp'): + decay_exp = config['decay_exp'] + else: + decay_exp = 3.73 + if check_exists_not_none(config, 'warmup_epochs'): + warmup_epochs = config['warmup_epochs'] + else: + warmup_epochs = 0 if check_exists_value(config, 'layer-wise-tune', True): logging.info('Layer-wise tuning.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, + warmup_epochs=warmup_epochs, decay_exp=decay_exp) elif check_exists_value(config, 'layer-wise-tune-cosine', True): logging.info('Layer-wise tuning with cosine decay.') num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, cosine=True) + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, + warmup_epochs=warmup_epochs, cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -544,29 +561,42 @@ def main(config, log_dir, checkpoints_dir): weight_dict_initial, _ = get_param_weights_counts(net, detach=True) num_epochs = config['epochs'] - for epoch in range(num_epochs): + for epoch in range(num_epochs): + logging.info("\nEpoch #{}".format(epoch)) if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. num_layers = len(net.get_layers()) - num_trans_layers = (num_layers - 6) / 4 + num_trans_layers = int((num_layers - 6) / 4) # Get number of transformer layers to freeze. - num_trans_tune = int(float(epoch) / num_epochs * (num_trans_layers + 1)) + effective_epoch = max(0, epoch - warmup_epochs) + effective_num_epochs = max(1, num_epochs - warmup_epochs) + if effective_num_epochs == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) if num_trans_tune > num_trans_layers: num_trans_tune = num_trans_layers - num_trans_freeze = num_epochs - num_trans_tune - # COnvert to number of layers to freeze. - num_layers_freeze = num_trans_freeze * 4 + 4 + num_trans_freeze = num_trans_layers - num_trans_tune + # Convert to number of layers to freeze. + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if config['optimizer']['classname'] in non_sgd_optimizer_names: + num_layers_freeze = 0 + else: + num_layers_freeze = 2 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 # Set all grads to True. set_requires_grad(net, True) # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? net.freeze_bottom_k(num_layers_freeze) # Print statistics about number of parameters tuning, layers frozen, etc. - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') - logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -580,14 +610,19 @@ def main(config, log_dir, checkpoints_dir): if "full_ft_epoch" in config and config["full_ft_epoch"] is not None: if epoch == config["full_ft_epoch"]: set_requires_grad(net, True) - num_trainable_params = count_parameters(net, True) - num_params = count_parameters(net, False) + num_trainable_params - assert(num_trainable_params == num_params) - logging.info(f'Full FT {num_trainable_params} of {num_params} parameters.') + logging.info(f'Full FT.') + num_trainable_params = count_parameters(net, True) + num_params = count_parameters(net, False) + num_trainable_params + logging.info(f'Fine-tuning {num_trainable_params} of {num_params} parameters.') # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + # Add number of layers frozen to train_stats. + if (check_exists_value(config, 'layer-wise-tune', True) or + check_exists_value(config, 'layer-wise-tune-cosine', True)): + train_stats['num_trans_freeze'] = num_trans_freeze + train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. if not check_exists_not_none(config, 'batch_scheduler'): @@ -757,9 +792,7 @@ def set_random_seed(seed): def update_optimizer_args(config): - if config['optimizer']['classname'] in [ - 'torch.optim.Adam', 'torch.optim.AdamW', 'torch.optim.RMSprop', 'torch_optimizer.Lamb', - 'torch_optimizer.lamb.Lamb']: + if config['optimizer']['classname'] in non_sgd_optimizer_names: # These optimizers don't have a momentum term. # A bit of a hack so we can just pass in torch.optim.Adam as a command line arg, # without having to rework the config. diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index 18d8832..e258707 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,19 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine + self.decay_exp = decay_exp + self.warmup_epochs = warmup_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(current_epoch) / float(max(1, self.num_epochs)) + progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: # num_layers_tuning = num_layers - lr_multiplier = np.exp(3.73 * (1.0 - progress)) + lr_multiplier = np.exp(self.decay_exp * (1.0 - progress)) if self.cosine: lr_multiplier *= max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(self.num_cycles) * 2.0 * progress))) return lr_multiplier From 4d884ae534844eabffe2beb51abf1355ada4f13e Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 21 Sep 2022 00:09:19 -0700 Subject: [PATCH 144/197] Improve layer wise tuner, add arbitrary options to run script. --- scripts/run_adaptation_experiments.py | 36 ++++++-- unlabeled_extrapolation/baseline_train.py | 89 ++++++++----------- unlabeled_extrapolation/models/clip_model.py | 22 +++++ .../utils/layer_wise_tuner.py | 36 ++++++++ unlabeled_extrapolation/utils/schedulers.py | 9 +- 5 files changed, 133 insertions(+), 59 deletions(-) create mode 100644 unlabeled_extrapolation/utils/layer_wise_tuner.py diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index c31d57f..957c9af 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1507,6 +1507,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1634,7 +1638,8 @@ def linprobe_experiments_usenewbnstats(args, num_replications=3): linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) -def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False): +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False, + options_dict={}): if args.epochs is not None: raise ValueError('Does not support epochs yet.') adapt_name = 'lp_then_ft' @@ -1700,6 +1705,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,8 +1735,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) -def lp_then_ft_valmode_experiments(args, num_replications=3): - lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) +def lp_then_ft_valmode_experiments(args, num_replications=3, options_dict={}): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, options_dict=options_dict) def lp_then_ft_l2sp_experiments(args, num_replications=3): @@ -1808,7 +1817,7 @@ def summarize_dataset(args): os.system(cmd) -def main(args): +def main(args, options_dict={}): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, 'spray_fmow_jags': spray_fmow_jags, @@ -1841,7 +1850,10 @@ def main(args): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - experiment_to_fns[args.experiment](args) + if options_dict != {}: + experiment_to_fns[args.experiment](args) + else: + experiment_to_fns[args.experiment](args, options_dict=options_dict) else: raise ValueError(f'Experiment {args.experiment} does not exist.') @@ -1862,6 +1874,14 @@ def fill_platform_specific_default_args(args): '/u/scr/ananya/simclr_weights/') +def get_unparsed_options_dict(unparsed): + options_dict = {} + for unparsed_option in unparsed: + option_name, val = unparsed_option.split('=') + options_dict[option_name] = val + return options_dict + + if __name__ == "__main__": parser = argparse.ArgumentParser(description='Run celeba experiments.') parser.add_argument('--experiment', type=str, required=True, @@ -1934,4 +1954,6 @@ def fill_platform_specific_default_args(args): args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) - main(args) + options_dict = get_unparsed_options_dict(unparsed) + print('options_dict', options_dict) + main(args, options_dict) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index cea1ab1..ae8282c 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -26,6 +26,7 @@ from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils import unlabeled_extrapolation.utils.schedulers as schedulers +import unlabeled_extrapolation.utils.layer_wise_tuner as layer_wise_tuner from timm.data.mixup import Mixup log_level = logging.INFO @@ -313,7 +314,8 @@ def add_layer_grad_stats(net, loss_dict, config): def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None): + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None, + batch_lw_tuner=None): # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training @@ -395,6 +397,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ optimizer.step() if batch_scheduler is not None: batch_scheduler.step() + if batch_lw_tuner is not None: + batch_lw_tuner.step() num_examples += len(all_labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -454,6 +458,12 @@ def check_exists_not_none(d, k): return k in d and d[k] != None +def get_or_default(d, k, default): + if k in d and d[k] != None: + return d[k] + return default + + def check_exists_value(d, k, v): return k in d and d[k] == v @@ -501,25 +511,34 @@ def main(config, log_dir, checkpoints_dir): # If batch scheduler is specified, then use a batch scheduler that updates the learning # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None + batch_lw_tuner = None scheduler = None - if check_exists_not_none(config, 'decay_exp'): - decay_exp = config['decay_exp'] - else: - decay_exp = 3.73 - if check_exists_not_none(config, 'warmup_epochs'): - warmup_epochs = config['warmup_epochs'] - else: - warmup_epochs = 0 - if check_exists_value(config, 'layer-wise-tune', True): - logging.info('Layer-wise tuning.') - num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, - warmup_epochs=warmup_epochs, decay_exp=decay_exp) - elif check_exists_value(config, 'layer-wise-tune-cosine', True): - logging.info('Layer-wise tuning with cosine decay.') + decay_exp = get_or_default(config, 'decay_exp', 3.73) + warmup_epochs = get_or_default(config, 'warmup_epochs', 0) + cooldown_epochs = get_or_default(config, 'cooldown_epochs', 0) + if check_exists_value(config, 'batch-layer-wise-tune', True): + num_batches = len(train_loader) + num_training_steps = num_batches * config['epochs'] + num_warmup_steps = int(num_batches * warmup_epochs) + num_cooldown_steps = int(num_batches * cooldown_epochs) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + batch_lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_training_steps, num_warmup_steps, num_cooldown_steps, freeze_embed) + logging.info('Batch layer-wise tuning.') + batch_scheduler = schedulers.LayerWiseSchedule(optimizer, num_training_steps, warmup_epochs=num_warmup_steps, + cooldown_epochs=num_cooldown_steps, decay_exp=decay_exp) + elif check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True): num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, - warmup_epochs=warmup_epochs, cosine=True) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_epochs, warmup_epochs, cooldown_epochs, freeze_embed) + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp) + else: + logging.info('Layer-wise tuning with cosine decay.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp, + cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -566,37 +585,7 @@ def main(config, log_dir, checkpoints_dir): if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. - num_layers = len(net.get_layers()) - num_trans_layers = int((num_layers - 6) / 4) - # Get number of transformer layers to freeze. - effective_epoch = max(0, epoch - warmup_epochs) - effective_num_epochs = max(1, num_epochs - warmup_epochs) - if effective_num_epochs == 1: - num_trans_tune = num_trans_layers - else: - num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) - if num_trans_tune > num_trans_layers: - num_trans_tune = num_trans_layers - num_trans_freeze = num_trans_layers - num_trans_tune - # Convert to number of layers to freeze. - if num_trans_freeze == num_trans_layers: - # If we are tuning the head, don't tune the post layer norm. - num_layers_freeze = num_trans_freeze * 4 + 5 - elif num_trans_freeze == 0: - if config['optimizer']['classname'] in non_sgd_optimizer_names: - num_layers_freeze = 0 - else: - num_layers_freeze = 2 - else: - num_layers_freeze = num_trans_freeze * 4 + 4 - # Set all grads to True. - set_requires_grad(net, True) - # Call freeze. - # TODO: Q: should we freeze pos embedding and cls token? - net.freeze_bottom_k(num_layers_freeze) - # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + lw_tuner.step() # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -617,7 +606,7 @@ def main(config, log_dir, checkpoints_dir): # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) # Add number of layers frozen to train_stats. if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 14c3238..995a3db 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -137,6 +137,28 @@ def get_layers(self): raise NotImplementedError return layers + def get_num_trans_layers(self): + visual = self._model.visual + return len(visual.transformer.resblocks) + + def freeze_bottom_trans(self, num_trans_freeze, freeze_embed): + num_trans_layers = self.get_num_trans_layers() + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if freeze_embed: + num_layers_freeze = 2 + else: + num_layers_freeze = 0 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(self, True) + # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? + self.freeze_bottom_k(num_layers_freeze) + def tune_bottom_k(self, k): layers = [layer for name, layer in self.get_layers()] if k > len(layers): diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py new file mode 100644 index 0000000..53641df --- /dev/null +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -0,0 +1,36 @@ + +import logging + +class LayerWiseTuner: + # Only works for CLIP ViT at the moment. + + def __init__(self, model, num_steps, num_warmup_steps, num_cooldown_steps, freeze_embed): + self._model = model + self._num_steps = num_steps + self._num_warmup_steps = num_warmup_steps + self._num_cooldown_steps = num_cooldown_steps + self._freeze_embed = freeze_embed + self._step = 0 + self._num_trans_freeze = -1 + + def step(self): + num_trans_layers = self._model.get_num_trans_layers() + # Get number of transformer layers to freeze. + effective_steps = max(0, self._step - self._num_warmup_steps) + effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) + if self._step >= self.num_steps - self._num_cooldown_steps: + num_trans_tune = num_trans_layers + elif effective_num_steps == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) + assert num_trans_tune <= num_trans_layers: + num_trans_freeze = num_trans_layers - num_trans_tune + if num_trans_freeze != self._num_trans_freeze: + self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) + # Print statistics about number of parameters tuning, layers frozen, etc. + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + self._num_trans_freeze = num_trans_freeze + self._step += 1 + if self._step > self._num_steps: + logging.warning(f'self._step ({self._step}) > num_steps ({num_steps})') diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e258707..e1ab0ec 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,16 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, cooldown_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine self.decay_exp = decay_exp self.warmup_epochs = warmup_epochs + self.cooldown_epochs = cooldown_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) + effective_curr_epoch = max(0, current_epoch - self.warmup_epochs) + effective_total_epochs = max(1, self.num_epochs - self.warmup_epochs - self.cooldown_epochs) + if current_epoch >= self.num_epochs - self.cooldown_epochs or effective_total_epochs == 1: + return 1.0 + progress = float(effective_curr_epoch) / float(effective_total_epochs - 1.0) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: From ce411ce4bb8c48fb8b377014d04bad567658ab67 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 21 Sep 2022 00:09:19 -0700 Subject: [PATCH 145/197] Improve layer wise tuner, add arbitrary options to run script. --- scripts/run_adaptation_experiments.py | 36 ++++++-- unlabeled_extrapolation/baseline_train.py | 89 ++++++++----------- unlabeled_extrapolation/models/clip_model.py | 22 +++++ .../utils/layer_wise_tuner.py | 36 ++++++++ unlabeled_extrapolation/utils/schedulers.py | 9 +- 5 files changed, 133 insertions(+), 59 deletions(-) create mode 100644 unlabeled_extrapolation/utils/layer_wise_tuner.py diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index c31d57f..957c9af 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1507,6 +1507,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1634,7 +1638,8 @@ def linprobe_experiments_usenewbnstats(args, num_replications=3): linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) -def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False): +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False, + options_dict={}): if args.epochs is not None: raise ValueError('Does not support epochs yet.') adapt_name = 'lp_then_ft' @@ -1700,6 +1705,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,8 +1735,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) -def lp_then_ft_valmode_experiments(args, num_replications=3): - lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) +def lp_then_ft_valmode_experiments(args, num_replications=3, options_dict={}): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, options_dict=options_dict) def lp_then_ft_l2sp_experiments(args, num_replications=3): @@ -1808,7 +1817,7 @@ def summarize_dataset(args): os.system(cmd) -def main(args): +def main(args, options_dict={}): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, 'spray_fmow_jags': spray_fmow_jags, @@ -1841,7 +1850,10 @@ def main(args): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - experiment_to_fns[args.experiment](args) + if options_dict != {}: + experiment_to_fns[args.experiment](args) + else: + experiment_to_fns[args.experiment](args, options_dict=options_dict) else: raise ValueError(f'Experiment {args.experiment} does not exist.') @@ -1862,6 +1874,14 @@ def fill_platform_specific_default_args(args): '/u/scr/ananya/simclr_weights/') +def get_unparsed_options_dict(unparsed): + options_dict = {} + for unparsed_option in unparsed: + option_name, val = unparsed_option.split('=') + options_dict[option_name] = val + return options_dict + + if __name__ == "__main__": parser = argparse.ArgumentParser(description='Run celeba experiments.') parser.add_argument('--experiment', type=str, required=True, @@ -1934,4 +1954,6 @@ def fill_platform_specific_default_args(args): args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) - main(args) + options_dict = get_unparsed_options_dict(unparsed) + print('options_dict', options_dict) + main(args, options_dict) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index cea1ab1..ae8282c 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -26,6 +26,7 @@ from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils import unlabeled_extrapolation.utils.schedulers as schedulers +import unlabeled_extrapolation.utils.layer_wise_tuner as layer_wise_tuner from timm.data.mixup import Mixup log_level = logging.INFO @@ -313,7 +314,8 @@ def add_layer_grad_stats(net, loss_dict, config): def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None): + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None, + batch_lw_tuner=None): # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training @@ -395,6 +397,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ optimizer.step() if batch_scheduler is not None: batch_scheduler.step() + if batch_lw_tuner is not None: + batch_lw_tuner.step() num_examples += len(all_labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -454,6 +458,12 @@ def check_exists_not_none(d, k): return k in d and d[k] != None +def get_or_default(d, k, default): + if k in d and d[k] != None: + return d[k] + return default + + def check_exists_value(d, k, v): return k in d and d[k] == v @@ -501,25 +511,34 @@ def main(config, log_dir, checkpoints_dir): # If batch scheduler is specified, then use a batch scheduler that updates the learning # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None + batch_lw_tuner = None scheduler = None - if check_exists_not_none(config, 'decay_exp'): - decay_exp = config['decay_exp'] - else: - decay_exp = 3.73 - if check_exists_not_none(config, 'warmup_epochs'): - warmup_epochs = config['warmup_epochs'] - else: - warmup_epochs = 0 - if check_exists_value(config, 'layer-wise-tune', True): - logging.info('Layer-wise tuning.') - num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, - warmup_epochs=warmup_epochs, decay_exp=decay_exp) - elif check_exists_value(config, 'layer-wise-tune-cosine', True): - logging.info('Layer-wise tuning with cosine decay.') + decay_exp = get_or_default(config, 'decay_exp', 3.73) + warmup_epochs = get_or_default(config, 'warmup_epochs', 0) + cooldown_epochs = get_or_default(config, 'cooldown_epochs', 0) + if check_exists_value(config, 'batch-layer-wise-tune', True): + num_batches = len(train_loader) + num_training_steps = num_batches * config['epochs'] + num_warmup_steps = int(num_batches * warmup_epochs) + num_cooldown_steps = int(num_batches * cooldown_epochs) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + batch_lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_training_steps, num_warmup_steps, num_cooldown_steps, freeze_embed) + logging.info('Batch layer-wise tuning.') + batch_scheduler = schedulers.LayerWiseSchedule(optimizer, num_training_steps, warmup_epochs=num_warmup_steps, + cooldown_epochs=num_cooldown_steps, decay_exp=decay_exp) + elif check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True): num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, - warmup_epochs=warmup_epochs, cosine=True) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_epochs, warmup_epochs, cooldown_epochs, freeze_embed) + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp) + else: + logging.info('Layer-wise tuning with cosine decay.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp, + cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -566,37 +585,7 @@ def main(config, log_dir, checkpoints_dir): if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. - num_layers = len(net.get_layers()) - num_trans_layers = int((num_layers - 6) / 4) - # Get number of transformer layers to freeze. - effective_epoch = max(0, epoch - warmup_epochs) - effective_num_epochs = max(1, num_epochs - warmup_epochs) - if effective_num_epochs == 1: - num_trans_tune = num_trans_layers - else: - num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) - if num_trans_tune > num_trans_layers: - num_trans_tune = num_trans_layers - num_trans_freeze = num_trans_layers - num_trans_tune - # Convert to number of layers to freeze. - if num_trans_freeze == num_trans_layers: - # If we are tuning the head, don't tune the post layer norm. - num_layers_freeze = num_trans_freeze * 4 + 5 - elif num_trans_freeze == 0: - if config['optimizer']['classname'] in non_sgd_optimizer_names: - num_layers_freeze = 0 - else: - num_layers_freeze = 2 - else: - num_layers_freeze = num_trans_freeze * 4 + 4 - # Set all grads to True. - set_requires_grad(net, True) - # Call freeze. - # TODO: Q: should we freeze pos embedding and cls token? - net.freeze_bottom_k(num_layers_freeze) - # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + lw_tuner.step() # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -617,7 +606,7 @@ def main(config, log_dir, checkpoints_dir): # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) # Add number of layers frozen to train_stats. if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 14c3238..995a3db 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -137,6 +137,28 @@ def get_layers(self): raise NotImplementedError return layers + def get_num_trans_layers(self): + visual = self._model.visual + return len(visual.transformer.resblocks) + + def freeze_bottom_trans(self, num_trans_freeze, freeze_embed): + num_trans_layers = self.get_num_trans_layers() + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if freeze_embed: + num_layers_freeze = 2 + else: + num_layers_freeze = 0 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(self, True) + # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? + self.freeze_bottom_k(num_layers_freeze) + def tune_bottom_k(self, k): layers = [layer for name, layer in self.get_layers()] if k > len(layers): diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py new file mode 100644 index 0000000..53641df --- /dev/null +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -0,0 +1,36 @@ + +import logging + +class LayerWiseTuner: + # Only works for CLIP ViT at the moment. + + def __init__(self, model, num_steps, num_warmup_steps, num_cooldown_steps, freeze_embed): + self._model = model + self._num_steps = num_steps + self._num_warmup_steps = num_warmup_steps + self._num_cooldown_steps = num_cooldown_steps + self._freeze_embed = freeze_embed + self._step = 0 + self._num_trans_freeze = -1 + + def step(self): + num_trans_layers = self._model.get_num_trans_layers() + # Get number of transformer layers to freeze. + effective_steps = max(0, self._step - self._num_warmup_steps) + effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) + if self._step >= self.num_steps - self._num_cooldown_steps: + num_trans_tune = num_trans_layers + elif effective_num_steps == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) + assert num_trans_tune <= num_trans_layers: + num_trans_freeze = num_trans_layers - num_trans_tune + if num_trans_freeze != self._num_trans_freeze: + self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) + # Print statistics about number of parameters tuning, layers frozen, etc. + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + self._num_trans_freeze = num_trans_freeze + self._step += 1 + if self._step > self._num_steps: + logging.warning(f'self._step ({self._step}) > num_steps ({num_steps})') diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e258707..e1ab0ec 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,16 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, cooldown_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine self.decay_exp = decay_exp self.warmup_epochs = warmup_epochs + self.cooldown_epochs = cooldown_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) + effective_curr_epoch = max(0, current_epoch - self.warmup_epochs) + effective_total_epochs = max(1, self.num_epochs - self.warmup_epochs - self.cooldown_epochs) + if current_epoch >= self.num_epochs - self.cooldown_epochs or effective_total_epochs == 1: + return 1.0 + progress = float(effective_curr_epoch) / float(effective_total_epochs - 1.0) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: From 46ce62f06f5917dc5032456c1dcedc34099f6bfc Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 21 Sep 2022 00:09:19 -0700 Subject: [PATCH 146/197] Improve layer wise tuner, add arbitrary options to run script. --- scripts/run_adaptation_experiments.py | 36 ++++++-- unlabeled_extrapolation/baseline_train.py | 89 ++++++++----------- unlabeled_extrapolation/models/clip_model.py | 22 +++++ .../utils/layer_wise_tuner.py | 36 ++++++++ unlabeled_extrapolation/utils/schedulers.py | 9 +- 5 files changed, 133 insertions(+), 59 deletions(-) create mode 100644 unlabeled_extrapolation/utils/layer_wise_tuner.py diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index c31d57f..957c9af 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1507,6 +1507,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1634,7 +1638,8 @@ def linprobe_experiments_usenewbnstats(args, num_replications=3): linprobe_experiments(args, num_replications=num_replications, use_new_bn_stats=True) -def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False): +def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode=False, use_new_bn_stats=False, l2sp=False, + options_dict={}): if args.epochs is not None: raise ValueError('Does not support epochs yet.') adapt_name = 'lp_then_ft' @@ -1700,6 +1705,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'full_ft_epoch': args.full_ft_epoch}) adapt_name += '_full_ft_epoch_' + str(args.full_ft_epoch) + if options_dict != {}: + hyperparams_list = append_to_each( + hyperparams_list, options_dict) + adapt_name += '_' + '_'.join(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,8 +1735,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) -def lp_then_ft_valmode_experiments(args, num_replications=3): - lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True) +def lp_then_ft_valmode_experiments(args, num_replications=3, options_dict={}): + lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, options_dict=options_dict) def lp_then_ft_l2sp_experiments(args, num_replications=3): @@ -1808,7 +1817,7 @@ def summarize_dataset(args): os.system(cmd) -def main(args): +def main(args, options_dict={}): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, 'spray_fmow_jags': spray_fmow_jags, @@ -1841,7 +1850,10 @@ def main(args): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - experiment_to_fns[args.experiment](args) + if options_dict != {}: + experiment_to_fns[args.experiment](args) + else: + experiment_to_fns[args.experiment](args, options_dict=options_dict) else: raise ValueError(f'Experiment {args.experiment} does not exist.') @@ -1862,6 +1874,14 @@ def fill_platform_specific_default_args(args): '/u/scr/ananya/simclr_weights/') +def get_unparsed_options_dict(unparsed): + options_dict = {} + for unparsed_option in unparsed: + option_name, val = unparsed_option.split('=') + options_dict[option_name] = val + return options_dict + + if __name__ == "__main__": parser = argparse.ArgumentParser(description='Run celeba experiments.') parser.add_argument('--experiment', type=str, required=True, @@ -1934,4 +1954,6 @@ def fill_platform_specific_default_args(args): args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) - main(args) + options_dict = get_unparsed_options_dict(unparsed) + print('options_dict', options_dict) + main(args, options_dict) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index cea1ab1..ae8282c 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -26,6 +26,7 @@ from unlabeled_extrapolation.utils.accumulator import Accumulator import unlabeled_extrapolation.utils.utils as utils import unlabeled_extrapolation.utils.schedulers as schedulers +import unlabeled_extrapolation.utils.layer_wise_tuner as layer_wise_tuner from timm.data.mixup import Mixup log_level = logging.INFO @@ -313,7 +314,8 @@ def add_layer_grad_stats(net, loss_dict, config): def train(epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None): + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler=None, + batch_lw_tuner=None): # Returns a dictionary with epoch, train/loss and train/acc. # Train model. training_state = net.training @@ -395,6 +397,8 @@ def train(epoch, config, train_loader, net, device, optimizer, criterion, model_ optimizer.step() if batch_scheduler is not None: batch_scheduler.step() + if batch_lw_tuner is not None: + batch_lw_tuner.step() num_examples += len(all_labels) outputs, loss, train_preds = None, None, None # Try to force garbage collection. def should_log(log_interval): @@ -454,6 +458,12 @@ def check_exists_not_none(d, k): return k in d and d[k] != None +def get_or_default(d, k, default): + if k in d and d[k] != None: + return d[k] + return default + + def check_exists_value(d, k, v): return k in d and d[k] == v @@ -501,25 +511,34 @@ def main(config, log_dir, checkpoints_dir): # If batch scheduler is specified, then use a batch scheduler that updates the learning # rate every step. Otherwise, update the learning rate every epoch. batch_scheduler = None + batch_lw_tuner = None scheduler = None - if check_exists_not_none(config, 'decay_exp'): - decay_exp = config['decay_exp'] - else: - decay_exp = 3.73 - if check_exists_not_none(config, 'warmup_epochs'): - warmup_epochs = config['warmup_epochs'] - else: - warmup_epochs = 0 - if check_exists_value(config, 'layer-wise-tune', True): - logging.info('Layer-wise tuning.') - num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, - warmup_epochs=warmup_epochs, decay_exp=decay_exp) - elif check_exists_value(config, 'layer-wise-tune-cosine', True): - logging.info('Layer-wise tuning with cosine decay.') + decay_exp = get_or_default(config, 'decay_exp', 3.73) + warmup_epochs = get_or_default(config, 'warmup_epochs', 0) + cooldown_epochs = get_or_default(config, 'cooldown_epochs', 0) + if check_exists_value(config, 'batch-layer-wise-tune', True): + num_batches = len(train_loader) + num_training_steps = num_batches * config['epochs'] + num_warmup_steps = int(num_batches * warmup_epochs) + num_cooldown_steps = int(num_batches * cooldown_epochs) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + batch_lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_training_steps, num_warmup_steps, num_cooldown_steps, freeze_embed) + logging.info('Batch layer-wise tuning.') + batch_scheduler = schedulers.LayerWiseSchedule(optimizer, num_training_steps, warmup_epochs=num_warmup_steps, + cooldown_epochs=num_cooldown_steps, decay_exp=decay_exp) + elif check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True): num_epochs = config['epochs'] - scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, decay_exp=decay_exp, - warmup_epochs=warmup_epochs, cosine=True) + freeze_embed = not(config['optimizer']['classname'] in non_sgd_optimizer_names) + lw_tuner = layer_wise_tuner.LayerWiseTuner(net, num_epochs, warmup_epochs, cooldown_epochs, freeze_embed) + if check_exists_value(config, 'layer-wise-tune', True): + logging.info('Layer-wise tuning.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp) + else: + logging.info('Layer-wise tuning with cosine decay.') + scheduler = schedulers.LayerWiseSchedule(optimizer, num_epochs, warmup_epochs=warmup_epochs, + cooldown_epochs=cooldown_epochs, decay_exp=decay_exp, + cosine=True) elif check_exists_not_none(config, 'batch_scheduler'): # TODO: add batch scheduler. num_batches = len(train_loader) @@ -566,37 +585,7 @@ def main(config, log_dir, checkpoints_dir): if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): # Get number of transformer layers. - num_layers = len(net.get_layers()) - num_trans_layers = int((num_layers - 6) / 4) - # Get number of transformer layers to freeze. - effective_epoch = max(0, epoch - warmup_epochs) - effective_num_epochs = max(1, num_epochs - warmup_epochs) - if effective_num_epochs == 1: - num_trans_tune = num_trans_layers - else: - num_trans_tune = int(float(effective_epoch) / (effective_num_epochs-1) * num_trans_layers) - if num_trans_tune > num_trans_layers: - num_trans_tune = num_trans_layers - num_trans_freeze = num_trans_layers - num_trans_tune - # Convert to number of layers to freeze. - if num_trans_freeze == num_trans_layers: - # If we are tuning the head, don't tune the post layer norm. - num_layers_freeze = num_trans_freeze * 4 + 5 - elif num_trans_freeze == 0: - if config['optimizer']['classname'] in non_sgd_optimizer_names: - num_layers_freeze = 0 - else: - num_layers_freeze = 2 - else: - num_layers_freeze = num_trans_freeze * 4 + 4 - # Set all grads to True. - set_requires_grad(net, True) - # Call freeze. - # TODO: Q: should we freeze pos embedding and cls token? - net.freeze_bottom_k(num_layers_freeze) - # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f'Freezing {num_layers_freeze} layers out of {num_layers}') - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + lw_tuner.step() # Save checkpoint once in a while. if epoch % config['save_freq'] == 0 and ( 'save_no_checkpoints' not in config or not config['save_no_checkpoints']): @@ -617,7 +606,7 @@ def main(config, log_dir, checkpoints_dir): # One epoch of model training. train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, - test_loaders, max_test_examples, weight_dict_initial, batch_scheduler) + test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) # Add number of layers frozen to train_stats. if (check_exists_value(config, 'layer-wise-tune', True) or check_exists_value(config, 'layer-wise-tune-cosine', True)): diff --git a/unlabeled_extrapolation/models/clip_model.py b/unlabeled_extrapolation/models/clip_model.py index 14c3238..995a3db 100644 --- a/unlabeled_extrapolation/models/clip_model.py +++ b/unlabeled_extrapolation/models/clip_model.py @@ -137,6 +137,28 @@ def get_layers(self): raise NotImplementedError return layers + def get_num_trans_layers(self): + visual = self._model.visual + return len(visual.transformer.resblocks) + + def freeze_bottom_trans(self, num_trans_freeze, freeze_embed): + num_trans_layers = self.get_num_trans_layers() + if num_trans_freeze == num_trans_layers: + # If we are tuning the head, don't tune the post layer norm. + num_layers_freeze = num_trans_freeze * 4 + 5 + elif num_trans_freeze == 0: + if freeze_embed: + num_layers_freeze = 2 + else: + num_layers_freeze = 0 + else: + num_layers_freeze = num_trans_freeze * 4 + 4 + # Set all grads to True. + set_requires_grad(self, True) + # Call freeze. + # TODO: Q: should we freeze pos embedding and cls token? + self.freeze_bottom_k(num_layers_freeze) + def tune_bottom_k(self, k): layers = [layer for name, layer in self.get_layers()] if k > len(layers): diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py new file mode 100644 index 0000000..53641df --- /dev/null +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -0,0 +1,36 @@ + +import logging + +class LayerWiseTuner: + # Only works for CLIP ViT at the moment. + + def __init__(self, model, num_steps, num_warmup_steps, num_cooldown_steps, freeze_embed): + self._model = model + self._num_steps = num_steps + self._num_warmup_steps = num_warmup_steps + self._num_cooldown_steps = num_cooldown_steps + self._freeze_embed = freeze_embed + self._step = 0 + self._num_trans_freeze = -1 + + def step(self): + num_trans_layers = self._model.get_num_trans_layers() + # Get number of transformer layers to freeze. + effective_steps = max(0, self._step - self._num_warmup_steps) + effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) + if self._step >= self.num_steps - self._num_cooldown_steps: + num_trans_tune = num_trans_layers + elif effective_num_steps == 1: + num_trans_tune = num_trans_layers + else: + num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) + assert num_trans_tune <= num_trans_layers: + num_trans_freeze = num_trans_layers - num_trans_tune + if num_trans_freeze != self._num_trans_freeze: + self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) + # Print statistics about number of parameters tuning, layers frozen, etc. + logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + self._num_trans_freeze = num_trans_freeze + self._step += 1 + if self._step > self._num_steps: + logging.warning(f'self._step ({self._step}) > num_steps ({num_steps})') diff --git a/unlabeled_extrapolation/utils/schedulers.py b/unlabeled_extrapolation/utils/schedulers.py index e258707..e1ab0ec 100644 --- a/unlabeled_extrapolation/utils/schedulers.py +++ b/unlabeled_extrapolation/utils/schedulers.py @@ -22,16 +22,21 @@ def lr_lambda(self, current_step): class LayerWiseSchedule(LambdaLR): """Linear warm up and then cosine annealing of the learning rate.""" - def __init__(self, optimizer, num_epochs, warmup_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): + def __init__(self, optimizer, num_epochs, warmup_epochs=0, cooldown_epochs=0, decay_exp=3.73, cosine=False, num_cycles=0.5, last_epoch=-1): self.num_epochs = num_epochs self.num_cycles = num_cycles self.cosine = cosine self.decay_exp = decay_exp self.warmup_epochs = warmup_epochs + self.cooldown_epochs = cooldown_epochs super(LayerWiseSchedule, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch) def lr_lambda(self, current_epoch): - progress = float(max(0, current_epoch - self.warmup_epochs)) / float(max(1, self.num_epochs - self.warmup_epochs)) + effective_curr_epoch = max(0, current_epoch - self.warmup_epochs) + effective_total_epochs = max(1, self.num_epochs - self.warmup_epochs - self.cooldown_epochs) + if current_epoch >= self.num_epochs - self.cooldown_epochs or effective_total_epochs == 1: + return 1.0 + progress = float(effective_curr_epoch) / float(effective_total_epochs - 1.0) # num_layers_tuning = int(progress * (num_layers + 1)) # assert num_layers_tuning >= 0 # if num_layers_tuning > num_layers: From 1c317c8e3afb1b1ee5b0d50a0e96be6da97ab16d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 7 Oct 2022 09:43:11 -0700 Subject: [PATCH 147/197] Final paper updates --- .amltignore | 4 + .gitignore | 3 + ...nalyze_dataset_stats_model_gradients.ipynb | 297 +++++++ scripts/fine-tuning-results.ipynb | 348 --------- ...eeze-embed-paper-fine-tuning-results.ipynb | 737 ++++++++++++++++++ ...> imagenet_fmow_waterbirds_examples.ipynb} | 81 +- ...ad_models_test_get_layers_gradients.ipynb} | 201 ++++- scripts/run_adaptation_experiments.py | 33 +- scripts/run_sphinx_sbatch.sh | 2 +- scripts/summarize_all_results.py | 7 +- scripts/summarize_results.py | 21 +- unlabeled_extrapolation/baseline_train.py | 7 +- .../utils/layer_wise_tuner.py | 6 +- 13 files changed, 1350 insertions(+), 397 deletions(-) create mode 100644 scripts/analyze_dataset_stats_model_gradients.ipynb delete mode 100644 scripts/fine-tuning-results.ipynb create mode 100644 scripts/freeze-embed-paper-fine-tuning-results.ipynb rename scripts/{fmow_waterbirds_examples.ipynb => imagenet_fmow_waterbirds_examples.ipynb} (98%) rename scripts/{load_models_get_layers.ipynb => load_models_test_get_layers_gradients.ipynb} (72%) diff --git a/.amltignore b/.amltignore index 6cccde4..ca7271f 100644 --- a/.amltignore +++ b/.amltignore @@ -1,3 +1,7 @@ +**wandb** +**.tsv** +**egg-info** +**slurm_outputs** **logs** **amlt_results** **amlt_configs** diff --git a/.gitignore b/.gitignore index 91c9254..13a7bb8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +**amlt_configs/** +.amltconfig + **tmp.tsv** **slurm_outputs** **outdated** diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb new file mode 100644 index 0000000..c41625a --- /dev/null +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -0,0 +1,297 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "import timm\n", + "import torch\n", + "from torch import nn\n", + "import numpy as np\n", + "import os\n", + "import sys\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.pyplot import figure" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "ue_src = '/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation'\n", + "if ue_src not in sys.path:\n", + " sys.path = [ue_src] + sys.path\n", + "print(sys.path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import breeds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "model_display_names = ['clip_b', 'clip_l', 'vit_b', 'dino_b', 'convnext_b', 'resnet50', 'resnet101']\n", + "log_root = '../logs/'\n", + "\n", + "def get_gradient_log_name(dataset_name, model_name):\n", + " return f'full_ft_epochs1_no_train__{dataset_name}_{model_name}'\n", + "\n", + "def get_dir_path(dataset_name, model_name):\n", + " log_name = get_gradient_log_name(dataset_name, model_name)\n", + " run_name = 'epochs-1_no_train-True_optimizer.args.lr-0.0_scheduler.args.T_max-1_seed-0_run0'\n", + " return log_root + '/' + log_name + '/' + run_name + '/'\n", + "\n", + "def get_config_path(dir_path):\n", + " return dir_path + '/config.json'\n", + "\n", + "def get_stats_path(dir_path):\n", + " return dir_path + '/stats.tsv'\n", + "\n", + "def get_random_images(dataset, n=100):\n", + " indices = np.random.choice(np.arange(len(dataset)), size=n, replace=False)\n", + " return [dataset[i][0].cpu().detach().numpy() for i in indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['grad_2', 'grad_1']\n" + ] + } + ], + "source": [ + "S = {'grad_1', 'grad_2', 'norm_1', 'other'}\n", + "filtered_S = [s for s in S if 'grad' in s]\n", + "print(filtered_S)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "living17_nonorm\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "domainnet\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def filter_df_get_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_norm(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_normalized_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " filtered_d = df[filtered_keys].to_dict(orient='records')[0]\n", + " norm_d = df[norm_keys].to_dict(orient='records')[0]\n", + " normalized_grad_d = {}\n", + " for fk, nk in zip(filtered_keys, norm_keys):\n", + " normalized_grad_d[fk] = filtered_d[fk] / norm_d[nk]\n", + " return normalized_grad_d\n", + "\n", + "# def filter_df_get_norm_grad(df):\n", + "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad' in s]\n", + "# print(filtered_keys)\n", + "# return df[filtered_keys] \n", + "\n", + "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", + " dataset_stats = {}\n", + " for dataset in datasets:\n", + " print(dataset)\n", + " figure(figsize=(8, 4), dpi=80)\n", + " for model_idx, model in enumerate(models):\n", + " dir_path = get_dir_path(dataset, model)\n", + " config_path = get_config_path(dir_path)\n", + " stats_path = get_stats_path(dir_path)\n", + " with open(config_path, 'r') as f:\n", + " config = json.load(f)\n", + " train_data = utils.init_dataset(config['train_dataset'])\n", + " if model_idx == 1:\n", + " random_images = get_random_images(train_data,n=10)\n", + " dataset_stats[dataset] = {\n", + " 'mean': np.mean(random_images),\n", + " 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", + " 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", + " }\n", + " df = pd.read_csv(stats_path, sep='\\t')\n", + " d = filter_df(df)\n", + " values = list(d.values())\n", + " if model_idx == 1:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers')\n", + " plt.scatter([model_idx], values[-1], c='green', label='last layer')\n", + " plt.scatter([model_idx], values[0], c='red', label='first layer')\n", + " else:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black')\n", + " plt.scatter([model_idx], values[-1], c='green')\n", + " plt.scatter([model_idx], values[0], c='red')\n", + " my_xticks = ['John','Arnold','Mavis','Matt']\n", + " plt.legend()\n", + " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", + "\n", + " plt.show()\n", + "# print(d.values())\n", + "# print(filtered_keys)\n", + "# print(df['train/grad_patch_embed'])\n", + "# print(df[filtered_keys])\n", + "# print(df[compute_keys(df)])\n", + " return dataset_stats\n", + "\n", + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'living17_nonorm': {'mean': 0.405586, 'std': 0.19588944, 'std_mean': 0.105948165}, 'waterbirds': {'mean': 0.37670943, 'std': 0.22946799, 'std_mean': 0.11904866}, 'domainnet': {'mean': 0.8599936, 'std': 0.1735559, 'std_mean': 0.15381968}}\n" + ] + } + ], + "source": [ + "print(dataset_stats)\n", + "# The std-devs within the image, and the std devs of the mean, are pretty similar (and small).\n", + "# So it's really the mean that varies a lot.\n", + "# I think the \"obvious\" thing to do is to normalize the images to have the same mean, std-dev\n", + "# Let's check this and see what the gradients look like if we do this." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Loop over datasets\n", + " # Loop over models\n", + " # Get folder name\n", + " # Get gradient stats\n", + " # Compute relevant stats. E.g., for transformer models combine blocks?\n", + " # Plot stats. Can start by just plotting first layer and some in between layer for every model?\n", + " # For the first model, load config. Load dataset.\n", + " # Sample random images. Get image mean. Std-dev within a single image. Variance of the mean across images." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb deleted file mode 100644 index 17fe75a..0000000 --- a/scripts/fine-tuning-results.ipynb +++ /dev/null @@ -1,348 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "import summarize_all_results\n", - "import importlib\n", - "importlib.reload(summarize_all_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", - " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " cur_results = []\n", - " for dataset_idx, dataset in enumerate(datasets):\n", - " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", - " output_metrics = output_metrics_list[dataset_idx]\n", - " if val_metric_list is None:\n", - " val_metric = 'LAST'\n", - " else:\n", - " val_metric = val_metric_list[dataset_idx]\n", - " if aggregation_metric_list is None:\n", - " agg_metric = val_metric\n", - " else:\n", - " agg_metric = aggregation_metric_list[dataset_idx]\n", - " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", - " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", - " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", - " cur_results = np.concatenate(cur_results)\n", - " table[model_idx][option_idx] = cur_results\n", - " return table\n", - "\n", - "# Add table to make TSV and Latex tables.\n", - "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", - " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", - " print(first_line)\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " line = model + '\\t' + option\n", - " for idx, val in enumerate(table[model_idx][option_idx]):\n", - " line += '\\t' + '{:.1f}'.format(val)\n", - " if std_err_table is not None:\n", - " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", - " print(line)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "log_dir = '../logs/'\n", - "name_template = 'full_ft_{option}{dataset}_{model}'\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['LAST', 'LAST', 'LAST']\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", - "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", - "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", - "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", - "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", - "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", - "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", - "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", - "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", - "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", - "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" - ] - } - ], - "source": [ - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", - "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", - "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", - "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", - "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", - "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", - "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", - "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", - "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" - ] - } - ], - "source": [ - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" - ] - } - ], - "source": [ - "# LAMB and LARS results for CLIP ViT-B/16\n", - "models = ['clip_vit_b16']\n", - "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['Lamb', 'LARS']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[97.026]], dtype=object)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "best_row_mean.to_numpy()[:,:-2]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" - ] - } - ], - "source": [ - "# CLIP results including all optimizers and and layerwise method.\n", - "models = ['clip_vit_b16']\n", - "# \n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" - ] - } - ], - "source": [ - "# CLIP results including wilds datasets\n", - "models = ['clip_vit_b16']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb new file mode 100644 index 0000000..c317685 --- /dev/null +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "import math\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "\n", + "# TODOs:\n", + "# Get mean and std (done)\n", + "# Filter out for ID and OOD columns (done)\n", + "# Add an overall average column\n", + "\n", + "# Print some nice Latex tables (done)\n", + "# Bold the best numbers within confidence intervals, in the latex table\n", + "\n", + "def get_bolds(table, std_err_table=None, eps=0.2):\n", + " is_best = np.zeros((len(table), len(table[0])), dtype=np.int32)\n", + " for col in range(len(table[0])):\n", + " best_idx = np.argmax(table[:,col])\n", + " best_acc = table[best_idx][col]\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " best_std = std_err_table[best_idx][col]\n", + " if math.isnan(best_std):\n", + " best_std = eps\n", + " for row in range(len(table)):\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " cur_std = std_err_table[row][col]\n", + " if math.isnan(cur_std):\n", + " cur_std = eps\n", + " if np.abs(table[row][col] - best_acc) <= max(best_std, cur_std):\n", + " is_best[row][col] = 1\n", + " else:\n", + " if table[row][col] >= best_acc - eps:\n", + " is_best[row][col] = 1\n", + " return is_best\n", + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None,\n", + " aggregation_metric_list=None, num_sweep=6, desired_epochs_list=None):\n", + " # desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\n", + " # supposed to have run each dataset for. Used to validate if the runs finished.\n", + " mean_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " std_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_means = []\n", + " cur_stds = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " num_jobs = len(res)\n", + " if (desired_epochs_list is not None and\n", + " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + " bad_indices = np.argwhere(np.array(num_epochs_list) < desired_epochs_list[dataset_idx])\n", + " bad_runs = [dir_path + '/' + run_folder for run_folder in res['name'][bad_indices[:, 0]]]\n", + " print('some jobs did not finish: ', model, dataset, option, bad_runs)\n", + " if num_jobs != num_sweep and num_jobs != num_sweep * 3:\n", + " print('not all jobs ran: ', model, option, dataset, num_jobs)\n", + " cur_means.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_stds.append(best_row_std.to_numpy()[0,:-2])\n", + " cur_means = np.concatenate(cur_means)\n", + " cur_stds = np.concatenate(cur_stds)\n", + " mean_table[model_idx][option_idx] = cur_means\n", + " std_table[model_idx][option_idx] = cur_stds\n", + " return mean_table, std_table\n", + "\n", + "def flatten(list_of_lists):\n", + " x = []\n", + " for l in list_of_lists:\n", + " x.append(l)\n", + " return x\n", + "\n", + "def filter_columns(table, old_output_metrics_list, new_output_metrics_list):\n", + " def get_indices(old_list, new_items):\n", + " return np.array([old_list.index(x) for x in new_items])\n", + " local_indices_list = [get_indices(o, n) for o, n in zip(old_output_metrics_list, new_output_metrics_list)]\n", + "# print(local_indices_list)\n", + " old_lens = [len(o) for o in old_output_metrics_list]\n", + " cum_old_lens = np.concatenate([[0], np.cumsum(old_lens)])[:-1]\n", + "# print(cum_old_lens)\n", + " global_indices = [local_indices + cum_old_len for local_indices, cum_old_len in zip(local_indices_list, cum_old_lens)]\n", + "# print(list(np.concatenate(global_indices)))\n", + " return table[:, :, global_indices][:,:,:,0]\n", + "\n", + "\n", + "# Add table to make TSV and Latex tables. Add averages.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " print(line)\n", + " \n", + "def add_average_column(table):\n", + " new_table = []\n", + " for model_idx in range(len(table)):\n", + " model_table = table[model_idx]\n", + " means = np.mean(model_table, axis=1)\n", + " new_model_table = np.concatenate([model_table, np.expand_dims(means, axis=-1)], axis=-1)\n", + " new_table.append(new_model_table)\n", + " return np.array(new_table)\n", + " \n", + "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True):\n", + "\n", + " # Print latex table.\n", + " if len(models) == 1:\n", + " num_columns = len(shortened_output_metrics_list) + 1\n", + " else:\n", + " num_columns = len(shortened_output_metrics_list) + 2\n", + " if is_last_avg:\n", + " print('\\\\begin{tabular}{' + ('c'*(num_columns-1)) + '|c}')\n", + " else:\n", + " print('\\\\begin{tabular}{' + ('c'*num_columns) + '}')\n", + " print('\\\\toprule')\n", + " first_line = ' & ' + ' & '.join(shortened_output_metrics_list) + '\\\\\\\\'\n", + " if len(models) > 1:\n", + " first_line = ' & ' + first_line\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " print('\\\\midrule')\n", + " if std_err_table is None:\n", + " is_bold = get_bolds(table[model_idx], eps=0.2)\n", + " else:\n", + " is_bold = get_bolds(table[model_idx], std_err_table[model_idx], eps=0.2)\n", + " for option_idx, option in enumerate(options):\n", + " if len(models) > 1:\n", + " line = model + ' & ' + option\n", + " else:\n", + " line = option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += ' & '\n", + "# print(is_bold[option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '\\\\textbf{'\n", + " line += '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx]) and\n", + " not math.isnan(std_err_table[model_idx][option_idx][idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '}'\n", + " line += '\\\\\\\\'\n", + " print(line)\n", + " print('\\\\bottomrule')\n", + " print('\\\\end{tabular}')\n", + " \n", + " \n", + "def display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", + " # Filter the ID and OOD metrics.\n", + " print('\\n\\nID Accuracies')\n", + " id_mean_table = filter_columns(mean_table, output_metrics_list, id_output_metrics_list)\n", + " id_mean_table = add_average_column(id_mean_table)\n", + " id_std_table = filter_columns(std_table, output_metrics_list, id_output_metrics_list)\n", + " if no_std:\n", + " id_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table, is_last_avg=True)\n", + "\n", + " print('\\n\\nOOD Accuracies')\n", + " ood_mean_table = filter_columns(mean_table, output_metrics_list, ood_output_metrics_list)\n", + " ood_mean_table = add_average_column(ood_mean_table)\n", + " ood_std_table = filter_columns(std_table, output_metrics_list, ood_output_metrics_list)\n", + " if no_std:\n", + " ood_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table, is_last_avg=True)\n", + " return id_mean_table, ood_mean_table\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.concatenate([[0], np.array([1,2,3])])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "some jobs did not finish: timm_vit_b16_in21k domainnet freeze_bottom_2_opt_torch.optim.AdamW_ ['../logs//full_ft_freeze_bottom_2_opt_torch.optim.AdamW_domainnet_timm_vit_b16_in21k/freeze_bottom_k-2_optimizer.args.lr-3e-06_seed-0_run0']\n", + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.7\t81.0\t97.0\t64.6\t87.4\t69.5\n", + "CLIP ViT-B/16\tAdamW\t97.9\t83.5\t97.7\t71.1\t94.9\t89.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t81.9\t97.8\t74.3\t94.6\t87.9\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 ID & Living-17 OOD & Waterbirds ID & Waterbirds OOD & DomainNet ID & DomainNet OOD\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.7 & 81.0 & 97.0 & 64.6 & 87.4 & 69.5\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{97.9} & \\textbf{83.5} & \\textbf{97.7} & 71.1 & \\textbf{94.9} & 89.3\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.0} & 81.9 & \\textbf{97.8} & \\textbf{74.3} & 94.6 & 87.9\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.1} & 82.6 & \\textbf{97.8} & 69.2 & \\textbf{94.8} & \\textbf{89.8}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.5} & \\textbf{89.4} & \\textbf{99.0} & 78.7 & \\textbf{91.5} & \\textbf{86.7}\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.6} & 87.9 & 98.9 & 80.1 & \\textbf{91.5} & 84.4\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{89.5} & \\textbf{99.2} & \\textbf{82.4} & \\textbf{91.5} & 86.3\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.5} & 88.4 & 99.0 & \\textbf{82.4} & 90.8 & 82.6\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & \\textbf{88.2} & 97.0 & 55.6 & 88.0 & 76.2\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.4} & 87.5 & \\textbf{97.9} & 61.2 & 89.1 & 77.5\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.3} & 87.6 & 97.5 & \\textbf{68.5} & 88.9 & \\textbf{78.9}\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & 86.7 & 97.6 & 61.5 & \\textbf{89.6} & 76.4\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{97.3} & \\textbf{85.7} & \\textbf{98.4} & 75.2 & \\textbf{89.0} & 80.9\\\\\n", + "BIT ResNet-50 & AdamW & 97.1 & 83.2 & \\textbf{98.3} & 76.9 & \\textbf{89.2} & \\textbf{84.0}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.5} & 84.4 & \\textbf{98.5} & 75.5 & \\textbf{89.0} & 82.4\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & 83.6 & \\textbf{98.4} & \\textbf{78.5} & \\textbf{89.0} & 83.5\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.2} & 82.2 & \\textbf{98.9} & 79.0 & \\textbf{91.8} & \\textbf{86.0}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.2} & 84.5 & 98.6 & \\textbf{79.4} & 91.0 & 83.7\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{84.9} & \\textbf{98.8} & 78.7 & 91.4 & \\textbf{85.9}\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.1} & 84.1 & 98.7 & 72.0 & 90.6 & 83.9\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.5} & \\textbf{92.1} & 99.0 & 81.3 & 94.6 & 89.8\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & 90.1 & \\textbf{99.4} & 85.8 & 94.0 & 89.9\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.5} & 91.5 & \\textbf{99.3} & \\textbf{88.0} & \\textbf{94.8} & \\textbf{91.5}\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.6} & 89.8 & \\textbf{99.3} & 87.7 & 94.5 & 91.0\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.3 & 84.9 & 96.3 & 56.7 & 84.1 & 60.9\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & 88.4 & \\textbf{98.7} & 86.0 & 96.6 & \\textbf{93.8}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & 98.6 & \\textbf{89.4} & \\textbf{98.7} & 84.9 & \\textbf{96.8} & \\textbf{93.9}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & 98.6 & 88.2 & \\textbf{98.6} & \\textbf{87.5} & \\textbf{96.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (LAST)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "desired_epochs_list = [20, 20, 50]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)\n", + "display_latex_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t80.0\t97.2\t62.5\t87.6\t69.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t82.8\t97.7\t71.9\t95.0\t89.2\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t83.2\t97.8\t73.7\t94.9\t88.2\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (Early stopped)\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t87.6\t67.0\t99.4\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 87.6 & 67.0 & \\textbf{99.4} & 89.8\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & \\textbf{95.0} & \\textbf{70.1} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & \\textbf{94.9} & \\textbf{70.0} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & \\textbf{66.4} & \\textbf{99.5} & \\textbf{91.1}\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & \\textbf{89.4} & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", + "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & \\textbf{68.8} & \\textbf{99.7} & \\textbf{92.2}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & \\textbf{92.0}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t69.6\t37.3\t86.8\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 69.6 & 37.3 & 86.8 & 67.2\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & \\textbf{95.7} & \\textbf{76.0}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & \\textbf{91.9} & 70.7\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{84.3} & \\textbf{76.5} & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", + "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & \\textbf{35.0} & \\textbf{95.2} & \\textbf{74.4}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{82.9} & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{83.1} & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & \\textbf{75.6}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & \\textbf{39.7} & 83.0 & 77.3\\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\textbf{89.8} & 89.5 & 38.4 & \\textbf{89.5} & \\textbf{79.5}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & \\textbf{79.4}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.2243181 91.46286571 91.27799905]\n", + "[71.87552286 76.03873524 76.73786476]\n" + ] + } + ], + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIP results including wilds datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t87.6 (6.4)\t67.0 (0.8)\t99.4 (0.0)\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & 92.1\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & 92.1\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", + "LAMB & 98.2 & 97.8 & 95.1 & 67.9 & 99.5 & 91.7\\\\\n", + "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t69.6 (16.0)\t37.3 (1.1)\t86.8 (1.1)\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & 76.0\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", + "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", + "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", + "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 waterbirds freeze_bottom_2_full_ft_epoch_50_ []\n", + "not all jobs ran: clip_vit_b16 freeze_bottom_2_full_ft_epoch_50_ waterbirds 7\n", + "empty dir ../older_logs//full_ft_freeze_bottom_5_full_ft_epoch_50_waterbirds_clip_vit_b16\n" + ] + }, + { + "ename": "TypeError", + "evalue": "object of type 'NoneType' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# desired_epochs_list = [20, 20, 50, 5, 3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../older_logs/'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-embed)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Layer-wise'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LAMB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LARS'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 54\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 55\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 58\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" + ] + } + ], + "source": [ + "# Get table for dino and clip, freezing different number of layers.\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['freeze_bottom_2_full_ft_epoch_50_', 'freeze_bottom_5_full_ft_epoch_50_', 'freeze_bottom_8_full_ft_epoch_50_', 'freeze_bottom_11_full_ft_epoch_50_', 'freeze_bottom_14_full_ft_epoch_50_']\n", + "val_metric_list = ['WATERBIRDS_VAL']\n", + "datasets = ['waterbirds']\n", + "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", + "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "# desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table('../older_logs/', name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fmow_waterbirds_examples.ipynb b/scripts/imagenet_fmow_waterbirds_examples.ipynb similarity index 98% rename from scripts/fmow_waterbirds_examples.ipynb rename to scripts/imagenet_fmow_waterbirds_examples.ipynb index 86576a2..9b6bef5 100644 --- a/scripts/fmow_waterbirds_examples.ipynb +++ b/scripts/imagenet_fmow_waterbirds_examples.ipynb @@ -28,6 +28,22 @@ "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ImageNet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -74,18 +90,79 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "train_transform = transforms.Compose([\n", - " transforms.Resize(size=224)\n", + " transforms.Resize(size=224),\n", + " transforms.ToTensor()\n", "])\n", "root = '/u/scr/nlp/wilds/data' # For NLP cluster.\n", "# root = '/home/t-anakumar/wilds/data/' # For microsoft sandbox.\n", "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root=root, transform=train_transform, return_meta=True)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.6039216 , 0.6039216 , 0.6 , ..., 0.30980393,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.6039216 , 0.6039216 , 0.6039216 , ..., 0.3137255 ,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.60784316, 0.6039216 , 0.6039216 , ..., 0.31764707,\n", + " 0.31764707, 0.31764707],\n", + " ...,\n", + " [0.3019608 , 0.3019608 , 0.29803923, ..., 0.7058824 ,\n", + " 0.6901961 , 0.6901961 ],\n", + " [0.29411766, 0.29803923, 0.29803923, ..., 0.7058824 ,\n", + " 0.7019608 , 0.69411767],\n", + " [0.28627452, 0.2901961 , 0.29411766, ..., 0.6745098 ,\n", + " 0.67058825, 0.67058825]],\n", + "\n", + " [[0.69803923, 0.69803923, 0.69411767, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.69803923, 0.69803923, 0.69803923, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.7019608 , 0.69803923, 0.69803923, ..., 0.42745098,\n", + " 0.42745098, 0.42745098],\n", + " ...,\n", + " [0.38039216, 0.38039216, 0.3764706 , ..., 0.627451 ,\n", + " 0.6117647 , 0.6117647 ],\n", + " [0.37254903, 0.3764706 , 0.3764706 , ..., 0.627451 ,\n", + " 0.62352943, 0.6156863 ],\n", + " [0.3647059 , 0.36862746, 0.37254903, ..., 0.59607846,\n", + " 0.5921569 , 0.5921569 ]],\n", + "\n", + " [[0.8862745 , 0.8862745 , 0.88235295, ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8862745 , 0.8862745 , 0.8862745 , ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8901961 , 0.8862745 , 0.8862745 , ..., 0.6745098 ,\n", + " 0.6745098 , 0.6745098 ],\n", + " ...,\n", + " [0.3372549 , 0.3372549 , 0.33333334, ..., 0.61960787,\n", + " 0.6039216 , 0.6039216 ],\n", + " [0.32941177, 0.33333334, 0.33333334, ..., 0.62352943,\n", + " 0.61960787, 0.6117647 ],\n", + " [0.32156864, 0.3254902 , 0.32941177, ..., 0.5921569 ,\n", + " 0.5882353 , 0.5882353 ]]], dtype=float32)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(waterbirds_train[0][0])" + ] + }, { "cell_type": "code", "execution_count": 49, diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb similarity index 72% rename from scripts/load_models_get_layers.ipynb rename to scripts/load_models_test_get_layers_gradients.ipynb index beceb6e..c2f9663 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -1,32 +1,21 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", "import timm\n", "import torch\n", + "from torch import nn\n", "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", - "importlib.reload(timm_model)" + "importlib.reload(timm_model)\n", + "importlib.reload(clip_model)" ] }, { @@ -49,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -62,6 +51,184 @@ " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing layer norm" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.4242, grad_fn=)\n", + "tensor([[ 0.0140, 0.0559, 0.0699],\n", + " [-0.0701, -0.2804, -0.3505],\n", + " [ 0.0561, 0.2245, 0.2806]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)*0.1\n", + "x = torch.tensor(data)\n", + "layer_norm = nn.LayerNorm(len(data), elementwise_affine=False)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "output = layer_norm(torch.matmul(A, x))\n", + "loss = torch.dot(torch.tensor([0.1, 0.2, 0.5]), output) # torch.sum(torch.square(output))\n", + "loss.backward()\n", + "print(loss)\n", + "print(A.grad)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-18.0826, -18.0283, -18.0102],\n", + " [ 72.3376, 72.1204, 72.0480],\n", + " [-54.2588, -54.0958, -54.0415]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32) - 100.0\n", + "x = torch.tensor(data)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "z = torch.matmul(A, x)\n", + "z.retain_grad()\n", + "mu = torch.mean(z)\n", + "mu.retain_grad()\n", + "sigma = torch.sqrt(torch.std(z, unbiased=False) ** 2)\n", + "sigma.retain_grad()\n", + "o = (z - mu) / sigma\n", + "o.retain_grad()\n", + "l = torch.dot(torch.tensor([0.1, 0.2, 0.5]), o)\n", + "# l.backward()\n", + "# print(A.grad)\n", + "l.backward()\n", + "print(A.grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get norms and gradients for different models" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "model = clip_model.ClipModel('ViT-B/16')\n", + "model.new_last_layer(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# print(list(model.get_layers()[0][1].parameters())[0].requires_grad)\n", + "# inputs = torch.zeros((1, 3, 224, 224))\n", + "\n", + "def get_clip_mean_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "def get_clip_dist_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + "inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + "inputs = inputs.tile([1, 1, 224, 224])\n", + "print(inputs.shape)\n", + "inputs = inputs.cuda()\n", + "model.cuda()\n", + "outputs = model(inputs)\n", + "loss = torch.sum(torch.square(outputs))\n", + "loss.backward()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[29.54964256286621, 2.6062560390040383, 7.567190647125244, 1.0375860929489136, 0.26622636570179553, 9.328513982084095, 0.2186721176275342, 17.19362955770947, 0.26272152142902877, 9.570395973223832, 0.33883179052500684, 17.063759606866164, 0.4135279331824097, 19.316852593622446, 0.348065239809437, 23.211175772550735, 0.2866482939208723, 21.411272157777947, 0.2982341959606744, 32.02183701601188, 0.7350253231739102, 23.98497888947061, 0.3489564675414618, 36.33611495543812, 0.3906924973175038, 26.982765200703604, 0.4056054973737743, 39.959679978199176, 0.46362568149293487, 25.90123800988363, 0.2922789139876288, 40.1849475230448, 1.12168652906377, 28.275337317915774, 0.2797527143483323, 48.489088348578655, 0.5411435171208155, 21.4489124869876, 0.23895772899326645, 34.997931414576485, 1.7938492117508384, 21.208721582016143, 0.16792367077919937, 30.11186549644565, 2.420525364382956, 19.86338208946117, 0.4717152135407727, 27.1885166259501, 1.0686553663789327, 34.53155986991048, 0.2615572246974295, 33.576464443434766, 1.2850386157480747, 13.470720567165724]\n" + ] + } + ], + "source": [ + "\n", + "def get_grad_layer(cur_layer):\n", + " grads = [p.grad.detach().cpu().numpy() for p in cur_layer.parameters()]\n", + " grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads]\n", + " grad_norm = np.sqrt(np.sum(grad_norms_squared))\n", + " return grad_norm\n", + "\n", + "def get_norm_layer(cur_layer):\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " return norm\n", + "\n", + "def get_layer_grads(model):\n", + " named_layers = model.get_layers()\n", + " names, layers = zip(*named_layers)\n", + " norms = [get_norm_layer(l) for l in layers]\n", + " grad_norms = [get_grad_layer(l) for l in layers]\n", + " return norms, grad_norms\n", + "\n", + "norms, grad_norms = get_layer_grads(model)\n", + "print(grad_norms)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test get layers for different models" + ] + }, { "cell_type": "code", "execution_count": 22, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 957c9af..21d3349 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1441,8 +1441,9 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [1e-6, 3e-6, 1e-5] else: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + # Note for fmow I also tried 3e-4 and 1e-3. if args.no_replications or args.only_one_run: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1491,6 +1492,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) adapt_name += '_layer_wise_tune_cosine_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.decay_exp is not None: hyperparams_list = append_to_each( hyperparams_list, {'decay_exp': args.decay_exp}) @@ -1510,7 +1515,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1544,10 +1549,12 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) for dataset in datasets: + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, - ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1652,7 +1659,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= model = names_to_model[args.model_name] if args.optimizer is not None: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 @@ -1686,6 +1693,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune': True}) adapt_name += '_layer_wise_tune_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.layer_wise_tune_cosine: hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) @@ -1708,7 +1719,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,11 +1737,13 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= for i in range(num_replications): replication_hyperparams_list.append({ 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1850,7 +1863,7 @@ def main(args, options_dict={}): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - if options_dict != {}: + if options_dict == {}: experiment_to_fns[args.experiment](args) else: experiment_to_fns[args.experiment](args, options_dict=options_dict) @@ -1876,8 +1889,10 @@ def fill_platform_specific_default_args(args): def get_unparsed_options_dict(unparsed): options_dict = {} + print(unparsed) for unparsed_option in unparsed: option_name, val = unparsed_option.split('=') + option_name = option_name[2:] options_dict[option_name] = val return options_dict @@ -1947,6 +1962,8 @@ def get_unparsed_options_dict(unparsed): help='Don\'t train model, just collect stats.', required=False) parser.add_argument('--layer_wise_tune', action='store_true', help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--batch_layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) parser.add_argument('--layer_wise_tune_cosine', action='store_true', help='Gradually unfreeze layers, multiply by cosine lr', required=False) parser.add_argument('--warmup_epochs', type=int, required=False, default=None, diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 45365b3..db134ab 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3,4,5,6,7,8] +#SBATCH --exclude=sphinx[3,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 25db1d0..a3b0a5a 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -29,10 +29,11 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre # summarize_result gets a table where each row is the results for one *run*. # We now summarize the information across runs in a *single* experiment. # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). - res, val_values_list, file_paths = summarize_results( + res, val_values_list, file_paths, num_epochs_list = summarize_results( dir_path, val_metric, output_metrics) if len(res) == 0: - return None, None, None + print('empty dir', dir_path) + return None, None, None, None res['group'] = res['name'].apply(remove_replication_info) grouped = res.groupby('group') means = grouped.mean() @@ -56,7 +57,7 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre for best_row in [best_row_mean, best_row_std]: best_row['group'] = best_row.index best_row.set_index('name') - return res, best_row_mean, best_row_std + return res, best_row_mean, best_row_std, num_epochs_list def get_all_results(val_metric, dir_paths, output_metrics): diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index 4816144..eceb4e0 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -21,6 +21,7 @@ def get_parent_folder(file_path): def get_result(file_path, val_metric, output_metrics, take_max=True): + # Get the result for a single run. df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': @@ -68,9 +69,12 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): else: run_name = [('name', file_path[file_path.rfind('/')+1:-4])] best_res = run_name + best_res - return best_res, best_value + # len(df) is the number of epochs + assert len(df) == df['epoch'].max() + 1 + return best_res, best_value, len(df) -def summarize_results(results_dir, val_metric, output_metrics, replication=False, use_all=False, max_num=None): +def summarize_results(results_dir, val_metric, output_metrics, max_num=None): + # Get results for all runs in an experiment. # If use_all is True, then look at all stats.tsv files. # Otherwise, if replication is True look for replication files, if false ignore replicatin files. # max_num is for linear probing, and uses only the first max_num runs. @@ -81,15 +85,14 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False # the same validation metric. file_paths = sorted(file_paths) results_list, val_values_list = [], [] + num_epochs_list = [] for file_path in file_paths: if max_num is not None and int(file_path[-5]) >= max_num: continue - parent_folder = get_parent_folder(file_path) - if use_all or (('replication' in parent_folder and replication) or - ('replication' not in parent_folder and not replication)): - res_row, val_value = get_result(file_path, val_metric, output_metrics) - results_list.append(OrderedDict(res_row)) - val_values_list.append(val_value) + res_row, val_value, num_epochs = get_result(file_path, val_metric, output_metrics) + results_list.append(OrderedDict(res_row)) + val_values_list.append(val_value) + num_epochs_list.append(num_epochs) res = pd.DataFrame(results_list) for col in res.columns: if 'epoch' in col: @@ -97,7 +100,7 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False if 'acc' in col: res[col] = res[col] * 100 res = res.round(4) - return res, val_values_list, file_paths + return res, val_values_list, file_paths, num_epochs_list if __name__ == '__main__': # Higher is better when we pick val_metric, so use it for accuracies not losses. diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index ae8282c..8a0c371 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -607,14 +607,9 @@ def main(config, log_dir, checkpoints_dir): train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) - # Add number of layers frozen to train_stats. - if (check_exists_value(config, 'layer-wise-tune', True) or - check_exists_value(config, 'layer-wise-tune-cosine', True)): - train_stats['num_trans_freeze'] = num_trans_freeze - train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. - if not check_exists_not_none(config, 'batch_scheduler'): + if batch_scheduler is None: scheduler.step() # Get test stats across all test sets. test_stats = get_all_test_stats( diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py index 53641df..2e2bfad 100644 --- a/unlabeled_extrapolation/utils/layer_wise_tuner.py +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -18,18 +18,18 @@ def step(self): # Get number of transformer layers to freeze. effective_steps = max(0, self._step - self._num_warmup_steps) effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) - if self._step >= self.num_steps - self._num_cooldown_steps: + if self._step >= self._num_steps - self._num_cooldown_steps: num_trans_tune = num_trans_layers elif effective_num_steps == 1: num_trans_tune = num_trans_layers else: num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) - assert num_trans_tune <= num_trans_layers: + assert num_trans_tune <= num_trans_layers num_trans_freeze = num_trans_layers - num_trans_tune if num_trans_freeze != self._num_trans_freeze: self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') self._num_trans_freeze = num_trans_freeze self._step += 1 if self._step > self._num_steps: From 55026d231d519ad58ab6574b69d6d267d242a0f5 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 7 Oct 2022 09:43:11 -0700 Subject: [PATCH 148/197] Final paper updates --- .amltignore | 4 + .gitignore | 3 + ...nalyze_dataset_stats_model_gradients.ipynb | 297 +++++++ scripts/fine-tuning-results.ipynb | 348 --------- ...eeze-embed-paper-fine-tuning-results.ipynb | 737 ++++++++++++++++++ ...> imagenet_fmow_waterbirds_examples.ipynb} | 81 +- ...ad_models_test_get_layers_gradients.ipynb} | 201 ++++- scripts/run_adaptation_experiments.py | 33 +- scripts/run_sphinx_sbatch.sh | 2 +- scripts/summarize_all_results.py | 7 +- scripts/summarize_results.py | 21 +- unlabeled_extrapolation/baseline_train.py | 7 +- .../utils/layer_wise_tuner.py | 6 +- 13 files changed, 1350 insertions(+), 397 deletions(-) create mode 100644 scripts/analyze_dataset_stats_model_gradients.ipynb delete mode 100644 scripts/fine-tuning-results.ipynb create mode 100644 scripts/freeze-embed-paper-fine-tuning-results.ipynb rename scripts/{fmow_waterbirds_examples.ipynb => imagenet_fmow_waterbirds_examples.ipynb} (98%) rename scripts/{load_models_get_layers.ipynb => load_models_test_get_layers_gradients.ipynb} (72%) diff --git a/.amltignore b/.amltignore index 6cccde4..ca7271f 100644 --- a/.amltignore +++ b/.amltignore @@ -1,3 +1,7 @@ +**wandb** +**.tsv** +**egg-info** +**slurm_outputs** **logs** **amlt_results** **amlt_configs** diff --git a/.gitignore b/.gitignore index 91c9254..13a7bb8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +**amlt_configs/** +.amltconfig + **tmp.tsv** **slurm_outputs** **outdated** diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb new file mode 100644 index 0000000..c41625a --- /dev/null +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -0,0 +1,297 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "import timm\n", + "import torch\n", + "from torch import nn\n", + "import numpy as np\n", + "import os\n", + "import sys\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.pyplot import figure" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "ue_src = '/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation'\n", + "if ue_src not in sys.path:\n", + " sys.path = [ue_src] + sys.path\n", + "print(sys.path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import breeds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "model_display_names = ['clip_b', 'clip_l', 'vit_b', 'dino_b', 'convnext_b', 'resnet50', 'resnet101']\n", + "log_root = '../logs/'\n", + "\n", + "def get_gradient_log_name(dataset_name, model_name):\n", + " return f'full_ft_epochs1_no_train__{dataset_name}_{model_name}'\n", + "\n", + "def get_dir_path(dataset_name, model_name):\n", + " log_name = get_gradient_log_name(dataset_name, model_name)\n", + " run_name = 'epochs-1_no_train-True_optimizer.args.lr-0.0_scheduler.args.T_max-1_seed-0_run0'\n", + " return log_root + '/' + log_name + '/' + run_name + '/'\n", + "\n", + "def get_config_path(dir_path):\n", + " return dir_path + '/config.json'\n", + "\n", + "def get_stats_path(dir_path):\n", + " return dir_path + '/stats.tsv'\n", + "\n", + "def get_random_images(dataset, n=100):\n", + " indices = np.random.choice(np.arange(len(dataset)), size=n, replace=False)\n", + " return [dataset[i][0].cpu().detach().numpy() for i in indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['grad_2', 'grad_1']\n" + ] + } + ], + "source": [ + "S = {'grad_1', 'grad_2', 'norm_1', 'other'}\n", + "filtered_S = [s for s in S if 'grad' in s]\n", + "print(filtered_S)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "living17_nonorm\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhsAAAEUCAYAAACCmfT1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAxOAAAMTgF/d4wjAAA1AElEQVR4nO3de3zU5Z3//deHTAa0UQEPaBsISUYwIBAoYjWRWqEG/Xm7al2pLVqsq1K1slKtrXe392937x5txaq9RVst7U/d1Zb+1L2tpipSybiejaCgYSYHQKtYEGo8MExy/f74TmISZpJJZiZzyPv5eMwjme/1PVy5MofP9zqacw4RERGRTBmV7QyIiIhIYVOwISIiIhmlYENEREQySsGGiIiIZJSCDREREckoBRsiIiKSUQo2REREJKN82brw6NGj3eGHH56ty4uIiMgQvPnmmxHn3OjBHJO1YOPwww9n+/bt2bq8iIiIDIGZvTvYY9SMIiIiIhmlYENEREQyKmvNKP1xznU/JP+YGaNGKY4VERFPTgUbnZ2d7Nixg927dyvQyHPFxcVMmjQJv9+f7ayIiEiW5VSw0dbWxqhRo5g8eTLFxcXZzo4MkXOOnTt3snXrVgKBQLazIyIiWZYzwUZnZycff/wxRx99ND5fzmRLhujQQw9l165ddHZ25n+TinMQDEIoBIEA1NSAWbZzJSKSN3LmW72r2cT0IV4Quv6Ped8c1tYGdXXQ0gJ+P0QiUF4O9fVQVpbt3ImI5IU8v+UUySDnvEAjHPaCjPZ272c4DIsWeekiIjIgBRtp8tZbb3HSSSclTD/ssMNobW2NmzZ37lzWrVsHwMknn8wDDzwwqGuvW7eO6urqQR0jSQgGobUVotHe26NRaG720kUk45xzNGxtYHXjahq2NuR/jekIlDPNKKlwzhEMBgmFQgQCAWpqaoa9OebTn/4069evH9ZrZkM0Gh05fWpCISguhr1790/z+7302trhz5fICNK2u426u+to2d2Cv8hPpCNC+dhy6pfUUzZWTZn5IumaDTP7s5ltMLNGM1tvZrNj2482s6fNrMnMnjez6ZnL7v7a2tqoqqpiwYIFfPOb32TBggVUVVXR1taWlvObGT/4wQ84/vjjmTx5Mg888AA/+tGPmDt3LkcffXR3jURraytjx47tPu6hhx6iqqqKmTNn8u1vf7vXOZ9++mmqq6s59thjueiii4j2vXOOef/997nkkkuYN28eM2fO5NJLLyUSifSb32g0Sl1dHXPnzmX69Ol85Stf4YMPPgDgjDPO4N577+3e989//jPHH3/8gNc6+eSTueqqqzjhhBM49dRTeffddzn11FOZMWMGM2fO5KKLLhpUmeaNQMBrNoknEvHSRSRjnHPU3V1HeFeYSEeE9kg7kY4I4V1hFt2zSDUceWQwzSjnOedmOueqgRuB1bHttwN3OOemAD/psT3jnHPU1dURDoeJRCK0t7cTiUQIh8MsWpS+F2JJSQnPPvssd955J0uWLOGoo47ihRde4Ic//CHXXnvtfvvv2LGDiy66iDVr1rBhwwYCgQA7d+4EIBKJsHjxYn72s5/x6quvcv755/PKK6/Eve63vvUtTjrpJJ577jleeeUVOjs7+cUvftFvXouKirj33nt54YUXePXVVznkkEO45ZZbAFi+fDm33npr976//OUvufLKK5O6VlNTE0899RRr167l7rvvpry8nI0bN7JhwwZ+/vOfD65A80VNjdcZtG9Njs8HFRVeuohkTHBbkNbdrURd7xuyqIvS/F4zwW1qyswXSQcbzrndPZ4eAjgzOwKYC9wd274GmGhmw3LLFwwGaW1t3a9mIBqN0tzcTDBNbeqLFy8GvL4VH3zwAV/+8pcBmDdvHlu2bNlv/2eeeYaZM2cybdo0AC6++OLuya1ef/11fD4fCxcuBODUU0+loqIi7nUfeOABbrjhBqqrq5k9ezbr168nFAr1m1fnHCtXrmT27NnMnDmThx9+mMbGRgC++MUvsmfPHl5++WXa2tp47rnnOO+885K61pIlS7rnPvnc5z7HI488wre+9S0efPBBPvWpTyVVjnnHzBt1UlnpNZuUlHg/AwFvu0ZOiWRUaFeI4qL4cy75R/kJ7er/81Byx6Aa383sd8AXYk9PByYCf3XOCzudc87MtgKTgIy/CkKhEMXFxeyN06bu9/sJhULUpqFNfcyYMYBXa9D3eaImkJ4G6j+SKN05x5o1a5gyZUrSeb333ntZu3Ytf/nLXzj44IO5+eabWbt2bXf6VVddxS233MKECRP4+te/zujRo5O6VklJSffvJ5xwAo2NjTz++OP88Y9/5F/+5V94+eWXu8unoJSVwebNmmdDJAsC4wNEOuI3ZUY6IwTGqykzXwxqNIpz7kLn3ETge3hNJkkzsxVmtr3r0d7ePpjD4woEAgn7MEQikazNXnnCCSewYcMGXn/9dQDuuuuu7nwec8wxRKNRnnzySQAef/xxwuFw3POcddZZ/OQnP+kOaN57770Bazbee+89DjvsMA4++GDef/99Vq9e3Sv9ggsuoL6+nt/85jcsW7ZsSNdqaWmhpKSE8847j1tuuYWmpibS8f/MWWZeR9ClS72fCjREhkXNxBrKx5bjs973xT7zUTGugpqJasrMF0Ma+uqc+y1eDcd24Cgz75Vg3i36JGBrnGNudM6Vdj163ikPVU1NDeXl5fuNjvD5fFRUVFCTpTb1ww8/nLvuuouzzz6bWbNmsWXLFg499FDAq3G57777uPrqq5kxYwb33nsvs2bNinuelStXcsABB1BdXc3MmTNZsGBBwuGzXS688EI+/PBDpk6dymmnnbbfcNwDDzyQc845h5qaGiZOnDika61bt47PfvazVFdXc+KJJ3LDDTdwyCGHJF9AeUbD7kSyw8yoX1JP5fhK/EV+SopL8Bf5CRwaoH5JvSaBzCOWzAenmY0FDnTOvRV7fhZwK14zypPAaufcajM7F/iOc27uQOcsLS1127dv737e0dFBU1MTU6ZMGVR1fFtbG3V1dbS0tOD3+4lEIlRUVFBfX8+kSZOSPs9I0dHRwWc/+1luueWWfucFScd1hvL/zDUadieSfc45gtuChHaFCIwPUDNx+Kc3kE+Y2ZvOudLBHJNsn41DgN+b2QFAJ/AucEasj8ZlwGozux74OzCs4yDLysrYvHlz1ufZyAcPPfQQV111VdwaD9lfz2F3URftbjvuGna36fJNep2JDAMzo3ZSLbWTNK9NvkqqZiMT0lWzIbmpEP6fDVsbWPi7heztiNMBucjPExc+oQ8/ERlxhlKzoenKRRLQsDsRkfRQsCGSgIbdiYikh4INkQQ07E5EJD0UbIgkoGF3IiLpMUKW7xQZmrKxZWy+YrOG3YmIpKAgajYyOemSmbF79+4hHdva2sqqVasSpq9evZqzzjpraBmTYdM17G5p9VJqJ9Uq0BARGaS8r9nI5UmXuoKNntOCZ0s0Gt1vplUREZHhkNc1Gz0nXYp0RGiPtBPpiHRPupTuOUSuueYajjvuOKqrq5k/fz5vvPEGAB999BGLFy9m2rRpzJo1i1NPPRWAZcuW8cYbb1BdXc2ZZ57Z77nffvttvvCFL/DZz36W6dOnc+WVV9LZ2QnAjBkzePrpp7v3veOOO7pXon377bc577zzmDdvHjNmzOB73/te936TJ0/muuuuY968eXzta19La1mIiIgkK6+DjeC2IK27W4m6PkvMuyjN7zUT3JaeJea7XHfddTz//PM0NjZy+eWXs3z5cgAeffRRdu/ezaZNm3jllVf4z//8TwBWrVrF1KlTaWxs5KGHHur33GPHjuW//uu/ePHFF9mwYQOtra3cf//9gLdS66233tq97y9/+UuuvPJKAL72ta9xxRVX8Nxzz/Hyyy/zwgsv8Pvf/7573507d/Lss89yzz33pLUsREQk9+TqWk55Xa/eNelS3BkeY5MupXOGx8cee4xbbrmF999/n87OTnbt2gXArFmz2Lx5M5dffjmf//znOf300wd97s7OTq677joaGrwXx44dOzj22GP58pe/zJIlS/j+97/PO++8w5YtWzAzTjrpJD744AOeeOIJ3nnnne7ztLe3d9e4ACxdulR9DERERoBc7laQ18HGcE66tHXrVq688kqef/55Kisr2bBhA/PnzwegoqKCTZs2sXbtWh5//HG+/e1v09jYOKjz33jjjezYsYNnn32WMWPGsGLFCj7++GMADjjgAJYuXcrtt9/O5s2bueKKKwC6I9ZnnnmGMWPGxD1vOlbXFRGR3JbraznldTPKcE66tGfPHoqLiznqqKNwzvVq1ti+fTtmxplnnsnPfvYznHNs27aNgw8+mD179iR1/vfee48jjzySMWPG8Pbbb/dqCgG44ooruOOOO1i7di1f/epXAS+Q+MIXvsCPf/zj7v3eeusteq45IyIihW+4uxUMVl4HG8M56dKMGTP48pe/zPTp0znuuON6LV+/ceNGampqmDVrFrNnz+aCCy5g5syZzJw5k+nTp3PssccO2EF0+fLlPPvss0yfPp0LLriAhQsX9kovLS1l9uzZLFmyhAMPPLB7+z333EMoFOLYY49lxowZnHPOOezcuTNtf7eIiOS+XF/LqSBWfXXOFfykSx988AFTp05l/fr1lJeXZzs7AyqEVV9FRPJFw9YGFvxuQdyuBelepXrErvpa6JMurVq1imOOOYbLL788LwINEREZXrm+llNBBBuFbtmyZWzbto3rr78+21kREZEclOtrOeX1aBQRERHx5PJaTgo2RERECkRXt4J0zjGVDmpGERERkYxSsCEiIiIZpWBjAA8++CBVVVVUV1ezceNGqquref/99wd1jnXr1vHoo48mTF+6dCk33XRTijkVERHJTYXRZ8M5CAYhFIJAAGpqIE0dYlatWsX3v/99zj//fICE05D3t4T7unXr2L17N4sWLUpLnlKhpeZFRGS45X/NRlsbVFXBggXwzW96P6uqvO0puuqqq1i/fj3XX389J554IuB1vtm9ezew/xLuW7Zs6Z5JtGu598bGRlatWsU999xDdXU1//Zv/9bvNZ944glOOOEEZs+ezfTp07nzzjsBbxryCRMm8OGHH3bv+5WvfIXbbrsNgOeff55TTjmFuXPnMnv27O7pzltbWxk7dizXXXcdc+bM6TXNuoiIyHDI71tc56CuDsJhiEYhEps5LRyGRYtg06aUajhuvvlmNmzYwD//8z9z1llnxd2nawl3M2P58uWcccYZfPe73wVg165djB8/nmXLlrF79+6kmkrmzJlDQ0MDRUVF7Nq1i9mzZ1NXV0dpaSkLFy7k7rvv5tJLL+Wdd97h8ccf54477mD37t1ceuml/OlPf+Koo47ib3/7G3PmzOkOkPbs2cP06dP5yU9+MuSyEBERGar8DjaCQWht9QKNnqJRaG720mszO/yn5xLu8+fP59prr6W9vZ3Pf/7z+61vkoydO3dy8cUX09TUhM/nY+fOnbz66quUlpayfPlyLrnkEi699FJ+9atfcf7551NSUsKf/vQnmpubOe2003qd64033qCiooLi4mKWLFmSlr9XRERksPK7GSUUguL4C8/g93vpGdZzCfcvfelLBINBpk6dyq233soZZ5wx6PMtW7aM2tpaNm7cSGNjI1OmTOlean7evHkceOCBPPnkk9xxxx29lpqfPn06jY2N3Y+tW7dyyimnAHDggQcyalR+/6tFRCR/5fc3UCDwSdNJX5GIlz6MtmzZwoQJE7jwwgv56U9/yjPPPAMw6KXmy8rKMDOeeuopXnnllV7py5cv58ILL6SqqoopU6YAcOKJJ9LS0sLjjz/evV9jYyORRGUjIiIyjJIKNsxsjJk9YGZNZvaKmT1mZoFY2jozazGzxtjj6sxmuYeaGigvh76jK3w+qKjw0ofRH/7wB2bMmMHs2bNZvHgxq1atAuDss8+msbExqQ6iP/7xj/nOd75DdXU1d911F8cff3yv9HPPPZf29nauvPLK7m3jxo3j4Ycf5oc//CGzZs1i2rRpfOc736GzszP9f6SIiMggJbXEvJmNAU4BHnHOOTO7EjjXOXeyma0DbnLOPTCYC6dtifm2Nq+TaEuL13QSiXiBRn09TJo0mCzlhRdeeIGvfOUrvP766zndNKIl5kVECtNQlphPqoOoc+5j4E89Nj0DXDOYC2VMWRls3pyxeTZyyT/90z/x5z//mV//+tc5HWiIiIj0NNTRKMuBB3s8/7GZ/TuwCfiuc6455ZwNhpk36iTDI0+y7de//nW2syAiIjJog749NrPrgQDw3dimC5xzxwAzgfXA/5/guBVmtr3r0d7ePtQ8i4iISB4ZVLBhZtcA5wCnOec+BHDObYv9dM65W4EKMzu077HOuRudc6Vdj55DRmPn7tpvSH+I5Jau/6MVYHOWiIgMTtLNKGa2AjgfWOic2x3b5gMOdc69E3v+JeAd59zOwWZk1KhRjBkzhjfffJMJEyZQnGj+DMl5zjl27txJcXGx+paIiEhywYaZlQI/B5qBJ2N3q3vxRqg8bGajgU7gb8CZQ81MWVkZO3bsoLW1VTUcea64uJhJBTgaSEREBi/Z0SjbgUT14XPTlZlRo0Zx5JFHMmHCBJxzCjjylJmpRkNERLrl5NooZqa2fhERkQKh208RERHJKAUbIiIiklEKNkRERCSjFGyIiIhIRinYEBERkYxSsCEiIiIZpWBDREREMkrBhoiIiGSUgg0RERHJKAUbIiIiklEKNkRERCSjFGyIiIhIRinYEBERkYxSsCEiIiIZlZNLzIuIiHRxzhEMBgmFQgQCAWpqajCzbGdLBkHBhoiI5Ky2tjbq6upoaWnB7/cTiUQoLy+nvr6esrKybGdPkqRmFBERyUnOOerq6giHw0QiEdrb24lEIoTDYRYtWoRzLttZlCQp2BARkZwUDAZpbW0lGo322h6NRmlubiYYDGYpZzJYCjZERCQnhUIhiouL46b5/X5CodAw50iGSsGGiIjkpEAgQCQSiZsWiUQIBALDnCMZKgUbIiKSk2pqaigvL8fn6z2WwefzUVFRQU1NTZZylrucczQ0NLB69WoaGhpypl+LRqOIiEhOMjPq6+v3G41SUVFBfX29hr/2kcsjdyxbUU9paanbvn17Vq4tIiL5Q/NsDMw5R1VVFeFwuFeHWp/PRyAQYNOmTWkrMzN70zlXOqhjFGyIiIjkt4aGBhYuXMjevXv3S/P7/TzxxBPU1tam5VpDCTbUZ0NERCTP5frIHQUbIiIieS7XR+4kFWyY2Rgze8DMmszsFTN7zMwCsbQjzOxRM9tiZq+a2fzMZllERER6yvWRO4Op2bgDmOqcmwU8CPw6tv3HwDPOuaOBi4B7zSx+XY6IiIikXdfIncrKSvx+PyUlJfj9fgKBQE6M3BlSB1Ezmwv8wTk32czagYBz7u1Y2nPA9c65x/s7hzqIioiIpNdwjNwZSgfRoc6zsRx40MwOBYq7Ao2YVmBSnMytAFZ0PT/kkEOGeGkRERGJx8yora1N28iTdBl0B1Ezux4IAN8dzHHOuRudc6Vdj5KSksFeWkRERPLQoIINM7sGOAc4zTn3oXNuJxA1syN77DYZ2Jq+LIqIiEg+SzrYiDWDnA980Tm3u0fS74FlsX2OAz4D/CWNeRQREZE8llSfDTMrBX4ONANPxjqb7HXOHQ9cB/wvM9sCRIAlzrl9GcqviIiI5Jmkgg3n3HYgbndW59w7wKnpzJSIiIgUDq36KjIALQIlIpIaBRsi/cjlJZtFRPKF1kYRScA5R11dHeFwmEgkQnt7O5FIhHA4zKJFi8jWiskiIvlGwYZIAsFgkNbWVqLRaK/t0WiU5uZmgsFglnImIpJfFGyIJJDrSzaLiOQLBRsiCeT6ks0iIvlCwYZIArm+ZLOISL5QsCGSQK4v2Swiki809FWkH2VlZWzevFnzbIiIpMCyNXyvtLTUbd++PSvXFhERKUTDMQmhmb3pnCsdzDGq2RARESkAuTwJofpsiIiI5Llcn4RQwYaIiEiey/VJCBVsiIiI5Llcn4RQwYaIiEiey/VJCBVsiIiI5Llcn4RQwYaIiEiey/VJCDX0VUREpADk8iSEmtRLREREkjaUSb3UjCIiIiIZpWBDREREMkrBhoiIiGSUOoiKDGA4FjYSESlkCjZE+pHLCxuJiOQLNaOIJJDrCxuJiOQLBRsiCeT6wka5yDlHw9YGVjeupmFrgwIyEQGSbEYxs5uBM4EyYLZzrjG2vRXYC3wU2/VHzrn70p9NkeHXtbDR3r1790vrWtiotrY2CznLTW2726i7u46W3S34i/xEOiKUjy2nfkk9ZWPV5CQykiVbs/EHoBZoi5O22DlXHXso0JCCkesLG+US5xx1d9cR3hUm0hGhPdJOpCNCeFeYRfeoyUlkpEsq2HDOPeWc03SfMqLk+sJGuSS4LUjr7lairk+Tk4vS/F4zwW1qchIZydLRZ+N3ZrbRzO40s8PTcD6RnJDrCxvlktCuEMVFxXHT/KP8hHaFhjlHIpJLUh36Ot85t9XMioH/F/gtcHq8Hc1sBbCi6/khhxyS4qVFMi+XFzbKJYHxASIdCZqcOiMExqvJSWQkG9RCbLEOoWd1dRDtk3YU0OScOyiZc2khNpHC4Zyj6pdVhHeFezWl+MxH4NAAmy7fpABNpEAM60JsZvYpMxvbY9P5wMtDPZ+I5C8zo35JPZXjK/EX+SkpLsFf5CdwaID6JWpyEhnpkqrZMLPbgf8BHAnsBN4HTgXWAEWAAc3AcudcazIXVs2GSOFxzhHcFiS0K0RgfICaiWpyEik0Q6nZGFQzSjop2BAREck/Qwk2tDaKyAC0EJuISGoUbIj0QwuxiYikTmujiCTQtRBbKBTqtRBbKBTSQmwiIoOgYEMkgWAwSEtLCx0dHb22d3R0EA6HtRCbiEiSFGyIJLBly5aEa6Ps27ePLVu2DHOORETyk4INkQQ+/PDDlNJFRMSjYEMkgYGGZmvotohIchRsiCQw0PBWDX8VEUmOgg2RBE477bSEaWbWb7qIiHxCwYZIArW1tVRUVMRNq6iooLa2dphzJCKSnxRsiCRgZqxdu5apU6dSVFSEz+ejqKiIY445hrVr16oZRUQkSZpBVGQAzjnMjKKiIjo6Oujs7NSEXok4B8EghEIQCEBNDSgoExnxtBCbSALOOaqqqgiHw0Sj0e7tPp+PQCDApk2bVLvRU1sb1NVBSwv4/RCJQHk51NeDpnYXKRhDWYhNzSgiCQSDQZqbm3sFGgDRaFQziPblnBdohMNekNHe7v0Mh2HRIi9dREYsBRsiCTQ1NbFv3764afv27aOpqWmYc5TDgkFobYU+gRnRKDQ3e+kiQ+Sco6GhgdWrV9PQ0KBmzDykPhsiCbz66qsppY8ooRAUF8Pevfun+f1eukbvyBBo5eXCoJoNkQR27dqVUvqIEgh4zSbxRCJeusggda28HA6He628HA6HtfJynlGwIZLA1q1bU0ofUWpqvM6gvj6VpT4fVFR46SKDFAwGaW1tjdtvqrm5Wf2m8oiCDZEEEvXXSDZ9RDHzRp1UVnrNJiUl3s9AwNuuUTsyBKFQiOLi4rhpfr+fUCg0zDmSoVKfDZEEjjvuOBoaGvpNlx7KymDzZs2zIWkTCASIJGiei0QiBNQ8lzc0z4ZIAh0dHfj6Ngv0EI1GKSoqGsYciYwsmusmN2meDZE0MjNGjYr/Fhk1apQ+5EQyzMyor6+nsrISv99PSUkJfr+fQCBAfX293oN5RM0oIgncdtttdHZ2xk3r7Ozktttu44orrhjmXImMLGVlZWzevJlgMEgoFCIQCFBTU6NAI8+oZkMkgUceeSSldBFJDzOjtraWpUuXUltbq0AjDynYEElg3LhxKaWLiIhHwYZIAhdffHFK6SIi4lGwIZKApisXEUmPpIINM7vZzFrNzJlZdY/tR5vZ02bWZGbPm9n0jOVUZJipz4aISHokW7PxB6AWaOuz/XbgDufcFOAnwOr0ZU0kuzSDqIhIeiQVbDjnnnLO9ZqBy8yOAOYCd8c2rQEmmpmmdJOCcPjhh6eULiIinlT6bEwE/uqciwI4byrSrcCkdGRMJNvefffdlNJFRMQzbB1EzWyFmW3verS3tw/XpUWGpL+pypNJFxERTyrBxjbgKDPzAZg3y8okvNqN/TjnbnTOlXY9SkpKUri0SOZNnTo1pXQREfEMOdhwzu0AXgKWxDZ9CdjunNOav1IQxowZk1K6iIh4kh36eruZbQdKgXoz6wooLgMuM7Mm4DvARZnJpsjwG2hKZE2ZLCKSnGRHo1wWa/7wOecmOOcCse1vOOdOcM5Ncc7Ndc5tzGx2RYbPaaedllK6iIh4NIOoSAK1tbVUVFTETausrKS2tnaYcyQikp8UbIgkYGasXbuWKVOm4PP5GD16ND6fj6lTp7J27Vo1o4iIJElj90T6UVZWxuuvv04wGCQUChEIBKipqVGgISIyCObNxTX8SktL3fbt2wfeUURERHKGmb3pnCsdzDGq2RAZgHNONRsiIilQsCHSj7a2Nurq6mhpacHv9xOJRCgvL6e+vp6ysrJsZ09EJC8UTjOKcxAMQigEgQDU1IDuPhNTeQ3IOUdVVRXhcJhoNNq93efzEQgE2LRpk2o4RGTEGbnNKG1tUFcHLS3g90MkAuXlUF8Puvvcn8orKcFgkNbW1l6BBkA0GqW5uZlgMKjhryIiScj/oa/OeV+c4bD3pdne7v0Mh2HRIi9dPqHySlooFKK4uDhumt/vJxTSzPwiIsnI/2AjGITWVuhz90k0Cs3NXrp8QuWVtEAgQCQSiZsWiUQIBALDnCMRkfyU/8FGKAQJ7j7x+710+YTKK2k1NTWUl5fvt5S8z+ejoqKCmpqaLOVMZGRxztHQ0MDq1atpaGggW30NZejyv89GIOA1A8QTiXjp8gmVV9LMjPr6+v1Go1RUVFBfX6/OoSLDQCPCCkP+j0ZxDqqqvD4HPZsGfD7vi3PTJo2y6EnlNWiaZ0MkOzQiLDcNZTRK/gcbEH90RUWFN7pi0qT0XKOQqLxEJA80NDSwcOFC9u7du1+a3+/niSee0IiwLBi5Q1/LymDzZs0bkSyVl4jkga4RYYmCjVAopGAjTxRGsAHeF2VtrfeQgam8RCTHaURY4cj/0SgiIlKQNCJs8HJ15E7h1GyIiEhB0YiwwcnlkTuF0UFUREQKlkaEDWw4R+6M3NEoIpIT9KUgkh3DOXJn5I5GEZGsy+UqXJFCl+sjd9RBVERS5pyjrq6OcDhMJBKhvb2dSCRCOBxm0aJFOdNJTaRQ5frIHQUbIpKyYDBIa2trr7ZigGg0SnNzM0Et8CeSUbk+ckfBhoikrKsKN56uKlwRyZyukTuVlZX4/X5KSkrw+/0EAoGcGLmjPhsikrJAIBC3rRhg7969Wa/CFRkJysrK2Lx5c0520tZoFBFJWWdnJ2PGjGHfvn37pfn9fj766CNGjVJFqkghGMpoFL37RSRlTz/9dMJOoJ2dnTz99NPDnCMpJLk6K6YkLy3NKGbWCuwFPopt+pFz7r50nFtEcl9TU9N+nUO7RKNRmpqatGCWDImGVA9Ors51k84+G4udc41pPJ+I5IlXX301pXSReHoOqY5Go91DO7uGVKdzVsxCkMuBmZpRRCRle/bsSSldJB4NqU5ers91k85g43dmttHM7jSzw9N4XhHJcXPmzEkpXSQeDalOXq4HZukKNuY752YCc4C/Ab/tu4OZrTCz7V2P9vb2NF1aRLJtxowZKaWLxJPrs2LmklwPzNISbDjntsZ+7gNuAk6Ks8+NzrnSrkdJSUk6Li0iOaC5uZnRo0fHTRs9ejTNzc3DnCMpBLk+K2YuyfXALOVgw8w+ZWZje2w6H3g51fOKSP6orKzsd1KvysrKYc6RFIJcnxUzl+R6YJaO0SgTgDVmVgQY0AxcmIbzikieGKjzWbY7p0n+yuVZMXNJV2DWdzRKRUVFTgRmKQcbzrlmYHYa8iLDyDlHcFuQ0K4QgfEBaibqzStD9+ijjw6YPn/+/GHKjRQaM6O2tlZztQwglwMzrY0yArXtbqPu7jpadrfgL/IT6YhQPrac+iX1lI3VJDkyeNu2bUspXUTSI1cDM82zMcI456i7u47wrjCRjgjtkXYiHRHCu8Isuif7Y7ElP336059OKV1ECpuCjREmuC1I6+5Woq7PWGwXpfm9ZoLbNEmODF6iXvDJpotIYVOwMcKEdoUoLkowFnuUn9AuTZIjg9fU1JRSuogUNvXZGGEC4wNEOhKMxe6MEBivSXJk8MLhcErpIv1yDoJBCIUgEICaGsiBTo85KUfLSsHGCFMzsYbyseWEd4V7NaX4zEfFuApqJmqSHBk8rY0yBDn6pZBz2tqgrg5aWsDvh0gEysuhvh606mtvOVxWakYZYcyM+iX1VI6vxF/kp6S4BH+Rn8ChAeqXZH8stuSnQw89NKX0EaetDVdVRecpp7Dv8mV0nnIKrqrK+7KQTzjnfXmGw94XZ3u79zMchkWLvHTx5HhZqWZjBCobW8bmKzZrng1Jm4ULF/Laa6/1my4xzrHvi6dAuJniThi1z9u8b8sbuC8uwP/GFtVwdAkGobUV+iwuRjQKzc1eeo4N8cyaHC8r1WyMUGZG7aRallYvpXZSrQKNfjjnaGhoYPXq1TQ0NGh4cBwzZ85MKX0kcQ0NuJYWijt7by/uBJqbcQ0NWclXTgqFIMHiYvj9Xrp4crysCibY6OjoYMWKFcyfP58VK1bQ0dGR7SxJAWhra6OqqooFCxbwzW9+kwULFlBVVUWbqrt7GWiRp2wvApVLtjz3CHtHxQ9Y9xY5tjz3yDDnKIcFAl5TQDyRiJcunhwvq4IINtasWYPP52PlypWsX7+elStX4vP5WLNmTbazJnnMOUddXR3hcJhIJEJ7ezuRSIRwOMyiRZoAracNGzaklD6ShMaDP8G9kL/DS5eYmhqvg2OfxcXw+aCiwksXT46XVd4HGx0dHZx77rnek0lAdewncO6556qGQ4YsGAzS2tpKtE8baDQapbm5mWBQE6B1SWZtFPEcfMpptIyDfX1aLvcZtIzz0iXGzBtJUVnpNQWUlHg/AwFvu5p/P5HjZZX3HUSvueYaOARYAowDOoAi4D3gbi995cqV2cyi5KlQKERxcXHcpdP9fj+hUCjn1h/IlrFjx6aUPpLUTKplwTcr+P9uaab8PYiMAn8nNI+DK66q5IlJek31UlYGmzdrmHAycris8j7YePChB71AYzxekNH1F40HlnjpCjZkKAKBQMJptiORiPoh9HDYYYellD6SmBm/uWotdeNO5agNzUx9r4g3xnXw9qxK6i/4szprx2PmjaRQcD+wHC2rvG9G+eiwj7wajaI+CUXAuFi67CcajbJ48WKmTp3K4sWL92sqEKipqaG8vBxfnzZQn89HRUUFNWov7qbpygenbGwZm67YzD/+wy+InryEf/yHX/Da5ZuYdMikbGdNJCPyPtgYVznOazqJpyOWLr2sWrWK4uJi7r//fpqamrj//vspLi5m1apV2c5aTjEz6uvrqaysxO/3U1JSgt/vJxAIUF+vCdB6GihYVTDbW1tbG9OmTePqL13Nfd+9j6u/dDXTpk3TKCcpWHkfbLRvbd+/VqNLUSxdukWjUb7xjW/ETfvGN76hL4U+ysrK2LRpEytXrmTx4sWsXLmS1157jUmTdAcqQ6NRTjIS5X2wsefVPV5n0L61Gx3Ae7F06Xb++eenlD7SdN+BXn019913H1dfrTvQeIoTTSaUZPpIolFOMhLlfbDhK/LB3cAuIArsjf3cBdwdS5duDz74YErpI4nuQJN3+umnp5Q+knSNcoqna5STSKHJ+2DjoIMOgj3AL4HfAY/Efv4S2BNLl2779u1LKX0k0R1o8r7xjW8k/AItLi5O2HQ3EmmUk4xEeR9sfPRRj9EmW4HG2M946SKDoDvQ5I0aNYonn3xyv/Ly+/385S9/YdSovP+oSZuamhpKS0vjpk2cOFGjnKQg5X0bg+7UJVMCgQAff/xx3LSPP/5Yd6B91NTU8PHHH7Nq1Speeukl5syZw7JlyxRoxJHoc0mfV1KoLFvtzqWlpW779u0pn2fatGls3rw5YXpVVRWbNm1K+TqFIpnhmuqL4Ono6Nhvjo2eotEoRUWJhkKJxLd+/Xrmz5+fMP2pp57ipJNOGsYciQyOmb3pnItfPZdA3t9yXHbZZSmliyRy++23p5QuEs8jj/S/qutA6SL5KO+DjYGqaFWFK0P17LPPppQ+EjnnaGhoYPXq1TQ0NKiWTESAAgg26uvrU0ofaSorK1NKH0kGGm2i0Si9tbW1MXXqVE4++WQuueQSTj75ZKZOnao5Sfr4zGc+k1K6SD7K+2Bj3Lj+pyMfKH2kufzyy1NKH0kG+pLUl+gnnHOcdNJJbNmyhY6ODqLRKB0dHWzZsoX58+erhqOHAw88MKV0kXyUlmDDzI42s6fNrMnMnjez6ek4bzLmzZuXUvpI8+ijj6aUPpJovY/krV+/nm3btsVN27p1K+vXrx/mHOWugUYxaZSTFKJ01WzcDtzhnJsC/ARYnabzDujFF19MKX2keeyxx1JKF4nnpz/9aUrpI02iUWFa3E8KVcrBhpkdAczFmzQcYA0w0cyGJTz/7W9/m1K6iKTu4YcfTil9JAmHwxxwwAFx0w444ADC4fAw50gk89JRszER+KtzLgrgvMbZrUCvZTHNbIWZbe96tLdrNVbJbWpbl0wIBAIJm+Ci0aiaUaQgDVsHUefcjc650q5HSUnJcF1aZEguvvjilNJF4qmpqaG8vHy/CeN8Ph8VFRWarlwKUjqCjW3AUWbmAzCv0XESvVYoyZy33norpfSR5qWXXkopfSRZuXJlSukjyTvvvJNS+khiZtTX11NZWYnf76ekpAS/308gEKC+vl79NqQgpWW6cjNbB6x2zq02s3OB7zjn5vZ3TLqmKwcYPXp03FUUR48enXBti5Gsvw8zDVHsbc2aNZx77rn7bf/jH//I2WefnYUc5a6SkhI++OCD/bYfdNBB/P3vf89CjnKbc45gMEgoFCIQCFBTU6NAQ/LCUKYrT1ewMRVvBMqhwN+Bi5xzG/s7Jp3BBsBf//pXPv3pT3c/f+uttzjqqKPSdv5C8/LLLzNnzpzu5y+99BKzZ8/OYo5yV0dHB9deey0vvPACc+fO5YYbbtCaKAns2LGDCRMmdD9/5513OOKII7KYIxFJt6wFG0OR7mBDREREMm9ELsQmIiIiuU3BhoiIiGSUgg0RERHJKAUbIiIiklEKNkRERCSjsjYaxcz2Au9m4NQlgOZCT57KK3kqq+SprJKnskqeyip5mSyrw51zowdzQNaCjUwxs+2DHZIzkqm8kqeySp7KKnkqq+SprJKXa2WlZhQRERHJKAUbIiIiklGFGGzcmO0M5BmVV/JUVslTWSVPZZU8lVXycqqsCq7PhoiIiOSWQqzZEBERkRyiYENEREQySsGGiIgUBDP7n2Y2ps/zd82sMfa4p0faKDO7xczCZhYysyuzk+vhEads/oeZvWhme83spj77Jiyb/o7rT14FG2bWambVsd9/bWZfSOFczszGpitvuUplNjhmdqaZrYz9PtnMliVxzMlm1pjxzGWJmf0tVhZ/MrOpGTh/QZdfpvX9Eulnv2F//5qZbzivB/w/QN+yuMc5Vx17fLXH9iXANGAKMA+41symD1M+c6FstgBfB26Is29/ZdPfcQnlVbDRk3Pun5xzT2Y7H/lEZTYw59xDzrmrY08nAwMGGyOFc+5059wb2c6H7CfeF2zWxIKafzWz54EfmdlBZvYrM3vOzDaY2R1m5o/t+z0z29yj5qGsxzmujx3TYmYX9Tj/0Wb2sJk9HzvflbHtq2K7rI+d64gBsroY+JVzrsM5twu4Dzg/3eXRUy6VjXOuyTn3ChCNk9WEZTPAcQnlbLBhZieYWYOZvRIrtH/ok77OzM6K/b7azO4ys6fNrMnMfmtmByRxmWvM7OXYMV8dePfcNkxlVhDM7P82s1t7PC8xs11mdq2ZPRDbvAqYGntzPjTAKX1m9jsze9W8KsbqDGU942K1O5tjr6Gf9tjes5ZsnZn9zMzWm1fVuqrHfkeY2R/NbGOsPC5L4rJZL7947x8zmxt7j2yIfbjXxPadbGa7Y18cL5pX1Xx6LC3Ra+twM1tqZo+b2X/EyucFM6vose8FZvasmb1kZk+Z2SzzqrQfNbNrYvtUmtl2M5sa70tkgD9zuD7zOpxzxznnrgV+Dqx3zs0DZuF97yw3s3HANcAc51w1cCLwTo9z7I0dcxpws5n5zKwI+A/gW86544DPAZea2XHOua4bg5NitRg7Ys//MfY/XWu9a3YnAW09nrfGtmVaLpVNIukvG+dczj2A8bGCPSn2fFRsWytQHdu2Djgr9vtq4DXgIKAI+C/g+gGu4YB/j/1eAewCJmf7b8+DMhub7b81TeU1EdgBjI49vwhYAywFHohtOxloTOJcJ8fKZkHs+XnA68SGlufTAzgC2AlMiz2/NPa3TY7zWvrfgA84AGgBToil3Qf8qMf5tgGfy+XyS/D+OQLYCtTFttUCb+OtOTE5lucvxdIWAW/099qK/b4U2AOUx57/GLg99nsN8Kcex50EvBb7/bBYGZ8MvAic3yPvSb0vGabPvNh1Sns83wFsBBpjjzeA2/E+d56Pve8u63OMA47s8fw9oBSvav+jHudqjJXL1+KVBXAkUNyjfHcAZbHnG7tes7HnlwO/y/DrLGfKpsfx/xO4qc+2Acsm3nH9PXK1ZuMEvDfuegDnXKfzqnL6c79z7n3nXAdwJ7Awiev8Onb+ZuApYH4Kec624SqzguCc2wa8DJwZ27QU+E0Kp2x1zj0RO/f9eB9yE1PJY5Z8DtjgnNsUe34nEEmw733OuahzrusDrjK2fSHeBybOu4P6IwO/trJdfvu9f4AJQKdzrj62rQEvIKmOHfMx3t8G8N/E/v4kXlv/7Zxr6Xsc8A94d7fPmteH5RZgvJkd4Jz7G147+p+BF51z/zHEv3O4PvN6LgBmeEFZdewx1Tl3Wexz53PATXiB3TNmdlKP4z7u8XsHXmBrwK4e56p2zpU7534bLxPOubedc/tivwfx/i9zY8lbgbIeu0+Obcu0nCibAaS9bHI12EiHocxWNtJnOBtpf/9dwEWxauwA8Ggaz+0ojPLs72+I94E32HP0d91cLL+eedrrYrd4eH9/UY+0/l5bicrNgN/2+bI4KhbMAczGq3X6jJlZBv6eTHkAuM5iHSLNbJyZBczsIGCCc269c+7fgQa8v7E/bwB/t979FAJmNj729H3gkB5ppT1+PxovUNwY2/R74BIzK4odvxivVm44PUCWymYAaS+bXA02ngaO7orkYm2W4wc45txY22gRXrXl40lc56LY+SfjVVmuH3qWs264yqyQPAAcB3wXuNs517fD099J/s05uas92MzOxbsD3p6mfA6n/wZmmtkxsedfB/yDPMfjwCUAZnY4cA7w2ADHZLv89nv/xPIwysy+GNt2Il6NS2MS53uA/l9b8TwELDGzSV15MLO5sd/n4LXhd33hfLvHcYP5EsnGZ97VxKr3zWwD8ATenfIhQFffng1AMdDvXXisHM8Azon1o3kNr/atq7/Zz4HHevRf+UGsH1Aj8J/AFc65pti+/wuvuW4LXpPFjc65jQyvrJWNmS0ws+3ACuDiWD+grtq4hGUzwHEJDffQm6Q4594zs7OBn8civE7gXwY47HmgHjgc7wPzpiQuVWRmLwOfAq5yzrUOOdNZNoxlVjCcc3vN7H689siqOLtsAF4zs1eBZudcf2+o14ClZnYzXrPD+T3uevOGc+5dM/s68L/NLIJ3R75zkKe5CrjNzDbi3a3/wDn37ADHZLX8+nn/nIPXAe/neDUS5zrn2s3ssAHON9BrK94x683s23hl78ML8h42sya8L8qvO+feNrMLgefMrCHWNND1JfIhcKrrv/Nfxj/znHPW53k7kGgOi88leY7DevweBv6vBMf9K/CvPTZ9rZ98dgBXJErPhBwrmyfw+nrE2zdh2cSaOwe9dH1BrI1iZqvxOvLdlOWs5A2VmYiIDJdcbUYRERGRAlEQNRuJxMagx6uKOqFHpyvpQWWWmJm9wP5Nj6+53rMSSgIqv8zT+1dyVUEHGyIiIpJ9akYRERGRjFKwISIiIhmlYENEREQySsGGiIiIZJSCDREREckoBRsiIiKSUf8H6HtuSmYdC94AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "domainnet\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def filter_df_get_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_norm(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_normalized_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " filtered_d = df[filtered_keys].to_dict(orient='records')[0]\n", + " norm_d = df[norm_keys].to_dict(orient='records')[0]\n", + " normalized_grad_d = {}\n", + " for fk, nk in zip(filtered_keys, norm_keys):\n", + " normalized_grad_d[fk] = filtered_d[fk] / norm_d[nk]\n", + " return normalized_grad_d\n", + "\n", + "# def filter_df_get_norm_grad(df):\n", + "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad' in s]\n", + "# print(filtered_keys)\n", + "# return df[filtered_keys] \n", + "\n", + "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", + " dataset_stats = {}\n", + " for dataset in datasets:\n", + " print(dataset)\n", + " figure(figsize=(8, 4), dpi=80)\n", + " for model_idx, model in enumerate(models):\n", + " dir_path = get_dir_path(dataset, model)\n", + " config_path = get_config_path(dir_path)\n", + " stats_path = get_stats_path(dir_path)\n", + " with open(config_path, 'r') as f:\n", + " config = json.load(f)\n", + " train_data = utils.init_dataset(config['train_dataset'])\n", + " if model_idx == 1:\n", + " random_images = get_random_images(train_data,n=10)\n", + " dataset_stats[dataset] = {\n", + " 'mean': np.mean(random_images),\n", + " 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", + " 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", + " }\n", + " df = pd.read_csv(stats_path, sep='\\t')\n", + " d = filter_df(df)\n", + " values = list(d.values())\n", + " if model_idx == 1:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers')\n", + " plt.scatter([model_idx], values[-1], c='green', label='last layer')\n", + " plt.scatter([model_idx], values[0], c='red', label='first layer')\n", + " else:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black')\n", + " plt.scatter([model_idx], values[-1], c='green')\n", + " plt.scatter([model_idx], values[0], c='red')\n", + " my_xticks = ['John','Arnold','Mavis','Matt']\n", + " plt.legend()\n", + " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", + "\n", + " plt.show()\n", + "# print(d.values())\n", + "# print(filtered_keys)\n", + "# print(df['train/grad_patch_embed'])\n", + "# print(df[filtered_keys])\n", + "# print(df[compute_keys(df)])\n", + " return dataset_stats\n", + "\n", + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'living17_nonorm': {'mean': 0.405586, 'std': 0.19588944, 'std_mean': 0.105948165}, 'waterbirds': {'mean': 0.37670943, 'std': 0.22946799, 'std_mean': 0.11904866}, 'domainnet': {'mean': 0.8599936, 'std': 0.1735559, 'std_mean': 0.15381968}}\n" + ] + } + ], + "source": [ + "print(dataset_stats)\n", + "# The std-devs within the image, and the std devs of the mean, are pretty similar (and small).\n", + "# So it's really the mean that varies a lot.\n", + "# I think the \"obvious\" thing to do is to normalize the images to have the same mean, std-dev\n", + "# Let's check this and see what the gradients look like if we do this." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Loop over datasets\n", + " # Loop over models\n", + " # Get folder name\n", + " # Get gradient stats\n", + " # Compute relevant stats. E.g., for transformer models combine blocks?\n", + " # Plot stats. Can start by just plotting first layer and some in between layer for every model?\n", + " # For the first model, load config. Load dataset.\n", + " # Sample random images. Get image mean. Std-dev within a single image. Variance of the mean across images." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb deleted file mode 100644 index 17fe75a..0000000 --- a/scripts/fine-tuning-results.ipynb +++ /dev/null @@ -1,348 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "import summarize_all_results\n", - "import importlib\n", - "importlib.reload(summarize_all_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", - " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " cur_results = []\n", - " for dataset_idx, dataset in enumerate(datasets):\n", - " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", - " output_metrics = output_metrics_list[dataset_idx]\n", - " if val_metric_list is None:\n", - " val_metric = 'LAST'\n", - " else:\n", - " val_metric = val_metric_list[dataset_idx]\n", - " if aggregation_metric_list is None:\n", - " agg_metric = val_metric\n", - " else:\n", - " agg_metric = aggregation_metric_list[dataset_idx]\n", - " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", - " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", - " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", - " cur_results = np.concatenate(cur_results)\n", - " table[model_idx][option_idx] = cur_results\n", - " return table\n", - "\n", - "# Add table to make TSV and Latex tables.\n", - "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", - " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", - " print(first_line)\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " line = model + '\\t' + option\n", - " for idx, val in enumerate(table[model_idx][option_idx]):\n", - " line += '\\t' + '{:.1f}'.format(val)\n", - " if std_err_table is not None:\n", - " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", - " print(line)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "log_dir = '../logs/'\n", - "name_template = 'full_ft_{option}{dataset}_{model}'\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['LAST', 'LAST', 'LAST']\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", - "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", - "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", - "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", - "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", - "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", - "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", - "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", - "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", - "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", - "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" - ] - } - ], - "source": [ - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", - "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", - "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", - "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", - "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", - "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", - "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", - "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", - "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" - ] - } - ], - "source": [ - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" - ] - } - ], - "source": [ - "# LAMB and LARS results for CLIP ViT-B/16\n", - "models = ['clip_vit_b16']\n", - "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['Lamb', 'LARS']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[97.026]], dtype=object)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "best_row_mean.to_numpy()[:,:-2]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" - ] - } - ], - "source": [ - "# CLIP results including all optimizers and and layerwise method.\n", - "models = ['clip_vit_b16']\n", - "# \n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" - ] - } - ], - "source": [ - "# CLIP results including wilds datasets\n", - "models = ['clip_vit_b16']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb new file mode 100644 index 0000000..c317685 --- /dev/null +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "import math\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "\n", + "# TODOs:\n", + "# Get mean and std (done)\n", + "# Filter out for ID and OOD columns (done)\n", + "# Add an overall average column\n", + "\n", + "# Print some nice Latex tables (done)\n", + "# Bold the best numbers within confidence intervals, in the latex table\n", + "\n", + "def get_bolds(table, std_err_table=None, eps=0.2):\n", + " is_best = np.zeros((len(table), len(table[0])), dtype=np.int32)\n", + " for col in range(len(table[0])):\n", + " best_idx = np.argmax(table[:,col])\n", + " best_acc = table[best_idx][col]\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " best_std = std_err_table[best_idx][col]\n", + " if math.isnan(best_std):\n", + " best_std = eps\n", + " for row in range(len(table)):\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " cur_std = std_err_table[row][col]\n", + " if math.isnan(cur_std):\n", + " cur_std = eps\n", + " if np.abs(table[row][col] - best_acc) <= max(best_std, cur_std):\n", + " is_best[row][col] = 1\n", + " else:\n", + " if table[row][col] >= best_acc - eps:\n", + " is_best[row][col] = 1\n", + " return is_best\n", + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None,\n", + " aggregation_metric_list=None, num_sweep=6, desired_epochs_list=None):\n", + " # desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\n", + " # supposed to have run each dataset for. Used to validate if the runs finished.\n", + " mean_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " std_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_means = []\n", + " cur_stds = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " num_jobs = len(res)\n", + " if (desired_epochs_list is not None and\n", + " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + " bad_indices = np.argwhere(np.array(num_epochs_list) < desired_epochs_list[dataset_idx])\n", + " bad_runs = [dir_path + '/' + run_folder for run_folder in res['name'][bad_indices[:, 0]]]\n", + " print('some jobs did not finish: ', model, dataset, option, bad_runs)\n", + " if num_jobs != num_sweep and num_jobs != num_sweep * 3:\n", + " print('not all jobs ran: ', model, option, dataset, num_jobs)\n", + " cur_means.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_stds.append(best_row_std.to_numpy()[0,:-2])\n", + " cur_means = np.concatenate(cur_means)\n", + " cur_stds = np.concatenate(cur_stds)\n", + " mean_table[model_idx][option_idx] = cur_means\n", + " std_table[model_idx][option_idx] = cur_stds\n", + " return mean_table, std_table\n", + "\n", + "def flatten(list_of_lists):\n", + " x = []\n", + " for l in list_of_lists:\n", + " x.append(l)\n", + " return x\n", + "\n", + "def filter_columns(table, old_output_metrics_list, new_output_metrics_list):\n", + " def get_indices(old_list, new_items):\n", + " return np.array([old_list.index(x) for x in new_items])\n", + " local_indices_list = [get_indices(o, n) for o, n in zip(old_output_metrics_list, new_output_metrics_list)]\n", + "# print(local_indices_list)\n", + " old_lens = [len(o) for o in old_output_metrics_list]\n", + " cum_old_lens = np.concatenate([[0], np.cumsum(old_lens)])[:-1]\n", + "# print(cum_old_lens)\n", + " global_indices = [local_indices + cum_old_len for local_indices, cum_old_len in zip(local_indices_list, cum_old_lens)]\n", + "# print(list(np.concatenate(global_indices)))\n", + " return table[:, :, global_indices][:,:,:,0]\n", + "\n", + "\n", + "# Add table to make TSV and Latex tables. Add averages.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " print(line)\n", + " \n", + "def add_average_column(table):\n", + " new_table = []\n", + " for model_idx in range(len(table)):\n", + " model_table = table[model_idx]\n", + " means = np.mean(model_table, axis=1)\n", + " new_model_table = np.concatenate([model_table, np.expand_dims(means, axis=-1)], axis=-1)\n", + " new_table.append(new_model_table)\n", + " return np.array(new_table)\n", + " \n", + "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True):\n", + "\n", + " # Print latex table.\n", + " if len(models) == 1:\n", + " num_columns = len(shortened_output_metrics_list) + 1\n", + " else:\n", + " num_columns = len(shortened_output_metrics_list) + 2\n", + " if is_last_avg:\n", + " print('\\\\begin{tabular}{' + ('c'*(num_columns-1)) + '|c}')\n", + " else:\n", + " print('\\\\begin{tabular}{' + ('c'*num_columns) + '}')\n", + " print('\\\\toprule')\n", + " first_line = ' & ' + ' & '.join(shortened_output_metrics_list) + '\\\\\\\\'\n", + " if len(models) > 1:\n", + " first_line = ' & ' + first_line\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " print('\\\\midrule')\n", + " if std_err_table is None:\n", + " is_bold = get_bolds(table[model_idx], eps=0.2)\n", + " else:\n", + " is_bold = get_bolds(table[model_idx], std_err_table[model_idx], eps=0.2)\n", + " for option_idx, option in enumerate(options):\n", + " if len(models) > 1:\n", + " line = model + ' & ' + option\n", + " else:\n", + " line = option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += ' & '\n", + "# print(is_bold[option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '\\\\textbf{'\n", + " line += '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx]) and\n", + " not math.isnan(std_err_table[model_idx][option_idx][idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '}'\n", + " line += '\\\\\\\\'\n", + " print(line)\n", + " print('\\\\bottomrule')\n", + " print('\\\\end{tabular}')\n", + " \n", + " \n", + "def display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", + " # Filter the ID and OOD metrics.\n", + " print('\\n\\nID Accuracies')\n", + " id_mean_table = filter_columns(mean_table, output_metrics_list, id_output_metrics_list)\n", + " id_mean_table = add_average_column(id_mean_table)\n", + " id_std_table = filter_columns(std_table, output_metrics_list, id_output_metrics_list)\n", + " if no_std:\n", + " id_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table, is_last_avg=True)\n", + "\n", + " print('\\n\\nOOD Accuracies')\n", + " ood_mean_table = filter_columns(mean_table, output_metrics_list, ood_output_metrics_list)\n", + " ood_mean_table = add_average_column(ood_mean_table)\n", + " ood_std_table = filter_columns(std_table, output_metrics_list, ood_output_metrics_list)\n", + " if no_std:\n", + " ood_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table, is_last_avg=True)\n", + " return id_mean_table, ood_mean_table\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.concatenate([[0], np.array([1,2,3])])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "some jobs did not finish: timm_vit_b16_in21k domainnet freeze_bottom_2_opt_torch.optim.AdamW_ ['../logs//full_ft_freeze_bottom_2_opt_torch.optim.AdamW_domainnet_timm_vit_b16_in21k/freeze_bottom_k-2_optimizer.args.lr-3e-06_seed-0_run0']\n", + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.7\t81.0\t97.0\t64.6\t87.4\t69.5\n", + "CLIP ViT-B/16\tAdamW\t97.9\t83.5\t97.7\t71.1\t94.9\t89.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t81.9\t97.8\t74.3\t94.6\t87.9\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 ID & Living-17 OOD & Waterbirds ID & Waterbirds OOD & DomainNet ID & DomainNet OOD\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.7 & 81.0 & 97.0 & 64.6 & 87.4 & 69.5\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{97.9} & \\textbf{83.5} & \\textbf{97.7} & 71.1 & \\textbf{94.9} & 89.3\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.0} & 81.9 & \\textbf{97.8} & \\textbf{74.3} & 94.6 & 87.9\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.1} & 82.6 & \\textbf{97.8} & 69.2 & \\textbf{94.8} & \\textbf{89.8}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.5} & \\textbf{89.4} & \\textbf{99.0} & 78.7 & \\textbf{91.5} & \\textbf{86.7}\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.6} & 87.9 & 98.9 & 80.1 & \\textbf{91.5} & 84.4\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{89.5} & \\textbf{99.2} & \\textbf{82.4} & \\textbf{91.5} & 86.3\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.5} & 88.4 & 99.0 & \\textbf{82.4} & 90.8 & 82.6\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & \\textbf{88.2} & 97.0 & 55.6 & 88.0 & 76.2\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.4} & 87.5 & \\textbf{97.9} & 61.2 & 89.1 & 77.5\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.3} & 87.6 & 97.5 & \\textbf{68.5} & 88.9 & \\textbf{78.9}\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & 86.7 & 97.6 & 61.5 & \\textbf{89.6} & 76.4\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{97.3} & \\textbf{85.7} & \\textbf{98.4} & 75.2 & \\textbf{89.0} & 80.9\\\\\n", + "BIT ResNet-50 & AdamW & 97.1 & 83.2 & \\textbf{98.3} & 76.9 & \\textbf{89.2} & \\textbf{84.0}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.5} & 84.4 & \\textbf{98.5} & 75.5 & \\textbf{89.0} & 82.4\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & 83.6 & \\textbf{98.4} & \\textbf{78.5} & \\textbf{89.0} & 83.5\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.2} & 82.2 & \\textbf{98.9} & 79.0 & \\textbf{91.8} & \\textbf{86.0}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.2} & 84.5 & 98.6 & \\textbf{79.4} & 91.0 & 83.7\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{84.9} & \\textbf{98.8} & 78.7 & 91.4 & \\textbf{85.9}\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.1} & 84.1 & 98.7 & 72.0 & 90.6 & 83.9\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.5} & \\textbf{92.1} & 99.0 & 81.3 & 94.6 & 89.8\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & 90.1 & \\textbf{99.4} & 85.8 & 94.0 & 89.9\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.5} & 91.5 & \\textbf{99.3} & \\textbf{88.0} & \\textbf{94.8} & \\textbf{91.5}\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.6} & 89.8 & \\textbf{99.3} & 87.7 & 94.5 & 91.0\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.3 & 84.9 & 96.3 & 56.7 & 84.1 & 60.9\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & 88.4 & \\textbf{98.7} & 86.0 & 96.6 & \\textbf{93.8}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & 98.6 & \\textbf{89.4} & \\textbf{98.7} & 84.9 & \\textbf{96.8} & \\textbf{93.9}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & 98.6 & 88.2 & \\textbf{98.6} & \\textbf{87.5} & \\textbf{96.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (LAST)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "desired_epochs_list = [20, 20, 50]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)\n", + "display_latex_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t80.0\t97.2\t62.5\t87.6\t69.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t82.8\t97.7\t71.9\t95.0\t89.2\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t83.2\t97.8\t73.7\t94.9\t88.2\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (Early stopped)\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t87.6\t67.0\t99.4\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 87.6 & 67.0 & \\textbf{99.4} & 89.8\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & \\textbf{95.0} & \\textbf{70.1} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & \\textbf{94.9} & \\textbf{70.0} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & \\textbf{66.4} & \\textbf{99.5} & \\textbf{91.1}\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & \\textbf{89.4} & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", + "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & \\textbf{68.8} & \\textbf{99.7} & \\textbf{92.2}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & \\textbf{92.0}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t69.6\t37.3\t86.8\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 69.6 & 37.3 & 86.8 & 67.2\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & \\textbf{95.7} & \\textbf{76.0}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & \\textbf{91.9} & 70.7\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{84.3} & \\textbf{76.5} & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", + "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & \\textbf{35.0} & \\textbf{95.2} & \\textbf{74.4}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{82.9} & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{83.1} & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & \\textbf{75.6}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & \\textbf{39.7} & 83.0 & 77.3\\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\textbf{89.8} & 89.5 & 38.4 & \\textbf{89.5} & \\textbf{79.5}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & \\textbf{79.4}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.2243181 91.46286571 91.27799905]\n", + "[71.87552286 76.03873524 76.73786476]\n" + ] + } + ], + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIP results including wilds datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t87.6 (6.4)\t67.0 (0.8)\t99.4 (0.0)\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & 92.1\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & 92.1\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", + "LAMB & 98.2 & 97.8 & 95.1 & 67.9 & 99.5 & 91.7\\\\\n", + "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t69.6 (16.0)\t37.3 (1.1)\t86.8 (1.1)\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & 76.0\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", + "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", + "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", + "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 waterbirds freeze_bottom_2_full_ft_epoch_50_ []\n", + "not all jobs ran: clip_vit_b16 freeze_bottom_2_full_ft_epoch_50_ waterbirds 7\n", + "empty dir ../older_logs//full_ft_freeze_bottom_5_full_ft_epoch_50_waterbirds_clip_vit_b16\n" + ] + }, + { + "ename": "TypeError", + "evalue": "object of type 'NoneType' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# desired_epochs_list = [20, 20, 50, 5, 3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../older_logs/'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-embed)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Layer-wise'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LAMB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LARS'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 54\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 55\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 58\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" + ] + } + ], + "source": [ + "# Get table for dino and clip, freezing different number of layers.\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['freeze_bottom_2_full_ft_epoch_50_', 'freeze_bottom_5_full_ft_epoch_50_', 'freeze_bottom_8_full_ft_epoch_50_', 'freeze_bottom_11_full_ft_epoch_50_', 'freeze_bottom_14_full_ft_epoch_50_']\n", + "val_metric_list = ['WATERBIRDS_VAL']\n", + "datasets = ['waterbirds']\n", + "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", + "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "# desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table('../older_logs/', name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fmow_waterbirds_examples.ipynb b/scripts/imagenet_fmow_waterbirds_examples.ipynb similarity index 98% rename from scripts/fmow_waterbirds_examples.ipynb rename to scripts/imagenet_fmow_waterbirds_examples.ipynb index 86576a2..9b6bef5 100644 --- a/scripts/fmow_waterbirds_examples.ipynb +++ b/scripts/imagenet_fmow_waterbirds_examples.ipynb @@ -28,6 +28,22 @@ "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ImageNet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -74,18 +90,79 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "train_transform = transforms.Compose([\n", - " transforms.Resize(size=224)\n", + " transforms.Resize(size=224),\n", + " transforms.ToTensor()\n", "])\n", "root = '/u/scr/nlp/wilds/data' # For NLP cluster.\n", "# root = '/home/t-anakumar/wilds/data/' # For microsoft sandbox.\n", "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root=root, transform=train_transform, return_meta=True)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.6039216 , 0.6039216 , 0.6 , ..., 0.30980393,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.6039216 , 0.6039216 , 0.6039216 , ..., 0.3137255 ,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.60784316, 0.6039216 , 0.6039216 , ..., 0.31764707,\n", + " 0.31764707, 0.31764707],\n", + " ...,\n", + " [0.3019608 , 0.3019608 , 0.29803923, ..., 0.7058824 ,\n", + " 0.6901961 , 0.6901961 ],\n", + " [0.29411766, 0.29803923, 0.29803923, ..., 0.7058824 ,\n", + " 0.7019608 , 0.69411767],\n", + " [0.28627452, 0.2901961 , 0.29411766, ..., 0.6745098 ,\n", + " 0.67058825, 0.67058825]],\n", + "\n", + " [[0.69803923, 0.69803923, 0.69411767, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.69803923, 0.69803923, 0.69803923, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.7019608 , 0.69803923, 0.69803923, ..., 0.42745098,\n", + " 0.42745098, 0.42745098],\n", + " ...,\n", + " [0.38039216, 0.38039216, 0.3764706 , ..., 0.627451 ,\n", + " 0.6117647 , 0.6117647 ],\n", + " [0.37254903, 0.3764706 , 0.3764706 , ..., 0.627451 ,\n", + " 0.62352943, 0.6156863 ],\n", + " [0.3647059 , 0.36862746, 0.37254903, ..., 0.59607846,\n", + " 0.5921569 , 0.5921569 ]],\n", + "\n", + " [[0.8862745 , 0.8862745 , 0.88235295, ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8862745 , 0.8862745 , 0.8862745 , ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8901961 , 0.8862745 , 0.8862745 , ..., 0.6745098 ,\n", + " 0.6745098 , 0.6745098 ],\n", + " ...,\n", + " [0.3372549 , 0.3372549 , 0.33333334, ..., 0.61960787,\n", + " 0.6039216 , 0.6039216 ],\n", + " [0.32941177, 0.33333334, 0.33333334, ..., 0.62352943,\n", + " 0.61960787, 0.6117647 ],\n", + " [0.32156864, 0.3254902 , 0.32941177, ..., 0.5921569 ,\n", + " 0.5882353 , 0.5882353 ]]], dtype=float32)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(waterbirds_train[0][0])" + ] + }, { "cell_type": "code", "execution_count": 49, diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb similarity index 72% rename from scripts/load_models_get_layers.ipynb rename to scripts/load_models_test_get_layers_gradients.ipynb index beceb6e..c2f9663 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -1,32 +1,21 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", "import timm\n", "import torch\n", + "from torch import nn\n", "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", - "importlib.reload(timm_model)" + "importlib.reload(timm_model)\n", + "importlib.reload(clip_model)" ] }, { @@ -49,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -62,6 +51,184 @@ " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing layer norm" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.4242, grad_fn=)\n", + "tensor([[ 0.0140, 0.0559, 0.0699],\n", + " [-0.0701, -0.2804, -0.3505],\n", + " [ 0.0561, 0.2245, 0.2806]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)*0.1\n", + "x = torch.tensor(data)\n", + "layer_norm = nn.LayerNorm(len(data), elementwise_affine=False)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "output = layer_norm(torch.matmul(A, x))\n", + "loss = torch.dot(torch.tensor([0.1, 0.2, 0.5]), output) # torch.sum(torch.square(output))\n", + "loss.backward()\n", + "print(loss)\n", + "print(A.grad)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-18.0826, -18.0283, -18.0102],\n", + " [ 72.3376, 72.1204, 72.0480],\n", + " [-54.2588, -54.0958, -54.0415]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32) - 100.0\n", + "x = torch.tensor(data)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "z = torch.matmul(A, x)\n", + "z.retain_grad()\n", + "mu = torch.mean(z)\n", + "mu.retain_grad()\n", + "sigma = torch.sqrt(torch.std(z, unbiased=False) ** 2)\n", + "sigma.retain_grad()\n", + "o = (z - mu) / sigma\n", + "o.retain_grad()\n", + "l = torch.dot(torch.tensor([0.1, 0.2, 0.5]), o)\n", + "# l.backward()\n", + "# print(A.grad)\n", + "l.backward()\n", + "print(A.grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get norms and gradients for different models" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "model = clip_model.ClipModel('ViT-B/16')\n", + "model.new_last_layer(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# print(list(model.get_layers()[0][1].parameters())[0].requires_grad)\n", + "# inputs = torch.zeros((1, 3, 224, 224))\n", + "\n", + "def get_clip_mean_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "def get_clip_dist_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + "inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + "inputs = inputs.tile([1, 1, 224, 224])\n", + "print(inputs.shape)\n", + "inputs = inputs.cuda()\n", + "model.cuda()\n", + "outputs = model(inputs)\n", + "loss = torch.sum(torch.square(outputs))\n", + "loss.backward()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[29.54964256286621, 2.6062560390040383, 7.567190647125244, 1.0375860929489136, 0.26622636570179553, 9.328513982084095, 0.2186721176275342, 17.19362955770947, 0.26272152142902877, 9.570395973223832, 0.33883179052500684, 17.063759606866164, 0.4135279331824097, 19.316852593622446, 0.348065239809437, 23.211175772550735, 0.2866482939208723, 21.411272157777947, 0.2982341959606744, 32.02183701601188, 0.7350253231739102, 23.98497888947061, 0.3489564675414618, 36.33611495543812, 0.3906924973175038, 26.982765200703604, 0.4056054973737743, 39.959679978199176, 0.46362568149293487, 25.90123800988363, 0.2922789139876288, 40.1849475230448, 1.12168652906377, 28.275337317915774, 0.2797527143483323, 48.489088348578655, 0.5411435171208155, 21.4489124869876, 0.23895772899326645, 34.997931414576485, 1.7938492117508384, 21.208721582016143, 0.16792367077919937, 30.11186549644565, 2.420525364382956, 19.86338208946117, 0.4717152135407727, 27.1885166259501, 1.0686553663789327, 34.53155986991048, 0.2615572246974295, 33.576464443434766, 1.2850386157480747, 13.470720567165724]\n" + ] + } + ], + "source": [ + "\n", + "def get_grad_layer(cur_layer):\n", + " grads = [p.grad.detach().cpu().numpy() for p in cur_layer.parameters()]\n", + " grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads]\n", + " grad_norm = np.sqrt(np.sum(grad_norms_squared))\n", + " return grad_norm\n", + "\n", + "def get_norm_layer(cur_layer):\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " return norm\n", + "\n", + "def get_layer_grads(model):\n", + " named_layers = model.get_layers()\n", + " names, layers = zip(*named_layers)\n", + " norms = [get_norm_layer(l) for l in layers]\n", + " grad_norms = [get_grad_layer(l) for l in layers]\n", + " return norms, grad_norms\n", + "\n", + "norms, grad_norms = get_layer_grads(model)\n", + "print(grad_norms)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test get layers for different models" + ] + }, { "cell_type": "code", "execution_count": 22, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 957c9af..21d3349 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1441,8 +1441,9 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [1e-6, 3e-6, 1e-5] else: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + # Note for fmow I also tried 3e-4 and 1e-3. if args.no_replications or args.only_one_run: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1491,6 +1492,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) adapt_name += '_layer_wise_tune_cosine_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.decay_exp is not None: hyperparams_list = append_to_each( hyperparams_list, {'decay_exp': args.decay_exp}) @@ -1510,7 +1515,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1544,10 +1549,12 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) for dataset in datasets: + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, - ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1652,7 +1659,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= model = names_to_model[args.model_name] if args.optimizer is not None: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 @@ -1686,6 +1693,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune': True}) adapt_name += '_layer_wise_tune_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.layer_wise_tune_cosine: hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) @@ -1708,7 +1719,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,11 +1737,13 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= for i in range(num_replications): replication_hyperparams_list.append({ 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1850,7 +1863,7 @@ def main(args, options_dict={}): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - if options_dict != {}: + if options_dict == {}: experiment_to_fns[args.experiment](args) else: experiment_to_fns[args.experiment](args, options_dict=options_dict) @@ -1876,8 +1889,10 @@ def fill_platform_specific_default_args(args): def get_unparsed_options_dict(unparsed): options_dict = {} + print(unparsed) for unparsed_option in unparsed: option_name, val = unparsed_option.split('=') + option_name = option_name[2:] options_dict[option_name] = val return options_dict @@ -1947,6 +1962,8 @@ def get_unparsed_options_dict(unparsed): help='Don\'t train model, just collect stats.', required=False) parser.add_argument('--layer_wise_tune', action='store_true', help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--batch_layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) parser.add_argument('--layer_wise_tune_cosine', action='store_true', help='Gradually unfreeze layers, multiply by cosine lr', required=False) parser.add_argument('--warmup_epochs', type=int, required=False, default=None, diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 45365b3..db134ab 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3,4,5,6,7,8] +#SBATCH --exclude=sphinx[3,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 25db1d0..a3b0a5a 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -29,10 +29,11 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre # summarize_result gets a table where each row is the results for one *run*. # We now summarize the information across runs in a *single* experiment. # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). - res, val_values_list, file_paths = summarize_results( + res, val_values_list, file_paths, num_epochs_list = summarize_results( dir_path, val_metric, output_metrics) if len(res) == 0: - return None, None, None + print('empty dir', dir_path) + return None, None, None, None res['group'] = res['name'].apply(remove_replication_info) grouped = res.groupby('group') means = grouped.mean() @@ -56,7 +57,7 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre for best_row in [best_row_mean, best_row_std]: best_row['group'] = best_row.index best_row.set_index('name') - return res, best_row_mean, best_row_std + return res, best_row_mean, best_row_std, num_epochs_list def get_all_results(val_metric, dir_paths, output_metrics): diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index 4816144..eceb4e0 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -21,6 +21,7 @@ def get_parent_folder(file_path): def get_result(file_path, val_metric, output_metrics, take_max=True): + # Get the result for a single run. df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': @@ -68,9 +69,12 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): else: run_name = [('name', file_path[file_path.rfind('/')+1:-4])] best_res = run_name + best_res - return best_res, best_value + # len(df) is the number of epochs + assert len(df) == df['epoch'].max() + 1 + return best_res, best_value, len(df) -def summarize_results(results_dir, val_metric, output_metrics, replication=False, use_all=False, max_num=None): +def summarize_results(results_dir, val_metric, output_metrics, max_num=None): + # Get results for all runs in an experiment. # If use_all is True, then look at all stats.tsv files. # Otherwise, if replication is True look for replication files, if false ignore replicatin files. # max_num is for linear probing, and uses only the first max_num runs. @@ -81,15 +85,14 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False # the same validation metric. file_paths = sorted(file_paths) results_list, val_values_list = [], [] + num_epochs_list = [] for file_path in file_paths: if max_num is not None and int(file_path[-5]) >= max_num: continue - parent_folder = get_parent_folder(file_path) - if use_all or (('replication' in parent_folder and replication) or - ('replication' not in parent_folder and not replication)): - res_row, val_value = get_result(file_path, val_metric, output_metrics) - results_list.append(OrderedDict(res_row)) - val_values_list.append(val_value) + res_row, val_value, num_epochs = get_result(file_path, val_metric, output_metrics) + results_list.append(OrderedDict(res_row)) + val_values_list.append(val_value) + num_epochs_list.append(num_epochs) res = pd.DataFrame(results_list) for col in res.columns: if 'epoch' in col: @@ -97,7 +100,7 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False if 'acc' in col: res[col] = res[col] * 100 res = res.round(4) - return res, val_values_list, file_paths + return res, val_values_list, file_paths, num_epochs_list if __name__ == '__main__': # Higher is better when we pick val_metric, so use it for accuracies not losses. diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index ae8282c..8a0c371 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -607,14 +607,9 @@ def main(config, log_dir, checkpoints_dir): train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) - # Add number of layers frozen to train_stats. - if (check_exists_value(config, 'layer-wise-tune', True) or - check_exists_value(config, 'layer-wise-tune-cosine', True)): - train_stats['num_trans_freeze'] = num_trans_freeze - train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. - if not check_exists_not_none(config, 'batch_scheduler'): + if batch_scheduler is None: scheduler.step() # Get test stats across all test sets. test_stats = get_all_test_stats( diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py index 53641df..2e2bfad 100644 --- a/unlabeled_extrapolation/utils/layer_wise_tuner.py +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -18,18 +18,18 @@ def step(self): # Get number of transformer layers to freeze. effective_steps = max(0, self._step - self._num_warmup_steps) effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) - if self._step >= self.num_steps - self._num_cooldown_steps: + if self._step >= self._num_steps - self._num_cooldown_steps: num_trans_tune = num_trans_layers elif effective_num_steps == 1: num_trans_tune = num_trans_layers else: num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) - assert num_trans_tune <= num_trans_layers: + assert num_trans_tune <= num_trans_layers num_trans_freeze = num_trans_layers - num_trans_tune if num_trans_freeze != self._num_trans_freeze: self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') self._num_trans_freeze = num_trans_freeze self._step += 1 if self._step > self._num_steps: From 312fc856d668dceb9dd63884d82a810f475635e4 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 7 Oct 2022 09:43:11 -0700 Subject: [PATCH 149/197] Final paper updates --- .amltignore | 4 + .gitignore | 3 + ...nalyze_dataset_stats_model_gradients.ipynb | 297 +++++++ scripts/fine-tuning-results.ipynb | 348 --------- ...eeze-embed-paper-fine-tuning-results.ipynb | 737 ++++++++++++++++++ ...> imagenet_fmow_waterbirds_examples.ipynb} | 81 +- ...ad_models_test_get_layers_gradients.ipynb} | 201 ++++- scripts/run_adaptation_experiments.py | 33 +- scripts/run_sphinx_sbatch.sh | 2 +- scripts/summarize_all_results.py | 7 +- scripts/summarize_results.py | 21 +- unlabeled_extrapolation/baseline_train.py | 7 +- .../utils/layer_wise_tuner.py | 6 +- 13 files changed, 1350 insertions(+), 397 deletions(-) create mode 100644 scripts/analyze_dataset_stats_model_gradients.ipynb delete mode 100644 scripts/fine-tuning-results.ipynb create mode 100644 scripts/freeze-embed-paper-fine-tuning-results.ipynb rename scripts/{fmow_waterbirds_examples.ipynb => imagenet_fmow_waterbirds_examples.ipynb} (98%) rename scripts/{load_models_get_layers.ipynb => load_models_test_get_layers_gradients.ipynb} (72%) diff --git a/.amltignore b/.amltignore index 6cccde4..ca7271f 100644 --- a/.amltignore +++ b/.amltignore @@ -1,3 +1,7 @@ +**wandb** +**.tsv** +**egg-info** +**slurm_outputs** **logs** **amlt_results** **amlt_configs** diff --git a/.gitignore b/.gitignore index 91c9254..13a7bb8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +**amlt_configs/** +.amltconfig + **tmp.tsv** **slurm_outputs** **outdated** diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb new file mode 100644 index 0000000..c41625a --- /dev/null +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -0,0 +1,297 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", + "from unlabeled_extrapolation.utils import utils\n", + "import importlib\n", + "import timm\n", + "import torch\n", + "from torch import nn\n", + "import numpy as np\n", + "import os\n", + "import sys\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.pyplot import figure" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/juice/scr/ananya/cifar_experiments/transfer_learning/scripts', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python38.zip', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/lib-dynload', '', '/sailhome/ananya/.local/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/apex-0.1-py3.8-linux-x86_64.egg', '/juice/scr/ananya/cifar_experiments/wilds', '/juice/scr/ananya/cifar_experiments/transfer_learning', '/juice/scr/ananya/verified_calibration', '/u/nlp/anaconda/main/anaconda3/envs/ananya-ue/lib/python3.8/site-packages/IPython/extensions', '/sailhome/ananya/.ipython']\n" + ] + } + ], + "source": [ + "ue_src = '/u/scr/ananya/cifar_experiments/transfer_learning/unlabeled_extrapolation'\n", + "if ue_src not in sys.path:\n", + " sys.path = [ue_src] + sys.path\n", + "print(sys.path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import breeds" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "model_display_names = ['clip_b', 'clip_l', 'vit_b', 'dino_b', 'convnext_b', 'resnet50', 'resnet101']\n", + "log_root = '../logs/'\n", + "\n", + "def get_gradient_log_name(dataset_name, model_name):\n", + " return f'full_ft_epochs1_no_train__{dataset_name}_{model_name}'\n", + "\n", + "def get_dir_path(dataset_name, model_name):\n", + " log_name = get_gradient_log_name(dataset_name, model_name)\n", + " run_name = 'epochs-1_no_train-True_optimizer.args.lr-0.0_scheduler.args.T_max-1_seed-0_run0'\n", + " return log_root + '/' + log_name + '/' + run_name + '/'\n", + "\n", + "def get_config_path(dir_path):\n", + " return dir_path + '/config.json'\n", + "\n", + "def get_stats_path(dir_path):\n", + " return dir_path + '/stats.tsv'\n", + "\n", + "def get_random_images(dataset, n=100):\n", + " indices = np.random.choice(np.arange(len(dataset)), size=n, replace=False)\n", + " return [dataset[i][0].cpu().detach().numpy() for i in indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['grad_2', 'grad_1']\n" + ] + } + ], + "source": [ + "S = {'grad_1', 'grad_2', 'norm_1', 'other'}\n", + "filtered_S = [s for s in S if 'grad' in s]\n", + "print(filtered_S)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "living17_nonorm\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "domainnet\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def filter_df_get_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_norm(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_normalized_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", + " filtered_d = df[filtered_keys].to_dict(orient='records')[0]\n", + " norm_d = df[norm_keys].to_dict(orient='records')[0]\n", + " normalized_grad_d = {}\n", + " for fk, nk in zip(filtered_keys, norm_keys):\n", + " normalized_grad_d[fk] = filtered_d[fk] / norm_d[nk]\n", + " return normalized_grad_d\n", + "\n", + "# def filter_df_get_norm_grad(df):\n", + "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad' in s]\n", + "# print(filtered_keys)\n", + "# return df[filtered_keys] \n", + "\n", + "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", + " dataset_stats = {}\n", + " for dataset in datasets:\n", + " print(dataset)\n", + " figure(figsize=(8, 4), dpi=80)\n", + " for model_idx, model in enumerate(models):\n", + " dir_path = get_dir_path(dataset, model)\n", + " config_path = get_config_path(dir_path)\n", + " stats_path = get_stats_path(dir_path)\n", + " with open(config_path, 'r') as f:\n", + " config = json.load(f)\n", + " train_data = utils.init_dataset(config['train_dataset'])\n", + " if model_idx == 1:\n", + " random_images = get_random_images(train_data,n=10)\n", + " dataset_stats[dataset] = {\n", + " 'mean': np.mean(random_images),\n", + " 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", + " 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", + " }\n", + " df = pd.read_csv(stats_path, sep='\\t')\n", + " d = filter_df(df)\n", + " values = list(d.values())\n", + " if model_idx == 1:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers')\n", + " plt.scatter([model_idx], values[-1], c='green', label='last layer')\n", + " plt.scatter([model_idx], values[0], c='red', label='first layer')\n", + " else:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black')\n", + " plt.scatter([model_idx], values[-1], c='green')\n", + " plt.scatter([model_idx], values[0], c='red')\n", + " my_xticks = ['John','Arnold','Mavis','Matt']\n", + " plt.legend()\n", + " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", + "\n", + " plt.show()\n", + "# print(d.values())\n", + "# print(filtered_keys)\n", + "# print(df['train/grad_patch_embed'])\n", + "# print(df[filtered_keys])\n", + "# print(df[compute_keys(df)])\n", + " return dataset_stats\n", + "\n", + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'living17_nonorm': {'mean': 0.405586, 'std': 0.19588944, 'std_mean': 0.105948165}, 'waterbirds': {'mean': 0.37670943, 'std': 0.22946799, 'std_mean': 0.11904866}, 'domainnet': {'mean': 0.8599936, 'std': 0.1735559, 'std_mean': 0.15381968}}\n" + ] + } + ], + "source": [ + "print(dataset_stats)\n", + "# The std-devs within the image, and the std devs of the mean, are pretty similar (and small).\n", + "# So it's really the mean that varies a lot.\n", + "# I think the \"obvious\" thing to do is to normalize the images to have the same mean, std-dev\n", + "# Let's check this and see what the gradients look like if we do this." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Loop over datasets\n", + " # Loop over models\n", + " # Get folder name\n", + " # Get gradient stats\n", + " # Compute relevant stats. E.g., for transformer models combine blocks?\n", + " # Plot stats. Can start by just plotting first layer and some in between layer for every model?\n", + " # For the first model, load config. Load dataset.\n", + " # Sample random images. Get image mean. Std-dev within a single image. Variance of the mean across images." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fine-tuning-results.ipynb b/scripts/fine-tuning-results.ipynb deleted file mode 100644 index 17fe75a..0000000 --- a/scripts/fine-tuning-results.ipynb +++ /dev/null @@ -1,348 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "import summarize_all_results\n", - "import importlib\n", - "importlib.reload(summarize_all_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None, aggregation_metric_list=None):\n", - " table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " cur_results = []\n", - " for dataset_idx, dataset in enumerate(datasets):\n", - " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", - " output_metrics = output_metrics_list[dataset_idx]\n", - " if val_metric_list is None:\n", - " val_metric = 'LAST'\n", - " else:\n", - " val_metric = val_metric_list[dataset_idx]\n", - " if aggregation_metric_list is None:\n", - " agg_metric = val_metric\n", - " else:\n", - " agg_metric = aggregation_metric_list[dataset_idx]\n", - " _, best_row_mean, best_row_std = summarize_all_results.get_experiment_aggregate_summary(\n", - " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", - " cur_results.append(best_row_mean.to_numpy()[0,:-2])\n", - " cur_results = np.concatenate(cur_results)\n", - " table[model_idx][option_idx] = cur_results\n", - " return table\n", - "\n", - "# Add table to make TSV and Latex tables.\n", - "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", - " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", - " print(first_line)\n", - " for model_idx, model in enumerate(models):\n", - " for option_idx, option in enumerate(options):\n", - " line = model + '\\t' + option\n", - " for idx, val in enumerate(table[model_idx][option_idx]):\n", - " line += '\\t' + '{:.1f}'.format(val)\n", - " if std_err_table is not None:\n", - " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx])\n", - " print(line)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "log_dir = '../logs/'\n", - "name_template = 'full_ft_{option}{dataset}_{model}'\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_resnet50', 'clip_vit_l14']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['LAST', 'LAST', 'LAST']\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.6\t82.3\t97.0\t67.4\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.0\t82.1\t97.9\t69.3\t94.9\t90.3\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t83.5\t97.9\t73.1\t94.9\t88.4\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", - "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", - "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", - "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", - "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", - "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", - "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", - "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", - "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.8\t10.1\t82.0\t54.9\n", - "CLIP ResNet-50\tAdamW\t96.8\t73.9\t96.5\t59.7\t88.1\t71.2\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t71.6\t93.0\t24.1\t83.2\t53.0\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t96.5\t73.7\t96.8\t53.3\t87.4\t70.5\n", - "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n" - ] - } - ], - "source": [ - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ResNet-50', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", - "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", - "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", - "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", - "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", - "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", - "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", - "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", - "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" - ] - } - ], - "source": [ - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n" - ] - } - ], - "source": [ - "# LAMB and LARS results for CLIP ViT-B/16\n", - "models = ['clip_vit_b16']\n", - "options = ['opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['Lamb', 'LARS']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[97.026]], dtype=object)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "best_row_mean.to_numpy()[:,:-2]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "CLIP ViT-B/16\tLamb\t98.2\t79.5\t97.8\t64.0\t95.1\t90.4\n", - "CLIP ViT-B/16\tLARS\t97.7\t83.9\t97.1\t48.6\t93.2\t83.8\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\n" - ] - } - ], - "source": [ - "# CLIP results including all optimizers and and layerwise method.\n", - "models = ['clip_vit_b16']\n", - "# \n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Lamb', 'LARS', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\tFMoW ID\tFMoW OOD Val\tFMoW OOD Test\tFMoW Africa\n", - "CLIP ViT-B/16\tSGD\t97.8\t81.4\t97.3\t61.7\t89.6\t74.3\t67.9\t65.5\t58.5\t36.6\n", - "CLIP ViT-B/16\tAdamW\t98.1\t81.5\t97.9\t69.3\t95.0\t90.6\t70.3\t67.8\t61.5\t40.8\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.1\t80.7\t97.9\t73.1\t95.2\t89.0\t70.3\t67.7\t60.8\t39.6\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\t70.5\t67.9\t61.5\t40.7\n", - "CLIP ViT-B/16\tLayer-wise\t98.2\t81.9\t98.3\t71.5\t96.3\t93.3\t69.0\t67.0\t61.0\t42.4\n", - "CLIP ViT-B/16\tLayer-wise AdamW\t98.2\t82.8\t98.3\t71.0\t95.5\t93.1\t69.5\t66.5\t60.4\t40.5\n" - ] - } - ], - "source": [ - "# CLIP results including wilds datasets\n", - "models = ['clip_vit_b16']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_', 'layer_wise_tune__', 'layer_wise_tune__decay_exp_6.03_opt_torch.optim.AdamW_']\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test']]\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/ood_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "shorted_model_names = ['CLIP ViT-B/16']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)', 'Layer-wise', 'Layer-wise AdamW']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\"]\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb new file mode 100644 index 0000000..c317685 --- /dev/null +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import summarize_all_results\n", + "import importlib\n", + "import math\n", + "importlib.reload(summarize_all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = '../logs/'\n", + "name_template = 'full_ft_{option}{dataset}_{model}'\n", + "\n", + "# TODOs:\n", + "# Get mean and std (done)\n", + "# Filter out for ID and OOD columns (done)\n", + "# Add an overall average column\n", + "\n", + "# Print some nice Latex tables (done)\n", + "# Bold the best numbers within confidence intervals, in the latex table\n", + "\n", + "def get_bolds(table, std_err_table=None, eps=0.2):\n", + " is_best = np.zeros((len(table), len(table[0])), dtype=np.int32)\n", + " for col in range(len(table[0])):\n", + " best_idx = np.argmax(table[:,col])\n", + " best_acc = table[best_idx][col]\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " best_std = std_err_table[best_idx][col]\n", + " if math.isnan(best_std):\n", + " best_std = eps\n", + " for row in range(len(table)):\n", + " if std_err_table is not None and col < len(std_err_table[0]):\n", + " cur_std = std_err_table[row][col]\n", + " if math.isnan(cur_std):\n", + " cur_std = eps\n", + " if np.abs(table[row][col] - best_acc) <= max(best_std, cur_std):\n", + " is_best[row][col] = 1\n", + " else:\n", + " if table[row][col] >= best_acc - eps:\n", + " is_best[row][col] = 1\n", + " return is_best\n", + "\n", + "def get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list=None,\n", + " aggregation_metric_list=None, num_sweep=6, desired_epochs_list=None):\n", + " # desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\n", + " # supposed to have run each dataset for. Used to validate if the runs finished.\n", + " mean_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " std_table = np.zeros((len(models), len(options), sum([len(ol) for ol in output_metrics_list])))\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " cur_means = []\n", + " cur_stds = []\n", + " for dataset_idx, dataset in enumerate(datasets):\n", + " dir_path = log_dir + '/' + name_template.format(model=model, option=option, dataset=dataset)\n", + " output_metrics = output_metrics_list[dataset_idx]\n", + " if val_metric_list is None:\n", + " val_metric = 'LAST'\n", + " else:\n", + " val_metric = val_metric_list[dataset_idx]\n", + " if aggregation_metric_list is None:\n", + " agg_metric = val_metric\n", + " else:\n", + " agg_metric = aggregation_metric_list[dataset_idx]\n", + " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", + " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " num_jobs = len(res)\n", + " if (desired_epochs_list is not None and\n", + " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + " bad_indices = np.argwhere(np.array(num_epochs_list) < desired_epochs_list[dataset_idx])\n", + " bad_runs = [dir_path + '/' + run_folder for run_folder in res['name'][bad_indices[:, 0]]]\n", + " print('some jobs did not finish: ', model, dataset, option, bad_runs)\n", + " if num_jobs != num_sweep and num_jobs != num_sweep * 3:\n", + " print('not all jobs ran: ', model, option, dataset, num_jobs)\n", + " cur_means.append(best_row_mean.to_numpy()[0,:-2])\n", + " cur_stds.append(best_row_std.to_numpy()[0,:-2])\n", + " cur_means = np.concatenate(cur_means)\n", + " cur_stds = np.concatenate(cur_stds)\n", + " mean_table[model_idx][option_idx] = cur_means\n", + " std_table[model_idx][option_idx] = cur_stds\n", + " return mean_table, std_table\n", + "\n", + "def flatten(list_of_lists):\n", + " x = []\n", + " for l in list_of_lists:\n", + " x.append(l)\n", + " return x\n", + "\n", + "def filter_columns(table, old_output_metrics_list, new_output_metrics_list):\n", + " def get_indices(old_list, new_items):\n", + " return np.array([old_list.index(x) for x in new_items])\n", + " local_indices_list = [get_indices(o, n) for o, n in zip(old_output_metrics_list, new_output_metrics_list)]\n", + "# print(local_indices_list)\n", + " old_lens = [len(o) for o in old_output_metrics_list]\n", + " cum_old_lens = np.concatenate([[0], np.cumsum(old_lens)])[:-1]\n", + "# print(cum_old_lens)\n", + " global_indices = [local_indices + cum_old_len for local_indices, cum_old_len in zip(local_indices_list, cum_old_lens)]\n", + "# print(list(np.concatenate(global_indices)))\n", + " return table[:, :, global_indices][:,:,:,0]\n", + "\n", + "\n", + "# Add table to make TSV and Latex tables. Add averages.\n", + "def display_tsv_table(models, options, shortened_output_metrics_list, table, std_err_table=None):\n", + " first_line = '\\t\\t' + '\\t'.join(shortened_output_metrics_list)\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " for option_idx, option in enumerate(options):\n", + " line = model + '\\t' + option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += '\\t' + '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " print(line)\n", + " \n", + "def add_average_column(table):\n", + " new_table = []\n", + " for model_idx in range(len(table)):\n", + " model_table = table[model_idx]\n", + " means = np.mean(model_table, axis=1)\n", + " new_model_table = np.concatenate([model_table, np.expand_dims(means, axis=-1)], axis=-1)\n", + " new_table.append(new_model_table)\n", + " return np.array(new_table)\n", + " \n", + "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True):\n", + "\n", + " # Print latex table.\n", + " if len(models) == 1:\n", + " num_columns = len(shortened_output_metrics_list) + 1\n", + " else:\n", + " num_columns = len(shortened_output_metrics_list) + 2\n", + " if is_last_avg:\n", + " print('\\\\begin{tabular}{' + ('c'*(num_columns-1)) + '|c}')\n", + " else:\n", + " print('\\\\begin{tabular}{' + ('c'*num_columns) + '}')\n", + " print('\\\\toprule')\n", + " first_line = ' & ' + ' & '.join(shortened_output_metrics_list) + '\\\\\\\\'\n", + " if len(models) > 1:\n", + " first_line = ' & ' + first_line\n", + " print(first_line)\n", + " for model_idx, model in enumerate(models):\n", + " print('\\\\midrule')\n", + " if std_err_table is None:\n", + " is_bold = get_bolds(table[model_idx], eps=0.2)\n", + " else:\n", + " is_bold = get_bolds(table[model_idx], std_err_table[model_idx], eps=0.2)\n", + " for option_idx, option in enumerate(options):\n", + " if len(models) > 1:\n", + " line = model + ' & ' + option\n", + " else:\n", + " line = option\n", + " for idx, val in enumerate(table[model_idx][option_idx]):\n", + " line += ' & '\n", + "# print(is_bold[option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '\\\\textbf{'\n", + " line += '{:.1f}'.format(val)\n", + " if (std_err_table is not None and\n", + " idx < len(std_err_table[model_idx][option_idx]) and\n", + " not math.isnan(std_err_table[model_idx][option_idx][idx])):\n", + " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", + " if is_bold[option_idx][idx] and bold_best:\n", + " line += '}'\n", + " line += '\\\\\\\\'\n", + " print(line)\n", + " print('\\\\bottomrule')\n", + " print('\\\\end{tabular}')\n", + " \n", + " \n", + "def display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", + " # Filter the ID and OOD metrics.\n", + " print('\\n\\nID Accuracies')\n", + " id_mean_table = filter_columns(mean_table, output_metrics_list, id_output_metrics_list)\n", + " id_mean_table = add_average_column(id_mean_table)\n", + " id_std_table = filter_columns(std_table, output_metrics_list, id_output_metrics_list)\n", + " if no_std:\n", + " id_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, id_mean_table, id_std_table, is_last_avg=True)\n", + "\n", + " print('\\n\\nOOD Accuracies')\n", + " ood_mean_table = filter_columns(mean_table, output_metrics_list, ood_output_metrics_list)\n", + " ood_mean_table = add_average_column(ood_mean_table)\n", + " ood_std_table = filter_columns(std_table, output_metrics_list, ood_output_metrics_list)\n", + " if no_std:\n", + " ood_std_table = None\n", + " display_tsv_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table)\n", + " print('')\n", + " display_latex_table(shorted_model_names, shortened_options_names, shortened_dataset_names, ood_mean_table, ood_std_table, is_last_avg=True)\n", + " return id_mean_table, ood_mean_table\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.concatenate([[0], np.array([1,2,3])])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "some jobs did not finish: timm_vit_b16_in21k domainnet freeze_bottom_2_opt_torch.optim.AdamW_ ['../logs//full_ft_freeze_bottom_2_opt_torch.optim.AdamW_domainnet_timm_vit_b16_in21k/freeze_bottom_k-2_optimizer.args.lr-3e-06_seed-0_run0']\n", + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.7\t81.0\t97.0\t64.6\t87.4\t69.5\n", + "CLIP ViT-B/16\tAdamW\t97.9\t83.5\t97.7\t71.1\t94.9\t89.3\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t81.9\t97.8\t74.3\t94.6\t87.9\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", + "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", + "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", + "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", + "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", + "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", + "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", + "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", + "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", + "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 ID & Living-17 OOD & Waterbirds ID & Waterbirds OOD & DomainNet ID & DomainNet OOD\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.7 & 81.0 & 97.0 & 64.6 & 87.4 & 69.5\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{97.9} & \\textbf{83.5} & \\textbf{97.7} & 71.1 & \\textbf{94.9} & 89.3\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.0} & 81.9 & \\textbf{97.8} & \\textbf{74.3} & 94.6 & 87.9\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.1} & 82.6 & \\textbf{97.8} & 69.2 & \\textbf{94.8} & \\textbf{89.8}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.5} & \\textbf{89.4} & \\textbf{99.0} & 78.7 & \\textbf{91.5} & \\textbf{86.7}\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.6} & 87.9 & 98.9 & 80.1 & \\textbf{91.5} & 84.4\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{89.5} & \\textbf{99.2} & \\textbf{82.4} & \\textbf{91.5} & 86.3\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.5} & 88.4 & 99.0 & \\textbf{82.4} & 90.8 & 82.6\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & \\textbf{88.2} & 97.0 & 55.6 & 88.0 & 76.2\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.4} & 87.5 & \\textbf{97.9} & 61.2 & 89.1 & 77.5\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.3} & 87.6 & 97.5 & \\textbf{68.5} & 88.9 & \\textbf{78.9}\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & 86.7 & 97.6 & 61.5 & \\textbf{89.6} & 76.4\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{97.3} & \\textbf{85.7} & \\textbf{98.4} & 75.2 & \\textbf{89.0} & 80.9\\\\\n", + "BIT ResNet-50 & AdamW & 97.1 & 83.2 & \\textbf{98.3} & 76.9 & \\textbf{89.2} & \\textbf{84.0}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.5} & 84.4 & \\textbf{98.5} & 75.5 & \\textbf{89.0} & 82.4\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & 83.6 & \\textbf{98.4} & \\textbf{78.5} & \\textbf{89.0} & 83.5\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.2} & 82.2 & \\textbf{98.9} & 79.0 & \\textbf{91.8} & \\textbf{86.0}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.2} & 84.5 & 98.6 & \\textbf{79.4} & 91.0 & 83.7\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{84.9} & \\textbf{98.8} & 78.7 & 91.4 & \\textbf{85.9}\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.1} & 84.1 & 98.7 & 72.0 & 90.6 & 83.9\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.5} & \\textbf{92.1} & 99.0 & 81.3 & 94.6 & 89.8\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & 90.1 & \\textbf{99.4} & 85.8 & 94.0 & 89.9\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.5} & 91.5 & \\textbf{99.3} & \\textbf{88.0} & \\textbf{94.8} & \\textbf{91.5}\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.6} & 89.8 & \\textbf{99.3} & 87.7 & 94.5 & 91.0\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.3 & 84.9 & 96.3 & 56.7 & 84.1 & 60.9\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & 88.4 & \\textbf{98.7} & 86.0 & 96.6 & \\textbf{93.8}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & 98.6 & \\textbf{89.4} & \\textbf{98.7} & 84.9 & \\textbf{96.8} & \\textbf{93.9}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & 98.6 & 88.2 & \\textbf{98.6} & \\textbf{87.5} & \\textbf{96.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (LAST)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", + "val_metric_list = ['LAST', 'LAST', 'LAST']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "desired_epochs_list = [20, 20, 50]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)\n", + "display_latex_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", + "CLIP ViT-B/16\tSGD\t97.8\t80.0\t97.2\t62.5\t87.6\t69.6\n", + "CLIP ViT-B/16\tAdamW\t98.1\t82.8\t97.7\t71.9\t95.0\t89.2\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t83.2\t97.8\t73.7\t94.9\t88.2\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", + "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", + "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", + "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", + "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", + "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", + "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", + "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", + "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", + "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", + "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", + "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", + "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", + "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", + "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", + "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (Early stopped)\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", + "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", + "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t87.6\t67.0\t99.4\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 87.6 & 67.0 & \\textbf{99.4} & 89.8\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & \\textbf{95.0} & \\textbf{70.1} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & \\textbf{94.9} & \\textbf{70.0} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & \\textbf{66.4} & \\textbf{99.5} & \\textbf{91.1}\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & \\textbf{89.4} & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", + "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & \\textbf{68.8} & \\textbf{99.7} & \\textbf{92.2}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & \\textbf{92.0}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t69.6\t37.3\t86.8\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 69.6 & 37.3 & 86.8 & 67.2\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & \\textbf{95.7} & \\textbf{76.0}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & \\textbf{91.9} & 70.7\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{84.3} & \\textbf{76.5} & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", + "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & \\textbf{35.0} & \\textbf{95.2} & \\textbf{74.4}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{82.9} & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{83.1} & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & \\textbf{75.6}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & \\textbf{39.7} & 83.0 & 77.3\\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\textbf{89.8} & 89.5 & 38.4 & \\textbf{89.5} & \\textbf{79.5}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & \\textbf{79.4}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.2243181 91.46286571 91.27799905]\n", + "[71.87552286 76.03873524 76.73786476]\n" + ] + } + ], + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIP results including wilds datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t87.6 (6.4)\t67.0 (0.8)\t99.4 (0.0)\t89.8\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & 92.1\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & 92.1\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", + "LAMB & 98.2 & 97.8 & 95.1 & 67.9 & 99.5 & 91.7\\\\\n", + "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t69.6 (16.0)\t37.3 (1.1)\t86.8 (1.1)\t67.2\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & 76.0\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", + "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", + "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", + "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "some jobs did not finish: clip_vit_b16 waterbirds freeze_bottom_2_full_ft_epoch_50_ []\n", + "not all jobs ran: clip_vit_b16 freeze_bottom_2_full_ft_epoch_50_ waterbirds 7\n", + "empty dir ../older_logs//full_ft_freeze_bottom_5_full_ft_epoch_50_waterbirds_clip_vit_b16\n" + ] + }, + { + "ename": "TypeError", + "evalue": "object of type 'NoneType' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# desired_epochs_list = [20, 20, 50, 5, 3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../older_logs/'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-embed)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Layer-wise'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LAMB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LARS'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 54\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 55\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 58\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" + ] + } + ], + "source": [ + "# Get table for dino and clip, freezing different number of layers.\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['freeze_bottom_2_full_ft_epoch_50_', 'freeze_bottom_5_full_ft_epoch_50_', 'freeze_bottom_8_full_ft_epoch_50_', 'freeze_bottom_11_full_ft_epoch_50_', 'freeze_bottom_14_full_ft_epoch_50_']\n", + "val_metric_list = ['WATERBIRDS_VAL']\n", + "datasets = ['waterbirds']\n", + "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", + "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "# desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table('../older_logs/', name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/scripts/fmow_waterbirds_examples.ipynb b/scripts/imagenet_fmow_waterbirds_examples.ipynb similarity index 98% rename from scripts/fmow_waterbirds_examples.ipynb rename to scripts/imagenet_fmow_waterbirds_examples.ipynb index 86576a2..9b6bef5 100644 --- a/scripts/fmow_waterbirds_examples.ipynb +++ b/scripts/imagenet_fmow_waterbirds_examples.ipynb @@ -28,6 +28,22 @@ "importlib.reload(wilds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ImageNet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = '/scr/biggest/ue_datasets/wilds/data/'" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -74,18 +90,79 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "train_transform = transforms.Compose([\n", - " transforms.Resize(size=224)\n", + " transforms.Resize(size=224),\n", + " transforms.ToTensor()\n", "])\n", "root = '/u/scr/nlp/wilds/data' # For NLP cluster.\n", "# root = '/home/t-anakumar/wilds/data/' # For microsoft sandbox.\n", "waterbirds_train = wilds.WILDS(dataset_name='waterbirds-background', split='train', download='true', root=root, transform=train_transform, return_meta=True)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.6039216 , 0.6039216 , 0.6 , ..., 0.30980393,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.6039216 , 0.6039216 , 0.6039216 , ..., 0.3137255 ,\n", + " 0.3137255 , 0.3137255 ],\n", + " [0.60784316, 0.6039216 , 0.6039216 , ..., 0.31764707,\n", + " 0.31764707, 0.31764707],\n", + " ...,\n", + " [0.3019608 , 0.3019608 , 0.29803923, ..., 0.7058824 ,\n", + " 0.6901961 , 0.6901961 ],\n", + " [0.29411766, 0.29803923, 0.29803923, ..., 0.7058824 ,\n", + " 0.7019608 , 0.69411767],\n", + " [0.28627452, 0.2901961 , 0.29411766, ..., 0.6745098 ,\n", + " 0.67058825, 0.67058825]],\n", + "\n", + " [[0.69803923, 0.69803923, 0.69411767, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.69803923, 0.69803923, 0.69803923, ..., 0.42352942,\n", + " 0.42352942, 0.42352942],\n", + " [0.7019608 , 0.69803923, 0.69803923, ..., 0.42745098,\n", + " 0.42745098, 0.42745098],\n", + " ...,\n", + " [0.38039216, 0.38039216, 0.3764706 , ..., 0.627451 ,\n", + " 0.6117647 , 0.6117647 ],\n", + " [0.37254903, 0.3764706 , 0.3764706 , ..., 0.627451 ,\n", + " 0.62352943, 0.6156863 ],\n", + " [0.3647059 , 0.36862746, 0.37254903, ..., 0.59607846,\n", + " 0.5921569 , 0.5921569 ]],\n", + "\n", + " [[0.8862745 , 0.8862745 , 0.88235295, ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8862745 , 0.8862745 , 0.8862745 , ..., 0.67058825,\n", + " 0.67058825, 0.67058825],\n", + " [0.8901961 , 0.8862745 , 0.8862745 , ..., 0.6745098 ,\n", + " 0.6745098 , 0.6745098 ],\n", + " ...,\n", + " [0.3372549 , 0.3372549 , 0.33333334, ..., 0.61960787,\n", + " 0.6039216 , 0.6039216 ],\n", + " [0.32941177, 0.33333334, 0.33333334, ..., 0.62352943,\n", + " 0.61960787, 0.6117647 ],\n", + " [0.32156864, 0.3254902 , 0.32941177, ..., 0.5921569 ,\n", + " 0.5882353 , 0.5882353 ]]], dtype=float32)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array(waterbirds_train[0][0])" + ] + }, { "cell_type": "code", "execution_count": 49, diff --git a/scripts/load_models_get_layers.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb similarity index 72% rename from scripts/load_models_get_layers.ipynb rename to scripts/load_models_test_get_layers_gradients.ipynb index beceb6e..c2f9663 100644 --- a/scripts/load_models_get_layers.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -1,32 +1,21 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", "import timm\n", "import torch\n", + "from torch import nn\n", "import numpy as np\n", "importlib.reload(bit_resnet)\n", "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", - "importlib.reload(timm_model)" + "importlib.reload(timm_model)\n", + "importlib.reload(clip_model)" ] }, { @@ -49,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -62,6 +51,184 @@ " print(f'num params after freezing {k}: {utils.count_parameters(model, trainable=True)}')\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing layer norm" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.4242, grad_fn=)\n", + "tensor([[ 0.0140, 0.0559, 0.0699],\n", + " [-0.0701, -0.2804, -0.3505],\n", + " [ 0.0561, 0.2245, 0.2806]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)*0.1\n", + "x = torch.tensor(data)\n", + "layer_norm = nn.LayerNorm(len(data), elementwise_affine=False)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "output = layer_norm(torch.matmul(A, x))\n", + "loss = torch.dot(torch.tensor([0.1, 0.2, 0.5]), output) # torch.sum(torch.square(output))\n", + "loss.backward()\n", + "print(loss)\n", + "print(A.grad)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-18.0826, -18.0283, -18.0102],\n", + " [ 72.3376, 72.1204, 72.0480],\n", + " [-54.2588, -54.0958, -54.0415]])\n" + ] + } + ], + "source": [ + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32) - 100.0\n", + "x = torch.tensor(data)\n", + "A = torch.eye(len(data), requires_grad=True)\n", + "z = torch.matmul(A, x)\n", + "z.retain_grad()\n", + "mu = torch.mean(z)\n", + "mu.retain_grad()\n", + "sigma = torch.sqrt(torch.std(z, unbiased=False) ** 2)\n", + "sigma.retain_grad()\n", + "o = (z - mu) / sigma\n", + "o.retain_grad()\n", + "l = torch.dot(torch.tensor([0.1, 0.2, 0.5]), o)\n", + "# l.backward()\n", + "# print(A.grad)\n", + "l.backward()\n", + "print(A.grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get norms and gradients for different models" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "model = clip_model.ClipModel('ViT-B/16')\n", + "model.new_last_layer(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# print(list(model.get_layers()[0][1].parameters())[0].requires_grad)\n", + "# inputs = torch.zeros((1, 3, 224, 224))\n", + "\n", + "def get_clip_mean_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "def get_clip_dist_input():\n", + " inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + " inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + " inputs = inputs.tile([1, 1, 224, 224])\n", + " return inputs\n", + "\n", + "inputs = torch.tensor([0.48145466, 0.4578275, 0.40821073])\n", + "inputs = inputs.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n", + "inputs = inputs.tile([1, 1, 224, 224])\n", + "print(inputs.shape)\n", + "inputs = inputs.cuda()\n", + "model.cuda()\n", + "outputs = model(inputs)\n", + "loss = torch.sum(torch.square(outputs))\n", + "loss.backward()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[29.54964256286621, 2.6062560390040383, 7.567190647125244, 1.0375860929489136, 0.26622636570179553, 9.328513982084095, 0.2186721176275342, 17.19362955770947, 0.26272152142902877, 9.570395973223832, 0.33883179052500684, 17.063759606866164, 0.4135279331824097, 19.316852593622446, 0.348065239809437, 23.211175772550735, 0.2866482939208723, 21.411272157777947, 0.2982341959606744, 32.02183701601188, 0.7350253231739102, 23.98497888947061, 0.3489564675414618, 36.33611495543812, 0.3906924973175038, 26.982765200703604, 0.4056054973737743, 39.959679978199176, 0.46362568149293487, 25.90123800988363, 0.2922789139876288, 40.1849475230448, 1.12168652906377, 28.275337317915774, 0.2797527143483323, 48.489088348578655, 0.5411435171208155, 21.4489124869876, 0.23895772899326645, 34.997931414576485, 1.7938492117508384, 21.208721582016143, 0.16792367077919937, 30.11186549644565, 2.420525364382956, 19.86338208946117, 0.4717152135407727, 27.1885166259501, 1.0686553663789327, 34.53155986991048, 0.2615572246974295, 33.576464443434766, 1.2850386157480747, 13.470720567165724]\n" + ] + } + ], + "source": [ + "\n", + "def get_grad_layer(cur_layer):\n", + " grads = [p.grad.detach().cpu().numpy() for p in cur_layer.parameters()]\n", + " grad_norms_squared = [np.linalg.norm(g) ** 2 for g in grads]\n", + " grad_norm = np.sqrt(np.sum(grad_norms_squared))\n", + " return grad_norm\n", + "\n", + "def get_norm_layer(cur_layer):\n", + " norms_squared = [np.linalg.norm(p.data.detach().cpu().numpy()) ** 2 for p in cur_layer.parameters()]\n", + " norm = np.sqrt(np.sum(norms_squared))\n", + " return norm\n", + "\n", + "def get_layer_grads(model):\n", + " named_layers = model.get_layers()\n", + " names, layers = zip(*named_layers)\n", + " norms = [get_norm_layer(l) for l in layers]\n", + " grad_norms = [get_grad_layer(l) for l in layers]\n", + " return norms, grad_norms\n", + "\n", + "norms, grad_norms = get_layer_grads(model)\n", + "print(grad_norms)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test get layers for different models" + ] + }, { "cell_type": "code", "execution_count": 22, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 957c9af..21d3349 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, - imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict=options_dict): + imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1441,8 +1441,9 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn sweep_lrs = [1e-6, 3e-6, 1e-5] else: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] + # Note for fmow I also tried 3e-4 and 1e-3. if args.no_replications or args.only_one_run: num_replications = 1 # Would be num_replications = 0 if we used adaptation_experiment below. @@ -1491,6 +1492,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) adapt_name += '_layer_wise_tune_cosine_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.decay_exp is not None: hyperparams_list = append_to_each( hyperparams_list, {'decay_exp': args.decay_exp}) @@ -1510,7 +1515,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict) hyperparams_list = append_to_each(hyperparams_list, {'seed': args.seed}) if linear_probe: hyperparams_list = append_to_each(hyperparams_list, {'linear_probe': True}) @@ -1544,10 +1549,12 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn 'epochs-5_linear_probe-True_optimizer.args.lr-0.1_scheduler.args.' 'T_max-5_seed-0_run0/checkpoints/ckp_best_val'}) for dataset in datasets: + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=hyperparams_list, num_replications=num_replications, args=args, - ignore_name_hypers={'full_ft_epoch', 'checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1652,7 +1659,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= model = names_to_model[args.model_name] if args.optimizer is not None: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] - elif args.layer_wise_tune or args.layer_wise_tune_cosine: + elif args.layer_wise_tune or args.layer_wise_tune_cosine or args.batch_layer_wise_tune: sweep_lrs = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4] if args.only_one_run or args.no_replications: num_replications = 1 @@ -1686,6 +1693,10 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune': True}) adapt_name += '_layer_wise_tune_' + if args.batch_layer_wise_tune: + hyperparams_list = append_to_each( + hyperparams_list, {'batch-layer-wise-tune': True}) + adapt_name += '_batch_layer_wise_tune' if args.layer_wise_tune_cosine: hyperparams_list = append_to_each( hyperparams_list, {'layer-wise-tune-cosine': True}) @@ -1708,7 +1719,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= if options_dict != {}: hyperparams_list = append_to_each( hyperparams_list, options_dict) - adapt_name += '_' + '_'.join(options_dict.keys()) + adapt_name += '_' + hyperparams_to_str(options_dict.keys()) if l2sp: # Note: tried 1.0, 0.1, 0.01, 0.001, 0.0001 on Living-17 # 0.01 worked best ID, and 0.1 worked best OOD but did 0.4% worse than fine-tuning ID. @@ -1726,11 +1737,13 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= for i in range(num_replications): replication_hyperparams_list.append({ 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', + 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers={'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) + ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1850,7 +1863,7 @@ def main(args, options_dict={}): 'summarize_dataset': summarize_dataset, } if args.experiment in experiment_to_fns: - if options_dict != {}: + if options_dict == {}: experiment_to_fns[args.experiment](args) else: experiment_to_fns[args.experiment](args, options_dict=options_dict) @@ -1876,8 +1889,10 @@ def fill_platform_specific_default_args(args): def get_unparsed_options_dict(unparsed): options_dict = {} + print(unparsed) for unparsed_option in unparsed: option_name, val = unparsed_option.split('=') + option_name = option_name[2:] options_dict[option_name] = val return options_dict @@ -1947,6 +1962,8 @@ def get_unparsed_options_dict(unparsed): help='Don\'t train model, just collect stats.', required=False) parser.add_argument('--layer_wise_tune', action='store_true', help='Gradually unfreeze layers from top to bottom', required=False) + parser.add_argument('--batch_layer_wise_tune', action='store_true', + help='Gradually unfreeze layers from top to bottom', required=False) parser.add_argument('--layer_wise_tune_cosine', action='store_true', help='Gradually unfreeze layers, multiply by cosine lr', required=False) parser.add_argument('--warmup_epochs', type=int, required=False, default=None, diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 45365b3..db134ab 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3,4,5,6,7,8] +#SBATCH --exclude=sphinx[3,5,6,7,8] # Print execute commands in the log. set -x diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index 25db1d0..a3b0a5a 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -29,10 +29,11 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre # summarize_result gets a table where each row is the results for one *run*. # We now summarize the information across runs in a *single* experiment. # If aggregation is "MAX" then we take the max over the runs (regardless of how we early stopped in the run). - res, val_values_list, file_paths = summarize_results( + res, val_values_list, file_paths, num_epochs_list = summarize_results( dir_path, val_metric, output_metrics) if len(res) == 0: - return None, None, None + print('empty dir', dir_path) + return None, None, None, None res['group'] = res['name'].apply(remove_replication_info) grouped = res.groupby('group') means = grouped.mean() @@ -56,7 +57,7 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre for best_row in [best_row_mean, best_row_std]: best_row['group'] = best_row.index best_row.set_index('name') - return res, best_row_mean, best_row_std + return res, best_row_mean, best_row_std, num_epochs_list def get_all_results(val_metric, dir_paths, output_metrics): diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index 4816144..eceb4e0 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -21,6 +21,7 @@ def get_parent_folder(file_path): def get_result(file_path, val_metric, output_metrics, take_max=True): + # Get the result for a single run. df = pd.read_csv(file_path, sep='\t') # The user probably wants us to output the val metric! if val_metric not in output_metrics and val_metric != 'LAST': @@ -68,9 +69,12 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): else: run_name = [('name', file_path[file_path.rfind('/')+1:-4])] best_res = run_name + best_res - return best_res, best_value + # len(df) is the number of epochs + assert len(df) == df['epoch'].max() + 1 + return best_res, best_value, len(df) -def summarize_results(results_dir, val_metric, output_metrics, replication=False, use_all=False, max_num=None): +def summarize_results(results_dir, val_metric, output_metrics, max_num=None): + # Get results for all runs in an experiment. # If use_all is True, then look at all stats.tsv files. # Otherwise, if replication is True look for replication files, if false ignore replicatin files. # max_num is for linear probing, and uses only the first max_num runs. @@ -81,15 +85,14 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False # the same validation metric. file_paths = sorted(file_paths) results_list, val_values_list = [], [] + num_epochs_list = [] for file_path in file_paths: if max_num is not None and int(file_path[-5]) >= max_num: continue - parent_folder = get_parent_folder(file_path) - if use_all or (('replication' in parent_folder and replication) or - ('replication' not in parent_folder and not replication)): - res_row, val_value = get_result(file_path, val_metric, output_metrics) - results_list.append(OrderedDict(res_row)) - val_values_list.append(val_value) + res_row, val_value, num_epochs = get_result(file_path, val_metric, output_metrics) + results_list.append(OrderedDict(res_row)) + val_values_list.append(val_value) + num_epochs_list.append(num_epochs) res = pd.DataFrame(results_list) for col in res.columns: if 'epoch' in col: @@ -97,7 +100,7 @@ def summarize_results(results_dir, val_metric, output_metrics, replication=False if 'acc' in col: res[col] = res[col] * 100 res = res.round(4) - return res, val_values_list, file_paths + return res, val_values_list, file_paths, num_epochs_list if __name__ == '__main__': # Higher is better when we pick val_metric, so use it for accuracies not losses. diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index ae8282c..8a0c371 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -607,14 +607,9 @@ def main(config, log_dir, checkpoints_dir): train_stats = train( epoch, config, train_loader, net, device, optimizer, criterion, model_loss, test_loaders, max_test_examples, weight_dict_initial, batch_scheduler, batch_lw_tuner) - # Add number of layers frozen to train_stats. - if (check_exists_value(config, 'layer-wise-tune', True) or - check_exists_value(config, 'layer-wise-tune-cosine', True)): - train_stats['num_trans_freeze'] = num_trans_freeze - train_stats['num_layers_freeze'] = num_layers_freeze # Call scheduler to update learning rate, unless we have a batch scheduler, in which # case we will update the learning rate every step. - if not check_exists_not_none(config, 'batch_scheduler'): + if batch_scheduler is None: scheduler.step() # Get test stats across all test sets. test_stats = get_all_test_stats( diff --git a/unlabeled_extrapolation/utils/layer_wise_tuner.py b/unlabeled_extrapolation/utils/layer_wise_tuner.py index 53641df..2e2bfad 100644 --- a/unlabeled_extrapolation/utils/layer_wise_tuner.py +++ b/unlabeled_extrapolation/utils/layer_wise_tuner.py @@ -18,18 +18,18 @@ def step(self): # Get number of transformer layers to freeze. effective_steps = max(0, self._step - self._num_warmup_steps) effective_num_steps = max(1, self._num_steps - self._num_warmup_steps - self._num_cooldown_steps) - if self._step >= self.num_steps - self._num_cooldown_steps: + if self._step >= self._num_steps - self._num_cooldown_steps: num_trans_tune = num_trans_layers elif effective_num_steps == 1: num_trans_tune = num_trans_layers else: num_trans_tune = int(float(effective_steps) / (effective_num_steps-1) * num_trans_layers) - assert num_trans_tune <= num_trans_layers: + assert num_trans_tune <= num_trans_layers num_trans_freeze = num_trans_layers - num_trans_tune if num_trans_freeze != self._num_trans_freeze: self._model.freeze_bottom_trans(num_trans_freeze, self._freeze_embed) # Print statistics about number of parameters tuning, layers frozen, etc. - logging.info(f' = freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') + logging.info(f'Freezing {num_trans_freeze} transformer blocks out of {num_trans_layers}') self._num_trans_freeze = num_trans_freeze self._step += 1 if self._step > self._num_steps: From 0d84a284a9294b20cc697d2991f458f7ad2481ed Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 7 Oct 2022 10:20:50 -0700 Subject: [PATCH 150/197] Remove files --- scripts/run_adaptation_experiments.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 21d3349..567ecc5 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -285,15 +285,15 @@ def get_amlt_config(experiment_name, job_names, cmds, dataset, args=None): # TODO: use some better library to inject additional options into the yaml files. amlt_config = f"description: Sweep for experiment {experiment_name}\n\n" if args.amulet_cluster == 'amlk8s': - amlt_config_path = 'scripts/amlt_config_template_amlk8s.yaml' + amlt_config_path = 'amlt_scripts/amlt_config_template_amlk8s.yaml' elif args.amulet_cluster == 'sing' or args.amulet_cluster == 'sing_basic': - amlt_config_path = 'scripts/amlt_config_template_sing.yaml' + amlt_config_path = 'amlt_scripts/amlt_config_template_sing.yaml' else: raise ValueError(f'Unknown cluster {args.cluster}') with open(amlt_config_path, "r") as f: amlt_config += f.read() # Read and fill out the setup. - setup_config_path = 'scripts/amlt_setup.yaml' + setup_config_path = 'amlt_scripts/amlt_setup.yaml' with open(setup_config_path, "r") as f: amlt_setup = f.read() if dataset.amlt_data_cmd is not None: From 3ba355c8aaf1498c943e78e7967a721b492dd6c7 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 7 Oct 2022 10:21:32 -0700 Subject: [PATCH 151/197] Update gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 13a7bb8..72f1f93 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ **amlt_configs/** .amltconfig +**amlt_scripts** **tmp.tsv** **slurm_outputs** From 3ddc9c5a816976e00476acbbc53ff1c3202d1390 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 22:28:27 -0700 Subject: [PATCH 152/197] Start prep for wilds leaderboard. --- configs/adaptation/camelyon17_weakaugs.yaml | 1 + .../datasets_fmow_all_nonorm_weakaugs.yaml | 7 +++++- .../adaptation/fmow_all_nonorm_weakaugs.yaml | 1 + scripts/run_adaptation_experiments.py | 13 ++++++++-- unlabeled_extrapolation/baseline_train.py | 25 +++++++++++++++++-- 5 files changed, 42 insertions(+), 5 deletions(-) diff --git a/configs/adaptation/camelyon17_weakaugs.yaml b/configs/adaptation/camelyon17_weakaugs.yaml index 890e273..48323e0 100644 --- a/configs/adaptation/camelyon17_weakaugs.yaml +++ b/configs/adaptation/camelyon17_weakaugs.yaml @@ -8,6 +8,7 @@ epochs: &epochs 3 batch_size: 32 batch_splits: 2 save_no_checkpoints: True +save_wilds_model_preds: True model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml index 1c053b6..92510df 100644 --- a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -26,6 +26,12 @@ test_datasets: split: 'id_val' regions: ['all'] root: 'wilds/data' + - name: 'id_test' + classname: datasets.fmow.Fmow + args: + split: 'id_test' + regions: ['all'] + root: 'wilds/data' - name: 'ood_val' classname: datasets.fmow.Fmow args: @@ -38,7 +44,6 @@ test_datasets: split: 'test' regions: ['all'] root: 'wilds/data' - - name: 'africa_test' classname: datasets.fmow.Fmow args: diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml index ba1c101..23e79b1 100644 --- a/configs/adaptation/fmow_all_nonorm_weakaugs.yaml +++ b/configs/adaptation/fmow_all_nonorm_weakaugs.yaml @@ -8,6 +8,7 @@ epochs: &epochs 5 batch_size: 32 batch_splits: 2 save_no_checkpoints: True +save_wilds_model_preds: True model: classname: models.imnet_resnet.ResNet50 diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 567ecc5..36af66b 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1348,6 +1348,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= if args.only_one_run: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs[0]) num_replications = 1 + elif args.replication_one_run: + hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs[0]) # Would be num_replications = 0 if we used adaptation_experiment below. else: hyperparams_list = range_hyper('optimizer.args.lr', sweep_lrs) @@ -1452,7 +1454,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' - elif args.only_one_run: + elif args.only_one_run or args.replication_one_run: if args.layer_wise_tune or args.layer_wise_tune_cosine: hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) if 'waterbirds' in args.datasets[0] and (args.freeze_bottom_k is None or @@ -1463,6 +1465,10 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) else: hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + if 'fmow' in args.datasets[0] and args.optimizer is None: + hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change + elif 'camelyon17' in args.datasets[0] and args.optimizer is None: + hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. @@ -1667,7 +1673,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = range_hyper('optimizer.args.lr', [0.0]) hyperparams_list = append_to_each(hyperparams_list, {'no_train': True}) adapt_name += '_no_train_' - elif args.only_one_run: + elif args.only_one_run or args.replication_one_run: if args.layer_wise_tune or args.layer_wise_tune_cosine: hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) else: @@ -1956,6 +1962,9 @@ def get_unparsed_options_dict(unparsed): parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) + parser.add_argument('--replications_one_run', action='store_true', + help='Only run one hyperparameter setting, but all replications.', + required=False) parser.add_argument('--no_replications', action='store_true', help='Don\'t run replication runs, only sweep.', required=False) parser.add_argument('--no_train', action='store_true', diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 8a0c371..5141015 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -92,7 +92,26 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na if num_examples >= max_examples: logging.info("Breaking after %d examples.", num_examples) break - if 'save_model_preds' in config and config.save_model_preds: + if check_exists_value(config, 'save_wilds_model_preds', True): + pred_strings = [str(p) for p in preds] + pred_string = '\n'.join(pred_strings) + if config['train_dataset']['classname'] == 'datasets.fmow.Fmow': + dataset_name = 'fmow' + elif (config['train_dataset']['classname'] == 'datasets.wilds.WILDS' and + config['train_dataset']['args']['dataset_name'] == 'camelyon17'): + dataset_name = 'camelyon17' + split_name = loader_name + if split_name == 'ood_val': + split_name = 'val' + elif split_name == 'ood_test': + split_name = 'test' + seed = config['seed'] + file_name = '{dataset}_split:{split}_seed:{seed}_epoch:{epoch}_pred.csv'.format( + dataset=dataset_name, split=split_name, seed=seed, epoch=epoch) + file_path = log_dir + '/model_preds/' + file_name + with open(file_name, "w") as f: + f.write(pred_string) + elif check_exists_value(config, 'save_model_preds', True): preds = np.concatenate(predicted_list) labels = np.concatenate(labels_list) pickle_name = log_dir+'/model_preds/'+loader_name+'_'+str(epoch)+'_preds.pkl' @@ -473,6 +492,7 @@ def main(config, log_dir, checkpoints_dir): logging.info("Entering main.") train_loader = get_train_loader(config) # Set up test loaders. + # shuffle is always False so test examples are in the order they're presented. test_loaders, max_test_examples = get_test_loaders(config) # Create model. net = build_model(config) @@ -861,7 +881,8 @@ def setup(): # transform for every test datset. preprocess_config(config, args.config) # If we should save model preds, then save them. - if 'save_model_preds' in config and config.save_model_preds: + if (('save_model_preds' in config and config.save_model_preds) or + ('save_wilds_model_preds' in config and config.save_wilds_model_preds)): os.makedirs(log_dir + '/model_preds/') # Setup wandb. setup_wandb(args, config) From 233b15568b6472f5a4ad5d9437e190b3c430b23b Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 22:37:00 -0700 Subject: [PATCH 153/197] Add best to avoid name conflict. --- scripts/run_adaptation_experiments.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 36af66b..f60ee30 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1465,10 +1465,13 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) else: hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: - hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: - hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. From 09b35a96507ee0a3a3187da18dd57492c3a3bbad Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 22:37:00 -0700 Subject: [PATCH 154/197] Add best to avoid name conflict. --- scripts/run_adaptation_experiments.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 36af66b..f60ee30 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1465,10 +1465,13 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = range_hyper('optimizer.args.lr', [1e-3]) else: hyperparams_list = range_hyper('optimizer.args.lr', [sweep_lrs[0]]) + # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: - hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: - hyperparams_list = range_hyper('optimizer.args.lr', [3e-4]) # TODO: change + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. From 558037ce37209c5ce9629dad8110a7fd95e007d0 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 22:42:46 -0700 Subject: [PATCH 155/197] Fix arg name. --- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/baseline_train.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index f60ee30..9d3f79d 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1965,7 +1965,7 @@ def get_unparsed_options_dict(unparsed): parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) - parser.add_argument('--replications_one_run', action='store_true', + parser.add_argument('--replication_one_run', action='store_true', help='Only run one hyperparameter setting, but all replications.', required=False) parser.add_argument('--no_replications', action='store_true', diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 5141015..7aad99e 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -100,14 +100,17 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na elif (config['train_dataset']['classname'] == 'datasets.wilds.WILDS' and config['train_dataset']['args']['dataset_name'] == 'camelyon17'): dataset_name = 'camelyon17' + logging.info('dataset_name: ' + dataset_name) split_name = loader_name if split_name == 'ood_val': split_name = 'val' elif split_name == 'ood_test': split_name = 'test' + logging.info('split_name: ' + split_name) seed = config['seed'] file_name = '{dataset}_split:{split}_seed:{seed}_epoch:{epoch}_pred.csv'.format( dataset=dataset_name, split=split_name, seed=seed, epoch=epoch) + logging.info('file_name: ' + file_name) file_path = log_dir + '/model_preds/' + file_name with open(file_name, "w") as f: f.write(pred_string) From f32a864b6d09665068329d84f5a9d9ce8707a5e9 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 22:42:46 -0700 Subject: [PATCH 156/197] Fix arg name. --- scripts/run_adaptation_experiments.py | 2 +- unlabeled_extrapolation/baseline_train.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index f60ee30..9d3f79d 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1965,7 +1965,7 @@ def get_unparsed_options_dict(unparsed): parser.add_argument('--only_one_run', action='store_true', help=('Only run one hyperparameter setting, e.g. for debugging' '(also do not run replications).'), required=False) - parser.add_argument('--replications_one_run', action='store_true', + parser.add_argument('--replication_one_run', action='store_true', help='Only run one hyperparameter setting, but all replications.', required=False) parser.add_argument('--no_replications', action='store_true', diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 5141015..7aad99e 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -100,14 +100,17 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na elif (config['train_dataset']['classname'] == 'datasets.wilds.WILDS' and config['train_dataset']['args']['dataset_name'] == 'camelyon17'): dataset_name = 'camelyon17' + logging.info('dataset_name: ' + dataset_name) split_name = loader_name if split_name == 'ood_val': split_name = 'val' elif split_name == 'ood_test': split_name = 'test' + logging.info('split_name: ' + split_name) seed = config['seed'] file_name = '{dataset}_split:{split}_seed:{seed}_epoch:{epoch}_pred.csv'.format( dataset=dataset_name, split=split_name, seed=seed, epoch=epoch) + logging.info('file_name: ' + file_name) file_path = log_dir + '/model_preds/' + file_name with open(file_name, "w") as f: f.write(pred_string) From efc99a50f28f0116b0dd0624bcf6023f475fcb28 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 23:31:36 -0700 Subject: [PATCH 157/197] Debug --- unlabeled_extrapolation/baseline_train.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 7aad99e..dc4fa5a 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -878,8 +878,12 @@ def setup(): config = json.load(json_file) else: config = quinine.Quinfig(args.config) + logging.info('config before command line') + logging.info(config) # Update config with command line arguments. utils.update_config(unparsed, config) + logging.info('config after command line') + logging.info(config) # This makes specifying certain things more convenient, e.g. don't have to specify a # transform for every test datset. preprocess_config(config, args.config) From 5ec49e990c6ce98f4f06fe977ee0def7ad310627 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 9 Oct 2022 23:31:36 -0700 Subject: [PATCH 158/197] Debug --- unlabeled_extrapolation/baseline_train.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 7aad99e..dc4fa5a 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -878,8 +878,12 @@ def setup(): config = json.load(json_file) else: config = quinine.Quinfig(args.config) + logging.info('config before command line') + logging.info(config) # Update config with command line arguments. utils.update_config(unparsed, config) + logging.info('config after command line') + logging.info(config) # This makes specifying certain things more convenient, e.g. don't have to specify a # transform for every test datset. preprocess_config(config, args.config) From 866072e152c0975a75ffbf590b12824769685cb1 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 11 Oct 2022 21:21:32 -0700 Subject: [PATCH 159/197] Add high rest fmow --- .../adaptation/fmow_all_nonorm_weakaugs_highres.yaml | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml index 0bb0fd2..a6bedd4 100644 --- a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml +++ b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml @@ -5,8 +5,9 @@ inherit: num_classes: 62 epochs: &epochs 5 batch_size: 32 -batch_splits: 2 +batch_splits: 4 save_no_checkpoints: True +save_wilds_model_preds: True model: classname: models.imnet_resnet.ResNet50 @@ -52,6 +53,12 @@ test_datasets: split: 'id_val' regions: ['all'] root: 'wilds/data' + - name: 'id_test' + classname: datasets.fmow.Fmow + args: + split: 'id_test' + regions: ['all'] + root: 'wilds/data' - name: 'ood_val' classname: datasets.fmow.Fmow args: @@ -64,7 +71,6 @@ test_datasets: split: 'test' regions: ['all'] root: 'wilds/data' - - name: 'africa_test' classname: datasets.fmow.Fmow args: From dc2859013df4e986f21349b6990e53ce18b9b0c2 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 11 Oct 2022 21:21:32 -0700 Subject: [PATCH 160/197] Add high rest fmow --- .../adaptation/fmow_all_nonorm_weakaugs_highres.yaml | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml index 0bb0fd2..a6bedd4 100644 --- a/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml +++ b/configs/adaptation/fmow_all_nonorm_weakaugs_highres.yaml @@ -5,8 +5,9 @@ inherit: num_classes: 62 epochs: &epochs 5 batch_size: 32 -batch_splits: 2 +batch_splits: 4 save_no_checkpoints: True +save_wilds_model_preds: True model: classname: models.imnet_resnet.ResNet50 @@ -52,6 +53,12 @@ test_datasets: split: 'id_val' regions: ['all'] root: 'wilds/data' + - name: 'id_test' + classname: datasets.fmow.Fmow + args: + split: 'id_test' + regions: ['all'] + root: 'wilds/data' - name: 'ood_val' classname: datasets.fmow.Fmow args: @@ -64,7 +71,6 @@ test_datasets: split: 'test' regions: ['all'] root: 'wilds/data' - - name: 'africa_test' classname: datasets.fmow.Fmow args: From 0f4b6dad6d836acc1630e192b9bf8ac5128c2db3 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 5 Nov 2022 22:54:32 -0700 Subject: [PATCH 161/197] address reviewer comments --- configs/adaptation/resnet50_transfer.yaml | 1 + configs/adaptation/waterbirds.yaml | 3 +- ...nalyze_dataset_stats_model_gradients.ipynb | 12 +- ...eeze-embed-paper-fine-tuning-results.ipynb | 993 ++++++++++++++++-- ...oad_models_test_get_layers_gradients.ipynb | 252 ++++- scripts/run_adaptation_experiments.py | 2 +- scripts/run_rtx_sbatch.sh | 1 + scripts/run_sphinx_sbatch.sh | 1 + unlabeled_extrapolation/baseline_train.py | 15 +- .../models/imnet_resnet.py | 21 + 10 files changed, 1192 insertions(+), 109 deletions(-) diff --git a/configs/adaptation/resnet50_transfer.yaml b/configs/adaptation/resnet50_transfer.yaml index e6030e0..05ed519 100644 --- a/configs/adaptation/resnet50_transfer.yaml +++ b/configs/adaptation/resnet50_transfer.yaml @@ -15,6 +15,7 @@ optimizer: args: lr: 0.03 momentum: 0.9 + weight_decay: 0.0 criterion: classname: torch.nn.CrossEntropyLoss diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index f508c49..8798441 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -11,8 +11,7 @@ save_no_checkpoints: True model: classname: models.clip_model.ClipModel - args: - model_name: 'ViT-B/16' + args: {} scheduler: classname: torch.optim.lr_scheduler.CosineAnnealingLR diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index c41625a..a0f485e 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -113,7 +113,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhsAAAEUCAYAAACCmfT1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAxOAAAMTgF/d4wjAAArTUlEQVR4nO3dfXxU1b3v8c+PJIPaVBC0lp5ASBihgEBQRDFAVdRgj9dDrVdEo4JWylUqp9Sn9tre8/Cyaq0PR/QWqSLtAdta9SJ9aU1F5AjjEcEaQEFgEpKAFm0TYokPDJOs+8eexBDyMCGzMzPJ9/16zSsze+299pqVefjNWmuvZc45RERERPzSJ9kFEBERkZ5NwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPgqM1kn7tu3rzvppJOSdXoRERE5Cu+//37EOde3M8ckLdg46aST2Lt3b7JOLyIiIkfBzP7a2WPUjSIiIiK+UrAhIiIivkpaN4qIiPRcDQ0NaO2t9GRm9OmT2LYIBRsiIpIwkUiEqqoqDh06lOyiSBdkZWUxZMgQAoFAQvJTsCEiIglTVVXFl7/8ZQYOHIiZJbs4chScc1RXV1NVVUUwGExIngo2RDrgnCO0J0S4JkxwQJDCwYX6EBVpRUNDA4cOHWLgwIFkZurrJZ0NHDiQmpoaGhoaEtKloleDSDsqayspWl7E7trdBDICROoj5PXPo6S4hNz+uckunkhKaRyjoWA8/TX+DxM17kZXo4i0wTlH0fIiymrKiNRHqIvUEamPUFZTxvQV0zX4TUQkTgo2RNoQ2hOioraCqIsetj3qopTvLye0J5SkkolIon3wwQdMmTKlzfQTTzyRioqKVtMmTJjA2rVrATjnnHNYuXJlp869du1aCgoKOnVMulGwIdKGcE2YrIysVtMCfQKEa8LdXCKRnsk5x/r161m2bBnr169PSqvh1772NdatW9ft5+1u0Wi04518EFewYWYPm1mFmTkzK4htO8bMVprZTjPbbGYvm1lihq2KpIDggCCR+kiraZGGCMEBermLdFVlZSUjR45k2rRpfO9732PatGmMHDmSysrKhORvZtx1112ceeaZDB06lJUrV3L33XczYcIETjnllKYWiYqKCvr379903KpVqxg5ciRjx47ltttuOyzP119/nYKCAk499VTmzJnT5hf4gQMHuOGGG5g4cSJjx45l7ty5RCKtf6Y0ikajFBUVMWHCBEaPHs2VV17JJ598AsDFF1/MU0891bTvn/70J84888wOz3XOOedw8803M2nSJC688EL++te/cuGFFzJmzBjGjh3LnDlzOlWnRyPelo1ngMlAy//+EmCEc24c8DzweALLJpJUhYMLyeufR6YdPo460zLJPyGfwsGFSSqZSM/gnKOoqIiysjIikQh1dXVEIhHKysqYPj1x46Kys7PZsGEDTzzxBMXFxQwaNIhNmzbx05/+lFtvvfWI/T/66CPmzJnDs88+y5YtWwgGg1RXVwPePCIzZ87k5z//Oe+88w6zZs1i8+bNrZ73Bz/4AVOmTOHNN99k8+bNNDQ08B//8R/tljUjI4OnnnqKTZs28c4779CvXz8WLVoEwIIFC3jkkUea9n300UeZP39+XOfauXMnr732GmvWrGH58uXk5eWxdetWtmzZwv3339+5Cj0KcQUbzrnXnHN7W2z73Dn3ovvi1fAGMDTB5RNJGjOjpLiEYQOGEcgIkJ2VTSAjQHBgkJLiEo24F+miUChERUXFES0D0WiU8vJyQqHEjIuaOXMm4I2t+OSTT7jiiisAmDhxIrt27Tpi/zfeeIOxY8cyatQoAK6//vqmya3ee+89MjMzOf/88wG48MILyc/Pb/W8K1eu5L777qOgoIDx48ezbt06wuH2u1+dczz44IOMHz+esWPH8sILL1BaWgrABRdcwMcff8zbb79NZWUlb775Jpdffnlc5youLiYry+sWPuuss/jjH//ID37wA55//nm+9KUvxVWPXZHIS18X4LVuiPQYuf1z2X7Tds2zIeKDcDhMVlYWBw8ePCItEAgQDoeZPHlyl89zzDHHAF6rQcvH8Yxh6Oj93la6c45nn32W4cOHx13Wp556ijVr1vBf//VfHH/88Tz88MOsWbOmKf3mm29m0aJFnHzyyVx33XX07ds3rnNlZ2c33Z80aRKlpaWsXr2a5557jh//+Me8/fbbTfXjh4QMEDWzHwFB4Ift7LPQzPY23urq6hJxahHfmRmTh0xmdsFsJg+ZrEBDJEGCwWCbYxgikUjCZq/srEmTJrFlyxbee+89AJYuXdpUzq9//etEo1FeffVVAFavXk1ZWVmr+cyYMYN77723KaDZv39/hy0b+/fv58QTT+T444/nwIEDLFu27LD0q6++mpKSEp588knmzZt3VOfavXs32dnZXH755SxatIidO3fi93dyl4MNM7sFuBS4yDn3aVv7OececM7lNN6aR1kiItL7FBYWkpeXd8Rso5mZmeTn51NYmJxxUSeddBJLly7lW9/6FuPGjWPXrl0MHDgQ8Fpcfve73/H973+fMWPG8NRTTzFu3LhW83nwwQc59thjKSgoYOzYsUybNq3Ny2cbXXPNNXz66aeMGDGCiy666IjLcY877jguvfRSCgsLGTx48FGda+3atZx++ukUFBRw9tlnc99999GvX7/4K+goWGcG4JhZBTDDOVcae7wQuAo43zm3vzMnzsnJcXv37u14RxERSQv19fXs3LmT4cOHx90kX1lZSVFREbt37yYQCBCJRMjPz6ekpIQhQ4b4XOL0U19fz+mnn86iRYvanRckEedp639pZu8753I6k19cYzbM7DHgH4GvAiVmdgA4B7gfKAdejTUtH3TOndmZAoiISO+Vm5vL9u3bCYVChMNhgsEghYUaF9WaVatWcfPNN7fa4pHqOtWykUhq2RAR6VmOpmVDUlOiWzY0g6iIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIJJVzjvVV61lWuoz1VYldYt7MqK2tPapjKyoqWLx4cZvpy5YtY8aMGUdXsF4mkWujiIiIdEplbSVFy4vYXbubQEaASH2EvP55lBSXkNs/N6llaww2mk8LnizRaPSImVbTiVo2REQkKZxzFC0voqymjEh9hLpIHZH6CGU1ZUxfkbgl5hvdcsstnHHGGRQUFDB16lR27NgBwGeffcbMmTMZNWoU48aN48ILLwRg3rx57Nixg4KCAi655JJ28963bx/nnnsup59+OqNHj2b+/Pk0NDQAMGbMGF5//fWmfZcsWdK0Eu2+ffu4/PLLmThxImPGjOHOO+9s2m/o0KHcfvvtTJw4kWuvvTahddHdFGyIiEhShPaEqKitIOpaLDHvopTvLye0JzFLzDe6/fbb2bhxI6Wlpdx4440sWLAAgJdeeona2lq2bdvG5s2b+e1vfwvA4sWLGTFiBKWlpaxatardvPv3788f/vAH3nrrLbZs2UJFRQVPP/004K3U+sgjjzTt++ijjzJ//nwArr32Wm666SbefPNN3n77bTZt2sTvf//7pn2rq6vZsGEDK1asSGhddLf0bZMREZG0Fq4Jk5WRxcH6VpaY7xMgXBNm8pCuLzHf6OWXX2bRokUcOHCAhoYGampqABg3bhzbt2/nxhtv5Bvf+Abf/OY3O513Q0MDt99+O+vXe2NOPvroI0499VSuuOIKiouL+clPfsKHH37Irl27MDOmTJnCJ598wiuvvMKHH37YlE9dXV1TiwvA7Nmze8TU7Qo2REQkKYIDgkTq21hiviFCcEDilpivqqpi/vz5bNy4kWHDhrFlyxamTp0KQH5+Ptu2bWPNmjWsXr2a2267jdLS0k7l/8ADD/DRRx+xYcMGjjnmGBYuXMjnn38OwLHHHsvs2bN57LHH2L59OzfddBNAUzfRG2+8wTHHHNNqvj1lhXR1o4iISFIUDi4kr38emdZiiXnLJP+EfAoHJ26J+Y8//pisrCwGDRqEc+6wbo29e/diZlxyySX8/Oc/xznHnj17OP744/n444/jyn///v189atf5ZhjjmHfvn2HdYUA3HTTTSxZsoQ1a9Zw1VVXAV4gce6553LPPfc07ffBBx/QE9cNU7AhIiJJYWaUFJcwbMAwAhkBsrOyCWQECA4MUlJcktDugzFjxnDFFVcwevRozjjjjMOWr9+6dSuFhYWMGzeO8ePHc/XVVzN27FjGjh3L6NGjOfXUUzscILpgwQI2bNjA6NGjufrqqzn//PMPS8/JyWH8+PEUFxdz3HHHNW1fsWIF4XCYU089lTFjxnDppZdSXV2dsOedKrTqq4iIJMTRrvrqnCO0J0S4JkxwQJDCwT1viflPPvmEESNGsG7dOvLy8pJdnA5p1VcREelRzIzJQyYzu2A2k4dM7nGBxuLFi/n617/OjTfemBaBhh80QFRERMRH8+bNS4mJwZJJLRsiIiLiKwUbIiIi4isFGyIiIuIrBRsiIiLiKwUbIiLSYz3//POMHDmSgoICtm7dSkFBAQcOHOhUHmvXruWll15qM3327Nk89NBDXSxpz6arUUREJLmcg1AIwmEIBqGwEBJ0+evixYv5yU9+wqxZswDanIa8vSXc165dS21tLdOnT09ImboiXZeaV8uGiIgkT2UljBwJ06bB977n/R050tveRTfffDPr1q3jRz/6EWeffTbgzelRW1sLHLmE+65du5pmEm1c7r20tJTFixezYsUKCgoK+Ld/+7d2z/nKK68wadIkxo8fz+jRo3niiScAbxryk08+mU8//bRp3yuvvJJf/OIXAGzcuJHzzjuPCRMmMH78+KbpzisqKujfvz+33347p5122mHTrKeT9AuPRESkZ3AOioqgrAyiUYjEFmUrK4Pp02Hbti61cDz88MNs2bKFf/7nf2bGjBmt7tO4hLuZsWDBAi6++GJ++MMfAlBTU8OAAQOYN28etbW1cXWVnHbaaaxfv56MjAxqamoYP348RUVF5OTkcP7557N8+XLmzp3Lhx9+yOrVq1myZAm1tbXMnTuXF198kUGDBvG3v/2N0047rSlA+vjjjxk9ejT33nvvUddFsinYEBGR5AiFoKLCCzSai0ahvNxLn5y4JeZb03wJ96lTp3LrrbdSV1fHN77xjSPWN4lHdXU1119/PTt37iQzM5Pq6mreeecdcnJyWLBgATfccANz587ll7/8JbNmzSI7O5sXX3yR8vJyLrroosPy2rFjB/n5+WRlZVFcXJyQ55ss6kYREZHkCIchK6v1tEDAS/dZ8yXcv/3tbxMKhRgxYgSPPPIIF198cafzmzdvHpMnT2br1q2UlpYyfPjwpqXmJ06cyHHHHcerr77KkiVLDltqfvTo0ZSWljbdqqqqOO+88wA47rjj6NMnvb+u07v0IiKSvoLBL7pOWopEvPRutGvXLk4++WSuueYafvazn/HGG28AdHqp+dzcXMyM1157jc2bNx+WvmDBAq655hpGjhzJ8OHDATj77LPZvXs3q1evbtqvtLSUSFt1k4biCjbM7GEzqzAzZ2YFzbafYmavm9lOM9toZqN9K6mIiPQshYWQlwctr67IzIT8fC+9Gz3zzDOMGTOG8ePHM3PmTBYvXgzAt771LUpLS+MaIHrPPfdwxx13UFBQwNKlSznzzDMPS7/sssuoq6tj/vz5TdtOOOEEXnjhBX76058ybtw4Ro0axR133EFDQ0Pin2SSxLXEvJlNBcqB9cAM51xpbPsa4NfOuWVmdhlwu3PujHhOrCXmRUR6lqNaYr6y0hskunu313USiXiBRkkJDBnib4GTYNOmTVx55ZW89957Kd01kugl5uMaIOqcey12guYn+wowAbgwtulZ4BEzCzrn/O9oExGR9JebC9u3+zbPRir5zne+w5/+9Ccef/zxlA40/NCVq1EGA39xzkUBnHPOzKqAIcARwYaZLQQWNj7u169fF04tIiI9hpl31YnPV54k2+OPP57sIiRNt4VWzrkHnHM5jbfmI4BFRESk5+pKsLEHGGRmmQDm9bEMAaoSUTAREUkvjV3t8YwFlNTW+D+0BHVnHXU3inPuIzP7M1AMLAO+DezVeA0Rkd6pT58+ZGVlUV1dzcCBAxP2RSXdyzlHdXU1WVlZCRtbEu/VKI8B/wh8FagGDjjngmY2Ai/QGAj8HZjjnNsaz4l1NYqISM8TiUSoqqri0KFDyS6KdEFWVhZDhgwhEAgckXY0V6PEFWz4QcGGiEjP1dDQoO6UNGVm7bZo+Hbpq4iISGf0tks7pX16NYiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivFGyIiIiIrxRsiIiIiK8UbIiIiIivEhJsmNk3zezPZlZqZu+Y2bWJyFdERETSX2ZXMzAzA5YD5zjntpjZUOA9M3vOOXegq/mLiIhIektUN4oD+sfuHw9UAwcTlLeIiIiksS63bDjnnJnNBJ4zs0+AE4BLnXORLpdORERE0l6XWzbMLBO4Ey/AyAWmAf9pZie22G+hme1tvNXV1XX11CIiIpIGEtGNUgB8zTn3GoBzbiOwFxjffCfn3APOuZzGW3Z2dgJOLSIiIqkuEcHGHmCQmY0EMLMgMAzYkYC8RUREJM0lYszGh2Y2F3jazBrwApj5zrmqLpdORERE0l6Xgw0A59xvgN8kIi8RERHpWTSDqIiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+Coz2QUQkZ7DOUdoT4hwTZjggCCFgwsxs2QXS0SSTMGGiCREZW0lRcuL2F27m0BGgEh9hLz+eZQUl5DbPzfZxRORJFI3ioh0mXOOouVFlNWUEamPUBepI1IfoaymjOkrpuOcS3YRRSSJFGyISJeF9oSoqK0g6qKHbY+6KOX7ywntCSWpZCKSChRsiEiXhWvCZGVktZoW6BMgXBPu5hKJSCpRsCEiXRYcECRSH2k1LdIQITgg2M0lEpFUkpBgw8z6mtkjZrbLzLaa2fJE5Csi6aFwcCF5/fPItMPHnGdaJvkn5FM4uDBJJRORVJColo17AAcMd86NAW5JUL4ikgbMjJLiEoYNGEYgI0B2VjaBjADBgUFKikt0+atIL2ddHSVuZl8C/gLkOOf+Hu9xOTk5bu/evV06t4ikFs2zIdLzmdn7zrmcTh2TgGBjLLAK+C1wPvAZ8C/OuVfaO07BhoiISPo5mmAjEd0omUAusM05NwG4GfidmZ3conALzWxv462uri4BpxYREZFUl4hgowpoAFYAOOfeBnYDY5rv5Jx7wDmX03jLzs5OwKlFREQk1XU52HDO/Q14BSgCMLM8IA/Y3tW8RUREJP0lam2UecATZnYvXivHd51z7ycobxEREUljCQk2nHPlwLmJyEtERER6Fs0gKiIiIr5SsCEiIiK+UrAhIiIivlKwISIiIr5SsCEiIiK+UrAhIiIivlKwISIiIr5SsCEiIiK+StQMoiIi3hLzoRDhcJhgMEhhoZaYFxEFGyKSIJWVlRQVFbF7924CgQCRSIS8vDxKSkrIzc1NdvFEJInUjSIiXeaco6ioiLKyMiKRCHV1dUQiEcrKypg+fTrOuWQXUUSSSMGGiHRZKBSioqKCaDR62PZoNEp5eTmhUChJJRORVKBgQ0S6LBwOk5WV1WpaIBAgHA53c4lEJJUo2BCRLgsGg0QikVbTIpEIwWCwm0skIqlEwYaIdFlhYSF5eXlkZh4+5jwzM5P8/HwKCwuTVDIRSQUKNkSky8yMkpIShg0bRiAQIDs7m0AgQDAYpKSkRJe/ivRyuvRVRBIiNzeX7du3a54NETmCJeuStJycHLd3796knFtERESOjpm975zL6cwx6kYRERERXynYEBEREV8p2BARERFfKdgQERERXynYEBEREV8p2BARERFfKdgQERERXynYEBEREV8p2BARERFfJTTYMLM5ZubMbEYi8xUREZH0lbBgw8yGAjcAbyQqTxEREUl/CQk2zKwP8DjwPeBgIvIUERGRniFRLRsLgZBz7q0E5SciIiI9RJeXmDezU4FvA1M72G8hXlACQL9+/bp6ahEREUkDiWjZmAIMBXaZWQVwFrDEzP5X852ccw8453Iab9nZ2Qk4tYiIiKS6LgcbzrlfOOcGOeeGOueG4g0Qneuc+0WXSyciIiJpT/NsiIiIiK+6PGajJefcOYnOU0RERNKXWjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFcKNkRERMRXCjZERETEVwo2RERExFeZyS6ASMpzDkIhCIchGITCQjBLdqlERNKGgg2R9lRWQlER7N4NgQBEIpCXByUlkJub7NKJiKQFdaOItMU5L9AoK/OCjLo6729ZGUyf7qWLiEiHFGyItCUUgooKiEYP3x6NQnm5ly4iIh1SsCHSlnAYsrJaTwsEvHQREemQgg2RtgSDXrdJayIRL11ERDqkYEOkLYWF3mDQzBbjqDMzIT/fSxcRkQ51Odgws2PMbKWZ7TSzzWb2spnpJ5+kPzPvqpNhw7xuk+xs728w6G3X5a8iInFJ1KWvS4A/Ouecmc0HHgfOSVDeIsmTmwvbt2ueDRGRLjCX4Mv3zGwC8Ixzbmh7++Xk5Li9e/cm9NwiIiLiLzN73zmX05lj/BizsQB43od8RUREJA0ldAZRM/sREASmtZK2EFjY+Lhfv36JPLWIiIikqIR1o5jZLcAVwPnOudqO9lc3ioiISPo5mm6UhLRsxFotZhFnoCHJ55wjtCdEuCZMcECQwsGFmAY9ioiID7ocbJhZDnA/UA68GvvCOuicO7OreYs/KmsrKVpexO7a3QQyAkTqI+T1z6OkuITc/lpcTEREEivhV6PES90oyeGcY+SjIymrKSPqvljzI9MyCQ4Msu3GbWrhEBGRNqXK1SiSwkJ7QlTUVhwWaABEXZTy/eWE9mhxMRERSSwFG71MuCZMVkbri4sF+gQI12hxMRERSSwFG71McECQSH3ri4tFGiIEB2imeRERSSwFG71M4eBC8vrnkWmHjw3OtEzyT8incLAWFxMRkcRSsNHLmBklxSUMGzCMQEaA7KxsAhkBggODlBSXaHCoiIgknK5G6aU0z4ZIcuk9KOnqaK5GUbAhItLNNNeNpDNd+ioikuKccxQtL6KspoxIfYS6SB2R+ghlNWVMXzGdZP0AFPGTgg0RkW6kuW6kN1KwISLSjTTXjfRGCjZERLqR5rqR3qjHBBvOOdZXrWdZ6TLWV61Xv6eIpCTNdSO9UUKWmE82jewWkXTRONdN02dWnwCRhgj5J+RrrhvpsdL+0letYiqSQpyDUAjCYQgGobAQ9P5rlebZkHR1NJe+pn3LRjwjuycPmZyk0on0IpWVUFQEu3dDIACRCOTlQUkJ5KqFsSUzY/KQyfp8kl4h7cdsaGS3SApwzgs0ysq8IKOuzvtbVgbTp3vpItJrpX2woZHdR8k5WL8eli3z/urLQLoiFIKKCoge3sJINArl5V66iPRaad+N0jiyu6w6zJmV9QRrIDwANuRmaGR3W9TcLYkWDkNWFhw8eGRaIOClT1Z3gUhvlfbBhpmxeuoTRC44l3+orudQBmTVw/snZtD35Sc04Kql5s3d0agXaMAXzd3btmlAn3ReMPjFa6mlSMRLF5FeK+27UXCOnMuvJ6/G0bcesiPQtx7yqhv4h8uvV/dAS2ruFj8UFnqtY5ktfr9kZkJ+vpcuIr1W+gcbsS9Pa/HlafrybF1jc3drGpu7RTrLzOuGGzbMex1lZ3t/g0Fvu1rLRHq1tO9GUV9xJ6m5u9MaGhpYvHgxf/7znznttNOYN28effqkf5yecLm5sH275tmQxNP8LfFL0bpK+0m9WL8epk1r/Qs0EIBXXlGw0ZxzMHLkF2M2GmVmei9Mjdk4TCgUYurUqTQ0NDRt69OnD6+99hqF6hoQ8Z8GtMevm+rqaCb1Sv9gQ1+endfaCzI/33tBDhmS7NKljIaGBjIyMtpMr6+vVwtHC9FolKuuuorS0lIKCgpYsWIFmS3HcYjES5/v8evGujqaYCP9PynVV9x5ubm4bdvY8uCDrJ85ky0PPoh7910FGi089NBDXUrvbRYvXkxWVhZPP/00O3fu5OmnnyYrK4vFixcnu2ipSXPddEwD2uOX4nWV/i0bMftrarhk4ECGAWXAqupqThgwIGH59ySVlZVccMEFlJeXY2Y458jPz+fll18mV82STbKysoi2fOM2k5mZyaFDh7qxRKkrGo2S1dbAY+DQoUNq4WhOXQPxWbaM+htvJOOzz45Iih53LJmP/l+YPbv7y5WKurGuemfLBjBo0CAGDBzIeuBXwHpgwMCBDBo0KMklSz3OOaZMmcKuXbuor68nGo1SX1/Prl27mDp1KskKPlNRe4FGPOm9yaxZs7qU3qvE5rpxLaZ2d5ra/QgN+flEDx755QlQ//lnNOTnd3OJUleq11VCgg0zO8XMXjeznWa20cxGJyLfeOzfv599+/a1mrZv3z7279/fXUVJC+vWrWPPnj2tplVVVbFu3bpuLlHqCgQCXUrvTVatWtWl9F4lFCIaDrd6uX50166kN3enkkdrSik/AQ616A0/ZFB+gpcunlSvq0S1bDwGLHHODQfuBZYlKN8ODeigq6Sj9N5mxowZXUrvTSJtXSIcZ3pvorqKX3THDj6rr2817bP6eqI7dnRziVLXY88sYfpMbwmKgxlwIMv7Gx4IRTO9dPGkel11uRPVzL4CTAAujG16FnjEzILOOc0QlWI6aulRS5CIvxY++ij3tZEWiKU/fP313VmklPX5B59TlQej5kNhFU1rX4WGAPUwbPvnyS5iykj1ukpEy8Zg4C/OuSiA8zr9q4DDLm0ws4VmtrfxVldXl4BTi4ikl6fff59yoOXQ4kNAeSxdPBePuxj2Aw0QyoVfjff+0gDsj6ULkPp11eWrUczsdOAp59yIZtveBO5wzq1p67hEXY0Sz0JrGvT4BdVX/FRX8VNdxe+8886j7NVXeQnIByJ4LRrlQBEQPPdc1qxp86OzV6mvrydzYCYUAycA9UAG3pfqcohWR9udC6c36c66StbVKHuAQWaWGSuE4bVqVCUg7w6FO1jLo6P03mbp0qVdSu9NPvjggy6l9yY7d+7sUnpvUlJSQhUwCpgGfC/2dxTeh2lJSUkSS5daMjIyeOaJZ+BR4NfAH2N/H4XnnnxOgUYzqV5XCZlnw8zWAsucc8vM7DK8Vo0J7R2TyHk22vtVpV9TR1J9xa9v376tDm7s27cvn3+u/uLm9LqK31133cWdd955xPa7776bO+64IwklSm319fXceuutbNq0iQkTJnDfffcl/cszVXVHXSVtunIzG4F3BcpA4O/AHOfc1vaOSfSkXmVlZQSbLSIWDocZNmxYwvLvaZ588kmuu+66psdLly5lzpw5SSxR6vrLX/7C1772tabHH3zwgeZwacOuXbsYPnx40+OdO3dyyimnJLFEqevQoUMUFRWxbds2Ro0aRUlJSbsTo4mkit65NoqIiIh0m147g6iIiIikLgUbIiIi4isFGyIiIuIrBRsiIiLiKwUbIiIi4qukXY1iZgeBv/qQdTagudDjp/qKn+oqfqqr+Kmu4qe6ip+fdXWSc65vZw5IWrDhFzPb29lLcnoz1Vf8VFfxU13FT3UVP9VV/FKtrtSNIiIiIr5SsCEiIiK+6onBxgPJLkCaUX3FT3UVP9VV/FRX8VNdxS+l6qrHjdkQERGR1NITWzZEREQkhSjYEBEREV8p2BARkR7BzP7FzI5p8fivZlYau61oltbHzBaZWZmZhc1sfnJK3T1aqZt/NLO3zOygmT3UYt8266a949qTVsGGmVWYWUHs/uNmdm4X8nJm1j9RZUtVqrPOMbNLzOzB2P2hZjYvjmPOMbNS3wuXJGb2t1hdvGhmI3zIv0fXn99afom0s1+3v3/NLLM7zwf8H6BlXaxwzhXEblc1214MjAKGAxOBW81sdDeVMxXqZhdwHXBfK/u2VzftHdemtAo2mnPOfcc592qyy5FOVGcdc86tcs59P/ZwKNBhsNFbOOe+6ZzbkexyyBFa+4JNmlhQ869mthG428y+bGa/NLM3zWyLmS0xs0Bs3zvNbHuzlofcZnn8KHbMbjOb0yz/U8zsBTPbGMtvfmz74tgu62J5faWDos4Efumcq3fO1QC/A2Yluj6aS6W6cc7tdM5tBqKtFLXNuunguDalbLBhZpPMbL2ZbY5V2j+1SF9rZjNi95eZ2VIze93MdprZr8zs2DhOc4uZvR075qqOd09t3VRnPYKZ/W8ze6TZ42wzqzGzW81sZWzzYmBE7M25qoMsM83s12b2jnlNjAU+Fd13sdad7bHX0M+abW/eSrbWzH5uZuvMa2pd3Gy/r5jZc2a2NVYf343jtEmvv9beP2Y2IfYe2RL7cC+M7TvUzGpjXxxvmdfU/M1YWluvrZPMbLaZrTaz38TqZ5OZ5Tfb92oz22Bmfzaz18xsnHlN2i+Z2S2xfYaZ2V4zG9Hal0gHT7O7PvPqnXNnOOduBe4H1jnnJgLj8L53FpjZCcAtwGnOuQLgbODDZnkcjB1zEfCwmWWaWQbwG+AHzrkzgLOAuWZ2hnOu8YfBlFgrxkexx/8z9j9dY4e37A4BKps9roht81sq1U1bEl83zrmUuwEDYhU7Jfa4T2xbBVAQ27YWmBG7vwx4F/gykAH8AfhRB+dwwL/H7ucDNcDQZD/3NKiz/sl+rgmqr8HAR0Df2OM5wLPAbGBlbNs5QGkceZ0Tq5tpsceXA+8Ru7Q8nW7AV4BqYFTs8dzYcxvaymvp/wGZwLHAbmBSLO13wN3N8tsDnJXK9dfG++crQBVQFNs2GdiHt+bE0FiZvx1Lmw7saO+1Fbs/G/gYyIs9vgd4LHa/EHix2XFTgHdj90+M1fE5wFvArGZlj+t9STd95sXOk9Ps8UfAVqA0dtsBPIb3ubMx9r77botjHPDVZo/3Azl4TfufNcurNFYv17ZWF8BXgaxm9fsRkBt7vLXxNRt7fCPwa59fZylTN82O/xfgoRbbOqyb1o5r75aqLRuT8N646wCccw3Oa8ppz9POuQPOuXrgCeD8OM7zeCz/cuA1YGoXypxs3VVnPYJzbg/wNnBJbNNs4MkuZFnhnHsllvfTeB9yg7tSxiQ5C9jinNsWe/wEEGlj398556LOucYPuGGx7efjfWDivF9Qz9HxayvZ9XfE+wc4GWhwzpXEtq3HC0gKYsd8jvfcAP6b2POP47X138653S2PA/4J79ftBvPGsCwCBpjZsc65v+H1o/8JeMs595ujfJ7d9ZnXfAEwwwvKCmK3Ec6578Y+d84CHsIL7N4wsynNjvu82f16vMDWgJpmeRU45/Kcc79qrRDOuX3OuUOx+yG8/8uEWHIVkNts96GxbX5LibrpQMLrJlWDjUQ4mtnKevsMZ73t+S8F5sSasYPASwnM29Ez6rO959DaB15n82jvvKlYf83LdNDFfuLhPf+MZmntvbbaqjcDftXiy2JQLJgDGI/X6vQPZmY+PB+/rARut9iASDM7wcyCZvZl4GTn3Drn3L8D6/GeY3t2AH+3w8cpBM1sQOzhAaBfs7ScZvdPwQsUt8Y2/R64wcwyYsfPxGuV604rSVLddCDhdZOqwcbrwCmNkVysz3JAB8dcFusbzcBrtlwdx3nmxPIfitdkue7oi5x03VVnPclK4Azgh8By51zLAU9/J/4359DG/mAzuwzvF/DeBJWzO/03MNbMvh57fB0Q6GQeq4EbAMzsJOBS4OUOjkl2/R3x/omVoY+ZXRDbdjZei0tpHPmtpP3XVmtWAcVmNqSxDGY2IXb/NLw+/MYvnNuaHdeZL5FkfOZ9n1jzvpltAV7B+6XcD2gc27MFyALa/RUeq8eLgUtj42jexWt9axxvdj/wcrPxK3fFxgGVAr8FbnLO7Yzt+5943XW78LosHnDObaV7Ja1uzGyame0FFgLXx8YBNbbGtVk3HRzXpu6+9CYuzrn9ZvYt4P5YhNcA/LiDwzYCJcBJeB+YD8Vxqgwzexv4EnCzc67iqAudZN1YZz2Gc+6gmT2N1x85spVdtgDvmtk7QLlzrr031LvAbDN7GK/bYVazX71pwzn3VzO7Dvh/ZhbB+0Ve3clsbgZ+YWZb8X6t3+Wc29DBMUmtv3beP5fiDcC7H69F4jLnXJ2ZndhBfh29tlo7Zp2Z3YZX95l4Qd4LZrYT74vyOufcPjO7BnjTzNbHugYav0Q+BS507Q/+8/0zzzlnLR7XAW3NYXFWnHmc2Ox+GfA/2jjuX4F/bbbp2nbKWQ/c1Fa6H1Ksbl7BG+vR2r5t1k2su7PTS9f3iLVRzGwZ3kC+h5JclLShOhMRke6Sqt0oIiIi0kP0iJaNtsSuQW+tKWpSs0FX0ozqrG1mtokjux7fdYfPSihtUP35T+9fSVU9OtgQERGR5FM3ioiIiPhKwYaIiIj4SsGGiIiI+ErBhoiIiPhKwYaIiIj4SsGGiIiI+Or/A96WhjgtoJIQAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -132,7 +132,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -151,7 +151,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -230,8 +230,8 @@ "# print(df[compute_keys(df)])\n", " return dataset_stats\n", "\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" ] }, diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index c317685..b41bcb4 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -235,84 +235,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "some jobs did not finish: timm_vit_b16_in21k domainnet freeze_bottom_2_opt_torch.optim.AdamW_ ['../logs//full_ft_freeze_bottom_2_opt_torch.optim.AdamW_domainnet_timm_vit_b16_in21k/freeze_bottom_k-2_optimizer.args.lr-3e-06_seed-0_run0']\n", - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.7\t81.0\t97.0\t64.6\t87.4\t69.5\n", - "CLIP ViT-B/16\tAdamW\t97.9\t83.5\t97.7\t71.1\t94.9\t89.3\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t81.9\t97.8\t74.3\t94.6\t87.9\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", - "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", - "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", - "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", - "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", - "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", - "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", - "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", - "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", - "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 ID & Living-17 OOD & Waterbirds ID & Waterbirds OOD & DomainNet ID & DomainNet OOD\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.7 & 81.0 & 97.0 & 64.6 & 87.4 & 69.5\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{97.9} & \\textbf{83.5} & \\textbf{97.7} & 71.1 & \\textbf{94.9} & 89.3\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.0} & 81.9 & \\textbf{97.8} & \\textbf{74.3} & 94.6 & 87.9\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.1} & 82.6 & \\textbf{97.8} & 69.2 & \\textbf{94.8} & \\textbf{89.8}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.5} & \\textbf{89.4} & \\textbf{99.0} & 78.7 & \\textbf{91.5} & \\textbf{86.7}\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.6} & 87.9 & 98.9 & 80.1 & \\textbf{91.5} & 84.4\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{89.5} & \\textbf{99.2} & \\textbf{82.4} & \\textbf{91.5} & 86.3\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.5} & 88.4 & 99.0 & \\textbf{82.4} & 90.8 & 82.6\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & \\textbf{88.2} & 97.0 & 55.6 & 88.0 & 76.2\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.4} & 87.5 & \\textbf{97.9} & 61.2 & 89.1 & 77.5\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.3} & 87.6 & 97.5 & \\textbf{68.5} & 88.9 & \\textbf{78.9}\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & 86.7 & 97.6 & 61.5 & \\textbf{89.6} & 76.4\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{97.3} & \\textbf{85.7} & \\textbf{98.4} & 75.2 & \\textbf{89.0} & 80.9\\\\\n", - "BIT ResNet-50 & AdamW & 97.1 & 83.2 & \\textbf{98.3} & 76.9 & \\textbf{89.2} & \\textbf{84.0}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.5} & 84.4 & \\textbf{98.5} & 75.5 & \\textbf{89.0} & 82.4\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & 83.6 & \\textbf{98.4} & \\textbf{78.5} & \\textbf{89.0} & 83.5\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.2} & 82.2 & \\textbf{98.9} & 79.0 & \\textbf{91.8} & \\textbf{86.0}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.2} & 84.5 & 98.6 & \\textbf{79.4} & 91.0 & 83.7\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{84.9} & \\textbf{98.8} & 78.7 & 91.4 & \\textbf{85.9}\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.1} & 84.1 & 98.7 & 72.0 & 90.6 & 83.9\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.5} & \\textbf{92.1} & 99.0 & 81.3 & 94.6 & 89.8\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & 90.1 & \\textbf{99.4} & 85.8 & 94.0 & 89.9\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.5} & 91.5 & \\textbf{99.3} & \\textbf{88.0} & \\textbf{94.8} & \\textbf{91.5}\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.6} & 89.8 & \\textbf{99.3} & 87.7 & 94.5 & 91.0\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.3 & 84.9 & 96.3 & 56.7 & 84.1 & 60.9\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & 88.4 & \\textbf{98.7} & 86.0 & 96.6 & \\textbf{93.8}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & 98.6 & \\textbf{89.4} & \\textbf{98.7} & 84.9 & \\textbf{96.8} & \\textbf{93.9}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & 98.6 & 88.2 & \\textbf{98.6} & \\textbf{87.5} & \\textbf{96.6} & \\textbf{93.7}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'test_acc/source_val_living'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'test_acc/sketch_val'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sup ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DINO ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-50'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-101'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ConvNext-Base'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'CLIP ViT-L/14'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;31m# supposed to have run each dataset for. Used to validate if the runs finished.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mmean_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmodel_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" ] } ], @@ -394,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -575,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -606,10 +541,10 @@ " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", "\\midrule\n", "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & 92.1\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & 92.1\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & 98.2 & 97.8 & 95.1 & 67.9 & 99.5 & 91.7\\\\\n", + "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", "\\bottomrule\n", "\\end{tabular}\n", @@ -629,7 +564,7 @@ " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", "\\midrule\n", "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & 76.0\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", @@ -637,6 +572,39 @@ "\\bottomrule\n", "\\end{tabular}\n" ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 87.57816667, 66.9715 ,\n", + " 99.3802 , 89.79514667],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 69.58566667, 37.34413333,\n", + " 86.79546667, 67.22942 ],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -661,6 +629,440 @@ "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIP Results for ViT-L" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4118 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 98.2941 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 97.7647 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 95.7059 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 82.8824 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 98.4118 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 84.2353 \n", + "1 83.9412 \n", + "2 81.5294 \n", + "3 68.6471 \n", + "4 42.2353 \n", + "5 89.9412 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3qbk... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/279j... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/j354... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/8695... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/10f5... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2ot2... optimizer.args.lr-3e-05 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.6786 36.7601 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 93.1918 16.3551 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 92.3360 14.4860 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 90.9443 10.4361 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 88.6586 4.5171 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.2767 64.9533 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3lyi... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2sig... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/6l40... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2tso... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3i5g... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/o0ed... optimizer.args.lr-3e-05 \n", + " name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 84.3268 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 79.4081 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 77.3239 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 71.0713 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 14.3393 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 63.0263 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 60.7950 https://wandb.ai/p-lambda/finetuning/runs/24w9... \n", + "1 55.3939 https://wandb.ai/p-lambda/finetuning/runs/1rxe... \n", + "2 47.7315 https://wandb.ai/p-lambda/finetuning/runs/16kz... \n", + "3 32.5940 https://wandb.ai/p-lambda/finetuning/runs/3mr8... \n", + "4 6.9134 https://wandb.ai/p-lambda/finetuning/runs/22r2... \n", + "5 28.7772 https://wandb.ai/p-lambda/finetuning/runs/3ci4... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-0.003 \n", + "4 optimizer.args.lr-0.01 \n", + "5 optimizer.args.lr-3e-05 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 69.0151 67.4215 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 66.9947 65.1218 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 67.1166 64.8506 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 63.6332 60.6076 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 31.0198 26.9646 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 62.7536 62.9274 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 61.3353 40.9950 \n", + "1 57.9473 37.3698 \n", + "2 57.7483 37.0999 \n", + "3 53.9307 33.5904 \n", + "4 22.5032 15.8889 \n", + "5 56.6447 37.6012 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/f1au... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/284k... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/w0s6... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/4aij... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1zj3... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/13fr... optimizer.args.lr-3e-05 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.3474 89.3995 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 99.4219 88.1160 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 99.4487 87.5774 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 98.1585 70.8973 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 97.6579 73.7709 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 99.3206 90.6314 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 92.1544 https://wandb.ai/p-lambda/finetuning/runs/csa6... \n", + "1 84.8908 https://wandb.ai/p-lambda/finetuning/runs/3fwt... \n", + "2 83.2060 https://wandb.ai/p-lambda/finetuning/runs/x1pv... \n", + "3 48.1706 https://wandb.ai/p-lambda/finetuning/runs/fuzi... \n", + "4 55.1614 https://wandb.ai/p-lambda/finetuning/runs/21rv... \n", + "5 95.0526 https://wandb.ai/p-lambda/finetuning/runs/2mb7... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-0.003 \n", + "4 optimizer.args.lr-0.01 \n", + "5 optimizer.args.lr-3e-05 \n", + " name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.4706 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 98.7059 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.4706 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.8824 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 98.2353 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 67.7059 \n", + "1 85.7647 \n", + "2 90.2941 \n", + "3 80.7647 \n", + "4 88.0000 \n", + "5 91.5294 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/8bu0... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2mhb... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1s2a... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/3ci0... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2ypn... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2sn5... optimizer.args.lr-3e-07 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.0114 5.6075 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 98.8165 85.2025 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.3287 85.5140 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 97.9859 65.2648 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.6567 86.2928 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 98.0875 82.0872 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2nee... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/nwln... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3ses... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2ua0... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2cp9... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/yo7d... optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 58.3576 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 96.3318 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 96.3318 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 96.8737 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 95.6232 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 21.4317 https://wandb.ai/p-lambda/finetuning/runs/3jmk... \n", + "1 92.2944 https://wandb.ai/p-lambda/finetuning/runs/1l1o... \n", + "2 92.5825 https://wandb.ai/p-lambda/finetuning/runs/1dab... \n", + "3 85.6834 https://wandb.ai/p-lambda/finetuning/runs/2xnh... \n", + "4 93.7635 https://wandb.ai/p-lambda/finetuning/runs/189b... \n", + "5 90.7677 https://wandb.ai/p-lambda/finetuning/runs/1lui... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 41.2697 38.3279 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 74.4579 72.4429 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 70.3736 68.1647 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 73.1342 70.3339 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 73.5522 70.7959 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 62.6840 61.9483 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 32.2508 21.0567 \n", + "1 67.0979 48.2838 \n", + "2 62.7239 44.0802 \n", + "3 63.6240 43.5789 \n", + "4 64.5649 45.4686 \n", + "5 56.0657 38.4497 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ir1... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2015... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2psl... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/t2pv... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/xprd... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1qdx... optimizer.args.lr-3e-07 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4029 78.5698 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.5411 91.5712 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 99.6216 95.0464 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.2372 84.9587 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 99.6275 94.8229 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 99.4547 93.5366 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 65.6771 https://wandb.ai/p-lambda/finetuning/runs/10mp... \n", + "1 90.2380 https://wandb.ai/p-lambda/finetuning/runs/zur7... \n", + "2 96.4517 https://wandb.ai/p-lambda/finetuning/runs/182q... \n", + "3 84.6251 https://wandb.ai/p-lambda/finetuning/runs/3ct8... \n", + "4 95.9155 https://wandb.ai/p-lambda/finetuning/runs/2uej... \n", + "5 95.9285 https://wandb.ai/p-lambda/finetuning/runs/awtw... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + " name \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 98.7059 90.4706 \n", + "1 98.6471 88.4706 \n", + "2 98.7059 86.1176 \n", + "3 98.0000 81.8824 \n", + "4 96.7059 70.3529 \n", + "5 98.5294 91.7647 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/db01... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2jb3... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/21ja... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1vxt... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2yr9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/32hw... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 98.2503 86.1371 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 98.4706 87.0717 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 98.8519 84.7352 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.3602 76.0125 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.4060 18.6916 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 98.1511 84.7352 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/14mo... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/tsai... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2le0... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/10t5... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2c6t... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2gdu... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name test_acc/sketch_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.0821 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 96.9571 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 96.5402 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.3718 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 83.2847 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 96.1234 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 93.1010 https://wandb.ai/p-lambda/finetuning/runs/2bbx... \n", + "1 94.0804 https://wandb.ai/p-lambda/finetuning/runs/31x1... \n", + "2 92.1504 https://wandb.ai/p-lambda/finetuning/runs/7q05... \n", + "3 79.5189 https://wandb.ai/p-lambda/finetuning/runs/l2xq... \n", + "4 50.2665 https://wandb.ai/p-lambda/finetuning/runs/khjr... \n", + "5 91.7183 https://wandb.ai/p-lambda/finetuning/runs/1z28... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 73.2300 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 74.4927 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 74.1357 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 72.4027 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 63.2761 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 69.6508 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 71.6395 65.5283 47.7825 \n", + "1 72.2420 66.3063 49.9422 \n", + "2 72.2922 65.6324 45.1600 \n", + "3 69.8519 62.5656 41.1492 \n", + "4 60.2661 53.4467 33.5904 \n", + "5 68.0593 62.7510 44.3887 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3ocq... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3vnf... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3naz... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/pn49... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/uoyu... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/jh49... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5650 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.6156 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.5888 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.5769 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 98.4237 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4070 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.8888 96.4599 \n", + "1 95.3472 96.5363 \n", + "2 94.8745 96.3153 \n", + "3 93.8832 94.0156 \n", + "4 75.9025 74.1623 \n", + "5 93.6512 95.9861 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ads... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3mpi... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/13dm... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/wdak... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/v23o... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3fqz... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-B/16\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 1 is out of bounds for axis 0 with size 1", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Liv-17'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"FMoW\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Camelyon\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Avg.\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m id_mean_table, ood_mean_table = display_id_ood_tables(\n\u001b[0m\u001b[1;32m 18\u001b[0m id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_id_ood_tables\u001b[0;34m(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std)\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mno_std\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0mid_std_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 168\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 169\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mdisplay_latex_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_last_avg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m if (std_err_table is not None and\n", + "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 0 with size 1" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 48, @@ -705,6 +1107,433 @@ "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Post ICLR Supplementary results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Big table, including AdamW + Freeze " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", + "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", + "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 88.8 & 67.0 & \\textbf{99.4} & 90.0\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & 95.0 & 70.1 & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & 94.9 & 70.0 & \\textbf{99.5} & 92.1\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & \\textbf{97.8} & \\textbf{95.3} & \\textbf{70.5} & \\textbf{99.6} & \\textbf{92.3}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & 66.4 & \\textbf{99.5} & \\textbf{91.1}\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.6} & \\textbf{99.0} & 90.9 & \\textbf{66.8} & \\textbf{99.5} & \\textbf{91.0}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & 89.4 & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.4} & \\textbf{97.8} & \\textbf{89.7} & 65.7 & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", + "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & \\textbf{98.4} & \\textbf{89.1} & 64.9 & \\textbf{99.6} & \\textbf{89.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.2} & 98.7 & 91.1 & 66.6 & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & 68.8 & \\textbf{99.7} & \\textbf{92.2}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & 92.0\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{99.5} & 94.7 & \\textbf{69.2} & \\textbf{99.6} & \\textbf{92.4}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{98.8} & 96.7 & \\textbf{75.1} & \\textbf{99.6} & \\textbf{93.8}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", + "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", + "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "ConvNext-Base\tAdamW (Freeze-2)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 72.8 & 37.3 & 86.8 & 67.9\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & 95.7 & \\textbf{76.0}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & 82.4 & 69.5 & 88.2 & \\textbf{40.7} & \\textbf{96.7} & 75.5\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & 88.1 & \\textbf{82.4} & 82.3 & 35.7 & 93.0 & 76.3\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & 91.9 & 70.7\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & 86.8 & 64.5 & 76.6 & 35.4 & \\textbf{93.5} & 71.4\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{84.3} & 76.5 & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", + "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & 35.0 & \\textbf{95.2} & 74.4\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & 82.9 & \\textbf{77.3} & 83.3 & \\textbf{36.3} & 93.7 & \\textbf{74.7}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", + "BIT ResNet-101 & AdamW & 82.9 & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & 83.1 & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & 75.6\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{84.8} & 78.3 & 84.3 & \\textbf{38.2} & 95.0 & \\textbf{76.1}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & 39.7 & 83.0 & 77.3\\\\\n", + "ConvNext-Base & AdamW & 90.3 & 89.8 & 89.5 & 38.4 & \\textbf{89.5} & 79.5\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & 79.4\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & 88.1 & \\textbf{91.6} & 89.8 & \\textbf{41.6} & 87.7 & \\textbf{79.8}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & 88.0 & 84.6 & \\textbf{93.8} & 44.6 & \\textbf{96.4} & 81.5\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ResNet-50 waterbirds results " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: sup_resnet50 waterbirds opt_torch.optim.AdamW_ ['../logs//full_ft_opt_torch.optim.AdamW_waterbirds_sup_resnet50/optimizer.args.lr-0.0001_seed-0_run0']\n", + "not all jobs ran: sup_resnet50 opt_torch.optim.AdamW_ waterbirds 4\n", + "some jobs did not finish: sup_resnet50 waterbirds freeze_bottom_2_ ['../logs//full_ft_freeze_bottom_2_waterbirds_sup_resnet50/freeze_bottom_k-2_optimizer.args.lr-0.001_seed-0_run0']\n", + "not all jobs ran: sup_resnet50 freeze_bottom_2_ waterbirds 4\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tWaterbirds\tAvg.\n", + "ResNet-50 (batchnorm)\tSGD\t97.8\t97.8\n", + "ResNet-50 (batchnorm)\tAdamW\t98.0\t98.0\n", + "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t97.2\t97.2\n", + "\n", + "\\begin{tabular}{cc|c}\n", + "\\toprule\n", + " & Waterbirds & Avg.\\\\\n", + "\\midrule\n", + "SGD & \\textbf{97.8} & \\textbf{97.8}\\\\\n", + "AdamW & \\textbf{98.0} & \\textbf{98.0}\\\\\n", + "SGD (Freeze-2) & 97.2 & 97.2\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tWaterbirds\tAvg.\n", + "ResNet-50 (batchnorm)\tSGD\t60.3\t60.3\n", + "ResNet-50 (batchnorm)\tAdamW\t67.9\t67.9\n", + "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t66.2\t66.2\n", + "\n", + "\\begin{tabular}{cc|c}\n", + "\\toprule\n", + " & Waterbirds & Avg.\\\\\n", + "\\midrule\n", + "SGD & 60.3 & 60.3\\\\\n", + "AdamW & \\textbf{67.9} & \\textbf{67.9}\\\\\n", + "SGD (Freeze-2) & 66.2 & 66.2\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['sup_resnet50']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['waterbirds']\n", + "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", + "val_metric_list = ['WATERBIRDS_VAL']\n", + "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['ResNet-50 (batchnorm)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['WATERBIRDS_VAL']]\n", + "ood_output_metrics_list = [['WORST']]\n", + "shortened_dataset_names = ['Waterbirds', \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CLIP weight decay, no momentum, freeze only embed " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "some jobs did not finish: clip_vit_b16 domainnet optimizer.args.weight_decay-0.01_ ['../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.0003_seed-0_run0', '../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.01_seed-0_run0']\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "CLIP ViT-B/16\tFreeze only embed\t98.0 (nan)\t98.0 (nan)\t95.4 (nan)\t70.2 (nan)\t99.5 (nan)\t92.2\n", + "CLIP ViT-B/16\tSGD (no momentum)\t98.0 (nan)\t97.1 (nan)\t89.5 (nan)\t66.4 (nan)\t99.3 (nan)\t90.1\n", + "CLIP ViT-B/16\tSGD (weight decay)\t97.6 (nan)\t97.2 (nan)\t87.9 (nan)\t66.4 (nan)\t99.3 (nan)\t89.7\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & 97.2 (0.1) & 88.8 (7.1) & 67.0 (0.8) & 99.4 (0.0) & 90.0\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", + "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", + "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", + "Freeze only embed & 98.0 & 98.0 & 95.4 & \\textbf{70.2} & \\textbf{99.5} & \\textbf{92.2}\\\\\n", + "SGD (no momentum) & 98.0 & 97.1 & 89.5 & 66.4 & 99.3 & 90.1\\\\\n", + "SGD (weight decay) & 97.6 & 97.2 & 87.9 & 66.4 & 99.3 & 89.7\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "CLIP ViT-B/16\tFreeze only embed\t83.6 (nan)\t74.3 (nan)\t89.1 (nan)\t39.3 (nan)\t92.9 (nan)\t75.9\n", + "CLIP ViT-B/16\tSGD (no momentum)\t81.4 (nan)\t59.2 (nan)\t76.7 (nan)\t37.9 (nan)\t84.3 (nan)\t67.9\n", + "CLIP ViT-B/16\tSGD (weight decay)\t83.9 (nan)\t65.1 (nan)\t67.5 (nan)\t37.1 (nan)\t85.6 (nan)\t67.8\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & 62.5 (5.0) & 72.8 (18.0) & 37.3 (1.1) & 86.8 (1.1) & 67.9\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & 71.9 (2.4) & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", + "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", + "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", + "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", + "Freeze only embed & 83.6 & \\textbf{74.3} & 89.1 & 39.3 & 92.9 & 75.9\\\\\n", + "SGD (no momentum) & 81.4 & 59.2 & 76.7 & 37.9 & 84.3 & 67.9\\\\\n", + "SGD (weight decay) & \\textbf{83.9} & 65.1 & 67.5 & 37.1 & 85.6 & 67.8\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ],\n", + " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", + " 99.5262 , 92.22186 ],\n", + " [98. , 97.071 , 89.5373 , 66.3764 ,\n", + " 99.3236 , 90.06166 ],\n", + " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", + " 99.2938 , 89.6767 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ],\n", + " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", + " 92.941 , 75.85068 ],\n", + " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", + " 84.2829 , 67.88824 ],\n", + " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", + " 85.5645 , 67.8308 ]]]))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index c2f9663..0c0f074 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -1,10 +1,23 @@ { "cells": [ { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 31, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model, imnet_resnet\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", "import timm\n", @@ -15,12 +28,13 @@ "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", "importlib.reload(timm_model)\n", - "importlib.reload(clip_model)" + "importlib.reload(clip_model)\n", + "importlib.reload(imnet_resnet)" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -38,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -67,22 +81,22 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.4242, grad_fn=)\n", - "tensor([[ 0.0140, 0.0559, 0.0699],\n", - " [-0.0701, -0.2804, -0.3505],\n", - " [ 0.0561, 0.2245, 0.2806]])\n" + "tensor(0.4314, grad_fn=)\n", + "tensor([[ 0.1264, 0.1806, 0.1987],\n", + " [-0.5067, -0.7239, -0.7963],\n", + " [ 0.3803, 0.5433, 0.5976]])\n" ] } ], "source": [ - "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)*0.1\n", + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)+0.6\n", "x = torch.tensor(data)\n", "layer_norm = nn.LayerNorm(len(data), elementwise_affine=False)\n", "A = torch.eye(len(data), requires_grad=True)\n", @@ -574,6 +588,222 @@ "print(model._model.head)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Supervised ResNet" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "model = imnet_resnet.ResNet50(pretrained=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('stem',\n", + " ModuleList(\n", + " (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " )),\n", + " ('layer1',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer2',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer3',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer4',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('avgpool', AdaptiveAvgPool2d(output_size=(1, 1))),\n", + " ('head', Linear(in_features=2048, out_features=1000, bias=True))]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_layers()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 9d3f79d..43662c0 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): -def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, +def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index 1261db3..fa7afe5 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --exclude=jagupard[10-25] +#SBATCH --account=nlp # Print execute commands in the log. set -x diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index db134ab..0829412 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -5,6 +5,7 @@ #SBATCH --mem=24G #SBATCH --partition=sphinx #SBATCH --exclude=sphinx[3,5,6,7,8] +#SBATCH --account=nlp # Print execute commands in the log. set -x diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index dc4fa5a..81b8f57 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -64,7 +64,11 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na training_state = net.training net.eval() num_examples = 0 - if 'save_model_preds' in config and config.save_model_preds: + save_model_preds = False + if (check_exists_value(config, 'save_wilds_model_preds', True) or + check_exists_value(config, 'save_model_preds', True)): + save_model_preds = True + if save_model_preds: predicted_list = [] labels_list = [] with torch.no_grad(): @@ -81,7 +85,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na else: _, predicted = torch.max(outputs.data, dim=1) predicted = predicted.detach().cpu().numpy() - if 'save_model_preds' in config and config.save_model_preds: + if save_model_preds: predicted_list.append(predicted) labels_list.append(labels.detach().cpu().numpy()) correct = (predicted == labels.detach().cpu().numpy()) @@ -93,6 +97,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na logging.info("Breaking after %d examples.", num_examples) break if check_exists_value(config, 'save_wilds_model_preds', True): + preds = np.concatenate(predicted_list) pred_strings = [str(p) for p in preds] pred_string = '\n'.join(pred_strings) if config['train_dataset']['classname'] == 'datasets.fmow.Fmow': @@ -112,7 +117,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na dataset=dataset_name, split=split_name, seed=seed, epoch=epoch) logging.info('file_name: ' + file_name) file_path = log_dir + '/model_preds/' + file_name - with open(file_name, "w") as f: + with open(file_path, "w") as f: f.write(pred_string) elif check_exists_value(config, 'save_model_preds', True): preds = np.concatenate(predicted_list) @@ -878,12 +883,8 @@ def setup(): config = json.load(json_file) else: config = quinine.Quinfig(args.config) - logging.info('config before command line') - logging.info(config) # Update config with command line arguments. utils.update_config(unparsed, config) - logging.info('config after command line') - logging.info(config) # This makes specifying certain things more convenient, e.g. don't have to specify a # transform for every test datset. preprocess_config(config, args.config) diff --git a/unlabeled_extrapolation/models/imnet_resnet.py b/unlabeled_extrapolation/models/imnet_resnet.py index c2cc3f6..22986e7 100644 --- a/unlabeled_extrapolation/models/imnet_resnet.py +++ b/unlabeled_extrapolation/models/imnet_resnet.py @@ -6,6 +6,9 @@ from torch import nn from . import model_utils from torchvision.transforms import Normalize + +import unlabeled_extrapolation.utils.utils as utils + try: from models import swav_resnet50 except: @@ -96,6 +99,24 @@ def enable_side_tuning(self): # In many of their experiments, this is also a ResNet-50 like the original network. self._side_network = ResNet50() + def get_layers(self): + stem = nn.ModuleList([self._model.conv1, self._model.bn1, self._model.relu, self._model.maxpool]) + layers = ([('stem', stem)] + + [('layer1', self._model.layer1)] + + [('layer2', self._model.layer2)] + + [('layer3', self._model.layer3)] + + [('layer4', self._model.layer4)] + + [('avgpool', self._model.avgpool)] + + [('head', self._model.fc)]) + return layers + + def freeze_bottom_k(self, k): + layers = [l for _, l in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + for i in range(k): + utils.set_requires_grad(layers[i], False) + def new_last_layer(self, num_classes): num_in_features = self._model.fc.in_features self._model.fc = nn.Linear(num_in_features, num_classes) From 0315a9b33c626db61a4422131abbeb6dba2b0537 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sat, 5 Nov 2022 22:54:32 -0700 Subject: [PATCH 162/197] address reviewer comments --- configs/adaptation/resnet50_transfer.yaml | 1 + configs/adaptation/waterbirds.yaml | 3 +- ...nalyze_dataset_stats_model_gradients.ipynb | 12 +- ...eeze-embed-paper-fine-tuning-results.ipynb | 993 ++++++++++++++++-- ...oad_models_test_get_layers_gradients.ipynb | 252 ++++- scripts/run_adaptation_experiments.py | 2 +- scripts/run_rtx_sbatch.sh | 1 + scripts/run_sphinx_sbatch.sh | 1 + unlabeled_extrapolation/baseline_train.py | 15 +- .../models/imnet_resnet.py | 21 + 10 files changed, 1192 insertions(+), 109 deletions(-) diff --git a/configs/adaptation/resnet50_transfer.yaml b/configs/adaptation/resnet50_transfer.yaml index e6030e0..05ed519 100644 --- a/configs/adaptation/resnet50_transfer.yaml +++ b/configs/adaptation/resnet50_transfer.yaml @@ -15,6 +15,7 @@ optimizer: args: lr: 0.03 momentum: 0.9 + weight_decay: 0.0 criterion: classname: torch.nn.CrossEntropyLoss diff --git a/configs/adaptation/waterbirds.yaml b/configs/adaptation/waterbirds.yaml index f508c49..8798441 100644 --- a/configs/adaptation/waterbirds.yaml +++ b/configs/adaptation/waterbirds.yaml @@ -11,8 +11,7 @@ save_no_checkpoints: True model: classname: models.clip_model.ClipModel - args: - model_name: 'ViT-B/16' + args: {} scheduler: classname: torch.optim.lr_scheduler.CosineAnnealingLR diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index c41625a..a0f485e 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -113,7 +113,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -132,7 +132,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -151,7 +151,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -230,8 +230,8 @@ "# print(df[compute_keys(df)])\n", " return dataset_stats\n", "\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" ] }, diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index c317685..b41bcb4 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -235,84 +235,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "some jobs did not finish: timm_vit_b16_in21k domainnet freeze_bottom_2_opt_torch.optim.AdamW_ ['../logs//full_ft_freeze_bottom_2_opt_torch.optim.AdamW_domainnet_timm_vit_b16_in21k/freeze_bottom_k-2_optimizer.args.lr-3e-06_seed-0_run0']\n", - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.7\t81.0\t97.0\t64.6\t87.4\t69.5\n", - "CLIP ViT-B/16\tAdamW\t97.9\t83.5\t97.7\t71.1\t94.9\t89.3\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.0\t81.9\t97.8\t74.3\t94.6\t87.9\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.1\t82.6\t97.8\t69.2\t94.8\t89.8\n", - "Sup ViT-B/16\tSGD\t98.5\t89.4\t99.0\t78.7\t91.5\t86.7\n", - "Sup ViT-B/16\tAdamW\t98.6\t87.9\t98.9\t80.1\t91.5\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.6\t89.5\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.5\t88.4\t99.0\t82.4\t90.8\t82.6\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t55.6\t88.0\t76.2\n", - "DINO ViT-B/16\tAdamW\t98.4\t87.5\t97.9\t61.2\t89.1\t77.5\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.3\t87.6\t97.5\t68.5\t88.9\t78.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.3\t86.7\t97.6\t61.5\t89.6\t76.4\n", - "BIT ResNet-50\tSGD\t97.3\t85.7\t98.4\t75.2\t89.0\t80.9\n", - "BIT ResNet-50\tAdamW\t97.1\t83.2\t98.3\t76.9\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.5\t84.4\t98.5\t75.5\t89.0\t82.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t83.6\t98.4\t78.5\t89.0\t83.5\n", - "BIT ResNet-101\tSGD\t98.2\t82.2\t98.9\t79.0\t91.8\t86.0\n", - "BIT ResNet-101\tAdamW\t98.2\t84.5\t98.6\t79.4\t91.0\t83.7\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.2\t84.9\t98.8\t78.7\t91.4\t85.9\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.1\t84.1\t98.7\t72.0\t90.6\t83.9\n", - "ConvNext-Base\tSGD\t98.5\t92.1\t99.0\t81.3\t94.6\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.1\t99.4\t85.8\t94.0\t89.9\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.5\t91.5\t99.3\t88.0\t94.8\t91.5\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.6\t89.8\t99.3\t87.7\t94.5\t91.0\n", - "CLIP ViT-L/14\tSGD\t98.3\t84.9\t96.3\t56.7\t84.1\t60.9\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.4\t98.7\t86.0\t96.6\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.6\t89.4\t98.7\t84.9\t96.8\t93.9\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.6\t88.2\t98.6\t87.5\t96.6\t93.7\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 ID & Living-17 OOD & Waterbirds ID & Waterbirds OOD & DomainNet ID & DomainNet OOD\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.7 & 81.0 & 97.0 & 64.6 & 87.4 & 69.5\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{97.9} & \\textbf{83.5} & \\textbf{97.7} & 71.1 & \\textbf{94.9} & 89.3\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.0} & 81.9 & \\textbf{97.8} & \\textbf{74.3} & 94.6 & 87.9\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.1} & 82.6 & \\textbf{97.8} & 69.2 & \\textbf{94.8} & \\textbf{89.8}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.5} & \\textbf{89.4} & \\textbf{99.0} & 78.7 & \\textbf{91.5} & \\textbf{86.7}\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.6} & 87.9 & 98.9 & 80.1 & \\textbf{91.5} & 84.4\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{89.5} & \\textbf{99.2} & \\textbf{82.4} & \\textbf{91.5} & 86.3\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.5} & 88.4 & 99.0 & \\textbf{82.4} & 90.8 & 82.6\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & \\textbf{88.2} & 97.0 & 55.6 & 88.0 & 76.2\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.4} & 87.5 & \\textbf{97.9} & 61.2 & 89.1 & 77.5\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.3} & 87.6 & 97.5 & \\textbf{68.5} & 88.9 & \\textbf{78.9}\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & 86.7 & 97.6 & 61.5 & \\textbf{89.6} & 76.4\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{97.3} & \\textbf{85.7} & \\textbf{98.4} & 75.2 & \\textbf{89.0} & 80.9\\\\\n", - "BIT ResNet-50 & AdamW & 97.1 & 83.2 & \\textbf{98.3} & 76.9 & \\textbf{89.2} & \\textbf{84.0}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.5} & 84.4 & \\textbf{98.5} & 75.5 & \\textbf{89.0} & 82.4\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & 83.6 & \\textbf{98.4} & \\textbf{78.5} & \\textbf{89.0} & 83.5\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.2} & 82.2 & \\textbf{98.9} & 79.0 & \\textbf{91.8} & \\textbf{86.0}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.2} & 84.5 & 98.6 & \\textbf{79.4} & 91.0 & 83.7\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{84.9} & \\textbf{98.8} & 78.7 & 91.4 & \\textbf{85.9}\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.1} & 84.1 & 98.7 & 72.0 & 90.6 & 83.9\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.5} & \\textbf{92.1} & 99.0 & 81.3 & 94.6 & 89.8\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & 90.1 & \\textbf{99.4} & 85.8 & 94.0 & 89.9\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.5} & 91.5 & \\textbf{99.3} & \\textbf{88.0} & \\textbf{94.8} & \\textbf{91.5}\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.6} & 89.8 & \\textbf{99.3} & 87.7 & 94.5 & 91.0\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.3 & 84.9 & 96.3 & 56.7 & 84.1 & 60.9\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & 88.4 & \\textbf{98.7} & 86.0 & 96.6 & \\textbf{93.8}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & 98.6 & \\textbf{89.4} & \\textbf{98.7} & 84.9 & \\textbf{96.8} & \\textbf{93.9}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & 98.6 & 88.2 & \\textbf{98.6} & \\textbf{87.5} & \\textbf{96.6} & \\textbf{93.7}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'test_acc/source_val_living'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'test_acc/sketch_val'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sup ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DINO ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-50'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-101'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ConvNext-Base'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'CLIP ViT-L/14'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;31m# supposed to have run each dataset for. Used to validate if the runs finished.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mmean_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmodel_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" ] } ], @@ -394,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -575,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -606,10 +541,10 @@ " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", "\\midrule\n", "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & 92.1\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & 92.1\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & 98.2 & 97.8 & 95.1 & 67.9 & 99.5 & 91.7\\\\\n", + "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", "\\bottomrule\n", "\\end{tabular}\n", @@ -629,7 +564,7 @@ " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", "\\midrule\n", "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & 76.0\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", @@ -637,6 +572,39 @@ "\\bottomrule\n", "\\end{tabular}\n" ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 87.57816667, 66.9715 ,\n", + " 99.3802 , 89.79514667],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 69.58566667, 37.34413333,\n", + " 86.79546667, 67.22942 ],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -661,6 +629,440 @@ "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIP Results for ViT-L" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4118 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 98.2941 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 97.7647 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 95.7059 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 82.8824 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 98.4118 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 84.2353 \n", + "1 83.9412 \n", + "2 81.5294 \n", + "3 68.6471 \n", + "4 42.2353 \n", + "5 89.9412 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3qbk... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/279j... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/j354... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/8695... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/10f5... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2ot2... optimizer.args.lr-3e-05 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.6786 36.7601 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 93.1918 16.3551 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 92.3360 14.4860 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 90.9443 10.4361 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 88.6586 4.5171 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.2767 64.9533 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3lyi... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2sig... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/6l40... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2tso... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3i5g... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/o0ed... optimizer.args.lr-3e-05 \n", + " name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 84.3268 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 79.4081 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 77.3239 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 71.0713 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 14.3393 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 63.0263 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 60.7950 https://wandb.ai/p-lambda/finetuning/runs/24w9... \n", + "1 55.3939 https://wandb.ai/p-lambda/finetuning/runs/1rxe... \n", + "2 47.7315 https://wandb.ai/p-lambda/finetuning/runs/16kz... \n", + "3 32.5940 https://wandb.ai/p-lambda/finetuning/runs/3mr8... \n", + "4 6.9134 https://wandb.ai/p-lambda/finetuning/runs/22r2... \n", + "5 28.7772 https://wandb.ai/p-lambda/finetuning/runs/3ci4... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-0.003 \n", + "4 optimizer.args.lr-0.01 \n", + "5 optimizer.args.lr-3e-05 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 69.0151 67.4215 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 66.9947 65.1218 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 67.1166 64.8506 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 63.6332 60.6076 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 31.0198 26.9646 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 62.7536 62.9274 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 61.3353 40.9950 \n", + "1 57.9473 37.3698 \n", + "2 57.7483 37.0999 \n", + "3 53.9307 33.5904 \n", + "4 22.5032 15.8889 \n", + "5 56.6447 37.6012 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/f1au... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/284k... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/w0s6... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/4aij... optimizer.args.lr-0.003 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1zj3... optimizer.args.lr-0.01 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/13fr... optimizer.args.lr-3e-05 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.3474 89.3995 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 99.4219 88.1160 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 99.4487 87.5774 \n", + "3 optimizer.args.lr-0.003_seed-0_run0 98.1585 70.8973 \n", + "4 optimizer.args.lr-0.01_seed-0_run0 97.6579 73.7709 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 99.3206 90.6314 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 92.1544 https://wandb.ai/p-lambda/finetuning/runs/csa6... \n", + "1 84.8908 https://wandb.ai/p-lambda/finetuning/runs/3fwt... \n", + "2 83.2060 https://wandb.ai/p-lambda/finetuning/runs/x1pv... \n", + "3 48.1706 https://wandb.ai/p-lambda/finetuning/runs/fuzi... \n", + "4 55.1614 https://wandb.ai/p-lambda/finetuning/runs/21rv... \n", + "5 95.0526 https://wandb.ai/p-lambda/finetuning/runs/2mb7... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-0.003 \n", + "4 optimizer.args.lr-0.01 \n", + "5 optimizer.args.lr-3e-05 \n", + " name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.4706 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 98.7059 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.4706 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.8824 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 98.2353 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 67.7059 \n", + "1 85.7647 \n", + "2 90.2941 \n", + "3 80.7647 \n", + "4 88.0000 \n", + "5 91.5294 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/8bu0... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2mhb... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1s2a... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/3ci0... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2ypn... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2sn5... optimizer.args.lr-3e-07 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.0114 5.6075 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 98.8165 85.2025 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.3287 85.5140 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 97.9859 65.2648 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.6567 86.2928 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 98.0875 82.0872 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2nee... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/nwln... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3ses... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2ua0... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2cp9... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/yo7d... optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 58.3576 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 96.3318 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 96.3318 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 96.8737 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 95.6232 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 21.4317 https://wandb.ai/p-lambda/finetuning/runs/3jmk... \n", + "1 92.2944 https://wandb.ai/p-lambda/finetuning/runs/1l1o... \n", + "2 92.5825 https://wandb.ai/p-lambda/finetuning/runs/1dab... \n", + "3 85.6834 https://wandb.ai/p-lambda/finetuning/runs/2xnh... \n", + "4 93.7635 https://wandb.ai/p-lambda/finetuning/runs/189b... \n", + "5 90.7677 https://wandb.ai/p-lambda/finetuning/runs/1lui... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 41.2697 38.3279 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 74.4579 72.4429 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 70.3736 68.1647 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 73.1342 70.3339 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 73.5522 70.7959 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 62.6840 61.9483 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 32.2508 21.0567 \n", + "1 67.0979 48.2838 \n", + "2 62.7239 44.0802 \n", + "3 63.6240 43.5789 \n", + "4 64.5649 45.4686 \n", + "5 56.0657 38.4497 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ir1... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2015... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2psl... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/t2pv... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/xprd... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1qdx... optimizer.args.lr-3e-07 \n", + " name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4029 78.5698 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.5411 91.5712 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 99.6216 95.0464 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.2372 84.9587 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 99.6275 94.8229 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 99.4547 93.5366 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 65.6771 https://wandb.ai/p-lambda/finetuning/runs/10mp... \n", + "1 90.2380 https://wandb.ai/p-lambda/finetuning/runs/zur7... \n", + "2 96.4517 https://wandb.ai/p-lambda/finetuning/runs/182q... \n", + "3 84.6251 https://wandb.ai/p-lambda/finetuning/runs/3ct8... \n", + "4 95.9155 https://wandb.ai/p-lambda/finetuning/runs/2uej... \n", + "5 95.9285 https://wandb.ai/p-lambda/finetuning/runs/awtw... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + " name \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 98.7059 90.4706 \n", + "1 98.6471 88.4706 \n", + "2 98.7059 86.1176 \n", + "3 98.0000 81.8824 \n", + "4 96.7059 70.3529 \n", + "5 98.5294 91.7647 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/db01... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2jb3... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/21ja... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1vxt... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2yr9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/32hw... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name WATERBIRDS_VAL WORST \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 98.2503 86.1371 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 98.4706 87.0717 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 98.8519 84.7352 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.3602 76.0125 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.4060 18.6916 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 98.1511 84.7352 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/14mo... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/tsai... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2le0... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/10t5... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2c6t... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2gdu... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name test_acc/sketch_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.0821 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 96.9571 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 96.5402 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.3718 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 83.2847 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 96.1234 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 93.1010 https://wandb.ai/p-lambda/finetuning/runs/2bbx... \n", + "1 94.0804 https://wandb.ai/p-lambda/finetuning/runs/31x1... \n", + "2 92.1504 https://wandb.ai/p-lambda/finetuning/runs/7q05... \n", + "3 79.5189 https://wandb.ai/p-lambda/finetuning/runs/l2xq... \n", + "4 50.2665 https://wandb.ai/p-lambda/finetuning/runs/khjr... \n", + "5 91.7183 https://wandb.ai/p-lambda/finetuning/runs/1z28... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + " name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 73.2300 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 74.4927 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 74.1357 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 72.4027 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 63.2761 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 69.6508 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 71.6395 65.5283 47.7825 \n", + "1 72.2420 66.3063 49.9422 \n", + "2 72.2922 65.6324 45.1600 \n", + "3 69.8519 62.5656 41.1492 \n", + "4 60.2661 53.4467 33.5904 \n", + "5 68.0593 62.7510 44.3887 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3ocq... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3vnf... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3naz... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/pn49... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/uoyu... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/jh49... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5650 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.6156 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.5888 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.5769 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 98.4237 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4070 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.8888 96.4599 \n", + "1 95.3472 96.5363 \n", + "2 94.8745 96.3153 \n", + "3 93.8832 94.0156 \n", + "4 75.9025 74.1623 \n", + "5 93.6512 95.9861 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ads... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3mpi... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/13dm... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/wdak... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/v23o... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3fqz... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-B/16\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 1 is out of bounds for axis 0 with size 1", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Liv-17'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"FMoW\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Camelyon\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Avg.\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m id_mean_table, ood_mean_table = display_id_ood_tables(\n\u001b[0m\u001b[1;32m 18\u001b[0m id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_id_ood_tables\u001b[0;34m(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std)\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mno_std\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0mid_std_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 168\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 169\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mdisplay_latex_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_last_avg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m if (std_err_table is not None and\n", + "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 0 with size 1" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 48, @@ -705,6 +1107,433 @@ "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Post ICLR Supplementary results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Big table, including AdamW + Freeze " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", + "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", + "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 88.8 & 67.0 & \\textbf{99.4} & 90.0\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & 95.0 & 70.1 & \\textbf{99.5} & \\textbf{92.1}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & 94.9 & 70.0 & \\textbf{99.5} & 92.1\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & \\textbf{97.8} & \\textbf{95.3} & \\textbf{70.5} & \\textbf{99.6} & \\textbf{92.3}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & 66.4 & \\textbf{99.5} & \\textbf{91.1}\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.6} & \\textbf{99.0} & 90.9 & \\textbf{66.8} & \\textbf{99.5} & \\textbf{91.0}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & 89.4 & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.4} & \\textbf{97.8} & \\textbf{89.7} & 65.7 & \\textbf{99.6} & \\textbf{90.3}\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", + "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & \\textbf{98.4} & \\textbf{89.1} & 64.9 & \\textbf{99.6} & \\textbf{89.9}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.2} & 98.7 & 91.1 & 66.6 & \\textbf{99.6} & \\textbf{90.9}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & 68.8 & \\textbf{99.7} & \\textbf{92.2}\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & 92.0\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{99.5} & 94.7 & \\textbf{69.2} & \\textbf{99.6} & \\textbf{92.4}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{98.8} & 96.7 & \\textbf{75.1} & \\textbf{99.6} & \\textbf{93.8}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (Freeze-2)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tAdamW (Freeze-2)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tAdamW (Freeze-2)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", + "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BIT ResNet-50\tAdamW (Freeze-2)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", + "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BIT ResNet-101\tAdamW (Freeze-2)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "ConvNext-Base\tAdamW (Freeze-2)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tAdamW (Freeze-2)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 72.8 & 37.3 & 86.8 & 67.9\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & 95.7 & \\textbf{76.0}\\\\\n", + "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", + "CLIP ViT-B/16 & AdamW (Freeze-2) & 82.4 & 69.5 & 88.2 & \\textbf{40.7} & \\textbf{96.7} & 75.5\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", + "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", + "Sup ViT-B/16 & AdamW (Freeze-2) & 88.1 & \\textbf{82.4} & 82.3 & 35.7 & 93.0 & 76.3\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & 91.9 & 70.7\\\\\n", + "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", + "DINO ViT-B/16 & AdamW (Freeze-2) & 86.8 & 64.5 & 76.6 & 35.4 & \\textbf{93.5} & 71.4\\\\\n", + "\\midrule\n", + "BIT ResNet-50 & SGD & \\textbf{84.3} & 76.5 & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", + "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", + "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & 35.0 & \\textbf{95.2} & 74.4\\\\\n", + "BIT ResNet-50 & AdamW (Freeze-2) & 82.9 & \\textbf{77.3} & 83.3 & \\textbf{36.3} & 93.7 & \\textbf{74.7}\\\\\n", + "\\midrule\n", + "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", + "BIT ResNet-101 & AdamW & 82.9 & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", + "BIT ResNet-101 & SGD (Freeze-2) & 83.1 & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & 75.6\\\\\n", + "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{84.8} & 78.3 & 84.3 & \\textbf{38.2} & 95.0 & \\textbf{76.1}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & 39.7 & 83.0 & 77.3\\\\\n", + "ConvNext-Base & AdamW & 90.3 & 89.8 & 89.5 & 38.4 & \\textbf{89.5} & 79.5\\\\\n", + "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & 79.4\\\\\n", + "ConvNext-Base & AdamW (Freeze-2) & 88.1 & \\textbf{91.6} & 89.8 & \\textbf{41.6} & 87.7 & \\textbf{79.8}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", + "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", + "CLIP ViT-L/14 & AdamW (Freeze-2) & 88.0 & 84.6 & \\textbf{93.8} & 44.6 & \\textbf{96.4} & 81.5\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ResNet-50 waterbirds results " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "some jobs did not finish: sup_resnet50 waterbirds opt_torch.optim.AdamW_ ['../logs//full_ft_opt_torch.optim.AdamW_waterbirds_sup_resnet50/optimizer.args.lr-0.0001_seed-0_run0']\n", + "not all jobs ran: sup_resnet50 opt_torch.optim.AdamW_ waterbirds 4\n", + "some jobs did not finish: sup_resnet50 waterbirds freeze_bottom_2_ ['../logs//full_ft_freeze_bottom_2_waterbirds_sup_resnet50/freeze_bottom_k-2_optimizer.args.lr-0.001_seed-0_run0']\n", + "not all jobs ran: sup_resnet50 freeze_bottom_2_ waterbirds 4\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tWaterbirds\tAvg.\n", + "ResNet-50 (batchnorm)\tSGD\t97.8\t97.8\n", + "ResNet-50 (batchnorm)\tAdamW\t98.0\t98.0\n", + "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t97.2\t97.2\n", + "\n", + "\\begin{tabular}{cc|c}\n", + "\\toprule\n", + " & Waterbirds & Avg.\\\\\n", + "\\midrule\n", + "SGD & \\textbf{97.8} & \\textbf{97.8}\\\\\n", + "AdamW & \\textbf{98.0} & \\textbf{98.0}\\\\\n", + "SGD (Freeze-2) & 97.2 & 97.2\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tWaterbirds\tAvg.\n", + "ResNet-50 (batchnorm)\tSGD\t60.3\t60.3\n", + "ResNet-50 (batchnorm)\tAdamW\t67.9\t67.9\n", + "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t66.2\t66.2\n", + "\n", + "\\begin{tabular}{cc|c}\n", + "\\toprule\n", + " & Waterbirds & Avg.\\\\\n", + "\\midrule\n", + "SGD & 60.3 & 60.3\\\\\n", + "AdamW & \\textbf{67.9} & \\textbf{67.9}\\\\\n", + "SGD (Freeze-2) & 66.2 & 66.2\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['sup_resnet50']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", + "datasets = ['waterbirds']\n", + "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", + "val_metric_list = ['WATERBIRDS_VAL']\n", + "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['ResNet-50 (batchnorm)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "\n", + "id_output_metrics_list = [['WATERBIRDS_VAL']]\n", + "ood_output_metrics_list = [['WORST']]\n", + "shortened_dataset_names = ['Waterbirds', \"Avg.\"]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CLIP weight decay, no momentum, freeze only embed " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "some jobs did not finish: clip_vit_b16 domainnet optimizer.args.weight_decay-0.01_ ['../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.0003_seed-0_run0', '../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.01_seed-0_run0']\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "CLIP ViT-B/16\tFreeze only embed\t98.0 (nan)\t98.0 (nan)\t95.4 (nan)\t70.2 (nan)\t99.5 (nan)\t92.2\n", + "CLIP ViT-B/16\tSGD (no momentum)\t98.0 (nan)\t97.1 (nan)\t89.5 (nan)\t66.4 (nan)\t99.3 (nan)\t90.1\n", + "CLIP ViT-B/16\tSGD (weight decay)\t97.6 (nan)\t97.2 (nan)\t87.9 (nan)\t66.4 (nan)\t99.3 (nan)\t89.7\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & 97.2 (0.1) & 88.8 (7.1) & 67.0 (0.8) & 99.4 (0.0) & 90.0\\\\\n", + "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", + "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", + "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", + "Freeze only embed & 98.0 & 98.0 & 95.4 & \\textbf{70.2} & \\textbf{99.5} & \\textbf{92.2}\\\\\n", + "SGD (no momentum) & 98.0 & 97.1 & 89.5 & 66.4 & 99.3 & 90.1\\\\\n", + "SGD (weight decay) & 97.6 & 97.2 & 87.9 & 66.4 & 99.3 & 89.7\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "CLIP ViT-B/16\tFreeze only embed\t83.6 (nan)\t74.3 (nan)\t89.1 (nan)\t39.3 (nan)\t92.9 (nan)\t75.9\n", + "CLIP ViT-B/16\tSGD (no momentum)\t81.4 (nan)\t59.2 (nan)\t76.7 (nan)\t37.9 (nan)\t84.3 (nan)\t67.9\n", + "CLIP ViT-B/16\tSGD (weight decay)\t83.9 (nan)\t65.1 (nan)\t67.5 (nan)\t37.1 (nan)\t85.6 (nan)\t67.8\n", + "\n", + "\\begin{tabular}{cccccc|c}\n", + "\\toprule\n", + " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & 62.5 (5.0) & 72.8 (18.0) & 37.3 (1.1) & 86.8 (1.1) & 67.9\\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & 71.9 (2.4) & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", + "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", + "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", + "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", + "Freeze only embed & 83.6 & \\textbf{74.3} & 89.1 & 39.3 & 92.9 & 75.9\\\\\n", + "SGD (no momentum) & 81.4 & 59.2 & 76.7 & 37.9 & 84.3 & 67.9\\\\\n", + "SGD (weight decay) & \\textbf{83.9} & 65.1 & 67.5 & 37.1 & 85.6 & 67.8\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ],\n", + " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", + " 99.5262 , 92.22186 ],\n", + " [98. , 97.071 , 89.5373 , 66.3764 ,\n", + " 99.3236 , 90.06166 ],\n", + " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", + " 99.2938 , 89.6767 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ],\n", + " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", + " 92.941 , 75.85068 ],\n", + " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", + " 84.2829 , 67.88824 ],\n", + " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", + " 85.5645 , 67.8308 ]]]))" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "print(\"CLIP Results, all datasets\")\n", + "models = ['clip_vit_b16']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", + "\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index c2f9663..0c0f074 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -1,10 +1,23 @@ { "cells": [ { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 31, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model\n", + "from unlabeled_extrapolation.models import bit_resnet, vit_model, timm_model, clip_model, imnet_resnet\n", "from unlabeled_extrapolation.utils import utils\n", "import importlib\n", "import timm\n", @@ -15,12 +28,13 @@ "importlib.reload(vit_model)\n", "importlib.reload(utils)\n", "importlib.reload(timm_model)\n", - "importlib.reload(clip_model)" + "importlib.reload(clip_model)\n", + "importlib.reload(imnet_resnet)" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -38,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -67,22 +81,22 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.4242, grad_fn=)\n", - "tensor([[ 0.0140, 0.0559, 0.0699],\n", - " [-0.0701, -0.2804, -0.3505],\n", - " [ 0.0561, 0.2245, 0.2806]])\n" + "tensor(0.4314, grad_fn=)\n", + "tensor([[ 0.1264, 0.1806, 0.1987],\n", + " [-0.5067, -0.7239, -0.7963],\n", + " [ 0.3803, 0.5433, 0.5976]])\n" ] } ], "source": [ - "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)*0.1\n", + "data = np.array([0.1, 0.4, 0.5], dtype=np.float32)+0.6\n", "x = torch.tensor(data)\n", "layer_norm = nn.LayerNorm(len(data), elementwise_affine=False)\n", "A = torch.eye(len(data), requires_grad=True)\n", @@ -574,6 +588,222 @@ "print(model._model.head)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Supervised ResNet" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "model = imnet_resnet.ResNet50(pretrained=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('stem',\n", + " ModuleList(\n", + " (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " )),\n", + " ('layer1',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer2',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer3',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('layer4',\n", + " Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )),\n", + " ('avgpool', AdaptiveAvgPool2d(output_size=(1, 1))),\n", + " ('head', Linear(in_features=2048, out_features=1000, bias=True))]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_layers()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 9d3f79d..43662c0 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1391,7 +1391,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): -def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, +def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index 1261db3..fa7afe5 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --exclude=jagupard[10-25] +#SBATCH --account=nlp # Print execute commands in the log. set -x diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index db134ab..0829412 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -5,6 +5,7 @@ #SBATCH --mem=24G #SBATCH --partition=sphinx #SBATCH --exclude=sphinx[3,5,6,7,8] +#SBATCH --account=nlp # Print execute commands in the log. set -x diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index dc4fa5a..81b8f57 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -64,7 +64,11 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na training_state = net.training net.eval() num_examples = 0 - if 'save_model_preds' in config and config.save_model_preds: + save_model_preds = False + if (check_exists_value(config, 'save_wilds_model_preds', True) or + check_exists_value(config, 'save_model_preds', True)): + save_model_preds = True + if save_model_preds: predicted_list = [] labels_list = [] with torch.no_grad(): @@ -81,7 +85,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na else: _, predicted = torch.max(outputs.data, dim=1) predicted = predicted.detach().cpu().numpy() - if 'save_model_preds' in config and config.save_model_preds: + if save_model_preds: predicted_list.append(predicted) labels_list.append(labels.detach().cpu().numpy()) correct = (predicted == labels.detach().cpu().numpy()) @@ -93,6 +97,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na logging.info("Breaking after %d examples.", num_examples) break if check_exists_value(config, 'save_wilds_model_preds', True): + preds = np.concatenate(predicted_list) pred_strings = [str(p) for p in preds] pred_string = '\n'.join(pred_strings) if config['train_dataset']['classname'] == 'datasets.fmow.Fmow': @@ -112,7 +117,7 @@ def get_test_stats(config, net, test_loader, criterion, device, epoch, loader_na dataset=dataset_name, split=split_name, seed=seed, epoch=epoch) logging.info('file_name: ' + file_name) file_path = log_dir + '/model_preds/' + file_name - with open(file_name, "w") as f: + with open(file_path, "w") as f: f.write(pred_string) elif check_exists_value(config, 'save_model_preds', True): preds = np.concatenate(predicted_list) @@ -878,12 +883,8 @@ def setup(): config = json.load(json_file) else: config = quinine.Quinfig(args.config) - logging.info('config before command line') - logging.info(config) # Update config with command line arguments. utils.update_config(unparsed, config) - logging.info('config after command line') - logging.info(config) # This makes specifying certain things more convenient, e.g. don't have to specify a # transform for every test datset. preprocess_config(config, args.config) diff --git a/unlabeled_extrapolation/models/imnet_resnet.py b/unlabeled_extrapolation/models/imnet_resnet.py index c2cc3f6..22986e7 100644 --- a/unlabeled_extrapolation/models/imnet_resnet.py +++ b/unlabeled_extrapolation/models/imnet_resnet.py @@ -6,6 +6,9 @@ from torch import nn from . import model_utils from torchvision.transforms import Normalize + +import unlabeled_extrapolation.utils.utils as utils + try: from models import swav_resnet50 except: @@ -96,6 +99,24 @@ def enable_side_tuning(self): # In many of their experiments, this is also a ResNet-50 like the original network. self._side_network = ResNet50() + def get_layers(self): + stem = nn.ModuleList([self._model.conv1, self._model.bn1, self._model.relu, self._model.maxpool]) + layers = ([('stem', stem)] + + [('layer1', self._model.layer1)] + + [('layer2', self._model.layer2)] + + [('layer3', self._model.layer3)] + + [('layer4', self._model.layer4)] + + [('avgpool', self._model.avgpool)] + + [('head', self._model.fc)]) + return layers + + def freeze_bottom_k(self, k): + layers = [l for _, l in self.get_layers()] + if k > len(layers): + raise ValueError(f"k {k} should be less than number of layers {len(layers)}") + for i in range(k): + utils.set_requires_grad(layers[i], False) + def new_last_layer(self, num_classes): num_in_features = self._model.fc.in_features self._model.fc = nn.Linear(num_in_features, num_classes) From c55423e12e7e94d2f5e2d77fe9d5737b8813de56 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 8 Nov 2022 18:28:37 -0800 Subject: [PATCH 163/197] Updates --- .gitignore | 1 + configs/adaptation/cifar_stl_nonorm.yaml | 2 + configs/adaptation/living17.yaml | 2 + ...eeze-embed-paper-fine-tuning-results.ipynb | 1194 +---------------- ...oad_models_test_get_layers_gradients.ipynb | 15 +- scripts/run_adaptation_experiments.py | 26 +- unlabeled_extrapolation/baseline_train.py | 19 + 7 files changed, 118 insertions(+), 1141 deletions(-) diff --git a/.gitignore b/.gitignore index 72f1f93..000eee2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ **amlt_configs/** .amltconfig **amlt_scripts** +**.pkl **tmp.tsv** **slurm_outputs** diff --git a/configs/adaptation/cifar_stl_nonorm.yaml b/configs/adaptation/cifar_stl_nonorm.yaml index f4daf3f..e2ec2ef 100644 --- a/configs/adaptation/cifar_stl_nonorm.yaml +++ b/configs/adaptation/cifar_stl_nonorm.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 10 epochs: &epochs 20 save_no_checkpoints: True +batch_size: 32 +batch_splits: 2 model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/living17.yaml b/configs/adaptation/living17.yaml index a24583f..19263a3 100644 --- a/configs/adaptation/living17.yaml +++ b/configs/adaptation/living17.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 17 epochs: &epochs 20 +save_no_checkpoints: True + model: classname: models.imnet_resnet.ResNet50 args: {} diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index b41bcb4..7d11f1c 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,45 +2,27 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", "import importlib\n", "import math\n", + "import pickle\n", "importlib.reload(summarize_all_results)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "log_dir = '../logs/'\n", "name_template = 'full_ft_{option}{dataset}_{model}'\n", "\n", - "# TODOs:\n", - "# Get mean and std (done)\n", - "# Filter out for ID and OOD columns (done)\n", - "# Add an overall average column\n", - "\n", - "# Print some nice Latex tables (done)\n", - "# Bold the best numbers within confidence intervals, in the latex table\n", - "\n", "def get_bolds(table, std_err_table=None, eps=0.2):\n", " is_best = np.zeros((len(table), len(table[0])), dtype=np.int32)\n", " for col in range(len(table[0])):\n", @@ -188,7 +170,7 @@ " print('\\\\end{tabular}')\n", " \n", " \n", - "def display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", + "def display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", " # Filter the ID and OOD metrics.\n", " print('\\n\\nID Accuracies')\n", " id_mean_table = filter_columns(mean_table, output_metrics_list, id_output_metrics_list)\n", @@ -213,113 +195,6 @@ " " ] }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 2, 3])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.concatenate([[0], np.array([1,2,3])])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'np' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'test_acc/source_val_living'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'test_acc/sketch_val'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sup ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DINO ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-50'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-101'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ConvNext-Base'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'CLIP ViT-L/14'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;31m# supposed to have run each dataset for. Used to validate if the runs finished.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mmean_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmodel_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" - ] - } - ], - "source": [ - "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (LAST)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['LAST', 'LAST', 'LAST']\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "desired_epochs_list = [20, 20, 50]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)\n", - "display_latex_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t80.0\t97.2\t62.5\t87.6\t69.6\n", - "CLIP ViT-B/16\tAdamW\t98.1\t82.8\t97.7\t71.9\t95.0\t89.2\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t83.2\t97.8\t73.7\t94.9\t88.2\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", - "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", - "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", - "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", - "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", - "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", - "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", - "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", - "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" - ] - } - ], - "source": [ - "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (Early stopped)\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -329,135 +204,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t87.6\t67.0\t99.4\t89.8\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 87.6 & 67.0 & \\textbf{99.4} & 89.8\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & \\textbf{95.0} & \\textbf{70.1} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & \\textbf{94.9} & \\textbf{70.0} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & \\textbf{66.4} & \\textbf{99.5} & \\textbf{91.1}\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & \\textbf{89.4} & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", - "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & \\textbf{68.8} & \\textbf{99.7} & \\textbf{92.2}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & \\textbf{92.0}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t69.6\t37.3\t86.8\t67.2\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 69.6 & 37.3 & 86.8 & 67.2\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & \\textbf{95.7} & \\textbf{76.0}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & \\textbf{91.9} & 70.7\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{84.3} & \\textbf{76.5} & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", - "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & \\textbf{35.0} & \\textbf{95.2} & \\textbf{74.4}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{82.9} & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{83.1} & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & \\textbf{75.6}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & \\textbf{39.7} & 83.0 & 77.3\\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\textbf{89.8} & 89.5 & 38.4 & \\textbf{89.5} & \\textbf{79.5}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & \\textbf{79.4}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", @@ -467,34 +216,34 @@ "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", - "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "\n", + "mean_table, std_table = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.2243181 91.46286571 91.27799905]\n", - "[71.87552286 76.03873524 76.73786476]\n" - ] - } - ], + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -510,103 +259,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t87.6 (6.4)\t67.0 (0.8)\t99.4 (0.0)\t89.8\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", - "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t69.6 (16.0)\t37.3 (1.1)\t86.8 (1.1)\t67.2\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", - "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", - "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", - "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 87.57816667, 66.9715 ,\n", - " 99.3802 , 89.79514667],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ]]]),\n", - " array([[[79.9608 , 62.46103333, 69.58566667, 37.34413333,\n", - " 86.79546667, 67.22942 ],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ]]]))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -626,7 +281,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", - "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" ] }, { @@ -638,401 +293,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/source_val_living \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 98.4118 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 98.2941 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 97.7647 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 95.7059 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 82.8824 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 98.4118 \n", - "\n", - " test_acc/target_val_living \\\n", - "0 84.2353 \n", - "1 83.9412 \n", - "2 81.5294 \n", - "3 68.6471 \n", - "4 42.2353 \n", - "5 89.9412 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3qbk... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/279j... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/j354... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/8695... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/10f5... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2ot2... optimizer.args.lr-3e-05 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 95.6786 36.7601 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 93.1918 16.3551 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 92.3360 14.4860 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 90.9443 10.4361 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 88.6586 4.5171 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 97.2767 64.9533 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3lyi... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2sig... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/6l40... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/2tso... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/3i5g... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/o0ed... optimizer.args.lr-3e-05 \n", - " name test_acc/sketch_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 84.3268 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 79.4081 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 77.3239 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 71.0713 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 14.3393 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 63.0263 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 60.7950 https://wandb.ai/p-lambda/finetuning/runs/24w9... \n", - "1 55.3939 https://wandb.ai/p-lambda/finetuning/runs/1rxe... \n", - "2 47.7315 https://wandb.ai/p-lambda/finetuning/runs/16kz... \n", - "3 32.5940 https://wandb.ai/p-lambda/finetuning/runs/3mr8... \n", - "4 6.9134 https://wandb.ai/p-lambda/finetuning/runs/22r2... \n", - "5 28.7772 https://wandb.ai/p-lambda/finetuning/runs/3ci4... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-0.0003 \n", - "2 optimizer.args.lr-0.001 \n", - "3 optimizer.args.lr-0.003 \n", - "4 optimizer.args.lr-0.01 \n", - "5 optimizer.args.lr-3e-05 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 69.0151 67.4215 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 66.9947 65.1218 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 67.1166 64.8506 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 63.6332 60.6076 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 31.0198 26.9646 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 62.7536 62.9274 \n", - "\n", - " test_acc/ood_test test_acc/africa_test \\\n", - "0 61.3353 40.9950 \n", - "1 57.9473 37.3698 \n", - "2 57.7483 37.0999 \n", - "3 53.9307 33.5904 \n", - "4 22.5032 15.8889 \n", - "5 56.6447 37.6012 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/f1au... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/284k... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/w0s6... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/4aij... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/1zj3... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/13fr... optimizer.args.lr-3e-05 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 99.3474 89.3995 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 99.4219 88.1160 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 99.4487 87.5774 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 98.1585 70.8973 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 97.6579 73.7709 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 99.3206 90.6314 \n", - "\n", - " test_acc/ood_test wandb_url \\\n", - "0 92.1544 https://wandb.ai/p-lambda/finetuning/runs/csa6... \n", - "1 84.8908 https://wandb.ai/p-lambda/finetuning/runs/3fwt... \n", - "2 83.2060 https://wandb.ai/p-lambda/finetuning/runs/x1pv... \n", - "3 48.1706 https://wandb.ai/p-lambda/finetuning/runs/fuzi... \n", - "4 55.1614 https://wandb.ai/p-lambda/finetuning/runs/21rv... \n", - "5 95.0526 https://wandb.ai/p-lambda/finetuning/runs/2mb7... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-0.0003 \n", - "2 optimizer.args.lr-0.001 \n", - "3 optimizer.args.lr-0.003 \n", - "4 optimizer.args.lr-0.01 \n", - "5 optimizer.args.lr-3e-05 \n", - " name test_acc/source_val_living \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 95.4706 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 98.7059 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 98.4706 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 98.8824 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 98.2353 \n", - "\n", - " test_acc/target_val_living \\\n", - "0 67.7059 \n", - "1 85.7647 \n", - "2 90.2941 \n", - "3 80.7647 \n", - "4 88.0000 \n", - "5 91.5294 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/8bu0... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2mhb... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/1s2a... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/3ci0... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2ypn... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2sn5... optimizer.args.lr-3e-07 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 90.0114 5.6075 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 98.8165 85.2025 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 98.3287 85.5140 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 97.9859 65.2648 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 98.6567 86.2928 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 98.0875 82.0872 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2nee... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/nwln... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/3ses... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/2ua0... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2cp9... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/yo7d... optimizer.args.lr-3e-07 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/sketch_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 58.3576 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 96.3318 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 96.3318 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 96.8737 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 95.6232 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 21.4317 https://wandb.ai/p-lambda/finetuning/runs/3jmk... \n", - "1 92.2944 https://wandb.ai/p-lambda/finetuning/runs/1l1o... \n", - "2 92.5825 https://wandb.ai/p-lambda/finetuning/runs/1dab... \n", - "3 85.6834 https://wandb.ai/p-lambda/finetuning/runs/2xnh... \n", - "4 93.7635 https://wandb.ai/p-lambda/finetuning/runs/189b... \n", - "5 90.7677 https://wandb.ai/p-lambda/finetuning/runs/1lui... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-1e-05 \n", - "2 optimizer.args.lr-1e-06 \n", - "3 optimizer.args.lr-3e-05 \n", - "4 optimizer.args.lr-3e-06 \n", - "5 optimizer.args.lr-3e-07 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 41.2697 38.3279 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 74.4579 72.4429 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 70.3736 68.1647 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 73.1342 70.3339 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 73.5522 70.7959 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 62.6840 61.9483 \n", - "\n", - " test_acc/ood_test test_acc/africa_test \\\n", - "0 32.2508 21.0567 \n", - "1 67.0979 48.2838 \n", - "2 62.7239 44.0802 \n", - "3 63.6240 43.5789 \n", - "4 64.5649 45.4686 \n", - "5 56.0657 38.4497 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2ir1... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2015... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/2psl... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/t2pv... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/xprd... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/1qdx... optimizer.args.lr-3e-07 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 98.4029 78.5698 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 99.5411 91.5712 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 99.6216 95.0464 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 99.2372 84.9587 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 99.6275 94.8229 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 99.4547 93.5366 \n", - "\n", - " test_acc/ood_test wandb_url \\\n", - "0 65.6771 https://wandb.ai/p-lambda/finetuning/runs/10mp... \n", - "1 90.2380 https://wandb.ai/p-lambda/finetuning/runs/zur7... \n", - "2 96.4517 https://wandb.ai/p-lambda/finetuning/runs/182q... \n", - "3 84.6251 https://wandb.ai/p-lambda/finetuning/runs/3ct8... \n", - "4 95.9155 https://wandb.ai/p-lambda/finetuning/runs/2uej... \n", - "5 95.9285 https://wandb.ai/p-lambda/finetuning/runs/awtw... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-1e-05 \n", - "2 optimizer.args.lr-1e-06 \n", - "3 optimizer.args.lr-3e-05 \n", - "4 optimizer.args.lr-3e-06 \n", - "5 optimizer.args.lr-3e-07 \n", - " name \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", - "\n", - " test_acc/source_val_living test_acc/target_val_living \\\n", - "0 98.7059 90.4706 \n", - "1 98.6471 88.4706 \n", - "2 98.7059 86.1176 \n", - "3 98.0000 81.8824 \n", - "4 96.7059 70.3529 \n", - "5 98.5294 91.7647 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/db01... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2jb3... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/21ja... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/1vxt... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2yr9... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/32hw... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 98.2503 86.1371 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 98.4706 87.0717 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 98.8519 84.7352 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.3602 76.0125 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.4060 18.6916 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 98.1511 84.7352 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/14mo... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/tsai... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/2le0... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/10t5... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2c6t... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2gdu... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name test_acc/sketch_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.0821 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 96.9571 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 96.5402 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.3718 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 83.2847 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 96.1234 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 93.1010 https://wandb.ai/p-lambda/finetuning/runs/2bbx... \n", - "1 94.0804 https://wandb.ai/p-lambda/finetuning/runs/31x1... \n", - "2 92.1504 https://wandb.ai/p-lambda/finetuning/runs/7q05... \n", - "3 79.5189 https://wandb.ai/p-lambda/finetuning/runs/l2xq... \n", - "4 50.2665 https://wandb.ai/p-lambda/finetuning/runs/khjr... \n", - "5 91.7183 https://wandb.ai/p-lambda/finetuning/runs/1z28... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name test_acc/id_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 73.2300 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 74.4927 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 74.1357 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 72.4027 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 63.2761 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 69.6508 \n", - "\n", - " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", - "0 71.6395 65.5283 47.7825 \n", - "1 72.2420 66.3063 49.9422 \n", - "2 72.2922 65.6324 45.1600 \n", - "3 69.8519 62.5656 41.1492 \n", - "4 60.2661 53.4467 33.5904 \n", - "5 68.0593 62.7510 44.3887 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3ocq... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/3vnf... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/3naz... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/pn49... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/uoyu... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/jh49... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/id_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5650 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.6156 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.5888 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.5769 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 98.4237 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4070 \n", - "\n", - " test_acc/ood_val test_acc/ood_test \\\n", - "0 94.8888 96.4599 \n", - "1 95.3472 96.5363 \n", - "2 94.8745 96.3153 \n", - "3 93.8832 94.0156 \n", - "4 75.9025 74.1623 \n", - "5 93.6512 95.9861 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2ads... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/3mpi... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/13dm... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/wdak... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/v23o... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/3fqz... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-B/16\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 1 is out of bounds for axis 0 with size 1", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Liv-17'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"FMoW\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Camelyon\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Avg.\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m id_mean_table, ood_mean_table = display_id_ood_tables(\n\u001b[0m\u001b[1;32m 18\u001b[0m id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_id_ood_tables\u001b[0;34m(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std)\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mno_std\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0mid_std_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 168\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 169\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mdisplay_latex_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_last_avg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m if (std_err_table is not None and\n", - "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 0 with size 1" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_l14']\n", @@ -1051,7 +314,7 @@ "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] @@ -1065,32 +328,16 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "some jobs did not finish: clip_vit_b16 waterbirds freeze_bottom_2_full_ft_epoch_50_ []\n", - "not all jobs ran: clip_vit_b16 freeze_bottom_2_full_ft_epoch_50_ waterbirds 7\n", - "empty dir ../older_logs//full_ft_freeze_bottom_5_full_ft_epoch_50_waterbirds_clip_vit_b16\n" - ] - }, - { - "ename": "TypeError", - "evalue": "object of type 'NoneType' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# desired_epochs_list = [20, 20, 50, 5, 3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../older_logs/'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-embed)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Layer-wise'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LAMB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LARS'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 54\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 55\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 58\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" - ] - } - ], + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Get table for dino and clip, freezing different number of layers.\n", "print(\"CLIP Results, all datasets\")\n", @@ -1123,162 +370,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", - "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", - "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 88.8 & 67.0 & \\textbf{99.4} & 90.0\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & 95.0 & 70.1 & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & 94.9 & 70.0 & \\textbf{99.5} & 92.1\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & \\textbf{97.8} & \\textbf{95.3} & \\textbf{70.5} & \\textbf{99.6} & \\textbf{92.3}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & 66.4 & \\textbf{99.5} & \\textbf{91.1}\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.6} & \\textbf{99.0} & 90.9 & \\textbf{66.8} & \\textbf{99.5} & \\textbf{91.0}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & 89.4 & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.4} & \\textbf{97.8} & \\textbf{89.7} & 65.7 & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", - "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & \\textbf{98.4} & \\textbf{89.1} & 64.9 & \\textbf{99.6} & \\textbf{89.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.2} & 98.7 & 91.1 & 66.6 & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & 68.8 & \\textbf{99.7} & \\textbf{92.2}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & 92.0\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{99.5} & 94.7 & \\textbf{69.2} & \\textbf{99.6} & \\textbf{92.4}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{98.8} & 96.7 & \\textbf{75.1} & \\textbf{99.6} & \\textbf{93.8}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", - "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", - "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "ConvNext-Base\tAdamW (Freeze-2)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 72.8 & 37.3 & 86.8 & 67.9\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & 95.7 & \\textbf{76.0}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & 82.4 & 69.5 & 88.2 & \\textbf{40.7} & \\textbf{96.7} & 75.5\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & 88.1 & \\textbf{82.4} & 82.3 & 35.7 & 93.0 & 76.3\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & 91.9 & 70.7\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & 86.8 & 64.5 & 76.6 & 35.4 & \\textbf{93.5} & 71.4\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{84.3} & 76.5 & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", - "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & 35.0 & \\textbf{95.2} & 74.4\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & 82.9 & \\textbf{77.3} & 83.3 & \\textbf{36.3} & 93.7 & \\textbf{74.7}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", - "BIT ResNet-101 & AdamW & 82.9 & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & 83.1 & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & 75.6\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{84.8} & 78.3 & 84.3 & \\textbf{38.2} & 95.0 & \\textbf{76.1}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & 39.7 & 83.0 & 77.3\\\\\n", - "ConvNext-Base & AdamW & 90.3 & 89.8 & 89.5 & 38.4 & \\textbf{89.5} & 79.5\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & 79.4\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & 88.1 & \\textbf{91.6} & 89.8 & \\textbf{41.6} & 87.7 & \\textbf{79.8}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & 88.0 & 84.6 & \\textbf{93.8} & 44.6 & \\textbf{96.4} & 81.5\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", @@ -1297,87 +391,53 @@ "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## ResNet-50 waterbirds results " + "## ResNet-50 all results " ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: sup_resnet50 waterbirds opt_torch.optim.AdamW_ ['../logs//full_ft_opt_torch.optim.AdamW_waterbirds_sup_resnet50/optimizer.args.lr-0.0001_seed-0_run0']\n", - "not all jobs ran: sup_resnet50 opt_torch.optim.AdamW_ waterbirds 4\n", - "some jobs did not finish: sup_resnet50 waterbirds freeze_bottom_2_ ['../logs//full_ft_freeze_bottom_2_waterbirds_sup_resnet50/freeze_bottom_k-2_optimizer.args.lr-0.001_seed-0_run0']\n", - "not all jobs ran: sup_resnet50 freeze_bottom_2_ waterbirds 4\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tWaterbirds\tAvg.\n", - "ResNet-50 (batchnorm)\tSGD\t97.8\t97.8\n", - "ResNet-50 (batchnorm)\tAdamW\t98.0\t98.0\n", - "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t97.2\t97.2\n", - "\n", - "\\begin{tabular}{cc|c}\n", - "\\toprule\n", - " & Waterbirds & Avg.\\\\\n", - "\\midrule\n", - "SGD & \\textbf{97.8} & \\textbf{97.8}\\\\\n", - "AdamW & \\textbf{98.0} & \\textbf{98.0}\\\\\n", - "SGD (Freeze-2) & 97.2 & 97.2\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tWaterbirds\tAvg.\n", - "ResNet-50 (batchnorm)\tSGD\t60.3\t60.3\n", - "ResNet-50 (batchnorm)\tAdamW\t67.9\t67.9\n", - "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t66.2\t66.2\n", - "\n", - "\\begin{tabular}{cc|c}\n", - "\\toprule\n", - " & Waterbirds & Avg.\\\\\n", - "\\midrule\n", - "SGD & 60.3 & 60.3\\\\\n", - "AdamW & \\textbf{67.9} & \\textbf{67.9}\\\\\n", - "SGD (Freeze-2) & 66.2 & 66.2\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['sup_resnet50']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", - "datasets = ['waterbirds']\n", - "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", - "val_metric_list = ['WATERBIRDS_VAL']\n", - "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['ResNet-50 (batchnorm)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "shorted_model_names = ['ResNet50']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", "\n", - "id_output_metrics_list = [['WATERBIRDS_VAL']]\n", - "ood_output_metrics_list = [['WORST']]\n", - "shortened_dataset_names = ['Waterbirds', \"Avg.\"]\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] @@ -1391,131 +451,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "some jobs did not finish: clip_vit_b16 domainnet optimizer.args.weight_decay-0.01_ ['../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.0003_seed-0_run0', '../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.01_seed-0_run0']\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "CLIP ViT-B/16\tFreeze only embed\t98.0 (nan)\t98.0 (nan)\t95.4 (nan)\t70.2 (nan)\t99.5 (nan)\t92.2\n", - "CLIP ViT-B/16\tSGD (no momentum)\t98.0 (nan)\t97.1 (nan)\t89.5 (nan)\t66.4 (nan)\t99.3 (nan)\t90.1\n", - "CLIP ViT-B/16\tSGD (weight decay)\t97.6 (nan)\t97.2 (nan)\t87.9 (nan)\t66.4 (nan)\t99.3 (nan)\t89.7\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & 97.2 (0.1) & 88.8 (7.1) & 67.0 (0.8) & 99.4 (0.0) & 90.0\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", - "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", - "Freeze only embed & 98.0 & 98.0 & 95.4 & \\textbf{70.2} & \\textbf{99.5} & \\textbf{92.2}\\\\\n", - "SGD (no momentum) & 98.0 & 97.1 & 89.5 & 66.4 & 99.3 & 90.1\\\\\n", - "SGD (weight decay) & 97.6 & 97.2 & 87.9 & 66.4 & 99.3 & 89.7\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "CLIP ViT-B/16\tFreeze only embed\t83.6 (nan)\t74.3 (nan)\t89.1 (nan)\t39.3 (nan)\t92.9 (nan)\t75.9\n", - "CLIP ViT-B/16\tSGD (no momentum)\t81.4 (nan)\t59.2 (nan)\t76.7 (nan)\t37.9 (nan)\t84.3 (nan)\t67.9\n", - "CLIP ViT-B/16\tSGD (weight decay)\t83.9 (nan)\t65.1 (nan)\t67.5 (nan)\t37.1 (nan)\t85.6 (nan)\t67.8\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & 62.5 (5.0) & 72.8 (18.0) & 37.3 (1.1) & 86.8 (1.1) & 67.9\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & 71.9 (2.4) & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", - "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", - "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", - "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", - "Freeze only embed & 83.6 & \\textbf{74.3} & 89.1 & 39.3 & 92.9 & 75.9\\\\\n", - "SGD (no momentum) & 81.4 & 59.2 & 76.7 & 37.9 & 84.3 & 67.9\\\\\n", - "SGD (weight decay) & \\textbf{83.9} & 65.1 & 67.5 & 37.1 & 85.6 & 67.8\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", - " 99.3802 , 90.03969333],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ],\n", - " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", - " 99.5262 , 92.22186 ],\n", - " [98. , 97.071 , 89.5373 , 66.3764 ,\n", - " 99.3236 , 90.06166 ],\n", - " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", - " 99.2938 , 89.6767 ]]]),\n", - " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", - " 86.79546667, 67.86795333],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ],\n", - " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", - " 92.941 , 75.85068 ],\n", - " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", - " 84.2829 , 67.88824 ],\n", - " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", - " 85.5645 , 67.8308 ]]]))" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", "models = ['clip_vit_b16']\n", + "# options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'freeze_bottom_2_optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", @@ -1524,6 +467,7 @@ "desired_epochs_list = [20, 20, 50, 5, 3]\n", "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", + "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", @@ -1531,7 +475,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", - "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n" ] }, { diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index 0c0f074..b93c2a7 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 31, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 31, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -148,6 +148,15 @@ "# Get norms and gradients for different models" ] }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "model = clip_model.ClipModel('ViT-L/14')\n" + ] + }, { "cell_type": "code", "execution_count": 24, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 43662c0..9893c26 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -7,7 +7,7 @@ import subprocess PROJECT_NAME = 'finetuning' -WORKSHEET_NAME = 'nlp::ananyak-fine-tuning' +WORKSHEET_NAME = 'public::fine-tuning-distorts-iclr' DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' @@ -29,10 +29,11 @@ def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): slurm_cmd += f' {sbatch_script_path} ' slurm_cmd += f'"{cmd}"' print(slurm_cmd + '\n') - output = subprocess.check_output(shlex.split(slurm_cmd)).decode('utf8') - job_names = list(re.findall(r'\d+', output)) - assert(len(job_names) == 1) - return job_names[0] + if not(args.print_command): + output = subprocess.check_output(shlex.split(slurm_cmd)).decode('utf8') + job_names = list(re.findall(r'\d+', output)) + assert(len(job_names) == 1) + return job_names[0] def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=''): @@ -44,18 +45,17 @@ def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=' nlp_opt = '' cl_deps_str = ':' + ' :'.join(deps) bundles = ':unlabeled_extrapolation :scripts :configs ' + cl_deps_str + ' ' - makedirs = '"export PYTHONPATH="."; export PYTHONPATH="' + args.code_dir + '"; ' + makedirs = '"export PYTHONPATH=\'.\'; export PYTHONPATH=\'' + args.code_dir + '\'; ' codalab_cmd = prefix + nlp_opt + bundles + makedirs + cmd + '"' - print(codalab_cmd) - subprocess.run(shlex.split(codalab_cmd)) - return job_name + print(codalab_cmd + '\n') + if not(args.print_command): + subprocess.run(shlex.split(codalab_cmd)) + return job_name def run_job(cmd, job_name, args, deps=[]): if args.codalab: return run_codalab(cmd, job_name, args, deps=deps) - elif args.print_command: - print(cmd + '\n') else: return run_sbatch(cmd, job_name, args, deps=deps) @@ -103,7 +103,7 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, if not(run_saved): if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir - if args.amulet_option is not None: + elif args.amulet_option is not None: kwargs['root_prefix'] = '.' else: kwargs['root_prefix'] = root_prefix @@ -833,7 +833,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], config_rel_path='adaptation/cifar_stl.yaml', - bundles=['cifar_stl'], + bundles=['cifar10_dataset', 'stl10_dataset'], slurm_data_cmd=None, slurm_data_dir='/u/scr/ananya/', eval_config_rel_path='adaptation/cifar_stl_eval.yaml') diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 81b8f57..34f9d1a 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -533,6 +533,25 @@ def main(config, log_dir, checkpoints_dir): ] optimizer = utils.initialize( config['optimizer'], update_args={'params': param_groups}) + elif 'embed_layer_lr_multiplier' in config: + layers = [l for n, l in net.get_layers()] + embed_params = get_params(layers[:2]) + other_params = get_params(layers[2:]) + # count number of params, check that it's same as model. + net_count = count_parameters(net, trainable=True) + embed_count = sum([p.numel() for p in embed_params]) + other_count = sum([p.numel() for p in other_params]) + logging.info('total params: %d, opt params: %d', net_count, embed_count + other_count) + # Set different lr for embedding layer. + other_lr = config['optimizer']['args']['lr'] + embed_lr = config['embed_layer_lr_multiplier'] * other_lr + logging.info('Using lr %f for embed layer, %d params', embed_lr, len(embed_params)) + param_groups = [ + {'params': other_params}, + {'params': embed_params, 'lr': embed_lr} + ] + optimizer = utils.initialize( + config['optimizer'], update_args={'params': param_groups}) else: optimizer = utils.initialize( config['optimizer'], update_args={'params': net.parameters()}) From e6db406a88a7352c600a44e292866dd35bef7ae0 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 8 Nov 2022 18:28:37 -0800 Subject: [PATCH 164/197] Updates --- .gitignore | 1 + configs/adaptation/cifar_stl_nonorm.yaml | 2 + configs/adaptation/living17.yaml | 2 + ...eeze-embed-paper-fine-tuning-results.ipynb | 1194 +---------------- ...oad_models_test_get_layers_gradients.ipynb | 15 +- scripts/run_adaptation_experiments.py | 26 +- unlabeled_extrapolation/baseline_train.py | 19 + 7 files changed, 118 insertions(+), 1141 deletions(-) diff --git a/.gitignore b/.gitignore index 72f1f93..000eee2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ **amlt_configs/** .amltconfig **amlt_scripts** +**.pkl **tmp.tsv** **slurm_outputs** diff --git a/configs/adaptation/cifar_stl_nonorm.yaml b/configs/adaptation/cifar_stl_nonorm.yaml index f4daf3f..e2ec2ef 100644 --- a/configs/adaptation/cifar_stl_nonorm.yaml +++ b/configs/adaptation/cifar_stl_nonorm.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 10 epochs: &epochs 20 save_no_checkpoints: True +batch_size: 32 +batch_splits: 2 model: classname: models.imnet_resnet.ResNet50 diff --git a/configs/adaptation/living17.yaml b/configs/adaptation/living17.yaml index a24583f..19263a3 100644 --- a/configs/adaptation/living17.yaml +++ b/configs/adaptation/living17.yaml @@ -6,6 +6,8 @@ inherit: num_classes: 17 epochs: &epochs 20 +save_no_checkpoints: True + model: classname: models.imnet_resnet.ResNet50 args: {} diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index b41bcb4..7d11f1c 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,45 +2,27 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", "import importlib\n", "import math\n", + "import pickle\n", "importlib.reload(summarize_all_results)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "log_dir = '../logs/'\n", "name_template = 'full_ft_{option}{dataset}_{model}'\n", "\n", - "# TODOs:\n", - "# Get mean and std (done)\n", - "# Filter out for ID and OOD columns (done)\n", - "# Add an overall average column\n", - "\n", - "# Print some nice Latex tables (done)\n", - "# Bold the best numbers within confidence intervals, in the latex table\n", - "\n", "def get_bolds(table, std_err_table=None, eps=0.2):\n", " is_best = np.zeros((len(table), len(table[0])), dtype=np.int32)\n", " for col in range(len(table[0])):\n", @@ -188,7 +170,7 @@ " print('\\\\end{tabular}')\n", " \n", " \n", - "def display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", + "def display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=False):\n", " # Filter the ID and OOD metrics.\n", " print('\\n\\nID Accuracies')\n", " id_mean_table = filter_columns(mean_table, output_metrics_list, id_output_metrics_list)\n", @@ -213,113 +195,6 @@ " " ] }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 2, 3])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.concatenate([[0], np.array([1,2,3])])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'np' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'test_acc/source_val_living'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'test_acc/sketch_val'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Sup ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DINO ViT-B/16'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-50'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'BIT ResNet-101'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ConvNext-Base'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'CLIP ViT-L/14'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-2)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW (Freeze-2)'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# desired_epochs_list is a list of size len(datasets) that stores the number of epochs we are\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0;31m# supposed to have run each dataset for. Used to validate if the runs finished.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mmean_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mol\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mol\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mmodel_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" - ] - } - ], - "source": [ - "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (LAST)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", - "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", - "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val']]\n", - "val_metric_list = ['LAST', 'LAST', 'LAST']\n", - "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "desired_epochs_list = [20, 20, 50]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", - "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD']\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)\n", - "display_latex_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t\tLiving-17 ID\tLiving-17 OOD\tWaterbirds ID\tWaterbirds OOD\tDomainNet ID\tDomainNet OOD\n", - "CLIP ViT-B/16\tSGD\t97.8\t80.0\t97.2\t62.5\t87.6\t69.6\n", - "CLIP ViT-B/16\tAdamW\t98.1\t82.8\t97.7\t71.9\t95.0\t89.2\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t83.2\t97.8\t73.7\t94.9\t88.2\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t82.4\t97.8\t69.5\t95.3\t88.2\n", - "Sup ViT-B/16\tSGD\t98.6\t89.5\t99.1\t77.4\t91.7\t86.3\n", - "Sup ViT-B/16\tAdamW\t98.7\t88.3\t99.0\t81.6\t91.7\t84.4\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t88.0\t99.2\t82.4\t91.5\t86.3\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t88.1\t99.0\t82.4\t90.9\t82.3\n", - "DINO ViT-B/16\tSGD\t98.4\t88.2\t97.0\t56.1\t88.2\t76.0\n", - "DINO ViT-B/16\tAdamW\t98.5\t87.4\t97.9\t61.2\t89.4\t77.4\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t86.7\t97.5\t67.9\t89.0\t78.4\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t86.8\t97.8\t64.5\t89.7\t76.6\n", - "BIT ResNet-50\tSGD\t97.4\t84.3\t98.4\t76.5\t89.3\t80.0\n", - "BIT ResNet-50\tAdamW\t97.2\t83.1\t98.5\t74.8\t89.2\t84.0\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t84.1\t98.5\t75.5\t89.2\t82.3\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t82.9\t98.4\t77.3\t89.1\t83.3\n", - "BIT ResNet-101\tSGD\t98.3\t82.8\t98.9\t76.9\t92.0\t86.2\n", - "BIT ResNet-101\tAdamW\t98.4\t82.9\t98.6\t79.4\t91.1\t83.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t83.1\t98.8\t77.3\t91.5\t86.0\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t84.8\t98.7\t78.3\t91.1\t84.3\n", - "ConvNext-Base\tSGD\t98.7\t94.0\t99.0\t80.2\t94.8\t89.8\n", - "ConvNext-Base\tAdamW\t98.6\t90.3\t99.5\t89.8\t94.5\t89.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t92.6\t99.4\t86.9\t95.1\t91.2\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t88.1\t99.5\t91.6\t94.7\t89.8\n", - "CLIP ResNet-50\tSGD\t94.5\t66.9\t90.9\t7.3\t82.4\t56.1\n", - "CLIP ResNet-50\tAdamW\t96.9\t73.1\t96.8\t63.2\t88.6\t70.6\n", - "CLIP ResNet-50\tSGD (Freeze-2)\t95.9\t70.5\t93.1\t20.2\t84.5\t60.1\n", - "CLIP ResNet-50\tAdamW (Freeze-2)\t97.0\t70.9\t97.1\t59.3\t87.6\t71.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t84.2\t97.3\t65.0\t84.3\t60.8\n", - "CLIP ViT-L/14\tAdamW\t98.9\t88.0\t98.8\t85.2\t96.9\t93.8\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t90.5\t98.9\t84.7\t97.1\t93.1\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t88.0\t98.8\t84.6\t96.7\t93.8\n" - ] - } - ], - "source": [ - "# Big table, Living17, Waterbirds, DomainNet, including AdamW freeze-2 (Early stopped)\n", - "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val']\n", - "table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list)\n", - "display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, table)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -329,135 +204,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t87.6\t67.0\t99.4\t89.8\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 87.6 & 67.0 & \\textbf{99.4} & 89.8\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & \\textbf{95.0} & \\textbf{70.1} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & \\textbf{94.9} & \\textbf{70.0} & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & \\textbf{66.4} & \\textbf{99.5} & \\textbf{91.1}\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & \\textbf{89.4} & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", - "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & \\textbf{68.8} & \\textbf{99.7} & \\textbf{92.2}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & \\textbf{92.0}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & \\textbf{74.5} & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t69.6\t37.3\t86.8\t67.2\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 69.6 & 37.3 & 86.8 & 67.2\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & \\textbf{95.7} & \\textbf{76.0}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & \\textbf{91.9} & 70.7\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{84.3} & \\textbf{76.5} & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", - "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & \\textbf{35.0} & \\textbf{95.2} & \\textbf{74.4}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{82.9} & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{83.1} & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & \\textbf{75.6}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & \\textbf{39.7} & 83.0 & 77.3\\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\textbf{89.8} & 89.5 & 38.4 & \\textbf{89.5} & \\textbf{79.5}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & \\textbf{79.4}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", @@ -467,34 +216,34 @@ "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", - "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "\n", + "mean_table, std_table = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.2243181 91.46286571 91.27799905]\n", - "[71.87552286 76.03873524 76.73786476]\n" - ] - } - ], + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -510,103 +259,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "some jobs did not finish: clip_vit_b16 domainnet ['../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-0.0001_seed-0_run0', '../logs//full_ft_domainnet_clip_vit_b16/optimizer.args.lr-3e-05_seed-0_run0']\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t87.6 (6.4)\t67.0 (0.8)\t99.4 (0.0)\t89.8\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & 97.2 (0.1) & 87.6 (6.4) & 67.0 (0.8) & 99.4 (0.0) & 89.8\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", - "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t69.6 (16.0)\t37.3 (1.1)\t86.8 (1.1)\t67.2\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & 62.5 (5.0) & 69.6 (16.0) & 37.3 (1.1) & 86.8 (1.1) & 67.2\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\textbf{71.9 (2.4)} & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", - "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", - "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", - "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 87.57816667, 66.9715 ,\n", - " 99.3802 , 89.79514667],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ]]]),\n", - " array([[[79.9608 , 62.46103333, 69.58566667, 37.34413333,\n", - " 86.79546667, 67.22942 ],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ]]]))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -626,7 +281,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", - "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" ] }, { @@ -638,401 +293,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/source_val_living \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 98.4118 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 98.2941 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 97.7647 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 95.7059 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 82.8824 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 98.4118 \n", - "\n", - " test_acc/target_val_living \\\n", - "0 84.2353 \n", - "1 83.9412 \n", - "2 81.5294 \n", - "3 68.6471 \n", - "4 42.2353 \n", - "5 89.9412 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3qbk... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/279j... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/j354... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/8695... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/10f5... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2ot2... optimizer.args.lr-3e-05 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 95.6786 36.7601 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 93.1918 16.3551 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 92.3360 14.4860 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 90.9443 10.4361 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 88.6586 4.5171 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 97.2767 64.9533 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3lyi... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2sig... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/6l40... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/2tso... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/3i5g... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/o0ed... optimizer.args.lr-3e-05 \n", - " name test_acc/sketch_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 84.3268 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 79.4081 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 77.3239 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 71.0713 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 14.3393 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 63.0263 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 60.7950 https://wandb.ai/p-lambda/finetuning/runs/24w9... \n", - "1 55.3939 https://wandb.ai/p-lambda/finetuning/runs/1rxe... \n", - "2 47.7315 https://wandb.ai/p-lambda/finetuning/runs/16kz... \n", - "3 32.5940 https://wandb.ai/p-lambda/finetuning/runs/3mr8... \n", - "4 6.9134 https://wandb.ai/p-lambda/finetuning/runs/22r2... \n", - "5 28.7772 https://wandb.ai/p-lambda/finetuning/runs/3ci4... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-0.0003 \n", - "2 optimizer.args.lr-0.001 \n", - "3 optimizer.args.lr-0.003 \n", - "4 optimizer.args.lr-0.01 \n", - "5 optimizer.args.lr-3e-05 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 69.0151 67.4215 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 66.9947 65.1218 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 67.1166 64.8506 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 63.6332 60.6076 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 31.0198 26.9646 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 62.7536 62.9274 \n", - "\n", - " test_acc/ood_test test_acc/africa_test \\\n", - "0 61.3353 40.9950 \n", - "1 57.9473 37.3698 \n", - "2 57.7483 37.0999 \n", - "3 53.9307 33.5904 \n", - "4 22.5032 15.8889 \n", - "5 56.6447 37.6012 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/f1au... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/284k... optimizer.args.lr-0.0003 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/w0s6... optimizer.args.lr-0.001 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/4aij... optimizer.args.lr-0.003 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/1zj3... optimizer.args.lr-0.01 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/13fr... optimizer.args.lr-3e-05 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 99.3474 89.3995 \n", - "1 optimizer.args.lr-0.0003_seed-0_run0 99.4219 88.1160 \n", - "2 optimizer.args.lr-0.001_seed-0_run0 99.4487 87.5774 \n", - "3 optimizer.args.lr-0.003_seed-0_run0 98.1585 70.8973 \n", - "4 optimizer.args.lr-0.01_seed-0_run0 97.6579 73.7709 \n", - "5 optimizer.args.lr-3e-05_seed-0_run0 99.3206 90.6314 \n", - "\n", - " test_acc/ood_test wandb_url \\\n", - "0 92.1544 https://wandb.ai/p-lambda/finetuning/runs/csa6... \n", - "1 84.8908 https://wandb.ai/p-lambda/finetuning/runs/3fwt... \n", - "2 83.2060 https://wandb.ai/p-lambda/finetuning/runs/x1pv... \n", - "3 48.1706 https://wandb.ai/p-lambda/finetuning/runs/fuzi... \n", - "4 55.1614 https://wandb.ai/p-lambda/finetuning/runs/21rv... \n", - "5 95.0526 https://wandb.ai/p-lambda/finetuning/runs/2mb7... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-0.0003 \n", - "2 optimizer.args.lr-0.001 \n", - "3 optimizer.args.lr-0.003 \n", - "4 optimizer.args.lr-0.01 \n", - "5 optimizer.args.lr-3e-05 \n", - " name test_acc/source_val_living \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 95.4706 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 98.7059 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 98.4706 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 98.8824 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 98.2353 \n", - "\n", - " test_acc/target_val_living \\\n", - "0 67.7059 \n", - "1 85.7647 \n", - "2 90.2941 \n", - "3 80.7647 \n", - "4 88.0000 \n", - "5 91.5294 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/8bu0... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2mhb... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/1s2a... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/3ci0... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2ypn... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2sn5... optimizer.args.lr-3e-07 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 90.0114 5.6075 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 98.8165 85.2025 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 98.3287 85.5140 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 97.9859 65.2648 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 98.6567 86.2928 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 98.0875 82.0872 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2nee... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/nwln... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/3ses... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/2ua0... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2cp9... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/yo7d... optimizer.args.lr-3e-07 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/sketch_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 58.3576 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 96.3318 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 96.3318 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 96.8737 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 95.6232 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 21.4317 https://wandb.ai/p-lambda/finetuning/runs/3jmk... \n", - "1 92.2944 https://wandb.ai/p-lambda/finetuning/runs/1l1o... \n", - "2 92.5825 https://wandb.ai/p-lambda/finetuning/runs/1dab... \n", - "3 85.6834 https://wandb.ai/p-lambda/finetuning/runs/2xnh... \n", - "4 93.7635 https://wandb.ai/p-lambda/finetuning/runs/189b... \n", - "5 90.7677 https://wandb.ai/p-lambda/finetuning/runs/1lui... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-1e-05 \n", - "2 optimizer.args.lr-1e-06 \n", - "3 optimizer.args.lr-3e-05 \n", - "4 optimizer.args.lr-3e-06 \n", - "5 optimizer.args.lr-3e-07 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 41.2697 38.3279 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 74.4579 72.4429 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 70.3736 68.1647 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 73.1342 70.3339 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 73.5522 70.7959 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 62.6840 61.9483 \n", - "\n", - " test_acc/ood_test test_acc/africa_test \\\n", - "0 32.2508 21.0567 \n", - "1 67.0979 48.2838 \n", - "2 62.7239 44.0802 \n", - "3 63.6240 43.5789 \n", - "4 64.5649 45.4686 \n", - "5 56.0657 38.4497 \n", - "\n", - " wandb_url group \n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2ir1... optimizer.args.lr-0.0001 \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2015... optimizer.args.lr-1e-05 \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/2psl... optimizer.args.lr-1e-06 \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/t2pv... optimizer.args.lr-3e-05 \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/xprd... optimizer.args.lr-3e-06 \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/1qdx... optimizer.args.lr-3e-07 \n", - " name test_acc/id_val test_acc/ood_val \\\n", - "0 optimizer.args.lr-0.0001_seed-0_run0 98.4029 78.5698 \n", - "1 optimizer.args.lr-1e-05_seed-0_run0 99.5411 91.5712 \n", - "2 optimizer.args.lr-1e-06_seed-0_run0 99.6216 95.0464 \n", - "3 optimizer.args.lr-3e-05_seed-0_run0 99.2372 84.9587 \n", - "4 optimizer.args.lr-3e-06_seed-0_run0 99.6275 94.8229 \n", - "5 optimizer.args.lr-3e-07_seed-0_run0 99.4547 93.5366 \n", - "\n", - " test_acc/ood_test wandb_url \\\n", - "0 65.6771 https://wandb.ai/p-lambda/finetuning/runs/10mp... \n", - "1 90.2380 https://wandb.ai/p-lambda/finetuning/runs/zur7... \n", - "2 96.4517 https://wandb.ai/p-lambda/finetuning/runs/182q... \n", - "3 84.6251 https://wandb.ai/p-lambda/finetuning/runs/3ct8... \n", - "4 95.9155 https://wandb.ai/p-lambda/finetuning/runs/2uej... \n", - "5 95.9285 https://wandb.ai/p-lambda/finetuning/runs/awtw... \n", - "\n", - " group \n", - "0 optimizer.args.lr-0.0001 \n", - "1 optimizer.args.lr-1e-05 \n", - "2 optimizer.args.lr-1e-06 \n", - "3 optimizer.args.lr-3e-05 \n", - "4 optimizer.args.lr-3e-06 \n", - "5 optimizer.args.lr-3e-07 \n", - " name \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", - "\n", - " test_acc/source_val_living test_acc/target_val_living \\\n", - "0 98.7059 90.4706 \n", - "1 98.6471 88.4706 \n", - "2 98.7059 86.1176 \n", - "3 98.0000 81.8824 \n", - "4 96.7059 70.3529 \n", - "5 98.5294 91.7647 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/db01... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/2jb3... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/21ja... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/1vxt... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2yr9... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/32hw... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name WATERBIRDS_VAL WORST \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 98.2503 86.1371 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 98.4706 87.0717 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 98.8519 84.7352 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.3602 76.0125 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.4060 18.6916 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 98.1511 84.7352 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/14mo... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/tsai... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/2le0... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/10t5... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/2c6t... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/2gdu... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name test_acc/sketch_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.0821 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 96.9571 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 96.5402 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.3718 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 83.2847 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 96.1234 \n", - "\n", - " test_acc/real_val wandb_url \\\n", - "0 93.1010 https://wandb.ai/p-lambda/finetuning/runs/2bbx... \n", - "1 94.0804 https://wandb.ai/p-lambda/finetuning/runs/31x1... \n", - "2 92.1504 https://wandb.ai/p-lambda/finetuning/runs/7q05... \n", - "3 79.5189 https://wandb.ai/p-lambda/finetuning/runs/l2xq... \n", - "4 50.2665 https://wandb.ai/p-lambda/finetuning/runs/khjr... \n", - "5 91.7183 https://wandb.ai/p-lambda/finetuning/runs/1z28... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - " name test_acc/id_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 73.2300 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 74.4927 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 74.1357 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 72.4027 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 63.2761 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 69.6508 \n", - "\n", - " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", - "0 71.6395 65.5283 47.7825 \n", - "1 72.2420 66.3063 49.9422 \n", - "2 72.2922 65.6324 45.1600 \n", - "3 69.8519 62.5656 41.1492 \n", - "4 60.2661 53.4467 33.5904 \n", - "5 68.0593 62.7510 44.3887 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/3ocq... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/3vnf... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/3naz... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/pn49... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/uoyu... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/jh49... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name test_acc/id_val \\\n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5650 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.6156 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.5888 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.5769 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 98.4237 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4070 \n", - "\n", - " test_acc/ood_val test_acc/ood_test \\\n", - "0 94.8888 96.4599 \n", - "1 95.3472 96.5363 \n", - "2 94.8745 96.3153 \n", - "3 93.8832 94.0156 \n", - "4 75.9025 74.1623 \n", - "5 93.6512 95.9861 \n", - "\n", - " wandb_url \\\n", - "0 https://wandb.ai/p-lambda/finetuning/runs/2ads... \n", - "1 https://wandb.ai/p-lambda/finetuning/runs/3mpi... \n", - "2 https://wandb.ai/p-lambda/finetuning/runs/13dm... \n", - "3 https://wandb.ai/p-lambda/finetuning/runs/wdak... \n", - "4 https://wandb.ai/p-lambda/finetuning/runs/v23o... \n", - "5 https://wandb.ai/p-lambda/finetuning/runs/3fqz... \n", - "\n", - " group \n", - "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", - "1 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", - "2 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", - "3 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", - "4 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", - "5 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-B/16\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index 1 is out of bounds for axis 0 with size 1", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'Liv-17'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Waterbirds'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'DomainNet'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"FMoW\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Camelyon\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Avg.\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m id_mean_table, ood_mean_table = display_id_ood_tables(\n\u001b[0m\u001b[1;32m 18\u001b[0m id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_id_ood_tables\u001b[0;34m(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std)\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mno_std\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0mid_std_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 168\u001b[0;31m \u001b[0mdisplay_tsv_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 169\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mdisplay_latex_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshorted_model_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_options_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshortened_dataset_names\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_mean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mid_std_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_last_avg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mdisplay_tsv_table\u001b[0;34m(models, options, shortened_output_metrics_list, table, std_err_table)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moption_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moption\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodel_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moption_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0mline\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m'\\t'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'{:.1f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m if (std_err_table is not None and\n", - "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 0 with size 1" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_l14']\n", @@ -1051,7 +314,7 @@ "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] @@ -1065,32 +328,16 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "some jobs did not finish: clip_vit_b16 waterbirds freeze_bottom_2_full_ft_epoch_50_ []\n", - "not all jobs ran: clip_vit_b16 freeze_bottom_2_full_ft_epoch_50_ waterbirds 7\n", - "empty dir ../older_logs//full_ft_freeze_bottom_5_full_ft_epoch_50_waterbirds_clip_vit_b16\n" - ] - }, - { - "ename": "TypeError", - "evalue": "object of type 'NoneType' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0maggregation_metric_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'WATERBIRDS_VAL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# desired_epochs_list = [20, 20, 50, 5, 3]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../older_logs/'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mshorted_model_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'CLIP ViT-B/16'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mshortened_options_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'SGD'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'AdamW'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'SGD (Freeze-embed)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Layer-wise'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LAMB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'LARS'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 54\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 55\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 58\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" - ] - } - ], + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Get table for dino and clip, freezing different number of layers.\n", "print(\"CLIP Results, all datasets\")\n", @@ -1123,162 +370,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", - "BIT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BIT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BIT ResNet-50\tSGD (Freeze-2)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", - "BIT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BIT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BIT ResNet-101\tSGD (Freeze-2)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (Freeze-2)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "ConvNext-Base\tAdamW (Freeze-2)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & 97.2 & 88.8 & 67.0 & \\textbf{99.4} & 90.0\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\textbf{97.7} & 95.0 & 70.1 & \\textbf{99.5} & \\textbf{92.1}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{98.2} & \\textbf{97.8} & 94.9 & 70.0 & \\textbf{99.5} & 92.1\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.3} & \\textbf{97.8} & \\textbf{95.3} & \\textbf{70.5} & \\textbf{99.6} & \\textbf{92.3}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & \\textbf{99.1} & \\textbf{91.7} & 64.1 & \\textbf{99.4} & 90.6\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\textbf{99.0} & \\textbf{91.7} & 66.4 & \\textbf{99.5} & \\textbf{91.1}\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{99.2} & 91.5 & 65.0 & \\textbf{99.6} & 90.8\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.6} & \\textbf{99.0} & 90.9 & \\textbf{66.8} & \\textbf{99.5} & \\textbf{91.0}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & 97.0 & 88.2 & 62.4 & 99.4 & 89.1\\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\textbf{97.9} & 89.4 & \\textbf{66.0} & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & \\textbf{98.4} & 97.5 & 89.0 & 63.5 & \\textbf{99.5} & 89.6\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & \\textbf{98.4} & \\textbf{97.8} & \\textbf{89.7} & 65.7 & \\textbf{99.6} & \\textbf{90.3}\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & 97.4 & \\textbf{98.4} & \\textbf{89.3} & 64.6 & \\textbf{99.5} & \\textbf{89.8}\\\\\n", - "BIT ResNet-50 & AdamW & 97.2 & \\textbf{98.5} & \\textbf{89.2} & \\textbf{65.1} & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & \\textbf{97.6} & \\textbf{98.5} & \\textbf{89.2} & 64.8 & \\textbf{99.5} & \\textbf{89.9}\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & \\textbf{97.4} & \\textbf{98.4} & \\textbf{89.1} & 64.9 & \\textbf{99.6} & \\textbf{89.9}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & \\textbf{98.3} & \\textbf{98.9} & \\textbf{92.0} & 66.0 & \\textbf{99.4} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & AdamW & \\textbf{98.4} & 98.6 & 91.1 & \\textbf{67.0} & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & \\textbf{98.4} & \\textbf{98.8} & 91.5 & 65.9 & \\textbf{99.5} & \\textbf{90.8}\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{98.2} & 98.7 & 91.1 & 66.6 & \\textbf{99.6} & \\textbf{90.9}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & 99.0 & 94.8 & 66.3 & 99.4 & 91.6\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\textbf{99.5} & 94.5 & 68.8 & \\textbf{99.7} & \\textbf{92.2}\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & \\textbf{98.6} & \\textbf{99.4} & \\textbf{95.1} & 67.4 & \\textbf{99.5} & 92.0\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{99.5} & 94.7 & \\textbf{69.2} & \\textbf{99.6} & \\textbf{92.4}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & 97.3 & 84.3 & 69.0 & \\textbf{99.4} & 89.7\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\textbf{98.8} & 96.9 & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{98.7} & \\textbf{98.9} & \\textbf{97.1} & 74.5 & \\textbf{99.6} & \\textbf{93.7}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & \\textbf{98.7} & \\textbf{98.8} & 96.7 & \\textbf{75.1} & \\textbf{99.6} & \\textbf{93.8}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-2)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (Freeze-2)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (Freeze-2)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tAdamW (Freeze-2)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (Freeze-2)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tAdamW (Freeze-2)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", - "BIT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BIT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BIT ResNet-50\tSGD (Freeze-2)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BIT ResNet-50\tAdamW (Freeze-2)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", - "BIT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BIT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BIT ResNet-101\tSGD (Freeze-2)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BIT ResNet-101\tAdamW (Freeze-2)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (Freeze-2)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "ConvNext-Base\tAdamW (Freeze-2)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (Freeze-2)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "CLIP ViT-L/14\tAdamW (Freeze-2)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & 62.5 & 72.8 & 37.3 & 86.8 & 67.9\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & 71.9 & \\textbf{89.2} & \\textbf{40.7} & 95.7 & \\textbf{76.0}\\\\\n", - "CLIP ViT-B/16 & SGD (Freeze-2) & \\textbf{83.2} & \\textbf{73.7} & 88.2 & 40.2 & 94.3 & \\textbf{75.9}\\\\\n", - "CLIP ViT-B/16 & AdamW (Freeze-2) & 82.4 & 69.5 & 88.2 & \\textbf{40.7} & \\textbf{96.7} & 75.5\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & 77.4 & \\textbf{86.3} & 33.5 & 92.6 & 75.8\\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & 81.6 & 84.4 & \\textbf{35.9} & 87.9 & 75.6\\\\\n", - "Sup ViT-B/16 & SGD (Freeze-2) & 88.0 & \\textbf{82.4} & \\textbf{86.3} & 34.4 & \\textbf{93.7} & \\textbf{77.0}\\\\\n", - "Sup ViT-B/16 & AdamW (Freeze-2) & 88.1 & \\textbf{82.4} & 82.3 & 35.7 & 93.0 & 76.3\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & 56.1 & 76.0 & 33.6 & 86.9 & 68.2\\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & 61.2 & 77.4 & \\textbf{35.8} & 91.9 & 70.7\\\\\n", - "DINO ViT-B/16 & SGD (Freeze-2) & 86.7 & \\textbf{67.9} & \\textbf{78.4} & \\textbf{35.9} & 90.6 & \\textbf{71.9}\\\\\n", - "DINO ViT-B/16 & AdamW (Freeze-2) & 86.8 & 64.5 & 76.6 & 35.4 & \\textbf{93.5} & 71.4\\\\\n", - "\\midrule\n", - "BIT ResNet-50 & SGD & \\textbf{84.3} & 76.5 & 80.0 & 34.1 & 90.4 & 73.1\\\\\n", - "BIT ResNet-50 & AdamW & 83.1 & 74.8 & \\textbf{84.0} & 33.8 & 92.4 & 73.6\\\\\n", - "BIT ResNet-50 & SGD (Freeze-2) & 84.1 & 75.5 & 82.3 & 35.0 & \\textbf{95.2} & 74.4\\\\\n", - "BIT ResNet-50 & AdamW (Freeze-2) & 82.9 & \\textbf{77.3} & 83.3 & \\textbf{36.3} & 93.7 & \\textbf{74.7}\\\\\n", - "\\midrule\n", - "BIT ResNet-101 & SGD & 82.8 & 76.9 & \\textbf{86.2} & \\textbf{38.0} & 89.3 & 74.6\\\\\n", - "BIT ResNet-101 & AdamW & 82.9 & \\textbf{79.4} & 83.5 & 37.0 & 89.7 & 74.5\\\\\n", - "BIT ResNet-101 & SGD (Freeze-2) & 83.1 & 77.3 & 86.0 & 36.0 & \\textbf{95.5} & 75.6\\\\\n", - "BIT ResNet-101 & AdamW (Freeze-2) & \\textbf{84.8} & 78.3 & 84.3 & \\textbf{38.2} & 95.0 & \\textbf{76.1}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & 80.2 & 89.8 & 39.7 & 83.0 & 77.3\\\\\n", - "ConvNext-Base & AdamW & 90.3 & 89.8 & 89.5 & 38.4 & \\textbf{89.5} & 79.5\\\\\n", - "ConvNext-Base & SGD (Freeze-2) & 92.6 & 86.9 & \\textbf{91.2} & 38.2 & 88.1 & 79.4\\\\\n", - "ConvNext-Base & AdamW (Freeze-2) & 88.1 & \\textbf{91.6} & 89.8 & \\textbf{41.6} & 87.7 & \\textbf{79.8}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & 65.0 & 60.8 & 41.0 & 83.2 & 66.8\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\textbf{85.2} & \\textbf{93.8} & 48.3 & 95.9 & 82.2\\\\\n", - "CLIP ViT-L/14 & SGD (Freeze-2) & \\textbf{90.5} & 84.7 & 93.1 & \\textbf{49.9} & \\textbf{96.5} & \\textbf{83.0}\\\\\n", - "CLIP ViT-L/14 & AdamW (Freeze-2) & 88.0 & 84.6 & \\textbf{93.8} & 44.6 & \\textbf{96.4} & 81.5\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", @@ -1297,87 +391,53 @@ "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## ResNet-50 waterbirds results " + "## ResNet-50 all results " ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "some jobs did not finish: sup_resnet50 waterbirds opt_torch.optim.AdamW_ ['../logs//full_ft_opt_torch.optim.AdamW_waterbirds_sup_resnet50/optimizer.args.lr-0.0001_seed-0_run0']\n", - "not all jobs ran: sup_resnet50 opt_torch.optim.AdamW_ waterbirds 4\n", - "some jobs did not finish: sup_resnet50 waterbirds freeze_bottom_2_ ['../logs//full_ft_freeze_bottom_2_waterbirds_sup_resnet50/freeze_bottom_k-2_optimizer.args.lr-0.001_seed-0_run0']\n", - "not all jobs ran: sup_resnet50 freeze_bottom_2_ waterbirds 4\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tWaterbirds\tAvg.\n", - "ResNet-50 (batchnorm)\tSGD\t97.8\t97.8\n", - "ResNet-50 (batchnorm)\tAdamW\t98.0\t98.0\n", - "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t97.2\t97.2\n", - "\n", - "\\begin{tabular}{cc|c}\n", - "\\toprule\n", - " & Waterbirds & Avg.\\\\\n", - "\\midrule\n", - "SGD & \\textbf{97.8} & \\textbf{97.8}\\\\\n", - "AdamW & \\textbf{98.0} & \\textbf{98.0}\\\\\n", - "SGD (Freeze-2) & 97.2 & 97.2\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tWaterbirds\tAvg.\n", - "ResNet-50 (batchnorm)\tSGD\t60.3\t60.3\n", - "ResNet-50 (batchnorm)\tAdamW\t67.9\t67.9\n", - "ResNet-50 (batchnorm)\tSGD (Freeze-2)\t66.2\t66.2\n", - "\n", - "\\begin{tabular}{cc|c}\n", - "\\toprule\n", - " & Waterbirds & Avg.\\\\\n", - "\\midrule\n", - "SGD & 60.3 & 60.3\\\\\n", - "AdamW & \\textbf{67.9} & \\textbf{67.9}\\\\\n", - "SGD (Freeze-2) & 66.2 & 66.2\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['sup_resnet50']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", - "datasets = ['waterbirds']\n", - "output_metrics_list = [['WATERBIRDS_VAL', 'WORST']]\n", - "val_metric_list = ['WATERBIRDS_VAL']\n", - "aggregation_metric_list = ['WATERBIRDS_VAL']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['ResNet-50 (batchnorm)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "shorted_model_names = ['ResNet50']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", "\n", - "id_output_metrics_list = [['WATERBIRDS_VAL']]\n", - "ood_output_metrics_list = [['WORST']]\n", - "shortened_dataset_names = ['Waterbirds', \"Avg.\"]\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", - " id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] @@ -1391,131 +451,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "some jobs did not finish: clip_vit_b16 domainnet optimizer.args.weight_decay-0.01_ ['../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.0003_seed-0_run0', '../logs//full_ft_optimizer.args.weight_decay-0.01_domainnet_clip_vit_b16/optimizer.args.lr-0.01_seed-0_run0']\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "CLIP ViT-B/16\tFreeze only embed\t98.0 (nan)\t98.0 (nan)\t95.4 (nan)\t70.2 (nan)\t99.5 (nan)\t92.2\n", - "CLIP ViT-B/16\tSGD (no momentum)\t98.0 (nan)\t97.1 (nan)\t89.5 (nan)\t66.4 (nan)\t99.3 (nan)\t90.1\n", - "CLIP ViT-B/16\tSGD (weight decay)\t97.6 (nan)\t97.2 (nan)\t87.9 (nan)\t66.4 (nan)\t99.3 (nan)\t89.7\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & 97.2 (0.1) & 88.8 (7.1) & 67.0 (0.8) & 99.4 (0.0) & 90.0\\\\\n", - "AdamW & 98.1 (0.1) & 97.7 (0.0) & 95.0 (0.1) & \\textbf{70.1 (0.2)} & \\textbf{99.5 (0.0)} & \\textbf{92.1}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & 97.8 (0.1) & 94.9 (0.3) & \\textbf{70.0 (0.2)} & 99.5 (0.0) & \\textbf{92.1}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\textbf{98.3 (0.0)} & \\textbf{96.3 (0.1)} & 69.2 (0.5) & 99.3 (0.1) & \\textbf{92.3}\\\\\n", - "LAMB & \\textbf{98.2} & 97.8 & 95.1 & 67.9 & \\textbf{99.5} & 91.7\\\\\n", - "LARS & 97.7 & 97.1 & 93.2 & 67.0 & 99.3 & 90.9\\\\\n", - "Freeze only embed & 98.0 & 98.0 & 95.4 & \\textbf{70.2} & \\textbf{99.5} & \\textbf{92.2}\\\\\n", - "SGD (no momentum) & 98.0 & 97.1 & 89.5 & 66.4 & 99.3 & 90.1\\\\\n", - "SGD (weight decay) & 97.6 & 97.2 & 87.9 & 66.4 & 99.3 & 89.7\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "CLIP ViT-B/16\tFreeze only embed\t83.6 (nan)\t74.3 (nan)\t89.1 (nan)\t39.3 (nan)\t92.9 (nan)\t75.9\n", - "CLIP ViT-B/16\tSGD (no momentum)\t81.4 (nan)\t59.2 (nan)\t76.7 (nan)\t37.9 (nan)\t84.3 (nan)\t67.9\n", - "CLIP ViT-B/16\tSGD (weight decay)\t83.9 (nan)\t65.1 (nan)\t67.5 (nan)\t37.1 (nan)\t85.6 (nan)\t67.8\n", - "\n", - "\\begin{tabular}{cccccc|c}\n", - "\\toprule\n", - " & Liv-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & 62.5 (5.0) & 72.8 (18.0) & 37.3 (1.1) & 86.8 (1.1) & 67.9\\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & 71.9 (2.4) & 89.2 (1.1) & \\textbf{40.7 (0.3)} & 95.7 (0.4) & \\textbf{76.0}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\textbf{73.7 (1.1)} & 88.2 (0.7) & \\textbf{40.2 (0.7)} & 94.3 (0.3) & 75.9\\\\\n", - "Layer-wise & 81.9 (0.1) & 69.1 (3.4) & \\textbf{93.2 (0.3)} & \\textbf{40.5 (1.2)} & \\textbf{96.5 (0.4)} & \\textbf{76.2}\\\\\n", - "LAMB & 79.5 & 64.0 & 90.4 & 38.8 & 93.4 & 73.2\\\\\n", - "LARS & \\textbf{83.9} & 48.6 & 83.8 & 38.6 & 93.3 & 69.6\\\\\n", - "Freeze only embed & 83.6 & \\textbf{74.3} & 89.1 & 39.3 & 92.9 & 75.9\\\\\n", - "SGD (no momentum) & 81.4 & 59.2 & 76.7 & 37.9 & 84.3 & 67.9\\\\\n", - "SGD (weight decay) & \\textbf{83.9} & 65.1 & 67.5 & 37.1 & 85.6 & 67.8\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", - " 99.3802 , 90.03969333],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ],\n", - " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", - " 99.5262 , 92.22186 ],\n", - " [98. , 97.071 , 89.5373 , 66.3764 ,\n", - " 99.3236 , 90.06166 ],\n", - " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", - " 99.2938 , 89.6767 ]]]),\n", - " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", - " 86.79546667, 67.86795333],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ],\n", - " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", - " 92.941 , 75.85068 ],\n", - " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", - " 84.2829 , 67.88824 ],\n", - " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", - " 85.5645 , 67.8308 ]]]))" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", "models = ['clip_vit_b16']\n", + "# options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'freeze_bottom_2_optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", @@ -1524,6 +467,7 @@ "desired_epochs_list = [20, 20, 50, 5, 3]\n", "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", + "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", @@ -1531,7 +475,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", - "display_id_ood_tables(id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names)\n" + "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n" ] }, { diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index 0c0f074..b93c2a7 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 31, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 31, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -148,6 +148,15 @@ "# Get norms and gradients for different models" ] }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "model = clip_model.ClipModel('ViT-L/14')\n" + ] + }, { "cell_type": "code", "execution_count": 24, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 43662c0..9893c26 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -7,7 +7,7 @@ import subprocess PROJECT_NAME = 'finetuning' -WORKSHEET_NAME = 'nlp::ananyak-fine-tuning' +WORKSHEET_NAME = 'public::fine-tuning-distorts-iclr' DOCKER_IMAGE = 'ananya/unlabeled-extrapolation' @@ -29,10 +29,11 @@ def run_sbatch(cmd, job_name, args, exclude=None, deps=[]): slurm_cmd += f' {sbatch_script_path} ' slurm_cmd += f'"{cmd}"' print(slurm_cmd + '\n') - output = subprocess.check_output(shlex.split(slurm_cmd)).decode('utf8') - job_names = list(re.findall(r'\d+', output)) - assert(len(job_names) == 1) - return job_names[0] + if not(args.print_command): + output = subprocess.check_output(shlex.split(slurm_cmd)).decode('utf8') + job_names = list(re.findall(r'\d+', output)) + assert(len(job_names) == 1) + return job_names[0] def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=''): @@ -44,18 +45,17 @@ def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=' nlp_opt = '' cl_deps_str = ':' + ' :'.join(deps) bundles = ':unlabeled_extrapolation :scripts :configs ' + cl_deps_str + ' ' - makedirs = '"export PYTHONPATH="."; export PYTHONPATH="' + args.code_dir + '"; ' + makedirs = '"export PYTHONPATH=\'.\'; export PYTHONPATH=\'' + args.code_dir + '\'; ' codalab_cmd = prefix + nlp_opt + bundles + makedirs + cmd + '"' - print(codalab_cmd) - subprocess.run(shlex.split(codalab_cmd)) - return job_name + print(codalab_cmd + '\n') + if not(args.print_command): + subprocess.run(shlex.split(codalab_cmd)) + return job_name def run_job(cmd, job_name, args, deps=[]): if args.codalab: return run_codalab(cmd, job_name, args, deps=deps) - elif args.print_command: - print(cmd + '\n') else: return run_sbatch(cmd, job_name, args, deps=deps) @@ -103,7 +103,7 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, if not(run_saved): if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir - if args.amulet_option is not None: + elif args.amulet_option is not None: kwargs['root_prefix'] = '.' else: kwargs['root_prefix'] = root_prefix @@ -833,7 +833,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], config_rel_path='adaptation/cifar_stl.yaml', - bundles=['cifar_stl'], + bundles=['cifar10_dataset', 'stl10_dataset'], slurm_data_cmd=None, slurm_data_dir='/u/scr/ananya/', eval_config_rel_path='adaptation/cifar_stl_eval.yaml') diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 81b8f57..34f9d1a 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -533,6 +533,25 @@ def main(config, log_dir, checkpoints_dir): ] optimizer = utils.initialize( config['optimizer'], update_args={'params': param_groups}) + elif 'embed_layer_lr_multiplier' in config: + layers = [l for n, l in net.get_layers()] + embed_params = get_params(layers[:2]) + other_params = get_params(layers[2:]) + # count number of params, check that it's same as model. + net_count = count_parameters(net, trainable=True) + embed_count = sum([p.numel() for p in embed_params]) + other_count = sum([p.numel() for p in other_params]) + logging.info('total params: %d, opt params: %d', net_count, embed_count + other_count) + # Set different lr for embedding layer. + other_lr = config['optimizer']['args']['lr'] + embed_lr = config['embed_layer_lr_multiplier'] * other_lr + logging.info('Using lr %f for embed layer, %d params', embed_lr, len(embed_params)) + param_groups = [ + {'params': other_params}, + {'params': embed_params, 'lr': embed_lr} + ] + optimizer = utils.initialize( + config['optimizer'], update_args={'params': param_groups}) else: optimizer = utils.initialize( config['optimizer'], update_args={'params': net.parameters()}) From a112530bbb45b6c2177bc36a87dbdaea377e8660 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 8 Nov 2022 18:29:04 -0800 Subject: [PATCH 165/197] Add big table data. --- .gitignore | 1 - scripts/big_table_main.pkl | Bin 0 -> 4561 bytes 2 files changed, 1 deletion(-) create mode 100644 scripts/big_table_main.pkl diff --git a/.gitignore b/.gitignore index 000eee2..72f1f93 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ **amlt_configs/** .amltconfig **amlt_scripts** -**.pkl **tmp.tsv** **slurm_outputs** diff --git a/scripts/big_table_main.pkl b/scripts/big_table_main.pkl new file mode 100644 index 0000000000000000000000000000000000000000..205d60d396030d7023f002bb5a063bcad505f2b2 GIT binary patch literal 4561 zcmeH}dst0r8^${$9WWv)Mvi@yL6qaVcjeTsz1KdiwKN7vl<1r=4vkal+rv~lhX^qt zG?H@YGeo11D5oe=358G+In?*Ay_#`d-=E*#?LXSr)q3}OpXYvl_x-+628sFIb+jL~ zMPS6z;1v!&L7~15OCy$q`+J9mdaux^P3DIB`UC}rg@;D?gliHsYD4Wpjk;6d0%1vl zMy#_@oy7WL(`b#KzS?j>_=;d({%3j%oi#C=g%$d0-ANjWMB?5? zKH5KGop8*AGeuy?h7SzXPc|HQ-=M>UJw)MY!vU$Z#l zo4%z>EQd3(_a}%8mB6~{f*oNTR4b!&w+G5$ac`f?<{TEm7AGRMnK8I(96%3G`~;A22zi_zO&GlHcE<#jtG z#{Mj)kC)B?Qheu~SI!~$#^zfUR~YciuMcK%dF!Z1`*aQy`3F51EblsK*qU4p+cHf; zjxAEcHQm1=(cB## zq@PzK|1;D)l120(_S)z#s(3lm1(8Dvk0@dUV1;QhQmSQX@et(Zc}O>9Q(9{ z6@Hi0zP~wx%dMm^aJXGj*)^eyhcE|I25%4Li=A{87-rrz``{=kc8?)S)p}y=8|SIh zW8LxV_P`$Ni`#W84Ib86Soo5QNc3_9Qw4RgM5iUCpGLcL9a9i;5s94U-T4+KxHmLO%( z$roX(#lrmGiQs9Wc7IXHVUCy(f11S_8|OuCX=ES159V(UREQ#Wwb{*qOtEWrKLuoE zR;#?_3{JiKdS|(=QkbV54bsi!rAwqBGz4_1660m{xW2hvMTim2dsxr=5{dx7g7$%Q9~|mDo_d>B)98(LN4q>{5f_`&PQu zfcIi7Uzs|>wFU^}!5}`>`uivg(~x8TF1Kv=k1r?mt*-)EZT)f&hl-HcEj88O_OatZ z(kQXm^W7GOBaH&P3Gs!~rDz-QwK<|vjD)mxvYD$z;Nv6VF$Y7(?&BsA4tjkqe0{Z$ z6?_xVp=Yt%{kIuPB>Hal`RN=d_;Qj$Sl7m&)%8>TOSKA3M7}!0L5BWw^|0!?c=k*5Lk@lTV2oiwT#|T4_KgFdwGSq*IHMH!Jj@AmdZ-ZkEMSlm z(4}SHW2L|Y$x*$e&Q^OS(0J-ioaN*x=&;TOosU_2EqKDg*w1#!@=O+S^{c3{i`zNa z)~;Kg68TGsz*!{kj+26E1xU4r@*gwk!{_uG6>NE#meWE`^q>)Qix}-^4-8Ql9*Ea- zLASco$MwlRhe-_lML00g8y?-O>Raw;^B{_aCVHdSZIU~yi%-saZ>oelzmU|W&9~t8 zz7l8{@Dg;>T07VA3|@P=OsRdu zflMQJd>Dhs^LzV_OlCo7wJrB%FpkgXu`&?XDlZzy1i!qJ;KvgeUhQ#o1xdS@j5-eE zr%n%TA^FDg4@f@$y^r?Wjs-94$_JdFe~t<^UJE8ZE?}|nLydRJ4F=cpT+;o^Xjs@> zeMItA^T~4a6|$=K4-6W6Xr{Ji?komzo|wg=uxDE zz!?Yad~_HTh@E0YgafT#JXC1eM}ozP125mBU>1k@gDqJO9#76%4w7!IuKBd!t3fk_ zysqWo{PEI)BU!{Ze8ZoEjIKl#zy?b9nF02Q4f3%9ewM+(`WN{0#ZajbEq# zz1o-ymzAJZ&lK{o%T(~LyH{TLG*MaV2rHT88ES{f_IT5m@8I}LK|@u%HHL>ohF&)q zjgU4M(exkcsHI!&xyiX@)b{74SN1F}r~dFQPB*q|q?ps6AMI7gQWxtDk9O91N7-4P zb-V4=K(T#RHzse)psJ11?9xgbsbv4w^(I++s0S--+%7ii;a*NZkJzmzsFeJZU$PaA zlo{@5aGTP% roOHhO&K*jC Date: Tue, 8 Nov 2022 18:29:04 -0800 Subject: [PATCH 166/197] Add big table data. --- .gitignore | 1 - scripts/big_table_main.pkl | Bin 0 -> 4561 bytes 2 files changed, 1 deletion(-) create mode 100644 scripts/big_table_main.pkl diff --git a/.gitignore b/.gitignore index 000eee2..72f1f93 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ **amlt_configs/** .amltconfig **amlt_scripts** -**.pkl **tmp.tsv** **slurm_outputs** diff --git a/scripts/big_table_main.pkl b/scripts/big_table_main.pkl new file mode 100644 index 0000000000000000000000000000000000000000..205d60d396030d7023f002bb5a063bcad505f2b2 GIT binary patch literal 4561 zcmeH}dst0r8^${$9WWv)Mvi@yL6qaVcjeTsz1KdiwKN7vl<1r=4vkal+rv~lhX^qt zG?H@YGeo11D5oe=358G+In?*Ay_#`d-=E*#?LXSr)q3}OpXYvl_x-+628sFIb+jL~ zMPS6z;1v!&L7~15OCy$q`+J9mdaux^P3DIB`UC}rg@;D?gliHsYD4Wpjk;6d0%1vl zMy#_@oy7WL(`b#KzS?j>_=;d({%3j%oi#C=g%$d0-ANjWMB?5? zKH5KGop8*AGeuy?h7SzXPc|HQ-=M>UJw)MY!vU$Z#l zo4%z>EQd3(_a}%8mB6~{f*oNTR4b!&w+G5$ac`f?<{TEm7AGRMnK8I(96%3G`~;A22zi_zO&GlHcE<#jtG z#{Mj)kC)B?Qheu~SI!~$#^zfUR~YciuMcK%dF!Z1`*aQy`3F51EblsK*qU4p+cHf; zjxAEcHQm1=(cB## zq@PzK|1;D)l120(_S)z#s(3lm1(8Dvk0@dUV1;QhQmSQX@et(Zc}O>9Q(9{ z6@Hi0zP~wx%dMm^aJXGj*)^eyhcE|I25%4Li=A{87-rrz``{=kc8?)S)p}y=8|SIh zW8LxV_P`$Ni`#W84Ib86Soo5QNc3_9Qw4RgM5iUCpGLcL9a9i;5s94U-T4+KxHmLO%( z$roX(#lrmGiQs9Wc7IXHVUCy(f11S_8|OuCX=ES159V(UREQ#Wwb{*qOtEWrKLuoE zR;#?_3{JiKdS|(=QkbV54bsi!rAwqBGz4_1660m{xW2hvMTim2dsxr=5{dx7g7$%Q9~|mDo_d>B)98(LN4q>{5f_`&PQu zfcIi7Uzs|>wFU^}!5}`>`uivg(~x8TF1Kv=k1r?mt*-)EZT)f&hl-HcEj88O_OatZ z(kQXm^W7GOBaH&P3Gs!~rDz-QwK<|vjD)mxvYD$z;Nv6VF$Y7(?&BsA4tjkqe0{Z$ z6?_xVp=Yt%{kIuPB>Hal`RN=d_;Qj$Sl7m&)%8>TOSKA3M7}!0L5BWw^|0!?c=k*5Lk@lTV2oiwT#|T4_KgFdwGSq*IHMH!Jj@AmdZ-ZkEMSlm z(4}SHW2L|Y$x*$e&Q^OS(0J-ioaN*x=&;TOosU_2EqKDg*w1#!@=O+S^{c3{i`zNa z)~;Kg68TGsz*!{kj+26E1xU4r@*gwk!{_uG6>NE#meWE`^q>)Qix}-^4-8Ql9*Ea- zLASco$MwlRhe-_lML00g8y?-O>Raw;^B{_aCVHdSZIU~yi%-saZ>oelzmU|W&9~t8 zz7l8{@Dg;>T07VA3|@P=OsRdu zflMQJd>Dhs^LzV_OlCo7wJrB%FpkgXu`&?XDlZzy1i!qJ;KvgeUhQ#o1xdS@j5-eE zr%n%TA^FDg4@f@$y^r?Wjs-94$_JdFe~t<^UJE8ZE?}|nLydRJ4F=cpT+;o^Xjs@> zeMItA^T~4a6|$=K4-6W6Xr{Ji?komzo|wg=uxDE zz!?Yad~_HTh@E0YgafT#JXC1eM}ozP125mBU>1k@gDqJO9#76%4w7!IuKBd!t3fk_ zysqWo{PEI)BU!{Ze8ZoEjIKl#zy?b9nF02Q4f3%9ewM+(`WN{0#ZajbEq# zz1o-ymzAJZ&lK{o%T(~LyH{TLG*MaV2rHT88ES{f_IT5m@8I}LK|@u%HHL>ohF&)q zjgU4M(exkcsHI!&xyiX@)b{74SN1F}r~dFQPB*q|q?ps6AMI7gQWxtDk9O91N7-4P zb-V4=K(T#RHzse)psJ11?9xgbsbv4w^(I++s0S--+%7ii;a*NZkJzmzsFeJZU$PaA zlo{@5aGTP% roOHhO&K*jC Date: Thu, 10 Nov 2022 17:44:45 -0800 Subject: [PATCH 167/197] big table format change --- ...eeze-embed-paper-fine-tuning-results.ipynb | 378 +++++++++++++++++- 1 file changed, 356 insertions(+), 22 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 7d11f1c..ff7f763 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -129,15 +140,18 @@ "\n", " # Print latex table.\n", " if len(models) == 1:\n", - " num_columns = len(shortened_output_metrics_list) + 1\n", + " num_columns = 2*len(shortened_output_metrics_list) + 1\n", " else:\n", - " num_columns = len(shortened_output_metrics_list) + 2\n", + " num_columns = 2*len(shortened_output_metrics_list) + 2\n", " if is_last_avg:\n", - " print('\\\\begin{tabular}{' + ('c'*(num_columns-1)) + '|c}')\n", + " print('\\\\begin{tabular}{' + ('c'*(num_columns-2)) + '|cc}')\n", " else:\n", " print('\\\\begin{tabular}{' + ('c'*num_columns) + '}')\n", " print('\\\\toprule')\n", - " first_line = ' & ' + ' & '.join(shortened_output_metrics_list) + '\\\\\\\\'\n", + " first_line = '' \n", + " for oml in shortened_output_metrics_list:\n", + " first_line += ' & \\multicolumn{2}{c}{' + oml + '} '\n", + " first_line += '\\\\\\\\'\n", " if len(models) > 1:\n", " first_line = ' & ' + first_line\n", " print(first_line)\n", @@ -164,6 +178,16 @@ " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", " if is_bold[option_idx][idx] and bold_best:\n", " line += '}'\n", + " if option_idx:# if not sgd\n", + " sgd_val = table[model_idx][0][idx]\n", + " diff = val-sgd_val\n", + " if diff>=0:\n", + " line += ' & \\hspace{{-1em}}{{\\hgreen{{(+{:.1f})}}}}'.format(diff)\n", + " else:\n", + " line += ' & \\hspace{{-1em}}{{\\hred{{({:.1f})}}}}'.format(diff)\n", + " else:\n", + " line += ' & '\n", + "\n", " line += '\\\\\\\\'\n", " print(line)\n", " print('\\\\bottomrule')\n", @@ -204,23 +228,149 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.0)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{91.7} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "DINO ViT-B/16 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.9} & \\hspace{-1em}{\\hred{(-0.0)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\hred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "BiT ResNet-50 & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.5)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.4)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.2)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.3)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.8)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.6)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.1)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "Sup ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.9)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.6)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-0.9)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.4)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "BiT ResNet-50 & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.4)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "BiT ResNet-101 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.8)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101', ]\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)']\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", - "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", @@ -370,25 +520,183 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "ConvNext-Base\tAdamW (freeze-embed)\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8\\hphantom{ (+0.0)} & 97.2\\hphantom{ (+0.0)} & 88.8\\hphantom{ (+0.0)} & 67.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.0\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2 {\\hgreen{(+0.3)}}} & \\textbf{97.8 {\\hgreen{(+0.6)}}} & \\textbf{94.9 {\\hgreen{(+6.1)}}} & \\textbf{70.0 {\\hgreen{(+3.0)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.1 {\\hgreen{(+2.0)}}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{98.6\\hphantom{ (+0.0)}} & \\textbf{99.1\\hphantom{ (+0.0)}} & \\textbf{91.7\\hphantom{ (+0.0)}} & 64.1\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.6\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.2 {\\hgreen{(+0.1)}}} & 91.5 {\\hred{(-0.3)}} & 65.0 {\\hgreen{(+0.9)}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & 90.8 {\\hgreen{(+0.2)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.4\\hphantom{ (+0.0)}} & 97.0\\hphantom{ (+0.0)} & 88.2\\hphantom{ (+0.0)} & 62.4\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 89.1\\hphantom{ (+0.0)}\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.0)}}} & 97.5 {\\hgreen{(+0.5)}} & 89.0 {\\hgreen{(+0.8)}} & 63.5 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & 89.6 {\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & 97.4\\hphantom{ (+0.0)} & \\textbf{98.4\\hphantom{ (+0.0)}} & \\textbf{89.3\\hphantom{ (+0.0)}} & 64.6\\hphantom{ (+0.0)} & \\textbf{99.5\\hphantom{ (+0.0)}} & \\textbf{89.8\\hphantom{ (+0.0)}}\\\\\n", + "DINO ViT-B/16 & AdamW & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6 {\\hgreen{(+0.2)}}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & 64.8 {\\hgreen{(+0.2)}} & \\textbf{99.5 {\\hgreen{(+0.0)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.3\\hphantom{ (+0.0)}} & \\textbf{98.9\\hphantom{ (+0.0)}} & \\textbf{92.0\\hphantom{ (+0.0)}} & 66.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & \\textbf{90.9\\hphantom{ (+0.0)}}\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & \\textbf{98.8 {\\hred{(-0.1)}}} & 91.5 {\\hred{(-0.5)}} & 65.9 {\\hred{(-0.2)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{90.8 {\\hred{(-0.1)}}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{98.7\\hphantom{ (+0.0)}} & 99.0\\hphantom{ (+0.0)} & 94.8\\hphantom{ (+0.0)} & 66.3\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 91.6\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-50 & AdamW & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.4 {\\hgreen{(+0.4)}}} & \\textbf{95.1 {\\hgreen{(+0.3)}}} & 67.4 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.0 {\\hgreen{(+0.4)}}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 98.4\\hphantom{ (+0.0)} & 97.3\\hphantom{ (+0.0)} & 84.3\\hphantom{ (+0.0)} & 69.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 89.7\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.3)}}} & \\textbf{98.9 {\\hgreen{(+1.6)}}} & \\textbf{97.1 {\\hgreen{(+12.8)}}} & \\textbf{74.5 {\\hgreen{(+5.5)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.1)}}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "ConvNext-Base\tAdamW (freeze-embed)\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0\\hphantom{ (+0.0)} & 62.5\\hphantom{ (+0.0)} & 72.8\\hphantom{ (+0.0)} & 37.3\\hphantom{ (+0.0)} & 86.8\\hphantom{ (+0.0)} & 67.9\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2 {\\hgreen{(+3.2)}}} & \\textbf{73.7 {\\hgreen{(+11.3)}}} & 88.2 {\\hgreen{(+15.4)}} & 40.2 {\\hgreen{(+2.8)}} & 94.3 {\\hgreen{(+7.5)}} & \\textbf{75.9 {\\hgreen{(+8.1)}}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{89.5\\hphantom{ (+0.0)}} & 77.4\\hphantom{ (+0.0)} & \\textbf{86.3\\hphantom{ (+0.0)}} & 33.5\\hphantom{ (+0.0)} & 92.6\\hphantom{ (+0.0)} & 75.8\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 {\\hred{(-1.5)}} & \\textbf{82.4 {\\hgreen{(+5.0)}}} & \\textbf{86.3 {\\hgreen{(+0.1)}}} & 34.4 {\\hgreen{(+1.0)}} & \\textbf{93.7 {\\hgreen{(+1.1)}}} & \\textbf{77.0 {\\hgreen{(+1.1)}}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{88.2\\hphantom{ (+0.0)}} & 56.1\\hphantom{ (+0.0)} & 76.0\\hphantom{ (+0.0)} & 33.6\\hphantom{ (+0.0)} & 86.9\\hphantom{ (+0.0)} & 68.2\\hphantom{ (+0.0)}\\\\\n", + "Sup ViT-B/16 & AdamW & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 {\\hred{(-1.5)}} & \\textbf{67.9 {\\hgreen{(+11.8)}}} & \\textbf{78.4 {\\hgreen{(+2.3)}}} & \\textbf{35.9 {\\hgreen{(+2.3)}}} & 90.6 {\\hgreen{(+3.7)}} & \\textbf{71.9 {\\hgreen{(+3.7)}}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{84.3\\hphantom{ (+0.0)}} & \\textbf{76.5\\hphantom{ (+0.0)}} & 80.0\\hphantom{ (+0.0)} & 34.1\\hphantom{ (+0.0)} & 90.4\\hphantom{ (+0.0)} & 73.1\\hphantom{ (+0.0)}\\\\\n", + "DINO ViT-B/16 & AdamW & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 {\\hred{(-0.2)}} & 75.5 {\\hred{(-0.9)}} & 82.3 {\\hgreen{(+2.3)}} & \\textbf{35.0 {\\hgreen{(+0.9)}}} & \\textbf{95.2 {\\hgreen{(+4.8)}}} & \\textbf{74.4 {\\hgreen{(+1.4)}}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & 82.8\\hphantom{ (+0.0)} & 76.9\\hphantom{ (+0.0)} & \\textbf{86.2\\hphantom{ (+0.0)}} & \\textbf{38.0\\hphantom{ (+0.0)}} & 89.3\\hphantom{ (+0.0)} & 74.6\\hphantom{ (+0.0)}\\\\\n", + "ConvNext-Base & AdamW & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1 {\\hgreen{(+0.3)}}} & 77.3 {\\hgreen{(+0.3)}} & 86.0 {\\hred{(-0.2)}} & 36.0 {\\hred{(-2.0)}} & \\textbf{95.5 {\\hgreen{(+6.2)}}} & \\textbf{75.6 {\\hgreen{(+0.9)}}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{94.0\\hphantom{ (+0.0)}} & 80.2\\hphantom{ (+0.0)} & 89.8\\hphantom{ (+0.0)} & \\textbf{39.7\\hphantom{ (+0.0)}} & 83.0\\hphantom{ (+0.0)} & 77.3\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-50 & AdamW & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 92.6 {\\hred{(-1.4)}} & 86.9 {\\hgreen{(+6.7)}} & \\textbf{91.2 {\\hgreen{(+1.5)}}} & 38.2 {\\hred{(-1.5)}} & 88.1 {\\hgreen{(+5.1)}} & \\textbf{79.4 {\\hgreen{(+2.1)}}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 84.2\\hphantom{ (+0.0)} & 65.0\\hphantom{ (+0.0)} & 60.8\\hphantom{ (+0.0)} & 41.0\\hphantom{ (+0.0)} & 83.2\\hphantom{ (+0.0)} & 66.8\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-101 & AdamW & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5 {\\hgreen{(+6.2)}}} & 84.7 {\\hgreen{(+19.8)}} & 93.1 {\\hgreen{(+32.3)}} & \\textbf{49.9 {\\hgreen{(+8.9)}}} & \\textbf{96.5 {\\hgreen{(+13.3)}}} & \\textbf{83.0 {\\hgreen{(+16.1)}}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "\n", + "mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", + "std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'AdamW (freeze-embed)']\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", - "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", @@ -396,6 +704,27 @@ "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7, 5, 13)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", + "mean_table.shape" + ] + }, { "cell_type": "code", "execution_count": null, @@ -488,7 +817,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.9.12 ('torch')", "language": "python", "name": "python3" }, @@ -502,7 +831,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.12" + }, + "vscode": { + "interpreter": { + "hash": "e20a982d9929f39844afb80a108913d82415026ed53cd5cf5e2e4d27193773a2" + } } }, "nbformat": 4, From 4668c0c4032e389ad38c8d91f131ab507935b784 Mon Sep 17 00:00:00 2001 From: suriya Date: Thu, 10 Nov 2022 17:44:45 -0800 Subject: [PATCH 168/197] big table format change --- ...eeze-embed-paper-fine-tuning-results.ipynb | 378 +++++++++++++++++- 1 file changed, 356 insertions(+), 22 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 7d11f1c..ff7f763 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -129,15 +140,18 @@ "\n", " # Print latex table.\n", " if len(models) == 1:\n", - " num_columns = len(shortened_output_metrics_list) + 1\n", + " num_columns = 2*len(shortened_output_metrics_list) + 1\n", " else:\n", - " num_columns = len(shortened_output_metrics_list) + 2\n", + " num_columns = 2*len(shortened_output_metrics_list) + 2\n", " if is_last_avg:\n", - " print('\\\\begin{tabular}{' + ('c'*(num_columns-1)) + '|c}')\n", + " print('\\\\begin{tabular}{' + ('c'*(num_columns-2)) + '|cc}')\n", " else:\n", " print('\\\\begin{tabular}{' + ('c'*num_columns) + '}')\n", " print('\\\\toprule')\n", - " first_line = ' & ' + ' & '.join(shortened_output_metrics_list) + '\\\\\\\\'\n", + " first_line = '' \n", + " for oml in shortened_output_metrics_list:\n", + " first_line += ' & \\multicolumn{2}{c}{' + oml + '} '\n", + " first_line += '\\\\\\\\'\n", " if len(models) > 1:\n", " first_line = ' & ' + first_line\n", " print(first_line)\n", @@ -164,6 +178,16 @@ " line += ' ({:.1f})'.format(std_err_table[model_idx][option_idx][idx])\n", " if is_bold[option_idx][idx] and bold_best:\n", " line += '}'\n", + " if option_idx:# if not sgd\n", + " sgd_val = table[model_idx][0][idx]\n", + " diff = val-sgd_val\n", + " if diff>=0:\n", + " line += ' & \\hspace{{-1em}}{{\\hgreen{{(+{:.1f})}}}}'.format(diff)\n", + " else:\n", + " line += ' & \\hspace{{-1em}}{{\\hred{{({:.1f})}}}}'.format(diff)\n", + " else:\n", + " line += ' & '\n", + "\n", " line += '\\\\\\\\'\n", " print(line)\n", " print('\\\\bottomrule')\n", @@ -204,23 +228,149 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.0)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{91.7} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "DINO ViT-B/16 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.9} & \\hspace{-1em}{\\hred{(-0.0)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\hred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "BiT ResNet-50 & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.5)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.4)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.2)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.3)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.8)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.6)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.1)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "Sup ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.9)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.6)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-0.9)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.4)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "BiT ResNet-50 & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.4)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "BiT ResNet-101 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.8)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)']\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101', ]\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)']\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", - "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", @@ -370,25 +520,183 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "ConvNext-Base\tAdamW (freeze-embed)\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8\\hphantom{ (+0.0)} & 97.2\\hphantom{ (+0.0)} & 88.8\\hphantom{ (+0.0)} & 67.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.0\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2 {\\hgreen{(+0.3)}}} & \\textbf{97.8 {\\hgreen{(+0.6)}}} & \\textbf{94.9 {\\hgreen{(+6.1)}}} & \\textbf{70.0 {\\hgreen{(+3.0)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.1 {\\hgreen{(+2.0)}}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{98.6\\hphantom{ (+0.0)}} & \\textbf{99.1\\hphantom{ (+0.0)}} & \\textbf{91.7\\hphantom{ (+0.0)}} & 64.1\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.6\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.2 {\\hgreen{(+0.1)}}} & 91.5 {\\hred{(-0.3)}} & 65.0 {\\hgreen{(+0.9)}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & 90.8 {\\hgreen{(+0.2)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.4\\hphantom{ (+0.0)}} & 97.0\\hphantom{ (+0.0)} & 88.2\\hphantom{ (+0.0)} & 62.4\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 89.1\\hphantom{ (+0.0)}\\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.0)}}} & 97.5 {\\hgreen{(+0.5)}} & 89.0 {\\hgreen{(+0.8)}} & 63.5 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & 89.6 {\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & 97.4\\hphantom{ (+0.0)} & \\textbf{98.4\\hphantom{ (+0.0)}} & \\textbf{89.3\\hphantom{ (+0.0)}} & 64.6\\hphantom{ (+0.0)} & \\textbf{99.5\\hphantom{ (+0.0)}} & \\textbf{89.8\\hphantom{ (+0.0)}}\\\\\n", + "DINO ViT-B/16 & AdamW & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6 {\\hgreen{(+0.2)}}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & 64.8 {\\hgreen{(+0.2)}} & \\textbf{99.5 {\\hgreen{(+0.0)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.3\\hphantom{ (+0.0)}} & \\textbf{98.9\\hphantom{ (+0.0)}} & \\textbf{92.0\\hphantom{ (+0.0)}} & 66.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & \\textbf{90.9\\hphantom{ (+0.0)}}\\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & \\textbf{98.8 {\\hred{(-0.1)}}} & 91.5 {\\hred{(-0.5)}} & 65.9 {\\hred{(-0.2)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{90.8 {\\hred{(-0.1)}}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{98.7\\hphantom{ (+0.0)}} & 99.0\\hphantom{ (+0.0)} & 94.8\\hphantom{ (+0.0)} & 66.3\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 91.6\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-50 & AdamW & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.4 {\\hgreen{(+0.4)}}} & \\textbf{95.1 {\\hgreen{(+0.3)}}} & 67.4 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.0 {\\hgreen{(+0.4)}}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 98.4\\hphantom{ (+0.0)} & 97.3\\hphantom{ (+0.0)} & 84.3\\hphantom{ (+0.0)} & 69.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 89.7\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.3)}}} & \\textbf{98.9 {\\hgreen{(+1.6)}}} & \\textbf{97.1 {\\hgreen{(+12.8)}}} & \\textbf{74.5 {\\hgreen{(+5.5)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.1)}}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "ConvNext-Base\tAdamW (freeze-embed)\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "\n", + "\\begin{tabular}{ccccccc|c}\n", + "\\toprule\n", + " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0\\hphantom{ (+0.0)} & 62.5\\hphantom{ (+0.0)} & 72.8\\hphantom{ (+0.0)} & 37.3\\hphantom{ (+0.0)} & 86.8\\hphantom{ (+0.0)} & 67.9\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2 {\\hgreen{(+3.2)}}} & \\textbf{73.7 {\\hgreen{(+11.3)}}} & 88.2 {\\hgreen{(+15.4)}} & 40.2 {\\hgreen{(+2.8)}} & 94.3 {\\hgreen{(+7.5)}} & \\textbf{75.9 {\\hgreen{(+8.1)}}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & \\textbf{89.5\\hphantom{ (+0.0)}} & 77.4\\hphantom{ (+0.0)} & \\textbf{86.3\\hphantom{ (+0.0)}} & 33.5\\hphantom{ (+0.0)} & 92.6\\hphantom{ (+0.0)} & 75.8\\hphantom{ (+0.0)}\\\\\n", + "CLIP ViT-L/14 & AdamW & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 {\\hred{(-1.5)}} & \\textbf{82.4 {\\hgreen{(+5.0)}}} & \\textbf{86.3 {\\hgreen{(+0.1)}}} & 34.4 {\\hgreen{(+1.0)}} & \\textbf{93.7 {\\hgreen{(+1.1)}}} & \\textbf{77.0 {\\hgreen{(+1.1)}}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{88.2\\hphantom{ (+0.0)}} & 56.1\\hphantom{ (+0.0)} & 76.0\\hphantom{ (+0.0)} & 33.6\\hphantom{ (+0.0)} & 86.9\\hphantom{ (+0.0)} & 68.2\\hphantom{ (+0.0)}\\\\\n", + "Sup ViT-B/16 & AdamW & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 {\\hred{(-1.5)}} & \\textbf{67.9 {\\hgreen{(+11.8)}}} & \\textbf{78.4 {\\hgreen{(+2.3)}}} & \\textbf{35.9 {\\hgreen{(+2.3)}}} & 90.6 {\\hgreen{(+3.7)}} & \\textbf{71.9 {\\hgreen{(+3.7)}}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{84.3\\hphantom{ (+0.0)}} & \\textbf{76.5\\hphantom{ (+0.0)}} & 80.0\\hphantom{ (+0.0)} & 34.1\\hphantom{ (+0.0)} & 90.4\\hphantom{ (+0.0)} & 73.1\\hphantom{ (+0.0)}\\\\\n", + "DINO ViT-B/16 & AdamW & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 {\\hred{(-0.2)}} & 75.5 {\\hred{(-0.9)}} & 82.3 {\\hgreen{(+2.3)}} & \\textbf{35.0 {\\hgreen{(+0.9)}}} & \\textbf{95.2 {\\hgreen{(+4.8)}}} & \\textbf{74.4 {\\hgreen{(+1.4)}}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & 82.8\\hphantom{ (+0.0)} & 76.9\\hphantom{ (+0.0)} & \\textbf{86.2\\hphantom{ (+0.0)}} & \\textbf{38.0\\hphantom{ (+0.0)}} & 89.3\\hphantom{ (+0.0)} & 74.6\\hphantom{ (+0.0)}\\\\\n", + "ConvNext-Base & AdamW & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1 {\\hgreen{(+0.3)}}} & 77.3 {\\hgreen{(+0.3)}} & 86.0 {\\hred{(-0.2)}} & 36.0 {\\hred{(-2.0)}} & \\textbf{95.5 {\\hgreen{(+6.2)}}} & \\textbf{75.6 {\\hgreen{(+0.9)}}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{94.0\\hphantom{ (+0.0)}} & 80.2\\hphantom{ (+0.0)} & 89.8\\hphantom{ (+0.0)} & \\textbf{39.7\\hphantom{ (+0.0)}} & 83.0\\hphantom{ (+0.0)} & 77.3\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-50 & AdamW & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 92.6 {\\hred{(-1.4)}} & 86.9 {\\hgreen{(+6.7)}} & \\textbf{91.2 {\\hgreen{(+1.5)}}} & 38.2 {\\hred{(-1.5)}} & 88.1 {\\hgreen{(+5.1)}} & \\textbf{79.4 {\\hgreen{(+2.1)}}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 84.2\\hphantom{ (+0.0)} & 65.0\\hphantom{ (+0.0)} & 60.8\\hphantom{ (+0.0)} & 41.0\\hphantom{ (+0.0)} & 83.2\\hphantom{ (+0.0)} & 66.8\\hphantom{ (+0.0)}\\\\\n", + "BiT ResNet-101 & AdamW & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5 {\\hgreen{(+6.2)}}} & 84.7 {\\hgreen{(+19.8)}} & 93.1 {\\hgreen{(+32.3)}} & \\textbf{49.9 {\\hgreen{(+8.9)}}} & \\textbf{96.5 {\\hgreen{(+13.3)}}} & \\textbf{83.0 {\\hgreen{(+16.1)}}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", - "models = ['clip_vit_b16', 'timm_vit_b16_in21k', 'dino_vit_b16', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k', 'convnext_vit_b', 'clip_vit_l14']\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_opt_torch.optim.AdamW_']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", - "shorted_model_names = ['CLIP ViT-B/16', 'Sup ViT-B/16', 'DINO ViT-B/16', 'BIT ResNet-50', 'BIT ResNet-101', 'ConvNext-Base', 'CLIP ViT-L/14']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-2)', 'AdamW (Freeze-2)']\n", + "\n", + "mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", + "std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'AdamW (freeze-embed)']\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", - "shortened_dataset_names = ['Liv-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", @@ -396,6 +704,27 @@ "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7, 5, 13)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", + "mean_table.shape" + ] + }, { "cell_type": "code", "execution_count": null, @@ -488,7 +817,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.9.12 ('torch')", "language": "python", "name": "python3" }, @@ -502,7 +831,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.12" + }, + "vscode": { + "interpreter": { + "hash": "e20a982d9929f39844afb80a108913d82415026ed53cd5cf5e2e4d27193773a2" + } } }, "nbformat": 4, From dca4ca0ec02ab50ec1a4724c45e794009a533d57 Mon Sep 17 00:00:00 2001 From: suriya Date: Thu, 10 Nov 2022 20:03:21 -0800 Subject: [PATCH 169/197] made non significant gain/loss lighter --- ...eeze-embed-paper-fine-tuning-results.ipynb | 190 ++++++++++-------- 1 file changed, 105 insertions(+), 85 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index ff7f763..e98713f 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -136,7 +136,7 @@ " new_table.append(new_model_table)\n", " return np.array(new_table)\n", " \n", - "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True):\n", + "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True, light_thresh=0.2):\n", "\n", " # Print latex table.\n", " if len(models) == 1:\n", @@ -180,11 +180,18 @@ " line += '}'\n", " if option_idx:# if not sgd\n", " sgd_val = table[model_idx][0][idx]\n", - " diff = val-sgd_val\n", - " if diff>=0:\n", + " diff_fp = val - sgd_val\n", + " diff = round(val,1)-round(sgd_val,1)\n", + " if diff_fp>=light_thresh:\n", " line += ' & \\hspace{{-1em}}{{\\hgreen{{(+{:.1f})}}}}'.format(diff)\n", + " elif diff_fp>=0.0:\n", + " line += ' & \\hspace{{-1em}}{{\\lgreen{{(+{:.1f})}}}}'.format(diff)\n", + " elif diff>=-1*light_thresh:\n", + " line += ' & \\hspace{{-1em}}{{\\lred{{(-{:.1f})}}}}'.format(abs(diff))\n", " else:\n", - " line += ' & \\hspace{{-1em}}{{\\hred{{({:.1f})}}}}'.format(diff)\n", + " line += ' & \\hspace{{-1em}}{{\\hred{{(-{:.1f})}}}}'.format(abs(diff))\n", + " # else:\n", + " # line += ' & '\n", " else:\n", " line += ' & '\n", "\n", @@ -228,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 70, "metadata": {}, "outputs": [ { @@ -242,56 +249,56 @@ "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", "\n", "\\begin{tabular}{cccccccccccc|cc}\n", "\\toprule\n", " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", "\\midrule\n", "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.0)}}\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{91.7} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", "\\midrule\n", - "DINO ViT-B/16 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "DINO ViT-B/16 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.9} & \\hspace{-1em}{\\hred{(-0.0)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\hred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "BiT ResNet-50 & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", "\\midrule\n", - "BiT ResNet-101 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.5)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.4)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\n", @@ -301,56 +308,56 @@ "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", "\n", "\\begin{tabular}{cccccccccccc|cc}\n", "\\toprule\n", " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", "\\midrule\n", "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.2)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.3)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.8)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.6)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.1)}}\\\\\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "Sup ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.9)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.6)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-0.9)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.4)}}\\\\\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", "\\midrule\n", - "ConvNext-Base & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "BiT ResNet-50 & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.4)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", "\\midrule\n", - "BiT ResNet-101 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "BiT ResNet-101 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.8)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.1)}}\\\\\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", "\\bottomrule\n", "\\end{tabular}\n" ] @@ -375,7 +382,11 @@ "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", "\n", - "mean_table, std_table = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "# Rearranging mean table\n", + "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", @@ -391,9 +402,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.25925333 91.46286571 91.27799905]\n", + "[71.9667419 76.03873524 76.73786476]\n" + ] + } + ], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", From 115dcbe13260510aa45031daf823a03b5c93d0a3 Mon Sep 17 00:00:00 2001 From: suriya Date: Thu, 10 Nov 2022 20:03:21 -0800 Subject: [PATCH 170/197] made non significant gain/loss lighter --- ...eeze-embed-paper-fine-tuning-results.ipynb | 190 ++++++++++-------- 1 file changed, 105 insertions(+), 85 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index ff7f763..e98713f 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -136,7 +136,7 @@ " new_table.append(new_model_table)\n", " return np.array(new_table)\n", " \n", - "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True):\n", + "def display_latex_table(models, options, shortened_output_metrics_list, table, std_err_table=None, bold_best=True, is_last_avg=True, light_thresh=0.2):\n", "\n", " # Print latex table.\n", " if len(models) == 1:\n", @@ -180,11 +180,18 @@ " line += '}'\n", " if option_idx:# if not sgd\n", " sgd_val = table[model_idx][0][idx]\n", - " diff = val-sgd_val\n", - " if diff>=0:\n", + " diff_fp = val - sgd_val\n", + " diff = round(val,1)-round(sgd_val,1)\n", + " if diff_fp>=light_thresh:\n", " line += ' & \\hspace{{-1em}}{{\\hgreen{{(+{:.1f})}}}}'.format(diff)\n", + " elif diff_fp>=0.0:\n", + " line += ' & \\hspace{{-1em}}{{\\lgreen{{(+{:.1f})}}}}'.format(diff)\n", + " elif diff>=-1*light_thresh:\n", + " line += ' & \\hspace{{-1em}}{{\\lred{{(-{:.1f})}}}}'.format(abs(diff))\n", " else:\n", - " line += ' & \\hspace{{-1em}}{{\\hred{{({:.1f})}}}}'.format(diff)\n", + " line += ' & \\hspace{{-1em}}{{\\hred{{(-{:.1f})}}}}'.format(abs(diff))\n", + " # else:\n", + " # line += ' & '\n", " else:\n", " line += ' & '\n", "\n", @@ -228,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 70, "metadata": {}, "outputs": [ { @@ -242,56 +249,56 @@ "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", "\n", "\\begin{tabular}{cccccccccccc|cc}\n", "\\toprule\n", " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", "\\midrule\n", "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.0)}}\\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{91.7} & \\hspace{-1em}{\\hred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", "\\midrule\n", - "DINO ViT-B/16 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "DINO ViT-B/16 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.2} & \\hspace{-1em}{\\hred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\hgreen{(+0.1)}}\\\\\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.9} & \\hspace{-1em}{\\hred{(-0.0)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\hred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "BiT ResNet-50 & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\hred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", "\\midrule\n", - "BiT ResNet-101 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.5)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.4)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\n", @@ -301,56 +308,56 @@ "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", "\n", "\\begin{tabular}{cccccccccccc|cc}\n", "\\toprule\n", " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", "\\midrule\n", "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.2)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.3)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.8)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.6)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\hgreen{(+0.1)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.1)}}\\\\\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "Sup ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.9)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.6)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-0.9)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.4)}}\\\\\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", "\\midrule\n", - "ConvNext-Base & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\hgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\hred{(-0.1)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "BiT ResNet-50 & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.4)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", "\\midrule\n", - "BiT ResNet-101 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "BiT ResNet-101 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.8)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.1)}}\\\\\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", "\\bottomrule\n", "\\end{tabular}\n" ] @@ -375,7 +382,11 @@ "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", "\n", - "mean_table, std_table = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "# Rearranging mean table\n", + "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", @@ -391,9 +402,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.25925333 91.46286571 91.27799905]\n", + "[71.9667419 76.03873524 76.73786476]\n" + ] + } + ], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", From 84566ae43e37689512a50eeb35e2f4df7e2b1176 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 01:48:13 -0800 Subject: [PATCH 171/197] Change name. --- ...eeze-embed-paper-fine-tuning-results.ipynb | 113 ++++++++++++++++-- 1 file changed, 103 insertions(+), 10 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index e98713f..c8de9e9 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,16 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -235,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -429,9 +429,102 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", + "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -817,7 +910,7 @@ "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", @@ -837,7 +930,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.12 ('torch')", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -851,7 +944,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.5" }, "vscode": { "interpreter": { From 0380e11d0f3f4f2f813985059ed54c5c051ec563 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 01:48:13 -0800 Subject: [PATCH 172/197] Change name. --- ...eeze-embed-paper-fine-tuning-results.ipynb | 113 ++++++++++++++++-- 1 file changed, 103 insertions(+), 10 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index e98713f..c8de9e9 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,16 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -235,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -429,9 +429,102 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", + "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -817,7 +910,7 @@ "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", @@ -837,7 +930,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.12 ('torch')", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -851,7 +944,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.5" }, "vscode": { "interpreter": { From 248f4399315d2da49d7b5f9dca1d75c9e0cb32de Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 01:48:41 -0800 Subject: [PATCH 173/197] Clear outputs. --- ...nalyze_dataset_stats_model_gradients.ipynb | 66 +-- ...eeze-embed-paper-fine-tuning-results.ipynb | 428 +----------------- 2 files changed, 51 insertions(+), 443 deletions(-) diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index a0f485e..f837b93 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -89,7 +89,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "['grad_2', 'grad_1']\n" + "['grad_1', 'grad_2']\n" ] } ], @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -113,9 +113,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -132,9 +132,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -151,9 +151,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -173,6 +173,11 @@ " df = df[filtered_keys]\n", " return df.to_dict(orient='records')[0]\n", "\n", + "def filter_df_get_param_normalized_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", "def filter_df_get_normalized_grad(df):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", @@ -186,38 +191,43 @@ "# def filter_df_get_norm_grad(df):\n", "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad' in s]\n", "# print(filtered_keys)\n", - "# return df[filtered_keys] \n", + "# return df[filtered_keys] \n", + "\n", + "# Get a sorted list of outputs, \n", "\n", "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", " dataset_stats = {}\n", " for dataset in datasets:\n", " print(dataset)\n", - " figure(figsize=(8, 4), dpi=80)\n", + " figure(figsize=(8, 4), dpi=300)\n", " for model_idx, model in enumerate(models):\n", " dir_path = get_dir_path(dataset, model)\n", " config_path = get_config_path(dir_path)\n", " stats_path = get_stats_path(dir_path)\n", " with open(config_path, 'r') as f:\n", " config = json.load(f)\n", - " train_data = utils.init_dataset(config['train_dataset'])\n", - " if model_idx == 1:\n", - " random_images = get_random_images(train_data,n=10)\n", - " dataset_stats[dataset] = {\n", - " 'mean': np.mean(random_images),\n", - " 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", - " 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", - " }\n", + "# train_data = utils.init_dataset(config['train_dataset'])\n", + "# if model_idx == 1:\n", + "# random_images = get_random_images(train_data,n=10)\n", + "# dataset_stats[dataset] = {\n", + "# 'mean': np.mean(random_images),\n", + "# 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", + "# 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", + "# }\n", " df = pd.read_csv(stats_path, sep='\\t')\n", " d = filter_df(df)\n", + "# print(model)\n", + "# print(list(d.keys()))\n", + "# print(sorted([(-v, k) for k, v in list(d.items())]))\n", " values = list(d.values())\n", " if model_idx == 1:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers')\n", - " plt.scatter([model_idx], values[-1], c='green', label='last layer')\n", - " plt.scatter([model_idx], values[0], c='red', label='first layer')\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers', marker='o')\n", + " plt.scatter([model_idx], values[-1], c='green', label='head layer', marker='^')\n", + " plt.scatter([model_idx], values[0], c='red', label='embedding layer', marker='s')\n", " else:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black')\n", - " plt.scatter([model_idx], values[-1], c='green')\n", - " plt.scatter([model_idx], values[0], c='red')\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", + " plt.scatter([model_idx], values[-1], c='green', marker='^')\n", + " plt.scatter([model_idx], values[0], c='red', marker='s')\n", " my_xticks = ['John','Arnold','Mavis','Matt']\n", " plt.legend()\n", " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", @@ -228,11 +238,11 @@ "# print(df['train/grad_patch_embed'])\n", "# print(df[filtered_keys])\n", "# print(df[compute_keys(df)])\n", - " return dataset_stats\n", + "# return dataset_stats\n", "\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad)\n" ] }, { diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index c8de9e9..00a5619 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,20 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -27,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -235,134 +224,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -402,18 +266,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.25925333 91.46286571 91.27799905]\n", - "[71.9667419 76.03873524 76.73786476]\n" - ] - } - ], + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -429,102 +284,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "\n", - "\\begin{tabular}{ccccccccccc|cc}\n", - "\\toprule\n", - " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", - "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", - "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", - "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "\n", - "\\begin{tabular}{ccccccccccc|cc}\n", - "\\toprule\n", - " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", - "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", - "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", - " 99.3802 , 90.03969333],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ]]]),\n", - " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", - " 86.79546667, 67.86795333],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ]]]))" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -633,162 +395,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "ConvNext-Base\tAdamW (freeze-embed)\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8\\hphantom{ (+0.0)} & 97.2\\hphantom{ (+0.0)} & 88.8\\hphantom{ (+0.0)} & 67.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.0\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2 {\\hgreen{(+0.3)}}} & \\textbf{97.8 {\\hgreen{(+0.6)}}} & \\textbf{94.9 {\\hgreen{(+6.1)}}} & \\textbf{70.0 {\\hgreen{(+3.0)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.1 {\\hgreen{(+2.0)}}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{98.6\\hphantom{ (+0.0)}} & \\textbf{99.1\\hphantom{ (+0.0)}} & \\textbf{91.7\\hphantom{ (+0.0)}} & 64.1\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.6\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.2 {\\hgreen{(+0.1)}}} & 91.5 {\\hred{(-0.3)}} & 65.0 {\\hgreen{(+0.9)}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & 90.8 {\\hgreen{(+0.2)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.4\\hphantom{ (+0.0)}} & 97.0\\hphantom{ (+0.0)} & 88.2\\hphantom{ (+0.0)} & 62.4\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 89.1\\hphantom{ (+0.0)}\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.0)}}} & 97.5 {\\hgreen{(+0.5)}} & 89.0 {\\hgreen{(+0.8)}} & 63.5 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & 89.6 {\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & 97.4\\hphantom{ (+0.0)} & \\textbf{98.4\\hphantom{ (+0.0)}} & \\textbf{89.3\\hphantom{ (+0.0)}} & 64.6\\hphantom{ (+0.0)} & \\textbf{99.5\\hphantom{ (+0.0)}} & \\textbf{89.8\\hphantom{ (+0.0)}}\\\\\n", - "DINO ViT-B/16 & AdamW & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6 {\\hgreen{(+0.2)}}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & 64.8 {\\hgreen{(+0.2)}} & \\textbf{99.5 {\\hgreen{(+0.0)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.3\\hphantom{ (+0.0)}} & \\textbf{98.9\\hphantom{ (+0.0)}} & \\textbf{92.0\\hphantom{ (+0.0)}} & 66.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & \\textbf{90.9\\hphantom{ (+0.0)}}\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & \\textbf{98.8 {\\hred{(-0.1)}}} & 91.5 {\\hred{(-0.5)}} & 65.9 {\\hred{(-0.2)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{90.8 {\\hred{(-0.1)}}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{98.7\\hphantom{ (+0.0)}} & 99.0\\hphantom{ (+0.0)} & 94.8\\hphantom{ (+0.0)} & 66.3\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 91.6\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-50 & AdamW & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.4 {\\hgreen{(+0.4)}}} & \\textbf{95.1 {\\hgreen{(+0.3)}}} & 67.4 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.0 {\\hgreen{(+0.4)}}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 98.4\\hphantom{ (+0.0)} & 97.3\\hphantom{ (+0.0)} & 84.3\\hphantom{ (+0.0)} & 69.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 89.7\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.3)}}} & \\textbf{98.9 {\\hgreen{(+1.6)}}} & \\textbf{97.1 {\\hgreen{(+12.8)}}} & \\textbf{74.5 {\\hgreen{(+5.5)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.1)}}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "ConvNext-Base\tAdamW (freeze-embed)\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0\\hphantom{ (+0.0)} & 62.5\\hphantom{ (+0.0)} & 72.8\\hphantom{ (+0.0)} & 37.3\\hphantom{ (+0.0)} & 86.8\\hphantom{ (+0.0)} & 67.9\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2 {\\hgreen{(+3.2)}}} & \\textbf{73.7 {\\hgreen{(+11.3)}}} & 88.2 {\\hgreen{(+15.4)}} & 40.2 {\\hgreen{(+2.8)}} & 94.3 {\\hgreen{(+7.5)}} & \\textbf{75.9 {\\hgreen{(+8.1)}}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{89.5\\hphantom{ (+0.0)}} & 77.4\\hphantom{ (+0.0)} & \\textbf{86.3\\hphantom{ (+0.0)}} & 33.5\\hphantom{ (+0.0)} & 92.6\\hphantom{ (+0.0)} & 75.8\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 {\\hred{(-1.5)}} & \\textbf{82.4 {\\hgreen{(+5.0)}}} & \\textbf{86.3 {\\hgreen{(+0.1)}}} & 34.4 {\\hgreen{(+1.0)}} & \\textbf{93.7 {\\hgreen{(+1.1)}}} & \\textbf{77.0 {\\hgreen{(+1.1)}}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{88.2\\hphantom{ (+0.0)}} & 56.1\\hphantom{ (+0.0)} & 76.0\\hphantom{ (+0.0)} & 33.6\\hphantom{ (+0.0)} & 86.9\\hphantom{ (+0.0)} & 68.2\\hphantom{ (+0.0)}\\\\\n", - "Sup ViT-B/16 & AdamW & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 {\\hred{(-1.5)}} & \\textbf{67.9 {\\hgreen{(+11.8)}}} & \\textbf{78.4 {\\hgreen{(+2.3)}}} & \\textbf{35.9 {\\hgreen{(+2.3)}}} & 90.6 {\\hgreen{(+3.7)}} & \\textbf{71.9 {\\hgreen{(+3.7)}}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{84.3\\hphantom{ (+0.0)}} & \\textbf{76.5\\hphantom{ (+0.0)}} & 80.0\\hphantom{ (+0.0)} & 34.1\\hphantom{ (+0.0)} & 90.4\\hphantom{ (+0.0)} & 73.1\\hphantom{ (+0.0)}\\\\\n", - "DINO ViT-B/16 & AdamW & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 {\\hred{(-0.2)}} & 75.5 {\\hred{(-0.9)}} & 82.3 {\\hgreen{(+2.3)}} & \\textbf{35.0 {\\hgreen{(+0.9)}}} & \\textbf{95.2 {\\hgreen{(+4.8)}}} & \\textbf{74.4 {\\hgreen{(+1.4)}}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & 82.8\\hphantom{ (+0.0)} & 76.9\\hphantom{ (+0.0)} & \\textbf{86.2\\hphantom{ (+0.0)}} & \\textbf{38.0\\hphantom{ (+0.0)}} & 89.3\\hphantom{ (+0.0)} & 74.6\\hphantom{ (+0.0)}\\\\\n", - "ConvNext-Base & AdamW & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1 {\\hgreen{(+0.3)}}} & 77.3 {\\hgreen{(+0.3)}} & 86.0 {\\hred{(-0.2)}} & 36.0 {\\hred{(-2.0)}} & \\textbf{95.5 {\\hgreen{(+6.2)}}} & \\textbf{75.6 {\\hgreen{(+0.9)}}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{94.0\\hphantom{ (+0.0)}} & 80.2\\hphantom{ (+0.0)} & 89.8\\hphantom{ (+0.0)} & \\textbf{39.7\\hphantom{ (+0.0)}} & 83.0\\hphantom{ (+0.0)} & 77.3\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-50 & AdamW & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 92.6 {\\hred{(-1.4)}} & 86.9 {\\hgreen{(+6.7)}} & \\textbf{91.2 {\\hgreen{(+1.5)}}} & 38.2 {\\hred{(-1.5)}} & 88.1 {\\hgreen{(+5.1)}} & \\textbf{79.4 {\\hgreen{(+2.1)}}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 84.2\\hphantom{ (+0.0)} & 65.0\\hphantom{ (+0.0)} & 60.8\\hphantom{ (+0.0)} & 41.0\\hphantom{ (+0.0)} & 83.2\\hphantom{ (+0.0)} & 66.8\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-101 & AdamW & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5 {\\hgreen{(+6.2)}}} & 84.7 {\\hgreen{(+19.8)}} & 93.1 {\\hgreen{(+32.3)}} & \\textbf{49.9 {\\hgreen{(+8.9)}}} & \\textbf{96.5 {\\hgreen{(+13.3)}}} & \\textbf{83.0 {\\hgreen{(+16.1)}}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -819,20 +428,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(7, 5, 13)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", "mean_table.shape" From c502625807ec45d4b0a41961c9b72b617427ae8c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 01:48:41 -0800 Subject: [PATCH 174/197] Clear outputs. --- ...nalyze_dataset_stats_model_gradients.ipynb | 66 +-- ...eeze-embed-paper-fine-tuning-results.ipynb | 428 +----------------- 2 files changed, 51 insertions(+), 443 deletions(-) diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index a0f485e..f837b93 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -89,7 +89,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "['grad_2', 'grad_1']\n" + "['grad_1', 'grad_2']\n" ] } ], @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -113,9 +113,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -132,9 +132,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -151,9 +151,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -173,6 +173,11 @@ " df = df[filtered_keys]\n", " return df.to_dict(orient='records')[0]\n", "\n", + "def filter_df_get_param_normalized_grad(df):\n", + " filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + " df = df[filtered_keys]\n", + " return df.to_dict(orient='records')[0]\n", + "\n", "def filter_df_get_normalized_grad(df):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", @@ -186,38 +191,43 @@ "# def filter_df_get_norm_grad(df):\n", "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad' in s]\n", "# print(filtered_keys)\n", - "# return df[filtered_keys] \n", + "# return df[filtered_keys] \n", + "\n", + "# Get a sorted list of outputs, \n", "\n", "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", " dataset_stats = {}\n", " for dataset in datasets:\n", " print(dataset)\n", - " figure(figsize=(8, 4), dpi=80)\n", + " figure(figsize=(8, 4), dpi=300)\n", " for model_idx, model in enumerate(models):\n", " dir_path = get_dir_path(dataset, model)\n", " config_path = get_config_path(dir_path)\n", " stats_path = get_stats_path(dir_path)\n", " with open(config_path, 'r') as f:\n", " config = json.load(f)\n", - " train_data = utils.init_dataset(config['train_dataset'])\n", - " if model_idx == 1:\n", - " random_images = get_random_images(train_data,n=10)\n", - " dataset_stats[dataset] = {\n", - " 'mean': np.mean(random_images),\n", - " 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", - " 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", - " }\n", + "# train_data = utils.init_dataset(config['train_dataset'])\n", + "# if model_idx == 1:\n", + "# random_images = get_random_images(train_data,n=10)\n", + "# dataset_stats[dataset] = {\n", + "# 'mean': np.mean(random_images),\n", + "# 'std': np.mean(np.std(random_images, axis=(1,2,3))),\n", + "# 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", + "# }\n", " df = pd.read_csv(stats_path, sep='\\t')\n", " d = filter_df(df)\n", + "# print(model)\n", + "# print(list(d.keys()))\n", + "# print(sorted([(-v, k) for k, v in list(d.items())]))\n", " values = list(d.values())\n", " if model_idx == 1:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers')\n", - " plt.scatter([model_idx], values[-1], c='green', label='last layer')\n", - " plt.scatter([model_idx], values[0], c='red', label='first layer')\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers', marker='o')\n", + " plt.scatter([model_idx], values[-1], c='green', label='head layer', marker='^')\n", + " plt.scatter([model_idx], values[0], c='red', label='embedding layer', marker='s')\n", " else:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black')\n", - " plt.scatter([model_idx], values[-1], c='green')\n", - " plt.scatter([model_idx], values[0], c='red')\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", + " plt.scatter([model_idx], values[-1], c='green', marker='^')\n", + " plt.scatter([model_idx], values[0], c='red', marker='s')\n", " my_xticks = ['John','Arnold','Mavis','Matt']\n", " plt.legend()\n", " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", @@ -228,11 +238,11 @@ "# print(df['train/grad_patch_embed'])\n", "# print(df[filtered_keys])\n", "# print(df[compute_keys(df)])\n", - " return dataset_stats\n", + "# return dataset_stats\n", "\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_norm)\n" + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad)\n" ] }, { diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index c8de9e9..00a5619 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,20 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -27,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -235,134 +224,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -402,18 +266,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.25925333 91.46286571 91.27799905]\n", - "[71.9667419 76.03873524 76.73786476]\n" - ] - } - ], + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -429,102 +284,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CLIP Results, all datasets\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", - "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", - "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", - "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", - "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", - "\n", - "\\begin{tabular}{ccccccccccc|cc}\n", - "\\toprule\n", - " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", - "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", - "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", - "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", - "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", - "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", - "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", - "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", - "\n", - "\\begin{tabular}{ccccccccccc|cc}\n", - "\\toprule\n", - " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", - "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", - "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", - "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - }, - { - "data": { - "text/plain": [ - "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", - " 99.3802 , 90.03969333],\n", - " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", - " 99.5451 , 92.10128 ],\n", - " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", - " 99.52623333, 92.08117333],\n", - " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", - " 99.26896667, 92.27565333],\n", - " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", - " 99.5232 , 91.70076 ],\n", - " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", - " 99.3445 , 90.88064 ]]]),\n", - " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", - " 86.79546667, 67.86795333],\n", - " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", - " 95.72586667, 76.04364667],\n", - " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", - " 94.29106667, 75.92171333],\n", - " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", - " 96.48143333, 76.22931333],\n", - " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", - " 93.3948 , 73.2131 ],\n", - " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", - " 93.2843 , 69.64942 ]]]))" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -633,162 +395,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "CLIP ViT-L/14\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "Sup ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "DINO ViT-B/16\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "ConvNext-Base\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "ConvNext-Base\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "ConvNext-Base\tAdamW (freeze-embed)\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-50\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "BiT ResNet-50\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-50\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "BiT ResNet-101\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "BiT ResNet-101\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8\\hphantom{ (+0.0)} & 97.2\\hphantom{ (+0.0)} & 88.8\\hphantom{ (+0.0)} & 67.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.0\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2 {\\hgreen{(+0.3)}}} & \\textbf{97.8 {\\hgreen{(+0.6)}}} & \\textbf{94.9 {\\hgreen{(+6.1)}}} & \\textbf{70.0 {\\hgreen{(+3.0)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.1 {\\hgreen{(+2.0)}}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.1 {\\hgreen{(+0.3)}}} & \\textbf{97.7 {\\hgreen{(+0.5)}}} & \\textbf{95.0 {\\hgreen{(+6.2)}}} & \\textbf{70.1 {\\hgreen{(+3.1)}}} & \\textbf{99.5 {\\hgreen{(+0.2)}}} & \\textbf{92.1 {\\hgreen{(+2.1)}}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{98.6\\hphantom{ (+0.0)}} & \\textbf{99.1\\hphantom{ (+0.0)}} & \\textbf{91.7\\hphantom{ (+0.0)}} & 64.1\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 90.6\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.2 {\\hgreen{(+0.1)}}} & 91.5 {\\hred{(-0.3)}} & 65.0 {\\hgreen{(+0.9)}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & 90.8 {\\hgreen{(+0.2)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.1)}}} & \\textbf{99.0 {\\hred{(-0.0)}}} & \\textbf{91.7 {\\hred{(-0.0)}}} & \\textbf{66.4 {\\hgreen{(+2.4)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{91.1 {\\hgreen{(+0.5)}}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.4\\hphantom{ (+0.0)}} & 97.0\\hphantom{ (+0.0)} & 88.2\\hphantom{ (+0.0)} & 62.4\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 89.1\\hphantom{ (+0.0)}\\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.0)}}} & 97.5 {\\hgreen{(+0.5)}} & 89.0 {\\hgreen{(+0.8)}} & 63.5 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & 89.6 {\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.5 {\\hgreen{(+0.1)}}} & \\textbf{97.9 {\\hgreen{(+0.8)}}} & \\textbf{89.4 {\\hgreen{(+1.2)}}} & \\textbf{66.0 {\\hgreen{(+3.6)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{90.3 {\\hgreen{(+1.2)}}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & 97.4\\hphantom{ (+0.0)} & \\textbf{98.4\\hphantom{ (+0.0)}} & \\textbf{89.3\\hphantom{ (+0.0)}} & 64.6\\hphantom{ (+0.0)} & \\textbf{99.5\\hphantom{ (+0.0)}} & \\textbf{89.8\\hphantom{ (+0.0)}}\\\\\n", - "DINO ViT-B/16 & AdamW & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{97.6 {\\hgreen{(+0.2)}}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & 64.8 {\\hgreen{(+0.2)}} & \\textbf{99.5 {\\hgreen{(+0.0)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 97.2 {\\hred{(-0.1)}} & \\textbf{98.5 {\\hgreen{(+0.0)}}} & \\textbf{89.2 {\\hred{(-0.1)}}} & \\textbf{65.1 {\\hgreen{(+0.5)}}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{89.9 {\\hgreen{(+0.1)}}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.3\\hphantom{ (+0.0)}} & \\textbf{98.9\\hphantom{ (+0.0)}} & \\textbf{92.0\\hphantom{ (+0.0)}} & 66.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & \\textbf{90.9\\hphantom{ (+0.0)}}\\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & \\textbf{98.8 {\\hred{(-0.1)}}} & 91.5 {\\hred{(-0.5)}} & 65.9 {\\hred{(-0.2)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{90.8 {\\hred{(-0.1)}}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.4 {\\hgreen{(+0.1)}}} & 98.6 {\\hred{(-0.3)}} & 91.1 {\\hred{(-0.9)}} & \\textbf{67.0 {\\hgreen{(+0.9)}}} & \\textbf{99.6 {\\hgreen{(+0.1)}}} & \\textbf{90.9 {\\hred{(-0.0)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{98.7\\hphantom{ (+0.0)}} & 99.0\\hphantom{ (+0.0)} & 94.8\\hphantom{ (+0.0)} & 66.3\\hphantom{ (+0.0)} & 99.4\\hphantom{ (+0.0)} & 91.6\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-50 & AdamW & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.4 {\\hgreen{(+0.4)}}} & \\textbf{95.1 {\\hgreen{(+0.3)}}} & 67.4 {\\hgreen{(+1.1)}} & \\textbf{99.5 {\\hgreen{(+0.1)}}} & \\textbf{92.0 {\\hgreen{(+0.4)}}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{98.6 {\\hred{(-0.1)}}} & \\textbf{99.5 {\\hgreen{(+0.5)}}} & 94.5 {\\hred{(-0.3)}} & \\textbf{68.8 {\\hgreen{(+2.5)}}} & \\textbf{99.7 {\\hgreen{(+0.2)}}} & \\textbf{92.2 {\\hgreen{(+0.6)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 98.4\\hphantom{ (+0.0)} & 97.3\\hphantom{ (+0.0)} & 84.3\\hphantom{ (+0.0)} & 69.0\\hphantom{ (+0.0)} & \\textbf{99.4\\hphantom{ (+0.0)}} & 89.7\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.7 {\\hgreen{(+0.3)}}} & \\textbf{98.9 {\\hgreen{(+1.6)}}} & \\textbf{97.1 {\\hgreen{(+12.8)}}} & \\textbf{74.5 {\\hgreen{(+5.5)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.1)}}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.9 {\\hgreen{(+0.5)}}} & \\textbf{98.8 {\\hgreen{(+1.5)}}} & 96.9 {\\hgreen{(+12.5)}} & \\textbf{74.5 {\\hgreen{(+5.4)}}} & \\textbf{99.6 {\\hgreen{(+0.2)}}} & \\textbf{93.7 {\\hgreen{(+4.0)}}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-L/14\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "CLIP ViT-L/14\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "Sup ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "DINO ViT-B/16\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "ConvNext-Base\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "ConvNext-Base\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "ConvNext-Base\tAdamW (freeze-embed)\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-50\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "BiT ResNet-50\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-50\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "BiT ResNet-101\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "BiT ResNet-101\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "BiT ResNet-101\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "\n", - "\\begin{tabular}{ccccccc|c}\n", - "\\toprule\n", - " & & Living-17 & Waterbirds & DomainNet & FMoW & Camelyon & Avg.\\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0\\hphantom{ (+0.0)} & 62.5\\hphantom{ (+0.0)} & 72.8\\hphantom{ (+0.0)} & 37.3\\hphantom{ (+0.0)} & 86.8\\hphantom{ (+0.0)} & 67.9\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2 {\\hgreen{(+3.2)}}} & \\textbf{73.7 {\\hgreen{(+11.3)}}} & 88.2 {\\hgreen{(+15.4)}} & 40.2 {\\hgreen{(+2.8)}} & 94.3 {\\hgreen{(+7.5)}} & \\textbf{75.9 {\\hgreen{(+8.1)}}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.8 {\\hgreen{(+2.8)}} & 71.9 {\\hgreen{(+9.4)}} & \\textbf{89.2 {\\hgreen{(+16.4)}}} & \\textbf{40.7 {\\hgreen{(+3.3)}}} & \\textbf{95.7 {\\hgreen{(+8.9)}}} & \\textbf{76.0 {\\hgreen{(+8.2)}}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & \\textbf{89.5\\hphantom{ (+0.0)}} & 77.4\\hphantom{ (+0.0)} & \\textbf{86.3\\hphantom{ (+0.0)}} & 33.5\\hphantom{ (+0.0)} & 92.6\\hphantom{ (+0.0)} & 75.8\\hphantom{ (+0.0)}\\\\\n", - "CLIP ViT-L/14 & AdamW & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & 88.0 {\\hred{(-1.5)}} & \\textbf{82.4 {\\hgreen{(+5.0)}}} & \\textbf{86.3 {\\hgreen{(+0.1)}}} & 34.4 {\\hgreen{(+1.0)}} & \\textbf{93.7 {\\hgreen{(+1.1)}}} & \\textbf{77.0 {\\hgreen{(+1.1)}}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.3 {\\hred{(-1.2)}} & 81.6 {\\hgreen{(+4.2)}} & 84.4 {\\hred{(-1.8)}} & \\textbf{35.9 {\\hgreen{(+2.5)}}} & 87.9 {\\hred{(-4.6)}} & 75.6 {\\hred{(-0.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{88.2\\hphantom{ (+0.0)}} & 56.1\\hphantom{ (+0.0)} & 76.0\\hphantom{ (+0.0)} & 33.6\\hphantom{ (+0.0)} & 86.9\\hphantom{ (+0.0)} & 68.2\\hphantom{ (+0.0)}\\\\\n", - "Sup ViT-B/16 & AdamW & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 86.7 {\\hred{(-1.5)}} & \\textbf{67.9 {\\hgreen{(+11.8)}}} & \\textbf{78.4 {\\hgreen{(+2.3)}}} & \\textbf{35.9 {\\hgreen{(+2.3)}}} & 90.6 {\\hgreen{(+3.7)}} & \\textbf{71.9 {\\hgreen{(+3.7)}}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & 87.4 {\\hred{(-0.9)}} & 61.2 {\\hgreen{(+5.1)}} & 77.4 {\\hgreen{(+1.4)}} & \\textbf{35.8 {\\hgreen{(+2.2)}}} & \\textbf{91.9 {\\hgreen{(+5.0)}}} & 70.7 {\\hgreen{(+2.6)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{84.3\\hphantom{ (+0.0)}} & \\textbf{76.5\\hphantom{ (+0.0)}} & 80.0\\hphantom{ (+0.0)} & 34.1\\hphantom{ (+0.0)} & 90.4\\hphantom{ (+0.0)} & 73.1\\hphantom{ (+0.0)}\\\\\n", - "DINO ViT-B/16 & AdamW & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 84.1 {\\hred{(-0.2)}} & 75.5 {\\hred{(-0.9)}} & 82.3 {\\hgreen{(+2.3)}} & \\textbf{35.0 {\\hgreen{(+0.9)}}} & \\textbf{95.2 {\\hgreen{(+4.8)}}} & \\textbf{74.4 {\\hgreen{(+1.4)}}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 83.1 {\\hred{(-1.2)}} & 74.8 {\\hred{(-1.7)}} & \\textbf{84.0 {\\hgreen{(+3.9)}}} & 33.8 {\\hred{(-0.3)}} & 92.4 {\\hgreen{(+2.0)}} & 73.6 {\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & 82.8\\hphantom{ (+0.0)} & 76.9\\hphantom{ (+0.0)} & \\textbf{86.2\\hphantom{ (+0.0)}} & \\textbf{38.0\\hphantom{ (+0.0)}} & 89.3\\hphantom{ (+0.0)} & 74.6\\hphantom{ (+0.0)}\\\\\n", - "ConvNext-Base & AdamW & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{83.1 {\\hgreen{(+0.3)}}} & 77.3 {\\hgreen{(+0.3)}} & 86.0 {\\hred{(-0.2)}} & 36.0 {\\hred{(-2.0)}} & \\textbf{95.5 {\\hgreen{(+6.2)}}} & \\textbf{75.6 {\\hgreen{(+0.9)}}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{82.9 {\\hgreen{(+0.1)}}} & \\textbf{79.4 {\\hgreen{(+2.5)}}} & 83.5 {\\hred{(-2.7)}} & 37.0 {\\hred{(-1.0)}} & 89.7 {\\hgreen{(+0.4)}} & 74.5 {\\hred{(-0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{94.0\\hphantom{ (+0.0)}} & 80.2\\hphantom{ (+0.0)} & 89.8\\hphantom{ (+0.0)} & \\textbf{39.7\\hphantom{ (+0.0)}} & 83.0\\hphantom{ (+0.0)} & 77.3\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-50 & AdamW & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 92.6 {\\hred{(-1.4)}} & 86.9 {\\hgreen{(+6.7)}} & \\textbf{91.2 {\\hgreen{(+1.5)}}} & 38.2 {\\hred{(-1.5)}} & 88.1 {\\hgreen{(+5.1)}} & \\textbf{79.4 {\\hgreen{(+2.1)}}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & 90.3 {\\hred{(-3.7)}} & \\textbf{89.8 {\\hgreen{(+9.6)}}} & 89.5 {\\hred{(-0.2)}} & 38.4 {\\hred{(-1.3)}} & \\textbf{89.5 {\\hgreen{(+6.4)}}} & \\textbf{79.5 {\\hgreen{(+2.2)}}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 84.2\\hphantom{ (+0.0)} & 65.0\\hphantom{ (+0.0)} & 60.8\\hphantom{ (+0.0)} & 41.0\\hphantom{ (+0.0)} & 83.2\\hphantom{ (+0.0)} & 66.8\\hphantom{ (+0.0)}\\\\\n", - "BiT ResNet-101 & AdamW & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{90.5 {\\hgreen{(+6.2)}}} & 84.7 {\\hgreen{(+19.8)}} & 93.1 {\\hgreen{(+32.3)}} & \\textbf{49.9 {\\hgreen{(+8.9)}}} & \\textbf{96.5 {\\hgreen{(+13.3)}}} & \\textbf{83.0 {\\hgreen{(+16.1)}}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & 88.0 {\\hgreen{(+3.8)}} & \\textbf{85.2 {\\hgreen{(+20.2)}}} & \\textbf{93.8 {\\hgreen{(+33.0)}}} & 48.3 {\\hgreen{(+7.3)}} & 95.9 {\\hgreen{(+12.7)}} & 82.2 {\\hgreen{(+15.4)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -819,20 +428,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(7, 5, 13)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", "mean_table.shape" From 8981329da430a54077c72a89b7b86caf47bbf3c0 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 13:56:28 -0800 Subject: [PATCH 175/197] Update, and keep big table source. --- ...eeze-embed-paper-fine-tuning-results.ipynb | 339 ++++++++++++++++-- 1 file changed, 314 insertions(+), 25 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 00a5619..6582268 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -224,9 +235,134 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -243,10 +379,10 @@ "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "# mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "# Rearranging mean table\n", "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", @@ -395,9 +531,162 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "ConvNext-Base\tAdamW (freeze-embed)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & 70.1 & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 70.0 & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.1 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{95.3} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{70.5} & \\hspace{-1em}{\\hgreen{(+3.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.7 & \\hspace{-1em}{\\hgreen{(+12.4)}} & \\textbf{75.1} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & 66.4 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hred{(-0.8)}} & \\textbf{66.8} & \\hspace{-1em}{\\hgreen{(+2.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & 89.4 & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.7} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 65.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 68.8 & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.0 & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.7 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{69.2} & \\hspace{-1em}{\\hgreen{(+2.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.4} & \\hspace{-1em}{\\hgreen{(+0.8)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{97.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{98.4} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{89.1} & \\hspace{-1em}{\\hred{(-0.2)}} & 64.9 & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 98.7 & \\hspace{-1em}{\\hred{(-0.2)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "ConvNext-Base\tAdamW (freeze-embed)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.4 & \\hspace{-1em}{\\hgreen{(+2.4)}} & 69.5 & \\hspace{-1em}{\\hgreen{(+7.0)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{96.7} & \\hspace{-1em}{\\hgreen{(+9.9)}} & 75.5 & \\hspace{-1em}{\\hgreen{(+7.6)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & 84.6 & \\hspace{-1em}{\\hgreen{(+19.6)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 44.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{96.4} & \\hspace{-1em}{\\hgreen{(+13.2)}} & 81.5 & \\hspace{-1em}{\\hgreen{(+14.7)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 82.3 & \\hspace{-1em}{\\hred{(-4.0)}} & 35.7 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.0 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 76.3 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 91.9 & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 86.8 & \\hspace{-1em}{\\hred{(-1.4)}} & 64.5 & \\hspace{-1em}{\\hgreen{(+8.4)}} & 76.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 35.4 & \\hspace{-1em}{\\hgreen{(+1.8)}} & \\textbf{93.5} & \\hspace{-1em}{\\hgreen{(+6.6)}} & 71.4 & \\hspace{-1em}{\\hgreen{(+3.2)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & 39.7 & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & 89.8 & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & 79.5 & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 79.4 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-5.9)}} & \\textbf{91.6} & \\hspace{-1em}{\\hgreen{(+11.4)}} & 89.8 & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{41.6} & \\hspace{-1em}{\\hgreen{(+1.9)}} & 87.7 & \\hspace{-1em}{\\hgreen{(+4.7)}} & \\textbf{79.8} & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & 76.5 & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & 35.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & 74.4 & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & 82.9 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{77.3} & \\hspace{-1em}{\\hgreen{(+0.8)}} & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{36.3} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{74.7} & \\hspace{-1em}{\\hgreen{(+1.6)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & 82.9 & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & 83.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 75.6 & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{84.8} & \\hspace{-1em}{\\hgreen{(+2.0)}} & 78.3 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 84.3 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{38.2} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+5.7)}} & \\textbf{76.1} & \\hspace{-1em}{\\hgreen{(+1.5)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -408,11 +697,11 @@ "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", - "mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", - "std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", + "# mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "# mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", + "# std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'AdamW (freeze-embed)']\n", "\n", @@ -420,6 +709,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", + "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", @@ -428,19 +718,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", - "mean_table.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.25925333 91.46286571 91.27799905 91.48981143]\n", + "[71.9667419 76.03873524 76.73786476 76.46011143]\n" + ] + } + ], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", From 2cbf3883ac9aefdf759d0e8322665d8900021d04 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 11 Nov 2022 13:56:28 -0800 Subject: [PATCH 176/197] Update, and keep big table source. --- ...eeze-embed-paper-fine-tuning-results.ipynb | 339 ++++++++++++++++-- 1 file changed, 314 insertions(+), 25 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 00a5619..6582268 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -224,9 +235,134 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -243,10 +379,10 @@ "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "# mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", "# Rearranging mean table\n", "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", @@ -395,9 +531,162 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", + "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", + "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", + "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", + "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", + "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", + "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", + "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", + "ConvNext-Base\tAdamW (freeze-embed)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", + "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", + "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", + "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", + "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", + "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", + "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & 70.1 & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 70.0 & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.1 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{95.3} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{70.5} & \\hspace{-1em}{\\hgreen{(+3.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", + "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.7 & \\hspace{-1em}{\\hgreen{(+12.4)}} & \\textbf{75.1} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", + "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & 66.4 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hred{(-0.8)}} & \\textbf{66.8} & \\hspace{-1em}{\\hgreen{(+2.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", + "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & 89.4 & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.7} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 65.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", + "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 68.8 & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.0 & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.7 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{69.2} & \\hspace{-1em}{\\hgreen{(+2.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.4} & \\hspace{-1em}{\\hgreen{(+0.8)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", + "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{97.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{98.4} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{89.1} & \\hspace{-1em}{\\hred{(-0.2)}} & 64.9 & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", + "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 98.7 & \\hspace{-1em}{\\hred{(-0.2)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", + "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", + "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", + "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", + "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", + "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", + "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", + "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", + "Sup ViT-B/16\tAdamW (freeze-embed)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", + "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", + "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", + "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", + "DINO ViT-B/16\tAdamW (freeze-embed)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", + "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", + "ConvNext-Base\tAdamW (freeze-embed)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", + "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", + "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", + "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", + "BiT ResNet-50\tAdamW (freeze-embed)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", + "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", + "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", + "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", + "BiT ResNet-101\tAdamW (freeze-embed)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", + "\n", + "\\begin{tabular}{cccccccccccc|cc}\n", + "\\toprule\n", + " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.4 & \\hspace{-1em}{\\hgreen{(+2.4)}} & 69.5 & \\hspace{-1em}{\\hgreen{(+7.0)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{96.7} & \\hspace{-1em}{\\hgreen{(+9.9)}} & 75.5 & \\hspace{-1em}{\\hgreen{(+7.6)}}\\\\\n", + "\\midrule\n", + "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", + "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", + "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", + "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & 84.6 & \\hspace{-1em}{\\hgreen{(+19.6)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 44.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{96.4} & \\hspace{-1em}{\\hgreen{(+13.2)}} & 81.5 & \\hspace{-1em}{\\hgreen{(+14.7)}}\\\\\n", + "\\midrule\n", + "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", + "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", + "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", + "Sup ViT-B/16 & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 82.3 & \\hspace{-1em}{\\hred{(-4.0)}} & 35.7 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.0 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 76.3 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "\\midrule\n", + "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", + "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 91.9 & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", + "DINO ViT-B/16 & AdamW (freeze-embed) & 86.8 & \\hspace{-1em}{\\hred{(-1.4)}} & 64.5 & \\hspace{-1em}{\\hgreen{(+8.4)}} & 76.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 35.4 & \\hspace{-1em}{\\hgreen{(+1.8)}} & \\textbf{93.5} & \\hspace{-1em}{\\hgreen{(+6.6)}} & 71.4 & \\hspace{-1em}{\\hgreen{(+3.2)}}\\\\\n", + "\\midrule\n", + "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & 39.7 & & 83.0 & & 77.3 & \\\\\n", + "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & 89.8 & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & 79.5 & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 79.4 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "ConvNext-Base & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-5.9)}} & \\textbf{91.6} & \\hspace{-1em}{\\hgreen{(+11.4)}} & 89.8 & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{41.6} & \\hspace{-1em}{\\hgreen{(+1.9)}} & 87.7 & \\hspace{-1em}{\\hgreen{(+4.7)}} & \\textbf{79.8} & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-50 & SGD & \\textbf{84.3} & & 76.5 & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", + "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", + "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & 35.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & 74.4 & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", + "BiT ResNet-50 & AdamW (freeze-embed) & 82.9 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{77.3} & \\hspace{-1em}{\\hgreen{(+0.8)}} & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{36.3} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{74.7} & \\hspace{-1em}{\\hgreen{(+1.6)}}\\\\\n", + "\\midrule\n", + "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", + "BiT ResNet-101 & AdamW & 82.9 & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "BiT ResNet-101 & SGD (freeze-embed) & 83.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 75.6 & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", + "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{84.8} & \\hspace{-1em}{\\hgreen{(+2.0)}} & 78.3 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 84.3 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{38.2} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+5.7)}} & \\textbf{76.1} & \\hspace{-1em}{\\hgreen{(+1.5)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -408,11 +697,11 @@ "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", - "mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", - "std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", + "# mean_table_3, std_table_3 = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "# mean_table = np.concatenate((mean_table_3, mean_table_3[:,1,None,:]), axis=1)\n", + "# std_table = np.concatenate((std_table_3, std_table_3[:,1,None,:]), axis=1)\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'AdamW (freeze-embed)']\n", "\n", @@ -420,6 +709,7 @@ "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", "\n", + "\n", "id_mean_table, ood_mean_table = display_id_ood_tables(\n", " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", "\n", @@ -428,19 +718,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "mean_table = np.concatenate((mean_table, mean_table[:,1,None,:]), axis=1)\n", - "mean_table.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[90.25925333 91.46286571 91.27799905 91.48981143]\n", + "[71.9667419 76.03873524 76.73786476 76.46011143]\n" + ] + } + ], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", From f3ee8b4cf5c0c6d81f7faae2566d72cb8fd8f746 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 13 Nov 2022 23:39:47 -0800 Subject: [PATCH 177/197] Add more pickle files for results. --- scripts/clip_table_extended.pkl | Bin 0 -> 2065 bytes scripts/clip_table_main.pkl | Bin 0 -> 1441 bytes ...eeze-embed-paper-fine-tuning-results.ipynb | 332 ++---------------- 3 files changed, 22 insertions(+), 310 deletions(-) create mode 100644 scripts/clip_table_extended.pkl create mode 100644 scripts/clip_table_main.pkl diff --git a/scripts/clip_table_extended.pkl b/scripts/clip_table_extended.pkl new file mode 100644 index 0000000000000000000000000000000000000000..7a625e4fc610dd5da2a3f70f9112839167a22945 GIT binary patch literal 2065 zcmeHHi#L>M7{{PS(p75{wbiP&HLX;eOTCYo*)C>`Zy57^=~OPwhKey}Slf-P)HJ2W z=Tfapi;xte(w-VBM2Qh8y0|4u7n8`cwcoJk>^b`{?7r_g@AJOrJlEgz{N4!tc*F5J zqf22LDBCFxXZQw5M2wxX9a4X9iNrgcR2XlOh57HfQt3A1*4FZFmxfHxlTczcBqCY~^O z-CgJb{$HQ8UUPteCB=6#LM{p*wo@~^K8S!{O~S?x4Dez5;(^2`DjcqbmDSWb3!%fd z*XURbAH2IiHJ#C5aC_XUQy!^2(7IC!*kH|?^{Ty{fY}c5L(3F6lxBvWkiNm;iYV_W zT~5Fi`9pio9Ra}p_R6FX0z7_>&`k_<1Jeg-%!5~P5Stdr5=?|pWwagpDuNIGIzf^8 zY7CawIPlbVJfO0Y6n?>mMn>Gdyfy;nlj@d2PaGnYlm{ga+OX3}0uq}=^(El~xOpH8 zuT~PEz7%sdn#G6K4!d=-X#`CCU9WSqD-IT$l<&@R`5;<7(O^Rc2D`F7KfZYD0#)I? zf-VO(&{>136>0(?ciwD-gp8hf)~CZDpT>RGvs z?H@$ou-AgRZNQ;C)+Wq)Cjq|u9<2)hD1b<-8wax15)kk-SbmhdZmeHa9m+e@pnMQO zRp|B9nJNtAvwh!q24Zk5?W0Xss0$c1rHfa&v0(Y;tLu#)5D=+Pd5*z>p;d6hVRZZ> z2ncnxoDt9?fC5!-iX-)Yf7D$%Kh6!dBymj@%{X+dm|41!Erelv@x6m`KBOz{bzM3! zs2z0g$h74F?WYOz7oK6k+p3#PZGW`wE8l_x&u21W=lD+?d45|@yifp!k@2jVf6j3f-4cSSAX+GB97W4c9EG8aCH20Oinm@pkx zJT7h^z~Pzekwm2sWO^sZn@{x^tHYldt7Aj}M7DN<2zXvMw`FJz1__16!RH1&#_XPA zuv?RlZBM|UkP(=!E5Lw48LxiH1z~D#-oqFsSan9F)YKDT7T-YkqvCXAp1L(>s|S!2 zWBv5}47B9;8~1POPZ}e0(C#jGw~%rqKGk^prEfnfQpn8tW>-*>)7%UFBhz46WMyBQ zauzHO4wKx~UkbsWnNDlJ>p?qXt%+5o%_#9j)9sXi7Ia=zmuIv{gM^odpQI|}sO+^t z?s%Q|Xpvb7`@Ux%!oS?3Nsi7(?S?sva+)+K+5c0NaZw6-6mG#T)9As2tCn1OYymo5 zadD*BU4u+8Hh=Dd8r1A+V`LIii~9O98`5eYAV1qIn*qH>Bp+9E!HOA&zV&g;{w!`n zrE2w_puEROV$@c`NLQobwQGhGq%Tp$`kc&J>3N8LbM^FRH~WxRPF)-~xejH_(Oj%{ z>O!h3G{JG78g!}VwU=RBGg7e1)NSr9=uXk1QuZsNMluJJue3vljj?k_;Hm-`dg7Ck#=bw{t%6Q U{vY@KFSQ8#cX7~?`2flI3m-!ojQ{`u literal 0 HcmV?d00001 diff --git a/scripts/clip_table_main.pkl b/scripts/clip_table_main.pkl new file mode 100644 index 0000000000000000000000000000000000000000..8dc1af9ece57078a0a63a0ac6077d99b037e8a9d GIT binary patch literal 1441 zcmds%|2NcW6vu}#iDlAOyEfErc9qkbT~SNuxy)>27&Bwc=aW6Pm}c`OX3Q7P?53zi zO|z--LALd!O-Zf3h@w3i>O{yg6+*?R6|KIQgqE%SNI&hLu=hFVxz7*pd+&4a^Eywe zSxzpE^42tq5|r^$6+3(k2S`H2?e;jh8dWC?z>wTlIn-F5C z1#8+}`Cw}%q`TB|VN`Tu6C1c7e>HFT;zSUX+5DPi^_w5qZ;xCRb_a(@EcI?&gAlCq zX-|eK!XW0epIz2x;P6FNONsov0J0t$m)?}%@C!Y8?)W$l;#Q95-P2)kIk~>IEl>y# z+(s-9Wbz<#=ylg|BNwil`y37{;=oKgt$+nCO#8nE25?yFmGjD7gF)S~q>ys+P>4#bBoFLIQ`p9`Vf@l>n}0 zlw!?V9P}45Po^_@(Eq?QK)C=1>)%ZuZVth~VUzax$sitx*ICmxmT=*R6XBDOo&`gb zYD6&T#R3cFgl>%<2Po;QrB}Y2!x9_{pOrSS_u;U-c<)(*Ar!vxTQ}4##i7TJ9JC1+ z9KyGF^)+H3J{ck4=Lx}m{u=Mge{!{R+&xF;RFKw{u#39X$%$$h zHjSpuKpbuUUxeq)LMhok7|NGlL(;" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -27,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -235,134 +224,11 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -433,7 +299,11 @@ "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", @@ -531,162 +401,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "ConvNext-Base\tAdamW (freeze-embed)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & 70.1 & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 70.0 & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.1 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{95.3} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{70.5} & \\hspace{-1em}{\\hgreen{(+3.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.7 & \\hspace{-1em}{\\hgreen{(+12.4)}} & \\textbf{75.1} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & 66.4 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hred{(-0.8)}} & \\textbf{66.8} & \\hspace{-1em}{\\hgreen{(+2.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & 89.4 & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.7} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 65.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 68.8 & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.0 & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.7 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{69.2} & \\hspace{-1em}{\\hgreen{(+2.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.4} & \\hspace{-1em}{\\hgreen{(+0.8)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{97.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{98.4} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{89.1} & \\hspace{-1em}{\\hred{(-0.2)}} & 64.9 & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 98.7 & \\hspace{-1em}{\\hred{(-0.2)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "ConvNext-Base\tAdamW (freeze-embed)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.4 & \\hspace{-1em}{\\hgreen{(+2.4)}} & 69.5 & \\hspace{-1em}{\\hgreen{(+7.0)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{96.7} & \\hspace{-1em}{\\hgreen{(+9.9)}} & 75.5 & \\hspace{-1em}{\\hgreen{(+7.6)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & 84.6 & \\hspace{-1em}{\\hgreen{(+19.6)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 44.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{96.4} & \\hspace{-1em}{\\hgreen{(+13.2)}} & 81.5 & \\hspace{-1em}{\\hgreen{(+14.7)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 82.3 & \\hspace{-1em}{\\hred{(-4.0)}} & 35.7 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.0 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 76.3 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 91.9 & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 86.8 & \\hspace{-1em}{\\hred{(-1.4)}} & 64.5 & \\hspace{-1em}{\\hgreen{(+8.4)}} & 76.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 35.4 & \\hspace{-1em}{\\hgreen{(+1.8)}} & \\textbf{93.5} & \\hspace{-1em}{\\hgreen{(+6.6)}} & 71.4 & \\hspace{-1em}{\\hgreen{(+3.2)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & 39.7 & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & 89.8 & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & 79.5 & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 79.4 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-5.9)}} & \\textbf{91.6} & \\hspace{-1em}{\\hgreen{(+11.4)}} & 89.8 & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{41.6} & \\hspace{-1em}{\\hgreen{(+1.9)}} & 87.7 & \\hspace{-1em}{\\hgreen{(+4.7)}} & \\textbf{79.8} & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & 76.5 & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & 35.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & 74.4 & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & 82.9 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{77.3} & \\hspace{-1em}{\\hgreen{(+0.8)}} & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{36.3} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{74.7} & \\hspace{-1em}{\\hgreen{(+1.6)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & 82.9 & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & 83.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 75.6 & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{84.8} & \\hspace{-1em}{\\hgreen{(+2.0)}} & 78.3 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 84.3 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{38.2} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+5.7)}} & \\textbf{76.1} & \\hspace{-1em}{\\hgreen{(+1.5)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -718,18 +435,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.25925333 91.46286571 91.27799905 91.48981143]\n", - "[71.9667419 76.03873524 76.73786476 76.46011143]\n" - ] - } - ], + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -794,7 +502,11 @@ "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", From 873ef110d58edd330034dcb91229f647c6ccce7c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 13 Nov 2022 23:39:47 -0800 Subject: [PATCH 178/197] Add more pickle files for results. --- scripts/clip_table_extended.pkl | Bin 0 -> 2065 bytes scripts/clip_table_main.pkl | Bin 0 -> 1441 bytes ...eeze-embed-paper-fine-tuning-results.ipynb | 332 ++---------------- 3 files changed, 22 insertions(+), 310 deletions(-) create mode 100644 scripts/clip_table_extended.pkl create mode 100644 scripts/clip_table_main.pkl diff --git a/scripts/clip_table_extended.pkl b/scripts/clip_table_extended.pkl new file mode 100644 index 0000000000000000000000000000000000000000..7a625e4fc610dd5da2a3f70f9112839167a22945 GIT binary patch literal 2065 zcmeHHi#L>M7{{PS(p75{wbiP&HLX;eOTCYo*)C>`Zy57^=~OPwhKey}Slf-P)HJ2W z=Tfapi;xte(w-VBM2Qh8y0|4u7n8`cwcoJk>^b`{?7r_g@AJOrJlEgz{N4!tc*F5J zqf22LDBCFxXZQw5M2wxX9a4X9iNrgcR2XlOh57HfQt3A1*4FZFmxfHxlTczcBqCY~^O z-CgJb{$HQ8UUPteCB=6#LM{p*wo@~^K8S!{O~S?x4Dez5;(^2`DjcqbmDSWb3!%fd z*XURbAH2IiHJ#C5aC_XUQy!^2(7IC!*kH|?^{Ty{fY}c5L(3F6lxBvWkiNm;iYV_W zT~5Fi`9pio9Ra}p_R6FX0z7_>&`k_<1Jeg-%!5~P5Stdr5=?|pWwagpDuNIGIzf^8 zY7CawIPlbVJfO0Y6n?>mMn>Gdyfy;nlj@d2PaGnYlm{ga+OX3}0uq}=^(El~xOpH8 zuT~PEz7%sdn#G6K4!d=-X#`CCU9WSqD-IT$l<&@R`5;<7(O^Rc2D`F7KfZYD0#)I? zf-VO(&{>136>0(?ciwD-gp8hf)~CZDpT>RGvs z?H@$ou-AgRZNQ;C)+Wq)Cjq|u9<2)hD1b<-8wax15)kk-SbmhdZmeHa9m+e@pnMQO zRp|B9nJNtAvwh!q24Zk5?W0Xss0$c1rHfa&v0(Y;tLu#)5D=+Pd5*z>p;d6hVRZZ> z2ncnxoDt9?fC5!-iX-)Yf7D$%Kh6!dBymj@%{X+dm|41!Erelv@x6m`KBOz{bzM3! zs2z0g$h74F?WYOz7oK6k+p3#PZGW`wE8l_x&u21W=lD+?d45|@yifp!k@2jVf6j3f-4cSSAX+GB97W4c9EG8aCH20Oinm@pkx zJT7h^z~Pzekwm2sWO^sZn@{x^tHYldt7Aj}M7DN<2zXvMw`FJz1__16!RH1&#_XPA zuv?RlZBM|UkP(=!E5Lw48LxiH1z~D#-oqFsSan9F)YKDT7T-YkqvCXAp1L(>s|S!2 zWBv5}47B9;8~1POPZ}e0(C#jGw~%rqKGk^prEfnfQpn8tW>-*>)7%UFBhz46WMyBQ zauzHO4wKx~UkbsWnNDlJ>p?qXt%+5o%_#9j)9sXi7Ia=zmuIv{gM^odpQI|}sO+^t z?s%Q|Xpvb7`@Ux%!oS?3Nsi7(?S?sva+)+K+5c0NaZw6-6mG#T)9As2tCn1OYymo5 zadD*BU4u+8Hh=Dd8r1A+V`LIii~9O98`5eYAV1qIn*qH>Bp+9E!HOA&zV&g;{w!`n zrE2w_puEROV$@c`NLQobwQGhGq%Tp$`kc&J>3N8LbM^FRH~WxRPF)-~xejH_(Oj%{ z>O!h3G{JG78g!}VwU=RBGg7e1)NSr9=uXk1QuZsNMluJJue3vljj?k_;Hm-`dg7Ck#=bw{t%6Q U{vY@KFSQ8#cX7~?`2flI3m-!ojQ{`u literal 0 HcmV?d00001 diff --git a/scripts/clip_table_main.pkl b/scripts/clip_table_main.pkl new file mode 100644 index 0000000000000000000000000000000000000000..8dc1af9ece57078a0a63a0ac6077d99b037e8a9d GIT binary patch literal 1441 zcmds%|2NcW6vu}#iDlAOyEfErc9qkbT~SNuxy)>27&Bwc=aW6Pm}c`OX3Q7P?53zi zO|z--LALd!O-Zf3h@w3i>O{yg6+*?R6|KIQgqE%SNI&hLu=hFVxz7*pd+&4a^Eywe zSxzpE^42tq5|r^$6+3(k2S`H2?e;jh8dWC?z>wTlIn-F5C z1#8+}`Cw}%q`TB|VN`Tu6C1c7e>HFT;zSUX+5DPi^_w5qZ;xCRb_a(@EcI?&gAlCq zX-|eK!XW0epIz2x;P6FNONsov0J0t$m)?}%@C!Y8?)W$l;#Q95-P2)kIk~>IEl>y# z+(s-9Wbz<#=ylg|BNwil`y37{;=oKgt$+nCO#8nE25?yFmGjD7gF)S~q>ys+P>4#bBoFLIQ`p9`Vf@l>n}0 zlw!?V9P}45Po^_@(Eq?QK)C=1>)%ZuZVth~VUzax$sitx*ICmxmT=*R6XBDOo&`gb zYD6&T#R3cFgl>%<2Po;QrB}Y2!x9_{pOrSS_u;U-c<)(*Ar!vxTQ}4##i7TJ9JC1+ z9KyGF^)+H3J{ck4=Lx}m{u=Mge{!{R+&xF;RFKw{u#39X$%$$h zHjSpuKpbuUUxeq)LMhok7|NGlL(;" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -27,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -235,134 +224,11 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{95.0} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{94.9} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & \\textbf{74.5} & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{66.4} & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{89.4} & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{95.7} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & \\textbf{91.9} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & \\textbf{39.7} & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{79.5} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & \\textbf{76.5} & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{35.0} & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & \\textbf{74.4} & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{82.9} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{83.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{75.6} & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -433,7 +299,11 @@ "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", @@ -531,162 +401,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "ID Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", - "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t98.3\t97.8\t95.3\t70.5\t99.6\t92.3\n", - "CLIP ViT-L/14\tSGD\t98.4\t97.3\t84.3\t69.0\t99.4\t89.7\n", - "CLIP ViT-L/14\tAdamW\t98.9\t98.8\t96.9\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t98.7\t98.9\t97.1\t74.5\t99.6\t93.7\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t98.7\t98.8\t96.7\t75.1\t99.6\t93.8\n", - "Sup ViT-B/16\tSGD\t98.6\t99.1\t91.7\t64.1\t99.4\t90.6\n", - "Sup ViT-B/16\tAdamW\t98.7\t99.0\t91.7\t66.4\t99.5\t91.1\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t98.7\t99.2\t91.5\t65.0\t99.6\t90.8\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t98.6\t99.0\t90.9\t66.8\t99.5\t91.0\n", - "DINO ViT-B/16\tSGD\t98.4\t97.0\t88.2\t62.4\t99.4\t89.1\n", - "DINO ViT-B/16\tAdamW\t98.5\t97.9\t89.4\t66.0\t99.6\t90.3\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t98.4\t97.5\t89.0\t63.5\t99.5\t89.6\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t98.4\t97.8\t89.7\t65.7\t99.6\t90.3\n", - "ConvNext-Base\tSGD\t98.7\t99.0\t94.8\t66.3\t99.4\t91.6\n", - "ConvNext-Base\tAdamW\t98.6\t99.5\t94.5\t68.8\t99.7\t92.2\n", - "ConvNext-Base\tSGD (freeze-embed)\t98.6\t99.4\t95.1\t67.4\t99.5\t92.0\n", - "ConvNext-Base\tAdamW (freeze-embed)\t98.7\t99.5\t94.7\t69.2\t99.6\t92.4\n", - "BiT ResNet-50\tSGD\t97.4\t98.4\t89.3\t64.6\t99.5\t89.8\n", - "BiT ResNet-50\tAdamW\t97.2\t98.5\t89.2\t65.1\t99.5\t89.9\n", - "BiT ResNet-50\tSGD (freeze-embed)\t97.6\t98.5\t89.2\t64.8\t99.5\t89.9\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t97.4\t98.4\t89.1\t64.9\t99.6\t89.9\n", - "BiT ResNet-101\tSGD\t98.3\t98.9\t92.0\t66.0\t99.4\t90.9\n", - "BiT ResNet-101\tAdamW\t98.4\t98.6\t91.1\t67.0\t99.6\t90.9\n", - "BiT ResNet-101\tSGD (freeze-embed)\t98.4\t98.8\t91.5\t65.9\t99.5\t90.8\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t98.2\t98.7\t91.1\t66.6\t99.6\t90.9\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", - "CLIP ViT-B/16 & AdamW & \\textbf{98.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{97.7} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & 70.1 & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 70.0 & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.1 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{95.3} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{70.5} & \\hspace{-1em}{\\hgreen{(+3.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 98.4 & & 97.3 & & 84.3 & & 69.0 & & \\textbf{99.4} & & 89.7 & \\\\\n", - "CLIP ViT-L/14 & AdamW & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.9 & \\hspace{-1em}{\\hgreen{(+12.6)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.9} & \\hspace{-1em}{\\hgreen{(+1.6)}} & \\textbf{97.1} & \\hspace{-1em}{\\hgreen{(+12.8)}} & 74.5 & \\hspace{-1em}{\\hgreen{(+5.5)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+4.0)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{98.8} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 96.7 & \\hspace{-1em}{\\hgreen{(+12.4)}} & \\textbf{75.1} & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+4.1)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{98.6} & & \\textbf{99.1} & & \\textbf{91.7} & & 64.1 & & \\textbf{99.4} & & 90.6 & \\\\\n", - "Sup ViT-B/16 & AdamW & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{91.7} & \\hspace{-1em}{\\lred{(-0.0)}} & 66.4 & \\hspace{-1em}{\\hgreen{(+2.3)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.1} & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{99.2} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.2)}} & 65.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 90.8 & \\hspace{-1em}{\\hgreen{(+0.2)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.0} & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hred{(-0.8)}} & \\textbf{66.8} & \\hspace{-1em}{\\hgreen{(+2.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{91.0} & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{98.4} & & 97.0 & & 88.2 & & 62.4 & & 99.4 & & 89.1 & \\\\\n", - "DINO ViT-B/16 & AdamW & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{97.9} & \\hspace{-1em}{\\hgreen{(+0.9)}} & 89.4 & \\hspace{-1em}{\\hgreen{(+1.2)}} & \\textbf{66.0} & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 89.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 63.5 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 89.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{97.8} & \\hspace{-1em}{\\hgreen{(+0.8)}} & \\textbf{89.7} & \\hspace{-1em}{\\hgreen{(+1.5)}} & 65.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{90.3} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{98.7} & & 99.0 & & 94.8 & & 66.3 & & 99.4 & & 91.6 & \\\\\n", - "ConvNext-Base & AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 68.8 & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+0.6)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & \\textbf{95.1} & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 92.0 & \\hspace{-1em}{\\hgreen{(+0.4)}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & \\textbf{98.7} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & 94.7 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{69.2} & \\hspace{-1em}{\\hgreen{(+2.9)}} & \\textbf{99.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{92.4} & \\hspace{-1em}{\\hgreen{(+0.8)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & 97.4 & & \\textbf{98.4} & & \\textbf{89.3} & & 64.6 & & \\textbf{99.5} & & \\textbf{89.8} & \\\\\n", - "BiT ResNet-50 & AdamW & 97.2 & \\hspace{-1em}{\\hred{(-0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{65.1} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & \\textbf{97.6} & \\hspace{-1em}{\\hgreen{(+0.2)}} & \\textbf{98.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 64.8 & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & \\textbf{97.4} & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{98.4} & \\hspace{-1em}{\\lred{(-0.0)}} & \\textbf{89.1} & \\hspace{-1em}{\\hred{(-0.2)}} & 64.9 & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{89.9} & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & \\textbf{98.3} & & \\textbf{98.9} & & \\textbf{92.0} & & 66.0 & & \\textbf{99.4} & & \\textbf{90.9} & \\\\\n", - "BiT ResNet-101 & AdamW & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 98.6 & \\hspace{-1em}{\\hred{(-0.3)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & \\textbf{67.0} & \\hspace{-1em}{\\hgreen{(+1.0)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & \\textbf{98.4} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{98.8} & \\hspace{-1em}{\\lred{(-0.1)}} & 91.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 65.9 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{90.8} & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\lred{(-0.1)}} & 98.7 & \\hspace{-1em}{\\hred{(-0.2)}} & 91.1 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & \\textbf{99.6} & \\hspace{-1em}{\\lgreen{(+0.2)}} & \\textbf{90.9} & \\hspace{-1em}{\\lred{(-0.0)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n", - "\n", - "\n", - "OOD Accuracies\n", - "\t\tLiving-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", - "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", - "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", - "CLIP ViT-B/16\tSGD (freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", - "CLIP ViT-B/16\tAdamW (freeze-embed)\t82.4\t69.5\t88.2\t40.7\t96.7\t75.5\n", - "CLIP ViT-L/14\tSGD\t84.2\t65.0\t60.8\t41.0\t83.2\t66.8\n", - "CLIP ViT-L/14\tAdamW\t88.0\t85.2\t93.8\t48.3\t95.9\t82.2\n", - "CLIP ViT-L/14\tSGD (freeze-embed)\t90.5\t84.7\t93.1\t49.9\t96.5\t83.0\n", - "CLIP ViT-L/14\tAdamW (freeze-embed)\t88.0\t84.6\t93.8\t44.6\t96.4\t81.5\n", - "Sup ViT-B/16\tSGD\t89.5\t77.4\t86.3\t33.5\t92.6\t75.8\n", - "Sup ViT-B/16\tAdamW\t88.3\t81.6\t84.4\t35.9\t87.9\t75.6\n", - "Sup ViT-B/16\tSGD (freeze-embed)\t88.0\t82.4\t86.3\t34.4\t93.7\t77.0\n", - "Sup ViT-B/16\tAdamW (freeze-embed)\t88.1\t82.4\t82.3\t35.7\t93.0\t76.3\n", - "DINO ViT-B/16\tSGD\t88.2\t56.1\t76.0\t33.6\t86.9\t68.2\n", - "DINO ViT-B/16\tAdamW\t87.4\t61.2\t77.4\t35.8\t91.9\t70.7\n", - "DINO ViT-B/16\tSGD (freeze-embed)\t86.7\t67.9\t78.4\t35.9\t90.6\t71.9\n", - "DINO ViT-B/16\tAdamW (freeze-embed)\t86.8\t64.5\t76.6\t35.4\t93.5\t71.4\n", - "ConvNext-Base\tSGD\t94.0\t80.2\t89.8\t39.7\t83.0\t77.3\n", - "ConvNext-Base\tAdamW\t90.3\t89.8\t89.5\t38.4\t89.5\t79.5\n", - "ConvNext-Base\tSGD (freeze-embed)\t92.6\t86.9\t91.2\t38.2\t88.1\t79.4\n", - "ConvNext-Base\tAdamW (freeze-embed)\t88.1\t91.6\t89.8\t41.6\t87.7\t79.8\n", - "BiT ResNet-50\tSGD\t84.3\t76.5\t80.0\t34.1\t90.4\t73.1\n", - "BiT ResNet-50\tAdamW\t83.1\t74.8\t84.0\t33.8\t92.4\t73.6\n", - "BiT ResNet-50\tSGD (freeze-embed)\t84.1\t75.5\t82.3\t35.0\t95.2\t74.4\n", - "BiT ResNet-50\tAdamW (freeze-embed)\t82.9\t77.3\t83.3\t36.3\t93.7\t74.7\n", - "BiT ResNet-101\tSGD\t82.8\t76.9\t86.2\t38.0\t89.3\t74.6\n", - "BiT ResNet-101\tAdamW\t82.9\t79.4\t83.5\t37.0\t89.7\t74.5\n", - "BiT ResNet-101\tSGD (freeze-embed)\t83.1\t77.3\t86.0\t36.0\t95.5\t75.6\n", - "BiT ResNet-101\tAdamW (freeze-embed)\t84.8\t78.3\t84.3\t38.2\t95.0\t76.1\n", - "\n", - "\\begin{tabular}{cccccccccccc|cc}\n", - "\\toprule\n", - " & & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", - "\\midrule\n", - "CLIP ViT-B/16 & SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", - "CLIP ViT-B/16 & AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & \\textbf{89.2} & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", - "CLIP ViT-B/16 & SGD (freeze-embed) & \\textbf{83.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & \\textbf{75.9} & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", - "CLIP ViT-B/16 & AdamW (freeze-embed) & 82.4 & \\hspace{-1em}{\\hgreen{(+2.4)}} & 69.5 & \\hspace{-1em}{\\hgreen{(+7.0)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & \\textbf{96.7} & \\hspace{-1em}{\\hgreen{(+9.9)}} & 75.5 & \\hspace{-1em}{\\hgreen{(+7.6)}}\\\\\n", - "\\midrule\n", - "CLIP ViT-L/14 & SGD & 84.2 & & 65.0 & & 60.8 & & 41.0 & & 83.2 & & 66.8 & \\\\\n", - "CLIP ViT-L/14 & AdamW & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & \\textbf{85.2} & \\hspace{-1em}{\\hgreen{(+20.2)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 48.3 & \\hspace{-1em}{\\hgreen{(+7.3)}} & 95.9 & \\hspace{-1em}{\\hgreen{(+12.7)}} & 82.2 & \\hspace{-1em}{\\hgreen{(+15.4)}}\\\\\n", - "CLIP ViT-L/14 & SGD (freeze-embed) & \\textbf{90.5} & \\hspace{-1em}{\\hgreen{(+6.3)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+19.7)}} & 93.1 & \\hspace{-1em}{\\hgreen{(+32.3)}} & \\textbf{49.9} & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+13.3)}} & \\textbf{83.0} & \\hspace{-1em}{\\hgreen{(+16.2)}}\\\\\n", - "CLIP ViT-L/14 & AdamW (freeze-embed) & 88.0 & \\hspace{-1em}{\\hgreen{(+3.8)}} & 84.6 & \\hspace{-1em}{\\hgreen{(+19.6)}} & \\textbf{93.8} & \\hspace{-1em}{\\hgreen{(+33.0)}} & 44.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{96.4} & \\hspace{-1em}{\\hgreen{(+13.2)}} & 81.5 & \\hspace{-1em}{\\hgreen{(+14.7)}}\\\\\n", - "\\midrule\n", - "Sup ViT-B/16 & SGD & \\textbf{89.5} & & 77.4 & & \\textbf{86.3} & & 33.5 & & 92.6 & & 75.8 & \\\\\n", - "Sup ViT-B/16 & AdamW & 88.3 & \\hspace{-1em}{\\hred{(-1.2)}} & 81.6 & \\hspace{-1em}{\\hgreen{(+4.2)}} & 84.4 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.4)}} & 87.9 & \\hspace{-1em}{\\hred{(-4.7)}} & 75.6 & \\hspace{-1em}{\\hred{(-0.2)}}\\\\\n", - "Sup ViT-B/16 & SGD (freeze-embed) & 88.0 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & \\textbf{86.3} & \\hspace{-1em}{\\lgreen{(+0.0)}} & 34.4 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{93.7} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+1.2)}}\\\\\n", - "Sup ViT-B/16 & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{82.4} & \\hspace{-1em}{\\hgreen{(+5.0)}} & 82.3 & \\hspace{-1em}{\\hred{(-4.0)}} & 35.7 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.0 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 76.3 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "\\midrule\n", - "DINO ViT-B/16 & SGD & \\textbf{88.2} & & 56.1 & & 76.0 & & 33.6 & & 86.9 & & 68.2 & \\\\\n", - "DINO ViT-B/16 & AdamW & 87.4 & \\hspace{-1em}{\\hred{(-0.8)}} & 61.2 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 77.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & \\textbf{35.8} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 91.9 & \\hspace{-1em}{\\hgreen{(+5.0)}} & 70.7 & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "DINO ViT-B/16 & SGD (freeze-embed) & 86.7 & \\hspace{-1em}{\\hred{(-1.5)}} & \\textbf{67.9} & \\hspace{-1em}{\\hgreen{(+11.8)}} & \\textbf{78.4} & \\hspace{-1em}{\\hgreen{(+2.4)}} & \\textbf{35.9} & \\hspace{-1em}{\\hgreen{(+2.3)}} & 90.6 & \\hspace{-1em}{\\hgreen{(+3.7)}} & \\textbf{71.9} & \\hspace{-1em}{\\hgreen{(+3.7)}}\\\\\n", - "DINO ViT-B/16 & AdamW (freeze-embed) & 86.8 & \\hspace{-1em}{\\hred{(-1.4)}} & 64.5 & \\hspace{-1em}{\\hgreen{(+8.4)}} & 76.6 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 35.4 & \\hspace{-1em}{\\hgreen{(+1.8)}} & \\textbf{93.5} & \\hspace{-1em}{\\hgreen{(+6.6)}} & 71.4 & \\hspace{-1em}{\\hgreen{(+3.2)}}\\\\\n", - "\\midrule\n", - "ConvNext-Base & SGD & \\textbf{94.0} & & 80.2 & & 89.8 & & 39.7 & & 83.0 & & 77.3 & \\\\\n", - "ConvNext-Base & AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & 89.8 & \\hspace{-1em}{\\hgreen{(+9.6)}} & 89.5 & \\hspace{-1em}{\\hred{(-0.3)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & 79.5 & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", - "ConvNext-Base & SGD (freeze-embed) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & \\textbf{91.2} & \\hspace{-1em}{\\hgreen{(+1.4)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 79.4 & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", - "ConvNext-Base & AdamW (freeze-embed) & 88.1 & \\hspace{-1em}{\\hred{(-5.9)}} & \\textbf{91.6} & \\hspace{-1em}{\\hgreen{(+11.4)}} & 89.8 & \\hspace{-1em}{\\lgreen{(+0.0)}} & \\textbf{41.6} & \\hspace{-1em}{\\hgreen{(+1.9)}} & 87.7 & \\hspace{-1em}{\\hgreen{(+4.7)}} & \\textbf{79.8} & \\hspace{-1em}{\\hgreen{(+2.5)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-50 & SGD & \\textbf{84.3} & & 76.5 & & 80.0 & & 34.1 & & 90.4 & & 73.1 & \\\\\n", - "BiT ResNet-50 & AdamW & 83.1 & \\hspace{-1em}{\\hred{(-1.2)}} & 74.8 & \\hspace{-1em}{\\hred{(-1.7)}} & \\textbf{84.0} & \\hspace{-1em}{\\hgreen{(+4.0)}} & 33.8 & \\hspace{-1em}{\\hred{(-0.3)}} & 92.4 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 73.6 & \\hspace{-1em}{\\hgreen{(+0.5)}}\\\\\n", - "BiT ResNet-50 & SGD (freeze-embed) & 84.1 & \\hspace{-1em}{\\hred{(-0.2)}} & 75.5 & \\hspace{-1em}{\\hred{(-1.0)}} & 82.3 & \\hspace{-1em}{\\hgreen{(+2.3)}} & 35.0 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{95.2} & \\hspace{-1em}{\\hgreen{(+4.8)}} & 74.4 & \\hspace{-1em}{\\hgreen{(+1.3)}}\\\\\n", - "BiT ResNet-50 & AdamW (freeze-embed) & 82.9 & \\hspace{-1em}{\\hred{(-1.4)}} & \\textbf{77.3} & \\hspace{-1em}{\\hgreen{(+0.8)}} & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{36.3} & \\hspace{-1em}{\\hgreen{(+2.2)}} & 93.7 & \\hspace{-1em}{\\hgreen{(+3.3)}} & \\textbf{74.7} & \\hspace{-1em}{\\hgreen{(+1.6)}}\\\\\n", - "\\midrule\n", - "BiT ResNet-101 & SGD & 82.8 & & 76.9 & & \\textbf{86.2} & & \\textbf{38.0} & & 89.3 & & 74.6 & \\\\\n", - "BiT ResNet-101 & AdamW & 82.9 & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{79.4} & \\hspace{-1em}{\\hgreen{(+2.5)}} & 83.5 & \\hspace{-1em}{\\hred{(-2.7)}} & 37.0 & \\hspace{-1em}{\\hred{(-1.0)}} & 89.7 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 74.5 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", - "BiT ResNet-101 & SGD (freeze-embed) & 83.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 77.3 & \\hspace{-1em}{\\hgreen{(+0.4)}} & 86.0 & \\hspace{-1em}{\\hred{(-0.2)}} & 36.0 & \\hspace{-1em}{\\hred{(-2.0)}} & \\textbf{95.5} & \\hspace{-1em}{\\hgreen{(+6.2)}} & 75.6 & \\hspace{-1em}{\\hgreen{(+1.0)}}\\\\\n", - "BiT ResNet-101 & AdamW (freeze-embed) & \\textbf{84.8} & \\hspace{-1em}{\\hgreen{(+2.0)}} & 78.3 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 84.3 & \\hspace{-1em}{\\hred{(-1.9)}} & \\textbf{38.2} & \\hspace{-1em}{\\lgreen{(+0.2)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+5.7)}} & \\textbf{76.1} & \\hspace{-1em}{\\hgreen{(+1.5)}}\\\\\n", - "\\bottomrule\n", - "\\end{tabular}\n" - ] - } - ], + "outputs": [], "source": [ "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", @@ -718,18 +435,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[90.25925333 91.46286571 91.27799905 91.48981143]\n", - "[71.9667419 76.03873524 76.73786476 76.46011143]\n" - ] - } - ], + "outputs": [], "source": [ "# Get average ID and OOD results for the 3 methods.\n", "print(np.mean(id_mean_table[:,:,5], axis=0))\n", @@ -794,7 +502,11 @@ "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", - "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", + "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", From 5ab5c47260cefcdc27694c9df92685f461e40fd1 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 13 Nov 2022 23:42:16 -0800 Subject: [PATCH 179/197] Fix typo. --- scripts/freeze-embed-paper-fine-tuning-results.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 6ecbe11..33079ed 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -67,6 +67,7 @@ " agg_metric = aggregation_metric_list[dataset_idx]\n", " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " print(dataset, res)\n", " num_jobs = len(res)\n", " if (desired_epochs_list is not None and\n", " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", @@ -302,7 +303,7 @@ "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", @@ -505,7 +506,7 @@ "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", From 6a7dc5ce28afa4498c72f719ebcab1a4b22a93da Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 13 Nov 2022 23:42:16 -0800 Subject: [PATCH 180/197] Fix typo. --- scripts/freeze-embed-paper-fine-tuning-results.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 6ecbe11..33079ed 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -67,6 +67,7 @@ " agg_metric = aggregation_metric_list[dataset_idx]\n", " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", + " print(dataset, res)\n", " num_jobs = len(res)\n", " if (desired_epochs_list is not None and\n", " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", @@ -302,7 +303,7 @@ "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", @@ -505,7 +506,7 @@ "\n", "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", - "mean_table_old_order, std_table_old_order = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", From bb02830937ec8eef00443c426e0584873f1e8138 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 13 Dec 2022 15:09:39 -0800 Subject: [PATCH 181/197] Add group name, add models. --- ...nalyze_dataset_stats_model_gradients.ipynb | 122 +- ...eeze-embed-paper-fine-tuning-results.ipynb | 2000 ++++++++++++++++- scripts/run_adaptation_experiments.py | 54 + scripts/run_jag10_11_sbatch.sh | 21 + scripts/run_sbatch.sh | 1 + scripts/run_sphinx_big_sbatch.sh | 21 + scripts/run_sphinx_sbatch.sh | 2 +- 7 files changed, 2174 insertions(+), 47 deletions(-) create mode 100644 scripts/run_jag10_11_sbatch.sh create mode 100644 scripts/run_sphinx_big_sbatch.sh diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index f837b93..d7a11f0 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -58,6 +58,7 @@ "source": [ "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "merge_models = ['clip_vit_b16', 'clip_vit_l14','convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "model_display_names = ['clip_b', 'clip_l', 'vit_b', 'dino_b', 'convnext_b', 'resnet50', 'resnet101']\n", "log_root = '../logs/'\n", "\n", @@ -101,19 +102,24 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "living17_nonorm\n" + "living17_nonorm\n", + "train/grad_patch_embed train/grad_ln_pre 7.832826223456222 0.24551549220763905 7.836673050713384\n", + "train/grad_patch_embed train/grad_ln_pre 7.882409921775851 0.1939453432210928 7.884795556707068\n", + "train/grad_stem train/grad_stage0 2.9855660124116703 1.6714600848737493 3.421605358569846\n", + "train/grad_stem train/grad_conv-block-0 3.1797744363503244 5.134835911909651 6.039661025943761\n", + "train/grad_stem train/grad_conv-block-0 3.067531236001276 4.9374460843294825 5.812755088553453\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,12 +133,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "waterbirds\n" + "waterbirds\n", + "train/grad_patch_embed train/grad_ln_pre 7.377456283569336 0.2574999781599999 7.381948757254352\n", + "train/grad_patch_embed train/grad_ln_pre 10.778858884175618 0.2457886140039833 10.78166085942911\n", + "train/grad_stem train/grad_stage0 2.1539545361168058 1.1490996834679277 2.4413009290548873\n", + "train/grad_stem train/grad_conv-block-0 1.7377760092417398 3.5004814195246396 3.9080987227465713\n", + "train/grad_stem train/grad_conv-block-0 2.3392495417594907 4.621618547990456 5.179907954949721\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -146,12 +157,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "domainnet\n" + "domainnet\n", + "train/grad_patch_embed train/grad_ln_pre 14.819977995993076 0.6566372829489773 14.83451786621586\n", + "train/grad_patch_embed train/grad_ln_pre 8.467114253975879 0.2888876401186325 8.472041068036368\n", + "train/grad_stem train/grad_stage0 6.788537111079389 2.5746775567102635 7.260385708041249\n", + "train/grad_stem train/grad_conv-block-0 3.289056084621912 7.2814341256452 7.989816822299426\n", + "train/grad_stem train/grad_conv-block-0 3.4599138361284103 6.826684185454191 7.653405824948992\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,26 +179,71 @@ } ], "source": [ - "def filter_df_get_grad(df):\n", + "def merge_first_2(param_dict, merge_type='norm'):\n", + " keys = list(param_dict.keys())\n", + " k0 = keys[0]\n", + " k1 = keys[1]\n", + " v0 = param_dict[k0]\n", + " v1 = param_dict[k1]\n", + " if merge_type == 'norm':\n", + " param_dict[k0] = np.sqrt(v0**2 + v1**2)\n", + " elif merge_type == 'sum':\n", + " param_dict[k0] = v0 + v1\n", + " else:\n", + " raise ValueError(\"Invalid merge_type\")\n", + " print(k0, k1, v0, v1, param_dict[k0])\n", + " del param_dict[k1]\n", + " \n", + "\n", + "def filter_df_get_grad(df, merge=False):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " df = df[filtered_keys]\n", - " return df.to_dict(orient='records')[0]\n", + " keys_values = df.to_dict(orient='records')[0]\n", + " if merge:\n", + " merge_first_2(keys_values)\n", + " return keys_values\n", "\n", "def filter_df_get_norm(df):\n", " filtered_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", " df = df[filtered_keys]\n", " return df.to_dict(orient='records')[0]\n", "\n", - "def filter_df_get_param_normalized_grad(df):\n", - " filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", - " df = df[filtered_keys]\n", - " return df.to_dict(orient='records')[0]\n", + "def get_num_params(df):\n", + " param_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + " param_dict = df[param_keys].to_dict(orient='records')[0]\n", + " grad_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " grad_dict = df[grad_keys].to_dict(orient='records')[0]\n", + " num_params_dict = {}\n", + " for pk, gk in zip(param_keys, grad_keys):\n", + " npk = gk[:gk.find('grad')] + 'param' + gk[gk.find('grad')+4:]\n", + " num_params_dict[npk] = int(np.round((grad_dict[gk] / param_dict[pk]) ** 2))\n", + " return num_params_dict\n", "\n", - "def filter_df_get_normalized_grad(df):\n", + "def filter_df_get_param_normalized_grad(df, merge=False):\n", + " num_params_dict = get_num_params(df)\n", + " merge_first_2(num_params_dict, merge_type='sum')\n", + " grad_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " grad_dict = df[grad_keys].to_dict(orient='records')[0]\n", + " merge_first_2(grad_dict)\n", + " normalized_dict = {}\n", + " for npk, gk in zip(num_params_dict.keys(), grad_dict.keys()):\n", + " normalized_dict[gk] = grad_dict[gk] / np.sqrt(num_params_dict[npk])\n", + " return normalized_dict\n", + "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + "# df = df[filtered_keys]\n", + "# return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_normalized_grad(df, merge=False):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", " filtered_d = df[filtered_keys].to_dict(orient='records')[0]\n", " norm_d = df[norm_keys].to_dict(orient='records')[0]\n", + " if merge:\n", + " merge_first_2(filtered_d)\n", + " merge_first_2(norm_d)\n", + " filtered_keys = [filtered_keys[0]] + filtered_keys[2:]\n", + " norm_keys = [norm_keys[0]] + norm_keys[2:]\n", + " # Get filtered keys after merge.\n", " normalized_grad_d = {}\n", " for fk, nk in zip(filtered_keys, norm_keys):\n", " normalized_grad_d[fk] = filtered_d[fk] / norm_d[nk]\n", @@ -195,7 +256,7 @@ "\n", "# Get a sorted list of outputs, \n", "\n", - "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", + "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df, merge_models):\n", " dataset_stats = {}\n", " for dataset in datasets:\n", " print(dataset)\n", @@ -215,20 +276,25 @@ "# 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", "# }\n", " df = pd.read_csv(stats_path, sep='\\t')\n", - " d = filter_df(df)\n", + " if model in merge_models:\n", + " d = filter_df(df, merge=True)\n", + " else:\n", + " d = filter_df(df, merge=False)\n", "# print(model)\n", "# print(list(d.keys()))\n", "# print(sorted([(-v, k) for k, v in list(d.items())]))\n", " values = list(d.values())\n", " if model_idx == 1:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers', marker='o')\n", + " plt.scatter([model_idx]*(len(d)-5), values[4:-1], c='black', label='middle layers', marker='o')\n", " plt.scatter([model_idx], values[-1], c='green', label='head layer', marker='^')\n", " plt.scatter([model_idx], values[0], c='red', label='embedding layer', marker='s')\n", " else:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", + " if model_idx <= 3:\n", + " plt.scatter([model_idx]*(len(d)-5), values[4:-1], c='black', marker='o')\n", + " else:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", " plt.scatter([model_idx], values[-1], c='green', marker='^')\n", " plt.scatter([model_idx], values[0], c='red', marker='s')\n", - " my_xticks = ['John','Arnold','Mavis','Matt']\n", " plt.legend()\n", " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", "\n", @@ -240,24 +306,16 @@ "# print(df[compute_keys(df)])\n", "# return dataset_stats\n", "\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad)\n" + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad, merge_models)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad, merge_models)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad, merge_models)\n" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'living17_nonorm': {'mean': 0.405586, 'std': 0.19588944, 'std_mean': 0.105948165}, 'waterbirds': {'mean': 0.37670943, 'std': 0.22946799, 'std_mean': 0.11904866}, 'domainnet': {'mean': 0.8599936, 'std': 0.1735559, 'std_mean': 0.15381968}}\n" - ] - } - ], + "outputs": [], "source": [ "print(dataset_stats)\n", "# The std-devs within the image, and the std devs of the mean, are pretty similar (and small).\n", diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 33079ed..f55cd9c 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +78,6 @@ " agg_metric = aggregation_metric_list[dataset_idx]\n", " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", - " print(dataset, res)\n", " num_jobs = len(res)\n", " if (desired_epochs_list is not None and\n", " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", @@ -287,9 +297,1782 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.8235 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 97.6471 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 98.0000 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 97.7059 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 97.1765 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 97.2353 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 96.8824 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 95.1765 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 95.5882 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 94.0588 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 73.0588 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 74.8235 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 70.7059 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 69.7059 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 71.2941 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 97.4706 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 97.7059 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 96.7059 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 81.4118 \n", + "1 78.7647 \n", + "2 79.7059 \n", + "3 79.8824 \n", + "4 77.0588 \n", + "5 78.0588 \n", + "6 76.0588 \n", + "7 67.2941 \n", + "8 67.5882 \n", + "9 64.7647 \n", + "10 31.9412 \n", + "11 33.5882 \n", + "12 30.5882 \n", + "13 30.6471 \n", + "14 31.7059 \n", + "15 83.8235 \n", + "16 83.1176 \n", + "17 75.0588 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/23xt... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/vdnf... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1hv9... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/oq4g... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2ywr... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2n8e... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/35ic... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/2cqg... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/mcfd... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/18y4... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2at9... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2yr7... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/4wef... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1kfz... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/2eyl... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3mkp... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/24p2... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2v9m... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 96.4352 48.7539 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 96.1016 47.6636 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 95.9652 36.7601 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 94.4102 25.2336 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 95.3812 23.3645 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 91.2967 8.5670 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 92.0223 10.2804 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 92.2794 11.9938 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 89.2976 5.1402 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 88.2076 6.8536 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 88.5881 4.0498 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 89.8418 3.5826 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 89.7166 6.5421 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 89.2625 3.7383 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 89.3853 3.4268 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 97.2577 61.6822 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 97.1104 57.6324 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 97.2989 68.0685 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/21nx... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2ech... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/w69b... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2c46... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/36q9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/p95b... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/242a... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/1pwr... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/2ims... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2txk... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2kyy... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/123f... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3s37... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2dxs... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/3w52... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/39mq... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1nca... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/3lj2... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.1626 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 86.4527 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 86.7028 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 82.1175 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 83.7015 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 83.2430 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 73.3222 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 76.6569 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 74.6561 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 62.5677 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 62.3593 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 64.9437 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 29.8875 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 35.6398 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 29.4706 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 93.2472 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 93.0388 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 80.1167 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 78.7556 https://wandb.ai/p-lambda/finetuning/runs/2nfv... \n", + "1 64.5398 https://wandb.ai/p-lambda/finetuning/runs/8up5... \n", + "2 64.7991 https://wandb.ai/p-lambda/finetuning/runs/63s4... \n", + "3 57.8568 https://wandb.ai/p-lambda/finetuning/runs/uc6x... \n", + "4 59.9885 https://wandb.ai/p-lambda/finetuning/runs/7fo3... \n", + "5 60.1037 https://wandb.ai/p-lambda/finetuning/runs/1ei6... \n", + "6 34.9129 https://wandb.ai/p-lambda/finetuning/runs/2dj0... \n", + "7 37.4190 https://wandb.ai/p-lambda/finetuning/runs/32j3... \n", + "8 38.4128 https://wandb.ai/p-lambda/finetuning/runs/24k1... \n", + "9 21.6765 https://wandb.ai/p-lambda/finetuning/runs/2wgz... \n", + "10 21.9790 https://wandb.ai/p-lambda/finetuning/runs/1ykm... \n", + "11 23.3617 https://wandb.ai/p-lambda/finetuning/runs/2yqb... \n", + "12 11.5944 https://wandb.ai/p-lambda/finetuning/runs/171u... \n", + "13 12.8331 https://wandb.ai/p-lambda/finetuning/runs/1vhn... \n", + "14 11.1335 https://wandb.ai/p-lambda/finetuning/runs/3bcv... \n", + "15 83.8398 https://wandb.ai/p-lambda/finetuning/runs/2uhu... \n", + "16 83.6238 https://wandb.ai/p-lambda/finetuning/runs/1cmw... \n", + "17 50.8714 https://wandb.ai/p-lambda/finetuning/runs/2iam... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 66.9337 65.3678 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 65.0527 63.6103 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 66.1413 64.9561 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 67.8830 65.5084 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 66.2632 64.6950 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 66.7683 64.8104 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 63.3110 60.7432 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 63.6506 61.1097 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 62.5098 60.7381 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 53.3049 50.9114 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 53.9929 51.6646 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 45.8765 43.3241 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 27.7279 24.6397 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 27.0835 24.2732 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 26.4826 24.4389 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 62.5446 61.4562 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 61.6999 60.2109 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 62.2747 61.9081 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 58.5897 36.9456 \n", + "1 57.1377 38.1026 \n", + "2 57.7890 37.0999 \n", + "3 58.4540 36.5600 \n", + "4 57.6352 36.7528 \n", + "5 57.7167 38.7196 \n", + "6 53.7814 35.7115 \n", + "7 53.7769 35.3259 \n", + "8 52.7773 32.2021 \n", + "9 44.1469 28.8083 \n", + "10 43.7670 26.1088 \n", + "11 36.0277 20.9410 \n", + "12 20.8929 13.7293 \n", + "13 19.8752 12.9194 \n", + "14 19.9747 13.0351 \n", + "15 55.8802 38.0640 \n", + "16 54.3378 35.6344 \n", + "17 56.0159 37.6012 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1216... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2ppo... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/qsjv... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2un3... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2b5f... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/e921... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3bdt... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/11ws... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1yhv... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/1m5g... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2kp0... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2kuy... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3i5d... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2iad... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/24wq... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/2d4r... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1jhk... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2b8g... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.3772 89.6602 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 99.3683 91.9092 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 99.3951 91.7316 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 99.1746 83.5320 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 99.0793 79.4379 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 99.0703 85.8240 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 98.7664 82.1854 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 98.7455 84.0248 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 98.3343 79.7874 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 98.2926 77.2089 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 98.3105 77.0284 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 98.3045 75.3610 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 98.1913 78.8935 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 98.2896 77.7103 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 97.9827 68.7428 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 99.3117 94.1239 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 99.2729 93.1297 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 99.1836 89.9524 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 85.8890 https://wandb.ai/p-lambda/finetuning/runs/3lgv... \n", + "1 88.0782 https://wandb.ai/p-lambda/finetuning/runs/9g01... \n", + "2 86.4192 https://wandb.ai/p-lambda/finetuning/runs/35sq... \n", + "3 69.5358 https://wandb.ai/p-lambda/finetuning/runs/3d0i... \n", + "4 68.4130 https://wandb.ai/p-lambda/finetuning/runs/37g3... \n", + "5 66.8152 https://wandb.ai/p-lambda/finetuning/runs/3cnf... \n", + "6 51.8812 https://wandb.ai/p-lambda/finetuning/runs/3ob1... \n", + "7 55.9492 https://wandb.ai/p-lambda/finetuning/runs/ffkb... \n", + "8 66.4225 https://wandb.ai/p-lambda/finetuning/runs/7roy... \n", + "9 48.2023 https://wandb.ai/p-lambda/finetuning/runs/2fap... \n", + "10 55.2919 https://wandb.ai/p-lambda/finetuning/runs/2931... \n", + "11 56.0079 https://wandb.ai/p-lambda/finetuning/runs/2gpp... \n", + "12 49.3604 https://wandb.ai/p-lambda/finetuning/runs/aydg... \n", + "13 65.4255 https://wandb.ai/p-lambda/finetuning/runs/28jo... \n", + "14 65.1398 https://wandb.ai/p-lambda/finetuning/runs/10v5... \n", + "15 94.1073 https://wandb.ai/p-lambda/finetuning/runs/2x55... \n", + "16 94.0614 https://wandb.ai/p-lambda/finetuning/runs/3rtu... \n", + "17 86.5039 https://wandb.ai/p-lambda/finetuning/runs/6wx0... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 82.5294 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 74.4118 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 74.1176 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 98.1176 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 97.8824 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 97.8824 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 97.6471 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 97.8824 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 98.2941 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 97.3529 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 96.8235 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 96.5882 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 98.0588 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 98.0588 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 98.1765 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 96.9412 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 97.2941 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 97.8235 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 41.5294 \n", + "1 34.3529 \n", + "2 34.2941 \n", + "3 81.5294 \n", + "4 79.7059 \n", + "5 80.4118 \n", + "6 84.1765 \n", + "7 82.9412 \n", + "8 83.7059 \n", + "9 78.1176 \n", + "10 74.5294 \n", + "11 75.2941 \n", + "12 84.1765 \n", + "13 81.7647 \n", + "14 82.4706 \n", + "15 82.8824 \n", + "16 83.0000 \n", + "17 83.7647 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/bxpw... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/21xk... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3nio... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2f58... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/xnsv... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2dtz... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/320l... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/icog... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/2q6p... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2fhj... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3kfd... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/1ryy... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/1czo... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2e0r... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/3hxw... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/107a... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/14jd... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/1dl4... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 89.5521 2.8037 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 89.9072 6.2305 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 88.8488 5.4517 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.9436 69.3146 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 97.4628 66.6667 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 97.6901 68.5358 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 97.3885 67.2897 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 97.3596 70.7165 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 97.6066 64.1745 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 97.0159 53.5826 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 96.7293 43.6137 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 96.9287 48.5981 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 97.7807 69.3146 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 97.7180 74.2991 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 97.7429 71.9626 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 96.8930 56.8536 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 97.0290 67.6012 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 97.2621 64.4860 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1q9q... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2pim... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/i3p7... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/6jgf... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/epno... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3bkh... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/7jaa... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/18r2... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3p0v... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/30gn... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3dv5... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/lejn... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/2a7x... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2xwh... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/4t60... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/1eam... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/18yv... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/1p12... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 52.9804 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 33.5556 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 40.3918 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 94.5394 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 94.6644 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 94.0392 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 94.3310 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 94.1642 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 93.4973 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 91.0796 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 91.2047 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 90.8712 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 95.0396 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 94.9145 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 95.0396 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 92.2468 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 91.9133 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 91.9967 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 16.9811 https://wandb.ai/p-lambda/finetuning/runs/232h... \n", + "1 11.7817 https://wandb.ai/p-lambda/finetuning/runs/2sx2... \n", + "2 13.2220 https://wandb.ai/p-lambda/finetuning/runs/3i7o... \n", + "3 88.5352 https://wandb.ai/p-lambda/finetuning/runs/1wdb... \n", + "4 88.9241 https://wandb.ai/p-lambda/finetuning/runs/p66t... \n", + "5 88.0455 https://wandb.ai/p-lambda/finetuning/runs/kemg... \n", + "6 85.1937 https://wandb.ai/p-lambda/finetuning/runs/h6og... \n", + "7 84.1567 https://wandb.ai/p-lambda/finetuning/runs/sw9z... \n", + "8 85.3810 https://wandb.ai/p-lambda/finetuning/runs/1hc8... \n", + "9 75.6589 https://wandb.ai/p-lambda/finetuning/runs/3ue3... \n", + "10 76.4799 https://wandb.ai/p-lambda/finetuning/runs/3gl6... \n", + "11 78.2947 https://wandb.ai/p-lambda/finetuning/runs/t7sx... \n", + "12 90.5516 https://wandb.ai/p-lambda/finetuning/runs/1gon... \n", + "13 88.6216 https://wandb.ai/p-lambda/finetuning/runs/318v... \n", + "14 88.3336 https://wandb.ai/p-lambda/finetuning/runs/12xq... \n", + "15 82.2699 https://wandb.ai/p-lambda/finetuning/runs/4ndp... \n", + "16 81.3769 https://wandb.ai/p-lambda/finetuning/runs/12m4... \n", + "17 81.6938 https://wandb.ai/p-lambda/finetuning/runs/37vl... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 33.5452 30.7658 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 34.5728 32.1818 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 35.5221 33.1860 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 70.2778 67.7831 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 69.8424 67.5370 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 70.2343 68.0542 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 62.6578 61.0545 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 62.2921 60.5172 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 62.0482 61.0495 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 68.3968 66.0507 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 68.5535 66.2064 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 68.9280 66.2315 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 67.7872 65.5687 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 68.1094 65.7695 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 68.5100 66.0357 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 47.9666 48.1195 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 47.3570 46.7386 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 48.0624 47.9588 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 25.9499 17.0459 \n", + "1 26.7595 16.5831 \n", + "2 27.3430 16.9688 \n", + "3 61.5298 40.8407 \n", + "4 60.8196 40.8793 \n", + "5 61.3850 40.2622 \n", + "6 55.1294 37.6398 \n", + "7 54.2699 36.7914 \n", + "8 55.6902 37.9869 \n", + "9 58.9696 38.1797 \n", + "10 59.0058 39.2981 \n", + "11 58.7977 38.1026 \n", + "12 58.6665 38.4882 \n", + "13 59.0646 41.8049 \n", + "14 59.2772 41.1107 \n", + "15 43.7896 32.0478 \n", + "16 42.0843 29.4639 \n", + "17 43.4006 31.8936 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ctt... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2c18... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/dcqz... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1ft8... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2kb5... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/24m2... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/m7tk... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/50fj... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/92oa... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/3jhw... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2reh... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3jb3... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/xmr9... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/amzd... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1z3l... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3b7x... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/zty5... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/ga5d... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4237 78.4065 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 98.3045 79.9851 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 97.5387 76.1517 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 99.4458 91.2102 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 99.4160 91.2847 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 99.4190 89.3594 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 99.4249 94.7886 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 99.5143 93.6110 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 99.5083 94.2757 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 99.1359 87.5659 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 98.9988 84.8413 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 98.6323 79.1342 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 99.5679 94.3474 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 99.5322 94.4734 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 99.5352 93.7514 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 99.2878 94.5479 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 99.2938 92.8547 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 99.3117 92.5940 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 63.7560 https://wandb.ai/p-lambda/finetuning/runs/2zux... \n", + "1 61.7337 https://wandb.ai/p-lambda/finetuning/runs/umt6... \n", + "2 59.0942 https://wandb.ai/p-lambda/finetuning/runs/3pci... \n", + "3 91.5183 https://wandb.ai/p-lambda/finetuning/runs/8eai... \n", + "4 92.0686 https://wandb.ai/p-lambda/finetuning/runs/2d88... \n", + "5 93.1032 https://wandb.ai/p-lambda/finetuning/runs/11gy... \n", + "6 96.6010 https://wandb.ai/p-lambda/finetuning/runs/183o... \n", + "7 95.6216 https://wandb.ai/p-lambda/finetuning/runs/e8e7... \n", + "8 96.6798 https://wandb.ai/p-lambda/finetuning/runs/10zp... \n", + "9 81.5952 https://wandb.ai/p-lambda/finetuning/runs/2g31... \n", + "10 82.3700 https://wandb.ai/p-lambda/finetuning/runs/2v1i... \n", + "11 64.1933 https://wandb.ai/p-lambda/finetuning/runs/17xu... \n", + "12 95.9720 https://wandb.ai/p-lambda/finetuning/runs/3bn2... \n", + "13 95.1819 https://wandb.ai/p-lambda/finetuning/runs/23om... \n", + "14 96.0237 https://wandb.ai/p-lambda/finetuning/runs/2v57... \n", + "15 94.0403 https://wandb.ai/p-lambda/finetuning/runs/2502... \n", + "16 94.8492 https://wandb.ai/p-lambda/finetuning/runs/14ml... \n", + "17 94.7986 https://wandb.ai/p-lambda/finetuning/runs/36bk... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "living17_nonorm name \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 97.8235 83.7647 \n", + "1 98.3529 82.1765 \n", + "2 98.2941 83.5882 \n", + "3 98.1176 80.7059 \n", + "4 97.8824 81.8235 \n", + "5 98.1765 81.0000 \n", + "6 97.8824 79.4706 \n", + "7 97.8235 77.1765 \n", + "8 97.4706 78.1765 \n", + "9 97.2353 74.1176 \n", + "10 95.7059 69.5882 \n", + "11 95.7059 71.1765 \n", + "12 94.5882 63.7647 \n", + "13 88.9412 50.7647 \n", + "14 87.4706 47.5294 \n", + "15 97.7059 84.1765 \n", + "16 97.8235 82.4118 \n", + "17 98.2353 84.1176 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/cjnc... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/37b2... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/168z... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2sg5... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3df8... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2sgu... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2bmu... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/3jd6... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3ayf... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/24mp... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/151t... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/338h... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/1e4k... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1ooi... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/meox... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/23jc... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/30ne... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2zk0... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "waterbirds name WATERBIRDS_VAL \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.6151 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.7998 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.6586 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.8519 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.8297 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.7370 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.7858 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.2823 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.4715 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 96.2965 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 96.4551 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.0653 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 90.0736 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 90.7563 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.3953 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.3644 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.1726 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.3713 \n", + "\n", + " WORST wandb_url \\\n", + "0 71.9626 https://wandb.ai/p-lambda/finetuning/runs/2w3y... \n", + "1 75.8567 https://wandb.ai/p-lambda/finetuning/runs/2qf0... \n", + "2 67.7570 https://wandb.ai/p-lambda/finetuning/runs/1zf0... \n", + "3 73.0530 https://wandb.ai/p-lambda/finetuning/runs/3z79... \n", + "4 73.0530 https://wandb.ai/p-lambda/finetuning/runs/3hg2... \n", + "5 75.0779 https://wandb.ai/p-lambda/finetuning/runs/j7im... \n", + "6 66.9782 https://wandb.ai/p-lambda/finetuning/runs/3e8b... \n", + "7 71.0280 https://wandb.ai/p-lambda/finetuning/runs/kqer... \n", + "8 57.7882 https://wandb.ai/p-lambda/finetuning/runs/3tte... \n", + "9 40.4984 https://wandb.ai/p-lambda/finetuning/runs/1h6c... \n", + "10 46.8847 https://wandb.ai/p-lambda/finetuning/runs/102j... \n", + "11 13.2399 https://wandb.ai/p-lambda/finetuning/runs/2ckq... \n", + "12 9.6573 https://wandb.ai/p-lambda/finetuning/runs/208v... \n", + "13 5.6075 https://wandb.ai/p-lambda/finetuning/runs/3mci... \n", + "14 9.3458 https://wandb.ai/p-lambda/finetuning/runs/4p8p... \n", + "15 67.2897 https://wandb.ai/p-lambda/finetuning/runs/17ng... \n", + "16 72.2741 https://wandb.ai/p-lambda/finetuning/runs/522l... \n", + "17 73.5202 https://wandb.ai/p-lambda/finetuning/runs/156a... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "domainnet name test_acc/sketch_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 95.1647 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 94.6228 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 94.9562 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.4977 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.5394 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.4977 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 90.7461 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 90.3710 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 92.3718 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 84.1601 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 85.5356 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 85.7024 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 70.9045 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 68.8203 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 66.9862 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 93.9975 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 94.2476 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 94.1226 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 89.0249 https://wandb.ai/p-lambda/finetuning/runs/1hdc... \n", + "1 88.0743 https://wandb.ai/p-lambda/finetuning/runs/3m8c... \n", + "2 87.5846 https://wandb.ai/p-lambda/finetuning/runs/31rn... \n", + "3 87.4838 https://wandb.ai/p-lambda/finetuning/runs/1vfm... \n", + "4 86.7780 https://wandb.ai/p-lambda/finetuning/runs/2uic... \n", + "5 89.0249 https://wandb.ai/p-lambda/finetuning/runs/3meu... \n", + "6 72.2886 https://wandb.ai/p-lambda/finetuning/runs/3ea0... \n", + "7 76.2207 https://wandb.ai/p-lambda/finetuning/runs/dp9h... \n", + "8 75.6157 https://wandb.ai/p-lambda/finetuning/runs/b7nx... \n", + "9 54.9906 https://wandb.ai/p-lambda/finetuning/runs/3leh... \n", + "10 58.0009 https://wandb.ai/p-lambda/finetuning/runs/3gge... \n", + "11 56.0853 https://wandb.ai/p-lambda/finetuning/runs/1nu1... \n", + "12 32.6228 https://wandb.ai/p-lambda/finetuning/runs/2qr4... \n", + "13 30.6640 https://wandb.ai/p-lambda/finetuning/runs/c1ft... \n", + "14 29.8574 https://wandb.ai/p-lambda/finetuning/runs/wsxh... \n", + "15 85.5250 https://wandb.ai/p-lambda/finetuning/runs/rq4v... \n", + "16 84.6464 https://wandb.ai/p-lambda/finetuning/runs/33zi... \n", + "17 86.0291 https://wandb.ai/p-lambda/finetuning/runs/yjxd... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.4577 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.5013 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.7712 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 70.2604 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 69.9643 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 69.7814 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 69.6247 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 68.4926 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 68.8148 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.1311 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.4533 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.0962 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 53.3397 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 48.2714 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 53.8361 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 64.0512 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 63.8857 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 63.7551 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 66.3871 59.8471 39.7995 \n", + "1 65.8197 58.8294 39.7609 \n", + "2 66.0909 59.0601 40.3008 \n", + "3 67.7128 60.8422 39.5681 \n", + "4 66.8391 59.9602 39.9923 \n", + "5 67.2458 60.5527 40.9950 \n", + "6 66.5328 59.5893 38.1797 \n", + "7 65.9352 59.0827 35.9815 \n", + "8 66.5478 59.2953 38.1026 \n", + "9 62.9224 55.6767 35.6344 \n", + "10 62.5860 55.0887 34.8631 \n", + "11 62.8722 55.1746 34.1689 \n", + "12 50.7256 44.1514 30.3509 \n", + "13 44.7703 37.7510 23.9491 \n", + "14 51.9257 43.8936 25.1446 \n", + "15 62.0587 55.4641 36.9456 \n", + "16 61.6621 54.8534 37.2541 \n", + "17 61.9382 55.9028 37.7169 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3eni... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2sgj... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3tel... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1cr0... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1hvg... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3lh6... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/w8ll... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/rwap... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3kbr... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2s21... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/1glt... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3iis... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/rw88... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/18ab... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1pou... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/o8u7... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1dyr... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/iqb4... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5143 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5083 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5203 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5322 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5173 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5292 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.4458 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.3802 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.4219 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.2223 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 97.6698 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.6532 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.8784 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.9082 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.9350 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4398 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.3534 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4547 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.8802 94.8797 \n", + "1 93.0753 95.7274 \n", + "2 94.0952 96.1495 \n", + "3 93.7858 93.9603 \n", + "4 93.1555 94.6446 \n", + "5 93.3102 94.2683 \n", + "6 91.5683 89.2656 \n", + "7 91.4021 92.6952 \n", + "8 91.6055 90.1968 \n", + "9 85.6177 69.5993 \n", + "10 79.7043 70.1695 \n", + "11 79.2603 63.3668 \n", + "12 72.2381 58.2947 \n", + "13 76.4096 56.8027 \n", + "14 77.0284 68.2390 \n", + "15 94.0007 95.9567 \n", + "16 94.5966 94.4659 \n", + "17 93.7342 95.9073 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/niyx... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3pj2... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3pqw... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1rxa... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/247u... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/ujrs... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/1smz... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/23j5... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1qtj... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/42jz... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/m57o... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3oov... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3iew... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/3qxp... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1i5f... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/wuhs... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/37r8... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2rqw... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "living17_nonorm name \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 98.1765 80.4706 \n", + "1 98.3529 83.0000 \n", + "2 97.9412 79.3529 \n", + "3 98.1765 83.4706 \n", + "4 98.1765 85.7059 \n", + "5 98.0588 84.4118 \n", + "6 97.8235 87.6471 \n", + "7 97.7647 87.6471 \n", + "8 97.7647 87.7059 \n", + "9 98.2353 81.8824 \n", + "10 98.2941 81.8235 \n", + "11 98.4118 82.0000 \n", + "12 98.0588 85.5294 \n", + "13 98.0000 86.4706 \n", + "14 97.9412 86.1765 \n", + "15 97.3529 86.6471 \n", + "16 97.1765 87.4118 \n", + "17 97.4118 87.2941 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3002... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/137p... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/in9f... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1vca... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/wec9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3rqg... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/33lf... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/uspk... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/229d... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2moq... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/1a5r... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2sxl... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3fdk... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1wgh... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/2dox... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3n5n... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/3kdx... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2auy... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds name WATERBIRDS_VAL \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.2763 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.2581 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.3464 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 98.0542 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 97.8983 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 97.9775 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.3154 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.3131 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.2459 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.2068 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.1980 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.0882 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.5852 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.4949 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.5619 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.8196 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.9204 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.9769 \n", + "\n", + " WORST wandb_url \\\n", + "0 71.4953 https://wandb.ai/p-lambda/finetuning/runs/2be5... \n", + "1 64.9533 https://wandb.ai/p-lambda/finetuning/runs/3s7t... \n", + "2 70.7165 https://wandb.ai/p-lambda/finetuning/runs/w5h7... \n", + "3 76.1682 https://wandb.ai/p-lambda/finetuning/runs/qaxr... \n", + "4 78.6604 https://wandb.ai/p-lambda/finetuning/runs/1ss9... \n", + "5 77.5701 https://wandb.ai/p-lambda/finetuning/runs/15wn... \n", + "6 72.4299 https://wandb.ai/p-lambda/finetuning/runs/23pq... \n", + "7 71.9626 https://wandb.ai/p-lambda/finetuning/runs/93k6... \n", + "8 70.0935 https://wandb.ai/p-lambda/finetuning/runs/28g3... \n", + "9 76.0125 https://wandb.ai/p-lambda/finetuning/runs/76s1... \n", + "10 74.1433 https://wandb.ai/p-lambda/finetuning/runs/1bos... \n", + "11 65.8879 https://wandb.ai/p-lambda/finetuning/runs/3b9z... \n", + "12 74.2991 https://wandb.ai/p-lambda/finetuning/runs/3n5j... \n", + "13 76.4798 https://wandb.ai/p-lambda/finetuning/runs/1r58... \n", + "14 75.0779 https://wandb.ai/p-lambda/finetuning/runs/21mt... \n", + "15 52.0249 https://wandb.ai/p-lambda/finetuning/runs/veh2... \n", + "16 53.8941 https://wandb.ai/p-lambda/finetuning/runs/2adf... \n", + "17 51.4019 https://wandb.ai/p-lambda/finetuning/runs/2mlb... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.4981 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.4148 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.2897 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.2901 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.4152 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.2068 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.3722 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.2472 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.2889 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 95.8733 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 96.0817 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 95.8733 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.8733 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.8316 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.9566 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 73.9892 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 76.1984 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 74.6144 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 92.1504 https://wandb.ai/p-lambda/finetuning/runs/1983... \n", + "1 92.0784 https://wandb.ai/p-lambda/finetuning/runs/1r6b... \n", + "2 92.6257 https://wandb.ai/p-lambda/finetuning/runs/26mi... \n", + "3 93.2882 https://wandb.ai/p-lambda/finetuning/runs/1s2w... \n", + "4 93.4898 https://wandb.ai/p-lambda/finetuning/runs/1noz... \n", + "5 92.9425 https://wandb.ai/p-lambda/finetuning/runs/3iz4... \n", + "6 86.3172 https://wandb.ai/p-lambda/finetuning/runs/2kp2... \n", + "7 84.9057 https://wandb.ai/p-lambda/finetuning/runs/8f3c... \n", + "8 87.5702 https://wandb.ai/p-lambda/finetuning/runs/2wkl... \n", + "9 93.3602 https://wandb.ai/p-lambda/finetuning/runs/2x9b... \n", + "10 93.5042 https://wandb.ai/p-lambda/finetuning/runs/360e... \n", + "11 93.6483 https://wandb.ai/p-lambda/finetuning/runs/3d9r... \n", + "12 91.7615 https://wandb.ai/p-lambda/finetuning/runs/14v9... \n", + "13 91.7759 https://wandb.ai/p-lambda/finetuning/runs/33oz... \n", + "14 92.2656 https://wandb.ai/p-lambda/finetuning/runs/195b... \n", + "15 52.9598 https://wandb.ai/p-lambda/finetuning/runs/2r8a... \n", + "16 58.0153 https://wandb.ai/p-lambda/finetuning/runs/1f92... \n", + "17 55.3363 https://wandb.ai/p-lambda/finetuning/runs/cgzl... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 68.6493 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 69.4418 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 69.5027 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 67.5956 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 66.7334 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 66.2893 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 45.5891 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 39.3800 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 40.4163 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 68.9628 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 69.1544 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 68.9367 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 62.4314 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 59.0090 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 58.3558 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 23.6088 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 21.6494 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 21.4839 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 65.6591 59.3134 41.5735 \n", + "1 66.9295 60.0461 40.8022 \n", + "2 67.1152 60.2633 39.0282 \n", + "3 65.5185 59.8109 40.3779 \n", + "4 64.4439 58.5218 39.7609 \n", + "5 64.5443 58.9244 40.1851 \n", + "6 47.1906 42.6904 30.5438 \n", + "7 40.7130 35.5754 23.4477 \n", + "8 41.2202 36.2086 24.9518 \n", + "9 66.9947 61.0232 42.3833 \n", + "10 66.5177 60.3311 39.8766 \n", + "11 66.6282 60.6161 38.4111 \n", + "12 61.2202 55.3781 37.5241 \n", + "13 57.8458 52.7637 35.5573 \n", + "14 57.6852 52.6325 35.2873 \n", + "15 26.1562 20.8115 16.4288 \n", + "16 23.8263 18.9072 14.7320 \n", + "17 23.7409 18.5453 14.9248 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/249d... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2b0j... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3aek... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/3nxd... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2lv5... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/wsc5... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2sb5... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/1qvv... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1zop... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2crw... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3lpx... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2bqh... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/24it... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2ir8... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/hq0o... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/1wmr... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/ask4... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/236v... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 99.1597 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 99.0256 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.7217 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.2610 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.1329 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.3325 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.6442 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.6591 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.7455 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.3355 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.1895 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.2819 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 99.0495 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 98.9809 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 99.1418 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8337 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8456 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8546 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.2041 95.9355 \n", + "1 94.9003 95.2195 \n", + "2 92.6828 94.8891 \n", + "3 93.7887 94.7645 \n", + "4 94.3932 93.6146 \n", + "5 93.8775 92.7552 \n", + "6 92.7687 95.4511 \n", + "7 92.2273 95.2183 \n", + "8 92.0124 95.3383 \n", + "9 95.1152 96.9361 \n", + "10 94.1697 96.1812 \n", + "11 95.1553 96.3270 \n", + "12 92.9693 95.4735 \n", + "13 92.7515 94.6940 \n", + "14 92.5166 95.1066 \n", + "15 92.8232 94.6481 \n", + "16 93.0810 94.7986 \n", + "17 93.0151 94.8527 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3aew... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3pgh... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1zp9... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2ktv... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3179... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/rnel... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3k6b... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/9f0p... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3se2... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/3kzy... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3d3p... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/17fj... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3u8y... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/34un... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1xmj... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/2iqx... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/35hv... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/3bvu... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.1176 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 98.1765 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 96.2353 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.2353 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 91.4118 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 96.0000 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 71.2353 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 83.5882 \n", + "1 79.5294 \n", + "2 70.8235 \n", + "3 84.1765 \n", + "4 74.8824 \n", + "5 84.7059 \n", + "6 77.8824 \n", + "7 56.5294 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/138g... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2lqs... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/185g... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2o2z... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1ufa... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/qyz8... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3kg7... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/3ofw... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.7633 64.0187 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 97.7132 65.1090 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 95.9931 30.6854 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 96.8696 57.7882 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 78.0727 0.0000 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.2860 66.8224 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 95.3479 14.3302 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 76.7741 0.0000 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2lvy... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2htp... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1xf9... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/37yi... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1vwm... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/273s... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/bfpd... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/x0nb... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.1230 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 93.5807 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 89.2872 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 91.2880 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 32.2634 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 67.9867 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 9.0038 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 90.3644 https://wandb.ai/p-lambda/finetuning/runs/3tyw... \n", + "1 85.2801 https://wandb.ai/p-lambda/finetuning/runs/2k27... \n", + "2 70.1858 https://wandb.ai/p-lambda/finetuning/runs/wosn... \n", + "3 79.0580 https://wandb.ai/p-lambda/finetuning/runs/11o5... \n", + "4 16.3906 https://wandb.ai/p-lambda/finetuning/runs/1cib... \n", + "5 83.9263 https://wandb.ai/p-lambda/finetuning/runs/242n... \n", + "6 47.9908 https://wandb.ai/p-lambda/finetuning/runs/2cu3... \n", + "7 6.0493 https://wandb.ai/p-lambda/finetuning/runs/a1ev... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-06 \n", + "5 optimizer.args.lr-3e-05 \n", + "6 optimizer.args.lr-3e-06 \n", + "7 optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 67.9178 66.1863 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 47.3918 47.9538 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 15.7624 17.8509 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 62.4924 61.0244 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 26.6394 28.8024 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 11.1382 11.9407 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 59.2365 38.7582 \n", + "1 43.8484 32.2792 \n", + "2 12.8686 7.2503 \n", + "3 55.2108 37.6012 \n", + "4 23.6928 15.9661 \n", + "5 9.2093 1.9283 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1c88... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2hzp... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2elk... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/ryko... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3ifo... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/35s8... optimizer.args.lr-3e-07 \n", + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.5232 93.3818 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.3176 94.6883 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.1943 91.3849 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.4815 94.1955 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.9869 92.4622 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 96.2992 92.8747 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 93.3948 https://wandb.ai/p-lambda/finetuning/runs/3nvc... \n", + "1 95.3406 https://wandb.ai/p-lambda/finetuning/runs/1p4m... \n", + "2 91.7688 https://wandb.ai/p-lambda/finetuning/runs/1z8r... \n", + "3 96.1613 https://wandb.ai/p-lambda/finetuning/runs/wr9d... \n", + "4 92.1779 https://wandb.ai/p-lambda/finetuning/runs/gj7w... \n", + "5 93.8933 https://wandb.ai/p-lambda/finetuning/runs/2tdk... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.5882 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 97.3529 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 95.8235 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.4706 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 92.8235 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.7059 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 96.3529 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 74.5294 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 81.3529 \n", + "1 79.8824 \n", + "2 67.6471 \n", + "3 84.8235 \n", + "4 79.3529 \n", + "5 83.8824 \n", + "6 80.8235 \n", + "7 63.6471 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1rvf... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/1k06... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2lm1... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/14j4... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2j6q... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1lry... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3ebz... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/ljkn... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 96.3042 44.2368 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 95.0043 20.0935 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 89.5186 3.7383 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 96.9109 56.5421 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 78.5911 0.0000 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.1196 48.5981 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 95.7925 21.6511 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 76.8178 0.0000 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2fuj... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3s5h... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/bk9a... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1dtz... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3esy... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1p3r... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2t2e... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/eff9... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.1626 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 83.3681 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 72.6553 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 91.4965 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 27.7199 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 93.2472 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 21.5090 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 9.1288 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 78.7556 https://wandb.ai/p-lambda/finetuning/runs/6xuy... \n", + "1 63.5892 https://wandb.ai/p-lambda/finetuning/runs/13jn... \n", + "2 34.8408 https://wandb.ai/p-lambda/finetuning/runs/2izf... \n", + "3 80.2535 https://wandb.ai/p-lambda/finetuning/runs/nbzx... \n", + "4 14.0285 https://wandb.ai/p-lambda/finetuning/runs/2c5l... \n", + "5 83.8398 https://wandb.ai/p-lambda/finetuning/runs/bmfh... \n", + "6 8.8434 https://wandb.ai/p-lambda/finetuning/runs/wlgh... \n", + "7 6.3949 https://wandb.ai/p-lambda/finetuning/runs/1rkr... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-06 \n", + "5 optimizer.args.lr-3e-05 \n", + "6 optimizer.args.lr-3e-06 \n", + "7 optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 66.9860 65.7243 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 47.3134 48.0191 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 14.7087 16.5051 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 60.7942 59.9749 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 23.8352 26.1913 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 10.9989 11.8303 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 58.9289 38.6425 \n", + "1 43.1925 31.7007 \n", + "2 12.2490 6.7104 \n", + "3 54.4102 37.7169 \n", + "4 21.2593 14.6548 \n", + "5 9.2093 1.8897 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/4m5k... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/38yn... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2shg... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/20v2... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3fra... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/fmd3... optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.2193 85.9844 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.1806 94.0694 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.4118 89.9353 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.3445 94.1124 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.9273 91.0411 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 96.9249 91.2073 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 75.9976 https://wandb.ai/p-lambda/finetuning/runs/2hlj... \n", + "1 94.2683 https://wandb.ai/p-lambda/finetuning/runs/uaha... \n", + "2 89.2750 https://wandb.ai/p-lambda/finetuning/runs/1lmq... \n", + "3 93.2843 https://wandb.ai/p-lambda/finetuning/runs/2km8... \n", + "4 91.7335 https://wandb.ai/p-lambda/finetuning/runs/2wbk... \n", + "5 92.4272 https://wandb.ai/p-lambda/finetuning/runs/2ja1... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", + "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -301,9 +2084,9 @@ "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", - "mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "# mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", @@ -489,28 +2272,153 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3\t98.3\t96.3\t69.2\t99.3\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2\t97.8\t95.1\t67.9\t99.5\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7\t97.1\t93.2\t67.0\t99.3\t90.9\n", + "CLIP ViT-B/16\tSGD (Freeze-embed, not layer-norm)\t98.0\t98.0\t95.4\t70.2\t99.5\t92.2\n", + "CLIP ViT-B/16\tSGD (no momentum)\t98.0\t97.1\t89.5\t66.4\t99.3\t90.1\n", + "CLIP ViT-B/16\tSGD (weight decay)\t97.6\t97.2\t87.9\t66.4\t99.3\t89.7\n", + "CLIP ViT-B/16\tSGD (lower LR, embed layer)\t98.0\t97.5\t94.8\t68.7\t99.5\t91.7\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "AdamW & 98.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "SGD (Freeze-embed, not layer-norm) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 98.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 95.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{70.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "SGD (no momentum) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 89.5 & \\hspace{-1em}{\\hgreen{(+0.7)}} & 66.4 & \\hspace{-1em}{\\hred{(-0.6)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.1 & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "SGD (weight decay) & 97.6 & \\hspace{-1em}{\\hred{(-0.2)}} & 97.2 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 87.9 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.4 & \\hspace{-1em}{\\hred{(-0.6)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 89.7 & \\hspace{-1em}{\\hred{(-0.3)}}\\\\\n", + "SGD (lower LR, embed layer) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 94.8 & \\hspace{-1em}{\\hgreen{(+6.0)}} & 68.7 & \\hspace{-1em}{\\hgreen{(+1.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9\t69.1\t93.2\t40.5\t96.5\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5\t64.0\t90.4\t38.8\t93.4\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9\t48.6\t83.8\t38.6\t93.3\t69.6\n", + "CLIP ViT-B/16\tSGD (Freeze-embed, not layer-norm)\t83.6\t74.3\t89.1\t39.3\t92.9\t75.9\n", + "CLIP ViT-B/16\tSGD (no momentum)\t81.4\t59.2\t76.7\t37.9\t84.3\t67.9\n", + "CLIP ViT-B/16\tSGD (weight decay)\t83.9\t65.1\t67.5\t37.1\t85.6\t67.8\n", + "CLIP ViT-B/16\tSGD (lower LR, embed layer)\t83.3\t71.7\t85.7\t38.7\t95.7\t75.0\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & 83.2 & \\hspace{-1em}{\\hgreen{(+3.2)}} & 73.7 & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "SGD (Freeze-embed, not layer-norm) & 83.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{74.3} & \\hspace{-1em}{\\hgreen{(+11.8)}} & 89.1 & \\hspace{-1em}{\\hgreen{(+16.3)}} & 39.3 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 92.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "SGD (no momentum) & 81.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 59.2 & \\hspace{-1em}{\\hred{(-3.3)}} & 76.7 & \\hspace{-1em}{\\hgreen{(+3.9)}} & 37.9 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 84.3 & \\hspace{-1em}{\\hred{(-2.5)}} & 67.9 & \\hspace{-1em}{\\lgreen{(+0.0)}}\\\\\n", + "SGD (weight decay) & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 65.1 & \\hspace{-1em}{\\hgreen{(+2.6)}} & 67.5 & \\hspace{-1em}{\\hred{(-5.3)}} & 37.1 & \\hspace{-1em}{\\lred{(-0.2)}} & 85.6 & \\hspace{-1em}{\\hred{(-1.2)}} & 67.8 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "SGD (lower LR, embed layer) & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & 71.7 & \\hspace{-1em}{\\hgreen{(+9.2)}} & 85.7 & \\hspace{-1em}{\\hgreen{(+12.9)}} & 38.7 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & 75.0 & \\hspace{-1em}{\\hgreen{(+7.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ],\n", + " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", + " 99.5262 , 92.22186 ],\n", + " [98. , 97.071 , 89.5373 , 66.3764 ,\n", + " 99.3236 , 90.06166 ],\n", + " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", + " 99.2938 , 89.6767 ],\n", + " [98. , 97.5392 , 94.7895 , 68.6841 ,\n", + " 99.5113 , 91.70482 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ],\n", + " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", + " 92.941 , 75.85068 ],\n", + " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", + " 84.2829 , 67.88824 ],\n", + " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", + " 85.5645 , 67.8308 ],\n", + " [83.2941 , 71.6511 , 85.6834 , 38.7196 ,\n", + " 95.6675 , 75.00314 ]]]))" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", "models = ['clip_vit_b16']\n", "# options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'freeze_bottom_2_optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_', 'embed_layer_lr_multiplier-0.2_']\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", - "mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "# mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)', 'SGD (lower LR, embed layer)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", @@ -520,6 +2428,70 @@ "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Big table with no momentum" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "not all jobs ran: clip_vit_l14 freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 1\n", + "not all jobs ran: timm_vit_b16_in21k freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 1\n", + "not all jobs ran: timm_vit_b16_in21k freeze_bottom_2_optimizer.args.momentum-0.0_ fmow_all_nonorm_weakaugs 4\n", + "not all jobs ran: dino_vit_b16 freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 5\n", + "empty dir ../logs//full_ft_freeze_bottom_2_optimizer.args.momentum-0.0_fmow_all_nonorm_weakaugs_dino_vit_b16\n" + ] + }, + { + "ename": "TypeError", + "evalue": "object of type 'NoneType' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# Rearranging mean table\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 46\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 47\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 49\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 50\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_optimizer.args.momentum-0.0_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101', ]\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'SGD (freeze-embed, no momentum)']\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# Rearranging mean table\n", + "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 9893c26..6c05891 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1193,6 +1193,54 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +timm_vit_l32_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch32_224_in21k', + }, + bundles=[] +) + +timm_vit_l16_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch16_224_in21k', + }, + bundles=[] +) + +timm_vit_h14_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_huge_patch14_224_in21k', + }, + bundles=[] +) + +timm_clip_vit_l14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch14_224_clip_laion2b', + }, + bundles=[] +) + +timm_clip_vit_h14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_huge_patch14_224_clip_laion2b', + }, + bundles=[] +) + +timm_clip_vit_g14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_giant_patch14_224_clip_laion2b', + }, + bundles=[] +) + convnext_vit_b = Model( kwargs={ 'classname': 'models.timm_model.TimmModel', @@ -1259,8 +1307,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, 'clip_vit_l14_highres': clip_vit_l14_highres, + 'timm_vit_l32_in21k': timm_vit_l32_in21k, + 'timm_vit_l16_in21k': timm_vit_l16_in21k, + 'timm_vit_h14_in21k': timm_vit_h14_in21k, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, + 'timm_clip_vit_l14': timm_clip_vit_l14, + 'timm_clip_vit_h14': timm_clip_vit_h14, + 'timm_clip_vit_g14': timm_clip_vit_g14, 'convnext_vit_b': convnext_vit_b, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, diff --git a/scripts/run_jag10_11_sbatch.sh b/scripts/run_jag10_11_sbatch.sh new file mode 100644 index 0000000..9fac09d --- /dev/null +++ b/scripts/run_jag10_11_sbatch.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --partition=jag-standard +#SBATCH --mem=16G +#SBATCH --exclude=jagupard[15-31] +#SBATCH --account=nlp + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue-new + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index e657813..6b1b046 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --partition=jag-standard #SBATCH --mem=16G +#SBATCH --account=nlp #SBATCH --exclude=jagupard[13,14,15,17,18] # #SBATCH --exclude=jagupard[14,17,18,20] diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh new file mode 100644 index 0000000..03bad48 --- /dev/null +++ b/scripts/run_sphinx_big_sbatch.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=24G +#SBATCH --partition=sphinx +#SBATCH --exclude=sphinx[1,2,3,8] +#SBATCH --account=nlp + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue-new + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 0829412..7e1f92a 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3,5,6,7,8] +#SBATCH --exclude=sphinx[3] #SBATCH --account=nlp # Print execute commands in the log. From 0b8944e7d39c6d477a3f68eefd6a5900ebe5da60 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 13 Dec 2022 15:09:39 -0800 Subject: [PATCH 182/197] Add group name, add models. --- ...nalyze_dataset_stats_model_gradients.ipynb | 122 +- ...eeze-embed-paper-fine-tuning-results.ipynb | 2000 ++++++++++++++++- scripts/run_adaptation_experiments.py | 54 + scripts/run_jag10_11_sbatch.sh | 21 + scripts/run_sbatch.sh | 1 + scripts/run_sphinx_big_sbatch.sh | 21 + scripts/run_sphinx_sbatch.sh | 2 +- 7 files changed, 2174 insertions(+), 47 deletions(-) create mode 100644 scripts/run_jag10_11_sbatch.sh create mode 100644 scripts/run_sphinx_big_sbatch.sh diff --git a/scripts/analyze_dataset_stats_model_gradients.ipynb b/scripts/analyze_dataset_stats_model_gradients.ipynb index f837b93..d7a11f0 100644 --- a/scripts/analyze_dataset_stats_model_gradients.ipynb +++ b/scripts/analyze_dataset_stats_model_gradients.ipynb @@ -58,6 +58,7 @@ "source": [ "datasets = ['living17_nonorm', 'waterbirds', 'domainnet']\n", "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "merge_models = ['clip_vit_b16', 'clip_vit_l14','convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", "model_display_names = ['clip_b', 'clip_l', 'vit_b', 'dino_b', 'convnext_b', 'resnet50', 'resnet101']\n", "log_root = '../logs/'\n", "\n", @@ -101,19 +102,24 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "living17_nonorm\n" + "living17_nonorm\n", + "train/grad_patch_embed train/grad_ln_pre 7.832826223456222 0.24551549220763905 7.836673050713384\n", + "train/grad_patch_embed train/grad_ln_pre 7.882409921775851 0.1939453432210928 7.884795556707068\n", + "train/grad_stem train/grad_stage0 2.9855660124116703 1.6714600848737493 3.421605358569846\n", + "train/grad_stem train/grad_conv-block-0 3.1797744363503244 5.134835911909651 6.039661025943761\n", + "train/grad_stem train/grad_conv-block-0 3.067531236001276 4.9374460843294825 5.812755088553453\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -127,12 +133,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "waterbirds\n" + "waterbirds\n", + "train/grad_patch_embed train/grad_ln_pre 7.377456283569336 0.2574999781599999 7.381948757254352\n", + "train/grad_patch_embed train/grad_ln_pre 10.778858884175618 0.2457886140039833 10.78166085942911\n", + "train/grad_stem train/grad_stage0 2.1539545361168058 1.1490996834679277 2.4413009290548873\n", + "train/grad_stem train/grad_conv-block-0 1.7377760092417398 3.5004814195246396 3.9080987227465713\n", + "train/grad_stem train/grad_conv-block-0 2.3392495417594907 4.621618547990456 5.179907954949721\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -146,12 +157,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "domainnet\n" + "domainnet\n", + "train/grad_patch_embed train/grad_ln_pre 14.819977995993076 0.6566372829489773 14.83451786621586\n", + "train/grad_patch_embed train/grad_ln_pre 8.467114253975879 0.2888876401186325 8.472041068036368\n", + "train/grad_stem train/grad_stage0 6.788537111079389 2.5746775567102635 7.260385708041249\n", + "train/grad_stem train/grad_conv-block-0 3.289056084621912 7.2814341256452 7.989816822299426\n", + "train/grad_stem train/grad_conv-block-0 3.4599138361284103 6.826684185454191 7.653405824948992\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,26 +179,71 @@ } ], "source": [ - "def filter_df_get_grad(df):\n", + "def merge_first_2(param_dict, merge_type='norm'):\n", + " keys = list(param_dict.keys())\n", + " k0 = keys[0]\n", + " k1 = keys[1]\n", + " v0 = param_dict[k0]\n", + " v1 = param_dict[k1]\n", + " if merge_type == 'norm':\n", + " param_dict[k0] = np.sqrt(v0**2 + v1**2)\n", + " elif merge_type == 'sum':\n", + " param_dict[k0] = v0 + v1\n", + " else:\n", + " raise ValueError(\"Invalid merge_type\")\n", + " print(k0, k1, v0, v1, param_dict[k0])\n", + " del param_dict[k1]\n", + " \n", + "\n", + "def filter_df_get_grad(df, merge=False):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " df = df[filtered_keys]\n", - " return df.to_dict(orient='records')[0]\n", + " keys_values = df.to_dict(orient='records')[0]\n", + " if merge:\n", + " merge_first_2(keys_values)\n", + " return keys_values\n", "\n", "def filter_df_get_norm(df):\n", " filtered_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", " df = df[filtered_keys]\n", " return df.to_dict(orient='records')[0]\n", "\n", - "def filter_df_get_param_normalized_grad(df):\n", - " filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", - " df = df[filtered_keys]\n", - " return df.to_dict(orient='records')[0]\n", + "def get_num_params(df):\n", + " param_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + " param_dict = df[param_keys].to_dict(orient='records')[0]\n", + " grad_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " grad_dict = df[grad_keys].to_dict(orient='records')[0]\n", + " num_params_dict = {}\n", + " for pk, gk in zip(param_keys, grad_keys):\n", + " npk = gk[:gk.find('grad')] + 'param' + gk[gk.find('grad')+4:]\n", + " num_params_dict[npk] = int(np.round((grad_dict[gk] / param_dict[pk]) ** 2))\n", + " return num_params_dict\n", "\n", - "def filter_df_get_normalized_grad(df):\n", + "def filter_df_get_param_normalized_grad(df, merge=False):\n", + " num_params_dict = get_num_params(df)\n", + " merge_first_2(num_params_dict, merge_type='sum')\n", + " grad_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", + " grad_dict = df[grad_keys].to_dict(orient='records')[0]\n", + " merge_first_2(grad_dict)\n", + " normalized_dict = {}\n", + " for npk, gk in zip(num_params_dict.keys(), grad_dict.keys()):\n", + " normalized_dict[gk] = grad_dict[gk] / np.sqrt(num_params_dict[npk])\n", + " return normalized_dict\n", + "# filtered_keys = [s for s in list(df.keys()) if 'param_normalized_grad_' in s]\n", + "# df = df[filtered_keys]\n", + "# return df.to_dict(orient='records')[0]\n", + "\n", + "def filter_df_get_normalized_grad(df, merge=False):\n", " filtered_keys = [s for s in list(df.keys()) if 'grad' in s and '_grad' not in s]\n", " norm_keys = [s for s in list(df.keys()) if 'norm_' in s]\n", " filtered_d = df[filtered_keys].to_dict(orient='records')[0]\n", " norm_d = df[norm_keys].to_dict(orient='records')[0]\n", + " if merge:\n", + " merge_first_2(filtered_d)\n", + " merge_first_2(norm_d)\n", + " filtered_keys = [filtered_keys[0]] + filtered_keys[2:]\n", + " norm_keys = [norm_keys[0]] + norm_keys[2:]\n", + " # Get filtered keys after merge.\n", " normalized_grad_d = {}\n", " for fk, nk in zip(filtered_keys, norm_keys):\n", " normalized_grad_d[fk] = filtered_d[fk] / norm_d[nk]\n", @@ -195,7 +256,7 @@ "\n", "# Get a sorted list of outputs, \n", "\n", - "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df):\n", + "def get_dataset_grad_stats(datasets, models, model_display_names, filter_df, merge_models):\n", " dataset_stats = {}\n", " for dataset in datasets:\n", " print(dataset)\n", @@ -215,20 +276,25 @@ "# 'std_mean': np.std(np.mean(random_images, axis=(1,2,3)))\n", "# }\n", " df = pd.read_csv(stats_path, sep='\\t')\n", - " d = filter_df(df)\n", + " if model in merge_models:\n", + " d = filter_df(df, merge=True)\n", + " else:\n", + " d = filter_df(df, merge=False)\n", "# print(model)\n", "# print(list(d.keys()))\n", "# print(sorted([(-v, k) for k, v in list(d.items())]))\n", " values = list(d.values())\n", " if model_idx == 1:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', label='middle layers', marker='o')\n", + " plt.scatter([model_idx]*(len(d)-5), values[4:-1], c='black', label='middle layers', marker='o')\n", " plt.scatter([model_idx], values[-1], c='green', label='head layer', marker='^')\n", " plt.scatter([model_idx], values[0], c='red', label='embedding layer', marker='s')\n", " else:\n", - " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", + " if model_idx <= 3:\n", + " plt.scatter([model_idx]*(len(d)-5), values[4:-1], c='black', marker='o')\n", + " else:\n", + " plt.scatter([model_idx]*(len(d)-2), values[1:-1], c='black', marker='o')\n", " plt.scatter([model_idx], values[-1], c='green', marker='^')\n", " plt.scatter([model_idx], values[0], c='red', marker='s')\n", - " my_xticks = ['John','Arnold','Mavis','Matt']\n", " plt.legend()\n", " plt.xticks(list(range(len(model_display_names))), model_display_names)\n", "\n", @@ -240,24 +306,16 @@ "# print(df[compute_keys(df)])\n", "# return dataset_stats\n", "\n", - "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad)\n", - "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad)\n" + "dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_grad, merge_models)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_normalized_grad, merge_models)\n", + "# dataset_stats = get_dataset_grad_stats(datasets, models, model_display_names, filter_df_get_param_normalized_grad, merge_models)\n" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'living17_nonorm': {'mean': 0.405586, 'std': 0.19588944, 'std_mean': 0.105948165}, 'waterbirds': {'mean': 0.37670943, 'std': 0.22946799, 'std_mean': 0.11904866}, 'domainnet': {'mean': 0.8599936, 'std': 0.1735559, 'std_mean': 0.15381968}}\n" - ] - } - ], + "outputs": [], "source": [ "print(dataset_stats)\n", "# The std-devs within the image, and the std devs of the mean, are pretty similar (and small).\n", diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index 33079ed..f55cd9c 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,9 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import numpy as np\n", "import summarize_all_results\n", @@ -16,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +78,6 @@ " agg_metric = aggregation_metric_list[dataset_idx]\n", " res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n", " dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n", - " print(dataset, res)\n", " num_jobs = len(res)\n", " if (desired_epochs_list is not None and\n", " desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", @@ -287,9 +297,1782 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.8235 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 97.6471 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 98.0000 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 97.7059 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 97.1765 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 97.2353 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 96.8824 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 95.1765 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 95.5882 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 94.0588 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 73.0588 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 74.8235 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 70.7059 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 69.7059 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 71.2941 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 97.4706 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 97.7059 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 96.7059 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 81.4118 \n", + "1 78.7647 \n", + "2 79.7059 \n", + "3 79.8824 \n", + "4 77.0588 \n", + "5 78.0588 \n", + "6 76.0588 \n", + "7 67.2941 \n", + "8 67.5882 \n", + "9 64.7647 \n", + "10 31.9412 \n", + "11 33.5882 \n", + "12 30.5882 \n", + "13 30.6471 \n", + "14 31.7059 \n", + "15 83.8235 \n", + "16 83.1176 \n", + "17 75.0588 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/23xt... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/vdnf... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1hv9... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/oq4g... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2ywr... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2n8e... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/35ic... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/2cqg... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/mcfd... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/18y4... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2at9... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2yr7... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/4wef... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1kfz... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/2eyl... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3mkp... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/24p2... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2v9m... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 96.4352 48.7539 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 96.1016 47.6636 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 95.9652 36.7601 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 94.4102 25.2336 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 95.3812 23.3645 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 91.2967 8.5670 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 92.0223 10.2804 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 92.2794 11.9938 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 89.2976 5.1402 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 88.2076 6.8536 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 88.5881 4.0498 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 89.8418 3.5826 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 89.7166 6.5421 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 89.2625 3.7383 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 89.3853 3.4268 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 97.2577 61.6822 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 97.1104 57.6324 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 97.2989 68.0685 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/21nx... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2ech... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/w69b... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2c46... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/36q9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/p95b... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/242a... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/1pwr... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/2ims... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2txk... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2kyy... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/123f... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3s37... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2dxs... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/3w52... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/39mq... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1nca... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/3lj2... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.1626 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 86.4527 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 86.7028 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 82.1175 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 83.7015 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 83.2430 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 73.3222 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 76.6569 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 74.6561 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 62.5677 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 62.3593 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 64.9437 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 29.8875 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 35.6398 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 29.4706 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 93.2472 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 93.0388 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 80.1167 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 78.7556 https://wandb.ai/p-lambda/finetuning/runs/2nfv... \n", + "1 64.5398 https://wandb.ai/p-lambda/finetuning/runs/8up5... \n", + "2 64.7991 https://wandb.ai/p-lambda/finetuning/runs/63s4... \n", + "3 57.8568 https://wandb.ai/p-lambda/finetuning/runs/uc6x... \n", + "4 59.9885 https://wandb.ai/p-lambda/finetuning/runs/7fo3... \n", + "5 60.1037 https://wandb.ai/p-lambda/finetuning/runs/1ei6... \n", + "6 34.9129 https://wandb.ai/p-lambda/finetuning/runs/2dj0... \n", + "7 37.4190 https://wandb.ai/p-lambda/finetuning/runs/32j3... \n", + "8 38.4128 https://wandb.ai/p-lambda/finetuning/runs/24k1... \n", + "9 21.6765 https://wandb.ai/p-lambda/finetuning/runs/2wgz... \n", + "10 21.9790 https://wandb.ai/p-lambda/finetuning/runs/1ykm... \n", + "11 23.3617 https://wandb.ai/p-lambda/finetuning/runs/2yqb... \n", + "12 11.5944 https://wandb.ai/p-lambda/finetuning/runs/171u... \n", + "13 12.8331 https://wandb.ai/p-lambda/finetuning/runs/1vhn... \n", + "14 11.1335 https://wandb.ai/p-lambda/finetuning/runs/3bcv... \n", + "15 83.8398 https://wandb.ai/p-lambda/finetuning/runs/2uhu... \n", + "16 83.6238 https://wandb.ai/p-lambda/finetuning/runs/1cmw... \n", + "17 50.8714 https://wandb.ai/p-lambda/finetuning/runs/2iam... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 66.9337 65.3678 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 65.0527 63.6103 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 66.1413 64.9561 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 67.8830 65.5084 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 66.2632 64.6950 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 66.7683 64.8104 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 63.3110 60.7432 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 63.6506 61.1097 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 62.5098 60.7381 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 53.3049 50.9114 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 53.9929 51.6646 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 45.8765 43.3241 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 27.7279 24.6397 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 27.0835 24.2732 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 26.4826 24.4389 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 62.5446 61.4562 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 61.6999 60.2109 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 62.2747 61.9081 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 58.5897 36.9456 \n", + "1 57.1377 38.1026 \n", + "2 57.7890 37.0999 \n", + "3 58.4540 36.5600 \n", + "4 57.6352 36.7528 \n", + "5 57.7167 38.7196 \n", + "6 53.7814 35.7115 \n", + "7 53.7769 35.3259 \n", + "8 52.7773 32.2021 \n", + "9 44.1469 28.8083 \n", + "10 43.7670 26.1088 \n", + "11 36.0277 20.9410 \n", + "12 20.8929 13.7293 \n", + "13 19.8752 12.9194 \n", + "14 19.9747 13.0351 \n", + "15 55.8802 38.0640 \n", + "16 54.3378 35.6344 \n", + "17 56.0159 37.6012 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1216... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2ppo... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/qsjv... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2un3... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2b5f... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/e921... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3bdt... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/11ws... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1yhv... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/1m5g... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2kp0... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2kuy... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3i5d... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2iad... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/24wq... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/2d4r... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1jhk... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2b8g... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.3772 89.6602 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 99.3683 91.9092 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 99.3951 91.7316 \n", + "3 optimizer.args.lr-0.0003_seed-0_run0 99.1746 83.5320 \n", + "4 optimizer.args.lr-0.0003_seed-1_run1 99.0793 79.4379 \n", + "5 optimizer.args.lr-0.0003_seed-2_run2 99.0703 85.8240 \n", + "6 optimizer.args.lr-0.001_seed-0_run0 98.7664 82.1854 \n", + "7 optimizer.args.lr-0.001_seed-1_run1 98.7455 84.0248 \n", + "8 optimizer.args.lr-0.001_seed-2_run2 98.3343 79.7874 \n", + "9 optimizer.args.lr-0.003_seed-0_run0 98.2926 77.2089 \n", + "10 optimizer.args.lr-0.003_seed-1_run1 98.3105 77.0284 \n", + "11 optimizer.args.lr-0.003_seed-2_run2 98.3045 75.3610 \n", + "12 optimizer.args.lr-0.01_seed-0_run0 98.1913 78.8935 \n", + "13 optimizer.args.lr-0.01_seed-1_run1 98.2896 77.7103 \n", + "14 optimizer.args.lr-0.01_seed-2_run2 97.9827 68.7428 \n", + "15 optimizer.args.lr-3e-05_seed-0_run0 99.3117 94.1239 \n", + "16 optimizer.args.lr-3e-05_seed-1_run1 99.2729 93.1297 \n", + "17 optimizer.args.lr-3e-05_seed-2_run2 99.1836 89.9524 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 85.8890 https://wandb.ai/p-lambda/finetuning/runs/3lgv... \n", + "1 88.0782 https://wandb.ai/p-lambda/finetuning/runs/9g01... \n", + "2 86.4192 https://wandb.ai/p-lambda/finetuning/runs/35sq... \n", + "3 69.5358 https://wandb.ai/p-lambda/finetuning/runs/3d0i... \n", + "4 68.4130 https://wandb.ai/p-lambda/finetuning/runs/37g3... \n", + "5 66.8152 https://wandb.ai/p-lambda/finetuning/runs/3cnf... \n", + "6 51.8812 https://wandb.ai/p-lambda/finetuning/runs/3ob1... \n", + "7 55.9492 https://wandb.ai/p-lambda/finetuning/runs/ffkb... \n", + "8 66.4225 https://wandb.ai/p-lambda/finetuning/runs/7roy... \n", + "9 48.2023 https://wandb.ai/p-lambda/finetuning/runs/2fap... \n", + "10 55.2919 https://wandb.ai/p-lambda/finetuning/runs/2931... \n", + "11 56.0079 https://wandb.ai/p-lambda/finetuning/runs/2gpp... \n", + "12 49.3604 https://wandb.ai/p-lambda/finetuning/runs/aydg... \n", + "13 65.4255 https://wandb.ai/p-lambda/finetuning/runs/28jo... \n", + "14 65.1398 https://wandb.ai/p-lambda/finetuning/runs/10v5... \n", + "15 94.1073 https://wandb.ai/p-lambda/finetuning/runs/2x55... \n", + "16 94.0614 https://wandb.ai/p-lambda/finetuning/runs/3rtu... \n", + "17 86.5039 https://wandb.ai/p-lambda/finetuning/runs/6wx0... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-0.0003 \n", + "4 optimizer.args.lr-0.0003 \n", + "5 optimizer.args.lr-0.0003 \n", + "6 optimizer.args.lr-0.001 \n", + "7 optimizer.args.lr-0.001 \n", + "8 optimizer.args.lr-0.001 \n", + "9 optimizer.args.lr-0.003 \n", + "10 optimizer.args.lr-0.003 \n", + "11 optimizer.args.lr-0.003 \n", + "12 optimizer.args.lr-0.01 \n", + "13 optimizer.args.lr-0.01 \n", + "14 optimizer.args.lr-0.01 \n", + "15 optimizer.args.lr-3e-05 \n", + "16 optimizer.args.lr-3e-05 \n", + "17 optimizer.args.lr-3e-05 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 82.5294 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 74.4118 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 74.1176 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 98.1176 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 97.8824 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 97.8824 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 97.6471 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 97.8824 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 98.2941 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 97.3529 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 96.8235 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 96.5882 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 98.0588 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 98.0588 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 98.1765 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 96.9412 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 97.2941 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 97.8235 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 41.5294 \n", + "1 34.3529 \n", + "2 34.2941 \n", + "3 81.5294 \n", + "4 79.7059 \n", + "5 80.4118 \n", + "6 84.1765 \n", + "7 82.9412 \n", + "8 83.7059 \n", + "9 78.1176 \n", + "10 74.5294 \n", + "11 75.2941 \n", + "12 84.1765 \n", + "13 81.7647 \n", + "14 82.4706 \n", + "15 82.8824 \n", + "16 83.0000 \n", + "17 83.7647 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/bxpw... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/21xk... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3nio... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2f58... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/xnsv... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2dtz... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/320l... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/icog... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/2q6p... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2fhj... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3kfd... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/1ryy... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/1czo... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2e0r... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/3hxw... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/107a... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/14jd... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/1dl4... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 89.5521 2.8037 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 89.9072 6.2305 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 88.8488 5.4517 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.9436 69.3146 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 97.4628 66.6667 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 97.6901 68.5358 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 97.3885 67.2897 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 97.3596 70.7165 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 97.6066 64.1745 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 97.0159 53.5826 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 96.7293 43.6137 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 96.9287 48.5981 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 97.7807 69.3146 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 97.7180 74.2991 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 97.7429 71.9626 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 96.8930 56.8536 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 97.0290 67.6012 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 97.2621 64.4860 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1q9q... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2pim... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/i3p7... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/6jgf... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/epno... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3bkh... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/7jaa... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/18r2... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3p0v... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/30gn... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3dv5... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/lejn... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/2a7x... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2xwh... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/4t60... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/1eam... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/18yv... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/1p12... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 52.9804 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 33.5556 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 40.3918 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 94.5394 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 94.6644 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 94.0392 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 94.3310 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 94.1642 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 93.4973 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 91.0796 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 91.2047 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 90.8712 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 95.0396 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 94.9145 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 95.0396 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 92.2468 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 91.9133 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 91.9967 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 16.9811 https://wandb.ai/p-lambda/finetuning/runs/232h... \n", + "1 11.7817 https://wandb.ai/p-lambda/finetuning/runs/2sx2... \n", + "2 13.2220 https://wandb.ai/p-lambda/finetuning/runs/3i7o... \n", + "3 88.5352 https://wandb.ai/p-lambda/finetuning/runs/1wdb... \n", + "4 88.9241 https://wandb.ai/p-lambda/finetuning/runs/p66t... \n", + "5 88.0455 https://wandb.ai/p-lambda/finetuning/runs/kemg... \n", + "6 85.1937 https://wandb.ai/p-lambda/finetuning/runs/h6og... \n", + "7 84.1567 https://wandb.ai/p-lambda/finetuning/runs/sw9z... \n", + "8 85.3810 https://wandb.ai/p-lambda/finetuning/runs/1hc8... \n", + "9 75.6589 https://wandb.ai/p-lambda/finetuning/runs/3ue3... \n", + "10 76.4799 https://wandb.ai/p-lambda/finetuning/runs/3gl6... \n", + "11 78.2947 https://wandb.ai/p-lambda/finetuning/runs/t7sx... \n", + "12 90.5516 https://wandb.ai/p-lambda/finetuning/runs/1gon... \n", + "13 88.6216 https://wandb.ai/p-lambda/finetuning/runs/318v... \n", + "14 88.3336 https://wandb.ai/p-lambda/finetuning/runs/12xq... \n", + "15 82.2699 https://wandb.ai/p-lambda/finetuning/runs/4ndp... \n", + "16 81.3769 https://wandb.ai/p-lambda/finetuning/runs/12m4... \n", + "17 81.6938 https://wandb.ai/p-lambda/finetuning/runs/37vl... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 33.5452 30.7658 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 34.5728 32.1818 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 35.5221 33.1860 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 70.2778 67.7831 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 69.8424 67.5370 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 70.2343 68.0542 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 62.6578 61.0545 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 62.2921 60.5172 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 62.0482 61.0495 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 68.3968 66.0507 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 68.5535 66.2064 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 68.9280 66.2315 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 67.7872 65.5687 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 68.1094 65.7695 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 68.5100 66.0357 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 47.9666 48.1195 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 47.3570 46.7386 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 48.0624 47.9588 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 25.9499 17.0459 \n", + "1 26.7595 16.5831 \n", + "2 27.3430 16.9688 \n", + "3 61.5298 40.8407 \n", + "4 60.8196 40.8793 \n", + "5 61.3850 40.2622 \n", + "6 55.1294 37.6398 \n", + "7 54.2699 36.7914 \n", + "8 55.6902 37.9869 \n", + "9 58.9696 38.1797 \n", + "10 59.0058 39.2981 \n", + "11 58.7977 38.1026 \n", + "12 58.6665 38.4882 \n", + "13 59.0646 41.8049 \n", + "14 59.2772 41.1107 \n", + "15 43.7896 32.0478 \n", + "16 42.0843 29.4639 \n", + "17 43.4006 31.8936 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2ctt... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2c18... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/dcqz... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1ft8... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2kb5... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/24m2... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/m7tk... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/50fj... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/92oa... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/3jhw... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/2reh... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3jb3... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/xmr9... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/amzd... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1z3l... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3b7x... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/zty5... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/ga5d... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.4237 78.4065 \n", + "1 optimizer.args.lr-0.0001_seed-1_run1 98.3045 79.9851 \n", + "2 optimizer.args.lr-0.0001_seed-2_run2 97.5387 76.1517 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 99.4458 91.2102 \n", + "4 optimizer.args.lr-1e-05_seed-1_run1 99.4160 91.2847 \n", + "5 optimizer.args.lr-1e-05_seed-2_run2 99.4190 89.3594 \n", + "6 optimizer.args.lr-1e-06_seed-0_run0 99.4249 94.7886 \n", + "7 optimizer.args.lr-1e-06_seed-1_run1 99.5143 93.6110 \n", + "8 optimizer.args.lr-1e-06_seed-2_run2 99.5083 94.2757 \n", + "9 optimizer.args.lr-3e-05_seed-0_run0 99.1359 87.5659 \n", + "10 optimizer.args.lr-3e-05_seed-1_run1 98.9988 84.8413 \n", + "11 optimizer.args.lr-3e-05_seed-2_run2 98.6323 79.1342 \n", + "12 optimizer.args.lr-3e-06_seed-0_run0 99.5679 94.3474 \n", + "13 optimizer.args.lr-3e-06_seed-1_run1 99.5322 94.4734 \n", + "14 optimizer.args.lr-3e-06_seed-2_run2 99.5352 93.7514 \n", + "15 optimizer.args.lr-3e-07_seed-0_run0 99.2878 94.5479 \n", + "16 optimizer.args.lr-3e-07_seed-1_run1 99.2938 92.8547 \n", + "17 optimizer.args.lr-3e-07_seed-2_run2 99.3117 92.5940 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 63.7560 https://wandb.ai/p-lambda/finetuning/runs/2zux... \n", + "1 61.7337 https://wandb.ai/p-lambda/finetuning/runs/umt6... \n", + "2 59.0942 https://wandb.ai/p-lambda/finetuning/runs/3pci... \n", + "3 91.5183 https://wandb.ai/p-lambda/finetuning/runs/8eai... \n", + "4 92.0686 https://wandb.ai/p-lambda/finetuning/runs/2d88... \n", + "5 93.1032 https://wandb.ai/p-lambda/finetuning/runs/11gy... \n", + "6 96.6010 https://wandb.ai/p-lambda/finetuning/runs/183o... \n", + "7 95.6216 https://wandb.ai/p-lambda/finetuning/runs/e8e7... \n", + "8 96.6798 https://wandb.ai/p-lambda/finetuning/runs/10zp... \n", + "9 81.5952 https://wandb.ai/p-lambda/finetuning/runs/2g31... \n", + "10 82.3700 https://wandb.ai/p-lambda/finetuning/runs/2v1i... \n", + "11 64.1933 https://wandb.ai/p-lambda/finetuning/runs/17xu... \n", + "12 95.9720 https://wandb.ai/p-lambda/finetuning/runs/3bn2... \n", + "13 95.1819 https://wandb.ai/p-lambda/finetuning/runs/23om... \n", + "14 96.0237 https://wandb.ai/p-lambda/finetuning/runs/2v57... \n", + "15 94.0403 https://wandb.ai/p-lambda/finetuning/runs/2502... \n", + "16 94.8492 https://wandb.ai/p-lambda/finetuning/runs/14ml... \n", + "17 94.7986 https://wandb.ai/p-lambda/finetuning/runs/36bk... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0001 \n", + "2 optimizer.args.lr-0.0001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-05 \n", + "5 optimizer.args.lr-1e-05 \n", + "6 optimizer.args.lr-1e-06 \n", + "7 optimizer.args.lr-1e-06 \n", + "8 optimizer.args.lr-1e-06 \n", + "9 optimizer.args.lr-3e-05 \n", + "10 optimizer.args.lr-3e-05 \n", + "11 optimizer.args.lr-3e-05 \n", + "12 optimizer.args.lr-3e-06 \n", + "13 optimizer.args.lr-3e-06 \n", + "14 optimizer.args.lr-3e-06 \n", + "15 optimizer.args.lr-3e-07 \n", + "16 optimizer.args.lr-3e-07 \n", + "17 optimizer.args.lr-3e-07 \n", + "living17_nonorm name \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 97.8235 83.7647 \n", + "1 98.3529 82.1765 \n", + "2 98.2941 83.5882 \n", + "3 98.1176 80.7059 \n", + "4 97.8824 81.8235 \n", + "5 98.1765 81.0000 \n", + "6 97.8824 79.4706 \n", + "7 97.8235 77.1765 \n", + "8 97.4706 78.1765 \n", + "9 97.2353 74.1176 \n", + "10 95.7059 69.5882 \n", + "11 95.7059 71.1765 \n", + "12 94.5882 63.7647 \n", + "13 88.9412 50.7647 \n", + "14 87.4706 47.5294 \n", + "15 97.7059 84.1765 \n", + "16 97.8235 82.4118 \n", + "17 98.2353 84.1176 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/cjnc... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/37b2... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/168z... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2sg5... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3df8... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/2sgu... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2bmu... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/3jd6... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3ayf... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/24mp... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/151t... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/338h... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/1e4k... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1ooi... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/meox... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/23jc... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/30ne... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2zk0... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "waterbirds name WATERBIRDS_VAL \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.6151 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.7998 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 97.6586 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.8519 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.8297 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 97.7370 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.7858 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.2823 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 97.4715 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 96.2965 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 96.4551 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 92.0653 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 90.0736 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 90.7563 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 92.3953 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.3644 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.1726 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 97.3713 \n", + "\n", + " WORST wandb_url \\\n", + "0 71.9626 https://wandb.ai/p-lambda/finetuning/runs/2w3y... \n", + "1 75.8567 https://wandb.ai/p-lambda/finetuning/runs/2qf0... \n", + "2 67.7570 https://wandb.ai/p-lambda/finetuning/runs/1zf0... \n", + "3 73.0530 https://wandb.ai/p-lambda/finetuning/runs/3z79... \n", + "4 73.0530 https://wandb.ai/p-lambda/finetuning/runs/3hg2... \n", + "5 75.0779 https://wandb.ai/p-lambda/finetuning/runs/j7im... \n", + "6 66.9782 https://wandb.ai/p-lambda/finetuning/runs/3e8b... \n", + "7 71.0280 https://wandb.ai/p-lambda/finetuning/runs/kqer... \n", + "8 57.7882 https://wandb.ai/p-lambda/finetuning/runs/3tte... \n", + "9 40.4984 https://wandb.ai/p-lambda/finetuning/runs/1h6c... \n", + "10 46.8847 https://wandb.ai/p-lambda/finetuning/runs/102j... \n", + "11 13.2399 https://wandb.ai/p-lambda/finetuning/runs/2ckq... \n", + "12 9.6573 https://wandb.ai/p-lambda/finetuning/runs/208v... \n", + "13 5.6075 https://wandb.ai/p-lambda/finetuning/runs/3mci... \n", + "14 9.3458 https://wandb.ai/p-lambda/finetuning/runs/4p8p... \n", + "15 67.2897 https://wandb.ai/p-lambda/finetuning/runs/17ng... \n", + "16 72.2741 https://wandb.ai/p-lambda/finetuning/runs/522l... \n", + "17 73.5202 https://wandb.ai/p-lambda/finetuning/runs/156a... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "domainnet name test_acc/sketch_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 95.1647 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 94.6228 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 94.9562 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.4977 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.5394 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 94.4977 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 90.7461 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 90.3710 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 92.3718 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 84.1601 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 85.5356 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 85.7024 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 70.9045 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 68.8203 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 66.9862 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 93.9975 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 94.2476 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 94.1226 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 89.0249 https://wandb.ai/p-lambda/finetuning/runs/1hdc... \n", + "1 88.0743 https://wandb.ai/p-lambda/finetuning/runs/3m8c... \n", + "2 87.5846 https://wandb.ai/p-lambda/finetuning/runs/31rn... \n", + "3 87.4838 https://wandb.ai/p-lambda/finetuning/runs/1vfm... \n", + "4 86.7780 https://wandb.ai/p-lambda/finetuning/runs/2uic... \n", + "5 89.0249 https://wandb.ai/p-lambda/finetuning/runs/3meu... \n", + "6 72.2886 https://wandb.ai/p-lambda/finetuning/runs/3ea0... \n", + "7 76.2207 https://wandb.ai/p-lambda/finetuning/runs/dp9h... \n", + "8 75.6157 https://wandb.ai/p-lambda/finetuning/runs/b7nx... \n", + "9 54.9906 https://wandb.ai/p-lambda/finetuning/runs/3leh... \n", + "10 58.0009 https://wandb.ai/p-lambda/finetuning/runs/3gge... \n", + "11 56.0853 https://wandb.ai/p-lambda/finetuning/runs/1nu1... \n", + "12 32.6228 https://wandb.ai/p-lambda/finetuning/runs/2qr4... \n", + "13 30.6640 https://wandb.ai/p-lambda/finetuning/runs/c1ft... \n", + "14 29.8574 https://wandb.ai/p-lambda/finetuning/runs/wsxh... \n", + "15 85.5250 https://wandb.ai/p-lambda/finetuning/runs/rq4v... \n", + "16 84.6464 https://wandb.ai/p-lambda/finetuning/runs/33zi... \n", + "17 86.0291 https://wandb.ai/p-lambda/finetuning/runs/yjxd... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.4577 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.5013 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 68.7712 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 70.2604 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 69.9643 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 69.7814 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 69.6247 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 68.4926 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 68.8148 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.1311 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.4533 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 65.0962 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 53.3397 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 48.2714 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 53.8361 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 64.0512 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 63.8857 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 63.7551 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 66.3871 59.8471 39.7995 \n", + "1 65.8197 58.8294 39.7609 \n", + "2 66.0909 59.0601 40.3008 \n", + "3 67.7128 60.8422 39.5681 \n", + "4 66.8391 59.9602 39.9923 \n", + "5 67.2458 60.5527 40.9950 \n", + "6 66.5328 59.5893 38.1797 \n", + "7 65.9352 59.0827 35.9815 \n", + "8 66.5478 59.2953 38.1026 \n", + "9 62.9224 55.6767 35.6344 \n", + "10 62.5860 55.0887 34.8631 \n", + "11 62.8722 55.1746 34.1689 \n", + "12 50.7256 44.1514 30.3509 \n", + "13 44.7703 37.7510 23.9491 \n", + "14 51.9257 43.8936 25.1446 \n", + "15 62.0587 55.4641 36.9456 \n", + "16 61.6621 54.8534 37.2541 \n", + "17 61.9382 55.9028 37.7169 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3eni... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2sgj... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3tel... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1cr0... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1hvg... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3lh6... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/w8ll... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/rwap... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3kbr... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2s21... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/1glt... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3iis... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/rw88... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/18ab... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1pou... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/o8u7... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/1dyr... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/iqb4... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val \\\n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5143 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5083 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001_see... 99.5203 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5322 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5173 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003_see... 99.5292 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.4458 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.3802 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001_seed... 99.4219 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 99.2223 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 97.6698 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003_seed... 98.6532 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.8784 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.9082 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01_seed-... 97.9350 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4398 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.3534 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05_seed... 99.4547 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.8802 94.8797 \n", + "1 93.0753 95.7274 \n", + "2 94.0952 96.1495 \n", + "3 93.7858 93.9603 \n", + "4 93.1555 94.6446 \n", + "5 93.3102 94.2683 \n", + "6 91.5683 89.2656 \n", + "7 91.4021 92.6952 \n", + "8 91.6055 90.1968 \n", + "9 85.6177 69.5993 \n", + "10 79.7043 70.1695 \n", + "11 79.2603 63.3668 \n", + "12 72.2381 58.2947 \n", + "13 76.4096 56.8027 \n", + "14 77.0284 68.2390 \n", + "15 94.0007 95.9567 \n", + "16 94.5966 94.4659 \n", + "17 93.7342 95.9073 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/niyx... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3pj2... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3pqw... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1rxa... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/247u... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/ujrs... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/1smz... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/23j5... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1qtj... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/42jz... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/m57o... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/3oov... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3iew... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/3qxp... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1i5f... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/wuhs... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/37r8... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2rqw... \n", + "\n", + " group \n", + "0 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "1 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "2 freeze_bottom_k-2_optimizer.args.lr-0.0001 \n", + "3 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "4 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "5 freeze_bottom_k-2_optimizer.args.lr-0.0003 \n", + "6 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "7 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "8 freeze_bottom_k-2_optimizer.args.lr-0.001 \n", + "9 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "10 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "11 freeze_bottom_k-2_optimizer.args.lr-0.003 \n", + "12 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "13 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "14 freeze_bottom_k-2_optimizer.args.lr-0.01 \n", + "15 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "16 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "17 freeze_bottom_k-2_optimizer.args.lr-3e-05 \n", + "living17_nonorm name \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... \n", + "\n", + " test_acc/source_val_living test_acc/target_val_living \\\n", + "0 98.1765 80.4706 \n", + "1 98.3529 83.0000 \n", + "2 97.9412 79.3529 \n", + "3 98.1765 83.4706 \n", + "4 98.1765 85.7059 \n", + "5 98.0588 84.4118 \n", + "6 97.8235 87.6471 \n", + "7 97.7647 87.6471 \n", + "8 97.7647 87.7059 \n", + "9 98.2353 81.8824 \n", + "10 98.2941 81.8235 \n", + "11 98.4118 82.0000 \n", + "12 98.0588 85.5294 \n", + "13 98.0000 86.4706 \n", + "14 97.9412 86.1765 \n", + "15 97.3529 86.6471 \n", + "16 97.1765 87.4118 \n", + "17 97.4118 87.2941 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3002... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/137p... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/in9f... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1vca... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/wec9... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/3rqg... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/33lf... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/uspk... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/229d... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2moq... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/1a5r... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2sxl... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3fdk... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/1wgh... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/2dox... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/3n5n... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/3kdx... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/2auy... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waterbirds name WATERBIRDS_VAL \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.2763 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.2581 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.3464 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 98.0542 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 97.8983 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 97.9775 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.3154 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.3131 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 97.2459 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.2068 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.1980 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 98.0882 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.5852 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.4949 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 97.5619 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.8196 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.9204 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 96.9769 \n", + "\n", + " WORST wandb_url \\\n", + "0 71.4953 https://wandb.ai/p-lambda/finetuning/runs/2be5... \n", + "1 64.9533 https://wandb.ai/p-lambda/finetuning/runs/3s7t... \n", + "2 70.7165 https://wandb.ai/p-lambda/finetuning/runs/w5h7... \n", + "3 76.1682 https://wandb.ai/p-lambda/finetuning/runs/qaxr... \n", + "4 78.6604 https://wandb.ai/p-lambda/finetuning/runs/1ss9... \n", + "5 77.5701 https://wandb.ai/p-lambda/finetuning/runs/15wn... \n", + "6 72.4299 https://wandb.ai/p-lambda/finetuning/runs/23pq... \n", + "7 71.9626 https://wandb.ai/p-lambda/finetuning/runs/93k6... \n", + "8 70.0935 https://wandb.ai/p-lambda/finetuning/runs/28g3... \n", + "9 76.0125 https://wandb.ai/p-lambda/finetuning/runs/76s1... \n", + "10 74.1433 https://wandb.ai/p-lambda/finetuning/runs/1bos... \n", + "11 65.8879 https://wandb.ai/p-lambda/finetuning/runs/3b9z... \n", + "12 74.2991 https://wandb.ai/p-lambda/finetuning/runs/3n5j... \n", + "13 76.4798 https://wandb.ai/p-lambda/finetuning/runs/1r58... \n", + "14 75.0779 https://wandb.ai/p-lambda/finetuning/runs/21mt... \n", + "15 52.0249 https://wandb.ai/p-lambda/finetuning/runs/veh2... \n", + "16 53.8941 https://wandb.ai/p-lambda/finetuning/runs/2adf... \n", + "17 51.4019 https://wandb.ai/p-lambda/finetuning/runs/2mlb... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "domainnet name test_acc/sketch_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.4981 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.4148 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 95.2897 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.2901 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.4152 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 96.2068 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.3722 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.2472 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 93.2889 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 95.8733 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 96.0817 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 95.8733 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.8733 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.8316 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 95.9566 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 73.9892 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 76.1984 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 74.6144 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 92.1504 https://wandb.ai/p-lambda/finetuning/runs/1983... \n", + "1 92.0784 https://wandb.ai/p-lambda/finetuning/runs/1r6b... \n", + "2 92.6257 https://wandb.ai/p-lambda/finetuning/runs/26mi... \n", + "3 93.2882 https://wandb.ai/p-lambda/finetuning/runs/1s2w... \n", + "4 93.4898 https://wandb.ai/p-lambda/finetuning/runs/1noz... \n", + "5 92.9425 https://wandb.ai/p-lambda/finetuning/runs/3iz4... \n", + "6 86.3172 https://wandb.ai/p-lambda/finetuning/runs/2kp2... \n", + "7 84.9057 https://wandb.ai/p-lambda/finetuning/runs/8f3c... \n", + "8 87.5702 https://wandb.ai/p-lambda/finetuning/runs/2wkl... \n", + "9 93.3602 https://wandb.ai/p-lambda/finetuning/runs/2x9b... \n", + "10 93.5042 https://wandb.ai/p-lambda/finetuning/runs/360e... \n", + "11 93.6483 https://wandb.ai/p-lambda/finetuning/runs/3d9r... \n", + "12 91.7615 https://wandb.ai/p-lambda/finetuning/runs/14v9... \n", + "13 91.7759 https://wandb.ai/p-lambda/finetuning/runs/33oz... \n", + "14 92.2656 https://wandb.ai/p-lambda/finetuning/runs/195b... \n", + "15 52.9598 https://wandb.ai/p-lambda/finetuning/runs/2r8a... \n", + "16 58.0153 https://wandb.ai/p-lambda/finetuning/runs/1f92... \n", + "17 55.3363 https://wandb.ai/p-lambda/finetuning/runs/cgzl... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "fmow_all_nonorm_weakaugs name test_acc/id_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 68.6493 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 69.4418 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 69.5027 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 67.5956 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 66.7334 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 66.2893 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 45.5891 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 39.3800 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 40.4163 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 68.9628 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 69.1544 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 68.9367 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 62.4314 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 59.0090 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 58.3558 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 23.6088 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 21.6494 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 21.4839 \n", + "\n", + " test_acc/ood_val test_acc/ood_test test_acc/africa_test \\\n", + "0 65.6591 59.3134 41.5735 \n", + "1 66.9295 60.0461 40.8022 \n", + "2 67.1152 60.2633 39.0282 \n", + "3 65.5185 59.8109 40.3779 \n", + "4 64.4439 58.5218 39.7609 \n", + "5 64.5443 58.9244 40.1851 \n", + "6 47.1906 42.6904 30.5438 \n", + "7 40.7130 35.5754 23.4477 \n", + "8 41.2202 36.2086 24.9518 \n", + "9 66.9947 61.0232 42.3833 \n", + "10 66.5177 60.3311 39.8766 \n", + "11 66.6282 60.6161 38.4111 \n", + "12 61.2202 55.3781 37.5241 \n", + "13 57.8458 52.7637 35.5573 \n", + "14 57.6852 52.6325 35.2873 \n", + "15 26.1562 20.8115 16.4288 \n", + "16 23.8263 18.9072 14.7320 \n", + "17 23.7409 18.5453 14.9248 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/249d... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2b0j... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/3aek... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/3nxd... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2lv5... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/wsc5... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2sb5... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/1qvv... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/1zop... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/2crw... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3lpx... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/2bqh... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/24it... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/2ir8... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/hq0o... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/1wmr... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/ask4... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/236v... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val \\\n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001_... 99.1597 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001_... 99.0256 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001_... 98.7217 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.2610 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.1329 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05_s... 99.3325 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.6442 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.6591 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06_s... 98.7455 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.3355 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.1895 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05_s... 99.2819 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 99.0495 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 98.9809 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06_s... 99.1418 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8337 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8456 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07_s... 97.8546 \n", + "\n", + " test_acc/ood_val test_acc/ood_test \\\n", + "0 94.2041 95.9355 \n", + "1 94.9003 95.2195 \n", + "2 92.6828 94.8891 \n", + "3 93.7887 94.7645 \n", + "4 94.3932 93.6146 \n", + "5 93.8775 92.7552 \n", + "6 92.7687 95.4511 \n", + "7 92.2273 95.2183 \n", + "8 92.0124 95.3383 \n", + "9 95.1152 96.9361 \n", + "10 94.1697 96.1812 \n", + "11 95.1553 96.3270 \n", + "12 92.9693 95.4735 \n", + "13 92.7515 94.6940 \n", + "14 92.5166 95.1066 \n", + "15 92.8232 94.6481 \n", + "16 93.0810 94.7986 \n", + "17 93.0151 94.8527 \n", + "\n", + " wandb_url \\\n", + "0 https://wandb.ai/p-lambda/finetuning/runs/3aew... \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3pgh... \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1zp9... \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2ktv... \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3179... \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/rnel... \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3k6b... \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/9f0p... \n", + "8 https://wandb.ai/p-lambda/finetuning/runs/3se2... \n", + "9 https://wandb.ai/p-lambda/finetuning/runs/3kzy... \n", + "10 https://wandb.ai/p-lambda/finetuning/runs/3d3p... \n", + "11 https://wandb.ai/p-lambda/finetuning/runs/17fj... \n", + "12 https://wandb.ai/p-lambda/finetuning/runs/3u8y... \n", + "13 https://wandb.ai/p-lambda/finetuning/runs/34un... \n", + "14 https://wandb.ai/p-lambda/finetuning/runs/1xmj... \n", + "15 https://wandb.ai/p-lambda/finetuning/runs/2iqx... \n", + "16 https://wandb.ai/p-lambda/finetuning/runs/35hv... \n", + "17 https://wandb.ai/p-lambda/finetuning/runs/3bvu... \n", + "\n", + " group \n", + "0 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "1 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "2 layer-wise-tune-True_optimizer.args.lr-0.0001 \n", + "3 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "4 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "5 layer-wise-tune-True_optimizer.args.lr-1e-05 \n", + "6 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "7 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "8 layer-wise-tune-True_optimizer.args.lr-1e-06 \n", + "9 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "10 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "11 layer-wise-tune-True_optimizer.args.lr-3e-05 \n", + "12 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "13 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "14 layer-wise-tune-True_optimizer.args.lr-3e-06 \n", + "15 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "16 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "17 layer-wise-tune-True_optimizer.args.lr-3e-07 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 98.1176 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 98.1765 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 96.2353 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.2353 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 91.4118 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.8824 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 96.0000 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 71.2353 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 83.5882 \n", + "1 79.5294 \n", + "2 70.8235 \n", + "3 84.1765 \n", + "4 74.8824 \n", + "5 84.7059 \n", + "6 77.8824 \n", + "7 56.5294 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/138g... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2lqs... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/185g... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/2o2z... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1ufa... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/qyz8... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3kg7... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/3ofw... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.7633 64.0187 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 97.7132 65.1090 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 95.9931 30.6854 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 96.8696 57.7882 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 78.0727 0.0000 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.2860 66.8224 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 95.3479 14.3302 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 76.7741 0.0000 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2lvy... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2htp... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/1xf9... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/37yi... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/1vwm... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/273s... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/bfpd... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/x0nb... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 95.1230 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 93.5807 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 89.2872 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 91.2880 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 32.2634 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 93.8308 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 67.9867 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 9.0038 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 90.3644 https://wandb.ai/p-lambda/finetuning/runs/3tyw... \n", + "1 85.2801 https://wandb.ai/p-lambda/finetuning/runs/2k27... \n", + "2 70.1858 https://wandb.ai/p-lambda/finetuning/runs/wosn... \n", + "3 79.0580 https://wandb.ai/p-lambda/finetuning/runs/11o5... \n", + "4 16.3906 https://wandb.ai/p-lambda/finetuning/runs/1cib... \n", + "5 83.9263 https://wandb.ai/p-lambda/finetuning/runs/242n... \n", + "6 47.9908 https://wandb.ai/p-lambda/finetuning/runs/2cu3... \n", + "7 6.0493 https://wandb.ai/p-lambda/finetuning/runs/a1ev... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-06 \n", + "5 optimizer.args.lr-3e-05 \n", + "6 optimizer.args.lr-3e-06 \n", + "7 optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 67.9178 66.1863 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 47.3918 47.9538 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 15.7624 17.8509 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 62.4924 61.0244 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 26.6394 28.8024 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 11.1382 11.9407 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 59.2365 38.7582 \n", + "1 43.8484 32.2792 \n", + "2 12.8686 7.2503 \n", + "3 55.2108 37.6012 \n", + "4 23.6928 15.9661 \n", + "5 9.2093 1.9283 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1c88... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/2hzp... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2elk... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/ryko... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3ifo... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/35s8... optimizer.args.lr-3e-07 \n", + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.5232 93.3818 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.3176 94.6883 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.1943 91.3849 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.4815 94.1955 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.9869 92.4622 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 96.2992 92.8747 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 93.3948 https://wandb.ai/p-lambda/finetuning/runs/3nvc... \n", + "1 95.3406 https://wandb.ai/p-lambda/finetuning/runs/1p4m... \n", + "2 91.7688 https://wandb.ai/p-lambda/finetuning/runs/1z8r... \n", + "3 96.1613 https://wandb.ai/p-lambda/finetuning/runs/wr9d... \n", + "4 92.1779 https://wandb.ai/p-lambda/finetuning/runs/gj7w... \n", + "5 93.8933 https://wandb.ai/p-lambda/finetuning/runs/2tdk... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + "living17_nonorm name test_acc/source_val_living \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 97.5882 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 97.3529 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 95.8235 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 97.4706 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 92.8235 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.7059 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 96.3529 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 74.5294 \n", + "\n", + " test_acc/target_val_living \\\n", + "0 81.3529 \n", + "1 79.8824 \n", + "2 67.6471 \n", + "3 84.8235 \n", + "4 79.3529 \n", + "5 83.8824 \n", + "6 80.8235 \n", + "7 63.6471 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/1rvf... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/1k06... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2lm1... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/14j4... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/2j6q... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1lry... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/3ebz... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/ljkn... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "waterbirds name WATERBIRDS_VAL WORST \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 96.3042 44.2368 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 95.0043 20.0935 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 89.5186 3.7383 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 96.9109 56.5421 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 78.5911 0.0000 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 97.1196 48.5981 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 95.7925 21.6511 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 76.8178 0.0000 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/2fuj... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/3s5h... optimizer.args.lr-0.0003 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/bk9a... optimizer.args.lr-0.001 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/1dtz... optimizer.args.lr-1e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3esy... optimizer.args.lr-1e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/1p3r... optimizer.args.lr-3e-05 \n", + "6 https://wandb.ai/p-lambda/finetuning/runs/2t2e... optimizer.args.lr-3e-06 \n", + "7 https://wandb.ai/p-lambda/finetuning/runs/eff9... optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "domainnet name test_acc/sketch_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 90.1626 \n", + "1 optimizer.args.lr-0.0003_seed-0_run0 83.3681 \n", + "2 optimizer.args.lr-0.001_seed-0_run0 72.6553 \n", + "3 optimizer.args.lr-1e-05_seed-0_run0 91.4965 \n", + "4 optimizer.args.lr-1e-06_seed-0_run0 27.7199 \n", + "5 optimizer.args.lr-3e-05_seed-0_run0 93.2472 \n", + "6 optimizer.args.lr-3e-06_seed-0_run0 21.5090 \n", + "7 optimizer.args.lr-3e-07_seed-0_run0 9.1288 \n", + "\n", + " test_acc/real_val wandb_url \\\n", + "0 78.7556 https://wandb.ai/p-lambda/finetuning/runs/6xuy... \n", + "1 63.5892 https://wandb.ai/p-lambda/finetuning/runs/13jn... \n", + "2 34.8408 https://wandb.ai/p-lambda/finetuning/runs/2izf... \n", + "3 80.2535 https://wandb.ai/p-lambda/finetuning/runs/nbzx... \n", + "4 14.0285 https://wandb.ai/p-lambda/finetuning/runs/2c5l... \n", + "5 83.8398 https://wandb.ai/p-lambda/finetuning/runs/bmfh... \n", + "6 8.8434 https://wandb.ai/p-lambda/finetuning/runs/wlgh... \n", + "7 6.3949 https://wandb.ai/p-lambda/finetuning/runs/1rkr... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-0.0003 \n", + "2 optimizer.args.lr-0.001 \n", + "3 optimizer.args.lr-1e-05 \n", + "4 optimizer.args.lr-1e-06 \n", + "5 optimizer.args.lr-3e-05 \n", + "6 optimizer.args.lr-3e-06 \n", + "7 optimizer.args.lr-3e-07 \n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "fmow_all_nonorm_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 66.9860 65.7243 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 47.3134 48.0191 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 14.7087 16.5051 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 60.7942 59.9749 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 23.8352 26.1913 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 10.9989 11.8303 \n", + "\n", + " test_acc/ood_test test_acc/africa_test \\\n", + "0 58.9289 38.6425 \n", + "1 43.1925 31.7007 \n", + "2 12.2490 6.7104 \n", + "3 54.4102 37.7169 \n", + "4 21.2593 14.6548 \n", + "5 9.2093 1.8897 \n", + "\n", + " wandb_url group \n", + "0 https://wandb.ai/p-lambda/finetuning/runs/4m5k... optimizer.args.lr-0.0001 \n", + "1 https://wandb.ai/p-lambda/finetuning/runs/38yn... optimizer.args.lr-1e-05 \n", + "2 https://wandb.ai/p-lambda/finetuning/runs/2shg... optimizer.args.lr-1e-06 \n", + "3 https://wandb.ai/p-lambda/finetuning/runs/20v2... optimizer.args.lr-3e-05 \n", + "4 https://wandb.ai/p-lambda/finetuning/runs/3fra... optimizer.args.lr-3e-06 \n", + "5 https://wandb.ai/p-lambda/finetuning/runs/fmd3... optimizer.args.lr-3e-07 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "camelyon17_weakaugs name test_acc/id_val test_acc/ood_val \\\n", + "0 optimizer.args.lr-0.0001_seed-0_run0 99.2193 85.9844 \n", + "1 optimizer.args.lr-1e-05_seed-0_run0 99.1806 94.0694 \n", + "2 optimizer.args.lr-1e-06_seed-0_run0 98.4118 89.9353 \n", + "3 optimizer.args.lr-3e-05_seed-0_run0 99.3445 94.1124 \n", + "4 optimizer.args.lr-3e-06_seed-0_run0 98.9273 91.0411 \n", + "5 optimizer.args.lr-3e-07_seed-0_run0 96.9249 91.2073 \n", + "\n", + " test_acc/ood_test wandb_url \\\n", + "0 75.9976 https://wandb.ai/p-lambda/finetuning/runs/2hlj... \n", + "1 94.2683 https://wandb.ai/p-lambda/finetuning/runs/uaha... \n", + "2 89.2750 https://wandb.ai/p-lambda/finetuning/runs/1lmq... \n", + "3 93.2843 https://wandb.ai/p-lambda/finetuning/runs/2km8... \n", + "4 91.7335 https://wandb.ai/p-lambda/finetuning/runs/2wbk... \n", + "5 92.4272 https://wandb.ai/p-lambda/finetuning/runs/2ja1... \n", + "\n", + " group \n", + "0 optimizer.args.lr-0.0001 \n", + "1 optimizer.args.lr-1e-05 \n", + "2 optimizer.args.lr-1e-06 \n", + "3 optimizer.args.lr-3e-05 \n", + "4 optimizer.args.lr-3e-06 \n", + "5 optimizer.args.lr-3e-07 \n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8 (0.2)\t97.2 (0.1)\t88.8 (7.1)\t67.0 (0.8)\t99.4 (0.0)\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1 (0.1)\t97.7 (0.0)\t95.0 (0.1)\t70.1 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2 (0.3)\t97.8 (0.1)\t94.9 (0.3)\t70.0 (0.2)\t99.5 (0.0)\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3 (0.1)\t98.3 (0.0)\t96.3 (0.1)\t69.2 (0.5)\t99.3 (0.1)\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2 (nan)\t97.8 (nan)\t95.1 (nan)\t67.9 (nan)\t99.5 (nan)\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7 (nan)\t97.1 (nan)\t93.2 (nan)\t67.0 (nan)\t99.3 (nan)\t90.9\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 (0.2) & & 97.2 (0.1) & & 88.8 (7.1) & & 67.0 (0.8) & & 99.4 (0.0) & & 90.0 & \\\\\n", + "AdamW & 98.1 (0.1) & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 (0.0) & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 (0.1) & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5 (0.0)} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 (0.1) & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 (0.3) & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0 (0.2)} & \\hspace{-1em}{\\hgreen{(+3.0)}} & 99.5 (0.0) & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3 (0.0)} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3 (0.1)} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 (0.5) & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 (0.1) & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0 (1.3)\t62.5 (5.0)\t72.8 (18.0)\t37.3 (1.1)\t86.8 (1.1)\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8 (1.2)\t71.9 (2.4)\t89.2 (1.1)\t40.7 (0.3)\t95.7 (0.4)\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2 (0.8)\t73.7 (1.1)\t88.2 (0.7)\t40.2 (0.7)\t94.3 (0.3)\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9 (0.1)\t69.1 (3.4)\t93.2 (0.3)\t40.5 (1.2)\t96.5 (0.4)\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5 (nan)\t64.0 (nan)\t90.4 (nan)\t38.8 (nan)\t93.4 (nan)\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9 (nan)\t48.6 (nan)\t83.8 (nan)\t38.6 (nan)\t93.3 (nan)\t69.6\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 (1.3) & & 62.5 (5.0) & & 72.8 (18.0) & & 37.3 (1.1) & & 86.8 (1.1) & & 67.9 & \\\\\n", + "AdamW & \\textbf{82.8 (1.2)} & \\hspace{-1em}{\\hgreen{(+2.8)}} & \\textbf{71.9 (2.4)} & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 (1.1) & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7 (0.3)} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 (0.4) & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{83.2 (0.8)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{73.7 (1.1)} & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 (0.7) & \\hspace{-1em}{\\hgreen{(+15.4)}} & \\textbf{40.2 (0.7)} & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 (0.3) & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 (0.1) & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 (3.4) & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2 (0.3)} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5 (1.2)} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5 (0.4)} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ]]]))" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", @@ -301,9 +2084,9 @@ "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_main.pkl\", \"wb\" ) )\n", - "mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", + "# mean_table, std_table = pickle.load( open( \"clip_table_main.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS']\n", @@ -489,28 +2272,153 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CLIP Results, all datasets\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.Lamb_ domainnet 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ living17_nonorm 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ waterbirds 8\n", + "not all jobs ran: clip_vit_b16 opt_torch_optimizer.LARS_ domainnet 8\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t97.8\t97.2\t88.8\t67.0\t99.4\t90.0\n", + "CLIP ViT-B/16\tAdamW\t98.1\t97.7\t95.0\t70.1\t99.5\t92.1\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t98.2\t97.8\t94.9\t70.0\t99.5\t92.1\n", + "CLIP ViT-B/16\tLayer-wise\t98.3\t98.3\t96.3\t69.2\t99.3\t92.3\n", + "CLIP ViT-B/16\tLAMB\t98.2\t97.8\t95.1\t67.9\t99.5\t91.7\n", + "CLIP ViT-B/16\tLARS\t97.7\t97.1\t93.2\t67.0\t99.3\t90.9\n", + "CLIP ViT-B/16\tSGD (Freeze-embed, not layer-norm)\t98.0\t98.0\t95.4\t70.2\t99.5\t92.2\n", + "CLIP ViT-B/16\tSGD (no momentum)\t98.0\t97.1\t89.5\t66.4\t99.3\t90.1\n", + "CLIP ViT-B/16\tSGD (weight decay)\t97.6\t97.2\t87.9\t66.4\t99.3\t89.7\n", + "CLIP ViT-B/16\tSGD (lower LR, embed layer)\t98.0\t97.5\t94.8\t68.7\t99.5\t91.7\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 97.8 & & 97.2 & & 88.8 & & 67.0 & & \\textbf{99.4} & & 90.0 & \\\\\n", + "AdamW & 98.1 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 97.7 & \\hspace{-1em}{\\hgreen{(+0.5)}} & 95.0 & \\hspace{-1em}{\\hgreen{(+6.2)}} & \\textbf{70.1} & \\hspace{-1em}{\\hgreen{(+3.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "SGD (Freeze-embed) & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 94.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & \\textbf{70.0} & \\hspace{-1em}{\\hgreen{(+3.0)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.1} & \\hspace{-1em}{\\hgreen{(+2.1)}}\\\\\n", + "Layer-wise & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{98.3} & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{96.3} & \\hspace{-1em}{\\hgreen{(+7.5)}} & 69.2 & \\hspace{-1em}{\\hgreen{(+2.2)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{92.3} & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "LAMB & \\textbf{98.2} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 97.8 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 95.1 & \\hspace{-1em}{\\hgreen{(+6.3)}} & 67.9 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "LARS & 97.7 & \\hspace{-1em}{\\lred{(-0.1)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 93.2 & \\hspace{-1em}{\\hgreen{(+4.4)}} & 67.0 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.9 & \\hspace{-1em}{\\hgreen{(+0.9)}}\\\\\n", + "SGD (Freeze-embed, not layer-norm) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 98.0 & \\hspace{-1em}{\\hgreen{(+0.8)}} & 95.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{70.2} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & \\textbf{92.2} & \\hspace{-1em}{\\hgreen{(+2.2)}}\\\\\n", + "SGD (no momentum) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 97.1 & \\hspace{-1em}{\\lred{(-0.1)}} & 89.5 & \\hspace{-1em}{\\hgreen{(+0.7)}} & 66.4 & \\hspace{-1em}{\\hred{(-0.6)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 90.1 & \\hspace{-1em}{\\lgreen{(+0.1)}}\\\\\n", + "SGD (weight decay) & 97.6 & \\hspace{-1em}{\\hred{(-0.2)}} & 97.2 & \\hspace{-1em}{\\lgreen{(+0.0)}} & 87.9 & \\hspace{-1em}{\\hred{(-0.9)}} & 66.4 & \\hspace{-1em}{\\hred{(-0.6)}} & 99.3 & \\hspace{-1em}{\\lred{(-0.1)}} & 89.7 & \\hspace{-1em}{\\hred{(-0.3)}}\\\\\n", + "SGD (lower LR, embed layer) & 98.0 & \\hspace{-1em}{\\lgreen{(+0.2)}} & 97.5 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 94.8 & \\hspace{-1em}{\\hgreen{(+6.0)}} & 68.7 & \\hspace{-1em}{\\hgreen{(+1.7)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.7 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiv-17\tWaterbirds\tDomainNet\tFMoW\tCamelyon\tAvg.\n", + "CLIP ViT-B/16\tSGD\t80.0\t62.5\t72.8\t37.3\t86.8\t67.9\n", + "CLIP ViT-B/16\tAdamW\t82.8\t71.9\t89.2\t40.7\t95.7\t76.0\n", + "CLIP ViT-B/16\tSGD (Freeze-embed)\t83.2\t73.7\t88.2\t40.2\t94.3\t75.9\n", + "CLIP ViT-B/16\tLayer-wise\t81.9\t69.1\t93.2\t40.5\t96.5\t76.2\n", + "CLIP ViT-B/16\tLAMB\t79.5\t64.0\t90.4\t38.8\t93.4\t73.2\n", + "CLIP ViT-B/16\tLARS\t83.9\t48.6\t83.8\t38.6\t93.3\t69.6\n", + "CLIP ViT-B/16\tSGD (Freeze-embed, not layer-norm)\t83.6\t74.3\t89.1\t39.3\t92.9\t75.9\n", + "CLIP ViT-B/16\tSGD (no momentum)\t81.4\t59.2\t76.7\t37.9\t84.3\t67.9\n", + "CLIP ViT-B/16\tSGD (weight decay)\t83.9\t65.1\t67.5\t37.1\t85.6\t67.8\n", + "CLIP ViT-B/16\tSGD (lower LR, embed layer)\t83.3\t71.7\t85.7\t38.7\t95.7\t75.0\n", + "\n", + "\\begin{tabular}{ccccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Liv-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{DomainNet} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & 80.0 & & 62.5 & & 72.8 & & 37.3 & & 86.8 & & 67.9 & \\\\\n", + "AdamW & 82.8 & \\hspace{-1em}{\\hgreen{(+2.8)}} & 71.9 & \\hspace{-1em}{\\hgreen{(+9.4)}} & 89.2 & \\hspace{-1em}{\\hgreen{(+16.4)}} & \\textbf{40.7} & \\hspace{-1em}{\\hgreen{(+3.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & \\textbf{76.0} & \\hspace{-1em}{\\hgreen{(+8.1)}}\\\\\n", + "SGD (Freeze-embed) & 83.2 & \\hspace{-1em}{\\hgreen{(+3.2)}} & 73.7 & \\hspace{-1em}{\\hgreen{(+11.2)}} & 88.2 & \\hspace{-1em}{\\hgreen{(+15.4)}} & 40.2 & \\hspace{-1em}{\\hgreen{(+2.9)}} & 94.3 & \\hspace{-1em}{\\hgreen{(+7.5)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "Layer-wise & 81.9 & \\hspace{-1em}{\\hgreen{(+1.9)}} & 69.1 & \\hspace{-1em}{\\hgreen{(+6.6)}} & \\textbf{93.2} & \\hspace{-1em}{\\hgreen{(+20.4)}} & \\textbf{40.5} & \\hspace{-1em}{\\hgreen{(+3.2)}} & \\textbf{96.5} & \\hspace{-1em}{\\hgreen{(+9.7)}} & \\textbf{76.2} & \\hspace{-1em}{\\hgreen{(+8.3)}}\\\\\n", + "LAMB & 79.5 & \\hspace{-1em}{\\hred{(-0.5)}} & 64.0 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 90.4 & \\hspace{-1em}{\\hgreen{(+17.6)}} & 38.8 & \\hspace{-1em}{\\hgreen{(+1.5)}} & 93.4 & \\hspace{-1em}{\\hgreen{(+6.6)}} & 73.2 & \\hspace{-1em}{\\hgreen{(+5.3)}}\\\\\n", + "LARS & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 48.6 & \\hspace{-1em}{\\hred{(-13.9)}} & 83.8 & \\hspace{-1em}{\\hgreen{(+11.0)}} & 38.6 & \\hspace{-1em}{\\hgreen{(+1.3)}} & 93.3 & \\hspace{-1em}{\\hgreen{(+6.5)}} & 69.6 & \\hspace{-1em}{\\hgreen{(+1.7)}}\\\\\n", + "SGD (Freeze-embed, not layer-norm) & 83.6 & \\hspace{-1em}{\\hgreen{(+3.6)}} & \\textbf{74.3} & \\hspace{-1em}{\\hgreen{(+11.8)}} & 89.1 & \\hspace{-1em}{\\hgreen{(+16.3)}} & 39.3 & \\hspace{-1em}{\\hgreen{(+2.0)}} & 92.9 & \\hspace{-1em}{\\hgreen{(+6.1)}} & 75.9 & \\hspace{-1em}{\\hgreen{(+8.0)}}\\\\\n", + "SGD (no momentum) & 81.4 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 59.2 & \\hspace{-1em}{\\hred{(-3.3)}} & 76.7 & \\hspace{-1em}{\\hgreen{(+3.9)}} & 37.9 & \\hspace{-1em}{\\hgreen{(+0.6)}} & 84.3 & \\hspace{-1em}{\\hred{(-2.5)}} & 67.9 & \\hspace{-1em}{\\lgreen{(+0.0)}}\\\\\n", + "SGD (weight decay) & \\textbf{83.9} & \\hspace{-1em}{\\hgreen{(+3.9)}} & 65.1 & \\hspace{-1em}{\\hgreen{(+2.6)}} & 67.5 & \\hspace{-1em}{\\hred{(-5.3)}} & 37.1 & \\hspace{-1em}{\\lred{(-0.2)}} & 85.6 & \\hspace{-1em}{\\hred{(-1.2)}} & 67.8 & \\hspace{-1em}{\\lred{(-0.1)}}\\\\\n", + "SGD (lower LR, embed layer) & 83.3 & \\hspace{-1em}{\\hgreen{(+3.3)}} & 71.7 & \\hspace{-1em}{\\hgreen{(+9.2)}} & 85.7 & \\hspace{-1em}{\\hgreen{(+12.9)}} & 38.7 & \\hspace{-1em}{\\hgreen{(+1.4)}} & 95.7 & \\hspace{-1em}{\\hgreen{(+8.9)}} & 75.0 & \\hspace{-1em}{\\hgreen{(+7.1)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[97.82353333, 97.22233333, 88.8009 , 66.9715 ,\n", + " 99.3802 , 90.03969333],\n", + " [98.09803333, 97.7472 , 94.9979 , 70.11816667,\n", + " 99.5451 , 92.10128 ],\n", + " [98.15683333, 97.8062 , 94.91456667, 70.00203333,\n", + " 99.52623333, 92.08117333],\n", + " [98.31373333, 98.2936 , 96.30403333, 69.19793333,\n", + " 99.26896667, 92.27565333],\n", + " [98.1765 , 97.7633 , 95.123 , 67.9178 ,\n", + " 99.5232 , 91.70076 ],\n", + " [97.7059 , 97.1196 , 93.2472 , 66.986 ,\n", + " 99.3445 , 90.88064 ],\n", + " [98. , 98.0037 , 95.4148 , 70.1646 ,\n", + " 99.5262 , 92.22186 ],\n", + " [98. , 97.071 , 89.5373 , 66.3764 ,\n", + " 99.3236 , 90.06166 ],\n", + " [97.6471 , 97.2224 , 87.8699 , 66.3503 ,\n", + " 99.2938 , 89.6767 ],\n", + " [98. , 97.5392 , 94.7895 , 68.6841 ,\n", + " 99.5113 , 91.70482 ]]]),\n", + " array([[[79.9608 , 62.46103333, 72.77833333, 37.34413333,\n", + " 86.79546667, 67.86795333],\n", + " [82.80393333, 71.85876667, 89.16893333, 40.66073333,\n", + " 95.72586667, 76.04364667],\n", + " [83.17646667, 73.72796667, 88.22793333, 40.18513333,\n", + " 94.29106667, 75.92171333],\n", + " [81.90196667, 69.05503333, 93.24016667, 40.46796667,\n", + " 96.48143333, 76.22931333],\n", + " [79.5294 , 64.0187 , 90.3644 , 38.7582 ,\n", + " 93.3948 , 73.2131 ],\n", + " [83.8824 , 48.5981 , 83.8398 , 38.6425 ,\n", + " 93.2843 , 69.64942 ],\n", + " [83.6471 , 74.2991 , 89.0681 , 39.2981 ,\n", + " 92.941 , 75.85068 ],\n", + " [81.3529 , 59.19 , 76.6671 , 37.9483 ,\n", + " 84.2829 , 67.88824 ],\n", + " [83.9412 , 65.109 , 67.478 , 37.0613 ,\n", + " 85.5645 , 67.8308 ],\n", + " [83.2941 , 71.6511 , 85.6834 , 38.7196 ,\n", + " 95.6675 , 75.00314 ]]]))" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "print(\"CLIP Results, all datasets\")\n", "models = ['clip_vit_b16']\n", "# options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'freeze_bottom_2_optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", - "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'layer_wise_tune__', 'opt_torch_optimizer.Lamb_', 'opt_torch_optimizer.LARS_', 'freeze_bottom_1_', 'optimizer.args.momentum-0.0_', 'optimizer.args.weight_decay-0.01_', 'embed_layer_lr_multiplier-0.2_']\n", "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", "desired_epochs_list = [20, 20, 50, 5, 3]\n", "\n", - "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", "# pickle.dump( (mean_table, std_table), open( \"clip_table_extended.pkl\", \"wb\" ) )\n", - "mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", + "# mean_table, std_table = pickle.load( open( \"clip_table_extended.pkl\", \"rb\" ) )\n", "\n", "shorted_model_names = ['CLIP ViT-B/16']\n", "# shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'Freeze only embed', 'SGD (no momentum)', 'SGD (Freeze, no momentum)', 'SGD (weight decay)']\n", - "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (Freeze-embed)', 'Layer-wise', 'LAMB', 'LARS', 'SGD (Freeze-embed, not layer-norm)', 'SGD (no momentum)', 'SGD (weight decay)', 'SGD (lower LR, embed layer)']\n", "shortened_output_metrics_list = ['Living-17 ID', 'Living-17 OOD', 'Waterbirds ID', 'Waterbirds OOD', 'DomainNet ID', 'DomainNet OOD', \"FMoW ID\", \"FMoW OOD Val\", \"FMoW OOD Test\", \"FMoW Africa\", \"Camelyon ID\", \"Camelyon OOD Val\", \"Camelyon OOD Test\"]\n", "\n", "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", @@ -520,6 +2428,70 @@ "display_id_ood_tables(mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Big table with no momentum" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "not all jobs ran: clip_vit_l14 freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 1\n", + "not all jobs ran: timm_vit_b16_in21k freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 1\n", + "not all jobs ran: timm_vit_b16_in21k freeze_bottom_2_optimizer.args.momentum-0.0_ fmow_all_nonorm_weakaugs 4\n", + "not all jobs ran: dino_vit_b16 freeze_bottom_2_optimizer.args.momentum-0.0_ domainnet 5\n", + "empty dir ../logs//full_ft_freeze_bottom_2_optimizer.args.momentum-0.0_fmow_all_nonorm_weakaugs_dino_vit_b16\n" + ] + }, + { + "ename": "TypeError", + "evalue": "object of type 'NoneType' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mmean_table\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_table\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname_template\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_metrics_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maggregation_metric_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdesired_epochs_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# Rearranging mean table\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mget_table\u001b[0;34m(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, num_sweep, desired_epochs_list)\u001b[0m\n\u001b[1;32m 46\u001b[0m res, best_row_mean, best_row_std, num_epochs_list = summarize_all_results.get_experiment_aggregate_summary(\n\u001b[1;32m 47\u001b[0m dir_path, val_metric, output_metrics, aggregation_metric=agg_metric)\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mnum_jobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 49\u001b[0m if (desired_epochs_list is not None and\n\u001b[1;32m 50\u001b[0m desired_epochs_list[dataset_idx] != np.min(num_epochs_list)):\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" + ] + } + ], + "source": [ + "# Big table, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped)\n", + "models = ['clip_vit_b16', 'clip_vit_l14', 'timm_vit_b16_in21k', 'dino_vit_b16', 'convnext_vit_b', 'bit_resnet_50_in21k', 'bit_resnet_101_in21k']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_2_optimizer.args.momentum-0.0_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 50, 5, 3]\n", + "shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101', ]\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-embed)', 'SGD (freeze-embed, no momentum)']\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "\n", + "# Rearranging mean table\n", + "mean_table = mean_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "std_table = std_table_old_order[[0,6,1,2,5,3,4],:,:]\n", + "\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 9893c26..6c05891 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1193,6 +1193,54 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=[] ) +timm_vit_l32_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch32_224_in21k', + }, + bundles=[] +) + +timm_vit_l16_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch16_224_in21k', + }, + bundles=[] +) + +timm_vit_h14_in21k = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_huge_patch14_224_in21k', + }, + bundles=[] +) + +timm_clip_vit_l14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_large_patch14_224_clip_laion2b', + }, + bundles=[] +) + +timm_clip_vit_h14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_huge_patch14_224_clip_laion2b', + }, + bundles=[] +) + +timm_clip_vit_g14 = Model( + kwargs={ + 'classname': 'models.vit_model.VitModel', + 'args.model_name': 'timm.vit_giant_patch14_224_clip_laion2b', + }, + bundles=[] +) + convnext_vit_b = Model( kwargs={ 'classname': 'models.timm_model.TimmModel', @@ -1259,8 +1307,14 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'clip_vit_b16': clip_vit_b16, 'clip_vit_l14': clip_vit_l14, 'clip_vit_l14_highres': clip_vit_l14_highres, + 'timm_vit_l32_in21k': timm_vit_l32_in21k, + 'timm_vit_l16_in21k': timm_vit_l16_in21k, + 'timm_vit_h14_in21k': timm_vit_h14_in21k, 'timm_vit_b16': timm_vit_b16, 'timm_vit_b16_in21k': timm_vit_b16_in21k, + 'timm_clip_vit_l14': timm_clip_vit_l14, + 'timm_clip_vit_h14': timm_clip_vit_h14, + 'timm_clip_vit_g14': timm_clip_vit_g14, 'convnext_vit_b': convnext_vit_b, 'scratch_vit_b16_clipstyle': scratch_vit_b16_clipstyle, 'dino_vit_b16': dino_vit_b16, diff --git a/scripts/run_jag10_11_sbatch.sh b/scripts/run_jag10_11_sbatch.sh new file mode 100644 index 0000000..9fac09d --- /dev/null +++ b/scripts/run_jag10_11_sbatch.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --partition=jag-standard +#SBATCH --mem=16G +#SBATCH --exclude=jagupard[15-31] +#SBATCH --account=nlp + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue-new + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index e657813..6b1b046 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --partition=jag-standard #SBATCH --mem=16G +#SBATCH --account=nlp #SBATCH --exclude=jagupard[13,14,15,17,18] # #SBATCH --exclude=jagupard[14,17,18,20] diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh new file mode 100644 index 0000000..03bad48 --- /dev/null +++ b/scripts/run_sphinx_big_sbatch.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=24G +#SBATCH --partition=sphinx +#SBATCH --exclude=sphinx[1,2,3,8] +#SBATCH --account=nlp + +# Print execute commands in the log. +set -x +conda_env=`whoami`-ue-new + +# source scripts/copy_imagenet_local.sh +source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh +conda deactivate +conda activate $conda_env +cd $PWD + +eval $1 + diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 0829412..7e1f92a 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3,5,6,7,8] +#SBATCH --exclude=sphinx[3] #SBATCH --account=nlp # Print execute commands in the log. From 29acb9bd0e95368663e20aaa2686b46682a6d2f5 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 25 Dec 2022 18:50:57 -0800 Subject: [PATCH 183/197] Codalab --- configs/adaptation/datasets_cifar_stl.yaml | 5 - .../adaptation/datasets_cifar_stl_nonorm.yaml | 4 - configs/adaptation/datasets_fmow.yaml | 10 +- configs/adaptation/datasets_fmow_all.yaml | 12 +- .../adaptation/datasets_fmow_all_nonorm.yaml | 12 +- .../datasets_fmow_all_nonorm_weakaugs.yaml | 14 +-- scripts/codalab.sh | 27 +++++ scripts/run_adaptation_experiments.py | 103 +++++++++++++----- scripts/summarize_all_results.py | 18 ++- scripts/summarize_linprobe_results.py | 18 ++- scripts/summarize_results.py | 12 +- unlabeled_extrapolation/extract_features.py | 1 + 12 files changed, 170 insertions(+), 66 deletions(-) create mode 100644 scripts/codalab.sh diff --git a/configs/adaptation/datasets_cifar_stl.yaml b/configs/adaptation/datasets_cifar_stl.yaml index 7c14df6..d991787 100644 --- a/configs/adaptation/datasets_cifar_stl.yaml +++ b/configs/adaptation/datasets_cifar_stl.yaml @@ -40,13 +40,8 @@ test_datasets: args: root: 'stl10_dataset/' split: 'test' - - name: 'imnet-n-cifar' - classname: datasets.imnet_intersect_c10.ImNetnC10 - args: - root: 'balanced_imnet_intersect_c10_val/' early_stop_dataset_names: - 'cifar10-test' - 'stl-test' - - 'imnet-n-cifar' diff --git a/configs/adaptation/datasets_cifar_stl_nonorm.yaml b/configs/adaptation/datasets_cifar_stl_nonorm.yaml index 04dc3d2..1f76039 100644 --- a/configs/adaptation/datasets_cifar_stl_nonorm.yaml +++ b/configs/adaptation/datasets_cifar_stl_nonorm.yaml @@ -32,10 +32,6 @@ test_datasets: args: root: 'stl10_dataset/' split: 'test' - - name: 'imnet-n-cifar' - classname: datasets.imnet_intersect_c10.ImNetnC10 - args: - root: 'balanced_imnet_intersect_c10_val/' early_stop_dataset_names: {} diff --git a/configs/adaptation/datasets_fmow.yaml b/configs/adaptation/datasets_fmow.yaml index 7679ea3..11f151f 100644 --- a/configs/adaptation/datasets_fmow.yaml +++ b/configs/adaptation/datasets_fmow.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: [3] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize @@ -32,19 +32,19 @@ test_datasets: args: split: 'val' regions: [1] - root: 'wilds/data' + root: '' - name: 'africa_val' classname: datasets.fmow.Fmow args: split: 'val' regions: [2] - root: 'wilds/data' + root: '' - name: 'americas_val' classname: datasets.fmow.Fmow args: split: 'val' regions: [3] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'americas_val' diff --git a/configs/adaptation/datasets_fmow_all.yaml b/configs/adaptation/datasets_fmow_all.yaml index c0e6ef9..229a6d3 100644 --- a/configs/adaptation/datasets_fmow_all.yaml +++ b/configs/adaptation/datasets_fmow_all.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize @@ -32,26 +32,26 @@ test_datasets: args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'ood_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm.yaml b/configs/adaptation/datasets_fmow_all_nonorm.yaml index c3627fd..cd9b97e 100644 --- a/configs/adaptation/datasets_fmow_all_nonorm.yaml +++ b/configs/adaptation/datasets_fmow_all_nonorm.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.RandomResizedCrop args: @@ -28,26 +28,26 @@ test_datasets: args: split: 'id_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml index 92510df..f85bb33 100644 --- a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.RandomHorizontalFlip - classname: torchvision.transforms.ToTensor @@ -25,31 +25,31 @@ test_datasets: args: split: 'id_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'id_test' classname: datasets.fmow.Fmow args: split: 'id_test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/scripts/codalab.sh b/scripts/codalab.sh new file mode 100644 index 0000000..dd93207 --- /dev/null +++ b/scripts/codalab.sh @@ -0,0 +1,27 @@ + +cl upload cifar10_dataset +cl upload stl10_dataset +cl upload domainnet +cl upload simclr_weights +cl upload configs +cl upload unlabeled_extrapolation +cl upload scripts + +# CIFAR-STL experiments. +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=lp_then_ft_valmode_experiments --codalab --no_replications + +# DomainNet experiments. +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=lp_then_ft_valmode_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=ft_val_mode_experiment --codalab --no_replications + +# FMoW experiments. + +# Living-17, Entity-30, CIFAR-STL. + +# ImageNet. + + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6c05891..6fcda40 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -45,12 +45,13 @@ def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=' nlp_opt = '' cl_deps_str = ':' + ' :'.join(deps) bundles = ':unlabeled_extrapolation :scripts :configs ' + cl_deps_str + ' ' - makedirs = '"export PYTHONPATH=\'.\'; export PYTHONPATH=\'' + args.code_dir + '\'; ' + makedirs = '"export PYTHONPATH=\'.\'; ' + # export PYTHONPATH=\'' + args.code_dir + '\'; ' codalab_cmd = prefix + nlp_opt + bundles + makedirs + cmd + '"' print(codalab_cmd + '\n') if not(args.print_command): subprocess.run(shlex.split(codalab_cmd)) - return job_name + return job_name def run_job(cmd, job_name, args, deps=[]): @@ -461,17 +462,28 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re overwrite_options=overwrite_options) -def linprobe_experiment(adapt_name, dataset, model, num_replications, args, deps=[], rerun=False, +def linprobe_experiment(adapt_name, dataset, model_name, num_replications, args, deps=[], rerun=False, aug=True, train_mode=False, use_new_bn_stats=False): + model = names_to_model[model_name] replication_ids = [] for i in range(num_replications): job_id = run_linprobe_replication(adapt_name, dataset, model, seed=i, args=args, deps=deps, rerun=rerun, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) replication_ids.append(job_id) - summarize_id = summarize_linprobe(adapt_name, dataset, model, args, deps=replication_ids, max_num=num_replications) - all_ids = replication_ids + [summarize_id] - return [summarize_id], all_ids + if not args.codalab: + summarize_id = summarize_linprobe(adapt_name, dataset, model, args, deps=replication_ids, max_num=num_replications) + all_ids = replication_ids + [summarize_id] + return [summarize_id], all_ids + else: + # If Codalab, add sweep experiment, with deps. + codalab_summarize_cmd = get_codalab_summarize_linprobe_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, model_name) + '_summarize' + summarize_id = run_job( + cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=replication_ids) + all_ids = replication_ids + [summarize_id] + return [summarize_id], all_ids + ############################################ @@ -826,12 +838,12 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): cifar_stl = Dataset( name='cifar_stl', val_metric='test_acc/cifar10-test', - secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], + secondary_val_metrics=['test_acc/stl-test', 'LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], config_rel_path='adaptation/cifar_stl.yaml', bundles=['cifar10_dataset', 'stl10_dataset'], slurm_data_cmd=None, @@ -843,10 +855,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): val_metric='test_acc/cifar10-test', secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], config_rel_path='adaptation/cifar_stl_nonorm.yaml', bundles=['cifar_stl'], slurm_data_cmd=None, @@ -881,7 +893,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -896,7 +908,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -911,7 +923,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') fmow_all_nonorm_weakaugs = Dataset( @@ -926,7 +938,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') fmow_all_nonorm_weakaugs_highres = Dataset( @@ -941,7 +953,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') camelyon17_weakaugs = Dataset( @@ -1361,7 +1373,7 @@ def append_to_each(hyperparams_list, more_hyperparams): ## Main experiments. ############################################ -SWEEP_LRS = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] def get_datasets(args): print(args.datasets) @@ -1445,7 +1457,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): -def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, +def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' @@ -1471,8 +1483,8 @@ def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batch sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] elif val_mode: adapt_name += '_valmode' - if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): - sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] + # if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): + # sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] if no_augmentation: adapt_name += '_no_augmentation' if linear_probe: @@ -1620,6 +1632,11 @@ def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batch ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + # If Codalab, add sweep experiment, with deps. + if args.codalab: + codalab_summarize_cmd = get_codalab_summarize_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_summarize' + run_job(cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=all_ids) def fine_tuning_mixup_sweep_experiments(args, num_replications=3): @@ -1685,13 +1702,13 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u raise ValueError('If use_new_bn_stats is True, train_mode must be False.') adapt_name += '_usenewbnstats' datasets = get_datasets(args) - model = names_to_model[args.model_name] if args.no_replications or args.only_one_run: num_replications = 1 for dataset in datasets: all_ids = linprobe_experiment( - adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, - args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + adapt_name=adapt_name, dataset=dataset, model_name=args.model_name, + num_replications=num_replications, args=args, aug=aug, + train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1716,7 +1733,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= sweep_lrs = SWEEP_LRS if val_mode: adapt_name += '_valmode' - sweep_lrs = [1e-4, 3e-5, 1e-5, 3e-6, 1e-6, 3e-7] + # sweep_lrs = [1e-4, 3e-5, 1e-5, 3e-6, 1e-6, 3e-7] linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1797,19 +1814,31 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= # cur_hyperparams_list, # {'linear_probe_checkpoint_path': linprobe_group_path + '/weights_0.pkl'}) replication_hyperparams_list = [] + deps = [] for i in range(num_replications): - replication_hyperparams_list.append({ - 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + if args.codalab: + linprobe_job_name = get_group_name(linprobe_adapt_name, dataset.name, args.model_name) + '_' + str(i) + weights_path = linprobe_job_name + '/logs/weights_' + str(i) + '.pkl' + replication_hyperparams_list.append({ + 'linear_probe_checkpoint_path': weights_path}) + deps.append(linprobe_job_name) + else: + replication_hyperparams_list.append({ + 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers=ignore_name_hypers) + ignore_name_hypers=ignore_name_hypers, deps=deps) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) - + # If Codalab, add sweep experiment, with deps. + if args.codalab: + codalab_summarize_cmd = get_codalab_summarize_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_summarize' + run_job(cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=all_ids) def lp_then_ft_valmode_experiments(args, num_replications=3, options_dict={}): lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, options_dict=options_dict) @@ -1893,6 +1922,23 @@ def summarize_dataset(args): os.system(cmd) +def get_codalab_summarize_python_cmd(dataset): + cmd = 'python scripts/summarize_all_results.py ' + cmd += '--results_dir_glob=. ' + cmd += '--val_metrics ' + dataset.val_metric + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' + cmd += '--one_experiment_json' + return cmd + +def get_codalab_summarize_linprobe_python_cmd(dataset): + cmd = 'python scripts/summarize_linprobe_results.py ' + cmd += '--results_dir=. ' + cmd += '--val_metric ' + dataset.val_metric + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.linprobe_output_metrics) + ' ' + cmd += '--one_experiment_json' + return cmd + + def main(args, options_dict={}): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, @@ -1947,6 +1993,7 @@ def fill_platform_specific_default_args(args): args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if args.pretrained_checkpoints_dir else + '/u/scr/ananya/simclr_weights/') diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index a3b0a5a..e08699d 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -9,6 +9,7 @@ import os import shlex import shutil +import sys import uuid import re import glob @@ -38,7 +39,7 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre grouped = res.groupby('group') means = grouped.mean() counts = grouped.count() - counts.drop(labels=['name', 'wandb_url'], axis=1) + counts.drop(labels=['name'], axis=1) stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) stderrs = stderrs[means.columns] min_count = grouped.count().iloc[:,0].min() @@ -57,6 +58,15 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre for best_row in [best_row_mean, best_row_std]: best_row['group'] = best_row.index best_row.set_index('name') + # Output results.json for the current sweep. + # This is especially useful for displaying results in CodaLab worksheets. + def codalab_reformat(s): + return s.replace('/', '_') + new_columns = [codalab_reformat(s) for s in best_row_mean.columns] + best_row_mean.columns = new_columns + json_output = best_row_mean.iloc[0].to_json() + json_file = open(dir_path + '/results.json', "w") + json_file.write(json_output) return res, best_row_mean, best_row_std, num_epochs_list @@ -87,7 +97,13 @@ def get_all_results(val_metric, dir_paths, output_metrics): parser.add_argument('--output_file', type=str, help='Path to output results, should end with .tsv') parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + # The following option is particularly useful for Codalab, where we just want to summarize all runs + # in a single experiment and store the json file. + parser.add_argument('--one_experiment_json', action='store_true', help="Summarize single experiment in json") args = parser.parse_args() + if args.one_experiment_json: + get_experiment_aggregate_summary(args.results_dir_glob, args.val_metrics[0], args.output_metrics) + sys.exit(0) # Get all folders satisfying glob. dir_paths = glob.glob(args.results_dir_glob, recursive=False) dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] diff --git a/scripts/summarize_linprobe_results.py b/scripts/summarize_linprobe_results.py index b5db401..b127bef 100644 --- a/scripts/summarize_linprobe_results.py +++ b/scripts/summarize_linprobe_results.py @@ -8,6 +8,7 @@ import os import shlex import shutil +import sys import uuid import re import glob @@ -31,15 +32,28 @@ parser.add_argument('--max_num', type=int, help='Max number of lin probe runs to use.') parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + parser.add_argument('--one_experiment_json', action='store_true', help="Summarize single experiment in json") args = parser.parse_args() metrics, results_list = [], [] # Get results for val_metric. - val_results, _, _ = summarize_results( - args.results_dir, args.val_metric, args.output_metrics, use_all=True, + val_results, _, _, _ = summarize_results( + args.results_dir, args.val_metric, args.output_metrics, max_num=args.max_num) + if args.one_experiment_json: + def codalab_reformat(s): + return s.replace('/', '_') + new_columns = [codalab_reformat(s) for s in val_results.columns] + val_results.columns = new_columns + json_output = val_results.iloc[0].to_json() + json_file = open(args.results_dir + '/results.json', "w") + json_file.write(json_output) + sys.exit(0) + metrics.append(args.val_metric) results_list.append(val_results) # Get other results. + if args.secondary_val_metrics is None: + args.secondary_val_metrics = [] for secondary_val_metric in args.secondary_val_metrics: secondary_results, _, _ = summarize_results( args.results_dir, secondary_val_metric, args.output_metrics, use_all=True, max_num=args.max_num) diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index eceb4e0..f2a9501 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -60,7 +60,14 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): # Get run-name and wandb from config file. parent_dir = Path(file_path).parent.absolute() config_path = parent_dir / 'config.json' - if os.path.isfile(config_path): + print(parent_dir, config_path) + print(Path(file_path).parent.name) + if Path(file_path).parent.name == 'logs': + # Codalab. + grandparent_dir = Path(file_path).parent.parent + run_name = [('name', grandparent_dir.name)] + best_res = run_name + best_res + elif os.path.isfile(config_path): with open(config_path, 'r') as f: config = json.load(f) run_name = [('name', config['run_name'])] @@ -70,7 +77,8 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): run_name = [('name', file_path[file_path.rfind('/')+1:-4])] best_res = run_name + best_res # len(df) is the number of epochs - assert len(df) == df['epoch'].max() + 1 + if 'epoch' in df: + assert len(df) == df['epoch'].max() + 1 return best_res, best_value, len(df) def summarize_results(results_dir, val_metric, output_metrics, max_num=None): diff --git a/unlabeled_extrapolation/extract_features.py b/unlabeled_extrapolation/extract_features.py index 2529b7e..e32a10f 100644 --- a/unlabeled_extrapolation/extract_features.py +++ b/unlabeled_extrapolation/extract_features.py @@ -132,6 +132,7 @@ def main(): parser.add_argument('--use_new_bn_stats', type=str, help='Update batchnorm stats before producing features.', required=False, default='False') + parser.add_argument('--no_wandb', action='store_true', help='disable W&B') args, unparsed = parser.parse_known_args() config = quinine.Quinfig(args.config) utils.update_config(unparsed, config) From 40d6bfc2eb9e14980f785a284262e240a4b40780 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Sun, 25 Dec 2022 18:50:57 -0800 Subject: [PATCH 184/197] Codalab --- configs/adaptation/datasets_cifar_stl.yaml | 5 - .../adaptation/datasets_cifar_stl_nonorm.yaml | 4 - configs/adaptation/datasets_fmow.yaml | 10 +- configs/adaptation/datasets_fmow_all.yaml | 12 +- .../adaptation/datasets_fmow_all_nonorm.yaml | 12 +- .../datasets_fmow_all_nonorm_weakaugs.yaml | 14 +-- scripts/codalab.sh | 27 +++++ scripts/run_adaptation_experiments.py | 103 +++++++++++++----- scripts/summarize_all_results.py | 18 ++- scripts/summarize_linprobe_results.py | 18 ++- scripts/summarize_results.py | 12 +- unlabeled_extrapolation/extract_features.py | 1 + 12 files changed, 170 insertions(+), 66 deletions(-) create mode 100644 scripts/codalab.sh diff --git a/configs/adaptation/datasets_cifar_stl.yaml b/configs/adaptation/datasets_cifar_stl.yaml index 7c14df6..d991787 100644 --- a/configs/adaptation/datasets_cifar_stl.yaml +++ b/configs/adaptation/datasets_cifar_stl.yaml @@ -40,13 +40,8 @@ test_datasets: args: root: 'stl10_dataset/' split: 'test' - - name: 'imnet-n-cifar' - classname: datasets.imnet_intersect_c10.ImNetnC10 - args: - root: 'balanced_imnet_intersect_c10_val/' early_stop_dataset_names: - 'cifar10-test' - 'stl-test' - - 'imnet-n-cifar' diff --git a/configs/adaptation/datasets_cifar_stl_nonorm.yaml b/configs/adaptation/datasets_cifar_stl_nonorm.yaml index 04dc3d2..1f76039 100644 --- a/configs/adaptation/datasets_cifar_stl_nonorm.yaml +++ b/configs/adaptation/datasets_cifar_stl_nonorm.yaml @@ -32,10 +32,6 @@ test_datasets: args: root: 'stl10_dataset/' split: 'test' - - name: 'imnet-n-cifar' - classname: datasets.imnet_intersect_c10.ImNetnC10 - args: - root: 'balanced_imnet_intersect_c10_val/' early_stop_dataset_names: {} diff --git a/configs/adaptation/datasets_fmow.yaml b/configs/adaptation/datasets_fmow.yaml index 7679ea3..11f151f 100644 --- a/configs/adaptation/datasets_fmow.yaml +++ b/configs/adaptation/datasets_fmow.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: [3] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize @@ -32,19 +32,19 @@ test_datasets: args: split: 'val' regions: [1] - root: 'wilds/data' + root: '' - name: 'africa_val' classname: datasets.fmow.Fmow args: split: 'val' regions: [2] - root: 'wilds/data' + root: '' - name: 'americas_val' classname: datasets.fmow.Fmow args: split: 'val' regions: [3] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'americas_val' diff --git a/configs/adaptation/datasets_fmow_all.yaml b/configs/adaptation/datasets_fmow_all.yaml index c0e6ef9..229a6d3 100644 --- a/configs/adaptation/datasets_fmow_all.yaml +++ b/configs/adaptation/datasets_fmow_all.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.ToTensor - classname: torchvision.transforms.Normalize @@ -32,26 +32,26 @@ test_datasets: args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'ood_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm.yaml b/configs/adaptation/datasets_fmow_all_nonorm.yaml index c3627fd..cd9b97e 100644 --- a/configs/adaptation/datasets_fmow_all_nonorm.yaml +++ b/configs/adaptation/datasets_fmow_all_nonorm.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.RandomResizedCrop args: @@ -28,26 +28,26 @@ test_datasets: args: split: 'id_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml index 92510df..f85bb33 100644 --- a/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml +++ b/configs/adaptation/datasets_fmow_all_nonorm_weakaugs.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' # Add augmentations, and change normalization a bit. # The difference is swav augmentation has a 0.228 instead of 0.229 (lol) @@ -10,7 +10,7 @@ train_dataset: args: split: 'train' regions: ['all'] - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.RandomHorizontalFlip - classname: torchvision.transforms.ToTensor @@ -25,31 +25,31 @@ test_datasets: args: split: 'id_val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'id_test' classname: datasets.fmow.Fmow args: split: 'id_test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.fmow.Fmow args: split: 'val' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.fmow.Fmow args: split: 'test' regions: ['all'] - root: 'wilds/data' + root: '' - name: 'africa_test' classname: datasets.fmow.Fmow args: split: 'test' regions: [2] - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/scripts/codalab.sh b/scripts/codalab.sh new file mode 100644 index 0000000..dd93207 --- /dev/null +++ b/scripts/codalab.sh @@ -0,0 +1,27 @@ + +cl upload cifar10_dataset +cl upload stl10_dataset +cl upload domainnet +cl upload simclr_weights +cl upload configs +cl upload unlabeled_extrapolation +cl upload scripts + +# CIFAR-STL experiments. +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets cifar_stl --experiment=lp_then_ft_valmode_experiments --codalab --no_replications + +# DomainNet experiments. +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=lp_then_ft_valmode_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=ft_val_mode_experiment --codalab --no_replications + +# FMoW experiments. + +# Living-17, Entity-30, CIFAR-STL. + +# ImageNet. + + diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6c05891..6fcda40 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -45,12 +45,13 @@ def run_codalab(cmd, job_name, args, gpus=1, mem='16G', cpus=1, nlp=True, deps=' nlp_opt = '' cl_deps_str = ':' + ' :'.join(deps) bundles = ':unlabeled_extrapolation :scripts :configs ' + cl_deps_str + ' ' - makedirs = '"export PYTHONPATH=\'.\'; export PYTHONPATH=\'' + args.code_dir + '\'; ' + makedirs = '"export PYTHONPATH=\'.\'; ' + # export PYTHONPATH=\'' + args.code_dir + '\'; ' codalab_cmd = prefix + nlp_opt + bundles + makedirs + cmd + '"' print(codalab_cmd + '\n') if not(args.print_command): subprocess.run(shlex.split(codalab_cmd)) - return job_name + return job_name def run_job(cmd, job_name, args, deps=[]): @@ -461,17 +462,28 @@ def run_linprobe_replication(adapt_name, dataset, model, seed, args, deps=[], re overwrite_options=overwrite_options) -def linprobe_experiment(adapt_name, dataset, model, num_replications, args, deps=[], rerun=False, +def linprobe_experiment(adapt_name, dataset, model_name, num_replications, args, deps=[], rerun=False, aug=True, train_mode=False, use_new_bn_stats=False): + model = names_to_model[model_name] replication_ids = [] for i in range(num_replications): job_id = run_linprobe_replication(adapt_name, dataset, model, seed=i, args=args, deps=deps, rerun=rerun, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) replication_ids.append(job_id) - summarize_id = summarize_linprobe(adapt_name, dataset, model, args, deps=replication_ids, max_num=num_replications) - all_ids = replication_ids + [summarize_id] - return [summarize_id], all_ids + if not args.codalab: + summarize_id = summarize_linprobe(adapt_name, dataset, model, args, deps=replication_ids, max_num=num_replications) + all_ids = replication_ids + [summarize_id] + return [summarize_id], all_ids + else: + # If Codalab, add sweep experiment, with deps. + codalab_summarize_cmd = get_codalab_summarize_linprobe_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, model_name) + '_summarize' + summarize_id = run_job( + cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=replication_ids) + all_ids = replication_ids + [summarize_id] + return [summarize_id], all_ids + ############################################ @@ -826,12 +838,12 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): cifar_stl = Dataset( name='cifar_stl', val_metric='test_acc/cifar10-test', - secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], + secondary_val_metrics=['test_acc/stl-test', 'LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], config_rel_path='adaptation/cifar_stl.yaml', bundles=['cifar10_dataset', 'stl10_dataset'], slurm_data_cmd=None, @@ -843,10 +855,10 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): val_metric='test_acc/cifar10-test', secondary_val_metrics=['test_acc/stl-test', 'test_acc/imnet-n-cifar', 'LAST'], output_metrics=['epoch', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], linprobe_secondary_val_metrics=None, linprobe_output_metrics=['C', 'train/acc', 'test_acc/cifar10-test', - 'test_acc/stl-test', 'test_acc/imnet-n-cifar'], + 'test_acc/stl-test'], config_rel_path='adaptation/cifar_stl_nonorm.yaml', bundles=['cifar_stl'], slurm_data_cmd=None, @@ -881,7 +893,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -896,7 +908,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -911,7 +923,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') fmow_all_nonorm_weakaugs = Dataset( @@ -926,7 +938,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') fmow_all_nonorm_weakaugs_highres = Dataset( @@ -941,7 +953,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') camelyon17_weakaugs = Dataset( @@ -1361,7 +1373,7 @@ def append_to_each(hyperparams_list, more_hyperparams): ## Main experiments. ############################################ -SWEEP_LRS = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] def get_datasets(args): print(args.datasets) @@ -1445,7 +1457,7 @@ def fine_tuning_celeba_experiments(args, linear_probe=True): -def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, +def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchnorm_ft=False, higher_linear_lr=False, val_mode=False, no_augmentation=False, l2sp=False, side_tune=False, imagenet_lp_ft_phase2=False, mixup_sweep=False, options_dict={}): adapt_name = 'full_ft' @@ -1471,8 +1483,8 @@ def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batch sweep_lrs = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] elif val_mode: adapt_name += '_valmode' - if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): - sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] + # if ('waterbirds' not in args.datasets[0] and 'imagenet' not in args.datasets[0]): + # sweep_lrs = [3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3] if no_augmentation: adapt_name += '_no_augmentation' if linear_probe: @@ -1620,6 +1632,11 @@ def fine_tuning_experiments(args, num_replications=10, linear_probe=False, batch ignore_name_hypers=ignore_name_hypers) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) + # If Codalab, add sweep experiment, with deps. + if args.codalab: + codalab_summarize_cmd = get_codalab_summarize_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_summarize' + run_job(cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=all_ids) def fine_tuning_mixup_sweep_experiments(args, num_replications=3): @@ -1685,13 +1702,13 @@ def linprobe_experiments(args, num_replications=3, aug=True, train_mode=False, u raise ValueError('If use_new_bn_stats is True, train_mode must be False.') adapt_name += '_usenewbnstats' datasets = get_datasets(args) - model = names_to_model[args.model_name] if args.no_replications or args.only_one_run: num_replications = 1 for dataset in datasets: all_ids = linprobe_experiment( - adapt_name=adapt_name, dataset=dataset, model=model, num_replications=num_replications, - args=args, aug=aug, train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) + adapt_name=adapt_name, dataset=dataset, model_name=args.model_name, + num_replications=num_replications, args=args, aug=aug, + train_mode=train_mode, use_new_bn_stats=use_new_bn_stats) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) @@ -1716,7 +1733,7 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= sweep_lrs = SWEEP_LRS if val_mode: adapt_name += '_valmode' - sweep_lrs = [1e-4, 3e-5, 1e-5, 3e-6, 1e-6, 3e-7] + # sweep_lrs = [1e-4, 3e-5, 1e-5, 3e-6, 1e-6, 3e-7] linprobe_adapt_name = 'linprobe' datasets = get_datasets(args) model = names_to_model[args.model_name] @@ -1797,19 +1814,31 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= # cur_hyperparams_list, # {'linear_probe_checkpoint_path': linprobe_group_path + '/weights_0.pkl'}) replication_hyperparams_list = [] + deps = [] for i in range(num_replications): - replication_hyperparams_list.append({ - 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) + if args.codalab: + linprobe_job_name = get_group_name(linprobe_adapt_name, dataset.name, args.model_name) + '_' + str(i) + weights_path = linprobe_job_name + '/logs/weights_' + str(i) + '.pkl' + replication_hyperparams_list.append({ + 'linear_probe_checkpoint_path': weights_path}) + deps.append(linprobe_job_name) + else: + replication_hyperparams_list.append({ + 'linear_probe_checkpoint_path': linprobe_group_path + '/weights_' + str(i) + '.pkl'}) ignore_name_hypers=set(options_dict.keys()).union({'batch-layer-wise-tune', 'full_ft_epoch', 'linear_probe_checkpoint_path', 'optimizer.classname'}) all_ids = replicated_sweep( adapt_name=adapt_name, dataset=dataset, model=model, hyperparams_list=cur_hyperparams_list, num_replications=num_replications, replication_hyperparams_list=replication_hyperparams_list, args=args, - ignore_name_hypers=ignore_name_hypers) + ignore_name_hypers=ignore_name_hypers, deps=deps) if all_ids is not None: print('Job IDs: ' + ' '.join([str(id) for id in all_ids])) - + # If Codalab, add sweep experiment, with deps. + if args.codalab: + codalab_summarize_cmd = get_codalab_summarize_python_cmd(dataset) + summarize_job_name = get_group_name(adapt_name, dataset.name, args.model_name) + '_summarize' + run_job(cmd=codalab_summarize_cmd, job_name=summarize_job_name, args=args, deps=all_ids) def lp_then_ft_valmode_experiments(args, num_replications=3, options_dict={}): lp_then_ft_experiments(args, num_replications=num_replications, val_mode=True, options_dict=options_dict) @@ -1893,6 +1922,23 @@ def summarize_dataset(args): os.system(cmd) +def get_codalab_summarize_python_cmd(dataset): + cmd = 'python scripts/summarize_all_results.py ' + cmd += '--results_dir_glob=. ' + cmd += '--val_metrics ' + dataset.val_metric + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.output_metrics) + ' ' + cmd += '--one_experiment_json' + return cmd + +def get_codalab_summarize_linprobe_python_cmd(dataset): + cmd = 'python scripts/summarize_linprobe_results.py ' + cmd += '--results_dir=. ' + cmd += '--val_metric ' + dataset.val_metric + ' ' + cmd += '--output_metrics ' + ' '.join(dataset.linprobe_output_metrics) + ' ' + cmd += '--one_experiment_json' + return cmd + + def main(args, options_dict={}): experiment_to_fns = { 'spray_celeba_jags': spray_celeba_jags, @@ -1947,6 +1993,7 @@ def fill_platform_specific_default_args(args): args.log_dir = args.log_dir if args.log_dir else 'logs/' args.pretrained_checkpoints_dir = (args.pretrained_checkpoints_dir if args.pretrained_checkpoints_dir else + '/u/scr/ananya/simclr_weights/') diff --git a/scripts/summarize_all_results.py b/scripts/summarize_all_results.py index a3b0a5a..e08699d 100644 --- a/scripts/summarize_all_results.py +++ b/scripts/summarize_all_results.py @@ -9,6 +9,7 @@ import os import shlex import shutil +import sys import uuid import re import glob @@ -38,7 +39,7 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre grouped = res.groupby('group') means = grouped.mean() counts = grouped.count() - counts.drop(labels=['name', 'wandb_url'], axis=1) + counts.drop(labels=['name'], axis=1) stderrs = 1.645 * (grouped.std() / np.sqrt(counts)) stderrs = stderrs[means.columns] min_count = grouped.count().iloc[:,0].min() @@ -57,6 +58,15 @@ def get_experiment_aggregate_summary(dir_path, val_metric, output_metrics, aggre for best_row in [best_row_mean, best_row_std]: best_row['group'] = best_row.index best_row.set_index('name') + # Output results.json for the current sweep. + # This is especially useful for displaying results in CodaLab worksheets. + def codalab_reformat(s): + return s.replace('/', '_') + new_columns = [codalab_reformat(s) for s in best_row_mean.columns] + best_row_mean.columns = new_columns + json_output = best_row_mean.iloc[0].to_json() + json_file = open(dir_path + '/results.json', "w") + json_file.write(json_output) return res, best_row_mean, best_row_std, num_epochs_list @@ -87,7 +97,13 @@ def get_all_results(val_metric, dir_paths, output_metrics): parser.add_argument('--output_file', type=str, help='Path to output results, should end with .tsv') parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + # The following option is particularly useful for Codalab, where we just want to summarize all runs + # in a single experiment and store the json file. + parser.add_argument('--one_experiment_json', action='store_true', help="Summarize single experiment in json") args = parser.parse_args() + if args.one_experiment_json: + get_experiment_aggregate_summary(args.results_dir_glob, args.val_metrics[0], args.output_metrics) + sys.exit(0) # Get all folders satisfying glob. dir_paths = glob.glob(args.results_dir_glob, recursive=False) dir_paths = [dir_path for dir_path in dir_paths if 'linprobe' not in dir_path or 'torch_linprobe' in dir_path] diff --git a/scripts/summarize_linprobe_results.py b/scripts/summarize_linprobe_results.py index b5db401..b127bef 100644 --- a/scripts/summarize_linprobe_results.py +++ b/scripts/summarize_linprobe_results.py @@ -8,6 +8,7 @@ import os import shlex import shutil +import sys import uuid import re import glob @@ -31,15 +32,28 @@ parser.add_argument('--max_num', type=int, help='Max number of lin probe runs to use.') parser.add_argument('-s', action='store_true', help="Short version: Do not show column names") + parser.add_argument('--one_experiment_json', action='store_true', help="Summarize single experiment in json") args = parser.parse_args() metrics, results_list = [], [] # Get results for val_metric. - val_results, _, _ = summarize_results( - args.results_dir, args.val_metric, args.output_metrics, use_all=True, + val_results, _, _, _ = summarize_results( + args.results_dir, args.val_metric, args.output_metrics, max_num=args.max_num) + if args.one_experiment_json: + def codalab_reformat(s): + return s.replace('/', '_') + new_columns = [codalab_reformat(s) for s in val_results.columns] + val_results.columns = new_columns + json_output = val_results.iloc[0].to_json() + json_file = open(args.results_dir + '/results.json', "w") + json_file.write(json_output) + sys.exit(0) + metrics.append(args.val_metric) results_list.append(val_results) # Get other results. + if args.secondary_val_metrics is None: + args.secondary_val_metrics = [] for secondary_val_metric in args.secondary_val_metrics: secondary_results, _, _ = summarize_results( args.results_dir, secondary_val_metric, args.output_metrics, use_all=True, max_num=args.max_num) diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index eceb4e0..f2a9501 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -60,7 +60,14 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): # Get run-name and wandb from config file. parent_dir = Path(file_path).parent.absolute() config_path = parent_dir / 'config.json' - if os.path.isfile(config_path): + print(parent_dir, config_path) + print(Path(file_path).parent.name) + if Path(file_path).parent.name == 'logs': + # Codalab. + grandparent_dir = Path(file_path).parent.parent + run_name = [('name', grandparent_dir.name)] + best_res = run_name + best_res + elif os.path.isfile(config_path): with open(config_path, 'r') as f: config = json.load(f) run_name = [('name', config['run_name'])] @@ -70,7 +77,8 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): run_name = [('name', file_path[file_path.rfind('/')+1:-4])] best_res = run_name + best_res # len(df) is the number of epochs - assert len(df) == df['epoch'].max() + 1 + if 'epoch' in df: + assert len(df) == df['epoch'].max() + 1 return best_res, best_value, len(df) def summarize_results(results_dir, val_metric, output_metrics, max_num=None): diff --git a/unlabeled_extrapolation/extract_features.py b/unlabeled_extrapolation/extract_features.py index 2529b7e..e32a10f 100644 --- a/unlabeled_extrapolation/extract_features.py +++ b/unlabeled_extrapolation/extract_features.py @@ -132,6 +132,7 @@ def main(): parser.add_argument('--use_new_bn_stats', type=str, help='Update batchnorm stats before producing features.', required=False, default='False') + parser.add_argument('--no_wandb', action='store_true', help='disable W&B') args, unparsed = parser.parse_known_args() config = quinine.Quinfig(args.config) utils.update_config(unparsed, config) From 30dd39d4fa6cb8c18dd9da994e3740ebc1c00599 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 27 Dec 2022 14:22:40 -0800 Subject: [PATCH 185/197] More codalab updates. --- configs/adaptation/datasets_imagenet.yaml | 15 +++++----- .../adaptation/datasets_imagenet_augs.yaml | 15 +++++----- scripts/codalab.sh | 10 +++++++ scripts/run_adaptation_experiments.py | 28 ++++++++++--------- scripts/run_rtx_sbatch.sh | 2 ++ scripts/run_sbatch.sh | 1 + scripts/run_sphinx_big_sbatch.sh | 1 + scripts/run_sphinx_sbatch.sh | 1 + unlabeled_extrapolation/baseline_train.py | 22 +++++++++++---- unlabeled_extrapolation/log_reg_sk.py | 21 +++++++++++++- 10 files changed, 83 insertions(+), 33 deletions(-) diff --git a/configs/adaptation/datasets_imagenet.yaml b/configs/adaptation/datasets_imagenet.yaml index 3b6c8b9..6325caf 100644 --- a/configs/adaptation/datasets_imagenet.yaml +++ b/configs/adaptation/datasets_imagenet.yaml @@ -1,12 +1,13 @@ -root_prefix: '' +root_prefix: '/scr/biggest/' +test_root_prefix: '/u/scr/nlp/' # The train and test transforms are taken from the Swav fine-tuning script. train_dataset: name: 'train' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'train' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize @@ -32,27 +33,27 @@ test_datasets: - name: 'val' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'val' - name: 'renditions' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-r' - name: 'imagenet-a' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-a' - name: 'v2' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenetv2-matched-frequency-format-val' - name: 'sketch' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'sketch' diff --git a/configs/adaptation/datasets_imagenet_augs.yaml b/configs/adaptation/datasets_imagenet_augs.yaml index 1592f74..aa9cb1d 100644 --- a/configs/adaptation/datasets_imagenet_augs.yaml +++ b/configs/adaptation/datasets_imagenet_augs.yaml @@ -1,12 +1,13 @@ -root_prefix: '' +root_prefix: '/scr/biggest/' +test_root_prefix: '/u/scr/nlp/' # The train and test transforms are taken from the Swav fine-tuning script. train_dataset: name: 'train' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'train' transforms: - classname: torchvision.transforms.RandomResizedCrop @@ -29,27 +30,27 @@ test_datasets: - name: 'val' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'val' - name: 'renditions' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-r' - name: 'imagenet-a' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-a' - name: 'v2' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenetv2-matched-frequency-format-val' - name: 'sketch' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'sketch' early_stop_dataset_names: diff --git a/scripts/codalab.sh b/scripts/codalab.sh index dd93207..28e1dfd 100644 --- a/scripts/codalab.sh +++ b/scripts/codalab.sh @@ -19,8 +19,18 @@ python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=c python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=ft_val_mode_experiment --codalab --no_replications # FMoW experiments. +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=lp_then_ft_valmode_experiments --codalab --no_replications # Living-17, Entity-30, CIFAR-STL. +declare -a datasets=(living17 entity30) +for dataset in "${datasets[@]}"; do + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=linprobe_experiments --codalab --only_one_run + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=fine_tuning_experiments --codalab --no_replications + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=lp_then_ft_valmode_experiments --codalab --no_replications + +done # ImageNet. diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6fcda40..734976c 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -104,6 +104,8 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, if not(run_saved): if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir + if 'imagenet' in args.datasets[0]: + kwargs['test_root_prefix'] = args.codalab_data_dir elif args.amulet_option is not None: kwargs['root_prefix'] = '.' else: @@ -814,7 +816,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet.yaml', bundles=['imagenet'], - slurm_data_dir='', + slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -830,7 +832,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet_augs.yaml', bundles=['imagenet'], - slurm_data_dir='', + slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -891,9 +893,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/americas_val', 'test_acc/africa_val', 'test_acc/europe_val'], config_rel_path='adaptation/fmow.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -906,9 +908,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -921,9 +923,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') fmow_all_nonorm_weakaugs = Dataset( @@ -936,9 +938,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') fmow_all_nonorm_weakaugs_highres = Dataset( @@ -951,9 +953,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') camelyon17_weakaugs = Dataset( @@ -1534,7 +1536,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' - hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + hyperparams_list = range_hyper('optimizer.args.lr', [0.01]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index fa7afe5..5a707ce 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -8,11 +8,13 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh conda deactivate +# source ~/.bashrc conda activate $conda_env cd $PWD diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 6b1b046..5b2ed92 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -10,6 +10,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh index 03bad48..b844a5d 100644 --- a/scripts/run_sphinx_big_sbatch.sh +++ b/scripts/run_sphinx_big_sbatch.sh @@ -9,6 +9,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 7e1f92a..2d68ddf 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -9,6 +9,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 34f9d1a..20a1186 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -783,19 +783,31 @@ def update_test_transform_args_configs(config): def update_root_prefix(config): # Go through test datasets, and train dataset. If root_prefix specified, then prepend that # to the root. - def apply_root_prefix(dataset_config, root_prefix): + def apply_root_prefix(dataset_config, root_prefix, test_root_prefix): for key in ['root', 'cache_path', 'pickle_file_path']: if key in dataset_config['args']: orig_path = dataset_config['args'][key] logging.info('orig_path %s', orig_path) - dataset_config['args'][key] = root_prefix + '/' + orig_path + if orig_path.find('{root_prefix}') != -1: + new_path = orig_path.replace('{root_prefix}', root_prefix) + elif orig_path.find('{test_root_prefix}') != -1: + new_path = orig_path.replace('{test_root_prefix}', test_root_prefix) + else: + new_path = root_prefix + '/' + orig_path + dataset_config['args'][key] = new_path if 'root_prefix' in config: root_prefix = config['root_prefix'] - logging.info("Adding root prefix %s to all roots.", root_prefix) - apply_root_prefix(config['train_dataset'], root_prefix) + # There needs to be a root prefix to use test root prefix. + if 'test_root_prefix' in config: + test_root_prefix = config['test_root_prefix'] + else: + test_root_prefix = root_prefix + logging.info("Adding root prefix %s, test root prefix %s to all roots.", + root_prefix, test_root_prefix) + apply_root_prefix(config['train_dataset'], root_prefix, test_root_prefix) for test_dataset_config in config['test_datasets']: - apply_root_prefix(test_dataset_config, root_prefix) + apply_root_prefix(test_dataset_config, root_prefix, test_root_prefix) def update_net_eval_mode(config): diff --git a/unlabeled_extrapolation/log_reg_sk.py b/unlabeled_extrapolation/log_reg_sk.py index 158bc84..65ffa32 100644 --- a/unlabeled_extrapolation/log_reg_sk.py +++ b/unlabeled_extrapolation/log_reg_sk.py @@ -47,6 +47,21 @@ def inv_normalize_weights(weights, intercept, features, normalize_index): return new_weights, new_intercept +def pad_head(coef, intercept, classes_present): + # Create a map from class to index in coef + # Create coef and intercept of the current shape + # Loop over real number of classes. if index doesn't exist in classes, then initialize to 0. Otherwise use coef intercept. + num_classes = np.max(classes_present) + 1 + assert num_classes >= len(classes_present) + assert len(classes_present) == coef.shape[0] == intercept.shape[0] + new_coefs = np.zeros((num_classes, coef.shape[1])) + new_intercept = np.zeros((num_classes,)) + for coef_index, present_class in enumerate(list(classes_present)): + new_coefs[present_class, :] = coef[coef_index, :] + new_intercept[present_class] = intercept[coef_index] + return new_coefs, new_intercept + + def test_log_reg_warm_starting(features, labels, train_index, test_indices, val_index, loader_names, num_cs=100, start_c=-7, end_c=2, max_iter=200, random_state=0): L = len(features) @@ -103,6 +118,7 @@ def main(): help='Metric to select regularization on.', required=True) parser.add_argument('--seed', type=int, help='Random seed.', required=False, default=0) + parser.add_argument('--no_padding', action='store_true', help='dont pad missing labels') args, unparsed = parser.parse_known_args() print('Running on machine ', socket.gethostname()) @@ -111,7 +127,7 @@ def main(): if args.train_index is None: args.train_index = 0 if args.test_indices is None: - args.test_indices = list(range(0, len(loader_names))) + args.test_indices = list(range(0, len(loader_names))) print("Training on: ", loader_names[args.train_index]) print("Testing on: ") for idx in args.test_indices: @@ -142,6 +158,9 @@ def make_parent_dir(save_path): accs_df.to_csv(args.results_save_path, sep='\t') new_coef, new_intercept = inv_normalize_weights(coef, intercept, features, normalize_index=args.train_index) + # Pad the head if desired, if some classes are missing from the training set, e.g., in FMoW. + if not(args.no_padding): + new_coef, new_intercept = pad_head(new_coef, new_intercept, clf.classes_) pickle.dump((new_coef, new_intercept, best_c, best_i), open(args.weights_save_path, 'wb')) # Just a redundancy check that the best classifier weights, and best weights, are the same. assert(np.allclose(clf.coef_, coef)) From 80bc68bcbf7ded118dd45345a448d53ffedcb005 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 27 Dec 2022 14:22:40 -0800 Subject: [PATCH 186/197] More codalab updates. --- configs/adaptation/datasets_imagenet.yaml | 15 +++++----- .../adaptation/datasets_imagenet_augs.yaml | 15 +++++----- scripts/codalab.sh | 10 +++++++ scripts/run_adaptation_experiments.py | 28 ++++++++++--------- scripts/run_rtx_sbatch.sh | 2 ++ scripts/run_sbatch.sh | 1 + scripts/run_sphinx_big_sbatch.sh | 1 + scripts/run_sphinx_sbatch.sh | 1 + unlabeled_extrapolation/baseline_train.py | 22 +++++++++++---- unlabeled_extrapolation/log_reg_sk.py | 21 +++++++++++++- 10 files changed, 83 insertions(+), 33 deletions(-) diff --git a/configs/adaptation/datasets_imagenet.yaml b/configs/adaptation/datasets_imagenet.yaml index 3b6c8b9..6325caf 100644 --- a/configs/adaptation/datasets_imagenet.yaml +++ b/configs/adaptation/datasets_imagenet.yaml @@ -1,12 +1,13 @@ -root_prefix: '' +root_prefix: '/scr/biggest/' +test_root_prefix: '/u/scr/nlp/' # The train and test transforms are taken from the Swav fine-tuning script. train_dataset: name: 'train' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'train' transforms: - classname: unlabeled_extrapolation.datasets.transforms.Resize @@ -32,27 +33,27 @@ test_datasets: - name: 'val' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'val' - name: 'renditions' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-r' - name: 'imagenet-a' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-a' - name: 'v2' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenetv2-matched-frequency-format-val' - name: 'sketch' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'sketch' diff --git a/configs/adaptation/datasets_imagenet_augs.yaml b/configs/adaptation/datasets_imagenet_augs.yaml index 1592f74..aa9cb1d 100644 --- a/configs/adaptation/datasets_imagenet_augs.yaml +++ b/configs/adaptation/datasets_imagenet_augs.yaml @@ -1,12 +1,13 @@ -root_prefix: '' +root_prefix: '/scr/biggest/' +test_root_prefix: '/u/scr/nlp/' # The train and test transforms are taken from the Swav fine-tuning script. train_dataset: name: 'train' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'train' transforms: - classname: torchvision.transforms.RandomResizedCrop @@ -29,27 +30,27 @@ test_datasets: - name: 'val' classname: datasets.imagenet.ImageNet args: - root: '/scr/biggest/imagenet/' + root: '{root_prefix}/imagenet/' split: 'val' - name: 'renditions' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-r' - name: 'imagenet-a' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenet-a' - name: 'v2' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'imagenetv2-matched-frequency-format-val' - name: 'sketch' classname: datasets.imagenet.ImageNet args: - root: '/u/scr/nlp/imagenet/' + root: '{test_root_prefix}/imagenet/' split: 'sketch' early_stop_dataset_names: diff --git a/scripts/codalab.sh b/scripts/codalab.sh index dd93207..28e1dfd 100644 --- a/scripts/codalab.sh +++ b/scripts/codalab.sh @@ -19,8 +19,18 @@ python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=c python scripts/run_adaptation_experiments.py --datasets domainnet --model_name=clip_resnet50 --experiment=ft_val_mode_experiment --codalab --no_replications # FMoW experiments. +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=linprobe_experiments --codalab --only_one_run +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=fine_tuning_experiments --codalab --no_replications +python scripts/run_adaptation_experiments.py --datasets fmow --model_name=mocotp_fmow_resnet50 --experiment=lp_then_ft_valmode_experiments --codalab --no_replications # Living-17, Entity-30, CIFAR-STL. +declare -a datasets=(living17 entity30) +for dataset in "${datasets[@]}"; do + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=linprobe_experiments --codalab --only_one_run + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=fine_tuning_experiments --codalab --no_replications + python scripts/run_adaptation_experiments.py --datasets $dataset --experiment=lp_then_ft_valmode_experiments --codalab --no_replications + +done # ImageNet. diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 6fcda40..734976c 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -104,6 +104,8 @@ def get_baseline_experiment_cmd(config_path, run_name, group_name, project_name, if not(run_saved): if args.codalab: kwargs['root_prefix'] = args.codalab_data_dir + if 'imagenet' in args.datasets[0]: + kwargs['test_root_prefix'] = args.codalab_data_dir elif args.amulet_option is not None: kwargs['root_prefix'] = '.' else: @@ -814,7 +816,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet.yaml', bundles=['imagenet'], - slurm_data_dir='', + slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -830,7 +832,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet_augs.yaml', bundles=['imagenet'], - slurm_data_dir='', + slurm_data_dir='/scr/biggest/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -891,9 +893,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/americas_val', 'test_acc/africa_val', 'test_acc/europe_val'], config_rel_path='adaptation/fmow.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -906,9 +908,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -921,9 +923,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_eval.yaml') fmow_all_nonorm_weakaugs = Dataset( @@ -936,9 +938,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm_weakaugs.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_eval.yaml') fmow_all_nonorm_weakaugs_highres = Dataset( @@ -951,9 +953,9 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): linprobe_output_metrics=['C', 'train/acc', 'test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres.yaml', - bundles=['fmow'], + bundles=['fmow_v1.1'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/wilds/data/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/fmow_all_nonorm_weakaugs_highres_eval.yaml') camelyon17_weakaugs = Dataset( @@ -1534,7 +1536,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' - hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + hyperparams_list = range_hyper('optimizer.args.lr', [0.01]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index fa7afe5..5a707ce 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -8,11 +8,13 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh source /u/nlp/anaconda/main/anaconda3/etc/profile.d/conda.sh conda deactivate +# source ~/.bashrc conda activate $conda_env cd $PWD diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 6b1b046..5b2ed92 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -10,6 +10,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh index 03bad48..b844a5d 100644 --- a/scripts/run_sphinx_big_sbatch.sh +++ b/scripts/run_sphinx_big_sbatch.sh @@ -9,6 +9,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 7e1f92a..2d68ddf 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -9,6 +9,7 @@ # Print execute commands in the log. set -x +# conda_env=unlabeled_extrapolation conda_env=`whoami`-ue-new # source scripts/copy_imagenet_local.sh diff --git a/unlabeled_extrapolation/baseline_train.py b/unlabeled_extrapolation/baseline_train.py index 34f9d1a..20a1186 100644 --- a/unlabeled_extrapolation/baseline_train.py +++ b/unlabeled_extrapolation/baseline_train.py @@ -783,19 +783,31 @@ def update_test_transform_args_configs(config): def update_root_prefix(config): # Go through test datasets, and train dataset. If root_prefix specified, then prepend that # to the root. - def apply_root_prefix(dataset_config, root_prefix): + def apply_root_prefix(dataset_config, root_prefix, test_root_prefix): for key in ['root', 'cache_path', 'pickle_file_path']: if key in dataset_config['args']: orig_path = dataset_config['args'][key] logging.info('orig_path %s', orig_path) - dataset_config['args'][key] = root_prefix + '/' + orig_path + if orig_path.find('{root_prefix}') != -1: + new_path = orig_path.replace('{root_prefix}', root_prefix) + elif orig_path.find('{test_root_prefix}') != -1: + new_path = orig_path.replace('{test_root_prefix}', test_root_prefix) + else: + new_path = root_prefix + '/' + orig_path + dataset_config['args'][key] = new_path if 'root_prefix' in config: root_prefix = config['root_prefix'] - logging.info("Adding root prefix %s to all roots.", root_prefix) - apply_root_prefix(config['train_dataset'], root_prefix) + # There needs to be a root prefix to use test root prefix. + if 'test_root_prefix' in config: + test_root_prefix = config['test_root_prefix'] + else: + test_root_prefix = root_prefix + logging.info("Adding root prefix %s, test root prefix %s to all roots.", + root_prefix, test_root_prefix) + apply_root_prefix(config['train_dataset'], root_prefix, test_root_prefix) for test_dataset_config in config['test_datasets']: - apply_root_prefix(test_dataset_config, root_prefix) + apply_root_prefix(test_dataset_config, root_prefix, test_root_prefix) def update_net_eval_mode(config): diff --git a/unlabeled_extrapolation/log_reg_sk.py b/unlabeled_extrapolation/log_reg_sk.py index 158bc84..65ffa32 100644 --- a/unlabeled_extrapolation/log_reg_sk.py +++ b/unlabeled_extrapolation/log_reg_sk.py @@ -47,6 +47,21 @@ def inv_normalize_weights(weights, intercept, features, normalize_index): return new_weights, new_intercept +def pad_head(coef, intercept, classes_present): + # Create a map from class to index in coef + # Create coef and intercept of the current shape + # Loop over real number of classes. if index doesn't exist in classes, then initialize to 0. Otherwise use coef intercept. + num_classes = np.max(classes_present) + 1 + assert num_classes >= len(classes_present) + assert len(classes_present) == coef.shape[0] == intercept.shape[0] + new_coefs = np.zeros((num_classes, coef.shape[1])) + new_intercept = np.zeros((num_classes,)) + for coef_index, present_class in enumerate(list(classes_present)): + new_coefs[present_class, :] = coef[coef_index, :] + new_intercept[present_class] = intercept[coef_index] + return new_coefs, new_intercept + + def test_log_reg_warm_starting(features, labels, train_index, test_indices, val_index, loader_names, num_cs=100, start_c=-7, end_c=2, max_iter=200, random_state=0): L = len(features) @@ -103,6 +118,7 @@ def main(): help='Metric to select regularization on.', required=True) parser.add_argument('--seed', type=int, help='Random seed.', required=False, default=0) + parser.add_argument('--no_padding', action='store_true', help='dont pad missing labels') args, unparsed = parser.parse_known_args() print('Running on machine ', socket.gethostname()) @@ -111,7 +127,7 @@ def main(): if args.train_index is None: args.train_index = 0 if args.test_indices is None: - args.test_indices = list(range(0, len(loader_names))) + args.test_indices = list(range(0, len(loader_names))) print("Training on: ", loader_names[args.train_index]) print("Testing on: ") for idx in args.test_indices: @@ -142,6 +158,9 @@ def make_parent_dir(save_path): accs_df.to_csv(args.results_save_path, sep='\t') new_coef, new_intercept = inv_normalize_weights(coef, intercept, features, normalize_index=args.train_index) + # Pad the head if desired, if some classes are missing from the training set, e.g., in FMoW. + if not(args.no_padding): + new_coef, new_intercept = pad_head(new_coef, new_intercept, clf.classes_) pickle.dump((new_coef, new_intercept, best_c, best_i), open(args.weights_save_path, 'wb')) # Just a redundancy check that the best classifier weights, and best weights, are the same. assert(np.allclose(clf.coef_, coef)) From c5f51a0ef6fe5f7670f5d0260f82e1aff5cd9613 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 27 Dec 2022 16:05:43 -0800 Subject: [PATCH 187/197] Add cluster group. --- scripts/run_adaptation_experiments.py | 4 ++-- scripts/run_cpu_sbatch.sh | 1 + scripts/run_micro_sbatch.sh | 1 + scripts/run_rtx_sbatch.sh | 1 + scripts/run_sbatch.sh | 1 + scripts/run_sphinx_sbatch.sh | 1 + 6 files changed, 7 insertions(+), 2 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 4c2db27..668a2aa 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -680,7 +680,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/u/scr/nlp/', eval_config_rel_path='adaptation/fmow_eval.yaml') fmow_all = Dataset( @@ -695,7 +695,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/fmow_all.yaml', bundles=['fmow'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/u/scr/nlp/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') landcover = Dataset( diff --git a/scripts/run_cpu_sbatch.sh b/scripts/run_cpu_sbatch.sh index 14fdea0..6fab493 100644 --- a/scripts/run_cpu_sbatch.sh +++ b/scripts/run_cpu_sbatch.sh @@ -1,6 +1,7 @@ #!/bin/bash #SBATCH --nodes=1 #SBATCH --cpus-per-task=1 +#SBATCH --account=nlp #SBATCH --mem=16G # Print execute commands in the log. diff --git a/scripts/run_micro_sbatch.sh b/scripts/run_micro_sbatch.sh index 76f5797..b4a3faa 100644 --- a/scripts/run_micro_sbatch.sh +++ b/scripts/run_micro_sbatch.sh @@ -2,6 +2,7 @@ #SBATCH --nodes=1 #SBATCH --gres=gpu:0 #SBATCH --cpus-per-task=2 +#SBATCH --account=nlp #SBATCH --mem=2G #SBATCH --exclude=jagupard[10-11,17] diff --git a/scripts/run_rtx_sbatch.sh b/scripts/run_rtx_sbatch.sh index 1261db3..ddca908 100644 --- a/scripts/run_rtx_sbatch.sh +++ b/scripts/run_rtx_sbatch.sh @@ -3,6 +3,7 @@ #SBATCH --gres=gpu:1 #SBATCH --cpus-per-task=4 #SBATCH --mem=24G +#SBATCH --account=nlp #SBATCH --exclude=jagupard[10-25] # Print execute commands in the log. diff --git a/scripts/run_sbatch.sh b/scripts/run_sbatch.sh index 13211ed..d0ed67d 100644 --- a/scripts/run_sbatch.sh +++ b/scripts/run_sbatch.sh @@ -4,6 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --partition=jag-standard #SBATCH --mem=16G +#SBATCH --account=nlp #SBATCH --exclude=jagupard[14,15,18] # #SBATCH --exclude=jagupard[14,17,18,20] diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 101a759..57b6751 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -3,6 +3,7 @@ #SBATCH --gres=gpu:1 #SBATCH --cpus-per-task=4 #SBATCH --mem=24G +#SBATCH --account=nlp #SBATCH --partition=sphinx #SBATCH -t 2-0:00 From 3b16a3e96b6dbac183109c6b38920fae2762b963 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 27 Dec 2022 22:33:07 -0800 Subject: [PATCH 188/197] Restore hyper for fmow. --- scripts/codalab.sh | 2 -- scripts/run_adaptation_experiments.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/scripts/codalab.sh b/scripts/codalab.sh index 28e1dfd..b9146d8 100644 --- a/scripts/codalab.sh +++ b/scripts/codalab.sh @@ -32,6 +32,4 @@ for dataset in "${datasets[@]}"; do done -# ImageNet. - diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 734976c..7457734 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1536,7 +1536,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' - hyperparams_list = range_hyper('optimizer.args.lr', [0.01]) + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) From 8dab1c4e9d6edc957d37bd0744911945a85ae572 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Tue, 27 Dec 2022 22:33:07 -0800 Subject: [PATCH 189/197] Restore hyper for fmow. --- scripts/codalab.sh | 2 -- scripts/run_adaptation_experiments.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/scripts/codalab.sh b/scripts/codalab.sh index 28e1dfd..b9146d8 100644 --- a/scripts/codalab.sh +++ b/scripts/codalab.sh @@ -32,6 +32,4 @@ for dataset in "${datasets[@]}"; do done -# ImageNet. - diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 734976c..7457734 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1536,7 +1536,7 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn # Use the best hyperparameter for fmow and camelyon17. if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' - hyperparams_list = range_hyper('optimizer.args.lr', [0.01]) + hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) From b60d17fd553783c0882cc71bec0563c1ca37ec10 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 28 Dec 2022 10:34:51 -0800 Subject: [PATCH 190/197] Updates for surgical fine tuning checkpoints. --- scripts/run_adaptation_experiments.py | 18 ++++++++++++++++-- scripts/run_sphinx_sbatch.sh | 2 +- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 7457734..68c00d4 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1431,6 +1431,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) hyperparams_list = append_to_each(hyperparams_list, {'default_test_args.target_attribute': attribute_name}) hyperparams_list = append_to_each(hyperparams_list, {'train_dataset.args.target_attribute': attribute_name}) if args.no_replications: @@ -1537,9 +1539,15 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + elif 'fmow' in args.datasets[0] and args.optimizer is not None: + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + elif 'camelyon17' in args.datasets[0] and args.optimizer is not None: + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [1e-6]) elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. @@ -1609,6 +1617,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) if imagenet_lp_ft_phase2: if 'imagenet_augs' in args.datasets: hyperparams_list = append_to_each(hyperparams_list, @@ -1809,6 +1819,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each(hyperparams_list, {'l2sp_weight': 0.01}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) for dataset in datasets: cur_hyperparams_list = deepcopy(hyperparams_list) linprobe_group_path = get_group_dir_path(linprobe_adapt_name, dataset.name, args.model_name, args) @@ -2027,7 +2039,6 @@ def get_unparsed_options_dict(unparsed): help='What amulet cluster to run on? Only relevant if amulet_option is not None. Options:' '(sing/amlk8s/sing_basic)') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') - parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', help='(Slurm only) What priority to use.') parser.add_argument('--mail_user', type=str, required=False, @@ -2083,7 +2094,10 @@ def get_unparsed_options_dict(unparsed): help='Gradually unfreeze layers, multiply by cosine lr', required=False) parser.add_argument('--warmup_epochs', type=int, required=False, default=None, help='Number of epochs to run linear probe for.') - + parser.add_argument('--save_no_checkpoints', action='store_true') + parser.add_argument('--save_checkpoints', dest='save_no_checkpoints', action='store_false') + parser.set_defaults(save_no_checkpoints=True) + args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) options_dict = get_unparsed_options_dict(unparsed) diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 2d68ddf..fe35ce4 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3] +#SBATCH --exclude=sphinx[3-8] #SBATCH --account=nlp # Print execute commands in the log. From 406687a050a178b381a654f5b2c334fda3361f9a Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 28 Dec 2022 10:34:51 -0800 Subject: [PATCH 191/197] Updates for surgical fine tuning checkpoints. --- scripts/run_adaptation_experiments.py | 18 ++++++++++++++++-- scripts/run_sphinx_sbatch.sh | 2 +- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 7457734..68c00d4 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -1431,6 +1431,8 @@ def fine_tuning_celeba_single_experiment(args, attribute_name, num_replications= hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) hyperparams_list = append_to_each(hyperparams_list, {'default_test_args.target_attribute': attribute_name}) hyperparams_list = append_to_each(hyperparams_list, {'train_dataset.args.target_attribute': attribute_name}) if args.no_replications: @@ -1537,9 +1539,15 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn if 'fmow' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + elif 'fmow' in args.datasets[0] and args.optimizer is not None: + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [1e-5]) elif 'camelyon17' in args.datasets[0] and args.optimizer is None: adapt_name += '_best_' hyperparams_list = range_hyper('optimizer.args.lr', [0.0003]) + elif 'camelyon17' in args.datasets[0] and args.optimizer is not None: + adapt_name += '_best_' + hyperparams_list = range_hyper('optimizer.args.lr', [1e-6]) elif mixup_sweep: lr_hypers = range_hyper('optimizer.args.lr', sweep_lrs) # TODO: add 1.0 to this as well. @@ -1609,6 +1617,8 @@ def fine_tuning_experiments(args, num_replications=3, linear_probe=False, batchn hyperparams_list = append_to_each(hyperparams_list, {'scheduler.args.T_max': args.epochs}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) if imagenet_lp_ft_phase2: if 'imagenet_augs' in args.datasets: hyperparams_list = append_to_each(hyperparams_list, @@ -1809,6 +1819,8 @@ def lp_then_ft_experiments(args, num_replications=3, val_mode=False, train_mode= hyperparams_list = append_to_each(hyperparams_list, {'l2sp_weight': 0.01}) if args.save_no_checkpoints: hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': True}) + else: + hyperparams_list = append_to_each(hyperparams_list, {'save_no_checkpoints': False}) for dataset in datasets: cur_hyperparams_list = deepcopy(hyperparams_list) linprobe_group_path = get_group_dir_path(linprobe_adapt_name, dataset.name, args.model_name, args) @@ -2027,7 +2039,6 @@ def get_unparsed_options_dict(unparsed): help='What amulet cluster to run on? Only relevant if amulet_option is not None. Options:' '(sing/amlk8s/sing_basic)') parser.add_argument('--print_command', action='store_true', help='only print the python commands (dont run anything).') - parser.add_argument('--save_no_checkpoints', action='store_true', help='run on CodaLab not slurm') parser.add_argument('--partition', type=str, required=False, default='jag-standard', help='(Slurm only) What priority to use.') parser.add_argument('--mail_user', type=str, required=False, @@ -2083,7 +2094,10 @@ def get_unparsed_options_dict(unparsed): help='Gradually unfreeze layers, multiply by cosine lr', required=False) parser.add_argument('--warmup_epochs', type=int, required=False, default=None, help='Number of epochs to run linear probe for.') - + parser.add_argument('--save_no_checkpoints', action='store_true') + parser.add_argument('--save_checkpoints', dest='save_no_checkpoints', action='store_false') + parser.set_defaults(save_no_checkpoints=True) + args, unparsed = parser.parse_known_args() fill_platform_specific_default_args(args) options_dict = get_unparsed_options_dict(unparsed) diff --git a/scripts/run_sphinx_sbatch.sh b/scripts/run_sphinx_sbatch.sh index 2d68ddf..fe35ce4 100644 --- a/scripts/run_sphinx_sbatch.sh +++ b/scripts/run_sphinx_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[3] +#SBATCH --exclude=sphinx[3-8] #SBATCH --account=nlp # Print execute commands in the log. From 925100ada6df9f48edda2f85b633be3a230f7864 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 28 Dec 2022 17:51:15 -0800 Subject: [PATCH 192/197] Use scr-sync --- .../datasets_camelyon17_weakaugs.yaml | 10 +++--- configs/adaptation/datasets_domainnet.yaml | 12 +++---- configs/adaptation/datasets_waterbirds.yaml | 12 +++---- .../adaptation/datasets_waterbirds_augs.yaml | 12 +++---- .../adaptation/datasets_waterbirds_norm.yaml | 12 +++---- scripts/run_adaptation_experiments.py | 36 +++++++++---------- 6 files changed, 47 insertions(+), 47 deletions(-) diff --git a/configs/adaptation/datasets_camelyon17_weakaugs.yaml b/configs/adaptation/datasets_camelyon17_weakaugs.yaml index 47dc593..d127e43 100644 --- a/configs/adaptation/datasets_camelyon17_weakaugs.yaml +++ b/configs/adaptation/datasets_camelyon17_weakaugs.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' train_dataset: name: 'train' @@ -7,7 +7,7 @@ train_dataset: args: dataset_name: 'camelyon17' split: 'train' - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.Resize args: @@ -27,19 +27,19 @@ test_datasets: args: dataset_name: 'camelyon17' split: 'id_val' - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.wilds.WILDS args: dataset_name: 'camelyon17' split: 'val' - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.wilds.WILDS args: dataset_name: 'camelyon17' split: 'test' - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_domainnet.yaml b/configs/adaptation/datasets_domainnet.yaml index 88a576b..f087570 100644 --- a/configs/adaptation/datasets_domainnet.yaml +++ b/configs/adaptation/datasets_domainnet.yaml @@ -1,5 +1,5 @@ -root_prefix: '/scr/biggest/' +root_prefix: '/u/scr/nlp/domainnet' # The train and test transforms are taken from Sentry. # Except the normalization and the bicubic resampling, taken from CLIP. @@ -9,7 +9,7 @@ train_dataset: args: domain: 'sketch' split: 'train' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False transforms: @@ -36,7 +36,7 @@ test_datasets: args: domain: 'sketch' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'real_val' @@ -44,7 +44,7 @@ test_datasets: args: domain: 'real' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'painting_val' @@ -52,7 +52,7 @@ test_datasets: args: domain: 'painting' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'clipart_val' @@ -60,7 +60,7 @@ test_datasets: args: domain: 'clipart' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 7f73908..d8a6e5e 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -33,34 +33,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/configs/adaptation/datasets_waterbirds_augs.yaml b/configs/adaptation/datasets_waterbirds_augs.yaml index f416a8a..00a2348 100644 --- a/configs/adaptation/datasets_waterbirds_augs.yaml +++ b/configs/adaptation/datasets_waterbirds_augs.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -31,34 +31,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/configs/adaptation/datasets_waterbirds_norm.yaml b/configs/adaptation/datasets_waterbirds_norm.yaml index 02097eb..4f230ed 100644 --- a/configs/adaptation/datasets_waterbirds_norm.yaml +++ b/configs/adaptation/datasets_waterbirds_norm.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -43,34 +43,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 68c00d4..0305d43 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -575,7 +575,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -591,7 +591,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_mixup.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_mixup_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -625,7 +625,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_large_batch = Dataset( @@ -643,7 +643,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_large_batch.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_large_batch_eval.yaml') @@ -662,7 +662,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_clipped_warmup.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_clipped_warmup_eval.yaml') waterbirds_label_balanced = Dataset( @@ -680,7 +680,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_label_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_label_balanced_eval.yaml') waterbirds_group_balanced = Dataset( @@ -698,7 +698,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_group_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_group_balanced_eval.yaml') waterbirds_background = Dataset( @@ -717,7 +717,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_norm = Dataset( @@ -735,7 +735,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_norm.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_norm_eval.yaml') waterbirds_augs = Dataset( @@ -753,7 +753,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_augs.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_augs_eval.yaml') @@ -769,7 +769,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_noaugs.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -785,7 +785,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_nonorm.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -800,7 +800,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_entity'], config_rel_path='adaptation/entity30.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/entity30_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -816,7 +816,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -832,7 +832,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet_augs.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -879,7 +879,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/domainnet.yaml', bundles=['domainnet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/domainnet/domainnet_sentry/', eval_config_rel_path='adaptation/domainnet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') @@ -970,7 +970,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/camelyon17_weakaugs.yaml', bundles=['camelyon17'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/camelyon17_weakaugs_eval.yaml') camelyon17_weakaugs_highres = Dataset( @@ -985,7 +985,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/camelyon17_weakaugs_highres.yaml', bundles=['camelyon17'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/camelyon17_weakaugs_highres_eval.yaml') landcover = Dataset( From a5724e57170d5e5f2c538f8f66af78da673ed96c Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Wed, 28 Dec 2022 17:51:15 -0800 Subject: [PATCH 193/197] Use scr-sync --- .../datasets_camelyon17_weakaugs.yaml | 10 +++--- configs/adaptation/datasets_domainnet.yaml | 12 +++---- configs/adaptation/datasets_waterbirds.yaml | 12 +++---- .../adaptation/datasets_waterbirds_augs.yaml | 12 +++---- .../adaptation/datasets_waterbirds_norm.yaml | 12 +++---- scripts/run_adaptation_experiments.py | 36 +++++++++---------- 6 files changed, 47 insertions(+), 47 deletions(-) diff --git a/configs/adaptation/datasets_camelyon17_weakaugs.yaml b/configs/adaptation/datasets_camelyon17_weakaugs.yaml index 47dc593..d127e43 100644 --- a/configs/adaptation/datasets_camelyon17_weakaugs.yaml +++ b/configs/adaptation/datasets_camelyon17_weakaugs.yaml @@ -1,5 +1,5 @@ -root_prefix: '/u/scr/nlp/' +root_prefix: '/u/scr/nlp/wilds/data/' train_dataset: name: 'train' @@ -7,7 +7,7 @@ train_dataset: args: dataset_name: 'camelyon17' split: 'train' - root: 'wilds/data' + root: '' transforms: - classname: torchvision.transforms.Resize args: @@ -27,19 +27,19 @@ test_datasets: args: dataset_name: 'camelyon17' split: 'id_val' - root: 'wilds/data' + root: '' - name: 'ood_val' classname: datasets.wilds.WILDS args: dataset_name: 'camelyon17' split: 'val' - root: 'wilds/data' + root: '' - name: 'ood_test' classname: datasets.wilds.WILDS args: dataset_name: 'camelyon17' split: 'test' - root: 'wilds/data' + root: '' early_stop_dataset_names: - 'id_val' diff --git a/configs/adaptation/datasets_domainnet.yaml b/configs/adaptation/datasets_domainnet.yaml index 88a576b..f087570 100644 --- a/configs/adaptation/datasets_domainnet.yaml +++ b/configs/adaptation/datasets_domainnet.yaml @@ -1,5 +1,5 @@ -root_prefix: '/scr/biggest/' +root_prefix: '/u/scr/nlp/domainnet' # The train and test transforms are taken from Sentry. # Except the normalization and the bicubic resampling, taken from CLIP. @@ -9,7 +9,7 @@ train_dataset: args: domain: 'sketch' split: 'train' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False transforms: @@ -36,7 +36,7 @@ test_datasets: args: domain: 'sketch' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'real_val' @@ -44,7 +44,7 @@ test_datasets: args: domain: 'real' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'painting_val' @@ -52,7 +52,7 @@ test_datasets: args: domain: 'painting' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False - name: 'clipart_val' @@ -60,7 +60,7 @@ test_datasets: args: domain: 'clipart' split: 'test' - root: 'domainnet/' + root: '' version: 'sentry' verbose: False diff --git a/configs/adaptation/datasets_waterbirds.yaml b/configs/adaptation/datasets_waterbirds.yaml index 7f73908..d8a6e5e 100644 --- a/configs/adaptation/datasets_waterbirds.yaml +++ b/configs/adaptation/datasets_waterbirds.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -33,34 +33,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/configs/adaptation/datasets_waterbirds_augs.yaml b/configs/adaptation/datasets_waterbirds_augs.yaml index f416a8a..00a2348 100644 --- a/configs/adaptation/datasets_waterbirds_augs.yaml +++ b/configs/adaptation/datasets_waterbirds_augs.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -31,34 +31,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/configs/adaptation/datasets_waterbirds_norm.yaml b/configs/adaptation/datasets_waterbirds_norm.yaml index 02097eb..4f230ed 100644 --- a/configs/adaptation/datasets_waterbirds_norm.yaml +++ b/configs/adaptation/datasets_waterbirds_norm.yaml @@ -6,7 +6,7 @@ train_dataset: name: 'train' classname: datasets.wilds.WILDS args: - root: 'wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'train' transforms: @@ -43,34 +43,34 @@ test_datasets: - name: 'val' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'val' - name: 'landbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 0, 0] - name: 'landbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [0, 1, 0] - name: 'waterbg-landbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 0, 0] - name: 'waterbg-waterbird-test' classname: datasets.wilds.WILDS args: - root: '/wilds/data/' + root: '' dataset_name: 'waterbirds' split: 'test' meta_selector: [1, 1, 0] diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 68c00d4..0305d43 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -575,7 +575,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -591,7 +591,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_mixup.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_mixup_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -625,7 +625,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_large_batch = Dataset( @@ -643,7 +643,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_large_batch.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_large_batch_eval.yaml') @@ -662,7 +662,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_clipped_warmup.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_clipped_warmup_eval.yaml') waterbirds_label_balanced = Dataset( @@ -680,7 +680,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_label_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_label_balanced_eval.yaml') waterbirds_group_balanced = Dataset( @@ -698,7 +698,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_group_balanced.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_group_balanced_eval.yaml') waterbirds_background = Dataset( @@ -717,7 +717,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_eval.yaml') waterbirds_norm = Dataset( @@ -735,7 +735,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_norm.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_norm_eval.yaml') waterbirds_augs = Dataset( @@ -753,7 +753,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/waterbirds_augs.yaml', bundles=['waterbirds_pickle'], slurm_data_cmd=None, - slurm_data_dir='/u/scr/nlp/', # corresponds to root_prefix. + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', # corresponds to root_prefix. eval_config_rel_path='adaptation/waterbirds_augs_eval.yaml') @@ -769,7 +769,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_noaugs.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -785,7 +785,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/living17_nonorm.yaml', bundles=['imagenet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -800,7 +800,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_entity'], config_rel_path='adaptation/entity30.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/entity30_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -816,7 +816,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -832,7 +832,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/renditions'], config_rel_path='adaptation/imagenet_augs.yaml', bundles=['imagenet'], - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/', slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -879,7 +879,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/domainnet.yaml', bundles=['domainnet'], slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', - slurm_data_dir='/scr/biggest/', + slurm_data_dir='/self/scr-sync/nlp/domainnet/domainnet_sentry/', eval_config_rel_path='adaptation/domainnet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') @@ -970,7 +970,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/camelyon17_weakaugs.yaml', bundles=['camelyon17'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/camelyon17_weakaugs_eval.yaml') camelyon17_weakaugs_highres = Dataset( @@ -985,7 +985,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/camelyon17_weakaugs_highres.yaml', bundles=['camelyon17'], slurm_data_cmd=None, - slurm_data_dir='/scr/biggest/ue_datasets/', + slurm_data_dir='/self/scr-sync/nlp/wilds/data/', eval_config_rel_path='adaptation/camelyon17_weakaugs_highres_eval.yaml') landcover = Dataset( From 3a35b16ad065b1f39bf159201e641774b976e776 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 29 Dec 2022 23:43:27 -0800 Subject: [PATCH 194/197] Merge branch 'amulet' of github.com:AnanyaKumar/transfer_learning into amulet From e295e789b9c1dcd4f20d1ecd7edcd25bbf87067d Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 29 Dec 2022 23:46:05 -0800 Subject: [PATCH 195/197] Updates --- ...oad_models_test_get_layers_gradients.ipynb | 51 +++++++++++++++++-- scripts/run_adaptation_experiments.py | 5 +- scripts/run_sphinx_big_sbatch.sh | 2 +- 3 files changed, 51 insertions(+), 7 deletions(-) diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index b93c2a7..f651cc9 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 36, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 36, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -252,6 +252,49 @@ "# Test get layers for different models" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# convnext\n", + "\n", + "convnext = timm_model.TimmModel('convnext_base_in22k')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num layers: 7\n", + "no. of params in layer 0 (stem): 6528\n", + "no. of params in layer 1 (stage0): 415488\n", + "no. of params in layer 2 (stage1): 1748992\n", + "no. of params in layer 3 (stage2): 57950208\n", + "no. of params in layer 4 (stage3): 27443200\n", + "no. of params in layer 5 (post_norm): 2048\n", + "no. of params in layer 6 (head): 22387025\n", + "109953489\n" + ] + } + ], + "source": [ + "layers = convnext.get_layers()\n", + "print('num layers: ', len(layers))\n", + "total_count = 0\n", + "for i in range(len(layers)):\n", + " num_params = utils.count_parameters(layers[i][1], trainable=False) + utils.count_parameters(layers[i][1], trainable=True)\n", + " total_count += num_params\n", + " print(f'no. of params in layer {i} ({layers[i][0]}): {num_params}')\n", + "print(total_count)" + ] + }, { "cell_type": "code", "execution_count": 22, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 02b08cf..18383dc 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -911,7 +911,6 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['fmow_v1.1'], slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/wilds/data/', - slurm_data_dir='/u/scr/nlp/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -1376,7 +1375,9 @@ def append_to_each(hyperparams_list, more_hyperparams): ## Main experiments. ############################################ -SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +SWEEP_LRS = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +# We used more LRs for codalab. +# SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] def get_datasets(args): print(args.datasets) diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh index b844a5d..fc50b36 100644 --- a/scripts/run_sphinx_big_sbatch.sh +++ b/scripts/run_sphinx_big_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[1,2,3,8] +#SBATCH --exclude=sphinx[1,2,3,4,5,6] #SBATCH --account=nlp # Print execute commands in the log. From 22bfc573c4ea3fa93d005e8b9b61e2eff0f48252 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Thu, 29 Dec 2022 23:46:05 -0800 Subject: [PATCH 196/197] Updates --- ...oad_models_test_get_layers_gradients.ipynb | 51 +++++++++++++++++-- scripts/run_adaptation_experiments.py | 5 +- scripts/run_sphinx_big_sbatch.sh | 2 +- 3 files changed, 51 insertions(+), 7 deletions(-) diff --git a/scripts/load_models_test_get_layers_gradients.ipynb b/scripts/load_models_test_get_layers_gradients.ipynb index b93c2a7..f651cc9 100644 --- a/scripts/load_models_test_get_layers_gradients.ipynb +++ b/scripts/load_models_test_get_layers_gradients.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 36, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 36, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -252,6 +252,49 @@ "# Test get layers for different models" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# convnext\n", + "\n", + "convnext = timm_model.TimmModel('convnext_base_in22k')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num layers: 7\n", + "no. of params in layer 0 (stem): 6528\n", + "no. of params in layer 1 (stage0): 415488\n", + "no. of params in layer 2 (stage1): 1748992\n", + "no. of params in layer 3 (stage2): 57950208\n", + "no. of params in layer 4 (stage3): 27443200\n", + "no. of params in layer 5 (post_norm): 2048\n", + "no. of params in layer 6 (head): 22387025\n", + "109953489\n" + ] + } + ], + "source": [ + "layers = convnext.get_layers()\n", + "print('num layers: ', len(layers))\n", + "total_count = 0\n", + "for i in range(len(layers)):\n", + " num_params = utils.count_parameters(layers[i][1], trainable=False) + utils.count_parameters(layers[i][1], trainable=True)\n", + " total_count += num_params\n", + " print(f'no. of params in layer {i} ({layers[i][0]}): {num_params}')\n", + "print(total_count)" + ] + }, { "cell_type": "code", "execution_count": 22, diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 02b08cf..18383dc 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -911,7 +911,6 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): bundles=['fmow_v1.1'], slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/wilds/data/', - slurm_data_dir='/u/scr/nlp/', eval_config_rel_path='adaptation/fmow_all_eval.yaml') fmow_all_nonorm = Dataset( @@ -1376,7 +1375,9 @@ def append_to_each(hyperparams_list, more_hyperparams): ## Main experiments. ############################################ -SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +SWEEP_LRS = [3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] +# We used more LRs for codalab. +# SWEEP_LRS = [3e-7, 1e-6, 3e-6, 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2] def get_datasets(args): print(args.datasets) diff --git a/scripts/run_sphinx_big_sbatch.sh b/scripts/run_sphinx_big_sbatch.sh index b844a5d..fc50b36 100644 --- a/scripts/run_sphinx_big_sbatch.sh +++ b/scripts/run_sphinx_big_sbatch.sh @@ -4,7 +4,7 @@ #SBATCH --cpus-per-task=4 #SBATCH --mem=24G #SBATCH --partition=sphinx -#SBATCH --exclude=sphinx[1,2,3,8] +#SBATCH --exclude=sphinx[1,2,3,4,5,6] #SBATCH --account=nlp # Print execute commands in the log. From d3433110d422b4e4ceb307104a657dcf2b55a0b4 Mon Sep 17 00:00:00 2001 From: Ananya Kumar Date: Fri, 30 Dec 2022 00:38:46 -0800 Subject: [PATCH 197/197] Remove printing in summarize results. --- .gitignore | 2 + scripts/amlt_config_template_amlk8s.yaml | 20 --- scripts/amlt_config_template_sing.yaml | 17 --- scripts/amlt_setup.yaml | 7 - ...eeze-embed-paper-fine-tuning-results.ipynb | 120 ++++++++++++++++-- scripts/run_adaptation_experiments.py | 16 +-- scripts/summarize_results.py | 4 +- 7 files changed, 123 insertions(+), 63 deletions(-) delete mode 100644 scripts/amlt_config_template_amlk8s.yaml delete mode 100644 scripts/amlt_config_template_sing.yaml delete mode 100644 scripts/amlt_setup.yaml diff --git a/.gitignore b/.gitignore index 72f1f93..613d06e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +**.swn +**.swo **amlt_configs/** .amltconfig **amlt_scripts** diff --git a/scripts/amlt_config_template_amlk8s.yaml b/scripts/amlt_config_template_amlk8s.yaml deleted file mode 100644 index a1bba32..0000000 --- a/scripts/amlt_config_template_amlk8s.yaml +++ /dev/null @@ -1,20 +0,0 @@ -target: - service: amlk8s - # run "amlt target list amlk8s" to list the names of available AMLK8s targets - name: itplabrr1cl1 - vc: resrchvc - -environment: - image: pytorch/pytorch:latest - registry: docker.io # any public registry can be specified here -{setup} - -code: - # local directory of the code. this will be uploaded to the server. - # $CONFIG_DIR is expanded to the directory of this config file - local_dir: . - -# data: -# data upload is not required for this example - -jobs: diff --git a/scripts/amlt_config_template_sing.yaml b/scripts/amlt_config_template_sing.yaml deleted file mode 100644 index 2337642..0000000 --- a/scripts/amlt_config_template_sing.yaml +++ /dev/null @@ -1,17 +0,0 @@ -target: - service: sing - name: msrresrchvc - -environment: - image: amlt-sing/pytorch-1.8.0 -{setup} - -code: - # local directory of the code. this will be uploaded to the server. - # $CONFIG_DIR is expanded to the directory of this config file - local_dir: . - -# data: -# data upload is not required for this example - -jobs: diff --git a/scripts/amlt_setup.yaml b/scripts/amlt_setup.yaml deleted file mode 100644 index 1f85616..0000000 --- a/scripts/amlt_setup.yaml +++ /dev/null @@ -1,7 +0,0 @@ - setup: - - set -x - - apt-get update - - apt-get install git - - pip install ./CLIP - - pip install -e . - - echo "$SHELL" \ No newline at end of file diff --git a/scripts/freeze-embed-paper-fine-tuning-results.ipynb b/scripts/freeze-embed-paper-fine-tuning-results.ipynb index f55cd9c..9056170 100644 --- a/scripts/freeze-embed-paper-fine-tuning-results.ipynb +++ b/scripts/freeze-embed-paper-fine-tuning-results.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 43, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,7 +11,7 @@ "" ] }, - "execution_count": 43, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -275,17 +275,119 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Get average ID and OOD results for the 3 methods.\n", + "print(np.mean(id_mean_table[:,:,5], axis=0))\n", + "print(np.mean(ood_mean_table[:,:,5], axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ConvNeXt results including just freeze stem" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4, 11)\n", + "\n", + "\n", + "ID Accuracies\n", + "\t\tLiving-17\tWaterbirds\tFMoW\tCamelyon\tAvg.\n", + "ConvNext-Base\tSGD\t98.7\t99.0\t66.3\t99.4\t90.9\n", + "ConvNext-Base\tAdamW\t98.6\t99.5\t68.8\t99.7\t91.7\n", + "ConvNext-Base\tSGD (freeze-stem-block-1)\t98.6\t99.4\t67.4\t99.5\t91.2\n", + "ConvNext-Base\tSGD (freeze-stem)\t98.8\t99.3\t67.2\t99.5\t91.2\n", + "\n", + "\\begin{tabular}{ccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & \\textbf{98.7} & & 99.0 & & 66.3 & & 99.4 & & 90.9 & \\\\\n", + "AdamW & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\hgreen{(+0.5)}} & \\textbf{68.8} & \\hspace{-1em}{\\hgreen{(+2.5)}} & \\textbf{99.7} & \\hspace{-1em}{\\hgreen{(+0.3)}} & \\textbf{91.7} & \\hspace{-1em}{\\hgreen{(+0.8)}}\\\\\n", + "SGD (freeze-stem-block-1) & \\textbf{98.6} & \\hspace{-1em}{\\lred{(-0.1)}} & \\textbf{99.4} & \\hspace{-1em}{\\hgreen{(+0.4)}} & 67.4 & \\hspace{-1em}{\\hgreen{(+1.1)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.2 & \\hspace{-1em}{\\hgreen{(+0.3)}}\\\\\n", + "SGD (freeze-stem) & \\textbf{98.8} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 99.3 & \\hspace{-1em}{\\hgreen{(+0.3)}} & 67.2 & \\hspace{-1em}{\\hgreen{(+0.9)}} & \\textbf{99.5} & \\hspace{-1em}{\\lgreen{(+0.1)}} & 91.2 & \\hspace{-1em}{\\hgreen{(+0.3)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n", + "\n", + "OOD Accuracies\n", + "\t\tLiving-17\tWaterbirds\tFMoW\tCamelyon\tAvg.\n", + "ConvNext-Base\tSGD\t94.0\t80.2\t39.7\t83.0\t74.2\n", + "ConvNext-Base\tAdamW\t90.3\t89.8\t38.4\t89.5\t77.0\n", + "ConvNext-Base\tSGD (freeze-stem-block-1)\t92.6\t86.9\t38.2\t88.1\t76.5\n", + "ConvNext-Base\tSGD (freeze-stem)\t91.4\t84.7\t40.3\t86.2\t75.7\n", + "\n", + "\\begin{tabular}{ccccccccc|cc}\n", + "\\toprule\n", + " & \\multicolumn{2}{c}{Living-17} & \\multicolumn{2}{c}{Waterbirds} & \\multicolumn{2}{c}{FMoW} & \\multicolumn{2}{c}{Camelyon} & \\multicolumn{2}{c}{Avg.} \\\\\n", + "\\midrule\n", + "SGD & \\textbf{94.0} & & 80.2 & & 39.7 & & 83.0 & & 74.2 & \\\\\n", + "AdamW & 90.3 & \\hspace{-1em}{\\hred{(-3.7)}} & \\textbf{89.8} & \\hspace{-1em}{\\hgreen{(+9.6)}} & 38.4 & \\hspace{-1em}{\\hred{(-1.3)}} & \\textbf{89.5} & \\hspace{-1em}{\\hgreen{(+6.5)}} & \\textbf{77.0} & \\hspace{-1em}{\\hgreen{(+2.8)}}\\\\\n", + "SGD (freeze-stem-block-1) & 92.6 & \\hspace{-1em}{\\hred{(-1.4)}} & 86.9 & \\hspace{-1em}{\\hgreen{(+6.7)}} & 38.2 & \\hspace{-1em}{\\hred{(-1.5)}} & 88.1 & \\hspace{-1em}{\\hgreen{(+5.1)}} & 76.5 & \\hspace{-1em}{\\hgreen{(+2.3)}}\\\\\n", + "SGD (freeze-stem) & 91.4 & \\hspace{-1em}{\\hred{(-2.6)}} & 84.7 & \\hspace{-1em}{\\hgreen{(+4.5)}} & \\textbf{40.3} & \\hspace{-1em}{\\hgreen{(+0.6)}} & 86.2 & \\hspace{-1em}{\\hgreen{(+3.2)}} & 75.7 & \\hspace{-1em}{\\hgreen{(+1.5)}}\\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n" + ] + } + ], "source": [ - "# Get average ID and OOD results for the 3 methods.\n", - "print(np.mean(id_mean_table[:,:,5], axis=0))\n", - "print(np.mean(ood_mean_table[:,:,5], axis=0))" + "# # ConvNeXt, Living17, Waterbirds, DomainNet, Camelyon, FMoW (Early stopped), including freeze-stem\n", + "# models = ['convnext_vit_b']\n", + "# options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_1_']\n", + "# datasets = ['living17_nonorm', 'waterbirds', 'domainnet', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "# output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/sketch_val', 'test_acc/real_val'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "# val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "# aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/sketch_val', 'test_acc/id_val', 'test_acc/id_val']\n", + "# desired_epochs_list = [20, 20, 50, 5, 3]\n", + "# shorted_model_names = ['CLIP ViT-B/16', 'CLIP ViT-L/14', 'Sup ViT-B/16', 'DINO ViT-B/16', 'ConvNext-Base', 'BiT ResNet-50', 'BiT ResNet-101', ]\n", + "# shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-stem-block-1)', 'SGD (freeze-stem)']\n", + "# id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/sketch_val'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "# ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/real_val'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "# shortened_dataset_names = ['Living-17', 'Waterbirds', 'DomainNet', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "\n", + "# mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# # pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "# # mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "\n", + "# id_mean_table, ood_mean_table = display_id_ood_tables(\n", + "# mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# # display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)\n", + "\n", + "# The following table is without DomainNet.\n", + "models = ['convnext_vit_b']\n", + "options = ['', 'opt_torch.optim.AdamW_', 'freeze_bottom_2_', 'freeze_bottom_1_']\n", + "datasets = ['living17_nonorm', 'waterbirds', 'fmow_all_nonorm_weakaugs', 'camelyon17_weakaugs']\n", + "output_metrics_list = [['test_acc/source_val_living', 'test_acc/target_val_living'], ['WATERBIRDS_VAL', 'WORST'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test', 'test_acc/africa_test'], ['test_acc/id_val', 'test_acc/ood_val', 'test_acc/ood_test']]\n", + "val_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/id_val', 'test_acc/id_val']\n", + "aggregation_metric_list = ['test_acc/source_val_living', 'WATERBIRDS_VAL', 'test_acc/id_val', 'test_acc/id_val']\n", + "desired_epochs_list = [20, 20, 5, 3]\n", + "shorted_model_names = ['ConvNext-Base']\n", + "shortened_options_names = ['SGD', 'AdamW', 'SGD (freeze-stem-block-1)', 'SGD (freeze-stem)']\n", + "id_output_metrics_list = [['test_acc/source_val_living'], ['WATERBIRDS_VAL'], ['test_acc/id_val'], ['test_acc/id_val']]\n", + "ood_output_metrics_list = [['test_acc/target_val_living'], ['WORST'], ['test_acc/africa_test'], ['test_acc/ood_test']]\n", + "shortened_dataset_names = ['Living-17', 'Waterbirds', \"FMoW\", \"Camelyon\", \"Avg.\"]\n", + "\n", + "\n", + "mean_table, std_table = get_table(log_dir, name_template, models, options, datasets, output_metrics_list, val_metric_list, aggregation_metric_list, desired_epochs_list=desired_epochs_list)\n", + "# pickle.dump( (mean_table, std_table), open( \"big_table_main.pkl\", \"wb\" ) )\n", + "# mean_table_old_order, std_table_old_order = pickle.load( open( \"big_table_main.pkl\", \"rb\" ) )\n", + "\n", + "print(mean_table.shape)\n", + "id_mean_table, ood_mean_table = display_id_ood_tables(\n", + " mean_table, std_table, id_output_metrics_list, ood_output_metrics_list, shortened_dataset_names, no_std=True)\n", + "\n", + "# display_tsv_table(shorted_model_names, shortened_options_names, shortened_output_metrics_list, mean_table, std_table)" ] }, { diff --git a/scripts/run_adaptation_experiments.py b/scripts/run_adaptation_experiments.py index 18383dc..bfd1430 100644 --- a/scripts/run_adaptation_experiments.py +++ b/scripts/run_adaptation_experiments.py @@ -574,7 +574,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_living'], config_rel_path='adaptation/living17.yaml', bundles=['imagenet'], - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -590,7 +590,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_living'], config_rel_path='adaptation/living17_mixup.yaml', bundles=['imagenet'], - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_mixup_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -768,7 +768,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_living'], config_rel_path='adaptation/living17_noaugs.yaml', bundles=['imagenet'], - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -784,7 +784,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/target_val_living'], config_rel_path='adaptation/living17_nonorm.yaml', bundles=['imagenet'], - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/', eval_config_rel_path='adaptation/living17_nonorm_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -801,7 +801,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/entity30.yaml', bundles=['imagenet'], slurm_data_dir='/self/scr-sync/nlp/', - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, eval_config_rel_path='adaptation/entity30_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -817,7 +817,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/imagenet.yaml', bundles=['imagenet'], slurm_data_dir='/self/scr-sync/nlp/', - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, eval_config_rel_path='adaptation/imagenet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -833,7 +833,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): config_rel_path='adaptation/imagenet_augs.yaml', bundles=['imagenet'], slurm_data_dir='/self/scr-sync/nlp/', - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh imagenet', + slurm_data_cmd=None, eval_config_rel_path='adaptation/imagenet_augs_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_imagenet.sh') @@ -878,7 +878,7 @@ def summarize_linprobe(adapt_name, dataset, model, args, deps, max_num=None): 'test_acc/real_val', 'test_acc/painting_val', 'test_acc/clipart_val'], config_rel_path='adaptation/domainnet.yaml', bundles=['domainnet'], - slurm_data_cmd='source {scripts_dir}/copy_dataset.sh domainnet', + slurm_data_cmd=None, slurm_data_dir='/self/scr-sync/nlp/domainnet/domainnet_sentry/', eval_config_rel_path='adaptation/domainnet_eval.yaml', amlt_data_cmd='. {scripts_dir}/amlt_copy_domainnet.sh') diff --git a/scripts/summarize_results.py b/scripts/summarize_results.py index f2a9501..6fd80e4 100644 --- a/scripts/summarize_results.py +++ b/scripts/summarize_results.py @@ -60,8 +60,8 @@ def get_result(file_path, val_metric, output_metrics, take_max=True): # Get run-name and wandb from config file. parent_dir = Path(file_path).parent.absolute() config_path = parent_dir / 'config.json' - print(parent_dir, config_path) - print(Path(file_path).parent.name) + # print(parent_dir, config_path) + # print(Path(file_path).parent.name) if Path(file_path).parent.name == 'logs': # Codalab. grandparent_dir = Path(file_path).parent.parent

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%0DeXzksd;-# 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�HbU>U!f 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 R>eLeW(pJ}3%RF=<=x@pmd%6Gs literal 0 HcmV?d00001 diff --git a/CLIP/LICENSE b/CLIP/LICENSE new file mode 100644 index 0000000..4e97f0b --- /dev/null +++ b/CLIP/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2021 OpenAI + +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/CLIP/MANIFEST.in b/CLIP/MANIFEST.in new file mode 100644 index 0000000..effd8d9 --- /dev/null +++ b/CLIP/MANIFEST.in @@ -0,0 +1 @@ +include clip/bpe_simple_vocab_16e6.txt.gz diff --git a/CLIP/README.md b/CLIP/README.md new file mode 100644 index 0000000..abc8a34 --- /dev/null +++ b/CLIP/README.md @@ -0,0 +1,193 @@ +# CLIP + +[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb) + +CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision. + + + +## Approach + +![CLIP](CLIP.png) + + + +## Usage + +First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick: + +```bash +$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0 +$ pip install ftfy regex tqdm +$ pip install git+https://github.com/openai/CLIP.git +``` + +Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU. + +```python +import torch +import clip +from PIL import Image + +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load("ViT-B/32", device=device) + +image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device) +text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + +with torch.no_grad(): + image_features = model.encode_image(image) + text_features = model.encode_text(text) + + logits_per_image, logits_per_text = model(image, text) + probs = logits_per_image.softmax(dim=-1).cpu().numpy() + +print("Label probs:", probs) # prints: [[0.9927937 0.00421068 0.00299572]] +``` + + +## API + +The CLIP module `clip` provides the following methods: + +#### `clip.available_models()` + +Returns the names of the available CLIP models. + +#### `clip.load(name, device=..., jit=False)` + +Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint. + +The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded. + +#### `clip.tokenize(text: Union[str, List[str]], context_length=77)` + +Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model + +--- + +The model returned by `clip.load()` supports the following methods: + +#### `model.encode_image(image: Tensor)` + +Given a batch of images, returns the image features encoded by the vision portion of the CLIP model. + +#### `model.encode_text(text: Tensor)` + +Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model. + +#### `model(image: Tensor, text: Tensor)` + +Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100. + + + +## More Examples + +### Zero-Shot Prediction + +The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset. + +```python +import os +import clip +import torch +from torchvision.datasets import CIFAR100 + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Download the dataset +cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False) + +# Prepare the inputs +image, class_id = cifar100[3637] +image_input = preprocess(image).unsqueeze(0).to(device) +text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device) + +# Calculate features +with torch.no_grad(): + image_features = model.encode_image(image_input) + text_features = model.encode_text(text_inputs) + +# Pick the top 5 most similar labels for the image +image_features /= image_features.norm(dim=-1, keepdim=True) +text_features /= text_features.norm(dim=-1, keepdim=True) +similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1) +values, indices = similarity[0].topk(5) + +# Print the result +print("\nTop predictions:\n") +for value, index in zip(values, indices): + print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%") +``` + +The output will look like the following (the exact numbers may be slightly different depending on the compute device): + +``` +Top predictions: + + snake: 65.31% + turtle: 12.29% + sweet_pepper: 3.83% + lizard: 1.88% + crocodile: 1.75% +``` + +Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs. + + +### Linear-probe evaluation + +The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features. + +```python +import os +import clip +import torch + +import numpy as np +from sklearn.linear_model import LogisticRegression +from torch.utils.data import DataLoader +from torchvision.datasets import CIFAR100 +from tqdm import tqdm + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Load the dataset +root = os.path.expanduser("~/.cache") +train = CIFAR100(root, download=True, train=True, transform=preprocess) +test = CIFAR100(root, download=True, train=False, transform=preprocess) + + +def get_features(dataset): + all_features = [] + all_labels = [] + + with torch.no_grad(): + for images, labels in tqdm(DataLoader(dataset, batch_size=100)): + features = model.encode_image(images.to(device)) + + all_features.append(features) + all_labels.append(labels) + + return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy() + +# Calculate the image features +train_features, train_labels = get_features(train) +test_features, test_labels = get_features(test) + +# Perform logistic regression +classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1) +classifier.fit(train_features, train_labels) + +# Evaluate using the logistic regression classifier +predictions = classifier.predict(test_features) +accuracy = np.mean((test_labels == predictions).astype(np.float)) * 100. +print(f"Accuracy = {accuracy:.3f}") +``` + +Note that the `C` value should be determined via a hyperparameter sweep using a validation split. diff --git a/CLIP/clip/__init__.py b/CLIP/clip/__init__.py new file mode 100644 index 0000000..dcc5619 --- /dev/null +++ b/CLIP/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/CLIP/clip/bpe_simple_vocab_16e6.txt.gz b/CLIP/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..7b5088a527f720063f044eb928eee315f63b2fc0 GIT binary patch literal 1356917 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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag 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%0DeXzksd;-# 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�HbU>U!f zcpzT07Hk`+V(FkogLU$toMWdL-x8;x`xI~5>7;<%4xx=IKJ!uooXcDYtZTFoK4mU2 z#p+!*FzsJYYri|&owZghVLMiCO1hFxw+xHE9WcIn+@GxscRD?gpImuzMXPreDwQ#F zagE4-+{!zhH7yaMQ*Yi?yIn2$y)CV|??i>HgL|Hh%!Ic@Q~0u&=De&Ow4VPu8QF6T zA&C$ts6L_Oea<=mH+$>>ny?(fRvVK$?8hz9u-dKrnfgb>rso{p)2n*d@X7)I!I4PH z{K*Xkf3F)C$4Je`bIpTm-f$T~L=I!yF53I)^n2t#)grX<${o8C&@?14DJ|1Z|wDku)9-4YE1ceg-rcXxMpx8T9uEx1eL?(WbDE+M!C zCrINO++BJ)|C}>-rt03Bm;17dm+mU6_g>#x>obbWpBp_Wc-nBcXWvU0QZ06wxbG#^ zivA#|rNKRHtnBr#yIaD09H4m-jG|msnEEju7Cf744HeBNz#_s5O;g895w}fvSfTee zUY+Ik4nWqre9KMmQ1OxqtPCAwTv;726{CEGv>57c1Io=4{VGw^TKE&kUakwD-!8EiXI> z{*6^=vuNJer^HdvKkqcVh{d2xFX1aFUU5z#`T*QTsagz|YEhavRtr)I&r?zWBn$ z6sFXd`i~uy%Zr6RN4?3rdgOh*tHvi+Yxr)r_W?v#qA zJA6?26{-TMW?oM0t_yUDsO)O1VwH2|bg73?^DkBDj4=7pMH|*WUlH5~$ktWh*C&%d zaWzZC(KQhet6o#}bsdUk4mEa(AxN;~;tK#*`%_?JM zmW9A?9yBIrb?FEX`Y|&MzwA10JGllXGYn$bn*>hFdZ?7n^+W`^Yd$iE<*_B|C(as! zi5I9djZ*p`UgB}j)DlEt5F?Vy=8+2Hp$^&B7EY?y{%PvO`zZNQwMOMMyxYjw+Q*VW zTDw3A8}XroV?+0SK}4TC%0f^+pVptXHs6*f2eHsTYdH0IbC&M=pQ{VN@lA}-=4W&u zvUkrnyYg}7E@ztDiO=+33+FtS{JM#mdo4G6106uE36OMquHbq5F8%tA0q*;v>6>;# z`wmh=#{m&b@8b@4$LT*n!VL<(!Vd-nK)pd0=w<={xZYKI-OWu+KhN4Wr#5>0v7;g? z{r`QbpB*V{#~0elf*>BS=b58wTbF9J$?L<}$IKq#C&Rl{(>K)CGoc9505JF}>f&9w z;Ne%{!NdC_Sfugt1MJ_CWUh(BTX7|s zpGmd%5ee`8xz|9PXk(E@QBh2$siZOaeU)e8#gNO!crJ{grlRR+5-TAB?YB;p7z)5L z>^h9Qg*x?DR{vnDxYN_P6Wp+7nJi4&&muyu6+J^tw>*zOXdVM!9DJ~w`>lM>1N(n)BG*^l# z60||OKUo|U$L}JDW$ioskIx`p2e^7ux^MU@_NM{7+XzzB|At8c|ICeuoz=SoId~rX zrTIJG@_)EA-F4BU8)#m_i}G^g?RW_>=KKblOVVJS|(Gbg7K1xzprwt^bIE+az)P84Z9yE(~nixWZ zp%6FkCgTuljoCkkI=~~9LRSbk`S!PRHbH3KzjB35WNI(5o{1;pvQwlNCB(T@j-i-q zWbi8-^+wS`Rcc1$*!aiEwL>=$>L$4ov3>5O%7u6uHwzzFg2m_FU9J*E;7mYMQ&XyB z64C&+*|!gN-3;`mt@ea1vjnOuK@aUDF6T>P>`N^GPN9?fPVsh`jhYkev-sS?i!;B9 z8ZFse^HZBVUK@J_P^2TkezQ-0)!yx|cQ)A!NWl!E+9nj|-xo`rq*(j0}+var^{19~B zbMtxQ@(*u|FNh`xOcI>j&e;9FWIE#i{wRE6?P>z?XV%x2cRehHr`kx*j_;O&G9jBL zY&y;kK&fqB1ubDqM$ZO8+qx#MliQGJ>BjY#f*$x+GT?x-&}_OOo%`=U7a0A03;oX| z?rzNI@$>br)cc0+>+!O$ue^_$K}VVGuh$#viHS1Zo^_X95O5DF0m(3(N3SdU@h8HW zUXS&?v6;TE;Sw*mal99ROA5DnH=abMeE+!nA3bCLNdSxV9`78wUaT{o$T8#>>k%o< zRT~A2)fP6rr_#?HDi)w9B$*z_{oZ^8F8rH7oyv9tQ~M_L8|ztkka?x zR*b`cnK{?a+(j?Z=h-9s^syCz3|r-}VJ7)!G_1r{uZ}+tFAJ>w`%-eCqjp z&^Xkvj7`nCMIb_G<}$awIDB#2RFyJ_nl3J~i${r{!6Hh-x0~EBtyELO%n`}uMbRis zA|PbK@HGw?P{{ktC2jvW#e0@1e~v!HQ5OXgvUTlA1;X^km`O;F_q%InbfJ!cgo1-*OO_2 zoeU7mMXI;OUYSut#Z^YHX5pTZ!sczt5>>M~@hzPcX%{1S+N0fV!7?E+xI;7Hq!6tE zZr?(|kdtw&Dxu`5R2rLs3w#CQ$Zs@pl{9Jl#0NZ~wTvY+wcWx5+&OXg9HbPO$)ez_ zb^1|>k8d2)=v2n$%q(SdZj&W?R*QAoMsYd5X9~GhOuj08)Mw{^y4BR<`~D4J%h}hi z6eLy7_0~i=!Y>G*iZHkSunGLyRjEl*q@ho)$)8zoT`~IXKnEFKH2Veg;pNl{{Za_j!! z&XLa{KhX9P7fB$SGe4<$nUA)0^wP&qKraxN=pQq48Z?gyZ~_y9-~sx@$NfKVc^XdN-sgElZg ziIRY)XJjCS14-0N7L|>bBWdB|RVy*GHCZ7STu{P7*^wo)x5y1JWN#CDIM(9eT!>tNR78Gv;Gz?opoH5#Ne-Ymd%c5 zLyt~l9PJ7XmR_U<2C3*Fy;X(>!=Ie3L9M9-g#_EJAg7(J{*N&)kr@8o zFz@3PpT$!4_GIIY4Y5IJAwD;%IL|Td((xTMyi(bhJ}V#<>4a;h9~q<8v6jEsd+)|_ zvkDBP)U`D%_#@jKin?aRGo)VgLNj!;)`SvC^%p=Kem%1!?%ATocN=KyeaJ$djS_t~V+nei{v6b}=x~+W2xdNieBZsu06#Rof3nGQ zm(i%4Kfj#f?TgE8=sR-7@8o^^lk2l|(RXwC!oKu0+xJLU*!`-Rq)&_IGKhvC%CN`R z4*ue%+KjQ=oY<~P+Oy*Z2M3SV_x7x~k-RoB-E(af@HF1|I{gHRv{~SlgUY-LS&vYsY@S~o+dw`A zvc+mX24W36-bSmL4RFBvVt*Ga(s>NJgaZUgRCOeT60~}|Os^%`KM0xjXS-2&jlmxVBz;F$@;tA3 zm}+3I(4rm0aH0_!WS+joV>7#-Klv^+4gOJ1JvHehRsX)y)+IsCIpv!>wcVf1QKSBA z(g%ks#H)5}BSOF7WmqUXRIZ=E($5P@8hr*O)$jLkY8Qb_&P;}S{0B~SC&OY**xxwh zt$sK~t!w75WkLxx%9RJDwMZtk5`)xgfjG(|cOP*Gk2!fh=FX!eR?I4*#imdj5>$W; zWRB#Rv~rcs@@dnt5!a)=n8l{QIxL&~M2BWrM5{5!@+i_iV`D3@7?2-$G>(gi;2%`$ z$98zlk*5>0Q=`A9;w z{7oSC4jEd_z^DcIqw7!f+@V~#Y>rT}n=Q!+OCbOC6O-4PjbK@EVNRMR13FE=AMuP7 zItXc);r7wfq0bUuCr=QPT&nz0L7cAeCbn1gbIp0r6+`bt>|76O9p8%X!~ z1s9ycO-HE0e6ukzCRe^C&w=JUF&NKd7Y~OQt6LB&<2KTw?>;8x=kcMJw`~4Z{~1AX zB=e6WFX?WcvUvf88s%CnjITWDLxdjvWn5ee^n$-$*Mw4PES{KeZ$JFbQRUl&)1}fL z--TC>eqv(vN=0Djk&YgKb5FNzO;nHxn!-emfL^(cS~B=H$flK%$(VQB zB0dE^N(d)Om7yKP7Z{CIvS=Jc@9TzFyyAOWIh@IAFlSC1EB9;}B923jOY?I2Nf+tC z(d9}+6OFwmiP)3lC*!Ji0+`mvb;|>H-}r(}-)FH|s7kR*<;RmBeaez4gGjn8x*x(W z#()RTo@dhWDLZn>OsGx&3v<^*ojV(MdCM)yEJ`YG2QO%x=`GRyYlH*?ISyy z_HKM*A@yA@5b-*ETw(=JY`;MMp}K;{>dbeXX}@zI-`nXtTAX?T#&W6Jm-^k!(wY5& z9KEEQ`pQoNA|gf9LWRJB{qYX~)Xq{3W4mH}Z3Cyc=aR5SLCZyA z#T(}90s4~f%5AvC69Tann9IrXgv0_|2^re*xE3}^JQ`J;9cC%3<`LuOsOlffYccGw znhlsuIg(?cORO~~AtM)RW`AKw<5d3)dr+m+;>xg7t^qPS7W&;&0TtbsGp233yx7|G zY+P$1iN_rT9Z_Zx2$X711-YbqhyXmCX_W#}DbtafZr_QTM+c>`w2+2Sj^bs2cIvLR zQX#+poJWlP6}ihx#R!K?4r4>Q6vkIqizZ=ZuKgXdek0$(JYF9&Lz&5)os)ROmNRzI z{3O%$NqtdObsRAre#>ljxCU7^h4Om4V-L@Zst>|BdYD;cTf9Uu_*4GgH@-XKS0velo6*_p6mZgVa!X~4mZ&q{016Tm2M+V{~vD&f=wGPr%NL2n0kx8cPs=9=oivfG)=MN8Pc2b}X({Ex+mr={-FR88NgH))~0vE(a z)soF@Vhzbw#X-q(_gVS|mR$H3nhKPNSQ->HAH?I6_wm#%w-=Oq-x|@kRzD-V&o6uB zlEnjar7T+r9YDkG!c_DWC>Guc2>cs&RMCvK+EP&J7|DZr-^r=E2>{9M&%@O^RPqvu z#sWCPz13xjc|e~bK^C!Oi$r!Q7pl-IB`Zu1>M-GxCN@!3aScog!j)D6mWmagD$OqM z5Lj6&pCT!X8M8hloiuBv^pX4;(Neyuf5~bj{(@7a>%t}Dv9ZehJe*(%tl)(PT;G6` z%b4_q-;Y(_b5y}+m8qG$qCT1_q0}m+*E>Mdlsy0K>F(qt@G%VzXI zCSP!*f3G4_gU@WXXnObi(9$~v>Eq}N>EfbHPk$||A2%nw4gdbFX8ZLjE0x8)Hhxde z%SDGMCLrMGnbj=kVB4?xWO!QSaA)t1GJ@E&>-gmL+%TAz9~=|>!Z#g!bwj%Nr!V+m z^J#wb1-Q4C+4o@8dcK_U`YuO4(zOZh>fWw*_GxkXyy#|60{*->C7Lk&XE(r~sLge< zrtZ$?=!UvScs!_k@xNgtKpv6?`4`2!jga{xS@Q;B1Qu$HVWcIvr5u(@=c7jtEXbpV z=Zvs9vA=jqoM!x9JC7d4%v#g2v~+=Cx8MYF$$Iz8su{(HeA}M;aMVxyyCSUm5$5}h zq9+G`gcG;4%KYeoX3Xx$X$V?GKu9qFy3{v4`&y_3ui4fzRM?&KuYz2e9;6D?Jrqf4 z`ZPkz+Rr8oABXT{wao|)K&EVEL`RAvdcEPni&JWlPRqrUEZvTj;rtX_fGN~M8g|OX(=QVY{PLH%mF087Qnq-D`y%dZ%tpp+tT$@ePM|^xz zQ`=%`X*ga~bNGp>6iFP0zcpi%!l(v6&w4^Du z7pi_QtndM>s@ID<*QhzEu)O4=BggUysno5ednKboGRo5F6RQ@`pTeOAdx>poSe0ZR zs%_s7X04UQbEGn=2Pri~A#1ctMnASb|}zS}PG3N%qtFi|aUUYoRArWW}tW z-a)tfJ8vv0dtXyh$QW_RvAI0AfpJurrhnF|p$t+Q6|+;&SB&52V^xIX`TP!zVa0ec zm(hV=+eQVSw)~icp zH{vjWn_#32r|0q|(AE2;1|98z)WN*=bQiehvHswaN0YEG(893mZ?dEHsgf^-M1V|* z=PX=(@@dd>*InWlcn}=tTftWzTT=B{P?!e5MO9D321J#8m0vXh-K^a05LXH}4*q&2 zHxdn7ydN#IG}??*`{is;XN*egu+78#Ix03=8O`jWEh|n^K$W5y!#9)|AXFV?-hR1ru=`GDv%x!HCr0+q)6FK>{r!#<%*^lkaBDnCoVRTS z*@?P$2M>Nu@*QIB+Zp*1w0ZF=qWd7b zjR2i%E?=tco-Mo}j$mGi1W?2H%j73l5?={<6Tiipr7Gdv%1S3_WCYATDyM#LLMkRN z+>UL-+RamOI6|vA1VrFke(!jo7B@v#*u{VP2wA}-=0&((xAVxd?)42T8s`RfRVAv< z%-oYAnIzUPMy6e=w3I`Gjn8xMiAl?DIVi3{cfbHo|1XORD4(-x<3q}w3q#gSF;@o7 ze$M1)fx*EH3im~%IDhEwQR|)WTsnr7-$?=l@gxxTWI27zlKDa(nL~7XWNbMSF8U*5 zT+viW2N!PW3X({r_|(7glaXhM?1$mma>g|r6Hu}!-rP|g9v__Tem69>MrYF4I3c3| z5NZIpNGt1`%xuu)ahtn1epIuV3{YmyVt8gZ+3(t;t!(3jeoS1JktxQOi)kts>XY)r zI5@u<&79+66NV0SoKIz>6$r93H0V&_!y-g-w6+tEtwNNGTnVV} z9-F-BPskef5AU*#3&^d+X&G69bvMQISVEFAw49p_C3k_pK^YIVgoC)X*R&{~}I<)wr7=fHEpdK@2 z6dd-an|8NMp9d8j!m4610bpuH8;nz`+=5!!ho!3{gU_)=wDfuiRspNw#r;L>kz{^M z3z@cF)&wNP!`GQtuW(Nb2s&gb+%lKO@R1G@P0f-~u~l}<>nxQ$ zU-Oiw6L|%P?s(^~?GUU<8p$btS0JD-GyMUD4?ruBrRuckMaCBEO==S%KsM^qX>f6A z=}Ru+q_O>~`Ch30A4gaxf_U1uANVvs0lr1VPvI*ct5MqqBoc3SoPbc0&_rwAjoUVd z>`m`G_tuu2-Wfi%IRvEb4&QkPM->B#3zrW@z{l9HXHnpL_0TxddJJR^b2FI$Bllh1 zEMdM0L(`kqy}L~3_MCdbws*Zxg)f!UHxLOjR@(3~cVn8v=Re5u8GMogzRP-h-rFx! znCiRsY!u3iwbmYW9jj&CR%HdJ(hgqg;p&|{KIpBFq&j*-3|?B$!=0K_{fHvO%s8vQ z->rwl4hU1&UOH6#@7S?xFgm;JL93!mmaaiSI;-d8#|H&dpz1$MDO#00CAYA%z)&Ms zi9K`GiIDP*;V3>$M%^-hj9DKK@1XrE$Ckr4Rm;HK0T_?P|5X7={Wk{>M`#}U*Dhl` zd~3of%Q5`9_7q8ha*DxT631K(g;LuWm>{VTC_K=-<;~}zP_ZA|l(KL`N_Yu4?)x8< zlWk#9tRdaeZYW2lUjG+R;&!fR<#)!E7u5y*Z=fQFS+EiRYD zL)S@pEjADzY5oYKD~-q%@FU^G(1D;p>=Q<+Si7GK;Aw@UqnYc66S8!Ing-S#A-X&! z;kpT#;{l(?UyKgSn1G-UBQ49pha3u)JA$8w)M43^)wwWz7lv#nv>ptP?taADiIltlp|& z3Bgjk(6bE38M@+v$7AHmCAYvH_^L1&<6}t?(Yy^+@$g%nn2=J<=vM7#x#E2DU#``? zIYNa9s1mv|>qYi-l$34EWkq=f%%$n#ub&g=$Prnak`>oxN3*fjM-m6hX4sL;X@&W!23;q(F8j|SGR-) zR7-7md5LKLa=wpob!2iJy(gT_j(M7f2@?94l*u1PW@O)WyHDa zh84((uB?iV9&JdXMvRYSF6dFGwK{n8vj28eZUv{DU6&jDzwC?dJsZ=>{lbn{dSGikfXnI;IDf~$le%P1iRktc3KYNx9|J6xg6E%tg*k} zF@k@clb&yfUA%p{em;PAqR<_E(-T}WaVNRxzRiz{AZF+F8y?J7T`pXN#_!uP7kPak zRWNBl;y3X>vTr|CW$~X|;#-AXf|T#Cz6IBu)sH;gYh7&XWtg5^%|RZyf6kjvEhIGj zM-D*zhRc)b%^&?2?RajFf=;D>QrOJz-qh;4yj_@*OK=+SztkW()++yfi7trDUaZn$ zwo~MBYMb!2aop+k$0zv2obp*SSp#oT5-*maD3{21gd#m10Q+&|%)CM?_K8A$uk;hg z4;_+9N-P*?%4~|t{0>6-tFItb2T?IpD(gd=8Fs>P>&rBxf)C<*lrR*M&uAJ7Ii#mu zVNcY6o(CO*90F^z8kuG8rVNtSJb|e}sSJ2LFU?v$OC+q8nn4!8_ZldtzdM=5dgH}t zuzFsZVzC&G=^iT7c1KK~4QM!+m5ePcnc_&Fw9vWb(&zRf=X~?%LLA!|;b9u^ebei6BvMOm5aOF-s24%8c zrWj*|T$mX;9$42wYFRvVvDk(Lnd+P}wZ@Ay=xL`Jrv%)8>bve?;0I@wX~(!%bS7q& z>CbX`Qb%XPbpJ}U(ZW~i!q2!3xs4f+QfeE0T+S^rAlrt`~Fm1`eE2KymZXUNPRn`D1i4fjUUL)oW9X#uxU~onpXaZRxHx6$EXnX@xEh5i*&%>dqZnlA6fnbi za(Ku4-dEb_SSKmvDMIOJ-zIUdm-EpQydnz0VWu|bT9tyEd;NmwZYN951Cy4QoytPa zLp{7Yj#7Yc4V5WcjAnbZDhqy8*ASt|kmKjf$HOW!o;<)`L-}IID{X*^FD4{IeI* zlXu}?oJZIaWSOOsApI)fi=c0e;QjHkHDmY-sl|oDcAvK^|Mx8L<0<}fr-gk=>t1u> zbkGhk;PEXuyW4a9Y{?DuyN$%_@8f;`rn#lV-bl^cVP7CX^jS3615(DH^kiIGNxlCs zBg@-+mLS?}nwm?)f6@(1;ea$rJiopGKOcggrH-5Z7Y`NxEX^N}81@J!{l6HA;|*Og zlOH(iIeK`1)`Q~Dlj(KqsSwuqgv838JcQy#GiI~^6=&>ivOlZEoajoppw2_(mm*`e ztpgN8ye39mzDs>;Vl%Wj97Gd1gF|OJ-%ZO;wT${$Gv&6^S$vF?8!1D`nqd9}6{<0C zXM8-t(rS|F1e*RMmyE+A4?CM7>2U zgSakvy6!SBcTyVg?|0(Un#sR9sQNQ{K0nP)T3x+1fthR{%YVb=>&M7lVR8eWL(raz zaXz)8YHa8ZbIpIp!Pmwiw*uhJGo7Dsv{*#Tu*tqfiClkS+CaGc#2`4mrtrm|Pa;C? z`cgRLSwn1tNv$D`UgZEGS0tPvmSTH{%onqQ(IO5iU6LE=*M}o_%RIJU^<5svEQVgF z9Bo}nrN@+XSRYg2O!nA>`gTUIIKeN$>b0ypt0W~eBP|9nA#sO-d=1LJJY!A@V?FrN zi1L+O=B9~!2TrXgkZvuen8`Rsdd<+4F2EiiL1xMVqbpIyvNfmI4Tf~gmoJB$4AJL~ zi2OW1UP4Bj`+GKzk^X6a5=JA4n`ja7`V3JJBkuoco%p{$b80H%3QXyQr*c~1H=)KeeMl!alZq;&BLg7(e4D$AHU<+=BZ8VAMlW7#o z;$1I8q@`#Fn015Ur<+r8n2bS?90}Hv4kCc;7E=m97OP_0j$GgP? zE0B*AQ6+D!R(dQ^y1%PWB%vb1&4FU(ey~OErv9yDOv+uP>ms*QSZH{LpLO3~G>>Ap z(ZvAr!kTmYWDQ4MhejH=SVbXnKGNbLUYmW80UFsI`Ss}HP5=7Zo8`sPsq?*JfFeP# z@?32G2kFNXlFZ)JlZFl!e()yH+kKkk;j*(ZIPm&;UiY06UkDsZT6?2Q`pPKs=3VHk zWtXn|K3UriE_lJ-9%(yoXOS1aEgg|W7fEYp9#a9d$h&zEHL6m@d4(H~LQ; zulGFrC+bW7XTIS7F#4?b1ldqR)`~K!w$>Bnc)ugUX6}cf)i9Y^O2NUkd@tqcfFhKN zT7j1s6f?J^8=A=q|4}ykwbN1ycM<1nxUrYxiqyQL+n0*ThI!r{F6IiGOg^h6vXEmo z9xkOHBpNf#AS?o$S~#IpGMw!!g|faEAVpfQ zwMHt}t*S+SB-j$D6sslg1*phI#3Dl=cWa(7cG$>Yk6EARTyLD8xH$OR>CJ}mQ|*I? zKYI`7gOj6jU(g|BvG_xH=cZ}!^hFoG<~1q>t4tN#0v?Pxb^qE8Vj!VBGA0d{?gqhp z9(}Wm*1+e{M=yy=PBBba>**ty0=ascrl-!K+if@?(5k^`*(|6v=AyiyT)@zfB*j3Y zqf7&Hg6rUL<*%_>_km5gc41TzD}@%!DyL$2Mp)Ikx<>8knf@c-8~^ue9b z>zh|pyYiXKs?3%WLYw6ALci#KJ_vQ@(=qA-O({_#zZ+P^r!7!X?8c<#yUgq(oy;nW z%DFzE&UI(26JyHCd)a+tSFWcQWB8jTn48{ZDCg13ym!CA5-}Cj32Kq&L&k4W5 zJ12S9Yul&t`wKGZdwQTRemC`AyQT~M^VPk?7Wav@&W{}ijP`tlHN##H!Q5a_n=!<~ zzn9eW*kTsj`s4pneIYPmGF_%qGn-}4k>y~W&DCj~)MJv_$$GW*@nLI({C5Y9L=Jrh zrWuzQ3N>VeleWmj=vuK>;#VzDdq0aAOs5fT|4>Un4K9>qHVwjj-se=NkMML^Uh$vO zVnSi$dn2i+Mio#e8h50vGpKcOpoKsqH=Z@COjf1CgGXDkyfa!*qIm3I%>+JHSWC(5 zep`1!=Ij>l>HbEipZ1+ZsWy~g{bP+3UH7k1ed)ME$UqIdo)|h5Oi%cclOl(LEycdz zf-4_dpb}=Z{7yI}J=kIJk5W7tck=*^`tnx7X4lWvliHR3IxUzIdJcI= z+psg{=sBhh9urcF26+l}#)Umay12?fl1iG@2CDZ1p9#y&F&_oSK2xG~l#bsp;%`^q zGNG+8f7A;6Pf9%I1@AYgQ}7f?o57-u4?km^tXJ(L)|!gF|kahV8f-?%R}+-x;G z^?q&SdrWcu8!HNPIM9gUw)bC$Uf)aDW-rXejqrGz$qQaK?z9Oxj&K0$@VPV-Nr41Y z%yKEayu)@9?r?^j{KD0*kukB|efVV)Yj|@eK1!dbiI(k*#IPC145E>oef5l?(;s=4S~OxyE}Hy85KGrnUb{O-w`BzCWswkcyY#gAslK?JNYNW zXJp{QrZl)35d`lqf6-I8|5}^G5$r*;F#LJTOw_4Z8c6)>B&!rb znmQB?7TSTvjy74-h;5yZUlI1m>PCuzP(tCBKlAg%2gIzyYNDJ^T=8OoF? zhm#&5TVYEK={+~y23&KTO!uht0c8}!pg5*c9OJFid(NZvR1i*+msR=fQ667N`J}j- z96@rx9Qj5P=C^H+mMv0`GwE>4?#B%!0EpCu0EA#hof}syT=4maKhsVGzOz0v?8@gT?-Ci-Laloy4Ts8nd73O#@3=Ts zH&TQ!(8>2bKol-d6R(mYH&-XmK3JT;_E zcd-$!4zcGm`{SJcOe(xBD8$B~3ie&h7w$m~1xgZY8&3z(K@UgbPgLsVwxgpZqvaEU ziTU=xHtt`mY-E?Fz;;G|#0k;GPQy-MQS2j>u z2wQe z+M%U6qxf2~ONHd5tAu~ALI-ZkQ$JD)nTqqrWAGrq}--u zR?0KMs{caAdX`Kb@^`{2=!%d!1W7olo`puQeO`;xai(b6lsfm?_N#=ysh@stP8%+t~>tniassM+G&v*fsB4U zBd!+$VA>)ovwD(6y&zXI%bidM%Uqsvd2KsFG$4I!c@mA;Hl2aGC(kNa+0jo^H)bI= zQ%ZV)YnAp`=xLc!sM95SHX`%qsf8R*uHomUI>gK_k&I%F@6g|^N&0yE6KDx)hUJ^5 zH$}J=ZI<>InepwLe~*_Y0RwG)bcc%2%!Lj!l6MVP#6_-d3!B_L_BZ860j)R3agEor z7d`ZKa*YEcXr;DxG=Jn8wdk${3*Q|xl9+4?3xf}Q-v>xvyG)r2V^xTL3p93L+GS`{ z_Po0tBm}ihqYFKS>3b#KD!_gkQ6-&*p|Z{Yp3s*Epk#iS0H3hlOoI=>yS3A<(;pu! zcapR$-A|*WAC~|AA9N{r8n7`gs3tL@f_}o0%sA?bbpSF64l<2jwR&UIL&Q~RkU~z^RP~I zpAibaF)?z1a21qe=4~pna@h&Im3g`>SnBSpV+Aykp<)aMPT@|yA|Z=C#hGq?u2?aR zSOw`++BdlGK1Uaml#Vi-*~N&9?j5N*x?EV?D6z&Gt^ak~(Sn_ZW&f6M4;7V(uAa?{ zIheIwFjfF+#xX}FJ!2R7&lV^p^b;S|Ck|8x9@OI8KiP`aG-ycHy^MICkyLebSI1G8hf zv82R*4??SdD6qkPMx&N2R?i+vf`*|_pr(gWuhDKwwm@aaWly#iSwzH2rDLN{x6bAx zm*DGX3ougsiRgf_bGj8r!Bd@K81Dy~9KRt@&lYZ;$N; zCf}~`LDD49%2bRWZ~H>acVBhs?}aC336)?s&Y)QarcSr*f&{U+eZ?5%g~)GjAs13! z9aEb?`}CYoGYG;a8(6-MY&0%d3!Nc(qdqXnay|udOqJdWK3`2NgF453{KHDoSvXlp zt?s&m{|f~+rAM#EY(xMtOd=09g@-o5J2pV}0JAe+4@qz*>XALC!&;4d?axKU+SfHz zuu;bLj(ua)<`o-wukVeO-y8f}X{fD%*Ca43>8&Tp)go}W(ZNsj!Ssz7JUjimpnCxB zd-L=5&rEt70rRs8Kg=yHK5dXbVvs(?kZ#ik|E29?p&Y4~2!8Dfo(z6aeSc|;m2!G} zUmmjvIPH5UPz^d%24xuP`V}4)ymN?NJp@zu--r2~@q&e`-n#FM;9Yx2JSKbZpYHv8 zajsGVN=*k9ueWtC-vS9%Gq7ARYE>9va8XrPYQH7BS%qa&8>g-V;&}iZX(!$zj2{wty-zw-xK2M zoKg7w{4&&B_&nMnn{K}+&_^bY>;!~uh*{Qxwl^$ne9o?=Y2J*F4N#BSGnj$T`%sFq zhIv6%A!n-&_5MbE&0#rT^Y}Drqm{<}awGm=E%{^Xn4ZrZ#aB)J!Gwhpb*X9{mFr@w zYw`6R46MwYRfGy9-PPu9@DTWpKS69LG&Zxk6~XFN#Y|1i&#N44EQV#iU|_e1#V*V( zNn!upPMapx^RMog0m8yhX>*DL{j zDkXxBv*jl*^V@%S@FEojhSG(q*UWsKR(LJa-ck8UaOt5lyKJj_@o!(eNYN)}IuM!T%?t)!|dXM8R&$z~skT(@t5ZL_MU?f3-}A#})J?mI7nrVlCD0M4(-=9*iX=pg|=;(n??0>i%p z@_EQ#tKK}&Z5trfSAS$KMo9OVWE#w4P@z|;43^H7B#H78LAGGlE;;9KjSPOt6!Qf) z?D-W530ftrys9XMCCuiSH(RV(*$iiEW>iUbpgFr1;`A9dGEy{>y5%g-xfy6}3hj}& zVe*Ru|Ecfi%sTF`#HB`=7@^-7Zf=dD9=K|Va|zk+xh5MFZFY+2MKnFr6)6GDgzipe z+4usi*l~eX@89M1g7Wn zXXhA?Dj6}9xNZm%p;R&1!dEY(9Z@5ngVWaSa|5oAY_f6-spX9-@M=(^pfZkJdz>-( zSR!k7J3jZ4T3$gqsqO7di!(e_gje?#)MJXBDG=QG*4g)w4eN5)4Lc=H3AJ*l;|Ghl zwSTcuHEb+Psn_ZaKncE)N1c$1-l?VfSSK!LZQro^dTXQ9L?6B`zA@k$8VLnoSu43& z#SBTt1@BhiMUtQBE_HZpV}+2qye_yV5{q7I$EEf)mdze(Ab7bDW3vs_Y5|rmQ>86qgc_$ zda&S$MEi}Fb+Dw@BZXy!Hl+v6%2Ny%f-85oZMJ!1Pu|<7A8E)KW zFKL)ARw$n=7`hs%4ra|DEkZ;+UPP*ZHw2wTw@k-({xlE%`Kgw2vQ+j;DoX9|RxWBq z4JxDoMBUihY(uu>*WxEAV|%$;sx59Rr`x+z7iCU4Ik+yl*>4Swei;e;pWya#xCMs=R|#5ymjTQT2^*W!Kl!oLgN4=&1(P+g@*HB zl!`7r_v*63FQr|&z8AN{hFEdjt2{yfK7qeIAjnObc`>YO3!wbIc~cJIh@X-mcjdos z$bZ=4pNsb`T?GE?ZM}scWK6ywrx>aX^+l~w_KDkD=#nZdSg6pfOZdLKPx>dqhUo36Tmzilpm zH(CtwrS_P^THCL9Lw*KfcQ}`fwUx<{@A)Wx2?VWs^c}imW{vW~BK=>W>f-G$7Ph?v z@cXyo7%A~^R@leHge>bXi_qOQdre#+<+Dy*~U%TRLEk$&?6NxJM3CinpDMjNEy>Mg{(DEo%b+|ayD5uMr2o& z^+$T!8LsiPg@vFtCF%VAonu@N`l7j^TMl z*nU~-0~RloL|nXRE4U@bfg+CP}J+_>lVXj6kUv>_^y+Oa&>4hAp-*3 zs<5sHB_jF<2e474I(~(clV?hYMi7b^8V~LeBsh(`Yvb;OK!D)x?oM#`Kr)^4z4G47 zeBOQc&HS?efbPB4s;X7H7AhU7UIf3JMF@V_K1o0Mfn;)twlTvLT~y<$V?3mZ8A>>1 z3!>>oO?97t=eA0SiSsqT>y4oG4b%2L z^8A;ax6Nz7XAehUT;i<8UIUeD2m(3JbhxF{&XfH77il?v9ZyhqYAaP1rPQ@ z!{fl=l5#k224OLfyQO6#fSiv?ZU?gbI|qGRnX=ciQA}W_`m`eJB>Fe_1ahVpU0yTI zfEWoJ+}F4g1Y9NoG-!OCs`ka^&o)cIA$8s2PPv3e_o&aY)V;y^;sk|m- z`hK8fR(4CA7N%B8dhUBko{STBM)1_wPm*#O2ToH+jg;l5AZ*b`Q49U5Q59eeo!Q@- zdfgsXCppH?-Iln)aW0lBW`%sNQnm|y*uE4iKontaLy7nzkg|D``uLMDsp=#*rq zLoMbx!Ixh&LYR2cY_0j`qD6ByLF^HeGxhbs`PNpU5}Qw&!#rk9V1mfrL%lHm-lnj$ z9T6B)o~F%*gSk;7X^rU0SZl#9?$b@iUz;8cW$$>6d+&lyG-Yi71uUFg8s-Qd;FAH@ zSr5y-RtM44?A7o@{+{kDU(f<079EUzx9oVV3~m^~o>^)Spq5pFnP|sOG2ALdiyLh|eZX&L*xH^3=`40M2jKE7 zEw6y(K>Pbz%r>YP@yC>r5gZ|HLeXx%#3M=&Q)66b6h4U4;cwXH)%Yi!(x}#O#NY@S zGkS{hq*7Kkj-QKqGV4U!>w@FEOr6);NILU6Q#|qd1>I)5TLM(rxrY1Hzjv`+tS!G& zSHIwL-6E;_TO=xI6eTS$xdN#~e50;w+J|1DGp1)|6!RTkmd)`k-g!S?B>v!UbWK=H zoC;4@lFa$^GHgf~#Jnxwap&hY`RU8X^L^g^7hQ)(8LQ48if~TOM+L7UYQKMKr|bTD zOQ&+ zzV#EtzViG-CYH(3qaK%4vtns^MB0-*8chU30+1%c3?Y^sjVm=42*s6t^YeGH5r9y? zP=GdA=^L#N+*cbRpdKKL^T3~znOztT2^g|c>Rc%iI{>`NV@8c&&bKm;Q#`PNs+Yx7 z&R=$Cn&L`?UsB{opR$&plFgL|h)~sY^9@XQW8{3~B6F`B<1kn5xvh+nE4ia24P81 zt!dE(8!h#jY5gXdGW9NsXxv}|YC<)2H6BW>85H42HGgz9JnJvSlee5PJ6oTOQY0YU zRB8^hUPoNHY+SXHg#udk;nSDT1)yV2>s(e&Q>1Of@i zKPOon{zdh&dB3g&6x<+k{$vB6K6jf&jo$cwaPk-Q1<66Dwm31}(?6^l0spc8%YVhH zZ(`Z<6fsS^ARdePHnUdR_yiK)8|@ICunZSC)+iH7mA`6sISuqqVbyOVL^3&({UpJI z;mG)wcU#Ly~78b8bsTDG|w;WM$to>06LH3S3W6K7{ZA+kKg+$r7ID6T4l*@m!6?tJl!_DShu9M zJQyAP*c`L>-ToX6T>*2f%+ao4B)STd3>|HR(ZUe{b>SX08`s@3z%z}V>h6Lwat%>! zo<@b$%hzCI=K)F|Gl3e+=gnQgNi%IV>$Q2wh)Ne(u}+m5%D{DNo%6GsA(hQ=|3PG= zvfVwJT}2L@J`gi{wIlZI_iHcLKQ!h`UmaJN*H$8*)dF)8HWbl59S^l*&-r}VNddj# zAwg~f{op-T7(px-7i&_fq(iMjJM8lD2lD^P{Aq)en_gtGz`SHf19a)|NrKmEQ)PGt(7UKsXRRozHTAD;~-htP~z+9)dD6^EV%tb76O^W-x9aF2JR?x4xzBYXCE< zrYq(KcD#8=1g(WB?%O2PV6<}mA_HsnYNf3Z97L=@lI^gv+wkymg%f*^#kIBl92ZO7 zEbFOL`)dc$>yktD9ENUQ`z=Y@Tu;}$w~e&TC{g|LbU~{l+r}+ zZ5HS_1Q-ra8f)N*1TiD#D3Y`&RdR$Qs3p96lgjxw{C*n!MUd_M_}Bz){HDJ9vUN98 zvA)B*DrH(!vJOj=bYHMu@tP4>dk)kfyUCxv*cU4aTG@WSwhoQf9K0-2dfqMpuVYVX zMcXKkKSSs_c4Zv700YK8PqEPLqeJ?Es8evXBPkVc#1XD(e!M06-J>#Y2GD zg)ic%p-fK&5R#pKfOAjHHz|_(Yn=opg5(|a!!*9sp1nnQzyDZ-pR9gE)>OdcLm~CNA$SUDFTsl)$}MAMfuY(Ecfy%uS2|C93QM2z5vV}bA&{Vf(D_zuaJmzNLqRc?A2!>I+O6i1qkDlLn(X!u|9 zN}QQ-z!-arUAewjfnbW_d6u$v)FgScN8nI^`l(gl5O4~ zTl?8x1;W@i_-fNrvz!U)Lpdx8!e#=)CprYulHm}U9@+@z8R}Kx>^ucj;f z`x8U(jAp8KZ6B2p1%QFb>1105fMF7F+J2nGGJrEBu6*E71!uh`c+8DI=(6$yno4Mu z83yH3hqqqK+yz?^d?@={KcihM`OO>L;@!z=N=VHL{e|1N!9I#uD|$T3Vk(#rmDAUs z!u6E}3x-)AQbR?h+t^$z3?z8WjZW;GdK%$7%NC8Kx!16C*3bpBR`N+cDVZ0;Q73G9 z0yRxc`2^HJjs`9*Z7Nalj^<}42$V4ijb)pBu>iACCRs#dGkVSt?zU`UYMP7%-Ync7 zbXs$r>4(>k2U$*B0H~kNPL?(f+WT8)c1~vXfO>ndpPcbFTkc&sQE&9Lmg9$$RtuR~ zD(&qqw?h^@7j|YwoAzr%yg)jeG9Ksu2Q1nHPNV&P5&I`9w2waWOJN`lg3 zjT~Br5yBfnx6(oN*Al7qN;Iahd@`OJXVekWL@-+f6CeUL!g=NnsC@6_3n5gCkfUHZ zeh=z%<+ZP67YaFzxok(7P_9ywNw4p7^EqnDBvsUux3uuf`DK;r=O61{6-vU`8yH+k zGMF%YGRqBdiLzE@A9K31ji9mAW-r^5&)Dbk#nMyo)iwY2eWE_njED=S&@LcVG~Mko zrgV`%Y>t>UiXam=!dvYOo({W+jjFxfc5><)AB^PcQKkLMO(GRK_ z#be}v92#h!rK|pyXIPi3X*`_8W5jnU)Dyt@BY}$St*E!r&}|TdpS z$i=Bk-_kxLdwe&7xf#$CiO_xETs7myVxMKu7HdLq=l8kEj&*qiygj;KPNHx*O?&Cv|T1I}j>$(EO_*q`VCBeW2QKnrqV zPLG)EDL1ye8q4k2fpH3pfex90Z=(ifDgw&6PtJp00{#7#7R#n;LcM6R?9sFZ(TGJa zByT%@;kBQNzMKil6XYLyGwh<^XDYlVQW2GN>ECPL6CfJnu~}y>XU0jjtR-*A>fElk zXTE6?d~2|7apX!W;TGO(TAjPGBb4hyeeQLFVI8xk!oDBcB-O`fb#BWcLhU%Garl~u z(UJf`*`pfEy<{t(Nx#lC&3gU zh6sc0?@~&q>WJwy_$+e0989nTR4$CFV3?MC?<@;<*E>yaX(@F&0@~jDS10U*3Q2M< zK7(a^R*xv^-eL~KBkK%ubj*7U*O4P~_5D`DbTJ5;@)A{i#Y6w@1yK5#q&^B(n8QQN zS0q?Q$(P0Z>6st>!>hN<9BR3ZjD`O($sE59L@xE#r1a1iF$J44Uz6Eo>+12urCq(x zg#xT6t<95h%Uce#Z04$GE+}ITIJQh-zLg;~T;Nob-=|Jo9*Q&jUF0LIe6PpGSITFB z^O|sjPXn1O98B>kQ_Wwz>Ff8CZnS!vJR7pRmWlOo2LH>x3CoHPyx!3KLq`bTsIBGE z9NxUu;OZ*DUU^_u&hW6vPY2O>$@p8^c6C~4+SG;SDDBnvpPfId>82i=<5o1_RrLk= z9yXWxFR0f-^xuMdHE05US13Esu_UMPuFxURX-3=9#$p~N%fx0M1g%Q;tG66?VOB>N zHqK~J(Vbnv2r@iIwqKr@4xd8577Sd{ze1p_Bd8T>6+Z|hP~p%p2J2vPP#Anz(C<@b z^}$Tc@D7x42wywKeT{UVEz;l5LK%9(+2$CiM#K3f0jKxSt1R5K4wL`OvDmx-uy|2{T2Dp!6Y-i?h27qk0e)l8a|;28$^H^-%{My@B7Ux z-Hmy5}9hpuY0fmnznp(oQMM90HG@S|bI2xe4qpZYaZSOp7k4|m~&a-3~d@%OM`C?!`W zqVPknubfG5{~40ma>-c}0ws*(wswhLX?RioYDcreiq;xvA&mnocy z`}!#ORbxQ^J5J_O?`RraCLKkfN$`&n1ibk2d^|)p`~?ZQq|tqPnB*WuE7eq~{*62D z((1aoANb8B23B_Dp?LB{9&VW4$!Jh1;7B)P#5K>?ejk7*wzlab>xXkk#{ zw_vCG&_)$%@@@{ZmkDN6!^!t$u&L=-4+(E=lIbJ8&qNsaPFT6xJf^|Q5U1U2c@v0y zAWv+tmwYcG0#?Y#mIT6=_vWMvmolZ5Apir_3Jk1G4|saPbSRaeAbA3B*ESuL_VDzt z_}nGLlTpqL3YVuGL1(F<6o#3C@{;_K1T-lYuH**f?qtXEXSO0PjPr_Yl?zH~3%WLP428aw- z(GC)}XwO%)aW(F^i$h_?|2+ONcd7jxm-%BAKBUf)Ea>9aqO(lqdoh$8r;Fskrq(Oo zPWC$O=fU%hBBe(RQ10P}gP1&OeT-mS*eq>~v1Dv)-XLaHZ$3z5a4W>)vVXY-?)sxG zqdnq?egFa(KlJz!@;EVBGswG=6wK0Lv4*a(HMpQNLFN5%wq;Ngr`QH2Ky;*Ztv2-> z-ZA{uJFfV)$A~ualF|ROn zPvw7m%BiP^JmRM_TKca-I1h0{{#IlDj?z7<-ggP0SO7%PAxcXmfhEOgE`)n^``L%V zPI0I}48sELG7CD);IxX0)Y?jpoE?iLF^sjmF1L;3W;PkyHf@ZkXCZsBx>f=XZYd+WglFani3OI!+ zY*_M}IK6C6NuoijB;NcvQY89OC!*F^u{K3x!&eCFW^$Ikl+uYfai~E+e9=NZQBCP0 zHHS?`c?+?`hPzCcJ-9LsIXrmz@~zoK_9+kVvJTWU6BRq z0=lJ$M?iOEAWV<&)xUchHhLn-b4_hp`t;ml_;$$_$hfTH<%=jdSaP})P6Kvuljbi- z0c3`F#{}x^vZY2nPKl!oI!ZPV&SCM%lWis(TDh{5fY1fjD0Qgk_B5K$?4UW`gJ#S; zX{?C0Yv!KxD=~~ix6De1n9132Bbuuh>Ib0~o$AXl|I2~k2GIwkDl62NNf2>O`*8dt z{)u5E>4`zlb-!m$q8{DH3~{gG;Mvk^jdRbeb75K>L@KAW4{p4*f~f~LcE55>NM&oS zgO#g|FVj91s&o1!y>F{9eJ3saV|={^%lrH;^EcJaFQQ}C{~F-= zyd!MF7DVXZMQ17x#vih^AJBVJnrMy#{#}PK6L~(;dSS}2E61t@4(3LewebQJrVFSG zAg{vf5bNok22T7dF|fzYtFu2U)CV|T{O_qyC8Ezb1=&B;c!E-REZA`cJZ{)i!&Y1! zT&F6+)b>+KlL@&^i;32I_74c3>q0=7>|@O8RnYHgbK?Wn+WXe%C8+akF0S_iM*~#m zZ9Zb;nf~2n>w-qQ`+I;A+zQ4r%~v)-imNli(b{_Z%C|GF36W9#=$=NOE#)Xrx)2?eo`%=d{`}=N{Z*JJ%f$AT=lbRYAOj$L!JRax8 z?US$Rm?_9}F!I_eV$^JRGb)sO?Iw=Y=l`oJbuFPaD|&#UnQaM8L`lMH_e+TP8sX+J zjMdfV_ud!LBQ|p3@{%%mA*bGcpGFl*K9(sDhT;SzRy z%3fv38i;-Rc63&&c1|-8hBEdVCI=&Lmy!Ock&r=i$PaiebcXYYdfhFxm@S&hHx5uv zF5~`qBa5>_ODNTMgbDqIBCU}o%1VnST3&H2H@mlXjnFpKo}~I>MYQ8}JNNd&^q#)j z&VgeIjpQ`OdQ5f7h+hE~St;@xG&fD>*0(u&iMK9i$(jD40=3A32j6xSGzzJyxon{J zjgvyxxM9n-+&SW{_DmBo-YYr_p0S*`q};fFabLkit*l;St1)*C1Ts`Gv@Cp^7H0g<4(%V;+OdcKMO#4# z#RdrcW$<#msH99=I{Z~QKBAiVTb7eEencb5p-Ge;M7@N|z`x#JSo7E{4Sn7k1Zx9_ z2}xI?r$)TBwUhBo#d_;}&Gfq2xj}s5DR|&FZhu{>X+`tnk=&h*5`neM`tix7$+Fgf~f8RR0u zffWa>5loT6P}zz#hKrq1m<$2W(<^*=0xnPikju~HlVxzVP8|icSb44Il`StJ+%(I` zNh|BU_H@7T3k0tS2luYkerLD@8NErYOgztwY>P$kQ=;SVH}I|4#mf2e>$;&ZE4cjl zFW=bz-8^Qh^+VJ%bjTeno_p$q-Na0*>52p)eS_uI?da*c$6<6-b-9FIv*`vPIv0~I zBI963R+^aOxCv|Ve0nNldvKPs;MB0uB75o4 zg(BB(>n7KNzcT#&}- zLVq5N6_em!G{4rEI9wRC=%VsHr?;Lo(XLt=yReLspy z%g&IkXiCoz8eY6Tur=Iy9w)Y*nEkFRF`FS57{Mfi5fo=(onh|~|UO`|OK)OZ6Nt<^jHY%xCym}trn{D3&2PVP415wFPR zxHW=@Mm0$Xpd?WS$rMeJeJv{YuY=ems%{RDV9Q4XE1d`7*-|wX3 z!0JPi6fGp7f#fJH_Mh{alcF>qXmCT=U~x1N3i^0@gms`yZNngN*R5$c&Gv80^RXb{ z*R!6{w-c@B9TQ*KiIIXx9sk0ik&}dh(O~Axu5njKSR=4*6R45Ud__-}?tp&VubwuO zPkf-NZ^wpqy5t{+rqyB6aY+*K2&i%V;SeO3i5m`I54Sa0?Huy-IS~@YLLPACepBi2SB$0C$WR1_h_ zjfeV_n<<8G!0O<$w?vbz5T|dhbKv=t6OT@|<^AxlBqH?qmo1RZ<2a&sdt94NmNYo# zlXOSt(dn%Z5jp-=zYfS2vC|Q;JDG@FXzKwQo$dG>Jct{U%OtXjc$c%{{|qIt6H5pw zs~65dzpErOhw1|ZHH^1@Bx24tdw81Lq-3XcTH@0(o0mH9I_}WZsihj+@Sp0VH_+1_ zeko-lef#%c2xcdfo1j*xHvvrt%;7&BN#7?N!+8v{uz2sQ6ORQKh zV)W&fZ<>=FHiznZX$nYIsOM`}$K{aHCPzS8i3YGlzuSBai`R`fVmX%FB{@^ny{V2x zx$%Bkku}7J*C0Ddd(KkO3M!|axUrfNq4pG^{n4$_!(*%nj6c85ySb~)da z&yihvB97cxaZ?azNvau|I`PC&j>be<2SWY?rxz+nBtd1W2vNv}z=(S4WsRW5QZysv ziObhGP&tr7gZ1ZQoVkKU?XY-B3T)(&J4caBPvL-_MWzHLO&tzFO51_1TQhEDS+#F@ z2F%%ox<{WY6O|50WLUxrP24CP4W7#hrBT(>3pp>vB`^0-MqI-W;>F|G1!dw|d+$aB zjA-1BtrJ!%kjjticftUz&?hUzjr`1oS-rj`Nl_HU zXT*zdGmSKXtO!=Q3*i_)TQOXMqpGsWgtU-{ZU_4S2VAk|5fsK4u;2%~o6Z;aPF7cx zc)%*FxxWH>Jj9I=14Zy~E%1v&Q~@;hhj8Qmvg+={{ed9>TFK~~6q@kKhn z32u+vCS@iIej)p~p13Faydc;xMB>T26dhc+HObVot4PlCJKk~ZzkT-CjNppO_7OX+ z;z`Nmo#?zpa~tTLHYlbVcCqpy+F=Hw?I;Z+sh0&a>cP{ynBLD$0}MQU!@S#r&b%n( zWthC#_`WEbp?QhAb9SqWi1aLXlWpkBUzfaP-Qiwo#K(g#9=3xsVMUGdqRl;h3vTm! z%C*~#r^3jLmT7SiB}FHDqjnjM$f;?wlkiZ%9EP01&CPeq>%9%jUF-Tq>cH}T64D_x zwE`sty>enA_+PV{T65pM>w$ue&}UeVMIApSGMM~UHd@2Y4rcC|nzim$c=1IYpir3-?M%Xnp)9+hOLyj9I%CUT_;h)Yh;u~R6;1d`5} zv2x9HI|h~aQ^EZlo!~0#?s^iD!|FQu8El>{!07Gn8KDkt{Ekuld5!lck=(w1aLXkj zIyt;b0vwC_`c?S-Od*UEVzkb|JB$k0d;#r0?x;l!ASE~^mEU?Se!WoS2t-|uiNSnd z&_2#!H}LX?h=>NwXi8MX4^`qt3h>(pa=1hoz{a9a@fymwH`v%9pU^@fw0))&&|Nw0 z4^EjbSS$ryK-UlB%ZG++yo_lJVXpqwfS^So z2A)$g%&=&TvG-&|RKB(> z`9d7?&AbAhPk)8=W1A2cJMt>%z8AWmqe@zwAU*r3)p=jNaJ=Dne!hM?e|~y$f9HD_ z=2yaao_%_ndh^L&`e$h3_s9LIt&>I3`=k8cIp1nEO-7V&%6W{xNiYQ`+xsr(ZygZd zC_V!z%ZX5X5qMzgAgw?v+!=T_6f?IzgL02#0uKzzKb8{0Jk(Mxy}~(Fpk_ORW)=;W zl%4~UVMc-_iy;qFe8P0`K*|E;Sz;z2@=CnbY{o%(C~&9|6WuT#K|oT6P)Te~0VG+p zP7^;J4(1l5B-cv56i#+;+p#pD%?_XB(6?#@1Iu?>@gnGUS~%-ZkbJMr@kVU6^WCMf zPH08}If``EbVGvgSF{qKz}DiKGwwi_2Nh^Fe@luokgSg#qjA%KHv$ip&go$|{5Wm5 zLEb>;u=rg(!NoF|j=8FtRF2B8({@EhS~AfW^_6}V8}bORJUl=VhIZ+h6@DgrQHo@( zaidEit)*s;U$9iT)*OUFowG|j^npa>BE$UA6siP{g+;e#>-XhWtc6qLiO_%hQRi>jZ`6XGL*Om!`o{j#!to;r9MeYsJ3AJiE^L!HM!aQOau?-a zlLa*%Kq02)-GX`|@`XC}I4b+iyCn1dADz?=Kivc!d~ll(D)5o@NJS{XgQX+P>zYaU zmrNnxnClAvZW%Aa5zRWT0t(ep4ch}xtuPohsXI(=d=!#mZ^Atg$W$UkoSGi4%H@B7 zGHb&<_qrbPVV@IJ$@j3uC@NRn60oj^CAz7>lgM-lsjT)3xhcpsJ^eW0#APH))x=+0 z1^f2xI~19D7hRsnL%nkL{kN|u??X_gibvuBCGQxtnr#S^ipONUINskH za%2-V;=+xtyl(KwaJfiQl_FanUott#&o4A^vdG;8j~%Ge5{zb8AUm!U7YZOW53?R)O;=O5>h?Rs^&T&wpLe&>cY3!N|P#e!ba0=0wX}S(zI0?HyP!08A$}SNlzU@es`VnGX~>ST3C(QU_G^OPbwj| z@IYT(mAwrSp{AH)DDtIeB})jnty`KKh98Rq{>d(w<52m|jwC9&ANrJnhF4x(->hu` zG^U9Uum9SFTWEb*;0=Uuj5d=F5_F)Lq-)byJ(Q_FC$UEtzjbS|%7`dtmY}v9k(g^O z(*%w59LNFj&}2q{q|td5HZ&RhF-jw~*5oocRlxWI8TKIyNI>EAS)*ez3KrX=62-!g zsXKtPE>lK~YG1616r+{;8%UDtm-a6Q{9a2~x@2-*!px%ayCz2gh4`=cA>a%lPjC3Ks1#E7mNodby2& z3JooC6~2+D-jPM8XwJ?_n#@oGW!iyE{upY~Ie?I0=&l`vkkHgUK=udz?3a0KBHF{p zPkfxm0IhEYq$w%&S!D2o&B!X#UvKSZ_mwY9bJNz34d_%nOw!9tqX;{9d} zb>6b>-td_8ug#^m&aM_wiO8{6B^!Rxv3^&`>HdzPS4Vh5c*S)sQnllq21{Booo%51@UhQaU2pK zgr0g;kp}>+_v8d(@Su~dP4b-LMB+I3-3vwD7!j)!8ZaCh4@x)7k||Q*%%@=yjCKzT z-6~;l3P12`L?hNai@=fd6C{kbXnU0-ElicaWECIIV%3_1-=^@?bpku*aI>BuB$e2@3^~pmLDsLbe_@Q*p zrk6)dIU?9vu+%%jd92snmSTY+JLUt4GG`h8p&5pPG7HTjcKF)BBgPoTA(ON ziY#Zc>BqLfoud;?@yOv_25QXeF20VdlND>N=SiTa#5*i8s<7k7GA+N&4t?c&7XDus5At{)zurW`kmX{neVwUxnO$F8 zs{6wra?Wm5GEcS4a+b(7KiATZ!SdH$^bvpXuzj7&h{RBm8lIZ%M~bn?DJO?b7{s1I ze%w5sFtG=)lQp93;=H;!tr9)Lk{KmHnz4-WamvkBqol3?PnnTFi(<>wFJ;@s_&d|v z#H>%$7Smf}m(ugh1-(%eQ#VZRz5xf@bc*zetY61YAlGJe^25i+Oy!{fz0uwhtJI2? zIwXxH0Tn{g2)e0M;>74n8Twfg!cW5~NqdMQP& z6l?xc-hQdVz_$8bcaH5;y$E@f}K3;h2F4B4IRsGHXk?$=cb?|bBQESazUhk7#%el_WdYe&= z|IhYLm~Y@`8X6P~v;dQ(5-NgqSay)ScsPYeIK_yAZ?+_SQ+Oh7PzxeO&4f-7RGX`< z+Q*MPpx1$M`e4>Ag)Z`yDv{1}7=`G@%yRUwGf)>o=U%#g#nyOW5$V@1lLs1WVKnQzF35Mw7_)1-w)gM~Xm~bCa z(y3vtxK9EEQ}#^LkP;I^X!@XU4ftcoQ7|HYv5=f+n1@IgW|s~w@Wv6FcCn)vfGx9=k}GfH z-x?6F-2U9!Tz2Qn#z0E}s8#8e#@lD4=qdq-w1V8FxnCQ8aS{;<$Alf?YRbcAY!G#f zs!ZZW3j=%ko6Su=)oQt0y{E!&pl)Gxeh^z#soEYOL4`RX)?DR<4^G{CaMWF#|D+{5 zLc$v9_SdC~>wBSD-JAahqdD%-g0cR^Yv9Eallvb726p3!zxc^MR^+QxAv0GQy){E3 zxXD^3*=g1Wx4OOGn_JoZ2qP@EGgjr$oR`h+;^^tR@W-?*>tf3?l1rF|ZFS)kclN4l zW->XZ{)p4KsC!mymS1?Idm`pBs{!Mf1mUQAcGEc1!u!{P(M0t`1wK`yvt0!QnJg69 z85X=5`OlXA5>s_k*tvP02Sf>iUCTvSdsoT^1tF#-Z|v+LgH+UB`<)1G0ma{>lSm+6 zDZK0gvv|ie8^skXYA?DKJ;~kh&V~9j=C|VRXg*H-qS6^ATwh(xH)OtC+)?Ee5{XSW zu-vUxsAwHOoMMFTz$5Ai5-iJpZ&_MbJJgAKNAdVZr8e6(#$#mO;;FO^f5petwO@9IPGMbo*W#U+6}@@|#=REEd*Lly zzW#NZ>IZd4L4Y?y_5;LF^IY%A0g1-WPE`0`6;AOYBK2vpm9O*Zb`I$yA?5(?} zuYW8PR<-T*wGj?3OIa}bu463BsMbJc_PGfp={7V3c<+RDlBAR+u8&$W z*c4qZ%fJM|15`F42WRu+%rp+d3Sp#UJb4i*rx#`m#%PNbf@Dgpm~khI8}6wHd0SA3 z=tqrfBCAE|;S?x~a@~yD;#be?Tt^YSKDW_J*+Jn4#JPoEuZrh(m&mb(A851Ex)mM1 zjlX(C6@3b#E-DCEb6<3_Fx>6^3=a^iR2I^Bc0$&)qB{axmw zD(ARBAW>uKHOJ<7kr1rmc`~R*L|DbYcJWA61)1`D_*f2 zrgTyULGJH=sYNh4J@-(fV|5r4O|`eO-CYZtZgu81N*ns8e}^jyVS9h;!PRQRg8!`- z*?pnoGaI8*Nimc<3%LZ`{w<_r;Z4nOmf*EK?+Ci9J|V?OuePwJ4nv|E^jOetiH@F{ z27hkQU3=;y`YMQ(D{)ewSjI}5o{i7k2A|0O7cS5Ni#0(uCbLnn20*VrXirg*E|C(U zSBL@UhR@|C$UC>yu^0J5lA}m!m6b^6N5o6YP34 zM>ZAzhV4Cz0ZaSviE9GKIgm%EsKpr_KQfx!4(}3$@=IV!V8M*+Aed_qH8W+l_iBdp z+}7#vh+!Zm7vlAUu6UnAXXv`_;cwG)+||>CIF^M)nhBi+dYR&w&0^PTgEkfL43kpS zOoA<17`Dsx^c+n@e}0h0D)WLP3=6%<9N5tHH%}0*(-LP!oC14_*x>L!rl2(P+z^eq ztEQfGEYLb7^MjjJr4CbS|pdgmGGj>Ygdt@F1arbA;K55QwvbQmrMeFr zTsJV&4{*xfbM+Z?hP=fF&#<+GcUE$2T4xl$EtFsu*8do-|3Isvu*~o4Ej=!F$H3kJeBZ8KqOi}>7&Tc6a#866`=_L@m&?9YD zDKsbUtJ|KrsZHdJ3%*qZnAP5Nm`$BKrj9ay&DP~&@E-A}cCj-Q4D27~K^JM4$P^5d zrOuzyHJyh71kn19c+LB0h;kX#IW9A(Nbxk^8qj3Me%Q^^SKTCZZWP2ymPuap3AIp^ z(4wH?Y4ChxHM%pyAZN;S9k#=RI5oC}QZ?1OD>0aInMFt|xF=r6NH{mD@FqjrT4Kz= zX}4I{W%#O_$!t^lej!aw%sQh8Lf#SDoa1BLXo6%;s@?Gh%`Ak@@VuZ5q5eu+7m$|4 z_Ct^Gm)h>+KE=_LawUDva<a{2}#?d)chn$n?Lt@z@{&}|D(V)B?{-|IEY9g z-)m1au+bc*#=C$t;1~~fdyfc;TXjr5Z8*}`2TQ4GnF$*#^fcRnM&MDdwj+gWb%Eg& zp}*~P8(EP@+#M;9SL$B*N@$qN$ks>gI&+gN6Y(`$^J1EjKl4Yk~WOzJ9#2Lqy!JkH&Y9k%J)ZP^Rh z+lW=%+Z`1jLjf}#lFPlswa#-W@V8#JAI~S`b8FHBYVX32d4maIcsRE|w_gt+br0qA z){(yyt~^)AO(%1^3+;9uy;@EN`^5MBXdt#RQ{6`~!lfG!YC$_Y%{SfhcX-@5Z^Hgh z8bG-8zeNLTqK(ZzO))UX0)CQ%^dr+}@CjDTle7c4V#TD(ZZQ>BMnJ~A2T5AaWds^w z_}?y{5nN*X*)!iT>tJMskECP!rLDGfUe^!LyGPo>Z#rnRD~8F(HdB%ue^H6o&Jm%VOXqb2sWx!V8-x#eJ~-U*(ONd4CFUIaNn49WK34hZBS9vzO6n!5Im{^MvVAeRQXZYkpM zxeI+FF>`RHoM+NJ8;j`DfcXJs>LmRQ9%gLiyh&FrG?_(7kh4IoHXG$5X5>c&%#W2p z8nG~UI!)e{LAAjchC|!#gHho`WQI4*k(xSur96Vqy|KSZGBYa-Jg@1Zwb3hxsAR%f{Wz>k{INT{1~gK* z`o;|#UdHBkq*8eZ;Oo&ai%SsY@}rRqwcpc~`kHvToj4=gdv5EsiH7OkZAYxiqd@ZT z_R@~$DjSMqJBJa8A~zR-J`0AyRummfv_WeRZQkB*78fzNQ~Pu$YH?~D?b4Y|1CBV^ z3%A4EH{FYkIgSxTA>7BIlxCe6<+y1Z>5^+kB<=)r67D6MXHR^t{3(#uUL;Hz+-szv zvxRQxzD8~FtA#+O7#PdHAz$?gAdE>RTJi+6=T+bcBaJ=Plfm4fLa!%rO$+?Qlpjx; zPM>(Zxh_e2sR*%zy~YmK-p+QaD_{C(b{sfmKs=?sMXfg$*j0$HwRnhn?n_*~5?z&Z zetLeoG^Ig|59i?jhT)^xn`8CRnb3E}Zh9~3XRy>pM54CO?Tp>sv2GJ1>eJ$ zOuDVr$|UZ904cXYhW~>0? zO63J{bUYL5yiqXA@$t7`-ssZvwT%RxDMr6w;5|$a{~xO+YQ^bLcH; zI8Wbfdl<(Ihq=HEwmsHi=2^P==Z78w`6wu%3nU?v)tN5{;z!dxNr!w}J{!2h`iE|w z%h4sRKPTj{ZIj8L*Ba;0Ym>><(o(`B>1^C_t3TUB{#fvaU+aSyIjN>e4t9dRp=p3+ z=>y@#pR#Gk^WMx>#{)u~THeX7Y4oheIFArE=MJw8ccGWQW;$Rgurt4~?vXcv>p)oL$?FNS;js7c^kR@u(Q6^s@K)~ zYR&Cz#Tnd4pOj&+d!v}YV#Oao%)iIV-@L+i1iiedzdGXG>teO*HsHtF(1)k2IB{>g z&(z+7(kcBVLIwl|lH$m6y(me$5XQ@=a%L83wFSyKF!9uOW`D()J|swx4!v7iMnv zh3YjVd>T;uWNYjxOxf-(%hLMYBEeToHLJL=RGggTOTUNSeXU%>MI~IuTcX|R#p$x9 z(^|_0?xQV&MnqC&9MKY#VKLcw+0o@J6Sv!vA2jc>wd!NK=kBDi@=JGHpX?GPi-Z@k zmEWVLS&@z4G_6uy0=n0-r(pWx=go_v;w>Z=RJ5ajR6MP>pb$D)(YhMS8;OCHIs}Q5_Y*4;XY>%RBS1Hc>eNJKFYp*a#j8*H6aDczCT>M+-$Fn??_O^6vkxyoFaArVa{L{ zdE_dLInr3l$k2)2WB{7@`V9wJY(Yu2u3@f|1TV@IDO1VWr_rXtf|pI6I{G8WQxWmKk>)j5aRiyQ4m1^Psit6tLZb0`TMb((Omms2(V_cl{M-nwmK!W2&ZrP+|b*>!>rPG?>`GPk* zM1mfcXTA`xo)~_w0_l@?G@! z3ny*f!0DgP@^~S%TQ75D{roilio5wUP`DSrF%cQ4WS z{j0r7{*}qIGg;R&=58Le+42@HM}f6xkXhGj0tS z5+?B3g-Cu8aVhL>lpSQqk5 ztU)if)4Wd5Q)wa79pn0|?XO={(zx`1H+c5e=CoVm;0BPG>Yjm{Ed4 zX;6}QiX;x-sXNxYgFsGY#+gq8wgx#vYX*0)_%EJP+GhPvV*ZoQ*>_JYp?v}DV^^OY`SgPAbBj&qNfp z?41m%p9m>_M;S=kKqYRZcR~>3eB#RK`{7>NTU5jV$jc923u1kv_aB!`l`vecH=Zn- zy>PkGzk*yT@qZQ#DH7Q|8;hhzc+x0wkGEX}#d3vU+xy;*#zf%q9NNQ6hai_@ zcrV^5$%~6RsGKjc3+ufjU7-)Ub2AIbiy7`%x9TxWwpLnJSI!!rGuL#{gAa|{Vfe?7 zwpJQP6L8N_?@!Ekl<#_w?YwEMu@LRL7EM4#wq2frGCr6OZ$fgdLT@^+jwbh!vDY^B z7Oia!)uw5_RgbK{su-%>mp3Ehb~>nKK2O@E@k-YXUi+Hi;2cxRomVz}vY_47)ukE8 z`SOXYa3D_W6Sn~G=Ne6~xz#ROk)&N;X1p4Zpp^c3DMSV-l-Dt>mDp^#_v0J$&Sevu zHZtj_aF|tdmZh%#t>&taaSQ`lhAj(B82UtQT{wgE1Z6?5eC(aQHp8A#Tc8YP&x(#@ zmPS2B4@`R+xbbbYqQ-AA&LHlE8B;6l936+zf62glk*Xt`TQ-&;EJ;*RpZ5MtQ$Sh! zePX_d)A$!HZ32Fp^#{qTH3#@g7?FCcJRU1zRqAnN3V?zdPJdDBj|;-$Z8 zWs%bIqx2_D8Mb^!f>b=2R;HdJYq%hJr&5S;#}IeW)`Cz1GlAD%*{tB*0bcR89gHT( zVtw7TLp7f3L16P9GFKRX%a^^CLiT_}qe#6<(X9px(ir~trL{I1n}P>>r@8gph@Wk0 zA;5u{GmlgDT!#+tAvc~*XW)q=xu;MJ*cz3pL*|#D;~5dbUbGN5GJhYmW4FMOpPIsCRK0glo zT=D&(O-0kddO5-Ka~|-qm{OP#om-OWHExB)P_blw%;EqDyTn< z+b4J+1(~2$<-y#634L|M&`AWZiy=QnOr;1euG;7Rwsc=B99koeG}bXcdRJX2UB!$- z`hW4zC_UC@_qG`8or!z&+9ujq^ywFj2-esn~AGc!*?L$+XjX{aMc zrJ$PbFbAD1y~9oqE+95vIbA$?P3a%OA--6|dwh%<7m2}CSJyJ9Ei;fMZ!oMPUS0-W zldQQ~q)f%dF`;+ov-FQE{+0|nx-1?1#Hj=1cfaPF&S`}cNbNOzCzj8a-hv4|%Ie-7 z;Pe%f8|QiQ&D#;%kHYGaq~4PN{rfL#5lJ@j7TQtT6a2&Ii_f)gr_Q}9HCYy=@pB+# zltKORRjt}Dmv%8YL73^j-?nIRtp>a&VDqvz`ar1H3FMT0`20A26~fT3bIJs*&-PQ? zKp|{_brkad3!qS14OiOdGYsW~E!3 zGr50w1VL{@mpxkB^S-X2qCsVW$hJaNs9LooL$%+!t^ph87}Icw#1qal7d5x_`~EzN z5?|QUmLK`;;KU``5Jr+0Wrly$f7B%$N?{Y>`z&>?pi1Z6yGw=u#k|>4^e5g>a>wxY zG1Z)0YUTRj2ES2W`%evG%lwUUw*JH8cQ%b@gz1MypODLyjhqlNMR%}=gzTVyL=rQ#%N>Zs5sgd@j@HF{EEf-I}b1d0xHQj3aBw^6hR$Avs@3m-yPR{$MrO(&UgWTH}Hv-{nBLZo5%P4qt(#++S_qx{fbOXKP~=D15nz0jjw}=-YgVc9r`&vO$t%S` zH0Na(HJI9_{6>8~s$9yr=!LCIP`bR{RJE{rXV?y=rkU~NWYx1RadamkeY&ST^W$0Y zHn_W>4UXcv4er&5u z;BCbE>bjh|1$WPed<~Hxq7kOOiK|_=#mo%;4jR`Dnr4g^C#9-nks!esw`Ys?STq@2 z2MyPb-O`^p9x5do{K^>5f>pIE5!${xe7~%mBbJcANxIf+$}H^VAjpf}qv-8&=glKo z_@SsS+TIq!d-j+}v6t2DYj0-M3l)`aC8^4H<^2%;5b7;HhJML72H7;CjsDFI4 zICZ-3YFkC&sV+mR6gP)7IaaCVM^$sv&p+-2%A-js_TPn4r>_vicfH#?cL*C~j|=jV z_m|DvdP{^!lf)}rjn~FnR8osHFvdt2$dP3F^MWFIHnW&)h5vGn?C0s8#yoP8eS%+@ zVCmRfM*h~wnpXP!nrB9z1*+AA2ii_XgWdd}o4bZ5mOlSJO!PfKsz;B?6=>vni%84C zhYrUsF^_8OjotBw&F7R%7r%C>F?9YAjm42ldE0r9RliF4tKU^#PGmtS~kbg+yj;MfrJEeHK}HyoeEkSHbUiEy7+% zWk8GCzm*!_vrQi}_jW`$j8XzdhmefTGG*I%D0gUD+!uWeY&r|cr$VH$L$08 z0PEAoFs3i1@+QsHJc%NO+DaH`&9x#w#BX}D+0uKYEyIGGV4{IPEI&G0p+e=w_Sile z1>jO3pTusT-LKoPu5U&g$+v_gE*aFkC+tm8=y1-g{pL7871~ETMQ5?K!2itDIN%#v zzU_R(psLMnqLy~pOl~N$u8DT!w3;W7c?%i-M%qj?J{q#u+^?t z-4+B`*>dDEC$nE6TD$0iQw^tvlb_o;mYW~h`JBw|^ZMQFZRZ<@nJo~|r^9>Y1uK-n zm6u};f!{DiF53CrZzl!sXAG1ieuPqE45!Gt^$)%t*Ikb&2v-l>Nw;LtiaZ+n?h>qW zrhc%M6K(_aIm>f*b%fLG+dB*_ccW~Wt+w}O+*PgrlJ({5m6|WTmwoln$FQecJGY9G zRh9&2ks79Cm;ihJl+B*3u=HdNP7;h-x@fT+u{m(0$kq_SB=b#HnawSqo^Pi~-k8_{ zQIF8i>humsN{#gUA z2$Fj>B|O9PMu8p^7jDHMh&6`icvODkA$|yZKg#f+L-T&(UBnOJ0wDjvlhEQ*t4KOD zj5%=-xpicR&B+@qg1ViZ#NaX{yO@7r*L!|A|4H`2uMRa%T&LR5pAUX-X^*V~dYi3Sj z!U+=C$JxODJk*01)6mgx7XBoQN%=AOVLExfRfF{7?^;r{az1Af{I(shmoMaR8}9M0 z8}eSF_#RAr`uP1_Sux1{&ZSX0{zBm8b&2DGhQ_ES8J_udB{c0<6nxu&>g#>=9&5Ia zQ^S{N2KD5+KTEIzEo+2G8Q$LiXLFY0OOYVkY!L=htdSGa2%vPhe1G-%|NolSY1;Xr z*(An1DL;h&7BA+x@!NH?AKODL04w&Fl`9T=rF-Wsy)OPu;wg%6w$>aRulK*LxR?(c@+zPxvx1AHrhvcGp~DuC^;_u)FY^G)~t{2Tvv*sD8yrElp`(5c`+ zTPpCEMn!0r5CF|TR%$aY`Cb(}W}^o`Zz|vFn&LRup5>g8a+)@c1@@~H^(}U+Sg_o6 zNzu()=ITPjx%`c@Oy_UByYX7T!BV;$bUT$f37k0&Jc?Mae(C_cg2zlXNxxa8;2ftf zd7BR@w4rtU4*%6!eQ*9nxErb2r)N=HAS3W{88pK_lNNZT2D%0i-EThZ%U>_Q*+>)j zAWQ(D>|s2GKN`I41%k417f@2^TRIeUM)(3Y`}~8z0>t18Fn=+l91IrFWACz(3eSYs z-%3Vw#Xfdq9=9uBfhRNcuNw7F=98WMW-e=I=0n@aDkqpW*DU}S{ZI^T_BlnX|A}^f zxqZc_aomJ&|06TwFmi87VHlp#uq&rHo(d-NI)Sg_+g|=oE`D7r5Iz|&e9IbYWO zY#58d$aV(*g<&Bljuxr^uPxu_ad%a(Kj7i%ulot_JH(hFx43<6Fo-vk1%i(mv5 zK0@{F4oe|c=%*EY%LNDUyP$Qu?MQ6S=>VMH&7_<>zo7EpOtoI{9<=G8q8tu{Ra2Rn z_+md_;%y8?3x(@hP6OX7)gMgwPHJqf9h@Frex`Axzh-c!YkQsHc{bnWaRYQcb|HY@ zCm=x3n&W>gbihPJ*Ai%lxmGKlDBo~|^e%?H%@5Y~RttIIHO%TNy z|J7vwYd_^RBpyEkgk<_s)QD?h4DjT;*LQ30UK7XFbtms-I4=9N4E$CIe_+{aHstXv zVoQ@-12XnQv;Afi%wP8x;-vrt;NNoakHL=0H7*4oLWa#fpS*4!>jB;LKH*`jkpPk? z2xr&*0!PUSUw2%|LAmwJutY=y$^9k`2&_Cg-angMZNvGsk0_kg;2fzypVB|}f|pzm z>G@0`XXdtU+K1vq;KDFzsQT%z&+{-D-cqy84}G<8Aq*Vd(V#&<-5rEm(!c`FTyA(* z^lwuvmYe@>JU3bY^Tht4VE-SV*mn8Nd-J08fv~9({p;Cg%|y?t$p+U08UDwfETroz zJNFPki28_vJz;a>;M9(b)=&Mqt*zkdIt6jn?nk&y0|aVCvZ(65JT}2Q086)gno&B3^g8Z;A9%(n)<~BkpcCwT@dq*XYf1NzhEz+?*MA;y2#zb*!ynN<45H zE}pKp=`qc{c-p&Ld4uyZ)C|%XC>|g-Z(q2Juj5L(nunK9rh~KCci;&@cICeLhFuUd zk?fDp5DMh|dkw@2x4q{XT2@KwGgqzYclEt*AfO1VLllx^#ngi+TElM$2HF4MSn+?~ zi&U|LWp@kJ%u99j!;bb6GwhtV?~Rl?Ka3ofvW_f>d2WqRW#mE3&Hu+I3rFC_&3cq~ zSIg1T-#hQ&sCw?)M8x*35y;`q2&y3#`$%)sgLvn=Y0v$e$!PBuwr#)!_KZJ# zcC>y^VETV|f_zg*BS!99hVN}18X+eRpQ;IKT|-1dghsGDh>zD0t%ney)~{INs1|Jw!h@E(y&Q&nS`geD?$be6fSC*rP;>^|i~^Gn3Dq6Tx`LMYr#;J&TW zNUOxqprOuShAAs_!~HwLVSt{`#Kzr3=b(Jzzw4UExwEq4?9~5sL*t**(srHSb=e$=*4_U=-+(gupfy1Fq zU7w309udWI^gG6~#|?zoJMR{fqkLv>&pg>e`gL0GX3iq+!#7V|5m&g+Z$4v>0+#aU zCzTMK{Lg?JN9L|;5gNXXQ_g!Fvzjx<3jY%R+Z?nlJ`rb2evLy)m3QH9n-?-Y{gCcq}2XAxrZ1DRGag~sK zn%)MuKA#p`4i+FrZJ7?_=ghLOK2fpCLWJfRipbGC3!%t5U&EBf797Dk|I1|H`~TZ) zd}~*ruA${NNxWFarL0|O@Y7d;bY~IM`dmS1Y1@@;D8RDGe0}$}X*m@ZepV5EToD6D z?7Bf{B?^&7I(GxRY?Pp0rI5%Wh?zZ(Q`(Nb=u7C*cME{);1>U1Oa^DP-)we%#oNX_ z@NZijij9)f5gHM(NX#S_G)pFxal)N#A^aIi-0TQu8!q=n1sD`)aO1q3{AzhHP9qS~ zT$d!QEs6;JoRYM|f=a%6>Ym&a4DtEvV}yt;(7=pv>6Em9udKQPpsdQ%T!Sre!`%QS z?M);FI7X!g&mpeQ{j@=bsW${MiK?3tumvDr-(OtMvNp~PX1OF4(fR;@lag?u4S-W8 zU-0zrfzxma-^r4H-N^zG$Wj)uJLsxL;_h({9O5!DB;NC_0&M-Y{5>i_wJp*{_0EbY zdv&cgzZ2YQ2LlXxydYw12ZLns5RW{voRb`0&HW6&*y2{;1RGdZMJ5C>vseC`J1K0Ma&w=}%-+o6JR3$ZZ z{tfTv3?Yf~P^G};UJ|{nIc#84nDVW{H{1(Qyslc4iG~W;f&_E#LSUNmJfArpco4rz z#d3V>fl}o<`}ZbwoV;=@(lqR_%iA^F^OzZ+0y2!~k=xN|L|izm+tUW#-%6}*^aKxV zm3+e)e5;zrAKxy2{T|{IY3g^JhGHq4z&m*B?my$X#w}?fn)Tm|$k)cbOJV6PdyvvL z-wM7zIP#a@zY5-P|BA9|eqQ-1P;!Cmt2{8?93!#s)IuQ?M*D(TFaFs~`v5I;#*Y8% ziMON*bjU-yPF7%Z&T>!n2ht=07y3PcQL=*dsF8u=BD#452l8op47@{ z*%0YJ@7DV>fMO`?znaTUMB!h%rS<>?5g!6;jC8+&P=^CM1&1L&!xru*Dg{vReKnW+ zF`NM&BH~zIH2keQbI$=svGn5KP8%DA30o<0p-WLY&=U>G9UWM~J42v(%n=8!88m*G z<&`n`Po+WsuhPIY24)lw~XQPOb0 zvZ*xT7HUI+{m(!^u{7Wjc_&0K{uG$Y`}Zzz<_?hvr)DoRx9vi?$pastA6XCV-xxN^ z^}XtEr8kaN@Jf^Ql)j^CTqlFyhU>-4EQuwH#HKO5H=NiTeP^JM@~gZ2^J} zd4%6J9~wuUJbW+Eb%#q3b8q6a2?``c1tJ!-2)i+MGk^&*PV*IO%pLev-$0nd14Ln_ z>Gn}3q&bfd=lYEPP3-1lraew%k-#%ss|JSJD@KGlL$@*4DSv8H_2V349?J_(6H?b(&>pK4k;xdo4YG z%g*;#9>j>8=a!}{GT@IIz5w_|zuh3^N63L`>gS_cj*j8$!Mz=Dok{?9Ufx4?o_7}u zvUUIYXbzE~C}zh?Dq2Z!i-eQ<-H_c;a5CV%Z2#GSNY?|7YhDl71}KI1wr<5JUdH@gK7IToBWP$h8tLh6X$ewk|l`S7tYS%6~oN!~f(V?SDaMn)Uju zpMVjg*uB<90Vtc3)YB4B|C7fQ_%){buQ4s*V{-bgiO2v4wZFm2^W;Anv%%%s3>`b+ z#{;4o?8TqT%`s++0D!_hYkZejo#CSn+9AX0REH6&Z|2$isdv!~LS$8C7SPGehn8<2&uiYHF|! zEaYL4PWxS2wTc3{9Hmzs(ag+=+%{pDB;3O15!c#F6`2wi%1CVs4~Bqa;efA6l&n-= zFhq!c)%2+#Vj|7oZUqV=^mPyCfAg>y_118n2G57*D;bjNbhP!v`S_>xJ6!4)A*yDT z-w696=@mPINO%^@Cd|UI_|N-JX2i{gvK8%`FffQXJ}zpeTIS$uIKMhQ++6q4RVg)E zLWF*-J;`vrIPFOmaioCZ818J41Vh9Q6Gq_y6)@@;xQxX$l}knx#AHv&xCKbxV%{fN zT0l|ikEs85#E*N;r)Iy7FCFRg-Nn%o!|)u9`f2xz`2gkwd4jy^E$)@(vz>)DRbf1F>#lUxu;)_85 z9%BO5&P16h{qjt?=>)ZIM?~SBM2MLEM4^5!DXnr*8iRU`(vP8R{Atfhf<%Z9S`Nw< z_)Cvb;@`f;0PcoukvF*bfO(!`#~}TKe}H?sYt~Xj6=sKNJ|kM{hzx(gswW;!EtU4n z`_4dy4B6ULb$NC;%w)y9{({5d0L$tlNKf!&t1+lmyo_SjV2W0=^iy-%EFJjzih@?D z;B8+Df?&{d=2|(vi+$M)4w)q09(oyWyR8i`>?h-0chzudq$5uDRyzIf)3Gs;AY5JoXw|dsL2-U60%ETc-e>_IQ{Q|S#HKfB7As?On z)qXg_+o}OnEXQ=Cp*Kmi@0-N48%KdJaT3HN=7I$C?)vVpkI2v|6k>uVIE-Sawl`sB914*@ks(D`(W{;gn(ax%EzK6?Qe_?p0Kj6 z419T>f#yt*{VG)yy5L~(g7FaCTA?K2wtm;sjmS)=n8#3mby@u)=5ZrxEW4t>oB0K+u|kn;%#$|G|p(31*z+?<^vWjuVN38@%x+zXR#1><-}Bnz2&jbKj&k{ zxL^7wzOYYqJosUGFr?Udwq2i0*SFh7<|f`2M54R5+%3&TV=7MZ_{HoH9lc_n^{IKM zXh?IEbXpR~|NejV{QtTYc#BF^)|t3jkMlV*!FqSoq-N**>GMK3XPgIz{B%l-Q7t#d zOFL2Tr8&EZed@_6&{PO~ob5Gf)%!H_1FK+=s(G#a2Mi)=TE0oU!*+xFIK}3{q)!tT zV&!=T%$A2}^$zaf?!yd_?v@K;G6%&*YLDl~D`uR-JE%^TKMA;7FSSmN#z#s_12}zZ z#$9}uO*(UiyXd=pX?1vgTo%+o==2aKH3COju+9zn2Oa#&Fn}7QcmIk6C3V?LK1G`Fu^#FdeV;`FUfd#wo9JH0y!XnoGa-v7U}Aspzgxi7-BH%+NdRakEK~2}6$c1L zX56l(9BL&+C%R%;mp%}gg#c4V##q5#e3#l&hX}2>{Yz5%QUITl!s*mjMq>GB=Vjl` zjwojOlU=9iI4qZ_vFwtEutM8S6&8uZ64jmr=#mE-6KvYgt6*fh)+v!lhcjN8j%D;o zgjp-hWagy@%JBuGfAW?j`ZpQ7meH&pvycVYTyv34XR@G7oq)T?>vT2mg2s)Ra>dK? ziK*V&^Aj}jvEBR492pG_AefWxy7}v&e)*1BbN8=^(DWCv^EpA9>PTTcc3ajL#~a1H zl;+blPaJl2dL4BUkU6KU!;7B?i^eOXws_r5mrjf`iU#u7=EwI?V9Pw&0XikIeH~-^ z$&6_DOc4Ol=@Z?iAe_VkF_QjktO1Hezl6&ir||Ir9G6VB65k<>ju)G;d?8GeK_GOdj{- ztq$w;3?7vYd3{b;A+2WZx!q{|6Vv%oxfFjwcH_>eqe*5{9&0qBo@!5I7|}(t1-ol* z6~zvhZrwf-c*l;~!Fj1DfmvR}c;rhUOyjZV04E_S(B8NS_l>wqic!=KHa)cMd$Q&!rdUqXPpN!rweQ7$jl0 z%_=5ZL`m4GDy@IMCyLK=uPtklEE9CN)PbXEh`a=p>S9CAfJBGTc7l9F?riZhx!lN+?lPEFdSPg%s*V!HL1Cw z3G>2mj{7dN^Xn`X3{lE}b9vnnNlz2}^e~3^bTu_;pB{VhEAZtpH@IkXPd zxj3Bw&#bdH@MZ1U{S-v-8rc(l{YZbiX$LXK{ngMd;xe--I(DP)AwZPFCd}(e_KCYK zy4T+h+8axzn(%!!>Kd&G%PS+DaTpg+mY~9b}`68+{mk3COnz*AzRGK&g*!b zxkV+{oAmSxC`t`f+ifpub{k7($!9O0+l||W#l@?#wgDTlhX%@N8}f;_G4Df=M`qSK zUs_#wZ^k!?-Kxg0B<69HW6G23gEl7xA6i|a9vwO-PrqI}ryDq#u5S(|8p)4LS4?sZ z;j}+q8OT{8X&+R&YBQ>=md8~tur#j7p#EEa@x2Z0GJXzMlMa_BD{v_k3Z$t-t>Zz$ z$X7&;y-tyda&tR{j0+&3biRLmB`pAPyFAaTiv6$KsApXXXrv9qmk6p?mlsQG z8OeBi8{J;7yO_;m3w)JB%Z*3!UYD6DvuG3eyp31RZLayC*A>IkQ(WPEvg;Qc9(x4~ zrC7=-?g?8P%*db{A{}Hba*!(7iDl9LfGb|Po>!e_zcb&%oEfV@$XYL;r$BTGVz&Vd z)1Hf;bIn@nXU?6BhcpxC14%Au-cVwN`rQ~DybQiD z$VIOV9lcL(vmjc0oG+TC{4m+71MA4)mE*o-t(Pem!?fdqh@r*A8*ujZWZ1fRi;u1B zYxMCQY-LuZul{}KKF@p+O1iobGVHfjL3{vOQSpByE7RmP* zRpbz|#naBm7lQej@&WZ^T}Zu41H@yS~c;@yV~-6m|ky4FXV!|75) z4xnYpBhMoRs`sdMnH`#6cbc^~zFIQTmm>5n!FYV-+u6~!odQyi5i5OkOvCekh$|XC zK-yyEp&W=Wg;1@r7yI6X?GP`bP)Ey$2xTPNlqQ4PyY7@sxzq83)@yu|Eq?f2k*sYE)F)Aci*zY;1s1=D!N%_l$x;5!sfMRM4ZB?b}zK z(w{sbK3luKK9Dw04^KFoy<=%2sl>dE z?x<`uR4X@bbE%)+kORXZ8X?mMg@8ZA=naHCkk_b~*IKcMCwTSC|4S;-1l2Mo94)6q z(}Q@K+5h)4#dv|5k&35=E0$aA+O6n@<0Xb43=p9MgR>cDqyhN+iLXuMChjfTUwp~X z9Ss@Wrcp1l4ZcUGMk%D@L0o8YVS)G81Avl|BxKo>csV*Qis=pAa-}c`=DvVvH;h$Z zdTpXSpUq^n?>-(+TQt}#o-?U`&p^MG4WZZs)y{ebJ(@mE)e!ADEHvG2bK`I)+o4iL z$;cn_0|)PZ92*unt!ypwbFMhsjU4u1$WwAocoLI2|8(D&DDQp9BKoGvIut1GbaHOj z^NN~-Vb#pb9C&PBWn;Y3Yr8$os8@QY*yU)-?)7J3KXgAK5Oa(bw?XS1u5{x$OyxG6 zwrh_PPPeA2t4V1_{fRlw;4V-!kdO+lIEbG*%KaG0XMXCqA3`qjW?ac!IuAuhUz5s}r*1X1(!*HB-I`4pckrNZP z((0LXKfSx-IXb!wabK?u<<7kPF7J2fHaA0Xso{R=0th)UN8TQkmLt{b|9y1Z9!%~(M40? z*J*i)G^9g(pp7NjmTA0eT?iy)NYKNLX^Q&u^MIPujqD;?&Eg1JMbTE*r=pS(k|d;~ zrP|Ri;vc_JUpw+IF`AIva+oE}e4T5lvBmOYS zAESlZMV4c|yRT=&bS}v1JKqaZEdHRD`tr8%S)K@-n2e+mp=#wp2!EJ4JhVc21IKvE z;L8W_=826O1W=Rv*Rlf02Nj@`Hhpp*$%+|>xJt783c5`?FO~BO$5ucE>ls&8p3dl} zBb}e`8+#!1WlS=qajj+D6N_Zg)3eUGmrDn_Eip$_GSj?knD(z?19ay>CR=f{ubatf z2y8Th{tj@?+;ix~2Wx|3>W*t)tZ9zHMs(VYyrH3fi}Pcd8dhkxt*%_G7r57WLS$Z} zse8SVst>XFjz6K3aDP{3)E&x_mv-YcpWZm%rb%|b`x=d1(Ce)rf$D|p=^Bj#kgDID zH4y(!lBJ^m|ied|Y;HGvC3_w{jtS)$pCOMdJ>%9LgH3P;zG8H4e zQQv&KefJB0dxM?OSrW@Fz59#4-xEN-b(9k^!}Bk;dOroJ>=I`M!(zRtM)rC(v#5S7mPg86;aVI}PI< zB^A|EPKVvav9ekfs=ge7kcGAA!H!n~D6^NltP0N0Gi<8vF$KZb>e=YS-0Iw@cK*f7P z`x(>=pU_~>qI?41vdFR+`EYluL9<6Likcy`Mt@0aOCAC%eAkWefbZDl0gJWQUTJWv z+iHywRRPZ8@!4+Oyg$9pT$49E)M9D$j8KL6K6blwUXdpTA}jpPeL7!<#1806!otQ6 zkr3@~{`X&3+nVavfV8264<<>``DHwp#pg-K_1srjmd8WPH%t`f9s$1E>xg_P^g(Bh z)C5@yyRp|b0H4{mNmx%Lh)zDsOGn?I&GjJ}+lM<-x1pFMk`Yyr0o(|+q)rN?&S~a! z7{#aGQd)!!M^2IlK1;ljIA8z7cG)Ji+vB4lk*8Lf;8KfXnR99CU1DO%eeY6xY*HOJw+_dkKk3}yUut%Ahh|bz{kQIV#^*Bp&7(Vlg!kB zBjBeHvH(=v?%Rx{-GxcA#LSOzT#`TD93K6^ru8I7x`P*zl<3rv5Igg{@fnitxt)eY zrTSeLguT~55&A*o~NSSxIy3~AuK3o|MCt#6NBEj5A)vwXf)2;AwDM! zsH8CD?9`w-@PlhBdR9xgC2G3jfSbjy=jqcBQ)lH^oTk_O?N4uvoQh@j~bT?F3lb zDhG^3f7rV6XbUgsSt_-Z?lDcc>_rW#7d5F%I&fYKYKCsc+WIqYhtAJP9ZvTpWyZk+ zRvzuZ$``#e$Shme-}TTOO*|ShRtOKKabrNbbIkpt*4Hzc0-ym+&5Ny?YDe-nG#CL5YxEnHAI29seu=l ztQ+ix_Ki!s-*PNo7ry?sfxdpir*Y0U`k+{&^N9DPdbU8bIe};nXgw$HkrF{n*5e9` zg*2&njvk9?*E3U^V~Z)95h%T_uw{T=2u1aZVR14Px%hJn03`)HZ&lpGO<(oXhmZkS}eCBiHt^JhHFZM!ML^% z8nTro%aomY&fK_H&swkNujlo8{N*p^_x*j(IiK@6??Wolh32+mgY&q8|3nr{BaAe{ zHtzuEBh??;_Z^6<71dStW1rg4VmdKyIvlMHn%KjNVs8~-C(C~nWnEYhhQu0Dy$Aa; z+Or`Ciw_G7?#Wjr3@~KQo+_$WWTxh32VHG0j30TBVVQF@7Bj0o#fMC6voV>z;sNr+ z_{qJ^i|#KMhaPe3EqUiI$~m`_=SPR%F^ufyb)WEw2PzQ_2g%#oSI37#Lw1tEI$0g} z$tQsqi>pt~T_-f7q)KqMjDM-5CFfABIBq%WBnA%i`;0`@2oc3cRToYkxB-H}u&3&- zILztFUpGXINOi2)*)$;dyOy3_3PrY6sC|V7WsGWU$zbvXSBPUrG6sYwZuMJi7kLS!Yju_4TS!s z8kQ{6flHyILbv;h4SbvW&=Ix=cpH}zmV_|j$=(V5CZ_{(RR?dK%075g087rJ%S;K+ z)~6Y9dV$HlbW;3={X(|arf&8$3IGSE(NgWN!pu2qv5%C)T_7z|uXKybd9j6ahJFoc zMy2L8_BHp_ckF{VI%xlfWQ_syHwJ{;ZePp84QVvwA$NB47 z141|8XBUspxaK~ib{IAne)-(*c`SFDHvfc#EX&w+A&Z~zB_tp>2jPfI94&z1`9>8* z0}s|Y0a)!vN_n(+HSZVEvtUChdt3G;p1)Da4oKX%$8>+&N5!^j1cE(zuD6;SZ{HTc zQVkq>_nSjA+2NzN(z)SZS(k=Lw7D%r;nK_8{K+tgsig%5ax4I{(rvx5)s3q@%1+G= zzv8O}UvFQ!RQ+QUw7J8pt30FNVCpgp1CCp~jJLI64H0FJ1#*$|4?&Lw;QJ}o^xJlg+Y_^D zoR)-Ihx6-tG{f9BUPdmdSdF*u+__h10A>%fWLKtA`E40T>KfM88L$2~#FYuH@pM(h=yU6twbng`AzXEI=VFc&}jrBQ)YcB(1s-eJ%8#oW!b zKw7qZ={2DX5()AYnoYPM4Pw63z3=Vw^j5c5JY<(Pd2qtQom=yM>8ZTk=`VDde5C>t zLz#H`x?i}oj?X7fM3c9o-!*&!#OHHxKWZOn@^Q*Tw&wFQ4e=%znEOX%7Wrqj zJ+;$pesS|#*pP|aNI>oWDjdQQH!j|Uw8A4}L$DPK(FXj#HO4n*NKl!_`*k1e zVHnIw9dvHm+pCcWSVv-2O_d5aH@9J$p_rVQ>EPBuzS@zx8hG>)1X3V(thZQ`a(5Yp{SnkbA$d~XH15$BiB8X76s02t)-V$rzdk{&p7AEaRU zNM4zg4yy)gU*F$1@Zz7^#}W$o`pC}G@Cq1*B*U{sDF@EktFY*mE^X9uj?E5^ew3W6 zm02EQ(Ao6;EoDzKvN=wIhbl|FFQ6+nL=CKSG2ich6{+lLjPGF(rOIs16!t4?tcgQO zePIu+EVnK=fq%jsG_(J`6Lzd|10{3lc$7Gs$vV&xe#O;*xQ0h6B6KLP7SZCotN5vH zE3TPppTJ_?Ogba7LTA%h7j9N*HKZE_t;K!n`Z6`R%AZDs0mx)g?+6F!Z~O}9ezPaG z5V0?a(Dm=mt8_AjqPYWR3q%;bP>ZTg_3lw-@2F6kw%VeIzq?V&0@voUD(6!q#Wjp? zOV?hTu;7+)x|abHMPcaBY+u(bzt+_vs2oT3LhH7THSP*mobG-aHJyROf1w?_kvuDk zLunVXtIZgXw{v0VTmWA%kn*WswWF*9i(38%@C+bm9+aOCm*+RBuK&tk@{fe>0ynhY z4Uk@u6^-G_a}vAqo}RAT)oY*|yBl?7jX)H53-mh&oVs8f?RMpE4MSHmKs;4HF>2~~ zX0=;Ek|raj%_%3@DpCZc{ZMJlI<28cGOa1g@9J}>hnUEl9%kBgf(r7}w**ukDo@_4 z@ApiINei(0T^{Cjmw|g`BDVF& z)$=m70HXL_wCHzU6qVLhSTOe_IQ81LB&7UT)!=04*3*`-XIKVl#%WQhs)QlyX+s_B zqraSab}GUq`@-Ekt)F_>v65x(10)e?7NrJ1IV-1qgYF=m(MCR(uzT8*us<**w5yCL z}fmXbIjEc(5-Wc|1*0cG@1 zD|FKy`^L=UhL4TYJkP;^CJvfizb#!8XKQyhPqyr$jEyJ+$)UCF8R*Wg;lkp2lIey> zM1WFMNSsOZohMS&Sv4mQ5Q1CA4yHSCA&z_ZS_h03p;(!P{m@d|)8HqP%JBDw>Sm6W`xqVu}9+$Q$ z;xY(EPXFXhpV<+e(({C;yFf!Q#i{8k7F}{#QE&Ku^F>BlVc}SRitQYQ?6?+Xn&wG; z`@+fO%=1DWNh>SG$^J`rvFT>&m5r5Xvr6yL5ANn;&3xp55{+J3_OZxLK$3idFek;L z;T!9Be*JsQ1mlyufediWU2L|(>H+ZLzaNL-{&O4g-&PN3yGyBF{mC%%#Y1;f_KHt= zH{b;^U~X~%Qx=oMbEq6?e*k_z{$olUbs6JS?@fI|TiX_4F06BZ*~iJnr2SGZX~1Of<>NSPFzkZ<#|#E{llQ@w$=)OdwCgRC zU4||&TE?3u>|IKDkpsLB2e?Fcg?Yalo|QD033wWh^WNzz$WMM0(A$6q=GJ_!nU9gw zi}^+C&S#2@Z<3L?L3tla`9_*SzKN5m!DB0HO;OF^@O-{OB^XTSX;iM+Mq$uJQluor zIb~NHfJdL%(vyg;%~*W0=iu80tTTK7`;qr0iAS3bLSfmOe+UXo=E7>i`Z8lqVOh50 zJM#q;78%RwvBBu>int0$%JBm7QU$|@%HuFe=*pjcl=9A!2AE`v5EF?n-&+)U-hce_qLI0M_mW8)n7)NsbB=%T?rmQZVj$f5a%i$E4WyqL0jqn* zA}<|Caf@3c94H;?@(T}6B{BT|O5#@1%}$VGKQoo}r_r&INUYl2TZ*-Q!aY2h~=UQDzw-k-%+2JHm|N?<%(cy?xIQocZOERCf8JC zENk188^6IETVi*#-Omexo|8hZ3oK2vF3}OkhP$nC3*4@MJkG9e9jspw=DnU8*cRzH z!UqxBStbE9J{sJ}f{%)-ysk*ZiutVY$90v4?W&h6f>hotvtLD)4QblW=KBzDDLkI= R>eLeW(pJ}3%RF=<=x@pmd%6Gs literal 0 HcmV?d00001 diff --git a/CLIP/LICENSE b/CLIP/LICENSE new file mode 100644 index 0000000..4e97f0b --- /dev/null +++ b/CLIP/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2021 OpenAI + +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/CLIP/MANIFEST.in b/CLIP/MANIFEST.in new file mode 100644 index 0000000..effd8d9 --- /dev/null +++ b/CLIP/MANIFEST.in @@ -0,0 +1 @@ +include clip/bpe_simple_vocab_16e6.txt.gz diff --git a/CLIP/README.md b/CLIP/README.md new file mode 100644 index 0000000..abc8a34 --- /dev/null +++ b/CLIP/README.md @@ -0,0 +1,193 @@ +# CLIP + +[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb) + +CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision. + + + +## Approach + +![CLIP](CLIP.png) + + + +## Usage + +First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick: + +```bash +$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0 +$ pip install ftfy regex tqdm +$ pip install git+https://github.com/openai/CLIP.git +``` + +Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU. + +```python +import torch +import clip +from PIL import Image + +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load("ViT-B/32", device=device) + +image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device) +text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + +with torch.no_grad(): + image_features = model.encode_image(image) + text_features = model.encode_text(text) + + logits_per_image, logits_per_text = model(image, text) + probs = logits_per_image.softmax(dim=-1).cpu().numpy() + +print("Label probs:", probs) # prints: [[0.9927937 0.00421068 0.00299572]] +``` + + +## API + +The CLIP module `clip` provides the following methods: + +#### `clip.available_models()` + +Returns the names of the available CLIP models. + +#### `clip.load(name, device=..., jit=False)` + +Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint. + +The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded. + +#### `clip.tokenize(text: Union[str, List[str]], context_length=77)` + +Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model + +--- + +The model returned by `clip.load()` supports the following methods: + +#### `model.encode_image(image: Tensor)` + +Given a batch of images, returns the image features encoded by the vision portion of the CLIP model. + +#### `model.encode_text(text: Tensor)` + +Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model. + +#### `model(image: Tensor, text: Tensor)` + +Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100. + + + +## More Examples + +### Zero-Shot Prediction + +The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset. + +```python +import os +import clip +import torch +from torchvision.datasets import CIFAR100 + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Download the dataset +cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False) + +# Prepare the inputs +image, class_id = cifar100[3637] +image_input = preprocess(image).unsqueeze(0).to(device) +text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device) + +# Calculate features +with torch.no_grad(): + image_features = model.encode_image(image_input) + text_features = model.encode_text(text_inputs) + +# Pick the top 5 most similar labels for the image +image_features /= image_features.norm(dim=-1, keepdim=True) +text_features /= text_features.norm(dim=-1, keepdim=True) +similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1) +values, indices = similarity[0].topk(5) + +# Print the result +print("\nTop predictions:\n") +for value, index in zip(values, indices): + print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%") +``` + +The output will look like the following (the exact numbers may be slightly different depending on the compute device): + +``` +Top predictions: + + snake: 65.31% + turtle: 12.29% + sweet_pepper: 3.83% + lizard: 1.88% + crocodile: 1.75% +``` + +Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs. + + +### Linear-probe evaluation + +The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features. + +```python +import os +import clip +import torch + +import numpy as np +from sklearn.linear_model import LogisticRegression +from torch.utils.data import DataLoader +from torchvision.datasets import CIFAR100 +from tqdm import tqdm + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Load the dataset +root = os.path.expanduser("~/.cache") +train = CIFAR100(root, download=True, train=True, transform=preprocess) +test = CIFAR100(root, download=True, train=False, transform=preprocess) + + +def get_features(dataset): + all_features = [] + all_labels = [] + + with torch.no_grad(): + for images, labels in tqdm(DataLoader(dataset, batch_size=100)): + features = model.encode_image(images.to(device)) + + all_features.append(features) + all_labels.append(labels) + + return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy() + +# Calculate the image features +train_features, train_labels = get_features(train) +test_features, test_labels = get_features(test) + +# Perform logistic regression +classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1) +classifier.fit(train_features, train_labels) + +# Evaluate using the logistic regression classifier +predictions = classifier.predict(test_features) +accuracy = np.mean((test_labels == predictions).astype(np.float)) * 100. +print(f"Accuracy = {accuracy:.3f}") +``` + +Note that the `C` value should be determined via a hyperparameter sweep using a validation split. diff --git a/CLIP/clip/__init__.py b/CLIP/clip/__init__.py new file mode 100644 index 0000000..dcc5619 --- /dev/null +++ b/CLIP/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/CLIP/clip/bpe_simple_vocab_16e6.txt.gz b/CLIP/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..7b5088a527f720063f044eb928eee315f63b2fc0 GIT binary patch literal 1356917 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%0D-8anuzg!0hrX~L}M*$l~SOpZ7=I+%ag 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