diff --git a/.gitignore b/.gitignore index 99959722..4fac6a80 100644 --- a/.gitignore +++ b/.gitignore @@ -142,4 +142,3 @@ deckard/deckard.egg-info/* examples/**/params.yaml examples/**/multirun/* *log.txt -examples/power/mnist/plots/adv_accuracy_vs_attack_type.pdf diff --git a/deckard/__main__.py b/deckard/__main__.py index 03153d92..ce7b27e4 100644 --- a/deckard/__main__.py +++ b/deckard/__main__.py @@ -55,11 +55,7 @@ def parse_and_repro(args, default_config="default.yaml", config_dir="conf"): else: cmd = f"python -m deckard.layers.parse {args} --config_file {default_config}" # error = f"error parsing command: {cmd} {args}" - with subprocess.Popen( - cmd, - stdout=subprocess.PIPE, - shell=True, - ) as proc: + with subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) as proc: for line in proc.stdout: print(line.rstrip().decode("utf-8")) if Path(Path(), "dvc.yaml").exists(): diff --git a/deckard/base/experiment/experiment.py b/deckard/base/experiment/experiment.py index 522ae9d3..a69f5065 100644 --- a/deckard/base/experiment/experiment.py +++ b/deckard/base/experiment/experiment.py @@ -6,7 +6,7 @@ import numpy as np from hydra.utils import instantiate -from omegaconf import DictConfig, OmegaConf, ListConfig +from omegaconf import DictConfig, OmegaConf from ..attack import Attack from ..data import Data @@ -258,28 +258,7 @@ def __call__(self): self.data.save(score_dict, files["score_dict_file"]) else: # pragma: no cover raise ValueError("Scorer is None. Please specify a scorer.") - ######################################################################### - # Returns score if scorer is not None, otherwise returns status - ######################################################################### - if self.optimizers is not None and self.optimizers != []: - self.optimizers = ( - [self.optimizers] - if not isinstance(self.optimizers, (list, ListConfig)) - else self.optimizers - ) - scores = {} - for scorer in self.optimizers: - try: - score = score_dict[scorer] - except KeyError: # pragma: no cover - raise KeyError( - f"Scorer {scorer} not found in score_dict. Available self.optimizers: {score_dict.keys()}", - ) - scores[scorer] = score - logger.info(f"Score for id : {self.get_name()} : {scorer}: {score}") - else: - scores = score_dict - logger.info(f"Score for id : {self.get_name()}: {score_dict}") + logger.info(f"Score for id : {self.get_name()}: {score_dict}") logger.info("Finished running experiment with id: {}".format(self.get_name())) new_name = self.get_name() assert ( @@ -288,7 +267,7 @@ def __call__(self): logger.debug( f"Experiment deckard hash changed from {old_hash} to {my_hash(self)}.", ) - return scores + return score_dict def _set_name(self): if self.files.name is not None: diff --git a/deckard/base/files/files.py b/deckard/base/files/files.py index 9946cf34..439782ab 100644 --- a/deckard/base/files/files.py +++ b/deckard/base/files/files.py @@ -54,21 +54,25 @@ def __init__( for need in needs: assert need is not None, f"Need to specify {need}" files.update(kwargs) - self.reports = str(Path(reports).as_posix()) - self.data_dir = str(Path(data_dir).as_posix()) - self.model_dir = str(Path(model_dir).as_posix()) - self.attack_dir = str(Path(attack_dir).as_posix()) - self.data_type = data_type - self.model_type = model_type - self.attack_type = attack_type + self.reports = str(Path(reports).as_posix()) if reports else None + self.data_dir = str(Path(data_dir).as_posix()) if data_dir else None + self.model_dir = str(Path(model_dir).as_posix()) if model_dir else None + self.attack_dir = str(Path(attack_dir).as_posix()) if attack_dir else None + self.data_type = data_type if data_type else None + self.model_type = model_type if model_type else None + self.attack_type = attack_type if attack_type else None self.directory = ( - Path(directory).as_posix() - if Path(directory).is_absolute() - else Path(Path(), directory).as_posix() + ( + Path(directory).as_posix() + if Path(directory).is_absolute() + else Path(Path(), directory).as_posix() + ) + if directory + else None ) - self.name = name - self.stage = stage - self.files = files + self.name = name if name else None + self.stage = stage if stage else None + self.files = files if files else {} logger.debug(f"FileConfig init: {self.files}") def __call__(self): @@ -95,10 +99,10 @@ def _set_filenames(self, **kwargs): data_type = self.data_type model_type = self.model_type attack_type = self.attack_type - reports = str(Path(directory, reports).as_posix()) - data_dir = str(Path(directory, data_dir).as_posix()) - model_dir = str(Path(directory, model_dir).as_posix()) - attack_dir = str(Path(directory, attack_dir).as_posix()) + reports = str(Path(directory, reports).as_posix()) if reports else None + data_dir = str(Path(directory, data_dir).as_posix()) if data_dir else None + model_dir = str(Path(directory, model_dir).as_posix()) if model_dir else None + attack_dir = str(Path(directory, attack_dir).as_posix()) if attack_dir else None if name is None and stage is None: path = Path(reports) elif name is not None and stage is None: @@ -109,17 +113,17 @@ def _set_filenames(self, **kwargs): path = Path(reports, stage, name) for kwarg in files: name = files.get(kwarg) - if "data_file" == kwarg: + if "data_file" == kwarg and data_dir is not None: new_path = Path(data_dir, name) if new_path.suffix != data_type: new_path = Path(data_dir, Path(name).stem + data_type) new_files[kwarg] = str(new_path.as_posix()) - elif "model_file" == kwarg: + elif "model_file" == kwarg and model_dir is not None: new_path = Path(model_dir, name) if new_path.suffix != model_type: new_path = Path(model_dir, Path(name).stem + model_type) new_files[kwarg] = str(new_path.as_posix()) - elif "attack_file" == kwarg: + elif "attack_file" == kwarg and attack_dir is not None: new_path = Path(attack_dir, name) if new_path.suffix != attack_type: new_path = Path(attack_dir, Path(name).stem + attack_type) diff --git a/deckard/base/model/art_pipeline.py b/deckard/base/model/art_pipeline.py index 679a089f..6b540f2d 100644 --- a/deckard/base/model/art_pipeline.py +++ b/deckard/base/model/art_pipeline.py @@ -63,8 +63,15 @@ def __call__(self): model, tuple(torch_dict.values()), ): + import torch + + device_type = "gpu" if torch.cuda.is_available() else "cpu" model = TorchInitializer( - data=data, model=model, library=library, **kwargs + data=data, + model=model, + library=library, + device_type=device_type, + **kwargs, )() elif "keras" in str(library) and not isinstance( model, diff --git a/deckard/layers/afr.py b/deckard/layers/afr.py index a19e887d..67e567e6 100644 --- a/deckard/layers/afr.py +++ b/deckard/layers/afr.py @@ -1,5 +1,6 @@ import pandas as pd import numpy as np +from pathlib import Path import matplotlib.pyplot as plt @@ -10,13 +11,11 @@ LogLogisticAFTFitter, CoxPHFitter, ) +from .plots import calculate_failure_rate, drop_frames_without_results, min_max_scaling import matplotlib -from pathlib import Path import logging import yaml import argparse -from .plots import calculate_failure_rate, drop_frames_without_results, min_max_scaling - logger = logging.getLogger(__name__) @@ -25,8 +24,6 @@ afr_parser.add_argument("--target", type=str, default="adv_failures") afr_parser.add_argument("--duration_col", type=str, default="adv_fit_time") afr_parser.add_argument("--dataset", type=str, default="mnist") - afr_parser.add_argument("--plots_folder", type=str, default="mnist/plots") - afr_parser.add_argument("--file", type=str, default="mnist/plots/data.csv") afr_args = afr_parser.parse_args() target = afr_args.target duration_col = afr_args.duration_col @@ -39,8 +36,10 @@ } matplotlib.rc("font", **font) - FOLDER = Path(afr_args.plots_folder) - data = pd.read_csv(afr_args.file, index_col=0) + + FOLDER = Path(f"{afr_args.dataset}/plots/") + csv_file = FOLDER / "data.csv" + data = pd.read_csv(csv_file, index_col=0) data.columns = data.columns.str.strip() data = data.applymap(lambda x: x.strip() if isinstance(x, str) else x) data.def_value.replace("", 0, inplace=True) @@ -51,14 +50,35 @@ data.dropna(axis=0, subset=["atk_value", "atk_param"], inplace=True) data.dropna(axis=0, subset=["def_value", "def_param"], inplace=True) data.loc[:, "adv_failures"] = (1 - data.loc[:, "adv_accuracy"]) * data.loc[ - :, - "attack.attack_size", + :, "attack.attack_size" ] data.loc[:, "ben_failures"] = (1 - data.loc[:, "accuracy"]) * data.loc[ - :, - "attack.attack_size", + :, "attack.attack_size" ] + # data=data[data['def_gen'] == 'Gauss-in'] + # data=data[data['atk_gen'] == 'HSJ'] + + print( + "Adversarial Accuracy:", + "\n", + "ResNet152:", + data[data["model_layers"] == 152].adv_accuracy.mean(skipna=True), + "\n", + "Resnet101:", + data[data["model_layers"] == 101].adv_accuracy.mean(skipna=True), + "\n", + "Resnet50:", + data[data["model_layers"] == 50].adv_accuracy.mean(skipna=True), + "\n", + "Resnet34:", + data[data["model_layers"] == 34].adv_accuracy.mean(skipna=True), + "\n", + "Resnet18:", + data[data["model_layers"] == 18].adv_accuracy.mean(skipna=True), + "\n", + ) + def plot_aft( df, file, @@ -207,7 +227,6 @@ def clean_data_for_aft( cleaned = cleaned[cleaned["adv_accuracy"] != -1e10] cleaned.dropna(inplace=True, how="any", axis=0) y = cleaned[target] - del cleaned[target] assert ( target in cleaned ), f"Target {target} not in dataframe with columns {cleaned.columns}" @@ -246,7 +265,7 @@ def split_data_for_aft( "adv_failure_rate", "model_layers", "adv_fit_time", - "model.trainer.nb_epoch", + # "model.art.pipeline.initialize.kwargs.optimizer.lr", ] X_train, X_test, y_train, y_test = split_data_for_aft( @@ -258,16 +277,16 @@ def split_data_for_aft( random_state=42, ) - weibull_dict = { + weibull_dict = { # noqa w605 "Intercept: rho_": "$\\rho$", - "Intercept: lambda_": "$\lambda$", # noqa W605 - "data.sample.random_state: lambda_": "Random State", + "Intercept: lambda_": "$\lambda$", # noqa w605 + "data.sample.random_state: lambda_": "Random State", # noqa w605 "def_value: lambda_": "Defence Strength", "atk_value: lambda_": "Attack Strength", "train_time: lambda_": "$t_{train}$", "predict_time: lambda_": "$t_{predict}$", - "adv_accuracy: lambda_": "$\lambda_{adv.}$", # noqa W605 - "accuracy: lambda_": "$\lambda_{ben.}$", # noqa W605 + "adv_accuracy: lambda_": "$\lambda_{adv.}$", # noqa w605 + "accuracy: lambda_": "$\lambda_{ben.}$", # noqa w605 "adv_fit_time: lambda_": "$t_{attack}$", "adv_log_loss: lambda_": "Adv. Log Loss", "adv_failure_rate: lambda_": "$h_{adv.}(t,;\\theta)$", @@ -275,7 +294,7 @@ def split_data_for_aft( "model_layers: lambda_": "No. of Layers", "model.art.pipeline.initialize.kwargs.optimizer.lr: lambda_": "Learning Rate", "def_gen": "Defence", - } + } # noqa w605 weibull_plot_dict = { "file": "weibull_aft.pdf", @@ -310,55 +329,55 @@ def split_data_for_aft( ) wft_scores = score_model(wft, X_train, X_test) - # cox_replacement_dict = { - # "adv_failure_rate": "$h_{adv}(t,;\\theta)$", - # "def_value": "Defence Strength", - # "data.sample.random_state": "Random State", - # "train_time": "$t_{train}$", - # "model_layers": "No. of Layers", - # "model.art.pipeline.initialize.kwargs.optimizer.lr": "Learning Rate", - # "adv_accuracy": "$\lambda_{adv.}$", # noqa W605 - # "adv_fit_time": "$t_{attack}$", - # "adv_log_loss": "Adv. Log Loss", - # "predict_time": "$t_{predict}$", - # "accuracy": "$\lambda_{ben.}$", # noqa W605 - # "failure_rate": "$h_{ben.}(t,;\\theta)$", - # "atk_value": "Attack Strength", - # } - # cox_partial_dict = { - # "file": "cox_partial_effects.pdf", - # "covariate_array": "model_layers", - # "values_array": [18, 34, 50, 101, 152], - # "replacement_dict": cox_replacement_dict, - # "title": "$S(t)$ for Cox AFR", - # "ylabel": "Expectation of $S(t)$", - # "xlabel": "Time $T$ (seconds)", - # "legend_kwargs": { - # "title": "No. of Layers", - # "labels": ["18", "34", "50", "101", "152"], - # }, - # } - # cox_plot_dict = { - # "file": "cox_aft.pdf", - # "duration_col": duration_col, - # "title": "Cox AFR Model", - # "mtype": "cox", - # "replacement_dict": cox_replacement_dict, - # } - # cox_afr, cft = plot_aft( - # df=X_train, - # event_col=target, - # **cox_plot_dict, - # ) - # cox_scores = score_model(cft, X_train, X_test) - # cox_partial = plot_partial_effects( - # aft=cft, - # **cox_partial_dict, - # ) + cox_replacement_dict = { + "adv_failure_rate": "$h_{adv}(t,;\\theta)$", + "def_value": "Defence Strength", + "data.sample.random_state": "Random State", + "train_time": "$t_{train}$", + "model_layers": "No. of Layers", + "model.art.pipeline.initialize.kwargs.optimizer.lr": "Learning Rate", + "adv_accuracy": "$\lambda_{adv.}$", # noqa w605 + "adv_fit_time": "$t_{attack}$", + "adv_log_loss": "Adv. Log Loss", + "predict_time": "$t_{predict}$", + "accuracy": "$\lambda_{ben.}$", # noqa w605 + "failure_rate": "$h_{ben.}(t,;\\theta)$", + "atk_value": "Attack Strength", + } # noqa w605 + cox_partial_dict = { + "file": "cox_partial_effects.pdf", + "covariate_array": "model_layers", + "values_array": [18, 34, 50, 101, 152], + "replacement_dict": cox_replacement_dict, + "title": "$S(t)$ for Cox AFR", + "ylabel": "Expectation of $S(t)$", + "xlabel": "Time $T$ (seconds)", + "legend_kwargs": { + "title": "No. of Layers", + "labels": ["18", "34", "50", "101", "152"], + }, + } + cox_plot_dict = { + "file": "cox_aft.pdf", + "duration_col": duration_col, + "title": "Cox AFR Model", + "mtype": "cox", + "replacement_dict": cox_replacement_dict, + } + cox_afr, cft = plot_aft( + df=X_train, + event_col=target, + **cox_plot_dict, + ) + cox_scores = score_model(cft, X_train, X_test) + cox_partial = plot_partial_effects( + aft=cft, + **cox_partial_dict, + ) log_normal_dict = { - "Intercept: sigma_": "$\sigma$", # noqa W605 - "Intercept: mu_": "$\mu$", # noqa W605 + "Intercept: sigma_": "$\sigma$", # noqa w605 + "Intercept: mu_": "$\mu$", # noqa w605 "def_value: mu_": "Defence Strength", "atk_value: mu_": "Attack Strength", "train_time: mu_": "$t_{train}$", @@ -368,12 +387,12 @@ def split_data_for_aft( "model.art.pipeline.initialize.kwargs.optimizer.lr: mu_": "Learning Rate", "data.sample.random_state: mu_": "Random State", "adv_log_loss: mu_": "Adv. Log Loss", - "adv_accuracy: mu_": "$\lambda_{adv.}$", # noqa W605 - "accuracy: mu_": "$\lambda_{ben.}$", # noqa W605 + "adv_accuracy: mu_": "$\lambda_{adv.}$", # noqa w605 + "accuracy: mu_": "$\lambda_{ben.}$", # noqa w605 "adv_failure_rate: mu_": "$h_{adv}(t,;\\theta)$", "def_gen": "Defence", "learning_rate: mu_": "Learning Rate", - } + } # noqa w605 log_normal_graph, lnt = plot_aft( X_train, @@ -399,20 +418,20 @@ def split_data_for_aft( "labels": ["18", "34", "50", "101", "152"], }, ) - log_logistic_dict = { - "Intercept: beta_": "$\\beta$", + log_logistic_dict = { # noqa w605 + "Intercept: beta_": "$\\beta$", # noqa w605 "Intercept: alpha_": "$\\alpha$", "data.sample.random_state: alpha_": "Random State", "def_value: alpha_": "Defence Strength", "atk_value: alpha_": "Attack Strength", "train_time: alpha_": "$t_{train}$", "predict_time: alpha_": "$t_{predict}$", - "adv_accuracy: alpha_": "$\lambda_{adv.}$", # noqa W605 - "accuracy: alpha_": "$\lambda_{ben.}$", # noqa W605 + "adv_accuracy: alpha_": "$\lambda_{adv.}$", # noqa w605 + "accuracy: alpha_": "$\lambda_{ben.}$", # noqa w605 "adv_fit_time: alpha_": "$t_{attack}$", "model_layers: alpha_": "No. of Layers", - "model.art.pipeline.initialize.kwargs.optimizer.lr:": "Learning Rate", - "adv_failure_rate: alpha_": "$h_{adv.}(t,\\theta)$", # noqa W605 + "model.art.pipeline.initialize.kwargs.optimizer.lr": "Learning Rate", + "adv_failure_rate: alpha_": "$h_{adv.}(t,\\theta)$", "alpha_": "", } diff --git a/deckard/layers/compile.py b/deckard/layers/compile.py index 17382b7d..170bace7 100644 --- a/deckard/layers/compile.py +++ b/deckard/layers/compile.py @@ -11,7 +11,15 @@ def flatten_results(df: pd.DataFrame) -> pd.DataFrame: - for col in df.columns: + """ + Args: + df (pd.DataFrame): a dataframe with dictionaries as entries in some columns + + Returns: + pd.DataFrame: a dataframe with the dictionaries flattened into columns using pd.json_normalize + """ + df = df.applymap(lambda x: x.strip() if isinstance(x, str) else x) + for col in tqdm(df.columns, desc="Flattening columns"): if isinstance(df[col][0], dict): tmp = pd.json_normalize(df[col]) tmp.columns = [f"{col}.{subcol}" for subcol in tmp.columns] @@ -34,48 +42,59 @@ def parse_folder(folder, files=["params.yaml", "score_dict.json"]) -> pd.DataFra :return: Pandas dataframe with the results """ folder = Path(folder) - results = {} + logger.debug(f"Parsing folder {folder}...") path_gen = [] for file in files: path_gen.extend(folder.glob(f"**/{file}")) path_gen.sort() - indices = [] - for file in tqdm(path_gen): - indices.append(file.parent.name) - suffix = file.suffix - folder = file.parent.name - stage = file.parent.parent.name - if folder not in results: - results[folder] = {} - if suffix == ".json": - with open(file, "r") as f: - try: - dict_ = json.load(f) - except json.decoder.JSONDecodeError as e: - raise e + folder_gen = map(lambda x: x.parent, path_gen) + folder_gen = set(folder_gen) + results = {} + for file in tqdm(path_gen, desc="Parsing Specified files"): + results = read_file(file, results) + for folder in tqdm(folder_gen, desc="Adding other files to results"): + results = add_file(folder, path_gen, results) + df = pd.DataFrame(results).T + return df - elif suffix == ".yaml": - with open(file, "r") as f: - dict_ = yaml.safe_load(f) - else: - raise ValueError(f"File type {suffix} not supported.") - results[folder]["stage"] = stage - results[folder].update(dict_) + +def add_file(folder, path_gen, results): all_files = Path(folder).glob("**/*") for file in all_files: if file not in path_gen: if file.parent.name not in results: results[file.parent.name] = {} results[file.parent.name][file.stem] = file - df = pd.DataFrame(results).T - return df + return results -def merge_defences(results: pd.DataFrame): +def read_file(file, results): + suffix = file.suffix + folder = file.parent.name + stage = file.parent.parent.name + if folder not in results: + results[folder] = {} + if suffix == ".json": + with open(file, "r") as f: + try: + dict_ = json.load(f) + except json.decoder.JSONDecodeError as e: + raise e + elif suffix == ".yaml": + with open(file, "r") as f: + dict_ = yaml.safe_load(f) + else: + raise ValueError(f"File type {suffix} not supported.") + results[folder]["stage"] = stage + results[folder].update(dict_) + return results + + +def merge_defences(results: pd.DataFrame, default_epochs=20): defences = [] def_gens = [] - for _, entry in results.iterrows(): + for _, entry in tqdm(results.iterrows(), desc="Merging defences"): defence = [] if ( "model.art.pipeline.preprocessor.name" in entry @@ -97,6 +116,11 @@ def merge_defences(results: pd.DataFrame): and entry["model.art.pipeline.trainer.name"] not in nones ): defence.append(entry["model.art.pipeline.trainer.name"]) + if ( + "model.init.nb_epoch" in entry + and entry["model.init.nb_epoch"] != default_epochs + ): + defence.append("Epochs") ############################################################################################################ if len(defence) > 1: def_gen = [str(x).split(".")[-1] for x in defence] @@ -121,7 +145,7 @@ def merge_defences(results: pd.DataFrame): def merge_attacks(results: pd.DataFrame): attacks = [] - for _, entry in results.iterrows(): + for _, entry in tqdm(results.iterrows(), desc="Merging attacks"): if "attack.init.name" in entry and entry["attack.init.name"] not in nones: attack = entry["attack.init.name"] else: @@ -133,17 +157,17 @@ def merge_attacks(results: pd.DataFrame): return results -def parse_results(folder, files=["score_dict.json", "params.yaml"]): +def parse_results(folder, files=["score_dict.json", "params.yaml"], default_epochs=20): df = parse_folder(folder, files=files) df = flatten_results(df) - df = merge_defences(df) + df = df.applymap(lambda x: x.strip() if isinstance(x, str) else x) + df = merge_defences(df, default_epochs=default_epochs) df = merge_attacks(df) return df -def format_control_parameter(data, control_dict): +def format_control_parameter(data, control_dict, min_max=True): logger.info("Formatting control parameters...") - if hasattr(data, "def_gen"): defences = data.def_gen.unique() else: @@ -152,7 +176,8 @@ def format_control_parameter(data, control_dict): attacks = data.atk_gen.unique() else: attacks = [] - + if data["model.init.name"].str.contains("Net").any(): + data["model_layers"] = data["model_name"].str.split("Net").str[-1] for defence in defences: if defence in control_dict: param = control_dict[defence] @@ -163,9 +188,17 @@ def format_control_parameter(data, control_dict): value = np.nan data.loc[data.def_gen == defence, "def_value"] = value control_dict.pop(defence) + else: logger.warning(f"Defence {defence} not in control_dict. Deleting rows.") data = data[data.def_gen != defence] + # if min_max is True: + # def_min = data[data.def_gen == defence].def_value.min() + # def_max = data[data.def_gen == defence].def_value.max() + # data.loc[data.def_gen == defence, "def_value"] = pd.to_numeric(data.loc[data.def_gen == defence, "def_value"], errors='coerce') + # data.loc[data.def_gen == defence, "def_value"] = ( + # data[data.def_gen == defence].def_value - def_min + # ) / (def_max - def_min) for attack in attacks: if attack in control_dict: @@ -181,6 +214,13 @@ def format_control_parameter(data, control_dict): logger.warning(f"Attack {attack} not in control_dict. Deleting rows.") data = data[data.atk_gen != attack] + # if min_max is True: + # atk_min = data[data.atk_gen == attack].atk_value.min() + # atk_max = data[data.atk_gen == attack].atk_value.max() + # data.loc[data.atk_gen == attack, "atk_value"] = pd.to_numeric(data.loc[data.atk_gen == attack, "atk_value"], errors='coerce') + # data.loc[data.atk_gen == attack, "atk_value"] = ( + # data[data.atk_gen == attack].atk_value - atk_min + # ) / (atk_max - atk_min) return data @@ -189,7 +229,6 @@ def clean_data_for_plotting( def_gen_dict, atk_gen_dict, control_dict, - file, ): logger.info("Replacing attack and defence names with short names...") if hasattr(data, "def_gen"): @@ -203,25 +242,24 @@ def clean_data_for_plotting( data.dropna(axis=1, how="all", inplace=True) logger.info("Shortening model names...") # Removes the path and to the model object and leaves the name of the model - data["model_name"] = data["model.init.name"].str.split(".").str[-1] - if data["model.init.name"].str.contains("Net").any(): - data["model_layers"] = data["model_name"].str.split("Net").str[-1] + if hasattr(data, "model.init.name") and len(data["model.init.name"].unique()) > 1: + model_names = data["model.init.name"].str.split(".").str[-1] + data["model_name"] = model_names data = data.loc[:, ~data.columns.str.endswith(".1")] - logger.info("Replacing data.sample.random_state with random_state...") - data["data.sample.random_state"].rename("random_state", inplace=True) - data = format_control_parameter(data, control_dict) - logger.info(f"Saving data to {file}") - data.to_csv(file) + if hasattr(data, "data.sample.random_state"): + logger.info("Replacing data.sample.random_state with random_state...") + data["data.sample.random_state"].rename("random_state", inplace=True) + data = format_control_parameter(data, control_dict, min_max=True) return data -def save_results(results, results_file) -> str: +def save_results(results, results_file, results_folder) -> str: """ Compile results from a folder of reports and save to a csv file; return the path to the csv file. It will optionally delete columns from the results. """ - logger.info("Compiling results...") - - suffix = Path(results_file).suffix + logger.info(f"Saving data to {Path(results_folder) / results_file}") + Path(results_folder).mkdir(exist_ok=True, parents=True) + suffix = Path(results_folder, results_file).suffix if suffix == ".csv": results.to_csv(results_file) elif suffix == ".xlsx": @@ -235,7 +273,6 @@ def save_results(results, results_file) -> str: assert Path( results_file, ).exists(), f"Results file {results_file} does not exist. Something went wrong." - logger.debug(f"Results saved to {results_file}") return results_file @@ -245,9 +282,11 @@ def save_results(results, results_file) -> str: parser = argparse.ArgumentParser() parser.add_argument("--results_file", type=str, default="results.csv") parser.add_argument("--report_folder", type=str, default="reports", required=True) + parser.add_argument("--results_folder", type=str, default="results") parser.add_argument("--config", type=str, default="conf/compile.yaml") parser.add_argument("--exclude", type=list, default=None, nargs="*") parser.add_argument("--verbose", type=str, default="INFO") + parser.add_argument("--default_epochs", type=int, default=20) parser.add_argument( "--kwargs", type=list, @@ -258,7 +297,8 @@ def save_results(results, results_file) -> str: logging.basicConfig(level=args.verbose) report_folder = args.report_folder results_file = args.results_file - results = parse_results(report_folder) + results_folder = args.results_folder + results = parse_results(report_folder, default_epochs=args.default_epochs) with open(Path(Path(), args.config), "r") as f: big_dict = yaml.load(f, Loader=yaml.FullLoader) def_gen_dict = big_dict["defences"] @@ -269,9 +309,8 @@ def save_results(results, results_file) -> str: def_gen_dict, atk_gen_dict, control_dict, - results_file, ) - report_file = save_results(results, results_file) + report_file = save_results(results, results_file, results_folder) assert Path( report_file, ).exists(), f"Results file {report_file} does not exist. Something went wrong." diff --git a/deckard/layers/old_afr.py b/deckard/layers/old_afr.py new file mode 100644 index 00000000..09072cb7 --- /dev/null +++ b/deckard/layers/old_afr.py @@ -0,0 +1,458 @@ +import pandas as pd +import numpy as np + +import matplotlib.pyplot as plt + +from sklearn.model_selection import train_test_split +from lifelines import ( + WeibullAFTFitter, + LogNormalAFTFitter, + LogLogisticAFTFitter, + CoxPHFitter, +) +import matplotlib +from pathlib import Path +import logging +import yaml +import argparse +from .plots import calculate_failure_rate, drop_frames_without_results, min_max_scaling + + +def plot_aft( + df, + file, + event_col, + duration_col, + title, + mtype, + xlabel=None, + ylabel=None, + replacement_dict={}, + **kwargs, +): + if mtype == "weibull": + aft = WeibullAFTFitter(**kwargs) + elif mtype == "log_normal": + aft = LogNormalAFTFitter(**kwargs) + elif mtype == "log_logistic": + aft = LogLogisticAFTFitter(**kwargs) + elif mtype == "cox": + aft = CoxPHFitter(**kwargs) + assert ( + duration_col in df.columns + ), f"Column {duration_col} not in dataframe with columns {df.columns}" + if event_col is not None: + assert ( + event_col in df.columns + ), f"Column {event_col} not in dataframe with columns {df.columns}" + plt.gcf().clear() + # enforce numerical values + df = df.apply(pd.to_numeric, errors="coerce") + print(df.columns) + input("Press Enter to continue...") + aft.fit(df, duration_col=duration_col, event_col=event_col, **kwargs) + ax = aft.plot() + labels = ax.get_yticklabels() + labels = [label.get_text() for label in labels] + for k, v in replacement_dict.items(): + labels = [label.replace(k, v) for label in labels] + ax.set_yticklabels(labels) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + ax.set_title(title) + ax.get_figure().tight_layout() + ax.get_figure().savefig(FOLDER / file) + logger.info(f"Saved graph to {FOLDER / file}") + plt.show() + plt.gcf().clear() + return ax, aft + + +def plot_partial_effects( + aft, + covariate_array, + values_array, + title=None, + file="partial_effects.pdf", + xlabel="Covariate", + ylabel="Failure rate", + legend_kwargs={"loc": "upper left"}, + replacement_dict={}, + cmap="coolwarm", + **kwargs, +): + plt.gcf().clear() + # kwargs.pop("replacement_dict") + pareto = aft.plot_partial_effects_on_outcome( + covariate_array, values_array, cmap=cmap, **kwargs + ) + labels = pareto.get_yticklabels() + labels = [label.get_text() for label in labels] + for k, v in replacement_dict.items(): + labels = [label.replace(k, v) for label in labels] + pareto.set_yticklabels(labels) + pareto.legend(**legend_kwargs) + pareto.set_ylabel(ylabel) + pareto.set_xlabel(xlabel) + pareto.set_title(title) + pareto.get_figure().tight_layout() + pareto.get_figure().savefig(FOLDER / file) + logger.info(f"Saved graph to {FOLDER / file}") + plt.gcf().clear() + return pareto + + +def score_model(aft, train, test): + train_score = aft.score(train) + test_score = aft.score(test) + scores = {"train_score": train_score, "test_score": test_score} + plt.show() + return scores + + +def make_afr_table(score_list, aft_dict, dataset): + assert len(score_list) == len( + aft_dict, + ), "Length of score list and aft dict must be equal" + aft_data = pd.DataFrame() + aft_data.index.name = "Model" + aft_data.index = aft_dict.keys() + aft_data["AIC"] = [ + x.AIC_ if not isinstance(x, CoxPHFitter) else np.nan for x in aft_dict.values() + ] + aft_data["Concordance"] = [x.concordance_index_ for x in aft_dict.values()] + aft_data["BIC"] = [ + x.AIC_ if not isinstance(x, CoxPHFitter) else np.nan for x in aft_dict.values() + ] + # aft_data["Train LL"] = [x["train_score"] for x in score_list] + # aft_data["Test LL"] = [x["test_score"] for x in score_list] + aft_data["Mean $S(t;\\theta)$"] = [ + x.predict_expectation(X_train).mean() for x in aft_dict.values() + ] + aft_data["Median $S(t;\\theta)$"] = [ + x.predict_median(X_train).median() for x in aft_dict.values() + ] + aft_data = aft_data.round(2) + aft_data.to_csv(FOLDER / "aft_comparison.csv") + logger.info(f"Saved AFT comparison to {FOLDER / 'aft_comparison.csv'}") + aft_data = aft_data.round(2) + aft_data.fillna("--", inplace=True) + aft_data.to_latex( + FOLDER / "aft_comparison.tex", + float_format="%.2f", + label=f"tab:{dataset}", + caption=f"Comparison of AFR Models on the {dataset.upper()} dataset.", + ) + + print(yaml.dump(aft_data.to_dict(), default_flow_style=False, indent=4)) + return aft_data + + +def clean_data_for_aft( + data, + kwarg_list, + target="adv_failure_rate", +): + subset = data.copy() + assert ( + target in subset + ), f"Target {target} not in dataframe with columns {subset.columns}" + + cleaned = pd.DataFrame() + kwarg_list.append(target) + for kwarg in kwarg_list: + cleaned = pd.concat([cleaned, subset[kwarg]], axis=1) + cols = cleaned.columns + cleaned = pd.DataFrame(subset, columns=cols) + if "accuracy" in cleaned.columns: + cleaned = cleaned[cleaned["accuracy"] != 1e10] + cleaned = cleaned[cleaned["accuracy"] != -1e10] + if "adv_accuracy" in cleaned.columns: + cleaned = cleaned[cleaned["adv_accuracy"] != 1e10] + cleaned = cleaned[cleaned["adv_accuracy"] != -1e10] + cleaned.dropna(inplace=True, how="any", axis=0) + y = cleaned[target].copy() + return cleaned, y, data + + +def split_data_for_aft( + data, + target, + duration_col, + kwarg_list, + test_size=0.2, + random_state=42, +): + cleaned, y, data = clean_data_for_aft(data, kwarg_list, target=target) + X_train, X_test, y_train, y_test = train_test_split( + cleaned, + y, + test_size=test_size, + random_state=random_state, + ) + assert ( + duration_col in cleaned + ), f"Duration {duration_col} not in dataframe with columns {cleaned.columns}" + return X_train, X_test, y_train, y_test + + +logger = logging.getLogger(__name__) + +if "__main__" == __name__: + afr_parser = argparse.ArgumentParser() + afr_parser.add_argument("--target", type=str, default="adv_failures") + afr_parser.add_argument("--duration_col", type=str, default="adv_fit_time") + afr_parser.add_argument("--dataset", type=str, default="mnist") + afr_parser.add_argument("--plots_folder", type=str, default="mnist/plots") + afr_parser.add_argument("--file", type=str, default="mnist/plots/data.csv") + afr_args = afr_parser.parse_args() + target = afr_args.target + duration_col = afr_args.duration_col + dataset = afr_args.dataset + + font = { + "family": "Times New Roman", + "weight": "bold", + "size": 22, + } + + matplotlib.rc("font", **font) + FOLDER = Path(afr_args.plots_folder) + data = pd.read_csv(afr_args.file, index_col=0) + data.columns = data.columns.str.strip() + + data = data.applymap(lambda x: x.strip() if isinstance(x, str) else x) + data = data.applymap(lambda x: pd.to_numeric(x, errors="coerce")) + data.def_value.replace("", 0, inplace=True) + data.atk_value.replace("", 0, inplace=True) + data.dropna(axis=0, subset=["atk_value", "atk_param"], inplace=True) + data.dropna(axis=0, subset=["def_value", "def_param"], inplace=True) + adv_failures = (1 - data.loc[:, "adv_accuracy"]) * data.loc[ + :, + "attack.attack_size", + ] + ben_failures = (1 - data.loc[:, "accuracy"]) * data.loc[ + :, + "attack.attack_size", + ] + data["adv_failures"] = adv_failures + data["ben_failures"] = ben_failures + data = drop_frames_without_results(data) + data = calculate_failure_rate(data) + data = min_max_scaling(data) + + kwarg_list = [ + "accuracy", + "train_time", + "predict_time", + "atk_value", + "def_value", + "data.sample.random_state", + "adv_failure_rate", + "model_layers", + "adv_fit_time", + "model.trainer.nb_epoch", + "adv_failures", + "ben_failures", + ] + + X_train, X_test, y_train, y_test = split_data_for_aft( + data, + target, + duration_col, + kwarg_list, + test_size=0.2, + random_state=42, + ) + + weibull_dict = { + "Intercept: rho_": "$\\rho$", + "Intercept: lambda_": "$\lambda$", # noqa W605 + "data.sample.random_state: lambda_": "Random State", + "def_value: lambda_": "Defence Strength", + "atk_value: lambda_": "Attack Strength", + "train_time: lambda_": "$t_{train}$", + "predict_time: lambda_": "$t_{predict}$", + "adv_accuracy: lambda_": "$\lambda_{adv.}$", # noqa W605 + "accuracy: lambda_": "$\lambda_{ben.}$", # noqa W605 + "adv_fit_time: lambda_": "$t_{attack}$", + "adv_log_loss: lambda_": "Adv. Log Loss", + "adv_failure_rate: lambda_": "$h_{adv.}(t,;\\theta)$", + "failure_rate: lambda_": "$h_{ben.}(t,;\\theta)$", + "model_layers: lambda_": "No. of Layers", + "model.art.pipeline.initialize.kwargs.optimizer.lr: lambda_": "Learning Rate", + "def_gen": "Defence", + } + + weibull_plot_dict = { + "file": "weibull_aft.pdf", + "title": "Weibull AFR Model", + "mtype": "weibull", + } + + weibull_partial_dict_layers = { + "file": "weibull_partial_effects.pdf", + "covariate_array": "model_layers", + "values_array": [18, 34, 50, 101, 152], + "title": "$S(t)$ for Weibull AFR", + "ylabel": "Expectation of $S(t)$", + "xlabel": "Time $T$ (seconds)", + "legend_kwargs": { + "title": "No. of Layers", + "labels": ["18", "34", "50", "101", "152"], + }, + } + + weibull_afr, wft = plot_aft( + X_train, + event_col=target, + duration_col=duration_col, + **weibull_plot_dict, + replacement_dict=weibull_dict, + ) + weibull_layers = plot_partial_effects(aft=wft, **weibull_partial_dict_layers) + wft_scores = score_model(wft, X_train, X_test) + + # cox_replacement_dict = { + # "adv_failure_rate": "$h_{adv}(t,;\\theta)$", + # "def_value": "Defence Strength", + # "data.sample.random_state": "Random State", + # "train_time": "$t_{train}$", + # "model_layers": "No. of Layers", + # "model.art.pipeline.initialize.kwargs.optimizer.lr": "Learning Rate", + # "adv_accuracy": "$\lambda_{adv.}$", # noqa W605 + # "adv_fit_time": "$t_{attack}$", + # "adv_log_loss": "Adv. Log Loss", + # "predict_time": "$t_{predict}$", + # "accuracy": "$\lambda_{ben.}$", # noqa W605 + # "failure_rate": "$h_{ben.}(t,;\\theta)$", + # "atk_value": "Attack Strength", + # } + # cox_partial_dict = { + # "file": "cox_partial_effects.pdf", + # "covariate_array": "model_layers", + # "values_array": [18, 34, 50, 101, 152], + # "replacement_dict": cox_replacement_dict, + # "title": "$S(t)$ for Cox AFR", + # "ylabel": "Expectation of $S(t)$", + # "xlabel": "Time $T$ (seconds)", + # "legend_kwargs": { + # "title": "No. of Layers", + # "labels": ["18", "34", "50", "101", "152"], + # }, + # } + # cox_plot_dict = { + # "file": "cox_aft.pdf", + # "duration_col": duration_col, + # "title": "Cox AFR Model", + # "mtype": "cox", + # "replacement_dict": cox_replacement_dict, + # } + # cox_afr, cft = plot_aft( + # df=X_train, + # event_col=target, + # **cox_plot_dict, + # ) + # cox_scores = score_model(cft, X_train, X_test) + # cox_partial = plot_partial_effects( + # aft=cft, + # **cox_partial_dict, + # ) + + log_normal_dict = { + "Intercept: sigma_": "$\sigma$", # noqa W605 + "Intercept: mu_": "$\mu$", # noqa W605 + "def_value: mu_": "Defence Strength", + "atk_value: mu_": "Attack Strength", + "train_time: mu_": "$t_{train}$", + "predict_time: mu_": "$t_{predict}$", + "adv_fit_time: mu_": "$t_{attack}$", + "model_layers: mu_": "No. of Layers", + "model.art.pipeline.initialize.kwargs.optimizer.lr: mu_": "Learning Rate", + "data.sample.random_state: mu_": "Random State", + "adv_log_loss: mu_": "Adv. Log Loss", + "adv_accuracy: mu_": "$\lambda_{adv.}$", # noqa W605 + "accuracy: mu_": "$\lambda_{ben.}$", # noqa W605 + "adv_failure_rate: mu_": "$h_{adv}(t,;\\theta)$", + "def_gen": "Defence", + "learning_rate: mu_": "Learning Rate", + } + + log_normal_graph, lnt = plot_aft( + X_train, + "log_normal_aft.pdf", + target, + duration_col, + "Log Normal AFR Model", + "log_normal", + replacement_dict=log_normal_dict, + ) + lnt_scores = score_model(lnt, X_train, X_test) + lnt_partial = plot_partial_effects( + file="log_normal_partial_effects.pdf", + aft=lnt, + covariate_array="model_layers", + values_array=[18, 34, 50, 101, 152], + replacement_dict=log_normal_dict, + title="$S(t)$ for Log-Normal AFR", + ylabel="Expectation of $S(t)$", + xlabel="Time $T$ (seconds)", + legend_kwargs={ + "title": "No. of Layers", + "labels": ["18", "34", "50", "101", "152"], + }, + ) + log_logistic_dict = { + "Intercept: beta_": "$\\beta$", + "Intercept: alpha_": "$\\alpha$", + "data.sample.random_state: alpha_": "Random State", + "def_value: alpha_": "Defence Strength", + "atk_value: alpha_": "Attack Strength", + "train_time: alpha_": "$t_{train}$", + "predict_time: alpha_": "$t_{predict}$", + "adv_accuracy: alpha_": "$\lambda_{adv.}$", # noqa W605 + "accuracy: alpha_": "$\lambda_{ben.}$", # noqa W605 + "adv_fit_time: alpha_": "$t_{attack}$", + "model_layers: alpha_": "No. of Layers", + "model.art.pipeline.initialize.kwargs.optimizer.lr:": "Learning Rate", + "adv_failure_rate: alpha_": "$h_{adv.}(t,\\theta)$", # noqa W605 + "alpha_": "", + } + + log_logistic_graph, llt = plot_aft( + X_train, + "log_logistic_aft.pdf", + target, + duration_col, + "Log Logistic AFR Model", + "log_logistic", + replacement_dict=log_logistic_dict, + ) + llt_scores = score_model(llt, X_train, X_test) + llt_partial = plot_partial_effects( + file="log_logistic_partial_effects.pdf", + aft=llt, + covariate_array="model_layers", + values_array=[18, 34, 50, 101, 152], + replacement_dict=log_logistic_dict, + title="$S(t)$ for Log-Logistic AFR", + ylabel="Expectation of $S(t)$", + xlabel="Time $T$ (seconds)", + legend_kwargs={ + "title": "No. of Layers", + "labels": ["18", "34", "50", "101", "152"], + }, + ) + aft_dict = { + "Weibull": wft, + "LogNormal": lnt, + "LogLogistic": llt, + # "Cox": cft, + } + score_list = [ + wft_scores, + lnt_scores, + llt_scores, + # cft_scores, + ] + aft_data = make_afr_table(score_list, aft_dict, dataset) diff --git a/deckard/layers/optimise.py b/deckard/layers/optimise.py index a1877c59..691b97c8 100644 --- a/deckard/layers/optimise.py +++ b/deckard/layers/optimise.py @@ -266,8 +266,10 @@ def write_stage(params: dict, stage: str, path=None, working_dir=None) -> None: def optimise(cfg: DictConfig) -> None: cfg = OmegaConf.to_container(OmegaConf.create(cfg), resolve=True) raise_exception = cfg.pop("raise_exception", False) - scorer = cfg.pop("optimizers", None) working_dir = Path(config_path).parent + direction = cfg.get("direction", "minimize") + direction = [direction] if not isinstance(direction, list) else direction + optimizers = cfg.get("optimizers") stage = cfg.pop("stage", None) cfg = parse_stage(params=cfg, stage=stage, path=working_dir) exp = instantiate(cfg) @@ -276,18 +278,10 @@ def optimise(cfg: DictConfig) -> None: Path(folder).mkdir(exist_ok=True, parents=True) write_stage(cfg, stage, path=folder, working_dir=working_dir) id_ = Path(files["score_dict_file"]).parent.name - direction = cfg.get("direction", "minimize") - direction = [direction] if not isinstance(direction, list) else direction + optimizers = [optimizers] if not isinstance(optimizers, list) else optimizers try: scores = exp() - if isinstance(scorer, str): - score = scores[scorer] - elif isinstance(scorer, list): - score = [scores[s] for s in scorer] - elif scorer is None: - score = list(scores.values())[0] - else: - raise TypeError(f"Expected str or list, got {type(scorer)}") + score = [v for k, v in scores.items() if k in optimizers] logger.info(f"Score is : {score}") except Exception as e: logger.warning( @@ -296,14 +290,21 @@ def optimise(cfg: DictConfig) -> None: with open(Path(folder, "exception.log"), "w") as f: f.write(str(e)) f.write(traceback.format_exc()) - if direction == "minimize": - score = [1e10] * len(direction) - else: - score = [-1e10] * len(direction) + fake_scores = [] + for direction in direction: + if direction == "minimize": + fake_scores.append(1e10) + elif direction == "maximize": + fake_scores.append(-1e10) + else: + raise ValueError(f"Unknown direction {direction}") + score = fake_scores logger.info(f"Score: {score}") if raise_exception: raise e - return tuple(score) + if len(score) == 1: + score = score[0] + return score if __name__ == "__main__": diff --git a/deckard/layers/plots.py b/deckard/layers/plots.py index 888c8527..db5427f7 100644 --- a/deckard/layers/plots.py +++ b/deckard/layers/plots.py @@ -153,7 +153,7 @@ def calculate_failure_rate(data): / data.loc[:, "predict_time"] ) data.loc[:, "adv_failure_rate"] = ( - (1 - data.loc[:, "adv_success"]) + (1 - data.loc[:, "adv_accuracy"]) * data.loc[:, "attack.attack_size"] / data.loc[:, "adv_fit_time"] ) @@ -264,24 +264,25 @@ def min_max_scaling(data, **kwargs): data, subset=[ "accuracy", - "adv_success", + "adv_accuracy", "train_time", "adv_fit_time", "predict_time", + "adv_success", ], ) - sense_dict = { - "accuracy": "max", - "adv_accuracy": "max", - "adv_success": "min", - "model_layers": "diff", - # "atk_param": "diff", - # "def_param": "diff", - "atk_gen": "diff", - "def_gen": "diff", - "data.sample.random_state": "diff", - } - data = pareto_set(data, sense_dict) + # sense_dict = { + # "accuracy": "max", + # "adv_accuracy": "max", + # "adv_success": "min", + # "model_layers": "diff", + # "atk_param": "diff", + # "def_param": "diff", + # "atk_gen": "diff", + # "def_gen": "diff", + # "data.sample.random_state": "diff", + # } + # data = pareto_set(data, sense_dict) data = calculate_failure_rate(data) data = min_max_scaling(data) if "Unnamed: 0" in data.columns: diff --git a/examples/classification/plots.ipynb b/examples/classification/plots.ipynb new file mode 100644 index 00000000..1ef9111e --- /dev/null +++ b/examples/classification/plots.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "# Load data\n", + "df = pd.read_csv(\"output/attack.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['attacks', 'defences', 'params'])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3723846/651469242.py:12: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " attack_results['Kernel'] = attack_results['model.init.kwargs.kernel']\n" + ] + } + ], + "source": [ + "from deckard.layers.compile import clean_data_for_plotting\n", + "import yaml\n", + "\n", + "with open(\"conf/compile.yaml\", \"r\") as f:\n", + " config = yaml.load(f, Loader=yaml.FullLoader)\n", + "print(config.keys())\n", + "def_gen_dict = config[\"defences\"]\n", + "atk_gen_dict = config[\"attacks\"]\n", + "control_dict = config[\"params\"]\n", + "\n", + "df = clean_data_for_plotting(df, def_gen_dict, atk_gen_dict, control_dict)\n", + "attack_results = df.dropna(subset=[\"accuracy\", \"adv_accuracy\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 2)\n", + "graph5 = sns.lineplot(\n", + " x=\"attack.init.kwargs.eps\",\n", + " y=\"accuracy\",\n", + " data=attack_results,\n", + " style=\"model.init.kwargs.kernel\",\n", + " ax=ax[0, 0],\n", + " legend=False,\n", + " color=\"darkred\",\n", + " style_order=[\"rbf\", \"poly\", \"linear\"],\n", + ")\n", + "graph5.set(xscale=\"log\", xlabel=\"Perturbation Distance\", ylabel=\"Accuracy\")\n", + "graph6 = sns.lineplot(\n", + " x=\"attack.init.kwargs.eps_step\",\n", + " y=\"accuracy\",\n", + " data=attack_results,\n", + " style=\"model.init.kwargs.kernel\",\n", + " ax=ax[0, 1],\n", + " color=\"darkred\",\n", + " style_order=[\"rbf\", \"poly\", \"linear\"],\n", + ")\n", + "graph6.set(xscale=\"log\", xlabel=\"Perturbation Step\", ylabel=\"Accuracy\")\n", + "graph7 = sns.lineplot(\n", + " x=\"attack.init.kwargs.max_iter\",\n", + " y=\"accuracy\",\n", + " data=attack_results,\n", + " style=\"Kernel\",\n", + " ax=ax[1, 0],\n", + " legend=False,\n", + " color=\"darkred\",\n", + " style_order=[\"rbf\", \"poly\", \"linear\"],\n", + ")\n", + "graph7.set(xscale=\"log\", xlabel=\"Maximum Iterations\", ylabel=\"Accuracy\")\n", + "graph8 = sns.lineplot(\n", + " x=\"attack.init.kwargs.batch_size\",\n", + " y=\"accuracy\",\n", + " data=attack_results,\n", + " style=\"Kernel\",\n", + " ax=ax[1, 1],\n", + " legend=False,\n", + " color=\"darkred\",\n", + " style_order=[\"rbf\", \"poly\", \"linear\"],\n", + ")\n", + "graph8.set(xscale=\"log\", xlabel=\"Batch Size\", ylabel=\"Accuracy\")\n", + "graph6.legend(loc=\"center left\", bbox_to_anchor=(1, 0.5), ncol=1, title=\"Kernel\")\n", + "fig.tight_layout()\n", + "fig.savefig(\"plots/accuracy_vs_attack_parameters.pdf\")\n", + "plt.gcf().clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(\n", + " data=df,\n", + " y=\"adv_fit_time\",\n", + " x=\"attack.init.kwargs.eps\",\n", + " hue=\"model.init.kwargs.kernel\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(\n", + " data=df,\n", + " y=\"adv_fit_time\",\n", + " x=\"attack.init.kwargs.eps_step\",\n", + " hue=\"model.init.kwargs.kernel\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(\n", + " data=df,\n", + " y=\"adv_fit_time\",\n", + " x=\"attack.init.kwargs.batch_size\",\n", + " hue=\"model.init.kwargs.kernel\",\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/power/conf/files/cifar.yaml b/examples/power/conf/files/cifar.yaml index 2a6598ec..2c7636a6 100644 --- a/examples/power/conf/files/cifar.yaml +++ b/examples/power/conf/files/cifar.yaml @@ -1,16 +1,16 @@ _target_: deckard.base.files.FileConfig reports: reports data_dir: data -model_dir: models +model_dir: null attack_dir: attacks directory: /result/cifar/ score_dict_file: score_dict.json data_file : data -model_file : model +model_file : null attack_file : attack attack_type : .pkl data_type : .pkl -model_type : .pt +model_type : null params_file : params.yaml # train_labels_file : train_labels.json # test_labels_file : test_labels.json diff --git a/examples/power/conf/files/cifar100.yaml b/examples/power/conf/files/cifar100.yaml index e9a11634..5674932d 100644 --- a/examples/power/conf/files/cifar100.yaml +++ b/examples/power/conf/files/cifar100.yaml @@ -1,16 +1,16 @@ _target_: deckard.base.files.FileConfig reports: reports data_dir: data -model_dir: models +model_dir: null attack_dir: attacks directory: /result/cifar100/ score_dict_file: score_dict.json data_file : data -model_file : model +model_file : null attack_file : attack attack_type : .pkl data_type : .pkl -model_type : .pt +model_type : null params_file : params.yaml # train_labels_file : train_labels.json # test_labels_file : test_labels.json diff --git a/examples/power/conf/files/mnist.yaml b/examples/power/conf/files/mnist.yaml index 09d39bb7..d45b1926 100644 --- a/examples/power/conf/files/mnist.yaml +++ b/examples/power/conf/files/mnist.yaml @@ -1,16 +1,16 @@ _target_: deckard.base.files.FileConfig reports: reports data_dir: data -model_dir: models +model_dir: null attack_dir: attacks directory: /result/mnist/ score_dict_file: score_dict.json data_file : data -model_file : model +model_file : null attack_file : attack attack_type : .pkl data_type : .pkl -model_type : .pt +model_type : null params_file : params.yaml # train_labels_file : train_labels.json # test_labels_file : test_labels.json diff --git a/examples/power/conf/model/art/initialize/default.yaml b/examples/power/conf/model/art/initialize/default.yaml index becd0f9a..b694473b 100644 --- a/examples/power/conf/model/art/initialize/default.yaml +++ b/examples/power/conf/model/art/initialize/default.yaml @@ -5,4 +5,3 @@ optimizer: lr : 0.01 momentum : 0.9 clip_values : [0, 255] -device_type : ${oc.env:DECKARD_DEVICE_TYPE,cpu} diff --git a/examples/power/dvc.lock b/examples/power/dvc.lock index 49bf8b09..9e991ad0 100644 --- a/examples/power/dvc.lock +++ b/examples/power/dvc.lock @@ -32,7 +32,7 @@ stages: data_file: data data_type: .pkl directory: mnist - model_dir: models + model_dir: null model_file: model model_type: .pt name: default @@ -292,7 +292,7 @@ stages: data_file: data data_type: .pkl directory: mnist - model_dir: models + model_dir: null model_file: model model_type: .pt name: default diff --git a/examples/pytorch/.dvc/.gitignore b/examples/pytorch/cifar10/.dvc/.gitignore similarity index 100% rename from examples/pytorch/.dvc/.gitignore rename to examples/pytorch/cifar10/.dvc/.gitignore diff --git a/examples/pytorch/.dvc/config b/examples/pytorch/cifar10/.dvc/config similarity index 100% rename from examples/pytorch/.dvc/config rename to examples/pytorch/cifar10/.dvc/config diff --git a/examples/pytorch/.dvcignore b/examples/pytorch/cifar10/.dvcignore similarity index 100% rename from examples/pytorch/.dvcignore rename to examples/pytorch/cifar10/.dvcignore diff --git a/examples/pytorch_cifar/.gitignore b/examples/pytorch/cifar10/.gitignore similarity index 100% rename from examples/pytorch_cifar/.gitignore rename to examples/pytorch/cifar10/.gitignore diff --git a/examples/pytorch/attacks.sh b/examples/pytorch/cifar10/attacks.sh similarity index 100% rename from examples/pytorch/attacks.sh rename to examples/pytorch/cifar10/attacks.sh diff --git a/examples/pytorch/conf/attack/default.yaml b/examples/pytorch/cifar10/conf/attack/default.yaml similarity index 100% rename from examples/pytorch/conf/attack/default.yaml rename to examples/pytorch/cifar10/conf/attack/default.yaml diff --git a/examples/pytorch_cifar/conf/cifar10.yaml b/examples/pytorch/cifar10/conf/cifar10.yaml similarity index 98% rename from examples/pytorch_cifar/conf/cifar10.yaml rename to examples/pytorch/cifar10/conf/cifar10.yaml index a0140d00..474fdfc6 100644 --- a/examples/pytorch_cifar/conf/cifar10.yaml +++ b/examples/pytorch/cifar10/conf/cifar10.yaml @@ -25,7 +25,7 @@ hydra: study_name: control storage: sqlite:///model.db n_jobs: ${hydra.launcher.n_jobs} - n_trials : 32 + n_trials: 32 params: ++data.sample.random_state: choice(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) ++model.art.initialize.optimizer.lr: choice(10, 1, 0.1, 0.01, 0.001, .0001, .00001, 0.000001) diff --git a/examples/pytorch/conf/compile.yaml b/examples/pytorch/cifar10/conf/compile.yaml similarity index 100% rename from examples/pytorch/conf/compile.yaml rename to examples/pytorch/cifar10/conf/compile.yaml diff --git a/examples/pytorch/conf/data/default.yaml b/examples/pytorch/cifar10/conf/data/default.yaml similarity index 100% rename from examples/pytorch/conf/data/default.yaml rename to examples/pytorch/cifar10/conf/data/default.yaml diff --git a/examples/pytorch/conf/data/torch_cifar.yaml b/examples/pytorch/cifar10/conf/data/torch_cifar.yaml similarity index 100% rename from examples/pytorch/conf/data/torch_cifar.yaml rename to examples/pytorch/cifar10/conf/data/torch_cifar.yaml diff --git a/examples/pytorch/conf/data/torch_mnist.yaml b/examples/pytorch/cifar10/conf/data/torch_mnist.yaml similarity index 100% rename from examples/pytorch/conf/data/torch_mnist.yaml rename to examples/pytorch/cifar10/conf/data/torch_mnist.yaml diff --git a/examples/pytorch/conf/files/cifar.yaml b/examples/pytorch/cifar10/conf/files/cifar.yaml similarity index 100% rename from examples/pytorch/conf/files/cifar.yaml rename to examples/pytorch/cifar10/conf/files/cifar.yaml diff --git a/examples/pytorch/conf/files/mnist.yaml b/examples/pytorch/cifar10/conf/files/mnist.yaml similarity index 100% rename from examples/pytorch/conf/files/mnist.yaml rename to examples/pytorch/cifar10/conf/files/mnist.yaml diff --git a/examples/pytorch/conf/model/art/default.yaml b/examples/pytorch/cifar10/conf/model/art/default.yaml similarity index 100% rename from examples/pytorch/conf/model/art/default.yaml rename to examples/pytorch/cifar10/conf/model/art/default.yaml diff --git a/examples/pytorch_cifar/conf/model/art/initialize/default.yaml b/examples/pytorch/cifar10/conf/model/art/initialize/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/initialize/default.yaml rename to examples/pytorch/cifar10/conf/model/art/initialize/default.yaml diff --git a/examples/pytorch/conf/model/art/postprocessor/confidence.yaml b/examples/pytorch/cifar10/conf/model/art/postprocessor/confidence.yaml similarity index 100% rename from examples/pytorch/conf/model/art/postprocessor/confidence.yaml rename to examples/pytorch/cifar10/conf/model/art/postprocessor/confidence.yaml diff --git a/examples/pytorch/conf/model/art/postprocessor/gauss-out.yaml b/examples/pytorch/cifar10/conf/model/art/postprocessor/gauss-out.yaml similarity index 100% rename from examples/pytorch/conf/model/art/postprocessor/gauss-out.yaml rename to examples/pytorch/cifar10/conf/model/art/postprocessor/gauss-out.yaml diff --git a/examples/pytorch/conf/grid/model/default.yaml b/examples/pytorch/cifar10/conf/model/art/preprocessor/default.yaml similarity index 100% rename from examples/pytorch/conf/grid/model/default.yaml rename to examples/pytorch/cifar10/conf/model/art/preprocessor/default.yaml diff --git a/examples/pytorch/conf/model/art/preprocessor/fsq.yaml b/examples/pytorch/cifar10/conf/model/art/preprocessor/fsq.yaml similarity index 100% rename from examples/pytorch/conf/model/art/preprocessor/fsq.yaml rename to examples/pytorch/cifar10/conf/model/art/preprocessor/fsq.yaml diff --git a/examples/pytorch/conf/model/art/preprocessor/gauss-in.yaml b/examples/pytorch/cifar10/conf/model/art/preprocessor/gauss-in.yaml similarity index 100% rename from examples/pytorch/conf/model/art/preprocessor/gauss-in.yaml rename to examples/pytorch/cifar10/conf/model/art/preprocessor/gauss-in.yaml diff --git a/examples/pytorch/conf/model/torch_cifar.yaml b/examples/pytorch/cifar10/conf/model/torch_cifar.yaml similarity index 100% rename from examples/pytorch/conf/model/torch_cifar.yaml rename to examples/pytorch/cifar10/conf/model/torch_cifar.yaml diff --git a/examples/pytorch/conf/model/torch_mnist.yaml b/examples/pytorch/cifar10/conf/model/torch_mnist.yaml similarity index 100% rename from examples/pytorch/conf/model/torch_mnist.yaml rename to examples/pytorch/cifar10/conf/model/torch_mnist.yaml diff --git a/examples/pytorch/conf/plots.yaml b/examples/pytorch/cifar10/conf/plots.yaml similarity index 100% rename from examples/pytorch/conf/plots.yaml rename to examples/pytorch/cifar10/conf/plots.yaml diff --git a/examples/pytorch/conf/scorers/default.yaml b/examples/pytorch/cifar10/conf/scorers/default.yaml similarity index 100% rename from examples/pytorch/conf/scorers/default.yaml rename to examples/pytorch/cifar10/conf/scorers/default.yaml diff --git a/examples/pytorch_cifar/dvc.lock b/examples/pytorch/cifar10/dvc.lock similarity index 66% rename from examples/pytorch_cifar/dvc.lock rename to examples/pytorch/cifar10/dvc.lock index d90598f9..95038e8d 100644 --- a/examples/pytorch_cifar/dvc.lock +++ b/examples/pytorch/cifar10/dvc.lock @@ -98,29 +98,30 @@ stages: size: 739680311 - path: cifar/models/model.optimizer.pt hash: md5 - md5: 09f978b389dbce742b1a8731b81913b0 + md5: d46598fb7feec074c02bd0ed081184da size: 44805933 - path: cifar/models/model.pt hash: md5 - md5: 7b6a070a946d4f5fcc79ac17de88296e + md5: f5d11f93160ad27b8468efc0d71eb695 size: 44811029 - path: cifar/reports/train/default/predictions.json hash: md5 - md5: c0a3cdf07b36af7ef9084ab0e2030fcc - size: 2435001 + md5: 37f581850d9f6d491cb0d9025e620bf9 + size: 2439094 - path: cifar/reports/train/default/score_dict.json hash: md5 - md5: 665f7680184855a05db884355132024c + md5: 055f95d856bc09b533eccb57314db0c4 size: 397 attack: cmd: python -m deckard.layers.experiment attack --config_file cifar10.yaml deps: - path: cifar/data/data.pkl + hash: md5 md5: 6503fed5d4e6cc1163898c0ab6a863dd size: 739680311 - path: cifar/models/model.pt hash: md5 - md5: 7b6a070a946d4f5fcc79ac17de88296e + md5: f5d11f93160ad27b8468efc0d71eb695 size: 44811029 params: params.yaml: @@ -330,16 +331,60 @@ stages: outs: - path: cifar/attacks/attack.pkl hash: md5 - md5: 7af56fed692b7c502bf7431adc68a3d0 + md5: 4c6d7b56c319a2a3a8f4288873141a44 size: 123046 - path: cifar/reports/attack/default/adv_predictions.json hash: md5 - md5: 7860bb5575e86ce8df3240e01abc930d - size: 2099 + md5: 0e905b6a95defafe1472cd1d329ed124 + size: 2136 - path: cifar/reports/attack/default/score_dict.json hash: md5 - md5: d3213b13fda99e50a582440a9752f827 - size: 558 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 + attacks@ResNet101: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet101 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar/reports/attack/ResNet101.db + --config-name cifar10.yaml + deps: + - path: attacks.sh + hash: md5 + md5: 963c858a322d7a4990a92a25d5684c57 + size: 2907 + - path: cifar/reports/attack/default/score_dict.json + hash: md5 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 + - path: models.sh + hash: md5 + md5: 02a4961b4afe7ba84c41e9ad49c30c83 + size: 2760 + outs: + - path: cifar/reports/attack/ResNet101.db + hash: md5 + md5: 268500e55100c8e2c0de628e8b66b612 + size: 819200 + attacks@ResNet152: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet152 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar/reports/attack/ResNet152.db + --config-name cifar10.yaml + deps: + - path: attacks.sh + hash: md5 + md5: 963c858a322d7a4990a92a25d5684c57 + size: 2907 + - path: cifar/reports/attack/default/score_dict.json + hash: md5 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 + - path: models.sh + hash: md5 + md5: 02a4961b4afe7ba84c41e9ad49c30c83 + size: 2760 + outs: + - path: cifar/reports/attack/ResNet152.db + hash: md5 + md5: 47684cf7d10b05f6343f58579fd05af3 + size: 249856 attacks@ResNet18: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet18 stage=attack ++hydra.sweeper.storage=sqlite:///cifar/reports/attack/ResNet18.db @@ -351,8 +396,8 @@ stages: size: 2907 - path: cifar/reports/attack/default/score_dict.json hash: md5 - md5: d3213b13fda99e50a582440a9752f827 - size: 558 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 - path: models.sh hash: md5 md5: 02a4961b4afe7ba84c41e9ad49c30c83 @@ -360,8 +405,8 @@ stages: outs: - path: cifar/reports/attack/ResNet18.db hash: md5 - md5: cb2a1edd44e08358b52d5ab5b6232aa5 - size: 1212416 + md5: bf2b93a31c49e96b219c23095504a7f1 + size: 819200 attacks@ResNet34: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet34 stage=attack ++hydra.sweeper.storage=sqlite:///cifar/reports/attack/ResNet34.db @@ -373,8 +418,8 @@ stages: size: 2907 - path: cifar/reports/attack/default/score_dict.json hash: md5 - md5: d3213b13fda99e50a582440a9752f827 - size: 558 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 - path: models.sh hash: md5 md5: 02a4961b4afe7ba84c41e9ad49c30c83 @@ -382,7 +427,7 @@ stages: outs: - path: cifar/reports/attack/ResNet34.db hash: md5 - md5: c19b84776f8a6f99705c5f6bbd2a28c6 + md5: 8de8f4dfcda52bb40f206cf3c4977dd5 size: 819200 attacks@ResNet50: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet50 @@ -395,8 +440,8 @@ stages: size: 2907 - path: cifar/reports/attack/default/score_dict.json hash: md5 - md5: d3213b13fda99e50a582440a9752f827 - size: 558 + md5: f40b5d8125bf8b6370a94fe65d43cffa + size: 458 - path: models.sh hash: md5 md5: 02a4961b4afe7ba84c41e9ad49c30c83 @@ -404,175 +449,5 @@ stages: outs: - path: cifar/reports/attack/ResNet50.db hash: md5 - md5: e44f2b22e7d876571148078c180842ea - size: 819200 - attacks@ResNet101: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet101 - ++stage=attack ++hydra.sweeper.storage=sqlite:///ResNet101.db --config-name - default.yaml - deps: - - path: attacks.sh - md5: 18b363f1e2d0622c372e07116bed4fd8 - size: 2731 - - path: models.sh - md5: 9386478ad9795b80ec8ebc4abf1dbc81 - size: 1221 - - path: output/attacks/attack.pkl - md5: e57b871f32a1a8b7de497f6e5de4ebf1 - size: 123046 - - path: output/reports/attack/default/adv_predictions.json - md5: 0a097842037186d905fb2fd7ec4072d9 - size: 2125 - - path: output/reports/attack/default/params.yaml - md5: 5177666d7f2e1e55ccad8ab4b735ffc7 - size: 5175 - outs: - - path: ResNet101.db - md5: 076f51ae8bc6f487920baee046c1a930 - size: 1282048 - attacks@ResNet152: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet152 - ++stage=attack ++hydra.sweeper.storage=sqlite:///ResNet152.db --config-name - default.yaml - deps: - - path: attacks.sh - md5: da51ec626ca4fa915be37e944ac5218b - size: 2745 - - path: models.sh - md5: 9386478ad9795b80ec8ebc4abf1dbc81 - size: 1221 - - path: output/attacks/attack.pkl - md5: aab66fe871d14945003859fa44125c75 - size: 123046 - - path: output/reports/attack/default/adv_predictions.json - md5: 61d687b977e8c7e9404e69a690b244dd - size: 2154 - - path: output/reports/attack/default/params.yaml - md5: 5177666d7f2e1e55ccad8ab4b735ffc7 - size: 5175 - outs: - - path: ResNet152.db - md5: 143435750b3f57d1a1280d412df74e0b - size: 638976 - compile@attack: - cmd: python -m deckard.layers.compile --report_folder output/reports/attack --results_file - output/reports/attack.csv - deps: - - path: ResNet101.db - md5: 076f51ae8bc6f487920baee046c1a930 - size: 1282048 - - path: ResNet152.db - md5: 143435750b3f57d1a1280d412df74e0b - size: 638976 - - path: ResNet18.db - md5: ff0eb78d052a31f3710336a21e81601e - size: 110592 - - path: ResNet34.db - md5: 946c9a1a88d7caaa6af3679a343cc770 - size: 1290240 - - path: ResNet50.db - md5: 1e3b638560b7ee5e73c674d0e1eb0421 - size: 446464 - - path: output/reports/attack/ - md5: e9c9c2d886498cd61644b8780106edf3.dir - size: 9928248484 - nfiles: 30111 - outs: - - path: output/reports/attack.csv - md5: 4ff19338677ca0ae0d766354a77fa4c8 - size: 18272588 - plot: - cmd: python -m deckard.layers.plots --path output/plots/ --file output/reports/attack.csv - deps: - - path: output/reports/attack.csv - md5: 4ff19338677ca0ae0d766354a77fa4c8 - size: 18272588 - outs: - - path: output/plots/adv_accuracy_vs_attack_type.pdf - md5: 8352f085dde6740b1c87a38bd2a87516 - size: 34926 - - path: output/plots/adv_accuracy_vs_defence_type.pdf - md5: db4aeb461e389047e05eeef7408c5266 - size: 28996 - - path: output/plots/adv_failure_rate_vs_train_time.pdf - md5: a71510ed101d113855d2f9d9ed000393 - size: 42293 - - path: output/plots/adv_failures_per_test_time_vs_defence_type.pdf - md5: 05872213e13a2b0d71f2b6876f769c45 - size: 35029 - - path: output/plots/adv_failures_per_train_time_vs_attack_type.pdf - md5: cfbd9e3d4ff3acf690409cc1af22cbee - size: 39001 - - path: output/plots/adv_failures_per_train_time_vs_defence_type.pdf - md5: b267b951ccc797ccd0bb88e1b359fb6c - size: 32071 - - path: output/plots/atk_param_vs_accuracy.pdf - md5: 8fc619749560fd1be8ac91d04af75203 - size: 24819 - - path: output/plots/ben_accuracy_vs_defence_type.pdf - md5: 2b8f3b735b4eec3572734048dfb859d4 - size: 30297 - - path: output/plots/ben_failure_rate_vs_defence_type.pdf - md5: d2110a2ffdbaa984fe4eb0470dea5c32 - size: 36994 - - path: output/plots/ben_failures_per_train_time_vs_defence_type.pdf - md5: 3aee46faf5a24cd7e0fe3a7053e0f3a2 - size: 31693 - - path: output/plots/data.csv - md5: 1a5ba962d3fc11adcde869712cae4c73 - size: 5018537 - - path: output/plots/def_param_vs_accuracy.pdf - md5: 8e1eea047988b58adafa0919d9674f1a - size: 22770 - - path: output/plots/def_param_vs_adv_accuracy.pdf - md5: aa888fef90099ec3b4866bf0cc22686e - size: 22765 - - path: output/plots/def_param_vs_adv_failure_rate.pdf - md5: 30a15ed503ec93e3b34e69d1af6473e5 - size: 21905 - afr: - cmd: python -m deckard.layers.afr --dataset cifar - deps: - - path: output/plots/data.csv - md5: 1a5ba962d3fc11adcde869712cae4c73 - size: 5018537 - outs: - - path: output/plots/aft_comparison.csv - md5: 7e07c42f2d7c3f3d6a4f49a7823ee62f - size: 191 - - path: output/plots/aft_comparison.tex - md5: c9bf05dced494a1e69aa23534540902e - size: 416 - - path: output/plots/cox_aft.pdf - md5: 08ba7bf48594f94cc66ceccba7b38939 - size: 31502 - - path: output/plots/cox_partial_effects.pdf - md5: 7f7a310fbde6ee46749632023f6b0015 - size: 46475 - - path: output/plots/log_logistic_aft.pdf - md5: e21d6c4176804a522022461b02ab7e20 - size: 34160 - - path: output/plots/log_logistic_partial_effects.pdf - md5: 800456e5361a2cab4a36533fbe149f97 - size: 30412 - - path: output/plots/log_normal_aft.pdf - md5: a6c08cd4cea95e707ed21b35c3d450e8 - size: 34314 - - path: output/plots/log_normal_partial_effects.pdf - md5: 7f8cf2863b9f4a959848675c6c1e8817 - size: 31071 - - path: output/plots/weibull_aft.pdf - md5: 3f3a04df96a120e3a878ece4365df8d6 - size: 32480 - - path: output/plots/weibull_partial_effects.pdf - md5: 45e3c5680ca070186224dda2141db4d8 - size: 30790 - copy_results: - cmd: cp -r output/plots/* ~/ml_afr/cifar/ - deps: - - path: output/plots/aft_comparison.csv - md5: 7e07c42f2d7c3f3d6a4f49a7823ee62f - size: 191 - - path: output/plots/data.csv - md5: 1a5ba962d3fc11adcde869712cae4c73 - size: 5018537 + md5: 8adabcf8a15b13fc20ea31f58ae7388b + size: 1069056 diff --git a/examples/pytorch_cifar/dvc.yaml b/examples/pytorch/cifar10/dvc.yaml similarity index 98% rename from examples/pytorch_cifar/dvc.yaml rename to examples/pytorch/cifar10/dvc.yaml index 30efbe5b..54d84654 100644 --- a/examples/pytorch_cifar/dvc.yaml +++ b/examples/pytorch/cifar10/dvc.yaml @@ -54,11 +54,11 @@ stages: # persist: True attacks: foreach: # This is a loop over the ResNet models - - ResNet18 - - ResNet34 - - ResNet50 - - ResNet101 - - ResNet152 + - ResNet18 + - ResNet34 + - ResNet50 + - ResNet101 + - ResNet152 do: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.${item} stage=attack ++hydra.sweeper.storage=sqlite:///${files.directory}/${files.reports}/attack/${item}.db --config-name cifar10.yaml deps: diff --git a/examples/pytorch_cifar/models.sh b/examples/pytorch/cifar10/models.sh similarity index 100% rename from examples/pytorch_cifar/models.sh rename to examples/pytorch/cifar10/models.sh diff --git a/examples/pytorch_cifar/torch_example.py b/examples/pytorch/cifar10/torch_example.py similarity index 100% rename from examples/pytorch_cifar/torch_example.py rename to examples/pytorch/cifar10/torch_example.py diff --git a/examples/pytorch_cifar/.dvc/.gitignore b/examples/pytorch/cifar100/.dvc/.gitignore similarity index 100% rename from examples/pytorch_cifar/.dvc/.gitignore rename to examples/pytorch/cifar100/.dvc/.gitignore diff --git a/examples/pytorch_cifar/.dvc/config b/examples/pytorch/cifar100/.dvc/config similarity index 100% rename from examples/pytorch_cifar/.dvc/config rename to examples/pytorch/cifar100/.dvc/config diff --git a/examples/pytorch_cifar/.dvcignore b/examples/pytorch/cifar100/.dvcignore similarity index 100% rename from examples/pytorch_cifar/.dvcignore rename to examples/pytorch/cifar100/.dvcignore diff --git a/examples/pytorch_cifar_100/.gitignore b/examples/pytorch/cifar100/.gitignore similarity index 100% rename from examples/pytorch_cifar_100/.gitignore rename to examples/pytorch/cifar100/.gitignore diff --git a/examples/pytorch_cifar/attacks.sh b/examples/pytorch/cifar100/attacks.sh similarity index 100% rename from examples/pytorch_cifar/attacks.sh rename to examples/pytorch/cifar100/attacks.sh diff --git a/examples/pytorch_cifar/conf/attack/default.yaml b/examples/pytorch/cifar100/conf/attack/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/attack/default.yaml rename to examples/pytorch/cifar100/conf/attack/default.yaml diff --git a/examples/pytorch_cifar_100/conf/cifar100.yaml b/examples/pytorch/cifar100/conf/cifar100.yaml similarity index 98% rename from examples/pytorch_cifar_100/conf/cifar100.yaml rename to examples/pytorch/cifar100/conf/cifar100.yaml index 760e2feb..01df936a 100644 --- a/examples/pytorch_cifar_100/conf/cifar100.yaml +++ b/examples/pytorch/cifar100/conf/cifar100.yaml @@ -33,7 +33,7 @@ hydra: _target_: hydra_plugins.hydra_optuna_sweeper.optuna_sweeper.OptunaSweeper launcher: _target_: hydra_plugins.hydra_joblib_launcher.joblib_launcher.JoblibLauncher - n_jobs: 8 + n_jobs: 4 prefer : processes verbose: 10 timeout: null diff --git a/examples/pytorch_cifar/conf/compile.yaml b/examples/pytorch/cifar100/conf/compile.yaml similarity index 100% rename from examples/pytorch_cifar/conf/compile.yaml rename to examples/pytorch/cifar100/conf/compile.yaml diff --git a/examples/pytorch_cifar/conf/data/default.yaml b/examples/pytorch/cifar100/conf/data/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/data/default.yaml rename to examples/pytorch/cifar100/conf/data/default.yaml diff --git a/examples/pytorch/cifar100/conf/data/torch_cifar100.yaml b/examples/pytorch/cifar100/conf/data/torch_cifar100.yaml new file mode 100644 index 00000000..756bedca --- /dev/null +++ b/examples/pytorch/cifar100/conf/data/torch_cifar100.yaml @@ -0,0 +1,12 @@ +_target_: deckard.base.data.Data +generate: + name: torch_cifar100 + path: original_data +sample: + random_state : 0 + stratify: True +sklearn_pipeline: + preprocessor: + name: sklearn.preprocessing.StandardScaler + with_mean: True + with_std: True diff --git a/examples/pytorch/cifar100/conf/data/torch_mnist.yaml b/examples/pytorch/cifar100/conf/data/torch_mnist.yaml new file mode 100644 index 00000000..56e9c38b --- /dev/null +++ b/examples/pytorch/cifar100/conf/data/torch_mnist.yaml @@ -0,0 +1,14 @@ +_target_: deckard.base.data.Data +generate: + _target_: deckard.base.data.generator.DataGenerator + name: torch_mnist +sample: + _target_: deckard.base.data.sampler.SklearnDataSampler + random_state : 0 + stratify: True +sklearn_pipeline: + _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline + preprocessor: + name: sklearn.preprocessing.StandardScaler + with_mean: True + with_std: True diff --git a/examples/pytorch/conf/deploy/pod.yaml b/examples/pytorch/cifar100/conf/deploy/pod.yaml similarity index 100% rename from examples/pytorch/conf/deploy/pod.yaml rename to examples/pytorch/cifar100/conf/deploy/pod.yaml diff --git a/examples/pytorch/conf/deploy/pvc.yaml b/examples/pytorch/cifar100/conf/deploy/pvc.yaml similarity index 100% rename from examples/pytorch/conf/deploy/pvc.yaml rename to examples/pytorch/cifar100/conf/deploy/pvc.yaml diff --git a/examples/pytorch/conf/deploy/sclass.yaml b/examples/pytorch/cifar100/conf/deploy/sclass.yaml similarity index 100% rename from examples/pytorch/conf/deploy/sclass.yaml rename to examples/pytorch/cifar100/conf/deploy/sclass.yaml diff --git a/examples/pytorch_cifar_100/conf/files/cifar100.yaml b/examples/pytorch/cifar100/conf/files/cifar100.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/files/cifar100.yaml rename to examples/pytorch/cifar100/conf/files/cifar100.yaml diff --git a/examples/pytorch_cifar/conf/files/mnist.yaml b/examples/pytorch/cifar100/conf/files/mnist.yaml similarity index 100% rename from examples/pytorch_cifar/conf/files/mnist.yaml rename to examples/pytorch/cifar100/conf/files/mnist.yaml diff --git a/examples/pytorch_cifar/conf/model/art/default.yaml b/examples/pytorch/cifar100/conf/model/art/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/default.yaml rename to examples/pytorch/cifar100/conf/model/art/default.yaml diff --git a/examples/pytorch/conf/model/art/initialize/default.yaml b/examples/pytorch/cifar100/conf/model/art/initialize/default.yaml similarity index 100% rename from examples/pytorch/conf/model/art/initialize/default.yaml rename to examples/pytorch/cifar100/conf/model/art/initialize/default.yaml diff --git a/examples/pytorch_cifar/conf/model/art/postprocessor/confidence.yaml b/examples/pytorch/cifar100/conf/model/art/postprocessor/confidence.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/postprocessor/confidence.yaml rename to examples/pytorch/cifar100/conf/model/art/postprocessor/confidence.yaml diff --git a/examples/pytorch_cifar/conf/model/art/postprocessor/gauss-out.yaml b/examples/pytorch/cifar100/conf/model/art/postprocessor/gauss-out.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/postprocessor/gauss-out.yaml rename to examples/pytorch/cifar100/conf/model/art/postprocessor/gauss-out.yaml diff --git a/examples/pytorch/conf/model/art/preprocessor/default.yaml b/examples/pytorch/cifar100/conf/model/art/preprocessor/default.yaml similarity index 100% rename from examples/pytorch/conf/model/art/preprocessor/default.yaml rename to examples/pytorch/cifar100/conf/model/art/preprocessor/default.yaml diff --git a/examples/pytorch_cifar/conf/model/art/preprocessor/fsq.yaml b/examples/pytorch/cifar100/conf/model/art/preprocessor/fsq.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/preprocessor/fsq.yaml rename to examples/pytorch/cifar100/conf/model/art/preprocessor/fsq.yaml diff --git a/examples/pytorch_cifar/conf/model/art/preprocessor/gauss-in.yaml b/examples/pytorch/cifar100/conf/model/art/preprocessor/gauss-in.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/preprocessor/gauss-in.yaml rename to examples/pytorch/cifar100/conf/model/art/preprocessor/gauss-in.yaml diff --git a/examples/pytorch_cifar_100/conf/model/torch_cifar100.yaml b/examples/pytorch/cifar100/conf/model/torch_cifar100.yaml similarity index 93% rename from examples/pytorch_cifar_100/conf/model/torch_cifar100.yaml rename to examples/pytorch/cifar100/conf/model/torch_cifar100.yaml index ffc0db53..d7d0f91d 100644 --- a/examples/pytorch_cifar_100/conf/model/torch_cifar100.yaml +++ b/examples/pytorch/cifar100/conf/model/torch_cifar100.yaml @@ -8,6 +8,6 @@ init: num_classes: 100 _target_: deckard.base.model.Model trainer: - nb_epoch: 100 + nb_epoch: 1 batch_size: 1024 library : pytorch diff --git a/examples/pytorch_cifar/conf/model/torch_mnist.yaml b/examples/pytorch/cifar100/conf/model/torch_mnist.yaml similarity index 93% rename from examples/pytorch_cifar/conf/model/torch_mnist.yaml rename to examples/pytorch/cifar100/conf/model/torch_mnist.yaml index 762addc1..26c462f6 100644 --- a/examples/pytorch_cifar/conf/model/torch_mnist.yaml +++ b/examples/pytorch/cifar100/conf/model/torch_mnist.yaml @@ -8,6 +8,6 @@ init: name : torch_example.ResNet18 _target_: deckard.base.model.Model trainer: - nb_epoch: 20 + nb_epoch: 1 batch_size: 1024 library : pytorch diff --git a/examples/pytorch_cifar/conf/plots.yaml b/examples/pytorch/cifar100/conf/plots.yaml similarity index 100% rename from examples/pytorch_cifar/conf/plots.yaml rename to examples/pytorch/cifar100/conf/plots.yaml diff --git a/examples/pytorch_cifar/conf/scorers/default.yaml b/examples/pytorch/cifar100/conf/scorers/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/scorers/default.yaml rename to examples/pytorch/cifar100/conf/scorers/default.yaml diff --git a/examples/pytorch_cifar_100/dvc.lock b/examples/pytorch/cifar100/dvc.lock similarity index 77% rename from examples/pytorch_cifar_100/dvc.lock rename to examples/pytorch/cifar100/dvc.lock index de9319c7..a7d3feef 100644 --- a/examples/pytorch_cifar_100/dvc.lock +++ b/examples/pytorch/cifar100/dvc.lock @@ -84,7 +84,7 @@ stages: library: pytorch trainer: batch_size: 1024 - nb_epoch: 100 + nb_epoch: 10 scorers: _target_: deckard.base.scorer.ScorerDict accuracy: @@ -97,36 +97,29 @@ stages: name: sklearn.metrics.log_loss outs: - path: cifar100/data/data.pkl - hash: md5 md5: 1070854e6c00fc787bc0fdfc82792fd6 size: 761280311 - path: cifar100/models/model.optimizer.pt - hash: md5 - md5: 8b65d9bf40085b3f4573ed859d3b0696 - size: 44990637 + md5: c13297479b0da6a736dfd1221ba175ac + size: 44989261 - path: cifar100/models/model.pt - hash: md5 - md5: 4321db4b035a2016cabb9eb9d758ace6 - size: 44995733 + md5: d2e61603d2c2e3de37a441351b168efa + size: 44998157 - path: cifar100/reports/train/default/predictions.json - hash: md5 - md5: bdffc46adff64ccce60dcfb5960add7c - size: 24402965 + md5: d3714b8d6a66fb803936da52650f88ec + size: 24412355 - path: cifar100/reports/train/default/score_dict.json - hash: md5 - md5: 60904225857c24ad2822fb92e170a26b - size: 387 + md5: 07a51c660e5d2a980e6c1fbc3dce0c16 + size: 842 attack: cmd: python -m deckard.layers.experiment attack --config_file cifar100.yaml deps: - path: cifar100/data/data.pkl - hash: md5 md5: 1070854e6c00fc787bc0fdfc82792fd6 size: 761280311 - path: cifar100/models/model.pt - hash: md5 - md5: 4321db4b035a2016cabb9eb9d758ace6 - size: 44995733 + md5: d2e61603d2c2e3de37a441351b168efa + size: 44998157 params: params.yaml: attack: @@ -196,7 +189,7 @@ stages: library: pytorch trainer: batch_size: 1024 - nb_epoch: 100 + nb_epoch: 10 name: art.attacks.evasion.HopSkipJump method: evasion model: @@ -248,7 +241,7 @@ stages: library: pytorch trainer: batch_size: 1024 - nb_epoch: 100 + nb_epoch: 10 data: _target_: deckard.base.data.Data generate: @@ -329,7 +322,7 @@ stages: library: pytorch trainer: batch_size: 1024 - nb_epoch: 100 + nb_epoch: 10 scorers: _target_: deckard.base.scorer.ScorerDict accuracy: @@ -342,36 +335,101 @@ stages: name: sklearn.metrics.log_loss outs: - path: cifar100/attacks/attack.pkl - hash: md5 - md5: 53b5fbaa742a6e711248fd5bef50e333 + md5: b5d92a276b64215cbfbd6dbfb91c0d00 size: 123046 - path: cifar100/reports/attack/default/adv_predictions.json - hash: md5 - md5: c113079d397ba3f2714280524524a127 - size: 21335 + md5: 36f3eb805d4c1d45846c9e6684e2adfe + size: 21009 - path: cifar100/reports/attack/default/score_dict.json - hash: md5 - md5: df6268a9e688028be341b32b9cbc7f65 - size: 540 + md5: ddbabb9810f501b7bd027f511c11d526 + size: 1111 attacks@ResNet18: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet18 stage=attack ++hydra.sweeper.storage=sqlite:///cifar100/reports/attack/ResNet18.db --config-name cifar100.yaml deps: - path: attacks.sh - hash: md5 md5: 963c858a322d7a4990a92a25d5684c57 size: 2907 - path: cifar100/reports/attack/default/score_dict.json - hash: md5 - md5: df6268a9e688028be341b32b9cbc7f65 - size: 540 + md5: f21ab891918c857171941e84dcc1b09a + size: 561 - path: models.sh - hash: md5 md5: 1937e58bedac027034aea7d4a5712407 size: 1380 outs: - path: cifar100/reports/attack/ResNet18.db - hash: md5 - md5: 5542bfcf3caf0cccc60d1cdf43a0a35a - size: 462848 + md5: 89fd1d229465cb1c49d1fd99cacbad33 + size: 475136 + attacks@ResNet152: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet152 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar100/reports/attack/ResNet152.db + --config-name cifar100.yaml + deps: + - path: attacks.sh + md5: 963c858a322d7a4990a92a25d5684c57 + size: 2907 + - path: cifar100/reports/attack/default/score_dict.json + md5: f21ab891918c857171941e84dcc1b09a + size: 561 + - path: models.sh + md5: 1937e58bedac027034aea7d4a5712407 + size: 1380 + outs: + - path: cifar100/reports/attack/ResNet152.db + md5: 5561d1c232b35787d315ebc17c28386d + size: 249856 + attacks@ResNet34: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet34 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar100/reports/attack/ResNet34.db + --config-name cifar100.yaml + deps: + - path: attacks.sh + md5: 963c858a322d7a4990a92a25d5684c57 + size: 2907 + - path: cifar100/reports/attack/default/score_dict.json + md5: f21ab891918c857171941e84dcc1b09a + size: 561 + - path: models.sh + md5: 1937e58bedac027034aea7d4a5712407 + size: 1380 + outs: + - path: cifar100/reports/attack/ResNet34.db + md5: 95cd20456616d5eb65d47a74c8ea1fdd + size: 487424 + attacks@ResNet50: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet50 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar100/reports/attack/ResNet50.db + --config-name cifar100.yaml + deps: + - path: attacks.sh + md5: 963c858a322d7a4990a92a25d5684c57 + size: 2907 + - path: cifar100/reports/attack/default/score_dict.json + md5: f21ab891918c857171941e84dcc1b09a + size: 561 + - path: models.sh + md5: 1937e58bedac027034aea7d4a5712407 + size: 1380 + outs: + - path: cifar100/reports/attack/ResNet50.db + md5: 5556f78590f52e7879cb434450ab78c8 + size: 745472 + attacks@ResNet101: + cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet101 + stage=attack ++hydra.sweeper.storage=sqlite:///cifar100/reports/attack/ResNet101.db + --config-name cifar100.yaml + deps: + - path: attacks.sh + md5: 29a1990d363aa5e09675957c1beb3f61 + size: 2929 + - path: cifar100/reports/attack/default/score_dict.json + md5: b14eb1d736510305310573ea477f1d20 + size: 1107 + - path: models.sh + md5: 1937e58bedac027034aea7d4a5712407 + size: 1380 + outs: + - path: cifar100/reports/attack/ResNet101.db + md5: bb029a105080100e8ea5ee180fe5cfbc + size: 544768 diff --git a/examples/pytorch_cifar_100/dvc.yaml b/examples/pytorch/cifar100/dvc.yaml similarity index 99% rename from examples/pytorch_cifar_100/dvc.yaml rename to examples/pytorch/cifar100/dvc.yaml index 254a637a..2bd4ac3e 100644 --- a/examples/pytorch_cifar_100/dvc.yaml +++ b/examples/pytorch/cifar100/dvc.yaml @@ -54,9 +54,9 @@ stages: # persist: True attacks: foreach: # This is a loop over the ResNet models - - ResNet18 - - ResNet34 - - ResNet50 + # - ResNet18 + # - ResNet34 + # - ResNet50 - ResNet101 - ResNet152 do: diff --git a/examples/pytorch/models.sh b/examples/pytorch/cifar100/models.sh similarity index 100% rename from examples/pytorch/models.sh rename to examples/pytorch/cifar100/models.sh diff --git a/examples/pytorch/torch_example.py b/examples/pytorch/cifar100/torch_example.py similarity index 100% rename from examples/pytorch/torch_example.py rename to examples/pytorch/cifar100/torch_example.py diff --git a/examples/pytorch/conf/deploy/default.yaml b/examples/pytorch/conf/deploy/default.yaml deleted file mode 100644 index 134da65f..00000000 --- a/examples/pytorch/conf/deploy/default.yaml +++ /dev/null @@ -1,14 +0,0 @@ -num_nodes: 1 -cluster_name: k8s-cluster -gpu_type: nvidia-tesla-v100 -gpu_count: 1 -gpu_driver_version: default -machine_type: n1-standard-2 -min_nodes: 1 -max_nodes: 1 -storage_config: conf/deploy/sclass.yaml -persistent_volume_claim: conf/deploy/pvc.yaml -pod : conf/deploy/pod.yaml -image_project: ubuntu-os-cloud -image_family: ubuntu-2204-lts -mount_directory: /mnt/filestore diff --git a/examples/pytorch/dvc.lock b/examples/pytorch/dvc.lock deleted file mode 100644 index 589dc9b8..00000000 --- a/examples/pytorch/dvc.lock +++ /dev/null @@ -1,761 +0,0 @@ -schema: '2.0' -stages: - train: - cmd: python -m deckard.layers.experiment train --config_file mnist.yaml - params: - params.yaml: - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - files: - _target_: deckard.base.files.FileConfig - adv_predictions_file: adv_predictions.json - attack_dir: attacks - attack_file: attack - attack_type: .pkl - data_dir: data - data_file: data - data_type: .pkl - directory: mnist - model_dir: models - model_file: model - model_type: .pt - name: default - params_file: params.yaml - predictions_file: predictions.json - reports: reports - score_dict_file: score_dict.json - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - scorers: - _target_: deckard.base.scorer.ScorerDict - accuracy: - _target_: deckard.base.scorer.ScorerConfig - direction: maximize - name: sklearn.metrics.accuracy_score - log_loss: - _target_: deckard.base.scorer.ScorerConfig - direction: minimize - name: sklearn.metrics.log_loss - outs: - - path: mnist/data/data.pkl - md5: de934a5f5157970e5f30b8f3f1856a68 - size: 222320311 - - path: mnist/models/model.optimizer.pt - hash: md5 - md5: 1316143c68da44c95cc0294482ba8a50 - size: 44780845 - - path: mnist/models/model.pt - hash: md5 - md5: 0c750c2da34962313084b05ceb424aa2 - size: 44785941 - - path: mnist/reports/train/default/predictions.json - hash: md5 - md5: 1396b6032cbd1e76ace82789dcf54861 - size: 2883588 - - path: mnist/reports/train/default/score_dict.json - hash: md5 - md5: 45631341a862aa88bfffbde78d099c6d - size: 411 - attack: - cmd: python -m deckard.layers.experiment attack --config_file mnist.yaml - deps: - - path: mnist/data/data.pkl - md5: de934a5f5157970e5f30b8f3f1856a68 - size: 222320311 - - path: mnist/models/model.pt - hash: md5 - md5: 0c750c2da34962313084b05ceb424aa2 - size: 44785941 - params: - params.yaml: - attack: - _target_: deckard.base.attack.Attack - attack_size: 10 - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.attack.AttackInitializer - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - name: art.attacks.evasion.HopSkipJump - method: evasion - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - files: - _target_: deckard.base.files.FileConfig - adv_predictions_file: adv_predictions.json - attack_dir: attacks - attack_file: attack - attack_type: .pkl - data_dir: data - data_file: data - data_type: .pkl - directory: mnist - model_dir: models - model_file: model - model_type: .pt - name: default - params_file: params.yaml - predictions_file: predictions.json - reports: reports - score_dict_file: score_dict.json - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - scorers: - _target_: deckard.base.scorer.ScorerDict - accuracy: - _target_: deckard.base.scorer.ScorerConfig - direction: maximize - name: sklearn.metrics.accuracy_score - log_loss: - _target_: deckard.base.scorer.ScorerConfig - direction: minimize - name: sklearn.metrics.log_loss - outs: - - path: mnist/attacks/attack.pkl - hash: md5 - md5: e1047df78f629f7267cfa7ef869f19f5 - size: 31517 - - path: mnist/reports/attack/default/adv_predictions.json - hash: md5 - md5: 2ab54c7713532e6e1303e5653c9e14f3 - size: 2194 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - models: - cmd: bash models.sh - ++model.init.name=torch_example.ResNet18,torch_example.ResNet34,torch_example.ResNet50 - --config-name grid.yaml - deps: - - path: output/data/data.pkl - md5: de934a5f5157970e5f30b8f3f1856a68 - size: 222320311 - - path: output/models/model.pt - md5: 38451da384fb8f787707a2b39b8418de - size: 44786389 - outs: - - path: model.db - md5: d1eac324650402da6e3de1aebe0e3b3c - size: 237568 - attacks: - cmd: bash attacks.sh - ++model.init.name=torch_example.ResNet18,torch_example.ResNet34,torch_example.ResNet50 - ++stage=attack --config-name grid.yaml - deps: - - path: model.db - md5: d1eac324650402da6e3de1aebe0e3b3c - size: 237568 - - path: output/data/data.pkl - md5: de934a5f5157970e5f30b8f3f1856a68 - size: 222320311 - - path: output/models/model.pt - md5: 38451da384fb8f787707a2b39b8418de - size: 44786389 - outs: - - path: attack.db - md5: c9f920c7233802e9c46e4051c2da78e6 - size: 307200 - compile_train: - cmd: python -m deckard.layers.compile --report_folder output/reports/train/ --results_file - output/reports/train.csv - deps: - - path: model.db - md5: e5dc2d529f4841baf9cccedd7b417988 - size: 110592 - - path: output/data/ - md5: 0078b738d3ac5d26c4c487d9c43903da.dir - size: 1111601555 - nfiles: 5 - - path: output/models/ - md5: 2dc57f423c263fa18830ef6d532f592f.dir - size: 1074846 - nfiles: 14 - outs: - - path: output/reports/train.csv - md5: 54707302f1ee42d25231d73ee2c03cf3 - size: 12177 - compile_attack: - cmd: python -m deckard.layers.compile --report_folder output/reports/attack/ --results_file - output/reports/attack.csv - deps: - - path: attack.db - md5: 576e07b1a496218659b7a425a812412b - size: 319488 - - path: output/attacks/ - md5: f6967d943832917c2b1e0db449d514f7.dir - size: 336979704 - nfiles: 1044 - - path: output/data/ - md5: 837a1c3acf188d7955e48419b38d8135.dir - size: 2445523421 - nfiles: 11 - - path: output/models/ - md5: 33fa241d9672dfc7f7f27927869d4948.dir - size: 160466396 - nfiles: 2088 - outs: - - path: output/reports/attack.csv - md5: 36ffafc8cb80eb6fbed190be9d420ef7 - size: 3674355 - compile@attack: - cmd: python -m deckard.layers.compile --report_folder output/reports/attack --results_file - output/reports/attack.csv - deps: - - path: ResNet101.db - md5: c47414423a51a4b866be6ce8312cb97e - size: 561152 - - path: ResNet18.db - md5: 2ae52c7b342b46ac01c79f06bfdc6c38 - size: 2768896 - - path: ResNet34.db - md5: 6a5795cbb9d977cdaadf365a6ac76a0a - size: 983040 - - path: ResNet50.db - md5: 7e215d670119b0703c3d97d86e28e117 - size: 561152 - - path: output/reports/attack/ - md5: a76eb881be1813685bf988cf8dbe7a52.dir - size: 5109780242 - nfiles: 10514 - outs: - - path: output/reports/attack.csv - md5: 69c87ac633b8abae15d65852c79ea89c - size: 6309975 - compile@train: - cmd: python -m deckard.layers.compile --report_folder output/reports/train --results_file - output/reports/train.csv - deps: - - path: ResNet101.db - md5: 744f187243001db70f63c8161d7f913f - size: 1314816 - - path: ResNet152.db - md5: e0fcb3876ec636b12d7dc9e71b9d1e1c - size: 1314816 - - path: ResNet18.db - md5: aa69b1818219c139f8e33ac205771ec1 - size: 110592 - - path: ResNet34.db - md5: e4d151b9800a1255a0143368057cb146 - size: 1339392 - - path: ResNet50.db - md5: 9c9bc0aab00251ca5e9bd210366bc055 - size: 1339392 - - path: output/reports/train/ - md5: 098781f04bdba3498c00a157e3e45826.dir - size: 403646689 - nfiles: 640 - outs: - - path: output/reports/train.csv - md5: 152c61d1ae1a58e89c03c1351d5bf406 - size: 411488 - attacks@ResNet152: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet152 - stage=attack ++hydra.sweeper.storage=sqlite:///mnist/reports/attack/ResNet152.db - --config-name mnist.yaml - deps: - - path: attacks.sh - hash: md5 - md5: 963c858a322d7a4990a92a25d5684c57 - size: 2907 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - - path: models.sh - hash: md5 - md5: 1937e58bedac027034aea7d4a5712407 - size: 1380 - outs: - - path: mnist/reports/attack/ResNet152.db - hash: md5 - md5: afb6f3d2616446226012b3ff1143086a - size: 462848 - plot: - cmd: python -m deckard.layers.plots --path output/plots/ --file output/reports/attack.csv - deps: - - path: ResNet101.db - md5: c47414423a51a4b866be6ce8312cb97e - size: 561152 - - path: ResNet152.db - md5: 690f931bf696f8e5f1e044fa7b335411 - size: 425984 - - path: ResNet18.db - md5: 2ae52c7b342b46ac01c79f06bfdc6c38 - size: 2768896 - - path: ResNet34.db - md5: 6a5795cbb9d977cdaadf365a6ac76a0a - size: 983040 - - path: ResNet50.db - md5: 7e215d670119b0703c3d97d86e28e117 - size: 561152 - - path: output/reports/attack.csv - md5: 69c87ac633b8abae15d65852c79ea89c - size: 6309975 - outs: - - path: output/plots/data.csv - md5: 8283c78e358db5d4ce19e5d44b6e735e - size: 2185730 - attacks@ResNet101: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet101 - stage=attack ++hydra.sweeper.storage=sqlite:///mnist/reports/attack/ResNet101.db - --config-name mnist.yaml - deps: - - path: attacks.sh - hash: md5 - md5: 963c858a322d7a4990a92a25d5684c57 - size: 2907 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - - path: models.sh - hash: md5 - md5: 1937e58bedac027034aea7d4a5712407 - size: 1380 - outs: - - path: mnist/reports/attack/ResNet101.db - hash: md5 - md5: 600452804d96c8b8483c3f8da01130c4 - size: 462848 - attacks@ResNet34: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet34 - stage=attack ++hydra.sweeper.storage=sqlite:///mnist/reports/attack/ResNet34.db - --config-name mnist.yaml - deps: - - path: attacks.sh - hash: md5 - md5: 963c858a322d7a4990a92a25d5684c57 - size: 2907 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - - path: models.sh - hash: md5 - md5: 1937e58bedac027034aea7d4a5712407 - size: 1380 - outs: - - path: mnist/reports/attack/ResNet34.db - hash: md5 - md5: 9244c6545aa2d39680b601311b446b7d - size: 1593344 - attacks@ResNet50: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet50 - stage=attack ++hydra.sweeper.storage=sqlite:///mnist/reports/attack/ResNet50.db - --config-name mnist.yaml - deps: - - path: attacks.sh - hash: md5 - md5: 963c858a322d7a4990a92a25d5684c57 - size: 2907 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - - path: models.sh - hash: md5 - md5: 1937e58bedac027034aea7d4a5712407 - size: 1380 - outs: - - path: mnist/reports/attack/ResNet50.db - hash: md5 - md5: d9ee221b942b56d9bb720e022e05bf4b - size: 462848 - afr: - cmd: python -m deckard.layers.afr --dataset mnist - deps: - - path: output/plots/data.csv - md5: 8283c78e358db5d4ce19e5d44b6e735e - size: 2185730 - outs: - - path: output/plots/aft_comparison.csv - md5: a72d5fbf5c21b5055e6bc20a0e48c6aa - size: 178 - - path: output/plots/aft_comparison.tex - md5: e53edcb94e353f2e03324d1c02673332 - size: 401 - - path: output/plots/cox_aft.pdf - md5: 6b5fd449d724cf097eea5d8569dda3f0 - size: 30712 - - path: output/plots/cox_partial_effects.pdf - md5: a434a352ea874a5c188f76ef8456dbdf - size: 28132 - - path: output/plots/log_logistic_aft.pdf - md5: 6b1e524a7b7c2da913e4c9346115167c - size: 33524 - - path: output/plots/log_logistic_partial_effects.pdf - md5: f3c5ccbbb5129cbffe6b38f70d655245 - size: 29147 - - path: output/plots/log_normal_aft.pdf - md5: c0b1f808746c28b5b352ca425c6d2d33 - size: 34017 - - path: output/plots/log_normal_partial_effects.pdf - md5: 1c67a22e51019ceeb39573ea21b4a7ba - size: 29844 - - path: output/plots/weibull_aft.pdf - md5: 4b8119d87bd201bea0fa9955e3f3481d - size: 32175 - - path: output/plots/weibull_partial_effects.pdf - md5: 4b1433467ad94132bde9003c9faaed10 - size: 29359 - copy_results: - cmd: cp -r output/plots/* ~/ml_afr/mnist/ - deps: - - path: output/plots/aft_comparison.csv - md5: a72d5fbf5c21b5055e6bc20a0e48c6aa - size: 178 - - path: output/plots/data.csv - md5: 8283c78e358db5d4ce19e5d44b6e735e - size: 2185730 - attacks@ResNet18: - cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.ResNet18 - stage=attack ++hydra.sweeper.storage=sqlite:///mnist/reports/attack/ResNet18.db - --config-name mnist.yaml - deps: - - path: attacks.sh - hash: md5 - md5: 963c858a322d7a4990a92a25d5684c57 - size: 2907 - - path: mnist/reports/attack/default/score_dict.json - hash: md5 - md5: a7b1ec550fe1eeb7c5b16c0f36b28ff8 - size: 472 - - path: models.sh - hash: md5 - md5: 1937e58bedac027034aea7d4a5712407 - size: 1380 - outs: - - path: mnist/reports/attack/ResNet18.db - hash: md5 - md5: 2b4e2a2ac1cdd015cf469496a9861088 - size: 999424 - models@ResNet50: - cmd: bash models.sh ++model.init.name=torch_example.ResNet50 stage=train ++hydra.sweeper.storage=sqlite:///mnist/reports/train/ResNet50.db - --config-name mnist.yaml - deps: - - path: mnist/models/model.optimizer.pt - hash: md5 - md5: cc914518d5c8fdab1e7ec43c7db63a3b - size: 44780845 - - path: mnist/models/model.pt - hash: md5 - md5: 0508fa68d600b39cd8ce1dad0152fba3 - size: 44785941 - - path: models.sh - md5: e5079ede85d4f9b286984e507a157af4 - size: 1371 - outs: - - path: mnist/reports/train/ResNet50.db - hash: md5 - md5: 957e39666f06c9e8e207a9f98bc569b5 - size: 913408 - models@ResNet18: - cmd: bash models.sh ++model.init.name=torch_example.ResNet18 stage=train ++hydra.sweeper.storage=sqlite:///mnist/reports/train/ResNet18.db - --config-name mnist.yaml - deps: - - path: mnist/models/model.optimizer.pt - hash: md5 - md5: f4e28adc9c0d30180eca422da2dd00e3 - size: 44780845 - - path: mnist/models/model.pt - hash: md5 - md5: 53a2d89abb350e2601f35f36b95f6095 - size: 44785941 - - path: models.sh - hash: md5 - md5: cd5b2760310df71a36a2ea26021477b4 - size: 1366 - outs: - - path: mnist/reports/train/ResNet18.db - hash: md5 - md5: 225273e0494668fa42bc6f69fb29d392 - size: 901120 - models@ResNet34: - cmd: bash models.sh ++model.init.name=torch_example.ResNet34 stage=train ++hydra.sweeper.storage=sqlite:///mnist/reports/train/ResNet34.db - --config-name mnist.yaml - deps: - - path: mnist/models/model.optimizer.pt - hash: md5 - md5: cc914518d5c8fdab1e7ec43c7db63a3b - size: 44780845 - - path: mnist/models/model.pt - hash: md5 - md5: 0508fa68d600b39cd8ce1dad0152fba3 - size: 44785941 - - path: models.sh - hash: md5 - md5: e5079ede85d4f9b286984e507a157af4 - size: 1371 - outs: - - path: mnist/reports/train/ResNet34.db - hash: md5 - md5: af60ce478f27cda303ebd34c63cf05d3 - size: 913408 - models@ResNet101: - cmd: bash models.sh ++model.init.name=torch_example.ResNet101 stage=train ++hydra.sweeper.storage=sqlite:///mnist/reports/train/ResNet101.db - --config-name mnist.yaml - deps: - - path: mnist/models/model.optimizer.pt - hash: md5 - md5: cc914518d5c8fdab1e7ec43c7db63a3b - size: 44780845 - - path: mnist/models/model.pt - hash: md5 - md5: 0508fa68d600b39cd8ce1dad0152fba3 - size: 44785941 - - path: models.sh - hash: md5 - md5: cd5b2760310df71a36a2ea26021477b4 - size: 1366 - outs: - - path: mnist/reports/train/ResNet101.db - hash: md5 - md5: a8e178cba49addf77bac3b27e974ce8c - size: 917504 diff --git a/examples/pytorch_cifar_100/.dvc/.gitignore b/examples/pytorch/mnist/.dvc/.gitignore similarity index 100% rename from examples/pytorch_cifar_100/.dvc/.gitignore rename to examples/pytorch/mnist/.dvc/.gitignore diff --git a/examples/pytorch_cifar_100/.dvc/config b/examples/pytorch/mnist/.dvc/config similarity index 100% rename from examples/pytorch_cifar_100/.dvc/config rename to examples/pytorch/mnist/.dvc/config diff --git a/examples/pytorch_cifar_100/.dvcignore b/examples/pytorch/mnist/.dvcignore similarity index 100% rename from examples/pytorch_cifar_100/.dvcignore rename to examples/pytorch/mnist/.dvcignore diff --git a/examples/pytorch/.gitignore b/examples/pytorch/mnist/.gitignore similarity index 100% rename from examples/pytorch/.gitignore rename to examples/pytorch/mnist/.gitignore diff --git a/examples/pytorch_cifar_100/attacks.sh b/examples/pytorch/mnist/attacks.sh similarity index 51% rename from examples/pytorch_cifar_100/attacks.sh rename to examples/pytorch/mnist/attacks.sh index 8ec1f079..717f8dc4 100644 --- a/examples/pytorch_cifar_100/attacks.sh +++ b/examples/pytorch/mnist/attacks.sh @@ -3,20 +3,20 @@ # # This script is used to generate the attacks for the example. # Fast Gradient Method -bash models.sh attack=default ++attack.init.name=art.attacks.evasion.FastGradientMethod ++attack.init.eps=.001,.01,.1,.5,1 ++attack.init.norm=inf,1,2 ++attack.init.eps_step=.001,.003,.01 ++attack.init.batch_size=1024 stage=attack ++hydra.sweeper.study_name=fgm ++direction=maximize $@ +# bash models.sh attack=default ++attack.init.name=art.attacks.evasion.FastGradientMethod ++attack.init.eps=.001,.01,.1,.5,1 ++attack.init.norm=inf,1,2 ++attack.init.eps_step=.001,.003,.01 ++attack.init.batch_size=1024 stage=attack ++hydra.sweeper.study_name=fgm ++direction=maximize $@ -# Projected Gradient Descent -bash models.sh attack=default ++attack.init.name=art.attacks.evasion.ProjectedGradientDescent ++attack.init.eps=.001,.01,.1,.5,1 ++attack.init.norm=inf,1,2 ++attack.init.eps_step=.001,.003,.01 ++attack.init.batch_size=1024 ++attack.init.max_iter=10 stage=attack ++hydra.sweeper.study_name=pgd ++direction=maximize $@ +# # Projected Gradient Descent +# bash models.sh attack=default ++attack.init.name=art.attacks.evasion.ProjectedGradientDescent ++attack.init.eps=.001,.01,.1,.5,1 ++attack.init.norm=inf,1,2 ++attack.init.eps_step=.001,.003,.01 ++attack.init.batch_size=1024 ++attack.init.max_iter=10 stage=attack ++hydra.sweeper.study_name=pgd ++direction=maximize $@ -# DeepFool -bash models.sh attack=default ++attack.init.name=art.attacks.evasion.DeepFool ++attack.init.max_iter=10 ++attack.init.batch_size=1024 ++attack.init.nb_grads=1,3,5,10 stage=attack ++hydra.sweeper.study_name=deep ++direction=maximize $@ +# # DeepFool +# bash models.sh attack=default ++attack.init.name=art.attacks.evasion.DeepFool ++attack.init.max_iter=10 ++attack.init.batch_size=1024 ++attack.init.nb_grads=1,3,5,10 stage=attack ++hydra.sweeper.study_name=deep ++direction=maximize $@ -# HopSkipJump -bash models.sh attack=default ++attack.init.name=art.attacks.evasion.HopSkipJump ++attack.init.max_iter=1,3,5,10 ++attack.init.init_eval=10 ++attack.init.norm=inf,2 stage=attack ++hydra.sweeper.study_name=hsj ++direction=maximize $@ +# # HopSkipJump +# bash models.sh attack=default ++attack.init.name=art.attacks.evasion.HopSkipJump ++attack.init.max_iter=1,3,5,10 ++attack.init.init_eval=10 ++attack.init.norm=inf,2 stage=attack ++hydra.sweeper.study_name=hsj ++direction=maximize $@ -# ##################################################### -# PixelAttack -bash models.sh attack=default ++attack.init.name=art.attacks.evasion.PixelAttack ++attack.init.max_iter=10 ++attack.init.th=1,4,16,64,256 stage=attack ++hydra.sweeper.study_name=pixel ++direction=maximize $@ +# # ##################################################### +# # PixelAttack +# bash models.sh attack=default ++attack.init.name=art.attacks.evasion.PixelAttack ++attack.init.max_iter=10 ++attack.init.th=1,4,16,64,256 stage=attack ++hydra.sweeper.study_name=pixel ++direction=maximize $@ # ThresholdAttack bash models.sh attack=default ++attack.init.name=art.attacks.evasion.ThresholdAttack ++attack.init.max_iter=10 ++attack.init.th=1,4,16,64,256 stage=attack ++hydra.sweeper.study_name=thresh ++direction=maximize $@ diff --git a/examples/pytorch/mnist/average_across_random_states.ipynb b/examples/pytorch/mnist/average_across_random_states.ipynb new file mode 100644 index 00000000..26730596 --- /dev/null +++ b/examples/pytorch/mnist/average_across_random_states.ipynb @@ -0,0 +1,826 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from pathlib import Path\n", + "from paretoset import paretoset\n", + "\n", + "# Compiled data file\n", + "data_file = \"mnist/reports/attack.csv\"\n", + "\n", + "# Read data\n", + "df = pd.read_csv(data_file)\n", + "df.head()\n", + "sense_dict = {\n", + " \"model_layers\": \"diff\",\n", + " \"def_gen\": \"diff\",\n", + " \"def_param\": \"diff\",\n", + " \"train_time\": \"min\",\n", + " \"predict_time\": \"min\",\n", + " \"accuracy\": \"max\",\n", + " \"data.sample.random_state\": \"diff\",\n", + " \"model.trainer.nb_epoch\": \"diff\",\n", + " \"atk_gen\": \"diff\",\n", + " \"atk_param\": \"diff\",\n", + " \"adv_accuracy\": \"max\",\n", + " \"adv_fit_time\": \"min\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of models: 5\n", + "Layers: [ 18 34 50 101 152]\n", + "Number of epochs: 5\n", + "Epochs: [ 1 10 30 50 100]\n", + "Number of attacks: 6\n", + "Attacks: ['Deep' 'FGM' 'HSJ' 'PGD' 'Pixel' 'Thresh']\n", + "Number of defenses: 1\n", + "Defenses: ['Control']\n", + "\n" + ] + } + ], + "source": [ + "layers = df.model_layers.unique()\n", + "layers.sort()\n", + "epochs = df[\"model.trainer.nb_epoch\"].unique()\n", + "epochs.sort()\n", + "attacks = df.atk_gen.unique()\n", + "attacks.sort()\n", + "defenses = df.def_gen.unique()\n", + "defenses.sort()\n", + "\n", + "print(\n", + " f\"Number of models: {len(layers)}\\n\"\n", + " f\"Layers: {layers}\\n\"\n", + " f\"Number of epochs: {len(epochs)}\\n\"\n", + " f\"Epochs: {epochs}\\n\"\n", + " f\"Number of attacks: {len(attacks)}\\n\"\n", + " f\"Attacks: {attacks}\\n\"\n", + " f\"Number of defenses: {len(defenses)}\\n\"\n", + " f\"Defenses: {defenses}\\n\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grouping by ['model_layers', 'model.trainer.nb_epoch', 'atk_gen', 'def_gen', 'attack.attack_size'] for accuracy\n", + "Grouping by ['model_layers', 'model.trainer.nb_epoch', 'atk_gen', 'def_gen', 'attack.attack_size'] for adv_fit_time\n", + "Grouping by ['model_layers', 'model.trainer.nb_epoch', 'atk_gen', 'def_gen', 'attack.attack_size'] for adv_accuracy\n", + "Grouping by ['model_layers', 'model.trainer.nb_epoch', 'atk_gen', 'def_gen', 'attack.attack_size'] for predict_time\n", + "Grouping by ['model_layers', 'model.trainer.nb_epoch', 'atk_gen', 'def_gen', 'attack.attack_size'] for train_time\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", + " \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", + " \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", + " \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", + " \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", + "
Unnamed: 0stage_target_attackdatafilesmodelnamescorerspredict_time...def_paramdef_valueatk_paramatk_valuemean_accuracymean_model.trainer.nb_epochmean_adv_fit_timemean_adv_accuracymean_predict_timemean_train_time
000175a623388caceb6fa35784ab33620attackdeckard.base.experiment.Experiment00175a623388caceb6fa35784ab3362000175a623388caceb6fa35784ab3362000175a623388caceb6fa35784ab3362000175a623388caceb6fa35784ab3362000175a623388caceb6fa35784ab3362000175a623388caceb6fa35784ab336204.726294...model_layers18max_iterNaN0.67926931.625000104.0979430.1069233.09709194.782790
100345bccad4a3b4c9580a84c905273a9attackdeckard.base.experiment.Experiment00345bccad4a3b4c9580a84c905273a900345bccad4a3b4c9580a84c905273a900345bccad4a3b4c9580a84c905273a900345bccad4a3b4c9580a84c905273a900345bccad4a3b4c9580a84c905273a900345bccad4a3b4c9580a84c905273a96.605143...model_layers34max_iterNaN0.47865640.864583317.7070780.0987505.919636264.578600
200364b815dfeb4eec8959ff206821ec6attackdeckard.base.experiment.Experiment00364b815dfeb4eec8959ff206821ec600364b815dfeb4eec8959ff206821ec600364b815dfeb4eec8959ff206821ec600364b815dfeb4eec8959ff206821ec600364b815dfeb4eec8959ff206821ec600364b815dfeb4eec8959ff206821ec66.140715...model_layers34epsNaN0.63991437.4062500.1324870.0997504.967563304.453833
300afb3206b473526516167a7c6023c30attackdeckard.base.experiment.Experiment00afb3206b473526516167a7c6023c3000afb3206b473526516167a7c6023c3000afb3206b473526516167a7c6023c3000afb3206b473526516167a7c6023c3000afb3206b473526516167a7c6023c3000afb3206b473526516167a7c6023c301.534690...model_layers18epsNaN0.62521637.15207415.9554650.0990362.202140113.288236
40105b26b34f312bfc99989600bf15cbbattackdeckard.base.experiment.Experiment0105b26b34f312bfc99989600bf15cbb0105b26b34f312bfc99989600bf15cbb0105b26b34f312bfc99989600bf15cbb0105b26b34f312bfc99989600bf15cbb0105b26b34f312bfc99989600bf15cbb0105b26b34f312bfc99989600bf15cbb3.562745...model_layers34max_iterNaN0.64936240.864583245.0418090.1070374.813240245.121432
..................................................................
2166ff15b7d3369b63c99a52e96aed22e6f9attackdeckard.base.experiment.Experimentff15b7d3369b63c99a52e96aed22e6f9ff15b7d3369b63c99a52e96aed22e6f9ff15b7d3369b63c99a52e96aed22e6f9ff15b7d3369b63c99a52e96aed22e6f9ff15b7d3369b63c99a52e96aed22e6f9ff15b7d3369b63c99a52e96aed22e6f92.928936...model_layers34thNaN0.63234737.781250318.6470720.0948786.364891256.425714
2167ff1cbae69eb7f49a5629b48d942dfca1attackdeckard.base.experiment.Experimentff1cbae69eb7f49a5629b48d942dfca1ff1cbae69eb7f49a5629b48d942dfca1ff1cbae69eb7f49a5629b48d942dfca1ff1cbae69eb7f49a5629b48d942dfca1ff1cbae69eb7f49a5629b48d942dfca1ff1cbae69eb7f49a5629b48d942dfca12.278838...model_layers18epsNaN0.65403437.15207418.7023220.1095032.038393114.272417
2168ff24625e3c442e965b5e8be4631fe7b7attackdeckard.base.experiment.Experimentff24625e3c442e965b5e8be4631fe7b7ff24625e3c442e965b5e8be4631fe7b7ff24625e3c442e965b5e8be4631fe7b7ff24625e3c442e965b5e8be4631fe7b7ff24625e3c442e965b5e8be4631fe7b7ff24625e3c442e965b5e8be4631fe7b75.990600...model_layers34epsNaN0.57766337.4062500.1461080.1009374.530041284.475388
2169ff3df4c627576b21e736467bb164bb5battackdeckard.base.experiment.Experimentff3df4c627576b21e736467bb164bb5bff3df4c627576b21e736467bb164bb5bff3df4c627576b21e736467bb164bb5bff3df4c627576b21e736467bb164bb5bff3df4c627576b21e736467bb164bb5bff3df4c627576b21e736467bb164bb5b5.604070...model_layers34epsNaN0.53913437.4062500.1062050.1137505.053017301.237607
2170ffa0197ac2d21ef824d03ff81c6cebb2attackdeckard.base.experiment.Experimentffa0197ac2d21ef824d03ff81c6cebb2ffa0197ac2d21ef824d03ff81c6cebb2ffa0197ac2d21ef824d03ff81c6cebb2ffa0197ac2d21ef824d03ff81c6cebb2ffa0197ac2d21ef824d03ff81c6cebb2ffa0197ac2d21ef824d03ff81c6cebb212.892382...model_layers18epsNaN0.62521637.15207415.9554650.0990362.202140113.288236
\n", + "

2171 rows × 202 columns

\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 stage \\\n", + "0 00175a623388caceb6fa35784ab33620 attack \n", + "1 00345bccad4a3b4c9580a84c905273a9 attack \n", + "2 00364b815dfeb4eec8959ff206821ec6 attack \n", + "3 00afb3206b473526516167a7c6023c30 attack \n", + "4 0105b26b34f312bfc99989600bf15cbb attack \n", + "... ... ... \n", + "2166 ff15b7d3369b63c99a52e96aed22e6f9 attack \n", + "2167 ff1cbae69eb7f49a5629b48d942dfca1 attack \n", + "2168 ff24625e3c442e965b5e8be4631fe7b7 attack \n", + "2169 ff3df4c627576b21e736467bb164bb5b attack \n", + "2170 ffa0197ac2d21ef824d03ff81c6cebb2 attack \n", + "\n", + " _target_ attack \\\n", + "0 deckard.base.experiment.Experiment 00175a623388caceb6fa35784ab33620 \n", + "1 deckard.base.experiment.Experiment 00345bccad4a3b4c9580a84c905273a9 \n", + "2 deckard.base.experiment.Experiment 00364b815dfeb4eec8959ff206821ec6 \n", + "3 deckard.base.experiment.Experiment 00afb3206b473526516167a7c6023c30 \n", + "4 deckard.base.experiment.Experiment 0105b26b34f312bfc99989600bf15cbb \n", + "... ... ... \n", + "2166 deckard.base.experiment.Experiment ff15b7d3369b63c99a52e96aed22e6f9 \n", + "2167 deckard.base.experiment.Experiment ff1cbae69eb7f49a5629b48d942dfca1 \n", + "2168 deckard.base.experiment.Experiment ff24625e3c442e965b5e8be4631fe7b7 \n", + "2169 deckard.base.experiment.Experiment ff3df4c627576b21e736467bb164bb5b \n", + "2170 deckard.base.experiment.Experiment ffa0197ac2d21ef824d03ff81c6cebb2 \n", + "\n", + " data files \\\n", + "0 00175a623388caceb6fa35784ab33620 00175a623388caceb6fa35784ab33620 \n", + "1 00345bccad4a3b4c9580a84c905273a9 00345bccad4a3b4c9580a84c905273a9 \n", + "2 00364b815dfeb4eec8959ff206821ec6 00364b815dfeb4eec8959ff206821ec6 \n", + "3 00afb3206b473526516167a7c6023c30 00afb3206b473526516167a7c6023c30 \n", + "4 0105b26b34f312bfc99989600bf15cbb 0105b26b34f312bfc99989600bf15cbb \n", + "... ... ... \n", + "2166 ff15b7d3369b63c99a52e96aed22e6f9 ff15b7d3369b63c99a52e96aed22e6f9 \n", + "2167 ff1cbae69eb7f49a5629b48d942dfca1 ff1cbae69eb7f49a5629b48d942dfca1 \n", + "2168 ff24625e3c442e965b5e8be4631fe7b7 ff24625e3c442e965b5e8be4631fe7b7 \n", + "2169 ff3df4c627576b21e736467bb164bb5b ff3df4c627576b21e736467bb164bb5b \n", + "2170 ffa0197ac2d21ef824d03ff81c6cebb2 ffa0197ac2d21ef824d03ff81c6cebb2 \n", + "\n", + " model name \\\n", + "0 00175a623388caceb6fa35784ab33620 00175a623388caceb6fa35784ab33620 \n", + "1 00345bccad4a3b4c9580a84c905273a9 00345bccad4a3b4c9580a84c905273a9 \n", + "2 00364b815dfeb4eec8959ff206821ec6 00364b815dfeb4eec8959ff206821ec6 \n", + "3 00afb3206b473526516167a7c6023c30 00afb3206b473526516167a7c6023c30 \n", + "4 0105b26b34f312bfc99989600bf15cbb 0105b26b34f312bfc99989600bf15cbb \n", + "... ... ... \n", + "2166 ff15b7d3369b63c99a52e96aed22e6f9 ff15b7d3369b63c99a52e96aed22e6f9 \n", + "2167 ff1cbae69eb7f49a5629b48d942dfca1 ff1cbae69eb7f49a5629b48d942dfca1 \n", + "2168 ff24625e3c442e965b5e8be4631fe7b7 ff24625e3c442e965b5e8be4631fe7b7 \n", + "2169 ff3df4c627576b21e736467bb164bb5b ff3df4c627576b21e736467bb164bb5b \n", + "2170 ffa0197ac2d21ef824d03ff81c6cebb2 ffa0197ac2d21ef824d03ff81c6cebb2 \n", + "\n", + " scorers predict_time ... def_param \\\n", + "0 00175a623388caceb6fa35784ab33620 4.726294 ... model_layers \n", + "1 00345bccad4a3b4c9580a84c905273a9 6.605143 ... model_layers \n", + "2 00364b815dfeb4eec8959ff206821ec6 6.140715 ... model_layers \n", + "3 00afb3206b473526516167a7c6023c30 1.534690 ... model_layers \n", + "4 0105b26b34f312bfc99989600bf15cbb 3.562745 ... model_layers \n", + "... ... ... ... ... \n", + "2166 ff15b7d3369b63c99a52e96aed22e6f9 2.928936 ... model_layers \n", + "2167 ff1cbae69eb7f49a5629b48d942dfca1 2.278838 ... model_layers \n", + "2168 ff24625e3c442e965b5e8be4631fe7b7 5.990600 ... model_layers \n", + "2169 ff3df4c627576b21e736467bb164bb5b 5.604070 ... model_layers \n", + "2170 ffa0197ac2d21ef824d03ff81c6cebb2 12.892382 ... model_layers \n", + "\n", + " def_value atk_param atk_value mean_accuracy \\\n", + "0 18 max_iter NaN 0.679269 \n", + "1 34 max_iter NaN 0.478656 \n", + "2 34 eps NaN 0.639914 \n", + "3 18 eps NaN 0.625216 \n", + "4 34 max_iter NaN 0.649362 \n", + "... ... ... ... ... \n", + "2166 34 th NaN 0.632347 \n", + "2167 18 eps NaN 0.654034 \n", + "2168 34 eps NaN 0.577663 \n", + "2169 34 eps NaN 0.539134 \n", + "2170 18 eps NaN 0.625216 \n", + "\n", + " mean_model.trainer.nb_epoch mean_adv_fit_time mean_adv_accuracy \\\n", + "0 31.625000 104.097943 0.106923 \n", + "1 40.864583 317.707078 0.098750 \n", + "2 37.406250 0.132487 0.099750 \n", + "3 37.152074 15.955465 0.099036 \n", + "4 40.864583 245.041809 0.107037 \n", + "... ... ... ... \n", + "2166 37.781250 318.647072 0.094878 \n", + "2167 37.152074 18.702322 0.109503 \n", + "2168 37.406250 0.146108 0.100937 \n", + "2169 37.406250 0.106205 0.113750 \n", + "2170 37.152074 15.955465 0.099036 \n", + "\n", + " mean_predict_time mean_train_time \n", + "0 3.097091 94.782790 \n", + "1 5.919636 264.578600 \n", + "2 4.967563 304.453833 \n", + "3 2.202140 113.288236 \n", + "4 4.813240 245.121432 \n", + "... ... ... \n", + "2166 6.364891 256.425714 \n", + "2167 2.038393 114.272417 \n", + "2168 4.530041 284.475388 \n", + "2169 5.053017 301.237607 \n", + "2170 2.202140 113.288236 \n", + "\n", + "[2171 rows x 202 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sense_dict = {\n", + " \"model_layers\": \"diff\",\n", + " \"accuracy\": \"max\",\n", + " \"data.sample.random_state\": \"diff\",\n", + " \"model.trainer.nb_epoch\": \"diff\",\n", + " \"model_layers\": \"diff\",\n", + " \"atk_gen\": \"diff\",\n", + " \"def_gen\": \"diff\",\n", + " \"adv_fit_time\": \"min\",\n", + " \"adv_accuracy\": \"min\",\n", + " \"predict_time\": \"min\",\n", + " \"train_time\": \"min\",\n", + " \"attack.attack_size\": \"diff\",\n", + "}\n", + "\n", + "# Average across random states\n", + "scorer = \"accuracy\"\n", + "\n", + "\n", + "def average_across_random_states(df, scorer, sense_dict):\n", + " sense_dict.pop(\"data.sample.random_state\", None)\n", + " group_list = [k for k, v in sense_dict.items() if v == \"diff\"]\n", + " group_list_wo_random_state = group_list.copy()\n", + " print(f\"Grouping by {group_list_wo_random_state} for {scorer}\")\n", + " df[f\"mean_{scorer}\"] = df.groupby(group_list_wo_random_state)[scorer].transform(\n", + " \"mean\"\n", + " )\n", + " return df\n", + "\n", + "\n", + "def drop_poorly_merged_columns(df):\n", + " cols = df.columns\n", + " for col in cols:\n", + " if col.endswith(\".1\") and col[:-2] in cols:\n", + " df = df.drop(col, axis=1)\n", + " return df\n", + "\n", + "\n", + "def find_pareto_set_for_graph(df, sense_dict):\n", + " scorers = [k for k, v in sense_dict.items() if v in [\"max\", \"min\"]]\n", + " group_list = [k for k, v in sense_dict.items() if v == \"diff\"]\n", + " group_list_wo_attack = group_list.copy()\n", + " for group in group_list:\n", + " if group in [\"atk_gen\", \"atk_value\", \"atk_param\"]:\n", + " group_list_wo_attack.remove(group)\n", + " elif group.startswith(\"attack_\") or group.startswith(\"attack_\"):\n", + " group_list_wo_attack.remove(group)\n", + " elif group.startswith(\"adv.\") or group.startswith(\"adv_\"):\n", + " group_list_wo_attack.remove(group)\n", + " else:\n", + " continue\n", + " for scorer in scorers:\n", + " scores = df[scorer].fillna(\n", + " df.groupby(group_list_wo_attack)[scorer].transform(\"mean\")\n", + " )\n", + " df[scorer] = scores.fillna(scores.mean())\n", + " df = average_across_random_states(df, scorer, sense_dict)\n", + " value = sense_dict.get(scorer)\n", + " sense_dict.update({f\"mean_{scorer}\": value})\n", + " del sense_dict[scorer]\n", + " # sub_df = df[[*sense_dict.keys()]]\n", + " # bools = paretoset(sub_df, list(sense_dict.values()))\n", + " # df = df[bools]\n", + " return df\n", + "\n", + "\n", + "df = find_pareto_set_for_graph(df, sense_dict)\n", + "\n", + "\n", + "def drop_col_if_no_variance(df):\n", + " drop_these = []\n", + " for col in df.columns:\n", + " if df[col].nunique() == 1:\n", + " drop_these.append(col)\n", + " tmp = df.drop(drop_these, axis=1)\n", + " return tmp\n", + "\n", + "\n", + "df = drop_poorly_merged_columns(df)\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(data=df, y=\"adv_log_loss\", x=\"model.trainer.nb_epoch\", hue=\"model_layers\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting cox model\n" + ] + }, + { + "ename": "KeyError", + "evalue": "\"['atk_gen', 'def_gen'] not found in axis\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/cmeyers/deckard/examples/pytorch/average_across_random_states.ipynb Cell 6\u001b[0m line \u001b[0;36m5\n\u001b[1;32m 53\u001b[0m \u001b[39mfor\u001b[39;00m model_name \u001b[39min\u001b[39;00m model_dict:\n\u001b[1;32m 54\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mFitting \u001b[39m\u001b[39m{\u001b[39;00mmodel_name\u001b[39m}\u001b[39;00m\u001b[39m model\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 55\u001b[0m model, plot, score \u001b[39m=\u001b[39m fit_aft_model(aft_df, new_sense_dict, model_name)\n\u001b[1;32m 56\u001b[0m models\u001b[39m.\u001b[39mupdate({model_name : model})\n\u001b[1;32m 57\u001b[0m scores\u001b[39m.\u001b[39mupdate({model_name : score})\n", + "\u001b[1;32m/home/cmeyers/deckard/examples/pytorch/average_across_random_states.ipynb Cell 6\u001b[0m line \u001b[0;36m1\n\u001b[1;32m 17\u001b[0m stratify \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39matk_gen\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mdef_gen\u001b[39m\u001b[39m'\u001b[39m,]\n\u001b[1;32m 18\u001b[0m subset_df \u001b[39m=\u001b[39m df\u001b[39m.\u001b[39mcopy()\n\u001b[0;32m---> 19\u001b[0m subset_df \u001b[39m=\u001b[39m subset_df\u001b[39m.\u001b[39;49mdrop(stratify, axis\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m)\n\u001b[1;32m 20\u001b[0m model \u001b[39m=\u001b[39m model_dict[model_name]()\n\u001b[1;32m 21\u001b[0m model\u001b[39m.\u001b[39mfit(df, duration_col \u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmean_adv_fit_time\u001b[39m\u001b[39m'\u001b[39m, event_col\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madv_failures\u001b[39m\u001b[39m'\u001b[39m)\n", + "File \u001b[0;32m~/deckard/env/lib/python3.8/site-packages/pandas/core/frame.py:5258\u001b[0m, in \u001b[0;36mDataFrame.drop\u001b[0;34m(self, labels, axis, index, columns, level, inplace, errors)\u001b[0m\n\u001b[1;32m 5110\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdrop\u001b[39m(\n\u001b[1;32m 5111\u001b[0m \u001b[39mself\u001b[39m,\n\u001b[1;32m 5112\u001b[0m labels: IndexLabel \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 5119\u001b[0m errors: IgnoreRaise \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mraise\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 5120\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m DataFrame \u001b[39m|\u001b[39m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 5121\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 5122\u001b[0m \u001b[39m Drop specified labels from rows or columns.\u001b[39;00m\n\u001b[1;32m 5123\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 5256\u001b[0m \u001b[39m weight 1.0 0.8\u001b[39;00m\n\u001b[1;32m 5257\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 5258\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49mdrop(\n\u001b[1;32m 5259\u001b[0m labels\u001b[39m=\u001b[39;49mlabels,\n\u001b[1;32m 5260\u001b[0m axis\u001b[39m=\u001b[39;49maxis,\n\u001b[1;32m 5261\u001b[0m index\u001b[39m=\u001b[39;49mindex,\n\u001b[1;32m 5262\u001b[0m columns\u001b[39m=\u001b[39;49mcolumns,\n\u001b[1;32m 5263\u001b[0m level\u001b[39m=\u001b[39;49mlevel,\n\u001b[1;32m 5264\u001b[0m inplace\u001b[39m=\u001b[39;49minplace,\n\u001b[1;32m 5265\u001b[0m errors\u001b[39m=\u001b[39;49merrors,\n\u001b[1;32m 5266\u001b[0m )\n", + "File \u001b[0;32m~/deckard/env/lib/python3.8/site-packages/pandas/core/generic.py:4549\u001b[0m, in \u001b[0;36mNDFrame.drop\u001b[0;34m(self, labels, axis, index, columns, level, inplace, errors)\u001b[0m\n\u001b[1;32m 4547\u001b[0m \u001b[39mfor\u001b[39;00m axis, labels \u001b[39min\u001b[39;00m axes\u001b[39m.\u001b[39mitems():\n\u001b[1;32m 4548\u001b[0m \u001b[39mif\u001b[39;00m labels \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 4549\u001b[0m obj \u001b[39m=\u001b[39m obj\u001b[39m.\u001b[39;49m_drop_axis(labels, axis, level\u001b[39m=\u001b[39;49mlevel, errors\u001b[39m=\u001b[39;49merrors)\n\u001b[1;32m 4551\u001b[0m \u001b[39mif\u001b[39;00m inplace:\n\u001b[1;32m 4552\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_update_inplace(obj)\n", + "File \u001b[0;32m~/deckard/env/lib/python3.8/site-packages/pandas/core/generic.py:4591\u001b[0m, in \u001b[0;36mNDFrame._drop_axis\u001b[0;34m(self, labels, axis, level, errors, only_slice)\u001b[0m\n\u001b[1;32m 4589\u001b[0m new_axis \u001b[39m=\u001b[39m axis\u001b[39m.\u001b[39mdrop(labels, level\u001b[39m=\u001b[39mlevel, errors\u001b[39m=\u001b[39merrors)\n\u001b[1;32m 4590\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 4591\u001b[0m new_axis \u001b[39m=\u001b[39m axis\u001b[39m.\u001b[39;49mdrop(labels, errors\u001b[39m=\u001b[39;49merrors)\n\u001b[1;32m 4592\u001b[0m indexer \u001b[39m=\u001b[39m axis\u001b[39m.\u001b[39mget_indexer(new_axis)\n\u001b[1;32m 4594\u001b[0m \u001b[39m# Case for non-unique axis\u001b[39;00m\n\u001b[1;32m 4595\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/deckard/env/lib/python3.8/site-packages/pandas/core/indexes/base.py:6696\u001b[0m, in \u001b[0;36mIndex.drop\u001b[0;34m(self, labels, errors)\u001b[0m\n\u001b[1;32m 6694\u001b[0m \u001b[39mif\u001b[39;00m mask\u001b[39m.\u001b[39many():\n\u001b[1;32m 6695\u001b[0m \u001b[39mif\u001b[39;00m errors \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mignore\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m-> 6696\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mlist\u001b[39m(labels[mask])\u001b[39m}\u001b[39;00m\u001b[39m not found in axis\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 6697\u001b[0m indexer \u001b[39m=\u001b[39m indexer[\u001b[39m~\u001b[39mmask]\n\u001b[1;32m 6698\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdelete(indexer)\n", + "\u001b[0;31mKeyError\u001b[0m: \"['atk_gen', 'def_gen'] not found in axis\"" + ] + } + ], + "source": [ + "from lifelines import (\n", + " CoxPHFitter,\n", + " KaplanMeierFitter,\n", + " NelsonAalenFitter,\n", + " AalenAdditiveFitter,\n", + " WeibullAFTFitter,\n", + " LogNormalAFTFitter,\n", + " LogLogisticAFTFitter,\n", + " PiecewiseExponentialRegressionFitter,\n", + ")\n", + "\n", + "\n", + "model_dict = {\n", + " \"cox\": CoxPHFitter,\n", + " # \"kaplan_meier\" : KaplanMeierFitter,\n", + " # \"nelson_aalen\" : NelsonAalenFitter,\n", + " # \"aalen_additive\" : AalenAdditiveFitter,\n", + " \"weibull\": WeibullAFTFitter,\n", + " \"log_normal\": LogNormalAFTFitter,\n", + " \"log_logistic\": LogLogisticAFTFitter,\n", + " # \"piecewise_exponential\" : PiecewiseExponentialRegressionFitter,\n", + "}\n", + "\n", + "\n", + "def fit_aft_model(df, sense_dict, model_name):\n", + " stratify = [\n", + " \"atk_gen\",\n", + " \"def_gen\",\n", + " ]\n", + " subset_df = df.copy()\n", + " subset_df = subset_df.drop(stratify, axis=1)\n", + " model = model_dict[model_name]()\n", + " model.fit(df, duration_col=\"mean_adv_fit_time\", event_col=\"adv_failures\")\n", + " model.print_summary()\n", + " plot = model.plot()\n", + " concordance = model.score(df, scoring_method=\"concordance_index\")\n", + " print(f\"Concordance index: {concordance}\")\n", + " measured_median = np.median(\n", + " df.mean_adv_fit_time / df[\"attack.attack_size\"] * ((1 - df.adv_failures) / 100)\n", + " )\n", + " print(\"Measured median attack time:\", measured_median)\n", + " modelled_median = np.median(model.predict_median(df, ancillary=df))\n", + " print(\"Predicted median attack time:\", modelled_median)\n", + " score = model.score(df, scoring_method=\"log_likelihood\")\n", + " score_dict = {\n", + " \"model\": model_name,\n", + " \"concordance\": concordance,\n", + " \"measured_median\": measured_median,\n", + " \"modelled_median\": modelled_median,\n", + " \"log_likelihood\": score,\n", + " }\n", + " return model, plot, score\n", + "\n", + "\n", + "models = {}\n", + "scores = {}\n", + "plots = {}\n", + "stratify = [\"atk_gen\", \"def_gen\"]\n", + "subset_cols = [k for k in sense_dict if k not in stratify]\n", + "aft_df = df[subset_cols].copy()\n", + "aft_df[\"adv_failures\"] = (1 - df[\"mean_adv_accuracy\"]) * df[\"attack.attack_size\"]\n", + "del aft_df[\"mean_adv_accuracy\"]\n", + "new_sense_dict = sense_dict.copy()\n", + "new_sense_dict.update({\"adv_failures\": sense_dict[\"mean_adv_accuracy\"]})\n", + "new_sense_dict.pop(\"mean_adv_accuracy\", None)\n", + "new_sense_dict\n", + "\n", + "for model_name in model_dict:\n", + " print(f\"Fitting {model_name} model\")\n", + " model, plot, score = fit_aft_model(aft_df, new_sense_dict, model_name)\n", + " models.update({model_name: model})\n", + " scores.update({model_name: score})\n", + " plots.update({model_name: plot})\n", + " plt.xscale(\"linear\")\n", + " plt.show()\n", + " plt.gcf().clear()\n", + "\n", + "# scores = pd.DataFrame.from_dict(scores, orient='index', columns=['score'])\n", + "\n", + "# covariates = [k for k,v in sense_dict.items() if v == 'diff']\n", + "# values = [np.array(df[k].unique()) for k in covariates]\n", + "# print(f\"Number of covariates: {len(covariates)}\")\n", + "# print(f\"Number of values: {len(values)}\")\n", + "# print(f\"Values: \\n{[value.tolist() for value in values]}\")\n", + "# for i in range(len(covariates)):\n", + "# if covariates[i] in stratify:\n", + "# continue\n", + "# else:\n", + "# print(f\"Plotting {covariates[i]} with values {values[i]}\")\n", + "# graph = model.plot_partial_effects_on_outcome(covariates = covariates[i], values =values[i], cmap='coolwarm', figsize=(10, 10))\n", + "# print(type(graph))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = models[\"weibull\"]\n", + "expectations = model.predict_expectation(df, ancillary=df)\n", + "survival_function = model.predict_survival_function(df, ancillary=df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scores.T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/pytorch_cifar_100/conf/attack/default.yaml b/examples/pytorch/mnist/conf/attack/default.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/attack/default.yaml rename to examples/pytorch/mnist/conf/attack/default.yaml diff --git a/examples/pytorch_cifar_100/conf/compile.yaml b/examples/pytorch/mnist/conf/compile.yaml similarity index 92% rename from examples/pytorch_cifar_100/conf/compile.yaml rename to examples/pytorch/mnist/conf/compile.yaml index 43418520..1314aceb 100644 --- a/examples/pytorch_cifar_100/conf/compile.yaml +++ b/examples/pytorch/mnist/conf/compile.yaml @@ -14,6 +14,7 @@ defences: GaussianAugmentation: Gauss-in GaussianNoise: Gauss-out HighConfidence: Conf + Epochs: Epochs params: # art.attacks.evasion.CarliniL0Method: attack.init.confidence # art.attacks.evasion.CarliniL2Method: attack.init.confidence @@ -28,5 +29,5 @@ params: Conf: model.art.pipeline.postprocessor.cutoff FSQ: model.art.pipeline.preprocessor.bit_depth Gauss-in: model.art.pipeline.preprocessor.sigma - Depth: model_layers - Epochs: model.train.nb_epoch + Control: model_layers + Epochs: model.trainer.nb_epoch diff --git a/examples/pytorch/mnist/conf/data/default.yaml b/examples/pytorch/mnist/conf/data/default.yaml new file mode 100644 index 00000000..5eb78278 --- /dev/null +++ b/examples/pytorch/mnist/conf/data/default.yaml @@ -0,0 +1,2 @@ +defaults: + - torch_mnist diff --git a/examples/pytorch_cifar/conf/data/torch_cifar.yaml b/examples/pytorch/mnist/conf/data/torch_cifar.yaml similarity index 100% rename from examples/pytorch_cifar/conf/data/torch_cifar.yaml rename to examples/pytorch/mnist/conf/data/torch_cifar.yaml diff --git a/examples/pytorch_cifar/conf/data/torch_mnist.yaml b/examples/pytorch/mnist/conf/data/torch_mnist.yaml similarity index 100% rename from examples/pytorch_cifar/conf/data/torch_mnist.yaml rename to examples/pytorch/mnist/conf/data/torch_mnist.yaml diff --git a/examples/pytorch_cifar_100/conf/deploy/pod.yaml b/examples/pytorch/mnist/conf/deploy/pod.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/deploy/pod.yaml rename to examples/pytorch/mnist/conf/deploy/pod.yaml diff --git a/examples/pytorch_cifar_100/conf/deploy/pvc.yaml b/examples/pytorch/mnist/conf/deploy/pvc.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/deploy/pvc.yaml rename to examples/pytorch/mnist/conf/deploy/pvc.yaml diff --git a/examples/pytorch_cifar_100/conf/deploy/sclass.yaml b/examples/pytorch/mnist/conf/deploy/sclass.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/deploy/sclass.yaml rename to examples/pytorch/mnist/conf/deploy/sclass.yaml diff --git a/examples/pytorch_cifar/conf/files/cifar.yaml b/examples/pytorch/mnist/conf/files/cifar.yaml similarity index 100% rename from examples/pytorch_cifar/conf/files/cifar.yaml rename to examples/pytorch/mnist/conf/files/cifar.yaml diff --git a/examples/pytorch_cifar_100/conf/files/mnist.yaml b/examples/pytorch/mnist/conf/files/mnist.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/files/mnist.yaml rename to examples/pytorch/mnist/conf/files/mnist.yaml diff --git a/examples/pytorch/conf/grid/attack/cw_0.yaml b/examples/pytorch/mnist/conf/grid/attack/cw_0.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/cw_0.yaml rename to examples/pytorch/mnist/conf/grid/attack/cw_0.yaml diff --git a/examples/pytorch/conf/grid/attack/cw_2.yaml b/examples/pytorch/mnist/conf/grid/attack/cw_2.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/cw_2.yaml rename to examples/pytorch/mnist/conf/grid/attack/cw_2.yaml diff --git a/examples/pytorch/conf/grid/attack/cw_inf.yaml b/examples/pytorch/mnist/conf/grid/attack/cw_inf.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/cw_inf.yaml rename to examples/pytorch/mnist/conf/grid/attack/cw_inf.yaml diff --git a/examples/pytorch/conf/grid/attack/deepfool.yaml b/examples/pytorch/mnist/conf/grid/attack/deepfool.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/deepfool.yaml rename to examples/pytorch/mnist/conf/grid/attack/deepfool.yaml diff --git a/examples/pytorch/conf/grid/attack/fgm.yaml b/examples/pytorch/mnist/conf/grid/attack/fgm.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/fgm.yaml rename to examples/pytorch/mnist/conf/grid/attack/fgm.yaml diff --git a/examples/pytorch/conf/grid/attack/hsj.yaml b/examples/pytorch/mnist/conf/grid/attack/hsj.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/hsj.yaml rename to examples/pytorch/mnist/conf/grid/attack/hsj.yaml diff --git a/examples/pytorch/conf/grid/attack/patch.yaml b/examples/pytorch/mnist/conf/grid/attack/patch.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/patch.yaml rename to examples/pytorch/mnist/conf/grid/attack/patch.yaml diff --git a/examples/pytorch/conf/grid/attack/pgd.yaml b/examples/pytorch/mnist/conf/grid/attack/pgd.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/pgd.yaml rename to examples/pytorch/mnist/conf/grid/attack/pgd.yaml diff --git a/examples/pytorch/conf/grid/attack/pixel.yaml b/examples/pytorch/mnist/conf/grid/attack/pixel.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/pixel.yaml rename to examples/pytorch/mnist/conf/grid/attack/pixel.yaml diff --git a/examples/pytorch/conf/grid/attack/threshold.yaml b/examples/pytorch/mnist/conf/grid/attack/threshold.yaml similarity index 100% rename from examples/pytorch/conf/grid/attack/threshold.yaml rename to examples/pytorch/mnist/conf/grid/attack/threshold.yaml diff --git a/examples/pytorch/conf/grid/model/confidence.yaml b/examples/pytorch/mnist/conf/grid/model/confidence.yaml similarity index 100% rename from examples/pytorch/conf/grid/model/confidence.yaml rename to examples/pytorch/mnist/conf/grid/model/confidence.yaml diff --git a/examples/pytorch_cifar/conf/model/art/preprocessor/default.yaml b/examples/pytorch/mnist/conf/grid/model/default.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/art/preprocessor/default.yaml rename to examples/pytorch/mnist/conf/grid/model/default.yaml diff --git a/examples/pytorch/conf/grid/model/fsq.yaml b/examples/pytorch/mnist/conf/grid/model/fsq.yaml similarity index 100% rename from examples/pytorch/conf/grid/model/fsq.yaml rename to examples/pytorch/mnist/conf/grid/model/fsq.yaml diff --git a/examples/pytorch/conf/grid/model/gauss-in.yaml b/examples/pytorch/mnist/conf/grid/model/gauss-in.yaml similarity index 100% rename from examples/pytorch/conf/grid/model/gauss-in.yaml rename to examples/pytorch/mnist/conf/grid/model/gauss-in.yaml diff --git a/examples/pytorch/conf/grid/model/gauss-out.yaml b/examples/pytorch/mnist/conf/grid/model/gauss-out.yaml similarity index 100% rename from examples/pytorch/conf/grid/model/gauss-out.yaml rename to examples/pytorch/mnist/conf/grid/model/gauss-out.yaml diff --git a/examples/pytorch/conf/mnist.yaml b/examples/pytorch/mnist/conf/mnist.yaml similarity index 100% rename from examples/pytorch/conf/mnist.yaml rename to examples/pytorch/mnist/conf/mnist.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/default.yaml b/examples/pytorch/mnist/conf/model/art/default.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/default.yaml rename to examples/pytorch/mnist/conf/model/art/default.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/initialize/default.yaml b/examples/pytorch/mnist/conf/model/art/initialize/default.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/initialize/default.yaml rename to examples/pytorch/mnist/conf/model/art/initialize/default.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/postprocessor/confidence.yaml b/examples/pytorch/mnist/conf/model/art/postprocessor/confidence.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/postprocessor/confidence.yaml rename to examples/pytorch/mnist/conf/model/art/postprocessor/confidence.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/postprocessor/gauss-out.yaml b/examples/pytorch/mnist/conf/model/art/postprocessor/gauss-out.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/postprocessor/gauss-out.yaml rename to examples/pytorch/mnist/conf/model/art/postprocessor/gauss-out.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/preprocessor/default.yaml b/examples/pytorch/mnist/conf/model/art/preprocessor/default.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/preprocessor/default.yaml rename to examples/pytorch/mnist/conf/model/art/preprocessor/default.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/preprocessor/fsq.yaml b/examples/pytorch/mnist/conf/model/art/preprocessor/fsq.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/preprocessor/fsq.yaml rename to examples/pytorch/mnist/conf/model/art/preprocessor/fsq.yaml diff --git a/examples/pytorch_cifar_100/conf/model/art/preprocessor/gauss-in.yaml b/examples/pytorch/mnist/conf/model/art/preprocessor/gauss-in.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/art/preprocessor/gauss-in.yaml rename to examples/pytorch/mnist/conf/model/art/preprocessor/gauss-in.yaml diff --git a/examples/pytorch_cifar/conf/model/torch_cifar.yaml b/examples/pytorch/mnist/conf/model/torch_cifar.yaml similarity index 100% rename from examples/pytorch_cifar/conf/model/torch_cifar.yaml rename to examples/pytorch/mnist/conf/model/torch_cifar.yaml diff --git a/examples/pytorch_cifar_100/conf/model/torch_mnist.yaml b/examples/pytorch/mnist/conf/model/torch_mnist.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/model/torch_mnist.yaml rename to examples/pytorch/mnist/conf/model/torch_mnist.yaml diff --git a/examples/pytorch_cifar_100/conf/plots.yaml b/examples/pytorch/mnist/conf/plots.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/plots.yaml rename to examples/pytorch/mnist/conf/plots.yaml diff --git a/examples/pytorch_cifar_100/conf/scorers/default.yaml b/examples/pytorch/mnist/conf/scorers/default.yaml similarity index 100% rename from examples/pytorch_cifar_100/conf/scorers/default.yaml rename to examples/pytorch/mnist/conf/scorers/default.yaml diff --git a/examples/pytorch/mnist/dvc.lock b/examples/pytorch/mnist/dvc.lock new file mode 100644 index 00000000..36e3cd85 --- /dev/null +++ b/examples/pytorch/mnist/dvc.lock @@ -0,0 +1,52 @@ +schema: '2.0' +stages: + compile@attack: + cmd: python -m deckard.layers.compile --report_folder mnist/reports/attack --results_file + mnist/reports/attack.csv + deps: + - path: mnist/reports/attack/ + md5: c1191d4aed87840a6035d44b5edfed67.dir + size: 63191255 + nfiles: 8010 + - path: mnist/reports/attack/ResNet101.db + md5: 600452804d96c8b8483c3f8da01130c4 + size: 462848 + - path: mnist/reports/attack/ResNet18.db + md5: 920b0ed178ec504c0d7990777862283f + size: 1363968 + - path: mnist/reports/attack/ResNet34.db + md5: 3f56dd2ea0783a56a2a9e3eaaad88c21 + size: 1945600 + - path: mnist/reports/attack/ResNet50.db + md5: d9ee221b942b56d9bb720e022e05bf4b + size: 462848 + outs: + - path: mnist/reports/attack.csv + md5: b6d03ebcc65d652ca2392c7510983fa5 + size: 9063722 + plot: + cmd: python -m deckard.layers.plots --path mnist/plots/ --file mnist/reports/attack.csv + -o data.csv + deps: + - path: mnist/reports/attack.csv + md5: b6d03ebcc65d652ca2392c7510983fa5 + size: 9063722 + - path: mnist/reports/attack/ResNet101.db + md5: 600452804d96c8b8483c3f8da01130c4 + size: 462848 + - path: mnist/reports/attack/ResNet152.db + md5: afb6f3d2616446226012b3ff1143086a + size: 462848 + - path: mnist/reports/attack/ResNet18.db + md5: 920b0ed178ec504c0d7990777862283f + size: 1363968 + - path: mnist/reports/attack/ResNet34.db + md5: 3f56dd2ea0783a56a2a9e3eaaad88c21 + size: 1945600 + - path: mnist/reports/attack/ResNet50.db + md5: d9ee221b942b56d9bb720e022e05bf4b + size: 462848 + outs: + - path: mnist/plots/data.csv + md5: 73aac3fbd8615cc932c5537c7a9b74b4 + size: 2353615 diff --git a/examples/pytorch/dvc.yaml b/examples/pytorch/mnist/dvc.yaml similarity index 96% rename from examples/pytorch/dvc.yaml rename to examples/pytorch/mnist/dvc.yaml index 0cbb2c6f..a66b36dc 100644 --- a/examples/pytorch/dvc.yaml +++ b/examples/pytorch/mnist/dvc.yaml @@ -55,10 +55,10 @@ stages: attacks: foreach: # This is a loop over the ResNet models - ResNet18 - #- ResNet34 - #- ResNet50 - #- ResNet101 - #- ResNet152 + - ResNet34 + - ResNet50 + - ResNet101 + - ResNet152 do: cmd: bash attacks.sh ++attack.attack_size=100 ++model.init.name=torch_example.${item} stage=attack ++hydra.sweeper.storage=sqlite:///${files.directory}/${files.reports}/attack/${item}.db --config-name mnist.yaml deps: @@ -97,7 +97,7 @@ stages: outs: - ${files.directory}/plots/data.csv afr: - cmd: python -m deckard.layers.afr --dataset ${files.directory} --file ${files.directory}/plots/data.csv + cmd: python -m deckard.layers.afr --dataset ${files.directory} --data_file ${files.directory}/plots/data.csv --target adv_accuracy --duration_col adv_fit_time --dataset mnist deps: - ${files.directory}/plots/data.csv plots: diff --git a/examples/pytorch_cifar_100/models.sh b/examples/pytorch/mnist/models.sh similarity index 100% rename from examples/pytorch_cifar_100/models.sh rename to examples/pytorch/mnist/models.sh diff --git a/examples/pytorch_cifar_100/torch_example.py b/examples/pytorch/mnist/torch_example.py similarity index 56% rename from examples/pytorch_cifar_100/torch_example.py rename to examples/pytorch/mnist/torch_example.py index 580b7f80..2007d9d0 100644 --- a/examples/pytorch_cifar_100/torch_example.py +++ b/examples/pytorch/mnist/torch_example.py @@ -1,32 +1,17 @@ +import torch.nn as nn from torchvision import models -import torch __all__ = [ "ResNet18", - "ResNet34", "ResNet50", "ResNet101", "ResNet152", - "LogisticRegression", ] -class LogisticRegression(torch.nn.Module): - def __init__(self, input_dim, output_dim, dtype="torch.FloatTensor"): - self.dtype = dtype - self.device = "cuda" if torch.cuda.is_available() else "cpu" - super().__init__() - self.linear = torch.nn.Linear(input_dim, output_dim) - - def forward(self, x): - x = x.type(torch.FloatTensor) - outputs = torch.sigmoid(self.linear(x)) - return outputs - - def ResNet18(num_channels=1, num_classes=10): model = models.resnet18() - model.conv1 = torch.nn.Conv2d( + model.conv1 = nn.Conv2d( num_channels, 64, kernel_size=7, @@ -34,13 +19,13 @@ def ResNet18(num_channels=1, num_classes=10): padding=3, bias=False, ) - model.fc = torch.nn.Linear(512, num_classes) + model.fc = nn.Linear(512, num_classes) return model def ResNet34(num_channels=1, num_classes=10): model = models.resnet34() - model.conv1 = torch.nn.Conv2d( + model.conv1 = nn.Conv2d( num_channels, 64, kernel_size=7, @@ -48,13 +33,13 @@ def ResNet34(num_channels=1, num_classes=10): padding=3, bias=False, ) - model.fc = torch.nn.Linear(512, num_classes) + model.fc = nn.Linear(512, num_classes) return model def ResNet50(num_channels=1, num_classes=10): model = models.resnet50() - model.conv1 = torch.nn.Conv2d( + model.conv1 = nn.Conv2d( num_channels, 64, kernel_size=7, @@ -62,13 +47,13 @@ def ResNet50(num_channels=1, num_classes=10): padding=3, bias=False, ) - model.fc = torch.nn.Linear(2048, num_classes) + model.fc = nn.Linear(2048, num_classes) return model def ResNet101(num_channels=1, num_classes=10): model = models.resnet101() - model.conv1 = torch.nn.Conv2d( + model.conv1 = nn.Conv2d( num_channels, 64, kernel_size=7, @@ -76,13 +61,13 @@ def ResNet101(num_channels=1, num_classes=10): padding=3, bias=False, ) - model.fc = torch.nn.Linear(2048, num_classes) + model.fc = nn.Linear(2048, num_classes) return model def ResNet152(num_channels=1, num_classes=10): model = models.resnet152() - model.conv1 = torch.nn.Conv2d( + model.conv1 = nn.Conv2d( num_channels, 64, kernel_size=7, @@ -90,5 +75,5 @@ def ResNet152(num_channels=1, num_classes=10): padding=3, bias=False, ) - model.fc = torch.nn.Linear(2048, num_classes) + model.fc = nn.Linear(2048, num_classes) return model diff --git a/examples/pytorch/mnist/weibull.ipynb b/examples/pytorch/mnist/weibull.ipynb new file mode 100644 index 00000000..def6e2d1 --- /dev/null +++ b/examples/pytorch/mnist/weibull.ipynb @@ -0,0 +1,2062 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import seaborn as sns\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "\n", + "from paretoset import paretoset\n", + "from lifelines import (\n", + " WeibullAFTFitter,\n", + " LogNormalAFTFitter,\n", + " LogLogisticAFTFitter,\n", + " CoxPHFitter,\n", + ")\n", + "from plots import calculate_failure_rate, drop_frames_without_results, min_max_scaling\n", + "import matplotlib\n", + "import argparse\n", + "from pathlib import Path\n", + "import logging\n", + "\n", + "logger = logging.getLogger(__name__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "font = {\"family\": \"Times New Roman\", \"weight\": \"bold\", \"size\": 22}\n", + "\n", + "matplotlib.rc(\"font\", **font)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adversarial Accuracy: \n", + " ResNet152: 0.08431102362204726 \n", + " Resnet101: 0.08595785440613028 \n", + " Resnet50: 0.09093333333333335 \n", + " Resnet34: 0.08867549668874172 \n", + " Resnet18: 0.07971698113207548 \n", + "\n" + ] + } + ], + "source": [ + "FOLDER = Path(\"output/plots/\")\n", + "csv_file = FOLDER / \"data.csv\"\n", + "data = pd.read_csv(csv_file, index_col=0)\n", + "data.columns = data.columns.str.strip()\n", + "data = data.applymap(lambda x: x.strip() if isinstance(x, str) else x)\n", + "data.def_value.replace(\"\", 0, inplace=True)\n", + "data.atk_value.replace(\"\", 0, inplace=True)\n", + "data = drop_frames_without_results(data)\n", + "data = calculate_failure_rate(data)\n", + "data = min_max_scaling(data)\n", + "data.dropna(axis=0, subset=[\"atk_value\", \"atk_param\"], inplace=True)\n", + "data.dropna(axis=0, subset=[\"def_value\", \"def_param\"], inplace=True)\n", + "# data=data[data['def_gen'] == 'Gauss-in']\n", + "# data=data[data['atk_gen'] == 'HSJ']\n", + "\n", + "print(\n", + " \"Adversarial Accuracy:\",\n", + " \"\\n\",\n", + " \"ResNet152:\",\n", + " data[data[\"model_layers\"] == 152].adv_accuracy.mean(skipna=True),\n", + " \"\\n\",\n", + " \"Resnet101:\",\n", + " data[data[\"model_layers\"] == 101].adv_accuracy.mean(skipna=True),\n", + " \"\\n\",\n", + " \"Resnet50:\",\n", + " data[data[\"model_layers\"] == 50].adv_accuracy.mean(skipna=True),\n", + " \"\\n\",\n", + " \"Resnet34:\",\n", + " data[data[\"model_layers\"] == 34].adv_accuracy.mean(skipna=True),\n", + " \"\\n\",\n", + " \"Resnet18:\",\n", + " data[data[\"model_layers\"] == 18].adv_accuracy.mean(skipna=True),\n", + " \"\\n\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_aft(\n", + " df,\n", + " file,\n", + " event_col,\n", + " duration_col,\n", + " title,\n", + " mtype,\n", + " xlabel=None,\n", + " ylabel=None,\n", + " replacement_dict={},\n", + " **kwargs,\n", + "):\n", + " if mtype == \"weibull\":\n", + " aft = WeibullAFTFitter(**kwargs)\n", + " elif mtype == \"log_normal\":\n", + " aft = LogNormalAFTFitter(**kwargs)\n", + " elif mtype == \"log_logistic\":\n", + " aft = LogLogisticAFTFitter(**kwargs)\n", + " elif mtype == \"cox\":\n", + " aft = CoxPHFitter(**kwargs)\n", + " assert (\n", + " duration_col in df.columns\n", + " ), f\"Column {duration_col} not in dataframe with columns {df.columns}\"\n", + " if event_col is not None:\n", + " assert (\n", + " event_col in df.columns\n", + " ), f\"Column {event_col} not in dataframe with columns {df.columns}\"\n", + " aft.fit(df, duration_col=duration_col, event_col=event_col)\n", + " ax = aft.plot()\n", + " labels = ax.get_yticklabels()\n", + " labels = [label.get_text() for label in labels]\n", + " for k, v in replacement_dict.items():\n", + " labels = [label.replace(k, v) for label in labels]\n", + " ax.set_yticklabels(labels)\n", + " ax.set_xlabel(xlabel)\n", + " ax.set_ylabel(ylabel)\n", + " ax.set_title(title)\n", + " ax.get_figure().tight_layout()\n", + " ax.get_figure().savefig(FOLDER / file)\n", + " logger.info(f\"Saved graph to {FOLDER / file}\")\n", + " plt.show()\n", + " return ax, aft\n", + "\n", + "\n", + "def plot_partial_effects(\n", + " file,\n", + " aft,\n", + " covariate_array,\n", + " values_array,\n", + " title,\n", + " xlabel=\"Covariate\",\n", + " ylabel=\"Failure rate\",\n", + " legend_kwargs={\"loc\": \"upper left\"},\n", + " replacement_dict={},\n", + " cmap=\"coolwarm\",\n", + " **kwargs,\n", + "):\n", + " plt.gcf().clear()\n", + " # kwargs.pop(\"replacement_dict\")\n", + " pareto = aft.plot_partial_effects_on_outcome(\n", + " covariate_array, values_array, cmap=cmap, **kwargs\n", + " )\n", + " labels = pareto.get_yticklabels()\n", + " labels = [label.get_text() for label in labels]\n", + " for k, v in replacement_dict.items():\n", + " labels = [label.replace(k, v) for label in labels]\n", + " pareto.set_yticklabels(labels)\n", + " pareto.legend(**legend_kwargs)\n", + " pareto.set_ylabel(ylabel)\n", + " pareto.set_xlabel(xlabel)\n", + " pareto.set_title(title)\n", + " pareto.get_figure().tight_layout()\n", + " pareto.get_figure().savefig(FOLDER / file)\n", + " logger.info(f\"Saved graph to {FOLDER / file}\")\n", + " return pareto\n", + "\n", + "\n", + "def score_model(aft, train, test):\n", + " train_score = aft.score(train)\n", + " test_score = aft.score(test)\n", + " scores = {\"train_score\": train_score, \"test_score\": test_score}\n", + " plt.show()\n", + " return scores\n", + "\n", + "\n", + "def clean_data_for_aft(data, kwarg_list, target=\"adv_failure_rate\"):\n", + " subset = data.copy()\n", + " assert (\n", + " target in subset\n", + " ), f\"Target {target} not in dataframe with columns {subset.columns}\"\n", + "\n", + " cleaned = pd.DataFrame()\n", + " kwarg_list.append(target)\n", + " for kwarg in kwarg_list:\n", + " cleaned = pd.concat([cleaned, subset[kwarg]], axis=1)\n", + " cols = cleaned.columns\n", + " cleaned = pd.DataFrame(subset, columns=cols)\n", + "\n", + " # if \"accuracy\" in cleaned.columns:\n", + " # cleaned = cleaned[~cleaned[cleaned['accuracy'] != 1e10]]\n", + " # cleaned = cleaned[~cleaned[cleaned['accuracy'] != -1e10]]\n", + " # if \"adv_accuracy\" in cleaned.columns:\n", + " # cleaned = cleaned[cleaned[cleaned['adv_accuracy'] != 1e10]]\n", + " # cleaned = cleaned[cleaned[cleaned['adv_accuracy'] != -1e10]]\n", + " cleaned.dropna(inplace=True, how=\"any\", axis=0)\n", + " y = cleaned[target]\n", + " assert (\n", + " target in cleaned\n", + " ), f\"Target {target} not in dataframe with columns {cleaned.columns}\"\n", + " return cleaned, y, data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "kwarg_list = [\n", + " # \"accuracy\",\n", + " \"train_time\",\n", + " \"predict_time\",\n", + " \"atk_value\",\n", + " \"def_value\",\n", + " \"data.sample.random_state\",\n", + " \"adv_failure_rate\",\n", + " # \"failure_rate\",\n", + " \"model_layers\",\n", + " \"adv_fit_time\",\n", + " # \"atk_param\",\n", + " # \"def_param\",\n", + " \"model.art.pipeline.initialize.kwargs.optimizer.lr\",\n", + " # \"def_gen\",\n", + " # \"atk_gen\",\n", + " # \"adv_log_loss\",\n", + " # \"adv_accuracy\",\n", + " # \"adv_accuracy\",\n", + "]\n", + "\n", + "\n", + "# cleaned['accuracy'] = y" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "data.loc[:, \"adv_failures\"] = 1 - data.loc[:, \"adv_accuracy\"]\n", + "data.loc[:, \"ben_failures\"] = 1 - data.loc[:, \"accuracy\"]\n", + "target = \"adv_failures\"\n", + "duration_col = \"adv_fit_time\"\n", + "cleaned, y, data = clean_data_for_aft(data, kwarg_list, target=target)\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " cleaned, y, test_size=0.2, random_state=42\n", + ")\n", + "assert (\n", + " target in cleaned\n", + "), f\"Target {target} not in dataframe with columns {cleaned.columns}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# from sklearn.preprocessing import PowerTransformer\n", + "# pt = PowerTransformer(method='yeo-johnson', standardize=False)\n", + "# del X_train[target]\n", + "# del X_test[target]\n", + "# X_train_cols = X_train.columns\n", + "# X_train = pt.fit(X_train).transform(X_train)\n", + "# X_test = pt.transform(X_test)\n", + "# X_train = pd.DataFrame(X_train, columns=X_train_cols)\n", + "# X_test = pd.DataFrame(X_test, columns=X_train_cols)\n", + "# X_train[target] = y_train\n", + "# y_train = X_train[target]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# sense_dict ={\n", + "# \"accuracy\" : \"max\",\n", + "# \"train_time\" : \"min\",\n", + "# \"predict_time\" : \"min\",\n", + "# # \"atk_value\" : \"diff\",\n", + "# # \"def_value\" : \"diff\",\n", + "# \"data.sample.random_state\" : \"diff\",\n", + "# \"adv_accuracy\" : \"min\",\n", + "# \"model_layers\" : \"diff\",\n", + "# # \"adv_fit_time\" : \"min\",\n", + "# # \"atk_param\" : \"diff\",\n", + "# # \"def_param\" : \"diff\",\n", + "# \"model.art.pipeline.initialize.kwargs.optimizer.lr\" : \"diff\",\n", + "# # \"adv_failure_rate\" : \"maximize\",\n", + "# }\n", + "# subset = X_train.loc[:, sense_dict.keys()]\n", + "# senses = sense_dict.values()\n", + "# these = paretoset(subset)\n", + "# X_train = X_train.iloc[these, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
modellifelines.WeibullAFTFitter
duration col'adv_fit_time'
event col'adv_failures'
number of observations1500
number of events observed1500
log-likelihood-5531.26
time fit was run2023-09-29 11:13:25 UTC
\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", + " \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", + " \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", + "
coefexp(coef)se(coef)coef lower 95%coef upper 95%exp(coef) lower 95%exp(coef) upper 95%cmp tozp-log2(p)
lambda_adv_failure_rate-0.001.000.00-0.00-0.001.001.000.00-39.62<0.005inf
atk_value0.151.160.16-0.160.460.851.580.000.950.341.56
data.sample.random_state0.031.030.02-0.010.070.991.070.001.310.192.39
def_value-0.210.810.16-0.530.100.591.110.00-1.310.192.41
model.art.pipeline.initialize.kwargs.optimizer.lr-0.001.000.00-0.000.001.001.000.00-0.530.600.74
model_layers0.011.010.000.010.011.011.010.007.04<0.00538.88
predict_time-0.150.860.01-0.17-0.120.840.880.00-12.17<0.005110.86
train_time0.001.000.000.000.001.001.000.0010.81<0.00588.14
Intercept3.0020.180.182.653.3614.1428.790.0016.56<0.005202.20
rho_Intercept-0.840.430.02-0.88-0.800.410.450.00-43.75<0.005inf

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Concordance0.84
AIC11082.52
log-likelihood ratio test800.84 on 8 df
-log2(p) of ll-ratio test554.32
\n", + "
" + ], + "text/latex": [ + "\\begin{tabular}{llrrrrrrrrrrr}\n", + " & & coef & exp(coef) & se(coef) & coef lower 95% & coef upper 95% & exp(coef) lower 95% & exp(coef) upper 95% & cmp to & z & p & -log2(p) \\\\\n", + "param & covariate & & & & & & & & & & & \\\\\n", + "\\multirow[c]{9}{*}{lambda_} & adv_failure_rate & -0.00 & 1.00 & 0.00 & -0.00 & -0.00 & 1.00 & 1.00 & 0.00 & -39.62 & 0.00 & inf \\\\\n", + " & atk_value & 0.15 & 1.16 & 0.16 & -0.16 & 0.46 & 0.85 & 1.58 & 0.00 & 0.95 & 0.34 & 1.56 \\\\\n", + " & data.sample.random_state & 0.03 & 1.03 & 0.02 & -0.01 & 0.07 & 0.99 & 1.07 & 0.00 & 1.31 & 0.19 & 2.39 \\\\\n", + " & def_value & -0.21 & 0.81 & 0.16 & -0.53 & 0.10 & 0.59 & 1.11 & 0.00 & -1.31 & 0.19 & 2.41 \\\\\n", + " & model.art.pipeline.initialize.kwargs.optimizer.lr & -0.00 & 1.00 & 0.00 & -0.00 & 0.00 & 1.00 & 1.00 & 0.00 & -0.53 & 0.60 & 0.74 \\\\\n", + " & model_layers & 0.01 & 1.01 & 0.00 & 0.01 & 0.01 & 1.01 & 1.01 & 0.00 & 7.04 & 0.00 & 38.88 \\\\\n", + " & predict_time & -0.15 & 0.86 & 0.01 & -0.17 & -0.12 & 0.84 & 0.88 & 0.00 & -12.17 & 0.00 & 110.86 \\\\\n", + " & train_time & 0.00 & 1.00 & 0.00 & 0.00 & 0.00 & 1.00 & 1.00 & 0.00 & 10.81 & 0.00 & 88.14 \\\\\n", + " & Intercept & 3.00 & 20.18 & 0.18 & 2.65 & 3.36 & 14.14 & 28.79 & 0.00 & 16.56 & 0.00 & 202.20 \\\\\n", + "rho_ & Intercept & -0.84 & 0.43 & 0.02 & -0.88 & -0.80 & 0.41 & 0.45 & 0.00 & -43.75 & 0.00 & inf \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\n", + " duration col = 'adv_fit_time'\n", + " event col = 'adv_failures'\n", + " number of observations = 1500\n", + "number of events observed = 1500\n", + " log-likelihood = -5531.26\n", + " time fit was run = 2023-09-29 11:13:25 UTC\n", + "\n", + "---\n", + " coef exp(coef) se(coef) coef lower 95% coef upper 95% exp(coef) lower 95% exp(coef) upper 95%\n", + "param covariate \n", + "lambda_ adv_failure_rate -0.00 1.00 0.00 -0.00 -0.00 1.00 1.00\n", + " atk_value 0.15 1.16 0.16 -0.16 0.46 0.85 1.58\n", + " data.sample.random_state 0.03 1.03 0.02 -0.01 0.07 0.99 1.07\n", + " def_value -0.21 0.81 0.16 -0.53 0.10 0.59 1.11\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr -0.00 1.00 0.00 -0.00 0.00 1.00 1.00\n", + " model_layers 0.01 1.01 0.00 0.01 0.01 1.01 1.01\n", + " predict_time -0.15 0.86 0.01 -0.17 -0.12 0.84 0.88\n", + " train_time 0.00 1.00 0.00 0.00 0.00 1.00 1.00\n", + " Intercept 3.00 20.18 0.18 2.65 3.36 14.14 28.79\n", + "rho_ Intercept -0.84 0.43 0.02 -0.88 -0.80 0.41 0.45\n", + "\n", + " cmp to z p -log2(p)\n", + "param covariate \n", + "lambda_ adv_failure_rate 0.00 -39.62 <0.005 inf\n", + " atk_value 0.00 0.95 0.34 1.56\n", + " data.sample.random_state 0.00 1.31 0.19 2.39\n", + " def_value 0.00 -1.31 0.19 2.41\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr 0.00 -0.53 0.60 0.74\n", + " model_layers 0.00 7.04 <0.005 38.88\n", + " predict_time 0.00 -12.17 <0.005 110.86\n", + " train_time 0.00 10.81 <0.005 88.14\n", + " Intercept 0.00 16.56 <0.005 202.20\n", + "rho_ Intercept 0.00 -43.75 <0.005 inf\n", + "---\n", + "Concordance = 0.84\n", + "AIC = 11082.52\n", + "log-likelihood ratio test = 800.84 on 8 df\n", + "-log2(p) of ll-ratio test = 554.32" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "weibull_dict = {\n", + " \"Intercept: rho_\": \"$\\\\rho$\",\n", + " \"Intercept: lambda_\": \"$\\lambda$\",\n", + " \"data.sample.random_state: lambda_\": \"Random State\",\n", + " \"def_value: lambda_\": \"Defence Strength\",\n", + " \"atk_value: lambda_\": \"Attack Strength\",\n", + " \"train_time: lambda_\": \"Training Time\",\n", + " \"predict_time: lambda_\": \"Inference Time\",\n", + " \"adv_accuracy: lambda_\": \"Adv. Accuracy\",\n", + " \"accuracy: lambda_\": \"Ben. Accuracy\",\n", + " \"adv_fit_time: lambda_\": \"Adv. Fit Time\",\n", + " \"adv_log_loss: lambda_\": \"Adv. Log Loss\",\n", + " \"adv_failure_rate: lambda_\": \"Adv. Failure Rate\",\n", + " \"failure_rate: lambda_\": \"Ben. Failure Rate\",\n", + " \"model_layers: lambda_\": \"No. of Layers\",\n", + " \"model.art.pipeline.initialize.kwargs.optimizer.lr: lambda_\": \"Learning Rate\",\n", + " \"def_gen\": \"Defence\",\n", + "}\n", + "\n", + "weibull_afr, wft = plot_aft(\n", + " X_train,\n", + " file=\"weibull_aft.pdf\",\n", + " event_col=target,\n", + " duration_col=duration_col,\n", + " title=\"Weibull AFR Model\",\n", + " mtype=\"weibull\",\n", + " replacement_dict=weibull_dict,\n", + ")\n", + "wft.print_summary()\n", + "wft_scores = score_model(wft, X_train, X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_773113/12050270.py:64: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " pareto.set_yticklabels(labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pareto_dict = {\n", + " \"model_layers=18\": \"18\",\n", + " \"model_layers=34\": \"34\",\n", + " \"model_layers=50\": \"50\",\n", + " \"model_layers=101\": \"101\",\n", + " \"model_layers=152\": \"152\",\n", + "}\n", + "pareto_weibull = plot_partial_effects(\n", + " file=\"weibull_partial_effects.pdf\",\n", + " aft=wft,\n", + " covariate_array=\"model_layers\",\n", + " values_array=[18, 34, 50, 101, 152],\n", + " title=\"Partial Effects of No. of Layers on Failure Rate for Weibull AFR\",\n", + " replacement_dict=pareto_dict,\n", + " ylabel=\"% Chance of Survival\",\n", + " xlabel=\"Time $T$ (seconds)\",\n", + " legend_kwargs={\n", + " \"title\": \"No. of Layers\",\n", + " \"labels\": [\"18\", \"34\", \"50\", \"101\", \"152\"],\n", + " },\n", + ")\n", + "\n", + "# weibull_accuracy = plot_partial_effects(\n", + "# file = \"weibull_partial_effect_accuracy.pdf\",\n", + "# aft = wft,\n", + "# covariate_array = \"accuracy\",\n", + "# values_array = [.9, .99, .999, .9999],\n", + "# replacement_dict=weibull_dict,\n", + "# title=\"Partial Effects of Benign Accuracy on Failure Rate\",\n", + "# ylabel=\"% Chance of Survival\",\n", + "# xlabel=\"Time $T$ (seconds)\",\n", + "# legend = {\"title\" : \"Benign Accuracy\"},\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/cmeyers/deckard/env/lib/python3.8/site-packages/lifelines/fitters/coxph_fitter.py:1614: ConvergenceWarning: Newton-Raphson failed to converge sufficiently. Please see the following tips in the lifelines documentation: https://lifelines.readthedocs.io/en/latest/Examples.html#problems-with-convergence-in-the-cox-proportional-hazard-model\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
modellifelines.CoxPHFitter
duration col'adv_fit_time'
event col'adv_failures'
baseline estimationbreslow
number of observations1500
number of events observed1500
partial log-likelihood-7421.70
time fit was run2023-09-29 11:13:28 UTC
\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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coefexp(coef)se(coef)coef lower 95%coef upper 95%exp(coef) lower 95%exp(coef) upper 95%cmp tozp-log2(p)
train_time-0.001.000.00-0.00-0.001.001.000.00-4.25<0.00515.52
predict_time0.031.030.010.020.041.021.040.004.21<0.00515.26
atk_value-0.090.910.07-0.230.050.801.050.00-1.310.192.40
def_value0.041.050.07-0.090.180.911.200.000.630.530.92
data.sample.random_state-0.010.990.01-0.030.000.971.000.00-1.570.123.10
adv_failure_rate0.011.010.000.010.011.011.010.0028.70<0.005599.53
model_layers-0.001.000.00-0.00-0.001.001.000.00-5.20<0.00522.23
model.art.pipeline.initialize.kwargs.optimizer.lr-0.001.000.00-0.000.001.001.000.00-0.130.900.15

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Concordance0.92
Partial AIC14859.40
log-likelihood ratio test4105.41 on 8 df
-log2(p) of ll-ratio testinf
\n", + "
" + ], + "text/latex": [ + "\\begin{tabular}{lrrrrrrrrrrr}\n", + " & coef & exp(coef) & se(coef) & coef lower 95% & coef upper 95% & exp(coef) lower 95% & exp(coef) upper 95% & cmp to & z & p & -log2(p) \\\\\n", + "covariate & & & & & & & & & & & \\\\\n", + "train_time & -0.00 & 1.00 & 0.00 & -0.00 & -0.00 & 1.00 & 1.00 & 0.00 & -4.25 & 0.00 & 15.52 \\\\\n", + "predict_time & 0.03 & 1.03 & 0.01 & 0.02 & 0.04 & 1.02 & 1.04 & 0.00 & 4.21 & 0.00 & 15.26 \\\\\n", + "atk_value & -0.09 & 0.91 & 0.07 & -0.23 & 0.05 & 0.80 & 1.05 & 0.00 & -1.31 & 0.19 & 2.40 \\\\\n", + "def_value & 0.04 & 1.05 & 0.07 & -0.09 & 0.18 & 0.91 & 1.20 & 0.00 & 0.63 & 0.53 & 0.92 \\\\\n", + "data.sample.random_state & -0.01 & 0.99 & 0.01 & -0.03 & 0.00 & 0.97 & 1.00 & 0.00 & -1.57 & 0.12 & 3.10 \\\\\n", + "adv_failure_rate & 0.01 & 1.01 & 0.00 & 0.01 & 0.01 & 1.01 & 1.01 & 0.00 & 28.70 & 0.00 & 599.53 \\\\\n", + "model_layers & -0.00 & 1.00 & 0.00 & -0.00 & -0.00 & 1.00 & 1.00 & 0.00 & -5.20 & 0.00 & 22.23 \\\\\n", + "model.art.pipeline.initialize.kwargs.optimizer.lr & -0.00 & 1.00 & 0.00 & -0.00 & 0.00 & 1.00 & 1.00 & 0.00 & -0.13 & 0.90 & 0.15 \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\n", + " duration col = 'adv_fit_time'\n", + " event col = 'adv_failures'\n", + " baseline estimation = breslow\n", + " number of observations = 1500\n", + "number of events observed = 1500\n", + " partial log-likelihood = -7421.70\n", + " time fit was run = 2023-09-29 11:13:28 UTC\n", + "\n", + "---\n", + " coef exp(coef) se(coef) coef lower 95% coef upper 95% exp(coef) lower 95% exp(coef) upper 95%\n", + "covariate \n", + "train_time -0.00 1.00 0.00 -0.00 -0.00 1.00 1.00\n", + "predict_time 0.03 1.03 0.01 0.02 0.04 1.02 1.04\n", + "atk_value -0.09 0.91 0.07 -0.23 0.05 0.80 1.05\n", + "def_value 0.04 1.05 0.07 -0.09 0.18 0.91 1.20\n", + "data.sample.random_state -0.01 0.99 0.01 -0.03 0.00 0.97 1.00\n", + "adv_failure_rate 0.01 1.01 0.00 0.01 0.01 1.01 1.01\n", + "model_layers -0.00 1.00 0.00 -0.00 -0.00 1.00 1.00\n", + "model.art.pipeline.initialize.kwargs.optimizer.lr -0.00 1.00 0.00 -0.00 0.00 1.00 1.00\n", + "\n", + " cmp to z p -log2(p)\n", + "covariate \n", + "train_time 0.00 -4.25 <0.005 15.52\n", + "predict_time 0.00 4.21 <0.005 15.26\n", + "atk_value 0.00 -1.31 0.19 2.40\n", + "def_value 0.00 0.63 0.53 0.92\n", + "data.sample.random_state 0.00 -1.57 0.12 3.10\n", + "adv_failure_rate 0.00 28.70 <0.005 599.53\n", + "model_layers 0.00 -5.20 <0.005 22.23\n", + "model.art.pipeline.initialize.kwargs.optimizer.lr 0.00 -0.13 0.90 0.15\n", + "---\n", + "Concordance = 0.92\n", + "Partial AIC = 14859.40\n", + "log-likelihood ratio test = 4105.41 on 8 df\n", + "-log2(p) of ll-ratio test = inf" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_773113/12050270.py:64: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " pareto.set_yticklabels(labels)\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAGyCAYAAAAvcypsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADT20lEQVR4nOzdd1xTVxsH8N9NSALIVgQHKC7AgXvg3lZcqFVfd90Lrbt1W7V1122VOnDg3nvvXfcCBw6WgOyded8/IldCAgQSCODz7YdPc9e5JwkxD2c8h2FZlgUhhBBCCMkxnqErQAghhBBSWFEgRQghhBCSSxRIEUIIIYTkEgVShBBCCCG5RIEUIYQQQkguUSBFCCGEEJJLFEgRQgghhOQSBVKEEEIIIblEgRQhhBBCSC5RIEVIPomNjUX37t3RtGlTPHnyxNDVAQD8999/mDJlCqpXr26wOkybNg116tSBr6+vweqQVxITE/Hvv/+iW7duqF27Npo3b44pU6bgw4cPhq4aIURPjAxdAULSe/36NXx8fPDgwQNERkbCzMwM5cuXR9OmTdGmTRtYWlpi/vz58Pb2NnRVc+zevXt4/fo1AODUqVOoXbu2wepy584drF27NlcB3f379zFo0CCd7n/s2DG4uroiOjoaJ06cAADs27cP/fv316ncgiQoKAgjR45Enz594OvrC39/f0yaNAmnTp3C5cuXsW/fPri4uBi6miru37+P06dP4+nTpwgODoZYLIaVlRWcnZ3RunVrdO3aFRYWFli/fj3MzMzwyy+/GLrKuTZ+/Hj07t0bzZo10+r8ffv24dGjR7h27Rri4+NzdK/Lly+jbNmyWLx4MQIDA3Ht2jUoFAqVcxiGgUAggLm5Oezt7eHi4oLevXujVq1aOboXMQCWkAJi+/btrKurK9u3b1/23r17bGxsLBsSEsIeOXKE7dSpE1ulShW2SpUqbPfu3Q1d1VyJiYlhPT092SZNmrBPnjwxaF3EYjHLsiw7Z84c7nXV1r1799gqVaqwU6dOZd+/f88mJiayUqmUlUql7OrVq7nyDh48yO1PTExknz17xo4YMYKtUqUK+/r1a668qVOnsrVq1WJ3796t9+dpKFKplO3Zsyfr4eGhsv/Zs2dsjRo12CpVqhSo5/vq1Sv2559/5j5fhw8fZt+9e8cmJSWxkZGR7I0bN9jJkyeztWrVYocMGcJWq1aN3b59u6GrnWuBgYGsi4sLO3z48Bxf+/HjR+53vEqVKuyXL19UfoKDg1k/Pz92//79bIsWLdgqVaqwQUFBKmX4+vpy1/fr14+9du0a++bNG/b169fs3r172bZt23LHZ86cycpkMn09dZIHqEWKFAgXLlzA4sWLUbt2bezcuRNGRspfTUtLS3Tv3h0eHh6YOXMmTp06ZeCa5p6VlRWOHj1q6GoAAIRCIQDA2dk5V9c3aNAAy5YtA8MwKvt5PJ7K47T30cjICG5ubti4cSN+/vlnlWuWL1+eqzoUZDdv3sSLFy/QunVrlf1ubm7Yt28fnjx5gl69ehmodqqOHDmCOXPmQC6XY86cORgwYIDKcVNTUzRr1gzNmjXD3bt34eXlBalUaqDa6seOHTugUChw8+ZNfPz4EU5OTlpfW758eVhbWyMmJgYAYG9vr/E8FxcXNGnSBJ07d1Y7Vq9ePe5xxYoV0aJFC27b1dUVnTt3xqBBg/Dq1SscOnQIfD4fCxYs0LqOJH/RGClSIKxZswYA0K9fP+7LNz2RSITFixejcuXK+V21Ii0toMqpXr16qQVR2jAyMkLPnj1zdc/C5ObNmwCUQUhGVatWRf/+/XP92uvTmTNnMHPmTMhkMkyaNEktiMrI3d0da9asydV7X1AkJCTg8OHDAACWZbFr164cl2FiYqLVeWXKlFH7w0Gb683MzPDXX39x2wcOHMDHjx9zVkmSbyiQIgYXFxeH9+/fA0CW/0ALhUIMHTo0v6r1Q+Dz+Tm+pnz58nB3d8/1PVu3bg07O7tcX18YfPnyBQA0/lFQUISGhmLWrFlgWRaVKlXCiBEjtLquadOmGltZCosDBw7AxMQENjY2AICjR48iISEhR2XkJJAcNWoUbG1tc3y9i4sLHBwcACgDvrt37+aojiT/UCBFDI5lWe7xli1bkJSUlOm57du3V+k+IvnPzs5O7YshJ8qUKcN9iRVViYmJAHL2hZvfVq1aheTkZADAoEGDcvS5Gj58eIF+bpmRyWTYvXs3+vXrhz59+gAAkpOTcejQoTy7Z4kSJSASiXJ9bZqcDnAn+Ye+kYjBWVlZoVy5cgAAf39/9OvXj2uhysjMzIw7F1DOPnN2dlb5OXLkCHfcz88vy+OA8ktv165d8PDwwLp16wAA+/fvR4sWLdC0aVNcuXIFVatWVSvH2dkZ586dUymrefPmKsfTygOAjx8/YunSpWjYsCHu37/P7Z81a5bGskeNGqVS9qpVq1SOZxx/8/DhQ3h5eaFJkyaoVq0aGjZsiL59+2L//v0qwWpBEh0djW3btuGnn35Sea3ShIeHY9WqVXB3d+des5cvX2LUqFGoXbs2mjZtioULF6oE348fP8bo0aNRv359NGzYEL/99luWX0KJiYnYsGEDl6Kgdu3a6NWrF/bu3as2syorR44c4d6bBw8eAFC2dqR/z4KDg1WuSUlJga+vL3r37o369eujdu3a6NatG9auXZtpK0lUVBQ2bdqE1q1b48iRI2BZFuvXr4e7uzvatWuHZ8+eZVvXqKgonDlzhttu27at1s8TULaWNGjQQOOxjx8/YuHChejQoQPc3NzQuHFjDB8+HGfPnlU7d8WKFRp/93v37g1AOYsw47GrV6/mqK7pnT9/HlFRUejXrx/69esHgUAAANi9e3eO3mttLF68WOcyIiIiuMelSpXSuTySNyiQIgXC2LFjucf+/v7w9PTEypUrub/s01u5ciX3OO0LdvTo0RrLdXFxwd27d/Hrr7+qHZNIJJg7dy6aNWuGRYsWISAgAACwc+dOzJ07F2FhYfj69StWr16Ny5cvo0uXLty1JUuWxLVr19ChQweVMi9duoRRo0aBx+NhxYoVGDVqFDcN3sPDA9u2bUNsbKzKNbNmzcLixYthbGzM7VuyZAk2bNigct6ECRNw6tQpMAyDjh07qvwVvX//fgwYMABfvnyBj48P7ty5gzlz5sDf3x9z584tcAO6ZTIZfv/9d7Rr1w5Lly5VG/8RGhqKSZMmoXXr1ti0aROio6MBAMePH0ffvn3x5s0bSCQSfP36Fbt378bvv/8O4Pvr8Pr1a0ilUsTGxuLYsWOYMGGCxnoEBATA09MTqampWL9+Pa5fv4558+YhMDAQ8+fPx+jRoyGTybR6Tt27d8erV6/w6tUr1K9fHwDg6enJ7Xv16hXKli3LnR8YGIjevXtj7969mDJlCq5du4a9e/eiVKlS2LBhAzp27MilywCUQefkyZPRokULrFq1CiEhIQCUvyvr1q1DdHQ0AgMDsWnTpmzreuXKFe55lS1bFsWLF9fqOabn6uqqtu/YsWPo1q0bpFIptmzZgjt37mDevHl48+YNJk6ciLFjx0IikXDnT5gwAfv370eVKlW4fVWqVMG2bdsAKCc1pP3u1qpVCydPnlQZmJ1TPj4+8PT0hI2NDUqWLImOHTsCAIKDg3HlypVcl5vRhw8fEBcXp1MZjx8/5t5jExMTNG/eXB9VI3mAAilSIHh6eqqM0ZBKpfD29kbbtm2xY8cOlX9802MYBlZWVmqtN+mP29jYYPDgwWrHhEIhvLy8sG3bNq6b4v3793jy5Anu3LmDgQMHQigUok2bNihVqhSWLl2KSpUqAQDMzc1RqlQpte4NoVAIhUKBTp06oUuXLhAKhShVqhT++ecfLFmyRGMdTU1N0aNHD4wbN47bV7FiRbXxNXw+HzweD6amppg/fz7XPRYdHY1FixaBZVmMHz8elStXhqWlJTfzBwB8fX0hl8s13t8QjIyMsGDBApw8eVJjF5GVlRVmzJiByZMnc/tOnDiB+/fv4/z587h27Rru3buHRo0aAVDO+ly7di0uX76MkydP4saNG3j06BEGDhwIALh79y5evHihco/4+HiMGDECPXr0wJQpU+Dg4AALCwt4enpyA32vX7+udc4yhmFgZGQEIyMj7jml35f+/UxOTsbw4cMRGhqK7du3o2HDhihWrBhcXFywYcMGNGrUCF+/fsWQIUMQFhYGQNkaO3v2bCxbtowr586dO5DJZLhx4wY6d+4MoVCo1lKpSfrXwtHRUavnl52bN2/it99+Q+vWrbFgwQI4ODjAzMwMHTp0gI+PD0QiES5fvoxp06Zx1wiFQtSqVQtbt27luovDwsIgFosBKF+/V69ewdnZGVu3bkWVKlVy3bX/6NEjvHjxQuXfgvSPd+zYkatyM4qJicHSpUt1KiMyMhIzZszgtqdMmQJra2tdq0byCAVSpMCYOnUqli9fDisrK25fTEwM/vrrL3h4eOD8+fOZXqtpdlR6xYoV07i/ZMmSqF27NheUPH78GAsXLkTx4sUxe/ZsPH/+nGvN4vP5XALCgIAA+Pn5qZUnlUpx7NgxDBkyhNtnZGQEPp+v8S/49P73v/9xz+PkyZMazzl06BB69Oih8hoFBwdzgaaFhYXK+TVq1AAApKamctO1CwqhUIjSpUvD0tJS7ZipqSlKliyJJk2acPsqVKiAv/76C6VLlwagDGanTp3KHY+MjMTmzZtRsWJFAMr3a9KkSdyA+oyB1NatWxEWFqZxplrjxo25x/v27dPhWWq2bt06fP78Gd26dVMbb8bn8zF//nwwDIPY2FguqBMKhbCxsVEJlN6/f4+ZM2fCzs4OK1euxPPnz7VKqxAeHs49Tv+7lFsSiQSzZs0CAAwbNkzteMWKFbnPxLlz59S650qWLImlS5eCYRjEx8dj3rx5AJQB8PHjx7Fx40aYmZnpVEcfHx+0aNGC+/0AgOrVq6Nu3boAgAcPHsDf3z/H5TZp0oT7adSoERo1aoRr167lqo7BwcHw8fFB165d8enTJ+6PprQ/CEjBRIEUKVC6du2Kc+fOoU+fPiozyoKCgjBhwgSMHj1a5yZzTdKmovfo0UPlH+yMrSVdunThvnh27typVs7FixdRtmxZVKtWTe1YdlOe01pDAOV4m4yD7lNTU3HkyBH069dPZb+rqys6duyIDh06qC31kj6AzKxVz9Cyel3SB8ialrGpUKEC97hWrVpq71exYsW49yvjOKljx46BZVl07NhR5cuwSZMmKmOGwsPD1bpjdSEWi7lu2fT5hNJzcnLixiBdvHhRJfBJnzahf//+Kp8TbQeAp88DlZuZmxldunQJ4eHhMDExyXS5obRxT4ByTFJGTZo04VqILl68CF9fX0ybNg2LFy9W6RLNjaCgIFy6dEljJvb0rVKaPtPZOXbsGPdz4sQJHDx4MEezWo8fPw53d3e4ubmhTZs2WLx4MXg8HubOnYvr16+jb9++Oa4TyV8USJECx9raGgsWLMCJEyfQqlUrlWNXr17FgAEDNI6d0kVad0F209WNjY252T6nT5/mxu6k8fX1zTQXjzZfcgMHDgTDMEhMTFRL3nnq1ClUr15dJXgAAIFAgNWrV2Pt2rXcl6y/vz8WLFjAjR0CoPfBtPqSVVdNdt04mbU0ppc29ix98BAWFoawsDDY2NiofBGm/7l16xb3k7GlTxf37t3jgrqsxialBVIKhQIPHz7k9qd/TXIbBJmbm3OP9REkXrhwAQBgY2OT6e95mTJluIDo4cOHGidATJkyhVs2Z8GCBejSpYvavwG5sXPnTjg7O2sMcNq2bYsyZcoAUH7GMn6ms2Nra8v9lCxZEm5ubli+fLnWQW3NmjVx4sQJnDhxgksLEhUVxXU1k4KPAilSYFWqVAmbNm3Czp07VQajvn37lkvgaQhpSUPFYjEOHjzI7X/z5g0+f/6sNgA9JypUqICmTZsCUP7Vnv7LZs+ePdmuRXf16lX069cPixcvhru7u15mDhVFX79+BaCcsVeiRAmVL0NNP/pMuREYGMg9zqrc9AFzWn31JX0m76ioKJ3LS3tO2QUPac8pNTVV40xKoVCIlStXcukCPn36pHPd0hJwfvr0Sa3lsUmTJmjevDkiIyMBKFsL9+/fr/M9bW1ttU7xIRAIYGtri/Lly+Pvv/+GkZERFAoFpk6diqCgIJ3rQvIeBVKkQEg/1iWjhg0b4vDhw/Dw8OD2HT161GAtLPb29mjXrh0AYO/evdzsJ19fX/Tp04ebUp1baeMhPn78iFu3bgEAnj59iri4OLRs2VLjNRERERg+fDhmz56NMWPGYMeOHWjXrp1eum2KorT3LDU1Nd8zRqekpHCPsxq3lr41Qt8tEw0bNuQev3//PsvcbdpIy0eVXetW2vPg8/mZtiaGhIRwLcNXrlzBnj17dKrbgQMHYGZmhvPnz2fa+nj8+HEueNuzZ49elsBJP6heW/Xq1cPEiRMBKBMVe3l5qfy+kIKJAilSILx48SLLwEgoFGLJkiVc10BCQkKOm+D1KW023JcvX3Dx4kUkJCRwY7t01bx5c5QvXx4AuOUrfH190a9fP40tGNHR0ejfvz/u3LmDrVu3ar2a/Y8s/QyoS5cuZXnuixcv9Dq+LP3abG/fvs30vPStkelzp+lDw4YNuc+SRCLhlrTJrbQcR4mJiQgNDc30vLTnVLZsWY3d6MHBwZg5cya2bt2KNm3aAACWLl3KpSbJqbQEnAMGDOASyWr6cXJy4tKbREREZDmxJa8NHz6c68709/fHnDlzDFYXoh0KpEiBEBsbyyUxzIxIJOIGAfN4PJVxHgC4lqDs/prUR0tWnTp1uEG1u3btwtGjR9G0aVOULFlS57IZhuECtRs3buDx48e4fv26xjW7AODff/9FYGAgXFxcuPElJGvlypXjBqHv2LEjy5aUtWvX6nWpl4YNG3IBcVYBTNofCmkzS/WJx+Nh/Pjx3PaWLVty9LmQy+WYPXs217KXfuzRjRs3Mr0u7Tm1b99e7ZhEIsGECRO4ZKuLFi2Cra0tUlNTMXny5FwFsxcuXEBMTIzKQPfMpJ8Zl5tB5/rCMAyWLl3Kjds6efKk3lIzkLxBgRQpMDZs2JBtrqO0LohGjRqpLbuQ9sWoaVzF9evXucepqamZlp+TL5O0YOfRo0fYtGlTtuOX0rcwZJdp3NPTE+bm5mBZFl5eXmjfvr3GNAEA8O7dOwDKsS4Zy02fTFLTc8tJnbSR/v3T9rVMu6+m++szI3v6shiGQadOnQAo0yZMmDCB655Kz9fXF+XKlcvxGKm0YF5TMk87Ozuua/jp06d49eqVxjLS9v/vf//L9P66/FHg6enJBTQvXrzA1q1btb72zz//RMeOHbkAs2fPntwMyz179mh83+RyOfz8/CAUCjWmaFiwYAEcHR25z5WNjQ2X+sHf3x8rVqzI2ROEMkDs1KmTVikeXFxc4ObmBgB49uyZygB/Tc8lTW5+R7N73ywtLbF69Wruj8Nly5bhzp07Ob4PyR8USJEC48GDB5g7d26mf3kGBQXhzJkzEIlEGscfODs7AwAOHz6MO3fuQKFQIDQ0FH/++SdOnDjBnffo0SNIJBKVwa5pwVVa8kNtdOzYkcsBZGdnx+WjyUz6JT+ym3VYrFgxrgUqKioq05mAALi8SmFhYVi7di0UCgVSUlKwZ88eLrdP2vFnz56pLA2Svk66jpMBwA3aTau3NtLqoOk1SV8nTfVLS9wIINOxJGm/TxmvHzNmDDdr7v79+/D09MTBgwfx+vVr3L59GzNmzMDGjRtVsu5rK21wePq0BenNmDGD+3L/448/1FpR4+PjcerUKY2LCaf/QyAnv6+arFy5kpvcsGLFCvz9999ZfsmLxWLMmTMH1apVU8nxVbx4cW6c45s3b7gu6fTOnDmD2NhYjBkzRq2rcs+ePbh16xYWLVqksr958+ZcSpCdO3dm2w2b3smTJ/Hq1asczfpL3y2+atWqTAPC9GPbcpOfLf3kgcyGKLi5uWH69OkAlAH5uHHjVJaWIgUHBVKkQDl06BC6d++O/fv3IzAwEElJSfj48SN27dqF3r17w8jICOvXr0fVqlXVrh0yZAgYhkFcXByGDBmC6tWro1WrVmqZhs+cOYMBAwbg1atXSExMxKFDh7gv/QsXLuD69esaWycyEgqF+N///gcA2bZGxcfHq+TO8fX1RXh4eJZfWv379wePx0O9evWy7LL7+eefuRaLjRs3om7duqhfvz6uX7+usjTM8OHDsXjxYrRu3RoKhQLh4eEqQdW///6b6fpuWWFZFklJSbhy5YrK2oOHDx/Gs2fPVIKd9FJTU3HgwAHunufOnYO/vz8XVMTFxal0aezfvx+RkZFQKBRgWRZxcXHcUiKAcup6YGAgd31SUhKOHj3KfWldvHgRb9684VqJbG1tsWnTJm521efPnzF79mx0794dQ4cOxcWLF7Fu3TqtZ1+lvQ5bt27l1tR7/PgxTp48iZSUFJX3ulSpUvD29oa1tTWePXuGYcOG4cWLF0hOTsazZ88wdOhQ2NvbY9u2bSp5o2JiYrBlyxZu++DBg3j06FGmr3F2hEIh/vnnH0ycOBEikQibN29Gt27d4Ovri4CAACQnJyMuLg7+/v7w9vbGsGHD8NNPP6Fnz55qZfXv3x+jR48GwzBYvHgx1q1bh/DwcMTHx+PgwYOYO3cuRo0ahTFjxnDXSCQS+Pr6YtGiRbCyslJrLRaLxdwfKyzLYtq0aTh//nyWA7BTU1Nx8eJFLFiwAABw9uxZBAUFZdlyJJfLERwcrNIK9fDhQ8ycOROfP3+GXC6HQqFAREQEVq5cqfJ6L1++HCEhIVqtHCCVShEQEIBVq1Zx+/z9/XHs2DEkJiaq/XswaNAgbhZwcnIyhg4dipkzZ+Lu3bu0iHEBwrAFdTVT8kMZNmwYVq9ejaCgINy6dQt3797F27dvERcXB4FAAAcHB7Ro0QIDBw7MchzS+fPnsW7dOgQGBqJcuXLo378/F+xUr14dP/30EwYOHIiaNWsCAKpWrarxH8AyZcpotfZWVFQUPD09cfHiRZW18tL7/PmzxjEhADB//vwsE+6NGzcOnTp1UpmxqMnVq1exevVqfPz4EQ4ODhg4cCD69OkDhmEwevRoPHjwAB06dMDs2bNRrFgxHD9+nPtrN6OTJ0+qpJvIzqVLl1SWt9HkzJkzKhmlAWVrg6YWGw8PD3h5eWX6nGfMmIGGDRtyLRUZ9enTB1OnTuXWu8to9OjRmDRpErcdFRUFb29vLqmkpaUlmjZtCi8vLzg4OGT5vNK7ceOGWutReu7u7vDx8VHZFx0djS1btuDq1asIDQ2FqakpnJyc0L17d3Tt2lWl+zosLCzTdeYaNGigsRUoJ8LDw7ms44GBgYiKioJCoUCJEiXg6uqKtm3bcsvQZOW///7Drl278PjxY8TFxaFkyZKoVasWBgwYoDbWa8eOHVz3HaDMb5U+mPn999/V8qkBQNOmTTPtihw9erTGhY2HDh2K3377TeM1W7duVVl6J6PFixfj9OnT3CxaTZycnNQWMc8os39v0nh5eamMXQOULbU9evTA58+fVfbXqVMHe/fuzfJ+JH9QIEUIIYQQkkvUtUcIIYQQkksUSBFCCCGE5BIFUoQQQgghuUSBFCGEEEJILlEgRQghhBCSSxRIEUIIIYTkkv4WkCKZevLkCViW5dL9E0IIIUS/pFIpGIbR+9qU2aEWqXzAsqxe1wxLX65EIsmTskneoveu8KL3rnCj96/wyu69y6vv2uxQi1Q+SGuJqlGjhl7LTU5Ohp+fHypVqsQtGEoKB3rvCi967wo3ev8Kr+zeuxcvXhigVtQiRQghhBCSaxRIEUIIIYTkEgVShBBCCCG5VKjHSF28eBHbt2/HmzdvwOfz0aBBA4wdOxZVq1bNVXm3b9/G/v378ezZM8THxwMASpcujSZNmmDo0KGwt7fXZ/UJIYQQUsgV2haplStXwsvLCwqFArdv38bBgwdx+/Zt9O7dGxcvXsxRWSzLYt68eRg6dCjOnz+PX375BQ8ePMC5c+dgZmaGHTt2oHPnznj27FkePRtCCCGEFEaFMpA6dOgQvL29AQC9e/eGsbExypUrh2bNmkEqlWLSpEl48+aN1uXt3LkT+/btAwDUrl0bQ4YMgUAggJ2dHWbNmgUASEhIwOTJk6FQKPT/hAghhBBSKBW6QEoikWDDhg3ctqOjI/e4XLlyAJRJuVatWqV1mbt37+YelyhRQuVYjRo1IBQKAQDBwcE5CtAIIYQQUrQVukDq7t27CA0N5bbNzMy4x2kBDwDcuHEDCQkJWpUZFhbGPX78+DFSU1O5bYZhYGVlxW1TdnJCCCGEpCl0gdS9e/dUtjMLbORyudq5mSlbtiz3OCoqCuvWreO2ZTIZYmNjAQAVK1aEk5NTDmtMCCGEkKKq0AVST548Udk2Msp84uHTp0+1KrNHjx4q21u2bMGKFSugUCjw6NEjSCQS2NjYYOXKleDz+TmuMyGEEEKKpkKX/iAiIkJlm8fLPBaMiorSqswhQ4bg0aNHuHr1Krfv33//xZMnTyCXy9GhQwfMmjULdnZ2uas0IYQQQoqkQhdIxcTEqGwzDJPpudHR0VqVaWRkhPXr1+Ovv/6Cr68vt//hw4cAgAoVKiAxMVGnQIplWSQnJ+f6ek0eT10MaTFzpPxeXq/lkryXkpKi8n9SeOTne8eyLGQyGc0W1qO0MbBxcXEQi8UGrg1Jw+fzwefzs/xOz+6zx7JsltfnlUIXSEmlUq3Pzckq0EZGRmjfvj2uXr2KZs2a4ciRI9y9Pnz4gL59+2LHjh1wdXXNcZ0BZb39/Pxyda0m8WExOOC7G5+FCszt3gwCkTD7i0iB8+nTJ0NXgeRSfrx3PB4PDMMY5MuhKDMyMlLr3SCGk/ZdrVAotPrezuqzl37SWX4pdIGUhYWF1l121tbWWp0nlUoxd+5cHDlyBJ06dcKCBQvQo0cPjBo1ihtoHhcXh3HjxuHcuXO5eqMEAgEqVaqU4+sy4xf7HCfMJAAAh7JlYV2iuN7KJnkvJSUFnz59Qvny5WFiYmLo6pAcyOv3LikpCV+/foVAIIC5uTlMTU1pbKYesSwLiUQCoVBIAWoBIpVKkZCQgISEBJibm6N4cfXvtOw+e+/fv8+PqqopdIGUvb29SiCVVfRqa2urVZnLli3DkSNHAACtWrUCANSqVQve3t4YNGgQ1xQcEhKCs2fPolu3bjmuN8MwMDU1zfF1mbG0tkbnJOWMRWNjE72WTfKPiQm9d4VVXrx3ycnJiIyMhKWlJUqXLk1f9HlALpeDYRgYGxtTgFrAWFlZISYmBmFhYbCwsIClpaXG8zL77Bnq81LoZu25ubmpbMvl8kzPrV27drblxcfHY+/evdy2g4MD97hmzZoYNGiQyvmvX7/Wtqp5ysTEBF2TROiaJAJDwycIKRLi4uIgEAgoiCI/LGtra5iamnLr3RYGhS6Qaty4scp2+uSZ6fF4PNSrV4/bDggIQI8ePdCgQQOsWbOG2//p0yeVcVfpk28C6qkRsgrc8hPD+/6XFFtA6kQIyT2WZZGQkAALCwsKosgPzczMDMnJyYVmkkWhC6Ratmyp0ncaFxfHPU4f5LRo0UIlKJozZw5evXqFuLg4bNy4EXfv3gWgPo4q4/gre3t7le2aNWvq/Bz0geExSGZYJDEs5IXkl40QkjmpVAq5XI5ixYoZuiqEGJSxsTEUCgVkMpmhq6KVQhdICYVCTJo0idtOP3o/PDwcgHJg98SJE1Wuy9gll7bt4OCA+vXrc/tv376d6XVVqlTBTz/9pFP99SVFnIqJtkmYZJuEVJpCT0ihl/bXd1a58Qj5EaR9BqhFKg/16tULv/zyCwDg8OHDSE5ORnh4OC5dugSBQIBly5bBxcVF5ZqM21WrVuUeL1u2jFvwePv27Vxizg8fPmD+/PkAgMqVK2Pz5s0FZq299P/YKhTap3kghBRs1K1HfnSF7TNQ6GbtpZkxYwZq1qyJnTt3okWLFuDz+WjUqBHGjRunFjQBwKJFizBt2jQEBwdjwIABcHd3546VLl0aR48eha+vLy5duoSpU6dCJpPB2NgYVapUwZw5c9CrVy+IRKL8fIpZMjUrho0Ryi4AEb/Qvo2EEEJIoVaov4E9PDzg4eGh1bmVKlXC0aNHMz1erFgxjBw5EiNHjtRX9fKUEZ8PI6RF7YUreieEEEKKinzv2mNZVmUZFpJL6bv2aNYeIYQQYhD53iIVGRmJRYsWoX///vl96yJFzshxqJgYLANUocHmhPxwli5dim3btmk85ujoiMOHD8PCwkLt2Ny5c7F//361/Xw+v8DkydOVQqHA8ePHceLECfj5+SExMRGWlpZwc3PDhAkT4OjoqHZNUlIS6tSpo1X5o0ePVpn0RH5sWgVS//33n843YlkWSUlJ1BqlJwyAC8WU+a+mZ5JLixBSdE2ePBk9evTAvHnz8OjRI5VjgYGBmDZtGjZt2qQ2cHfmzJno168f1q5di8uXL8PU1BSzZ89Wy9FXWCUlJWHMmDG4f/8+BAIBjh49iqtXr2LlypW4cuUKnj59irNnz8LY2FjlumLFiuHly5cICgrCzJkz8eTJE5XjNjY2WLVqFWrVqmWQ9dxIwaVVIDV+/HiVfE26MNTqzEWNkUCA9t+WiDHiF4yZhISQ/CMQCFC5cmV4e3ujd+/eCAgIUDl+7do1rFu3DhMmTFDZb2xsDBcXF6xZswaNGzdGjx490LNnz/ysep5aunQp7t+/D0C5TFjlypVVAk2ZTJZpYmWBQIAKFSpg2LBh8PLyUjnWuXNnNGrUKO8qTgotrQKp7t27Y/v27XldF5IDRkIRfk5SziIUGVEgRciPyszMDG5ubmqBFABs3LgR1atXR+vWrdWOCQQClC9fHk5OTvlRzXwhkUhw/Phxbjvtj/YePXpALBYjNjYWHTt2VGuNysjc3FyrfYQAWgZS//vf/7Bz504sX74czs7OEAqFOU4ax7IsEhMTsX//fuzbty9XlSXfMelefxaFI2kZISTvNG/eHPfv34dYLOb2sSyL6dOn49ChQyhfvrzaNcbGxkWqmyoqKkrjsmFCoRCDBw8GoFwBI7OlxdJo6jWhnhSSGa0CqXLlyqFVq1bo2LGjzr9MkyZNUlkkmOQOwwNkDAuwgEJGs/YI+dG5ubmhW7dumDJlisr+hIQEeHl54cCBAzA1NTVQ7fJHQVkLlfxYtJ61N3PmTL3c0MLCAtevX9dLWT8yhmEw1jYJAHAiJsbAtSGEFASdO3fGhw8fsGHDBpX97969w8yZM7F69eoclSeRSLBnzx6cOXMGHz58gFwuR9myZdG6dWv069cPdnZ2eqz9dwqFAkePHsWxY8fw9u1bpKamonTp0mjSpAn69++v1h0ZHByMNm3aqJUTEhICZ2dnAMCbN2/ypK7a8vPzw+HDh/Hw4UOEhIQgNTUVdnZ2aNSoEUaMGMGtrgEAL1++zHLc2n///QcLCwtcunQJ48aNUznm4+OjknA6NTUVO3bswJkzZ/D582cIhULUrVsXY8aMgZubG3deVFQUJkyYgIcPH6qU5+XlhfHjx+Pr16/4+++/cfnyZZQoUQIbN27kWjnj4uKwevVqXL58GV+/flVZ2qVatWo4cuRIrl6zwkLr/rnSpUvr3Bq1ZcsWBAYG5tmH70dCS8QQQjQZP368xkTFZ8+exZYtW7QuJzIyEj179sTixYvx5csX/Pvvv7h27RqqVq2KTZs2wcPDA5cvX9Zn1QEoZ9398ssvmDlzJl6+fInly5fj9u3baNeuHXbt2oUuXbqopW8oW7YsXr16hYsXL6rsL1OmDF69eoVXr17pvZ7akkqlmDt3Ljw9PcHn8+Ht7Y3z58+ja9euCAoKwsGDB9GjRw88fvyYu6ZatWpYunSp2pJkZcqUwY0bN7i0Fq1bt8bZs2dhb28PgUAAb29vlQHxQUFB6NatG/7++2/Ur18fV65cwcyZM3HlyhX07dtXJUl18eLF4evri5o1a6o9hy9fvqB37944cuQI4uLiEBAQwPUsicViDB48GHv27EH9+vVx9+5d7Nu3D9WqVdPr61iQ5WtCzu7du2Pw4MEIDAzMz9sWSQwDrI42w+qvxWBpZmbo6hBCCgiGYbBkyRKV1oY0f//9N+7evZttGTKZDKNGjcLbt28BAIMHD0bt2rVhaWmJ2bNnw9jYGImJiRg/fjyeP3+u1/pPnz6dm3Xn6emJ5s2bw8zMDL/++ivs7e25wOT8+fMq1xkZGWkcu2tkZAQjI8Mt4rF27Vou8KtSpQpKliwJGxsbTJ06lTsnMTERs2bN4rYZhoGnpyeGDRumUpZMJkPJkiW5bR6PhwoVKsDJyQm9evVCixYtuAaPhIQEDBkyBJ8+fYKtrS2mTZsGGxsbeHp6okGDBpDJZJgzZw7evXunco/0LWNp9/Ty8oK1tbXK68jn8wEA+/fvh5+fHwCgffv2sLKyQu3atbFr1y5UrFgx169bYaK3QCotN8fx48dx7NgxtZ/Dhw9j3759CA8Px7x58/R12x8WA6AYeDBlGTBsoVx7mhCSR0QiETZu3IhSpUqp7JfL5Zg8eTJCQ0OzvH7//v14+fIlt50+KDM3N0flypW58tIHALq6du0aLl26pPG+fD4ftWrV4rbnz5+vMrC+oDp06BD3ePHixVydLS0tVc778OEDEhISVPYNHz5cZbZgeHg4bt26pXKORCLBq1ev8Msvv6js37BhA4KCggAADRs2VFkrNq27UyqVYteuXSrXpQVIafbt24d27drhyJEj3O9UuXLl0LdvXwDAnTt3uHOXLl3KzR4tVqwY5syZo+klKXJ0DtOTkpIwbNgwPHv2TKvzWZbV+lySOR6PAStT9kOzMpmBa0MIKWhsbW2xadMm9O3bF8nJydz+6OhojB8/Hnv27Mn02ozHbG1tVbZtbGy4x2/fvsXLly9RvXp1neuck/tGR0fj2rVr6NChg873zUt2dnaIjo4GoBz7xbLKoRiaWs+Sk5NVAidzc3P07dsX3t7e3D4fHx80a9aM275+/Trc3NxUWpJkMhkOHjzIbZcpU0blPmbpejHSWv8yw7Ishg4dCgBo0aIFrl27pnI8fSqJkJAQ/Pzzz/j999/Rp08fuLu7o0aNGlmWXxTo3JTx77//4unTp2BZVqsfa2trjB49Wh91/6HxeMApUwlOFBMjMTU5+wsIIT8cFxcXrFy5Uu1L++XLl/jjjz80XhMZGYn379+r7DPLMHwgY8qEe/fu6VxXhUKhtopGftw3r23evBmDBw+Gp6cntm7dCmNjY8TFxWHjxo1q58o0/FE8YMAAlbFSt27dgr+/P7d96NAh9O7dW+Wa169fIzExkdvetWsXmjRpwv3s2LGDOxYeHp5l/evUqZNlioyMGfGTk5Mxd+5cjBgxApGRkZn+nhUlOgdSly9fhpOTE7Zv346HDx/i9evXcHZ2xsOHD+Hv78/9vHjxAm5ubtixYwdGjhypj7r/0BiGwZliEpwqJkVSYpKhq0MIKaBat26tMh4nzeHDhzWOb9LU7Ze+W0iTsLCw3Ffwm9jYWJWWs/y6b16zs7PDzJkzsXTpUlSoUAGrVq1C69atNQYwaa1VGa/v3Lmzyr60NRa/fPmC169fqyVc/fLli8p248aNVYbaXLhwAbdu3cKtW7dUulI1cXBwyPJ4z549NQ5Qv3HjBrp3727w2ZL5QedA6suXL/jrr7/g7u4OMzMz8Hg8dOzYESdPnlQ5TyAQYNy4cfj111+zTYZGtNNcIkTLZAGMDTiQkhBS8A0bNgw///yz2n5N/xZr+jLPOG4m/fR2QDnWRlcZy8yv++rbmTNn1AJUhUKB3bt3o23btti2bRuWL1+eo5aaIUOGqN0jLCwMhw4dQrdu3dRm92UcO5acnAxbW1uNPyVKlMjy3tlldOfz+diyZQuaNm2qdiwiIgLDhg1TaR0rinQOpMRiMapUqaKyr2fPnhqTbjZv3hwRERFqOU5I7vRLMUG/RBHMzWjpAkJI1ubPn48GDRpke56m9DQZA5aMX9TpZ5LllpWVlVoXUn7cV98OHjwIExMTbjsxMRFDhw7FwoULER8fj2XLlmlcsicrzs7OKoGKVCrF9u3bceTIEbVuPUD5Wqb3+vXrXCcr1SbtkYWFBf79919MmTJFLaj7+vWryrI9RZHOgZS9vT1evHihsi9tocidO3eq7E9KSoJYLFZrrSK5k/YLzlIeKUJINgQCAdatW6c2vT0je3t7ODo6quzLuGh9xi64OnXqcI9jY2MxduxY1KlTBwMHDsx2hmAaIyMj1K1bN9f3LQgCAwNx7949ldmSM2fO5FJOlC9fHh07dsxV2RlTIezcuRPlypVTe68AwNXVVWU7NjYWV65c0Vjuf//9p7EVUlsbN25EUFAQeDweRo4ciUOHDqmlPcg45q6o0TmQcnd3x8SJE7F8+XJ4e3tzOaJGjhyJ5cuXY+/evUhOTkZQUBAmT54MmUymNsWT6IgCKUJ+aCkpKRoHKmdkZWWFTZs2cQkdM9OnTx+V7djYWJXttFlogDLvUMOGDbntZcuW4fLly0hKSsKDBw9ylB4hJ/c1NzfHTz/9pHXZ+WHNmjUwMTHhBsmHhoaq5LuSy+Vc92RKSkqOym7cuDFcXFy4bYVCobE1ClA2ZtSrV09l35IlS9QC0+fPn2PXrl0qrU45Darkcjk3ZgtQTnA4cOCASvb54sWL56jMwkbnQGrUqFGQyWTYtm0bVq1axX1onJ2dMWDAAPzxxx+oW7cu2rdvj5s3b4JhGJVcICT3vCxiMdo2ESFfIwxdFUKIAb17905lJldWKlSogLVr12aZpHLQoEGoVKkSt50+p1RsbCyCg4MBKKfwz5s3T2VWYMbxQU+fPtWqXgDw008/qcwCS39fmUzGJX4EgN9//11tVl/GMV8ZW7C0pSkoza6s3bt349SpU7C3t+f2RUVFqZwTFBSEX3/9FevXr0f37t3Vus3i4+O5PEyapB8rZWNjg7Zt22Z67sSJE1Xel+DgYPTt2xfnz5/H69ev4evriwkTJmD69Okq1yUlqU5e0qZLcO/evSqD1s3MzNCqVSsAyp6Tgp6iQlc6B1JlypSBj48PXF1dIRKJVPpxJ0+ejDZt2qikP7C1tdVrArcfmRyAggEA9UGahJCiTSKRIDAwEIsXL0ZAQACuX7+O9evXIzw8XOPA7fTc3d2zTJYoFArh7e3NdQNu2rQJz58/R0xMDBYtWgSZTAahUIjFixejSZMmKtdmXBokJ/mlGIbB6tWruUSce/fuxe3bt5GQkIC///4b0dHR4PF4mDJlitrg+bi4OJXklwAQExODffv2ISaH65FqCmauX7+Oz58/QyKRQCaTQSaTITo6Gg8ePMCUKVOwcOFCAFAJpCpXrqyWC+vChQs4dOgQ/vzzT7XZboMHD85yPFGnTp248j09PbNMS1C/fn3MmjVLJZgKCAjAhAkT0L17d6xYsQJ//vknypYtq3I8Y+B77do1hIeHZ9lSxbIsJk6ciA0bNiA8PBwBAQFcYDVy5EgugWtRxbC6dI5qgWVZ3LhxA2/fvkXp0qXRokULtb8iirq0MWT6Tky217Iq5KlSVN+3GbW652zwIjGs5ORk+Pn5wdXVFaampoauDsmBvHrvUlNT8fHjRzg5OakkOczM0qVLVbpU0hsxYoTGlAcZ/fnnn3B1dUWPHj00Hk9JScGuXbtw4cIFfPr0CWKxGHZ2dmjcuDGGDBmitngwoOx+mzFjBh48eIBq1aph8eLF2U6hz0gmk+HAgQM4ffo03r17h+TkZJQoUQL169fHoEGD1P4tzWzR4vTSpuHL5XKkpqbC2NhYZVagVCqFr68vAgMDcfjw4VzPLu/RowcWL17MbT9//hwLFizAu3fvUKZMGXTp0gWDBw+Gqakp3r59izlz5sDPzw+2trYYPHgwBg0alGX5W7ZswfLly3Hu3DmNr39GT548wfbt2/H48WPExcXB3t4e7u7uGDFihMr7EhgYiHbt2mVazqZNm7hWpvTWrVuH9evXq+wzMTFB5cqVMXDgQHTt2jXbOmaU2Wchu89eXn3XZkfnQCo0NBSlS5fWV32KpLx6c89bVIcsRYryh71RrWsLvZZN8hYFUoVXQQmkSO5kFkgVFg8ePMD69evVJnMVJYUtkNK5a69Nmzb4/PmzPupCcupb/7qCBpsTQkiRExcXp9bNePz4cfTv399ANSKa6BxIsSyLcePGFYpU/UXNRUEqzplKkJBIsyAJIaQoef78OVq2bAkPDw8sXboUgDKwevbsWZaDzEn+0zmQApRNpdOnT4enpycOHjxYKFbkLgqOCVNwxEyCuISinTWWEEJ+NCdOnOBmCqblgNqyZQv69etXKLskizK9rC2yd+9eWFpa4tq1a9izZw9WrlyJ7t27o3///iozAoh+NZIJkSqTw0SU+cwNQgghhU/6pJbBwcGYNm0a3r9/jwMHDhiwVkQTnQOp7du3c+noW7VqhVatWuHz58/Yt28ffv75Z9SqVQsDBw5UmyJLdDdIagZpohjWFpaGrgohhBA96tOnD4KDg3Hs2DEkJydDLBbD29tbbQkWYnh6yWyeUbly5fDbb7/h+vXraNOmDVauXImOHTvC19dXLdkX0UFaLjcabE4IIUUKj8fDtGnTcPv2bTx58gRr165Vy0lFCga9jJHKjEgkQrdu3dCvXz/Ex8dj0aJFaN68ORYsWJCXt/2BfFtrL29TgRFCCCEkE3oZI6VJeHg49uzZgwMHDnDrJbEsi+LFi2uVRIxkb7ooGgkiBdaEh6KWoStDCCGE/IB0DqTq1KmDe/fucanqHz58iF27duHy5cuQy+Vca4m7uzsGDRqEli1bqq0vRHInhWGRygByOS0RQwghhBiCzoFUcnIy/vzzTzg6OuLUqVPcwpksy8LY2Bhdu3bFwIEDi/xaO4YwV2INcWIqShcvYeiqEEIIIT8kvXTtpU3HTGt9KlWqFPr164fevXvD0pJmlOWVkgwfEjkPAn6e9dASQgghJAt6+wZmWRZ16tTBoEGD0K5dO0oYli+oi5QQQggxJL0EUmXKlMHKlStRs2ZNfRRHtHSTl4JkEwm6JMQbuiqEEELID0kvgdSSJUsoiDKAQ/wkxJkr4B4XY+iqEEIIIT8knQOpZcuWoU6dOvqoC8mhWqwQCWIpiomMDV0VQggh5Iekc0LOrl27gsfTvhiZTIYpU6boelsCYKjCEqPjTVDS0sbQVSGEEEJ+SHma2VyTgIAAnDlzJr9vWzSljTVnKY8UIYQQYghade3t3bsXe/fuRb9+/fC///1P5dj69eu1vlliYiLOnTuXsxqSLNASMYQQQoghaRVIrVixAsnJyVi+fLlaIHX69Gl8+vRJ6xuyLEuZzfVkHi8SMcXlWBgWirqGrgwhhBDyA9Kqa69169ZgWRZt27ZVO9arVy+uRcTS0hL29vYoVaqUxh8zMzP91v4HFwcF4vgsZDKZoatCCCGE/JC0apFavnw5Zs6cCWtra7Vj3bt3x8aNG3Hq1CnY29tnW9aBAwcwb968nNeUqJnKWiM1JhllzCh7PCGEFBYfP37E7t27cfnyZVy7di3T827fvo39+/fj2bNniI9X5gssXbo0mjRpgqFDh2r1nUvyntaDzTUFUWn727Vrh+LFi2tVTrdu3VCyZEltb0uyYBsphoOMD2Nq6SOEkAKNZVlcv34dw4cPR8eOHbF7924kJiZmeu68efMwdOhQnD9/Hr/88gsePHiAc+fOwczMDDt27EDnzp3x7NmzfH4WRBO9zNpbtGgRBAKBVueKRCJcv35dH7f94ZnYWygfKGjWHiGEFERisRi7d+9Gly5dMHLkSNy8eTPbCUI7d+7Evn37AAC1a9fGkCFDIBAIYGdnh1mzZgEAEhISMHnyZCjo33+D0zmQGjRoEFJSUvRRF5JDD5CK28ZSxCUmGLoqhBBCNGAYBvXr18fJkyexatUqra7ZvXs397hEiRIqx2rUqAGhUAgACA4Oxps3b/RXWZIrOgdSDx48wPr16yGXy/VRH5IDexVx2GEhRlhMlKGrQgghRAOhUAhnZ2cwDKNxwpYmYWFh3OPHjx8jNTWV22YYBlZWVty2tr1BJO/opWvPx8cHHTp0gI+PT6Z9vkT/qjIiVBfzUUwgNHRVCCGEZCOtJSk7ZcuW5R5HRUVh3bp13LZMJkNsbCwAoGLFinByctJrHUnO6WXRYm9vbzAMg4MHD2LDhg3w8PDAgAEDULlyZX0UTzIxUlAcyeExKGlja+iqEEKKMJZlkSouGmNx5HI5xKlysJCDz1fuMxbxClR+wx49emDFihXc9pYtW8AwDCZPnoxHjx5BIpHAxsYGK1euBD/tSRCD0TmQ6tKlC5o2bQoej4dmzZohPDwc+/fvx5AhQ1ChQgUMHDgQbdq0ydF6fEQ7aR98Vk6ZzQkheYNlWYz97Sle+MUbuip5poarBTYurVVggqkhQ4bg0aNHuHr1Krfv33//xZMnTyCXy9GhQwfMmjULdnZ2BqwlSaNzdLN8+XKVIMnOzg4TJkzAtWvX0KdPH/j4+KBNmzbw9vZGTEyMrrcjKpQBFCOXGrgehBBC9MXIyAjr169H//79VfY/fPgQT548wbt372gYTQGil649jQUbGaFTp07o1KkTHj58iF9//ZXr9uvXrx9q1KiRV7f+YSyWRCCsuAS/hYegvqErQwgpkhiGwcaltYpY114qRMbGXLdYQevaA5Tfoe3bt8fVq1fRrFkzHDlyBFKp8o/mDx8+oG/fvtixYwdcXV0NXFOSZ4EU8D1767Fjx5CcnAyWZXH06FG8efMGR44c0bn8ixcvYvv27Xjz5g34fD4aNGiAsWPHomrVqnqoPRAXF4fLly/j9u3biIqKQqVKldCmTRu4u7vrpXxdRUGOSD4LsVRi6KoQQoowhmFgYlw0xuLI5QADPoyN+QV2fJFUKsXcuXNx5MgRdOrUCQsWLECPHj0watQobqB5XFwcxo0bh3Pnzmk9iJ3kDZ0DqUWLFmH27Nkq+65fv45du3bhzp07YFkWLMuCz+ejTZs2GDRoEOrVq6frbbFy5Up4e3ujdu3auH37NsLDw+Hp6Ylr165h1apVaNeuXa7LTkxMxPr167F//344Ojpi9OjRaNeuHYyM8jTuzLHxxiURFxKD8sUpUzwhhBQVy5Yt4xobWrVqBQCoVasWvL29MWjQIC4dQkhICM6ePYtu3boZrK5ED2OkfH198fDhQ0RHR2Pnzp3o0KEDRo8ejdu3b0OhUMDc3BxDhw7FxYsXsXbtWr0EUYcOHYK3tzcAoHfv3jA2Nka5cuXQrFkzSKVSTJo0KddJyp48eQIPDw9s374d//vf/3Do0CF07NixwAVRAFCeb4yKMj5MjUSGrgohhBA9iI+Px969e7ltBwcH7nHNmjUxaNAglfNfv36db3UjmukcHbAsi4EDB6psA8r8FgMGDICnpydMTEx0vQ1HIpFgw4YN3LajoyP3uFy5cgCUzaKrVq3Cpk2bclT2rVu3MGbMGEgkEgwYMAC//fabfiqdRxjet1l7oFl7hBBSFHz69IkbCwVAJfkmoEyNkNaQAICSYRcAemtmYVkWDMOgRYsWGDRoEJo0aaKvolXcvXsXoaGh3LZZugV70/cT37hxAwkJCTA3N9eq3I8fP2L8+PGQSCSwt7fH1KlT9VfpPPJMloxIkRTuCUV3WjIhhBQVGdfF07TmnrW1tcp2VFQUypcvz23b29urHK9Zs6b+KkhyRS/JnXg8Hvr06YOzZ89i8+bNeRZEAcC9e/dUtjNLjy+Xy9XOzcrMmTORnJwMAOjbt69eW9Hyyp7UKGyxFONzZLihq0IIISQbGVMWpKamqgVXDg4OqF//+zzs27dvqxxP35VXpUoV/PTTT3lQU5ITegmkpkyZgj/++EMlas4rT548UdnOauzS06dPtSrz+vXrePz4sco9OnfujAYNGqBp06aYPHkyAgICclXfvFTRyBjOEj5MZdS0SwghBVlqaiq2b9+usk8mk2HHjh2QyWQq+5ctW8YNVdm+fTuXmPPDhw+YP38+AKBy5crYvHkzrbVXAOjctefu7o5evXrpoy5aiYiIUNnOKmN6VJR2i/kePHiQe2xlZYUpU6agdOnSWL16NXbt2oXTp0/j6tWr+Pfff/UyWF5fBsYIIEsyQfHSDtmfTAghxCDq1KnDpQDKaMmSJVi+fDl69+7NBUmlS5fG0aNH4evri0uXLmHq1KmQyWQwNjZGlSpVMGfOHPTq1QsiEU00Kgh0DqTq1q2LBg0aoFGjRmrRdl7ImB09qyRq0dHR2ZanUChUmk6LFSuGKlWqAAB+//13XLx4EWFhYUhOTsbUqVNx4cKFXOXsYFmW6zrUF1OH4oj3D4UiD8omeSslJUXl/6TwyKv3TiwWQ6FQQC6X0wDiPJQWzLAsm2+v83///afVeenrY2xsjGHDhmHYsGFanV+UyOVyKBQKpKSkqHR9ZvfZSxurnd90DqS2b98OlmXzbQpm+tkM2dEU/WcUGBiYaRBiZGSEFi1aYP/+/QCAL1++4OrVq+jQoYPWdUgjlUrh5+eX4+uywhgpk8mJU1L0XjbJH58+fTJ0FUgu5cV7Z2RkBLFYrPdyiTp6nQsusVgMmUyGDx8+aDye1WfPEMlJdQ6kHBwc8ObNG0yZMkXra0JDQ1G6dOlc3c/CwkLrLruMsx80ydjClXHgX1rrVJrnz5/nKpASCASoVKlSjq/LytD4UHywScbwqHAMoGUCCpWUlBR8+vQJ5cuXLxQTG8h3efXeicVihIaGQiQSwdjYWG/lElUsy0IsFkMkEhW4ZWHId0ZGRnB0dFTpvszus/f+/fv8rCJH50Bq9uzZGD58OJo1a6bV+XFxcWjTpk2uW1Ds7e1VAqmsWp1sbW2zLS/jP1gZW6cyrq4dH5+7VAMMw8DU1DRX12YmTC5BiJECqVKx3ssm+cPExITeu0JK3+8dj8cDj8cDn19wly4pCtK6wxiGode5gOLz+eDxeDAxMdH4R0Vmnz1DBcY6z9qrV68eduzYgXnz5mnVvafrGntubm4q21n1EdeuXTvb8jIGSomJiSrdhxnfRBsbG22qmS+GWJXCxBhjVLG2z/5kQgghhOidzi1Sv/zyCxQKBcRiMXr16oVatWppjPJZlkVYWBiCg4N1ul/jxo1V0uenrTmUEY/HU5lhFxAQgGnTpiE4OBj9+/fHr7/+CkAZGLm4uMDf3x+AMjALDg6Gk5MTAPX0CvruntNFZWMzlJAawVxAC1YSQgghhqBzIMUwDB48eACGYcCyLB49eqTVNbnVsmVLFC9enOvei4uL446lb51q0aKFSmr9OXPm4NWrVwCAjRs3okGDBnB3dwcAeHp6YsmSJdy5/v7+XCCVfnaAiYkJWrduneu6692315FhFdmcSAghhJC8oHMg1bdvX9y9exf29vaoVasWhEJhprmdUlNTcffuXZXgJ6eEQiEmTZqE2bNnA1CO3m/YsCEAIDxcmeFbIBBg4sSJKtdl7HZ8/fo1F0j1798fhw8fxrt37wAAV69eRceOHQEoZ/WlGT9+PIoVK5bruuvbW0kyQoUyuCUlZn8yIYQQQvRO50CqTZs2sLOzw+HDh7UaP/To0SMMGDBAp3v26tUL79+/h4+PDw4fPowuXbogISEBly5dgkAgwLJly+Di4qJyjYuLi0pW9KpVq3KPhUIh/vnnH4waNQoBAQE4c+YM+vTpAycnJ+zbtw8A0KdPHwwZMkSneuubb+wXvLZKxXC/Z+hs6MoQQgghPyCdAyk+n5+jAKNGjRpo1KiRrrfFjBkzULNmTezcuRMtWrQAn89Ho0aNMG7cOLUgCgAWLVrEjZEaMGAA1xqVxsHBAQcOHMCBAwdw6tQpjBgxAqampnB2dsZvv/2GVq1a6VxnfVOIpXCS8mBrW9LQVSGEEEJ+SDoHUoBywLk2YmJicO7cOb1lQPfw8ICHh4dW51aqVAlHjx7N8hwzMzMMHToUQ4cO1Uf18tz8ytURdcsfJUqUMXRVCCGEkB+SXhYt1pZQKMSWLVu0yjhOsifkG0EABqDB5oQQQohB6NwiNWPGjGzPYVkWKSkpePXqFUJDQ3H58mW0bdtW11sTbtYeBaaEEEKIIegcSB09elTrdAZpLVG7du2iQEoPdoR/xjPrZPQOD0YTQ1eGEEII+QHpZYwUn8+Hs7NzlsslfP78GdbW1rCwsKCuPT0JkaTik0CBWLF+V6EnhBBCiHb0Ekht2rQJTZs2zfKcz58/47fffsOaNWsK1DIrhdnPJR3QMCgFVa1p1h4hhBBiCDoPNjc3N9dqTbty5cqhU6dOGDZsWKbLupCcqVLMAjUlRighokVvCSGEEEPQOZD677//tM723b17d/j5+WHjxo263pYAQFoGeZq1RwghhBhEvqc/4PF4OHnyZH7etsgKTEnCa4EMkSlJhq4KIYQQ8kPK10DqwIEDUCgUiI2Nzc/bFlmHIgKx2joVp4P8DV0VQggh5IeUL3mkpFIpPn36hFevXoFhGNSsWVPX2xIAErkMJWUMyptZGboqhBBCyA8p3/JIpaU8sLS01Cr4Itmb4VwbEafvw6qEg6GrQgghJAtyuRwHDhzAoUOH8P79e/D5fLi5uWHMmDFo2LCh1uXs3r0bCxcuRPfu3bFkyZI8rDHRlt7ySLm4uMDExETtGMMwEAgEsLKygrOzM3r27InixYvr47Y/PBbMt/8oLxchhBRUCQkJGDNmDP777z+V/Xfv3sX9+/exfPlydO7cOdtynjx5QsFTAaSXQGr16tWUqdwQGOUQN2lUnIErQgghJDOTJk3Cw4cPYW9vj/j4eCQnJ3PHFAoF/vjjD7Rt2xbGxsaZlhEVFYVff/0VUqk0P6pMckAvg82zS8ZJ8sbRoAAss0rG9chgQ1eFEEKIBseOHYNMJsPFixdx/fp1PHr0CHPnzgWP9/3rNz4+Hm/fvs20DLlcjokTJyI8PDw/qkxySOdA6tWrV1lG0STvhLNSvBcqEElLxBBCSIEUFxcHb29vODgox7LyeDz0798fPXv2VDnPysoq0zJWrFiBlBT6d76g0jmQ4vP5mR7z8/PD2bNncefOHYjFYl1vRTLoWLEKRscZo25KvmaxIIQQoqXBgwdDKBSq7Xd1deUe161bF46OjhqvP3fuHK5cuYJFixblWR2JbrQeI5VVNJxxkLm/vz9mzpwJPz8/bp+ZmRmmTp2KPn365KKaRJPKJe1QTGwEkYW1oatCCCnCWJaFTG7oWuiHXA5I5QBfBii+zSY34kOr2ef69OTJEwCAo6MjVqxYofGcgIAALFy4EFu3boWZmVl+Vo/kgNaBlJeXF+7cucNtMwyDqlWrolq1avjjjz+4/W/evMGgQYOQkJDApTwAlLMW5s+fj/j4eIwYMUJP1f+x8Sy/fbCkMsNWhBBSZLEsi/23gNBoQ9dEX3gAVNcnLW0D9GnK5lswdeXKFZw+fRoAMGLECJQuXVrtnKSkJIwfPx7Tpk2Di4sLgoNpLGxBpXUgtWLFCri7uwMAfv75Z4wePRply5ZVOUcqlWLy5MmIj4/nfiE7deqETp06ISkpCdu3b8fq1avRrFkzuLi46PFp/JjCUpPxViCHzecgQ1eFEEJINs6cOYMTJ07g2rVrXEPDnDlzcOvWLaxcuRICgYA7d8aMGahfvz48PT0NVFuiLa0DKX9/5TIks2bNwsCBAzWes337dgQEBHDbGc9t3749fv75Z/j6+mLhwoW5rTP55tiLZzhhnYLOsMBgQ1eGEFIkMQyDPk2LUteeAqniVBiLjMHnK8eX5lfXHsMw4PP5YBhGpcfm/PnzcHJywqRJkwAAW7duRWhoaKZdfqRg0XqU8pUrV9CiRYtMg6jo6Ghs3rwZDMOAYRi0adNG7VyRSITx48fj3r17utWaAACszc1hJ2Ngnr9LJhJCfjAMw0BgVFR+AAEfyv9/25dfXXodO3bEhg0bcPjwYZQvX17lmK+vLwDgwYMH2LZtG9auXatxkDopeLT+Br53716mQRQA/PPPP0hKSgLLshAIBPjtt980nufm5oaIiIic15SoGeTeEAuji6EdS4MQCSGksKhatSp2796NkiVLcvsSEhIQHR2NI0eOIDIyEq1atYKzszP306ZNG5Uyjh49CmdnZxw5ciS/q08y0DqQCgsLQ7Vq1TQeCwoKwr59+7jWqL59+3I5MzIyMzNTSURGck/Ofks9oaAlYgghpDCxtbVVa3DQtMwaKfi0HiMllUohk2meHbZ8+XIubb2FhQXGjh2baTkhISGwsbHJYTWJJnJ8a45mKZAihJDCpn379hAKhZBIJHB1dYWJiQlsbW3h5OSkdq5MJkNQ0PeJRWZmZrC1tYW5uXl+VplooHUgVaZMGTx8+BAdO3ZU2X/58mVcuHCB62MeO3YsLC0tMy3n4sWLqFGjRi6rS9I7//oFLlqmoC746GDoyhBCCFETGBgIkUgEOzs7tWNCoRDm5uaIiorC4MHKKUNTpkzBlClT1M4NDg5W6d5r164dLWBcQGjdx9aiRQusWLFCZa2fjx8/YtasWVwQVbly5SzHUUVERMDX1xdNmjTRocokTXBMDF6J5HjIJGd/MiGEkHx19uxZtG/fHi1btsTq1auhUChUjoeEhCAqKgodO3akNAeFmNYtUkOGDMHhw4fRrVs3tG/fHgBw6tQppKSkgGVZiEQiLF68ONMlY6Kjo+Hl5YXY2Fg0btxYP7X/wbmWLIHhcSKUEZlmfzIhhJB8FRkZCZZlwbIs/vnnH9y5cwfTp09HrVq18OXLF0ybNg0DBw7Eb7/9lu+Z1Yn+aB1I2draYu3atRgzZgwOHjwIAFweDGNjY6xYsULjYHR/f39cunQJe/fuRVRUFBiGocHmelLfrRE++FyDuSDz9Q4JIYQYRv/+/SEWi3HmzBl8/PgRL168wOjRo1GuXDnUrl0bCxcuROXKlQ1dTaIjrQMpAGjYsCFOnTqFf//9F48fPwbLsnBzc8PQoUNRoUIFtfN///13JCcru53q1q3L7V+1ahWWLVumY9UJwwNMWYZm7RFCSAHE4/EwfPhwDB8+XOeyypYtizdv3uihVkTfchRIAUDp0qUxb948rc6lgXB562uqDE+FMpjyGPxk6MoQQgghPyDqYyvE3oWFY6NVKg4IkgxdFUIIIeSHlOMWKVJwmFtYoryUh1IyiocJIYQQQ6BAqhCrXNkFM2OUM/ZYuRxMJjMmCSGEEJI3qCmjEFMYf097IE8VG7AmhBBCyI+JAqnCTPR9ZXB5IiXlJIQQQvKb1oHU4cOHMWnSJHz9+jUv60NyIDjsC/60TsZayxQoxBJDV4cQQgj54Wg1RurOnTvcUjB169bFgAED8rpeRAsSiQSfBQpYyxkopJoXlCaEEEJI3tEqkPL29gYAODo64qefKGNRQWFXsjQmppiBnyoDK5UaujqEEELID0errj0/Pz/Ur18fBw8eRIkSJVSOHTt2LC/qRbRgaloMNSGCs9QICjEFUoQQQkh+0yqQYhgGixcvhoWFhdqxGTNmqK1onRWFQoHq1atrX0OSKRYMpAnK2XqyhEQD14YQQgj58WgVSFWuXBmmpqYaj6UtXKythIQEyGQ0nkcf5PJk+BVj4SeQAbQQNCGEEJLvtPr27dOnDxYvXoyYmBi1YwzDgGEYrW4mk8mwadMmrc8nWfsUGoNVxZLgbZkK5KBVkBBCCCH6odVg886dO+Ps2bNo3LgxzMzMYGpqCj6fzwVEbdu2zbYMuVyO6OhoSGlQtN6IBEKUgxFEMgVYCqQIIYSQfKf1EjGrVq3CihUrsGfPHiQkJKgcCwkJydFNqUVKPyytS+NPfkkkx8aDlcsNXR1CCCHkh6N1ICUUCjFz5kx4eXnh7t27+PLlCxITE7FhwwaMGTMGvGzG6EilUnz9+hXnz59HcjJl4dYHqYIPhqcMSlk5tUgRQggh+S3HixZbWFigQ4cO3PaGDRvg5eWVbSCVpmPHjhg5cmROb0s0UCjSte5R1x4hhBCS73IcSGWU01l7DRs2zPE1RLOE5ESsl0Yg1VqGI5TZnBBCCMl3OgdSly9f1ro1ClB2ET5//lzX2xIAUpjgDSsBBIAkJcXQ1SGEEEJ+ODoHUmXKlMnxNUKhUNfbEgB8gRCTRSUgDU8EI6cWKUIIISS/6RxIpSeVSnHx4kU8ePAAX79+hYWFBcqXL4/27dvDyclJn7ciAJJTGdTnmyJBkgp5RJShq0MIISQTYrEYjRs3RmJi5qtQDBkyBL///ju3LZFIsGvXLhw+fBhfvnyBubk52rRpAy8vLxQvXjw/qk20oLdA6vr165g7dy4iIiLUjq1evRru7u74448/4ODgoK9b/vBsi4uQEqFMRSGwKGbg2hBCCMnM5cuXswyiBAIBfvnlF247NTUVI0eOxP379/HLL79gxowZOHPmDCZNmoRLly5h586d1EBRQOhlXZFjx45h7NixiIiIAMuyGn/u3LmDrl274smTJ/q4JQDg4sWL6NevH+rWrYsGDRrAy8sLr1+/1lv5ALB79244Ozur/JVQUPCNGATam+CFUJblB5QQQohhHT9+PMvjHh4esLe357bnzp2L+/fvAwAGDhwIQDnr3draGhERERg2bBjEYnHeVZhoTecWqU+fPmHu3LmQy+UoW7YsunfvjoYNG6JChQowNzcHy7KIiYnBy5cvsWfPHowbNw6nTp2CjY2NTvdduXIlvL29Ubt2bdy+fRvh4eHw9PTEtWvXsGrVKrRr107Xp4YnT55gyZIlOpeTVxRyFiuTwpBgpUDj6Cg4G7pChBBC1ERFReHBgwd4+PAhzM3Nsz3//fv3OHnyJADAyMgIZcuWBaBMd1OuXDnExMQgJCQEvr6+GDp0aJ7WnWRP5xap7du3QyqVwsvLC2fPnsW4ceNQr1492NjYQCAQQCgUws7ODm3atMHWrVvRrFkz7N27V6d7Hjp0CN7e3gCA3r17w9jYGOXKlUOzZs0glUoxadIkvHnzRqd7REVF4ddffy3QS9pYWhjB0cgYjlIeeDTYnBBCCqTTp0/D3d1dqyAKAI4cOQLFt9yApqamKsfST9Y6deqU/ipJck3nQOrOnTsYOXIkvLy8IBAIsj3fy8sLly5dyvX9JBIJNmzYwG07Ojpyj8uVKwdAOeh91apVub6HXC7HxIkTER4enusy8gOfARbYlMHsGFOUSCi4AR8hhPzIjh8/jitXrqBevXpo3bo1Ro0ahY0bNyIoKEjj+WldegCy/F718/NDTEyM3utLckbnQCoiIgJ9+/bV+nxra+tMf3m0cffuXYSGhnLbZmZm3OP0kfqNGzfU1gTU1ooVK5BSCPIy8Y0YSFOUa+wlBgQauDaEkKKKZVkoFIoi88Nm3M7DJNEBAQF4+fIlWJZFQkICQkJCcO3aNaxZswbt2rXDxIkTERX1fda1WCyGn58ft21klPkIHIVCQXkZCwCdx0hZWFioBDPZefjwoU6LFt+7d09lO7NoXS6X4969ezkeK3Xu3DlcuXIFa9asQbdu3XJdz/ygULAwtTUH3kcgNUR9tiQhhOiKZVmEhoZCnJpq6KrkGZGxMUqXLq3Td1NmTpw4kekxlmVx9uxZ/Pfff9i5cycqVqyIyMhIyNMtQp9dwuv0QRgxDJ1bpFxdXXH16lWtzg0LC8OCBQtQoUKFXN8v46y/rKL1p0+f5qjsgIAALFy4EGvWrMlRcGgoIiEPaxPD8Jd1Mj6yNHuDEEIKEpZluUHjWYmMjMTYsWMhkUjUuuqyC6Sio6N1qiPRnc4tUr1798bMmTNhbW2Npk2bajwnKSkJBw8exD///IP4+HgMGTIk1/fLmKcqq1+ynETqSUlJGD9+PKZNmwYXFxcEBwfnuo75hWGAT6nJ+CRQIOL1e0NXhxBSBDEMg9KlSxeZNVLlcjnEqakQGRuDz+cDUD7HvGiNYhgGV65cgUQiQWJiIj59+oQXL17g/PnzePTokcq5nz59wsmTJ3OcG6qovC+Fmc6BVNu2bXHixAmMGDEClStXRt26dVG8eHHweDzExMTg3bt3ePz4MaRSKViWRdWqVdGvX79c3y9jtJ7VL39OIvUZM2agfv368PT0zG3VssSyLJKTk/VaplQmw6/1auHt4f9QsVQpvZdP8k7aGLzCMBaPqMqr904sFkOhUEAul6t07RD9YhgGDI8HhmG4ICSvgxE+nw9LS0vUrFkTNWvWxIABA/DkyRPMnz8f79694867ffs2atSooXIty7Iqvw8Z62ppaVnkfl/kcjkUCgVSUlK42YtA9p89lmXzJCDOjl4ymy9duhRGRkY4c+aMyi9FmrQ3vlatWvjnn3+4vwJyIyfpCLT9cGzduhWhoaFYsWJFbquVLalUqjKAUB9io4RoVKU8TCVPYJQq03v5JO99+vTJ0FUguZQX752RkRElWcwnhn6dXV1d4ePjg/Hjx+Px48cAlA0FlpaWKkGeQqFAarrxaekDCwCwsrJSOV4UiMViyGQyfPjwQePxrD57hljLVy+BlImJCf7++2906dIFvr6+uHPnjsqb7eTkhAEDBqBv377Z9vdmx8LCQusuO2tr62zPefDgAbZt24aDBw/m6RsgEAhQqVIlvZaZoogFz0gZlMoiYuDq6qrX8kneSUlJwadPn1C+fHmYmJgYujokB/LqvROLxQgNDYVIJIKxsbHeyiWqWJaFWCyGSCQySOtFesbGxli5ciXatWsHmUwGBwcHlChRAk5OTlwQoVAoVH4f0n+H8ng81KtXr0j+vhgZGcHR0REikYjbl91n7/17wwxx0euixa1atUKrVq2QnJyM4OBgpKSkwN7eHnZ2dnq7h729vUoglVWrk62tbbblHTlyBJGRkWjVqlWW5x09ehRHjx7F4sWL0aNHD+0r/A3DMGqJ1XQlECTjbVwc/AQylJXxYSISgdGhtY/kPxMTE73/XpD8oe/3jsfjgcfjgc/n69RqT7KW1g3GMEyBeJ1Lly6NevXq4d69e2jatCn4fD6aNGnCBVKpqakq9Uwf/Dk7O+u8SkhBxOfzwePxYGJiojFIzOyzZ6jAWC9r7WVkamqKKlWqoGbNmnoNogDAzc1NZTurvuHatWvr9d4FDsNg2dV7WGWdigCBHLIkGm9DCCEFiUQigb+/f5bdbxYWFnByckLbtm0BAD179uSOJSYmqnzPpX9c0FP0/CjyJJDKS40bN1bZzuyXM63JM01AQAB69OiBBg0aYM2aNdx+W1tbODk5qf04ODiolGdmZgYnJyetU/znB4YBHGytUFrGg4gFpJGU4ZYQQgqSQYMGoVu3bmjSpAm2b9+uNsYpOTkZb9++xZo1a7huO1dXV3Tt2hWAsmsvMPB7wuWwsDAAylU9+vTpk0/PgmSl0AVSLVu2RPHixbntuLg47nH6SL1FixawsrLitufMmYNXr14hLi4OGzduxN27dwEAU6ZMwblz59R+fHx8VO7brl07nDt3Ti+LIesLn8fDym5NMD/aFK5SI0TffpT9RYQQQvJNUlISAGXL0pIlS9C3b188evQICoUCYWFhWLduHZYvXw5nZ9Vl5xcsWIC6desCAHx9faFQKHD9+nWEhITA1tYWGzdupGEBBUShC6SEQiEmTZrEbacfvZ+2Np5AIMDEiRNVrnv9+nWW24URn2EhMbcFT6DsP5dEUmI2QggpSHx8fDBo0CBUqFABIpEIr1+/xrRp0zBhwgTcu3cPEydOVBuyAijHAfn4+GDSpEm4ffs26tevj7lz52LgwIE4ceIEKleubIBnQzTR62Dz/NKrVy+8f/8ePj4+OHz4MLp06YKEhARcunQJAoEAy5Ytg4uLi8o1Li4uKlnRq1atmt/V1jsjIwAMD7a1yyD8QSC+HDyLCpOGGrpahBBCvilevDhmzZqVq2uFQiFGjx6N0aNH67lWRJ8KXYtUmhkzZmDVqlXg8Xho0aIFunXrhkaNGuHQoUPw8PBQO3/RokWoWrUqLCwsMHbsWLi7uxug1vrFZ4C1Z65hRtAHvBDKYFrR0dBVIoQQQn4ohbJFKo2Hh4fGoEmTSpUq4ejRo1qXXbZsWbx58ya3VcsXfD7wNjQCr+WpqMcTgS1i2W0JIYSQgq5QB1I/Oj4P+KVtY7Rg+TC+EYio6w8MXSVCCCHkh6LXrr3AwEBcunQJEomE2xccHAx/f3993oZ8IxDwUMexNFpa28BWwYPItnj2FxFCCCFEb/QSSIWHh2Po0KHo0KEDxo8fj4SEBO6YSCTC6dOn0bt3bzx4QC0m+mQs4kEmMoNZWSsAQMKrt4atECGEEPKD0TmQSkhIwIABA3D37l2Ny7XY2tpiypQpmDt3LsaNG4c9e/boekvyjVDAQ6DcBGdDvuCeSPvFnAkhhBCiHzoHUlu2bEFQUBBEIhFq1KgBIyPNw66qV6+OwYMHY9GiRfjvv/90vS0BIBAwePkxEPNvPcFOC+VK5kkBgdlcRQghhBB90TmQunDhApydnXH58mUcPHgQlpaWmZ7buHFjKBQKeHt763pbAuUCjbZ2ZWBnboqmKQIAQMy9J9lcRQghhBB90TmQCgkJwezZs1WWbclMWmvVs2fPdL0t+aZCxSq4Oak3Rtsr1wYMO3LewDUihBBCfhw6B1ImJiZaZwm/ffs2AEAqpfE8+qJglG+hOEo5wD85IMiQ1SGEEEJ+KDoHUs7OzggKyv7LOzAwEFu3bgXDMHByctL1tuQbBU/ZyleynjKrOc3cI4QQQvKPzoFUjx49sG7duizPefz4MQYNGoTExEQAQNeuXXW9LfkmkRWg7lJfdH7+GCmMctakLDHJwLUihBBCfgw6Zzbv1q0bTpw4geHDh2PAgAFQKBQIDg5GSEgI/P39cfHiRdy+fZtLjVC9enUMGDBA54oTJZ7ABIliKVgASQwLE5bBees6+CnhOfjGIkNXjxBCCCnSdA6kGIbBunXrMH36dG6F6v/9738q56QFUQ0aNMDq1aszTZFAcs7aXIGVPZqjZWUHvFpzHymBYQCASw5N0eErpZkghBBC8pJeIppixYphw4YNuHPnDo4dO4anT5/i69evkMlksLa2hpubG7p06YL27duDYRh93JJ8E5fEh0f1CmBYFs1OLMX1jlMh/vIVsth4JH8Khmn5soauIiGEEFJk6bVpqHHjxmjcuLE+iyTZkCsYiEtVgvTjK3y5fwOt3l3BObMaAIAHnYej5ctzBq4hIYQQUnTpddFikv8ULHDkyi1MPXoTvneegS8Sfj8moTQThBBCSF7SSyClUChw6NAhbNq0CampqSrHHj58iN9++w2XLl3Sx61IBiwLRLICXHsXjJCoGABA7T2rAAApH4MNWTVCCCGkyNO5a0+hUGDMmDG4ceMGAMDGxga9e/fmjterVw+VKlXCzJkzsXPnTqxduxZWVla63pZ8w/D4aONeH5XZeJR2UGY3t6jpyh1nWZbGpRFCCCF5ROcWqd27d+P69etgWRYsy8Le3l7tHCsrK6xZswbR0dEYNmwYJBKJrrcl34iM5ChnZwuPak6oXbqEcl/J78v1JNMixoQQQkie0TmQOnr0KEqUKIFx48Zh27ZtaN68ucbzBAIBhg8fjlevXmHnzp263pZ8E5PIQG5iDplCgdCISACAkaU5d/zLYRpsTgghBcnHjx+xcOFCtGzZMsvzJBIJtm7dCg8PD9SuXRvNmzfHH3/8gaioKK3uI5FIcPz4cfz888/w8fHRveJEI5279j58+IBdu3bBzc0t23OrVKkCADh27BiGDx+u660JlOkPYgRi3PH7jFdfojB/kjK3l2lFRyQHBCLp/WdDV5EQQn54LMvixo0b2LVrF27dugWWZWFubp7p+ampqRg5ciTu37+PX375BTNmzMCZM2cwadIkXLp0CTt37sx0ubWvX79i37592LdvHyIjlX9gd+7cOU+eF9FDi5SRkREXIGUnLYoODKTuJn2JT+ZBLDTBxMPX8e+dl5CKlYP9S7RyBwAE+xw2ZPUIIeSHJhaLsXv3bnTp0gUjR47EzZs3uSTVWZk7dy7u378PABg4cCAAoGPHjrC2tkZERASGDRsGsViscs3r168xffp0tGvXDuvXr+eCKJK3dA6kKlasiI8fP2p17r59+wAAFhYWut6WfCOXszAvXhIAcHBoJ8T7PwUAFKtSnjvHf9ZKA9SMEEIIwzCoX78+Tp48iVWrVml1zfv373Hy5EkAysaKsmXLcmWVK1cOABASEgJfX1+V60QiEebNm4dbt26hZs2aenwWJCs6B1IeHh7466+/1CLj9ORyOZYsWYLLly+DYRg0bdpU19uSb1LlAhgJhVjXqxUcrM1hnhILAHCaMJg7J2CZt4FqRwghPzahUAhnZ2cwDIO2bdtqdc2RI0egUCgAAKampmrlpTl16pTKsYoVK6JYsWIwMzNDo0aNdKw50ZbOgVS/fv0QFRWFLl264ODBgwgJCYFcLodYLMb79++xY8cOeHh4YMeOHQAAY2NjjBs3TueKEyVWpky62aZ2dZiJBJBHhwMAGD4f7le//7UiiY41RPUIIYR8kz4Iykpalx6gnKiVGT8/P8TExGg8ltV1RL90HmwuFAqxefNmDBkyBHPnzs30PJZlYWJigtWrV8PhW74jojtxqjKVxAeFCPcevcHixbsRGKxsjbKsV4M77/WkP1Frx3KD1JEQUrixLAvIisZKCaxcDsgkYKU8sAq+cqeRoMDk2xOLxfDz8+O2jYwy/5pWKBR4/vw5WrRokR9VI5nQy1p7Dg4OOHr0KNasWYPDhw8jJSVF5Tifz0fr1q0xadIkVKhQQR+3JN/ERicBEOHcszdYf/4BHK3NoVAowOPxwDcWgV/MFPKkZITsOQGT8mXg/MdEQ1eZEFKIsCyL1OPeUIQXrUlC6Qej8OzLwbjriAIRTEVGRkIul3PbPF7WHUfapkIgeUdvixabm5tj9uzZmD59Ol6+fInw8HCwLIvixYujevXqKFasmL5uRdKRypT/7zFyPNYfPIndg3+C+M5ZmDTtBACoe2g9HnQcCgB4/9c/FEgRQnKuAAQYP4qMXXXZBVLR0dF5WR2iBb0FUmmEQiHq1KmT6XG5XI6VK1di+vTp+r71D0mcIgEggkBkjGMju8DKRIQv9y5BCCOUbdoBtm2boMWrc7he7ScAgCwpGUbFTLMulBBCvmEYBsZdRxSZrj3lGN5UiETG4PMLXtdeTlf+0CaVAslbelm0OCc+ffqE7du35/dtiyw+7/uHqMqAX/EiNBJ7/vNHwz5DkZqcBAAoVrk8d855q9pQyGT5XU1CSCHGMAwYgbDI/MAow74CEkQBgKWlZY7Ot7a2zqOaEG3prUXq1atXePHiBeLj4zONqBMTE3HhwgV93ZIAMDMFopNFsDEVQ2pRAlbt/od/dvwCALi/bxtaDB0PhmFgWaca4h6/AgDE3n8GmyZ1DVhrQgghmtjZ2YFhGK6lKbsWJ1tb2/yoFsmCzoFUXFwcJk6ciHv37ml1PsuyBSr6L+zKl2YhkSmbp8ViCWq1aocl3ZqiU7XyMEmX97Tp/SM4LXAGAASs+JcCKUIIKYDMzMxQoUIFBAQEAABkWfQg8Hg81KpVK59qRjKjc9feggULcPfuXbAsq9UP0TNWBrFc+TYy3/r7+wweBiGfD0VUmMqplnWqAQAiTl2FNCYuf+tJCCFEK40bN+Yep6amZnqes7NzjrsCif7pHEjdvHkTDMOgU6dOOHr0KB4+fAh/f/9Mf7LKNUVyztociE0RAQC4P1zsyyEsPhmB0fEq56bPI/XCa34+1ZAQQggALlt5mswaF3r27Mk9TkxMVEmHkP5xt27dtL4XyTs6B1ICgQCmpqZYsWIFXF1dYWZmluX53bt3p5YpPeLzAZZVdpVKJckAgAQjU7RYcxBt1x+BPF2zsJlLRfDNlDP2vhw4A2lsvHqBhBBC8kRiYqLKdmpqqsaAx9XVFV27dgWgDIgCA7/n8AoLU/Y0ODo6ok+fPlrfK+M20R+dA6mWLVvC1NRU63FPJiYmuHz5sq63Jd/w+d+zm8sUyiUBTC2tAAAz2tdH2KNbKufXP76Ze3zBtn7+VJIQQn5wqampajPWZTIZduzYoXEc1IIFC1C3rnIsq6+vLxQKBa5fv46QkBDY2tpi48aNauvwpXn//r3a9+yZM2cQFBSkp2dD0tM5kBo/fjxkMhn8/f21Ol8mk2HZsmW63pZ8Y2LMICRMmd9FwFMGVCZm5hjUwBUNy9nDlqf6AS3evAHsun1fOJPW4COEkLxVp04d1KpVCxs3blQ7tmTJEri5uWH+/Pkq+01MTODj44NJkybh9u3bqF+/PubOnYuBAwfixIkTqFy5slpZ3t7eqFGjBjp16oSQkBCVYwEBAWjbti1q166N0NBQvT6/H53Os/bs7e2xbt06LF++HJs3b85yXSAACAoKohQIemRejIFE9j0eTpsVOW/4AIgD30D28TWE9VVXHK93aAM3g08SGQOhjVV+VpkQQn4ojx8/ztV1QqEQo0ePxujRo7U6f+TIkRg5cmSu7kVyT+dAav369QCUY6VGjRqF2rVrZ3quWCzG+fPndb0lSYfPBz58SABaKIMpiUQCkUgEWFjDLywaPRftxPMm3VG8jOpC0cZl7ZEaHIbwU1dgNnmYIapOCCGEFHo6B1Jnz57Fhw8fuO07d+5keT7lkdIvhmEgFn8fvC8WiyESiZBgVwmj9l4CALRv2xqP/N6pXJcarByw+HHVdlSkQIoQQgjJFZ3HSPXt25cLjqytrWFnZ4dSpUqp/djb28PY2FgfdSYZmJjyEZmkfG2TkpTLwthWqYZ6FR0wu0MDXB7/s9pMSadJyoWMxWFfaRYlIYQQkks6t0h5enpi8+bNOHbsGIoXL57t+fv371cbVEd0U7YEAyFfmVtEnC5527+HTyJl1xIoWBbyoLcwcnTmjtl3bYOPq7YBAKKu3kOJ1u75W2lCCCGkCNC5RcrMzAxdunTJdBpmRt26ddMq4CLai4kVIyxB+fqnz0nCMzUHACy9+BDl3Fsj4PkT7phN03rc44Dl/+ZTTQkhhJCiRedACgAmT54MExOTbM/bsmULIiIicOvWrWzPJdqrU9UEgbHm3Hb6zLePUgU4+/ojGADLf5+kcp1Vw1oAgMhLt/OjmoQQQkiRo5dAKruUB2m6d++OwYMHq2RpJboT8oFEsZDb/vzpExdMNR47C93c62LbgPZY2a0JWPZ7i1XVlTO5xynBquvyEUIIISR7Oo+RSvP06VN8+fIFEolE4+BluVyOsLAwhIeHY968eWoZXknuiSUKREbHIbycCezMUwAogymnChVgJBBgzr+7kbxlHkLjEvFgwW/oP0+55p51w5pcGVecWqBj8kvwBAKDPAdCCCGkMNI5kEpKSsKwYcPw7Nkzrc5nWVbrc4l2KpYzRaBEhLufLdGsQhiKmyrX3EvLKcXwlW+zf1gMpu+/jNaDRqGUUyUAQJn+3RDiexwA8GzIb6i9+2/DPAlCCCGkENK5a+/ff//F06dPwbKsVj/W1tZaZ2kl2jEx4SHoQwQA4OYHO25/eNj37jqTvlMw65RyLNTVI/u4/bV8vi/XE7r/dF5XlRBCCClSdA6kLl++DCcnJ2zfvh0PHz7E69ev4ezsjIcPH8Lf35/7efHiBdzc3LBjxw5KYa9nZeyNEfop6tsWwyU8VZnBZ2GDmR5NcH5cd3iYJKmMlWr+9BT3OOr6/XypMyGEEFIU6BxIffnyBX/99Rfc3d1hZmYGHo+Hjh074uTJkyrnCQQCjBs3Dr/++itS0+U6IrozK8ZHzNcEbvve55IAVAMpAOg5dBScilsiNiUVKf7fUyGYVa30/dq2g/K4toQQQkjRoXMgJRaLUaVKFZV9PXv2xN69e9XObd68OSIiIrBhwwZdb0vSYRgGrpXNERuVCACITRFxx9IP/Be4NcH7r7G48jYYldt2hVwu4663796eOy/u0ct8qjkhhBBSuOkcSNnb2+PFixcq+2xtbVG5cmXs3LlTZX9SUhLEYrFaaxXRXWS0GFeOPkZqYgqk8u9vq1gsVjnvTKQcc04p10O8unAit7/2nlXc41uNekIhk+VthQkhhJAiQOdAyt3dHRMnTsTy5cvh7e3N5YgaOXIkli9fjr179yI5ORlBQUGYPHkyZDIZEhISsimV5FS7FsruvLP7/4NM8f1tTUlJUTlvxupNmNG+Pv6b1hfupSzBSiUAAJ6REWr8s5A770KJ+vlQa0IIIaRw0zmQGjVqFGQyGbZt24ZVq1Zh1qxZAABnZ2cMGDAAf/zxB+rWrYv27dvj5s2bYBgGtWrV0vW2AICLFy+iX79+qFu3Lho0aAAvLy+8fv061+X5+flh0qRJaNy4MWrUqIG2bdti8eLFiI6O1kt981KjujYAgLSevOhkZfdeSnKy2rnjthyCpYnyOJv8Pah1HN6beyxPSqYuPkIIISQbOgdSZcqUgY+PD1xdXSESidC0aVPu2OTJk9GmTRuV9Ae2trZcsKWLlStXwsvLCwqFArdv38bBgwdx+/Zt9O7dGxcvXsxxeYcOHcLPP/+MM2fOICoqChKJBEFBQfDx8UHnzp0REBCgc53zUu0aVtzje5dec+OkUlNT1RKkMnwjhManYNbJ23h+54bKsQ6x3weh32rUM+8qTAghhBQBelkipnr16jhy5AiePn2KUaNGcfsFAgHWr1+PzZs3Y8qUKVi5ciXOnDmDChUq6HS/Q4cOwdvbGwDQu3dvGBsbo1y5cmjWrBmkUikmTZqEN2/eaF3e06dPMXfuXMgyGRcUFRWFiRMnaszYXlAwDINyZZULF8d8TUBE4ve1Dz99/Kh2fsvV+3HwyTsMmjhNZb9RMVMYWZhx289Hzc6jGhNCCCGFn14CqawwDIMWLVpgxIgR6NSpE8zMzPDff//lujyJRKIy68/R0ZF7XK5cOQCAVCrFqlWr1K7NzIoVK+Dp6YkzZ87g6dOn2Lt3L6pVq6Zyztu3b/Hw4cNc1zs/+P5TH6XtjSGVyBCWUIzbrykAHNauCeo52uEPj0Zqx9p//f7+BG07iKuu7cFmSKVACCGEkHwIpDKKjo7GoEG5z1V09+5dhIaGcttmZt9bT4TC7wv33rhxQ6tB7dHR0XBzc8Nff/2FihUrwsTEBHXq1MHWrVthY2Ojcm5MTEyu651f9vxTHzKpcsHi82++B5mpGQadz134J3YM7ID2LuUgjwhSOcbweGgbfJvbTn7/GWfN3PKw1oQQQkjhpLdFiwEgODgYMTExEIvFaq0gLMsiMTERBw4c0Oke9+7dU9kWZLLIrlwux71799CuXbssy7OxscH06dPV9ltbW6Nly5Y4cuQIt698+fI5r3A+MzJSxsZR4fEobmfB7Q8NDYWjoyOMvr1eRg6VIeDz8CUuCTGHd6P+mBkq5YjsSqBD7BOct6oNAGClUqQEhsLEsXQ+PRNCCCmaPn78iN27d+Py5cu4du1apuc9fvwYffv2zbKsf/75B61bt1bZd/HiRezevRsvX76EXC5H+fLl4enpif79+2f6nUlyTy+B1JYtW7B9+3atZrexLMstYZIbT548Udk2Msr8KTx9+jTbQCortra23OOKFSuicuXKuS4rP/05oyoOXE9EcTsLRCYZo0QxZSb5kJAQlEsXDB54E4YT957gwedwhGQIpADleKlO0jc4LXAGAFyp2AqdpNqPPSOEEKLEsixu3LiBXbt24datW2BZFubm5llec/z48SyPV6xYEa1atVK5x5w5c3Dw4EGV8/z8/ODn54ezZ8/Cx8cHJiYmGYsiOtC5a2/Tpk1YuXIloqKitFq0WFcREREq2zxe5k8hKioq02PaCAkJ4R4PHz5cpwAwP7lUNseXz8rnfvtjKcSnKv8CkcvlKu+BS7uuePA5HCIjPpLCQzSWBQCiUt8DSrlYkke1JoSQokcsFmP37t3o0qULRo4ciZs3b2r1XSiRSHDu3Lkszxk6dKjK99K2bdvUgqj0nj59iuXLl2tfeaIVnVuk9u3bB5Zl4eTkhAEDBqBs2bIwNjbONOg4evQojh07luv7ZRynlFVwo0v+J4VCgfv3lQv4NmvWDD169Mh1WYDyL4VkDTmddJGWbDNj0k0jvhwRIcrXiQWDawFl0bWacuZeSHAwbIoXBwDUbNEOx0Z2gaudDXBsI5L6TgdjpN7s2+DBEdx0aAYAiLj/BJb1auj1efyIMnvvSMGXV++dWCyGQqGAXC6HXC7Xa9nku7QghmXZfHmdFQoF6tati//97384d+4cpkyZonI8szpcvXoVjo6OuHPnTpblp12fkJCALVu2YMqUKejatSuMjY1x69Yt/PXXXyqNCgcPHsT06dMLdBefXC6HQqFASkqKypqx2X32dO3xyi2dA6m4uDgIhULs3r0bxb99QWelcuXKOHr0aK7vJ5VKtT5Xlxawy5cv4+vXryhfvjxWrFiR63LSSKVS+Pn56VyOJp8+fdK4/4zvPXj0bwQF+/0XSyKR4M2bN9wvp71bAzARAYhLESN02wowzTyzvNe7U5dQrJheh9b90DJ770jBlxfvnZGRkdqyTiRv5Ofr7OjoCLFYrJJnEVB+R6Wmpmq85ujRo2jXrl2mxzO6e/cuZsyYgTZt2nD7WrVqBQsLC4wYMYLbJ5FIEB0dDUtLy1w8k/whFoshk8nw4cMHjcez+uyln3SWX3T+RqxRowZCQkK0CqIA5SDuhQsXZn9iJiwsLLTusrO2ts7VPSQSCf7++2+ULFkSW7ZsgZWVVa7KSU8gEKBSpUo6l5NeSkoKPn36hPLly6v1eddw9ccLv++zFk/7lUMn188AgFKlSsHC4ttAdFdXHJ8+FFOP3gQAvBn+m8bu0nA+H6xcDkuJHJVdXfX6PH5EWb13pGDLq/dOLBYjNDQUIpEIxsbGeiuXqGJZFmKxGCKRKN9bLzK+rwzDaHyvY2NjcevWLdy8eZObQe7i4oJ69erBw8Pj+7/f6bRv315tHwA0adIEZcuWRXBwMADAysoKdnZ2eng2ecvIyAiOjo4QiUTcvuw+e+/fv8/PKnJ0DqTGjh2LESNGIDo6Wi1dgCYsy0Iiyf04G3t7e5VAKqtWp/SDxXNi7dq1SEhIwM6dO+Hg4JCrMjJiGAampqZ6KSsjExMTtbIrVzDHC78EBH/4irIVbCGV8yGW8SAyUiA5KQklS5bkAqamE+YCR9uhrkNJsC/vwLSR+gfSukldRN94ACMeP8+ex49I03tHCgd9v3c8Hg88Hg98Ph98Pl9v5eoDy7KQJxeNbmi5XA55qhhyuYJ7nfmmJgYbA6vpvb5w4QLX+xIbG4vY2Fh8+PABZ86cwbJlyzB06FCMGTNG69YXW1tbLpD66aefCtzvV0Z8Ph88Hg8mJiYaA83MPnuGeg91DqQaNWqEadOmYeXKlfjzzz+zPf/r169YtGgR+vfvn6v7ubm54dWrV9x2Vn3ctWvXznH5N27cwJkzZ7Br1y44OTmpHLt58yacnZ1RsmTJHJeb3zq2tsOR06F4cMUPErEUFVxL42FwSTQpHwYAiIqMhO235+FQpSrezv1FeeGz64CGQMqyTjVE33gAhUT7rlVCSOHHsizutuiLmLtPsj+5kLJuXAfu1/YUmAlFWc3WS01NxcaNG3Hv3j1s2bIFxYoVy/TcNGkTpwQCAX755Rd9VZN8o1UglV0mcldXVzx+/Bhr166Fu7t7puclJyer5GXKjcaNG2Pv3r3cdmb9xzweD/Xq1eO2AwICMG3aNAQHB6N///749ddf1a4JCgrCxo0b4evri1KlSnH7JRIJnj17hjlz5uDChQs61T+/uFaxgJOjKT4GJuPpnfeo4FoaXxNNwbIAwygHJtrY2ID/LX2EsGVPSK4dxsPAcNwfNwTTN2xXKU9oq2xtjPvveb4/F0KIgRWQAONHEBQUpJbmR5PHjx9jwYIFWLp0aZbnvX//npvtPmHCBLUGAqI7rQIpLy8vxMfHa1XgP//8k+VxXUfVt2zZEsWLF+e69+Li4rhj6VunWrRooTK2ac6cOVxL1saNG9GgQQOVoC8pKQljx47F27dv0bJlS433rlSpkkEGsuXWhiW14NHvDpCu9/P2p1Jo6vQFAPD582c4VagAhmEgcK6DKZMn4fBTZR/z5D++wKjE92BSlpAEAIh/5p9/T4AQYnAMw8D92p4i1bUnThVDZCwqEF17GTk4OODNmzdISUlBfHw83r9/j4cPH+LMmTNqg6yPHTsGLy+vLIeg7Nu3DwDQsWNHlUHnRH+0yiPVvXt3rXJE5UceKaFQiEmTJnHb6X+xwsPDASibLydOnKhy3evXrzPdVigUmDJlCt6+fZvlvZ2dnXNZa8OwMP8+vfXIlhsAgMgkE0QkfU8Cp0gXfP6+bisA4OiILojdtxqs7Hs3npmLcqFplqZlE/LDYRhGuaB5EfnhFzNR2S4oQVR6JiYmsLOzQ5MmTfDrr7/i7NmzWLp0qdpsu7t372ZaxsePH7F//340aNAAS5cuLZDPsyjQqkWqb9++2LFjBxYvXozq1atDJBJlmQhTk7QlYvbu3avzMjG9evXC+/fv4ePjg8OHD6NLly5ISEjApUuXIBAIsGzZMri4uKhc4+LiotJcWrVqVe7x4sWLcfXq1WzvW9gCKQCYNLoSVm1StjLFRiXCqrgZ7ny0hWd15Yw+uUKBtGGHpStUwrHl81A64i3eRsQAG/9C4wnzAAAWNQrfcyeEkKKCx+PB09MTdevWRZ8+fbhemdjYWI3ny2QyzJw5E25ubti8ebPK7DeiX1pFQ+XKlUOrVq3QrVs3VKpUCQ4ODihTpkyOfsqWLQsXFxdMmDBBLy1TM2bMwKpVq8Dj8dCiRQt069YNjRo1wqFDh+Dh4aF2/qJFi1C1alVYWFhg7NixXLfesWPHsHPnTq3uWRgDqZ6dymDj0loAgHsXvw/SF8uU4dPXDJni6/cbiRSJDAGRcei11BthH94BAESlvg+w95+pe14tQgghOefg4IDZs2dz22XLltV43po1ayASieDt7a02w+3w4cN5Wscfjdaz9n7//XfI5fIs17bTRvHixXHy5Emdykjj4eGhMWjSpFKlShoTgXp6esLT01Mv9Smoargqc44kJ4qRnJAKU3NjiIyUXXSaktIZd+iP3z080a+eC0J2/40SA70gcqrGHf/87364/DU1fypPCCFERfv27bnM5OknVaW5ePEiPn/+DG9vb5VxvcnJyTh9+jROnDiBnj175lt9izqtoyJHR8dc3+Tz588oV64ct11YFv8tKhiGQYdWdjh/NRyXjz5Cl0FN8CSkBGqXiQSgbAJOHyCXrVkfC8YMQcLb53Cxs8Gljctx6Usifr/gg/vtf4EsNt5gqfgJIaSwSr/cCZB5HsTY2FhERkaiQoUKGofRGBkZoVixYmjXrp1aOp63b99i+vTpSE5Oxvnz5zWW369fv1w+A6KJ1oHUuHHj1L44ixcvjr59+6qNR8rozJkzUCgUGDduXO5qSXQ2Z7ILLl0Ph1Qix5Vjj9G2ey0ukIqJjuZySqUZNnsRpG+f4MPR7Xga8hV7rz/FnL++NyEnPH8Di5pZv++EEEK+S0xMVNlOTU2FQqFQCZYiIyPRqVMnxMbGwsHBAXPmzEGLFi1Urnv9+jVsbW3x+++/q+yPiorCmDFjsl3XtTAOUynItB4xPnjwYDx69AiXL1/Go0eP0LJlS8ydOzfbIAoAxowZg/Lly2PevHk6VZbopmMbewBAbGQiFCwPEpny7U9ISNB4vqBKbVSauAzrrj/F1DZ1kXjamzv2fOTMvK8wIYQUEampqdi+XTU/n0wmw44dOyCTybh9crmcy48YFBSEkSNHYvr06fj8+TNYlsXz589x7NgxbNu2DWZmZtx1YrEYY8eO5TKYZ4UCKf3SOpBq0KABKlWqhEqVKuHEiRP4+eefc5RmvlOnTnBxcYGPj09u6kn0YNq4KirbT0K/L6GT2WLQfJEx5nR0R80yJWDFU8CsqnK9wLjHr/DlaOFITkoIIYZUp04d1KpVCxs3blQ7tmTJEri5uWH+/PkAADs7O+zbtw+dOnVCqVKlYGRkhIsXL2LUqFGYO3cuEhISMHPmTLUuvfnz5+Pp06fZ1oVhGFSpUiXb84j2tO7aCwoKgp+fH06ePJnrNez69u2LoUOHolu3brleUJjkHp/PYHAfR+zYH4jIsDgA3xe+DAoMRHknJ4398aPW+iB512IAQJ1/5+BGk8EAgMe9x8ND4k9jpQghJAuPHz/O0fmurq74+++/c3TN4sWLsXjx4hxdQ/RD6xapo0eP4n//+5/K0im50aVLF5p6aUAjBjiBz2fw8r+PABgERKkGU5owpmY4/PQdRu29hJtP78NxVF/umPhLhMZrCCGEkB+B1oHUnTt30L69+mK2OVW7dm3cvHlT53JI7l072gzR4colf158KQHxt7FScrk801kka649xdV3wbhy6w5qrJ/P7b9apS0UEkme15kQQggpiLQOpD5+/IgKFSrofEM7OzsEBAToXA7JPYZhUNxGiOAPXwEAl95+X6cpOChI4zW/tG2CX1vWRu92zVX2K8QSnC1WA08HT8u7ChNCCCEFlNaBVFJSkl5uKJPJMk1pT/JPVLQEj28q1xaUKr5PGpBKpWq5TgBg1C8DMbxxNdSwNgEAtA25o3I8ZM8JnBY4I/pOzsYCEEIIIYWZ1oGUmZkZgjJprciJjx8/wsTEROdyiG5+86oCmfT7AsQX0rVKffr4Ub2LTyaFyMgIbIxyTJSoZHF0kr5Bm0DVbtq7LfqCEEII+VFoHUg5OTnpZWzT9evXUaJECZ3LIbrp0NoOAHB8+y0AQLJEgLD47+sxffzwQeX8RAVw430w9t58pLLfuFRJeEj8UbpPJ27faYEzLpZqhOtuHnpZV5EQQggpqHKUR2rPnj2Q6DCwODExEfv27aMcFgWAUMBDyRIiyOUKXD3+BABwL9Be5ZyE+Hju8YdEOYbvuYS5p1W79ADlmKtau1aq7JNExiDRLwCxD57nQe0JIYSQgkHrQKpbt24IDw/PdXZyhUKBSZMmITo6Wi+z/4ju/pxRFQAQ8/V7ZvPjr5y4x1+/fuXGSzk6u0DI56Fl5bKQvX2qVhbDMPBIfY1mj0+g2cPj3H5Kj0AIIaQo0zqQqlChAjw8PHDs2DGMHj0aYWFhWt8kIiICXl5euHnzJuzs7NCmTZtcVZbol2uV7zmk/rvqDwBgWQbvvlpy+z99/IjkpCTYOjjh5axB8O7bFuJbx9XKAgCGz4dFDWdY1HRBibZNAAAJr9/l4TMghBBCDEvrQAoAZs2aBRsbG1y/fh3t27fH1KlTcf78eY1BVVJSEu7cuYNFixahU6dOuHr1KhiGwaxZs2BsbKy3J0B0s/avmgCAoIDvLUevwosjOvX7Gk5hYWEI+/IFog4DAAB/nboFuVyGrMgSlLM8P2/eq+8qE0IIIQWG1kvEAICNjQ02b96MYcOGIS4uDqdPn8bp06cBAAKBABYWFjAyMkJcXBy36CIAbsDx+PHj0a5dOz1Wn+iqTg0rjB7shE07PuLIlhvoMVyZJ+rG+5L4ub4IspQoAEBKSgoUpRzw6ksUfO6/Rq9b11CrRdtMyzVzqYDY+08hDqWuPUIIIUVXjlqkAKB69erYu3cvXF1dwbIs9yORSBAZGYmwsDCkpKSoHBOJRJg1axbGjRuXF8+B6Kh/z++pD07t+j6Y/NB/lnAo933MVPCXcPx2/Bbau5TDh6M+YDXkm0pT3msQ9zji/A0915iQootmupIfXWH7DOQ4kAKU46UOHTqEhQsXZjkDTygUwtPTE8ePH8fAgQNzXUmStxiGwc9dygAAJGIZ4iK/z9Zbd5oBwxdy246lS8HdqRTauzgi9cS/mZZpUdOFe/xf5xGF7oNBSH7j85WJcWWyrLvNCSnq5HJljkMeL1chSr7LUddeenw+H7169UKvXr0QFBSEFy9eICwsDFKpFObm5nByckKtWrUo+WYhMXFkJRw6GQIAuHzsKbr2rw+jb+/d0Wdl4Fn9IwBgza79SNr5FxiGwe1799G681DwjARq5TEMA7uubRB+4jIA4IzQBe0jHkBgbal2LiEEMDIygkgkQlxcHMzNzQ1dHUIMJiEhAQKBAAKB+ndLQZTrQCo9BwcHODg4ZH8iKdCuHW2Glt2VSVdP+P6H8ZMbIiReBIDhzpEpFLAfMgMuNesgWSrDmpLL8PPkWRrLq7N3Nc4Wq8FtXyjZAC39L6JYRcc8fR6EFEYMw8DKygrh4eGIiYmBtbW1oatESL5LSUlBfHw8rKyswDBM9hcUAHoJpEjRYGTEw4md7ug66C4AYN3f93F6b1NsvcxDQqoA5sZSAADfsjiSpTJ0quYE87B3SNw0E5KarWDjrjqRgCcU4qeE5zhn7sbtu+bSDlUWTESl30cXmg8JIfnF2toaEokEYWFhiI+Ph5mZGYyNjcHj8ejzoidyuRxisRjA9+5UYlgsy0IulyMhIQHx8fEQiUSFagUUCqSIChtrIRrXs8Gdh9EAgE59b6H/yEaISDKBubEUKanKzPbbli3CnaP70LRiGUhkctT4+RcAwN1TR+BYuyFXHt9YhE7SN3jYYwzCT14BALyduxpv565GnQPrYO/Zjr4gCPmGYRjY29vDxMQE8fHxiIyM1LiIOMk9hUIBmUwGIyOjQjMG50chEAhgZWWFEiVKFKoglwIpombZvBqY+dcr3LgbCQDw9b6H2bOqAwAk3/6S69B/CNr/bxDkn17DZ9EcAMBw9+p4f2AzrOzLIC4+HmUqu3D/UNU78g8iL9/B/Z+GcPd53Hs8AEBYsjjsOrdG2YGeMHYoBQAQWJjReCryw7K0tISlpSX3pU/BlP6kpKTgw4cPcHR0pDG8BQiPx4NAICiUf1hTIEU0+mtmNZy7Eo5Fq5QZz8UyZUDE4Ps/6AyfD6OKNTBy8344b1yCSvJY2JqZYv/8SZhzSplG4cP7dxCZKBdDLtGmMTpJ3+D11MX4uMaHK0cSEYWgbQcRtO2gWj1KtGuKmtuWwNjeNq+eKiEFFo/Hg1AozP5EorW0oFQkElFyaKIX1K5JMvVTazvcPKFM0Pkx5Hv6grSpqWkEQhHaTpwH2xK2AI+P2GRlMtbf29VH0qc3auVWXTEDnaRv0ObzDVSaOQb2PTsAAHgmxuCZqP7DFnnxFi47NMX7pZv1+twIIYQQfaAWKZIlhmEwfEB5PHgbC9RT7gsNCYGDo/rMu2KDZwIAJo8Aeq+aAksTEYylyZmWbVzaDs5/TFTbL09JxedNexHkcwiJr98DAN7M/hsVpw4HU4j6zQkhhBR91CJFsvVLn3KQs3ykSJVBjFQqzfYam7LlEJGQjJCn93J8P76JMSpMGoIWz06jzr413P6Xvy7McVmEEEJIXqJAimglMTYZV9+X5bYlEkmW54uLWeNZSCSazvhbp/uW6vkT9zhw816cFjhDQZmfCSGEFBB5Eki9f/8eS5cuRb9+/fDTTz+he/fumDp1Kq5cuZIXtyP5oLw9HxL592614KCgLGcShVmWxbJLD8ECeH/5hE73rrVzhcr2WZNqOpVHCCGE6IveAylvb294enrCx8cHjx8/xqdPn+Dn54dTp05h3LhxmDBhAq0lVQhVcFDOHAqKNeP2ffr4MdPznd1bICgmAQs6uaPEm7tQJMbm+t5l+naBh8RfZd+zYTNyXR4hhBCiL3odbH7p0iX8/fffKFWqFOrUqQM7OzsYGxtDIpEgIiICjx8/xoULF7Bp0yZ4eXnp89Ykj/EZBrfOPgc61oCDVSK3Py2xXUY8Hg9vD29DzN0LkMrlmDOoFx6HROLs/Se5uj/DMOgkfYPTAmcAQPDOI7Dv3g52nVvn7gkRQggheqB1IJWQkJDtQpo7duzA6NGj8euvv2aaVOuff/7B/v37KZAqZNzr2WCL7ycADE68ckLXasrWqMDPn2FarBhsrK0hFIlUrinWqAP4MeGoOFzZemRlIkLU+t9g3X8KeNYlc1WP5s/P4IabBwDgYfcx8JD4F8oEboQQQooGrbv2unXrhsePH2d5Tnh4ODp16pTlF9vPP/+MuLg47WtICgTHssqkmnHRiVCwDOJSvicJTE5KQnBwMD4EBHCZz9MYdxyER3eUCyEv7toExgIjnPtzGsqUKYMvj++AZXOWsdnctSKqzBvPbZ8RuuDDqm25fVqEEEKITrQOpGbPno0JEyZg/fr1YFlW4zlubm6YOXMmHj16pDYOimVZvHz5Er/99htq166tW61JvjMx5qNNc1vcPvcSAHA1oCz+CyoJoUg1gWZwcDCSEhORmJjI/Q7Yl6uA4OAgdOjqiUSxFMsvPwQAnPdehWTvOUjaPAu92zTD9j9n4//t3Xd4VMXewPHv2ZbeKy0QhIQuoUoTL1XpgiBFEEFBBQsqglcvKiqvYLsqAqIXkKoISC+CSFG6ofcWEgKk92T7ef9YcpIlhWQTAoH5PA8Pe86ZmT17ZssvM3NmzJdPYb58CsvVC0UGWXXfs2/NPP32dI69+J/yfsmCIAiCcFsl7trr1KkTDRs2ZNKkSQwbNowvv/yS4OBguzTjxo1j0KBBPPPMM6hUKry9vXFycsJsNpOSkoLZbMbZ2ZlFixaV+wsR7rx3X69Hp/672bh0Hz2GPkJsmjvL/3GnVR0LIe7XMZttUyLExcUpeUJq1kSj0SBJKpweG0Bgx/6EbolEJUm0rml7/9xIz2LPmUucu3qdQf62IP1sXAojFm3GSaNm+3ef4vnYk0j5FhjtaTpL6oFj/N1uIAAx/1tOzP+WA+DTthkAWecuU3VIb1RaDcbkNEKefxqf1g/f+QslCIIgPDBKNdg8KCiI+fPn88MPP9C/f3+mTJnC44/nzfMTGhrKTz/9xJQpUzhx4gRJSUl2+R966CE++ugjGjVqVD5nL1QonVZFoL8T8YkGZFlWunAPXFBzgOq0rBFHiJ8ZtUpW5pnS6/W4u+fd6SdJEvM2bANANuoxXz6FOuoS9arupGntGqiCQrDGRWORraRkG3isbnUMJ/eTfT4St7Gf2J2Pd6smdPhnDbub97Xbn7Inrws66tuFyuOrC1ai8XDDv2t7ZKuV5su/FeOrBEEQhDKR5KL66W7j2LFjvPXWW7Rq1Yr33nuvwOKP586d48iRI6SkpODp6UnDhg1p0qRJuZx0ZXP8+HEAGjduXK7lZmdnc/r0aerXr4+rq2u5ll2U6KvZDH3pIABN29WhUdMqZBvsg5HuEeBkuooKI25ubgTd0nJZElmJcRz4cyvmQ3/QtnZV1hy7SLNBo6jXsVuBtLIsY4hLJOPYGcxZOQCkHzmFJVuPpFaRevA4ybsOFPo8PU0F1wKsCHej7oTyIequchP1V3ndru7u1G/t7TgcSAFkZWXx/vvvc/LkSb766ivq1atXnud237ifAimA2Bs5PP1CXmDSoX0wNRrVQW/O63prV+saAe62xYtrP/SQw88lyzL/eao75+JT+PvSNSInDSVw7FQkJ5dSlWNMTiV28RokrYaTr061O1Z/xiRCX3+uQlunxJd55SXqrnIT9Vd53auBVJkm5HRzc+Pzzz9n7NixjBw5kgULFpTTaQn3smrBLnh7aZXt3X/dYOmcv4g6ex03tZFqfnAxyUs5HnfjhsPPJUkSmsDq/H3pGv+qWx03nZb476eUuhydrzehrz5LrZeG0fWG/fp/p9+ezkZdPWSLxeHzFARBEB5M5TKzeb9+/Vi+fDkbNmxg9OjRJCcnl0exwj1s/eK2TH41jFYRPsq+yN3nWfT9Pk78dZqrCXlvraysLC5dvFiixY4L88HsecTExPDFwM7IwISVu6hWrRrZmRkOlafz86Gn6Szhn7xpt3+jcwO2VnmELf4tONBnDFkXo4u8Q1UQBEEQoByXiAkJCWHZsmXUq1ePPn36sHv37vIqWrhH9epahS+nNmHHbx14aWSosv/PvxNITMhhx4VqduljoqOJiY52aIkglUpF0Lhp7L18nZ0XrgLwyYj+ZTr/Om+PoXuq/UzrxsQUzGkZJGzayY56Xdmoq8dfrftjTE4t03MJgiAI96dyXSJGo9EwceJE2rVrx+TJk+nRowdvvvkmWq329pmFSkujUTFsQAj1wzw5fS4dSZKY/8s5gms8woZTNekWHoNWbZsTymQyEX3lCgCeXl54eHig0+lKPD6p2/T5PLa/NS+1b0JEjUD+mDyKzdez+OynXxw7dzdXeprOYkpJI/3YGZJ3H+Tch9/apUmLPMnWoNYAtN48H//ObR16LkEQBOH+U+pAKiUlhV27dhEXF4enpyetW7cmNDTULk3btm1ZvXo1//73vxk0aBBffvllgTTC/adZY2+aNfYGYPe+RABMVjUbTtdCp7bwrzpXcdHmjUNKT0sjPd8s92q1Wrn702g04urmhk6nw93d3S7QWvznPrLnvkdUUjrHryWy9I9/CB7em1cnTiJTVnMq+jpOTjoimjdH5eoJgN5sxaWYJY60Pl74dWyNX8fWyoSfCdv+5sATo+zS7X/8OaoO6U1At/bIJjM+bZvhHl67DFdNEARBqMxKFUgtXLiQr776Cr1er+yTJIkhQ4bwn//Yzyzt6+vLnDlzWLRoEYMHD+att95i4MCB5XPWwj2vwyP+zPpxF71HtEWr02C0qNlytiYgE1EtgRreWagk+/FHFouFrKwsZTstNRWAhPh4nF1cqFq1KmB7z7mN/YS6cVfp1qw1WrWK4a3qY9y7idNXExg0bwPVvd3Z/upTgO3Ov/CPfgLg4MKZBFSpiuTijia0YbGvIaBLO3qazmI1Gjnz7pdc/u98AK4tW8e1Zevs0ur8faj6dC8opmHNEJdI+Iev41a31u0unyAIglBJlDiQWrVqFdOmTQNsd+t5eHiQk5NDWloaS5cupWrVqowePbpAvuHDh9OyZUvefPNN/vrrLz755BO7CRqF+9OQJ6sza/4l1i3cgyRJPDm6w80jEodjAzkca9tSS1bcdBbqBuXg6izj5gRqWY9KNqCW8sZS6XNySEtNxdPLS2md0gVVJyYmhgOLvsPDzw1r7CWcff15KMiPYLe8BZR3XrA9Wf+H63Dxz4141QgkKimd2X8d5dv1fyKp1MW+FpVOR4PPJlN9eD9OjP8AjYcbqf+cwJSUqqQxJqYQ9d3tZ+y//usmHv7fp2gfqoHVkHXb9IIgCMK9rcTzSPXp04cqVarwzjvvUKtWLWX/9evX+eKLL9i/f3+xA8z1ej3Tpk3jr7/+4rPPPqN58+ZlPvnK4n6bR6qkomOzGfriQWVbrVER/nAI9SJCSlyGh5ORznWv2u3z8/fHy8uriBx5ctfqk60yk0YNJdTHnVE9OjP/lxV8vHk/AKvH9KZBsB+uI/+DdMu6gbcvXyb5r0MkbNkNkkRxw7wStuwmLfJkgf1BA5+g4fRJuNSoUqrnFu6ee/1zJxRP1F/lda/OI1XiQKpJkybs2LEDX1/fAsdMJhMtW7Zk9+7deBQzDgXg999/54MPPmDPnj2OnXEl9KAGUgBWq8zytVeZ+b9LBY55+brhX8ULP19ngqt74+KswtlJRYbZPqAJD0ihflCK3T6tVkuNkJIHZPklxcbQpNUjNAj2ZfWYPgC0nLGUmgE+/Pblx6jUaggORQ6sjpNL+V3XC9O/5+x7X+JcPRj9Vfu5tQIef5T60yehdnXGKTgAtbNTEaUId1tl+NwJRRP1V3ndq4FUibv2/Pz8OHHiBI8++miBY1euXMFiseDm5nbbcrp16/bALhXzIFKpJAb3q8HgfjU4cSaNz2ed58JlW5dWWnIWaclZXCwmf4MWtaBpCGcTfKjulUmLGvGALXi/dPEitUJDUalKN4uHX7UaxMbGIudkkb1wGv9Ex5GmNxKflkHKwe14Ojtx4toq+v+4HoBDH40n8IkhqKvUcuAK5KkzaSx1Jo0FIHrlJo4Pfl05lrB5FwmbdxXIE9SvK05B/lQb0hvfdg9OK64gCEJlUeJAqmvXrrz++uv07duXOnXq4OLiQk5ODhcvXmTDhg20b9++xD9owQ6svSZUfo3qebHgmxYApKWbOHA4hXMXMzBbZM5eyMDZ2TZW6UBkXuvTqUNRqNUq6jauztU0d5JznOgWFqMcj7p8GYAqVavi7OxcqmVeJBc33MZ+QuipYwyJTqeqvw9efoHIWWlsOxsNwIR/NcOYkoB+7Q8MXbCJQ9FxRF2+hFZXthYj/yc6ErxvKSGSjgOtbYPi1a4uWLJz7NLFrd4KQPT3y4C7tzagIAiCULgSB1Kvvvoqu3fvZtmyZXY/VrIs4+vry7vvvntHTlC4P3l5aunaMZCuHQOLTCPLMktWxjDnp0sc33+JKiF+tOnWkNUnQunX6LJd2uvXrimP1WpbQGaxWGxzVKlUWMxmzGYzQUFBSJKEWqPByckWDNVo0ITPFy23K2/ScwaqfjWd0Owb+Lu7EJ+RzaHoOAAWv/IMg1rUZ/+lq7zy6w5a1qrCnHdeQ12lJokpqWz+az9uLs482aWjUt6Og5Gcu3iZIS+/jm9wVWW/W72H7IIjq9lMzuWrxG/cQdbFaBK37yHrbN5r3aANx6dNBLXGDafq0z1LfL0FQRCEO6PEgZS7uzsrVqxg7ty5bN68mevXr+Pr60vHjh0ZN24cgYFF/yAKgiMkSeKZp0Lw93Xi46/OcD06idXzd9PvuQ6sPlEbkHm09jV8XQ12+Sz51swzGo12x+Li4uy2AwICcPfwKNCSpdE58dykvDX9amalof1mBVvGPUl1bw+wWth4MorUHAM6lYTlwlEsF45y5Voi7/24nqpebvR0ypsj67sFmzgYHYfh8mleHvIUOV7BHNrxN/Xr17d7XpVGg1vdWoS+NlLZZzWZ2OTaSNlO2XuYlL2HOfzMG0hqNbLFQsTSr/Bu2QTXWtVLdnEFQRCEclGqeaTc3NyYMGECEyZMuFPnUypbt25l/vz5nD17FrVaTatWrXj55Zdp0KCBQ+UZjUYWLVrEypUruX79Oh4eHnTu3Jnx48fj5+dXzmcvlNTjnYJ4vFMQZrOVxwf/zaofd9G0XR1q16/KrkvVABmtyopOY0Gjst07oVVb0aktyLKEVm2hWfVEMg0azFY13i55gVdCQgIJCQmo1Wr8/P1RSRIarRaNRmPXVa1y8yIqOgbZkINsNoIMr0QcJfnjTxj4SGPUtRqAJOHtmkj35lH4uLuhzj9PlbQZgDHtGmOJOUfs4QNMnbWaj2b9j3Ofv4HTvwZCQO48WSr759Zq6WE8Q8z8FcSv307cuu3KsdyFlg8PzftMhjz/NH6dHqFK/+5I6uKndhAEQRDKpsR37d1rvvjiC+bOnUtERAQLFiwgLi6Ofv36YTKZ+Oqrr+jatWupytPr9YwZM4b9+/czcuRI3nnnHTZu3MiECRMIDAxk4cKFDs/O/iDftXcnHDuVxsuTjgDg5KylUevaqFQSarUKldr2f0BVH3KyDGg0N/dp8v5mUEtWetaPoqRj1F1cXHBxccHVzQ2tVluqcVj55Vw8gXz4T1Q+QTw0whb4fNyrLYOahQHQa85qzsWnMrFzc0Z1bI7abGTeyevsPXuZcQP70HbUq8qcV8bkVEwp6Rwb+y5p/5zAkpld+JNKEjo/b/w7t8WSo8dqMFL95hqFkkrCp11znIIDHH5ND6IH9XN3vxD1V3lV+rv27iW5XYwAgwYNwtnZmZo1a9KhQwe2bNnChAkTWLlyJeHh4SUuc8qUKezfb5tbaPjw4QA88cQTTJ06lfj4eEaPHs2mTZuUcTXC3dOkgRd/revIpStZzJh5jn923n4Atkqtwj/YC61OTfWHAlkr25Z10aotNK2aiFplxUVrwcvZWCBvTk4OOTk5JCcnA+Dk5ISLiwuSJCFjW2NSo9GgUavJP5mUdMtjbc16qGs3RJIkzp/vxW//m8MjPlrIsp8KoVv9mmDUE5+l5/f9h4m8Gs9T9f8h+4cp3PB/iMi4NLoNfAavh0Josy1vEtALn87h+sotpB85lVeYLGNMTOHaLxuUXQlbCp/vza1ebVyqF5zPypiUis7PG7ew8lvmyXAjAd8OLcutPACsViSNBre6NQFba517eG1cQ2uU7/MIgiDkU+kCKaPRyHfffadsh+SbS6hmTdsXaG6r1Jw5c0pU5oULF1i3zrbkh0ajoXp12zgTSZKoWbMmKSkpxMbGsmTJEkaNGlVcUUIFql3TjTmfRQCQmWXGZLZiMcuYLTLZORaSUoxYrTIms5U9B5KxWmVyDBb+2GYLNFzdnakXEYLJEozVas3XnSbjqjXj6WzE11VPkHsOXi55AZbBYMBgMNx6OiXm5OSERqulaafu+FevjouHB5LVwqq+48hMS8XXVYcu5QYBmZlEnLxGcraexlVtXcvbNq1n6qb9VJs5mz9fG4jKrwrnrsTwj15H7Yce4tHf56LyCcCiN2C4Hk/85l3IZgtWg4Ez73yO32O2xZeNiSlknDhnd15ZZy6RdabgfF+5Erf97fBrLsyNVVvKtbziSOW6cLqMLMvESRLFrQkkm0y41KqGIS6JgG7tAcg6d5nAJzpya3OoMSEZj0bhaDyLmELGYkXl6ox3yyZoPEu+MoTO1wuVTlfi9IIglF6lC6T27t3LtXx3aOVfbkaX7wtj165dZGRk3HaCULAtf2O12mbBvrW5MH+Z69evF4HUPcrdreBbuXbNvB+l9q38lccfToQb8Xp+3xHHms1XiNxtCygklYSziw53Lxdc3JzwDfTAy9cN38BqSJKEp5OBKp7ZaFRWVJKMm5MJJ40FHxcjOSY1EiBJ8s3/AfIeq1V5Pei5gZiLszNJiYkkJSYiSRIajQYnH3+ygexg22LLb3z1CG9JEpqoE3B6P2fibFNDPNfGNvjcmnSdfafPM3XTfrrXr0nLtPMAxKRk8sIv2xnSvROPt21JSFgENfv8wqHTZ9F5evNwvXpoNVpMOTKZ56+QcyUWlVPBH1xTSjpZ56PQ+ng6Xjm3SPpzH85VAyl2KvhSkq1Wbqz6Hc8m9QDQx97AmJg3jYZsMpXbcyllliBNTpRteaK4NduUfZmni5s57c4IHtAd95stirIMlswsPBqG4dWiMW51a6JxE11cguCoShdI7du3z25bW8RfmhaLhX379pVorFRul15x5QGcPn2alJQUfHx8Sni2wr0qONCZEYNqMmKQrRUzJc2IwWAlPtHA9Tg96RkmTp9PJ+ZMHLs3ZGC1QpUQP/yCPVGpVahUEm6eLuh0GnwCPMjK0CNJed15kiTBzW0JUGlUeLpYqe2XhixL1PZLR29W46azrScoyzImkwlTUT/47sHQsi+vturHO25uWNKSMEtW1NcuUC1DQ9draTQNsP1RYTCbORR9g0vxyUT+c4hO3jLG66eRZZkBNxdv3vvm0/i5uQDw3y0HWLD/FK8/FsG4no8BEJOczsi5K/BwdmL1hOEgWQCJzzfsYuuJCzz/r1YMbN0YJInEjCyenf0LWrWaNW89d7ORRmL21j1sOnKGoe2aMbhdBEgSmXoDE36/wJWD+/ln5ofcvFgs2Po3+89eYkD7FnSJaAiSREpmFlMWrkKn1vDFi0OxXVD4decB9p4+T/eWD/N4C9vkvtkGIz8RgyRJ/N8LQ1Cr1MhWC+v+3MvpG8l0bNyAiDq27tz07GwWbtuJRq3mxZ7dlYBu57GTnIqOoVW9ujSvWweAHKOJxdt2APB8z25IkoTZbGbr/oPEpmbQtO5DtAyvCxKYLVaWbPsTgEFt2mCNTyLzWhqXszJIyMrENymb6r5+qJycMFqs3MjKQKNW4xGbhDXHgMbTjTSTEYPVgrtGi6va9l1kMhq58udePGTptutC2rn5xyHAjZW3b/3zjGhI1rnLuD0Ugn/XdiBJuIbWQOfrhfcjEbhUF/P/CUJhKl0gdfjwYbttjabol3DkyJHbBlIGg4HTp0+XqDyr1cqxY8fo2LFjkWmEysnHy9YaExzoTJMGBdfxk2WZy9HZHDqagsUiYzZbSU5NJjnZyOHDWQQFOCPLMrIM1pv/y7JtiRxkMJmtnIvKoUbtAJAkqtcOwGyyUCXEB3/XHHxcDVistvX6tGornk5GrLKEl7MBdyez3XlkZmaC2okcgOqNaVC9MVOeHAFAvMmAOjMFT/MuhnfT4KmWCaofgclqRrpxiZr+3pjMFrTafK23F22tJu7OOuQMWyuOMS2N6KQ0PJ11yOlJStobiUlcik8mLSkROTUBAFN6FueuJ6JVqbAm5433unb9BqeuxhF34zrWxCBbuTkGjl65hotWg/7SKbRqWxfX0RMn+P34JSL8nLF42/JnpmWy8cBRdGoVM7rmDR49fDiSNZHnqKm10MXLFixkZetZufsAAB89Go58s+ts+8GDrD1+CV9zKi1uTkeRnZrJd+s246RRM65JgFLu9r/2sDzyHK8/FkErXartfLP1fLlyDQBjG3jb5iADjh3/hwX7TzGmXWNaa23Xx2Iy839LfwVgUIgOD50Wj2owa/1efrlZbodmQYCF8/EpjJ6zBh9XJ/a/NUQ5hzdW7WT9ycu8060lzz1iu+vzamoGA0/YbiY4N2XkzcBP4tVft7P9XAzv92jLwBb1QJK4mJDKoLmr8XVz4ffXh5Fy9ApJFzL4NTmOZLOJXlVCcDkSTc71JOLUVs5pLbjJEk0NatIP29aCjD5xihvHT+MqF2wxlLRaZJMJ9wZ1kK1Wss5cosboQVhz9Hg1b4TVaETj7oZztSBcQqrhXCMYtauLWPJIuK9VukAqPj7ebru42dSTkpKKPJYrMTHRbt6h283OXpIyhfuPJEnUrulm111YWrIsk5RiJC3dxKUraZw4GU3aGQ/izRIWWY3ZAucvZ+Hv54zaSUtGphkvH1d8/L0JCfWkhlcmkiRTxdP2o2q2qgh0z8FslZRpH2StE2afYBr1GkSjXoMAUDq4mnRicbfnAcgBcmQZyWLmu6Y9ib10niqBgST7eIMMzgYDc2s2R6VSkRxeR+nHGhL0MN1TU6kWGEhygD8gIxuNzPQJQwJSmuTOdyXTx78BrZ9IonqVQFKq2FozTEYTE5+14ubqSk6jtuTcvGn48d4+NGgZR5M6tUmveXOMYo6et0aoUUsS6WGtbQ1dskzHrp5UrdeIh+vWJqNOKMhgNhp4ZVAOIJNVpwUq2YomM5lWLVviFlCF2o0akl39IVu53pkM7PgIGrWK7Gr1yH1xTR7OwuzqRe2G9cmuans9Vr2evm2bgQw5VerebHGUCW+QRS9ZS5164eQE28o1msz0aNEEGRnJyQ2Dly+SLBMYGEjD6mkEerhi0TiBJCFrnfByccLTxRnrzZYnZBmNWoOTRo1KpUaWVLbXY7AF0tW83JR0IGMyWzCaLVitFjDbWjItRgMZeiNalQrJZMC3QTC+DYLZO+cUZ+NTeLJTOK17/guAVUfOs2jt33SsEUznhmEEmCUSj8YyJuECAO84BxIabXuvrXEzcExnoUuOljYmLZmnLpCisjLbR0+jnxfRJ8uJ2KVrATjoZCJDJdPEoMHfavs+TVVZiavlj4ekIUyb240occmcjQErNdDhlJ6Df+dHyLyWgEebpqg1Wpx1WlCpkVQSZmSQJDRqDSqNGiQVkkqFpJJsi4arVKBSoQvwwa1uKBp3V3T+Pqh0WjENiHBHVbrpDyIiIsjOzrvV+48//lAGh3/77bfMnDlTOdaxY0fl7r6inDhxggEDBijb1apVY/v2vHl6hg8fzoEDB5TtiRMn8vzzz5fqnI8fP44sy9SpU6dU+W4nJyeHqKgoatWqhYuLS7mWLdxZJa07i1VGr7dw7FQGx89kIqlUnLtswM/PGYsM1xKsuDirUDm54O3jhLuTierVnHGW9EhaHVqtCtliQauW8XIxoTerUUkyGrWMr6uBTIPW1iWJrAxZUsZ5AZ7ORiyyhNGiKnJYdYH9N8sraVr7/bfJJxWy75a8EgXGcld6JoOenPQ0vD09AVtzZ2paGnqDHk93D1xdnJFkGaPRxI24OFQqiRqB/qgNWWgyU/ll204SU9Pp274lNQJ80aYl8vfFWD5Y/Bu9Iuox4Yn2aLJS0ZvNNJm2GICz/3lW6ap+49cdrD8dxYQWDRlcx9Ydvv7v03wUcxkf1MyvEYY5x0T6lWSm6lKJ0loZn+pME6Ptb/V/nMx876WnjlHF26l547E+8skmRmvl1VRnGt1Mu8fZxAJPA40Mal5Ny/tsvOebRbxG5u0UF+qY1Eq5cz31hJnUvJmal/ZTn2wuaa2MSHeivd4WqB7TmZnvZSDUomZCTt7Y2c9dMohRWRijd6OhxTa9yWm1idnOmVSzqpmUkzc+8BvnDC6ozTyndyPCYmvVvagy87VLBoFWFe/l5LVmz3HK5LTaxFCjK60ttha5q5KZz10y8LSqmKrPSztfl8VRjZEBRlc63Fy0PV6yMM05DRck/i8nbzjJEl0WBzUG+phc6XQzbSpWPnRJRS1LfK63pZUk+FWTxR6Nge5mFx432657NlbedU4F4DO9D5qbn6S1mmz+1Oj5l9mZPjfTmpF529n2p9gnem9cJNsHa7M6m981etpZnBhgzvvjcqIuGYsE7xt88OJmq7A6h/WabFpanBhizhvT/IVrBp/MW0SDdk0pqdt9b164cAFJksT0B7dT5BiSQpQkRrx15uvyKLMwJpPJrguxPEVFRd2RcoU7r6R15+0GHW6uWdw+AuDWuwZt3VYWi4zBCNk5MlYjWHNswZjBAhezZFQq29AZiwXMVomUdBXOzjdDkptdOfLNH0/bW10ClYbcICXv7Z+7Xcxda7c8yAtzbjleIA1IN9PlT3PrR0+WsYuwUlKteHpISiZJowOr5eZYNfs8qsJCvfzTVciA6mZR8s30BYK+m2ea+5SyrcUk/3Nl62U8XFW2Gw60WmSrBVmWba9PUoaT5b1m5SaFfMcBZyc3LFY35fltz+FpC3QSbXlUki2nSrJ1o56N0eHhZMJgBL8OrQhQwQUJ0n3VpGqsaIPgow7jqeJr5XCWCpUEKgmWrx2PKSuNiy4S7joTxmwTT3o+TMfkBEJ93TEHBaPGwkO1Qhl59Ax+Xh6EdOmAZDGhzUymy+/7iI5P5F+t61M3tDaZl+PIvhRD/cijhPl607BNS6VVLXTH30gp6dRuXIs6Af6kn4/Dy5AO8bE4+7gQXL+W7TtXBtXVc2A24RMeSIDO9iPqkZWGnHIdjbsOvxpVSLuUhEqr5rImEwB/S15tWYAsSSbHasWSk/c7ku1sJVMlYzKasdz8OTDqzGS6yGRbrZiz834jsnQWMjUyBqMZ882PoElrIdNVxlW2T5uttZChvZlWbzsPo8ZCuquMCivmrHzlqs2k56bNsRVsUltJd5UxW2XMWXmf92yVLW2O0YQ521auSWUlzVVGjYw5My9tlruZVK1MtsGMKVtvOwdJJtXF1iVuytDfvCUGstxMpGqtZBlNmLJsac3IpNxMa8w0oJHz0qZorWQazZgy9crzJQdYsUpgzMzBdLM1MsvVaEtrMmHKsK0lelxnZnimihsnziH5lr7bt7jvTd1duEu10gVSnp6eJe5eK8mgcC+vguNhylpmYbRarWiREhSi7iqvB6PubNNt5I77q96oAVZZxmq1jfuTZXi4cXsaD7IF5kZZxmqBNLOVoS1HKKUkIiO3gcZAbl+Bsiy3DP8ZpTzEDLgCjxsNdDYaUCGh0zmR2wI3OysTs8WMq4srarUGCZlHDXqaZ2agVqlw9/LGQ7YiI7E4MZ6slAQCvQNwUmuwZmThk5PFw6kpqCQJV50THh6eaDQapiTGYzSbCPDxw0Vr+1H3Neipl5yEVqulin+gEsRPTkrAYDLi7+WDq7MLMjI+RgMzkxLQatRUCQhWXs/ryYnoDXp8vXxwd7UFwT5GIzMT41GpVFQJyltzc1xSAtn6HHy9fPB0s7Xa+JtNfBt/A0lSERxc7eaFknk+NYnB2dn4eHjhffOudH+Lma/jrgMQXLWG8lfHs6nJ9M/OwtvdE28P22+dxWLhqzjbuMiqVWrY/mhAZnBaCk9kZeDl7omfpzdgGxf81fWrAIRUqY5aZetuHpCeSueMdDzc3Anw9lVe82exV0CGkKCqaG+ON+6dkUbb9FQ8XN0I9LHdPd3JZEHl70ODri1K9G7MVZIWqbuh0gVSwcHBdoFUcS1EAQEBRR7LlbuIbW45t2txKkmZhZEk6Y7Nouvi4iJm6K2kRN1VXqLu7mVFTx57v85s3voOpW1VirTlPMVukYr67N2tFRoq3UiCJk2a2G3nHyh+q4iIiNuW5+7uTu3atZVts9lcZFqVSkXTpk1vf5KCIAiCIDwQKl0g1bZtW7ttvV5faDqVSkWLFnnNhhcvXqR///60atWKr7/+usgyiyoPIDw8vNRdgYIgCIIg3L8qXSD12GOP4efnp2ynpaUpj/O3TnXs2BFvb29l+z//+Q8nT54kLS2NWbNmsXfvXuVY/rv2MjMz7crJ/7hv377l9joEQRAEQaj8Kl0gpdPpmDBhgrKdf/R+XFwcYBvY/frrr9vlO3XqVJHb9evXp0+fPoBtcF10dLRy7MYN2wSDISEhPP300+XyGgRBEARBuD9UukAKYODAgYwcORKAlStXkp2dTVxcHNu2bUOr1TJjxgzq1atnl+fW7QYNGthtT506lebNbfeXL1myBKvVys6dO4mNjSUgIIBZs2bdVwMTBUEQBEEou0p3116ud955h4cffpiFCxfSsWNH1Go1jzzyCOPGjSsQNAF8/PHHTJw4katXr/LMM8/Qpk0bu+MuLi4sWLCAefPmsWbNGlq2bIm7uzvDhw/n5ZdfxtfXt6JemiAIgiAIlUSlDaQAevToQY8ePUqUtk6dOvz222/FptHpdLz44ou8+OKL5XF6giAIgiDc5ypl154gCIIgCMK9QARSgiAIgiAIDhKBlCAIgiAIgoMk2dFVeIUSi4yMRJblcl9MUZZlTCYTWq32rk2NLzhG1F3lJequchP1V3ndru6MRiOSJNGsWbMKPa9KPdi8srhTH1ZJku7KStdC2Ym6q7xE3VVuov4qr9vVnSRJdyU4Fi1SgiAIgiAIDhJjpARBEARBEBwkAilBEARBEAQHiUBKEARBEATBQSKQEgRBEARBcJAIpARBEARBEBwkAilBEARBEAQHiUBKEARBEATBQSKQEgRBEARBcJAIpARBEARBEBwkAilBEARBEAQHiUBKEARBEATBQWLR4kpo69atzJ8/n7Nnz6JWq2nVqhUvv/wyDRo0uNun9sAwGAy0bduWzMzMItM899xzTJ48Wdk2Go0sWrSIlStXcv36dTw8POjcuTPjx4/Hz8+vyHKSkpKYNWsWW7duJSMjg+DgYAYMGMCIESPE4qsldPnyZRYvXswff/zBjh07ikxX0XV0+vRpZs2axYEDBzCZTISHh/Pcc8/RrVu3srzc+0pJ6y4yMpIhQ4YUW9bs2bPp1KmT3T5Rd+UrMTGRuXPnsn37dm7cuIG3tzetW7fm+eefp379+oXmkWWZFStWsGzZMqKionBycqJDhw688sor1KhRo8jnysrKYu7cuaxfv57k5GR8fX3p2bMnY8aMwd3dvch8MTExfPfdd+zatYucnBxq1arF0KFDeeqppxxb9FgWKpXPP/9cDgsLk59++mk5JydHjoqKkps2bSo3bNhQ/v333+/26T0wNmzYIIeFhRX5r2HDhvL169eV9Dk5OfLw4cPlsLAwedq0aXZltG/fXr506VKhzxMdHS136NBBDgsLk7du3SpbrVb5/fffl8PCwuRnnnlGzsrKqpDXWxlZrVZ5x44d8ujRo+Xw8HA5LCxMbt68eZHpK7qOtm/fLjds2FBu0aKFHBMTI2dmZsr9+/eXw8LC5E8//bTsF6ASK23dybIsT5kypdjP5BNPPCFbrVa7PKLuyteJEyfkRx55pMjvxPXr1xfIY7FY5DfffFMOCwuTX3nlFdlkMsmRkZFyeHi4HBERIUdGRhb6XMnJyXKvXr3ksLAwecGCBbIsy/L3338vh4WFyT169JATExMLzXf06FG5WbNmcoMGDeRjx47JRqNRHjt2rBwWFia//vrrstlsLvXrFl17lciKFSuYO3cuAIMGDcLZ2ZmaNWvSoUMHTCYTEyZM4OzZs3f5LB8Ma9asKfZ4jx49CA4OVranTJnC/v37ARg+fDgATzzxBD4+PsTHxzN69GgMBoNdGUajkdGjRxMXF0e1atXo0qULkiQxdOhQAA4cOMC7775bni/rvmAwGFi8eDG9e/dmzJgx7N69G1mWb5uvIuvo4sWLvPrqq5hMJjp37kz16tVxc3PjySefBGDevHksW7asTNehMnK07oxGI5s3by42zahRo+xaG0Tdla/09HReeuklkpOTCz1uMpl45513uH79ut3+b7/9lnXr1gEwbNgwNBoNERERNGjQgKysLJ5//nkSExMLlPfKK69w7tw5dDodgwcPBmDo0KFIksSFCxd4+eWXC+RJTk7mhRdeIDMzk2bNmtG4cWO0Wi1PP/00ABs3buSrr74q9WsXgVQlYTQa+e6775TtkJAQ5XHNmjUB2xvVkTeBUDpJSUkcOHCAQ4cOcfbs2UL/zZgxQ0l/4cIF5YtCo9FQvXp1ACRJUuouNjaWJUuW2D3PypUruXLlCmBf37Vq1VIeb9y4kePHj9+R11lZSZJEy5YtWbduXYk/DxVdRzNnzsRoNBbIl/tcuWlycnJKdP73C0fqDmDnzp3UrFmzyM/j2bNneeqpp+zyiLorXwsWLKBatWosWbKEI0eOsGnTJnr16mWXxmAwsHLlSmU7OTmZBQsWKNv5r2FuPWRmZjJ79my7cnbt2sXBgwcBCA4OxsnJCQB3d3f8/f0BOHLkCFu2bLHLN2/ePFJTU4Gi627hwoXExcWV5qWLQKqy2Lt3L9euXVO28/f/5u/H37VrFxkZGRV6bg+aDRs20KZNGzw8PEqUftWqVVitVgBcXV3tjuWvu/Xr19sdy/+F4+bmVmgesH3ZC3l0Oh3h4eFIkkSXLl1KlKci6ygzM9PuC76ofImJiezbt69E53+/cKTuwNZC3KNHj1I9l6i78pWYmMhPP/1EixYtcHFxoXbt2nzxxRe0bt3aLl1uIAOwadMmsrOzle2irufGjRvtWiaLqrtb823YsMHu2KpVq277XAaDga1btxb9QgshAqlK4tYPpVarLTSdxWJ54D7AFW3NmjVs376dFi1a0KlTJ8aOHcusWbOIiYkpNH1udxEUXW9gG7yakpIC2L6wT506VaJ8f//9d2lfwgOjpIPxK7KODh06hMViKXW+B01J6y41NZUdO3bw2Wef0bp1a5544gneeOMNli5dSnp6eqF5RN2Vv6lTpxZaZ/3797fbzt/il/9zB0Vfz+TkZE6fPq1sHzhw4LZ5wPa7mfsH0vnz50lKSipRvtLWnQikKonDhw/bbWs0Rd9weeTIkTt8Ng+uixcvcuLECWRZJiMjg9jYWHbs2MHXX39N165def311+0+rAaDwe4LoLh6s1qtHDt2DICjR4/afWEXl+/cuXMPXDdCearoOrr1s1zcF/rRo0eLP3mBTZs2YTKZMJvNpKamcunSJTZs2MCHH35Ihw4d+Prrr5WuuFyi7ipOblcb2K5z/pZGR37XoqKi7MZhFZcnLS2Ny5cvl/q5Slt3IpCqJOLj4+22Vaqiqy7/D7lQvtauXVvkMVmW2bRpE3369OHixYuArbk7/xd2cfUGeXVXmvqWZVnUeRlUdB3dmq+4261Fvd5ecTd+6PV6Zs2axbPPPktWVpayX9RdxYmNjVUe9+7dW7kJx2q1FrhGJfldK03dAcpA9dLkS0lJUVqySkIEUpVEbndCruI+wEXdNSGUjSzLyoDk4iQmJvLyyy9jNBoL1NvtPvS5dedoPqH0KrqOSpNP1GvxYmJiCrQ0FCYyMpKpU6cq26LuKs6ePXsACAwMZNKkScr+tLQ0uz9goGTXsyLqzmq12o3luh0xIWclYTKZSpy2JLcLC6UnSRLbt2/HaDSSmZlJVFQUx48fZ8uWLfzzzz92aaOioli3bh2hoaGleo7curu1K0K4c0p7rctaR6XJJz7LxatRowZnz54lJyeH9PR0Lly4wKFDh9i4cSNRUVF2aVevXs348eOpUaOGqLsKEh8fz/bt23FxceG7777Dx8dHOVZRn7uy5isJ0SJVSXh6epY4bf43q1D+dDodvr6+NGvWjGeffZalS5eybNkywsLC7NLt2bMHLy+vUpWdW3elqe/8+YTSq+g6Ep/l8ufi4kJQUBDt2rXjtddeY9OmTUyfPr1A3e7duxcQdVdRvvrqK2RZ5ssvv6RJkyZ2x+7lz50kSXh7e5c4vQikKon8kztC8dFyQEDAnT4d4RbNmjVj+fLltGzZUtmXlpZGUFCQXTfs7f7Kya27KlWq2O0vLp9KpSp2+RKheBVdR6XJJz7LjlGpVPTr14+VK1fafTZyu2tE3d15O3fuZN26dXz55ZcFluUBcHZ2LhCslOR6lqYOwNalWNp8vr6+qNXqYsvNTwRSlcSt0fytfcv5RURE3OnTEQrh4uLCF198odzJU61aNdzd3aldu7aSxmw2F5lfpVLRtGlToGB9F5cvPDy8wNxHQslVdB01btzY7pj4LN85NWrU4L333lO2cydaFXV3Z8XFxTFlyhT++9//Flh7MDY2VpmipzT10KxZMwDq1Klj931XXB5vb2/ls30nf0NFIFVJtG3b1m5br9cXmk6lUtGiRYuKOCWhEEFBQTRv3hyAdu3aAfZ1V1S9ge0LO7e528/Pz66rsLh8rVq1KtM5CxVbR61bt7a79bq4qStE3ZZdt27d0Gq1aLVa5btR1N2dYzQamTx5Mp9++qndVAcWi4WoqCjefvttpTWopL9r3t7eSn2pVCq7ST6Lq7sWLVoorc3169e3awErz7oTgVQl8dhjj9k1UaelpSmP80fWHTt2LFXfrlA6RqORM2fOFPvh9fT0JDQ0VPkSGTBggHIsMzPTrr7yP+7bt69dOfnz5Z9Y8Na/pG7NJ+S59RbmoprzK7KO/Pz86NixY6H58p+vr68vjz76aKHn+yAoad2lpqZy4cKFIm9X12g0uLm50a9fP6WbB0Td3Snvv/8+e/bsYeTIkYSHhyv/GjRoQPfu3Tl06BDh4eEA9OrVy24Sz6J+13r37m13l13+5X5unXS1qM+rVqulT58+hebLX3darbbUs+SLQKqS0Ol0TJgwQdnOf0dK7rpAWq2W119/vYLP7MEyYsQI+vbtS7t27Zg/f36BL+/s7GzOnTvH119/rXzw69evr3yArVYr0dHRSvobN24AtnWfchfOzDVkyBBlFuD89Z2bB2yLIzds2LDcXt/9JjMz025br9cX+oNb0XU0YcIEZX2wovK9+uqrJZ7d+35UkrpLTEyke/fu9OzZk27durFz584C5Zw6dYqAgAAmT55st1/UXfn78ccf7ZZhKUxAQAC+vr7K49GjRyvHCrueXl5evPDCC3ZldO7cWWldjIuLU1qXzGazMt9UREREgWWGxo4dqww+L6ruRo4cWerxbSKQqkQGDhzIyJEjAdtaQ9nZ2cTFxbFt2za0Wi0zZsygXr16d/ck73O5k/plZmby6aefMmTIEP755x+sVis3btzg22+/5bPPPlP+4so1depUpctvyZIlWK1Wdu7cSWxsLAEBAcyaNavAOCcnJydmz55NQEAA8fHxyur2uSvLN2/enI8++uhOv+RKS6/XM3/+fLt9ZrOZn376qdBxFRVZR3Xr1mXGjBlotVp27txJdHQ0RqNRWUNs+PDhDBkypOwXoZIqad1ZLBaldTgmJoYxY8bw9ttvc+XKFWRZ5tixY6xevZp58+bZrU8Kou7K29atW/n8889vm+7W78ZXX32V7t27A/Dzzz9jMpk4e/YskZGRuLm5MXPmTIKCguzySJLEN998Q+3atTGbzUqdLV++HJPJRO3ate3+mM3l7+/PzJkzcXd359ixYxw9ehSr1covv/wCQPfu3XnttddK/dolWUx2Uels3LiRhQsXcvHiRdRqNS1btmTcuHEiiKoASUlJzJkzh7/++ovY2FhkWSYgIIAGDRrQpUsXnnjiCeWv1VsZjUbmzZvHmjVriI+Px93dna5du/Lyyy8rf6EVJiEhgZkzZ/Lnn3+SlZVFcHAwAwYMYMSIEcUuc/Aga9asGdnZ2UV2B6nVagYNGsQHH3xgt7+i6+j48ePMmjWLw4cPY7VaqVOnDqNGjSrVgr33m9LW3enTp/nhhx+IjIwkISEBnU5HUFAQLVu25PHHH1fGKhZF1F3ZXbx4kQEDBpRoqapRo0bZTcwJtm7bZcuWsXz5cq5evYqTkxMdOnRg/Pjxyg0ChcnMzGT27Nls3ryZlJQUfH196dWrF2PGjCn2BpyoqChmzpzJ3r17MRgMhISEMHToUAYMGFDsZNdFEYGUIAiCIAiCg0TXniAIgiAIgoNEICUIgiAIguAgEUgJgiAIgiA4SARSgiAIgiAIDhKBlCAIgiAIgoNEICUIgiAIguAgEUgJgiAIgiA4SARSgiAIgiAIDhKBlCAIgiAIgoNEICUIgiAIguAgEUgJgiAIgiA4SARSgiAIgiAIDhKBlCAIgiAIgoM0d/sEBEEQ8uvVqxfnz58vt/K+/vprHn/8cYfyWq1WVCrx9+bdIq6/UBmId6gg3AcmTpxIs2bNWLJkyd0+lTLJyMjgwoUL5Vpm06ZNS53n6tWr/Pvf/+bMmTPlei4PEqvVys6dO3nxxRfp0qWLQ2VERkby8ccfk5qaWr4nJwjlSLRICcJdEB4eXqb877zzDiNHjgQgOTmZtWvXAvDzzz8zbNiwsp7eXXP06FFkWS638oKCgggODi5Vnj///JM5c+Ywbdo0HnrooXI7lwfJ6tWr+eGHH5SguFq1ag6V06JFC1QqFUOHDuWTTz4hIiKiPE9TEMqFCKQE4S5p3LgxkydPJjw8HBcXFwAOHjyoBEj9+vXjk08+AcBisXDt2jWWL1/O/Pnz7crx9fWlT58+bNu2jcGDB1foayhv8fHxNGzYsNBjGRkZREdHF9gfEhKCh4dHoXlatWpVqudfu3YtM2bM4JdffnH4x1+Axx9/nN69ezNy5EgOHDhQprKaNWvGp59+ygsvvMC0adPo3LlzOZ2lIJQPEUgJwl3g5eXF//73P7y8vOz25x8PIkkSGo3tI6rRaAgNDWXSpEkYjcYC5X322Wd39oQrSP/+/enfv3+hxxYuXKgElvl98cUXNGnSpMzPvWfPHt555x1mzZolgqgycnZ2BqBRo0ZlDqQAmjRpwmuvvcZbb73F8uXLqVu3bpnLFITyIsZICcJd0K1btwJBVEkNGjSonM+mcjh9+nSBfWq1mrCwsDKXnZaWxqRJk2jcuDEdO3Ysc3mCjZOTU7mVNWTIEEJCQhg/fjyZmZnlVq4glJUIpAThLihLF9xDDz3EI488Uo5nUzkUFkiFhoYqrR9l8fnnnxMfH8+zzz5b5rKEPGq1utzKkiSJ5557jqioKObOnVtu5QpCWYlAShDugkaNGjmcV6PRUK9evXI8m3ufyWQq9G6+8rgOMTExrFq1Co1GQ4cOHcpcnnDndOnSBa1Wy6JFi0hOTr7bpyMIgBgjJQiVXnJyMqtXr2b58uX07NmTV155xe74gQMHWLRoEWfOnGHr1q3IssyyZctYunQp0dHR1KxZk5deeokePXoAtoHtS5Ys4ddff+XKlSsEBwczatSoYlvRtm3bxi+//MLx48fJzMwkKCiIjh07MnbsWIKCgsr8Gi9evIjJZCqwv379+mUu+6effsJsNtOyZUvc3d2LTGc0Gpk9ezZr164lLi6O4OBg2rdvT926dTl58iTTpk0rNJ8j12bfvn0sWbKEyMhI0tLS8PPzo3379owfP54qVaoUeY4nTpxg8eLFHDx4kPj4eLy8vIiIiGDIkCG0bdu2QHqLxcL27dtZsmQJFouFRYsWYTAY+PHHH/ntt99ITEykUaNGvPvuu8Ve64sXLzJv3jz27NlDQkICgYGB9O3bF4vFUq7X093dnbCwME6ePMmCBQt44403iixfECqKaJEShErKbDYzefJkunbtyvTp07l8+bLd8W3bttG3b1+GDx/O77//jsViwWg0Mm7cOGbMmEFqaioGg4Fz587xxhtv8Mcff6DX6xkzZgyfffYZGRkZGI1Grly5wvvvv8+aNWsKnIPJZGLixInMmzePF198kW3btrF06VKqVq3KkiVL6Nu3b7nMxVRYtx6UPZCyWCxs2rSpRGWNGzeOjRs3Mn36dPbt28fXX3/N1atXmTp1aqE3ADhybSwWC1OnTmX8+PF07tyZzZs388cffxAREcGKFSvo168fZ8+eLfT85s6dy9NPP01wcDBLly5l9+7dvPbaa+zdu5fnnnuODz74wG5qiWXLlvHUU08xfvx49u7dC0BcXByDBw9m3rx5ZGVlkZOTo9xJmpaWVujzrlu3jieffJIbN24we/Zs9u3bx3vvvcfq1asL3GFaluuZK7c1d82aNeU6VYYgOEwWBOGesW/fPjksLEwOCwuTJ02adNv0BoNBjo2NlcPDw+WwsDD5m2++UY7duHFDTkxMlAcOHCiHhYXJ7du3lydOnCgvWbJE1uv1sizL8qFDh+RmzZrJYWFh8lNPPSW//PLL8pw5c+SMjAxZlmX5+vXr8uOPPy6HhYXJPXv2LPD8H3/8sdyrVy85JyfHbn92drb86KOPymFhYXL37t1ls9lclssif/LJJ8p1yf8vKSmpTOVGRkYqZS1ZsqTIdH/99ZccFhYmb9myxW6/2WyWBw4cKL/55psF8jhybaZNmyaHhYXJO3futMsTHR2tnOfgwYMLPNeyZcvksLAwecaMGQWO7dmzR3l/TJ8+XdmfmZkpWywWuWfPnnJYWJjcu3dveeTIkfKWLVtki8Uiy7IsL168WHneH3/8sdCy69evLw8ePFg2mUx2xy5duiQ3bNhQDgsLk//1r3/ZHXPkeub64YcflHM6ceJEkekEoaKIFilBqMR0Oh1Vq1Yt9A7AoKAg/Pz8lEkMs7OzeeWVVxg6dKhyN1Xz5s3p27cvAMeOHeP5559n7NixShdXcHAwI0aMAOD8+fPk5OQo5V++fJlFixYxaNCgAgO+XVxclBnFL1++zL59+8r0OgtrkQoMDMTX17dM5Z44cUJ5HBISUmS6kydPAnD9+nW7/Wq1mrFjxxZI78i1ye2uioiI4NFHH7XLU6NGDaUbMDEx0e5YQkIC06dPR5IkRo0aVeBc2rRpQ8+ePQGYP3++0grm5uaGSqVSJh1NTU3l008/pVu3bso0HIMHD8bb2xuA48eP25VrNBp59913sVgsvP3228pUHblCQ0N57LHHCpxP7muFkl/P/KpXr648/ueff4pNKwgVQQRSgnAfyJ3Qs7hjXl5e1KhRo8Dx2rVrK48Lmzm6atWqyuP09HTlcW7Xyrfffku7du0K/Pvzzz+VtOfOnSvdC7pFYd1Z5TE+Kv95eXp6FpnOx8cHgG+++YYdO3bYHevQoQOurq52+xy5NkuXLgUodCwTwOLFi3nvvff47rvv7Pb/9ttvZGdnExoaip+fX6F5c8e3Wa1W5Xly6XQ6AGrWrFlgzJZarVbqPyMjo8BrjI2NxdfXt8gZx4ua76m01zO/gIAA5fGlS5eKTCcIFUUMNheE+0BxC7ve7hb04n60ALsWlfwDvo8cOQLABx98QMuWLYstw83NrdjjxYmNjS10fE55BFIpKSnK4+KuQ5cuXZgxYwbp6emMHTuW9u3b89JLL9GiRQt0Oh1Tp061S+/ItTl48CBAkUvahISEMHz48AL7t27dCoC/v3+Rz9G0aVN0Oh1Go7HABJm3e3/ktk7eOm5py5YtgC0AK0pR78vSXs/88v/REBcXV+y5C0JFEC1SgiA4JLeLSZZlAgICiv13u2CtOHdqoDlgN7FjcZNH+vj4MG/ePKX776+//mLYsGEMGzasQJcXOHZtcoOCwu5OLE7usjmSJBWZRqvVKq2RCQkJpSq/KKdOnQKKbw0tSmmvZ375A/v8Xc2CcLeIQEoQBIfk/uCXx115xbmTgVT+cT16vb7YtI0bN2b9+vW8/fbbStfUoUOHGDRoUIHuMkeujXzzDrSrV6+WOA/Yxr6BfetaYXK7Lh2dUf9Wua2E+bt7S6M01zO//C1o5TEZqyCUlQikBEFwSO6P37Zt24pNp9frldYLRxQWSLm5uRU7OLyk8gcVJWndcHJyYvTo0Wzfvp1XXnkFnU6H1Wpl6tSpygBqcOza5I5v+vvvv4vNc/XqVbtB2rnzSkVFRRU7bUBuoFZcV1xp5Hb5Xbp0CbPZ7FAZJb2e+WVlZSmPixvXJggVRQRSgiA4JHeh4EuXLrF27doi0/3222/ExsY6/DyFteqEh4cX25VVUvmDilsHU+e3YMECjh49qmy7uroyfvx4li1bhrOzM7IsK/NRgWPXJjfP2bNni73LcebMmXbdkLnLBRmNRvbv319kvtyZwLt161ZkmtLIXeMwOzu7wIDxW906MWdpr2d++QOp8gimBaGsRCAlCPcQq9Va6OPbyW1tkAuZoLCwfY7KX1bv3r2Vxx9++KHdD2Ou2NhYFi9eXOB2/pJKT08vNAgrj249sF+q53bB3rp16wrN36dPH8C+RcuRa5NbDsCUKVMK7arbuHEjaWlpdtM+DB06VBnUvWTJkkLPPTU1ldjYWLy9vZUZ7HOV9H126/sofzm5E7gWlSe3+zG/0lzP/OLj45XHDRo0KMGZC8KdJQIpQbiH5B8InJSUVOJ8uT9i+QdP58rdl/8v+fwMBoPyuLAfvPzdRfnLaNy4sTIHVWZmJsOGDWP69OkcOnSIY8eOMX/+fJ566imef/75YgdyF+dOjo8CaNGiBVqtFrCtuVecZcuWFbjjDVC6tdq0aaPsc+TadOrUSZn64MqVKwwYMIBff/2VU6dOsXPnTiZNmsTkyZN588037Z6/Xr16jBw5EoA///yTP/74o8A5/vzzz1gsFv79738XGCOVmpoK3H6M2K3vrQEDBiitUlFRUYwYMULpprRarWzcuFEJ7NLT09mwYQMHDhxQArfSXM/8cmfw12q1NG/evNhzFoSKIAIpQbgHGI1GTp06xQ8//KDsO3jwIJs3byYzM7PIViW9Xs/y5cuVQGrz5s2cOXMGk8mE2WzmwoUL/P7774DtB3PFihVKsGQ2m4mJibFb+mXRokWkpqYiyzJWq5W4uDh++eUX5fjChQvtWko+/PBDpUXFZDIxb948hg0bxsCBA/n000/p168fTz75pMPXpahAqrwWbfb09KR9+/aAbcLR4pjNZsaMGcOcOXOIiooiLS2NX3/9lbVr19K7d2+6dOlil76010aSJL744gsaNmwI2Fqs3nvvPZ588knGjBnDli1b+O9//0udOnUKnNvEiROVsiZMmMDixYtJTk4mOTmZH3/8ke+++44pU6YowV3u6zly5Igy7cKZM2fYtWuXElAZjUYiIyOVSUvPnz/Pjh07lMBap9Mxa9Ys5W7AU6dO8eSTT/Loo4/Spk0b5s2bZ9fK9uWXX3LhwgXlvVza65krd+6o9u3bl9vAeUEoC0kuz3Z/QRBKLT09/bZzDX3wwQcMGTKkwP5HH3200Ll0evToQbVq1ewCs/wOHjzIt99+y8KFCws9/ssvv3DkyBH+7//+r9Djv//+uzK+yGq1smrVKlasWKFMnFm/fn2effZZunfvXuzrup3Jkyfz22+/2e3TaDRERkY63Mp1qwMHDjB8+HB8fHyKHJu0YMGCAtdCp9NRt25dhg0bRv/+/Qsds+XItTEajSxYsIA1a9YQHR2Nh4eHMs9SaGhosa8ld4HkEydOkJWVRZUqVWjVqhXDhw9XWo9yTZgwgY0bNxYow9vbm/3799OpU6dCuzsbNmzIqlWrlO2MjAzmzJnD5s2biYuLo0qVKvTt25cxY8bw/fffs2XLFl544QV69eql3HHn6PWUZZkOHTqQkJDA999/X+TM6YJQkUQgJQjCA2/EiBHs37+fX3/9VRn0Ldx7Tpw4wYABA2jcuDErVqy426cjCIDo2hMEQeCNN95ArVYXaP0S7i1r165FrVbz7rvv3u1TEQSFCKQEQXjgNW3alLfeeosVK1aUekJMoWLExcXx888/8/zzzxe5tp8g3A2ia08QBOGmN954g4SEBBYsWHDbNeiEiiPLMuPHj0etVvPf//632LUlBaGiiXejIAjCTTNmzKBmzZq899575Tr/llA2M2bMwMnJic8//1wEUcI9R7RICYIg3GL58uUcPnyYd999V1kKRah4aWlpTJs2jUaNGjF8+PC7fTqCUCgRSAmCIBQiOTmZ7OxsqlevfrdP5YF1+fJlvLy87GZyF4R7jQikBEEQBEEQHCQ6mwVBEARBEBwkAilBEARBEAQHiUBKEARBEATBQSKQEgRBEARBcJAIpARBEARBEBwkAilBEARBEAQHiUBKEARBEATBQSKQEgRBEARBcJAIpARBEARBEBwkAilBEARBEAQH/T8ttkXSgmfYfwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cox_dict = {\n", + " \"adv_failure_rate\": \"Adv. Failure Rate\",\n", + " \"def_value\": \"Defence Strength\",\n", + " \"data.sample.random_state\": \"Random State\",\n", + " \"train_time\": \"Training Time\",\n", + " \"model_layers\": \"No. of Layers\",\n", + " \"model.art.pipeline.initialize.kwargs.optimizer.lr\": \"Learning Rate\",\n", + " \"adv_accuracy\": \"Adv. Accuracy\",\n", + " \"adv_fit_time\": \"Adv. Fit Time\",\n", + " \"adv_log_loss\": \"Adv. Log Loss\",\n", + " \"predict_time\": \"Inference Time\",\n", + " \"accuracy\": \"Ben. Accuracy\",\n", + " \"failure_rate\": \"Ben. Failure Rate\",\n", + " \"atk_value\": \"Attack Strength\",\n", + "}\n", + "\n", + "cox_afr, cft = plot_aft(\n", + " X_train,\n", + " file=\"cox_aft.pdf\",\n", + " event_col=target,\n", + " duration_col=duration_col,\n", + " title=\"Cox AFR Model\",\n", + " mtype=\"cox\",\n", + " replacement_dict=cox_dict,\n", + ")\n", + "cox_scores = score_model(cft, X_train, X_test)\n", + "cft.print_summary()\n", + "cox_partial = plot_partial_effects(\n", + " file=\"cox_partial_effects.pdf\",\n", + " aft=cft,\n", + " covariate_array=\"model_layers\",\n", + " values_array=[18, 34, 50, 101, 152],\n", + " replacement_dict=cox_dict,\n", + " title=\"Survival Time for Cox AFR\",\n", + " ylabel=\"% Chance of Survival\",\n", + " xlabel=\"Time $T$ (seconds)\",\n", + " legend_kwargs={\n", + " \"title\": \"No. of Layers\",\n", + " \"labels\": [\"18\", \"34\", \"50\", \"101\", \"152\"],\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
modellifelines.LogNormalAFTFitter
duration col'adv_fit_time'
event col'adv_failures'
number of observations1500
number of events observed1500
log-likelihood-5374.54
time fit was run2023-09-29 11:13:31 UTC
\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", + " \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", + " \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", + "
coefexp(coef)se(coef)coef lower 95%coef upper 95%exp(coef) lower 95%exp(coef) upper 95%cmp tozp-log2(p)
mu_adv_failure_rate-0.001.000.00-0.00-0.001.001.000.00-31.84<0.005736.80
atk_value0.081.090.16-0.220.390.801.480.000.520.600.74
data.sample.random_state0.021.020.02-0.020.060.981.060.000.830.411.30
def_value-0.160.850.16-0.480.160.621.170.00-0.980.321.62
model.art.pipeline.initialize.kwargs.optimizer.lr-0.001.000.00-0.000.001.001.000.00-0.060.950.07
model_layers0.011.010.000.010.011.011.010.007.13<0.00539.81
predict_time-0.210.810.02-0.26-0.160.770.850.00-8.37<0.00553.94
train_time0.001.000.000.000.001.001.000.007.13<0.00539.89
Intercept2.027.540.171.682.365.3710.610.0011.63<0.005101.36
sigma_Intercept0.842.310.020.800.872.232.390.0045.86<0.005inf

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Concordance0.84
AIC10769.08
log-likelihood ratio test925.72 on 8 df
-log2(p) of ll-ratio test643.78
\n", + "
" + ], + "text/latex": [ + "\\begin{tabular}{llrrrrrrrrrrr}\n", + " & & coef & exp(coef) & se(coef) & coef lower 95% & coef upper 95% & exp(coef) lower 95% & exp(coef) upper 95% & cmp to & z & p & -log2(p) \\\\\n", + "param & covariate & & & & & & & & & & & \\\\\n", + "\\multirow[c]{9}{*}{mu_} & adv_failure_rate & -0.00 & 1.00 & 0.00 & -0.00 & -0.00 & 1.00 & 1.00 & 0.00 & -31.84 & 0.00 & 736.80 \\\\\n", + " & atk_value & 0.08 & 1.09 & 0.16 & -0.22 & 0.39 & 0.80 & 1.48 & 0.00 & 0.52 & 0.60 & 0.74 \\\\\n", + " & data.sample.random_state & 0.02 & 1.02 & 0.02 & -0.02 & 0.06 & 0.98 & 1.06 & 0.00 & 0.83 & 0.41 & 1.30 \\\\\n", + " & def_value & -0.16 & 0.85 & 0.16 & -0.48 & 0.16 & 0.62 & 1.17 & 0.00 & -0.98 & 0.32 & 1.62 \\\\\n", + " & model.art.pipeline.initialize.kwargs.optimizer.lr & -0.00 & 1.00 & 0.00 & -0.00 & 0.00 & 1.00 & 1.00 & 0.00 & -0.06 & 0.95 & 0.07 \\\\\n", + " & model_layers & 0.01 & 1.01 & 0.00 & 0.01 & 0.01 & 1.01 & 1.01 & 0.00 & 7.13 & 0.00 & 39.81 \\\\\n", + " & predict_time & -0.21 & 0.81 & 0.02 & -0.26 & -0.16 & 0.77 & 0.85 & 0.00 & -8.37 & 0.00 & 53.94 \\\\\n", + " & train_time & 0.00 & 1.00 & 0.00 & 0.00 & 0.00 & 1.00 & 1.00 & 0.00 & 7.13 & 0.00 & 39.89 \\\\\n", + " & Intercept & 2.02 & 7.54 & 0.17 & 1.68 & 2.36 & 5.37 & 10.61 & 0.00 & 11.63 & 0.00 & 101.36 \\\\\n", + "sigma_ & Intercept & 0.84 & 2.31 & 0.02 & 0.80 & 0.87 & 2.23 & 2.39 & 0.00 & 45.86 & 0.00 & inf \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\n", + " duration col = 'adv_fit_time'\n", + " event col = 'adv_failures'\n", + " number of observations = 1500\n", + "number of events observed = 1500\n", + " log-likelihood = -5374.54\n", + " time fit was run = 2023-09-29 11:13:31 UTC\n", + "\n", + "---\n", + " coef exp(coef) se(coef) coef lower 95% coef upper 95% exp(coef) lower 95% exp(coef) upper 95%\n", + "param covariate \n", + "mu_ adv_failure_rate -0.00 1.00 0.00 -0.00 -0.00 1.00 1.00\n", + " atk_value 0.08 1.09 0.16 -0.22 0.39 0.80 1.48\n", + " data.sample.random_state 0.02 1.02 0.02 -0.02 0.06 0.98 1.06\n", + " def_value -0.16 0.85 0.16 -0.48 0.16 0.62 1.17\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr -0.00 1.00 0.00 -0.00 0.00 1.00 1.00\n", + " model_layers 0.01 1.01 0.00 0.01 0.01 1.01 1.01\n", + " predict_time -0.21 0.81 0.02 -0.26 -0.16 0.77 0.85\n", + " train_time 0.00 1.00 0.00 0.00 0.00 1.00 1.00\n", + " Intercept 2.02 7.54 0.17 1.68 2.36 5.37 10.61\n", + "sigma_ Intercept 0.84 2.31 0.02 0.80 0.87 2.23 2.39\n", + "\n", + " cmp to z p -log2(p)\n", + "param covariate \n", + "mu_ adv_failure_rate 0.00 -31.84 <0.005 736.80\n", + " atk_value 0.00 0.52 0.60 0.74\n", + " data.sample.random_state 0.00 0.83 0.41 1.30\n", + " def_value 0.00 -0.98 0.32 1.62\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr 0.00 -0.06 0.95 0.07\n", + " model_layers 0.00 7.13 <0.005 39.81\n", + " predict_time 0.00 -8.37 <0.005 53.94\n", + " train_time 0.00 7.13 <0.005 39.89\n", + " Intercept 0.00 11.63 <0.005 101.36\n", + "sigma_ Intercept 0.00 45.86 <0.005 inf\n", + "---\n", + "Concordance = 0.84\n", + "AIC = 10769.08\n", + "log-likelihood ratio test = 925.72 on 8 df\n", + "-log2(p) of ll-ratio test = 643.78" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_773113/12050270.py:64: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " pareto.set_yticklabels(labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log_normal_dict = {\n", + " \"Intercept: sigma_\": \"$\\sigma$\",\n", + " \"Intercept: mu_\": \"$\\mu$\",\n", + " \"def_value: mu_\": \"Defence Strength\",\n", + " \"atk_value: mu_\": \"Attack Strength\",\n", + " \"train_time: mu_\": \"Training Time\",\n", + " \"predict_time: mu_\": \"Inference Time\",\n", + " \"adv_fit_time: mu_\": \"Adv. Fit Time\",\n", + " \"model_layers: mu_\": \"No. of Layers\",\n", + " \"model.art.pipeline.initialize.kwargs.optimizer.lr: mu_\": \"Learning Rate\",\n", + " \"data.sample.random_state: mu_\": \"Random State\",\n", + " \"adv_log_loss: mu_\": \"Adv. Log Loss\",\n", + " \"adv_accuracy: mu_\": \"Adv. Accuracy\",\n", + " \"accuracy: mu_\": \"Ben. Accuracy\",\n", + " \"adv_failure_rate: mu_\": \"Adv. Failure Rate\",\n", + " \"def_gen\": \"Defence\",\n", + " \"learning_rate: mu_\": \"Learning Rate\",\n", + "}\n", + "\n", + "log_normal_graph, lnt = plot_aft(\n", + " X_train,\n", + " \"log_normal_aft.pdf\",\n", + " target,\n", + " duration_col,\n", + " \"Log Normal AFR Model\",\n", + " \"log_normal\",\n", + " replacement_dict=log_normal_dict,\n", + ")\n", + "lnt_scores = score_model(lnt, X_train, X_test)\n", + "lnt.print_summary()\n", + "lnt_partial = plot_partial_effects(\n", + " file=\"log_normal_partial_effects.pdf\",\n", + " aft=lnt,\n", + " covariate_array=\"model_layers\",\n", + " values_array=[18, 34, 50, 101, 152],\n", + " replacement_dict=log_normal_dict,\n", + " title=\"Survival Time for Log-Normal AFR\",\n", + " ylabel=\"% Chance of Survival\",\n", + " xlabel=\"Time $T$ (seconds)\",\n", + " legend_kwargs={\n", + " \"title\": \"No. of Layers\",\n", + " \"labels\": [\"18\", \"34\", \"50\", \"101\", \"152\"],\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
modellifelines.LogLogisticAFTFitter
duration col'adv_fit_time'
event col'adv_failures'
number of observations1500
number of events observed1500
log-likelihood-5426.84
time fit was run2023-09-29 11:13:33 UTC
\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", + " \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", + " \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", + "
coefexp(coef)se(coef)coef lower 95%coef upper 95%exp(coef) lower 95%exp(coef) upper 95%cmp tozp-log2(p)
alpha_adv_failure_rate-0.001.000.00-0.00-0.001.001.000.00-26.62<0.005516.20
atk_value0.071.070.17-0.260.400.771.490.000.420.670.58
data.sample.random_state0.021.020.02-0.020.060.981.070.000.910.361.47
def_value-0.190.820.18-0.540.150.581.160.00-1.110.271.90
model.art.pipeline.initialize.kwargs.optimizer.lr0.001.000.00-0.000.001.001.000.000.030.970.04
model_layers0.011.010.000.010.021.011.020.007.88<0.00548.13
predict_time-0.310.740.04-0.38-0.240.690.790.00-8.73<0.00558.49
train_time0.001.000.000.000.001.001.000.006.12<0.00530.02
Intercept1.886.540.191.512.254.529.460.009.97<0.00575.31
beta_Intercept-0.320.720.02-0.36-0.280.690.750.00-15.46<0.005176.59

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Concordance0.82
AIC10873.68
log-likelihood ratio test961.93 on 8 df
-log2(p) of ll-ratio test669.73
\n", + "
" + ], + "text/latex": [ + "\\begin{tabular}{llrrrrrrrrrrr}\n", + " & & coef & exp(coef) & se(coef) & coef lower 95% & coef upper 95% & exp(coef) lower 95% & exp(coef) upper 95% & cmp to & z & p & -log2(p) \\\\\n", + "param & covariate & & & & & & & & & & & \\\\\n", + "\\multirow[c]{9}{*}{alpha_} & adv_failure_rate & -0.00 & 1.00 & 0.00 & -0.00 & -0.00 & 1.00 & 1.00 & 0.00 & -26.62 & 0.00 & 516.20 \\\\\n", + " & atk_value & 0.07 & 1.07 & 0.17 & -0.26 & 0.40 & 0.77 & 1.49 & 0.00 & 0.42 & 0.67 & 0.58 \\\\\n", + " & data.sample.random_state & 0.02 & 1.02 & 0.02 & -0.02 & 0.06 & 0.98 & 1.07 & 0.00 & 0.91 & 0.36 & 1.47 \\\\\n", + " & def_value & -0.19 & 0.82 & 0.18 & -0.54 & 0.15 & 0.58 & 1.16 & 0.00 & -1.11 & 0.27 & 1.90 \\\\\n", + " & model.art.pipeline.initialize.kwargs.optimizer.lr & 0.00 & 1.00 & 0.00 & -0.00 & 0.00 & 1.00 & 1.00 & 0.00 & 0.03 & 0.97 & 0.04 \\\\\n", + " & model_layers & 0.01 & 1.01 & 0.00 & 0.01 & 0.02 & 1.01 & 1.02 & 0.00 & 7.88 & 0.00 & 48.13 \\\\\n", + " & predict_time & -0.31 & 0.74 & 0.04 & -0.38 & -0.24 & 0.69 & 0.79 & 0.00 & -8.73 & 0.00 & 58.49 \\\\\n", + " & train_time & 0.00 & 1.00 & 0.00 & 0.00 & 0.00 & 1.00 & 1.00 & 0.00 & 6.12 & 0.00 & 30.02 \\\\\n", + " & Intercept & 1.88 & 6.54 & 0.19 & 1.51 & 2.25 & 4.52 & 9.46 & 0.00 & 9.97 & 0.00 & 75.31 \\\\\n", + "beta_ & Intercept & -0.32 & 0.72 & 0.02 & -0.36 & -0.28 & 0.69 & 0.75 & 0.00 & -15.46 & 0.00 & 176.59 \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\n", + " duration col = 'adv_fit_time'\n", + " event col = 'adv_failures'\n", + " number of observations = 1500\n", + "number of events observed = 1500\n", + " log-likelihood = -5426.84\n", + " time fit was run = 2023-09-29 11:13:33 UTC\n", + "\n", + "---\n", + " coef exp(coef) se(coef) coef lower 95% coef upper 95% exp(coef) lower 95% exp(coef) upper 95%\n", + "param covariate \n", + "alpha_ adv_failure_rate -0.00 1.00 0.00 -0.00 -0.00 1.00 1.00\n", + " atk_value 0.07 1.07 0.17 -0.26 0.40 0.77 1.49\n", + " data.sample.random_state 0.02 1.02 0.02 -0.02 0.06 0.98 1.07\n", + " def_value -0.19 0.82 0.18 -0.54 0.15 0.58 1.16\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr 0.00 1.00 0.00 -0.00 0.00 1.00 1.00\n", + " model_layers 0.01 1.01 0.00 0.01 0.02 1.01 1.02\n", + " predict_time -0.31 0.74 0.04 -0.38 -0.24 0.69 0.79\n", + " train_time 0.00 1.00 0.00 0.00 0.00 1.00 1.00\n", + " Intercept 1.88 6.54 0.19 1.51 2.25 4.52 9.46\n", + "beta_ Intercept -0.32 0.72 0.02 -0.36 -0.28 0.69 0.75\n", + "\n", + " cmp to z p -log2(p)\n", + "param covariate \n", + "alpha_ adv_failure_rate 0.00 -26.62 <0.005 516.20\n", + " atk_value 0.00 0.42 0.67 0.58\n", + " data.sample.random_state 0.00 0.91 0.36 1.47\n", + " def_value 0.00 -1.11 0.27 1.90\n", + " model.art.pipeline.initialize.kwargs.optimizer.lr 0.00 0.03 0.97 0.04\n", + " model_layers 0.00 7.88 <0.005 48.13\n", + " predict_time 0.00 -8.73 <0.005 58.49\n", + " train_time 0.00 6.12 <0.005 30.02\n", + " Intercept 0.00 9.97 <0.005 75.31\n", + "beta_ Intercept 0.00 -15.46 <0.005 176.59\n", + "---\n", + "Concordance = 0.82\n", + "AIC = 10873.68\n", + "log-likelihood ratio test = 961.93 on 8 df\n", + "-log2(p) of ll-ratio test = 669.73" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'train_score': -3.617893432558881, 'test_score': -3.971188942813805}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_773113/12050270.py:64: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " pareto.set_yticklabels(labels)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log_logistic_dict = {\n", + " \"Intercept: beta_\": \"$\\\\beta$\",\n", + " \"Intercept: alpha_\": \"$\\\\alpha$\",\n", + " \"data.sample.random_state: alpha_\": \"Random State\",\n", + " \"def_value: alpha_\": \"Defence Strength\",\n", + " \"atk_value: alpha_\": \"Attack Strength\",\n", + " \"train_time: alpha_\": \"Training Time\",\n", + " \"predict_time: alpha_\": \"Inference Time\",\n", + " \"adv_accuracy: alpha_\": \"Adv. Accuracy\",\n", + " \"accuracy: alpha_\": \"Ben. Accuracy\",\n", + " \"adv_fit_time: alpha_\": \"Adv. Fit Time\",\n", + " \"model_layers: alpha_\": \"No. of Layers\",\n", + " \"model.art.pipeline.initialize.kwargs.optimizer.lr\": \"Learning Rate\",\n", + " \"adv_failure_rate: alpha_\": \"Adv. Failure Rate\",\n", + " \"alpha_\": \"\",\n", + "}\n", + "\n", + "log_logistic_graph, llt = plot_aft(\n", + " X_train,\n", + " \"log_logistic_aft.pdf\",\n", + " target,\n", + " duration_col,\n", + " \"Log Logistic AFR Model\",\n", + " \"log_logistic\",\n", + " replacement_dict=log_logistic_dict,\n", + ")\n", + "llt.print_summary()\n", + "llt_scores = score_model(llt, X_train, X_test)\n", + "print(llt_scores)\n", + "llt_partial = plot_partial_effects(\n", + " file=\"log_logistic_partial_effects.pdf\",\n", + " aft=llt,\n", + " covariate_array=\"model_layers\",\n", + " values_array=[18, 34, 50, 101, 152],\n", + " replacement_dict=log_logistic_dict,\n", + " title=\"Survival Time for Log-Logistic AFR\",\n", + " ylabel=\"% Chance of Survival\",\n", + " xlabel=\"Time $T$ (seconds)\",\n", + " legend_kwargs={\n", + " \"title\": \"No. of Layers\",\n", + " \"labels\": [\"18\", \"34\", \"50\", \"101\", \"152\"],\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.62393284274078" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(llt.predict_median(X_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "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", + "
AICConcordanceBICTrain LLTest LLMean STMedian ST
Weibull11082.520.8411082.52-3.69-4.0071.5310.23
LogNormal10769.080.8410769.08-3.58-3.92122.817.79
LogLogistic10873.680.8210873.68-3.62-3.97NaN6.62
\n", + "
" + ], + "text/plain": [ + " AIC Concordance BIC Train LL Test LL Mean ST \\\n", + "Weibull 11082.52 0.84 11082.52 -3.69 -4.00 71.53 \n", + "LogNormal 10769.08 0.84 10769.08 -3.58 -3.92 122.81 \n", + "LogLogistic 10873.68 0.82 10873.68 -3.62 -3.97 NaN \n", + "\n", + " Median ST \n", + "Weibull 10.23 \n", + "LogNormal 7.79 \n", + "LogLogistic 6.62 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aft_dict = {\n", + " \"Weibull\": wft,\n", + " \"LogNormal\": lnt,\n", + " \"LogLogistic\": llt,\n", + " # \"Cox\": cft,\n", + "}\n", + "\n", + "score_list = [\n", + " wft_scores,\n", + " lnt_scores,\n", + " llt_scores,\n", + " # cft_scores,\n", + "]\n", + "aft_data = pd.DataFrame()\n", + "aft_data.index.name = \"Model\"\n", + "aft_data.index = aft_dict.keys()\n", + "aft_data[\"AIC\"] = [\n", + " x.AIC_ if not isinstance(x, CoxPHFitter) else np.nan for x in aft_dict.values()\n", + "]\n", + "aft_data[\"Concordance\"] = [x.concordance_index_ for x in aft_dict.values()]\n", + "aft_data[\"BIC\"] = [\n", + " x.AIC_ if not isinstance(x, CoxPHFitter) else np.nan for x in aft_dict.values()\n", + "]\n", + "aft_data[\"Train LL\"] = [x[\"train_score\"] for x in score_list]\n", + "aft_data[\"Test LL\"] = [x[\"test_score\"] for x in score_list]\n", + "aft_data[\"Mean ST\"] = [x.predict_expectation(X_train).mean() for x in aft_dict.values()]\n", + "aft_data[\"Median ST\"] = [x.predict_median(X_train).median() for x in aft_dict.values()]\n", + "aft_data = aft_data.round(2)\n", + "aft_data.to_csv(FOLDER / \"aft_comparison.csv\")\n", + "logger.info(f\"Saved AFT comparison to {FOLDER / 'aft_comparison.csv'}\")\n", + "aft_data = aft_data.round(\n", + " 2,\n", + ")\n", + "aft_data.to_latex(\n", + " FOLDER / \"aft_comparison.tex\",\n", + " float_format=\"%.2f\",\n", + " label=\"tab:mnist\",\n", + " caption=\"Comparison of AFR Models on the MNIST dataset.\",\n", + ")\n", + "aft_data" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/pytorch/params.yaml b/examples/pytorch/params.yaml deleted file mode 100644 index 7a9ccdc6..00000000 --- a/examples/pytorch/params.yaml +++ /dev/null @@ -1,228 +0,0 @@ -_target_: deckard.base.experiment.Experiment -attack: - _target_: deckard.base.attack.Attack - attack_size: 10 - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.attack.AttackInitializer - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - name: art.attacks.evasion.HopSkipJump - method: evasion - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true -direction: maximize -files: - _target_: deckard.base.files.FileConfig - adv_predictions_file: adv_predictions.json - attack_dir: attacks - attack_file: attack - attack_type: .pkl - data_dir: data - data_file: data - data_type: .pkl - directory: mnist - model_dir: models - model_file: model - model_type: .pt - name: default - params_file: params.yaml - predictions_file: predictions.json - reports: reports - score_dict_file: score_dict.json -model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - _target_: deckard.base.data.generator.DataGenerator - name: torch_mnist - sample: - _target_: deckard.base.data.sampler.SklearnDataSampler - random_state: 0 - stratify: true - sklearn_pipeline: - _target_: deckard.base.data.sklearn_pipeline.SklearnDataPipeline - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 1 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -optimizers: accuracy -scorers: - _target_: deckard.base.scorer.ScorerDict - accuracy: - _target_: deckard.base.scorer.ScorerConfig - direction: maximize - name: sklearn.metrics.accuracy_score - log_loss: - _target_: deckard.base.scorer.ScorerConfig - direction: minimize - name: sklearn.metrics.log_loss -stage: ??? diff --git a/examples/pytorch_cifar/params.yaml b/examples/pytorch_cifar/params.yaml deleted file mode 100644 index d8ad2b2e..00000000 --- a/examples/pytorch_cifar/params.yaml +++ /dev/null @@ -1,207 +0,0 @@ -_target_: deckard.base.experiment.Experiment -attack: - _target_: deckard.base.attack.Attack - attack_size: 10 - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.attack.AttackInitializer - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0.0 - - 255.0 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 10 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - name: art.attacks.evasion.HopSkipJump - method: evasion - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0.0 - - 255.0 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 10 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true -direction: maximize -files: - _target_: deckard.base.files.FileConfig - adv_predictions_file: adv_predictions.json - attack_dir: attacks - attack_file: attack - attack_type: .pkl - data_dir: data - data_file: data - data_type: .pkl - directory: cifar - model_dir: models - model_file: model - model_type: .pt - name: default - params_file: params.yaml - predictions_file: predictions.json - reports: reports - score_dict_file: score_dict.json -model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0.0 - - 255.0 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar10 - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 10 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -optimizers: accuracy -scorers: - _target_: deckard.base.scorer.ScorerDict - accuracy: - _target_: deckard.base.scorer.ScorerConfig - direction: maximize - name: sklearn.metrics.accuracy_score - log_loss: - _target_: deckard.base.scorer.ScorerConfig - direction: minimize - name: sklearn.metrics.log_loss -stage: ??? diff --git a/examples/pytorch_cifar_100/conf/deploy/default.yaml b/examples/pytorch_cifar_100/conf/deploy/default.yaml deleted file mode 100644 index 134da65f..00000000 --- a/examples/pytorch_cifar_100/conf/deploy/default.yaml +++ /dev/null @@ -1,14 +0,0 @@ -num_nodes: 1 -cluster_name: k8s-cluster -gpu_type: nvidia-tesla-v100 -gpu_count: 1 -gpu_driver_version: default -machine_type: n1-standard-2 -min_nodes: 1 -max_nodes: 1 -storage_config: conf/deploy/sclass.yaml -persistent_volume_claim: conf/deploy/pvc.yaml -pod : conf/deploy/pod.yaml -image_project: ubuntu-os-cloud -image_family: ubuntu-2204-lts -mount_directory: /mnt/filestore diff --git a/examples/pytorch_cifar_100/params.yaml b/examples/pytorch_cifar_100/params.yaml deleted file mode 100644 index ef99ba24..00000000 --- a/examples/pytorch_cifar_100/params.yaml +++ /dev/null @@ -1,215 +0,0 @@ -_target_: deckard.base.experiment.Experiment -attack: - _target_: deckard.base.attack.Attack - attack_size: 10 - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.attack.AttackInitializer - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 100 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 - name: art.attacks.evasion.HopSkipJump - method: evasion - model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 100 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true -direction: maximize -files: - _target_: deckard.base.files.FileConfig - adv_predictions_file: adv_predictions.json - attack_dir: attacks - attack_file: attack - attack_type: .pkl - data_dir: data - data_file: data - data_type: .pkl - directory: cifar100 - model_dir: models - model_file: model - model_type: .pt - name: default - params_file: params.yaml - predictions_file: predictions.json - reports: reports - score_dict_file: score_dict.json -model: - _target_: deckard.base.model.Model - art: - _target_: deckard.base.model.art_pipeline.ArtPipeline - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - initialize: - clip_values: - - 0 - - 255 - criterion: - name: torch.nn.CrossEntropyLoss - optimizer: - lr: 0.01 - momentum: 0.9 - name: torch.optim.SGD - library: pytorch - data: - _target_: deckard.base.data.Data - generate: - name: torch_cifar100 - path: original_data - sample: - random_state: 0 - stratify: true - sklearn_pipeline: - preprocessor: - name: sklearn.preprocessing.StandardScaler - with_mean: true - with_std: true - init: - _target_: deckard.base.model.ModelInitializer - name: torch_example.ResNet18 - num_channels: 3 - num_classes: 100 - library: pytorch - trainer: - batch_size: 1024 - nb_epoch: 100 -optimizers: accuracy -scorers: - _target_: deckard.base.scorer.ScorerDict - accuracy: - _target_: deckard.base.scorer.ScorerConfig - direction: maximize - name: sklearn.metrics.accuracy_score - log_loss: - _target_: deckard.base.scorer.ScorerConfig - direction: minimize - name: sklearn.metrics.log_loss -stage: ??? diff --git a/examples/security/classification/models.sh b/examples/security/classification/models.sh index b4929aed..44e7294f 100644 --- a/examples/security/classification/models.sh +++ b/examples/security/classification/models.sh @@ -1,6 +1,7 @@ N_FEATURES=( 10 100 1000 10000 ) TRAIN_SIZES=( 10 100 1000 10000 100000 ) # TRAIN_SIZES=( 1000 10000 100000 1000000 ) +N_FEATURES=( 100 ) N_SAMPLES=( 1010000 ) TOTAL=$(( ${#N_FEATURES[@]} * ${#N_SAMPLES[@]} * ${#TRAIN_SIZES[@]} )) i=$(( 0 )) @@ -21,6 +22,7 @@ for train_size in ${TRAIN_SIZES[@]}; do ++model.init.kernel=linear \ model.init.C=.0001,.001,.01,.1,1,10,100,1000,10000,10000 \ ++hydra.sweeper.study_name=linear_${n_features}_${train_size} "$@" --multirun \ + # Keeps a log of the output for each experiment >| logs/models/linear_features-${n_features}_samples-${n_samples}_train-${train_size}.log echo "Linear Kernel Done" >> log.txt # Runs the poly kernel diff --git a/setup.py b/setup.py index c5556dbd..65317ddb 100644 --- a/setup.py +++ b/setup.py @@ -29,6 +29,8 @@ "hydra-rq-launcher", "sqlalchemy<=1.4.46", "dvc", + "paretoset", + "lifelines", ] test_requires = [ "pytest", diff --git a/test/base/test_model/test_sklearn_model_pipeline.py b/test/base/test_model/test_sklearn_model_pipeline.py index fd904655..1705af2a 100644 --- a/test/base/test_model/test_sklearn_model_pipeline.py +++ b/test/base/test_model/test_sklearn_model_pipeline.py @@ -6,9 +6,7 @@ from hydra import initialize_config_dir, compose from hydra.utils import instantiate -from deckard.base.model.sklearn_pipeline import ( - SklearnModelPipeline, -) +from deckard.base.model.sklearn_pipeline import SklearnModelPipeline this_dir = Path(os.path.realpath(__file__)).parent.resolve().as_posix()