diff --git a/vit_unetr_ssl/README_multiple_datasets_pretraining.md b/vit_unetr_ssl/README_multiple_datasets_pretraining.md new file mode 100644 index 0000000..3eea04f --- /dev/null +++ b/vit_unetr_ssl/README_multiple_datasets_pretraining.md @@ -0,0 +1,70 @@ +# Pre-training on multiple datasets + +### Download datasets + +Download T2w images and spinal cord segmentations for the following datasets. + +```commandline +cd ~/duke/temp/janvalosek/ssl_pretraining_multiple_datasets +``` + +`spine-generic multi-subject` (n=267) + +```commandline +git clone https://github.com/spine-generic/data-multi-subject +cd data-multi-subject +git checkout sb/156-add-preprocessed-images +git annex get $(find . -name "*space-other_T2w.nii.gz") +git annex get $(find . -name "*space-other_T2w_label-SC_seg.nii.gz") +``` + + +`canproco` (n=413) + +```commandline +git clone git@data.neuro.polymtl.ca:datasets/canproco +cd canproco +git annex dead here +git annex get $(find . -name "*ses-M0_T2w.nii.gz") +git annex get $(find . -name "*ses-M0_T2w_seg-manual.nii.gz") +``` + +`sci-colorado` (n=80) + +```commandline +git clone git@data.neuro.polymtl.ca:datasets/sci-colorado +cd sci-colorado +git annex dead here +git annex get $(find . -name "*T2w.nii.gz") +git annex get $(find . -name "*T2w_seg-manual.nii.gz") +``` + +`dcm-zurich` (n=135) + +```commandline +git clone git@data.neuro.polymtl.ca:datasets/dcm-zurich +cd dcm-zurich +git annex dead here +git annex get $(find . -name "*acq-axial_T2w.nii.gz") +git annex get $(find . -name "*acq-axial_T2w_label-SC_mask-manual.nii.gz") +``` + +`sci-paris` (n=14) + +```commandline +git clone git@data.neuro.polymtl.ca:datasets/sci-paris +cd sci-paris +git annex dead here +git annex get $(find . -name "*T2w.nii.gz") +git annex get $(find . -name "*T2w_seg.nii.gz") +``` + +### Create MSD-style JSON datalists + +```commandline +python /Users/user/code/model-seg-dcm/vit_unetr_ssl/create_msd_data.py --path-data data-multi-subject --dataset-name spine-generic --path-out . --split 0.8 0.2 --seed 42 +python /Users/user/code/model-seg-dcm/vit_unetr_ssl/create_msd_data.py --path-data canproco --dataset-name canproco --path-out . --split 0.8 0.2 --seed 42 +python /Users/user/code/model-seg-dcm/vit_unetr_ssl/create_msd_data.py --path-data sci-colorado --dataset-name sci-colorado --path-out . --split 0.8 0.2 --seed 42 +python /Users/user/code/model-seg-dcm/vit_unetr_ssl/create_msd_data.py --path-data dcm-zurich --dataset-name dcm-zurich --path-out . --split 0.8 0.2 --seed 42 +python /Users/user/code/model-seg-dcm/vit_unetr_ssl/create_msd_data.py --path-data sci-paris --dataset-name sci-paris --path-out . --split 0.8 0.2 --seed 42 +``` \ No newline at end of file diff --git a/vit_unetr_ssl/create_msd_data.py b/vit_unetr_ssl/create_msd_data.py new file mode 100644 index 0000000..56fea62 --- /dev/null +++ b/vit_unetr_ssl/create_msd_data.py @@ -0,0 +1,181 @@ +""" +Create MSD-style JSON datalist file for BIDS datasets. +The following two keys are included in the JSON file: 'image' and 'label_sc'. + +NOTE: the script is meant to be used for pre-training, meaning that the dataset is split into training and validation. +In other words, NO testing set is created. + +The script has to be run for each dataset separately, meaning that one JSON file is created for each dataset. + +Example usage: + python create_msd_data.py + --path-data /Users/user/data/spine-generic + --dataset-name spine-generic + --path-out /Users/user/data/spine-generic + + python create_msd_data.py + --path-data /Users/user/data/dcm-zurich + --dataset-name dcm-zurich + --path-out /Users/user/data/dcm-zurich +""" + +import os +import json +import argparse +from pathlib import Path +from loguru import logger +from sklearn.model_selection import train_test_split + +contrast_dict = { + 'spine-generic': 'space-other_T2w', # iso T2w (preprocessed data) + 'canproco': 'ses-M0_T2w', # iso T2w (session M0) + 'dcm-zurich': 'acq-axial_T2w', # axial T2w + 'sci-paris': 'T2w', # iso T2w + 'sci-colorado': 'T2w' # axial T2w +} + +# Spinal cord segmentation file suffixes for different datasets +sc_fname_suffix_dict = { + 'spine-generic': 'label-SC_seg', + 'canproco': 'seg-manual', + 'dcm-zurich': 'label-SC_mask-manual', + 'sci-paris': 'seg-manual', + 'sci-colorado': 'seg-manual' +} + + +def get_parser(): + parser = argparse.ArgumentParser(description='Create MSD-style JSON datalist file for BIDS datasets.') + + parser.add_argument('--path-data', required=True, type=str, + help='Path to BIDS dataset. Example: /Users/user/data/dcm-zurich') + parser.add_argument('--dataset-name', required=True, type=str, + help='Name of the dataset. Example: spine-generic or dcm-zurich.') + parser.add_argument('--path-out', type=str, required=True, + help='Path to the output directory where dataset json is saved') + parser.add_argument('--split', nargs='+', type=float, default=[0.8, 0.2], + help='Ratios of training and validation 0-1. ' + 'Example: --split 0.8 0.2') + parser.add_argument('--seed', default=42, type=int, help="Seed for reproducibility") + + return parser + + +def main(): + args = get_parser().parse_args() + + dataset = os.path.abspath(args.path_data) + dataset_name = args.dataset_name + train_ratio, val_ratio = args.split + seed = args.seed + path_out = os.path.abspath(args.path_out) + + # Check if the dataset name is valid + if dataset_name not in contrast_dict.keys(): + raise ValueError(f"Dataset name {dataset_name} is not valid. Choose from {contrast_dict.keys()}") + + contrast = contrast_dict[dataset_name] + sc_fname_suffix = sc_fname_suffix_dict[dataset_name] + datalist_fname = f"{dataset_name}_seed{seed}" + + train_images, val_images = {}, {} + + # For spine-generic, we add 'derivatives/data_preprocessed' to the path to use the preprocessed data with the same + # resolution and orientation as the spinal cord segmentations + if dataset_name == 'spine-generic': + root = Path(dataset) / 'derivatives/data_preprocessed' + else: + root = Path(dataset) + # Path to 'derivatives/labels with spinal cord segmentations + labels = Path(dataset) / 'derivatives/labels' + + # Check if the dataset path exists + if not os.path.exists(root): + raise ValueError(f"Path {root} does not exist.") + if not os.path.exists(labels): + raise ValueError(f"Path {labels} does not exist.") + + logger.info(f"Root path: {root}") + logger.info(f"Labels path: {labels}") + + # get recursively all the subjects from the root folder + subjects = [sub for sub in os.listdir(root) if sub.startswith("sub-")] + + # Get the training and validation splits + # Note: we are doing SSL pre-training, so we don't need test set + tr_subs, val_subs = train_test_split(subjects, test_size=val_ratio, random_state=args.seed) + + # recursively find the spinal cord segmentation files under 'derivatives/labels' for training and validation + # subjects + tr_seg_files = [str(path) for sub in tr_subs for path in + Path(labels).rglob(f"{sub}_{contrast}_{sc_fname_suffix}.nii.gz")] + val_seg_files = [str(path) for sub in val_subs for path in + Path(labels).rglob(f"{sub}_{contrast}_{sc_fname_suffix}.nii.gz")] + + # update the train and validation images dicts with the key as the subject and value as the path to the subject + train_images.update({sub: os.path.join(root, sub) for sub in tr_seg_files}) + val_images.update({sub: os.path.join(root, sub) for sub in val_seg_files}) + + logger.info(f"Found subjects in the training set: {len(train_images)}") + logger.info(f"Found subjects in the validation set: {len(val_images)}") + + # keys to be defined in the dataset_0.json + params = {} + params["dataset_name"] = dataset_name + params["contrast"] = contrast + params["labels"] = { + "0": "background", + "1": "sc-seg" + } + params["modality"] = { + "0": "MRI" + } + params["numTraining"] = len(train_images) + params["numValidation"] = len(val_images) + params["seed"] = args.seed + params["tensorImageSize"] = "3D" + + train_images_dict = {"training": train_images} + val_images_dict = {"validation": val_images} + + all_images_list = [train_images_dict, val_images_dict] + + for images_dict in all_images_list: + + for name, images_list in images_dict.items(): + + temp_list = [] + for label in images_list: + + temp_data_t2w = {} + # create the image path by replacing the label path + if dataset_name == 'spine-generic': + temp_data_t2w["image"] = label.replace(f'_{sc_fname_suffix}', '').replace('labels', + 'data_preprocessed') + else: + temp_data_t2w["image"] = label.replace(f'_{sc_fname_suffix}', '').replace('/derivatives/labels', '') + + # Spinal cord segmentation file + temp_data_t2w["label_sc"] = label + + if os.path.exists(temp_data_t2w["label_sc"]) and os.path.exists(temp_data_t2w["image"]): + temp_list.append(temp_data_t2w) + else: + logger.info(f"Either image/label does not exist.") + + params[name] = temp_list + logger.info(f"Number of images in {name} set: {len(temp_list)}") + + final_json = json.dumps(params, indent=4, sort_keys=False) + if not os.path.exists(path_out): + os.makedirs(path_out, exist_ok=True) + + jsonFile = open(path_out + "/" + f"{datalist_fname}.json", "w") + jsonFile.write(final_json) + jsonFile.close() + print(f"JSON file saved to {path_out}/{datalist_fname}.json") + + +if __name__ == "__main__": + main() + diff --git a/vit_unetr_ssl/finetune.py b/vit_unetr_ssl/finetune.py new file mode 100644 index 0000000..673ddb1 --- /dev/null +++ b/vit_unetr_ssl/finetune.py @@ -0,0 +1,372 @@ +""" +Finetuning of the 3D Single-Class Spinal Cord Lesion Segmentation Model Using SSL Pre-trained Weights + +This script is based on this MONAI tutorial: +https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl + +Author: Jan Valosek +""" + +import os +import argparse +import torch +import torch.nn.functional as F +import numpy as np +from tqdm import tqdm +import matplotlib.pyplot as plt + +from loguru import logger +from monai.utils import set_determinism, first +from monai.losses import DiceCELoss +from monai.inferers import sliding_window_inference + +from monai.transforms import AsDiscrete + +from monai.metrics import DiceMetric +from monai.networks.nets import UNETR + +from monai.data import ( + Dataset, + DataLoader, + CacheDataset, + decollate_batch, +) + +from load_data import load_data +from transforms import define_finetune_train_transforms, define_finetune_val_transforms + +# Added this to solve problem with too many files open allowing number of workers > 0 +# https://github.com/pytorch/pytorch/issues/11201#issuecomment-421146936 +# https://github.com/ivadomed/model-seg-dcm/issues/8 +import torch.multiprocessing + +torch.multiprocessing.set_sharing_strategy('file_system') + + +def get_parser(): + # parse command line arguments + parser = argparse.ArgumentParser(description='Run Fine-tuning.') + parser.add_argument('--dataset-split', required=True, type=str, + help='Path to the JSON file with training/validation split. ' + 'If paths are absolute, you do NOT need to use --data. ' + 'If only filenames are provided, you need to use --data to specify the root directory ' + 'of the dataset.') + parser.add_argument('--data', required=False, type=str, default="", + help='Path to the dataset root directory. If not provided, path to data specified in the JSON ' + 'file will be used.') + parser.add_argument('--logdir', required=True, type=str, + help='Path to the directory for logging.') + parser.add_argument('--pretrained-model', required=False, type=str, + help='Path to the pretrained model.') + parser.add_argument('--cuda', type=int, default=0, help='Index of the CUDA device to use.') + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + # ----------------------------------------------------- + # Define file paths & output directory path + # ----------------------------------------------------- + json_path = os.path.abspath(args.dataset_split) + data_root = os.path.abspath(args.data) + logdir_path = os.path.abspath(args.logdir) + pretrained_model_path = os.path.abspath(args.pretrained_model) if args.pretrained_model is not None else None + use_pretrained = True if pretrained_model_path is not None else False + + # ----------------------------------------------------- + # Create result logging directories, manage data paths & set determinism + # ----------------------------------------------------- + train_list, val_list = load_data(data_root, json_path, logdir_path, is_segmentation=True) + + # save output to a log file + logger.add(os.path.join(logdir_path, "log.txt"), rotation="10 MB", level="INFO") + + logger.info("Total training data are {} and validation data are {}".format(len(train_list), len(val_list))) + + # Set Determinism + set_determinism(seed=123) + + # ----------------------------------------------------- + # Define MONAI Transforms + # ----------------------------------------------------- + # keeping the same image size as for pretraining + SPATIAL_SIZE = (64, 256, 256) + ROI_SIZE = (64, 64, 64) + + # roi_size is used to crop samples around the spinal cord + train_transforms = define_finetune_train_transforms(spatial_size=SPATIAL_SIZE, roi_size=ROI_SIZE) + val_transforms = define_finetune_val_transforms(spatial_size=SPATIAL_SIZE, roi_size=ROI_SIZE) + + # ----------------------------------------------------- + # Sanity Check for the transforms + # ----------------------------------------------------- + check_ds = Dataset(data=train_list, transform=train_transforms) + check_loader = DataLoader(check_ds, batch_size=1) + check_data = first(check_loader) + logger.info(f'original image shape: {check_data["image"][0][0].shape}') + logger.info(f'original SC label shape: {check_data["label_sc"][0][0].shape}') + logger.info(f'original lesion label shape: {check_data["label_lesion"][0][0].shape}') + + # ----------------------------------------------------- + # Training Config + # ----------------------------------------------------- + + CUDA_NUM = args.cuda + device = torch.device(f"cuda:{CUDA_NUM}") + model = UNETR( + in_channels=1, + out_channels=1, + img_size=ROI_SIZE, + feature_size=16, + hidden_size=768, + mlp_dim=3072, + num_heads=12, + pos_embed="conv", + norm_name="instance", + res_block=True, + dropout_rate=0.0, + ) + + # ----------------------------------------------------- + # Load ViT backbone weights into UNETR + # ----------------------------------------------------- + if use_pretrained is True: + logger.info(f"Loading Weights from the Path {pretrained_model_path}") + vit_dict = torch.load(pretrained_model_path) + vit_weights = vit_dict["state_dict"] + + # Remove items of vit_weights if they are not in the ViT backbone (this is used in UNETR). + # For example, some variables names like conv3d_transpose.weight, conv3d_transpose.bias, + # conv3d_transpose_1.weight and conv3d_transpose_1.bias are used to match dimensions + # while pretraining with ViTAutoEnc and are not a part of ViT backbone. + model_dict = model.vit.state_dict() + + vit_weights = {k: v for k, v in vit_weights.items() if k in model_dict} + model_dict.update(vit_weights) + model.vit.load_state_dict(model_dict) + del model_dict, vit_weights, vit_dict + logger.info("Pretrained Weights Succesfully Loaded !") + + elif use_pretrained is False: + print("No weights were loaded, all weights being used are randomly initialized!") + + model.to(device) + + # Training Hyper-params + lr = 1e-4 + max_iterations = 30000 + eval_num = 100 + batch_size = 8 + loss_function = DiceCELoss(include_background=True) + torch.backends.cudnn.benchmark = True + optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-5) + + dice_metric = DiceMetric(include_background=True, reduction="mean", get_not_nans=False) + global_step = 0 + dice_val_best = 0.0 + global_step_best = 0 + epoch_loss_values = [] + metric_values = [] + + # ----------------------------------------------------- + # Create dataloaders for training + # ----------------------------------------------------- + + NUM_WORKERS = batch_size + + train_dataset = CacheDataset(data=train_list, transform=train_transforms, cache_rate=0.5, num_workers=NUM_WORKERS) + val_dataset = CacheDataset(data=val_list, transform=val_transforms, cache_rate=0.25, num_workers=NUM_WORKERS) + train_loader = DataLoader(train_dataset, + batch_size=batch_size, + shuffle=True, + num_workers=NUM_WORKERS, + pin_memory=True, + persistent_workers=False) + val_loader = DataLoader(val_dataset, + batch_size=1, + shuffle=True, + num_workers=NUM_WORKERS, + pin_memory=True, + persistent_workers=False) + + # ----------------------------------------------------- + # Training Loop with Validation + # ----------------------------------------------------- + + # Create validation_figures directory if it does not exist + if not os.path.exists(os.path.join(logdir_path, "validation_figures")): + os.mkdir(os.path.join(logdir_path, "validation_figures")) + + def validation(epoch_iterator_val): + model.eval() + dice_vals = [] + + with torch.no_grad(): + for _step, batch in enumerate(epoch_iterator_val): + val_inputs, val_labels = (batch["image"].cuda(CUDA_NUM), batch["label_lesion"].cuda(CUDA_NUM)) + val_outputs = sliding_window_inference(val_inputs, ROI_SIZE, batch_size, model) + + # Print val_outputs shape + logger.info(f'val_outputs shape: {val_outputs.shape}') + + # get probabilities from logits + val_outputs = F.relu(val_outputs) / F.relu(val_outputs).max() if bool( + F.relu(val_outputs).max()) else F.relu(val_outputs) + + # Print val_outputs shape + logger.info(f'val_outputs shape: {val_outputs.shape}') + + # 'decollate_batch' converts the batch (5D tensor: batch_size, channels, depth, height, width) to a + # list of 4D tensors (batch_size, depth, height, width) + val_labels_list = decollate_batch(val_labels) + val_outputs_list = decollate_batch(val_outputs) + + # Print val_outputs_list shape + logger.info(f'val_outputs_list len: {len(val_outputs_list)}') + logger.info(f'val_outputs_list[0] shape: {val_outputs_list[0].shape}') + + # NOTE: the lines below are just for debugging purposes + # logger.info(len(val_labels_list)) + # logger.info(val_labels_list[0].detach().cpu().numpy().shape) + # # Get a list of non-zero slices + # slice_id_list = np.unique(val_labels_list[0][0,:,:,:].detach().cpu().numpy().nonzero()[2]) + # logger.info(slice_id_list) + # # Nonzero slice + # slice_id = slice_id_list[2].item() + # logger.info(slice_id) + # logger.info(np.unique(val_labels_list[0][0,:,:,slice_id].detach().cpu().numpy())) + + # At this moment, val_labels_list and val_outputs_list are non-binary, so we need to threshold them + val_outputs_list_bin = [] + val_labels_list_bin = [] + # NOTE: the loop is used because batch_size > 1 + for i in range(len(val_outputs_list)): + val_outputs_list_bin.append((val_outputs_list[i].detach().cpu() > 0.5).float()) + val_labels_list_bin.append((val_labels_list[i].detach().cpu() > 0.5).float()) + + # Now, the label is binarized + # logger.info(np.unique(val_labels_list_bin[0][0,:,:,slice_id].numpy())) + + # Compute the dice metric on binarized outputs and labels + dice_metric(y_pred=val_outputs_list_bin, y=val_labels_list_bin) + dice = dice_metric.aggregate().item() + dice_vals.append(dice) + epoch_iterator_val.set_description("Validate (%d / %d Steps) (dice=%2.5f)" % (global_step, 10.0, dice)) + + # Check whether val_labels is not empty (i.e., GT contains a lesion) + if val_labels_list_bin[0][0, :, :, :].sum() > 0: + logger.info(f"Lesion found in the validation image. Saving the validation images.") + # if val_labels is not empty, get a list of slices with non-zero voxels + slice_idx_list = np.unique(val_labels_list_bin[0][0, :, :, :].numpy().nonzero()[2]) + logger.info(slice_idx_list) + # get ~middle slice + slice_idx = slice_idx_list[len(slice_idx_list) // 2] + logger.info(slice_idx) + # print unique values to make sure the label is binary-- values should be 0 and 1. + logger.info(f'GT slice: {slice_idx}, unique values: ' + f'{np.unique(val_labels_list_bin[0][0, :, :, slice_idx].numpy())}') + logger.info(f'Predicted slice: {slice_idx}, unique values: ' + f'{np.unique(val_outputs_list_bin[0][0, :, :, slice_idx].numpy())}') + + # Plot and save input and output validation images to see how the model is learning + plt.figure(1, figsize=(8, 8)) + plt.subplot(2, 2, 1) + logger.info(f'Input image shape: {val_inputs.detach().cpu().numpy().shape}') + plt.imshow(val_inputs[0, 0, :, :, slice_idx].detach().cpu().numpy(), cmap="gray") + plt.title("Input Image") + + plt.subplot(2, 2, 2) + logger.info(f'Ground truth shape: {val_labels_list_bin[0].numpy().shape}') + plt.imshow(val_inputs[0, 0, :, :, slice_idx].detach().cpu().numpy(), cmap="gray") + plt.imshow(val_labels_list_bin[0][0, :, :, slice_idx].numpy(), alpha=0.5, cmap="jet", + interpolation='nearest') + plt.title("Ground Truth") + + plt.subplot(2, 2, 3) + logger.info(f'Predicted shape: {val_outputs_list_bin[0].numpy().shape}') + plt.imshow(val_inputs[0, 0, :, :, slice_idx].detach().cpu().numpy(), cmap="gray") + plt.imshow(val_outputs_list_bin[0][0, :, :, slice_idx].numpy(), alpha=0.5, cmap="jet", + interpolation='nearest') + plt.title("Predicted") + # Include the global_step as master title + plt.suptitle(f"Validation Step: {global_step}") + # Use 5 leading zeros for the global_step + fname = os.path.join(logdir_path, "validation_figures", f"val_{global_step:05d}_{_step}.png") + plt.savefig(fname) + plt.close(1) + logger.info(f"Saved validation images to {fname}") + + dice_metric.reset() + + mean_dice_val = np.mean(dice_vals) + return mean_dice_val + + def train(global_step, train_loader, dice_val_best, global_step_best): + model.train() + epoch_loss = 0 + epoch_iterator = tqdm(train_loader, desc="Training (X / X Steps) (loss=X.X)", dynamic_ncols=True) + for step, batch in enumerate(epoch_iterator): + step += 1 + x, y = (batch["image"].cuda(CUDA_NUM), batch["label_lesion"].cuda(CUDA_NUM)) + logit_map = model(x) + # get probabilities from logits + output = F.relu(logit_map) / F.relu(logit_map).max() if bool(F.relu(logit_map).max()) else F.relu(logit_map) + loss = loss_function(output, y) + loss.backward() + epoch_loss += loss.item() + optimizer.step() + optimizer.zero_grad() + epoch_iterator.set_description( + "Training (%d / %d Steps) (loss=%2.5f)" % (global_step, max_iterations, loss)) + + if (global_step % eval_num == 0 and global_step != 0) or global_step == max_iterations: + epoch_iterator_val = tqdm(val_loader, desc="Validate (X / X Steps) (dice=X.X)", dynamic_ncols=True) + dice_val = validation(epoch_iterator_val) + + epoch_loss /= step + epoch_loss_values.append(epoch_loss) + metric_values.append(dice_val) + if dice_val > dice_val_best: + dice_val_best = dice_val + global_step_best = global_step + torch.save(model.state_dict(), os.path.join(logdir_path, "best_metric_model.pth")) + logger.info(f"Model Was Saved ! Current Best Avg. Dice: {dice_val_best} " + f"Current Avg. Dice: {dice_val}") + else: + logger.info(f"Model Was Not Saved ! Current Best Avg. Dice: {dice_val_best} " + f"Current Avg. Dice: {dice_val}") + + plt.figure(1, (12, 6)) + plt.subplot(1, 2, 1) + plt.title("Iteration Average Training Loss") + x = [eval_num * (i + 1) for i in range(len(epoch_loss_values))] + y = epoch_loss_values + plt.xlabel("Iteration") + plt.plot(x, y) + plt.grid() + plt.subplot(1, 2, 2) + plt.title("Val Mean Dice") + x = [eval_num * (i + 1) for i in range(len(metric_values))] + y = metric_values + plt.xlabel("Iteration") + plt.plot(x, y) + plt.grid() + plt.savefig(os.path.join(logdir_path, "finetune_quick_update.png")) + plt.clf() + plt.close(1) + + global_step += 1 + return global_step, dice_val_best, global_step_best + + while global_step < max_iterations: + global_step, dice_val_best, global_step_best = train(global_step, train_loader, dice_val_best, global_step_best) + model.load_state_dict(torch.load(os.path.join(logdir_path, "best_metric_model.pth"))) + + logger.info(f"train completed, best_metric: {dice_val_best:.4f} " f"at iteration: {global_step_best}") + + +if __name__ == "__main__": + main() diff --git a/vit_unetr_ssl/load_data.py b/vit_unetr_ssl/load_data.py new file mode 100644 index 0000000..762b8c7 --- /dev/null +++ b/vit_unetr_ssl/load_data.py @@ -0,0 +1,23 @@ +import os + +from monai.data import load_decathlon_datalist + + +def load_data(data_root, json_path, logdir_path, is_segmentation=False): + """ + Load data from the json file and return the training and validation data + """ + if os.path.exists(logdir_path) is False: + os.mkdir(logdir_path) + + train_list = load_decathlon_datalist( + base_dir=data_root, data_list_file_path=json_path, is_segmentation=is_segmentation, data_list_key="training" + ) + + val_list = load_decathlon_datalist( + base_dir=data_root, data_list_file_path=json_path, is_segmentation=is_segmentation, data_list_key="validation" + ) + + #train_data[0] + + return train_list, val_list diff --git a/vit_unetr_ssl/ssl_RandCoarseDropoutd_debug.ipynb b/vit_unetr_ssl/ssl_RandCoarseDropoutd_debug.ipynb new file mode 100644 index 0000000..44e277a --- /dev/null +++ b/vit_unetr_ssl/ssl_RandCoarseDropoutd_debug.ipynb @@ -0,0 +1,637 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ceab8707", + "metadata": {}, + "source": [ + "Copyright (c) MONAI Consortium \n", + "Licensed under the Apache License, Version 2.0 (the \"License\"); \n", + "you may not use this file except in compliance with the License. \n", + "You may obtain a copy of the License at \n", + "    http://www.apache.org/licenses/LICENSE-2.0 \n", + "Unless required by applicable law or agreed to in writing, software \n", + "distributed under the License is distributed on an \"AS IS\" BASIS, \n", + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \n", + "See the License for the specific language governing permissions and \n", + "limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "b68c35c3", + "metadata": {}, + "source": [ + "# Self-Supervised Pre-training - step-by-step RandCoarseDropoutd transform debug\n", + "\n", + "ℹ️ This notebook is based on [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl) and provides step-by-step visualisation of data augmentation necessary for the Self-Supervised Pre-training.\n", + "\n", + "First, it uses augmentation (top row) to mutate the data and second, it utilizes regularized contrastive loss [3] to learn feature representations of the unlabeled data. The multiple augmentations are applied on a randomly selected 3D foreground patch from a 3D volume (selected by on the spinal cord mask). Two augmented views of the same 3D patch are generated for the contrastive loss as it functions by drawing the two augmented views closer to each other if the views are generated from the same patch, if not then it tries to maximize the disagreement.\n", + "\n", + "The augmentations mutate the 3D patch in various ways, the primary task of the network is to reconstruct the original image. The different augmentations used are classical techniques such as in-painting [1], out-painting [1] and noise augmentation to the image by local pixel shuffling [2]. The secondary task of the network is to simultaneously reconstruct the two augmented views as similar to each other as possible via regularized contrastive loss [3] as its objective is to maximize the agreement.\n", + "\n", + "For references, visit [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl)." + ] + }, + { + "cell_type": "markdown", + "id": "707541a2", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4dc0237b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[pillow, tqdm]\"\n", + "!python -c \"import matplotlib\" || pip install -q matplotlib\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "49070e05", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cf64bf41", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import time\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch.nn import L1Loss\n", + "from monai.utils import set_determinism, first\n", + "from monai.networks.nets import ViTAutoEnc\n", + "from monai.losses import ContrastiveLoss\n", + "from monai.data import (\n", + " Dataset,\n", + " DataLoader,\n", + " CacheDataset,\n", + " load_decathlon_datalist,\n", + ")\n", + "from monai.config import print_config\n", + "\n", + "from monai.transforms import (\n", + " LoadImaged,\n", + " AsDiscreted,\n", + " Compose,\n", + " CropForegroundd,\n", + " CopyItemsd,\n", + " ResizeWithPadOrCropd,\n", + " EnsureChannelFirstd,\n", + " Orientationd,\n", + " Spacingd,\n", + " OneOf,\n", + " NormalizeIntensityd,\n", + " RandCropByPosNegLabeld,\n", + " RandCoarseDropoutd,\n", + " RandCoarseShuffled,\n", + ")\n", + "\n", + "from load_data import load_data\n" + ] + }, + { + "cell_type": "markdown", + "id": "72e2e12c", + "metadata": {}, + "source": [ + "##### Define file paths & output directory path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aafc74a7-c62d-4d7d-8b38-ded9b17b8507", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Both images and labels (binary spinal cord masks) are loaded\n", + "json_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/dataset_split_short_with_labels.json\")\n", + "data_root = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/spine-generic_with_labels\")\n", + "logdir_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/\")" + ] + }, + { + "cell_type": "markdown", + "id": "7adf9d64", + "metadata": {}, + "source": [ + "##### Create result logging directories, manage data paths & set determinism" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5619b330-3994-4351-99d9-6909a2b9ec1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total training data are 3 and validation data are 1\n" + ] + } + ], + "source": [ + "train_list, val_list = load_data(data_root, json_path, logdir_path)\n", + "print(\"Total training data are {} and validation data are {}\".format(len(train_list), len(val_list)))" + ] + }, + { + "cell_type": "markdown", + "id": "d106d4ea", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f8ebbdd8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [51, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Original image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "d60b11f3-3cde-4c80-9fea-906ac0b19a29", + "metadata": { + "tags": [] + }, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a517c3b7-0dff-4edf-a1c6-ebb7345bd77f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAABwCAYAAABRlAS4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABCuUlEQVR4nO2deXxU1dnHf7PvS5KZbJCEEIKIgGCQTRS0SFSEglaF2sqiYBWwinbh85ZNRaxWSkWW+mrBl9aq6Iu+dUdAlApqUSu7LIGEkHUms+8z5/0jn+d4ZzJZQCQxPd/PJx+Ye8+999wzc89zn+f8znNkjDEGgUAgEAg6GXlnV0AgEAgEAkAYJIFAIBB0EYRBEggEAkGXQBgkgUAgEHQJhEESCAQCQZdAGCSBQCAQdAmEQRIIBAJBl0AYJIFAIBB0CYRBEggEAkGXoEsaJJlMhqVLl7ZbbunSpZDJZOf12mPHjsXYsWPbLderVy/MmDHjvF67K3Hy5EnIZDL+9+qrr3Z2lQRnidVq5d/fvHnzOrs6ADr+bH8XNm7cCJlMhpMnT36v1zlXPvzwQ8hkMnz44Ydnfez57PNS+7DvUq/zxVkZJPqi6U+r1aJv376YN28e6urqvq86CjqROXPmYNOmTRg2bFiLfV988QUmTZqEzMxM6PV6DBgwAE8//XSr53K5XMjOzv5OBi6RSGDjxo2YNGkSCgoKYDAYMGDAADz66KMIhUItykt/r9K/xx9/PO35X375ZYwcORIGgwFWqxWjRo3C9u3bz6mu27Ztw6xZs9C3b1/o9Xr07t0bd911F2pqalqUHTt2bNp6XnfddWnP3ZG2f/bZZ7Fp06ZzqrtA0Bkoz+Wghx9+GMXFxQiFQti1axfWrVuHt99+G/v374derz/fdeySHDlyBHJ5l3QwzysjR47Ez372sxbb33//fUycOBFDhgzBokWLYDQacfz4cZw+fbrVcy1evBiBQOA71ScQCGDmzJkYMWIEfvGLXyA7Oxu7d+/GkiVLsG3bNmzfvr3FG+S1116LO+64I2nbkCFDWpx76dKlePjhh/GTn/wEM2bMQDQaxf79+1FdXX1Odf3Nb34Dp9OJW265BaWlpThx4gSeeeYZvPnmm/jqq6+Qm5ubVL5nz55YsWJF0rb8/PwW5+1o2996660AgJ///OfnVP/vg2AwCKXynLqdbsNVV12FYDAItVrd2VVJoivU65x+Gddffz2GDh0KALjrrruQlZWFlStX4o033sC0adPOawW7KhqNprOr0Gl4PB7ccccdmDBhAl599dUOGeb9+/dj3bp1WLx4MRYvXnzO11ar1fjnP/+JUaNG8W2zZ89Gr169uFEaN25c0jF9+/ZNa1Sl7NmzBw8//DCeeuopPPDAA+dcPykrV67E6NGjk9rnuuuuw5gxY/DMM8/g0UcfTSpvsVjaree5tH1XQqvVdnYVOh25XN4l26Er1Ou8/JqvueYaAEBFRQUA4A9/+ANGjRqFrKws6HQ6lJWVpQ3RhMNhPPDAA7Db7TCZTJg0aVKrb9i7du3C5ZdfDq1Wi5KSEvz5z39utT5//etfUVZWBp1Oh8zMTEydOhVVVVUtyj377LMoKSmBTqfDsGHD8PHHH3f4nlPjrxTO3LVrF+677z7Y7XZYrVbcfffdiEQicLlcuOOOO5CRkYGMjAz8+te/Rmqi9Y62WzAYxH333Qebzcbbrbq6Om18vrq6GrNmzUJOTg40Gg0uueQS/OUvf+nwfabjxRdfRF1dHZYvXw65XA6/349EItHmMb/85S8xZcoUXHnlld/p2mq1OskYEVOmTAEAHDp0KO1xwWAwbUiPWLVqFXJzc/HLX/4SjDH4fL7vVE+g+Y0z1WBcddVVyMzMbLWesViszWufS9tfKP71r3+hvLwcNpsNOp0OxcXFmDVrVlKZ1N8ojYkcO3YMM2bMgNVqhcViwcyZM1t402fzu0/HO++8gyuvvBIGgwEmkwkTJkzAgQMH2j3O6XTioYcewsCBA2E0GmE2m3H99dfj3//+d1K56dOnQ6vVtvhuy8vLkZGRgTNnzgBIP1bz8ccf45ZbbkFhYSE0Gg0KCgrwwAMPIBgMtlu/dBw9ehQ333wzcnNzodVq0bNnT0ydOhVut7vVY1obQ/r0009xww03ICMjAwaDAYMGDcKf/vSnpDKHDx/GT37yE2RmZkKr1WLo0KH4v//7v7Ou93kxSMePHwcAZGVlAQD+9Kc/YciQIXj44Yfx2GOPQalU4pZbbsFbb72VdNxdd92FVatWYfz48Xj88cehUqkwYcKEFufft28fxo8fj/r6eixduhQzZ87EkiVLsGXLlhZlly9fjjvuuAOlpaVYuXIl7r//fmzbtg1XXXUVXC4XL/f888/j7rvvRm5uLp544glcccUVmDRpUlrDdTbMnz8fR48exbJlyzBp0iQ8++yzWLRoESZOnIh4PI7HHnsMo0ePxpNPPtkivt/RdpsxYwZWr16NG264Ab///e+h0+nStltdXR1GjBiBDz74APPmzcOf/vQn9OnTB3feeSdWrVp1zvf4wQcfwGw2o7q6GhdddBF/SO+55560nf7mzZvxySef4Iknnjjna7ZHbW0tAMBms7XYt3HjRhgMBuh0OvTv3x8vvvhiizLbtm3D5Zdfjqeffpq/IOXl5eGZZ545r/X0+Xzw+Xxp6/nNN9/wzjI3NxeLFi1CNBpNKnO2bX+hqK+vx/jx43Hy5En89re/xerVq3H77bdjz549HTr+1ltvhdfrxYoVK3Drrbdi48aNWLZsWVKZjv7u07Fp0yZMmDABRqMRv//977Fo0SIcPHgQo0ePblf8cOLECbz++uu48cYbsXLlSvzqV7/Cvn37MGbMGG5kgObn1263Y/r06YjH4wCAP//5z3j//fexevXqtOFXYvPmzQgEArjnnnuwevVqlJeXY/Xq1S1CzR0hEomgvLwce/bswfz587FmzRrMmTMHJ06cSOoDO8LWrVtx1VVX4eDBg/jlL3+Jp556CldffTXefPNNXubAgQMYMWIEDh06hN/+9rd46qmnYDAYMHny5LR9dJuws2DDhg0MAPvggw9YQ0MDq6qqYi+99BLLyspiOp2OnT59mjHGWCAQSDouEomwAQMGsGuuuYZv++qrrxgAdu+99yaV/elPf8oAsCVLlvBtkydPZlqtlp06dYpvO3jwIFMoFEx6CydPnmQKhYItX7486Zz79u1jSqWSb49EIiw7O5sNHjyYhcNhXu7ZZ59lANiYMWPabYuioiI2ffr0Fm1TXl7OEokE3z5y5Egmk8nYL37xC74tFouxnj17trhOR9pt7969DAC7//77k8rOmDGjRbvdeeedLC8vjzU2NiaVnTp1KrNYLC2uJ6WiooIBYBs2bGixb9CgQUyv1zO9Xs/mz5/PXnvtNTZ//nwGgE2dOrXFPRUWFrKFCxcyxhjbsWMHA8A2b97c6rXPhXHjxjGz2cyampqSto8aNYqtWrWKvfHGG2zdunVswIABDABbu3YtL+N0OhkAlpWVxYxGI3vyySfZyy+/zK677joGgK1fv/681fORRx5hANi2bduSts+aNYstXbqUvfbaa+x//ud/2KRJkxgAduuttyaVO5u2JwCwuXPnnrd7SMeWLVsYAPb555+3WS71N7pkyRIGgM2aNSup3JQpU1hWVhb/fDa/e3oWKyoqGGOMeb1eZrVa2ezZs5OOra2tZRaLpcX2VEKhEIvH40nbKioqmEajYQ8//HDS9vfee48BYI8++ig7ceIEMxqNbPLkyUll6BnYsWMH35buWVyxYgWTyWRJ/R61V1t8+eWXHXrGUvuw1HrFYjFWXFzMioqKWjxX0j7uRz/6ERs4cCALhUJJ+0eNGsVKS0vbrEMq52SQUv+KiorYu+++m/YYp9PJGhoa2D333MOsVivf/thjjzEA7PDhw0nlP/vss6QfWCwWYzqdLu3DdsMNNyR9OStXrmQymYwdPXqUNTQ0JP1dfPHFbNy4cYwxxj755JO0HU0kEmEWi+U7GaRXXnklqdz999+f9kGdPHkyKygoaPX8rbXb8uXLGQD2zTffJJWnB5baLZFIMKvVyubMmdOiLaiuu3btavX6bRmk3r17MwBJRpYxxu6+++4WdVu8eDHLy8tjXq+XMfb9GCRqE6mRaY1wOMwGDBjArFYr7wQqKyv5b/mll17iZePxOOvfvz/r2bPneannzp07mVKpbGFkWmP27NkMANu9ezffdjZtT1wIg0Tf65IlS1gkEmm1XGsG6bPPPksqt3LlSgaAud1uxljHf/eMtTRI//u//8sAsO3bt7d4FsaPH8/69OnT4fuMxWKssbGRNTQ0sEGDBrUwNow1fxdqtZoNHjyY2Ww2VldXl7Q/nUGS4vP5WENDA9u5cycDwF5//XW+ryMG6cSJEwwAu+uuu5jf72+1XHsG6fPPP2cA2B//+MdWz+FwOJhMJmOPPPJIi7ZdtmwZA8AdlY5wTiG7NWvWYOvWrdixYwcOHjyIEydOoLy8nO9/8803MWLECGi1WmRmZsJut2PdunVJ8ctTp05BLpejpKQk6dwXXXRR0ueGhgYEg0GUlpa2qEdq2aNHj4IxhtLSUtjt9qS/Q4cOob6+nl8bQItzqlQq9O7d+xxa5FsKCwuTPlssFgBAQUFBi+1NTU1J286m3YqLi5OO7dOnT9LnhoYGuFwuPPvssy3aYubMmQDA2+Ns0el0ANBCwPLTn/4UALB7924AzXOZnnzySSxfvhxGo/GcrtUeL7/8Mn73u9/hzjvvxD333NNuebVajXnz5sHlcmHv3r0Avr0flUqFn/zkJ7ysXC7HbbfdhtOnT6OysvI71fPw4cOYMmUKBgwYgOeee65Dxzz44IMAmsN0REfb/nzgdDpRW1vL/9oafxgzZgxuvvlmLFu2DDabDT/+8Y+xYcMGhMPhDl0r9bnJyMgAAP6MdPR3n46jR48CaB7rTn0W3n///Xafg0QigT/+8Y8oLS2FRqOBzWaD3W7H119/nbZN/vCHPyAzMxNfffUVnn76aWRnZ7dbx8rKSsyYMQOZmZkwGo2w2+0YM2YMALTZ7ukoLi7GggUL8Nxzz8Fms6G8vBxr1qw56/PQUMyAAQNaLXPs2DEwxrBo0aIWbbtkyRIAZ9fPnJPKbtiwYVxll8rHH3+MSZMm4aqrrsLatWuRl5cHlUqFDRs2pI3dn08SiQRkMhneeecdKBSKFvu/r05RSrrrtradSUQN57vdaKD7Zz/7GaZPn562zKBBg876vECzFPnAgQPIyclJ2k4PHnUiixcvRo8ePTB27Fgep6exnoaGBpw8eRKFhYXnrBTbunUrV5ytX7++w8fRy4HT6QQAPhBrtVpbfE/Se0rtNDtKVVUVxo8fD4vFgrfffhsmk+mc6gl0vO3PBzfddBN27tzJP0+fPh0bN25MW5bmlu3Zswf/+Mc/8N5772HWrFl46qmnsGfPnnafvdaeG5Yi/DkX6FnYtGlTC6k9gHZl6I899hgWLVqEWbNm4ZFHHkFmZibkcjnuv//+tIKSL7/8knfC+/bta1d5HI/Hce2118LpdOI3v/kN+vXrB4PBgOrqasyYMeOcRCtPPfUUZsyYgTfeeAPvv/8+7rvvPqxYsQJ79uxBz549z/p8rUF1e+ihh5KcEikdeWkgzvuEgNdeew1arRbvvfdekjR6w4YNSeWKioqQSCRw/PjxJE/nyJEjSeXsdjt0Oh1/y5GSWrakpASMMRQXF6Nv376t1rGoqAhA85sTKQQBIBqNoqKiApdeemkH7vT8crbtVlFRkeThHTt2LKkcDczH4/EWMujvSllZGbZu3coH1gka4LXb7QCa3/qOHTuW1uu89957ATR3oFar9azr8Omnn2LKlCkYOnQoXnnllbOa23LixImkesrlcgwePBiff/45IpFI0jyM1Hs6WxwOB8aPH49wOIxt27YhLy/vnOsJdLztzwdPPfVUkoFra1CeGDFiBEaMGIHly5fjxRdfxO23346XXnoJd91113eqS0d/9+mgKEx2dvY5PQuvvvoqrr76ajz//PNJ210uVwtxit/vx8yZM9G/f3+MGjUKTzzxBKZMmYLLL7+81fPv27cP33zzDV544YUkEcPWrVvPuq5SBg4ciIEDB+J3v/sdPvnkE1xxxRVYv359i+kGrUHttn///lbbjZ5tlUp1XvqZ8z6JQaFQQCaTcZUJ0By6ef3115PKXX/99QDQYnZ5qvpLoVCgvLwcr7/+elLY5NChQ3jvvfeSyt50001QKBRYtmxZizcrxhgcDgcAYOjQobDb7Vi/fj0ikQgvs3HjxrNWoZwvOtpu9Baydu3apO2rV69ucb6bb74Zr732Gvbv39/ieg0NDedcV5pwmfqAPvfcc1AqlTz10qOPPootW7Yk/T3yyCMAgF//+tfYsmULDAbDWV//0KFDmDBhAnr16oU333yTh7FSSXePXq8Xq1atgs1mQ1lZGd9+2223IR6P44UXXuDbQqEQ/va3v6F///4d6oxT8fv9uOGGG1BdXY233347bdgZaJ5blBraYozxjkP65tnRtj8flJWVYdy4cfyvf//+rZZtampq8cwNHjwYADoctmuLjv7uWzvWbDbjsccea6FaBNp/FhQKRYt727x5c9oJ07/5zW9QWVmJF154AStXrkSvXr0wffr0NtuAvEPpNRhjLaTVHcXj8SAWiyVtGzhwIORy+Vl9F5dddhmKi4uxatWqFv0i1TU7Oxtjx47Fn//857QZSM62nznvHtKECROwcuVKXHfddfjpT3+K+vp6rFmzBn369MHXX3/Nyw0ePBjTpk3D2rVr4Xa7MWrUKGzbti3tG8+yZcvw7rvv4sorr8S9996LWCyG1atX45JLLkk6Z0lJCR599FEsXLgQJ0+exOTJk2EymVBRUYEtW7Zgzpw5eOihh6BSqfDoo4/i7rvvxjXXXIPbbrsNFRUV2LBhw3ceQzpXOtpuZWVluPnmm7Fq1So4HA6MGDECO3fuxDfffAMASVkKHn/8cezYsQPDhw/H7Nmz0b9/fzidTnzxxRf44IMPkkJBZ8OQIUMwa9Ys/OUvf0EsFsOYMWPw4YcfYvPmzVi4cCHvvEePHt3iWPKGLr/8ckyePDlpn0wm4+dqDa/Xi/LycjQ1NeFXv/pVC0l8SUkJRo4cCaB5rPP111/HxIkTUVhYiJqaGvzlL39BZWUlNm3alOQJ3X333Xjuuecwd+5cfPPNNygsLMSmTZtw6tQp/OMf/0i6xtixY7Fz5852w0m33347PvvsM8yaNQuHDh1Kmp9iNBr5/X/xxReYNm0apk2bhj59+iAYDGLLli345z//iTlz5uCyyy7jx3W07S80L7zwAtauXYspU6agpKQEXq8X//3f/w2z2YwbbrjhO5//bH73qZjNZqxbtw4///nPcdlll2Hq1Kmw2+2orKzEW2+9hSuuuKJNef+NN96Ihx9+GDNnzsSoUaOwb98+/O1vf2vRV2zfvh1r167FkiVL+He2YcMGjB07FosWLWp12kO/fv1QUlKChx56CNXV1TCbzXjttdfOOfy6fft2zJs3D7fccgv69u2LWCyGTZs28ZfUjiKXy7Fu3TpMnDgRgwcPxsyZM5GXl4fDhw/jwIED3CFYs2YNRo8ejYEDB2L27Nno3bs36urqsHv3bpw+fbrFfK026bD8gX2rXmlP2vn888+z0tJSptFoWL9+/diGDRvSqkOCwSC77777WFZWFjMYDGzixImsqqqqhWqGsWaFUllZGVOr1ax3795s/fr1rSpOXnvtNTZ69GhmMBiYwWBg/fr1Y3PnzmVHjhxJKrd27VpWXFzMNBoNGzp0KPvoo4/YmDFjvpPKLrVtqI4NDQ1J26dPn84MBsM5tZvf72dz585lmZmZXFZ65MgRBoA9/vjjSWXr6urY3LlzWUFBAVOpVCw3N5f96Ec/Ys8++2yb99eWyo6xZkXi0qVLWVFREVOpVKxPnz5tqnGI1lR2Xq+3Telyar1a+5N+J++//z679tprWW5uLlOpVMxqtbLx48e3kFwTdXV1bPr06SwzM5NpNBo2fPjwtOrRsrIylpub2+69FhUVtVrPoqIiXu7EiRPslltuYb169WJarZbp9XpWVlbG1q9fnySvJc627XEBVHZffPEFmzZtGissLGQajYZlZ2ezG2+8kf3rX/9qUZd0KrvU5yNVKcdYx3/36Y5lrPm3V15eziwWC9NqtaykpITNmDGjRR1TCYVC7MEHH2R5eXlMp9OxK664gu3evTupr/B4PKyoqIhddtllLBqNJh3/wAMPMLlcztWS6VR2Bw8eZOPGjWNGo5HZbDY2e/Zs9u9//7vFM9hRld2sWbNYSUkJ02q1LDMzk1199dXsgw8+SCrXnsqO2LVrF7v22muZyWRiBoOBDRo0iK1evTqpzPHjx9kdd9zBn7UePXqwG2+8kb366qtt1jWVszJIgq4LzT3461//el7ORx3/6tWrWUNDQ9J8re+Dt956i8lkMvb1119/r9f5rng8HqZUKtkzzzzT2VVpF4fDwRoaGi6IQeoszvfvXtC5/LASYQkAIG06kVWrVkEul+Oqq646r9eaP38+7Hb7OaUBORt27NiBqVOnYuDAgd/rdb4rH330EXr06IHZs2d3dlXapXfv3udV5NDZXMjfvaBzkDF2HnSVggvKsmXLsHfvXlx99dVQKpV455138M4772DOnDlt5vg7GyiTOzFo0KAOzacQdB127tzJB/ELCgpazNv7oXEhfveCzkUYpB8gW7duxbJly3Dw4EH4fD4UFhbi5z//Of7rv/7rPz61v6D7In733R9hkLooa9aswZNPPona2lpceumlWL16ddpF8gQCgaC7IMaQuiAvv/wyFixYgCVLluCLL77ApZdeivLy8nNO9SMQCAQ/BISH1AUZPnw4Lr/8cj43IpFIoKCgAPPnz8dvf/vbTq6dQCAQfD+IwGsXIxKJYO/evVi4cCHfJpfLMW7cuA4nzkwkEjhz5gxMJlObEwYFgh8ijDF4vV7k5+f/4FbMFbSNMEhdjMbGRsTj8RbJM3NycnD48OG0x4TD4aSUINXV1W2meREIugNVVVXnNVGooPMRBqkbsGLFiharawLNaejFG6Sgu0FJVjuaNV3ww0EYpC6GzWaDQqFAXV1d0va6urq0qfMBYOHChViwYAH/7PF4UFBQALlc3mpaf4Hgh44IR3c/hEHqYqjVapSVlWHbtm08+WYikcC2bdswb968tMdoNJqkJSsIl8sFpVLJ1yxhjEEmk7VICiqTyfh26X76TGW0Wi2vTzweRyKRgFwu58ckEglotVqoVCpYrVZEo1EeSgyFQvx6CoUCeXl5uOiii3D48GEcP36cZzmn89H1VSoVotEor5NGo0E0GoVWq0V+fj7q6+sRDAZRUFCAhoYGeDyepDqpVCr06tULPXr0QCQSwcGDB+FyuaBQKBCPxyGXy/l9ymQyqFQqxGIxbsyVSiX8fj8YY9BqtYjH42CMIRwOQ6fTwWq1IhAIIBqNIhaLJWWPl3aYdL1EIoGsrCyYTCYwxqBUKhEMBtHU1IREIgGVSoVIJMLrIP0u6BzSOTf5+fn8e9Bqtfxe5HI5amtr4fF4+HdD7ZJIJKBQKJBIJJJ+C9Rm0m2p+6XbWvstdWRbR5BeT9qWqZmsBd0HYZC6IAsWLMD06dMxdOhQDBs2DKtWreLrrJwNgUAAQHMn39YiX9IOHEDSv7SPOgStVsvT2IdCIcjlciiVSsTjcb6ERiKRgNfrRSgUgkKh4GFDuVyOSCSCxsZG+Hw+hEIheL1eBAKBpOvLZDLEYjEolUrIZDIEAgHeeVPnFI1G4fP54Pf70bt3b5SWlsLr9UKr1UKhUPB7HzJkCAYNGgS/348DBw7A7XYjHo8jGo1CpVLBYDDwMTiFQoFwOIxEIoHMzEwAzenz4/E4ZDIZjEYjgsEg7HY76uvrYbVakZWVxcs6nU6cOnUqyXgQGo0GoVAIjDH4/X4UFBRwA5aVlQWtVstXMvb5fNyIyGQyKBQKaLVahEIhKJVKhEIhJBIJxGIx9OrVCxqNBmq1GkajkddVoVDA4XAgGAwikUggGo1yI0vGidqS6plqNFJfSKSfqW6p5em+U7/PdIavtWu1x7ksWCf4YSAMUhfktttuQ0NDAxYvXoza2loMHjwY7777bguhQ3vQQ09v9dIHXtpZSDvOVOhtVKFQIBgMIhwOc4NAnVIkEuFv3aFQiBsntVrNDVI4HE5aj8XlcsHj8cBoNEKhUPDzUZ2IQCDADZFSqYTFYoHRaIRSqYTJZEJRURF0Oh3sdjtKSkogk8lQVFQEhUKB3NxcZGVlwefzoa6uDnK5HPn5+fB4PNBoNJDJZNBoNDAYDKivr0cgEIDP54NWq0VjYyMYY0keSW1tLTQaDZRKJUpLS9G3b18Eg0E0NjZCoVDAbrfD4XDA5/NBrVYjkUjw+yaDIJfLEY/HEQqFYDKZeBvRUhj19fVJXi19f2SMyIOhMk6nE8XFxdBqtUgkElAqldBqtdzAklEnA0ffNXlHqV6I1NDQi4jUGNE+qfdG0G8p1RjRv+m8pFRD1xpnY7AEP1yEQeqizJs3r9UQXUdJfYtN1yF0NJQSj8fbNFxUhojFYkmLoaXreKjD1uv1CAaDSZ0f8K1nJ5fLoVKpYDabodfrYTQaYbVakZGRgby8PHi9XlRWVsLv98Pv9yM/Px8DBgyAwWDgXlgwGIRSqYTRaITNZoPBYIDf7+eeVCgU4h6d2+3mYa9YLAbGGDQaDQ8TFhcXc0NYVVXFZchqtRoGg4GHDaWdP3mJMpmMhy9jsRhisRjUajUYYzxXoN/vRyQS4Z2+1BhoNBp+vlgsBpfLhWAwCLPZzEOUKpWKhwcpDEmGUWro0hkO8qBon/SY1oyCtExrIhqp4WsrJNja7/Fcw36CHxbCIAm+N1I7r3SdGWMMarU6qaOlTpQ6ZL1eD6vVyr0woLnTJq8tEonA4/EgEAjwVYVtNht69+4Nn8+Hb775Bl9//TUMBgOUSiXMZjN0Oh0YYzh9+jTcbjdcLhf3BtVqNUwmE5RKJZqamvh2vV6PUaNGobS0FE6nk3s5Wq0W1dXV8Hg8sNvtiMfjcDgcSeFMMnA0ZuRyuaBSqaDRaGC1WuH3+xEMBpGVlYVAIICKigru8dB9k5dDxjkejyMWi/HQaSKR4H/k2dH1pe2d7uVAaoAAJBmlVO9IegxdT3p+6b/S7z3dOGXqce39noRR6t4IgyToVKizMpvNCAQCUKlUvGM0mUzw+/08TBYIBBCJRBAOh6HRaOD1euHxeKBWq2E2mxEKhWA2m3Hq1Cns2LEDZ86cQSKRwIkTJ+D3+xGLxRCPx6HT6aBUKuF2u+F0OhGLxbhYQq/Xw2Qy8Q6dxpgSiQT8fj8OHjyIjIwMLtxQKpXweDzQ6/Xwer3IyMiAVqtFJBKB3+/nYz3knfl8Pn7PSqUSdrsdhYWFcDqdqKioAGMMdrsdgUAAdXV13BhRuI+8OKPRCIfDkeSZ0PiSSqWCQqGAXq+HUqnk4VCpYARofRyIzind3574QXp86vfbmleUOkaVui31HOnqIuheCIMk6HTo7d5qtSIej0Oj0UClUvFxEepgtVotPB4PYrEYFAoFVCoVgObJxNQh5+XlQalU4uTJk6isrOSKOFIJSpWCJ06cgNfrhV6vh0wmg16vh0ajQV5eHjdUarUaarUasVgM4XAYtbW1cDgcKC4uhs/ng8/nQywWg0qlgslk4ucwmUxwu91QKpVQKBTcqNKgP92DXC7n41c6nY6LEOx2O0KhEDweD5RKJffSyIOJxWJJKjkaYyLIMyKhQbrQbao3JA23pZaXGoN0Yb9Ub4vKtmU80nnMUk+stTEnQfdFGCRBp8IYg9ls5l6F0WiESqWCXq/nIS2guSNyuVxcAadWq3lHrdfrUVdXB7VajUAgkOS5kBybBAFZWVkIh8OorKyE1+sFYww5OTmora3lsnW/3w+j0QjGGFfz0RhTdnY27HY7Ghsbk65ltVpRUFCA06dPQ61WIz8/H3V1dQiFQlyOTeIPuVyOYDAItVoNj8cDv98Pp9MJrVYLi8UCnU4HnU4HlUqFw4cPIxgMcg+JZPBqtZp33jqdjhsUtVqNaDQKhUIBv9+PcDjMDbdUpEBtL/0e6N/UUB0ZKuk26WfpcanjgERb21L3parz0oUBBd0TYZAEnYrBYEBRURGUSiVqamq4IVAqlQiHw/xNn0J4FFJzOBxwuVx8/o1er4fb7eYdvs1m42G8RCKB48ePw+/3IxQKoaqqintijDE4HA4ezqN5SBqNhgsH6DhpmC4zMxO9evVCr169kJ+fD5/PB7lcjqNHj+Lo0aM8/EernJI4AkCSd+f1enHy5EmEw2HEYjFccsklsNvtiEQivB1Irm0wGCCXy+HxeODxeLjwQa1Wc89PLpfDarVypR9dhxSDbXXqqR4NGZfWQnutGRQqn7o/VTLenqFJFVzQ/4Xsu/siDJKgU6FwllwuR1ZWFhKJBNRqNfx+P/eUyEshoQGJEAKBAOx2O/d+jEYjV+5Rp9WjRw+uMHO5XKiqqoLb7QYALhigEBqJHoBmuTl5GaFQCBqNBhdffDEKCgowePBgFBQUICcnB06nEzqdjhuv/v3783lKBoOBK/bIU1OpVHye1YEDBxCLxeDz+XidvV4vrrnmGpw4cQIulwsGgwFGoxFerxcA+BgbTaS12WyQyWQIh8Ncak6Gh8KYNA5FqkcSi1ColIQi0m2pYzqpwoZ0c4tSDU860QRB12rLGLU2liTovgiDJOg0dDod+vbtyz0e8oICgQBcLhdMJhOftCqTyeB2u7nXZLVaYbPZYDQaUV9fD51OB7/fzwULKpUKNTU1UKlUsNls8Hq90Gg0PHktiRW0Wi2Kiopw5swZGI1GmM1mhMNhBINB6PV6OBwOmM1mZGRkoHfv3hgyZAiGDRvG6xMKhdDU1MTl0mQIR4wYgb1790Kn0yESifCQJBk/CquRJySTyfhYT319Pfx+P8xmMwYMGACHwwGDwQCHw4HGxkauQszOzobZbObhO6pDJBLhogapOk8aAiMjJDUyrXk2VI5IZ7So7qmKvnT/l8rZWyPdmJcwRt0fYZAEnYZer0efPn3g8/ng8Xggk8ng8/ngdDoRDocRiUR4Gh0pJCDIyMhANBqF0WhMmnhrMpn4vKMzZ85Aq9VCJpPBYDDAYrHA6/XydETkFVHKH7VazUN/NFlVqVSiR48eCAaDGDBgAGQyGYLBILxeL7xeL+LxOMxmM7xeL3w+HxQKBbKzs5GRkcGVchRao2wNdB9SQ0SqvqqqKgQCAej1ej63SKPRIBKJwGAw8DahlFF0f+Qd0XmBb8UPRDo1W1squNRjgORMCem2SbdLP39XlVxr86AE3QdhkASdRiwWg9PphNvths/nQyQSQSgUQiQSgUajgcfjAQA+lkKdNoXoPB4PQqEQH8incSB6Y6cxlqamJp7ySKvVciUb0Lx0x7Fjx3hGCEo9RAbLbDajpqaGS7s1Gg334MLhMD7//HPU19ejsLAQgwYN4p6aQqFAVlZWknKOJrZSFgWan0Sht+zsbJ4iCGheGysQCMDv96O2tpaLGgKBANxuNwwGA8xmMx8nkobi9Ho91Go1FyRIUxmlC9WRN5Q6vkP72yLVq5KeI50K71wRIbvujzBIgk6DMYa6ujp4PB64XC4ur1ar1TxsRt4DGSW9Xo+MjAw+9hKNRnmWh3g8Dq1Wy89Bhi0SicBisfBrSuXSdA2j0cjVeDSmRZ5PY2MjTpw4AZVKhfr6em6wamtrsXv3bkSjUezfvx8GgwGXXnop9+gyMzMRDAa5N0OJU0lQQQIEUuiRd0P1Bpo7YTJKZJB0Oh0SiQRycnJgNBp5++h0Op6aie5DpVJxA5dqFKQ57FpTzknHeVpTykm/z9RyHR0jSvc5XZ2FUereCIMk6DSos6E39kAgwI0RiQxIpUZv4dIJrYwxPnmWxlUoNEchO+r4HQ4Hl0vL5XIYjUY+x4dUaTTORJ26dD7QiRMncPLkSR5+UyqV+Pe//w2/3w+tVgulUomPPvoIpaWl0Ov1XO5NE3tTE5qqVCrk5ubyY+PxOHw+H8/TR+NRBoMBVquVG069Xg8AyMvLg91u57nwaCxKutwIpSSSyrWln6VJddN5MVKj0J6yTSp6SKe8a+27l36WXk+E5v4zEau3CTqNaDSKUCjEl1oAwJdyIM8AAM9WTW/7ZEgUCgV8Ph90Oh18Ph8SiQQsFgvUajV8Ph8Pwdntduj1em5oMjMzkZ2dzecqMdacnkgul3MDotfrediLwoUulwsulwtAs3dx9OhRrnCjNEO7d+/mk3iBb5V8NL5FRoXEBw0NDfB6vTh9+jTPbRcIBPg4Fwk9+vTpg5KSEi66yMzM5N6gTqfj9VcoFHzCLY2BUQoi6TwhmtckFTe0Nq+orZBbOk+oNQPXHukMkfT8wjPq/giDJOg0GGteY8hqtfK3ecqMQMlBAfAxEYPBwA0EzeXRaDQ81EblychZrVZkZ2fzMRyXywWfzweLxYJQKASLxQKFQoGmpibuZSUSCeh0Op7Pjs5N84GOHz8Oxhg3lrRGEiVUdTgc3EiRt0aeCNWdOla/38/HkbRaLc/+TQaGJtSaTCYuXjCZTDAajby+0kzotAwFGTutVgudTgcA3OOSKupI8UdI5x0R6eYgpYoTUiXhqRkf0hmadMYqnRAi3fkF3RdhkASdCr3RUyeo1Wq5UaJ5M5SrzmAwAGj2rKLRKO/MKQMCGTIaE6LPx48fRygUgtFo5MeTkIBUbBQ21Ov1XHFHiVsBcCNFc4dIAUeeEK2xRLnrKDs6eX+UQJYm1tLcpEAggEAgwCfO0vnIIFqtVjDGeFskEgkYjUY+R4nqTnObNBoNcnJyuACDjLg0TVCq1yFNyioN5aWjtVBcOk8m3TyltpR26YxW6twnYZS6N2IMSdBpaDQaZGZm8mzVFCKTzs0hGTfloQsEAryjNxqNPMRHnTwZA5JGx2IxmM1mKJVKZGVl8ewOGRkZXCQAfPtWTwKAUCgEg8EAmUzGx3Wampq4EpCEE1VVVTysFgqFkJmZyVV4UuUa1ZeOo23hcJjPLzp27BgsFgtycnKQm5ubdE/Hjx/nY080PhWJRPgkXLPZzL0dg8HAJ+xSnj4Sh6SOIwHfjhG1FqJrK2wmNTCp40zSVWnPJtyWev10dRF0T4RBEnQakUgEhw4dAgA+PycajXLZNIXjIpEIfD4fX6iOOl6pgi2RSCAYDEKn0/FxFbPZDIfDAY1Gw5V4NEZEKjbGGPeqyLCRmo/ChlI5Oc35CYfDyM/Px9GjR6HX6+HxeGAwGNC7d28+ZkMZymlMhxYvBAC3283DlDLZt2sk1dfXA2ge54rH43zcSy6Xo6amhq9qW1BQkLQEBiVrjcViqKmpAQAe9qPQntTgpK6NlLp0vJR040HpjETqkuup3lhHFXNSj0jwn4UI2Qk6FZoMSss9kNdCg+3kEYRCIR62UiqVfMBeq9XyUBmF6kwmE2QyGaqqqvg5VCoVV7PRvCfyGqTXampqgkql4iEskpdLs2nHYjF4vV6UlJSgZ8+ecLvdiMViKCws5IaN5kUB4F4VeXNkPIBvw1A0HqZSqdDY2MgVfxT669mzJ4xGI5eEnz59Gnv27EFNTU0LdRpdl2Tw0nx4bXksqWo8QqoOTCcPp2u35lnR/nTXS/f/dGWEqOE/A+EhCToNxhhXldGAfCQSgV6v5+E2MgxkqGiwXi6X8/k5ZCwsFgtX10lzt5HB8ng8PDSl1Wrhdrv5CrHkEdGbfTQa5ao48pzUajUaGxvhdrt5fr2ysjI+rnPxxRejoaGBG4BoNMpTFNEYEy2pQfdEBpU8GJVKBZ/Px+dbRSIRBINBGAwGNDY2ck+PJtCePHkSNpsNOTk53OuhfTKZDCaTiYfzpOG6dCu7Sg1K6lyiVFl26mq20nMA4CmLUg1KW2NT6a4r+M9CGCRBpxEMBvncI/KAZDIZFysAyWownU6HzMxMOJ1OnlyVOnMyXnQuGtSnpKckF4/H4zyjOKnvEokEDxlKlW9kaBwOB8+czRhDQ0MDwuEwzwA+btw4rs5zuVx8GQ0KD5IiDgA/N4kaGGM85MgY4+NQJSUliMViqK+vR1ZWFhdXZGdn80UJQ6EQXC4Xzpw5w9V35FVRCM5oNHIDTgY/VQUnNVAUxks1MqnekbRcagiwPal4OtoTObQlhhB0H0TITtBpyGQyZGZmwmAw8DV9aLwGAA/BUcJUr9fL5xDpdDpkZGTwLNnxeJyr4qRpg8ijisVi6NGjB+RyOdxuN2pqauD3+/mS5jTeQuej8BalJwLA12r6+OOPuTHUaDTw+XxgjHHpN123srISfr+/RYdPixFmZmbysowxXueioiIYjUbU1tZy2TatvySXy5Gbm8sl6yqVCi6XCydPnuRhOem/BoOB5+uThkJTvR5pKK+1+UipRkpaLjW/HX0n0nGk9n4Lrc1Bau2zoPshPCRBp0I54sjABINBnmWBxk9okmowGERFRQUyMjJgs9n4vB+SSpNBsFqtPBRIoT6j0QiLxYJoNMqNDKXjMZvNPM0PeV+UnogmwtIk3KNHj6KpqQkOhwO9evXiSjwSIGi1Wvh8Phw/fpxnAac/CtuRyo+MnjRFUnZ2NkpLS/lYUTweR1VVFZxOJ5xOJ2QyGex2O1QqFZd9G41GXqecnJwkY6DRaJCRkYGamhq+fDoZyNZCcUR76rrU49PNF0pV80nP2xrtiR0E3RdhkASdikql4tkHGGOw2+1wuVxcZi1dzC4SiXADRmM+er2eexOUf47Kk9qN8r9R6iBKT0TjOX6/H6WlpfD7/fB4PKiqquLCAJp/5PF4oFKp4PV6EYvFuAGIRqPo168fH/M6deoUqqurUVVVBavVCpfLhWAwyMORtOJrPB6HTqeDzWYDAH58QUEBGhoaUFNTA4vFgng8jsrKSp5CCQAaGhr4/ZAHFI/HUVdXB7vdzsfMVCoVX2qDVH8U3iQxh3TJDOm4UDpxAyGdQCvdL51P1pExodbCelLVXuo2QfdGGCRBp5KRkYG8vDwEAgF4PB5otVrk5eUlzfchKTdlLnC5XNzTIAk2eSFGo5ELDigcZjabcebMGQSDQZ57jtYpomNramqg1Wr5mA+Fy2iVWkrkSuNGNpsNarUaFRUVfLE8EiQ0NTXxzlSpVHJDCICvgySXy6HRaKDT6WC32+F2u+FwOBAMBlFTU4OsrCxoNBocO3aMLygoNc7kialUKm6sgsFgkkGmEChlBae5UbRPaoxI/i4lnVeULqed1Hi1NX7UnoeT7rj2lHqC7oUwSIJOg0JEpDijCag0zpOVlcU9EuDb8A/NP6J5QeQRSLN6kxegVCrhdDr5+BLJzN1uNwKBADckTqcTffv25eo0MlS0CJ90ki3JwenaDQ0NAMC9PLVaDYPBgLq6Ou7tSdVtlDnBbDYjKysLbrebj2cplUru5VCeO7VajWAwyD0YCtVRW/l8Pvh8PvTs2ZMr+WiNJzKgOp2OK99SPZ90IbZUFV7qXKPUMBz9K10QMFXW3dZ1W6sLbZMqBAXdF2GQBJ0GY4znlqOko8FgMMkrIbUaeUB+v597TUCzx0HjLRS+osmyNB7lcDhgNBr5gD4JKADwhQBJkUeScZJ709gQTdSl9Y0MBgNMJhPcbjfkcjlX7NFqsIwxLhWXrq9EY0mU187tdqO+vr7FUhCnT5/myjoymmSMSNZN3h9lKicZvfRfMlo0h0pqMKQvA6mhNqmwgwyU1EOiepKMXnp8uvWQ6JjU7/9sfitne4zgh4dQ2V1gli5dmqRakslk6NevH98fCoUwd+5cZGVlwWg04uabb0ZdXV0n1vj7g8Jvp06dQn19PV/0rqqqqsWcIWkHaTAYuEybOlTp3CWfzwe/3w+v18tDdJSeCABPvNqnT5+kDtTlcnHPg7JnA+DeF3XKPp8PQLMx1Ol08Hq9cLlcXG5tsVig1WpRU1PDx49I7k2Gwmw2Izs7m6dCono5HA6uziNxB6njotFoUjsB4BkgKAuE0+lEY2MjDzH6fD6eCJYm5ErFBVJxA20DvjUsqftay7aQKmtvyyPqSOguVeknDS8Kui/CQ+oELrnkEnzwwQf8M729AsADDzyAt956C5s3b4bFYsG8efNw00034Z///GdnVPV7hdRpDQ0N0Ov1/C2fBuxVKhX3joBmUQNlXaC3f4VCAbPZDAB8wN7r9fJyMpksaT0iKksZtE0mE5ddk7w7HA5zz4OMiHSVWp1Oh9raWoRCISgUCl4Pt9sNm80GpVKJ+vp6PqeJxowIk8kEm82GeDzOJ7tSNnKqC82pknbM5F253W4ujiBjo1QqEQwG0djYmDTviTEGo9HI65oa9kr1ZuiYdP+2JTJIdzx9x6nHSI1eW17TuYxDCX7YCIPUCSiVSuTm5rbY7na78fzzz+PFF1/ENddcAwDYsGEDLr74YuzZswcjRoy40FX9XqG5N7SqK4WOpPOQALSYz0JZuSkLOKneqMMmoQB5NrToHo2vuFwueL1e6PV65OXlIRwOIxAIIBKJcLGD1+tNeiOnlD9kDCkhalFREXr37g2n08kze7vdbpw8eTJpeXVpclO3243Tp09DqVTC5/Px1EO0ZEXqdQHwcTRSEspkMm64lUolz2ROnhWF+xhrzmZOE4dTQ22pXktbRiNdNvBUmXdqGK89jyqdF9VWWE6E7Lo3wiB1AkePHkV+fj60Wi1GjhyJFStWoLCwEHv37kU0GsW4ceN42X79+qGwsBC7d+/udgYJaO5g8vPzucCAxj9oBVVph0rjISQMyMzMhNVqxcGDB6HRaJCdnY2KigqujpOOtZBEmxRrp0+f5hNmtVotNxgejwfBYJAvuiddYI+MJaUYorWLaM4UZfOmHHpUTxJvULLYUCiEY8eO8SXbaTKuRqNJystHmbqlK9hSO9jtdu6ZUdohk8nEQ4CU+YK8SvIeKfyXLvGpVO4t/X6ktOXVtKXCa00kkXru1sq0Z6gE3QNhkC4ww4cPx8aNG3HRRRehpqYGy5Ytw5VXXon9+/ejtrYWarUaVqs16ZicnBzU1ta2es5wOMw7LaB5gugPBZpTFAgEwBjj4gJa4wgA92qovNVqhd1ux6BBg3Dw4EEA4Jmuycg4HA6Ew2EEg0E+F4jOrdVqeUiutraWL2MeCoWg0WgQCAR4tvCMjAwwxlBdXY1oNIpgMMiXj7Db7Tx8R519dXU1b3/KZ0f55YxGI1+ePRgM8jAaeYRSb4PS/KQaDipHikQaYyJDLRVMeL3eJCk3hQJTr9Waaq4tNV1r85RS5yelEyOcjfETIbr/LIRBusBcf/31/P+DBg3C8OHDUVRUhFdeeYUrx86WFStWYNmyZeerihcMeqsnLyYQCEAmk/G8caS0i8VifDkGrVYLlUqFvn37YvTo0Th27Bg3Kn6/H06nk6+uGolEUF9fn5Tvjs4LfJslor6+nue5o0mmlMcudU0kt9uNzMxM7nV4PB5uZJqamvicIErfQ94UzZvKysoC8O1qsSS2IE9KajAoHRJ5hhT+o/x8FouFr69kNpsRCAT4CrWkFJQKGej8FPJLzeLdmkFIN5aUToItPZe0fDoj1lqoMPX6bX0WdD+EQepkrFYr+vbti2PHjuHaa69FJBKBy+VK8pLq6urSjjkRCxcuxIIFC/hnj8eDgoKC77Pa5w2v14szZ84kSY8pXGaz2bhRAgCbzQaj0QibzQaPx4P9+/fj0KFDSau1UshPuq4SeRLhcBgDBgxAOBzmYz5WqxUWiwVnzpxJyv+m0Whw/PhxaLVa2Gw25ObmoqGhAdnZ2TAajfB6vaitrYVer4fD4eBpigwGA7xeLwDw7AzkKdXU1CAvLw85OTkAgEAggNOnTyeVAZo7XpoPRZ9TPQ+an0SeEY2h0ZLqJOigbA3kOdLYkvS8qYaCjKHUGLXmyaQzLqn/T1cu1UilMzapazYJuj9C9t3JUN6zvLw8lJWVQaVSYdu2bXz/kSNHUFlZiZEjR7Z6Do1GA7PZnPT3Q4GyC9BgPM3XSSQScDqdXCXm9/u53Fkul+PAgQN45ZVX4Pf7YTKZeJJRqYiBBtVJVDBixAgMHjwYcrkcfr8fTU1NUKvVPOlqIpHgK9RmZGQkJVclWXVNTQ0qKipQX18Pn8+H6upqnkAVaJbtpwoGAPCM5W63G5FIBCaTCRaLBT179gRjjHtZ5J2R8SEvi0QZZCS8Xi9X2EUiEW5EaDyLDDGNedFEYCqb6qm0lbGBttM4UOrYE/2/tTGedOG7dElXU8+RTmYuxpG6N8JDusA89NBDmDhxIoqKinDmzBksWbIECoUC06ZNg8ViwZ133okFCxYgMzMTZrMZ8+fPx8iRI89J0ECD3V0V8gyo4yT1FnVEcrmcL7VAy4I7nU6cOnUKGRkZKCwsTJqESuE9kkVT567VanHxxRdj5MiROHToEI4fP849qrq6OkQiES6xNplMsFqt3OOgOU8VFRVc3BAOh3keOqm6DgCXa5PnkroqKwkNSLhA0nPyqtRqddISFRSeo//TOUmmTivf0pLt0rWVqAyJQqgzl/4u6Lzpxn1Svyu6h9ZI9bTOxXikemKpnhSVkXp6gu6DjIlXjgvK1KlT8dFHH8HhcMBut2P06NFYvnw5SkpKADS/YT/44IP4+9//jnA4jPLycqxdu7bNkF0qHo8HFosFJSUlXDotEHQX4vE4jh8/Drfb/YOKBgjaRxikbogwSILujDBI3RcxhiQQCASCLoEwSAKBQCDoEghRQzdEmupFIOhuSBWBgu6FMEjdEIfDAQCoqKjo5JoIBN8fXq+Xr38l6B4Ig9QNyczMBABUVlaKBzYNNHG4qqpKDIqnoau3D83Dys/P7+yqCM4zwiB1Q2iuiMVi6ZIdSlfhhzaJ+ELTldtHvGh1T4SoQSAQCARdAmGQBAKBQNAlEAapG6LRaLBkyRKeVkaQjGifthHtI+gsRKYGgUAgEHQJhIckEAgEgi6BMEgCgUAg6BIIgyQQCASCLoEwSAKBQCDoEgiD1A1Zs2YNevXqBa1Wi+HDh+Ozzz7r7CpdED766CNMnDgR+fn5kMlkeP3115P2M8awePFi5OXlQafTYdy4cTh69GhSGafTidtvvx1msxlWqxV33nknX0L9h8yKFStw+eWXw2QyITs7G5MnT8aRI0eSyoRCIcydOxdZWVkwGo24+eabUVdXl1SmsrISEyZMgF6vR3Z2Nn71q18hFotdyFsRdGOEQepmvPzyy1iwYAGWLFmCL774ApdeeinKy8tRX1/f2VX73vH7/bj00kuxZs2atPufeOIJPP3001i/fj0+/fRTGAwGlJeXIxQK8TK33347Dhw4gK1bt+LNN9/ERx99hDlz5lyoW/je2LlzJ+bOnYs9e/Zg69atiEajGD9+PPx+Py/zwAMP4B//+Ac2b96MnTt34syZM7jpppv4/ng8jgkTJiASieCTTz7BCy+8gI0bN2Lx4sWdcUuC7ggTdCuGDRvG5s6dyz/H43GWn5/PVqxY0Ym1uvAAYFu2bOGfE4kEy83NZU8++STf5nK5mEajYX//+98ZY4wdPHiQAWCff/45L/POO+8wmUzGqqurL1jdLwT19fUMANu5cydjrLktVCoV27x5My9z6NAhBoDt3r2bMcbY22+/zeRyOautreVl1q1bx8xmMwuHwxf2BgTdEuEhdSMikQj27t2LcePG8W1yuRzjxo3D7t27O7FmnU9FRQVqa2uT2sZisWD48OG8bXbv3g2r1YqhQ4fyMuPGjYNcLsenn356wev8feJ2uwF8m4h37969iEajSe3Tr18/FBYWJrXPwIEDkZOTw8uUl5fD4/HgwIEDF7D2gu6KMEjdiMbGRsTj8aQOAwBycnJQW1vbSbXqGtD9t9U2tbW1yM7OTtqvVCqRmZnZrdovkUjg/vvvxxVXXIEBAwYAaL53tVoNq9WaVDa1fdK1H+0TCL4rItu3QPAfxty5c7F//37s2rWrs6siECQhPKRuhM1mg0KhaKGMqqurQ25ubifVqmtA999W2+Tm5rYQf8RiMTidzm7TfvPmzcObb76JHTt2oGfPnnx7bm4uIpEIXC5XUvnU9knXfrRPIPiuCIPUjVCr1SgrK8O2bdv4tkQigW3btmHkyJGdWLPOp7i4GLm5uUlt4/F48Omnn/K2GTlyJFwuF/bu3cvLbN++HYlEAsOHD7/gdT6fMMYwb948bNmyBdu3b0dxcXHS/rKyMqhUqqT2OXLkCCorK5PaZ9++fUlGe+vWrTCbzejfv/+FuRFB96azVRWC88tLL73ENBoN27hxIzt48CCbM2cOs1qtScqo7orX62Vffvkl+/LLLxkAtnLlSvbll1+yU6dOMcYYe/zxx5nVamVvvPEG+/rrr9mPf/xjVlxczILBID/Hddddx4YMGcI+/fRTtmvXLlZaWsqmTZvWWbd03rjnnnuYxWJhH374IaupqeF/gUCAl/nFL37BCgsL2fbt29m//vUvNnLkSDZy5Ei+PxaLsQEDBrDx48ezr776ir377rvMbrezhQsXdsYtCbohwiB1Q1avXs0KCwuZWq1mw4YNY3v27OnsKl0QduzYwQC0+Js+fTpjrFn6vWjRIpaTk8M0Gg370Y9+xI4cOZJ0DofDwaZNm8aMRiMzm81s5syZzOv1dsLdnF/StQsAtmHDBl4mGAyye++9l2VkZDC9Xs+mTJnCampqks5z8uRJdv311zOdTsdsNht78MEHWTQavcB3I+iuiOUnBAKBQNAlEGNIAoFAIOgSCIMkEAgEgi6BMEgCgUAg6BIIgyQQCASCLoEwSAKBQCDoEgiDJBAIBIIugTBIAoFAIOgSCIMkEAgEgi6BMEgCgUAg6BIIgyQQCASCLoEwSAKBQCDoEgiDJBAIBIIuwf8DsEkd2z7VTCYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Padded image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "044bbc61-7819-4245-a80c-a8f9a0c6532f", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 64 64)` around the label" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "83e2da2c-fa48-4ca6-aa0a-cdf5230d4e8c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 64, 64]\n", + "[0. 1.]\n", + "[0. 1.]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAAHZCAYAAAB98yxJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC5MUlEQVR4nO39e7hkZXkmjN91rr1794GDdEPohk7CBBx05EyLQCJERnEU6TGJwYwYR6NpUMQkypVPDY7SRMeRSwMixoBzKSFDMsRgPuDj18rJcJBmVJCko6MOjNiNIN27e+9dteuwfn+svlfd66nnXVW16aZrN+u5rrqqaq13vcfncD/Pe1iFKIoi5JRTTmNHxX1dgZxyysmnXDhzymlMKRfOnHIaU8qFM6ecxpRy4cwppzGlXDhzymlMKRfOnHIaU8qFM6ecxpRy4cwppzGlXDhfQPqzP/szFAqFBT17ww03oFAo4Cc/+cmerZTQT37yExQKBdxwww17LM+77roLhUIBd9111x7L88VCuXAOQd///vfx1re+Fb/0S7+EWq2Gww47DBdccAG+//3v7+uqveD03ve+F4VCAT/84Q+Daf70T/8UhUIB3/ve917Amu2HFOWUSX/3d38XVavVaNWqVdGf/umfRn/5l38Z/T//z/8THXrooVG1Wo3+5//8n0Pn1Wq1orm5uQXVo91uR3Nzc1G3213Q88PQj3/84whAdP311wfTPPDAAxGA6PLLLw+mWbt2bfSyl70siqIo6nQ60dzcXNTpdPZ0dfd7yoUzg374wx9Gk5OT0dFHHx09/fTTqXs///nPo6OPPjpasmRJ9L//9//OzGfXrl17s5p7jIYRziiKol/91V+Njj76aPfeP/3TP0UAoiuvvHIv1PDFRTmszaBPfepTmJ2dxXXXXYeXvOQlqXsHH3wwvvCFL2BmZgaf/OQnk+v0Kx9//HH87u/+Lg444AC86lWvSt1Tmpubw3vf+14cfPDBWLp0Kd7whjfgpz/9KQqFAv7sz/4sSef5nEceeSRe//rX47777sPJJ5+Mer2OX/7lX8Z//+//PVXGL37xC/zRH/0RXvayl2FqagrLli3Da1/7Wnz3u99dUL9ccMEF+Jd/+Rc88sgjffduvPFGFAoFvOUtbwEQ9jkffPBB/Pt//++xfPlyTE5O4swzz8S3vvWt5P73vvc9FAoF/MM//ENybfPmzSgUCjj++ONTeb32ta/FKaeckvx/+OGHcc455+Dggw/GxMQE1q5di9///d9fUFv3JeXCmUG33norjjzySJx++unu/TPOOANHHnkk/vEf/7Hv3pvf/GbMzs7iiiuuwDvf+c5gGRdeeCE+97nP4XWvex3+/M//HBMTEzj33HOHruMPf/hD/Mf/+B/xm7/5m/j0pz+NAw44ABdeeGHKH/7Rj36Ev//7v8frX/96/Lf/9t/wx3/8x3j00Udx5pln4qmnnhq6LNIFF1wAIBZEpU6ng//xP/4HTj/9dKxZsyb4/De+8Q2cccYZmJ6exkc/+lFcccUV2L59O1796lfjoYceAgAce+yxWLFiBe65557kuXvvvRfFYhHf/e53MT09DQDodrv4p3/6J5xxxhkAgKeffhqvec1r8JOf/AQf+tCH8LnPfQ4XXHABHnjggZHbuc9pX5vucaXt27dHAKI3vvGNmene8IY3RACi6enpKIqi6KMf/WgEIHrLW97Sl5b3SJs3b44ARJdcckkq3YUXXhgBiD760Y8m166//voIQPTjH/84uXbEEUdEAKJ77rknufb0009HtVot+sAHPpBcazQafT7fj3/846hWq0Uf+9jHUtcwBKyNoig66aSTosMPPzyV7+233x4BiL7whS8k1775zW9GAKJvfvObURRFUbfbjY466qjonHPOSfnPs7Oz0dq1a6Pf/M3fTK6de+650cknn5z8P//886Pzzz8/KpVK0W233RZFURQ98sgjEYDoa1/7WhRFUXTLLbdEAKJvf/vbA9sw7pRbzgDt3LkTALB06dLMdLxPTU5697vfPbCM22+/HQDwh3/4h6nrF1988dD1fOlLX5qy7C95yUvwa7/2a/jRj36UXKvVaigW46HudDp49tlnMTU1hV/7tV9zoekw9Na3vhX/9//+35Rlu/HGG1GtVvHmN785+Nx3vvMd/OAHP8Dv/u7v4tlnn8UzzzyDZ555BjMzMzjrrLNwzz33oNvtAgBOP/10PPLII5iZmQEA3HfffXjd616HV7ziFbj33nsBxNa0UCgkrsOKFSsAAF//+tfRarUW1LZxoVw4A0Sho5CGKCTEa9euHVjG//k//wfFYrEv7a/+6q8OXU8PPh5wwAF47rnnkv/dbhef+cxncNRRR6FWq+Hggw/GS17yEnzve9/Djh07hi5L6Xd+53dQKpUSaNtoNHDLLbfgta99LQ444IDgcz/4wQ8AAG9729vwkpe8JPX5y7/8SzSbzaROp59+OtrtNu6//35s2bIFTz/9NE4//XScccYZKeF86UtfigMPPBAAcOaZZ2L9+vW4/PLLcfDBB+ONb3wjrr/+ejSbzQW1c19SeV9XYFxp+fLlOPTQQwfO1X3ve9/DL/3SL2HZsmWp6xMTE3uzegmVSiX3eiSnz1xxxRX48Ic/jN///d/Hf/kv/wUHHnggisUiLrnkksRKjUqHHHIIfvM3fxN/93d/h6uvvhq33nordu7cmfijIWJ5n/rUp/CKV7zCTTM1NQUAOPHEE1Gv13HPPfdgzZo1OOSQQ/Bv/s2/wemnn45rrrkGzWYT9957L970pjclzxYKBfzt3/4tHnjgAdx6662444478Pu///v49Kc/jQceeCDJezFQLpwZ9PrXvx5f/OIXcd999yWwSenee+/FT37yE/zBH/zBgvI/4ogj0O128eMf/xhHHXVUcj1rgn8h9Ld/+7f4jd/4DXzpS19KXd++fTsOPvjgBed7wQUX4Pbbb8dtt92GG2+8EcuWLcN/+A//IfOZX/mVXwEALFu2DGeffXZm2mq1ipNPPhn33nsv1qxZk8D3008/Hc1mE1/96lexbdu2JBikdOqpp+LUU0/FJz7xCdx444244IILcNNNN+E//+f/vMDWvvCUw9oM+uM//mNMTEzgD/7gD/Dss8+m7v3iF7/Au9/9bkxOTuKP//iPF5T/OeecAwC45pprUtc/97nPLazCASqVSilLCgA333wzfvrTnz6vfM877zxMTk7immuuwW233Ybzzz8f9Xo985kTTjgBv/Irv4L/+l//K3bt2tV3/+c//3nq/+mnn44HH3wQ3/zmNxPhPPjgg3HMMcfgz//8z5M0pOeee66vrbTQiw3a5pYzg4466ih8+ctfxgUXXICXvexleMc73oG1a9fiJz/5Cb70pS/hmWeewV//9V8n1mBUOuGEE7B+/XpcddVVePbZZ3Hqqafi7rvvxr/+678CwILX4Vp6/etfj4997GN4+9vfjle+8pV49NFH8dWvfhW//Mu//LzynZqawnnnnZf4nYMgLQAUi0X85V/+JV772tfi3/7bf4u3v/3t+KVf+iX89Kc/xTe/+U0sW7YMt956a5L+9NNPxyc+8Qk8+eSTKSE844wz8IUvfAFHHnkkDj/88OT6l7/8ZVxzzTV405vehF/5lV/Bzp078cUvfhHLli3D6173uufV3hec9nG0eFHQ9773vegtb3lLdOihh0aVSiVatWpV9Ja3vCV69NFH+9JyuuTnP/958J7SzMxMtGHDhujAAw+MpqamovPOOy/asmVL3yqb0FTKueee21fOmWeeGZ155pnJ/0ajEX3gAx+IDj300GhiYiI67bTTovvvv78v3ShTKaR//Md/jABEhx56qLtEz06lkP7X//pf0fnnnx8ddNBBUa1Wi4444ojot37rt6JNmzal0k1PT0elUilaunRp1G63k+tf+cpXIgDR7/3e76XSP/LII9Fb3vKWaM2aNVGtVosOOeSQ6PWvf3308MMPD92mcaFCFOXn1o4bfec738Fxxx2Hr3zlK0NZo5z2T8p9zn1Mc3NzfdeuuuoqFItFN9CR04uHcp9zH9MnP/lJbN68Gb/xG7+BcrmM2267Dbfddhve9a53YfXq1fu6ejntQ8ph7T6mO++8E5dffjkef/xx7Nq1C2vWrMHv/d7v4U//9E9RLue688VMuXDmlNOY0l7zOa+++moceeSRqNfrOOWUU5LdBjnllNNwtFeE82/+5m9w6aWX4qMf/SgeeeQR/Lt/9+9wzjnn4Omnn94bxeWU035JewXWnnLKKTjppJPwF3/xFwDi9ZSrV6/GxRdfjA996EOZz3a7XTz11FNYunTpHpuEzymncaIoirBz504cdthhyW4hj/Z4xGF+fh6bN2/GZZddllwrFos4++yzcf/99/elbzabqWVVP/3pT/HSl750T1crp5zGjp588snU6iZLe1w4n3nmGXQ6HaxcuTJ1feXKlfiXf/mXvvQbN27E5Zdf3nd9yZKzUCjk0cqc9j+KojZmZjYN3Cu8z7n/sssuw6WXXpr8n56exurVq1EolFEoVPZhzXLKae/SILdtjwvnwQcfjFKphG3btqWub9u2DatWrepLX6vVUKvV9nQ1cspp0dMej9ZWq1WccMIJ2LRpU3Kt2+1i06ZNWLdu3Z4uLqec9lvaK7D20ksvxdve9jaceOKJOPnkk3HVVVdhZmYGb3/72/dGcTnltF/SXhHO3/7t38bPf/5zfOQjH8HWrVvxile8ArfffntfkCinnHIK09gt35uensby5csxNXVOHhDKab+kKGph1647sGPHjr6zp5TyLWM55TSmlAtnTjmNKeXCmVNOY0q5cOaU05hSLpw55TSmlAtnTjmNKeXCmVNOY0r7fOF7iOLp14VNweqC4oVM4/L5QqGQ+j2oLKVut5uUzW8vv0KhgCh+w3hffUN1H9SmYfbB2jxCz4zaf177+Fvb6LV3HIj1LRQKKBaLmX2pdR/Uf+m2D2cTx1Y42+2O2+CswVRGUAq9rMcTYh2cSqWCSqWCYrGIcrmcHLilz3mD2Ol00Gg00G630e12k+9isYhqtYpisYhSqYRKpYJCoYBOp4NWq4Vut4tut4tOp4MoilIC7v3OUhgeY6lQMI8oigYyoS0/1G/cOMy+KhaLSR8WCgW0Wq2knfxt6zWMkvDG+fkIO5/hmJRKJVSrVUxOTibt4AujtB84TqxTqVRK6lUsFpN2djqdZFzjMW7BvDHSpTEWzjZC/OINgAqVJTI90+m3zbdYLCbMSgHlYFGwtMxSqdS3m73dbgOIX4vX6XTQ6XQAIGHWcrmMSqWCer2OYrGI+fl5zM3NJYJMwVSrqsKqDOK1hfWx/cFnAfTVKyTM+pwt0/5X5iyVSiiVSqjVapiYmEChUECj0UjyopDyP9s7SMGG0Iy1xqNYNf3NMa5Wq1i2bFkyXlTMURQlQtnpdJKx1jTsh263i7m5OczPzxtBXeSWc0/TMFDPwhkyrX6yrBH/qzIIlcH8OZDFYjEIbUMf5udZnZB1GcXCMG+bj9eXobJs/1BxsC9DMN7Cfps21Iasa1nujo6JjrUqXlpD/db2aD72w7RxuYtcOOlzDhKqkKbt5eH7Pbyu3wBQqVRS2rNaraJUKqFcLqc0okIbWjt+dzodzM/PJ3CWZVAYaTn5xmmmt5aK1s0KvCdkHjOQoa2FsgJj+5OMpgpGlYfX91Z5se1sL9NWq9XEirA/Q0JHVOIJ+iDBHMUlYr3L5XIy5hx3FUAdS8JcdXXUZVClUiqVkr6I3Zjh3ok6tsJJCmnuUQaCjKEDa+GRwjFCWfWXOFBMpwxPoVT/gsxpfTLmoQI/Pz+faGPWzwqTFU7b1pDm9qz6IL+dedn+8tKGhFP7odPppASAjKp11jracaFCZHsIx20fDFLGofaq4uSYU6GEnmGbtXx+q3XVPu3Bfv+Fx5bGXjhH0YCD7oXyV+HTYIYyj/prtGr8zXI1mEPSYAIHnsKv/ottgwqobZdnbUZtc5YVUaajMFuByIKxKlxEFuwH6zLYvKxg0nJ6iiYLVY3SP8O6LyH0FapfqKxFH63NgquWRvGjbBlADE0mJiYSS0ZYqwOlAqnBFBKh2vz8PIDegJfLZdTr9QQysRy1uDYvtZSeldC6e5Ym1BdqTS2SUChZrVaTdqr11gCS1oF5MDii9VJLMjExgUqlkpRTqVQS4fXQEdGFNy3ltd0jT/FpWo6RWs1qtZoKANHSa18xHwt5s+IDPQjsj6mlsRZOj7xBCjn6nvbzyiFD0moSymoeahVVODlAvE9GU/har9dRrVaTCG2pVEKr1UKj0XAjyRbWajmhdgzTT7YMm55l6DtaKNAUvCylGRIiAIkPr20hw3uWyrOuVpl4z+j9QWQhLT9arrWYimasa6QKyY6fpl/0lhPw4VdoQLx7HtzQAdG5OIWz+myINE8KLX0q5qn+q1rgUBDEalptk2UErYNnpbzgidX0IX/YEwSbn1cXT/A9d0BdCaCHMry2K6y1ghCiYVwhhddWMFkvfTakdLx6WAEexEshGmvhBHxh9AbQ3rdRSSs8CmX5W/1AfUbL8eYaFbYQItVqtdTvXqSuk8BFZThqWbs4gIwSslh2cQK/vQCRjTwyvUJ49o+2Tdus+dm+93wuwt1isYh2u41Wq5UIRrVaTRZgUMFphJsCA/QUIKPbHp8MoyhUMehcLN0ODQZpf3tTY9rPtpyQgh2Fxl44lbxG2t/8hAIpqi3Vv+BKIJ2+8DrTQhyFWKp5Och6jYIf0rb6m/+t4tHfHuTyfCrtNxV2TaPzrZ6bYPO2istaXPu8nRpSwWMfUfi1jZ7ltOMQ4gdFFFZYqYxYD44V+8EKuyXvnkLaYWD1IFpUwulpZks6GHbC2/qW/G1hjDKECgfL5WBaTa8CGqp/CCbaNlhFZCGpptV2e9dVKXl5Kylq4DSIMrRlXEte3hZ2h+rGMmgh9XlbxrBuRwjaq8uhiEfrMgyPZSkjbeNCaNEIZ0gwtdOtNeC3CqEHN5kPGYdWTmGgMi2tLKEhoZrCwpCWJ6QNtc1TCArDVGi0naH8rFVUa0XSYBcjzqyrQkgrnCGFwLSqhDzLaX0+ZXq7QMGDip4Cs/3gPaPLMRXO2nqE+IzfIeTi+fN2PIehRSOcwGBn3IO4HHwNl/O3+lcKZa2l0fz424OHnnXyBtkGC7Jgk+arFt2msc9qvtba2bZZAdCpE2sBPMs5qA3Wf/Usp/a5B2NDsN0TSP3mb1umDQRZSGvJg6+hdIMWegxLYy+cWY0MCWOhUEi0YbFYRK1WS6ZHeF8FUgVGGUMhnWp9JVrgQqGQgkbKmK1Wq2+HipLWg/loYEghoRWEkOX0tLr2FaOmAPqUxSDh98bFWhZ7TRWMRRa6QIHp1Se08QNPSG2d1OoynS400cUgnp+pCMpTPiHFE2pzqI+yaGyFM27I8HNVQLrzp6amMDk5mYK1ujOA8NCDZtTeKkx2FwfnAgmPCoVCYpV79Y8Zf35+vm8bmMIdWihCafqzel2jqzYPOw1hp2v4Xy2hpveW0mUpRWuVbHt43bP+OmWh1yqVSvJMp9NJoR11KTwFlYUgtC7qX1ar1WRts85tWqXB/vP8fCUvjbbXjv0wNLbC6ZHXqBBc44DrnCOFjRSCYyT1xXS1jjK+DqodXA6G+oielbJ1UOVgy8vyvbL6yZaxJ/yiENS0lAWJtXwqkZBv60HWYcmz3p7FtOmHIVsva7WVP0ep+9gKp2oeNjA0OWytiHXqCeGyloGp1qMAc17OWk5qSbXK1hLqZmtaTj4LxHOihMPeQGofWCFWRrYMzOds/3hMoX2hgZ+QsA/y9ew6Y9aVwsapK7WcHmqxz2UJinUhtN0k5QsbmQ0pgywFZ/1mW6ZV2KpsBxkEpbEVTvUN7G9lOG9eUoVY0ylEVLK+IJ9pt9vJRlld3dLpdBImY/TXwsjZ2VnMzc0lS/oUmkVRlGy0tqcrKGNYwfSY2aa3aTnJn8UQdrpEyauXJ6yW+TQ/QrtqtZq025vUZ3rL2J7lYRs9QfIEhQiK46ZQ1ivHEtundbfBP9sGbbsd/2FobIXTwhBqPbWIniZTUiblR5nCOvPq0wHpIBDv0wKrNbZl6zpba3W1zsNAwkH9Y4VHhdPrD5uH1xeaRxbDDsqfz1n/knl5iw60Dl47RyXPIoaEahQYOwiipvPaz+Y5JycnUanUUztE7Jwk0L9lK4qiVJTNBlHUjySpINGK2rTW4We6arWKRqORsuiMzto1txZqqQ+rDOttR7OL7XXwNRpoFZdCY+sGZFkI0iBrYhnUQmtv9Y0Gn7rdbioiq352qE0eeb64tt+uBFIB9Syo8pOdm7ZCPtgSpuH2orecU1NLUK1OpoI5ngWkIFlhstMgQHrVC//zvk51NJtNl+l0sIDe9iq1BgBSwqmDqER4bH1HVQJqzXggFgXdBjNCTFwo9KYE1OKrkGh6DxJqPey3vcYyVTh1JY7WWxd9aDzAKsFQOYPqwrxVMK1wWqWhdVPesvna7yyrq+2ySj6LxlY4vQ4LaRy9Z6GaPsOOGUYDq9B4afhtJ+pZTkiTh/5r2fbZEGMynyzhtOV5/Tic9h+OBkHIUFvsGC4Uxnp84AWXbBme3+q1LZR+b9DYCie1OiOnqsmA9FREtVpNWUXe48bnUJRWGZbalPmwDhqBtVqaZ//MzMykGKDdbqfqwjronBotigoW02kAR69b381aZOvben6jB1M1H8/3HoYR1RLbQB5jBd1uF81m04WEFgUMQ1YZeXmxLhZeh6LB1iXw+s1bHcZ+3JM0xsJZShhdAyxkOA25c3d9sVhMBItCZoXWbgdS+AX0hCCK0jsneE9/FwqFJJqrcFNhsi1Hz0Hlbxt4UjjlwUVvVQuVhSozbYMnlNqXbKcXtVYr6Fk8fnNMNCqr14kyKLQWVi/EGnkIQ+vrwWpvbtqiHlsf9ZM9dyCk+BbaLmCMhdOjLB+H31Z7KZNbTWihjWVEC2N0vsrCSVvWMOTVweYT8nNC/WL7xitzmHqFhHCYdFbgbT2tRdf8vTEchkJtzoK0o0LZLHo+UDxEYyucsYbtnUau0VaFtDqQuv3LakCFObQkmpanjxMm2zlRLjjwoKIuj9M6esypixDIOBoosP6qx1Caj07vqALSZ0mq/TUP+5tp9DuUp5bL9iiU1PllDWrpafqKUFTgh1E69r6iC7WcWo5GZm37tQ5WcdvfowpkSCmEaGyFU9fVqhWzlpODagNHGpUlcdBUMAiF9ZUJ3tpWC3E9BrJzl1nR0CjqnXSgUzc2j0HCyXZ5oX7+VtLpKCWPOT0LpnlbNKJTXhRO7Reem8RrnEYhBNb6sv9DFtHyg/avWm89fsaOuyd8XptDZWg9QihMn99vhLNQ6F+1YcP6oUZqJ9AyeX6GN0DeR++RdBCZh1rCUJ5q8axPqr7oIFipAz4MjGZ/6bfXj7bNHvT0KAsyhtrP/56LMmybhq1PaMy1foqCQnmH+M6zrCGYvOiFM9a8ldRgqTZVuElSAdbrKqB2RwQtpzdH6q2nZX5cF6sWlfkyikvrzeirhdrNZjNZvlev1xFFEarVaurITLWqlsGZjzJTiPE8skxk82dfDqPx6TLo3CjzIgIhQtG+0jlOW461nMMqIh0XhbX2tAMKox58rXDX8p7yldd3FqnZANp+YznL5RJKpd5yvXK5nFoyR/Iaq51v/SErnHxefT5vVZBqVYVI9kAoCqcKixd9VTjLPBi55fYpnQoC0vs+SR50tqSwm3UKPROynBbO2v5Wy6+KUftRVz9ZxWfHLmS1rTLyyKuPCqttD5Ugx5UUcqc8OGzHZVhFkkVjK5yA78/Z64M6wMJGFSIN5KiG9yCXDooKsC5cV63rWQRtl7bDLo6wMFkVkh30hTJAKI+QBVayQmOFX311zwcE0icVhiLs3mIOWw8tg9d0LCiYIUThCZXmk9V222f8bd2GhY7R2Apnp9NFFPUsBaEHBUM3PmtHWi3Mb2UOCg7zm5+fR6PRSM7OsfN8VlsStpKxOM/KCKTO5xWLxb7X3TFvhUGETPY9oITkHrRVra5ttRRSZp7i077MYlCLYNiPFq3o4gmefA8g2WrH/rPjxzFWQbf18pbBEV7rqYrMX4XZ9qW23/IU4L9WUe+rglWLqz7sqEI6tsJpLYqdbhgEbe09q1GZJ4WeezeB/jNKrXDaoA7L0Z0zDOqokHr5WgZX66vXQ9rfttX+9pjCCqj1MwfNM9o+tQxOP94iFZ3qsi+JsvWx/qq2SRWAZ/VUyamfaZWUugl6zwv28Rnbbq9fbf/aoNewNLbCSQdd/RKr3fib5A2UajK9FoKv9tlBnUorys3TNg+FcgqHdYUP79Ea6CqfLGg3yFoOSheyljaNhY9a11DfWb+P7WFaO99MhWmXH9o+CKEAq3x1PtOSJyze9EqoH/W6fttAmg0I2b4eRGMsnG10Ov1BEIUd/K8UsiYKhVQr69auLP8wVFaz2US320028nKhAtATzCVLliRMpuuD7cCyDhbu8poKvCVVKPqtiszrH6YJrRe19bNlab+pwtT5TlpIzcO+Zk+RBZWTjo9VpraNtMyEyfZQbyCt7HRHkEZwB/UVr6vCYn4aiQbQpyB6wbtF/grAeAD8XSQhn8haGA/mMZ1CptBzyughZaCRWc/ftTBaf6tSUKis5xyF2pWlfUPa2ubjtSvUnyFoFmJgtWQUGnUDrG/Nj75xTF0Yz3KGytPobNa8pirRkJUNjb1VrJ6rZd0YreMwtGiF04NNfE4ZXu9bgdH0ej/EhOpnWIisfqsOumppz0fxoJv1sVhPazHsb88fymrTsPBqmOe0TDtlomcy8Xq73U4sp8Jaqyw9ofT8PW/aRKfTmLd1GTz3iDQINVlYrxZSEV6WAcmisRXOdruTaFLbSRp44e/4mXaflgXS8IcDx461AQdPO1u/0AoN03JRARmEc7NckKB5KcPYXSweMghZLo0Qetrf6wP9b9NZ31zJsyA6z2ohnkJI9g8j4vr2tXq9nkS8tV88AbV10XroweF6ggaf5SII1slC/5A7o+1UgdT8mEaVjc03y/J7NNLy/40bN+Kkk07C0qVLccghh+C8887Dli1bUmkajQY2bNiAgw46CFNTU1i/fj22bds2SjEA+v0wz6oojMmCL0rDaDLL0N49W08KmfU9KPAefLbtUmFVP2tQQMRaFfvxaBSrOQi6Wths+4RM3Gq1EgHlt66ksvDQa2uILC9kBYPsDIDtj6z2ar1sHsqHw4zBIBpJOO+++25s2LABDzzwAO688060Wi285jWvwczMTJLm/e9/P2699VbcfPPNuPvuu/HUU0/h/PPPH7lipVK/wNkGe/d10tmzUmQSRoM1aqh52PxDHa2astPpoNls9i26V+blcj5Oj+jblHWlkMcIg/wtTZ9FTDMqE3l1UWYP9bkiFBVYCuf8/HzyjhY7vaFt9Mj6tt6eTa2HhaFWoGzeJNsGFWoLqUP5jWo5R4K1t99+e+r/DTfcgEMOOQSbN2/GGWecgR07duBLX/oSbrzxRrz61a8GAFx//fU45phj8MADD+DUU08duqz43JtSKko5yFpygELWDUifOaS+jjfJzOdCAQHrV1DoKXAWNulRm5VKJTlxvFwuJ/XitqoQtMtiIFtfS8ocntLTdKFn7TWbh4Xh+uHZSoSEHDOmV2Vpp7nYh7YN/HDBgX5rn1ihyhJMi0I8ZEOy00FZ/dqrw3CvnX9e5yrs2LEDAHDggQcCADZv3oxWq4Wzzz47SXP00UdjzZo1uP/++908ms0mpqenUx+gv2FZTKnXsqyAp+kV/ni+3jCWkx8vAhxSFLZ8DWLY9IPgnaehQxSC+SFNP0weoTQWsnvW1K768qD6MOVrX7Id6g/z20ZUQ1bOUsi18JBciPdGpQUHhLrdLi655BKcdtppOPbYYwEAW7duRbVaxYoVK1JpV65cia1bt7r5bNy4EZdffnnf9fn5FoD+YyyBHpS0g8Dr6rPooHkMTqvJgIQyySC4pwPE/7QKupRNGcIbWIVfhNuh4FNIgPi8/ua3LdPWZRhY7CkrW75nfTzrqgrIixXYMrVeNj9dQskDvtVq6s4ejjUtrbo/WQglS7BC0y9WoY4CZ0kLFs4NGzbgsccew3333bfQLAAAl112GS699NLk//T0NFavXr37IKhynzYlKcwB0tG6YrGYLMXjPV2lonOKzIcT5XqspReOJylT6zQA8+biBNbVCooytU4FcdmbkjfQg6ycJ5ghWOpdD6EI/YQYTq/rdAVAd6X/VYtab+/bq6fOofLcopBwcmwUBusOlEHoRNPo2NkFBmzzoLyGoQUJ50UXXYSvf/3ruOeee3D44Ycn11etWoX5+Xls3749ZT23bduGVatWuXnVarXUsjdS3JH+maVqjUKWwYOfIQYG/OVbo3as1oUW0ApfiNTa7S0apm3axyG3Qvt4lD4KCfnzIRXw0BjaxQCeQA0rTAvhCa3rKDSScEZRhIsvvhi33HIL7rrrLqxduzZ1/4QTTkClUsGmTZuwfv16AMCWLVvwxBNPYN26dSNVDOif52MnM9rJQWFgRdPzlX/WwlJYKEAKa3ldrR7zGAWWENoy7yhKn0Jvfa9Bg2YtjKa3kV2tg+1DtsfLX397CMG2j98hyKx11qNRrBBYOO3lHep79df5DC21PmOFUefJbb+F2hiaZ7b96BkS8oHto0E0knBu2LABN954I772ta9h6dKliR+5fPlyTExMYPny5XjHO96BSy+9FAceeCCWLVuGiy++GOvWrRspUmsboQJKoZqfn0/gjDIBB0bfq6LfHqMxH7V4ClU1ra2bXufvbrebwGP1jS3cYSBEg1IhBvAQgfWnQ8zPOti51izL6MFo60NrmR4c1foBSI2JKiabp83bQzy2/apArQKyikJ9VX3GIgJV0LogX9NmoR2riIdBUEojCefnP/95AMCv//qvp65ff/31uPDCCwEAn/nMZ1AsFrF+/Xo0m02cc845uOaaa0aq1CAaVZtZSwP0W5BRoVYondXGg7T/KBSC7AvNK6Rs7H2PBsFim1fov2chR4XKoyCP0BiH6gSgTxnZdg7qp5CrMIhGhrWDqF6v4+qrr8bVV189StZOWV1EUfqlPqEO9QZVNTon+K0ms+1R+OGRwiMrKJbRdUAZfeVvMoe1FnzOwl6WGYoMcrG4Mp3XNq2fl4bkMVBIeGxAh2k5Xno0iPY7UQrbzLRsC+9ZoWI+vM7Ajn2FvPY98wm13UMFXLBix8i6CIoqQoJng2LD0tiurY0HMLxf0BNE+zyhRLVaxcTERMLI/Lbbt6zwhJjQwlAdOIWPjPjak+pZhrekz65k0Qijdw6uHk6lm4pt33jKJGQxPasZgszq09t2WItlYaxdRcX2UJmxr0Ow1q4K8vzIQqGQispaha6CpcqDrpMVSh17b87Ukmdph7WeYyuclqzW0w611tAX5vR/q+msX6K7Kry6ZPmd/WWHpxy8Z1kPzw/z4Jf+Dlm9rHqE0g9DHtS21s7CyRDaGLV8mz+vWYWZRewzry/1vtde7fNBdV6ISzK2whmfW1tKaU7tcNVaCoGUaEni1/o1kjTeAPJTrVYxNTWVvApwbm6uL1igDKF1sxt41braYzt67exZW+arJ86rkrD1VcUUYkqbTvvRI09R2GsWKtqPvsioWq0mx4gCaYvKfO1J7LZfsyynbqrOguMe9OR11knnRHUdrV0v653swP+aL+torfOwymeMhbN/B38WfLXXdcB0xQ8nra11ZVp9YxmA5HhKW7fQqxYUvup19WV0BZBeU1itddA8QtbHCqqFaprWa49ti17XvKwgehayUqlgYmIi6c9qtQoACcwnWcg+DCNr24ly9GwiCpuHoLxoqfaf+pnqWmi7rdLVvrdKnHXU50ehsRVOpSzYEGpwFkzhb5241vw4iDbcruV5SiJEngDZ66GAl6dIsgZZ6+kpNA/ueXDYWl4te5Bw2ukKnV/UA7iZ3i4gsHULCag+70FP2w7bT6ExtH0UWuCQRZ5rNSotCuH0BCvEyNZiKSmjc/ECISS3KxWLRUxMTCTPcL+hWj9aY69+ag21zqpdNR01PXffWGam1bH5qEa3/WGtpYcsVAhCgumttrHCZ60WrWWtVku2xNmDz/TcJiB9nhAFWhfHa90ZBCKk1SM2rVBalKGK1Y4Jx0z5Q9up5yBpOosuLCniGJXGVjg9SxRisNAA6CJym49qQu4lpH9BH6nVaiU76u1BYPajdRrGQtp681lldDKgChjbZSOFob5SZgoxSNZ1hdvqF5N5q9VqCi4S1tLn5G/WBYiVDhdpAOhbhB6C5BZa8jtrtU9ICWmfquJlH2u++jIkXUQ/LILxlMYwNLbCCaQtkQc5bMfbqJ3CHwujmJd2tNW+DGjYc09DzB6CvwoNLezUtLzvBaAstLdWwP62FBJgW48QLLbQ2FodC0s9GKj3ePAzBcG2R1GK7TsVTG8eM9QHnnvhKVdVFOryeEsfs6ZPtI9t3w1DYyyc/as0vIl8hVY6CR0SXntGKvNVwaVw1Go1HHjggeh2u9i1axemp6f75uesxrXzeywnaZUDSYH0yiVCXH0xENum9bZt0DXHSh7ThhhIn/VWxvC6VUSVSiV5lZ8uClDmVUg6OTmZcil0g7ldfGHnfPXAaM9f9QTC9r++NUCJ1tLmybI1Gm+FzBP2hSw+SOqy4CdfIAppOyugnnW00TkPMulrHZiGZZTLZdTrdQDxVq7Z2dnUW7+YXuuq2j3L1/Em14H0An9VNLrFSRmYcFvPLvKEzVpJ27+2n1QphtKzfIXjGkH1LKeOT7VaTZQLhVOVjSo4LVsVshdI8pCG7X/vJHlV3izHPqf9Y62q9tUg2DsMjbFwhpeZWX/D7rskeaFtC3eZzgZ8LJVKJSxZsiSZ/2S9PLhr65ylxb26qqJQpaP7FFlesVhMnShgNbUH4UICOUxdtU7an9Zy69ylKhWLhHRzu/dfxyQ0H6pohXnrjiPbF6E2W4UassCDYKl1e0Zd8E4aW+GMG5R2wAEkVqReryfBGwZtLNziwFhG4uIGXp+fn0+sItPxm9arXq9j2bJlAIDnnnsO27dvT0Ft/Qb6J7+1fiTrV1norYqHkUlFClEUJQLBc2Dt+zy1HGX8EKOy7vy2ddZgjApEp9NJDnqrVqvJi564CVoZlPXmmUu6wb3ZbCYb5TV/lqenubMPrMVSyKpK2AqVzVsVoY6h9pVnKNjH1iqzvsoH8Vgv8kOl40b42k4Zl3BPtSgQXoLVG/ACSiUKb29ViK0DrdHk5CSWLo2Fs9FoYGZmps/38wIbcf6DJ9c9y6QfFQoyJ6PLuoaX+asQWuvhBTY8+Osxvg2qqbXiWlTmoQJFstMk9kQ7no6oSsjCYWs5rQCpcCos9hCRl79FYFlj5bk1as0t75L3hqGxFc6YKfw1mBrCt2H0kC+o2szCTz19XOGUClvMOC0A8Tze8uXLk8XRagH0wCotX8ljErVyWle1kIVCoQ/yKaNTeFUZeUoiC4YrJLPMl+6LdkpIASQnH+pSOu0XHVseiakBIWulvb7z7llrqb914YO2SZW1DSZ5ZQ9Tj0E+5qh+6NgKZywI/uqQSqWCycnJ1BulgZ6gAWlGVGbXXQ/8MKzPeSwyjZbZbrcxNzeHYrGIJUuW4IADDkC328WOHTswMzOTMKBaLe+Ud0tWieiZt2r5KBBEDep/kgh/LangKey1vl7c720XEioRdrIuGuBRZmd+c3NzANIv1VWBtHPItt787SkKKiUeWG19VS7ioCW2byEP9VUWlPVcACvwFk6PIpSksRXOuNG+cHoM6vlRJBtYUAhF5tfAhfcKCApOPMAVTE1N7faR5pP1t7paRtsxSCh77e3Vl1aSltBGJEPQyloHz8cFkFIAtlwvGKJprT+rvr2N0FpfTKOzjNDqvkntG2uRQtZL0YMqXUVJVmBCvmhIQVh+GJXS/Lno5zn710h6H3uUpVoOfS+Gbuzltw4+fTigp201vQ5kp9Pe7V8B1WoFS5cuTd6OzeAGlwPyGW9wQ4NskYAiALbZ+kjqj9k8bJstpPX6mM+SPEti/atB1s+WT7ICbctQpcGxVBeH93TpH9PYAJb2jed727JDYzMMZUHhYWishRPwIq3pgAAjfFEUJbshoijCqc3/D6353twZB5nwUweq0qmgjjiiODExgUeWvj4RVjKUavr4/KISSqUi6vUJLF26FM3mfPIqBr4LxL40xwukkDxL6E3vaB8o8xFWWsut8FXLUVLflt9WGK1Aad4WzmmZ+lzI8utmaA3o2chyoZBeahlFUSqibc+BAtAX5Q5ZYY03eH2k8H6QcrX5s+4Wcg+isRbOLMtJ4mAwja7csINLptFgBgVcJ/Dpm3S7EbrdTqoMzadQiN/pUqvVEEVIHZVho36DYJFlcIWNlmy0kpZB50pJCiU9n21Q/2cJtZJauCzh9KyktlmVA/O19fAY3EJ5q+w8H1PTZLlFo1IIOYxKYyuc3uoShTCqTa3P48098rcNYqjV4NElsWaOUKmUUavFK4SiKA2Tm80G2u3eq+ZjIa0ngapGo9H3SkLrA1ry7nsCpemsn2UDONp2m59XpjJ+FsNaJaLCyX7mdV095CmFLJ/PKmItmwEwO1XEyDbTauTb9qeWF7KaWcrU1pnjbJGeWuxhBXZshTM+CSG9xUshnDbS7hEE0tMnGiBQ/0Mn8zWK2Gg0UC63US4vxeTkxO40XTSbjSSQxHdxLlkymZQdQ+ouGo0G5ubmEmH3DoqyDDjI/7SQ0H6yaBTt7aEVMpyXRstQ39D6wp4/axWM5mXrbPuLSta+vh6I+YGuDoCURVe3whPKLISj7dE2h+rspd9PhDM7XO1p2BBsCaW1GpffPT8qEqXQf2SK1bSlUm9xBD82Aqpl8fcgwdQ6e0wbaudCyIOAnoBqWlsfvW6DVIPg9DAMbKGqjqctf5Q+sdZvFNqTsJg0tsIZD2h/BFA7nVrLwl0bRLE78PntQc12u41Go7E7ODSZ5BMvfKil5jK1LoVCYfd8aQ3dbjc5nqNQKKRWznhTGFoPO2Viyd5THztkUT1F5+VpBTP0nL3vCa1XhkehuntlWotpAzyhvZZemwdZZqtgsp7VZ0L3bRuHobEWzm635wNZAdSFzTpI6uMB/StAlDxmaLfbmOvGiw2mpqZE8OJ1vDEE6wWVdClWuVxJ6lev15M3jVUqldRcXIhZlBlCKMDe93wfb5UR73sBJu/8Hq9cludB3FDeIfIUSRZUZxu4fNHCWbuoQt0VW+YgsnDc1tum9SytRVajuCGksRVOpUGNsX6E14Ge9vNgItA/F9pTAkUQ6trBi/8X0O1mHwkZKvP5kOZpLd8gK6fpPOHMSuvd835nXQN8JTmobJuXVcqh8gahiVHh7Cg06riPrXDGnZ1eZqcLCdhQXdnjaSbCTcI/T3gZ5GEep0ffRCEqYGV3JX7YuiCxLJOTk7sFN7aYxWIRtVo1dZQItXZaaIsp+OmRhWdZwmQZbJB212vePKunRGzdrG+n/jfz9yynB5U5BnrAt7eAIZQHp7643FIXHnjPqiK2c64a0fcWcAxDFkprP+l9+3sQja1wKrMTxmqonqTCyUGzkJZL/TQfUhbUjecI22i1SqjVqrvnM1l2hEIhnuMkbNXXImj5+vFIn7ELD0I+oK1/yOexisoLznh52Lop9LWbDbL8XA/FsJ0cC13Pm9VOFTDdYE5FoTtRQv2iK76spfZ8VQ9eq7CH/ONBsYNhaKyFk+31cDswGIIMcz+Upne9gEIhzdhxgKmMYjF9jmk8YACwcD/DoxAEH8TEnoUdJnJq4akqGf2v+ZPxPeH2yFt+aNvrtStk3UP9axWV9mWWgIXIG4ssGD5svh6NtXAC6bkojXRaa+NZK4UudsdIyMro4DPKy+gg19wqdF2yZAkmJiaS3RftdgutVjt1fIh+Qm21sCjdD+i770Eo3XFhVyiRBlkUTa+bkO0RmF4btG89haCKSgWce1KtFWUeOsfNceAuIi+WYANCNjDjQXPGFWxe9neWUhuUptd+9/E+GlvhBPpxujKQp20BH67p4OguBTKwtxSsxwy9w6QUzvH+xMQE6vV6so2Kiw48wQytQNE2DIJV2i4VRHuujndcpGVE3rcnJFDZ6VJERkdtnVgHT3FaOGxXS1E4isX0USsW4qpbUC6XE1fCKhitm/IKf9s1zsP4mB5a8+bHQ5beptsvfE4guyF2YPgd0lj2t83bMo0ylmeFPF+S1qPbTa9M2hPQVhle66Qn0HEpm04vWdimfrvXF7aOKrAaNKNQ2dVaHnnR9FCf2HZa6Gsht33Wu27b4/Wt99wwUHlYWsj4j61wxoGdNIwKNc7ujGBa3XhtIYxaTF3mVyqV8E+Vs1Eul3FIdSXW7D6jCEBysJeeLqfHcbZaLczOzqHZbKDZbCanxdsTzi2FfCi9ppab7xvlb9aDwmktiM7/8R7rZfvV9h//NxqNvnoXi8WkfLVQnoJTv5SCroszWAeFsHrYdCjAEoKioZ0wVE6hg6w9qG/z95CDZxi0z0PPZ9HYCmfcMf3bdCx8DflUdueCtQzWZ9X09DH1w7NtgPT5q8p8rVb8NjPd10nBzIoQh9qnvxW21uv1ZHuYvo6A9zVqTcWlwkamoXBYy0SG1/lezxdklNxuU7PTLAqhdVqM/al5KkznKiB73wqz9qe6LZrGTplYyxwiC1stxM0aU9ZnGHTh0dgKZ9zY9HpJpRAk0t/aKVmdzOsaACJTkIG4n5Pp9N0Z1se0kHYY8tIpfKW1pEDyt7UAyoQ65cB66ivurI85yE+ydbQrnlQAWXftA+tXqiBZYbJ+oZbN5z3lzDI9C2shv2eJs8ZjWFIXScmrbxaNrXDGJxr0ByCUoSzsUC3Lc4G63W6y8ZlpFIbRcnyrfFYc4KlPYOnERBL82L59B4rF4m7hnEehUMQBB6xI5jZpkWZnZ9FozKHRaCSHV6nV9LStZTje56dWq6FWq6FYLKJerye/a7Va6sU/ahkpAM1mM7GgzWYzEU49Wd0GXkIM6/W3WmBPEHRJJevabDYxOzubWE19vSLLVYWjpwyqUmEbWBYF2IO4qmB4jKr2m627ttOOWcjHtWXaZ1VQ4/+L/GjMYrGEQqG3qsYGV4DsaQbCPMK7VqvVN73Ce7qThG/FKpfjVT9zc7MAkDATI7RqMQgR5+dbqfNYh4nQsv5qQVh/vuKAJzTwdQdkWm2vhbK0kjz4ivUhY3t+pjJriGkthKTS02cU7uvJe6xLt9tNvciI5PnyFtayfbxmD+zyhcF/F443DqHxGgbCaj6eMub/AY8nNLbCaX0wG+Qgk+kiAFoPWkP7ligNUAA9CGR9D4VxnU4PkvXqkA7PA9h9GPJ8n585DIzRspWxlUGVsdSXJNFCkunVcirUzqKQtrdjkgUHtT0aCLLPDspDx4Dt5fEjHAsKrub/fOBoFoWUVlZaku3XYas41sIZRWmYQc09Pz+Pubk5lEolTE5OJq/sY4S0UCjg3upvoLKkgk6ng+O7X0/yVEvDPHUek2tgY6vQSi0HJEO02z3/stFooNFootFoJMdk6gFfahVDfrIe2ajWo16vp14OxEG3UxpRFG8S37lzZwLhKZxsCymk0bNQiKa3guX5pRowU4XH9gH9EXTP31U/me3SJXqqXENCaX3qLLJxCpJd7BBSBKHYiB37QUqSNPbCaTUo0DuomJZJNSjhKyOa7XY7ibZaUr/FhvyjKP3mLrWuvAcAzWasKNTXDEHaUEBALY2+PUstvg66TvhTAHmCQ6PRSPmcIaHKomxIVuiziJ6fpZYz9Lwtw4PSdEH07Ceup7XKL6s9yidZZOFwyOozX88P98ofpt8tja1wxo0MBygobNSmZAZdYsejKgqF9JGZvM+TCmy0006D0BpQgDudbnIC3NzcLGZmdqHZbKZ8O89KKnnwToNdrCPPytW2K0xloIR1VqRhV8AsdByyYJr6ebyu7zKxR1J60XcVWivUVjGrQlKoC/gvDBoF5tpyFFJr3trm0PPPp89JYyucQHrQ1FnvdDpJNLRWqyXWkjCXFnRmZgaFQgH3lV+NYqV/yZX+r8hAcP5PiXOfxWK8TWnnzp3odDp49tlnsWPHjqQ8Cq03xcDfCvGsr6vKoNVqoVwuJ8xBodQX/2hUWM/KtUJgBSjkp1loaceC12mJ2CcqqJzu4W8ytl2wQVKh1MPCgf5Dt9h+KlyOldZjkGL0yOMJXcRCUvfCKiYbsPRoWPQCjLlwAj6+t9pTFw8w9M7giIbk9XntYC9U7wWKYgYq7Y7OtpIjTXiYl76SYSFWkwOtllMtg/phLIu+mM4dZvmMwzCttQohWMa+sat47GsZh7GcIavJb/2tcNfOKS/EYmVZQOuzqsK1fTSqQhhEYy+cSl7jaTH0RD2gd5yFQtWQv6QCqVCWFoAMGA9UB/PzvUjozMwM5ubmkv8hZ39YptE62lU0ZACNwIY2KntQNMQ8IcGz5CEB9ctUwDxoqorOnutkFwkA6YXqnkXn2Ktyzmqnve75y7zOuqqys2m9srwx8PprGBp74fR8Dv3ogVzU2voN9Fb3cI5QA0gAUtFN9dlqtVoSLdUo7vT0NHbu3JkSToU1JDs4Hrzlb2UIZc7Z2dmknXYtLMvUBQyafxbE86yq5h267lli+u06BUThtCuluHiDkB3oLQzROVx1YTxinzBqD/TeVeNZa62rbT/v6bWQv66WNMty2gURAAa2ydLYC6eSx2Q6EW4dcgZ8tENCWsv6icyDfhCJ1oyHRvNtWZayBHNQu5hW60QFY/MKWUzraw6iLAG1FiPUFrX6no9qBUYFQJ/1pi28crV/dNooFJW1wjRMXwyC2HptUP/Y5wfR2Atnlr9iAwXcNaJ+jwqYwlg+wwFldFE7Vo8/0ZU/c3NzSfBFYaynLUkhK8lr3oCFggx23k3zt0Kg9bLWfRi/WPPx6scP+4jRZboULJ9la5/xvlpdK5hW0LXeVMyFQiF5P42ezhdSOFnXtJ88pa9zqqHxDsHnUX3S4Rb5BejKK69EoVDAJZdcklxrNBrYsGEDDjroIExNTWH9+vXYtm3bgvK3jOzNnemgNxoNTE9PY9euXamIK9fZ6jlCXI5HIeNLkCYmJjA1NYWpqankzCDCy+eeew6/+MUvsHPnTszNzaXmElUJeIKeBWE5eF5kUqdm+Lw9nYFrcL1ADBWV1slaNK/f7RjY3/Y59j/7hYiCvjsVnZ3q0bZ4kV8rmFpvBsT44TyvndP22mytneUlfTWHfsg3VNY2KMWPznN7ZQ1DCxbOb3/72/jCF76Al7/85anr73//+3Hrrbfi5ptvxt13342nnnoK559//kKL6Ruc0EDZjrW+TmiQlVF0yZx907Vaz6z8PSuT5fNlQSDbPu95VVgeQ3uCNUr99H+obvytyiTkf1v4N0wbhukbG7VdKFnl6AmYvT4oL5tmr8LaXbt24YILLsAXv/hFfPzjH0+u79ixA1/60pdw44034tWvfjUA4Prrr8cxxxyDBx54AKeeeurQZcRTGf48m9WEupXLbvUicfAZECK01akKpSiKEqjU6XSwa9euZEeFLry2Ppk3aB5spebPYkhlCOuL2SkTC7tCfpEncCFBDPloWlcrGLbPAaR8diUPQdhlfVlWTutsI+66eEPT2aV8tg8ViuuRp974ZS3DYz7e0slhaUHCuWHDBpx77rk4++yzU8K5efNmtFotnH322cm1o48+GmvWrMH999/vCichCWl6ehoAG9X/bkqg/4VFFE5COPVB1CISutbrE2i3Wynfx5tfm5+fx/T0NFqtFubm5jA7O5vMf2rQQQUiFInzhE7bY3dXeJaS32QMj8GU1DfT/8NYVfusTWsXTtjgDJVeqVRKtrpZpME+V9hrhdP2mb2mQsBdQ9VqNTUdpuPKfvMCUlZB6biq0tV5aM1Px1PraIV4r1nOm266CY888gi+/e1v993bunUrqtUqVqxYkbq+cuVKbN261c1v48aNuPzyy507PtQKabAQ3LUT1nE+vfyyGFN3deg0SyiaOKjTrYBlBSSGzdMKnOaf9UxIoEP1UMqCxxb+hYRK8/KUxCBI65WtYz2Kn+eVZS1pVp1CqOT5wGtgROF88skn8b73vQ933nkn6vX68yqYdNlll+HSSy9N/k9PT2P16tUA0qtmAD96p9ZKAyc28sd0XG/LdDbsrkJIx587U6jlPSvI+mVdV42tykLTUvhV43rCyvp4zG3Ta962L7162zK9vlcLrv0WRb2Dv3TBh91PGsrT1pnkwV2bnnVhIIeIxKIAW7ZtJ4lz23qd7dM2qWIgetO3EFho2+3uhXnOzZs34+mnn8bxxx+fXOt0OrjnnnvwF3/xF7jjjjswPz+P7du3p6zntm3bsGrVKjdPRhotxZ3fH+UE0AdBVTgJp7SD0i+97S3r817ToKtOmJaM501MWyG0DGO1qQq3N61hhTLL8lgB8+BgKG+PMW17tN4hQdLpKIWS/bt8otQ5TPaoEIXJtg4hQVLSPmM5uuxS+0H7y/anfutvqxg0Kqv5kveogG3/ezA3RCMJ51lnnYVHH300de3tb387jj76aHzwgx/E6tWrUalUsGnTJqxfvx4AsGXLFjzxxBNYt27dKEUB6Hf6gdHhjs3LEwabzkbjvBU4e5o8obIwOPScKoQs6LUQGgb2esKs314fZ/V/VvmD+kLHj9essgvVaxAp1NXoshU+rw0W8g9DIwnn0qVLceyxx6auLVmyBAcddFBy/R3veAcuvfRSHHjggVi2bBkuvvhirFu3bqRIrZJOdYR8A4Wm6qxrZ2ggRxcXkFSL6hEfOmlutbv97dVNSeFPaDEAYZHmrZZJ8x1GWdj6hSK+oTrzmrWW2p4QTNU0fM62CUDqHTP64bhy7Gwk2us7RT/KM/ptfWGr3FSAVbC8fiECUFjPWIWmGWbqxdIeXyH0mc98BsViEevXr0ez2cQ555yDa665ZkF5eTDMaj2FJ9qRyszaMYQdDLlz4Jl3t9u/n1PTaNme1h+k2T0/UzW69dX4YUSa7SR5CiAEVzW95p/le3n5a531Y1dwWb/UE0wyM9uusJ/jqv1vBdP7T9/Wzp9qHMIqpiyl5AmyrS9dKvsb6MU1htmxpPS8hfOuu+5K/a/X67j66qtx9dVXP9+sAQyOelnG8hqv/wdFED2tmsXsIY1qhSQ0+CHhyIJ+gygkoMNa3EHQOGS57LMWxoX6KqsOo7gSqhw9COlZ9lAbRu1zzT8kzCzrBRPOvUVxQ9PrGEOW04O1tgN0lY8KhEZOCWktlB3WjwsJsg6QDqCdZ1WtDqRfaegJxDAMzLw9Kz3M88Myks2P7dMzmOyWOu0Pa+FoLWnhsgTO1tVLB6RfF2nTa1957c9CEMzb8qHCXl7bL4QT5oiSLA3r+Tce3FFm0aga0Ivo2qV56ueEGETrYn/ba16bdOoBSAunheaWLNy2sFIpq84hdDAMI6mwW+WpwRlv10+oT7x7w9YllE4FyBtLheXKSyEF7T2v9zyK+2PRC2eYrNbyIKrtODvoeo3P6EoXy0heOUoLhYzWctiVK165WWUNgmuheoSs0ShuRciKhZRHVt1Dwjos1LereHTKzJZpLa617lltV+s+LJIZFqqPsXD2ggyAH472BJAfjZYB/Uf82x0uugvB7jbxBtDCbfs7aYUDnbSuQO8wZcIgTpzr7grPKnoQ35ZL0jp69bLp7LWQ1Q2tS9b+t/W0Y+dZT71ut5PZCLGtO4N6REcUTM1H66510eDUIKut6ew1z4r2ylzkwhkPTvzbG1yrGYH0qiA96Mouqrb+DQdFtwpx4bRdEZSun6/dvbQ2nZLWi4snVDFZiJ7lBw8qlx8Lk0OWcxDZyDIQXokU8t9s3TRv3suaSrH52UiwwmpG6nWhgKd8Af80P1tn6/Z4bQkpoUE0tsKpFNK4ei30O8sHoZDrJ5RHKIprNf4gKGqvhQZykLBkQcMsIfDSW2EKWYksobBCFVr9ZNs4CJ56/eC1MaQUdUotxCteeTruVqC8sQ3xQajdw9BYC6daSBUQIG1N7dpFC0ftsjaFskDvPShceKBL0jzGUjhjYZKui/WYWQfOLi/z2mk1s6d97XVPkEJW0l7T+T9bjnUtWD+bzs5r2jEkVPWUna2Llm3holc/Ww4XONBdoPvgwdGQElb0ZcfV66uQohhWKEljLZxAf9TPamwLdRVq6CJyplHm1RUddpOwCoOW5UFEhciavwe5SJ7VJGUFJDxL6zHFIChp74cUyTCUteZYrRbHcBCTK1ml5JH3jJapEW+PJ5iHZzW99cq23p4Vt/l5i08G0dgKZ6HQvyIkvt5z+vkd0r7WL1WLpas1dBAHDUQWeZDJs3pqaT2rM0i4dfBD316dbF2t0tI2hoTZ5qX9rGPjrQrSumcpJ8vYXrnDkh1fxhJ0t4rtD20X/VMVVO1r2yZb14VYTNLYCmfMuMWUtVSL6AkSnwPSBzKHrBw1uwaBQoESj4ls+WrxLCTmb40YenOU9qNHcqr/YwWUeahCUmLarM3gnoCqQvOExpt/zbIU2v+2D2y7bCzA5jGMZScfdLvd5H2g9vWCtq8ApAJJqjCzlJcdS+2P/QrWhjpfrUoWLPK0N0kDFgpjQxP9HnlWLWSxrIBbxrQWXOsd8mlC8M9rb6jP9H5W3ppO8/Pa6tXF9o2WM6is0FgPC7mB3tpcXZA+jLB4C1G0bl57sqxx79pw9R5b4eR8kGcdvJA6mV7/ezBXX8+nG6sHwagQ/FJ4au9ZK8g87X9FAiqcVpi1Xll5W/I0/iDG1PaowhukBLzr/K0KSd89Yy2y586E6mzH2Nbd6+dCIQ4U2aNhWEeS+psqqKEplpBC6VfQ7uN9NObCWUzBMA96ZQmQPf2b0EZfZUCol6XxPEblbzuPqvDRWmeFa1pf3eCtZWt0UU9C17dCW+sfEjqWrxretlmVgSXPhywUCu5UQ6gP9cVHusneCgG/PXTCvLX/Pbhtr1EoWS99+RUPfVMlYiGtRn2zUJ1tv0Vj5OthaGyFM+5I/R0WFk9jWosL9AYJQJ/gZNWD31lwRhl70HIuTzDsPKttlyoBZTQ+r/lmQb5R4CDThyylV8+Q9dR22IUg+kzIao7SHh172592XttTtlZRWYU6Sl08ODzsGIytcMad4a/AAPq1p71ugwl84Wq3200tfibpnjveG8SMXh4a2WP5DDRZi6XvGA0pCTKG7k7JennRqMytz/G3Ld/riyxG9GA0oax947X2oacIbEBQ+1Gf1Xp59dS+Z38yPx6BaQVJg3F2SsgqFq2z1y+DlLxHYyuccef1ay9vMFTY7Nwl8wJ6Z5F662vt+k1vUAZZK54sTwFS/9GbuuEgKQT2BjuK4jN0rfbXerAv+B0SUI8xrLBo+baMEIUUp0JB+pkhhaqkypV1jKKor57es7aN+p/50Y3gqfk2X9a3UCj0HfKmwplVH+t69fp5kcNaO8CedtX7+ozmoQyvg+vBHuZnoekgqKj1sEwUqpPes9c8K6bQKmRlQ/1g7w9DWYJp6+X91rQe9PcsiM3Ls2ah9MO2TZWjN00Tqrd91gsC2rp6SGIUGlvh9N75AaT9M/63zj6vA0g0HQVGIaYXzKB1tflquiyLqz6tt+KIZOtqF3nrN6/rQIcsplpX7772idbFm+uz/egJpQflFM0olK3VaomV4kdhP/vWCqYnnB7KsP6jrattL4M89uVK7B8NVOlYkP/0RHlPSXnQPP6/yF8BGDN9OmRtYaEniCrE1s/gR9e0UgjsOyIJZ2z+AFCtVpM09p7Cagqo9+4QbYMKt06Oe/AsC96HpiU8S6xzvSqcnoZXBWmVilcX3c1TrVYTgeRLlzQ/7R+vnd4CBO3DUJ1t/bU/gJ4roXVQmKoKLIp6i0F0rpT9mEUaeOKimJAitDS2wmk1tWUOzxplkYW3/PYghwdp7D0dRKsIshTIMG0OCYhNNyyFYLLWPwsijtLHtlz2VShC642J15devbTcUWCtVWBWaQ9qcxZq8J4PIaZBNLbCWamUUSxWkv8WinnRSs8P0HuWQoJjfTu1QJ5fZ61PFEWpCKynKS1k9RaPh8i+/8NDDgrBaeXVHbBt8ATY3rPpbFDKMjzTEZVEUZR6AbDWSQVSF4fwniILb+G6x/BZwqz11BdhMWBo+1af1fHWYKNNY61+z51a5MIZ72BPvwBVTyewkEctGNDP/KSQ36R5eEdqZgkn/9uzSy3z2np4ddTvEMMRhqvWt/mTOL2jy9eyIr2hPlKyzJvFwABSG5vtuzNtGTquatF0jlfXxIbQD/MNXee3Hvqm7zC1EXSvzTrGVBqsl9ZP22aNTBaNrXAOSyEmXgh5kMcymseQng8WYtosn87+zqJh0z/fvrHKaJi6efAe8Lf9ZfWv7eNRoPyw6b0x82Crhdu8RrIC54196F6IxlY4Y9jaf6yiairbWRbWZsE9vc/yLISyPqMuJfQGIzRw3jUNAlkr6lHIytkooicYhG0exFZU4PWbVw/LsJ7VZ10ajYY7aW/bY9vg9amF5VZBad7eb6//mK+eyqhz20zPfGxwj3np8j/LM7bPF320Nu6A9PkvugaWMMLCumF9McsAmkeWlrTw2d7zLHlIGytTqZCFtKy17La9HmOzz7z2h/IZBg6GhMsqgW43vVXLvmoCQHIIl5e37V8vemvT22shS+UptdDyS01r+5nl2ZVn7Id+33yRC2en00Wh0BPGrOBKFoVgnxUyK3x6zbunZIXGezZEnmDb+j4feGefHwUyD6qvFfrQcxrwUUbNUoIhBZflNgyiUPqQpdZ22nqEns9qw6g0tsI5NzeXitZyztDCNpK1BBq698gKlDINGc0LOoW+s4TGG3D9bT/aZquFsxSE1iXUL7a9+qytX8gFsO0G0gszdHzsOyxtvUKwWNuvZSsfeHW3bc4iry/0ZVGhCLpFL8zDC8x5Ajus0I6tcM7PN1EodPsEBei3JF4H6GS+UhZk5HcIKlqh4rdnNewAeYzoCak+67XTUwIec4+KAKwFzyKvH/TsXdtv3qn1FqoqvCepcvQ+IYThCUBWWhUq/rbz2JqPdQNs26yLslALOrbCGYfQfehDGgQxLewKDZg+kyU0WqbNO1Qnm05XJ+mkvFUKofbZ+uq1QZDM1nFUeOyRVQi65YqWcxRk4VmzUepg8/XSev2n9bB96SlVr01een/+c5EvfG+3OygUWsH7nva2mpMaWTfIhhhYNaYHzzR/GzX0SKcMyLSFQiF1NKM9sNoiA68cz6pqmz2r4lkUa6U88qCsXldGLZVKyTI9qzR0btUKh44VkH5nqmehvHG3aZneQxhWIdv+4VayYrGYGitdS+0hstAyQ8t3+4Vw6vsNSZ6GtFotBG10QbXNw+btrVENwWfPL1FY5w0sr+lZqB7k8yCg/lfyUIFCRisEoZPsQ/mHSJlXNyuQOI1jx8wKsLdgIytmEILyw9Q/5DZYn16X9KmS9YTTKiW9brc87neLELIgi3aop+G94EeW4IUEXMuzgzZI2FUb2zWmWUJio5shGhb2Z6X30gwiVUKe70hfVINCWflapejVw+uvYRXKsG22/EXFY3dLkUJTeopOqCwX/X5OwA+aAP0CFNKeIQ1oyTIqrbYNBll/0ZZpNTLL5TweN2Pr0rssX4yRSa++tp9s2zyU4Fn3UJ94/ULSpWxaP85hlkqlZPcJy+E5SZzztPXy9tlmQUWvLzzBsr9DbbXpVdi43c17ERLzs+mty0DI7C1KCNHYCmfItyBlWTQL4RTeeVApNKh2RZKW4ykEWxf1x/jh/kaNYIbI+pCeH6w+nP4PQWJes9AyBPU85ua3wvFSqdTXX1x0T9/NW1fr9aHWXa2x9oNX11C9bZ/aNofSaN/bVzkAaSH02m7r0ys7+wVJpLEVTqWQn6jXPIvp+SWhQfMsoMc0KnC2Tnbglam0bqphbb3t9IENLNk2epbdq5fXJ4MskM0nlB5IW3m7xM4ytSWvPV6bhqFh4e0wgqljqL6mwlqvfp7ytq+UHIbGXjiHZRprMfR6lm8ApCO0Wo5aYj5LZuM2LKYjxOMg2OAIn9VXE+puEUJdvlCJzG7fM+r1hd5XpqF101e/631P62sfhnb2eGk7nQ6azWZiLemHlstl1Gq1BNZ6dc+aS1Yk5Lkytk9CiGoQedZYhZIIwIOsTGs/QC/wxnEmHwxDYy+cSiH/w9Po9roKr3aQ9XssA3iMQOGz5Xod7wkVfVG7L9NGVi00z7J0nibPqounwfvhVzqthwL0WT39gaQWJ8taWWhu6ziMRRzWag563hNQHS9POL24hoey9ivLGaJhnPsQhYTK09AkjbjyQGQduG63mzqlTc8qsgEUD9aqtdN6hqZqbP0UAmv4XplD0wD++1SUQgoqZMXVinKPpLaTgTFadItgshSipSwLae95gh963roudrFIlpJU8oJGo9LYCqenNW2neIMwTL42DzKLWgZNy4FixG5ychITExOpgEcURWg2m4mANhqNZNe/lsdrNrKnCyX0YwNRFHCv/bRYGpAoFuOze1gmlYe3btgTCosGsjQ/69RutzE7O5tEp+v1OgAkx1BSeL25TYtq7JiE4g9ZdeK3h6QsMQ0hORWKFVSbtz6rLo0q9VGFdOyFU7XpnibbuYMGy0ZdKZyVSiXF7IVCfDiYt0CbDKwLwkNWyYPmtu7ef4sAFLKHlBPT6X8P3lrlZdNTwKgo9NiPUD20Pgu1Mln1HPaeTWddhVCd9be10DZtyC/2aGyFM7YYgw8QBnym9RjbCvqgSKDtaApTs9lM4GOj0UhOedfXCDKwY+ulAqxHM+pbtnUAPWYOre7RZ6yGV0UR8ptC+Vl4ZuckPaKFZl8BvYOcmQfnRS1pOV5dBwmJ/a9QNfSctX4cFwBoNBopFKOBNC8PDRpp2mazuZs/enO9WTTGwllEobDnqrcnrC+Fqd1uY25uLsmXpEKVtSWLeen2JOZjoabHUMMIlhVMe93OxQ1DWf6aTUdFNT8/n2JQ9tEw5WvbR63r8yW2gRB8dnZ2ZKvuuQhx+8NrxpXGVjizfJvnk+fzIRW+0EtoR81vITRqO4ZBHHu6fG+P5PMpf0/zwjC0p8e7l6+/GMPSC6uOcsopp6EpF86cchpTyoUzp5zGlHLhzCmnMaWRhfOnP/0p3vrWt+Kggw7CxMQEXvayl+Hhhx9O7kdRhI985CM49NBDMTExgbPPPhs/+MEP9milc8rpxUAjCedzzz2H0047DZVKBbfddhsef/xxfPrTn8YBBxyQpPnkJz+Jz372s7j22mvx4IMPYsmSJTjnnHPQaDT2eOVzyml/pkI0Qjz/Qx/6EL71rW/h3nvvde9HUYTDDjsMH/jAB/BHf/RHAIAdO3Zg5cqVuOGGG/A7v/M7A8uYnp7G8uXLMTV1DgqFysD0OeW02CiKWti16w7s2LEDy5YtC6YbyXL+wz/8A0488US8+c1vxiGHHILjjjsOX/ziF5P7P/7xj7F161acffbZybXly5fjlFNOwf333+/m2Ww2MT09nfrklFNOIwrnj370I3z+85/HUUcdhTvuuAPvec978N73vhdf/vKXAQBbt24FAKxcuTL13MqVK5N7ljZu3Ijly5cnn9WrVy+kHTnltN/RSMLZ7XZx/PHH44orrsBxxx2Hd73rXXjnO9+Ja6+9dsEVuOyyy7Bjx47k8+STTy44r5xy2p9oJOE89NBD8dKXvjR17ZhjjsETTzwBAFi1ahUAYNu2bak027ZtS+5ZqtVqWLZsWeqTU045jSicp512GrZs2ZK69q//+q844ogjAABr167FqlWrsGnTpuT+9PQ0HnzwQaxbt24PVDennF48NNLC9/e///145StfiSuuuAK/9Vu/hYceegjXXXcdrrvuOgDx4uRLLrkEH//4x3HUUUdh7dq1+PCHP4zDDjsM55133t6of0457bc0knCedNJJuOWWW3DZZZfhYx/7GNauXYurrroKF1xwQZLmT/7kTzAzM4N3vetd2L59O171qlfh9ttvT3bD55RTTsPRSPOcLwTl85w57e+0V+Y5c8oppxeOcuHMKacxpbE7CaF3Hstwu8VzymmxEXl7kEc5dsK5c+dOAMDMzKYBKXPKaXHTzp07sXz58uD9sQsIdbtdPPXUU4iiCGvWrMGTTz653y5MmJ6exurVq/frNgIvjnaO0sYoirBz504cdthhmQeXjZ3lLBaLOPzww5MF8C+GVUMvhjYCL452DtvGLItJygNCOeU0ppQLZ045jSmNrXDWajV89KMfRa1W29dV2Wv0Ymgj8OJo595o49gFhHLKKaeYxtZy5pTTi51y4cwppzGlXDhzymlMKRfOnHIaUxpL4bz66qtx5JFHol6v45RTTsFDDz20r6v0vGjjxo046aSTsHTpUhxyyCE477zz+k6UaDQa2LBhAw466CBMTU1h/fr1fce9LCa68sork833pP2ljS/YwerRmNFNN90UVavV6K/+6q+i73//+9E73/nOaMWKFdG2bdv2ddUWTOecc050/fXXR4899lj0ne98J3rd614XrVmzJtq1a1eS5t3vfne0evXqaNOmTdHDDz8cnXrqqdErX/nKfVjrhdNDDz0UHXnkkdHLX/7y6H3ve19yfX9o4y9+8YvoiCOOiC688MLowQcfjH70ox9Fd9xxR/TDH/4wSXPllVdGy5cvj/7+7/8++u53vxu94Q1viNauXRvNzc2NVNbYCefJJ58cbdiwIfnf6XSiww47LNq4ceM+rNWepaeffjoCEN19991RFEXR9u3bo0qlEt18881Jmn/+53+OAET333//vqrmgmjnzp3RUUcdFd15553RmWeemQjn/tLGD37wg9GrXvWq4P1utxutWrUq+tSnPpVc2759e1Sr1aK//uu/HqmssYK18/Pz2Lx5c+pQ6mKxiLPPPjt4KPVipB07dgAADjzwQADA5s2b0Wq1Uu0++uijsWbNmkXX7g0bNuDcc89NtQXYf9q4Nw5WD9FYCeczzzyDTqcz0qHUi4263S4uueQSnHbaaTj22GMBxIdxV6tVrFixIpV2sbX7pptuwiOPPIKNGzf23dtf2rg3DlYP0djtStnfacOGDXjsscdw33337euq7FF68skn8b73vQ933nnnfn2YW7fbxYknnogrrrgCAHDcccfhsccew7XXXou3ve1te7SssbKcBx98MEql0kiHUi8muuiii/D1r38d3/zmN3H44Ycn11etWoX5+Xls3749lX4xtXvz5s14+umncfzxx6NcLqNcLuPuu+/GZz/7WZTLZaxcuXLRtxHYOwerh2ishLNareKEE05IHUrd7XaxadOmRX0odRRFuOiii3DLLbfgG9/4BtauXZu6f8IJJ6BSqaTavWXLFjzxxBOLpt1nnXUWHn30UXznO99JPieeeCIuuOCC5PdibyPwAh+svtCo1d6im266KarVatENN9wQPf7449G73vWuaMWKFdHWrVv3ddUWTO95z3ui5cuXR3fddVf0s5/9LPnMzs4mad797ndHa9asib7xjW9EDz/8cLRu3bpo3bp1+7DWz580WhtF+0cbH3rooahcLkef+MQnoh/84AfRV7/61WhycjL6yle+kqS58soroxUrVkRf+9rXou9973vRG9/4xv1jKiWKouhzn/tctGbNmqharUYnn3xy9MADD+zrKj0vAuB+rr/++iTN3Nxc9Id/+IfRAQccEE1OTkZvetObop/97Gf7rtJ7gKxw7i9tvPXWW6Njjz02qtVq0dFHHx1dd911qfvdbjf68Ic/HK1cuTKq1WrRWWedFW3ZsmXkcvItYznlNKY0Vj5nTjnl1KNcOHPKaUwpF86cchpTyoUzp5zGlHLhzCmnMaVcOHPKaUwpF86cchpTyoUzp5zGlHLhzCmnMaVcOHPKaUwpF86cchpTyoUzp5zGlHLhzCmnMaVcOHPKaUwpF86cchpT2mvCub+d2p5TTi807ZXN1n/zN3+D//Sf/hOuvfZanHLKKbjqqqtw8803Y8uWLTjkkEMyn+12u3jqqaewdOlSFAqFPV21nHLa5xRFEXbu3InDDjsMxWKGfdwDpzb00SintjcajWjHjh3J5/HHHw8e65F/8s/+9HnyyScz5WiPn1vLU9svu+yy5FrWqe0bN27E5Zdf3nd9xYpzUChU9nT1csppn1MUtbB9+x1YunRpZro9LpxZp7b/y7/8S1/6yy67DJdeemnyf3p6GqtXr0ahUMmFM6f9mga5bfv8xPdarYZarbavq5FTTmNHezxau7+f2p5TTi8U7XHh3F9Pbc8ppxea9gqsvfTSS/G2t70NJ554Ik4++WRcddVVmJmZwdvf/va9UVxOOe2XtFeE87d/+7fx85//HB/5yEewdetWvOIVr8Dtt9/eFyTKKaecwjR2J75PT09j+fLlOOCA1+fR2pz2S4qiFp577uvYsWMHli1bFkyXr63NKacxpVw4c8ppTCkXzpxyGlPKhTOnnMaUcuHMKacxpVw4c8ppTGmfr60NUblcQbHoT6VE8Ru5k9/dbrcvTaFQSD5K3W4Xw84e8Vn7HaJQvvq85mHTR1Hk1jkrf22PPsvf2j/sN5azUBqmfpqGv3XMQu3JKoftGXX2L6utWXmFxn3Y+i+kTKWxFc6DDz4Y5XINxWKxj6FbrRbm5+fR7XbRbDbRbDYTJoyiCMViEdVqNVlQXyqVUCgU0O12MTc3h1arlUpvBYK/S6USSqUSisUiSqUSyuVy6j7rY5lfqVgsolwuo1gsJvUqFouIogjtdjt5nnkwPctRhlQlVCgU0G63MTs7i2azmcq7VCqhVov7bn5+Ho1GA51OJ+k39hE3+oaYL8TUqvj46Xa76HQ66Ha7SR0KhUJq/DqdDjqdTtL2TqeT6jebJ5/lbyBWRuy3rDrauobaGUVRUidNz3Hgb7an0+mkxo1t8JSqKkMtP4pamXUmja1wrlixAtXqZNIpPYowNzeH2dnZpGPIcECvQyqVCur1etLJpVIJrVYLrVYrNbi24/S7WCyiUqkkjF+tVvsGQQVLf5NKpRKq1SrK5TIqlQomJiZRLpfQbnfQas0nA9xutwEAlUoFlUpldzlFFApAFAGdTrtPOJvNJtrtNtrtNsrlMmq1GsrlMqrVKiYnJ1EulzE3N5coNCqjbrfbZ2GtddO+UFJBUaZtt9tJvsrYVHA6TmwHx0+tvxVqW0/2MfPwlCrbYQVb06jCo9KwykQFk2PCevNZ8hKVuPahGoB02Z2+fvVobIWzWCyhWCygWKT10HvFxPoogwBIrnnWTT9Wo4XgpLVa1tKyLF5nvXRgqJ1LpdLu8guIot49T1Fk1YW/aakss4YETstTIfTuZ0F5vW/z8fIneZZRy9Z+tEqC6XW8bRleezWd94x9Vp9XNDMIii4Ebg+isRXOcrmIYpFCV0ChwEGPO5JQsV6vJ4zabrfRarVSWpYQCkAC6+bn51NakpqRg6CakWnjOpUT7UgG4XNKnU4Hc3NziVZtNpsAkFiXcrmcEihqbgB9ygboQXnC8VarlcBUwtqQ760ann1E6GkhqYX6avWUrPVRC8RnaUWpLNlnet0+r3W2FpGWiVaZ48Q+UQtJNAEghRI8paN5e1ZdFQbbxb5jGdrPfMZafNODfX3q0dgKJweC7YqiAuKjV/ReIYFz9D+VtKOVwdvtdvK8DnipVEoxqfoUFCiWz06nYAO9gZifn0/qor4YGUUHVdPwt7VGFC5C02azifn5eXQ6HczPz6PVarnanUxhUYMtwwqnMqB3AJV9VhWh/rdw0kJi9qntD9sGhZfaLvYHy1K/VOtpLb0VHA/tWBfC89GtAmV5FpIvlMZWOLvdaDf0i/9rx5GRAaQ6jcLF6/ocBcT6IgqBdYCsr6CBnUqlkvxWa0oKDYpaZR1g1bhMw9+sCwWewkkLCMSKgz5tpVJJmNiD8MpgHnOynpomq23WPbD9qf601kGViWX8kJvhwUYVdusLe/A9CzrbcdF0Vlj3NIT1aGyFMxayNoCewHiBHAZrFNqo5lTrosKp1lI1vxfRLBaLqNVqWLJkSRIJrVSqKBSoRPjpWUeti0K9+fl5AP3CofVQ+EoI22g00Gg0kjza7TZKpRImJiZQr9dRq9WwdOlSTE5OJkJJKEvFBCCBhFQqVkAVzmmQg2SZV5WYjWZHUZRCEdVqNRVYYf/YaCnvqfL0psCiKEpF1FXANW+1zGrZdRxYpuZtjYG14Pq8+uqap1Veo9DYCmfceT2NG/IvOCj05awgq/bWDtTgAsuwVpbCS0FmNLRWq6FarQGI0Gq10em0d5fj+zQ6UKyHWhlVEppGreXs7GwinBTYSqWCycnJZNqoXq+jXq+j1Wqj2WykLKcNbnjMzD5QofUgHMnCYPaV+tPq/zFybeGyIh6Sx+RaLtNw/LQ9GtBR62cVuy1L/WNV8DYyrOk9K5oFaePri9znLBR6QgcgYUq1TCHtzvSEfsNEM/UzoGa7v6PdkDv+VsGmMtDybf4qnJ5v5vlJNohTqVSSA9I4r8lntA4acPKELqte3vSA9hmf0aCaWkN+87dCdtsnnq+tdea4WisFpIVT51O1jp4Q2d/WX9X62Ouq1Gwwbk9A37EVzngapSecjEyq/1IoFFCv1zE5Odk34K1WK7E6DJ6oMCvTKRN5nazf8TN8Loa1FEAGm+bn5xNLx7ztoOtcYKFQQLVaTcqhv6Rwjr4u0FscUalUsGLFCixZsiSZ3ywUiil43mw20Wg00Gq1Er/U+tpK7B/Wg3VRZrcQk9afc6vsA4XWRAJMr3DV6x+1fqqsLIJSWG7jDN7zVrlrXfRZT1mrZSWkpnDqogprOVVB7BeW0zKPMj87kExhtblCW7WcnkWwz3k+Qj8T96wmfWK1nBwoMpEyH8tTOOZFBm2blIm4qKFarSZQNp4XLiGuapSqBz+hCX4raB7Tqp+m/a+WSxdQ2KkI7RtVklnWk2Wwj9QqWyHLsvJaD4+s3+il88bDwmEaAMsv1soPS2MrnHNzcygWe8KlPqNqNt5TK2OnDKyPqUxKBvEGT6c4etMhHXS7pd2MGklAqNsHZYF+TUyyg60rVMhk9Xo95YdyCojRYlrCOE1vKqnRmEtNt1AR8BlPKEkew7N+Wl9FAJ4l1udVCBXWKiQM9Y0dFyIOK9AW9VgFq/Wy7QxR6L51AZTHNE2/xRyNxlY4d+zYgVKpmvwno1kfkvBVhdMuSNDILBnbWg4yDf9b66uBjdhKdUAL1e32/Eyd5tB8LGyzUIvKR4NQtIhx4KmV1DGGpunFAa3WfLJuuNlsYteuXYnlpkVTYbZRTJIKGpWZFUy2h+uN+a3CaKc1+LyWaf1dS2qlSLrGmWOsY6hklZ2nPEJCo8Jm66gW3QYUraIgSrBtGobGVjhbrXl0Or3wtobbgbRPotqY9/RjGc4OlsITJe1kVQzx/Cu1dHodpc6n2ry8b72v1ihWJNVkmqhSqaDd7iRQPvYFu7ujxZ3dfdZKLCanYdS3VX/SUxYkC2ttwM2zCt7H3rfWzSMPElp4qm0YBEdDZWRZM1t/S7Y+9hlbjyykkkVjK5zz8/O7l/D11q5yRQl/A2mfTYVDfUy1RtbfAtJaUmEYiUxFSxRD43JSpsJnBlAUPisTaYBHAzv1eh2lUimZsywWSyiXSyiViuhVReFmAZ0OrUcv8NNsNlPzo7aNnMqgpQkJmratHzmkhdZjRrbd+paKGJQ8pWUVsJ2yAXoBLFXe3th5wmZ9R/VvBwmwB9PV//aUb5bf69HYCmej0US5jCS6SDgHpDtYw+acnOeAUNAUznlTLxxwZUoLRwlZO51OKr2WT3+wUCik6sF6EtZRuRBq1ut1LFmyZLeQTmBycmJ3HdMBl3KZ8KiAQgG7g04xnCWU1blQy5QsS9GI9YeVIXUBg1pirkKyboAKIBUpYai1Hqp0Q/6m1l+j7exr5QldZKJ18qKzWo62WRXOIMtJpauQ30Ng1jcehcZWOGMh6J/T8iKNGoQJ7c3T52yHexBMyfpaOuiWKS2EBnqaVCOO2pa070aLSwWisNPWqydAOr9qhYXP2+CNZaZh2q152bS2T7OQiv1tGTrruuUJHbss/zUkcPZ6lmDavrFCHqr7qFYTGGPhBHqROY1MWiddtSsFlc/aCC2vkyyTKDT1fCOWx/k6e0+txsTEBGq1WhK0oAXiN60mBTP+XU4JZWyt4iWMnQ793B6snZ9vJXBT2w30ds0wb15nxJfWh+RFOtkv7EP6vpOTk6hUKiloXCgUEkhtp2C8tb5WYC0UtIrSKhM7/UQryjp5MFeFW5XGIMtmoXBWGs9y8ntU33iMhTPuwHgdayVZDcPooVpKhT66aZmdrxE+T+vaOSpv4JQpCJ/5rPVXC4VCciqBjeAqBE4LEIWVy8ciNJvzmJ2dSTGcwkpO9hPSaR10sYFCSN1K5fmMnjVgHQuFQrLGuF6vJ23jWHDRBcdLfX4iBk57ZVk6HRc7JiqYFrFwIQdjA0xrBcRCWCs4WVbW9pftJ9uHPszte9ylMRbONCTVBc6pVA4U87StBiXc0sRy6vMefFPtr6T+itZV19MCPcGwvhCha5QsB+z0QXZlauszWhhP4dd6Wj9UIbftTxUS9eF15RDvab90Op1U8M62MQT3lLk96GktmAfbQ2mzIGqIBsFvm3cIiu93PueSJZOo1ep9xz94E9baAQrrFM56MEjhl436KcQF0oEpZWa7UoaQWIXaO8qDde+l6a0l5tK3mZkZ7Nq1K7W0sFAo7F6g0QvqsJ5cmM82esrICq/tV9uXanGjqBclpxXkqi0Njqgy4iolDa7Zullh1W+PtP8UMZAUhofaFlLUnuW0SsOzkLbuWo4tf9HD2iVLplCp1FN+ZmiOzK4EUiirDGZJIR+QDt0DPQFXaMZ0HrTib4XJURT1WVG1oGqdYqjawvx87KPOzs5ix44dfXOS/N3bvlZJlcGlg14klnlxd421MBQ2+nBcjaMnKFCJqIAq43GbnvaP7SdvPNMIImx19D4Vgm7EVuEMzY9bIVQKWWNPsDmGWWcI9Qtn9lwvaWyFk8QO1iMuLHnw0A60l95eC6VT34110vpl/de8Lby2cBbgQvoOOp12yupo/vptLVKoD21aSxa68pqNLjMfZTyrPEJWalRY5ynVkLWz9zzLZ/MeFep6MNejYeo8DI2tcM7M7EKp1Ft+p3sBGbkF0kdP2sUAJG96I0t4yXi6cIEBKQCJVVDm9IJCLEcXgXsnJ8SKp4N2O14XOzMzg3a7jZmZGczNzaV8VCWWrdbd80d1+5aN1vI51kMDK9pXqigUxnJZpfadflvh1fvDCIf6qTZvvUa0oPzC67T+ilI0jYe8LJpSa2qtNPO0i2E8tDAKjbFwzqJY7J3vyQ3FXEWjvpUNPijjWf9SGRjwtb1CEQ4iV/GQaE30uBDWx4NCTEOlooOliqXZbGJmZibZIsejLXXpHT8KH6m8sjaPW2GwsJ1QVhnbCnen0+k7+5fkWQz1Rdkn3m9L9p5nea1w8jnu2gGQ4g0+o26PpzAsrLZ1VkVvBdzyj7ZlVAEdW+HsdjuIop618Jz60OAOCzlCkNT7aN601hZue0GYLEinjNDpdBEvyestKAhBOMs8vKYLI2z7Qsyu1lWhbeiZEJTN6mdb71FokNUZxirZgM4waYdJo4pyWBivLswgGlvhjCeze41Xv8fOQ+rOEQ0QaKd5lkPv6bk99oBkWiUg7lzuoaSl032bNqoJpOdfOWAMyBBitlrxuUWct2Q+vB/yp9leRnmtlqYi8bQ3Fwx0Op1kZ098BEs1ZUV1Kkc/Nj/tX3vd8/GtkrHX9VtRkZd3CI6G4Kst19Y/RMp/usNJtwtqWbaeo1jPsRXOdruDYrF3hKWFHNpYu5XMdgKtgbUyCol0BY8usrb7M2P/s4pqNV6NUq3W0GrNJz4i91QqnLXnqKp/w0UVnD7hAgcVTm2vMqP15bwJd55Ur1MLvT5upxhe4TUhL31ktZo2SKXkCRCft+mymNUTaItIQgrL5mNPlgihHH1Gv7320BWg0rb9PyhINwyNrXB6pHChfxN0P2PqfxUuva9CrR+9x0FNRzu5cqYEoJowge7CsNpT62NJ87fzgiTPomT1lbZdhRro+ZtatroQNm/r73rCFmrbKLB0GD80BE9VMLwgFPMY1H9qpQf1uV73lJDmNSqNrXDaqCehp86vAUjOx7FzejZARGG2Cwn4rRFIDaDoxHpvaWCP2ev1CRSLvV0oWh6veZuALWTj+ttms4m5ubm+aJ9OcQxiYBVM5sko7MREvOOFh4IVCoXkvCGSLnpgnvF7XiYwPx/vgmH+1qJ4FPJ7vf7wnsmCyNpHes2z7N6qLK2XpzyJKPRZbSfT6iIWvlXAc6ni70Xuc9LfJGl4WoWTPpolZSyFQOqL2jW6vKblqA/R8xu7KBR6Z+ZWq5Xdx1H2XixEpeGRHWSWzwl9rle12tibZ7X5khRhsP30IXWbGoDUSRKeP0kIx7pa9GEho9bFg6LaB5assFnB9u5ZJRFyBwjX2ZdWQdo89XndIufVxwqvGhV1G/YL4Qz5lzZKaC2m7TTbyXrdwlfPB1EmV4VQLld2L7krJFHWbrc/SmuZcBhIpfX37mn+Ni3bposHSKpgVGgtvFe0wGCX9iF95dCUwTA0DMyzgugJ0zDptb/UTbFtD+VD8sZDXQZNZ+tqrfUwNLbCGe8qqaQ6x052q6XzaBgtzW/LZDo4UdR7GVGpVEreeVkqlTA1NYWJiUl0ux3Mzzf7Tlmn1bGQ1GpiK2y2HR5MU+uvq5hUiNS66ZxoqVTCkiVLUCgUUtva9F0yQC+iq6+fqFariRATHQxivCzfa9DYAOmgEssa5FvasjS9VfiKVDzylnkSJXGMuWWN/aTKP91Hi9xyxsc89kdYgfS+QC9wAoQnuz0fhXl66fmMbhEjY3I/ZmxF0sd+sG7eYgjmo/nb3x4T2wigBy15zwalKMjNZjPZbqb9SqWiB6MRAtKfooDq6QZ2C1hWG7IE0xMmFUYPhXjkja32n2eBdRuf9p2tl62jCjUjwkynmx14bb8RzrgT49+2U5QhB5E3+N7ghaCn9WsUGrbb7dQ+UbWaWj9ueLbWkRP/QG/hNldCqd9rfShVJFnLzUIQnW2wgmqfs4LP8mmhoyhKnWSofpYu/PegoQcbvTHx2hBSvKF0oTw8RT3IlbD10j71rKRdOhr326Jf+N4fGFCmD0FZpSxY60FHTWsHVn0xPZ9nZmYm9fbrSqWSiv5y2R8FjvOZzIfEU/Y0Ssy1tWyzzkPyP4M81kraaRztw2433hgdHz9aSvUr28nIo25mJ3Pp+UCeb6tL+1Q4NeLsKVtvrCzqsWMWCpLZPG0ai5RCcFb7zZtOUv9cBd4qXR2rbjdcltIYC2eaLFz0oJxH3kB7mjMknLZsAMlhV4Qt9hgUGyjhCiP6ddoO3ufA05+jZVN4bPuATGX9G2v92C59ntMn3oJ6C5et4Cgz64n7JOtmeJbTS2fTZAmml18obehZHftB/rLHK9o3qrxZL/X76Q7EcHeRW86Y+dIRNO0gT9N5MAVA3yoXy+DqIwDpgIMHa/RbAxKc29K6aOBEI6RAetcHhUQFXYXWkoWQHvwkUygzqUB4r0bQ/56C8sbJW7TgncKgvqO2wetj/h5G+IZV0FlCOoisorLXtR90PBU17FfCCXT6mB1IH2WpwqYf3iecYCRNX6zDb+460a1AQG8bkmpH1oWk0I/QhxCX/pwu6fPgm10GxroRJnuLAvitPjBJ89bgjWr3KIrQaDRQKBRS7zhhf1kFqAyo19ifNr2+Gl77zFOwNurqtUOhJNNZoVSIaxUp8xgG/nplKoKxrhb5gG1SBavKjgHEEGKwNBz43U0bN27ESSedhKVLl+KQQw7Beeedhy1btqTSNBoNbNiwAQcddBCmpqawfv16bNu2bZRiAPgwlqTOdVZAJGlkMX0GkbdSRI810bQexLX11FVLXBRh/WNvPaq2If6U+uqpfpqStYY2Esk0yjCan62XCo21nFlWQ+dHdZy0zBAUDPVtSLiyxsBr9yCLGsrXWu+s+oRcAIuEBo2nRyMJ5913340NGzbggQcewJ133olWq4XXvOY1mJmZSdK8//3vx6233oqbb74Zd999N5566imcf/75oxQDwO8U/uaezomJieRTr9dTb00Ofaug6uJu/a0v/LFQkB3uvepd03NaQvcZ0vfkzo+0suifo2T+TGt9PsvYLFf9UZtnSOFYoVE3gIEsvl3bniqv0J1L17xT5+34eosYtJ6h+nl84ikJT5AG8ZunaFRhWcGyVlbr7yn8URTGSLD29ttvT/2/4YYbcMghh2Dz5s0444wzsGPHDnzpS1/CjTfeiFe/+tUAgOuvvx7HHHMMHnjgAZx66qlDlxUzmD8g1WoVU1NTqShlt9vFzp07U5PiJO1AtRx8nrBWmRfoRWW5b9NaXBLrYCOxjGgCva1b9fpEEiFtt+M08Wqj+PV9Wj+uZ1UYzrw8q6bTLmyPMoVNr/91wYRutmbf8lR59Z+JFjzrrcow5DeGoKdCSbWKFn5aAfTKtGWEvm3f6JynWkALr7XOKpSE9Tr/2atX+iVUIXpePueOHTsAAAceeCAAYPPmzWi1Wjj77LOTNEcffTTWrFmD+++/3xXOZrOZ+GQAMD09DQCI2xOO0PVe5tNjDOuEe0zhCa3OQ/E/71sfh9cHQU3PR4sHmfsLoySk3hN4oFBIW7rQWlDLIJ5f5Glp2/5BvpkKANtj53L1OvtJ+4dtUApZMc9F4e9BFscbq2HSh/LQ70EWz0JpfjRYNirUXrBwdrtdXHLJJTjttNNw7LHHAgC2bt2KarWKFStWpNKuXLkSW7dudfPZuHEjLr/88r7rtCJWICiYKogKPb2G2zA34IfBqTFVWKvVairQo1oU6FkX1ZqsA+uk/levbLZTLXCvfrR+k5OTfdvisjY7a5DFamxlDD3OhO2wcFkZVDeLa/DGwmHtX88t0LqGaFSByHpO71tFqc/Y9tqYhrbX9gPzC8FWq9j3unBu2LABjz32GO67776FZgEAuOyyy3DppZcm/6enp7F69eqU5bC/FYLagQ8Nik6mk7SzdY2kChoXBzBPpmH0V09/V4b3gyMlRBGZIEJ6GVf8n0qp2+0mJy6oYul04iMz1ZfVtvOj960AaR+xrroMz+ZL4bRlqnCGBJR1Zj+oRbXW31IWxLX5KUqx7fDq5JEqFOU3awRs9Jx1UV7V/qFy36s+J+miiy7C17/+ddxzzz04/PDDk+urVq3C/Pw8tm/fnrKe27Ztw6pVq9y8uK9wEFlcr5TV4TadpzFDebE8z7+wv73//UKR3PFauPu+D4FseH4QZPfao2k8RaV1Vr8rJOC27V55WS6G5h26F/qf1e/2GauMQvnrNQtP2RarjGzaQby514QziiJcfPHFuOWWW3DXXXdh7dq1qfsnnHACKpUKNm3ahPXr1wMAtmzZgieeeALr1q0bpaiURtSG2+CDRtcYdLEwwubjdZDCF4WRVnOyHzztGRLctFYvIoq4DI8BnNLuExUKKJX6l8sRLXD1EIBkOSAjp6yjbVe3200tZM8KatBCst26HNG+DVwVpVoI62YoDQNxQwJjo8623vaajfbqdyhv6x6pJQzxjJ5aaCP8Nu7Q4+G9sHxvw4YNuPHGG/G1r30NS5cuTfzI5cuXY2JiAsuXL8c73vEOXHrppTjwwAOxbNkyXHzxxVi3bt1IkVo2BEj7ThoAIkzV83bYSVazMR8dNCuo2vEKI1VJaF7KhGoddA5R06d3PkSID4/uRTfjgS2i0+nBS0LhYrGbnJsbRVEiMDwzllvBQpaMEWyd8glpcD27SKd7tC880sit+sPWp/OCPFlohNfI+AoP7bRJSDF6fqWnZOx9bTcFNDSXy4Uk6gKocDKPuB2D14UDIwrn5z//eQDAr//6r6euX3/99bjwwgsBAJ/5zGdQLBaxfv16NJtNnHPOObjmmmtGKSZF3uCy0VkRU++6taYhGDgIig0Do0MQN6577HOmGTPNLDGzFVEqFdHt9qyeKgmG7EMKydbXg64eDKUiC0Fi778Kg1dGCO4Ogpm2vJBSpeBoOvUhQ1CUvz3h1Ei5VerM2waOhoHBw9LIsHYQ1et1XH311bj66qtHroxSbBn7z8yhZuYmYKs5PR8xNA0xqD2hNJ6ga/oo6p1eR2tv17/q0ZjFYnziO3a/e7NenwDArWal1Pxlu93G7OxsMod60EEHoVgsotls4rnnnkOj0UjVU+tPa6tWh9c9odJ3bbLOVnnp/C+/Fc1wqkzHyYPfIZ/WWkCFsJyfthZNv/X1iJZPWHddYKDX+BpHRT6c642iKIH9xWLvVZVA75QJlqlR+71mOV9Iarc7KUgF9Dpd/SjPD7AQRxe+e36j9TtseUpZkFCtDqGXRnB1CiRmrCoqlTI6nS7iQ7R714vFAkqlMiqV8u7BjfPiGUNcexsvk1yK6ekdmJubS4TTKg/WTV8wZP0/7R/CVPYpT9tXKK9rkvWV9nqGK9+Spn68JYX36ufr/Kg+p7CSCs4qG9ZT3/Rt/UndPK4CSYg6MTGBcrmM+fn5lIKhwHORCKe9uA5alb9VKnEfvgCLEPYVeRAl9O1BDf22+Y5ajyyy5dr69Q7N1kUXusm8l0+sdXuvF+RAkymq1TjqXa/X+3wxr76DYLAGNvS3bZvCOl00wXw0UGJ35QxyH/SerbtFLNqm0CeUt3dN2+b53SF4bfvRy38QfCeNrXBai2m1Okl3XVjfwUI6m5fCRQ9qeX4X8/DK4DULm3idQRbV+OpvRlHPYsXtKaJUivOvViu7hbGFViuGptVqFZOTk5icjLX3mjVHoNlsYGZmBs8++ywajUZqNU+oDaHrNiLNs4UYKCI017XGVBg8IUJ31jQaDczOzvaVbTcJ2DopsrFRdYXpusyRv2nBPYHW1TtqddWn5Jpn3WCuvr+1jszDtmMUoSSNrXAWCv5cnPUvVJORQYD0OUPWB8jSrKo5PYHVPLJIrQmfIfzha+Zjn1rnP3uvAIyhVwdRVE7aVqkU0OmUMT/f2u3z1FCvTyQL6ScnJxBFEZ599heYnZ1NnbTn0SDrqauftP4qkGyPwsRqtYp6fWJ3vWPL3m63MT09ndqdw/LJ7Pqx6MdO4CtsZRt1va99/QXJPq/jS+uu8Do+XbF/jy3TW56kYCrPqXX15ulDNLbCaclqWzt4XrqQVSDZgQnB4ywobMnLh5qX36USlx/qczafniXVwY2FpSBC0VspRZ+Q/h+3sNlVLQuB73xWP7aPNWrJhRZUsjrdYIND6o8qmrFjHJpvzIKvaSvYH0nlb3u9J2i9+Whtp9dHuv1Og0Bal/0C1gL9gqc793lfJ4KBnpWwJ+GFoJL+tj6Endu0oXr72y41pKXhtrbYui0xr6WLl+3FAkYmAoDeSfAsn20ol8uYmlqagpUMxERRhKVLp7B69WrMz7cwPb0DP//5z5NDrhuNhosUlKx/p/0KIBWxrNVqAvfi6HKhUECrRYvWC5BNTk4m0z4W2ZCx5+bmUkEroLfOmGPE8Wdg0LopHIusdulYsgwqMQCpwJu16HoEJoWfp2AQvjPSbSH/fhEQslbNMpS3v1EHXH8DfkDGCpinoUPQzxNOO2mtEcB6vb47AhjvO40Hf363QFJB9Gv3dpsM3N69RrOEycmJFLQkLGQfsKwoigMyu3bt6rMUob62gmn7QA8pKxbjQ8CoHCmgUaRHp/SgIwNW1srosZxkesJTluNNd9jIs10QYhWPtdg96FpMXWM77TQMicKpvMkjRakweLYUgNQ4xYtKFjmsjRnDn6T2IE7IEmhQR5nNph0GKtm8bDqm0U9vyqSKcrmn/eNnaY1j66lCCsT+p4VY8fX+Fyyxbd5ChYmJieS/vnohBHE9YbWwj1ZGBcRGa7Wu2jdeeXxOLWsPxqd3BKkyUIVo+97yh93NY/1F5kPEMj8/7/q6ygvaH/q+HevP9trf78KEaIyFs38Znc4d6uS3djQ7V6NuIf/C6zyg/2R53rORYLUAmocyUa1Ww9KlU1i2bFlKqQDxXG6n004xXxx84Gnr7d3zn120Wm3MzzcFxhdRLPbm1BT66QnutVoVK1euQqfTxnPPPZdAMJ5qYPtE+9RaIqbV1yLqjguWz6CRRliZt763lPnqW6i5EZ3MboVJT4bgWNu5RaaxLgpPcVBrXSj0gkDFYjG1Dnl2dravPTpWygN8wRPnknmmsfJG/GxsPYehMRbO2B/zLJIXCWUajSx6E96a3gYKLISzVlvhj2pM6/yrcDI4Mzk52WetYk0eLzCIrWV68j2OOHIdbieZyogHvgOgx5gMOHHdLZmmXC5j+fJlu/PrYMeOHSgUCqlopkUQquAUbTCdCqaeaE7lyZck6SoptapWSXEso6h3coAKp1olXbmjlptKQoVTBYl56JvqbGSWgmr5jW9j00UX2hcUdsJ9fU2D5V++W2cYGlvhBPxoqvodCjdsZ2X5Hva6Z1ktBPbgn+ZjP6yjWnigF/K30xvpwaNwRGi1ev4YlUBvoXsR8/OthGmYP4VYA2UAUKvFx7tw3pGv8lNSxaNWL4QytF90PpRn4mr7qbCA3nGlOqa2HlqWtcJAOgquz6nwaJTarlLKQlCWP/RUfJatgSwbgNRnbXQ7xEuWxlY4rVDpPBrn12ynqkNvoZrmy/vaUao9mS7kq2o+dokhrzEIxDWX5XI52eI1P997rXyhgEQgFbKTIWZnZ9DtdvHK1v+vZ6Xm+9fz1ut1PHrgmzAxMZE6ZV4ZY9myZSiVymi3Y4GemZlJnQdEUubV5Yfql1mXgRaIz3NxgPqCumVNj+PUzfM2lsC+tYvQiRaISKwCY73oO/b6fj7FJzreIUXBZ1mmvqWcfccyrOCxXqVSaTcS6MUOBtHYCidJO08HUKGQhZn2We+/QhjboVZr2jTWKts0aiU4p8kBV2iFZNN1ISWkhOSxr9nq87+8SOf8/DxmajNJPSYnJxOfR6c96NNt37495d8pWbjvaXvbP1a4vRf4qCW1CxzSEV9/H6W15BaRqA+q29cUbipiGcZi8pswVUktsVpO2z/pOdzh55kXlXCq7+JBVaVBMNSLpln/a1CdSDYUn1YkaUutflrPx+wd5EylwVA+NXIH/TsdWF9aFX29QqvVSiK3uqaViwAmJyexdOnSJJDBd7LYvrAWzAqF7ROrAC2x3pyfLBR6r7TQMQbSp8aroKYj3unosSosTmuoMrOW0n483rJtU8jP53TuWi0o66XwN7Riy9LYCichH9ATTDrjOmhWq4d+Mx9vCibLD/CuW6alcOo8Xa++vbeQxVq8F6LXhQqMBsYCGcPeE2f+Xzy982l0u100d0NjlkNLpcx84sz/i+JcEUvbS/EvE7+dKCEyAwM1hUIBBx54UBK9fOaZZ1KwTAVThdIyrSo4a3Vs/zI9f+tLnDzB8yCxKr0sl0aFU5Uhx0aVgIWyXhssH7BNdikf+5tn9nKs2Mb5+XlUq1W02/4bzy2NrXCSrC8QCgQBwy2zY17Wclr/Mut5m5fVvr169y9miOFNB/GCg3ICZXWVj2pYjVJa+G4Vjb55m4sWYqXQ86/ot09M1DE5uSQV/bQT7lYJWYGzsN7rB5un1t/z4T3h1HG3wukpWYW13jxrKE87zp4BsIqc40KUQiSgfGWDUYv+FYCe9gTSi9/5zev6bJYlDE2x2HReHqp9qYE5MDaiF1e5xyy0YPHzRXBFkE6sR1GUnJiuZQFpv86zHqRut4tmcx48SUGP+CBVKhVMTU2hWq1g586dyVpcrm5hXax1ZB9koRYti6iC9aJQZi2A8ITcjotVorbsrECWFfKsvtR287dVTKF2sM0AUq5Kp7PILWehkN4OpnOaKmBWqyl5FiDLqtp8vPx0oBg55tm2+l7K3a1I/CsGX+JN1IS0PR+aEcudO3filLnbMN9qYWenk1oqFlppY4MQnU4Hs7NxJHZiop5s29LVOxMTEzjooNg3nZ2dS07L54ZttUKhKQv9rX1jEY4Kuk4peIqVlIWOdC7Si8TbqG8Y2fQrAAvDbd5efSyS0Pu0mKVSCc1mc3fUftELp+/LANkCNiwNEtKQJrWCQAYJW+p0AIdBoPiD3R+zcki2HPXmPPtX64TqS1+nUCig06m6CEThbLVaSRYvePBVy/WgaIjUSnnCbPs01L9ZFEqfJag2X50aUkQWau8wvKjPqlLabwJCJA/eaLphYKqm1egq81cGyoIqCps0EKQ+Iue0Wq15lMslo1UBrgjSfZC83263k10NAJKF4hqO1+kPtSK0voTGnU4nebUg4O8xBZDsuWR+LEeDRJah+Kz2g0JWLoSw/cq6sj563VOKVknbazaKrPftc1p3Dxpb8pSI52Z5+XpCbRfIDKKxFU4eHQn42lO1kqd5szrAwhXrQ3hwRr9VoMjE6q8xMqebv9PaGygWS6kTBXQedHZ2Fq1WKznxHUhvJuYJB8oIOhUBAOvm7wQAHFA/AD+I3pKU7c0j1uvxbhEGN1ieBlX0PFttiwq1bptin+qqoCyo6ilGa936+zEd4LEQ1+MFhdRsj4Xgyichy6llqZW1fKfPsG/iw9wG09gKZ5aTPcozXpqQdtY8Quk8rW8Zy1o6+2z8vz/aGz+X3k6lfqLXPsvMVsFYOOwxdRw4KiX+JYU0S4BsPqrQFB4qRPT604PMWePjtSMrne0zTwlkQXXtB69+Kqie1Xw+NLbCaTW9XaOa5cNk+ReWcZTRmFahmCe43oBo3rqAgPsqe3UqyseDbOk2aeRUJ+dVgLxpFV3uNqiPQowe+tgli8zXu8b+UCG1FPI/bV3sGOg46CKDkHDoOOm2LkUEtKK2HCVth05Bef2owk0UsV8s32Nn9Taq6tK2tECQlJE97W7hjD7HMpmvkmehQhaDwhlDxnqSr37SlksHtMeEhJYK2wqFQrJOF0DK2llhLxQKKBq45VvP/ukF/a/9o0ysfqbtO/Wvshh9ENn0qnQ8oQ2NlaZR4bR5qxL0FJbyW1YgUIlpelH5Re5zkjxtRBrUMYPgkWc1Qz5D6HqI0vN54fm7/nzTTGEhoYWBuqDCE86s/rMaPiug4X1CVs7C34XCPO9ZWz8tw4Op9lkvj1DeWo+QNRxFOLPGwqOxFk7bGG2U+lSqyfQ5yxxWU4YYWsvKgsu8zw+tGgVGX7tOixO/sKi3ppRzYL03chfxYP0ctMttnN79ZrLaROGtBlzssaAWMeir64vFortzQv1kPTuHi+6JMnRts04/eH2hedo+1vQct5AFDJGd6vB8SebtRYU9X9xaVG1jqO56zYsWe+0elsZWOC2c6Id//aFphSQkb/C8stIwz1/Kpmk1f9aDk/WsG6O3FEa9D8SbnwuFTiKcsRAUMTk5GS9ibxRTpxXYvqHw2dMFgN6i8dLuRRJchKC+mYWhrHOj0UhFaMng9oR0T0A866tKUoVQmd5et+PnPWfr4Fk+7RuvfrZsXQtrxzvEO9pGiyxCinwYGlvhVAo1KAu22o4ZlTzLO8wzPvzuT9MbqP6IanyKXf98rGVyzwJqGcViEVk90LNu6QizB2uznrd19GBhVj68542Z998KjlXkWgdvTDRNSDmo1VfjELLsXl/Yeu03sLZQ6NeW8fVCKqLmTXTbTrSdZK95zMg8bIQx1LEcQC/IBKSDCJy26HRa6HYjlErFZLtXuVzGsmXL0G63UJ4vJ9DSrrFVlGD3KJbLZdxXejXK5TKWlpbiYFkcQXjLaDJhbKPRSP7rGmEvSk6IbRd0e8GhEBzUe4TM9r4dW+1ny+xajro6Os+aJVh8TreYaRTWK1NdBH3tn7odbIPOOgCL/PS9kGDy274kV7WdFVT7rM3fwhYLYT044ml61ep6TU/RU4HiGUKtVil1zunU1JL4nKDnesKp0yd8lkrK+nW9KHclgX4UYMJbnnMTb2+aT4RVmUyZy+sLZURrcT2hCaEfLUOF23sBFYVZywB600uFQiG1yUCF0yOtuz0pXpdQsn4aqbbP2g3XbEe/cC7yA748YueEYNOwUHYUuOsxFAfO3lcGtum9AISkcOfK1BJnoQGFaFqGXTNqrUVvyWH6LWCheqqF4XdIcVllofXU+heLvVdUKFEI7dJAO3ZZcFr73vZZqH46XWf71/627bcfq+T3G1hLa6NMqh3nHQuhkDK03tYToJCwK7TRtHanu2c1tB7NZhNzc3OJNaC1Y33jJXlN8DULtG4P1F6DbVPb0G63U2cIaeRU28pvbvKOIWzvNAStJ3egxHWbxdzcXB+kVQFn/tp++5v9owzPOWqLWCiQxWL63ZZeP/IMn/T0VDqyaiPIGtBTa8wPX/WnbSSkVeurZTIPVczeSiwlzm3qqe+L/sR3TxNTSD0Nr+n42xNQ608OUw+rBbl+FvCnZ+yz7Xbs16ngcdlcocAley0UCvFUSu/gq/gtYq1WC+WonEy3KMTVctLL/oqpaR0rnO12e7evGR96RX9TIa21vmyvZdrQOPB5PWmPH758qVQqJSfUa1ssZFToqFBaD9tSRcK89JhK74A4rR+AvhcEMx/18+2qJB17iyQU0vYg8X4gnHaQeF3hrWfZ9HlgcLTQCqDmoWQtopePN0cWM1HPR0wzUZQIJS8phCMTlZrpJXPWz9QyNf9CAX0MBfSOr6SfaYVMrYwdDw/Kah/ZQIg9oZ2WS8+DpTJVxUshpEX3hNOOtzeOOj7sA119pXPNHrz3xl//W+Vt+2KhNNbCaSfCdfuTQkKFmdYfINlAjZYD9CKeNjJpGdbmrWnJQGQ+Ml2z2USp1FssoIGOmDHiN1hTmOfm4s3OlUoZy5YtR6fTxrc7r8V0exrdbhentTclfaKbqFn33mnrcT/x1D3WJYoi7Ny5E7/4xXPJ+zx114me3M6DqyzMswKqSoEn3asQEt5RIAllowhot3tCwe1yGjmlIgltX+OYeItQaO2Up7rdLmZnZ/vqrXO72lYdZ4vOPFeGZSnU9nhqEI21cKrg8UQAhVyaVjWptbJe3iHtr4OcpTktnOGz+gIb5sO9nZ1Oz1LE92JIWy73VvrMz7d2w9d4cCcnJ9Fut1GrzSRraqNWlCrHwrPY2qZfgcD8yXxzcw3MzOxKznKltVCLaSOgFsrafuZH10NTOIvFYvK2tZ7gV3bXpSc0ukJJo8cU2JBCCClSb9xYjidYHjqwAqn5evxlkcxCLejYCifJgy2ALyheGv1YP0I7394bBIWtJrVl2nJ6Uyc9WBZbk7is9M4NACjs/vTmG3kcykRhIvWiWgq7vlm6VErvfAF6ey47nU5qXpMW0/OPaOG1nd63wlOdNlBBVV877pN2EuxpNBqJH2zfKUprrEpYx8EKgDcGdmztmNuxDblEIWFUF8DWTQ1NrGzafXl4NPbCqcRG2ggi71mB8yaO1Z/wYItO1XgMqWktU+h8GOvW7XaT1ydUKpXUW77q9fpuLd5GszkvjBND0kIhjloXCkC9PpG087Hu+YlAadkU1FKpjHqlinI5vYCg0Whg585daLVaeO65X2B6ejoRUIXEdB8UJnJ5IQNM2i8AkrOULJSdmJjA5ORkMu9aLsdR2ZhJm2i1Wti+fXsCrZvNZuplQlQSExMTyeIN3QSu0NVCSI6BFWrlD8tfWXyg6UjMp1arJZBd+VBfb8izmTqd+aH4fdEIp4WgIa1nO85azpCVDT2v395g2TI85uDgtNudxC8FelFXPeWgF0BJagQAyQuR4iqwDUD8GsEosaxxnsU+wSSj8OW0fMuYnrVLC8VpDe0Tz9pYiOdZSuZXKpVTlpjQkmt5Z2dnEytKyE5mLxR6U0xEGIpGgF5U1KtXaD7WkhVATyGHnqdyUj5TlEQeiKdiFvkBX3YgrQb0Vol4voEHZb0QuBUstcBePl6ASZ/X+Tfe63Y7aDSaAJAETcjUvTLjc20BVSpkPm+44vW5pVI6CKVBjkajgUKhgF27ZjA9vSP1ujrWkc9xkTyQXpIW8vX0v+1jwvXe3tPetAcPtNaVSQqvNdKr+3nZdxqt1vFQYWRZIXdI66v/9dsq29CY82NXNKk1p5Au+mNK6vUagN67PnSDsZ4CYCGr+kgkHSyN7NpOVf+A90l63dPQQFp7kymVadrtNnbu3InZ2VksXboUS5YsQbVaTeYv48Hrgq+fL5XoxxRQLqfP4onLiyEwD6YmrOwxQTc5k6jT6eDZZ5/FT3/6094rHnZbofiN2xOJteJJfDMzM0la7UMKsu0/7SedsuFUiM6lzs7OJgqCQso+ZAS6Vqsllpe/2afkC2vN1SpbQVMB14ivhbw2CGTJE3QqWeWlno/Zew9oXNYit5zFYglR1H/eqUccIPUTlEJQNuQ7emksJA7Vw/ocdi6OL8CdnJxIBV3iYqIEtkYR64Tdn2KSzgoFP2RqPYKj04kPmKaQzszMoNlspnw0XRDvwccsXz40VcDyVYgIYQmvKZyqKGwwyn6zDB1zFSwgvGpLeUSFehB/eLwUGnsdDyvkVnENorEVzjhY0lv9z2+S3f3hdagHV7z7nqW0/z1f0pJeUyZNv1ksvtdszmPXrl2JZZqcnNy9CD5eiB5FSDFtbDl04Xsc1WX0s1zuQVPV2I1GA7t29Q6M1veskOjrUbDJ8LOzs8myOY2c6tI7XYWk/ivryeAOgATK2qkRjqcyNwWbeTYaDRcV0EKqUFlLzz63ytPyjx1vvWcFmL8tfNd8Qgs5ut1FPs+5ZMkSdDpICaeeLEDnG+ifZ1Oyms4Kpw6o57vqcxa62fy9CXpOX0RRlMDSUqmEmZldiOcyy5iaWoLly5ejWIxPfN+xg8GjVnJaPNeCUrCbzabUq4ByuffG5TgyGAdWdu3aiWeffRbNZjMFU1W59V7Gm16lQ7ip/VQulzExMZHATB6pyfXDunqH/cqFD81mMyXs6qZQIHVRhS7qoJBr3oTKHqLxYgWhNPa3xwN2XDneTEOFo1NGURQlfrMqlUXvczJiadeQeqtDSBZCZKXzrCrvDfNc6FtJBVT9YgpQbK3amJycSAIfsQDHcFbP7gV6EC6KuruDK8wzHYjQCDEn9SloutjApgfSb+jqneSQtiScS+XxJxwjfTGtZ23U0jGN5mshsg0CWiumdbXj5C0kCUFWyzP2nrW0Xr46PafPhoR8GBpj4Syl5u6omaIoShhOfRHrbyq2H+Rf2A7MCgaQrO9CwSNZWOv5OWT+mZmZxGK0Wi1UKmWUSnEgKG5bHPihtWk0mpidnUUczInhLiFxoVDA3FwDO3fuxPx8E7t27UoWHHiCBqSDZGr5yHA2SKMrfTTgRYunK44UEqsVtn6r3VFkrZTtV6bjWFgKKV8dX1UC1rWxaVRIbVoqHroGvd0nvaNr1PcexFuksRXOeLmebqlqJJBMI3s6+asaUzfNqmB48ATw107yeUvKDFboLWMR1mo0GOidqE6hbjbnUSoVUa/XMTExsZvZuXuit1Vpfn4es7MzmJ6eRqlUwtQUUCzWd9+LT1aYnZ3Fc8/9Igm67Nq1K7X8zjKefeOzZf5YCVRRrVaTd3zyde/8EJKynmRGLq7XfqIgexsBPCtkA4Jq4bwlcvZZa6H1OS3L5sdx1qCT+pXKQ0QlOvXDPLiyy/bzIBruvIQAXXnllSgUCrjkkkuSa41GAxs2bMBBBx2EqakprF+/Htu2bVtQ/upQW83FwbeQRjV5yA8NkdWUoTTeM156ZXKPwdSyzs83d1u33ml9pRKRQSnVfh3oON/eez8VztIya7DCI+1TC0lZF10eaPeTZuWZlbc3RlZx2jG3ghuydNr/IfIQk83LW2Vmx9q6BxqP8OD6sLRgy/ntb38bX/jCF/Dyl788df39738//vEf/xE333wzli9fjosuugjnn38+vvWtb41chtWUdukY0As46MS1PgP0mMv6Wkpex2V1ZghuWeajMGl0UaEcB47Bjxj+ze9GBXXU67UkfWyVuql8Z2dnE8s8M1PeDWvnkikTfb27tslGEQnDPOEhnK3X66kFCjo1QljX7XYTa6m+rIdMVHlZ4bTjoG6LdUWsFbP198ZTlYeuCSZ8t7DX7nzS5z0ir2nZLKNQ2ItTKbt27cIFF1yAL37xi/j4xz+eXN+xYwe+9KUv4cYbb8SrX/1qAMD111+PY445Bg888ABOPfXUkcuyzGIdffXn7LIzHTwLnbxymNY+Z5/xBiXLR1ImoHDqq+Z1aoHrL0ulEg4++GAsXTqVYhYbIZyZmekrc35+HjMzM32R1pBFUKbTOVJ+GJWdnJxMhIQrezgdpMKpllrrZq2QFTbPT1RlEhJa7WdLIeus37rUkIsxVJCpfCxUtvW1Vl7LZxu4qGQYWhCs3bBhA84991ycffbZqeubN29Gq9VKXT/66KOxZs0a3H///W5ezWYT09PTqQ8py0fU+1kBhGFpEOQYFZIo2TraiB7TKMxVH9F+rFZnenuigSoRy6De7xBkt/8tvLYboUPw1etHKyj2tz6zkDHIcjms0lf0Zb8HwdpQmyyCGwXejmw5b7rpJjzyyCP49re/3Xdv69atqFarWLFiRer6ypUrsXXrVje/jRs34vLLL++7HmvgKFkIrQxn19WysepwK2yzZDsvy7J6Wp1l2/z0f5bP5QmFN/iNRgM7dkynLE6nE8/7LVmyJLXTgb91x4b2A61u1vREloDwPpUA60dYrdBPGXoYhemVZZnYW5bpKQ+bxuZvy2JddTO47h1mft5CGM1PFaHOJujZSPy/VxYhPPnkk3jf+96HO++8M3lBz/Olyy67DJdeemnyf3p6GqtXr95tEaLEb9KtQoRaVqMq9GDwAoAbvKDmZ6epcHpTMEpWMEOamQNmJ+Y9Dap+FesSo4odJn08rTI1NZUEfAhfuQKn59v0ooWFQiE1ae/5aPxtFYj2F31KwljCZ01L2G77T+GeLdfrP7XUIYtjFaonmHZclSicnLdV4bRTTFw9FYLIrKvGFTxXYq+8ZWzz5s14+umncfzxxyfXOp0O7rnnHvzFX/wF7rjjDszPz2P79u0p67lt2zasWrXKzZNTIZZUIw2CrdpBtAbqNw0DebVzB2n8YaCzN2hZ8NH7b7U378XR2/7DrLQ8S4PgpNdeZSqPPKjsfWs5IcpCJsNSSJkOKptt1LlW60p4LoYtU8faQyU20DSIRhLOs846C48++mjq2tvf/nYcffTR+OAHP4jVq1ejUqlg06ZNWL9+PQBgy5YteOKJJ7Bu3bpRitrdMH/KxGoiID0dAPR8MUIJGznrlZEOhmi+OjC2bqEO1mfsXkNqZ12bqnNoTKvowM7H7S7FZRROd9i+Ucay7QMAG/5nG7kjRE+noyXWd7R4q35CCiIkQLb/svo4ZH2z/EFbJgWF1pKbw5m/faETf2tUnQKn9WZ/Mh893Iz9F0V74cT3pUuX4thjj01dW7JkCQ466KDk+jve8Q5ceumlOPDAA7Fs2TJcfPHFWLdu3YIjtYMif0xnBYLEAfNefc7/KoDKhN4Caj4zzBwfYZA9kjH08iEtn7+VYdIaOq3VNb1to2pxz5rZftM+oyCqn0/IykUUHCO6Fep/WjTCPLR823eeQLFONtikeYYstuUdpqWvyZMbSGwL4x3cnK6xA298vGiurmNmv+0VyzkMfeYzn0GxWMT69evRbDZxzjnn4JprrllQXhY2efDVCpoHM2xom/e8QSNZS2LTWcbKsgbWkmWl628732ZdRqHQEyBlFK999vcgSGbLDS0AySJbhn3GKyskjIMoBCe9ttv/Hl/ZDxWOjT4PW8dQH7ygwnnXXXel/tfrdVx99dW4+uqrn1e+MWP0DvnVXfm6RtQulWJ61d5cLZNVFoNGCs3UKlkms1paoaW18LqoXfO1q11IvbbwvZqFxMfsdjuYnZ1Ds9lIdoLMzs4mTKArpLS+LEeDajpHqFCaboCeik6oZ5GFrlbShfV6cry2K2TdsoJltv+9uU2rdNI+uv92bo4Fd81ovRXK2hVWWUpcf+s4e/O0g2hs19ZSOEulUsoyUKupX6KQS1e6sPOtT2V9L93iE4J+WYOv5DEXJ7gVsrJNFvbp87G/XE4EtVwuodVqJ69O0DeEsR2e0vCEU9Na4eTGa4WzymTqy6qAKqy1wsn22H24tm81f09AtW9VoO2cbmgZp2c1WVdVMISz3pytjmMImvPbIptRaGyFExgceAHSTM5nvLSekGX5Nh7kC9XDQixlGp3YtitPPG2rbY6PKentutHgkIVcWn+bt5JdBqf1pIBrIErbxL6zc5jeJ9SHVvnZNtu0XrssRPVgbVbett/pb3t9OggeZ9XVljmqoI6tcMZMmfYrLYbX6wofyWzqP6j1sJbKWlAynw6Sbg62dbB+ioWI9Xo9iQYq03s7FLQelUoV9XoteSb+bicLDhiwYODJ1sfma9ceaxtoJev1OqampgCkD/gixNP5ZbsySJf+2WkJ/W0td8gf99pg//NjGd66HtZNIdndQRa+eujCE1A7m+DNm/ei2ov8aMxB2lQ7yq4c4vM6TWHhne14hZLqf+rzVrAtqQADPV+2dzxk//tObFuttWWET9vFrVi6airLOigTE/Yr1NfdJpxaYHsVthLmEfZqZFa/FSWE/EJPAOz42jaErK5NY++H8vfqxDG2q5y0LA+laTq7qEWVNwB0u4v8UOnY1yy4G1WtJqYvpBbE83dC2g/oh8dA+s3K+rE7FGx5fFatoIWbdh5UV5PwyBGdFqE/p2+ftr63ktdPltRyEXVwHta2U+vnCU7In9NyQv+9Og0iK3BWwYWesUGwrDxCBsKS1y7PzdEFMsPQ2ApnrJ2j5IwaAElUTTWcNpyOvMI0nWe0k/FAr/MYCNAXuTI4AiDZlsU89DhLzYdal5aS+emRmUBvyxUnqjUIMzW1BKVSOYG0URSh0Yjfo9loxKcbzM7OJuV5VgroCWgIPpMqlQomJiZQqVSwZMkSLFmyJOUq6N5QhX9Uimy/KhMLK4F+f9eLdKpQeArQKgFFQaFn1H1hHbx5Sa2rheZeXfW/CrLyIctW1LTohbNc7k3cAj3hoIUk2UHmYCksUa3vbdDWPBgdZlk6/aGMrpZU/5M0COStOCI05TM9X7mESqWKSiU99cJDuxqNudQ7TqzG96yRZX4lMo6eCVSr1RC/MzR92qG36oh5eJbGwlB7zyoSzWtQGzyYay17yG2x9z14apFCFjS2z7J/VCnptUUvnPHhyj5jZUENdqTCRtWUIeZlh9ntWkDcubqoXn03FUoN3HCOkMzQO7Wg90JY/ufcbH8f9KKI8XawZgrSsu789pjGWh3tS91knJ42SUdn2Sa2x/rkoT610Npatyz/0ctPlZuX1rokes0qA7uwwLOI3nXm6bVP73tuwH4jnDHzpv0bq509/wfowQrb+epH2Tw02kj/tlwup3Z5cMBpaVgWNS1fZUBYS39ZX+eusJgBFhV0oCdMnMdstzvYtWtn8uIhRmm1T4De8Z5ajueLKcQrFoupt0zH6KLdx5zc2aJ9Yc8lYr1JViEA/S8V9ixrSNi1XZqX1z7veQ3YhWCqLS/Lf7W8qfVSa8l0PR5Y5AGhWCv7wQd+e9pOYZfm5VkYC1VC/ooKmwZ61EprpFN9TkY5qRSUOXQrmZ3sZhpacvp9FHS2z06h9PquJzTeVIVaQDuFZIXApk9P7WQHTEJW0o5liOw42z7ScfDgqdbBKpyQYHrlDmqnprNw2Fr9KFrkljNuWNFlCk9rhfKw5GlavWchru1gWlQ98Y8fG/jRxeCsiy5419U6ugyx2+2g3Y52vwmsiXY7Pq1dz561dfcYztZP09gVNHZJnAq2rbf24SAGt/08CIZ77cqyYBYFaf20LSocti72OdtXIfiadc9r/34mnL3XLqi/Y/2hEIxR8hjFDgTg79AAsPs82dgaLl++HEuXLk1BWcIWCiWX2OmqEI3K6ukBDMIwANRqxUK7c+dO7Ny5M/UCJIXdobay3to/tPBqcfWeLlDQ9hOaUyEooyvTeYyufcy+tYEka82yFGdonKngtC3W17MIxebrPetF9z3yrDZjDVYw49+L/MR3ktdxoXQezOU9/dZn9NvT6rYe/N17rXrsr1EbEroSkgJpiK1IQNtkmZjCrse0qB+d1V5b30FpbFoVarWgLNubmhmWLETlt62Xh4oGWWs7Rp4V9oIxIQQVqrdXpxCF4O0wNLbCGcPYnj/BMD9hlr7PEQhbSruA20ujpEd5WD+Q1/RokEolvTRQ12aSQRgk4t5BTgd5TBhFQLfbQRT14Kd+QnODg7Q779tNxqyTLsz3Isq6CFz7wk6HDCNAXt9nCWPotzc2bKO1XF4+g657SsNLY9vlKTvAP7Uvi8ZcOIupw5Z0CoFL16w20s6iQNTr9WQxAe+FiIdX6XpR5qu+KAU4VhpddDq94A2foYXlBL9aSlpVrVPMUBTwNGy3HwvplWEtI7NP1GrzZHmeScv+0TY0Go3U+U2hkyK0/tpXXh3tFIetY+iep3wtxObHCqdnCbUcT6DYjpDSzyK20/q3PeFc5D4n0D9I9sAubbD3rMJhu50qpL3s9jG74EE/PSvWe97zabyAVojifLOXx3ltHWR5+N9aYm95obaP1pOKylMGWnYIEobqzfuh+noUuh4qZxjBHJR3Vj1DFLLwi95yxqt00pqRARO+iVnPd+EzFgaXSiVMTEwkpwVqh9mFBUrMu1BIv08jyx8lhCbcU6XAfFg20FsVxCAXITGXBuoukEqlklgvno1k0YIyjwfjuUNG+0TnLAEkR3JEUZSaAlJIrH2o0FatKtPolJH1r0NwfBDEtMKk/a9jS+XqLc8Ljd8witATOs3b8opFDnvlDKEXkrwGql9EZufRjMr4jKJOTk6iXC5jcnIyEU4+z4gq10AqJOJr18mkFBh7ZAUp7vS0cLIMu3xPp1bs4Vk2kKT+skaC9dV8bLN+q4XUemqf6AuTdMqn0Whgbm4uVVdFH1qOKhQtU+ulp1AsxHqqFbcWWn9bhaAuiIXYnnK1Abosa2/rHKqvV0Z8fzjLO7bCSQp1pC49s76OprNwUq2YN7AqpFmBBY+shtRrOmgeFNelXXa6Q/O0FmgQpNd6s02qMCxDh+o3bPuzIKeXfhSoqOPg+db67cUhPAHNgrchQc5ql94Pw+lFLpwxs3b7gj5RFCWwjIxKSzc7O5u8nlwZnZYBSAuJ1fo6UBxIKxDWP4u/0xPdhN4MCuhUiEJFtfY6j0hIDPTOUIqna6KU79fv+/YCPxohpjDyFX58Vi0ko8+EzMzHEtvHPlGk4DGm9qH2v7XqISjrXfPy5kIOIP3aee0bT5jT/NYfk8hSOLaOWoYajFBbBtHYCqcVICVO5lMIJicnk72cdlkbGZo+iPcOEtuh6oMo5PQCOj0m6FlFRkArlWry/hLuJGk0Gn2LCBRaa5kKJdleCraeraQMyHsUTkJY/uaaYJ49xGkSQk9vDlZ9NxLrT+H3lATTqSCqIIcEwLN43m9rLfUECzvGlkLw1LOyIfKss5fvQgQTWATCaefWLCkzK6PYPOwqEQB9Gl872AquV78ew0UAvAGIr1vI6E1J2PZZSGXhrbcgQ62StZq2LK2Lx8CDLJntK6/OWZTVv1n5ZPl7z4eeryDtjfzGVjg7nRiGWksHpKOyCq1qtVrqjcvcA0qLSbICofmR1BJ4EMh+gF5EE0BijWgtuS6WLxvS9bnMU8tlEIr19gJJGqjiswASa2mjq1xtpNbSWgqFyt68pe1/z2dTobcUsoAhZeApDVuujotaUU/ZahrN09bP/raoIUu5WINiLf2wNMbCGa+S0VUqFqboSQP0qcgYXNtKmGNPSADSc3reAFk4HbLI3W5v0YEqAwpBo9FIwdp2u52a+Pfgkc4t8j/ro693Z7n6zakmCjDr0mq1sGvXrr4FFuqvWSVIV0H7yipHKzAhBte+toIXCrR4QmxRAEmDfOovM23oLF2tk5atysaD9CGraPlGn9kvAkKeZbPfnKqwHac+E4mMZn0jT6tZxghpPntfv+2hV3YqwJYfqodOy1g47jGH93zWB/BfTEuG9RhN74dImT4EXe3vrIBNqAyvXipso+SzkPJHgfH7keXsAugtG7PQyhv0KOrtTmAARRlUrYUVXptPXIdeIEm1sv5vtVp9q4/0dDzWX60efUFPyDQg0+12k3OT+No9AMlhXKoEVODb7fjgaQ3mAEjyUMUBILGOHnxXKxdSRrbfSGrFQkooy9KFmNmD0uyvLEWgFt772PK9+obyHkZIe/23yJfvsRFqeRROaYQT6B9krmUltGTH6IoXPYPVYzgVToVxQI9x9dxT3meZ9qWy9Em9c3FJavUJRTU/PmetvyIGe0Qny7CnsqslVuUTspbpsel3BawlCTG/1imUxgt4KQ2Tr6bVZ7xybT7aD6F6jGI10/+Hemx8hRMIDxwtF/0u776Fk/ZjGcn7Pay1sPBQy/aO0eRvrYPHZFp3FSC1erY9HhpQIbTt0TxsfpZCz6l1tf0XIjtt5fWP9sswMFWfCf323Bctx7s3rBDavDw3ZpT8xlY4405FCjIqQ3oCYKdMlLE9AVU/lPnqNy2QFWr1eXUNrlpnBqQGMawOnIXM2h5aPRVC7QcGxKxwqtBk7eRRy6llaLs8X91G0u39LEvq7VCxdbN18qycLdOzwiFFay2sog/bZjtmdhxDCmVU4SaNrXAC/QcleYyiEIwMDPhC4DGQx0gW7mk6HWgOIgdDlYWuKbVMzvpomXqfH/W31W9VQSbs1eWMtv2qNGyY37N6noXy0thx8frdEgXHLrv0PtpPdvwsWSGw8FUVkNbTCrRdeGHzzrLgVtC9+o4irGMrnHEHINhZ3ryTZT69b//rdikdOGXYLC3tCbB+q3/s1cGrj7ZFywlZJisstKC2X7QOqlxC/R6yLLY/PZgYskZ63Y5fyBKH6jnomuavwmmfs3XSOuuY2HEYpCgs9Qv0Ip9Kia1BIbVJGUDKKtkOt68oINklafwQBtJKWQsF+D4P01uloYEWhZshv1nr5518pwEpfdZaUX7r1iwGu5T5dC5TIbuStTB63RN2K3As30JY7R8rPLZsT0GEBFvHSdNYy2uve/1mTyFU3uAmfLZj0JhmW9pFLpxsnB5gTMhmFyYwvS5wB/yAklpN+5oGjWDq80oqkMVivA9S15Zay+kxiebDgesd6JxeKaTTHWrl7QIEj2k9mGXnerP8N89CZKEKtXba396ij1C+HlKw7fHu2w0JnoINkUUdFt5al4rPWIUQIk0zqC5KYyucdmuT+ii2gdYXI1lNFhJWhTHe6hOmtdbXwlF9zpZl4a1Np2Uxbz0JXp9TmGjrr31lF+pb5s2C3B7TsUxvZ44HX7Usm5eOmzK+tThKHmy29wddHwRJtW803qHTX54vOmzZu38Fy1caW+GsVHqvzVNG4AQ//2tnAen3UpCsRvdgl1o/y/zMl3XRJYBWmNUy628rKCGrqjtRePiW5/Mwb7sckXnQHVDIzNP8mI/6xRZZaH6W9DUT1sdXZrUCp2Nix43kKROmV8H0VjV5NAi9hCAzd/AoYtGzlELw2vYDf6fLWuTCqYu2lRmBfggTskKWUZRCAxWyzlbgvHSekHqKQOGSl4fmbaEylQc/9tXw9J1UMPWFSFyZpH2YBbWs5td+stZX2+b1vWVY77p3vIpN7wXPNB8LyT3hDLVZ28QxV8irVtOOt1cPS/uJcJZTp6CrMOoxmfoqPu0gQsJCoZB6cS3PFbKC4/k6ymwaZOHyOZbLb7vqhs+xfKCnWDSyrIKvwsl8oyg9raJ1UUVBDc8NAapMbH4hxgkxcAiW85pdx6zpPWuq9dHxC/W/lu0FrGydfDjpk5ZNC6nKh32uqEvRBdN4Ct/WKR7zRb58r3dAV3m38HQS6Knwguf82AG0UVkKup7Zo8/YKKISrRAVAvMD+udC7UR9sVhMneZuo87dbjeBUBZmqR/HLWcKJT1ryroSkpGUiSwUteXatntQ0/a3TeMJJfvLwnTNLxTh1vzsNIlnrW0bbB1tGubJkyAY7GO+upbZvnXAKhivbC1zGDgOjLFwqnBZSKZbnDSaSyJT8576D/boS+ubah76rfVhngD6jj9R7c5BVQSgcJILGDT45ZVJptDILeuuUy22jsP6ZVqmvWatZ4j5tO2eEAwDnT3racvKEgTNy6tjqA5WiajS81wS2z6ti/qXXn3i9MGuSNHYCueOHTtQqTRTAR52hB6xYacUSCp4+vIfnU/Uj31FnxVUe1Qm4bRCWasZmS+nW5gX82CZClO1LTrIuvFaLYgykUIu1pXptS5qOb1+I3kRXdY9xHy270N+nw30aV97QmBhpO2fwX5e+rcHgW2ZOg+sPKMGY5Ab4PfPIoe1P//5z1EsVoKwYNA8ompAe2ZP1gDZb4Wh3IZlyxtknbKesZo29GwItoV8q5BVUaGxsNf+zrJ2g6xQ6Lpac2+p4SC/7YUkLjRRsv3Ga1l9ZWnRW85Wax6FwvMblFEx/qC89hWT7CvKau/z6Yssv2yY9C8UhcZ81Pr303Dphzt6OqeccnrBKRfOnHIaU8qFM6ecxpRy4cwppzGlkYXzpz/9Kd761rfioIMOwsTEBF72spfh4YcfTu5HUYSPfOQjOPTQQzExMYGzzz4bP/jBD/ZopXPK6cVAIwnnc889h9NOOw2VSgW33XYbHn/8cXz605/GAQcckKT55Cc/ic9+9rO49tpr8eCDD2LJkiU455xz0Gg09njlc8ppf6ZCNEJM/EMf+hC+9a1v4d5773XvR1GEww47DB/4wAfwR3/0RwDixQQrV67EDTfcgN/5nd8ZWMb09DSWL1+OAw54PQqFyrBVyymnRUNR1MJzz30dO3bswLJly4LpRrKc//AP/4ATTzwRb37zm3HIIYfguOOOwxe/+MXk/o9//GNs3boVZ599dnJt+fLlOOWUU3D//fe7eTabTUxPT6c+OeWU04jC+aMf/Qif//zncdRRR+GOO+7Ae97zHrz3ve/Fl7/8ZQDA1q1bAQArV65MPbdy5crknqWNGzdi+fLlyWf16tULaUdOOe13NJJwdrtdHH/88bjiiitw3HHH4V3vehfe+c534tprr11wBS677DLs2LEj+Tz55JMLziunnPYnGkk4Dz30ULz0pS9NXTvmmGPwxBNPAABWrVoFANi2bVsqzbZt25J7lmq1GpYtW5b65JRTTiMK52mnnYYtW7akrv3rv/4rjjjiCADA2rVrsWrVKmzatCm5Pz09jQcffBDr1q3bA9XNKacXD4208P39738/XvnKV+KKK67Ab/3Wb+Ghhx7Cddddh+uuuw5AvAD4kksuwcc//nEcddRRWLt2LT784Q/jsMMOw3nnnbc36p9TTvstjSScJ510Em655RZcdtll+NjHPoa1a9fiqquuwgUXXJCk+ZM/+RPMzMzgXe96F7Zv345XvepVuP3221Gv1/d45XPKaX+mkeY5XwjK5zlz2t9pr8xz5pRTTi8c5cKZU05jSmN3EkLv9ILWPq5JTjntHSJvD/Iox044d+7cCQDYvv2OfVyTnHLau7Rz504sX748eH/sAkLdbhdPPfUUoijCmjVr8OSTT+63CxOmp6exevXq/bqNwIujnaO0MYoi7Ny5E4cddljfYWFKY2c5i8UiDj/88GQB/Ith1dCLoY3Ai6Odw7Yxy2KS8oBQTjmNKeXCmVNOY0pjK5y1Wg0f/ehHUavV9nVV9hq9GNoIvDjauTfaOHYBoZxyyimmsbWcOeX0YqdcOHPKaUwpF86cchpTyoUzp5zGlHLhzCmnMaWxFM6rr74aRx55JOr1Ok455RQ89NBD+7pKz4s2btyIk046CUuXLsUhhxyC8847r++4l0ajgQ0bNuCggw7C1NQU1q9f33cW02KiK6+8MjkZg7S/tPEFe+tBNGZ00003RdVqNfqrv/qr6Pvf/370zne+M1qxYkW0bdu2fV21BdM555wTXX/99dFjjz0Wfec734le97rXRWvWrIl27dqVpHn3u98drV69Otq0aVP08MMPR6eeemr0yle+ch/WeuH00EMPRUceeWT08pe/PHrf+96XXN8f2viLX/wiOuKII6ILL7wwevDBB6Mf/ehH0R133BH98Ic/TNJceeWV0fLly6O///u/j7773e9Gb3jDG6K1a9dGc3NzI5U1dsJ58sknRxs2bEj+dzqd6LDDDos2bty4D2u1Z+npp5+OAER33313FEVRtH379qhSqUQ333xzkuaf//mfIwDR/fffv6+quSDauXNndNRRR0V33nlndOaZZybCub+08YMf/GD0qle9Kni/2+1Gq1atij71qU8l17Zv3x7VarXor//6r0cqa6xg7fz8PDZv3pw6Mb5YLOLss88Onhi/GGnHjh0AgAMPPBAAsHnzZrRarVS7jz76aKxZs2bRtXvDhg0499xzU20B9p827o23HoRorITzmWeeQafTGenE+MVG3W4Xl1xyCU477TQce+yxAOKT8qvVKlasWJFKu9jafdNNN+GRRx7Bxo0b++7tL23cG289CNHYbRnb32nDhg147LHHcN999+3rquxRevLJJ/G+970Pd95553590mK328WJJ56IK664AgBw3HHH4bHHHsO1116Lt73tbXu0rLGynAcffDBKpdJIJ8YvJrrooovw9a9/Hd/85jdx+OGHJ9dXrVqF+fl5bN++PZV+MbV78+bNePrpp3H88cejXC6jXC7j7rvvxmc/+1mUy2WsXLly0bcR2DtvPQjRWAlntVrFCSeckDoxvtvtYtOmTYv6xPgoinDRRRfhlltuwTe+8Q2sXbs2df+EE05ApVJJtXvLli144oknFk27zzrrLDz66KP4zne+k3xOPPFEXHDBBcnvxd5G4AV+68FCo1Z7i2666aaoVqtFN9xwQ/T4449H73rXu6IVK1ZEW7du3ddVWzC95z3viZYvXx7ddddd0c9+9rPkMzs7m6R597vfHa1Zsyb6xje+ET388MPRunXronXr1u3DWj9/0mhtFO0fbXzooYeicrkcfeITn4h+8IMfRF/96lejycnJ6Ctf+UqS5sorr4xWrFgRfe1rX4u+973vRW984xv3j6mUKIqiz33uc9GaNWuiarUanXzyydEDDzywr6v0vAiA+7n++uuTNHNzc9Ef/uEfRgcccEA0OTkZvelNb4p+9rOf7btK7wGywrm/tPHWW2+Njj322KhWq0VHH310dN1116Xud7vd6MMf/nC0cuXKqFarRWeddVa0ZcuWkcvJ93PmlNOY0lj5nDnllFOPcuHMKacxpVw4c8ppTCkXzpxyGlPKhTOnnMaUcuHMKacxpVw4c8ppTCkXzpxyGlPKhTOnnMaUcuHMKacxpVw4c8ppTOn/D0b4xeqRXBo0AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " AsDiscreted(keys='label', to_onehot=None, threshold=0.5),\n", + " # Randomly crop samples of a specified size around the label (spinal cord)\n", + " # Note that it seems that the transform randomly selects a foreground point from image, then use it as\n", + " # center crop. This means that it can find the closest voxel that is just outside the SC and use it as the\n", + " # center (hence it includes the SC)\n", + " # https://github.com/Project-MONAI/MONAI/issues/452#issuecomment-636065502\n", + " RandCropByPosNegLabeld(\n", + " keys=keys,\n", + " label_key=\"label\",\n", + " spatial_size=roi_size,\n", + " pos=2,\n", + " neg=1,\n", + " num_samples=2,\n", + " image_key=\"image\",\n", + " image_threshold=0,\n", + " )\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=roi_size[2]//3 # // int division\n", + "index=2\n", + "#batch_to_plot = first(check_loader)\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "ax1.imshow(batch_to_plot[\"label\"][0][0][:,:,slice], alpha=0.5, cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "print(np.unique(batch_to_plot[\"label\"][0][0][:,:,slice]))\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax2=plt.subplot(2,3,4)\n", + "ax2.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "ax2.imshow(batch_to_plot[\"label\"][1][0][:,:,slice], alpha=0.5,cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "print(np.unique(batch_to_plot[\"label\"][1][0][:,:,slice]))\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "48b67e7b-d402-4d6b-a10f-abf827d88c3a", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 64, 64)` around the label, create copies for augmentation, debug RandCoarseDropoutd" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "51db1e0d-b803-4108-9e59-82951fb7966a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 64, 64]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "number_of_holes=5\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " AsDiscreted(keys='label', to_onehot=None, threshold=0.5),\n", + " # Randomly crop samples of a specified size around the label (spinal cord)\n", + " # Note that it seems that the transform randomly selects a foreground point from image, then use it as\n", + " # center crop. This means that it can find the closest voxel that is just outside the SC and use it as the\n", + " # center (hence it includes the SC)\n", + " # https://github.com/Project-MONAI/MONAI/issues/452#issuecomment-636065502\n", + " RandCropByPosNegLabeld(\n", + " keys=keys,\n", + " label_key=\"label\",\n", + " spatial_size=roi_size,\n", + " pos=2,\n", + " neg=1,\n", + " num_samples=2,\n", + " image_key=\"image\",\n", + " image_threshold=0,\n", + " ),\n", + " # Create copies of items in the dictionary under new keys, allowing for the same image to be manipulated\n", + " # differently in subsequent transformations\n", + " CopyItemsd(keys=[\"image\"], times=4, names=[\"gt_image\", \"image_2\", \"image_3\", \"image_4\"], allow_missing_keys=False),\n", + " \n", + " # Randomly drop regions of the image\n", + " RandCoarseDropoutd(\n", + " keys=[\"image\"], \n", + " prob=1.0, \n", + " holes=number_of_holes, \n", + " spatial_size=roi_size[0]//2,\n", + " dropout_holes=True, # if True, dropout the regions of holes and fill value specified by 'fill_value'\n", + " fill_value=None, # if None, will compute the min and max value of input image then randomly select value to fill\n", + " ),\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_2\"], \n", + " prob=1.0, \n", + " holes=number_of_holes, \n", + " spatial_size=roi_size[0]//2,\n", + " dropout_holes=False, # if False, keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " fill_value=None, # if None, will compute the min and max value of input image then randomly select value to fill\n", + " ),\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_3\"], \n", + " prob=1.0, \n", + " holes=number_of_holes, \n", + " spatial_size=roi_size[0]//2,\n", + " dropout_holes=True, # if True, dropout the regions of holes and fill value specified by 'fill_value'\n", + " fill_value=0, # if providing a number, will use it as constant value to fill all the regions\n", + " ),\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_4\"], \n", + " prob=1.0, \n", + " holes=number_of_holes, \n", + " spatial_size=roi_size[0]//2,\n", + " dropout_holes=False, # if False, keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " fill_value=0, # if providing a number, will use it as constant value to fill all the regions\n", + " )\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=roi_size[2]//3 # // int division\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "# Note: 'gt_image' is added by 'CopyItemsd'\n", + "ax1=plt.subplot(2,5,1)\n", + "ax1.set_title('Original Views', fontsize=7)\n", + "ax1.imshow(batch_to_plot[\"gt_image\"][0][0][:,:,slice], cmap='gray')\n", + "#ax1.imshow(batch_to_plot[\"label\"][0][0][:,:,slice], alpha=0.5, cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "#print(np.unique(batch_to_plot[\"label\"][0][0][:,:,slice]))\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax6=plt.subplot(2,5,6)\n", + "ax6.imshow(batch_to_plot[\"gt_image\"][1][0][:,:,slice], cmap='gray')\n", + "#ax4.imshow(batch_to_plot[\"label\"][1][0][:,:,slice], alpha=0.5,cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "#print(np.unique(batch_to_plot[\"label\"][1][0][:,:,slice]))\n", + "\n", + "\n", + "ax2=plt.subplot(2,5,2)\n", + "ax2.set_title('RandCoarseDropoutd\\ndropout_holes=True\\nfill_value=None', fontsize=7)\n", + "ax2.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax7=plt.subplot(2,5,7)\n", + "ax7.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "ax3=plt.subplot(2,5,3)\n", + "ax3.set_title('RandCoarseDropoutd\\ndropout_holes=False\\nfill_value=None', fontsize=7)\n", + "ax3.imshow(batch_to_plot[\"image_2\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax8=plt.subplot(2,5,8)\n", + "ax8.imshow(batch_to_plot[\"image_2\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "ax4=plt.subplot(2,5,4)\n", + "ax4.set_title('RandCoarseDropoutd\\ndropout_holes=True\\nfill_value=0', fontsize=7)\n", + "ax4.imshow(batch_to_plot[\"image_3\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax9=plt.subplot(2,5,9)\n", + "ax9.imshow(batch_to_plot[\"image_3\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "ax4=plt.subplot(2,5,5)\n", + "ax4.set_title('RandCoarseDropoutd\\ndropout_holes=False\\nfill_value=0', fontsize=7)\n", + "ax4.imshow(batch_to_plot[\"image_4\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandCropByPosNegLabeld(num_samples=2)'\n", + "ax10=plt.subplot(2,5,10)\n", + "ax10.imshow(batch_to_plot[\"image_4\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "vscode": { + "interpreter": { + "hash": "da3e08083059755bb70e9f8b58ba677201225f59652efa5b6b39528ae9381865" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/vit_unetr_ssl/ssl_debug_transforms.ipynb b/vit_unetr_ssl/ssl_debug_transforms.ipynb new file mode 100644 index 0000000..fa143f2 --- /dev/null +++ b/vit_unetr_ssl/ssl_debug_transforms.ipynb @@ -0,0 +1,666 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ceab8707", + "metadata": {}, + "source": [ + "Copyright (c) MONAI Consortium \n", + "Licensed under the Apache License, Version 2.0 (the \"License\"); \n", + "you may not use this file except in compliance with the License. \n", + "You may obtain a copy of the License at \n", + "    http://www.apache.org/licenses/LICENSE-2.0 \n", + "Unless required by applicable law or agreed to in writing, software \n", + "distributed under the License is distributed on an \"AS IS\" BASIS, \n", + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \n", + "See the License for the specific language governing permissions and \n", + "limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "b68c35c3", + "metadata": {}, + "source": [ + "# Self-Supervised Pre-training - step-by-step augmentation\n", + "\n", + "ℹ️ This notebook is based on [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl) and provides step-by-step visualisation of data augmentation necessary for the Self-Supervised Pre-training.\n", + "\n", + "First, it uses augmentation (top row) to mutate the data and second, it utilizes regularized contrastive loss [3] to learn feature representations of the unlabeled data. The multiple augmentations are applied on a randomly selected 3D foreground patch from a 3D volume. Two augmented views of the same 3D patch are generated for the contrastive loss as it functions by drawing the two augmented views closer to each other if the views are generated from the same patch, if not then it tries to maximize the disagreement.\n", + "\n", + "The augmentations mutate the 3D patch in various ways, the primary task of the network is to reconstruct the original image. The different augmentations used are classical techniques such as in-painting [1], out-painting [1] and noise augmentation to the image by local pixel shuffling [2]. The secondary task of the network is to simultaneously reconstruct the two augmented views as similar to each other as possible via regularized contrastive loss [3] as its objective is to maximize the agreement.\n", + "\n", + "For references, visit [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl)." + ] + }, + { + "cell_type": "markdown", + "id": "707541a2", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4dc0237b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[pillow, tqdm]\"\n", + "!python -c \"import matplotlib\" || pip install -q matplotlib\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "49070e05", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cf64bf41", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import time\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch.nn import L1Loss\n", + "from monai.utils import set_determinism, first\n", + "from monai.networks.nets import ViTAutoEnc\n", + "from monai.losses import ContrastiveLoss\n", + "from monai.data import (\n", + " Dataset,\n", + " DataLoader,\n", + " CacheDataset,\n", + " load_decathlon_datalist,\n", + ")\n", + "from monai.config import print_config\n", + "\n", + "from monai.transforms import (\n", + " LoadImaged,\n", + " Compose,\n", + " CropForegroundd,\n", + " CopyItemsd,\n", + " ResizeWithPadOrCropd,\n", + " EnsureChannelFirstd,\n", + " Orientationd,\n", + " Spacingd,\n", + " OneOf,\n", + " NormalizeIntensityd,\n", + " RandSpatialCropSamplesd,\n", + " RandCoarseDropoutd,\n", + " RandCoarseShuffled,\n", + ")\n", + "\n", + "from load_data import load_data\n" + ] + }, + { + "cell_type": "markdown", + "id": "72e2e12c", + "metadata": {}, + "source": [ + "##### Define file paths & output directory path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "780bf9d9-6664-4f1d-a350-eba61ae3b215", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "json_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/dataset_split_spine-generic.json\")\n", + "data_root = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/spine-generic\")\n", + "logdir_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/\")" + ] + }, + { + "cell_type": "markdown", + "id": "7adf9d64", + "metadata": {}, + "source": [ + "##### Create result logging directories, manage data paths & set determinism" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5619b330-3994-4351-99d9-6909a2b9ec1c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "train_list, val_list = load_data(data_root, json_path, logdir_path)" + ] + }, + { + "cell_type": "markdown", + "id": "d106d4ea", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f8ebbdd8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [51, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=[\"image\"], image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=[\"image\"], axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=[\"image\"], pixdim=(1.0, 1.0, 1.0), mode=2),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Original image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "d60b11f3-3cde-4c80-9fea-906ac0b19a29", + "metadata": { + "tags": [] + }, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a517c3b7-0dff-4edf-a1c6-ebb7345bd77f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=[\"image\"], image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=[\"image\"], axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=[\"image\"], pixdim=(1.0, 1.0, 1.0), mode=2),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=[\"image\"], spatial_size=spatial_size)\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Padded image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "044bbc61-7819-4245-a80c-a8f9a0c6532f", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 256, 256)`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "83e2da2c-fa48-4ca6-aa0a-cdf5230d4e8c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=spatial_size\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=[\"image\"], image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=[\"image\"], axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=[\"image\"], pixdim=(1.0, 1.0, 1.0), mode=2),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=[\"image\"], spatial_size=spatial_size),\n", + " # Randomly crop samples of a specified size\n", + " RandSpatialCropSamplesd(keys=[\"image\"], roi_size=roi_size, random_size=False, num_samples=2),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax2=plt.subplot(2,3,4)\n", + "ax2.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "71e99903-eedf-4706-9673-0e75e0592cd9", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 256, 256)`, create copies for augmentation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "75a188fb-b236-48c4-b3f6-04a0c298fb74", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=spatial_size\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=[\"image\"], image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=[\"image\"], axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=[\"image\"], pixdim=(1.0, 1.0, 1.0), mode=2),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=[\"image\"], spatial_size=spatial_size),\n", + " # Randomly crop samples of a specified size\n", + " RandSpatialCropSamplesd(keys=[\"image\"], roi_size=roi_size, random_size=False, num_samples=2),\n", + " # Create copies of items in the dictionary under new keys, allowing for the same image to be manipulated\n", + " # differently in subsequent transformations\n", + " CopyItemsd(keys=[\"image\"], times=2, names=[\"gt_image\", \"image_2\"], allow_missing_keys=False)\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "# Note: 'gt_image' is added by 'CopyItemsd'\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"gt_image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax4=plt.subplot(2,3,4)\n", + "ax4.imshow(batch_to_plot[\"gt_image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "ax2=plt.subplot(2,3,2)\n", + "ax2.set_title('Augmented Views 1')\n", + "ax2.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax5=plt.subplot(2,3,5)\n", + "ax5.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "# Note: 'image_2' is added by 'CopyItemsd'\n", + "ax3=plt.subplot(2,3,3)\n", + "ax3.set_title('Augmented Views 2')\n", + "ax3.imshow(batch_to_plot[\"image_2\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax6=plt.subplot(2,3,6)\n", + "ax6.imshow(batch_to_plot[\"image_2\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "48b67e7b-d402-4d6b-a10f-abf827d88c3a", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 256, 256)`, create copies for augmentation, do augmentation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "51db1e0d-b803-4108-9e59-82951fb7966a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "roi_size=spatial_size\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=[\"image\"], image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=[\"image\"], axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=[\"image\"], pixdim=(1.0, 1.0, 1.0), mode=2),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=[\"image\"], spatial_size=spatial_size),\n", + " # Randomly crop samples of a specified size\n", + " RandSpatialCropSamplesd(keys=[\"image\"], roi_size=roi_size, random_size=False, num_samples=2),\n", + " # Create copies of items in the dictionary under new keys, allowing for the same image to be manipulated\n", + " # differently in subsequent transformations\n", + " CopyItemsd(keys=[\"image\"], times=2, names=[\"gt_image\", \"image_2\"], allow_missing_keys=False),\n", + " \n", + " # AUGMENTED VIEW 1\n", + " OneOf(\n", + " transforms=[\n", + " # Randomly drop regions of the image\n", + " # 'dropout_holes=True': dropout the regions of holes and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image\"], prob=1.0, holes=6, spatial_size=(10, 20, 20), dropout_holes=True,\n", + " max_spatial_size=(spatial_size[0]/4, spatial_size[1]/4, spatial_size[2]/4)\n", + " ),\n", + " # 'dropout_holes=False': keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image\"], prob=1.0, holes=6, spatial_size=(30, 60, 60), dropout_holes=False,\n", + " max_spatial_size=(spatial_size[0]/2, spatial_size[1]/2, spatial_size[2]/2)\n", + " ),\n", + " ]\n", + " ),\n", + " # Randomly shuffle blocks within the image\n", + " RandCoarseShuffled(keys=[\"image\"], prob=0.8, holes=10, spatial_size=8),\n", + " \n", + " # AUGMENTED VIEW 2\n", + " # Please note that that if image and image_2 are called via the same transform call because of the\n", + " # determinism they will get augmented the exact same way which is not the required case here, hence two\n", + " # calls are made\n", + " OneOf(\n", + " transforms=[\n", + " # Randomly drop regions of the image\n", + " # 'dropout_holes=True': dropout the regions of holes and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_2\"], prob=1.0, holes=6, spatial_size=(10, 20, 20), dropout_holes=True,\n", + " max_spatial_size=(spatial_size[0]/4, spatial_size[1]/4, spatial_size[2]/4)\n", + " ),\n", + " # 'dropout_holes=False': keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_2\"], prob=1.0, holes=6, spatial_size=(30, 60, 60), dropout_holes=False,\n", + " max_spatial_size=(spatial_size[0]/2, spatial_size[1]/2, spatial_size[2]/2)\n", + " ),\n", + " ]\n", + " ),\n", + " RandCoarseShuffled(keys=[\"image_2\"], prob=0.8, holes=10, spatial_size=8),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "# Note: 'gt_image' is added by 'CopyItemsd'\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"gt_image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax4=plt.subplot(2,3,4)\n", + "ax4.imshow(batch_to_plot[\"gt_image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "ax2=plt.subplot(2,3,2)\n", + "ax2.set_title('Augmented Views 1')\n", + "ax2.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax5=plt.subplot(2,3,5)\n", + "ax5.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "# Note: 'image_2' is added by 'CopyItemsd'\n", + "ax3=plt.subplot(2,3,3)\n", + "ax3.set_title('Augmented Views 2')\n", + "ax3.imshow(batch_to_plot[\"image_2\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax6=plt.subplot(2,3,6)\n", + "ax6.imshow(batch_to_plot[\"image_2\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "vscode": { + "interpreter": { + "hash": "da3e08083059755bb70e9f8b58ba677201225f59652efa5b6b39528ae9381865" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/vit_unetr_ssl/ssl_debug_transforms_sc_crop.ipynb b/vit_unetr_ssl/ssl_debug_transforms_sc_crop.ipynb new file mode 100644 index 0000000..45248ab --- /dev/null +++ b/vit_unetr_ssl/ssl_debug_transforms_sc_crop.ipynb @@ -0,0 +1,655 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ceab8707", + "metadata": {}, + "source": [ + "Copyright (c) MONAI Consortium \n", + "Licensed under the Apache License, Version 2.0 (the \"License\"); \n", + "you may not use this file except in compliance with the License. \n", + "You may obtain a copy of the License at \n", + "    http://www.apache.org/licenses/LICENSE-2.0 \n", + "Unless required by applicable law or agreed to in writing, software \n", + "distributed under the License is distributed on an \"AS IS\" BASIS, \n", + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \n", + "See the License for the specific language governing permissions and \n", + "limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "b68c35c3", + "metadata": {}, + "source": [ + "# Self-Supervised Pre-training - step-by-step augmentation\n", + "\n", + "ℹ️ This notebook is based on [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl) and provides step-by-step visualisation of data augmentation necessary for the Self-Supervised Pre-training.\n", + "\n", + "First, it uses augmentation (top row) to mutate the data and second, it utilizes regularized contrastive loss [3] to learn feature representations of the unlabeled data. The multiple augmentations are applied on a randomly selected 3D foreground patch from a 3D volume (selected by on the spinal cord mask). Two augmented views of the same 3D patch are generated for the contrastive loss as it functions by drawing the two augmented views closer to each other if the views are generated from the same patch, if not then it tries to maximize the disagreement.\n", + "\n", + "The augmentations mutate the 3D patch in various ways, the primary task of the network is to reconstruct the original image. The different augmentations used are classical techniques such as in-painting [1], out-painting [1] and noise augmentation to the image by local pixel shuffling [2]. The secondary task of the network is to simultaneously reconstruct the two augmented views as similar to each other as possible via regularized contrastive loss [3] as its objective is to maximize the agreement.\n", + "\n", + "For references, visit [this MONAI tutorial](https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl)." + ] + }, + { + "cell_type": "markdown", + "id": "707541a2", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4dc0237b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[pillow, tqdm]\"\n", + "!python -c \"import matplotlib\" || pip install -q matplotlib\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "49070e05", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cf64bf41", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import time\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch.nn import L1Loss\n", + "from monai.utils import set_determinism, first\n", + "from monai.networks.nets import ViTAutoEnc\n", + "from monai.losses import ContrastiveLoss\n", + "from monai.data import (\n", + " Dataset,\n", + " DataLoader,\n", + " CacheDataset,\n", + " load_decathlon_datalist,\n", + ")\n", + "from monai.config import print_config\n", + "\n", + "from monai.transforms import (\n", + " LoadImaged,\n", + " AsDiscreted,\n", + " Compose,\n", + " CropForegroundd,\n", + " CopyItemsd,\n", + " ResizeWithPadOrCropd,\n", + " EnsureChannelFirstd,\n", + " Orientationd,\n", + " Spacingd,\n", + " OneOf,\n", + " NormalizeIntensityd,\n", + " RandSpatialCropSamplesd,\n", + " RandCropByPosNegLabeld,\n", + " RandCoarseDropoutd,\n", + " RandCoarseShuffled,\n", + ")\n", + "\n", + "from load_data import load_data\n" + ] + }, + { + "cell_type": "markdown", + "id": "72e2e12c", + "metadata": {}, + "source": [ + "##### Define file paths & output directory path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aafc74a7-c62d-4d7d-8b38-ded9b17b8507", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Both images and labels (binary spinal cord masks) are loaded\n", + "json_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/dataset_split_short_with_labels.json\")\n", + "data_root = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/spine-generic_with_labels\")\n", + "logdir_path = os.path.normpath(\"/Users/valosek/data/experiments/vit_unetr_ssl/\")" + ] + }, + { + "cell_type": "markdown", + "id": "7adf9d64", + "metadata": {}, + "source": [ + "##### Create result logging directories, manage data paths & set determinism" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5619b330-3994-4351-99d9-6909a2b9ec1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total training data are 3 and validation data are 1\n" + ] + } + ], + "source": [ + "train_list, val_list = load_data(data_root, json_path, logdir_path)\n", + "print(\"Total training data are {} and validation data are {}\".format(len(train_list), len(val_list)))" + ] + }, + { + "cell_type": "markdown", + "id": "d106d4ea", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f8ebbdd8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [51, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "#roi_size=spatial_size\n", + "#roi_size=(64,128,128)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Original image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "d60b11f3-3cde-4c80-9fea-906ac0b19a29", + "metadata": { + "tags": [] + }, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a517c3b7-0dff-4edf-a1c6-ebb7345bd77f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image shape: [64, 256, 256]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "#roi_size=spatial_size\n", + "#roi_size=(64,128,128)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=100\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "image_to_plot = batch_to_plot[\"image\"][0][0]\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title(f\"Padded image {list(image_to_plot.shape)} - single axial slice\")\n", + "ax1.imshow(image_to_plot[:,:,slice], cmap='gray')\n", + "plt.tight_layout()\n", + "\n", + "print(f'image shape: {list(image_to_plot.shape)}')" + ] + }, + { + "cell_type": "markdown", + "id": "044bbc61-7819-4245-a80c-a8f9a0c6532f", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 64 64)` around the label" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "83e2da2c-fa48-4ca6-aa0a-cdf5230d4e8c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 64, 64]\n", + "[0. 1.]\n", + "[0. 1.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "#roi_size=spatial_size\n", + "#roi_size=(64,128,128)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " AsDiscreted(keys='label', to_onehot=None, threshold=0.5),\n", + " # Randomly crop samples of a specified size around the label (spinal cord)\n", + " # Note that it seems that the transform randomly selects a foreground point from image, then use it as\n", + " # center crop. This means that it can find the closest voxel that is just outside the SC and use it as the\n", + " # center (hence it includes the SC)\n", + " # https://github.com/Project-MONAI/MONAI/issues/452#issuecomment-636065502\n", + " RandCropByPosNegLabeld(\n", + " keys=keys,\n", + " label_key=\"label\",\n", + " spatial_size=roi_size,\n", + " pos=2,\n", + " neg=1,\n", + " num_samples=2,\n", + " image_key=\"image\",\n", + " image_threshold=0,\n", + " )\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=roi_size[2]//3 # // int division\n", + "index=2\n", + "#batch_to_plot = first(check_loader)\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "ax1.imshow(batch_to_plot[\"label\"][0][0][:,:,slice], alpha=0.5, cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "print(np.unique(batch_to_plot[\"label\"][0][0][:,:,slice]))\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax2=plt.subplot(2,3,4)\n", + "ax2.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "ax2.imshow(batch_to_plot[\"label\"][1][0][:,:,slice], alpha=0.5,cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "print(np.unique(batch_to_plot[\"label\"][1][0][:,:,slice]))\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "48b67e7b-d402-4d6b-a10f-abf827d88c3a", + "metadata": {}, + "source": [ + "### Define Transforms - reorient to RPI, resample to 1 mm iso, pad to `(64, 256, 256)`, crop two samples of `(64, 64, 64)` around the label, create copies for augmentation, do augmentation" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "51db1e0d-b803-4108-9e59-82951fb7966a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "patch shape: [64, 64, 64]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spatial_size=(64, 256, 256)\n", + "#roi_size=spatial_size\n", + "#roi_size=(64,128,128)\n", + "roi_size=(64,64,64)\n", + "\n", + "keys=[\"image\", \"label\"]\n", + "\n", + "transforms = Compose(\n", + " [\n", + " # Load image data using the key \"image\"\n", + " LoadImaged(keys=keys, image_only=True),\n", + " # Ensure that the channel dimension is the first dimension of the image tensor.\n", + " EnsureChannelFirstd(keys=keys),\n", + " # Ensure that the image orientation is consistently RPI\n", + " Orientationd(keys=keys, axcodes=\"RPI\"),\n", + " # Resample the images to a specified pixel spacing\n", + " # NOTE: spine interpolation with order=2 is spline, order=1 is linear\n", + " Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2,1)),\n", + " # Normalize the intensity values of the image\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=False, channel_wise=False),\n", + " # Remove background pixels to focus on regions of interest.\n", + " #CropForegroundd(keys=[\"image\"], source_key=\"image\"),\n", + " # Pad the image to a specified spatial size if its size is smaller than the specified dimensions\n", + " ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size),\n", + " AsDiscreted(keys='label', to_onehot=None, threshold=0.5),\n", + " # Randomly crop samples of a specified size around the label (spinal cord)\n", + " # Note that it seems that the transform randomly selects a foreground point from image, then use it as\n", + " # center crop. This means that it can find the closest voxel that is just outside the SC and use it as the\n", + " # center (hence it includes the SC)\n", + " # https://github.com/Project-MONAI/MONAI/issues/452#issuecomment-636065502\n", + " RandCropByPosNegLabeld(\n", + " keys=keys,\n", + " label_key=\"label\",\n", + " spatial_size=roi_size,\n", + " pos=2,\n", + " neg=1,\n", + " num_samples=2,\n", + " image_key=\"image\",\n", + " image_threshold=0,\n", + " ),\n", + " # Create copies of items in the dictionary under new keys, allowing for the same image to be manipulated\n", + " # differently in subsequent transformations\n", + " CopyItemsd(keys=[\"image\"], times=2, names=[\"gt_image\", \"image_2\"], allow_missing_keys=False),\n", + " \n", + " # AUGMENTED VIEW 1\n", + " OneOf(\n", + " transforms=[\n", + " # Randomly drop regions of the image\n", + " # 'dropout_holes=True': dropout the regions of holes and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image\"], \n", + " prob=1.0, \n", + " holes=10, \n", + " spatial_size=roi_size[0]//4,\n", + " dropout_holes=True,\n", + " #max_spatial_size=(roi_size[0]//4, roi_size[1]//4, roi_size[2]//4)\n", + " ),\n", + " # 'dropout_holes=False': keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image\"], \n", + " prob=1.0, \n", + " holes=10, \n", + " spatial_size=roi_size[0]//2,\n", + " dropout_holes=False,\n", + " #max_spatial_size=(roi_size[0]//2, roi_size[1]//2, roi_size[2]//2)\n", + " ),\n", + " ]\n", + " ),\n", + " # Randomly select regions in the image, then shuffle the pixels within every region\n", + " RandCoarseShuffled(keys=[\"image\"], prob=0.8, holes=10, spatial_size=roi_size[2]//4),\n", + " \n", + " # AUGMENTED VIEW 2\n", + " # Please note that that if image and image_2 are called via the same transform call because of the\n", + " # determinism they will get augmented the exact same way which is not the required case here, hence two\n", + " # calls are made\n", + " OneOf(\n", + " transforms=[\n", + " # Randomly drop regions of the image\n", + " # 'dropout_holes=True': dropout the regions of holes and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_2\"], \n", + " prob=1.0, \n", + " holes=10, \n", + " spatial_size=roi_size[0]//4,\n", + " dropout_holes=True,\n", + " #max_spatial_size=(roi_size[0]//4, roi_size[1]//4, roi_size[2]//4)\n", + " ),\n", + " # 'dropout_holes=False': keep the holes and dropout the outside and fill value specified by 'fill_value'\n", + " RandCoarseDropoutd(\n", + " keys=[\"image_2\"], \n", + " prob=1.0, \n", + " holes=10, \n", + " spatial_size=roi_size[0]//2, \n", + " dropout_holes=False,\n", + " #max_spatial_size=(roi_size[0]//2, roi_size[1]//2, roi_size[2]//2)\n", + " ),\n", + " ]\n", + " ),\n", + " # Randomly select regions in the image, then shuffle the pixels within every region\n", + " RandCoarseShuffled(keys=[\"image_2\"], prob=0.8, holes=10, spatial_size=roi_size[2]//4),\n", + " ]\n", + ")\n", + "\n", + "# Sanity check -- plotting\n", + "\n", + "check_ds = Dataset(data=train_list, transform=transforms)\n", + "check_loader = DataLoader(check_ds, batch_size=1)\n", + "\n", + "slice=roi_size[2]//3 # // int division\n", + "index=2\n", + "batch_to_plot = None\n", + "for i, batch in enumerate(check_loader):\n", + " if i == index: # indexing starts at 0\n", + " batch_to_plot = batch\n", + " break # exit the loop as soon as the desired batch is found \n", + "\n", + "print(f'patch shape: {list(batch_to_plot[\"image\"][0][0].shape)}')\n", + "\n", + "# Note: 'gt_image' is added by 'CopyItemsd'\n", + "ax1=plt.subplot(2,3,1)\n", + "ax1.set_title('Original Views')\n", + "ax1.imshow(batch_to_plot[\"gt_image\"][0][0][:,:,slice], cmap='gray')\n", + "#ax1.imshow(batch_to_plot[\"label\"][0][0][:,:,slice], alpha=0.5, cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "#print(np.unique(batch_to_plot[\"label\"][0][0][:,:,slice]))\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax4=plt.subplot(2,3,4)\n", + "ax4.imshow(batch_to_plot[\"gt_image\"][1][0][:,:,slice], cmap='gray')\n", + "#ax4.imshow(batch_to_plot[\"label\"][1][0][:,:,slice], alpha=0.5,cmap='jet', interpolation='nearest') # interpolation='nearest' has to be used to show binary mask\n", + "#print(np.unique(batch_to_plot[\"label\"][1][0][:,:,slice]))\n", + "\n", + "\n", + "ax2=plt.subplot(2,3,2)\n", + "ax2.set_title('Augmented Views 1')\n", + "ax2.imshow(batch_to_plot[\"image\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax5=plt.subplot(2,3,5)\n", + "ax5.imshow(batch_to_plot[\"image\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "# Note: 'image_2' is added by 'CopyItemsd'\n", + "ax3=plt.subplot(2,3,3)\n", + "ax3.set_title('Augmented Views 2')\n", + "ax3.imshow(batch_to_plot[\"image_2\"][0][0][:,:,slice], cmap='gray')\n", + "# Note: the [1] dimension is added by 'RandSpatialCropSamplesd(num_samples=2)'\n", + "ax6=plt.subplot(2,3,6)\n", + "ax6.imshow(batch_to_plot[\"image_2\"][1][0][:,:,slice], cmap='gray')\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "vscode": { + "interpreter": { + "hash": "da3e08083059755bb70e9f8b58ba677201225f59652efa5b6b39528ae9381865" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/vit_unetr_ssl/train.py b/vit_unetr_ssl/train.py new file mode 100644 index 0000000..bad3876 --- /dev/null +++ b/vit_unetr_ssl/train.py @@ -0,0 +1,317 @@ +""" +Self-Supervised Pre-training using Vision Transformer (ViT) + +This script is based on this MONAI tutorial: +https://github.com/Project-MONAI/tutorials/tree/main/self_supervised_pretraining/vit_unetr_ssl + +Author: Jan Valosek +""" + +import os +import time +import torch +import argparse +import matplotlib.pyplot as plt + +from loguru import logger +from torch.nn import L1Loss +from monai.utils import set_determinism, first +from monai.networks.nets import ViTAutoEnc +from monai.losses import ContrastiveLoss +from monai.data import ( + Dataset, + DataLoader, + CacheDataset, +) + +from transforms import define_pretrain_transforms +from load_data import load_data +# Added this to solve problem with too many files open allowing number of workers > 0 +# https://github.com/pytorch/pytorch/issues/11201#issuecomment-421146936 +# https://github.com/ivadomed/model-seg-dcm/issues/8 +import torch.multiprocessing +torch.multiprocessing.set_sharing_strategy('file_system') + + +def get_parser(): + # parse command line arguments + parser = argparse.ArgumentParser(description='Run Self-Supervised Pre-training.') + parser.add_argument('--dataset-split', required=True, type=str, + help='Path to the JSON file with training/validation split. ' + 'If paths are absolute, you do NOT need to use --data. ' + 'If only filenames are provided, you need to use --data to specify the root directory ' + 'of the dataset.') + parser.add_argument('--data', required=False, type=str, default="", + help='Path to the dataset root directory. If not provided, path to data specified in the JSON ' + 'file will be used.') + parser.add_argument('--logdir', required=True, type=str, + help='Path to the directory for logging.') + parser.add_argument('--cuda', type=int, default=0, help='Index of the CUDA device to use.') + + return parser + + +def main(): + + parser = get_parser() + args = parser.parse_args() + + # ----------------------------------------------------- + # Define file paths & output directory path + # ----------------------------------------------------- + json_path = os.path.abspath(args.dataset_split) + data_root = os.path.abspath(args.data) + logdir_path = os.path.abspath(args.logdir) + + # ----------------------------------------------------- + # Create result logging directories, manage data paths & set determinism + # ----------------------------------------------------- + train_list, val_list = load_data(data_root, json_path, logdir_path) + + # save output to a log file + logger.add(os.path.join(logdir_path, "log.txt"), rotation="10 MB", level="INFO") + + logger.info("Total training data are {} and validation data are {}".format(len(train_list), len(val_list))) + + # Set Determinism + set_determinism(seed=123) + + # ----------------------------------------------------- + # Define MONAI Transforms + # ----------------------------------------------------- + SPATIAL_SIZE = (64, 256, 256) + ROI_SIZE = (64, 64, 64) + #ROI_SIZE = SPATIAL_SIZE + keys = ["image", "label"] + + transforms = define_pretrain_transforms(keys=keys, spatial_size=SPATIAL_SIZE, roi_size=ROI_SIZE) + + # ----------------------------------------------------- + # Sanity Check for the transforms + # ----------------------------------------------------- + check_ds = Dataset(data=train_list, transform=transforms) + check_loader = DataLoader(check_ds, batch_size=1) + check_data = first(check_loader) + logger.info(f'original image shape: {check_data["gt_image"][0][0].shape}') + logger.info(f'augmented image 1 shape: {check_data["image"][0][0].shape}') + logger.info(f'augmented image 2 shape: {check_data["image_2"][0][0].shape}') + + # ----------------------------------------------------- + # Training Config + # ----------------------------------------------------- + + # Define Network ViT backbone & Loss & Optimizer + patch_size = (16, 16, 16) + device = torch.device(f"cuda:{args.cuda}") + model = ViTAutoEnc( + in_channels=1, + img_size=ROI_SIZE, + patch_size=patch_size, + pos_embed="conv", + hidden_size=768, + mlp_dim=3072, + ) + + model = model.to(device) + + # Define Hyper-parameters for training loop + max_epochs = 500 + val_interval = 2 + # Note: the batch size is actually doubled (8*2=16), because we are using two augmented samples per 3D Volume + # TODO: increase it to 16 + batch_size = 8 + lr = 1e-4 + epoch_loss_values = [] + step_loss_values = [] + epoch_cl_loss_values = [] + epoch_recon_loss_values = [] + val_loss_values = [] + best_val_loss = 1000.0 + + recon_loss = L1Loss() + contrastive_loss = ContrastiveLoss(temperature=0.05) + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + # ------------------------------------------------------ + # Print hyper-parameters into the log file + # ------------------------------------------------------ + logger.info(f"img_size: {ROI_SIZE}") + logger.info(f"patch_size: {patch_size}") + logger.info(f"max_epochs: {max_epochs}") + logger.info(f"val_interval: {val_interval}") + logger.info(f"batch_size: {batch_size}") + logger.info(f"lr: {lr}") + + # ----------------------------------------------------- + # Create dataloaders for training + # ----------------------------------------------------- + + NUM_WORKERS = batch_size + + train_dataset = CacheDataset(data=train_list, transform=transforms, cache_rate=0.5, num_workers=NUM_WORKERS) + val_dataset = CacheDataset(data=val_list, transform=transforms, cache_rate=0.25, num_workers=NUM_WORKERS) + train_loader = DataLoader(train_dataset, + batch_size=batch_size, + shuffle=True, + num_workers=NUM_WORKERS, + pin_memory=False, + persistent_workers=False) + val_loader = DataLoader(val_dataset, + batch_size=batch_size, + shuffle=True, + num_workers=NUM_WORKERS, + pin_memory=False, + persistent_workers=False) + + # ----------------------------------------------------- + # Training Loop with Validation + # ----------------------------------------------------- + + for epoch in range(max_epochs): + start_time_epoch = time.time() + logger.info("-" * 10) + logger.info(f"epoch {epoch + 1}/{max_epochs}") + model.train() + epoch_loss = 0 + epoch_cl_loss = 0 + epoch_recon_loss = 0 + step = 0 + + for batch_data in train_loader: + step += 1 + start_time = time.time() + + inputs, inputs_2, gt_input = ( + batch_data["image"].to(device), + batch_data["image_2"].to(device), + batch_data["gt_image"].to(device), + ) + optimizer.zero_grad() + outputs_v1, hidden_v1 = model(inputs) + outputs_v2, hidden_v2 = model(inputs_2) + + flat_out_v1 = outputs_v1.flatten(start_dim=1, end_dim=4) + flat_out_v2 = outputs_v2.flatten(start_dim=1, end_dim=4) + + r_loss = recon_loss(outputs_v1, gt_input) + cl_loss = contrastive_loss(flat_out_v1, flat_out_v2) + + # Adjust the CL loss by Recon Loss + total_loss = r_loss + cl_loss * r_loss + # TODO: verify if the detach is necessary + total_loss.detach().cpu() + + total_loss.backward() + optimizer.step() + epoch_loss += total_loss.item() + step_loss_values.append(total_loss.item()) + + # CL & Recon Loss Storage of Value + epoch_cl_loss += cl_loss.item() + epoch_recon_loss += r_loss.item() + + end_time = time.time() + logger.info( + f"{step}/{len(train_dataset) // train_loader.batch_size}, " + f"train_loss: {total_loss.item():.4f}, " + f"time taken: {end_time-start_time}s" + ) + + epoch_loss /= step + epoch_cl_loss /= step + epoch_recon_loss /= step + + epoch_loss_values.append(epoch_loss) + epoch_cl_loss_values.append(epoch_cl_loss) + epoch_recon_loss_values.append(epoch_recon_loss) + logger.info(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}") + end_time_epoch = time.time() + logger.info(f"epoch {epoch + 1} time taken: {end_time_epoch-start_time_epoch}s") + + # Validation every 2 epochs + if epoch % val_interval == 0: + logger.info("Entering Validation for epoch: {}".format(epoch + 1)) + total_val_loss = 0 + val_step = 0 + model.eval() + for val_batch in val_loader: + val_step += 1 + start_time = time.time() + inputs, gt_input = ( + val_batch["image"].to(device), + val_batch["gt_image"].to(device), + ) + logger.info("Input shape: {}".format(inputs.shape)) + # Call forward pass of the model with the inputs + # The model returns the output and the hidden states + # 1. outputs: This is the reconstructed image from the model. It should have the same dimensions as + # the input image. + # 2. outputs_v2: This is the hidden representation of the input image, which is the output of the + # transformer encoder. It's a high-dimensional feature representation of the input. + outputs, outputs_v2 = model(inputs) + val_loss = recon_loss(outputs, gt_input) + total_val_loss += val_loss.item() + end_time = time.time() + + # Create validation_figures directory if it does not exist + if not os.path.exists(os.path.join(logdir_path, "validation_figures")): + os.mkdir(os.path.join(logdir_path, "validation_figures")) + if val_step == 1: + # Plot and save input and output validation images to see how the model is learning + plt.figure(1, figsize=(8, 8)) + plt.subplot(2, 2, 1) + plt.imshow(inputs[0, 0, :, :, 32].detach().cpu().numpy(), cmap="gray") + plt.title("Input Image") + plt.subplot(2, 2, 2) + plt.imshow(gt_input[0, 0, :, :, 32].detach().cpu().numpy(), cmap="gray") + plt.title("Ground Truth Image") + plt.subplot(2, 2, 3) + plt.imshow(outputs[0, 0, :, :, 32].detach().cpu().numpy(), cmap="gray") + plt.title("Output Image") + # Include the epoch number as master title + plt.suptitle(f"Epoch {epoch + 1}") + # Use 3 leading zeros for the epoch number + fname = os.path.join(logdir_path, "validation_figures", f"epoch_{epoch + 1:03d}_val_{val_step}.png") + plt.savefig(fname) + plt.close(1) + logger.info(f"Saved validation images to {fname}") + + total_val_loss /= val_step + val_loss_values.append(total_val_loss) + logger.info(f"epoch {epoch + 1} Validation avg loss: {total_val_loss:.4f}, " f"time taken: {end_time-start_time}s") + + if total_val_loss < best_val_loss: + logger.info(f"Saving new model based on validation loss {total_val_loss:.4f}") + best_val_loss = total_val_loss + checkpoint = {"epoch": max_epochs, "state_dict": model.state_dict(), "optimizer": optimizer.state_dict()} + torch.save(checkpoint, os.path.join(logdir_path, "best_model.pt")) + + plt.figure(1, figsize=(8, 8)) + plt.subplot(2, 2, 1) + plt.plot(epoch_loss_values) + plt.grid() + plt.title("Training Loss") + + plt.subplot(2, 2, 2) + plt.plot(val_loss_values) + plt.grid() + plt.title("Validation Loss") + + plt.subplot(2, 2, 3) + plt.plot(epoch_cl_loss_values) + plt.grid() + plt.title("Training Contrastive Loss") + + plt.subplot(2, 2, 4) + plt.plot(epoch_recon_loss_values) + plt.grid() + plt.title("Training Recon Loss") + + plt.savefig(os.path.join(logdir_path, "loss_plots.png")) + plt.close(1) + + logger.info("Done") + + +if __name__ == "__main__": + main() diff --git a/vit_unetr_ssl/transforms.py b/vit_unetr_ssl/transforms.py new file mode 100644 index 0000000..2a6daba --- /dev/null +++ b/vit_unetr_ssl/transforms.py @@ -0,0 +1,225 @@ +import numpy as np + +from monai.transforms import ( + LoadImaged, + Compose, + CropForegroundd, + CopyItemsd, + ResizeWithPadOrCropd, + AsDiscreted, + RandCropByPosNegLabeld, + EnsureChannelFirstd, + Orientationd, + Spacingd, + OneOf, + NormalizeIntensityd, + RandCoarseDropoutd, + RandCoarseShuffled, + RandFlipd, + RandGaussianSmoothd, + RandBiasFieldd, + RandAdjustContrastd, + RandSimulateLowResolutiond, + RandAffined, + ToTensord +) + + +def define_pretrain_transforms(keys, spatial_size, roi_size, number_of_holes=5): + """ + Define MONAI Transforms for Training/Validation of the self-supervised pretrained model + :args: keys: list of keys to be used for the transforms, e.g. ["image", "label"] + :args: spatial_size: spatial size of the input image, e.g. (64, 256, 256) + :args: roi_size: size of the sample to crop, e.g. (64, 64, 64) + :args: number_of_holes: number of holes to be used for the RandCoarseDropoutd and RandCoarseShuffled transforms + """ + transforms = Compose( + [ + # Load image data using the key "image" + LoadImaged(keys=keys, image_only=True), + # Ensure that the channel dimension is the first dimension of the image tensor. + EnsureChannelFirstd(keys=keys), + # Ensure that the image orientation is consistently RPI + Orientationd(keys=keys, axcodes="RPI"), + # Resample the images to a specified pixel spacing + # NOTE: spine interpolation with order=2 is spline, order=1 is linear + Spacingd(keys=keys, pixdim=(1.0, 1.0, 1.0), mode=(2, 1)), + # Normalize the intensity values of the image + NormalizeIntensityd(keys=["image"], nonzero=False, channel_wise=False), + # Remove background pixels to focus on regions of interest. + # CropForegroundd(keys=["image"], source_key="image"), + # Pad the image to a specified spatial size if its size is smaller than the specified dimensions + ResizeWithPadOrCropd(keys=keys, spatial_size=spatial_size), + AsDiscreted(keys='label', to_onehot=None, threshold=0.5), + # Randomly crop samples of a specified size around the label (spinal cord) + # Note that it seems that the transform randomly selects a foreground point from image, then use it as + # center crop. This means that it can find the closest voxel that is just outside the SC and use it as the + # center (hence it includes the SC) + # https://github.com/Project-MONAI/MONAI/issues/452#issuecomment-636065502 + RandCropByPosNegLabeld( + keys=keys, + label_key="label", + spatial_size=roi_size, + pos=2, + neg=1, + num_samples=2, + image_key="image", + image_threshold=0, + ), + # Create copies of items in the dictionary under new keys, allowing for the same image to be manipulated + # differently in subsequent transformations + CopyItemsd(keys=["image"], times=2, names=["gt_image", "image_2"], allow_missing_keys=False), + + # AUGMENTED VIEW 1 + OneOf( + transforms=[ + # Randomly drop regions of the image + RandCoarseDropoutd( + keys=["image"], + prob=1.0, + holes=number_of_holes, + spatial_size=roi_size[0] // 4, + dropout_holes=True, # if True, dropout the regions of holes and fill value specified by 'fill_value' + fill_value=0, # fill value for the dropped regions + ), + # 'dropout_holes=False': the areas inside the holes will be filled with random noise + RandCoarseDropoutd( + keys=["image"], + prob=1.0, + holes=number_of_holes, + spatial_size=roi_size[0] // 2, + dropout_holes=False, # if False, keep the holes and dropout the outside and fill value specified by 'fill_value' + fill_value=0, # fill value for the dropped regions + ), + ] + ), + # Randomly select regions in the image, then shuffle the pixels within every region + RandCoarseShuffled(keys=["image"], prob=0.8, holes=number_of_holes, spatial_size=roi_size[2] // 4), + + # AUGMENTED VIEW 2 + # Please note that that if image and image_2 are called via the same transform call because of the + # determinism they will get augmented the exact same way which is not the required case here, hence two + # calls are made + OneOf( + transforms=[ + # Randomly drop regions of the image + RandCoarseDropoutd( + keys=["image_2"], + prob=1.0, + holes=number_of_holes, + spatial_size=roi_size[0] // 4, + dropout_holes=True, # if True, dropout the regions of holes and fill value specified by 'fill_value' + fill_value=0, # fill value for the dropped regions + ), + # 'dropout_holes=False': the areas inside the holes will be filled with random noise + RandCoarseDropoutd( + keys=["image_2"], + prob=1.0, + holes=number_of_holes, + spatial_size=roi_size[0] // 2, + dropout_holes=False, # if False, keep the holes and dropout the outside and fill value specified by 'fill_value' + fill_value=0, # fill value for the dropped regions + ), + ] + ), + # Randomly select regions in the image, then shuffle the pixels within every region + RandCoarseShuffled(keys=["image_2"], prob=0.8, holes=number_of_holes, spatial_size=roi_size[2] // 4), + ] + ) + + return transforms + + +def define_finetune_train_transforms(spatial_size, roi_size): + """ + Define MONAI Transforms for Training of the fine-tuned model + :args: spatial_size: spatial size of the input image, e.g. (64, 256, 256) + :args: roi_size: size of the sample to crop, e.g. (64, 64, 64) + """ + train_transforms = Compose( + [ + # Load image data and GT using the keys "image" and "label" + LoadImaged(keys=["image", "label_sc", "label_lesion"], image_only=False), + # Ensure that the channel dimension is the first dimension of the image tensor. + EnsureChannelFirstd(keys=["image", "label_sc", "label_lesion"]), + # Ensure that the image orientation is consistently RPI + Orientationd(keys=["image", "label_sc", "label_lesion"], axcodes="RPI"), + # Resample the images to a specified pixel spacing + # NOTE: spine interpolation with order=2 is spline, order=1 is linear + Spacingd(keys=["image", "label_sc", "label_lesion"], pixdim=(1.0, 1.0, 1.0), mode=(2, 1, 1)), + # Normalize the intensity values of the image + NormalizeIntensityd(keys=["image"], nonzero=False, channel_wise=False), + # Remove background pixels to focus on regions of interest. + CropForegroundd(keys=["image", "label_sc", "label_lesion"], source_key="image"), + # Pad the image to a specified spatial size if its size is smaller than the specified dimensions + ResizeWithPadOrCropd(keys=["image", "label_sc", "label_lesion"], spatial_size=spatial_size), + # Randomly crop samples of a specified size + RandCropByPosNegLabeld( + keys=["image", "label_sc", "label_lesion"], + label_key="label_sc", # cropping around the SC + spatial_size=roi_size, + pos=1, + neg=0, + num_samples=4, # if num_samples=4, then 4 samples/image are randomly generated + image_key="image", + image_threshold=0, + ), + # data-augmentation + # Note: we use simple transforms suitable for lesion seg + RandAffined(keys=["image", "label_lesion"], mode=(2, 1), prob=0.1, + rotate_range=(-20. / 360 * 2. * np.pi, 20. / 360 * 2. * np.pi), + # monai expects in radians + scale_range=(-0.2, 0.2), + translate_range=(-0.1, 0.1)), + RandSimulateLowResolutiond(keys=["image"], zoom_range=(0.5, 1.0), prob=0.2), + RandAdjustContrastd(keys=["image"], gamma=(0.5, 3.), prob=0.2), # this is monai's RandomGamma + RandBiasFieldd(keys=["image"], coeff_range=(0.0, 0.5), degree=3, prob=0.1), + RandGaussianSmoothd(keys=["image"], sigma_x=(0., 2.), sigma_y=(0., 2.), sigma_z=(0., 2.0), + prob=0.2), + RandFlipd(keys=["image", "label_lesion"], prob=0.2), + #AsDiscreted(keys=["label_sc", "label_lesion"], to_onehot=None, threshold_values=True, logit_thresh=0.5), + ] + ) + + return train_transforms + + +def define_finetune_val_transforms(spatial_size, roi_size): + """ + Define MONAI Transforms for Validation of the fine-tuned model + :args: spatial_size: spatial size of the input image, e.g. (64, 256, 256) + :args: roi_size: size of the sample to crop, e.g. (64, 64, 64) + """ + val_transforms = Compose( + [ + # Load image data and GT using the keys "image" and "label" + LoadImaged(keys=["image", "label_sc", "label_lesion"], image_only=False), + # Ensure that the channel dimension is the first dimension of the image tensor. + EnsureChannelFirstd(keys=["image", "label_sc", "label_lesion"]), + # Ensure that the image orientation is consistently RPI + Orientationd(keys=["image", "label_sc", "label_lesion"], axcodes="RPI"), + # Resample the images to a specified pixel spacing + # NOTE: spine interpolation with order=2 is spline, order=1 is linear + Spacingd(keys=["image", "label_sc", "label_lesion"], pixdim=(1.0, 1.0, 1.0), mode=(2, 1, 1)), + # Normalize the intensity values of the image + NormalizeIntensityd(keys=["image"], nonzero=False, channel_wise=False), + # Remove background pixels to focus on regions of interest. + CropForegroundd(keys=["image", "label_sc", "label_lesion"], source_key="image"), + # Pad the image to a specified spatial size if its size is smaller than the specified dimensions + ResizeWithPadOrCropd(keys=["image", "label_sc", "label_lesion"], spatial_size=spatial_size), + # Randomly crop samples of a specified size + RandCropByPosNegLabeld( + keys=["image", "label_sc", "label_lesion"], + label_key="label_sc", # cropping around the SC + spatial_size=roi_size, + pos=1, + neg=0, + num_samples=1, # if num_samples=1, then 1 samples/image are randomly generated + image_key="image", + image_threshold=0, + ), + #AsDiscreted(keys=["label_sc", "label_lesion"], to_onehot=None, threshold_values=True, logit_thresh=0.5), + ] + ) + + return val_transforms