From 7096255f7714666678ae2051c4e1dbe7c17c2116 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Thu, 7 Sep 2023 11:59:15 +0200 Subject: [PATCH 01/20] BCEWithLogitsLoss in reconstruction --- data/MNISTDataModule.py | 42 ------------------- experiments/gz-svae.yaml | 39 +++++++++++++++++ ...ional_spherical_variational_autoencoder.py | 9 ++-- 3 files changed, 44 insertions(+), 46 deletions(-) delete mode 100644 data/MNISTDataModule.py create mode 100644 experiments/gz-svae.yaml diff --git a/data/MNISTDataModule.py b/data/MNISTDataModule.py deleted file mode 100644 index f794b81..0000000 --- a/data/MNISTDataModule.py +++ /dev/null @@ -1,42 +0,0 @@ -import lightning.pytorch as pl -from torch.utils.data import DataLoader, random_split -from torchvision import transforms -from torchvision.datasets import MNIST - - -class MNISTDataModule(pl.LightningDataModule): - def __init__(self, data_dir: str = "./data/", batch_size: int = 32, num_workers: int = 12): - super().__init__() - self.data_dir = data_dir - self.batch_size = batch_size - self.num_workers = num_workers - self.transform = transforms.Compose([transforms.ToTensor()]) - - def prepare_data(self): - # download - MNIST(self.data_dir, train=True, download=True) - MNIST(self.data_dir, train=False, download=True) - - def setup(self, stage: str): - if stage == "fit": - mnist_full = MNIST(self.data_dir, train=True, transform=self.transform) - self.mnist_train, self.mnist_val = random_split(mnist_full, [55000, 5000]) - - if stage == "test": - self.mnist_test = MNIST(self.data_dir, train=False, transform=self.transform) - - if stage == "predict": - self.mnist_predict = MNIST(self.data_dir, train=False, transform=self.transform) - - def train_dataloader(self): - return DataLoader(self.mnist_train, batch_size=self.batch_size, num_workers=self.num_workers, - shuffle=True) - - def val_dataloader(self): - return DataLoader(self.mnist_val, batch_size=self.batch_size, num_workers=self.num_workers) - - def test_dataloader(self): - return DataLoader(self.mnist_test, batch_size=self.batch_size, num_workers=self.num_workers) - - def predict_dataloader(self): - return DataLoader(self.mnist_predict, batch_size=self.batch_size, num_workers=self.num_workers) diff --git a/experiments/gz-svae.yaml b/experiments/gz-svae.yaml new file mode 100644 index 0000000..da3ab4c --- /dev/null +++ b/experiments/gz-svae.yaml @@ -0,0 +1,39 @@ +seed_everything: 42 + +model: + class_path: models.RotationalSphericalVariationalAutoencoder + init_args: + h_dim: 256 + z_dim: 3 + distribution: "vmf" + +data: + class_path: data.GalaxyZooDataModule + init_args: + data_dir: /hits/basement/ain/Data/KaggleGalaxyZoo/images_training_rev1 + extension: jpg + batch_size: 256 + shuffle: True + num_workers: 12 + +optimizer: + class_path: torch.optim.Adam + init_args: + lr: 0.001 + +lr_scheduler: + class_path: lightning.pytorch.cli.ReduceLROnPlateau + init_args: + mode: min + factor: 0.1 + patience: 500 + cooldown: 500 + min_lr: 1.e-5 + monitor: train_loss + verbose: True + +trainer: + max_epochs: -1 + accelerator: gpu + devices: 1 + precision: 32 \ No newline at end of file diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index 913fc15..82e3fd1 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -137,12 +137,13 @@ def training_step(self, batch, batch_idx): return loss - def reconstruction_loss(self, images, reconstructions): - return torch.sqrt(torch.sum(torch.square(images.reshape(-1,3*64*64)-reconstructions.reshape(-1,3*64*64)), dim=-1)) - def project(self, images): z_mean, _ = self.encode(images) return z_mean def reconstruct(self, coordinates): - return self.decode(coordinates) \ No newline at end of file + return torch.sigmoid(self.decode(coordinates)) + + def reconstruction_loss(self, images, reconstructions): + return nn.BCEWithLogitsLoss(reduction='none')( + reconstructions.reshape(-1, 3*64*64), images.reshape(-1, 3*64*64)).sum(-1).mean() From 6bf66d301b51e300e5e7861bc3a51dd77f2b3dce Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Thu, 7 Sep 2023 16:39:49 +0200 Subject: [PATCH 02/20] test z_mean of svae --- .vscode/launch.json | 18 ++++++++++ environment.yml | 1 + ...IllustrisSVAE.yaml => illustris-svae.yaml} | 9 ++--- test-svae.py | 33 +++++++++++++++++++ 4 files changed, 54 insertions(+), 7 deletions(-) rename experiments/{IllustrisSVAE.yaml => illustris-svae.yaml} (57%) create mode 100644 test-svae.py diff --git a/.vscode/launch.json b/.vscode/launch.json index e7a97cf..ca86945 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -22,6 +22,24 @@ "console": "integratedTerminal", "justMyCode": true }, + { + "name": "Python: illustris-svae", + "type": "python", + "request": "launch", + "program": "main.py", + "args": "fit -c experiments/illustris-svae.yaml", + "console": "integratedTerminal", + "justMyCode": true + }, + { + "name": "Python: gz-svae", + "type": "python", + "request": "launch", + "program": "main.py", + "args": "fit -c experiments/gz-svae.yaml", + "console": "integratedTerminal", + "justMyCode": true + }, { "name": "Python: Current File", "type": "python", diff --git a/environment.yml b/environment.yml index 1c033ac..e3e0608 100644 --- a/environment.yml +++ b/environment.yml @@ -12,6 +12,7 @@ dependencies: - pip - pip: - jsonargparse[signatures] + - tensorboard - tensorrt - python=3.10 - pytorch-gpu diff --git a/experiments/IllustrisSVAE.yaml b/experiments/illustris-svae.yaml similarity index 57% rename from experiments/IllustrisSVAE.yaml rename to experiments/illustris-svae.yaml index 518603a..6614a61 100644 --- a/experiments/IllustrisSVAE.yaml +++ b/experiments/illustris-svae.yaml @@ -10,12 +10,7 @@ model: data: class_path: data.IllustrisSdssDataModule init_args: - data_directories: ["/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/", - "/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_095/data/", - "/local_data/AIN/SKIRT_synthetic_images/TNG50/sdss/snapnum_099/data/", - "/local_data/AIN/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/", - "/local_data/AIN/SKIRT_synthetic_images/Illustris/sdss/snapnum_135/data/", - "/local_data/AIN/SKIRT_synthetic_images/Illustris/sdss/snapnum_131/data/"] + data_directories: ["/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/"] extension: fits minsize: 100 batch_size: 128 @@ -41,5 +36,5 @@ lr_scheduler: trainer: max_epochs: -1 accelerator: gpu - devices: 4 + devices: [0] precision: 32 \ No newline at end of file diff --git a/test-svae.py b/test-svae.py new file mode 100644 index 0000000..b47b278 --- /dev/null +++ b/test-svae.py @@ -0,0 +1,33 @@ +import argparse + +import torch +import yaml + +import data +import models + +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description="Test SVAE") + parser.add_argument("--config", "-c", default="config.yaml", + help="config file (default = 'config.yaml').") + + vars = vars(parser.parse_args()) + if "config" in vars: + with open(vars["config"], "r", encoding="utf-8") as stream: + config = yaml.load(stream, Loader=yaml.Loader) + + model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) + + checkpoint = torch.load("lightning_logs/version_13/checkpoints/epoch=43-step=3344.ckpt") + model.load_state_dict(checkpoint["state_dict"]) + + data_module = data.IllustrisSdssDataModule(**(config["data"]["init_args"])) + data_module.setup("predict") + dataloader = data_module.predict_dataloader() + + for batch in dataloader: + image = batch["image"] + z_mean, _ = model.encode(image) + print(z_mean) + break From 304d1286a7d6dfb52c69c8ae5d5b02fd5df5232b Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Sat, 9 Sep 2023 11:31:04 +0200 Subject: [PATCH 03/20] config illustris-svae --- experiments/illustris-svae.yaml | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/experiments/illustris-svae.yaml b/experiments/illustris-svae.yaml index 6614a61..deedefb 100644 --- a/experiments/illustris-svae.yaml +++ b/experiments/illustris-svae.yaml @@ -10,12 +10,17 @@ model: data: class_path: data.IllustrisSdssDataModule init_args: - data_directories: ["/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/"] + data_directories: ["/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/", + "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG100/sdss/snapnum_095/data/", + "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG50/sdss/snapnum_099/data/", + "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/", + "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/Illustris/sdss/snapnum_135/data/", + "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/Illustris/sdss/snapnum_131/data/"] extension: fits minsize: 100 - batch_size: 128 + batch_size: 64 shuffle: True - num_workers: 32 + num_workers: 8 optimizer: class_path: torch.optim.Adam @@ -36,5 +41,11 @@ lr_scheduler: trainer: max_epochs: -1 accelerator: gpu - devices: [0] - precision: 32 \ No newline at end of file + devices: 4 + precision: 32 + logger: + class_path: lightning.pytorch.loggers.WandbLogger + init_args: + project: spherinator + name: illustris-svae + log_model: True From 054dd689b782e2f00d4bb36519bb24f2925ac632 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Sat, 9 Sep 2023 16:03:03 +0200 Subject: [PATCH 04/20] remove SimpleModel --- models/__init__.py | 7 +++---- models/simple.py | 12 ------------ 2 files changed, 3 insertions(+), 16 deletions(-) delete mode 100644 models/simple.py diff --git a/models/__init__.py b/models/__init__.py index 4e4d5bc..3c92718 100644 --- a/models/__init__.py +++ b/models/__init__.py @@ -4,22 +4,21 @@ It contains the following modules: -1. `rotational_spherical_projecting_autoencoder`: +1. `rotational_spherical_autoencoder`: A plain convolutional autoencoder projecting on a sphere with naive rotation invariance. -2. `simple`: TODO +2. `rotational_spherical_variational_autoencoder`: + A convolutional variational autoencoder projecting on a sphere with naive rotation invariance. """ from .rotational_spherical_autoencoder import RotationalSphericalAutoencoder from .rotational_spherical_variational_autoencoder import \ RotationalSphericalVariationalAutoencoder -from .simple import SimpleModel from .svae import SVAE from .vae import VAE __all__ = [ 'RotationalSphericalAutoencoder', 'RotationalSphericalVariationalAutoencoder', - 'SimpleModel', 'SVAE', 'VAE', ] diff --git a/models/simple.py b/models/simple.py deleted file mode 100644 index 34e85d4..0000000 --- a/models/simple.py +++ /dev/null @@ -1,12 +0,0 @@ -import lightning.pytorch as pl -import torch - -class SimpleModel(pl.LightningModule): - def __init__(self): - super().__init__() - self.l1 = torch.nn.Linear(in_features=64, out_features=4) - self.example_input_array = torch.randn(1, 64) - - - def forward(self, x): - return torch.relu(self.l1(x.view(x.size(0), -1))) From 70916075978f2c08b7ed6859e54575b0ffd55aea Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Sun, 10 Sep 2023 12:12:16 +0200 Subject: [PATCH 05/20] dynamic binarization and recon_loss --- models/rotational_spherical_variational_autoencoder.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index 82e3fd1..0e52b11 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -118,6 +118,9 @@ def training_step(self, batch, batch_idx): x = functional.center_crop(x, [256,256]) input = functional.resize(x, [64,64], antialias=False) + # dynamic binarization + input = (input > torch.distributions.Uniform(torch.tensor([0.0]), torch.tensor([1.0])).sample(input.shape)) + _, (q_z, p_z), _, recon = self.forward(input) loss_recon = self.reconstruction_loss(input, recon) @@ -133,7 +136,10 @@ def training_step(self, batch, batch_idx): loss = torch.mean(torch.min(losses, dim=1)[0]) - self.log('train_loss', loss, on_step=False, on_epoch=True, prog_bar=True, logger=True) + self.log('train_loss', loss, prog_bar=True) + self.log('loss_recon', loss_recon) + self.log('loss_KL', loss_KL) + self.log('learning_rate', self.optimizers().param_groups[0]['lr']) return loss From 13f639aa066084a9412b03f1196f1f2fc0f18691 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Sun, 10 Sep 2023 12:15:40 +0200 Subject: [PATCH 06/20] default adam optimizer --- ...rotational_spherical_variational_autoencoder.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index 82e3fd1..6508ae3 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -1,15 +1,18 @@ +import sys + import lightning.pytorch as pl import torch import torch.linalg import torch.nn as nn import torch.nn.functional as F import torchvision.transforms.functional as functional +from torch.optim import Adam -import sys sys.path.append('external/s-vae-pytorch/') from hyperspherical_vae.distributions import (HypersphericalUniform, VonMisesFisher) + class RotationalSphericalVariationalAutoencoder(pl.LightningModule): def __init__(self, h_dim=256, z_dim=2, distribution='normal'): @@ -52,7 +55,6 @@ def __init__(self, h_dim=256, z_dim=2, distribution='normal'): self.deconv4 = nn.ConvTranspose2d(in_channels=32, out_channels=16, kernel_size=(4,4), stride=2, padding=1) self.deconv5 = nn.ConvTranspose2d(in_channels=16, out_channels=3, kernel_size=(5,5), stride=1, padding=2) - def encode(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) @@ -76,7 +78,6 @@ def encode(self, x): return z_mean, z_var - def decode(self, z): x = F.tanh(self.fc2(z)) x = F.tanh(self.fc3(x)) @@ -88,7 +89,6 @@ def decode(self, z): x = self.deconv5(x) return x - def reparameterize(self, z_mean, z_var): if self.distribution == 'normal': q_z = torch.distributions.normal.Normal(z_mean, z_var) @@ -105,10 +105,8 @@ def forward(self, x): q_z, p_z = self.reparameterize(z_mean, z_var) z = q_z.rsample() x = self.decode(z) - return (z_mean, z_var), (q_z, p_z), z, x - def training_step(self, batch, batch_idx): images = batch["image"] rotations = 36 @@ -137,6 +135,10 @@ def training_step(self, batch, batch_idx): return loss + def configure_optimizers(self): + """Default Adam optimizer if missing from the configuration file.""" + return Adam(self.parameters(), lr=1e-3) + def project(self, images): z_mean, _ = self.encode(images) return z_mean From b281fcd2822646d45519588981c3908858b9e24a Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Sun, 10 Sep 2023 12:17:12 +0200 Subject: [PATCH 07/20] test binary crossentropy loss (BCE) --- .gitignore | 1 + experiments/illustris-svae-test.yaml | 46 ++++++++++++++++++++++++++++ test-bce.py | 19 ++++++++++++ 3 files changed, 66 insertions(+) create mode 100644 experiments/illustris-svae-test.yaml create mode 100644 test-bce.py diff --git a/.gitignore b/.gitignore index 3b51e5a..fb88b03 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ HiPSter lightning_logs data/MNIST/ wandb +TNG50/ diff --git a/experiments/illustris-svae-test.yaml b/experiments/illustris-svae-test.yaml new file mode 100644 index 0000000..7f30d19 --- /dev/null +++ b/experiments/illustris-svae-test.yaml @@ -0,0 +1,46 @@ +seed_everything: 42 + +model: + class_path: models.RotationalSphericalVariationalAutoencoder + init_args: + h_dim: 256 + z_dim: 3 + distribution: "vmf" + +data: + class_path: data.IllustrisSdssDataModule + init_args: + data_directories: ["TNG100"] + extension: fits + minsize: 100 + batch_size: 32 + shuffle: True + num_workers: 4 + +optimizer: + class_path: torch.optim.Adam + init_args: + lr: 0.001 + +lr_scheduler: + class_path: lightning.pytorch.cli.ReduceLROnPlateau + init_args: + mode: min + factor: 0.1 + patience: 500 + cooldown: 500 + min_lr: 1.e-5 + monitor: train_loss + verbose: True + +trainer: + max_epochs: -1 + accelerator: gpu + devices: 1 + precision: 32 + # logger: + # class_path: lightning.pytorch.loggers.WandbLogger + # init_args: + # project: spherinator + # name: illustris-svae + # log_model: True diff --git a/test-bce.py b/test-bce.py new file mode 100644 index 0000000..241912d --- /dev/null +++ b/test-bce.py @@ -0,0 +1,19 @@ +import lightning.pytorch as pl +import yaml + +import data +import models + +if __name__ == "__main__": + + with open("experiments/illustris-svae.yaml", "r", encoding="utf-8") as stream: + config = yaml.load(stream, Loader=yaml.Loader) + + model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) + + data_module = data.IllustrisSdssDataModule(data_directories=["TNG50"], num_workers=8, batch_size=32) + + trainer = pl.Trainer(accelerator='gpu', max_epochs=-1) + trainer.fit(model, data_module) + + print("Done.") From 8fa1a25aca450ceccd542d18f1c87d7bee03c0eb Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 11 Sep 2023 13:46:22 +0200 Subject: [PATCH 08/20] fix shape and device usage in dynamic binarization --- experiments/illustris-svae-test.yaml | 16 ++++++++-------- ...tational_spherical_variational_autoencoder.py | 5 +++-- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/experiments/illustris-svae-test.yaml b/experiments/illustris-svae-test.yaml index 7f30d19..f91ff71 100644 --- a/experiments/illustris-svae-test.yaml +++ b/experiments/illustris-svae-test.yaml @@ -10,12 +10,12 @@ model: data: class_path: data.IllustrisSdssDataModule init_args: - data_directories: ["TNG100"] + data_directories: ["TNG50"] extension: fits minsize: 100 batch_size: 32 shuffle: True - num_workers: 4 + num_workers: 8 optimizer: class_path: torch.optim.Adam @@ -38,9 +38,9 @@ trainer: accelerator: gpu devices: 1 precision: 32 - # logger: - # class_path: lightning.pytorch.loggers.WandbLogger - # init_args: - # project: spherinator - # name: illustris-svae - # log_model: True + logger: + class_path: lightning.pytorch.loggers.WandbLogger + init_args: + project: spherinator + name: illustris-svae-bce + log_model: True diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index c91a5b8..6fb930c 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -117,7 +117,8 @@ def training_step(self, batch, batch_idx): input = functional.resize(x, [64,64], antialias=False) # dynamic binarization - input = (input > torch.distributions.Uniform(torch.tensor([0.0]), torch.tensor([1.0])).sample(input.shape)) + input = (input > torch.distributions.Uniform(torch.tensor(0.0, device=self.device), + torch.tensor(1.0, device=self.device)).sample(input.shape)).float() _, (q_z, p_z), _, recon = self.forward(input) @@ -135,7 +136,7 @@ def training_step(self, batch, batch_idx): loss = torch.mean(torch.min(losses, dim=1)[0]) self.log('train_loss', loss, prog_bar=True) - self.log('loss_recon', loss_recon) + self.log('loss_recon', loss_recon, prog_bar=True) self.log('loss_KL', loss_KL) self.log('learning_rate', self.optimizers().param_groups[0]['lr']) From 9dc2569507eea27f36d1ffad1db95adf2d4531b7 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 11 Sep 2023 16:25:44 +0200 Subject: [PATCH 09/20] compare images with reconstructions --- test-bce-predict.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 test-bce-predict.py diff --git a/test-bce-predict.py b/test-bce-predict.py new file mode 100644 index 0000000..4ad8c60 --- /dev/null +++ b/test-bce-predict.py @@ -0,0 +1,34 @@ +import matplotlib.pyplot as plt +import torch +import torchvision.transforms.functional as functional + +import data +import models + +if __name__ == "__main__": + + model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint( + "spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt") + + data_module = data.IllustrisSdssDataModule(data_directories=["TNG50"], num_workers=1, batch_size=1) + data_module.setup("fit") + data_loader = data_module.train_dataloader() + + for batch in data_loader: + image = batch["image"] + image = image.to(model.device) + image = functional.rotate(image, 0.0, expand=False) + image = functional.center_crop(image, [256,256]) + input = functional.resize(image, [64,64], antialias=False) + + plt.imshow(input.cpu().numpy().squeeze().T) + plt.show() + + _, (q_z, p_z), _, recon = model(input) + + recon_image = torch.sigmoid(recon) + + plt.imshow(recon_image.cpu().detach().numpy().squeeze().T) + plt.show() + + print("Done.") From 3706a1254b699d78e7170a06d15d9d3cb1be4e68 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 11:01:24 +0200 Subject: [PATCH 10/20] jupyter notebook to visualize the images --- experiments/illustris-svae-test.yaml | 14 ++-- experiments/illustris-svae.yaml | 16 ++-- test-bce-predict.ipynb | 121 +++++++++++++++++++++++++++ test-bce-predict.py | 34 -------- 4 files changed, 136 insertions(+), 49 deletions(-) create mode 100644 test-bce-predict.ipynb delete mode 100644 test-bce-predict.py diff --git a/experiments/illustris-svae-test.yaml b/experiments/illustris-svae-test.yaml index f91ff71..4ff4880 100644 --- a/experiments/illustris-svae-test.yaml +++ b/experiments/illustris-svae-test.yaml @@ -10,7 +10,7 @@ model: data: class_path: data.IllustrisSdssDataModule init_args: - data_directories: ["TNG50"] + data_directories: ["/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/"] extension: fits minsize: 100 batch_size: 32 @@ -38,9 +38,9 @@ trainer: accelerator: gpu devices: 1 precision: 32 - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - project: spherinator - name: illustris-svae-bce - log_model: True + # logger: + # class_path: lightning.pytorch.loggers.WandbLogger + # init_args: + # project: spherinator + # name: illustris-svae-bce + # log_model: True diff --git a/experiments/illustris-svae.yaml b/experiments/illustris-svae.yaml index deedefb..48172aa 100644 --- a/experiments/illustris-svae.yaml +++ b/experiments/illustris-svae.yaml @@ -10,17 +10,17 @@ model: data: class_path: data.IllustrisSdssDataModule init_args: - data_directories: ["/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/", - "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG100/sdss/snapnum_095/data/", - "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG50/sdss/snapnum_099/data/", - "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/", - "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/Illustris/sdss/snapnum_135/data/", - "/hits/basement/its/doserbd/projects/AIN_SPACE/SKIRT_synthetic_images/Illustris/sdss/snapnum_131/data/"] + data_directories: ["/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_099/data/", + "/local_data/AIN/SKIRT_synthetic_images/TNG100/sdss/snapnum_095/data/", + "/local_data/AIN/SKIRT_synthetic_images/TNG50/sdss/snapnum_099/data/", + "/local_data/AIN/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/", + "/local_data/AIN/SKIRT_synthetic_images/Illustris/sdss/snapnum_135/data/", + "/local_data/AIN/SKIRT_synthetic_images/Illustris/sdss/snapnum_131/data/"] extension: fits minsize: 100 - batch_size: 64 + batch_size: 128 shuffle: True - num_workers: 8 + num_workers: 16 optimizer: class_path: torch.optim.Adam diff --git a/test-bce-predict.ipynb b/test-bce-predict.ipynb new file mode 100644 index 0000000..b7b28eb --- /dev/null +++ b/test-bce-predict.ipynb @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torchvision.transforms.functional as functional\n", + "\n", + "import data\n", + "import models\n", + "\n", + "model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint(\n", + " \"spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt\")\n", + "\n", + "data_module = data.IllustrisSdssDataModule(\n", + " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", + " num_workers=1, batch_size=1)\n", + "data_module.setup(\"fit\")\n", + "data_loader = data_module.train_dataloader()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGfCAYAAAD22G0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAg40lEQVR4nO3df2xV9f3H8ddV4Npie/3JvW2srGqjIqBIHVIZJVO6GDUzJkZBHcuSRRQUoomu+gfdEtuGZUSXbhBwMRJ1/CM4zFToopQtDbOijbUYxFC1U+4aHd57ZdJm9P39wy8nXnoP9LT38rn39vkgn0TO+fScz+cW++LDfd/PCZmZCQAAB85wPQAAwMRFCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnJmUqwv/8Y9/1G9/+1sdOnRIV111lZ5++mn96Ec/OuXXDQ8P64svvlBZWZlCoVCuhgcAyBEzUyqVUmVlpc444xRrHcuBLVu22OTJk23Tpk22b98+W7VqlU2dOtU+/fTTU35tf3+/SaLRaDRagbf+/v5T/swPmWV/A9N58+bp2muv1fr1671jV155pW6//Xa1tLSc9GsTiYTOOeecbA8JAHCaff3114pEIiftk/X3hIaGhrR37141NDSkHW9oaFBnZ+eI/oODg0omk15LpVLZHhIAwIHRvKWS9RD68ssvdezYMUWj0bTj0WhU8Xh8RP+WlhZFIhGvVVVVZXtIAIA8lbPquBMT0MwypmJjY6MSiYTX+vv7czUkAECeyXp13AUXXKAzzzxzxKpnYGBgxOpIksLhsMLhcLaHAQAoAFlfCU2ZMkVz585Ve3t72vH29nbV1dVl+3YAgAKWk88JPfLII7rvvvtUW1ur+fPna+PGjfrss8+0fPnyXNwOAFCgchJCd911l7766iv95je/0aFDhzRz5ky99tprmj59ei5uBwAoUDn5nNB4JJPJU9aVAwDyXyKRUHl5+Un7sHccAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcCh9Du3bt12223qbKyUqFQSK+88kraeTNTU1OTKisrVVJSokWLFqm3tzdb4wWKgvk0YKIJHEJHjhzR1Vdfrba2tozn165dq3Xr1qmtrU1dXV2KxWJavHixUqnUuAcLACgyNg6SbNu2bd7vh4eHLRaLWWtrq3fs6NGjFolEbMOGDRmvcfToUUskEl7r7+/3+0sijVY0zXya63HRaNlsiUTilDmS1feE+vr6FI/H1dDQ4B0Lh8Oqr69XZ2dnxq9paWlRJBLxWlVVVTaHBADIY1kNoXg8LkmKRqNpx6PRqHfuRI2NjUokEl7r7+/P5pAAAHlsUi4uGgqF0n5vZiOOHRcOhxUOh3MxDABAnsvqSigWi0nSiFXPwMDAiNURMJGFfBow0WQ1hKqrqxWLxdTe3u4dGxoaUkdHh+rq6rJ5KwBAEQj8z3HffPONPv74Y+/3fX196u7u1nnnnaeLL75Yq1evVnNzs2pqalRTU6Pm5maVlpZq6dKlWR04AKAIBC3LfuuttzKW4i1btswr016zZo3FYjELh8O2cOFC6+npGfX1E4mE87JCGo1Go42/jaZEO2RmpjySTCYViURcDwMAME6JRELl5eUn7cPecQAAZwghAIAzhBAAwBlCCADgDCEEAHCGEAIAOJOTveMAnJzf5yLYugcTDSshAIAzhBAAwBlCCADgDCEEAHCGEAIAOEN1HOAAVXDAd1gJAQCcIYQAAM4QQgAAZwghAIAzhBAAwBlCCADgDCEEAHCGEAIAOEMIAQCcIYQAAM6wbQ/ySi4f9pbbB8kFvTqPtQMkVkIAAIcIIQCAM4QQAMAZQggA4AwhBABwhuo45JVc1obltu4s6NUdVMFRkIc8xEoIAOAMIQQAcIYQAgA4QwgBAJwhhAAAzlAdB/goumKygh04ihkrIQCAM4QQAMAZQggA4AwhBABwhhACADhDdRwmjKDVbhSTAbnHSggA4AwhBABwhhACADhDCAEAnAkUQi0tLbruuutUVlamadOm6fbbb9f+/fvT+piZmpqaVFlZqZKSEi1atEi9vb1ZHTQAoDgECqGOjg6tWLFCe/bsUXt7u/73v/+poaFBR44c8fqsXbtW69atU1tbm7q6uhSLxbR48WKlUqmsDx4IIuTTvquby9TyXeZxmyljC3Yd4DSxcRgYGDBJ1tHRYWZmw8PDFovFrLW11etz9OhRi0QitmHDhlFdM5FI+P1EoNFy1Hx/bOd5yzxuM2Vswa7jem60YmiJROKUP/PH9Z5QIpGQJJ133nmSpL6+PsXjcTU0NHh9wuGw6uvr1dnZmfEag4ODSiaTaQ0AMDGMOYTMTI888ogWLFigmTNnSpLi8bgkKRqNpvWNRqPeuRO1tLQoEol4raqqaqxDAgAUmDGH0MqVK/X+++/rz3/+84hzoVD6Z83NbMSx4xobG5VIJLzW398/1iEBAArMmLbteeihh7R9+3bt3r1bF110kXc8FotJ+m5FVFFR4R0fGBgYsTo6LhwOKxwOj2UYyDfmczzv97/xGWCQ+fj2zc6LkukqIZ9rhALfM++/QShigVZCZqaVK1dq69atevPNN1VdXZ12vrq6WrFYTO3t7d6xoaEhdXR0qK6uLjsjBgAUjUAroRUrVuill17SX/7yF5WVlXnv80QiEZWUlCgUCmn16tVqbm5WTU2Nampq1NzcrNLSUi1dujQnEwAAFLAgJdnyKcN77rnnvD7Dw8O2Zs0ai8ViFg6HbeHChdbT0zPqe1CiXcDN75frcZ2O+fj2zU75d6aL+Pcv1JJzWrG10ZRoh/4/XPJGMplUJBJxPQyMhd+fpEJ9yyHIfHz7ZudFyXQV/ysU2zcChSqRSKi8vPykfdg7DgDgDA+1g6/Af5/Oyl+0Xfwt3ueePh8rCLYscbH6yEK1H3CasBICADhDCAEAnCGEAADOEEIAAGcIIQCAM1THwZeboqn8qSbz/QBdxu7BPm4XsoDzzNDdfO7pt6dcNl7awPcEToGVEADAGUIIAOAMIQQAcIYQAgA4QwgBAJyhOg4TR8C903zrvTJuPO9TYee3i7b/xX26Z/qC/KkkzCW2vCturIQAAM4QQgAAZwghAIAzhBAAwBlCCADgDNVxmDgCllNlLIKTFMr4xFWfqjbfLeUynzCfp7kG2a7Ob1u6UKA6s/zZI44quOLGSggA4AwhBABwhhACADhDCAEAnKEwAQXNv3ggd9fI1N/vdv4Pxgv2FZah2sDvEv5TD/Ki5O7BeMD3sRICADhDCAEAnCGEAADOEEIAAGcIIQCAM1THIbhsPGUsS08qC1IF53uN8V/Cd7udoPf0q9TLuP9PDp/25rt9EE+YQ5axEgIAOEMIAQCcIYQAAM4QQgAAZwghAIAzVMchuGxUQgXdbM1vH7cA3f33cQv2ALdMD4fLtLfbye7quzWb72s78oST7d2ogkOWsRICADhDCAEAnCGEAADOEEIAAGcIIQCAM1THFatAVWZ5tCFY0L3jgvT1LY/LzHxel4z39Lu4b9Wc702Dnhj3pTNV5PlVBgLZxkoIAOAMIQQAcIYQAgA4QwgBAJwJFELr16/X7NmzVV5ervLycs2fP1+vv/66d97M1NTUpMrKSpWUlGjRokXq7e3N+qAxCiGfNv7OTlgWmi+/6fu+LEFeK5/RWObmO/aMYwllbj4DD4Uyt/z53gf+zqEIBAqhiy66SK2trXrnnXf0zjvv6Mc//rF++tOfekGzdu1arVu3Tm1tberq6lIsFtPixYuVSqVyMngAQIGzcTr33HPt2WefteHhYYvFYtba2uqdO3r0qEUiEduwYcOor5dIJLLxl15akTXLQvP95fMl5tMyXcOvb3CZL5R5fEHnme/Nb0qux0Uba0skEqf8Ez/m94SOHTumLVu26MiRI5o/f776+voUj8fV0NDg9QmHw6qvr1dnZ6fvdQYHB5VMJtMaAGBiCBxCPT09OvvssxUOh7V8+XJt27ZNM2bMUDwelyRFo9G0/tFo1DuXSUtLiyKRiNeqqqqCDgkAUKACh9Dll1+u7u5u7dmzRw888ICWLVumffv2eedDJ3z82sxGHPu+xsZGJRIJr/X39wcdEgCgQAXetmfKlCm67LLLJEm1tbXq6urSM888o8cff1ySFI/HVVFR4fUfGBgYsTr6vnA4rHA4HHQYmGD8t9zxOZFxLxrfiwS6dMYTvk+Y87lI0O18MlSshSzztc3nL31+/U/yJL3TLF/GgdNp3J8TMjMNDg6qurpasVhM7e3t3rmhoSF1dHSorq5uvLcBABShQCuhJ554QjfffLOqqqqUSqW0ZcsW7dq1S2+88YZCoZBWr16t5uZm1dTUqKamRs3NzSotLdXSpUtzNX4AQAELFEL//ve/dd999+nQoUOKRCKaPXu23njjDS1evFiS9Nhjj+nbb7/Vgw8+qMOHD2vevHnauXOnysrKcjJ4AEBhC5n5/UOxG8lkUpFIxPUwkG+y8Z6Q/0UyX9nv0hmvnNv3hDJPp9jeE0KxSSQSKi8vP2kf9o4DADjDQ+0wBn4rimz8jTrgtX3/Fj/+Bb7fg90yLmL8bhd0Bec3z0zdg8490Ion6OvHagpjw0oIAOAMIQQAcIYQAgA4QwgBAJwhhAAAzlAdhzHIYSVUtgrvMpSwWeCqscz9M330x/dzQr6C3TNjcZzPZ438qvr8987L1J9qN5werIQAAM4QQgAAZwghAIAzhBAAwBlCCADgDNVxOA1GVmX5VZP5PQo++E5mI7/Ctx4t4EbymcceYMvt727q099v77gMr6FfEZzPLXNZ8ZbL3QRR3FgJAQCcIYQAAM4QQgAAZwghAIAzFCZkUcG+OZvzgY+8ULY2uQk0eN+LjH57Hv/+PgUVPgUIweczen7bE/lu5zP66fjK+z/jyFushAAAzhBCAABnCCEAgDOEEADAGUIIAOAM1XFZVLAVQtkaeE6r7AJePGNpm89WQT6X9t0WJ+ND7Xz6+hz3fQhekC2EAu4U5HvLIIWEQJaxEgIAOEMIAQCcIYQAAM4QQgAAZwghAIAzVMdhDAI+kC3AJYKXdo1+LL77uPmMO9OD8SSfqrmAFXb+8w9QwRf0tfLdIy/A9y3wfEZ/aUxMrIQAAM4QQgAAZwghAIAzhBAAwBlCCADgDNVxyF6lWhABL+FfBOf3RNMgt/SpggvQ3a+SLmtVY1l4yf32q8v4EvqNmyo4ZBkrIQCAM4QQAMAZQggA4AwhBABwhsIEBC8SyM5lAgmyI9B3/Uf/5DnfB8z5bXOTobvvaxJ83x6f40H4jDvItYPukhRoJEFnSTVEMWMlBABwhhACADhDCAEAnCGEAADOEEIAAGfGFUItLS0KhUJavXq1d8zM1NTUpMrKSpWUlGjRokXq7e0d7ziRR0I+LRvMpwWXYYShzC34fEb29vuV0xcrwPikUFZeXJ+XMOhIAnLyIuI0GXMIdXV1aePGjZo9e3ba8bVr12rdunVqa2tTV1eXYrGYFi9erFQqNe7BAgCKjI1BKpWympoaa29vt/r6elu1apWZmQ0PD1ssFrPW1lav79GjRy0SidiGDRtGde1EIuH39zXaBGjm09yMxTK27Fzfb6o5nJPfrzz4vtOKsyUSiVP+zB/TSmjFihW65ZZbdNNNN6Ud7+vrUzweV0NDg3csHA6rvr5enZ2dGa81ODioZDKZ1gAAE0PgHRO2bNmid999V11dXSPOxeNxSVI0Gk07Ho1G9emnn2a8XktLi379618HHQYAoAgEWgn19/dr1apVeuGFF3TWWWf59jvxGS9m5vvcl8bGRiUSCa/19/cHGRIAoIAFWgnt3btXAwMDmjt3rnfs2LFj2r17t9ra2rR//35J362IKioqvD4DAwMjVkfHhcNhhcPhsYwdRSi3NU8W6K7BHoLnt9ma3zUC7rYWdPO8ILcEHAq0ErrxxhvV09Oj7u5ur9XW1uqee+5Rd3e3LrnkEsViMbW3t3tfMzQ0pI6ODtXV1WV98ACAwhZoJVRWVqaZM2emHZs6darOP/987/jq1avV3Nysmpoa1dTUqLm5WaWlpVq6dGn2Rg0AKApZf5TDY489pm+//VYPPvigDh8+rHnz5mnnzp0qKyvL9q0AAAUuZOb3hBA3ksmkIpGI62GgKAV7T+gkb+iM/hqB/+/K4XtCwGmWSCRUXl5+0j7sHQcAcIYnq0JBVwhB1xO5FGQsfk9QzfQQ1u9OBFjd+E3e9+J+lw4wRhZH+YPvz5ixEgIAOEMIAQCcIYQAAM4QQgAAZwghAIAzVMdBQct48qnoJ8hYfPsGnVCg/ll6bfPpRc8T+VSlyfdn7FgJAQCcIYQAAM4QQgAAZwghAIAzFCagwOXV29MZ5HJ8+T733JoYsyx+rIQAAM4QQgAAZwghAIAzhBAAwBlCCADgDNVxKHD5XiOVy/Hl+9yBU2MlBABwhhACADhDCAEAnCGEAADOEEIAAGeojgMm9hZsgFOshAAAzhBCAABnCCEAgDOEEADAGUIIAOAM1XFATqvgKL0DToaVEADAGUIIAOAMIQQAcIYQAgA4Q2EC8kyxvZFfqOMGTg9WQgAAZwghAIAzhBAAwBlCCADgDCEEAHCG6jjkGarJgImElRAAwBlCCADgDCEEAHCGEAIAOEMIAQCcCRRCTU1NCoVCaS0Wi3nnzUxNTU2qrKxUSUmJFi1apN7e3qwPGih85tOAiSXwSuiqq67SoUOHvNbT0+OdW7t2rdatW6e2tjZ1dXUpFotp8eLFSqVSWR00AKA4BP6c0KRJk9JWP8eZmZ5++mk9+eSTuuOOOyRJzz//vKLRqF566SXdf//9Ga83ODiowcFB7/fJZDLokAAABSrwSujAgQOqrKxUdXW17r77bh08eFCS1NfXp3g8roaGBq9vOBxWfX29Ojs7fa/X0tKiSCTitaqqqjFMAwBQiAKF0Lx587R582bt2LFDmzZtUjweV11dnb766ivF43FJUjQaTfuaaDTqncuksbFRiUTCa/39/WOYBgCgEAX657ibb77Z++9Zs2Zp/vz5uvTSS/X888/r+uuvlySFQunbrpjZiGPfFw6HFQ6HgwwDAFAkxlWiPXXqVM2aNUsHDhzw3ic6cdUzMDAwYnUEIOTTChTFfhijcYXQ4OCgPvzwQ1VUVKi6ulqxWEzt7e3e+aGhIXV0dKiurm7cAwUAFCEL4NFHH7Vdu3bZwYMHbc+ePXbrrbdaWVmZffLJJ2Zm1traapFIxLZu3Wo9PT22ZMkSq6iosGQyOep7JBIJv79T0Wi0fG1+v1yPi+a0JRKJU/7MD/Se0L/+9S8tWbJEX375pS688EJdf/312rNnj6ZPny5Jeuyxx/Ttt9/qwQcf1OHDhzVv3jzt3LlTZWVlQW4DAJggQmZmrgfxfclkUpFIxPUwAATh91OkgN/mwvglEgmVl5eftA97xwEAnOHJqkA2TPSVwESZJ7KOlRAAwBlCCADgDCEEAHCGEAIAOENhApANvDEPjAkrIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOBA6hzz//XPfee6/OP/98lZaW6pprrtHevXu982ampqYmVVZWqqSkRIsWLVJvb29WBw0AKA6BQujw4cO64YYbNHnyZL3++uvat2+ffve73+mcc87x+qxdu1br1q1TW1uburq6FIvFtHjxYqVSqWyPHQBQ6CyAxx9/3BYsWOB7fnh42GKxmLW2tnrHjh49apFIxDZs2DCqeyQSCZNEo9FotAJviUTilD/zA62Etm/frtraWt15552aNm2a5syZo02bNnnn+/r6FI/H1dDQ4B0Lh8Oqr69XZ2dnxmsODg4qmUymNQDAxBAohA4ePKj169erpqZGO3bs0PLly/Xwww9r8+bNkqR4PC5JikajaV8XjUa9cydqaWlRJBLxWlVV1VjmAQAoQIFCaHh4WNdee62am5s1Z84c3X///frlL3+p9evXp/ULhUJpvzezEceOa2xsVCKR8Fp/f3/AKQAAClWgEKqoqNCMGTPSjl155ZX67LPPJEmxWEySRqx6BgYGRqyOjguHwyovL09rAICJIVAI3XDDDdq/f3/asY8++kjTp0+XJFVXVysWi6m9vd07PzQ0pI6ODtXV1WVhuACAojKqkrX/9/bbb9ukSZPsqaeesgMHDtiLL75opaWl9sILL3h9WltbLRKJ2NatW62np8eWLFliFRUVlkwmqY6j0Wi0CdRGUx0XKITMzF599VWbOXOmhcNhu+KKK2zjxo1p54eHh23NmjUWi8UsHA7bwoULraenZ9TXJ4RoNBqtONpoQihkZqY8kkwmFYlEXA8DADBOiUTilO/zs3ccAMAZQggA4AwhBABwhhACADhDCAEAnCGEAADOEEIAAGcIIQCAM4QQAMAZQggA4AwhBABwhhACADiTdyGUZ/upAgDGaDQ/z/MuhFKplOshAACyYDQ/z/PuUQ7Dw8P64osvVFZWplQqpaqqKvX39xf1Y7+TySTzLCITYZ4TYY4S8xwrM1MqlVJlZaXOOOPka51J475blp1xxhm66KKLJEmhUEiSVF5eXtR/AI5jnsVlIsxzIsxRYp5jMdrnwuXdP8cBACYOQggA4Exeh1A4HNaaNWsUDoddDyWnmGdxmQjznAhzlJjn6ZB3hQkAgIkjr1dCAIDiRggBAJwhhAAAzhBCAABnCCEAgDN5HUJ//OMfVV1drbPOOktz587V3//+d9dDGpfdu3frtttuU2VlpUKhkF555ZW082ampqYmVVZWqqSkRIsWLVJvb6+bwY5RS0uLrrvuOpWVlWnatGm6/fbbtX///rQ+xTDP9evXa/bs2d4nzOfPn6/XX3/dO18MczxRS0uLQqGQVq9e7R0rhnk2NTUpFAqltVgs5p0vhjke9/nnn+vee+/V+eefr9LSUl1zzTXau3evd97JXC1PbdmyxSZPnmybNm2yffv22apVq2zq1Kn26aefuh7amL322mv25JNP2ssvv2ySbNu2bWnnW1tbrayszF5++WXr6emxu+66yyoqKiyZTLoZ8Bj85Cc/seeee84++OAD6+7utltuucUuvvhi++abb7w+xTDP7du321//+lfbv3+/7d+/35544gmbPHmyffDBB2ZWHHP8vrffftt+8IMf2OzZs23VqlXe8WKY55o1a+yqq66yQ4cOeW1gYMA7XwxzNDP7z3/+Y9OnT7ef//zn9s9//tP6+vrsb3/7m3388cdeHxdzzdsQ+uEPf2jLly9PO3bFFVfYr371K0cjyq4TQ2h4eNhisZi1trZ6x44ePWqRSMQ2bNjgYITZMTAwYJKso6PDzIp3nmZm5557rj377LNFN8dUKmU1NTXW3t5u9fX1XggVyzzXrFljV199dcZzxTJHM7PHH3/cFixY4Hve1Vzz8p/jhoaGtHfvXjU0NKQdb2hoUGdnp6NR5VZfX5/i8XjanMPhsOrr6wt6zolEQpJ03nnnSSrOeR47dkxbtmzRkSNHNH/+/KKb44oVK3TLLbfopptuSjteTPM8cOCAKisrVV1drbvvvlsHDx6UVFxz3L59u2pra3XnnXdq2rRpmjNnjjZt2uSddzXXvAyhL7/8UseOHVM0Gk07Ho1GFY/HHY0qt47Pq5jmbGZ65JFHtGDBAs2cOVNScc2zp6dHZ599tsLhsJYvX65t27ZpxowZRTXHLVu26N1331VLS8uIc8Uyz3nz5mnz5s3asWOHNm3apHg8rrq6On311VdFM0dJOnjwoNavX6+amhrt2LFDy5cv18MPP6zNmzdLcvf9zLtHOXzf8Uc5HGdmI44Vm2Ka88qVK/X+++/rH//4x4hzxTDPyy+/XN3d3fr666/18ssva9myZero6PDOF/oc+/v7tWrVKu3cuVNnnXWWb79Cn+fNN9/s/fesWbM0f/58XXrppXr++ed1/fXXSyr8OUrfPauttrZWzc3NkqQ5c+aot7dX69ev189+9jOv3+mea16uhC644AKdeeaZI9J3YGBgREoXi+PVOMUy54ceekjbt2/XW2+95T0fSiqueU6ZMkWXXXaZamtr1dLSoquvvlrPPPNM0cxx7969GhgY0Ny5czVp0iRNmjRJHR0d+v3vf69JkyZ5cyn0eZ5o6tSpmjVrlg4cOFA030tJqqio0IwZM9KOXXnllfrss88kuft/My9DaMqUKZo7d67a29vTjre3t6uurs7RqHKrurpasVgsbc5DQ0Pq6OgoqDmbmVauXKmtW7fqzTffVHV1ddr5YplnJmamwcHBopnjjTfeqJ6eHnV3d3uttrZW99xzj7q7u3XJJZcUxTxPNDg4qA8//FAVFRVF872UpBtuuGHExyU++ugjTZ8+XZLD/zdzVvIwTsdLtP/0pz/Zvn37bPXq1TZ16lT75JNPXA9tzFKplL333nv23nvvmSRbt26dvffee17ZeWtrq0UiEdu6dav19PTYkiVLCq4U9IEHHrBIJGK7du1KK3n973//6/Uphnk2Njba7t27ra+vz95//3174okn7IwzzrCdO3eaWXHMMZPvV8eZFcc8H330Udu1a5cdPHjQ9uzZY7feequVlZV5P2uKYY5m35XZT5o0yZ566ik7cOCAvfjii1ZaWmovvPCC18fFXPM2hMzM/vCHP9j06dNtypQpdu2113plvoXqrbfeMkkj2rJly8zsuxLJNWvWWCwWs3A4bAsXLrSenh63gw4o0/wk2XPPPef1KYZ5/uIXv/D+bF544YV24403egFkVhxzzOTEECqGeR7/LMzkyZOtsrLS7rjjDuvt7fXOF8Mcj3v11Vdt5syZFg6H7YorrrCNGzemnXcxV54nBABwJi/fEwIATAyEEADAGUIIAOAMIQQAcIYQAgA4QwgBAJwhhAAAzhBCAABnCCEAgDOEEADAGUIIAODM/wHyl+DLqwmrUQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/doserbd/anaconda3/envs/spherinator/lib/python3.10/site-packages/torch/distributions/distribution.py:51: UserWarning: does not define `arg_constraints`. Please set `arg_constraints = {}` or initialize the distribution with `validate_args=False` to turn off validation.\n", + " warnings.warn(f'{self.__class__} does not define `arg_constraints`. ' +\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for batch in data_loader:\n", + " image = batch[\"image\"]\n", + " image = image.to(model.device)\n", + " image = functional.rotate(image, 0.0, expand=False)\n", + " image = functional.center_crop(image, [256,256])\n", + " input = functional.resize(image, [64,64], antialias=False)\n", + "\n", + " plt.imshow(input.cpu().numpy().squeeze().T)\n", + " plt.show()\n", + " \n", + " # dynamic binarization\n", + " input = (input > torch.distributions.Uniform(torch.tensor(0.0, device=model.device),\n", + " torch.tensor(1.0, device=model.device)).sample(input.shape)).float()\n", + "\n", + " plt.imshow(input.cpu().numpy().squeeze().T)\n", + " plt.show()\n", + "\n", + " _, (q_z, p_z), _, recon = model(input)\n", + "\n", + " recon_image = torch.sigmoid(recon)\n", + "\n", + " plt.imshow(recon_image.cpu().detach().numpy().squeeze().T)\n", + " plt.show()\n", + " \n", + " break" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spherinator", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test-bce-predict.py b/test-bce-predict.py deleted file mode 100644 index 4ad8c60..0000000 --- a/test-bce-predict.py +++ /dev/null @@ -1,34 +0,0 @@ -import matplotlib.pyplot as plt -import torch -import torchvision.transforms.functional as functional - -import data -import models - -if __name__ == "__main__": - - model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint( - "spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt") - - data_module = data.IllustrisSdssDataModule(data_directories=["TNG50"], num_workers=1, batch_size=1) - data_module.setup("fit") - data_loader = data_module.train_dataloader() - - for batch in data_loader: - image = batch["image"] - image = image.to(model.device) - image = functional.rotate(image, 0.0, expand=False) - image = functional.center_crop(image, [256,256]) - input = functional.resize(image, [64,64], antialias=False) - - plt.imshow(input.cpu().numpy().squeeze().T) - plt.show() - - _, (q_z, p_z), _, recon = model(input) - - recon_image = torch.sigmoid(recon) - - plt.imshow(recon_image.cpu().detach().numpy().squeeze().T) - plt.show() - - print("Done.") From 20d37579934ad9ffd803ea3ceeded5d60185b303 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 13:17:15 +0200 Subject: [PATCH 11/20] remove dynamic binarization --- .../rotational_spherical_variational_autoencoder.py | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index 6fb930c..fd1d847 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -68,7 +68,7 @@ def encode(self, x): if self.distribution == 'normal': z_var = F.softplus(self.fc_var(x)) elif self.distribution == 'vmf': - length = torch.linalg.vector_norm(z_mean, dim=1)+1.e-20 + length = torch.linalg.vector_norm(z_mean, dim=1) + 1.e-20 z_mean = (z_mean.T / length).T #z_mean = z_mean / z_mean.norm(dim=-1, keepdim=True) # the `+ 1` prevent collapsing behaviors @@ -104,8 +104,8 @@ def forward(self, x): z_mean, z_var = self.encode(x) q_z, p_z = self.reparameterize(z_mean, z_var) z = q_z.rsample() - x = self.decode(z) - return (z_mean, z_var), (q_z, p_z), z, x + recon = self.decode(z) + return (z_mean, z_var), (q_z, p_z), z, recon def training_step(self, batch, batch_idx): images = batch["image"] @@ -116,10 +116,6 @@ def training_step(self, batch, batch_idx): x = functional.center_crop(x, [256,256]) input = functional.resize(x, [64,64], antialias=False) - # dynamic binarization - input = (input > torch.distributions.Uniform(torch.tensor(0.0, device=self.device), - torch.tensor(1.0, device=self.device)).sample(input.shape)).float() - _, (q_z, p_z), _, recon = self.forward(input) loss_recon = self.reconstruction_loss(input, recon) @@ -134,12 +130,10 @@ def training_step(self, batch, batch_idx): losses[:,i] = loss_recon + loss_KL loss = torch.mean(torch.min(losses, dim=1)[0]) - self.log('train_loss', loss, prog_bar=True) self.log('loss_recon', loss_recon, prog_bar=True) self.log('loss_KL', loss_KL) self.log('learning_rate', self.optimizers().param_groups[0]['lr']) - return loss def configure_optimizers(self): From 0d45447e26711642a88311c4504c53bac7938e4c Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 13:45:16 +0200 Subject: [PATCH 12/20] visualize reconstructions of non-variational model --- experiments/illustris-svae-test.yaml | 12 ++-- experiments/illustris-test.yaml | 42 +++++++++++ test-bce-predict.ipynb | 34 ++------- test-predict.ipynb | 101 +++++++++++++++++++++++++++ 4 files changed, 154 insertions(+), 35 deletions(-) create mode 100644 experiments/illustris-test.yaml create mode 100644 test-predict.ipynb diff --git a/experiments/illustris-svae-test.yaml b/experiments/illustris-svae-test.yaml index 4ff4880..1008c94 100644 --- a/experiments/illustris-svae-test.yaml +++ b/experiments/illustris-svae-test.yaml @@ -38,9 +38,9 @@ trainer: accelerator: gpu devices: 1 precision: 32 - # logger: - # class_path: lightning.pytorch.loggers.WandbLogger - # init_args: - # project: spherinator - # name: illustris-svae-bce - # log_model: True + logger: + class_path: lightning.pytorch.loggers.WandbLogger + init_args: + project: spherinator + name: illustris-svae-bce + log_model: True diff --git a/experiments/illustris-test.yaml b/experiments/illustris-test.yaml new file mode 100644 index 0000000..56f155b --- /dev/null +++ b/experiments/illustris-test.yaml @@ -0,0 +1,42 @@ +seed_everything: 42 + +model: + class_path: models.RotationalSphericalAutoencoder + +data: + class_path: data.IllustrisSdssDataModule + init_args: + data_directories: ["/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/"] + extension: fits + minsize: 100 + batch_size: 32 + shuffle: True + num_workers: 8 + +optimizer: + class_path: torch.optim.Adam + init_args: + lr: 0.001 + +lr_scheduler: + class_path: lightning.pytorch.cli.ReduceLROnPlateau + init_args: + mode: min + factor: 0.1 + patience: 500 + cooldown: 500 + min_lr: 1.e-5 + monitor: train_loss + verbose: True + +trainer: + max_epochs: -1 + accelerator: gpu + devices: 1 + precision: 32 + logger: + class_path: lightning.pytorch.loggers.WandbLogger + init_args: + project: spherinator + name: illustris-test + log_model: True diff --git a/test-bce-predict.ipynb b/test-bce-predict.ipynb index b7b28eb..ca4ca61 100644 --- a/test-bce-predict.ipynb +++ b/test-bce-predict.ipynb @@ -14,7 +14,8 @@ "import models\n", "\n", "model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint(\n", - " \"spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt\")\n", + " # \"spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt\")\n", + " \"spherinator/iktq1u6p/checkpoints/epoch=8-step=4167.ckpt\")\n", "\n", "data_module = data.IllustrisSdssDataModule(\n", " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", @@ -25,12 +26,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -40,25 +41,7 @@ }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/doserbd/anaconda3/envs/spherinator/lib/python3.10/site-packages/torch/distributions/distribution.py:51: UserWarning: does not define `arg_constraints`. Please set `arg_constraints = {}` or initialize the distribution with `validate_args=False` to turn off validation.\n", - " warnings.warn(f'{self.__class__} does not define `arg_constraints`. ' +\n" - ] - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -77,13 +60,6 @@ "\n", " plt.imshow(input.cpu().numpy().squeeze().T)\n", " plt.show()\n", - " \n", - " # dynamic binarization\n", - " input = (input > torch.distributions.Uniform(torch.tensor(0.0, device=model.device),\n", - " torch.tensor(1.0, device=model.device)).sample(input.shape)).float()\n", - "\n", - " plt.imshow(input.cpu().numpy().squeeze().T)\n", - " plt.show()\n", "\n", " _, (q_z, p_z), _, recon = model(input)\n", "\n", diff --git a/test-predict.ipynb b/test-predict.ipynb new file mode 100644 index 0000000..b8ec507 --- /dev/null +++ b/test-predict.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torchvision.transforms.functional as functional\n", + "\n", + "import data\n", + "import models\n", + "\n", + "model = models.RotationalSphericalAutoencoder.load_from_checkpoint(\n", + " \"spherinator/ksl5gx72/checkpoints/epoch=10-step=5093.ckpt\")\n", + "\n", + "data_module = data.IllustrisSdssDataModule(\n", + " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", + " num_workers=1, batch_size=1)\n", + "data_module.setup(\"fit\")\n", + "data_loader = data_module.train_dataloader()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGfCAYAAAD22G0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1N0lEQVR4nO3df2zc9X348df518V2nEv4EZ89QmrAFEiAAmEhgZF0NJ4oQ0NIVQu0o5o0kQJtIjbBAtIwU7FDpkV0Ck2VrKIgyvIP0FGtLfHUYjZlrCElIyRdSL8YcCFXJ8E5O4lzZ9+9v39QTjWf1yv4bd/lfT4/H9VHKu97+33vz/mclz/+vO71ijnnnAAAEEBV6A0AAGYughAAIBiCEAAgGIIQACAYghAAIBiCEAAgGIIQACAYghAAIBiCEAAgGIIQACCYmlIt/N3vflf+8R//UQ4ePCiLFi2Sxx9/XP7kT/7kU78un8/LBx98IE1NTRKLxUq1PQBAiTjnZHh4WFpbW6Wq6lOudVwJbNu2zdXW1rqtW7e6ffv2uTVr1rjGxkb37rvvfurX9vf3OxHh4ODg4JjmR39//6f+mx9zrvgFTJcuXSpXXnmlbN68uTB28cUXyy233CLd3d2n/Np0Oi1z584t9pYAAKfZ0aNHJZFInHJO0e8JZbNZ2bVrl3R0dIwb7+jokB07dkTmZzIZGRoaKhzDw8PF3hIAIICJ3FIpehA6fPiw5HI5aW5uHjfe3NwsqVQqMr+7u1sSiUThWLBgQbG3BAAoUyXLjvtkBHTOqVFx3bp1kk6nC0d/f3+ptgQAKDNFz44766yzpLq6OnLVMzAwELk6EhGJx+MSj8eLvQ0AwDRQ9Cuhuro6ueqqq6Snp2fceE9PjyxfvrzYTwcAmMZK8jmh++67T772ta/JkiVLZNmyZbJlyxZ57733ZPXq1aV4OgDANFWSIPTlL39Zjhw5Iv/wD/8gBw8elMWLF8tPfvITWbhwYSmeDgAwTZXkc0JTMTQ09Kl55QCA8pdOp2XOnDmnnEPtOABAMAQhAEAwBCEAQDAEIQBAMAQhAEAwBCEAQDAEIQBAMAQhAEAwBCEAQDAEIQBAMAQhAEAwBCEAQDAlqaINnDZGC/tP72w/+dnF4Vc3WJsdM/ZdZjWJgVPiSggAEAxBCAAQDEEIABAMQQgAEAxBCAAQDNlxKCtWnpqV71X+WXCW0u08Zkw2c+ZIpkNAXAkBAIIhCAEAgiEIAQCCIQgBAIIhCAEAgiE7DkHErBQuI1XLqpMGjf5a2a846XEIhyshAEAwBCEAQDAEIQBAMAQhAEAwJCag5MwcBH12qbbhz7eG0DSlJYmUvDGe8trGjKf03YmWxELyRfniSggAEAxBCAAQDEEIABAMQQgAEAxBCAAQDNlxsHlmh9lZcGWU8aYxtmeWClLTuE7/OZoZX0VIBPMtq2Sdvz1becTz/ePV6M/z+1PK1xbjcSUEAAiGIAQACIYgBAAIhiAEAAiGIAQACIbsOHjWdpvMF5SQTwKb7yLmbKU2WXGSybyyr+zsPWttfXG/hC/f12rq64R4t1mvLTXoio8rIQBAMAQhAEAwBCEAQDAEIQBAMAQhAEAw3kHolVdekZtvvllaW1slFovJj370o3GPO+eks7NTWltbpb6+XlauXCl79+4t1n4xRbFYLHKcYrZxlHKD1hFTD+t/PmtYz6m9VjHPfVhreM9X9+H57bH2PsFzLKusyEB4WYrPOwgdP35cLr/8ctm0aZP6+IYNG2Tjxo2yadMm2blzpySTSVm1apUMDw9PebMAgMoSc1NoJh+LxeSFF16QW265RUQ+ugpqbW2VtWvXygMPPCAiIplMRpqbm+Wxxx6Tu+66K7JGJpORTCZT+O+hoSFZsGDBZLeET6Ff+fh+mKWEilZJ2aPStW8V7TJRykrP5hKT/+eiQhiftZrpL4shnU7LnDlzTjmnqPeE+vr6JJVKSUdHR2EsHo/LihUrZMeOHerXdHd3SyKRKBwEIACYOYoahFKplIiINDc3jxtvbm4uPPZJ69atk3Q6XTj6+/uLuSUAQBkrSdmeT/7Jxzln3gCPx+MSj8dLsQ0AQJkrahBKJpMi8tEVUUtLS2F8YGAgcnWEclKkex8h7q143EOy9mEvUYQCb94dPa1VlEesgnXmU078fkZpXxPP2WV1v8V6D0U3WVbbLmNF/XNcW1ubJJNJ6enpKYxls1np7e2V5cuXF/OpAAAVwPtK6NixY/Kb3/ym8N99fX2ye/duOeOMM+Tcc8+VtWvXSldXl7S3t0t7e7t0dXVJQ0OD3H777UXdOABg+vMOQq+99pp8/vOfL/z3fffdJyIid955p/zgBz+Q+++/X0ZGRuTuu++WwcFBWbp0qWzfvl2ampqKt2sAQEWY0ueESmFoaEgSiUTobVSsU1dImOri1nCIe0IT38d0vSfk/5Nbys+4zJR7QgblRZwO2y61iXxOiKZ2053vvekS8npO7337ftBUG7MmlzJIejaB8/j8qd8HdUWckcigb9GzAZ7Z1U9ntYzzmHyKBzwCQrEihc9nwDEOBUwBAMEQhAAAwRCEAADBEIQAAMEQhAAAwZAdN10UK5ts6k/pn/GlTvfJ1LJTy33HNb5tC5xaEqg4zEo82gPGXK/SP+b8YrTOsL9C/2RIsV5Fj1S14lQhUhey3oJl9qmY4LgSAgAEQxACAARDEAIABEMQAgAEQxACAARDdtw0UcosOIt3zzSTltnlmx2n/74Uq9K/oMonO87l1fG8lSGmZDf5Fob1yyUTUU/TeM68ldVnjGvnYzKm5u1UMH38NNdaM5PgAiSq+b5UlY4rIQBAMAQhAEAwBCEAQDAEIQBAMAQhAEAwZMeVIT1xyLeW18QXD5F5Z6dCGVlwRsvRKq+sOSvbbeJZcCJGlpmR8mRl6TmzYtvUa+HFrGy/nD6u7cS/c3i5p3YVrUhcEZgFAvXxcn9pp4grIQBAMAQhAEAwBCEAQDAEIQBAMCQmlKHT3e6rWKv7VK7xf0YrYcFICKiqVsbMmkD6eF6/I5xXbvybCQX6ypL3TEyoro6O5/U8A4nlPc9H3Ye1hE8LPM976r5vCq/FjX1biSNllGhR6WV+uBICAARDEAIABEMQAgAEQxACAARDEAIABEN2XDkqQrKalfWjjprPV8qyPcYzGk9pZbZVV+u/R1XX1kbHaqJjH62tr+HyY+p4fkwfV1mJakYJnZixF+08rQyusVFj305fu0rJmjMb4FmlZXzz46yOiR6cV5mbcirbo7MyI8tpj6XAlRAAIBiCEAAgGIIQACAYghAAIBiCEAAgGLLjypCdJaPMtbLgPDLe7IZpRcrKUda3mr1VV0drvomI1NTo49XGeI2SCVfX0KivUVenjudOHtfHMyejg1ZZOuMBV6f//ldbq/9IOrVQnP79GTUy7Kzvc07J1Mvlc+pci5VNl88be1H2bjX6M/PxitIDrkgN5nyS/bx/rDz2OA0T6bgSAgAEQxACAARDEAIABEMQAgAEQxACAARDdtxM49X91Ez5MsatTD0lO86qkWZku1UZNeK0DqoiIrV10bd2fJaeBVcXj6vj+Rr9fLLKU8aNDLtZ9bP0tY3aaVZttpHjI5GxMaOGnW+30FgsmglndWfNiZ41p3WbFRGJqX1bjSavVmaXsW9ndbNVXkPfLqS+730rsw+fjishAEAwBCEAQDAEIQBAMAQhAEAwXkGou7tbrr76amlqapL58+fLLbfcIvv37x83xzknnZ2d0traKvX19bJy5UrZu3dvUTcNAKgMXtlxvb29cs8998jVV18tY2Nj8tBDD0lHR4fs27dPGhs/qsu1YcMG2bhxo/zgBz+QCy+8UL797W/LqlWrZP/+/dLU1FSSk5i2fOpNeTaitDKH1N86PDurWqXmYjGrK6hHdpxRO67amm/UWtNqsDXUGZl0tfoJ1dbXq+NudjTjbe5ZZ6hza4zzyeX0LLOTI0pdOhGpb4ju5fjQsL5GJquOjxodV7Ud1hj/NGRjo+r42Jh+PjkrI09JmvPNYPMp5GZlHfo/p/WM2nvIWNwze9F8TiXDcjpm6cWc75n/gUOHDsn8+fOlt7dXrr/+enHOSWtrq6xdu1YeeOABERHJZDLS3Nwsjz32mNx1112fuubQ0JAkEonJbml68Sl66Vkg03qjq12yzVbgAYJQjf6PnxmE6vSW3fVKAGlqmq3OrTXWqK2x2n5Hf2RKHYQymUxkzDcIHRs2CrIqe7G+99lRzyCU0wOf9hrm1bxt+x9nv3+6ShuEfJ7T+mH2/qdYrV9aXkEonU7LnDlzTjlnSveE0um0iIicccZHP4B9fX2SSqWko6OjMCcej8uKFStkx44d6hqZTEaGhobGHQCAmWHSQcg5J/fdd59cd911snjxYhERSaVSIiLS3Nw8bm5zc3PhsU/q7u6WRCJROBYsWDDZLQEApplJB6F7771X3njjDfnXf/3XyGOf/MS2c878FPe6desknU4Xjv7+/sluCQAwzUyqbM83v/lNefHFF+WVV16Rc845pzCeTCZF5KMropaWlsL4wMBA5OroY/F4XOJG2ZRK59W8znvtiZc68azCIzHr/oxHKZ5qowxPjXFPyCrPEzfu58yZE02CaUroiTGJeXPV8aaE/rfsYx8ejow1/8HPwR+aNUsv23P8+DF1fOiYfs/lWHowMpbN6HNHc/r3Pm4kWoxlo/eQYurNQ7HL1lj3M5xxT0wp86OVD5oMfSt+ZZKKc6/IuPdTjKWt5cvrltCEeF0JOefk3nvvleeff15+/vOfS1tb27jH29raJJlMSk9PT2Esm81Kb2+vLF++vDg7BgBUDK8roXvuuUeeffZZ+bd/+zdpamoq3OdJJBJSX18vsVhM1q5dK11dXdLe3i7t7e3S1dUlDQ0Ncvvtt5fkBAAA05dXENq8ebOIiKxcuXLc+JNPPilf//rXRUTk/vvvl5GREbn77rtlcHBQli5dKtu3b+czQgCACK8gNJE89lgsJp2dndLZ2TnZPQEAZghqxwEAgqGpXcUqRuadVUnBmG02tYv+rmNVErDK9sTjepZZ8lw9K23e2WdFxmpn6RUTzj5H/2za/PMuVMdPjEbPs3bshDo33qhn2NW+v18db1WqS4iIXFTfFhn79/f/nzq37/X/Vscbc3qDueFD70fGckZlhJzRSM/6vvlUO3BGoz/rDzBW9qa6hpU2ZjxnKdPM7MxVP1ModlNWuBICAARDEAIABEMQAgAEQxACAARDEAIABEN23Gngk8VT6rW1DDYrq81Og/N8TiXvp8rIppozT+/Lkzh7vjo+L6nXJFx4yWWRsabW89S5dfWN6viJQ3ox3bq5rdHBD6O13UREasf01iRzGvVsvzrjJzJVOxIZO/f8i9S5VmbbkXf2qePZdLT+Xlap7SYiUltXp45bvYDyRt+knNYyy+qBZfyqbD2nuoyVeWfkpFl7KUZGWrFy2rQ9TseMOa6EAADBEIQAAMEQhAAAwRCEAADBEIQAAMGQHTcZnslkvulkZrZaEdZQR825VhtNY9isExYdqzO66c6/YJE6fvHSz6vjf3RWtEaciEgmOxAZyx6LdkQVEcme+FAdz5/QM9uGP4jWfXNGppbU6z9i2aZoLTgRkfix6L5FROaeEc2mS8b1TqnDjfrvlqOz9Yy8bFNDZGykRv/eW6c5mtUz8sxcrSJkcVkdftX3oVmAzljc2t7pLzXnp9z3p+BKCAAQDEEIABAMQQgAEAxBCAAQDEEIABAM2XGTUpxicD6r2AlzvntRasf5Lm3WmtPHq5V6Y/OSSv01ETlr4WfU8YSR3vOZ6oXq+M/felnZSLRGmojIrGp97dn6dMmNZSNjNcYaMTE6xR59S1/bmP+hkqnXcEa0npyIyNy4/n0Ybf+cOp4dPhoZGzM6qMbr9FpwmVr9n5IqI4NN67Ybi+n16kw+GXaeWWN2J9aJP2WRtuKnjLPgLFwJAQCCIQgBAIIhCAEAgiEIAQCCITFhEorWo863mZy6hFFyxy93QFVlJRoYDelqjJvT8fpoWZiGeXqTutzIMXX8yGH9Rv5rtfqd2LnzEtH9/VG00Z2IyOi7v1LHG2tOquNN8eh5zqrTsxiqGqL7EBEZO3lcHT+eUYclfSgVXbtWf86a2XpjwLPPvlQdn10dfdK+N/9XnXvk4AfqeM5IEhgzGuzllMQHZzWeM0vueLyZi9XsrdzL4pT7/hRcCQEAgiEIAQCCIQgBAIIhCAEAgiEIAQCCITvudPBMpzObyRWFUranSn++qmr9dxQrC67WyBCbFY+Ojwz+Tp176MSgOp6br2fTnXFUbwIXn90UGWs60avObYrr51mvlBsSEalrmB0Zm9ugvyZjo3qZm5ozomuIiHz4YVodr54bnZ/J6pmEtdV6o7+6dLQZn4jIaGM0g+/M8/TmglbzupzR7e7YsL5HLcMyb2SwVRm/K1vztUw4V6TudTFrvjLdTsgrXQpbrHTVhkqGKyEAQDAEIQBAMAQhAEAwBCEAQDAEIQBAMGTHfQqf8lTmGt5foeSyeG7Ep6acNdeqHWc1Kquq1t9O9bPnRMZmzZmrzq011ojVR9cQEalrjKvjc89pi66R1zO76mr0Zmqzq/XMrlmzlAzDumh9PBGReU1GTbUx/TnPPmuuOt7YMCsy9uFRfX8ns3qzO6uO3VkXXBEZy57Yoc6tbYhmHYqI1NQZWX01xvdTeQ8VJ3/NyoQrbX5YiOyzcs5488GVEAAgGIIQACAYghAAIBiCEAAgGIIQACAYsuNOC9/8OCX7ypppZs0Z2XFKnTi7Vp3R6dKYbT1y8kQ0i6t2OJrtJSIy75Ir1fHmcxeq44l4Vh2vnzMvMjY6+Ft1btyowZaYP1cdn3dmdO24UTdv7OQJdby6Xv/9bySjd60dORnt8lpfr2cG5o5/qI6frGlUxzP9b0cH57Sqc5ua9Sy4Y0f0WoDFqILojPeV9T7UO7GWOJfMY3mzU6yn058DWBpcCQEAgiEIAQCCIQgBAIIhCAEAgvFKTNi8ebNs3rxZ3nnnHRERWbRokfz93/+93HjjjSLy0Q23Rx55RLZs2SKDg4OydOlSeeKJJ2TRIr1BVhDGndJSNpKzbqwW5zmNta2yPcrvHVZTO2u8xijFEp+lJxu4XLRcTub4kDq3OXm2Op44W2/UFlcazImI1A6+FRmbVxu9uS8iUluln09TvZ5s0HhGdC9z6/QyPHU1eqkcSR9ShweMvWQS0XI5NdV60kPOKAmUO3lEHT8+Fn1PnPmZy9W5h/v71HGjp53kc/peJK+NGz8PZu86K2FBaWo38f53p3xSn/klTxIoUoJDaF5XQuecc46sX79eXnvtNXnttdfkT//0T+Uv/uIvZO/evSIismHDBtm4caNs2rRJdu7cKclkUlatWiXDw8Ml2TwAYHrzCkI333yzfPGLX5QLL7xQLrzwQnn00Udl9uzZ8uqrr4pzTh5//HF56KGH5NZbb5XFixfLU089JSdOnJBnn322VPsHAExjk74nlMvlZNu2bXL8+HFZtmyZ9PX1SSqVko6OjsKceDwuK1askB079Iq8IiKZTEaGhobGHQCAmcE7CO3Zs0dmz54t8XhcVq9eLS+88IJccsklkkqlRESkubl53Pzm5ubCY5ru7m5JJBKFY8GCBb5bAgBMU95B6LOf/azs3r1bXn31VfnGN74hd955p+zbt6/w+CdviDvnTvGpfpF169ZJOp0uHP39/b5bAgBMU95le+rq6uSCCy4QEZElS5bIzp075Tvf+Y488MADIiKSSqWkpaWlMH9gYCBydfSH4vG4xON6+ZGS8O2QVUpez+m3QZ8sHi1j7tTPqC9uZs3F6yJj1TV6eZpD7xzQ95I9ro7PUUroiIjEXLSx27x6/TnnztUbtc2eXa+ON45G/2ScmK1n6Z1VpWewDZzZoo435fS/Ggxloq/5yFEjO65W/3kaNUoIXTT7jyJjRw/9P33t9PvqeGZEb6QXs7I3q6PvuSor280az+XUcV2pM8mUn5YiZa9Z2bWVYsqfE3LOSSaTkba2Nkkmk9LT01N4LJvNSm9vryxfvnyqTwMAqEBeV0IPPvig3HjjjbJgwQIZHh6Wbdu2ycsvvyw/+9nPJBaLydq1a6Wrq0va29ulvb1durq6pKGhQW6//fZS7R8AMI15BaHf/e538rWvfU0OHjwoiURCLrvsMvnZz34mq1atEhGR+++/X0ZGRuTuu+8ufFh1+/bt0tSk/7kDADCzeQWh73//+6d8PBaLSWdnp3R2dk5lTwCAGYLacQCAYGhqdxqYWWYemXp2Iyyj7pv5pEVIAzQKhcWMPeaV+TGjpli+Ua8dN5I36tilB9Xx6qponbhjRjJVnZGplztD/zNyVa3yY9N0pjq3PqZ/+Lp+QG88N2h8f2rqohmGblRv6BfLRmv1iYi4mH6e+yXa1C82X28umM3qHzw/+uFRdTyn1ogTqapSsuNixnvCeDPbCaATrx03PdvAVRauhAAAwRCEAADBEIQAAMEQhAAAwRCEAADBzLjsON96aMUpKjf1NU5RA9ZgdZ1UMpCMrKnqGr2zaMyoEZeP6b/T5MbGomvX6V1Yh/veUMfr/yha30xEpKpZz6bTsq9cQq/XVhfXO66OGVmAJ0aiWWkNRw+rc/uNbrNZp79W2Sq97lu+Kvp9SyT0enUn9W+njA19oI67XLTu28nU/+lrD6fV8aqYX9039e1sNlb1botaOtbPobIV62fWd9vmU2oPTMNkP66EAADBEIQAAMEQhAAAwRCEAADBEIQAAMHMuOw4NaPkFErY/NRrvpm75/mcWmaOM+p7WVlJ+TG9CNvJY9EaZCIiNUqtNbX+moicGDqqjsc+06avnZivj8+Krj9y1OhaOltPJ6uafZY6Xh+LZtN9+KH+GtaLnjU3lNFfw2Mn9XVGRqPzB4f0TqlDg/r3YcSoB1dfG/1d9Ni7b6pzjx/Va95lrXp1RipYlfLGrTKyK4uSn+pZS9H8ebO6vHqs7Z/CZtSHVNaZhslxXAkBAMIhCAEAgiEIAQCCIQgBAIKZcYkJ1p27mH9dnOgaU17hVGtbNyd914mybh6PZfWmaa5av5Ef00oCiYhz0fGaEb1UTt5IWPiw7y11fG5Tozo+b8XXI2N1Q/v1/R3+X3V85PBv9b0o5XJcrXEDPq/fsD9p3MivqtXL9gwdi75ex0/o35+TY8Z7JasnMtTNjpYzGjzYr849MnBIHc+c1PeSsxogaj9v1pvZ+NmMVRnjHtlHXmWFRMSZTSQ9GukVK19BWUjbxyn3Uga4EgIABEMQAgAEQxACAARDEAIABEMQAgAEM/Oy4wzFaWnnW0PHZxmrXIjZCUyVV9JkzFIkHmucarxKKQuUG9OzqbInow3WREQy2QZ1PJ0eUsfPPBEtl1PdcI469+jwL9XxebP1H4/DQ8cjY4lGvQxPrFpfY9TIGhs+pJfF0bLphk/oGYYjx43Mw7E+dfzgwd8o+9Ab4ElOP08jUU3yOStjMnr+1vvHeiOa0yc4dirm/CI0qitaclyF4EoIABAMQQgAEAxBCAAQDEEIABAMQQgAEAzZcb9XjLpvVhM4e22roZbWec6vdpwzakhpw3ZWjlX3y5ht1QmrjX5BTZVef662plYdrzLSr4YPva+Op/77R5Gxtkv1pm5Zo0nf0bSeZVZbG93jSHZMnTt7tl7b7tgxPQvwyKCe7afVlDty6Kg6d7SuSd9L62J9/r7/jIyljw6rc3NGGtiokQU3atQfzCvvlbxSY1DEL8PuowfUyfrcYqS7GauUVbZbGafkcSUEAAiGIAQACIYgBAAIhiAEAAiGIAQACIbsuN+zM9s88uZ8M018MlaMbDffIld6kp1VC85Y2shWsuRdNJvMGdlxOaXO3Kn2ksno808OR7O7ai/4ojp3dFjvFnp0QO8uWn08unbN8Yw6N3UwWsNORGRsTN/38RF9nVn10dp58aZoh1cRkeyY3p312HH9OY8ei467Oa362oeOqOOjo3qn2Lz1/dSy48zvvV9NOZ1HJuoplXvn0uJk+51OXAkBAIIhCAEAgiEIAQCCIQgBAIIhMeFj1r1PJSHAK1nBXtq8WRhT6uL4Vh0pRhki+0Uxho3sgdxotKTNqNKk7aM19PI31g3kmpq0Ol5bF31r9/3kn9S5s2L6c9YvvlkdP/rfz0bGYnmjxM8sPUlgxGhIZ53/yZro+TRe8nl1btxYu0mvoCPvDkVLCJ343XvqXCuhwjd3QEs2sMvwFK0l3ZQVY+XSpgiUbwKChSshAEAwBCEAQDAEIQBAMAQhAEAwBCEAQDBTyo7r7u6WBx98UNasWSOPP/64iHyU4fLII4/Ili1bZHBwUJYuXSpPPPGELFq0qBj7Pe2Kk2VmLV7K1T3KEHmXGzJ+dzHOJ6eU+clm9fI0TinxIyJSdVJP7aqbN08dHxqMZs0dene/Ovcziz6njucG39Wfc0G0OVx1+h117kjNmep4Y+NxdXzI6Q3pjqei69dU6+deM/8Mdfz8YT2zrW/em5Gx9379mjo3N2ZlNepra5meH33BxLPj7LenR2qo0TDPTgD1LZM1cSXtLzf9kuMmfyW0c+dO2bJli1x22WXjxjds2CAbN26UTZs2yc6dOyWZTMqqVatkWKnlBQCY2SYVhI4dOyZ33HGHbN26Veb9wW+izjl5/PHH5aGHHpJbb71VFi9eLE899ZScOHFCnn02+tkKAMDMNqkgdM8998hNN90kX/jCF8aN9/X1SSqVko6OjsJYPB6XFStWyI4dO9S1MpmMDA0NjTsAADOD9z2hbdu2ya9+9SvZuXNn5LFUKiUiIs3NzePGm5ub5d139b+vd3d3yyOPPOK7DQBABfC6Eurv75c1a9bIM888I7NmzTLnffJmpHPOvEG5bt06SafThaO/X+/hAgCoPF5XQrt27ZKBgQG56qqrCmO5XE5eeeUV2bRpk+zf/1H2USqVkpaWlsKcgYGByNXRx+LxuMTjen2tcqAl7BQrqS1m1cRSnqCkeXRWVpI5btQPyxmNw5T+dbmx3MQ2V1jEeM7BQXV8Vn30l6Q5c+rVuccOva+v0dCijsvIh5GhjHHu8Wa9Odwx48/Os84+Xx3PxaIv4u92/lidWzX/YnX8jV0/V8cPvbc3Mnb82Al17uiYXtsubzQ6tBrVae8ts3acwZrtu06phNhHeZy5H68roRtuuEH27Nkju3fvLhxLliyRO+64Q3bv3i3nnXeeJJNJ6enpKXxNNpuV3t5eWb58edE3DwCY3ryuhJqammTx4vGfkWhsbJQzzzyzML527Vrp6uqS9vZ2aW9vl66uLmloaJDbb7+9eLsGAFSEordyuP/++2VkZETuvvvuwodVt2/fLk1N+ofwAAAz15SD0Msvvzzuv2OxmHR2dkpnZ+dUlwYAVDhqxwEAgqGz6iRYdaXsDDYja8ynK2qR0uPUrCRrspHxZCb9VBm/0ygdV8dyenZcrEo/0TEj+0xO6jXo8vno+r99T8+COz58TB1v+m1KHc+56HnWVukvSr5Pf86as85TxzOpo+p4+v+iH/ZO/+6gOjc7+hN1fCyrd1xVO9+aWXD6903rlCpyihpsHnlcdpLZxOu72c9WrHwyLY22tE9pv7bTC1dCAIBgCEIAgGAIQgCAYAhCAIBgCEIAgGDIjpsMKynFN4OtWOuoS1sdLX3WMLIAfTtgqp0ujee0ao0ZmXdjVhaXkh2XzejdWTMn9DpphweOqON1dXWRseoapUCeiGSM58y5/1PHXV4/n7FsdJ3sqL62U7IRPxrXX1ut861VCy5nrG2msPm8KcxsMquGobW2T3rcxDu/eita8lrpuryWA66EAADBEIQAAMEQhAAAwRCEAADBkJgwCZ73T72b4KkJAUaNn1jM76altoy5hLFx+36wUbpGuZntYkZTu1HPxmbWa66U/6mO6b9znTRuttcYN+fHctHkAWfMzWRG1XGr4VlNrf4jmVOSCkZP6okJUq2fp5WwMKY0GLSb0enjJuO9X6UkmphJKb7v8YlvwztfwXzOouQx+JYDqwxcCQEAgiEIAQCCIQgBAIIhCAEAgiEIAQCCITtuEvwTYYpRn8cqXTL1rDmzuZ7Zj8zai/EFRtaTZlT0uXkjK6vabKQXPakxZ2TkGa9tba5WHa9RmsBZrDI31muVN8oQaY0B89b7ysjUszLetEZ1ZpM6szxPETq4WZmO1nSPp/T+mfVtpFecxfXZFVKex8KVEAAgGIIQACAYghAAIBiCEAAgGIIQACAYsuNOA+/cOLX4lV8FKTOjxqt2nLW2Z+aUNtfM9tPn22dvZQdGx6wMO/MblNUz1XJV0fGYUZfO/L5ZdfmszDv1hfFryJZTsuBE9Ew4OwvOekq/mnLa8vb7ylrEc3zqk2USVeiUmSVspDcNcSUEAAiGIAQACIYgBAAIhiAEAAiGIAQACIbsuGnCyhyK+bdtjQ4VoXOliJ0hZdW385Gzsq+MYe11MUvbmZldVrZWdXSwyqhLZ9aO83lGPSerSukee6o1rM6qakfTqb+tfv/AxM/ffv8Ya0xgX582205I850/1ckzF1dCAIBgCEIAgGAIQgCAYAhCAIBgSEw4HTzL4vi1ujMSFnxW8b05a6ydN258q3zP3cgdyBl7rFKSLaz9+ZaLqVUSAmJO/30uZzWSsxr9WWWLlEQLewkjYcH4Av38rdIy+rDvjXztOe25xXlOH0VZowh9/mYCroQAAMEQhAAAwRCEAADBEIQAAMEQhAAAwZAdF5KVlaVkQnk1wBO7FI/RAk5fwztrTqdVFvKsFGSOVxkZX1oRHbucjb6G9Rtabkz5/lRZJXE8x43njBUhXUtrXmeJWfvzzviyztOnkZ5v2R5l7YlPnRQ1S5UsuAnhSggAEAxBCAAQDEEIABAMQQgAEAxBCAAQjFcQ6uzslFgsNu5IJpOFx51z0tnZKa2trVJfXy8rV66UvXv3Fn3TFc+56OG9hn7oSxuTzaX1/9nP6Up25D0OlzcO43XJ5516jOVykSM3Zhz5vHrYe8zrh89rks+rh7m28prkXV49fPdnnaf+RtQPv3en19KToC8UE4kcmBjvK6FFixbJwYMHC8eePXsKj23YsEE2btwomzZtkp07d0oymZRVq1bJ8PBwUTcNAKgM3p8TqqmpGXf18zHnnDz++OPy0EMPya233ioiIk899ZQ0NzfLs88+K3fddZe6XiaTkUwmU/jvoaEh3y0BAKYp7yuhAwcOSGtrq7S1tclXvvIVefvtt0VEpK+vT1KplHR0dBTmxuNxWbFihezYscNcr7u7WxKJROFYsGDBJE4DADAdeQWhpUuXytNPPy0vvfSSbN26VVKplCxfvlyOHDkiqVRKRESam5vHfU1zc3PhMc26desknU4Xjv7+/kmcBgBgOvL6c9yNN95Y+P+XXnqpLFu2TM4//3x56qmn5JprrhGRaPMt55zakOtj8Xhc4vG4zzYAABViSrXjGhsb5dJLL5UDBw7ILbfcIiIiqVRKWlpaCnMGBgYiV0fwZ9XVOlWAn/ja+njMLPBm1Jqz6tUp830Tk+ySZROvkWfXpfMsZKfUVcv5tor1fAF8apN5n09RipwZbV6tZyxGqbVitD8t0lOSDTd5U/qcUCaTkV//+tfS0tIibW1tkkwmpaenp/B4NpuV3t5eWb58+ZQ3CgCoPF5XQn/7t38rN998s5x77rkyMDAg3/72t2VoaEjuvPNOicVisnbtWunq6pL29nZpb2+Xrq4uaWhokNtvv71U+wcATGNeQei3v/2t3HbbbXL48GE5++yz5ZprrpFXX31VFi5cKCIi999/v4yMjMjdd98tg4ODsnTpUtm+fbs0NTWVZPMAgOkt5swmHmEMDQ1JIpEIvY1poxj3hOy1zUc8h6e+R/M8PYbNe0LW/Tar+5I6XNp7Qj4n5H9PqBj8FtfvCfk2mfLtMzR19nvl9O5jukin0zJnzpxTzqF2HAAgGDqrTnN2dljpsuas3/Gs59T26HuVZXYcNcb1vXv+tm51BVWG7c63RcoD9FjGvKKwvyCAImT7lZHy32H54koIABAMQQgAEAxBCAAQDEEIABAMiQnTnWfygFNufBcvy3vi6QPm/Xqz9I/fM2rPaa1RDPbN8+IkQxQj0SSMiSd3YGbiSggAEAxBCAAQDEEIABAMQQgAEAxBCAAQDNlxFcpOPoo+Yje188vI8muO51eexqdhnrVQSQtblrhoaDFKH51q9Yk7/Vl6PuWgioXkvdOHKyEAQDAEIQBAMAQhAEAwBCEAQDAEIQBAMGTH4RR8W8mVkG/W3NSXLuIXlIaZjWjVa/N4Ueycw2LV9isX03bjFYMrIQBAMAQhAEAwBCEAQDAEIQBAMAQhAEAwZMfBVKzcOI/Kcf7KJLnJ7ohaSlZNNYPHi+L7+pX29Q6QqmYV5qMlbNFxJQQACIYgBAAIhiAEAAiGIAQACIYgBAAIhuw42EqaHuebZRSgXp1HVlaxaqeZXUTVJ/DLyLO/ndpXlE/dwFImpNlrkwV3unAlBAAIhiAEAAiGIAQACIYgBAAIhsQEBGHeEDbvqnvehFfKrti31I0mcNZXlPBOuVX+p7QldzwSMLwTSjz2UbSlowuRZlC+uBICAARDEAIABEMQAgAEQxACAARDEAIABEN2HCahhCVdPNOY7KorxciQmsE5VZXW02267nsG4EoIABAMQQgAEAxBCAAQDEEIABCMdxB6//335atf/aqceeaZ0tDQIJ/73Odk165dhcedc9LZ2Smtra1SX18vK1eulL179xZ10wCAyuAVhAYHB+Xaa6+V2tpa+elPfyr79u2Tf/qnf5K5c+cW5mzYsEE2btwomzZtkp07d0oymZRVq1bJ8PBwsfeOQJwzDuN/oh4oa2X1bdM3Y/5PeW+ijDkPDzzwgLvuuuvMx/P5vEsmk279+vWFsZMnT7pEIuG+973vTeg50um09fbnKPcjph8x9YhxcEzw0N9D1vst+M8BR+FIp9Of+m++15XQiy++KEuWLJEvfelLMn/+fLniiitk69athcf7+voklUpJR0dHYSwej8uKFStkx44d6pqZTEaGhobGHQCAmcErCL399tuyefNmaW9vl5deeklWr14t3/rWt+Tpp58WEZFUKiUiIs3NzeO+rrm5ufDYJ3V3d0sikSgcCxYsmMx5AACmIa8glM/n5corr5Suri654oor5K677pK//uu/ls2bN4+bF/tELxfnXGTsY+vWrZN0Ol04+vv7PU8BADBdeQWhlpYWueSSS8aNXXzxxfLee++JiEgymRQRiVz1DAwMRK6OPhaPx2XOnDnjDgDAzOBVO+7aa6+V/fv3jxt76623ZOHChSIi0tbWJslkUnp6euSKK64QEZFsNiu9vb3y2GOPFWnLKFvOZ9iYDHyS8VcU0t4qxIRS1n7vl7/8paupqXGPPvqoO3DggPvhD3/oGhoa3DPPPFOYs379epdIJNzzzz/v9uzZ42677TbX0tLihoaGyI7j4ODwP2Ix/Qi9L45PPSaSHecVhJxz7sc//rFbvHixi8fj7qKLLnJbtmwZ93g+n3cPP/ywSyaTLh6Pu+uvv97t2bNnwusThDg4OMYdBKFpe0wkCMWcK69r2qGhIUkkEqG3AaBc8Oe4aSudTn/qfX5qxwEAgqGpHYDyxhVPReNKCAAQDEEIABAMQQgAEAxBCAAQDEEIABAMQQgAEAxBCAAQDEEIABAMQQgAEAxBCAAQTNkFoTKrpwoAmKSJ/HtedkFoeHg49BYAAEUwkX/Py66VQz6flw8++ECamppkeHhYFixYIP39/RXd9ntoaIjzrCAz4TxnwjmKcJ6T5ZyT4eFhaW1tlaqqU1/rlF0V7aqqKjnnnHNERCT2+z4ic+bMqeg3wMc4z8oyE85zJpyjCOc5GRPtC1d2f44DAMwcBCEAQDBlHYTi8bg8/PDDEo/HQ2+lpDjPyjITznMmnKMI53k6lF1iAgBg5ijrKyEAQGUjCAEAgiEIAQCCIQgBAIIhCAEAginrIPTd735X2traZNasWXLVVVfJf/7nf4be0pS88sorcvPNN0tra6vEYjH50Y9+NO5x55x0dnZKa2ur1NfXy8qVK2Xv3r1hNjtJ3d3dcvXVV0tTU5PMnz9fbrnlFtm/f/+4OZVwnps3b5bLLrus8AnzZcuWyU9/+tPC45Vwjp/U3d0tsVhM1q5dWxirhPPs7OyUWCw27kgmk4XHK+EcP/b+++/LV7/6VTnzzDOloaFBPve5z8muXbsKjwc5V1emtm3b5mpra93WrVvdvn373Jo1a1xjY6N79913Q29t0n7yk5+4hx56yD333HNORNwLL7ww7vH169e7pqYm99xzz7k9e/a4L3/5y66lpcUNDQ2F2fAk/Nmf/Zl78skn3Ztvvul2797tbrrpJnfuuee6Y8eOFeZUwnm++OKL7t///d/d/v373f79+92DDz7oamtr3Ztvvumcq4xz/EO//OUv3Wc+8xl32WWXuTVr1hTGK+E8H374Ybdo0SJ38ODBwjEwMFB4vBLO0TnnPvzwQ7dw4UL39a9/3f3P//yP6+vrc//xH//hfvOb3xTmhDjXsg1Cf/zHf+xWr149buyiiy5yf/d3fxdoR8X1ySCUz+ddMpl069evL4ydPHnSJRIJ973vfS/ADotjYGDAiYjr7e11zlXueTrn3Lx589y//Mu/VNw5Dg8Pu/b2dtfT0+NWrFhRCEKVcp4PP/ywu/zyy9XHKuUcnXPugQcecNddd535eKhzLcs/x2WzWdm1a5d0dHSMG+/o6JAdO3YE2lVp9fX1SSqVGnfO8XhcVqxYMa3POZ1Oi4jIGWecISKVeZ65XE62bdsmx48fl2XLllXcOd5zzz1y0003yRe+8IVx45V0ngcOHJDW1lZpa2uTr3zlK/L222+LSGWd44svvihLliyRL33pSzJ//ny54oorZOvWrYXHQ51rWQahw4cPSy6Xk+bm5nHjzc3NkkqlAu2qtD4+r0o6Z+ec3HfffXLdddfJ4sWLRaSyznPPnj0ye/Zsicfjsnr1annhhRfkkksuqahz3LZtm/zqV7+S7u7uyGOVcp5Lly6Vp59+Wl566SXZunWrpFIpWb58uRw5cqRizlFE5O2335bNmzdLe3u7vPTSS7J69Wr51re+JU8//bSIhPt+ll0rhz/0cSuHjznnImOVppLO+d5775U33nhD/uu//ivyWCWc52c/+1nZvXu3HD16VJ577jm58847pbe3t/D4dD/H/v5+WbNmjWzfvl1mzZplzpvu53njjTcW/v+ll14qy5Ytk/PPP1+eeuopueaaa0Rk+p+jyEe92pYsWSJdXV0iInLFFVfI3r17ZfPmzfKXf/mXhXmn+1zL8krorLPOkurq6kj0HRgYiETpSvFxNk6lnPM3v/lNefHFF+UXv/hFoT+USGWdZ11dnVxwwQWyZMkS6e7ulssvv1y+853vVMw57tq1SwYGBuSqq66Smpoaqampkd7eXvnnf/5nqampKZzLdD/PT2psbJRLL71UDhw4UDHfSxGRlpYWueSSS8aNXXzxxfLee++JSLifzbIMQnV1dXLVVVdJT0/PuPGenh5Zvnx5oF2VVltbmySTyXHnnM1mpbe3d1qds3NO7r33Xnn++efl5z//ubS1tY17vFLOU+Ock0wmUzHneMMNN8iePXtk9+7dhWPJkiVyxx13yO7du+W8886riPP8pEwmI7/+9a+lpaWlYr6XIiLXXntt5OMSb731lixcuFBEAv5slizlYYo+TtH+/ve/7/bt2+fWrl3rGhsb3TvvvBN6a5M2PDzsXn/9dff66687EXEbN250r7/+eiHtfP369S6RSLjnn3/e7dmzx912223TLhX0G9/4hkskEu7ll18el/J64sSJwpxKOM9169a5V155xfX19bk33njDPfjgg66qqspt377dOVcZ56j5w+w45yrjPP/mb/7Gvfzyy+7tt992r776qvvzP/9z19TUVPi3phLO0bmP0uxramrco48+6g4cOOB++MMfuoaGBvfMM88U5oQ417INQs4598QTT7iFCxe6uro6d+WVVxbSfKerX/ziF05EIsedd97pnPsoRfLhhx92yWTSxeNxd/3117s9e/aE3bQn7fxExD355JOFOZVwnn/1V39VeG+effbZ7oYbbigEIOcq4xw1nwxClXCeH38Wpra21rW2trpbb73V7d27t/B4JZzjx3784x+7xYsXu3g87i666CK3ZcuWcY+HOFf6CQEAginLe0IAgJmBIAQACIYgBAAIhiAEAAiGIAQACIYgBAAIhiAEAAiGIAQACIYgBAAIhiAEAAiGIAQACOb/AxqAZ1IQ4NVAAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for batch in data_loader:\n", + " image = batch[\"image\"]\n", + " image = image.to(model.device)\n", + " image = functional.rotate(image, 0.0, expand=False)\n", + " image = functional.center_crop(image, [256,256])\n", + " input = functional.resize(image, [64,64], antialias=False)\n", + "\n", + " plt.imshow(input.cpu().numpy().squeeze().T) # squeeze removes the batch dimension and transposes brings the color channel to the end\n", + " plt.show()\n", + "\n", + " recon, _ = model(input)\n", + "\n", + " plt.imshow(recon.cpu().detach().numpy().squeeze().T)\n", + " plt.show()\n", + " \n", + " break" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spherinator", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 3b2bf9f0c8fcd9a697dd13aadaf7c3d7feb385f3 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 14:34:23 +0200 Subject: [PATCH 13/20] update data path --- test-bce.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test-bce.py b/test-bce.py index 241912d..459ad1b 100644 --- a/test-bce.py +++ b/test-bce.py @@ -11,7 +11,9 @@ model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) - data_module = data.IllustrisSdssDataModule(data_directories=["TNG50"], num_workers=8, batch_size=32) + data_module = data.IllustrisSdssDataModule( + data_directories=["/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/"], + num_workers=8, batch_size=32) trainer = pl.Trainer(accelerator='gpu', max_epochs=-1) trainer.fit(model, data_module) From 9649717742f03d37c7f07a35877614267f4880e1 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 16:03:14 +0200 Subject: [PATCH 14/20] save l2 normalization --- models/rotational_spherical_variational_autoencoder.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index fd1d847..5545e95 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -68,9 +68,7 @@ def encode(self, x): if self.distribution == 'normal': z_var = F.softplus(self.fc_var(x)) elif self.distribution == 'vmf': - length = torch.linalg.vector_norm(z_mean, dim=1) + 1.e-20 - z_mean = (z_mean.T / length).T - #z_mean = z_mean / z_mean.norm(dim=-1, keepdim=True) + z_mean = torch.nn.functional.normalize(z_mean, p=2, dim=1) # the `+ 1` prevent collapsing behaviors z_var = F.softplus(self.fc_var(x)) + 1.e-6 else: From 417cd44664d342abec26dfa35cc6531f91c0a76c Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Wed, 13 Sep 2023 16:30:55 +0200 Subject: [PATCH 15/20] add spherical loss to SVAE --- experiments/illustris-svae.yaml | 1 + .../rotational_spherical_variational_autoencoder.py | 11 ++++++++--- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/experiments/illustris-svae.yaml b/experiments/illustris-svae.yaml index 48172aa..7c4bd5d 100644 --- a/experiments/illustris-svae.yaml +++ b/experiments/illustris-svae.yaml @@ -6,6 +6,7 @@ model: h_dim: 256 z_dim: 3 distribution: "vmf" + spherical_loss_weight: 1.e-4 data: class_path: data.IllustrisSdssDataModule diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index 5545e95..b3910f2 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -15,19 +15,21 @@ class RotationalSphericalVariationalAutoencoder(pl.LightningModule): - def __init__(self, h_dim=256, z_dim=2, distribution='normal'): + def __init__(self, h_dim=256, z_dim=2, distribution='normal', spherical_loss_weight=1e-4): """ RotationalSphericalVariationalAutoencoder initializer :param h_dim: dimension of the hidden layers :param z_dim: dimension of the latent representation :param distribution: string either `normal` or `vmf`, indicates which distribution to use + :param spherical_loss_weight: weight of the spherical loss """ super().__init__() self.save_hyperparameters() self.example_input_array = torch.randn(1, 3, 64, 64) self.h_dim, self.z_dim, self.distribution = h_dim, z_dim, distribution + self.spherical_loss_weight = spherical_loss_weight self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(5,5), stride=2, padding=2) self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(5,5), stride=2, padding=2) @@ -105,6 +107,9 @@ def forward(self, x): recon = self.decode(z) return (z_mean, z_var), (q_z, p_z), z, recon + def spherical_loss(self, coordinates): + return torch.square(1 - torch.sum(torch.square(coordinates), dim=1)) + def training_step(self, batch, batch_idx): images = batch["image"] rotations = 36 @@ -114,7 +119,7 @@ def training_step(self, batch, batch_idx): x = functional.center_crop(x, [256,256]) input = functional.resize(x, [64,64], antialias=False) - _, (q_z, p_z), _, recon = self.forward(input) + (z_mean, _), (q_z, p_z), _, recon = self.forward(input) loss_recon = self.reconstruction_loss(input, recon) @@ -125,7 +130,7 @@ def training_step(self, batch, batch_idx): else: raise NotImplementedError - losses[:,i] = loss_recon + loss_KL + losses[:,i] = loss_recon + loss_KL + self.spherical_loss_weight * self.spherical_loss(z_mean) loss = torch.mean(torch.min(losses, dim=1)[0]) self.log('train_loss', loss, prog_bar=True) From 2f29ae17763fb3d4c8a186920074509f9adf47e1 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Fri, 15 Sep 2023 16:22:47 +0200 Subject: [PATCH 16/20] fix import of hyperspherical_vae use absolute script path to find relative path when called outside the script directory --- models/rotational_spherical_variational_autoencoder.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index b3910f2..d91eb4a 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -1,3 +1,4 @@ +import os import sys import lightning.pytorch as pl @@ -8,7 +9,8 @@ import torchvision.transforms.functional as functional from torch.optim import Adam -sys.path.append('external/s-vae-pytorch/') +script_dir = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(script_dir, '../external/s-vae-pytorch/')) from hyperspherical_vae.distributions import (HypersphericalUniform, VonMisesFisher) From dcd957eeecbf5f337babb340f0782aa1a4961ea1 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 18 Sep 2023 10:17:01 +0200 Subject: [PATCH 17/20] add ipykernel to conda env --- environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment.yml b/environment.yml index e3e0608..0df755c 100644 --- a/environment.yml +++ b/environment.yml @@ -11,6 +11,7 @@ dependencies: - pandas - pip - pip: + - ipykernel - jsonargparse[signatures] - tensorboard - tensorrt From 28b3a86d58bc854562dc34cd17af5918b6cee2c6 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 18 Sep 2023 11:38:15 +0200 Subject: [PATCH 18/20] fix loss parts by using min indexing --- ...ational_spherical_variational_autoencoder.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/models/rotational_spherical_variational_autoencoder.py b/models/rotational_spherical_variational_autoencoder.py index d91eb4a..d62a2c9 100644 --- a/models/rotational_spherical_variational_autoencoder.py +++ b/models/rotational_spherical_variational_autoencoder.py @@ -116,6 +116,9 @@ def training_step(self, batch, batch_idx): images = batch["image"] rotations = 36 losses = torch.zeros(images.shape[0], rotations) + losses_recon = torch.zeros(images.shape[0], rotations) + losses_KL = torch.zeros(images.shape[0], rotations) + losses_spher = torch.zeros(images.shape[0], rotations) for i in range(rotations): x = functional.rotate(images, 360.0 / rotations * i, expand=False) x = functional.center_crop(x, [256,256]) @@ -132,12 +135,22 @@ def training_step(self, batch, batch_idx): else: raise NotImplementedError - losses[:,i] = loss_recon + loss_KL + self.spherical_loss_weight * self.spherical_loss(z_mean) + loss_spher = self.spherical_loss(z_mean) - loss = torch.mean(torch.min(losses, dim=1)[0]) + losses[:,i] = loss_recon + loss_KL + self.spherical_loss_weight * loss_spher + losses_recon[:,i] = loss_recon + losses_KL[:,i] = loss_KL + losses_spher[:,i] = loss_spher + + loss_idx = torch.min(losses, dim=1)[1] + loss = torch.mean(torch.gather(losses, 1, loss_idx.unsqueeze(1))) + loss_recon = torch.mean(torch.gather(losses_recon, 1, loss_idx.unsqueeze(1))) + loss_KL = torch.mean(torch.gather(losses_KL, 1, loss_idx.unsqueeze(1))) + loss_spher = torch.mean(torch.gather(losses_spher, 1, loss_idx.unsqueeze(1))) self.log('train_loss', loss, prog_bar=True) self.log('loss_recon', loss_recon, prog_bar=True) self.log('loss_KL', loss_KL) + self.log('loss_spher', loss_spher) self.log('learning_rate', self.optimizers().param_groups[0]['lr']) return loss From 74cf36edee24cae479746110c58728a979aa2ea2 Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 18 Sep 2023 12:39:20 +0200 Subject: [PATCH 19/20] move development scripts into a separate folder --- cli-vae.py => devel/cli-vae.py | 0 rot-vae-cli.py => devel/rot-vae-cli.py | 0 rot-vae-onnx.py => devel/rot-vae-onnx.py | 0 svae-cli.py => devel/svae-cli.py | 0 svae-fit.py => devel/svae-fit.py | 0 svae-predict.py => devel/svae-predict.py | 0 devel/test-bce-predict.ipynb | 97 ++++++++++++++++++++++ devel/test-bce.py | 21 +++++ devel/test-predict.ipynb | 101 +++++++++++++++++++++++ devel/test-svae.py | 33 ++++++++ 10 files changed, 252 insertions(+) rename cli-vae.py => devel/cli-vae.py (100%) rename rot-vae-cli.py => devel/rot-vae-cli.py (100%) rename rot-vae-onnx.py => devel/rot-vae-onnx.py (100%) rename svae-cli.py => devel/svae-cli.py (100%) rename svae-fit.py => devel/svae-fit.py (100%) rename svae-predict.py => devel/svae-predict.py (100%) create mode 100644 devel/test-bce-predict.ipynb create mode 100644 devel/test-bce.py create mode 100644 devel/test-predict.ipynb create mode 100644 devel/test-svae.py diff --git a/cli-vae.py b/devel/cli-vae.py similarity index 100% rename from cli-vae.py rename to devel/cli-vae.py diff --git a/rot-vae-cli.py b/devel/rot-vae-cli.py similarity index 100% rename from rot-vae-cli.py rename to devel/rot-vae-cli.py diff --git a/rot-vae-onnx.py b/devel/rot-vae-onnx.py similarity index 100% rename from rot-vae-onnx.py rename to devel/rot-vae-onnx.py diff --git a/svae-cli.py b/devel/svae-cli.py similarity index 100% rename from svae-cli.py rename to devel/svae-cli.py diff --git a/svae-fit.py b/devel/svae-fit.py similarity index 100% rename from svae-fit.py rename to devel/svae-fit.py diff --git a/svae-predict.py b/devel/svae-predict.py similarity index 100% rename from svae-predict.py rename to devel/svae-predict.py diff --git a/devel/test-bce-predict.ipynb b/devel/test-bce-predict.ipynb new file mode 100644 index 0000000..ca4ca61 --- /dev/null +++ b/devel/test-bce-predict.ipynb @@ -0,0 +1,97 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torchvision.transforms.functional as functional\n", + "\n", + "import data\n", + "import models\n", + "\n", + "model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint(\n", + " # \"spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt\")\n", + " \"spherinator/iktq1u6p/checkpoints/epoch=8-step=4167.ckpt\")\n", + "\n", + "data_module = data.IllustrisSdssDataModule(\n", + " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", + " num_workers=1, batch_size=1)\n", + "data_module.setup(\"fit\")\n", + "data_loader = data_module.train_dataloader()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGfCAYAAAD22G0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtUUlEQVR4nO3dcWzc9X3/8dedz77YjnMU2vhsETK3NQUSoJCwEMNINBpXjKEhpKoltEs1aSIF2kRsgoVIS5iKnWValFahQckqFkRp/gG6VGtLPBWcTRFrmhLhJlWaKi54bTwPlp5NYt/Zd5/fH1nuV3Oft/E3PvOxz89H9ZXK5/v1577fs5O3v/m+7v2JOeecAAAIIB76BAAAcxdFCAAQDEUIABAMRQgAEAxFCAAQDEUIABAMRQgAEAxFCAAQDEUIABAMRQgAEExiuib+1re+pX/4h3/QmTNntGTJEu3cuVN/9Ed/9IFfVygU9Nvf/lYNDQ2KxWLTdXoAgGninNPQ0JCam5sVj3/AvY6bBvv373fV1dVu79697sSJE27Dhg2uvr7evfXWWx/4tX19fU4SGxsbG9ss3/r6+j7w7/yYc+VvYLpixQrdfPPN2r17d3Hs2muv1b333qvOzs4JvzaTyeiyyy4r9ykBAD5kv/vd75RKpSY8puzPhHK5nI4ePar29vZx4+3t7Tp8+HDJ8dlsVoODg8VtaGio3KcEAAhgMo9Uyl6E3nnnHeXzeTU2No4bb2xsVH9/f8nxnZ2dSqVSxW3RokXlPiUAwAw1bem491dA55y3Km7atEmZTKa49fX1TdcpAQBmmLKn4z760Y+qqqqq5K5nYGCg5O5IkpLJpJLJZLlPAwAwC5T9TqimpkbLli1TV1fXuPGuri61tbWV++UAALPYtHxO6NFHH9WXvvQlLV++XCtXrtSePXv09ttva/369dPxcgCAWWpaitDnP/95vfvuu/q7v/s7nTlzRkuXLtUPfvADLV68eDpeDgAwS03L54SmYnBw8ANz5QCAmS+TyWjBggUTHkPvOABAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwkYvQoUOHdM8996i5uVmxWEzf+973xu13zmnr1q1qbm5WbW2tVq9erePHj5frfIHxYtYWK9liM2iLct7WuQOVIHIROnfunG688Ubt2rXLu3/79u3asWOHdu3apSNHjiidTmvNmjUaGhqa8skCACqMmwJJ7uWXXy7+d6FQcOl02m3btq04NjIy4lKplHvmmWe8c4yMjLhMJlPc+vr6nCQ2tsltMWuLlWyxGbRFOW/r3IO/92xsH7BlMpkPrCNlfSbU29ur/v5+tbe3F8eSyaRWrVqlw4cPe7+ms7NTqVSquC1atKicpwQAmMHKWoT6+/slSY2NjePGGxsbi/veb9OmTcpkMsWtr6+vnKcEAJjBEtMx6fsfmjrnzAepyWRSyWRyOk4DADDDlbUIpdNpSRfuiJqamorjAwMDJXdHgJfxy0qlZcFiZbiiqAk5Z+4w9wDTrqz/HNfS0qJ0Oq2urq7iWC6XU3d3t9ra2sr5UgCAChD5Tui9997Tr371q+J/9/b26tixY7r88st11VVXaePGjero6FBra6taW1vV0dGhuro6rV27tqwnDgCoAFFj2a+++qo3irdu3bpiTHvLli0unU67ZDLp7rjjDtfT0zPp+TOZTPBYIVvALUJEmS1qLNzYQn/P2Sp2m0xEO+bczPoH4cHBQaVSqdCngVDmyDOhEMw/6DPrrwBUkEwmowULFkx4zLSk4zBHmZWidMeMKirWyThzx9TntkxjPbC/PZM/SWedIHUMl4gGpgCAYChCAIBgKEIAgGAoQgCAYChCAIBgSMchummNURuzRJy8LOcSIe1XNhGmtgNp05dgM9sNGcOk6fBBuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM6DhME0qYzBVamhF0Z+tVZQa0w/e38Z+O812Mlz8qUYPMfHEmUNB1JurmJOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTj5hpPKq1sKbByJN7Klpqb/FeU5TexMizCeuFw6/o9E0VOwRmHRzlHa+4yLBFuJensBW6JzVUC7oQAAMFQhAAAwVCEAADBUIQAAMEQTKhU07nwXNS5PTvsdi5R5578FZVjjsjMqf0P1a2QgDewYBxshQTs7IRvT8QWOtZ7WJbAgjH1NL4mPjzcCQEAgqEIAQCCoQgBAIKhCAEAgqEIAQCCIR1XoaK1yrGGI6bGrGRbOdJx1qmYaTrvi07+2Il4XzNyf54ow4p5El9mqxw7Yuc/3LPDah9kLTxnLrBnzuMbjPYeRkk7lqOtEKYHd0IAgGAoQgCAYChCAIBgKEIAgGAoQgCAYEjHzXZl6HsWNR0Ws17TDLz5FtIzUm1xKx1nxuOM40t/v7LmLkdqLnIbM2OHmeFyhZKhgjV56aEXhmPGDt80ZpLOmMIK5Fnvre8LjDfRfk8iJN7oMzdjcScEAAiGIgQACIYiBAAIhiIEAAiGIgQACIZ03GwRLdg1wTxREl9R+7tF6B3nSa9NNEfcOr5q8im7uKqMY61z8Q5733Sr15odG4u2KqpvPF7wp91cPOKqrZ5pnDW3f4qJlm2dtOgrwk4eq7POXNwJAQCCoQgBAIKhCAEAgqEIAQCCiVSEOjs7dcstt6ihoUELFy7Uvffeq5MnT447xjmnrVu3qrm5WbW1tVq9erWOHz9e1pMGAFSGSOm47u5uPfzww7rllls0NjamzZs3q729XSdOnFB9fb0kafv27dqxY4f++Z//WVdffbW+/vWva82aNTp58qQaGhqm5SLmhqirf0YYjpqCs17SnKb0d5241SMu7k+wxY0EW5VxvKpKx6uM14ybr2md4+R/d7NWIlXBSMEZ44XCWMlY3kiwFfL+8XjBf955T085KzVWMF5zgiZ5kx61U3BWas7oNRch2VaO5B2mJuamsO7t//zP/2jhwoXq7u7WHXfcIeecmpubtXHjRj3++OOSpGw2q8bGRv393/+9HnzwwQ+cc3BwUKlU6lJPqXJFLAiRmnJGjVxbL2k2H6UIlQhQhKzYtW8e61irCEWJlpvjZlPXaMuVl2Mpb5YDL49MJqMFCxZMeMyUngllMhlJ0uWXXy5J6u3tVX9/v9rb24vHJJNJrVq1SocPH/bOkc1mNTg4OG4DAMwNl1yEnHN69NFHdfvtt2vp0qWSpP7+fklSY2PjuGMbGxuL+96vs7NTqVSquC1atOhSTwkAMMtcchF65JFH9Oabb+q73/1uyb73/zOOc878p51NmzYpk8kUt76+vks9JQDALHNJbXu++tWv6sCBAzp06JCuvPLK4ng6nZZ04Y6oqampOD4wMFByd3RRMplUMpm8lNOoYL5F4KY+R9Qjy/HsxzrefA5TZTz7qfL/qMYT/nmqEqXHJzxjF17TP54wzsXXosd6TmS2ojGe/eTzpc9+JP9zm3x+1H/sqPXsxz+3xvIlQ9ZzpVis9FjJflZUMK5TvjCEkXkw2w2ZK+/5+ipFfMZDO58PTaQ7IeecHnnkEb300kv68Y9/rJaWlnH7W1palE6n1dXVVRzL5XLq7u5WW1tbec4YAFAxIt0JPfzww3rhhRf0L//yL2poaCg+50mlUqqtrVUsFtPGjRvV0dGh1tZWtba2qqOjQ3V1dVq7du20XAAAYPaKVIR2794tSVq9evW48WeffVZf/vKXJUmPPfaYhoeH9dBDD+ns2bNasWKFDh48yGeEAAAlpvQ5oenA54Qk7zOhqA+FInzGx16CYfLLJFw4fvLPhKzP9/BM6MN/JpSP8EzIFcrzTMjJ90yoTMteRJjDYh49s/66nPGm/XNCAABMBYvazUTRo3CTn8K/wtzkj1X0Oydft4O4p6OBNMHdijFeU+0fr6ouTVzWJKuN1/SPVxl3Wb67ryrjLjAfsTOCM+6ERj3jo7mc/9hR6w7JP/dYvPT4sTHrrsn63vvvkCTjzsl53i9PYk6y70rMn3HP3YqL2J+Hdj4fHu6EAADBUIQAAMFQhAAAwVCEAADBUIQAAMGQjpuBIoXjIn6AyPs5IXPqqafgLoyXpsmsdFzcSLvVeNJuklRdU+MdT9bOKx2rKR2TpJp5xtxVRpqupvQcY8axzkiH5cestYD8qbRcLlsyNuoZk6TssD81NzY64h0fGfF8L2L+OWIykndGOM78GKJvDSNrIT3/DPZHdnwB0Kj95yz0lCs77oQAAMFQhAAAwVCEAADBUIQAAMFQhAAAwZCOm+Ui9YizvqBcvePMdFzpeMLoXF1t9HGrThopuHl1/vG62pKx+jr/sTW1pcdKUl2t//i4Jx1XZaT9rPBVwUjHZY2ebW74XMnYyLA/HXe+pvRYScqOGH32YsMlY8NGL7yc9bMyanW69h/uSw2aYTejQ/cEkbdJzx017Wb2lPPtIDA3KdwJAQCCoQgBAIKhCAEAgqEIAQCCoQgBAIIhHRdSlLZvZVht1ZrIDtJZO/y/u5jpOM9KpPFqf5qsqsZIxxl933wpOEman5pfMlZX71/rvra+wTteV2sk8mpKe80V4v4/SjEjZeWqjN5xI/7ebMMjpUm9qvPnvcfGz/nPu+o9f2ou5unt56zvsTOSasa4sYCsnK8jnLH8aT5iepM+brMLd0IAgGAoQgCAYChCAIBgKEIAgGAIJswaU1+8zh632vMYc5iL2lnjnmCC8SA/UW2EAYwAQq3RiqeutjRsUJ/yBxPmL/AHE+qT9f5zqS8NSTgjlFFtPOAfMxavK2T9q8PVeBakqx0a8h47VGOEPoyF9+K+jICxSl2+4A9OFIxgQt5oueN8i9r5TkRS3Gp95B/2/uCaLYGs4Ig1t4m+PZeKOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjgipHL56Ic3iSQ1EXxjMXtYv5U1neRe0SERe1q/Gn5uYZ6bhkQ2nbnlStPx1XV3eZd3xBylgEb17pOVbFjLY91f7f84xwnEZzpSk4SaoeKU3kjRjvYTxhtNwp+L9vznMyY85Ix+WN9jwF//GJMf94wTOPixnHxqxF7SbftsdcjM4Yj4ps3KXjTggAEAxFCAAQDEUIABAMRQgAEAxFCAAQDOm4gMqyTl20JnHGsVbazVq8LlpqzpeOMxe1M3rH1cwrXUhOkpLz/Am2+rrSfnDJ+aWJOUlqqPfPUVvnP76utjQdl6z2p/pixuJ1Y2P+9zY36l+8r7qmNDVXbfwO6fL+XNbYiD99NubpB5cb8af0stmsdzyR83/f4gl/DLBqrPQ189bPVT7iDzlRtVmFOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjZjtzychyZO/Myf2jVrrJk46r8qy2KklVCWtVUCM1V+NPpdV6Emzz5vl/3Gvm+5N3dfP9xzckSxNs8+b5zzuW8J93Qf6kWm7ESJN5lheNFXLeY0cL/lVos9lh7/hwtvR6EkbqsMZIzY1W+X+fjVcZ74vn+2+mMc30pndYznl2mM3jjJ/xCH3pMDXcCQEAgqEIAQCCoQgBAIKhCAEAgokUTNi9e7d2796tX//615KkJUuW6G//9m911113SZKcc3ryySe1Z88enT17VitWrNDTTz+tJUuWlP3EZ5Wy9OeJOrf/AWrM9wVW95Myjcc9i91ZD5vtwIL/96WEsQiei5eOx4zWOvOq/X8MklX+wEKtp4VQbZ2x6J7xYH7UWATOHx2QCqOl5zg26n/NbLXR4ijpH5/nCVokE/7vz7AVNDAW2It5AhUXxj2LK5o/VxHa8xjzmHmC6V7tDh8o0p3QlVdeqW3btumnP/2pfvrTn+qP//iP9Wd/9mc6fvy4JGn79u3asWOHdu3apSNHjiidTmvNmjUaGhqalpMHAMxukYrQPffcoz/5kz/R1VdfrauvvlpPPfWU5s+fr9dff13OOe3cuVObN2/Wfffdp6VLl2rfvn06f/68Xnjhhek6fwDALHbJz4Ty+bz279+vc+fOaeXKlert7VV/f7/a29uLxySTSa1atUqHDx8258lmsxocHBy3AQDmhshFqKenR/Pnz1cymdT69ev18ssv67rrrlN/f78kqbGxcdzxjY2NxX0+nZ2dSqVSxW3RokVRTwkAMEtFLkKf+tSndOzYMb3++uv6yle+onXr1unEiRPF/e9/iOicsx8sStq0aZMymUxx6+vri3pKAIBZKnLbnpqaGn3yk5+UJC1fvlxHjhzRN77xDT3++OOSpP7+fjU1NRWPHxgYKLk7+n3JZNJM7eD/ix6w83+FL/QTM5JAdocSo42K+TuNp+WMcawZhIq4kJ7v+BojeRczWs7EavzH19SUHl/rGZOkeUYboqSMc/GH5nS+urSdTyJu/LlJ+Beek3H98rRVinnShRfGjfY81niEn1xvclMTBNUi/dxGbEFlHB8pNEfyblKm/Dkh55yy2axaWlqUTqfV1dVV3JfL5dTd3a22trapvgwAoAJFuhN64okndNddd2nRokUaGhrS/v379dprr+lHP/qRYrGYNm7cqI6ODrW2tqq1tVUdHR2qq6vT2rVrp+v8AQCzWKQi9N///d/60pe+pDNnziiVSumGG27Qj370I61Zs0aS9Nhjj2l4eFgPPfRQ8cOqBw8eVENDw7ScPABgdotUhL797W9PuD8Wi2nr1q3aunXrVM4JADBH0DsOABAMi9p9KKazeZwlarMs35HRztsZcTpvgM3oKWaetZEac67gHY97Fo3zrXUmSXnjvGsK/rkL+dLjXd5Idpn9zfwXZF1PwvMmuir/HDGjL12UsJaVmDR/IgrWFxjJw0mex0QvWp4/VWVIwWFKuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM67sNgNWGboLFryRTG+PTm7iJmhIxIlTc4ZaWpjHRY3ho3kmD53GjJWC6b8x47lvP3Wjs3WrriqCTVeOYeqfJ/JwoFf782Z7xXuZz/Okc8rzk6bLwno6V95iRpLO9/r+L50rnHCv458kZi0EpGRhq3/pxYc0T54bd+lKczBkfEblK4EwIABEMRAgAEQxECAARDEQIABEMRAgAEQzpuljCDQGVI3plTR33NCEkoK+3m8v5Ulhvzjxey/vHRsdL5R8dKU2CSlM35U2PZYSM1lyj9Y1Ow+ptlo604OjziP8fh4dLrHMn703454z0seBJ2kj95Z6YUZcxtJO+clYL0/nRZP1cRppDRl45VTmcs7oQAAMFQhAAAwVCEAADBUIQAAMEQTJglzLY9VgAhSp8fO4HgHzUeNueN8YTnoXVhzP8ge8wYHx3xhwSyuWHv+Mhw6Xhdjb8NT7am2js+GPO33PEZHvHPUVvt//6MGe188qP+sMG58+dLxnLn/e/J8Mh73vHz2dI5JCnnec2R7Ij3WJczgiBWGMIIlPh+VoyOQJGzA97jCSDMWNwJAQCCoQgBAIKhCAEAgqEIAQCCoQgBAIIhHRdQWRaqK8uCeVYKzn98Ie7fUWUtMOcZzxtpKmvhuew8fwouez7pHU96jh80UnCxhH+84Izf0QqlbW6qq/x/lM7X+Odwef/42KjRtseTVhvxJOYk6fyQP9lmHZ8dKR0fy/qTd6NZoz2Pp02SJBXMHyLfuBWPi7ZgXlmicObc0/aKcxZ3QgCAYChCAIBgKEIAgGAoQgCAYChCAIBgSMfNFhFTcGbyzjePGaSzkk3+L7B6f+U9vePyVk8xY+G53LB//HzCn5qLDQ16Rv2/c8WMN2vU+V9zLFtTOkfcn7BLJIz+czEjTWb0zsuOlo6fP2f0iHvPd+3SyPlz/vEhT186o3dcbtT/flvfNysFWfD8sBSM3oN2Cs5QjqhaxEXwYp4dJOYmhzshAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDCk44Kaevc4ewYjaeQdNNJuZmsu/46Y0Tsuli+d3+qRNhr3/14Ur/KPV1X502fxROnxLm6sCGuk4EZH/f3Tcp4VWquM3nGxav+41a+vkPWn5kbzpeeSM/q7DRupuffO+dNxw57VaUdG/Om4Uev7Nmqk4PJGCtD3s2L0mbPScea4dyzCn4cJdxiHE4W7ZNwJAQCCoQgBAIKhCAEAgqEIAQCCIZgQUnlWtTOGo0xizRGtbY8zFrsreNv2+AMFubgRboj5H3zHYv6F2hQvPUeXjxYGsBbYG64p/WMTT/gX10sk/H/ErAf28Zj/+kezpYGA4RFjAcCssQCgEUwYOV8aZMgN++ceNcIQY5Hb9njGrB9D8+fTP+xNCZQrgYCy404IABAMRQgAEAxFCAAQDEUIABAMRQgAEMyU0nGdnZ164okntGHDBu3cuVPShVYaTz75pPbs2aOzZ89qxYoVevrpp7VkyZJynO+c4EsDxazIXORwnO8Los1dMFaBixnxpoJnATdXMBa184esNGpdj5HI872HY2NG4stqz+NZvE6SEjWlSbiY0VYoETcWtbNazhjvra8tjtX6KGek5nJZf5IwO1zaomfMSsGN+uf2LVwoSS5C2x67PY93WBPE46wvmNKhmB6XfCd05MgR7dmzRzfccMO48e3bt2vHjh3atWuXjhw5onQ6rTVr1mhoaGjKJwsAqCyXVITee+89PfDAA9q7d68+8pGPFMedc9q5c6c2b96s++67T0uXLtW+fft0/vx5vfDCC2U7aQBAZbikIvTwww/r7rvv1mc+85lx4729verv71d7e3txLJlMatWqVTp8+LB3rmw2q8HBwXEbAGBuiPxMaP/+/frZz36mI0eOlOzr7++XJDU2No4bb2xs1FtvveWdr7OzU08++WTU0wAAVIBId0J9fX3asGGDnn/+ec2bV7qmykWx2PinyM65krGLNm3apEwmU9z6+vqinBIAYBaLdCd09OhRDQwMaNmyZcWxfD6vQ4cOadeuXTp58qSkC3dETU1NxWMGBgZK7o4uSiaTSib9fbfmLF+0LVI/OSlabK48K3gVjF5zcU+vuTEjTRW3Yn0xfxLMam/nG8+P+RN5Yzn/eLa62jtelSjtzVZlLMYna9xIElqXX/CkCfNj/vcwn7MWnjPGPUk4qxfcmLV4nXUuviZxkpxn3JnfzKiL2nn6BsqY22AH8ojTlVukO6E777xTPT09OnbsWHFbvny5HnjgAR07dkwf//jHlU6n1dXVVfyaXC6n7u5utbW1lf3kAQCzW6Q7oYaGBi1dunTcWH19va644ori+MaNG9XR0aHW1la1traqo6NDdXV1Wrt2bfnOGgBQEcq+lMNjjz2m4eFhPfTQQ8UPqx48eFANDQ3lfikAwCwXc9Y/rAYyODioVCoV+jQCK/03bSPXEWWK/xv2ze0/2Bw3nnPEPGv4SFLc0zUgbnQYiMf9vxclqo3xKv9zm+pkabcDc45qozOC+UyodJ6580zI6Jgw6j+XMWs9Ic8zQeuZorPeK+t5k2/MfN4UaZhnQhFlMhktWLBgwmPoHQcACIaVVWek0t+2fIkfaYLQXIRVW82VK825rRVX/b/TOHl+6zXnNhJsxjlavyUXXOlrjhmruSaM3+6rqvx/POKecevOzr6BNVanjXA3kDf67/nuMiRpzLpb8dz15I07IWtus3ecp0ecZCTbrDseMwVniLSyKkLjTggAEAxFCAAQDEUIABAMRQgAEAxFCAAQDOm42cL6fELEDxB5V201PpwSPVBkJNU8ga+YlY+L+qIR0nGFvD8dlx8zet4Z/eriidJ57G9DxA94mZ9b8ezI+w/Oe65d8q9mKvk/b2Sl4ArGZ3Ps8ckn3syPLEYdLwc+D/Sh4U4IABAMRQgAEAxFCAAQDEUIABAMwYRZLkJ3HvMLzHXkrFY5kZ/Z+lq0+I8sxKI9hC7EjVCB56LMY43F7sxWPGOT/93NagIbOa/gecBvNuU0wgB5400v5D0LzJmL0UVb0NBsQxQhmBD1xy1yGyoExZ0QACAYihAAIBiKEAAgGIoQACAYihAAIBjScbOdlSiyluaOMIcd4SpHisla1s7/mgVrdmMhPd/0sbhx3sYS3NZCbb7Em9m2J2acX9R1BO1lAEuPNRJs1mKEBV9SLeoCc5EXpPMt3GiIMMfEE/mmJkkXGndCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGBIx1WsyF3lPDNEmyNmppgiNEoz037+cSuVlveMx4xF4GJWDzbrOid/qN07LnI6LsIk1ntoHu5rKDj1tNuE477hqL3joqTgJn8oPmTcCQEAgqEIAQCCoQgBAIKhCAEAgqEIAQCCIR1XqawklCdlFrOiXRFjSWa/Ol9vMjNNFSGRJpn90HxfYM5tLC1rds4zG8WVQ7R+fVGYybYI/dPMYyMn2yI1eJv8sdM5B6YFd0IAgGAoQgCAYChCAIBgKEIAgGAIJsw1vg4txuNjs+WMOffkH06bYYiIgQXz3I3Z/ZNYQQvr+MnPXq4IQ1keq0cJD0QNpZTlNaNdZVlCDwiOOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjYLJatEROzUWYO2rXGvNwbyQv4kJ/5uER2txEbsNThrY95Vgwr0wJsygtgcw57MmnPDfC404IABAMRQgAEAxFCAAQDEUIABAMRQgAEEykIrR161bFYrFxWzqdLu53zmnr1q1qbm5WbW2tVq9erePHj5f9pBGWc86/Sd4t2uTW5ryb9b8oc9vXY/yvoNLNmsPcrEuKOk+E8zaO97+v1tsVce5I33rje2m9WagIke+ElixZojNnzhS3np6e4r7t27drx44d2rVrl44cOaJ0Oq01a9ZoaGiorCcNAKgMkT8nlEgkxt39XOSc086dO7V582bdd999kqR9+/apsbFRL7zwgh588EHvfNlsVtlstvjfg4ODUU8JADBLRb4TOnXqlJqbm9XS0qIvfOELOn36tCSpt7dX/f39am9vLx6bTCa1atUqHT582Jyvs7NTqVSquC1atOgSLgMAMBtFKkIrVqzQc889p1deeUV79+5Vf3+/2tra9O6776q/v1+S1NjYOO5rGhsbi/t8Nm3apEwmU9z6+vou4TIAALNRpH+Ou+uuu4r///rrr9fKlSv1iU98Qvv27dOtt94qqbSli3NuwjYvyWRSyWQyymkAACrElCLa9fX1uv7663Xq1Knic6L33/UMDAyU3B2hQllJq+lK0smYpEwpM/skPZkxK8Blx+Aibva1ll57xCkmmZibcJKo37ZI7zcq2ZSKUDab1S9+8Qs1NTWppaVF6XRaXV1dxf25XE7d3d1qa2ub8okCACpPpH+O++u//mvdc889uuqqqzQwMKCvf/3rGhwc1Lp16xSLxbRx40Z1dHSotbVVra2t6ujoUF1dndauXTtd5w8AmMUiFaH/+q//0v3336933nlHH/vYx3Trrbfq9ddf1+LFiyVJjz32mIaHh/XQQw/p7NmzWrFihQ4ePKiGhoZpOXkAwOwWc+VY8KOMBgcHlUqlQp8GppsRVpn6SkXlE2XdJOsPUYjrifwHOsBfATPsrx1Mk0wmowULFkx4DL3jAADBsLIqwjB+EzbvKMqwmmtU07oqaIWZsF8fMAHuhAAAwVCEAADBUIQAAMFQhAAAwRBMwKxQlkjvLIiFh+B9Z823m6QByos7IQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwpOMwd0RsFRRJ5Iid9QVlOBsCbJhFuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM6DiiH6GtqT8dZALMOd0IAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgIheh3/zmN/riF7+oK664QnV1dfr0pz+to0ePFvc757R161Y1NzertrZWq1ev1vHjx8t60gCAyhCpCJ09e1a33Xabqqur9cMf/lAnTpzQP/7jP+qyyy4rHrN9+3bt2LFDu3bt0pEjR5ROp7VmzRoNDQ2V+9wBALOdi+Dxxx93t99+u7m/UCi4dDrttm3bVhwbGRlxqVTKPfPMM5N6jUwm4ySxsbGxsc3yLZPJfODf+ZHuhA4cOKDly5frc5/7nBYuXKibbrpJe/fuLe7v7e1Vf3+/2tvbi2PJZFKrVq3S4cOHvXNms1kNDg6O2wAAc0OkInT69Gnt3r1bra2teuWVV7R+/Xp97Wtf03PPPSdJ6u/vlyQ1NjaO+7rGxsbivvfr7OxUKpUqbosWLbqU6wAAzEKRilChUNDNN9+sjo4O3XTTTXrwwQf1l3/5l9q9e/e442Kx2Lj/ds6VjF20adMmZTKZ4tbX1xfxEgAAs1WkItTU1KTrrrtu3Ni1116rt99+W5KUTqclqeSuZ2BgoOTu6KJkMqkFCxaM2wAAc0OkInTbbbfp5MmT48Z++ctfavHixZKklpYWpdNpdXV1Fffncjl1d3erra2tDKcLAKgok4qs/Z+f/OQnLpFIuKeeesqdOnXKfec733F1dXXu+eefLx6zbds2l0ql3EsvveR6enrc/fff75qamtzg4CDpODY2NrY5tE0mHRepCDnn3Pe//323dOlSl0wm3TXXXOP27Nkzbn+hUHBbtmxx6XTaJZNJd8cdd7ienp5Jz08RYmNjY6uMbTJFKOacc5pBBgcHlUqlQp8GAGCKMpnMBz7np3ccACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgmBlXhGZYP1UAwCWazN/nM64IDQ0NhT4FAEAZTObv8xm3lEOhUNBvf/tbNTQ0aGhoSIsWLVJfX19FL/s9ODjIdVaQuXCdc+EaJa7zUjnnNDQ0pObmZsXjE9/rJKb8amUWj8d15ZVXSpJisZgkacGCBRX9A3AR11lZ5sJ1zoVrlLjOSzHZdeFm3D/HAQDmDooQACCYGV2EksmktmzZomQyGfpUphXXWVnmwnXOhWuUuM4Pw4wLJgAA5o4ZfScEAKhsFCEAQDAUIQBAMBQhAEAwFCEAQDAzugh961vfUktLi+bNm6dly5bp3//930Of0pQcOnRI99xzj5qbmxWLxfS9731v3H7nnLZu3arm5mbV1tZq9erVOn78eJiTvUSdnZ265ZZb1NDQoIULF+ree+/VyZMnxx1TCde5e/du3XDDDcVPmK9cuVI//OEPi/sr4Rrfr7OzU7FYTBs3biyOVcJ1bt26VbFYbNyWTqeL+yvhGi/6zW9+oy9+8Yu64oorVFdXp09/+tM6evRocX+Qa3Uz1P79+111dbXbu3evO3HihNuwYYOrr693b731VuhTu2Q/+MEP3ObNm92LL77oJLmXX3553P5t27a5hoYG9+KLL7qenh73+c9/3jU1NbnBwcEwJ3wJPvvZz7pnn33W/fznP3fHjh1zd999t7vqqqvce++9VzymEq7zwIED7l//9V/dyZMn3cmTJ90TTzzhqqur3c9//nPnXGVc4+/7yU9+4v7gD/7A3XDDDW7Dhg3F8Uq4zi1btrglS5a4M2fOFLeBgYHi/kq4Ruec+9///V+3ePFi9+Uvf9n953/+p+vt7XX/9m//5n71q18VjwlxrTO2CP3hH/6hW79+/bixa665xv3N3/xNoDMqr/cXoUKh4NLptNu2bVtxbGRkxKVSKffMM88EOMPyGBgYcJJcd3e3c65yr9M55z7ykY+4f/qnf6q4axwaGnKtra2uq6vLrVq1qliEKuU6t2zZ4m688Ubvvkq5Ruece/zxx93tt99u7g91rTPyn+NyuZyOHj2q9vb2cePt7e06fPhwoLOaXr29verv7x93zclkUqtWrZrV15zJZCRJl19+uaTKvM58Pq/9+/fr3LlzWrlyZcVd48MPP6y7775bn/nMZ8aNV9J1njp1Ss3NzWppadEXvvAFnT59WlJlXeOBAwe0fPlyfe5zn9PChQt10003ae/evcX9oa51Rhahd955R/l8Xo2NjePGGxsb1d/fH+isptfF66qka3bO6dFHH9Xtt9+upUuXSqqs6+zp6dH8+fOVTCa1fv16vfzyy7ruuusq6hr379+vn/3sZ+rs7CzZVynXuWLFCj333HN65ZVXtHfvXvX396utrU3vvvtuxVyjJJ0+fVq7d+9Wa2urXnnlFa1fv15f+9rX9Nxzz0kK9/2ccUs5/L6LSzlc5JwrGas0lXTNjzzyiN588039x3/8R8m+SrjOT33qUzp27Jh+97vf6cUXX9S6devU3d1d3D/br7Gvr08bNmzQwYMHNW/ePPO42X6dd911V/H/X3/99Vq5cqU+8YlPaN++fbr11lslzf5rlC6s1bZ8+XJ1dHRIkm666SYdP35cu3fv1p//+Z8Xj/uwr3VG3gl99KMfVVVVVUn1HRgYKKnSleJiGqdSrvmrX/2qDhw4oFdffbW4PpRUWddZU1OjT37yk1q+fLk6Ozt144036hvf+EbFXOPRo0c1MDCgZcuWKZFIKJFIqLu7W9/85jeVSCSK1zLbr/P96uvrdf311+vUqVMV872UpKamJl133XXjxq699lq9/fbbksL92ZyRRaimpkbLli1TV1fXuPGuri61tbUFOqvp1dLSonQ6Pe6ac7mcuru7Z9U1O+f0yCOP6KWXXtKPf/xjtbS0jNtfKdfp45xTNputmGu888471dPTo2PHjhW35cuX64EHHtCxY8f08Y9/vCKu8/2y2ax+8YtfqKmpqWK+l5J02223lXxc4pe//KUWL14sKeCfzWmLPEzRxYj2t7/9bXfixAm3ceNGV19f737961+HPrVLNjQ05N544w33xhtvOElux44d7o033ijGzrdt2+ZSqZR76aWXXE9Pj7v//vtnXRT0K1/5ikulUu61114bF3k9f/588ZhKuM5Nmza5Q4cOud7eXvfmm2+6J554wsXjcXfw4EHnXGVco8/vp+Ocq4zr/Ku/+iv32muvudOnT7vXX3/d/emf/qlraGgo/l1TCdfo3IWYfSKRcE899ZQ7deqU+853vuPq6urc888/XzwmxLXO2CLknHNPP/20W7x4saupqXE333xzMeY7W7366qtOUsm2bt0659yFiOSWLVtcOp12yWTS3XHHHa6npyfsSUfkuz5J7tlnny0eUwnX+Rd/8RfFn82Pfexj7s477ywWIOcq4xp93l+EKuE6L34Wprq62jU3N7v77rvPHT9+vLi/Eq7xou9///tu6dKlLplMumuuucbt2bNn3P4Q18p6QgCAYGbkMyEAwNxAEQIABEMRAgAEQxECAARDEQIABEMRAgAEQxECAARDEQIABEMRAgAEQxECAARDEQIABPP/ANvTcnw9TFgSAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for batch in data_loader:\n", + " image = batch[\"image\"]\n", + " image = image.to(model.device)\n", + " image = functional.rotate(image, 0.0, expand=False)\n", + " image = functional.center_crop(image, [256,256])\n", + " input = functional.resize(image, [64,64], antialias=False)\n", + "\n", + " plt.imshow(input.cpu().numpy().squeeze().T)\n", + " plt.show()\n", + "\n", + " _, (q_z, p_z), _, recon = model(input)\n", + "\n", + " recon_image = torch.sigmoid(recon)\n", + "\n", + " plt.imshow(recon_image.cpu().detach().numpy().squeeze().T)\n", + " plt.show()\n", + " \n", + " break" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spherinator", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/devel/test-bce.py b/devel/test-bce.py new file mode 100644 index 0000000..459ad1b --- /dev/null +++ b/devel/test-bce.py @@ -0,0 +1,21 @@ +import lightning.pytorch as pl +import yaml + +import data +import models + +if __name__ == "__main__": + + with open("experiments/illustris-svae.yaml", "r", encoding="utf-8") as stream: + config = yaml.load(stream, Loader=yaml.Loader) + + model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) + + data_module = data.IllustrisSdssDataModule( + data_directories=["/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/"], + num_workers=8, batch_size=32) + + trainer = pl.Trainer(accelerator='gpu', max_epochs=-1) + trainer.fit(model, data_module) + + print("Done.") diff --git a/devel/test-predict.ipynb b/devel/test-predict.ipynb new file mode 100644 index 0000000..b8ec507 --- /dev/null +++ b/devel/test-predict.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torchvision.transforms.functional as functional\n", + "\n", + "import data\n", + "import models\n", + "\n", + "model = models.RotationalSphericalAutoencoder.load_from_checkpoint(\n", + " \"spherinator/ksl5gx72/checkpoints/epoch=10-step=5093.ckpt\")\n", + "\n", + "data_module = data.IllustrisSdssDataModule(\n", + " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", + " num_workers=1, batch_size=1)\n", + "data_module.setup(\"fit\")\n", + "data_loader = data_module.train_dataloader()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for batch in data_loader:\n", + " image = batch[\"image\"]\n", + " image = image.to(model.device)\n", + " image = functional.rotate(image, 0.0, expand=False)\n", + " image = functional.center_crop(image, [256,256])\n", + " input = functional.resize(image, [64,64], antialias=False)\n", + "\n", + " plt.imshow(input.cpu().numpy().squeeze().T) # squeeze removes the batch dimension and transposes brings the color channel to the end\n", + " plt.show()\n", + "\n", + " recon, _ = model(input)\n", + "\n", + " plt.imshow(recon.cpu().detach().numpy().squeeze().T)\n", + " plt.show()\n", + " \n", + " break" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spherinator", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/devel/test-svae.py b/devel/test-svae.py new file mode 100644 index 0000000..b47b278 --- /dev/null +++ b/devel/test-svae.py @@ -0,0 +1,33 @@ +import argparse + +import torch +import yaml + +import data +import models + +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description="Test SVAE") + parser.add_argument("--config", "-c", default="config.yaml", + help="config file (default = 'config.yaml').") + + vars = vars(parser.parse_args()) + if "config" in vars: + with open(vars["config"], "r", encoding="utf-8") as stream: + config = yaml.load(stream, Loader=yaml.Loader) + + model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) + + checkpoint = torch.load("lightning_logs/version_13/checkpoints/epoch=43-step=3344.ckpt") + model.load_state_dict(checkpoint["state_dict"]) + + data_module = data.IllustrisSdssDataModule(**(config["data"]["init_args"])) + data_module.setup("predict") + dataloader = data_module.predict_dataloader() + + for batch in dataloader: + image = batch["image"] + z_mean, _ = model.encode(image) + print(z_mean) + break From 4097b7ce4328ebbfedc85615cbe57f036af99dda Mon Sep 17 00:00:00 2001 From: Bernd Doser Date: Mon, 18 Sep 2023 12:45:29 +0200 Subject: [PATCH 20/20] cleaning up --- .gitignore | 7 ++- test-bce-predict.ipynb | 97 --------------------------------------- test-bce.py | 21 --------- test-predict.ipynb | 101 ----------------------------------------- test-svae.py | 33 -------------- 5 files changed, 3 insertions(+), 256 deletions(-) delete mode 100644 test-bce-predict.ipynb delete mode 100644 test-bce.py delete mode 100644 test-predict.ipynb delete mode 100644 test-svae.py diff --git a/.gitignore b/.gitignore index fb88b03..04747b4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ __pycache__ *.ckpt -HiPSter -lightning_logs +HiPSter/ +lightning_logs/ data/MNIST/ -wandb -TNG50/ +wandb/ diff --git a/test-bce-predict.ipynb b/test-bce-predict.ipynb deleted file mode 100644 index ca4ca61..0000000 --- a/test-bce-predict.ipynb +++ /dev/null @@ -1,97 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import torch\n", - "import torchvision.transforms.functional as functional\n", - "\n", - "import data\n", - "import models\n", - "\n", - "model = models.RotationalSphericalVariationalAutoencoder.load_from_checkpoint(\n", - " # \"spherinator/euj7yhpr/checkpoints/epoch=34-step=16205.ckpt\")\n", - " \"spherinator/iktq1u6p/checkpoints/epoch=8-step=4167.ckpt\")\n", - "\n", - "data_module = data.IllustrisSdssDataModule(\n", - " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", - " num_workers=1, batch_size=1)\n", - "data_module.setup(\"fit\")\n", - "data_loader = data_module.train_dataloader()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGfCAYAAAD22G0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwNElEQVR4nO3df3DV1Z3/8de9+XEhIQkKkpt8RRpt/AVqFVwkuuKuko7rOus4022L7drZmR2p2sK6O1p0ZsWOTZSdYegOlg5sx+J0Xf5Ru+5sW8lONbTLuKVURgp+KZaoqSVGEe4NkNwk957vH5T7bfycN/KBG09yeT46n5n6viefe85NyPt+8nnf90k455wAAAggGXoCAICzF0kIABAMSQgAEAxJCAAQDEkIABAMSQgAEAxJCAAQDEkIABAMSQgAEAxJCAAQTOV4nfg73/mO/vmf/1kHDhzQ3LlztXbtWv3pn/7px35doVDQ73//e9XV1SmRSIzX9AAA48Q5p4GBATU3NyuZ/JhrHTcONm/e7KqqqtzGjRvdnj173PLly11tba17++23P/Zre3t7nSQODg4Ojkl+9Pb2fuzv/IRzpW9gunDhQl1zzTVav359MXbZZZfpjjvuUGdn50m/NpPJaPr06aWeEgDgE3b48GE1NDScdEzJ7wkNDw9rx44dam9vHxNvb2/Xtm3bIuNzuZyy2WzxGBgYKPWUAAABnMotlZInoQ8++ED5fF6NjY1j4o2Njerr64uM7+zsVENDQ/GYPXt2qacEAJigxq067qMZ0DnnzYorV65UJpMpHr29veM1JQDABFPy6riZM2eqoqIictXT398fuTqSpFQqpVQqVeppAAAmgZJfCVVXV2v+/Pnq6uoaE+/q6lJbW1upnw4AMImNy+eEHnjgAX35y1/WggULtGjRIm3YsEHvvPOOli1bNh5PBwCYpMYlCX3+85/XwYMH9c1vflMHDhzQvHnz9KMf/Uhz5swZj6cDAExS4/I5oTORzWY/tq4cADDxZTIZ1dfXn3QMveMAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwVSGngAw6SRijHXjNgugLHAlBAAIhiQEAAiGJAQACIYkBAAIhiQEAAiG6jggpoSn4s0ZFXOJhP8Bu2guRjkdlXcoA1wJAQCCIQkBAIIhCQEAgiEJAQCCIQkBAIKJnYS2bt2q22+/Xc3NzUokEvrhD3845nHnnFatWqXm5mZNnTpVN910k3bv3l2q+QLhJaJHwvhfjFP84Yjxv0TcQ97DOxHgExI7CR09elRXXXWV1q1b53189erVWrNmjdatW6ft27crnU5ryZIlGhgYOOPJAgDKjDsDktwLL7xQ/O9CoeDS6bR74oknirGhoSHX0NDgvvvd73rPMTQ05DKZTPHo7e11Ov4JCA6OCXkkEr4jMQkO/9zlOybA68wx+Y9MJvOxeaSk94R6enrU19en9vb2YiyVSmnx4sXatm2b92s6OzvV0NBQPGbPnl3KKQEAJrCSJqG+vj5JUmNj45h4Y2Nj8bGPWrlypTKZTPHo7e0t5ZQAABPYuLTt+WirEuec2b4klUoplUqNxzQAABNcSa+E0um0JEWuevr7+yNXR8BEZ1WZTd5yslOvxwM+KSVNQi0tLUqn0+rq6irGhoeH1d3drba2tlI+FQCgDMT+c9yRI0f05ptvFv+7p6dHO3fu1LnnnqsLLrhAK1asUEdHh1pbW9Xa2qqOjg7V1NRo6dKlJZ04AKAMxC3Lfvnll72leHfffXexTPvRRx916XTapVIpd+ONN7pdu3ad8vkzmUzwskIODmmylF2PzxH6tecoj+NUSrQTzjmnCSSbzaqhoSH0NACzmOZsMMF+LWCSymQyqq+vP+kYNrVD6cT5pT2RfsmVINfYCcu/Tmv1dlGA7yviTdxZz+oJm5vxTaTvG8oCDUwBAMGQhAAAwZCEAADBkIQAAMGQhAAAwVAdh5PwV0iVpHLZqr6KUcFVKmZFmhn2PGC+JsZr+LGz+ijf+8V4r5W1TvM1Bz4BXAkBAIIhCQEAgiEJAQCCIQkBAIIhCQEAgqE6DrYA/TvjVqqV5knjVbB5+6qVan6xCtWMajez/ZxVNuf5AmOsVRlJSzmcLq6EAADBkIQAAMGQhAAAwZCEAADBkIQAAMFQHQdTyQrSfCcqVTVVnP5u1imski8rPJ7bfsfYWNXcndUoVbOq5nzj7W9PvB1kgY/DlRAAIBiSEAAgGJIQACAYkhAAIBgKE1A6cW7Yl6o7T5yWO9bYEhQg2IUQRpFACW7wW2coWOPj7IEXazDtfHD6uBICAARDEgIABEMSAgAEQxICAARDEgIABEN1HMbduO5HZz4QfSRpVccl/e/FEsl4m915xSsyi/UFzhibtE5hPamvnM6chtksyIhTHoeT40oIABAMSQgAEAxJCAAQDEkIABAMSQgAEAzVcdD41q/566NK1SPOHB7jHEmrCs6qmvOcPVlx6mMlqVAYNeLesJyvtM35B1s975xx8oJv6lYDOoN3fsAp4EoIABAMSQgAEAxJCAAQDEkIABAMSQgAEAzVcYhbeHaSXVFj9BWLsyPqyaZi7pbqqWAzquCSVhWcVU1XURGJVaem+MdWRsdKUn542BsfGfHH86P5SMx5y9pO0t/NWqevas7YWTVuEZxZqUc1Hf6AKyEAQDAkIQBAMCQhAEAwJCEAQDCxklBnZ6euvfZa1dXVadasWbrjjju0d+/eMWOcc1q1apWam5s1depU3XTTTdq9e3dJJw0AKA+xquO6u7t133336dprr9Xo6KgeeeQRtbe3a8+ePaqtrZUkrV69WmvWrNH3v/99XXzxxXr88ce1ZMkS7d27V3V1deOyCHyy7Aq2U69tsyryzGo349zW+Mqq6I/2lJoa79iqVMobL4z6+7s5T8+26ilWdVyVNz5irL9QiFbBSZIrRKvJClaDN6vwzIj7XltnlkDGrGqzntNzegrmzk4Jdwa1ku+//75mzZql7u5u3XjjjXLOqbm5WStWrNBDDz0kScrlcmpsbNSTTz6pe+6552PPmc1m1dDQcLpTwmmwfpHb481HTv0cVtPQSZuEpnrHmklo6Jg3nhsc9MZHR6JzKRgNSa1/0r5EZp3HOnfBaJpq/hoxf7tEHyAJlZ9MJqP6+vqTjjmje0KZTEaSdO6550qSenp61NfXp/b29uKYVCqlxYsXa9u2bd5z5HI5ZbPZMQcA4Oxw2knIOacHHnhAN9xwg+bNmydJ6uvrkyQ1NjaOGdvY2Fh87KM6OzvV0NBQPGbPnn26UwIATDKnnYTuv/9+vf766/r3f//3yGMf/ROJc878s8nKlSuVyWSKR29v7+lOCQAwyZxW256vfe1revHFF7V161adf/75xXg6nZZ0/IqoqampGO/v749cHZ2QSqWUMv4mj4nJ+tu9ea/I+0C8ezzJhP/9kq+FjiRVVVdHYtOmn+MdW1M3zT+XUX8LnWHPfZvRvL+gIJEw7q0Yr1XSbEPki8W7l+esooJT//Yo4WI2VjKG+36GrOXQ4qe8xboScs7p/vvv1/PPP6+f/vSnamlpGfN4S0uL0um0urq6irHh4WF1d3erra2tNDMGAJSNWFdC9913n5599ln9x3/8h+rq6or3eRoaGjR16lQlEgmtWLFCHR0dam1tVWtrqzo6OlRTU6OlS5eOywIAAJNXrCS0fv16SdJNN900Jv7000/rK1/5iiTpwQcf1ODgoO69914dOnRICxcu1JYtW/iMEAAg4ow+JzQe+JzQJy/uvYXY5/HEzXs/1nYLMe8JVaei94QaZp7nHTuu94SM7ROGh4a88aFBf3xkZCQSKxif+7H+SZuf/YnxOSHrs0Zxf43EGT/BfkUhhnH/nBAAAGeCTe0QZyu6jzmP/0y+dzp2BwTriscfr6r2/whXVUcrLq2rptpa/5VQKuUfX+G5WrOubDIHP/TGjQs+813/aN5zZeL8HR3idpfwxe2rWn/YYv1MeFsFGWtnY7zyxpUQACAYkhAAIBiSEAAgGJIQACAYkhAAIBiq46BEqerjrC1lPNVNVo+0ykqjIs2IVxr79aRqovv7TDc+JzTrok/7n3P4qP/c1dHnHDxyxDt2ZNj/WaOqnD9uVfD5NpkbNc49PBz9TFFcZuWZVdVnnMdqV+frY2dV9cWdi72HESYiroQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwVAdh/g7pcbkO01FjO7XkjS1psYbr5nm3yJk+oxzI7GZ5/8f79iZn7rcG08O/N4bHylE37sN537nn8c5073xwaP+yrupnqo+yd9Tb8joV5cYzHnjVtVcftTTATzh70vnHSspUfDH41TNWX3mrB9Es/KO8rhJhSshAEAwJCEAQDAkIQBAMCQhAEAwJCEAQDBUx5WrElW2xXpKq4rJs41ohbFT6tSpU7zxGefN9ManTZ/ujZ/TfEEklm6e7R/b5K+ay03zz2Uk+34kVq1G79hUyv9PLDd4LFY8kYxWEw4c8/eOSxX834djRwe98bxn19bc0ax/fkZcOX9FWkFW1Zxvjla5G9Vu5YwrIQBAMCQhAEAwJCEAQDAkIQBAMBQmTHZmAYJRJDBuE7ELE5Kem+rW5m3JpP99UU2tv53NjPOi7XkkadqM6AZ2ra1LvGNbL23zxve8vskbzxWiLYQqL7zEO3Yk4W9D9N7rP/fGB7OHvfFkdW0klqqY7h07HK0zkCQdO3zIGx8ajBYsZN/ztyEaHfIXTuSTxkZ6eesnLjrJuD+blCuUB66EAADBkIQAAMGQhAAAwZCEAADBkIQAAMFQHTfJBejOY7fnMeOnfu7KKn81WdKKeyrvJKmmOvr+6gPX7x1bUfGBNz798kXe+KE3dkRiDaMZ79iRmZ/yP+dln/HGD/7uXW+86eLoxnsfpC/yn2PPVm888c7/9caH330rOtb4niViV136a9h85zGK+tikrsxxJQQACIYkBAAIhiQEAAiGJAQACIYkBAAIhuq4SSNIHZw/ak0lRkVV0tjUzjpHjbHZ3bkz/b3jptTVR2Ijh3q9Y0dHh7zxS+dc4Y33TqmLxLKvbvaO/VR+vzf+bst8b3xqhb9HXlV+RvQ5B/3VflVJ/2Z3iVF/vDAc7R1XUVnlP0dlvF8ZVjWdS0Qr3jyh42NjPSMmG66EAADBkIQAAMGQhAAAwZCEAADBkIQAAMFQHTdp+GuErMohqyopjoRVrmS8d7F2RU0ko3OpMHq+VVXF+5EcHvZXfE3zlPBN8fSTk6Sp2bf95xia443fOG1mJPbLW77kHTuy82fe+PnD0Qo7Sfq/xvL7snujwVH/ekYP+6vmBt/3r3N0MLpb6uiI/3V1LmatmlUx6TmNfWbrZ5m6uXLAlRAAIBiSEAAgGJIQACAYkhAAIJhYd4HXr1+v9evX66233pIkzZ07V//0T/+kW2+9VdLxm5aPPfaYNmzYoEOHDmnhwoV66qmnNHfu3JJPHH9gtjoxNhPz3uON14fHV2gg2YUJFRXRIgRnPGXB2NlsaDDaWub4XPw/wiNHD0djzt+eR4f9rXV2ZWZ54zM8xRN1jS3+c1/2WW846Rq88dpjPd54dvhAJDZF/nNUVtZ64xVV/tZHuYG3IrGh7GHv2Pyw/zWMu9Gh96fTLGKIV5TjPQ81DBNWrCuh888/X0888YR++ctf6pe//KX+/M//XH/1V3+l3bt3S5JWr16tNWvWaN26ddq+fbvS6bSWLFmigYGBcZk8AGByi5WEbr/9dv3FX/yFLr74Yl188cX61re+pWnTpunVV1+Vc05r167VI488ojvvvFPz5s3Tpk2bdOzYMT377LPjNX8AwCR22veE8vm8Nm/erKNHj2rRokXq6elRX1+f2tvbi2NSqZQWL16sbdu2mefJ5XLKZrNjDgDA2SF2Etq1a5emTZumVCqlZcuW6YUXXtDll1+uvr4+SVJjY+OY8Y2NjcXHfDo7O9XQ0FA8Zs+eHXdKAIBJKnYSuuSSS7Rz5069+uqr+upXv6q7775be/bsKT7+0RuRzjnz5qQkrVy5UplMpnj09vr3fAEAlJ/YbXuqq6v16U9/WpK0YMECbd++Xd/+9rf10EMPSZL6+vrU1NRUHN/f3x+5OvpjqVRKqVQq7jRwmnxFQnEb/MSthPJVzSWtscZmaskKf3x4JO+N13g2tZvedL537GjeXzqVP/SON37sooWRWMpoiXP40FH/cx7zz1vV/nXOSl8YiQ0c9VfvDU33b4yXaXjLG+/3VDsmjDJFqwJSRhsmq82Pc9HzJ6zWVDG79vhaVlnVogjvjD8n5JxTLpdTS0uL0um0urq6io8NDw+ru7tbbW1tZ/o0AIAyFOtK6OGHH9att96q2bNna2BgQJs3b9Yrr7yin/zkJ0okElqxYoU6OjrU2tqq1tZWdXR0qKamRkuXLh2v+QMAJrFYSei9997Tl7/8ZR04cEANDQ268sor9ZOf/ERLliyRJD344IMaHBzUvffeW/yw6pYtW1RX5+8YDAA4u8VKQt/73vdO+ngikdCqVau0atWqM5kTAOAsQe84AEAwbGoHm1lab/UDO/U6u4RRTZWoOccbTzakvfHBY/6ecpkPD0XPbfROqzr/Am88e9C/OVwqHa1sqxvwf8h66Ji/L13W6JFXM+Svpjta2RSJVVX6X+/KCv8/6/yovyLPV8BmVSlWGt/jUfk3wSsY1XEJT3WcWb9m79wYbzwmJK6EAADBkIQAAMGQhAAAwZCEAADBkIQAAMFQHXe2idM8LuaOllafsIKnD1lljX9X0HOu8u9EWlVX443nel/1P+doLhI7YlW7Gf8Kpp7nr5ob7XszEnv34K+9Yy+cEe35Jkl7q/zv/44eG/HGh6pGI7Ged37hHfvBwYPeePbD97zxkdHouZXwzy9hVN5Z72aT1s6/nuo4FaxmcEavwrg7rmJC4koIABAMSQgAEAxJCAAQDEkIABAMSQgAEAzVcTBZu1E6o4opUel/T1MxNbqVR8UU//Ye+RF/ddiRD973xquH/T3Ljh6LVscNHTniH3voQ298VsHfP63a869mqD7a202S3j8a7WF3/Bz+PnZTpvirACunzYnEjmZ+7h17uM+/I+zQkcPeeLIi2sevIuWfX8L63hs7sSaM97m+nyFfFeXJzl2geVxZ4EoIABAMSQgAEAxJCAAQDEkIABAMhQkw2+0krBu/RhuVqvqZ3vjMS+ZHYtWplHfskTf9bXiSo8e88dqp/uKB9wvRgoWaKf7nrG/wtxA6uH+Pfy7Hom1xUhde6x07bdhfmDByrr+QoWbKuf74wd9GYrlkrX9+U6Z746NGEUdF9dToOYzX1RlFAlZByYin6EHyd+gp5D3tgyQVEv7N+OK2lcLExJUQACAYkhAAIBiSEAAgGJIQACAYkhAAIBiq42CyqowSSX/F0xSj4mvKzPMjsYqCv5rqWOaA/zlH/ZVduUF/RdVILtq2p1Dvb4lTa1THFUai55Ckw4ezkVhq33bv2Kom/2vS/7a/tU62713/XFLTIzFX3+gdm/S/VBrN+6vM8vloxVuF0YIpkTQqJo3fJIXR6lM+jzOqLk327orxzoOguBICAARDEgIABEMSAgAEQxICAARDEgIABEN1HGxWby7n7x82cjTjjQ/2vx2J5XNHvWNHP+zzxpPyV8FVVvjfR1VWRn+03bC//9zosL8KrrLC/89jat3hSCxV69+k7/33on3mJOlYzv8aZt/3r39KfbSnXE7+XniH3vmNNz6a869/ZCRaNTdq9IKz+gZadW15o8Iwb1Tq+di1blTBlQOuhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBUB2H2ApG5dTR9/z90ApDR6JBo8KuUv5zVxg9yyor/X3skp4dPY2CPB06+KH/3FX+3UV9u8JWpqK7k0pSZbX/HJVV/p5qR454XitJQ3vfiMSsXmvOqDwbMXZWHR2JVh4WCv4XK5Hwv291Rn1coeCfi+9nqGBVzPm2YRW1ceWCKyEAQDAkIQBAMCQhAEAwJCEAQDAUJiA2Z9wSHh0e9MaPHeqPxJLGTfVkhT9e4Sk0kKRKI15RFf3RrvbEjvM/58iocVPdMz7haX0jSa7gL8CQcYPfKh7IHYsWCowa505YTXSM17zgOY9voztJcmaRgBE3xufz0WIIq6DCOjeb15UHroQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZxRdVxnZ6cefvhhLV++XGvXrpUkOef02GOPacOGDTp06JAWLlyop556SnPnzi3FfDERxKxKKngqoYyaMSUL/vdFBaNSLW9tauertDIqtZJGS6CEUXk37GlzI/nnZ22YJ6Odja+FjiSNetaTN9aTSPpfE6si0VfBZrXQ8VW1SfaPhFUd6Kt4MysJqYIra6d9JbR9+3Zt2LBBV1555Zj46tWrtWbNGq1bt07bt29XOp3WkiVLNDAwcMaTBQCUl9NKQkeOHNFdd92ljRs36pxzzinGnXNau3atHnnkEd15552aN2+eNm3apGPHjunZZ58t2aQBAOXhtJLQfffdp9tuu0233HLLmHhPT4/6+vrU3t5ejKVSKS1evFjbtm3zniuXyymbzY45AABnh9j3hDZv3qxf/epX2r59e+Sxvr4+SVJjY+OYeGNjo95++23v+To7O/XYY4/FnQYAoAzEuhLq7e3V8uXL9YMf/EBTpkwxxyU+cgPUOReJnbBy5UplMpni0dvbG2dKAIBJLNaV0I4dO9Tf36/58+cXY/l8Xlu3btW6deu0d+9eSceviJqamopj+vv7I1dHJ6RSKaU8m4Rh8nFWFZOn6sl6U2JVSBWM8ZbRRLS6y+X8lWrWXMz4ULS/mzU9szrMeK18fdwka9O4U692k6S8UZPoe87CqL8KzpyfOW+DZ/1mhZ11DpSFWFdCN998s3bt2qWdO3cWjwULFuiuu+7Szp07deGFFyqdTqurq6v4NcPDw+ru7lZbW1vJJw8AmNxiXQnV1dVp3rx5Y2K1tbWaMWNGMb5ixQp1dHSotbVVra2t6ujoUE1NjZYuXVq6WQMAykLJt3J48MEHNTg4qHvvvbf4YdUtW7aorq6u1E8FAJjkEs78Q34Y2WxWDQ0NoaeBEvLdW4l9H8baf8jqDlAZ7XZQYYyNPZdk9NwT6Z6QORnj7srEvyfEfkKTVSaTUX19/UnH0DsOABAMO6uidGIUsJnvbs1TG5Vg5o6ennf3Md842+/AR6Ix86LEmHfsd/Ge8xhXdua0rcpDT58484rHvFyxdlw1xFk/VzxljSshAEAwJCEAQDAkIQBAMCQhAEAwJCEAQDBUx6FkrAq2Mx0rnaxS7dSrzwpG77Rkwv9ezK4EizE2Lus0nmUmYn42x654i8at/nPj+bHCCfaRRXxCuBICAARDEgIABEMSAgAEQxICAARDYQJsViuamEUF3tY1VnPQOOc4yfg44hQgHA/HaTkTK2w+kvCE/WUGslvoWHFPEUL8IgHrOY3hMTcpRPniSggAEAxJCAAQDEkIABAMSQgAEAxJCAAQDNVxMCvP4lawxammM4ujzOeMuQW3cXofs2osxjlMSWN+ZtmY9b7Q1yso5lzGs+WO+c1na26cHFdCAIBgSEIAgGBIQgCAYEhCAIBgSEIAgGCojjvL+KrJzAqzmFVz5nPGOLf9nNZUStCDzDqFUcDlf87SrOckzdYikYJZeWadwdgA0NuELu65jeEUweFjcCUEAAiGJAQACIYkBAAIhiQEAAiGJAQACIbqONj92uL2lIvVOy7uuWNWzfnDBqNqLMZoeznxZmL2sfOEK2Kew35OT3mcM16TmGVw1vrj79yKcsWVEAAgGJIQACAYkhAAIBiSEAAgGAoTylWMG/n2/nJGkUDS/94lTiuehLXZW8zChDjxuPfCrXWqED2RM8sYYj6pdYPfEzfP7G3DIyUS/vUkk9EzFayfCs/apZMVLBhx33hqFc5KXAkBAIIhCQEAgiEJAQCCIQkBAIIhCQEAgqE67izj3dgsZgudpFE1lqww4r7zWOcwn9PfpCZZYTSv8VbHWS1x/HFrnb4Ktnx+1Du0YMSdUWVmFpn5vm1xKs9kVxImfVVzVnFc0ii9M8J21SBwHFdCAIBgSEIAgGBIQgCAYEhCAIBgSEIAgGBiVcetWrVKjz322JhYY2Oj+vr6JB2vMnrssce0YcMGHTp0SAsXLtRTTz2luXPnlm7GGKsEm7qZVVMxq+Cqqqr84yujP2b2Zm/+eEWldW4j7inXGh21KtXy/plYG7J5Ktvy+VMfK0mFgr+czN4DL04vPKvnnzE6RnWcy8ftHUd1HE4u9pXQ3LlzdeDAgeKxa9eu4mOrV6/WmjVrtG7dOm3fvl3pdFpLlizRwMBASScNACgPsT8nVFlZqXQ6HYk757R27Vo98sgjuvPOOyVJmzZtUmNjo5599lndc8893vPlcjnlcrnif2ez2bhTAgBMUrGvhPbt26fm5ma1tLToC1/4gvbv3y9J6unpUV9fn9rb24tjU6mUFi9erG3btpnn6+zsVENDQ/GYPXv2aSwDADAZxUpCCxcu1DPPPKOXXnpJGzduVF9fn9ra2nTw4MHifaHGxsYxX/PH94x8Vq5cqUwmUzx6e3tPYxkAgMko1p/jbr311uL/v+KKK7Ro0SJddNFF2rRpk6677jpJ0Zu5zrmT3IQ+frWUSqXiTAMAUCbOqHdcbW2trrjiCu3bt0933HGHJKmvr09NTU3FMf39/ZGrI5SOtxfcSb/As8tpzF1LkxX+H5uKymp/vOrUq+OsYirfOU42F9/ZE0ZFmtX3TXn/+IKnmi5vVN7lY5xDivm9MMrd7HNYf/iIvuhJ4+fK6rMnZ7y21lw8p6HP3NnpjD4nlMvl9MYbb6ipqUktLS1Kp9Pq6uoqPj48PKzu7m61tbWd8UQBAOUn1pXQP/7jP+r222/XBRdcoP7+fj3++OPKZrO6++67lUgktGLFCnV0dKi1tVWtra3q6OhQTU2Nli5dOl7zBwBMYrGS0O9+9zt98Ytf1AcffKDzzjtP1113nV599VXNmTNHkvTggw9qcHBQ9957b/HDqlu2bFFdXd24TB4AMLklnPlH3jCy2awaGhpCT2PSOFnRh3e8pwtChbEnjxWvrPbf+6mu9heYjO89IX/HBN/ZR4aHvGNHR4b9T2p2O4jezxkdMe4JGfeKQtwTstsxRNfpjHtZ9r5JxnjjPpzvGz3BfhWhBDKZjOrr6086ht5xAIBg2Fl1soh7xWO+oz7zc/jeOR+PGu9kE9ErKmddCRnnGB31v6OuTBg92DyxgnFlkzf6oeVHR7xxed7dF/L+KxurR5wxFSWMq4EY7d3sHXGNKydfi0Bn7GRr9pRz/tfK2v2Vix6cwJUQACAYkhAAIBiSEAAgGJIQACAYChMmiZjNeU521/qUh1ols/ZGbUbcE04kjR89o9DAqnnIWzfyvRvPGcUDRtzFKDYwXytrgzmritooCEh64omkcW5zUzujMKEyGo/77tQq0bbivk3w4v4cojxwJQQACIYkBAAIhiQEAAiGJAQACIYkBAAIhuq4yS5eZx1vHxWrVY5VlVSw4tamcZ5mnRVGFZhVHRan+aYkFZyn0ab1mpiVbXGe0T+/isp466wwmsBWGnGfgtGQ1RlNU5Oeqrmk8XpXGN/jUaPyzqzg87RKogbu7MSVEAAgGJIQACAYkhAAIBiSEAAgGJIQACAYquMmiRjFbn94IOaJYk3GqEgztn7WiG/DM6uPmf8UVrWW2VbM+4B/sHnuONtkm33Z/AuqSk3xxitTNf7xU6d55uGf3vCxI954IXfMG/dWQRpvT62qPnsDxNhdD3GW4UoIABAMSQgAEAxJCAAQDEkIABAMSQgAEAzVcZOFVQZmVXYZp/GNtnZKdcYup64Qr5rMeXqZFaxKNVX5z2FUZVkvi3O+uRuDjbdiSd/2n/JXiFlVY1bPt8pqf3VcRbV//d4ebMZyKqv858g7/1zyo9HqRavPnLnLqVkdB5wcV0IAgGBIQgCAYEhCAIBgSEIAgGBIQgCAYKiOm+TsKjhrt1TvYP9Ys2rO2lnVX1HlPX3eqrDzz0VJ/7ntXnienTut+RnrtF6XhOcB3+6kJ4snKvxxl/fPcbQwGD2HdW5vZaCUSJz6e868MY+80R+wYIy3qunYRRUncCUEAAiGJAQACIYkBAAIhiQEAAiGwoTJzrzxa91V94y3Wt8YD1gFCEnjPU3B09IlYRUJGPUHCedvi2Px3RCP3YomRosaJ2Pio8Y6K/w3+L3teY4/EA054/U2Ci2sTQd9xRBWoUF+pDSFCb7X1hyLssaVEAAgGJIQACAYkhAAIBiSEAAgGJIQACAYquPKlVlp5Kvs8itY7V+syjuTpzrOGmoVpFXEm4tv+VZVn38DPJ2kh1D05IlkzPY0xiZwldXV3njS1+bH+h7no5vUSXZLIF9VmlVhlzdeQ6s6zooDJ3AlBAAIhiQEAAiGJAQACIYkBAAIJnYSevfdd/WlL31JM2bMUE1NjT7zmc9ox44dxcedc1q1apWam5s1depU3XTTTdq9e3dJJw0AKA+xquMOHTqk66+/Xn/2Z3+mH//4x5o1a5Z++9vfavr06cUxq1ev1po1a/T9739fF198sR5//HEtWbJEe/fuVV1dXannj5h8lVCnXgP2B0YxWcF6IMbZC0bFV7JgvF8yNmrzVbzF7RGXsNbjq2yzKu+MzfvsSj1rM0LPevL++VnVfs4Z/eBGo9V0Q0cGTnkscCYSLkbXwG984xv6n//5H/3sZz/zPu6cU3Nzs1asWKGHHnpIkpTL5dTY2Kgnn3xS99xzz8c+RzabVUNDw6lOCSWQMMqF4463mm/6dhc1dxy1dii1dgUd1yR06g1MrdckWeF/n1eRmuKNVxnxZIWngWshXhLKj/qbj44MD0dix7JZ4xwkIZy6TCaj+vr6k46J9ee4F198UQsWLNDnPvc5zZo1S1dffbU2btxYfLynp0d9fX1qb28vxlKplBYvXqxt27Z5z5nL5ZTNZsccAICzQ6wktH//fq1fv16tra166aWXtGzZMn3961/XM888I0nq6+uTJDU2No75usbGxuJjH9XZ2amGhobiMXv27NNZBwBgEoqVhAqFgq655hp1dHTo6quv1j333KO/+7u/0/r168eM++ifJpxz5p8rVq5cqUwmUzx6e3tjLgEAMFnFSkJNTU26/PLLx8Quu+wyvfPOO5KkdDotSZGrnv7+/sjV0QmpVEr19fVjDgDA2SFWddz111+vvXv3jon95je/0Zw5cyRJLS0tSqfT6urq0tVXXy1JGh4eVnd3t5588skSTRmlZt2wt65ezRv8VtVcjCKBhLUrqG9H2ONfYMR9J7Gq9069z54keesvjLdzVhWcRuLd4E8mo4UJztgpdfDoEW88NzgY6zmBT0KsJPT3f//3amtrU0dHh/76r/9av/jFL7RhwwZt2LBB0vFfWitWrFBHR4daW1vV2tqqjo4O1dTUaOnSpeOyAADA5BUrCV177bV64YUXtHLlSn3zm99US0uL1q5dq7vuuqs45sEHH9Tg4KDuvfdeHTp0SAsXLtSWLVv4jBAAICLW54Q+CXxOaOIo2eeHfJ+rMT5TlDA+92PFrS0RxvfPcTHWY33uqdK/ZUNFVZV/PH+OwyRU8s8JAQBQSmxqB5N5kWxdfVgtZ3ybwBntbGQUICTMAoQYV2uxOyMY3Rh8V0LGBngJ4+rL2jRuZGjIG88NcRWD8sSVEAAgGJIQACAYkhAAIBiSEAAgGJIQACAYquMQn1kFZ433hMziOOPcMT+zFId5ZqMizzsVq5ORuefPhPp4HhAMV0IAgGBIQgCAYEhCAIBgSEIAgGAmXGECN2zPEnGLGyY6Y+L8PONsdio//xMuCQ0MDISeAiaicfxlblf1lVmiBD5hAwMDH7srwoTbyqFQKOj3v/+96urqNDAwoNmzZ6u3t7est/3OZrOss4ycDes8G9Yosc7T5ZzTwMCAmpublTS2Mzlhwl0JJZNJnX/++ZL+/z409fX1Zf0DcALrLC9nwzrPhjVKrPN0nOq+cBQmAACCIQkBAIKZ0EkolUrp0UcfVSqVCj2VccU6y8vZsM6zYY0S6/wkTLjCBADA2WNCXwkBAMobSQgAEAxJCAAQDEkIABAMSQgAEMyETkLf+c531NLSoilTpmj+/Pn62c9+FnpKZ2Tr1q26/fbb1dzcrEQioR/+8IdjHnfOadWqVWpubtbUqVN10003affu3WEme5o6Ozt17bXXqq6uTrNmzdIdd9yhvXv3jhlTDutcv369rrzyyuInzBctWqQf//jHxcfLYY0f1dnZqUQioRUrVhRj5bDOVatWKZFIjDnS6XTx8XJY4wnvvvuuvvSlL2nGjBmqqanRZz7zGe3YsaP4eJC1uglq8+bNrqqqym3cuNHt2bPHLV++3NXW1rq333479NRO249+9CP3yCOPuOeee85Jci+88MKYx5944glXV1fnnnvuObdr1y73+c9/3jU1NblsNhtmwqfhs5/9rHv66afdr3/9a7dz50532223uQsuuMAdOXKkOKYc1vniiy+6//qv/3J79+51e/fudQ8//LCrqqpyv/71r51z5bHGP/aLX/zCfepTn3JXXnmlW758eTFeDut89NFH3dy5c92BAweKR39/f/Hxclijc859+OGHbs6cOe4rX/mK+9///V/X09Pj/vu//9u9+eabxTEh1jphk9Cf/MmfuGXLlo2JXXrppe4b3/hGoBmV1keTUKFQcOl02j3xxBPF2NDQkGtoaHDf/e53A8ywNPr7+50k193d7Zwr33U659w555zj/vVf/7Xs1jgwMOBaW1tdV1eXW7x4cTEJlcs6H330UXfVVVd5HyuXNTrn3EMPPeRuuOEG8/FQa52Qf44bHh7Wjh071N7ePibe3t6ubdu2BZrV+Orp6VFfX9+YNadSKS1evHhSrzmTyUiSzj33XEnluc58Pq/Nmzfr6NGjWrRoUdmt8b777tNtt92mW265ZUy8nNa5b98+NTc3q6WlRV/4whe0f/9+SeW1xhdffFELFizQ5z73Oc2aNUtXX321Nm7cWHw81FonZBL64IMPlM/n1djYOCbe2Niovr6+QLMaXyfWVU5rds7pgQce0A033KB58+ZJKq917tq1S9OmTVMqldKyZcv0wgsv6PLLLy+rNW7evFm/+tWv1NnZGXmsXNa5cOFCPfPMM3rppZe0ceNG9fX1qa2tTQcPHiybNUrS/v37tX79erW2tuqll17SsmXL9PWvf13PPPOMpHDfzwm3lcMfO7GVwwnOuUis3JTTmu+//369/vrr+vnPfx55rBzWeckll2jnzp06fPiwnnvuOd19993q7u4uPj7Z19jb26vly5dry5YtmjJlijlusq/z1ltvLf7/K664QosWLdJFF12kTZs26brrrpM0+dcoHd+rbcGCBero6JAkXX311dq9e7fWr1+vv/mbvymO+6TXOiGvhGbOnKmKiopI9u3v749k6XJxohqnXNb8ta99TS+++KJefvnl4v5QUnmts7q6Wp/+9Ke1YMECdXZ26qqrrtK3v/3tslnjjh071N/fr/nz56uyslKVlZXq7u7Wv/zLv6iysrK4lsm+zo+qra3VFVdcoX379pXN91KSmpqadPnll4+JXXbZZXrnnXckhfu3OSGTUHV1tebPn6+urq4x8a6uLrW1tQWa1fhqaWlROp0es+bh4WF1d3dPqjU753T//ffr+eef109/+lO1tLSMebxc1unjnFMulyubNd58883atWuXdu7cWTwWLFigu+66Szt37tSFF15YFuv8qFwupzfeeENNTU1l872UpOuvvz7ycYnf/OY3mjNnjqSA/zbHreThDJ0o0f7e977n9uzZ41asWOFqa2vdW2+9FXpqp21gYMC99tpr7rXXXnOS3Jo1a9xrr71WLDt/4oknXENDg3v++efdrl273Be/+MVJVwr61a9+1TU0NLhXXnllTMnrsWPHimPKYZ0rV650W7dudT09Pe711193Dz/8sEsmk27Lli3OufJYo88fV8c5Vx7r/Id/+Af3yiuvuP3797tXX33V/eVf/qWrq6sr/q4phzU6d7zMvrKy0n3rW99y+/btc//2b//mampq3A9+8IPimBBrnbBJyDnnnnrqKTdnzhxXXV3trrnmmmKZ72T18ssvO0mR4+6773bOHS+RfPTRR106nXapVMrdeOONbteuXWEnHZNvfZLc008/XRxTDuv827/92+LP5nnnneduvvnmYgJyrjzW6PPRJFQO6zzxWZiqqirX3Nzs7rzzTrd79+7i4+WwxhP+8z//082bN8+lUil36aWXug0bNox5PMRa2U8IABDMhLwnBAA4O5CEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADBkIQAAMGQhAAAwZCEAADB/D9Sb9Zt+VofxAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGfCAYAAAD22G0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtUUlEQVR4nO3dcWzc9X3/8dedz77YjnMU2vhsETK3NQUSoJCwEMNINBpXjKEhpKoltEs1aSIF2kRsgoVIS5iKnWValFahQckqFkRp/gG6VGtLPBWcTRFrmhLhJlWaKi54bTwPlp5NYt/Zd5/fH1nuV3Oft/E3PvOxz89H9ZXK5/v1577fs5O3v/m+7v2JOeecAAAIIB76BAAAcxdFCAAQDEUIABAMRQgAEAxFCAAQDEUIABAMRQgAEAxFCAAQDEUIABAMRQgAEExiuib+1re+pX/4h3/QmTNntGTJEu3cuVN/9Ed/9IFfVygU9Nvf/lYNDQ2KxWLTdXoAgGninNPQ0JCam5sVj3/AvY6bBvv373fV1dVu79697sSJE27Dhg2uvr7evfXWWx/4tX19fU4SGxsbG9ss3/r6+j7w7/yYc+VvYLpixQrdfPPN2r17d3Hs2muv1b333qvOzs4JvzaTyeiyyy4r9ykBAD5kv/vd75RKpSY8puzPhHK5nI4ePar29vZx4+3t7Tp8+HDJ8dlsVoODg8VtaGio3KcEAAhgMo9Uyl6E3nnnHeXzeTU2No4bb2xsVH9/f8nxnZ2dSqVSxW3RokXlPiUAwAw1bem491dA55y3Km7atEmZTKa49fX1TdcpAQBmmLKn4z760Y+qqqqq5K5nYGCg5O5IkpLJpJLJZLlPAwAwC5T9TqimpkbLli1TV1fXuPGuri61tbWV++UAALPYtHxO6NFHH9WXvvQlLV++XCtXrtSePXv09ttva/369dPxcgCAWWpaitDnP/95vfvuu/q7v/s7nTlzRkuXLtUPfvADLV68eDpeDgAwS03L54SmYnBw8ANz5QCAmS+TyWjBggUTHkPvOABAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwkYvQoUOHdM8996i5uVmxWEzf+973xu13zmnr1q1qbm5WbW2tVq9erePHj5frfIHxYtYWK9liM2iLct7WuQOVIHIROnfunG688Ubt2rXLu3/79u3asWOHdu3apSNHjiidTmvNmjUaGhqa8skCACqMmwJJ7uWXXy7+d6FQcOl02m3btq04NjIy4lKplHvmmWe8c4yMjLhMJlPc+vr6nCQ2tsltMWuLlWyxGbRFOW/r3IO/92xsH7BlMpkPrCNlfSbU29ur/v5+tbe3F8eSyaRWrVqlw4cPe7+ms7NTqVSquC1atKicpwQAmMHKWoT6+/slSY2NjePGGxsbi/veb9OmTcpkMsWtr6+vnKcEAJjBEtMx6fsfmjrnzAepyWRSyWRyOk4DADDDlbUIpdNpSRfuiJqamorjAwMDJXdHgJfxy0qlZcFiZbiiqAk5Z+4w9wDTrqz/HNfS0qJ0Oq2urq7iWC6XU3d3t9ra2sr5UgCAChD5Tui9997Tr371q+J/9/b26tixY7r88st11VVXaePGjero6FBra6taW1vV0dGhuro6rV27tqwnDgCoAFFj2a+++qo3irdu3bpiTHvLli0unU67ZDLp7rjjDtfT0zPp+TOZTPBYIVvALUJEmS1qLNzYQn/P2Sp2m0xEO+bczPoH4cHBQaVSqdCngVDmyDOhEMw/6DPrrwBUkEwmowULFkx4zLSk4zBHmZWidMeMKirWyThzx9TntkxjPbC/PZM/SWedIHUMl4gGpgCAYChCAIBgKEIAgGAoQgCAYChCAIBgSMchummNURuzRJy8LOcSIe1XNhGmtgNp05dgM9sNGcOk6fBBuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM6DhME0qYzBVamhF0Z+tVZQa0w/e38Z+O812Mlz8qUYPMfHEmUNB1JurmJOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTj5hpPKq1sKbByJN7Klpqb/FeU5TexMizCeuFw6/o9E0VOwRmHRzlHa+4yLBFuJensBW6JzVUC7oQAAMFQhAAAwVCEAADBUIQAAMEQTKhU07nwXNS5PTvsdi5R5578FZVjjsjMqf0P1a2QgDewYBxshQTs7IRvT8QWOtZ7WJbAgjH1NL4mPjzcCQEAgqEIAQCCoQgBAIKhCAEAgqEIAQCCIR1XoaK1yrGGI6bGrGRbOdJx1qmYaTrvi07+2Il4XzNyf54ow4p5El9mqxw7Yuc/3LPDah9kLTxnLrBnzuMbjPYeRkk7lqOtEKYHd0IAgGAoQgCAYChCAIBgKEIAgGAoQgCAYEjHzXZl6HsWNR0Ws17TDLz5FtIzUm1xKx1nxuOM40t/v7LmLkdqLnIbM2OHmeFyhZKhgjV56aEXhmPGDt80ZpLOmMIK5Fnvre8LjDfRfk8iJN7oMzdjcScEAAiGIgQACIYiBAAIhiIEAAiGIgQACIZ03GwRLdg1wTxREl9R+7tF6B3nSa9NNEfcOr5q8im7uKqMY61z8Q5733Sr15odG4u2KqpvPF7wp91cPOKqrZ5pnDW3f4qJlm2dtOgrwk4eq7POXNwJAQCCoQgBAIKhCAEAgqEIAQCCiVSEOjs7dcstt6ihoUELFy7Uvffeq5MnT447xjmnrVu3qrm5WbW1tVq9erWOHz9e1pMGAFSGSOm47u5uPfzww7rllls0NjamzZs3q729XSdOnFB9fb0kafv27dqxY4f++Z//WVdffbW+/vWva82aNTp58qQaGhqm5SLmhqirf0YYjpqCs17SnKb0d5241SMu7k+wxY0EW5VxvKpKx6uM14ybr2md4+R/d7NWIlXBSMEZ44XCWMlY3kiwFfL+8XjBf955T085KzVWMF5zgiZ5kx61U3BWas7oNRch2VaO5B2mJuamsO7t//zP/2jhwoXq7u7WHXfcIeecmpubtXHjRj3++OOSpGw2q8bGRv393/+9HnzwwQ+cc3BwUKlU6lJPqXJFLAiRmnJGjVxbL2k2H6UIlQhQhKzYtW8e61irCEWJlpvjZlPXaMuVl2Mpb5YDL49MJqMFCxZMeMyUngllMhlJ0uWXXy5J6u3tVX9/v9rb24vHJJNJrVq1SocPH/bOkc1mNTg4OG4DAMwNl1yEnHN69NFHdfvtt2vp0qWSpP7+fklSY2PjuGMbGxuL+96vs7NTqVSquC1atOhSTwkAMMtcchF65JFH9Oabb+q73/1uyb73/zOOc878p51NmzYpk8kUt76+vks9JQDALHNJbXu++tWv6sCBAzp06JCuvPLK4ng6nZZ04Y6oqampOD4wMFByd3RRMplUMpm8lNOoYL5F4KY+R9Qjy/HsxzrefA5TZTz7qfL/qMYT/nmqEqXHJzxjF17TP54wzsXXosd6TmS2ojGe/eTzpc9+JP9zm3x+1H/sqPXsxz+3xvIlQ9ZzpVis9FjJflZUMK5TvjCEkXkw2w2ZK+/5+ipFfMZDO58PTaQ7IeecHnnkEb300kv68Y9/rJaWlnH7W1palE6n1dXVVRzL5XLq7u5WW1tbec4YAFAxIt0JPfzww3rhhRf0L//yL2poaCg+50mlUqqtrVUsFtPGjRvV0dGh1tZWtba2qqOjQ3V1dVq7du20XAAAYPaKVIR2794tSVq9evW48WeffVZf/vKXJUmPPfaYhoeH9dBDD+ns2bNasWKFDh48yGeEAAAlpvQ5oenA54Qk7zOhqA+FInzGx16CYfLLJFw4fvLPhKzP9/BM6MN/JpSP8EzIFcrzTMjJ90yoTMteRJjDYh49s/66nPGm/XNCAABMBYvazUTRo3CTn8K/wtzkj1X0Oydft4O4p6OBNMHdijFeU+0fr6ouTVzWJKuN1/SPVxl3Wb67ryrjLjAfsTOCM+6ERj3jo7mc/9hR6w7JP/dYvPT4sTHrrsn63vvvkCTjzsl53i9PYk6y70rMn3HP3YqL2J+Hdj4fHu6EAADBUIQAAMFQhAAAwVCEAADBUIQAAMGQjpuBIoXjIn6AyPs5IXPqqafgLoyXpsmsdFzcSLvVeNJuklRdU+MdT9bOKx2rKR2TpJp5xtxVRpqupvQcY8axzkiH5cestYD8qbRcLlsyNuoZk6TssD81NzY64h0fGfF8L2L+OWIykndGOM78GKJvDSNrIT3/DPZHdnwB0Kj95yz0lCs77oQAAMFQhAAAwVCEAADBUIQAAMFQhAAAwZCOm+Ui9YizvqBcvePMdFzpeMLoXF1t9HGrThopuHl1/vG62pKx+jr/sTW1pcdKUl2t//i4Jx1XZaT9rPBVwUjHZY2ebW74XMnYyLA/HXe+pvRYScqOGH32YsMlY8NGL7yc9bMyanW69h/uSw2aYTejQ/cEkbdJzx017Wb2lPPtIDA3KdwJAQCCoQgBAIKhCAEAgqEIAQCCoQgBAIIhHRdSlLZvZVht1ZrIDtJZO/y/u5jpOM9KpPFqf5qsqsZIxxl933wpOEman5pfMlZX71/rvra+wTteV2sk8mpKe80V4v4/SjEjZeWqjN5xI/7ebMMjpUm9qvPnvcfGz/nPu+o9f2ou5unt56zvsTOSasa4sYCsnK8jnLH8aT5iepM+brMLd0IAgGAoQgCAYChCAIBgKEIAgGAIJswaU1+8zh632vMYc5iL2lnjnmCC8SA/UW2EAYwAQq3RiqeutjRsUJ/yBxPmL/AHE+qT9f5zqS8NSTgjlFFtPOAfMxavK2T9q8PVeBakqx0a8h47VGOEPoyF9+K+jICxSl2+4A9OFIxgQt5oueN8i9r5TkRS3Gp95B/2/uCaLYGs4Ig1t4m+PZeKOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjgipHL56Ic3iSQ1EXxjMXtYv5U1neRe0SERe1q/Gn5uYZ6bhkQ2nbnlStPx1XV3eZd3xBylgEb17pOVbFjLY91f7f84xwnEZzpSk4SaoeKU3kjRjvYTxhtNwp+L9vznMyY85Ix+WN9jwF//GJMf94wTOPixnHxqxF7SbftsdcjM4Yj4ps3KXjTggAEAxFCAAQDEUIABAMRQgAEAxFCAAQDOm4gMqyTl20JnHGsVbazVq8LlpqzpeOMxe1M3rH1cwrXUhOkpLz/Am2+rrSfnDJ+aWJOUlqqPfPUVvnP76utjQdl6z2p/pixuJ1Y2P+9zY36l+8r7qmNDVXbfwO6fL+XNbYiD99NubpB5cb8af0stmsdzyR83/f4gl/DLBqrPQ189bPVT7iDzlRtVmFOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjZjtzychyZO/Myf2jVrrJk46r8qy2KklVCWtVUCM1V+NPpdV6Emzz5vl/3Gvm+5N3dfP9xzckSxNs8+b5zzuW8J93Qf6kWm7ESJN5lheNFXLeY0cL/lVos9lh7/hwtvR6EkbqsMZIzY1W+X+fjVcZ74vn+2+mMc30pndYznl2mM3jjJ/xCH3pMDXcCQEAgqEIAQCCoQgBAIKhCAEAgokUTNi9e7d2796tX//615KkJUuW6G//9m911113SZKcc3ryySe1Z88enT17VitWrNDTTz+tJUuWlP3EZ5Wy9OeJOrf/AWrM9wVW95Myjcc9i91ZD5vtwIL/96WEsQiei5eOx4zWOvOq/X8MklX+wEKtp4VQbZ2x6J7xYH7UWATOHx2QCqOl5zg26n/NbLXR4ijpH5/nCVokE/7vz7AVNDAW2It5AhUXxj2LK5o/VxHa8xjzmHmC6V7tDh8o0p3QlVdeqW3btumnP/2pfvrTn+qP//iP9Wd/9mc6fvy4JGn79u3asWOHdu3apSNHjiidTmvNmjUaGhqalpMHAMxukYrQPffcoz/5kz/R1VdfrauvvlpPPfWU5s+fr9dff13OOe3cuVObN2/Wfffdp6VLl2rfvn06f/68Xnjhhek6fwDALHbJz4Ty+bz279+vc+fOaeXKlert7VV/f7/a29uLxySTSa1atUqHDx8258lmsxocHBy3AQDmhshFqKenR/Pnz1cymdT69ev18ssv67rrrlN/f78kqbGxcdzxjY2NxX0+nZ2dSqVSxW3RokVRTwkAMEtFLkKf+tSndOzYMb3++uv6yle+onXr1unEiRPF/e9/iOicsx8sStq0aZMymUxx6+vri3pKAIBZKnLbnpqaGn3yk5+UJC1fvlxHjhzRN77xDT3++OOSpP7+fjU1NRWPHxgYKLk7+n3JZNJM7eD/ix6w83+FL/QTM5JAdocSo42K+TuNp+WMcawZhIq4kJ7v+BojeRczWs7EavzH19SUHl/rGZOkeUYboqSMc/GH5nS+urSdTyJu/LlJ+Beek3H98rRVinnShRfGjfY81niEn1xvclMTBNUi/dxGbEFlHB8pNEfyblKm/Dkh55yy2axaWlqUTqfV1dVV3JfL5dTd3a22trapvgwAoAJFuhN64okndNddd2nRokUaGhrS/v379dprr+lHP/qRYrGYNm7cqI6ODrW2tqq1tVUdHR2qq6vT2rVrp+v8AQCzWKQi9N///d/60pe+pDNnziiVSumGG27Qj370I61Zs0aS9Nhjj2l4eFgPPfRQ8cOqBw8eVENDw7ScPABgdotUhL797W9PuD8Wi2nr1q3aunXrVM4JADBH0DsOABAMi9p9KKazeZwlarMs35HRztsZcTpvgM3oKWaetZEac67gHY97Fo3zrXUmSXnjvGsK/rkL+dLjXd5Idpn9zfwXZF1PwvMmuir/HDGjL12UsJaVmDR/IgrWFxjJw0mex0QvWp4/VWVIwWFKuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM67sNgNWGboLFryRTG+PTm7iJmhIxIlTc4ZaWpjHRY3ho3kmD53GjJWC6b8x47lvP3Wjs3WrriqCTVeOYeqfJ/JwoFf782Z7xXuZz/Okc8rzk6bLwno6V95iRpLO9/r+L50rnHCv458kZi0EpGRhq3/pxYc0T54bd+lKczBkfEblK4EwIABEMRAgAEQxECAARDEQIABEMRAgAEQzpuljCDQGVI3plTR33NCEkoK+3m8v5Ulhvzjxey/vHRsdL5R8dKU2CSlM35U2PZYSM1lyj9Y1Ow+ptlo604OjziP8fh4dLrHMn703454z0seBJ2kj95Z6YUZcxtJO+clYL0/nRZP1cRppDRl45VTmcs7oQAAMFQhAAAwVCEAADBUIQAAMEQTJglzLY9VgAhSp8fO4HgHzUeNueN8YTnoXVhzP8ge8wYHx3xhwSyuWHv+Mhw6Xhdjb8NT7am2js+GPO33PEZHvHPUVvt//6MGe188qP+sMG58+dLxnLn/e/J8Mh73vHz2dI5JCnnec2R7Ij3WJczgiBWGMIIlPh+VoyOQJGzA97jCSDMWNwJAQCCoQgBAIKhCAEAgqEIAQCCoQgBAIIhHRdQWRaqK8uCeVYKzn98Ie7fUWUtMOcZzxtpKmvhuew8fwouez7pHU96jh80UnCxhH+84Izf0QqlbW6qq/x/lM7X+Odwef/42KjRtseTVhvxJOYk6fyQP9lmHZ8dKR0fy/qTd6NZoz2Pp02SJBXMHyLfuBWPi7ZgXlmicObc0/aKcxZ3QgCAYChCAIBgKEIAgGAoQgCAYChCAIBgSMfNFhFTcGbyzjePGaSzkk3+L7B6f+U9vePyVk8xY+G53LB//HzCn5qLDQ16Rv2/c8WMN2vU+V9zLFtTOkfcn7BLJIz+czEjTWb0zsuOlo6fP2f0iHvPd+3SyPlz/vEhT186o3dcbtT/flvfNysFWfD8sBSM3oN2Cs5QjqhaxEXwYp4dJOYmhzshAEAwFCEAQDAUIQBAMBQhAEAwFCEAQDCk44Kaevc4ewYjaeQdNNJuZmsu/46Y0Tsuli+d3+qRNhr3/14Ur/KPV1X502fxROnxLm6sCGuk4EZH/f3Tcp4VWquM3nGxav+41a+vkPWn5kbzpeeSM/q7DRupuffO+dNxw57VaUdG/Om4Uev7Nmqk4PJGCtD3s2L0mbPScea4dyzCn4cJdxiHE4W7ZNwJAQCCoQgBAIKhCAEAgqEIAQCCIZgQUnlWtTOGo0xizRGtbY8zFrsreNv2+AMFubgRboj5H3zHYv6F2hQvPUeXjxYGsBbYG64p/WMTT/gX10sk/H/ErAf28Zj/+kezpYGA4RFjAcCssQCgEUwYOV8aZMgN++ceNcIQY5Hb9njGrB9D8+fTP+xNCZQrgYCy404IABAMRQgAEAxFCAAQDEUIABAMRQgAEMyU0nGdnZ164okntGHDBu3cuVPShVYaTz75pPbs2aOzZ89qxYoVevrpp7VkyZJynO+c4EsDxazIXORwnO8Los1dMFaBixnxpoJnATdXMBa184esNGpdj5HI872HY2NG4stqz+NZvE6SEjWlSbiY0VYoETcWtbNazhjvra8tjtX6KGek5nJZf5IwO1zaomfMSsGN+uf2LVwoSS5C2x67PY93WBPE46wvmNKhmB6XfCd05MgR7dmzRzfccMO48e3bt2vHjh3atWuXjhw5onQ6rTVr1mhoaGjKJwsAqCyXVITee+89PfDAA9q7d68+8pGPFMedc9q5c6c2b96s++67T0uXLtW+fft0/vx5vfDCC2U7aQBAZbikIvTwww/r7rvv1mc+85lx4729verv71d7e3txLJlMatWqVTp8+LB3rmw2q8HBwXEbAGBuiPxMaP/+/frZz36mI0eOlOzr7++XJDU2No4bb2xs1FtvveWdr7OzU08++WTU0wAAVIBId0J9fX3asGGDnn/+ec2bV7qmykWx2PinyM65krGLNm3apEwmU9z6+vqinBIAYBaLdCd09OhRDQwMaNmyZcWxfD6vQ4cOadeuXTp58qSkC3dETU1NxWMGBgZK7o4uSiaTSib9fbfmLF+0LVI/OSlabK48K3gVjF5zcU+vuTEjTRW3Yn0xfxLMam/nG8+P+RN5Yzn/eLa62jtelSjtzVZlLMYna9xIElqXX/CkCfNj/vcwn7MWnjPGPUk4qxfcmLV4nXUuviZxkpxn3JnfzKiL2nn6BsqY22AH8ojTlVukO6E777xTPT09OnbsWHFbvny5HnjgAR07dkwf//jHlU6n1dXVVfyaXC6n7u5utbW1lf3kAQCzW6Q7oYaGBi1dunTcWH19va644ori+MaNG9XR0aHW1la1traqo6NDdXV1Wrt2bfnOGgBQEcq+lMNjjz2m4eFhPfTQQ8UPqx48eFANDQ3lfikAwCwXc9Y/rAYyODioVCoV+jQCK/03bSPXEWWK/xv2ze0/2Bw3nnPEPGv4SFLc0zUgbnQYiMf9vxclqo3xKv9zm+pkabcDc45qozOC+UyodJ6580zI6Jgw6j+XMWs9Ic8zQeuZorPeK+t5k2/MfN4UaZhnQhFlMhktWLBgwmPoHQcACIaVVWek0t+2fIkfaYLQXIRVW82VK825rRVX/b/TOHl+6zXnNhJsxjlavyUXXOlrjhmruSaM3+6rqvx/POKecevOzr6BNVanjXA3kDf67/nuMiRpzLpb8dz15I07IWtus3ecp0ecZCTbrDseMwVniLSyKkLjTggAEAxFCAAQDEUIABAMRQgAEAxFCAAQDOm42cL6fELEDxB5V201PpwSPVBkJNU8ga+YlY+L+qIR0nGFvD8dlx8zet4Z/eriidJ57G9DxA94mZ9b8ezI+w/Oe65d8q9mKvk/b2Sl4ArGZ3Ps8ckn3syPLEYdLwc+D/Sh4U4IABAMRQgAEAxFCAAQDEUIABAMwYRZLkJ3HvMLzHXkrFY5kZ/Z+lq0+I8sxKI9hC7EjVCB56LMY43F7sxWPGOT/93NagIbOa/gecBvNuU0wgB5400v5D0LzJmL0UVb0NBsQxQhmBD1xy1yGyoExZ0QACAYihAAIBiKEAAgGIoQACAYihAAIBjScbOdlSiyluaOMIcd4SpHisla1s7/mgVrdmMhPd/0sbhx3sYS3NZCbb7Em9m2J2acX9R1BO1lAEuPNRJs1mKEBV9SLeoCc5EXpPMt3GiIMMfEE/mmJkkXGndCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGBIx1WsyF3lPDNEmyNmppgiNEoz037+cSuVlveMx4xF4GJWDzbrOid/qN07LnI6LsIk1ntoHu5rKDj1tNuE477hqL3joqTgJn8oPmTcCQEAgqEIAQCCoQgBAIKhCAEAgqEIAQCCIR1XqawklCdlFrOiXRFjSWa/Ol9vMjNNFSGRJpn90HxfYM5tLC1rds4zG8WVQ7R+fVGYybYI/dPMYyMn2yI1eJv8sdM5B6YFd0IAgGAoQgCAYChCAIBgKEIAgGAIJsw1vg4txuNjs+WMOffkH06bYYiIgQXz3I3Z/ZNYQQvr+MnPXq4IQ1keq0cJD0QNpZTlNaNdZVlCDwiOOyEAQDAUIQBAMBQhAEAwFCEAQDAUIQBAMKTjYLJatEROzUWYO2rXGvNwbyQv4kJ/5uER2txEbsNThrY95Vgwr0wJsygtgcw57MmnPDfC404IABAMRQgAEAxFCAAQDEUIABAMRQgAEEykIrR161bFYrFxWzqdLu53zmnr1q1qbm5WbW2tVq9erePHj5f9pBGWc86/Sd4t2uTW5ryb9b8oc9vXY/yvoNLNmsPcrEuKOk+E8zaO97+v1tsVce5I33rje2m9WagIke+ElixZojNnzhS3np6e4r7t27drx44d2rVrl44cOaJ0Oq01a9ZoaGiorCcNAKgMkT8nlEgkxt39XOSc086dO7V582bdd999kqR9+/apsbFRL7zwgh588EHvfNlsVtlstvjfg4ODUU8JADBLRb4TOnXqlJqbm9XS0qIvfOELOn36tCSpt7dX/f39am9vLx6bTCa1atUqHT582Jyvs7NTqVSquC1atOgSLgMAMBtFKkIrVqzQc889p1deeUV79+5Vf3+/2tra9O6776q/v1+S1NjYOO5rGhsbi/t8Nm3apEwmU9z6+vou4TIAALNRpH+Ou+uuu4r///rrr9fKlSv1iU98Qvv27dOtt94qqbSli3NuwjYvyWRSyWQyymkAACrElCLa9fX1uv7663Xq1Knic6L33/UMDAyU3B2hQllJq+lK0smYpEwpM/skPZkxK8Blx+Aibva1ll57xCkmmZibcJKo37ZI7zcq2ZSKUDab1S9+8Qs1NTWppaVF6XRaXV1dxf25XE7d3d1qa2ub8okCACpPpH+O++u//mvdc889uuqqqzQwMKCvf/3rGhwc1Lp16xSLxbRx40Z1dHSotbVVra2t6ujoUF1dndauXTtd5w8AmMUiFaH/+q//0v3336933nlHH/vYx3Trrbfq9ddf1+LFiyVJjz32mIaHh/XQQw/p7NmzWrFihQ4ePKiGhoZpOXkAwOwWc+VY8KOMBgcHlUqlQp8GppsRVpn6SkXlE2XdJOsPUYjrifwHOsBfATPsrx1Mk0wmowULFkx4DL3jAADBsLIqwjB+EzbvKMqwmmtU07oqaIWZsF8fMAHuhAAAwVCEAADBUIQAAMFQhAAAwRBMwKxQlkjvLIiFh+B9Z823m6QByos7IQBAMBQhAEAwFCEAQDAUIQBAMBQhAEAwpOMwd0RsFRRJ5Iid9QVlOBsCbJhFuBMCAARDEQIABEMRAgAEQxECAARDEQIABEM6DiiH6GtqT8dZALMOd0IAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgKEIAgGAoQgCAYChCAIBgIheh3/zmN/riF7+oK664QnV1dfr0pz+to0ePFvc757R161Y1NzertrZWq1ev1vHjx8t60gCAyhCpCJ09e1a33Xabqqur9cMf/lAnTpzQP/7jP+qyyy4rHrN9+3bt2LFDu3bt0pEjR5ROp7VmzRoNDQ2V+9wBALOdi+Dxxx93t99+u7m/UCi4dDrttm3bVhwbGRlxqVTKPfPMM5N6jUwm4ySxsbGxsc3yLZPJfODf+ZHuhA4cOKDly5frc5/7nBYuXKibbrpJe/fuLe7v7e1Vf3+/2tvbi2PJZFKrVq3S4cOHvXNms1kNDg6O2wAAc0OkInT69Gnt3r1bra2teuWVV7R+/Xp97Wtf03PPPSdJ6u/vlyQ1NjaO+7rGxsbivvfr7OxUKpUqbosWLbqU6wAAzEKRilChUNDNN9+sjo4O3XTTTXrwwQf1l3/5l9q9e/e442Kx2Lj/ds6VjF20adMmZTKZ4tbX1xfxEgAAs1WkItTU1KTrrrtu3Ni1116rt99+W5KUTqclqeSuZ2BgoOTu6KJkMqkFCxaM2wAAc0OkInTbbbfp5MmT48Z++ctfavHixZKklpYWpdNpdXV1Fffncjl1d3erra2tDKcLAKgok4qs/Z+f/OQnLpFIuKeeesqdOnXKfec733F1dXXu+eefLx6zbds2l0ql3EsvveR6enrc/fff75qamtzg4CDpODY2NrY5tE0mHRepCDnn3Pe//323dOlSl0wm3TXXXOP27Nkzbn+hUHBbtmxx6XTaJZNJd8cdd7ienp5Jz08RYmNjY6uMbTJFKOacc5pBBgcHlUqlQp8GAGCKMpnMBz7np3ccACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgGIoQACAYihAAIBiKEAAgmBlXhGZYP1UAwCWazN/nM64IDQ0NhT4FAEAZTObv8xm3lEOhUNBvf/tbNTQ0aGhoSIsWLVJfX19FL/s9ODjIdVaQuXCdc+EaJa7zUjnnNDQ0pObmZsXjE9/rJKb8amUWj8d15ZVXSpJisZgkacGCBRX9A3AR11lZ5sJ1zoVrlLjOSzHZdeFm3D/HAQDmDooQACCYGV2EksmktmzZomQyGfpUphXXWVnmwnXOhWuUuM4Pw4wLJgAA5o4ZfScEAKhsFCEAQDAUIQBAMBQhAEAwFCEAQDAzugh961vfUktLi+bNm6dly5bp3//930Of0pQcOnRI99xzj5qbmxWLxfS9731v3H7nnLZu3arm5mbV1tZq9erVOn78eJiTvUSdnZ265ZZb1NDQoIULF+ree+/VyZMnxx1TCde5e/du3XDDDcVPmK9cuVI//OEPi/sr4Rrfr7OzU7FYTBs3biyOVcJ1bt26VbFYbNyWTqeL+yvhGi/6zW9+oy9+8Yu64oorVFdXp09/+tM6evRocX+Qa3Uz1P79+111dbXbu3evO3HihNuwYYOrr693b731VuhTu2Q/+MEP3ObNm92LL77oJLmXX3553P5t27a5hoYG9+KLL7qenh73+c9/3jU1NbnBwcEwJ3wJPvvZz7pnn33W/fznP3fHjh1zd999t7vqqqvce++9VzymEq7zwIED7l//9V/dyZMn3cmTJ90TTzzhqqur3c9//nPnXGVc4+/7yU9+4v7gD/7A3XDDDW7Dhg3F8Uq4zi1btrglS5a4M2fOFLeBgYHi/kq4Ruec+9///V+3ePFi9+Uvf9n953/+p+vt7XX/9m//5n71q18VjwlxrTO2CP3hH/6hW79+/bixa665xv3N3/xNoDMqr/cXoUKh4NLptNu2bVtxbGRkxKVSKffMM88EOMPyGBgYcJJcd3e3c65yr9M55z7ykY+4f/qnf6q4axwaGnKtra2uq6vLrVq1qliEKuU6t2zZ4m688Ubvvkq5Ruece/zxx93tt99u7g91rTPyn+NyuZyOHj2q9vb2cePt7e06fPhwoLOaXr29verv7x93zclkUqtWrZrV15zJZCRJl19+uaTKvM58Pq/9+/fr3LlzWrlyZcVd48MPP6y7775bn/nMZ8aNV9J1njp1Ss3NzWppadEXvvAFnT59WlJlXeOBAwe0fPlyfe5zn9PChQt10003ae/evcX9oa51Rhahd955R/l8Xo2NjePGGxsb1d/fH+isptfF66qka3bO6dFHH9Xtt9+upUuXSqqs6+zp6dH8+fOVTCa1fv16vfzyy7ruuusq6hr379+vn/3sZ+rs7CzZVynXuWLFCj333HN65ZVXtHfvXvX396utrU3vvvtuxVyjJJ0+fVq7d+9Wa2urXnnlFa1fv15f+9rX9Nxzz0kK9/2ccUs5/L6LSzlc5JwrGas0lXTNjzzyiN588039x3/8R8m+SrjOT33qUzp27Jh+97vf6cUXX9S6devU3d1d3D/br7Gvr08bNmzQwYMHNW/ePPO42X6dd911V/H/X3/99Vq5cqU+8YlPaN++fbr11lslzf5rlC6s1bZ8+XJ1dHRIkm666SYdP35cu3fv1p//+Z8Xj/uwr3VG3gl99KMfVVVVVUn1HRgYKKnSleJiGqdSrvmrX/2qDhw4oFdffbW4PpRUWddZU1OjT37yk1q+fLk6Ozt144036hvf+EbFXOPRo0c1MDCgZcuWKZFIKJFIqLu7W9/85jeVSCSK1zLbr/P96uvrdf311+vUqVMV872UpKamJl133XXjxq699lq9/fbbksL92ZyRRaimpkbLli1TV1fXuPGuri61tbUFOqvp1dLSonQ6Pe6ac7mcuru7Z9U1O+f0yCOP6KWXXtKPf/xjtbS0jNtfKdfp45xTNputmGu888471dPTo2PHjhW35cuX64EHHtCxY8f08Y9/vCKu8/2y2ax+8YtfqKmpqWK+l5J02223lXxc4pe//KUWL14sKeCfzWmLPEzRxYj2t7/9bXfixAm3ceNGV19f737961+HPrVLNjQ05N544w33xhtvOElux44d7o033ijGzrdt2+ZSqZR76aWXXE9Pj7v//vtnXRT0K1/5ikulUu61114bF3k9f/588ZhKuM5Nmza5Q4cOud7eXvfmm2+6J554wsXjcXfw4EHnXGVco8/vp+Ocq4zr/Ku/+iv32muvudOnT7vXX3/d/emf/qlraGgo/l1TCdfo3IWYfSKRcE899ZQ7deqU+853vuPq6urc888/XzwmxLXO2CLknHNPP/20W7x4saupqXE333xzMeY7W7366qtOUsm2bt0659yFiOSWLVtcOp12yWTS3XHHHa6npyfsSUfkuz5J7tlnny0eUwnX+Rd/8RfFn82Pfexj7s477ywWIOcq4xp93l+EKuE6L34Wprq62jU3N7v77rvPHT9+vLi/Eq7xou9///tu6dKlLplMumuuucbt2bNn3P4Q18p6QgCAYGbkMyEAwNxAEQIABEMRAgAEQxECAARDEQIABEMRAgAEQxECAARDEQIABEMRAgAEQxECAARDEQIABPP/ANvTcnw9TFgSAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for batch in data_loader:\n", - " image = batch[\"image\"]\n", - " image = image.to(model.device)\n", - " image = functional.rotate(image, 0.0, expand=False)\n", - " image = functional.center_crop(image, [256,256])\n", - " input = functional.resize(image, [64,64], antialias=False)\n", - "\n", - " plt.imshow(input.cpu().numpy().squeeze().T)\n", - " plt.show()\n", - "\n", - " _, (q_z, p_z), _, recon = model(input)\n", - "\n", - " recon_image = torch.sigmoid(recon)\n", - "\n", - " plt.imshow(recon_image.cpu().detach().numpy().squeeze().T)\n", - " plt.show()\n", - " \n", - " break" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "spherinator", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/test-bce.py b/test-bce.py deleted file mode 100644 index 459ad1b..0000000 --- a/test-bce.py +++ /dev/null @@ -1,21 +0,0 @@ -import lightning.pytorch as pl -import yaml - -import data -import models - -if __name__ == "__main__": - - with open("experiments/illustris-svae.yaml", "r", encoding="utf-8") as stream: - config = yaml.load(stream, Loader=yaml.Loader) - - model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) - - data_module = data.IllustrisSdssDataModule( - data_directories=["/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/"], - num_workers=8, batch_size=32) - - trainer = pl.Trainer(accelerator='gpu', max_epochs=-1) - trainer.fit(model, data_module) - - print("Done.") diff --git a/test-predict.ipynb b/test-predict.ipynb deleted file mode 100644 index b8ec507..0000000 --- a/test-predict.ipynb +++ /dev/null @@ -1,101 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import torch\n", - "import torchvision.transforms.functional as functional\n", - "\n", - "import data\n", - "import models\n", - "\n", - "model = models.RotationalSphericalAutoencoder.load_from_checkpoint(\n", - " \"spherinator/ksl5gx72/checkpoints/epoch=10-step=5093.ckpt\")\n", - "\n", - "data_module = data.IllustrisSdssDataModule(\n", - " data_directories=[\"/home/doserbd/data/machine-learning/SKIRT_synthetic_images/TNG50/sdss/snapnum_095/data/\"],\n", - " num_workers=1, batch_size=1)\n", - "data_module.setup(\"fit\")\n", - "data_loader = data_module.train_dataloader()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for batch in data_loader:\n", - " image = batch[\"image\"]\n", - " image = image.to(model.device)\n", - " image = functional.rotate(image, 0.0, expand=False)\n", - " image = functional.center_crop(image, [256,256])\n", - " input = functional.resize(image, [64,64], antialias=False)\n", - "\n", - " plt.imshow(input.cpu().numpy().squeeze().T) # squeeze removes the batch dimension and transposes brings the color channel to the end\n", - " plt.show()\n", - "\n", - " recon, _ = model(input)\n", - "\n", - " plt.imshow(recon.cpu().detach().numpy().squeeze().T)\n", - " plt.show()\n", - " \n", - " break" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "spherinator", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/test-svae.py b/test-svae.py deleted file mode 100644 index b47b278..0000000 --- a/test-svae.py +++ /dev/null @@ -1,33 +0,0 @@ -import argparse - -import torch -import yaml - -import data -import models - -if __name__ == "__main__": - - parser = argparse.ArgumentParser(description="Test SVAE") - parser.add_argument("--config", "-c", default="config.yaml", - help="config file (default = 'config.yaml').") - - vars = vars(parser.parse_args()) - if "config" in vars: - with open(vars["config"], "r", encoding="utf-8") as stream: - config = yaml.load(stream, Loader=yaml.Loader) - - model = models.RotationalSphericalVariationalAutoencoder(**(config["model"]["init_args"])) - - checkpoint = torch.load("lightning_logs/version_13/checkpoints/epoch=43-step=3344.ckpt") - model.load_state_dict(checkpoint["state_dict"]) - - data_module = data.IllustrisSdssDataModule(**(config["data"]["init_args"])) - data_module.setup("predict") - dataloader = data_module.predict_dataloader() - - for batch in dataloader: - image = batch["image"] - z_mean, _ = model.encode(image) - print(z_mean) - break