diff --git a/Downstream_tasks/.DS_Store b/Downstream_tasks/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..543f0a00f010663143576d8fc03affd6c3dcb7f3 Binary files /dev/null and b/Downstream_tasks/.DS_Store differ diff --git a/Downstream_tasks/Classification/.DS_Store b/Downstream_tasks/Classification/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8c44415e91ec1bdea02ec4160c5ef3bc7d76de6e Binary files /dev/null and b/Downstream_tasks/Classification/.DS_Store differ diff --git a/Downstream_tasks/Classification/Cardio.py b/Downstream_tasks/Classification/Cardio.py new file mode 100644 index 0000000000000000000000000000000000000000..8cbb3c81fae72149cb30d67238cea9c9654455a8 --- /dev/null +++ b/Downstream_tasks/Classification/Cardio.py @@ -0,0 +1,1418 @@ +import os +from tqdm.auto import tqdm, trange +GPU_NUMBER = [0] +os.environ["CUDA_VISIBLE_DEVICES"] = ",".join([str(s) for s in GPU_NUMBER]) +os.environ["NCCL_DEBUG"] = "INFO" + +# imports +from collections import Counter +import seaborn as sns; sns.set() +from datasets import load_from_disk +from sklearn.metrics import accuracy_score, f1_score +from transformers import Trainer +from transformers.training_args import TrainingArguments +import pandas as pd +from datasets.utils.logging import disable_progress_bar, enable_progress_bar +from sklearn import preprocessing +from sklearn.metrics import ( + ConfusionMatrixDisplay, + accuracy_score, + auc, + confusion_matrix, + f1_score, + roc_curve, +) +from pathlib import Path + +import sys +# sys.path.append('../Geneformer') +from geneformer import DataCollatorForCellClassification +from datasets import load_from_disk +import sys +from tqdm.notebook import tqdm +import seaborn as sns +import matplotlib.pyplot as plt +from geneformer.pretrainer import token_dictionary +import datetime +import time +import pickle +import random +import subprocess +import numpy as np +import pytz +import torch +from datasets import load_from_disk, Dataset +from transformers import (BertConfig, BertForMaskedLM, TrainingArguments, TrainerCallback, + Trainer, BertModel, BertPreTrainedModel, BertForSequenceClassification, BertForTokenClassification) +from geneformer import GeneformerPretrainer +from torch import Tensor +from transformers.modeling_outputs import MaskedLMOutput +from transformers.models.bert.modeling_bert import BertLMPredictionHead, BertOnlyMLMHead, BertPredictionHeadTransform +from transformers.activations import ACT2FN +from typing import List, Optional, Tuple, Union +import torch.nn.functional as F + +macro_f1_list = [] +acc_list = [] + +iter_step = 2 + +class CustomBertForMaskedLM(BertPreTrainedModel): + _keys_to_ignore_on_load_missing = ["cls.predictions.decoder.weight", "cls.predictions.decoder.bias"] + _tied_weights_keys = ["decoder.weight", "bert.embeddings.word_embeddings.weight"] + + def __init__(self, config): + super().__init__(config) + self.bert = BertModel(config, add_pooling_layer=False) + self.transform = BertPredictionHeadTransform(config) + + self.decoder = torch.nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = torch.nn.Parameter(torch.zeros(config.vocab_size)) + + # Initialize weights + self.init_weights() + + # Tie weights automatically + self.tie_weights() + + # self.post_init() + + def tie_weights(self): + """ + Ties the weights between the input embeddings and output decoder weights. + """ + self.decoder.weight = self.bert.embeddings.word_embeddings.weight + + def probability_convert(self, probs: Tensor, input_ids: Tensor, labels: Tensor) -> Tensor: + device = probs.device + batch_size, seq_length, vocab_size = probs.size() + _, input_seq_length = input_ids.size() + non_mask = labels == -100 + non_mask_indices = non_mask.nonzero(as_tuple=True) + known_gene_indices = input_ids[non_mask] + + # Generate (1-p) matrix whiel assigning all known genes in the beginning + zeros = torch.zeros((batch_size, 1, vocab_size), device=device) + zeros[non_mask_indices[0], 0, known_gene_indices] = 1.0 + probs_shifted = torch.cat((zeros, probs[:, :-1, :]), dim=1) + inv_probs_shifted = 1 - probs_shifted + + # Cumulative product to get (1-p_1)*(1-p_2)*...*(p_i) + cumprod_inv_probs = torch.cumprod(inv_probs_shifted, dim=1) + modified_probs = probs * cumprod_inv_probs + + # # Since we are assigning probabilities for already known genes, + # # (1-p_1)*(1-p_2)*...*(p_i) for these genes can result in 0, due to hard assignment of probs to be 1 + # # Add 1e-18 to avoid dividing modified probs by 0 + # # During dubugging stage, some issues occurred in the normalization step. + # # Since probabilities in each position do not necessarily need to sum up to one, leave out normalization. + normalized_probs = modified_probs.sum(dim=-1, keepdim=True).clamp(min=1e-18) + modified_probs = modified_probs / normalized_probs # Normalization after cumulative production + + return modified_probs + + def assign_known_gene_probs(self, probs: Tensor, input_ids: Tensor, labels: Tensor) -> Tensor: + + device = probs.device + batch_size, seq_length, vocab_size = probs.size() + _, input_seq_length = input_ids.size() + + # Truncate `labels` to match the length of `input_ids` along the sequence dimension + truncated_labels = labels[:, :input_seq_length] + + non_mask = truncated_labels == -100 + non_mask_indices = non_mask.nonzero(as_tuple=True) + + ones = torch.ones((batch_size, seq_length, vocab_size), device=device) + zeros = torch.zeros((batch_size, seq_length, vocab_size), device=device) + + known_gene_indices = input_ids[non_mask] + + ones[non_mask_indices[0], non_mask_indices[1], :] = 0.0 + zeros[non_mask_indices[0], non_mask_indices[1], known_gene_indices] = 1.0 + + # Modify already known genes' probabilities using the one-hot tensor + modified_probs = probs * ones + modified_probs = modified_probs + zeros + + # Do the normalization + modified_probs = modified_probs / modified_probs.sum(dim=-1, keepdim=True).clamp(min=1e-18) # Normalize + + return modified_probs + + def forward( + self, + input_ids: Tensor | None = None, + attention_mask: Tensor | None = None, + token_type_ids: Tensor | None = None, + position_ids: Tensor | None = None, + head_mask: Tensor | None = None, + inputs_embeds: Tensor | None = None, + encoder_hidden_states: Tensor | None = None, + encoder_attention_mask: Tensor | None = None, + labels: Tensor | None = None, + output_attentions: bool | None = None, + output_hidden_states: bool | None = None, + return_dict: bool | None = None) -> Union[Tuple[torch.Tensor], MaskedLMOutput]: + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + token_type_ids=token_type_ids, + position_ids=position_ids, + head_mask=head_mask, + inputs_embeds=inputs_embeds, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + hidden_states = outputs[0] + hidden_transform = self.transform(hidden_states) + logits = self.decoder(hidden_transform) + self.bias + + probs = F.softmax(logits, dim=-1) + + # Probability manipulations to avoid repeats from already known genes + probs = self.assign_known_gene_probs(probs, input_ids, labels) + convert_probs = self.probability_convert(probs, input_ids, labels) + assigned_probs = self.assign_known_gene_probs(convert_probs, input_ids, labels) + + masked_lm_loss = None + if labels is not None: + probs_flat = assigned_probs.view(-1, self.config.vocab_size) + labels_flat = labels.view(-1) + mask = (labels != -100).float().view(-1) + + # Compute masked cross-entropy loss + masked_lm_loss = -torch.log(torch.clamp(probs_flat[torch.arange(len(labels_flat)), labels_flat], min=1e-18)) * mask + masked_lm_loss = masked_lm_loss.sum() / mask.sum() + + else: + loss = None + + if not return_dict: + output = (assigned_probs,) + outputs[2:] + return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output + + return MaskedLMOutput( + loss=masked_lm_loss, + logits=assigned_probs, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs): + input_shape = input_ids.shape + effective_batch_size = input_shape[0] + + # add a dummy token + if self.config.pad_token_id is None: + raise ValueError("The PAD token should be defined for generation") + + attention_mask = torch.cat([attention_mask, attention_mask.new_zeros((attention_mask.shape[0], 1))], dim=-1) + dummy_token = torch.full( + (effective_batch_size, 1), self.config.pad_token_id, dtype=torch.long, device=input_ids.device + ) + input_ids = torch.cat([input_ids, dummy_token], dim=1) + + return {"input_ids": input_ids, "attention_mask": attention_mask} + +def prepare_data( + input_data_file, + output_directory, + output_prefix, + split_id_dict=None, + test_size=None, + attr_to_split=None, + attr_to_balance=None, + max_trials=100, + pval_threshold=0.1, +): + """ + Prepare data for cell state or gene classification. + + **Parameters** + + input_data_file : Path + | Path to directory containing .dataset input + output_directory : Path + | Path to directory where prepared data will be saved + output_prefix : str + | Prefix for output file + split_id_dict : None, dict + | Dictionary of IDs for train and test splits + | Three-item dictionary with keys: attr_key, train, test + | attr_key: key specifying name of column in .dataset that contains the IDs for the data splits + | train: list of IDs in the attr_key column to include in the train split + | test: list of IDs in the attr_key column to include in the test split + | For example: {"attr_key": "individual", + | "train": ["patient1", "patient2", "patient3", "patient4"], + | "test": ["patient5", "patient6"]} + test_size : None, float + | Proportion of data to be saved separately and held out for test set + | (e.g. 0.2 if intending hold out 20%) + | If None, will inherit from split_sizes["test"] from Classifier + | The training set will be further split to train / validation in self.validate + | Note: only available for CellClassifiers + attr_to_split : None, str + | Key for attribute on which to split data while balancing potential confounders + | e.g. "patient_id" for splitting by patient while balancing other characteristics + | Note: only available for CellClassifiers + attr_to_balance : None, list + | List of attribute keys on which to balance data while splitting on attr_to_split + | e.g. ["age", "sex"] for balancing these characteristics while splitting by patient + | Note: only available for CellClassifiers + max_trials : None, int + | Maximum number of trials of random splitting to try to achieve balanced other attributes + | If no split is found without significant (p<0.05) differences in other attributes, will select best + | Note: only available for CellClassifiers + pval_threshold : None, float + | P-value threshold to use for attribute balancing across splits + | E.g. if set to 0.1, will accept trial if p >= 0.1 for all attributes in attr_to_balance + """ + + if test_size is None: + test_size = oos_test_size + + # prepare data and labels for classification + data = load_and_filter(filter_data, nproc, input_data_file) + + if classifier == "cell": + if "label" in data.features: + logger.error( + "Column name 'label' must be reserved for class IDs. Please rename column." + ) + raise + elif classifier == "gene": + if "labels" in data.features: + logger.error( + "Column name 'labels' must be reserved for class IDs. Please rename column." + ) + raise + + if (attr_to_split is not None) and (attr_to_balance is None): + logger.error( + "Splitting by attribute while balancing confounders requires both attr_to_split and attr_to_balance to be defined." + ) + raise + + if not isinstance(attr_to_balance, list): + attr_to_balance = [attr_to_balance] + + if classifier == "cell": + # remove cell states representing < rare_threshold of cells + data = remove_rare( + data, rare_threshold, cell_state_dict["state_key"], nproc + ) + # downsample max cells and max per class + data = downsample_and_shuffle( + data, max_ncells, None, cell_state_dict + ) + # rename cell state column to "label" + data = rename_cols(data, cell_state_dict["state_key"]) + + # convert classes to numerical labels and save as id_class_dict + # of note, will label all genes in gene_class_dict + # if (cross-)validating, genes will be relabeled in column "labels" for each split + # at the time of training with Classifier.validate + data, id_class_dict = label_classes( + classifier, data, None, nproc + ) + + # save id_class_dict for future reference + id_class_output_path = ( + Path(output_directory) / f"{output_prefix}_id_class_dict" + ).with_suffix(".pkl") + with open(id_class_output_path, "wb") as f: + pickle.dump(id_class_dict, f) + + if split_id_dict is not None: + data_dict = dict() + data_dict["train"] = filter_by_dict( + data, {split_id_dict["attr_key"]: split_id_dict["train"]}, nproc + ) + data_dict["test"] = filter_by_dict( + data, {split_id_dict["attr_key"]: split_id_dict["test"]}, nproc + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + elif (test_size is not None) and (classifier == "cell"): + if 1 > test_size > 0: + if attr_to_split is None: + data_dict = data.train_test_split( + test_size=test_size, + stratify_by_column=None, + seed=42, + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + else: + data_dict, balance_df = cu.balance_attr_splits( + data, + attr_to_split, + attr_to_balance, + test_size, + max_trials, + pval_threshold, + cell_state_dict["state_key"], + nproc, + ) + balance_df.to_csv( + f"{output_directory}/{output_prefix}_train_test_balance_df.csv" + ) + train_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_train" + ).with_suffix(".dataset") + test_data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled_test" + ).with_suffix(".dataset") + data_dict["train"].save_to_disk(str(train_data_output_path)) + data_dict["test"].save_to_disk(str(test_data_output_path)) + else: + data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled" + ).with_suffix(".dataset") + data.save_to_disk(str(data_output_path)) + print(data_output_path) + else: + data_output_path = ( + Path(output_directory) / f"{output_prefix}_labeled" + ).with_suffix(".dataset") + data.save_to_disk(str(data_output_path)) + +def load_and_filter(filter_data, nproc, input_data_file): + data = load_from_disk(input_data_file) + if filter_data is not None: + data = filter_by_dict(data, filter_data, nproc) + return data +# get number of classes for classifier +def get_num_classes(id_class_dict): + return len(set(id_class_dict.values())) + +def filter_by_dict(data, filter_data, nproc): + for key, value in filter_data.items(): + + def filter_data_by_criteria(example): + return example[key] in value + + data = data.filter(filter_data_by_criteria, num_proc=nproc) + if len(data) == 0: + logger.error("No cells remain after filtering. Check filtering criteria.") + raise + return data +def remove_rare(data, rare_threshold, label, nproc): + if rare_threshold > 0: + total_cells = len(data) + label_counter = Counter(data[label]) + nonrare_label_dict = { + label: [k for k, v in label_counter if (v / total_cells) > rare_threshold] + } + data = filter_by_dict(data, nonrare_label_dict, nproc) + return data +def downsample_and_shuffle(data, max_ncells, max_ncells_per_class, cell_state_dict): + data = data.shuffle(seed=42) + num_cells = len(data) + # if max number of cells is defined, then subsample to this max number + if max_ncells is not None: + if num_cells > max_ncells: + data = data.select([i for i in range(max_ncells)]) + if max_ncells_per_class is not None: + class_labels = data[cell_state_dict["state_key"]] + random.seed(42) + subsample_indices = subsample_by_class(class_labels, max_ncells_per_class) + data = data.select(subsample_indices) + return data +def rename_cols(data, state_key): + data = data.rename_column(state_key, "label") + return data +def label_classes(classifier, data, gene_class_dict, nproc): + if classifier == "cell": + label_set = set(data["label"]) + elif classifier == "gene": + # remove cells without any of the target genes + def if_contains_label(example): + a = pu.flatten_list(gene_class_dict.values()) + b = example["input_ids"] + return not set(a).isdisjoint(b) + + data = data.filter(if_contains_label, num_proc=nproc) + label_set = gene_class_dict.keys() + + if len(data) == 0: + logger.error( + "No cells remain after filtering for target genes. Check target gene list." + ) + raise + + class_id_dict = dict(zip(label_set, [i for i in range(len(label_set))])) + id_class_dict = {v: k for k, v in class_id_dict.items()} + + def classes_to_ids(example): + if classifier == "cell": + example["label"] = class_id_dict[example["label"]] + elif classifier == "gene": + example["labels"] = label_gene_classes( + example, class_id_dict, gene_class_dict + ) + return example + + data = data.map(classes_to_ids, num_proc=nproc) + return data, id_class_dict + +def train_classifier( + model_directory, + num_classes, + train_data, + eval_data, + output_directory, + predict=False, + classifier='cell', + no_eval=False, + quantize = False, + freeze_layers=2, + ): + """ + Fine-tune model for cell state or gene classification. + + **Parameters** + + model_directory : Path + | Path to directory containing model + num_classes : int + | Number of classes for classifier + train_data : Dataset + | Loaded training .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + eval_data : None, Dataset + | (Optional) Loaded evaluation .dataset input + | For cell classifier, labels in column "label". + | For gene classifier, labels in column "labels". + output_directory : Path + | Path to directory where fine-tuned model will be saved + predict : bool + | Whether or not to save eval predictions from trainer + """ + + ##### Validate and prepare data ##### + train_data, eval_data = validate_and_clean_cols( + train_data, eval_data, classifier + ) + + if (no_eval is True) and (eval_data is not None): + logger.warning( + "no_eval set to True; model will be trained without evaluation." + ) + eval_data = None + + if (classifier == "gene") and (predict is True): + logger.warning( + "Predictions during training not currently available for gene classifiers; setting predict to False." + ) + predict = False + + # ensure not overwriting previously saved model + saved_model_test = os.path.join(output_directory, "pytorch_model.bin") + if os.path.isfile(saved_model_test) is True: + logger.error("Model already saved to this designated output directory.") + raise + # make output directory + # subprocess.call(f"mkdir {output_directory}", shell=True) + os.makedirs(output_dir, exist_ok=True) + + ##### Load model and training args ##### + model = load_model( + "CellClassifier", + num_classes, + model_directory, + "train", + quantize=quantize, + ) + ############# + pretrained_model = CustomBertForMaskedLM.from_pretrained(model_directory) + # Extract the word embeddings from the pretrained model + pretrained_word_embeddings = pretrained_model.bert.embeddings.word_embeddings.weight.clone() + model.bert.embeddings.word_embeddings.load_state_dict({"weight": pretrained_word_embeddings}) + ############ + def_training_args, def_freeze_layers = get_default_train_args( + model, classifier, train_data, output_directory + ) + + if training_args is not None: + def_training_args.update(training_args) + logging_steps = round( + len(train_data) / def_training_args["per_device_train_batch_size"] / 10 + ) + def_training_args["logging_steps"] = logging_steps + def_training_args["output_dir"] = output_directory + if eval_data is None: + def_training_args["evaluation_strategy"] = "no" + def_training_args["load_best_model_at_end"] = False + training_args_init = TrainingArguments(**def_training_args) + + if freeze_layers is not None: + def_freeze_layers = freeze_layers + + if def_freeze_layers > 0: + modules_to_freeze = model.bert.encoder.layer[:def_freeze_layers] + for module in modules_to_freeze: + for param in module.parameters(): + param.requires_grad = False + + ##### Fine-tune the model ##### + # define the data collator + if classifier == "cell": + data_collator = DataCollatorForCellClassification() + elif self.classifier == "gene": + data_collator = DataCollatorForGeneClassification() + + # create the trainer + trainer = Trainer( + model=model, + args=training_args_init, + data_collator=data_collator, + train_dataset=train_data, + eval_dataset=eval_data, + compute_metrics=compute_metrics, + ) + + # train the classifier + trainer.train() + trainer.save_model(output_directory) + if predict is True: + # make eval predictions and save predictions and metrics + predictions = trainer.predict(eval_data) + prediction_output_path = f"{output_directory}/predictions.pkl" + with open(prediction_output_path, "wb") as f: + pickle.dump(predictions, f) + trainer.save_metrics("eval", predictions.metrics) + return trainer + +def validate_and_clean_cols(train_data, eval_data, classifier): + # validate that data has expected label column and remove others + if classifier == "cell": + label_col = "label" + elif classifier == "gene": + label_col = "labels" + + cols_to_keep = [label_col] + ["input_ids", "length"] + if label_col not in train_data.column_names: + logger.error(f"train_data must contain column {label_col} with class labels.") + raise + else: + train_data = remove_cols(train_data, cols_to_keep) + + if eval_data is not None: + if label_col not in eval_data.column_names: + logger.error( + f"eval_data must contain column {label_col} with class labels." + ) + raise + else: + eval_data = remove_cols(eval_data, cols_to_keep) + return train_data, eval_data + +def remove_cols(data, cols_to_keep): + other_cols = list(data.features.keys()) + other_cols = [ele for ele in other_cols if ele not in cols_to_keep] + data = data.remove_columns(other_cols) + return data + +def load_model(model_type, num_classes, model_directory, mode, quantize=False): + if model_type == "MTLCellClassifier-Quantized": + model_type = "MTLCellClassifier" + quantize = True + + output_hidden_states = (mode == "eval") + + # Quantization logic + if quantize: + if model_type == "MTLCellClassifier": + quantize_config = BitsAndBytesConfig(load_in_8bit=True) + peft_config = None + else: + quantize_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.bfloat16, + ) + peft_config = LoraConfig( + lora_alpha=128, + lora_dropout=0.1, + r=64, + bias="none", + task_type="TokenClassification", + ) + else: + quantize_config = None + peft_config = None + + # Model class selection + model_classes = { + "Pretrained": BertForMaskedLM, + "GeneClassifier": BertForTokenClassification, + "CellClassifier": BertForSequenceClassification, + "MTLCellClassifier": BertForMaskedLM + } + + model_class = model_classes.get(model_type) + if not model_class: + raise ValueError(f"Unknown model type: {model_type}") + + # Model loading + model_args = { + "pretrained_model_name_or_path": model_directory, + "output_hidden_states": output_hidden_states, + "output_attentions": False, + } + + if model_type != "Pretrained": + model_args["num_labels"] = num_classes + + if quantize_config: + model_args["quantization_config"] = quantize_config + + # Load the model + model = model_class.from_pretrained(**model_args) + ########################### + + if mode == "eval": + model.eval() + + # Handle device placement and PEFT + if not quantize: + # Only move non-quantized models + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + model = model.to(device) + elif peft_config: + # Apply PEFT for quantized models (except MTLCellClassifier) + model.enable_input_require_grads() + model = get_peft_model(model, peft_config) + + return model + +def get_default_train_args(model, classifier, data, output_dir): + num_layers = quant_layers(model) + freeze_layers_get = 0 + batch_size = 12 + if classifier == "cell": + epochs = 10 + evaluation_strategy = "epoch" + load_best_model_at_end = True + else: + epochs = 1 + evaluation_strategy = "no" + load_best_model_at_end = False + + if num_layers == 6: + default_training_args = { + "learning_rate": 5e-5, + "lr_scheduler_type": "linear", + "warmup_steps": 500, + "per_device_train_batch_size": batch_size, + "per_device_eval_batch_size": batch_size, + } + else: + default_training_args = { + "per_device_train_batch_size": batch_size, + "per_device_eval_batch_size": batch_size, + } + + training_args = { + "num_train_epochs": epochs, + "do_train": True, + "do_eval": True, + "evaluation_strategy": evaluation_strategy, + "logging_steps": np.floor(len(data) / batch_size / 8), # 8 evals per epoch + "save_strategy": "epoch", + "group_by_length": False, + "length_column_name": "length", + "disable_tqdm": False, + "weight_decay": 0.001, + "load_best_model_at_end": load_best_model_at_end, + } + training_args.update(default_training_args) + + return training_args, freeze_layers_get + +def quant_layers(model): + layer_nums = [] + for name, parameter in model.named_parameters(): + if "layer" in name: + layer_nums += [int(name.split("layer.")[1].split(".")[0])] + return int(max(layer_nums)) + 1 + +def compute_metrics(pred): + labels = pred.label_ids + preds = pred.predictions.argmax(-1) + # calculate accuracy and macro f1 using sklearn's function + acc = accuracy_score(labels, preds) + macro_f1 = f1_score(labels, preds, average='macro') + weighted_f1 = f1_score(labels, preds, average='weighted') + return { + 'accuracy': acc, + 'macro_f1': macro_f1, + 'weighted_f1': weighted_f1 + } +def evaluate_model( + model, + num_classes, + id_class_dict, + eval_data, + predict=False, + output_directory=None, + output_prefix=None, +): + """ + Evaluate the fine-tuned model. + + **Parameters** + + model : nn.Module + | Loaded fine-tuned model (e.g. trainer.model) + num_classes : int + | Number of classes for classifier + id_class_dict : dict + | Loaded _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + eval_data : Dataset + | Loaded evaluation .dataset input + predict : bool + | Whether or not to save eval predictions + output_directory : Path + | Path to directory where eval data will be saved + output_prefix : str + | Prefix for output files + """ + + ##### Evaluate the model ##### + labels = id_class_dict.keys() + y_pred, y_true, logits_list = classifier_predict( + model, classifier, eval_data, 100 + ) + conf_mat, macro_f1, acc, roc_metrics = get_metrics( + y_pred, y_true, logits_list, num_classes, labels + ) + if predict is True: + pred_dict = { + "pred_ids": y_pred, + "label_ids": y_true, + "predictions": logits_list, + } + pred_dict_output_path = ( + Path(output_directory) / f"{output_prefix}_pred_dict" + ).with_suffix(".pkl") + with open(pred_dict_output_path, "wb") as f: + pickle.dump(pred_dict, f) + return { + "conf_mat": conf_mat, + "macro_f1": macro_f1, + "acc": acc, + "roc_metrics": roc_metrics, + } + +def classifier_predict(model, classifier_type, evalset, forward_batch_size): + if classifier_type == "gene": + label_name = "labels" + elif classifier_type == "cell": + label_name = "label" + + predict_logits = [] + predict_labels = [] + model.eval() + + # ensure there is at least 2 examples in each batch to avoid incorrect tensor dims + evalset_len = len(evalset) + max_divisible = find_largest_div(evalset_len, forward_batch_size) + if len(evalset) - max_divisible == 1: + evalset_len = max_divisible + + max_evalset_len = max(evalset.select([i for i in range(evalset_len)])["length"]) + + disable_progress_bar() # disable progress bar for preprocess_classifier_batch mapping + for i in trange(0, evalset_len, forward_batch_size): + max_range = min(i + forward_batch_size, evalset_len) + batch_evalset = evalset.select([i for i in range(i, max_range)]) + padded_batch = preprocess_classifier_batch( + batch_evalset, max_evalset_len, label_name + ) + padded_batch.set_format(type="torch") + + input_data_batch = padded_batch["input_ids"] + attn_msk_batch = padded_batch["attention_mask"] + label_batch = padded_batch[label_name] + with torch.no_grad(): + outputs = model( + input_ids=input_data_batch.to("cuda"), + attention_mask=attn_msk_batch.to("cuda"), + labels=label_batch.to("cuda"), + ) + predict_logits += [torch.squeeze(outputs.logits.to("cpu"))] + predict_labels += [torch.squeeze(label_batch.to("cpu"))] + + enable_progress_bar() + logits_by_cell = torch.cat(predict_logits) + last_dim = len(logits_by_cell.shape) - 1 + all_logits = logits_by_cell.reshape(-1, logits_by_cell.shape[last_dim]) + labels_by_cell = torch.cat(predict_labels) + all_labels = torch.flatten(labels_by_cell) + logit_label_paired = [ + item + for item in list(zip(all_logits.tolist(), all_labels.tolist())) + if item[1] != -100 + ] + y_pred = [vote(item[0]) for item in logit_label_paired] + y_true = [item[1] for item in logit_label_paired] + logits_list = [item[0] for item in logit_label_paired] + return y_pred, y_true, logits_list + +def find_largest_div(N, K): + rem = N % K + if rem == 0: + return N + else: + return N - rem +def preprocess_classifier_batch(cell_batch, max_len, label_name): + if max_len is None: + max_len = max([len(i) for i in cell_batch["input_ids"]]) + + def pad_label_example(example): + example[label_name] = np.pad( + example[label_name], + (0, max_len - len(example["input_ids"])), + mode="constant", + constant_values=-100, + ) + example["input_ids"] = np.pad( + example["input_ids"], + (0, max_len - len(example["input_ids"])), + mode="constant", + constant_values=gene_token_dict.get(""), + ) + example["attention_mask"] = ( + example["input_ids"] != gene_token_dict.get("") + ).astype(int) + return example + + padded_batch = cell_batch.map(pad_label_example) + return padded_batch +def vote(logit_list): + m = max(logit_list) + logit_list.index(m) + indices = [i for i, x in enumerate(logit_list) if x == m] + if len(indices) > 1: + return "tie" + else: + return indices[0] +def py_softmax(vector): + e = np.exp(vector) + return e / e.sum() +def get_metrics(y_pred, y_true, logits_list, num_classes, labels): + conf_mat = confusion_matrix(y_true, y_pred, labels=list(labels)) + macro_f1 = f1_score(y_true, y_pred, average="macro") + acc = accuracy_score(y_true, y_pred) + roc_metrics = None # roc metrics not reported for multiclass + if num_classes == 2: + y_score = [py_softmax(item)[1] for item in logits_list] + fpr, tpr, _ = roc_curve(y_true, y_score) + mean_fpr = np.linspace(0, 1, 100) + interp_tpr = np.interp(mean_fpr, fpr, tpr) + interp_tpr[0] = 0.0 + tpr_wt = len(tpr) + roc_auc = auc(fpr, tpr) + roc_metrics = { + "fpr": fpr, + "tpr": tpr, + "interp_tpr": interp_tpr, + "auc": roc_auc, + "tpr_wt": tpr_wt, + } + return conf_mat, macro_f1, acc, roc_metrics +def evaluate_saved_model( + model_directory, + id_class_dict_file, + test_data_file, + output_directory, + output_prefix, + predict=True, +): + """ + Evaluate the fine-tuned model. + + **Parameters** + + model_directory : Path + | Path to directory containing model + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + test_data_file : Path + | Path to directory containing test .dataset + output_directory : Path + | Path to directory where eval data will be saved + output_prefix : str + | Prefix for output files + predict : bool + | Whether or not to save eval predictions + """ + + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + + # get number of classes for classifier + num_classes = get_num_classes(id_class_dict) + + # load previously filtered and prepared data + test_data = load_and_filter(None, nproc, test_data_file) + + # load previously fine-tuned model + model = load_model( + "CellClassifier", + num_classes, + model_directory, + "eval", + quantize=quantize, + ) + + # evaluate the model + result = evaluate_model( + model, + num_classes, + id_class_dict, + test_data, + predict=predict, + output_directory=output_directory, + output_prefix="CellClassifier", + ) + + all_conf_mat_df = pd.DataFrame( + result["conf_mat"], + columns=id_class_dict.values(), + index=id_class_dict.values(), + ) + all_metrics = { + "conf_matrix": all_conf_mat_df, + "macro_f1": result["macro_f1"], + "acc": result["acc"], + } + all_roc_metrics = None # roc metrics not reported for multiclass + + if num_classes == 2: + mean_fpr = np.linspace(0, 1, 100) + mean_tpr = result["roc_metrics"]["interp_tpr"] + all_roc_auc = result["roc_metrics"]["auc"] + all_roc_metrics = { + "mean_tpr": mean_tpr, + "mean_fpr": mean_fpr, + "all_roc_auc": all_roc_auc, + } + all_metrics["all_roc_metrics"] = all_roc_metrics + test_metrics_output_path = ( + Path(output_directory) / f"{output_prefix}_test_metrics_dict" + ).with_suffix(".pkl") + with open(test_metrics_output_path, "wb") as f: + pickle.dump(all_metrics, f) + + return all_metrics + +def plot_conf_mat( + conf_mat_dict, + output_directory, + output_prefix, + custom_class_order=None, +): + """ + Plot confusion matrix results of evaluating the fine-tuned model. + + **Parameters** + + conf_mat_dict : dict + | Dictionary of model_name : confusion_matrix_DataFrame + | (all_metrics["conf_matrix"] from self.validate) + output_directory : Path + | Path to directory where plots will be saved + output_prefix : str + | Prefix for output file + custom_class_order : None, list + | List of classes in custom order for plots. + | Same order will be used for all models. + """ + + for model_name in conf_mat_dict.keys(): + plot_confusion_matrix( + conf_mat_dict[model_name], + model_name, + output_directory, + output_prefix, + custom_class_order, + ) +def plot_confusion_matrix( + conf_mat_df, title, output_dir, output_prefix, custom_class_order +): + fig = plt.figure() + fig.set_size_inches(10, 10) + sns.set(font_scale=1) + sns.set_style("whitegrid", {"axes.grid": False}) + if custom_class_order is not None: + conf_mat_df = conf_mat_df.reindex( + index=custom_class_order, columns=custom_class_order + ) + display_labels = generate_display_labels(conf_mat_df) + conf_mat = preprocessing.normalize(conf_mat_df.to_numpy(), norm="l1") + display = ConfusionMatrixDisplay( + confusion_matrix=conf_mat, display_labels=display_labels + ) + display.plot(cmap="Blues", values_format=".2g") + plt.title(title) + plt.show() + + output_file = (Path(output_dir) / f"{output_prefix}_conf_mat").with_suffix(".pdf") + display.figure_.savefig(output_file, bbox_inches="tight") +def generate_display_labels(conf_mat_df): + display_labels = [] + i = 0 + for label in conf_mat_df.index: + display_labels += [f"{label}\nn={conf_mat_df.iloc[i,:].sum():.0f}"] + i = i + 1 + return display_labels + +def plot_predictions( + predictions_file, + id_class_dict_file, + title, + output_directory, + output_prefix, + custom_class_order=None, + kwargs_dict=None, +): + """ + Plot prediction results of evaluating the fine-tuned model. + + **Parameters** + + predictions_file : path + | Path of model predictions output to plot + | (saved output from self.validate if predict_eval=True) + | (or saved output from self.evaluate_saved_model) + id_class_dict_file : Path + | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data + | (dictionary of format: numerical IDs: class_labels) + title : str + | Title for legend containing class labels. + output_directory : Path + | Path to directory where plots will be saved + output_prefix : str + | Prefix for output file + custom_class_order : None, list + | List of classes in custom order for plots. + | Same order will be used for all models. + kwargs_dict : None, dict + | Dictionary of kwargs to pass to plotting function. + """ + # load predictions + with open(predictions_file, "rb") as f: + predictions = pickle.load(f) + + # load numerical id to class dictionary (id:class) + with open(id_class_dict_file, "rb") as f: + id_class_dict = pickle.load(f) + + if isinstance(predictions, dict): + if all( + [ + key in predictions.keys() + for key in ["pred_ids", "label_ids", "predictions"] + ] + ): + # format is output from self.evaluate_saved_model + predictions_logits = np.array(predictions["predictions"]) + true_ids = predictions["label_ids"] + else: + # format is output from self.validate if predict_eval=True + predictions_logits = predictions.predictions + true_ids = predictions.label_ids + + num_classes = len(id_class_dict.keys()) + num_predict_classes = predictions_logits.shape[1] + assert num_classes == num_predict_classes + classes = id_class_dict.values() + true_labels = [id_class_dict[idx] for idx in true_ids] + predictions_df = pd.DataFrame(predictions_logits, columns=classes) + if custom_class_order is not None: + predictions_df = predictions_df.reindex(columns=custom_class_order) + predictions_df["true"] = true_labels + custom_dict = dict(zip(classes, [i for i in range(len(classes))])) + if custom_class_order is not None: + custom_dict = dict( + zip(custom_class_order, [i for i in range(len(custom_class_order))]) + ) + predictions_df = predictions_df.sort_values( + by=["true"], key=lambda x: x.map(custom_dict) + ) + + plot_predictions_eu( + predictions_df, title, output_directory, output_prefix, kwargs_dict + ) +def plot_predictions_eu(predictions_df, title, output_dir, output_prefix, kwargs_dict): + sns.set(font_scale=2) + plt.figure(figsize=(10, 10), dpi=150) + label_colors, label_color_dict = make_colorbar(predictions_df, "true") + predictions_df = predictions_df.drop(columns=["true"]) + predict_colors_list = [label_color_dict[label] for label in predictions_df.columns] + predict_label_list = [label for label in predictions_df.columns] + predict_colors = pd.DataFrame( + pd.Series(predict_colors_list, index=predict_label_list), columns=["predicted"] + ) + + default_kwargs_dict = { + "row_cluster": False, + "col_cluster": False, + "row_colors": label_colors, + "col_colors": predict_colors, + "linewidths": 0, + "xticklabels": False, + "yticklabels": False, + "center": 0, + "cmap": "vlag", + } + + if kwargs_dict is not None: + default_kwargs_dict.update(kwargs_dict) + g = sns.clustermap(predictions_df, **default_kwargs_dict) + + plt.setp(g.ax_row_colors.get_xmajorticklabels(), rotation=45, ha="right") + + for label_color in list(label_color_dict.keys()): + g.ax_col_dendrogram.bar( + 0, 0, color=label_color_dict[label_color], label=label_color, linewidth=0 + ) + + g.ax_col_dendrogram.legend( + title=f"{title}", + loc="lower center", + ncol=4, + bbox_to_anchor=(0.5, 1), + facecolor="white", + ) + + output_file = (Path(output_dir) / f"{output_prefix}_pred").with_suffix(".pdf") + plt.savefig(output_file, bbox_inches="tight") +def make_colorbar(embs_df, label): + labels = list(embs_df[label]) + + cell_type_colors = gen_heatmap_class_colors(labels, embs_df) + label_colors = pd.DataFrame(cell_type_colors, columns=[label]) + + # create dictionary for colors and classes + label_color_dict = gen_heatmap_class_dict(labels, label_colors[label]) + return label_colors, label_color_dict +def gen_heatmap_class_colors(labels, df): + pal = sns.cubehelix_palette( + len(Counter(labels).keys()), + light=0.9, + dark=0.1, + hue=1, + reverse=True, + start=1, + rot=-2, + ) + lut = dict(zip(map(str, Counter(labels).keys()), pal)) + colors = pd.Series(labels, index=df.index).map(lut) + return colors +def gen_heatmap_class_dict(classes, label_colors_series): + class_color_dict_df = pd.DataFrame( + {"classes": classes, "color": label_colors_series} + ) + class_color_dict_df = class_color_dict_df.drop_duplicates(subset=["classes"]) + return dict(zip(class_color_dict_df["classes"], class_color_dict_df["color"])) + + +for i in range(iter_step): + + model_directory = "model path" + + corpus_dir = "Pretrain_data" + with open(corpus_dir + "/token_dictionary.pkl", "rb") as fp: + gene_token_dict = pickle.load(fp) + token_gene_dict = {v: k for k, v in gene_token_dict.items()} + + filter_data_dict={"cell_type":["Cardiomyocyte1","Cardiomyocyte2","Cardiomyocyte3"]} + training_args = { + "num_train_epochs": 0.9, + "learning_rate": 0.000804, + "lr_scheduler_type": "polynomial", + "warmup_steps": 1812, + "weight_decay":0.258828, + "per_device_train_batch_size": 12, + "seed": 73, + } + + cell_state_dict = {"state_key": "disease", "states": "all"} + classifier='cell' + filter_data=filter_data_dict + split_sizes={"train": 0.8, "valid": 0.1, "test": 0.1} + train_size = split_sizes["train"] + valid_size = split_sizes["valid"] + oos_test_size = split_sizes["test"] + max_ncells=None + freeze_layers = 2 + num_crossval_splits = 1 + forward_batch_size=200 + nproc=16 + rare_threshold=0 + quantize=None + + + train_ids = ["1447", "1600", "1462", "1558", "1300", "1508", "1358", "1678", "1561", "1304", "1610", "1430", "1472", "1707", "1726", "1504", "1425", "1617", "1631", "1735", "1582", "1722", "1622", "1630", "1290", "1479", "1371", "1549", "1515"] + eval_ids = ["1422", "1510", "1539", "1606", "1702"] + test_ids = ["1437", "1516", "1602", "1685", "1718"] + + train_test_id_split_dict = {"attr_key": "individual", + "train": train_ids+eval_ids, + "test": test_ids} + train_valid_id_split_dict = {"attr_key": "individual", + "train": train_ids, + "eval": eval_ids} + + # define output directory path + current_date = datetime.datetime.now() + datestamp = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}{current_date.strftime('%X').replace(':','')}" + datestamp_min = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}" + output_directory = "output path" + + if output_directory[-1:] != "/": # add slash for dir if not present + output_directory = output_directory + "/" + output_dir = f"{output_directory}{datestamp}_geneformer_diseaseClassifier/" + output_prefix = "cm_classifier_test" + subprocess.call(f"mkdir {output_dir}", shell=True) + os.makedirs(output_dir, exist_ok=True) + + prepare_data(input_data_file="example_input_files/cell_classification/disease_classification/human_dcm_hcm_nf.dataset", + output_directory=output_dir, + output_prefix=output_prefix, + split_id_dict=train_test_id_split_dict) + + with open(f"{output_dir}/{output_prefix}_id_class_dict.pkl", "rb") as f: + id_class_dict = pickle.load(f) + class_id_dict = {v: k for k, v in id_class_dict.items()} + + num_classes = get_num_classes(id_class_dict) + + data = load_and_filter(None, nproc, f"{output_dir}/{output_prefix}_labeled_train.dataset") + data = data.shuffle(seed=42) + + ##### (Cross-)validate the model ##### + results = [] + all_conf_mat = np.zeros((num_classes, num_classes)) + iteration_num = 1 + split_id_dict=train_valid_id_split_dict + + for i in trange(num_crossval_splits): + print( + f"****** Validation split: {iteration_num}/{num_crossval_splits} ******\n" + ) + ksplit_output_dir = os.path.join(output_dir, f"ksplit{iteration_num}") + if num_crossval_splits == 1: + # single 1-eval_size:eval_size split + if split_id_dict is not None: + data_dict = dict() + data_dict["train"] = filter_by_dict( + data, + {split_id_dict["attr_key"]: split_id_dict["train"]}, + nproc, + ) + data_dict["test"] = filter_by_dict( + data, + {split_id_dict["attr_key"]: split_id_dict["eval"]}, + nproc, + ) + train_data = data_dict["train"] + eval_data = data_dict["test"] + + trainer = train_classifier( + model_directory, + num_classes, + train_data, + eval_data, + ksplit_output_dir, + ) + + result = evaluate_model( + trainer.model, + num_classes, + id_class_dict, + eval_data, + True, + ksplit_output_dir, + output_prefix, + ) + results += [result] + all_conf_mat = all_conf_mat + result["conf_mat"] + iteration_num = iteration_num + 1 + + all_conf_mat_df = pd.DataFrame( + all_conf_mat, columns=id_class_dict.values(), index=id_class_dict.values() + ) + all_metrics = { + "conf_matrix": all_conf_mat_df, + "macro_f1": [result["macro_f1"] for result in results], + "acc": [result["acc"] for result in results], + } + all_roc_metrics = None # roc metrics not reported for multiclass + if num_classes == 2: + mean_fpr = np.linspace(0, 1, 100) + all_tpr = [result["roc_metrics"]["interp_tpr"] for result in results] + all_roc_auc = [result["roc_metrics"]["auc"] for result in results] + all_tpr_wt = [result["roc_metrics"]["tpr_wt"] for result in results] + mean_tpr, roc_auc, roc_auc_sd = eu.get_cross_valid_roc_metrics( + all_tpr, all_roc_auc, all_tpr_wt + ) + all_roc_metrics = { + "mean_tpr": mean_tpr, + "mean_fpr": mean_fpr, + "all_roc_auc": all_roc_auc, + "roc_auc": roc_auc, + "roc_auc_sd": roc_auc_sd, + } + all_metrics["all_roc_metrics"] = all_roc_metrics + save_eval_output=True + if save_eval_output is True: + eval_metrics_output_path = ( + Path(output_dir) / f"cm_classifier_test_eval_metrics_dict" + ).with_suffix(".pkl") + with open(eval_metrics_output_path, "wb") as f: + pickle.dump(all_metrics, f) + + datestamp_min = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}_{current_date.strftime('%X').replace(':','')}" + all_metrics_test = evaluate_saved_model( + model_directory=f"{output_dir}/ksplit1/", + id_class_dict_file=f"{output_dir}/{output_prefix}_id_class_dict.pkl", + test_data_file=f"{output_dir}/{output_prefix}_labeled_test.dataset", + output_directory=output_dir, + output_prefix=output_prefix, + ) + + macro_f1_list.append(all_metrics_test['macro_f1']) + acc_list.append(all_metrics_test['acc']) + + +print("Macro F1: ", macro_f1_list) +print("Accuracy: ", acc_list) diff --git a/Downstream_tasks/Classification/Cardio_ML.ipynb b/Downstream_tasks/Classification/Cardio_ML.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..2ca4d47ee6b9fd8467b3b5398d1bf75a3ac3e8d6 --- /dev/null +++ b/Downstream_tasks/Classification/Cardio_ML.ipynb @@ -0,0 +1,1404 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "from tqdm.auto import tqdm, trange\n", + "GPU_NUMBER = [0]\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \",\".join([str(s) for s in GPU_NUMBER])\n", + "os.environ[\"NCCL_DEBUG\"] = \"INFO\"\n", + "\n", + "# imports\n", + "from collections import Counter\n", + "import datetime\n", + "import pickle\n", + "import subprocess\n", + "import seaborn as sns; sns.set()\n", + "from datasets import load_from_disk\n", + "from sklearn.metrics import accuracy_score, f1_score\n", + "from transformers import BertForSequenceClassification, BertForMaskedLM, BertForTokenClassification\n", + "from transformers import Trainer\n", + "from transformers.training_args import TrainingArguments\n", + "import torch\n", + "import pandas as pd\n", + "from datasets.utils.logging import disable_progress_bar, enable_progress_bar\n", + "from sklearn import preprocessing\n", + "from sklearn.metrics import (\n", + " ConfusionMatrixDisplay,\n", + " accuracy_score,\n", + " auc,\n", + " confusion_matrix,\n", + " f1_score,\n", + " roc_curve,\n", + ")\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys\n", + "# sys.path.append('geneformer')\n", + "from geneformer import DataCollatorForCellClassification\n", + "\n", + "macro_f1_list = []\n", + "acc_list = []\n", + "\n", + "iter_step = 2\n", + "\n", + "def prepare_data(\n", + " input_data_file,\n", + " output_directory,\n", + " output_prefix,\n", + " split_id_dict=None,\n", + " test_size=None,\n", + " attr_to_split=None,\n", + " attr_to_balance=None,\n", + " max_trials=100,\n", + " pval_threshold=0.1,\n", + "):\n", + " \"\"\"\n", + " Prepare data for cell state or gene classification.\n", + "\n", + " **Parameters**\n", + "\n", + " input_data_file : Path\n", + " | Path to directory containing .dataset input\n", + " output_directory : Path\n", + " | Path to directory where prepared data will be saved\n", + " output_prefix : str\n", + " | Prefix for output file\n", + " split_id_dict : None, dict\n", + " | Dictionary of IDs for train and test splits\n", + " | Three-item dictionary with keys: attr_key, train, test\n", + " | attr_key: key specifying name of column in .dataset that contains the IDs for the data splits\n", + " | train: list of IDs in the attr_key column to include in the train split\n", + " | test: list of IDs in the attr_key column to include in the test split\n", + " | For example: {\"attr_key\": \"individual\",\n", + " | \"train\": [\"patient1\", \"patient2\", \"patient3\", \"patient4\"],\n", + " | \"test\": [\"patient5\", \"patient6\"]}\n", + " test_size : None, float\n", + " | Proportion of data to be saved separately and held out for test set\n", + " | (e.g. 0.2 if intending hold out 20%)\n", + " | If None, will inherit from split_sizes[\"test\"] from Classifier\n", + " | The training set will be further split to train / validation in self.validate\n", + " | Note: only available for CellClassifiers\n", + " attr_to_split : None, str\n", + " | Key for attribute on which to split data while balancing potential confounders\n", + " | e.g. \"patient_id\" for splitting by patient while balancing other characteristics\n", + " | Note: only available for CellClassifiers\n", + " attr_to_balance : None, list\n", + " | List of attribute keys on which to balance data while splitting on attr_to_split\n", + " | e.g. [\"age\", \"sex\"] for balancing these characteristics while splitting by patient\n", + " | Note: only available for CellClassifiers\n", + " max_trials : None, int\n", + " | Maximum number of trials of random splitting to try to achieve balanced other attributes\n", + " | If no split is found without significant (p<0.05) differences in other attributes, will select best\n", + " | Note: only available for CellClassifiers\n", + " pval_threshold : None, float\n", + " | P-value threshold to use for attribute balancing across splits\n", + " | E.g. if set to 0.1, will accept trial if p >= 0.1 for all attributes in attr_to_balance\n", + " \"\"\"\n", + "\n", + " if test_size is None:\n", + " test_size = oos_test_size\n", + "\n", + " # prepare data and labels for classification\n", + " data = load_and_filter(filter_data, nproc, input_data_file)\n", + "\n", + " if classifier == \"cell\":\n", + " if \"label\" in data.features:\n", + " logger.error(\n", + " \"Column name 'label' must be reserved for class IDs. Please rename column.\"\n", + " )\n", + " raise\n", + " elif classifier == \"gene\":\n", + " if \"labels\" in data.features:\n", + " logger.error(\n", + " \"Column name 'labels' must be reserved for class IDs. Please rename column.\"\n", + " )\n", + " raise\n", + "\n", + " if (attr_to_split is not None) and (attr_to_balance is None):\n", + " logger.error(\n", + " \"Splitting by attribute while balancing confounders requires both attr_to_split and attr_to_balance to be defined.\"\n", + " )\n", + " raise\n", + "\n", + " if not isinstance(attr_to_balance, list):\n", + " attr_to_balance = [attr_to_balance]\n", + "\n", + " if classifier == \"cell\":\n", + " # remove cell states representing < rare_threshold of cells\n", + " data = remove_rare(\n", + " data, rare_threshold, cell_state_dict[\"state_key\"], nproc\n", + " )\n", + " # downsample max cells and max per class\n", + " data = downsample_and_shuffle(\n", + " data, max_ncells, None, cell_state_dict\n", + " )\n", + " # rename cell state column to \"label\"\n", + " data = rename_cols(data, cell_state_dict[\"state_key\"])\n", + "\n", + " # convert classes to numerical labels and save as id_class_dict\n", + " # of note, will label all genes in gene_class_dict\n", + " # if (cross-)validating, genes will be relabeled in column \"labels\" for each split\n", + " # at the time of training with Classifier.validate\n", + " data, id_class_dict = label_classes(\n", + " classifier, data, None, nproc\n", + " )\n", + "\n", + " # save id_class_dict for future reference\n", + " id_class_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_id_class_dict\"\n", + " ).with_suffix(\".pkl\")\n", + " with open(id_class_output_path, \"wb\") as f:\n", + " pickle.dump(id_class_dict, f)\n", + "\n", + " if split_id_dict is not None:\n", + " data_dict = dict()\n", + " data_dict[\"train\"] = filter_by_dict(\n", + " data, {split_id_dict[\"attr_key\"]: split_id_dict[\"train\"]}, nproc\n", + " )\n", + " data_dict[\"test\"] = filter_by_dict(\n", + " data, {split_id_dict[\"attr_key\"]: split_id_dict[\"test\"]}, nproc\n", + " )\n", + " train_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_train\"\n", + " ).with_suffix(\".dataset\")\n", + " test_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_test\"\n", + " ).with_suffix(\".dataset\")\n", + " data_dict[\"train\"].save_to_disk(str(train_data_output_path))\n", + " data_dict[\"test\"].save_to_disk(str(test_data_output_path))\n", + " elif (test_size is not None) and (classifier == \"cell\"):\n", + " if 1 > test_size > 0:\n", + " if attr_to_split is None:\n", + " data_dict = data.train_test_split(\n", + " test_size=test_size,\n", + " stratify_by_column=None,\n", + " seed=42,\n", + " )\n", + " train_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_train\"\n", + " ).with_suffix(\".dataset\")\n", + " test_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_test\"\n", + " ).with_suffix(\".dataset\")\n", + " data_dict[\"train\"].save_to_disk(str(train_data_output_path))\n", + " data_dict[\"test\"].save_to_disk(str(test_data_output_path))\n", + " else:\n", + " data_dict, balance_df = cu.balance_attr_splits(\n", + " data,\n", + " attr_to_split,\n", + " attr_to_balance,\n", + " test_size,\n", + " max_trials,\n", + " pval_threshold,\n", + " cell_state_dict[\"state_key\"],\n", + " nproc,\n", + " )\n", + " balance_df.to_csv(\n", + " f\"{output_directory}/{output_prefix}_train_test_balance_df.csv\"\n", + " )\n", + " train_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_train\"\n", + " ).with_suffix(\".dataset\")\n", + " test_data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled_test\"\n", + " ).with_suffix(\".dataset\")\n", + " data_dict[\"train\"].save_to_disk(str(train_data_output_path))\n", + " data_dict[\"test\"].save_to_disk(str(test_data_output_path))\n", + " else:\n", + " data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled\"\n", + " ).with_suffix(\".dataset\")\n", + " data.save_to_disk(str(data_output_path))\n", + " print(data_output_path)\n", + " else:\n", + " data_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_labeled\"\n", + " ).with_suffix(\".dataset\")\n", + " data.save_to_disk(str(data_output_path))\n", + "\n", + "def load_and_filter(filter_data, nproc, input_data_file):\n", + " data = load_from_disk(input_data_file)\n", + " if filter_data is not None:\n", + " data = filter_by_dict(data, filter_data, nproc)\n", + " return data\n", + "# get number of classes for classifier\n", + "def get_num_classes(id_class_dict):\n", + " return len(set(id_class_dict.values()))\n", + "\n", + "def filter_by_dict(data, filter_data, nproc):\n", + " for key, value in filter_data.items():\n", + "\n", + " def filter_data_by_criteria(example):\n", + " return example[key] in value\n", + "\n", + " data = data.filter(filter_data_by_criteria, num_proc=nproc)\n", + " if len(data) == 0:\n", + " logger.error(\"No cells remain after filtering. Check filtering criteria.\")\n", + " raise\n", + " return data\n", + "def remove_rare(data, rare_threshold, label, nproc):\n", + " if rare_threshold > 0:\n", + " total_cells = len(data)\n", + " label_counter = Counter(data[label])\n", + " nonrare_label_dict = {\n", + " label: [k for k, v in label_counter if (v / total_cells) > rare_threshold]\n", + " }\n", + " data = filter_by_dict(data, nonrare_label_dict, nproc)\n", + " return data\n", + "def downsample_and_shuffle(data, max_ncells, max_ncells_per_class, cell_state_dict):\n", + " data = data.shuffle(seed=42)\n", + " num_cells = len(data)\n", + " # if max number of cells is defined, then subsample to this max number\n", + " if max_ncells is not None:\n", + " if num_cells > max_ncells:\n", + " data = data.select([i for i in range(max_ncells)])\n", + " if max_ncells_per_class is not None:\n", + " class_labels = data[cell_state_dict[\"state_key\"]]\n", + " random.seed(42)\n", + " subsample_indices = subsample_by_class(class_labels, max_ncells_per_class)\n", + " data = data.select(subsample_indices)\n", + " return data\n", + "def rename_cols(data, state_key):\n", + " data = data.rename_column(state_key, \"label\")\n", + " return data\n", + "def label_classes(classifier, data, gene_class_dict, nproc):\n", + " if classifier == \"cell\":\n", + " label_set = set(data[\"label\"])\n", + " elif classifier == \"gene\":\n", + " # remove cells without any of the target genes\n", + " def if_contains_label(example):\n", + " a = pu.flatten_list(gene_class_dict.values())\n", + " b = example[\"input_ids\"]\n", + " return not set(a).isdisjoint(b)\n", + "\n", + " data = data.filter(if_contains_label, num_proc=nproc)\n", + " label_set = gene_class_dict.keys()\n", + "\n", + " if len(data) == 0:\n", + " logger.error(\n", + " \"No cells remain after filtering for target genes. Check target gene list.\"\n", + " )\n", + " raise\n", + "\n", + " class_id_dict = dict(zip(label_set, [i for i in range(len(label_set))]))\n", + " id_class_dict = {v: k for k, v in class_id_dict.items()}\n", + "\n", + " def classes_to_ids(example):\n", + " if classifier == \"cell\":\n", + " example[\"label\"] = class_id_dict[example[\"label\"]]\n", + " elif classifier == \"gene\":\n", + " example[\"labels\"] = label_gene_classes(\n", + " example, class_id_dict, gene_class_dict\n", + " )\n", + " return example\n", + "\n", + " data = data.map(classes_to_ids, num_proc=nproc)\n", + " return data, id_class_dict\n", + "\n", + "def train_classifier(\n", + " model_directory,\n", + " num_classes,\n", + " train_data,\n", + " eval_data,\n", + " output_directory,\n", + " predict=False,\n", + " classifier='cell',\n", + " no_eval=False,\n", + " quantize = False,\n", + " freeze_layers=2,\n", + " ):\n", + " \"\"\"\n", + " Fine-tune model for cell state or gene classification.\n", + "\n", + " **Parameters**\n", + "\n", + " model_directory : Path\n", + " | Path to directory containing model\n", + " num_classes : int\n", + " | Number of classes for classifier\n", + " train_data : Dataset\n", + " | Loaded training .dataset input\n", + " | For cell classifier, labels in column \"label\".\n", + " | For gene classifier, labels in column \"labels\".\n", + " eval_data : None, Dataset\n", + " | (Optional) Loaded evaluation .dataset input\n", + " | For cell classifier, labels in column \"label\".\n", + " | For gene classifier, labels in column \"labels\".\n", + " output_directory : Path\n", + " | Path to directory where fine-tuned model will be saved\n", + " predict : bool\n", + " | Whether or not to save eval predictions from trainer\n", + " \"\"\"\n", + "\n", + " ##### Validate and prepare data #####\n", + " train_data, eval_data = validate_and_clean_cols(\n", + " train_data, eval_data, classifier\n", + " )\n", + " \n", + " if (no_eval is True) and (eval_data is not None):\n", + " logger.warning(\n", + " \"no_eval set to True; model will be trained without evaluation.\"\n", + " )\n", + " eval_data = None\n", + "\n", + " if (classifier == \"gene\") and (predict is True):\n", + " logger.warning(\n", + " \"Predictions during training not currently available for gene classifiers; setting predict to False.\"\n", + " )\n", + " predict = False\n", + "\n", + " # ensure not overwriting previously saved model\n", + " saved_model_test = os.path.join(output_directory, \"pytorch_model.bin\")\n", + " if os.path.isfile(saved_model_test) is True:\n", + " logger.error(\"Model already saved to this designated output directory.\")\n", + " raise\n", + " # make output directory\n", + " # subprocess.call(f\"mkdir {output_directory}\", shell=True)\n", + " os.makedirs(output_dir, exist_ok=True)\n", + "\n", + " ##### Load model and training args #####\n", + " model = load_model(\n", + " \"CellClassifier\",\n", + " num_classes,\n", + " model_directory,\n", + " \"train\",\n", + " quantize=quantize,\n", + " )\n", + " def_training_args, def_freeze_layers = get_default_train_args(\n", + " model, classifier, train_data, output_directory\n", + " )\n", + "\n", + " if training_args is not None:\n", + " def_training_args.update(training_args)\n", + " logging_steps = round(\n", + " len(train_data) / def_training_args[\"per_device_train_batch_size\"] / 10\n", + " )\n", + " def_training_args[\"logging_steps\"] = logging_steps\n", + " def_training_args[\"output_dir\"] = output_directory\n", + " if eval_data is None:\n", + " def_training_args[\"evaluation_strategy\"] = \"no\"\n", + " def_training_args[\"load_best_model_at_end\"] = False\n", + " training_args_init = TrainingArguments(**def_training_args)\n", + "\n", + " if freeze_layers is not None:\n", + " def_freeze_layers = freeze_layers\n", + "\n", + " if def_freeze_layers > 0:\n", + " modules_to_freeze = model.bert.encoder.layer[:def_freeze_layers]\n", + " for module in modules_to_freeze:\n", + " for param in module.parameters():\n", + " param.requires_grad = False\n", + "\n", + " ##### Fine-tune the model #####\n", + " # define the data collator\n", + " if classifier == \"cell\":\n", + " data_collator = DataCollatorForCellClassification()\n", + " elif self.classifier == \"gene\":\n", + " data_collator = DataCollatorForGeneClassification()\n", + "\n", + " # create the trainer\n", + " trainer = Trainer(\n", + " model=model,\n", + " args=training_args_init,\n", + " data_collator=data_collator,\n", + " train_dataset=train_data,\n", + " eval_dataset=eval_data,\n", + " compute_metrics=compute_metrics,\n", + " )\n", + "\n", + " # train the classifier\n", + " trainer.train()\n", + " trainer.save_model(output_directory)\n", + " if predict is True:\n", + " # make eval predictions and save predictions and metrics\n", + " predictions = trainer.predict(eval_data)\n", + " prediction_output_path = f\"{output_directory}/predictions.pkl\"\n", + " with open(prediction_output_path, \"wb\") as f:\n", + " pickle.dump(predictions, f)\n", + " trainer.save_metrics(\"eval\", predictions.metrics)\n", + " return trainer\n", + " \n", + "def validate_and_clean_cols(train_data, eval_data, classifier):\n", + " # validate that data has expected label column and remove others\n", + " if classifier == \"cell\":\n", + " label_col = \"label\"\n", + " elif classifier == \"gene\":\n", + " label_col = \"labels\"\n", + "\n", + " cols_to_keep = [label_col] + [\"input_ids\", \"length\"]\n", + " if label_col not in train_data.column_names:\n", + " logger.error(f\"train_data must contain column {label_col} with class labels.\")\n", + " raise\n", + " else:\n", + " train_data = remove_cols(train_data, cols_to_keep)\n", + "\n", + " if eval_data is not None:\n", + " if label_col not in eval_data.column_names:\n", + " logger.error(\n", + " f\"eval_data must contain column {label_col} with class labels.\"\n", + " )\n", + " raise\n", + " else:\n", + " eval_data = remove_cols(eval_data, cols_to_keep)\n", + " return train_data, eval_data\n", + " \n", + "def remove_cols(data, cols_to_keep):\n", + " other_cols = list(data.features.keys())\n", + " other_cols = [ele for ele in other_cols if ele not in cols_to_keep]\n", + " data = data.remove_columns(other_cols)\n", + " return data\n", + "\n", + "def load_model(model_type, num_classes, model_directory, mode, quantize=False):\n", + " if model_type == \"MTLCellClassifier-Quantized\":\n", + " model_type = \"MTLCellClassifier\"\n", + " quantize = True\n", + "\n", + " output_hidden_states = (mode == \"eval\")\n", + "\n", + " # Quantization logic\n", + " if quantize:\n", + " if model_type == \"MTLCellClassifier\":\n", + " quantize_config = BitsAndBytesConfig(load_in_8bit=True)\n", + " peft_config = None\n", + " else:\n", + " quantize_config = BitsAndBytesConfig(\n", + " load_in_4bit=True,\n", + " bnb_4bit_use_double_quant=True,\n", + " bnb_4bit_quant_type=\"nf4\",\n", + " bnb_4bit_compute_dtype=torch.bfloat16,\n", + " )\n", + " peft_config = LoraConfig(\n", + " lora_alpha=128,\n", + " lora_dropout=0.1,\n", + " r=64,\n", + " bias=\"none\",\n", + " task_type=\"TokenClassification\",\n", + " )\n", + " else:\n", + " quantize_config = None\n", + " peft_config = None\n", + "\n", + " # Model class selection\n", + " model_classes = {\n", + " \"Pretrained\": BertForMaskedLM,\n", + " \"GeneClassifier\": BertForTokenClassification,\n", + " \"CellClassifier\": BertForSequenceClassification,\n", + " \"MTLCellClassifier\": BertForMaskedLM\n", + " }\n", + "\n", + " model_class = model_classes.get(model_type)\n", + " if not model_class:\n", + " raise ValueError(f\"Unknown model type: {model_type}\")\n", + "\n", + " # Model loading\n", + " model_args = {\n", + " \"pretrained_model_name_or_path\": model_directory,\n", + " \"output_hidden_states\": output_hidden_states,\n", + " \"output_attentions\": False,\n", + " }\n", + "\n", + " if model_type != \"Pretrained\":\n", + " model_args[\"num_labels\"] = num_classes\n", + "\n", + " if quantize_config:\n", + " model_args[\"quantization_config\"] = quantize_config\n", + " \n", + " # Load the model\n", + " model = model_class.from_pretrained(**model_args)\n", + " ###########################\n", + "\n", + " if mode == \"eval\":\n", + " model.eval()\n", + "\n", + " # Handle device placement and PEFT\n", + " if not quantize:\n", + " # Only move non-quantized models\n", + " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + " model = model.to(device)\n", + " elif peft_config:\n", + " # Apply PEFT for quantized models (except MTLCellClassifier)\n", + " model.enable_input_require_grads()\n", + " model = get_peft_model(model, peft_config)\n", + "\n", + " return model\n", + "\n", + "def get_default_train_args(model, classifier, data, output_dir):\n", + " num_layers = quant_layers(model)\n", + " freeze_layers_get = 0\n", + " batch_size = 12\n", + " if classifier == \"cell\":\n", + " epochs = 10\n", + " evaluation_strategy = \"epoch\"\n", + " load_best_model_at_end = True\n", + " else:\n", + " epochs = 1\n", + " evaluation_strategy = \"no\"\n", + " load_best_model_at_end = False\n", + "\n", + " if num_layers == 6:\n", + " default_training_args = {\n", + " \"learning_rate\": 5e-5,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"warmup_steps\": 500,\n", + " \"per_device_train_batch_size\": batch_size,\n", + " \"per_device_eval_batch_size\": batch_size,\n", + " }\n", + " else:\n", + " default_training_args = {\n", + " \"per_device_train_batch_size\": batch_size,\n", + " \"per_device_eval_batch_size\": batch_size,\n", + " }\n", + "\n", + " training_args = {\n", + " \"num_train_epochs\": epochs,\n", + " \"do_train\": True,\n", + " \"do_eval\": True,\n", + " \"evaluation_strategy\": evaluation_strategy,\n", + " \"logging_steps\": np.floor(len(data) / batch_size / 8), # 8 evals per epoch\n", + " \"save_strategy\": \"epoch\",\n", + " \"group_by_length\": False,\n", + " \"length_column_name\": \"length\",\n", + " \"disable_tqdm\": False,\n", + " \"weight_decay\": 0.001,\n", + " \"load_best_model_at_end\": load_best_model_at_end,\n", + " }\n", + " training_args.update(default_training_args)\n", + "\n", + " return training_args, freeze_layers_get\n", + "\n", + "def quant_layers(model):\n", + " layer_nums = []\n", + " for name, parameter in model.named_parameters():\n", + " if \"layer\" in name:\n", + " layer_nums += [int(name.split(\"layer.\")[1].split(\".\")[0])]\n", + " return int(max(layer_nums)) + 1\n", + "\n", + "def compute_metrics(pred):\n", + " labels = pred.label_ids\n", + " preds = pred.predictions.argmax(-1)\n", + " # calculate accuracy and macro f1 using sklearn's function\n", + " acc = accuracy_score(labels, preds)\n", + " macro_f1 = f1_score(labels, preds, average='macro')\n", + " weighted_f1 = f1_score(labels, preds, average='weighted')\n", + " return {\n", + " 'accuracy': acc,\n", + " 'macro_f1': macro_f1,\n", + " 'weighted_f1': weighted_f1\n", + " }\n", + "def evaluate_model(\n", + " model,\n", + " num_classes,\n", + " id_class_dict,\n", + " eval_data,\n", + " predict=False,\n", + " output_directory=None,\n", + " output_prefix=None,\n", + "):\n", + " \"\"\"\n", + " Evaluate the fine-tuned model.\n", + "\n", + " **Parameters**\n", + "\n", + " model : nn.Module\n", + " | Loaded fine-tuned model (e.g. trainer.model)\n", + " num_classes : int\n", + " | Number of classes for classifier\n", + " id_class_dict : dict\n", + " | Loaded _id_class_dict.pkl previously prepared by Classifier.prepare_data\n", + " | (dictionary of format: numerical IDs: class_labels)\n", + " eval_data : Dataset\n", + " | Loaded evaluation .dataset input\n", + " predict : bool\n", + " | Whether or not to save eval predictions\n", + " output_directory : Path\n", + " | Path to directory where eval data will be saved\n", + " output_prefix : str\n", + " | Prefix for output files\n", + " \"\"\"\n", + "\n", + " ##### Evaluate the model #####\n", + " labels = id_class_dict.keys()\n", + " y_pred, y_true, logits_list = classifier_predict(\n", + " model, classifier, eval_data, 100\n", + " )\n", + " conf_mat, macro_f1, acc, roc_metrics = get_metrics(\n", + " y_pred, y_true, logits_list, num_classes, labels\n", + " )\n", + " if predict is True:\n", + " pred_dict = {\n", + " \"pred_ids\": y_pred,\n", + " \"label_ids\": y_true,\n", + " \"predictions\": logits_list,\n", + " }\n", + " pred_dict_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_pred_dict\"\n", + " ).with_suffix(\".pkl\")\n", + " with open(pred_dict_output_path, \"wb\") as f:\n", + " pickle.dump(pred_dict, f)\n", + " return {\n", + " \"conf_mat\": conf_mat,\n", + " \"macro_f1\": macro_f1,\n", + " \"acc\": acc,\n", + " \"roc_metrics\": roc_metrics,\n", + " }\n", + " \n", + "def classifier_predict(model, classifier_type, evalset, forward_batch_size):\n", + " if classifier_type == \"gene\":\n", + " label_name = \"labels\"\n", + " elif classifier_type == \"cell\":\n", + " label_name = \"label\"\n", + "\n", + " predict_logits = []\n", + " predict_labels = []\n", + " model.eval()\n", + "\n", + " # ensure there is at least 2 examples in each batch to avoid incorrect tensor dims\n", + " evalset_len = len(evalset)\n", + " max_divisible = find_largest_div(evalset_len, forward_batch_size)\n", + " if len(evalset) - max_divisible == 1:\n", + " evalset_len = max_divisible\n", + "\n", + " max_evalset_len = max(evalset.select([i for i in range(evalset_len)])[\"length\"])\n", + "\n", + " disable_progress_bar() # disable progress bar for preprocess_classifier_batch mapping\n", + " for i in trange(0, evalset_len, forward_batch_size):\n", + " max_range = min(i + forward_batch_size, evalset_len)\n", + " batch_evalset = evalset.select([i for i in range(i, max_range)])\n", + " padded_batch = preprocess_classifier_batch(\n", + " batch_evalset, max_evalset_len, label_name\n", + " )\n", + " padded_batch.set_format(type=\"torch\")\n", + "\n", + " input_data_batch = padded_batch[\"input_ids\"]\n", + " attn_msk_batch = padded_batch[\"attention_mask\"]\n", + " label_batch = padded_batch[label_name]\n", + " with torch.no_grad():\n", + " outputs = model(\n", + " input_ids=input_data_batch.to(\"cuda\"),\n", + " attention_mask=attn_msk_batch.to(\"cuda\"),\n", + " labels=label_batch.to(\"cuda\"),\n", + " )\n", + " predict_logits += [torch.squeeze(outputs.logits.to(\"cpu\"))]\n", + " predict_labels += [torch.squeeze(label_batch.to(\"cpu\"))]\n", + "\n", + " enable_progress_bar()\n", + " logits_by_cell = torch.cat(predict_logits)\n", + " last_dim = len(logits_by_cell.shape) - 1\n", + " all_logits = logits_by_cell.reshape(-1, logits_by_cell.shape[last_dim])\n", + " labels_by_cell = torch.cat(predict_labels)\n", + " all_labels = torch.flatten(labels_by_cell)\n", + " logit_label_paired = [\n", + " item\n", + " for item in list(zip(all_logits.tolist(), all_labels.tolist()))\n", + " if item[1] != -100\n", + " ]\n", + " y_pred = [vote(item[0]) for item in logit_label_paired]\n", + " y_true = [item[1] for item in logit_label_paired]\n", + " logits_list = [item[0] for item in logit_label_paired]\n", + " return y_pred, y_true, logits_list\n", + "\n", + "def find_largest_div(N, K):\n", + " rem = N % K\n", + " if rem == 0:\n", + " return N\n", + " else:\n", + " return N - rem\n", + "def preprocess_classifier_batch(cell_batch, max_len, label_name):\n", + " if max_len is None:\n", + " max_len = max([len(i) for i in cell_batch[\"input_ids\"]])\n", + "\n", + " def pad_label_example(example):\n", + " example[label_name] = np.pad(\n", + " example[label_name],\n", + " (0, max_len - len(example[\"input_ids\"])),\n", + " mode=\"constant\",\n", + " constant_values=-100,\n", + " )\n", + " example[\"input_ids\"] = np.pad(\n", + " example[\"input_ids\"],\n", + " (0, max_len - len(example[\"input_ids\"])),\n", + " mode=\"constant\",\n", + " constant_values=gene_token_dict.get(\"\"),\n", + " )\n", + " example[\"attention_mask\"] = (\n", + " example[\"input_ids\"] != gene_token_dict.get(\"\")\n", + " ).astype(int)\n", + " return example\n", + "\n", + " padded_batch = cell_batch.map(pad_label_example)\n", + " return padded_batch\n", + "def vote(logit_list):\n", + " m = max(logit_list)\n", + " logit_list.index(m)\n", + " indices = [i for i, x in enumerate(logit_list) if x == m]\n", + " if len(indices) > 1:\n", + " return \"tie\"\n", + " else:\n", + " return indices[0]\n", + "def py_softmax(vector):\n", + " e = np.exp(vector)\n", + " return e / e.sum()\n", + "def get_metrics(y_pred, y_true, logits_list, num_classes, labels):\n", + " conf_mat = confusion_matrix(y_true, y_pred, labels=list(labels))\n", + " macro_f1 = f1_score(y_true, y_pred, average=\"macro\")\n", + " acc = accuracy_score(y_true, y_pred)\n", + " roc_metrics = None # roc metrics not reported for multiclass\n", + " if num_classes == 2:\n", + " y_score = [py_softmax(item)[1] for item in logits_list]\n", + " fpr, tpr, _ = roc_curve(y_true, y_score)\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + " interp_tpr = np.interp(mean_fpr, fpr, tpr)\n", + " interp_tpr[0] = 0.0\n", + " tpr_wt = len(tpr)\n", + " roc_auc = auc(fpr, tpr)\n", + " roc_metrics = {\n", + " \"fpr\": fpr,\n", + " \"tpr\": tpr,\n", + " \"interp_tpr\": interp_tpr,\n", + " \"auc\": roc_auc,\n", + " \"tpr_wt\": tpr_wt,\n", + " }\n", + " return conf_mat, macro_f1, acc, roc_metrics\n", + "def evaluate_saved_model(\n", + " model_directory,\n", + " id_class_dict_file,\n", + " test_data_file,\n", + " output_directory,\n", + " output_prefix,\n", + " predict=True,\n", + "):\n", + " \"\"\"\n", + " Evaluate the fine-tuned model.\n", + "\n", + " **Parameters**\n", + "\n", + " model_directory : Path\n", + " | Path to directory containing model\n", + " id_class_dict_file : Path\n", + " | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data\n", + " | (dictionary of format: numerical IDs: class_labels)\n", + " test_data_file : Path\n", + " | Path to directory containing test .dataset\n", + " output_directory : Path\n", + " | Path to directory where eval data will be saved\n", + " output_prefix : str\n", + " | Prefix for output files\n", + " predict : bool\n", + " | Whether or not to save eval predictions\n", + " \"\"\"\n", + "\n", + " # load numerical id to class dictionary (id:class)\n", + " with open(id_class_dict_file, \"rb\") as f:\n", + " id_class_dict = pickle.load(f)\n", + "\n", + " # get number of classes for classifier\n", + " num_classes = get_num_classes(id_class_dict)\n", + "\n", + " # load previously filtered and prepared data\n", + " test_data = load_and_filter(None, nproc, test_data_file)\n", + "\n", + " # load previously fine-tuned model\n", + " model = load_model(\n", + " \"CellClassifier\",\n", + " num_classes,\n", + " model_directory,\n", + " \"eval\",\n", + " quantize=quantize,\n", + " )\n", + "\n", + " # evaluate the model\n", + " result = evaluate_model(\n", + " model,\n", + " num_classes,\n", + " id_class_dict,\n", + " test_data,\n", + " predict=predict,\n", + " output_directory=output_directory,\n", + " output_prefix=\"CellClassifier\",\n", + " )\n", + "\n", + " all_conf_mat_df = pd.DataFrame(\n", + " result[\"conf_mat\"],\n", + " columns=id_class_dict.values(),\n", + " index=id_class_dict.values(),\n", + " )\n", + " all_metrics = {\n", + " \"conf_matrix\": all_conf_mat_df,\n", + " \"macro_f1\": result[\"macro_f1\"],\n", + " \"acc\": result[\"acc\"],\n", + " }\n", + " all_roc_metrics = None # roc metrics not reported for multiclass\n", + "\n", + " if num_classes == 2:\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + " mean_tpr = result[\"roc_metrics\"][\"interp_tpr\"]\n", + " all_roc_auc = result[\"roc_metrics\"][\"auc\"]\n", + " all_roc_metrics = {\n", + " \"mean_tpr\": mean_tpr,\n", + " \"mean_fpr\": mean_fpr,\n", + " \"all_roc_auc\": all_roc_auc,\n", + " }\n", + " all_metrics[\"all_roc_metrics\"] = all_roc_metrics\n", + " test_metrics_output_path = (\n", + " Path(output_directory) / f\"{output_prefix}_test_metrics_dict\"\n", + " ).with_suffix(\".pkl\")\n", + " with open(test_metrics_output_path, \"wb\") as f:\n", + " pickle.dump(all_metrics, f)\n", + "\n", + " return all_metrics\n", + "\n", + "def plot_conf_mat(\n", + " conf_mat_dict,\n", + " output_directory,\n", + " output_prefix,\n", + " custom_class_order=None,\n", + "):\n", + " \"\"\"\n", + " Plot confusion matrix results of evaluating the fine-tuned model.\n", + "\n", + " **Parameters**\n", + "\n", + " conf_mat_dict : dict\n", + " | Dictionary of model_name : confusion_matrix_DataFrame\n", + " | (all_metrics[\"conf_matrix\"] from self.validate)\n", + " output_directory : Path\n", + " | Path to directory where plots will be saved\n", + " output_prefix : str\n", + " | Prefix for output file\n", + " custom_class_order : None, list\n", + " | List of classes in custom order for plots.\n", + " | Same order will be used for all models.\n", + " \"\"\"\n", + "\n", + " for model_name in conf_mat_dict.keys():\n", + " plot_confusion_matrix(\n", + " conf_mat_dict[model_name],\n", + " model_name,\n", + " output_directory,\n", + " output_prefix,\n", + " custom_class_order,\n", + " )\n", + "def plot_confusion_matrix(\n", + " conf_mat_df, title, output_dir, output_prefix, custom_class_order\n", + "):\n", + " fig = plt.figure()\n", + " fig.set_size_inches(10, 10)\n", + " sns.set(font_scale=1)\n", + " sns.set_style(\"whitegrid\", {\"axes.grid\": False})\n", + " if custom_class_order is not None:\n", + " conf_mat_df = conf_mat_df.reindex(\n", + " index=custom_class_order, columns=custom_class_order\n", + " )\n", + " display_labels = generate_display_labels(conf_mat_df)\n", + " conf_mat = preprocessing.normalize(conf_mat_df.to_numpy(), norm=\"l1\")\n", + " display = ConfusionMatrixDisplay(\n", + " confusion_matrix=conf_mat, display_labels=display_labels\n", + " )\n", + " display.plot(cmap=\"Blues\", values_format=\".2g\")\n", + " plt.title(title)\n", + " plt.show()\n", + "\n", + " output_file = (Path(output_dir) / f\"{output_prefix}_conf_mat\").with_suffix(\".pdf\")\n", + " display.figure_.savefig(output_file, bbox_inches=\"tight\")\n", + "def generate_display_labels(conf_mat_df):\n", + " display_labels = []\n", + " i = 0\n", + " for label in conf_mat_df.index:\n", + " display_labels += [f\"{label}\\nn={conf_mat_df.iloc[i,:].sum():.0f}\"]\n", + " i = i + 1\n", + " return display_labels\n", + "\n", + "def plot_predictions(\n", + " predictions_file,\n", + " id_class_dict_file,\n", + " title,\n", + " output_directory,\n", + " output_prefix,\n", + " custom_class_order=None,\n", + " kwargs_dict=None,\n", + "):\n", + " \"\"\"\n", + " Plot prediction results of evaluating the fine-tuned model.\n", + "\n", + " **Parameters**\n", + "\n", + " predictions_file : path\n", + " | Path of model predictions output to plot\n", + " | (saved output from self.validate if predict_eval=True)\n", + " | (or saved output from self.evaluate_saved_model)\n", + " id_class_dict_file : Path\n", + " | Path to _id_class_dict.pkl previously prepared by Classifier.prepare_data\n", + " | (dictionary of format: numerical IDs: class_labels)\n", + " title : str\n", + " | Title for legend containing class labels.\n", + " output_directory : Path\n", + " | Path to directory where plots will be saved\n", + " output_prefix : str\n", + " | Prefix for output file\n", + " custom_class_order : None, list\n", + " | List of classes in custom order for plots.\n", + " | Same order will be used for all models.\n", + " kwargs_dict : None, dict\n", + " | Dictionary of kwargs to pass to plotting function.\n", + " \"\"\"\n", + " # load predictions\n", + " with open(predictions_file, \"rb\") as f:\n", + " predictions = pickle.load(f)\n", + "\n", + " # load numerical id to class dictionary (id:class)\n", + " with open(id_class_dict_file, \"rb\") as f:\n", + " id_class_dict = pickle.load(f)\n", + "\n", + " if isinstance(predictions, dict):\n", + " if all(\n", + " [\n", + " key in predictions.keys()\n", + " for key in [\"pred_ids\", \"label_ids\", \"predictions\"]\n", + " ]\n", + " ):\n", + " # format is output from self.evaluate_saved_model\n", + " predictions_logits = np.array(predictions[\"predictions\"])\n", + " true_ids = predictions[\"label_ids\"]\n", + " else:\n", + " # format is output from self.validate if predict_eval=True\n", + " predictions_logits = predictions.predictions\n", + " true_ids = predictions.label_ids\n", + "\n", + " num_classes = len(id_class_dict.keys())\n", + " num_predict_classes = predictions_logits.shape[1]\n", + " assert num_classes == num_predict_classes\n", + " classes = id_class_dict.values()\n", + " true_labels = [id_class_dict[idx] for idx in true_ids]\n", + " predictions_df = pd.DataFrame(predictions_logits, columns=classes)\n", + " if custom_class_order is not None:\n", + " predictions_df = predictions_df.reindex(columns=custom_class_order)\n", + " predictions_df[\"true\"] = true_labels\n", + " custom_dict = dict(zip(classes, [i for i in range(len(classes))]))\n", + " if custom_class_order is not None:\n", + " custom_dict = dict(\n", + " zip(custom_class_order, [i for i in range(len(custom_class_order))])\n", + " )\n", + " predictions_df = predictions_df.sort_values(\n", + " by=[\"true\"], key=lambda x: x.map(custom_dict)\n", + " )\n", + "\n", + " plot_predictions_eu(\n", + " predictions_df, title, output_directory, output_prefix, kwargs_dict\n", + " )\n", + "def plot_predictions_eu(predictions_df, title, output_dir, output_prefix, kwargs_dict):\n", + " sns.set(font_scale=2)\n", + " plt.figure(figsize=(10, 10), dpi=150)\n", + " label_colors, label_color_dict = make_colorbar(predictions_df, \"true\")\n", + " predictions_df = predictions_df.drop(columns=[\"true\"])\n", + " predict_colors_list = [label_color_dict[label] for label in predictions_df.columns]\n", + " predict_label_list = [label for label in predictions_df.columns]\n", + " predict_colors = pd.DataFrame(\n", + " pd.Series(predict_colors_list, index=predict_label_list), columns=[\"predicted\"]\n", + " )\n", + "\n", + " default_kwargs_dict = {\n", + " \"row_cluster\": False,\n", + " \"col_cluster\": False,\n", + " \"row_colors\": label_colors,\n", + " \"col_colors\": predict_colors,\n", + " \"linewidths\": 0,\n", + " \"xticklabels\": False,\n", + " \"yticklabels\": False,\n", + " \"center\": 0,\n", + " \"cmap\": \"vlag\",\n", + " }\n", + "\n", + " if kwargs_dict is not None:\n", + " default_kwargs_dict.update(kwargs_dict)\n", + " g = sns.clustermap(predictions_df, **default_kwargs_dict)\n", + "\n", + " plt.setp(g.ax_row_colors.get_xmajorticklabels(), rotation=45, ha=\"right\")\n", + "\n", + " for label_color in list(label_color_dict.keys()):\n", + " g.ax_col_dendrogram.bar(\n", + " 0, 0, color=label_color_dict[label_color], label=label_color, linewidth=0\n", + " )\n", + "\n", + " g.ax_col_dendrogram.legend(\n", + " title=f\"{title}\",\n", + " loc=\"lower center\",\n", + " ncol=4,\n", + " bbox_to_anchor=(0.5, 1),\n", + " facecolor=\"white\",\n", + " )\n", + "\n", + " output_file = (Path(output_dir) / f\"{output_prefix}_pred\").with_suffix(\".pdf\")\n", + " plt.savefig(output_file, bbox_inches=\"tight\")\n", + "def make_colorbar(embs_df, label):\n", + " labels = list(embs_df[label])\n", + "\n", + " cell_type_colors = gen_heatmap_class_colors(labels, embs_df)\n", + " label_colors = pd.DataFrame(cell_type_colors, columns=[label])\n", + "\n", + " # create dictionary for colors and classes\n", + " label_color_dict = gen_heatmap_class_dict(labels, label_colors[label])\n", + " return label_colors, label_color_dict\n", + "def gen_heatmap_class_colors(labels, df):\n", + " pal = sns.cubehelix_palette(\n", + " len(Counter(labels).keys()),\n", + " light=0.9,\n", + " dark=0.1,\n", + " hue=1,\n", + " reverse=True,\n", + " start=1,\n", + " rot=-2,\n", + " )\n", + " lut = dict(zip(map(str, Counter(labels).keys()), pal))\n", + " colors = pd.Series(labels, index=df.index).map(lut)\n", + " return colors\n", + "def gen_heatmap_class_dict(classes, label_colors_series):\n", + " class_color_dict_df = pd.DataFrame(\n", + " {\"classes\": classes, \"color\": label_colors_series}\n", + " )\n", + " class_color_dict_df = class_color_dict_df.drop_duplicates(subset=[\"classes\"])\n", + " return dict(zip(class_color_dict_df[\"classes\"], class_color_dict_df[\"color\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7a260f2ee53e46cda883751b4f9ee36f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Saving the dataset (0/3 shards): 0%| | 0/115367 [00:00 2\n", + " print(f\"# targets1: {len(targets1_id)}\\n# targets2: {len(targets2_id)}\\n# splits: {nsplits}\")\n", + " return targets, labels, nsplits" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# targets1: 122\n", + "# targets2: 368\n", + "# splits: 5\n" + ] + } + ], + "source": [ + "# preparing targets and labels for dosage sensitive vs insensitive TFs\n", + "dosage_tfs = pd.read_csv(\"example_input_files/gene_classification/dosage_sensitive_tfs/dosage_sens_tf_labels.csv\", header=0)\n", + "sensitive = dosage_tfs[\"dosage_sensitive\"].dropna()\n", + "insensitive = dosage_tfs[\"dosage_insensitive\"].dropna()\n", + "targets, labels, nsplits = prep_inputs(sensitive, insensitive, \"ensembl_id\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# load training dataset\n", + "train_dataset=load_from_disk(\"Genecorpus-30M/genecorpus_30M_2048.dataset\")\n", + "shuffled_train_dataset = train_dataset.shuffle(seed=42)\n", + "subsampled_train_dataset = shuffled_train_dataset.select([i for i in range(50_000)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Functions for Training and Cross-Validating Classifier" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_classifier_batch(cell_batch, max_len):\n", + " if max_len == None:\n", + " max_len = max([len(i) for i in cell_batch[\"input_ids\"]])\n", + " def pad_label_example(example):\n", + " example[\"labels\"] = np.pad(example[\"labels\"], \n", + " (0, max_len-len(example[\"input_ids\"])), \n", + " mode='constant', constant_values=-100)\n", + " example[\"input_ids\"] = np.pad(example[\"input_ids\"], \n", + " (0, max_len-len(example[\"input_ids\"])), \n", + " mode='constant', constant_values=token_dictionary.get(\"\"))\n", + " example[\"attention_mask\"] = (example[\"input_ids\"] != token_dictionary.get(\"\")).astype(int)\n", + " return example\n", + " padded_batch = cell_batch.map(pad_label_example)\n", + " return padded_batch\n", + "\n", + "# forward batch size is batch size for model inference (e.g. 200)\n", + "def classifier_predict(model, evalset, forward_batch_size, mean_fpr):\n", + " predict_logits = []\n", + " predict_labels = []\n", + " model.eval()\n", + " \n", + " # ensure there is at least 2 examples in each batch to avoid incorrect tensor dims\n", + " evalset_len = len(evalset)\n", + " max_divisible = find_largest_div(evalset_len, forward_batch_size)\n", + " if len(evalset) - max_divisible == 1:\n", + " evalset_len = max_divisible\n", + " \n", + " max_evalset_len = max(evalset.select([i for i in range(evalset_len)])[\"length\"])\n", + " \n", + " for i in range(0, evalset_len, forward_batch_size):\n", + " max_range = min(i+forward_batch_size, evalset_len)\n", + " batch_evalset = evalset.select([i for i in range(i, max_range)])\n", + " padded_batch = preprocess_classifier_batch(batch_evalset, max_evalset_len)\n", + " padded_batch.set_format(type=\"torch\")\n", + " \n", + " input_data_batch = padded_batch[\"input_ids\"]\n", + " attn_msk_batch = padded_batch[\"attention_mask\"]\n", + " label_batch = padded_batch[\"labels\"]\n", + " with torch.no_grad():\n", + " outputs = model(\n", + " input_ids = input_data_batch.to(\"cuda\"), \n", + " attention_mask = attn_msk_batch.to(\"cuda\"), \n", + " labels = label_batch.to(\"cuda\"), \n", + " )\n", + " predict_logits += [torch.squeeze(outputs.logits.to(\"cpu\"))]\n", + " predict_labels += [torch.squeeze(label_batch.to(\"cpu\"))]\n", + " \n", + " logits_by_cell = torch.cat(predict_logits)\n", + " all_logits = logits_by_cell.reshape(-1, logits_by_cell.shape[2])\n", + " labels_by_cell = torch.cat(predict_labels)\n", + " all_labels = torch.flatten(labels_by_cell)\n", + " logit_label_paired = [item for item in list(zip(all_logits.tolist(), all_labels.tolist())) if item[1]!=-100]\n", + " y_pred = [vote(item[0]) for item in logit_label_paired]\n", + " y_true = [item[1] for item in logit_label_paired]\n", + " logits_list = [item[0] for item in logit_label_paired]\n", + " # probability of class 1\n", + " y_score = [py_softmax(item)[1] for item in logits_list]\n", + " conf_mat = confusion_matrix(y_true, y_pred)\n", + " fpr, tpr, _ = roc_curve(y_true, y_score)\n", + " # plot roc_curve for this split\n", + " plt.plot(fpr, tpr)\n", + " plt.xlim([0.0, 1.0])\n", + " plt.ylim([0.0, 1.05])\n", + " plt.xlabel('False Positive Rate')\n", + " plt.ylabel('True Positive Rate')\n", + " plt.title('ROC')\n", + " plt.show()\n", + " # interpolate to graph\n", + " interp_tpr = np.interp(mean_fpr, fpr, tpr)\n", + " interp_tpr[0] = 0.0\n", + " return fpr, tpr, interp_tpr, conf_mat \n", + "\n", + "def vote(logit_pair):\n", + " a, b = logit_pair\n", + " if a > b:\n", + " return 0\n", + " elif b > a:\n", + " return 1\n", + " elif a == b:\n", + " return \"tie\"\n", + " \n", + "def py_softmax(vector):\n", + "\te = np.exp(vector)\n", + "\treturn e / e.sum()\n", + " \n", + "# get cross-validated mean and sd metrics\n", + "def get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt):\n", + " wts = [count/sum(all_tpr_wt) for count in all_tpr_wt]\n", + " print(wts)\n", + " all_weighted_tpr = [a*b for a,b in zip(all_tpr, wts)]\n", + " mean_tpr = np.sum(all_weighted_tpr, axis=0)\n", + " mean_tpr[-1] = 1.0\n", + " all_weighted_roc_auc = [a*b for a,b in zip(all_roc_auc, wts)]\n", + " roc_auc = np.sum(all_weighted_roc_auc)\n", + " roc_auc_sd = math.sqrt(np.average((all_roc_auc-roc_auc)**2, weights=wts))\n", + " return mean_tpr, roc_auc, roc_auc_sd\n", + "\n", + "# Function to find the largest number smaller\n", + "# than or equal to N that is divisible by k\n", + "def find_largest_div(N, K):\n", + " rem = N % K\n", + " if(rem == 0):\n", + " return N\n", + " else:\n", + " return N - rem" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# cross-validate gene classifier\n", + "def cross_validate(data, targets, labels, nsplits, subsample_size, training_args, freeze_layers, output_dir, num_proc):\n", + " # check if output directory already written to\n", + " # ensure not overwriting previously saved model\n", + " model_dir_test = os.path.join(output_dir, \"ksplit0/models/pytorch_model.bin\")\n", + " if os.path.isfile(model_dir_test) == True:\n", + " raise Exception(\"Model already saved to this directory.\")\n", + " \n", + " # initiate eval metrics to return\n", + " num_classes = len(set(labels))\n", + " mean_fpr = np.linspace(0, 1, 100)\n", + " all_tpr = []\n", + " all_roc_auc = []\n", + " all_tpr_wt = []\n", + " label_dicts = []\n", + " confusion = np.zeros((num_classes,num_classes))\n", + " \n", + " # set up cross-validation splits\n", + " skf = StratifiedKFold(n_splits=nsplits, random_state=0, shuffle=True)\n", + " # train and evaluate\n", + " iteration_num = 0\n", + " for train_index, eval_index in tqdm(skf.split(targets, labels)):\n", + " if len(labels) > 500:\n", + " print(\"early stopping activated due to large # of training examples\")\n", + " nsplits = 3\n", + " if iteration_num == 3:\n", + " break\n", + " print(f\"****** Crossval split: {iteration_num}/{nsplits-1} ******\\n\")\n", + " # generate cross-validation splits\n", + " targets_train, targets_eval = targets[train_index], targets[eval_index]\n", + " labels_train, labels_eval = labels[train_index], labels[eval_index]\n", + " label_dict_train = dict(zip(targets_train, labels_train))\n", + " label_dict_eval = dict(zip(targets_eval, labels_eval))\n", + " label_dicts += (iteration_num, targets_train, targets_eval, labels_train, labels_eval)\n", + " \n", + " # function to filter by whether contains train or eval labels\n", + " def if_contains_train_label(example):\n", + " a = label_dict_train.keys()\n", + " b = example['input_ids']\n", + " return not set(a).isdisjoint(b)\n", + "\n", + " def if_contains_eval_label(example):\n", + " a = label_dict_eval.keys()\n", + " b = example['input_ids']\n", + " return not set(a).isdisjoint(b)\n", + " \n", + " # filter dataset for examples containing classes for this split\n", + " print(f\"Filtering training data\")\n", + " trainset = data.filter(if_contains_train_label, num_proc=num_proc)\n", + " print(f\"Filtered {round((1-len(trainset)/len(data))*100)}%; {len(trainset)} remain\\n\")\n", + " print(f\"Filtering evalation data\")\n", + " evalset = data.filter(if_contains_eval_label, num_proc=num_proc)\n", + " print(f\"Filtered {round((1-len(evalset)/len(data))*100)}%; {len(evalset)} remain\\n\")\n", + "\n", + " # minimize to smaller training sample\n", + " training_size = min(subsample_size, len(trainset))\n", + " trainset_min = trainset.select([i for i in range(training_size)])\n", + " eval_size = min(training_size, len(evalset))\n", + " half_training_size = round(eval_size/2)\n", + " evalset_train_min = evalset.select([i for i in range(half_training_size)])\n", + " evalset_oos_min = evalset.select([i for i in range(half_training_size, eval_size)])\n", + " \n", + " # label conversion functions\n", + " def generate_train_labels(example):\n", + " example[\"labels\"] = [label_dict_train.get(token_id, -100) for token_id in example[\"input_ids\"]]\n", + " return example\n", + "\n", + " def generate_eval_labels(example):\n", + " example[\"labels\"] = [label_dict_eval.get(token_id, -100) for token_id in example[\"input_ids\"]]\n", + " return example\n", + " \n", + " # label datasets \n", + " print(f\"Labeling training data\")\n", + " trainset_labeled = trainset_min.map(generate_train_labels)\n", + " print(f\"Labeling evaluation data\")\n", + " evalset_train_labeled = evalset_train_min.map(generate_eval_labels)\n", + " print(f\"Labeling evaluation OOS data\")\n", + " evalset_oos_labeled = evalset_oos_min.map(generate_eval_labels)\n", + " \n", + " # create output directories\n", + " ksplit_output_dir = os.path.join(output_dir, f\"ksplit{iteration_num}\")\n", + " ksplit_model_dir = os.path.join(ksplit_output_dir, \"models/\") \n", + " \n", + " # ensure not overwriting previously saved model\n", + " model_output_file = os.path.join(ksplit_model_dir, \"pytorch_model.bin\")\n", + " if os.path.isfile(model_output_file) == True:\n", + " raise Exception(\"Model already saved to this directory.\")\n", + "\n", + " # make training and model output directories\n", + " os.makedirs(ksplit_output_dir, exist_ok=True)\n", + " os.makedirs(ksplit_model_dir, exist_ok=True)\n", + " \n", + " # load model\n", + " model = BertForTokenClassification.from_pretrained(\n", + " model_path,\n", + " num_labels=2,\n", + " output_attentions = False,\n", + " output_hidden_states = False\n", + " )\n", + " if freeze_layers is not None:\n", + " modules_to_freeze = model.bert.encoder.layer[:freeze_layers]\n", + " for module in modules_to_freeze:\n", + " for param in module.parameters():\n", + " param.requires_grad = False\n", + "\n", + " #############\n", + " pretrained_model = CustomBertForMaskedLM.from_pretrained(model_path)\n", + " # Extract the word embeddings from the pretrained model\n", + " pretrained_word_embeddings = pretrained_model.bert.embeddings.word_embeddings.weight.clone()\n", + " model.bert.embeddings.word_embeddings.load_state_dict({\"weight\": pretrained_word_embeddings}) \n", + " ########### \n", + " \n", + " model = model.to(\"cuda:0\")\n", + " \n", + " # add output directory to training args and initiate\n", + " training_args[\"output_dir\"] = ksplit_output_dir\n", + " training_args_init = TrainingArguments(**training_args)\n", + " \n", + " # create the trainer\n", + " trainer = Trainer(\n", + " model=model,\n", + " args=training_args_init,\n", + " data_collator=DataCollatorForGeneClassification(),\n", + " train_dataset=trainset_labeled,\n", + " eval_dataset=evalset_train_labeled\n", + " )\n", + "\n", + " # train the gene classifier\n", + " trainer.train()\n", + " \n", + " # save model\n", + " trainer.save_model(ksplit_model_dir)\n", + " \n", + " # evaluate model\n", + " fpr, tpr, interp_tpr, conf_mat = classifier_predict(trainer.model, evalset_oos_labeled, 200, mean_fpr)\n", + " \n", + " # append to tpr and roc lists\n", + " confusion = confusion + conf_mat\n", + " all_tpr.append(interp_tpr)\n", + " all_roc_auc.append(auc(fpr, tpr))\n", + " # append number of eval examples by which to weight tpr in averaged graphs\n", + " all_tpr_wt.append(len(tpr))\n", + " \n", + " iteration_num = iteration_num + 1\n", + " \n", + " # get overall metrics for cross-validation\n", + " mean_tpr, roc_auc, roc_auc_sd = get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt)\n", + " return all_roc_auc, roc_auc, roc_auc_sd, mean_fpr, mean_tpr, confusion, label_dicts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Functions for Plotting Results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# plot ROC curve\n", + "def plot_ROC(bundled_data, title):\n", + " plt.figure()\n", + " lw = 2\n", + " for roc_auc, roc_auc_sd, mean_fpr, mean_tpr, sample, color in bundled_data:\n", + " plt.plot(mean_fpr, mean_tpr, color=color,\n", + " lw=lw, label=\"{0} (AUC {1:0.2f} $\\pm$ {2:0.2f})\".format(sample, roc_auc, roc_auc_sd))\n", + " plt.plot([0, 1], [0, 1], color='black', lw=lw, linestyle='--')\n", + " plt.xlim([0.0, 1.0])\n", + " plt.ylim([0.0, 1.05])\n", + " plt.xlabel('False Positive Rate')\n", + " plt.ylabel('True Positive Rate')\n", + " plt.title(title)\n", + " plt.legend(loc=\"lower right\")\n", + " plt.show()\n", + " \n", + "# plot confusion matrix\n", + "def plot_confusion_matrix(classes_list, conf_mat, title):\n", + " display_labels = []\n", + " i = 0\n", + " for label in classes_list:\n", + " display_labels += [\"{0}\\nn={1:.0f}\".format(label, sum(conf_mat[:,i]))]\n", + " i = i + 1\n", + " display = ConfusionMatrixDisplay(confusion_matrix=preprocessing.normalize(conf_mat, norm=\"l1\"), \n", + " display_labels=display_labels)\n", + " display.plot(cmap=\"Blues\",values_format=\".2g\")\n", + " plt.grid(False)\n", + " plt.title(title)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fine-Tune With Gene Classification Learning Objective and Quantify Predictive Performance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Please note that, as usual with deep learning models, we **highly** recommend tuning learning hyperparameters for all fine-tuning applications as this can significantly improve model performance. Example hyperparameters are defined below, but please see the \"hyperparam_optimiz_for_disease_classifier\" script for an example of how to tune hyperparameters for downstream applications." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# set model parameters\n", + "# max input size\n", + "max_input_size = 2 ** 11 # 2048\n", + "\n", + "# set training hyperparameters\n", + "# max learning rate\n", + "max_lr = 5e-5\n", + "# how many pretrained layers to freeze\n", + "freeze_layers = 4\n", + "# number gpus\n", + "num_gpus = 1\n", + "# number cpu cores\n", + "num_proc = 24\n", + "# batch size for training and eval\n", + "geneformer_batch_size = 12\n", + "# learning schedule\n", + "lr_schedule_fn = \"linear\"\n", + "# warmup steps\n", + "warmup_steps = 500\n", + "# number of epochs\n", + "epochs = 1\n", + "# optimizer\n", + "optimizer = \"adamw\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# set training arguments\n", + "subsample_size = 10_000\n", + "training_args = {\n", + " \"learning_rate\": max_lr,\n", + " \"do_train\": True,\n", + " \"evaluation_strategy\": \"no\",\n", + " \"save_strategy\": \"epoch\",\n", + " \"logging_steps\": 100,\n", + " \"group_by_length\": True,\n", + " \"length_column_name\": \"length\",\n", + " \"disable_tqdm\": False,\n", + " \"lr_scheduler_type\": lr_schedule_fn,\n", + " \"warmup_steps\": warmup_steps,\n", + " \"weight_decay\": 0.001,\n", + " \"per_device_train_batch_size\": geneformer_batch_size,\n", + " \"per_device_eval_batch_size\": geneformer_batch_size,\n", + " \"num_train_epochs\": epochs,\n", + " \"report_to\": \"none\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# define output directory path\n", + "current_date = datetime.datetime.now()\n", + "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", + "training_output_dir = f\"Downstream/previous/model_training_record/{datestamp}_geneformer_GeneClassifier_dosageTF_L{max_input_size}_B{geneformer_batch_size}_LR{max_lr}_LS{lr_schedule_fn}_WU{warmup_steps}_E{epochs}_O{optimizer}_n{subsample_size}_F{freeze_layers}/\"\n", + "\n", + "# ensure not overwriting previously saved model\n", + "ksplit_model_test = os.path.join(training_output_dir, \"ksplit0/models/pytorch_model.bin\")\n", + "if os.path.isfile(ksplit_model_test) == True:\n", + " raise Exception(\"Model already saved to this directory.\")\n", + "\n", + "# make output directory\n", + "os.makedirs(training_output_dir, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# cross-validate gene classifier\n", + "all_roc_auc, roc_auc, roc_auc_sd, mean_fpr, mean_tpr, confusion, label_dicts \\\n", + " = cross_validate(subsampled_train_dataset, targets, labels, nsplits, subsample_size, training_args, freeze_layers, training_output_dir, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# bundle data for plotting\n", + "bundled_data = []\n", + "bundled_data += [(roc_auc, roc_auc_sd, mean_fpr, mean_tpr, \"Geneformer\", \"red\")]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHPCAYAAABOau4WAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAn2RJREFUeJzs3Xd4VEUXwOHflvRKaEpvhl6kQ6hRhADSpUnvEEGKUgQRkN6khCYgICoIUpRPQu9FBFFAulQBDZDey+79/ghcWUJJQpK7Sc77PHmyd27ZszspZ2fmzugURVEQQgghhBAvpNc6ACGEEEKIzECSJiGEEEKIZJCkSQghhBAiGSRpEkIIIYRIBkmahBBCCCGSQZImIYQQQohkkKRJCCGEECIZJGkSQgghhEgGSZqEEEIIIZJBkiYhRLpZuHAhJUuWTNaxmzdvpmTJkty5cyedoxJpwdvbm9GjRyfr2K5du9K1a9d0jkiI9GfUOgAhUmLz5s2MGTNG3ba1tcXNzY2SJUtSv3592rRpg7Ozs4YRZrxTp06xdOlSLl++TEhICDlz5qRUqVI0a9aMd999V+vwkli6dCklSpTg7bff1jqUDLFw4UL8/Pw4fvw4Hh4eWoeTbv766y/8/f1p3bo1BQoU0DSWp/9OPE/+/PnZt2+fWkfPMmHCBDp16pTWIYpMSpImkSkNGTKEAgUKkJCQwMOHD/n111+ZOnUqq1evZvHixZQqVUrrEDOEv78/w4YNo3Tp0nTr1g03Nzfu3LnDyZMn2bBhg+ZJ08CBA+nXr59F2bJly2jcuHGSpKlly5Y0a9YMW1vbjAxRpNKOHTvQ6XTq9l9//YWfnx/Vq1dPkjStXLkyQ2OrVq0aM2fOtCgbN24cFSpUoH379mqZk5OTxTETJkzA0dHRoqxixYrpF6jIdCRpEplSvXr1KF++vLrdv39/jh8/zoABAxg0aBDbt2/H3t5ewwgzhp+fHyVKlOD7779PkmwEBgZqFNV/jEYjRmPy/swYDAYMBkM6RyTSSkqS24xOhAsWLEjBggUtyiZMmEDBggVp2bLlc89r3Lhxlm4NFK9OxjSJLKNWrVoMGjSIu3fv8tNPP1nsO378OJ07d6ZSpUpUrVqVgQMHcu3aNYtjIiIimDJlCt7e3pQrV45atWrRs2dPzp8/rx5z6tQphgwZQoMGDShXrhz169dn6tSpxMTEJInH39+fpk2bUr58eZo3b87u3bsZPXo03t7eFseZzWZWr15Ns2bNKF++PLVr12b8+PGEhoa+9DXfvn2b8uXLP/OfUs6cOVP1PN7e3vTv359Tp07Rrl07ypcvz1tvvcXWrVstjouPj8fPz4933nmH8uXLU6NGDTp16sTRo0fVY54e01SyZEmioqLYsmULJUuWpGTJkuq4mKfHNPXv35+33nrrma+7Q4cOtGnTxqLsxx9/pE2bNlSoUIHq1aszbNgw/vnnnxe+fzt27KBkyZL8+uuvSfatX7+ekiVLcuXKFQAePHjAmDFjqFevHuXKlaNOnToMHDgwVWOwunbtSvPmzfnrr7/o2rUrFStWpG7duixfvjzJsWvXrqVZs2ZUrFiRatWq0aZNG7Zt22ZxTEBAAGPGjKF27dqUK1eOZs2a8cMPP1gcc+LECUqWLMn27dtZsmSJ+sGje/fu3Lp1y+LYmzdvMnjwYLy8vChfvjz16tVj2LBhhIeHq8c8OaZp8+bNfPjhhwB069ZNrdsTJ06or/fxmKaHDx9SpkyZZ3aHXb9+nZIlS/LNN9+oZWFhYUyZMoX69etTrlw5GjVqxJdffonZbE72+51Wfv75Z9q0acObb75J5cqVeffdd1mzZk2GxyG0Iy1NIktp2bIlc+fO5ciRI2oz/LFjx+jbty8FChTggw8+ICYmhm+++YZOnTqxefNmtSvhs88+Y+fOnXTp0oXixYsTEhLCb7/9xrVr1yhbtiyQ+E82JiaGTp064e7uztmzZ/nmm2/4999/WbBggRrHgQMHGDZsGJ6enowYMYLQ0FDGjh1L3rx5k8Q8fvx4tmzZQps2bejatSt37tzh22+/5cKFC6xbtw4bG5vnvt58+fJx/Phx/v33X1577bUXvjcpeZ5bt27x4Ycf0q5dO1q3bs2mTZsYPXo0ZcuW5Y033gASW7mWLVvGe++9R4UKFYiIiODPP//k/PnzeHl5PTOGmTNnJukmKVSo0DOP9fHxYdSoUZw9e5YKFSqo5Xfv3uWPP/5g5MiRatmSJUuYP38+Pj4+tGvXjqCgIL755hvef/99tm7diqur6zOfo0GDBjg6OuLv70/16tUt9m3fvp033ngDT09PAAYPHsxff/1Fly5dyJ8/P0FBQRw9epR//vknVWN4QkND6dOnD40aNcLHx4edO3cye/ZsPD09qV+/PgAbNmxg8uTJNG7cmG7duhEbG8vly5c5c+aM2vX68OFD2rdvj06n4/3338fDw4NDhw4xduxYIiIi6NGjh8XzLl++HJ1OR69evYiIiGDFihV89NFHbNy4EYC4uDh69+5NXFwcXbp0IVeuXAQEBHDgwAHCwsJwcXFJ8lqqVatG165dWbt2LQMGDKBYsWIAFC9ePMmxuXLlolq1avj7+/PBBx8kec8NBgNNmjQBIDo6mi5duhAQEEDHjh15/fXX+f3335k7dy4PHjxg7NixKX7fX+TpDxAGgwE3NzcAjh49yvDhw6lVqxYfffQRkJjknT59mu7du6dpHMKKKUJkIps2bVI8PT2Vs2fPPveYKlWqKK1atVK3W7ZsqdSqVUsJDg5Wyy5evKiUKlVKGTlypMV5EydOfOHzR0dHJylbtmyZUrJkSeXu3btqWfPmzZV69eopERERatmJEycUT09PpWHDhmrZyZMnFU9PT+Wnn36yuOahQ4eeWf60jRs3Kp6enkrZsmWVrl27KvPmzVNOnjypmEwmi+NS8jwNGzZUPD09lZMnT6plgYGBSrly5ZTp06erZS1atFD69ev3wvgWLFigeHp6WpRVqlRJGTVqVJJjH9ft33//rSiKooSHhyd5TkVRlOXLl1u833fu3FFKly6tLFmyxOK4y5cvK2XKlElS/rThw4crtWrVUhISEtSy+/fvK6VKlVL8/PwURVGU0NBQxdPTU1mxYsULr/Usj9+DwMBAtaxLly6Kp6ensmXLFrUsNjZW8fLyUgYPHqyWDRw4UGnWrNkLr//JJ58oXl5eSlBQkEX5sGHDlCpVqqg/s7/88ovi6emp+Pj4KLGxsepxa9asUTw9PZXLly8riqIoFy5cUDw9PRV/f/8XPm/Dhg0t6tHf31/x9PRUfvnllyTHdunSRenSpYu6vX79eovnfKxp06ZKt27d1O1FixYplSpVUm7cuGFx3OzZs5XSpUsr9+7de2GMT3rez52i/FdHT389+bs6efJkpXLlyhY/JyL7ke45keU4OjoSGRkJwP3797l48SKtW7fG3d1dPaZUqVLUrl2bgwcPqmWurq6cOXOGgICA5177yXFSUVFRBAUF8eabb6IoChcuXAASu0quXLlCq1atLAaaVq9eXW21eGzHjh24uLjg5eVFUFCQ+lW2bFkcHR3V7o3nadeuHStWrKBGjRqcPn2axYsX8/777/POO+9w+vTpVD9PiRIlqFq1qrrt4eFB0aJF+fvvvy3er6tXr3Lz5s0Xxphazs7O1KtXD39/fxRFUcu3b99OpUqVyJcvHwC7d+/GbDbj4+Nj8dpy5cpF4cKFX/oe+vj4EBgYaNFFt3PnTsxmM02bNgUS693GxoZff/01Wd2myeHo6GgxvsbW1pby5csneY///fdfzp49+8xrKIrCrl278Pb2RlEUi9dfp04dwsPDLbqXAdq0aWPRnfu4nh8/7+O7T48cOUJ0dHSavNanNWrUCKPRyPbt29WyK1eu8Ndff6nvOST+3FapUgVXV1eL11a7dm1MJhMnT55M07gWLlzIqlWr1K9Zs2ap+1xdXYmOjrbofhbZj3TPiSwnKipKHc9z7949AIoWLZrkuOLFi3PkyBGioqJwdHTko48+YvTo0TRo0ICyZctSv359WrVqZTGg9N69eyxYsIB9+/Yl+ecZERFh8ZzP6nYqXLiwmlxBYjdYeHg4tWrVeuZrSc5g7rp161K3bl2io6M5f/4827dvZ/369QwYMAB/f39y5syZ4ud5/fXXkxzj5uZm8ZqHDBnCoEGDaNy4MZ6entSpU4eWLVum6Z2LTZs2Zc+ePfz+++9UrlyZ27dvc/78eT755BP1mJs3b6IoCu+8884zr/Gygej16tXDxcWF7du3q+/P9u3bKV26tPpzY2try0cffcSMGTPw8vKiYsWKNGjQgFatWpE7d+5UvbbXXnvN4u4zSHyPL1++rG737duXY8eO8d5771G4cGG8vLxo3rw5VapUASAoKIiwsDC+//57vv/++2c+T1BQkMX242Tzscddl2FhYUDiIOqePXuyatUqtm3bRtWqVfH29qZFixbP7JpLDQ8PD2rWrIm/vz9Dhw4FEt9zo9FIo0aN1ONu3brF5cuXn/tz+/Rre1VVq1Z97kDwzp074+/vT9++fcmbNy9eXl74+PhQr169NI1BWDdJmkSW8u+//xIeHv7ccTIv0rRpU6pWrcru3bs5evQoK1euZPny5SxcuJD69etjMpno2bOnOhalWLFiODo6EhAQwOjRo1M1MNVsNpMzZ05mz579zP0puZPHwcGBqlWrUrVqVXLkyIGfnx+HDh2idevWKX6e5NzFVq1aNXbv3s3evXs5evQoP/zwA2vWrGHixIm89957yY77RRo2bIiDgwP+/v5UrlwZf39/9Hq9OuYFEt9DnU7H8uXLnxn307eQP83W1pa3336b3bt389lnnxEYGMjp06cZPny4xXE9evTA29ubPXv2cOTIEebPn8+XX37JmjVrKFOmTIpfW3Le4+LFi7Njxw4OHDjA4cOH2bVrF9999x2+vr4MGTJE/Zlr0aIFrVu3fuY1np5cVK9/dgfDk615o0ePpnXr1mrdTp48mWXLlrFhw4aXjp1LrmbNmjFmzBguXrxI6dKl8ff3p2bNmhY/i2azGS8vL/r06fPMaxQpUiRNYkmOnDlzsnXrVo4cOcKhQ4c4dOgQmzdvplWrVsyYMSPD4hDakqRJZCk//vgjAHXq1AH++1R948aNJMdev36dHDlyWPxTzZMnD++//z7vv/8+gYGBtG7dmqVLl1K/fn2uXLnCzZs3mTFjBq1atVLPebq5/vFz3r59O8lzPn2XUqFChTh+/DiVK1dO0ykSypUrByTe8ZWez+Pu7k7btm1p27YtkZGRdOnShYULF6ZZ0uTo6EiDBg3YsWMHY8aMYfv27VStWtViQH2hQoVQFIUCBQo8s0UxOXx8fNiyZQvHjx/n2rVrKIqCj49PkuMKFSpEr1696NWrFzdv3qRVq1Z89dVXz01G04KjoyNNmzaladOmxMXFMXjwYJYuXUr//v3x8PDAyckJs9lM7dq10/R5H98BN2jQIE6fPk2nTp1Yt24dw4YNe+bxT7eavczbb7/N+PHj1S66mzdv0r9/f4tjChUqRFRUVJq/ttSytbXF29sbb29vzGYzEyZM4Pvvv2fQoEEULlxY6/BEBpAxTSLLOH78OIsXL6ZAgQK0aNECSEyCSpcuzdatW9XuB0gcP3H06FH1LiWTyWRxOzUkfrLMkycPcXFxwH+f0J/8RK4oCl9//bXFeXnz5sXT05OtW7eqY6sAfv31V/X29cd8fHwwmUwsXrw4yetJSEiwiPl5r/lZHo/VepxEvOrzPEtwcLDFtpOTE4UKFVLfr+dxdHRM0fM1bdqU+/fvs3HjRi5dupQkmXnnnXcwGAz4+flZ1A0k1s/TcT5L7dq1cXd3Z/v27fj7+1OhQgWLbtno6GhiY2MtzilUqBBOTk4vfb2v4unYbW1tKV68OIqiEB8fj8FgoHHjxuzcuTPJzxakrvsqIiKChIQEizJPT0/0ev0LX6uDgwNAkt+j53F1daVOnTr4+/vz888/Y2Njk2TCUx8fH37//XcOHz6c5PywsLAkcaanp+tCr9errXjp+TMgrIu0NIlM6dChQ1y/fh2TycTDhw85ceIER48eJV++fCxZsgQ7Ozv12JEjR9K3b186dOhAu3bt1CkHXFxc1FueIyMjqV+/Po0bN6ZUqVI4Ojpy7Ngxzp07p85FU6xYMQoVKsSMGTMICAjA2dmZnTt3PjMBGDZsGIMGDaJTp060adOGsLAwvv32Wzw9PS0SqerVq9OhQweWLVvGxYsX8fLywsbGhps3b7Jjxw7Gjh1r0RX1tEGDBlGgQAEaNmxIwYIFiY6O5tixY+zfv5/y5cvTsGHDNHmeZ2nWrBnVq1enbNmyuLu7c+7cOXXKhhcpW7Ysx48fZ9WqVeTJk4cCBQq8cNbl+vXr4+TkxIwZM9Qk4UmFChVi6NChzJkzh7t37/L222/j5OTEnTt32LNnD+3bt6d3794vjMnGxoZGjRrx888/Ex0dzahRoyz237x5kx49etCkSRNKlCiBwWBgz549PHz4kGbNmr3knUq93r17kytXLipXrkzOnDm5fv0633zzDfXr11cHbI8YMYITJ07Qvn173nvvPUqUKEFoaCjnz5/n+PHjz5yD6kV++eUXJk2aRJMmTShSpAgmk4kff/zxme/9k0qXLo3BYGD58uWEh4dja2tLzZo1k8wX9qSmTZvy8ccf891331GnTp0kU0P07t2bffv2MWDAAFq3bk3ZsmWJjo7mypUr7Ny5k71792bYZJTjxo0jNDSUmjVrkjdvXu7du8c333xD6dKlnzm1gsiaJGkSmdLjOZFsbGxwd3fH09OTTz755Jlrz9WuXZsVK1awYMECFixYgNFopFq1anz88cdqa4K9vb06MeOuXbtQFIVChQrx2Wef0blzZ/W5li5dqo7vsLOzo1GjRrz//vtJZhn29vZm7ty5LFy4kDlz5lCkSBGmTZvG1q1buXr1qsWxkyZNoly5cqxfv54vvvgCg8FA/vz5adGiBZUrV37h+zB58mT27t2Lv78/9+/fR1EUChYsyIABA+jbt6/FIOhXeZ5n6dq1K/v27ePo0aPExcWRL18+hg4d+tIEZfTo0YwfP5558+YRExND69atX5g02dnZ4e3tzbZt26hdu/Yz/wn369ePIkWKsHr1ahYtWgQkDrT28vJKMpno8zRt2pSNGzei0+mStGa99tprNGvWjOPHj/PTTz9hMBgoVqwY8+bNe2Ei8ao6dOjAtm3bWLVqFVFRUbz22mt07dqVQYMGqcfkypWLjRs3smjRInbv3s26detwd3enRIkS6nxCKVGyZEnq1KnD/v37CQgIwMHBgZIlS7J8+XIqVar03PNy587NxIkTWbZsGWPHjsVkMvH111+/MGny9vbG3t6eyMhIi7vmHnNwcGDt2rUsW7aMHTt2sHXrVpydnSlSpAiDBw9Os4HpydGiRQs2bNjAd999R1hYGLlz58bHx4fBgwc/d5yYyHp0ytPt2UKIdNOyZUs8PDxYtWqV1qEIIYRIIUmPhUgH8fHxScZbnDhxgkuXLiWZeVoIIUTmIN1zQqSDgIAAevbsSYsWLciTJw/Xr19n/fr15M6dm44dO2odnhBCiFSQpEmIdODm5kbZsmXZuHEjQUFBODo6Ur9+fT766CNy5MihdXhCCCFSQcY0CSGEEEIkg4xpEkIIIYRIBkmahBBCCCGSQZImIYQQQohkkIHgL6AoCmazDPmyBnq9TurCSkhdWBepD+shdWEd9HpditdCTC5Jml5Ap9MRFhZFQkLKV68Xacdo1JMjh5PUhRWQurAuUh/WQ+rCenh4OGEwpE/SJN1zQgghhBDJIEmTEEIIIUQySNIkhBBCCJEMkjQJIYQQQiSDJE1CCCGEEMkgSZMQQgghRDJI0iSEEEIIkQySNAkhhBBCJIMkTUIIIYQQySBJkxBCCCFEMlhV0nTr1i3Gjx9Py5YtKVOmDM2bN0/WeYqi8OWXX9KgQQMqVKhAhw4d+OOPP9I3WCGEEEJkK1aVNF29epWDBw9SuHBhihcvnuzzli9fzoIFC+jRowfLli0jd+7c9OrVi7///jsdoxVCCCFEdmJVSZO3tzcHDx5kwYIFlC1bNlnnxMbGsmzZMnr16kWPHj2oVasWc+fOxd3dnZUrV6ZzxEIIIYTILoxaB/AkvT7lOdzp06eJiIjAx8dHLbO1taVRo0bs3r07LcMTQgghhBYUBWJi0MXFQoIJXUI8xD/6UhSLQ3WupcFgly5hWFXSlBrXr18HoFixYhblxYsXZ82aNcTExGBvb5/q6xsMVtUYly09rgOpC+1JXVgXqQ/rIXVBYvISHw8x0ehiYtDFxEBUFLqoKHSREegiIyEyEl1kJLqoyP+2oyLRhYejCwtFFxb231dUJMTEoouJRhcb+/KnB1YA7a9dw+2pnCCtZPqkKSwsDFtbW+zsLLNKV1dXFEUhNDT0lZImV1eHVw1RpBGpC+shdWFdpD6sh9XWxaOWGsLCIDQ08Xt4OERGQkTEf99jYiAuzvIrJibxKzr6v+9RUYnnR0T89xUVlaTVJ6M8BPoCW4G3ALd0ep5MnzSlt7CwaEwms9ZhZGsGgx5XVwepCysgdWFdpD6sR4bWRXw8ugcP0Af8i+7hA/QPHqB7+BD9wwfoAh+iCwmxbLUJf/Q9ISF940ojisGA4uqG4uQEDvYodvZg74Bibwc2tig2NmBjBIMRbGz4JTiIjseO8k9MTLrHlumTJldXV+Li4oiNjbVobQoLC0On0+Hm9mr5pslkJiFB/hhZA6kL6yF1YV2kPqxHiutCUdBFhKMLDEQf+BB9UGDi45BgdCHB6IMffQ8KQv/gAfr7/6ILDESnUYuOReh2dihOTihOziiOjolfdvZgZ4fi4JD42MEh8RhHp0ffHf977OT8X5mzC4qrK2ZXN3B0BJ0u2XG43r1DVIPaEBODh4cHuXPnSbfXnOmTpsdjmW7cuEGpUqXU8uvXr5MvX75X6poTQgghUsRkQhcUlJj0PHiI/sF99A8fqN91gYHogwLRBwaiC0p8rIuPT5dQFKMRxdUVxSUxGUl87JKYoDz+/jhpeZz42DuArQ2KjS3YPmrVsU9s7VHs7RP329uhODiCjU26xJ1S+fMXYM6c+XzzzRoWLlyKo6Njuj1Xpk+aKleujLOzM/7+/mrSFB8fz65du6hXr57G0QkhhMiUFAUiI9GHBKMPDkpMhIKD0AU/2g4OQh/06HtwEPrgYAgJxj04ON1agRQbG8x58mLOmxdzntcw530Nc+7cmHPlxpwrF0qu3Jhz5sLsngPF1RXs7VPUYpMZKIrCt99+TYsWrXB1/a8nqUWL1rz7bit06fx6rSppio6O5uDBgwDcvXuXiIgIduzYAUD16tXx8PCge/fu3Lt3T51OwM7Ojv79+7Nw4UI8PDzw9PRk3bp1hISE0Lt3b81eixBCCCsRG5vY9RX4MHHsT+DDxMQnJARdaEhiF1hoCPqQEIsusdS0ACX3X7ZiZ5eY4HjkRMmZE3POnImPPXJizuGB4uGRmPzkyJH43d0dxc09yyVBKREQEMDQoYPYu3c3x48fZdGiLy32p3fCBFaWNAUGBvLhhx9alD3e/vrrr6lRowZmsxmTyWRxTN++fVEUha+++oqgoCBKly7NypUrKViwYIbFLoQQIp3Exz8a1ByK/vEA5/DwxAHOEeHow8Mf3bIehi70UdITHJzYRRYcjD48LN1DNLu5o8+VkwQ3d8zuiYmOOVcuzLnzJLYAqS1CuTF75AQnp2ydAKXUrl3+DB3qy8OHDwHYuHE9/fsPokKFShkah05RrGA0mRULDo6UAZYaMxr15MjhJHVhBaQurEumro+4OHTh4Ynjfe4HJI75uR+A/v599AH/PnockPg4KCjDwjI7OVu27uTwSGz5yZEDcw4PzB4e/5U9bg1yd8dob5t568KKRUVFMWHCWFav/m+Fj9y587Bw4RK8vRs98xwPD6d0my/LqlqahBBCZDIxMU+N+QlC/2iws+5Rl1jioOegxFaiiHB0ERHJmqzwVSgGQ2Ki4+aOkjNXYldYrtyYc+VM3H6cCLm5o7g/+p4jh9UMbhZw7twZBgzozdWrV9Syxo19+OKLReTKlUuTmCRpEkII8Z/HSVBgYGLrz4P7ia0/j1t+ggITu7we3wEWFZluoSh2do8GO+fBnCPHo7u/3B7dmp54V5ji4vLfd2dndRyQ4uwCqViaS2jPbDazePFCpk2bRPyjcWUODg5MmjSNbt16ZsjYpeeRpEkIIbKy+Hj1ji81GXrc7aV+v5/uSZBiMKC4uaE4u6I4O6O4uGB2dk5s9cmTF3OePInfc+dJTJTy5Mn2A5+zq59//olJkz5Vt8uXr8jSpSt54w1PDaNKJEmTEEJkNoqSeJfXgwCICMb2ynVs7917NDboAbrHLUQPH6IPDUn7p9frE8fz5Hg0vscj8e4vi7E+OXMlluXMiTlnLhRXN0mARLI0b96St99+h717d+Pr+yGjR4/D1tZW67AASZqEEMI6RUVhuHkDw43rGG7fwnDrBvrbtxIf/30bXXS0eqjTKz5VYhKUE7OHx3+3vXt4JN7xlTuxBUjJnSfxca5HCZB0fYk0Eh8fj80TY8l0Oh3z5i3mypVL1KljXfMtStIkhBBaUBR09+9j+PtRInT7VmJSdOM6huvXMPxz75Uub3Z2Qcn1aAC0h4fl/D+PJkg0PZogUcmZEwyGNHphQiTfqVO/4uvbjxkz5tKggbdanidPHvLkSb/lUFJLkiYhhEhHuvCwxETor6sYrl7BcO0qxqtXMVz/y6K1KLkUOztMBQthzlcAJX8+7IoWJipHLuLzvJ44LuhRixAODunwaoRIGwkJCcyfP4fZs6djMpkYPHgABw8ex8Mjp9ahvZAkTUII8SrM5sTB1LdvY7h9M7HV6MZ19Uv/8EHKL5kzJ6YixTAVK46paDFMhYtgKlQEc+HCmPPkVbvGjEY9djmciJW5gUQmcuvWTXx9+/Hrr7+oZQUKFCQqKkqSJiGEyAp04WEYrlzGcPUKxiuXMVy9nNh6dOfvFM85pBgMmIoUxVSkKOZChTEVLIypcGHMBQthKlos8a4xIbIYRVH44YfvGTVqBBER4QDo9XpGjBjFsGEfYzRaf0pi/REKIURGUhT0f9/GeP5PjH+exfjnOYznz2G4fSvFlzLlfQ1T0WKYixQloYQnpjc8MZV4A1PhImAldwMJkRFCQ0MYOXIYW7ZsUssKFSrC4sXLqV69hoaRpYwkTUKI7ElR0D14gPGvKxgunsd44QLGi+cxXLqI/tGn4JdewsHhUdfZo1aiQkUwPWotMhUpmri+mBDZ3O+//0bv3t24c+dvtax9+05MmzYLFxdXDSNLOUmahBBZnu7+fWzOnMZ47mxil9r1vzD89Rf6sNBkna84OpFQpiwJpUpjeqMkJk9PEt4oiblAQbn1XoiXcHfPQXBwMABubu7MmvUFrVq11Tiq1JGkSQiRpejCQjH+fhqb33/D+PtpjGd+x3DvbrLPNxUoSELpMiSUK09CuQqYypbDVKSYJEdCpFLRosWYOnUm33//HYsWfUn+/AW0DinVJGkSQmResbEYL1/E+MfvGE+fwua3kxiuXEanKC88TdHpMBcoiKl4CUzFS5BQqgwJpctiKlUqceJGIUSqKIrCpk0b8PFpjtMT3dMdO75Phw6d0WfyDx+SNAkhMoeIiMTB2ef+wHjuLDZnz2C4fBFdQsILTzM7u5BQsRIJFd9M/F6yNKaixWQeIyHSWGBgIMOHD8bf/39069aL2bPnqft0Op2mC+2mFUmahBDWJy4O4x+/Y3PyhJokGf66+vIWJKORhLLlSahSlfjKVUmoXBVTseLStSZEOtu/fy9DhgwkIOBfAL7++iu6d+9F+fIVNI4sbUnSJITQXnQ0NqdPYXP8aOLXqV9fOlu2otdj8ixJQrkKJJSvmJgkVagoLUhCZKCYmBimTJnIsmWL1DIPDw+++GJRlkuYQJImIYQGdEGB2Jz8FZtfjmFz4jjGM7+ji49/7vGKrS0JpcuSUKFiYpJUoSIJpcuCo2MGRi2EeNKlSxcZMKA3Fy78qZY1aODNwoVLyZv3NQ0jSz+SNAkh0l9EBLa/HMXm0EFsDx/EeP7cCw835S9AfC2vxK83q2AqWQqeWAVdCKEdRVFYuXIZEyd+Suyj2fDt7Oz49NOJ9OkzINMP9n4RSZqEEGnPbMZ49g9s9+3Bdv9ejL+dfOGA7YQSbxBfoxbxNWsTX8sLc6HCGRisECIlfvxxM598MlLdLl26DEuWrKRMmbIaRpUxJGkSQqQJ3cOH2B7ch+3e3dge2Iv+4cNnHqfodIljkGp5JSZJ1Wui5M6dwdEKIVLr3Xdb4eX1FUePHqZfv4GMGzcRe3t7rcPKEJI0CSFSRRcRnjho+3GX2xPjGp6WUKw48fUaEFe3AfF16qLk8MjASIUQr8JkMmEwGNRtg8GAn98yLl++iLd3Iw0jy3iSNAkhkkdR0F+9Aof34bz1R4y/HH9ul5vi6ERcvfrEeTcizvtt6W4TIpM6d+4MH3zQn5kz51GjRk21PH/+Apl6Zu/UkqRJCPF8cXHYHD+K7Z6d2O7agfHGdQCeHpKtdrnVrU9cw7eIr1EL7OwyPl4hRJowm80sXryQadMmER8fj69vX/btO4JrNp8xX5ImIYQFXUAAdnt3YbtrBzYH96OPjHjmcaYiRYlr4C1dbkJkMffu3WXw4AEcPnxQLXN3z0FISIgkTVoHIITQmKJguHgBu53bsd3xMza/n372YQYDCbW9sGnVktC63sQVKZ7BgQoh0ttPP23ho48+JCQkBEhc/uSDD4YyatRYbG1ttQ3OCkjSJER2pCgYT/yC3f+2YrfDH8Ptm888zJwzZ+K4pEaNiWv4FoacHuTI4YQ5OBISzBkbsxAi3UREhDN27CjWrftGLcuXLz+LFn2Jl1ddDSOzLpI0CZGN6G9cx37jeuw3rsdw6+Yzj0koU47Yxk2Ie7sxCZWrwhN3zQghsp6zZ/+gT5/u3Lx5Qy1r0aI1s2fPw909h4aRWR9JmoTI4nT372P3vx+x37QBm5MnkuxXjEbia9cltokPcY2bYi5YSIMohRBasbOz599//wHAycmZadNm0aFDZ3Q6ncaRWR9JmoTIgnSBgdht34bd1s3YHD2EzmzZlabodMTXbUDMex2Ia9IUxc1dm0CFEJorWbIUn302mR9++J7Fi5dTtGgxrUOyWjpFURStg7BmwcGRJMjYDU0ZjXpy5HCSuniZ2Fhsd/ljv/5bbPfvfeYcSgmlShPzXidi276HOV/+FD+F1IV1kfqwHpmlLhRFYfv2//HWW40sZvFWFAWTyYTRmPnbUjw8nDAY0mf9u8z/7giRnSkKxj9OY7/+W+y2/ID+0R0vTzIVLkJsq7bEtGyDqWw5kCZ3IbKl0NAQRo4cxpYtmxgw4AMmTZqq7tPpdFkiYUpv8g4JkQnpwsOw2/g9Dmu+wnjxfJL9pnz5iW3VlthWbUio+KYkSkJkc8ePH8XXtx937vwNwNKlfnTq1IXSpctoHFnmIkmTEJmI8dwZ7Fd/hf2mDeiiIi32KQ4OxDZrQUyHzsTXqSd3vQkhiI+PZ9asacyfP4fHo3FcXd2YPXueJEypIEmTEFZOf+8udls3Y7d5IzZn/0iyP75qdWK6dCf23ZYoLq4ZH6AQwipdu3aVgQP78Mcfv6tltWvXwc9vGQUKFNQwssxLkiYhrJAuJBi7n7YmJkrHj6J76n4Ns5Mzse91ILp778RxSkII8YiiKHz77deMGzeKqKgoAIxGI6NHj8PX90MM0gqdapI0CWEtFAWbY0ew/2YNdv/7EV1sbJJD4iu9Scz73Ylt+x6Ks4sGQQohrN3mzRsZPnywul28eAmWLl1JxYpvahhV1iBJkxAa092/j/36b7H/dg3GG9eT7E8oXoLYtu2JbdMOU7ESGkQohMhMWrZsw4oVy/jtt5N07dqTSZOm4uTkpHVYWYIkTUJoQVEw/noCh1VfYrftR3Tx8Ra7zTlyENOuA7EdOpNQvqLc/SaEeC5FUSxm7zYajSxevJyLFy/QtGlzDSPLeiRpEiIjRUZiv2kDDqtWYDx/LsnuuLr1Ewd1+zSHJyaeE0KIZ7l06SJDhgxg1qx5Ft1vRYsWk5m904EkTUJkAN39+zh8tQyHVSvQBwdb7DN7eBDzfneiu3THLH/khBDJoCgKK1cuY+LET4mNjWXAgN7s2XNYuuHSmSRNQqQjw7WrOCz2w37Dd0kGdsdXqUp0jz7EtmwjrUpCiGQLCAjgww8Hsm/fHrXM1taWhw8fSNKUziRpEiKtKQo2hw7gsHIZtjv9LaYLUIxGYlu3I7rfwMSZuoUQIgV27fJn6FBfHj58qJb16zeQceMmWqwlJ9KHJE1CpBFdRDh233+Hw1fLMV69YrHP7OxCTNceRPcbiDl/AY0iFEJkVlFRUUyYMJbVq1eqZXny5GXBgiV4e7+tYWTZiyRNQrwiXUAAjn7zsP/2a/QR4Rb7TK/nI7rPAGK690RxddMoQiFEZnb+/J/069eDq098GGvSpClz5/qRK1cuDSPLfiRpEiKVdPfv4+g3D4c1K9FFR1vsi6tdh+je/Yhr0gxsbDSKUAiRFZhMCdy8eQMABwcHJk2aRrduPS2mGRAZQ5ImIVJI9/BhYrK0arlFsqQ4OBDTriPRvfrK0iZCiDRToUIlRo/+lB9/3MySJSt44w1PrUPKtnSK8tSiVsJCcHAkCQlmrcPI1oxGPTlyOGlfFxEROC71w2HRAvSREWqxYm9PdPfeRH0wFCVvXu3iywBWUxcCkPqwJmlZF/v27aFu3frYPNFKbTabSUhIwNbW9lVDzfI8PJwwGPTpcu30uaoQWUl8PParVpCzRiWcZk5VEybFzo6ofgMJOnmWyM+nZfmESQiRviIiwvnww0F07NiGOXOmW+zT6/WSMFkB6Z4T4nkUBdv//YjT5AkWa8IpBgMxXXoQNWIk5tde1zBAIURWcerUrwwa1FcduzRv3hxat36PkiVLaRyZeJIkTUI8g/HkCZw/G4vNqV8tymNatCZqzDhMxd/QKDIhRFaSkJDAvHmzmTNnBiaTCQAnJ2emT5+Np2dJjaMTT5OkSYgn6G9cx2nKROx/2mJRHudVl8hPJ5JQuapGkQkhsppbt24yaFBfTp48oZZVqVKNxYuXy7pxVkqSJiEAoqJwmjUNhy8Xo4uPV4sTPEsS+dnnxL3dGOT2XiFEGlAUhR9++J5Ro0YQ8WhuN71ez4gRoxg27GOMRvnXbK2kZkS2Z3P8KM5DfS3GLZlz5SZy1Fhi3u8G8gdMCJGGNm3agK9vP3W7UKEiLF68nOrVa2gYlUgOuXtOZF8RETiP+Qj3lj5qwqTY2RE57COCfv2DmO69JGESQqS5d99tRblyFQBo374T+/cfkYQpk5D/CCJbsjl0AJfhgzHcvqWWxVerQfj8xZhKyCBvIUTaURTFYvZuOzs7lixZwcWL52nVqq2GkYmUkpYmkb1ER+M0diTu7VqoCZPi4EDE5OmE/LRDEiYhRJq6du0qLVv6cOnSRYvykiVLScKUCVld0nTt2jV69uxJpUqV8PLyYubMmcTFxb30vODgYMaPH0+DBg2oVKkSzZs3Z926dRkQscgsjGf/IEejejguX6qWxXnVJejAcaL7DQKDQcPohBBZiaIofPPNGt56qy6//HKMAQN6ExMTo3VY4hVZVfdcaGgo3bt3p0iRIixcuJCAgACmT59OTEwM48ePf+G5H374IdevX2f48OG8/vrrHDp0iAkTJmAwGGjfvn0GvQJhlUwmHPzm4TRjCrqEBCBx6ZOI8ZOI6dUP9Fb32UEIkYkFBQUyfPgQtm/fppbFxsbw77//UKRIUQ0jE6/KqpKm9evXExkZiZ+fH+7u7gCYTCYmTpxI//79yfucZSoePHjAiRMnmDZtGm3atAGgVq1anDt3jp9//lmSpmxM/+8/uPTrie0vx9Sy+AqVCF/0JSaZaVcIkcb279/HoEH9CAj4Vy3r2rUnkyZNxcnJScPIRFqwqo/Yhw4dolatWmrCBODj44PZbObo0aPPPS/hUeuBi4uLRbmzszOyHnH2ZXP0MDm866gJk6LXEznsI0K275GESQiRpmJiYhg+fDht27ZQEyYPDw/WrFnHnDnzJWHKIqwqabp+/TrFilnOgurq6kru3Lm5fv36c86C119/nTp16rB06VL++usvIiIi2L59O0ePHuX9999P77CFtVEUHPzm49auBfqHDwAw5S9AyI87iBozHmTRSyFEGrp8+RKNGjXgiy++UMsaNPDm4MFf8PFppmFkIq1ZVfdcWFgYrq6uScrd3NwIDQ194bkLFy5k2LBhNGuW+ANqMBgYN24cjRs3fqWYDAaryiuzpcd1kKy6CAvD6YMB2P7vJ7UovoE3kcu/gpy5rOsHPhNKUV2IdCf1YR0iI8PVu+Ps7Oz47LNJ9Os3EL2Ml9REei7ekCX+hyiKwpgxY7h58yZz5swhd+7cHDt2jKlTp+Lm5qYmUqnh6uqQhpGKV/HSurhwAVq3hitX/iv79FNsPvsMd7kzLk3J74V1kfrQVuPG3owbN45Nmzbx3XffUb58ea1DEunEqpImV1dXwsPDk5SHhobi5ub23PMOHDjAjh07+OmnnyhZMnFV6Bo1ahAYGMj06dNfKWkKC4vGZDKn+nzx6gwGPa6uDi+sC5uftuL0wQB0EREAmN3ciVy2goR3mkCY3OabVpJTFyLjSH1o49ixI9SoUQvDEx/GhgwZwejRo4mLUwgOjtQwOuHm5pBurXxWlTQVK1Ysydil8PBwHjx4kGSs05P++usvDAYDnp6eFuWlS5dm48aNREdH4+CQuk9iJpOZhAT5Y2QNnlkXJhNO0yfjOH+OWpRQtjyhq77BXKQoSN2lC/m9sC5SHxkjKiqKCRPGsnr1SsaNm8CQIcPVfUajHnt7e6KjI6UuNJae939ZVYdrvXr1OHbsGGFhYWrZjh070Ov1eHl5Pfe8/PnzYzKZuHz5skX5+fPnyZkzZ6oTJmHddMFBuHVuZ5EwxbRtT/DPuxMTJiGESCPnzp2hUaN6rF69EoDp0yfz119XNY5KZDSrSpo6duyIk5MTvr6+HDlyhE2bNjFz5kw6duxoMUdT9+7dadSokbpdr1498uXLx5AhQ/jxxx85fvw4s2bNYsuWLXTp0kWLlyLSmf7v2+Ro3BDb/XsBUAwGIiZPJ3zxcnB01Dg6IURWYTabWbRoAU2aeHP1auJ4SQcHB6ZNm03x4iU0jk5kNKvqnnNzc2PNmjV8/vnn+Pr64uTkRLt27Rg2bJjFcWazGZPJpG47OzuzevVqvvjiC2bPnk14eDgFChRg9OjRkjRlQfrbt3Bv01xdO86cKxdhy9cQ71VX48iEEFnJvXt3GTx4AIcPH1TLKlSoxJIlK3jjDc8XnCmyKp0isz++UHCw9E9rzWjUkyOHE8HBkZiv38C9dTMMf98GIKF4CUJ/+Alz/gIaR5k9PFkX8nuhPamP9LNt21ZGjBhCSEgIADqdjg8+GMqoUWOxfcZcb1IX1sPDwyndpuGwqpYmIV5Ef/sWrk8mTCXeIHTz/zC/9rrGkQkhspKNG9fj69tP3c6XLz+LFn2Jl7RmZ3tWNaZJiOe6cQPn5k3+S5je8CR0y8+SMAkh0lyzZi3U7rcWLVpz4MAxSZgEIC1NIhPQX78Gbd7FcOdvIDFhCtn8M8pzFnAWQohX4ejoyNKlKzl//k86dOiMLj2nmBaZirQ0CatmuHwJl+aN4fajFibPkpIwCSHSzK1bN2nfvhXXr/9lUV6+fEU6dnxfEiZhQZImYbWM587g3soH/b+JK4abSpchZNP/JGESQrwyRVHYuHE9DRt6ceDAPgYO7EN8fLzWYQkrJ0mTsErGU7/i1uZd9IGBiQVVqhC+zV8SJiHEKwsNDWHAgF74+vYjIiJx6a7AwCDu3r2jcWTC2knSJKyOzbEjuL3XCn1oCAAJ1WvC3r0oHjm1DUwIkekdP36Uhg292LJlk1rWvn0n9u8/QhFZSUC8hCRNwqrY7NuDW6e26CMTF96Nq1uf8E0/wgsWbBZCiJeJj49n6tRJtGrVlDuPbipxdXXjyy9X4ee3DBcXV40jFJmB3D0nrIbtz9tw7dcD3aNxBbGNGhO24muMTk4aRyaEyMyuXbvKwIF9+OOP39Wy2rXr4Oe3jAIFCmoYmchspKVJWAW7jetx7dPtv4Tp3VaErfoWZLFlIcQrunv3rpowGY1Gxo2bwKZN2yRhEikmSZPQnP3Xq3D5oD+6R+sJxnToTNiyr+AZSxUIIURK1avXgEGDhlC8eAn8/fcyZMhwDAaD1mGJTEiSJqEph2WLcPnoQ3SPlkCM7tGb8PmLwSg9x0KI1Pn9998wmy3Xfxsz5lP27DlMxYpvahSVyAokaRKasfv+O5w/HaNuR/l+SMSMuaCXH0shRMrFxMTw6adjaNy4IStXLrPYZ2dnh5OMjxSvSP47CU3YHD2My/DB6nbkx2OIHD8JZPZdIUQqXLp0kSZNvFm2bBEAkyaN5/r1axpHJbIaSZpEhjNcvYJrj/fVQd/RvfoS9dFoSZiEECmmKAorViylUaN6XLjwJ5DYqvTppxNl3iWR5mTgiMhQuocPcevcTp24Mvbtd4iYPEMSJiFEigUEBDB06CD27t2tlpUuXYYlS1ZSpkxZDSMTWZW0NImMExODW7eOGG7dBCChbHnCv1wlg76FECm2a5c/DRvWskiY+vUbyM6dByRhEunmlf5bxcXFcf78eQIDA6lcuTIeHh5pFZfIasxmXIYMwObUrwCYXnud0G83oDi7aByYECKz2bBhHR980F/dzpMnLwsWLMHb+20NoxLZQapbmr7++mvq1KlD586dGTx4MJcvXwYgKCiIGjVq8MMPP6RZkCKTUxScPx6G/dbNiZuOToR98z3mfPk1DkwIkRn5+DSjUKEiADRp0pQDB45LwiQyRKqSpk2bNjF16lTq1q3LlClTUB7NsQPg4eFBzZo12b59e5oFKTIxRcFp3Cgc1q5K3DQYCPvyKxIqVNI2LiFEpuXi4sqSJcuZNWsea9asI1euXFqHJLKJVCVNq1at4q233mLOnDk0bNgwyf6yZcty9erVVw5OZHKKgtPkCTguX5q4qdcTvng5ce/4aByYECKzuHfvLj16vK8usvtYtWo16N69Fzq5iURkoFQlTbdu3aJevXrP3e/u7k5ISEhqYxJZhOPs6Tgu/ELdDp+3iNjW7TSMSAiRmWzbtpUGDWqxffs2Bg3qi+nRUktCaCVVSZOrqyvBwcHP3f/XX3+RO3fuVAclMj+HhfNwmjVN3Q6fNY/Yju9rGJEQIrOIiAjnww8H0bt3N/UD+O3bt5K0NgmR0VKVNNWrV48NGzYQFhaWZN/Vq1fZuHEj3t7erxycyJxsf96G8+fj1e2IydOJ6d5Lw4iEEJnFqVO/4u1dh3XrvlHLWrRozYEDxyhcuIh2gQlBKqccGDp0KO3bt6d58+Y0bNgQnU7H1q1b2bRpE7t27SJ37twMGjQorWMVmYD+xnVcPvyv7iM/GU90P/lZEEK8WEJCAvPmzWbOnBlqN5yTkzPTps2iQ4fOMnZJWIVUJU158+Zl8+bNzJ07F39/fxRF4ccff8TJyYlmzZrx0UcfyZxN2VFMDK59e6APC03cbNWGqA9HaByUEMLa3bp1k0GD+nLy5Am1rEqVaixevJyiRYtpGJkQlnTKk/MFpFJQUBBmsxkPDw/0WWyF+uDgSBISzFqHkSk4jxqOw6oVACQUK07I7oMoLq6vfF2jUU+OHE5SF1ZA6sK6ZJX62LXLny5dOgCg1+sZMWIUw4Z9jDETrRaQVeoiK/DwcMJgSJ9cJFVXHTNmDGfOnFG3PTw8yJUrl5ownT17ljFjxqRNhCJTsNu6SU2YFHt7wlZ8nSYJkxAi63vnHR969uxDoUJF+OmnnXz88ZhMlTCJ7CNVSdOWLVu4ffv2c/ffuXOHrVu3pjYmkckYrl3FedhgdTti6ixM5cprGJEQwppdvHiBpzs5PvtsMvv3H6F69RoaRSXEy6VL+9X9+/ext7dPj0sLaxMdjWvv7ugjIwCIea8jMe930zgoIYQ1io+PZ+rUSTRoUIvvvltrsc/R0REXaZ0WVi7Z7Z979uxh79696vaGDRs4duxYkuPCw8M5duwY5cqVS5sIhVVzHjsS44U/AUgoWYrwmV+A3OUihHjKtWtXGTiwD3/88TsAY8eOpG7d+hQqVFjjyIRIvmQnTdeuXWPHjh0A6HQ6zpw5w59//mlxjE6nw9HRkWrVqjF69Oi0jVRYHbsN63D4Zg0AiqMjYcvXgJOTxlEJIayJoih8++3XjBs3iqioKACMRiPDh48kf/4CGkcnRMqk6u65UqVKMWvWLN599930iMmqyJ0Qz2a4fIkcjRuge/RHMGzhUmI7dE6X55K7UqyH1IV1sfb6CAoKZPjwIWzfvk0tK168BEuXrqRixTc1jCztWXtdZCfpefdcqm5PuHTpUlrHITKTyEhc+3RTE6bo97ulW8IkhMicDhzYx+DBAwgI+Fct69atFxMnTsFJWqRFJiX3dIqUURRcRg7DeDkxcU4oXZaIqbM0DkoIYU02blyPr28/dTtnzpzMneuHj08zDaMS4tWlOmk6ePAgq1ev5sKFC4SHhye5fRTg4sWLrxScsD72363FfuN6AMxOzoSt/BocHDSOSghhTd5++x1efz0f//xzj4YN32LBgiXkzfua1mEJ8cpSlTTt3LmToUOHUqJECZo2bcq6deto3rw5iqKwb98+ChcuzNtvv53WsQqNGf66ivOYj9TtiLkLMJV4Q8OIhBDWKEcOD/z8lnHx4nn69BmQ5VaKENlXqn6Sly1bRoUKFdi6dSuDBydOati2bVvmzJnDtm3bePDgAQUKyF0RWYrZjPOIIehiYgCI7t6b2NbtNA5KCKG1gIAABgzobTF2CaBu3fr06zdIEiaRpaTqp/natWs0bdoUg8GgTnWfkJAAQIECBejUqRPLly9PuyiF5uy/W4vt8aMAmAoVIWLiFI0jEkJobdcufxo2rMXmzRsZMmQgZrPcNSaytlQlTfb29tjY2ADg6uqKra0tDx48UPfnypWLO3fupE2EQnO6gACcJn6qbofPngeOjtoFJITQVFRUFCNHDqNLlw48fPgQgD//PMedO39rHJkQ6StVSVPRokW5du2aul26dGl+/PFHEhISiI2N5X//+x+vv/56mgUptOU8diT60BAgcZmU+Abe2gYkhNDMuXNnaNSoHqtXr1TLmjRpysGDv8js3iLLS1XS1KhRI/bu3UtcXBwAAwYM4Ndff6VatWrUrFmTU6dO0a9fv5dcRWQGtjv9sf9pCwDmnDmJmDRN44iEEFowm834+c2nSRNvrl69AoCDgwOzZs1jzZp15MqVS+MIhUh/qZoR/FlOnTrFrl27MBgM1K9fn5o1a6bFZTWXnWd31YWHkaNuDQz37gIQtuhLYt/rmOFxyEy71kPqwrpkVH3cu3eXwYMHcPjwQbWsQoVKLFmygjfe8Ey3581M5HfDeljdjODPUrVqVapWrapuR0RE4OzsnFaXFxpwmjpJTZjiGr5FbLsOGkckhNDCqVO/qgmTTqfjgw+GMmrUWGxtbTWOTIiMleapWGBgIHPnzqVhw4ZpfWmRgWx+OYb9V4l3QCoODoTP/AJ0Oo2jEkJooUWL1nTo0Jl8+fKzadM2Pv10oiRMIltKUUtTYGAgW7du5fbt27i5ufHOO+9Qrlw5IHGujiVLlrBlyxZiY2OpXr16ugQs0p8uLBQX337oHvXcRo4ah7lwEW2DEkJkmOvXr1GsWHGLsmnTZhEfH0+OHB4aRSWE9pKdNF27do0uXboQEhKiLpmyYsUKZs2ahU6nY+zYscTFxfHOO+/Qu3dvNZkSmY/z6I8w/H0bgLhaXkT3H6RxREKIjJCQkMC8ebOZM2cGixZ9SZs276n7nJ1dNIxMCOuQ7KRp/vz5REVF8dlnn1G1alXu3LnDtGnTmDp1KuHh4TRs2JCPPvqIggULpme8Ip3ZbfkB+x++B8Ds6ka43zIwGDSOSgiR3m7dusmgQX05efIEACNHDqdGjVrkzy+rOwjxWLKTplOnTtGpUyc6dky8e6pEiRIYDAb69u1L69atmTZNbkXP7PR37+A8cri6HTFjDuaChTSMSAiR3hRF4YcfvmfUqBFERIQDoNfr6ddvoCyyK8RTkp00hYSEULJkSYuyUqVKAcjivFmB2YzLB/3/m8SyTTti27bXNiYhRLoKDQ1h5MhhbNmySS0rVKgIixcvp3r1GhpGJoR1Svbdc2azWV1n7rHH246ypEam57DED9ujhwEw5S9AxIy5GkckhEhPx48fpWFDL4uEqX37Tuzff0QSJiGeI0V3z/3555/Y2dmp25GRkeh0On777TfCw8OTHP/OO++8eoQi3RmuXMZp6kQAFJ2OcL9lKG7u2gYlhEg3P/zwPb6+/dSbetzc3Jk16wtatWqrcWRCWLdkzwj+uCsu2RfW6bh48WKqgrImWX52V0XB7b1W2B7aD0CU74dEfva5xkFZkpl2rYfUhXVJbX3cv3+fBg1q8vDhQ2rXroOf3zIKFJCbeF6F/G5YD6uYEfzrr79OlwCEtmz9f1YTJlPBQkSO/ETjiIQQ6S1PnjzMn7+Yixcv4Ov7IQa5Q1aIZEmzteeyqiz9qSEmBo861THcvglA6FffENe8hbYxPYN8grMeUhfWJTn1ERgYyJQpExg7dgI5c+bM4AizD/ndsB5W0dIksh7HJQvVhCmubgPimr2rbUBCiDS1f/9ehgwZSEDAvwQGBrJ69bfoZDkkIVItfVIxYfX0d+/gOH8OAIrBQMSUGbK2nBBZRExMDJ9+OoYOHVoTEPAvAL/+epw7d/7WODIhMjdJmrIpp0mfoouKAiC6dz9MpUprHJEQIi1cunSRJk28WbZskVrWoIE3Bw4cp6BMVivEK7G6pOnatWv07NmTSpUq4eXlxcyZM4mLi0vWuQEBAYwaNYqaNWtSoUIFfHx8+Omnn9I54szH5vhR7B/NzWLOmZOoj8doHJEQ4lUpisKKFUtp1KgeFy78CYCdnR2TJ09n/frNMru3EGnAqsY0hYaG0r17d4oUKcLChQsJCAhg+vTpxMTEMH78+Beee//+fTp06EDRokX5/PPPcXZ25urVq8lOuLINkwnnT0aqm5GffCZzMgmRyQUEBODr2599+/aoZaVLl2HJkpWUKVNWw8iEyFqsKmlav349kZGR+Pn54e7uDoDJZGLixIn079+fvHnzPvfcWbNm8dprr7FixQr19tlatWplRNiZiv36bzGePwdAfIVKxHTuqnFEQohXdeDAPouEqV+/gYwbNxF7e3sNoxIi60l199y9e/cYP348jRs3pnr16pw8eRKAoKAgJk+ezIULF1J8zUOHDlGrVi01YQLw8fHBbDZz9OjR554XERGBv78/nTt3lvlGXiQqCscZU9TNiMkzQN4vITK99u070qJFa/Lkycv69ZuZPHmGJExCpINUtTT99ddfvP/++5jNZipUqMDt27dJSEgAwMPDg99++42oqCimTp2aoutev36dtm0tp/F3dXUld+7cXL9+/bnnnT9/nvj4eIxGI126dOH333/H3d2dVq1aMXToUGxsbFL+Ih9Jr7ketGC/cimGf/8BIK5pc6jjZV1Njc/xuA6yUl1kVlIX1uHu3bvkz59frQej0cC8eQtISEggV67cGkeXPcnvhvVIzxvBU/U/c9asWbi4uLBhwwYAateubbG/fv36+Pv7p/i6YWFhuLq6Jil3c3MjNDT0uec9fPgQgHHjxtG+fXs++OADzp49y4IFC9Dr9YwYMSLFsTzm6uqQ6nOtysOHMP/RIrx6PbazZmCbw0nbmFIoy9RFFiB1oQ2z2cycOXMYO3YsGzdupGXLlkBifbi6FtA4OgHyu5HVpSppOnnyJL6+vnh4eBAcHJxkf758+QgICHjl4JLLbE6cfbV27dqMHj0agJo1axIZGclXX32Fr69vqpuqw8KiMZky/+yuDp9OwD4sDIDY97sR9XphCI7UOKrkMRj0uLo6ZJm6yMykLrRz9+5dfH37cejQQQB69erF8eMn8fQsJvVhBeR3w3q4uTmg11vRjOCKorwwCQkKCsLW1jbF13V1dSU8PDxJeWhoKG5ubi88DxITpSfVqlWLpUuXcuvWLUqWLJnieABMJnOmnxJff+smdiu/BEBxcCDi4zGYM+Frygp1kVVIXWSsbdu2MmLEEEJCQoDEBdE7d+6Gm1sOQOrDmkhdaC89F4dLVSpWpkwZDh48+Mx9CQkJ/Pzzz1SsWDHF1y1WrFiSsUvh4eE8ePCAYsWKPfe8EiVKvPC6sbGxKY4lK3GaPhldfDwAUf19Mb/2usYRCSGSIyIinA8/HETv3t3UhClfvvxs2rSN8eMnperDqRAi9VKVNPXr14/Dhw/z2WefcfXqVSBxUchjx47Rq1cvrl+/Tr9+/VJ83Xr16nHs2DHCHnUjAezYsQO9Xo+Xl9dzz8ufPz+enp4cO3bMovzYsWPY29u/NKnKyoznzmC/KXHsmdnDg+gPPtQ4IiFEcpw69Sve3nVYt+4btaxFi9YcOHCMOnXqaRiZENmXTlFS15C1detWpk6dSnh4OIqioNPpUBQFZ2dnJkyYQPPmzVN8zdDQUJo1a0bRokXp37+/Ornlu+++azG5Zffu3bl37x67d+9Wy/bt28egQYPo2rUrDRo04Ny5c/j5+dG7d2+GDRuWmpcIkOlXrHZ7ryW2B/cDEPH5NKL7+2ocUcrJ6uHWQ+oiY2zatIEPPuiPyWQCwMnJmWnTZtGhQ2eLBXelPqyH1IX18PBwSre7GFOdNAFERUVx7Ngxbt68idlsplChQtSpUwdnZ+dUB3Tt2jU+//xzfv/9d5ycnGjZsiXDhg2zaIbu2rUrd+/eZd++fRbnbt++ncWLF3Pz5k3y5MlDhw4d6Nev3yut6p2ZfwFsDuzDvX0rAEyFChN09BTY2WkbVCrIHyPrIXWRMe7du0uDBrUICQmhSpVqLF68nKJFkw5RkPqwHlIX1sPqkqbHLUvZQab9BTCbcW9UH5tzZwAIW7KC2LbtNQ4qdeSPkfWQusg427Zt5dKliwwb9jFG47Pv2ZH6sB5SF9YjPZOmVF21bt26TJ48md9++y2t4xFpxG7zRjVhiq9QidjW7TSOSAjxLKGhIYwdO5KwMMu56N59txUffzzmuQmTECLjpeq3sXr16mzatIlvv/2WvHnz4uPjg4+PDxUqVEjr+ERqxMbiNH2yuhn56URIpzkrhBCpd/z4UXx9+3Hnzt8EBQWxZMkKrUMSQrxAqpKmuXPnEhMTw/79+/H392fdunWsXr2a/Pnz07RpU3x8fChdunRaxyqSyWHVcgy3bwEQ18Cb+PoNNY5ICPGk+Ph4Zs2axvz5c3g8QmL37p3cvXuH/PllZm8hrNUrDQR/LCoqin379rF9+3aOHDlCfHw8hQsXZseOHWkRo6YyW/+0LjQEj+oV0QcHo+h0BO85jKl85m4BlLEC1kPq4tVdu3aVgQP78Mcfv6tltWvXwc9vGQUKFEzRtaQ+rIfUhfWwujFNT3N0dKR58+bMmjWLkSNH4ujoyK1bt9Li0iKFHBfOQ/9oaZvYtu0zfcIkRFahKArffLOGt96qqyZMRqORceMmsGnTthQnTEKIjPfKIwyjo6PZt28f/v7+HD58mLi4OAoVKoSPj09axCdSQH/vLg5fLgZAsbUlcvQ4jSMSQgAEBQUyfPgQtm/fppYVL16CpUtXUrHimxpGJoRIiVQlTbGxsRw4cIDt27dz6NAhoqOjyZ8/P127dqVp06aUKVMmreMUyeA4cyq6mBgAonv1w1yosMYRCSEAfv55m0XC1LVrTyZNmoqTk5OGUQkhUipVSVPNmjWJiYkhT548tG/fnqZNm6ZqrTmRdgwXL2C//lsAzK5uRA0doXFEQojHunTpjr///zh9+hRffLEIH59mWockhEiFVCVNbdq0wcfHh6pVq6Z1PCKVnCZ9is6cOPgwashwFI+cGkckRPb14MEDcufOrW7rdDrmz1+CyZTAa7JgthCZVqoGgn/66aeSMFkRmwP7sNubuA6fqUBBovsO0DgiIbInRVFYsWIpVauWY//+vRb7cufOLQmTEJlcslqaTp48CUC1atUstl/m8fEiHZlMOE/4b8B35CfjwcFBw4CEyJ4CAgL48MOB7Nu3B4AhQwZy4MBxcuaUVl8hsopkJU1du3ZFp9Nx5swZbG1t1e3nebw23cWLF9MsUPFsdhvWYbzwJwDxld4kts17GkckRPaza5c/Q4f68vDhQ7WsZcvWMtBbiCwmWUnT119/DYCtra3FttBYZCROUyf9tzlhiiyXIkQGioqKYsKEsaxevVIty5MnLwsWLMHb+20NIxNCpIdkJU3Vq1d/4bbQhuOShRgC/gUgtkkz4mvX0TgiIbKPs2f/YODAPly9ekUta9KkKXPn+pErVy4NIxNCpJdUNUt069aN48ePP3f/L7/8Qrdu3VIdlHg5fcC/OPrNB0AxGon8bNJLzhBCpJXNmzfi4/OWmjA5ODgwa9Y81qxZJwmTEFlYqpKmX3/91aLv/mlBQUHJHiwuUsdxxhR0UZEAxHTvhan4GxpHJET28eabVbC1tQOgQoVK7NlzmO7de71wrKcQIvNL9TIqL/rjcOvWLRkAmY4Mly5i/91aAMwurkSOGK1xREJkL0WLFmP69NlcuXKZUaPGquM9hRBZW7KTpi1btrBlyxZ1e8mSJWzYsCHJceHh4Vy+fJl69eqlTYQiCaeZU/+byPLDESjSHSBEuomICGfevDkMHfoRzs7OanmHDp01jEoIoYVkJ03R0dEEBwer25GRkeifcaeWo6MjHTt2xNfXN20iFBYM585i978fATDlyUt0n/4aRyRE1nXq1K8MGtSXmzdvEBwcxJw5C7QOSQihIZ2iKEpKT/L29mbs2LG89dZb6RGTVQkOjiQhwax1GCrXrh2w2+kPQPjUmcT0yfqzfxuNenLkcLK6usiOsktdJCQkMG/ebObMmYHJZALA2dmFo0dP8vrr+TSO7j/ZpT4yA6kL6+Hh4YTBkD7T76RqTNO+ffvSOg6RDMbTp9SEyZQvPzFdemgbkBBZ0K1bNxk0qC8nT55Qy6pUqcbixcutKmESQmS8ZCVN9+7dAyBfvnwW2y/z+HiRNpxmTFEfRw37GOztNYxGiKxFURR++OF7Ro0aQUREOAB6vZ4RI0YxbNjHGI2pvm9GCJFFJOuvgLe3t8UyKo+3X0aWUUk7xhO/YPtoAVBTocLEdOqicURCZB2hoSGMHDmMLVs2qWWFChVhyZLlVKtWQ8PIhBDWJFlJ09SpU9HpdNjY2Fhsi4zjNGOy+jhyxCiQW5yFSDM//LDBImHq0KEzU6fOxMXFVcOohBDWJlUDwbMTaxjUZ3PkEO5tmgOQUKw4wUdOQjbqKpABltYjq9aF2WymXbsWnDt3llmzvqBVq7Zah5QsWbU+MiOpC+thdQPBnycuLo6EhAQcHR3T8rLZm6LgNP2/Vqaoj0Znq4RJiPQQGhqCm5u7uq3X61m06EtMJhMFChTULjAhhFVLVSr2888/M3XqVIsyPz8/KleuTLVq1fD19SUyMjJNAszubI4cwubXXwBI8CxJbOt2GkckROalKArffLOGN98syy+/HLPY9/rr+SRhEkK8UKqSpq+++oro6Gh1+/Tp0/j5+VGnTh26d+/O4cOHWbp0aZoFmZ05LF+iPo4aMQoMBg2jESLzCgoKpGfPLgwfPpiIiHAGDepLaGiI1mEJITKRVPXz/P3337Ru3Vrd/t///keuXLnw8/PDaDSiKAq7du1ixIgRaRZodqS/dRPbJ+Zlim3eUuOIhMicDhzYx+DBAwgI+Fcta9jwbYxGGw2jEkJkNqlqaYqLi8POzk7dPnr0KPXq1VPnMSlevDj//vvv804XyeTw1XJ0j8bpx/ToDTbyB16IlIiJieHTT8fQvn0rNWHy8PBgzZp1zJkzXxYWF0KkSKqSpgIFCnDsWOJ4gHPnznHr1i3q1q2r7g8MDJTB4K8qMhL779YCoNjZES2zfwuRIpcuXaRJE2+WLVukljVo4M3Bg7/g49NMw8iEEJlVqrrnOnTowJQpU/jrr78ICAjgtddeo2HDhur+06dPU6JEiTQLMjuy/+F79I/GW8S0eQ8lVy5tAxIiE9m6dRODBw8gNjYWAFtbWz79dCJ9+w585kLjQgiRHKlKmrp27YqdnR0HDx6kXLly9OnTB/tHS3qEhITw4MEDOnXqlKaBZiuKgsPKZepmTJ/+GgYjROZTpkw5dQLe0qXLsHjxCsqWLadxVEKIzE4mt3wJLSYqszl8EPe27wIQX6MWIdt2ZujzWxuZNM56ZKa6WLVqBdeuXWXcuInqh7qsJjPVR1YndWE9rHpyy7/++ou7d+8CkD9/fumWSwMOy/+briGq7wANIxHC+kVFRbF0qR+DBg2xSI569uyjYVRCiKwo1UnTnj17mD59upowPVagQAFGjx7NW2+99crBZUeJ0wxsB8D0ej7ifJprHJEQ1uvcuTMMGNCbq1evEBwczOefT9M6JCFEFpaq9quDBw8yZMgQAIYNG4afnx9+fn4MGzYMRVEYPHgwhw4dStNAswuHVSv+m2agZx+ZZkCIZzCbzfj5zadJE2+uXr0CwNq1qyzmYRJCiLSWqjFNHTp0IC4ujm+//TbJ1AJRUVF07twZOzs7vv/++zQLVCsZ2j8dGUnOSqXRh4ag2NkR+PtFuWsOGStgTayhLu7du8vgwQM4fPigWlahQiWWLFnBG294ahKTVqyhPkQiqQvrkZ5jmlJ11cuXL9OqVatnzsXk6OhI69atuXz58isHl93Yb9qgTjMQ27qdJExCPGXbtq00aFBLTZh0Oh2DBw9j+/Y92S5hEkJkvFSNabKzsyM0NPS5+0NDQy1mDBfJoCg4rPhvAHi0TDMghCoiIpyxY0exbt03alm+fPnx81tGnTr1NIxMCJGdpKqlqUaNGnz99df8/vvvSfadOXOGtWvXUqtWrVcOLjuxOXII46WLQOI0AwkVKmkbkBBW5Jtv1lgkTC1atObAgWOSMAkhMlSqWpo+/vhjOnbsSOfOnalQoQJFixYF4MaNG5w9e5acOXPy0UcfpWmgWZ3D8iXqY5lmQAhLffoM4Mcft3Dp0kWmTZtFhw6d1ckrhRAio6R6csvAwECWLVvGoUOHuHfvHgD58uWjfv369OvXj5w5c6ZpoFrJiEF9+ps38KhRCZ2iYMqXn6CTZ+WuuSfIAEvrkVF1ERkZmWQx3Vu3bmI2mylatFi6PW9mI78b1kPqwnpY1eSWJpOJoKAgXF1d+eSTT/jkk0/SI65sxeGr5eo0A9EyzYDIxhRF4YcfvufTT0ezfv1mKlWqrO4rXLiIdoEJIQQpGNOkKApz586lWrVq1KtXjypVquDr60tISEg6hpcNRERg/91aABQ7O2K69NA2HiE0EhoawoABvfD17UdQUBADB/YhMjJS67CEEEKV7JamzZs38+WXX/Laa69Rt25d/v77b/bu3YvZbGbJkiUvv4B4JvuN69GHJd6JGNO2PUoW6dYUIiWOHz+Kr28/7tz5Wy2rUqUaiiLdHEII65HspGndunWUKVOG7777Tl3fafLkyXz33XcEBQXh4eGRbkFmWU9PM9BbphkQ2Ut8fDyzZk1j/vw5PB5e6ebmzqxZX9CqVVuNoxNCCEvJ7p77+++/admypcWCmJ07d8ZsNnPr1q10CS6rszm4H+OjJSDianlhKl9B44iEyDjXrl2lWbO3mTdvtpow1a5dh/37j0rCJISwSslOmkJDQ5O0JuXIkQOA2NjYtI0qm7CczFKmGRDZx7ZtW3nrrbr88UfiXG9Go5Fx4yawadM2ChQoqHF0QgjxbCm6e07mRUk7+hvXsd29EwBT/gLE+TTTOCIhMk6RIkWJj48HoHjxEixdupKKFd/UOCohhHixFCVNc+bMYdmyZeq22Zw4SHPcuHE4ODhYHKvT6fjpp5/SIMSsyf6H7y2nGTCmap5RITKl8uUr8sknn3H9+jUmTZqaZE4mIYSwRsn+T12tWrVnlssA8FRQFOy2bkp8qNMR+15HjQMSIv3ExMSwatUK+vTpj80Tc5ANGjRYWq+FEJlKspOmtWvXpmcc2Yrhz3PqAPD4mrUxv55P44iESB8XL15gwIDeXLx4npCQIMaMGa/uk4RJCJHZpM884+KF7B+1MgHEyl1CIgtSFIUVK5byzjv1uXjxPABLly7i/v37GkcmhBCpJwNpMtqTXXMGA7HvttI2HiHSWEBAAB9+OJB9+/aoZaVLl2HJkpXkyZNHw8iEEOLVSEtTBjP+dhLD37cBiK/XACVXLo0jEiLt7NrlT8OGtSwSpn79BrJz5wHKlCmrYWRCCPHqpKUpg9k90TUX07qdhpEIkXaioqKYMGEsq1evVMvy5MnLggVL8PZ+W8PIhBAi7VhdS9O1a9fo2bMnlSpVwsvLi5kzZxIXF5eia6xevZqSJUvSv7+VLUtiMmH34xYAFFtbmZtJZBkrV35pkTA1adKUAweOS8IkhMhSrCppCg0NpXv37sTHx7Nw4UKGDRvGhg0bmD59erKv8eDBAxYtWkROK1z41uaXYxgC/gUgzrsRipu7tgEJkUb69RtIuXIVcHBwYNaseaxZs45c0vUshMhiXql7LiAggJMnTxIYGEjjxo157bXXMJlMhIeH4+LigsFgSNH11q9fT2RkJH5+fri7uwNgMpmYOHEi/fv3J2/evC+9xqxZs/D29ubevXupeUnpym7LE3fNtZa75kTmFRsbi8Hw35xLdnZ2fPnlKhRF4Y03PDWMTAgh0k+qWpoURWHatGm89dZbfPTRR0yfPp0bN24AiWMbvL29UzWv06FDh6hVq5aaMAH4+PhgNps5evToS88/deoUe/bsYcSIESl+7nQXH4/d/7YCoDg6EvuOj7bxCJFKP/zwA2++WZYLF85blJco8YYkTEKILC1VLU0rVqzg66+/pm/fvtSqVYuePXuq+1xcXHjnnXfYtWsXPXr0SNF1r1+/Ttu2li0wrq6u5M6dm+vXr7/wXJPJxOeff86AAQPS9LZmgyFtejCN+w+iDwoCIL5JU4xuLmly3ezgcR2kVV2I1AkPD2fs2JF8803iB6KBA3uzd+8h7O3tNY4s+5LfDeshdWE90nPe3FQlTRs3bqRVq1YMHz6c4ODgJPtLlizJoUOHUnzdsLAwXF1dk5S7ubkRGhr6wnO/++47oqOjU5yovYyrq8PLD0qOn7eqD227dcE2h6y1lVJpVhcixX755Re6dOnCtWvX1LLy5cvh5GSDq6v8LGtNfjesh9RF1paqpOmff/7hzTefvyK5g4MDERERqQ4qpQIDA1mwYAEzZszA1tY2Ta8dFhaNyWR+tYvExOC+eQs6wOzqRmiNuhAcmSbxZQcGgx5XV4e0qQuRIgkJCcydO4tZs6ZjMpkAcHZ2ZvbsL3jvvY6YTDqC5WdZM/K7YT2kLqyHm5sDen36tPilKmnKmTMn//zzz3P3nz9/ntdffz3F13V1dSU8PDxJeWhoKG5ubs89b/78+ZQsWZKqVasSFhYGJP6xT0hIICwsDEdHR4zG1I15N5nMJCS82i+A7Z496CISX1dc0+YkGGzgFa+ZHaVFXYjku3XrJoMG9eXkyRNqWbVqNVi//jty5Mj7qC4U7QIUKvndsB5SF9pT0vHPUqpSsUaNGrF+/Xr+/vtvtezx4ptHjhxhy5YtNGnSJMXXLVasWJKxS+Hh4Tx48IBixYo997wbN25w8uRJqlWrpn6dPn2aI0eOUK1aNY4dO5biWNKSzaH96uPYpu9qGIkQybN9+/9o2NBLTZj0ej0ffzyGn3/e+cLfRSGEyMpS1fwyZMgQTpw4QcuWLalatSo6nY7ly5czf/58/vjjD0qXLs2AAQNSfN169eqxdOlSi7FNO3bsQK/X4+Xl9dzzPvnkE7WF6bGpU6dib2/P8OHDKVmyZIpjSUu2RxLHdykGA/FedTSNRYjkyJ07N9HRUQAUKlSExYuXU716DYxGGeQqhMi+UpU0ubi4sGHDBr766it27tyJnZ0dJ0+epFChQvj6+tKnT59U3VHTsWNH1q5di6+vL/379ycgIICZM2fSsWNHizmaunfvzr1799i9ezcApUuXTnItV1dXHB0dqVGjRmpeYprR3b+P8dJFABIqvYniknSguxDWplq1GowYMYqbN28wbdosXOTnVgghUj+5pb29PYMGDWLQoEFpFoybmxtr1qzh888/x9fXFycnJ9q1a8ewYcMsjjObzeqgVGtne/S/uwjj69TXMBIhni0+Pp7vvltLly7dLSakHTFilNrtLoQQwgoX7C1evDirV69+4THJmTgzNZNrpgebI/8lTXF16mkYiRBJXbt2lYED+/DHH78TEhLMhx/+NzGsJExCCGEpVUnTmDFjXnqMTqdj6tSpqbl8lmJ76ACQuEBvfDVtuwqFeExRFL799mvGjRtFVFTi2KW5c2fy/vvdZc04IYR4jlQlTSdOnEhSZjabefDgASaTCQ8PDxwcZIIv/e1bGG7dBCC+anVwdNQ2ICGAoKBAhg8fwvbt29Sy4sVLsGTJCkmYhBDiBVKVNO3bt++Z5fHx8Xz//fesWbOGr7766pUCywpsjh5WH8dL15ywAgcO7GPw4AEEBPyrlnXt2pNJk6bi5CQzewshxIuk6f3DNjY2dOnSBS8vLz7//PO0vHSmZHv4oPo4TgaBCw3FxsYyfvwntG/fSk2YPDw8WLNmHXPmzJeESQghkiFdJl0pVaoUJ0+eTI9LZx6Kog4CVxydSKhcReOARHa2ZMlCli71U7cbNPDm4MFf8PFppmFUQgiRuaRL0nTs2LFsP6bJcO0vDP8mLjUTX7MWpPGaeEKkRL9+g/D0LImdnR2TJ09n/frN5M37mtZhCSFEppKqMU1+fn7PLA8PD+fkyZNcuHCBfv36vVJgmZ3No7vmQLrmRMZLSEiwWG/R0dGRL79cDUCZMmU1ikoIITK3NE2a3NzcKFiwIBMnTqR9+/avFFhmZ/vE/EzxdWUQuMg4u3b588knI/n++80UL/6GWi7JkhBCvJpUJU2XLl1K6ziyFrMZm0czgZvd3EkoV0HjgER2EBUVxYQJY1m9eiUAAwf24eef92BjY6NxZEIIkTWkeExTTEwM06ZNe+60AwIM5/9EHxwMQHztOvDE0hRCpIdz587QqFE9NWECeO2119VFd4UQQry6FCdN9vb2fP/99wQGBqZHPFnCk11zcdI1J9KR2WzGz28+TZp4c/XqFQAcHByYNWsea9asw9XVTeMIhRAi60hV91zZsmW5cuVKWseSZdgc+W9+JlmkV6SXe/fuMnjwAA4/MR9YhQqVWLJkBW+84alhZEIIkTWlasqBTz75hO3bt7Nx40YSEhLSOqbMLT4em2NHATDnzoOpZCmNAxJZ0a5d/jRoUEtNmHQ6HYMHD2P79j2SMAkhRDpJdkvTyZMnKV68OB4eHowePRqdTsf48eOZPHkyefPmxc7OzuJ4nU7HTz/9lOYBWzvjH6fRR0YAj7rmZKV4kQ4cHZ0IDQ0FIF++/Pj5LaOOLNUjhBDpKtlJU7du3Zg1axbNmzfH3d0dd3d3ihYtmp6xZUo2x46oj+O95J+YSB916tTD1/dDbt++xezZ83B3z6F1SEIIkeUlO2lSFAVFUQBYu3ZtugWU2dkeP6o+jq/tpWEkIqtISEhg8+aNtGvXAb3+vx71sWM/Q6/Xo5PWTCGEyBCpGgguniMhAeOJXwAw5cmLqVgJjQMSmd2tWzcZNKgvJ0+eICQkmH79Bqn7DDKVhRBCZKgUDQSXT7QvZjx3Rh3PFF/bS8YziVRTFIUNG9bRsKEXJ0+eAGDq1Eky1YcQQmgoRS1NH3/8MR9//HGyjtXpdFy4cCFVQWVWNsePqY/ja0rXnEid0NAQRo4cxpYtm9SyQoWKsHjxcnLmzKlhZEIIkb2lKGmqXbs2RYoUSadQMj+b408MAq9dR8NIRGZ1/PhRfH37cefO32pZ+/admDZtFi4urhpGJoQQIkVJU6tWrXj33XfTK5bMzWzG5pfjiQ89PDB5ltQ4IJGZxMXFMWvWNBYsmKvecOHq6sbs2fNo1aqtxtEJIYQAGQieZgwXzqMPDQEedc3pUzVvqMimFiyYy/z5c9Tt2rXr4Oe3jAIFCmoYlRBCiCfJf/Y0YvPLE1MN1KqtYSQiM+rffxCFCxfBaDQybtwENm3aJgmTEEJYGWlpSiO2x56cn0nGM4kXM5vNFnMuubi48uWXq9Dr9VSs+KaGkQkhhHieZLc0Xbp0ScYzPY+iqC1NZlc3EsqU0zggYc0OHNhH3brVuX37lkX5m29WkYRJCCGsmHTPpQHD1SvoHz4EIL5GTZBJB8UzxMTE8OmnY2jfvhVXr17hgw/6YzKZtA5LCCFEMkn3XBqwWG+ulnTNiaQuXbrIgAG9uXDhT7XMwcGBiIhw3NzctQtMCCFEsklLUxqQQeDieRRFYcWKpTRqVE9NmOzs7JgyZQbr1m2ShEkIITIRaWl6VYqCzaNB4IqjEwkVKmkbj7AaAQEBfPjhQPbt26OWlS5dhiVLVlKmTFkNIxNCCJEa0tL0ivQ3b2D49x8A4qvXABsbjSMS1mDfvt00bFjLImHq128gO3cekIRJCCEyKWlpekW2x5/smpP15kQis9nMw0c3B+TJk5cFC5bg7f22xlEJIYR4FZI0vSKbJ5KmOBkELh55++3G9OrVl3v37jJ3rh+5cuXSOiQhhBCvSJKmV/Q4aVLs7Ul4s7LG0QgtmM1mtm//H82avYtOp1PLP/98Okaj0aJMCCFE5iVjml6B/s7fGB5NUBhfpRrY2Wkckcho9+7d5b33WtKrVxe+/fZri302NjaSMAkhRBYiSdMrsPnlmPo4vqZMNZDd/PTTFho0qMXhwwcB+PTTMQQHB2kclRBCiPQiSdMrsPntpPo4vnpNDSMRGSkiIpwhQwbSp093QkJCAMiXLz9r164nRw4PbYMTQgiRbmRM0yswnkpMmhSdjoQqVTWORmSEU6d+ZeDAPty6dVMta9GiNbNnz8PdPYd2gQkhhEh3kjSlVlQUxvPnADB5lkRxddM4IJGeEhISmDdvNnPmzFDXi3NycmbatFl06NBZxi4JIUQ2IElTKhnPnkGXkABAfNXqGkcj0tucOTOYM2eGul2lSjUWL15O0aLFNIxKCCFERpIxTan05HimhCrVNIxEZIR+/QaSL19+9Ho9H388hm3bdkrCJIQQ2Yy0NKWSxSBwSZqyHEVRLLrccuTwYOnSr9Dr9VSvXkPDyIQQQmhFWppSQ1EwnvoVALOzCybPkhoHJNLS8eNHadSoPgEB/1qU16xZSxImIYTIxiRpSgX9vbvqIr0Jb1YBg0HjiERaiI+PZ+rUSbRq1ZSzZ/9g8OABmM1mrcMSQghhJaR7LhWMT3bNVZWpBrKCa9euMnBgH/7443e1LC4ujvDwMNzc3LULTAghhNWQlqZUsDklg8CzCkVR+OabNbz1Vl01YTIajYwbN4FNm7ZJwiSEEEIlLU2pYDkIXKYbyKyCggIZPnwI27dvU8uKFy/B0qUrqVjxTQ0jE0IIYY2kpSml4uIwnv0DgISixVBy5tQ2HpEqhw4doH79WhYJU7duvdiz57AkTEIIIZ5JWppSyPjnWXSxsYB0zWVmISHB6t1xHh4efPHFInx8mmkclRBCCGsmSVMKyfxMWUOLFq3p2HEX//77DwsXLiVv3te0DkkIIYSVk6QphZ68cy6hqiRNmYGiKOzfvwdv70YW5TNnfoGtrS16vfRSCyGEeDn5b5FCNqdOAaA4OJBQppzG0YiXCQgIoHPndnTs2JZNmzZY7LO3t5eESQghRLLJf4wU0N2/j+H2TQDiK74JNjbaBiReaNcufxo2rMXevbsBGD36I0JDQ7QNSgghRKYlSVMKyCK9mUNUVBQjRw6jS5cOPHz4EIA8efKybNlXMu+SEEKIVJMxTSkgg8Ct37lzZxgwoDdXr15Ry5o0acrcuX7kypVLw8iEEEJkdtLSlAIyCNx6mc1m/Pzm06SJt5owOTg4MGvWPNasWScJkxBCiFcmLU3JlZCAze+nATDlL4D5tdc1Dkg8aebMqcydO1PdrlChEkuWrOCNNzw1jEoIIURWIi1NyWS4dBFdVCQgXXPWqHfv/uTKlRudTsfgwcPYvn2PJExCCCHSlLQ0JZPxz7Pq44Q3q2gYiXiW3Llzs3jxcoxGI3Xq1NM6HCGEEFmQ1bU0Xbt2jZ49e1KpUiW8vLyYOXMmcXFxLzzn/v37zJw5k5YtW/Lmm29Sr149RowYwd27d9MsLn1QkPrYnD9/ml1XpNypU7/y7ruNCQwMtChv0MBbEiYhhBDpxqqSptDQULp37058fDwLFy5k2LBhbNiwgenTp7/wvPPnz7N79258fHxYvHgxo0eP5sqVK7z33nsEPZHsvApdaLD62Cy3rWsiISGB2bOn8+67jTlx4jjDhn2AoihahyWEECKbsKruufXr1xMZGYmfnx/u7u4AmEwmJk6cSP/+/cmbN+8zz6tSpQr+/v4Yjf+9nMqVK9OgQQO2bt1Kr169Xjk2fWio+lh5FJvIODdu3KBjx878+usvatmDB/cJDw/D1dVNw8iEEEJkF1bV0nTo0CFq1aqlJkwAPj4+mM1mjh49+tzzXF1dLRImgNdeew0PDw/u37+fJrHpQkLUx9LSlHEURWHDhvVUrFhRTZj0ej0ffzyGbdt2SsIkhBAiw1hVS9P169dp27atRZmrqyu5c+fm+vXrKbrWjRs3CAwMpHjx4q8Uk8GQmFcawv5raTLk8kBvtKp8M0sKDQ1hxIihbN78g1pWuHARli5dQY0aNTWMLPtSfx8M8vNvDaQ+rIfUhfXQ6dLv2laVNIWFheHq6pqk3M3NjdAnusdeRlEUJk+eTJ48eWjWrNkrxeTq6pD4ICJMLXMvnA+MVvXWZTmHDx+mS5cu3L59Wy3r1q0bCxcufObPiMhY6u+FsApSH9ZD6iJry5L/+RcuXMgvv/zCihUrcHR0fKVrhYVFYzKZcQ0MxAAozi6EhMcCsWkSq3i2c+cuqgmTm5s7y5YtxcenBSaTmeDgSI2jy74MBj2urg7q74XQltSH9ZC6sB5ubg7o9enT4mdVSZOrqyvh4eFJykNDQ3FzS97YlQ0bNrBo0SKmTJlCrVq1Xjkmk8lMQoIZXXAIAGZ3dxIS5BcivbVr15Fdu3by4MF9li5dQfnyJQkOjpT33ko8/r0Q1kHqw3pIXWgvPW+qtqqkqVixYknGLoWHh/PgwQOKFSv20vN3797NhAkTGDJkCO3atUu7wBQFXWhI4kMZBJ7mFEXhxInj1KxZWy3T6XTMm7cIe3t77OxsNIxOCCGESGRVI9bq1avHsWPHCAv7b/zQjh070Ov1eHl5vfDcEydOMHz4cN577z18fX3TNrCoKHTx8UBiS5NIO0FBgfTs2YUWLZqwffv/LPY5OTlhMBg0ikwIIYSwZFVJU8eOHXFycsLX15cjR46wadMmZs6cSceOHS3maOrevTuNGjVSt69du4avry9FihShZcuW/PHHH+rXkwOJU0v/qJUJpKUpLR04sI/69Wuxffs2AIYP/4Dw8LCXnCWEEEJow6q659zc3FizZg2ff/45vr6+ODk50a5dO4YNG2ZxnNlsxmQyqdtnzpwhPDyc8PBwOnXqZHFs69atXzqj+MtYzNEkLU2vLCYmhilTJrJs2SK1zMPDgy++WISLi9wZJ4QQwjpZVdIEULx4cVavXv3CY9auXWux3aZNG9q0aZNuMUlLU9q5dOkiAwb05sKFP9WyBg28WbhwKXnzvqZhZEIIIcSLWVX3nLV6sqVJllBJHUVRWLFiKY0a1VMTJjs7OyZPns769ZslYRJCCGH1rK6lyRrpnmhpkiVUUmfGjCnMnTtT3S5dugxLlqykTJmyGkYlhBBCJJ+0NCWDPiRYfSwtTanTrVtPdU3Bfv0GsnPnAUmYhBBCZCrS0pQMMhD81eXLl5+FC5dhY2PE27vRy08QQgghrIy0NCWDDARPmXPnztChQ2tCn3jfABo39pGESQghRKYlSVMyyEDw5DGbzfj5zadJE2/279/LqFEjtA5JCCGESDPSPZcMlgPBc2gXiBW7d+8ugwcP4PDhg2rZ1atXCA8Pk7mXhBBCZAnS0pQM+idbmpK5cHB2sm3bVho0qKUmTDqdjg8+GIq//15JmIQQQmQZ0tKUDLqwUADMTs5gI4vHPhYREc7YsaNYt+4btSxfvvz4+S2jTp16GkYmhBBCpD1JmpLh8ZgmaWX6z2+/nWTgwD7cvHlDLWvRojWzZ8/D3V26MIUQQmQ9kjQlw+O75+TOuf+cPXtGTZicnJyZNm0WHTp0RqfTaRyZEEIIkT4kaXqZ6Gh0sbGAzNH0pB49erN37y4CAwNZvHg5RYsW0zokIYQQIl1J0vQSFtMNZNOWJkVROHPmdypVqqyW6XQ6Fi9ejqOjE0aj/BgJIYTI+uTuuZfQZfMlVEJDQxgwoBfvvNOAffv2WOxzdXWThEkIIUS2IUnTS2TnxXqPHz9Kw4ZebNmyCYAhQwYSERGucVRCCCGENiRpegl9NpwNPD4+nqlTJ9GqVVPu3PkbADc3dyZPno6zs4vG0QkhhBDakL6Vl8hui/Veu3aVgQP78Mcfv6tltWvXwc9vGQUKFNQwMiGEEEJb0tL0EhZjmrJw95yiKKxdu5q33qqrJkxGo5Fx4yawadM2SZiEEEJke9LS9BLZZbHemTOnMmfODHW7ePESLF26kooV39QwKiGEEMJ6SEvTS1h0z2XhlqYOHTqr45W6du3Jnj2HJWESQgghniAtTS/x5N1zShZeHqRIkaLMnbsAW1s7mjZtrnU4QgghhNWRlqaXyIotTZcuXaRnzy5ERERYlLdq1VYSJiGEEOI5pKXpJbLSlAOKorBy5TImTvyU2NhYcuTIwdy5C7UOSwghhMgUJGl6icd3zymOjmBrq3E0qRcQEMCHHw60mNX7t99OEhERLnMviRQzm03Ex8drHUa2ZzbriIkxEBcXi8mkaB1OtiZ1kTEMBiN6vXadZJI0vcTjMU2ZuWtu505/hg4dRGBgoFrWr99Axo2biL29vYaRicxGURTu3btHYGCQ1qGIRx4+1GM2m7UOQyB1kVEcHJxxdfVAp9Nl+HNL0vQSj8c0ZcauuaioKCZMGMvq1SvVsjx58rJgwRK8vd/WMDKRWYWEBBIdHYmzcw5sbe00+aMlLBkMOmnZsBJSF+lLURTi4mKJiEjsAXJzy5nhMUjS9CJmM7qYmMSHmayl6ezZPxg4sA9Xr15Ry5o0acrcuX7kypVLw8hEZmU2m4iMDMfNzQMHB+nStRZGo56EBGndsAZSF+nP1tYOgIiIYFxccmR4V50kTS/yRDOr4uamYSApd/jwITVhcnBwYNKkaXTr1lNaBkSqmUwmAOzs7DSORAiRnT1OnEymBPT6jB1rLEnTi1gkTe7axZEKAwd+wL59uwkNDWXJkhW88Yan1iGJLEMSbyGEdrT88C9J04s8kTRZ+2K9ly9fomTJUuq2Xq9n+fLVODu7YJuJ7/oTQgghrIVMbvkimaClKSIigqFDfalfvybHjx+12OfhkVMSJiGEECKNSNL0Io/GcIB13j33228n8fb24rvv1mI2m/H17Zdklm8hhBBCpA1Jml7kye45K2ppSkhIYM6cGTRv/g43b94AwMnJmZEjP8HJyUnj6IQQQoisScY0vciT3XNW0tJ069ZNfH378euvv6hlVapUY/Hi5RQtWkzDyITInI4fP8qmTd9z6dIFwsPDcXV1o1Sp0rzzjg9vvfWOprMPf//9t3z//Xc8fPgAL6+6TJs2R7NY0kvfvt1o0qQ5bdu2T7Kve/dOXLt2lUWLllOx4psW+6ZMmcClSxdYu3ZDkvPmz5/D4cMH+OGHbUn2HTlykE2bNnDp0kWio6PInTsP1arVoGPHLhQqVPi5cd66dZMvvpjJn3+exdHRiSZNmtK37yBsbGxe+PqOHDnImjVfcfPmDRwdHahQ4U0GDPiA/PkLJDnW3/9/bNjwHbdu3cTBwYFSpcoydepM7OzSfxLi1L6+5Jx7/PgRvv32a27evE5kZCS5cuWhXr369OzZD2dnZ/U6M2ZMBmDUqHHp8yLTgCRNL2LR0pRDw0ASJ/X64YfvGTVqBBER4UDiYO/hw0cyfPhIjEapSiFSatmyRaxdu4p69RoybNhIcubMRVBQEIcPH+Dzz8fj6upGjRq1NInt779v4+c3j/ff746XV13crKi1O60cPLiff/75h+bNWyTZd/36Na5duwrA7t07kiRNqbFkyUK+/XYNDRq8xahRY3F3z8Hdu3f4+eef+OyzMaxa9d0zzwsLC2PIkAEULFiIKVNm8eDBffz8viAmJobhw0c99/lOnz7FJ598TJMmzejXbxBhYaGsWLGU4cM/4Ouv11skQ2vWrOTbb7+ma9eelCtXntDQEE6dOonJlP7zPqX29SX33LCwMMqUKUu7dh1wdXXjxo1rfPXVl1y/fo0vvlikXuv997vTtWt7OnfuRsGChdL1NaeW/Kd9ESsa0zRr1jRmz56ubhcqVITFi5dTvXoNDaMSIvM6duwIa9euomfPvvTu3d9in7f327z3XkdNP4zcvn0LRVF4991Wz2yVSC5FUYiPj9fkppCXPffGjet4++3Gz2xJ2b17B3q9nkqVKrN//x6GDv34leojsbVjDT169KFPnwFqeaVKlWnWrAVHjx5+7rk//riJqKhIpk6dhatr4px9JpOJuXNn0K1bL3Llyv3M8/bu3UXevK8zZsx49Tb5HDk8GDJkAJcuXVQTwdu3b/LVV18yffpcatXyUs9v0OCtFL/O06dPMWTIAI4cOZXsc1L7+pJ7buPGTS3OqVy5KjY2tsycOYWHDx+o1y9QoCDly1dk8+aNfPjhiJS+9AwhY5pexIq651q1aouDgwMA7dt3Yv/+I5IwCfEKvv/+W3LmzEX37r2fub9MmXJ4ev43jceff55lyJABvP12HRo3rs+ECWMJDrZcg2/KlAl07dqe06dP0bNnZ95+uw59+3bj0qWLFse97FpTpkxg1KhhAHTo0Io6daqyfXtiV9PBg/vo0aMz3t61admyCfPmzSE2NjZJDMePH6F79040bFiLo0cPWew7efIE3bt3xNvbiw8+6Mc//9wjLCyUTz8dzTvv1Kd9+5bs3bsryXuSnLif99xPu3fvLmfO/E7DhkkTA0VR2LNnJ5UrV6VDh/cJDQ3ll1+OPfM6ybV+/bd4eOSkR48+z9zv5VX3uef+8ssxqlatriYFAN7ejTCbzRZDJZ6WkJCAo6OjxbxCTk6J3VGK8t9yKz//vI3XX89vkTBlpNS+vlc51+3RhNFPL/zdsOHb7N7tT0JCQmpeSrqTpOlFrGgguKdnSWbMmMuXX67Cz28ZLi6umsYjRGaWkJDAuXNnqFKlWrJaL/788yyDB/fHycmZiROnMXLkWC5dusDo0Uk/DQcFBTJ//mw6derGpEnTiYuL45NPPlL/CSTnWj169GHgwMEATJkyi6VLV1GrVh2OHDnIuHGjKFKkKFOnzub997uxZcsmPv/8U4sYHj58yLx5s+nQoTNz5izkjTdKWsTn5zePbt168dlnn3P37h0mTRrH+PFjKF68BFOmzKBkydJMmvQp//77T4rfgxc995N+++0kBoOB0qXLJtl37twZ/vnnHo0aNaFGjVq4ubmxe/eOl1XTc6W0vp9269ZNChUqYlHm4uJCzpy5uHXr5nPPa9r0XW7evM7mzRuJiIjg7t07LFu2CE/PkpQvX1E97vz5cxQvXpzVq1fQvHkjGjSoycCBvTh//s+XxqYoCgkJCerX4wWDnyx7WQKS2teX0nNNJhOxsbFcvnyJVatWUKdOPV5/PZ/FMeXKVSAkJIS//rqCNZLuuRd59MOn2NuDffoPxHvs2rWrzJ07izlzFmD/xPN27Ph+hsUgRHLZ/rQFpxlT0Gk03YXi7Ezk6HHEvdsq2eeEhYUSFxdHnjx5La+lKOpyMZA4blCv17N0qR+lSpVm6tRZaqtBsWIl6NatA8ePH6FWrTpPXDuMhQu/pFix4gDY29szZMgAzp//k4oVKyXrWvnzF6BgwcRByZ6eJdV/LF999SVly5ZnwoQpANSsWRtHRwemT5/CtWt/Ubx4CQDCw8OYPXsBZcuWe8Zrt4zv4cMHfPHFLN5/v7vaClOqVFkOHdrPoUMHaN++E0Cy34MXPfeTLl48T8GChZ7Zdbd7905sbe2oX98bo9FIgwZvsXPndqKionB0dHzhdZ/lcX3nzftais+FxNfk7Jx0vUUXFxfCwsKee17Fim8ydepsJk4cx9y5MwB44w1P5sxZiMFgUI8LCgrk8uVLXLt2jREjRmFvb8/XX69i+HBf1q/fQo4cHs99Dn///zF16sQk5Q0a1LTY3rjxpyQJyqu+vpSe267duzx4cB+AGjVq89lnU5KcV7RoMQwGA+fP/0mpUmVe+NxakKTpRR798cyoViZFUfj2268ZN24UUVFR5MiRg8mTZ2TIcwuRWo6L5mO8qu2nQsdF81OUND329HIMBw7s5dNPR6vbbdq8x6BBH3Lu3Bl8fT+0SKgKFixEnjx5uXjxgkXSlCtXbjUhAdS7Wh88CCAmJiZF13pSVFQUV69ewdf3Q4vyt99+h+nTp3D27B9q0uTm5vbcpOXp+B4nZ1WrVlfLXFxccHfPwf37AQApivtFz/2kwMCHuLsnvcEmISGB/fv3UKtWbfXOqkaNmvDjj5s5dGg/TZo0e+m1nyejl984d+4Mn38+nnffbYWXV11CQ0NYvXolH388lMWLl6tjucxmhejoKCZPnkGJEm8AULZsedq1a8GmTRssxmA9zcurLitWfK1uX7p0kdmzp1mUAS8cl5RRZs2aT0xMNDduXGfNmpWMGjWML75YZJFAGo1GnJ2dCQx8qGGkzydJ04s8bmnKgPFMQUGBDB8+RB23ALBv3x4iIyNl7iVh1aI+GIrT9MmatjRFPZVIvIyrqxu2trZqUvBYlSrV1X82o0YNBxI/SZtMJhYsmMuCBXOTXOvpazx5CzWA0Zh423VcXFyKr/WkiIhwFEXBwyPnU8+XuFRSWFioWpYjR86nT39BfIn/BlxcLFsLbGxsiItLHCuVkrhf9NxPiouLw8YmaSvTyZO/EBISjJdXPcLDE+8ULlasBDlz5mL37p1q0mQwGNSuqKeZzSaLbrjE+rYjIODfZMX2NBcXVyIjk/58J05R8fyhEvPmzaZKlaoMHjxMLStbtjxt2zZnx47ttGzZ5tH1XXBzc1MTpscxe3qW5MaNay+Mzc3N3eLOyqioKIAUtdKk9vWl9NzHr69cuQqUKlWGnj07c+jQfho2fNviOBsbW4txetZEkqYXeTRQL72XUDlwYB+DBw+w+IXu2rUnkyZNlYRJWL24d1ulqpVHS0ajkfLlK/LbbycxmUzqJ11XV1dcXRP/2TyeY8bZ2QWdTkfXrj2pV69BkmulZCqAV7nW43OfHnweERFOXFycxUDctG5QSUncyX1uV1dX/vnnnyTlu3fvBHjU5WTZ7RQSEkxwcBA5cnjg7p6DwMDAZ1774cMH5MjxXyvWf/X9KwkJCSke11S4cJEk43MiIiIIDHxI4cJFnnvezZvXqVu3vkVZnjx5cXNz5+7dO2pZ0aLFuHfvztOnA4nJZXpL7et7lXNLlHgDo9HInTtJX3dERLg6UNzayEDwZEivxXpjYmL49NMxtG/fSk2YPDw8WLNmHXPmzJeESYh01KHD+zx8+IC1a1e98DgHBwfKlSvPrVs3KFWqTJKv540TSetrOTo68sYbnhw4sNeifM+e3QBUqFAp2XGkVFq+B48VKlSEf/65Z1EWExPD4cMHqVu3AQsWLLX4mjBhCiaTSb2rr1KlykREhPPHH6ctrhEZGcHp079RsWJli/KOHTsTGBjI119/9cx4jh8/8txYa9aszalTv6otXwD79+9Br9dTvXrN55732muvc/nyJYuyf//9h9DQEIv3LLHrLpSrVy+rZaGhIY8WYi/93Os/S+XKVVM03QCk/vW9yrnnz/9JQkIC+fLltygPDg4mJibmhRONaklampIhPVqaLl26yIABvblw4b+7Ixo08GbhwqWpHqwohEi+2rXr0KVLD1asWMrVq5fx9n6HXLlyERERwZkzvxMUFIijY+IHl0GDPuTDDwcyfvwY3nrrHVxcXHjw4D4nT56gadN3qVy5arKf91Wu1atXP8aM+YhJkz7lnXd8uH37Fl9+uYgGDbzV8UzpJS3fA4Dy5SuyatVy7t8PUAfkHz58gOjoKN57r+Mzr/fdd1+ze/dO2rXrSPXqNalY8U3Gjv2YHj36UqxYcR4+fMB3332NwaCnXbuOFufWqlWHzp278dVXX3Lz5g3eeusd3N3duXfvLj///BORkRHPHU/WsmVbfvjhe8aMGUG3br148OA+ixbNp2XLNhZjhbZv/x9Tpkxk3rzFvPlmFVq2bMuCBXOYN282Xl51CQsLZc2aleTI4YG3939dUnXrNqB06TKMGzeKfv0GYWdnx9q1q7G1taF163YvfB+Dg4MtWq2ex9Oz5HPny0ru6/P3/x/Tp3+uvr7knvvJJx9TqlRpihd/Azs7O/766wrr1q2lePE3krRcXrp0AUjfDwGvQpKmZEiPlqaff/5JTZjs7Oz49NOJ9OkzQNMlG4TIbgYM+IAKFSqxefMG5s6dTkREBK6ubpQsWYrRo8fz9tvvAIn/4BcvXsHKlcuYNm0i8fHx5M6dl6pVq1GgQMEUPeerXKtOnfp8/vl0Vq1awZgxI3B1daVVqzb07eub6vcgI+J+ljffrIKbmxu//HKMFi1aA4ldc3nzvqb+Q35akybNWbBgDnfv3iF//gLMmjWPFSuWsn79Nzx8+ABnZ2cqV67G5MkzyZUrV5LzBw0aQvnyFdi0aQPTpk0iJiaa3LnzUL16TTp16vrcWF1dXZk/fwlffDGLMWNG4OjoxLvvtqJfv0EWx5nNZkwmkzoH03vvdcTW1oYtWzbx888/4ujoSNmyFfj88xkWXZp6vZ5ZsxawcOEcZs2aSnx8PBUrvomf33Jy5kz6Op50/PiRZ94997QX3T2X3Nf3+O7SJ+eYSs65pUuXZd++XXzzzRoUxcxrr73Ou++2plOnLkmWaTlx4hgVK76ZZOyetdApT756Yen6dShenMgRo4gaNTZNL52QkEDLlj5ERISzZMlKypRJOleJSGQ06smRw4ng4EgSEtJ/SQHxbPHxcQQG/kOePPnQ61++HpXIGEajPtP+Xixc+AVXr15mwYKlWoeSJjJzXViDhIQE2rZtzoABH+Dj0/y5xz3+W5Qz5+vPvJnAw8MJgyF9GiCkWSMZ0uLuuZs3b1hsG41GvvrqG3buPCAJkxAiW+rUqSsXLvzJVY2nrBDWYffuHTg4ONKoUROtQ3kuSZqS4VXmaYqKimLkyGHUrl2F33//zWJf3rx5LSavFEKI7CRXrlx88skEQkKCtQ5FWAG9Xs+YMeOtegF6643MiijPmIAtOc6dO8OAAb3VT1EDB/Zh376jqZrRVgghsqInB0SL7O3phX2tkbQ0JUNKu+fMZjN+fvNp0sRbTZgcHBwYOHCwuuiuEEIIITIXaWlKhpR0z927d5fBgwdw+PBBtaxChUosWbKCN97wTIfohBBCCJERpKUpGZLb0rRt21YaNKilJkw6nY7Bg4exffseSZiEEEKITE5ampIhOS1Ns2dPZ+bMqep2vnz5WbToS7y86qZjZEJoQWYpEUJoR8uZkqSl6SUUW1tIxjikxo2bqpN0tWjRmgMHjknCJLKUx+uzWetCmkKI7OHxQtIGQ8a3+0hL00so7u7JWoGyfPkKTJo0DScnJzp06IwurVfMFEJjer0BJycXwsNDMJkUbG3t5OfcCpjNOkwmaf2zBlIX6UtRFOLiYomICMbBwVmTFTQkaXqJZ607d+vWTfz85jN16kyLKeB79+6XgZEJkfHc3XNib29DYGCQ1qGIR/R6PWazzEJtDaQuMoaDgzOurh6aPLckTS/x5BxNiqLwww/fM2rUCCIiwsmRIweffDJew+iEyFg6nY58+fJhZ+dMbGy81uFkewaDDjc3R0JDo6SFQ2NSFxnDYDBqukar1SVN165dY/Lkyfz+++84OTnRsmVLhg4d+tzVmR9TFIXly5fz3XffERQUROnSpRkzZgyVKlV6pXge3zkXGhrCyJHD2LJlk7rvxx83M3ToRzJZpch29HoDNjbSNac1o1GPvb090dEmWfNMY1IX2YNVDQQPDQ2le/fuxMfHs3DhQoYNG8aGDRuYPn36S89dvnw5CxYsoEePHixbtozcuXPTq1cv/v7771eKyezuzvHjR2nY0MsiYerQoTN79hyShEkIIYTIJqyqpWn9+vVERkbi5+eH+6MWHpPJxMSJE+nfvz958+Z95nmxsbEsW7aMXr160aNHDwCqVKlCkyZNWLlyJRMmTEhVPAow/uoVZrVqqt7i6ObmzqxZX9CqVdtUXVMIIYQQmZNVtTQdOnSIWrVqqQkTgI+PD2azmaNHjz73vNOnTxMREYGPj49aZmtrS6NGjTh06FCq47kHzPzjdzVhql27Dvv3H5WESQghhMiGrKql6fr167Rta5mQuLq6kjt3bq5fv/7C8wCKFStmUV68eHHWrFlDTEwM9vb2KY4nT8GCXLt2DQB39xy4ubml+Bri1T2+q93NzQEN5zQTSF1YG6kP6yF1YT30+vQbb2lVSVNYWBiurq5Jyt3c3AgNDX3heba2ttjZ2VmUu7q6oigKoaGhqUqabGxskiRiQjta3jEhLEldWBepD+shdZG1Se0KIYQQQiSDVSVNrq6uhIeHJykPDQ19YdeYq6srcXFxSZZ3CAsLQ6fTSbeaEEIIIV6ZVSVNxYoVSzJ2KTw8nAcPHrywm+zxvhs3bliUX79+nXz58qWqa04IIYQQ4klWlTTVq1ePY8eOERYWppbt2LEDvV6Pl5fXc8+rXLkyzs7O+Pv/v717D2rqTv8H/oZUUO4iWivKKjInUDAiKl7CAlIsBawWlktdqBZR6ZSqpdoK6rBa2I6yXrYgBdYqSOuithWvgKBVUFC2rbow2LFaC11QgwYl0Mot+fz+6HC+xADGQGh/yfOayYx5cj7nPCeP4Tyc88mhkI91dnaiuLgYnp6eWs2ZEEIIIfrhDzUR/PXXX8dnn32G2NhYxMTEQCKRICUlBa+//rrSPZqWLl2KO3fuoKSkBABgbGyMmJgYpKWlwdraGhzHIS8vD48ePUJ0dPTvtTuEEEII0SF/qKbJ0tIS+/fvR1JSEmJjY2FqaoqQkBDExcUpLadQKCCXy5ViK1asAGMM+/bt4/+Myt69ezFhwoSh3AVCCCGE6CgDxuiOEoQQQgghT/OHmtNECCGEEPJHRU0TIYQQQogaqGkihBBCCFEDNU2EEEIIIWqgpokQQgghRA3UNBFCCCGEqEEvm6Yff/wRUVFRcHV1hVgsRkpKCjo6Op46jjGGf/3rX/D29oZIJEJ4eDiuXbum/YR1mCa1aGxsREpKChYtWoRp06bB09MTa9euRUNDwxBlrZs0/Vz0lJOTA6FQiJiYGC1lqR8GUguJRIL169dj9uzZEIlE8Pf3x/Hjx7WcsW7TtB4PHz5EYmIivL294erqigULFiAvL28IMtZddXV1SExMxKJFi/Diiy9iwYIFao0brOP3H+rmlkOhubkZS5cuxcSJE5GWlgaJRIKtW7eira0NiYmJ/Y7ds2cPUlNTsW7dOgiFQhw4cADLli3DsWPH6CaaGtC0FjU1NSgpKcFf/vIXTJ06FQ8fPkRGRgZCQ0Nx8uRJWFtbD+Fe6IaBfC663b9/H+np6Rg1apSWs9VtA6lFY2MjwsPDMWnSJCQlJcHMzAw3b9585uaX/J+B1GPNmjW4ffs23nvvPbzwwgsoKyvD5s2bIRAIEBYWNkR7oFtu3ryJ0tJSTJ06FQqFAureanLQjt9Mz2RmZjJXV1f28OFDPnbw4EHm5OTE7t271+e4trY25ubmxnbs2MHH2tvb2bx589jf/vY3LWasuzStRXNzM+vs7FSK3b17lwmFQrZ3715tpavTNK1FT++//z774IMPWGRkJFu5cqWWMtV9A6nFunXrWHh4OOvq6tJylvpD03o0NjYyjuPYV199pRSPiIhgS5Ys0Va6Ok8ul/P/Xr9+PQsMDHzqmME8fuvd5bmysjLMmTMHVlZWfMzf3x8KhQLl5eV9jrty5QpaW1vh7+/Px4yMjDB//nyUlZVpM2WdpWktLCws8NxzyidJx44dC2trazQ2NmorXZ2maS26ffvttzhz5gzWrl2rxSz1g6a1aG1tRWFhIf76179CIBAMQab6QdN6dHV1AQDMzc2V4mZmZmqfHSGqDA2fvW0ZzOO33jVNt2/fhr29vVLMwsICo0ePxu3bt/sdB0Bl7OTJk3Hnzh20tbUNfrI6TtNa9Oann36CVCrF5MmTBzNFvTGQWsjlciQlJeGtt97CmDFjtJmmXtC0FjU1Nejs7MRzzz2HyMhIODs7QywW4x//+Ac6Ozu1nbbO0rQeL7zwAjw8PJCZmYlbt26htbUVBQUFKC8vR0REhLbTJj0M5vFb7+Y0yWQyWFhYqMQtLS3R3Nzc7zgjIyMYGxsrxS0sLMAYQ3NzM4YPHz7o+eoyTWvxJMYYkpOTMWbMGAQGBg5minpjILX497//jcePH+PNN9/UUnb6RdNaPHjwAACwadMmhIWF4Z133kFVVRVSU1NhaGhIZwE1NJDPRlpaGuLi4vifSwKBAJs2bYKfn59WciW9G8zjt941TUT3pKWl4fLly/j0009hYmLye6ejV6RSKVJTU7Ft2zYYGRn93unoNYVCAQCYO3cu4uPjAQCzZ8/GL7/8gn379iE2NpZ+sRtCjDEkJCSgtrYWO3bswOjRo1FRUYGPPvoIlpaW9Ave/6f0rmmysLBAS0uLSry5uRmWlpb9juvo6EB7e7tStyqTyWBgYNDvWNI7TWvR0+HDh5Geno6///3vmDNnzmCnqDc0rcXHH38MoVCIGTNmQCaTAfhtLkdXVxdkMhlMTExU5p+R/g3kZxTwW6PU05w5c5CZmYm6ujoIhcLBTVYPaFqP8+fPo6ioCMePH+ff91mzZkEqlWLr1q3UNA2hwTx+692cJnt7e5Xr0C0tLbh//77K9c4nxwG/zZ3p6fbt2xg3bhz9BqcBTWvRraSkBJs3b8bq1asREhKirTT1gqa1+Omnn/DNN99g5syZ/OPKlSu4ePEiZs6ciYqKCm2nrnM0rYWDg0O/621vbx+U/PSNpvW4desWBAIBOI5Tijs5OaGxsRGPHz/WSr5E1WAev/WuafL09ERFRQX/WzEAFBUVwdDQEGKxuM9xbm5uMDMzQ2FhIR/r7OxEcXExPD09tZqzrtK0FgBQWVmJ9957D6GhoYiNjdV2qjpP01ps2LABubm5Sg9HR0e4uroiNzcXIpFoKNLXKZrWwtbWFhzHqTSqFRUVGD58+FObKtK7gdRDLpfjxo0bSvGamhqMGjUKI0aM0FrORNmgHr+f6QYFOuDRo0dMLBazyMhIduHCBfbll1+yGTNmsC1btigtt2TJEubr66sUy8rKYi4uLiwnJ4dVVFSwVatWsWnTprGff/55KHdBZ2hai1u3brHp06ezBQsWsO+++45dvXqVf9TV1Q31buiEgXwunkT3aRqYgdTi7NmzTCgUsuTkZHbx4kWWkZHBnJ2d2c6dO4dyF3SKpvVoaWlh3t7ebP78+ezo0aOsoqKCpaSkMEdHR5aenj7Uu6Ezfv31V1ZYWMgKCwtZZGQk8/Ly4p9LpVLGmHaP33o32cDS0hL79+9HUlISYmNjYWpqipCQEMTFxSktp1AoIJfLlWIrVqwAYwz79u1DU1MTnJycsHfvXrobuIY0rcV///tftLS0oKWlBYsXL1ZaNigoCFu3bh2S/HXJQD4XZHANpBY+Pj7YuXMnPvnkE+Tl5WHMmDFYtWoVVq5cOZS7oFM0rYeZmRlycnKwa9cubN++HS0tLRg/fjzi4+MRGRk51LuhM6RSKdasWaMU636em5uLWbNmafX4bcAY3WWLEEIIIeRp9G5OEyGEEEKIJqhpIoQQQghRAzVNhBBCCCFqoKaJEEIIIUQN1DQRQgghhKiBmiZCCCGEEDVQ00QIIYQQogZqmgghhBBC1EBNEyFESWVlJYRCISorK3/vVLRKKBQiLS1NrWV9fHwQHx+v5YwIIX90evdnVAjRVUeOHEFCQkKvr61YsQLr1q0b4ozU92TuRkZGGDduHMRiMd5++23Y2NhoPYcrV66gvLwcS5cuhYWFhda3pw4fHx80NDTwz0eMGAEHBwdERkbitdde02idpaWlqKqqwqpVqwYpS0L0BzVNhOiY1atXY/z48UoxjuN+p2yeTXfuHR0d+O6775CXl4fS0lKcPHly0P8qfFVVFQQCAf/86tWr2L17N4KCglSapqKiIhgYGAzq9tXl5OSEqKgoAMD9+/fxxRdfYP369ejo6EBYWNgzr6+0tBQHDhygpokQDVDTRIiO8fT0xJQpU37vNDTSM/fQ0FBYWVkhOzsbZ8+exYIFCwZ1W8bGxmova2RkNKjbfhbPP/88Fi1axD8PDg7GSy+9hJycHI2aJkKI5mhOEyF6oqGhAZs3b4afnx9EIhFmzZqF1atXo76+/qlja2trsWrVKojFYkyZMgWenp6Ii4tDS0uL0nLHjh1DcHAwRCIR3N3dERcXh7t372qc8+zZswGAz7Grqwvp6enw9fWFi4sLfHx8sHPnTnR0dCiNq66uRnR0NGbNmgWRSAQfHx+VS5c95zSlpaUhJSUFAPDSSy9BKBRCKBTy2+05p6m6uhpCoRD5+fkq+V64cAFCoRDnzp3jYxKJBAkJCZg7dy5cXFwQGBiIL7/8UuP3xNraGvb29vj555+V4t9++y1Wr14Nb29vuLi4wMvLCx999BHa2tr4ZeLj43HgwAF+/7sf3RQKBXJychAYGIgpU6Zg7ty5SExMRHNzs8b5EqJL6EwTITqmtbUVTU1NSjFra2tUV1fj6tWrCAwMxNixY9HQ0IC8vDwsWbIEp06d6vPyV0dHB6Kjo9HR0YHIyEjY2NhAIpHg/PnzkMlkMDc3BwBkZGTg448/hr+/P0JCQtDU1ITPP/8cEREROHr0qEbzhLobAysrKwDApk2bkJ+fDz8/P0RFRaGqqgpZWVn48ccfkZ6eDgCQSqWIjo7GyJEjsXLlSlhYWKC+vh4lJSV9bmf+/Pmora3FyZMnkZCQgJEjR/Lv25OmTJmCCRMmoLCwEEFBQUqvFRQUwNLSEh4eHgCABw8eICwsDAYGBoiIiIC1tTXKysqwceNGtLa24s0333zm96SrqwsSiQSWlpZK8aKiIrS1tWHx4sWwsrJCVVUVPv/8c9y7dw+pqakAgPDwcDQ2NqK8vJxvEntKTExEfn4+goOD8cYbb6C+vh4HDhzA9evXkZeXh2HDhj1zvoToFEYI0QlfffUV4ziu1wdjjD1+/FhlzNWrVxnHcSw/P5+PXb58mXEcxy5fvswYY+z69euM4zhWWFjY57br6+uZk5MTy8jIUIrfuHGDvfjiiyrxvnKvqKhgUqmU3b17l506dYq5u7szkUjE7t27x77//nvGcRzbuHGj0titW7cyjuPYpUuXGGOMlZSUMI7jWFVVVb/b5DiOpaam8s8//fRTxnEc+9///qey7Lx589j69ev55zt27GDOzs7s0aNHfKy9vZ3NmDGDJSQk8LENGzYwsVjMmpqalNYXFxfHpk+f3mtNntzusmXLmFQqZVKplN24cYO9//77jOM4tmXLFqVle1tXVlYWEwqFrKGhgY9t2bKF/z/R0zfffMM4jmPHjx9XipeVlfUaJ0Qf0ZkmQnRMYmIiJk2apBIfPnw4/+/Ozk60trbCzs4OFhYWuH79ep/fxjIzMwMAXLx4EV5eXr2ekSopKYFCoYC/v7/SWS4bGxv86U9/QmVlJd56662n5v7kmRdbW1ts374dzz//PI4ePQoA/KTobsuWLcO+fftQWlqK2bNn82e+zp8/D0dHR62cHQkICEBWVhaKi4sRGhoKACgvL4dMJkNAQAAAgDGG4uJi+Pv7gzGm9L54eHjg1KlTqKmpwfTp0/vd1sWLFzFnzhylWHBwMD744AOlWM/6/vrrr2hra8O0adPAGMP169cxbty4frdTVFQEc3NziMVipVydnZ1hYmKCyspKvPrqq/2ugxBdR00TITpGJBL1OhG8ra0NWVlZOHLkCCQSCRhj/GtPzk3qacKECYiKikJ2djZOnDiBGTNmwMfHBwsXLuQblNraWjDG8PLLL/e6jueeU+9HTXfDJxAIYGNjg0mTJsHQ8Leplw0NDTA0NISdnZ3SmNGjR8PCwoL/ar67uzv8/Pywe/du5OTkwN3dHb6+vnj11VcHbUK3o6Mj7O3tUVhYyDdNBQUFGDlyJD8Pq6mpCTKZDIcOHcKhQ4d6Xc+Tl1F7M3XqVLz77ruQy+W4efMmMjIyIJPJVJrBO3fuIDU1FV9//bXKHKTW1tanbqeurg4tLS0qDVo3qVT61HUQouuoaSJETyQlJeHIkSNYunQpXF1dYW5uDgMDA8TFxSk1UL2Jj49HUFAQzp49i/LyciQnJyMrKwuHDx/G2LFjoVAoYGBggD179ih9jb+biYmJWjn21fD19LSv/hsYGCA1NRXXrl3DuXPncOHCBWzYsAHZ2dk4dOgQTE1N1crlaQICApCZmYmmpiaYmZnh66+/RmBgIN8gKhQKAMDChQtV5j516zkJuy8jR47E3LlzAQB//vOfYW9vj5iYGOTm5vJn3eRyOaKiotDc3Izly5fD3t4eJiYmkEgkiI+P53Ppj0KhwKhRo7B9+/ZeX+9tfhch+oaaJkL0xOnTp/Haa68p3dm6vb2937NMPXV/0+rtt9/GlStXsHjxYuTl5SEuLg52dnZgjGH8+PG9XhocDLa2tlAoFKirq8PkyZP5+IMHDyCTyWBra6u0vKurK1xdXREXF4cTJ05g3bp1KCgo4M8MPelZ78MUEBCA3bt3o7i4GDY2NmhtbUVgYCD/urW1NUxNTaFQKPimZzB4e3vD3d0dmZmZCA8Ph4mJCX744QfU1tZi27ZtSpdZy8vLVcb3tZ92dna4dOkS3NzclC71EUL+D91ygBA90dsZoM8++wxyubzfca2trejq6lKKcRwHQ0ND/qv+L7/8MgQCAXbv3q1y1ooxhocPHw4we8DLywsAsH//fqV4dna20uvNzc0qOTg5OQGAyq0Jeuqeq6VuEzl58mRwHIeCggIUFBRg9OjRmDlzJv+6QCCAn58fTp8+jR9++EFlvDqX5vqyfPlyPHr0CIcPHwYA/hJmz/1mjCE3N1dlbPd+ymQypbi/vz/kcjk++eQTlTFdXV0qyxOij+hMEyF6wtvbG8eOHYOZmRkcHBxw7do1VFRU8F/n78vly5fx4Ycf4pVXXsHEiRMhl8tx7NgxvikAfjtL8e6772LHjh1oaGiAr68vTE1NUV9fjzNnziAsLAzR0dEDyt/R0RFBQUE4dOgQZDIZZs6cierqauTn58PX15efS5Sfn4+8vDz4+vrCzs4Ov/zyCw4fPgwzMzN4enr2uX5nZ2cAwK5duxAQEIBhw4Zh3rx5/V5aDAgIQGpqKoyNjRESEsI3L93Wrl2LyspKhIWFITQ0FA4ODmhubkZNTQ0uXbqE//znPxq9F15eXuA4Djk5OYiIiIC9vT3s7Oywbds2SCQSmJmZ4fTp0702Ot37mZycDA8PDwgEAgQGBsLd3R3h4eHIysrC999/D7FYjGHDhqG2thZFRUXYuHEjXnnlFY3yJURXUNNEiJ7YuHEjDA0NceLECbS3t8PNzQ3Z2dlYvnx5v+OEQiE8PDxw7tw5SCQSjBgxAkKhEHv27IGrqyu/3MqVKzFx4kTk5OTw90waO3YsxGIxfHx8BmUfkpOTMX78eOTn5+PMmTOwsbFBTEwM3nnnHX4Zd3d3VFdXo6CgAA8ePIC5uTlEIhG2b9+OCRMm9LlukUiENWvW4ODBg7hw4QIUCgXOnj371Kbpn//8Jx4/fgx/f3+V121sbPDFF18gPT0dJSUlyMvLg5WVFRwcHAb8twCXLVuG+Ph4nDhxAsHBwcjMzOTnmhkbG2P+/PmIiIhQups48NtZwTfeeAOnTp3C8ePHwRjjLyt++OGHcHFxwcGDB7Fr1y4IBALY2tpi4cKFcHNzG1C+hOgCA/a0GaCEEEIIIYTmNBFCCCGEqIOaJkIIIYQQNVDTRAghhBCiBmqaCCGEEELUQE0TIYQQQogaqGkihBBCCFEDNU2EEEIIIWqgpokQQgghRA3UNBFCCCGEqIGaJkIIIYQQNVDTRAghhBCiBmqaCCGEEELU8P8AK5FwbzUrfEcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot ROC curve\n", + "plot_ROC(bundled_data, 'Dosage Sensitive vs Insensitive TFs')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot confusion matrix\n", + "classes_list = [\"Dosage Sensitive\", \"Dosage Insensitive\"]\n", + "plot_confusion_matrix(classes_list, confusion, \"Geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weighted Accuracy: 0.7942145185000915\n" + ] + } + ], + "source": [ + "actual_totals = confusion.sum(axis=1)\n", + "\n", + "# Compute correct predictions per class (diagonal)\n", + "correct_predictions = np.diag(confusion)\n", + "\n", + "# Compute class-wise accuracies\n", + "class_accuracies = correct_predictions / actual_totals\n", + "# print(class_accuracies)\n", + "\n", + "# Compute class weights (based on actual class frequency)\n", + "counting_num = confusion.sum(axis=0)\n", + "class_weights = counting_num / counting_num.sum()\n", + "\n", + "# Compute weighted accuracy\n", + "weighted_accuracy = np.sum(class_weights * class_accuracies)\n", + "\n", + "print(f\"Weighted Accuracy: {weighted_accuracy}\")" + ] + } + ], + "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.7" + }, + "vscode": { + "interpreter": { + "hash": "eba1599a1f7e611c14c87ccff6793920aa63510b01fc0e229d6dd014149b8829" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Downstream_tasks/Classification/Gene_dosage_ML.ipynb b/Downstream_tasks/Classification/Gene_dosage_ML.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f4f4efdfa9f300365b4141e25ef662feb1fa0ca7 --- /dev/null +++ b/Downstream_tasks/Classification/Gene_dosage_ML.ipynb @@ -0,0 +1,548 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading dosage sensitive TF data...\n", + "# targets1: 122\n", + "# targets2: 368\n", + "# splits: 5\n", + "Loading training dataset...\n", + "Extracting features for classification...\n", + "Creating gene co-expression features...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10000/10000 [56:14<00:00, 2.96it/s] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature matrix shape: (490, 4)\n", + "Labels distribution: [122 368]\n", + "Starting 5-fold cross-validation...\n", + "\n", + "Fold 1/5\n", + "\n", + "Random Forest Results:\n", + "Accuracy: 0.7551\n", + "Precision (Macro): 0.6710\n", + "Precision (Weighted): 0.7431\n", + "F1 (Macro): 0.6591\n", + "F1 (Weighted): 0.7477\n", + "\n", + "Logistic Regression Results:\n", + "Accuracy: 0.7449\n", + "Precision (Macro): 0.6538\n", + "Precision (Weighted): 0.7292\n", + "F1 (Macro): 0.6394\n", + "F1 (Weighted): 0.7349\n", + "\n", + "Fold 2/5\n", + "\n", + "Random Forest Results:\n", + "Accuracy: 0.8367\n", + "Precision (Macro): 0.7922\n", + "Precision (Weighted): 0.8304\n", + "F1 (Macro): 0.7728\n", + "F1 (Weighted): 0.8318\n", + "\n", + "Logistic Regression Results:\n", + "Accuracy: 0.7959\n", + "Precision (Macro): 0.7329\n", + "Precision (Weighted): 0.8016\n", + "F1 (Macro): 0.7382\n", + "F1 (Weighted): 0.7984\n", + "\n", + "Fold 3/5\n", + "\n", + "Random Forest Results:\n", + "Accuracy: 0.7755\n", + "Precision (Macro): 0.6938\n", + "Precision (Weighted): 0.7695\n", + "F1 (Macro): 0.6875\n", + "F1 (Weighted): 0.7721\n", + "\n", + "Logistic Regression Results:\n", + "Accuracy: 0.7551\n", + "Precision (Macro): 0.6645\n", + "Precision (Weighted): 0.7484\n", + "F1 (Macro): 0.6591\n", + "F1 (Weighted): 0.7514\n", + "\n", + "Fold 4/5\n", + "\n", + "Random Forest Results:\n", + "Accuracy: 0.8367\n", + "Precision (Macro): 0.7924\n", + "Precision (Weighted): 0.8281\n", + "F1 (Macro): 0.7576\n", + "F1 (Weighted): 0.8283\n", + "\n", + "Logistic Regression Results:\n", + "Accuracy: 0.7857\n", + "Precision (Macro): 0.7322\n", + "Precision (Weighted): 0.7657\n", + "F1 (Macro): 0.6174\n", + "F1 (Weighted): 0.7469\n", + "\n", + "Fold 5/5\n", + "\n", + "Random Forest Results:\n", + "Accuracy: 0.8163\n", + "Precision (Macro): 0.7524\n", + "Precision (Weighted): 0.8116\n", + "F1 (Macro): 0.7443\n", + "F1 (Weighted): 0.8136\n", + "\n", + "Logistic Regression Results:\n", + "Accuracy: 0.7449\n", + "Precision (Macro): 0.6365\n", + "Precision (Weighted): 0.7212\n", + "F1 (Macro): 0.6145\n", + "F1 (Weighted): 0.7289\n", + "\n", + "============================================================\n", + "CROSS-VALIDATION SUMMARY\n", + "============================================================\n", + " accuracy precision_macro \\\n", + " mean std mean std \n", + "classifier \n", + "Logistic Regression 0.7653 0.0239 0.6840 0.0454 \n", + "Random Forest 0.8041 0.0371 0.7403 0.0559 \n", + "\n", + " precision_weighted f1_macro f1_weighted \\\n", + " mean std mean std mean \n", + "classifier \n", + "Logistic Regression 0.7532 0.0321 0.6537 0.0506 0.7521 \n", + "Random Forest 0.7965 0.0386 0.7243 0.0486 0.7987 \n", + "\n", + " \n", + " std \n", + "classifier \n", + "Logistic Regression 0.0274 \n", + "Random Forest 0.0371 \n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABcsAAAPXCAYAAAD0UBMMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XtclGX+//E3M4AHcMADkmkGqJBRrLqbShSddM3DpqtWmBa5rvFLwsRqTXM1VytjPS6u4abmYVtx+2YlapStGSsevttq4lp5AA+Vu4SnGUARmZnfHy7zdeIQDKcBXs/Ho8fEdd+f67rumxkv5jPXXJeH3W63CwAAAAAAAACAZszQ0B0AAAAAAAAAAKChkSwHAAAAAAAAADR7JMsBAAAAAAAAAM0eyXIAAAAAAAAAQLNHshwAAAAAAAAA0OyRLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7JEsBwAAANzciy++qPvvv79aMfv27VNYWJj27dtXR70CAKBpY/wtX1hYmJKTk12O/d3vflfLPaqexx9/XI8//niD9gHui2Q50Ay8/fbbCgsL08MPP9zQXQEAoFHYtGmTwsLCHP/dfvvtGjRokH73u9/p7NmzDd09t/f4448rLCxMP//5z8s9npmZ6bi36enp9dw7AIC7Yvx13cSJE3XHHXfIbrc7lX/55ZcKCwvTfffdVyZmz549CgsL08aNG+urm1W2f/9+JScny2KxNHRX0Mx4NnQHANS9tLQ0de7cWVlZWTp16pRuvvnmhu4SAACNwuTJk9WlSxcVFxfrn//8pzZs2KDPPvtMW7ZsUatWreqtH3Pnzi3z5vfH3HHHHcrKypKXl1cd9apyLVq00KlTp5SVlaWIiAinY2lpaWrRooWuXLnSIH0DALg3xt/q++lPf6qMjAwdPXpUYWFhjvL9+/fL09NTZ86c0X/+8x/dcMMNTsdKY6sjKytLRqOxdjpegQMHDmjZsmX65S9/KZPJVKdtAddjZjnQxH3zzTc6cOCApk+frnbt2iktLa2hu1SuS5cuNXQXAAAoIzo6WsOHD9fDDz+s+fPnKzY2Vt9++63+9re/VRhTF2Oal5eXvL29qxVjMBjUokULGQwN8yd/165dFRwcrC1btjiVX7lyRdu3b9e9995b7326cuWKbDZbvbcLAKgext/qK014//Of/3Qq379/v6Kjo9W6detyj/n7+6tbt27VaqtFixby9GT+LZomkuVAE5eWliY/Pz/dc889GjRoULnJcovFoldffVX333+/brvtNkVHR+s3v/mNzp8/7zjnypUrSk5O1qBBg3T77bfrrrvu0jPPPKPTp09Lqnhdtm+//VZhYWHatGmTo+zFF19U7969dfr0aU2cOFG9e/fW888/L0n6/PPPNXnyZN1777267bbbdM899+jVV19VUVFRmX5nZ2fr2WefVf/+/RUREaFBgwZp8eLFkqS9e/cqLCxM27dvL/eehIWF6cCBAy7cUQBAc9a/f39J18Y3qfIxzWazac2aNRo6dKhuv/123XnnnZo1a5bMZnOZej/77DONGzdOvXv3Vp8+fTRq1CinMbu8NVO3bt2qkSNHOmJ+8YtfaO3atY7jFY3NH374oUaOHKmIiAj169dPzz//vHJzc53OKb2u3NxcTZo0Sb1791b//v31+uuvy2q1Vvl+DRs2TNu2bXNKUO/YsUNFRUV68MEHy5z/3Xff6eWXX9agQYMc/Zs8ebLjfl/vx/5+Kb3+rVu3avHixbr77rv1k5/8RAUFBVW+DwAA98D4++Pjb0REhLy8vByzxUvt379fd9xxhyIiIpyO2Ww2ffHFF+rdu7c8PDwkXRtbX3nlFd1zzz267bbbNHDgQP3pT38q80FzeWuW79u3TyNHjtTtt9+uAQMGKDU1VcnJyU6z3K/3ySefaNiwYbrttts0dOhQZWRkOI4lJycrKSlJkvTAAw84luW5/u+BDz74wHE/+/btq8TERP373/8u087GjRs1YMAARUREaPTo0fr8888rvY8AHwMBTVxaWpoGDhwob29vDRs2TBs2bHD6OnRhYaHGjh2r7OxsjRo1SrfeeqsuXLigHTt2KDc3V+3atZPValVcXJz27NmjoUOH6oknnlBhYaEyMzN19OhRde3atdr9Kikp0YQJE/TTn/5U06ZNU8uWLSVJ6enpKioq0pgxY+Tv76+srCz9+c9/1n/+8x/94Q9/cMR//fXXGjt2rDw9PfXoo4+qc+fOOn36tHbs2KHExET169dPnTp1clz/D+9J165d1bt37xrcWQBAc1T6IbG/v7+jrKIxbdasWXrvvfc0cuRIPf744/r222/19ttv68svv9SGDRscX8/etGmTZsyYoR49eiguLk5t2rTRV199pb///e/6xS9+UW4/MjMzNXXqVEVGRjqSAzk5Odq/f79iY2Mr7P+mTZs0ffp03X777Zo6darOnTundevWaf/+/Xr//fedvuZstVo1YcIERURE6De/+Y327Nmj1atX66abbtJjjz1Wpfs1bNgwJScna9++fYqMjJQkbdmyRf3791f79u3LnH/o0CEdOHBAQ4cO1Q033KDvvvtOGzZs0BNPPKGtW7c6vnpflb9fSi1fvlxeXl6aMGGCiouL5eXlVa37AABoeIy/Pz7+tmjRQrfddptTQvzf//63/v3vf6t3796yWCz67LPPHMeOHj2qgoICx4z0y5cva9y4ccrNzVVMTIw6deqkAwcOaNGiRcrLy9NLL71UYdtffvmlfv3rXysgIEAJCQmy2Wz64x//6DQeX++f//ynPv74Yz322GPy8fHR+vXrNXnyZH366adq27atBg4cqJMnT2rLli2aPn262rZtK0mO+t544w0tXbpUgwcP1ujRo3X+/Hn9+c9/1tixY53u5zvvvKNZs2apd+/eio2N1TfffKOnn35afn5+6tSpU4XXg2bODqDJOnTokD00NNSemZlpt9vtdpvNZo+OjrbPmzfPcc7SpUvtoaGh9o8//rhMvM1ms9vtdvv//M//2ENDQ+1vvfVWhefs3bvXHhoaat+7d6/T8W+++cYeGhpqf/fddx1l06ZNs4eGhtoXLFhQpr7Lly+XKVuxYoU9LCzM/t133znKxo4da+/du7dT2fX9sdvt9oULF9pvu+02u8VicZSdO3fOfuutt9r/8Ic/lGkHAIBS7777rj00NNS+e/du+7lz5+z//ve/7Vu3brX37dvXHhERYf/Pf/5jt9srHtP+8Y9/2ENDQ+2bN292Ks/IyHAqt1gs9t69e9sffvhhe1FRkdO5149p06ZNs993332On+fNm2fv06ePvaSkpMJr+OHYXFxcbI+MjLQPGzbMqa1PP/3UHhoaal+6dKlTe6GhofZly5Y51TlixAj7L3/5y4pv3H+NGzfOPnToULvdbrePHDnSPmPGDLvdbrebzWZ7eHi4/b333nP078MPP3TElfd3wIEDB+yhoaH29957z1FWlb9fSut/4IEHnOqtzn0AANQvxt+ajb+vv/66PTQ01HGftmzZYr/99tvtV65cse/cudPes2dPe35+vt1ut9v//Oc/20NDQ+3//Oc/7Xa73f7HP/7R3qtXL/uJEyec6lywYIG9Z8+e9jNnzjjKQkNDnd5Tx8XF2X/yk5842rXb7faTJ0/ab731VntoaKhTfaGhofbw8HD7qVOnHGVfffWVPTQ01L5+/XpH2cqVK+2hoaH2b775xin+22+/tffs2dP+xhtvOJUfOXLEfuuttzrKS+/78OHD7VeuXHGct3HjRntoaKh93LhxP3I30VyxDAvQhKWlpalDhw7q16+fJMnDw0NDhgzRtm3bHF/h+vjjj3XLLbeUmX1den7pOW3bttW4ceMqPMcVY8aMKVNWOhtAurbm3Pnz59W7d2/Z7XZ9+eWXkqTz58/rH//4h0aNGqUbb7yxwv4MHz5cxcXFSk9Pd5Rt27ZNJSUleuihh1zuNwCg+XjyyScVGRmpe+65R4mJifLx8dGyZcsUGBjodN4Px7T09HS1adNGUVFROn/+vOO/8PBwtW7d2vHV7MzMTBUWFuqpp55SixYtnOqobIw1mUy6fPmyMjMzq3wt//rXv3Tu3DmNGTPGqa17771XISEh2rlzZ5mYH17XT3/603KXRKnML37xC23fvl3FxcX66KOPZDQaNWDAgHLPvf7vgKtXr+rChQvq2rWrTCaT4+8AqWp/v5QaMWKEU72u3AcAQP1i/HVt/C2dJV661Mj+/fsVHh4ub29v9e7dWzabTQcPHnQcK52NLl27dz/96U9lMpmc7t2dd94pq9Wqf/zjH+W2abVatWfPHj3wwANOv5+bb75Zd999d7kxd955p9M31G+55Rb5+vrqm2+++dFr3L59u2w2mwYPHuzUzw4dOujmm292/I5L73tMTIzTuvO//OUv1aZNmx9tB80Xy7AATZTVatXWrVvVr18/p0E1IiJCq1ev1p49e3TXXXfp9OnT+vnPf15pXadPn1ZwcHCtbuDh6enptAt3qTNnzugPf/iDduzYUWZNudI1RksH0NDQ0Erb6Natm26//XalpaXp4YcflnTtA4RevXrp5ptvro3LAAA0cbNmzVJwcLCMRqM6dOig4ODgMht2lTemnTp1Svn5+Y6lR37o3Llzkv7va+U9evSoVr8ee+wxffjhh5o4caICAwMVFRWlwYMHKzo6usKYM2fOSJKCg4PLHAsJCSmz6VeLFi3KfH3az8+v3DVfKzNkyBC9/vrrysjI0ObNm3XvvffK19e33HOLioq0YsUKbdq0Sbm5ubLb7Y5j+fn5jv+vyt8vpbp06eL0c3XvAwCg/jH+ujb+9unTRx4eHtq/f7+GDh2q/fv3684775R0LdHfvXt37d+/X1FRUdq/f79uv/12RyL51KlTOnLkSIX37vo9za537tw5FRUVlfseu6L33eUtgeLn5yeLxfKj13jy5EnZ7fYK/w4ozVuU3vcf9sHLy0s33XTTj7aD5otkOdBE7d27V3l5edq6dau2bt1a5nhaWpruuuuuWmuvok/ff7gRSClvb+8yf+xYrVaNHz9eZrNZv/71rxUSEqLWrVsrNzdXL774YoV1VWbEiBF65ZVX9J///EfFxcX64osvNGvWrGrXAwBoniIiInT77bdXek55Y5rNZlP79u21YMGCcmMqWsOzqtq3b6/3339fu3btUkZGhjIyMrRp0yaNGDFCr7/+eo3qLmU0Gmulno4dO6pv37566623tH///jIbgl1v7ty52rRpk2JjY9WrVy+1adNGHh4eSkxMdEqcV8f1s8oBAI0D469r2rZt60jAFxYW6siRI4qPj3cc7927t/75z3/qP//5j86cOeO0NrvNZlNUVJR+/etfl1t3UFCQy/36oYqusSpjvc1mk4eHh958881y62ndunWN+4fmjWQ50ESlpaWpffv25SaGt2/fru3bt2vOnDnq2rWrjh07VmldXbt21cGDB3X16lXHZig/VLqBxvWzviTpu+++q3Kfjx49qpMnT+r111/XiBEjHOU//Ipb6afAR48e/dE6hwwZovnz52vLli0qKiqSl5eXBg8eXOU+AQDgiq5du2rPnj3q06dPpcna0q8gHzt2rNrfevL29tb999+v+++/XzabTS+//LI2btyoSZMmlVtX6dJlJ06cKDNr7MSJE2WWNqtNw4YN08yZM2UymSqdfffRRx9pxIgRevHFFx1lV65cKfP3RVX+fqlIQ94HAEDdYvy9thTLu+++q8zMTFmtVvXp08dxrHfv3tqyZYtjqZLSZVuka/fk0qVLjpnoVdW+fXu1aNFCp06dKnOsvLKqqmhCXteuXWW329WlS5dyZ+uXKr2vp06dcrrvV69e1bfffqtbbrnF5b6haWPNcqAJKioq0scff6x7771XDz74YJn/xo4dq8LCQu3YsUM///nP9fXXX2v79u1l6in9VPfnP/+5Lly4oLfffrvCczp37iyj0VhmHbMNGzZUud+lswKu/zTZbrdr3bp1Tue1a9dOd9xxh959913HV6t+2J/rz7377ru1efNmx2z6ms4mAADgxwwePFhWq1XLly8vc6ykpMTxNeO77rpLPj4+WrFiha5cueJ0XmWzqy5cuOD0s8FgUFhYmCSpuLi43JjbbrtN7du3V2pqqtM5n332mbKzs3XvvfdW6dpc8eCDD+qZZ57R7NmzndYN/aHyZoitX7/esddKqar8/VKRhrwPAIC6xfh7LQFutVq1evVqBQUFOb3/7d27ty5duqQNGzbIYDCod+/ejmODBw/WgQMH9Pe//71MnRaLRSUlJeW2ZzQadeedd+pvf/ubcnNzHeWnTp0qt66qatWqlaSyE/J+/vOfy2g0atmyZWV+V3a73fE7uu2229SuXbsy9/29996r0nIvaL6YWQ40QTt27FBhYaHuv//+co/36tVL7dq10+bNm7Vw4UJ99NFHevbZZzVq1CiFh4fLbDZrx44dmjNnjm655RaNGDFC77//vl577TVlZWXppz/9qS5fvqw9e/ZozJgxGjBggNq0aaMHH3xQf/7zn+Xh4aGbbrpJO3fudKwJVxUhISHq2rWrXn/9deXm5srX11cfffRRuQPZzJkzNWbMGP3yl7/Uo48+qi5duui7777Tzp079cEHHzidO2LECE2ePFmS9Oyzz1bjTgIA4Jq+ffvq0Ucf1YoVK/TVV18pKipKXl5eOnnypNLT0/XSSy/pwQcflK+vr6ZPn66ZM2dq9OjRGjZsmEwmk77++msVFRVV+JXumTNnymw2q3///goMDNSZM2f05z//WT179lS3bt3KjfHy8tLzzz+v6dOna9y4cRo6dKjOnTundevWqXPnznryySfr7H60adNGCQkJP3revffeqw8++EC+vr7q3r27vvjiC+3evVv+/v5O502YMOFH/36pSEPeBwBA3WL8/b/Z4gcOHNDIkSOdjgUHB6tt27Y6cOCAQkNDHd8Ql66NrTt27ND/+3//T7/85S8VHh6uy5cv6+jRo/roo4/0t7/9rcKJZ88884x27dqlMWPGaMyYMbLZbPrzn/+sHj166KuvvnLpOsLDwyVJixcv1pAhQ+Tl5aX77rtPXbt21ZQpU7Rw4UJ99913GjBggHx8fPTtt9/qk08+0SOPPKIJEybIy8tLU6ZM0axZsxQbG6shQ4bo22+/1aZNm1izHJUiWQ40QZs3b1aLFi0UFRVV7nGDwaB7771XaWlpKi4u1ttvv63k5GRt375d7733ntq3b6/IyEjHTtZGo1Fvvvmm3njjDW3ZskUff/yx/P391adPH8en6NK1PxxKSkqUmpoqb29vPfjgg/rNb36jYcOGVanfXl5eSklJ0bx587RixQq1aNFCAwcO1NixYzV8+HCnc2+55Rb99a9/1dKlS7VhwwZduXJFN954Y7lLrNx3333y8/OTzWbTAw88UNXbCABAjfzud7/TbbfdptTUVC1evFhGo1GdO3fWQw895PSV6Icffljt27fXn/70Jy1fvlyenp4KCQmp9M3zQw89pL/+9a/6y1/+IovFooCAAA0ePFgJCQll1m+93siRI9WyZUu9+eabWrBggVq3bq0BAwbohRdecHrD3FBeeuklGQwGpaWl6cqVK+rTp4/eeuutMuun+vj4/OjfL5Vx9/sAAHBdcx9/b7rpJnXs2FHff/+908zxUr1799aOHTuclmCRrs3kXr9+vVasWKH09HS9//778vX1VVBQkBISEtSmTZsK27ztttv05ptvKikpSUuXLlWnTp00efJk5eTkKCcnx6XriIiI0LPPPqvU1FT9/e9/l81m09/+9je1bt1aTz31lIKCgrRmzRr98Y9/lCTdcMMNioqKcpo0+Oijj8pqtWrVqlVKSkpSaGio3njjDS1dutSlPqF58LC7ulMOADQSJSUluvvuu3Xffffp1VdfbejuAAAAAADQ5E2aNEnHjx/Xxx9/3NBdAaqMNcsBNHmffPKJzp8/77RpKAAAAAAAqB1FRUVOP588eVIZGRnq27dvA/UIcA3LsABosg4ePKgjR45o+fLluvXWWxmkAQAAAACoAwMGDNAvf/lL3XTTTfruu++UmpoqLy+vMkupAe6OZDmAJmvDhg3avHmzbrnlFs2fP7+huwM0SdnZ2Zo3b54OHDggHx8fDR8+XFOmTJG3t3elcRcuXNDixYuVkZGhixcvqkuXLho7dqzGjBnjdF5ubq7mzZunXbt2ycvLSwMHDtT06dPl6+tbl5cFAAAAoBruvvtubd26VXl5efL29lavXr00depUBQUFNXTXgGphzXIAAOASs9msoUOHKigoSHFxccrNzdX8+fP10EMPadasWZXGPvHEE8rJydHUqVPVqVMnZWRkaPXq1Zo7d64eeeQRSdLVq1c1cuRISVJiYqKKior0+uuv65ZbbtGKFSvq/PoAAAAAAM0LM8sBAIBLUlNTVVhYqGXLlsnf31+SZLVaNWfOHMXFxSkwMLDcuLy8PO3bt0+vvfaaIxkeGRmpQ4cOaevWrY5k+UcffaRjx45p27ZtCgkJkSSZTCZNmDBBWVlZioiIqPuLBAAAAAA0G2zwCQAAXJKRkaHIyEhHolySBg8eLJvNpszMzArjSkpKJElt2rRxKvf19dX1X3jLyMhQWFiYI1EuSVFRUfL399dnn31WS1cBAAAAAMA1bjezvK7XPi1ls9k0evRoHT58WEuXLtWDDz7ocp/tdrtsNlazcScGgwe/E6AKeK24F4PBQx4eHg3djSrLycnRqFGjnMpMJpMCAgKUk5NTYVynTp101113KSUlRcHBwbrhhhuUkZGhzMxMLViwwKn+6xPlkuTh4aHg4OBK6/8xjNvuh3+LgKrhteJeGtu43Vgxbrsf/i0CqobXinup6rjtVslys9ms2NhYBQUFKTk52bH2aVFR0Y+uffrss8+WWfv05ZdfltFodHyd+3qpqanKzc2tlX7bbHadP19YK3Wh5jw9DWrb1kcWyyWVlNgaujuA2+K14n7atfOR0dh43nRbLBaZTKYy5X5+fjKbzZXGJicnKzExUUOHDpUkGY1GzZw5U4MGDXKq/4ezz6ta/48xGvlynbtpTM99oCHxWkFzw/tt98J7CKBqeK24n6q+33arZHldr31a6vz581q6dKl+85vfaMaMGXV6TQAAwJndbtf06dN18uRJLVy4UAEBAdq9e7deffVV+fn5ORLodcVms8tiuVSnbaDqjEaDTKZWslguy2rljQRQEV4r7sdkasWHrwAANDFulSyvaO3T2bNnKzMz05EI/6HK1j69dKnsm+FFixapX79+6tevX+11HgCAZsZkMik/P79Mudlslp+fX4VxO3fuVHp6ujZv3qywsDBJUr9+/XTu3DnNnz/fkSw3mUwqKCgot/5OnTrVqO/M7nA/VquN3wtQBbxWAAAA6o5bJcvreu1TScrKytKWLVu0ZcuWWu27pyczCtxF6ewOZnkAleO1gpoKCQkpMz7n5+crLy+vzFrj1zt+/LiMRqNCQ0Odynv27Kl33nlHly9fVqtWrRQSEqKjR486nWO323XixAlFRUXV3oUAAAAAACA3S5bX9dqnNptNc+bM0fjx49WlSxd9++23tdJvg8FDbdv61EpdqD0mU6uG7gLQKPBagauio6OVkpLiNH6np6fLYDBUmszu3LmzrFarjhw5oltuucVRfvjwYbVv316tWrVy1L9582adPHlSQUFBkqQ9e/bo4sWLuueee+ruwgAAAAAAzZJbJctdVdW1T9955x2dPXtWTz31VK22z9qn7oX1HIGq4bXifhrb2qcxMTFav3694uPjFRcXp9zcXCUlJSkmJsZpn5HY2FidOXNG27dvl3QtCX7jjTdq8uTJio+PV8eOHbVr1y699957SkhIcMQNGjRIK1asUEJCgqZOnarLly8rKSlJ9957ryIiIur9egEAAAAATZtbJcvrcu3TwsJCLVq0SImJibp69aquXr3qWAe1qKhIBQUF8vX1dbnvrBvofljPEagaXitwlZ+fn9auXau5c+cqPj5ePj4+Gj16tBITE53Os9lsslqtjp99fX21Zs0aLV68WAsWLFB+fr66dOmiF198UePGjXOc5+XlpZUrV2revHmaOnWqPD09NXDgQDbnBgAAAADUCbdKltfl2qcXLlzQxYsXNXv2bM2ePdvpvGnTpqlDhw7KzMysvYsBAKAZ6Natm9asWVPpOevXry9TdvPNN2vJkiU/Wn9gYKCSk5Nd7B0AAAAAAFXnVsnyulz7NCAgQOvWrXOKO3v2rKZOnaqEhATdeeeddXNRAAAAAAAAAAC351bJ8rpc+7RFixbq16+fU3ulG3x2795dffr0qaerBAAAAAAAAAC4G7dKltf12qcAAAAAAAAAAJTHw2632xu6E42d1WrT+fOFDd0N/Jenp0Ft2/rowoVCNi0EKsFrxf20a+cjo9HQ0N1o8hi33Qv/FgFVw2vF/TBu1w/GbffCv0VA1fBacT9VHbcZ2QEAAAAAAAAAzZ5bLcMCXC8n57gKCgrKPXbmzBkVFuaXe8xgMMjHp4UKC6/IZiv/0zsfnza68cYbyz3m6+urkJDurnUaAIBminEbAICm4eTJE7JYzOUeMxoNslqLZDS2lNVa/rhtMvkpKCi4LrsIAHWGZDncUk7OcfXv33Cbru7du5833gAAVBHjNgAATcO5c+fUv3/vCj/Argqj0ah//eu42rdvX4s9A4D6QbIcbql0Ztry5W8qNDSszPG6mqF29OgRTZo0scKZcQAAoCzGbQAAmob27dtr794DFc4sz84+pri4CVqxYpW6detR7jkmkx+JcgCNFslyuLXQ0DBFRPQqU15eWSk2UQAAoGEwbgMA0PhVtoRK6eZ4oaFhCg+PqK8uAUC9YYNPAAAAAAAAAECzR7IcAAAAAAAAANDssQwLAAAAAABAM5KTc9ylPT+ys49JurZviNVa/eXTfH192ZQbgFsjWQ4AAAAAANBM5OQcV//+fWpUR1zcBJdj9+7dT8IcgNsiWQ4AAAAAANBMlM4oX778TYWGhlUr1mg0yGotktHYstozy48ePaJJkya6NKMdAOoLyXIAAAAAAIBmJjQ0TBERvaoV4+lpUNu2PrpwoVAlJdVfhgUA3B0bfAIAAAAAAAAAmj2S5QAAAAAAAACAZo9kOQAAAAAAAACg2SNZDgAAAAAAAABo9kiWAwAAAAAAAACaPZLlAAAAAAAAAIBmj2Q5AAAAAAAAAKDZI1kOAAAAAAAAAGj2SJYDAAAAAAAAAJo9z4buAAAAaLyys7M1b948HThwQD4+Pho+fLimTJkib2/vCmP27dunJ554otxjwcHBSk9Pd/z8+eefa+nSpfr6669lMBh0++2367nnnlPPnj1r/VoAAAAAAM0byXIAAOASs9ms2NhYBQUFKTk5Wbm5uZo/f76Kioo0a9asCuPCw8O1ceNGp7KCggJNnDhR0dHRjrKcnBxNmDBB/fv318KFC1VcXKwVK1boySef1JYtWxQQEFBn1wYAAAAAaH5IlgMAAJekpqaqsLBQy5Ytk7+/vyTJarVqzpw5iouLU2BgYLlxvr6+6tWrl1PZpk2bZLPZNGzYMEfZJ598IrvdrqVLl6ply5aSpLCwMA0YMECZmZkaMWJEXVwWAAAAAKCZYs1yAADgkoyMDEVGRjoS5ZI0ePBg2Ww2ZWZmVquuLVu2KCgoSBEREY6yq1evytvbWy1atHCUtWnTpsb9BgAAAACgPMwsBwAALsnJydGoUaOcykwmkwICApSTk1Ples6ePau9e/fq6aefdiofOnSoVq5cqSVLlujJJ59UcXGxFi1apE6dOumBBx6oUd89PZkvUJuMRoPjsbr39vrY+mwXaGxq8loBAABA1ZAsBwAALrFYLDKZTGXK/fz8ZDabq1zPtm3bZLVanZZgkaSgoCCtWbNGkyZNUkpKiiSpc+fOeuutt2o0w9xg8FDbtj4ux6Msk6mV49HVe1taR323CzQ2rrxWgFKubMwtSRcuXNDixYuVkZGhixcvqkuXLho7dqzGjBnjOGf37t165513dPDgQZ07d06dO3fWyJEjFRsbKy8vr7q+NAAAagXJcgAA0KDS0tIUHh6u4OBgp/ITJ04oISFBUVFRGjFihK5cuaLVq1dr4sSJSk1NVYcOHVxqz2azy2K5VBtdx39ZLJcdjxcuFFYr1mg0yGRqJYvlsqxWW721CzQ2NXmtoG6YTK0a1Ux/VzfmlqRnn31WOTk5mjp1qjp16qSMjAy9/PLLMhqNeuSRRyRd28ukqKhIkydPVqdOnXTw4EElJycrOztbr732Wn1cIgAANUayHAAAuMRkMik/P79Mudlslp+fX5XqOH36tLKysjR9+vQyxxYvXqwOHTooKSnJUda3b1/dd999WrdunaZOnepy30tKSDTVptLEndVqc/neuhJbG+0CjQ3Pd7jK1Y258/LytG/fPr322msaOXKkJCkyMlKHDh3S1q1bHcnyl19+We3atXPE9evXTzabTUuWLNELL7zgdAwAAHfVeD4GBwAAbiUkJKTM2uT5+fnKy8tTSEhIlepIS0uTwWDQkCFDyhw7fvy4brnlFqcyHx8fde3aVadPn3a94wAANEOubsxdUlIiqewm276+vrLb7Y6fy0uG9+zZU3a7XXl5eTXsPQAA9YOZ5QAAwCXR0dFKSUlxWrs8PT1dBoNBUVFRVapj69at6tu3rzp27Fjm2I033qivvvpKdrtdHh4ekqSCggKdOnVK/fr1q70LAQCgGXB1Y+5OnTrprrvuUkpKioKDg3XDDTcoIyNDmZmZWrBgQaVt7t+/X97e3urSpUuN+s4mzrWLjbmBusfG3I0XyXIAAOCSmJgYrV+/XvHx8YqLi1Nubq6SkpIUExPj9FXu2NhYnTlzRtu3b3eK//LLL5Wdna3x48dXWH98fLyef/55DR8+XMXFxVq9erWKi4v18MMP1+m1AQDQ1NRkY+7k5GQlJiZq6NChkiSj0aiZM2dq0KBBFcacPHlS69atU0xMjHx8XN+EmY25ax8bcwP1h425Gx+S5QAAwCV+fn5au3at5s6dq/j4ePn4+Gj06NFKTEx0Os9ms8lqtZaJT0tLk7e3d4VvtAcMGKAlS5Zo1apVSkxMlJeXl2699VatW7dOQUFBdXFJAADgB+x2u6ZPn66TJ09q4cKFCggI0O7du/Xqq6/Kz8/PkUC/XkFBgRISEtSlS5cyfxdUFxtz1z425gbqHhtzu5+qbsxNshwAALisW7duWrNmTaXnrF+/vtzyadOmadq0aZXGDh48WIMHD3a1ewAA4L9c3Zh7586dSk9P1+bNmxUWFibp2uad586d0/z588sky4uLixUfHy+z2ayNGzeqdevWNe47m9rWLjbmBuoPz/fGh4VzAAAAAABo4lzdmPv48eMyGo0KDQ11Ku/Zs6e+//57Xb582VFms9n0/PPP6/Dhw3rzzTfVqVOn2r0IAADqGMlyAAAAAACauOjoaO3evVsWi8VRVpWNuTt37iyr1aojR444lR8+fFjt27dXq1b/tx7vnDlz9Omnn2r58uWOWegAADQmLMMCAAAAAEAT5+rG3NHR0brxxhs1efJkxcfHq2PHjtq1a5fee+89JSQkOOJSUlKUmpqqCRMmyNvbW1988YXjWPfu3eXr61tv1woAgKtIlgMAAAAA0MS5ujG3r6+v1qxZo8WLF2vBggXKz89Xly5d9OKLL2rcuHGO8zIzMyVJq1at0qpVq5zqXLdunfr161eHVwcAQO0gWQ4AAAAAQDPg6sbcN998s5YsWVLtOAAAGhvWLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7JEsBwAAAAAAAAA0eyTLAQAAAAAAAADNHslyAAAAAAAAAECzR7IcAAAAAAAAANDskSwHAAAAAAAAADR7JMsBAAAAAAAAAM0eyXIAAAAAAAAAQLNHshwAAAAAAAAA0Oy5XbI8Oztb48ePV69evRQVFaWkpCQVFxf/aNyFCxc0a9Ys3XvvverVq5eGDRumDRs2OJ2ze/duJSYm6v7779dPfvITDRkyRCtXrtTVq1fr6nIAAAAAAAAAAI2AZ0N34Hpms1mxsbEKCgpScnKycnNzNX/+fBUVFWnWrFmVxj777LPKycnR1KlT1alTJ2VkZOjll1+W0WjUI488IklKTU1VUVGRJk+erE6dOungwYNKTk5Wdna2Xnvttfq4RAAAAAAAgAYV4NtS3oXfy3r2ZPUCjQZdKWqlkvzLslpt1Qr1LvxeAb4tq9ceANQzt0qWp6amqrCwUMuWLZO/v78kyWq1as6cOYqLi1NgYGC5cXl5edq3b59ee+01jRw5UpIUGRmpQ4cOaevWrY5k+csvv6x27do54vr16yebzaYlS5bohRdecDoGAAAAAADQFI3pG6zOh/6iS4eqH5vvYpud/9suALgzt0qWZ2RkKDIy0pEol6TBgwdr9uzZyszMdCTCf6ikpESS1KZNG6dyX19fXbp0yfFzecnwnj17ym63Ky8vj2Q5AAAAAABo8jb87wmNfnauevQIrVac0WiQqU0rWVyYWX7s2FFtmD9OD1UrCgDql1sly3NycjRq1CinMpPJpICAAOXk5FQY16lTJ911111KSUlRcHCwbrjhBmVkZCgzM1MLFiyotM39+/fL29tbXbp0qVHfPT3dbvn3Rs1oNDgeq3tvr4+tz3aBxqYmrxUAAAAAjVdeQZGKfTrK2CGoWnGenga1aOsjz5aFUkn1kuXFZy4qr6CoWjEAUN/cKllusVhkMpnKlPv5+clsNlcam5ycrMTERA0dOlSSZDQaNXPmTA0aNKjCmJMnT2rdunWKiYmRj4+Py/02GDzUtq3r8SjLZGrleHT13pbWUd/tAo2NK68VAAAAAACApsatkuWustvtmj59uk6ePKmFCxcqICBAu3fv1quvvio/Pz9HAv16BQUFSkhIUJcuXZSYmFij9m02uyyWSz9+IqrMYrnseLxwobBasUajQSZTK1ks1f9aWE3aBRqbmrxWUDdMplbM9AcAAAAAoIG4VbLcZDIpP7/sVhFms1l+fn4Vxu3cuVPp6enavHmzwsLCJF3bvPPcuXOaP39+mWR5cXGx4uPjZTabtXHjRrVu3brGfS+p5tePULnSxJ3VanP53roSWxvtAo0Nz3cAAAAAAADJraavhYSElFmbPD8/X3l5eQoJCakw7vjx4zIajQoNdd6YomfPnvr+++91+fJlR5nNZtPzzz+vw4cP680331SnTp1q9yIAAGhGsrOzNX78ePXq1UtRUVFKSkpScXFxpTH79u1TWFhYuf89+OCDZc7fuXOnYmJi1KtXL91xxx16/PHH9Z///KeuLgkAAAAA0Ey51czy6OhopaSkOK1dnp6eLoPBoKioqArjOnfuLKvVqiNHjuiWW25xlB8+fFjt27dXq1b/tx7vnDlz9Omnn2rVqlWOWegAAKD6zGazYmNjFRQUpOTkZOXm5mr+/PkqKirSrFmzKowLDw/Xxo0bncoKCgo0ceJERUdHO5V/8MEHeumll/SrX/1KU6ZMUWFhoT7//HNduXKlTq4JAAAAANB8uVWyPCYmRuvXr1d8fLzi4uKUm5urpKQkxcTEKDAw0HFebGyszpw5o+3bt0u6lmS/8cYbNXnyZMXHx6tjx47atWuX3nvvPSUkJDjiUlJSlJqaqgkTJsjb21tffPGF41j37t3l6+tbb9cKAEBjl5qaqsLCQi1btkz+/v6SJKvVqjlz5iguLs5p7L6er6+vevXq5VS2adMm2Ww2DRs2zFF28eJF/e53v9OMGTP02GOPOcofeOCBWr8WAAAAAADcahkWPz8/rV27VkajUfHx8Vq4cKFGjx6tF1980ek8m80mq9Xq+NnX11dr1qzRrbfeqgULFujpp5/WZ599phdffFFxcXGO8zIzMyVJq1at0qOPPur03+HDh+vnIgEAaCIyMjIUGRnpSJRL0uDBg2Wz2RxjblVt2bJFQUFBioiIcJR9+OGHstlsGj16dG11GQAAAACACrnVzHJJ6tatm9asWVPpOevXry9TdvPNN2vJkiXVjgMAAK7JycnRqFGjnMpMJpMCAgLK7EFSmbNnz2rv3r16+umnncoPHjyo4OBgvf/++3rjjTeUm5urHj16aOrUqbrnnntq1HdPT7eaL9DoGY0Gx2N17+31sfXZLtDY1OS1AgAAgKpxu2Q5AABoHK7fY+R6fn5+MpvNVa5n27ZtslqtTkuwSFJeXp5OnDihpUuX6oUXXlBAQIDefvttTZo0Se+//7569OjhUr8NBg+1bevjUizKZzK1cjy6em9L66jvdoHGxpXXCgAAAKqGZDkAAGhQaWlpCg8PV3BwsFO53W7XpUuXtGDBAsc65X379tWgQYP05ptvKikpyaX2bDa7LJZLNe43/o/FctnxeOFCYbVijUaDTKZWslguy2q11Vu7QGNTk9cK6obJ1IqZ/gAANDEkywEAgEtMJpPy8/PLlJvNZvn5+VWpjtOnTysrK0vTp08vt35J6t+/v6PMy8tLd9xxh44dO+Zir68pKSHRVJtKE3dWq83le+tKbG20CzQ2PN8BAADqDslyuK0A35byLvxe1rMnqxdoNOhKUSuV5Fd/1o134fcK8G1ZvfYAoJkKCQkpszZ5fn6+8vLyFBISUqU60tLSZDAYNGTIkDLHunfvXmHclStXqtdZAAAAAAB+BMlyuK0xfYPV+dBfdOlQ9WPLznOsms7/bRcA8OOio6OVkpLitHZ5enq6DAaDoqKiqlTH1q1b1bdvX3Xs2LHMsfvuu0/Jycnas2ePBgwYIEkqLi7WP/7xD/3sZz+rvQsBAAAAAEAky+HGNvzvCY1+dq569AitVpzRaJCpTStZXJhZfuzYUW2YP04PVSsKAJqnmJgYrV+/XvHx8YqLi1Nubq6SkpIUExOjwMBAx3mxsbE6c+aMtm/f7hT/5ZdfKjs7W+PHjy+3/vDwcA0aNEi//e1vdfHiRQUEBOgvf/mLzp49qwkTJtTptQEAAAAAmh+S5XBbeQVFKvbpKGOHoGrFeXoa1KKtjzxbFkrVXM+x+MxF5RUUVSsGAJorPz8/rV27VnPnzlV8fLx8fHw0evRoJSYmOp1ns9lktVrLxKelpcnb21uDBg2qsI358+dr0aJFWrhwoQoKChQeHq633npLYWFhtX49AAAAAIDmjWQ5AABwWbdu3bRmzZpKz1m/fn255dOmTdO0adMqjW3durVmzpypmTNnutpFAAAAAACqxNDQHQAAAAAAAAAAoKGRLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7Hk2dAcAAADQ+AX4tpR34feynj1ZvUCjQVeKWqkk/7KsVlu1Qr0Lv1eAb8vqtQcAAAAAFSBZDgAAgBob0zdYnQ/9RZcOVT8238U2O/+3XQAAAACoDSTLAQAAUGMb/veERj87Vz16hFYrzmg0yNSmlSwuzCw/duyoNswfp4eqFQUAAADU3MmTJ2SxmMs9ZjQaZLUWyWhsWe7fuCaTn4KCmPThjkiWAwAAoMbyCopU7NNRxg5B1Yrz9DSoRVsfebYslEqqlywvPnNReQVF1YoBgOYsOztb8+bN04EDB+Tj46Phw4drypQp8vb2rjTuwoULWrx4sTIyMnTx4kV16dJFY8eO1ZgxY5zOy83N1bx587Rr1y55eXlp4MCBmj59unx9fevysgCg3p07d079+/eWzVa9v19LGY1G/etfx9W+ffta7hlqimQ5AAAAAABNnNlsVmxsrIKCgpScnKzc3FzNnz9fRUVFmjVrVqWxzz77rHJycjR16lR16tRJGRkZevnll2U0GvXII49Ikq5evapf//rXkqSFCxeqqKhIr7/+up577jmtWLGizq8PAOpT+/bttXfvgQpnlmdnH1Nc3AStWLFK3br1KHPcZPIjUe6mSJYDAAAAANDEpaamqrCwUMuWLZO/v78kyWq1as6cOYqLi1NgYGC5cXl5edq3b59ee+01jRw5UpIUGRmpQ4cOaevWrY5k+UcffaRjx45p27ZtCgkJkSSZTCZNmDBBWVlZioiIqPuLBIB6VNkyKkajQZIUGhqm8HD+/WtMDA3dAQAAAAAAULcyMjIUGRnpSJRL0uDBg2Wz2ZSZmVlhXElJiSSpTZs2TuW+vr6y2+1O9YeFhTkS5ZIUFRUlf39/ffbZZ7V0FQAA1C1mlgMAAAAA0MTl5ORo1KhRTmUmk0kBAQHKycmpMK5Tp0666667lJKSouDgYN1www3KyMhQZmamFixY4FT/9YlySfLw8FBwcHCl9VeFpyfz/GpT6YxXo9FQ7Xt7fWx9tgs0NgaDh+OR53vjQrIcAAAAAIAmzmKxyGQylSn38/OT2Vz+mrulkpOTlZiYqKFDh0q6tjHdzJkzNWjQIKf6fzj7vKr1V8Zg8FDbtj4ux6Msk6mV49HVe1taR323CzQWvr4tHY883xsXkuUAAAAAAKBcdrtd06dP18mTJ7Vw4UIFBARo9+7devXVV+Xn5+dIoNcVm80ui+VSnbbR3Fgslx2PFy4UVivWaDTIZGoli+WyrFZbvbULNDYFBUWOR57v7sFkalWlb8WQLAcAAAAAoIkzmUzKz88vU242m+Xn51dh3M6dO5Wenq7NmzcrLCxMktSvXz+dO3dO8+fPdyTLTSaTCgoKyq2/U6dONep7SUn1krKoXGmS22q1uXxvXYmtjXaBxsJmszseeb43LiyaAwAAAABAExcSElJm7fD8/Hzl5eWVWWv8esePH5fRaFRoaKhTec+ePfX999/r8uXLFdZvt9t14sSJSusHAMCdkCwHAAAAAKCJi46O1u7du2WxWBxl6enpMhgMioqKqjCuc+fOslqtOnLkiFP54cOH1b59e7Vq1cpR/9dff62TJ086ztmzZ48uXryoe+65p3YvBgCAOkKyHAAAAACAJi4mJkY+Pj6Kj4/Xrl279O677yopKUkxMTEKDAx0nBcbG6uBAwc6fo6OjtaNN96oyZMn64MPPtCePXv0+9//Xu+9957GjRvnOG/QoEHq0aOHEhIS9Omnn2rbtm2aMWOG7r33XkVERNTrtQIA4CrWLAcAAAAAoInz8/PT2rVrNXfuXMXHx8vHx0ejR49WYmKi03k2m01Wq9Xxs6+vr9asWaPFixdrwYIFys/PV5cuXfTiiy86Jcu9vLy0cuVKzZs3T1OnTpWnp6cGDhyoGTNm1Ns1AgBQUyTLAQAAAABoBrp166Y1a9ZUes769evLlN18881asmTJj9YfGBio5ORkF3sHAEDDYxkWAAAAAAAAAECzR7IcAAAAAAAAANDskSwHAAAAAAAAADR7JMsBAAAAAAAAAM0eyXIAAOCy7OxsjR8/Xr169VJUVJSSkpJUXFxcacy+ffsUFhZW7n8PPvhguTE2m00jR45UWFiY0tPT6+JSAAAAAADNnGdDdwAAADROZrNZsbGxCgoKUnJysnJzczV//nwVFRVp1qxZFcaFh4dr48aNTmUFBQWaOHGioqOjy41JTU1Vbm5urfYfAAAAAIDrkSwHAAAuSU1NVWFhoZYtWyZ/f39JktVq1Zw5cxQXF6fAwMBy43x9fdWrVy+nsk2bNslms2nYsGFlzj9//ryWLl2q3/zmN5oxY0ZtXwYAAAAAAJJYhgUAALgoIyNDkZGRjkS5JA0ePFg2m02ZmZnVqmvLli0KCgpSREREmWOLFi1Sv3791K9fv5p2GQAAAACACjGzHAAAuCQnJ0ejRo1yKjOZTAoICFBOTk6V6zl79qz27t2rp59+usyxrKwsbdmyRVu2bKlxf6/n6cl8gdpkNBocj9W9t9fH1me7QGNTk9cKAAAAqoZkOQAAcInFYpHJZCpT7ufnJ7PZXOV6tm3bJqvVWmYJFpvNpjlz5mj8+PHq0qWLvv322xr3WZIMBg+1betTK3XhGpOplePR1XtbWkd9tws0Nq68VgAAAFA1JMsBAECDSktLU3h4uIKDg53K33nnHZ09e1ZPPfVUrbZns9llsVyq1TqbO4vlsuPxwoXCasUajQaZTK1ksVyW1Wqrt3aBxqYmrxXUDZOpFTP9AQBoYkiWAwAAl5hMJuXn55cpN5vN8vPzq1Idp0+fVlZWlqZPn+5UXlhYqEWLFikxMVFXr17V1atXVVBQIEkqKipSQUGBfH19Xe57SQmJptpUmrizWm0u31tXYmujXaCx4fkOAABQd0iWAwAAl4SEhJRZmzw/P195eXkKCQmpUh1paWkyGAwaMmSIU/mFCxd08eJFzZ49W7Nnz3Y6Nm3aNHXo0KHam4gCAAAAAFAZkuUAAMAl0dHRSklJcVq7PD09XQaDQVFRUVWqY+vWrerbt686duzoVB4QEKB169Y5lZ09e1ZTp05VQkKC7rzzztq5CAAAAAAA/otkOQAAcElMTIzWr1+v+Ph4xcXFKTc3V0lJSYqJiVFgYKDjvNjYWJ05c0bbt293iv/yyy+VnZ2t8ePHl6m7RYsW6tevn1NZ6Qaf3bt3V58+fergigAAAAAAzRm7kQAAAJf4+flp7dq1MhqNio+P18KFCzV69Gi9+OKLTufZbDZZrdYy8WlpafL29tagQYPqq8sAAAAAAFSImeUAAMBl3bp105o1ayo9Z/369eWWT5s2TdOmTatyW126dNGRI0eq0z0AAAAAAKqMmeUAAAAAAAAAgGaPZDkAAAAAAAAAoNkjWQ4AAAAAAAAAaPZIlgMAAAAAAAAAmj02+AQAAAAAN3Dy5AlZLOZyjxmNBlmtRTIaW8pqtZU5bjL5KSgouK67CAAA0KS5XbI8Oztb8+bN04EDB+Tj46Phw4drypQp8vb2rjTuwoULWrx4sTIyMnTx4kV16dJFY8eO1ZgxY5zOy83N1bx587Rr1y55eXlp4MCBmj59unx9fevysgAAAAA0czk5x1VQUFDuMbP5oh5+eIRstrKJ8KowGIx655335OfnX+5xX19fhYR0d6luAACA5sKtkuVms1mxsbEKCgpScnKycnNzNX/+fBUVFWnWrFmVxj777LPKycnR1KlT1alTJ2VkZOjll1+W0WjUI488Ikm6evWqfv3rX0uSFi5cqKKiIr3++ut67rnntGLFijq/PgAAAADNU07OcfXv36fO6rfZrBo16qFKz9m7dz8JcwAAgEq4VbI8NTVVhYWFWrZsmfz9/SVJVqtVc+bMUVxcnAIDA8uNy8vL0759+/Taa69p5MiRkqTIyEgdOnRIW7dudSTLP/roIx07dkzbtm1TSEiIJMlkMmnChAnKyspSRERE3V8kAAAAgGandEb58uVvKjQ0rNrxP7YMS2WOHj2iSZMmVjirHQAAANe4VbI8IyNDkZGRjkS5JA0ePFizZ89WZmamIxH+QyUlJZKkNm3aOJX7+vrq0qVLTvWHhYU5EuWSFBUVJX9/f3322WckywEAAADUqdDQMEVE9Kp2nKenQW3b+ujChUKVlLi2VAsAAAAq51bJ8pycHI0aNcqpzGQyKSAgQDk5ORXGderUSXfddZdSUlIUHBysG264QRkZGcrMzNSCBQuc6r8+US5JHh4eCg4OrrT+qvD0NNQoHs6MRoPjsbr39vrY+mwXaGxq8loBAAAAAABoatwqWW6xWGQymcqU+/n5yWwuf1f4UsnJyUpMTNTQoUMlSUajUTNnztSgQYOc6v/h7POq1l8Zg8FDbdv6uByPskymVo5HV+9taR313S7Q2LjyWgEAAAAAAGhq3CpZ7iq73a7p06fr5MmTWrhwoQICArR79269+uqr8vPzcyTQ64rNZpfFcunHT0SVWSyXHY8XLhRWK9ZoNMhkaiWL5XK113OsSbtAY1OT1wrqhsnUipn+AAAAAAA0ELdKlptMJuXn55cpN5vN8vPzqzBu586dSk9P1+bNmxUWdm2znH79+uncuXOaP3++I1luMpnK3dTGbDarU6dONeo76wbWrtLEndVqc/neuhJbG+0CjQ3PdwAAAAAAAMmtpq+FhISUWTs8Pz9feXl5ZdYav97x48dlNBoVGhrqVN6zZ099//33unz5coX12+12nThxotL6AQAAAAAAAABNm1sly6Ojo7V7925ZLBZHWXp6ugwGg6KioiqM69y5s6xWq44cOeJUfvjwYbVv316tWrVy1P/111/r5MmTjnP27Nmjixcv6p577qndiwEAAAAAAAAANBpulSyPiYmRj4+P4uPjtWvXLr377rtKSkpSTEyMAgMDHefFxsZq4MCBjp+jo6N14403avLkyfrggw+0Z88e/f73v9d7772ncePGOc4bNGiQevTooYSEBH366afatm2bZsyYoXvvvVcRERH1eq0AAAAAAAAAAPfhVmuW+/n5ae3atZo7d67i4+Pl4+Oj0aNHKzEx0ek8m80mq9Xq+NnX11dr1qzR4sWLtWDBAuXn56tLly568cUXnZLlXl5eWrlypebNm6epU6fK09NTAwcO1IwZM+rtGgEAAAAAAAAA7setkuWS1K1bN61Zs6bSc9avX1+m7Oabb9aSJUt+tP7AwEAlJye72DsAAAAAAAAAQFPkVsuwAAAAAAAAAADQEEiWAwAAAAAAAACaPZLlAAAAAAAAAIBmr8Zrln/xxRfat2+fzp07p8cee0xBQUG6fPmycnJyFBQUJB8fn9roJwAAqAWM2wAANB6M2wAA1C+Xk+XFxcWaOnWq/va3v8lut8vDw0P33XefgoKCZDAY9Ktf/UpPPvmknn766drsLwCgGk6ePCGLxVzuMaPRIKu1SEZjS1mttjLHTSY/BQUF13UXUU8YtwEAaDwYtwEAaBguJ8uXLl2qnTt36uWXX1a/fv304IMPOo61aNFCDz74oP72t78xeANAAzl37pz69+8tm61sIrwqjEaj/vWv42rfvn0t9wwNgXEbAIDGo67G7ezsbM2bN08HDhyQj4+Phg8frilTpsjb27vCmH379umJJ54o91hwcLDS09MdP3/++edaunSpvv76axkMBt1+++167rnn1LNnz2r1EwCAhuJysnzr1q2KiYnRo48+qgsXLpQ53q1bN6dBEwBQv9q3b6+9ew9UOLM8O/uY4uImaMWKVerWrUeZ4yaTH4nyJqSuxu26fNO9e/duvfPOOzp48KDOnTunzp07a+TIkYqNjZWXl1e1+woAQGNRF+O22WxWbGysgoKClJycrNzcXM2fP19FRUWaNWtWhXHh4eHauHGjU1lBQYEmTpyo6OhoR1lOTo4mTJig/v37a+HChSouLtaKFSv05JNPasuWLQoICKhWfwEAaAguJ8vPnTunsLCwCo8bjUYVFRW5Wj0AoBZUtoyK0Xhtj+fQ0DCFh0fUV5fQQOpi3K7rN92pqakqKirS5MmT1alTJx08eFDJycnKzs7Wa6+9Vq2+AgDQmNTFuJ2amqrCwkItW7ZM/v7+kiSr1ao5c+YoLi5OgYGB5cb5+vqqV69eTmWbNm2SzWbTsGHDHGWffPKJ7Ha7li5dqpYtW0qSwsLCNGDAAGVmZmrEiBHV6i8AAA3B5WR5p06dlJOTU+Hx/fv3q2vXrq5WDwAAalFdjNt1/ab75ZdfVrt27Rw/9+vXTzabTUuWLNELL7zgdAwAgKakLsbtjIwMRUZGOsZsSRo8eLBmz56tzMxMjRw5ssp1bdmyRUFBQYqI+L8JF1evXpW3t7datGjhKGvTpk21+ggAQENzOVk+bNgwvfXWW/r5z3+uoKAgSZKHh4ck6a9//as+/PBDPffcc7XSSQAAUDN1MW7X9Zvu8pLhPXv2lN1uV15eHslyAECTVRfjdk5OjkaNGuVUZjKZFBAQUGli/ofOnj2rvXv3llkvfejQoVq5cqWWLFmiJ598UsXFxVq0aJE6deqkBx54oFp9/SFPT0ON4uGs9BumRqOh2vf2+tj6bBdobAwGD8cjz/fGxeVk+f/7f/9PBw8e1Lhx4xQSEiIPDw+99tprMpvN+s9//qN77rlHTz75ZC12FQAAuKouxu26ftNdnv3798vb21tdunSpVl9/iD9YaxdvuoEfV9PnK6+V5qUuxm2LxSKTyVSm3M/PT2Zz+XvclGfbtm2yWq1O3waTpKCgIK1Zs0aTJk1SSkqKJKlz58566623ajTD3GDwUNu2Pi7HoyyTqZXj0dV7W1pHfbcLNBa+vi0djzzfGxeXk+Xe3t5auXKlNm/erI8++kg2m03FxcUKCwvTlClTNHz4cMcn3wAAoGHVxbhd12+6f+jkyZNat26dYmJi5OPj+h+cvOmufbzpBn5cbT1fea00D+78fjstLU3h4eEKDnbeG+fEiRNKSEhQVFSURowYoStXrmj16tWaOHGiUlNT1aFDB5fas9nsslgu1UbX8V8Wy2XH44ULhdWKNRoNMplayWK5LKvVVm/tAo1NQUGR45Hnu3swmVpVadKBS8nyoqIiLV68WP369dPw4cM1fPhwV6oBAAD1wN3H7YredF+voKBACQkJ6tKlixITE2vUHm+6ax9vuoEfV9PnK68V91PVN93VVVfjtslkUn5+fplys9ksPz+/KtVx+vRpZWVlafr06WWOLV68WB06dFBSUpKjrG/fvrrvvvu0bt06TZ061eW+l5RU7zmPypX+G2K12ly+t67E1ka7QGNhs9kdjzzfGxeXkuUtW7bUxo0b1b1799ruDwAAqGV1NW7X9ZvuUsXFxYqPj5fZbNbGjRvVunVrl/tcij9YaxdvuoEfV1vPV14rTV9djdshISFllknLz89XXl6eQkJCqlRHWlqaDAaDhgwZUubY8ePHy2zg7ePjo65du+r06dMu9xsAgPrk8sfg4eHhOnr0aG32BQAA1JG6GLfr+k23JNlsNj3//PM6fPiw3nzzTXXq1KnG/QYAwN3VxbgdHR2t3bt3y2KxOMrS09NlMBgUFRVVpTq2bt2qvn37qmPHjmWO3Xjjjfrqq69kt9sdZQUFBTp16pQ6d+5c8wsAAKAeuJwsnzFjhrZt26Z33nlHJSUltdknAABQy+pi3K7rN92SNGfOHH366adavny5wsLCaqXfAAC4u7oYt0v3/IiPj9euXbv07rvvKikpSTExMQoMDHScFxsbq4EDB5aJ//LLL5WdnV3hHiMxMTH68ssv9fzzzysjI0OffPKJnnrqKRUXF+vhhx+ulWsAAKCuubzB54svvigPDw/NmjVL8+bNU2BgoFq0aOF0joeHhzZv3lzjTgIAgJqpi3E7JiZG69evV3x8vOLi4pSbm1vhm+4zZ85o+/btTvGlb7rHjx9fbv0pKSlKTU3VhAkT5O3trS+++MJxrHv37vL19a1yXwEAaEzqYtz28/PT2rVrNXfuXMXHx8vHx0ejR48usxeIzWaT1WotE5+WliZvb28NGjSo3PoHDBigJUuWaNWqVUpMTJSXl5duvfVWrVu3TkFBQVXuJwAADcnlZLm/v7/8/f0r3YwLAAC4h7oYt+v6TXdmZqYkadWqVVq1apXTsXXr1qlfv361dCUAALiXunq/3a1bN61Zs6bSc9avX19u+bRp0zRt2rRKYwcPHqzBgwe72j0AABqcy8nyigZQAADgfupq3K7LN938rQEAaK4YAwEAaBgur1kOAAAAAAAAAEBT4fLMckmyWq3avHmzdu7cqTNnzki6tgP2fffdp1/84hcyGo210kkAAFBzjNsAADQejNsAANQ/l5Pl+fn5mjBhgg4dOiQfHx/ddNNNkqTdu3fr448/1oYNG7Rq1So23wIAwA0wbgMA0HgwbgMA0DBcTpYvXrxYhw8f1syZM/XII4/Iy8tLknT16lW98847euWVV7R48WL99re/rbXOAgAA1zBuAwDQeDBuAwDQMFxes3z79u0aM2aMxo4d6xi4JcnLy0uPPfaYxowZo48++qhWOgkAAGqGcRsAgMaDcRsAgIbhcrL84sWLCg4OrvB4cHCwzGazq9UDAIBaxLgNAEDjwbgNAEDDcDlZfvPNN2vHjh0VHt+xY4e6du3qavUAAKAWMW4DANB4MG4DANAwXE6WjxkzRpmZmZo4caJ27dqlb7/9Vt9++63+/ve/66mnntLu3bs1duzY2uwrAABwEeM2AACNB+M2AAANw+UNPseOHavz58/rT3/6k3bt2uVcqaen4uPj9dhjj9W4gwAAoOYYtwEAaDwYtwEAaBguJ8slKSEhQWPHjtWePXv03XffSZI6d+6syMhItWvXrlY6CAAAagfjNgAAjQfjNgAA9a9GyXJJateunYYOHVobfQEAAHWMcRsAgMaDcRsAgPrl8prlu3fv1qJFiyo8vnjxYu3Zs8fV6gEAQC1i3AYAoPFg3AYAoGG4nCxfvny5/v3vf1d4PDc3V2+88Yar1QMAgFrEuA0AQOPBuA0AQMNwOVl+9OhR/eQnP6nw+O23364jR464Wj0AAKhFjNsAADQejNsAADQMl5PlxcXFunr1aqXHi4qKXK0eAADUIsZtAAAaD8ZtAAAahsvJ8h49emj79u3lHrPb7fr444/VrVs3lzsGAABqD+M2AACNB+M2AAANw+Vk+bhx47R//35NnjxZR44cUUlJiUpKSvT111/r2Wef1RdffKHHH3+8NvsKAABcxLgNAEDjwbgNAEDD8HQ1cPjw4frmm2+0fPlybd++XQbDtby7zWaTh4eHnn76af3yl7+stY4CAADXMW4DANB4MG4DANAwXE6WS9Izzzyjhx56SNu3b9c333wjSeratasGDBigrl271koHAQAVy8k5roKCApdis7OPSZKOHj0iq9VW7XhfX1+FhHR3qW00DMZtAAAaD8ZtAADqX42S5dK1wXrChAnKzs5Wenq6Tp8+rZ07d2rkyJHy9fWtjT4CAMqRk3Nc/fv3qXE9cXETXI7du3c/CfNGhnEbAIDGg3EbdSkr62C1Y4xGg6zWIhmNLas94ebo0SPVbg8A6lu1kuV//vOftX79em3YsEHt2rVzlH/66aeaPHmySkpKZLfbJUnr16/Xxo0bnc4DANSe0hnly5e/qdDQsGrH1/QP3UmTJro8qx31g3EbAIDGg3Eb9aWkpESSNHVqQoO0zwc9ANxZtZLlO3bs0E033eQ0IJeUlOill16S0WjU7373O912223auXOnlixZopSUFM2YMaPWOw0A+D+hoWGKiOhV7ThPT4PatvXRhQuFKimp/jIscH+M2wAANB6M26gvffr8TOnpO+TpWf3FBrKzjykuboJWrFilbt16VDuepRwBuLtq/ct4/PhxPfLII05l+/bt0/nz5xUXF+fYYKRHjx76+uuv9dlnnzF4AwDQQBi3AQBoPBi3UZ/69PmZS3FG47XNZkNDwxQeHlGbXQIAt2CozskXL17UDTfc4FS2Z88eeXh4aODAgU7lffr00b///e+a9xAAALiEcRsAgMaDcRsAgIZXrWR5hw4ddPbsWaeyzz//XC1bttQtt9ziVO7t7S0vL6+a9xAAALiEcRsAgMaDcRsAgIZXrWT5bbfdpvfee8+xoduxY8d06NAh3X333WXWusrJySnzqTgAAKg/9TFuZ2dna/z48erVq5eioqKUlJSk4uLiSmP27dunsLCwcv978MEHnc7Nzc1VQkKCevfurb59++qll15iY1kAQJPE+20AABpetdYsj4+P1+jRozVo0CB1795dhw8floeHh5566qky527fvl39+/evtY4CAIDqqetx22w2KzY2VkFBQUpOTlZubq7mz5+voqIizZo1q8K48PBwbdy40amsoKBAEydOVHR0tKPs6tWr+vWvfy1JWrhwoYqKivT666/rueee04oVK6rVVwAA3B3vtwEAaHjVSpaHhYVp7dq1SklJ0TfffKOf/OQnmjBhgm677Tan8/bt26dWrVqVmR0GAADqT12P26mpqSosLNSyZcvk7+8vSbJarZozZ47i4uIUGBhYbpyvr6969erlVLZp0ybZbDYNGzbMUfbRRx/p2LFj2rZtm0JCQiRJJpNJEyZMUFZWliIi2FQKANB08H4bAICGV61kuXRtI5E//elPlZ7Tr18/paWludwpAABQO+py3M7IyFBkZKQjUS5JgwcP1uzZs5WZmamRI0dWua4tW7YoKCjIKQGekZGhsLAwR6JckqKiouTv76/PPvuMZDkAoMnh/TYAAA2r2slyAAAA6dp6qaNGjXIqM5lMCggIUE5OTpXrOXv2rPbu3aunn366TP3XJ8olycPDQ8HBwdWqvzyentXatgU/wmg0OB6re2+vj63PdoH6VtPnK68VAADqV07OcZf3S8rOPiZJOnr0iKxWW7XjfX19FRLS3aW2UTMkywEAgEssFotMJlOZcj8/P5nN5irXs23bNlmtVqclWErrb9OmTY3r/yGDwUNt2/q4HI+yTKZWjkdX721pHfXdLlBfauv5ymsFAIC6l5NzXP3796lxPXFxE1yO3bt3PwnzBkCyHAAANKi0tDSFh4crODi4Xtqz2eyyWC7VS1vNhcVy2fF44UJhtWKNRoNMplayWC5Xe9ZNTdoF6ltNn6+8VtyPydTKpZn+AAD3VzqjfPnyNxUaGlbteKPRIKu1SEZjy2qP20ePHtGkSRNdntWOmnG7ZHl2drbmzZunAwcOyMfHR8OHD9eUKVPk7e1dYcy+ffv0xBNPlHssODhY6enpjp8///xzLV26VF9//bUMBoNuv/12Pffcc+rZs2etXwsAAE2ZyWRSfn5+mXKz2Sw/P78q1XH69GllZWVp+vTp5dZf3h+IZrNZnTp1qn6Hr1NSUv2vQqJipW8ArFaby/fWldjaaBeoL7X1fOW1AgBA/QkNDVNERK9qx3l6GtS2rY8uXChk7G1k3CpZbjabFRsbq6CgICUnJys3N1fz589XUVGRZs2aVWFceHi4Nm7c6FRWUFCgiRMnKjo62lGWk5OjCRMmqH///lq4cKGKi4u1YsUKPfnkk9qyZYsCAgLq7NoAAGhqQkJCyqwdnp+fr7y8vDJrjVckLS1NBoNBQ4YMKbf+o0ePOpXZ7XadOHFCUVFRrnccAAAAAIByuFWyPDU1VYWFhVq2bJn8/f0lSVarVXPmzFFcXJwCAwPLjfP19VWvXr2cyjZt2iSbzea0/uknn3wiu92upUuXqmXLlpKksLAwDRgwQJmZmRoxYkRdXBYAAE1SdHS0UlJSnNYuT09Pl8FgqHIye+vWrerbt686duxYbv2bN2/WyZMnFRQUJEnas2ePLl68qHvuuafWrgMAAAAAAElyqwXWMjIyFBkZ6UiUS9LgwYNls9mUmZlZrbq2bNmioKAgRUREOMquXr0qb29vtWjRwlFW3sZhAADgx8XExMjHx0fx8fHatWuX3n33XSUlJSkmJsbpA+7Y2FgNHDiwTPyXX36p7OzsMht7lho0aJB69OihhIQEffrpp9q2bZtmzJihe++912l8BwAAAACgNrjVzPKcnByNGjXKqcxkMikgIKDM17wrc/bsWe3du1dPP/20U/nQoUO1cuVKLVmyRE8++aSKi4u1aNEiderUSQ888ECN+u7p6VafOzR6pRvlGI2Gat/b62Prs12gvtX0+cprBTXl5+entWvXau7cuYqPj5ePj49Gjx6txMREp/NsNpusVmuZ+LS0NHl7e2vQoEHl1u/l5aWVK1dq3rx5mjp1qjw9PTVw4EDNmDGjTq4HAAAAANC8uVWy/PqvcV/Pz89PZrO5yvVs27ZNVqu1zEy1oKAgrVmzRpMmTVJKSookqXPnznrrrbdqNMPcYPBQ27Y+LsejLJOplePR1XtbWkd9twvUl9p6vvJaQU1069ZNa9asqfSc9evXl1s+bdo0TZs2rdLYwMBAJScnu9o9AAAAAACqzK2S5bUlLS1N4eHhCg4Odio/ceKEEhISFBUVpREjRujKlStavXq1Jk6cqNTUVHXo0MGl9mw2uyyWS7XRdfyXxXLZ8XjhQmG1Yo1Gg0ymVrJYLstqrd6OwzVpF6hvNX2+8lpxPyZTK5dm+gMAAAAAgJpzq2S5yWRSfn5+mXKz2Sw/P78q1XH69GllZWVp+vTpZY4tXrxYHTp0UFJSkqOsb9++uu+++7Ru3TpNnTrV5b6XlFQv0YTKlSburFaby/fWldjaaBeoL7X1fOW1AgAAAAAA4GbJ8pCQkDJrk+fn5ysvL08hISFVqiMtLU0Gg0FDhgwpc+z48ePq1auXU5mPj4+6du2q06dPu9xvAAAAAADcXXZ2tubNm6cDBw7Ix8dHw4cP15QpU+Tt7V1hzL59+/TEE0+Ueyw4OFjp6elOZTt37lRKSoq+/vpreXl56ZZbbtHvf/973XDDDbV6LQAA1AW3SpZHR0crJSXFae3y9PR0GQwGRUVFVamOrVu3qm/fvurYsWOZYzfeeKO++uor2e12eXh4SJIKCgp06tQp9evXr/YuBAAAoBnKyjpY7Rij0SCrtUhGY8tqLwl19OiRarcHAM2V2WxWbGysgoKClJycrNzcXM2fP19FRUWaNWtWhXHh4eHauHGjU1lBQYEmTpyo6Ohop/IPPvhAL730kn71q19pypQpKiws1Oeff64rV67UyTUBAFDb3CpZHhMTo/Xr1ys+Pl5xcXHKzc1VUlKSYmJiFBgY6DgvNjZWZ86c0fbt253iv/zyS2VnZ2v8+PEV1h8fH6/nn39ew4cPV3FxsVavXq3i4mI9/PDDdXptAAAATVVJSYkkaerUhAZp39fXt0HaBYDGJDU1VYWFhVq2bJn8/f0lSVarVXPmzFFcXJzTe+7r+fr6lvmG9qZNm2Sz2TRs2DBH2cWLF/W73/1OM2bM0GOPPeYof+CBB2r9WgAAqCtulSz38/PT2rVrNXfuXMXHx8vHx0ejR49WYmKi03k2m01Wq7VMfFpamry9vTVo0KBy6x8wYICWLFmiVatWKTExUV5eXrr11lu1bt06BQUF1cUlAQAANHl9+vxM6ek75OlZ/T8ts7OPKS5uglasWKVu3XpUO97X11chId2rHQcAzU1GRoYiIyMdiXJJGjx4sGbPnq3MzEyNHDmyynVt2bJFQUFBioiIcJR9+OGHstlsGj16dG12GwCAeuVWyXJJ6tatm9asWVPpOevXry+3fNq0aZo2bVqlsYMHD9bgwYNd7R4AAADK0afPz1yKMxoNkqTQ0DCFh0f8yNkAAFfl5ORo1KhRTmUmk0kBAQFl9g6rzNmzZ7V37149/fTTTuUHDx5UcHCw3n//fb3xxhvKzc1Vjx49NHXqVN1zzz016runp6FG8ag9BoOH45HfC5qy0r9RjUaDS8/16+Pru23UjNslywEAAAAAQO26fm+w6/n5+clsNle5nm3btslqtTotwSJJeXl5OnHihJYuXaoXXnhBAQEBevvttzVp0iS9//776tGj+t8ekq4lZdu29XEpFrXP17el45HfC5oyk6mV47Emz/XSehqibbiGZDkAAAAAAKiStLQ0hYeHKzg42Kncbrfr0qVLWrBggWOd8r59+2rQoEF68803lZSU5FJ7NptdFsulGvcbtaOgoMjxeOFCYQP3Bqg7Fstlx6Mrz3Wj0SCTqZUslsvV3sS+pm2jfCZTqyrN9CdZDgAAAABAE2cymZSfn1+m3Gw2y8/Pr0p1nD59WllZWZo+fXq59UtS//79HWVeXl664447dOzYMRd7fU1JSfUSTag7Npvd8cjvBU1ZaYLbarXV6LnuSnxttQ3XsPANAAAAAABNXEhISJm1yfPz85WXl6eQkJAq1ZGWliaDwaAhQ4aUOda9e8WbLV+5cqV6nQUAoIGQLAcAAAAAoImLjo7W7t27ZbFYHGXp6ekyGAyKioqqUh1bt25V37591bFjxzLH7rvvPknSnj17HGXFxcX6xz/+ofDw8Br2HgCA+sEyLAAAAAAANHExMTFav3694uPjFRcXp9zcXCUlJSkmJkaBgYGO82JjY3XmzBlt377dKf7LL79Udna2xo8fX2794eHhGjRokH7729/q4sWLCggI0F/+8hedPXtWEyZMqNNrAwCgtpAsh1vLyjpY7Rij0SCrtUhGY8tqb6Jw9OiRarcHAAAAAO7Oz89Pa9eu1dy5cxUfHy8fHx+NHj1aiYmJTufZbDZZrdYy8WlpafL29tagQYMqbGP+/PlatGiRFi5cqIKCAoWHh+utt95SWFhYrV8PAAB1gWQ53FJJSYkkaerUhAZp39fXt0HaBQAAAIC60q1bN61Zs6bSc9avX19u+bRp0zRt2rRKY1u3bq2ZM2dq5syZrnYRAIAGRbIcbqlPn58pPX2HPD2r/xTNzj6muLgJWrFilbp161HteF9fX4WEVLw5DQAAAAAAAICmh2Q53FafPj9zKc5ovLZvbWhomMLDI2qzSwAAAAAAAACaKENDdwAAAAAAAAAAgIZGshwAAAAAAAAA0OyRLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7JEsBwAAAAAAAAA0eyTLAQAAAAAAAADNHslyAADgsuzsbI0fP169evVSVFSUkpKSVFxcXKXY3NxcTZs2Tf3791dERIQGDx6szZs3O51z9OhRxcXFqX///vrZz36msWPHau/evXVxKQAAAACAZs6zoTsAAAAaJ7PZrNjYWAUFBSk5OVm5ubmaP3++ioqKNGvWrEpjv//+ez366KMKDg7W3Llz5evrq2PHjjkl2s+fP68nn3xSN910k1555RV5eXlp/fr1mjhxov7nf/5HYWFhdX2JAAAAAIBmhGQ5AABwSWpqqgoLC7Vs2TL5+/tLkqxWq+bMmaO4uDgFBgZWGPv73/9eN9xwg1auXCmj0ShJioyMdDpnz549OnfunP7617+qS5cukqS+ffuqb9+++uSTT0iWAwAAAABqFcuwAAAAl2RkZCgyMtKRKJekwYMHy2azKTMzs8K4goICffjhh3rsscccifLyXL16VZLUpk0bR1mLFi3k5eUlu91e8wsAAAAAAOA6zCwHAAAuycnJ0ahRo5zKTCaTAgIClJOTU2Hc4cOHdfXqVXl6emrcuHE6cOCA/P39NWLECE2ZMkVeXl6SpPvuu08dOnTQ/PnzlZiYKE9PT61evVoeHh4aPnx4jfru6cl8AXdhMHg4Hvm9oCkzGg2OR1ee69fH13fbAAAAzQXJcgAA4BKLxSKTyVSm3M/PT2azucK4s2fPSpJmzpypRx55RM8884yysrL0hz/8QQaDQc8995yjnrfffltxcXG6++67JUn+/v568803ddNNN7ncb4PBQ23b+rgcj9rl69vS8cjvBU2ZydTK8ViT53ppPQ3RNgAAQFNHshwAANQrm80mSbrzzjv14osvSpL69++vwsJCrV69WvHx8WrZsqXOnTunZ555Rl27dtWMGTNkNBr117/+VU8//bTefvttdevWzcX27bJYLtXa9aBmCgqKHI8XLhQ2cG+AumOxXHY8uvJcNxoNMplayWK5LKvVVq9to3wmUyuXZvoDAAD3RbIcAAC4xGQyKT8/v0y52WyWn59fpXHStQT59SIjI5WSkqJTp04pLCxMK1eulNls1qZNm+Tt7e04Z+jQoVq+fLkWLlzoct9LSqqXaELdsdnsjkd+L2jKShPcVqutRs91V+Jrq20AAICmjo/BAQCAS0JCQsqsTZ6fn6+8vDyFhIRUGNe9e/dK671y5Yok6fjx4woJCXEkyiXJaDQqLCxMp0+frkHPAQAAAAAoi2Q5AABwSXR0tHbv3i2LxeIoS09Pl8FgUFRUVIVxnTt3VmhoqHbv3u1Uvnv3brVs2dKRTL/xxhuVnZ3tSJ5LktVq1ddff63OnTvX8tUAAAAAAJo7kuUAAMAlMTEx8vHxUXx8vHbt2qV3331XSUlJiomJUWBgoOO82NhYDRw40Ck2MTFRO3bs0CuvvKLMzEylpKRo9erVevLJJ9W6dWtJ0sMPP6wLFy5o0qRJ2rFjhz777DMlJCTo1KlTGjt2bL1eKwAAAACg6WPNcgAA4BI/Pz+tXbtWc+fOVXx8vHx8fDR69GglJiY6nWez2WS1Wp3K7r//fi1atEjLly/Xhg0b1LFjRyUkJOipp55ynHPbbbdp5cqVWr58uaZPny6bzabu3bvrT3/6k+644456uUYAAAAAQPNBshwAALisW7duWrNmTaXnrF+/vtzyIUOGaMiQIZXGRkZGKjIy0tXuAQAAAIBLAnxbyrvwe1nPnqx+sNGgK0WtVJJ/2bHRdlV5F36vAN+W1W8TtYJkOQAAAAAAAABcZ0zfYHU+9BddOuRafL6L7Xb+b9toGCTLAQAAAAAAAOA6G/73hEY/O1c9eoRWO9ZoNMjUppUsLswsP3bsqDbMH6eHqt0qagPJcgAAAAAAAAC4Tl5BkYp9OsrYIajasZ6eBrVo6yPPloVSSfWS5cVnLiqvoKjabaJ2GBq6AwAAAAAAAAAANDSS5QAAAAAAAACAZo9kOQAAAAAAAACg2SNZDgAAAAAAAABo9kiWAwAAAAAAAACaPc+G7gAAAACatpMnT8hiMZd7LDv7mCTp6NEjslpt5Z5jMvkpKCi4zvoHAAAAABLJcgAAANShc+fOqX//3rLZyk+El4qLm1DhMaPRqH/967jat29f290DAAAAAAeS5QAAAKgz7du31969ByqcWW40GmS1FslobFnpzHIS5QAAAADqGslyAAAA1KnKllDx9DSobVsfXbhQqJKSymefAwAAAEBdYoNPAAAAAAAAAECzR7IcAAAAAAAAANDssQwLAAAAAAAAJEknT56ocK+R7OxjkqSjR49UutdIZUuwAYA7I1kOAAAAAAAAnTt3Tv3795bNVvk+InFxEyo8ZjQa9a9/HWdzbgCNEslyAAAAAAAAqH379tq790CFM8uNRoOs1iIZjS0rnVlOohxAY0WyHAAAAAAAAJJU6RIqnp4GtW3rowsXClVSUvnscwBojNjgEwAAAACAZiA7O1vjx49Xr169FBUVpaSkJBUXF1cas2/fPoWFhZX734MPPlhujM1m08iRIxUWFqb09PS6uBQAAOoEM8sBAAAAAGjizGazYmNjFRQUpOTkZOXm5mr+/PkqKirSrFmzKowLDw/Xxo0bncoKCgo0ceJERUdHlxuTmpqq3NzcWu0/AAD1we2S5dnZ2Zo3b54OHDggHx8fDR8+XFOmTJG3t3eFMfv27dMTTzxR7rHg4OAyn2Tv3LlTKSkp+vrrr+Xl5aVbbrlFv//973XDDTfU6rUAAAAAQKkA35byLvxe1rMnqx9sNOhKUSuV5F+ucJ3gingXfq8A35bVbxNNSmpqqgoLC7Vs2TL5+/tLkqxWq+bMmaO4uDgFBgaWG+fr66tevXo5lW3atEk2m03Dhg0rc/758+e1dOlS/eY3v9GMGTNq+zIAAKhTbpUsr49Puj/44AO99NJL+tWvfqUpU6aosLBQn3/+ua5cuVIn1wQAAAAAkjSmb7A6H/qLLh1yLT7fxXY7/7dtNG8ZGRmKjIx0JMolafDgwZo9e7YyMzM1cuTIKte1ZcsWBQUFKSIiosyxRYsWqV+/furXr19tdBsAgHrlVsnyuv6k++LFi/rd736nGTNm6LHHHnOUP/DAA7V+LQAAAABwvQ3/e0Kjn52rHj1Cqx1rNBpkatNKFhdmlh87dlQb5o/TQ9VuFU1JTk6ORo0a5VRmMpkUEBCgnJycKtdz9uxZ7d27V08//XSZY1lZWdqyZYu2bNlS4/5ez9OT7dbchdFocHoEmqrrn+uu/BtUk9dKTdtGzbhVsryuP+n+8MMPZbPZNHr06NrsNgAAAAD8qLyCIhX7dJSxQ1C1Yz09DWrR1keeLQulkuoly4vPXFReQVG120TTYrFYZDKZypT7+fnJbDZXuZ5t27bJarWWWYLFZrNpzpw5Gj9+vLp06aJvv/22xn2WJIPBQ23b+tRKXag9JlOrhu4CUKdKn+MmU6sa/RvkymulttqGa9wqWV7Xn3QfPHhQwcHBev/99/XGG28oNzdXPXr00NSpU3XPPffUqO980uM+DAYPxyO/FzRlfNINd+DKXiOlcnNztWjRIn322We6dOmSOnfurKeffloPPeQ89/GLL77QkiVLdPDgQXl4eKh79+6aM2eOevbsWVeXBQAAKpCWlqbw8HAFBzsv7fPOO+/o7Nmzeuqpp2q1PZvNLovlUq3WCdcZjQaZTK1ksVT/Wy5AY2KxXHY8XrhQWO34mrxWato2ymcytapS/sOtkuV1/Ul3Xl6eTpw4oaVLl+qFF15QQECA3n77bU2aNEnvv/++evTo4VK/+aTbvfj+d/MiX9+W/F7QpPFJNxqaq3uNSNL333+vRx99VMHBwZo7d658fX117NgxFRcXO523Z88ePfXUUxo1apQmTpyokpISZWVl6fLly3V5aQAANDkmk0n5+WVXvjebzfLz86tSHadPn1ZWVpamT5/uVF5YWKhFixYpMTFRV69e1dWrV1VQUCBJKioqUkFBgXx9fV3ue0k1v02Bume12vi9oEkrTXDX9LnuSnxttQ3XuFWyvLZU9Em33W7XpUuXtGDBAsc65X379tWgQYP05ptvKikpyaX2+KTbvRT89yumBQVFfAKHJo1Pupueqn7S7S5c3WtEkn7/+9/rhhtu0MqVK2U0GiVJkZGRTueUlJTopZde0hNPPKEXXnjBUV7Tb4MBANAchYSElPnGdn5+vvLy8hQSElKlOtLS0mQwGDRkyBCn8gsXLujixYuaPXu2Zs+e7XRs2rRp6tChgzIzM2t2AQAA1AO3SpbX5SfdpfVLUv/+/R1lXl5euuOOO3Ts2DEXe30Nn/S4D5vN7njk94KmjE+60dBc3WukoKBAH374oV599VVHorw8u3fv1nfffacnnniitrsOAECzEx0drZSUFKdvdKenp8tgMCgqKqpKdWzdulV9+/ZVx44dncoDAgK0bt06p7KzZ89q6tSpSkhI0J133lk7FwEAQB1zq2R5XX7SLUndu3evMO7KlSvV6ywAAM2cq3uNHD58WFevXpWnp6fGjRunAwcOyN/fXyNGjNCUKVPk5eUl6dpeI/7+/jp06JCeeOIJffPNN7rpppv09NNPa8SIETXqO2vtu4+a7J8ANCbsNYKGFhMTo/Xr1ys+Pl5xcXHKzc1VUlKSYmJinL4NFhsbqzNnzmj79u1O8V9++aWys7M1fvz4MnW3aNFC/fr1cyor3eCze/fu6tOnTx1cEQAAtc+tkuV1+Um3JN13331KTk7Wnj17NGDAAElScXGx/vGPf+hnP/tZ7V0IAADNgKt7jZw9e1aSNHPmTD3yyCN65plnlJWVpT/84Q8yGAx67rnnJF3ba+Ty5cuaMWOGJk+erG7dumnLli2aNm2a2rdvr7vvvtulfrPXiHtyZf8EoDFhrxE0ND8/P61du1Zz585VfHy8fHx8NHr0aCUmJjqdZ7PZZLVay8SnpaXJ29tbgwYNqq8uAwBQ79wqWV6Xn3RLUnh4uAYNGqTf/va3unjxogICAvSXv/xFZ8+e1YQJE+r02gAAwDU227Wle+688069+OKLkq4tkVZYWKjVq1crPj5eLVu2lN1u15UrV/T8889r3Lhxkq6ta56Tk6OUlBSXk+XsNeJearJ/AtCYsNdI09PY9hqRpG7dumnNmjWVnrN+/fpyy6dNm6Zp06ZVua0uXbroyJEj1ekeAAANzq2S5fXxSff8+fO1aNEiLVy4UAUFBQoPD9dbb72lsLCwWr8eAACaMlf3GilvDxHpWiI8JSVFp06dUlhYWKXnvf322zXqO2vtux/2QEBTx14jAAAA7s+tkuVS3X/S3bp1a82cOVMzZ850tYsAAECu7zVS2R4i0v/tI9KjR48fPQcAAAAAgNrSuL4zBgAA3EZ0dLR2794ti8XiKKvKXiOdO3dWaGiodu/e7VS+e/dutWzZ0pFMv+uuu+Tl5VXueeHh4bV4JQAAAAAAuOHMcgAA0DjUZK+RxMRETZo0Sa+88oruvfdeHTp0SKtXr9aECRPUunVrSVKHDh30+OOPa+nSpfLw8FC3bt20detWffHFF1q5cmW9Xy8AAAAAoGkjWQ4AAFxSk71G7r//fi1atEjLly/Xhg0b1LFjRyUkJOipp55yOu+5555T69attWrVKp0/f17dunXTH//4R9111111fn0AAAAAgOaFZDkAAHBZTfYaGTJkiIYMGVJprKenpxISEpSQkOBqFwEAAAAAqBLWLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs8ea5WiUTp48IYvFXO6x7OxjkqSjR4/IarWVe47J5KegoOA66x9QXwJ8W8q78HtZz56sfrDRoCtFrVSSf7nC10pFvAu/V4Bvy+q3CQBAM5eVddClOKPRIKu1SEZjy2qP20ePHnGpTQAAgOaGZDkanXPnzql//96y2Sp/kxAXN6HCY0ajUf/613G1b9++trsH1KsxfYPV+dBfdOmQa/H5Lrbb+b9tAwCAqikpKZEkTZ3acBsW+/r6NljbAAAAjQHJcjQ67du31969ByqcWV6VWTcmkx+JcjQJG/73hEY/O1c9eoRWO9ZoNMjUppUsLswsP3bsqDbMH6eHqt0qAADNU58+P1N6+g55err2Fiw7+5ji4iZoxYpV6tatR7XjfX19FRLS3aW2AQAAmguS5WiUKltCxdPToLZtfXThQqFKSqqXAAQam7yCIhX7dJSxQ1C1Yz09DWrR1keeLQular5Wis9cVF5BUbXbBACgOevT52cuxxqN17abCg0NU3h4RG11CQAAANdhg08AAAAAAAAAQLNHshwAAAAAAAAA0OyRLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7JEsBwAAAAAAAAA0e54N3QEAAAAAAAAAcDdZWQddijMaDbJai2Q0tpTVaqtW7NGjR1xqE7WDZDkAAAAAAAAA/FdJSYkkaerUhAbrg6+vb4O13ZyRLAcAAAAAAACA/+rT52dKT98hT0/XUqfZ2ccUFzdBK1asUrduPaod7+vrq5CQ7i61jZohWQ4AAAAAAAAA1+nT52cuxxqN17aJDA0NU3h4RG11CfWADT4BAAAAAAAAAM0eyXIAAAAAAAAAQLNHshwAAAAAAAAA0OyRLAcAAAAAAAAANHskywEAAAAAAAAAzR7JcgAAAAAAAABAs0eyHAAAAAAAAADQ7JEsBwAALsvOztb48ePVq1cvRUVFKSkpScXFxVWKzc3N1bRp09S/f39FRERo8ODB2rx5c4XnT5o0SWFhYVq1alVtdR8AAAAAAAfPhu4AAABonMxms2JjYxUUFKTk5GTl5uZq/vz5Kioq0qxZsyqN/f777/Xoo48qODhYc+fOla+vr44dO1Zhov2zzz7TwYMH6+IyAAAAAACQRLIcAAC4KDU1VYWFhVq2bJn8/f0lSVarVXPmzFFcXJwCAwMrjP3973+vG264QStXrpTRaJQkRUZGlntucXGxXnnlFU2dOlUzZsyo9esAAAAAAEBiGRYAAOCijIwMRUZGOhLlkjR48GDZbDZlZmZWGFdQUKAPP/xQjz32mCNRXplVq1bJZDJp5MiRtdFtAAAAAADKxcxyAADgkpycHI0aNcqpzGQyKSAgQDk5ORXGHT58WFevXpWnp6fGjRunAwcOyN/fXyNGjNCUKVPk5eXlOPfMmTP605/+pLfeekseHh611ndPT+YLuAuj0eD0CKB8BoOH45F/wwAAAOoGyXIAAOASi8Uik8lUptzPz09ms7nCuLNnz0qSZs6cqUceeUTPPPOMsrKy9Ic//EEGg0HPPfec49zXXntNAwcOVK9evWqt3waDh9q29am1+lA7TKZWDd0FwK35+rZ0PPJvGAAAQN0gWQ4AAOqVzWaTJN1555168cUXJUn9+/dXYWGhVq9erfj4eLVs2VK7du3Srl27lJ6eXsvt22WxXKrVOuE6o9Egk6mVLJbLslptDd0dwG0VFBQ5Hi9cKGzg3kC69iEf34oBAKBpIVkOAABcYjKZlJ+fX6bcbDbLz8+v0jjpWoL8epGRkUpJSdGpU6cUFhamefPm6YknnlCrVq1ksVgc5125cqXCWe1VVVJCUtbdWK02fi9AJWw2u+OR1woAAEDd4GNwAADgkpCQkDJrk+fn5ysvL08hISEVxnXv3r3Seq9cuSJJOnHihFJSUnTHHXc4/pOkpUuX6o477nCcBwAAAABAbWBmOQAAcEl0dLRSUlKcZnmnp6fLYDAoKiqqwrjOnTsrNDRUu3fv1rhx4xzlu3fvVsuWLR3J9HXr1pWJfeKJJxQTE6MhQ4Y4bQQKAAAAAEBNkSwHgEYuK+tghcfOnDmjwsKyy2RIksFgkI9PCxUWXnGsIX09H582uvHGG8uNPXr0iGudRZMSExOj9evXKz4+XnFxccrNzVVSUpJiYmIUGBjoOC82NlZnzpzR9u3bHWWJiYmaNGmSXnnlFd177706dOiQVq9erQkTJqh169aSpH79+pXbbteuXSs8BgCN2cmTJ2SxlL9Bcnb2MUnXxuDy1vc3mfwUFBRcp/1D45edna158+bpwIED8vHx0fDhwzVlyhR5e3tXGLNv3z498cQT5R4LDg527C2ye/duvfPOOzp48KDOnTunzp07a+TIkYqNjeUDbgBNEuN200SyHAAaqZKSEknS1KkJDdYHX1/fBmsbDc/Pz09r167V3LlzFR8fLx8fH40ePVqJiYlO59lsNlmtVqey+++/X4sWLdLy5cu1YcMGdezYUQkJCXrqqafq8xIAwG2cO3dO/fv3LvcD7OvFxU0ot9xoNOpf/zqu9u3b10X30ASYzWbFxsYqKChIycnJys3N1fz581VUVKRZs2ZVGBceHq6NGzc6lRUUFGjixImKjo52lKWmpqqoqEiTJ09Wp06ddPDgQSUnJys7O1uvvfZanV0XADQExu2my8Nut9sbuhONndVq0/nz7EjvLjw9DWrb1kcXLhSy+RGavP37P5enZ8Wfe9bVzHLpWqI8JKTytadRPe3a+choZDuRusa47V4Yt4H/U9kMNaPRIKu1SEZjS2aouYnGNm6vWLFCKSkp+vTTT+Xv7y9J2rhxo+bMmaNPP/3U6VthP2bTpk2aPn263nnnHUVEREiSzp8/r3bt2jmdl5KSoiVLlmj37t1ljlUV47Z7YdwG/g/jduNS1XGbmeUA0Ij16fOzSo9HRPSq8Bh/6AIA4F4qe9PMuI2aysjIUGRkpCNRLkmDBw/W7NmzlZmZqZEjR1a5ri1btigoKMiRKJdUbjK8Z8+estvtysvLczlZDgDuinG7aSJZDgAAAABAE5eTk6NRo0Y5lZlMJgUEBCgnJ6fK9Zw9e1Z79+7V008//aPn7t+/X97e3urSpUu1+3s9T8/GM4O/qSudldmYvlUBNAReK40XyXIAAAAAAJo4i8Uik8lUptzPz09mc/nLCJRn27ZtslqtGjZsWKXnnTx5UuvWrVNMTIx8fHyq3d9SBoOH2rZ1PR51w2Rq1dBdABoFXiuND8lyAAAAAABQJWlpaQoPD1dwcMXLDxQUFCghIUFdunQps/F3ddlsdlksl2pUB2qP0WiQydRKFsvlctdhBnANrxX3YzK1Ys1yAAAAAABwbcmV/PyyG7+bzWb5+flVqY7Tp08rKytL06dPr/Cc4uJixcfHy2w2a+PGjWrdurXLfS7Fer/ux2q18XsBqoDXSuNDshwAAAAAgCYuJCSkzNrk+fn5ysvLU0hISJXqSEtLk8Fg0JAhQ8o9brPZ9Pzzz+vw4cN6++231alTpxr3GwCA+sQq8wAAAAAANHHR0dHavXu3LBaLoyw9PV0Gg0FRUVFVqmPr1q3q27evOnbsWO7xOXPm6NNPP9Xy5csVFhZWK/0GAKA+kSwHAAAAAKCJK91oMz4+Xrt27dK7776rpKQkxcTEKDAw0HFebGysBg4cWCb+yy+/VHZ2doUbe6akpCg1NVWPP/64vL299cUXXzj+KygoqLPrAgCgNrEMCwAAAAAATZyfn5/Wrl2ruXPnKj4+Xj4+Pho9enSZDThtNpusVmuZ+LS0NHl7e2vQoEHl1p+ZmSlJWrVqlVatWuV0bN26derXr18tXQkAAHXHw2632xu6E42d1WrT+fOFDd0N/Jenp0Ft2/rowoVCNlEAKsFrxf20a+dTpd25UTOM2+6Ff4uAquG14n4Yt+sH47Z74d8ioGp4rbifqo7bjOwAAAAAAAAAgGaPZDkAAAAAAAAAoNljGZZaYLfbZbNxG92J0WiQ1crXXIAfw2vFvRgMHvLw8GjobjR5jNvuh3+LgKrhteJeGLfrB+O2++HfIqBqeK24l6qO2yTLAQAAAAAAAADNHsuwAAAAAAAAAACaPZLlAAAAAAAAAIBmj2Q5AAAAAAAAAKDZI1kOAAAAAAAAAGj2SJYDAAAAAAAAAJo9kuUAAAAAAAAAgGaPZDkAAAAAAAAAoNkjWQ4AAAAAAAAAaPZIlgMAAAAAAAAAmj2S5QAAAAAAAACAZo9kOQAAAAAAAACg2SNZDgAAAAAAAABo9kiWAwAAAAAAAACaPZLlAAAAAAAAAIBmj2Q5UIesVmtDdwEAAFQR4zYAAI0H4zaAukCyHKhlVqtVly5dkiQZjUZJ0r///e+G7BIAAKgA4zYAAI0H4zaAukayHKhlf//73/X888/r7NmzkqRf//rX+s1vfqMrV640cM+Axs9ms1WpDACqinEbqDuM2wBqG+M2UHcYt6/xbOgOAE1Nu3btdOLECT366KPq2rWrTp06pSVLlqhFixYN3TWgUSspKZGnp6eKi4v11VdfycfHRzfeeKNat24tm80mg4HPfwFUH+M2UDcYtwHUBcZtoG4wbv8fD7vdbm/oTgBNTVZWlsaOHSsPj//P3p3HRVX2/x9/MwO4gAOaiHuAC5pLarmQd7ZppllampGaaGZmpLmVS2Wau7mmqaWWyl2puZSoWdnmLaaVmpZlKriViQsKDArIzPz+6Md8nQBjmZHBeT0fjx6T1znXda6DDm/4nDPX8dKcOXN07733FveUgBLNZrPJy8tLZrNZTz/9tI4ePSqj0aj69etr6tSpCgoKksVisX8UEwAKgtwGnIvcBuBK5DbgXOS2I8+5LAC42NUfTTlz5oyqVq2qoKAgTZo0SX/++WeOfQDkj8VikZeXlywWi1577TX5+vpq/Pjx6tmzp06fPq3u3bsrMTFRRqORh/wAyDdyG3ANchuAK5DbgGuQ2zlxZzngBFdfYUtKSlKFChWUmJio48ePa8KECbp06ZKWL1+u6tWr26/YZb8C+HcZGRnas2ePPvzwQ0VGRuqOO+6Q9PeahdOnT9fFixe1Zs0aBQcHe9QVbwCFQ24DrkVuA3AmchtwLXLbEXeWA0V09TeKiRMn6vnnn9fBgwcVHBys5s2b65VXXlHZsmUVFRWlv/76S15eXsrMzNRbb72l+Pj4Yp49UDJER0erb9++SkhIUL169eztd955p0aNGqXAwEB1795dZ86ckdFo5K4SAHkitwHXI7cBOAu5Dbgeue2IYjlQBDabzR7cgwcP1v/+9z+1a9dOpUuXliR5eXnp9ttv16uvvqqyZcuqZ8+eWr16tV599VUtWLCgOKcOlCjTp09X3bp1deTIEW3atEmZmZn2ba1bt9bo0aMVGBiou+++W0lJSR718BEA+UduA9cHuQ3AGcht4Pogtx2xDAvgBAsXLtTatWs1Y8YM3XLLLfL19VVGRoauXLkif39/SdK+ffv0xhtv6OjRo7rppps0ffp0hyt2AP6W15O2L168qO7du8tqterll1/WXXfd5bDf119/rU8//VRTpky54T8WBqBoyG3AechtAK5GbgPOQ27/O4rlgBMMHz5c6enpeuuttyRJhw8f1rx583T69Gk1aNBAffr00c0336zMzEwlJCSoUqVKqlChQjHPGnA/WVlZ8vb2VmZmpg4ePKgzZ86oQYMGKl26tMqXL6+kpCR169ZNPj4+GjlypO6+++5cg94T1lEDUHjkNuAc5DaA64HcBpyD3M4f7+KeAFCSWSwW+9OAU1JS9MEHHygpKUmLFy9WvXr1FBoaqlWrVqlMmTJ66aWX5Ovry9VtIA9Wq1Xe3t4ym8166qmndOrUKZ07d05lypTRgw8+qMcff1yNGjXSmjVr1K1bN02bNk0Gg0Ft2rTJEeA3cnADKDxyG3AechuAq5HbgPOQ2/nHneVAAeR19ey7777T5MmT7U/m7tKli/r16ydJGjVqlE6dOqUlS5bI19f3ek8ZcFu5PaE+MzNTPXv2lJ+fn/r27auwsDCtWbNGW7ZsUeXKlfXiiy+qYcOGSkpKUmRkpM6fP6/FixerWbNmxXQWANwZuQ04D7kNwNXIbcB5yO3C485yIJ+uDu7NmzcrKSlJRqNR9957ryIiIvT222/br3yHhIRIkpKSknTmzBnVqlXrhr/yBhRUZmamSpUq5RDihw4d0unTpzVx4kS1adNGXl5eGjp0qKpXr67Fixdr9erVql69uipUqKCVK1dq3LhxuvXWW4v5TAC4I3IbcC5yG4ArkduAc5HbhXdjP74UcJJ/PoX7jTfe0OLFi7VkyRI9/PDD2rhxo8qWLasaNWrYg/vw4cOaMWOGfvvtN/Xq1YvwBq5y4MABRUVF6fz58w5Xu0+fPq2zZ8+qXr168vLysj+F+7HHHtMDDzygjRs3KiMjQ5JUoUIFvfnmmzIajfaPZwKARG4DzkZuA3AlchtwLnK7aCiWA/mQ/c1lzpw52r9/v9544w2tXr1aX375pZo2bapXX31VR44cUfaqRlOmTNGrr76q3bt367333lOtWrWKc/qA2zl48KDuvvtu3XTTTQ7t9evXl8lk0vLlyyVJvr6+9gB/5JFHdOnSJR08eDDHePxwDOBq5DbgXOQ2AFcitwHnIreLhmVYgGu4+uMq6enpOnDggDp06KBbb71VPj4+OnHihPbt26d7771XjRo1su97zz33qFy5curcubNq1KhRnKcAuKWuXbtK+vt9NXbsWPXv31916tSRv7+/IiIi9PXXXyssLEzdunWTr6+vbDabjh49qooVK6pixYrFPHsA7orcBlyD3AbgCuQ24BrkdtFwZzmQB4vF4vBxFYPBoFOnTslqtcrHx0fHjh1Tt27d1LJlS02cOFGlSpXS0qVLde7cObVq1UoDBw4kuIFcXP1c6f/973+Ki4vTq6++qvj4eAUEBGjo0KEqU6aM3n33XU2bNk1//PGHvvrqK73zzjsKDQ1V/fr1i3H2ANwVuQ24BrkNwBXIbcA1yO2io1gO5OLqNdN69eqlCRMmyGKxqGLFijp+/LgOHz6s7t27KyIiQhMnTlSZMmV05MgRffbZZ4qLi5PkeR9TAfIj+4fi7ABv166dhg4dqkuXLmnUqFE6cuSIQkJCNHv2bNWrV0/r1q1T27ZtNX78ePn4+Ojdd9+VwWDwuDXTAFwbuQ24BrkNwBXIbcA1yG3n8LJdfckBgMNTuL/44gvNnTtXI0aM0N13362dO3fq2WefVXp6ujp16qTJkyfL19dXSUlJeuONN3Tw4EEtXLhQlStXLuazANxPVlaWvL29dfnyZa1Zs0Z16tRRq1atJElr1qzR8uXLVbp0aU2ZMkW1a9dWSkqKLl26pN9//12VKlVSeHi4DAaDfRwAkMhtwFXIbQCuQG4DrkFuO49nnz2Qi+zg/uSTT7Rr1y41bdpUd9xxhySpUaNGGjJkiN566y1ZLBbt379fiYmJ+uKLL7Rjxw7FxMQQ3EAuLBaLvL29ZTab1bNnT5lMJlksFjVr1ky+vr7q1q2bbDabVqxYodGjR2vq1KmqVauWTCaTw3vKarV6fHADcERuA85HbgNwFXIbcD5y27m4sxzIRVxcnPr166fAwEA9/vjjGjp0qH3bxYsXtWPHDk2fPl1eXl7y9vZWzZo1NXLkSNWtW7cYZw24t/T0dPXo0UOBgYF66aWXFBYWJl9fX1mtVhkMf68K9tFHHykmJkZly5bVhAkTVKdOnWKeNYCSgNwGnI/cBuAq5DbgfOS281AsB/KwcuVKTZo0SRUqVNCbb76pW2+91WG72WzWmTNn5OfnJ39/f/n5+RXTTIGSYePGjZozZ47mz5+vevXqSZIOHDig48eP68qVK+rcubOkvwN8zpw5uvfeezVhwoTinDKAEoTcBpyL3AbgSuQ24FzktvNwbz083tVrpl0tMjJSVqtVc+bM0fLlyzVgwACFh4fb+/j7+8vf3/96TxcoMWw2m8MT7s+fP6/09HT5+fnp5MmT2rx5sxYuXCh/f3+dO3dOP/zwgyZOnKjHHntMFStWVJs2bYpx9gDcFbkNuAa5DcAVyG3ANcht1+HOcni0q4P7s88+U2JiokqVKqXw8HA1adJEkrRs2TItWrRIrVu31jPPPGMPcAB5y35vWSwWXb58Wf7+/kpISFDXrl1Vvnx5lSpVSmfOnNHw4cPVvHlz7dq1S1OmTNG6desc3mN5/XANwDOR24BrkNsAXIHcBlyD3HYt7iyHx7LZbPZvCoMHD9aPP/4og8Ggc+fOqVq1arr//vs1cuRI9enTR5K0aNEiGY1G9enTR7fccksxzhxwb9lPz05LS9OkSZMUEBCgPn36KCwsTB9++KFWrVql0NBQNW/eXPXr15ck7du3T7Vq1VKFChUcxiK4AWQjtwHXILcBuAK5DbgGue16FMvhka5+wMHs2bO1f/9+zZkzR7fccosuXLighQsXauPGjcrMzNSrr76qPn36yNvbWxMnTpSvr6/Gjh0rX1/fYj4LwP1kPz3bbDare/fuuummm9S8eXMFBARIkurVq6fXXnvNvv+VK1d04sQJrV+/XjfffLMqVqxYXFMH4MbIbcA1yG0ArkBuA65Bbl8fFMvhMVJTUzVkyBDNnj1bJpPJ3n7gwAE1b95cTZs2lY+Pj/z9/TV06FCVLVtWX375pVq0aKH27durV69e8vHxUYsWLQhuIA8Gg0FXrlzRCy+8oEqVKmnChAmqUqWKvL29lZmZKUn298+FCxf04Ycfavv27bp8+bKWL18uLy8vhx+uAXguchtwPXIbgLOQ24DrkdvXB18deASz2ayuXbsqOTlZWVlZkv7+WNilS5eUkJCgMmXKyMfHRxaLRRaLRUFBQerXr58yMjL0008/2cd5/PHHFRoaWkxnAZQMSUlJ+uuvv/TQQw+pRo0a8vb21tdff63XXntN/fv31+effy5JOnjwoHbs2KEaNWroo48+kre3t7KysghuAOQ2cB2R2wCKitwGrh9y2/W4sxw3PLPZrM6dO6t69ep644037Gs0eXl5qWzZsrr33nsVGxurbt26qXHjxrJYLLLZbKpSpYrq1KmjY8eOFe8JACXMpUuXdOLECZ0/f15bt27Vd999p/fff1+33XabMjMzNWzYMH3wwQeKiIhQWFiYKlWqJC8vL1ksFnl7E0uApyO3geuL3AZQFOQ2cH2R267H5QTc0NLS0tS5c2eFhYVp2rRpqlSpkqxWq6S/13qyWCxq3769goKCNHv2bP36668yGo3y8vLS+fPnlZqaypVt4BosFkuOttDQUD377LOaNWuWxo8frx07dmj+/Pn673//qzlz5igwMFD79u2TJAUHB9s/CsbDRQCQ24BrkdsAnIncBlyL3C4eXFLADctqtWrmzJn6888/NXPmTFWuXFlXrlyRj4+P/Wrb448/rjvvvFNPPPGE3n//fQ0ePFhPP/20LBaL9uzZo5MnT2rGjBnFfSqAW8p+CndGRoa+//57JScnq3r16rr11lv1/PPPq1WrVipXrpzKlSunqlWrSpKSk5Pl7++vSpUqOYzFR8EAkNuAa5HbAJyJ3AZci9wuPl42m81W3JMAXMFqtSouLk5z585VUlKSli5dqtDQUKWnp6tr167y8fHRO++8Y/8m8vnnn2vjxo3aunWrgoKCVKVKFY0bN0716tUr5jMB3E/2Q0HMZrOeeOIJZWZm6o8//lDlypVVtWpVLVy4UP7+/vb9L1++rGPHjmn8+PEyGo1asWIFV7YBOCC3AdchtwE4G7kNuA65XbwoluOGZrPZtHv3bk2YMEFms1nvvPOOhg0bpjJlymjOnDmqXLmybDabvLy87H1OnTqlsmXLytvb2+GbDwBHmZmZ6tevn7y8vDRixAhVrFhRx48fV//+/dWwYUMtWbJE/v7+SktL07hx43TkyBGVKlVKMTEx9gf8EOAArkZuA65DbgNwNnIbcB1yu/hwHz5uaF5eXrrtttv06quvqly5cnrwwQclSYsXL1blypXt+1x9zahq1aoKDAwkuIF/cfjwYZ0+fVp9+/ZVw4YNVbVqVZ05c0aSdM8999jfQ76+vmrcuLHuvfdevf/++/Lx8VFWVhbBDSAHchtwHXIbgLOR24DrkNvFh2I5bnjZAT5q1Ci1aNFCSUlJunjxoiTZHz5y9ZVuALnLfrjI5cuXJUkpKSk6d+6cqlevLoPBoA0bNmjkyJEaPHiwBgwYoNTUVHtYP/nkkxo0aJCMRiNP4QZwTeQ24BzkNoDrgdwGnIPcdh8Uy+ERvLy81KJFCw0aNEgVKlRQVFSUTpw4IYPBIFYiAv6dzWaT0WiU2WxWjx499O2336patWqyWCw6fPiwvvvuO7300ksaMmSInnnmGdlsNv3vf//T//73Px09etRhLK5wA/g35DZQNOQ2gOuJ3AaKhtx2LxTL4TEMBoNuv/12+0fE+vTpo5MnT+b4WBgAR1lZWfLy8pLFYtGkSZMUEBCg4OBgValSRZ07d9Yrr7yivn376tVXX9Wzzz4rSTp69KhiYmJUvnx5hYSEFO8JACiRyG2gcMhtAMWB3AYKh9x2PxTLcUO4OnyvFcRXr6lWvnx5Pfzww/rjjz/4WBhwDd7e3rp8+bK+//57Xbp0SZGRkQoPD5ePj486d+6spk2bKiAgQL6+vkpMTNTnn3+uUaNGKSMjQxMmTOAHZAA5kNuA65DbAJyN3AZch9x2P142vqIo4fJ6wu8/n7r9z207d+7U/PnzNXnyZN18882uniZQok2aNEkxMTEymUxauHChbrvtNvu2H3/8URs2bND69etVtmxZVaxYUTVr1tSbb77JU7gB5EBuA65HbgNwFnIbcD1y271QLEeJZrVaZTD8/QGJd955R3/88YeqV6+u++67T7Vq1XLY/k82m00ZGRkqXbr09ZwyUCJkZWU5PBTk8uXLmjRpktasWaO+ffvqueeeU7ly5Rz2//PPP3X27FnddNNNuvnmm2UwGHKMA8CzkduAa5DbAFyB3AZcg9x2bxTLcUMYMWKEdu7cqfLlyys1NVXe3t6aNm2abrvttmsGOIC8Xbp0Sdu3b9f9998vSUpPT9fo0aP1zTffaPz48br//vvtP/zm9j7jvQcgL+Q24HzkNgBXIbcB5yO33RdfVZRIV1/jOXnypBITE/Xmm29q/fr1Gj9+vKpWraoBAwbo+++/l8FgkNVqLcbZAiWHxWKR9Pd7bP369Ro8eLA2bdokSSpdurSmTp2q1q1ba/z48fr888+Vnp4uSbmGNMENIBu5DbgGuQ3AFchtwDXI7ZKBryxKHIvFYl8b7cqVK/Ly8pLJZFKdOnXk7e2tu+66S4MHD1aDBg303HPP6YcffiDAgXzIXussLS1Nc+bM0W+//SZJeumll7R+/XpJUqlSpTRz5kxFRETo9ddf19atW3X58uXinDYAN0duA65BbgNwBXIbcA1yu+RgGRaUKFc/RGTixIk6dOiQEhMTVbZsWb377rsqX768fd8ff/xR8+bN0++//65Zs2bpjjvuKK5pAyXG5cuX1aVLF1WtWlVt2rSRJH322Wfat2+fXn/9dT322GOSpIyMDL344ov6/PPPtXTpUrVu3bo4pw3ATZHbgGuR2wCcidwGXIvcLhkolqPEuHo9pnHjxunzzz/XXXfdpaNHj+qnn35S79699eyzz6pChQr2Pj/++KMmT56sCxcu6NNPP1WpUqXyfGI34MmyfzBetmyZli9friVLlqhWrVqSpGPHjmnJkiVau3atJk+erEceeUTS32uqLViwQIMHD+ahIgByILcB1yG3ATgbuQ24DrldsvDVRomRHdxJSUkym82aMmWK2rRpIy8vL40ePVqbN29W6dKl1adPH3uA33777Xr11VcVHBzMU7iBa8j+oTYzM1OZmZkymUz2bSEhIXr66ad16NAhvfzyy/Lx8VGnTp1UunRpDRs2TFLOp3kDALkNuA65DcDZyG3AdcjtkoU1y1GiTJo0SQ8++KB+//13Va1a1f4NZ8qUKbrrrru0du1aLVu2TElJSfY+TZs2VdWqVYtrykCJYjKZlJGRob/++kuS7GsPhoSEqG3btrJarRoxYoS2bt0q6f8e/kNwA8gNuQ24FrkNwJnIbcC1yO2SgWI5SpS7775blSpV0tGjR3Xq1CnZbDb704QnTZqku+++W5988okWLFigCxcuFPNsAfeV/b75p8cee0xVqlTRpEmTZDabczxhu3v37nr00Uc1ZcoU/fXXX3zMEsA1kduAc5DbAK4HchtwDnK7ZKNYDreV29O0mzdvrldeeUXBwcGaP3++/vzzTxmNRvu+kyZNUtOmTbV9+3axHD+Qu6ysLBmNRl2+fFlr1qzRm2++qa+//loHDx6U0WjUa6+9pj/++ENPPfWU9u7dq9OnT+v333/XV199pWrVqqlNmzZKSkrS6dOni/tUALgRchtwDXIbgCuQ24BrkNslHw/4hFuyWCwyGo2SpDNnzujKlSsKCAiQv7+/JOn777/XiBEjVK1aNc2YMUPVqlVzeCDJmTNnVKlSpWKbP+Cust8nZrNZ3bt3V2Zmpmw2m1JTU1W3bl1169ZNXbp00Y8//qgJEybYf0D28fFRhQoVtGHDBu3cuVNDhw7VggUL1LRp0+I+JQBugNwGXIPcBuAK5DbgGuT2jYFiOdzO1SE8fvx4/fDDD/rrr79UoUIFPfPMM7rnnntUsWLFfw1wALnLysrS888/r/T0dI0ZM0Z169bViRMn9MILL+jEiRNau3atQkJClJWVpfXr1ys1NVX+/v7q1q2bDAaDnn/+eR0/flzLly+3P9wHgOcitwHXIrcBOBO5DbgWuV3yUSyH2xoxYoR2796t3r17y8fHR7t379ann36qnj17qn///qpcubK+//57jR49WmXKlNHixYtVpUqV4p424HZsNpvDWmfJycmKjIzUk08+qW7dusnX11dbt27VoEGD9NJLL6lv377KzMyUr6+vwzg//PCDYmJitHPnTq1YsUL16tW73qcCwI2R24BzkNsArgdyG3AOcvvGwyVBuKUDBw5oz549GjFihPr27atevXpp9uzZGjJkiN5//31t3LhRktSsWTNNmDBBUt4PUAA8VUZGhiwWiy5dumRvs1gsOnPmjI4ePapatWrJ19dXn3zyiZ5//nkNGTJEffv2VVpamj744AMdPXrU3i8xMVG//PKLLly4oP/+978ENwAH5DZQdOQ2gOuF3AaKjty+cXkX9wTg2S5fvqy3335bnTp1Uu3ate3tSUlJOnXqlL3typUr8vHx0bPPPqvExES9/fbbeuihhxQcHKyIiAitWbNGpUuXLq7TANzOwYMHtXz5ch0/flzly5dX9+7dddddd8loNCokJES33HKLYmNjdfLkSb3yyisaMmSIBgwYIEnavn27duzYodtvv90+XnBwsLp27apu3bqpXLlyxXVaAIoZuQ24BrkNwBXIbcA1yO0bG3eWo1ht2rRJ7777rpYuXepwVS0wMFABAQH6/vvvZbFY5OPjo8zMTElSly5dlJGRoV9++UWS5OXlRXADV/nxxx/Vu3dvJSQkyGAw6Pvvv9ezzz6rzZs3S5K8vb31n//8R19++aVeffVVRUdH69lnn5XFYtGxY8e0fPlylS1bVrfccovDuCaTieAGPBy5DTgfuQ3AVchtwPnI7Rsfd5ajWHXr1k1JSUlauXKlLBaLnn32WYWFhalWrVqqVq2aVq9erVtvvVW33HKLfT2nS5cuyd/fX4GBgcU7ecAN7d692/5Ryr59+6pSpUratm2b3njjDS1evFitWrVShQoVNGjQIJ08eVI7d+7UqVOntG/fPv3888+KjY1Venq6ZsyYIYPBwEN8ADggtwHnIrcBuBK5DTgXue0Z+BtBscm+cv3MM88oMjJS+/bt09tvv634+HiVLVtWs2fPVlJSksaPH6/PP/9cV65c0dGjR7VhwwaZTCbVrFmzmM8AcC8nTpxQz549dc8992jIkCGqVKmSJKlNmzZ65JFHdPToUWVlZUmSfHx8NG3aNHXt2lXx8fHq2bOn1q1bp5o1a2rt2rXy9vZWVlYWwQ3AjtwGnIvcBuBK5DbgXOS25/Cy2Wy24p4EPI/FYpHRaJQkvfPOO0pLS9Py5cuVlZWljh072q94Hz58WNHR0UpKSpLFYlGlSpWUmpqqpUuXqn79+sV8FoB7iY+P1+jRo3Xu3DnNnj1bt956q/0p2999952mTp2qhx56SFWrVlX16tXVuHFje9+EhARVrlxZZcqUkZeXl7KysuTtzYePAPyN3Aacj9wG4CrkNuB85LbnoFiOYjV8+HDt3btXTz31lMqWLavvv/9en376qdq3b28P8JSUFG3fvl3Hjx9X5cqV1bx5c1WvXr24pw64paNHj2r06NH666+/NHPmTPtDQ5566int2LFDRqPR/sPzXXfdpRYtWui+++5TlSpV7GFts9nk5eVVnKcBwE2R24BzkdsAXIncBpyL3PYMFMtRbH7//Xf17t1bI0eO1KOPPmpvnz9/vpYvX6577rnHHuAA8i8hIUFjxoxRYmKiFi5cqDlz5ujQoUN65ZVX1LBhQx08eFC//PKL1q1bpz/++EPt27fX3Llzi3vaANwcuQ24BrkNwBXIbcA1yO0bH8VyFJvdu3erZ8+eWrNmjRo2bKiMjAyVKlVKkvT666/rgw8+0COPPKKnnnpKderUKebZAiVLdoD/9NNPuummm/Tuu+8qPDzcYZ/k5GQdP35cDRo0sH9MEwDyQm4DrkNuA3A2chtwHXL7xsZK8rjusq/P1KtXTxUrVtTHH38sSSpVqpQyMjIkSb169VK5cuX01Vdf6b///a+uXLlSXNMFSqSwsDBNmjRJd999tywWi/29lc1qtSogIECNGze2f1QMAHJDbgOuR24DcBZyG3A9cvvGRrEcLvfPbwpXr8107733aufOnVq7dq0k2a90JyYm6tZbb1Xv3r311FNPycfH5/pNGLhB1KpVSy+99JJCQkI0ePBg/fTTT/Zt/3zqNle6AWQjt4HiQW4DKAxyGyge5PaNi2VY4FJWq9X+TWLp0qU6deqUKlasqAcffFA1a9bUiRMnNGzYMGVmZqpt27YaOHCg4uPjFRMTo/Pnz2vevHkEN5CLq99b/yYhIUEvv/yyEhMTNW3aNDVv3tzFswNQUpHbgGuQ2wBcgdwGXIPc9mwUy+EyVz/h94UXXtDu3bvl7++vy5cvy8vLS/Pnz1fDhg119OhRzZs3T9u3b1dKSooCAwNls9m0bNky1a9fv5jPAnA/WVlZ8vb2VkZGhn755RfVqFFDlSpVumafo0eP6tlnn1Xt2rX11ltvXaeZAihJyG3ANchtAK5AbgOuQW6DYjlc4uqrcLt379acOXM0ZMgQ1a9fX7t379bbb7+tAwcOaMWKFWrUqJGSkpKUlJSk7777TgEBAWratKlq1KhRzGcBuB+LxSKj0Siz2aynn35apUqV0pNPPqn77rvP4SOXufnrr79UqVIlPgIGIAdyG3ANchuAK5DbgGuQ25AolsPFZs6cqUuXLun06dOaPXu2fH19JUk//fSTZsyYoQMHDigmJkYNGzYs5pkCJcfly5fVvXt3BQUFqX///rrtttvs7638yP4BAAD+idwGnI/cBuAq5DbgfOQ2eMAnXOrTTz/V+++/rwsXLjh8c2nSpIlGjBihhg0bqm/fvtq/f38xzhIoWT755BNlZGRo2LBhatWqlXx9fVWQ654EN4C8kNuA85HbAFyF3Aacj9wGxXK4RFZWliRp69atioiI0J49e7R69WplZGTY92nSpIlefPFFVa1aVc8//7wyMzML9A0IuNH9+uuv2rVrV47233//XQaDQQ0bNpSXl5d9vcLs94/FYrneUwVQwpHbQNGR2wCuF3IbKDpyG3mhWA6n+Oc3C29vb/v/v/fee2rcuLFmz56tzz77TJmZmfZtjRs31sSJE/Xhhx/K19f3X9eAAjyBzWZTRkaG+vXrp3379jlss1qt8vPzk8ViUWJioiQ5BPjly5e1detWnT17tjimDqCEILcB5yG3AbgauQ04D7mNf0OxHEV29XpMGzZs0DvvvKO5c+fqzJkz9n1Wr16t6tWra8qUKdqyZYtDgDdq1EjVqlW77vMG3JWXl5dKlSqlTZs26ZlnnlFGRoZ+/vlnSZLBYFCDBg108uRJffnll/a7SrIDfPfu3frwww/1119/FecpAHBj5DbgXOQ2AFcitwHnIrfxb3jAJ4rk6qdwDx06VL/99pvKli0ro9GoU6dOacaMGbr99tvl4+MjSXrsscd0+vRpDR48WJ07dy7QQxIAT3LlyhX7++bJJ5/UiRMnNG3aNLVq1UqSNHbsWK1fv16jRo3Sfffdp8qVK2vfvn2aNm2aSpUqpaVLl9rfmwCQjdwGXIPcBuAK5DbgGuQ2roViOZzi9ddf17fffqs33nhDzZo10+zZs/X2228rMDBQ06ZNU+vWre0fFWvfvr0kae3atfL39y/OaQNuJT09XTabTWXKlJEkZWZmytfXV/Hx8XryySdVpUoVjRgxQhERETKbzZo+fbpWr16tqlWrytvbW1lZWSpfvrxWrlwpHx8fhx+uAeBq5DZQdOQ2gOuF3AaKjtxGflEsR5H9/PPPmjRpkp5++mm1bdtWS5cu1axZszRmzBh9/fXX+uWXX/TGG2+oZcuW9ivbJ0+eVI0aNYp55oD7uHz5smJiYmQ0GhUVFSWr1aqHHnpIL7zwgjp27KijR48qMjJS1apV08iRI9WyZUtJ0ueff67ffvtNly5dUu3atfXoo4/KaDQqKyvLYS1DAMhGbgNFR24DuF7IbaDoyG0UBMVy5JvFYlFycrK8vLzk5+dnD+KkpCR98cUX6tixo+Li4jRmzBi99tpreuihhxQXF6cBAwaoatWqGjVqlO655x77emsAHM2bN09vvfWWnn76aX366aeqVKmS5s6dqwoVKsjb29shwF988UVFRERIkv1hI9muXtcQgOcitwHXIrcBOBO5DbgWuY38oliOfElLS9PYsWN18OBBJScn64EHHtATTzyhWrVqyWq1KjMzU6VLl9bw4cNls9k0ceJElS1bVlarVd26ddOJEyfk7++vTZs2yc/Pr7hPB3Bb48aN05o1a1S5cmXNnz9f9erVk/R/a6plB3j16tX14osv2tdUA4CrkdvA9UFuA3AGchu4Psht5AeL6+Bfmc1mde3aVX/88Yduu+02NWjQQP/97381depUnTp1SgaDQaVLl5YknTt3TufOnVPZsmUlSYcOHVJgYKDeffddffTRRwQ3kAubzWZ/yvbJkyfl7e2tP/74Q59//rnOnz8vSfLx8dGVK1cUGhqqlStX6tSpUxo1apQOHDhQnFMH4IbIbcC1yG0AzkRuA65FbqOgWGAH12Q2m/Xwww8rLCxM48ePV7Vq1SRJM2fO1OLFi3X06FFVrVpVVqtVNptNjRo10hdffKG33npLzZo108aNG3XhwgVVr15dFSpUKOazAdxP9ke4sj/W9dZbb6l06dKaMmWKFixYIJvNpp49e6pixYry8fFRVlaWQkND7T9AZ18JBwCJ3AZcjdwG4EzkNuBa5DYKg2VYkKesrCwNHjxYX331lXbs2KEKFSrYnxYsSa1bt9azzz6rJ5980t7n4sWLGj16tPbs2SOLxSKTyaS33npL9evXL67TANxW9kNB0tLSNG7cONWtW1cdO3a0/5A8efJkrVixQgMHDtSTTz6pChUqKDExUT/88IM6depkH4c10wBI5DbgauQ2AGcitwHXIrdRWNxZjjxlZGSoYcOG2r9/v15++WUtXLhQvr6+yszMlM1mU/ny5fXLL7/olVdeUcuWLVWnTh3Vq1dPc+fO1e+//64LFy4oPDxcwcHBxX0qgNuxWq3y9vaW2WxWZGSk/P391aJFCwUFBclqtcpgMGjMmDGy2WxauHChUlNTdfvtt+vdd99Venq6HnzwQfvVcYIbgERuA65EbgNwNnIbcB1yG0XBneW4JrPZrLVr19o/5rVo0SJJ0vz58zV//nxVrFhRV65cUXJyskqVKqWOHTuqTp06euqpp4p55oD7u3Llip555hlduXJF06ZNU3BwsLy9vZWZmSkfHx97OE+bNk0rV66Uv7+/br75Zr333nvy8fHJ8VRuACC3AdchtwE4G7kNuA65jcKiWI5/ZTabtWbNGi1cuFAREREKDw/XggUL9Prrr6tVq1YKCgrS1q1b9csvv2jDhg3KyMjQxx9/rCpVqhT31AG3sXfvXl2+fFl33HGHve3o0aN67rnnNGLECN13332SpG+//VYbNmyQxWJRw4YN9fTTT0uS9u/fb1+n0GAw2D9SBgD/RG4DRUduA7heyG2g6MhtOBPFcuRLdoC/++67OnPmjN58803df//99o+vZDt9+rR8fHx00003FeNsAfeSmZmpQYMGqVatWnrppZfs7YmJiXr44Yf18MMPq0OHDvr444+1evVqtWjRQmazWampqXrxxRd1//33O4zHmmkA/g25DRQeuQ3geiO3gcIjt+FsFMuRb6mpqVq7dq2WLFmiRo0aaeHChZLk8BASALlLTk5WQECALl++rN9//11NmjTRlStX9N5772nRokUqU6aMypcvrxdeeEHt2rVTfHy8nnjiCb300kvq1q1bcU8fQAlEbgOFR24DuN7IbaDwyG04E58pQL6VK1fO/k1kwYIFevbZZ7Vo0SL5+vpy5Q34FwEBAZKkGTNm6P3339fSpUvVunVr9ezZU3fffbfMZrOqVKmiKlWqyGKxyGazKTg4WGXLli3mmQMoqchtoPDIbQDXG7kNFB65DWfiznIUWPZHxBYvXqywsDDFxMQU95QAt3X1Wmc2m03Hjx/X1KlTtXfvXs2cOVP/+c9/HPa/fPmyjhw5osmTJ8tms+n999/nB2MARUJuA/lHbgMobuQ2kH/kNlzB8O+7AI78/f3VrVs39e7dW6dOndJff/1V3FMC3Ja3t7cuXbqkbdu2ycvLSzfffLNefvllNW7cWMOHD1dcXJx9X7PZrAULFujVV1+VJMXExMhoNMpisRTX9AHcAMhtIP/IbQDFjdwG8o/chitwZzkKzWw2KysrS4GBgcU9FcDtZH9U0mq1asmSJZo1a5YWLlyoe+65RzabTX/88Ydef/117d+/X7NmzVLr1q116tQpxcbGymazqX///jIajTyFG4DTkNtA3shtAO6G3AbyRm7DlSiWA4CTZQf3pUuX9OGHH+q3337Txo0bJUnz5s1Tu3bt8gzwqx/gw9qEAAC4HrkNAEDJQW7D1SiWA4ALXLp0SV26dFGNGjXUpEkTeXt7a/369Tpx4oRmzZqljh072gN84sSJ+vbbb7V69Wo1bty4uKcOAIDHIbcBACg5yG24Ep81AAAXWL58ubKysjR27FjdfPPNkqQ777xT77zzjoYNGyZvb2/df//9ql69usaMGaOwsDDdcsstxTxrAAA8E7kNAEDJQW7DlXjAJwC4QHp6ugwGgwICAuxtDRs2VP/+/VW9enUNHjxYW7dulZeXl2rWrKmXXnpJ3t7eysrKKsZZAwDgmchtAABKDnIbrkSxHABcoFy5crp48aIuXbokScrMzJQkNWrUSF26dJEkDRkyRF9++aW8vLzk5eUlSTxcBACAYkBuAwBQcpDbcCWK5QBQBBaLJdf27t2766abbtLw4cMlyf4QEenvIH/44YfVtm1bLV68WOfOnbsucwUAwNOR2wAAlBzkNooDxXIAKKSsrCwZjUalp6fr888/17Jly/Ttt9/qjz/+kMlk0vDhwxUfH6/IyEidPHlS586dU3x8vH788Uc1a9ZM//nPf/Tbb78pKSmpuE8FAIAbHrkNAEDJQW6juPD5AwAoBKvVKm9vb5nNZvXo0UMXL15UWlqa0tLS1Lx5c/Xu3Vv333+/vLy8NGPGDHXp0kXlypVTVlaWypcvr8jISH377bfy8/OT1Wot7tMBAOCGRm4DAFBykNsoThTLAaAQDAaDrly5oueee06BgYGaPHmyQkJC9MMPP2jhwoWaM2eOvLy81K5dO7Vq1Upr165VamqqTCaTevXqJUlauXKlgoKCFBwcXMxnAwDAjY3cBgCg5CC3UZy8bDabrbgnAQAl0enTp9WjRw9FR0fr0UcftT805KefftLEiRNVtmxZTZs2TVWqVHHot3//fi1dulQ7duxQTEyM6tWrVxzTBwDAo5DbAACUHOQ2igtrlgNAIV24cEGnTp1ScHCwvLy8dOXKFUlSkyZN9Nxzz+n7779XQkKCQ5+TJ09q27ZtOnv2rP773/8S3AAAXCfkNgAAJQe5jeJCsRwA/kVeT+AODQ1VvXr1tGzZMiUlJcnHx8ce4M2aNVPZsmV14sQJhz41atRQ9+7dtXDhQoWHh7t87gAAeBpyGwCAkoPchruhWA4AeTh+/LgkyWg05hrgpUuX1n333adDhw7pvffe0/nz5+Xj4yObzabjx4/Lz88v1/XRKlWqpICAAJfPHwAAT0JuAwBQcpDbcFesWQ4AuTh//ry6dOmikJAQxcTESJKysrLk7f33c5FtNpt9zbSXXnpJu3btUu3atfXkk0/q9OnTWr9+vaxWq1auXCmj0Vhs5wEAgCcgtwEAKDnIbbgziuUAkAuz2awPPvhAy5cvV6NGjbRo0SJJjgFusVjswfzWW2/pyy+/1K+//qrq1asrLCxMb731lnx8fBz2AwAAzkduAwBQcpDbcGcUywEgD2azWWvWrNHChQvVtGnTXAP8ypUr8vHxkSRdvnxZp0+fVtmyZVWpUiV5eXk57AsAAFyH3AYAoOQgt+GuKJYDwDXkJ8CzsrJ0+PBhnTp1ShERESpbtqwkyWq1ymDg0RAAAFwv5DYAACUHuQ13xL8qALgGf39/devWTQMHDtTevXv17LPPSpLDWmq//PKLBg4cqFWrVqlMmTL2vgQ3AADXF7kNAEDJQW7DHXFnOQDkQ15XvH/88UeNGzdOBoNBa9eutX9EDAAAFB9yGwCAkoPchjuhWA4A+ZQd4AsWLNBtt92m5557Tq+88oqsVqvWrVsnHx8f1kwDAMBNkNsAAJQc5DbcBcVyACgAs9mstWvXasmSJTp79qzq1KlDcAMA4KbIbQAASg5yG+6Af2UAUAD+/v7q2rWrzGaz4uPjNX36dHl7exPcAAC4IXIbAICSg9yGO+DOcgAohLS0NJUtW1ZeXl4ENwAAbo7cBgCg5CC3UZwolgNAEdhsNnl5eRX3NAAAQD6Q2wAAlBzkNooDxXIAAAAAAAAAgMczFPcEAAAAAAAAAAAobhTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAe7du1SeHi4du3aVei+W7ZsccHM8i88PFzz5s0r1jkAAACgZKFYDtyg1q1bp/Dw8Fz/mzFjhn2/7du3a8yYMerUqZPq16+ve++9t0DHyR7z5ZdfznX77Nmz7fskJSUV6ZwAAHBnrs5ei8WiZs2aaeDAgTm2LVu2TOHh4Ro5cmSObXPnzlV4eLiOHj1a+JNzkdjYWC1btqy4pwEAAABIkryLewIAXGvw4MGqXr26Q1vdunXt/79x40Zt3rxZt9xyiypVqlSoY5QqVUqff/65XnvtNfn6+jps27hxo0qVKqWMjIxCjQ0AQEnjquw1Go1q0qSJ9u7dm2Pbnj175O3trT179uS67aabblJoaGi+j9W8eXPt379fPj4++e5TGBs3btThw4fVp08flx4HAAAAyA+K5cANrk2bNmrUqFGe24cOHaoJEybIx8dHAwYM0OHDhwt8jDvvvFNfffWVtm3bprZt29rb9+zZoz/++EPt27fXZ599Vqj5F9alS5dUtmzZ63pMAAAk12Zvs2bNFBcXp/j4eNWqVcvevmfPHj3wwAPauHGjzp49q6CgIElSVlaW9u/fr9atWxfoHAwGg0qVKlWgPgAAAEBJxzIsgIcLDg4u8l1jwcHBuv3227Vx40aH9tjYWNWtW1d16tTJ0efHH3/U4MGDdffdd6thw4a66667NHnyZKWnp+fYNz4+Xi+88IJatWqlxo0bq3379po9e7Z9+7x58xQeHq4jR45o+PDhat68uXr06CHp7yLBW2+9pbZt26phw4a69957NWvWLGVmZhbpnAEAKKyiZO9tt90mSQ53kJ88eVJnz55Vr169VKpUKYdtv/32my5dumTvJ/2dq4MHD1aLFi3UqFEjPfroo/ryyy8djpPXmuXvv/++7rvvPjVu3FjdunXTjz/+qCeffFJPPvlkjrlarVYtXLjQfvEgKipKx48ft29/8skn9c033+jPP/+0L1dz9ZI0mZmZevPNN9WuXTv7zwrTp0/PkeGZmZmaPHmyWrVqpaZNm+rZZ5/V6dOnC/JlBQAAACRxZzlwwzObzTnWCq9QoYLTj/PQQw9p0qRJSktLk5+fn7KysrRlyxb17ds31yVYtmzZovT0dD3xxBMKDAzU/v379d///lenT5/Wm2++ad/v4MGD6tmzp7y9vfX444+rWrVqOnHihL766isNHTrUYcwXXnhBN998s4YOHSqbzSZJeuWVV7R+/Xq1b99effv21f79+/X2228rPj5eb731ltO/DgAAuDJ7mzRpIm9vb+3evVuPPfaYJGn37t0qW7asGjVqpIYNG2rPnj1q3769pP8rqmcXyw8fPqwnnnhCwcHB6t+/v8qWLatPP/1U0dHRmjdvntq1a5fnsT/44AO9/vrruv3229WnTx/9+eefio6OlslkUuXKlXPsv3jxYnl5eempp56S2WzWkiVLNGLECH300UeSpGeffVapqak6ffq0Ro8eLUny8/OT9HehfeDAgdq9e7e6d++uWrVq6dChQ1q+fLmOHTumBQsW2I/z8ssva8OGDerUqZOaNWumnTt36plnninqlxoAAAAeiGI5cIPLbQ3Q33//3enHad++vV5//XVt3bpVnTt3VlxcnC5cuKAHH3xQ69aty7H/iBEjVLp0afufH3/8cd18882aNWuWTp06papVq0qSJk6cKJvNpvXr19vbsvv/U7169TRz5kz7nw8ePKj169frscce08SJEyVJPXv2VIUKFfTuu+9q586datWqldO+BgAASK7N3jJlyqh+/fravXu3vW3Pnj1q1KiRvL291bRpU4e7wXfv3q0yZcrolltukSRNmjRJVapU0dq1a+3PGenRo4eeeOIJzZgxI89ieWZmpubOnatGjRpp+fLl8vb++9eI8PBwjRo1KtdieUZGhj7++GP7cUwmkyZNmqRDhw6pbt26at26tVasWKGUlBR17tzZoW9sbKx27NihmJgY3X777fb2OnXq6LXXXtOePXvUrFkzHTx4UBs2bFCPHj302muvSfo764cPH+6Sn3cAAABwY2MZFuAGN3bsWL333nsO/7lCQECA7rzzTm3atEnS37/kNm3aVNWqVct1/6sL5ZcuXVJSUpKaNm0qm82mX3/9VZKUlJSkH374QV27dnUolEuSl5dXjjEjIyMd/vztt99Kkvr27evQ/tRTTzlsBwDAmVydvbfddptOnDihs2fPSpL27t2rpk2bSvp7TfPffvtNly9flvR3Ib1x48by9vbWxYsXtXPnTnXo0MF+93tSUpIuXLig//znPzp27JgSExNzPeYvv/yiixcvqnv37vZCufT3J8sCAgJy7fPoo486PPg7u+h98uTJfz3HLVu2qFatWgoLC7PPMykpyX6RO/uCQHaW/3MZmKioqH89BgAAAPBP3FkO3OAaN258zYeMOdNDDz2kl156SadOndKXX36Z693f2U6dOqU333xTX331lZKTkx22mc1mSf/3y3TdunXzdfzq1as7/PnPP/+UwWBQzZo1HdqDgoJkMpn0559/5mtcAAAKwtXZe9ttt2nZsmXas2ePIiIidPjwYXvmNm3a1P5Qz6pVq+rs2bP25VpOnDghm82muXPnau7cubmOff78eQUHB+doP3XqlCTlyFRvb+88L4z/80K3yWSSJKWkpPzrOR4/flzx8fGKiIjIc55S3lkfFhb2r8cAAAAA/oliOQCnuffee+Xj46ORI0cqMzNTHTp0yHU/i8Wivn37Kjk5WU8//bTCwsJUtmxZJSYmatSoUbJarYU6fqlSpXJtz+0udAAASqrs9cd3795t/6RW9p3lFSpUUEhIiHbv3q2//vrLYf/sfH3qqad055135jr2P4vORWEw5P4h1uznilyL1WpV3bp17WuZ/1Nuy74AAAAARUWxHIDTlC5dWm3bttWGDRvUpk2bPB9mdujQIR07dkzTpk1Tly5d7O1xcXEO+9WoUcO+f2FUq1ZNVqtVx48fV61atezt586dU0pKSp53wgEA4M5uuukme0G8TJkyql27tv2ubenvwvmePXt0+vRpGY1GNWnSRNL/5aqPj4/uuOOOAh0z+y7xEydOODzvIysrS3/++afCw8MLdS55XdCuWbOmDh48qIiIiGte9M7O+hMnTjjcTZ6QkFCo+QAAAMCzsWY5AKfq16+fnn/+eT333HN57pN9p9nVd5bZbDatWLHCYb8KFSqoefPmWrt2rf3j31fv/2/uuusuSdLy5csd2rPXjs3eDgBASZP9cMu4uDj7XeXZmjZtqp9++km7d+9WeHi4/P39Jf1dZG/RooVWrVqlM2fO5BgzKSkpz+M1bNhQgYGBWr16tbKysuztsbGxOZZTK4gyZcooNTU1R3uHDh2UmJio1atX59iWnp6uS5cuSZLatGkjSYqJiXHY55/ZDwAAAOQHd5YDHu7gwYP66quvJP29PmhqaqoWLFggSapXr57uvffeAo1Xr1491atX75r7hIWFqWbNmpo2bZoSExPl7++vzz77LNc1TF955RU98cQTeuSRR/T444+revXq+vPPP/XNN9/ok08++de5PPLII1q1apVSUlLUvHlz/fzzz1q/fr3atm3rcGccAADXizOy97bbbtO6dev0888/q2fPng7bmjZtqtTUVKWmpuZ48OVrr72mHj166KGHHlL37t1Vo0YNnTt3Tj/99JNOnz6tDRs25Ho8X19fDRo0SBMmTFBUVJQ6dOigP//8U+vWrSvS0i0NGjTQ5s2bNWXKFDVq1Ehly5bVvffeq86dO+vTTz/Va6+9pl27dqlZs2ayWCxKSEjQli1btGTJEjVq1Ej169dXp06d9MEHHyg1NVVNmzbVzp07dfz48ULPCQAAAJ6LYjng4X799dccD/nK/vMjjzxS4GJ5fvj4+GjRokWaOHGi3n77bZUqVUrt2rVTz5491blzZ4d969Wrp9WrV2vu3Ln68MMPlZGRoapVq+a5Hvo/TZw4UdWrV9f69eu1detWVaxYUQMGDNDzzz/v9PMCACA/nJG92euQS8pxZ3mdOnVkMpmUkpKiZs2aOWyrXbu21q5dq/nz52v9+vW6ePGiKlSooFtuuUXR0dHXPGavXr1ks9n03nvvadq0aapXr54WLlyoiRMn5vnckH/To0cP/fbbb1q3bp2WLVumatWq6d5775XBYNBbb72lZcuW6ZNPPtEXX3yhMmXKqHr16nryyScVGhpqH2Py5MkqX768YmNj9eWXX6ply5Z65513+AQZAAAACszLlp+1DAAAAADgH6xWqyIiItSuXTtNnDixuKcDAAAAFAlrlgMAAAD4VxkZGTmeGfLxxx/r4sWLatGiRTHNCgAAAHAelmEBAAAA8K9++uknTZkyRQ888IACAwP166+/as2aNapbt64eeOCB4p4eAAAAUGQUywEAAAD8q2rVqqly5cqKiYlRcnKyAgIC1LlzZ40YMUK+vr7FPT0AAACgyNxuzfL4+HhNnDhRe/fulZ+fnzp37qwhQ4Zc8wfwXbt2qXfv3rluCw0N1ZYtW+x//vHHHzV37lwdPHhQBoNBjRo10vDhw1W/fn2nnwsAAAAAAAAAoGRwqzvLk5OTFRUVpZCQEM2bN0+JiYmaOnWq0tPTNXbs2Dz7NWjQQKtWrXJoM5vN6t+/v9q0aWNvS0hIUL9+/dSqVSvNnDlTmZmZevvtt9WnTx9t3LhRQUFBLjs3AAAAAAAAAID7cqti+cqVK5WWlqb58+crMDBQkmSxWDR+/HgNGDBAwcHBufbz9/dXkyZNHNrWrVsnq9WqTp062du2bt0qm82muXPnqnTp0pKk8PBwtW3bVnFxcerSpYsrTgsAAAAAAAAA4Obcqli+bds2RURE2AvlktShQwe99tpriouL06OPPprvsTZu3KiQkBA1btzY3nblyhX5+vqqVKlS9rZy5coVed42m01Wq1utZuPxDAYv/k6AfOC94l4MBi95eXkV9zRueOS2++F7EZA/vFfcC7kNAMCNx62K5QkJCeratatDm8lkUlBQkBISEvI9zrlz57Rz504NHDjQof3BBx/UkiVLNGfOHPXp00eZmZmaNWuWqlSpovvuu6/Q87ZabUpJuVzo/nAuo9Egk6mM0tLSZbFYi3s6gNviveJ+TKYyMhr5pdvVrFabkpLSinsa+P+8vQ0qX95PKSmXlJXF9yIgL7xX3E+FCn7kNgAANxi3KpanpKTIZDLlaA8ICFBycnK+x9m8ebMsFovDEiySFBISomXLlum5557TokWLJEnVqlXTe++9V6Q7zA0GL5Uv71fo/nANk6lMcU8BKBF4rwAAAAAAALhZsdxZYmNj1aBBA4WGhjq0Hz16VIMGDVLr1q3VpUsXZWRk6N1331X//v21cuVKVaxYsVDH+/vO8kvOmDqcIPtu2ZSUy9wtC1wD7xX38/ed5YbingYAAAAAAB7JrYrlJpNJqampOdqTk5MVEBCQrzFOnDih/fv3a/To0Tm2zZ49WxUrVtT06dPtbS1atNA999yjFStWaNiwYYWeOx+FdD8Wi5W/FyAfeK8AAAAAAABIbnX7WlhYWI61yVNTU3X27FmFhYXla4zY2FgZDAZ17Ngxx7YjR46oXr16Dm1+fn6qWbOmTpw4UfiJAwAAAAAAAABKNLcqlrdp00Y7duxQSkqKvW3Lli0yGAxq3bp1vsbYtGmTWrRooUqVKuXYVrVqVf3222+y2f7vCfJms1nHjx9XtWrVin4CAAAAAAAAAIASya2K5ZGRkfLz81N0dLS2b9+utWvXavr06YqMjFRwcLB9v6ioKLVr1y5H/19//VXx8fE5Hux59fi//vqrRowYoW3btmnr1q165plnlJmZqccee8xl5wUAAAAAAAAAcG9utWZ5QECAli9frgkTJig6Olp+fn7q1q2bhg4d6rCf1WqVxWLJ0T82Nla+vr5q3759ruO3bdtWc+bM0dKlSzV06FD5+Pjolltu0YoVKxQSEuKKUwIAAAAAAAAAlABetqvXJEGhWCxWJSWlFfc08P95extUvryfLlxI46GFwDXwXnE/FSr4yWh0qw993ZDIbffC9yIgf3ivuB9yGwCAGw/JDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg87+KeAFAYx44dVUpKcq7bjEaDLJZ0GY2lZbHk/vAjkylAISGhrpwiAAD4/8htAAAAACUBxXKUOOfPn1erVk1lteb+C3V+GI1G/fLLEd10001OnBkAAPgnchsAAABASUGxHCXOTTfdpJ079+Z5h1p8/GENGNBPb7+9VLVq1cl1H5MpgF+4AQC4DshtAAAAACUFxXKUSNf6KLbR+PdS/HXrhqtBg8bXa0oAACAP5DYAAACAkoAHfAIAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg87+KeAAAAAEq+hIQjMpvNBe4XH39YknTo0O+yWKwF7u/v76+wsNoF7gcAAAAA/0SxHAAAAEWSkHBErVo1K9IYAwb0K3TfnTv3UDAHAAAAUGQUywEAAFAk2XeUL1iwWHXrhheor9FokMWSLqOxdIHvLD906Hc991z/Qt3RDgAAAAD/RLEcAAAATlG3brgaN25SoD7e3gaVL++nCxfSlJVV8GVYAAAAAMBZeMAnAAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx/Mu7gn8U3x8vCZOnKi9e/fKz89PnTt31pAhQ+Tr65tnn127dql37965bgsNDdWWLVsc2r755hstWrRIBw8elI+Pj+rVq6c33nhDlStXduq5AAAAAAAAAABKBrcqlicnJysqKkohISGaN2+eEhMTNXXqVKWnp2vs2LF59mvQoIFWrVrl0GY2m9W/f3+1adPGof2TTz7Ryy+/rKeeekpDhgxRWlqafvzxR2VkZLjknAAAAAAAAAAA7s+tiuUrV65UWlqa5s+fr8DAQEmSxWLR+PHjNWDAAAUHB+faz9/fX02aNHFoW7dunaxWqzp16mRvu3jxol5//XWNGTNGPXr0sLffd999Tj8XAAAAAAAAAEDJ4VZrlm/btk0RERH2QrkkdejQQVarVXFxcQUaa+PGjQoJCVHjxo3tbZ9++qmsVqu6devmrCkDAAAAAAAAAG4AbnVneUJCgrp27erQZjKZFBQUpISEhHyPc+7cOe3cuVMDBw50aN+3b59CQ0P18ccfa+HChUpMTFSdOnU0bNgw3XXXXUWau7e3W1138GgGg5f9lb8XIG9Go8HhFQAAAAAAwJO5VbE8JSVFJpMpR3tAQICSk5PzPc7mzZtlsVgclmCRpLNnz+ro0aOaO3euXnzxRQUFBen999/Xc889p48//lh16tQp1LwNBi+VL+9XqL5wPn//0vZX/l6Af2cylSnuKQAAAAAAABQ7tyqWO0tsbKwaNGig0NBQh3abzaZLly5pxowZ9nXKW7Roofbt22vx4sWaPn16oY5ntdqUknKpyPOGc5jN6fbXCxfSink2gPsyGg0ymcooJeWyLBZrcU8H+vvCBXf6AwAAAABQPNyqWG4ymZSampqjPTk5WQEBAfka48SJE9q/f79Gjx6d6/iS1KpVK3ubj4+PmjdvrsOHDxdy1n/LyqLQ5C6sVpv9lb8X4N9ZLFbeKwAAAAAAwOO5VbE8LCwsx9rkqampOnv2rMLCwvI1RmxsrAwGgzp27JhjW+3atfPsl5GRUbDJwuUSEo7IbDYXuF98/N8XPg4d+r1Qd8v6+/srLCzvfysAAAAAAAAAbjxuVSxv06aNFi1a5LB2+ZYtW2QwGNS6det8jbFp0ya1aNFClSpVyrHtnnvu0bx58/Tdd9+pbdu2kqTMzEz98MMPuv322513IiiyhIQjatWqWZHGGDCgX6H77ty5h4I5AAAAAAAA4EHcqlgeGRmpmJgYRUdHa8CAAUpMTNT06dMVGRmp4OBg+35RUVE6deqUvvjiC4f+v/76q+Lj49W3b99cx2/QoIHat2+vV199VRcvXlRQUJA++OADnTt3Tv36Fb6wCufLvqN8wYLFqls3vEB9jUaDLJZ0GY2lC3xn+aFDv+u55/oX6o52APBE8fHxmjhxovbu3Ss/Pz917txZQ4YMka+v7zX7XbhwQbNnz9a2bdt08eJFVa9eXT179tQTTzxh32fHjh366KOPtG/fPp0/f17VqlXTo48+qqioKPn4+Lj61AAAAAAAHsatiuUBAQFavny5JkyYoOjoaPn5+albt24aOnSow35Wq1UWiyVH/9jYWPn6+qp9+/Z5HmPq1KmaNWuWZs6cKbPZrAYNGui9995TeHjBCrK4PurWDVfjxk0K1Mfb26Dy5f104UIa6zADgAslJycrKipKISEhmjdvnhITEzV16lSlp6dr7Nix1+z7wgsvKCEhQcOGDVOVKlW0bds2jRs3TkajUd27d5ckrVy5Uunp6Ro8eLCqVKmiffv2ad68eYqPj9eUKVOuxykCAAAAADyIWxXLJalWrVpatmzZNfeJiYnJtX3kyJEaOXLkNfuWLVtWr7zyil555ZXCThEAAOjvYnZaWprmz5+vwMBASZLFYtH48eM1YMAAh0+FXe3s2bPatWuXpkyZokcffVSSFBERoZ9//lmbNm2yF8vHjRunChUq2Pu1bNlSVqtVc+bM0YsvvuiwDQAAAACAojIU9wQAAEDJtG3bNkVERNgL5ZLUoUMHWa1WxcXF5dkvKytLklSuXDmHdn9/f9lsNvufcyuG169fXzabTWfPni3i7AEAAAAAcOR2d5YDAICSISEhQV27dnVoM5lMCgoKUkJCQp79qlSpov/85z9atGiRQkNDVblyZW3btk1xcXGaMWPGNY+5Z88e+fr6qnr16kWau7c39ws4k9FosL8W9Gt7dd/reVygpCnKewUAAAD5Q7EcAAAUSkpKikwmU472gIAAJScnX7PvvHnzNHToUD344IOSJKPRqFdeeeWazx05duyYVqxYocjISPn5+RV63gaDl8qXL3x/5GQylbG/FvZrmz3G9T4uUNIU5r0CAACA/KFYDgAAriubzabRo0fr2LFjmjlzpoKCgrRjxw5NnjxZAQEB9gL61cxmswYNGqTq1avnePB3QVmtNqWkXCrSGHCUknLZ/nrhQlqB+hqNBplMZZSSclkWS8EezF2U4wIlTVHeK3ANk6kMd/oDAHCDoVgOAAAKxWQyKTU1NUd7cnKyAgIC8uz3zTffaMuWLdqwYYPCw8Ml/f3wzvPnz2vq1Kk5iuWZmZmKjo5WcnKyVq1apbJlyxZ57llZFJqcKbtwZ7FYC/21LUxfZxwXKGn49w4AAOA6XAYHAACFEhYWlmNt8tTUVJ09e1ZhYWF59jty5IiMRqPq1q3r0F6/fn2dOXNGly9ftrdZrVaNGDFCBw4c0OLFi1WlShXnngQAAAAAAP8fxXIAAFAobdq00Y4dO5SSkmJv27JliwwGg1q3bp1nv2rVqslisej33393aD9w4IBuuukmlSnzf+vxjh8/Xl9//bUWLFhgvwsdAAAAAABXYBkWAABQKJGRkYqJiVF0dLQGDBigxMRETZ8+XZGRkQoODrbvFxUVpVOnTumLL76Q9HeRvWrVqho8eLCio6NVqVIlbd++XevXr9egQYPs/RYtWqSVK1eqX79+8vX11U8//WTfVrt2bfn7+1+3cwUAAAAA3PgolgMAgEIJCAjQ8uXLNWHCBEVHR8vPz0/dunXL8QBOq9Uqi8Vi/7O/v7+WLVum2bNna8aMGUpNTVX16tU1atQo9erVy75fXFycJGnp0qVaunSpw5grVqxQy5YtXXh2AAAAAABPQ7EcAAAUWq1atbRs2bJr7hMTE5Oj7eabb9acOXMK3A8AAAAAAFdhzXIAAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PIrlAAAAAAAAAACPR7EcAAAAAAAAAODxKJYDAAAAAAAAADwexXIAAAAAAAAAgMfzLu4JAAAAoOQL8i8t37Qzspw7VrCORoMy0ssoK/WyLBZrgbr6pp1RkH/pgh0PAAAAAPJAsRxui1+6AQAoOZ5oEapqP3+gSz8XvG9qIY9Z7f8fFwAAAACcgWI53Ba/dAMAUHJ8+P1RdXthgurUqVugfkajQaZyZZRSiIvchw8f0odTe+nhAvUCAAAAgNxRLIfb4pduAABKjrPmdGX6VZKxYkiB+nl7G1SqvJ+8S6dJWQXL7cxTF3XWnF6gPgAAAACQF4rlcFv80g0AAAAAAADgejEU9wT+KT4+Xn379lWTJk3UunVrTZ8+XZmZmdfss2vXLoWHh+f63wMPPJBrH6vVqkcffVTh4eHasmWLK04FAAAAAAAAAFBCuNWd5cnJyYqKilJISIjmzZunxMRETZ06Venp6Ro7dmye/Ro0aKBVq1Y5tJnNZvXv319t2rTJtc/KlSuVmJjo1PkDAAAAAAAAAEomtyqWr1y5UmlpaZo/f74CAwMlSRaLRePHj9eAAQMUHBycaz9/f381adLEoW3dunWyWq3q1KlTjv2TkpI0d+5cvfTSSxozZoyzTwMAAAAAAAAAUMK41TIs27ZtU0REhL1QLkkdOnSQ1WpVXFxcgcbauHGjQkJC1Lhx4xzbZs2apZYtW6ply5ZFnTIAlEgWi0Xbt2/Thx9+qO3bt8lisRT3lAAAAAAAAIqVW91ZnpCQoK5duzq0mUwmBQUFKSEhId/jnDt3Tjt37tTAgQNzbNu/f782btyojRs3Fnm+V/P2dqvrDiWe0Wiwvxb0a3t13+t5XKCkiI39RK++OkYnThy3t9WsebMmTJishx7qXIwzAwAAAAAAKD5uVSxPSUmRyWTK0R4QEKDk5OR8j7N582ZZLJYcS7BYrVaNHz9effv2VfXq1fXHH38Uec6SZDB4qXx5P6eMhb+ZTGXsr4X92maPcb2PC7izdevWqU+fXurUqZNWrVqphg0b6pdfftHkyZPVp08vrVmzRo8++mhxTxMAAAAAAOC6c6tiubPExsaqQYMGCg0NdWj/6KOPdO7cOT3zzDNOPZ7ValNKyiWnjunpUlIu218vXEgrUF+j0SCTqYxSUi7LYrFet+MC7s5isWjo0GFq376D3nvvffn4eMvfv4xuueVWvffe++rVK1LDhg1XmzZtZTQai3u6HslkKlOoT8UAAAAAAICic6tiuclkUmpqao725ORkBQQE5GuMEydOaP/+/Ro9erRDe1pammbNmqWhQ4fqypUrunLlisxmsyQpPT1dZrNZ/v7+hZ57VlbBirK4tuwit8ViLfTXtjB9nXFcwF3FxW3XiRPHtWjRUlmtjv/erVZp0KChevDBdtq+fbtat76zmGcLAAAAAABwfblVsTwsLCzH2uSpqak6e/aswsLC8jVGbGysDAaDOnbs6NB+4cIFXbx4Ua+99ppee+01h20jR45UxYoVC/wQUQAoSRITT0uS6tW7Jdft9evf4rAfAAAAAACAJ3GrYnmbNm20aNEih7XLt2zZIoPBoNatW+drjE2bNqlFixaqVKmSQ3tQUJBWrFjh0Hbu3DkNGzZMgwYN0h133OGckwAANxUcXFmSdPDgr7r99hY5tv/2268O+wEAAAAAAHgSt1oYNTIyUn5+foqOjtb27du1du1aTZ8+XZGRkQoODrbvFxUVpXbt2uXo/+uvvyo+Pj7Hgz0lqVSpUmrZsqXDf7feeqskqXbt2mrWrJnrTgwA3ECrVneoZs2bNXfuTFmtjssMWa1WvfnmLNWsGaJWrbh4CAAAAAAAPI9bFcsDAgK0fPlyGY1GRUdHa+bMmerWrZtGjRrlsJ/VapXFYsnRPzY2Vr6+vmrfvv31mjIAlBhGo1Hjxk3S559vUVTUE/r++11KTU3V99/vUlTUE/r88y0aN24iD/cEAAAAAAAeya2WYZGkWrVqadmyZdfcJyYmJtf2kSNHauTIkfk+VvXq1fX7778XZHoAUKJ16vSwli6N0bhxL+uBB+6zt9esGaKlS2PUqdPDxTg7AAAAAACA4uN2xXIAgGt16vSwOnR4UD/88J3M5ovy9w9U8+YR3FEOAAAAAAA8GsVyAPBARqNR//lPG5Uv76cLF9KUlWX9904AAAAAAAA3MLdasxwAAAAAAAAAgOJAsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAACFFh8fr759+6pJkyZq3bq1pk+frszMzH/td+HCBY0dO1Z33323mjRpok6dOunDDz/MsV9iYqIGDRqkpk2bqkWLFnr55ZdlNptdcSoAAAAAAA/nXdwTAAAAJVNycrKioqIUEhKiefPmKTExUVOnTlV6errGjh17zb4vvPCCEhISNGzYMFWpUkXbtm3TuHHjZDQa1b17d0nSlStX9PTTT0uSZs6cqfT0dE2bNk3Dhw/X22+/7fLzAwAAAAB4ForlAACgUFauXKm0tDTNnz9fgYGBkiSLxaLx48drwIABCg4OzrXf2bNntWvXLk2ZMkWPPvqoJCkiIkI///yzNm3aZC+Wf/bZZzp8+LA2b96ssLAwSZLJZFK/fv20f/9+NW7c2PUnCQAAAADwGCzDAgAACmXbtm2KiIiwF8olqUOHDrJarYqLi8uzX1ZWliSpXLlyDu3+/v6y2WwO44eHh9sL5ZLUunVrBQYG6ttvv3XSWQAAAAAA8DfuLAcAAIWSkJCgrl27OrSZTCYFBQUpISEhz35VqlTRf/7zHy1atEihoaGqXLmytm3bpri4OM2YMcNh/KsL5ZLk5eWl0NDQa46fH97e3C/gTEajwf5a0K/t1X2v53GBksRisWjHju1KSUmSyVRBLVtGyGg0Fve0AAAAbjgUywEAQKGkpKTIZDLlaA8ICFBycvI1+86bN09Dhw7Vgw8+KEkyGo165ZVX1L59e4fx/3n3eX7HvxaDwUvly/sVuj9yMpnK2F8L+7XNHuN6Hxdwd+vWrdPw4cN17Ngxe1tISIhmzpxpX8oKAAAAzkGxHAAAXFc2m02jR4/WsWPHNHPmTAUFBWnHjh2aPHmyAgIC7AV0V7FabUpJueTSY3ialJTL9tcLF9IK1NdoNMhkKqOUlMuyWKzX7bhASRAb+4n69Oml9u07aMmSZWrZ8jbt2rVbM2ZMV7du3bRs2X/10EOdi3uaHstkKlOoT8UAAAD35XbF8vj4eE2cOFF79+6Vn5+fOnfurCFDhsjX1zfPPrt27VLv3r1z3RYaGqotW7ZIknbs2KGPPvpI+/bt0/nz51WtWjU9+uijioqKko+Pj0vOBwCAG5XJZFJqamqO9uTkZAUEBOTZ75tvvtGWLVu0YcMGhYeHS5Jatmyp8+fPa+rUqfZiuclkktlsznX8KlWqFGnuWVkFK8ri2rKL3BaLtdBf28L0dcZxAXdlsVj06qtjdP/9D2jZsg/k6+stf38/NWt2u5Yt+0BRUU/o1Vdf1v33d2RJFgAAACdxq2J5cnKyoqKiFBISonnz5ikxMVFTp05Venq6xo4dm2e/Bg0aaNWqVQ5tZrNZ/fv3V5s2bextK1euVHp6ugYPHqwqVapo3759mjdvnuLj4zVlyhSXnRcAADeisLCwHGuHp6am6uzZsznWGr/akSNHZDQaVbduXYf2+vXr66OPPtLly5dVpkwZhYWF6dChQw772Gw2HT16VK1bt3beiQCAG9q5c4dOnDiuRYuWymBwvHvZYDBo8OBhevDBdtq5c4dat76zmGYJAABwY3GrYvnKlSuVlpam+fPnKzAwUNLfd1SMHz9eAwYMUHBwcK79/P391aRJE4e2devWyWq1qlOnTva2cePGqUKFCvY/t2zZUlarVXPmzNGLL77osA0AAFxbmzZttGjRIoe1y7ds2SKDwXDNYna1atVksVj0+++/q169evb2AwcO6KabblKZMmXs42/YsEHHjh1TSEiIJOm7777TxYsXddddd7nuxADADSQmnpYk1at3S67b69e/xWE/AAAAFJ1bLbC2bds2RURE2AvlktShQwdZrVbFxcUVaKyNGzcqJCREjRs3trflVgyvX7++bDabzp49W+h5AwDgiSIjI+Xn56fo6Ght375da9eu1fTp0xUZGelwgTsqKkrt2rWz/7lNmzaqWrWqBg8erE8++UTfffed3njjDa1fv169evWy79e+fXvVqVNHgwYN0tdff63NmzdrzJgxuvvuux3yHQBuRMHBlSVJBw/+muv233771WE/AAAAFJ1b3VmekJCgrl27OrSZTCYFBQXl+Jj3tZw7d047d+7UwIED/3XfPXv2yNfXV9WrVy/wfK/m7e1W1x1KvOwH5RiNhgJ/ba/uez2PC5Q0RXmvAJIUEBCg5cuXa8KECYqOjpafn5+6deumoUOHOuxntVplsVjsf/b399eyZcs0e/ZszZgxQ6mpqapevbpGjRrlUCz38fHRkiVLNHHiRA0bNkze3t5q166dxowZc93OEQCKS6tWd6hmzZs1d+5MLV/+oa6+z8lqterNN2epZs0QtWp1R/FNEgAA4AbjVsXyqz/GfbWAgAAlJyfne5zNmzfLYrE4LMGSm2PHjmnFihX2O+MKy2DwUvnyhe+PnEymMvbXwn5ts8e43scFSprCvFeAbLVq1dKyZcuuuU9MTEyOtptvvllz5sz51/GDg4M1b968Qs4OAEouo9GoceMmqV+/JxUV9YSGDh2hO+5oru+//0GzZ8/Q559v0dKlMTzcEwAAwIncqljuLLGxsWrQoIFCQ0Pz3MdsNmvQoEGqXr16jjvgCspqtSkl5VKRxoCjlJTL9tcLF9IK1NdoNMhkKqOUlMuyWKzX7bhASVOU9wpcw2Qqw53+AAC7Tp0e1tKlMRo37mU98MB99vaaNUO0dGmMOnV6uBhnBwAAcONxq2K5yWRSampqjvbk5GQFBATka4wTJ05o//79Gj16dJ77ZGZmKjo6WsnJyVq1apXKli1b6Dlny8qi0ORM2YU7i8Va6K9tYfo647hAScO/dwAA3FenTg+rQ4cH9cMP38lsvih//0A1bx7BHeUAAAAu4FbF8rCwsBxrk6empurs2bMKCwvL1xixsbEyGAzq2LFjrtutVqtGjBihAwcO6P3331eVKlWKPG8AAAAAcBWj0aj//KeNypf304ULaVzkBgAAcBG3+qx3mzZttGPHDqWkpNjbtmzZIoPBoNatW+drjE2bNqlFixaqVKlSrtvHjx+vr7/+WgsWLFB4eLhT5g0AAAAAAAAAKNncqlie/aDN6Ohobd++XWvXrtX06dMVGRmp4OBg+35RUVFq165djv6//vqr4uPj83yw56JFi7Ry5Uo9+eST8vX11U8//WT/z2w2u+y8AAAAAAAAAADuza2WYQkICNDy5cs1YcIERUdHy8/PT926dcvxAE6r1SqLxZKjf2xsrHx9fdW+fftcx4+Li5MkLV26VEuXLnXYtmLFCrVs2dJJZwIAAAAAAAAAKEncqlguSbVq1dKyZcuuuU9MTEyu7SNHjtTIkSML3A8AAAAAAAAA4NncahkWAAAAAAAAAACKA8VyAAAAAAAAAIDHo1gOAAAAAAAAAPB4FMsBAAAAAAAAAB6PYjkAAAAAAAAAwONRLAcAAAAAAAAAeDyK5QAAAAAAAAAAj0exHAAAAAAAAADg8SiWAwAAAAAAAAA8HsVyAAAAAAAAAIDHo1gOAAAAAAAAAPB4FMsBAAAAAAAAAB6PYjkAAAAAAAAAwONRLAcAAAAAAAAAeDyK5QAAAAAAAAAAj0exHAAAAAAAAADg8SiWAwAAAAAAAAA8HsVyAAAAAAAAAIDHo1gOAAAAAAAAAPB4FMsBAAAAAAAAAB6PYjkAAAAAAAAAwONRLAcAAAAAAAAAeDzvog7w008/adeuXTp//rx69OihkJAQXb58WQkJCQoJCZGfn58z5gkAAJyA3AYAAAAAIHeFLpZnZmZq2LBh+vLLL2Wz2eTl5aV77rlHISEhMhgMeuqpp9SnTx8NHDjQmfMFAACFQG4DAAAAAHBthV6GZe7cufrmm280btw4bdmyRTabzb6tVKlSeuCBB/Tll18WeNz4+Hj17dtXTZo0UevWrTV9+nRlZmZes8+uXbsUHh6e638PPPCAw76JiYkaNGiQmjZtqhYtWujll1+W2Wwu8DwBAChJXJXbAAAAAADcKAp9Z/mmTZsUGRmpxx9/XBcuXMixvVatWtqyZUuBxkxOTlZUVJRCQkI0b948JSYmaurUqUpPT9fYsWPz7NegQQOtWrXKoc1sNqt///5q06aNve3KlSt6+umnJUkzZ85Uenq6pk2bpuHDh+vtt98u0FwBAChJXJHbAAAAAADcSApdLD9//rzCw8Pz3G40GpWenl6gMVeuXKm0tDTNnz9fgYGBkiSLxaLx48drwIABCg4OzrWfv7+/mjRp4tC2bt06Wa1WderUyd722Wef6fDhw9q8ebPCwsIkSSaTSf369dP+/fvVuHHjAs0XAICSwhW5DQAAAADAjaTQy7BUqVJFCQkJeW7fs2ePatasWaAxt23bpoiICHuhXJI6dOggq9WquLi4Ao21ceNGhYSEOBTAt23bpvDwcHuhXJJat26twMBAffvttwUaHwCAksQVuQ0AAAAAwI2k0HeWd+rUSe+9957uv/9+hYSESJK8vLwkSatXr9ann36q4cOHF2jMhIQEde3a1aHNZDIpKCjomr/g/9O5c+e0c+fOHA8pS0hIcCiUZ885NDS0QOPnxtu70NcdkAuj0WB/LejX9uq+1/O4QElTlPcKSh5X5DYAAAAAADeSQhfLn332We3bt0+9evVSWFiYvLy8NGXKFCUnJ+v06dO666671KdPnwKNmZKSIpPJlKM9ICBAycnJ+R5n8+bNslgsDkuwZI9frly5Io//TwaDl8qX9yt0f+RkMpWxvxb2a5s9xvU+LlDSFOa9gpLHFbkNAAAAAMCNpNDFcl9fXy1ZskQbNmzQZ599JqvVqszMTIWHh2vIkCHq3Lmz/Y616y02NlYNGjRQaGjodTme1WpTSsql63IsT5GSctn+euFCWoH6Go0GmUxllJJyWRaL9bodFyhpivJegWuYTGVcdqe/O+c2AAAAAADuoFDF8vT0dM2ePVstW7ZU586d1blzZ6dMxmQyKTU1NUd7cnKyAgIC8jXGiRMntH//fo0ePTrX8c1mc67jV6lSpeATvkpWFoUmZ8ou3Fks1kJ/bQvT1xnHBUoa/r3f+FyV2wAAAAAA3EgKdfta6dKltWrVKp0/f96pkwkLC8uxdnhqaqrOnj2bY63xvMTGxspgMKhjx475Gt9ms+no0aP5Hh8AgJLGVbkNAAAAAMCNpNCf9W7QoIEOHTrkzLmoTZs22rFjh1JSUuxtW7ZskcFgUOvWrfM1xqZNm9SiRQtVqlQp1/EPHjyoY8eO2du+++47Xbx4UXfddVeR5w8AgLtyRW4DAAAAAHAjKXSxfMyYMdq8ebM++ugjZWVlOWUykZGR8vPzU3R0tLZv3661a9dq+vTpioyMVHBwsH2/qKgotWvXLkf/X3/9VfHx8Tke7Jmtffv2qlOnjgYNGqSvv/5amzdv1pgxY3T33XercePGTjkHAADckStyGwAAAACAG0mhH/A5atQoeXl5aezYsZo4caKCg4NVqlQph328vLy0YcOGfI8ZEBCg5cuXa8KECYqOjpafn5+6deumoUOHOuxntVplsVhy9I+NjZWvr6/at2+f6/g+Pj5asmSJJk6cqGHDhsnb21vt2rXTmDFj8j1HAABKIlfkNgAAAAAAN5JCF8sDAwMVGBio0NBQZ85HtWrV0rJly665T0xMTK7tI0eO1MiRI6/ZNzg4WPPmzSvs9AAAKJFcldsAAAAAANwoCl0sz6tgDQAA3I+rcjs+Pl4TJ07U3r175efnp86dO2vIkCHy9fXNs8+uXbvUu3fvXLeFhoZqy5Yt9j//+OOPmjt3rg4ePCiDwaBGjRpp+PDhql+/vtPPBQAAAADg2QpdLAcAAJ4tOTlZUVFRCgkJ0bx585SYmKipU6cqPT1dY8eOzbNfgwYNtGrVKoc2s9ms/v37q02bNva2hIQE9evXT61atdLMmTOVmZmpt99+W3369NHGjRsVFBTksnMDAAAAAHieIhXLLRaLNmzYoG+++UanTp2SJFWtWlX33HOPHnroIRmNRqdMEgAAFJ2zc3vlypVKS0vT/PnzFRgYaD/G+PHjNWDAAIeHc1/N399fTZo0cWhbt26drFarw0O6t27dKpvNprlz56p06dKSpPDwcLVt21ZxcXHq0qVLgeYLAAAAAMC1GArbMTU1VU888YTGjBmjuLg4ZWVlKSsrSzt27NDo0aPVo0cPmc1mZ84VAAAUkitye9u2bYqIiLAXyiWpQ4cOslqtiouLK9BYGzduVEhIiBo3bmxvu3Llinx9fR0eRFquXLkCjQsAAAAAQH4V+s7y2bNn68CBA3rllVfUvXt3+fj4SPr7F9uPPvpIkyZN0uzZs/Xqq686bbIAAKBwXJHbCQkJ6tq1q0ObyWRSUFCQEhIS8j3OuXPntHPnTg0cONCh/cEHH9SSJUs0Z84c9enTR5mZmZo1a5aqVKmi++67L9/j58bbu9D3CyAXRqPB/lrQr+3Vfa/ncYGSpijvFQAAAORPoYvlX3zxhZ544gn17NnTod3Hx0c9evRQQkKCtmzZQrEcAAA34IrcTklJkclkytEeEBCg5OTkfI+zefNmWSwWhyVYJCkkJETLli3Tc889p0WLFkmSqlWrpvfee69Id5gbDF4qX96v0P2Rk8lUxv5a2K9t9hjX+7hASVOY9woAAADyp9DF8osXLyo0NDTP7aGhoQX6RRkAALiOO+d2bGysGjRokGN+R48e1aBBg9S6dWt16dJFGRkZevfdd9W/f3+tXLlSFStWLNTxrFabUlIuOWPq+P9SUi7bXy9cSCtQX6PRIJOpjFJSLstisV634wIlTVHeK3ANk6kMd/oDAHCDKXSx/Oabb9ZXX32V4w61bF999ZVq1qxZ6IkBAADncUVum0wmpaam5mhPTk5WQEBAvsY4ceKE9u/fr9GjR+fYNnv2bFWsWFHTp0+3t7Vo0UL33HOPVqxYoWHDhhVovlfLyqLQ5EzZhTuLxVror21h+jrjuEBJw793AAAA1yn0ZfAnnnhCcXFx6t+/v7Zv364//vhDf/zxh/73v//pmWee0Y4dO/L8hRwAAFxfrsjtsLCwHGuTp6am6uzZswoLC8vXGLGxsTIYDOrYsWOObUeOHFG9evUc2vz8/FSzZk2dOHGiQHMFAAAAAODfFPrO8p49eyopKUnvvPOOtm/f7jiot7eio6PVo0ePIk8QAAAUnStyu02bNlq0aJHD2uVbtmyRwWBQ69at8zXGpk2b1KJFC1WqVCnHtqpVq+q3336TzWaTl5eXJMlsNuv48eNq2bJlgeYKAAAAAMC/KXSxXJIGDRqknj176rvvvtOff/4p6e8Hb0VERKhChQpOmSAAAHAOZ+d2ZGSkYmJiFB0drQEDBigxMVHTp09XZGSkgoOD7ftFRUXp1KlT+uKLLxz6//rrr4qPj1ffvn3zHD86OlojRoxQ586dlZmZqXfffVeZmZl67LHHCjxfAAAAAACupUjFckmqUKGCHnzwQWfMBQAAuJgzczsgIEDLly/XhAkTFB0dLT8/P3Xr1k1Dhw512M9qtcpiseToHxsbK19fX7Vv3z7X8du2bas5c+Zo6dKlGjp0qHx8fHTLLbdoxYoVCgkJcco5AAAAAACQrdDF8h07dmjnzp15Plxr9uzZatWqlSIiIgo9OQAA4Byuyu1atWpp2bJl19wnJiYm1/aRI0dq5MiR1+zboUMHdejQoUBzAgAAAACgMAr9gM8FCxbor7/+ynN7YmKiFi5cWNjhAQCAE5HbAAAAAABcW6HvLD906JAeeOCBPLc3atRIX3/9dWGHByRJ+/fvK3Afo9EgiyVdRmNpWSzWAvU9dOj3Ah8PAEoCchsAAAAAgGsrdLE8MzNTV65cueb29PT0wg4PD5eVlSVJGjZsULEc39/fv1iOCwCuQm4DAAAAAHBthS6W16lTR1988YX69u2bY5vNZtPnn3+uWrVqFWly8FzNmt2uLVu+krd3wf+Jxscf1oAB/fT220tVq1adAvf39/dXWFjtAvcDAHdGbgMAAAAAcG2FLpb36tVLI0eO1ODBgxUdHW3/BfvIkSNasGCBfvrpJ02ePNlpE4Xnadbs9kL1Mxr/Xoq/bt1wNWjQ2JlTAoASi9wGAAAAAODaCl0s79y5s06ePKkFCxboiy++kMHwd4HSarXKy8tLAwcO1COPPOK0iQIAgMIjtwEAAAAAuLZCF8sl6fnnn9fDDz+sL774QidPnpQk1axZU23btlXNmjWdMkEAAOAc5DYAAAAAAHkzFHWAmjVrql+/fnryyScVFBSkEydO6JtvvpHZbHbG/AAAgBOR2wAAAAAA5K5Ad5b/97//VUxMjD788ENVqFDB3v71119r8ODBysrKks1mkyTFxMRo1apVDvsBAIDrh9wGAAAAACD/CnRn+VdffaUaNWo4/CKdlZWll19+WUajUZMnT1ZsbKyGDx+uU6dOadGiRU6fMAAAyB9yGwAAAACA/CtQsfzIkSNq0qSJQ9uuXbuUlJSkqKgoPfLII6pTp4769++vBx54QN9++60z5woAAAqA3AYAAAAAIP8KVCy/ePGiKleu7ND23XffycvLS+3atXNob9asmf76668CTyg+Pl59+/ZVkyZN1Lp1a02fPl2ZmZn56puYmKiRI0eqVatWaty4sTp06KANGzY47HPo0CENGDBArVq10u23366ePXtq586dBZ4nAADu7nrkNgAAAAAAN4oCrVlesWJFnTt3zqHtxx9/VOnSpVWvXj2Hdl9fX/n4+BRoMsnJyYqKilJISIjmzZunxMRETZ06Venp6Ro7duw1+545c0aPP/64QkNDNWHCBPn7++vw4cMOhfakpCT16dNHNWrU0KRJk+Tj46OYmBj1799fa9asUXh4eIHmCwCAO3N1bgMAAAAAcCMpULG8YcOGWr9+vXr16mUvRv/888+677775O3tOFRCQkKOu9n+zcqVK5WWlqb58+crMDBQkmSxWDR+/HgNGDBAwcHBefZ94403VLlyZS1ZskRGo1GSFBER4bDPd999p/Pnz2v16tWqXr26JKlFixZq0aKFtm7dSrEcAHBDcXVuA/+0f/++AvcxGg2yWNJlNJaWxWItUN9Dh34v8PEAAAAAIC8FKpZHR0erW7duat++vWrXrq0DBw7Iy8tLzzzzTI59v/jiC7Vq1apAk9m2bZsiIiLshXJJ6tChg1577TXFxcXp0UcfzbWf2WzWp59+qsmTJ9sL5bm5cuWKJKlcuXL2tlKlSsnHx0c2m61AcwUAwN25OreBbFlZWZKkYcMGFcvx/f39i+W4AAAAAG4sBSqWh4eHa/ny5Vq0aJFOnjypW2+9Vf369VPDhg0d9tu1a5fKlCmjBx54oECTSUhIUNeuXR3aTCaTgoKClJCQkGe/AwcO6MqVK/L29lavXr20d+9eBQYGqkuXLhoyZIj9Y+X33HOPKlasqKlTp2ro0KHy9vbWu+++Ky8vL3Xu3LlAc/0nb+8CLf8OFzIYvOyv/L0AeTMaDQ6vuPG4OreBbM2a3a4tW77K8YmF/IiPP6wBA/rp7beXqlatOgXu7+/vr7Cw2gXuBwAAAAD/VODfaJo1a6Z33nnnmvu0bNlSsbGxBZ5MSkqKTCZTjvaAgAAlJyfn2S97PdZXXnlF3bt31/PPP6/9+/frzTfflMFg0PDhw+3jvP/++xowYIDuvPNOSVJgYKAWL16sGjVqFHi+2QwGL5Uv71fo/nAuf//S9lf+XoB/ZzKVKe4pwIVcmdvA1Zo1u71Q/bIv2NWtG64GDRo7c0oAAAAAUCAFv/3HDVmtf69veccdd2jUqFGSpFatWiktLU3vvvuuoqOjVbp0aZ0/f17PP/+8atasqTFjxshoNGr16tUaOHCg3n//fdWqVauQx7cpJeWS084HRWM2p9tfL1xIK+bZAO7LaDTIZCqjlJTLBV4nGK5hMpXhTn8AAAAAAIqJWxXLTSaTUlNTc7QnJycrICDgmv0k5VhrNSIiQosWLdLx48cVHh6uJUuWKDk5WevWrZOvr699nwcffFALFizQzJkzCz33rCwKTe7CarXZX/l7Af6dxWLlvQIAAAAAADyeW92+FhYWlmNt8tTUVJ09e1ZhYWF59qtd+9rrVGZkZEiSjhw5orCwMHuhXJKMRqPCw8N14sSJIswcAAAAAAAAAFCSuVWxvE2bNtqxY4dSUlLsbVu2bJHBYFDr1q3z7FetWjXVrVtXO3bscGjfsWOHSpcubS+mV61aVfHx8fbiuSRZLBYdPHhQ1apVc/LZAAAAAAAAAABKCrcqlkdGRsrPz0/R0dHavn271q5dq+nTpysyMlLBwcH2/aKiotSuXTuHvkOHDtVXX32lSZMmKS4uTosWLdK7776rPn36qGzZspKkxx57TBcuXNBzzz2nr776St9++60GDRqk48ePq2fPntf1XAEAAAAAAAAA7sOt1iwPCAjQ8uXLNWHCBEVHR8vPz0/dunXT0KFDHfazWq2yWCwObffee69mzZqlBQsW6MMPP1SlSpU0aNAgPfPMM/Z9GjZsqCVLlmjBggUaPXq0rFarateurXfeeUfNmze/LucIAAAAAAAAAHA/blUsl6RatWpp2bJl19wnJiYm1/aOHTuqY8eO1+wbERGhiIiIwk4PAAAAAAAAAHADcqtlWAAAAAAAAAAAKA4UywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PIrlAAAAAAAAAACPR7EcAAAAAAAAAODxKJYDAAAAAAAAADwexXIAAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PIrlAAAAAAAAAACPR7EcAAAAAAAAAODxKJYDAAAAAAAAADwexXIAAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PO/ingAAACi54uPjNXHiRO3du1d+fn7q3LmzhgwZIl9f3zz77Nq1S7179851W2hoqLZs2eLQ9s0332jRokU6ePCgfHx8VK9ePb3xxhuqXLmyU88FAAAAAODZKJYDAIBCSU5OVlRUlEJCQjRv3jwlJiZq6tSpSk9P19ixY/Ps16BBA61atcqhzWw2q3///mrTpo1D+yeffKKXX35ZTz31lIYMGaK0tDT9+OOPysjIcMk5AQAAAAA8F8VyAABQKCtXrlRaWprmz5+vwMBASZLFYtH48eM1YMAABQcH59rP399fTZo0cWhbt26drFarOnXqZG+7ePGiXn/9dY0ZM0Y9evSwt993331OPxcAAAAAAFizHAAAFMq2bdsUERFhL5RLUocOHWS1WhUXF1egsTZu3KiQkBA1btzY3vbpp5/KarWqW7duzpoyAAAAAAB5crs7ywuz9mm2xMREzZo1S99++60uXbqkatWqaeDAgXr44Ycd9vvpp580Z84c7du3T15eXqpdu7bGjx+v+vXru+q0AAC44SQkJKhr164ObSaTSUFBQUpISMj3OOfOndPOnTs1cOBAh/Z9+/YpNDRUH3/8sRYuXKjExETVqVNHw4YN01133VWkuXt7c7+AuzAYvOyv/L0AeTMaDQ6vAAAAcD63KpYXdu1TSTpz5owef/xxhYaGasKECfL399fhw4eVmZnpsN93332nZ555Rl27dlX//v2VlZWl/fv36/Lly648NQAAbjgpKSkymUw52gMCApScnJzvcTZv3iyLxeKwBIsknT17VkePHtXcuXP14osvKigoSO+//76ee+45ffzxx6pTp06h5m0weKl8eb9C9YXz+fuXtr/y9wL8O5OpTHFPAQAA4IblVsXywq59KklvvPGGKleurCVLlshoNEqSIiIiHPbJysrSyy+/rN69e+vFF1+0txf17jQAAFB4sbGxatCggUJDQx3abTabLl26pBkzZtjXKW/RooXat2+vxYsXa/r06YU6ntVqU0rKpSLPG85hNqfbXy9cSCvm2QDuy2g0yGQqo5SUy7JYrMU9HejvCxfc6Q8AwI3FrYrlea19+tprrykuLk6PPvporv3MZrM+/fRTTZ482V4oz82OHTv0559/qnfv3s6eOgAAHsdkMik1NTVHe3JysgICAvI1xokTJ7R//36NHj061/ElqVWrVvY2Hx8fNW/eXIcPHy7krP+WlUWhyV1YrTb7K38vwL+zWKy8VwAAAFzErYrlhV379MCBA7py5Yq8vb3Vq1cv7d27V4GBgerSpYuGDBkiHx8fSX+vfRoYGKiff/5ZvXv31smTJ1WjRg0NHDhQXbp0KdLcWWPTfbD2KZA/rH2KogoLC8uRz6mpqTp79qzCwsLyNUZsbKwMBoM6duyYY1vt2rXz7JeRkVGwyQIA8P/au+/4qKr8/+PvKQkhCQkESOiGRIpSBJQScRGxsKICKxGjNJFepUkTVKT3XqQJRoV1QXcVhUXUHyqICCIRlBYiZQPBEEiY9Cm/P/hmliwJQkiYSeb1fDz2gdx7z72fu+TmM+cz554DAADwJ9yqWF7QuU8TExMlSRMmTFDnzp01ePBgxcTEaNGiRTIajRo5cqSkq3Ofpqena/z48Ro6dKjCw8O1ZcsWjRkzRuXLl9df/vKXAsXN3KfuhblPgVvD3KcoqFatWmnFihW58ve2bdtkNBrVsmXLmzrHZ599pmbNmik4OPi6fY888ogWL16s77//Xo899pgkKSsrSz/++KMeeOCBwrsRAAAAAADkZsXygrLbr76G+OCDD2rs2LGSrr6ynZqaqrVr12rQoEHy8fGRw+FQZmamRo0apa5du0q6Oq/5yZMntWLFigIXy5n79M77/fe4fL9AOXHimCTpp58OKiUl74VbAwMDFRpaM899QHESG3tCFosl3/3x8f/Jd7/RaFDp0t5KT89yToNwLX9/f1WpUjXfc/v7+ys8PP+Rv7h1xW3u06ioKEVHR2vQoEHq16+fEhISNGvWLEVFReVaZ6RHjx6Kj4/XF198kav9r7/+qtjYWPXs2TPP89erV09t27bVxIkTdfnyZVWsWFEffPCBEhMT1atXryK9NwAAAACA53GrYnlB5z7Na05T6WohfMWKFTp16pTq1Klzw+Pef//924qdeQPvnIsXL+qBB+5zfkmSnz59Xs53n8lk0qFDJ1S+fPnCDg+4Y06ePKEWLZq4NIY9e35SWBgFc08VGBio9evXa/LkyRo0aJD8/PwUGRmp4cOH5zrObrfLZrNd1/7TTz+Vt7e32rZtm+81ZsyYoXnz5mnu3LmyWCyqV6+e3nnnHdWpU6fQ7wcAAAAA4Nncqlhe0LlPbzSnqfTfeU1r1ar1p8fA/ZUvX1579hxQSkreI8tNJqNstgyZTD6y2fIuqAcEBFIoR7GXM2J82bJVql0778JhfHy8UlOv/xJSkoxGo/z8Sik1NTPPL5/8/MqoSpUqebY9duyoBg7sc8NR7fAM4eHhWrdu3Q2PiY6OznP7mDFjNGbMmBu29fX11YQJEzRhwoSChggAAAAAwE1xq2J5Qec+rVq1qmrXrq3du3c7p1eRpN27d8vHx8dZTH/ooYfk5eWl3bt3q3bt2rmOq1evXhHdFYrCjaZQMZuNKlfOT5cupTLiHx6hdu06atiwUZ778tsu8awAAAAAAABcy62K5bcz9+nw4cM1cOBATZ06Va1bt9Yvv/yitWvXqlevXvL19ZUkVahQQd26ddPChQtlMBgUHh6uzz77TD///LNWr159x+8XAAAAAAAAAOAe3KpYfjtzn7Zp00bz5s3TsmXLtGHDBgUHB2vIkCHq27dvruNGjhwpX19frVmzRklJSQoPD9fSpUv10EMPFfn9AQAAAAAAAADck1sVy6Xbm/u0Xbt2ateu3Q3bms1mDRkyREOGDCloiAAAAAAAAACAEsbo6gAAAAAAAAAAAHA1iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PHMrg4AAAAAADzByZMnZLFY8t0fHx+v1NQree4zGo3y8yul1NRM2e326/b7+ZVRlSpV8j23v7+/wsLuvvWgAQAAPAjFcgAAAAAoYidPnlCLFk1cGsOePT9RMAcAALgBiuUAAAAAUMRyRpQvW7ZKtWvXyfOYohpZfuzYUQ0c2OeGo9oBAABAsRwAAAAA7pjateuoYcNGee7Lb7skmc1GlSvnp0uXUmW1Xl8sBwAAwO1jgU8AAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PIrlAAAAAAAAAACPR7EcAAAAAAAAAODxzK4OAAAAACXb77/HKSUlOc99sbHHJUnHjh2VzWbP85iAgECFhtYssvgAAAAAQKJYDgAAgCJ08eJFtWjRWHZ73oXwHP369cp3n8lk0qFDJ1S+fPnCDg8AAAAAnNyuWB4bG6spU6bowIED8vPzU4cOHTRs2DB5e3v/aduEhATNmzdPO3fuVFpamqpWraoBAwaoffv2eR4/cOBAffnllxo9erR69cq/gwYAAICCKV++vPbsOZDvyHKTySibLUMmk88NR5ZTKEdJUNHfR96pF2RL/P3WG5uMyswoLeuV9Hyflfx4p15QRX+fW78mAACAh3GrYnlycrJ69Oih0NBQLV68WAkJCZoxY4YyMjL0+uuv37DthQsX9Pzzz6tmzZqaPHmy/P39dfz4cWVlZeV5/M6dO3Xw4MGiuA0AAABc40ZTqJjNRpUr56dLl1Jltd5aARAobl5oVlNVf/lAab8UrP2VAl636v9dGwAAADfmVsXyjRs3KjU1VUuWLFHZsmUlSTabTZMmTVK/fv0UEhKSb9vZs2erUqVKWr16tUwmkyQpIiIiz2OzsrI0depUjRgxQuPHjy/0+wAAAACA/7Vhb5wiX5msWrVq33Jbk8mogDKllVKAkeXHjx/Thhldlff7tgAAAMjhVsXyb775RhEREc5CuSQ9+eSTeuONN7Rr1y49++yzebazWCzaunWrpk2b5iyU38iaNWsUEBCgZ599lmI5AAAAgDviD0uGsvyCZaoQesttzWajSpXzk9knVbrFtzCy4i/rD0vGLV8TAADA07hVsfzkyZPq1KlTrm0BAQGqWLGiTp48mW+7w4cPKzs7W2azWV27dtWBAwdUtmxZdezYUcOGDZOXl5fz2Pj4eK1cuVLvvPOODAZDocVuNhsL7Vy4PSaTMdefQEl17c96QX4H3c6zcrvXBgAAAAAAcDduVSxPSUlRQEDAddsDAwOVnJz3olCSlJiYKEmaMGGCOnfurMGDBysmJkaLFsyb9ikAAD5aSURBVC2S0WjUyJEjncdOnz5djz/+uBo1alRocRuNBpUr51do50PhCAgo7eoQgCIVEFBaFf19VM5xWb4ZCQU6R2aqVKoA7co5Lquiv48CAkrz+w8AAAAAAJQIblUsLyi7/epriA8++KDGjh0rSWrRooVSU1O1du1aDRo0SD4+Pvruu+/03Xffadu2bYV8fYdSUtIK9ZwoOJPJqICA0kpJufX5HIHiJCUlXS80q6kyu9fqP7vv7LXL6OpCYSkp6bp0KfXOXrwECwgozVsxAAAAAAC4iFsVywMCAnTlyvVrvCcnJyswMPCG7aSrBfJrRUREaMWKFTp16pTq1KmjKVOmqHv37ipdurRSUlKcx2VmZuY7qv1mWW9x3kAUPZvNzr8LSjSbze76hcJ4zgAAAAAAQAnhVsXysLCw6+Ymv3Lliv744w+FhYXl2+7uu+++4XkzMzMlSXFxcVqxYoVWrFiRa//ChQu1cOFCxcTEqFSpgkxIAACuwUJhAAAAAAAAhcOtiuWtWrXSihUrco3y3rZtm4xGo1q2bJlvu6pVq6p27dravXu3unbt6ty+e/du+fj4OIvp77777nVtu3fvrqioKLVr1y7XQqAAAAAAAAAAAM/hVsXyqKgoRUdHa9CgQerXr58SEhI0a9YsRUVFKSQkxHlcjx49FB8fry+++MK5bfjw4Ro4cKCmTp2q1q1b65dfftHatWvVq1cv+fr6SpKaN2+e53Vr1KiR7z4AAAAAAAAAQMnnVsXywMBArV+/XpMnT9agQYPk5+enyMhIDR8+PNdxdrtdNpst17Y2bdpo3rx5WrZsmTZs2KDg4GANGTJEffv2vZO3AAAAAAAAAAAohtyqWC5J4eHhWrdu3Q2PiY6OznN7u3bt1K5du1u63tGjR2/peAAAAAAAAABAyWN0dQAAAAAAAAAAALgaxXIAAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAQIHFxsaqZ8+eatSokVq2bKlZs2YpKyvrhm1++OEH1alTJ8///fWvf82zjd1u17PPPqs6depo27ZtRXErAAAAAAAP53YLfAIAgOIhOTlZPXr0UGhoqBYvXqyEhATNmDFDGRkZev311/NtV69ePf3973/Ptc1isahPnz5q1apVnm02btyohISEQo0fAAAAAIBrUSwHAAAFsnHjRqWmpmrJkiUqW7asJMlms2nSpEnq16+fQkJC8mzn7++vRo0a5dr20UcfyW636+mnn77u+KSkJC1cuFCjR4/W+PHjC/s2AAAAAACQxDQsAACggL755htFREQ4C+WS9OSTT8put2vXrl23dK4tW7YoNDRUDRs2vG7fvHnz1Lx5czVv3vx2QwYAAAAAIF+MLAcAAAVy8uRJderUKde2gIAAVaxYUSdPnrzp8yQmJmrPnj0aMGDAdftiYmK0ZcsWbdmy5bbjvZbZzHgBd2EyGXP9CZRU1/6sF+R30O08K7d7bQAAAE9BsRwAABRISkqKAgICrtseGBio5OTkmz7P559/LpvNdt0ULHa7XZMmTVLPnj1VrVo1nT179rZjliSj0aBy5fwK5VwoPAEBpV0dAlCkcn7GAwJK39bvoII8K4V1bQAAgJKOYjkAAHCpTz/9VPXq1VPNmjVzbf/HP/6hxMRE9e3bt1CvZ7c7lJKSVqjnRMGZTEYFBJRWSkq6bDa7q8MBikxKSrrzz0uXUm+5/e08K7d7beQtIKA0b8UAAFDCUCwHAAAFEhAQoCtXrly3PTk5WYGBgTd1jtOnTysmJkbjxo3LtT01NVXz5s3T8OHDlZ2drezsbFksFklSRkaGLBaL/P39Cxy71UpR1t3YbHb+XVCi5RS4b/dnvSDtC+vaAAAAJR3FcgAAUCBhYWHXzU1+5coV/fHHHwoLC7upc3z66acyGo1q165dru2XLl3S5cuX9cYbb+iNN97ItW/MmDGqUKHCLS8iCgAAAADAjVAsBwAABdKqVSutWLEi19zl27Ztk9FoVMuWLW/qHJ999pmaNWum4ODgXNsrVqyod999N9e2xMREjRgxQkOGDNGDDz5YODcBAAAAAMD/oVgOAAAKJCoqStHR0Ro0aJD69eunhIQEzZo1S1FRUQoJCXEe16NHD8XHx+uLL77I1f7XX39VbGysevbsed25S5UqpebNm+falrPA5913360mTZoUwR0BAAAAADwZq5EAAIACCQwM1Pr162UymTRo0CDNnTtXkZGRGjt2bK7j7Ha7bDbbde0//fRTeXt7q23btncqZAAAAAAA8sXIcgAAUGDh4eFat27dDY+Jjo7Oc/uYMWM0ZsyYm75WtWrVdPTo0VsJDwAAAACAm8bIcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8s6sDAAAAAABPERNzsEDtTCajbLYMmUw+stnst9T22LGjBbomAACAp6FYDgAAAABFzGq1SpJGjBjishj8/f1ddm0AAIDigGI5AAAAABSxJk0e0LZtX8lsLlgXLDb2uPr166W3316j8PBat9ze399fYWF3F+jaAAAAnsLtiuWxsbGaMmWKDhw4ID8/P3Xo0EHDhg2Tt7f3n7ZNSEjQvHnztHPnTqWlpalq1aoaMGCA2rdvL0mKiYnRhg0btG/fPl24cEEhISFq27atBgwYIF9f36K+NQAAAAAerEmTBwrc1mS6utxU7dp1VK9ew8IKCQAAANdwq2J5cnKyevToodDQUC1evFgJCQmaMWOGMjIy9Prrr9+w7YULF/T888+rZs2amjx5svz9/XX8+HFlZWU5j9m6datOnTql3r17KzQ0VCdOnNCiRYt08OBBvfvuu0V9ewAAAAAAAAAAN+VWxfKNGzcqNTVVS5YsUdmyZSVJNptNkyZNUr9+/RQSEpJv29mzZ6tSpUpavXq1TCaTJCkiIiLXMX369FFQUJDz782bN1dAQIBGjRqlQ4cOqX79+oV/UwAAAAAAAAAAt2d0dQDX+uabbxQREeEslEvSk08+Kbvdrl27duXbzmKxaOvWrXrxxRedhfK8XFsoz3HvvfdKujoyHQAAAAAAAADgmdxqZPnJkyfVqVOnXNsCAgJUsWJFnTx5Mt92hw8fVnZ2tsxms7p27aoDBw6obNmy6tixo4YNGyYvL6982+7fv1+SFBYWdluxm81u9b2DR8uZzzHnT6CkuvZnvSC/g27nWbndawMAAAAAALgbtyqWp6SkKCAg4LrtgYGBSk5OzrddYmKiJGnChAnq3LmzBg8erJiYGC1atEhGo1EjR47Ms11SUpIWL16sRx99VKGhoQWO22g0qFw5vwK3R9EICCjt6hCAIpXzMx4QUPq2fgcV5FkprGsDAAAAAAC4C7cqlheU3W6XJD344IMaO3asJKlFixZKTU3V2rVrNWjQIPn4+ORqk52drREjRkiS3nzzzdu8vkMpKWm3dQ4UHpPJqICA0kpJSZfNZnd1OECRSUlJd/556VLqLbe/nWfldq+NvAUElOatGAAAAAAAXMStiuUBAQG6cuXKdduTk5MVGBh4w3bS1QL5tSIiIrRixQqdOnVKderUcW53OBwaP368YmJi9MEHHyg4OPi2Y7daKcq6G5vNzr8LSrScAvft/qwXpH1hXRsAAAAAAMBduFWxPCws7Lq5ya9cuaI//vjjhnOK33333Tc8b2ZmZq6/z5w5U1u3btWqVatUt27dggcMAAAAAAAAACgR3KpY3qpVK61YsSLX3OXbtm2T0WhUy5Yt821XtWpV1a5dW7t371bXrl2d23fv3i0fH59cxfSVK1dq3bp1mjNnjiIiIoruZgDgDomJOVigdiaTUTZbhkwmn1uehuXYsaMFuiYAAAAAAIC7cqtieVRUlKKjozVo0CD169dPCQkJmjVrlqKiohQSEuI8rkePHoqPj9cXX3zh3DZ8+HANHDhQU6dOVevWrfXLL79o7dq16tWrl3x9fSVJn376qebOnav27durWrVq+vnnn53ta9SooaCgoDt2rwBwu6xWqyRpxIghLovB39/fZdcGAAAAAAAoTG5VLA8MDNT69es1efJkDRo0SH5+foqMjNTw4cNzHWe322Wz2XJta9OmjebNm6dly5Zpw4YNCg4O1pAhQ9S3b1/nMbt27ZIkffLJJ/rkk09ytZ8+fbqeffbZIrozACh8TZo8oG3bvpLZXLBf5bGxx9WvXy+9/fYahYfXuuX2/v7+Cgu78TRYAAAAAAAAxYXB4XA4XB1EcWez2ZWUlOrqMPB/zGajypXz06VLqSw8CNzA4cMxeuSRh/T119+pXr2Grg4HkoKC/GQyGV0dRolH3nYv5G3g5pC33Q95GwCAkofMDgAAAAAAAADweG41DQsAoHD9/nucUlKS89wXG3tc0tXFOvNa4DMgIFChoTWLND4AAPBf5G0AAADXYhqWQsDr3O6F17mBqy5evKh69cJltxfsOTCZTDp06ITKly9fyJEhP7zOfWeQt90LeRu4irxd/JC3AQAoeRhZDgAlVPny5bVnz4F8R6iZTEbZbBkymXzyHaFGhxsAgDuDvA0AAOB6FMsBoAS70evYjOYEAMC9kLcBAABci3fGAAAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8g8PhcLg6iOLO4XDIbuf/RndiMhlls9ldHQbg9nhW3IvRaJDBYHB1GCUeedv98LsIuDk8K+6FvA0AQMlDsRwAAAAAAAAA4PGYhgUAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHAAAAAAAAAHg8iuUAAAAAAAAAAI9HsRwAAAAAAAAA4PEolgMAAAAAAAAAPB7FcgAAAAAAAACAx6NYDgAAAAAAAADweBTLAQAAAAAAAAAej2I5AAAAAAAAAMDjUSwHipDNZnN1CAAA4CaRtwEAAADPRrEcKGQ2m01paWmSJJPJJEk6d+6cK0MCAAD5IG8DAAAAyEGxHChk3377rUaNGqXExERJUu/evTV69GhlZma6ODKg+LPb7Te1DQBuFnkbKDrkbQAAUNyYXR0AUNIEBQUpLi5Ozz//vGrUqKFTp05pwYIFKlWqlKtDA4o1q9Uqs9msrKws/fbbb/Lz81OVKlXk6+sru90uo5HvfwHcOvI2UDTI2wAAoDgyOBwOh6uDAEqamJgYdenSRQaDQQsWLFCbNm1cHRJQrDkcDhkMBlksFvXu3VtxcXEymUy65557NGPGDFWsWFE2m805hQIA3AryNlC4yNsAAKC44ut8oJBc+0rphQsXVKVKFVWsWFFTp07Vf/7zn+uOAXBzbDabDAaDbDab3njjDXl7e2vSpEnq0qWLzp8/r86dOyshIUEmk4nF+QDcNPI2UDTI2wAAoDhjZDlQCK4dGZOUlKSgoCAlJCTo1KlTmjx5stLS0rR+/XpVq1bNOdIm508Afy4zM1M//fSTNmzYoKioKD344IOSrs41PGvWLF2+fFmbNm1SSEgII9UA/CnyNlC0yNsAAKC4YmQ5cJuu/YA/ZcoUDR48WEeOHFFISIiaNm2qCRMmyNfXVz169NC5c+dkMBiUlZWlpUuXKjY21sXRA8XDoEGD1LNnT508eVJ169Z1bv/LX/6isWPHqmzZsurcubMuXLggk8nEaFAA+SJvA0WPvA0AAIoriuXAbXA4HM4O99ChQ/Xtt9/q8ccfl4+PjyTJYDDogQce0MSJE+Xr66suXbroww8/1MSJE7Vs2TJXhg4UK7NmzVLt2rV14sQJffbZZ8rKynLua9mypcaNG6eyZcuqdevWSkpKYtEwAHkibwN3BnkbAAAUV0zDAhSC5cuXa/PmzZozZ47uvfdeeXt7KzMzU9nZ2fL395ckHTx4ULNnz1ZcXJzKly+vWbNm5RppA+Aqu92eZ6f58uXL6ty5s+x2u1577TU9/PDDuY77+uuvtXXrVk2fPp3XuQHcEHkbKDzkbQAAUJJQLAcKwciRI5WRkaGlS5dKko4fP67Fixfr/Pnzqlevnl566SXdddddysrK0smTJxUcHKygoCAXRw24H6vVKrPZrKysLB05ckQXLlxQvXr15OPjo3LlyikpKUmRkZHy8vLSmDFj1Lp16zw76Mx/CuBGyNtA4SBvAwCAksbs6gCA4sxms8lms0mSUlJS9MEHHygpKUmrVq1S3bp1VbNmTf39739X6dKlNXr0aHl7ezMqDciH3W6X2WyWxWLRyy+/rPj4eCUmJqp06dJ66qmn9Pzzz6tBgwbatGmTIiMjNXPmTBmNRrVq1eq6jjcdbgB5IW8DhYe8DQAASiJGlgO3IL9RL99//72mTZumpKQkBQUFqWPHjurVq5ckaezYsYqPj9fq1avl7e19p0MG3JbD4ZDBYMi1LSsrS126dJGfn5969uypsLAwbdq0Sdu2bVOlSpX06quvqn79+kpKSlJUVJQuXryoVatWqUmTJi66CwDujLwNFB7yNgAA8ASMLAdu0rUd7s8//1xJSUkymUxq06aNIiIi9PbbbztHrIWGhkqSkpKSdOHCBYWHhzNiBvgfWVlZKlWqVK7O97Fjx3T+/HlNmTJFrVq1ksFg0PDhw1WtWjWtWrVKH374oapVq6agoCBt3LhRb775pu677z4X3wkAd0TeBgoXeRsAAHgClh0HboLD4XB2mocOHarZs2dr1apVWr16tdq3b68tW7bI19dX1atXd3a4jx8/rjlz5ui3335T165d6XQD1zh8+LB69Oihixcv5hqldv78ef3xxx+qW7euDAaDsrKyJEnPPfec/vrXv2rLli3KzMyUJAUFBWnRokUymUzOaRUAQCJvA4WNvA0AADwFxXLgJuR0ChYsWKCYmBjNnj1bH374ob788ks1btxYEydO1IkTJ5Qzq9H06dM1ceJE7d+/X++8847Cw8NdGT7gdo4cOaLWrVurfPnyubbfc889CggI0Pr16yVJ3t7ezo733/72N6WlpenIkSPXnY+iFoBrkbeBwkXeBgAAnoJpWIAbuPY104yMDB0+fFhPPvmk7rvvPnl5een06dM6ePCg2rRpowYNGjiPfeSRR1SmTBl16NBB1atXd+UtAG6pU6dOkq4+V6+//rr69OmjWrVqyd/fXxEREfr6668VFhamyMhIeXt7y+FwKC4uThUqVFCFChVcHD0Ad0XeBooGeRsAAHgKRpYD+bDZbLleMzUajYqPj5fdbpeXl5d+//13RUZGqnnz5poyZYpKlSqlNWvWKDExUS1atNCAAQPocAN5uHZd6W+//Va7du3SxIkTFRsbq8DAQA0fPlylS5fW2rVrNXPmTJ09e1ZfffWVVq5cqZo1a+qee+5xYfQA3BV5Gyga5G0AAOBJKJYDebh2rtOuXbtq8uTJstlsqlChgk6dOqXjx4+rc+fOioiI0JQpU1S6dGmdOHFC//73v7Vr1y5JvF4K5CWnmJXT8X788cc1fPhwpaWlaezYsTpx4oRCQ0M1f/581a1bVx999JEee+wxTZo0SV5eXlq7dq2MRiNznQLIhbwNFA3yNgAA8DQGx7VDBQDIZrM5O8xffPGFFi5cqFGjRql169bas2eP+vfvr4yMDD399NOaNm2avL29lZSUpNmzZ+vIkSNavny5KlWq5OK7ANyP1WqV2WxWenq6Nm3apFq1aqlFixaSpE2bNmn9+vXy8fHR9OnTdffddyslJUVpaWk6evSogoODVadOHRmNRud5AEAibwNFhbwNAAA8EZ9agP+R0+H+17/+pR9++EGNGzfWgw8+KElq0KCBhg0bpqVLl8pmsykmJkYJCQn64osvtHv3bkVHR9PhBvJgs9lkNptlsVjUpUsXBQQEyGazqUmTJvL29lZkZKQcDofeffddjRs3TjNmzFB4eLgCAgJyPVN2u50ON4BcyNtA4SNvAwAAT8XIciAPu3btUq9evVS2bFk9//zzGj58uHPf5cuXtXv3bs2aNUsGg0Fms1k1atTQmDFjVLt2bRdGDbi3jIwMvfjiiypbtqxGjx6tsLAweXt7y263y2i8OivYP/7xD0VHR8vX11eTJ09WrVq1XBw1gOKAvA0UPvI2AADwRBTLgXxs3LhRU6dOVVBQkBYtWqT77rsv136LxaILFy7Iz89P/v7+8vPzc1GkQPGwZcsWLViwQEuWLFHdunUlSYcPH9apU6eUnZ2tDh06SLra8V6wYIHatGmjyZMnuzJkAMUIeRsoXORtAADgiXgnDh7v2rlOrxUVFSW73a4FCxZo/fr16tevn+rUqeNs4+/vL39//zsdLlBsOBwOGQwG598vXryojIwM+fn56cyZM/r888+1fPly+fv7KzExUT/++KOmTJmi5557ThUqVFCrVq1cGD0Ad0XeBooGeRsAAICR5fBw13a4//3vfyshIUGlSpVSnTp11KhRI0nSunXrtGLFCrVs2VJ9+/Z1drwB5C/n2bLZbEpPT5e/v79OnjypTp06qVy5cipVqpQuXLigkSNHqmnTpvrhhx80ffp0ffTRR7mesfyKYgA8E3kbKBrkbQAAgKsYWQ6P5XA4nB/mhw4dqn379sloNCoxMVFVq1bVE088oTFjxuill16SJK1YsUImk0kvvfSS7r33XhdGDrg3q9Uqs9ms1NRUTZ06VYGBgXrppZcUFhamDRs26O9//7tq1qyppk2b6p577pEkHTx4UOHh4QoKCsp1LjrcAHKQt4GiQd4GAAD4L4rl8EjXLkw0f/58xcTEaMGCBbr33nt16dIlLV++XFu2bFFWVpYmTpyol156SWazWVOmTJG3t7def/11eXt7u/guAPdjt9tlNptlsVjUuXNnlS9fXk2bNlVgYKAkqW7dunrjjTecx2dnZ+v06dP6+OOPddddd6lChQquCh2AGyNvA0WDvA0AAJAbxXJ4jCtXrmjYsGGaP3++AgICnNsPHz6spk2bqnHjxvLy8pK/v7+GDx8uX19fffnll2rWrJnatm2rrl27ysvLS82aNaPDDeTDaDQqOztbr7zyioKDgzV58mRVrlxZZrNZWVlZkuR8fi5duqQNGzbou+++U3p6utavXy+DwZCrKAbAc5G3gaJH3gYAAMiNTzXwCBaLRZ06dVJycrKsVqukq69zp6Wl6eTJkypdurS8vLxks9lks9lUsWJF9erVS5mZmfr555+d53n++edVs2ZNF90FUDwkJSXp3LlzeuaZZ1S9enWZzWZ9/fXXeuONN9SnTx9t375dknTkyBHt3r1b1atX1z/+8Q+ZzWZZrVY63ADI28AdRN4GAAD4L0aWo8SzWCzq0KGDqlWrptmzZzvnVjQYDPL19VWbNm306aefKjIyUg0bNpTNZpPD4VDlypVVq1Yt/f777669AaCYSUtL0+nTp3Xx4kXt2LFD33//vd5//33df//9ysrK0ogRI/TBBx8oIiJCYWFhCg4OlsFgkM1mk9lMWgI8HXkbuLPI2wAAAP/FMACUaKmpqerQoYPCwsI0c+ZMBQcHy263S7o6R6PNZlPbtm1VsWJFzZ8/X7/++qtMJpMMBoMuXryoK1euMCINuAGbzXbdtpo1a6p///6aN2+eJk2apN27d2vJkiV67733tGDBApUtW1YHDx6UJIWEhDhf4WZRMADkbaBokbcBAABujKEAKLHsdrvmzp2r//znP5o7d64qVaqk7OxseXl5OUfJPP/88/rLX/6iF154Qe+//76GDh2q3r17y2az6aefftKZM2c0Z84cV98K4JasVqvMZrMyMzO1d+9eJScnq1q1arrvvvs0ePBgtWjRQmXKlFGZMmVUpUoVSVJycrL8/f0VHByc61y8wg2AvA0ULfI2AADAnzM4HA6Hq4MAioLdbteuXbu0cOFCJSUlac2aNapZs6YyMjLUqVMneXl5aeXKlc4P/9u3b9eWLVu0Y8cOVaxYUZUrV9abb76punXruvhOAPeTs5iXxWLRCy+8oKysLJ09e1aVKlVSlSpVtHz5cvn7+zuPT09P1++//65JkybJZDLp3XffZUQagFzI20DRIW8DAADcHIrlKNEcDof279+vyZMny2KxaOXKlRoxYoRKly6tBQsWqFKlSnI4HDIYDM428fHx8vX1ldlsztVpAJBbVlaWevXqJYPBoFGjRqlChQo6deqU+vTpo/r162v16tXy9/dXamqq3nzzTZ04cUKlSpVSdHS0c2E+Ot4ArkXeBooOeRsAAODP8f4cSjSDwaD7779fEydOVJkyZfTUU09JklatWqVKlSo5j7n2O6MqVaqobNmydLiBP3H8+HGdP39ePXv2VP369VWlShVduHBBkvTII484nyFvb281bNhQbdq00fvvvy8vLy9ZrVY63ACuQ94Gig55GwAA4M9RLEeJl9PxHjt2rJo1a6akpCRdvnxZkpyLhl07Qg1A3nIWBUtPT5ckpaSkKDExUdWqVZPRaNQnn3yiMWPGaOjQoerXr5+uXLni7GR369ZNQ4YMkclkks1mk9nMkhkA8kbeBgoHeRsAAODWUSyHRzAYDGrWrJmGDBmioKAg9ejRQ6dPn5bRaBQzEQF/zuFwyGQyyWKx6MUXX9TOnTtVtWpV2Ww2HT9+XN9//71Gjx6tYcOGqW/fvnI4HPr222/17bffKi4uLte5GJkG4M+Qt4HbQ94GAAAoGIrl8BhGo1EPPPCA89Xul156SWfOnLnudW4AuVmtVhkMBtlsNk2dOlWBgYEKCQlR5cqV1aFDB02YMEE9e/bUxIkT1b9/f0lSXFycoqOjVa5cOYWGhrr2BgAUS+RtoGDI2wAAAAVHsRwlwrWd5ht1oK+dC7VcuXJq3769zp49y+vcwA2YzWalp6dr7969SktLU1RUlOrUqSMvLy916NBBjRs3VmBgoLy9vZWQkKDt27dr7NixyszM1OTJkylsAbgOeRsoOuRtAACAgjM4+CSEYs5ms+X5eqjD4ci3M+1wOLRnzx4tWbJE06ZN01133VXUYQLF2tSpUxUdHa2AgAAtX75c999/v3Pfvn379Mknn+jjjz+Wr6+vKlSooBo1amjRokXy8vLK9xkF4JnI20DRI28DAAAUDMVyFGt2u11G49UXJFauXKmzZ8+qWrVqevTRRxUeHp5r//9yOBzKzMyUj4/PnQwZKBasVmuuxbzS09M1depUbdq0ST179tTAgQNVpkyZXMf/5z//0R9//KHy5cvrrrvuktFovO48ADwbeRsoGuRtAACAwkGxHCXCqFGjtGfPHpUrV05XrlyR2WzWzJkzdf/999+w4w0gf2lpafruu+/0xBNPSJIyMjI0btw4/b//9/80adIkPfHEE86iVV7PGc8egPyQt4HCR94GAAC4fXwaQrF07Xc8Z86cUUJCghYtWqSPP/5YkyZNUpUqVdSvXz/t3btXRqNRdrvdhdECxYfNZpN09Rn7+OOPNXToUH322WeSJB8fH82YMUMtW7bUpEmTtH37dmVkZEhSnp1rOtwAcpC3gaJB3gYAAChcfCJCsWOz2ZxzmmZnZ8tgMCggIEC1atWS2WzWww8/rKFDh6pevXoaOHCgfvzxRzrewE3ImaM0NTVVCxYs0G+//SZJGj16tD7++GNJUqlSpTR37lxFRETorbfe0o4dO5Senu7KsAG4OfI2UDTI2wAAAIWPaVhQrFy7+NeUKVN07NgxJSQkyNfXV2vXrlW5cuWcx+7bt0+LFy/W0aNHNW/ePD344IOuChsoNtLT09WxY0dVqVJFrVq1kiT9+9//1sGDB/XWW2/pueeekyRlZmbq1Vdf1fbt27VmzRq1bNnSlWEDcFPkbaBokbcBAAAKF8VyFBvXzqP45ptvavv27Xr44YcVFxenn3/+Wd27d1f//v0VFBTkbLNv3z5NmzZNly5d0tatW1WqVClnpx3Af+UUtNatW6f169dr9erVCg8PlyT9/vvvWr16tTZv3qxp06bpb3/7m6Src6EuW7ZMQ4cOZTEwANchbwNFh7wNAABQNPiUhGIjp8OdlJQki8Wi6dOnq1WrVjIYDBo3bpw+//xz+fj46KWXXnJ2vB944AFNnDhRISEhzgWNAFwvpxiVlZWlrKwsBQQEOPeFhoaqd+/eOnbsmF577TV5eXnp6aeflo+Pj0aMGCFJslqtdLwB5ELeBooOeRsAAKBoMGc5ipWpU6fqqaee0tGjR1WlShVnR2H69Ol6+OGHtXnzZq1bt05JSUnONo0bN1aVKlVcFTJQrAQEBCgzM1Pnzp2TJOecwaGhoXrsscdkt9s1atQo7dixQ9J/F+2jww0gL+RtoGiRtwEAAAoXxXIUK61bt1ZwcLDi4uIUHx8vh8Mhm80m6WqHvHXr1vrXv/6lZcuW6dKlSy6OFnBfOc/N/3ruuedUuXJlTZ06VRaLxTkyNEfnzp317LPPavr06Tp37hzTIwC4IfI2UDjI2wAAAHcGxXK4rZyRMddq2rSpJkyYoJCQEC1ZskT/+c9/ZDKZnMdOnTpVjRs31nfffSem4wfyZrVaZTKZlJ6erk2bNmnRokX6+uuvdeTIEZlMJr3xxhs6e/asXn75ZR04cEDnz5/X0aNH9dVXX6lq1apq1aqVkpKSdP78eVffCgA3Qt4GigZ5GwAA4M5hgU+4JZvNJpPJJEm6cOGCsrOzFRgYKH9/f0nS3r17NWrUKFWtWlVz5sxR1apVcy0kduHCBQUHB7ssfsBd5TwnFotFnTt3VlZWlhwOh65cuaLatWsrMjJSHTt21L59+zR58mRnYcvLy0tBQUH65JNPtGfPHg0fPlzLli1T48aNXX1LANwAeRsoGuRtAACAO4tiOdzOtZ3nSZMm6ccff9S5c+cUFBSkvn376pFHHlGFChX+tOMNIG9Wq1WDBw9WRkaGxo8fr9q1a+v06dN65ZVXdPr0aW3evFmhoaGyWq36+OOPdeXKFfn7+ysyMlJGo1GDBw/WqVOntH79eueifAA8F3kbKFrkbQAAgDuHYjnc1qhRo7R//351795dXl5e2r9/v7Zu3aouXbqoT58+qlSpkvbu3atx48apdOnSWrVqlSpXruzqsAG343A4cs1RmpycrKioKHXr1k2RkZHy9vbWjh07NGTIEI0ePVo9e/ZUVlaWvL29c53nxx9/VHR0tPbs2aN3331XdevWvdO3AsCNkbeBwkHeBgAAcB2G8sAtHT58WD/99JNGjRqlnj17qmvXrpo/f76GDRum999/X1u2bJEkNWnSRJMnT5aU/8JHgKfKzMyUzWZTWlqac5vNZtOFCxcUFxen8PBweXt761//+pcGDx6sYcOGqWfPnkpNTdUHH3yguLg4Z7uEhAQdOnRIly5d0nvvvUeHG0Au5G3g9pG3AQAAXM/s6gDg2dLT0/X222/r6aef1t133+3cnpSUpPj4eOe27OxseXl5qX///kpISNDbb7+tZ555RiEhIYqIiNCmTZvk4+PjqtsA3M6RI0e0fv16nTp1SuXKlVPnzp318MMPy2QyKTQ0VPfee68+/fRTnTlzRhMmTNCwYcPUr18/SdJ3332n3bt364EHHnCeLyQkRJ06dVJkZKTKlCnjqtsC4GLkbaBokLcBAADcAyPL4VKfffaZ1q5dqzVr1uQaDVO2bFkFBgZq7969stls8vLyUlZWliSpY8eOyszM1KFDhyRJBoOBDjdwjX379ql79+46efKkjEaj9u7dq/79++vzzz+XJJnNZj300EP68ssvNXHiRA0aNEj9+/eXzWbT77//rvXr18vX11f33ntvrvMGBATQ4QY8HHkbKHzkbQAAAPfByHK4VGRkpJKSkrRx40bZbDb1799fYWFhCg8PV9WqVfXhhx/qvvvu07333uuchzEtLU3+/v4qW7asa4MH3ND+/fudUyD07NlTwcHB+uabbzR79mytWrVKLVq0UFBQkIYMGaIzZ85oz549io+P18GDB/XLL7/o008/VUZGhubMmSOj0cjiewByIW8DhYu8DQAA4F74JAWXyRlx1rdvX0VFRengwYN6++23FRsbK19fX82fP19JSUmaNGmStm/fruzsbMXFxemTTz5RQECAatSo4eI7ANzL6dOn1aVLFz3yyCMaNmyYgoODJUmtWrXS3/72N8XFxclqtUqSvLy8NHPmTHXq1EmxsbHq0qWLPvroI9WoUUObN2+W2WyW1Wqlww3AibwNFC7yNgAAgPsxOBwOh6uDgOex2WwymUySpJUrVyo1NVXr16+X1WpVu3btnCPVjh8/rkGDBikpKUk2m03BwcG6cuWK1qxZo3vuucfFdwG4l9jYWI0bN06JiYmaP3++7rvvPmVlZcnb21vff/+9ZsyYoWeeeUZVqlRRtWrV1LBhQ2fbkydPqlKlSipdurQMBoOsVqvMZl4+AnAVeRsofORtAAAA90OxHC41cuRIHThwQC+//LJ8fX21d+9ebd26VW3btnV2vFNSUvTdd9/p1KlTqlSpkpo2bapq1aq5OnTALcXFxWncuHE6d+6c5s6d61zs6+WXX9bu3btlMpmcRa+HH35YzZo106OPPqrKlSs7O9kOh0MGg8GVtwHATZG3gcJF3gYAAHAvFMvhMkePHlX37t01ZswYPfvss87tS5Ys0fr16/XII484O94Abt7Jkyc1fvx4JSQkaPny5VqwYIGOHTumCRMmqH79+jpy5IgOHTqkjz76SGfPnlXbtm21cOFCV4cNwM2Rt4GiQd4GAABwHxTL4TL79+9Xly5dtGnTJtWvX1+ZmZkqVaqUJOmtt97SBx98oL/97W96+eWXVatWLRdHCxQvOR3vn3/+WeXLl9fatWtVp06dXMckJyfr1KlTqlevnnN6BQDID3kbKDrkbQAAAPfACjC443K+n6lbt64qVKigf/7zn5KkUqVKKTMzU5LUtWtXlSlTRl999ZXee+89ZWdnuypcoFgKCwvT1KlT1bp1a9lsNuezlcNutyswMFANGzZ0vuINAHkhbwNFj7wNAADgHiiWo8j974f5a+dUbNOmjfbs2aPNmzdLknOEWkJCgu677z51795dL7/8sry8vO5cwEAJER4ertGjRys0NFRDhw7Vzz//7NxnNOb+9c8INQA5yNuAa5C3AQAAXI9pWFCk7Ha788P9mjVrFB8frwoVKuipp55SjRo1dPr0aY0YMUJZWVl67LHHNGDAAMXGxio6OloXL17U4sWL6XADebj22fozJ0+e1GuvvaaEhATNnDlTTZs2LeLoABRX5G2gaJC3AQAAigeK5SgyDofDORrtlVde0f79++Xv76/09HQZDAYtWbJE9evXV1xcnBYvXqzvvvtOKSkpKlu2rBwOh9atW6d77rnHxXcBuB+r1Sqz2azMzEwdOnRI1atXV3Bw8A3bxMXFqX///rr77ru1dOnSOxQpgOKEvA0UDfI2AABA8UGxHEXi2tEz+/fv14IFCzRs2DDdc8892r9/v95++20dPnxY7777rho0aKCkpCQlJSXp+++/V2BgoBo3bqzq1au7+C4A92Oz2WQymWSxWNS7d2+VKlVK3bp106OPPpprqoS8nDt3TsHBwby6DeA65G2gaJC3AQAAiheK5ShSc+fOVVpams6fP6/58+fL29tbkvTzzz9rzpw5Onz4sKKjo1W/fn0XRwoUH+np6ercubMqVqyoPn366P7773c+Wzcjp+MOAP+LvA0UPvI2AABA8cECnyhSW7du1fvvv69Lly7l6hQ0atRIo0aNUv369dWzZ0/FxMS4MEqgePnXv/6lzMxMjRgxQi1atJC3t7du5XtPOtwA8kPeBgofeRsAAKD4oFiOImG1WiVJO3bsUEREhH766Sd9+OGHyszMdB7TqFEjvfrqq6pSpYoGDx6srKysW+o4ACXdr7/+qh9++OG67UePHpXRaFT9+vVlMBic8wznPD82m+1OhwqgmCNvA7ePvA0AAFD8USxHofjfD/lms9n53++8844aNmyo+fPn69///reysrKc+xo2bKgpU6Zow4YN8vb2/tO5GwFP4HA4lJmZqV69eungwYO59tntdvn5+clmsykhIUGScnW809PTtWPHDv3xxx+uCB1AMUHeBgoPeRsAAKDkoFiO23btPIqffPKJVq5cqYULF+rChQvOYz788ENVq1ZN06dP17Zt23J1vBs0aKCqVave8bgBd2UwGFSqVCl99tln6tu3rzIzM/XLL79IkoxGo+rVq6czZ87oyy+/dI4Gzel479+/Xxs2bNC5c+dceQsA3Bh5Gyhc5G0AAICSgwU+cVvsdruMxqvfuQwfPly//fabfH19ZTKZFB8frzlz5uiBBx6Ql5eXJOm5557T+fPnNXToUHXo0OGWFjcCPEl2drbzuenWrZtOnz6tmTNnqkWLFpKk119/XR9//LHGjh2rRx99VJUqVdLBgwc1c+ZMlSpVSmvWrHE+mwCQg7wNFA3yNgAAQMlAsRyF4q233tLOnTs1e/ZsNWnSRPPnz9fbb7+tsmXLaubMmWrZsqXzFe+2bdtKkjZv3ix/f39Xhg24lYyMDDkcDpUuXVqSlJWVJW9vb8XGxqpbt26qXLmyRo0apYiICFksFs2aNUsffvihqlSpIrPZLKvVqnLlymnjxo3y8vLKVRQDgGuRt4HbR94GAAAoeSiW47b98ssvmjp1qnr37q3HHntMa9as0bx58zR+/Hh9/fXXOnTokGbPnq3mzZs7R6SdOXNG1atXd3HkgPtIT09XdHS0TCaTevToIbvdrmeeeUavvPKK2rVrp7i4OEVFRalq1aoaM2aMmjdvLknavn27fvvtN6Wlpenuu+/Ws88+K5PJJKvVmmsOYgDIQd4Gbh95GwAAoGSiWI6bZrPZlJycLIPBID8/P2cHOikpSV988YXatWunXbt2afz48XrjjTf0zDPPaNeuXerXr5+qVKmisWPH6pFHHnHOkwogt8WLF2vp0qXq3bu3tm7dquDgYC1cuFBBQUEym825Ot6vvvqqIiIiJMm5SFiOa+cjBuC5yNtA0SJvAwAAlDwUy3FTUlNT9frrr+vIkSNKTk7WX//6V73wwgsKDw+X3W5XVlaWfHx8NHLkSDkcDk2ZMkW+vr6y2+2KjIzU6dOn5e/vr88++0x+fn6uvh3Abb355pvatGmTKlWqpCVLlqhu3bqS/jsXak7Hu1q1anr11Vedc6ECwLXI28CdQd4GAAAoWZgUD3/KYrGoU6dOOnv2rO6//37Vq1dP7733nmbMmKH4+HgZjUb5+PhIkhITE5WYmChfX19J0rFjx1S2bFmtXbtW//jHP+hwA3lwOByyWq2Srk51YDabdfbsWW3fvl0XL16UJHl5eSk7O1s1a9bUxo0bFR8fr7Fjx+rw4cOuDB2AGyJvA0WLvA0AAFByMTEebshisah9+/YKCwvTpEmTVLVqVUnS3LlztWrVKsXFxalKlSqy2+1yOBxq0KCBvvjiCy1dulRNmjTRli1bdOnSJVWrVk1BQUEuvhvA/eS8ep3zOvbSpUvl4+Oj6dOna9myZXI4HOrSpYsqVKggLy8vWa1W1axZ01n4yhnBBgASeRsoauRtAACAko1pWJAvq9WqoUOH6quvvtLu3bsVFBSkrKws55ynLVu2VP/+/dWtWzdnm8uXL2vcuHH66aefZLPZFBAQoKVLl+qee+5x1W0AbitnMa/U1FS9+eabql27ttq1a+csbk2bNk3vvvuuBgwYoG7duikoKEgJCQn68ccf9fTTTzvPw1ynACTyNlDUyNsAAAAlHyPLka/MzEzVr19fMTExeu2117R8+XJ5e3srKytLDodD5cqV06FDhzRhwgQ1b95ctWrVUt26dbVw4UIdPXpUly5dUp06dRQSEuLqWwHcjt1ul9lslsViUVRUlPz9/dWsWTNVrFhRdrtdRqNR48ePl8Ph0PLly3XlyhU98MADWrt2rTIyMvTUU085R7XR4QYgkbeBokTeBgAA8AyMLMcNWSwWbd682fl69ooVKyRJS5Ys0ZIlS1ShQgVlZ2crOTlZpUqVUrt27VSrVi29/PLLLo4ccH/Z2dnq27evsrOzNXPmTIWEhMhsNisrK0teXl7OTvXMmTO1ceNG+fv766677tI777wjLy8vORwO5zEAIJG3gaJE3gYAACj5KJbjT1ksFm3atEnLly9XRESE6tSpo2XLlumtt95SixYtVLFiRe3YsUOHDh3SJ598oszMTP3zn/9U5cqVXR064DYOHDig9PR0Pfjgg85tcXFxGjhwoEaNGqVHH31UkrRz50598sknstlsql+/vnr37i1JiomJcc4vbDQana+CA8D/Im8Dt4+8DQAA4JkoluOm5HS8165dqwsXLmjRokV64oknnK+d5jh//ry8vLxUvnx5F0YLuJesrCwNGTJE4eHhGj16tHN7QkKC2rdvr/bt2+vJJ5/UP//5T3344Ydq1qyZLBaLrly5oldffVVPPPFErvMx1ymAP0PeBgqOvA0AAOC5KJbjpl25ckWbN2/W6tWr1aBBAy1fvlySci0eBiBvycnJCgwMVHp6uo4ePapGjRopOztb77zzjlasWKHSpUurXLlyeuWVV/T4448rNjZWL7zwgkaPHq3IyEhXhw+gGCJvAwVH3gYAAPBMvAuIm1amTBnnh/9ly5apf//+WrFihby9vRkxA/yJwMBASdKcOXP0/vvva82aNWrZsqW6dOmi1q1by2KxqHLlyqpcubJsNpscDodCQkLk6+vr4sgBFFfkbaDgyNsAAACeiZHluGU5r3avWrVKYWFhio6OdnVIgNu6do5Sh8OhU6dOacaMGTpw4IDmzp2rhx56KNfx6enpOnHihKZNmyaHw6H333+fghaA20LeBm4eeRsAAMCzGf/8ECA3f39/RUZGqnv37oqPj9e5c+dcHRLgtsxms9LS0vTNN9/IYDDorrvu0muvvaaGDRtq5MiR2rVrl/NYi8WiZcuWaeLEiZKk6OhomUwm2Ww2V4UPoAQgbwM3j7wNAADg2RhZjgKzWCyyWq0qW7asq0MB3E7OFAd2u12rV6/WvHnztHz5cj3yyCNyOBw6e/as3nrrLcXExGjevHlq2bKl4uPj9emnn8rhcKhPnz4ymUy5RrgBwO0gbwP5I28DAABAolgOAIUup8OdlpamDRs26LffftOWLVskSYsXL9bjjz+eb8f72oX3mFMYAICiR94GAABADorlAFAE0tLS1LFjR1WvXl2NGjWS2WzWxx9/rNOnT2vevHlq166ds+M9ZcoU7dy5Ux9++KEaNmzo6tABAPA45G0AAABIEu8IAkARWL9+vaxWq15//XXdddddkqS//OUvWrlypUaMGCGz2awnnnhC1apV0/jx4xUWFqZ7773XxVEDAOCZyNsAAACQWOATAIpERkaGjEajAgMDndvq16+vPn36qFq1aho6dKh27Nghg8GgGjVqaPTo0TKbzbJarS6MGgAAz0TeBgAAgESxHACKRJkyZXT58mWlpaVJkrKysiRJDRo0UMeOHSVJw4YN05dffimDwSCDwSBJLAoGAIALkLcBAAAgUSwHgNtis9ny3N65c2eVL19eI0eOlCTn4l/S1Q54+/bt9dhjj2nVqlVKTEy8I7ECAODpyNsAAAC4EYrlAFBAVqtVJpNJGRkZ2r59u9atW6edO3fq7NmzCggI0MiRIxUbG6uoqCidOXNGiYmJio2N1b59+9SkSRM99NBD+u2335SUlOTqWwEAoMQjbwMAAODP8N4gABSA3W6X2WyWxWLRiy++qMuXLys1NVWpqalq2rSpunfvrieeeEIGg0Fz5sxRx44dVaZMGVmtVpUrV05RUVHauXOn/Pz8ZLfbXX07AACUaORtAAAA3AyK5QBQAEajUdnZ2Ro4cKDKli2radOmKTQ0VD/++KOWL1+uBQsWyGAw6PHHH1eLFi20efNmXblyRQEBAerataskaePGjapYsaJCQkJcfDcAAJRs5G0AAADcDIPD4XC4OggAKI7Onz+vF198UYMGDdKzzz7rXOzr559/1pQpU+Tr66uZM2eqcuXKudrFxMRozZo12r17t6Kjo1W3bl1XhA8AgEchbwMAAODPMGc5ABTQpUuXFB8fr5CQEBkMBmVnZ0uSGjVqpIEDB2rv3r06efJkrjZnzpzRN998oz/++EPvvfceHW4AAO4Q8jYAAAD+DMVyAPgTNpstz+01a9ZU3bp1tW7dOiUlJcnLy8vZ8W7SpIl8fX11+vTpXG2qV6+uzp07a/ny5apTp06Rxw4AgKchbwMAAKCgKJYDQD5OnTolSTKZTHl2vH18fPToo4/q2LFjeuedd3Tx4kV5eXnJ4XDo1KlT8vPzy3Ne0+DgYAUGBhZ5/AAAeBLyNgAAAG4Xc5YDQB4uXryojh07KjQ0VNHR0ZIkq9Uqs/nqusgOh8M51+no0aP1ww8/6O6771a3bt10/vx5ffzxx7Lb7dq4caNMJpPL7gMAAE9A3gYAAEBhoFgOAHmwWCz64IMPtH79ejVo0EArVqyQlLvjbbPZnB3qpUuX6ssvv9Svv/6qatWqKSwsTEuXLpWXl1eu4wAAQOEjbwMAAKAwUCwHgHxYLBZt2rRJy5cvV+PGjfPseGdnZ8vLy0uSlJ6ervPnz8vX11fBwcEyGAy5jgUAAEWHvA0AAIDbRbEcAG7gZjreVqtVx48fV3x8vCIiIuTr6ytJstvtMhpZGgIAgDuFvA0AAIDbwadBALgBf39/RUZGasCAATpw4ID69+8vSbnmQD106JAGDBigv//97ypdurSzLR1uAADuLPI2AAAAbgcjywHgJuQ3Um3fvn168803ZTQatXnzZuer3QAAwHXI2wAAACgIiuUAcJNyOt7Lli3T/fffr4EDB2rChAmy2+366KOP5OXlxVynAAC4CfI2AAAAbhXFcgC4BRaLRZs3b9bq1av1xx9/qFatWnS4AQBwU+RtAAAA3Ao+HQLALfD391enTp1ksVgUGxurWbNmyWw20+EGAMANkbcBAABwKxhZDgAFkJqaKl9fXxkMBjrcAAC4OfI2AAAAbgbFcgC4DQ6HQwaDwdVhAACAm0DeBgAAwI1QLAcAAAAAAAAAeDyjqwMAAAAAAAAAAMDVKJYDAAAAAAAAADwexXIAAAAAAAAAgMejWA4AAAAAAAAA8HgUywEAAAAAAAAAHo9iOQAAAAAAAADA41EsBwAAAAAAAAB4PIrlAAAAAAAAAACPR7EcAAAAAAAAAODx/j9O+8lcxF5ewwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Results saved to: Downstream/ml_classification_results_250831/\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import datetime\n", + "import numpy as np\n", + "import pandas as pd\n", + "from datasets import load_from_disk\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import (accuracy_score, precision_score, recall_score, \n", + " f1_score, classification_report, confusion_matrix)\n", + "from sklearn.model_selection import StratifiedKFold, cross_val_score\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "import pickle\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from tqdm import tqdm\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Load gene information\n", + "gene_info = pd.read_csv(\"example_input_files/gene_info_table.csv\", index_col=0)\n", + "\n", + "# Create dictionaries for gene mappings\n", + "gene_id_type_dict = dict(zip(gene_info[\"ensembl_id\"], gene_info[\"gene_type\"]))\n", + "gene_name_id_dict = dict(zip(gene_info[\"gene_name\"], gene_info[\"ensembl_id\"]))\n", + "gene_id_name_dict = {v: k for k, v in gene_name_id_dict.items()}\n", + "\n", + "# Load token dictionary (assuming it exists from the original script)\n", + "from geneformer.pretrainer import token_dictionary\n", + "\n", + "def prep_inputs(genegroup1, genegroup2, id_type):\n", + " \"\"\"Prepare gene targets and labels for classification\"\"\"\n", + " if id_type == \"gene_name\":\n", + " targets1 = [gene_name_id_dict[gene] for gene in genegroup1 if gene_name_id_dict.get(gene) in token_dictionary]\n", + " targets2 = [gene_name_id_dict[gene] for gene in genegroup2 if gene_name_id_dict.get(gene) in token_dictionary]\n", + " elif id_type == \"ensembl_id\":\n", + " targets1 = [gene for gene in genegroup1 if gene in token_dictionary]\n", + " targets2 = [gene for gene in genegroup2 if gene in token_dictionary]\n", + " \n", + " targets1_id = [token_dictionary[gene] for gene in targets1]\n", + " targets2_id = [token_dictionary[gene] for gene in targets2]\n", + " \n", + " targets = np.array(targets1_id + targets2_id)\n", + " labels = np.array([0]*len(targets1_id) + [1]*len(targets2_id))\n", + " nsplits = min(5, min(len(targets1_id), len(targets2_id))-1)\n", + " assert nsplits > 2\n", + " print(f\"# targets1: {len(targets1_id)}\\n# targets2: {len(targets2_id)}\\n# splits: {nsplits}\")\n", + " return targets, labels, nsplits\n", + "\n", + "def extract_features_from_cells(dataset, target_genes):\n", + " \"\"\"Extract features from cell data for traditional ML models\"\"\"\n", + " print(\"Extracting features from cell data...\")\n", + " \n", + " # Convert target genes to set for faster lookup\n", + " target_gene_set = set(target_genes)\n", + " \n", + " features = []\n", + " cell_labels = []\n", + " \n", + " for i, sample in enumerate(tqdm(dataset)):\n", + " input_ids = sample['input_ids']\n", + " \n", + " # Check if any target genes are in this cell\n", + " genes_in_cell = set(input_ids) & target_gene_set\n", + " if not genes_in_cell:\n", + " continue\n", + " \n", + " # Create feature vector based on gene expression patterns\n", + " feature_vector = create_feature_vector(input_ids, target_genes)\n", + " features.append(feature_vector)\n", + " \n", + " # Create labels for each target gene present in this cell\n", + " for gene_id in genes_in_cell:\n", + " if gene_id in target_genes:\n", + " cell_labels.append(gene_id)\n", + " \n", + " return np.array(features), cell_labels\n", + "\n", + "def create_feature_vector(input_ids, target_genes):\n", + " \"\"\"Create feature vector from gene expression data\"\"\"\n", + " # Simple features: gene presence/absence and position-based features\n", + " feature_vector = []\n", + " \n", + " # Feature 1: Length of gene sequence\n", + " feature_vector.append(len(input_ids))\n", + " \n", + " # Feature 2-3: First and last gene IDs (normalized)\n", + " if len(input_ids) > 0:\n", + " feature_vector.extend([input_ids[0], input_ids[-1]])\n", + " else:\n", + " feature_vector.extend([0, 0])\n", + " \n", + " # Feature 4: Number of unique genes\n", + " feature_vector.append(len(set(input_ids)))\n", + " \n", + " # Feature 5: Average gene ID (as proxy for gene expression level)\n", + " feature_vector.append(np.mean(input_ids) if input_ids else 0)\n", + " \n", + " # Feature 6-10: Statistical features\n", + " if input_ids:\n", + " feature_vector.extend([\n", + " np.std(input_ids),\n", + " np.min(input_ids),\n", + " np.max(input_ids),\n", + " np.median(input_ids),\n", + " len([x for x in input_ids if x in target_genes]) # Number of target genes\n", + " ])\n", + " else:\n", + " feature_vector.extend([0, 0, 0, 0, 0])\n", + " \n", + " return feature_vector\n", + "\n", + "def create_gene_coexpression_features(dataset, target_genes, max_samples=10000):\n", + " \"\"\"Create gene co-expression features for target genes\"\"\"\n", + " print(\"Creating gene co-expression features...\")\n", + " \n", + " # Sample dataset if too large\n", + " if len(dataset) > max_samples:\n", + " indices = np.random.choice(len(dataset), max_samples, replace=False)\n", + " sampled_dataset = dataset.select(indices.tolist())\n", + " else:\n", + " sampled_dataset = dataset\n", + " \n", + " # Create gene co-occurrence matrix\n", + " gene_cooccurrence = {}\n", + " target_gene_features = {}\n", + " \n", + " for gene in target_genes:\n", + " gene_cooccurrence[gene] = []\n", + " target_gene_features[gene] = {\n", + " 'avg_position': [],\n", + " 'expression_frequency': 0,\n", + " 'coexpressed_genes': set()\n", + " }\n", + " \n", + " total_cells = len(sampled_dataset)\n", + " \n", + " for sample in tqdm(sampled_dataset):\n", + " input_ids = sample['input_ids']\n", + " \n", + " for gene in target_genes:\n", + " if gene in input_ids:\n", + " target_gene_features[gene]['expression_frequency'] += 1\n", + " positions = [i for i, x in enumerate(input_ids) if x == gene]\n", + " target_gene_features[gene]['avg_position'].extend(positions)\n", + " target_gene_features[gene]['coexpressed_genes'].update(input_ids)\n", + " \n", + " # Create feature matrix for target genes\n", + " feature_matrix = []\n", + " gene_labels = []\n", + " \n", + " for gene in target_genes:\n", + " features = [\n", + " target_gene_features[gene]['expression_frequency'] / total_cells, # Expression frequency\n", + " np.mean(target_gene_features[gene]['avg_position']) if target_gene_features[gene]['avg_position'] else 0, # Avg position\n", + " len(target_gene_features[gene]['coexpressed_genes']), # Number of coexpressed genes\n", + " gene, # Gene ID itself as a feature\n", + " ]\n", + " feature_matrix.append(features)\n", + " gene_labels.append(gene)\n", + " \n", + " return np.array(feature_matrix), gene_labels\n", + "\n", + "def evaluate_classifier(classifier, X_train, X_test, y_train, y_test, classifier_name):\n", + " \"\"\"Evaluate classifier and return metrics\"\"\"\n", + " # Fit the classifier\n", + " classifier.fit(X_train, y_train)\n", + " \n", + " # Make predictions\n", + " y_pred = classifier.predict(X_test)\n", + " \n", + " # Calculate metrics\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " precision_macro = precision_score(y_test, y_pred, average='macro', zero_division=0)\n", + " precision_weighted = precision_score(y_test, y_pred, average='weighted', zero_division=0)\n", + " f1_macro = f1_score(y_test, y_pred, average='macro', zero_division=0)\n", + " f1_weighted = f1_score(y_test, y_pred, average='weighted', zero_division=0)\n", + " \n", + " results = {\n", + " 'classifier': classifier_name,\n", + " 'accuracy': accuracy,\n", + " 'precision_macro': precision_macro,\n", + " 'precision_weighted': precision_weighted,\n", + " 'f1_macro': f1_macro,\n", + " 'f1_weighted': f1_weighted\n", + " }\n", + " \n", + " print(f\"\\n{classifier_name} Results:\")\n", + " print(f\"Accuracy: {accuracy:.4f}\")\n", + " print(f\"Precision (Macro): {precision_macro:.4f}\")\n", + " print(f\"Precision (Weighted): {precision_weighted:.4f}\")\n", + " print(f\"F1 (Macro): {f1_macro:.4f}\")\n", + " print(f\"F1 (Weighted): {f1_weighted:.4f}\")\n", + " \n", + " return results, classifier\n", + "\n", + "def cross_validate_classifiers(X, y, target_genes, labels, nsplits=5):\n", + " \"\"\"Perform cross-validation for all classifiers\"\"\"\n", + " \n", + " # Initialize classifiers\n", + " classifiers = {\n", + " 'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1),\n", + " 'Logistic Regression': LogisticRegression(random_state=42, max_iter=1000),\n", + " # 'SVM': SVC(random_state=42, probability=True)\n", + " }\n", + " \n", + " # Initialize results storage\n", + " all_results = []\n", + " \n", + " # Set up cross-validation\n", + " skf = StratifiedKFold(n_splits=nsplits, random_state=42, shuffle=True)\n", + " \n", + " print(f\"Starting {nsplits}-fold cross-validation...\")\n", + " \n", + " for fold, (train_idx, test_idx) in enumerate(skf.split(X, labels)):\n", + " print(f\"\\nFold {fold + 1}/{nsplits}\")\n", + " \n", + " # Split data\n", + " X_train, X_test = X[train_idx], X[test_idx]\n", + " y_train, y_test = np.array(labels)[train_idx], np.array(labels)[test_idx]\n", + " \n", + " # Scale features\n", + " scaler = StandardScaler()\n", + " X_train_scaled = scaler.fit_transform(X_train)\n", + " X_test_scaled = scaler.transform(X_test)\n", + " \n", + " fold_results = []\n", + " \n", + " # Evaluate each classifier\n", + " for clf_name, classifier in classifiers.items():\n", + " try:\n", + " if clf_name == 'SVM':\n", + " # Use scaled features for SVM\n", + " results, trained_clf = evaluate_classifier(\n", + " classifier, X_train_scaled, X_test_scaled, y_train, y_test, clf_name\n", + " )\n", + " else:\n", + " # Use original features for tree-based methods\n", + " results, trained_clf = evaluate_classifier(\n", + " classifier, X_train, X_test, y_train, y_test, clf_name\n", + " )\n", + " \n", + " results['fold'] = fold + 1\n", + " fold_results.append(results)\n", + " \n", + " except Exception as e:\n", + " print(f\"Error with {clf_name}: {str(e)}\")\n", + " continue\n", + " \n", + " all_results.extend(fold_results)\n", + " \n", + " return all_results\n", + "\n", + "def plot_results(results_df):\n", + " \"\"\"Plot comparison of classifier performance\"\"\"\n", + " metrics = ['accuracy', 'precision_macro', 'precision_weighted', 'f1_macro', 'f1_weighted']\n", + " \n", + " fig, axes = plt.subplots(2, 3, figsize=(15, 10))\n", + " axes = axes.flatten()\n", + " \n", + " for i, metric in enumerate(metrics):\n", + " ax = axes[i]\n", + " \n", + " # Create box plot\n", + " data_to_plot = []\n", + " labels_to_plot = []\n", + " \n", + " for classifier in results_df['classifier'].unique():\n", + " classifier_data = results_df[results_df['classifier'] == classifier][metric]\n", + " data_to_plot.append(classifier_data)\n", + " labels_to_plot.append(classifier)\n", + " \n", + " ax.boxplot(data_to_plot, labels=labels_to_plot)\n", + " ax.set_title(f'{metric.replace(\"_\", \" \").title()}')\n", + " ax.set_ylabel('Score')\n", + " ax.tick_params(axis='x', rotation=45)\n", + " \n", + " # Remove empty subplot\n", + " axes[-1].remove()\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "def main():\n", + " # Load dosage sensitive TF data\n", + " print(\"Loading dosage sensitive TF data...\")\n", + " dosage_tfs = pd.read_csv(\"example_input_files/gene_classification/dosage_sensitive_tfs/dosage_sens_tf_labels.csv\", header=0)\n", + " sensitive = dosage_tfs[\"dosage_sensitive\"].dropna()\n", + " insensitive = dosage_tfs[\"dosage_insensitive\"].dropna()\n", + " targets, labels, nsplits = prep_inputs(sensitive, insensitive, \"ensembl_id\")\n", + " \n", + " # Load training dataset\n", + " print(\"Loading training dataset...\")\n", + " train_dataset = load_from_disk(\"Genecorpus-30M/genecorpus_30M_2048.dataset\")\n", + " \n", + " # Subsample dataset for efficiency\n", + " shuffled_train_dataset = train_dataset.shuffle(seed=42)\n", + " subsampled_train_dataset = shuffled_train_dataset.select([i for i in range(50_000)])\n", + " \n", + " # Extract features\n", + " print(\"Extracting features for classification...\")\n", + " X, gene_labels = create_gene_coexpression_features(subsampled_train_dataset, targets, max_samples=10000)\n", + " \n", + " # Create binary labels (0 for sensitive, 1 for insensitive)\n", + " y = []\n", + " for gene_id in gene_labels:\n", + " if gene_id in [token_dictionary.get(gene, -1) for gene in sensitive if token_dictionary.get(gene) is not None]:\n", + " y.append(0) # Sensitive\n", + " else:\n", + " y.append(1) # Insensitive\n", + " \n", + " y = np.array(y)\n", + " \n", + " print(f\"Feature matrix shape: {X.shape}\")\n", + " print(f\"Labels distribution: {np.bincount(y)}\")\n", + " \n", + " # Perform cross-validation\n", + " all_results = cross_validate_classifiers(X, y, targets, y, nsplits=nsplits)\n", + " \n", + " # Convert results to DataFrame\n", + " results_df = pd.DataFrame(all_results)\n", + " \n", + " # Calculate and display summary statistics\n", + " print(\"\\n\" + \"=\"*60)\n", + " print(\"CROSS-VALIDATION SUMMARY\")\n", + " print(\"=\"*60)\n", + " \n", + " summary_stats = results_df.groupby('classifier').agg({\n", + " 'accuracy': ['mean', 'std'],\n", + " 'precision_macro': ['mean', 'std'],\n", + " 'precision_weighted': ['mean', 'std'],\n", + " 'f1_macro': ['mean', 'std'],\n", + " 'f1_weighted': ['mean', 'std']\n", + " }).round(4)\n", + " \n", + " print(summary_stats)\n", + " \n", + " # Plot results\n", + " plot_results(results_df)\n", + " \n", + " # Save results\n", + " current_date = datetime.datetime.now()\n", + " datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", + " output_dir = f\"Downstream/ml_classification_results_{datestamp}/\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " \n", + " # Save detailed results\n", + " results_df.to_csv(os.path.join(output_dir, \"detailed_results.csv\"), index=False)\n", + " summary_stats.to_csv(os.path.join(output_dir, \"summary_statistics.csv\"))\n", + " \n", + " # Save feature matrix and labels for future use\n", + " np.save(os.path.join(output_dir, \"feature_matrix.npy\"), X)\n", + " np.save(os.path.join(output_dir, \"labels.npy\"), y)\n", + " \n", + " print(f\"\\nResults saved to: {output_dir}\")\n", + " \n", + " return results_df, summary_stats\n", + "\n", + "if __name__ == \"__main__\":\n", + " # Import sys for path manipulation\n", + " import sys\n", + " \n", + " # Run main function\n", + " results_df, summary_stats = main()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Downstream_tasks/Classification/Tissue_type.py b/Downstream_tasks/Classification/Tissue_type.py new file mode 100644 index 0000000000000000000000000000000000000000..f91900c548b2e4f860a1b58360e99e05b75a1fe9 --- /dev/null +++ b/Downstream_tasks/Classification/Tissue_type.py @@ -0,0 +1,457 @@ +import os +from tqdm.auto import tqdm, trange +GPU_NUMBER = [0] +os.environ["CUDA_VISIBLE_DEVICES"] = ",".join([str(s) for s in GPU_NUMBER]) +os.environ["NCCL_DEBUG"] = "INFO" + +# imports +from collections import Counter +import seaborn as sns; sns.set() +from datasets import load_from_disk +from sklearn.metrics import accuracy_score, f1_score +from transformers import Trainer +from transformers.training_args import TrainingArguments +import pandas as pd +from datasets.utils.logging import disable_progress_bar, enable_progress_bar +from sklearn import preprocessing +from sklearn.metrics import ( + ConfusionMatrixDisplay, + accuracy_score, + auc, + confusion_matrix, + f1_score, + roc_curve, +) +from pathlib import Path + +import sys +# sys.path.append('../Geneformer') +from geneformer import DataCollatorForCellClassification +from datasets import load_from_disk +import sys +from tqdm.notebook import tqdm +import seaborn as sns +import matplotlib.pyplot as plt +from geneformer.pretrainer import token_dictionary +import datetime +import time +import pickle +import random +import subprocess +import numpy as np +import pytz +import torch +from datasets import load_from_disk, Dataset +from transformers import (BertConfig, BertForMaskedLM, TrainingArguments, TrainerCallback, + Trainer, BertModel, BertPreTrainedModel, BertForSequenceClassification, BertForTokenClassification) +from geneformer import GeneformerPretrainer +from torch import Tensor +from transformers.modeling_outputs import MaskedLMOutput +from transformers.models.bert.modeling_bert import BertLMPredictionHead, BertOnlyMLMHead, BertPredictionHeadTransform +from transformers.activations import ACT2FN +from typing import List, Optional, Tuple, Union +import torch.nn.functional as F + +model_path = 'model path' +prefix = 'CAB5_1M' +total_iter = 1 + +class CustomBertForMaskedLM(BertPreTrainedModel): + _keys_to_ignore_on_load_missing = ["cls.predictions.decoder.weight", "cls.predictions.decoder.bias"] + _tied_weights_keys = ["decoder.weight", "bert.embeddings.word_embeddings.weight"] + + def __init__(self, config): + super().__init__(config) + self.bert = BertModel(config, add_pooling_layer=False) + self.transform = BertPredictionHeadTransform(config) + + self.decoder = torch.nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = torch.nn.Parameter(torch.zeros(config.vocab_size)) + + # Initialize weights + self.init_weights() + + # Tie weights automatically + self.tie_weights() + + # self.post_init() + + def tie_weights(self): + """ + Ties the weights between the input embeddings and output decoder weights. + """ + self.decoder.weight = self.bert.embeddings.word_embeddings.weight + + def probability_convert(self, probs: Tensor, input_ids: Tensor, labels: Tensor) -> Tensor: + device = probs.device + batch_size, seq_length, vocab_size = probs.size() + _, input_seq_length = input_ids.size() + + # truncated_labels = labels[:, :input_seq_length] + # non_mask = truncated_labels == -100 + non_mask = labels == -100 + non_mask_indices = non_mask.nonzero(as_tuple=True) + known_gene_indices = input_ids[non_mask] + + # Generate (1-p) matrix whiel assigning all known genes in the beginning + zeros = torch.zeros((batch_size, 1, vocab_size), device=device) + zeros[non_mask_indices[0], 0, known_gene_indices] = 1.0 + probs_shifted = torch.cat((zeros, probs[:, :-1, :]), dim=1) + inv_probs_shifted = 1 - probs_shifted + + # Cumulative product to get (1-p_1)*(1-p_2)*...*(p_i) + cumprod_inv_probs = torch.cumprod(inv_probs_shifted, dim=1) + modified_probs = probs * cumprod_inv_probs + + # # Since we are assigning probabilities for already known genes, + # # (1-p_1)*(1-p_2)*...*(p_i) for these genes can result in 0, due to hard assignment of probs to be 1 + # # Add 1e-18 to avoid dividing modified probs by 0 + # # During dubugging stage, some issues occurred in the normalization step. + # # Since probabilities in each position do not necessarily need to sum up to one, leave out normalization. + normalized_probs = modified_probs.sum(dim=-1, keepdim=True).clamp(min=1e-18) + modified_probs = modified_probs / normalized_probs # Normalization after cumulative production + + return modified_probs + + def assign_known_gene_probs(self, probs: Tensor, input_ids: Tensor, labels: Tensor) -> Tensor: + + device = probs.device + batch_size, seq_length, vocab_size = probs.size() + _, input_seq_length = input_ids.size() + + # Truncate `labels` to match the length of `input_ids` along the sequence dimension + truncated_labels = labels[:, :input_seq_length] + + non_mask = truncated_labels == -100 + non_mask_indices = non_mask.nonzero(as_tuple=True) + + ones = torch.ones((batch_size, seq_length, vocab_size), device=device) + zeros = torch.zeros((batch_size, seq_length, vocab_size), device=device) + + known_gene_indices = input_ids[non_mask] + + ones[non_mask_indices[0], non_mask_indices[1], :] = 0.0 + zeros[non_mask_indices[0], non_mask_indices[1], known_gene_indices] = 1.0 + + # Modify already known genes' probabilities using the one-hot tensor + modified_probs = probs * ones + modified_probs = modified_probs + zeros + + # Do the normalization + modified_probs = modified_probs / modified_probs.sum(dim=-1, keepdim=True).clamp(min=1e-18) # Normalize + + return modified_probs + + def compute_similarity_on_probs(self, probs: Tensor, labels: Tensor) -> Tensor: + """ + Optimized computation of average cosine similarity across all positions in each sequence and batch. + + Args: + probs (torch.Tensor): Probability tensor of shape (batch_size, seq_length, vocab_size). + + Returns: + torch.Tensor: Average similarity term for loss computation. + """ + batch_size, seq_length, vocab_size = probs.size() + device = probs.device + + non_mask = labels == -100 + non_mask_indices = non_mask.nonzero(as_tuple=True) + + mask_sim = torch.ones((batch_size, seq_length, seq_length), device=device) + mask_sim[non_mask_indices[0], non_mask_indices[1], :] = 0.0 + + seq_mask = torch.triu(torch.ones(seq_length, seq_length, device=device), diagonal=1) + batch_mask = seq_mask.unsqueeze(0).expand(batch_size, seq_length, seq_length) + mask_sim = mask_sim * batch_mask + + # Normalize along the vocab_size dimension + probs_norm = F.normalize(probs, dim=-1) # Shape: (batch_size, seq_length, vocab_size) + + # Compute pairwise cosine similarity using einsum + similarities = torch.einsum("biv,bjv->bij", probs_norm, probs_norm) # Shape: (batch_size, seq_length, seq_length), listing pair-wise similarity values across all positions + + # Mask out lower triangle (to consider only i < j pairs) + # mask_sim = torch.triu(torch.ones(seq_length, seq_length, device=probs.device), diagonal=1) + valid_similarities = similarities * mask_sim # Shape: (batch_size, seq_length, seq_length) + + # Compute average similarity + total_similarity = valid_similarities.sum() + total_comparisons = mask_sim.sum().item() + + if total_comparisons == 0: + return torch.tensor(0.0, device=device) + + return total_similarity / total_comparisons + + + def forward( + self, + input_ids: Tensor | None = None, + attention_mask: Tensor | None = None, + token_type_ids: Tensor | None = None, + position_ids: Tensor | None = None, + head_mask: Tensor | None = None, + inputs_embeds: Tensor | None = None, + encoder_hidden_states: Tensor | None = None, + encoder_attention_mask: Tensor | None = None, + labels: Tensor | None = None, + output_attentions: bool | None = None, + output_hidden_states: bool | None = None, + return_dict: bool | None = None) -> Union[Tuple[torch.Tensor], MaskedLMOutput]: + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + token_type_ids=token_type_ids, + position_ids=position_ids, + head_mask=head_mask, + inputs_embeds=inputs_embeds, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + hidden_states = outputs[0] + hidden_transform = self.transform(hidden_states) + logits = self.decoder(hidden_transform) + self.bias + + # temperature = 0.75 + # logits = logits / temperature + + probs = F.softmax(logits, dim=-1) + + # Probability manipulations to avoid repeats from already known genes + probs = self.assign_known_gene_probs(probs, input_ids, labels) + convert_probs = self.probability_convert(probs, input_ids, labels) + assigned_probs = self.assign_known_gene_probs(convert_probs, input_ids, labels) + + masked_lm_loss = None + if labels is not None: + probs_flat = assigned_probs.view(-1, self.config.vocab_size) + labels_flat = labels.view(-1) + mask = (labels != -100).float().view(-1) + + # Compute masked cross-entropy loss + masked_lm_loss = -torch.log(torch.clamp(probs_flat[torch.arange(len(labels_flat)), labels_flat], min=1e-18)) * mask + masked_lm_loss = masked_lm_loss.sum() / mask.sum() + + similarity_loss = self.compute_similarity_on_probs(assigned_probs, labels) + lambda_similarity = 5.0 # Adjust this value through experimentation + masked_lm_loss = masked_lm_loss + lambda_similarity * similarity_loss + + + else: + loss = None + + if not return_dict: + output = (assigned_probs,) + outputs[2:] + return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output + + return MaskedLMOutput( + loss=masked_lm_loss, + logits=assigned_probs, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs): + input_shape = input_ids.shape + effective_batch_size = input_shape[0] + + # add a dummy token + if self.config.pad_token_id is None: + raise ValueError("The PAD token should be defined for generation") + + attention_mask = torch.cat([attention_mask, attention_mask.new_zeros((attention_mask.shape[0], 1))], dim=-1) + dummy_token = torch.full( + (effective_batch_size, 1), self.config.pad_token_id, dtype=torch.long, device=input_ids.device + ) + input_ids = torch.cat([input_ids, dummy_token], dim=1) + + return {"input_ids": input_ids, "attention_mask": attention_mask} + + +# load cell type dataset (includes all tissues) +train_dataset=load_from_disk("example_input_files/cell_classification/cell_type_annotation/cell_type_train_data.dataset") +# load evaluation dataset (includes all tissues) +eval_dataset=load_from_disk("example_input_files/cell_classification/cell_type_annotation/cell_type_test_data.dataset") + +dataset_list = [] +evalset_list = [] +organ_list = [] +target_dict_list = [] + +for organ in Counter(train_dataset["organ_major"]).keys(): + # collect list of tissues for fine-tuning (immune and bone marrow are included together) + if organ in ["bone_marrow"]: + continue + elif organ=="immune": + organ_ids = ["immune","bone_marrow"] + organ_list += ["immune"] + else: + organ_ids = [organ] + organ_list += [organ] + + # filter datasets for given organ + def if_organ(example): + return example["organ_major"] in organ_ids + trainset_organ = train_dataset.filter(if_organ, num_proc=16) + + # per scDeepsort published method, drop cell types representing <0.5% of cells + celltype_counter = Counter(trainset_organ["cell_type"]) + total_cells = sum(celltype_counter.values()) + cells_to_keep = [k for k,v in celltype_counter.items() if v>(0.005*total_cells)] + def if_not_rare_celltype(example): + return example["cell_type"] in cells_to_keep + trainset_organ_subset = trainset_organ.filter(if_not_rare_celltype, num_proc=16) + + # shuffle datasets and rename columns + trainset_organ_shuffled = trainset_organ_subset.shuffle(seed=42) + trainset_organ_shuffled = trainset_organ_shuffled.rename_column("cell_type","label") + trainset_organ_shuffled = trainset_organ_shuffled.remove_columns("organ_major") + + # create dictionary of cell types : label ids + target_names = list(Counter(trainset_organ_shuffled["label"]).keys()) + target_name_id_dict = dict(zip(target_names,[i for i in range(len(target_names))])) + target_dict_list += [target_name_id_dict] + + # change labels to numerical ids + def classes_to_ids(example): + example["label"] = target_name_id_dict[example["label"]] + return example + labeled_trainset = trainset_organ_shuffled.map(classes_to_ids, num_proc=16) + + # create 80/20 train/eval splits + labeled_train_split = labeled_trainset.select([i for i in range(0,round(len(labeled_trainset)*0.8))]) + labeled_eval_split = labeled_trainset.select([i for i in range(round(len(labeled_trainset)*0.8),len(labeled_trainset))]) + + # filter dataset for cell types in corresponding training set + trained_labels = list(Counter(labeled_train_split["label"]).keys()) + def if_trained_label(example): + return example["label"] in trained_labels + labeled_eval_split_subset = labeled_eval_split.filter(if_trained_label, num_proc=16) + + dataset_list += [labeled_train_split] + evalset_list += [labeled_eval_split_subset] + +trainset_dict = dict(zip(organ_list,dataset_list)) +traintargetdict_dict = dict(zip(organ_list,target_dict_list)) + +evalset_dict = dict(zip(organ_list,evalset_list)) + +def compute_metrics(pred): + labels = pred.label_ids + preds = pred.predictions.argmax(-1) + # calculate accuracy and macro f1 using sklearn's function + acc = accuracy_score(labels, preds) + macro_f1 = f1_score(labels, preds, average='macro') + weighted_f1 = f1_score(labels, preds, average='weighted') + return { + 'accuracy': acc, + 'macro_f1': macro_f1, + 'weighted_f1': weighted_f1 + } + +# set model parameters +# max input size +max_input_size = 2 ** 11 # 2048 + +# set training hyperparameters +# max learning rate +max_lr = 5e-5 +# how many pretrained layers to freeze +freeze_layers = 0 +# number gpus +num_gpus = 1 +# number cpu cores +num_proc = 16 +# batch size for training and eval +geneformer_batch_size = 12 +# learning schedule +lr_schedule_fn = "linear" +# warmup steps +warmup_steps = 500 +# number of epochs +epochs = 10 +# optimizer +optimizer = "adamw" + +for organ in organ_list: + print(organ) + organ_trainset = trainset_dict[organ] + organ_evalset = evalset_dict[organ] + organ_label_dict = traintargetdict_dict[organ] + + # set logging steps + logging_steps = round(len(organ_trainset)/geneformer_batch_size/10) + + # reload pretrained model + model = BertForSequenceClassification.from_pretrained(model_path, + num_labels=len(organ_label_dict.keys()), + output_attentions = False, + output_hidden_states = False).to("cuda") + + # ############# + pretrained_model = CustomBertForMaskedLM.from_pretrained(model_path) + # Extract the word embeddings from the pretrained model + pretrained_word_embeddings = pretrained_model.bert.embeddings.word_embeddings.weight.clone() + model.bert.embeddings.word_embeddings.load_state_dict({"weight": pretrained_word_embeddings}) + # ############ + + # define output directory path + current_date = datetime.datetime.now() + datestamp = f"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}" + output_dir = f"/ibex/user/chenj0i/Geneformer/Downstream_tasks/Cell_Classify/{prefix}/{datestamp}_geneformer_CellClassifier_{organ}/" + + # ensure not overwriting previously saved model + saved_model_test = os.path.join(output_dir, f"pytorch_model.bin") + if os.path.isfile(saved_model_test) == True: + raise Exception("Model already saved to this directory.") + + # make output directory + # subprocess.call(f'mkdir {output_dir}', shell=True) + os.makedirs(output_dir, exist_ok=True) + + # set training arguments + training_args = { + "learning_rate": max_lr, + "do_train": True, + "do_eval": True, + "evaluation_strategy": "epoch", + "save_strategy": "epoch", + "logging_steps": logging_steps, + "group_by_length": True, + "length_column_name": "length", + "disable_tqdm": False, + "lr_scheduler_type": lr_schedule_fn, + "warmup_steps": warmup_steps, + "weight_decay": 0.001, + "per_device_train_batch_size": geneformer_batch_size, + "per_device_eval_batch_size": geneformer_batch_size, + "num_train_epochs": epochs, + "load_best_model_at_end": True, + "output_dir": output_dir, + } + + training_args_init = TrainingArguments(**training_args) + + # create the trainer + trainer = Trainer( + model=model, + args=training_args_init, + data_collator=DataCollatorForCellClassification(), + train_dataset=organ_trainset, + eval_dataset=organ_evalset, + compute_metrics=compute_metrics + ) + # train the cell type classifier + trainer.train() + predictions = trainer.predict(organ_evalset) + with open(f"{output_dir}predictions.pickle", "wb") as fp: + pickle.dump(predictions, fp) + trainer.save_metrics("eval",predictions.metrics) + trainer.save_model(output_dir) \ No newline at end of file diff --git a/Downstream_tasks/Classification/Tissue_type_ML.ipynb b/Downstream_tasks/Classification/Tissue_type_ML.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..83d30ef0dd78abeb56f0af7d035356c91079d77c --- /dev/null +++ b/Downstream_tasks/Classification/Tissue_type_ML.ipynb @@ -0,0 +1,933 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from collections import Counter\n", + "import datetime\n", + "import pickle\n", + "import numpy as np\n", + "from datasets import load_from_disk\n", + "from sklearn.metrics import accuracy_score, f1_score\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import SVC\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import make_pipeline\n", + "from tqdm import tqdm\n", + "\n", + "# Load datasets\n", + "train_dataset = load_from_disk(\"example_input_files/cell_classification/cell_type_annotation/cell_type_train_data.dataset\")\n", + "eval_dataset = load_from_disk(\"example_input_files/cell_classification/cell_type_annotation/cell_type_test_data.dataset\")\n", + "\n", + "dataset_list, evalset_list, organ_list, target_dict_list = [], [], [], []\n", + "\n", + "for organ in Counter(train_dataset[\"organ_major\"]).keys():\n", + " if organ in [\"bone_marrow\"]: \n", + " continue\n", + " elif organ == \"immune\":\n", + " organ_ids = [\"immune\", \"bone_marrow\"]\n", + " organ_list += [\"immune\"]\n", + " else:\n", + " organ_ids = [organ]\n", + " organ_list += [organ]\n", + " \n", + " def if_organ(example):\n", + " return example[\"organ_major\"] in organ_ids\n", + " trainset_organ = train_dataset.filter(if_organ, num_proc=16)\n", + " \n", + " celltype_counter = Counter(trainset_organ[\"cell_type\"])\n", + " total_cells = sum(celltype_counter.values())\n", + " cells_to_keep = [k for k, v in celltype_counter.items() if v > (0.005 * total_cells)]\n", + " \n", + " def if_not_rare_celltype(example):\n", + " return example[\"cell_type\"] in cells_to_keep\n", + " trainset_organ_subset = trainset_organ.filter(if_not_rare_celltype, num_proc=16)\n", + " \n", + " trainset_organ_shuffled = trainset_organ_subset.shuffle(seed=42)\n", + " trainset_organ_shuffled = trainset_organ_shuffled.rename_column(\"cell_type\", \"label\")\n", + " trainset_organ_shuffled = trainset_organ_shuffled.remove_columns(\"organ_major\")\n", + " \n", + " target_names = list(Counter(trainset_organ_shuffled[\"label\"]).keys())\n", + " target_name_id_dict = dict(zip(target_names, range(len(target_names))))\n", + " target_dict_list.append(target_name_id_dict)\n", + " \n", + " def classes_to_ids(example):\n", + " example[\"label\"] = target_name_id_dict[example[\"label\"]]\n", + " return example\n", + " labeled_trainset = trainset_organ_shuffled.map(classes_to_ids, num_proc=16)\n", + " \n", + " labeled_train_split = labeled_trainset.select(range(0, round(len(labeled_trainset) * 0.8)))\n", + " labeled_eval_split = labeled_trainset.select(range(round(len(labeled_trainset) * 0.8), len(labeled_trainset)))\n", + " \n", + " trained_labels = list(Counter(labeled_train_split[\"label\"]).keys())\n", + " def if_trained_label(example):\n", + " return example[\"label\"] in trained_labels\n", + " labeled_eval_split_subset = labeled_eval_split.filter(if_trained_label, num_proc=16)\n", + " \n", + " dataset_list.append(labeled_train_split)\n", + " evalset_list.append(labeled_eval_split_subset)\n", + "\n", + "trainset_dict = dict(zip(organ_list, dataset_list))\n", + "traintargetdict_dict = dict(zip(organ_list, target_dict_list))\n", + "evalset_dict = dict(zip(organ_list, evalset_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===== Organ: spleen =====\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "padding...: 12330it [00:00, 76763.11it/s]\n", + "padding...: 3083it [00:00, 75593.59it/s]\n", + "spleen models: 0%| | 0/2 [00:00 +Packages version + +This code has been tested with the following versions of the packages: + +- Python - tested with `3.9` +- PyTorch - tested with - `1.13` +- CUDA - tested with `11.7` +- [FlashAttention](https://github.com/Dao-AILab/flash-attention/tree/v1.0.4) - depends on `v1.0.4` +- [scGPT](https://github.com/bowang-lab/scGPT/tree/v0.1.6) - depends on `v0.1.6` +- [Geneformer](https://huggingface.co/ctheodoris/Geneformer/tree/5d0082c1e188ab88997efa87891414fdc6e4f6ff) - depends on commit `5d0082c` +- [scIB](https://github.com/theislab/scib/tree/v1.0.4) - tested with `v1.0.4` +- [sc_foundation_evals](https://github.com/microsoft/zero-shot-scfoundation) `v0.1.0` + + + +## Installation + +Below you can find the instructions on how to install the dependencies for this project. We provide two options: using conda/mamba or using Docker. + +
+Conda / Mamba + +### Conda / Mamba + +You can install the dependencies using conda. To do so, you need to have conda installed on your machine. If you don't have it, you can install it from [here](https://docs.conda.io/en/latest/miniconda.html). + +We recommend using [mamba](https://mamba.readthedocs.io/en/latest/user_guide/mamba.html), since it is faster in our experience. You can install mamba following the guide [here](https://mamba.readthedocs.io/en/latest/installation/micromamba-installation.html#operating-system-package-managers). + +To simplify installation, we provide the installation script that creates a new conda environment with all the dependencies installed. You can run the following command to create the environment: + +```bash +bash envs/installation.sh +``` + +If the installation is successful, you will see the following message: + +```console +2024-08-22 19:49:26 SUCCESS: All packages installed successfully. +``` + +And you can activate the environment by running: + +```bash +conda activate sc_foundation_evals +``` + +
+ +
+Docker + +### Docker + +The docker image is available on DockerHub [here](https://hub.docker.com/repository/docker/kzkedzierska/sc_foundation_evals/general). You can pull the image by running: + +```bash +docker pull kzkedzierska/sc_foundation_evals +``` + +The image is based on the `cnstark/pytorch:1.13.0-py3.9.12-cuda11.7.1-ubuntu20.04` image, and has all the dependencies installed. The Dockerfile used to build the image can be found in the `envs/docker` directory. + +You can also skip pulling the image since `docker` will pull it if needed. To run the interactive session with the image, you can use the following command: + +```bash +docker run --gpus all -it kzkedzierska/sc_foundation_evals +``` + +If you want to be able to run the notebooks, run the image with the following tag: + +```bash + docker run --gpus all -it --rm -p 8888:8888 -v ./:/workspace kzkedzierska/sc_foundation_evals:latest_notebook +``` + +And open the link provided in the terminal in your browser. It should look like this: + +```console +[I 2024-08-23 22:15:13.015 ServerApp] Serving notebooks from local directory: /workspace +[I 2024-08-23 22:15:13.015 ServerApp] Jupyter Server 2.14.2 is running at: +[I 2024-08-23 22:15:13.015 ServerApp] http://localhost:8888/tree +[I 2024-08-23 22:15:13.015 ServerApp] http://127.0.0.1:8888/tree +``` + +For running the command on the server, consult the documentation of the server provider on how to forward the ports properly. + +
+ +## Running the code + +### Downloading the weights + +To run notebooks you also need to have the weights of the models downloaded. scGPT weights are avaialble [here](https://github.com/bowang-lab/scGPT#pretrained-scgpt-model-zoo) and Geneformer weights are available in its repository. As per the instructions in the Geneformer repository, make sure you have `git lfs` installed before downloading the weights via repository cloning. + +### Copying this repository + +To run the code, you need to clone this repository. + +```bash +git clone https://github.com/microsoft/zero-shot-scfoundation +``` + +And download and unpack the data, stored at figshare (see [here](https://doi.org/10.6084/m9.figshare.24747228) for more details). + +```bash +cd zero-shot-scfoundation +# download and unpack the data +wget https://figshare.com/ndownloader/files/43480497 -O data.zip +unzip data.zip && rm data.zip +``` + +### Notebooks + +To best understand the code and it's organization, please have a look at the notebooks. The `notebooks` directory currently contains the following notebooks: + +- [scGPT_zero_shot](notebooks/scGPT_zero_shot.ipynb) - notebook for running scGPT zero-shot evaluation +- [Geneformer_zero_shot](notebooks/Geneformer_zero_shot.ipynb) - notebook for running Geneformer zero-shot evaluation +- [Baselines_HVG_and_scVI](notebooks/Baselines_HVG_and_scVI.ipynb) - notebook for running the baselines used in the paper, i.e. HVG and scVI. + +## Any questions? + +If you have any questions, or find any issues with the code, please open an issue in this repository. You can find more information on how to file an issue in [here](/SUPPORT.md). We also welcome any contributions to the code - be sure to checkout the **Contributing** section below. + +## Contributing + +This project welcomes contributions and suggestions. Most contributions require you to agree to a +Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us +the rights to use your contribution. For details, visit . + +When you submit a pull request, a CLA bot will automatically determine whether you need to provide +a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions +provided by the bot. You will only need to do this once across all repos using our CLA. + +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). +For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or +contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. + +## Trademarks + +This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft +trademarks or logos is subject to and must follow +[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general). +Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. +Any use of third-party trademarks or logos are subject to those third-party's policies. diff --git a/Downstream_tasks/Zero_shot_batch_effect/SECURITY.md b/Downstream_tasks/Zero_shot_batch_effect/SECURITY.md new file mode 100644 index 0000000000000000000000000000000000000000..b3c89efc852e22f71eabf5dfbc6ac62493425eb6 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/SECURITY.md @@ -0,0 +1,41 @@ + + +## Security + +Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet) and [Xamarin](https://github.com/xamarin). + +If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/security.md/definition), please report it to us as described below. + +## Reporting Security Issues + +**Please do not report security vulnerabilities through public GitHub issues.** + +Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/security.md/msrc/create-report). + +If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/security.md/msrc/pgp). + +You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc). + +Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: + + * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) + * Full paths of source file(s) related to the manifestation of the issue + * The location of the affected source code (tag/branch/commit or direct URL) + * Any special configuration required to reproduce the issue + * Step-by-step instructions to reproduce the issue + * Proof-of-concept or exploit code (if possible) + * Impact of the issue, including how an attacker might exploit the issue + +This information will help us triage your report more quickly. + +If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/security.md/msrc/bounty) page for more details about our active programs. + +## Preferred Languages + +We prefer all communications to be in English. + +## Policy + +Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/security.md/cvd). + + diff --git a/Downstream_tasks/Zero_shot_batch_effect/SUPPORT.md b/Downstream_tasks/Zero_shot_batch_effect/SUPPORT.md new file mode 100644 index 0000000000000000000000000000000000000000..1061576c14b2f71f9bab487e25f9bfd0918e739b --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/SUPPORT.md @@ -0,0 +1,16 @@ +# Support + +## How to file issues and get help + +This project uses GitHub Issues to track bugs and feature requests. Please search the existing +issues before filing new issues to avoid duplicates. For new issues, file your bug, ask a question +or request a feature as a new Issue. + +If you face an issue with installation or running the code, on top of the error message please describe +your enviornment well (what operating system do you use, if you use conda or virtual enviornment, +please list what versions of the packages are installed and available in your PATH at the time of +running the code). We will try to respond and help. + +## Microsoft Support Policy + +Support for this PROJECT is limited to the resources listed above. diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/conda_env.yml b/Downstream_tasks/Zero_shot_batch_effect/envs/conda_env.yml new file mode 100644 index 0000000000000000000000000000000000000000..2deaab46f23f1393cb375fd1c1c07eef826a9f57 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/conda_env.yml @@ -0,0 +1,21 @@ +name: sc_foundation_evals +channels: + - nvidia/label/cuda-11.7.0 + - conda-forge + - bioconda + - defaults +dependencies: + - python=3.10 + - cudatoolkit + - r-base=4.2.3 + - ninja + - rpy2 + - packaging + - gxx=11.4 + - git-lfs + - pip>=21.1 + - pip: + - --index-url https://download.pytorch.org/whl/cu117 + - torch==1.13 + - torchvision + - torchaudio diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/Dockerfile b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..e7d96bbecee778c09e8738a40e0c9a4a4e290800 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/Dockerfile @@ -0,0 +1,28 @@ +FROM cnstark/pytorch:1.13.0-py3.9.12-cuda11.7.1-ubuntu20.04 + +# NAME sc_foundation_evals + +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update && apt-get install -y wget git git-lfs && \ + wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-keyring_1.1-1_all.deb && \ + dpkg -i cuda-keyring_1.1-1_all.deb && \ + rm cuda-keyring_1.1-1_all.deb && \ + apt-get update && \ + echo "tzdata tzdata/Areas select Europe" > /tmp/prelseed.txt; \ + echo "tzdata tzdata/Zones/Europe select Warsaw" >> /tmp/preseed.txt; \ + debconf-set-selections /tmp/preseed.txt && \ + apt-get install -y cuda-toolkit-11-7 && \ + apt-get install -y r-base && \ + apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* + +ENV PATH=/usr/local/cuda-11.7/bin${PATH:+:${PATH}} +ENV LD_LIBRARY_PATH=/usr/local/cuda-11.7/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}} + +RUN pip install packaging && \ + pip install flash-attn==1.0.4 --no-build-isolation + +RUN pip install scib[kBET,rpy2] colorlog PyComplexHeatmap wandb && \ + pip install git+https://github.com/bowang-lab/scGPT.git@v0.1.6 && \ + pip install git+https://huggingface.co/ctheodoris/Geneformer.git@5d0082c1e188ab88997efa87891414fdc6e4f6ff && \ + pip install git+https://github.com/microsoft/zero-shot-scfoundation.git@v0.1.0 diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test.py b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test.py new file mode 100644 index 0000000000000000000000000000000000000000..8af15665866c59c7a5151649e7348ae0c0bb2a3c --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test.py @@ -0,0 +1,66 @@ +#! /usr/bin/env python + +try: + from sc_foundation_evals.helpers.custom_logging import log +except ImportError: + import logging + + logging.basicConfig(level=logging.DEBUG) + log = logging.getLogger(__name__) + msg = "Cannot load sc_foundation_evals custom logging module. Exiting..." + log.error(msg) + raise ImportError(msg) + +log.info("Hello from the test script! This is to test the build process.") + + +def import_package(package_name): + """ + Try to import a package and return the package if successful. + Logs and raises an error if the package is not available. + """ + try: + package = __import__(package_name) + version = getattr(package, "__version__", None) + log.info( + f"Successfully imported {package_name}. " + f"Version: {version if version else 'unknown'}" + ) + return package + + except ImportError as e: + msg = f"Could not import required package: {package_name}" + log.error(f"{msg}: {e}") + raise ImportError(msg) + + +def test_cuda_availability(): + """ + Check if CUDA is available and log the result. + """ + torch = import_package("torch") + if torch.cuda.is_available(): + log.info("Success -- CUDA is available!") + else: + log.error( + "CUDA is not available. Please check your system configuration." + ) + + +def main(): + try: + log.debug("Testing CUDA availability...") + test_cuda_availability() + log.debug("Testing loading scGPT...") + import_package("scgpt") + log.debug("Testing loading Geneformer...") + import_package("geneformer") + log.info("All tests passed successfully! :)") + + except Exception as e: + log.error(f"An error occurred during the testing process: {e}") + raise + + +if __name__ == "__main__": + main() diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test_docker.sh b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test_docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..2db80059cf7e486c250c6dc62f5d0ea73dcbe21d --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/base_image/test_docker.sh @@ -0,0 +1,13 @@ +#! /bin/bash + +# This script is used to test the docker image built by the Dockerfile in the same directory. +# The docker image is built by the following command: +# docker build -t kzkedzierska/sc_foundation_evals[:tag] . + +# The script runs the docker image and executes the test.py script in the container. +# The test.py script is a simple script that imports the sc_foundation_evals package and prints the version of the package. + +docker run \ + --gpus all \ + -v "$(pwd)":/workspace kzkedzierska/sc_foundation_evals \ + python test.py diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/docker/jupyter/Dockerfile b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/jupyter/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ac63ec9db6410faa397b7ef32bdaa0db23bc89a6 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/docker/jupyter/Dockerfile @@ -0,0 +1,12 @@ +FROM kzkedzierska/sc_foundation_evals:latest + +# Install Jupyter Notebook +RUN pip install notebook + +WORKDIR /workspace + +# Expose the port Jupyter will run on +EXPOSE 8888 + +# Set the default command to run when starting the container +CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''", "--NotebookApp.password=''"] \ No newline at end of file diff --git a/Downstream_tasks/Zero_shot_batch_effect/envs/installation.sh b/Downstream_tasks/Zero_shot_batch_effect/envs/installation.sh new file mode 100644 index 0000000000000000000000000000000000000000..2f039dcba41fa21c8fd528e0d557f7cf69c897cd --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/envs/installation.sh @@ -0,0 +1,85 @@ +#! /bin/bash +# exit on error +set -e + +_script_name=$(basename "$0") + +ENV_NAME="sc_foundation_evals" + +warning() { + yellow='\033[0;33m' + nc='\033[0m' + echo -e "${yellow}$(date '+%Y-%m-%d %H:%M:%S') WARNING: $@${nc}" 1>&2 +} + +success() { + green='\033[0;32m' + nc='\033[0m' + echo -e "${green}$(date '+%Y-%m-%d %H:%M:%S') SUCCESS: $@${nc}" +} + +error() { + red='\033[0;31m' + nc='\033[0m' + echo -e "${red}$(date '+%Y-%m-%d %H:%M:%S') ERROR: $@${nc}" 1>&2 + usage_and_exit 1 +} + +msg() { + echo -e "$(date '+%Y-%m-%d %H:%M:%S') INFO: $@" +} + +usage() { + echo -e " + +USAGE: bash ${_script_name} + +Script to install the package and set up the Conda environment. + +EXAMPLES: + Install the package and set up the Conda environment: + bash ${_script_name} + " +} + +usage_and_exit() { + usage + exit $1 + +} + +# if mamba available, use it +if command -v mamba &>/dev/null; then + conda_cli=mamba +else + conda_cli=conda +fi +msg "Using '${conda_cli}' as the Conda CLI." + +${conda_cli} env create -f envs/conda_env.yml -n ${ENV_NAME} || + error "Failed to create the Conda environment '${ENV_NAME}'." +success "Conda environment '${ENV_NAME}' created successfully." + +${conda_cli} run \ + -n ${ENV_NAME} pip install flash-attn==1.0.4 --no-build-isolation +success "Flash attention installed successfully." + +${conda_cli} run \ + -n ${ENV_NAME} pip install 'setuptools>=65.2' wandb colorlog \ + PyComplexHeatmap scib[kBET,rpy2]==1.0.4 || + error "Failed to install the wandb, colorlog, PyComplexHeatmap or scib." + +${conda_cli} run \ + -n ${ENV_NAME} pip install git+https://github.com/bowang-lab/scGPT.git@v0.1.6 || + error "Failed to install the scGPT." + +${conda_cli} run \ + -n ${ENV_NAME} pip install \ + git+https://huggingface.co/ctheodoris/Geneformer.git@5d0082c1e188ab88997efa87891414fdc6e4f6ff || + error "Failed to install the Geneformer." + +${conda_cli} run \ + -n ${ENV_NAME} pip install git+https://github.com/microsoft/zero-shot-scfoundation || + error "Failed to install the sc_foundation_evals." + +success "All packages installed successfully." diff --git a/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_Geneformer.ipynb b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_Geneformer.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..cf71e75dbc2bc0e705382a932d5efd20afd376fc --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_Geneformer.ipynb @@ -0,0 +1,1539 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d64b7280", + "metadata": {}, + "source": [ + "# Evalutating Geneformer in zero-shot setting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4be00a33-d204-43b9-8edb-dce6df631946", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import logging\n", + "import warnings\n", + "import sys\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", + "\n", + "from sc_foundation_evals import geneformer_forward as gf\n", + "from sc_foundation_evals import data, cell_embeddings, model_output\n", + "from sc_foundation_evals.helpers.custom_logging import log\n", + "log.setLevel(logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "id": "42dddae8", + "metadata": {}, + "source": [ + "## Setting up variables" + ] + }, + { + "cell_type": "markdown", + "id": "b1178f8e", + "metadata": {}, + "source": [ + "Define some variables, that we will rely on later, starting with paths and run configs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2bde6459", + "metadata": {}, + "outputs": [], + "source": [ + "geneformer_data = \"model path\"\n", + "# path to the pre-trained model, can work with the huggingface model hub\n", + "# i.e. ctheodoris/Geneformer\n", + "model_dir = os.path.join(geneformer_data)\n", + "# path to dictionaries in geneformer repo\n", + "dict_dir = \"Pretrain_data/\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively to the code above, you can also use the snippet below, using the copy of the Genefomerme repository.\n", + "\n", + "```python\n", + "repo_dir = \"/path/to/repository/of/Geneformer\"\n", + "model_dir = os.path.join(repo_dir)\n", + "dict_dir = os.path.join(repo_dir, \"geneformer\")\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# batch_size depends on available GPU memory\n", + "batch_size = 24\n", + "# output_dir is the path to which the results should be saved\n", + "output_dir = \"zero_shot_results/\"\n", + "# path to where we will store the embeddings and other evaluation outputs\n", + "model_out = os.path.join(output_dir, \"model_outputs\")\n", + "# if you can use multithreading specify num_workers, -1 means use all available\n", + "num_workers = -1" + ] + }, + { + "cell_type": "markdown", + "id": "a5217358", + "metadata": {}, + "source": [ + "Data paths and configs.\n", + "\n", + "I will be using the Pancreas dataset as an example, as described in the scGPT_zer-shot notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b64e18c2", + "metadata": {}, + "outputs": [], + "source": [ + "# specify the path to anndata object\n", + "in_dataset_path = \"zero_shot_batch_data/pbmc.h5ad\"\n", + "# dataset_name is inferred from in_dataset_path\n", + "dataset_name = os.path.basename(in_dataset_path).split(\".\")[0]\n", + "# specify the path for the output of the pre-processing\n", + "preprocessed_path = f\"zero_shot_preprocess/{dataset_name}/\"\n", + "# create the preprocessed path if it does not exist\n", + "os.makedirs(preprocessed_path, exist_ok=True)\n", + "# in which column in adata.obs are gene names stored? if they are in index, the index will be copied to a column with this name\n", + "gene_col = \"gene_symbols\"\n", + "# batch column found in adata.obs\n", + "batch_col = \"batch\"\n", + "# where are labels stored in adata.obs? \n", + "label_col = \"celltype\" #\"str_labels\"\n", + "# where the raw counts are stored?\n", + "layer_key = \"counts\" #\"X\" " + ] + }, + { + "cell_type": "markdown", + "id": "8b836746", + "metadata": {}, + "source": [ + "## Loading model and data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d8ad1f4c-28eb-4d0d-b912-f4674acf94b6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mINFO \u001b[0m | 2025-06-21 16:11:37 | \u001b[32mUsing device cuda\u001b[0m\n" + ] + } + ], + "source": [ + "geneform = gf.Geneformer_instance(save_dir = output_dir, \n", + " saved_model_path = model_dir,\n", + " explicit_save_dir = True,\n", + " num_workers = num_workers)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12f648ae-f69d-4fed-970e-8dec72d9d634", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "geneform.load_pretrained_model()" + ] + }, + { + "cell_type": "markdown", + "id": "4146fcb5", + "metadata": {}, + "source": [ + "Load them vocabulary and gene to Ensembl ID matching." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "459d6ceb-770b-4317-9439-56e99e4e3735", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "geneform.load_vocab(dict_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "f8b64aba", + "metadata": {}, + "source": [ + "To prepare the data, we need to preprocess it and then tokenize it. First, we create the input data objec." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "302e72c0", + "metadata": {}, + "outputs": [], + "source": [ + "input_data = data.InputData(adata_dataset_path = in_dataset_path)" + ] + }, + { + "cell_type": "markdown", + "id": "193ec9d3", + "metadata": {}, + "source": [ + "Then, we preprocess the data - match gene names and filter cells and genes. This will create a new adata, that will be saved in the `preprocessed_path` to a `.loom` or `.h5ad` file. Loom data seems to be causing more issues in this version of the Geneformer code, so I'll stick with this, but overall this should also work with adata format." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "48f40540", + "metadata": {}, + "outputs": [], + "source": [ + "# input_data.preprocess_data(gene_col = gene_col,\n", + "# model_type = \"geneformer\",\n", + "# save_ext = \"loom\",\n", + "# gene_name_id_dict = geneform.gene_name_id,\n", + "# preprocessed_path = preprocessed_path)" + ] + }, + { + "cell_type": "markdown", + "id": "9a7d6ca5", + "metadata": {}, + "source": [ + "Now, tokenizing the data. Preprocessing saves the data to a file, as the tokenizer expects to read it from drive. This will create a `dataset_name`.dataset directory with the tokenized data in the `preprocessed_path`. This will also read in the tokenized_data to the `geneform` object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb4d7aa0", + "metadata": {}, + "outputs": [], + "source": [ + "# geneform.tokenize_data(adata_path = os.path.join(preprocessed_path, \n", + "# f\"{dataset_name}.loom\"),\n", + "# dataset_path = preprocessed_path,\n", + "# cell_type_col = label_col)\n", + "geneform.load_tokenized_dataset(os.path.join(preprocessed_path, f\"{dataset_name}.dataset\"))\n", + "input_data = data.InputData(adata_dataset_path = os.path.join(preprocessed_path, f\"{dataset_name}.loom\"))" + ] + }, + { + "cell_type": "markdown", + "id": "5d02f5bb", + "metadata": {}, + "source": [ + "If the data was already tokenized, we can just load it." + ] + }, + { + "cell_type": "markdown", + "id": "99872a63-9f2a-40c1-9d5b-7eb5e4ee10b4", + "metadata": {}, + "source": [ + "```python\n", + "geneform.load_tokenized_dataset(os.path.join(preprocessed_path, f\"{dataset_name}.dataset\"))\n", + "input_data = data.InputData(adata_dataset_path = os.path.join(preprocessed_path, f\"{dataset_name}.loom\"))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "b531b185", + "metadata": {}, + "source": [ + "## Evaluating model outputs" + ] + }, + { + "cell_type": "markdown", + "id": "27e634f2", + "metadata": {}, + "source": [ + "First, we will perform forward pass on the model and extract embeddings. We're interested with second to last layer, as per the instructions in the codebase of Geneformer [here](https://huggingface.co/ctheodoris/Geneformer/blob/main/geneformer/emb_extractor.py#L285). Using the argument `layer` we can refer to layers according to python logic (i.e. 0 is the embedding layer, 1 - first layer, 2 is the second layer, etc. and -1 is the last layer, etc.).\n", + "\n", + "*Note:* If you get a CUDA out of memory error, you can try reducing the batch size. As a rule of thumb, try batch sizes of multiples of 8, to avoid potential issues with how approximations are handled in CUDA." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5e4d662e-02d8-4483-9712-a08c9b3cb8ce", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c0c774543de416c85911f2258a5284d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Geneformer (extracting embeddings): 0%| | 0/500 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
correlationmean_correlation
count500.000000500.000000
mean0.4414060.588006
std0.0732410.193206
min0.275004-0.060057
25%0.3964260.618768
50%0.4211340.657667
75%0.4619140.689752
max0.7148370.799947
\n", + "" + ], + "text/plain": [ + " correlation mean_correlation\n", + "count 500.000000 500.000000\n", + "mean 0.441406 0.588006\n", + "std 0.073241 0.193206\n", + "min 0.275004 -0.060057\n", + "25% 0.396426 0.618768\n", + "50% 0.421134 0.657667\n", + "75% 0.461914 0.689752\n", + "max 0.714837 0.799947" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eval_pred.evaluate(n_cells = 500,\n", + " save_rankings = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0ac882a2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mINFO \u001b[0m | 2025-06-16 14:10:58 | \u001b[32mSubsetting to 100 cells\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_pred.visualize(n_cells = 100, cmap = \"mako_r\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a1814d12", + "metadata": {}, + "outputs": [], + "source": [ + "eval_ce = cell_embeddings.CellEmbeddingsEval(geneform,\n", + " data = input_data,\n", + " output_dir = model_out,\n", + " label_key = label_col,\n", + " batch_key = batch_col)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "eedc7513", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2025-06-16 15:08:38 | \u001b[33madata_ has 329762 cells. Taking a subset of 2000 cells.\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metriclabelvalue
0NMI_cluster/labelcelltype0.469597
1ARI_cluster/labelcelltype0.270278
2ASW_labelcelltype0.462948
3graph_conncelltype0.720883
4ASW_batchcelltype0.433283
5ASW_label/batchcelltype0.795673
6PCR_batchcelltype0.097238
7avg_biocelltype0.400941
\n", + "
" + ], + "text/plain": [ + " metric label value\n", + "0 NMI_cluster/label celltype 0.469597\n", + "1 ARI_cluster/label celltype 0.270278\n", + "2 ASW_label celltype 0.462948\n", + "3 graph_conn celltype 0.720883\n", + "4 ASW_batch celltype 0.433283\n", + "5 ASW_label/batch celltype 0.795673\n", + "6 PCR_batch celltype 0.097238\n", + "7 avg_bio celltype 0.400941" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with n_cells you can specify how much to subset the obs for\n", + "eval_ce.evaluate(n_cells = 2000, embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "db5cb432", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2025-06-16 15:08:56 | \u001b[33madata_ has 329762 cells. Taking a subset of 2000 cells.\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metriclabelvalue
0NMI_cluster/labelcelltype0.469597
1ARI_cluster/labelcelltype0.270278
2ASW_labelcelltype0.462948
3graph_conncelltype0.720883
4ASW_batchcelltype0.433283
5ASW_label/batchcelltype0.795673
6PCR_batchcelltype0.097238
7avg_biocelltype0.400941
\n", + "
" + ], + "text/plain": [ + " metric label value\n", + "0 NMI_cluster/label celltype 0.469597\n", + "1 ARI_cluster/label celltype 0.270278\n", + "2 ASW_label celltype 0.462948\n", + "3 graph_conn celltype 0.720883\n", + "4 ASW_batch celltype 0.433283\n", + "5 ASW_label/batch celltype 0.795673\n", + "6 PCR_batch celltype 0.097238\n", + "7 avg_bio celltype 0.400941" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with n_cells you can specify how much to subset the obs for\n", + "eval_ce.evaluate(n_cells = 2000, embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8f5be831", + "metadata": {}, + "outputs": [], + "source": [ + "eval_ce.visualize(embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ae997d3e", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, Optional\n", + "import numpy as np\n", + "import scanpy as sc\n", + "import scib\n", + "from anndata import AnnData\n", + "from sklearn.metrics import silhouette_score\n", + "from tqdm import tqdm\n", + "import pandas as pd\n", + "import logging\n", + "\n", + "log = logging.getLogger(__name__)\n", + "\n", + "\n", + "def eval_clustering_metrics(\n", + " adata: AnnData,\n", + " batch_key: Optional[str] = \"str_batch\",\n", + " label_key: str = \"cell_type\",\n", + " embedding_key: str = \"X\", # \"X\" for raw, or embedding key in .obsm\n", + " resolutions: Optional[list] = None,\n", + " use_progress_bar: bool = True,\n", + " verbose: bool = False,\n", + " subsample_frac: Optional[float] = 0.25,\n", + ") -> Dict[str, float]:\n", + " \"\"\"Evaluate biological and batch mixing metrics on an embedding or raw expression.\"\"\"\n", + " \n", + " results_dict = {}\n", + "\n", + " if subsample_frac is not None and 0 < subsample_frac < 1:\n", + " adata = adata.copy()\n", + " sc.pp.subsample(adata, fraction=subsample_frac, copy=False)\n", + " if verbose:\n", + " log.info(f\"Subsampled adata to {subsample_frac * 100:.1f}% of original cells.\")\n", + "\n", + " # Determine whether to use .X or .obsm[embedding_key]\n", + " if embedding_key == \"X\":\n", + " use_rep = \"X\"\n", + " adata.obsm[\"X\"] = adata.X\n", + " elif embedding_key in adata.obsm:\n", + " use_rep = embedding_key\n", + " else:\n", + " raise ValueError(f\"embedding_key '{embedding_key}' not found in adata.obsm or is not 'X'\")\n", + "\n", + " # Clear stale neighbors\n", + " if \"neighbors\" in adata.uns:\n", + " if verbose:\n", + " log.warning(f\"Removing stale neighbors computed from other representations.\")\n", + " adata.uns.pop(\"neighbors\", None)\n", + "\n", + " sc.pp.neighbors(adata, use_rep=use_rep)\n", + "\n", + " # Run Louvain across multiple resolutions\n", + " if resolutions is None:\n", + " resolutions = [2 * i / 20 for i in range(1, 21)] # Default: 20 steps from 0.1 to 2.0\n", + "\n", + " best_nmi = -1\n", + " best_res = None\n", + " best_clustering = None\n", + "\n", + " if verbose:\n", + " log.info(f\"Searching for optimal clustering resolution on {use_rep}...\")\n", + "\n", + " for res in tqdm(resolutions, disable=not use_progress_bar, desc=\"Louvain clustering\"):\n", + " sc.tl.louvain(adata, resolution=res, key_added=\"temp_cluster\")\n", + " nmi = scib.metrics.nmi(adata, \"temp_cluster\", label_key)\n", + " if nmi > best_nmi:\n", + " best_nmi = nmi\n", + " best_res = res\n", + " best_clustering = adata.obs[\"temp_cluster\"].copy()\n", + " del adata.obs[\"temp_cluster\"]\n", + "\n", + " if verbose:\n", + " log.info(f\"Best resolution: {best_res:.2f} with NMI = {best_nmi:.4f}\")\n", + "\n", + " adata.obs[\"cluster\"] = best_clustering\n", + "\n", + " # Biological conservation metrics\n", + " results_dict[\"NMI_cluster/label\"] = scib.metrics.nmi(adata, \"cluster\", label_key, \"arithmetic\")\n", + " results_dict[\"ARI_cluster/label\"] = scib.metrics.ari(adata, \"cluster\", label_key)\n", + " results_dict[\"ASW_label\"] = scib.metrics.silhouette(adata, label_key, use_rep, \"euclidean\")\n", + "\n", + " # Batch effect metrics (if batch_key valid)\n", + " if batch_key is not None and batch_key in adata.obs and adata.obs[batch_key].nunique() > 1:\n", + " adata.obs[label_key] = adata.obs[label_key].astype(\"category\")\n", + " results_dict[\"graph_conn\"] = scib.metrics.graph_connectivity(adata, label_key)\n", + " results_dict[\"ASW_batch\"] = scib.metrics.silhouette(adata, batch_key, use_rep, \"euclidean\")\n", + " results_dict[\"ASW_label/batch\"] = scib.metrics.silhouette_batch(\n", + " adata, batch_key, label_key, embed=use_rep, metric=\"euclidean\", return_all=False\n", + " )\n", + " results_dict[\"PCR_batch\"] = scib.metrics.pcr(\n", + " adata, covariate=batch_key, embed=use_rep, recompute_pca=True, n_comps=50, verbose=False\n", + " )\n", + " results_dict[\"Average_Batch_Score\"] = (\n", + " results_dict[\"ASW_batch\"] + results_dict[\"PCR_batch\"]\n", + " ) / 2\n", + " else:\n", + " if verbose:\n", + " log.info(\"Skipping batch metrics — only one batch present or invalid batch_key.\")\n", + " \n", + " results_dict[\"avg_bio\"] = np.mean([\n", + " results_dict[\"NMI_cluster/label\"],\n", + " results_dict[\"ARI_cluster/label\"],\n", + " results_dict[\"ASW_label\"]\n", + " ])\n", + "\n", + " # Filter NaNs\n", + " results_dict = {k: v for k, v in results_dict.items() if not np.isnan(v)}\n", + "\n", + " return results_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "ffc57695", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Removing stale neighbors computed from other representations.\n", + "Louvain clustering: 100%|██████████| 20/20 [00:02<00:00, 6.69it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.990084\n", + "CD14+ Monocytes 0.974680\n", + "CD4 T cells 0.991498\n", + "CD8 T cells 0.993202\n", + "Dendritic Cells 0.949204\n", + "FCGR3A+ Monocytes 0.984050\n", + "Megakaryocytes 0.864510\n", + "NK cells 0.970672\n", + "Other 0.927177\n" + ] + }, + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.7359355202550268,\n", + " 'ARI_cluster/label': 0.799818412461634,\n", + " 'ASW_label': 0.5363253504037857,\n", + " 'graph_conn': 0.8937669240723102,\n", + " 'ASW_batch': 0.5006234394968487,\n", + " 'ASW_label/batch': 0.9605642071196792,\n", + " 'PCR_batch': 0.0007014657462978147,\n", + " 'Average_Batch_Score': 0.2506624526215733,\n", + " 'avg_bio': 0.6906930943734823}" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict = eval_clustering_metrics(adata=input_data.adata, \n", + " batch_key=\"batch\",\n", + " label_key=\"celltype\",\n", + " embedding_key=\"geneformer\", # or \"X_scGPT\", etc.\n", + " verbose=True)\n", + "results_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "42f25b38", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Removing stale neighbors computed from other representations.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Louvain clustering: 100%|██████████| 20/20 [00:02<00:00, 6.87it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.971033\n", + "CD14+ Monocytes 0.942456\n", + "CD4 T cells 0.988742\n", + "CD8 T cells 0.987412\n", + "Dendritic Cells 0.938792\n", + "FCGR3A+ Monocytes 0.950513\n", + "Megakaryocytes 0.752894\n", + "NK cells 0.890206\n", + "Other 0.914109\n" + ] + }, + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.6505152890434263,\n", + " 'ARI_cluster/label': 0.5759899223104351,\n", + " 'ASW_label': 0.5245759263634682,\n", + " 'graph_conn': 0.8891452955038966,\n", + " 'ASW_batch': 0.4964794989209622,\n", + " 'ASW_label/batch': 0.9262396008669715,\n", + " 'PCR_batch': 0.0007824623021499673,\n", + " 'Average_Batch_Score': 0.24863098061155608,\n", + " 'avg_bio': 0.5836937125724432}" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict_raw = eval_clustering_metrics(adata=input_data.adata, \n", + " batch_key=\"batch\",\n", + " label_key=\"celltype\",\n", + " embedding_key=\"X\", # or \"X_scGPT\", etc.\n", + " verbose=True)\n", + "results_dict_raw" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "7f2fe454", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.7102011123975458,\n", + " 'ARI_cluster/label': 0.6477001468186342,\n", + " 'ASW_label': 0.5428623855113983,\n", + " 'graph_conn': 0.912028584635897,\n", + " 'ASW_batch': 0.5018822988495231,\n", + " 'ASW_label/batch': 0.9549707840228508,\n", + " 'PCR_batch': 0.001357968419881124,\n", + " 'avg_bio': 0.6335878815758594}" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict" + ] + }, + { + "cell_type": "markdown", + "id": "e587cf14", + "metadata": {}, + "source": [ + "Layer = -1\n", + "BertCAB 25\n", + "30M Models" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "4ada5d2f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2025-06-10 15:20:08 | \u001b[33mCopying existing UMAP embedding to X_umap_old and overwriting X_umap.\u001b[0m\n", + "\u001b[33mWARNING \u001b[0m | 2025-06-10 15:20:19 | \u001b[33madata_ has 16382 cells. Taking a subset of 7500 cells.\u001b[0m\n", + "\u001b[33mWARNING \u001b[0m | 2025-06-10 15:20:19 | \u001b[33mMore than 10 labels for celltype.The plots might be hard to read.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_ce.visualize(embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "markdown", + "id": "ca6d2ca5", + "metadata": {}, + "source": [ + "GF 30M re-trained from scratch\n", + "layer = -2" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ede172d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2025-06-10 13:50:03 | \u001b[33madata_ has 16382 cells. Taking a subset of 7500 cells.\u001b[0m\n", + "\u001b[33mWARNING \u001b[0m | 2025-06-10 13:50:03 | \u001b[33mMore than 10 labels for celltype.The plots might be hard to read.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_ce.visualize(embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "markdown", + "id": "8893e014", + "metadata": {}, + "source": [ + "# Original Reported Results" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b385dc3d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
correlationmean_correlation
count500.000000500.000000
mean0.5714960.661472
std0.1122160.112700
min0.2387100.401928
25%0.4876760.548921
50%0.5636080.719794
75%0.6678900.757058
max0.8157320.809235
\n", + "
" + ], + "text/plain": [ + " correlation mean_correlation\n", + "count 500.000000 500.000000\n", + "mean 0.571496 0.661472\n", + "std 0.112216 0.112700\n", + "min 0.238710 0.401928\n", + "25% 0.487676 0.548921\n", + "50% 0.563608 0.719794\n", + "75% 0.667890 0.757058\n", + "max 0.815732 0.809235" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eval_pred.evaluate(n_cells = 500,\n", + " save_rankings = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3a82096e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mINFO \u001b[0m | 2023-12-05 15:07:41 | \u001b[32mSubsetting to 100 cells\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_pred.visualize(n_cells = 100, cmap = \"mako_r\")" + ] + }, + { + "cell_type": "markdown", + "id": "cd10d4e0", + "metadata": {}, + "source": [ + "# Evaluate the cell embeddings" + ] + }, + { + "cell_type": "markdown", + "id": "b9b7df94", + "metadata": {}, + "source": [ + "First, creating cell embeddings evaluation object." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "aa6639c6", + "metadata": {}, + "outputs": [], + "source": [ + "eval_ce = cell_embeddings.CellEmbeddingsEval(geneform,\n", + " data = input_data,\n", + " output_dir = model_out,\n", + " label_key = label_col,\n", + " batch_key = batch_col)\n" + ] + }, + { + "cell_type": "markdown", + "id": "753a1f29", + "metadata": {}, + "source": [ + "Then, evaluating the embeddings. Here, for speed we are subsetting the data to 1000 cells." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "54f580ab", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2023-12-05 15:13:20 | \u001b[33madata_ has 16382 cells. Taking a subset of 1000 cells.\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metriclabelvalue
0NMI_cluster/labelcelltype0.091457
1ARI_cluster/labelcelltype0.023780
2ASW_labelcelltype0.323220
3graph_conncelltype0.476560
4ASW_batchcelltype0.622801
5ASW_label/batchcelltype0.676177
6PCR_batchcelltype0.632914
7avg_biocelltype0.146152
\n", + "
" + ], + "text/plain": [ + " metric label value\n", + "0 NMI_cluster/label celltype 0.091457\n", + "1 ARI_cluster/label celltype 0.023780\n", + "2 ASW_label celltype 0.323220\n", + "3 graph_conn celltype 0.476560\n", + "4 ASW_batch celltype 0.622801\n", + "5 ASW_label/batch celltype 0.676177\n", + "6 PCR_batch celltype 0.632914\n", + "7 avg_bio celltype 0.146152" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with n_cells you can specify how much to subset the obs for\n", + "eval_ce.evaluate(n_cells = 1000, embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "73907a79", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2023-12-05 15:13:28 | \u001b[33madata_ has 16382 cells. Taking a subset of 1000 cells.\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metriclabelvalue
0NMI_cluster/labelcelltype0.091457
1ARI_cluster/labelcelltype0.023780
2ASW_labelcelltype0.323220
3graph_conncelltype0.476560
4ASW_batchcelltype0.622801
5ASW_label/batchcelltype0.676177
6PCR_batchcelltype0.632914
7avg_biocelltype0.146152
\n", + "
" + ], + "text/plain": [ + " metric label value\n", + "0 NMI_cluster/label celltype 0.091457\n", + "1 ARI_cluster/label celltype 0.023780\n", + "2 ASW_label celltype 0.323220\n", + "3 graph_conn celltype 0.476560\n", + "4 ASW_batch celltype 0.622801\n", + "5 ASW_label/batch celltype 0.676177\n", + "6 PCR_batch celltype 0.632914\n", + "7 avg_bio celltype 0.146152" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# with n_cells you can specify how much to subset the obs for\n", + "eval_ce.evaluate(n_cells = 1000, embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f10b0ae9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING \u001b[0m | 2023-12-05 15:14:52 | \u001b[33madata_ has 16382 cells. Taking a subset of 7500 cells.\u001b[0m\n", + "\u001b[33mWARNING \u001b[0m | 2023-12-05 15:14:53 | \u001b[33mMore than 10 labels for celltype.The plots might be hard to read.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_ce.visualize(embedding_key = \"geneformer\")" + ] + }, + { + "cell_type": "markdown", + "id": "6fa16fef", + "metadata": {}, + "source": [ + "bertcab10 1M\n", + "{'NMI_cluster/label': 0.550067742123904,\n", + " 'ARI_cluster/label': 0.2844253502648678,\n", + " 'ASW_label': 0.497075610794127,\n", + " 'graph_conn': 0.8462051187718054,\n", + " 'ASW_batch': 0.4679742865264416,\n", + " 'ASW_label/batch': 0.8438504014519913,\n", + " 'PCR_batch': 0.11005443461431771,\n", + " 'Average_Batch_Score': 0.28901436057037966,\n", + " 'avg_bio': 0.4438562343942996}\n", + "\n", + "raw\n", + "\n", + "\n", + "hvg\n", + "{'NMI_cluster/label': 0.6519618825284081, \n", + " 'ARI_cluster/label': 0.382739455731563, \n", + " 'ASW_label': 0.5102478610351682, \n", + " 'graph_conn': 0.9159615962052413, \n", + " 'ASW_batch': 0.5001192105482914, \n", + " 'ASW_label/batch': 0.9501239357502514, \n", + " 'PCR_batch': 0.13615515236009157, \n", + " 'Average_Batch_Score': 0.3181371814541915, \n", + " 'avg_bio': 0.5149830664317131} \n", + "\n", + "\n", + "scvi" + ] + } + ], + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_HVG_and_scVI.ipynb b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_HVG_and_scVI.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f179f792cde9bdd54c561f989799987003416a46 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_HVG_and_scVI.ipynb @@ -0,0 +1,451 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generating metrics for selected baselines" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import logging\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "from scipy import sparse\n", + "import scvi\n", + "\n", + "import sys\n", + "from sc_foundation_evals import utils\n", + "from sc_foundation_evals.helpers.custom_logging import log\n", + "\n", + "log.setLevel(logging.INFO)\n", + "\n", + "import warnings\n", + "os.environ[\"KMP_WARNINGS\"] = \"off\"\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specifying necessary variables, including path to anndata and names of columns with cell type labels and batch labels. I will be using the Pancreas dataset as an example, as described in the scGPT_zer-shot notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# specify the path to anndata object\n", + "adata_path = \"zero_shot_batch_data/pancreas.h5ad\"\n", + "# dataset_name is inferred from in_dataset_path\n", + "dataset_name = os.path.basename(adata_path).split(\".\")[0]\n", + "\n", + "# batch column found in adata.obs\n", + "batch_col = \"batch\"\n", + "# where are labels stored in adata.obs? \n", + "label_col = \"celltype\"\n", + "# where the raw counts are stored?\n", + "layer_key = \"counts\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reading the anndata." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 16382 × 19093\n", + " obs: 'tech', 'celltype', 'size_factors', 'batch'\n", + " layers: 'counts'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata = sc.read(adata_path)\n", + "adata" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the raw data is stored in `X` or other layer instead of `counts`, we need to copy it to counts to be able to use it in scVI." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "if layer_key == \"X\":\n", + " adata.layers[\"counts\"] = adata.X\n", + "elif layer_key != \"counts\":\n", + " adata.layers[\"counts\"] = adata.layers[layer_key]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, I opted for minimal preprocessing, similar to this suggested by Geneformer." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.filter_cells(adata, min_genes=10)\n", + "sc.pp.filter_genes(adata, min_cells=10)\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "sc.pp.log1p(adata)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Highly variable genes\n", + "\n", + "For first baseline, I selected 2000 highly variable genes (HVGs) using `scanpy.pp.highly_variable_genes` with default parameters. I do not want the adata to be subsetted, so I set `subset=False` and save the created cell embedding space to `adata.obsm['X_hvg']`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.highly_variable_genes(adata, flavor='seurat', subset=False, n_top_genes=2000)\n", + "\n", + "adata.obsm[\"X_genes\"] = adata.X[:, adata.var.highly_variable.values]\n", + "\n", + "# check if adata.obsm[\"X_genes\"] is sparse and if so, convert to dense\n", + "if sparse.issparse(adata.obsm[\"X_genes\"]):\n", + " adata.obsm[\"X_genes\"] = np.asarray(adata.obsm[\"X_genes\"].todense())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculating metrics similiarly to those calculated for Geneformer and scGPT." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "scib_metrics = utils.eval_scib_metrics(adata, \n", + " batch_key=batch_col, \n", + " label_key=label_col,\n", + " embedding_key=\"X_genes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.7003624430820531,\n", + " 'ARI_cluster/label': 0.4701226289442969,\n", + " 'ASW_label': 0.5141745712608099,\n", + " 'graph_conn': 0.877999727358774,\n", + " 'ASW_batch': 0.4712261650711298,\n", + " 'ASW_label/batch': 0.8851817055731181,\n", + " 'PCR_batch': 0.21440366886552753,\n", + " 'avg_bio': 0.5615532144290533}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(scib_metrics)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize, we will use the umap plotting function from scanpy." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pp.neighbors(adata, use_rep=\"X_genes\")\n", + "sc.tl.umap(adata, min_dist = 0.3)\n", + "sc.pl.umap(adata, color=[batch_col, label_col], wspace = 0.4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## scVI" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the other baseline, we look at the scVI model, which is a VAE model. To read more about it please refer to [scvi-tools manual](https://docs.scvi-tools.org/en/stable/user_guide/models/scvi.html) or [its publication](https://www.nature.com/articles/s41592-018-0229-2/)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "scvi.model.SCVI.setup_anndata(adata, layer=\"counts\", batch_key=batch_col)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specifying the model and training it." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model = scvi.model.SCVI(adata, n_layers=2, n_latent=30, gene_likelihood=\"nb\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "You are using a CUDA device ('NVIDIA A100-SXM4-80GB') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "SLURM auto-requeueing enabled. Setting signal handlers.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7cd661b1160e41cea2a4957530df4d48", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0%| | 0/400 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(adata, color=[batch_col, label_col], wspace = 0.4)" + ] + } + ], + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_evaluation_aggregated.ipynb b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_evaluation_aggregated.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1b132e131079420dc491b528a28233b2641e1fcc --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/notebooks/zero_shot_evaluation_aggregated.ipynb @@ -0,0 +1,1058 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Geneformer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import logging\n", + "import warnings\n", + "import sys\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", + "\n", + "from sc_foundation_evals import geneformer_forward as gf\n", + "from sc_foundation_evals import data, cell_embeddings, model_output\n", + "from sc_foundation_evals.helpers.custom_logging import log\n", + "log.setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geneformer_data = \"model path\"\n", + "# path to the pre-trained model, can work with the huggingface model hub\n", + "# i.e. ctheodoris/Geneformer\n", + "model_dir = os.path.join(geneformer_data)\n", + "# path to dictionaries in geneformer repo\n", + "dict_dir = \"Pretrain_data/\"\n", + "\n", + "# batch_size depends on available GPU memory\n", + "batch_size = 24\n", + "# output_dir is the path to which the results should be saved\n", + "output_dir = \"zero_shot_results/\"\n", + "# path to where we will store the embeddings and other evaluation outputs\n", + "model_out = os.path.join(output_dir, \"model_outputs\")\n", + "# if you can use multithreading specify num_workers, -1 means use all available\n", + "num_workers = -1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# specify the path to anndata object\n", + "in_dataset_path = \"Zero_shot_batch_data/pbmc.h5ad\"\n", + "# dataset_name is inferred from in_dataset_path\n", + "dataset_name = os.path.basename(in_dataset_path).split(\".\")[0]\n", + "# specify the path for the output of the pre-processing\n", + "preprocessed_path = f\"zero_shot_preprocess/{dataset_name}/\"\n", + "# create the preprocessed path if it does not exist\n", + "os.makedirs(preprocessed_path, exist_ok=True)\n", + "# in which column in adata.obs are gene names stored? if they are in index, the index will be copied to a column with this name\n", + "gene_col = \"gene_symbols\"\n", + "# batch column found in adata.obs\n", + "batch_col = \"batch\"\n", + "# where are labels stored in adata.obs? \n", + "label_col = \"celltype\" #\"str_labels\"\n", + "# where the raw counts are stored?\n", + "layer_key = \"counts\" #\"X\" " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geneform = gf.Geneformer_instance(save_dir = output_dir, \n", + " saved_model_path = model_dir,\n", + " explicit_save_dir = True,\n", + " num_workers = num_workers)\n", + "\n", + "geneform.load_pretrained_model()\n", + "geneform.load_vocab(dict_dir)\n", + "# input_data = data.InputData(adata_dataset_path = in_dataset_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# input_data.preprocess_data(gene_col = gene_col,\n", + "# model_type = \"geneformer\",\n", + "# save_ext = \"loom\",\n", + "# gene_name_id_dict = geneform.gene_name_id,\n", + "# preprocessed_path = preprocessed_path)\n", + "\n", + "# geneform.tokenize_data(adata_path = os.path.join(preprocessed_path, \n", + "# f\"{dataset_name}.loom\"),\n", + "# dataset_path = preprocessed_path,\n", + "# cell_type_col = label_col)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mINFO \u001b[0m | 2025-07-17 11:57:03 | \u001b[32mLoading data from /ibex/user/chenj0i/Geneformer/zero_shot_preprocess/pbmc/pbmc.loom\u001b[0m\n" + ] + } + ], + "source": [ + "geneform.load_tokenized_dataset(os.path.join(preprocessed_path, f\"{dataset_name}.dataset\"))\n", + "input_data = data.InputData(adata_dataset_path = os.path.join(preprocessed_path, f\"{dataset_name}.loom\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Embeddings extraction" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c89a344776044c95bfef70882ebd4ff8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Geneformer (extracting embeddings): 0%| | 0/500 [00:00 Dict[str, float]:\n", + " \"\"\"Evaluate biological and batch mixing metrics on an embedding or raw expression.\"\"\"\n", + " \n", + " results_dict = {}\n", + "\n", + " if subsample_frac is not None and 0 < subsample_frac < 1:\n", + " adata = adata.copy()\n", + " sc.pp.subsample(adata, fraction=subsample_frac, copy=False)\n", + " if verbose:\n", + " log.info(f\"Subsampled adata to {subsample_frac * 100:.1f}% of original cells.\")\n", + "\n", + " # Determine whether to use .X or .obsm[embedding_key]\n", + " if embedding_key == \"X\":\n", + " use_rep = \"X\"\n", + " adata.obsm[\"X\"] = adata.X\n", + " elif embedding_key in adata.obsm:\n", + " use_rep = embedding_key\n", + " else:\n", + " raise ValueError(f\"embedding_key '{embedding_key}' not found in adata.obsm or is not 'X'\")\n", + "\n", + " # Clear stale neighbors\n", + " if \"neighbors\" in adata.uns:\n", + " if verbose:\n", + " log.warning(f\"Removing stale neighbors computed from other representations.\")\n", + " adata.uns.pop(\"neighbors\", None)\n", + "\n", + " sc.pp.neighbors(adata, use_rep=use_rep)\n", + "\n", + " # Run Louvain across multiple resolutions\n", + " if resolutions is None:\n", + " resolutions = [2 * i / 20 for i in range(1, 21)] # Default: 20 steps from 0.1 to 2.0\n", + " # resolutions = [4 * i / 40 for i in range(1, 41)] # Default: 20 steps from 0.1 to 2.0\n", + "\n", + " best_nmi = -1\n", + " best_res = None\n", + " best_clustering = None\n", + "\n", + " if verbose:\n", + " log.info(f\"Searching for optimal clustering resolution on {use_rep}...\")\n", + "\n", + " for res in tqdm(resolutions, disable=not use_progress_bar, desc=\"Louvain clustering\"):\n", + " sc.tl.louvain(adata, resolution=res, key_added=\"temp_cluster\")\n", + " nmi = scib.metrics.nmi(adata, \"temp_cluster\", label_key)\n", + " if nmi > best_nmi:\n", + " best_nmi = nmi\n", + " best_res = res\n", + " best_clustering = adata.obs[\"temp_cluster\"].copy()\n", + " del adata.obs[\"temp_cluster\"]\n", + "\n", + " if verbose:\n", + " log.info(f\"Best resolution: {best_res:.2f} with NMI = {best_nmi:.4f}\")\n", + "\n", + " adata.obs[\"cluster\"] = best_clustering\n", + "\n", + " # Biological conservation metrics\n", + " results_dict[\"NMI_cluster/label\"] = scib.metrics.nmi(adata, \"cluster\", label_key, \"arithmetic\")\n", + " results_dict[\"ARI_cluster/label\"] = scib.metrics.ari(adata, \"cluster\", label_key)\n", + " results_dict[\"ASW_label\"] = scib.metrics.silhouette(adata, label_key, use_rep, \"euclidean\")\n", + "\n", + " # Batch effect metrics (if batch_key valid)\n", + " if batch_key is not None and batch_key in adata.obs and adata.obs[batch_key].nunique() > 1:\n", + " adata.obs[label_key] = adata.obs[label_key].astype(\"category\")\n", + " results_dict[\"graph_conn\"] = scib.metrics.graph_connectivity(adata, label_key)\n", + " results_dict[\"ASW_batch\"] = scib.metrics.silhouette(adata, batch_key, use_rep, \"euclidean\")\n", + " results_dict[\"ASW_label/batch\"] = scib.metrics.silhouette_batch(\n", + " adata, batch_key, label_key, embed=use_rep, metric=\"euclidean\", return_all=False\n", + " )\n", + " results_dict[\"PCR_batch\"] = scib.metrics.pcr(\n", + " adata, covariate=batch_key, embed=use_rep, recompute_pca=True, n_comps=50, verbose=False\n", + " )\n", + " results_dict[\"Average_Batch_Score\"] = (\n", + " results_dict[\"ASW_batch\"] + results_dict[\"PCR_batch\"]\n", + " ) / 2\n", + " else:\n", + " if verbose:\n", + " log.info(\"Skipping batch metrics — only one batch present or invalid batch_key.\")\n", + " \n", + " results_dict[\"avg_bio\"] = np.mean([\n", + " results_dict[\"NMI_cluster/label\"],\n", + " results_dict[\"ARI_cluster/label\"],\n", + " results_dict[\"ASW_label\"]\n", + " ])\n", + "\n", + " # Filter NaNs\n", + " results_dict = {k: v for k, v in results_dict.items() if not np.isnan(v)}\n", + "\n", + " return results_dict\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Embeddings metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Louvain clustering: 100%|██████████| 20/20 [00:02<00:00, 7.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.990590\n", + "CD14+ Monocytes 0.979706\n", + "CD4 T cells 0.987594\n", + "CD8 T cells 0.991305\n", + "Dendritic Cells 0.958009\n", + "FCGR3A+ Monocytes 0.990665\n", + "Megakaryocytes 0.857295\n", + "NK cells 0.977292\n", + "Other 0.933587\n" + ] + }, + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.6061048617613637,\n", + " 'ARI_cluster/label': 0.503784927975462,\n", + " 'ASW_label': 0.510432125069201,\n", + " 'graph_conn': 0.8852579724762832,\n", + " 'ASW_batch': 0.5012279110960662,\n", + " 'ASW_label/batch': 0.9628935503212096,\n", + " 'PCR_batch': 0.0007131078007747846,\n", + " 'Average_Batch_Score': 0.25097050944842053,\n", + " 'avg_bio': 0.5401073049353422}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict = eval_clustering_metrics(adata=input_data.adata, \n", + " batch_key=\"batch\",\n", + " label_key=\"celltype\",\n", + " embedding_key=\"geneformer\", # or \"X_scGPT\", etc.\n", + " verbose=True)\n", + "results_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "12c31089634046939fc59c2ef27adb59", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/2 [00:00 best_nmi:\n", + "# best_nmi = nmi\n", + "# best_res = res\n", + "# best_clustering = adata.obs[\"temp_cluster\"].copy()\n", + "# del adata.obs[\"temp_cluster\"]\n", + "\n", + "# adata.obs[\"cluster\"] = best_clustering\n", + "# # Biological conservation metrics\n", + "# results_dict[\"NMI_cluster/label\"] = scib.metrics.nmi(adata, \"cluster\", label_key, \"arithmetic\")\n", + "# results_dict[\"ARI_cluster/label\"] = scib.metrics.ari(adata, \"cluster\", label_key)\n", + "# results_dict[\"ASW_label\"] = scib.metrics.silhouette(adata, label_key, use_rep, \"euclidean\")\n", + "\n", + "# # Batch effect metrics (if batch_key valid)\n", + "# batch_key = \"batch\"\n", + "# if batch_key is not None and batch_key in adata.obs and adata.obs[batch_key].nunique() > 1:\n", + "# adata.obs[label_key] = adata.obs[label_key].astype(\"category\")\n", + "# results_dict[\"graph_conn\"] = scib.metrics.graph_connectivity(adata, label_key)\n", + "# results_dict[\"ASW_batch\"] = (1 - scib.metrics.silhouette(adata, batch_key, use_rep, \"euclidean\"))\n", + "# results_dict[\"ASW_label/batch\"] = scib.metrics.silhouette_batch(\n", + "# adata, batch_key, label_key, embed=use_rep, metric=\"euclidean\", return_all=False\n", + "# )\n", + "# results_dict[\"PCR_batch\"] = scib.metrics.pcr(\n", + "# adata, covariate=batch_key, embed=use_rep, recompute_pca=True, n_comps=50, verbose=False\n", + "# )\n", + "# results_dict[\"Average_Batch_Score\"] = (\n", + "# results_dict[\"ASW_batch\"] + results_dict[\"PCR_batch\"]\n", + "# ) / 2\n", + "# else:\n", + "# if verbose:\n", + "# log.info(\"Skipping batch metrics — only one batch present or invalid batch_key.\")\n", + "\n", + "# results_dict[\"avg_bio\"] = np.mean([\n", + "# results_dict[\"NMI_cluster/label\"],\n", + "# results_dict[\"ARI_cluster/label\"],\n", + "# results_dict[\"ASW_label\"]\n", + "# ])\n", + "\n", + "# # Filter NaNs\n", + "# results_dict = {k: v for k, v in results_dict.items() if not np.isnan(v)}\n", + "\n", + "# results_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Raw data metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Louvain clustering: 100%|██████████| 20/20 [00:02<00:00, 6.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.971033\n", + "CD14+ Monocytes 0.942456\n", + "CD4 T cells 0.988742\n", + "CD8 T cells 0.987412\n", + "Dendritic Cells 0.938792\n", + "FCGR3A+ Monocytes 0.950513\n", + "Megakaryocytes 0.752894\n", + "NK cells 0.890206\n", + "Other 0.914109\n" + ] + }, + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.6505152890434263,\n", + " 'ARI_cluster/label': 0.5759899223104351,\n", + " 'ASW_label': 0.5245759263634682,\n", + " 'graph_conn': 0.8891452955038966,\n", + " 'ASW_batch': 0.4964794989209622,\n", + " 'ASW_label/batch': 0.9262396008669715,\n", + " 'PCR_batch': 0.0007824623021499673,\n", + " 'Average_Batch_Score': 0.24863098061155608,\n", + " 'avg_bio': 0.5836937125724432}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict_raw = eval_clustering_metrics(adata=input_data.adata, \n", + " batch_key=\"batch\",\n", + " label_key=\"celltype\",\n", + " embedding_key=\"X\", # or \"X_scGPT\", etc.\n", + " verbose=True)\n", + "results_dict_raw" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scGraph import scGraph\n", + "\n", + "scg = scGraph(adata=input_data.adata, batch_key=\"batch\", label_key=\"celltype\", \n", + " trim_rate=0.05, thres_batch=1, thres_celltype=1, embedding_key=\"X\")\n", + "scg.preprocess()\n", + "scg.compute()\n", + "results = scg.evaluate()\n", + "print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# HVG & scVI" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## HVG" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import logging\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "from scipy import sparse\n", + "import scvi\n", + "\n", + "import sys\n", + "sys.path.append(\"zero_shot_batch_effect\")\n", + "from sc_foundation_evals import utils\n", + "from sc_foundation_evals.helpers.custom_logging import log\n", + "\n", + "log.setLevel(logging.INFO)\n", + "\n", + "import warnings\n", + "os.environ[\"KMP_WARNINGS\"] = \"off\"\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 11990 × 3346\n", + " obs: 'n_counts', 'batch', 'labels', 'str_labels', 'celltype'\n", + " var: 'gene_symbols', 'n_counts-0', 'n_counts-1', 'n_counts'\n", + " uns: 'cell_types'\n", + " obsm: 'design', 'normalized_qc', 'qc_pc', 'raw_qc'" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# specify the path to anndata object\n", + "adata_path = in_dataset_path\n", + "# dataset_name is inferred from in_dataset_path\n", + "dataset_name = os.path.basename(adata_path).split(\".\")[0]\n", + "\n", + "# batch column found in adata.obs\n", + "batch_col = \"batch\"\n", + "# where are labels stored in adata.obs? \n", + "label_col = \"celltype\"\n", + "# where the raw counts are stored?\n", + "layer_key = \"counts\"\n", + "\n", + "adata = sc.read(adata_path)\n", + "adata" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if layer_key == \"X\":\n", + " adata.layers[\"counts\"] = adata.X\n", + "elif layer_key != \"counts\":\n", + " adata.layers[\"counts\"] = adata.layers[layer_key]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.filter_cells(adata, min_genes=10)\n", + "sc.pp.filter_genes(adata, min_cells=10)\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "sc.pp.log1p(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.highly_variable_genes(adata, flavor='seurat', subset=False, n_top_genes=2000)\n", + "\n", + "# hvg_mask = adata.var[\"highly_variable\"].values\n", + "\n", + "adata.obsm[\"X_genes\"] = adata.X[:, adata.var.highly_variable.values]\n", + "\n", + "# check if adata.obsm[\"X_genes\"] is sparse and if so, convert to dense\n", + "if sparse.issparse(adata.obsm[\"X_genes\"]):\n", + " adata.obsm[\"X_genes\"] = np.asarray(adata.obsm[\"X_genes\"].todense())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mINFO \u001b[0m | 2025-06-22 14:32:11 | \u001b[32mSubsampled adata to 25.0% of original cells.\u001b[0m\n", + "\u001b[32mINFO \u001b[0m | 2025-06-22 14:32:12 | \u001b[32mSearching for optimal clustering resolution on X_genes...\u001b[0m\n", + "Louvain clustering: 100%|██████████| 20/20 [00:02<00:00, 8.92it/s]\n", + "\u001b[32mINFO \u001b[0m | 2025-06-22 14:32:14 | \u001b[32mBest resolution: 0.70 with NMI = 0.6944\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.990475\n", + "CD14+ Monocytes 0.994091\n", + "CD4 T cells 0.994429\n", + "CD8 T cells 0.996067\n", + "Dendritic Cells 0.990181\n", + "FCGR3A+ Monocytes 0.997131\n", + "Megakaryocytes 0.973109\n", + "NK cells 0.997118\n", + "Other 0.982645\n" + ] + }, + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.6944194464119003,\n", + " 'ARI_cluster/label': 0.6730602977338459,\n", + " 'ASW_label': 0.513224795460701,\n", + " 'graph_conn': 0.8757625892165339,\n", + " 'ASW_batch': 0.4997675784834428,\n", + " 'ASW_label/batch': 0.9905828886755944,\n", + " 'PCR_batch': 0.0008402505807411988,\n", + " 'Average_Batch_Score': 0.250303914532092,\n", + " 'avg_bio': 0.626901513202149}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict_hvg = eval_clustering_metrics(adata=adata, \n", + " batch_key=batch_col,\n", + " label_key=label_col,\n", + " embedding_key=\"X_genes\", # or \"X_scGPT\", etc.\n", + " verbose=True)\n", + "results_dict_hvg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scGraph import scGraph\n", + "\n", + "scg = scGraph(adata=input_data.adata, batch_key=\"batch\", label_key=\"celltype\", \n", + " trim_rate=0.05, thres_batch=1, thres_celltype=1, embedding_key=\"X_genes\")\n", + "scg.preprocess()\n", + "scg.compute()\n", + "results = scg.evaluate()\n", + "print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## scVI" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if \"counts\" not in adata.layers.keys():\n", + " adata.layers[\"counts\"] = adata.X.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnnData object with n_obs × n_vars = 11990 × 3345\n", + " obs: 'n_counts', 'batch', 'labels', 'str_labels', 'celltype', 'n_genes'\n", + " var: 'gene_symbols', 'n_counts-0', 'n_counts-1', 'n_counts', 'n_cells', 'highly_variable', 'means', 'dispersions', 'dispersions_norm'\n", + " uns: 'cell_types', 'log1p', 'hvg'\n", + " obsm: 'design', 'normalized_qc', 'qc_pc', 'raw_qc', 'X_genes'\n", + " layers: 'counts'" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "You are using a CUDA device ('NVIDIA A100-SXM4-80GB') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "SLURM auto-requeueing enabled. Setting signal handlers.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f654545481b64af2b59385925c0f992a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0%| | 0/400 [00:00 Dict[str, float]:\n", + " \"\"\"Evaluate biological and batch mixing metrics on an embedding or raw expression.\"\"\"\n", + " \n", + " results_dict = {}\n", + "\n", + " # Determine whether to use .X or .obsm[embedding_key]\n", + " if embedding_key == \"X\":\n", + " use_rep = \"X\"\n", + " adata.obsm[\"X\"] = adata.X\n", + " elif embedding_key in adata.obsm:\n", + " use_rep = embedding_key\n", + " else:\n", + " raise ValueError(f\"embedding_key '{embedding_key}' not found in adata.obsm or is not 'X'\")\n", + "\n", + " # Clear stale neighbors\n", + " if \"neighbors\" in adata.uns:\n", + " if verbose:\n", + " log.warning(f\"Removing stale neighbors computed from other representations.\")\n", + " adata.uns.pop(\"neighbors\", None)\n", + "\n", + " sc.pp.neighbors(adata, use_rep=use_rep)\n", + "\n", + " # Run Louvain across multiple resolutions\n", + " if resolutions is None:\n", + " resolutions = [2 * i / 20 for i in range(1, 21)] # Default: 20 steps from 0.1 to 2.0\n", + "\n", + " best_nmi = -1\n", + " best_res = None\n", + " best_clustering = None\n", + "\n", + " if verbose:\n", + " log.info(f\"Searching for optimal clustering resolution on {use_rep}...\")\n", + "\n", + " for res in tqdm(resolutions, disable=not use_progress_bar, desc=\"Louvain clustering\"):\n", + " sc.tl.louvain(adata, resolution=res, key_added=\"temp_cluster\")\n", + " nmi = scib.metrics.nmi(adata, \"temp_cluster\", label_key)\n", + " if nmi > best_nmi:\n", + " best_nmi = nmi\n", + " best_res = res\n", + " best_clustering = adata.obs[\"temp_cluster\"].copy()\n", + " del adata.obs[\"temp_cluster\"]\n", + "\n", + " if verbose:\n", + " log.info(f\"Best resolution: {best_res:.2f} with NMI = {best_nmi:.4f}\")\n", + "\n", + " adata.obs[\"cluster\"] = best_clustering\n", + "\n", + " # Biological conservation metrics\n", + " results_dict[\"NMI_cluster/label\"] = scib.metrics.nmi(adata, \"cluster\", label_key, \"arithmetic\")\n", + " results_dict[\"ARI_cluster/label\"] = scib.metrics.ari(adata, \"cluster\", label_key)\n", + " results_dict[\"ASW_label\"] = scib.metrics.silhouette(adata, label_key, use_rep, \"euclidean\")\n", + "\n", + " # Batch effect metrics (if batch_key valid)\n", + " if batch_key is not None and batch_key in adata.obs and adata.obs[batch_key].nunique() > 1:\n", + " results_dict[\"graph_conn\"] = scib.metrics.graph_connectivity(adata, label_key)\n", + " results_dict[\"ASW_batch\"] = scib.metrics.silhouette(adata, batch_key, use_rep, \"euclidean\")\n", + " results_dict[\"ASW_label/batch\"] = scib.metrics.silhouette_batch(\n", + " adata, batch_key, label_key, embed=use_rep, metric=\"euclidean\", return_all=False\n", + " )\n", + " results_dict[\"PCR_batch\"] = scib.metrics.pcr(\n", + " adata, covariate=batch_key, embed=use_rep, recompute_pca=True, n_comps=50, verbose=False\n", + " )\n", + " else:\n", + " if verbose:\n", + " log.info(\"Skipping batch metrics — only one batch present or invalid batch_key.\")\n", + " \n", + " results_dict[\"avg_bio\"] = np.mean([\n", + " results_dict[\"NMI_cluster/label\"],\n", + " results_dict[\"ARI_cluster/label\"],\n", + " results_dict[\"ASW_label\"]\n", + " ])\n", + "\n", + " # Filter NaNs\n", + " results_dict = {k: v for k, v in results_dict.items() if not np.isnan(v)}\n", + "\n", + " return results_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Louvain clustering: 100%|██████████| 20/20 [00:15<00:00, 1.32it/s]\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: silhouette_score\n", + "group \n", + "B cells 0.986484\n", + "CD14+ Monocytes 0.943531\n", + "CD4 T cells 0.980745\n", + "CD8 T cells 0.951482\n", + "Dendritic Cells 0.956119\n", + "FCGR3A+ Monocytes 0.986242\n", + "Megakaryocytes 0.856766\n", + "NK cells 0.953083\n", + "Other 0.930244\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/anndata/_core/anndata.py:522: FutureWarning: The dtype argument is deprecated and will be removed in late 2024.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import scanpy as sc \n", + "adata = sc.read_h5ad(\"zero_shot_batch_data/pbmc.h5ad\") \n", + "\n", + "results_dict = eval_clustering_metrics(adata=adata, \n", + " batch_key=\"batch\",\n", + " label_key=\"celltype\",\n", + " embedding_key=\"X\", # or \"X_scGPT\", etc.\n", + " verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.7043350648326699,\n", + " 'ARI_cluster/label': 0.6456273245075416,\n", + " 'ASW_label': 0.5333220548927784,\n", + " 'graph_conn': 0.9038879996225364,\n", + " 'ASW_batch': 0.4965497492812574,\n", + " 'ASW_label/batch': 0.9494108132303586,\n", + " 'PCR_batch': 0.0009914006163016576,\n", + " 'avg_bio': 0.6277614814109966}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_786097/2986997571.py:30: ImplicitModificationWarning: Setting element `.obsm['X']` of view, initializing view as actual.\n", + " adata.obsm[\"X\"] = adata.X\n", + "Louvain clustering: 100%|██████████| 20/20 [00:11<00:00, 1.68it/s]\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n", + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/scib/metrics/graph_connectivity.py:56: FutureWarning: pandas.value_counts is deprecated and will be removed in a future version. Use pd.Series(obj).value_counts() instead.\n", + " tab = pd.value_counts(labels)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean silhouette per group: nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/anndata/_core/anndata.py:522: FutureWarning: The dtype argument is deprecated and will be removed in late 2024.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "results_dict_ood = eval_clustering_metrics(adata=adata_ood[:15000],\n", + " batch_key=\"batch\",\n", + " label_key=\"cell_type\",\n", + " embedding_key=\"X\", \n", + " verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'NMI_cluster/label': 0.9334102174490695,\n", + " 'ARI_cluster/label': 0.9699361136567832,\n", + " 'ASW_label': 0.5538543930108312,\n", + " 'graph_conn': 0.9231509101914211,\n", + " 'ASW_batch': 0.6438532075334105,\n", + " 'PCR_batch': 0.042066597759588056,\n", + " 'avg_bio': 0.8190669080388946}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_dict_ood" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Downstream_tasks/Zero_shot_batch_effect/requirements.txt b/Downstream_tasks/Zero_shot_batch_effect/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..57ed62e72d7ea47227ef223465312a101fb07de8 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/requirements.txt @@ -0,0 +1,12 @@ +anndata==0.9.2 +colorlog==6.7.0 +scgpt==0.1.6 +geneformer==0.0.1 +PyComplexHeatmap +numpy +pandas +scanpy +scipy +seaborn +scib +scvi-tools \ No newline at end of file diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__init__.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a539f6914dbadef3d6bb3d57529028d893b91a8 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..670ad2cf83fe84dac2a965709420434ef7ae6ba8 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/__init__.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c284d8a39a5660bcddbfad117b7d6e009e8cae3f Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f742f56c37574773e260f8ac8e3ff96e4c8e882d Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/cell_embeddings.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be46ed734c8efabde543455e0915bb39427734d3 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c35b1f36fc7b4d6695a7e8f9cb916bcd9d7440ee Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/data.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e2ab6ac887f3d04cea9513257373239c50ddad0 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fcc769a2f0eff9f47d31192632ebfe0701bcca7 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/geneformer_forward.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9edc92452c42a621fa4fa04035f97dc0f6d776c1 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa89ac5cf76700c8ca01359fcd863f23ae416087 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/model_output.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/scgpt_forward.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/scgpt_forward.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7b7e8886f7f43fcd4430f14ef159205fffa6fa6 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/scgpt_forward.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6165f6fce64baeafe0ff2a003c8d4622edb829f4 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb4783a7c96e84c959963ff7156287a4785d5d77 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/__pycache__/utils.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/cell_embeddings.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/cell_embeddings.py new file mode 100644 index 0000000000000000000000000000000000000000..b37cf2faf409e7ae3f36bec570ba219c22895fec --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/cell_embeddings.py @@ -0,0 +1,417 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. + +import os +from typing import List, Optional, Tuple, Dict, Union +import pandas as pd +import matplotlib.pyplot as plt +plt.style.use('fivethirtyeight') + +import seaborn as sns +import scanpy as sc + +from .helpers import umap +from .helpers.custom_logging import log + +from . import data, utils +from .geneformer_forward import Geneformer_instance +# from .scgpt_forward import scGPT_instance + +class CellEmbeddingsEval(): + def __init__(self, + # model_instance: Union[scGPT_instance, + # Geneformer_instance], + model_instance: Union[Geneformer_instance], + data: data.InputData, + label_key: Union[str, List[str]] = "cell_type", + batch_key: Optional[str] = None, + output_dir: Optional[str] = None, + log_wandb: bool = False) -> None: + + # test if model_instance is an instance of scGPT_instance or Geneformer_instance + # if not isinstance(model_instance, + # (scGPT_instance, Geneformer_instance)): + # msg = ("scgpt_instance must be an instance of " + # "scGPT_instance or Geneformer_instance") + if not isinstance(model_instance, + (Geneformer_instance)): + msg = ("scgpt_instance must be an instance of " + "scGPT_instance or Geneformer_instance") + log.error(msg) + raise ValueError(msg) + + # test if instance is properly processed + if not hasattr(model_instance, "cell_embeddings"): + msg = "Cell embeddings need to be extracted first" + log.error(msg) + raise ValueError(msg) + + # if wandb set to true and not initialized, throw error + if log_wandb and not model_instance._wandb: + msg = "wandb is not initialized in model_instance" + log.error(msg) + raise ValueError(msg) + + self._wandb = model_instance._wandb + + self.eval_instance = model_instance + self.data = data + + if batch_key is not None: + if batch_key not in self.data.adata.obs.columns: + msg = f"batch_key {batch_key} not found in adata.obs" + log.error(msg) + raise ValueError(msg) + else: + self.batch_key = batch_key + else: + try: + self.batch_key = self.data.batch_str_col + except AttributeError: + msg = "batch_key not provided and not found in data object" + log.error(msg) + raise ValueError(msg) + + if output_dir is not None: + # if output dir is provided, use it + self.output_dir = output_dir + # check if output_dir exists + if not os.path.exists(self.output_dir): + log.warning(f"Creating the output directory {self.output_dir}") + os.makedirs(self.output_dir) + else: + # use the same output_dir as the scgpt_instance + self.output_dir = self.eval_instance.output_dir + + # if label_key is string, convert to list + if isinstance(label_key, str): + label_key = [label_key] + self.label_key = label_key + + # make sure that each label exists and is categorical in adata.obs + for label in self.label_key: + if label not in self.data.adata.obs.columns: + msg = f"Label {label} not found in adata.obs" + log.error(msg) + raise ValueError(msg) + self.data.adata.obs[label] = self.data.adata.obs[label].astype("category") + + def evaluate(self, + embedding_key: str = "X_scGPT", + n_cells: int = 7500) -> pd.DataFrame: + + adata_ = self.data.adata.copy() + + # if adata_ too big, take a subset + if adata_.n_obs > n_cells: + log.warning(f"adata_ has {adata_.n_obs} cells. " + f"Taking a subset of {n_cells} cells.") + sc.pp.subsample(adata_, n_obs = n_cells, copy = False) + + met_df = pd.DataFrame(columns = ["metric", "label", "value"]) + + # get unique values in self.label_key preserving the order + label_cols = [x for i, x in enumerate(self.label_key) + if x not in self.label_key[:i]] + # remove label columns that are not in adata_.obs + label_cols = [x for x in label_cols if x in adata_.obs.columns] + + if len(label_cols) == 0: + msg = f"No label columns {self.label_key} found in adata.obs" + log.error(msg) + raise ValueError(msg) + + # check if the embeddings are in adata + if embedding_key not in adata_.obsm.keys(): + msg = f"Embeddings {embedding_key} not found in adata.obsm" + log.error(msg) + raise ValueError(msg) + + for label in label_cols: + log.debug(f"Computing metrics for {label}") + + metrics = utils.eval_scib_metrics(adata_, + batch_key = self.batch_key, + label_key = label, + embedding_key = embedding_key) + for metric in metrics.keys(): + log.debug(f"{metric} for {label}: {metrics[metric]}") + + # log to wandb if initialized + if self._wandb: + self._wandb.log({f"{embedding_key}/{label}/{metric}": metrics[metric]}) + + # add row to the dataframe + met_df.loc[len(met_df)] = [metric, label, metrics[metric]] + + met_df.to_csv(os.path.join(self.output_dir, + f"{embedding_key}__metrics.csv"), + index = False) + + if self._wandb: + wandb_df = self._wandb.Table(data = met_df) + self._wandb.log({f"{embedding_key}/metrics": wandb_df}) + return met_df + + def create_original_umap(self, + out_emb: str = "X_umap_input") -> None: + + sc.pp.neighbors(self.data.adata) + temp = sc.tl.umap(self.data.adata, min_dist = 0.3, copy=True) + self.data.adata.obsm[out_emb] = temp.obsm["X_umap"].copy() + + # TODO: this should be a more generic function that can plot any embedding + def visualize(self, + embedding_key: str = "X_scGPT", + return_fig: bool = False, + plot_size: Tuple[float, float] = (9, 7), + plot_title: Optional[str] = None, + plot_type: [List, str] = "simple", + n_cells: int = 7500 + ) -> Optional[Dict[str, plt.figure]]: + + raw_emb = "X_umap_input" + + if embedding_key == raw_emb: + # if the umap_raw embedding is used, create it first + self.create_original_umap(out_emb = embedding_key) + + # if adata already has a umap embedding warn that it will be overwritten + if "X_umap" in self.data.adata.obsm.keys(): + old_umap_name = "X_umap_old" + log.warning(f"Copying existing UMAP embedding to {old_umap_name} " + "and overwriting X_umap.") + self.data.adata.obsm[old_umap_name] = self.data.adata.obsm["X_umap"].copy() + + # check if the embeddings are in adata + if embedding_key not in self.data.adata.obsm.keys(): + msg = f"Embeddings {embedding_key} not found in adata." + log.error(msg) + raise ValueError(msg) + + # if embedding_key contains the string umap, do not compute umap again + if embedding_key != raw_emb: + # compute umap embeddings + sc.pp.neighbors(self.data.adata, use_rep = embedding_key) + sc.tl.umap(self.data.adata, min_dist = 0.3) + + adata_ = self.data.adata.copy() + # if adata_ too big, take a subset + if adata_.n_obs > n_cells: + log.warning(f"adata_ has {adata_.n_obs} cells. " + f"Taking a subset of {n_cells} cells.") + sc.pp.subsample(adata_, n_obs = n_cells, copy = False) + # save the subsetted adata.obs + adata_.obs.to_csv(os.path.join(self.output_dir, + "adata_obs_subset.csv")) + + + + # make sure plot size is a tuple of numbers + try: + w, h = plot_size + if not isinstance(h, (int, float)) or not isinstance(w, (int, float)): + msg = f"Height (h = {h}) or width (w = {w}) not valid." + log.error(msg) + raise TypeError(msg) + except TypeError: + msg = f"Plot size {plot_size} is not a tuple of numbers." + log.error(msg) + raise TypeError(msg) + + # get unique values in self.label_key preserving the order + label_cols = self.label_key + [self.batch_key] + label_cols = [x for i, x in enumerate(label_cols) + if x not in label_cols[:i]] + # remove label columns that are not in adata_.obs + label_cols = [x for x in label_cols + if x in self.data.adata.obs.columns] + + if len(label_cols) == 0: + msg = f"No label columns {self.label_key} found in adata.obs" + log.error(msg) + raise ValueError(msg) + + # set the colors for the labels + labels = dict() + labels_colors = dict() + palettes = ['viridis', 'inferno', + 'mako', 'rocket', + 'tab20', 'colorblind', + 'tab20b', 'tab20c'] + + if len(label_cols) > len(palettes): + log.warning("More labels than palettes. Adding random colors.") + palettes = palettes + ["random"] * (len(label_cols) - len(palettes)) + + # creating palettes for the labels + for i, label in enumerate(label_cols): + labels[label] = self.data.adata.obs[label].unique() + if len(labels[label]) > 10: + log.warning(f"More than 10 labels for {label}." + f"The plots might be hard to read.") + labels_colors[label] = dict(zip(labels[label], + umap.generate_pallette(n = len(labels[label]), + cmap = palettes[i]))) + + + + figs = {} + + # if plot_type a string, convert to list + if isinstance(plot_type, str): + plot_type = [plot_type] + + plot_type = [x.lower() for x in plot_type] + # get unique values in plot_type + plot_type = [x for i, x in enumerate(plot_type) + if x not in plot_type[:i]] + old_plot_type = plot_type + # check if plot_type is valid + valid_plot_types = ["simple", "wide", "scanpy"] + + # create a subset of plot_type that is valid + plot_type = [x for x in plot_type if x in valid_plot_types] + if len(plot_type) == 0: + msg = f"Plot type {plot_type} is not valid. Valid plot types are {valid_plot_types}" + log.error(msg) + raise ValueError(msg) + + # print a warning if plot_type is not valid + if len(plot_type) < len(old_plot_type): + log.warning(f"Some plot type(s) {old_plot_type} is not valid. " + f"Valid plot types are {valid_plot_types}. " + f"Plotting only {plot_type}") + + + plt_emb = "X_umap" if embedding_key != raw_emb else embedding_key + + plot_title = (plot_title + if plot_title is not None + else "UMAP of the cell embeddings") + + if "simple" in plot_type: + fig, axs = plt.subplots(ncols = len(label_cols), + figsize = (len(label_cols) * w, h), + squeeze = False) + + axs = axs.flatten() + + # basic plotting, problematic: size of the points + embedding = self.data.adata.obsm[plt_emb] + for i, label in enumerate(label_cols): + log.debug(f"Plotting the embeddings for {label}") + # remove axis and grid from the plot + axs[i].axis('off') + # plot umap embeddings, add color by cell type + axs[i].scatter(embedding[:, 0], embedding[:, 1], + # make points smaller + s = 0.5, + c = [labels_colors[label][x] for x + in self.data.adata.obs[label]]) + legend_handles = [axs[i].plot([], [], + marker = "o", ls = "", + color = c, label = l)[0] + for l, c in labels_colors[label].items()] + axs[i].legend(handles = legend_handles, + bbox_to_anchor = (1.05, 1), + loc = 'upper left') + + # Add a title to the plot + axs[i].title.set_text(f"{label}") + + fig.suptitle(plot_title, fontsize = 16) + fig.tight_layout() + fig.subplots_adjust(top = 0.85) + + fig_savefig = os.path.join(self.output_dir, + f"umap__{embedding_key}.png") + fig.savefig(fig_savefig) + + # if wandb initialized, log the figure + if self._wandb: + self._wandb.log({f"umap__{embedding_key}": self._wandb.Image(fig_savefig)}) + + if return_fig: + figs["umap"] = fig + + # wide plotting + if "wide" in plot_type: + df = pd.DataFrame(self.data.adata.obsm[plt_emb], + columns = ["umap_1", "umap_2"]) + for i, label in enumerate(label_cols): + if self.data.adata.obs[label].unique().shape[0] <= 10: + df[label] = self.data.adata.obs[label].tolist() + wide_plot = sns.relplot(data = df, + col = label, + x = "umap_1", + y = "umap_2", + hue = label, + style = label, + legend = "full", + palette = palettes[i]) + # switch off axes + for axes in wide_plot.axes.flat: + axes.set_axis_off() + sns.move_legend(wide_plot, "upper left", bbox_to_anchor=(1, 1)) + wide_plot.fig.suptitle(plot_title, fontsize = 16) + wide_plot.fig.tight_layout() + wide_plot.fig.subplots_adjust(top = 0.85) + + wide_plot_savefig = os.path.join(self.output_dir, + f"umap_wide__{embedding_key}_{label}.png") + wide_plot.savefig(wide_plot_savefig) + + # if wandb initialized, log the figure + if self._wandb: + self._wandb.log({f"umap_wide__{embedding_key}_{label}": self._wandb.Image(wide_plot_savefig)}) + if return_fig: + figs[label] = wide_plot + else: + msg = f"More than 10 labels for {label}. Skipping wide plot." + log.warning(msg) + + + if "scanpy" in plot_type: + # scanpy plotting + labels_colors_flat = {k: v for d in labels_colors + for k, v in labels_colors[d].items()} + if embedding_key == raw_emb: + # TODO: this needs rewriting + adata_temp__ = self.data.adata.copy() + adata_temp__.obsm["X_umap"] = self.data.adata.obsm[raw_emb].copy() + fig2 = sc.pl.umap(adata_temp__, + color = label_cols, + add_outline = True, + layer = plt_emb, + legend_loc = 'on data', + palette = labels_colors_flat, + return_fig = True) + # remove the temporary adata + del adata_temp__ + else: + fig2 = sc.pl.umap(self.data.adata, + color = label_cols, + add_outline = True, + layer = plt_emb, + legend_loc = 'on data', + palette = labels_colors_flat, + return_fig = True) + fig2.suptitle(plot_title, fontsize = 16) + fig2.tight_layout() + fig2.subplots_adjust(top = 0.85) + + fig2_savefig = os.path.join(self.output_dir, + f"umap_scanpy__{embedding_key}.png") + fig2.savefig(fig2_savefig) + + # if wandb initialized, log the figure + if self._wandb: + self._wandb.log({f"umap_scanpy/{embedding_key}": self._wandb.Image(fig2_savefig)}) + + if return_fig: + figs["umap_scanpy"] = fig2 + + + if return_fig: + return figs diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/data.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/data.py new file mode 100644 index 0000000000000000000000000000000000000000..9314beec97f1e8ecbe0a03a5027173f4e2bac2d9 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/data.py @@ -0,0 +1,330 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. +import os +import scanpy as sc + +from typing import List, Optional, Union, Dict, Literal + +import numpy as np +# from scgpt.preprocess import Preprocessor + +from .helpers.custom_logging import log + +# switch of warnings +import warnings +os.environ["KMP_WARNINGS"] = "off" +warnings.filterwarnings('ignore') + +class InputData(): + def __init__(self, + adata_dataset_path: str) -> None: + + # check if the dataset exists + if not os.path.isfile(adata_dataset_path): + msg = f"Dataset {adata_dataset_path} does not exist!" + log.error(msg) + raise ValueError(msg) + + msg = f"Loading data from {adata_dataset_path}" + log.info(msg) + + self.dataset_name = os.path.basename(adata_dataset_path).split(".")[0] + self.adata_path = adata_dataset_path + # read in the dataset + self.adata = sc.read(adata_dataset_path) + + self.data_config = dict( + data_path = adata_dataset_path, + ) + # this will be updated if add_batch_labels is called + self.batch_key = None + + def add_batch_labels(self, + batch_key: Optional[str] = None, + batch_str_col: str = "str_batch", + batch_id_col: str = "batch_id") -> int: + + self.batch_key = batch_key + self.batch_id_col = batch_id_col + self.batch_str_col = batch_str_col + + if self.batch_key is None: + # try guessing which column contains batch info + # get the columns that contain "batch" + batch_cols = [col for col in + self.adata.obs.columns if "batch" in col.lower()] + if len(batch_cols) == 1: + ori_batch_col = batch_cols[0] + log.info(f"Using {ori_batch_col} as batch column") + else: + msg = "Cannot determine which column contains batch information!" + log.error(msg) + raise ValueError(msg) + else: + ori_batch_col = self.batch_key + log.info(f"Using {ori_batch_col} as batch column") + + self.adata.obs[self.batch_str_col] = ( + self + .adata + .obs[ori_batch_col] + .astype(str) + ) + batch_id_labels = ( + self.adata + .obs[self.batch_str_col] + .astype("category") + .cat + .codes + .values + ) + self.adata.obs[self.batch_id_col] = batch_id_labels + log.debug(self.adata.obs[self.batch_id_col].value_counts()) + num_batch_types = len(set(batch_id_labels)) + log.debug(f"Number of batch types: {num_batch_types}") + return num_batch_types + + def preprocess_data(self, + gene_col: str = "gene_name", + vocab_source: str = "model_default", + fract_matching: float = 0.5, + model_type: str = "scGPT", + # arguments for Geneformer preprocessing + gene_name_id_dict: Optional[Dict[str, str]] = None, + filter_gene_by_cells: Optional[int] = 10, + filter_cell_by_genes: Optional[int] = 10, + preprocessed_path: Optional[str] = None, + save_ext: Optional[str] = "loom", + # arguments for scGPT preprocessing + gene_vocab: Optional[List[str]] = None, + data_is_raw: Optional[bool] = True, + counts_layer: Optional[str] = "X", + filter_gene_by_counts: Optional[int] = 3, + filter_cell_by_counts: Optional[Union[int, bool]] = False, + n_hvg: Optional[Union[int, bool]] = 1200, + normalize_total: Optional[int] = 1e4, + n_bins: Optional[int] = 50, + **kwargs) -> None: + + if gene_col not in self.adata.var.columns: + self.adata.var[gene_col] = self.adata.var.index.tolist() + log.warning(f"Gene names not found in var columns. Using index instead.") + + self.gene_col = gene_col + self.data_config["gene_col"] = gene_col + + # check if model_type is valid + model_type = model_type.lower() + valid_model_types = ["scgpt", "geneformer"] + + if model_type not in valid_model_types: + msg = (f"Model type {model_type} not supported! " + f"Valid options are: {valid_model_types}.") + log.error(msg) + raise ValueError(msg) + + self.data_config["model_type"] = model_type + self.data_config["vocab_source"] = vocab_source + + # note raw data shape + self.data_config["input__n_cells"] = self.adata.shape[0] + self.data_config["input__n_genes"] = self.adata.shape[1] + + # check if scgpt found in lowercase model string + if model_type == "scgpt": + + self.data_config["data_is_raw"] = data_is_raw + self._preprocess_data_scGPT(gene_vocab = gene_vocab, + fract_matching = fract_matching, + input_key = counts_layer, + filter_gene_by_counts = filter_gene_by_counts, + filter_cell_by_counts = filter_cell_by_counts, + normalize_total = normalize_total, + n_hvg = n_hvg, + n_bins = n_bins, + preprocessed_path = preprocessed_path, + **kwargs) + + elif model_type == "geneformer": + + self._preprocess_data_geneformer(preprocessed_path = preprocessed_path, + save_ext = save_ext, + gene_name_id_dict = gene_name_id_dict, + fract_matching = fract_matching, + filter_cell_by_genes = filter_cell_by_genes, + filter_gene_by_cells = filter_gene_by_cells) + + # note raw preprocessed shape + self.data_config["preprocessed__n_cells"] = self.adata.shape[0] + self.data_config["preprocessed__n_genes"] = self.adata.shape[1] + + # def _preprocess_data_scGPT(self, + # gene_vocab: List[str], + # fract_matching: float = 0.5, + # input_key: str = "X", + # filter_gene_by_counts: int = 3, + # filter_cell_by_counts: Union[int, bool] = False, + # normalize_total: int = 1e4, + # n_hvg: Union[int, bool] = 1200, + # n_bins: int = 51, + # normed_key: str = "X_normed", + # log1p_key: str = "X_log1p", + # binned_key: str = "X_binned", + # preprocessed_path: Optional[str] = None) -> None: + + # # preprocess the data + # self.adata.var["id_in_vocab"] = [ + # 1 if gene in gene_vocab else -1 + # for gene in self.adata.var[self.gene_col] + # ] + # gene_ids_in_vocab = np.array(self.adata.var["id_in_vocab"]) + # fract = np.sum(gene_ids_in_vocab >= 0)/len(gene_ids_in_vocab) + + # if fract < fract_matching: + # msg = f"Only {fract*100:.2f}% genes in the dataset are in the vocabulary!" + # log.error(msg) + # raise ValueError(msg) + + # self.adata = self.adata[:, self.adata.var["id_in_vocab"] >= 0] + # self.data_config["fract_genes_in_vocab"] = fract + + # log.info( + # f"Matched {np.sum(gene_ids_in_vocab >= 0)}/{len(gene_ids_in_vocab)}" + # f" genes in vocabulary of size {len(gene_vocab)}." + # ) + + # if n_hvg < 1: + # n_hvg = False + # # append preprocessing parameters to run config + # d_ = { + # "preprocesing__input_key": input_key, + # "preprocesing__filter_gene_by_counts": filter_gene_by_counts, + # "preprocesing__filter_cell_by_counts": filter_cell_by_counts, + # "preprocesing__normalize_total": normalize_total, + # "preprocesing__normed_key": normed_key, + # "preprocesing__log1p_key": log1p_key, + # "preprocesing__binned_key": binned_key, + # "preprocesing__n_bins": n_bins, + # "preprocesing__n_hvg": n_hvg, + # } + + # self.data_config.update(d_) + + # msg = "Preprocessing data" + # log.info(msg) + + # # Preprocess the data following the scGPT data pre-processing pipeline + # preprocessor = Preprocessor( + # # the key in adata.layers to use as raw data + # use_key = input_key, + # # step 1 + # filter_gene_by_counts = filter_gene_by_counts, + # # step 2 + # filter_cell_by_counts = filter_cell_by_counts, + # # 3. whether to normalize the raw data and to what sum + # normalize_total = normalize_total, + # # the key in adata.layers to store the normalized data + # result_normed_key = normed_key, + # # 4. whether to log1p the normalized data + # log1p = self.data_config["data_is_raw"], + # result_log1p_key = log1p_key, + # # 5. whether to subset the raw data to highly variable genes + # subset_hvg = n_hvg, + # hvg_flavor = ("seurat_v3" + # if self.data_config["data_is_raw"] + # else "cell_ranger"), + # # 6. whether to bin the raw data and to what number of bins + # binning = n_bins, + # # the key in adata.layers to store the binned data + # result_binned_key = binned_key, + # ) + + # preprocessor(self.adata, batch_key = self.batch_key) + + # if preprocessed_path is not None: + # # check if path exists + # if os.path.exists(preprocessed_path): + # msg = (f"Saving {self.dataset_name} preprocessed data " + # f"to {preprocessed_path}") + # self.adata.write(os.path.join(preprocessed_path, + # f"{self.dataset_name}.h5ad")) + # else: + # msg = (f"Directory {preprocessed_path} does not exist! " + # "Skipping saving preprocessed data.") + # log.warning(msg) + + + def _preprocess_data_geneformer(self, + preprocessed_path: str, + gene_name_id_dict: Dict[str, str], + save_ext: Literal["loom", "h5ad"] = "loom", + fract_matching: float = 0.5, + filter_cell_by_genes: int = 10, + filter_gene_by_cells: int = 10) -> None: + + # for geneformer we need the path to save the data, check if exists + if preprocessed_path is None or not os.path.exists(preprocessed_path): + msg = ("For Geneformer, preprocessed_path needs to be specified " + "and exists to save the dataset. Provided path: " + f"{preprocessed_path}") + log.error(msg) + raise ValueError(msg) + + sc.pp.calculate_qc_metrics(self.adata, + percent_top = None, + log1p = False, + inplace = True) + self.adata.obs['n_counts'] = self.adata.obs['total_counts'] + sc.pp.filter_cells(self.adata, min_genes=int(filter_cell_by_genes)) + sc.pp.filter_genes(self.adata, min_cells=int(filter_gene_by_cells)) + + # for now, assuming gene names and using geneformer dictionary + # to match gene nam to ensembl id; TODO: look into better way? + # this is tricky because ensembl ids change, in a way + # gene names are more constant; however they aren't necessarily unique + # and might be missing from the geneformer dictionary/be different + # for now, make sure to report the fraction of genes that are matched + # and save the match/not matched + + self.adata.var['ensembl_id'] = self.adata.var[self.gene_col].map(gene_name_id_dict) + self.adata.var['has_ensembl_match'] = self.adata.var['ensembl_id'].notnull() + + n_all_genes = self.adata.var.shape[0] + n_matched = self.adata.var.has_ensembl_match.sum() + fract = n_matched / n_all_genes + + if fract < fract_matching: + msg = f"Only {fract*100:.2f}% genes in the dataset are in the vocabulary!" + log.error(msg) + raise ValueError(msg) + + # save the adata.var dataframe + self.adata.var.to_csv(os.path.join(preprocessed_path, + f"{self.dataset_name}_var.csv"), + index = False) + + # filter out genes that don't have a match + self.adata = self.adata[:, self.adata.var.has_ensembl_match] + + # additionally, add the order of the samples, since they will be sorted + # to speed up forward pass + self.adata.obs['adata_order'] = self.adata.obs.index.tolist() + + self.data_config["fract_genes_in_vocab"] = fract + + log.info( + f"Matched {fract*100:.2f}% genes ({n_matched}/{n_all_genes})" + f" genes in vocabulary of size {len(gene_name_id_dict)}." + ) + + if save_ext == "loom": + self.adata.write_loom(os.path.join(preprocessed_path, + f"{self.dataset_name}.loom")) + elif save_ext == "h5ad": + self.adata.write_h5ad(os.path.join(preprocessed_path, + f"{self.dataset_name}.h5ad")) + + + def get_config(self): + return self.data_config + \ No newline at end of file diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/geneformer_forward.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/geneformer_forward.py new file mode 100644 index 0000000000000000000000000000000000000000..cd4986ef0b7bfc0536329a7648aaedf729c51b17 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/geneformer_forward.py @@ -0,0 +1,365 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. +import os + +import importlib.util +import pickle + +from typing import Dict, Optional, List + +import numpy as np +import torch +import torch.nn.functional as F + +from transformers import BertForMaskedLM +from geneformer.tokenizer import TranscriptomeTokenizer + +# from geneformer import EmbExtractor +from tqdm.auto import trange +from datasets import Dataset, load_from_disk +from . import utils +from .data import InputData +from .helpers.custom_logging import log + +from GF_CAB import CustomBertForMaskedLM + +import warnings +os.environ["KMP_WARNINGS"] = "off" +warnings.filterwarnings("ignore") + +def pad_tensor(t: torch.Tensor, + max_size: int, + pad_token_id: int = 0) -> torch.Tensor: + """ + Pad a tensor to a max size + """ + + return F.pad(t, pad = (0, max_size - t.numel()), + mode = 'constant', value = pad_token_id) + +# get cell embeddings excluding padding +def mean_nonpadding_embs(embs, original_lens): + # mask based on padding lengths + mask = torch.arange(embs.size(1)).unsqueeze(0).to("cuda") < original_lens.unsqueeze(1) + + # extend mask dimensions to match the embeddings tensor + mask = mask.unsqueeze(2).expand_as(embs) + + # use the mask to zero out the embeddings in padded areas + masked_embs = embs * mask.float() + + # sum and divide by the lengths to get the mean of non-padding embs + mean_embs = masked_embs.sum(1) / original_lens.view(-1, 1).float() + return mean_embs + +def average_embeddings(embs: torch.Tensor, + org_lengths: torch.Tensor) -> torch.Tensor: + + device = embs.device + + # mask based on padding lengths + mask = (torch.arange(embs.size(1)).unsqueeze(0).to(device) < + org_lengths.unsqueeze(1)) + + # extend mask dimensions to match the embeddings tensor + if len(embs.shape) > 2: + mask = mask.unsqueeze(2).expand_as(embs) + + # Use the mask to compute the sum over non-padded areas + summed_embs = (embs * mask.float()).sum(dim=1) + + # Divide by the lengths to get the mean of non-padding embs + mean_embs = summed_embs / org_lengths.view(-1, 1).float() + + return mean_embs + +class Geneformer_instance(): + def __init__(self, + saved_model_path: Optional[str] = None, + model_run: str = "pretrained", + model_files: Dict[str, str] = { + "model_args": "config.json", + "model_training": "training_args.bin", + "model_weights": "pytorch_model.bin" + }, + save_dir: Optional[str] = None, + explicit_save_dir: bool = False, + num_workers: int = 0, + log_wandb: bool = False, + project_name: str = "Geneformer_eval", + ) -> None: + + # check if the model run is supported + supported_model_runs = ["pretrained"] #, "random", "finetune", "train"] + if model_run not in supported_model_runs: + msg = f"model_run must be one of {supported_model_runs}" + log.error(msg) + raise ValueError(msg) + self.model_run = model_run + + self.saved_model_path = saved_model_path + self.model_files = model_files + + if num_workers == -1: + num_workers = len(os.sched_getaffinity(0)) + + if num_workers == 0: + num_workers = 1 + + self.num_workers = num_workers + + # check if output directory exists + if save_dir is not None: + if explicit_save_dir: + self.output_dir = save_dir + else: + self.output_dir = os.path.join(save_dir, + self.run_id) + # if the top out directory does not exist, create it + if not os.path.exists(save_dir): + log.warning(f"Creating the top output directory {save_dir}") + os.makedirs(save_dir) + else: + # save in a current path + self.output_dir = os.path.join(os.getcwd(), self.run_id) + + # if the out directory already exists, raise an error + if os.path.exists(self.output_dir) and not explicit_save_dir: + msg = f"Output directory: {self.output_dir} exists. Something is wrong!" + log.error(msg) + raise ValueError(msg) + + os.makedirs(self.output_dir, exist_ok=True) + + self.device = torch.device("cuda" + if torch.cuda.is_available() + else "cpu") + + log.info(f"Using device {self.device}") + + self.project_name = project_name + if log_wandb: + has_wandb = importlib.util.find_spec("wandb") is not None + if not has_wandb: + msg = "Wandb is not installed. Please install wandb to log to wandb." + log.error(msg) + raise RuntimeError(msg) + if has_wandb: + import wandb + self._wandb = wandb + else: + self._wandb = None + + # update this when saved config so that when training it only is saved once + self.config_saved = False + + def _check_attr(self, + attr: str, + not_none: bool = True) -> bool: + """ + Check if the argument is in the class + """ + out = hasattr(self, attr) + if not_none and out: + out = getattr(self, attr) is not None + return out + + def load_pretrained_model(self) -> None: + + # self.model = BertForMaskedLM.from_pretrained(self.saved_model_path, + # output_attentions=False, + # output_hidden_states=True) + self.model = CustomBertForMaskedLM.from_pretrained(self.saved_model_path, + output_attentions=False, + output_hidden_states=True) + + self.model = self.model.to(self.device) + log.info(f"Model successfully loaded from {self.saved_model_path}") + + + def load_tokenized_dataset(self, + dataset_path: str) -> None: + + self.tokenized_dataset = load_from_disk(dataset_path) + + def tokenize_data(self, + adata_path: str, + dataset_path: str, + cell_type_col: str = "cell_type", + columns_to_keep: List[str] = ["adata_order"]): + + dataset_name = os.path.basename(adata_path).split(".")[0] + + cols_to_keep = dict(zip([cell_type_col] + columns_to_keep, + ['cell_type'] + columns_to_keep)) + # initialize tokenizer + self.tokenizer = TranscriptomeTokenizer(cols_to_keep, + nproc = self.num_workers) + + # get the extension from adata_path + _, ext = os.path.splitext(adata_path) + ext = ext.strip(".") + + if ext not in ["loom", "h5ad"]: + msg = f"adata_path must be a loom or h5ad file. Got {ext}" + log.error(msg) + raise ValueError(msg) + + if ext == "h5ad": + msg = ("using h5ad file. This sometimes causes issues. " + "If not working try with loom.") + log.warning(msg) + + # get the top directory of the adata_path + adata_dir = os.path.dirname(adata_path) + + self.tokenizer.tokenize_data(adata_dir, + dataset_path, + dataset_name, + file_format=ext) + + + # tokenizer does not return the dataset + # load the dataset + self.load_tokenized_dataset(os.path.join(dataset_path, + f"{dataset_name}.dataset")) + + + def load_vocab(self, + dict_paths: str) -> None: + + token_dictionary_path = os.path.join(dict_paths, + "token_dictionary.pkl") + with open(token_dictionary_path, "rb") as f: + self.vocab = pickle.load(f) + + self.pad_token_id = self.vocab.get("") + + # size of vocabulary + self.vocab_size = len(self.vocab) + + gene_name_id_path = os.path.join(dict_paths, + "gene_name_id_dict.pkl") + with open(gene_name_id_path, "rb") as f: + self.gene_name_id = pickle.load(f) + + + def _extend_batch(self, + batch_dataset: Dataset, + return_attention_mask: bool = True): + + max_size = max(batch_dataset['length']) + + batch_ = [pad_tensor(x, max_size, self.pad_token_id) + for x in batch_dataset['input_ids']] + + batch_ = torch.stack(batch_).to(self.device) + + if return_attention_mask: + mask_ = [[1] * l + [0] * (max_size - l) + for l in batch_dataset['length']] + mask_ = torch.tensor(mask_).to(self.device) + return batch_, mask_ + + return batch_ + + def _pass_batch(self, + batch_ids: torch.Tensor, + attention_mask: torch.Tensor, + **kwargs) -> torch.Tensor: + # make sure that batch and attn_mask on the same device + batch_ids = batch_ids.to(self.device) + attn_mask = attention_mask.to(self.device) + + with torch.no_grad(): + outputs = self.model(input_ids = batch_ids, + attention_mask = attn_mask, + **kwargs) + + return outputs + + + def extract_embeddings(self, + data: InputData, + batch_size: int = 48, + embedding_key: str = "geneformer", + layer: int = -2): + + # check if tokenized dataset is loaded + if not self._check_attr("tokenized_dataset"): + msg = "Tokenized dataset not loaded. Please load the tokenized dataset." + log.error(msg) + raise RuntimeError(msg) + + # check if layer is valid + n_layers = self.model.config.num_hidden_layers + if layer >= n_layers or layer < -n_layers: + msg = (f"Layer {layer} is not valid. There are only {n_layers} " + f"Acceptable values are between {-n_layers} (if counting " + f"forwards) and {n_layers - 1} (if counting backwards)") + log.error(msg) + raise ValueError(msg) + + # save the embeddings to subdir + embeddings_subdir = os.path.join(self.output_dir, "model_outputs") + os.makedirs(embeddings_subdir, exist_ok=True) + + cell_embs_list = [] + rankings_list = [] + + size = len(self.tokenized_dataset) + + for i in trange(0, size, batch_size, + desc = "Geneformer (extracting embeddings)"): + + max_range = min(i+batch_size, size) + batch_dataset = self.tokenized_dataset.select(list(range(i, max_range))) + batch_dataset.set_format(type = 'torch') + + org_lengths = torch.tensor(batch_dataset['length']).to(self.device) + + batch, attn_mask = self._extend_batch(batch_dataset) + + model_output = self._pass_batch(batch, + attention_mask = attn_mask) + + embs = model_output.hidden_states[layer] + + # cell_embs = average_embeddings(embs, org_lengths) + cell_embs = mean_nonpadding_embs(embs, org_lengths) + + # add cell embeddings to the list + cell_embs_list.extend(cell_embs.detach().cpu().numpy()) + + # now, get the ranking reconstruction + out_rankings = (model_output.logits + .argmax(axis=-1) + .detach().cpu().numpy()) + + # save the rankings with the original order + rankings_list.extend(out_rankings) + + torch.cuda.empty_cache() + del model_output + del batch + del attn_mask + del embs + del cell_embs + + self.cell_embeddings = np.array(cell_embs_list) + + self.output_rankings = rankings_list + self.input_rankings = [np.array(item) + for item + in self.tokenized_dataset['input_ids']] + + # add embeddings to adata + data.adata.obsm[embedding_key] = self.cell_embeddings + + # for plotting later, save the data.adata.obs + # order here agrees with the order of the embeddings + data.adata.obs.to_csv(os.path.join(embeddings_subdir, + "adata_obs.csv")) + + + diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__init__.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b2d2dc47aedd4eed2c609cab495b2b16f6c1e863 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1301291db4c522db2ca88b08ad33a8dda0c5f301 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/__init__.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b4315f9ff789fd67ba8b68c57660c49096a28d6 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f6f0b2b3232161e59f33a8822d6e6c7c975fae8 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/custom_logging.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-310.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d10be8e54f406bd99898acc64f5b744fd5ee05c6 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-310.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-311.pyc b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2474a2700b8549ffadf10bfcdbe5cd9bd9f9d7b8 Binary files /dev/null and b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/__pycache__/umap.cpython-311.pyc differ diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/custom_logging.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/custom_logging.py new file mode 100644 index 0000000000000000000000000000000000000000..2b81c4eeeec8c2d8def454bfd2171a3207bf0597 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/custom_logging.py @@ -0,0 +1,18 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. +import logging +# colorful logging +from colorlog import ColoredFormatter + +LOG_LEVEL = logging.DEBUG + +LOGFORMAT = "%(log_color)s%(levelname)-8s%(reset)s | %(asctime)s | %(log_color)s%(message)s%(reset)s" + +logging.root.setLevel(LOG_LEVEL) +formatter = ColoredFormatter(LOGFORMAT, datefmt = '%Y-%m-%d %H:%M:%S') +stream = logging.StreamHandler() +stream.setLevel(LOG_LEVEL) +stream.setFormatter(formatter) +log = logging.getLogger('pythonConfig') +log.setLevel(LOG_LEVEL) +log.addHandler(stream) \ No newline at end of file diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/umap.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/umap.py new file mode 100644 index 0000000000000000000000000000000000000000..4a0662f38d9c4bde051407fcf672cf38827a1d55 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/helpers/umap.py @@ -0,0 +1,154 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. + +def plot_side_by_side(df, label, col_palette=None, direction="row", + title="UMAP projection of the dataset"): + """ + Plot a scatter plot for each label in the dataset. + Parameters + ---------- + df : pandas.DataFrame + DataFrame containing the x and y coordinates of the projection and the + labels. + label : str + Name of the column containing the labels. + col_palette : dict, optional + Dictionary containing the colors for each label. The default is None. + direction : str, optional + Direction of the subplots. The default is "row". + title : str, optional + Title of the plot. The default is "UMAP projection of the dataset". + Returns + ------- + fig : matplotlib.pyplot.figure + Figure containing the scatter plots. + """ + import numpy as np + import matplotlib.pyplot as plt + # check how many different labels there are + labels = sorted(df[label].unique().tolist()) + n_labels = len(labels) + # check if color pallette is provided and if so, if the length is correct + if col_palette is not None: + # check if all labels have a color + for l in labels: + assert l in col_palette, "Not all labels have a color assigned." + + # Create n_labels scatter plots with different color schemes + if n_labels > 10: + print("Warning: more than 10 labels! Ignoring direction argument.") + n_subplots_sqrt = np.sqrt(n_labels) + n_cols = int(np.ceil(n_subplots_sqrt)) + n_rows = int(np.ceil(n_labels / n_cols)) + fig, axs = plt.subplots(nrows=n_rows, ncols=n_cols, + figsize=(5 * n_cols, 5 * n_rows)) + + elif direction == "row": + fig, axs = plt.subplots(nrows=n_labels, figsize=(5, n_labels * 5)) + elif direction == "col": + fig, axs = plt.subplots(ncols=n_labels, figsize=(n_labels * 5, 5)) + else: + raise ValueError("direction must be either row or col.") + + # Flatten the axs array to make it easier to iterate over + axs = axs.flatten() + + # loop over the labels + for i, label_ in enumerate(labels): + # check if color pallette is provided + if col_palette is not None: + label_col = col_palette[label_] + else: + label_col = "red" + + # add background scatter + axs[i].scatter( + df.loc[df[label] != label_, 'x'], + df.loc[df[label] != label_, 'y'], + color = "gray", + alpha = 0.2, + s = 0.5 + ) + + # add scatter for each label + axs[i].scatter( + df.loc[df[label] == label_, 'x'], + df.loc[df[label] == label_, 'y'], + color = label_col, + alpha = 0.5, + s = 0.5 + ) + + # switch off axis + axs[i].axis('off') + + # add title + axs[i].title.set_text(label_) + + # add main title + fig.suptitle(title, fontsize=16) + + return fig + +def plot_latent(latent, annot_df, label, col_palette=None, direction="row", + title="UMAP projection of the dataset"): + import pandas as pd + df = pd.DataFrame(latent, columns=["x", "y"]) + df[label] = annot_df[label].tolist() + psbs = plot_side_by_side(df, label, + col_palette=col_palette, + direction=direction, title=title) + return psbs + +cmaps = { + 'Perceptually Uniform Sequential': [ + 'viridis', 'plasma', 'inferno', 'magma', 'cividis' + ], + 'Sequential': [ + 'Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds', + 'YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu', + 'GnBu', 'PuBu', 'YlGnBu', 'PuBuGn', 'BuGn', 'YlGn' + ], + 'Sequential (2)': [ + 'binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink', + 'spring', 'summer', 'autumn', 'winter', 'cool', 'Wistia', + 'hot', 'afmhot', 'gist_heat', 'copper' + ], + 'Diverging': [ + 'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu', + 'RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic' + ], + 'Cyclic': ['twilight', 'twilight_shifted', 'hsv'], + 'Qualitative': [ + 'Pastel1', 'Pastel2', 'Paired', 'Accent', + 'Dark2', 'Set1', 'Set2', 'Set3', + 'tab10', 'tab20', 'tab20b', 'tab20c' + ], + 'Miscellaneous': [ + 'flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern', + 'gnuplot', 'gnuplot2', 'CMRmap', 'cubehelix', 'brg', + 'gist_rainbow', 'rainbow', 'jet', 'turbo', 'nipy_spectral', + 'gist_ncar' + ] +} + +# get random value from a list +def get_random_value_from_list(l): + """ + Get a random value from a list. + """ + import random + return l[random.randint(0, len(l)-1)] + +# generate a color pallette of length n +def generate_pallette(n, cmap="viridis"): + """ + Generate a color pallette of length n. + """ + import numpy as np + import seaborn as sns + if cmap == "random": + return np.random.rand(n, 3) + else: + return sns.color_palette(cmap, n_colors=n).as_hex() + diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/model_output.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/model_output.py new file mode 100644 index 0000000000000000000000000000000000000000..fef52cefa72cc0a4d687736aa2cebd27c7524e02 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/model_output.py @@ -0,0 +1,635 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. +import os +from typing import List, Optional, Union, Dict + +from . import utils +from . import data + +from .geneformer_forward import Geneformer_instance +# from .scgpt_forward import scGPT_instance + +from .helpers.custom_logging import log + +import numpy as np +import torch +import pandas as pd + +import matplotlib.pyplot as plt + +import seaborn as sns + +import PyComplexHeatmap as pych + +import scipy.stats as stats + +import warnings +os.environ["KMP_WARNINGS"] = "off" +warnings.filterwarnings('ignore') + +def check_attributes(object, attribute: str): + """ + check if the attribute is in the object + """ + if not hasattr(object, attribute): + msg = f"{attribute} is not an attribute of {object}" + log.error(msg) + raise ValueError(msg) + +def save_tensor_as_csv(tensor: torch.Tensor, + output_dir: str, + filename: str) -> None: + """ + save a tensor as csv + """ + if not os.path.exists(output_dir): + log.warning(f"Creating the output directory {output_dir}") + os.makedirs(output_dir) + + if not isinstance(tensor, torch.Tensor): + msg = "tensor must be a torch.Tensor" + log.error(msg) + raise ValueError(msg) + + tensor_df = pd.DataFrame(tensor.numpy(), + index = range(tensor.shape[0]), + columns = range(tensor.shape[1])) + + tensor_df.to_csv(os.path.join(output_dir, filename)) + + +def calculate_correlation(in_ranks_mat, out_ranks_mat, mean_ranks_mat): + + # throw an error if the matrices are not the same shape + if not (in_ranks_mat.shape == out_ranks_mat.shape == mean_ranks_mat.shape): + msg = (f"Input ranks matrix shape: {in_ranks_mat.shape}, " + f"Output ranks matrix shape: {out_ranks_mat.shape}, " + f"Mean ranks matrix shape: {mean_ranks_mat.shape}") + log.error(msg) + raise ValueError(msg) + + cors_list = [] + mean_cors_list = [] + for i in range(in_ranks_mat.shape[1]): + in_rank = in_ranks_mat[:,i] + out_rank = out_ranks_mat[:,i] + mean_rank = mean_ranks_mat[:,i] + keep = np.logical_or(in_rank > 0, out_rank > 0) + in_rank = in_rank[keep] + out_rank = out_rank[keep] + mean_rank = mean_rank[keep] + cors_list.append(stats.pearsonr(in_rank, out_rank)[0]) + mean_cors_list.append(stats.pearsonr(in_rank, mean_rank)[0]) + + return cors_list, mean_cors_list + + +class GeneExprPredEval(): + def __init__(self, + model_instance: Union[Geneformer_instance], + # model_instance: Union[scGPT_instance, + # Geneformer_instance], + data: Optional[data.InputData] = None, + embedding_key: Optional[Union[str, List[str]]] = "mlm_output", + output_dir: Optional[str] = None, + log_wandb: bool = False,) -> None: + + # test if scGPT_instance is a valid instance + # if not isinstance(model_instance, + # (scGPT_instance, Geneformer_instance)): + # msg = "model_instance must be an instance of scGPT_instance" + # log.error(msg) + # raise ValueError(msg) + if not isinstance(model_instance, + (Geneformer_instance)): + msg = "model_instance must be an instance of scGPT_instance" + log.error(msg) + raise ValueError(msg) + + # if wandb set to true and not initialized, throw error + if log_wandb and not model_instance._wandb: + msg = "wandb is not initialized in model_instance" + log.error(msg) + raise ValueError(msg) + + self._wandb = model_instance._wandb + + self.eval_instance = model_instance + self.embedding_key = embedding_key + + self.model_type = ("geneformer" + # "scgpt" + # if isinstance(self.eval_instance, scGPT_instance) + # else "geneformer" + ) + # if self.model_type == "scgpt": + # self.data = data + # embedding_key = ([embedding_key] if isinstance(embedding_key, str) + # else embedding_key) + # # check if embedding_key is valid + # for key in embedding_key: + # check_attributes(self.eval_instance, key) + + if self.model_type == "geneformer": + # elif self.model_type == "geneformer": + # check if rankings are saved + rankings = ["input_rankings", "output_rankings"] + for ranking in rankings: + check_attributes(self.eval_instance, ranking) + + + if output_dir is not None: + # if output dir is provided, use it + self.output_dir = output_dir + # check if output_dir exists + if not os.path.exists(self.output_dir): + log.warning(f"Creating the output directory {self.output_dir}") + os.makedirs(self.output_dir) + else: + # use the same output_dir as the model_instance + self.output_dir = self.eval_instance.output_dir + + + + def _evaluate_Geneformer(self, + n_cells: Optional[int] = 1000, + return_all: bool = False, + save_rankings: bool = False) -> None: + + n_all_cells = len(self.eval_instance.input_rankings) + + if n_cells is None: + n_cells = n_all_cells + rand_cells = np.arange(n_all_cells) + + elif n_cells > n_all_cells: + msg = (f"n_cells {n_cells} is larger than the number of cells in the " + f"dataset ({n_all_cells}); setting to the maximum") + log.warning(msg) + n_cells = n_all_cells + + elif n_cells < 1: + msg = "n_cells must be greater than 0" + log.error(msg) + raise ValueError(msg) + + + if n_cells < n_all_cells: + rand_cells = np.random.choice(range(n_all_cells), + n_cells, replace = False) + input_rankings = [self.eval_instance.input_rankings[i] + for i in rand_cells] + output_rankings = [self.eval_instance.output_rankings[i] + for i in rand_cells] + + output_rankings = [output_rankings[i][:len(input_rankings[i])] + for i in range(len(input_rankings))] + + else: + input_rankings = self.eval_instance.input_rankings + output_rankings = [self.eval_instance.output_rankings[i][:len(input_rankings[i])] + for i in range(len(input_rankings))] + + log.debug(f"Extracting output from {n_cells} cells") + + # if 'adata_order' is not in the datset, generate numbers + if 'adata_order' not in self.eval_instance.tokenized_dataset.features.keys(): + msg = "adata_order is not in the dataset; generating numbers for sample_id" + log.warning(msg) + + sample_ids = [[i] * input_rankings[i].shape[0] + for i in range(len(input_rankings))] + else: + sample_ids = [self.eval_instance.tokenized_dataset.select([i])['adata_order'] + for i in rand_cells] + sample_ids = [sample_ids[i] * input_rankings[i].shape[0] + for i in range(len(input_rankings))] + + positions = [np.arange(input_rankings[i].shape[0]) + for i in range(len(input_rankings))] + positions = [np.max(positions[i]) - positions[i] + for i in range(len(input_rankings))] + positions = [positions[i] / np.max(positions[i]) + for i in range(len(input_rankings))] + + input_rankings = np.concatenate(input_rankings, axis = 0) + sample_ids = np.concatenate(sample_ids, axis = 0) + output_rankings = np.concatenate(output_rankings, axis = 0) + positions = np.concatenate(positions, axis = 0) + + # create the tables + input_df = pd.DataFrame({"token": input_rankings, + "sample_id": sample_ids, + "input_rank": positions}) + + output_df = pd.DataFrame({"token": output_rankings, + "sample_id": sample_ids, + "output_rank": positions}) + + # since the output can contain more than one occurrence of a token average + output_df = output_df.groupby(["token", "sample_id"]).mean().reset_index() + + # join the two dataframes + df = pd.merge(input_df, output_df, + on = ["token", "sample_id"], + how = "outer") + + # fill nas with 0 for tokens absent from input and output + df = df.fillna(0) + + # calculate mean rank for each token + mean_rank_df = df[df['input_rank'] > 0].groupby(["token"]).apply(lambda x: x.input_rank.mean()).reset_index() + # rename the column + mean_rank_df = mean_rank_df.rename(columns = {0: "mean_rank"}) + + # merge dataframes + df = pd.merge(df, mean_rank_df, on = ["token"], how = "left") + + # fill nas with 0 for tokens absent from input + df = df.fillna(0) + + # calculate correlation with stats.pearsonr for each sample between input and output rankings + cors = df.groupby("sample_id").apply(lambda x: stats.pearsonr(x["input_rank"], x["output_rank"])[0]) + mean_cors = df.groupby("sample_id").apply(lambda x: stats.pearsonr(x["input_rank"], x["mean_rank"])[0]) + + cors_df = pd.concat([cors, mean_cors], axis = 1) + cors_df = cors_df.rename(columns = {0: "correlation", + 1: "mean_correlation"}) + + self.rankings_df = df + + if save_rankings: + df.to_csv(os.path.join(self.output_dir, + "rankings.csv.gz"), + index = False, + compression = "gzip") + + metrics_df = cors_df.describe() + + self.rankings_summary_df = metrics_df + + # log the metrics to wandb + if self._wandb: + self._wandb.log({"gene_embeddings_metrics": + self._wandb.Table(dataframe = metrics_df)}) + + + if return_all: + cors_df.to_csv(os.path.join(self.output_dir, + "correlations.csv.gz"), + index = False, + compression = "gzip") + return metrics_df, cors_df + + return metrics_df + + + def _evaluate_scGPT(self, + remove_cell_embedding: bool = True, + include_zero_genes: bool = False) -> None: + # take the embeddings and input and calculate the metrics using + # the loss function + metrics_df = pd.DataFrame() + input_values = self.eval_instance.tokenized_data['values'] + + if include_zero_genes: + masked_values_ = torch.full_like(input_values, + True, + dtype=torch.bool) + else: + masked_values_ = input_values > 0 + + non_padded_values = input_values.ne(self.eval_instance.model_config['pad_value']) + + for emb_key in self.embedding_key: + embedding = getattr(self.eval_instance, emb_key) + # check if embedding is a tensor + if not isinstance(embedding, torch.Tensor): + msg = f"{emb_key} is not a tensor" + log.warning(msg) + embedding = torch.tensor(embedding) + + metrics = utils.calculate_losses(embedding, + input_values, + masked_values_, + non_padded_values, + skip_cell = remove_cell_embedding) + metrics = {key: value.item() for key, value in metrics.items()} + metrics_df = pd.concat([metrics_df, + pd.DataFrame(metrics, index = [emb_key])]) + + # add the reference if the prediction would have been the mean + mean = np.mean(input_values[masked_values_].detach().cpu().numpy()) + mean_values = torch.full_like(input_values, mean) + metrics = utils.calculate_losses(mean_values, + input_values, + masked_values_, + non_padded_values, + skip_cell = remove_cell_embedding) + metrics = {key: value.item() for key, value in metrics.items()} + metrics_df = pd.concat([metrics_df, + pd.DataFrame(metrics, index = ["mean"])]) + + # save the metrics + metrics_df.to_csv(os.path.join(self.output_dir, + "gene_embeddings_metrics.csv")) + + # log the metrics to wandb + if self._wandb: + self._wandb.log({"gene_embeddings_metrics": + self._wandb.Table(dataframe = metrics_df)}) + + return metrics_df + + + def evaluate(self, + remove_cell_embedding: Optional[bool] = True, + include_zero_genes: Optional[bool] = False, + n_cells: Optional[int] = 1000, + return_all: Optional[bool] = False, + save_rankings: Optional[bool] = False) -> None: + """ + Evaluate the model output + """ + + if self.model_type == "scgpt": + return self._evaluate_scGPT(remove_cell_embedding = remove_cell_embedding, + include_zero_genes = include_zero_genes) + + elif self.model_type == "geneformer": + return self._evaluate_Geneformer(n_cells = n_cells, + return_all = return_all, + save_rankings = save_rankings) + + + + def _visualize_Geneformer(self, + n_cells: Optional[int] = 1000, + cmap = "Blues") -> plt.figure: + + n_all_available_cells = self.rankings_df['sample_id'].nunique() + + if n_cells < n_all_available_cells: + msg = f"Subsetting to {n_cells} cells" + log.info(msg) + # select random cells + rand_cells = np.random.choice(self.rankings_df['sample_id'].unique(), + n_cells, replace=False) + rankings_df = self.rankings_df[self.rankings_df['sample_id'].isin(rand_cells)] + elif n_cells < 1: + msg = f"n_cells must be greater than 0; provided: {n_cells}" + log.error(msg) + raise ValueError(msg) + else: + rankings_df = self.rankings_df + + # set seaborn style + sns.set_style("white") + + # get two plots side by side + fig, (ax1, ax2) = plt.subplots(ncols = 2, + sharey = True, + tight_layout = True, + figsize = (10, 5)) + ax1.set_xlabel("Input ranks") + ax1.set_ylabel("Geneformer reconstructed ranks") + ax2.set_xlabel("Input ranks") + ax2.set_ylabel("Mean ranks") + + sns.kdeplot(x = "input_rank", + y = "output_rank", + data = rankings_df, + cmap = cmap, + fill = True, + shade = True, + thresh = 0, ax = ax1) + sns.kdeplot(x = "input_rank", + y = "mean_rank", + data = rankings_df, + cmap = cmap, + shade = True, + fill = True, thresh = 0, ax = ax2) + + plt.suptitle("Correlation between input and reconstructed and mean rankings") + + save_path = os.path.join(self.output_dir, + "input_and_outputs_kde.png") + + plt.savefig(save_path, bbox_inches='tight') + if self._wandb: + self._wandb.log({"input_and_outputs_kde": + self._wandb.Image(save_path)}) + return plt + + + def _visualize_scGPT(self, + label_key: str = "cell_type", + skip_cell: bool = True) -> plt.figure: + # get the cell embedding + input_values = self.eval_instance.tokenized_data['values'] + mlm_output = self.eval_instance.mlm_output + mvc_output = self.eval_instance.mvc_output + + # arrange columns by mean value + mean_value = np.mean(input_values.detach().cpu().numpy(), axis = 0) + sort_indices = np.argsort(-mean_value) + input_values = input_values[:, sort_indices] + mlm_output = mlm_output[:, sort_indices] + mvc_output = mvc_output[:, sort_indices] + + # get the random cells + rand_indices = np.random.choice(np.arange(input_values.shape[0]), + size = 100, replace = False) + input_values = input_values[rand_indices, :] + mlm_output = mlm_output[rand_indices, :] + mvc_output = mvc_output[rand_indices, :] + cell_type_annot = self.data.adata.obs[label_key].values[rand_indices] + cm_values = self.plot_heatmap(input_values, + label = "Input values", + output_dir = self.output_dir, + plot_name = "input_values_heatmap", + annot = False, + cell_type_annotation = cell_type_annot, + return_fig = True, + plot_fig = False, + skip_cell = skip_cell) + cm_mlm_output = self.plot_heatmap(mlm_output, + label = "MLM output", + # cmap = "Greens", + output_dir = self.output_dir, + plot_name = "mlm_output_heatmap", + annot = False, + return_fig = True, + plot_fig = False, + skip_cell = skip_cell) + cm_mvc_output = self.plot_heatmap(mvc_output, + label = "MVC output", + # cmap = "Reds", + output_dir = self.output_dir, + plot_name = "mvc_output_heatmap", + annot = False, + return_fig = True, + plot_fig = False, + skip_cell = skip_cell) + + with plt.style.context('ggplot'): + plt.figure(figsize = (25, 7)) + ax, legend_axes = pych.composite(cmlist = [cm_values, + cm_mlm_output, + cm_mvc_output], + main = 0, + legend_hpad = 10, + legend_gap = 17) + + cm_values.ax.set_title("Input bins") + cm_mlm_output.ax.set_title("MLM output") + cm_mvc_output.ax.set_title("MVC output") + model_run = self.eval_instance.model_run + ax.set_title((f"Comparison of input and output of the {model_run} " + "scGPT model"), + y=1.05, fontdict={'fontweight':'bold'}) + save_path = os.path.join(self.output_dir, + "input_and_outputs_heatmap.png") + plt.tight_layout() + plt.savefig(save_path, bbox_inches='tight') + if self._wandb: + self._wandb.log({"input_and_outputs_heatmap": + self._wandb.Image(save_path)}) + return plt + + def visualize(self, + n_cells: Optional[int] = 1000, + label_key: Optional[str] = "cell_type", + skip_cell: Optional[bool] = True, **kwargs) -> None: + + if self.model_type == "scgpt": + self._visualize_scGPT(label_key = label_key, + skip_cell = skip_cell) + + elif self.model_type == "geneformer": + self._visualize_Geneformer(n_cells = n_cells, **kwargs) + + + @staticmethod + def plot_heatmap(mat: Union[np.ndarray, torch.Tensor], + label = "MVC_output", + cmap = "Blues", + annot: bool = True, + cell_type_annotation: Optional[List] = None, + return_fig: bool = False, + plot_fig: bool = True, + output_dir: Optional[str] = None, + plot_name: str = "heatmap", + skip_cell: bool = True) -> Optional[pych.ClusterMapPlotter]: + + # if tensor detach and move to cpu and numpy + if type(mat) == torch.Tensor: + mat = mat.detach().cpu().numpy() + + if annot and cell_type_annotation is None: + msg = "cell_type_annotation is required for annot = True" + log.error(msg) + raise ValueError(msg) + + if not return_fig and output_dir is None: + msg = "output_dir is required if return_fig is False" + log.error(msg) + raise ValueError(msg) + + if skip_cell: + mat = mat[:, 1:] + + + mean_value_ = np.mean(mat, axis = 0) + mean_value_ = pd.Series(mean_value_, + index = np.arange(mean_value_.shape[0])) + rand_indices = list(range(mat.shape[0])) + if mat.shape[0] > 100: + msg = (f"Matrix is too large to plot ({mat.shape}), " + "subsetting to 100 cells") + log.warning(msg) + rand_indices = np.random.choice(mat.shape[0], 100, replace=False) + mat = mat[rand_indices, :] + if annot: + cell_type_annotation = cell_type_annotation[rand_indices] + + if annot: + cell_types = np.unique(cell_type_annotation) + cell_type_colors = dict(zip(cell_types, + plt.cm.viridis(np.linspace(0, 1, + len(cell_types))))) + # if cell annotation is not DataFrame or Series make it into one + if (type(cell_type_annotation) != pd.DataFrame and + type(cell_type_annotation) != pd.Series): + msg = (f"cell_type_annotation is {type(cell_type_annotation)} " + "but must be a pandas DataFrame or Series; changing") + log.warning(msg) + cell_type_annotation = pd.Series(cell_type_annotation, + index = rand_indices) + row_ha = pych.HeatmapAnnotation(Cell = pych.anno_simple(cell_type_annotation, + colors = cell_type_colors, + legend = True), + legend_gap = 5, + hgap = 0.5, + label_side = 'bottom', + axis = 0) + + log.debug(f"mean_value_ shape: {mean_value_.shape}") + log.debug(f"mat shape: {mat.shape}") + + plot_df = pd.DataFrame(mat, + index = range(mat.shape[0]), + columns = range(mat.shape[1])) + + col_ha = pych.HeatmapAnnotation(Bin = pych.anno_barplot(mean_value_, + legend = False), + axis = 1, plot_legend = False) + + plt.figure(figsize = (10, 10)) + vmin = round(np.nanmin(mat[mat != -np.inf]), 0) + vmax = round(np.nanmax(mat[mat != np.inf]), 0) + + if annot: + cmp = pych.ClusterMapPlotter(data = plot_df, + top_annotation = col_ha, + left_annotation = row_ha, + plot = plot_fig, + plot_legend = True, + legend_hpad = 2, + legend_vpad = 10, + label = label, + legend_gap = 17, + cmap = cmap, + row_cluster = False, + col_cluster = False, + verbose = False, + legend_kws = {"vmin": vmin, + "vmax": vmax}) + else: + cmp = pych.ClusterMapPlotter(data = plot_df, + top_annotation = col_ha, + left_annotation = None, + plot = plot_fig, + plot_legend = True, + legend_hpad = 2, + legend_vpad = 10, + label = label, + legend_gap = 17, + cmap = cmap, + row_cluster = False, + col_cluster = False, + verbose = False, + legend_kws = {"vmin": vmin, + "vmax": vmax}) + + if output_dir is not None: + # save the plot + plt.savefig(os.path.join(output_dir, + f"{plot_name}.png")) + + if return_fig: + return cmp + + @staticmethod + def plot_boxplot(): + pass \ No newline at end of file diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/scgpt_forward.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/scgpt_forward.py new file mode 100644 index 0000000000000000000000000000000000000000..66dfae0eaad0503da3f85b29225d3c5c7990c7ce --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/scgpt_forward.py @@ -0,0 +1,873 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. +import os +import json +import time +import importlib.util + +from typing import Dict, Optional, List, Union + +from scipy.sparse import issparse +import torch +import scanpy as sc +import numpy as np +from torch.utils.data import Dataset, DataLoader + +# import utils from scgpt_eval +from . import utils +from .data import InputData + +from scgpt import SubsetsBatchSampler +from scgpt.model import TransformerModel +from scgpt.tokenizer import tokenize_and_pad_batch +from scgpt.tokenizer.gene_tokenizer import GeneVocab + +from scgpt.utils import set_seed + +from .helpers.custom_logging import log + +# create a helper function to sanitize the name +def sanitize_name(old_name): + """Sanitize the name of the label + to be used as variable name in annotation""" + import re + # remove leading and trailing whitespace + old_name = old_name.strip() + # remove non-alphanumeric characters + old_name = re.sub(r"[^a-zA-Z0-9\s_-]", "", old_name) + # split on " ", "_", and "-" + words = re.split(r"[\s_-]", old_name) + # return camel case + # return words[0] + ''.join(word.capitalize() for word in words[1:]) + + # return lowercase words joined by _ + return '_'.join( word.lower() for word in words) + +class SeqDataset(Dataset): + def __init__(self, + data: Dict[str, torch.Tensor], + gene_key: str = "gene_ids"): + self.data = data + self.gene_key = gene_key + + def __len__(self): + return self.data[self.gene_key].shape[0] + + def __getitem__(self, idx): + d_ = {k: v[idx] for k, v in self.data.items()} + d_['idx'] = idx + return d_ + + +class scGPT_instance(): + def __init__(self, + saved_model_path: Optional[str] = None, + model_run: str = "pretrained", + model_files: Dict[str, str] = { + "model_args": "args.json", + "model_vocab": "vocab.json", + "model_weights": "best_model.pt" + }, + batch_size: int = 8, + save_dir: Optional[str] = None, + explicit_save_dir: bool = False, + num_workers: int = 0, + n_log_reports: int = 10, + log_wandb: bool = False, + project_name: str = "scGPT_eval", + ) -> None: + + # check if the model run is supported + # add "train" "finetune" later + supported_model_runs = ["pretrained", "random"] + if model_run not in supported_model_runs: + msg = f"model_run must be one of {supported_model_runs}" + log.error(msg) + raise ValueError(msg) + self.model_run = model_run + + if self.model_run in ["pretrained", "finetune"] and saved_model_path is None: + msg = "saved_model_path must be provided if model_run is not 'train'" + log.error(msg) + raise ValueError(msg) + + if self.model_run == "train" and saved_model_path is not None: + msg = "args from saved_model_path will be used for training the model" + log.warning(msg) + + self.saved_model_path = saved_model_path + + self.model_files = model_files + if batch_size % 8 != 0: + batch_size_ = batch_size + batch_size = (batch_size // 8 + 1) * 8 + + msg = ("Using AMP by default (currently hardcoded) " + f"batch_size must be a multiple of 8 " + f"provided {batch_size_}, changing to {batch_size}") + log.warning(msg) + + self.batch_size = batch_size + + + self.run_id = (f'{self.model_run}__' + f'{time.strftime("%Y-%m-%d_%H-%M-%S")}') + + + # check if output directory exists + if save_dir is not None: + if explicit_save_dir: + self.output_dir = save_dir + else: + self.output_dir = os.path.join(save_dir, + self.run_id) + # if the top out directory does not exist, create it + if not os.path.exists(save_dir): + log.warning(f"Creating the top output directory {save_dir}") + os.makedirs(save_dir) + else: + # save in a current path + self.output_dir = os.path.join(os.getcwd(), self.run_id) + + # if the out directory already exists, raise an error + if os.path.exists(self.output_dir) and not explicit_save_dir: + msg = f"Output directory: {self.output_dir} exists. Something is wrong!" + log.error(msg) + raise ValueError(msg) + + os.makedirs(self.output_dir, exist_ok=True) + + self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + log.info(f"Using device {self.device}") + + + self.num_workers = num_workers + self.n_log_reports = n_log_reports + + self.project_name = project_name + if log_wandb: + has_wandb = importlib.util.find_spec("wandb") is not None + if not has_wandb: + msg = "Wandb is not installed. Please install wandb to log to wandb." + log.error(msg) + raise RuntimeError(msg) + if has_wandb: + import wandb + self._wandb = wandb + else: + self._wandb = None + + # update this when saved config so that when training it only is saved once + self.config_saved = False + + def _check_attr(self, + attr: str, + not_none: bool = True) -> bool: + """ + Check if the argument is in the class + """ + out = hasattr(self, attr) + if not_none and out: + out = getattr(self, attr) is not None + return out + + def create_configs(self, + seed: int = 97, + # ---> scGPT_human defaults + embsize: int = 512, + nheads: int = 8, + d_hid: int = 512, + nlayers: int = 12, + nlayers_cls: int = 3, + dropout: float = 0.2, + pad_token: str = "", + pad_value: int = -2, + mask_value: int = -1, + mask_ratio: Union[float, List[float]] =[0.25, 0.5, 0.75], + do_mvc: bool = True, # MVC in args.json + input_emb_style: str = "continuous", + n_bins: Optional[int] = 51, + use_fast_transformer: bool = True, + # <--- scGPT_human defaults + # ---> scgpt.TransformerModel class default + n_cls: int = 1, + do_dab: bool = False, + use_batch_labels: bool = False, + domain_spec_batchnorm: bool = False, + cell_emb_style: str = "cls", + mvc_decoder_style: str = "inner product", + ecs_threshold: float = 0.3, + explicit_zero_prob: bool = False, + fast_transformer_backend: str = "flash", + pre_norm: bool = False, + # <--- scgpt.TransformerModel class default + do_cce: bool = False, + do_ecs: bool = False, + do_cls: bool = False, + max_seq_len: int = 1200, + per_seq_batch_sample: bool = False, + shuffle: bool = False, + append_cls: bool = True, + permute_gene_order: bool = True): + # input_emb_style ["category", "continuous", "scaling"] + # check if input_emb_style is supported + supported_input_emb_styles = ["category", "continuous", "scaling", "concat"] + # "category" => CategoryValueEncoder + # coded here: https://github.com/bowang-lab/scGPT/blob/5a69912232e214cda1998f78e5b4a7b5ef09fe06/scgpt/model/model.py#L778 + # "continous" => ContinuousValueEncoder + # coded here: https://github.com/bowang-lab/scGPT/blob/5a69912232e214cda1998f78e5b4a7b5ef09fe06/scgpt/model/model.py#L748 + # "concat" added by me for concatenating the gene token embeddings + # and the expression value embedding + # nn.Identity() + if input_emb_style not in supported_input_emb_styles: + msg = f"input_emb_style must be one of {supported_input_emb_styles}" + log.error(msg) + raise ValueError(msg) + + if append_cls: + self.cell_emb_position = 0 + # check if cell_emb_style is supported + supported_cell_emb_styles = ["cls", "avg-pool", "w-pool"] + if cell_emb_style not in supported_cell_emb_styles: + msg = f"cell_emb_style must be one of {supported_cell_emb_styles}" + log.error(msg) + raise ValueError(msg) + + # model config + self.model_config = dict( + # ---> arguments used in TransformerModel init + embsize = embsize, # controls d_hid arg in model + nheads = nheads, # nheads arg in model + d_hid = d_hid, # d_hid arg in model + nlayers = nlayers, + nlayers_cls = nlayers_cls, + n_cls = n_cls, + dropout = dropout, + pad_token = pad_token, + pad_value = pad_value, + mask_value = mask_value, + mask_ratio = mask_ratio, + do_mvc = do_mvc, # also known as GEPC + do_cls = do_cls, + do_cce = do_cce, + do_ecs = do_ecs, + do_dab = do_dab, + use_batch_labels = use_batch_labels, + # update this with # of batch labels from data config + num_batch_labels = None, + domain_spec_batchnorm = domain_spec_batchnorm, # False + input_emb_style = input_emb_style, + n_bins = n_bins, # n_input_bins in model + cell_emb_style = cell_emb_style, + mvc_decoder_style = mvc_decoder_style, + ecs_threshold = ecs_threshold, + explicit_zero_prob = explicit_zero_prob, + use_fast_transformer = use_fast_transformer, + fast_transformer_backend = fast_transformer_backend, + pre_norm = pre_norm, + # <--- arguments used in TransformerModel init + # Flag to indicate whether to update model parameters during training + do_train = (True + if self.model_run in ["finetuned", "train", "retrain"] + else False), + # Default setting: Automatic Mixed Precision, + amp = True, + # what model are we using + model_run = self.model_run, + # Path to pre-trained model configs and weights + load_model = self.saved_model_path, + # special tokens + special_tokens = [pad_token, "", ""], + ) + + # TODO: work on the logical split of configs + self.run_config = dict( + save_dir = self.output_dir, + per_seq_batch_sample = per_seq_batch_sample, + shuffle = shuffle, + # max sequence length + max_seq_len = max_seq_len, + append_cls = append_cls, + seed = seed, + permute_gene_order = permute_gene_order, + ) + + if self._wandb: + if self._wandb.run is None: + self._wandb.init( + project = os.getenv("WANDB_PROJECT", self.project_name), + name = os.getenv("WANDB_RUN_NAME", self.run_id), + config = {**self.model_config, **self.run_config}, + dir = self.output_dir + ) + + + + def update_config(self) -> None: + if self.saved_model_path is None and self.model_run != "train": + msg = "saved_model_path must be provided if model_run is not 'train'" + log.error(msg) + raise ValueError(msg) + + if self.saved_model_path: + with open(os.path.join(self.saved_model_path, + self.model_files['model_args']), "r") as f: + pre_trained_config = json.load(f) + + # update the config with the updated config + for key, value in pre_trained_config.items(): + if key in self.model_config.keys(): + if value != self.model_config[key] and key not in ['model_run', 'load_model']: + # print a warning if the value is different + log.warning(f"Overriding model config['{key}']" + f" with {value}" + f" (was {self.model_config[key]})") + self.model_config[key] = value + else: + if key in self.run_config: + log.warning(f"Overriding pre-trained config['{key}']" + f" with {self.run_config[key]}" + f" (was {value})") + self.model_config[key] = self.run_config[key] + else: + msg = "saved_model_path is not provided. Nothing to update." + log.warning(msg) + + # remove dist_url or save_dir from model_config + # those are artifacts of scGPT config + for key in ["dist_url", "save_dir"]: + if key in self.model_config.keys(): + del self.model_config[key] + + + def load_vocab(self, + vocab_file: str = None) -> None: + + if vocab_file is None: + vocab_file = os.path.join(self.saved_model_path, + self.model_files['model_vocab']) + + self.model_config['vocab_path'] = vocab_file + # check if file exists + if not os.path.exists(vocab_file): + msg = f"Vocab file {vocab_file} does not exist!" + log.error(msg) + raise FileNotFoundError(msg) + + msg = f"Loading vocab from {vocab_file}" + log.info(msg) + + # load the vocab + self.vocab = GeneVocab.from_file(vocab_file) + for s in self.model_config['special_tokens']: # type: ignore + if s not in self.vocab: + self.vocab.append_token(s) + + self.vocab.set_default_index(self.vocab[self.model_config['pad_token']]) # type: ignore + self.model_config['ntokens'] = len(self.vocab) # size of vocabulary + + def initialize_model(self) -> None: + # set seed + set_seed(self.run_config['seed']) + + # check if vocab is loaded + if self.vocab is None: + msg = "Vocab not loaded!" + log.error(msg) + raise ValueError(msg) + + if self.model_config["use_batch_labels"] and self.model_config["num_batch_labels"] is None: + msg = ("Model configured to use batch labels but number of batches " + "not set! If use_batch_labels=True, load data before " + "initializing model to count the number of batches.") + + log.error(msg) + raise ValueError(msg) + + log.debug(f"Use fast transformer? {self.model_config['use_fast_transformer']}") + # annoyingly this triggers VSCode to show an error + self.model = TransformerModel( + ntoken = self.model_config['ntokens'], + d_model = self.model_config['embsize'], + nhead = self.model_config['nheads'], + d_hid = self.model_config['d_hid'], + nlayers = self.model_config['nlayers'], + nlayers_cls = self.model_config['nlayers_cls'], + n_cls = self.model_config['n_cls'], + vocab = self.vocab, + dropout = self.model_config['dropout'], + pad_token = self.model_config['pad_token'], + pad_value = self.model_config['pad_value'], + do_mvc = self.model_config['do_mvc'], + do_dab = self.model_config['do_dab'], + use_batch_labels = self.model_config['use_batch_labels'], + num_batch_labels = self.model_config['num_batch_labels'], + domain_spec_batchnorm = self.model_config['domain_spec_batchnorm'], + input_emb_style = self.model_config['input_emb_style'], + n_input_bins = self.model_config['n_bins'], + cell_emb_style = self.model_config['cell_emb_style'], + mvc_decoder_style = self.model_config['mvc_decoder_style'], + ecs_threshold = self.model_config["ecs_threshold"], + explicit_zero_prob = self.model_config["explicit_zero_prob"], + use_fast_transformer = self.model_config["use_fast_transformer"], + fast_transformer_backend = self.model_config["fast_transformer_backend"], + pre_norm = self.model_config['pre_norm'] + ) + + # if wandb set, log the model + if self._wandb: + self._wandb.watch(self.model) + + + def load_pretrained_model(self) -> None: + # check if configs are created + if self.model_config is None: + msg = "Model config not created!" + log.error(msg) + raise ValueError(msg) + + self.update_config() + self.load_vocab() + self.initialize_model() + + model_file = os.path.join(self.saved_model_path, + self.model_files['model_weights']) + + msg = f"Loading model from {model_file}" + log.info(msg) + try: + self.model.load_state_dict(torch.load(model_file)) + log.debug(f"Loading all model params from {model_file}") + except: + log.warning(f"Loading partial model params from {model_file}") + # only load params that are in the model and match the size + model_dict = self.model.state_dict() + pretrained_dict_full = torch.load(model_file) + pretrained_dict = { + k: v + for k, v in pretrained_dict_full.items() + if k in model_dict and v.shape == model_dict[k].shape + } + for k, v in pretrained_dict.items(): + log.debug(f"Loading params {k} with shape {v.shape}") + + # print which params are not loaded + for k, v in model_dict.items(): + if k not in pretrained_dict: + log.warning(f"Cannot load {k} with shape {v.shape}") + + model_dict.update(pretrained_dict) + self.model.load_state_dict(model_dict) + if torch.cuda.device_count() > 1: + log.info(f"Using {torch.cuda.device_count()} GPUs") + # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs + self.model = torch.nn.DataParallel(self.model) + self.model.to(self.device) + + def randomly_initialize_model(self) -> None: + self.update_config() + self.load_vocab() + self.initialize_model() + + msg = f"Randomly initializing model" + log.info(msg) + + if torch.cuda.device_count() > 1: + log.info(f"Using {torch.cuda.device_count()} GPUs") + # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs + self.model = torch.nn.DataParallel(self.model) + + self.model.to(self.device) + + + # data_loader + @staticmethod + def prepare_dataloader( + data_pt: Dict[str, torch.Tensor], + batch_size: int, + per_seq_batch_sample: bool = False, + shuffle: bool = False, + intra_domain_shuffle: bool = False, + drop_last: bool = False, + num_workers: int = 0, + ) -> DataLoader: + """ + Prepare a dataloader from a data_pt + + Args: + data_pt: A dictionary with elements such as tokenized + gene_ids, values, etc. + batch_size: Batch size + per_seq_batch_sample: If True, sample from each batch of sequences + instead of each sequence + shuffle: If True, shuffle the data + intra_domain_shuffle: If True, shuffle the data within each batch + drop_last: If True, drop the last batch if it is + smaller than batch_size + num_workers: Number of workers for the dataloader; + if -1, use the number of available CPUs; + positive integers turn multiprocessing on + Returns: + A DataLoader object + """ + + if num_workers == -1: + num_workers = min(len(os.sched_getaffinity(0)), batch_size // 2) + + dataset = SeqDataset(data_pt) + + if per_seq_batch_sample: + # find the indices of samples in each seq batch + subsets = [] + batch_labels_array = data_pt["batch_labels"].numpy() + for batch_label in np.unique(batch_labels_array): + batch_indices = ( + np.where(batch_labels_array == batch_label)[0] + .tolist() + ) + subsets.append(batch_indices) + data_loader = DataLoader( + dataset = dataset, + batch_sampler = SubsetsBatchSampler( + subsets, + batch_size, + intra_subset_shuffle = intra_domain_shuffle, + inter_subset_shuffle = shuffle, + drop_last = drop_last, + ), + num_workers = num_workers, + pin_memory = True, + ) + return data_loader + + data_loader = DataLoader( + dataset = dataset, + batch_size = batch_size, + shuffle = shuffle, + drop_last = drop_last, + num_workers = num_workers, + pin_memory = True, + ) + return data_loader + + def tokenize_data(self, + data: InputData, + input_layer_key: str = "X_binned", + include_zero_genes: bool = False) -> None: + + + # check if data is preprocessed + if input_layer_key not in data.adata.layers.keys(): + msg = f"{input_layer_key} is not in adata.layers! Preprocess the data" + log.error(msg) + raise ValueError(msg) + + input_data = ( + data.adata.layers[input_layer_key].A + if issparse(data.adata.layers[input_layer_key]) + else data.adata.layers[input_layer_key] + ) + + self.genes = data.adata.var[data.data_config["gene_col"]].values.tolist() + self.gene_ids = np.array(self.vocab(self.genes), dtype=int) + + self.data_config = data.get_config() + # add the arguments of tokenizer to config + self.run_config['tokenizer__input_layer_key'] = input_layer_key + self.run_config['tokenizer__include_zero_genes'] = include_zero_genes + + msg = "Tokenizing data" + log.info(msg) + + self.tokenized_data = tokenize_and_pad_batch( + input_data, + self.gene_ids, + max_len = self.run_config['max_seq_len'], + vocab = self.vocab, + pad_token = self.model_config['pad_token'], + pad_value = self.model_config['pad_value'], + # append token at the beginning + append_cls = self.run_config['append_cls'], + include_zero_gene = include_zero_genes, + ) + + if data.batch_key is not None: + batch_labels = ( + data + .adata + .obs[data.batch_id_col] + .values + ) + batch_labels = torch.from_numpy(np.array(batch_labels)).long() + self.tokenized_data["batch_labels"] = batch_labels + + self.tokenized_data["values"] = self.tokenized_data["values"].float() + + + def get_dataloader(self, + input_layer_key: str = "X_binned", + include_zero_gene: bool = False, + drop_last: bool = False) -> None: + + # check if data is tokenized and make sure include zero genes is shared + if not self._check_attr("tokenized_data"): + self.tokenize_data(input_layer_key = input_layer_key, + include_zero_gene = include_zero_gene) + else: + include_zero_gene = self.run_config['tokenizer__include_zero_genes'] + + data_pt = { + "gene_ids": self.tokenized_data["genes"], + "values": self.tokenized_data["values"] + } + + if self.model_config["use_batch_labels"]: + data_pt["batch_labels"] = self.tokenized_data["batch_labels"] + + + msg = "Preparing dataloader" + log.info(msg) + + self.data_loader = self.prepare_dataloader( + data_pt, + batch_size = self.batch_size, + shuffle = self.run_config['shuffle'], + drop_last = drop_last, + num_workers = self.num_workers, + per_seq_batch_sample = self.run_config['per_seq_batch_sample'] + ) + + def save_config(self): + msg = f"Saving config to {self.output_dir}" + log.info(msg) + + with open(os.path.join(self.output_dir, "args.json"), "w") as f: + json.dump(self.model_config, f, indent=4) + + with open(os.path.join(self.output_dir, "config.json"), "w") as f: + json.dump(self.run_config, f, indent=4) + + # check if data config is created, if is, save it + if self._check_attr("data_config"): + with open(os.path.join(self.output_dir, "data_config.json"), "w") as f: + json.dump(self.data_config, f, indent=4) + else: + msg = "Data config not created." + log.warning(msg) + + self.config_saved = True + + def extract_embeddings(self, + data: InputData, + embedding_key: str = "X_scGPT", + experimental: bool = False, + ) -> Optional[Dict[str, np.ndarray]]: + + # check if model is loaded + if not self._check_attr("model"): + msg = "Please load model before extracting embeddings!" + log.error(msg) + raise ValueError(msg) + + # check if data loader is created + if not self._check_attr("data_loader"): + self.get_dataloader() + + self.model.eval() + if not self.config_saved: + self.save_config() + + # save the embeddings to subdir + embeddings_subdir = os.path.join(self.output_dir, "model_outputs") + os.makedirs(embeddings_subdir, exist_ok=True) + + # update wandb config + if self._wandb: + self._wandb.config.update(self.model_config, + # some config is updated after init + allow_val_change = True) + self._wandb.config.update(self.run_config, + # some config is updated after init + allow_val_change=True) + + msg = "Extracting embeddings" + log.info(msg) + + cell_embeddings = [] + mlm_output = [] + batch_idxs = [] + mvc_output = [] + masked_values = [] + + # how many updates to log + login_freq = len(self.data_loader) // self.n_log_reports + + for batch, batch_data in enumerate(self.data_loader): + input_gene_ids = batch_data["gene_ids"].to(self.device) + input_values = batch_data["values"].to(self.device) + if experimental: + # mask 20% of the values with self.model_config['mask_value'] + target_values = input_values.clone() + # for each row in the input values, mask 20% of the values + # Apply masking row-wise + for i in range(input_values.shape[0]): + row = input_values[i, :] + positive_indices = torch.nonzero(row > 0) + + # calculate how many values we need to change + n_to_change = int(0.2 * len(positive_indices)) + + # if the row has no positive values or the number of positive values is less than 5, + # it's impossible to replace 20% of them + if n_to_change == 0: + continue + + # choose random indices to change + indices_to_change = torch.randperm(len(positive_indices))[:n_to_change] + + # replace chosen values with -1 + input_values[i, + positive_indices[indices_to_change]] = self.model_config['mask_value'] + + if self.model_config["use_batch_labels"]: + # TODO: I'm not using this, should delete it and add only if needed + batch_labels = batch_data["batch_labels"].to(self.device) + + # for when used with shuffling + batch_idx = batch_data["idx"].numpy() + batch_idxs.append(batch_idx) + + # permute the gene order for each sample + if self.run_config["permute_gene_order"]: + input_values_temp = input_values.clone() + input_values, indx = utils.permute_values(input_values) + input_gene_ids = utils.rearrange(input_gene_ids, indx) + if experimental: + target_values = utils.rearrange(target_values, indx) + + src_key_padding_mask = input_gene_ids.eq(self.vocab[self.model_config['pad_token']]) + + # TODO: added this because there is a bug in the code + self.model = self.model.to(self.device) + + if batch % login_freq == 0: + msg = f"Extracting embeddings for batch {batch+1}/{len(self.data_loader)}" + log.info(msg) + + with torch.no_grad() and torch.cuda.amp.autocast(enabled=self.model_config['amp']): + output_dict = self.model( + input_gene_ids, + input_values, + src_key_padding_mask = src_key_padding_mask, + batch_labels = batch_labels if self.model_config["use_batch_labels"] else None, + # gene expression prediction from cell embedding? GEPC + MVC = self.model_config["do_mvc"], + # elastic cell similarity + ECS = self.model_config["do_ecs"], + # cell type classification objective + CLS = self.model_config["do_cls"], + # contrastive cell embedding objective + CCE = self.model_config["do_cce"] + ) + + # revert order, so that it works with down stream tasks + if self.run_config["permute_gene_order"]: + # inputs + input_values = utils.reverse_permute(input_values, indx) + # is the reverse permuted exactly the same as the original? + assert torch.all(input_values == input_values_temp) + input_gene_ids = utils.reverse_permute(input_gene_ids, indx) + if experimental: + target_values = utils.reverse_permute(target_values, indx) + + output_dict["mlm_output"] = ( + utils.reverse_permute(output_dict["mlm_output"], + indx) + ) + + if self.model_config["do_mvc"]: + output_dict["mvc_output"] = ( + utils.reverse_permute(output_dict["mvc_output"], + indx) + ) + + cell_embeddings.append(output_dict["cell_emb"] + .detach() + .cpu() + .numpy()) + mlm_output.append(output_dict["mlm_output"] + .detach() + .cpu() + .numpy()) + if self.model_config["do_mvc"]: + mvc_output.append(output_dict["mvc_output"] + .detach() + .cpu() + .numpy()) + if experimental: + masked_values.append(input_values.eq(self.model_config['mask_value']) + .detach() + .cpu() + .numpy()) + # flatten the list of cell embeddings + self.cell_embeddings = np.concatenate(cell_embeddings, axis=0) + # normalize cell embeddings + self.cell_embeddings = self.cell_embeddings / np.linalg.norm( + self.cell_embeddings, axis = 1, keepdims = True + ) + # flatten the list of mlm_output + self.mlm_output = np.concatenate(mlm_output, axis=0) + + if self.model_config["do_mvc"]: + self.mvc_output = np.concatenate(mvc_output, axis=0) + else: + self.mvc_output = None + + if experimental: + self.masked_values = np.concatenate(masked_values, axis=0) + + self.batch_indices = np.concatenate(batch_idxs, axis=0) + + # revert to original order if shuffling is used + sorted = all(self.batch_indices[i] <= self.batch_indices[i+1] + for i in range(len(self.batch_indices)-1)) + + if not sorted: + self.cell_embeddings = self.cell_embeddings[np.argsort(self.batch_indices)] + self.mlm_output = self.mlm_output[np.argsort(self.batch_indices)] + if self.model_config["do_mvc"]: + self.mvc_output = self.mvc_output[np.argsort(self.batch_indices)] + if experimental: + self.masked_values = self.masked_values[np.argsort(self.batch_indices)] + + # save the gene ids to a gzipped numpy file + np.savez_compressed( + os.path.join(embeddings_subdir, "out.npz"), + gene_ids = self.tokenized_data["genes"].detach().cpu().numpy(), + masked_values = self.masked_values if experimental else None, + values = self.tokenized_data["values"].detach().cpu().numpy(), + mlm_output = self.mlm_output, + mvc_output = self.mvc_output, + cell_embeddings = self.cell_embeddings + ) + + # add embeddings to adata + data.adata.obsm[embedding_key] = self.cell_embeddings + + # for plotting later, save the data.adata.obs + # order here agrees with the order of the embeddings + data.adata.obs.to_csv(os.path.join(embeddings_subdir, + "adata_obs.csv")) + + + def clean_up(self, + save_model: bool = False) -> None: + # close wandb + if self._wandb: + self._wandb.finish() + + if save_model: + import pickle + # save the model + with open(os.path.join(self.output_dir, "model.pkl"), "wb") as f: + pickle.dump(self.model, f) diff --git a/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/utils.py b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e7e5f97a6ebfdaa42e53b4ef2b1c371422d2389e --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/sc_foundation_evals/utils.py @@ -0,0 +1,498 @@ +## Copyright (c) Microsoft Corporation. +## Licensed under the MIT license. + +from typing import Dict, Union, List +from anndata import AnnData +import numpy as np +import scanpy as sc +import scib +import torch +import torch.nn.functional as F + +from .helpers.custom_logging import log + +# MODIFIED wrapper for all scib metrics from +# https://github.com/bowang-lab/scGPT/blob/5a69912232e214cda1998f78e5b4a7b5ef09fe06/scgpt/utils/util.py#L267 +def eval_scib_metrics( + adata: AnnData, + batch_key: str = "str_batch", + label_key: str = "cell_type", + embedding_key: str = "X_scGPT" +) -> Dict: + + # if adata.uns["neighbors"] exists, remove it to make sure the optimal + # clustering is calculated for the correct embedding + # print a warning for the user + if "neighbors" in adata.uns: + log.warning(f"neighbors in adata.uns found \n {adata.uns['neighbors']} " + "\nto make sure the optimal clustering is calculated for the " + "correct embedding, removing neighbors from adata.uns." + "\nOverwriting calculation of neighbors with " + f"sc.pp.neighbors(adata, use_rep={embedding_key}).") + adata.uns.pop("neighbors", None) + sc.pp.neighbors(adata, use_rep=embedding_key) + log.info("neighbors in adata.uns removed, new neighbors calculated: " + f"{adata.uns['neighbors']}") + + + # in case just one batch scib.metrics.metrics doesn't work + # call them separately + results_dict = dict() + + res_max, nmi_max, nmi_all = scib.metrics.clustering.opt_louvain( + adata, + label_key=label_key, + cluster_key="cluster", + use_rep=embedding_key, + function=scib.metrics.nmi, + plot=False, + verbose=False, + inplace=True, + force=True, + ) + + results_dict["NMI_cluster/label"] = scib.metrics.nmi( + adata, + "cluster", + label_key, + "arithmetic", + nmi_dir=None + ) + + results_dict["ARI_cluster/label"] = scib.metrics.ari( + adata, + "cluster", + label_key + ) + + results_dict["ASW_label"] = scib.metrics.silhouette( + adata, + label_key, + embedding_key, + "euclidean" + ) + + results_dict["graph_conn"] = scib.metrics.graph_connectivity( + adata, + label_key=label_key + ) + + + # Calculate this only if there are multiple batches + if len(adata.obs[batch_key].unique()) > 1: + results_dict["ASW_batch"] = scib.metrics.silhouette( + adata, + batch_key, + embedding_key, + "euclidean" + ) + + results_dict["ASW_label/batch"] = scib.metrics.silhouette_batch( + adata, + batch_key, + label_key, + embed=embedding_key, + metric="euclidean", + return_all=False, + verbose=False + ) + + results_dict["PCR_batch"] = scib.metrics.pcr( + adata, + covariate=batch_key, + embed=embedding_key, + recompute_pca=True, + n_comps=50, + verbose=False + ) + + results_dict["avg_bio"] = np.mean( + [ + results_dict["NMI_cluster/label"], + results_dict["ARI_cluster/label"], + results_dict["ASW_label"], + ] + ) + + log.debug( + "\n".join([f"{k}: {v:.4f}" for k, v in results_dict.items()]) + ) + + # remove nan value in result_dict + results_dict = {k: v for k, v in results_dict.items() if not np.isnan(v)} + + return results_dict + +def create_attention_mask_default(vecs: torch.Tensor) -> torch.Tensor: + """ + Create an attention mask from a vector of positions of unknown genes. + Implementation of the mask described in the scGPT v2 preprint, fig S1A + https://www.biorxiv.org/content/10.1101/2023.04.30.538439v2.full#F7 + + Args: + vecs (torch.Tensor): A bool tensor with position of unknown genes. + shape (batch_size, seq_len) + + Returns: + torch.Tensor: A bool attention mask. + shape (batch_size, seq_len, seq_len) + + Examples: + >>> create_attention_mask_default(torch.tensor([[0, 0, 1, 1], + [0, 0, 0, 1]]).bool()) + tensor([[[False, False, True, True], + [False, False, True, True], + [False, False, False, True], + [False, False, True, False]], + + [[False, False, False, True], + [False, False, False, True], + [False, False, False, True], + [False, False, False, False]]]) + + """ + # check if vecs is a boolean tensor + if not vecs.dtype == torch.bool: + # check if vecs is 0 and 1 tensor + if not torch.all(vecs.eq(0) | vecs.eq(1)): + raise TypeError("vecs must be a boolean tensor") + else: + # convert to boolean tensor + vecs = vecs.bool() + + # Use broadcasting to expand each vector into a square matrix + attn_mask = vecs.unsqueeze(-1).repeat(1, 1, vecs.size(1)) + + # Create a boolean mask for the diagonal + diagonal_mask = ~torch.eye(vecs.size(1), device=vecs.device).bool() + + # Use the diagonal mask to set the diagonal of each square matrix to False + attn_mask &= diagonal_mask + + # Transpose the last two dimensions to make each row of the original vector a column in the matrix + attn_mask = attn_mask.transpose(-1, -2) + + return attn_mask + +def create_attention_mask_modified(unknown_genes: torch.Tensor, + cell_embedding_position: int = 0) -> torch.Tensor: + """ + Create an attention mask from a vector of positions of unknown genes. + This is a modification of the mask described in the scGPT v2 preprint. + With this attention mask, the cell embedding is always attended to, + and the unknown genes are only attended to by the cell embedding. + + Args: + unknown_genes (torch.Tensor): A bool or 0/1 tensor with position of unknown genes. + shape (batch_size, seq_len) + + Returns: + torch.Tensor: A bool attention mask. + shape (batch_size, seq_len, seq_len) + Examples: + >>> create_attention_mask_modified(torch.tensor([[0, 0, 1, 1], + [0, 0, 0, 1]]).bool()) + tensor([[[False, False, True, True], + [False, False, True, True], + [False, True, False, True], + [False, True, True, False]], + + [[False, False, False, True], + [False, False, False, True], + [False, False, False, True], + [False, True, True, False]]]) + + """ + # if not using GPU show warning + if unknown_genes.device.type == 'cpu': + log.warning('create_attention_mask_modified() is not optimized for CPU, ' + 'please use GPU for better performance.' + f'Device: {unknown_genes.device.type} ') + + # # change vecs to 0 and 1 tensor + # if unknown_genes.dtype == torch.bool: + # unknown_genes = unknown_genes.float() + + if torch.any(unknown_genes[:, cell_embedding_position].eq(True)): # eq(1) + raise ValueError('Cell embedding position is unknown gene position.') + + attn_mask = create_attention_mask_default(unknown_genes) + + + known_genes = ~unknown_genes + # the cell embedding should always be attended to + known_genes[:, cell_embedding_position] = False + + for i in range(len(unknown_genes)): + attn_mask[i][unknown_genes[i].unsqueeze(-1) & known_genes[i].unsqueeze(0)] = True + + return attn_mask + +def random_mask_value( + values: Union[torch.Tensor, np.ndarray], + mask_ratio: float = 0.15, + mask_value: int = -1, + pad_value: int = -2, + mask_cell_embedding: bool = False, + cell_emb_value: int = 0, +) -> torch.Tensor: + """ + Randomly mask a batch of data. + + Args: + values (array-like): + A batch of tokenized data, with shape (batch_size, n_features). + mask_ratio (float): The ratio of genes to mask, default to 0.15. + mask_value (int): The value to mask with, default to -1. + pad_value (int): The value of padding in the values, will be kept unchanged. + mask_cell_embedding (bool): Whether to mask the cell embedding, default to False. + + Returns: + torch.Tensor: A tensor of masked data. + """ + if isinstance(values, torch.Tensor): + # it is crucial to clone the tensor, otherwise it changes the original tensor + values = values.clone().detach().numpy() + else: + values = values.copy() + + if not mask_cell_embedding: + # sanity check that the first element is the cell embedding + assert np.all(values[:, 0] == cell_emb_value) + + for i in range(len(values)): + row = values[i] + non_padding_idx = np.nonzero(row - pad_value)[0] + if not mask_cell_embedding: + # remove the first element, which is the cell embedding + non_padding_idx = non_padding_idx[1:] + n_mask = int(len(non_padding_idx) * mask_ratio) + mask_idx = np.random.choice(non_padding_idx, n_mask, replace=False) + row[mask_idx] = mask_value + return torch.from_numpy(values).float() + +def mask_data(tokenized_data: Dict[str, torch.Tensor], + mask_ratio: float = 0.15, + pad_value: int = -2, + mask_value: int = -1, + mask_cell_embedding: bool = False, + cell_emb_value: int = 0) -> Dict[str, torch.Tensor]: + """ + Mask the data. + """ + # this will randomly mask all the values, + # including or excluding the cell embedding based on the mask_cell_embedding flag + masked_values = random_mask_value( + tokenized_data["values"], + mask_ratio = mask_ratio, + mask_value = mask_value, + pad_value = pad_value, + mask_cell_embedding = mask_cell_embedding, + cell_emb_value = cell_emb_value + ) + + # this will mark the genes which values were masked for loss calculation + gene_mask = torch.logical_and(tokenized_data["values"].ne(pad_value), + masked_values.eq(mask_value)) + + out_dict = { + "gene_ids": tokenized_data["genes"], + "values": masked_values, + "target_values": tokenized_data["values"], + "gene_mask": gene_mask + } + + if "batch_labels" in tokenized_data.keys(): + out_dict["batch_labels"] = tokenized_data["batch_labels"] + + return out_dict + +def calculate_losses(input: torch.Tensor, + output: torch.Tensor, + masked_position: torch.Tensor, + non_padded_position: torch.Tensor, #TODO: add this! + skip_cell: bool = True, + methods: Union[List[str], str] = "all", + reduction_method = "mean", + cp: int = 0 + ) -> Dict[str, float]: + + if reduction_method not in ["mean", "sum"]: + msg = f"calculate_loss: reduction_method {reduction_method} is not supported" + log.error(msg) + raise ValueError(msg) + + implemented_methods = ["mse", "mre", "mae"] + # check if methods equal to string all + if isinstance(methods, str) and methods.lower() == "all": + methods = implemented_methods + + # if methods is not a list, make it a list + methods = [methods] if isinstance(methods, str) else methods + + # make sure methods are lower case + methods = [method.lower() for method in methods] + + # check if element of methods is implemented + methods_ = [method for method in methods if method not in implemented_methods] + if len(methods_) == len(methods): + msg = f"calculate_loss: methods {methods_} are not implemented" + log.error(msg) + raise ValueError(msg) + + if len(methods_) > 0: + msg = f"calculate_loss: methods {methods_} are not implemented" + log.warning(msg) + + # make sure masked_position is boolean + if masked_position.dtype != torch.bool: + # log.warning("evaluate_and_log: masked_position is not boolean") + masked_position = masked_position.bool() + + if skip_cell: + # check if cp is valid + if cp >= input.shape[1]: + msg = f"evaluate_and_log: cp {cp} is greater than input.shape[1] {input.shape[1]}" + log.error(msg) + raise ValueError(msg) + # remove cp from input and output + input = torch.concat((input[:,:cp], input[:,cp+1:]), dim=1) + output = torch.concat((output[:,:cp], output[:,cp+1:]), dim=1) + masked_position = torch.concat((masked_position[:,:cp], + masked_position[:,cp+1:]), dim=1) + non_padded_position = torch.concat((non_padded_position[:,:cp], + non_padded_position[:,cp+1:]), dim=1) + + results = dict() + if "mse" in methods: + # get the loss for masked values + loss = F.mse_loss(torch.masked_select(output, masked_position).float(), + torch.masked_select(input, masked_position).float(), + reduction = reduction_method) + + # TODO: add masked_select on non padded! + loss_all = F.mse_loss(torch.masked_select(output, non_padded_position).float(), + torch.masked_select(input, non_padded_position).float(), + reduction = reduction_method) + + results["MSE"] = loss + results["MSE_all"] = loss_all + + if "mre" in methods: + loss = (torch.abs(torch.masked_select(output, masked_position) - + torch.masked_select(input, masked_position)) / + (torch.masked_select(input, masked_position) + 1e-6)) + + if reduction_method == "mean": + loss = loss.mean() + elif reduction_method == "sum": + loss = loss.sum() + + loss_all = torch.abs((torch.masked_select(output, non_padded_position) - + torch.masked_select(input, non_padded_position)) / + (torch.masked_select(input, non_padded_position) + 1e-6)) + + if reduction_method == "mean": + loss_all = loss_all.mean() + elif reduction_method == "sum": + loss_all = loss_all.sum() + + results["MRE"] = loss + results["MRE_all"] = loss_all + + if "mae" in methods: + # get the loss for masked values + loss = F.l1_loss(torch.masked_select(output, masked_position).float(), + torch.masked_select(input, masked_position).float(), + reduction = reduction_method) + + loss_all = F.l1_loss(torch.masked_select(output, non_padded_position).float(), + torch.masked_select(input, non_padded_position).float(), + reduction = reduction_method) + + results["MAE"] = loss + results["MAE_all"] = loss_all + + return results + +import torch + +def permute_values(mat: torch.Tensor, + pad_value: int = -2, + cell_embedding: bool = True) -> tuple: + """ + Permute the data in a batch. The data is a 2D matrix with shape + (batch_size, seq_len). The non-padded values are permuted and + pad values are kept at the end of the sequence + Args: + - mat: 2D matrix with shape (batch_size, seq_len) + - pad_value: the value of the pad + - cell_embedding: if True, the first position is a cell embedding + Returns: + - mat_perm: the permuted matrix + - indx_perm: the indices of the permutation + """ + if len(mat.shape) > 2: + raise ValueError("mat should be 2D or 1D") + + # reshape the mat if needed so that the mat id 2D + reshape = False + if len(mat.shape) == 1: + reshape = True + mat = mat.unsqueeze(0) + + if cell_embedding: + cemb = mat[:,0] + mat = mat[:,1:] + mat_perm = torch.empty_like(mat) + indx_perm = torch.empty_like(mat) + pad_masks = mat == pad_value + + for i in range(mat.shape[0]): + non_pad = torch.where(~pad_masks[i])[0] + pad = torch.where(pad_masks[i])[0] + perm_non_pad = non_pad[torch.randperm(len(non_pad))] + perm = torch.cat([perm_non_pad, pad]) + indx_perm[i] = perm + mat_perm[i] = mat[i][perm] + + if cell_embedding: # TODO: test not permuting cell_embedding! + mat_perm = torch.cat([cemb.unsqueeze(1), mat_perm], dim=1) + indx_perm = torch.cat((torch.zeros(indx_perm.shape[0], 1).to(indx_perm.device), + indx_perm+1), dim=1) + + if reshape: + mat_perm = mat_perm.view(-1) + indx_perm = indx_perm.view(-1) + + # change indx_perm to int + indx_perm = indx_perm.long() + return mat_perm, indx_perm + +def rearrange(mat: torch.Tensor, + indx: torch.Tensor) -> torch.Tensor: + """ + Rearrange the rows of a 2D tensor A according to the indices indx + Args: + - mat: 2D tensor with shape (batch_size, seq_len) + - indx: 2D tensor with shape (batch_size, seq_len) + Returns: + - mat_reordered: 2D tensor with shape (batch_size, seq_len) + """ + batch_size = mat.shape[0] + batch_indices = torch.arange(batch_size).view(-1, 1).to(indx.device) + mat_reordered = mat[batch_indices, indx] + return mat_reordered + +def reverse_permute(mat: torch.Tensor, + indx: torch.Tensor) -> torch.Tensor: + """ + Reverse the permutation of a 2D tensor A according to the indices indx + Args: + - mat: 2D tensor with shape (batch_size, seq_len) + - indx: 2D tensor with shape (batch_size, seq_len) + Returns: + - Sorted 2D tensor with shape (batch_size, seq_len) + """ + dims = torch.arange(indx.size(0)).reshape(-1, 1) + return mat[dims, indx.argsort()] diff --git a/Downstream_tasks/Zero_shot_batch_effect/setup.py b/Downstream_tasks/Zero_shot_batch_effect/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..a19987af3c15a162f329c47b0dba5842b2cb3af7 --- /dev/null +++ b/Downstream_tasks/Zero_shot_batch_effect/setup.py @@ -0,0 +1,14 @@ +from setuptools import setup, find_packages + +with open('requirements.txt') as f: + required_packages = f.read().splitlines() + +setup( + name='sc_foundation_evals', + version='0.1', + packages=find_packages(), + # install_requires=required_packages, + author='Kasia Kedzierska', + author_email='kasia@well.ox.ac.uk', + description='Evaluations of foundation models in single-cell biology', +)