From e8025a4678619441385d6d09c1a33fd68f05e343 Mon Sep 17 00:00:00 2001 From: huangyun Date: Mon, 22 Dec 2025 16:44:54 +0800 Subject: [PATCH] update: continual-learning --- .../other/continual-learning/Dockerfile | 12 + .../continual-learning/ICLRblogpost/README.md | 54 + .../ICLRblogpost/compare_FI.py | 356 +++ .../build-in/other/continual-learning/LICENSE | 21 + .../NeurIPStutorial/README.md | 59 + .../NeurIPStutorial/compare_for_tutorial.py | 334 ++ .../other/continual-learning/README.md | 100 + .../continual-learning/StabilityGap/README.md | 14 + .../StabilityGap/stability_gap_example.py | 193 ++ .../other/continual-learning/all_results.sh | 92 + .../other/continual-learning/compare.py | 362 +++ .../continual-learning/compare_hyperParams.py | 328 ++ .../compare_hyperParams_task_free.py | 194 ++ .../continual-learning/compare_replay.py | 282 ++ .../continual-learning/compare_task_free.py | 294 ++ .../other/continual-learning/cover.txt | 5 + .../other/continual-learning/coverage.py | 28 + .../other/continual-learning/data/__init__.py | 0 .../continual-learning/data/available.py | 53 + .../continual-learning/data/datastream.py | 73 + .../continual-learning/data/labelstream.py | 122 + .../other/continual-learning/data/load.py | 155 + .../continual-learning/data/manipulate.py | 119 + .../other/continual-learning/eval/__init__.py | 0 .../continual-learning/eval/callbacks.py | 198 ++ .../other/continual-learning/eval/evaluate.py | 222 ++ .../continual-learning/example_DGR.ipynb | 628 ++++ .../example_comparison.ipynb | 728 +++++ .../figures/rotatedMNIST.png | Bin 0 -> 187654 bytes .../figures/splitMNIST_results_tutorial.png | Bin 0 -> 262531 bytes .../figures/splitMNIST_schematic.png | Bin 0 -> 128666 bytes .../figures/stabilityGap.png | Bin 0 -> 72711 bytes .../continual-learning/figures/strategies.png | Bin 0 -> 330887 bytes .../other/continual-learning/get_loss.py | 87 + ...ands_on_tutorial_InvictaSpringSchool.ipynb | 2689 +++++++++++++++++ .../build-in/other/continual-learning/main.py | 584 ++++ .../other/continual-learning/main_pretrain.py | 177 ++ .../continual-learning/main_task_free.py | 417 +++ .../continual-learning/models/__init__.py | 0 .../continual-learning/models/cl/__init__.py | 0 .../models/cl/continual_learner.py | 641 ++++ .../models/cl/fromp_optimizer.py | 415 +++ .../models/cl/memory_buffer.py | 207 ++ .../models/cl/memory_buffer_stream.py | 168 + .../continual-learning/models/classifier.py | 431 +++ .../models/classifier_stream.py | 312 ++ .../continual-learning/models/cond_vae.py | 747 +++++ .../models/conv/__init__.py | 0 .../continual-learning/models/conv/layers.py | 347 +++ .../continual-learning/models/conv/nets.py | 252 ++ .../models/define_models.py | 299 ++ .../continual-learning/models/fc/__init__.py | 0 .../models/fc/excitability_modules.py | 91 + .../continual-learning/models/fc/layers.py | 152 + .../continual-learning/models/fc/nets.py | 219 ++ .../models/feature_extractor.py | 122 + .../models/generative_classifier.py | 114 + .../models/separate_classifiers.py | 85 + .../models/utils/__init__.py | 0 .../models/utils/loss_functions.py | 154 + .../models/utils/modules.py | 68 + .../continual-learning/models/utils/ncl.py | 24 + .../other/continual-learning/models/vae.py | 535 ++++ .../continual-learning/params/__init__.py | 0 .../continual-learning/params/options.py | 351 +++ .../continual-learning/params/param_stamp.py | 201 ++ .../continual-learning/params/param_values.py | 220 ++ .../other/continual-learning/requirements.txt | 11 + .../other/continual-learning/store/README.md | 7 + .../continual-learning/train/__init__.py | 0 .../train/train_standard.py | 43 + .../continual-learning/train/train_stream.py | 143 + .../train/train_task_based.py | 635 ++++ .../other/continual-learning/utils.py | 233 ++ .../continual-learning/visual/__init__.py | 0 .../continual-learning/visual/visual_plt.py | 380 +++ .../visual/visual_visdom.py | 35 + 77 files changed, 16622 insertions(+) create mode 100644 PyTorch/build-in/other/continual-learning/Dockerfile create mode 100644 PyTorch/build-in/other/continual-learning/ICLRblogpost/README.md create mode 100644 PyTorch/build-in/other/continual-learning/ICLRblogpost/compare_FI.py create mode 100644 PyTorch/build-in/other/continual-learning/LICENSE create mode 100644 PyTorch/build-in/other/continual-learning/NeurIPStutorial/README.md create mode 100644 PyTorch/build-in/other/continual-learning/NeurIPStutorial/compare_for_tutorial.py create mode 100644 PyTorch/build-in/other/continual-learning/README.md create mode 100644 PyTorch/build-in/other/continual-learning/StabilityGap/README.md create mode 100644 PyTorch/build-in/other/continual-learning/StabilityGap/stability_gap_example.py create mode 100644 PyTorch/build-in/other/continual-learning/all_results.sh create mode 100644 PyTorch/build-in/other/continual-learning/compare.py create mode 100644 PyTorch/build-in/other/continual-learning/compare_hyperParams.py create mode 100644 PyTorch/build-in/other/continual-learning/compare_hyperParams_task_free.py create mode 100644 PyTorch/build-in/other/continual-learning/compare_replay.py create mode 100644 PyTorch/build-in/other/continual-learning/compare_task_free.py create mode 100644 PyTorch/build-in/other/continual-learning/cover.txt create mode 100644 PyTorch/build-in/other/continual-learning/coverage.py create mode 100644 PyTorch/build-in/other/continual-learning/data/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/data/available.py create mode 100644 PyTorch/build-in/other/continual-learning/data/datastream.py create mode 100644 PyTorch/build-in/other/continual-learning/data/labelstream.py create mode 100644 PyTorch/build-in/other/continual-learning/data/load.py create mode 100644 PyTorch/build-in/other/continual-learning/data/manipulate.py create mode 100644 PyTorch/build-in/other/continual-learning/eval/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/eval/callbacks.py create mode 100644 PyTorch/build-in/other/continual-learning/eval/evaluate.py create mode 100644 PyTorch/build-in/other/continual-learning/example_DGR.ipynb create mode 100644 PyTorch/build-in/other/continual-learning/example_comparison.ipynb create mode 100644 PyTorch/build-in/other/continual-learning/figures/rotatedMNIST.png create mode 100644 PyTorch/build-in/other/continual-learning/figures/splitMNIST_results_tutorial.png create mode 100644 PyTorch/build-in/other/continual-learning/figures/splitMNIST_schematic.png create mode 100644 PyTorch/build-in/other/continual-learning/figures/stabilityGap.png create mode 100644 PyTorch/build-in/other/continual-learning/figures/strategies.png create mode 100644 PyTorch/build-in/other/continual-learning/get_loss.py create mode 100644 PyTorch/build-in/other/continual-learning/hands_on_tutorial_InvictaSpringSchool.ipynb create mode 100644 PyTorch/build-in/other/continual-learning/main.py create mode 100644 PyTorch/build-in/other/continual-learning/main_pretrain.py create mode 100644 PyTorch/build-in/other/continual-learning/main_task_free.py create mode 100644 PyTorch/build-in/other/continual-learning/models/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cl/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cl/continual_learner.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cl/fromp_optimizer.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cl/memory_buffer.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cl/memory_buffer_stream.py create mode 100644 PyTorch/build-in/other/continual-learning/models/classifier.py create mode 100644 PyTorch/build-in/other/continual-learning/models/classifier_stream.py create mode 100644 PyTorch/build-in/other/continual-learning/models/cond_vae.py create mode 100644 PyTorch/build-in/other/continual-learning/models/conv/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/models/conv/layers.py create mode 100644 PyTorch/build-in/other/continual-learning/models/conv/nets.py create mode 100644 PyTorch/build-in/other/continual-learning/models/define_models.py create mode 100644 PyTorch/build-in/other/continual-learning/models/fc/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/models/fc/excitability_modules.py create mode 100644 PyTorch/build-in/other/continual-learning/models/fc/layers.py create mode 100644 PyTorch/build-in/other/continual-learning/models/fc/nets.py create mode 100644 PyTorch/build-in/other/continual-learning/models/feature_extractor.py create mode 100644 PyTorch/build-in/other/continual-learning/models/generative_classifier.py create mode 100644 PyTorch/build-in/other/continual-learning/models/separate_classifiers.py create mode 100644 PyTorch/build-in/other/continual-learning/models/utils/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/models/utils/loss_functions.py create mode 100644 PyTorch/build-in/other/continual-learning/models/utils/modules.py create mode 100644 PyTorch/build-in/other/continual-learning/models/utils/ncl.py create mode 100644 PyTorch/build-in/other/continual-learning/models/vae.py create mode 100644 PyTorch/build-in/other/continual-learning/params/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/params/options.py create mode 100644 PyTorch/build-in/other/continual-learning/params/param_stamp.py create mode 100644 PyTorch/build-in/other/continual-learning/params/param_values.py create mode 100644 PyTorch/build-in/other/continual-learning/requirements.txt create mode 100644 PyTorch/build-in/other/continual-learning/store/README.md create mode 100644 PyTorch/build-in/other/continual-learning/train/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/train/train_standard.py create mode 100644 PyTorch/build-in/other/continual-learning/train/train_stream.py create mode 100644 PyTorch/build-in/other/continual-learning/train/train_task_based.py create mode 100644 PyTorch/build-in/other/continual-learning/utils.py create mode 100644 PyTorch/build-in/other/continual-learning/visual/__init__.py create mode 100644 PyTorch/build-in/other/continual-learning/visual/visual_plt.py create mode 100644 PyTorch/build-in/other/continual-learning/visual/visual_visdom.py diff --git a/PyTorch/build-in/other/continual-learning/Dockerfile b/PyTorch/build-in/other/continual-learning/Dockerfile new file mode 100644 index 000000000..8e364d1a1 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/Dockerfile @@ -0,0 +1,12 @@ +ARG FROM_IMAGE_NAME=jfrog.tecorigin.net/tecotp-docker/release/ubuntu22.04/x86_64/pytorch:2.1.1-torch_sdaa2.1.1 +FROM ${FROM_IMAGE_NAME} + +WORKDIR /workspace/ +ADD requirements.txt /workspace/ +RUN rm -rf /bin/sh && ln -s /bin/bash /bin/sh +RUN source activate torch_env && pip install --no-cache-dir -r requirements.txt +ADD . /workspace/other/continual-learning +WORKDIR /workspace/other/continual-learning + +ARG FROM_IMAGE_NAME=jfrog.tecorigin.net/tecotp-docker/release/ubuntu22.04/x86_64/pytorch:2.1.1-torch_sdaa2.1.1 +FROM ${FROM_IMAGE_NAME} \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/ICLRblogpost/README.md b/PyTorch/build-in/other/continual-learning/ICLRblogpost/README.md new file mode 100644 index 000000000..096c649b8 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/ICLRblogpost/README.md @@ -0,0 +1,54 @@ +# On the computation of the Fisher Information in continual learning (2025, ICLR Blogpost) + +The code in this repository is used for the experiments reported in the +[ICLR 2025 blog post "On the computation of the Fisher Information in continual learning"](https://iclr-blogposts.github.io/2025/blog/fisher/) +(or see the arXiv-preprint [here](https://arxiv.org/abs/2502.11756)). + +This blog post compares the performance of Elastic Weight Consolidation (EWC) with various different ways of computing the diagonal elements of the Fisher Information matrix. +The following options are considered: +- **EXACT** +The elements of the Fisher Information are computed exactly. All training samples are used. +To use this option: `./main.py --ewc --fisher-labels='all'` + +- **EXACT ($n$=500)** +The elements of the Fisher Information are computed exactly. Only 500 training samples are used. +To use this option: `./main.py --ewc --fisher-labels='all' --fisher-n=500` + +- **SAMPLE** +The elements of the Fisher Information are estimated using a single Monte Carlo sample. All training samples are used. +To use this option: `./main.py --ewc --fisher-labels='sample'` + +- **EMPIRICAL** +The empirical Fisher Information is used. All training samples are used. +To use this option: `./main.py --ewc --fisher-labels='true'` + +- **BATCHED ($b$=128)** +The empirical Fisher Information is approximated using mini-batches (see blog post for details). +To use this option: `./main.py --ewc --fisher-labels='true' --fisher-batch=128` + + +To run the experiments from the blog post, the following lines of code can be used: + +```bash +python3 ICLRblogpost/compare_FI.py --seed=1 --n-seeds=30 --experiment=splitMNIST --scenario=task +python3 ICLRblogpost/compare_FI.py --seed=1 --n-seeds=30 --experiment=CIFAR10 --scenario=task --reducedResNet --iters=2000 --lr=0.001 +``` + + +### Citation +If this is useful, please consider citing the blog post: +``` +@inproceedings{vandeven2025fisher, + title={On the computation of the {F}isher {I}nformation in continual learning}, + author={van de Ven, Gido M}, + booktitle={ICLR Blogposts 2025}, + year={2025}, + date={April 28, 2025}, + url={https://iclr-blogposts.github.io/2025/blog/fisher/} +} +``` + + +### Acknowledgments +This project has been supported by a senior postdoctoral fellowship from the +Resarch Foundation -- Flanders (FWO) under grant number 1266823N. \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/ICLRblogpost/compare_FI.py b/PyTorch/build-in/other/continual-learning/ICLRblogpost/compare_FI.py new file mode 100644 index 000000000..ec82db246 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/ICLRblogpost/compare_FI.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +import sys +import os +import numpy as np +# -expand module search path to parent directory +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) +# -custom-written code +import main +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt as my_plt + + +## Parameter-values to compare +lamda_list = [1., 10., 100., 1000., 10000., 100000., 1000000., 10000000., 100000000., 1000000000., 10000000000., + 100000000000., 1000000000000., 10000000000000.] + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_hyper': True} + # Define input options + parser = options.define_args(filename="compare_hyperParams", + description='Compare performance EWC with differrent ways of computing FI matrix.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser.add_argument('--n-seeds', type=int, default=1, help='how often to repeat?') + # Add options specific for EWC + param_reg = parser.add_argument_group('Parameter Regularization') + param_reg.add_argument('--offline', action='store_true', help='use Offline EWC rather than Online EWC') + param_reg.add_argument("--fisher-n-all", type=float, default=500, metavar='N', + help="how many samples to approximate FI in 'ALL-n=X'") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=False) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +## Function for running experiments and collecting results +def get_result(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args) + # -check whether already run, and if not do so + if os.path.isfile('{}/time-{}.txt'.format(args.r_dir, param_stamp)) and os.path.isfile('{}/acc-{}.txt'.format(args.r_dir, param_stamp)): + print(" already run: {}".format(param_stamp)) + else: + args.train = True + print("\n ...running: {} ...".format(param_stamp)) + main.run(args) + # -get average accuracy + fileName = '{}/acc-{}.txt'.format(args.r_dir, param_stamp) + file = open(fileName) + ave = float(file.readline()) + file.close() + # -get training time + fileName = '{}/time-{}.txt'.format(args.r_dir, param_stamp) + file = open(fileName) + traintime = float(file.readline()) + file.close() + # -return it + return (traintime, ave) + + +def collect_all(method_dict, seed_list, args, name=None): + # -print name of method on screen + if name is not None: + print("\n------{}------".format(name)) + # -run method for all random seeds + for seed in seed_list: + args.seed = seed + method_dict[seed] = get_result(args) + # -return updated dictionary with results + return method_dict + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + args.time = True + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + seed_list = list(range(args.seed, args.seed+args.n_seeds)) + + ## Baselline + args.replay = "none" + BASE = {} + BASE = collect_all(BASE, seed_list, args, name="None") + + # -set EWC-specific arguments + args.weight_penalty = True + args.importance_weighting = 'fisher' + + ## EWC, "sample" + SAMPLE = {} + args.fisher_labels = "sample" + args.fisher_n = None + args.fisher_batch = 1 + for ewc_lambda in lamda_list: + args.reg_strength=ewc_lambda + SAMPLE[ewc_lambda] = {} + SAMPLE[ewc_lambda] = collect_all(SAMPLE[ewc_lambda], seed_list, args, + name="EWC -- FI-labels='sample' (lambda={})".format(ewc_lambda)) + + ## EWC, "true" + TRUE = {} + args.fisher_labels = "true" + args.fisher_n = None + args.fisher_batch = 1 + for ewc_lambda in lamda_list: + args.reg_strength=ewc_lambda + TRUE[ewc_lambda] = {} + TRUE[ewc_lambda] = collect_all(TRUE[ewc_lambda], seed_list, args, + name="EWC -- FI-labels='true' (lambda={})".format(ewc_lambda)) + + ## EWC, "true" - batch=128 + TRUE128 = {} + args.fisher_labels = "true" + args.fisher_n = None + args.fisher_batch = 128 + for ewc_lambda in lamda_list: + args.reg_strength=ewc_lambda + TRUE128[ewc_lambda] = {} + TRUE128[ewc_lambda] = collect_all(TRUE128[ewc_lambda], seed_list, args, + name="EWC -- FI-labels='true' - batch=128 (lambda={})".format(ewc_lambda)) + + ## EWC, "all" -- only [args.fisher_n_all] samples per task + ALL500 = {} + args.fisher_labels = "all" + args.fisher_n = args.fisher_n_all + args.fisher_batch = 1 + for ewc_lambda in lamda_list: + args.reg_strength=ewc_lambda + ALL500[ewc_lambda] = {} + ALL500[ewc_lambda] = collect_all(ALL500[ewc_lambda], seed_list, args, + name="EWC -- FI-labels='all' - n={} (lambda={})".format(args.fisher_n_all, ewc_lambda)) + + ## EWC, "all" + ALL = {} + args.fisher_labels = "all" + args.fisher_n = None + args.fisher_batch = 1 + for ewc_lambda in lamda_list: + args.reg_strength=ewc_lambda + ALL[ewc_lambda] = {} + ALL[ewc_lambda] = collect_all(ALL[ewc_lambda], seed_list, args, + name="EWC -- FI-labels='all' (lambda={})".format(ewc_lambda)) + + + #-------------------------------------------------------------------------------------------------# + + #-----------------------------------------# + #----- COLLECT DATA & PRINT ON SCREEN-----# + #-----------------------------------------# + + ext_lambda_list = [0] + lamda_list + ext_lambda_list = lamda_list + print("\n") + + base_entries = [BASE[seed][1] for seed in seed_list] + mean_base = np.mean(base_entries) + sem_base = (np.sqrt(np.var(base_entries)) / np.sqrt(args.n_seeds)) if args.n_seeds>1 else None + + ###---EWC "all" ---### + mean_all = [] + sem_all = [] + for ewc_lambda in lamda_list: + new_entries = [ALL[ewc_lambda][seed][1] for seed in seed_list] + mean_all.append(np.mean(new_entries)) + if args.n_seeds>1: + sem_all.append(np.sqrt(np.var(new_entries)) / np.sqrt((args.n_seeds))) + lambda_all = ext_lambda_list[np.argmax(mean_all)] + # -print on screen + print("\n\nEWC -- FI-labels='all'") + print(" param list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(mean_all)) + print("---> lambda = {} -- {}".format(lambda_all, np.max(mean_all))) + + ###---EWC "all, with n=500" ---### + mean_all500 = [] + if args.n_seeds>1: + sem_all500 = [] + for ewc_lambda in lamda_list: + new_entries = [ALL500[ewc_lambda][seed][1] for seed in seed_list] + mean_all500.append(np.mean(new_entries)) + if args.n_seeds>1: + sem_all500.append(np.sqrt(np.var(new_entries)) / np.sqrt((args.n_seeds))) + lambda_all500 = ext_lambda_list[np.argmax(mean_all500)] + # -print on screen + print("\n\nEWC -- FI-labels='all' - n={}".format(args.fisher_n_all)) + print(" param list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(mean_all500)) + print("---> lambda = {} -- {}".format(ext_lambda_list[np.argmax(mean_all500)], np.max(mean_all500))) + + ###---EWC "sample" ---### + mean_sample = [] + if args.n_seeds>1: + sem_sample = [] + for ewc_lambda in lamda_list: + new_entries = [SAMPLE[ewc_lambda][seed][1] for seed in seed_list] + mean_sample.append(np.mean(new_entries)) + if args.n_seeds>1: + sem_sample.append(np.sqrt(np.var(new_entries)) / np.sqrt((args.n_seeds))) + lambda_sample = ext_lambda_list[np.argmax(mean_sample)] + # -print on screen + print("\n\nEWC -- FI-labels='sample'") + print(" param list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(mean_sample)) + print("---> lambda = {} -- {}".format(ext_lambda_list[np.argmax(mean_sample)], np.max(mean_sample))) + + ###---EWC "true" ---### + mean_true = [] + if args.n_seeds>1: + sem_true = [] + for ewc_lambda in lamda_list: + new_entries = [TRUE[ewc_lambda][seed][1] for seed in seed_list] + mean_true.append(np.mean(new_entries)) + if args.n_seeds>1: + sem_true.append(np.sqrt(np.var(new_entries)) / np.sqrt((args.n_seeds))) + lambda_true = ext_lambda_list[np.argmax(mean_true)] + # -print on screen + print("\n\nEWC -- FI-labels='true'") + print(" param list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(mean_true)) + print("---> lambda = {} -- {}".format(ext_lambda_list[np.argmax(mean_true)], np.max(mean_true))) + + ###---EWC "true" - batch=128 ---### + mean_true128 = [] + if args.n_seeds>1: + sem_true128 = [] + for ewc_lambda in lamda_list: + new_entries = [TRUE128[ewc_lambda][seed][1] for seed in seed_list] + mean_true128.append(np.mean(new_entries)) + if args.n_seeds>1: + sem_true128.append(np.sqrt(np.var(new_entries)) / np.sqrt((args.n_seeds))) + lambda_true128 = ext_lambda_list[np.argmax(mean_true128)] + # -print on screen + print("\n\nEWC -- FI-labels='true' - batch=128") + print(" param list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(mean_true128)) + print("---> lambda = {} -- {}".format(ext_lambda_list[np.argmax(mean_true128)], np.max(mean_true128))) + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- PLOTTING -----# + #--------------------# + + # name for plot + plot_name = "hyperParams-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "incremental {} learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + ylabel = "Test accuracy (after all contexts)" + + # open pdf + pp = my_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + + ########### ALL HYPERPARAM-VALUES ########### + + # - select lines, names and colors + lines = [mean_all, mean_all500, mean_sample, mean_true, mean_true128] + errors = [sem_all, sem_all500, sem_sample, sem_true, sem_true128] if args.n_seeds>1 else None + names = ["All", "All - n={}".format(args.fisher_n_all), "Sample", "True", "True - batch=128"] + colors = ["black", "grey", "red", "orange", "blue"] + # - make plot (line plot - only average) + figure = my_plt.plot_lines(lines, x_axes=ext_lambda_list, ylabel=ylabel, line_names=names, list_with_errors=errors, + title=title, x_log=True, xlabel="EWC: lambda log-scale)", + with_dots=True, colors=colors, h_lines=[mean_base], + h_errors=[sem_base] if args.n_seeds>1 else None, h_labels=["None"]) + figure_list.append(figure) + + + ########### ACCURACY (AND TRAIN-TIMES) OF BEST HYPERPARAMS ########### + + # Collect the best accuracies (and training times) + ave_prec = {} + train_time = {} + for seed in seed_list: + ave_prec[seed] = [BASE[seed][1], ALL[lambda_all][seed][1], ALL500[lambda_all500][seed][1], SAMPLE[lambda_sample][seed][1], + TRUE[lambda_true][seed][1], TRUE128[lambda_true128][seed][1]] + train_time[seed] = [BASE[seed][0], ALL[lambda_all][seed][0], ALL500[lambda_all500][seed][0], SAMPLE[lambda_sample][seed][0], + TRUE[lambda_true][seed][0], TRUE128[lambda_true128][seed][0]] + names = ["None", "All", "All - n={}".format(args.fisher_n_all), "Sample", "True", "True - batch=128"] + colors = ["green", "black", "grey", "red", "orange", "blue"] + ids = [0, 1, 2, 3, 4, 5] + + # Avearge accuracy + # -bar-plot + means = [np.mean([ave_prec[seed][id] for seed in seed_list]) for id in ids] + if len(seed_list)>1: + sems = [np.sqrt(np.var([ave_prec[seed][id] for seed in seed_list]))/np.sqrt(len(seed_list)) for id in ids] + cis = [1.96*np.sqrt(np.var([ave_prec[seed][id] for seed in seed_list]))/np.sqrt(len(seed_list)) for id in ids] + figure = my_plt.plot_bar(means, names=names, colors=colors, ylabel="average precision (after all tasks)", + title=title, yerr=cis if len(seed_list)>1 else None, ylim=(0,1)) + figure_list.append(figure) + # -print results to screen + print("\n\n"+"#"*49+"\n AVERAGE TEST ACCURACY (in %)\n"+"-"*49) + for i,name in enumerate(names): + if len(seed_list) > 1: + print("{:21s} {:.2f} (+/- {:.2f}), n={}".format(name, 100*means[i], 100*sems[i], len(seed_list))) + else: + print("{:21s} {:.2f}".format(name, 100*means[i])) + if i==0: + print("-"*49) + print("#"*49) + + # Training time + # -bar-plot + means = [np.mean([train_time[seed][id] for seed in seed_list]) for id in ids] + if len(seed_list) > 1: + sems = [np.sqrt(np.var([train_time[seed][id] for seed in seed_list])) / np.sqrt(len(seed_list)) for id in ids] + cis = [1.96 * np.sqrt(np.var([train_time[seed][id] for seed in seed_list])) / np.sqrt(len(seed_list)) for id in ids] + figure = my_plt.plot_bar(means, names=names, colors=colors, ylabel="Training Time (in Sec)", + title=title, yerr=cis if len(seed_list) > 1 else None) + figure_list.append(figure) + # -print results to screen + print("\n\n" + "#" * 49 + "\n TOTAL TRAINING TIME (in Sec)\n" + "-" * 49) + for i, name in enumerate(names): + if len(seed_list) > 1: + print("{:21s} {:4.0f} (+/- {:2.0f}), n={}".format(name, means[i], sems[i], len(seed_list))) + else: + print("{:21s} {:4.0f}".format(name, means[i])) + if i==0: + print("-"*49) + print("#" * 49) + + + # add figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) diff --git a/PyTorch/build-in/other/continual-learning/LICENSE b/PyTorch/build-in/other/continual-learning/LICENSE new file mode 100644 index 000000000..8127a5016 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Gido van de Ven + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/PyTorch/build-in/other/continual-learning/NeurIPStutorial/README.md b/PyTorch/build-in/other/continual-learning/NeurIPStutorial/README.md new file mode 100644 index 000000000..ca302c958 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/NeurIPStutorial/README.md @@ -0,0 +1,59 @@ +# NeurIPS tutorial "Lifelong Learning Machines" + +The code in this repository is used as part of the +[NeurIPS 2022 tutorial "Lifelong Learning Machines"](https://sites.google.com/view/neurips2022-llm-tutorial). + +In Part 2a of the tutorial, an overview is provided of currently used strategies for continual learning. +In this overview, following +[van de Ven et al. (2022, *Nature Machine Intelligence*)](https://www.nature.com/articles/s42256-022-00568-3), +five computational strategies for continual learning are distinguished: + +![image](../figures/strategies.png) + +To illustrate the relative strengths and weaknesses of these different computational strategies, +an empirical comparison is performed in which for each strategy two representative examples methods are included: +- ***Parameter regularization*** + - Elastic weight consolidation (**EWC**; + [Kirkpatrick et al, 2017 *PNAS*](https://www.pnas.org/doi/10.1073/pnas.1611835114)) + - Synaptic Intelligence (**SI**; + [Zenke et al., 2017 *ICML*](http://proceedings.mlr.press/v70/zenke17a)) +- ***Functional regularization*** + - Learning without forgetting (**LwF**; + [Li & Hoiem, 2017 *TPAMI*](https://ieeexplore.ieee.org/abstract/document/8107520)) + - Functional Regularization of the Memorable Past (**FROMP**; + [Pan et al., 2020 *NeurIPS*](https://proceedings.neurips.cc/paper/2020/hash/2f3bbb9730639e9ea48f309d9a79ff01-Abstract.html)) +- ***Replay*** + - Deep Generative Replay (**DGR**; + [Shin et al., 2017 *NeurIPS*](https://proceedings.neurips.cc/paper/2017/hash/0efbe98067c6c73dba1250d2beaa81f9-Abstract.html)) + - Experience Replay (**ER**; + [Chaudhry et al., 2019 *arXiv*](https://arxiv.org/abs/1902.10486)) +- ***Context-specific components*** + - Separate Networks (**SepN**) + - Context-dependent Gating (**XdG**; + [Masse et al., 2018 *PNAS*](https://www.pnas.org/doi/abs/10.1073/pnas.1803839115)) +- ***Template-based classification*** + - Generative Classifier (**GenC**; + [van de Ven et al., 2021 *CVPR-W*](https://openaccess.thecvf.com/content/CVPR2021W/CLVision/html/van_de_Ven_Class-Incremental_Learning_With_Generative_Classifiers_CVPRW_2021_paper.html)) + - Incremental Classifier and Representation Learning (**iCaRL**; + [Rebuffi et al., 2017 *CVPR*](https://openaccess.thecvf.com/content_cvpr_2017/html/Rebuffi_iCaRL_Incremental_Classifier_CVPR_2017_paper.html)) + +The comparison is done on the Split MNIST benchmark, +which is performed according to each of the three continual learning scenarios +([van de Ven et al., 2022 *Nature Machine Intelligence*](https://www.nature.com/articles/s42256-022-00568-3)): + +![image](../figures/splitMNIST_schematic.png) + +Note that in the NeurIPS tutorial, the term "task" is used instead of "context" +to refer to the incremental parts of the Split MNIST protocol. + +To run the experimental comparison from the tutorial yourself, the following lines of code can be used: + +```bash +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=task +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=domain +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=class +``` + +This should produce graphs similar to the ones below: + +![image](../figures/splitMNIST_results_tutorial.png) diff --git a/PyTorch/build-in/other/continual-learning/NeurIPStutorial/compare_for_tutorial.py b/PyTorch/build-in/other/continual-learning/NeurIPStutorial/compare_for_tutorial.py new file mode 100644 index 000000000..012c1919d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/NeurIPStutorial/compare_for_tutorial.py @@ -0,0 +1,334 @@ +#!/usr/bin/env python3 +import sys +import os +import numpy as np +# -expand module search path to parent directory +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) +# -custom-written code +import main +import utils +from utils import checkattr +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_all': True} + # Define input options + parser = options.define_args(filename="compare", description='Compare and plot performance of CL strategies.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=True) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +## Functions for running experiments and collecting results +def get_results(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args) + # -check whether the 'results-dict' is already available; if not, run the experiment + file_to_check = '{}/dict-{}--n{}{}.pkl'.format( + args.r_dir, param_stamp, "All" if args.acc_n is None else args.acc_n, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "" + ) + if os.path.isfile(file_to_check): + print(" already run: {}".format(param_stamp)) + else: + args.train = True + args.results_dict = True + print(" ...running: {}".format(param_stamp)) + main.run(args) + # -get average accuracy + fileName = '{}/acc-{}{}.txt'.format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + file = open(fileName) + ave = float(file.readline()) + file.close() + # -get results-dict + dict = utils.load_object( + "{}/dict-{}--n{}{}".format(args.r_dir, param_stamp, "All" if args.acc_n is None else args.acc_n, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + ) + # -print average accuracy on screen + print("--> average accuracy: {}".format(ave)) + # -return average accuracy + return (dict, ave) + +def collect_all(method_dict, seed_list, args, name=None): + # -print name of method on screen + if name is not None: + print("\n------{}------".format(name)) + # -run method for all random seeds + for seed in seed_list: + args.seed = seed + method_dict[seed] = get_results(args) + # -return updated dictionary with results + return method_dict + + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + seed_list = list(range(args.seed, args.seed+args.n_seeds)) + + + ###----"BASELINES"----### + + ## None + args.replay = "none" + NONE = {} + NONE = collect_all(NONE, seed_list, args, name="None") + + ## JOINT training, again for each context (only using number of iterations from that context) + args.cummulative = True + args.reinit = True + JOINT = {} + JOINT = collect_all(JOINT, seed_list, args, name="Joint") + args.reinit = False + args.cummulative = False + + + ###----"CONTEXT-SPECIFIC"----#### + + if args.scenario=="task": + ## Separate network per context + fc_units_temp = args.fc_units + args.fc_units = args.fc_units_sep + args.separate_networks = True + SEP = {} + SEP = collect_all(SEP, seed_list, args, name="Separate Networks") + args.separate_networks = False + args.fc_units = fc_units_temp + + ## XdG + always_xdg = checkattr(args, 'xdg') + args.xdg = True + XDG = {} + XDG = collect_all(XDG, seed_list, args, name="XdG") + args.xdg = always_xdg + + + ###----"PARAMETER REGULARIZATION"----#### + + ## EWC + args.weight_penalty = True + args.importance_weighting = 'fisher' + args.offline = True + args.reg_strength = args.ewc_lambda + EWC = {} + EWC = collect_all(EWC, seed_list, args, name="EWC") + args.weight_penalty = False + args.offline = False + + ## SI + args.weight_penalty = True + args.importance_weighting = 'si' + args.reg_strength = args.si_c + SI = {} + SI = collect_all(SI, seed_list, args, name="SI") + args.weight_penalty = False + + + ###----"FUNCTIONAL REGULARIZATION"----#### + + ## LwF + args.replay = "current" + args.distill = True + LWF = {} + LWF = collect_all(LWF, seed_list, args, name="LwF") + args.replay = "none" + args.distill = False + + ## FROMP + args.fromp = True + args.sample_selection = "fromp" + FROMP = {} + FROMP = collect_all(FROMP, seed_list, args, name="FROMP") + args.fromp = False + + + ###----"REPLAY"----### + + ## DGR + args.replay = "generative" + args.distill = False + DGR = {} + DGR = collect_all(DGR, seed_list, args, name="Deep Generative Replay") + + ## Experience Replay + args.replay = "buffer" + args.sample_selection = "random" + ER = {} + ER = collect_all(ER, seed_list, args, name="Experience Replay (budget = {})".format(args.budget)) + args.replay = "none" + + + ###----"TEMPLATE-BASED CLASSIFICATION"----#### + + if args.scenario=="class": + ## iCaRL + args.bce = True + args.bce_distill = True + args.prototypes = True + args.add_buffer = True + args.sample_selection = "herding" + args.neg_samples = "all-so-far" + ICARL = {} + ICARL = collect_all(ICARL, seed_list, args, name="iCaRL (budget = {})".format(args.budget)) + args.bce = False + args.bce_distill = False + args.prototypes = False + args.add_buffer = False + + ## Generative Classifier + args.gen_classifier = True + classes_per_context = 2 if args.experiment=="splitMNIST" else 10 + args.iters = int(args.iters / classes_per_context) + args.fc_units = args.fc_units_gc + args.fc_lay = args.fc_lay_gc + args.z_dim = args.z_dim_gc + args.hidden = True + args.lr = 0.001 + GENCLASS = {} + GENCLASS = collect_all(GENCLASS, seed_list, args, name="Generative Classifier") + + + #-------------------------------------------------------------------------------------------------# + + #---------------------------------------------# + #----- COLLECT RESULTS: AVERAGE ACCURACY -----# + #---------------------------------------------# + + ## For each seed, create list with average test accuracy + ave_acc = {} + for seed in seed_list: + ave_acc[seed] = [NONE[seed][1], JOINT[seed][1], EWC[seed][1], SI[seed][1], LWF[seed][1], FROMP[seed][1], + DGR[seed][1], ER[seed][1]] + if args.scenario=="task": + ave_acc[seed].append(XDG[seed][1]) + ave_acc[seed].append(SEP[seed][1]) + elif args.scenario=="class": + ave_acc[seed].append(ICARL[seed][1]) + ave_acc[seed].append(GENCLASS[seed][1]) + + ## For each seed, create lists with test accuracy throughout training + prec = {} + for seed in seed_list: + # -for plot of average accuracy throughout training + key = "average" + prec[seed] = [NONE[seed][0][key], JOINT[seed][0][key], EWC[seed][0][key], SI[seed][0][key], LWF[seed][0][key], + FROMP[seed][0][key], DGR[seed][0][key], ER[seed][0][key]] + if args.scenario=="task": + prec[seed].append(XDG[seed][0][key]) + prec[seed].append(SEP[seed][0][key]) + elif args.scenario=="class": + prec[seed].append(ICARL[seed][0][key]) + prec[seed].append(GENCLASS[seed][0][key]) + + + #-------------------------------------------------------------------------------------------------# + + #--------------------------------------------------# + #----- REPORTING / PLOTTING: AVERAGE ACCURACY -----# + #--------------------------------------------------# + + # name for plot + plot_name = "tutorialplots-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "{}-incremental learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + + # select names / colors / ids + names = ["None", "Joint"] + colors = ["grey", "black"] + ids = [0, 1] + if args.scenario=="task": + names += ['Separate Networks', 'XdG'] + colors += ['dodgerblue', 'deepskyblue'] + ids += [9, 8] + names += ['EWC', 'SI', 'LwF', 'FROMP (b={})'.format(args.budget), 'DGR', "ER (b={})".format(args.budget)] + colors += ['darkgreen', 'yellowgreen', 'gold', 'goldenrod', 'indianred', 'red'] + ids += [2, 3, 4, 5, 6, 7] + if args.scenario=="class": + names += ['Generative Classifier', "iCaRL (b={})".format(args.budget)] + colors += ['indigo', 'purple'] + ids += [9, 8] + + # open pdf + pp = visual_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + # bar-plot + means = [np.mean([ave_acc[seed][id] for seed in seed_list]) for id in ids] + if len(seed_list)>1: + sems = [np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + cis = [1.96*np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + figure = visual_plt.plot_bar(means, names=names, colors=colors, ylabel="Average accuracy (after all contexts)", + title=title, yerr=cis if len(seed_list)>1 else None, ylim=(0,1)) + figure_list.append(figure) + + # print results to screen + print("\n\n"+"#"*60+"\nSUMMARY RESULTS: {}\n".format(title)+"#"*60) + for i,name in enumerate(names): + if len(seed_list) > 1: + print("{:27s} {:.2f} (+/- {:.2f}), n={}".format(name, 100*means[i], 100*sems[i], len(seed_list))) + else: + print("{:27s} {:.2f}".format(name, 100*means[i])) + if i==1: + print("="*60) + print("#"*60) + + # line-plot + x_axes = NONE[args.seed][0]["x_context"] + ave_lines = [] + sem_lines = [] + for id in ids: + new_ave_line = [] + new_sem_line = [] + for line_id in range(len(prec[args.seed][id])): + all_entries = [prec[seed][id][line_id] for seed in seed_list] + new_ave_line.append(np.mean(all_entries)) + if len(seed_list) > 1: + new_sem_line.append(1.96*np.sqrt(np.var(all_entries)/(len(all_entries)-1))) + ave_lines.append(new_ave_line) + sem_lines.append(new_sem_line) + figure = visual_plt.plot_lines(ave_lines, x_axes=x_axes, line_names=names, colors=colors, title=title, + xlabel="# of contexts", ylabel="Average accuracy (on contexts so far)", + list_with_errors=sem_lines if len(seed_list)>1 else None) + figure_list.append(figure) + + # add all figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/README.md b/PyTorch/build-in/other/continual-learning/README.md new file mode 100644 index 000000000..8fd1a3ca4 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/README.md @@ -0,0 +1,100 @@ +# continual-learning + +## 1. 模型概述 +continual-learning是一个基于 PyTorch 的持续学习（Continual Learning）算法综合实现库，由 Gido van de Ven 等人开发，用于复现其发表在 Nature Machine Intelligence（2022）上的论文《Three types of incremental learning》中的实验。 +它系统性地实现了多种主流持续学习方法，包括 EWC、Synaptic Intelligence (SI)、LwF、iCaRL、Experience Replay (ER)、Deep Generative Replay (DGR) 等，并支持三种经典持续学习场景：任务增量（task）、领域增量（domain）和类别增量（class）。项目代码结构清晰，便于比较不同方法在 SplitMNIST、PermutedMNIST、CIFAR10/100 等基准数据集上的性能，是研究持续学习/灾难性遗忘问题的重要开源工具。 + + +- 参考实现： + ``` + url=https://github.com/GMvandeVen/continual-learning + commit_id=e6d795aa81b9cef742b8de76cb71222d4d1ce00b + ``` + + +## 2. 快速开始 +使用本模型执行训练的主要流程如下： +1. 基础环境安装：介绍训练前需要完成的基础环境检查和安装。 +2. 获取数据集：介绍如何获取训练所需的数据集。 +3. 构建Docker环境：介绍如何使用Dockerfile创建模型训练时所需的Docker环境。 +4. 启动训练：介绍如何运行训练。 + +### 2.1 基础环境安装 + +请参考[基础环境安装](../../../doc/Environment.md)章节，完成训练前的基础环境检查和安装。 + + +### 2.2 准备数据集 + +- 本实验采用MNIST数据集进行训练，请解压后放在仓库的store文件夹中。 + + +### 2.3 构建Docker环境 + +使用Dockerfile，创建运行模型训练所需的Docker环境。 + +#### 2.3.1 执行以下命令，进入Dockerfile所在目录。 + + ``` + cd /PyTorch/other/continual-learning + ``` + 其中： `modelzoo-dir`是ModelZoo仓库的主目录。 + +#### 2.3.2 执行以下命令，构建名为`sdaa_continual-learning`的镜像。 + + ``` + DOCKER_BUILDKIT=0 COMPOSE_DOCKER_CLI_BUILD=0 docker build . -t sdaa_continual-learning + ``` + +#### 2.3.3 执行以下命令，启动容器。 + + ``` + docker run -itd --name sdaa_continual-learning -v :/datasets --net=host --ipc=host --device /dev/tcaicard0 --device /dev/tcaicard1 --device /dev/tcaicard2 --device /dev/tcaicard3 --shm-size=128g sdaa_mobilenetv3 /bin/bash + ``` + + 其中：`-v`参数用于将主机上的目录或文件挂载到容器内部，对于模型训练，您需要将主机上的数据集目录挂载到docker中的`/datasets/`目录。更多容器配置参数说明参考[文档](../../../doc/Docker.md)。 + + +#### 2.3.4 执行以下命令，进入容器。 + + ``` + docker exec -it sdaa_continual-learning /bin/bash + ``` + +#### 2.3.5 执行以下命令，启动虚拟环境。 + + ``` + conda activate torch_env_py310 + ``` + +#### 2.3.6 执行以下命令，安装其他环境依赖包。 + + ``` + pip install -r requirements.txt + ``` + + +### 2.4 启动训练 + +#### 2.4.1 在Docker环境中，进入训练脚本所在目录。 + ``` + cd /workspace/other/continual-learning + ``` + +#### 2.4.2 运行以下命令训练。 + + - 检查数据集路径，请参考2.2组织数据集。 + - 启动训练： + ``` + python ./main.py --experiment=splitMNIST --scenario=task --si + ``` + +### 2.5 训练结果 + +输出训练loss曲线及结果(代码参考[get_loss.py](./get_loss.py)) + +MeanRelativeError: -0.121553406 +MeanAbsoluteError: 0.00038663193 +Rule,mean_relative_error -0.121553406 +pass mean_relative_error=-0.121553406 <= 0.05 or mean_absolute_error=0.00038663193 <= 0.0002 + diff --git a/PyTorch/build-in/other/continual-learning/StabilityGap/README.md b/PyTorch/build-in/other/continual-learning/StabilityGap/README.md new file mode 100644 index 000000000..fd96acf9f --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/StabilityGap/README.md @@ -0,0 +1,14 @@ +# Stability Gap example + +The script `stability_gap_example.py` provides a simple example of the **stability gap** [(De Lange et al.; 2023, *ICLR*)](https://openreview.net/forum?id=Zy350cRstc6). This phenomenon of temporary forgetting can be consistently observed when using state-of-the-art continual learning methods (e.g., replay or regularization) to incrementally train a deep neural network on multiple tasks. Strikingly, as described by [Hess et al. (2023, *ContinualAI Unconference*)](https://proceedings.mlr.press/v249/hess24a.html), the stability gap occurs even with **incremental joint training** (i.e., when training on a new task, all previous tasks are fully retrained as well), which can be interpreted as "full replay" or "perfect regularization". + +The example in this script uses **Rotated MNIST** with three tasks (rotations: 0°, 80° and 160°) as the task sequence: + +![image](../figures/rotatedMNIST.png) + +This task sequence is performed according to the domain-incremental learning scenario ([van de Ven et al.; 2022, *Nat Mach Intell*](https://www.nature.com/articles/s42256-022-00568-3)). +A fully-connected neural network (with two hidden layers of 400 ReLUs each) is trained on this task sequence using incremental joint training, while the model's performance on the first task is evaluated after each training iteration. + +Running this script should produce a plot similar to: + +![image](../figures/stabilityGap.png) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/StabilityGap/stability_gap_example.py b/PyTorch/build-in/other/continual-learning/StabilityGap/stability_gap_example.py new file mode 100644 index 000000000..3f9ca594c --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/StabilityGap/stability_gap_example.py @@ -0,0 +1,193 @@ +#!/usr/bin/env python3 + +# Standard libraries +import sys +import os +import numpy as np +import tqdm +# Pytorch +import torch +from torch.nn import functional as F +from torchvision import datasets, transforms +# For visualization +from torchvision.utils import make_grid +import matplotlib.pyplot as plt + +# Expand the module search path to parent directory +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) +# Load custom-written code +import utils +from visual import visual_plt +from eval.evaluate import test_acc +from models.classifier import Classifier +from data.manipulate import TransformedDataset + + +################## INITIAL SET-UP ################## + +# Specify directories, and if needed create them +p_dir = "./store/plots" +d_dir = "./store/data" +if not os.path.isdir(p_dir): + print("Creating directory: {}".format(p_dir)) + os.makedirs(p_dir) +if not os.path.isdir(d_dir): + os.makedirs(d_dir) + print("Creating directory: {}".format(d_dir)) + +# Open pdf for plotting +plot_name = "stability_gap_example" +full_plot_name = "{}/{}.pdf".format(p_dir, plot_name) +pp = visual_plt.open_pdf(full_plot_name) +figure_list = [] + + + +################## CREATE TASK SEQUENCE ################## + +## Download the MNIST dataset +print("\n\n " +' LOAD DATA '.center(70, '*')) +MNIST_trainset = datasets.MNIST(root='data/', train=True, download=True, + transform=transforms.ToTensor()) +MNIST_testset = datasets.MNIST(root='data/', train=False, download=True, + transform=transforms.ToTensor()) +config = {'size': 28, 'channels': 1, 'classes': 10} + +# Set for each task the amount of rotation to use +rotations = [0, 80, 160] + +# Specify for each task the transformed train- and testset +n_tasks = len(rotations) +train_datasets = [] +test_datasets = [] +for rotation in rotations: + train_datasets.append(TransformedDataset( + MNIST_trainset, transform=transforms.RandomRotation(degrees=(rotation,rotation)), + )) + test_datasets.append(TransformedDataset( + MNIST_testset, transform=transforms.RandomRotation(degrees=(rotation,rotation)), + )) + +# Visualize the different tasks +figure, axis = plt.subplots(1, n_tasks, figsize=(3*n_tasks, 4)) +n_samples = 49 +for task_id in range(len(train_datasets)): + # Show [n_samples] examples from the training set for each task + data_loader = torch.utils.data.DataLoader(train_datasets[task_id], batch_size=n_samples, shuffle=True) + image_tensor, _ = next(iter(data_loader)) + image_grid = make_grid(image_tensor, nrow=int(np.sqrt(n_samples)), pad_value=1) # pad_value=0 would give black borders + axis[task_id].imshow(np.transpose(image_grid.numpy(), (1,2,0))) + axis[task_id].set_title("Task {}".format(task_id+1)) + axis[task_id].axis('off') +figure_list.append(figure) + + + +################## SET UP THE MODEL ################## + +print("\n\n " + ' DEFINE THE CLASSIFIER '.center(70, '*')) + +# Specify the architectural layout of the network to use +fc_lay = 3 #--> number of fully-connected layers +fc_units = 400 #--> number of units in each hidden layer + +# Define the model +model = Classifier(image_size=config['size'], image_channels=config['channels'], classes=config['classes'], + fc_layers=fc_lay, fc_units=fc_units, fc_bn=False) + +# Print some model info to screen +utils.print_model_info(model) + + + +################## TRAINING AND EVALUATION ################## + +print('\n\n' + ' TRAINING + CONTINUAL EVALUATION '.center(70, '*')) + +# Define a function to train a model, while also evaluating its performance after each iteration +def train_and_evaluate(model, trainset, iters, lr, batch_size, testset, + test_size=512, performance=[]): + '''Function to train a [model] on a given [dataset], + while evaluating after each training iteration on [testset].''' + + optimizer = torch.optim.SGD(model.parameters(), lr=lr) + model.train() + iters_left = 1 + progress_bar = tqdm.tqdm(range(1, iters+1)) + + for _ in range(1, iters+1): + optimizer.zero_grad() + + # Collect data from [trainset] and compute the loss + iters_left -= 1 + if iters_left==0: + data_loader = iter(torch.utils.data.DataLoader(trainset, batch_size=batch_size, + shuffle=True, drop_last=True)) + iters_left = len(data_loader) + x, y = next(data_loader) + y_hat = model(x) + loss = torch.nn.functional.cross_entropy(input=y_hat, target=y, reduction='mean') + + # Calculate test accuracy (in %) + accuracy = 100*test_acc(model, testset, test_size=test_size, verbose=False, batch_size=512) + performance.append(accuracy) + + # Take gradient step + loss.backward() + optimizer.step() + progress_bar.set_description( + ' | training loss: {loss:.3} | test accuracy: {prec:.3}% |' + .format(loss=loss.item(), prec=accuracy) + ) + progress_bar.update(1) + progress_bar.close() + +# Specify the training parameters +iters = 500 #--> for how many iterations to train? +lr = 0.1 #--> learning rate +batch_size = 128 #--> size of mini-batches +test_size = 2000 #--> number of test samples to evaluate on after each iteration + +# Define a list to keep track of the performance on task 1 after each iteration +performance_task1 = [] + +# Iterate through the contexts +for task_id in range(n_tasks): + current_task = task_id+1 + + # Concatenate the training data of all tasks so far + joint_dataset = torch.utils.data.ConcatDataset(train_datasets[:current_task]) + + # Determine the batch size to use + batch_size_to_use = current_task*batch_size + + # Train + print('Training after arrival of Task {}:'.format(current_task)) + train_and_evaluate(model, trainset=joint_dataset, iters=iters, lr=lr, + batch_size=batch_size_to_use, testset=test_datasets[0], + test_size=test_size, performance=performance_task1) + + + +################## PLOTTING ################## + +## Plot per-iteration performance curve +figure = visual_plt.plot_lines( + [performance_task1], x_axes=list(range(n_tasks*iters)), + line_names=['Incremental Joint'], + title="Performance on Task 1 throughout 'Incremental Joint Training'", + ylabel="Test Accuracy (%) on Task 1", + xlabel="Total number of training iterations", figsize=(10,5), + v_line=[iters*(i+1) for i in range(n_tasks-1)], v_label='Task switch', ylim=(70,100), +) +figure_list.append(figure) + +## Finalize the pdf with the plots +# -add figures to pdf +for figure in figure_list: + pp.savefig(figure) +# -close pdf +pp.close() +# -print name of generated plot on screen +print("\nGenerated plot: {}\n".format(full_plot_name)) + diff --git a/PyTorch/build-in/other/continual-learning/all_results.sh b/PyTorch/build-in/other/continual-learning/all_results.sh new file mode 100644 index 000000000..be542195e --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/all_results.sh @@ -0,0 +1,92 @@ +#!/usr/bin/env bash + + + + +########### ICLR 2025 Blogpost ########### + +python3 ICLRblogpost/compare_FI.py --seed=1 --n-seeds=30 --experiment=splitMNIST --scenario=task +python3 ICLRblogpost/compare_FI.py --seed=1 --n-seeds=30 --experiment=CIFAR10 --scenario=task --reducedResNet --iters=2000 --lr=0.001 + + + + +########### NeurIPS 2022 Tutorial ########### + +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=task +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=domain +python NeurIPStutorial/compare_for_tutorial.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=class + + + + +########### Three Types of Incremental Learning (2022, Nat Mach Intell) ########### + +## MNIST + +./compare_hyperParams.py --seed=1 --experiment=splitMNIST --scenario=task +./compare_hyperParams.py --seed=1 --experiment=splitMNIST --scenario=domain +./compare_hyperParams.py --seed=1 --experiment=splitMNIST --scenario=class + +./compare.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=task +./compare.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=domain +./compare.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=class + +./compare_replay.py --seed=2 --n-seeds=5 --experiment=splitMNIST --scenario=task --tau-per-budget +./compare_replay.py --seed=2 --n-seeds=5 --experiment=splitMNIST --scenario=domain --tau-per-budget +./compare_replay.py --seed=2 --n-seeds=5 --experiment=splitMNIST --scenario=class --tau-per-budget + + +## Pre-training on CIFAR-10 + +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=1 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=2 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=3 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=4 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=5 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=6 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=7 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=8 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=9 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=10 +./main_pretrain.py --experiment=CIFAR10 --epochs=100 --augment --convE-stag=e100 --seed-to-stag --seed=11 + + +## CIFAR-100 + +./compare_hyperParams.py --seed=1 --experiment=CIFAR100 --scenario=task --pre-convE --freeze-convE --seed-to-ltag --no-fromp +./compare_hyperParams.py --seed=1 --experiment=CIFAR100 --scenario=domain --pre-convE --freeze-convE --seed-to-ltag --no-fromp +./compare_hyperParams.py --seed=1 --experiment=CIFAR100 --scenario=class --pre-convE --freeze-convE --seed-to-ltag --no-fromp + +./compare.py --seed=2 --n-seeds=10 --experiment=CIFAR100 --scenario=task --pre-convE --freeze-convE --no-fromp --seed-to-ltag +./compare.py --seed=2 --n-seeds=10 --experiment=CIFAR100 --scenario=domain --pre-convE --freeze-convE --no-fromp --seed-to-ltag +./compare.py --seed=2 --n-seeds=10 --experiment=CIFAR100 --scenario=class --pre-convE --freeze-convE --no-fromp --seed-to-ltag --eval-s=10000 + +./compare_replay.py --seed=2 --n-seeds=5 --experiment=CIFAR100 --scenario=task --pre-convE --freeze-convE --seed-to-ltag --no-fromp +./compare_replay.py --seed=2 --n-seeds=5 --experiment=CIFAR100 --scenario=domain --pre-convE --freeze-convE --seed-to-ltag --no-fromp +./compare_replay.py --seed=2 --n-seeds=5 --experiment=CIFAR100 --scenario=class --pre-convE --freeze-convE --seed-to-ltag --no-fromp + + +## Permuted MNIST + +./compare_hyperParams.py --seed=1 --experiment=permMNIST --scenario=task --fisher-n=1000 --no-xdg --no-fromp --no-bir +./compare_hyperParams.py --seed=1 --experiment=permMNIST --scenario=task --singlehead --fisher-n=1000 --no-reg --no-fromp --no-bir +./compare_hyperParams.py --seed=1 --experiment=permMNIST --scenario=task --singlehead --xdg --gating-prop=0.6 --fisher-n=1000 --no-xdg --no-fromp --no-bir +./compare_hyperParams.py --seed=1 --experiment=permMNIST --scenario=domain --fisher-n=1000 --no-fromp --no-bir + +./compare.py --seed=2 --n-seeds=5 --experiment=permMNIST --scenario=task --no-context-spec --no-fromp --no-bir --no-agem --fisher-n=1000 +./compare.py --seed=2 --n-seeds=5 --experiment=permMNIST --scenario=task --singlehead --xdg --gating-prop=0.6 --no-context-spec --no-fromp --no-bir --no-agem --fisher-n=1000 +./compare.py --seed=2 --n-seeds=5 --experiment=permMNIST --scenario=domain --no-fromp --no-bir --no-agem --fisher-n=1000 + + +## Task-free Split MNIST + +./compare_hyperParams_task_free.py --seed=1 --experiment=splitMNIST --scenario=task +./compare_hyperParams_task_free.py --seed=1 --experiment=splitMNIST --scenario=domain +./compare_hyperParams_task_free.py --seed=1 --experiment=splitMNIST --scenario=class + +./compare_task_free.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=task --gating-prop=0.45 --c=10. +./compare_task_free.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=domain --c=10. +./compare_task_free.py --seed=2 --n-seeds=20 --experiment=splitMNIST --scenario=class --c=10. + +# \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/compare.py b/PyTorch/build-in/other/continual-learning/compare.py new file mode 100644 index 000000000..a07bfa2c2 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/compare.py @@ -0,0 +1,362 @@ +#!/usr/bin/env python3 +import os +import numpy as np +# -custom-written code +import main +from utils import checkattr +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_all': True} + # Define input options + parser = options.define_args(filename="compare", description='Compare performance of CL strategies.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Should some methods not be included in the comparison? + parser.add_argument('--no-context-spec', action='store_true', help="no XdG or Separate Networks") + parser.add_argument('--no-reg', action='store_true', help="no EWC or SI") + parser.add_argument('--no-fromp', action='store_true', help="no FROMP") + parser.add_argument('--no-bir', action='store_true', help="no BI-R") + parser.add_argument('--no-agem', action='store_true', help="no A-GEM") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=True) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +## Functions for running experiments and collecting results +def get_results(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args) + # -check whether already run; if not do so + file_to_check = '{}/acc-{}{}.txt'.format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + if os.path.isfile(file_to_check): + print(" already run: {}".format(param_stamp)) + elif os.path.isfile("{}/mM-{}".format(args.m_dir, param_stamp)): + args.train = False + print(" ...testing: {}".format(param_stamp)) + main.run(args) + else: + args.train = True + print(" ...running: {}".format(param_stamp)) + main.run(args) + # -get average accuracy + fileName = '{}/acc-{}{}.txt'.format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + file = open(fileName) + ave = float(file.readline()) + file.close() + # -print average accuracy on screen + print("--> average accuracy: {}".format(ave)) + # -return average accuracy + return ave + +def collect_all(method_dict, seed_list, args, name=None): + # -print name of method on screen + if name is not None: + print("\n------{}------".format(name)) + # -run method for all random seeds + for seed in seed_list: + args.seed = seed + method_dict[seed] = get_results(args) + # -return updated dictionary with results + return method_dict + + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + seed_list = list(range(args.seed, args.seed+args.n_seeds)) + + + ###----"BASELINES"----### + + ## None + args.replay = "none" + NONE = {} + NONE = collect_all(NONE, seed_list, args, name="None") + + ## JOINT training (using total number of iterations from all contexts) + iters_temp = args.iters + args.iters = args.contexts*iters_temp + args.joint = True + JOINT = {} + JOINT = collect_all(JOINT, seed_list, args, name="Joint") + args.joint = False + args.iters = iters_temp + + + ###----"CONTEXT-SPECIFIC"----#### + + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + ## Separate network per context + fc_units_temp = args.fc_units + args.fc_units = args.fc_units_sep + args.separate_networks = True + SEP = {} + SEP = collect_all(SEP, seed_list, args, name="Separate Networks") + args.separate_networks = False + args.fc_units = fc_units_temp + + ## XdG + always_xdg = checkattr(args, 'xdg') + args.xdg = True + XDG = {} + XDG = collect_all(XDG, seed_list, args, name="XdG") + args.xdg = always_xdg + + + ###----"PARAMETER REGULARIZATION"----#### + + if not checkattr(args, 'no_reg'): + ## EWC + args.weight_penalty = True + args.importance_weighting = 'fisher' + args.offline = True + args.reg_strength = args.ewc_lambda + EWC = {} + EWC = collect_all(EWC, seed_list, args, name="EWC") + args.weight_penalty = False + args.offline = False + + ## SI + args.weight_penalty = True + args.importance_weighting = 'si' + args.reg_strength = args.si_c + SI = {} + SI = collect_all(SI, seed_list, args, name="SI") + args.weight_penalty = False + else: + EWC = SI = None + + + ###----"FUNCTIONAL REGULARIZATION"----#### + + ## LwF + args.replay = "current" + args.distill = True + LWF = {} + LWF = collect_all(LWF, seed_list, args, name="LwF") + args.replay = "none" + args.distill = False + + ## FROMP + if not checkattr(args, 'no_fromp'): + args.fromp = True + args.sample_selection = "fromp" + FROMP = {} + FROMP = collect_all(FROMP, seed_list, args, name="FROMP") + args.fromp = False + else: + FROMP = None + + + ###----"REPLAY"----### + + ## DGR + args.replay = "generative" + args.distill = False + DGR = {} + DGR = collect_all(DGR, seed_list, args, name="Deep Generative Replay") + + ## BI-R + if not checkattr(args, 'no_bir'): + args.replay = "generative" + args.feedback = True + args.hidden = True + args.dg_gates = True + args.prior = "GMM" + args.per_class = True + args.distill = True + BIR = {} + BIR = collect_all(BIR, seed_list, args, name="Brain-Inspired Replay") + args.feedback = False + args.hidden = False + args.dg_gates = False + args.prior = "standard" + args.per_class = False + args.distill = False + else: + BIR = None + + ## Experience Replay + args.replay = "buffer" + args.sample_selection = "random" + ER = {} + ER = collect_all(ER, seed_list, args, name="Experience Replay (budget = {})".format(args.budget)) + args.replay = "none" + + ## A-GEM + if not checkattr(args, 'no_agem'): + args.replay = "buffer" + args.sample_selection = "random" + args.use_replay = "inequality" + AGEM = {} + AGEM = collect_all(AGEM, seed_list, args, name="A-GEM (budget = {})".format(args.budget)) + args.replay = "none" + args.use_replay = "normal" + else: + AGEM = None + + + ###----"TEMPLATE-BASED CLASSIFICATION"----#### + + if args.scenario=="class" and not args.neg_samples=="current": + ## iCaRL + args.bce = True + args.bce_distill = True + args.prototypes = True + args.add_buffer = True + args.sample_selection = "herding" + args.neg_samples = "all-so-far" + ICARL = {} + ICARL = collect_all(ICARL, seed_list, args, name="iCaRL (budget = {})".format(args.budget)) + args.bce = False + args.bce_distill = False + args.prototypes = False + args.add_buffer = False + + ## Generative Classifier + args.gen_classifier = True + classes_per_context = 2 if args.experiment=="splitMNIST" else 10 + args.iters = int(args.iters / classes_per_context) + args.fc_units = args.fc_units_gc + args.fc_lay = args.fc_lay_gc + args.z_dim = args.z_dim_gc + args.hidden = True + args.lr = 0.001 + GENCLASS = {} + GENCLASS = collect_all(GENCLASS, seed_list, args, name="Generative Classifier") + + + #-------------------------------------------------------------------------------------------------# + + #---------------------------------------------# + #----- COLLECT RESULTS: AVERAGE ACCURACY -----# + #---------------------------------------------# + + ## For each seed, create list with average test accuracy + ave_acc = {} + for seed in seed_list: + ave_acc[seed] = [NONE[seed], JOINT[seed], + 0 if EWC is None else EWC[seed], 0 if SI is None else SI[seed], LWF[seed], + 0 if FROMP is None else FROMP[seed], + DGR[seed], 0 if BIR is None else BIR[seed], ER[seed], 0 if AGEM is None else AGEM[seed]] + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + ave_acc[seed].append(XDG[seed]) + ave_acc[seed].append(SEP[seed]) + elif args.scenario=="class" and not args.neg_samples=="current": + ave_acc[seed].append(ICARL[seed]) + ave_acc[seed].append(GENCLASS[seed]) + + + #-------------------------------------------------------------------------------------------------# + + #--------------------------------------------------# + #----- REPORTING / PLOTTING: AVERAGE ACCURACY -----# + #--------------------------------------------------# + + # name for plot + plot_name = "summary-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "{}-incremental learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + + # select names / colors / ids + names = ["None", "Joint"] + colors = ["grey", "black"] + ids = [0, 1] + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + names += ['Separate Networks', 'XdG'] + colors += ['dodgerblue', 'deepskyblue'] + ids += [11, 10] + if not checkattr(args, 'no_reg'): + names += ['EWC', 'SI'] + colors += ['darkgreen', 'yellowgreen'] + ids += [2, 3] + names.append('LwF') + colors.append('gold') + ids.append(4) + if not checkattr(args, 'no_fromp'): + names.append("FROMP (b={})".format(args.budget)) + colors.append('goldenrod') + ids.append(5) + names.append('DGR') + colors.append('indianred') + ids.append(6) + if not checkattr(args, 'no_bir'): + names.append('BI-R') + colors.append('lightcoral') + ids.append(7) + names.append("ER (b={})".format(args.budget)) + colors.append('red') + ids.append(8) + if not checkattr(args, 'no_agem'): + names.append("A-GEM (b={})".format(args.budget)) + colors.append('orangered') + ids.append(9) + if args.scenario=="class" and not args.neg_samples=="current": + names += ['Generative Classifier', "iCaRL (b={})".format(args.budget)] + colors += ['indigo', 'purple'] + ids += [11, 10] + + # open pdf + pp = visual_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + # bar-plot + means = [np.mean([ave_acc[seed][id] for seed in seed_list]) for id in ids] + if len(seed_list)>1: + sems = [np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + cis = [1.96*np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + figure = visual_plt.plot_bar(means, names=names, colors=colors, ylabel="average accuracy (after all contexts)", + title=title, yerr=cis if len(seed_list)>1 else None, ylim=(0,1)) + figure_list.append(figure) + + # print results to screen + print("\n\n"+"#"*60+"\nSUMMARY RESULTS: {}\n".format(title)+"#"*60) + for i,name in enumerate(names): + if len(seed_list) > 1: + print("{:27s} {:.2f} (+/- {:.2f}), n={}".format(name, 100*means[i], 100*sems[i], len(seed_list))) + else: + print("{:27s} {:.2f}".format(name, 100*means[i])) + if i==1: + print("="*60) + print("#"*60) + + # add all figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/compare_hyperParams.py b/PyTorch/build-in/other/continual-learning/compare_hyperParams.py new file mode 100644 index 000000000..009c86392 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/compare_hyperParams.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python3 +import os +import numpy as np +from matplotlib.pyplot import get_cmap +# -custom-written code +import main +import utils +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt as my_plt + + +## Parameter-values to compare +lamda_list = [1., 10., 100., 1000., 10000., 100000., 1000000., 10000000., 100000000., 1000000000., 10000000000., + 100000000000., 1000000000000., 10000000000000.] +lamda_list_permMNIST = [1., 10., 100., 1000., 10000., 100000., 1000000., 10000000.] +c_list = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1., 5., 10., 50., 100., 500., 1000., 5000., 10000., 50000., 100000.] +c_list_permMNIST = [0.01, 0.1, 1., 10., 100., 1000., 10000., 100000.] +xdg_list = [0., 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95] +xdg_list_permMNIST = [0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] +dg_prop_list = [0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] +tau_list = [0.001, 0.01, 0.1, 1., 10., 100., 1000., 10000., 100000.] +budget_list_splitMNIST = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000] +budget_list_splitCIFAR100 = [1, 2, 5, 10, 20] + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_hyper': True} + # Define input options + parser = options.define_args(filename="compare_hyperParams", description='Hyperparamer gridsearches.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Should the gridsearch not be run for some methods? + parser.add_argument('--no-xdg', action='store_true', help="no XdG") + parser.add_argument('--no-reg', action='store_true', help="no EWC or SI") + parser.add_argument('--no-fromp', action='store_true', help="no FROMP") + parser.add_argument('--no-bir', action='store_true', help="no BI-R") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=False) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +## Function for running experiments and collecting results +def get_result(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args) + # -check whether already run, and if not do so + if os.path.isfile('{}/acc-{}.txt'.format(args.r_dir, param_stamp)): + print(" already run: {}".format(param_stamp)) + else: + args.train = True + print("\n ...running: {} ...".format(param_stamp)) + main.run(args) + # -get average accuracy + fileName = '{}/acc-{}.txt'.format(args.r_dir, param_stamp) + file = open(fileName) + ave = float(file.readline()) + file.close() + # -return it + return ave + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + ## Select parameter-lists based on chosen experiment + xdg_list = xdg_list_permMNIST if args.experiment=="permMNIST" else xdg_list + lamda_list = lamda_list_permMNIST if args.experiment=="permMNIST" else lamda_list + c_list = c_list_permMNIST if args.experiment=="permMNIST" else c_list + budget_list = budget_list_splitMNIST if args.experiment=="splitMNIST" else budget_list_splitCIFAR100 + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + ## Baselline + args.replay = "none" + BASE = get_result(args) + + ## XdG + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + XDG = {} + always_xdg = utils.checkattr(args, 'xdg') + if always_xdg: + gating_prop_selected = args.gating_prop + args.xdg = True + for xdg in xdg_list: + args.gating_prop = xdg + XDG[xdg] = get_result(args) + args.xdg = always_xdg + if always_xdg: + args.gating_prop = gating_prop_selected + + ## EWC + if not utils.checkattr(args, 'no_reg'): + EWC = {} + args.weight_penalty = True + args.offline = True + args.importance_weighting = 'fisher' + for ewc_lambda in lamda_list: + args.reg_strength = ewc_lambda + EWC[ewc_lambda] = get_result(args) + args.weight_penalty = False + args.offline = False + + ## SI + if not utils.checkattr(args, 'no_reg'): + SI = {} + args.weight_penalty = True + args.importance_weighting = 'si' + for si_c in c_list: + args.reg_strength = si_c + SI[si_c] = get_result(args) + args.weight_penalty = False + + ## FROMP + if not utils.checkattr(args, 'no_fromp'): + FROMP = {} + args.fromp = True + args.sample_selection = 'fromp' + for budget in budget_list: + args.budget = budget + FROMP[budget] = {} + for tau in tau_list: + args.tau = tau + FROMP[budget][tau] = get_result(args) + args.fromp = False + + ## BI-R + if not utils.checkattr(args, 'no_bir'): + BIR = {} + args.replay = "generative" + args.feedback = True + args.hidden = True + args.dg_gates = True + args.prior = "GMM" + args.per_class = True + args.distill = True + for dg_prop in dg_prop_list: + args.dg_prop = dg_prop + BIR[dg_prop] = get_result(args) + + + #-------------------------------------------------------------------------------------------------# + + #-----------------------------------------# + #----- COLLECT DATA & PRINT ON SCREEN-----# + #-----------------------------------------# + + ext_c_list = [0] + c_list + ext_lambda_list = [0] + lamda_list + ext_tau_list = [0] + tau_list + print("\n") + + + ###---XdG---### + + if args.scenario == "task" and not utils.checkattr(args, 'no_xdg'): + # -collect data + ave_acc_xdg = [XDG[c] for c in xdg_list] + # -print on screen + print("\n\nCONTEXT-DEPENDENT GATING (XDG))") + print(" param list (gating_prop): {}".format(xdg_list)) + print(" {}".format(ave_acc_xdg)) + print("---> gating_prop = {} -- {}".format(xdg_list[np.argmax(ave_acc_xdg)], np.max(ave_acc_xdg))) + + + ###---EWC---### + + if not utils.checkattr(args, 'no_reg'): + # -collect data + ave_acc_ewc = [BASE] + [EWC[ewc_lambda] for ewc_lambda in lamda_list] + # -print on screen + print("\n\nELASTIC WEIGHT CONSOLIDATION (EWC)") + print(" param-list (lambda): {}".format(ext_lambda_list)) + print(" {}".format(ave_acc_ewc)) + print("---> lambda = {} -- {}".format(ext_lambda_list[np.argmax(ave_acc_ewc)], np.max(ave_acc_ewc))) + + + ###---SI---### + + if not utils.checkattr(args, 'no_reg'): + # -collect data + ave_acc_si = [BASE] + [SI[c] for c in c_list] + # -print on screen + print("\n\nSYNAPTIC INTELLIGENCE (SI)") + print(" param list (si_c): {}".format(ext_c_list)) + print(" {}".format(ave_acc_si)) + print("---> si_c = {} -- {}".format(ext_c_list[np.argmax(ave_acc_si)], np.max(ave_acc_si))) + + + ###---FROMP---### + + if not utils.checkattr(args, 'no_fromp'): + ave_acc_fromp_per_budget = [] + for budget in budget_list: + # -collect data + ave_acc_fromp = [FROMP[budget][tau] for tau in tau_list] + ave_acc_fromp_ext = [BASE] + [FROMP[budget][tau] for tau in tau_list] + # -print on screen + print("\n\nFROMP (budget={})".format(budget)) + print(" param-list (tau): {}".format(ext_tau_list)) + print(" {}".format(ave_acc_fromp_ext)) + print("---> tau = {} -- {}".format(ext_tau_list[np.argmax(ave_acc_fromp_ext)], + np.max(ave_acc_fromp_ext))) + # -collect data for each budget for plotting in one graph + ave_acc_fromp_per_budget.append(ave_acc_fromp) + + + ###---BI-R---### + + if not utils.checkattr(args, 'no_bir'): + # -collect data + ave_acc_bir = [BIR[dg_prop] for dg_prop in dg_prop_list] + # -print on screen + print("\n\nBRAIN-INSPIRED REPLAY (BI-R)") + print(" param list (dg_prop): {}".format(dg_prop_list)) + print(" {}".format(ave_acc_bir)) + print("---> dg_prop = {} -- {}".format(dg_prop_list[np.argmax(ave_acc_bir)], np.max(ave_acc_bir))) + print('\n') + + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- PLOTTING -----# + #--------------------# + + # name for plot + plot_name = "hyperParams-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "incremental {} learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + ylabel = "Test accuracy (after all contexts)" + + # calculate limits y-axes (to have equal axes for all graphs) + full_list = [] + if not utils.checkattr(args, 'no_reg'): + full_list += ave_acc_ewc + ave_acc_si + if not utils.checkattr(args, 'no_fromp'): + for item in ave_acc_fromp_per_budget: + full_list += item + if not utils.checkattr(args, 'no_bir'): + full_list += ave_acc_bir + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + full_list += ave_acc_xdg + miny = np.min(full_list) + maxy = np.max(full_list) + marginy = 0.1*(maxy-miny) + ylim = (np.max([miny-2*marginy, 0]), + np.min([maxy+marginy,1])) if not args.scenario=="class" else (0, np.min([maxy+marginy,1])) + + # open pdf + pp = my_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + + ###---XdG---### + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + figure = my_plt.plot_lines([ave_acc_xdg], x_axes=xdg_list, ylabel=ylabel, + line_names=["XdG"], colors=["deepskyblue"], ylim=ylim, + title=title, x_log=False, xlabel="XdG: % of nodes gated", + with_dots=True, h_line=BASE, h_label="None") + figure_list.append(figure) + + + ###---EWC---### + if not utils.checkattr(args, 'no_reg'): + figure = my_plt.plot_lines([ave_acc_ewc[1:]], x_axes=lamda_list, ylabel=ylabel, line_names=["EWC"], + colors=["darkgreen"], title=title, x_log=True, xlabel="EWC: lambda (log-scale)", + with_dots=True, ylim=ylim, h_line=BASE, h_label="None") + figure_list.append(figure) + + + ###---SI---### + if not utils.checkattr(args, 'no_reg'): + figure = my_plt.plot_lines([ave_acc_si[1:]], x_axes=c_list, ylabel=ylabel, line_names=["SI"], + colors=["yellowgreen"], title=title, x_log=True, xlabel="SI: c (log-scale)", + with_dots=True, ylim=ylim, h_line=BASE, h_label="None") + figure_list.append(figure) + + + ###---FROMP---### + if not utils.checkattr(args, 'no_fromp'): + colors = get_cmap('YlOrBr')(np.linspace(1.0, 0.5, len(budget_list))).tolist() + figure = my_plt.plot_lines(ave_acc_fromp_per_budget, x_axes=tau_list, ylabel=ylabel, + line_names=["FROMP (budget={})".format(budget) for budget in budget_list], + colors=colors, title=title, x_log=True, xlabel="FROMP: tau (log-scale)", + with_dots=True, ylim=ylim, h_line=BASE, h_label="None") + figure_list.append(figure) + + + ###---BI-R---### + if not utils.checkattr(args, 'no_bir'): + figure = my_plt.plot_lines([ave_acc_bir], x_axes=dg_prop_list, ylabel=ylabel, line_names=["BI-R"], + colors=["lightcoral"], title=title, x_log=False, with_dots=True, + xlabel="BI-R: % of nodes gated in decoder", ylim=ylim, h_line=BASE, h_label="None") + figure_list.append(figure) + + + # add figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/compare_hyperParams_task_free.py b/PyTorch/build-in/other/continual-learning/compare_hyperParams_task_free.py new file mode 100644 index 000000000..7f5695fa1 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/compare_hyperParams_task_free.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +import os +import numpy as np +# -custom-written code +import main_task_free +import utils +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt as my_plt + + +## Parameter-values to compare +c_list = [0.001, 0.01, 0.1, 1., 10., 100., 1000., 10000., 100000., 1000000., 10000000.] +xdg_list = [0., 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95] + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_hyper': True, 'no_boundaries': True} + # Define input options + parser = options.define_args(filename="compare_hyperParams_task_free", description='Hyperparamer gridsearches.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Should the gridsearch not be run for some methods? + parser.add_argument('--no-xdg', action='store_true', help="no XdG") + parser.add_argument('--no-si', action='store_true', help="no SI") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=False) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +## Function for running experiments and collecting results +def get_result(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args, no_boundaries=True) + # -check whether already run, and if not do so + if os.path.isfile('{}/acc-{}.txt'.format(args.r_dir, param_stamp)): + print(" already run: {}".format(param_stamp)) + else: + args.train = True + print("\n ...running: {} ...".format(param_stamp)) + main_task_free.run(args) + # -get average accuracy + fileName = '{}/acc-{}.txt'.format(args.r_dir, param_stamp) + file = open(fileName) + ave = float(file.readline()) + file.close() + # -return it + return ave + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + ## Baselline + args.replay = "none" + BASE = get_result(args) + + ## XdG + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + XDG = {} + always_xdg = utils.checkattr(args, 'xdg') + if always_xdg: + gating_prop_selected = args.gating_prop + args.xdg = True + for xdg in xdg_list: + args.gating_prop = xdg + XDG[xdg] = get_result(args) + args.xdg = always_xdg + if always_xdg: + args.gating_prop = gating_prop_selected + + ## SI + if not utils.checkattr(args, 'no_si'): + SI = {} + args.weight_penalty = True + args.importance_weighting = 'si' + for si_c in c_list: + args.reg_strength = si_c + SI[si_c] = get_result(args) + args.weight_penalty = False + + + #-------------------------------------------------------------------------------------------------# + + #-----------------------------------------# + #----- COLLECT DATA & PRINT ON SCREEN-----# + #-----------------------------------------# + + ext_c_list = [0] + c_list + print("\n") + + + ###---XdG---### + + if args.scenario == "task" and not utils.checkattr(args, 'no_xdg'): + # -collect data + ave_acc_xdg = [XDG[c] for c in xdg_list] + # -print on screen + print("\n\nCONTEXT-DEPENDENT GATING (XDG))") + print(" param list (gating_prop): {}".format(xdg_list)) + print(" {}".format(ave_acc_xdg)) + print("---> gating_prop = {} -- {}".format(xdg_list[np.argmax(ave_acc_xdg)], np.max(ave_acc_xdg))) + + + ###---SI---### + + if not utils.checkattr(args, 'no_si'): + # -collect data + ave_acc_si = [BASE] + [SI[c] for c in c_list] + # -print on screen + print("\n\nSYNAPTIC INTELLIGENCE (SI)") + print(" param list (si_c): {}".format(ext_c_list)) + print(" {}".format(ave_acc_si)) + print("---> si_c = {} -- {}".format(ext_c_list[np.argmax(ave_acc_si)], np.max(ave_acc_si))) + + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- PLOTTING -----# + #--------------------# + + # name for plot + plot_name = "hyperParams-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "incremental {} learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + ylabel = "Test accuracy (after all contexts)" + + # calculate limits y-axes (to have equal axes for all graphs) + full_list = [] + if not utils.checkattr(args, 'no_si'): + full_list += ave_acc_si + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + full_list += ave_acc_xdg + miny = np.min(full_list) + maxy = np.max(full_list) + marginy = 0.1*(maxy-miny) + ylim = (np.max([miny-2*marginy, 0]), + np.min([maxy+marginy,1])) if not args.scenario=="class" else (0, np.min([maxy+marginy,1])) + + # open pdf + pp = my_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + + ###---XdG---### + if args.scenario=="task" and not utils.checkattr(args, 'no_xdg'): + figure = my_plt.plot_lines([ave_acc_xdg], x_axes=xdg_list, ylabel=ylabel, + line_names=["XdG"], colors=["deepskyblue"], ylim=ylim, + title=title, x_log=False, xlabel="XdG: % of nodes gated", + with_dots=True, h_line=BASE, h_label="None") + figure_list.append(figure) + + ###---SI---### + if not utils.checkattr(args, 'no_si'): + figure = my_plt.plot_lines([ave_acc_si[1:]], x_axes=c_list, ylabel=ylabel, line_names=["SI"], + colors=["yellowgreen"], title=title, x_log=True, xlabel="SI: c (log-scale)", + with_dots=True, ylim=ylim, h_line=BASE, h_label="None") + figure_list.append(figure) + + + # add figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/compare_replay.py b/PyTorch/build-in/other/continual-learning/compare_replay.py new file mode 100644 index 000000000..a7bfcbf36 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/compare_replay.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 +import os +import numpy as np +# -custom-written code +import main +from utils import checkattr +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt + + +## Memory budget values to compare +budget_list_CIFAR100 = [1, 2, 5, 10, 20, 50, 100, 200, 500] +budget_list_splitMNIST = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000] + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_replay': True} + # Define input options + parser = options.define_args(filename="compare_replay", + description='Evaluate CL methods storing data as function of available memory budget.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Should some methods not be included? + parser.add_argument('--no-fromp', action='store_true', help="no FROMP") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + set_default_values(args, also_hyper_params=False) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +def get_result(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args) + # -check whether already run, and if not do so + if os.path.isfile('{}/acc-{}.txt'.format(args.r_dir, param_stamp)): + print(" already run: {}".format(param_stamp)) + else: + args.train = True + print("\n ...running: {} ...".format(param_stamp)) + main.run(args) + # -get average accuracy + fileName = '{}/acc-{}.txt'.format(args.r_dir, param_stamp) + file = open(fileName) + ave = float(file.readline()) + file.close() + # -return it + return ave + + +def collect_all(method_dict, seed_list, args, name=None): + # -print name of method on screen + if name is not None: + print("\n------{}------".format(name)) + # -run method for all random seeds + for seed in seed_list: + args.seed = seed + method_dict[seed] = get_result(args) + # -return updated dictionary with results + return method_dict + + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # -create results-directory if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + # -create plots-directory if needed + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + ## Select correct memory budget list + budget_list = budget_list_CIFAR100 if args.experiment=="CIFAR100" else budget_list_splitMNIST + + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + seed_list = list(range(args.seed, args.seed+args.n_seeds)) + + budget_limit_FROMP = 1000 + if checkattr(args, 'tau_per_budget'): + if args.scenario=="task": + tau_dict = {'1': 100000., '2': 1000., '5': 100000., '10': 0.001, '20': 10000., '50': 1000., + '100': 0.01, '200': 0.01, '500': 0.1, '1000': 10.} + elif args.scenario=="domain": + tau_dict = {'1': 0.001, '2': 100000., '5': 100000., '10': 100000., '20': 100000., '50': 10000., + '100': 10., '200': 1., '500': 10., '1000': 0.1} + elif args.scenario=="class": + tau_dict = {'1': 100000., '2': 0.01, '5': 10000., '10': 100000., '20': 10000., '50': 1000., + '100': 1000., '200': 10., '500': 0.001, '1000': 1.} + + + ###### BASELINES ######### + + args.replay = "none" + BASE = {} + BASE = collect_all(BASE, seed_list, args, name="None") + + iters_temp = args.iters + args.iters = args.contexts*iters_temp + args.joint = True + JOINT = {} + JOINT = collect_all(JOINT, seed_list, args, name="Joint") + args.joint = False + args.iters = iters_temp + + + ###### CL METHODS STORING DATA ######### + + ## Experience Replay + args.replay = "buffer" + args.sample_selection = "random" + args.distill = False + ER = {} + for budget in budget_list: + args.budget = budget + ER[budget] = {} + ER[budget] = collect_all(ER[budget], seed_list, args, name="Experience Replay - budget = {}".format(budget)) + + ## A-GEM + args.replay = "buffer" + args.distill = False + args.sample_selection = "random" + args.use_replay = "inequality" + AGEM = {} + for budget in budget_list: + args.budget = budget + AGEM[budget] = {} + AGEM[budget] = collect_all(AGEM[budget], seed_list, args, name="A-GEM - budget = {}".format(budget)) + args.use_replay = "normal" + + ## FROMP + if not checkattr(args, 'no_fromp'): + args.replay = "none" + args.fromp = True + args.sample_selection = "fromp" + FROMP = {} + for budget in budget_list: + if budget<=budget_limit_FROMP: + args.budget = budget + if checkattr(args, 'tau_per_budget'): + args.tau = tau_dict['{}'.format(budget)] + FROMP[budget] = {} + FROMP[budget] = collect_all(FROMP[budget], seed_list, args, name="FROMP - budget = {}".format(budget)) + args.fromp = False + + ## iCaRL + if args.scenario=="class": + args.replay = "none" + args.prototypes = True + args.bce = True + args.bce_distill = True + args.add_buffer = True + args.sample_selection = 'herding' + args.neg_samples = "all-so-far" + ICARL = {} + for budget in budget_list: + args.budget = budget + ICARL[budget] = {} + ICARL[budget] = collect_all(ICARL[budget], seed_list, args, name="iCaRL - budget = {}".format(budget)) + + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- PLOTTING -----# + #--------------------# + + # name for plot + plot_name = "summaryExactRep-{}{}-{}".format(args.experiment,args.contexts,args.scenario) + scheme = "incremental {} learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + + # open pdf + pp = visual_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + # set scale of y-axis + y_lim = [0,1] if args.scenario=="class" else None + y_lim = None + + # Methods for comparison + h_lines = [np.mean([BASE[seed] for seed in seed_list]), np.mean([JOINT[seed] for seed in seed_list])] + h_errors = [np.sqrt(np.var([BASE[seed] for seed in seed_list]) / (len(seed_list)-1)), + np.sqrt(np.var([JOINT[seed] for seed in seed_list]) / (len(seed_list)-1))] if args.n_seeds>1 else None + h_labels = ["None", "Joint"] + h_colors = ["grey", "black"] + + + # Different variants of exact replay + # -prepare + ave_ER = [] + sem_ER = [] + ave_AGEM = [] + sem_AGEM = [] + if not checkattr(args, 'no_fromp'): + ave_FROMP = [] + sem_FROMP = [] + if args.scenario=="class": + ave_ICARL = [] + sem_ICARL = [] + + for budget in budget_list: + all_entries = [ER[budget][seed] for seed in seed_list] + ave_ER.append(np.mean(all_entries)) + if args.n_seeds > 1: + sem_ER.append(np.sqrt(np.var(all_entries) / (len(all_entries) - 1))) + + all_entries = [AGEM[budget][seed] for seed in seed_list] + ave_AGEM.append(np.mean(all_entries)) + if args.n_seeds > 1: + sem_AGEM.append(np.sqrt(np.var(all_entries) / (len(all_entries) - 1))) + + if not checkattr(args, 'no_fromp'): + if budget<=budget_limit_FROMP: + all_entries = [FROMP[budget][seed] for seed in seed_list] + ave_FROMP.append(np.mean(all_entries)) + if args.n_seeds > 1: + sem_FROMP.append(np.sqrt(np.var(all_entries) / (len(all_entries) - 1))) + else: + ave_FROMP.append(np.nan) + if args.n_seeds>1: + sem_FROMP.append(np.nan) + + if args.scenario=="class": + all_entries = [ICARL[budget][seed] for seed in seed_list] + ave_ICARL.append(np.mean(all_entries)) + if args.n_seeds > 1: + sem_ICARL.append(np.sqrt(np.var(all_entries) / (len(all_entries) - 1))) + + # -collect + lines = [ave_ER, ave_AGEM] + errors = [sem_ER, sem_AGEM] if args.n_seeds > 1 else None + line_names = ["ER", "A-GEM"] + colors = ["red", "orangered"] + if not checkattr(args, 'no_fromp'): + lines.append(ave_FROMP) + line_names.append("FROMP") + colors.append("goldenrod") + if args.n_seeds>1: + errors.append(sem_FROMP) + if args.scenario=="class": + lines.append(ave_ICARL) + line_names.append("iCaRL") + colors.append("purple") + if args.n_seeds>1: + errors.append(sem_ICARL) + + # -plot + figure = visual_plt.plot_lines( + lines, x_axes=budget_list, ylabel="average accuracy (after all contexts)", title=title, x_log=True, ylim=y_lim, + line_names=line_names, xlabel="Total memory budget", with_dots=True, colors=colors, list_with_errors=errors, + h_lines=h_lines, h_errors=h_errors, h_labels=h_labels, h_colors=h_colors, + ) + figure_list.append(figure) + + + # add figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/compare_task_free.py b/PyTorch/build-in/other/continual-learning/compare_task_free.py new file mode 100644 index 000000000..cb4179f0b --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/compare_task_free.py @@ -0,0 +1,294 @@ +#!/usr/bin/env python3 +import os +import numpy as np +# -custom-written code +import main_task_free +from utils import checkattr +from params.param_stamp import get_param_stamp_from_args +from params.param_values import check_for_errors,set_default_values +from params import options +from visual import visual_plt + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'comparison': True, 'compare_all': True, 'no_boundaries': True} + # Define input options + parser = options.define_args(filename="compare_task_free", description='Compare performance of CL strategies.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Should some methods not be included in the comparison? + parser.add_argument('--no-context-spec', action='store_true', help="no XdG or Separate Networks") + parser.add_argument('--no-si', action='store_true', help="no SI") + parser.add_argument('--no-agem', action='store_true', help="no A-GEM") + # Parse, process (i.e., set defaults for unselected options) and check chosen options + args = parser.parse_args() + args.log_per_context = True + set_default_values(args, also_hyper_params=True, no_boundaries=True) # -set defaults, some based on chosen options + check_for_errors(args, **kwargs) # -check for incompatible options + return args + + +## Functions for running experiments and collecting results +def get_results(args): + # -get param-stamp + param_stamp = get_param_stamp_from_args(args, no_boundaries=True) + # -check whether already run; if not do so + file_to_check = '{}/acc-{}{}.txt'.format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + if os.path.isfile(file_to_check): + print(" already run: {}".format(param_stamp)) + elif os.path.isfile("{}/mM-{}".format(args.m_dir, param_stamp)): + args.train = False + print(" ...testing: {}".format(param_stamp)) + main_task_free.run(args) + else: + args.train = True + print(" ...running: {}".format(param_stamp)) + main_task_free.run(args) + # -get average accuracy + fileName = '{}/acc-{}{}.txt'.format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + file = open(fileName) + ave = float(file.readline()) + file.close() + # -print average accuracy on screen + print("--> average accuracy: {}".format(ave)) + # -return average accuracy + return ave + +def collect_all(method_dict, seed_list, args, name=None): + # -print name of method on screen + if name is not None: + print("\n------{}------".format(name)) + # -run method for all random seeds + for seed in seed_list: + args.seed = seed + method_dict[seed] = get_results(args) + # -return updated dictionary with results + return method_dict + + + +if __name__ == '__main__': + + ## Load input-arguments + args = handle_inputs() + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- RUN ALL MODELS -----# + #--------------------------# + + seed_list = list(range(args.seed, args.seed+args.n_seeds)) + + + ###----"BASELINES"----### + + ## None + args.replay = "none" + NONE = {} + NONE = collect_all(NONE, seed_list, args, name="None") + + ## JOINT training (using a random stream, rather than what was selected) + stream_temp = args.stream + args.stream = 'random' + JOINT = {} + JOINT = collect_all(JOINT, seed_list, args, name="Joint") + args.stream = stream_temp + + + ###----"CONTEXT-SPECIFIC"----#### + + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + ## Separate network per context + fc_units_temp = args.fc_units + args.fc_units = args.fc_units_sep + args.separate_networks = True + SEP = {} + SEP = collect_all(SEP, seed_list, args, name="Separate Networks") + args.separate_networks = False + args.fc_units = fc_units_temp + + ## XdG + always_xdg = checkattr(args, 'xdg') + args.xdg = True + XDG = {} + XDG = collect_all(XDG, seed_list, args, name="XdG") + args.xdg = always_xdg + + + ###----"PARAMETER REGULARIZATION"----#### + + if not checkattr(args, 'no_si'): + ## SI + args.weight_penalty = True + args.importance_weighting = 'si' + args.reg_strength = args.si_c + SI = {} + SI = collect_all(SI, seed_list, args, name="SI") + args.weight_penalty = False + else: + SI = None + + + ###----"FUNCTIONAL REGULARIZATION"----#### + + ## LwF + args.replay = "current" + args.distill = True + LWF = {} + LWF = collect_all(LWF, seed_list, args, name="LwF") + args.replay = "none" + args.distill = False + + + ###----"REPLAY"----### + if hasattr(args, 'replay_update') and args.replay_update is not None: + args.update_every = args.replay_update + + ## Experience Replay + args.replay = "buffer" + ER = {} + ER = collect_all(ER, seed_list, args, name="Experience Replay (budget = {})".format(args.budget)) + args.replay = "none" + + ## A-GEM + if not checkattr(args, 'no_agem'): + args.replay = "buffer" + args.use_replay = "inequality" + AGEM = {} + AGEM = collect_all(AGEM, seed_list, args, name="A-GEM (budget = {})".format(args.budget)) + args.replay = "none" + args.use_replay = "normal" + else: + AGEM = None + + + ###----"TEMPLATE-BASED CLASSIFICATION"----#### + + if args.scenario=="class": + ## iCaRL + args.bce = True + args.prototypes = True + args.replay = "buffer" + ICARL = {} + ICARL = collect_all(ICARL, seed_list, args, name="iCaRL (budget = {})".format(args.budget)) + args.bce = False + args.prototypes = False + args.replay = "none" + + ## Generative Classifier + args.gen_classifier = True + args.fc_units = args.fc_units_gc + args.fc_lay = args.fc_lay_gc + args.z_dim = args.z_dim_gc + args.hidden = True + args.lr = 0.001 + GENCLASS = {} + GENCLASS = collect_all(GENCLASS, seed_list, args, name="Generative Classifier") + + + #-------------------------------------------------------------------------------------------------# + + #---------------------------------------------# + #----- COLLECT RESULTS: AVERAGE ACCURACY -----# + #---------------------------------------------# + + ## For each seed, create list with average test accuracy + ave_acc = {} + for seed in seed_list: + ave_acc[seed] = [NONE[seed], JOINT[seed], + 0 if SI is None else SI[seed], LWF[seed], + ER[seed], 0 if AGEM is None else AGEM[seed]] + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + ave_acc[seed].append(XDG[seed]) + ave_acc[seed].append(SEP[seed]) + elif args.scenario=="class": + ave_acc[seed].append(ICARL[seed]) + ave_acc[seed].append(GENCLASS[seed]) + + + #-------------------------------------------------------------------------------------------------# + + #--------------------------------------------------# + #----- REPORTING / PLOTTING: AVERAGE ACCURACY -----# + #--------------------------------------------------# + + # name for plot + plot_name = "summary-{}{}-{}".format(args.experiment, args.contexts, args.scenario) + scheme = "{}-incremental learning".format(args.scenario) + title = "{} - {}".format(args.experiment, scheme) + + # select names / colors / ids + names = ["None", "Joint"] + colors = ["grey", "black"] + ids = [0, 1] + if args.scenario=="task" and not checkattr(args, 'no_context_spec'): + names += ['Separate Networks', 'XdG'] + colors += ['dodgerblue', 'deepskyblue'] + ids += [7, 6] + if not checkattr(args, 'no_si'): + names += ['SI'] + colors += ['yellowgreen'] + ids += [2] + names.append('LwF') + colors.append('gold') + ids.append(3) + names.append("ER (b={})".format(args.budget)) + colors.append('red') + ids.append(4) + if not checkattr(args, 'no_agem'): + names.append("A-GEM (b={})".format(args.budget)) + colors.append('orangered') + ids.append(5) + if args.scenario=="class": + names += ['Generative Classifier', "iCaRL (b={})".format(args.budget)] + colors += ['indigo', 'purple'] + ids += [7, 6] + + # open pdf + pp = visual_plt.open_pdf("{}/{}.pdf".format(args.p_dir, plot_name)) + figure_list = [] + + # bar-plot + means = [np.mean([ave_acc[seed][id] for seed in seed_list]) for id in ids] + if len(seed_list)>1: + sems = [np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + cis = [1.96*np.sqrt(np.var([ave_acc[seed][id] for seed in seed_list])/(len(seed_list)-1)) for id in ids] + figure = visual_plt.plot_bar(means, names=names, colors=colors, ylabel="average accuracy (after all contexts)", + title=title, yerr=cis if len(seed_list)>1 else None, ylim=(0,1)) + figure_list.append(figure) + + # print results to screen + print("\n\n"+"#"*60+"\nSUMMARY RESULTS: {}\n".format(title)+"#"*60) + for i,name in enumerate(names): + if len(seed_list) > 1: + print("{:27s} {:.2f} (+/- {:.2f}), n={}".format(name, 100*means[i], 100*sems[i], len(seed_list))) + else: + print("{:27s} {:.2f}".format(name, 100*means[i])) + if i==1: + print("="*60) + print("#"*60) + + # add all figures to pdf + for figure in figure_list: + pp.savefig(figure) + + # close the pdf + pp.close() + + # Print name of generated plot on screen + print("\nGenerated plot: {}/{}.pdf\n".format(args.p_dir, plot_name)) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/cover.txt b/PyTorch/build-in/other/continual-learning/cover.txt new file mode 100644 index 000000000..a8e2f23f4 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/cover.txt @@ -0,0 +1,5 @@ +all api: ['_copy_from_and_resize', '_has_compatible_shallow_copy_type', '_index_put_impl_', '_local_scalar_dense', '_log_softmax', '_log_softmax_backward_data', '_pin_memory', 'add', 'add_', 'amax', 'argmax', 'as_strided', 'clone', 'copy_', 'empty', 'empty_strided', 'eq', 'fill_', 'fused_adam', 'index', 'is_pinned', 'matmul', 'max', 'mm', 'mul', 'neg', 'nll_loss_backward', 'nll_loss_forward', 'relu', 'resize_', 'slice_backward', 'sub', 'sum', 'threshold_backward', 'uniform_', 'view', 'zero_'], total: 37 + +fallback op: ['_index_put_impl_'], total: 1 + +coverage rate: 97.30% diff --git a/PyTorch/build-in/other/continual-learning/coverage.py b/PyTorch/build-in/other/continual-learning/coverage.py new file mode 100644 index 000000000..264e48bcd --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/coverage.py @@ -0,0 +1,28 @@ +import argparse +import re + +def get_api_info(path): + pattern_api = '(?<=sdaa::)\s*\w+' + pattern_fallback = '(?<=default::)\s*\w+' + all_api_set = set() + fallback_api_set = set() + with open(path, 'r', encoding='utf-8') as f: + lines = f.readlines() + for line in lines: + if 'sdaa::' in line: + api = re.search(pattern_api, line).group() + all_api_set.add(api) + if 'default::' in line: + api = re.search(pattern_fallback, line).group() + fallback_api_set.add(api) + return sorted(list(all_api_set)), sorted(list(fallback_api_set)) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='suanzifugailvtongji') + parser.add_argument('--path', type=str, help='rezhilujing', required=True) + args = parser.parse_args() + all_api_set, fallback_api_set = get_api_info(args.path) + print(f"all api: {all_api_set}, total: {len(all_api_set)}\n") + print(f"fallback op: {fallback_api_set}, total: {len(fallback_api_set)}\n") + print(f"coverage rate: {(1 - len(fallback_api_set) / len(all_api_set)) * 100:.2f}%") \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/data/__init__.py b/PyTorch/build-in/other/continual-learning/data/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/data/available.py b/PyTorch/build-in/other/continual-learning/data/available.py new file mode 100644 index 000000000..8bc047a9d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/data/available.py @@ -0,0 +1,53 @@ +from torchvision import datasets, transforms +from data.manipulate import UnNormalize + + +# specify available data-sets. +AVAILABLE_DATASETS = { + 'MNIST': datasets.MNIST, + 'CIFAR100': datasets.CIFAR100, + 'CIFAR10': datasets.CIFAR10, +} + +# specify available transforms. +AVAILABLE_TRANSFORMS = { + 'MNIST': [ + transforms.ToTensor(), + ], + 'MNIST32': [ + transforms.Pad(2), + transforms.ToTensor(), + ], + 'CIFAR10': [ + transforms.ToTensor(), + ], + 'CIFAR100': [ + transforms.ToTensor(), + ], + 'CIFAR10_norm': [ + transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2470, 0.2435, 0.2616]) + ], + 'CIFAR100_norm': [ + transforms.Normalize(mean=[0.5071, 0.4865, 0.4409], std=[0.2673, 0.2564, 0.2761]) + ], + 'CIFAR10_denorm': UnNormalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2470, 0.2435, 0.2616]), + 'CIFAR100_denorm': UnNormalize(mean=[0.5071, 0.4865, 0.4409], std=[0.2673, 0.2564, 0.2761]), + 'augment_from_tensor': [ + transforms.ToPILImage(), + transforms.RandomCrop(32, padding=4, padding_mode='symmetric'), + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + ], + 'augment': [ + transforms.RandomCrop(32, padding=4, padding_mode='symmetric'), + transforms.RandomHorizontalFlip(), + ], +} + +# specify configurations of available data-sets. +DATASET_CONFIGS = { + 'MNIST': {'size': 28, 'channels': 1, 'classes': 10}, + 'MNIST32': {'size': 32, 'channels': 1, 'classes': 10}, + 'CIFAR10': {'size': 32, 'channels': 3, 'classes': 10}, + 'CIFAR100': {'size': 32, 'channels': 3, 'classes': 100}, +} diff --git a/PyTorch/build-in/other/continual-learning/data/datastream.py b/PyTorch/build-in/other/continual-learning/data/datastream.py new file mode 100644 index 000000000..1566652a9 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/data/datastream.py @@ -0,0 +1,73 @@ +import itertools +import torch +from torch.utils.data import DataLoader + + +def repeater(data_loader): + '''Function to enable looping through a data-loader indefinetely.''' + for loader in itertools.repeat(data_loader): + for data in loader: + yield data + + +class DataStream: + '''Iterator for setting up data-stream, with context for each observation or iteration given by `label_stream`.''' + + def __init__(self, datasets, label_stream, batch_size=1, per_batch=False, shuffle=True, return_context=False): + '''Instantiate the DataStream-object. + Args: + datasets (list): list of Datasets, each on representing a context + label_stream (LabelStream): iterator dictating from which context (task, domain or class) to sample + batch_size (int, optional): # of samples per mini-batch (default: ``1``) + per_batch (bool, optional): if ``True``, each label from `label_stream` specifies entire mini-batch; + if ``False``, there is separate context-label for each sample in a mini-batch (default: ``False``) + shuffle (bool, optional): whether the DataLoader should shuffle the Datasets (default: ``True``) + return_context (bool, optional): whether identity of the context should be returned (default: ``False``) + ''' + + self.datasets = datasets + self.label_stream = label_stream + self.n_contexts = label_stream.n_contexts + self.batch_size = batch_size + self.per_batch = per_batch + self.return_context = return_context + + # To keep track of the actual label-sequence being used + self.sequence = [] + + # Create separate data-loader for each context (using 'repeater' to enable looping through them indefinitely) + self.dataloaders = [] + for context_label in range(self.n_contexts): + self.dataloaders.append(repeater( + DataLoader(datasets[context_label], batch_size=batch_size if per_batch else 1, shuffle=shuffle, + drop_last=True) + )) + + def __iter__(self): + return self + + def __next__(self): + '''Function to return the next batch (x,y,c).''' + if self.per_batch or self.batch_size == 1: + # All samples in the mini-batch come from same context. + context_label = next(self.label_stream) + self.sequence.append(context_label) + (x, y) = next(self.dataloaders[context_label]) + c = torch.tensor([context_label]*self.batch_size) if self.return_context else None + else: + # Multiple samples per mini-batch that might come from different contexts. + x = [] + y = [] + c = [] if self.return_context else None + for _ in range(self.batch_size): + context_label = next(self.label_stream) + self.sequence.append(context_label) + (xi, yi) = next(self.dataloaders[context_label]) + x.append(xi) + y.append(yi) + if self.return_context: + c.append(context_label) + x = torch.cat(x) + y = torch.cat(y) + c = torch.tensor(c) if self.return_context else None + return (x, y, c) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/data/labelstream.py b/PyTorch/build-in/other/continual-learning/data/labelstream.py new file mode 100644 index 000000000..7de5bb99f --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/data/labelstream.py @@ -0,0 +1,122 @@ +import random +import torch + + +class LabelStream: + '''Base class for iterators that determine from which context should be sampled.''' + + def __init__(self): + self.n_contexts = None + + def __iter__(self): + return self + + def __next__(self): + raise NotImplementedError # returns 'context_id' (i.e., starting from context 0); type=int + + +class SharpBoundaryStream(LabelStream): + '''Set up a label-stream with strictly separated contexts (as in the academic continual learning setting).''' + + def __init__(self, n_contexts, iters_per_context): + '''Instantiate the dissociated-stream object by defining its parameters. + Args: + n_contexts (int): number of contexts + iters_per_context (int): number of iterations to generate per context + ''' + + super().__init__() + self.n_contexts = n_contexts + self.iters_per_context = iters_per_context + + # For keeping track of context + self.iters_count = 0 + self.context = 0 + + def __next__(self): + self.iters_count += 1 + # -move to next context when all iterations of current context are done + if self.iters_count > self.iters_per_context: + self.iters_count = 1 + self.context += 1 + if self.context >= self.n_contexts: + raise StopIteration + next_label = self.context + return next_label + + +class RandomStream(LabelStream): + '''Set up a completely random label-stream.''' + + def __init__(self, n_contexts): + super().__init__() + self.n_contexts = n_contexts + + def __next__(self): + return random.randint(0, self.n_contexts-1) + + +def _linear_line(number, direction="up"): + if direction == "up": + return torch.FloatTensor([(i+0.5) / number for i in range(number)]) + return torch.FloatTensor([1 - ((i+0.5) / number) for i in range(number)]) + +def _probs_per_context(n_contexts, iters_per_context, context_id, fuzziness=3): + if (2 * fuzziness) > iters_per_context: + raise ValueError("Fuzziness must be smaller than half the number of iterations per context.") + + # Start with zero probability for every iteration + probs = torch.zeros(n_contexts * iters_per_context) + + # Depending on which context, add non-zero probabilities + if context_id == 0: + # -first period of seeing context 0 + end = int(iters_per_context / 2) + probs[0:(end - fuzziness)].add_(1) + probs[(end - fuzziness):(end + fuzziness)] = _linear_line(2 * fuzziness, direction="down") + # -second period of seeing context 0 + start = int(iters_per_context / 2) + (n_contexts - 1) * iters_per_context + probs[(start - fuzziness):(start + fuzziness)] = _linear_line(2 * fuzziness, direction="up") + probs[(start + fuzziness):(iters_per_context * n_contexts)].add_(1) + else: + start = int(iters_per_context / 2) + (context_id - 1) * iters_per_context + end = int(iters_per_context / 2) + context_id * iters_per_context + probs[(start - fuzziness):(start + fuzziness)] = _linear_line(2 * fuzziness, direction="up") + probs[(start + fuzziness):(end - fuzziness)].add_(1) + probs[(end - fuzziness):(end + fuzziness)] = _linear_line(2 * fuzziness, direction="down") + + return probs + +class FuzzyBoundaryStream(LabelStream): + '''Set up a label-stream for an experiment with fuzzy context boundaries.''' + + def __init__(self, n_contexts, iters_per_context, fuzziness, batch_size=1): + super().__init__() + self.n_contexts = n_contexts + self.batch_size = batch_size + self.total_iters = iters_per_context*n_contexts + self.batch_count = 0 + self.iters_count = 0 + + # For each context, get a tensor with its probability per iteration + context_probs_per_iter = [_probs_per_context( + n_contexts, iters_per_context, context_id, fuzziness=fuzziness + ) for context_id in range(n_contexts)] + + # For each iteration, specify a probability-distribution over the contexts + self.context_probs = [] + context_probs_tensor = torch.cat(context_probs_per_iter).view(n_contexts, iters_per_context*n_contexts) + for iter_id in range(iters_per_context*n_contexts): + self.context_probs.append(context_probs_tensor[:, iter_id]) + + def __next__(self): + self.batch_count += 1 + # -move to next iteration when all mini-batch samples of current iteration are done + if self.batch_count > self.batch_size: + self.batch_count = 1 + self.iters_count += 1 + if self.iters_count >= self.total_iters: + raise StopIteration + # -sample a context label using the probability-distribution of current iteration + context_label = random.choices(range(self.n_contexts), self.context_probs[self.iters_count])[0] + return context_label diff --git a/PyTorch/build-in/other/continual-learning/data/load.py b/PyTorch/build-in/other/continual-learning/data/load.py new file mode 100644 index 000000000..a21da5e4a --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/data/load.py @@ -0,0 +1,155 @@ +import copy +import numpy as np +from torchvision import transforms +from torch.utils.data import ConcatDataset +from data.manipulate import permutate_image_pixels, SubDataset, TransformedDataset +from data.available import AVAILABLE_DATASETS, AVAILABLE_TRANSFORMS, DATASET_CONFIGS + + +def get_dataset(name, type='train', download=True, capacity=None, permutation=None, dir='./store/datasets', + verbose=False, augment=False, normalize=False, target_transform=None): + '''Create [train|valid|test]-dataset.''' + + data_name = 'MNIST' if name in ('MNIST28', 'MNIST32') else name + dataset_class = AVAILABLE_DATASETS[data_name] + + # specify image-transformations to be applied + transforms_list = [*AVAILABLE_TRANSFORMS['augment']] if augment else [] + transforms_list += [*AVAILABLE_TRANSFORMS[name]] + if normalize: + transforms_list += [*AVAILABLE_TRANSFORMS[name+"_norm"]] + if permutation is not None: + transforms_list.append(transforms.Lambda(lambda x, p=permutation: permutate_image_pixels(x, p))) + dataset_transform = transforms.Compose(transforms_list) + + # load data-set + dataset = dataset_class('{dir}/{name}'.format(dir=dir, name=data_name), train=False if type=='test' else True, + download=download, transform=dataset_transform, target_transform=target_transform) + + # print information about dataset on the screen + if verbose: + print(" --> {}: '{}'-dataset consisting of {} samples".format(name, type, len(dataset))) + + # if dataset is (possibly) not large enough, create copies until it is. + if capacity is not None and len(dataset) < capacity: + dataset = ConcatDataset([copy.deepcopy(dataset) for _ in range(int(np.ceil(capacity / len(dataset))))]) + + return dataset + +#----------------------------------------------------------------------------------------------------------# + +def get_singlecontext_datasets(name, data_dir="./store/datasets", normalize=False, augment=False, verbose=False): + '''Load, organize and return train- and test-dataset for requested single-context experiment.''' + + # Get config-dict and data-sets + config = DATASET_CONFIGS[name] + config['output_units'] = config['classes'] + config['normalize'] = normalize + if normalize: + config['denormalize'] = AVAILABLE_TRANSFORMS[name+"_denorm"] + trainset = get_dataset(name, type='train', dir=data_dir, verbose=verbose, normalize=normalize, augment=augment) + testset = get_dataset(name, type='test', dir=data_dir, verbose=verbose, normalize=normalize) + + # Return tuple of data-sets and config-dictionary + return (trainset, testset), config + +#----------------------------------------------------------------------------------------------------------# + +def get_context_set(name, scenario, contexts, data_dir="./datasets", only_config=False, verbose=False, + exception=False, normalize=False, augment=False, singlehead=False, train_set_per_class=False): + '''Load, organize and return a context set (both train- and test-data) for the requested experiment. + + [exception]: ; if True, for visualization no permutation is applied to first context (permMNIST) or digits + are not shuffled before being distributed over the contexts (e.g., splitMNIST, CIFAR100)''' + + ## NOTE: options 'normalize' and 'augment' only implemented for CIFAR-based experiments. + + # Define data-type + if name == "splitMNIST": + data_type = 'MNIST' + elif name == "permMNIST": + data_type = 'MNIST32' + if train_set_per_class: + raise NotImplementedError('Permuted MNIST currently has no support for separate training dataset per class') + elif name == "CIFAR10": + data_type = 'CIFAR10' + elif name == "CIFAR100": + data_type = 'CIFAR100' + else: + raise ValueError('Given undefined experiment: {}'.format(name)) + + # Get config-dict + config = DATASET_CONFIGS[data_type].copy() + config['normalize'] = normalize if name=='CIFAR100' else False + if config['normalize']: + config['denormalize'] = AVAILABLE_TRANSFORMS["CIFAR100_denorm"] + # check for number of contexts + if contexts > config['classes'] and not name=="permMNIST": + raise ValueError("Experiment '{}' cannot have more than {} contexts!".format(name, config['classes'])) + # -how many classes per context? + classes_per_context = 10 if name=="permMNIST" else int(np.floor(config['classes'] / contexts)) + config['classes_per_context'] = classes_per_context + config['output_units'] = classes_per_context if (scenario=='domain' or + (scenario=="task" and singlehead)) else classes_per_context*contexts + # -if only config-dict is needed, return it + if only_config: + return config + + # Depending on experiment, get and organize the datasets + if name == 'permMNIST': + # get train and test datasets + trainset = get_dataset(data_type, type="train", dir=data_dir, target_transform=None, verbose=verbose) + testset = get_dataset(data_type, type="test", dir=data_dir, target_transform=None, verbose=verbose) + # generate pixel-permutations + if exception: + permutations = [None] + [np.random.permutation(config['size']**2) for _ in range(contexts-1)] + else: + permutations = [np.random.permutation(config['size']**2) for _ in range(contexts)] + # specify transformed datasets per context + train_datasets = [] + test_datasets = [] + for context_id, perm in enumerate(permutations): + target_transform = transforms.Lambda( + lambda y, x=context_id: y + x*classes_per_context + ) if scenario in ('task', 'class') and not (scenario=='task' and singlehead) else None + train_datasets.append(TransformedDataset( + trainset, transform=transforms.Lambda(lambda x, p=perm: permutate_image_pixels(x, p)), + target_transform=target_transform + )) + test_datasets.append(TransformedDataset( + testset, transform=transforms.Lambda(lambda x, p=perm: permutate_image_pixels(x, p)), + target_transform=target_transform + )) + else: + # prepare permutation to shuffle label-ids (to create different class batches for each random seed) + classes = config['classes'] + perm_class_list = np.array(list(range(classes))) if exception else np.random.permutation(list(range(classes))) + target_transform = transforms.Lambda(lambda y, p=perm_class_list: int(p[y])) + # prepare train and test datasets with all classes + trainset = get_dataset(data_type, type="train", dir=data_dir, target_transform=target_transform, + verbose=verbose, augment=augment, normalize=normalize) + testset = get_dataset(data_type, type="test", dir=data_dir, target_transform=target_transform, verbose=verbose, + augment=augment, normalize=normalize) + # generate labels-per-dataset (if requested, training data is split up per class rather than per context) + labels_per_dataset_train = [[label] for label in range(classes)] if train_set_per_class else [ + list(np.array(range(classes_per_context))+classes_per_context*context_id) for context_id in range(contexts) + ] + labels_per_dataset_test = [ + list(np.array(range(classes_per_context))+classes_per_context*context_id) for context_id in range(contexts) + ] + # split the train and test datasets up into sub-datasets + train_datasets = [] + for labels in labels_per_dataset_train: + target_transform = transforms.Lambda(lambda y, x=labels[0]: y-x) if ( + scenario=='domain' or (scenario=='task' and singlehead) + ) else None + train_datasets.append(SubDataset(trainset, labels, target_transform=target_transform)) + test_datasets = [] + for labels in labels_per_dataset_test: + target_transform = transforms.Lambda(lambda y, x=labels[0]: y-x) if ( + scenario=='domain' or (scenario=='task' and singlehead) + ) else None + test_datasets.append(SubDataset(testset, labels, target_transform=target_transform)) + + # Return tuple of train- and test-dataset, config-dictionary and number of classes per context + return ((train_datasets, test_datasets), config) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/data/manipulate.py b/PyTorch/build-in/other/continual-learning/data/manipulate.py new file mode 100644 index 000000000..13c4d356b --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/data/manipulate.py @@ -0,0 +1,119 @@ +import torch +from torch.utils.data import Dataset + + +def permutate_image_pixels(image, permutation): + '''Permutate the pixels of an image according to [permutation]. + + [image] 3D-tensor containing the image + [permutation] of pixel-indeces in their new order''' + + if permutation is None: + return image + else: + c, h, w = image.size() + image = image.view(c, -1) + image = image[:, permutation] #--> same permutation for each channel + image = image.view(c, h, w) + return image + +#----------------------------------------------------------------------------------------------------------# + +class SubDataset(Dataset): + '''To sub-sample a dataset, taking only those samples with label in [sub_labels]. + + After this selection of samples has been made, it is possible to transform the target-labels, + which can be useful when doing continual learning with fixed number of output units.''' + + def __init__(self, original_dataset, sub_labels, target_transform=None): + super().__init__() + self.dataset = original_dataset + self.sub_indeces = [] + for index in range(len(self.dataset)): + if hasattr(original_dataset, "targets"): + if self.dataset.target_transform is None: + label = self.dataset.targets[index] + else: + label = self.dataset.target_transform(self.dataset.targets[index]) + else: + label = self.dataset[index][1] + if label in sub_labels: + self.sub_indeces.append(index) + self.target_transform = target_transform + + def __len__(self): + return len(self.sub_indeces) + + def __getitem__(self, index): + sample = self.dataset[self.sub_indeces[index]] + if self.target_transform: + target = self.target_transform(sample[1]) + sample = (sample[0], target) + return sample + + +class MemorySetDataset(Dataset): + '''Create dataset from list of with shape (N, C, H, W) (i.e., with N images each). + + The images at the i-th entry of [memory_sets] belong to class [i], unless a [target_transform] is specified''' + + def __init__(self, memory_sets, target_transform=None): + super().__init__() + self.memory_sets = memory_sets + self.target_transform = target_transform + + def __len__(self): + total = 0 + for class_id in range(len(self.memory_sets)): + total += len(self.memory_sets[class_id]) + return total + + def __getitem__(self, index): + total = 0 + for class_id in range(len(self.memory_sets)): + examples_in_this_class = len(self.memory_sets[class_id]) + if index < (total + examples_in_this_class): + class_id_to_return = class_id if self.target_transform is None else self.target_transform(class_id) + example_id = index - total + break + else: + total += examples_in_this_class + image = torch.from_numpy(self.memory_sets[class_id][example_id]) + return (image, class_id_to_return) + + +class TransformedDataset(Dataset): + '''To modify an existing dataset with a transform. + This is useful for creating different permutations of MNIST without loading the data multiple times.''' + + def __init__(self, original_dataset, transform=None, target_transform=None): + super().__init__() + self.dataset = original_dataset + self.transform = transform + self.target_transform = target_transform + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, index): + (input, target) = self.dataset[index] + if self.transform: + input = self.transform(input) + if self.target_transform: + target = self.target_transform(target) + return (input, target) + +# ----------------------------------------------------------------------------------------------------------# + +class UnNormalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, tensor): + """Denormalize image, either single image (C,H,W) or image batch (N,C,H,W)""" + batch = (len(tensor.size()) == 4) + for t, m, s in zip(tensor.permute(1, 0, 2, 3) if batch else tensor, self.mean, self.std): + t.mul_(s).add_(m) + # The normalize code -> t.sub_(m).div_(s) + return tensor diff --git a/PyTorch/build-in/other/continual-learning/eval/__init__.py b/PyTorch/build-in/other/continual-learning/eval/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/eval/callbacks.py b/PyTorch/build-in/other/continual-learning/eval/callbacks.py new file mode 100644 index 000000000..16e8b5f80 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/eval/callbacks.py @@ -0,0 +1,198 @@ +from eval import evaluate + + +######################################################### +## Callback-functions for evaluating model-performance ## +######################################################### + +def _sample_cb(log, config, visdom=None, test_datasets=None, sample_size=64): + '''Initiates function for evaluating samples of generative model. + + [test_datasets] None or of (if provided, also reconstructions are shown)''' + + def sample_cb(generator, batch, context=1, class_id=None, **kwargs): + '''Callback-function, to evaluate sample (and reconstruction) ability of the model.''' + + if batch % log == 0: + + # Evaluate reconstruction-ability of model on [test_dataset] + if test_datasets is not None: + # Reconstruct samples from current context + evaluate.show_reconstruction(generator, test_datasets[context-1], config, size=int(sample_size/2), + visdom=visdom, context=context) + + # Generate samples + evaluate.show_samples( + generator, config, visdom=visdom, size=sample_size, + visdom_title='Samples{}'.format(" VAE-{}".format(class_id) if class_id is not None else "") + ) + + # Return the callback-function (except if visdom is not selected!) + return sample_cb if (visdom is not None) else None + + +def _eval_cb(log, test_datasets, visdom=None, plotting_dict=None, iters_per_context=None, test_size=None, + summary_graph=True, S='mean'): + '''Initiates function for evaluating performance of classifier (in terms of accuracy). + + [test_datasets] of ; also if only 1 context, it should be presented as a list! + ''' + + def eval_cb(classifier, batch, context=1): + '''Callback-function, to evaluate performance of classifier.''' + + iteration = batch if (context is None or context==1) else (context-1)*iters_per_context + batch + + # Evaluate the classifier every [log] iterations + if iteration % log == 0: + + # If needed, set the requested way of doing inference as attributes of the classifier + if (S is not None) and hasattr(classifier, 'S'): + classifier.S = S + + # Evaluate the classifier on multiple contexts (and log to visdom) + evaluate.test_all_so_far(classifier, test_datasets, context, iteration, test_size=test_size, + visdom=visdom, summary_graph=summary_graph, plotting_dict=plotting_dict) + + ## Return the callback-function (except if visdom is not selected!) + return eval_cb if (visdom is not None) or (plotting_dict is not None) else None + + +##------------------------------------------------------------------------------------------------------------------## + +######################################################################## +## Callback-functions for keeping track of loss and training progress ## +######################################################################## + +def _classifier_loss_cb(log=1, visdom=None, model=None, contexts=None, iters_per_context=None, progress_bar=True): + '''Initiates function for keeping track of, and reporting on, the progress of the classifier's training.''' + + def cb(bar, iter, loss_dict, context=1): + '''Callback-function, to call on every iteration to keep track of training progress.''' + + if visdom is not None: + from visual import visual_visdom + + iteration = iter if context==1 else (context-1)*iters_per_context + iter + + # progress-bar + if progress_bar and bar is not None: + context_stm = "" if (contexts is None) else " Context: {}/{} |".format(context, contexts) + bar.set_description( + ' |{t_stm} training loss: {loss:.3} | training accuracy: {prec:.3} |' + .format(t_stm=context_stm, loss=loss_dict['loss_total'], prec=loss_dict['accuracy']) + ) + bar.update(1) + + # log the loss of the solver (to visdom) + if (visdom is not None) and (iteration % log == 0): + if contexts is None or contexts==1: + plot_data = [loss_dict['pred']] + names = ['prediction'] + else: + plot_data = [loss_dict['pred']] + names = ['current'] + if hasattr(model, 'replay') and not model.replay=='none': + if model.replay_targets == "hard": + plot_data += [loss_dict['pred_r']] + names += ['replay'] + elif model.replay_targets == "soft": + plot_data += [loss_dict['distil_r']] + names += ['distill'] + if hasattr(model, 'reg_strength') and model.reg_strength>0: + plot_data += [loss_dict['param_reg']] + names += ['param reg'] + visual_visdom.visualize_scalars( + scalars=plot_data, names=names, iteration=iteration, + title="CLASSIFIER: loss ({})".format(visdom["graph"]), env=visdom["env"], ylabel="training loss" + ) + + # Return the callback-function. + return cb + + +def _VAE_loss_cb(log=1, visdom=None, model=None, contexts=None, iters_per_context=None, replay=False, + progress_bar=True): + '''Initiates functions for keeping track of, and reporting on, the progress of the generator's training.''' + + if visdom is not None: + from visual import visual_visdom + + def cb(bar, iter, loss_dict, context=1): + '''Callback-function, to perform on every iteration to keep track of training progress.''' + + iteration = iter if context==1 else (context-1)*iters_per_context + iter + + # progress-bar + if progress_bar and bar is not None: + context_stm = "" if (contexts is None) else " Context: {}/{} |".format(context, contexts) + bar.set_description(' |{t_stm} training loss: {loss:.3} |{acc}'.format( + t_stm=context_stm, loss=loss_dict['loss_total'], acc=' training accuracy: {:.3} |'.format( + loss_dict['accuracy'] + ) if model.label=='CondVAE' and model.lamda_pl>0 else '' + )) + bar.update(1) + + # log the loss of the solver (to visdom) + if (visdom is not None) and (iteration % log == 0): + if contexts is None or contexts==1: + plot_data = [loss_dict['recon'], loss_dict['variat']] + names = ['Recon', 'Variat'] + if model.lamda_pl > 0: + plot_data += [loss_dict['pred']] + names += ['Prediction'] + else: + plot_data = [loss_dict['recon'], loss_dict['variat']] + names = ['Recon', 'Variat'] + if model.label=='CondVAE' and model.lamda_pl > 0: + plot_data += [loss_dict['pred']] + names += ['Prediction'] + if replay: + plot_data += [loss_dict['recon_r'], loss_dict['variat_r']] + names += ['Recon - r', 'Variat - r'] + if model.label=='CondVAE' and model.lamda_pl>0: + if model.replay_targets=="hard": + plot_data += [loss_dict['pred_r']] + names += ['Pred - r'] + elif model.replay_targets=="soft": + plot_data += [loss_dict['distil_r']] + names += ['Distill - r'] + visual_visdom.visualize_scalars( + scalars=plot_data, names=names, iteration=iteration, + title="VAE: loss ({})".format(visdom["graph"]), env=visdom["env"], ylabel="training loss" + ) + + # Return the callback-function + return cb + + +def _gen_classifier_loss_cb(log=1, classes=None, visdom=None, progress_bar=True): + '''Initiates functions for keeping track of, and reporting on, the progress of the generator's training.''' + + if visdom is not None: + from visual import visual_visdom + + def cb(bar, iter, loss_dict, class_id=0): + '''Callback-function, to perform on every iteration to keep track of training progress.''' + + # progress-bar + if progress_bar and bar is not None: + class_stm = "" if (classes is None) else " Class: {}/{} |".format(class_id+1, classes) + model_stm = " " if (classes is None) else " " + bar.set_description('{m_stm}|{c_stm} training loss: {loss:.3} |' + .format(m_stm=model_stm, c_stm=class_stm, loss=loss_dict['loss_total'])) + bar.update(1) + + # plot training loss every [log] + if (visdom is not None) and (iter % log == 0): + plot_data = [loss_dict['recon'], loss_dict['variat']] + names = ['Recon loss', 'Variat loss'] + + visual_visdom.visualize_scalars( + scalars=plot_data, names=names, iteration=iter, + title="VAE{}: loss ({})".format("" if classes is None else "-{}".format(class_id), visdom["graph"]), + env=visdom["env"], ylabel="training loss" + ) + + # Return the callback-function + return cb \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/eval/evaluate.py b/PyTorch/build-in/other/continual-learning/eval/evaluate.py new file mode 100644 index 000000000..1f1d10832 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/eval/evaluate.py @@ -0,0 +1,222 @@ +import numpy as np +import torch +from visual import visual_plt +from visual import visual_visdom +from utils import get_data_loader,checkattr + + +####--------------------------------------------------------------------------------------------------------------#### + +####-----------------------------#### +####----CLASSIFIER EVALUATION----#### +####-----------------------------#### + +def test_acc(model, dataset, batch_size=128, test_size=1024, verbose=True, context_id=None, allowed_classes=None, + no_context_mask=False, **kwargs): + '''Evaluate accuracy (= proportion of samples classified correctly) of a classifier ([model]) on [dataset]. + + [allowed_classes] None or containing all "active classes" between which should be chosen + (these "active classes" are assumed to be contiguous)''' + + # Get device-type / using cuda? + device = model.device if hasattr(model, 'device') else model._device() + cuda = model.cuda if hasattr(model, 'cuda') else model._is_on_cuda() + + # Set model to eval()-mode + mode = model.training + model.eval() + + # Apply context-specifc "gating-mask" for each hidden fully connected layer (or remove it!) + if hasattr(model, "mask_dict") and model.mask_dict is not None: + if no_context_mask: + model.reset_XdGmask() + else: + model.apply_XdGmask(context=context_id+1) + + # Should output-labels be adjusted for allowed classes? (ASSUMPTION: [allowed_classes] has consecutive numbers) + label_correction = 0 if checkattr(model, 'stream_classifier') or (allowed_classes is None) else allowed_classes[0] + + # If there is a separate network per context, select the correct subnetwork + if model.label=="SeparateClassifiers": + model = getattr(model, 'context{}'.format(context_id+1)) + allowed_classes = None + + # Loop over batches in [dataset] + data_loader = get_data_loader(dataset, batch_size, cuda=cuda) + total_tested = total_correct = 0 + for x, y in data_loader: + # -break on [test_size] (if "None", full dataset is used) + if test_size: + if total_tested >= test_size: + break + # -if the model is a "stream-classifier", add context + if checkattr(model, 'stream_classifier'): + context_tensor = torch.tensor([context_id]*x.shape[0]).to(device) + # -evaluate model (if requested, only on [allowed_classes]) + with torch.no_grad(): + if checkattr(model, 'stream_classifier'): + scores = model.classify(x.to(device), context=context_tensor) + else: + scores = model.classify(x.to(device), allowed_classes=allowed_classes) + _, predicted = torch.max(scores.cpu(), 1) + if model.prototypes and max(predicted).item() >= model.classes: + # -in case of Domain-IL (or Task-IL + singlehead), collapse all corresponding domains to same class + predicted = predicted % model.classes + # -update statistics + y = y-label_correction + total_correct += (predicted == y).sum().item() + total_tested += len(x) + accuracy = total_correct / total_tested + + # Set model back to its initial mode, print result on screen (if requested) and return it + model.train(mode=mode) + if verbose: + print('=> accuracy: {:.3f}'.format(accuracy)) + return accuracy + + +def test_all_so_far(model, datasets, current_context, iteration, test_size=None, no_context_mask=False, + visdom=None, summary_graph=True, plotting_dict=None, verbose=False): + '''Evaluate accuracy of a classifier (=[model]) on all contexts so far (= up to [current_context]) using [datasets]. + + [visdom] None or with name of "graph" and "env" (if None, no visdom-plots are made)''' + + n_contexts = len(datasets) + + # Evaluate accuracy of model predictions + # - in the academic CL setting: for all contexts so far, reporting "0" for future contexts + # - in task-free stream setting (current_context==None): always for all contexts + precs = [] + for i in range(n_contexts): + if (current_context is None) or (i+1 <= current_context): + allowed_classes = None + if model.scenario=='task' and not checkattr(model, 'singlehead'): + allowed_classes = list(range(model.classes_per_context * i, model.classes_per_context * (i + 1))) + precs.append(test_acc(model, datasets[i], test_size=test_size, verbose=verbose, + allowed_classes=allowed_classes, no_context_mask=no_context_mask, context_id=i)) + else: + precs.append(0) + if current_context is None: + current_context = i+1 + average_precs = sum([precs[context_id] for context_id in range(current_context)]) / current_context + + # Print results on screen + if verbose: + print(' => ave accuracy: {:.3f}'.format(average_precs)) + + # Add results to [plotting_dict] + if plotting_dict is not None: + for i in range(n_contexts): + plotting_dict['acc per context']['context {}'.format(i+1)].append(precs[i]) + plotting_dict['average'].append(average_precs) + plotting_dict['x_iteration'].append(iteration) + plotting_dict['x_context'].append(current_context) + + # Send results to visdom server + names = ['context {}'.format(i + 1) for i in range(n_contexts)] + if visdom is not None: + visual_visdom.visualize_scalars( + precs, names=names, title="accuracy ({})".format(visdom["graph"]), + iteration=iteration, env=visdom["env"], ylabel="test accuracy" + ) + if n_contexts>1 and summary_graph: + visual_visdom.visualize_scalars( + [average_precs], names=["ave"], title="ave accuracy ({})".format(visdom["graph"]), + iteration=iteration, env=visdom["env"], ylabel="test accuracy" + ) + + +def initiate_plotting_dict(n_contexts): + '''Initiate with accuracy-measures to keep track of for plotting.''' + plotting_dict = {} + plotting_dict["acc per context"] = {} + for i in range(n_contexts): + plotting_dict["acc per context"]["context {}".format(i+1)] = [] + plotting_dict["average"] = [] # average accuracy over all contexts so far: Task-IL -> only classes in context + # Class-IL -> all classes so far + plotting_dict["x_iteration"] = [] # total number of iterations so far + plotting_dict["x_context"] = [] # number of contexts so far (i.e., context on which training just finished) + return plotting_dict + + +####--------------------------------------------------------------------------------------------------------------#### + +####-----------------------------#### +####----GENERATION EVALUATION----#### +####-----------------------------#### + +def show_samples(model, config, pdf=None, visdom=None, size=32, pdf_title="Generated images", visdom_title="Samples"): + '''Plot samples from a generative model in [pdf] and/or in [visdom].''' + + # Set model to evaluation-mode + mode = model.training + model.eval() + + # Generate samples from the model + sample = model.sample(size) + image_tensor = sample.view(-1, config['channels'], config['size'], config['size']).cpu() + # -denormalize images if needed + if config['normalize']: + image_tensor = config['denormalize'](image_tensor).clamp(min=0, max=1) + + # Plot generated images in [pdf] and/or [visdom] + # -number of rows + nrow = int(np.ceil(np.sqrt(size))) + # -make plots + if pdf is not None: + visual_plt.plot_images_from_tensor(image_tensor, pdf, title=pdf_title, nrow=nrow) + if visdom is not None: + visual_visdom.visualize_images( + tensor=image_tensor, title='{} ({})'.format(visdom_title, visdom["graph"]), env=visdom["env"], nrow=nrow, + ) + + # Set model back to initial mode + model.train(mode=mode) + + +####--------------------------------------------------------------------------------------------------------------#### + +####---------------------------------#### +####----RECONSTRUCTION EVALUATION----#### +####---------------------------------#### + +def show_reconstruction(model, dataset, config, pdf=None, visdom=None, size=32, context=None): + '''Plot reconstructed examples by an auto-encoder [model] on [dataset], in [pdf] and/or in [visdom].''' + + # Set model to evaluation-mode + mode = model.training + model.eval() + + # Get data + data_loader = get_data_loader(dataset, size, cuda=model._is_on_cuda()) + (data, labels) = next(iter(data_loader)) + data, labels = data.to(model._device()), labels.to(model._device()) + + # Evaluate model + with torch.no_grad(): + recon_batch = model(data, full=False) + + # Plot original and reconstructed images + comparison = torch.cat( + [data.view(-1, config['channels'], config['size'], config['size'])[:size], + recon_batch.view(-1, config['channels'], config['size'], config['size'])[:size]] + ).cpu() + image_tensor = comparison.view(-1, config['channels'], config['size'], config['size']) + # -denormalize images if needed + if config['normalize']: + image_tensor = config['denormalize'](image_tensor).clamp(min=0, max=1) + # -number of rows + nrow = int(np.ceil(np.sqrt(size*2))) + # -make plots + if pdf is not None: + context_stm = "" if context is None else " (context {})".format(context) + visual_plt.plot_images_from_tensor( + image_tensor, pdf, nrow=nrow, title="Reconstructions" + context_stm + ) + if visdom is not None: + visual_visdom.visualize_images( + tensor=image_tensor, title='Reconstructions ({})'.format(visdom["graph"]), env=visdom["env"], nrow=nrow, + ) + + # Set model back to initial mode + model.train(mode=mode) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/example_DGR.ipynb b/PyTorch/build-in/other/continual-learning/example_DGR.ipynb new file mode 100644 index 000000000..2988512fb --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/example_DGR.ipynb @@ -0,0 +1,628 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a00a09c9", + "metadata": {}, + "outputs": [], + "source": [ + "# Load required libraries\n", + "import torch\n", + "import tqdm\n", + "import copy\n", + "import numpy as np\n", + "# -custom-written libraries\n", + "import utils\n", + "from data.load import get_context_set\n", + "from models.classifier import Classifier\n", + "from models.vae import VAE\n", + "from eval import evaluate, callbacks as cb\n", + "from visual import visual_plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cb0539a1", + "metadata": {}, + "outputs": [], + "source": [ + "# Enable plotting in the notebook\n", + "%matplotlib inline " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "57e3b84a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA is used\n" + ] + } + ], + "source": [ + "# Is cuda available?\n", + "cuda = torch.cuda.is_available()\n", + "device = torch.device(\"cuda\" if cuda else \"cpu\")\n", + "print(\"CUDA is {}used\".format(\"\" if cuda else \"not \"))" + ] + }, + { + "cell_type": "markdown", + "id": "320f9e43", + "metadata": {}, + "source": [ + "## DATA: Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c6ead555", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify what kind of continual learning experiment we should run\n", + "experiment = \"splitMNIST\" #--> create context set by splitting up the MNIST dataset\n", + "contexts = 5 #--> split the dataset up into how many contexts?\n", + "iters = 1000 #--> number of iterations per context\n", + "batch = 128 #--> number of samples per iteration (i.e., the mini-batch size)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ee01ec88", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify according to which scenario the continual learning experiment should be performed?\n", + "scenario = \"class\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2746c66a", + "metadata": {}, + "outputs": [], + "source": [ + "# Where is, or should, the data be stored?\n", + "d_dir = './store/datasets'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d9b6f329", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " --> MNIST: 'train'-dataset consisting of 60000 samples\n", + " --> MNIST: 'test'-dataset consisting of 10000 samples\n" + ] + } + ], + "source": [ + "# Load the context set (both train- and test-data) for the specified continual learning experiment\n", + "(train_datasets, test_datasets), config = get_context_set(\n", + " name=experiment, scenario=scenario, contexts=contexts, data_dir=d_dir, verbose=True, exception=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "51fc95ea", + "metadata": {}, + "source": [ + "## CLASSIFIER: Specify the classifier network" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06a212fa", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify the architectural layout of the network to use\n", + "fc_lay = 3 #--> number of fully-connected layers\n", + "fc_units = 400 #--> number of units in each hidden layer\n", + "fc_bn = False #--> use batch-norm\n", + "fc_nl = \"relu\" #--> what non-linearity to use?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a9749091", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model\n", + "model = Classifier(\n", + " image_size=config['size'], image_channels=config['channels'], classes=config['output_units'],\n", + " # -conv-layers are not used\n", + " depth=0,\n", + " # -fc-layers\n", + " fc_layers=fc_lay, fc_units=fc_units, fc_bn=fc_bn, fc_nl=fc_nl, excit_buffer=True,\n", + ").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d6b15c63", + "metadata": {}, + "outputs": [], + "source": [ + "# Indicate to model what scenario it will be trained on and how many classes there are in each context\n", + "model.scenario = scenario\n", + "model.classes_per_context = config['classes_per_context']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6b08f0cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Indicate to the classifier model that it will be trained with generative replay\n", + "model.replay_mode = 'generative'\n", + "model.replay_targets = 'hard'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "749dc0cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------\n", + "Classifier(\n", + " (convE): ConvLayers(\n", + " (pooling): Identity()\n", + " )\n", + " (flatten): Flatten()\n", + " (fcE): MLP(\n", + " (fcLayer1): fc_layer(\n", + " (linear): LinearExcitability(in_features=784, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " (fcLayer2): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " )\n", + " (classifier): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=10)\n", + " )\n", + ")\n", + "-------------------------------------------------------\n", + "--> this network has 478410 parameters (~0.5 million)\n", + " of which: - learnable: 478410 (~0.5 million)\n", + " - fixed: 0 (~0.0 million)\n" + ] + } + ], + "source": [ + "# Print layout of the model to the screen\n", + "utils.print_model_info(model)" + ] + }, + { + "cell_type": "markdown", + "id": "10f44613", + "metadata": {}, + "source": [ + "## GENERATOR: Specify the generative model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "67d36f29", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify the architectural layout of the network to use\n", + "g_fc_lay = 3 #--> number of fully-connected layers\n", + "g_fc_units = 400 #--> number of units in each hidden layer\n", + "g_fc_bn = False #--> use batch-norm\n", + "g_fc_nl = \"relu\" #--> what non-linearity to use?\n", + "g_z_dim = 100 #--> number of units in latent space VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "654bd91d", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model\n", + "generator = VAE(\n", + " image_size=config['size'], image_channels=config['channels'],\n", + " # -conv-layers are not used\n", + " depth=0,\n", + " # -fc-layers\n", + " fc_layers=g_fc_lay, fc_units=g_fc_units, fc_bn=g_fc_bn, fc_nl=g_fc_nl, excit_buffer=True,\n", + " # -prior\n", + " prior='standard', z_dim=g_z_dim,\n", + " #-decoder\n", + " recon_loss='BCE', network_output='sigmoid'\n", + ").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3a2575d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------\n", + "VAE(\n", + " (convE): ConvLayers(\n", + " (pooling): Identity()\n", + " )\n", + " (flatten): Flatten()\n", + " (fcE): MLP(\n", + " (fcLayer1): fc_layer(\n", + " (linear): LinearExcitability(in_features=784, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " (fcLayer2): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " )\n", + " (toZ): fc_layer_split(\n", + " (mean): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=100)\n", + " )\n", + " (logvar): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=100)\n", + " )\n", + " )\n", + " (fromZ): fc_layer(\n", + " (linear): LinearExcitability(in_features=100, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " (fcD): MLP(\n", + " (fcLayer1): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " (fcLayer2): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=784)\n", + " (nl): Sigmoid()\n", + " )\n", + " )\n", + " (to_image): Reshape(channels = 1)\n", + " (convD): DeconvLayers()\n", + ")\n", + "-------------------------------------------------------\n", + "--> this network has 1069684 parameters (~1.1 million)\n", + " of which: - learnable: 1069684 (~1.1 million)\n", + " - fixed: 0 (~0.0 million)\n" + ] + } + ], + "source": [ + "# Print layout of the generator to the screen\n", + "utils.print_model_info(generator)" + ] + }, + { + "cell_type": "markdown", + "id": "6448262e", + "metadata": {}, + "source": [ + "## PREPARE FOR TRAINING" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "680da4f9", + "metadata": {}, + "outputs": [], + "source": [ + "# Settings for the optimizer to use\n", + "lr = 0.001 #--> learning rate to use" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8e3602ca", + "metadata": {}, + "outputs": [], + "source": [ + "# For the classifier model, set up the optimizer to use\n", + "model.optim_list = [{'params': filter(lambda p: p.requires_grad, model.parameters()), 'lr': lr}]\n", + "model.optimizer = torch.optim.Adam(model.optim_list, betas=(0.9, 0.999))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "fe5483d1", + "metadata": {}, + "outputs": [], + "source": [ + "# For the generative model, set up the optimizer to use\n", + "generator.optim_list = [{'params': filter(lambda p: p.requires_grad, generator.parameters()), 'lr': lr}]\n", + "generator.optimizer = torch.optim.Adam(generator.optim_list, betas=(0.9, 0.999))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c0403c75", + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare for keeping track of performance (on test set) during training, for later plotting\n", + "plotting_dict = evaluate.initiate_plotting_dict(contexts)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fe52ca66", + "metadata": {}, + "outputs": [], + "source": [ + "# Define callback function for keeping track of performance trhoughout training\n", + "eval_periodicity = 50\n", + "eval_cb = cb._eval_cb(log=eval_periodicity, test_datasets=test_datasets, plotting_dict=plotting_dict,\n", + " visdom=None, iters_per_context=iters, test_size=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1e4e4e84", + "metadata": {}, + "outputs": [], + "source": [ + "# Set the models in training mode\n", + "_ = model.train()\n", + "_ = generator.train()" + ] + }, + { + "cell_type": "markdown", + "id": "81b4b344", + "metadata": {}, + "source": [ + "## TRAIN: Train the classifier and generative model on the continual learning experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c6013758", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 1.02e-06 | training accuracy: 1.0 |: 100%|████████████████████████████| 1000/1000 [00:28<00:00, 35.00it/s]\n", + " | Context: 2/5 | training loss: 0.00302 | training accuracy: 1.0 |: 100%|█████████████████████████████| 1000/1000 [00:35<00:00, 27.94it/s]\n", + " | Context: 3/5 | training loss: 0.0424 | training accuracy: 1.0 |: 100%|██████████████████████████████| 1000/1000 [00:36<00:00, 27.69it/s]\n", + " | Context: 4/5 | training loss: 0.0366 | training accuracy: 1.0 |: 100%|██████████████████████████████| 1000/1000 [00:36<00:00, 27.38it/s]\n", + " | Context: 5/5 | training loss: 0.14 | training accuracy: 0.977 |: 100%|██████████████████████████████| 1000/1000 [00:37<00:00, 26.70it/s]\n" + ] + } + ], + "source": [ + "# Indicate that on first context, there are no stored models yet for generating replay\n", + "previous_model = previous_generator = None\n", + " \n", + "# Loop over all contexts.\n", + "for context, train_dataset in enumerate(train_datasets, 1):\n", + " \n", + " # Find [active_classes]\n", + " if scenario==\"task\":\n", + " # -for Task-IL scenario, create with for all contexts so far a with the active classes\n", + " active_classes = [list(\n", + " range(model.classes_per_context * i, model.classes_per_context * (i+1))\n", + " ) for i in range(context)]\n", + " else:\n", + " # -for Domain- and Class-IL scenario, always all classes are active\n", + " active_classes = None\n", + " \n", + " # Initialize # iters left on current data-loader(s)\n", + " iters_left = 1\n", + " \n", + " # Define tqdm progress bar\n", + " progress = tqdm.tqdm(range(1, iters+1))\n", + " \n", + " # Loop over all iterations\n", + " for batch_index in range(1, iters+1):\n", + " \n", + " # Update # iters left on current data-loader(s) and, if needed, create new one(s)\n", + " iters_left -= 1\n", + " if iters_left==0:\n", + " data_loader = iter(utils.get_data_loader(train_dataset, batch, cuda=cuda, drop_last=True))\n", + " iters_left = len(data_loader)\n", + " \n", + " # -----------------Collect data------------------#\n", + "\n", + " #--> Sample training data of current context\n", + " x, y = next(data_loader)\n", + " # Adjust y-targets to 'active range'\n", + " y = y-model.classes_per_context*(context-1) if scenario=='task' else y\n", + " # Transfer them to correct device\n", + " x, y = x.to(device), y.to(device)\n", + " \n", + " #--> Sample inputs to be replayed from stored copy of generative model\n", + " if previous_model is not None:\n", + " x_ = previous_generator.sample(batch, only_x=True)\n", + " if not scenario=='task':\n", + " with torch.no_grad():\n", + " scores_ = previous_model.classify(x_)\n", + " _, y_ = torch.max(scores_, dim=1)\n", + " else:\n", + " # With Task-IL, [x_] needs to be evaluated according to each past context\n", + " scores_ = list()\n", + " y_ = list()\n", + " with torch.no_grad():\n", + " all_scores_ = previous_model.classify(x_)\n", + " for context_id in range(context-1):\n", + " temp_scores_ = all_scores_[:, active_classes[context_id]]\n", + " scores_.append(temp_scores_)\n", + " _, temp_y_ = torch.max(temp_scores_, dim=1)\n", + " y_.append(temp_y_)\n", + "\n", + " # Only keep predicted y/scores if required (as otherwise unnecessary computations will be done)\n", + " y_ = y_ if (model.replay_targets == \"hard\") else None\n", + " scores_ = scores_ if (model.replay_targets == \"soft\") else None\n", + " else:\n", + " x_ = y_ = scores_ = None #-> when training on the first context, there is no replay yet\n", + " \n", + " # Train the classifier model on this batch\n", + " loss_dict = model.train_a_batch(\n", + " x, y, x_=x_, y_=y_, scores_=scores_, rnt = 1./context,\n", + " active_classes=active_classes, context=context\n", + " )\n", + " \n", + " # Train the generative model on this batch\n", + " _ = generator.train_a_batch(x, x_=x_, rnt=1./context)\n", + " \n", + " # Update progress bar\n", + " context_stm = \" Context: {}/{} |\".format(context, contexts)\n", + " progress.set_description(\n", + " ' |{t_stm} training loss: {loss:.3} | training accuracy: {prec:.3} |'\n", + " .format(t_stm=context_stm, loss=loss_dict['loss_total'], prec=loss_dict['accuracy'])\n", + " )\n", + " progress.update(1)\n", + " \n", + " # Execute callback-function to keep track of performance throughout training\n", + " if eval_cb is not None:\n", + " eval_cb(model, batch_index, context=context)\n", + " \n", + " ##----------> UPON FINISHING EACH CONTEXT...\n", + "\n", + " # Close progres-bar\n", + " progress.close()\n", + " \n", + " # Update the source for the replay\n", + " previous_generator = copy.deepcopy(generator).eval()\n", + " previous_model = copy.deepcopy(model).eval()" + ] + }, + { + "cell_type": "markdown", + "id": "41bcf17f", + "metadata": {}, + "source": [ + "## EVALUATION: average accuracy throughout training and samples from generator" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "ca4edf2d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "size = 25\n", + "sample = generator.sample(size)\n", + "image_tensor = sample.view(-1, config['channels'], config['size'], config['size']).cpu()\n", + "nrow = int(np.ceil(np.sqrt(size)))\n", + "visual_plt.plot_images_from_tensor(image_tensor, title='Samples from generative model', nrow=nrow)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "75b21830", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_list = []\n", + "for i in range(contexts):\n", + " plot_list.append(plotting_dict[\"acc per context\"][\"context {}\".format(i + 1)])\n", + "figure = visual_plt.plot_lines(\n", + " plot_list, x_axes=plotting_dict[\"x_iteration\"],\n", + " line_names=['Context {}'.format(i + 1) for i in range(contexts)],\n", + " ylabel=\"Test accuracy (per context)\", ylim=(0,1.05) if scenario==\"class\" else None,\n", + " xlabel=\"Iteration\", title=\"{} -- {}-incremental learning\".format(experiment, scenario)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00d3deb7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PyTorch/build-in/other/continual-learning/example_comparison.ipynb b/PyTorch/build-in/other/continual-learning/example_comparison.ipynb new file mode 100644 index 000000000..c342b7817 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/example_comparison.ipynb @@ -0,0 +1,728 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a00a09c9", + "metadata": {}, + "outputs": [], + "source": [ + "# Load required libraries\n", + "import torch\n", + "from torch import optim\n", + "import copy\n", + "import numpy as np\n", + "# -custom-written libraries\n", + "import utils\n", + "from data.load import get_context_set\n", + "from models.classifier import Classifier\n", + "from train.train_task_based import train_cl\n", + "from eval import evaluate, callbacks as cb\n", + "from visual import visual_plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cb0539a1", + "metadata": {}, + "outputs": [], + "source": [ + "# Enable plotting in the notebook\n", + "%matplotlib inline " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "57e3b84a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA is used\n" + ] + } + ], + "source": [ + "# Is cuda available?\n", + "cuda = torch.cuda.is_available()\n", + "device = torch.device(\"cuda\" if cuda else \"cpu\")\n", + "print(\"CUDA is {}used\".format(\"\" if cuda else \"not \"))" + ] + }, + { + "cell_type": "markdown", + "id": "320f9e43", + "metadata": {}, + "source": [ + "## DATA: Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c6ead555", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify what kind of continual learning experiment we should run\n", + "experiment = \"splitMNIST\" #--> create context set by splitting up the MNIST dataset\n", + "contexts = 5 #--> split the dataset up into how many contexts?\n", + "iters = 500 #--> number of iterations per context\n", + "batch = 128 #--> number of samples per iteration (i.e., the mini-batch size)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ee01ec88", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify according to which scenario the continual learning experiment should be performed?\n", + "scenario = \"class\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2746c66a", + "metadata": {}, + "outputs": [], + "source": [ + "# Where is, or should, the data be stored?\n", + "d_dir = './store/datasets'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d9b6f329", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " --> MNIST: 'train'-dataset consisting of 60000 samples\n", + " --> MNIST: 'test'-dataset consisting of 10000 samples\n" + ] + } + ], + "source": [ + "# Load the context set (both train- and test-data) for the specified continual learning experiment\n", + "(train_datasets, test_datasets), config = get_context_set(\n", + " name=experiment, scenario=scenario, contexts=contexts, data_dir=d_dir, verbose=True, exception=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "51fc95ea", + "metadata": {}, + "source": [ + "## CLASSIFIER: Specify the classifier network" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06a212fa", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify the architectural layout of the network to use\n", + "fc_lay = 3 #--> number of fully-connected layers\n", + "fc_units = 400 #--> number of units in each hidden layer\n", + "fc_bn = False #--> use batch-norm\n", + "fc_nl = \"relu\" #--> what non-linearity to use?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a9749091", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model\n", + "model = Classifier(\n", + " image_size=config['size'], image_channels=config['channels'], classes=config['output_units'],\n", + " # -conv-layers are not used\n", + " depth=0,\n", + " # -fc-layers\n", + " fc_layers=fc_lay, fc_units=fc_units, fc_bn=fc_bn, fc_nl=fc_nl, excit_buffer=True,\n", + ").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d6b15c63", + "metadata": {}, + "outputs": [], + "source": [ + "# Indicate to model what scenario it will be trained on and how many classes there are in each context\n", + "model.scenario = scenario\n", + "model.classes_per_context = config['classes_per_context']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "749dc0cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------\n", + "Classifier(\n", + " (convE): ConvLayers(\n", + " (pooling): Identity()\n", + " )\n", + " (flatten): Flatten()\n", + " (fcE): MLP(\n", + " (fcLayer1): fc_layer(\n", + " (linear): LinearExcitability(in_features=784, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " (fcLayer2): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=400)\n", + " (nl): ReLU()\n", + " )\n", + " )\n", + " (classifier): fc_layer(\n", + " (linear): LinearExcitability(in_features=400, out_features=10)\n", + " )\n", + ")\n", + "-------------------------------------------------------\n", + "--> this network has 478410 parameters (~0.5 million)\n", + " of which: - learnable: 478410 (~0.5 million)\n", + " - fixed: 0 (~0.0 million)\n" + ] + } + ], + "source": [ + "# Print layout of the model to the screen\n", + "utils.print_model_info(model)" + ] + }, + { + "cell_type": "markdown", + "id": "91b36dc3", + "metadata": {}, + "source": [ + "#### Create several copies of the network, which each will be trained with a different continual learning method " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6b421901", + "metadata": {}, + "outputs": [], + "source": [ + "# -baseline\n", + "model_naive = copy.deepcopy(model)\n", + "# -different continual learning methods (each method illustrates a different strategy)\n", + "model_si = copy.deepcopy(model)\n", + "model_lwf = copy.deepcopy(model)\n", + "model_er = copy.deepcopy(model)\n", + "if scenario==\"task\":\n", + " model_xdg = copy.deepcopy(model)\n", + "if scenario==\"class\":\n", + " model_icarl = copy.deepcopy(model)" + ] + }, + { + "cell_type": "markdown", + "id": "10f44613", + "metadata": {}, + "source": [ + "## CL-STRATEGY: Specify the continual learning strategy to use" + ] + }, + { + "cell_type": "markdown", + "id": "50eb0638", + "metadata": {}, + "source": [ + "### Parameter Regularization" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "456d55be", + "metadata": {}, + "outputs": [], + "source": [ + "# Synaptic Intelligence (SI)\n", + "model_si.weight_penalty = True\n", + "model_si.importance_weighting = 'si'\n", + "model_si.reg_strength = 100." + ] + }, + { + "cell_type": "markdown", + "id": "a1b72b02", + "metadata": {}, + "source": [ + "### Functional Regularization" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c59bc386", + "metadata": {}, + "outputs": [], + "source": [ + "# Learning without Forgetting (LwF)\n", + "model_lwf.replay_mode = 'current'\n", + "model_lwf.replay_targets = 'soft'\n", + "model_lwf.KD_temp = 2.\n", + "model_lwf.lwf_weighting = True" + ] + }, + { + "cell_type": "markdown", + "id": "02317fbe", + "metadata": {}, + "source": [ + "### Replay" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "82668e74", + "metadata": {}, + "outputs": [], + "source": [ + "# Experience Replay (ER)\n", + "model_er.replay_mode = 'buffer'\n", + "model_er.use_memory_buffer = True\n", + "model_er.budget_per_class = 100\n", + "model_er.sample_selection = 'random'" + ] + }, + { + "cell_type": "markdown", + "id": "975a3268", + "metadata": {}, + "source": [ + "### Context-specific components" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5a8ce734", + "metadata": {}, + "outputs": [], + "source": [ + "# Context-specific Gating (XdG)\n", + "gating_prop = 0.9\n", + "if scenario==\"task\":\n", + " model_xdg.mask_dict = {}\n", + " model_xdg.excit_buffer_list = []\n", + " for context_id in range(contexts):\n", + " model_xdg.mask_dict[context_id + 1] = {}\n", + " for i in range(model_xdg.fcE.layers):\n", + " # For each fully-connected hidden layer, define for every context a random mask of units to set to zero\n", + " layer = getattr(model_xdg.fcE, \"fcLayer{}\".format(i + 1)).linear\n", + " if context_id == 0:\n", + " model_xdg.excit_buffer_list.append(layer.excit_buffer)\n", + " n_units = len(layer.excit_buffer)\n", + " gated_units = np.random.choice(n_units, size=int(gating_prop * n_units), replace=False)\n", + " model_xdg.mask_dict[context_id + 1][i] = gated_units" + ] + }, + { + "cell_type": "markdown", + "id": "04975f9b", + "metadata": {}, + "source": [ + "### Template-based Classification" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d9e0a292", + "metadata": {}, + "outputs": [], + "source": [ + "# Incremental Classification and Represenation Learning (iCaRL)\n", + "if scenario==\"class\":\n", + " model_icarl.use_memory_buffer = True\n", + " model_icarl.budget_per_class = 100\n", + " model_icarl.sample_selection = 'herding'\n", + " model_icarl.norm_exemplars = True\n", + " model_icarl.add_buffer = True\n", + " model_icarl.prototypes = True\n", + " model_icarl.binaryCE = True\n", + " model_icarl.binaryCE_distill = True" + ] + }, + { + "cell_type": "markdown", + "id": "6448262e", + "metadata": {}, + "source": [ + "## CALLBACKS: Specify callback-functions to get insight into training progress" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "198c0fbf", + "metadata": {}, + "outputs": [], + "source": [ + "# Callback-function that provides a tqdm progress bar for during training, reporting training loss and accuracy\n", + "loss_cbs = [cb._classifier_loss_cb(contexts=contexts, iters_per_context=iters)]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7e7cdc33", + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare for keeping track of performance (on test set) during training, for later plotting\n", + "plotting_dict_naive = evaluate.initiate_plotting_dict(contexts)\n", + "plotting_dict_si = evaluate.initiate_plotting_dict(contexts)\n", + "plotting_dict_lwf = evaluate.initiate_plotting_dict(contexts)\n", + "plotting_dict_er = evaluate.initiate_plotting_dict(contexts)\n", + "if scenario==\"task\":\n", + " plotting_dict_xdg = evaluate.initiate_plotting_dict(contexts)\n", + "if scenario==\"class\":\n", + " plotting_dict_icarl = evaluate.initiate_plotting_dict(contexts)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6b7b35c6", + "metadata": {}, + "outputs": [], + "source": [ + "# Callback-function to track test accuracy during training, for later plotting\n", + "context_cbs_naive = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_naive, iters_per_context=iters)\n", + "]\n", + "context_cbs_si = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_si, iters_per_context=iters)\n", + "]\n", + "context_cbs_lwf = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_lwf, iters_per_context=iters)\n", + "]\n", + "context_cbs_er = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_er, iters_per_context=iters)\n", + "]\n", + "if scenario==\"task\":\n", + " context_cbs_xdg = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_xdg, iters_per_context=iters)\n", + " ]\n", + "if scenario==\"class\":\n", + " context_cbs_icarl = [\n", + " cb._eval_cb(log=iters, test_datasets=test_datasets, plotting_dict=plotting_dict_icarl, iters_per_context=iters)\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "id": "1c1c8ab1", + "metadata": {}, + "source": [ + "## TRAIN: Train the model on the continual learning experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "680da4f9", + "metadata": {}, + "outputs": [], + "source": [ + "# Settings for the optimizer to use\n", + "lr = 0.001 #--> learning rate to use" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8e3602ca", + "metadata": {}, + "outputs": [], + "source": [ + "# For each model, set up the optimizer to use\n", + "model_list = [model_naive, model_si, model_lwf, model_er]\n", + "if scenario==\"task\":\n", + " model_list.append(model_xdg)\n", + "if scenario==\"class\":\n", + " model_list.append(model_icarl)\n", + "for model in model_list:\n", + " model.optim_list = [{'params': filter(lambda p: p.requires_grad, model.parameters()), 'lr': lr}]\n", + " model.optimizer = optim.Adam(model.optim_list, betas=(0.9, 0.999))" + ] + }, + { + "cell_type": "markdown", + "id": "cc1dd1bb", + "metadata": {}, + "source": [ + "#### Train all the models using different continual learning methods" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "609facda", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 1.05e-05 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 47.20it/s]\n", + " | Context: 2/5 | training loss: 0.0128 | training accuracy: 0.992 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 49.12it/s]\n", + " | Context: 3/5 | training loss: 0.000898 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 48.89it/s]\n", + " | Context: 4/5 | training loss: 0.000352 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 49.36it/s]\n", + " | Context: 5/5 | training loss: 0.00319 | training accuracy: 1.0 |: 100%|███████████████████████████████| 500/500 [00:09<00:00, 50.34it/s]\n" + ] + } + ], + "source": [ + "# Naive baseline\n", + "train_cl(\n", + " model_naive, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_naive,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "b585d66d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 6.23e-05 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 47.72it/s]\n", + " | Context: 2/5 | training loss: 0.0373 | training accuracy: 1.0 |: 100%|████████████████████████████████| 500/500 [00:11<00:00, 43.94it/s]\n", + " | Context: 3/5 | training loss: 0.0161 | training accuracy: 1.0 |: 100%|████████████████████████████████| 500/500 [00:11<00:00, 44.69it/s]\n", + " | Context: 4/5 | training loss: 0.00592 | training accuracy: 1.0 |: 100%|███████████████████████████████| 500/500 [00:11<00:00, 44.42it/s]\n", + " | Context: 5/5 | training loss: 0.0707 | training accuracy: 0.984 |: 100%|██████████████████████████████| 500/500 [00:10<00:00, 47.00it/s]\n" + ] + } + ], + "source": [ + "# Synaptic Intelligence\n", + "train_cl(\n", + " model_si, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_si,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "fc974df9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 3.24e-06 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:08<00:00, 56.95it/s]\n", + " | Context: 2/5 | training loss: 1.46 | training accuracy: 0.992 |: 100%|████████████████████████████████| 500/500 [00:09<00:00, 50.88it/s]\n", + " | Context: 3/5 | training loss: 1.97 | training accuracy: 1.0 |: 100%|██████████████████████████████████| 500/500 [00:09<00:00, 52.16it/s]\n", + " | Context: 4/5 | training loss: 2.3 | training accuracy: 1.0 |: 100%|███████████████████████████████████| 500/500 [00:09<00:00, 52.21it/s]\n", + " | Context: 5/5 | training loss: 2.49 | training accuracy: 1.0 |: 100%|██████████████████████████████████| 500/500 [00:09<00:00, 51.95it/s]\n" + ] + } + ], + "source": [ + "# Learning without Forgetting\n", + "train_cl(\n", + " model_lwf, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_lwf,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f7824f59", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 9.88e-06 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:09<00:00, 50.40it/s]\n", + " | Context: 2/5 | training loss: 0.00253 | training accuracy: 1.0 |: 100%|███████████████████████████████| 500/500 [00:11<00:00, 44.84it/s]\n", + " | Context: 3/5 | training loss: 0.00109 | training accuracy: 1.0 |: 100%|███████████████████████████████| 500/500 [00:10<00:00, 47.07it/s]\n", + " | Context: 4/5 | training loss: 0.000389 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:09<00:00, 50.39it/s]\n", + " | Context: 5/5 | training loss: 0.00527 | training accuracy: 0.984 |: 100%|█████████████████████████████| 500/500 [00:09<00:00, 50.81it/s]\n" + ] + } + ], + "source": [ + "# Experience Replay\n", + "train_cl(\n", + " model_er, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_er,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "76f05e7a", + "metadata": {}, + "outputs": [], + "source": [ + "# XdG\n", + "if scenario==\"task\":\n", + " train_cl(\n", + " model_xdg, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_xdg,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "54e9c8de", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " | Context: 1/5 | training loss: 0.000369 | training accuracy: 1.0 |: 100%|██████████████████████████████| 500/500 [00:08<00:00, 55.57it/s]\n", + " | Context: 2/5 | training loss: 0.397 | training accuracy: 0.859 |: 100%|███████████████████████████████| 500/500 [00:09<00:00, 50.54it/s]\n", + " | Context: 3/5 | training loss: 1.37 | training accuracy: 0.977 |: 100%|████████████████████████████████| 500/500 [00:09<00:00, 51.36it/s]\n", + " | Context: 4/5 | training loss: 2.95 | training accuracy: 0.953 |: 100%|████████████████████████████████| 500/500 [00:08<00:00, 55.88it/s]\n", + " | Context: 5/5 | training loss: 4.05 | training accuracy: 0.945 |: 100%|████████████████████████████████| 500/500 [00:10<00:00, 49.02it/s]\n" + ] + } + ], + "source": [ + "# iCaRL\n", + "if scenario==\"class\":\n", + " train_cl(\n", + " model_icarl, train_datasets, iters=iters, batch_size=batch, loss_cbs=loss_cbs, context_cbs=context_cbs_icarl,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "41bcf17f", + "metadata": {}, + "source": [ + "## EVALUATION: Plot average accuracy curves throughout training for compared methods" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5b128331", + "metadata": {}, + "outputs": [], + "source": [ + "# Collect data for the lines to plot\n", + "lines_to_plot = [\n", + " plotting_dict_naive[\"average\"],\n", + " plotting_dict_si[\"average\"],\n", + " plotting_dict_lwf[\"average\"],\n", + " plotting_dict_er[\"average\"]\n", + "]\n", + "if scenario==\"task\":\n", + " lines_to_plot.append(plotting_dict_xdg[\"average\"])\n", + "if scenario==\"class\":\n", + " lines_to_plot.append(plotting_dict_icarl[\"average\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "ae1533dc", + "metadata": {}, + "outputs": [], + "source": [ + "# Specify labels and layout for the plot\n", + "line_names = ['Naive', 'SI', 'LwF', 'ER']\n", + "line_colors = ['grey', 'yellowgreen', 'gold', 'red']\n", + "if scenario==\"task\":\n", + " line_names.append('XdG')\n", + " line_colors.append('deepskyblue')\n", + "if scenario==\"class\":\n", + " line_names.append('iCaRL')\n", + " line_colors.append('purple')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "9e5b4617", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create the plot\n", + "figure = visual_plt.plot_lines(\n", + " lines_to_plot, x_axes=plotting_dict_naive[\"x_context\"], line_names=line_names, colors=line_colors,\n", + " ylabel=\"Test accuracy (averaged over contexts so far)\", ylim=(0,1.05) if scenario==\"class\" else None,\n", + " xlabel=\"# of contexts so far\", title=\"{} -- {}-incremental learning\".format(experiment, scenario)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a5620d1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PyTorch/build-in/other/continual-learning/figures/rotatedMNIST.png b/PyTorch/build-in/other/continual-learning/figures/rotatedMNIST.png new file mode 100644 index 0000000000000000000000000000000000000000..afb9d51bbdc1f1c17325a3b1a70105d67d961ce2 GIT binary patch literal 187654 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 z%0AosO`{iT^iPVT%!rH9QY=&(?c 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 A9{>OV literal 0 HcmV?d00001 diff --git a/PyTorch/build-in/other/continual-learning/figures/splitMNIST_results_tutorial.png b/PyTorch/build-in/other/continual-learning/figures/splitMNIST_results_tutorial.png new file mode 100644 index 0000000000000000000000000000000000000000..a118d1bf045bc0cc8ed939568875b4f9ef926d59 GIT binary patch literal 262531 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

7_~wC8mrWqrV+rb$%D#MRG*Ij1OLtR*scJ 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�&gE$lYk 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

Bx8#5Ns&QPcWV3@;u7 zxu~i~4CqK<=QwzH6<+su9IZy(m6rQk6*1uEtaj%E=Vr{UYR!+B7<l|F2Pl;pOXaEvn3*#SRJ-@%Obv{2B}<385pa`kl#}MVd_k%5>u;jg!pr z%6vWH0rd1;LcgpER^Ia9C@&+J(K)KzbwKXt~KME?E0C&#j=p?`vmjImh;X0Au%`tBLZMd{_ zL$nV9l8)0xO&ujKXVRvfbceAd=?&{^yT_U3UDe#xuDwtHsbAGwnhmiX)Hk-nb`e$* z6VM#hJKqnH<2;d*QwuMs?!OqC^XBi@rix{bskI+E|my4=ZXi z5@%oSqI|XOPn4GZxh5z4wc`JLOeM7f`j-Al?wvK1O}Iy1ymv~BS{c(&jZy;qj5HT% z3z-FsR$Wx%XUud9JfZNaGlj!rJ9eLy*H1X}jTQtRpkqbaT1ulc>-Fg`a{GPS#rFXx(TyLypd3hx*CMMRKbesBf zW*3~z6ecsk6su;5bHc8u2-Is6l*j*xRgA4}E)L;#=9>j~*|m<5(f||)aPbDVuD!Vi zpLXF~`}I`&zaMu8HouK*>Tiwan`k8@BxtCXa=E@(eGwg(6fp(Uf?eGBy5|feCbAq) z=Iz*^4)SF5m#u2K_i4p#;-%*l1YxBevQbL(Bk?Az!D8X6j_O(F9*x2&*x@p-)3DjC zb9|VRR7qyN;XtaBmYnJ$DOqWY`pWjTr=hU~#1gX_a~;}lzs zDxGR~QsDi}$#|~V_E?Yf*LT$|VS`bmvk}ZUZP@uQF&(hwgpI}fg=N^~w%#b9H>E7h zJ@rAr%n!_DIFLqpc@-DJP@lJ|c?7C2qt2#&xv&CZ!=s0N^oSUusvN$+?9Tuz@wurB z(x<5k#P+{_j}e#RNl}qQ)qFPF*x)PJc-T9jfnkISFC3NL*C((2nYum;LRxp58+*OL-Zs6tp*x7(Wl6qsc?ZAj2ZX3RFN zL-n6BeVE@U)rBf@@}|P`_A1K*Hf$_$=D&t4r7@iB(6fA)h30MM(I59l{s-nJ7_ffA zbo31jbeJ}jaDN(Wzl_e6ktVQWqgoe1stc&%t~Q?&zpmBC5e%kfY_Dm=phP3JH4<|8WWprOD@_J_2|C<>LYADQbL&W1DVlg{x{OH;w$f zHM-f%JxP5z)@+Od)@#S_4Y!&*WBXh2b+8(Q@y}k2?BqFOC>`z>uv50LZ}QM$hcNl< zxwMPFf8ZP1ThG+`oEh|2srB=LCBnWJ7J(QnES)4F%pL>^R=%O3SpfVY@&ZT$eAXMs zXf*tQd?NCU?ne#I1O3zS4yIhbVC^buqh!hzmk(FR9F zMHA5XR95y~DE&6<90Fl5QIS*{94&gP=+vrk{(XBxSh`)uEV?C9)>(?QLTP|1eVW!gZ*tiMQqfrawXsPCdStUWgz z-W0BYHagxzKNpzB@VV+1wv$!e5ox;TYdR}Y(qbC_q;@Lut17(#h*1PqPr{GtG?PB0%3!rfhT z2~y4dDJpn#eZFsWe|I}NI{G?g84yt`V4}86*f-OO1=ysb zFWb-6{2n&GvK-(kh46GpW(`2t!>Uq`u(zeZ%CkMr_vUUUyl(L#QSci;H0E>|=t}7M z^PK`7QqsGC)Vb+OEr&5hpaSp`8exN2b%^5#Kr>4+*n+yKL3#n)f*W=+ zp?=9MH(Fvcs3>=5W@hg`7m-)dI>r6>fnNS8SQP?P8jiF`4x6a zpjGT=JVIz)j3YN!GZ9@pYHZ~)F@fqUqK|xVI#>j^q0&r7e%()y>b!u#Qwwwyw_oo!557=R zZ#~kb0cRSpw>dwEq~qJ_KM}O}oD_61Z4E0Kfb=b^*Bh(6w>mS;56I zcTkmf7%}E$u$&X+XhBrHx0sEAYrRc*?#LHOiJ`0c!C@}mi$h;JpfTe8Ep>j^6KMX< z*ucU+rC_QY+!+_^d)7n}$&AzIaZjfR5uY$ldtR>MoSXnqsN%3a3$WyaT`RAK-gQMK zCD5b{i}m6(lH;-8z=UcGrd=IVq>dk!kQhnzkm!25ji=zi1iJ0sgbZJEM`<1LrN`EBURl#@Lg&Z^8$7- z2NcTc{;Tu|NnYl%y4ZEM-9UUa+?nO!$m#xxe9Le={SyC$UBq~-%yT6yb}4s*>6k%M#FfI$8y&wuz|An;>IfYa_ENYhbJVIW0yR6JGCqs zOb|UB{IN`zh01q4=1w90U5IdBiu1cyT>Tr5DxOI)$kuzj1){!iT5KvwZ6Ln50grAO z6!pN$%dv7tx&ds{=hS?y0mM4rkJOX;J6Q+$5QfU%Q4#s zNB#J?m3l@!*!5=Ze`^8Y0q%8+F-kA>IA2tr5|b-gwAh3sv<{=3$5|}D16xJ6f3KYo z$Hj{dn*TGCU=FNN*&qbvrSRvh%3UERzY(yd`~fECdUhkTehg8OeF7lG0^&GxJ998X zsyod&h#QM`1$K6d&3)2h(5R0=BjTv!6|i0qYC2BYKe>PxlTj}I0$RhZMJ67c)iy=> zd3n&?y$=3vOeZ*iFas!>`+zVfI@N8V#iuf1gk0`!{k-{}A0qbwPx!G5lCsGN0$KU` zz;3J2U(iN#>o02D7_%qb-U=51 znE!nlRVpi-^u3HQOL=X>wCC(NXST z@CvD>8G;_!7=sB<($L^T>j3s=hJI+#t-%>u0z!&dl=YGcK}Duic(;t$$>481^#X{e zxIv@zG_hTsdc6Yib8$ShFs++a!&I;3s;qqkP_L6BD(Hm~l8-%Men@`dC>BB54+!J|KpG{LpL`t(e4I-{ z0RC$rMN*?Y_v`zYP{gipt9C;*7>d7vum99JJQW~C`bI`%!|eb45FyZO1Lonpf`V6X z--hJN=h}iJLYF0bfCC#na0-OW!66`_YHti>&|Y8NdP4P-0D=OwmhJj1;0F-`px6NL zUb`9~_<}!u-juMAmX_ChB6CnI)i5#Vup{wQAy$#f0;5Z~sQ4yEn{H_Bf^(oY`Pi^; z#Dc^yB&e^budgZJ~9P5d#J z#~(C(6*oq=8d!jh!mqH#wKNhz>z$Kyi(VhGU5al!VkADHcwp0a;MeXqX3|r@%6>-OfxM526ASG^pDh-vD6>-?@T!W+0~nZbM*!cI%`l41*C*@AgHLX zPXxpeBvJxxVN(1~!|SiPcK?9Q4EP`IXUnjGWiOe{E}(aH37~5&=Ht!npOiqyr%p|8 z|9{rL@2QV-gKk%^^YY$M69?PR);$Bq$MKIedHElF$6v_Tj5Jn1{XYC+;EnUuD#h-F zkujRS}>VX0spIWr+iUn}RO?b~gHV}}zS4P#bM;Rs0#=m{vOnHs5mV?b8XI%Z6cEo zkMlNDMEm363EHsl|C_plPo_v>A#ZoZ08a>HSpkr?TpY6n2N4*c5y57Z!?66shR(X~ zL}Hf@1c3py+ce3!Yh#gGjdYDmeIel2l#6bYK0VChFa3=zJ}k%LPg3I*wfNX#Fy0CK;oN? zng2B&<5nUM$}56#rf?tX4y3Viny9&`U}H2{^O_=4Zi3rn(>+H~fICymrP~LH41}a!EUc%EI`c0Qb0GPhj!s6**2BZa ze4nMykwBoz7Ha+4zhOAj3^NumQfr&6%2oF4nh`Y`4I|0jF~1Ys<*E{E9i8pMat=GY zN?|ll?PR#+;~YeOKX=z8E9o00itP(Vi*q6WXN>sI8^bRn(Kor8l9gR*gwZci_q8FB ze{1qrX5}ZUNByFDw(Gi_M#n0bh3%DRQ@d>R14ch2ti=ns>lWU-7RG$fiGPBdEdG=H zyG;iGk%=cGXk~q;8i*>qB1+)(1B?;IJFAq5CaBPf%WTv0n^Na)`9C^pZtbf`hG2z= z&JeS{>5Qc_1Ghq^Zm03a_RcP0-pgOzUR@)d4YYswN(3eU4FD;)}aB~+#=gNHQqNBFOOrwEAqbf==AQ&I@@%q zjIzCWA4tB2bp2E0ObL3kzj>C(WO9Rr6b=+ij2Q4W&kuqM>jw9KK)D9;&$1cJFkynG zcN!yY>F@l26wtn5xlFl8D`q6DLsvmTVQ6Sbh-((Fq3;1H_Qw>@loY2DbrIE{JjHlj zrcBqzqetZ^epFUb#4X8?9G>A2BqX(b8lkDPN_G2B>8o%MT$R0~vP}Xq49+qwFtKyX z(c=X5AA)R{G%WnPNktx-qtwdIVvR0q_S2G)Nx9~jvDN#K0#W&s;W*O)D)3==fl!vP zy1;4q)NGyKRtKofKeSsB+jl5F8@g}fK8$l;nxC#`bgb;SeuGc4dTBHvT#HWM`K1|4 zFU_!fW0%e>zoUw4(HYLGGAPIT#c77{C=&V*{+lkMdYk70wwfeyS|MRI1fK$TZagRv0VKa_?w|{36;0rG z#o^1}L&x3e4#39PC*?K(c4PlsUS3`psPzHRuE_u1 zKUc_x4T1kSg^sHzOA!})ljd3((A(yGoqF(_z_uEO{_q(*Q z`eIo-Gh>VyQDd*b44MDLTO5kA&{qGWwFMGeG_+;1oU;`p6XI(Lcj1zk$*c%t$=UlcAA5cNNsl)P zF66mCD|AEnG+VlzOj1PCUD!~simSk@jyvkd`B}mvFLZjr=ZnF+IgwFJRjoM0F&L(W zuQlSuIaQC3YxVnumbg`+2!;I5(8~*Fy}8NBv^^U1apr6%e?`WMZ>VZpD;isUxs~Ia zv=+u{8k)S8&+LkUm>Qdr+|2Qe2=0V^rSmIo0c)X0E6^)DTzaZvJq)X62h`$NC|OOHTZhgU15QnCKvf-Aorc-6mIaW;ZY%j{ z4;$mu%t*PoaG#!@*2i%EuTzSc2uD;$`OuoBf`u9Xw3%|rdOE?SGc=~v3h_)=x-V^Z zEk4KOX5Wpmd`~cKvpQUx{6kCH-M>J&vM7@`mQQ30EecE~ayiRCQ;>E!Vq_T97lmfml* z((hT79a2WX$uwR0T)aa~fA^LGfn#0_pxE7XE>GS1k>foYl&~tO#j+bckDk^Do0OAY|3h$f0=;X9l@x#0YDd%0g zj@S{~b_k9@8VF*0?pv1+E4el0<=d()X5!gQq8N@hXfaVhdms~G7)SvDr=wWr;Ri;E zhcOn#=CKMr2NE9oM{{$NBYXGvcm{?BEP8vWUl_HbPi`lL)-hqG{u*dAs^KODoxS^w z-nz2!9G(FT+b9=)-cjYFG_N0xs(0%CI{cLQO9}w5-aEb=?@SVNGB#A|v4og02WiAY zxS0bA7T)?O82Y7D1bC(mzP*pYI>-AMcp$ocQM+QZhI&bgz#_KQ&_rs=fJ``$_^9J` zk3+y4Cd5xn$mrTj$%n0<%g zsgUtmuXY2TW4%)`qzLDNW_!5?JfWTHCAE)j5DAo z8n;k!er~}vsB0MnTLWv-m%zNlB_alOFff6eS6Lllaf}5H#5Rg!- z$1)RC{cQYnb~ua9@mS}nv3iLGhkpgr#N}{u!jnpRc^=)tA^G{zQ@G^I!9}-z%K02h z{pDk3?(=jjKxK@rym#PY3MgQ1pKfwe#KC4o_6$^?(dJNS7A{}NvgT_k|7#Sld1Db^ zBsJ{eQ7?zu&Vp1E^B7Tf>78V&Fny~jm;q7cYCPo&7TcEha=7{A*p09qLdgxu-t`G2 zf3u@Y9L|_YPEl8h((`!n6IYO!iO_UR4Z_9*i1Q5D4YfbWIeu|cCDu)CFEn^($TW@3 z7|s9u*SOL)G4h{}C%VhU( z+Q0puKt1hH`gr{SqlnjkiXFFzsg!=?pl!q z^aSm3Y$frCLRj4W;UmN7ppVoW*ygLpS8_Orh4iO}Fp;1^A7|YcY_5brUa(@gcKXqK zIu2O;@Y@vA#b($dx>G{>SC%S*Df3h-=Qay)mn(vm4n@tlY40E1PE1H7f((!! zi3n_LFw<{&i73j)kEr|*lZL=qv@~{8%&FYEBKf$8-AFlFk_J3p zk(x<*X-~W33U!zH2@}(Al_uc-?yJOIyC`d^zVW*)tYZ^`zDQ=&zNw(2f2LW>c05U< z{a$b!^N;-2oRUSQ(7e5+5(CS zWh^aAEbUHTfSqAvv)!^rf`k2GfYlrNe~_Pup;b;94GlAF>a0nnYoxf}}wqN;2BkeZ5oAz5*2kGhQL~lz@Pdi)xo5f3ITz^w z47UQ~qkf7plLpIkV48?jzE3Fp1~?jSWHNR$Qc7n>qk*^A8@(nbH_?$Wn{8rO(k zTDQUI*aR>2n7G881R{TFlS*o!PUQlCZ8Gf-%yA(f)IxUfEzH3WpAr2xXEc=(NH^NpAAe}|Etx{l@ZI&K$bi_MDQ)Ao%+YU|&%E7?9c zH~=A+u4V_{R4w6hT{C}2_3ag6p37`1I_EN&FOXo`=_UEq`v{|O{Tr`M$%0IKEbV6h zN7~G?TBmr&@9wPq^3GVewB+!^a3}|Cfcf!Lh894fZ^^iZ)_;^)5Lj$J!1xvVZTmHw z@D^6d+^{IahldnJq2L8Z2d0=8$eGLQuo4SPp*#vegB)qtSI}Ls?!Y z1>;>*V$LTIDpu}RZU#Bs3RcRtVo|0;W_%B)R}!XgREc|V+d7F_8u)MHRq37&;nE?l zBtGP}dz6Z|g3Me}eSoyb0FBgS4X_QLZckKrxFO?xnEMHg6hKfs`#EPd(X2#guHFGM z9R^`jW1$CL9!7ZeaW-E{0o|)ZnieBuR)qYjz+PksBsLKD2;xn)Vr_XqHZahm*a9;s zi_4KdpikOG@if{YM(CGjDTCd&yKeBc@uY&pDY?WX`|0$lRVwTmj+4iIx57_z9ocu;VBTAD-@|Q>vlTCOV+l zOcqSGB)t<8Bu9i$gTL43sLnR!2w=#XMT-_IK6zC*+&a}}siQo;5|iutYRp}sJTgF5 zWxu2>O}2l^zanRWu_-i%`CQhm$Bqr)H>ry?Sah}CU?kj730IV7M(iycEB)f{b?n|yFFl~Ho_m9p`Dog# zlo=?MNC!*tz)1)=(LWFDy2r)AB2;0U46N>Rse0=JDUeTAAE;Pq*PTJAO#+XDY0bK^ z1yH&GHmst*4A5RSa}E=mEKM6g`OM?nnr^wAU(f@zAjZbV%|y3=e%1#@hx-08Ezs&k zjE*dwi|w}<|B;Ut49qAt;Dxf%>^00W#Na!C176(w=c?Z~A`;!Dc6e(8bHtoV`!h@k zw*_Z}Ix>Q@cE3COJ1C|tMO1qz>vO1Gw5|&3o($R47qw~2{^{#!*XPLI#hZYEk;6C- zXAL)Mwa*eS=4>pzN;4xLpW+n%l|wN`dGVfb^_XY;5nHsb!P>$ls$=Ttwb{;kj5CV- z0r^@Byrj=9*a4XWws{1~kb!zut_wx?>^VfUa&^H7+)Di|&+SjEjgQit5D^Qzefl@r zqZrygHtWGflc1i77~<-Qt@nmQ61J1WE;2h{pRM9vv#qn2fFlp*uabJv*KnsI;nR#>jN`~0PTULcy!p2PY)M@hG8CL1UbM~ESO~5*AU%RiZ)wWvKHP+z^ zbQZ$w>Pa+g4i?^l00?nMN66V?5O^DiM%0Ojr!GW;voz;4zYA7^(ed%4Uah+*XTE{_ z+|-@`G@|LpIqzPzjcDB+;Q>-9bYyb{7$~4r1E7zskEIKyOGBV~iHEEXT z|Cc&tgWBzAC?Bch-8SXsLm3QXa_Gc)8uBcc}K2pFMo#|8RRjrm2pLsF4 zD5GB?COThY8{5yWvKyN_J*9hma{i9(n0EJini~7-3j8N`KNQ>gR-iMdR4B;)otyGA zLMzt6?gxG4<9&W`2h4Q`u0bQmu!+!_(B9PmoZm(J zqb7m|0MjU?f;vU=8WCkDu%FZERY+ni4f5U$ns^8MgX1&YaSmO228gGC5#68%XXk8S zt~Q0;3>Qj?0W03eIrroKBK5kc?-b%WJ9fZ04#Z5Z(!i|=dP9M?yS^l&!Eygz|Gwur zFC0VjjV;s~$^bG4AzEawVP62E>4Db-{HuI`te;DS+`N?FcVO|3qLgq396uLe+Mo~! z!Rx6(Ww2Iob8`a)i8WA+Y+P=Fr)XNGTeanu=>qA7@R?zAhaX=5E>JAAPbqAE^7s*W z-##lUe(hR*r+BUN^vAST!bX1L z(^-UzXFgALw|nW<>$qKxt~h4RSqGL*lj{T=Rt7!hVBM^OCM>H36yOp~Y?U4rz#5C1 zw>8%vw;v!r^5_e|nM!5*LC=1#uQ7I?@p6AgHQF}4`-D$cYHSH;*?{nn?J>slZyYew zO|QYL7xd`NgNwH5*DV!@d}=SP7kX{eZ_7eKP8G_q)O_+azhN2=t;tMkfcKlYAKIsZfCz;Fu$VplclM?KP~1Ca zrb=V{1QiB4T)Qr6`{-ePNIY(nS>K((^gln6ec%MJlX~j9@*}QO) z?@F?e3{L3#0&m*nef|wGuL^u)7-lZtls54D>nJR{EC)WiOgD87UaSl~6H)B;PKnYb zk7bUR{YMOFoD7|tw$aoZ;xIk0Age#@{zuXjmi_zA$t9Bc0nGnDuhVc#dQ>y}e*&d9 z9}EolrPEc_nCXKVr#}E?X^u5wYy9~JYSifefN=Us$CiQGv?5zCN%{W1#Q~pZeZOwy z(MG>lMmkrwAu^h#$Gt=K5BFiWXG{i94v*9Sw-&(1?vZlH#zlRm18!CRW&_e$Th2Zi znAoL8_j?UY zxpfR?8~I?jLH4c~6i9mKheWvxeX|HbLKTn^ScA|DB+1dQzL4SFt&F(^hVf^wo5a1Y zXXfkK0=ZoE_4Pq)8Ss)J*45QPDIdGxW{I6ZbQ+N)L@zah^7TE)_W;rRK{InUNROcH z5By~J(K=PEmBw5NDhcuZS501~{pQT9+b0QJ8UtCoD&xdpQ1*Fe;0Xn_`3@KqPb>s4;WrWAMe zqsKnR@>=xAdDN>yNe&#c^e!Ci-XHk<0cNd{jw6#5@XeJC+1?~Q0L#au_3xKeAt&LV zsISmIzmfzerJR9sE52ppO<;V~j?AG8>}DrF>52cZ#u~T|xN4sT;v|8$s;p|vlInR@ zxK+yXuP*q;t6md;|2u!olwshp1T-%khxz2trd{GSN7_shaBv)6y3@|EvV4wl+Yknc zKEyosDBi$1mb(LGU&MODKpiNsmt0+4#YTWjGPYc6`)??4m8k&juy|Zw-wN-sn=Xiz z`{BgoB!9r^qx4oJY@=%h|9MqnNE^Que4vUN(H2aqM8#_ zXYJNiyHlaX2ON#TRar-N&0kO;7k;u=5$7ve0-)$cQ%7EWHw%WyaHztV(!#TgD5N}+ zd^%GOd8&2P=CF4q*z&2sPIaWS`9AUesz*hqUStfyuF8}QT9|B~xO`qzy%25F2LxvJ zzt6UJ^i=uej#wY=pgU?g^wDOF_dkM==c2+uRFsI|S>rR$o^I@DrI6`g7Gz#7Uhno9 ze;dm@&ND#GSQf9<=!R970@+5T@{*O)0y%Nml;#8OZ{^_j?7$>9B>+YPEdkjQake0D zGj~@D6u3N40RR@P=e76*STV>x<$kdkxHDb#OlqWd0~X>8@&nYa+)swZZ?5O>4S}gi z-Rt(WzBHrIaqq@9?l+h(QBI7qMISho-8KU+oH>+I|V_6_7R3y_Dp8y|wl zxc8IIZ2M5;e#x54esIg6Vv1|Gas*O;%v8~9H6?>PPnY9d^JDTI9nMo=yZ#T3CPok3 zo7#SO`Ta4kdL0dg4^b2x$fUw7N1gZilFN8^`glC33S&#Duq?^aKWj6twf~a8keL&! z{PK>WRTg?!2u|vk_xP$YuB@s?9lAENQl#bOEOMy%2v(@^f7meEv5V8oo05Hcw22AA z9pM2s?La%@DFZkZRqv_#GOAs&;QGtjl_%0f?r0qYPdv&y^`^m1 z(@*&h{{I~7^8! zMQJa);&KotuJv%yTYOEf>Nq8sw*g!{3-&69Uh2tQQbnHPEy zOFwSS#wtcA#n@@%jq84}Gr|z&!Xs(u=vF|w(jq{S7ol7rE3a#{p7QU&E~ReM@d7%R zl$HO0Qi$1IL~0<*d*ylHM}~=-BNHg7{|6IN5Zc<>)&k{fgtPYtpziGL0!N(5H3xET zl|U{lNFf?KIs_uG&u3;NkzX`4QXKmrp(oG<+nbQUylm>!+1NMLI`#i%eS}rYMI^_BJXIO-g@XZVpWx90HKv!TA2M$03CAbX5|wiX<^1pXoh~(LUSj+?n@->1}qc*`|-@gasi4`@|Q=$9r%w zUw?psy@QxyIObn1*<^}PRdq8FGrO-$aTi{3*MGPgVMJ>SJv-`mrlDVDiXR^r5u^nA zjk7$UYfC8cY_>>B{S8q@T5j2MRbF}?kqv20U*q=OFbeZA?!FKdEpWlZ!h*=FDhWPd z7|Hbtyl}iHoHZ%XL_BNFNzxv2$9KfW|NI(PR(N3saU9kzk!tX;fFQe8qU{fhlTq^W zCV_-BXut#{d6!-Ue<#>5`+>v+0}??&bwZutB)!0X4-OX)T!fiBl0R|f0!%Hn0Hl6` z3lN&tvAn76G-&hs|3dd( zbqQUf|94}C%S{cKi=mT>8af)53Pf~w_b!f(Ko%NJF?-{+4`PN@gO&@=oK=3VoGXlN z%IB~U1}!=`xofqg17Ha?F{tOt_R*ryU!h8Yw}(@FX)pcqJRTQNrpZmQa@!q*#iMrj z=D_lcO0S5B3g*Rna8H|-bBXibuYdBQV!VEW8IEinXqJZ-vk*3lB`18vSTR3@h0&bp z5M-O)M6xi2dN+qz@IhZgLdg?coc=>Ue#zk4XKxIqC)GLr~fTO)_BO%+@rcCXF}-`~tqBV%=6jArwRp z<-$QvO+FP!Ro3Ak#rE9zutst38%KqsA>A@yjjw=~4syA1J3vgD&r}y@7lSaX!qTS1 zu|lO9VtK{7mu^L1Bjh5!imS%wv8U1N3^j4$!woqN@gBMpQ&a?MS+H#?C@C$UUtiy} zhCwq9*nUC0Ab4hkU*C?56(+PG;jFPbti{CGB}cM`>m+0X;S%C6zG~=!DQ%R8e|R0- zwYz(88}yEOk>y2Zp4c1Ho+~MDRXg0Ocs(xBglI?>JK4`o+puqW5%a@<5nJA1SvHMF z9i1(P6L~+<%ozWksft=qVr0YZ5UoDS`b)5oEG4kRq;IYp`FP=3hg9Pw%samq$N>2}lR<^7m&kQGwUm53CJKE%b zDSqbb{nYnWxj$vmOaCG#t%0K(o9M{Mq^~QQC9N zfPp$B6p8!;`;Ch8qOT`{DXYYw-g|A^wADE@)8a4}?g;xgQfycx_6>X9iP30zl%Io! zpUY-ei1uqqF|nl;7TksF%G_tlV2J)({&6cvVe%>IW^=_@^KZsf`&+AYz3KT8zI|%8 z!Rsd^BhBy4Z=|w<@s^A)8>bj}(d{XG+L|+J_cVLvFNqD*n%^7G4<4{LdOt4~Ca?}2 zmqo3TLc21PuONZUUs-XV^-k&*FPK|b^=ez%;PPF zz88QmrF}@9XJ1&oX6YzdW=@>&_w4O~M*O%5N+^*iW^xKi1^49k(?RF>^Jw#sM4lG> z&s{siurHh~j$h7PI5h?Te3OITp>Itm?mJn(ekJd_uk(U`<}-lJ2GsmWj${E9H0X-N z+bLPvovA^v1|aa#G0DBPbNaFaVksfvksasZhZ9sEH1=eU*@a0cL=OseXuh3kE^|3H z1V%nMeFWRI%RZxvJ*VbgAY(vi0X@q|vlAeH4%uQ(wb_%uOxav{{f#u5#snDgLHgCN zJx-jbHm!(w2OvJ+MCBYx*9L~|b&sr#sjNaNdfbqVZ643&G$C?wFQbRU;(h2N%8bvZ zIepqjx9Ce{?$vKkIc$1FST<4jL20nvZ8Gz-?n#2gC2?2!i1yz%E1ZH0y)}0fdcnQo z?xgwpgrY%MDCq8X(FGfi!wyCIDA%soYnsc_^@@^Je}r?OY&WP(>CO;u6g_7 zAJ>5$A#BFhaw?IpMeFPqxtDtG-S>tgoV45xnF+2Th2hI7#PG0GbD@a+wr>-9BHKgQ z*W?lKALz&YV@-WycUBO^9rUhpw6Aia4y8Iy6m?vw(e3v6y^xW3)>F4#@BhU+Cg#n( zXB+WVJ6;?{sAUuEiTrJ46f$6wzWI7+Yzby49>00FBgih8=U3H>@^Zi)=#uSuW;_YQ z&`FE%bZOWW*R=#LvH#7wzC=EAI8nKuEr?ULo3blXwrFoAKj@06F7gW$K%^Z}W@z z*vWtzU<$)mCI`M?yFaL8{Z?Gi1TdI$UY4e&TTZ+))h3pfNPoClZ1OCdE)AhyiAhP^ z?iWn;CGr{?VH4Yw(cM1{dU4@!=~dYlJUs!ijp14Z#ta~4VcxNOkqg-B9ycyDDBvDk zD`D1Lvt}-!j{|tW4Zuy~BDgm7hfNA3*MTtCmi6Ps^Xo%rzTE4|ho97+EB6QP4`#b9 zI>(*4cds;Sy{AVL^RqtFZdLF0)Ol)NzTzO!kTEN-n>afAKqTmTGkXR@DE*2CM`oJHA5#YM>N=aQTY`)_|F7b@yd-t-u3{DN(#j%>&CUzdGVUR7}* z!Mv}K;Kb_`)b?|4W~5)(6+YY##{_)xo&PurP(i}|blU%?*^7J?X$QPzaFX#u_cVd> z*#IxrX8Q0NYY`L&?Kw37l~So&`#gvw6nCEmI2aRf^K15MdS0&XMg9ezBjzQ&Z>)Yg z_|AN(zak>pQ2n49W1xB|8LS5xsVPv7pb2Uz7XxVoc0^ah%qW-?5~;{?{;Lqt|;`9h{S|C#dCtRzvS5cSD!JP0%`({SMbqjZF>Nz2u;+Qsk3S?W=+cG_$*Wt{z!NS*KfR)N!~t z-n_MiNG6KceJJ(13*)!Wrx3@C_8aSd}4L+@uO49#ev8^2K)G;0xFakPztK z*YXNgn)o$hG?&URewnm?&#uJK9RK22P-OSw*rskaFF0J{c=2;%EjwAj+Pe(dMS4W_ z)$~Ae8_d3gmKpS1(c&$;q516~Njnaly}~Vbfd?ty9}AH*=~+w5G%EloL*V~?WDU}W*H($e-jA@A z)U6SwIxjte76z=K$C_62ymTNUw|h^}>!OW};ZGe%SQLZG0v(i!XXLTh= z6S78ArJ4}^JuA>%_}l1Qi7CME5B|2tgu$a@7z@d8JKPj?K83U7S7-@|UC+q~Lzu%D zfTO3N-fXu?ry(-NfTYxVZUyK`50lkAaDadaMsq!w_K4hAR z={RX&KUcJ0`n^4M?b}vX%N4-~(qiCK8+vX+PB$R?B|r-4{rde)+Pj)k;Je$Mu3}?j zJE-xxu5lsQ=G6K97;!6vK z!vfn5W7@;D63!Ki>{y2T&kQXVarf?bF)ogJys~Iy`IhX0x|Z?^e7krL{s<`!qYx}V zF(Tx0-dV^)&GY%aa#VQe+I8$Y*Eq?q_T#ACk>xcjK~w^hA9}n34me8U9Dn)rXBsu1 zJJysTTAK;*xuPs5lgw~ELI_8g^LsuMeQuM^h3oo@lwWgRkJ$J*!91JfJsXRUiN5<7 z*DXg_sQZplr}X!ax!>RjEYZa?0)yIRhA#j zAeQ}s62}>9dOMYJf2UxMTr;NQr6sskqCby$G52OrC+Mr6abS$Y)`Ye`REzfWA}UOL z@WO(wjbwuW66u+rItcy!{e7wYNr0;M8rnr`TY%z!?ymROp>RO1D2^rnCO9!I^5;v1^c)B%A6W$1cx!%SH{_tN{MG#t zj4cck#j)klg0*rv=6N-l^R;xKv zwVdIA;%;-2EPJk*2SsBIo}&kXbX=gOG?B;t??}Qapdkri?bqqr+l|jrj0A4r9+&|b zaJM*(xyPrC8YLXcoM$P24IdDi6rRTq>lI4@-hKZt`-fJqgb+PpPzKFY%fS}TYTCRx z_$uM9atZ;B0J9jx(R4nhxZd^IuD1^7+LY+YO|{|6k!%#N`%w_k^tNDcco_J38G5oE zIm!uMs;jP_i(!^(`e(QtZg*^88TM|Tgd*&=%#}TH>dM(O5GF$ADKATdqkSvZ6P)oz z)kv1!p8+p|ms?xxbu#E0d6he;dCs2dwf&L9a(ZT;qZ$p_iIV#lbw~T=lSJI6mKm^B zqq-)1W=Y#x>QKOAY&F7JT!^g3&f0xEJb+~=WwZGASBefhWBnF^X1w}v3nxKe6j)05 zTULk%{mnzBhm8UzVP}R$A*xb)yL~7kHGWRE95fKhi85?5xmbC1PGMo0Cv zia^$uc5UFU9%xyEMAPnIe$36!40rqBnmPHh66z=bziZXnUTeZN(D7u-ea2HLw^ z@9n+=(sRN=lJ(x{iV>jIKn5YuZw|5)pr{@IV65N9ua~DUd{(W?h+PhQ=?~?Obk_wU>oX zo%vnO8GD45%ccKzhar#*Ov;0c8OHk)h$*4+xxz)@zE>Rl|HwM)s4Bnc%_|5< z3(}1spmcXhOCv}~cZYOKcO#9YlysLMd8I+R1(fb?=DdFAH*03iTJVp^6};!&XUDTY z&l%Tw=k3FXr^*__mmQdwfQp0u1E^H4{?H1$r;SKwM75SvJe)TnHQnji{n=c({4_sT z-{sd#9de$Z!ZzM@dPNhrNxW;}jjH1t8rH!J&WDNC5jLElZcjYhf*wg?Y)>?L<{OxqysOE0xv`wuNOBn&w25>cRI|G4)T4{ zrl3ROP)>MG?++gK$ADEnx)I`PGe0xKv(UBf1cJv2Xi^;mN#+4`Db&`Vw?$}7I|Khd zwtYbK0qp(NRx*BaKz?=GDQjp1p~4+lQ}ehTQuG;Pcd!C~Jh)=6{c*aHLJHcu1R7Q5MP^2cp7OjDc+ zNaw>1e`jM7ArfWE(aLj-%Q^ixQh+sa3fl^X%AT17$a*}D+2669|G49$T|y2ODF`TD z=Y^W(4%sd!f^F^WrBk!jNjw?tM(YGf+vY-SZI)~ugeh&W+3pEvJVx4Yau6py9=@b1 z1e+H`nHQiZuXmIo9GUwhYU8H|Ju}29DJsg&&4v59^o&tFXE3ulFzfb?+3k1CLvqxI zC0e3Bw8rl?yc2e^_SsA_YGpu(?j88n`aJc(p5m6Ng48V(W!b3!7aXrX?6=>admf1J zE|p7eGKHDGGK2q_k8W1czTy(;sGs9FMx0v zPET!rkIiOw&Are#;3E{nc?w?*hh-sRj6r-3QrCqJXjA>Uq5x|?40Kk7R}Sv?4;q1< z${h^JLL6sAXY1v4bVwm%NJCbLGz!|`$?Ub9TFwY>L9;xf;O|3p4`{J~>jqpU?#r&p z|CPRDR41#MvI^L-&1%G=kc#J95>~wD*f_%6{Oc;p zsmKNv=SJgzJ6T-ajKcDT>+^ovV-R$LN7l%X-04sP!^Om`t?IW}VzNuP5?<5hSxIJn z(sIely9iE8#C@4$OPOgwm1_AS)v}j^zq0gcu@f;eyWCuK!cXy^Gw|G&88(r_%DGIO z^SdjYZ`{t5vas@OCj+FISGzw=%w~_Si8xk88M67M!icAuVSX5Az9LNzf^>9^&cbBS zQCnYFFa4AHXus22_jMp$YqG9K7=SXAOjm;34p<6FsaC##Aj}`!*m5Bw_`KhP_ zjB>twitznFG`#bL=YD=Vr9+D7{F{UjgN^n#my3Q4?{wfBikuzPL|jozp_o1_(PgWU z&g)1MYa;WK#4*OWFS2H(Dk+ORbj#55z;`8C!(vbCd_zaI?=Ff>!j;0XWRS)FVA ztIT+iB}|ULPp+}%>ctn*!W86$dTi<;7SwbT#xZ$QOcCtDi!K$k0HzFjg0OL{O9FK0RDFq>WR~kUPw}kWZeN!ajK*31$t(~)QW(!VB$ALr{xWj< z%S06cKexnVc=~5J93j6&6e3b=M)yl&=z+#VqS~rp7E<_WEVDKUG@YzW2If3Q-bf7yo7A; zBLfLv+PcKDKJPALkzpq`l>OkaYMPRdOJgBPDMi0DTS7m$KKADFRLPY-R0?xt{0%`f zewJ>aI_B>wG5DBzz9AGL433btHIYIiOg=68i-WB4=0kH)0S|j=8zwUn3x(&ak+ee= ztE!G9A?wjJOEcBMQeUp^xONvr*v2o`9nqf@`*N<(n>8biDuy>(GZ3s`?Fto^xy zG?qL_==^}y3ss(Iko>2r(wj(+KvJy`u8ZElNQ<9nu<$91{!h8#9@Ya!O1>sU_kG^%oZv~ZTZyjo8@DK>jnJ`Y8S5=&N|Lq2k68F9nKNEd$35I=Mm{G^dgWsL- zLAykmtoiT{M$1PYbS**~JO6Zt8BxK4Q_p|P>Rn?)rl(+;_0Lve);jns08IukI?CSR zlZqiT0l=umdEk7Osdu}IPbIV!w|QN8Qu^@eU8n&HVnDZHm49s^kQ4z)9vpzNPFOXq z@j%Qipu$w~;Z~#?=h)iZ%+AY$|G)CG$kEeRoEil^IlW>C{E}NKDoh$KkBO&kb{(mn z{h)qOm76zKmt8Ih2#~@&9A91>d1(84a6~}mxo0fyeWYNS!;OiXYV1&T7Ss$M3j93cic1rQ}3$h&A zaNY#_DBa-gHaiB+sERznSo1gs2FHA55-HN$yMy+aL|j^v9%ZF!-w=;y(}ZmP5R&O9 zHxTZ>(;hxc_Ktjcl3Zguz9VovA!c3Tn_kOnpF*GMG*iXeyHti;GIGLZ6OE+D;wnA# z@fS&C>p;iPmQtZpmNhT-6s^`2iyqlmN0H>$=;Yz!ydQ-`Rrg2`(s=x3l}FXoT^Nei zd6%TWnX?>KSbfkv||EyEZLa>6yfe0ShqyGk} z{W^F?sp6zZXJ(|0jEpMw0HfE4{DuHBI{^@8;xXhHRVyp{PfwTtySjV_6z14r;-cri zV-omP-Z$q$H^N{p0ha5)YGe%s43`$n!T+b@{E&^G0zH_Zk>Nd*!G$_sWx+G2RB5Cd zO+Mh?b2586wVr{XIhjM4;u3sauj4(nXEoCW-~K)3;qIv7H`f9cALe}ZmO17-Z50l4 z;+ou|Cv^_uY*IWI!D~dJ zJn(1;8n*_PTOF;qp-h8c-*s4$H9`(MnQB2wl-uNF;$rk9Wv7}O7d+SdOjn8pC)2{b9O zn4r%Lq|57TUQ+oW7=u+8_)kzXalHo1@DwHJ4FYPRy8s#FvjYt%gmxe%t+O*{FeSNu zG@g!)<%&H)!#q&4!*BR84A2Tz)gDKwUP*Z0IU_GskCseF&J&SDJf9$LYo0>gN8PV*5M zcW6E0R5yZbX&mst%A|u)uj7exgZ)uZ@^Sy1`sHL6`TAYgfguLAifk{#k}rM#(#3PR ztOJu{In1_CbH37L@2plS%EAJyt#9Eer!`6<@ZYJ`ri68zTnpf5U3z>_#!*sbaOJHh zdm~FKT7{jWfH*$*NcpGn+E(+nWJM#M>)0D@&;5X(=l6=QTXDI3i3%3Rd?U09&<6=F zzg@TXLeq=xSuqC`)|Ltpu-kM6?8cYwyxCI!0KdH)FyqFhe}8(@sQOw0^s&LJEG1Et zimIx(kx^c4A+8d@P4c_!Zr1HWd0E!=M4`esVOYZC#Dw_k&#!;B+03s4J=EWsDkJYH z9j7q~ZSaY}TmBOhpn~TooV>dU&HfF_{9Awlmpe%MJQ-WSK&ufRJO6EHQbo4v7TN(gYQiL&h9^iW)IB{3I#O9`uWiH7I&Rx^gH`FUx@BKVx= zsK4pM$=YN9L0UsgkBREB+@p(`ac{ggp;(Z0WFydCcrc9z4H-jU&=~uv3#ppjcZM{nx>P2cCl%x zCG#?3J_!j*95p!0yqEyPuPww=IJD@Qlw6WyQbF|zlr}xmvohGJEPZnIevCG-8Y4;e zm2ob^38n9<*Jdn~Ea_nqj$@zWLikRYHh4x65sBdWSH&zrz|9Bqd`@Gp@v5j@Gl8_+ zm0!2ujt=HSd1wPaWH+H=r-fmyY`O&oDesRgJ@@G4+rR3&ma~2~n0sfkl|Lnh-e5j2 z(QymGQh{et#eDAXSp2Ff)S?G}^_LgCZ3PdFRyEdSIE#|LoFd7K+5^f{xBUx>Mb!%^ zg(|`HQp=X2ob3yEpF@yPQS>XJldw(2B0JHdi>X7_BYuOJV7S^wJ53$J5XG~+|r5UnJ>2>}2 z?L`wf+@&OS(4*QDZqU8Mn(K@}h?FLK;E>JE>aAv;2DPp7LXwRkNMy@*wyOhDZvaqa`qiip z0Td!4J={?X>lzwr9M&X(FapUt$F~Ppodpn9u*gq<8JOz(_tjokA9X$V>aY$J|HMG= z1yFfRO?B$9fNbf(?lw3z~wjz;IIUS@N7 zK!xCcH&J!o8^!6+(YP9!G*%Ut$XdcYPKVHdxC?WIePU(Li~<5xL{qj`Jjuu%yaXlO zzJ=NpmIb6#%{4U!dlND6FP+GmeeuYsLf;58zAp3+91rAKli`uiuu$2e_Qc#@iSfM` zR4l&|MB+PN_u5MzXgqe%KKBd4k&hf7X3{3}yc}o2{rvGjwIl-X-Mf#hUzbRxO-YCu zozaF!F4L6jCHC48ZIm5V@wdY0t9r}2zj}^2)|G5i9?CzKunmQ_#fP1!Fbel(YeIZ4 zLwtXOo1mjU#HC>cB2F?kEU?9Q!Np2byMfjnA-63F5FgxyUeF#(0h10Sm;=wpKTng? z8mkB(OAyfY+pTE@dbalao%SSD3^NurwIh%3KuM|1G`%H6`fuRX1x1-WW46Bf<_n7m z9F}ZT{??=GbP}t<#aPou=l6S_ej2Y`t$wwp1$nLa@{di#H4rr|F!|^Fkl_T4exkMB z$YiXnyiB7!r|2hYyG~|1TG+dtoK^TL{ox;}s{`QUTzRqQd8?Ik!uttEaA-o-*?Bq0 zV}xpB*DYL$V19glghdjlW8q2Jjk2gNtr`ClPgdnV%e^f6w%kXa^&sf0b%BG_btZ;U zEKkJm_o2KcHCzS}tL{thDS!UnW$19>Pn|wcolPWa%YF5wc^fm4ZU`HDE>&%`a$S8@B4zg3;>3DG4)Jr(7KCDUB$~UgtJ2| zlUWX!brHtNLJQcJ~QpuZmxFME+9u$iQQmZW0Gw z$JwaJ)@kGk+Jh601o_wqB#{ptHxgf|g=U_R#0Dh5jsPKA10oIJ{UR>8t)YWpH0GQ+ zl+JyU^>CF1q`&PeV1xKCXjkC^HrLfHVK*K1N^MQZ8V?xzqcssa@BoHTuj9zso&E5} z$x-Tv7h(gyRAvni)vIv->7AZ~i?t)1LwJ*ac@Y`(VANgJkBoX{MfOU^ zaJ6K?)xh@(hyAn7vOUVhY?pMZOIqHM4hfpwijo`Zx`+*BfHF?_;`0=O40*LpFSzpK z+sw^ZPJF$7tLbQdsn61~(7(BV6X_e5x4%Lwe2LLH!1+BH!SqKsv%gxO`A^236^0X_~D1~s>CB1=a>Ip`1<&_TYE(JZmv)YyIkj6EcmR^rm)-KeU*6G zok+Ed**>&?&TXNH;Vs+*u5~quh$1H4?!;VFdwvwH?Wf_KBJbw=YKss|pOs$=B(<q6Kevm7TF;0Elkjv%KNTE{p#P)8{{<|F(dIj7J*v)|#$7Wq|PFc>@Mo z59^LuHzd=#o{Yef!g@)VM*xtKM}!{)Kpsnh-FIhTr3hJ20~C1Q4sYlhc-~wr?Ci*Y z9ZcHuMnmg}!z*3h%LF=ZD?to;ZLRt+yuz6Bo&Q@Mk(&*@Yc0{y7~9*f&!Tbnz17*` z{+y{#VaNP!v;TwKe05SU9AEVjNp?7^E>uzPp$WWetwPNApX@?En891x#`N&;$M&n@3KX1X#wErMT?tZzu&V7=Z+}10ituPgQ($&=&!J ztob0UMTfV&ez{i^Ea-4GeDGGN9h`&2c`q}#IKY#Xml8PMJxfD^dNMpEf4ef$zBYMr z|51gqF0F6;YA43af3BGQ6+KfPorbv8F@@(mx6*Q(U+>H?WkdDfTzXrYpmk-P))XRN z#>f0iYmxzNH$(MBf`Meq+`oNptdw{9T%tNY#yrNsQPobvPhRhWG<3SE7V6MgUoz7` znBQ)u^6^hZsb+r*LCvJeotqJ#^BPDvAaHj&4)u^AA&NH{JIR()8kp-02%L_Jc}Mfc zf(KBw)8Y-9GC=YWMXk3!ip31iwTA|kK+$)`+Y7AXAs#Lr*!}-m)w5-kMgvSDot&Hi zGcRBMKYQSe8X)dZ;c5yNL~_Ap$X-A4&^Y%4qrrYHl|I$1vp(r?%%P?*;qMPE8Cez9 zb5&Skt`0XLLYbt0+2O+6;3OVr`O-b+49eCOrJfZxl7;_l(gcPDYak+8XBY9LVM?9& zjTto=nZaARaFrJDSm4kjpFf=&kQ8}`M)PDHB(_NNefHGvrNo?wLtY#tuqocV@?`M! zPZ=>+pUp%piq;|f@g};_;Qii3l^$dH{+#vubD78{hL)e#qZTmk$4!dj;AM^{nB3kMDg;WW>NyK*noI-_XCZ?^%3@-w3r{ zA^P0xR%kXjqQh3B0)$+q{T6Qre7(|VCu^>{&*)P%)x}ylAlgn@HQCGqMN~L=wPNUj)e|5C zEvq~LGRTS%p%}gM`p?L@yD7W276+C(ycE!ail=mfbj$FeEwS#~RGiF(P43&k1a091 zBZ0epyQ;mmHQeQeW(=q|U6)1VAi_u{`v^toL5T^+8F2y|TZ!N7)$8c>jxhx^0_Uiw z@;Ni9yP-<-H)^Bx3>%+R`B(QJ399ySFYR=IZ)G!c@L%A|qV% zOYj$|yq2I*Km1<8??rj*X+VasFV+rs>0itd;g06!$y%CpB%f^f`E%>F55mpqL3JmZ z?u&0rXytNBozN(K5l~+X4f=;;Ca_TL?zp92M@Q`*%!v0YWK3M~M)%~*C}8xstag}& zf6FNDXrc|=!&P!xHL9Q`O;a>q_RWFq+$rB~xZU&EUVm;sT&@+s9Cq7QzHl#nh{&Z|a2cXKd8QPR zSAs%zphN^r`6kllhzLLMDZp96DcN&yV|b@$;J}{nhk;SyATrQcYFYS!pKGe(E9WfR?==zxX1$&r-5 zp$^DIQdxGrH3A`j5BQZ_8p_Pr&$VI zKbl3%IR?}gedYTw!R1UxYCcJLNL^X;sU9iFLGY=VRh5hK%gq4#kjcQ|L$W5xo7C4Kms;T9a0N9lF z@Bc^s2$+>ii$;n3ZTsJYhv_#BuB4zotDLweit3#Z2e{Umc=14a3 zBHkav&|@x;eIJ)DAM>Hiewvd`&&Z7<0DQr7G!wauHzE}jc*4EP;NWPzddxY-EHx&I z`rG`J2rCV}%p`pZhd$Ltr{>q_h{V{+4x#GJQ_?L-jNoMxJ(y|kmJ#ju2DgGTAc3BO zk31PMR52%8gRi5)2>)UmZ5Vr`NVS$FIbEnwLMR%u*B3mw>N#fQsWfDMk73!9?QL}a zP4?(TFL><`u$qm9ksFL8m5%QLDg&&$`UQ2_t|t?$?|yfdHCt#Q4PWQ8 z@)Y=q#oN$sUi(5;I1nSG?iO0hH50xe#1y_|fks*_>65^C7P0{FYs(V}p(nwBuLK*p z$OXs_D1mQs{Da3ILGA(oBx7M^wNuwxSN9nt_>N%32IutB@U)5{!k$NthopDsZ1vw7 z#m6ccD2}|z_>3cw1Ee^h1|D_G)_+`gT=iGGau<%Pd_IN!6P``@$r!5oF|6Su(!`XF zX25{G!wGIf^rbeCsWCNJjoRSi+-mVEBNv4k^aoF!3gvKu6fin34H*Z7k(bAF)$jk5 z*5&zAMGa z_dobUxSuJYFU(lZa#=0;WY(omJN8}SpBz~|ggg9QqhlrwSYF#%QczRvMY1F$FZ%ln z`5|KckI;F&oxb`!pVo6EL_t_>?yvl!CnV{yM&};rdGxlgZ^u(eGDf;nAH+9j=*6s+ zJwxm#H?C`oUTJKG1!#D%CYdqlFxE6J4gB%Q%65u^AIkq!KkQwSIbDqxQQnnI;bx|kFuw)~$e#-b1huw7T_CUju!*0B6( zPJZD1@y%I`*|#SOmD_vCqRNd|$DhGa4CW9Tm=_rCPrzg}x`&Gc#@1CD&*l4-U%%~r zDI6PCb3Of_sN(P7hOR`udfhs@AtfZJR@le=x!jgJ_xU1eDPE~R! z(|A^DqMePW!~0=QsJb0iuPj$$PFb8AG~4s9jv!kO!7A$toy?&n{&@djDGkTz&bKUZ zsPN>$DRfV$t@Q8N+Dh$|vv*fQG=j}e&g$H-je@z#$+YnWe~Qin*WvXxvja`cXWTcT zHBq^As?mfn8}7wnBqrUCh>F%9S?>k=Jkis`j630lrs^5r+i4G75A8Hr_kFZ&U6p)2 zKz|cBQ4Ldmb@Be)ewpdk zF|<p)oI$)2e!d;hv3hfqv-;4nYZgGVJu+JgmQFQKw zAAl6*2E^6P4eB^S2i^ysi)B_+&cLL4<;=q!Xd){a014u_S`W}ifais1m&GHn>jmx= zNSUHL@U9pKtYQBJlz`WpM?I+>9P)DGyBFuTXr-{M~j5V2L#S5%kpAG{?irIy@z)k-5V!UAT%&3zc@Cln^5Ev*#M&G`)WH z`kS%K>|b$qM$pW00P4V@Fz-`~??mFg(HG`a4$3Q8Uu>ve@nP!pc{`jB{yK4;eJs&+ zs?dF^K&|N__k}0LMk8XsGt^d!^iQW3_X8bDp=iBenL1CI)J*AD*rjsb6E+)I z!xlLo zb*v|3-BL&3F>cp+0j?V)n5PT(Hy{9=>5ovM3cecn!Ip3~AHj7l-imJ`uHH8_(J%FXRi zByw24nXK^X0rrcYjF6=y*a+qkq^0hDW|0;QG~3RqDqA=f>@jOQ9(1qhJL;{q(m&jk zI+7sqKXx=5GJ$nmI107388C0jg=?xgN_sJEsiJh5pluFUl$+$xE1+H){RlXbg%UTu79?<7peq%<+CtlDL@|ItFIzx7=aQ(J6tPXsc-SL0nA z2dm#>+D$VW;=f=#IE($!Nu0IR=W9G%kJYy{*`nWW9Zd#U>bLa&yev$3-4uH{vm>3T zr$D0-VH4SRPtQR`*Cbj0{=ufcjDdWRW#U2Vz@(h5=sG>;pi7}MZW+k@ywM8o8O_ON z+%c(%s|N~wakbu?J?y5iTwzFacb(gvF6j+TQ?PuysJ?#q8U0j{kiG43_yRSPWFh2> z1GcozwE%4Ts?hhk5Sr*^c$DO-kT95bxT9)T>%aOc$valhvtmq~D*EOu$)?8Y!B$uM z2A}T*X(C=sN41=GuwTxFFMOEn3G0+_W~#|Rs-6R*(cSo%DmQ6yuaIb6WNxg8gxZhK zYn%!2yD-Cw_1s@vNBnns5x-RA-9G4cjRgQ^X@oweL0(S75BPsYbexeRsK~eS~kITAK9T<>pKBjhKoDu8lQ4 zj~xW<;B-tKuddMHE(eNVSpTW&9%kN(c2vB77QvBI%$OM5pD!w(p%R_DX8w4S2x*%K zDBWGEYfKoU4PPpHwEN@*5`Il)%R5z3d7nrXM@kafIuJLbkfGgC@_0s}05-#riLwlG zjCB^?+D9>D0$Yy6-pxJ@jv;W4(eP2^KSK99LJvAZ_e5nm4Lu5Q_PdT(2u>a=sctsY z9n8!+d@&iwSU2^L-yk9Q15; zx6q1@y=O}(BN`Bpc& zl$@{^@fI}k79HP0o)Q_c)YjxwK~lb-73|lU#$com8l8`;*XALcZRpd#gW~JgukcGI zH(liSvBY4zP&KpUnHg^TvZ9m}Qj+sW^58F}(CQB+H)1 zmyZS8CjJrx`J9v(7xNXo4@_5s`?6_a+-G+)8mYcLd0;N zKRqo%-bkf3NU!}R-8%#J;u7q@kWwdH9_D~B^1x}J(F(r8$ zoAkPxRZ^9`Jc6yve(3|8-Szx^S9?+ZZ+m8iU2;X`W8fpO2`@Ib_L;&KT#KgdQNRUT z(XzX#=8$A;nLdYlo6MKli79pqz6qZxRo=4m8urfi zHBCreaBzR)dTnm$@7!PIE_OBFpuLOmz{Nr(jbBt~(`u%|bs$z(-d+jr7A|ME8f zWuals9N%L3U%mx~4}=LE39K^gnj9*H3~niTb;P{yTY`c$USb))HYThnUwOmdLiU;u zn}3ig+=M>D2tD6L`D%!0CPer_&w}J0p|cp(!c|9qGv!5LTpdLTV@)00=4=)^Hu|?Z zQdd)QM1#67m0B@sF2Ab^bY3t&20!xCHxG^3LUtF41s1^M&P8JhaH++_#FFP-8g!op zmNzZhZtr+5z0alHb>WBT9-xdTohs9;2_DOnGOBXYeXI3s7(r(`tjDn1@aO|WU-g2; zWL?r>nwtm>cy;ZkaDI=#)oKK`Gxw6n`CTHxdhWk16|ir|?s2-QyY~ReVam&yR*p0^ zHD6@VJhf@mE}y~=M0}kc{A9em5lu~*PFQEmz?p%lOL(NqhL!5Ey zj@j}=Vew|OsJD)wjF4R?qmWL46PzDPHe&lUGn{2-kXSscoB~?H^Tqgu+Mi14a8{O$ zP0d=3#ZLO%r8MeRO7de}i3phQ=Imn={Je`KYt2sBoJu-j#VF)vWQZ%c?;M)k~7HS!shsuGeC)r-ayj<{GQom}*?= z%IT!2Y&z&JPpj(8^(6M_&8N;gtYwh($KIINQ*N5N!uHm@6gHVE@hZ}^{aHpKY6FB9eFTZt9S*)<7}jZBfs_H*4$y{5=KWb;ueO=z%1|(ixp?@>>>Z}h zGV?bDAiR_SA9U6lGH|673qIY}97sXuF|NGY02#2TdAtE=&}#il*f#;R(Ev(YHJBw=_GNV@snik?*pS zKNxRgVmPu5;=U8G_xR}0;&`*cvVyI_S$@ZM;il2pV0KfijqqVE(EBB-+sSb4S;pPt zd|mX<^aiqylW#A?pOW#8W8mmd-Nd@c!|p1GFjrR32k??Z`z->XUAQK&H^%F{ts3II zwYAj>EC(S*-krxFuwlrTNdRQs#}rgl0l@RYN3a+0tvUe#WuEcGO#rYueFUQ^v{7D+ zvCO;J{q0gCul89cik>DF-O6Rt{2&w)^8s(E8?5zPmgSq)&0&`a;2rR_3TX`=HQPXE zOpJxRqTGq-Z~uf^dDPSzH{XE^Tz234?chbfq_!ukyYk#Oqq~IijJ3}v=1&q>SE{ca zKHUDy6|9HeWNDp=6^@n8mz@>?VmdmDyv1)cw6zDpMLA~BG;6({6G8?|R530|o~(Gq zQy1&>)Vb+JgjhiVOs^FXfdNt&EtGuj8YX<-VbidP_yep&bwJvP^BWSNz9R&{ryQkF z&{H`+pSQc1ZVmj#tu<3khEy%i~$e@?I~rz=-$F8CK=WvKhV z=QO!b-I-_-Ek*0F^{OMN8!(?e=3IGUvRNj|DHFq?uD;V2RcK3>VT)YCNg^`Y z<((!et7H>s_FATXP-t(bbL`x#lNY6MHbi8pqIqffGx}1oS=;oRO2em{4xPdA2)1F;Mtp%;IUDft1-h=*Kx*;ii!g5bu#xqSTu4eKdOvimtc?3 z4s<>2c}PGjHi^ExF?Tuo<|kDQgh{V|&xO0fA==0i*eP1Sx73f6<@KW%KI>!a{nL^q z=fiJ7%R3v65y@=6>t46ID=Cc{xZBz?aWBnWG#nwU7}AzhKxu`y!w~0mrN^0NFa~Kq5D~4` zE7fKRLjXrFAOZD=S;8S z$;5tjN^3po3#BO5K~hC`D(RBIK{{6=nUNRYo0ko?m3`~DGg6$-R~@Pz_Gi_etkWWl z;74DicK4*_tLd^%TLM#dm$ ziV<+{4=zuxt{Q@QoP?$(VX}@3Atdrl-nj?2BIJ6-X4w4{dUN|f(}VN*jEN;G2a(Hq z_6Jf{>&UtP2ptLzHHpfAT%Z1I-9Y2^F}=+Bwe-nXLkruB+2rgryt3>P7b@BvSBGi? z;Sw?nUu}7VDr}0TbobuaS$${6PF8_^=SW+5iJF2p%tFMcH2J}gU22eGIMJIXN=XJ+x3wMxWxj4(YVY^MzYsW1JcTOz)qoI z)uoM|_!+0@vnM(1V6asBVfyq3cpwiViRIv-6;{YFrcfc%5b$TgHrhA6jU(WsiTr7B zQ10m1kHSeTo?7MIJ1|Ai*VwjKc>jeOd+*^>+N7z;a3{THyCwXJ66|hTbuyOMi6_F0 z(co_qCjb5qmdknC3Q8(gySZGUAqh3k?HxGkm+ov?MAl{?*B;Y287XXW$_NovU_t2^x*i<1YAH)mN!Q;CF^ ztun|V6IxT5-a59`UlUS&P{k6=93*PP!$%zyIM?4TREC6NXAc^$s3o+6NB6x`c{Bo@ z3aSR~w?EQD9vMl-!Hu*m6PW`_7vh5+PlvejxA?vxX{|5JUe)O=dH7(9*CM`HL1d^V zO@4_`*ks1M3MGl1J?rr(g_BcL)xgOC$fp#5A{`7{fN>s}6hoSi+1c3*&v1YHKA=I{ zpw3u7xoQMlzu9JItCqjP2GHsmpz1+mWdPp<^tH!XF%;U?XkB33tXg-{@KdX#3}lW( z8vOh}{-uo`fGoavePaMPxtY=F>}Co((|3T~&|pVCU(YEh_x+&lh7bKGvcG*WwG2?v z0~_s*!&*PoqFGXxa&4CMC@U_kC?{)rb(fM1tUSpY{p%M(i%kV<7-#|0!tS^-@r~Qn zLEdQ*B}G6l*DA9VNWRc0_iAE_3t>V)p#qc_$rOZLf4W(C{fs$?rGw`t5LMBswpP}+ zEhSsB=T0NPPDm;!&$)ei?#vGkiig*qY?W~$RjY?j+(=>fWtDtIUv=R_eCHh8`_=Z^ zFGd24+M{c{m%pi_Bu6(ad7zqmY&F&}(OxV#VnP6Wa4&H$d)17r)RNyHhJY;mBeX6H z=o8`gX%yPOTWy&K%G*C9IO0{C-o1WbdKJ1TG5-n$C)agc_g2;9)yVysYwKs;`1$hh zpHtrzBBl#Md4K;*N3P{8# z;WK_^eIGWk3Nw+BjPG_%1fj!ztBLvxn^c}M#LqfuS-y)_qVsv>3I3;nWt2NG8wUPT z-Mn9ND72dgP1!L*0_@%N=YH05dY)S!pPX1&@6MVCqbp6Q0Tp+j6SA>pCE_$fT!1BtjhfLr)krVtlgPiPY-Z{n`vJd zY;Ul)KGldf=yw!c9!{8cNVW60^}ZTGDf~JZAniJWFH;&*qUI_y>3mkS!l%i z1n74O85tz5kzFhL>w~FYz{{p=?dD@Epq(axqQVE5W}I5+ff^Lb(?%BE_)p5Uf6!V9 zoA#t(&U#wne~pq@tgmKxMZccfexKw(MQcA_H;@va5HgZE!IY0Ei28AhhP&Ajtw4kG zV`&Mey)fq;&9;$ABG;c2hc2J$9ZYIf37b+PgU^g%k}@;}L39=~VlrK1a)rx3Hu|U- zO@uVtW*ZsW$nKiz?&QXFIP2<-)TkuAOCv=};XvL4OA3~0rY2iM1FWCoBWxxxOwUtV6Y_zaqR=`z1+OLSr8qt%s{m#q1k zlP;K&TNqbcFd`^3B^R&4)+gVTmaWpYR5BU)>VY5zuRR+%Lrr36*IcKZ5M|PDF%jv! zQq%{l-Ri~Kts~)1dK4@vZ8U2(^@?WdxJD-%Ju_QNOsTBL;C!_z-;j0I(@7g77ov^N z&aQ1mfU%RJz|j+M-w50ub|Kq9l2OQp0>AALp+GM6*SuK6NgnxK5oZci>)rp=yANt| z+^D~)bOH`0_dw!w0v0opK=QcXdZGZnF{+Q_>GB-02xM}(ztFVdN!01C-!T7yTot2s zVL=;uX;81WkP@Q=&9r&*gDc4FXDp@M7lBlesDd&S$?JeJ9F)8P8)nTAh;a~@s&)XHvQwWB*}wSWggiZ zEGeL?*g4OEFku;ci_H`w`()x;*%gy!gi~jF3=LguTA34FUVV%MeQ|V5t9^RRsq9J^ zSBJYYg|Ts0fy4#hHst2lz4ePs3#5_{X(hCEweV*e@A@304OHgPIeJTYCSw&H^fA>| zo{Nm!>%nT3tdxcrG-X^(*nhEqUXe*)m94)QW)^+MHwl&=fw-u-ec#UALP8nmf13my z9YI$@LRQuYaOi=g0iHrDJi6XzY7ln7XEvGQsbE5CTA!GnTgpy(n;)i-Pt0Vxx?`gk zd0_x8YjcwjkJF2+tk%PWKheW$5!}K*8cP`#Y&}C_iKq!w*=LnAHGjS(Es*B5sZi9$ z6E3H8eb%QD?r`iZphiyRTs<=N+EOb~?LBjp&74IVtMp_Z2iLBd&LPFl+k5deM~1aK z$3B@R#KMKzC+4CN0xGo>HOgSG`42V5E7PAp>{3Aq5Pq6&$T-k8T!H}62YfQp z?RoZq@6F#ybv+X>l)A%KurfFQeYKH=^!wqi{Q(B_tYog*3JMs|x(ei}2vp93Hx~yR z09fN+P47JS6|6=MbprY*FFHjJR5D<_K zfdNE1r4f*3=x$`_?hXY(x|D8^7`hwjkdp3hNu@#Hp7Hzt?!9ZhEEg<^nfJWsJkQ?y z*_)9&)s;@Z2|a(&qkma!=O-o}N)vZ-MY=T1Y)S5w>W{*H;_HGX{~ z%&xmmxSRBY^$5aPS@4wVDN4yf%fw-$T(#bE3V{j&9xwB|wE{7*|IGWYGBQ50CSr_` z4r?6V5Krs*2p*NVC%EVcZ`yAP{rH&QxX68fiF|i3>t{3*VR*-*{tD-4$$j0`1`=kY0ri`TAKUOFVl zMME5-bP?NGz3zm|#B`Z~0tCkh%!VT5mq)IDJ3gU%05Bafvxi6lf0~afD(uLY25jyx zt{>Yg00aQhS0ElI5MT%P7g={5aizYI5jtUE3gGDj0G_^qfzI{kcBxN0K8cQ3GmBv{ ziExE=j}dEHUFk3EgsCw-rDByp9a(NbPDM(ki&|E7+gKrqIxPi zGJD_}8y8ntSZJhq-S%iAD2f=^s_)OwR=C6)5$-RxMp>CI`+sP!Magg>%^~@_c`HmM z%RWvwyg#l>wfZU+vhK(aYA5Eag2KW_e$&WYMuwc922@p{Rs@{m&d;D$+DjB7Rjuq8 z0aA>j5d17!#Q;WW9&4~A(UIprDKcSIHL(LQ7X|mcqQnieSvWZrsZe*}HCbxuvbYv2 z1xCw!OU*YT8Gzt2S4Hm<_p&OGcP_-0r*xnBzr=VbuB81POxKm_?%1cIn!U>rY>NNf z{a)a>4F#|k2(>wwo%G^X62WG6kA=i=d2=p%?Uo1z|hUviVw*=1&O3ui^om3H#a zxVS$Vr_~)!NDvgAvd85P4jUZW&SUDu( z7UfONM<-`X7KEi!VKeoboUPYhK2aEO28Z8jwwt`4F&O_uIuM>Y?FKsnGKg08?O@^~ zVAAdaMs^C)($e1tMX&=oz@7rS@a+vvP$+@eo^ZrRax(Gx(Z76o)K8+QM>(aXkx7FdEJwG`!)6CJfIU~TEDxSU zY}>AkK;~9-Twzg(SS%3Qn=SY!|7!w?zBKl0>LkX$cOhlZ7cu<9=7JDiy=o!4y&D*Pd0k=g{=Xi_5UY?6eW4qPW+V zIMJ|znV6?WR8-RDQWFv~v(A5B)W)|C^W2ltg7O=CI?#5c<-o(m#rC(TB_Hv#3K?Q! zH6A7*-FQ64O7jF}1R^&xJR3I$)&Y=hKW+on_O(d{(;J_;+N@pq0Zk<>aqR1ifz9mJ z)>g@T+M9soBeT1|SGq2fY9Por6^yegDk?@F3t)6+78HC26*m}4?+!%8t>3R4kWx^f zSV;mkWCkcer`fA*nnG)BM40f=@x#8=m=x60Vm~x0PhnjhgpPwsT)y{fLPDLdpzq&H zA&O~M3NZ!gJL$+j%_CeXtULRcB22m><)2k5yuv>+W(Y%zJaHjDz0G zGGhw|EeIJkpW!zFl}&8a9Gp)|{NaT8bwe@9b7LWRlhP)B|KZ=TghPu;Xjec)~4>Ys#8+FA%A)wCU--`VJeru*SX4?ui&=SsDK^#fl`(|j#iG=Oqclv zi)pnbYRP1vb%aOT$v;_2En%KGsC^10WyaNz<0Ox1MYhg6;&~FaeLZAfo=95A>Dj2B z)KK(LK`mt;Emocs5zYa_@#|8Di4CD8UGW1!zNW+jcxdtvYkAg3WHcNjXyKrngh#+Kp;15!hvR}!F zQaB?*0Fe-}EG$mg!-?!BXrSbNvI1<0R=PrPx7|cLccsE%6zW6RgL$7W|ir)PoJP4;t}Y= z$PMnpEWwNsVBqmEpnVF>66Lw#Knem(!lMAWLh>qHwKfaGHt2`6dGLMy#-epXy-h5; zmNpIB8@{-nQ?5*W(RiADOs|gl85l*)89x6sP)@xzWy^Xn1oU(5DAp9W1GIoMpDS0$ve)s|3@d`rkA~ZdOH9~Nlf-4YFIy+Y4swZDE7`+40cme^a6`@ zTG$N(W9mSAAg_f)ll7MPuxXc4!Zf^X-NDc;S@G0B%JY+A+ zSDQGDdOWi?{61&O-$8vq5&bc~Sf`bFLC`zZSkwU=msK3@H1AJL-v)@*Q~GnO_Xu~P z`&IJUlmLo|d6~_Hjml*hb5PGn&od-VFl0sm)~bm+s4^Y;HQx>i0TVHi zps3vQnNtV@HmjbVeC>wOk`z8)K$2eGfI&5obRi65L0|}ik+cOa(Y{H+Kb1hKAB;(6 zS+~ELV6gS!2|14f2hK2PxB(G2@#w4;D0z56_~|MDt{ejB7uk~J5MwmW%>oipAmNPS--s=Pj+Wp#=c7$Og}Txp6Nh*czpLeSH^3)WGvYhsbM_l92%uJP(Q{=kkr0 zfZP@_+yx?8L&L&uN;+Hxe!tEa1lE!WD?p-hW3-M>ZLAoe69YD|1<8Dd$XwvuZS{DP zuh3Jb`rd7(!Eu#Q|90cWIoTqaTlg$&l_BGX&%-zmxF(R7k)*Vk+1R|7K=Om5H=T8O zu}M$6IE&fYL=;+DTK$xp=5iL3oYa1uUf5DsPsf zIC1F*4MTjL(R2GM57q~ds8I`dc}kYMg_n|On3n7AF<7J>Q(TnybTPyvLGWg<(kV8v z%yj;8fbd2#!&{tZ+}##y?!smM3?6YT zN7Ela8%9(ks6M`ooKHtk$6rTqgA*8r@VN8<#)Hxd3i)7AaeSK|2$FL$GyOrNa3$!k z0x$0W46vL4&bYAmq!G9Y0A-6uR2{!gvwd>!IwkhgQ;+43FHd#lLMlAwY1NDGJ}*kT zDJ!NZ_;6Od2Lbd+d#1~M1PKCCra!Q~rG--EIgCm$10waD_?o!mPM>ZaTR^DCDszV# zHS5$Sv;zg>X5%@UIl?|4g3A=^+RIyyYp_nXgNXzJx(c)hh~>sO*89z?$X>{_6ldiUvroa8Ul$% zz#oa94OD=A)%njZ5+EUDfZhT7IFJ1bQg?TE3))YhuLNOQi6D_TN@foIqrHWN1uk*f zTCzJe6gx0%^vLht3&GGMA0whNfSXy3&Udhef!-kk4)+FY7Yy-UL4$n|lpe_P#r0pl zJFlCuPJ1E-vf2=lJirAR2r+*HuJCMq))~@a(P3yx_!!`IKsSyD%>sZ);+)G)-WyKn zdX(6L=a+L!@VCkydE5lQ~ZMT15?1FQt}wIV72{Ux(tObiR$3J2>~G zU6@q!FY*c8+egxvS0oIY@J)kRE{?72+t03K5}}2Xi?VeTNIc9*Sy9ctAe^g3a^V-` zu_n-e>6mHJC~9FW)Vo*bP;ZK2^lg{2219eSg7`6hXIp4w;hr8cRHVk}P$0;|QQ9S3 z-X0%FUohkm^RkGTBV^$Eiw^u-#e>6_Pgt{3|xI+^A;YS<3Y9QFv4z%iPH59LmG&5SJAT z)WSu-aWU9+aP%+P?!#*ADNChOsRbK8{RE=_u$0(|%EQ5$vYOSG>Dj`Dq3X`O1dIE$ zJp1H7QagDx>mst-N--xV_y!++roxRe>5%HHj6 zEH7TXcooVH1O#eIv!}bJzbw}@#DFX2U^0-wEZ?I%LA&TCGp^9Q>N&XYs`q_b;1MUF zSuFUsn07aul$|tq(S>%#rd+9{C0>wfxtTx_RcF)2VA7MNOL7HK`B)_*dk&Mb@8DbNspDo-;RBfj8U;t#-u05xzhfg~(SkaPp&^?#!L z{^oQhJ|TDaM`XXI4D|q+7ZKb0cTHzNrGwB}AOUZ(IE(STGjmK3FUxP&dPNJ~u`gd; zmgLLc{9AR_t5Tn9NTxVHO~{-(6(7D7`No!IV}sBCX1FD(sjMjq!;jXYf7e}*S=5q@ z@|#eWrDZI6CqP`LKH4PImdaL#632$G{h-|$+Wc(&-mg=H_-pBWeC=n-=kaoZG$AlE zZk4f8GtnR3jJKLlraM7%)Zp2$-q_IY2|t!~1XL%Q?Me1OG>#4cu)wXq===60H5~qD zLPg>C>9~T59@%}u_wM(r2*);H(nrh0bU->{fBbxvGYfcWYh;xqF~KY-@1$48Oj=|`l0CpAGUE}cAL$O$}_&)s|+9od0Ai5w{9LYi9X z!1yh9wpb8GR(-vDn;#~E&*NO=2VD2taZXieR&Mh{6Ql>0z)mHi=*=khX9FldFHKUC zQ~t?KUHZ1v@2q-bMtp|l=Jk14RN_ytn<=ZjEX`-ZO@f*Ri8xiDL&fSb;=5V{;LjdiR4=JEO;?w;IPNY?WJr$zGa%xPO2>?{KbT?gmE#v zlMt1a-U9B>b0&SDJ|JxN1%ViUKqMy0@$C`FZM!?o=Sh>N zig}7?RS=GL$d|)zt(}Nk33I*-*qmLRY@-|lw}w=N_qiZnD_CA1u`#&*jKZ*F3Z#7`0$)BQEv?xiAD~BxPDtnl+m{2+V*@Kppp(e|2HlyRoO+i6 zL=(d`KwpIr9RbObh>;N`5_l{SStWmugN64Mxw1+!ZuiZA8yvYgJZNgR<|kkk8UPxO ztl8*H4_IJx;S6y}g!~cu->4hFRVN7P800af-ZJ4tmK&Wt7Hzj*II|$Kko)fV`u=vy ziSz)HX<9RL*|Ys!?EKgPKqhu5mLH>Eq2v_8wVluvp;0dS#bN1>CLz*bpIE7Gvgg;G zDGn(5A?}hJn8QVa&^OFUS>&(7v^y*xtGCcsySnC%{Qrr{^htOvO=^7beA@Uu9o16; zLUE<~&3GNeEHIL7UCMK6048hC5wB^N8zO_UxXrZ6Wkw&ofg(FB&mxc!)zVih4P`~& z#EwR>z=^I2gEXvV~_U07(k;KE2f#foqS`@0-@Oj=KREsz4LMG4gReCep zf1h&anj%Vk-_$KguE?oqAcB$c#W3e7DKC#!D^gd|)|LSg_H~P{B=Y%AnV59CZ^530 zR8U+DLK{<$EKX(qzd9Z8G~{-6>`8>6zXXc}WJfmYp@RlDF#X@5!eanBqvSk2oDW{l z<#7W!z-QnvAPi#5d@=Dcf|9#*X=c}~gR+x7$+H`let%;}|4InQEqrlnWwhxoNh!(r znv*~){+QN-P3K*Ww$aLNP|*9pklifbGWb;Oqk_)EF80p=zj`FC&x~(wt?jQ(S6pGwW_SZ9J>}n!)8L-T_C|5l75NMXp#bY5o$htm;EG&PUCoJ5lYvYf3ZokBb=xMOp+wlwBemWv9{m9` z4ONo8cOYlFJ@f?wNKQqJ$g~KD@ci54|T{1)G%30;WaXPP#wocc_!90_yw#&pgL)%GYGmQ7$% z)%4!L%~7nykzqwLCCp4gmM*6%5S@JrIw>m7+&veW9S3)_ZKXyIfefl4^=!)U(! zTwUuK6DEbwU`~|K4^ZgOmmuV)4S+gU`oi&sr>d$7Am}uJ3vEd+w|Br^s?0%YkZmhlUC2x@U-_*M%)I??GF*lIZVgHgxAjR5xZ-X@?=usDAtj982`>I%2R4$CRx@0775ImmU+xWie5I3CNJ2~&eJhX42NXs~3h#^NLrYxgw(ONMhOsiWxt$hZIX_|fy4-ZmkBr}V5pJdoB~EnL>l(Al zExIx6L8XRR+bpCzY!1%OyA3FJ`RL7Y+n9NuACRpGcP zgGllPXEH)31mt228NS!_h*`gr4PBYrfnM+e#9 zWt}77#13p7b4k-=#D7D&P}`_I54R#XNf|}_%`Z<=$9LbUsR7+^MPdnt0!e%Sk2|aa zntX^;w;IQ6rLWb(i2S2qv~q1G0ncr>tAo9JaR;qle{CL|EjK%Xp&U1#sOLm2SOvSu z@|n#38bCM14cbe%eco>3U>>qhl9(vy|0~vdEM&wvvj3H9w0V*|H$QE*#})&`_1-*{ z`1p`o%1`buIY4j=7Y%&5!(C9*J`+RvWv`U_mq>JpeE5C#>t|bMKQ?$%d;9<-6a9%d-{0 zT5d1WG5hXSDEar-PGOBf+IOeteka3?e)dPtE}U+^zFBpx*AcVqKhJ^?5e-dFSSp@! zf1Q(Ar3{fP&NmIo%h3fDBL>R{s-PUHW5bGrb#yTwQaD0CA54JKEAHk;3;bi5C&4E9b) zLG6;q)3ueob`n-L2PSWagaX}P2cSGP^z2&d1>^PQb@qs6?`r#19 z;@daQ&QLqF^j*FnWQhUxJD2Q6jRpQ!H`c*q3ai5!^z2zYes>HSZn zGZR596nf-+3zG6&6aAWR+|J47B$XD~BBv=tCY$aS^|f?{?ex7ur`7*{^(wu8uOc;c zNGte_K6k4UvR(6<)r@IK5KEhlq*vj0WZQ5Y6|`f4i3 z+qy=leDXkI?4zKNLa-65QUtg%WpMIo(0hltBa`POoT-yQarQXob4hAjYNKHWMpKAH9rg>2xJ6L!L9SYrOa$Fu^rg)>(sq?Xk;iI z8#sTES6X`Ltzh!DUY9vfA!GP-cbuMu#cU*9kd)84K(a)xsHjM*&X$aX+xjJFR;A-; z|H-SrfVy?K5FQGLzoUwA9S}!!7(g@NeB~|VtVc(PfocBMrtcW&kc5(2_|E|WM)=sv zb>Adt)3MbBXq@)<6jYS;7mRd`3qF{|--jM8oS?9)1f6>_+n`vkX>WB*)@IKp`D^uN zCgoWW`e%^{S_aI{vVBbq#Zf_hB$g=0uAcI&X!7Iidm%TqNu(jg&$}Y3)Zy>n@kJgP zX)@u2VTXtpl$HS@5^1e$6R1}AY3N)ic?;1)3Z9Xc&9{%vMc}>Jm)Of)`|;|i+Lyl- z-uueJ{Qkt&bnC#|cMUhqR)w5#MRU>Ymix)S7p5vl$p66)O#hnPxBE1otj?42G-qVL zr4&DVRIvE)=YW;`Ny>Ek+7XbCAMPEkClgJtx_b5JfmoqmC&e*@Oc

^*NhzaC>lf3aYg4cd#~$LTxd|lgxHPRJS4s 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 EAF^J}LjV8( literal 0 HcmV?d00001 diff --git a/PyTorch/build-in/other/continual-learning/figures/splitMNIST_schematic.png b/PyTorch/build-in/other/continual-learning/figures/splitMNIST_schematic.png new file mode 100644 index 0000000000000000000000000000000000000000..72d129f844c993da2930e989fffe076729ac7e0f GIT binary patch literal 128666 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

bt)1sklSw}~1`G_wZ&bejuoaDey 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 literal 0 HcmV?d00001 diff --git a/PyTorch/build-in/other/continual-learning/figures/strategies.png b/PyTorch/build-in/other/continual-learning/figures/strategies.png new file mode 100644 index 0000000000000000000000000000000000000000..f5aa4dfed75344a6b12d360e3e82b9d624af4b32 GIT binary patch literal 330887 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∈$ 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

SB@JFdXA+Gm3q%aozjkWAvZD>IjqR zGKVJ4TlCN)JE#tN>WRG2Z#Yk_V5=F1PTWnqvpQ8{Q3Qye>D}W9Q6uDX|IZ;Y~ee^@G#rkpA>n`)a$Z4$2{r!kkX!kF zJRb2)m(z~8?O-!?{7`r4L}YLboe9oxe)=rFw?Xsu^{Aws*^^QjkVoT1g5zB>Il;uj zP_8*~qOg_e1K=3LY_Yf6g7&l>yY2?F2_-OaBdaGWUf-0pU{_*}bT7YR=C^}`!7ed! zRm@sedb1H!12Z6^lU_mRt$|D;$M!E`YptYA=+QFkP9XGSd`?`7#cpFl4m>^f z3T`tF%!-Kth|8n_R~lZd2_9Acxc)ZP9xjQ7nf4cRreN$5EWzMhw(x#2Rc0m;nzw?c zEV%tMvdx=p+NWsPa#5?y0v-bijT*$>>LN;^Nm!>ZVHmRb&z#%25;ZUWq zI47G8ndf&CVv^^@VC*qFDdt)nlHNz}@#>1W->{awYBsiid`~$aY&i{CJY>9ec-8Li zk9#G;#hoM4WrZZAm7$&BX@8?Bfo*ax!XGKNG*2$R*#{)Ma` zaWyFCZ-dtLVWsWCZ*$qf7L_q<%u}?%P?g9q_Usr87DOCT`ed#^5$OFS#v)*aYUV9U zup?^BW|WTtTMwJp2RgP7v4;zgrViv8X;-X1hf+(t#4uc~@?>hT!uR?|gCMnw*FQQ^ z9i{UIwhxx_qsmb8&~tIQFyG35Ch?7EA#K6Aw_g<0XcZ5RDBG4pF3tr@_O$j)6DRLl zY-?)}C0>{BV*-D<>sJbTqQGulNViux?EjwvMU~Lk6>j)4w{uy0-s9T*P1Q?n zf;Y=_^-SO9N&;U6-s^qCg9WmHZO}d$tPhwu`;d=nDGCyxDm=QWTA4s=GIWANei2^S z;;_{`_=d$UBP8HX0e!RY4d&O|nfOY(vsGT*<&eXE#=QPZ=4DI4AzZWA8x?UZ*oYff zw7!yD|AgYt-dh;H>#UL=jZj5BvdqeM~TC6(UbW2nO>&4_iV&jGfF<)gtAVqhs_$?v| z((l?e1h`y%LvCMCL4aAGE;L^4G&ScYmbjudQWZ&TE{e@qrHOL3xVQLz@)pOMh4oH!KzmD-3Q%Ap*!l}rXadZW{Ci^7C@i9s)5g}%SDeMQ57 ze=z1>UHYb*+GJV!y}{3zTx({%SU^n2SLo~R2y#JQTT>EHKdBkIfuT#EEU9vSVR&tU zEExzh8ZQOA&?QDl2A2hs9U%fKa{V%FNEBu~W*18pK%#siR?w!Qv0Nm9%LF$9;O^^i z#}a6L0{kK~OhDQ+H_*>${{v_GG&67FsMuSpyJi?&N3DOeE)v(bo4NJu+l#XfY};G4 zLiW4bv=ur>%1g6(2_j_R_gMgic6BIi9QhaZnm5HL>K<>?- zLH*iOa(17%{HSD@+dBTYOdh;#)dk5mT8sE6j2| z=Ks%5>95PK8R%+4;E0Mpzf$kdF&JAJoHSfbD754)7vnoPqnh%4%d@-1|Cgl>GClbh zx!o?PO8>qf<8lFB;HF#;Yh5=f61`lt`sC{< zK*I!{z@P&JB(ZI)_DF*NqJn86Ze0SvlV<0W^UPL!Sr+M0~uK@vsD-iHe zA{Enu@4S8R2^`^po^L|`{M>l~aGNsa_4ms~)xfT?(9o{463m~=s~-R6+LcT_z-Eyz z?O*db-?>6(4haj)#GN7t^Oh39kmxr{bzF9w=bD~^jr5SWJe^AQ6p34Z$DkvM;`rO!=JxYLLXCaDaOz@2qyT)mn%0%u@x32HO4*-W`B_Z zb#@ADiQ?9nHnF;8jwqhdm)sH3t29p>Rw@Ng8)yC6zyS>Q184C)!|TC)aKgN)*jVRG!jz+WxM}BW}eHv zy})3+ddgO1M>MGlM7O4zFQks}>aKw&vos3D-07lC*oCfXSVxCtqY~l6?%M(#D46{t zsD^*`XcT&sLn;SavY`kV-rrkIb&JvA} z(ht4gS(kgHnnG2h{(g3TWw7-NzWu&u-O<#2n8ChTe`|^u<7uCAaT26EtXM18Q=GG> z2S*ardN4(?(MLwIKjY@lwKRvtSUV`GIj8Xa zaMTDTt< zaaS0=5eklL%rvf|VO@`7F!_rgG;VSBF-4GY&aGbPv^b&D@}zf$wKv5&UtDJPcIM92 zazQM!Nn$8Rrc4->AYAc744=l(3{!d`SuhFmFyk~pK*1zKgt5EfQ;*2@Obi9e=TK&o z6+%C=1c+9%2`Vfj&5w*Pv6JMP)STk{YHnLpF@xK{fXddCB4M?v$%TZNNYF@lk)5r% zsIr$O#++%%ZD7JoO)n_tiJbmEz=K^R5ow4t+Ws4PsG>H!Ay!|rQBP)U5Ng*ebaAaP z2@ULqYXc4%Ch@#}jyU#`?mKFLx;S@edWB^RzV{K6^x#uBn9iw#L84NjKxPY*5MyU} zT4WCMO2jIu-uN&3ls(yU`ugK?i2zCv&1s-^>l0bZJ<0|gF&44r+hUU0 z88vjDlP5iNu_N{{tyA=0pkg-J_=iJ2P1`S>ePdzudq|V%DZ!Vuk&4HofM&;c-K8tf zFT{aZuLyFA5nX`tv13#r^SeZLq*mkewo_S=mB z*a4g(6uE>AqST^xq1ZEkR7=^Sf?i^ogT*1d|CqHbcb1XXtv7B!F1{p} z)JX-ot~8evHt0qWPF0aC@u!3yF<#_(DFQ^5>O%1$%mtAYcBi!SH*xk7OmPY!B2HFn zvFqtI3fVHU!lD!vg5ffD&(D(%7JEGp#peg6C73i!B3d+ZHlmsJ3c5rB$|3J7A}yjj zviQ6WV(*5unKbZqm}%K@gEJRmEiEI#HXSh!k1_O_4ttM*SL2czaR`n3^>tC$tYk)p zNrDWqwj0wod6^F#Y%K{r?dd__wg%kDwtYlpW#KW$0m~3)&2d}T9r9avaL`7jn`bAH zHK{f>hcIap5s|wqwsN|$CoJdO_eo@yUy@%kjX7B+KX;<6tQ~<|9BL|QY6{!+%~ho0 zCTXl%Mh^mKGRSOV0-|Xjvechfej7#2->Y>7rS~6-x>KzBf7p8RcJKnX)Cvetj)Uaz zjvVKs-Z?u}AwQ>@sPI)TkM-9cqvSwZN!q?XmorVz<+_kbhw|#Qjr7wN8GPG#UdeC) zvIZ%}XlsVTq9Qaq41vw6g!!=IqOZ1vtRk8N8Rk@z12SBSXC|ZP8j*f=&cZ?Up*I9f z0+{AE9q*ibg9l}P^-F+k>y;QVn4-1Auwx8jbltQYMu_G~LKuZqQb|dHG)2C{i?W-?* z_Mo}P1H*$uoUh*VIboT#>N@c4r}fCdJTsr6>!Ii5+4Q9(wVs?prOM9FbLr6)4(*ZC z2E3(ve-@y2kllFbCMsNL5T1^20%H(u8qhhSp!i?fCRT_&0dE_=+f{w;FvOi95XDW@ zr6E!RIj~?|Z%6in`_N|3Zt#4x5=Kk9i~r?VC(a-8li$)oA;`A+M_g2iiX^Qd@SUY+ zHiT-5W|As%ui}IiZ&5AsSJ2xu9Fa)M-weFks`RP6sBa;SRqe=$AMsZm23zA$hJxoO z24pz5FkPB|XfI7()iAu2qZz>`BN?$)4 z#>Rfph!(8R9AzK)qFmJ~21~OnQqnE5i$zoi^F>i@3%p1yZRH;z&33grkfh3hR%oEy z73&|&jj&KHM(cmP)+Ym`(m_sz3T$>_?JhFo?SaA>!`|DkTM z^nA8h*JdK4$YF(TIUPkp*7r^L`)g<5v;E@pL^Qa*e|6OxX>$-i;xj4k#KrOb&&P3j zszUJq4t^WD(vbD6%9iUj-=C-bg!Bt1oCY?0ecaO9srl~JvctpLoX977QJf(oI(jp?(-OFqjCbtNb};^Eq?%od=D$;Zh6)_ z`-Uhpoj4z7{!m~F()*?mr#LeDO(L)ZeI8fBi^q%Eg@Dg+8C{boKof%jtsVm%WdjfC zp;KaPpz9!_)Z9mRCfz1=mKegWKbzraY?AVLfH95{D3fg9;1#o7uE9fSOhu5j8clJCN>0T(#mpFxFT(Modl>)lrbu1`A%}<$P3lWC)#T zLi&i2u_Rgf8l@SP2UQ4UDQgo@f=vF5Mh(_qae<r^oxJqZ9+PjJVfrdKLAT4QZVYDw>)T z!g_G8t~(87Xa^zyez`xJmsQo2!XXHx^lI;$AYGc4mK;sx@k>JExxp?qq7D4XH*@|m zuK_+gpY?0+$<%8%{Pm%keZ)7`DS7MLSEv)0jZ|4u%^yUcJb-6aqU|u}yI}%{$N6|c z@i!|q;#)jN??bYR({diy-Hr(=*%USce}zYgnA?rwM5rxS`_P|Ew3^Qv(Rn*Cc%Se| zoGfQ&ZVnMCZc*#X9KJ5pT zA|8sk?wL@s)4M=p#sGoHZ2DO3W3)gTlXr`336BfwiXZj2)9hmC%BS#$LK! z98^0e8!d5v-gQ93G=+#^1x0OWB>p0`^~@-qM&nIvgX$39ag6tjqktUg_Pz6hIZ)C^ zSk&(Zy_eBd%h5-AlZV0Ml~6mVIt13Ao)4vo!j~n+l}Zw@0}xvT@Y75Mfwh1md;`{V zI6H=dI(|We(^?5&HfL0hEk3Eus`7rj^J@NSbTxsUvldLEO;iDt57BJ+A4oI4YSp79 zKrz!-5cP5v(fSM+n0ha&GYxfhW(>y$D+SHef00^3Ed}>yylNY<9Z1*YC_f61eo z8^|0Yg%4E-N~%cfA$0xig9;<4NE@P)TX?2~h>7oh=Si7vA7%V*BvmhL!_+Fv$#5-8 zdao=zDP$8jZeHZDwD8QKsPly!N*m!4I47QKCafy#E}$WUvd13{Fj#0B%<2*Lth;@Y zDwhJ$iJ|#v1F6it&+m(pLAv(}BanGFD^Btw7LyqAboUEN;{3EBrXkJ$>R4!CZU|Lu zlook8PvjZ~7vBpyonZ7TgBZ>g)@+o6D1Ki33es^9K#0HP zz2-5xU4o`nkY|kc7Pp+xG;%2w@h6|=$wi!1_?tT+i+lW%ImnkH4`-klp&l7(7GcED z;;bdA1j?rx5K?8~)1YGJ|4`8J>#oSP(X45We(G~Y$WokGy!6U=YP*EL@jW)}-#|#r zR_h&()1PEnM4K6OZG0w#+x(Y>>Vor2)~{dEuWV-CWqFg+BHcx^x=QzSJM*u}=~^!_ zW;_J~&Ogb>1-yc>TEn=&IWl_Ie^WUcHSK@@C_(NmiC}rxystBRYieqG4S0hEuUOSb z#ssV&11c*>zsAM1YAV<5;{I%}ZN=jzJuhrJa<^%ExN%|e}po`VUaB2S?(@~#w zl`S*{RU&FRghTfgM^nH(^#(QC)NP(m=XPiEf&+kT?W$)xP{i)|58IXj!~L$QvDc2= ziS=B&w9+!LedxvI!!HAe+b#K@R&uXLZ z;u;zK2b$TPsS~GLrQt=^av`-EuC*y6vh~{N9-onpsb0^} zB-Z;L|3ZSMYvtOU!by?l>K8Nqmf=oIE!z1xS1KnA5>riD-saCg?`OSn|H-?m->#Xt z86_xVv#TuDdO84giT;{)co6acwFZSOPJGsbe>ePzjH?{))LaU0hXY!+2g>tTDEp-ay!eyJ@?(bstR9)z>YLx*Q7CetY0I44o2gyiUONI7Ttu z6%f&UH;cuJ3)AV@%`G33!(H=oqt9kjtGZdSvSK;XO?sxePjWy)?pvi>X!6y@YcIHI zU^s@xRHb|D_u5l=I(4a_sbU`~tfze*R&B%5i3r@c| z(e`Jt2u04syQ8xlW~$t4J2>~*oo|PHUcETxKeVrEXkn>j`tJ+w?lifv72@5dvMV|>bm=#+ho0h zFO%6V_7wDobgA=*KWx>{tD4sX$rA7T9dZu)r_W~IZb+?IcoXME{47qV z{JPHU{E3D;bO!@pL7?jutXoWB@q~Cw?6C@gC4{sNsbNT!A~+RZT^pm9g(0Vso|fM7 zpaz(!<(4C)osF(AHx3T7xeaFBjU3hi&AfZ5XA_9K$0-hAqF4feUT;?O$eKEQ9?t9X z{8R#U!?g(!_cLGHj!*>}2RP=2oaoOo<&9i@S`v&UpQ^Vhh#D)B1&vM7*`+@QrznbzDb0S2Zt<~ZayLFygB>=?X>(Us7xj+6nLBwx;`<}E+&UXkT2 zj*S_WoocVKf#FsW=Mq`jUk4E79$zMc2_RU` zG!=k)J@wRvhZ=|k#gO(c!<&|df_mQp<)zvHCWEu&XVKFBNXkDvo6xLOZ(4NDATDZD z7L^&wXb{942LACn00aNwsKVFQgl^pf7m*U7)_=O40G# z`@O~rh<0RRE%eAJ)*dBENvyH@h1_CGqT^S5N2n*jqlva$qK+(REalbGp#+M&u>LMM zEbj%jrc9A^C1ozau-=kc0;Sq1;aNZX74L%92V^!svZ6v!?-}Tcs>#^Ae77-hnjW{< z(}bG3$7Lz@gO2edOAsh=a&AWm_=d5tC^u_kz&wnZU?X&_-(!Vj!Xle-9K(S0Pk>xf z&>1FANKfcD(i>OzDH$_TOEd=h;Q>3NNWEe4JAkUcDIl>gZTe zmW*6w_eT=wT@ksUt0|enKOy0swtu#Eo-yGU9!o8ZK==T?&ou-7Bs;6QxvQp786e@2 zYrD`|&gKMwliLP(N&4FYs`QDFxXiFlOr84GE!C&m@oE2eWfxv@?E}H<%=R^Ds$*FQSa~N&wxd} zc>M~NNmC~RKhvmMKi6)(XI zU4V0Jgjfbt3?idFA@~9%KhmM*^3enZ5p@X=%(6wx4I2L43{x)@Qg72eid`b5H^2{aA5nd*N1$K!IF#$Gig601*$Rv_a zqEnXR9D}@3biKCu>WO!ACG;B}d8O;=Y$O}0HsNK%S8TTO70}!fcEK`eO%N-cZbJrL zlbr7$VT%S}^xe6GC95fGTc10Q#^E^!5;oDqBxP!PA}Ej1*?G2shS=W`l=dSV@~6K@ zUtKEyc0IB@o;SjVC`nY3nCK$k< z87SOcj#$qbX!^v_s0iP$D5Kl!?AC;qevI^9zh4{vocC~OT2otA77-u#cl+Y%iem%1 z6PovTht=1C*|nmqCY9UN2lsRxY+0(2!$E&H8S&2Ep4zi>>Y@jY@N|$Tpnfy5fhD?7 zF7Tp={wTeJER92uuiDt})ROlJ=gVjt?-4DOKR5W~WYBRvTuityMy9qf&&*|4E>8ho z+ges7Znud7J(dnK_+rGJ!Z8&v0jS+sZYs3>enG&q$1%`l^+!l27Bt@gr{Um{O73Vyw75LD}ek==Hmp_STgL7%YYicn7*Arc}Jj*o)#r# zad*LI0x1NiGNq^pCaqw-vn=chbuEx)`D}-|%0m3dGT>NeI&w1-Y~b;m`b^s;e58}? zI~Fa=z&jLm5p6-)6{;i(R3)hSj1vEaxd5~-!aF#cBJ##ugaJt4J!|45Kw00ffJvaC z3?kyg)(!o+6>|sKjRNTJP>|0dak%_K%2F43$t2-m67IvPR3{R3BKgdh)&n-yP$Bkg zaEzvM)OmDmGO_VlF_H21fjEZN4%Mt%bry1pn7^gbGM6-;7pl3Vs@K+|g7jQ*AIO(5 zdqGfo8VQg~dVl#G5iy7sm|upX?m&sFE--8}M@R1iRq>UBDw5%O2S)CV*vpz(dy6tL z>*vR!ct#ERy_NwkSUU2R+i)EkS!A&M=5oO=m8vm<* zj*D5Nz%d4a0`>UtIE-h>?zOLD#sUR#1*Wk4=y&+byFgQTL7D(zlty5Q`~>*;p5A*E zK0#A|$juB_2~OwOKc zrFGNrP7FTdwpj2s|Mls)_=`Eu zS%nZt0O6fVr^DjME1`dvX>@;b_$F)4!U%DaF-uYOm0ea0hR~rsU?s6nuopz(*utg{ zQuAdwNhb%Ydpg6W(R)H8&DM6pn z!v|NjrbM66`a};kgIQPvv=KA8ljvZvg>xjO+^OCKmv#`FcB*&-Tb$}%#Fqs{@%oE3 zb&VnaNb2aI4jf+5W@uNz-&*-my`w^}Ec$DwGDl*u>!679;Eq4!O5dSoh^4hSQFy2# zYBt)no^L#B6rs&D2eq5Ao?93x_I^89F=gT~sDPPlY&Bb~P-Q4+=azLdQVz23$W(Lt z7zqO&oF#s?<83WrqZh3bt8ZD^s>_JHd>0x?3ZkU`C^+~9S0CfxOq+ZBmqwKs^2<}I z@8jUd*bc*GuSi3tSJnfH3Vu6-iWK$Rl78A{Vh0f-s%MWcfFJv}+$uF3^k#rfdB!%g0$0>vq2v`Rddj?eB|qz#9sTGBI(Y@& z&GSi*jv=ijO_+mx$a>wjx;4pk^KIsYhMUocTWbi9#1)Bn+8`A3Br zat*1~AkFehZf~2>u|W(zz4~RBq#nfrk6O4B>i2keqQ*QX7dRXDI98epE8#y%bzCLP zdi2Q}&E=0k;;g;eVW)wC*gbt)_b!HK57<+MkiS&HM7IO^)TkR)7P zq@JQIIx}EzSno-wKtClo@|ihrVUcEJAvhj^R_M4n)bRPk7=9F~2}kjGf*Np3P0Qw# zW5DslRKX;aS=NlJSt0Tds`-d4a|CJcJce>;M?UE+&YDW(fX?aCoj)b4q0m{Sb4woh z8v5Q#-rptvw89eF>lK63%;aWsI%n0vcw$hu5z7jZVc-kmADG()4T`cmS+RLD>)9uG zvWbk`g>n&giTU#}vt1gdzcOfhuhinClClAtZ}AS@cCY4QVsIp2Av{Wciivxl{2`){j(pM;=mnj*wP9s=Wk zm7a+>u$Xp>f7)QUVmqZqPT^BGo^9q)NnJOz2scCf`?F3S*Cd)RZ${PZPXt+I_@#Ut z`kFl4M;MD%IwT}+J@1v`#K3@@xaZ(#sn|BhtGhG!-(S?^L_w)%0*Nn>ahl!Z8+#c| z5u%n9s9UWs`fxGLTC$d`DV4G8)E=vzC4}QL`n-9?jk_Qj`F`LiL)UONpG7;wQ+(RS$Wr(<@IK|Ru}UGuiRYK}U!`O6dAtd20T32HpXIB}w9`F`4v(M#wvaQ14yI4ON57XUB$Z-)u7rY4n2?JZ2Z4S`k_B{47E!~ zEx-tNLY&x+6N00G!3|8@W<593gNg;6pxh&C%r}T7=_?~-0?CXFf1jFoao!Vv~{ZL;~Uz znA;I)_;qr=Rd2pbhDWhu;ig4lzaYO^McKsxV)SnFv2Ddr0mo3{6=iZlR|`H+)l(%h z)oZ^V=&y_v+LG!sQ^SC|H z;U68ZgL5Kikg!3*tINiQR=0Gg%2igRapL&+zT~re;(PemrwjtD%ixn`*oyB-=MR@$ z!&bMFs>#F}5L3zF+EW;+^WOio00RShamDN~JNh3jB(U%F0hm@|R7*`#10Gxsqv_PS zm?nhbqU@!T>IcHD>N`TC6Ggp0xkuP;Y^376GzszUTC48l-l-R4be&n_Qc*_$}HZ(lfJtSsNdK8GR3h zE@hF?*FPd@&lHq=Wx13sLk>beqaNWy)2-`6-z7^~_)I@m!L0M~8aBnIj4AJ4T}lW< zAN*&8ih3rUlh1SY`1~eHKAw(^2VR=Y1kRCCt{g=d{yEfdOKDu z86(_Q#CaeHZbkqNE5I46iyhq080)Xo;8tRRnTC9}*0l}Y<0ADd_}%hwFoX<1j&fe% zIPvN}gxl$H@1*69pnIdMQYhgnhQ?CF_YC!Mi^+iZAibZ0YQiE~@!a`qb^9geKTO^T zdC$+*0+pdvks}RnzNd@9_is2gWQHirZoe6T!}Kl-e|}HX)c9GF`$r5}13d#sE!;fa z9&|t2L+nq#Ki;2A{3ubSo)6}m{2|+cteqgR?u~hBC)2uLz1JZosOj}$9D4PUx%qwa z8n>%$gYGA0zM~zQwZ4xlZygrXjeIZuen!ThX5hug7%X)F+sA>^PWbTn{Uh2$ zp65lb^X5X5yR%59VK@Gx)wV1M(5Fq&ZG>btd_+&Mcoy)~@w5EL1l@O54xaSKJ2$C* zbX7A*qpsn+2*|RantS+MWAupDY4Hk2{V-HOr1dYsr19vTH2BY}#JRfY$ZXjbOhf1m zYPUR0SeW#7V(YdQ={8wB{I=El?C-pjKwwLz^!-B?ImyZAsix1+of++YFV5aum(P*- zD;rz^s@+C2zT~GBg=QFQ_!mSp_fkR%?N`qA4ieSOE5ZKwBJH6NWF(@Ao!9)qQD`M1 zFl9I6%P*kq_5MUiU}_Cty#?C99(4iB4lbCYA*EODe*@+*fh6^*_v}Q~w`L0HSh+b{ zHiEe+H+e0psJ6k$zgkJlAgLRnlZV_uQYW026(Mm|0TZO$fhlcyz?ezu1%YBzcoy_? zGSnq8f$b&`R&nrWC_g_+eY|Vp%Vwq6l&DXCxf?ZfZKow? z!NS&+*WcB$y{YB<4Q|;?!wM}%?QkGos-NdhMG}WbduzTJ&p07w7%MAZT=?n&4Aq8B z_KtARs6GcfiuX16H1`Ccd@>jN0>_yOkWEFQ)vCrpmK0S9)V)T%EJVBVpXAB*V@v@A zUn09A5f}p6BI=QXP+ovKg|kcO-JdTmxpgSHF7l5lp0do7Bb^P^afxOw#BsF{@JvNC zU&5OY7%{MHVMCk=3QcQ<;e`7Q0pKQIVv;Z8IVR!2Tr!F>#2l6PL&yLwQ028#{_*d~ z6eeegmtSOpx%@mw(IJglu5I|s|oCFkAQT$@uWVDdjwDyIXn4Uup( z5J8U1=F5d|yjl7WBuIi!3BFbE^6oW{zt(t{9lPs2OAjX&nVRpFp4m;V+)bXQU_aXD z;CNz&Xn*5t`g_;O0t0l(thUzQA@;u)-K0*9fVb?YDHg(9)MDiCZaN8%PaYj9yKhT( z*G?{6X6$`Mtrxilp2QgLcL@OdlwL zMelc7JQuiRTjqLy)O@~R6;BD1gd_Rb@6K(%OQ|7nCM1kpJV)PY4or;?XGi&o8TxZ@ zi!c1cS0I=scm!*%I;$NYP`@}okb#xZxo#?vR84Q-;2L;Mneg9LYA0D zoJ~*)++tm021_$QO)iKP)N^{wvtK{!KuT9B^jA4H2zqojkTMGFQ&V#+6o41?W+3qf z6Qa$Pc>S9k{$rY-7Su8y)KcG~e}})Ruv^eG3;rXzVI)g4`Z>rwXr3JIj~qfKF#GU! z!=vv$K<;y8D8h*-5ighr^@#y2T)zKY{lE#3i?d`W|ZWJ?4LMLlvLHEGyL5qOr~5{e4tg zWWUj40dlrmQ%xd-XYk5%DP~@LL_(XaU@2fx#!NLoDY2TKFhNArObG;1YRR-Mn6_dt zpdh!((qRNFQeZ|cgM4(Ww_|qmo;pdQB*$RI!ENY?1jR=p$o)d6OnQ)=T4M$S8Hx7g z7MPc0d^4z|&XEmu`O7J(R)?4DZXFd*tdr&JOHWtMcK)l^E&`)0(NbUM0jcXg6)RUFLX19}13I$-WZjpa+19S7)7H}hYI7EvX~h>}YUVOQu7Ddc?;x$2 zD~Raw$nx{Vh?oKB+N)Zy+4%~B&y0iEHg`8EdVU15W>`B^j-dKFXn!aHj-rCwb<7Ls zG*;Nryvn(xB zTL?|&Vdsd48Ud#hudt8!!`8U_|I7dOsuw_JIKzv%nQ3L0XtT*3tixN>(?^K10J=~} z5U^G7MnXgis&E<>5}L9hmFOFy;^I*kwj9b+!%a1erx@gT+CWroU_lfpW2popPkQdBsgD}vi6w!l)lj^ zY@B-&C6Vw3QaF`HY^@qpUORem@$scfgw9~nzHYuaY(eKe_%sHe0I39bjI9hy{*JlD zwl~KcYf}E z^|r5OGeh6o%K$dX#GHnB>mMf65n>-MLR;UftBn?vbaGNxuf_7L4n58~SrjoY%p(@+ zaGd|DF!&5#7FumlrLMji?V}64A!yI8m!#M82cLQ&ngf(+A<6vS<%?-J+-OEOXgA<{ z`k5gd9+8+4QCfLB*zn)xdz3)`b$(1?F-EzMXVZwgq2<7@$ccrX?!6I}u9CRK3UP<_ zv>rJ+Z;r_mq+c9K-0kK1|NENBH1rBKomzLbNB?}&@5j;5G9^{?MniO);^fg0LR?o@ zHy9yx!BC)19mIP-VmF*B=zn0eDhF#rl$Yt1D6P13<84PC>S)G5|1?|etl+jbrko%6 z26Uf&`@J;X5&hZc0G%Cs)ZuMErfqDh8Mbek!R=G);_QhY({QuZZX3;onbwb0%QJio z6INXXQ_HDQ-K`1B3{W8EgL63kg^of6`9-cDRaQI_by00)%0!@o>9$PAb_EyEc5qK6 z!-)75-rh3o=_ul--1GIdoAHQlj+i(t&g<6^X^H~3@;f-pQSd2bDKpG0L@X+gnsNDf zml6+)@giLrLj3c4XW%ahhi}NM8SOC>;fm=>q>Iax0g5o`%C84W3kp#KL>x`>d6zYD@wY!do14avRhAzW zKiOVwOh@Xo&QK%qQi_lzBYDPjRb!d5HSX7iu6!>!U?Yw-DypA(JMwi*}nW9&2dF+8c?P5#o!YSp8o&< zYN39ZUL+Tu+Vh(3x7e9on!Y`8W&#oAnMP@+br?@E`mZNy`!wzT1YN z42cg=+n~1yzqNh@bRDHz)tAe)hGo_PPPm*)-T1&$F3i;+6?PAKW|dq75GkhZsGiRMRU zkt*jBG*(r~AG&F?>1q_klS46~&jZy#&nzw-<_u2EM~^t=V)x2xp&k6;uo~J%n^t@u z(T&5moZf?mVjt=V{`|RnRsP&!HZl8+&l}@G54Ox&v$VZ*VEw|4Ud$x}yY9#{@Fqk2 z@4Sw+O_-v5a>;(L{65hwCqqSwW%`HOyCyW@&zBwe4xFv00ny%9QSRY_tf-RuNb?9n z#m5~v`QCGxG+$%}Uq?nt?ib~HPySq~?XUM77MwlJrGLc43)L!b`CIVQ^jE)-o?Yhm z$bm%W*MS%`JdhpI3U73z!)~5&Q3v+x^b=2|)3TWEH1cKEt1y+!sX>xpZP}OoBYw&3 z&w6SF6fNGJNA@Q^=4VUtcy6p(=!ASHuxYw6(vC`Z@UU#3Tc=5!Te^99fcL`PPfgRZ z?%>JqhW8KFnJ;G^>|dM9&F3_JGnZ!Q3hZrtu2~xat)f>3p0(POm>MSi;sCpwmLAi~ zjAWzB1Xo(F(^7w=l(AtJ-EAg^>||o*ZbSgVOYli&^KD{t)$zojaadtHPpRKyZ)9r| zTRWB@kL<-!mNU&t;F|ARx9|KvEYH2)x6%@TT~m}aU?8P(KbwLP9`FyGgZJ)zt1(XR zFQxYXT)@`=qz#w=TrMj!7?oqaAN08W4u8sTK?RzD&dJ#L`VSM}-y+-(PG7Wd0xsPZ z>AJQA0>$xI>+LYYoRz^h0QtX#(NpUk z_iRXxpe_VU0|@~7xXwQ#(=cdErmhuWj#%`c2mCSobewgj7k_?F$7&5beOy#-jBwX1 z@lBl(g|Dqt@!!4wi`{sA0SyJCW7gt|M2+=d;-aL~Vl{#rKh*j`Ak~;QoPJFR)3#ls zhn^C6+6vkqPM8XrO8uh$d{ z1@Sv0Oj2K4U4CR?+Y${C`EZ!>50<7Xe}PtgT~heK#=G8Q|DK80g1TawFw|QRwKD8; z*mk!C7NepGoH+)0<6VT!;y)U^P z`o$|=H6|nPTo~0U`lDvWqZHVnYc;|QT`;^4jWw0O8KWbr%Mk@L7M$CtexVmeX_Q~L z2<6Okg|pnfl3(G`EyQXf-S_#r2z65S!;K=c_Lk$2QY+cu zpwlNPCuw4rx<FO#d?n z404L@-o?GBuC~>qkKH{#n)HKL5IUvR=}4an!2)cc=@z;jFFSsy{k+#tyQ%;Y!!Y7j zsZZv*hB*R-Du2+>?z@eMW!`;&TacHmyd{?vc?uI?o@@&YifWhF4zhPaDmxD3PH zAox=K<823S*Kne&@Mp#mAC^&ZYX*5Gi+7P}*~#4Z>)gNck?{z^bdL#@2m|{d)Y@KG zPI6Ok1`v%)N8`Z}V*gU?KQuO9Wfeh|dp~N>=6gwSHHY!~sOG=?zyWm29%A`nIF*_H zrUO*@aWp?(>fZpP|5Z(9uipvm@=Rispk@2Jk>N)}v-;#Uh&eZ_Z|IQ?uF}Zu9{~B>LVLNtfNeh#Lg$jS9|6&a(6{9N?_Y!>WA0l z{~3k5U&nydyob;umY&wOk(M5>fH!#qcfM_pMcv0ug&_0CDx8e6{bR>gVIuCdp#D(u zGRd8_Zs-=OA8}UvxsyaNZ`VVNMYP1gv;4BsoD==K@TU;PKOt@e-(K>JIj0$;#@7T% zd|_)Ne`zcg7Bu@hx!vSH1GYg^JfVfT(v;&?x9{NVaF5@EzrTgw#|22a*sXK&>7n)G z6M~voE0N@ZV_NAH$M-U%Jljt9&V2Q&x~OV}L=#BHG@u&-35*bW0&RUnDv_?>1)u*k z-8yRD9OM%`y}gO1TqLHbjb09XGKD>hl*Sg)ifA|P`=i>7{ic?Qc(^)AU4+`(Sn}pr zF)V}dB3QE8SAZLIWf{>L!7B{SeDmBm5i2*Rj3zp-q)`O zab}9%XZhEuEobbK9Eq(3X|OwF>j;ZWo3l73-oRQzhP`nxEj!-kV137|2+a+Z0I5e4t?BBaYXC*?f6N`g1(a58+8;C(UqS(7wlP*~<@qm!h}_7gp@uRw`}UV>xZ_h$7EWz$ZZ!Z!Xhm6_=j_ zjw$u85cg1S4SsNmdb%Ol*3NfY>5V^XhO&B2!r*j%-wBO`_9QpkT2$b2Z9?{G48T| z;Y?u&WOvgMn$NvaoT3cumy&Zqh=kBm)2(N`zK8S4=h=0<<| zFz`ou)z1g09>cbBaW}q>JjcZvMvYpgX!sQF0`4XF;WvtqcHPxK{={(4qj)L)ZvpwH zjs0YU?W;iSk9LDUM-CJhW;82hW5HGPyO3J{t9M$N()WioUnQHzb?(zNB+hy?h;E^q znOmhbBMZ4>XdSX3+Mct1dV+N+4QmpGObY97I{7U6kVG7E;SQ8ft4_lAc$C|>{Uac0 zyot!Fl#u3U?!ixWm;~^2%ahEuKvvX%E-fqbqqbyJMAkZ+LAG#e|7rkrR za)s`m**@8Fk%lyS@2@lZKjiEjz%gyrd{IYs`mwc>eRY(?0=Pi$#3K-+~z8d#i zA5=0%KHxLk_5*2r`R0qQ3dKhWR22E3AKVYGKy_yAnQFzk@iOOFzd_b7D0aC%*m4m0 zNV<@(XXwr#{*)_u$XugkMP-FzV|(ClimG?$BJ)PIAuLEwI}6oV*kBuJ z#!55+U5QyTyEBZ+;vj+%?k6 z%UAaON6(9NiCHcE!s(?AO2(c|5iM1VxHu7mEPMnr9h*szkgA(=C_ypR2Urf#zdUIDO3I#ED@rXi&8WSwE22FEN*?WPlM6A` zu;mT!!)Cwg`=|HLnmk?Jm^&G}kEDq@_{&~LU<%RdorZK`!5%^IhVJ$#Go|YB>L#sh zIph)JR>~;_j~;@jHKBz2F?wCe(J;3~)PPZ+2CNQ((>U4#(8DAhJ(5lHeUY`KR9lBy zztM@s8b*r3C8H8a=3UwKNhCJxsou6&7QDd}y-Ubyu8@@vkU^8_LYVctWbVsiAv&T! zFVZm6gg7^rIUq8f0JS+984EW+geMBMIo2DNywT(@0fpc^#rQm_K(zN+Np~W|wSYE& zaf>wB%#BsT)u;SqN@Psr*Hv22rUc8MMml}`MJh|V*;p36iWj`-k+Swa$q90wut^tE zs=0PMb|(}iKiMrNcO5NLsS1aH0b}EN(@r;R@kMpsH_vo^(#gAlr^It7wBo=<1DJD= zX#l;&S*f^@tQX!s5AQSZI^Y1}O^z4lNc`QuDO1?~4Xh%f!TS*(o{4fJ4M+xxpazEj z&IgbIZ^TOlkM}}^SSKkWi*>Bk+5Gt#)yk~4zX@=`mSk9Fc-aKCi0BaHGZRiLdYs&@Bk)&je z>>F3R^+#Qowo(H0j-_3_5P=N(`~R?_^&hIw_%sZw_f-MySYAe@8}{R!9H?xie(G=F zU9M*?z|R1+2NI8Vs3fm8x(n*s)kG7&#up7jiGWURfRvU!fPRX)-h$TH8$EJH(p}3*6!U?mw>UZe5u$LAcg)!h*h@_{DI664-C&Xfb| z<;chTlW7uU9(xT0fS|c@wc^~*Bko|Z#|(sNKH?;}U4&*;x&d^GnrL<3(0m!ab-l)# zRNJZ9cdId%_{|nWU10Vl-ZepYs^DwUd<(}g7T%_MCzDmS*osmXIcUGu8BO3RrA-*i z?-2sS`%ZfT^`!J{uELmc8q3#-ERv7{rj3UeK6dG22sTMVWRg>YBwH?7d3pvOWd~r{ zi|Odn{R>+Eiiu?)Jz%E8Nc6o@-8^b)9sm}x+RF}8)RHS@i3;uTiIn39$SVAZU^K>1 zfKszX5B$FuV4ySn@dF$R7g8poAfWH@R8 zZKqL5qdup&Jk2FaXX>zi%TrQAK#IX%#fp;*^OkfhL_wMtdZhvptbMoVEx-%_;INgy zPhYRbNy7dWKn=Shcfoo4W#nm(h5C9_AQf@OoWKG_ELdwg6L7-<*Y9YbCui5SVMN$M z`_BWC2bOTe9x_*~4XnS<-y0v{*)PdBfmK2m!?2vdFajJXJZHa^T7F{RggOlwFm@Yk z0GrTE5RR^gy+uk?iptl}CqtRxuyl10ie&#f1*zimnvsQ0Dmj+4s zW?JlsjjMH|TVj(U|6Nq%lf|diS`wIVn);J;CZ%F*E(vPYAnwRvZ5lA?T!enn zejH2?R*_k>9|61MLiola0%c*DQ`FY}1Z($Hh6|L;{&6N=_}@89i^d{38YPU$tS>TM zy0F-ih2zdpRnq+b4gNSlgKK{D^d#-jW&p_O>(4R)PS9VdB(8;lHRc@d=_GvxVv#wn zy$z<3rjp%1KWeng4@lSrQojHCIIGWg*5rWhYP-A9PcFok_gVcuT5iLjOu&wCwLqNMh&EPc7DVBZGp)!oF2IJ8UTOE^=uA_;q+ZE+ZgOxVew}?I4qwB4Dv%&F;TmwG z-`K#)e!%m4A(dard>my@9zb7SF?T}TEe%`(>=m==e+>D@&Sout`LjrU7Xaa9_)tA^ zBxUBDaXZ`msNIfdt~S@(ZDZ>kcnHkmbPoCOW3xF%@;-Q?b@Uqs*vNY+yHO`rK<3r|i6p*J{vQ6;i*qnQnNIefCzIDQJmA-> zDRJILhgL%Mh)gCoO!z1R8Ygc4juTk0H!}7iVqt%UwW;3O$n4{*$^usUaqUo+KHZs0 z>Uw=(SsleD(;*>Gedu(EbUi}60Av2><*tQRA zO@>qlx~=D-pYh((`b1!1zcTLsUM{qk31UtaQ5myK zELv4UV}ej5bfSh+Vg>_9=SuNDz|lzhct&K>vk^V$BdHIGWd!f7mZ@~t@2S=a!ydQp zQN_TW*eAvbECZsjqH|v5l^;1od6l9AJw2OWL)nP=P{KF4*~dRYP)KYrv?#tI^1?Mf zB}RHa`RE_4QxwYaJv}I=dof!~u+}oWG6zY$7336^Hxd#kR;9|ZV7HCV6ZJ*`q;`TG zZ3*m8(O!95s=deayL&juX{b&;xKs3*jmjvb$j+s`f9gZNvPYL64cccNq-UcTVE4AX z4*gFSHdap^PlRwB;KTPV4S7;--J&r?ok`(%B(%|w`8!~5^7`@d2zXI8sGthnHlGP} z0vD_}cA>jukelD7i%UA2JYW5j|mE( z1S(t0Oo+h2nQa;DZ0ByKKghyHH+*s(_Y6X06^tAc^UVPM!Sbs#UiWmDQc2U~d!x4; zZ2FkBs7I%jD)v0V<1%#-%3lF_G3Vvr0Ok+nU`f1kFkd<2iI{fL*lS%T0!Wi>z=GMn zsv>=yuYQyu+@Hhi8UFW#3d_nA7KS} z@LN`$<~jJ%zqIMR?+j?g>o5jf0~+b2>^4mh%_?hF>EfI1GR6y)cUp%_=S>BqNX#U6 z@n8M|<;Dj)jn@L@YBlJ*;Ll<6LAl6j2P#me3%y(PXC3ONdV_>k6b7lC0mitctuwwa zVh^X?Rg)Ux3YFH+W)B^7$NYHnO`S3p(=;|E;OWBJUi_}wI2itu+FvHh>u z@aP}+5~m#tQLpt(zt`6t(g8jPP1n1bAx4aT1@%8F|B?EBEE~Cq6&jnUl_e2|I5$ww zG?dEUydr(Wn)W;w2$sTMvoTYABPLq2xy$i0xD)`7ivIqbkUD(&DbdW|<9V5imf{s0 z#gYn$&ETDeNyhVY!u8u&5_=rrDe>6vQ{QD9w+j~l;-rzDMan%e|>9+?dMM@Qeucf=zVf|`lq!B&zsu66Xu#Yp#e`vrUHe$NPNNf*@fY4)J2I8!ZGSR>AIXfcKjr6V2b z^uq}YP#X@pgJtxbA+&UC2fNa+PLIuHEMgq_LY@3F_mlxRmLY*bSnxCS!PnXZMH^Wq z$14LEu;j?eg<`0Rr0g+`(97%HVoROU zP)gjaQzE+Jm*OY5mR~-<5`?f5rz!qB2G_0xKtxc7(JU#<1tuElN6V zvsLGkl>Pi4!VL!3qA;mbrur?QBAq)l^af>}xI}OlofB>g!CkooLT;=vg|3Ci9&yE# zF%6H*O2g=@teLA_hv&Ii3IVJaPaw>r+)03e>Zdba8$5(wotIvBi)k7<6}j@PvtIxB%V|Ocq%uuw;&qYfoG2UK+w4 zBN2fzu=YH}Yhl}Vmeq4U8S<%$DT1?@Tj#mFdoJBQpMB&g@JEN^sOUg%zBjbyyS6&k z*zElIflO(k0<@=V3N$mN9BaIC#>n!^%gZ+jH>~=;P&dqPSp6eT5K|(7wOthD#x8uQ z@yZ)}t;kWJCW6z!w_ct*Spz~P0GMZj=!%NWgN zEwf}(x?~~FGu{(G;UO|6Xc(QFI-LP#fg3*?ysjj_d6^xc-gq)O<#?rtd{n5ZzpY0< z2^p=AaMmB0`1wIAdUjTYQZ)SK!XMe0ye8_oU^FnHN zgkXf*&&ZnP1D>iAa1J_Luw|=X^JAxmII3ho$vkyd)XIJ;ZYqUf!JprRW6+r0qP*d( zD0W*I!Zp5yAyvLB%UgkBLzuXVn}~iWfeI>&vb&5ald3}juMky3Gw+&)V~KsE=uH?? zmSSfl0B)Hux8|ZT5vam%m1Fkk)`3_E)iB02xd#O}C5?iEOHU*>A?7tD0ArA6?47~u zat#Lpm4N&20^GCYT4hF* zU3v$jyAl%Xqh17>H?y*I8K)J=MK@wpoYlG7@=Y2Sg%QHP4xko)4T{EQazNL%PX(0> zsE46_9vv;}c|bH7adQs3G&ZG(C^GNzNyg?7=qy&N8*0Xw z+^2d~T1<0xxU-`gPPv?^|6*5F)<}`j-!1Ad+j0&)w}2J&wR6A|xT6KwYE4LZ1p*uo zpWwUBtgRjg;g3Ex(e-HAMyAYF_r3|L=E@=$DE(!;OS_B($Z9wJUj1U3lZyWX?#fM{a39caGwojIZ2o)#78!Tz zk4Cm~Q6QY1pZ^|uSG}9zXSo`1js75*PCFscW)sQ&30sm!QmW3175$f%QLfoutJicz z#2c>($&zCQrw^qlW`SU zpZs}0o!LZFKc|i1)szvg^>Aj_TO974QuJsoE*|^H*r9`yNFtiDzxZMe_iRXHkiX)w zM8NAC@ips#GxGA$?j`Bx)ok`jkK>qVjQiLjQFpWvQ=Ci%0>HK91%9_%60$y){Zn^w zoqR=ZLd?^#%RU)9633F2%ey!HZ1QkY3!tK#*aIRb*@*7+IqcE_aF5a`n&c-uC`q*+ zh%JNDD!+4#@I@dp3K2Eyv_R?95^+&|XZ+U5y%XReSq^mc%``v2BU}pD0g9l$_^MEHEDDj~EVS2DTIyl=@u&>A=76c*;G$`0nfjW!aUhl& zRw^fV`__JkXs+H@OcwYEfER<8sCwWUN7rgFt>)8bkrdp5fnE=`N7n&y9jG~k;AfAg zZbB0GV2iH|Yzl%ZmIlr)q9CVb(`8ePx!mrhj5?#8Dbms{^}bH1KIh~5GES=kNn+{( z!&u7GE&cKmMgD>`8?h$=ntAnc!)sBh_!*}Ov~-YvTH_-WnbC&>?HN>z;#6jFUn(Yx zM9B$QtF1N>09GW9PW^U&3Nn4`-X{yHJhsibrnF?e3BKz~iT&NI<;5AlgK=NRumC&} zBAP{Sh{D8U0%j=Z^2_gAgb6f?RPr<`Hc|p+GS;WSyzE;Nl{KL|OGg78Ko+Q45>;{;9rE9{dsPDk!zE3)mSTgob z!@0iaF@7NK@;Jo49LyvO5m&U|QQwJp=^xW84Cwh`OV*(Z$n4%rA1yDDk&La`5&pxu z6auS00mWyY-3u5_2G$5Gs)}9DO>12X-B{60V_8QJ#L5{ZA<@8-Z=y5v%Us1Ta$a87 zkynK!B{<@TmGWs#r_D%!FsWE8|4C6zQ~L2DqU+Q9j~*TlS2rn&{|VK~iD;*@o+Fu3 z0lu3GCrDDSQfFHq5CZ}bzBV#E#0Yqv*-g|$@n&0E4v%_VFyE%151Q>(wf&nME&|?j z2I2#BV;C-%hYHjrq}l@~0^+1aTnB#-i6xhcpcT&(#Rp?7Hh{b_V7ttc0YPyIbVCFw zy26qCwu8T0ls~w7lK6Y}PK^MUO+>6?PcJ_8pVZBgw@*&{40iUb->{Lz&J*~+H}(Xt zncbf+^4|_6X9V^Bwgq3)RF=7uC!2fI`k%69c>}hu;-ZOmko6~&G5hMfsy}^+cS$2* za7LeP`bNYpS2bHk4V<=6){CLf~#u!iVyE~ z^lQx8+(Y(SF04gB-pJ^Ma~Mlck+M!GOU(I!9rD^K@euteu=)j{5h;vK^uIgTDIKl2CpZ-gzn1cL|-O7mot) zVjwABJyQn>gAP*&iK@C~YeWQ3*O?plt_TC2(+l;D7vrBoZhe7S1O0hgx~lt`qXN)U zt@tL*v0HDlX2RLTxMP>Pz1XSZNOdSNDIb!+Aka(_c<+&+%qXF4m*5u0Iw2u3zPpaK z_&VrU#5w(9S2wZ@f^Ov-`Y^I7_&V;8qWl2rZ{n;$x(3abGirQLSRlU{sq|Gi`oa?Z z7ZWV$`+Gf5UJV3z(c@uWn|Yqh0!$*zF+OV;I=YZ|;97y@Buy-;p*0{GOq9AyB3fm* z4wg&^?mL(Lb*vIP|444IP_xQbj(8rhC_Zc~4?`96?>g4&M!QI$%7c_K{%79&v5LGE zpRRai0D-eImkv|(;fsVTY#k0dlHxlz7zf>p;w!Io8Hw;*_!QwZoh7F~ld7QC68|jL zO=GMl*PjhBj8uLdBts!z0sT&n2DqUZSSUmY z7w;PZX>iOHE7Mxloimy+13$)bU((vSuH+1KJMEa&sD0`?4w9ST8iItqQFNzJw3lT6k%r(X{3Gefts}hhiKA*P3_dN3Y`uY;WLnBSkG~@WB3;VT}cKv?=8c3TF+iKNN z#q&}PgQJ@7VU-jt0QAb`O`Hi|zLlO;Q-oRDV)js>ns*V@ofY18(6Da@KMxio51R$w zb#LEmw)*uxwFu+ibR-?t!-r@fnEp7QO8^3567Le|Dz7yE`=!hL6jpM1%7Ra1P{MhL zae6xJ$eQZ9SJXYMW+yYGzd#azlsFDSfVld@nCrHU!#e8|-xYPq2{#TmB0B7}jWnrR z%im!>>cG!}LH9Ip3W8~z&cAm@-F~9>PtcLnAbe}CMpB{2!qvU;lO^2&w|M^t!Z#j~ zAuf}!U8Ih%dBBa*E{jNTaGb-qyvzGfQ3-=^CIzKCWVJY=2Ngic$-^1Qp&n1gd z4%p_T7Ad=6W?hD^*ixWf6VZHga50Wiou>>|M`c?N#yaSi#O7?bh-n@DUL)@PVO?Wp-2-B{LqA*n96}Tml2M$j+wH3Zf$Tc|Ttl zNg%yoJc>qdf4l*zg1kr6dH;BRl&ir0!vKXs*ogegFMv-l0w|LuTAm6PYIZhN)yTVJ zaMJ06IAgqk$eXS8sLy#U2~1Ua>OIBzb5Mjzrmo{l==l{Zp}qqxbMFNT0sSGTejIKMMt~XoSUwfY}nD)Kb|=P*fNyL6AM_NW+O2xke zB+`gYSZ9d;M|^%c%O&!CD=yZkLGtwor)|r_ygLA;F?_3z={ar-k{A@+jx5TO8mb!O z?JXAv3ycV4J!Y!cNyAJk5MTI5%bnOfg+?E>pDCSSzVPWqshP zXl#dUaP%t;j?8~07KinVPK?XUfR1q``Y(?4^B7F%9aYF?%>EdUOl(J5Lov_MRX?OM?cBNVD7g!+x&<+c0xYB1VpW890kvMIg5w zfJ_`prHB`&BC0P#N5823dcMQ~Xmiff8fE$*L3Hj+xTtiv{|m0s-Fdg4#l=xmp^b!w zQRDl-b|g`+mA(El1pDW=U(E9w|6oi6%%bUA9yd{(wrq(4x=nl!k~AH}iS!JjX@`5% zU8`0APKXb1u+7xw`QARBVUm1J2na}7T6MJSh>Ycvs?M?;x(FSVDdDPWunbs|#ZRpS zrm~648Y z_LrF-h|`&=ETU4o<=TEiV{C$xvKSs*)%_F^$LMZQfjK?)!~-g1djClc9D5`VhE0ma}0 zT*qkXph-P?{z;>%3A;z1jJU(1umSwAS*0USG85K2rH@-Ctnl?FjXyv5BSI&Msmb%% zI--zFftVoiTWX5GT3kd&w<-AYwNxjGW0sL*41cJC1)=u#!((ksP@MS3kD3FA^*G#k zsTf|M8DnZ=IEe$`g}Hw^rg~#fC}ARR^s39okfKb;{yH}D;%L|+QP#kV&&Dwk&4lPW zm#1Nh9ie}+@R@`4GRJn5lNREeG?>=U^7J08N`3qBSOu-|krq65`#kQIyy>Y8vA(`g zGhyxSeoui)FaSPoPrAv9@DkzB-DA#IL>_;47I2Pu9=|r6Qoij6_y?YQ*mI0)v{lFl zO!a(iJZqG8n2{>ok+@mfE;=(9;#wffbl<@wp+}fSRs6klHWrpMp)zhrYeo(9>ZL8p zTz>@=YP0FN(=8%|3%9Q0Z36#9@!x5RZj(ehh)V0PKI{lHsw7g(yLMVc&_qRev>8E-tPVQTGo!k#he&A0HooPdL`kCT}M$^C#^X>RyHgeAA|;!=`;IfabbcVG{S1t4HTY|{pM3yd2KMdkIiE*O?H0^BI=$8M zbB)3N9>@5LJ1b}4RzuydgSY)QVIHd9`W4LUVTM;kAn-o3-lu-M}mzbO&VGj50_Tf}Nz^kZwasq#$XL2R;N1k;> zaOa@TN&P{r3PDM3B4h1Z;&^Q8m?1tG6Uzz4puZFO)u!U2^uK%- z`POs0^-0X83)W+UBl&^|qc{Dt_A5pA9$7aLDr_cZTpM{#5UwsW7B}wqnT{$^-e5vJ zA{ms|)|R+RjGRO!%rd)-!uv8z$b2Fh#XsMI>yvBz-T{hHbm# zu{6fEG6gs*7d6;z$SJ;uz#=Dk(WCEt0ag&sydEt`gkp>@~U%z4H{r=-145u6% zg;t0Km?6w3w4a#S85XnLQi(a}n0s=i)z-W+LS6fIdB%ZUj(Z_*A-5kAy#ONo?N~1! zR}0#|trQ~K)Mv=4lszU7jyar%jBcIq|AtTo0Di4h-W~m{A)qeJpNv&%`(Z`T?t3ZI ztE9se2Rc>fY!5KwY(EI@eBEeTy=eNdPSBuVZ z-T30TfUtM-6z+eOuZzbDX48+LM{%>Xj%P8oYHfVGLcV1#uMcS&N5}r2glBdo z%=!YPQ7()dJ@nHTC1JZC%}U+lOeFTMuiWmf0guVjY!o;y5lb`Dz#G8tBf69nuitQ2 zPJ~vQZC_cVZJ#ciwVZ2^(|J7rfA}~dbL!+H&(Z8axSe3E;*lr|BIP+`aY>c*!`C4C zz<3WzxB?&$>qO|9Cs7l#yok70rrfI!fi zKGU`LQ=G$Qqk50u7bmb!Z&M6k4&z8cMc%+8{vucc1B@;g{Fv+ZicB?{=g`Nr%pogkS73mmGRHUX%s1pSxQ5*W%gq7 zMyNi22tCpz+O#S9f)56!XqoB##SI+_Md_D?Lz|*D~Kk8)bW$XQl!Mo8OA;?*7QM}3x=fgc><7dShqs-@5O~I`m2qwjS zywo85W6UnlK|<9*h?T(VGGdVL3e1riiOM0{4aUu?%nSC7N6E5q$x_CWCsm;dW4E+b zk2x7=(exH3BBftmU&pGOnIjw|UdOTu`*I4Es%LcVLcA%a`i8jN&Ckm0c=>4Hp^Ffif3YFo?pDF{Sd?C&1 z1`LLV@lEPX8|f5U7^=Ask9$H1&4i)j6yp|Hu7WmlC`*LdQU1nCX!K!dlT^4wxnfkw z5)wqqFO3bO*CWeGh%zd*R)@J!UQrvCpoNV^oWWABN?d9>m%>-!zLvcc&xRX?);ptm8sL!q~Sv&Q6 z(LY0u&3rqXBfe(@-CM=|y6yy>+vozF}%s-$r~=yX5tCWR1YMEYXhE8)*1kT*lTg8vFtn`7a{n)GTFEW@?#Om z^?O+=P@X-!@r#9e4x`VD2j`#;R9`U6vmOyB2jh7&%>lbSps-BRhMl~bMy9OM0DeGk z9=Le-PB9=*)vbl)lB{?inNSgj>vx4xc|{CYfLxR!JE*^#&K;iphe)Uf98o$QbIhO- zNA%--RJr4vIk|W;`?ws%s?44`I`UN-#)G`t7HMbBY3=D^^rIHKMeK(J>Nm1(eX?$s z=IF&bub3x_=hBA4tXvdaaL@4BZ73>5XGRL{{6ieG5QmRi+=PGN;KBb6uX^kfe9csOC(k~V3fdomJlV- zog-W&T4vqTCFXnUp`-$vDhRjCBN>V7T#K6WRswHIlzwIEViL}C6~OmS53Fv&%JROVr3lY0eZcljlLpCubA(4v zp$mbZDuV8PrvXvYxI1ALEwjg3beo;HQ)Ljcc_V;@LPPM@dzFn~Y zqv@KW<7(UXOl&uelg3HI#x@(HvD4T#8k>!6Cyi~}X=B@V{{8-IeJ67;YYql`?tMQO z;k52-Fc0TIxFTL>0oqc7lzb=W5i5x=FM1AbjBDR?V zaXvWKu`zSP30`x!sQaM($cR_sz!>fd0SznSq4nDW*AMZ?DlKWxY24wM z!ZxlzD%57l^Y3N{V-J=B-I!%7DKTfAPpDq5?mA)j$%H*~zFv}DX~0EosA1U!$`Os1 zAaurRT&dc)YoZsftgPfbZ{Dc|Td2PE&X+3Vn?inGmc9+}Re8{=+r+yKQe*4&4f7*Xq2aht9@|Px)U%VO2RwZ>|O8)=!SRfQKh<_^WGSdyX#7=#Kwc2ohiQ3 zf82Qn+lTNiWej9H);eLXnj_p=NTXeiM_u@?)|ROwWVaVcS;bjR)w`oiPHjQ0PeQZvGZB*o z?4?dTqwTuke+zV+4}`vKvp3O*BEG@{59pkNi=g*4@Nx<47E^Zbh(X!{X#rjpkya&E zU8pXx`0R%%vci-1AsRpEfeNj#gA9@j=<;j&>gS5$x&dk4Cn5F*uxCH@^_#+Uo?B!^ zqhS5)0ZJF-B`To@NE|654iCTUgdQ@{nUD74wknPG!zaYUUlF8pgn?p%bL-?3#neveIZ@s zN^t!hi{>s=ctB|wDUK2^NJxU-4Ocu^I+n+6F@xJlPaSC-A*szYOzIp_ji1kDVZC&p z493P)N6!i0{2`R(zaYwYD#KINE-g)T$kjkjigZ0GvlC$NfM3rLc)YL&02yTzVCQPKAAA_yL&K37OIu zNA(+(H+-2X7XBhKpGUPtjHnw_KTR14E=~#%e^DRaV&1eS2tSY3&^QR4^bcDTyhLxB zM-zNKND6`+7@i?tz>uh4)rHYBsIJih%Kee>+523v^3H#ml`Lr-?hEP)V&clMJM2CO%w&^4;Q6;=a0&izIyl%kf^u*zlY%W!8W zy=SjCDpg%w`!p9swJuKR3yNlzi^Z-CRM}=6QV8MHcr-JE9DS?%BWs8F4Lc?Lqo2hE zuFKlEUK+Ozr|s&ErpiJ4?L$v$9ZxB$WQ)XycXzILNFS-qK_e}WimnjHYyU9=5)}dg z<-S!{vsxd)ro_GsO~E;Bd4ACd)^ddQ{peH)yx|2_ZD);~fDahhIRcJ>bnbqewlkQ= zrT6s}tGbCc@#gQq^&LDx{A}M>mKbk9+$3No#zO2b)a?APKKc#DGGYx;i_`L*i#kdd{t^$=#;drD%@HF2Rea{s!xA0u z`rEBB*8{)%sI0j+WtS0EKJ)djE6Q2tPAKO44N=iv7dQiU6Y2Ivx9GgH5uVdD*>&eu zXX+!NkZ#zT4$KQ#gG!%0YyWmllW^S8f8#B1bk4$B!IPdQws@X(2qPfyxAO7>W6Cb&Fse}EhaoZ0BSQs6ozkYc-N3@}(n|29dYr?v z)m8)smaW-v>hsTqxC#b3bj87eyF%fIl5s7HB?xTXiqnD+tfVE5C*2?vtfWb%=D=7| z=1#J~+HS6$!)({^XKHLyFQ<^lYj?L_$d`dJ4p#@sQdXS5Rm@bCPRMCAD6696{1~BW1qD}Uh61qhL&>esB3O~bvPizA6B;1~mAvXaqX9M9O%yPhac1hGh4wGT7 z>2Tj84{KDfRvhC983a+79r{Y$B*H+VKyU|m#3v&75!IQ^P1w;-Eb_x{JD)4#`K^xj zpT|K;579Q1=5${?Ya&bmV1;zY9#+mSZ&2LFhHe9G8xDzvAPFp7OwYg10O`%?mW6kB)(dy2 zH@DgCwNiz`?uw`-ZPn*XWb>HSjkjG}XU6%IoAp5ox!+TypTFKZrffPYWC)ngjQ&B`C7^u# zEzsfda1~{ZtTsj|Zy!Ql6Z#=gqcRn>VYsFL6pGUrnF{yvyih~*-hXVF>_g1R&i9oQQ`SGZ2P)buI$@( zx{)xJ-HyVtxEjH}1Pl5q0yXpj5xHdQ>ATUnbmd8>=~GcgR4`4vmsSo*og}+P@2I_b zB;bJyY$!P9V-AlpQ?KJU@IW}PJz>)~ zG1Li}@A?;iGxhRMgkl>+GsKQF4M53Iajqk4d92yX3zA*(nn7xE!i zb5};tXUI^J&63qdWe_jyW(@g@eCOp)Bn!JiWrH;(-=`^|lR#<#8b$1oIel3;PmLuo7xprZBB@pHzwJ20?N{f{l~ zdoGG2>~SXL*$6m++RRj=?FlNJaW<40keGdN%pC4O$v+Wwv~14Z;f9$-e4=lsF-gdT z`Y_XNgkJ`@HZ+BZBOFN)Tm^O`f$~Ca8Ho{|FZF5KG9kN$+`IwnqX|JsAIrXRyqCf9Qm2KeN9W`FwtKIm6%cX&+&-4uYEfGzpGbh4Y zL7G}x0!Z>fqq`#sS7}S_CV`%;ys{}w;JG4M$k&UbD>1s>MJmg)J-91oV3*l2+%dvi zSXc-mbou*5m)t`KFyr~v!E*#4dGP|~8yFfMcD1ThR6~{TBIyIB3*rer;88cWn-Qf2 zz*J@-(790%0D!(*ohql*pz{?tnUc+b%m_8BIRJ}M1(778`adTt=od>%bzXXTPBP!u z`DBCq4kWn{%UTcK%73^p=(<-0bRtaSPlFUf^{>KdF!$dsbMo(j1?8Zxa15mF|NNEG z7vd6}xWe<_yg6!D_Mr97e~0WAF?jjQPvdKMt*a)$XN7`X93K z-X$F*ix|(1fd|VmKOo$J>~lcow$Q>-CE>ib?w5r)fZ3u6D4Ah+s(r0Qzz7`%gT-JS zRjocQ-ZxhsB=xPre9p&zR-$=wWydOaJ7v$Z3)-(z9UfA05H)b!$>4U}?p#nScpQ8g z!gQ%g6;DrY3vp=)`aseDQQ}I@Yxk}L>dKFSGgJ8tc*!zwbDFckZkFmmB@}9W2IL3c zE303s0Wk|G19kI&+?LRorP59M{b%>|%6*A`G_1q!*c6sq3X-B*J5osTG> z?@~bJ_7(V)D{1!w@{*+eYf!f@5h1?z*Wg+CK0U}yOY$KI(8vt=l)rD(I@IPv?kc{6 z!rT;CWwXolEppc>eorBr`~k*}@AV}L^0GtW0_Ab)AK{jsyw0Bq1zSBgyOW=n7aC1S z4=Lck#NAweBlLKsAxI6pB#16uAcZDxr zPZd5w8i0h$!IKD8mK0F<72m=mDwzi(DOw`LA^|I=Et)Y4MHXUZj{vEPYjLF@YNUe~ zWc;EJMItOfs-g%*vC=lu((V8*Gd!d&4`4=jPL z@|;(j;(0_>p)-VX18osVV0j#8aO)So#C+kaXv$J$sVHd++J<42&w}Ccr4gspJbgI- z{2N^ob%Kgc$s4?7tckU(iD4ZxL4H~MAFZQpa{Wtd%P>n}{@dK_P3+K|=w~k6>_RJm zM+i?EIZ3$ze2?-$#r^q~|AY|vSz7d`b*0?C7gHa~+}KKJ$yp|lA)*_C~voEH$&hfV>;kb+Q|g#bi)AjL#OZ3)f{b0wZ&XLLg3 z1Z$71QeQcIBQ-#sj8N}(JU@F;)bU*8=*s_q`N4Od^X%xAzE<-FzIgsLuTjGNNNgIu zEQYMwU0PPiy>{M%e_ZxZ%j%N&!*>j@+W)~N8jVn?Ag)wd7Z4^a4Qv0i^`7p2Ouq+~ zjtM+AouuvLTU|Yhi!Gyl9T>39U!TbT6|(RBiT{Grf^_k{vPU*wAvdZVV85)?K%Zj^ zm|*~D`WiS11~~P?Q{^o1gol*@r!TT-90VPPThbXIKEWPigyUKagE%1>cyX4S;eIH@ zrX!%fk%f&x_!R!1F%VAmt!Ww0d&$&6sv0>HNeSq7wCKezMt zrZ9%{qTwq4dyyi z_=Br(&i5ZV60;G3H@E)HlSppWsq~>6M;G0tfsU8RP>-dgN6@`&ds9$wl0>b3dUqX9n__;K z+900P4-Fgvl9~sHanIMVGX=6_lZ(IV4s7BDKR*geJ~sTKv#=8bs6cITcCR7X zX$wNmOJVy-m0NFF@?yYHLw%@>Vx(2|$Zm?d;;Hj=rrluLBAC#m(yDKmmw@~H{viD< z<=bLG|KBe?`}RH>RDMWtPm8*WOBYZ}HH z#lz#*f@>OrEtrVf>TV8$6LsN`eM`0(s|KW|jsXgYhyDyB5qfnAl_G>*ae37k!Ik*y zCxc)e_9ml7v+(FpWd3mAr#ocn?t`51+5SL!J z0*97;9zGuK98SYEEzG~qbW{`0w3HbopG>XZ@k#LiT_ng?zjluaVM%`9T~kB%@f(Pc z{FoAhd4DQCKgcHf01K?%?P~6=NH4KFsdsK4aKGKFas2RVgi7OE>FHl$jT%ogBxH}F z{pusvazj&L0&d|eoGhLH`k6ib_Fn5A2E`iZC;12mhnoB150gbm?Jq~t!t$|DZnIgP zj7y~)T@ZD_(vIGub2gn`--CrTms@|6j~u`+nw$eE&p!_`VIybONZE{s(SXzmGn?iu z7;sps4*Ag~98E+0@8it?)N?ai+v%0k5PSQ`K$b=gG*0J8@5h; zt8-*(*KU!-U`#4mh25u@#dt{Z3yx#?2tDmJhoG#CnlX}6FD_5|uNzf9`BO$D)4};Y-|fGjTpc|Re7<(^oKDMs82;;*Uuh=`*M0qx zS6O?FHht9{7U}hJ&PU5~GN1=x_pZEj-6rIDqx200X(t5||sg8$VTgU+s zb@dI@N65%ZSOK%b#d3e*6ZzIkj33f$x#gcv^z-#F8?QC)=g8C`->V%el%KHe%fFVP z>R0cjbiLM_>}Yj+Ux--E$uP#Xk=vg)XEWEAdS}}1=b0}PzHSDGej8m@leZzx$EzPb z%}kNgRBR_jC)Shp5ir^%LTUCZ3ewN)&X#e+D+_Z~xR*Coe1#C&Wpy^~;h)ZB`a|%t zt|S5&a#x>xCR(57RMf_gkUd$G-*!Xp8q+(2cQy>ob&FG*GAz~PpO%*sy}du_VBBv= zmg@W8xJx%sD{P>bP%@^+ieuw6i zR%%OihV0MUJLrG1VXkxKpnJf%q>?%Vrj`*!6m#9+P9=y+9FhlI%~EHIhe%bF2we7>sSc+bp|;Dm7r-ZX~juE%)9>@nX)U>T$Ej<#Fl zj0CZ-;U{--aevQ%ClD^-aigfgdc^OUxK1}&gkv)>5lE_M%uN{SK_2510b%$;Yqz3+ zBy(YVA1VawZhdZxQqqo$2ePSq@rAuI7NLid z@ha|y*Xx1R+%2qwUsW>c;L(w0q)0gsec;w%i~S+esPlNoxoBb-pw=l&uHzk1Qg;KB zIWh$0)>FCM-Ki2X+zp@_dsCT|4datti468L`}|Y8X;}N*aN}_uFtG7;0*(DrBQ7Ea zQwU_lnHXTtIpG_EP}N4lCkeR0 zDpHRwI0AqJF)T4U`aU$5k{L?`WtVt~~DaQZXHc8m=7ar~s= zuN)zcxoZ;ahZsMiuwJ1(7+$GveLsm{NF&f(sprclC zJ-7bpSnmA8bmMII%6*Zt-r%n_$R?C)-WBA`UK%La-?Iz|z%+5GF5p0?tKOG-M)r^Q z%(#^OTCVZhsf%j--%Z7$p-B8j4KhYNzDl@32w{8);RQk6a(Zn`V#M)CdIb`Y5{YzEfP&0}i@&=XsHv82UOe{~_LukF)j;-@=9QM@` z7if;y`!C`TN&p_?cFiU9*(tg&&s-onB}BJ#eg}XY&I(y zH`6I4*^RE&Ck`k;UPo8iUadk;81xtZFNORg*4^OJLfP0dKjIG@tFFVkTcjV5)klN^ z%W)NFe5dbQ58%H0^CzB<`%~>Ax~_DH98QOUY@QhHtAiN-Gv_Pxov!P5o%IG(CPFI& z)`NcE^WU~6*Q1`eir#TsPv1JP`Z>*Q(N<1+!5(Zj21T2F;tX9KKh5Z9k`U z+;+o(W|}=c8m&2lF4#*Og9{VM#^boFe4jrh*8R30&Ihhhh1Lfe99A5;Z^37jOr4fr zF1+t4*Xyr^KuR}wD>t_W-H?bwG4Ihok3J&X4z`9~5(}p>1Nes~%jLdsf{=utY0LBJ z@qYhcgmH%YRJoy{vEfa&4kfz8EgTuq%$6gZt?^o zbiv!FAoEfkC3h2cPng_KYx=y0z?S5HaDg+Z(W4h&cihmoVO?x+mb5s~yW!#F(4#g* z!LFxpUb!5s=+4}^^!e%Bf-?nw?L3KV^ym&`6(IExUfwTQ1u>&qlQzqkUHq<_>e0!M z&^9|PGwkn{xxXzu$EB`8RwVD31~Qr;F;zl%(V{@oZ^#l-AM>5r|56@rO)?)5Jn_PP z7Q#73Qn$skx_`POI*j6*3rI8K28rK>!>a$g`PKUMQ_y#HrZrka7}|f*zk`3{rUeC0 z0L_4{E27j=|I`vat7{)d{vzr7aj$fA5uI*gBY3(Mf&Ms-P&|q(#>z zRFNH}byv12vHN_vuC3WD-`rbB!a7ino)+tv=SMld<#?b&ii>i9r9(+RMkqI_g;WT~ zj?R$6)$fpM%%{#7!V81D+G}$1NjR>+>e}~tPip1?^n4V$ujgTwBaEM*$|5b z+r@*Ux@r|(9%?VA!&i&DD=g~ZZ3O&WgeQn1xT!>tdYHg4*vF?MI|l z{jt|?Kc8GIU|SQ)gzSEfggC2z5c<0owOzaRNOP|=Htp%iTk_PP^T{8THa@d#T<@Wp zx1HTDR}d<(yQzc}jQIsYK&poCJv(4&+;Y2AmIJ zLSOsZ7Z~E4gO;KcG0=>-F`%2^dt-SN8RoF&;;5S$6Qz45dJbmdzKGjnq2tL3tA;Qd ze!B)KG_#7DsY^y6++YLY7)MN4=QvVs*1C_YY{)^1@rJ_5h83_u31Vc4=mJgH|F%@W zCQpf_p^Y8{R&z=Qtcd=w-{rfrG+!j_j6p?(GvHzCci#QYBxsd(9C%M|^Pi6b+4w0Q zOWWV^bz!$?H)OkWGM(RDT|2f*vH~_w#OY|e#dBx!%TL+WypCkvg_X(KJ)!l3) zE(^wHo>^NNkWZO4IXTHj-zY{ah4EkV@1T0%6p`oYAFYFA^DwCd$}@xvs-SaqEiEsZ z{9sh#$*mA#luh#A3FJ?=MGOI{?kt{F1~}7KW8+C2;~XSN1}49CPqYb*XJ+wkhyC+W zIVxaiQdV1xF5C;c2BnF@;t06@T|7tZ3c9TSg^mc0Zn3=56u|^lKlklS;g&tfa7=3Q z+K(U}0@ zLwb+rhb#J#{be)a$I>)>ccGxIn|ti^?H@jQJx6W9y{0?+Xhx^1Rizv0*~LXlePs5QMKX}F!w@r)2yZ}xZM z7P5n)98bfIp80HG;&trDrPEo?49fxre|d-I{igNmEf-q)=6KGR<~&D(@wR07blUuP zAEHFYdGGE-DY#PbWL{t2qzNtKU_+v2i_r)6Leg)p6N;DmNLQ-3d~v2p&waBBT*UTH zSuG|saB@R<_3$KkJ}1xGuDfR2N{qzRY4`dPky?oo|0MhRF&J!Lor}`>pw$VN{NciO zVr{--<|;hZoyzF=N17 z3@gOARuF@e#wnI9$P7VGRC!Yjor3frBSD7K_O8b;T~_i2?!*G`S3pq0Q*bVd)2%=X z-T}vr9JP<=&U4>E9-5mXquL__0~U>VZeY9Hcn0G(-?9J2w_Q5XY`87$$U`QU&#f=g zUwX-`HU=M2Fi}{NIkjtAL-*(!W2!Gcr?L&XpuK$!Km3&3V&}!_Zac}v_&J7(h4Fhq zKNcBxuf2MnD285Jzjl(EcG5$0*@gW=zc$+gLlYX8^2qqltG`8LqRvh(D5PVa76+o7 z0>V2#IBi`*4;1;TjEt*qD&Z!Mrc`~M?FsR<@X5;Z3xOr>6i=R|nQ-Av+bYtR=Ji5@ z;cu=%@E5^PFsQ-jHZyaSqjEjWc}Qot4OL#;L=hHkkZC z`#EZ?$TpdJY=}B4B8T#>uxQA`7regozEp*>);ZCd2!tv$bQ@})7j+>*ai>Xqbs_@^ z*mcAMzV)CF1~xj(B+;S5@h!|g2@d#(Jq8j)TmP5ubDK=L!>CEpn~o9|!C$rLs~|~P zx1pu@s``qj<9<~OFOtp9565p(D&k@I5U736TYVJaazQ#jWmXqH6rEQ3uJwm}iSK=3 zgU_|emH19!Ww=Pnn!l~^q_7dw`utCaXEQJH$48KU<&)V?zxvFTAOT2ngXw)0c8sj+ zO0v(C&NWkSW*pzwSWVux;`V9i_rp$FIa$LVCzY4$a^`qOTdYTQwvbaXRc%s7HGBB% z7We?ZGxu>~DioX@nHBRkk}Gq8q+a1O9yo9gUbv|&oYunXhZQYva(LO9cIIid5oIN|y z?9NH?qPF`^XrY7kEAl0lU&46+wHp6EIG_sOW%@F#9Gl;9|3<)bFYfC(ll=Fi3c#dUTX&mJyCr!_U}DM*^qQ*YgH z<^0{WdgwZQs<1mu!?$IuA3eRmpEsgixdpm z+mvLR?VBpw3eo{NfEt`Wx31T`FORyeAC-T$@Y*a!b<)@##=5(P&K&-jta_E}@Ho@F zNwU~_K~L&vmX|W=*r>@9mc)5R)mp}=gT2H}wLjQe6C8zzNq^CIzoX|gtJR%ivL7@T z?aWniZONy(-z;=js3(cAIi9cl_>6n~?T*!MMO@R>)*7|KT1GtyYK>E_PY1yKz?fz$bT8^;^DVC1TOg>@}B{ zS=0Y@R8c_=IaSD!xfWs1DFQ}$WpnjZ(jqdT*o1nF2Z~F>Q!KzsI!1m0d^;_7&a$^Y zHUs0PbWz~5N=Y}Bar22PnL8VpG4bvrr9?AAq!k-Wil> zIboaSn;8l18fLE-C*RP~AY(apYtR~qPN|KHHfd+ZbVyCILjGxAS(#r4Lqr@17R8<@ zHiw3^2$Kd|hHKG~#|IChZ!me2G}fe0^jnLL!QVySp?$l&9ynP})4{Qw>B-m>SL9S0 zPL~Su7PDimZc*?XctuGVfi6bs`>Ye%!^DzN1M>i%z@;bZnsTWx2SX|RE4*csHy39G zJSj>^#tiE=K9a#WLg#wDiE+>|RH(0-kTFKcFY1yrPxm`sd(@kvIgDK4ewRWTCr{f& zof0?)f9fnNSi{9l1hfwSOpRMGImfP5&MI>7spHfo77MEk`YLL@3P))cb#$sotMZLZ ztr}bndY_h?B=j7$hpbFaye2oys<7}OGamKy<-Bw#cIzuE-#fP==771AEgaJjeB%?9 z?5C`MbY>}`jr=v@tTm@i_7*8vS_Y&H^oZIAagUEw>eou3qagm{IojM7 zDT#u(ahN26LO1lK(10wB^>D{1S!fR0$`+P3MWSC!6NW_O71|a9P_F9s#c>!~0sMJi z9_~`Ca&joddY@od>aU*(sXY+saY(I?G_uo656^`t7_32G)%Tqm`9#Lwf@su)K?b!- z`InM_Jz*3&q1ep!NxKAHbvSFpBvD~aax#6uEXm!!6P=$z1L`d*l_k+hjnHpT-5vZN zojURYM^k5Q98rufulrf;2cqeo!oD-QQxL8YR4M;7g-}D@40oI&OK}oJPn1%&|CayLRjjX1-X6`hJRg@s507^; z8T1B19!zEH=>T7p_04hZHC1R-tO;*+5vv$IR(BviD8=sjgT>>08yV(@NquI50#_uc zINIWC^(*;=y)|1yQ}uJa26$n)j=@>>=aRXACx!bvapEc8JlQb98?F=0B;yck=4?(i zHd>!fz@WoYjw5G{CAz7=gEE3&o-voL_Z3I`-M~g9Xqjb<`0q9-ob zLEWcs-huvBqiXzbQk!>IIvh#kR$ha%6)n}hr`~~Xtxij$js&&G)dVfux+q#teuayF z&87*CwkCYOtUh3v>P_-p6n++rBRBs54d{QM|7hlbH1bnZsGSmFbZvM}exnt)TVTo( zeBXGI-2hC{hZKhT^5S&`t;@91VrIv4m2e`V z?G)(3@*-be*~n z@KUhoKE+Y^`bi67>*;TBuv^K#mkTG~B^h8L(OQ4OhD-h>Dn%vzNcnm^ikqS0IQ%7&C0dAveN z2k{ggq}4krh?04T=`btc#MMC5<6|5^*ArY6+g3wbZWtVo`h?II*6#H1 z`%ET=<}cLbj^rsp!3m^g`F>O9-O{2aBqRu(pUJlj@6w2KbjFMpKbNT2U88*> zy;~{6<`;nf8a?#`T1F8n5$cpwpYTg^AEp<5#ui^NZlF49aX-E;u%cpuBbi#zdbTDK z-L}i<1u=9@ssLgL@q^jjc0X+^Y;}Z!xv_6&0^mEsCLrDmSao>n6~4qcn7{bZz^vv6OwRw<9yk+y}%VI#LTnbv9NjfBD&Ccx}w zY#y>;L_dIbpObjz&zyPPddx$<(g%u{*i$+nau*#1`TR|}y z*vvcHU{c+@G@fgVzKJrVJ%_i-m>i*PQFx0@|FM&9QJWqvQpM0NCdPKxFXJQHcHYC< zq1&N1*m9Wb5Oj*K9Ej-ni(erM*dNVkRYh&o)vM|H{ZjJg!~)sIVVA--J+>@P6c*x! z9?bDb5XYct$QiiJjkkQkGLJGUqx0Wnyi|APre*2N@+a;(u26AjO;zghe$QMNFYV;! z7A7?!@i}b%b>wfoS$Th3%6wss0(uq}rPsalbUdYfr=bF6{*81a$7jXW|Ik=#D-_^) z$()+i`hHR&U3d-u>t}sBr#-3BkPSZiESY%ZW~>N`|K&@o z$gC;5W1OZY>_iGP8FO8==*o2^H?SS9Uj}p3yqvd*lsv7N9!}?)+U}D!)I%QvP#$XS zAg}w8cmBEdD;AXgb{wR{##zPl%R4EMgCQ`)pw8-a`$~a7A7xSfgv$R_qXS*{6{Y|4 zm;Y%2R<^H<1SD<=WN$IPX0;U ztEkziMcguFoi{uS3D5N~jPMCSA+t3jv39vWC6MdX+r1usC*rkx$ONCpAC)t`HyCuz zIUP?-Ottx$OnT!FMjFoTI2BEBRefL=-6aAE%Qx(%%g`yrh|fsVfBk&WYEJ+bY~yfV zixM(r>kCh5?uHcXSazq2NRqjhVkAdv;B?##qy4RUJi8=acEOr|HhNB&Dcn+uw_mPF z(cjC4DT^P9X3pp`VthTB-5Qo$ST-}nC6g5>x@GfxCpRt4NcDnqu`|*A zR!usaYnKL;+`wIm5T;%J5OoY3Mz)5e2^hy{iPAE2_d^YpM`eKo9+{nv^LTQiN@ zrx`4vq_A-*)e0cgB*|))E@C>+#GW zSYCwck=D?0h(g$oL*0`mJkB|W&R1@lC~X^yXTRtzo&Kvd{i1P$S+?;jj~mqH@vJ8l z#Z^xu{o!7RCGJ5bJ2my3sbjzDonAX#QkcW?4@-tsx8xgv{ubwS&%JW(?&0RzApzF6L8X zW5&uQfw5x|p`l}R`a_y$mL``?PaggtgSyw^U;FPaV1XWeb~B;si=FO4L^;@WKeup` zkPQfshBgSx<*r_fR2{?ErPO3q*HUnC#g`kSbn9ul(?CtOBQ=T~_-*RgO^-uLEL5PV zk0(tBds4b&>-OI@>ul1D9pxS=iqb9S2JF+^-)8X3t+d+4t#G&SKwIkT3Rovy=-cnS zb``1K1LN;_0@c%FK^WnOlb=jnjx}xo#yew$2#*?)l}|Pok8^>CVQ-$PIKa^ ztgW(8oV~yj6~-k5Z|m+wEJNArOu9u zuz0h-fSky(fI>P^5-(cOwx!)wdSWE`TOq%qCvPVYu=&t}3BpH#BcglEuN~3)P&}C5 za9^C&k}Wy6c=KIJ_p=5fyk9cPz9;ifJL$B1yuWaaIGf~iU`u*56u3&aD$J^ppUp8< z(wRFantrE$>!aZ{uJ}@v--RfO$@g@;Z~isALjJ@@s-bak6k%bO4F9)tM7x$T-=ACo z^s}=&)?Pd&^vqA~hzyvem@TesDWG47VqiR|8j@xXa^#v{4`92?8S7qjg9y4`s55N6 z2VhM*^k38j zBd30nJ$5DDuz5PADDLbxJwgUtZMjEON<-=Q9NZ0gCY}y=@|C0&(cJoj@2sX1(FLnd zll~^Qz~dh|C% z@{u|FW4v6Hu^4~9eGQUt{G%o>uOy&L|DmVf^mslJbIQBp2po$HzdexTx_WwA z>n?aCqe?Ij=2qEkve%%-)iq6|vM=t-cxF#gHOGb++?;xvp(7Y^+Vp3jvLFBC)FHLSc~rj|Mv=k2@4#IL)5xOW5&Jq!7MHwy zxezKnd41--w*7U6vq4|Pr?-+4m`u^;a;%ijawkH5R05~KI=IsTe~UPg_F`$Qm&Xj# zTeuXQ^=GA%Jd?pZy1?0f*=#i$fAr1W>(#e9b&ao^x0+c06)2#2^c}Z2IM$26(|tG? z(lT4A5m`a_X`+S!aXJM0Y`ed0)u4%qWDtliyHnG7?5bnwN2j~Lbkc>U*nzJS0kd=^ zi+F3Df?U?L>!K!7{V3h2gj8+{1r7cFl@$lJIBYd!639=@TM?zSm0MWVUU=ZNm0LfM zo}1QHVwD+7WjQ%xM@K?Y${9pXK?On2v~=&ZM_l1jj$EfXg4eaTBn6!+x~10X>N8k5 zWrq;}f3H5 zioALtl^yg2`X-KT3u2ATmP#BCasCf4D68K3aW1MS-73sjrDi#|o9lgJ^O`<0D9>3| zwe1s-*m=HZxERMLfY(s{1mseZ-hBG$9)tHZEDc4y=+uc^aAlbhfNVg=oWs5>Qc#dj zzJ|OiL82iblOykHopMIKITeqxqP}NVT4=3YT(M!Ov-i%Z9>oCLaH3^uCrQ1l6PiX% zN_8#sr7S;1w^=SRN2P4YsQ~IAc$LR%yj*&YTVZQkL^(cCD~y6UEk6aNnOqpN1bf0D z3{ZsI<<*dL%d+yOP%u=?X%NnuJ!hA|$Ck9nO{2ZUg8@((%}Ag@4d zH`0h?g|*`~>XepgI?D}_P(QGqCcr#)*4CmZ-md$8U4hD9Y;FV4@b9znQu!+fsCaA- z0c57ge}d(7DaLe9T?(aKo}|jhaINE0Wxv(&ji0gsjMPWk!`cUj`#^{6mf3?-q1t zk}%m4*WZg=LHGZPo8=nyD*s$OQcf^r4>Gu4P|_O}K4JAyUz&n{=^uoWCVm?aF;`~u zuw#Eb6r5?l@cV-L3e^)5Be7D^d#AT2{}W$Ua6Q*nW;6Ft#C$jJaegC{84^ood~2cK z@FA%f^Pf@G3nvl~vgl|u0;ETf82x zVK4nuJ3cqb4}@HbKkeKzM1(9VvChVTOou|ZUn8IIp?Ikqh2+&%?;BKs1fNN%_mLr1 zsUA(G_^GYVcmb@c2@Od^CLQ}?1<{3>JXIeNfQGj@0iLEl_$}BsFLNwAg(b1z;i(96 zo=jLs#ud0q-Q8=D1Ssu2P}%!9B5({BH(7qC&d#WzWbT&4b9D5emz|h=rBF4+#V8g* zTn~ewYR0VMHwIM-Dc}ZY3)&5L3lglNwyr;6Q{_X&LWP1TtQ_MTcPU~Q;;J`4QS8N; z0~#O`PZ4kUl4W`U+}U|F7-aU}f{{@1C2YfK{9S(BbR3*Y zMa7;CtFgo`;k4NjKE;j)Y}FIPF7Mrn(;FN{A&1m2j|j9bfl0Co9h8ovZsDCq=kGP2 z!Lm1c%NgaHS{kI=R1s{=UlIdf|MU@cUndAJ+?;25=-OueUhcnFQjcU-lC$-${qxUl zL9E$Hd7Yc~&9M1omQt+EwNw=9sX<9M-rcXKz%V3MwiASG2x!kEc7XeTi*Fp4S1`9u_l0z9C~3D;lI`daShK=wu!%#)z8h&G6}|7{@4-!uvlOk-h@P%$$J<&g#aHUwCP zF8d=#V7z39{LrRHF3i1VmP8$+Z+lMiE3_eb0laKqCW@uZch3I(wj`SCH*|#9c)WPt z1ortKm3(BIMzuHe9jqN?EzUEtC)8@mFsaoYQirh2Hp)&31egDikyYsRJC zMpT5dl7Epm7Yr}OdNR)5l>Z<%P-vyfT4z`(Q68Ko0kr;!&WB{7BiU-rfNS3XMejCL z1{;4`FOANYM}e{gicjewn67=l0*dx|G<`gDGVKK;HGVj2-)c1`Sje^)b9o$3Y%mfW zY54j}wb0CYks&byv?LVa@OG;IliE@vs}>N4a*E~pEgo(NDQ)3{D6Q+kACI7vV$60-83Z7>_;G!D0dOU*VeDdk`kdx z@8*L%1~wKiQE8mrGu~OHCXHzSgeEUUbd}mq2>J32Y65ebc3SRahKPoABH^ce52^lhxy@$ppEskOhhMEwe)XsH3)+25OvWF{t(#XaHH5`^5^OYx*}{IU zv!`zfZv0z&d*P+*;czGreKfjFI|v41T-aF2!6%2;H{!eSDZ!$1QWwLt-2tn=0AGJW7&<0b35`GveW~El30lF+QG#Yz~^XbN{P=!yhELy&R0o+X#M1BZ;+YW=VK#lsd47gf}! z@FkIDnDu5W__vbR^3vEvTDijw2M-k12WNi>K>I=qGS3IJ&uR3=yoxH=4m!YhL75F$ ztk1pOgJm@+vS%j6Jhuu$@wfRm%V5yTqM5|ubdP(XB{u4=&?e%8A zRBE8olOu@YMqWa5ny^yvm%&_QfXK7x9#^RMJ1cbn$~V|GI6iDVSVce}ayKHM{vyVn zIHx|N&G@votN`&70z`U;%3@mx975g@8sv_I&7ba^URShJOtClAJ)Kk*s1L+TtnZtc zPeM0Ed_jcsaAIJ9Qi)m$4q;8KaJamf*+|;m+c~+oxAg&vK9g4}2bTa&$k1<9u&aVr zAAeJ+TC<78Q?)$XyGHn0Ez`S_j84KpMt)uAxLZeAUXZ+L=sVREC%^Np2pSNVuRCH@ z?jW6(<{4wB8-q##V?UzVpaWE&o<7cmyOW!%gMl$+8HvH^^Ia9(Eh)l?0k=p(u_L5* zq2rX%tZ;~^B-xVtUq;=R3K2+)5GJsQh|tx;(Xh6#G%rg4vhDp^OFJ@x|AO_F#zUop zi*$AFjH00-Z*K8Ry#YVFA?Nu zA>%?OQoY!lX?Y~Fz}Uy;^5Q0;a{a%1q!TaERSO{mP;69xkD7kqhs-JbogEkugf|9oM-S!>ra&485eb*H_26 zYEz`SAe4$IDl87>QShl~`hLOG+YTvaMi{ph{Mkg2TKZfp{EZEqT)C{7j6W2d!6@ki z7lwLf#31dZ+q`b2!0fpGmCN+z^T=cwStb>{Z8|i_ z7|FvSm_*pGh8^eCn?DHuY*nh7a~@{K&80(mAO4YIHu^Q(-yh&k{Gd3V6MxUzO;?##Um`OxL%>*^z)r@Z~4V< zVKp~w&S`wNwVBIt9WaGpNw@+=f4zB|G5bez*d>}u{MszwwNJ|9TB%GR#TME2enJUs zUagZWp$73x>1FzOF;O$&3&dMa^&wG?4KW&{$Y(;f1#gS_1x}SGCI`c-%3_l6yWHPb zgGl?_r9c;f9kp?^HT-j$ocT{vQuEJHHl(n`4L1&LcMa>N*PzY1&qi?~niZ*%>#z4@ zMJdmBNu=GIsM{Hf7FnVs9^C^!Uv;#eMigqk{h~emV>h~ZZr;7-#p`ip*8Q~hrPlX^ zD~53T@;ayU@_nK{s|lJ6wHunI5+ zth^YoHS1Fm!}w>+4 z!iG@uv=NVp74(sajli_%GG<+C zsJ5CXjPiJpwPc_e3?Z>L?S5lO8x51?x%MAT+GFv_&I9DDPn4O5@CqHsoeam5SsN2A6e=3Z|`0 zfJtQSA*;DG2Eois-xy@sQ6*$?hI9%~cF5d4qY$K`5RmE*lx8s!ZPw7eEF4yCyWgr; z_suRE3*s~;xJgo7g-MzR=^&}Hl8$Tm)rPehPQzY(PzvEU3uQ-ve3X*0x;B5C0P;V8 znhQ{1r&)N=6J#51w=7b4EbG z0hy1$@Ja3=>`Uc*fWD3mVeoGY*XY+Te z_vAh4e+-2%%HYaobY6BZ;`^}6UKw%l8H|V`)<)BZc zwJNmDAifkEuIv##-!&U%6(ygt(k z`a~%CZ|9)3P^vf_btGSkn?OqTtEAqIzdz(;T^b3Jtzl|&g*b}%U(vl_LB)x7a<6*zDRTB(ambqnFfyhn1 zXBfOYQQc$TW8u_y+=^80@qxdYJxOU*>QVx4D5?-H1FO2rY;!h)>=*y)taVd<%~A(X zNGCHnpq_~|TGq#%>)wv3rYh<`6X52~QQaCWY%rSo&ia{TIuvPGaQZyYJ=Zhyrx$$k z9o)zjm!Z^b($a4`uAluLn5F3?72Ec0Z$lQyb2u49FlP|n4rAE>^}h1hLuZvvgyXf! ziTzPw%-Imq+tP@@_8!9Y9)em8Nww7dFyF(pdR()jb5jZxem*>CLnnxTt*-IveKf@0xn-gQiscwDUSd*8h42T^aI?8T(s&yqCjJZ3e%%6z=yn;Kz48{l4SzX%Y%aRb)sb zm9tJgO(IXs^Ua7MH_QLm0$lSnFMFQ85xMXOY$6bP(wgQ-xY*k;4dGH5Dnu*dp)x^T zK?NG#KXNrQQoW=vK_aV1M!5zUBP2yC4-{jBHwLq7BgsCykI!Ef4~P{a2mUewN4z+>g-ab zORD#G={y2eAIiK6UJd<{%Yww%dzftjSrzXDQV6KNJJZj2fAatq?L~Z#h)93_iSHJ5 zgrc$LIUDL1#R+z(XS0rV9#4t?Imdi2mdObgzvQt|yY5EfVRLF=@Dbn}opdjuuL4^u zbW*9R<>jYknZEPV-^1hVa6F$$Lp0jfwEo>FJ`BgKfB$UuK5=!^JbwA?t*G|1;>e;( zL&uO{gOCV@Mu(4vHxg@&V=7KIfYB6_+t;V_*U&y`F)cK4-3z*-#kbR3$9NfSC zc=cYoCV9{d8j-YMa$#4_=ZQlFKC5U26khZE%_7Sv%)a3$^AueR-f_-?|N9_$Vyt{J}2$p$Nza%O@>)1g z=@oQcd>`YKYJl(}u~;AmJ`=fm)aSbGW?bH%%?Jd25K3b!XszzkAmTcUt>d~Jg?-$5 z0Fvq|5(Ah2ymfpeW&b+v56(~&0v@V-aMM-V(YjcZzPNZSyGFx z2frJ*+8ePc-upJZmQ*x|89I8DEjSD%^#cDbMu!cbzk__kil??W0v=~!$h{hW%duSU3 zke%-@G<)a^OjYWzIYT^@O16u*f7@RRbQd$E)RrSzESg+-sR%YTh0IEo)El`l&&!_= z7YfCS9~u(HveBgZV*4bK&CrPKblQ@dYCuousGTDOu@RIuh7~!_N^S<-huu1$<}zVn zB_8Dp!OcxU69sg^8b+jFoYAM9P;wsk%U2H2=>$=U#RyC2Qf~l}h&6Ro=7cZ7!eqN;y z$J#GEgab+F@UVMSIT|yWtr7w7+lGI&nAMVtm-w{;lCh}9uy6rx&;D~RDWsB$%L_@3 zE*^54j!sH7I=ql6T_U835?dEr@vN2(aRmsg89|0l@yXw~qcQJIkz`$-oPg`o^l~?6eeP%K}>Wos* zRsW_Zm76+w;wK5@F(M}x;p`EW|q!0?Djj&Pem}c?b_ou zKI*g4%G|?PQh9XZg!V2JTD)Iy=O1dK;1!?Ox+QMwx)oSxhd)%)&^sB6&G_wUKdR%R zzU$k0RXXn`{2QZ7Z8T9uwTeS&?={RD`Wj14FZit6+rP2q>)uxm+eIoGrR?Eqt(tGo z$KQRxKmYH|_X{!;idnt5e2S9F+RLPlrM=D(l<}nLN(Dkb9AhMYOmL+BY#J5HmKSwx z=SCO(VFPF6B49waVo zAD<_`B2y8MP2L5^jlaT{}Mwv*=PcWsP z{x3_*DifclP1&`W<&tiy8c%6Hv^7-ezNLMFZi1AZ#7~~+2tJ&mU@b-n3R&4R1Z+eM z8!~o?>J_OtO_*A=M18e3m*4IH%JWb%<&MGOSucs6o=DESO6{B*OHA7c$!)U6 zGeDSZ1m3hc2vSz6%D4(-Kfi#tz+Fvo5yz(xnV@8R5`To+t&f z!7e1)6B%{PM_l!yj$gC(qOJ4Vi0Z}y_ie+tg+W#<7#*lk7$Ql~^?Oi&8)2D`^CMp< zW#gMgZz-f!-dqAACSDu04VgZzra}d6jt*Qde*fjN?s}oY1eg=crpk{c=AN1JVBanz zS0)+u14mwHwX~hSrL1pdAefrSeo-Vm&m-7>?`pYekuVh$AsQlst}sAz`1p~|&6KVZ z$;3DEkP8wV2hGL{*_TR+Xl|R@s~?9)KU}|S9^QThhK6IQ>p7x{IY1-MHkBY%_+T|u ztL5TBNvd99#g;JsIoya?)nBHM0guh~eaDZUEZ%=;Ra zUhiwIf}n%&9FgbK(Z94bwtXZ$7kw;0+BUK8a78|>5aM+hmDgr+_#lFhrKzZugKtfr z_f&As{>nU3k2P~Hm&R=L9m1YkZ^rS77d=y%Y%0pbRe!dG2=BT9*X(1a@iqMey&uip zUuiD2{%@}MS3ZgfceRM&rDP2M=AMcZPcqbgxI4EtlqgL=;D@`h(m~VGeW&`9-JbM= zy9OsP?v~N1sEuq4T?$ROYxQwV@w3l5pLpUUZd{8`iVXtHdgl6^WEuGWDFfSk^Yq+a z|N5;A_%E4t%Vh}V?aI6F5Ik;A2H;2)o2H>ja8f#|Uz&keuYRs`;xlp^YBIzlS~`X! zMt*;n89%|(4Sav&7|GNKuJN?{obXsE3{v~w*3IZcysgVyLkhQ)>K(ShfL-kN@9}lx zwR+9%;Ef;rk89@a<)GAAFsw}++&m|e!)?Ffa+tvDHiW|a(`tsmWp@|SgctZ+SiOQN zM4I1Q;P#1Eeg<;YMhC@EZSKcnu`Iymlw`pUW&*yW-2W6{Z zPot=-o3`71zr+P+;$}H!WAK#wZ*;T}0W%C4X@yemUMgAlm&G@1TIEl2PC*3&1h&rc zV|y0Utc!Ge>v@Yz6=44!SH+S^s_P? zwZ;cFHhhnQNs(vH@u}X!)Qzc%E=-Py296SGHF8xdDugf9WJP@DX}=VVW<%_5!@oW} zw6kj~aZz$LLa2qsc3RbF(y~=j3fORr(q|18a(`$!r8LRa38n^8XVP6MsI|;aQa1*w zF^cbD(Kq4ZC>=P#z#lOAP*5S8(_1U6=|@u~W`~n$yLeDe^{1oD{}UibKL5B9^xG)w zC~C1Y_5&f>I&N8|Wut?ei35l|)jdXvTNW+DWn(MWws#&A?3*aynMxv&GcuFz{Ojm$ ztL~XDjk32L>Mve|G?^}cVkHUdu>P;PJwv}U+{#)ciU7x+5_pJMCR|teWLLmY8W71C zWQv&hPs=e8O-8J^QeLu)7$iVAI@$2(HQKh4^739;9?>6moP%M%FL{s=6;uL@@c?hr zr0$JyTCK|V$2^Jf8vS8E&$7~(NtD&y!nYZPkFpvlsSxHU2@di zksq;qai~GH;YJCA*OWMu6DWKg-WkELG7NGK^9ODbM`}zRFSaWTUs~9|JzlhDvj(I# zxHH_CUEfj3Br3(VK}1LEtu`w^J!rX{osv6P)O?#EHO_e$mI{3Mq{_wFxvPFThyCTw z!G?H_(G3?N?3XY6_upvSR@z#Okp5QZQ_`ckGxRKp-L^h_bquCd*RvmlRNkjT(KBhg zCnO+Y_}_ECR6zRpB7*%XeX8Gu@{*Xyqb@|H7U^?m;OQA}-fCUo#gEhDqt`wJUn`nt z#OF2hUEt|@FFe_#|aZGE?lm_n=o8f8(ksWd61a;;_!lVUVk6)J5Dws> z_+*6Db*jO5H0p~NEeB{^=1PQ2Cx1MJa?HhCH9ST<9ML`o<3Sdq1v;jK`+6t>O|Mm* z4@lPJPjBme<=`!;6`&uC94?zevWu;wiP2E$(=agb@h(F=RaRD}?hJnaT`zVR&n|7h zBY!p`mVL|9TuHc3C}vg&A;T1M3XWuHTDY1YHDh1WD3A?3!-j?qDPGYo%a(ir$W)GB zX;MmHw2ggBl{~02g@Hs~Va4PQ)|mI=A*y=&QpQ|SuqOx8Vu#sE)pn_(I^HT#vN|2Da@g5!nXVgBN+Q4CuTN(j^Wc~ggWjF>e4kln zNrR3}r2hC&ZuAtL2u6Zi?|E|*U-5m7Koh$H#%y_P`llHNcRX1oi<6MJ1Y}bJLQOOT)L0}T2p0#n$Q6OHog~zM<4!oJvasV&EL5{8b>bf1vQ_eMv+Z`63ca1wI zYZ#^9B+nE!G$&*=xD7H0J0(u)NR@2ieCMkqDtd~B)Ddofi^#jL7O@)uJZ5;2o4%(p z*_ur-^$ADI6lJTGL-tjRo?lP)DqW!-)hk+&4yY!b-X>6n_6qmS7sINeKk zBSPipl3~Nd4D$^6Mj#O8q>~lp*Fu!q!pg~E*1O64kacD_ZxaR%(s-ZNjzk5ONyZT@ zhCh7>qEI$?q@W8(eCK6(eaRgLt~?#iR(oPq#cLd4(-9E)P_QgN8@+*4joS8g9*OvQ zAcV-xoX2Eu`)0IM23c8Y4TMB}9T(vCV;S>Dl*)zCm@J?&IyE2Ev;tJMf&`ZWgYNP# zuDAQ#*LR!$D-Wh*aERQ#=281PGd+olrE$o~>)%Y4pU;WyUy|EtA0SvyOn_P+)sCvF zbC(;SRUR2y9+#8Ulq%`WhgcnD3wF`r4{IvTo*JR-jfKrMJZWVTL&P|c0^E+)wvr19 z_#;DUPZj$J_)r1B(a)(WMFG%nC|V^8GSl&=4pOsQT9%n=&FNG(e>h5){Mhk@{?oL% z>ws&&=NacfPP#=&9I!bn1)A_Z`lfSVKq?o(Q&F_yWyKn-xMVrhXIueZ7Pmc4lF;pV zp)95zSaw4q^ma2u6!^5ie$)^<4)NvEjx|~q>IO>4*6ebvaSL1n7`P0;K+z~!u)7{e zUiH2@v2@=II^0G{9T`WJ4Yk0_7$V&|xhODw?(T2iu7ey!O~C&lLW~bIUuEEafU1`f zyZr~%`8y2Kt-U*V&WeNvW|33i#*F97@%i=Oku{qQKw1nyhQr88WR9m|;4q7WKQ|2> z?eG$}8@jTackjCCJ}G}d{w|WSNA2f(?gg(~g7w|ElX3N3SDh0E1Ho8yCjd^t%os{V zWKjxzXXQTL+62z$>g68CQHB9M4^2*Z$VxDJS7~BydCEgwJGk(PS$+5Rmj)Kbt*cp?q z+4t~eIvo}&t;{Ov{|+x-P9v!W)msjKT-JeH%*Jz}%3plwvU1QC=N{x(LspJeOMg}^ z`hE#oSC^DCaD{4YJw2YGpy9cU#jJkmjLrpYMd>T~dMaf)uhKt4?Y-<@DI^l4_+nNcVeUmcry}rNVUKW367xO`utO>8wHS~5=?JI&%L>9ITQ7x2#mlzn9(EG2C zzmUZ&a=mtSpi`ZRbjLMs;3z_Pod;sahvLy{Svr_`?~e!SwZw!gl8Z|RR?Q|T1q_9D z3dA=jsbAnl#+*ZI%HlKB8`*Q7V?*F$BYHbb2un#-vy}1RK&trv0t@9fWNmB!gqFG$ z3GGb?tS$J(EadmJ5aauP{V%`FI^!-WqIP=d(U-?AF+piEH($ALSC^Y3VY9~)gk$z@Oc`I8@UBy#!~h? z=>3EgNs;SSJYjw*XUW}csd~wv9P_==0{X~lHEb;rPoz*H0ke|QV1(>7K-6QIQPwAy zH_8)qjxAuH&aX+I{mB=OJJ)%N82iVp0kaL+ze@_X{5IA(_sYq2uE;44gEw#P+QHkS z>2_atKy+B=dJ(8Z;LsgHG@%;+*aL#JM!OD@m)s4L&DloyDndWF4&p!02`Dt7esF|& zS3bpiNlQxxDcCiQ2prBK^m10RXH|ZUo|324(#G=yws#DM>Ze!o|9ss&{W*k6s2(wj z2Y%TFR_gS}lz7W3CR!+NF|`8xZMN&glzTzw9O3av#6l4oXqS$s9J)lko8JH*e_vH- zCo!-0V**4G{T;_MPRCOYXW~H+tI+ePZyme2P`Q5$lgZ^RQWylE=Afu$n4AcWY7!rc zs*M$rrR03;D5MeyV8pQ2-Nko}S-uCM?ilgV|IF`ta|ph|<{)Y+Vj&YscCmwMnS@-K zlBgV|NL>PQBx8#8*g;cG!iaxmS$L~QgW{G(TNh5O(TK_JBI~a3(wU}TBn!$;O_`{a zS*(=%^D1=lJG(?8`>dw2y4OzfBip}~f)&J_iCq>gB0VL`x|uF7`a-fT5Rh7H2p6WU zSNSDD)fF1uc_c-hJM_g6sq!wN!l!1Aw<35^^!b+S~O!gIVs zS1_ein_J+Okms|d$SExIQn-G}7^b;sypw+ZcMX(29LJ1zwbe6Cw&G zBowz=d*Z;VyWvvAuQ_j&T0MRx9xmV$tA{0Eef6Hfz<+ftw+}dasY<-N&u-`CPtdn%einT#rFrwjU-k8MM2Mm&QPI zT1}hm4@UezOnQ|Bt~={8z)2p_?V$%pM#5foUeuGP(O__KbGxn@db9huofm^}_6~>C z`N=5K#?j;Zo<>+vv$#@5zW3f!qw*gmADN3ut65aKOsO4ZAKjTYe|B@ERs?Dmb7SlINkBM0UozC@E!uNXzZ4$F)XyGS1PC) z+fgQZZyLf}TXC3)Wv8Z5{5>_#5o&NNH8(Dx^rT{IF<>;)=`xwb!5^_#k~s)@Tg59q z`kX2GM=V}3$jsME}7wOmEgBuI)y8u6daCJ30+;DYq8v>~GkOg$lE|Y*?((poQ?0)ZY z3C)Lv@KP6aYAZF8;eng6d@2=9v~=Ipzf{gPeQ^y(On3`StK|E38#?D)Yl2D2Bs+l_ zqSM3%(*P*y?V&1>eVM1<;gNTl#0aI(CcCkaM+%{{>#uIkT^v3bVw9@H#^5j3d|?Ql zm(UBB037S)D(PCC)!l^^%StVEpN-9D68|f01Rjh(G$PPFz`N?6ruYzDr6RBaJ2%72 zY0CV{x(BXR_<78~WvybmqO6df3NI+xkoOoZ9Yp7I z0*Z@3*#A=E)%{GwXN&3WNTp`)*f@et3!vlLmbBgO=zkO`gFhi`G8rHj2nt-jE358B z^#_{+KsCE?h_FJU)!1buHRj$QLIGJS?G!qsaY>d(bBKI5fen-Npxx;6GTY*DDUNGv z-iyH@ZRf%I<8d`K>(nNVXFQi}noIDat2bR@mf;DpEHA?Eb{|Iz$_>n=n%hN5aPU0m z*RlshLe*Uh$F%gl!yJGA4&^}X@$kk7g)w?XO2Gm16f|+l>c5W^Pij1MNKAk#e6Oku zj<5&Y67jeMEjA3K5l2Fj!YfPwPIKK+!Mn?^Rcq=7)9E$Z&#P;m#$`lOsSKGYj6rja zUq;Hl8P9`bWnFfBhNk>bhLRinj~Op}U#}$9pk3ml-_neAdAa=edO;A*P&N#BEWRN9 z$k+7K>9F#fL(v8>TH+^`rD(eS+ zYRDdy=)f4~O4!=*P_#B6(&+zexO8)jrx$77pXqTj4hfB#vU4>LBG zKkEO=dWrD!kS;&h586KQ4Lc#u_|QeGoU)dM;N#mI1QUde4IiG(J9Bdvvpa>QzxX%P z6)LcCq`59iuRBRv?@;a9;@Vp%%V*__3ekNLXJ$Qh}gb#J2Z8 zwp6A9)GspCKYoWUMlwAiI)vJ+oy*9kmQXf6A zY^iJM;xhKkfK)quQ>e)hLXF&XdUd~3n0vnxtMT%ailb<2X^Au^5wITRX9Y|HXe4Va zjtesYZ>}&X1S9_dS7O3T8*X?AntpYxNhZRK9}osN)Nwy7gx^dcYbc7(&FNSyAeCdp ze{)e*Yawm~_K{`NiG2fQ7460_zq4G-wen-ZU${A)3d6Q6sGoAK-s zR*LM#L-$x;+N+KldTc-IC-e`;tf?RTzZM_>`cd%DMVupiPL#M(z|k^|NjMg5lj<_K ze=evFl+tR@T4t>}_tx~3lgLI-ag?%%(mbS=NhBHyyUMuYUGDk1)ww=hD(REQ#~6)# zKtlc~8Pa})MU!eGs;ZVHt4ZrZ1(A>o`DGwzlu>Cd+yNaD0@{dLLP}PM3$q0-j8ghX zyj?_5F&>p2dWL2mg;pwA2|-GT?`x7|hJ>p{^6&}e%y)806Ms^GLz(hn43)UfB zQHrqI5*bwhUsI#bne2J+6LGw5XG%Jud9CfZB!bgaYY)orYW*8o z7}a>8&x0t;t18vBfPf|65?jRY=Aiy9WFg5il?6SeTxl81h}*e1S-mO(CmxR6knu2F zzBUP86(rFT^)18y0Rvt`q7Q`A{b${9yiP|W z+~W-Ple9>qmyCVlw|Vl#Cn+n&_SeHF0pH0w$g}Pefaf-vN-abxC4@KTzx~xI+T4jb z<7o<8=jN=khRBpj&HM*at**GKVb*Q~Evi`w`@Vf_Rjhh?g9h@1vFX<)y z19@70sK!1AuHTk59gnI{qvd~{x*MRVF93nFM}miosmD7x;!2_ms2@ff-?er4Ujo2~ zUOB&0&%@^+*e+-pdrs)?MS)tsmv-?<)U3rg+Tpo%Ri3fn?Q(H$`*|C;x63d!NMe<7 zas9VQDWR!NEEFPu5cA33vM^pYIg>NX5l|Jg*R}SI+jcMwM>h2CAw0-2j~U2CIMH6h zozl()Jk53mNrSTCYA}!Q+-`fqR!A~okdP;NE9rEDUr%pM4f)zu3a^!rdLEuuCuGC@ za%sVxpMzvM7*Bv0Q+?OZhxRW`>IRQ;uIOwwt z%9WL~Hey*eo&e3<$0L#7k3^AnNh&F!1~X~KFx+^eFA z8eM&LLoAAOVFRK4Ih$W~`e*uQB5+o;C)q?3JMclI$K>YiWbk~;{Tc0t>s>X|bJ78c z@6F0sxYMQK1?J6@%G*Fu3|#^O78I0Kgg0!mR{yhX~o_^*=H&vVVMw@mawynst zFE)n6uA85)oJu1TvbPfI+eZj<4f|1uUC@#GvE+A1k*rAF$XpprtC#M$q>Rea`40U| zc?Tm%LQM)sr-19u2=BVM4h>T{6DgY~Q0RUdxdHtR+q}ts+UG09XMTFl#ps=Oh+mqm zR7e-{?E|30aiNkp&{R_)dQ8i%05M-zo+*QE}(19Rg5WGl2>MM8FZDRTqB4JnY&OAu#7& zHxJ8%Q(_Vj+)F}EzHY5{A#dxOy^7SUBa2rb^x=+;KVU@@^-8XynbCYNRg7-RNK|C! zZQ>mwr}a94!Nw6D!>|~BH&sQgRLT^7)NC{3okkR^J&wVHA9NUl9=PTIno9mdbEu`j zU&f?yrA3Wg>&eYkNeu~`BLc=ul1f-*>j!=vGmS2H0Qxtg#tMndO7x(@)tEf-Oj#^g z6s#+&gprt-_Baz)bj#G37o*-KuyEiE$}#Ts^TE4S>-yU1OfX1O zX1fp(MdZmC=SC6`n@CjHs7j|P3m?MghlJVnS1g>ZGMTI&EIdnSpkj8n)VR15 z!q7r!na%%_`sm`A6I=~5NTWY%6^$En9-bUp58^k znupN>U6v1DJ%r!CJ8WF%Sm(=s4kt6?GPG=r>m$2LNPd+%GTVa_atRE%?R2y9hTozm z?FQv#y=_L17g2ENNTOn;FpL&5>6+-aUMm$YU;UU9e!{)tdw~Y>t4OwzOqg#Jt2*=o zWqg%Y#kh5j#~bNBpRLlLW$aEjwWc`jd3|B zeMrZHj5l2}a<1|J<+i0-jhXVV9|8~|5mJ&Q;%oD+k7l>Tlt>)O@LM2J&`I`7qtVj+ zJG^rm9~M!XLpP}Bn%GS1-5e}zuz0!uGckssi8%tBBykFSib-47$j;)jI&wN3g@>CZ z(wF-w&}8iKUz;}MpDVEt){k24TU>3F@H@C6v^pQbATGyGpv&u1mO>#L5WWA>sObRS z1)0cTUFEit&0PykhqXr9zGdB^*07iN&$^wxGk5clQTHaZ@sj!mZ+;8=-!4+-1J zNMpGAASfe<^415YK61fijgb7??9RKa5tH;!yVa#l!w8mOr!!bc%xd-`SoOw39yM-y z3Y?lJ{MxTDh~nI{lAY!Uh%prPmGEl>T9Ayz(F@rcO|Y$C_!0XU8ka%`TMiy41~Q_C zlUhKP+$K6YRw)`LRUXY+amn=+V{rg5j>$8`EGvuphtYPkFMR^?m5MdIO6ygsMTeNG zi<{aWIg*Q9s~V#kA*)ni+e##^nC46HI7xH$Md&Mu!Pf}rlw`VJv6UDa_(8Z^lZl?0 zs^(JM3cWz~kM8PnHQAFVj6o@hQo4+)FhrkXBzRw76l~H-3?4oxI_RuHJYFsLj^YlaQ<)N7aLg4#z7pax9+o8v2e_xZxEROAQy& zH3-w2H@rhhZi!btWogPmm2i1z+sd5tz=gE+4?}z)N#8MEGx2q}V2t>+CFb&7jgD#+9RgHarK#qpkt>R< z6hzvN{q)GTq!od1%uULhWj#lou*n^85be%Fa^=N?sR?ImF-4~QG;wGjObIak%ScV~ zv8Z0X^=!eV9Y{g?w2(#N2H_&;g71QQqqm3pi5%;H7E-6zdTl87usFue>Une1*8uSd zPzE^Rrg+CcK{!Fo>!V$b+SE}`nu6rE=+$rMT`U{;8RboGdrMd_sb(c0S0QFKsM zvpurQj`WrCe>l%&t^@C19wJEeck?ADzp~A2TR$jvsL#`&hMvdb7Eg-~i6~-iPr^0u z^V-7SS{m%yd8h}M1kQ>DB6;BDo{Cfk!WrKzfAhUE(3H2RX&(JWUd zgUc+g8!F@tZBH}Qr;#{DJlfJ zs(W{R{-UfF6F}#j!NJlQr>T2u!Q>+;>gul!^ls~AN zQvcWf%AuLERdeezfZ|HzH{FDx;o-pWy<*50Z##sQiN(hpU~Vfqu8EtH5nEm69m(<5 z9n-cpS={Cpi!NT;CQ+2mOWbqmrSJS!ZT9nyJMY;-7+wXS*yC?``Iad>TiHLoFh;xT z*mhJ;j#W9l5_T7L9T3#9>&ULjHzw3tB?%*e5`l>IEBlQPa7RQ$jvOIIt*8nK5hAX# zZ;)gkS|KbTn%ZWF-{IAAy3q( zC8YU8Jpsc_+$9~ulMIp9wb9~5~36YQ|-0vU^>e<&g;!$TxL>eB< zo;`cSV`9U#g7PsO+w3Xa#4^AGnY6xMe*^Bqv5+nB_%QV+M~*i*=B{V|^vY&e9nY?D zI2(v^moR!XGqwRcg?$MZ<)UosWaJ9N-cw3UKu_$iS_d8j_^Hs$Qb1r>p9)2N`~N@BClw(evzc*|bNS zcKXzCx3igGOSS4a0+^Zkti15sRs8jiCu{OGVS=x5)PH`49S)yFp}BIg4+>+M`u6$q z?wb}7N6V;PiP-&mHxFL%IB_|99v6YjL?qY#0rd8x??(7>b*g+p<}GU4G(F0ZBgJ|2 z{Xh4Tp~{Bm$T0+b6t5Og2j`1OOCS4kr+lqr4Z91ylmHn!Vt zyZ-VG3novVOrel2VwfZ%b;4HzgICLF0+=vi0;5Lt^)ntm)Qr(k$388;F~)xC)G7h= zq4ixW=lrCxBQF}Yb(Nxp4t3mfRoqNVM~(kT_Y zjlej?34m>yc`(cnBcAO*esu`#_^_u{ri7hH^2&6fbk5G)_hKiKeTALKZsYkylBqjl z@30e@4rKpeDXy)s137a#ap_zxjLzl5kDtwdB>ha(D3-P(+c)z}QZ`m5w#;-S5l^1z zHTQimKwF!faKl40fgJ(DQ0`g2yd%v!Wy%x3 zdogI#LfBaKb$7DPTNA9SR|J3_N+c#7MywjK>K5>qD*ZR>a(g7E=NXn0*hKr`{1T~ z2S%Q#s4ZlP2%4%-cq)U|BT>{RQX~Y38q^Xb`XEYV6(+P7VZxC+R8*6`W~@OxX+qT| zN)Hy4ENQ|biG7Fl3LyTNDryss?BXXH-FJj)VxOYw*bh$a!+js3?t508rH3Tng}A==a2yR8*hNwpL0H0CSr-!LOIdZ%?F(b3x-6U)Sv^NS9C&KD3 zp|n>@9il6~#C$`3`%MmM-pmO*riNeN$77O5?SxhYH^PEOf^=wxHOsEh; zS6K)HrQ6rJ!TW8lU={IlNl>HiZ$QDbS*e$bN`JeOn9WM|VVfOoHR9$~t zw;#*f&mYTvpHRwc%cw$eOaXVN*^63quj=L(^Z!D}^6s>5(m(7?z`nqJBXC?>9>koF z+P_e_lTD{E`byx!P1vg(Z(@kZDBwf=WZ4lo5%})L=~0dx4&rRT&gv)2c-*tm7dB3h za%_nZNWHm()>_B4;YUpyLk%KNPB$h`?l0f4z!<}%Nt1Z-#TUWNK1>3ZZ(wyBweJ8^ zrc@307B%+UZo6&v<2HTe8yF-lzt!lG=RHmwlbO;M$%zv=a%>tTMEn;9SuTmvwJ;EW zg$=-ZRVEa-SaEglT?-ZuL&%l?zdm`#E2JN*$#z9g@&NDH!;BoPyE0A>7fp3;o5(q?T|%8Kp4aJ zK`ZhYhz1qndI*xVO9%3--~8Qjg3Euy%-17!EGy&i^9YfWl3ff0a{y){EkN*_+8$KU zRf;onL!#fk{V#jN(!>Qrp&)>Sr~sXy&1H>e_p0b+U_6X2ua(tNW-;XJI92F1r0XBU zpg|++7eIF5Bca^{rdb1{O57z$c(g<{o8L&FWg-k^jD#ACY6uX4HQri5U4jc>2-X@6 z#b`{dU@;Q9z`9jMEMQPEDpu7RG)UAYKn0^}V@(#2igm$wBgR@Vf>l+6lg<_u1jk@7 zDq^wL*;t`u*04Itfnvpz1zcR;Dr&s!fhxv|h(XgrfZ{j+?t3<>nT4{Nj#NU}@Spl# zGP*+1N2%m{HLG$_jjRnv78P{~kX{NCzTT81VLd5A0I|-h!%ZtzNE7N+EFAg4<+s)m zAUuJ^)vYL4tQAL)5u*ZbPCW+1*>tE=jDR>!2g50XplZA#iCWh`W72cTqH3&BRK2@) zgh-$+WM(vuV>N*&DwKhO1gcsF1S6puNy#0Q085Di0`w4=CJl^eOeZi3y4DefqqUPY zGzKjxF{7}qQHz1muD-s(<;$U1Pl0YJ$>ZZ=xC`dQiL*vrVWJkp^3-l|>hO`u z>x3}$H}cV>v9h>F2GN&{lZv5gvXrR_oss^Kh)zGv~=!yXE7uC}t zP*3(KM~;n)9ZtG&(&|yWUY!+=X*C+PXMc|lUj=>)90V0leHty71?3zewk6J?wMV z4wyo<@_~p@Z0Vn>w&sPG`Q>L`rSsKhoF-5=6&;`ixevXE-u}-|$jSGA88oBHq8G?X z_ur#;9QEL)>sgLBF+Rllf1{U)$U?2m1?0%FF>o}n{d)3zN<_Y*+V}iYjyE?1EvL`l zQPh9t;XqvVr?sxr@gR_PINBI}2g>EDE)S*uTXNrFBlo{ls#=*i#J)>833WvER+tVm zqByIJJ>+rEkt4^3VWofHai9gn1%`LUMM6g;#xx+(L?2kN0GSV5YnhOwS@_p=W&U-& z4XZ1Y*jpqphK__R@oa{ikO|c5m-nXQu_9&)5LC~EXp+}-Axuis#iy@o59=%VZ9NeL z+7%|M(qg)hsieFD0D=%%QN%0iv>ln%iq652FfzO3 z=8g_Iv!%tU7(|+mXB645bwrlx3HMUvpelzxf$3yCHC6!4j4HP1Yvr}FZP={Obhnve zI9`d%vYHB$$4w25OVlO=ATY58rl43PFtHjNsz^ZtV^zvlO<=V|L<1ovvZ}_aNSK~2 zv8WF;hZqS|iBv%27(!!IG*Jss6%$xu0ul8FQCIKcw-3I?KH@jz9bK84fG zcCHX=F=|A;Y=oj}@Zt!@ZD+|7nsHWlh8yCPx)ppQRuLm2URFV@il>kFB2ZW?cv6C+ zB4mF+>VInn`Xoc}svzl{^7@|;sysjHk|kV9Z^8s*NfJ2qjVjv`>y#%F(uDRwnh;e1 zt11fC+ooWh`iDi;eSb!bMPjFNp~fO&RRU|oI_VPYB-x$Uyj3fr0a!& zyP#Z2VCO^de;B_~*NPC9#t;|&4a7eHYdgp*KoR9FxWMY(sQo@hf9oiX38gN%rPd)$ zxNGCq2(74$!|*;-D^l(%Qc<#y=~(>;XcK}(cphaP=+?kAU>a)o0lr8oG!*z}FS8wn z&-r5oq*`gPPc5Bv)F0FH#yTe|VdAFrUX^^?px@#BOI z#}4SxS$T=o&)mxWA3qG$S}*2K;CU*4t^YK{{=c!%SiX|(@B}IWL4)YGWZuu-stXUR zv(_d@juAzzd3%JP%mH4-{Y#H8nb z==GKTWgQko?b$YTL)97*q~%wvSkYg;VL`cErmZcV_b4&6K-xy_JHYbgRl_}yMQQzE z1%Bz?^5x6fdh4x+SlxOWs~)2vo;R9S*48odq>r|a%-oC&weLA{M9X=64+Bj zj#Sm3thW%HhP%%FQB`}^mwB)l4$_3rm#$V6_&xQW`6MMTB%fbi+K$Yc4NtDjSaskC z6HqbiezDqagP_$ZRlL&W(riY8~nhrw`Hus2^`{(V?n}A`+-kvCekG zTcco9v1$lZF=Ev*VHCBB2v$@BSD{m?5TgdH6{ltrSYyi~8hG^yBvuAv zMs@%IAOJ~3K~zPcTqX`e4J1$z*XhUvsv2qNm^8TQPy+~oDQI9~wfkb2gX15zAe@FU8{`C#7Z6@dd9aR{=hY_C zo1}X;fNBilBo$S60(k)9ze7*}x}DvIX+iWfpb6zAL~lX$Ra7i07GvLvn$r+w0wg>@^_2Lx>UEh&5*+<{XkoFJnq6Poh|WZvP=Rl8$jFIPPjlN}w1G zbax4bu=hzZ5olX2(3C4rRS4{y4j<#?0g z6yW`;8jHv;aCVXjPEyre2_?s-!l!`?RkbW4x8u&$tLq=nJo8NU;}H9<%abXe5#`gM~)mD zj$47NfQ2IRN#J&`BVPp(84H{ZT223fienV6b`K$Z|;Kvu7= zt1PjV>8Vegc(MmkuYzG0AR4x4V&> z+Kj&ELB`(wOxh=A08dV?ZC@z>Pw&tzvw>MpH>!xNN!)^)8iLQ?a_r6z0W4(}+qAao ziuQJa*{oc|1rR$V={U9v*mjfK%l`88<>M`>%cPD(&AY*ONO zp&}OIj_U%+BY@}kGk^yQERBfyxhSah{v6}e9 zcoPs~1npaS0u)i_@1Ys%4!2;z*+)2*flwh(sHzzEXjYd*;l5=}7#aQjvijNA_pW45 z*3zSzEaAFo)ASm`L`D`pOPT;jTS-^>_CcC(^c1los%q7#gGgY-wW%to8x2Q_kVHPD zN^L@{Xbcq8>7(1Uj1i|cp`d{cZKSaVB8a2IXrzLO)i|~)foLE`Rbs^yt;V9ph$<0K z#*{eLqw*D$h$=3Jt8t`{Uvhb$N^N;Cf1AI z_FMx(LYjy|-_9tY2^zC}uLhv#NE1cCNJ8`90dyfE-^GNH3;c(m;o~4bb6I3(tSvaT z2N5)wjJH1Pqb{C{>(g24DixZAes`#G7sT0IkkO_ywwq zQL_Sg4kRYF0(uZG2-bscgo^_{YJZmUs=Plme54}a9-nYtNb#JF*p0u!NeY)+cUu}L5w`2Xyk zdAJ-^o&G=HQ`Oz~=H_OD5C{RoDuT-(i{mng%AkTEjDkW~)KS#=F~hhZsEm2LuEJ1VI*A1rs1Z$iCgZm#Xvr{y0_LeU~gG_a-3yK2JUOR&~{>)78~g z)#rT9`(8Eunc~zz+1sxvKa+fD`5z7=jN<=A#y!F;szk2-Iws{HarRq3=q?-txPQL{10PX}X0*;q-U46xc_xv08 zoO20RfAmlM>hRxl`SE|?iVxk%C5PY46(2f9b5DM!E_~1BtbXcX0#TR%^9ZAVo3FJo z@JE6ZQA}JPbd-&$4 zS4*QSNtGsGZ|Km}u@6UYsin0@QnjhUzjbc5v{90&?tIq&=X=L|fBk>Hr?GEsvg6hh zgx?1|{P4ppT)1!(i(9wm&Yjyl`@kp^S%3f6U3cBO*4tz~^w2}i$7dz*+$I*e+3KFA zDL343!-)IdD9P&Q{GId0K2`7!^9PxwwOr;}YH7>qyM%cA3BdV4mzmuQYy)6s*PGd6 z1V_2A5&Ej{1b#G{mDp5hBG;vlVn+e{P3CE`QFEzh$7X0^9|l7cd+rsWiCqaG!Gazv zcbLelcV7_~O~#_h*o*|pJX)|uwvAv zLVs=0I(_t0bwx3d*>zARa&d_5$VR4CfWhfi;F3sb<~jl3ED8=187SZ^lFYoNlJ`z> z7CP3=i!{Y7I2w49yjg%Gyd-my1!y9?=46)2Eb`9GoA99%-n=usjL^AH=)70fnQxK| z^P!U;Zzf?;=*PwSHb^b}Z`q!wbCR0|en^rf`f+@);2#Q*f9F@68A~C0RU)0yN=q z=Dca`@f;T7Qieej3h0QO$D0MP!jv7)tSroha=nBLpO^VG`@EgJNtT9VY!=QJ!^yeW zrzx3jyO*;lL~|qwsYz))rlUq`UTOY%e*ROXLVglg2v$M@?5wHOG9dHHk z+NO2(GqWF=+1UETwbatfRRb#rUo&b2quOUom;ki_gYl4*GkBt6w2x3mS~Jqb>K*=S zdMr%+9DJI&F{DOJ01Tujvo&IzO+;z#C-la88S=LU0HO{}glo8b1^h$VvOVz@hz2vm znFV;ya+ith|E!G0^Q^%BRKLP0122N3(B9e7NASLz%={{=cPP*NodjgkFuz~@{i<>O z!tB;ynvvBdhdEOJv&O;8h)JJ>m=Yk*SHstgwAS?b^f#ah$e@-9jHq&#vEFW<8H#Gy9>Loo;6DHnU0VFY#|nX4s5$&9!~5t!`h_?yG!k z)lH`#a?dSG2n~Aw2t2YGsQ!@a*~^ z@Hp@n;9+2~q|Fm-{ZdrNv@ZdF8nn!~z>fXxM$(<5tU|~4kUxcmrR4zj!RvOhS#y7C zv*tc%v*tcvv*!N9PP}Hvu(GYd+js4_YyW*qR=K53*3f*kR_Am}FBY}V&6YMw&via? zyTmGh+R{Z-pIb0y`%PwE41%KqnyE3Vk2`mIk_UOA|`n^gCq zWsG&*hm?O!vxDD8s$Tc2uDYt(iDT4t#~pXDVnsa_Wr3tki#hC^b}M11A`4cQd3yQS zxlWX8p1bA`f-^?rylJVWmNr6}Tj{%itFlGy1g;=&xqc_`DjK8H<^b=JG^Cq)6YH@N zFG@`SfiN;?0^qj?P&T+f+x)=J-LV{+fB;N9Ha$dD?D#!)e|!N^4ou7h;-)ALM>rsE z09zg7R(4{pA8YRH%Rvd(1V?livOsOX3A1rnPlW44Q4DkY8r{_$5wWRI=g}J-d9!!IaS(B8lXtTAlWm$ zq3wK6;G?@tdW5WZww9{dX^=gEDZRb6vUjD;1AcwmFZT$J6Z3|DXwxACb_BJ@9raIl zBCsMYH?`mQ5=SM)t|+pMlgOotv-pC@rHU+;Gq1>{Sx2>3>U@anFrQ6P82O*%^G>xv7in}D1Z=VmaUJJbb48M8K4M(9u0^h#8L!IAy`vb6GV{%3(YWv7hW_2 z4nrrzRH41=lbF8F^}Wc-ZGt57X*etqOdOhl2_K?3h5{2t_BlB3y(IGf6rREj6qIc%yl5n1;E;}!4QFa~|6j_{|<8l3b4@h)Bu`4Q$O7)2OLe!>W)V7XG z=-SiJCbw-T2;|(B)R=%1X0{LTDDW9rXZPMAz)8SuW;V7ycP+K_a!}9Gjf1Pw%(^_S z7-`k;&Pbhwm=35vhx!a|2~)yTe=2EPl(s>hRGp} z$mPZlnI)nM;HTyJZiD2S015zWa-lGmBKnc6>2VNb6KQl5F2a1+Cp3(50p!X!Woc?Q zv$32RS^53QR@PyNIv4_&{z9|2kWU-XiEjc>>aSPBF;62SE)Bn-tc9Ie_ocO^7a}uz zo0(lqa7_3Ea1L+^a5Qiz;Ro4Kz{d$B`&?j!ncZY&$D3Jkp{M* zA6<3RMEJNma%?AYrLvsrVGw^`R8VjsSBP*kEFd)*PhiI_V^w;Y(*iP!8% zq&tD#5oaNN3-m@3ce5RR>v&ys=xUr!MD|TPZtiQwvhFR7sfOMoq7m0>sin=Y*16fz zM(My?l$hh1e16TfmyOxJx^KD`U#@pjKeX$;&px@X^*2!Uj_7mFIfq(pnCtqe=)ngc zwB&{CR3Ye|EjeRZMfoGnHZC7mg)Vt8{Ue~S5u{h$V zSrM;)%lUj@A2MKKbpR%cE3vno$KO4-n)?sCnuTxvHT%YW*uuWx&_JVbdo0GePHZY6 zf}^VoM-#Y_gA(06xEzp}+}?1OFtFYpoU3A!s*UA<-S{l0^!DL~PS17ok!+pH2ln8W z-Ut^*IHyKGV+3^f1cwUeSOFlh!&wh9zN-tjO&Qyh5a+SYFL_TT>LE&&`R~#P(^4J=0sU`MnkU#%rfl;?SOpmyZ3|wSRrhlHSIk#BIlq*KWWMZ~Dox zEBbr>{J+=#;EBucxjeK@ENH&OFJ>t)uGpy+O-qYWMRawsb=Cn~h}u++N{XY#0IS#) z6}h6SuAl)3aUDS7V!2wZ#JrsIb%4TUqxx&qr~?$4>jX)HGbwTfKh$+1GV|VQnZrPE zoxqvTT_=1FOqh8m?`6(Q!L34BC%h3L3XK3yIKu~c!aSC{EM%Sc+5bb`C%l)Og8M`> zKw;**Oe4Bb5TZHi5QTg*6p+IdHUw;FOr8uJu)*I#7YZB!iWm$?422|eP@(}#M1HWl zL@ELx;?11Tk7YA35pWOhM~dc<5SiIWfG(P$i2%Fg&;%BF?^8L8!f`=zM(~+1y!kY^ zidX$@@zpE})?mQ6yqU^g6B`QZH6|(P37r+`QW*|~qp;OEAm4~*-)_JDK7^?175E&HosRJZj5APHS23mTNa5(rmW9qm7Y%+?RvL_z z(DPY6SnDwYLJSHJ6-89iAjb*DXRaW*GPbPTJ%+c0mzT`!EoOEPa5HcWgFBIz5Ge55 zve)k;j6lyH*dyQ_z%PKO%?Y{qv=J`L2f8~VlzU}=-jP-sulLmtmQK5G&>%AOw7a=fd z8X>&04F)wFtR!3yT3Uznt3&^S@#!Ipcf#Bi_VH`Rjm19g*lYilLi#+WtAJmCzmmS? z^?RiqeQAX0Ea1nw@ZG`pI&mKXO4P=^OBWw9M;9M@A#ftF3x&Qn1L&8B-VWS?>Up^> zz4X+ILul#6s@A#L(nd?-T(T~kp4)#nCax2{zmL_IUtFKJu+P!ZrNDB4dGqFR-g)P( zXZ4NKXFvPdW>=|D-Zl(b{kCiIV)^W;OLy-(XnXks?-_{sDUqCZJIA8Nmxx3yo+ zfzz&H=7GQ$|AAjvhykUXa$e~?zVMz~*y)Ui={)3Oc7E--oU(9$>w!XK%)9C!?$2W_ z+`wSRiRKuN+*!gkwVCIjL>%FAK%%#gdIx|5iy~YU;rgORBYNz3xUa?uulhA-opc+! zE*hY4%AM@E=dbzCft2?FbQbvese98M_2Z&`+|a0wINSGD9o(2L>-fQ+`N@ZFX7{h& z$ArBuVecJ(#M#RSxOhT|Gn_FWppx?Lv!0;y_q`Mr_F*%|Q_rsItNMRG>Q@W@{sT8Z z{mxVVvUu|R-iqx%rR^((0hp!kf#kYVZ+hw@r`~YG_GjODXXi=RUc1+)fBVC;lBD)y zfXLhpAAQY1D<7?N8NkGj!7%|$gSNtW!3s)oh!+^hI)U5LWftNG8mg2NjU3mJDkOv# z6uDSQEkF}BYE%K2c*V}VS)|m0>jcz@T*0U2Woa;vXm*`2bMoE=M*;I*4sU62IPjL? z4Oz!}9@(L+)7@n*5b~iTei%IALu`l394R~mSRi+(KpvSN>OK*SB)pgKPA-El%x75? zVV{``MSv($4F)L)5J4a@>Hxz~s6qh&k@-gC#_(@ozB zD2N;&@v`iAIt>RVnq4N43msM#{>Sh>xNn5dL*clO3{51Nn*@Pk$RLRj(P7?s?=6e) z2o4j$tt7ZlSlw;H@EX}|!n`wyT8QT`izH`0PR&D(P=uJ7p)nnii^KNd zIOHtMH^UH)(8nBsa#Dc4dNfD#Whj3zwWiUk%184@)TvnqgWM(UoLEZjMO#vp#odrVYqEAOYj>^G}?7mTFC$h~;L)K5LM%o=m2$-Hg5L%ro7@wEUZ@73yblrytI*p>5!3nY3Jugde!puHE7^xBiTNCaBdjLBS?jH+*FGyOo z#VYv{k}f>thcK+M`OWl3zp;#us{?qT1_S7Q_o_KcRf>9wHBy|J-mCt|ii(h2kyb&z3H$gxC z@sGLbrknEFD)7ZoEdF%B1I(E-hs!P-UB{0H9(aJSfBoyti_VZVS|9Fr$j0|ASg?T4 zeeQFkRBX_iHETHOq?4K#T_EW%qfxdle%Bqyu7cpQ{pBm3rkbp!=W=7p7ku@aXXqNJ zC!#z?(s#kA?VzQWT6#gsVsuZ-rfFMX|F+gE%m^=>c_x-a69AV!iaGdsHv6h_!j0vG zo4OMYxNmoC_U@$nZ^IF0{0=BpJzsu$1&?3;I4kC@=z%kRe3!cMn zLWsC%uIiem7>@2j03%#eWJVp7s9{lm03=-7AlC{yYglIua{~>aqUcyKy@S(xD*W@@ z1^jXUOIdu`eD3eA@Gk(Rh}(bsHvX%#hFM#ficR}1D(thj4|nCE%q>M>Ky@|c&_68Z zPv3cvg^#V~wsOiz9Wmd#`EV|1k3uXY@W{L@bmiCAwE!HLOqP`sfB?K@krd4Uh4;Z@Api{c;C~RXhX7GDoG2QR z9;poTG{F>P?i4vxVf9E4)#bgO7rHZ_yjY-SSq?@Fha>VSjKoccfD&0f>#&3ZvXQw< zm~z*Sk%5VP+8|1yT7p7qIA>HUMlm*$h^(C;$fpJ_zz?w? zU0cALw~Tqse)Ov&fDH~%c-=W8i`4>+s{<8I)%q@TAR~t)%-b-4f>7ij2G=Q6+gzpo zlq-K37Tq6sKY1J>gG%O!NC|+Y$1A~%0B$JB3LY1tNAly~4HtzgY7zr!M|i<9*d+hk z0sfp#-#4@E2@u7}z&`*FnAuU1em55N-x7-F?fu!VD1Ke@vd=8P`uSI_ zSur-ltX_oLxw`ac&lactdp`fi@w>n7zJ2$dxX-=!c5TUeZHnyZOWP@QG~W#RHGB5h z1s=ahWoCx~pU7sr36`Ie2p4A&eB%Bs`|h{2p&GyKDfBMc9qb*Ag?cB2j;rnHTi-Vb zSlARvClMS*7ZF8o(k~9~8@`fzC+Im{{GP|_o6R{YB^w1)SIzzzV+GaX?e%3z;T8(j z6c-;1{A^U}+|uUM&`kJN970Pk7PZdJmNrSw*%!Rmp+Kqf)I65`=-W&?`E*#v0ND-I znycr~`-hwB^YWZ_;4P#29P~rNZ>QZ>uU^gJhab*eciqLLNs~6Y;M;DyjgwD4xp~q5 zN_uLO3(h3z0W-T0I6)F8o_HcV@4Pd6@4fdXm%Vi9Qr`RC_tM{=k6Ptk;F3))IFqD) zGy4*79)zfrSHJqzeC%T%+vKv-H079Mj^T+Xp2!#VFxt)8j?W|B1r#4y*vEffwScc2 zxzlKz@|=JBVs3b(scGNqbJ??EOD(muWwbqzQ)Iu|+&h0E&_u3gXyPc~_Feh>xlgeu z^}H1*Ie4zE#Gm)c*8AyOSCE#VwMQG{pBO056@AOJ~3K~y6G zt6@Yiz6N~>Ho3(4UW}hUj(hqur-=a#a@;IDa1@sucOwtpvw~yF39s~GeC${}bsX1S zeh9zWemrSEI0w)Nubjw|CwurGfY)rrk|@HdfTp*>?+@jl-+Ln;SX1TT)HA~zT?NNq zUonAS&pnKLCl=wdckqo5+{*HSgnbQqCltBSO~76^0Po#{W3QdZXOc9uJ$qMGVm-fJefBCyoV9`9)Dxa3p&ANklTfaZXX9TviK zGaBXTbP^g7%27#eBqS*oM@5yrSJA~(U8=-; zi-5=#R7nTSQJ_K8Q~K6xTqp)FG(QR_Ig+u>lq>g5u=H2hqe(Pj1_8$d&f@z@FLvmkxSmHnT^Mq8&kF z0Z!~lI10C~Z^b4(OaLcZqq$mYX(T=Rs5LGUo1jUPAgVxr%}64nEi%e7#sO{|R1*dd zfGRP(U2h$d8BuC9CubK%0VbJ?valt=RmgP;ys z02bu}z=#Q1PyN1WQ9Du@!-Mmf_u$fy?4|6k>e2vHWN*l}407-_8+gq_uV${y77u#R7I`v-S^6u2U~dw+Y~bP5+BXNHyoy49K3APcf>owC#9=Kh9&^hs|jut zYn9Eq_Jf#x5%V9^oP+8>l;#}NWwWkb0QQE{5wciswV$~K?;ELLjUxI!h?Tzx4kfBmz@BKYpE4?KP4rq{T6H>#T15rmku z36DSiI0qbX09Rdg6*Fhf+~{)W&YjD##~w?qR*#my3;6sdS9rKiCO8njrmwG$gAO`~ zIdkUlj(5CcecP>7^XARt@WT)1x#ynC7p(%0ku<7Mv!wIQ?2W)b1AOw6pJdglRh)L( zX&YT;PfriWAAda8Uw?hR$OFeq8k%0cNz#Sye#~ag{Wx#|z}yE{lBAw5AF&f{g^e>) zmf+`qSj@RMH~(z6vvtWKBSlTO)KW{EPfG~TN-;2TJ?oCD*2-e7C!PZu&;-Cady|~A zH{ZE+Ip6KXljg?%BC1HcVnkHxqgm{?Q6rT`Cp zgtJ^VTc;g!Rjjusz!6amyYcj3&Y0wD315AwbK1nUT4nhqdx zH0KYyiYGe%9Xvr32&cGlB%EtlNcTnX-GAWuv*4@aVniSGm2u+|)DfdsY=wW|crFGm zrU!fhsSwKYMXYN8Ub!9q=@a>h`uOoGU{VRGANy+o`^u~7`N6)-UdlGq)~d>7SrwCGVg>9F^49*JGu&31Xnv zqEf8Lc@^TwS6%9yj}=GG6L}m(EE3@Hsc?~ZiNz8%Tq>E1m0E~juv9V^$t(@aeC(YQ zhIh`zKJ`N8%`B03k+)P%ku|{+Zk_Oiz=8?5g&+#^mRX2f#!Z-<0ybcnFcW4*7{F@C z8UO_*Fqd-!SUym;38IjJlXFdRE`cd-{9Be^#-rv_9}KkYWSFGTfKEvq67h9h!i zC<%sHQ~4fwWgI~rmIxzr8?ZzGG=ym+U;=Y;NRpECmdxhMN*f}pty>sT}L+(ptCU21}l~RY~iawG_X(H!LRg9P#K8?L1^Ks<7 zl9Er{fSk|bVq)hbpU9k36$bh4c7nVs&GK=BN&6L{$v>8?p9Fi=NK@nFM}3 z@f}_5zZJVuM1yg(jL6NBP9at2X@>nF1SJ-BQg-;L3et-D=)Q~Xog*W zL(kui&s}t^17pG<*NFyP@k-F(2m2Z{E^|O7n}9H=nZQVl1JbgEsE%d_eV{hvv)hiA zHcp+u*}(oeG_lU?!VQ$9MUp-U9837HH?qa@#UuOpeTAZ`ze+8tH|9@Cd-=k$|GRMK zd!Kw+xkEj3&9STZs4g1R@p@nTPA6`u`izPq>lm_Rnf zQcD{zN&OI<3kU<1#-jgfm_`el0JwEIcI$F%t5s!MeI|(<)fhiOnzI;b#O9l1seeEHXjfe3Y6`&C8jSPrc+r#DXmKkvAXmA!>4_Y}lt|kq&rE^G#-eX<}vT(@p$i@A}@KLX3-sH-s4?}>kvcYJHob^8HR$5gz7OK65jCj zD335jA=X3q5OfiuLQI6{ku2K7S!P8p^GH7AT*wceYy+mD+juc3a)bK*oI?CYUZ=c% zzFzk*g(wd1O^vt>L*9fp1=k47XU8bYVma!OC?1b@&Qh6qZ{{WMom`4}pZY*!IOo#f z0x~i*VLp*Jlea`UG@;-I;`4|OZ=vMKhixNQ2(Np*GpE$NEXmKUqL;I}+e9sNU{S4B zgG)*+R^nonv-7#?3aVytG|lII93_pIj;KuoBgS+Le$LEeIy&2@2{t^YW3RpT+H4@j zSloD)0u#+_<_p+n-|X*tqdi(`>E*4XVEL^^&tHvwfYp zw3aO|g15mCL9U_j#89~?01VC>o_q48U~fjUI&e^j9B9Y%+OS&mFtX5cBZVlBTy;ny zuaMTV|NL*ht%c4{9cAE{=>uS zP=Ig@hkz&bQOMId|B!wNvBF`Zq+)@%>HRK3YT;V@D~0S zMyK~K`H!lLUfsOt%S(UVwM+l9Q`WVanf;@g{W_Zt9E+-%*@okgS2eE@OMl z-)ytye%U^J>k9(SY}U0$*{r#%NRuW*KmWfrYwjwWb=?X(`qm-jp~XlwhRDu5)7h-K z=K-I_>>yoq$XXitRYTV5)O=}bsBK#7b8P9wqSm?D(x_;cU7tP;bap;pd3qkteg0oq zcJA351W+U^ma*zr7x3(-K0@EUch;91TwQA~y`MQ6v$%q+bA1-Udy!?!mT|-pM{vLa z2XNz!H)>~HC4WM!$OYupGUaui9xB0S5O;wbSt8xrIubClJsfdM1lk4AIp=PKA% z9RV;H224Z^V8RXH2AW`rfv5pWL=IQZAO}}zfDjhpst~yjoa?|@=Iv|-=5RwN=K?%Y zZ428}A+lz;qSAmd^8Gs3s84?s>gWb=);zscP#jzrEQ%A{-Q9z`ySoQ>cXuW@1PwB{ zyEDPvg1b8ecY;fRGv9yixexnss-~u9_wLo*YpqBWsWy5-RJAtb0w4!$N0pvde+!(B z&o~&&Rv?`<#EW>Lj_c=|jA*cvyT z8i1vWW`+jkIuMr;sA(+(<>p!#p6Wl=VYaY~s@CUYht=gF(%g%xm|_9J66Nky=8hun zm6UPX(K)OoM^tf#IT;|iX$eBfEGdOrO3wPluA;>*!?R-MDshpi-5B%e)hX}erI8`aL%$v%tk>Sb-!PmoX&bzW%4AtnQo9TV!uW7nR^HX4r3mKhFo|ao2 zJ6#<6`3DX@3}q5DO!^?=Hm@Ykcp)NeTmKje6f^Pqbicvv*pEyUa!Lc;I^)Pl<+YE= zw?%xN)~;zdFJCDR)&phx?=&~tT_f#U)`Ou4KNX>$3ohE=o+;hGrUgO=BP1L@%s5k* zBN$Soy+F)a&W7K)kz|eT3+FtE(0tlzvPLE5yew9^%Tx2;y}YE;?it=!zVI==@+k!N zrv*}QTu(AJX$`Nwj1I>dG2)X~h2M2+psL@wX^oo;*nfA9b?ejvMVcF8i2djC0>HLN zqb-Kh@EDb`zHGwjC^ui3g@-LzJKTZ%Cw#-rDX23qz<|yv2*LM5Oxq>J%3qPC`(Wvx z6aU@htliy7UUqrde=!#OBz$aS6HY@Vw&by3!PlX)WGu0^aBB3@ehf-)zi=5%;t1Xx z4mv~@h)%M5|6RF;V?ZyInc(qA;R(zTAG!Ex?E?@E+5K628;&3vC4#nu`NM*GpQw{$ z6@D@DlnUKQ44(zl*}?iJTdtgM`WBo^hSfE6$q0M8X$y<1&~J}ucnH^Ep=lMUN2qKx z`(5Vk$e~y&q4%0LKcDsDn$BER?aWd?cPgoZYhw!TS`uc!aiS4Z-B zn}4vdWP440LmO_PM( zMx7=G)OUHFnY8qn`f(MKn1Y9h)&4pT2}a*;=YJGEYx*{Vj(KGTuVVR%k_631wdLZH z{Hw>Kr_@VMRMfpR*L6_5q?z9|imO`-!dmlEbU7jW&F-tf!8g0G8ayA`zHi!Gyx@8r6;_*F<1^M{H{G}=gf4blFrV?)5k~7P`#DD4tiYa$e6tY8cpjqZRN)gonhQfyT z$Bl)xwK4E+3cW60cAqUTyx!0E>ud{tcO%v4Ha!r**+)UErg)Y05m`R|a`S>#wEc`?OR=THl z+wmCbN5`)az2rXqi;wcPEa8C3ng2Q1gO=7F2yQo*;hqusT-_~o%EyZSg$c>5qmkZ0 zvqONspiYaaK9~UUMr^_?ynD6l*_pza%g|CRHav@|Mq&dm7`#aNeR35yElKJqhrw5& z7AKTf%t_22sICM2c;>v5W;)Xn6>(KlA_b1@)C%-H z!G@ZDn`654oTO_ua!B_1sbR2*I%f`C-uv}yW&@Q(|HlZjUQdI$rl7)lXK@Mq2?#7I zo+;!jfAxxHW-NHC9B~?$4yfqdbb?OXehvNIGViOdukKP$7QMcRs*|w3xNK6QbDLhm z#FFrv=|1h=;39V5|B8%EIu_a%49f7#Ep7@q8B3JyqfBlos^;w#MMLJ9eoIt>m}8U- z?njz0crQluITKcKxxb1d{6qbPG!ljBk;kC8J+V2h(=JY~<=e~$2T z0>-|$5v1^Q?n!nJ+sj_TgodkRrbf~0kNfN}f3mPHlf{}A1Mt@wff$AX!35lj0;rg?#k-{Ut=i8)%(}#=m zNb1*|+1^fa6L6InILkc=K5#h2voOl|nG@kC9Zv;ZopC%&h!a%MrFfwmaE@@l%Q0q5 zTc8&B4!rxdpfpN8C7lt{JCHj@L!*Tlk>Iw}pd02&lJapvkr!?A7VT$gOh?StNuPyI z2pUL#AQX@wxD-TQlqaR1A7YgPgQM5*k_BAn^kGhl;8#h7e5a}ZxGo+*|1qBv(xbDW z9Vld=pIN75jPZmHscv;#L6(ni`WL`pe%J~O&GxdgB%9^Y@|7|lF zCp0;@Oj!za8~%JZ%Ye`OI83kENKdt%d352s4On3&<1PH?d``UVB=tStU>3Q-tqqXd zj8l*Ojn?6P++)wmDW7FwjTMT<_OJb!XE!^$S0^OkKgR}C%qpDo=b4ovx8Ky>hIeR* zSnvrlyEO5%Nb=giMjwyl6=jzQ%wetiL;>&ec-?Qx=c@+{N-oaErl7hYqE)(nvI3+X z&@w6_xblaUkTja`Iw-CDpQ)qMT#%P8qusgrc0ZFJ{65|4e`f+Im{9ZH(BjB$#B1Cw zZiT;@J1)|?@vgeXlkP>rDF2kTM%rfsm`Q$6tNGR(i^SUHDjDa8`pmi;Xm?@A5vefG z!5P5hN_^whguCP3J_$y^OhKQkNbCjpK(gnmlBuI_6}!J5Sgjw4c8U7VL5KhCANlW` zZ;Je+3#BTTf6!Z=q6EJv`Rnk<+v1j=u>PWJ{JpN)5&Tcg8?)vg(F@1-6Ot}blFPl` z|G7B)58p;D2u4(_t)-j74+{wkC!C85W75J3W7^OJz)Cg_32A%?qzI9?P zjmh>|t=z=#o~Ctt&o5jvJ@$#{X>2B%p>%3DcAhZN1MRbVE+nJ&gA|Cz1*}lgqm-67 zT%>xKW+ciG!$aO`2*SF<($b4dbhLlgIu5vclRCBnB#M{k<=L89`DB^LcVp6mwp+3Q zxYjpA$WTh`78J}igIFY|v3=h`Ar`DP3_nKk=rCf&cj~ z!lV3?e%F>N#@1zvu%QD=w4fhcuC%bS?&XVPO8CBUuA?~!NbfwE4sCl$mbfZWVw!R~ zWcb~QYM{>lp9h2zV5Es^wM6fF#^tM?aH31v0-&}6lE6LK_A2D z3y>DGzSMSknYnO**}K%qo$?1OD@c=$h+$E>Gw>=zmmT1(^AkE7b0fcy!j@}U5 za@CnkQU-9Eza$wV6t0Al<#ph8pzkC4izqj5QZ9buhcWjzsqkHcI$K*WtXJZXnJERa z>v_#4VWuV#>%R*lf5QgTrcNonW*>A#N>5s+($|9s5N(~pL_WUq1U-Z^+Eae!(=H31>eB5?nd0a(}q zJzrOa^SOss@JxWt;H4UP%lnjRrxF9UtoVfHJpQj-YygOM7an1gtiZ^^;?$tV&rK1~ z^GOv|0zbNOtk~FuNEKB^$=&3|Hwn+p$3BH!aruy~ChoTl4IT;C7O-WaVtH&aNI3A3 zkZLvvu~N8VL$lMHC%p6J(M|BN%C6)2hB<3k1rpg~Wxb{_mry_#41v-RuNnV@_28|k z+Hsoi|LF3D6>}RrZh)1=#lc;VyHa@5miwXwl_${$WY>YNAfH#0;}_~ONrdU;^OR5< zVII2p>Ydg7s|Y4uN$n_Ii8I(9N9$v(U<(q2i>B%L$^LKxrp&Ip_^zWMo3pB)t)ng+ zur>)Mz%{Ery5IbQg*(S{#pg*(lOrof5XW-gI<_B1y7d<>vF$q9|9*_zLEn+9WXvH#rVX!Mlh8qq4K zM$+}kJV9tAuA}2Bk$vYA=%<{7%LC)@P5HB*lVC z4jaCgL{o6q$m=q}@4%?ERu^WaLv+EHeC(jZFoK*iY~ z>ZJCv)}V0Trjcf@gOFy%`FcBDK8-~qg)QGLfhQGNC)LmXebh?Sw%gU&(suyXSK_EU z?%-xxkpmCG&t;lnSTKs84jSnS3m?;cns{3%^1v1XJKPh|#=5@*26h7}yoR92l@FU9 z4vA$Ppy2vEX+jYfMgXPBmBTPl9kw+bPmv>4;i_4#cw~GAU;k4Q^TmI8v0@8Z&eFN+Cq?5zi^c#H_6CGu4QwU{%r?ph!z+Q!;6H0l?o3x^gJ5q~2 zay2H9OD31*V7(4HQ<|3OiUN1NL6#*&0P*q_Zn>p1K~kx}627<-xssBKRhrvMKWS+) z*=Z(*mm!qV7w=5%L!+vSZ;PSlgPm@S9dg>o*ehGKm=UO>m=PaYvFaPq&RD|3D$N0z9ZHzu=D1 zDSl(e^#XS)Wz>!v$x( z2gh^0!ZlI`67Ctg{_I08#XWi#-c69UBPJb-j4xuO3W0Uk6?fv$!AGn56GV0t&Oe9^ zD;e{p3pvW_N7cmW5XEdbv|BK4rMU38B*#I2PNdMwSJ@7F*I$HajDJpLJh7x1e94Hv z-Y(sBRuG7M6VrI3WoJNOXe?bkV33jbmfR+UN!WJXP;ta3*N3vlk)tX$ZfqX%`o*=} zf$IygDwr*b0yMYIcO-4Jw9XAjeVaiyEdDsM95H_K{t@D2?EUX-!&mcq|Fe7HUDZXc zSnr6GyUd$DrH)|YcBL$$S75Kcv+L6)E}zi}L=t}d-Z^slQTh3l0z=0YJo;~9-i$I0x@`bhm+?)Hgd!HhCFI*9c7UwWOaA`41diAShMi>L6n*NsKz zCy^jtS6*2Iu8@z(R=$xP3K3@CtuNI?H;7RxUh;d3bWdxi47;?MTd7h@*}S}R6sP>V zi*JuxPe_Sg!Xew7OY46p>?@77wJr9R10**rZS#>y7EC+43%T5wzHeN@J1uVxoBD+I z#*FS%m=L$D5u@h?T{6+mguJWBQX~xBuUj>z3I@RWmh_I#q(2Qjx`fWd;J4!Za)Dhi zM#^3Af!jv(|E>$Z z|ELb~Lu(U~_Ug-}<^Wgl>!nhrUrDgX04~7sVt?gFF_^Q}uSRze9k5Q!R_G zlT-b2K!Af&z2s6=^tVg$SX%?)ssi0iVzy9fIO(^vv+~2;yz40`A8g*e};8uu+Vr3ehIe11*b1x(z*=`SQnKlj5^gu zlL^d`{qQ!E{RxWj9WbHm0RSZFa;Zu&&4kq1B2NXltC?dm(LeVG_r;2fmy7ESd90RAp$CuJl zA_Xb&0VOM8SVAV^$2WN zJ%rukY<=<7FNU0;_S$H`lQZD-@N*E$jc85jt1XUR3J^i719ow-{o}|czVkoGenPDR zzNEmGj%JWIGf4GKLPKjpH%1Q7^(-)t(_DF37A6fdD=m|g*D8)lLW`hw z;sBLH;6e84u?FL~wqm|>JG^FF+EMS^W_MvPr!N|<@DK@5c%{jS=n&->Q}!V@L2NI|EdeW z-;dR8yL1Gip88M5Q@b%$JlFhxzn$wGop$ZSLi2~ke&tB+(7^7HVJ)n&(|k3NRhU^) z(bh%C-_iP=p35HZn|=GieHFgjS*@TyKT0n-XDW_cMc!vqGPb?obC39#{a|W>g}6qJ zojc$>QCIo3VxUnqavV;NP#p3ThO3uuOklX-GnS)xFbGWBa$vOh)l$^&Jh8jh) zA!C{0r(pztR{cW~yq=#46&V=Gdm8p%J_ufjR~2!Sw`lqtf}}S)IS^RRX{QR0+k9!4 z{M{B@wVRDaa^e`KX#&ecCQN^ey-OHyO2fK5GX3%UqvlxR8$_xvB5v*55`#!{bG2&s z2`ic*i!7mCNtkj#I4$n%c0ml_3XQ8Vk}wN6xjUHf^(d|}SNLL9T21S@Zu`f?P>M)P z=Mb&Is@4FWAoa+I!U=7cu9?xyU*hdS4d`=3hxn;J%y-mf`@{A-E7Mi6M(WDl4;u0?7RVfcyO*{eq87A)rO zye*jKx93rAL;S_9xjBuwl*u>mOI$$In&z2wO z#JU6b^66?B4vB%kssXZfpUZdc2{R9$0rwQAo@v|G-_lQ{4&1nv8~MK~xi-AMOQRGh z>R9m3QSVBR1`oFsfmb($d2+K@!WmJ~I%Ng|+cK1rpEPa4 zaLF@P2H449L9iAv;2|J;IYTa)ZXuAQO$f&@&?k@IM7)-qOC2bXYyqKdIqYa`J__92 zMQsplx|VvU$$Kb9ZP+uTTq#J(L^FbfjXVZst}7RjLXQ`Orv}lw6AL-ha$@6Kmyz4I zKCBxJ7=~*hWOnALE%t>s$xDBYV%i)`5|U`*+OQg6(TF&JIZ7U&tYIyR9$*=uhTUV2 zzEvw3r?!^FQkTSHxZN3-kk+rN$|Kk$ISLrXvp_C}R52cLEd!50f;2XDlL~-WTwGR=DG~TONMV_eKF~0O!}_>!Wp)Yxzp~ zGR5OwUb%z67P5`Q%m8^be0&b7&Y2bZDK0`$0*PX0cVYVUvJ^BA- zg)*TPq#g^5P{mRO^FW^zvTZKpGBV zWud#-n)MG4F*_^{xhu&*2}B>We&WfF7uioH^*pthc@=TZ%l)i(`IE3*`_^SP#PHDV zmT3Ry?MeSb*5djgdhD1p`2+1H>y6Rb#V>B~Gz9)NRpg^<=F+2E27E7*We89A=&2%| z1L|Q^c1Bpr#bcdYqvOj-eV|=m08k9hB8R|y&;g!V4Iy)9>Bi?HQ;6&FzMyvBqe1U* zBx_ErpZTeJ!>xM5>j6AYN!!D(eHG@tUSL8HEbd*wt8+B#mf#rORp#z_XBiLF2*?TA zaibyGL6mPgOH;>flXJHspWw=Y4~CEIBGB0XG~SyupZuTX>odqDh}o``IS^Ef^rDw9sL}vz}%v^6o z8;G2}nr1}X<(-M2aER|SnN84gLK}!N>lLU(0K5TohEGM(XhbYT1|K{KAHMTshf4Mi z(6eb=wL2$Ie7*lLs3ou+05nO(r|!jUYk6ne3Y;Mo$7|Gkmz)$pO0geBuSZBQh>}8J z>&W`Hg*DGw!arfgCl({PUKfmQ?b%HZVLzMW_hC&K)Dd;xrU6?PZ-(r5>na5ur&g0Y zuzW8%%6eK0Ej9pDp~_4G-p91ymPKYK5{eG276QFR!C+gQ?&(8DYHf}Y#@K^cIY#aF2*7vOpJ6zF)P@Tm zbfDqrr1pyhLiP$YWo!=iqRj@v*dFnDsOBU8Xt@k zoXi*tuCQib7|QdKlo`0_iH^*GLX2Y?2VNBXX3pwb^pw~tKzaVGFgA_0Y)ftOYE3;L zBvndORUYnlT1KQXC21=RZBEAXs)jNJR-97l;wD?_#Cb;jy=4DkB`MkDqKd3DcKH<} zX?p~3w&;`4T&_4P`>V4`6VD|^T!(Zp3`K0wUfI{;*3iB6O|~gdE`#v`5*|MXAAFU9 z2Nq%ct+^D6m6ECmRVp}$%@{_!R}IAgn@3_Ol1ka`ET;do6|FgS;yfVXr-nQyztf%_ z?@c!5t%lj-#h8_flMuM)0E4$g{&?WC!l)F-^6mvDm~u{2N~jL=5kV~AQEY`W-mn)| zi3EF8v6*T=YHfX#h-(rn9I9&!H%{%g}6Gw_7cv8dhS?&kId z*o)m1WOQHL^+M%{c3mtPe8&GQcYe88cW`Ncrl?vT)ad+p$+!wW;J@B^4m-j)hnuMT z=J~Ih@3}8#*uzLM)_Yy^;?d8`#TJk;R&;-@ zO-@i8auz8{&UePPKbI!^tK~f;f6aE;3LpZASiA4#AIGQ?d&3d$)r^3Ao_*9(TilwUjjEcewO7Teg2A*Vp(;z6> z#jn^p(-7DsvQB-NXP!4&1(o4&S6GUOzp7Cb1v=X@XqZXDE;U^j&1aomzaO@>BuvZ; z_oWnU9**Bg?JWP`_B_7IYqZAN^c%Vl5U5;Re%*F9KyE?8HTrT4 zCoYvocbUMY+Q=+^Q8NQqOE38wW5Cu4x1x)8wpP4?Fkzdn{Uf6Pa4I3BwFZ^ny_o< zw0Y2xpDJDfE?9hRY1Bq|!3)VRwxO6|Tb2^ww$|s&FtmQkETCk}T@%#~oZ!vYj4GS) zAAHQ3_9uU|#{=QSh6}C-nN3KS8i_I)e-%EuC1{{XBae6@PuNIeu|?nOJx}|Z_#wJG zuTEM3gM$)PDNMqBd92ILa|A&CuU4#7|3Z!|tohe1uL6F2I7Y<)aFMIgrFdR{Y<~t->Obtj{~O+YIgBG~eq7g7 z(f7OMUUBqmIKK_0iJuXvwLjovpYNw~Q+PM62b<13;L?ZavGPJT|4n!|0IkIS|1ZgY zW)GXrcN6qHR%P#W@BOl<=UAfy>_ghy{?Qqv4JQS$c3SbssXGZhv=O!ElMnwMsTIum z1B^qSCj1sC*dMoI95AuM1ky!gL6bM(0WE}vKup7k&HdTl;PJS2T4~%vQtj^=Yii~< zHb0bqLecP@gl7=>n?tr8c)M;hT9pyjjjqSlswmNL`o{@N@Z)GYK((WJgY5qL8p@dJ zbl>_hyzozueD>4@e;=%pQ)egD3d=d}LJj68&v~!{aaI4$_vjOe zriI)BMfnt9Zj9XXFZU#e>tT(lPiZ;d2K7fiif6iqjBi~M>C*DWa@1KvAiIyoytiqN z&x%03+}Fd$w!QoceJBT&G>N%>6D?`cx+nWHZ#lXCe}4=Dk0Nps!Bs3;NUpMXNOy0C zDtSnVl&6v;mLvv=5MkC6bXEiZ?2s$hNII&sJx<+3@)Jz$gvnIbGMQE4bHLK!rmybRA)Rs#VZyGt}Ia;R)-8% zV*auiTwJ9wwZrSp0Wq12Hg=pfD@z*}%Os;7EdvCapcTdu&%G7qjHS+0qH(pPV~zFw z&bSv{Xbm+PUs(v_gMHVAV!v8x``Q_)Hy4SeG6eDnndvMI;-JWe0IH*@Wq%eUfsQCMZcLth;=TgE9mpntCXFJcWsDe_~4Idv7l#1_N z0#U(yJ?-#ALULbVK@FA->BS1bTJrL3Rt-7VN$T&Gz7-etA|#t@oNK;u@##qdeiAAr zhaSZtVb%*eeR3}Sq>*2!16=x-pUe^qZp2691!|a*$;6y}QnBL-er+j9hLB&ILLwxj z28wQ|^>Gk2-6<(MRZ0lc8&V~-Y1$+FFpRC$%*|{E%<;46gA}AgluA_@1C=UuD;b%; zMaa%Dp->8ReW2y_FuN zms1|rfMLYOMM)eK{heflvaCB$a*>^Y@Ix?=@s4l{D_j-hR@T79 z4K1gn8S@rA@GH`qaOE|YdTGWA@Umlec$}0UyQV;i+FygTDRXj8-HV}(L`A4hxYa@N zh$+AjhH0U!uH0v7VY`iHIa>;Yn%kXUdC4=&UhR*>w$WMknoT#-2B!%TSxkRub(qc9 z7)}fsi^W>kcU+uYZ?^>biV~>`KAvJfvNtSAzV(!BRT;Cx7$N&mTXKoLCTG4g-{|Z< zopV%=?!INKJ6df->VljGD>r@Fft*MsdLH)D7LIjKhs;Ul!|nMMd2G!Tx$STMc};Kr zq;vV!VjXb#FK5%!y2j0a>vovAnZo^qUF%B3f2=nAl#3n7%9DY9`&pGY;+-f-9Yl(+Pnc1x6g&efYuMQsEw1aFNry&t49 zT$DY5z|*{EiW@gmr1l+eN81IYvDuMD(!}?Xe7{cNcP7>S=*rgba3df1H}&g&86N)=+F=bx|MXXhlK9{G)&V2dW4pza zBu>WDkIt^2T95iZ!HQ{GxZ3FV!1j-YE2Gm`6F#DU-xY9d^s~j{&~;95yMc4 z6hT}H4{VP1v8jPcB{R4q4b+A&6BM{fqS8JdD4VpK*k1wh2)hyXVfCHT(CP`UPDLh5V9o%*-kXrP`4@axca=u|gilS(| zk|KGsq(UNjFLr#aLCQ)!g29S237Bv!ha0=5f>nBaZFKtc%%IS^UIWx{5>U#JV~wJW zU8!}bj8mzVSFmNS&I@~CS*1toeNnJB{xi%&Y6N$EiUz6;>oI#{D9GWnT^YQlly35Z zps%;V2KwXw;vh+b1E{~Tq0_1+Gqkd-(H&6$CEGj4w;;C3JA$6PYMrGh;h>-j5c55g z=rPM0y;(AXbAKHIw2LH7a;+|?ZfS#%-J?uuSW@Yn?M|7_Vmo8`m;RtP+Lu?S_Y|_N zQPy^#@KHId^z@w-ou9+#_jO+zN`-5^8cebR<#z}|`Bd8Z*??{+Z5Z)wCPF@i#KZTAY_0qG#keXSuCjEL5ulWO5P!#<%!I&X6 zzVBec1J(H)qx}N??Io+S7v3yI`!`TG(sR>&UhhE0ElhMB5SQS`0FTAjPwXl|2*9Eu zA!Zavw3!v_yaw$L$-zf4KfwmUv>DGE9M=S3`~AL(EVL?z4uS46oR3FyH~Rb`B>iV4 z(uNDT*4T$BzeDt`B~r-hk1Eakd6@o8@?-uPU|kg6nE5p7q3O^v>WHRqiV&(}@}j%% zt9*Sx(s_Hj5c!*cyzb%zE~F|sc=iHGn}&vd{aes3*RGKKJ3Oe4N?2~3U;+Xd_)6=u z_1S4hXU*F2vS?AC^o&%1&@vGJsd!VjwKTtvi_@96cM@1=Qj~DZR)e4O5WZzGgxX*M zL_wT{Vt7T#hh%7A^*^EB`~aTzNTv;ZIBs#bz9Y=vpuFBFzuez~Thib--vn+b+!GzM z{}H{@-*D~f?Sl8)S#CrQuC)LNg;xqY|6dlMM2^`2DN3|uhAOXZO(*Y{Ql7ODkqb+D z$qXxhCioD9F1?d%;VeyGJ2RvQ2i~oGWVjtSUz5K{qk2-@n9wMrvJi=o9@ZpM3)%?v zY+q$UXl>;mrtI*Yw&|Q}y9EB33Avw$BYUfIVg9J(bhaZELE+t;)7uVSi9Nn;oyZ@Y zQThnQyZA>tv+kwb+|AkifFwwp5$K_7b76o*k_{A2w4ifkZx8Cm^kuz)_gLHKt>)+Q45Rv$7 zi?iE&CE~lb`HdnV>+z%BKX*IeZ1QCyvPjnPKbkKGpG__7V=}%}*Vrq573bGm(z|&c z{Pg!BYKs|UV7m%In9`5KqzG5Sy@I$HwHf$30+2K(!4xed}&(%+{xyRC?I2BaJe_qPIS zmh?)TL*~mg3@o0^-9`)dx=FTyjqiL+S155Q%=k!bUO>|3H>s zv=Eq#WH=MgCn$gl)#_A1{%r;4I{dG_G7HquLslP|r&`ZxXk5>6N8HN}BYW_E*eZZ5 zuU0-D-aZNeV@A6`-ZAKEzOGNnJP1u1&MvHHhi&)B&Ll7#1zzPq-p43$9yR< z%ZLfS6n{vvYLxqDW9R!s0X4H;BhM2+N>R}wR#(N`lIaP zzrdX1@M(^D=S5CT7n~iq56TT>|3EQinq7->;w1@v{Q;JOs;~38JW=`JTLOnyAHs-H z8-p_0*@I1IFy?r>T0-v)j5(G;a~y|sWhq1mEVP=q&R;s3IO|1uIyp&R?+5A(7) zw`1{J#yOA(e@4bw)|%dZ;~cc1h9uekl55<8W{tPt;#IaUPJLG9OaFT?b}b-wT#j=E z0;zg9=i_HGDd9WzU17{aUp7t9_@psvSN=a}Urg7uOktDxR{m%!){lRGOP=HQu1^R$ zU3PIcdMRf^jC>Z9(YOT86?R!3_My3n{yA7iRYfry7vXfHL4G>i{HuEWJF*kF{x__e|0z#{U@uRJpdyKQt*<)`O)nEHQ+ zK6xSM&efNXCXUsM`j6(N%oLBH;hpgYDa9Mo1-_0Q^pGO*OupoS{A|O4&mKxUO^F61 zh1yik%k|R?67IzC?MS(QJ{;q zBJsOL=BCM_uKn;1Nh_qk|E=&W5dZ0o*H&ybBvh6e3#g8Xg|<5(@ew z08!^aHq}dfEA`dbUqH~lhibCT{4Z5I_`JO1uqt(2Iz)k96kV_V&r}k~pGJaV+T`Y) zIR(=;MT7pSao17EdN5nMh&rrKbiJC~Z^m7wW#owOe8$)vql94S^w`!Hz-)$l@>)kh zi$*lM1A;Rj2-0uR&VJ6UnI9W_e;H=M1H6wbC1=_u_!&&t^dVf{>79bvwr7(3Jj@L$ zXD9q~L8j9;2q@^sKRk1m%LK1Ilmh7&S^WJ|5wzrzSlJm?4d!Pxdy zSpeFa2xWc|;;Fg+jGABgZA$k7Z8*SYPNBIoo2VEaq zmEJk@eZrzVx3HH%o|c*n8}M3CtY-|*R(Wvx59)h@l`+0DDg2BfwRX;8AoT_C~#yz?hM#%G-SV z@@L2HyfZ(`ib|5R7^_`zMhChmDiMhpV^g&vv=}lg-G!1iCrhC~U+xrAEcO(>4lv^+ zN8MUQC_z;l9{E+QbLgWdU~-~IFf(UjA2ly6kk3O)MN;GYa_L1fAY*~(hL8AvMM}}2 z_$gcR#tQ{<(p8bft%aSGMGzNpR|H_3iR_vl3Njq+4ODR3)RCQchl_wiX ztKg+!62GXEaAM1fJ~uaqy9(ym%3+FA4-3v%x*(g@7(ap8k|AP}FRtdH5jm`OAH(Nz zR3uUypnR$w*Xxw~kn8GyiKTm*g9h8TySa!}&fW`Ll%sViuj2IvPtg_XvcS|%0*i0l5OgGB)#@InOowL1(fasy&&0$}_TTz3>mwx3h z444u4ZD<|JC7XHV#Qx)_K74G8eJv64ok18cjO>g0*#_RN8%OW8bV?@( zXN$lnC#O^dn`4rrT5qY4{(9-#{jNAKJLyQ&4hqC*2fb8VKc<8==Yq;ZN_R0jzO3Ev zzN7&EIQax&%i@uSEY+F>7rdo=;ujeyiYDC$amVY+5ArplMkDlqc**28M01s$7bXaAZ<2fu4VFnE4sH0(~sE zuFe|3<%+;R5%^BZ69i3A_SW5@0J%U-%l7i(46 z50W;B=OB6B?6psrkJilhxRT3&)u)fe>!iZm@}&nu8E>6VDBqZpT*=Fb0wJQ6tUe%1pAVm^{aUu^_I@($2MwLi*X?3&FAEW_5=C4Ri9Nz zkMo1Y@^wz&L|Ui7%$s<5z9a|ECg?@xYAuioHK(DX`?5SCa6q@`eWBM+d(F_D<0RAa z##Uy(`mT3BZw~Hb9c)wigffX`Xr3Uw-mHmQ0xD2L9}@j0eLMLdN^bZZ2FFH(2^O$c zL{BGg8?baV=}Ida@t1`KKeOAaM_N#JOji;= z^maaO?yr|8jg>#9&_dv@p^cgBRQvwbFmUt@%n^AE$Q;v$5+xY{hK+#2m~K4QiG~Fi zxt0(|*IsiTHWw`>j}Z%YL!zN1yjtGgTq9jsBWziqjI;m3PofmBY%kv~(EzahF%d-Q zN4fo1oJISKj@&K5g5LARW`oO_9MUMt#Nv^(ftcCw$`=E*iI>y6gIrvD3FWBHUR+W9 zB03}P$el`U`@Y^lTO2)6E3qPdGnT=LaD8xa1HoajA)G)2f@V~5S_eY=Qa~Nsi~ecW z)l+-sT7}2sId}1oJ0>$mb7ur%@}~o4IwT?!2@cBuO!wDFFt(rD ztRN6UGbKMIaeIWNmK7Kj>LAgkEPjoF6l(0WP#eU`N+DU`a=IQ*Z&lj(ZN((ux}P%D z;<>`;e_3*9f#Q@mfJ-tDx_laF(os}Qw6i-cWA}b6cRZyXx)s`O$eh}o;){azY5jdH z?X9#0ZL#l^AfysI|#`c~?A*`t6 zOKVC>#b#{kXNvovy?W+=T$+Bu)rsG&HFBqFn=UB_#@9aTI}KoG83{dy7=`923f9-^ z)JX&?=3Y}ors7*m1_`gXENC6%0SzZocGqGEwoH_^E#k{$BL=v?qy*ZdnJ#`LFA7aE zSY4i9d+Kxh#dIn#%s=_oQb6E|U@m!!wuN1nN!OV`KpKqqd%y(V?o;JIQ+GUq z1p?^1L%T@+!;q^_gEH3Mh_1Ldwx;~;nOjhf5Irz~PK$pZW-G2ngZP_KDoYaI@jC-V z)}#-;-OE=)P`O`au;H{L!5SU|N?qV`G-Io-`ck+=Ki5LiK!p$pu3wE<7DZ#yt3qvY z=J*~zrYgE-Y_@DPulqlFaO_ zz`vN;PfPkP`M&Wj=&1re)UC%jQt#kj2Xa9oj#x5I>A3~onUL3@7n{oak6t5Klth|^MkKG2e-lbonbMHTL$*(^X_~oIO*a^H!(kJ(HJZl+63zn^e6Q2EKJMYqe z--qapxqJ9GL53z~MRZ(ULlZs(P3-7m%NJw!_ON2$ zG_e3Q(W#+{u_o4ayw}6W8d%TpRuAiY?M~6h`(3=1uu^!d!WcMAlsLl7uoB$Cs)Pl2 z0Z?M*7)6FBdXeFYhOnxK^@^Fn!m@Uu00?DZ0-zT_35^`ItzJM%2uD+#yT ze8N@%o0}85dkeMTRG;=9raC zdeL7*L;dIjWrP=nN0?bu;3+&R4<(RFYgkKF^gK}zDpVHOu=|8rlA`aPnu_SVg{i=- zlDRSuFe}2NBFyEMgoVN_rI0E|P$=b15>Y9pohSy-MAU8+pxRx+kz>M4HRw5r_ZWOC z8K@X?m?%M>L5Z0QzB=Q*=^a0FBAMU?)?>GO=R^%~n1>`x?=)0T^G;Eww!J5NIvxyO?!(=+Q;{{j3s;KWa+%4GSzvm{TTFYA95nE`qr%uiy*_K57{ zAQ>q^RT*X(lE@8eZoBICd3y7K93bsN`XR=#_0l%*c+lg)x|kN8)iB6It!<&ea%_jf z7VMRn`xZ)=v5Q)uPifGI0<)qz=AKTYvYgFn89o{Q`3yUEK!zq#5==3BQVP&mB+5~o z#{t%tfa3?9$$OHdZ`3mwzW^Lf{?Lzp5bC#IWiR`}>0}%6X+3w>HT=TPD*=1M@!#2S z_d`>&gHMag-p6Tj!QlBdi`G8s#wVY+ z4|RS1v&zhVnG8+r2F|MotA5;lw#m*5Z<}+Y`>CPp{JrhsAIOeT&#oUINSzD(>l{Gi z+mfz@`>f}sC>;DrgGiv}Bks;T2OZvzCwCi6X`^9~B zu%N!rU+7+c8QB44P;SD^E(Ko10R|_?6FUxL=rmwe!<-??KI*{S9Q%-ocZ0p}1UY`rP}yYb@Pq~>dQ z(Ldh+oJEc#c?xqKDPS#29 z;D=v>TfPKazJC=tn&akq`(%!z#M$qCIpeFq8vsAQPPsmw|2r`ykk(^9RDS zA)dX!c2@%zQglD65C78Exhw75%MRfs-S@Mv(HwK-exFVyBaJlDPn-tlzZK*OkN|s* z=vZLk;KVW4Z31RP6YIBQ&DLya;*Qj>@aP8j6Kj>#=sX5a}XfJJnd zP1@x4MN0Q>v(6!h$g3UJm|Uu|72Zjx-E2gsSNY!HiC(YrsyP<2o;8$=D(EMO%B*O( zl?2_YPg2X87AnJh5Zw`yOoe$RuL4w5hIzJmP?Dl@Bw1=$Kl<)r0yEVBMM&~wmXu>R zN>!e)hzNI5gqNpWN)JOemUErr` z!?7Mi($F>S;Afs@mq4?|aca3S7(g=fSy+YTV?!dQA&ER8H%DhAkt00ZpSNR5#FJg&z{ESA|l2LF!uj+upml`>sWSn+$|aYv1Oi3Nd)P(-Cr3PVcnl2@TJ zso~jWLRKod%|vrpsi>NPnUrP#iU?Dq1}aLQRHU(J_9``*8_%(4Xkt+}1?;41Eem!) zzqK-88-s|B0W`6r2rYAtKGrVsbR5giW?w+T2f;KciYUnI|7_}c@p|A$Ow_8a7x zMT6t^UGf0h9pv`pDBzjoyvKFq*+hRT>3=)~)!m!kM!xAeyv_gv2B|?akLT(@-f1Lw zdBC40IJe9sfUI~pYMsb)e5Usg@S~^Lzus$*JRW;f|$ z3zQk@K&#Gn-q*6%o7t1dcHECUaJ4!xve#U)2>FE!wf~2g_wpxqegcVat-JP?_dkTy zJLvSC#?k-RqzeYFa^Gzq<5zO@OCOo-*dOki-ML%%!2o-V^q*Y%z%sMt zz~9wR-?)cN^ar9d$u#dQAZA~$&FdNTw~_C04j6b~W~+h60Dm**_4l=&eKY$id4T(Z zdfClp_GaLJ0e@>|mr0s8h&0kZ>5ahYz>k36-;ewKdEoN|eg_48zB)IG)80AOZM0A5IT!5G#T$&*B$MuvPKN8p@IcKdlFJQUqlBmMZA zu~{_teaX}0gllg8>V{KJc)VG8A@Hnv@zbk{t8PB+_!qCeYU8ZuSn7!lX zQ`ep$#rX#3Yk`|w2^Hw)aC`r{t8RHSz;_?FdhvK#{4?QkmW4eT)9DO>6v^Nb&9n-5 ztx2z~oN74QV*pb8;PFR2V&loj{^HJvu?v299xu3I6Yn@?Wjy_m_LpS- zzI!?B)2Ci_RsVRV@9sZqW`~hssowz}wZNenqw4(zA3OUaz~4%G`-e{cr9;2BV)aXI zZLWCH9nBSwy}o_qVY__x+n!vsichnOPapCG09N;RbdTxXbIW0|>#KPCotJ+4_tw`C z;q%FHv3t@+;G@8YB;7i+{BnEcSN?$B?&pKO9OAjTa|LJ)MR}lcu$S8_F8QE7eD)9R zHJ2=6!p^7xkTYjFN-RBcq1T@cO7x2_>XXmfX6JsYNiqH`jMsq{imL+H4)#8%KA?-v z-lK!f9-=wEMJivs$7qguwbW2Y%fqdoZ={h%+TSv>Gs$ByVm=spzqH4Qj{5of?O1d5 zd}tyq!+Z+cx?~2L@EV#}Hiqr$!S2c0HKKN!n1&{*3`>kPux=0UIo>X2qB%-s*upJ8 zZdUm*%G-7fw~V=&7kHJOB&-525@y*^!W#utWWb^qIq=E&|LmQ4oLp6z{=d(;x2k$i zLN*8>NdOl>5rXJ|j)=J6t|K6_2%;Gs9cJ8@(ILTQbaX}$w;wJu;s6Tjhzlsf04lhF zfU-&wqCiNFRVtK*LNw`Q+2J+^wqacFy^}&x5kuc|u8i&4+Q^ z1Q1;(JRpzN8ZH!Lt`k8x1uWEXNkSkm(N9FkgeiwN%o8jjq#58)S%g{*S&Awm)T*eI z5}X6op@1i-L3bG=AsR|lhv}>IjKLFqT?%v=175Z*4Q^Z2g@rSl;ECO2>82q1Gd699 z-MbRIYxI82@7mK=%&3VxvIAhC)NP$2J9^6Vt#AE$4eq_zHdF^Sr!-;_p4hCB4PDl~ zb*sXRnZebzxOvrqu&D=)CiO|-37;k*sd-l~mmt&$NfJsv5K2y#Nokq^WrAgj(U$!T zmjD1D07*naR2>njs3(wEro<}pp$>^NLMltlHOF_z5;X%9A=F)BY48z-keMk9!6gYe zTp*Zp5Hj;F@d`n~rA-h;4m(IzxK6}F(Gn4IM+%W*%~2kPj36u_+Jr|SqA`E&F5wCw z!eQ7LV6h|Z=t3W>cjK*a1S8@c(QiC2(!g2VMvrhUkOVkzW*HvInF}(L9Zb**C3`={ zP?m(mdG`)1>MG4w%U|3+{>BjIY94i4tu1OD$Z=VORX2Vf#0$VXtpt8SSq z2W7IvwYp5y6f7N!=17AjnVAwxlPqNQ#4K^4R5vRnE@UzbuG^BDw{ki;G%?5^DV1^1 z#86VRGTX3PJ4%sk+OlI}9I3;vAT+L^)v zj*lb7heM0Xj+=?YH zL6cO)w5}vx2_55jh$(5pk6Az#5DP+_ku|NrC03-BP-mQRMC+nbqf&)XinkZYqT@tr z_=mI6)0(Oz?Z2}&!)Eq?q@#fEO|Xu6K=sdH75>mQn0yLsEKgP#|FZT1W`@BmnErOm zv1M9Ql3o0wwU0ag{QK`M&Dj&8+0HL|pRn}g#|Ahtv*nrGpCfmDTGN`=V_(aO743Hc zUw8zUTU00S%r$xi(JKAX)MDZd;m&U7;cc&-3;bQa{IiI0Ak%sXlC(GQp8V+t%xv%x zT>K(nhZW9}UP*+CKG-3~tpJP`1CJ&+u?SeTqxPw!!-!EP-)8*%O7nICV~!ag1ik{i zThdp|>|Unzm{LpmfK9!BVZYzry&mb}$&}a;#xOV%{`+A)_`rzI& zX=|5EOSFdC1$os z(kL;Gr;{8J_B*mHedc*Hd$*o4uYb2UyY95nTj02(YcIZ}Mf@;b2=fktQcuf5)|O^g z)|O^I5qKi7RImQVR-W;;3hRE?#k$|Y@cM~otg#?RBMje-l)ImMKAw)+wfScOy0UxT{ zM7xe+d_)ILi1U3zXx*&%{_Xu}F0iGFb_2H6kc-fSk~V0fIiABMouP?(7fyAY9Il?k zD2~EqLK!YAUeS5@IU(J``vbv#HPjIL5wWo`>RK{Ct;U370{44x<|bXXz8xy@-J zIHG4taYyW;F@xn!D#`(h7_EV1=9Cj0KJN1=2>~-F@X~95Uz)R33bIu0$w53t!9MQA zuM!l3xgSV;0=buZ*)=il!~a(xInTU%PEhhAxnNRi_?lVp7UCCUNpR*JmN|m5)Dn}K zr2&EkCv&;WMA=!$ytBe(qKM|OtP(64F;`D5Bras~R(IZ#nlnEIXaWXFlZqA4#7NR* zWs}`Y&euGiE%Kg?|8Lq`;Mrz&$3)Yc*-s=L0o+7{XFe(E zzs+oTg5~c?w0rLcHUW3+C_-a`0sQ%C>~KuG;hy0pOR8pF8j1OK3&9E14U00^6Ho%{ zM&S=rop-8Q9>3RTOgiBNdLZs=#{##P;G`PdqFBZCh-yc@PqU$aJ3QWCRu=OjSJHGF zHA&}H53o0-Qa@?Bjy?B$kdsfIyg~S@&-AkK50B%TtegJc^(=bDdgeWUf=q{T4wjFs z(llCrMxU?fK4B)Dgyn#Q?ZEk?8H}*d6l>wOq3|crM4cAxG87hKZh|U=DL7wvAn|~R zw`m3>@tQt1Z+_}b12li*DNv&WG*M?fP*MRuGBJ?S2TX*V&1F3GG_9%Xdy+nCW?$c# zg_zkENiP6e%5Wqt0lotqO}t+0GSX`=e+9Co&99xj`KLU4@HQ}a&i*&8y7>`Vk8~Qb zY8K${&FrE_V!3VW_#*MzG-zfgKGMs7D4LOteCys)Ba{B-p2Y`0aM+$bd)#n;$7}vB zq*icZgWsk0*J({_TDzVk%?HlNpMKKJ>P_#>rnQZ+wUcXtq;85bgQzU8z@JS-UN^PR z^APkP@Z`xR$}4({QKa=|HsM{BBuB&jYzqww;0+yTn3~oDyGcsSq9vJ`)g*lq_&l&Q zzgOAi+QqxL-a%|n|A|<{0F3($3$3;eu&AU36a_O;#r`pu_`7wKq;~=zA>Q|#*I|-k z-pK|Pk+ettIf`RrN7FVRclYGWpD^|^hdaJb1Sa0q-bOXEt&*z50+42%Pjs5t8+beL zw#h!nw014IKqy+=GMkd)#F%1q$H!M5w(!@OE&%obrGm3o9J(91Vn$QMf^7ize#7<@oJI?jU`v4imyT4=S+!)*_c3?g;+s}o^^_PRcjdm) zQ-PyARypO@98iRSzB;;(A4d(+-w& zqM42LRZ8juz6hMuw2bZZOUc`xHPF5Log=jq?-;2)$>;D%&8%|e*5P?qZXISpIpw9Z zdO2}!KYNu^f6(Z?H!r;ZmQAeN`aG1t9*2C7qn2HtJ3IU}5rAl@GBAV1$H3yeD{F8q zY+89g^`XmH@#FPuyz^c8=bZ~&F6mt09cDJxBO&Q&MAxN73~z+nzXf;y@J62h@0T+0 zxEJF%6wAM}*ax#)hhMzmDDk`V=kkXizLMH@fbW>uB>+0*$9oX`@xW<_r%tepUx1wt z+=%Hv5eMb(ox-3yNT>Yxc>DSb#$2m*I+|nr7Bo6qEKHLV)0);}Pah}t`8*UE?XhT` z#!z+)O^kD!=$|B_8Ika}8Lc1oAml0T2>|Mb`-*n6Lvs8fJwM;owgRi6t!Ks#cSFWX$%UP&p-r=gGSrVK@cZnF?ktrj^a`y?B1Q)yu zmP$^+T###y?`Q=moG=jr&MUFRf}HaX(ohd|m$ti5n3v@cg+oCmVL{$ZhAHu)aHA+d z3X$S1W?m!~BQ-?BS;7br&`E^Pfr*GCSRND81Xr{kyV0Qn2(Sm@*~ME9>N2i}RuE$B zz;-T=t+Ph(y37(&S*BwQI}&WRp=}OsHq#Hx!e&Y49eM6ZjO_^KpNhH18TNUZd2eQT zw+iuLId`*jmKk6^m`tk$hbA5$gazCh96uL&m2>_w3kqNs{Vm!ZCd?9ZW57h>yqQyw zQnM^rbeT|-%Y+MA-7ExI@b!>}Zp)Hkt1C67E|hC!tEJv5sS6`iDc3_tec5U*GhcHd zb!8gy91W+5k)+GYgWWbBnpjT}(ec2V5xUAl)?1m?i0Bw&@*B_uG(!{XCy(ful#+P# zFp5VUoX8s*-vgeLztl@)@eZ8A?7ON@{hMhFFuZF=&_p3KTPf*1L{Q-pIt+nIIt6$y z?S3RMEa}_82WSHz%5mCT^T$tdux&KPqa2gvBeNMG_;ndxU(Ibg`(e&t>`WZfAUv4w zS~nStfs@NYXT#C}@1!Z4GGFff4$e6QK7B*ekZ}qx^LfT=0%v6KAMKxaF7$1H-xC|F z*Bu2%T@&Gwq5*}6i;LZT7R=lfA%q>u#ao`wFMxO54V_2`p|0`Auv25A5DVIOa``>?O%L?!NPQt1$ypw#G{YmI=N))Z9+&X@FJ;7l`naIzUDl9`Q=SDZ>J6D^_tnb@JVOF1{_bwAh>xi2-p zwr_1M?_U31fP1U8o@I~V>bhwREOqT@!ky63!2aw4aLTRa$DIo{22T9Cd%xs2m4&Z* zS<|4+t|py+O&7F89*x*#$4&@rPHS4znpUo*#Pj+#pxsSx58yX6&ij9obWjH<;XL5v zrswY?#t0Uvfje_onfIYgsuFNB5pe$^@t%Al{WWlP{`gfi?#3S4z+vc z_5rU4KDra@_&=o_$a#JK^vlfyiDnigeTWz(TIe5vbJ~{i1mb>C?8EDbv25FEO|@)a z_c_2Dfmcu9NJ-PYQyIMbTVkhwkhEwLc;XUbzss#=_T)UFia9EI!)gPt6C(i+;c^gX2&* zZsnm1@3q4gU1%i)Z#6bi`90=ihSA z`mMj-K2pF&&jxOmbds4}Dd_;N?6K1bg8USIe8aPtt~ z-Z;n|Bek&=t*K@Fzja$VZ{1c)#0{D8)qI}kVIJ1p@BkOS&FJ$+pCd@ss zqay`KS9o58wUdRcdi7~W98AFm}As+|dZg0xa%&XZv7fyUlP z-p9;+4x;Gqn;Jf_0_=S1e2rVb(TMX&d!1f;`AZR}fW4B=Jxce2F2wUC`^K?jahN*( zlEW$Wo=XG1JcQtH)XA4Gwf{Qyn-fNJ1f5_Py?FJMwz^%exercL`{dJ_*0dh08Un5d zK5k}LO*U}{jh!!=Z}6uY(XpTmZUng$X%x9CQZJg>1B2U<>WF^ONQ5Rv94_euO?2Z_ z!*!KVUE`sNig0y{kc5v}Oin3|5dEETxx<8T1u&7iJhCH+@A(KvC?qJ&p9e#UAQ-9} zN}B5X3Q#an;|fv-l7L|l0w!UJu$qIC5fppgEi)`l2?W#vP>hWy5Hdq)8n+{f?h``! zXn97w(m1G9k(CG~pjLyfGGTNS3V0&aP_=5VQUPC4P}Lah67%Y48^(;X?EWOUncjs^ zHO;QbHdcdXSFlZ^UK2%j3{)yMP};(_IvQBB#s(HFFsg$Zs`MEQ^2d8uX`j6p+aSehoUxn`SFy>zpeE5==77 zgta?NB+i*R3pGUQ6;frE`NZnVEKSPMWg^SWtP(7#TPb&$kZKlOx0P$&l8{-=RV}1F zq2|1mtIle!Y$1mxfF@`HdMZhvI#p<5&3I_y?g&k+t?X{Ix+-Jmj~zvHOhr3t#5~fe z0FQ>_#6Qx2CaT0ir46*!WlyACwefvI{&yYlwW-czW)s@iO8PX6RjA%W%oE*C%;S0i za0>9eG8|onvBC4M_?-gaVPP#+i*y0sCk}@{ftZJQcnvO}3kR-;!6bhFHxdW47Uqk% zh4}hi#WI(Jmcf7K>o2DH84c^JLjwHkjd0|1;MG^>r=SeJC-^e(1`nU;h0BMarAlf8 ze2555Z0mwkuLiFOb{LK7uvO$)WNF*!Z6d9YpSwLr_EA>~$NFe-T67@)hzPpOBmRa* zWboq@mS*tPw%I>L!-97u5hxiZR<9ocoJy_s3O@SLXL7{*Bd9YMW5wq_4Ipxcbbm7?F9f1;KDly^i?CZkUMUoiRU{rkE$^vfLwhemc8bj-ia;5V!ru9&C zDiQKJ0XSCDzXG2(vxgN^AgKf#M|4`+mv~NntC{T>Uivdi%a=Q{!@dU0DPAjE#;4c( z2i>6t*gqU_>#dKZo%J^2bq)Rxc%#@ij$OIO2^Vfyo6ejAkSXEkJqNyNR|Y2-8lKta zjPoel5>0Db)B0bcqD^#J`=F_r-74vQ#Cu$bZh9XB-cn2>=~!B!iEDvR0;sl&WV!VF_AMM@S6PZgTN1fL-XfzI!`|3?cC7rcwlBjl70ld znrJsX4Ngp5FQVv!iTD5Q`a9sSXn^M*mGlEMTM1*X6knzRO$6X%Gb{GR^>lEH$RkQm z172umKi$Fh6%Gzl0d~JkETBk;_pKl9G?Ap;iC|ALPqCfj_DxAA5aVFZFtZ)?XUrfD z^maOqzC{El`iX9j-KXuw0Q&mw0SdbzJA;Aou68} zrSIm!>XDWodlmTbmD`|e!^aKa->Mg z3t0SISp3}hd~hwSz4_T}S@{Qot)+XneVKaz%sVg|x5sPh-W`6%+)=`A%AX(61}r=t z^f5|&gcpC|KK}SK=$ZlhKL4MPb+XOh23!huJ{P|Ds`gS90K53O5#S9v>GGd~eSz4& zIDpwV^x7YtiNay*Y&6HXl}T-oa)GRq5e7=&d`YATp1}wO{nUcoF*oKCbAld$`PLMjKy_C zmx+K>!g-$q6~d_iCel2*BX-KW0+y%+TvVqhBW|+eBfNA5+O0jLWC!*jx0ekWGS**{Od#rbxXBjQn57)U|>ym{07#nVPL@mTUQ-aU!~9X=>$*ApJTB#+khuV zW^`G14o}p3N*ZM}Z*)}1YSmEb&Xmy?lIoyKy31C}a8SpOi|)umnk6dSClpGAwCd8( z8sCvB(?kG88l+&71#`93D^Y4m&{&K|W=@F(nI%#ZWM=YaN-e>gcO_g176cZ5Gcy$+ zg(x8lc~pmJg(*Vh7IL5>9*(V0MLeE!2MYX{yF{mBSFO8c?ssCXgD?3RWXxfLJdQ&# z#zV#vCGDTTb~|V&F2a6f*qwOyE`xW2ZF7o9kX&Lid%VP*!G+BG+>HV=BTym@ndSAi z&i$RlOeuUZ^@$IdWhCZ;|D7Bp!5tWqbWQw*6T_z=0oolVYGkBdp{!s|Tq`4S!X<=UTyubAcOX!70to z3<f&|{1b?)ri zrPL2|e1vGafSY>ZMT1S9ytAQyQ-msx@o;VzTvL3;?g*~@eLm^3W$>Z1z?LstCV-E9 z>|+Z@M@PR896+u1k)z^o$n}@*_M}=4O*ognFZ|7g|IT2an7=NbB`*Ev{n&ipcfs~$ z>#7ehT8V%~y(D@{qPrW0>w+%m8Wq_9akm+lD={^h7g!EI_y|KNzar%q(D*#R^=ffz z2n~orJGu`J2NFS&hp~O^iRn!^`ys|nSjhRJNq6@rD0}EAB3jC ziD^x1T02%AA5b_5UNOOB=MWu%UYb9DlcaB&*-s@65ZxULZ2(?tjn0k2$MNwzd~jla zV5)ZBUm}7NGk{mp;kqR$&EEq!-^}WgRuQi~k0-X*9**{-@p;>I1reM$SknBaf%|Fg zSkKG<-rLC?GLN7*0l1FX_~`+@B?Q+{~_QdcK0fB`}wygMs%0r%&PD zZ~vy{>`-QQUk=c`7zg8s)a4Ng3^6d3D#)Xw%YUTl6pShniWeST)R3lQ^(5$UgLnrf@e&RG20)!*LH zq88qC&laK+(RnMLy3c{6?i3lP(}0cKUX^s8WqXe$N<6V`5nI8&Cri%X_oh`>(R8fb ze$YXEUFDHy1Q(7eqCEtq)8-9uKu?)}yk|WR);$LL-Ei&jIWrPYojbtHv}6B-2i=U> zb>{T*a?M})xZnM8^S;E+Gf5TT`T5gV(CB1ocHe7v;SIq50AI)ax9q-Oj{$so&NV3u zh7Jaf$=yAUq}`#nZ+F=5g%DkS_hn)=qBjUvQcth4i(k;vPpgxDxCGo%uoG!OXbCeO zw+~MlOD*YbTV{;nNJ!m*d@fGZBS_H@7alHj&?P>zS^|o z#I&aMSd*FUw7ck34*ccI$3p@zf!o9c5gi-*(Oh6l745bgY~7A#b))Sya9z=HV*Mzt zFGh5zCqs(RgmXDG(Ul^(1~icwiE?*|0-7kIIaJF3<}MSeH$aLs#&0-pxHLnlaKYge zVh?vc;FLsXhXRsthDf60M5>0%#6(IQ=7CVebOfBh0+^BrPm~IlRTept+^XE6r_v99Ah~q1XkF~Q_ID6;&U)sh^wa0dtlHV)X{~J4gW%rr2R;>!x;xOUI-p<=eBw4|G zn%Un51)S;U`P?g9lD;3hR0-7iyIvUUflR^{ukN1%DNV`qI zqXSM9=a*%Vb!Z~jA{wI$4?F)|tx*l{&i~$Z6ujf=wo>#e{62xR0(=g5dI^rGN6RVH z3PDzOgOfM5RrD@~Pp^m>q+LF`PnNU@{j^Z;*r4t%EA z{`D|eg4boSdhECqF8JUwzJJLw(t2zRC%|_;2wz*i46!U3KC zQ@c0XDGf&}*g1fe;k3cF4&IHhy$8-1iJeZ})o5+}UVu70mHhDUg)fe6@3Q#+z3+YR z>JNYT!*9;A?3K>BKNQRKe(;duaqk|7erf(-pR)Pulnreb?8SZ0{QN4eIQ2}j;TMvY z?x4C|)XI9;U<5$OasVQQP`E-AphU{p-OEI5?xc`GzN|5L!lDC(9LRRVIF6m^*pXE* zUIpwAx)e0>sO%mgj{(VYX9}O2O<4w|vVqUP%N;mIbQ6!HDfz4bBbybSoTv3rWoCbp zbTrXc`9s8G`PBSB`Jl)uVn%e8xPw=S)kgaeJM5YdtU9qn`fM}Xr3RpN$`203+=rT9 zd*;v`oVMv|fZ;Ug?>o=AYilyN<wnbovQ z?YGmK*0gp>9p3c#*PSLXGm~@%(Xnn1;!Wb0^8x0M5nU)C-i)1LW^0;e{{_)+>$ya? zI{+kIM09e4IGAISiZ7GCw(EZ6&K8%_DO43b4N4?YOJlyj<8iRNLk3sMa2E(+78ncMGBXiS>X`z6Jl}0lY!smuboW1*L{(y z`4#avd-@bV$Fz14nbc^Q%k50m(3lqg_K#PseComzmFNc+&wFuQP&4fH`~Pe+0eM43Fo7_KimXngEbB949pGI5DkhJ=P@YivVW!rYTOJ0CxbZ z&FuM8b(=VghW%Z$j-ufGW4(AdA0SktRpD75GC78v*aVbHu13mwrMW>9U z__>O>4rqlZDp*%Oz+TO8p$3#kP`NwwdK4;X1IFwO2{ANk&O>kmkZgl~WT9$WSdncU zYK`nz%Ub5MJIsg8>#CYnso20i6&qOd01vQ7tes!OSU~Z9%-O&?5sLKbb-F>3sE6^0*k(yar z@)H6SN)t27giV=fVf zqH~0R6mNbErho=e5#1FO3tjUuq#};Pw?(8IZIS8b|46)_Dkh-)ATJyy3c2F6kiQy~ z-6fKHEjo1d%k<6w&vpu*^FbR!@av?)fjx;EC1;rRVQdd7WkDH|Gby!H!7|f;)x+7y z%`vmL3j1RTGoN5aM&` zK?$RA*!IJm!G?pxH`}3!LOt-U!3a)}#ZJ5HJ52W9?a&0k-B42;^gDn?XWyi{C3b-9 z36Q`A%bWMWWsT{Q5Akj9IUU&Rx)Mv4{}aD~c(YN5Una}=Sbz_B_}o`N#ZT{Z{2hU( z01xcm$D7W2XX`RQ^|4m}!m~Q8^C3!F*02>=zHACd(z2$%%f_~2!p2pAm*fwBUyU&v z<1`HSDt0bCli1<=UI4|*BLJhZa$sDw_bXrd%IkpZ)~`P>-}Yw%A03--c(jcChZI3vnQa9`akqki;87 zpGS3gI&-+ei;_e(6=Cdc!2QIw`RTNQ z6OtYWJR^VF90_?95$HdW1~~Cu;I)w2sA|6NIZI9w@S2CooSnxq$}Tj(W; z@uHPW7XFXPomU&}x%7ZrZ><45aM+$bBcbbvpzus#M?(2oO0!1af?#%<@YVh1^SQNK z`0N8)2*8?J#%uqumUr(ti__)}NZ1^VmrJ~ydOcgYWbrK~yAsoNl#*);kRo?9TuMCl z`a5iIyY?ZTe?BPbQev^wRc2=T+aL5Ws3Snn1dasvETGc3G<1*|0HSpzltqfJ8uc9y=He76gC=rE^uM%)`=rK=t^vM z_eNVcGFu}HD>mzaIOeiu0kGx)hRXX{Z*7hC-?+f;o*i8$x+{GK1FT!OP6a$M$_C9z zG3cS1ZB}1-x4`xqBmLdf7@>O@=&3VG1*p?iE``je%4*e637N94zEG*xlvS$oq2WH! zopl+R!m=rp#QHm`Ro@v&<)B zksO97fC;loP+GE5y>2d#y4qYO1{onu zDppGBRvJ!nXrkNLvW0qOZYZ;fsX9&U2%5N&;s*0t8bdEoxJ@)`Y7rgnzv?6JHUWn0d)~ZHM)Otwj6SgE~#)^5}<&7XgfK zj5JHlP(e7GLyOyr-U_#!^}fzCeYV1HH{?V3A#m_nu__0EOKwAdy^xPwvziwIhuyoC z|FmdXXi35upE;IIm)zF2zqcL^8u$KA>VSNC#~p}W()74xqGcT)%Pni%B(MxEZ#*u3 z$Ge*WlLEF_4$2>|B!Ux9dJZI4gP#XKTLTXOdw955@RbC*DhsgGegp%-roJM z-nQ+wjlgX0hyQ!Uk6-$gq}2O^frDP~^WMdiH&P4rk?*6`wa!xSNXpLY-Vw^qoOcAL z>O`l8ln4bR2=AhAR&KFHaPj?S^NAvoqeYIfBgBF_|JvatpeaK?t`sJ@Cu+eDYmN zK0AjdTWMkZ%i8~9uHOdYw#}OT?|;Fq`(LL$vQ5`)O8Ukc_qUh#dd^>Rdv+{q%Rk?> z96Y8qt!eF&+AIINF0ZVeP-gaHNuL7Vp1<^>rnhgU;c(ZkWyFEm<#yBHaGAe4YQCZ|4doiDAgwiyr_kY^v~Y zk(rH3T2F-ETe9ijb)@Fuc%zIJ!SVY~{pKAvvF-~Gg~R?YrsEAy2#9encc>YfrLV55*r2QPGQ<&eVL@M0v`lkE$K`%Yla+8 zB(_2Cqse8(%tj=A4ET_we>1ZUX4YDbHL+e!>~}bE2h$YAG5wNeO_V7|}}7eMjuwU8|MOMRrDfMF87DUj%yt(b>9U#-~>nl^reDR~)*}0XTQ6 zY~krBbZY;P+%{ZY^{@ADIdGfzynVr}Up;G}dq2kNJaM37WOhusYk2#LLl@nFGn18{ zib6$=?Q4-YxTjj@hQU!*RqG?O68GgzKAdbYt7gWB@7u&J!&Upp<7TS>9S36J2cRt2h#&r^ZSbecU;%qdbZzky7twopkvn zn7(cozVPRrHe1JEIfK{Mz5@JB)2ka1%Q5@MxP1sXlfiY*(1|}f!7h5?>IuJx$)x7W z)JLa7eOl9+)~+K-M*?$+=cZmd6q>f{tO;H}3b-++COW!J0tgOE0_F`|-os8T zNemTXKE!yC0-&%Q(nv(WLzcvgv_&6hSsf*%2u~=9*XvI3goIItx&xPCm6TwHf*(~V zcS(sU$&HG^HNnyALVILKcec^C6_Fhybqd6h8Y;FRU-bdy zF1x+9Lges7-^K;Tf*h>i0lF(#0Z&i@>VxV|N5dhHS#N(gBaF~JT%$yn4OhGy zP3jh-JF;kfJUR?rDb)Kc$r|nx^-z~jlTgmOMH|mb3aefWj%YU{c+JB_UNP zN#zi%5#teEC=$yQ%$b>&qm)AwDdce;!MqalD%>bQ6d(l%mq&aEN3$zMFs}?^9EX+S z@KO_0Azc1i5wi}oJ503hiW6wk%e@r~D9KseCjQ_}XC|^YBK{hXne`&Q4Y99W_`D3C zdb0wO0NZS6hBxzAM&e4rnGsy_0huM{{9A%cw<-&UQcD1DjVO+?B{M=SdES`0)EDj& zxQyTxs$`_83r0qoC}j1-%w$SS7V33NL&+jzk;ih>%o10&TIx;CS#T9goVTQ!jk!!z zM@P-Oa!WKvN`;(O_c zfJXM7^jBwo8Yga#w`s_8AzHU>k_8W^;RXF%; z_NwDL<{`h8?@_oKBqSWy5{>!rbV7dc33ObsZMUK03X-V}&KS=(jn^f&p#y+V{em)i zW6{C7vzE0?CK&r(#j>#qv+{3YU^#4A3Zox^m)B$U&jMhnhox)QtQlUmY}pk_l6Z< zbJ)q_tR8o$q-=O^xRS+Ff};{LSuhbYXD(4)nFyJ~IW_K_vhm~j7Su>EP}Bc>r!zG` z1hdZ06VcB3ug1SIiDYY0auFfh2F@^N$OE~hk~wQ+o+jimR}-tn5~}TPQAs@PC5zBS zzAz>E^CX8K^5~8+c%;S-<2r!oa=Hx|gwk$C&nED5jrw|n3Umz^+t)+)0XBtpz_cEM z@=WY;x!8|I>7*aN3Uo&EYbS61DMt_93UTj#>yqExuya*B(`wOL4SboVs)!qU_M5qK z$$tCod*g~p^UVM33hdr?pSkugv?bG;*0dfwDk}1)dh_uclwtSB^l79Y3h##O%qSbfN%ncnGmj8i3dWarK_-3Xjlt@d2_@;g_* z12_=i^cCwazvrlhAJ4Yw)ezn+(=&<^M49y?4xgZ(-B-<4|7i2jZdYy{ne~h9BW%e+ zzU`b~W_L^aBoW$s2Eg|>4e6>a!}oq>@w}fLHPCY~*der3g(#h0O7?u++yP!UcK~n3 z9V2ya8XDd3r&0giKh~=s{+}(QuO|oWfZNUNL)z!?#q{p|4!U;x8)hw<&%6V{l_2)} zb?W;Iz@4nWZIHXZcNlALan!a$?DIPpc&C}wCH;_1cYl-HzqJS@Fl!O)edN77;bng! z?OFnPlzKzEF%Y33ky7SL@`0L8=ZXl zsrFyTUf$^kom8f2$BAi8>oFurPXVrJdTB=f`cz`zD>NdbHqhyQuSVmDx04YfyftRKaxf)anG@y{=(}42{P7zj6DBuZjK8Gd}Lm|I*dZWMtmH&(I1hF^0 zSw5f86+_!GJHdj19KmAmc<`|Y-UUUFA{Bvvf=8A^8fLKwQ_+2bBD%wsKy^qx;?UhhCL`V4F@z-#dUWnkQtO@uFKRpvSXud8l5k?ich~5 z_SlCth3mweQ4MV9GPsYS@?N$_ZH*pSlamubZ`Xjqw&*;u_k0_?7e?!Ynv=s5WWy?_ zRU6t4y}lbiv)j6}5m7CNdQVBCjFM5OFR57O`<2zIitZCGRO(JysLEHO`$Pye`H+mo zcZA?%swr5aG;?hZ6jCTn_UE)-dsDlsp!RLu~DC}F{?WT}Eh4~48$ zq8X%!jueKO$;`_Wtwai#BJN}bP!a7b3Kxl1u%g)G;$^&mEXEzvN)Lvt;Y=fUBf-YG z{yHVr7{1CMIS7hlL{5oG*#_W03HA#@ax}810g~CvZiSeMyZcWXF!d=3oG zi2P5pV!!+(t&hg-vik#SsX|8U;mxunEW#vXGdCPSWZ1ZgtN4 z`{PvITity--7E=l?C0}IZr!R=Rj2FLty^`@_dHK7I|Q0o4z#=sXks|MT5c1t9l(jW z0qQt>1J)BFav6Rk#yUnGHvRZWBbZ(Vr8^T|mjDwl;}fYptjNd>I|+0$_yMP;MllqN zp*CJh7zjtCgYH#_xI3ixvyxH#nFdoiDGiLr+N-T?&F?mC+CXe~9~d*5(KtImC%uTd zaB2#vNXnesO(9jJr;$TO;%;FKy)GVfkZmHr_#8jI7?#cb7JIMi;tc0F5g*yn1iZsq z`;PAJ?$XbH{`2$Z%<295%$aYfHHPi6$LH@`z4_{W`(IdfhI95^pa%mjs6D|}drs(E z`K$ion%mABx9}^MNbAfxqZbv0YDNZr<(n9-lR-LgLX$WSX9SSQ1Q11l^}lzC%S7VH zppm~tOFJ}dQ!1dp@C`a5ptBJvqWV065gcy=ZE3LDpHTP8+09EWV$E~7FXuWuAhDxD zy}hOEBT;N91j$WVKZJQD+Sx9JWBO~6oO#nO5L}wRgwHFl=W{RkR3H)g(cA}CEZuJV z7daG28ojPn)d#j!{w40?7<`9PWw71*tEJ5?Gk%>db=!&w1Aw)eiQL(`_xt9;7hmnV zHPF-n??hg7KJl2wG^W2fB|}$73*8ArpEa|LoIQ2{zUk?GG>#k|xD#)WJ_9&WRflzM z+lDTS_caqZ3Tjb!Nyqf{jXJzl^_L=YE^wBJd~Bo#b`hBdycyp?w|-k?spsSkplzLF zUaI5sH_807kC4fE$2T$ueVLJpW7?5YaW$()F)uBuWBCDd-eZLS25C-h`Kl(VerWoGf9VI9^WbyO zFP}eup|nO9A)M`tu)9P5xMIPaA1SUCBPW6uhP0xHu2tkGU@x2Z;Pdt9BoQeXVV|ZP z@1E59Cflty3LFlS8yNvn2R!_X&c28LW!0wBtkyc#0ImW)q^kV@s`|W$EX2o1oDI=X@E%qDb$vB`Ktx^- z`~bBlvSm4RKDR6DA8zBIkNk%5yB^NKzrT^%K^BqGMY3qg3Xb|}k>`F58y|&okJBG7 zEa6+bub0zrnTfhZARnOassXS!$iE}u`98{nwRngtxmJ7NBNfM?SHG=Wgp&uwcuYd| zW?8i4JFIK^wBEh&#o2J0)F>SpbDS8{nEndXk4MiB4u=2$AOJ~3K~xmx4VvHnBDUdx z#iRMc59cgI498rlQ zIwW~DNVSZSoQEZHQimpnI8CIX3F>YXP6%w`P60*~BLU)E3{t3vD8hK2iy;Z;d~`?b z(Jam(CWs-029Rao50H17ur+`}H9(!i7=w!(#t6(M2L9D z2?@pj{6!Ji0LfM%lY%ECY2b|fha`~?`K}oMOE01CpRPt2TnU%WBUy3H7I8VG7o{me zhKuZI$%!%nCiTJ7tsAASXDXF^pnDfG`ebpn6xmJJ#m8YLiR*}mC#bBGwoT32Hgi|j zFbJN=qD|T9+FR+77J8W-PL4+g^w9@2Z|#@j`0<)VcVq~(KbJEls-)c~s2HteBZFzt zpxkSMLZnH2hjSINQ6O2D1}H?FRwd_hRIM|hxJZnU!G&d$C5v;Bh^kaoC2-+3APNS{mOX^fM{i$Hfi~ z)qcbUd;>y6oLZ-UFlvrB>UMR=D(}{z^HsD51cV1*l?94V?DI6?p@~deLBc zRh^npwHC)gg&@kglB*B|Rn1gGHO^=hn4!Rg5tY!-t57Bz<{iZ{E^KiX`f21c0XYUn zbF?d4x6&6hX*MkD;AoCKP{7BuV>erkRsc&bgmC#7rTR3_0C?BFcI&spjPxe0X z#1o1?#*Vv2VSQFopl@S&(_)00}&%TZ$|H(BfHJP@? zgAy7$M2PXu5&i(xDvM-N^M_I5Mp1Qs+K5uMN@(J^j%}oEg*o*hTiZ~n+uy>DX-o|y z=bme*9(*;Twb4pBt@5pPKO(PHfX&VY!vrzCV%i@+suti+q~e@jL460GuieGSop3uu z`s0PAxhGxz)QaqseUf>PO6ob;FImk2|eDI@(I9>N4Qi(Uxzp{(U0ySX|dLfICE_nYx3};Fyl|x);5O{cK=h zWXZOabZqsfXBxx9&T$d22g1$C{G4*33a5(Y*v}p=CtiGyE*)*X{*Nf_U^3$QDI&W9 z-*2$!7~r4TMx=(S{*f1PzNzXbM=rHZU5W=M4i%AkaU@Iv^({?M;(=Tr7m+{W zzkkj6^ZxT&s+N1IMegY-axtAW2gV-JT6pw*Q`^?OzB#w6!0P~0G&vqB%wkz#UU=7( z*Gyylo?t?(hw~cAqWTQoYo2HMk~UT@J%~zA(pKAqkI_l%55T)rYkfHB`ge)Q$?S6Q zc}(2>bIdwApk?Yf;Fv)z2o`i1@GQu5;82EMKj$$00GJ*dM^*dIl|{Gg5AF`a%3XT( z32X6jR~O2nn-_pN3*2cS$sm_F%42}Gf?1?LId;j=x}$L1x8(F&e~-HB@NKXHoXw2> z{pH=iI!&+r`yqexuyTw!PK;?xe?^M#apsH2WZ(^WxGli9n~%6U-ZA_xRec;8)XzGM z+XVQQ{tu=XiqGx^YHky?h>kvFMiw>}k;$zfvD-vf1!?zg6PQL39a+Q}L}G`DeCPp- zYSu#&xd4eGj1f%L!xBbfSc0eyP1qQk2&qFAe&ix1486+)$ub*56^coK35_t$#C6ex zNAUlgiT$M&aocjHQV&ds0Vm$uSwQ2VhhhR0MZ}_N5EJ06?>`n7kB&rL!6nzTUDS$%B2he@ ztec!lK@3$S_l7PWaO<}hVo~3tT3;nD69P)0xB+LXIwHjS%SMEel+}1OnG8r=BM=*4 z!}AahjKBPki`cWBm5`xfo8^OR*w<5L<4c5NbD{V$8ng9I$PBYLWZm>2W83d_p1Jr&L7CTq49%~6LY3b}S=-8$C80BEAM zFjaXLUVJ=<*Jz-L#u{{K-;Qn*uzjLB{_2%>m59H-H{d&gW<2FHKd&6kcCzr=D%>t` z$$0o?Cv+KDlj;_oI^4P^pM>FhzudrDzT$t>|BIn56pb7Y(n@#iFX9)&mJ^ZH$@Hdb z^)*X7I!4uzvJjx7Lt1-!1mK8A9(k*S4*|9{43F=PqQwet*<3DP{+m^+jy`_k!~s3S znmX$PAlc3Y2^JF|8*3W0}qk9mqplsxY1d~ zifHXslSH>sTxiojxM{FLjK4h`38gDsC(}VN5Sm&m8n+L>H!K zeeQ)D*rV**m;^pM_n~Jy8m&5}S3>S*#8$!pkL7op|MX#dw(fE7Q#)6#jxcRNO9@JHVN*bOm3AF2mR99U@Y|M-4Uu&j1ax z+PAY3AaHAX=7qo2`+@t@^FDRB%n9N+1{KER0g$CTppH9}x~M(2Z~OcdkpTEfs$2)~ zAa%&#A`!VuRd*7%L~g=Acg_G#1a`E63M@90tcp%!Bf zNg6?>WCG5d(#Dxn+L}Q=z2d;xQ?l9Us+qrEQ?r4Oe*=!kySxnN&afQ#L7#P(FX`;v zC}-T(jIAEhT@)1Gdvi$LPV|tewH|9$jNt%BUAkcPP_R%42;pJt9L^Y^gE2(^*{8= zx7OPG)SQq>ONCK2h2-+%tatS^!@`VOz8H}v{=&|_`g)bs$iiFn?|l-tCV z5|X%0jBkRTo_a(_UxXCX5gisWigd>T*p+JRHc`doLL^d*2!f{KIx-j=5o9tRqG$w7 zgnoFwsX`zYBLRlkWuoRhA($w_;2{Pd)8UtUSRw``#K(6??Lf#deNCy>Z*i!C8qgp> zRT1?(gtIX~5k=mKLKMLw_(%`mH4xi82Z{tS6k*kqAYlrgAciL-M2R5st{9p%XvHCs zU_y(MK}6xsj=Y3Wkq#7tlFy525fG2>}~^hA1d@% z$Ok$-{(IMzR!Dn(jy_o`$=<-)a-SsdL|1mEwgJ1YT|@UCuhp);PVw+WAKjTYiW@e{ z)EJ)FRNW*qGc5|ul%u{>bVt9~@$Ie>6{XPMO@=n@&*cnM$&;x6;joxIVpd#WlH0DmLoI?VQix`6(r_Ox?RGo@Nr0i^-ZL}#{L^Q>hcG~pAeUpzE% z{ivadp|f@@Gy&TOoVWy^7y44HQeV}E`{c)U@KMjfcgud{Q`W-Qo8Yeg#Fb|lO@@}L zZ_Jnse5ULhcf!(MO+pYC_T4OYzX( zH@o-W|NhrJ{`iO2l*L9@pM|L4@S}e zhQI^r!HEUmdHCUQznL=|+5|W_C@%kCdj8-4?svJKYSrAmaA7g|{FVZ+kRv~^uUsbrCCbDK^FCLQvRolmTL z^g`R;c{q@-F8{-8vh$C5N~>115Qzp>h(ggQ^wUAk|8R`f&~~swhW})$@dZ$l$FR_;+8$%$X zK0wXH@f=16M0KPAikc$o78X+99zyL0--KE#5@ZxRlGEhiHl}u7gxSrQ{stwd-Et(t zm(%l(=zEg)bpAGer}xfzX!Yegpei@uohHC{I&BYKgwN%DDfb%NO)IifuOwv#^+3}+ zvp#Bl`yTMqSFu_{rGpw_bu6l5Ok*0;h)MwK2_n*}sttj#c$CqbtriLJn2sXQEtt z(Y^ZZ?OVg0PpaB4BAf8f-MfuY{9i~}y5jBlmjX}XZ?^Nm|A@#zs#+Yn`i_;VMzN#k z7lBhmWC^er9;*5It5Bun_`Z;I){g0~L+Qk5H%gD&=N8O5fk1vtoHHM9>8ie{^x@Y& zx}k4CVG*-p!JI=?-FpNUAvAA$H*U5nb29zqk36?v)|(+b3|u}*z;2{9<%kW{=>7v+ z3tvxz5`#7G56^bTW1;q+lh1H`do%Bv*upN^bn~Y!P-Q{69RBQ$w?zJo^uHe0PIfwK;!+6&R zzW-nj@NpGBZo4&lZo!;KAKd>nzyH_On-9ISyMJogr9ZY>GKj%DIlLK>Z_AvcA7H=J zp=H{kG=e=UJtbD&ooB@z(D_^eKe+k18IJ)Cve51-_RF}x2 zCFimG1OKLr7jJvyifYPnVho%Z)0qAWHCm^(nndJ?(04Q3FZ%~^K|P|Qr3(Eyq{Semp%EQ|AQB>?e!hqYC?ty!i%1f|Ve79}3DWT#2{hp} zcA-#$FhKAz9DyhXgAt#QU`*hr9T-&)O=udHFo-07dg3^-jjN^+;&2a8P^T!)k3SaB zNPS!f;7r^p;M99cquzZ&EfNG^6|u3evJwABCh&wfu!06Q4i2fmA{jIi-}#UUQB@38 zs0bQ54^c=Fkt`w(Ng_LJh)P*STSQF>>FsmIV%+%gqFc9m*NH7HD)SJ1p{MRTK_R2< z^Rmj?wd|drsZUNSN!zBp0<`CvmGWBY&h4XZ~~Zbj7S z9|I?~HgHA%5(O#y^lI{ru6l=w+W8wOCJ3CmQwH!sj+F)zp%!b^BEd>T_pU8gcYp+; z74bJ`R?LkOxdW}?0zLDc};FM`Cd}#x0 z8nVwSABiW+lM39BxJG=6n;7UuI#h$BDF(f-JzO|zo6<1AulL*Uxr3H1yI{(wpPV}N{TI)iS$VQl5`YK$`o5zuL*SVc+S|YS zWT_;#&YQR9fIt8FOJ(Q2RdMc%6CZu_wtM#2qsAy0ky@P;nr`XpdP$j^0K4UK$;Vjx zyOO#MrvkpEEScUrpC5862m=9(d=OkywDujqw9lU2K4XTz_*N>lh>xbAsT-c;)?3g0m8u>chT*?2 zeBGJn_t8m-X6Qp!7YkxbdBH`s_?LXsq|Wj9E`0?wlUEx>qWF_QZCU!Uq8TS(g-jMq z8C*eeRUsRKaZrhbTsSZyYNRX2fT)Wh2Q!Dtf*QT5v>}{e;HRTW+3?aT&iw-6{UC_Z3)~{!zHk~p3?MP1h)l?+BmJ~-jCF_&1a>6HcU0%*n06vb zJT4RvVVmtO%jeI}No#ZwB4?*&mq0!~ciGBI(`8q@Ztm_baHq)uv(7}_EEw`sUKaS3 zN^p%;yMF**zz+~Ai14|%M#EKQ1#rhV)^DBslaB5awnh%%7pgk6<+b)_N-OX^VgPPM zsmiz4Z|(Ws`mG=Q^XunysMs?=PNW_?lNXT_PoC6r;t}KW{O^`Ne!8iLHRTBWZ`j>5 zPq~8GNAHgbKf$EELZp1b`mRC-t!hMzw6wYxrxXzc2s zuZQ$!AtC63@qt^)8w07tdb#f_7W`Zs1tjb`6>HW|;GL7;yDCKt0E159wm;CJ1_u-wDvUm{YIuZE}@L5$IGL$9(DMa4(DDVct9LzoLLKeKg zGj^mnoS|c&=72kE;4CR2`c2f_1Nsk*qderz^lscDi*ETD#(rO~I{qO@MRzP(@-WD? zpfloi7W2$Ohs()J7U^}z4gbuUw(8$z7vPx2G^U+Vs`}VVSnV?w_QOMI@rD`~Z0I%- zUo{4}O~f%B%SLjWs3H;|9VJXl4k;SMSVZzZqN9*OL=Z7Z)pznsHNfPel*@#q+#+P) zD~ic9fF?uPF7hkE<@C4NMK_C#tuK?Df0Vp9z zgjPb(2(meBIr0t^Rf7p_NhO{T^%3Z>$)r?~|?V8*v%!KB( zeF}XsJc0Jm>fwn>hvYNF?h{)i8&Y$hD2^Ym6^a!4D`d!P65j!k&t_a?%TflYm>NJq z)euCH2?~)~7m9O6s;*aTSan2s5*G@|XQ@Qico&LDa5-`=5T{j{7lObV zC#)H8g1WjXx~ahux%fIzjkg~m!tR2!rB^j#wu*_Il~AFIs&)_f5(tyTsZ}D31R4@i zb(!`=!APiC6KaJDrW&e9sD`M;ihd}p@<1qA4X|1cK%}BoATXj* zF`6}^fe|f+kN^|bsAf%|=}3;oz=YF?Y8{whGsPgU*|1%+Tes2|1X>;7GEtA_XwS7P ztYiJUVjRtpt)1hq1T>L$o2Wq(qw12|@op2alSFlh$f>|*fMZm(AvOLA?yLSqd=cxt z3(mV9<^t~lW>;XDz)u6X$-uJ$k%c+dXD+^%I_drOfBg#IJ2(D>7X$zKHU6!;%sYX$ zjlKMD+XcMuhyUP{VZLxD&8xPWPdVKC0StV7<8dbq0V@&>h9nyO$!RzuE3zTMxHnWP zr(d#q^*8S9?Va?MY17ufcj83b7KZ=Q6-Boz%>7ws=dY&y=}-TB*ZlcU1AOr>e`&g< zyZel?a~I-A<8*$owKYmWhm%&WJk@$&(@hM+4_+{FVu^BD0Ir%b73X7FYJcotY4*Eu-pwKsJg6GIHHxCoUw!ol zi_@m#^(Fk!t&Oe+N zEQO$eD_b;g!BnMG4TXX;Xe5OGR|v%ueIC*qo#I?7)CnT^U5~< zN7NW6fJ{7t#~O9o@08E8t;0SZVp;bNZvnQc+Fvm$j&m-Nsd|?GGjo@l%vu+s%Wk; zjcH7O(|Qo!3=!gUhlhX@BJyE;%tfOAP}K(kRJAA~9{}#c-&KwWt`d=>v}UQfUG)E` zI|2QMLGc$U{Q&h_NxNM)9+FA)L%cP9(gFDi5xGNEmu%Ns z!}sIY{{b3;6RNsOL~aL;p+5R@hsSipF(--j{&3*bn08t@tv7Axux&^y516x?Y198v zf1OYCv_Vduz05yLBvBZMdk=y9-7q5p9zyhPoat9_hoJV_U~u%qP&JI+_^!y;Qe}p{ zpB9n5f$K=c<^c}_Czn;1$7SxHlgs@6nD(Z#7q&I+wV0EC^{HR{5V%l2cvBNS z;Q_U158(*3(J|6I%ICqI13ZOt9im;RIRMckQh)CR(6eynELpVVNzf~kC=dO~ale(5 zZ+RUVxeD}{xct$CJSeB#da7P?Y~x5RCG9xz5*uvBG^R1_3=)wRd~8|ka7FNObqg7x zuWNCGd5OFCh;9>Y$mD+5T1FDLiO^yaw+SgC&CMVNX(}P*tdFMpno@-=h}r zE*xkb#PAg(PUuj-ACbh`IvEg&MxbE?k)RR*0V)>BWl`pWJF4*Rh*23%cl(=4_ibXVLD>&9bq&QD*J7XU)QKsQW~qm7a<; z+X8lcLDTUaHGm>8nzw#pfy=7RM&evL%447t zg#h9*QgYECH;Ot)5q}&pOkpHL$Y7WP1_BiUhDeQ&(OOJLBA@4yM0RKms>qNUDOkH3 zOs^UDozx0NwcZpDQG`GhBY|2g;|GWOL_#%iCi3YXAtJ7r=7$6+;nYHi1FUgs0^196 z9SYenRAZc0h%nVaYY`kKqvEVOssxg`O^sC-!xFvVm&fiB*)VVkEKxEUKe*bcW=&Zs zf(!GG(9j5&$OKM%1^^SOSPr1Cr=rn17JDJftK7BZO`X4 z)dj&bt-GtgIFAmRNFCHs%zAa83D`-%3H$@X0{nGmyMPme-6dYEt^;>2y!YSWvDkT{ z893ege~q*`2>5LDWv&>!;0J%tig*8llda`{fH(G3c=F`yS&65@XM@WF7`Xh5S+mYd z)?3=qQ6ut_KWibdECogkmSLb%!W#>P2kz|Y=>R5IoICeNn>L*baK+}$lc$DZ&$Y8= z{qDq-E6?h;_7a67HdZQ+?fb+N>+xXUG~z2#0Cz8HZT-?bJk;>owQG0jv-X?#0+&26 zbLJn2>KDg@!cgaCvmahwsobxy`}JL2Upv3O{SyEmZfU9h$EHnpSa_?2x8Kt1J8;GY z!HMC_=w?>Md1AAGRYOnO&M5k)s?VStB89#Bto=!Po>Toy7)9Sr&zlv73IhR+F1g%EA8&7u5^tX`O`G&VMKGC|ALy5ggr4H%DSVNEn;#iKvg(4vX)d}8|DPGX%+hGvv?$FS@ z0jJg|*I{%GYK*`Ais2>|F}V0XPQh8@Qr1fG-})OwU))G(G1|CZgUh^3#W`$L@G%_~ z3$6k=Q7S0mHlUCJ+vyj`D3x9zJ2q0{847O;Ej{by9Q7QLye8oNLI3ICigz>h`bwW_)^#93X62PXg?OMs*utV5~C$lUlU z?0-xzL#pEHBZy2x$BE?!%=vo}y`034*XtJ|<{xJ-ThX)Pz`2L{C=NXhk(MD1nXp+@ zpHh)fV1HB&@CJ;d7)qwv3-ZOe53OwE(w44o!wzr}IRp4_21Zp}g^#5ui^yU4K~RfU zl&j7Ey`hW$-q6Loe1_wvOl027{q&iZ-DO!}F84Rhqbk8v;H|^dRq0+MbUX(p9Q@uZSFgzn+{DuYMr# zu!#KAFisu~kG+2X_`n}r(fW&SSy**%Jw+V@mqGAGrDF+^sFqIgV zus))rs+gR?WW~c0QQ|BSVWLdzJdwe;DuILzoF~9kJtPq%kc3!*5R8)=9AU)y_oDtE zf{1sjFbO0P_c4iB#P}wDe}fSCVTJ=PohAiM#1Ms1R2&+&HEZI{IL8 zb58sA=%9O5GZPA}y1LjSy8)|OJdcf~j2RE?4J zw?IW!5Kvp5H5r8pm5K*5>YzlZ5?XbYDj5Xhsu~5Mf{)?w&JtF|Wa20e(TWizEaAc? z=b?il(3(2sar#nZRjvzgS<8k0454rq(HW(qJ3erW11CgeI{s#S4`AXpiq4=uvgVbpLk*UACGL|K zgD!^uXoJi9;62VaUhE4@!GDr30FN2NO|!;v^>ZJm2mB9meJeh6x>(3+-GB{ z^ai6&Fz}#*K7l_a zP6?~aW%=~fslAUCi|^bNMgOj_hd|lD)4PXZb$-0=qqApUecbcU|9(}a^05exQrH#m zhP2ke<1ImO)psUMT5@=yU{^(vFbketQ8_IT9unyL=Uv(s&zc2m%h7cF%d%T8rzf?yN4sUSCw_R%ns-&L zJ;lL%g=q@A0GkCK%owxe4O6CE_K$lW+XJwgS?o8pz0#CvI^nhzx1Csyswbjuo}$x1 zCxUDeF;54X%q`RRdB^1w_dlk;+E=VUu-l5!Ke@hpvh%K2gZ2}Cj(fqM%{ODrYFW$O`T^Q{ES`8)WE0;;_BHhsKX3@ zQ|vXu;DVPj_P}Z4GT|W%3H@cpIUrC1I}myt)6S&b@D1m+PhLdc2YeFvw5s0zYE|r| zNZxbPLNEiYV&B;R3?JV7>v|c?M~CDPk7>K9->rL$c6%x5 zXk7*T@l~qBm|mhxs>xW)z*fkmM@cxdXV!TloI|~ZvMj>qTs8c;1ks0{J7CraP&YT; zLVaaXt4b%Bae_`ndv(Ki#6X{J3 zXbTz~%@L~yI17L8{W;(a{I$U=%)_KTVamRC`HTZQzu7)-JR-xkjRrVomp8IcdF|HS zsvWmaEq7k<#iiFA30#c-PEG=rh{$=szv)1Cg9bw(2h{(~z}3LiEs^D}u72+7>c8XS zxgY;(+w^@-EJ@~!iph){yk1VL9NqgkCv^RhBYU67M9y-1d$Dp&l<$48w=~|>e`CkT z$Koszc?$11aSq=7>D%~0J8k&rj!S`$4T|m<{@9;+!$cP4u0U(RAHXIsXVMZa9pFeY zG}^;}q@PI~&;`;`^X>KngN_F|p5BdHIPI37;mr3i?tVnBL79ec(_YLo2Q843e|=`+ z^x-S0L27!;abiqk`YV%&%mIGKK$veNtq;;sYoq84TH1kR8NPe2<~C78CdYmk6DB}c z&rr7snxWZ%lsv^}fJze4QAMg*gfddK7%`Y!3{ThujIiEG!dQ$AF`>f{U_ysDVZ`^>80VcQeB-^tXb`^&#u@KE5&xMc5G3XmBm!ds@46v)&uC)D2?zCXFaN`$ ziM>DqG{mq3A-KpwXmBoY4{wy-dLqC{$xY!~x>)eccun17cCc z$AZMi%(usfkg;glA2-eAK>HCFdN&Pck*vfX(@oG@QR#?~LMUpgb=L`it!0(D;{&%D zl_|ZV9Yre>3&}vv_4sCG-+eT-uu<3;WpiP^PAqQm(H-k!_ldH1 zpUBfk=cbvID(htWj2Q#mCz5pCB)+2>HfwWFpA=gQ5YiZ+z<2$GL7)jh0VVGY5yyDs zobfIcDTqQ)#5swgKni5BE)eS?k$e{Gj1)yAPlaJYij0#|6bMwwk&O`-C2^)`1XKVu zr~;rK`%wob>aG)s6c@(Zv|y2g5$Z1Us(%dN=a{&$AqvzD`evILq)-z+0a_x}TUIqR z8S$=#vD3t$e006bS?kh}1PDQBRjNiE2`FJSGO7e+0tvN<5E!F@$*LumvDhmTP!IU@|ji*1HXJ|B*#!-q7xV{mII)WYuEMb){!6N zG663pngb?J?uffY6TK49#8B->w+R5*9{UrKlYlFz=LU{OtAM>!b)*KZ!TVZIJ(gjb zs&0I_?h+&E+^^I>%f$_rHv%QL02D#%zNNu&8w(lUMPe`@k&cf@l#ZGh+&hve4FL?R zS#jC&$YnQH+=yjnjJU&BPU}+p8$7)&P0boj{+2YLF*6rx0)j-ju$Bw5Y83+sj6q7A zELKI4L@8H`M!i(`&YUR#o#nE$=W^Ovo}4xvj0fnVRd zbK%q=8kY$Ku?7kJ?Ux{k`ujk2o?$f!IAI2ke}K3vyvDtH-jq05O^u@JFoDBae=Dit zz&Ss^_TG9cN8=6E)H#1^=Al3TFa2ID68iZrE*n^f#LJvcTSz+p3vT-gz|JHoCwsv}aW8Aqn7WGhM~>&TB&wpNs$mWtlJa5T8em|}^@LwJ{? zwz;Aj6m0YeDSxa9w%6UX@&Yp@>Plw) zV(zk)?|Q{5JeqomOax}eZ=YAy&KveDz~%GZXep-haH~rj_5k?UFg$T4zT| zPP_SIh}7-dh41Ut$9-rUtBh$(V;U0xB9aGI%Y~%6>tI(`2>Dc zVlS|(sty;+vePJTx7Yw&p{nO>queQYn5GB+w{;Cyc6&%f#sh2c4Tzsq)o+fl%9wUC zJ$K;jvr)bUpzzIk%T|68;JJh6?TWQO#XE|43C}C$d!qJekiVmGTjpr2BnE&IyFd8! zkO3G?vRP`J2{Jrrlv*~po!-EKK#e;rQ z10^Q!1C#fLDf=lV*jC-`1l!wjSl?5bxAZ(R@sPe}81Du!=nnL*%Qkl3f6-q$-#5Uk z*aHctB~CRWay`@<^-omQpU3k<;7h=lNm@0str7d3b}M`Q{Vw?D)gc;Z`%Qkc zw)xhnZMJ`Z8hi#DtCnAG>E*gjJ-WJaTb_&Sc@G{cnVVX+3^+wqpNs4HV|p`gdAJRYy+>bM-=(WeL8oWdK;7v{R%Ap{K0dHa`NHKT~-A1I$lfW;4BjSIF z)}Zbbz2^A)0OXCI{2_DS;vKHmFMCGs`tlyb?{7?F8q>}u5xE9P{2Rk3ck%a-2Z?d*|?D=LLg$2MFig8N~VE zYH`N13r_v3>hQnu>I1gb0mgZd0Uu7QMsQC3dr?1a3{Dk?;$kNXhx%8mxC~hJV1+ec zEjR;KBOD>tSgeNFDDv|I!75l)oC?-~%?nlqTTxsnSap7%&f(PIiVl~_;+!iuXK~hw z%UN-Syf`hPwjfS3qAk|AEq$Wnr-^nHj85nkeFE4c%DALYX+2Qv+)XDp=X4d&v#}7L zY4g|;J5GSNU!2%7Q8)K)7MRb(KX38Jbk=Tkl{=*~?xgN3cS@-oC`3i6*pfgS)uxP8t?wty+p<6lkqsrXzMn9170Knp zcsi7E_LtV*KL#?lq(ZJaFq1}TLC4Bq_l>BQ60uyRrtQLXLSPe`j9$``>Fj);^ zSi-wYWEJ`;mm&>K*3S=eF)-0fDaa|10w$;d698=8N?*{V*|4m@pjZy-u^g;p{W@Zo ziN?T0J(^?sfa6(*CPp94@#3M0fpd2>Gy&VeaY97q16NWfcDnGRI$neS$y$R4Dw2nb zhk@IG@4i@QqS5Y=!3j05jLro~%w`9}5(7brkx_}kpaei`3Y1tDzczv-2Df~zE|+C6 z95J7PkrS(igCu78m*K#OjXjNFh%^AvQMEET6X*=URBglZo2}o@fS$9-4Qup@sgUfi zBQ+h*pBOZbVb}<4`Ty*_d%Rs$eeV7JjWO44U$Xa32q7UzLV_YtS_vWw3RLTjHFJ=J>cd)gkcYPC{(s@7I(t5r~n^;QI}qF_a7m5UcZg%ES>1 zbB^(Q{}^MgHP_l}=YFHE=kr;6%{k_6tjnHj&N05@dD4)pw6tWE0t~XL)snVHYpW$~ zfBz-0tZ9^ z=USuENR7~h(R7x>BwW2O%hGg ztbzwy3hP;`xI-E5Jy1d4BQ!*PUPP`YIQXpG{U%4B#}6KP zh$PtQcjUSM2-Reufd+bvNmUyn@*YA=#~VcCuaA-#gFWd5z#V&tzIY`8nrIM4FCSKk z$Wq|<;_RR94>SSr=eKA-uK$-s9|hh(7zXwh;C~(2>g<)CN&t~=S!jg_Eaji;KOAmo zBI>OKXyReu?~cIn2Rcxx_;xIKyyM-lZq4&l{XdF?m{9+nzeUq_-FdWMJy1_ zu>n{^QvLI8P~vnjT`e%Zb$7teL2dzmBWd!@ZP#A19pL_TC$2-yD-kZE&LmAtINn>Ob|q_aX?F-ta#O(Ol(NuE2*FS@vfA z=(>5X8qkjRxG_HZffUau?2p|*6A(a|Q-K!By}-%A^qmtB^KWw5^?$@?p8MyVBgK6j z_Qv*s1{!Gp6@ljG5&n1oo2q^{mY+xfCw@_g7y77(JYV3S{w-!=!LENt*n#Xs9)^NciCPrsS9GWkAIDss95ugI1 zE;vr)&;&llbp(?LH6AbFl_(0K@wyn>F z_X$qau~o4js4}6$6?CdOERD%YS-t|TRUW6)%_(WLw#w2HS}h%?jdWUImRX=R9jsV_ z14T_+SzT&#yC|_p)1ihmr~oP0RI9EOV2QR11vuXjUrhvt$eJxF`wUB_MJI|`pzK@X zd@5vB0!Sg^yb)goAvjXZ_*AOasnCHb@MRL;ai;L3;R{s;Q7`xk4WCJF##PBL0is(4 zbO4Fs)j@GK^Tro{-32Hmp#!GXYl$Acv^qdVf;alX1UW-v7p(LC=|brX&_okmEGUL=+$RP=(#S8(Iu%@gY$m2JxDQn$B?kdqRC4~^ffw5Yy&jE(S7;PmZ z3Ul~|QD^46OU$r?#8wn41z=(uWm|1KOtgWCiq&$D!^Bn^ROiKVOz4u)SuMW7qYp3B ze7N`SqB(;3&VOxa0uD`7$7>1D#67@es`^6!5xI}xaIrSduOZ~#{wDD6s`}7@9(Z`q ztL&5Z7M9poP-3)?o5Y?ViGF|tgkGb5?hzYTb*B4)5nEbbnC{H?!Vu8ilbFK~08<6% zApxf7EL#d}rNc#RPgN{S2%z03ZNKL_t(%n8HhOg(cQ#Z_nx$<^vWGT`hXx3Z|ojMIXQd zLR846W>YFatrdvB8ZebMWujEk6~NC3m@Tb_n6xA|vqB2fX;WJ1c1g3Eg!i>VmNo>+ z3}r2W8CrxEhTH?WMjh`eqGlM6!{g_B7ngy|8`Mj8bOsQAXc9oRBpIOUo(b}@wh5@} z`3nCg`1=4s3>Xzv4Uk5glaP1`WfU#mAba|sK8->T)DxX1Oujro5o+Q>?5wA}mTKPK3YxAlf?*YUL3pS9;z z`QK~5zy5%KTaQxJ;-j^v6_12ACyTGe`*-H^-yc3%HrEzE=W*RO_D4v%w(Hz#{2;1h zpn(S37kz{P#hn3MLAdujY9%7iApBmwYB%dVjo?TD@RzE(`Eb;&NACf~fFCmGnBFg` zYF$L$OlYxrqlo-NK5F_X);kFiBiHv^C?XX?tjH6AU4-w+VO6xs&OzKas_G#A?J=k@ zC^KCDsi3+^TWp!YX9JCYWCBGbqtdPq^i0)4*@vf96SFMf7h8*Z7M> z^xFH+T>YV%F;edgRwx%nAqOQ@&oQSMmY#Of0-!{%=7ADj5f25ex&6W0f!jA;xcY6` zv^*d6uN34t#0HWji5dIyDJ#bQdh-rGv}s4)e!mj*6DT6eWMYcs&o1b3xBMeW)y_4=v`c zD<=5X&N;rgeU@+Un!|PWHWnXwyu1*iJFXFt=TdA4npic=MK@g6FPcNI{>>Y9_lEas z9!T-ZuMgwWr!EXq^i>(*@r25I0uYpdyq8OFcq+drcjCfyzXDnZ8fc&+r{f9k68GfL zL{#3W+BGCyRj;!mZ&vv01a8aV6TN56eq`~@TagPWoNVIHU+y;Xa4g<7iYx_oG?694 z$oLRUPa`%(#3GU*qDaGInl`vhm{xFd5J9X7u!JNLPzc)u_`xE1L`O*xmjeJr6gc|?bV2oD6r$KL^q zrWr;oDh^2vrUI@RAQfqr13+RNUW3oHNQTU2O06V1HU?T(VOEq!VLK{I7F)k%2v+QZ z$yqN;hK)Wv3`}ig6|k|sN~VG1Mn)7ibKlHy(s7yyS~9XkVLRKBZNSMa$sQCo!srvv z*6I2d0T`~#DqZm%dj=?|4{Ix%m0?%IjpqPGixO1@=#KH2A+aNxxuzs`RP!hg=UWk? zfMT2nZHPhy480%)K-r5xncS5khbf#-CAFeeT66&w4xj^70Bx|M@GsZ_EFkvzgms`gkNK9Gh$VmFY5>m37(1?)4j<&l* z&5pI*C14wMTh($hq4gcXZDI=O2TVYN={7I{-LV|yJ}wi}1(%767ERTP(Hy@F&;)Ss zqdG+7-+`w97pm&bh4P;QL#ldW&-#Bx7!mSZRsC1?QN^f^VOTyB`m^_2dk0Irr0{pX z_9l9x2udszx6unqUJI!LSvPen+g7@yHQ95;s}mc{vP&PzWRh+@(9baC9@Hf%P& z*LTx9GcRLFaCtCU$9-a7Ldy0=`97zB{CN8-m)Q2nDA(dr$IPS`y67z|x?1>Be|wcP>0oc|I)<&&LNvE1i!uz~=8Pl#IGg(tO2I|?Uz+zYo^|UEdOwh_|(i(0^ znpGtmDodk*nE_mNLel26@zpWOTC;}Q5?sp}^@+@thQ(WFyz!=Cozb*pe2nTKON^GV zEv*P;Z!}d4Si~9)e5eJif(5mTDYb$ZdmKWrJnZ~jS(Eyg`_nX zqdROTrUSxuB8BJ<7h*cR^OVGebhTI}IJ}L^vk=iyvL0_eE{jnesi&1GmBf>kJc(0= zN}hVA%%#e3#ZyU@>81{%Iu1;6l+W7;BT#qeHZe!A1I$5+JAt3{0$qVh{*Xs{yIJpM_V22V|<11%ePBa zpSFk9kBBB-_PHH9>~K4i`2Cwc{k1oL>$A@}l63-*%WeoGv)Tomp;uk>lOtE7fd(4r zu_h5Y9r!*0mVeIv+`}C%iO6CCO8pDf&TpcKTnId$Fv>RX9J&*D`r+;v7Lkj9uMpfW zo~){O@6UeTcAktnc)d}6?kzw4Ws2!2N<=;dyn>L6eg4r3!N!=5)xeCZKGL)7y@bxo zXA{1o3cONPuR6?iw7|Cs9hsk2)mI+Q;}3N3wBfAP|Bq_h5pFZ>xLaip&Jta_A%YU> z?6=nb=)Q;dxWztd{aLHd6qRc!#78{TO1He?-Yv@>Ze;*lNUF>B;3(0ny#^)rM)&^O z3CAZUdASO|Q>^E$(+%FZaVw9eU8kJRxT4YH|CtqMy@)lxA&jr4k34WI=%+}BKcm-P zFw<|Pz10KfoV3hkJfjFw0Fp;}eD2X1Ha6!QLu}I`mH}X?O@k)pn(QDG>UHK_X0Pn>TeXvmjaIfpHtOK z3gxm2Di4OH_6I$jxwkPLqmM^ka5bkrQs+(ygu-1veK}8FMR!ccu?@sDkzFOsL=BM^ zGHWrTDKZyf326jJ2xBm<2sTKHNz2%*iLF#HSqm#=j40NnSd(BA!8pYlLUe~HR=|3T zB@54@VLcy)-B|&PV7y|*2UiK}G2UQBgVRJYrbA*(hZl^AJ`oy*IEoiK-Vwy1jj_Gm z$1)Rv3GYJ(b$H|3ZWADQ2_OY(@J8_n>Oyd~$KWNb=`{cr-k1=}p^7(xi}4-KNQ~hi z#BUgINOxpM*^s3go-@V!3};JWeT{J)%_csn;7T#NqmiNBJiT8EU(bRY?i*BtLT|6!7Pc*t^3#8F?;vt|pl@Er6=`Byx08Rvjo3PW!Z|Y7f zEZEkJ(H+@#*$9j#XDcT|4p2ad?|_vwT2r!oMd;PrU4#cLCIA#=$p;a4$9OaZMwuVw z(G(b_Uz`UFQT8p#dLlg_L~{U?eHyn*B@Z7c$7Oj;M8{R}0hX{PS-{FME|)}8^mr@gnW}P0tVv+=nT#R2o;5OrEhbG|AfD;c8 z>@i1*cBmrq6W|zCUEZ_4CES2{V2!Ho6A65;?sBvFjdXuC!fZgrLtTp_~TlD7BYLQW4k_%N^B^)KI(ruTEZUX3mgzp*Ff z!MBV0Y`-r6hD&zD^@6*`;*w|=T(JODk$+j2maJ}Fa*RM|#n{;j@Bef<-u`R=X0udS z4E0^hb$cT*Oh7Yh35+w{6vHBzYZ_CUSfcd?CUY&><;JCz%o>J|VOML`Xn9mz>dl<9 zqUB-n)*GLCqcv|dD;aMRqb4z}%o{CXHBGG=YcxU=sj&f?5NnhirZ5IE#;Kl?sr)&@ z4kLUv(d>IM9?g1h3|6f=ZxJzAF?b9j0iy64r$quh(Kh{B0GuEos_mJ*2PbHQ6F5}7 zH{ubK;Z?B`pa{gpT#wy@6Jo=qS6&8=k~mtJxpZo!Fa zQ<)xs69-Eo@;JgMx;FwpB{WhWzne``;4V5a#TQj|ayRSm>G=BuPRJ!U97mZu(Y&z} zMtyzu#tl~tFUi_ALJs^>;s~jMj*wQpoC^BJv2GyY`*H z@2l!R9)WsX3A~AL-TMqxJ)n-h4ecbvUL2mZK&61jLM~8z$ zu8mJxJ?;$u09?Ey^K8u=w`Rk9L?6ea6Q=}FVt5(Y1^dw*a3`wY#>maI%HPpzpLOsf zZban%bthhc@+y!Q0Yj6mjMqP~l^@L(n&^)?6^{GWQ19Aes4anVmtXF^ApeNBpVrSl z`;fT>K6uuu<<83mDqH}ZukeK1W*U59+YC4Cm}Az>Z;G{Ia4XM&lb!`b$3kr!s^f~v zd)YMfCx@#oLSFMPqcqA-NB#MP`k%?ZI4D2*^9?LL<$Q*Z-Lg=e$Up-Pbo59>77?z0 z?oicrh4M0?xAWVodO@LF6fp1|;Atnq&;v^QM7&T;2V0Tb7XT-cS;S5tW)WiMkexd* zW*9LoB(a#WG=LNJ24^QEV&a!aFWWMCh};G085zQwh&`Dg3m+*Cd42i|FJ;3sb3B7S@g-lE= z*Qu#Za$3G1DhDV!TFZe06wt~lGVJDr@$oocms$iUAh=NE00nd)3V_Tdl0y^#nNOrr zZ7l#&gfiz_l7kd^v1-o^KS_>%b8J^}sga&zH%=pku=KMG+Fz2dkagzuIMgN3-fs#N78Js-yO*T)x8BKfZ#H*Ffg&d zE)($BhbG|AM0Mofo!$%RI?)2IC{=YL@@3%lz*&TbqeHGxaeMy{{v3pWxCoFw!z9$ zqQhw>+kjS<$!HQz*wa}mTeCF8anz<|qBcQeq$QHJ1e&DQ2pP;#CC#=;=0?T2mJG+^ z%n|$_^C5Iqz`Il&Uc6UnV$krzCD4+RPee&VCWW!8J_L#-K8nc@zEDk$l1gphA6&25Ea&fO_!? z-EkqN17GBqhWU2JDtqL-Qo^aQ48|+IC-TJjaH%-Z5tFL^B03@gd_Yw{E+XT=>4Z~x z{y2s3RVe{aijP+lP6t=d+wmcgT=F?fY53|QGy&@W_CG&bEkF~1eqaDi9CVD-XrO`iN2+?Qh&)QTWbPA=chu{Pz=MQg zEBEZL%fmrXp2fUPRljv0JMzj!?HS>ybpbilijf^J0GfLo3P zuplB;;6H#%fbR^TiN}s^KkKa0xPSCnh`fL^SN(UC<+2y?8%BA+3*SKHyCmkOHAg7& zZ}ks1t_6NNVa-#foG*+Ex|f*j5F93sJsnn_11CJyQ(f|N#C+#qI7;lbRCNv91l+X# zoReQCE%(A%?=Sz&@u8!;+mtt z1tNTFUkAVKkM!^V`!sMveDpX{=y_nD0lu{04vu-kNvJ-=%$A*U*;l`c@FiNc>krh` zW1xWsIy6$%T_UmzI738Msp`g9-imPPnZ@h7!U?nt$d=F*vRhZAo3|pP(@2NP=qy_W z+&&SO-7|+A+lcT$3o$i>7R*$U(G<*Z@Jb$PAWe%@4GdMFrHG_RS_PU&xfGxa%AqYi zOED%v5Cv4Ae}gm9GYmCX@n&_VkEdupkZE2 zfGC2IM0}mv$*IoY7S*nn``|tSY9t1BhqiZ(?M)gTCrpGW!p0udgdGQ(0u>+pti=aE zYVoLmW*$taKi-Gq_;4&u45}gCMAe}-47pUz5K2fYVJKxukY*E;R8VOl)e=&%VaTJ# zD*K^1oQIklVR{5`Fw;`m*@BgbYSYVB3{L?4aox!o!$uzlP5`o1kZptWMiaedVvR&BI(3tr7B2~wR6=}5xCuR#gx8mtlKL3Q(dYs#z?w?1F*H`o%u$3S<^VAxN)kYcV*CaWBRDLH z&Ebgp9s95qi4uB3Y(V$w0!Fe)JY=GJZ)I{WXRqf3_+!UWzafrc* ze$EnbXkdxrvU0O?0@)oXv5EpD(F|@9d00e#$G9@ONE88ygz&GpJyo%Qt#_g{a(uu7 zyRr_cHRHVWYvs&gh%sQM07G;^5R1l`aZV-*07E~}VvZ0>1~6Ti9&^48C5!>H-b*9R zcKd}aE^nk6W5(#L_hOyz{4-UHTMSX`N`&q&{4_9Zjn09TXag7k!mbWpmm6WQQiH6BfZ#36coHG}BC)WCC-Pr(l`Ogba3& z0xfo=EvaUyK#OUrq%M`D>`YQEDH48+W|@Tqs^ymKs;5$!X-Sr-1lYky-G-BRxt@s& zl&&Z$O%+ksFsg~*on%@XpDUGqeI#pMm(aN|Ri`Gyiv>Xp*85ul>oP2;;GFcM9|A%U zU=vjluLxoZznIbi9z?Y(TP-GZ_=RrI_vW@;^7u~Tg`FxY7*Q2(72|Qv3zqJ>Oa7Tg z`%MuI_011jIJlG)BN{GI6UFzq1lyA04sd|R(yd3u56OQ4-3ok&01cz6JAhl_1Aquq zJc%&6C4YYWVXb9(_|H&&y;$@++i%?bl-c`=MnfBCv&I#NwO#}DRXuUvkTlUeC-R=k z32ZDK^IJz0oIua+DY)&3RAZol2Kq0d1MTQPl2X-&*+YZsVXDXNgtmzTm+)crJZyyL zh;scw+2>Yend;+!(3a0&^AE%0w!h7QZvgL7)xN2!hgv89$NEtM ztaT21lYO$|0n3gD&Hz3N|L}Yf{!mp9>pjBif8VeL_?(Db5B$Es8eMqoQ%A136nI^H z{6s|lP*o4>Z;pQI*|WfnB7BoeuYW1xPC{k%UTiuB`ZAQ4QJUK-mtOy;WOE`m_4dS$oE!?s zPu>sDA}h+UrH(9(9T|%W{R5^IfQZ@PTP$@&tU-)JOciO>FHHeP@gb#5Y#)j&KR%Z#Yglac5p@e5cbeb?Bo&%35 z0u!d=*(}jL0u~r6F2Q9YhbY2W%MjyXhz=AOeC#n+iNh0ByWt5m?kiRTK}As)!3zn? z^G0}ef*Oa~65eGP4_Y?(3=9UJr5G!ybEplq*HkfLQE^CWFwUW>i1&yuBff>W45@fz z&Z!83$wCr|Lv(5a#%BZNzO~_HS=H#K^81Ip1f9b_la(R zVkM2%WEVgIFdBQos-@#JxKM1Da)PFb)z)i7`h z0{Tn9%Tz;*jEMXN@CU#jsOn$#Z1ZVC9{MX)_0#)!ygf#BC}ND6;m-bwFu*7s&GvDZ z80ndxt*I=ueC{AcbmST;KngiBK2n$-w!z_nnNC?h4V%t>dZCLPw8-a2tkpdM7CY%5 zBhoJ-WNM;wGMmn}35+wFjYyizD2y|gWztF#tq*4cV>Gr8Nn8B3*xyGOt7-POa@M>pUK$z&t1-I6iRr|5fK^6QVf4;$u7q#(=Xb zCeW^Uiv)8tuOgrZqv3}%u%&{D{t>S5{SwhUe~rv2crez7E3%NQ7A}v(qpI;T&qt=! zWAJF07H}B#IPnClFbCosooR$ZoJXNNkLpOACoMV35~DiG4(~!VM;_HttvX!h@rj=o z)q!!8Ql*|LX~|PcmGX!(Hsjkd9n~cY54ZH%mmHP3&A$v135G7Jy5H8XdmGgum)>v* z!Zj4GC|0+&tpC>s{&cM={EizV&tCn54d2+``V4e%we+R`^x&h(=;QMFcW(LYPyYDE zPoHt5>LZt3e?3TNM6&W){mexlJyP`&t*s^5{>({Txxp}w2yMQ;T>cdQym5B^fU`gw=N{dk~(2HHD`$gcwbP8cHD0;;O2BJxr~Tp)x#zFQ3(qwoU4dH4rj zc}l*YJ;ija1CGCn(;sbehX5knb>GFD-5b-fWEhblWM&#;=P*)5OaoIN#n=YMSd18q zXNgG&G#iUKFDPb!aCQCy6hD)&~!6t%fc@oK^IV{!}VmgEn%Yo}mw<9{@I?+|a zdXH&GcjQhJ9XARgcbQNmwycW@phOUDNZZ6QUl*8;Y)(^im#`rclb&rwAj}ie!4Nzj_dGs(QUJ$Cl=#6c353rHOg?J z8&|=`jRBmv4>)miMe7q)-7ppU2SZ%Pxq3S}JOPuFlfvzxH*u;F0E)Yz-FZFL*d%Z& z0iejWhX@aVzA+woN%vg93xt*kC%Kx;RV9?%=>(G(b_80`U&M|lhn50SY} z%tx-=b)vX#TeZ%*u6J3FBsEVH^{)ssGG_2MWhME$-ECtd{6N7mqNp5>m@7=T<2Gzr znT1*A3d`blUC|rR8@~a)5gaf-hNA#W^h9w$(On|MaRAgR6UyWyn;-xaJ&_#H?JxnV zKF~e@03ZNKL_t&s9?JoTCYl3|E@%P{jpM{W66{7_2>hprJXcl!gFt})0q|}SnFYQ; zAk!`ZemicvzR&*lTYGkw=#NVjL5T}k7?#*w1jlpYa}G;vg!!Pvbhn#CF>)h^BocyE zhwX8a$Rjp(W@#IcD8dm-;`3tXWyX7%qXS1w5TY`m14eY5AyUR%HyAMziHBLIlEV+S z5BN|A#CJNgZQ*vW?o|$@S7IXzqY-LG)W+l0<1|1c)HIVK=wbmdk;jNcz#@k$78|2G39c16SW#}Y+MjLH4a=}~I_I3=YBFSp zwd67>ImB2iP-b{2W9v{=$TBG>Ri?94#AQ;c8qBUtZ1YjmWQa;-SWJRAmx%X?_);pZ zRK?lUl+3WWOpP7R#9^dq44OCr5fv{9B9qCYw>dEvx8Ea4URU$!?}){v>H?H2Ch(sU z0S8$iej;$Df*Jt{24MiWz^Iyz6PW2_Y{VE13EPItw=Oo&2jedVqZpsFvf(+~+jFi5 zv7I;$@qq~m&;^$0Goe0SNLmH@$8|Wnz(HG(p(G`x(FB)5*+R=IuA)?$N~5Y&2Lm1+ z3sTkDJ+F1(l9yfoM67(A!c|40e)5_JKd{ntUsHT?08JcSGUyG!YxDWLtB*VFp3_es zIrXl)4!`C0g*PXxkn_3={bP2t_&@{gtL{1d^zw+A9)8@9ADr6Lx*N_~GiFA8bJa}` zH1@RaKm#2Odh>;H%#}Ckqer?P0}V9L;n#+<)|{uJp9hZ3%j}{t7CrO144?HhDy!Gh zFB&u5Jjv`2zRRwgzDBw!81SgFT10NT|ICvvUvtNXPaW#Ii^%bWL04zxWtB>WSG?jC zy!gd0=E4gvq+Bk~+ivUDtz38AbzF7TRorybO?mMm;O|7_R|o*Y0opt6vF;V%V+7!% zt&1+Yh)XZMl#4F9h>61Bm|XRGoo{^O8+`6_pW~Wqt|7}Z2+dEgC)m=zSoP4K&qd_* zzy~O_3!ibu8NB+{ujU0Wcmb(Y zI}dr?Fa7HIi2Y~an7nMsNQsNjJcbLOIL;}{hx?|%Zrs-3=ATaSr8~Cqi*4;oyft9H zEth@u|JJLYb66rc2O4OgJxf)8BqA>a{yxmM8^5jvUI9Fp7_D1q6-zC=eNX$oc`I@O zg~708kY<=Pz?Pnvj>W*vR&b0M2WCfMB!#(Q7$!8-wOnY4mJ%WkkpxLoOeH}wk6@9K zN1P%hi?|-Q3Fk4!VQhl<6yt1glgMK^6758JSdUSIF&bhwypItbKDb$Ebf+*xhlvPH zsA5c9ZWL58V!(xUAzxqnn>ptog$hIy35}uHs*0Lm4lPE&YfR$^4ia8Moe>2uF$~*a za3BUHyiOGl*f6wF!ca(6P)CU4aM9U9e3;H%Cyc?91t$;j1m6pbrXEQWgcQ?C&o^0mDPTLB+WsI6F`waUbTE)?M?p(#5}n%bJqA&MsT@o`9M+REwzP;{e! z08%(xEjUsbg?blE0g$=T0Bh8n;gbd+{N`r9B~8#_hRCWd!4wA@59Ns=0J!K{(LpY{ zl_@JVk4IKTRUWFOrmtODj;l)hcq8%ZryFGT4HFysa|a2?T_hYCNvWb$Mhi|75PA*k zh3JjkQ3AR_iQp=+6X=cMfZ!~V62eJ(VF~DUmw*6F1c!+#5AW7t0*b&yMPYe+y#tBm zfZa!PEL?o_LlbZa947!oJLQ35-g#AZGp{x2Am#km-gjYU5*oPfk${p zShg?j61$7x*cVp`C^$>33iHWcI7;lTn}o@{^gNGuuyK%A3ytVCSi3r5Vw z(fj@4HlQ1bsK@EziK|iA-%w$leNn!@Il!pOT%p`caEutD_msAK)r@Ff7d4{!_ElrF z;k{Ii(SG}@8EOAxXkogmz7cqsp&PKswUB#-U%<6uGQun)*6JqbWXM{bbHknY-3`e! z#1Aq2^fhZ$X}YSkT==0YFB;bensX+rmIYu}Ru)$&Nz2wv+Nv2EHGJ7hmSP&!D$bOR z%hc438b@k(s!!a-&?hO-5GC(EIO-Z-$;24IYVI%*=UrYd(OE*V zwAWSZy$R)kX*DXw;N!fgfRQ*a7>%5&2>4(!rYgRe)sZ`jU^HB&i3a$=DLxvGIq@Nq zV*$sB=old?9xD!yL%he^;6RZ(OK6-HoD-Y1T_zAmCXN!}**cFm9+Buak$EcOs2fib zohMxCDO-=T9#`^Inm&RPe&9Iq%b`6vPRM1~PXOPC0&EP8PyOPre*Cn#dkdp$^ikE) zscY}J?}*sb79}Dt0sbh?{)wu7`4AlA9l$bRPF3G@u=jtkBrpHkGf^MHnD724j$3{P z-`)D5=bd!h#=~x*F0Z)$>3Atxe?P2OUv$FZuE#(F9SMcJ_w6?!{?0YGZ+v}T{tE+BZ+Qzp{_&5C#a{$o ztlDps!+}dg%D~rv3-hvb&N+uGue_3T&pmhH4SV#npZ$!tzy0le`O96mOY4EB9!hvZ zMBWYjfBF0gC!D~$-~DbbyX-QISzr)MkG5~$&U@bT9zOWN50a+so{m}I*{b@zgI?(< zdHD^`L-{=MJ6|ms{>OR8@rtJ%$546i>YjP!3%70MZ*Q7p$6TAQQQ!@F^+g{%Bo!ZM zpn>*F@qBx#s{XK0Rsr4!Tn4O`(A0lx0`Fu1f5osW17}+(ANi0TE#9EAGh_RT4!I&ndRmGYXrWRs4Oa@j2 zlSStUlVByoI8P!aObKl6HsQf03%E^)lHf5aB!uCHq5VC&O(!YeowFB00`9e4vyJWYnc{thv*5IhOEO$D!TS_f z5}fz=QWd9l{9GCDJziU=b9m?Ql`4KH!|yDOYML28JYu|`6?GM(Zd!CnHMmZ=s?n9h ziEae4Es3suN=5Gh?!LPNP872kH?0`eFgzQ$xl=wlJt?=dj?vM_>-6-!QtX3-jspe2 zam~%Kk7&LF1?=910${Y2_jN8MhbW3p6tI|9HY*cAYe6>(=r~d|1V-s~r2yu^6wq;~ z=uGckMK_A!UVLI0T$;TMrITu)@)=vPZ=z?2<1F*zHg>0uYedmOBG-H;2?%ZybVY9f z?CJp}h!*ran6*P%PKFga!_51^61lrXtqYdele+}u-UN9h$No7?z`=K!=)dG>geKt7 zI8LCdea>8g4%T?JKy0vuNPj zki;S@Is-5h-qU;?>%2}!*NRf5Cf*vYGcDu5+|HUQlSUY01dAhcPH2q)O^mBb%{Hl# zFiV9UE|au5CuNt3$&6&aBqOdaPDYse!O?m zGT~h=sgp&`#=Z4g?enRZmjI0t*{3FC_A6PEkYrwzXzc}(MYh7K&+WbpqQ>QMadCO) zZ@9d1)<-u98!BNSOjwG>6F}fsjZtGv2cFP4o}lyTck{6-iXjB2sYL6Dg2X88b96jz z=YXLCUZcB&Xgrc8+7d{}fZ#xJNZMrv`X!ZIafN}iuIhm%c3TdanGMT28$3JN(Q3Hb%Yq8FH#|JaK1}fBEQb zhc7;0puN+^vsRx1e3saOoJ=g?xHtW8Dr=swPx}#LS@avvV`$wuZ2rI%H1EGRl#9H7 z{koIxTYLM4>kf9^V?4*_iO@u)QsHm@=5Kh_t6sJH4g2WX&we)NpMO5DeeG-c|?y{b+5|-gtfpI zMdX>PdeE&XMdTF}pow$OJ(tga{_`wbwrn?B&DY|^i@Ea3D|z7yU&xDI^dcU4t~;P`0v#Q8fc)tis!)}_LMb&_X6(~5!suT*o6by7tk_b4t6w=B?&S< z4l~nWQe?!!T!u(3fE7|ks(`70C?Y9B8A+R%N(IRj!6TVqj77v@9GFCd+e88)97F!gy4eVhN!tS)0sqb;{himnvU$C)Bm!J#6tXfIfi zD+er!(1Pn)2GqeCQR(UiRGRfn^G?Kk`)Yd_d9HpyM6Ql|1Q;^9Z+~(piTRL3bd#{H z4kW<@^&L=V2eZMEo^qwBU@6lCnhU@Zjdm1AaF>{5(`3jM*}c02kHkN-PNh)*B=Q)Idb0yA4AF6lkRB)^2O_A|Xn7T=w_%8; zSIMD=;xt`Gh@NIerA;-&m5l8iYj0X!s&s=9{gl_aVnln_tr*cxW>E!z;ZkRx6(ib; zRqqE~KsXVn^{^8!-Ec$>Sd0>Y3g2Zh1Vp%Edwj9Aa_1P{8l9VQvS=(o71lYi&Pm;s zrDlz`%E2|F3^-fUhTAD)0JSR3UAv_2MQB0UR zF12b(ZB`*8029GuE6Cvh(}~qkFMv4p!Bv9zy^B0UaEs6w%K?x{`x6#Xdh^wKMnkkO zmP4#ZEa{2O2slUNHsU2*OjMJQ@D}Frpb^0Eg?)&b7tfIZnRkME!6WTct4Wl+t<@w7 z4oqqHfJIW%&bM!%UuxZV_B%l@Di)3Txqo=~=BqF6UQw=JbH|2jIC|vhe2IUl9Z~cX z7c`E2*=K*URfeC$)C1s}yzA$U7hNt=J`@e1d(cJQvwFi}KK?)h9TMIDq*YJDm=A)k zOA=vD%leBmPF#{la{T;PSFKJGdA-5B=%oAZYXWRox8`|@{Jmgaqxg@^+W_}K2*2sI z>Ui>rZx=8B_Q1N6{%ZB@8-6@*oq+~AN@N79N~%y&`0FEGpU1l1_*7YyB-|+Q;cKte zF97`Bg)%an^6`8f75?S@-_g$$xBK0*q%>CLW5je`6>c@~8ZTTbA}>0e4MT5wx;)+( zzNyN4^5eeY99dRQ_^ZNexcdFy(XI~hE6$RknJOO@D8+TYqlULF8sa>{$j*U|65Vt9 z=_8ejUPo{Zr*!OcR=ndcNG6u-Y10LjEIx+g|M>lEy7C>=@46F0KgLz}uUorr&F$+C zYOF5s31U1)wOZwCU;7&8pMU;-@2pa(@QF`+g5!=mj`zOzy?OE5MdVIZz4pMX+mVR; zzrgS2^Y44#`*`bH-+Dm%y!`UZS+QaT7himF9^G*sAx7hM2ejiJiO89Rco6_DzW8FU zx#pU_aVUGM^Ugbu?|tukJpJiUXVa!l5c-q8BqHai9z5VmUjEfZSosPuMfY(_s(k#_ zPvDr5eS=ksI(D?o-@WPy{QgzDABOaBylq&_DwnRu!(cuDAlp z`-zHf6Bp3!29QhIe_&gT>45n$9kX>r!oYcIbYePMim4{hN)Y3aavA0_OhsahM`)1_ z0}E}KcQJk=@rd^rF-W3_H%MU!U|@E))SfnYF`d?M@8jDg_#B`J_7kDCT{X1K8^L?UNN6n&!P+L&K_zwr*Z@hy z$POVu5*`!kts&f75xlq%=}}UAW{^aX%wep>tB>!mMM^F}AtgbYicyOu4oMZ`LjA-G zqGiOl5T7A{&SeNAsA(XkwKK+bOsH>qc@)E1&>xLESr+3u7*3S6z-Bo0ZeRnj4%V$0 z)!Qeh<=)9@dHjk|U9n%;}^_co07-^$jl_sGHk1;7-W*-ke= zf%dvk~FFzN5r+gdOH0C@}%d439|N1?XZFpa+zgt*O|!k2)X? z6-#%dM(%Q83yu$|sw9Oyw)@>H1GuQovZV-Wp#AtpZDiz8x!)%SKm3)iN@$_9HNpzOf+A7qee0M(HM;pF_GCJ<~4~){M5uNQAjk2LnKBS z1X08>Hc_FOg~q1osk*Ap*?X_w_s3fMoPADJbvIqrfKbnM_0{L>VeR4U+I#J_?)5x` zyi_QI8}*&>Ryp~8YkFtFyF3D~T@V5}Jh6US?W44U_qD(iP+|wes}5+ zL{J25Yh?_&Pyk5gsw$jhV1$rGCka_JD~rZqhVy|?T1<3v)}?4eT6d;h(^N*IZ%LWMPrWY+VR0qBTn<)DEH8}+#EGp`J?`UGOxLlUirlrQyU4C zrrvPFt?yVu9V>;MsqyYnBQyIOY7KJxNiQX`b^A5DcrLU{3;vmHcb-TYpICQq-`qH` z;XetS`Ec!nUUlUmsOtg(P?Bd~dAPPeuX*h+-SW&Mj&e>{f{g;>57?!12Enj>!vgmW0kFQ3=E9!@rY|fwp%gE#EjkYLffI{|_#G3ks=fycNpwd55;|J%R)+gU*qbzN}51>Ao7?R@&vpROi-K+@;UrcG#l$da@a z_|xk9YhLr3Swj<*UiiWn^1k=Ik2k;h&DEsWOZuppeRoba5Oo=8Sknn7oWMW)!#~Ul zny9pL+W0d2}%VP=O{Ka!u4RF@{62rCVNIH--paSb`!H-6y07T`0DCI}2%EitCVi zz=TuJfx?I@RPclpVS_YJE{>VB0M5mz4y1SVn_w{>BT2u%<-;DosgAy>E ztHf|?sl{H|erE}q_i(@fECG9pcTRPd*ir^%%j>QZ;EN?)SBX1|TubRiYCwV|64+3=NdSzO zK?{M!W$1zu8ik2Y=_(#!GMIecgCtzdL88knm}xSYhKGl{9D{aBc?Z>t1-_zeo8}f#!;bfXLxpapq zI-nt09!y0C8bhh$xec_yRpdk;kwHHkQ3jf>VQr@Nur(!HP+OHUffRkP#jq`4vg=aO z1t%tbH#df*EIp<3nArqlsAsGR< zCOiC$2mHc!82Dv*`z1}=*$L+43OUQ1+9m}nl;fhC1fF0)4pexDm8DFcA~{WTL5k|1 zjFh{f?mVl4I!c0^Rj7qgK@{E~sGHW|oI%;MUNegjMRj#a(fq4>&vjk5h(13GlY-H^ zE@M1L%}K%xmkcgCB*HPegh6tdkWc?RqdRz_Al^!=JroT}2vQzOVWprDZZ|LWJ{aY$ zR89?TK)aQ5!tbGDZl67Xv8b~j@39J)hvGo z9EAFhVg2(oBKUtX9x!nrfOmZN!fWii>(}YaPF(Q&C+TzZksXh`Ha>0Dh?Rcp001BW zNklZ+RDYzx@v&lmIW?c;bqaSAO@7ug|t@Ndhjd zzQ6XhujQ<>&YEqp_44`XM?cC9H{8HocijcCsqW3dg>$rtcaWk8k2~%-KJt-|%u%sX zXP}MGn8JUZs0a&wU4HsT`VIBN< zm!!WpoBe%Hue$OOYOXhb@}d>2JZLcdci**m*mLojM{(9ieiY3|v6t&NzxXWsrx$#4 z&NecydClt~OOgZL1iX#G-avQ*#P$^rf9l{VEqKEO?6H09+fPPofSb3XW^2Gzq4s%O z8yzr$mMrMSbl@X2F>c5^B#(w1662(4H^tyV9tW0;;_^~eGUJ7GbF?JQz0@Z!Y~ zCeYT-gDI|KIqZb{CxaMrb_cP)uo!D=)#yO{!_^6ic*Anz=FO^SD<88w0Ti1z>vXPW z!$2qYLjfq@K{mxw_sWH$4pBgg^8n*e7;Zhu3ZQbMnC$GVffR#|6m6;=wJuCibEc^F zvm5mRQ=kfnU`6$LG0<#BFr`y&(crR`W`ZuFw#+!ESwR&Ei0Dqw>id=82!I&@i3fo} zNFuYCST@yBq6bRUT_u2f@9nxuz*44jmVn*6OH3EX0fWHAOzsk}J75A5H1RkCCMxX@ z$BC6h3ix3^5yLeffjTU4I@8B-RItRIHBh2bwudN=L0F=4mZ(Q?RAsp$!VInqI)JJ1 z8;z0C?tI_LSq$t7L6w_?t3_^1PR0y_iD0UtHtLXsGn0ae;m9ggfW(LgiWr|U1hi$U z+#)(=QfMjziaY`l5W9n2Dq}(Hh*l02ClH^sH3y5rB5*ONymE}_F4&val>=X<_wwkl zlTIj*C*ulF9KfHJCx?blfID)SN695O0U(WL>CYn0Tl4O>6+F=%mknVget`+C?c(y2S?MDJf_qKZ^nf zG(%94I~#2^*d96}OQ&nHqtVdRWB^}GIBOR2F0d;E4f_!Vl`1_NQ6@skjt>6c7oYfn zwzB6{=jaxH!2ek@`QTrMV6Kx%p(tEtnF0;GnF5}?;}jHu2ya1!LlB%t4mno@r&xzf zq^Ok+m&r$03Y93r6^agJ&O+aHPy(oQn2XaZ&QvZ1esoR22vq<`X{uluNKqSos%mD@ zi!3@_n0j#@L~pRj>&CjEcZLhKohlQMQ+D@3E`b#m=>4_Sw`Y$LI^w*@)kB@)MUqwo34geJMXk zH^_MR#;315YGsA=&ud57yRh`U$>vu z=btaRu~Ybz7cZ=)tv`i7B96G8Nq+=9(b7|-*Zs(bAV?8jEs!%p7*?G z4vOqoRqm@_{pxDcdP(n_ZA_k|#nhrRF1+wU8jaaI9t`TDi!S1GpZgqn96<3al1?(S zo93YCKdwH!@r`d}#flYkP-MSe|N7VS7k}{=+#0K72N7K--Z$%lLwGZ(sqDDJMtJVA zOZTwCL)X!VjPU&9m+^(~Zvha}JAfC@`G)2-uX*j25;XBi;5P?m^}64aECOanx5ZbN zE@jQut?_;RyfnW)#P)QikLl>s6X^4=*wK#B6)c3&9L7gr#DOMbLrxXd!9Yw$Uf^7U z9vYy+BNfptLCHHo!j<5Bh!GPcZ{tAMVL}KO)N_rfKnPWF6N3>QDbm9#-{cCqs6!JW zre7x*qX$gXhi^?UtIFvEC>$Y`88Bkhwm~{hf?{My0yJb6;Rgav(Xk>%idc#r0V{-a zPz^ej#cjG0%sB#Oge45jSp+EBF)k(gKj+bvLMg%{Cq{c9)DCeUf+E-wJ1l?^*wscX z#70YOM+YrPod*X1Kc3vI2qhfK6X^}my@g(0aUE^|;0ieX70ZoR9BWrxu_12f6>)k6 zP;5w@*K}t_O$SiGo?<*;@1s0mq}8;o?X9BjMghj5hcet+S_3Ki9VuWsm;&lR1=ONG zUUBH?5ep+^zZx3umtSRT>_>9CZ>0nfIR>cun#U1(@*_*gC=1A^xAzB zcnYM(g@;))#c{w?U;?7MMCB|2J$DJ93ryUCjltJmw zeOgzEDt=>e89TTkI!dUF(Hj#)5MwZMV|az!202entMeV-6sm#wDMtV zHe@8niaw|!Y0@`wPL?$)D~<`;!4#aV+?A{0oIyc51dTXn6GaddjFPdV2x|(+RtAShKGG-7oH>)p6J(ZI8S7B0I2dQ4s`g+e1zG$t1Q>W1 z;gnz@f(4t<^?Y1zKfrXd2~v2;vDc4jajaN8}Ev0a(%a29rK&nI^r|NTw7rroi}xPH9$=!IFjUz(=xL@YYl zK>+61r%q)bxIYL8#X-!26Z3i$=`GLJiY()7gP~@FUw`Y#dS-H+c-(0HTHa&ub~A2n zc33w!e|#P9#=6i%0Gx?Gd)r!l`{L{Ds=?*YIax=`^JL)f2IraabmAMscMYCzHR#~% z7pOG^e`K&7;|GYBnsLX4*TsQJ7hh*TUcXL1HuzQc0i1Z-S}n}P=Ygliogut!tzLfd zb@uOr%O1IjH6cPBQ+lIioM-}xuNk~V);osv&(jFvtwcA9pQP<RBR5l>}6-M^V%<`0CJvl z>;GE4Xb!;7?!LeN^{?mPgQu$s&t9*3)vI{#d*90~x7-4;75WU|%2^is0@B;~GoJAb zUiiWn?qTtL)9Tf$IqR&m_}IrjR!w>-Fe`9E(qX`}Ai7Pw{q1j`-A>M+Mx((y-}%lu zwDMBs0-UH_^S^(_q5JES=XJk$C|~@+meh)6zpOK_9<|F)AKO1$o7cSNwFmtU5t=aI z<3xz!JHYpduqsk)T=($1C42@rYR3*<2V8vq`RKf9i=8T~o}{UDc*{6CXc8?0ws+9d zVHitp6T1pDk=!O+iQEwCOvI=QN@4@EAkT3v*Nf>Wa^#4>L$>ONM@{pWcv{NA$RW7nuW3B{OZk{b@~;{?TRZl=oOd8PUG-hCX$tbqvu@1Ab%ZaIo+ z=l(nb6P5M{IPrGi7l?U$-va*89;S{ROC9kKC5{7XaU3h+_vzdvTppo_Ez5ckh0jgB z7>=^fSpvY9LE{xH!D7ZnO1UyPjr*$ zbmKO9ki-yxhmN(B<*`$JIzS=^)QXVBcnyxo&7?en871HX-8c@Jsp@pj&D3l*`yq)` zh6i%%b(Z%-7HQ0Fa*=4H&&4$Sef>rQ6!g$8emZeGpus20EUDO0l22M%Tf`lX!Jo9-gP3-QFE#&Tmh5N zbWQWYBqu8x4K-cIpd<@HaHLD^?xor@mB)wP_S~iZ2!yha`OHmb8443N?hSO0#B9)1$kU3oXIPf z!zd#}YRDm#(ZyQkQ5hVlaE{>05S){X6(kgYYBQmLGZPXKlyHiPWF{A5G`iPKbmc0N zOGIyK{Oyv`Z_&FhQdOv$Dp^Woi~mZ%IrAoi(A%%lb-|c!FI;d&hEXJ5SG(&&OIK)~ z9=pzrpmfD}a1DckAwXqEl%*yf0f(M>Jqq>AKX@u|{J_+|zvU-yydCsc^@(O&wCa0z z{@lb>Jl>Q>M?4pJ9q@uM@nF_%;WMi``DIi8_U~qz&W>5>(D9S0JD7+~eCqk%(a4ukCuw#8{~2gVM(?Z9k@IonpM+`g+kc*mNXZu+^f zU%&O~E1vD7w`8!0Di6%`8@H`F@^pZ)V&XLwOcH_{MFCg1eS%9$SB%L#=H2LA?f<;y zH5Y1lUT*0X$&CMgyg?J^tkthcyj?Ix;H4McWOXMX*00k`7274i_=<XD?T7W{%fNFa z!1o`+IcMlVrDzTZ-!5URi9^mjQ~vVHtz?`x5=V#sv0!a_{B)1uJhO1_T3wCtobx63 zA+sHCdA5E%%ec{r^UqzY?_F}8eQ|G(YhL@V+fH1$8pkgHxCJ9Dc-l$(ZClxa2Qjqj zXeNJhGeA>$@qFOZ`&wR#>G;*^`;PG#^=5QBy}qJjj%8X`|K-((Wx!6@*@>+= z%F%d{hUYn?X6&>dBE@s$h$hP0xK=Cnjr7HIL`XtqNKO*TeIcap84)T_isX<*V8GLL zkceK%O0E=@+k`_dM8}3Qnk{!DIuObfqcp1WlGB9J&<|G)MXUo8U8tfaBaIEIIZmLM zZ;fGz)`;)~1XJ7zKxK^Yh&=<{@rsnVbUtdX6U1Y55}_<{@-a;#kf01ASdoq;;85mb z{6<+trxZ|>xJGosQ0`-NN;`|k+3LjQhguLUepZRbLj)#9Gt6?dvy(>1EQKXS>?hhX zi4GpBF28$N!3yr!SqNfO$8D37+B!63J4sO;b)6sod&POj8aKlg8zMmQ3Szf-)tNmL zKmo9P`DO!l>p}tbC=aHEC?J6ptK)F;eux65f)u@I55Nuq>aG+}2P$IB2f$RQBDz#m z>IW<8Y7hM1FS((EF`eH1j@{GD+BV&?5rn8THKwcwMZh2!QBB!707$@qn?wzisG>J$ z-m_;=0+OVndHmI7lVqY;)MXK~pd z!QsoGi4OSCbCqzl=#AXs|Ef7kv-dwp-8X=+8rPPvBkLvD1s5m z5u%Y`4OPw)Y2aomKY{@PpT3tgA`fA?8fsX}P+_J_vSQGkqKq4D0D1Z>GgZ*SOrN{w zdz#C*Bgn3vUEFsk+I zP=!lTAZ9(M3X{wOS)M6mvVuvRi^tHAS5Rh6*RU`V6k5*m3^iP4jZlaL>jW39845Km z$Q4r232HVPiu>Up1a-5>WbxkM!RLEX5G>e}dCBUZmYLTQR-UaCNh00By+brgTR2o9&^0+?4I z)Ig1d5=n*+wda8%NI?Mk)SilgB7f^L>-nF!_&wBpQlb_B*fqxM5~HXgMj`y?GtwBZG~ z(#+-@@Q`!@kq0cy>|1kP{=Q1m0l=$?wzMmIb5aaY{9JwOP3Y+@W_#bEvUfYh^ZT}7 ze97#QuqCw{`ymOJjTb<+s8ldnB@QY$W4}?dxlP@ z;7bO_5xC;5Cu`mNzit!NdJc{-z_sZEDt2~ws$6u9DoeiOJ@){s^A?Al{Q`}(jJFBK zCdG$_jH}Xq^@9`Qb|4$gISlym-X7~%&Ib_B!}#RrByTwHCL2F@t-d1haUB1){uDj? z((CPKwPQHapt$T>?zps8j_dIB^pX_J_&#tC;;Bd8#UX!ihPI8s9~x|N#$N__6PgD8 zfQ=?z-hL)afh`}n!Tx9cTK$QM%MgEe_NjW>hpx5F%xk~OoSjj9UhuS&P_}=gA4k?a zy8@4eevSOoOar2eEG{?hS-#|4*EREAEJuWs@JAxKpdzFwjw)Uw25dx^2tnmG5vFmQs9MQuP1dpmEhJ|MImLL6E;Nyr z>mI&!<20s~#d0d_qgtnOpTOwGb*OTkkkY_bivWj35Ck(sge=T_giu2K-w7;KE*6Gd z!1;_|$xQe|vdxDjylc5Hn5aE`VQiJ}2NN9|fUGD>y zEQukmTiR&ZV#4MjU?t`xu&X9|cw1;oCuxUYs zvCbW1IAG6F95A!H1UwSJ1UxpN3D`g2#CgO{gG!5uBQEzwU#5P=?1QFrn7A{=aX`&o zqSA_fVB%0J- zZX7~k76TNDo&yCI6d4Flnd&A2f`#rfg_*iO<&D^8@ALQ>kw}4QK37W9a-fkz-iYoJ zMJECp5X>7kvQfA09rR~KdT+K`oM4|#Qp+#hdh0HbOy<{#Z;7}-BZZWI_IXtm~;VdNQiP%(W7GyX%iPC~9;I(uCoa8VC3>P9R z+kLuOh&?{Zk)oGi7o#`aAUx59C_=3JS$wEEnIUJPqIC$W#_)DyJaC4U5PUQ+Q~d65 z7BDCiZj&4;s49pqfSLg-6Eu|6lS|RhVS$WGX z(<8T!4xK{Jl65O_gydZ7a$ z94DqvKYRbz?WgP4>23fE9M;;wsffcd-rHKhIJ;Oq9dux@S%5hXWG}&qx2@Gv1euAK zUHUcqw`%$&*Vz}>pQdL~@>V&133?t<2FnFo1{S+uk>+yZ-8f7tF4xz0j(Ihil(7 z+iQMa^P1Pb=^$cz$$vk@4!GNaBW}ErgHAs^1}6;C_IuR8qiIK**srk=MspZXgVl$D zPKhRs*dHV06M~ReksTSLh1_DwyF z*nNEk(_D}5?tMJZVh8s5=bzs_)%DKq-Mdgkh+^~Rn+2y)kMe;2{?dA!2RxV(MrLrM zmYR4R?=W5O27* z`(Fh|08;>oekX~krNG{R63`Dz^n((xCs+bz?Jn`|>6V~7`=QKvtN;_0_Aj3PFsrIU z4+0ab=>ZdWq-9pDfP317riBf3MgdIdmZ@|+KW?q)lb34cszay+9#{=20jI`}R*NRRmw~^;2 zjA9U|04&HFS#+uJuI##NxKw~AU}_qmP&$HhmgPb1mIDV_S&}tjm*r};Q*FmdpE%%* zU-(9A^}9xF^80V&ia1nM7 z>wadg_ern(!cj=a)h6Y%I{!J>+nGrlPh4@bocpaM*qOlchiG)s0d5!k1nCyAyMpOH z5BFKA`^Rk8PwUPCKacwH+M^e?I_;6N^rMh3Hs=<);6}~DDAFRtA~PG6X%vM;LQ86Sg@rk{>)Tyx}&lAQ*8w3>eFnj_yW?3A=$%fWtY&q{<^6>^uoO7~{mgg)0iFchhO(f{0 zU$cMgejb>2*;V!c@F&xiE${~AV1ti?6Vin5rSEs8jUItG7ufE_2a7R|Hpmq$zXfT4Y%85S&Hrp^CZtUW;bW1K5 zO!9+)vU7ke8chOl`Q=ugbE@7W<5R%zzV&3i@9`EJ^KeVf9a>$Y*^>Piw@}G1IiR;~ zbm%OL>$V0Ta>&$%;knj=1q)cbcrn|zZwDBav~U&xzShvVE2Y-5%i>^ajNINI35va{Fn{%y?mnxEIa=CyCCn>jxe4Ffnwe%?b^Y4FaX z$#}ot-a&2{l-wqE6==ecchTv=jX-+>ITt(PanK3KHIO=K@TqXkEOz7*Ux?*>T&_V6 zm~a3-jZ;W{F;3B0LY3=8Tu#XcS+O}i&STJR!cnDwM)wL3E&&ofuZS)*QEe0At9ojM zADm`^9z;=%sgN*Jgc{6n6&w*PnT#v;g;ZchsNjs`I^j||=1@`Md>WgPj!D7A<0hbP zTu0jHG&)i~7KbG;#W?~+1T2bxhSE8wiO3PH_&Ya;U}6G=GDdk!6sQbnI6Zijqs2{Z zYX>a@3zKLIa12;EgdIMD-LMNWQg7_qz#3rZfX~D$=($Qvdwr&}Jsm&+`|d&kuzM#8 zn9hv?rUNNp&oBklfeL^wQ~}+{59k9cD%q4u!;~j+oKS?#|HXJ5Km&lwHVt+6;okmL z2ENvTh)O*$VkvOX036Xfrs)6)m=2PFJ%bW36D-jm!vVX8C15VxCH63D#<`C*V4~9g z04L5R{{8RE3(599FS2`8u^f8>Chn;L6Vt_UJeV(&PjMXEi|8a#0TWZ)CCVT=Ia!GF z$7?Yh3xO>~a(tKqOY|Z*RG8XUYG^2a?^sL9gBB3uH--}^k+;AFQ(-2TMTj9UqiaMb zff9u^)NF!e>Ov9(m<6nsAVrh}s zgRI|K0`OHifU7m_4YqRa&Ba*NoYDil2ST{Me&=3mkz`Qd({kO-w`4AdHr5AQWGQN+ zOw&BcK_Z8;-dP`G87Ncon5&jcP(|ECf-0Qvx=>V36_)p0DkiFRospPN3jsAUEDNPN zfcGxY2^1mVo3NlP*<}sUj3*_-Gw!5YhYnou=gWWf54X6{-vGG|BgcJy!SSE}7R42a-?CgWx9WL_$9P2@ruggJRN)FwE?skGcVWe$h)DayrwV9_liH|K&2@?u~K~~L>D%RON0Q4 zy-htbAwdy62PfZGUQjoRqj~^XNY%uiyu4webl$K$R(J(j5rC3HMAwOS5G`-CbI3|4 zn%28=0oO3_DX4z;ZQYB3?VT~fE@-#K(BjABgJ@no+2t?T1f2TgwMQ>Bh5x2rD-j!P zyMNCkwsU*0FB9Xs0KU1Ow($w#D1`C-RQ^88%x;u)3h+wc0;*cQ4T2LwSjzeVqC3|o z=5%Moi~3mwyVgGTk||vLT3<99O>%nLUcwSP!M+Llj*Rb>vhS^4dFM}f zjCTk=<+>m3WR^~AmF_zJh^1xb7n#!{Q?ZCri;xz97K1H8wvZ5E3}6x1B5+H=7GYG= zhxfFdheJYp1Y+(v`H92ej|PyNVkbXX;=cmx?>YI2!-s$U?uob!`@T%ooAQ5ETLw_e zb^vguJgoRtXS1>;pVz$ROm9C;Ckoza&^Y2=e&-#}((^C)radZRWX?HFr@FvXi;^q% zXUDnooNe*7^tO@f_+owDx$E>tX8c-h(nl}7&OS0&#<}bCK{HOSzMJEc%dWM5CblvT zuYaCKF1^ya_aTF)r;pzOFykH~5`MPDXZ)XD_%+*l?m9iaYN@;ADjS5Y4gv`Mp0U&F zoV9w3;8!F%lM8wIhrVbtx{Re`K0{*r$aVaNox*0|z`^ANCtBS1@1}#g2Z7*^43-(Z z?XoLv*ZOrjF|F|9^KP=fI+ha$1|YcpV_4|<*Rg`TOgt%boDH14r(>MgzAG5rQ9W*C zbiZ%UkM^2tr5Rd^_g-DMttCqy9^7vrR{XoIe5Qd%+Wp`L@HO;y7IWAkdP6T3$y(1*(!jL(f zGb{swq6M_lF+1XUbB27D&PR3JF1bx4SfVUZQ_;nv3KVI?P9!xNv74Zsp)5pq2}{3W z0IV6~R20y7iH75EZaX{axCV6pQgnC+J7fe~u@L)@g}|ohHxVz`t7}(Yza9!e0kd9hJ}xUjqKXSFUHl%Qh)g6H!l(I#A)#G{j{x7cHQ?u*!X+LoBC)A1GuwM&@b{NXaVLA_uZU zRykHw2Ms-_qFHyU$a7kf<=#^KM`lBnLxuBLksAR@Gr1ru()qODUE9ThN|}QW4l^k$ zW7!!cLwFX4PT1iVoIyLy|d!IbkNF zbSX9?nW99GZ{Hxa4yIc*;X@L zl{Sa7U}bc(Fq6kq%9)k9x>+?IqbyJ+%klu3v$BxkJBo~nS)(#jX+Ytl1BF~>gbui- z5vJ+?^G%Bs(tsL6MiF6)>QU_hO>Wm_h9A=prFlhVlkH1@BYIP;Q2D5j=m5aXZlzaq z++W*x@BS=*wn~-9PfGe%;3D94@in!6`%<0f0(gd`Q_Sr8x!V!Fq|i>yX6$){}m4=T@q>+kMoxPdceF;x{ew z<`*kyi8nVAER33SqcWD7g;D1;YG$Jm$Y7CCIbvub*bLACtYxM#XZ>+tQUU%2Qd=?%>GK7*mRo~&i>|GGU0aQ6SwqM-&W0h~+l2i%offR7Pu9?$ql z+V`gu8`h^BLx{~MosrahS?Rp1tT=a_K5ekx#IK)!hTeMKRW>F5YF=|A$u?J&$8yK4 z#~tla<@OqHYqN@qfEqaTzylBLZn-(r=FNT0le1~7eAxH>XFuyZ-E(p7mq0uxix%x) zv$Ff|zrXM6EQ{-&`>o^C8S2cf9^BQpjoF^}dChBH`yex$lynX7T;PL}UT@R5j8!^v z1+DQr`8#6w=;x0;Ha;n@*nkG35xSkk$HJ;DaL2&>ZWVDE-F{G)94Azu@#r|wTfULv z9a_*da81YqRf}^K*+EvsL8r3lj!*`a5rGN$2wMceTa2Yp{M?J_h|Uda5L?iLMW+iZ zdr*a|H8)v;BAkm5f$MopOb<;|)1jN80sXEMjyUqCD#eKI6E%3EdlIYJ!6HDB_QfL2 zk@m4FDfHYkl!h^u>bXgT8R9ysfx6Dp=LAFKA)c#dmIl_As7Sy_Py{QiM4c?2Pc{1c zt40<;*qOQ`a#S|ru5KGaiwbNxaQ_54bhsa;SPiUNiru_5miLpL=*bH)xSE?cqhpr8 z!ZvK!pn3=Q`R@kay?cNH_Uu9duwla$wRzJ)6!1{oC}1i`v2>_qnEBf)SPa93)_n!Rl2uL?B^f@A$S=u&B8~s=|LiIH#^+Zq4gkK1g=B#0GO7Xo z-C9*#w)Z#fiU?gaB&&kG0!C9H+qAcmifn+|NqoE>L2WZHw48e5(D`lR*LIRy8GBf2k8i*(EdZ2jv zuG=p8=E&*~SG&}rynAbT;DUo}`?xC$wX;Hmj(pK{KKJrj#w3Mn_#m8DaLBucLLTIr zrbZ}S=->(;R9fMJ8uDI}N>|8SL*|MQRNx~8stjkjO7C!Tl)+&_zLc2{E?6@7ifJ4; zGli;lC7BDQ3qsC02&SNleQ{tWXCbn*Nj>L?l&VI&P)Yt^5y23YX}*~V!SK!q0YWK< zL!M|VMqwU-oQ2ZpVL<&c9G-wwk&yvhVFZEm)+jNWrRAZNI`KjneAvi0qvM1x4Mq%R z?hjXU#AwI)PiSwI2kspieOx@G9*?^1=|}t$a=%}nW~R$les|-y9sn^x&c3OAn%BO` z%*G`B9nnpK^orQK8AzhPzWIm1oPZNL^U7s3IHhl5(C6o(>^_|-f9u90UMHIG1P`yEJl6sqlm?*Tx8}( z&4p1Hv@pOD$won=l8u_NB;Ypgsdx|7$Zjhe{`}KRI`u z0N!E7o1JmC^GvQ^r>ii&R0h5@8#jt2L#z#H{+FgX7MSJ}36Pu1@z@KqBYSdcmX zM$#{tnVtQ=w5ZkKFKer8_3+zO+=(}?34-7_l>|;K9p;!a4oafvx!c^`Ey4KUh1c0u z087w;+*IhmV!ZJWF8rG95pcWYYkc*bQ@91O8po@d0i0Mo#B&V}0C2{~(s{X7V!h8; z2mBkrP?HlYE9KG?@0XsttCuJ3L;Hh!Gh%r+ z`Wb0R#imW02qECyG-Gk+Py^>^wkPafQn$r@_ua?Jl`Cgi-0pSXeSM7B9)YplO1igt zUwUB2{s$*E@2qb_`~O0n*SzL6lP(0F1N|o6*82)9n~;Zs~8hsDIhkMh9eQ$r2b#eWatn_y~+R&}3Y`6QKo2pPdn%zoF;9 zklZ2UdhQa6t`YNav%w z=OH?1C@8u^c%MLv61Bm37sIv75Z5mP(HXmmC{RvxO>dGMC`!~2Y9-pk07hW6>~)bZ zSpqf=TiR&xP_Iwoo+&XM|379LW0N)NES^D z#)uJU5vmr%u(U-WQ&;2*2q-c-HqOyHtE};NO!btT}mL z$+Qo6`>8Y!Iab7xBqeyWU(m?0vJ<( zhfQfheI`GiPBkZ+=pX?NAOVAb1Z)bDfayUAU^A`~u*I+h%(=S+{OkY|jkY^DA*ljh zP~JWj*lKWM1hk^A1yg|um<2Gga3?Ir2@Vt55ke>0hE8^m7)!1l=(|e6ZCRHLOYF?1oh20AYImvCQX9aN6kU@YB^pp7(|g5DVi1yW)bNQZC2IjS z**T&`j`OG;rQi)=*assD6j*Nhq)EEh?GUKtNur9~CkPRRE0F+2KM3s;DF%2S#e#ivvXlC<4XX!|N)ji3Z889bKxC zwgi@oR^v#!S2&2#X#SQl?f77ZsOfu7W!eU5LN@fab#oCeuMFrel-I!#R z6qMvLEJmwknHZ^DO3|=DbhqfpJhyw2MT!UJ>x>^tW)U>^!ewuabbDz88$cTN6 zi7k~|SyP>~eQGq+9BAMPVt|{l3QyhU;j#HG`dvxSbob2;9B)>wbR-kodEfBQ|JI6G zmph=l4t)B7u=hvRw=tirF7RcUf9l>Hzkl(IhBHuqcI57Rteg?cIQ_RVeIiq$*7&)fH=6=!X3+o6W~QK>jAeE5XL`otMu z_c@9AnQJY-%1=DuFgc08_52_=Pw?9gFAattzeINd7XtrXN3PfsH;SZQyvEp$tEP|W zS$?HobNpd?FV5csxH#-a-Qz)OPA=A zz6yqE$`;5=P$x5GpKaGB?+@-^R= zaksP1hU~MdySqn8KLGZs>zZ$U>suUf zzyX`xZ)>%7?OJZX{r2ABfz3jnn^EulZ@lqF7B5~r%i=bz8*jXE@a?@D+ipfmeqZzW zbnAn&nQ=NZefNREl%lD>y+aK()Q?8)ewn0qljBc+wfr}zJ11FIy2P=a4%eT2@}|cH zZ(W7jdrY%pV|y)NAQL=mJR({7S7l&cxd+!MQ5}v*KteUB<#~|5lTfR`6&e5{L;(rN zumc&S$Vi2w6fztzIi|z&Hoa&H3Pe%hg{f{6Fg-Luh9NeG1(t2R#Hjb+i5@o5EE{y4 zD82RaULEp(4d?-$EW;-`4jm)qeGFuwbea_i!pmnuhE>cg2b1R^1C#?n^7>YlJ+C3d z65~}K3+oow55UJG@_8tAii61DcOPN(IGQlnzdJe0Ws+`Pg`Tshzuk*=%df9^c=FYC z(xiX;YBt;yKml6|QNT>xC?JCrFwv2s*=OT01x)M$dW^~Wg_Gfc9$e9A5@fM4t=ese zBP3tiynmwmgG+Z>x#5E|+q0seBw51&AVCco&T8*m;iWmm!#={3CN&C^X~*; zqSMt*kbwyxwEMushDpFg<1PVUb;{9ABQ8s>5M4@b)$S6`NOE=BsBxA6sAIC8vqZa% zrDRkv;z%jO60PDYp#vnx#{Hr>@Z+N-ar+A$tR3Z586i+{Wtc)!{%|9M zP({AScpYitIueN>^F#(Jyuclv8(5g4<=_kGQe$l;YR6(OFOh+Vgwu|=x8yY$szByV zo!T}CRLG<1e5esQUB^mUgRvhe8cpO!1}K7$V;Qa7aMq?%9AW zH@1?DfRn%_BPmhk$xtP=19xSJC$~Kb?irr&ek+K^g~A+91sSpeR>Vx(3Z)n@B9c6M zxe8+{q(<3ZRl<`8Pe{RuiKyUolb|D*(3~PSk#lQW7P6xR9olU}YI!Gh<*`=geF6|r z7;$0^)reC+fvQE$nhnz?&D-cs&J$x(R}A%2qjr1Ua(Z_%0HT>*zt3=X{!g;{w!qD! z{=1VFoHzS2 zvu--*pw>=2`W|7&G0iR9oyR2oYmD80e%3ed`vJf+=IY=>4F!NbKeyhdwZxxR&%EjG zzn$^6H?BBw>*_VsP;;x357G{6=W!lz+UZyMB><;g{o@HuG&=1{|NEs&6y^MVnf>NC zO&;>T5^t09S0OOIbg{0IaVc=g@+*Clf6s#b3o-w_W#946#0w$g@uuEJ&cB>~l~1@YE^|-EAEtlAdCv)p_4B7)?YA$#%KsbqZ=gp#l+S-c=Y4Ul znCS9UG~&G7Mc2Cg>!!|cP~9${Y_~Ycp%oIxkYm4kI{65VB3=d{_;|DY^oxAm(k1#R z&YPAVs*_K@#vfXKm46!e^x*#gaE*VT95vEYIj;%JdP=-Quy#!SV-4!V7y9_p#rhub zJcsAa^gM^!a@8I$u5vV}HhlYL(%1%UbeadpInuft`W%qVFP=?V?tYJ??*Y$x?6JqV z^2#guwO{+S*;a9*`tp}2q;g#}2Sxr5@J4|1&O2|Lf)f{Bcp+nBz32Yx-8b)6vl(3s zyasaJ-|>!j%(A$RYvsz7Tzl=c&D$=s1*ux;Vrp|h|9j_Z#=42o*0yu|_}X^|;%S)O zH9yo)L(NX^{sBqf1l|K2w24ix4uNIeE|<;a@mG)cA%b-^+K^*9WD(hX7~hZq2c5N(bzZu znNXluI~23$>D(roAlcrpsU|`blY?gIZTS+O!N449%l-W^A`hr-(5)#Gj!_WmHnAuPF#?^j>@=|f7>jw` zh8o3$JR(~7Lf~=WiB2Aw*o`gEpnA@3_^bBEzj({W01B8K*fF@_+(8t#X!4-^=0FOV z80`TwgDGG#P|;}Bq-_S{KQ^YRfWfHN>;c|yNIDPva0&nclOc%7nhHh0=D>(XgNW`_ zHwlrp!dsHN+6n5EOh8P@+N~U!kv$8L%mpoC-lpd!VeZ+9BDnI+ z$`wJDAO_Sx6VZcImUrESONm59zFAoa#FEFAZ>nWKYyQf-|JSBIR3RD&V|r~gsH`b! znq`Ag9ld4b2#)4`Ku*iNAup_KQx(7==E9vA3FL5x?4yOF;2tyC*~|tGlBdSKqJb(( z8D4;jyfVMfksR($@R}0gVUWE(lw&_~CWyyY`4q~2bYWb{ljMO&!Z>%AgLgk`*WdW- z7q7nMQ*U2&-Ys28qmp;)NY|>|ZjiKpXT>^z=pl5YFjXklMi3Qa$byoOs2e+0VR8?W zjZ!DfK^?;^m|C$m52lVJPsxI{6isTGq=cn})u}e~N`~Z)0)~6aks4m9<+a7Sk|ZTz zE|({hAr<~cNs^f$xgtq<94hskt8`TN2za1CQGSzktB!%5gnue~-;{oqb>uGdcbE91!Da58zRwMJU%$QTv^A16N^W}sta10BY3Re< zH%M9!>;UfC@1?aL_~#W8kL>&`Ub^>lp7Y9Q|L(W_O;sbl%eD~v1*AF$+>~+&Y2eo#__b+d!opnCc zP(LkNH;)eiM+jcDbg@o9{c3;r_O8=Rboy0(^3o+j&fk~xyyTFdu_&|KoKeKDd*U|% zKYoes!TFzLTpAJ=O$J2V*}HU+uGrMEm$|2757+BL;wFb(92VkyvT0-sZmko?Pq(kn z<1DS`FWotjGRQa^z2gPiz189`fiq9L)@M9p{2#CNl}nfCeBhPt{E4K~20O3Tba|=7 zPC#c&d~R^xZkOe)7HDxI%v^6 zSldO@&GsCNXa_(e&>aKX&>ru*O?0!X1hH|OD4;~gQB^>OSR5$&6Hrl}UI-!256ojd z#fid{M-v*jV%nIF#&M#F4B3p^MBytYI!z2f6N5~K`cr{=ZWE>qMHH}Og6l+cw8o(# z<;eG@9z9o#-fZ0BHWBG9&rv3p_p?;?&;HMeGI~%u^5QVjj9CSsPN;z5o;d>7t$5_$qQ{;3H$`QD9LSE82V0m(&EEvp>$Vyx&x3 zlz~s3>DNrZcH#yzg(zTVAO%c}_Gpx03Opwg_F;-fn}aF_H9cT4s6K4*wR=83@17^V z@mt5d;Gd@q?JpW#HBC7)gCI7hjlmHx*-7HTNst6=6Ho&3_kGf)wjR1m%!TG0oRIWF z`uC{E$oW%`052u~=KMFX19_IlZop;0M}RMTwjbSUjks%NCuvXM;cnE!KoyhNEw2yV zT@>o5#{sL8R>wT}+5i)afVJ~|Wca{J1V@tR8>+jaS9$0@qKZVII7ygW_FM3L zbIBB*@a(tX1(Lu$--PjegECj8ilhQN1gIRv5~k1$T6>A$P|7#V0DZ7xK#6?LJpwV% zw~^S$>rh@#vfj$d?BbNggFr;cnF&4UA@7#ul846i0SJ|OjCr4)y9LUxV}TsV0`sd#?iE!6SGDkdhEYkD^W)AMOIJkmEjR z0~-cBD8})aq&UI|WPl=dm2Gz+~RdKuzxfSkKMmy&c5un(}>-8VJ!;KxOe08axxz%TvDL3sUJ`7s)< z-tjp*y}|PrO)nv7!N8Jx`OJ~u;6G+p>|F=!{X$hbpOUFQAV>U% zr`B=%-gL)C2UUg|YA&=eKDs}~D1h8%>^L#hP(NvU_rcoL+q?uyr=|GL_O8>GC`Oi7 zf!%Qag3>~t(h1w-HRg=tXCj^{=g*QzOBd_XK{pDCol6t{u_*_eqz_)<_Z_!bZ;?1> z(yB2tjydD1=_5i;zsT2}uvo87;%iF}(`!z@(m%5`=MHePWUa+~61Y3YEpN}6^RXme ziP-Oi#T*J;-CGAom)V5pPlg%(@mgPb!eaf2!xxt>(Z!8Z$yS}i5vpQ#tN7-Qk8|3l zwsm+EK(J_Qk2lne^(FG)5v%_5GwgWC;d%P%9P81u2Mk7}uk3x-_EB${b^qR`q$4vu@iOu z_1AOmx#u=-6Y!t2Ez{i}lXNNYk{Bb)mM!BGpP2JUG}f$H!~5U={=r3GnwygKCGZ0P zK63d3{Ko!^sBF_i0$ZaqFP)GaeV(85s*SoE4K>tIKU%r_-N4-w7HWD^ghqqIzb|6q z0BEDVo1zAm?ZU(q26gl5`M`LM)JCIaT_@((-Go%3ZbEJKfeDcZ-(ufIqVG1*M0NDz zE1C(Yc{-;uJOO2Dp_d4cn4y9^|BzlJ#e|rSW_uOKiGdTG>^4!{Bg#r97+4I-`*rL) zPc%?OUgz%3)W^I-aeemW{p}{ib%-gjhXqKnoc{no5xuuhudXQ|rT*ttm(RPK^5@V7 zx_LHm1}I8YO1oXah!Ge`kVbNS=K-lk>k~>5&CB1tuj%y8sHdj@H;tjE&c|1*K`g-8 zA1KX_7Y%GX6-9t$4M1_y#sCT?A94n3CvLDQhyu1Aq=4z2DPU^U2TX-3U?NyCsLeqZ z_pkoeFUQ#V_;(+;3$1fDi{HSa0E<^+Gw;XKmw+Irke*PV9R1SHowWn z*A9V+>9s8!CtgqfCN2hE-O$C7?f}f)k1p@qz+VEV0#~?i+-`HGDnHUZ+>P3uL6-?v zsCQN~1aAW_6Bd&erTlvB{2gU6$x_lfK=WK1V$z0gc8-9V0TbrgVPc+p513GLDQ0I0 zxvK#px~-N*+|`XqsmkRx?h-L3;W@TL1(vAYCCh`o$t$&@t9E4BXF*hul3TtfWEYBL zZap`NScaoLHE|unTwwr`s0>A1M#3E>cM^l;BPoCj4~nkrP3xT+g1iKr^c^Wuai?gR zgFCg%+d$W$mU&S0k1smnx!)Xp+S{AzZLs#ff3xQw{{EQ{eEdt6APD*NfQp6;W)=k08T~;Sm zRkT`erl3|!)TxqrQVbPl(Ik^pE7oR`DY}bT%Vo+2T}ha-jh5F+9;6&rqLd9IWLCcY zR2ybwM-Rgi47!`-??!H(^6;G%3M&eaN!GZNc;h4?50c}txO7-{oIp)1hzIW~#n51? z3L!yERK;#3Ur`lR>PVsGH5x%o^{!o2EuYtkY?ud(fY)Qv zM%p}+Wuv<~3_*&YCLRBCi`caaI}R+04sV#F4$7ZK?E~xwJh8niGDEE-+iZWtzj!n} z>Dln&9KCn>{O9n7M=$+7m_u91)XP0@^kw&%{l08WcOUr7BQbq}48IO)g*?6K88>}@ zE@mMPHPmJmP76Iu)`AunuB&;_ z2d5c1H=TAR-}%5M_B-urzxMb;^~Y{J`{<(;N({#qYt0g#t;9Fn`N$bxpB~iMl$Kw^ zB}*4`r^CJxUPl2ZmcB&uf!_v5Ha(nr+SPvkaZB`0!J(2a-P+Eu4T)bB+$!hPO~s=W ztpo6>?S!G`SmWdK|9Pan?ynKMcUL~Z6BnJ!&cE~fb9#&o-@cjkH(yuYd7Yg1%tg8G zex0NXftS{G&C;byIrrRiH#hdRMOwLXCGUIR`vw=CJljcH&~uUd0Az@0*|KFEb<|Pp zw9`(rExM-|BgYNEgM zRQcad%5L2)P~|{?&_E3#0}}-j$gqI-0E0XZV@NSCO9jX%?h6{^$lRD3)6qyhIHB)0 zF>w@r<~QTMvjh!NP+Tt>*9j;c_nv_dhw?CBOn5Nx0dOSc9{TKpVTf4D>c@W2_*tkw z<&qE}Dt|`BwL`)4XD&x|%HN$5>N=_dD58!~OL_T(v)=*cugRa`LIye>ccHX+i=IN? z#$qeAtc(RLb9YT?5X~V(!LkXxf?E$#z{X$-*f>xDeW(Ip(5+%n(?J%4>ZJNtfYBRQ zob%_xj(+x2f9?AKiq)gvTk!N5J@YJ>cIg$sgS~fC;Rx6~AOX{VURw!DoV4lfH~$Aa zge7L9Z2?X+Ge4J3vSjPhx9+BZ5+9QE81P9+kGlJrvpMi6@YHV9qq`(MO1865cNaZg z=eUl>WnyOrVmaso6FbGkx|FozjfB7I@xr-V*H`IUA`|F7GEnn<9c z#%Nn)yc-nM@_;d(WT7$w9XiUOip6A=<&#aM&<=nnrQ{Z?gcF03QMF_#VO2u4Os#y@ zLRj6!tYtEiQu1K#YK0)x(W041Ms1Rr_Pz`cf%o;C=UR4naeRqp0ede%ollTT5n!U$jw!jQ?A>RJCp53`nMQQ#XSS3 zE2=7ZK9G6zsH&4B8MReTrvt%g4_v>Dk1*0QIwk7G>#h_=(+)8o!{)DJ{dg@OtFdaw z)HKV~?l_OEK_d&Cl`9D&iyZEU1v~nL#@bLnu{wCcD97wJx!LAt?0eISYp31e$6wzE z{;RycZ&Mr2LaWJtBtI$O#4+U0H0^oG6u@B6dOT^?$v8OuczD!$@bH{SlpcCE}%Lu~{7*+FXU zxd2~wnb#k<(VviX%t`yx+TQhQwDeFtnZV0Q947HX7f){*%(+K&V#l3SI%qdjZg29K z)9jF3i~*M^w=0fwn6DZ3VXUorFO$7l#i2`=@D|`-Hns2aYkbx-y#L`!zZKZ(Xcc$& zQ}#-RjYbU)7yYg&Pm}}A0|%#+v~pj z?&H<3el-_daKW5Kb{v2F@mzg%&s?U%>>TGO$lb4%^kv|v7$Zj=brjcMe?7bJzWbb% zf8KfLv3&XR!A0+$iwSZ7{+Zuitz#}c75FEBf4t~Ep0&q34%&PAp^q)q1CMw3`!C-! zxagyP_DeT6b~DsaL(QFj3-~O#%`r_RXb-Nqp}akCwlP4P)GqYQfUQJz%m+5?0F-pu|t~KnkkQHLz>rL(zA& z=u-m4NrRBjH(36+JX_kxxqSQbi-j6Pc`wV6VNx&pf0_MO~V$)j< zVTmo%wg4v{1acB)MV=)=D{MLpcRP3MI0`-4wFZgdBMc63|U4J5N}!9w?CzA?0`t&tv$hSQ=%E zC0B4n2t@L+s%-S2T8%YQDy~fB=AEpe0;!6#M4;~g0vYowKqbjj|CfJDXvSV)^d`>s z0SZHSp&^W_xksqif7gdDkSF1dX8<@Zc>`CZh*!c3Mu8&_DP~ec6QPP4$CU4-DOV`< zZ~Ep+8H5n>*hGF**_}cbk~|YdZBvRdNiDg9D|!xLF+7mu;3q!vrH}sAQ{H$8I0vn} z^J8Z`@E;d+rOFlE0h4>|)Mk=f5>%1(p0A&gB(D)cNu3bY3Ki~BO)@8nRJjQY!aUZD zguqy;gSt{}rk1-%(YnG~CdDKL0`iWLS{8$0Zt6rS1aNmnC2K{Kt5#IN%`my511aG$ z87VuAIdavRbTBZll@#*duH4O~L=q%YsvN_uX~IO5EGL~==37(B=#4BwFg)R2P+m88 ziXIm{Lz)Ng-=aW(bWeSI^h0v>G3*o+lCImFfTu9 zIowt))ZcICYHhXL{X*cvZG4QMgm{jg-2HAz23!fif<2!{`9tn1aNWFTJ#E2(>krr$ zW*<8+zW#R*3kR0m$LEi{maUwpeE0L8{_B!`W)d{vj{n`hH-G>Aa{+q{HPn_#&o3{A zF&#twRBGWo-m|u5$x4l*IdJEUh^7K z>J9&0$fiaVwnp7`|4MuQAK@HaC+CE7?&2eV^7HJw`@C5d`|z3$Z~M&mShcQqncPcP zC(pXRLk%_5Tq^+27j2;x>J#2zrOh*rx7?AgePkJB7 zz_NZ|HUsd)gj4JT6}{T@NercCI_g0GdMaDy0e})o!a&SO9;)fV9gQPJCwj^t>7iA7|WiS?bX766u#6kRqisd1UuP+TU)d$AlYC@vF#MqKlfYfWs~ zP9!?+YJdq@cA2o0j0p}CNnJ~cDU$~llC>Sx$)yV6t{8*0$m6|n0G2Rv z+(!(ka#xDM%H1)?d|0r`G6+$*D~94Ok@q9z016U0`XlE?nF*0X1}1X6hb!M-gOt1g z7wUl#%`pM69O0o%R;sxGlDjN32#r;1Ud|*Nq^(fn0->ILggm*+b6iIM2Gf7xN_Z-W zW{%y!X>vuBA%{GiZyrl?z$^0@^R^kP$oEb|ZYf%JxWFx9u^h+9evpzp$z5iIC?{oi z3ZvOi?$Ip~AeJPR67vy(L?T4|kkz-X`NPqxPX5i+H{bKT`Uh(~REn{ZC-bf&s0ea- zlvj$3NrWic9#mJ6ii)wiwh-kCwZsUfAlwusVbR=8F(6aWJTr~C36B<1w3?P$X6mM7 zEl*aNYurtN2pvKSq5^rskV)AGIQm2mPuZ0%Ti1tSc#}nzLpgGR|rN@6a+Un zoTNaVc_ih}5)zh@^;sRG0{{RZ07*naRO34O%&jB`$B0VJ&s|X7r}kntLT;u;_hjbf zdY#~{!qPA#<30}apSQ|bjSy< z^6fh7_4vhlsW0aJWMkuju)Lnu0M`NkEBKx#R&*ol+AThZ^9$q_es89k8fv1k^A%$_ zS4&))#8*$-7|G5_EtTUF-xio5vX2T!7Yq!+a?X0liA^Q}7{+SGnqsS|)_ z14pKmcn4`m_TYN{`tx`4!zX%UEgML@($D$rnN5KmYN(-pZ1u%k(58lI z_oY8KeL7pWop*+{#dTswn3f71j~Q491LGTQ^2}jcWPC57x;P=^`Ivph1{f%A2~~NG zda>mwKLJxompIa1a8JI(Ds7kp!_v|X+ zKQAtB`NXnX)-gN zJiqm{F_;224-wpQ%NMs|6ma5S@r4)uz?GM|1lV~Myf_L0iMHSDGMBBuM5EZ&EQ}nK(SdS~HBB&)&G8iEQshy-cM8y=a zREOXgp-sz7-5RT^j^UNYQ?wuqiwYJPS2PorlAD?25=N3p5=JB`MmHlV+dm{Lfifl7 zCE=yjlE{f1NiK81TrThBvzX`P6sI5AQ6W;nSuB;S)R9}2z}>tSIW0`dqcAza+})M2 zR}r!UM!8VB<=P9q>n?bbqC8Sl)uJZmlo)F8NULh0+PypI_m$R*385Wh^i9#`u|ufb z;_6-_Jk{f})v!|wY-f04-8!Z2IDswigc<55M_qT0|Ng_@`rTbdU-I)e-}}J!uFp{0 zTIoVi51hDc$LE4{6tlGB)t`NJ2i$&V;zFIXHD%rTg8den`4>ThGkX)RKYqr|_nbYO zdJZ+zEaa`O?*&e0Lwh)@d8nU08S`;Eh!LF2&$xy=KDeE#^3Ef)bF0glF8*L}xpGk9 z6%OZPT>1SyxMk4!;2kf}?(G(r;`~DI>CyZBzn*jY?!oz=WL!GvDzPaE?kx7a`)z7F z%XMxdI%*kjI_*k-;P^xJF2u*m^8MGNLk?$`qyL1~?t5;w41ly#}}pas=0hKm1{?yY4zpJMAwSE?l^| zA^^DMmRtCnzxf-!@|CX)E`9)b*|xIK_j6wQLmhL$D?k?myR7ddmVV)GUh>>U{Kaql z96z`7$Y#p`czk`$$F6vQFW&Gl-Prq>$5A@QKY!$n+oJA64K>t{j|L6-?_W1{^l<`; zwSWvj%AXRbI+aPP zO{1C;-;uoU9^qwuvWcz~6QrKALl0IMbeotAO$@4Wn%J1@!~pOyaX&}dJsOhtd&Qgc zGX|g#^gv-J@-$4cSHAy4zN2DFEPyQ)CQWE4Gb}zrT`MKMUX_Z`E0iw!V+_@Z2?Yv1Nd#= zpCtXEdvAu!{{g=X{5kN>N&7TNd}0<#?h~L1E6{}XpoyJWJAZ04#~?IeDM`t-0hsTu zv5`@A>SUwzT_!p{qS2Jp@d8@3k;P;<)PpV)tsKo!CpW8HqJ@%M15Ct}tkr^AZVF|e z6ikjEEbo=TEDxZQ3ZzgDWXcW`6&a++eSP^PMVt&+q_P^+tEwl86;**MEDit_ zG$2Iu1O%CT%(O|c9QxqME8)aw2rnImMB(pw^3exggWLJl7uRvqP2kzW+Qo)mudwC zqRHCcp-!flDhrI@pq3@cjBbkNBy&}&t&+MqvLhj-lq{LaaG4@?FgztWNiiienLH(7 z*%K=z@Ju$S|BIdqUFu4yHnWPttCBy;{EcT4$w=-(awW)7CYD_!N?9ofY2@^j3{2!` z4$EMx$vk)ax;&KKV}t}Do3a$Ek$iN11!JBKe=>?UJd*vfWtdaI7}Cx zcBNmsrFEGrEnSim{siYNzsmn;x@{I*#s92Z%nBEK#n>F*D7R`<{T&P_Vzt1m!y9?mZ$cmC_!k8#PZt2p8pcIJp@FXDy!Eo8yy#P06# zZsNMT*Koz{tGM_(t5`Qaq3$b@Ug@7X@|tZ~_o0RwYWwK&htZ1$-rxD?q>heRXoP&@ z=_F)5yNOAvC^I$lp#DH-c&}%85Uc@e`&2iGxaM0t+Y zi|ZJuf^1^IYp;%}f12(nm1hUM8AKW^r9WA>03RCQD1hR+QDWxn0##IG?xj(S{9O&! zxswJQ(MN%GGd$Vdfz>nIb{lEt5CzN`NHNV$8v`mD%>=BNtmy!U|NPJYoD|#KKj*RT z>fM-rZ268o_Sj?joVrIq|1&sg%gdV!Py&Xq#J1M904F{M91A=jxLwk3xcjBRSAf3* z-XUoe_lR{<|6ufILHuq{!`N2Wj%Yhu!(l(cZ+POR*7Z9&Y@8~_XExz@*2+$8$Y zM0S~Qjg@GQQJ~XGHkwB1#%ShI9YE2o+j5P>;xOT^Zggw6+gM80O)ga~nXBb3)fu!f zd0w9679)9^R7vhKN73CHw+JN{Rd$+4F*`)W2hz_Qb zj{~t?O#ES(`XkZY_(Rzx72MIYsa3x*Fadr@#mULa&DlL-nRFB$kmFcvZp8(vNaZ*x z%tgX+$*lkt67JDK=H-U(2se_~P+~U;p;2wgxYt-l2_jz02FWb&Azi9oO#~@Fq-bW9Iwhu6Z)At@o0TqZ;WLh{C$B7+Z^pjEPx%u?=-37M4e zD3=NY5in9OOC}+5zDvZS373)qT?oOwz!OC|qa)-$KH?OXwWca43GI1PU!zFdwu}Q5ba?XGi8EYBsQ*)EyH*wV+PBtb>u=;E_>CkFS!AZd(hmp@tf2 z+sZ$3U{`;1!Nr4vJD1OYF3;X@{~wY;)2%J}brav~oUMuJxci`e{v0@ZV$pnf-l0#>#Val>#Vbo#FL-=WOmp!_uqd%Yu2opuBaOLH{e)z-|!=;`)7~5Lq}h72(9t6Kz{_N8=Z^4lc5NJ1)~+a zEvPUPkFM>qYTdNg4B(ei`5XLGN8bCRsQXYu4YhrB>nhaVW11B+9LXGu$mYZNhV1q* zS>2SQ9tP2@3h0pGh^ibaCZvJx<$n4E^x`^fs+~ib$VtjBZWCfX1|1oim!7+;C!Ad> z;Kj5b!NBs#P=+ujQ{um_~CT$GShFk%_O=}Pfrfz@o z$!OWKx$oDXJcvG5AjQVFoZ-%F9;_JDbdbfVr=EIvUDt0RPs-mSRaN!&H^2GK6B=LB zf)JB6Sc{Xk^r+JpGuy3)pu~?>a}G|F%)Hl=8{Z?8=pT2#UeZ^9myt7P-ZE*|OWplD zvpxP~Xd#j7w3q4 zLu%j%$TzAo)4u^L%1z(ZbC(#TCmWT9!sHur?>l8GF4o+vd(>oUk%-(lY1T(~j0T=i z0VIH4tVRP@#KvU+&&1;ds6yUkY~Vr3d%hJS0~Ez~s{tw?yFy5EMM!FVFd#{(fieF2 z;q$J#W`}3LyrXI%KvWp{$6a6giWjc?_QylERq$BM4^*5nD#<;#cVmztqLPQ$r6y1X zODR&B8L`9KE00*YdV z3pVUPVgaKjYAk3hA9{ON^DUBc1mp6XriDXO1tfx znYEtxkG1!-bI!dNxR(oN9zMgJ*=6lDd-j>VX07jfo`JHGp2+qnKJxM+VUTy}*?&6#Gpx+LiVz@N1*-(c5)pj~{7 zrvdu{+ibsXSC@aaDB=X{Avp2nb%*e@U;pPLkzT@;XbkJIpS%%{`%EtMaaXjQvk%>P z2aDHFE&kTR;@THp(XwWmX{MQG+Ob}61TO=Q{qrOBZ)-2%*~fm*i#yzDH|gc~QsV(1 zLBs6WtrQ;jny>hy+uQF&N9u+}94|Q2;>}mqRbqR3{a1b73y;*-5J%WNj4^QH=%bZx zmUuID0PkXefG5BHtCNFxZ}^(e`SZK$Sn7lhfYtpuUI{#TSJw54$`eTSQiXYE5&xI^ zQ{)53p6qK>RFU8z25i3ds*^k$eB1*%`0GEp40y~LzjMGF$a=NJM4PZ|+05dW?M$IG z7utT)+SGsJ{->RHwO(IsC-5sJy^9)K_XNiJDz|Rk%9&?w_v_?WRM&@pvEAR^hPy+y zkC*g$;F(kaWa#qV0S7<-`OjC{eSr#Hyu!Zv0WRA=XyJ*6Q{zW&F}98iF1UaTF1TQO zMf?Zw65Bu6y)|7bf9T$q>gW$Ymfrf0L-{Kv-S@eC+knfrtprN|=G(|G@^KIR%+fFX>yrp*#X(1f*6Y9z;kEe)*jyj02vnwV=rg%+AvDVk&8 zo>ZzsL<2-B5rGE9QgZ7Mkt&4Y3O7jgxe_%R!>LAR6h}@dIjK5KIOMv`5SXwdC6FVC zI`G`Lm7I_rot=|gSOUN}BA}UoC6emR-AXMiQKC|QU=`QfVZAw89URet5dfqS2%&M` zoC$KVP2MPD+br{4x8(j&s=LJ4`U&JBjhSB6hC_QVulspyzlxC9K#W-%wP_ekLKU5* zfn5QH5U$xB6{BcECD-Xy6`rVMhF#q%0!96#E5l$3-)h^>w?5#qQ$O$@d;RW{6J_yt zww&?FH=X~^k2fV!Ze1%(5y(+$O-p4;nU7TZwp>IO^knB;q6jC~lqb`W$t2X0Erke3 z#VE2|tU^KsQ4+S)1d&p*%OEXQCkypS(S#VdAE;475zf&sL`0+H5@1oRtdK!=mI#%c zRV39njj|&`6$J?klx%C*sI#*gNhNwF=O_f>4!)5~DYZ>nv5fkeIhBxw?NUEYsV0dS z1}exwSk8i=NDg<6vNq-;ch@phiwRIpPVTG169R?7ZU&1|FPuxDUNZemuf5)~lIIxE zU&uAHqr0wB_A0RG88WNb#zLyso%4d!q_L}dJ$uoRxRA>(hCH`f4R!tgz%Q2mnaniP zHAy!E9?(Aj$Zk5ubAg)!mjc%ca6+{;|H1a*nYEL8?Jvr%MI{|DQv?_q{zfkT=szGtKnd zsu$i}_oNPpWAUWT`|us$Eqkgyn={V??gAj_OFZP&U)gb#h0W@9J&w4lt`a+x_!r;^ z!Tq0mR~_(%ulXE+4}HiPxZlnc@tPC;Cg4rGuaY~j*PiI+&+o3&t?e8A=E8+a z4z4k3okorVka+8!uFwB=9sI3xP6O_H=3xgPjLJh~KL|L?6Y1>BNbD!+@3wgEZ_YY= z$LD1N$&^V(AH;r{jCeYr-0|$dk!{|vbT?LSiS)=% z+z|B+Lp}_AB)zpqKv}ipJ%L*HA0Qo%^2hz&qfXtOb)9LZnST4Ub+7_VF$Z%CwU2om z*BTV+#K2OWCKhR(CffC#1I2PT*y*H-oq;$y@L*@7ID(-Y#FEk5l_t0Dj9e|nmkjon z!YV4 z#dUvRGtI~$EyViV=YCDXrH`Y>)&d_I)_WWKMB~6+dvSx5`Lkbc zX7!rF{JM3V3%s&hf8iPq$id$n3B6zZ6rKn_p}K4VaKRI~P5D#az~hIf{JZ< z0fZLsC*`+w`&;}Q@RZ@_*Yxj=%JBE^m(R~1d?fk}@F-y2!T^Ovm$fU~IrKc)P80RA z)vVs76Tq$--?DRi&p?T5j&=(;0bu(KMl(6OWtRhgEa|zx?Wo_4-?x|MlU^A$?Ld6z zG_irb*p#!@Gm7WfoUPc7)5HWcG1o31hbFu{G%+Ym%-OAz#3-60m+BM|O$90j4eHs- zB}EU&cC;hNA$#N)QBs|8-?~gxP$H?uX;hG+fRd4DK?tWB)e!`?5*;wn!4-8o2@y5Y zqe2@{>}W`2+V@6FOv);4@I(bAIy|k`t3&uwccX2;14;*U#26*menWIO-%0whZdHe{ z$CoTsS%Hr$?f+Yrq1LPW7A$|!90lvpT>(L|$x zb7Y$&#h_$0At9+`g;LPNQZ6b=vaATJxF2#O)esLgmNHf@B_iteQ|!p5UXOzkC2AF2 zN<^gAdm<3en?L{nAOJ~3K~&d&+x(3}5ZQ__MRF;lYp9Sbi$ORjqG>Xv$jFpR8P(4r znUWQ5-6trdER_Tu2OOn_hKNETLzA5PgUE`~v;aj(;5>*%Q550&muN${DVf}dITcs; ziF!3V4>}ERCOxGR>hS3~f_lF+vG9B~jZvnpxP$WLT{`NfTk`tf66$B?F#H0M!siVE~ zidJxbe$zjLZaGnmdHOBCea_iew5*wCnrWt)cC2*`U*9y~J;38+{_C9m`PV&FmzUgG z`!dIiyVr)7zUIGo3{3#+YIlj1blFxuykRxRS{&5$cs3QJyw>Uk_tJI490dIH_O^?} zU$is&zWmw~eH9|TcD)Kb2bdF_v-V;>u)`f@x>|J5DQBEPg^OPY6^>mszv+uchwor& zW7xhG=vFp=0>PPw9&j0lZTuGS4Htj2>G6#NzIpa9cURqQUj)3Xg%D0*$Kb?j;NI=y z4U$fwPR{xyaN5<;0WImezze9Z6Ki&2mwDh}z&#|rnd;Ja>29pzP?By&bpn16aF4bw zJF5ab&Gt`rN8QGyCwyW(+tT4kcftHFaA%^~f6RAwXN$U+(z~tSf1mSrPfcfrh<$)ZcCW*HlQD222OCtl_gMW`Pn`UQwG<8;TR#C@m&|+w z8^_+y8RP3E!XCL{l@_M$+DGRCPY|8jWr>U#WrcB+ETeJ77pV#@mqy0@9 ze|`SYN51O3&8!1%Lj_}(sI6+Sv>`C@=M}_XZDGq!-TQaF;l~V;_-)W`11GkpmL%UT zlcq<|1Z-NH6}c$J;yIRsCIB?Qs{UK7g?W!)iZZt(o?{420G-psI5a^EO{j$?=2~b% z9zhf8fQK%c!=q>pT%n29sX|0*;fU5{!d7ujkSHxM(b!T8LnK?p5yHq7q99OFyDqiB zg==_2!IcH600vh3UR}8mwRTViOMzPOp#~pR=wb*-(0((h-g&EMLjBYy8Uah~q1-xP zjJ{e{`sP^XtH<3T0}YwR4sw{>Nkf~9OnVY*0aj}(Vc}@gBxa%2k`rz0 zhpHb(EhdP9FOAjdV;k;rz+*4@!cW|yEkjp|T$>n8WWVpHZ~XT{h!m+5q7lxPO~%oB zV$gRc(S)2u7+Gb2OTw}v3#%Brx;IE(C9_DPvNUchUNEAcBO>G=M=@@+7)5gwWi|bx zoJ=px)vSt;N(`iEM7ByJ=nv9jAVq7eP$G!R`$&?S967g?h@^TI1$OHq0dk2@AfkYi zG9ro{NJXXIi&aBMh5$|_gNE@h6?jo=d6I=vDb4~rB0~*SkmkHPFDikzHS_l1QkB6rC7OxLe_!_D63zplzx6WpR_|t;u$gAMYI-Llr-|*( zpu7rtDzy=PwcGLTQkjpS3Qhq0=ej%csEbd0#Lw?`ljq*}t3UhAPM7n@|2%>*Yh7R~ zy~QgucyZRD2Rt6>Po^sP=8dPG^ZqMR&P+4SG}BBwuhyaAiGO~izTWit_trUKkEq|{ z@xX@m<@eT|#2fciT~^Y+ob3LKj?@c__?XO7pMQ6~5U$oIat>BooP^8U$--v{kimv&wJ zJJbg79{_)#fSlpX!w&p~@hPBF!g12-*!I=^Pu}GbAIDNV&Y}LMIE^~c4=Ycq6>xa_ zcsX#Pq|Z=6ivMgUbL}#kgj6SMPl(~zQfnD7^-Vt&zadQ+k0a3d z>ufweIoCqt8w`i0M(-t{MyfRRz2x!oik1NbCf?9g`(tXoJhgvQ=Vh+6e{vn3SZV+1 z^6^9x2`N#gPSAGiKMg)iAD;@*wv&jZX)vOW9*!1x>7}@|{$u->srQ#n87C2+7%^->h`LLh@p^LX9!B&HlhL*rDY7G)SGu3??Je_ z6(sOG_r2G_|8(6y{6Ck(n(N)L{QB?id+B$6*>+7hxj46g2ACqOY;xVeMKx7KisFIl zeX7QasK{kdAX3<=5-|?BiSV{TQ5QdwZJZzwHIgei7nD+c-Czc#gi<1v>Uxx;sFc2% zNGJl6!w&3z%sH`8N+=aYDdAqDW{_J)lsVZ&b||o{BIgFF$Rcb>3P}Uyl-!h}+$P6l z6-C?RQ>cx73Bu7fm7@A|P}~9+^|MyBYY8e$Aq)za8op71*HR#?kW2+KS|i<<1L!=ROGbl<5mz*KBZIcX5lbp){_p{Vp^Zg8S$@GioT@pA}*amBQTiMpOE!PYdv~3$^739H%ir(H6H`MELT`r-b%yVlun4jOw?7N*mhM8vC zL$bXM*sWIGw*PB)mcKh>J4-sCeYpTYlRrXEucmEre`D<}_;s^>^}dUjKN|Rloi04e z)29gW|L{8>veTWeXZ+3qcarpvQ;Sba8?;Mp?Pi*3rkQ4{9Z)Ykl2?Rz->XjY_W@pW zlHazY{dT*=ACEnM)v;HDHUE{-t55PLUU;P5Z}G^0w;z49?zty{lPfDpdj64YlX&K9 zPx6K1>z;d8-MZ<~!#oIhG4&_-hhKe?zqm&#yNo311xNBvz$(ngUw5K+S3KKHyGXY< z`9~L>dH8`(!TdWw?Z)8*@O`Lb2UkS<3mpX zzzM*2sSXqYoJe)D-JT=Ge!!o!kFAovLUp3JN|7Ft_NBT@EC)<{7q~7pWfLki@hD&; z6}$=0sIj7CUs!!Zosps zktA2HeiM-!99APY^4>e#afk9Zfm?vOYvLdM-Ups|)yth}rkSoLt&?=v3hTzdBkmyS z(jI7RxE=tBg@u>!{oPf;9jeb29&M{m)+?*_^Do`!YSu&za%qPfMjAnZLQ7DH$rlRY z(k_)I2mV8oBhqDR|Kd7rbF@P@Ow+#fSROkyO@5MFsP*hc9n%>UoF+ejiC3#c9-pzL zDR5z-p^T4vS(EF_pxR`wRK6$ABc3Y1K%N*^n+79lw8?hM*ACWWa_3~Bu^1KG{>7ha zGjP^u2QHf0|02XGW9xr91r?kJe17cx{BYv!SZ5(VJY4TM4Zhb0{sGqizXSK$^shg? zj0d|d)FaTQn}0oSMK$(L7oSRX#=C;LYPiJ=kofJfh|-b{2jo% zcO{LylIE$uSSFx}QnYRzY+WovM+vCW9a~#K0#>6^T_rSctt!xOp$UM+?CAI00uqx> z6Z5wEMllXe*cwbZP0&=Qi4K|=jK^~{sFW16&J8M#oYE+UBem`oRO(DMEh>tmMjcdB z1SMBz3c02Y&_WRmohZ=24v{E!Bp?ME0TUIHC@s{HDp{c64bPVA*RxXVC{e0^gt~Lm zT@Kx6Qan690EwW0s#C=>(;LRV`iIdT^#CeNW`)K0mth%O+REzeFY1lZQ#aar9gHG6 zJVYX8Tq89`jumyl-Lj*mV^p_;gu|2W6c&E;O`i3TudTV|J-T!8s_Q-c=zCxG-G6G| zl?Q~W))cmIs}wn? zE))GE&Bp(n*?(yX>)Qjx7N+&3+~OY z_l;Kd3}bLwWSYUw$gmKQ8@wyi|Jh z2{*>W8EmcM?K@kiv+uI;`YQSlCT)c;SBd{~z!%Tly;=1$%{0?Y{|ohkBYBD8g&Cgy z!Xx#h*Pi4R-3G3u?J8~K8D%whGTilmU-DAmulIDFuBh5h zwPhV7dJX?&bG@-eCvItY($!P5ozn~N&I@hsD>$p^^W;5UpP6<}2c3NOf1G*Pfgb{n zZabiFAH-n={~7r4(*T9)EX?hV=X6TIA)rG>5g#|(#GxC%P3ugN?EgOCw6o9IQ9+U# z;O$hybAT@bZ?kPl&u`ZO96@zaxE&QRng%EaO!j$>M|!+b(&>yMJ-)It9o=KV#B+eX zrdEH4`ZxVMKnEXR3OvVlU((|l!3VdbLKo)&f78B(I;-+n;JK3C0=#Nx0SZa`0r#VV z5)YuY;$B9XrJrd5K1%&A{ovU8Puc!pTmIiN`mTM2q|ewseTVgW%xBj!D0ixE5>z*d zXg2PgIsBBYHX?P2+sIe2{u1d);LgqO9Qtcs#!NHKbZye@fs=P)yDvaHMle{i?hHoX zsk=mL8?1yErf7wQg`H2xfcoXT+>mUHIWlYyqG-v4MWep9Xy zs2i=RdoGMwjJIwE?K5M;CEc>(F;E~w1UbXc)om>%9L`i2NPL%ejHN4U z_?8O`B)-_r$n0BOFup#CO%fllSyZsunM=pd#l5d0E&Oq&8-JRt-`pyGwC!^4+XbOSOgi^AeZEtI!-wZKv1xq$Lgt%mf`b4C zra!02@^5%kzI5)7*{96m1Kzo`O>u*_`vkT#M!f$!{hv_FAJ*X=6PtVv_?)!-{rTIZS>YyIRxjM@a`# z+m^4k{hr-<>}j7#t)c#qIRbd7q(`)~PqNMM613|^5gqeV``xbWAt=$WU_-lX4!NjrDj?w&rf>@^ z)Md3kjg{S~*Zv)M&_uS?44o#%p@}w1BU#xkctM3GO6xQs#|VsQqdB@VXrT$);Y1s| zQC%hiS4bi{Kq8d7NDqLalSONr)NUJ8XNlryho?ud#Dt@SQHc(qi0VdxhBi$l>gQBw zSp>Q*mnu==ig9dgT;1{z(AOS|QTkFNo1O|e#KIscnq*2n zHK|xo$VH@Rl#^*|RB{dTuxgq}Wl&XYhmutc6cwqOPFaos zMJlCaQm!AC2$!a@1_P%OmR#LNvMb3#{pb^-xU@Y<1L#XB)oZz-Hh^7flt+&~c}}pc zUYK(%GKe|PXXuxK*7UJrP_L~mTUgV~v9Qp0qXL#74WGmDulbBO@5%b?NUu8CmpUlFYLgFpJ)0hM(y8g~zQH^MC#$>nBA?@Quz^^3zCo4pHNZQbr{}(I;CcaCB zA3oC7<+!nR&#`@8Tla5EdIj)T?Yh6CMra%YJe)~@VnbW6r%U>0YUlfsj(A@4Md@^yp6?g@?{bMtX`rbk9x86gbmN zGtG3Rw7S6y3(Krnghl9ju7_#@%eV==*bXM7z+Emv63#0S3)7Ir&TtWB?BAUQI$C&P z>AcnoFpS`c!Y3sLZjHbL29u-394E-dpe`C>veb8|8hCq|Xon*6Rz#*y028JxV7EIhe5Y;yjo;UIbiB2| z6KubB_f>0Bt>f26fuBO{m6dcbaHQ>b?WSWM0^Gs&`)wCVFQ#5EFX0*%^LTC3RR$+o z+v#^xp@~AZ%lk1kd;A_$OSq$`jqK-M)#GhXa{wFmA{P6@h>mf$iD5)X3skTgD63f< zlvqWDCu&4T8AWse>REG!fvq}CeU3pXF-HXl2DW3rXG{qF00Pk zX%xpXwSQO1j&zvXwsLG8#W8e(pdW4~^Xe8?A?rb@-8YlIInw(`NM-*ug)zhlf>=$bw z5y+UZqQF2_s8~v+#a&zw(YB~U1&SowD7ihkmDDVh_uoe}ub}P3 z{O+oo^27NXaqETiUdj%@2|eYLYjAqf#P0?3278A;AnN|>`)>x_ZEEprHlBL+`>)V@ zm}#b&W}0cI^onoz*U!6~j%X79VK{eP;+heOByKnM{8|x*_4*Ti7IjwjZ=GIqqMxv* z>##kwkjh>6bUkLea=OLIKf36QLpMHI_~QUbPdxL`13q@pspp&kJp1fJH@3 z_J5p)eG0^_k+(BY?_9e%mT0>XA0PbHW#DXI zTbG7ufZ}@XD{Chb4WK3Q+ttaI1Fv^-Ka3Zvt*Z1sEO<+=!KRI`H-O9Nm*i zoBIx!_)FVA1UeVtKOfuX1>EV@utNcd-l%-OUTw<;GFB^%H;}3V=)!uYR4*uy*aHrf${QV9_=L1cEaeA za+Vx=0+Lu}i!tX2b>(zpGKy-C+&NTq2W&@xTo?to50ABsIxm4jH>-By*c00o+H$ zzvE4JiJlMK7I^5G+rz_wqp5Aa-JwTO+r{q(uzjYazoE8^KWzI)yXm;U_1YDV6VIex zu$Ke(v;Ea>g`_#)AAu)R8~U%cef};u<_enUg2jHUZ(pqglt+#d0NYBDT7Y7qtkOcU zRs+>-0$>&Ml|O>soh;Zutbg$ml$e-)y^^+O(s{xT@#EX#Mz2b$CM_ znO9KSMn|`uhl~WR{lTalBS(cCDjLz^D#N3wu6KL4PPLKYV=wr~@qclHKVJ2mi#~b$ z!!G;AxdARBx!`C&nP{UuGL@pS!j#s%LO97~(P|>(Qqv@=>qRO=EsDmpztfGeBnnQ1 zvub=rp--Wg<~$e-B2te`p|QxN(39xfL|8o)7KM7fIhV>~D3?MnvKHMaa;OPYQVq5g z9$r5+F06pYQo5qxEF$-#MC6c!ROHfHI;v1AWMRUQ1f7k>24XB~dfksD7w^Q0Ab-mE8s_Z?euA@gf? z3VJx}&;wtD^u)=f`qV+Ep8XeB=nc#?(@ZnXv_rk%Ub^o3FY%jW?ehAs`iz&{S@$TJ z!LcV_LtF&R?Ydu5rSRQ7TbY?=nrV0I;8V}~#F>X5_RCT!C4d6%gmfp&S7blJ#9GNm8Q&i?){#AeCS1pqE)iP8WHcO1MSL86-3=VI&pLjv zrO&ww{a-wI?{$}*bEg9j7?1d{eW9eM0v~G^Jz3HxY=7GJWz>%1e+Hh;B=B&H_VImc z)W*5M16c|ntYQ@Dv7EjSyassRlm+sOm~_f`^7QP>G5Fw=_BeN?PB432Th=&0@p9nS z?XDd_@#n1EFSd;e8+?-Lg7LWaG2XpafKLN2v;FOE;WE(2mw>m87p|wA(&JH|T*Fyk z_&kcE*ymu_>!vT;F(l!FbqQh>qtAc2v8&TT$Ai8Jz+f47*9lP5nGnyc4MuVD}dTu@TFVyos7uaP4xAX!p zF2dqmEvMIoeoT=QtDBKCNT&_+*wY?a+tFd`@t2lae(bS3H_>UPWpxqDgA-q(w&iX< zwfx4^Hq{4qZ?!au21teeDJO5;(#3uiABgM2%@%-Ijm4?e7C`rM4MgMumcBx)Qn~QA{hT z>*#;QI5YuZdl7gBa1PZF;{NPT&DCEM>lwv#Y{_N#bwBHJR(&Ci-Io_OjLe)X2#JJ$kfX=574O@Q}rkoz$(%2_>5Lxs}^; zvumuz@ZYGvLhI16m1sXm*93zWnuxl-LK9^OMyw1?M2iG;(HsL4%Rv*xsK`M`sX7A$ zMnrw28vUitEuz#QjTXv4*$%f4wcDzKiNi8Vj6D}o>Z_^$V)!VEs1KqjA|e!lqAerp zJvh2Y!qxqweb^4_`-oCVm?-UQ*`XLc5K*M&{JDMC$Pu!lNKxcKjuM0m>Bvo||K`hQ z{N=wq{E}~;hZV(2)kA?~IZ2KpM=4Ipgo2Q&Z3H-ELPbeda#4~ZDkS6ZK*_F;Qj{bo zE2pF^vKuLf=y-P2>nUDE*`|2zwCW66D-O3?gBL2Z0r`m0SWl zqBtcg#Y3C5R}HO93)Ta#9%CDMJdC$Qiq+ zk)3h|GL$f6k{2ZvGoWpvO1&6$hBRfH=5q0TB)jDL9TUk~HR%}9eebLpViH>@gGI5a zLn9#dR(a6hrezW%^d&-&>>r=I<6DQp&p7OWHy+;2aQ7$t)9;aeBS~*iAR0%Kpk_!V|2`?-=t$ceG;24 zxEypc8}EG-2mU_nbyJp=xqv!*{B-bE>P)MBSPIQ-13nKt2k9o1=6>MSP>uth#UwQG z74Ut0+yjoBh9>l=6Mmlxh;$Wrx{rI{Znq?#X{MR3J-X-hCcoDY-gnmxTz5CdxxmwR zw5Edr1`O$mlqZkfF(0XhSC7_>^~y{{aHtNVbjzl}22btl>2Qmu~@nv)4uXos+Hl|q@{hrWomRa^1+xND8YbreP z5Gvq$D)mZx-qlpMhfv+U-Z8f9snl4u>r(;P-v^L%b1I1YHY!B>AmB@qKGwplwA=j~ z@Gao+zkk%zD8x#<9E&s13Nl+ zp@SiCjFs2I5cPm9)Y!&!fPyv<0&ojI3|%GM+0)MSMTR}D-=2WYgwgmCxQUqOlv zlIZ?3!Vx&4v=0a^|6rL%ba2OLe|HE)eS~5NV+_HHK&oyZ5tRLm@1qJ+XdI@%#Mf5c zV!!)ueA#3ERBDt*7*df_v6HH! zNXSl-l8MyFVdW0`NVX!1l3h{?%POe}M+GQKG%BINAevHwqSUy;5+Q{Kif}zKX;4zi zC|n}hLXPATF(`GtvQS+omqbM1dGhG zKw7)1C>l?t1e(RebO|cLTWVS%=>2q01JyExnLxE8OW)(zbutQ9aH$bmO16HonKdPkxQ^ zQ5#P_^BOUTH`7cr&Gg%%qmNdy_`RQEHn!+-XC8jwL#DUec=DO&P5~67AGGoj!k<{!*85zMS08lh+0Q=c zl(TQ_Ty87#Vyv&QbP(l6LWhBG2fhsW%x`l3*r$H8IiIm@MJMI`g^m&&EBuKZT=b(u z54hu-4!qvh$L+U)+pd|rVS**?;GF;{-VJ=4+R+?Th-`bmxz_`a20jE_An9|Go){{T1>IHfKBU&re6IjRT1?wZi} zTd%7c)v`29 z2zhiXDdFVJ2;6*j@%o{!N zUSC*yo4XdJ0Qmd;9(0H2U-n`{jcYd2Ri~3RYIQP#lgn zs3a7HQgC~9xs8O25F%^}Nl|LHTSgQ)*XugTE;%`({p(4I(ce@?Ik|~UQF0j!fJ{R} zrvB;YNG1&s$#V>xY3$M$3k|*AKsn8opqRXk)nk|Q8n&?5tTlt$QPec6yov=j_g1-o z!4_@k!PfaSv+|nh+M=)0HsTm{2<~cqhH62(c}E*w8{~gEtgmA}^-rKzb<5td&mVBi zB`2}EEWGNBo8SCX2mj?dyodhTQ)ey!jA&|h!wIAd%M*z72O zbnv&%U3OO7Of$_i(@a-hAO0}qg?Hy$nEMM{%v+DWhB^C`IrbUr(%bHRWTu&B`t8!e zr<`^CnTH+lUQo61HUIqcyWQl!Z~WDtEt%1`@#Hhl1)hD@;RpS_OL;yTi&Bt}5Pagy zLpOfK;?)QL&rgr1&ZK+w*>~A^{j$g(TICT!_hw>XT-OEuaG#X;gX^r}l+D}t@?~3p z{@8u5b8JfGrr^V{?xyNkFs_u~mJi%}Ef3tgPNdsX$}!)#{ml-)ZWEsYoifPf#9My* zoU@?<6s#QKaU0-YmN`8?pt@3Akw}kB1sJyb+r5qKcrNfoYNz%cSz$67qX>>qQD;{? zgHa^NIx1}Ntm#9v+aGKD)bSO1$|*fI{qpvpBe4(X!Eb*U>#o0QtXuAo6{??s9|5O; zzQb8xxI2R_59Y>qhBeo_1Lh7ZFef#F!}=t*{Ki*(?6CzvkNNC=I_89zqUPD)rI8%g ztNs7(fBXvPq^b;F18i(xUBsfUu34os%{0?BT#vX7=KCv;Bb>o#P;5D5?~+TPX$N06 zvHZ;A`PM?aZ`_R)Eq2>>g$8bn@sNucW+J5)SSZ4&OA#Lf2SiQ9@K|KWFz%v_nieB? zf;RoapcXo){pxK|61a}>)MbXEW!{@d0E0&pZQZS#xI?sXL%9B{76j24_%RJ|RQvOG zeFuNU==~RuppMR2A{e<$M3-w4^}M;@oWW6{ls+)m#;o`2X`(-X)Ej+9#PT<~`P81< zR-2&0GwrO$bG2C-T|`IcHi3=Y zE^i}1I;V+x&u*cKAz0BlR#cD!jX7wP>M*e)Ffjp3tN=+AmS5gwTrHJ*vL1$XCgS^I zlt$ILV-x^uUT{CetyNnA86vtfRKRl#{PSkt>vhlszWApLX=}SsDi@M^)m%gwEee$gJSY)S zlScZvs0opgimeFIkd=+3AUn&F97x4n+N}B6{tLf($aV7OJ8xY0<)xd_>Yx0gxz6`~ z)!X|QSyodVw^;c35!WAFdN*nO^H)yB1-GC@xSlo()JA2rpK>vZaPdG<0>?m6WE1Vx zC>Ju}qK-65l(yBDND0aS?5v1zQwC&bp|Dik4EmI&soYc~_e!5MDDFogFA95$pvNi- zeMF?5D{{4!Xx5s|z&xbXcm2izE`{s#+D00%VPTUlo5u@VFVhX#;ClCaIdJTh z?J2d^uhaIgyZRW<+@0m`CKX11us>U}R`C`pDZK&U!e%ety3c)i?nTGnJod`3pjzlw z^6ydcZ%pR;{eq_V#_b*a%)<_R9MZos*>+pB{fL9U_0z9h>322LOf$_i(~4^I?f?1( zN9w1B8@=u%AGfFLv_zg5kX+9Gbf%eR`Yo1}o@xF+d*>c6*HxGO@9($v%(*2^n>O^8 zwn^Gjd!x`)KtP0Yv!z7@iy|+5k&EJuS3%)@RV>vP1rbnqRZsz|g4m)33YDAOlmewG z0&VFfNmFQ>q)pS@&zYIM*7N?c)}EPja!!(75NPMg=j6=n*?aB1*Pb(L&syL0Jn^Z> zmIFt2I^oZN3m00y0Vviz_JlvBj=!}}fMU)1D^`AG{bq9P#NXfkgkvUVI<2Q0IuAGx zII1ak+>IwLp5Td#CzeBc4{(Fbu5j}=Cwdz#RZj%123w8kN9liY&YE;*(m4q@2}D&H z>sGJaSYkoefUUXp(JTIA#n*3rvzh%JIj-Y8_U>cq0`CW2S>lHwM_>G}5~*<>*;4rl z^K2W)E*5V!v(J$`sy{4gN3QGrZr^AN8Kk%Z_++zvDdX?RGZ6m>IBcG6Zv}oy(x(CJ zg&#c%4^ISp5;?}>EU>Xs7%VzsfkR*;xzl|OvNeR>w@IxhdUj|Gdw*smov?8i~PTa)MKz$^`1P=L|f(^h5 zqr`EP*V52HNP!@f29Nv8DWfeKKo92hp^3hggq5)i?=Kms0V+iKkG)+b#Qe+iDVAeu zKnV@Du>wBKOtM#2^?7-ubo>Vb9BL}2j)I825$!@)#BHhWgGve9jjm9 zeU_sh)-wcr9{Fx<+4wShA@JEvFS9Qn@g9BdK=$)Ps(Z-aSD!2Cs_*x~%+WG(RN4M? zdii~dnZ0hF*PFzKtANh~Z!xpy09OK+OS*ZUZRXS6;X;~=I5%zs!)m^nwII_Jr3PDudO2&tDl^47jtM!}%7}RwcUI#R3=yz64;2uZ zy{vJSC`~|yA_n#ngZ1WfY-q|WgZs_n`KZYTL>PW8MH%k>*Jtl<;55<5hQN+l&;+xg zi3XTRU_Phdrb?VX6*;f=YV8L{Q44y8o~FdvGQMNjb#mR}%5F?19R>CrV98KC-=Z?5kJy%v%7*b?>=jPZ(=iRL4?j)B(ffnUc&mBc}d2%S=k(xNww6 zeMX|WH8CkuljbBvGixYPA(I?a5GY6_lO=&Wsj&)aoG;`i8NpnV8!iRah!#P-mv)F2c_M|Pc(f~cqHBTb)1PO zwvCB7v2EL!*!Bby8y$3P+ji2?#C9^VtuOEI|9lr!H`PyFoKt7@+Iz3PSK-C13zMV3 zt=R=>0~0WJSY_!%Uce0`zT0y{ChN+W0SzHk?mOcN#GKrs%NPcD-CPlWy;$#zqEJbN#YFFVJZ{85XdyD;Ac6O*@ZFmJ9k;G56k^%F_sj9)JD|8#0bv#Vyi69DP+*XUNhdk0WL~Ok zLZ{=E$@f&lvxf^EC>3FWRgo1$FCIB*tB%L}XQfJ$XmqRydj!sAk)CLI@*@Lg7?)cW zQE`($7xiPuV~6Od*st8JpTVl?g5ee&ml|Cv|kQ zgmv?;A|qRoR@ls_%M~f=LTqJ#c|NOBtfrZDiF5nyWH{GXh}RY3!iIRxo^^$RC-K4C zIA0Ioo6ph283lsxLbNPpGfozVM+f;uc@c8Z&PL2@i_6K0>GN-x!oe5;k2J zK69&CD(O#_Y451?4Osf^0#Qf10!sF_(^rk##h;kzvNiVL&FR{dWtJ94V1fvp@#{Hn zRBXDCoxa^qO~#lW4f*6w;!$x2()$NGTuTB42 zDEN)tobpO33t|{11yhOp`m(*d&~@HtKM87?GD4V{jqk)+cXA^S4}ZI~;KszJTTnG`>`AmICh;kG{LZ z7C7CseX8Ax((;3FE9xeWF@;JeI_ZehJcftQt6Kdk56ltcj2K}FH!*0>5<)BEGRo3J zx%umkJc(vr08z)}c&|t*F9DXMbrWEF79y8%IUIbU7Al48CPn8w&=I5yrP(tVbM34^equ!9!QhGydyCb%j~~r>~={LHm}ijcJ;Dp&Oo9~ z6DWqfTxV6hJ*&#T16O!fNCwSXgby{Q;%<-tV4#d^0wg3#4~DG&z`4PqT}U7q5ZQwy zzn|N-{{6kGUg(Bop2d5{`W|dxIGEvHOeR{pXjNW8?O#UINFFwRbOnp>%B0wtc8fJa zZZ$6_Pa8YZ-$f$}ixw7vd!?>t++T$WSjX~b^=V)uU?8n1L%x@^wzFozdvm7|SOuSt zj?J;BI*0VG1iwU-tXD1&TljM^_50}VRXXM+>-DXRLF69<#a8!s$sX(ymj7Vw&T-L! ze?`G*FXso#^_pU{X4gT~OXlSx%emw`ID_ivuxnw0gg4Hw1rB_HZuk4~M{O9G?+?{( zmRVOhBVToKP5yI(SG`Z@i09BsLVzmo(^Ny)RfirIeEMM>E(5Re z*-I`>iTy%3qA$_pot{h1afr z(j`sdeTn6KvF`S(vaIrqI)F;dMqA`#W7q0d+;Lp+c;SDi={_a5xmiW(VPy!>>CPym ze8&JYBL-n09~<+88C71Wm=zD?DNRyw^R+ zqPQyUbK;6cD4^W_SEqN}>tV%;-@{{?U_pD5|OdBu~_HLRLi@r>)-fM zaCYM~>$a)yJ3l6u|GwspBj(Yy;Uzz+tNiCO3RJr1XAn5LpL$Zjw=6B7T>)mmfq31#nqrz5+rGH(WH_ymHh0b!qQdQZ@< z4NNGYB4N}+(k(~EO@O_}D};HM+{Tp65TZP@KR?;0kT=0F4;(YJ%K(iu69m7utp)y^ zjtc#r#Dl9x4F2O6jikJKx$_h=oSk15v>P^?!?Ql`gInntbFs#gRhQ8-H((mKh}Wo$4sA*9N#M<9OO8?QkB>v(-eozgXe zWVd9RgLhe%N1iY^Zh-CXDz9O`m!!GWJt?*H=M@Q73(}M6_S22;Feo<7)v_TNz;hMX ztB7RxnBkQhQQQd`gpm;eA3%2u`KqJ*7xCHP4vj4nVv2HP)NdZ7aY2tY2-4a2YJZi9 z!1+b&Efs`r{7+Q3Pi*}W)~|qtE5R%~*>>4Y#J-;Uv$qp8Ur&$*R)iX|D`K2aP2OAk zDkg8wj`u{$DSnS%NU(vL_p1`#$ap{Err3xq#STe(bTF@p58a*CL=->-kJI(M4Ii1J zx`j$w05KLt_?K@cG;^|}leU6*E8$lUWVsKHSSZM^THBo62IRy4P{%Y9egDUslduNM zk(D#k5SNY>Nf@7MB3TH+XRjE=;Jss~o+EtT$J=W!h+KR{Eke%20z$0#kj{cS(n3GT zc{4qeVT=OZ*$k14LWRAhFhrN8g-7CnF3P4Mx9hIvyD;6&fXmbq5=#x`W zs{i99=Jp3F8faz@rNTZoi@X# zS+y*2PL&-y3|1xbFgF$YUaFacq5Hbl`)K9WuK`gy^5!sF%^L6jYXR&TDM5OJKxzay z@g&kDS^yjw@ZAUlk&==FmrW*dqBhwXs37$XPQ0R0g<_mx)Mr)&dOl$$iVEUKQu0q| zjB*wFc?z9$4>4(YYe-r(XRe}6dmCt#$XUG43~7>()Sr~!X%_YI@rf02=T>?7?S`5+ zPKerdf0vejk%Z$svaZ)o{)hay9+b(1u?&Wn~Db7Id4YK|WI8I-{F zZ}Q}1ra6F0@~@wXYTAEfs(9l$GSo(Eys<4Kbn7coChi5)@a~1QlwlfnfeBrk8wcot zMH)f@l?`gRT)jW{_H7*WA>S5;8@`NRs_IH6v5ylb8cSsP_(M*n7pn}s27Xj%>Rq4c zw!EE=G+%gsShig55aNGLULv|5n~Tfn^wvFU>O~;pnFV^!t7R?{5YIVz2-Z)Qldqvy z03DSC)_-)Rcej=7Eu9}bZvZdKzBpf-nWUUwV6ZLX^J1RKM*^ZirN!mSZvx;KxSs`H?C>~(zt)a5w6DrPyd#N)ZZ ztL@v5srQg{1mSg+*TsEZxb#6jk#oh>>q7El{+KwZCa_xQ<&S{lW(=6cw7YZRtLms9 zC@p=(+Td;MH<7CmL@oAL>M{LucqU)-IPvzPwdUZ9ElZ*J=}R=f2c3EJcmmxxleY%m zdNppsSKMX3c_V0N>r;z_&I@N>^Qo|)DwU+co-YVjX*gv$s?o+R%$t=sGfknV6r|s9 zr)q~mMnZ}L+q7GQcQF_l;*Oz2-SEUz5o7pE<-+Vdp~_mNC~B$N3wVyGs(%mLnOt?C zC?@{|>@f(yni!?74OT9Nkw#MK6b|-q&4gx{Dz0SeAqgpe4a6Ye*0%ng@(k7GXKaPBsDWKEdh>Q43`d^Xr@TgtpPsR(pI4d6J#se427 zLw`CnIGvtV4ydSc@GbKji9Wje4oyuYhbb8zHTvinf4OI%>W|lzvNAJBEaklhA-*}; zUxzagAiEU*>FZCB4y};Ba@_k<+6Qz-v;8y-E&A7fo0W|>gW$*+>Y2#d{y7GjenOJP z;!zca){zW;4bB{^lL0zy#I+alDds2QrrpL3cLBm}bbZ=zam22Xf|$e{_u?xA9NrWY zU>!-8?B@!rkhz(FC9{^38^F!QQUj~pdWGWV}m3EeZ^-MTnHW3Utb)%4ty^Jax+XNRGx2X z=DKkqkMd-|w!SsCY;Q;^r-zDl%~W1C*T8Ldq2wlq90Dl!Wh z)2t(AqqQa(t#*7->A3JYg{-ih?1`>la}a=$*4?gBM~qNMW@EKngLi27v0{Bi9=vO2 zu}@udgHXTRT5cWTd@(xK7T_K$k6_f^FwxI<{~vSXXD@sdd}V!oj_bi}_?Ud*Uog2S zdw9tZj9H1gLz!OX?z~!Ds31y_>Ir@RG`ehdM!&h$)bF^!`!BLekaz)>avEqwOavt* zdtRWhvV*h3dHlBg59S6`{x6CJjP%H*3W#4UdF`ySX}+JrEmij@qJA4HG9eAz9YOTF zTeGZgeZYlP1l}Fn`6Xp?$(~Fja^Ga|J}`eN_bx!D#N=;p1RZ&70KYh&$OzTV?p}JLAfGvTpeZgkMfD`Slb{7`WnV}H;I3V8EolE$Sm)*8-Id>%9B))%wvf)j^ zIbCLn4QXbVt2C`mbG-NM{MoXL(|4P1P5NxQ)f*ey8r_dey`itAiEE<`vLmC&m;+q* z;jB1IHZaX}tEy=$PKw?YkovXRNequ()Gu^%q!Y7>bDarfpqYDljWfj&2LlTq|28*|C zRnN1UfK)BPjJ95=2lGMVEn*{xUIRz%OzRVV(Yc`y`AfmazAV3=|7{qQD~sdo`+D>7 zl>T1{-oE*at!y8@ec>mC5?>sTTbxA5%?V@-wjt;|6&QTHe|g|AB0~JEX0u}IA<5vs z|9!uC3QEq46fja6#+}zn!l(Qw=>0b2XtK>VOWZ}~pbfk~?}y#P_VXl*I|uCzvcP8i z>kwmSME*Ul(lC9PUe!yEBxHQ>X6wi(Q`8BQPI4)?DaSl1C{5dgHRg5_YwfHjnN7%d zrB~x;Wb!1dFp)su7U&*RJaM|GpF9j>j}8{4Tl(v*8G<^xfIC8^E`J%UGF??Z<(l_T zfxPeOmHyj-c`tOy%}~?h)kj&jUfuD5t>CW1^XrZsr^7ZwG$l^XR>dZYUJm5N+~9n8 zn}CozB5woVCnlRuMIrCx*+DOJ=`*AB>x)$z7WW9KpMd(0es6?DGt|G-dL~E%6N?;h zM(Q5(9LP8H73JN>FR@~Pg#{CY00nKvipus%FV*%`-i>CmR02(zuy2M`n$4wdO7#4{ zJ}ByLi{@=Dchi=DYQT9#!w1iRI}M6h24|?dYhc7KP2Eg8+dj%Yi-()axTWzQ>qdUwz0_gn7cO)AdqAlyN(Z{IA+vhZn5 zF6eY~qpMp<)>Mp?W%|G&swo-@2}YC;qDT}I_S50>tr8LQauKK0M5J5u3AiBDQ+EpX zXH@G0%VgQ}g_)C{#n=l{)iE<-Rp492Czhy4WZmk=`%)BS^0TFc>*h9bsk+5)fD>{Q zw-9M+LiI8ut{2`f;J-P=si$pQw~HTcCR!Si+oSd=qMoOFWhJLewV4g)J4)x72# z*6VVllnSg3mXL~s)*WH@lkrbqB+syA$H)8ZKb(|85&bH4?5OEr>z7=t^_0e7=a^ew zW^L~az9&|{`V+5xP!MMXaT>xN{}*Q0&i2{-Np3Nv_}szptIxN&!IOb0(Vw| z_hpt;!3z=OpBAmrZ5uW`!I1iW`Q+WX9yJ%|mn0N+wM8R6348v#@>zET-_D6MyClG= z1ROsDBf51|YhV@Vr`_Yr4ZVd9{zuQxMPXy|^f!ES_|!=e+6=d>=d*+A;x{OhH;Am# zme$$6EAvEl@#QKn&8RRI=pIQoClE*)-;vW|aDXAw7(pN<$HNk2)P-8`m7=hMHJC7m z?fuN9H`E!Q&%87519m3qh=L<~a#J3#pi6>Y zMy$UcK?h#@iUpT$uL%@@l}m_E4XhZ*8qNkq$N-MUlY`!x^O9D@#Ek(BNKKR}m;f^%O*_sXsN$3z4-mm%5h9V4Y6Pi_D-#@A&`JZ#`V-+y zcm(<ItKEG)_k4m06q}0|IS-2=_WxGAUWZB3N$Gi$~ueL zh?2{zy5G?A8Zp_NF0Y!%$M$O%#!6|alOC7^-R#%o)2A~(*)!s(0slRI#V$Ga385!R z!snP30Y!sW7xQW&EN}yzweU)|PQL2w!5AQjy3PPP5@m6I{JB1PzbPwQJG=6(>urcD zsIj1ov3Z^aX;oNfJG>@!Cf+WWHCe7=Q2`fIpXY_XLR%1;)V?5A0*OdGEqVF(M0)MS zk>ov3x%%%)(fxa1h#;U9d|M$t&B_q=Cj-~}KL?{X#)HkV?~2QQY&|YZ;oM~| zM`Pm;wg(T!eSfX5xNIb!1~6OJ|7u%R{V&&_aM9!c8qsNt&3CV^*nHHp7uEinZ_^k~ zoT$fP(>{??YoA(@7aP(`;ZGFFR4&&wwNZNX-syx=qCsrz8K^lA${79 z7WIj09iPQ=!LKq)74fQ}q0tA=z_x7tY_| zSp}+tCD!##lI2yUA!o08r8Z%BBmZCO2vN)U=~ZFJ>B||=^JeFVAmj4cGjGyGr2+f! ziTH1O&~c$%%5}>4S%ndonsjD(O9Hzo)7w8JEgJ~aj7^}WN=$Z`mrV~QuBA8VtP}8% zPhUz^lh5Ij!uWjbgQc^<_%@Hh)aeW{H(B_i)~UmO8JQ?`?-sJyW8z-+ah-+#;KMNR z>ebitqhQE}`zX66qvWh6xaS%i5mg3W)lk4f&NBI!s3*vdBJDD#>3T=VYNR zerBqgWd8X{7kHZV({RL{=`vtZepJDTRg`^|tnnJ}0wO#IfwK3KS{6?z&*a51jKVCX?&G;I}M)1t^ZuEgpEb%gkq)AZv_f za^7jTj}BX@J`_IM!qJ+ zaH^-2A`N{x#ijE>Q@fzXGl-`pjr}nj7A^AX@o z+>0KnJ$gvg)h9`{mxMVkO;}>{T)c{@^tSs|blyy^av@e1eVUK^+>xAyA|2PP z{U3l(>Wl838_CIae|kElvxaG&)B6C~$%2txcmgCr1_8OPxFeM@%8?1~) z*kV%}zki7$!BS;_oX3QGc)L4Al6j)2432O@2%Ft`K}l6tXB+&+cPfT4hDD1_x@rX6 z497$U{1ik@C3VU_SY4qu5}pSU=_XWSAPWvE@KCz(6B!yT&7ndxxIO6ORwnGmgmQ8p z-GG~1@5gJdXyVs|jm1sM3MUr^@k+5JjQOVcvM%2dTs@-DHVQeS!eqIi5NO&U2o4!x zB5T#Ed3a%#VY!)yK()E@;ON3;*deVbGxp&GyY~4;mKyfO=c+CqB!nq_XVg2U>tjumc!Qh9>El`G0s)y>n#)|KF$**>3H;O~c)`Y*%; zcWA)Yd-(jO8u$DKRz4rowjC#FC^aq9TgN;--N@cU*EWlvN{E~PV?yuDCoMo*!M)*2 zFiytqyA$eV)h+iFf2*5C^t-T&8_7+JFRsbF1ZUW0KGMEG?+<>)w*R_xRIT520!>}1 z9dHau`}pKg*);+BIGdq++m%HTEcM%||DArdOU_7S_wR3$W%Uz`WtI0{5EurSWK~-O z)s|t-dF_7k7^nQ;a9Ps1cD4izHMs)TvD+z8g9%%OrmxJQ=GpOi+l}(pawC2(h>kVa zkLXHon_?7|xI`h=Y1ORbEt=y3y@7qlo%t&1S<<#OyavNLktX#0iL)KG z%MT=Y_INHqGZukDphza9praN?TBnxrqe=B^eYyH$O;7a~NDO;`6SrEQDTbov6~Pzb z6;P$esPA0Bisih*Mw_DvMddzFO{!(F#wm4vvx!rlbf9WAz<1d~K4j>?4upLZt45xR zcUqvg-?MA!$>3rLz-M!5VVOn!-hpCd(#95Kq?!iso75xz#ngrTME7iJolv9^x9-ksxoX(1>ol31P7@GoWmbua4CW1aj*B`lPJ zRC}7R!8l5E@p=<)k^dgo4i)4B1z_44kX|edqrS_>uBaETQ;an;=r(iy*Sg8<4}bsa zU3}Bax!A8XM79ICPiO69R3#$PsW6`X(b%6~$&fSUpl`Ir|N4GJkdVV9me}T>j3r7N zbnHme{)`oehBhH0A6`#PT(_-NV3wuz(NCT!|0{y+*Mhvu~bi z15SqL8T?l$O`mowqZP^AldQ~B8`FJYAFYVxl52QH%=GEi-sSuA#cv)k@vnGN%n0#} z+I2NZ1pRBrC!cZ>1%8~RS`d4v$!gl#65fzc>Wn;GXrp9uBE>pwe+@q7e~gH2La|3K zEmrR~PfKRZJQp&Sak&ZQPi}A%(jZeefir@8*7&vfLdB(;@2vU5i@A)G0bO`-rRfCt z;)bQ1j2pBafiv2IJ-|VzT6@MUL7^i~LRK*jJv>mkr>Szls7^bFz|%fd#-~i}cnt3L zSE0;h7ch5f;HCR|HPN$X;4Mqn;s}HoqtJ}k_6o;Ni}fAE6$huK+4Yn#G;s%S*jABa zO%s_&k*Wt;%9KHzwt-aK)2&Yan!2}0O}1As>eiiT^5b9lt~K2)8YRryaZ6_!}I0FEz`H&|Ct#opq4D!L^Zl3P@F&qt zD(}UCpU3&r)RCg@N1juIrpnJUq$#0SSQ=0zbZ0z)X%DPP+iRx6 zZiYVF@z?eKdbu}T9^kbv_DZb?v{KCGTse#`qit3o9CO0M)~*}kyUKo4F?L3i5oGIZ>9 zNy}G-?$?8%btev6Jr|U+Zt$n;8|zG4{C70ASIcb^>C;1ci*M;qZV&ZC`}BGN#~i+U ziNjMbEub@a>Cd+5+pV0~4F4aHX?y%o0ik!I_xz6krGO2}K}NQ&v*LfE>JSvf^#py^ zjgSro_Pw=y1~(y1-%XnT=IRt;!5fv&mx zLS|k%V!PK_Op=g|IYG$H^!bdZydZOfb{hF>a-w0bcRt@A-N~2BC}&{0AG2haOU;Xpa^-f&!kmzLt3Odb& ztqReUvu*|04Fe%4|>)`@O5svUGrL`~8Mb;@UH`NpJNKBN$& zWL{Ks-wSEHf=GLVbt7p+SPq6qqS<}?8p;D{JbxG9jFA=3^cdn0C<0ZC zVk@w4)iAjg2+fCWnaNFlBz2Zc@sF`qo3QB zi*ys8H`0H~RD)#$ssDhtoUwt6%-a20bxO?RDYksn4{EgX@>^oFsBAi~wzh7Vps0Z3 zu1}ZmW+-0{qJh$^5|g583sM(R)>6aN9}{+)2Cbd2l{AeSQ-DXQK$pUl`*Ia0BXWr> zC}>dQ3h%{w(7*0l5>Ge|Ii1s<qs3W4#73>JudouC!|1;QYiW4kpA!G2@>P08<`(fW!Ag6z1K$J zMZgcdr?OXFAmE*$jSZK??sy16vCDk`dlBfhn_2s!iR7OI@r@m9sGUvISJkrWr3Xof z1xoJCU!YpM9l;a-3R!y2!hIUHmgr z8lt)oLje;wuCwEtm2;n`vj={?o{|prtIJ;M(FRmvZO#t0C8A&dUkk9?ob!>Uxxv}6 zC!N!MRIE7z^o9=yswtm;lDj%(942J*^4Ls!Ybe(2vCN$wPo5cxmbAF7pPQBt^L*r4 z+AhH1lR405$|bNh#6eG$;JvaS2Q<3enSM!hjNal4j4vx)ovDYHg5s{L9=FC?1g@&{ zmJCRbo!NZQyf}AP%)RhES*~0x9)!cdBHtm<>jlRX2#!qL$F6&M_U+qyI2uOQw=NwX zb``Uryx)z2{53zXDw`flD*saw>{Lxdx{S4AM!_<|4?w=?j{UYMixELlMbM5phxxA- z%^7L|R^uY+)gi$zsV}1@$=gAz7GwrTokyYut-`fiMT#BiK1JJN^7JEmKb7|oH}auW z=F%N~DFG0&dl)~e`h+Ml_3w)HBC%kgE6W6MP4B$VoqU}X$Xptlrq1_k62+1{#n+J+t4EU-36jsa&KuT;fVn{99x`t4Md$GBU|^ev z3?^^Kwg0ssW%``aB+?xQXXSD0Ov(O>rs?KhcU|IfYA%@2pUH%-Cwvh?4~2j=&?Qwg zZKKnDj^c92t7{wLhQrIZW@I7LaEd4VsLJ^sx|*6dK5Hs|;B(lpen2GqGA?X(ZD z?Mt5Maq*g08jiuevr(<$cpg25)nTLQ6zf=DFbLJ4PrXlNy1Kt-qBE=oT;tc!qaFs$ zi%Y=jRGsN4%WBw$$nmRoP=QE1<@>F6&0FsE;5Hfgix_pC^q}>JD#j^4Vv$pNC2!$3En*Bgnl;uGi z*N0n2)OIft0`7A3Eha>d5@uddd0+nV^7pxR%tqdK8FM#w}vz znSXsy+wG;Ulyy#my6yy0wV+YojwlS_)xofA_UPh#ZSch4y}k>Jy^H# zV~GhaiWAq(wP>@x)un=>#f&yxn{`ZvHHwnE$!8>mUqospLm0LM@FOLU0??scM3PX- zY`tB$IsEvrek|UykI9dcS|yzuY0)If<{>wWfpn!v%|(`S&!9C$J@F_`wr`WFXZJIl zVFBoJ`H0!K+t^~irY*nGxPsFD%aWswgEFavg27mWQd3P0EGk|vPs=q317t=OL1W_o zTc@6CMHGv&1xQJY8VsT!FUL$ulwRZvwQt)_HDf8e3H-;RQJ~f2qdq`*YIYa3Ky1MQ!fn~Z*S!`oW9%Lspb~p z5CH;>|7s}wz_&we9NO?b2PQ4E?>_Z54Dn%T0wuNGbDtIk34E5Zk$^>A!uuUTEh>Q# zc?SWAeE6R0u78&&mh8MSuZ+XbOXQm4Y{~c)G70329RH0tb)Jm=Mm=L~eaxTS$Z2nE zxl8C0jSZK~S~Pu*<0oq1P1l1@5^TPTpl5A9s=kQGmiORuKe|63QLN!VDYM0m3}Ui| zCYptp4MGsc_CK62*dyHVURrXWWN5cnmh}orw)A?5uAp39Y@)ZOtaCD;@oAdfKV0gf;-EAcyK#_L`uj+=$4M7Xx_un@Ad5SDQ( z;N19vykN>;?6J*NEW@ZF%D@%W3d&P<;CS*GbH%v?FI{gq)JE^Ql=IYjBeDZ^taxh+ zV=j*S5}jQCQLMI-FAcyPwj{SdOCcNZO;wE9*Nw!JH+O&IE2^yLqpV(kGnxANM(m6@ zkPuL@#@Rh@pX`Zu(L_Tu=gJT$rZB((x-V`y%wIvkgIJ#tI%R|;ViGzB5h zzd02p8@QC%w*r}3xE44^lvU8-K!^SS{Cr=26jlDx+T~g~V5CKq8L?uyXI~*l z#~diG*CD&=);GJ&y9rxcwvu5o6=JDflqrmv7i+}+%MJYpX9JKnpq5Qh&F4M=RxZ@5 zE#c06Td?)a$3}9&pe%<_B+({oEij|ix!Y#JRG5**@a!LR!n+B{q!tGSE3fKlLJgoX zst(i3J=aN!uZy77+wLUyX1XG_AX?lN@PZ~2>o0$IP%eCV*oA9**%O7D&8C2tK!wr% z#Dcf_`liBYQS2tbygqSWij`M33vBn>j9UaYw5ly)udUVz)jlRHRB7Y<1m~h(2~R2N z7L2k1H3P1e<51)!pmnGBdhZdc!0Y*Qg1IgabkMzg+JTHbpWS1Nz*60bV2O$c6}ak& z#Y7=QC=F%<>U!dKo6n+e`E^L?ZJSwSC;^=EiL$U3;#KQ$(`O3W;CCog6(#9hW`OdJ ztE^h2&u-}jzsGRM7<~~&sgq;N#~XK?7Q~RzVQdKnx<=ca=wdIO0tr@cJ~bON9a>X| zoUt8v&4~VlRFpAfxOkzI} zHqo=;R@a^Y*1f{^)y)&<_9sYxCt+#5F%%jM{`VY{Uh~u4$Pc`|PrKDA>WhsSEEp<0 zLMY#O0w#h$^q?)G$h+;Y__wZ8f5-&|uzJ-gTGBoe*PkJzxD-R|bCwaI z-s3qSJu;)X3sUN<_nKB&9gMx)oUqF=>^nTATJ}cBUbZuYrLTe9L}0LiR>&dPgNqvJ z@tGn`^5DxaC*oxd(Jcj>O>7+x{&1iG5XgQ~7&k;w$|is8_A<-+#-adRjusGjZ+V zT|W_fn7bQ`dw;dl)kg2G?bsQ(yk~48vnap$9}|Y;(pW8-TQq7^RPY$#NVvFEV>tAi zcvzQce?D;;xH#mzK;)v5Rk%^K`uOZp+4)e%L`;N8wC8OIS|5@9~I1ZPK589Oma}@8-b!!keFCqt0V@FA_#jf zLB8n#2o9Ihikx!LWFA-qTTVcWoJCCqp)x)*sO8io1vl)C3ru(G=M5TrBbot11|SeZ zjx3t`;%UL<4iXbIB}O^uO_Rz(*aYrnsH+YUi^Pi4-#-id-s;#3Sk03(%=ZCPyN1m> zoIYGjqkNHUw!#*qE+yCu*p_^~N(E#~xrbZ9=yr?w>vBC3_1IekFdk1mHxnP{Redoy z@ZQ*S=B7W{y(S*#t0{XjjWpQj%5pYp%Vw#U6{?r2jW-)(yZqjZW>3L3aSRpn3Pqa^O*t`3D7?bi&w#Q|E!%qV zz^2$a;-YFo=ZHzuPrB2e%vYj<$g5OZsJ$?m>u*g!qhulG zyqB$8P0+1m!so23p+|E=1&F0+NwKJB13e|YzF@Jg9ENlwH6t&lUV~J24yg7DrwBc= z=8ZR}g4v-w&3MA+J069)+i<2J@eKm3AZ1sqMJTL(x8q`QNP0Te(@0R&|0x2aFjFr6 z{?%>kK*Y4Bp5_%0(9=|Lg6JV*e+UMEqyVRY6JBHHM2@zmcaM^}jpY0x)3On{+_^!R zzflv}{6x3Gxg40g%vs6=5gUU_3L(RoBu#=I0Y|aEj_ARys(ya&vnjZ^dNj}Tct|x9 zBD6gHo~5XM?zB+uXH%nd+5wa_s8<@VBWHJOftmY~S4WMmY$WP9@{M?R?Mbm>y5=5M zh;K~G#yLX4C56cLv!H#qfDaA*jh>oF?`)?C7>kI^!s&1)==aQCCSPNHx`v0C+a%2(iFJ^%!BB8P!qo;j~`HC)0FY) z{NXf?Njucr!^>q3#lY2J&QEn7&-E;zwF&ki=OJT_?&F`BlPdkeLP!9GWwlmTq*fjN ziS*1v^{C8{6Gck1+b{`k;*%LlaY9y04gkcj~PIJBDCWAjAh zjirYp1Gf!*i-!hm2GGXKy6K_etKW#-R@aXd`yk0_l;?Z4*rRGmf>&q{pMxX;uhX^D z&V>s-%f)*BxLpWW!>NKth)c-L*EWQJw*m*gJ>6;lg5!KKKFsU5`sa6lY{o%u;!Knc z0VO>r8<#iY!!zPVUSLB_@}A^$p(C22Il^(RLxyHGckRtEJ#yvS{Pc#q2Tbcu;@ngx zuRH&(qPzZGaNK0hb734~mfvpnBr@+=p}J+<Qe>EHRa z1(K;wICqW|`mX%DdS{)c-#dajxVj50J+?SR@cM$@wUS6+Xq5AR`a+-Bm4RWXvg7va zMHP#(;|^GiIc2^Er;NoL8|`om7Yw^uQB@bbkYiZF?=0l?w~v$>1*Zw) z8~`4b`(TUEj(1AiwbHVjYW!C?thxkhl*C{aLFK=xEU-q~=e}m8LLj!*)SRB=$_4+Z zBRE;7qPdjC!oP%M3Jk?hV7pOEog8-k&Q?c=TO{lTU}kqVSzYuvz&9ESM%`m!Cuh$h zL4p?|6}55Gqo@%w`vaf_zCI4bo?B_^j@Umy++O_=cb$-X&+&*3 z2mpUFv~<3lus@JT6Xb1JlePCl6}&CoG8YU)^5j?jh@tjJ^W^9qbC}WZ)qnI-hSal1 zy1ESF%DJMtpY1{svT%oh&fv~tYzLsxK6-8kEScXXd$tC6ErWaWpWW9&P#5R^?u|Vt zEE4}m#+yoR>z{7ome}>1I@(!N=gYp$rhYaH2_I$k$~crdivyY242X7bjGmXrGFfj7 zt7wF`UlvyadC2Ptk;H*zSBtDzno>35uIAZ4uZ4dz%uu|Y8k#6R?#!W01d-^$m7P^z zWq50!b60t8p=r-d5?N@NauqPZ~ZayWxQ2uc&c7gj^~~ zHH5N~ZF%55ek-M|WN#=;IMTQ*=dczOq0>qC_B6vHk-A)3 zIwXnzc>j1qaigrM#MZAT-1ZI^1BY?Mj5SpHJJqceX;YY-29LHGCalxf$g=ok77vc} zeRz7!D#S7&ENzN01~V#_DpW_|UkL3JR_2^)b6WNdDUlv?StYg1NMoZ7&Wwgl7uuBj z=9n6!lPHZ1!Zz6~>!iyp!3&T=kV(hoNU-=Ze^)tA7fvg5EFRdmUr#5t5+h@t)1C=F zLrgL`Q}4vrpdU{b{sTe7aw>o#a@HgG7R1|FGm3q-&1(~-Z1hq%;cIE^7ew04j%oV& z9~4sqKhV|%z$gZQ9&@3V-A|Qqeh*)4yasR%+n@REhtlaDoIdnCx-&OzcuR?Rt zb8qwa+xGR^a~`_8l`h?_c^rOWQs7qibwtTK$S}w6Z^y@hybr7$I2Do4JOsyW?dy6M z-@!tSY3sSK4Brs0KDNRz3Y#mKl-U%{))=%+i_`TIcx0 z$uA4N~w<3cYd>BEBFk{eF!4VZ0>%vXgz$~UhH9+Q4LbeTp%g zTf;s60G4jtNz;{J4^#R?v8M2L@VZv>-@+SulT;2OOiSvicCY04^O+Dg!?u2FeZa#3 zx;_cKmXen}fgoXg7 z4Ge8oUO7ABbTqfPl_~@-4cjxfUFZ**s&Oed8^M@ce`omh>#C4P1(gQp3 zmbh=-fk|7rDQkw-f>yiyIRRx|NAq0A1Cm|672S^XpVBjCOts=Q1rs25umFjm;5?AM zUr-@$&?8`Ft9EDkUWLskyYQ4KIRC->+kYqs*4!4wZM61R;k@daAp17ttJ98A7aVJy zL$MZbdym7G-LhgKqJKS7Jx);x5m(p=nEuD&AIsRz0An+`HmDyR-T2GaF(%l`*QgXJ z3o9ecDl~yb<@AP1DVtLeQc+7cb&QQh`vxsLsD3P|q}JAI!!LhOTRYuMCEY8ro-Yxc zGEe9*L1sC5qQXlhm0tO>BWTarSamE(7bYda$SeXvjs$>!z!ZzYV`jeIv7V{ETek=f zw4p6L{rU zhJfjS_}EGm3*XuFOY+|72AU!ah`LW3tlU&q7|%`+(9gNAdVU*x z1x`9gm;6RApDNf}_ZANqX>hz16KM3?{#fKF@Vj-S&UapIZ(75+<=r*Q{~FFq#mu#(9Aw;kh&2mN*Ed#c1o zm08C&L~z5GBXytNmp64eA2b<%pU1NNg5yHI>dSzR?JRNv)TQolvdJbn;HVdE!4LA8 zU9fUC&B^cV8?%$&-#iK8Nqqk4Y}?rQY`3qS`HmCx52sz`g$GvwM(Jc8CHSfyFcKuV z017D;nLaoBu{ZhG%JzX=G01gk{o`H2muTPM{*!VH#R3U?Ho0d3v2_yo}(68O{wCIMUGkQq|Dn!JO^zHL(ofIqO1!U z$q%YIrD2`=&{bi7$@;@bHP*W=XOOH=cA^dR;J8(vO0<;cPg zK>x5mD(aDTXIu%mi^)2LG0Qavu&~d89W!OfjKHk z7!Saz5YStF?_9`(p^VFYzc)%&FhHaWYnOPJkn^N7=kj#_k|5vg&w10-92v)fQyaV* zQN@>0v9mOR-vQpQNxg$3i%bF4^1rqTHjwOBzw_+eLufTIVK2>F1s{aOP2(P$yL~@J_ZJ%+3QJ~=lX6v62n)BOs^!uvWFM6= z)#_#4L}n8_lh$NquI*5Eh+ve?4DV7vp8??(a`Id`lrDX@LQ(kP#PDesUF2{-=!`Q~ zu{-}>4&0TDOEOb&+4+ee>c#E*DyoWyGQYf!Wbd>0C(h=M)$h|_qWh>|7f25wNu_Qd z0nbNV=7vKuB`Uqv>!(L@XcvH!R}<+htRr;5siCG7=4-lB(X#ErV1aBAuMz{z4r{Sp z#9PM4Ks}8l8mC~o$w@tpt)<52LxZJigd|Usp-?kvCeYmQ0Yn;Kj6|tGf==eoVfUP#7J(j zeC6Lv(b#acIhB=|sO8h!syP+(qXNiK`7rVt*l_lw7#(f}tX2 za?^7@p&3~4W)jFNIf%Xg7UP|-Sy@TXt#2k0hyJ?@{IB>0p#84kXboD2*L$Cg{QJD# zdH*l6OT`Rb*0Sk+afBZY_5lJKSGw>WZvWs#%*y4WoYS^CkDhPXmT=qJ*nSZDOiUMN zcqe1>Y6iI~kq)?3nsYCfm>ZQO3%{T{bn1El_PI=zC`%NHr zH5bng@Y_#S47n{GbF8B7bhnQR{*Ms%8a1ptCsFqk=-JIq&}!W$il1+L3C{l8ISB#F zyKMtpESXnbvni1E#98x=je(t^kJpF(DjqK`zvp#vpEEoJ-Hv_mB%OpW%52)-6#-+n z^{nl3WhsJSld#{GZ9sOmj=N#U5?Ij}*I1gszomKBt|w!6n_~TacUcVY7ZbCh<&JF- zKfZpV`ggI8d*`3fy@Wm(*F)ee+_P&0R1Jl1-B|$yNACQ)XnaivQLbzc0axO1&Vhke z!EX}(E=~f@#m{R0BPWC%_vY9u;=KA&Z)M?*Vgp{@$Ua|<$~{7lCCn|r9$>Q01al0z zF}sqX>q`$oQ zBFrdmmPSF|+HN)2FbjORQH|Om99;w>>0s{!JTlQeH4OxT>K7o=d8RC5n-bs8q2)2r zE}w*`!u2>DTu?Cxov$ejIY=K)EDh1kch&}-K}pJ51BR=tG%(}Kh=N>cqaS;$ zTqKM0w8fV+IuN^BZldpk*hgJ~d@EV4Q%5|tKdF0CNg!A%;p!5udCPSa9_kz5lDCIA&lPir}8j)V< z1+$+{48Id+&YAVSF`hr$K0r*l-|?938ycX+&cV?a6P}2Igcc&{87(axXtNfvd`(ua zzgk`ayGWb7Uxwth7p*bHGs=lif*Xc#sIr%3U4~B#4V%5p9dX1twKw+5ne3HX zim3+0mLf3V>7mQn_#pwMc`sqm%GJ1*EZSDdxDh&=v|!ezldv)cZtD&vswpagW{ofm ztvwE;N2v6Q1Q{Sb9!?o&GZAP|$}P)4VNlwwoi@oJ^SkT6N-QFq)1Fv%NkXUe0mQ5x zL5xOpqsmPmw4|O(N4kh9E(`kR{k@h;;QU0~&)Q=2cV}oOOZZYob1=Mu=5N3mIMUGV zfOyzo`ZWpNLk!Q7(;{aeYVE}21e`op&u8`J*HHl3?@>aKV+8$VTLks;6f>wzlJeKR z#X*3_TP_w{03*YspyGU9t2l3Faen<_J0*ighYObe9{aSl$*MlK7XN2TBDXN2q5v>~1u zFGr;F7|2RBWol?EMj`@Z(8UI$HCfTal~hqKrG5Mkcs$G-Z-KS|U@G$RoTP+z4cY;h z4Da!bGwG39yF14 zonE(*y+(a4$A4ViXR^?3yDV~TjLdn1X5`f$39aIf=pz?keAT?R1K;1~94~N|Z2UBS zw-)%?+2!=E>2+{w{pVS&Iw(?^3O(>=$BA6WNkq5c!AAa&z~x5C6#K>@sdfL%R4_Y# z3!EwamjL`>9Pw7~{QbZ0c@z5n=dUhg=^f@4<6>V(f_g9f>sKEHU%>mm>c$WAI6^76 zI_KS^Pp>-zjuau^11grkb;3V!($$myx07&HXzeU=jnCs3QaTG=0Jja_c(Nah;10oU zkd|HM<4m*UI1UA0E>}!o)nn3ck-9%%dQsiy?#HaC#e@J+qucG|$=}nQz@2obz7%!# z1}@pyTKVAX9gw<)t@*nJ+m!p)JZCt@_ma}tY0`i4UjyhqmkNC&U;PjXko|gin34TR8U~AM8V5hvh(KO5qh?i7kJOUPzwz=1B<{1-rmY0h zvKA&}>PJs&j1csot{J5vCaNana|cj3h$%!v8)l=u0w8}f)wu7ZOU1QKnMld9Hn1`BmLfXj&sk&m zM1X8-%owNd4U*L7o(-OczFV07ff+$?2)^-TK<+7_pA6`BFJZihm`Nu0yc;5A0x;J( zM>K>YAis4AB?7!aY@IjH_b7i5eN7wJMl2tmYummBd$ObRyjbwi%Cqs9ph2u;P1E)4 zq~+FKiYkAQY!!$oP<>j7K(v!g9gJfnO7BKQLp7{wi&M%%9;-%kj?EfmNhTA8<{RIt z<2AMxQu+%I8&9W-__a2=YGM+>BDfVjUbJ!lD(O2bo_vg?T&OQSwWn%_WhedG_Q20X z_QM+?n(~u#b(DfO?vaM!3L1UyI6{51aML+)2w) z_}0Ucx9l>31Vattz(y@!c( z|4+QAQO}SVA`WdwBqka&xK6cwU}#RSHk*oxK)U!h)hAO40TPc@%@STyk0T27l@3+%6PV30ZAJ`*#fL-?8oxyJ&TX&3Bh(-{f{@q!oi^B}457&U1w$$CH zyS>%sshvytuM?>Og|)rvEDu&2WnMbe$rht8tudc#&iHB`Wjii5`Yd# zVy%k3WITWnEZ&imMx^XU?fcsiSf%=|>c2V>Ml~(-aF!CzMJ)Go2l;3A9oY3O&=e6R0M?p~! zJy3Odx0=G1>|}u8rK}knKzNR`k7$*V;`*XWGvEWRFw{)s?#g)zhN9^U)%?= zE4FKZw-K5y7#P8J4Gr32wcuzbJ9)Q@S&K(F^N}Y^J<(Z$6R_sm$sc;rWVi=Od?a4ME5;qN@_dGSqG_Z6)TcTu zs=$0nJ%ii2DWpbs82&O{zroB>M1RKenV8ZhS=Kks4VJ?eBix|UG0W{I`@X{#P}(WV zc)P$V#DSbXDx`4kC_an2+8ciazcjbBB>}!%6iyv~a?P=K8#Ef_;P}N)_U3UAmDNH4 zU+SQq-!MgB961%se#?^5dsdOVGptpPHxmgZsV0u0I++F0d0K}Ok_4OOlp}I%l1RLB zHz@OEPwfm#f+|ZfrfOQ$r7CQRGFG>$!xJlb)7V1W_rSuD%E$yun<_Dh zkG#e4IVvU9eY|2ECz(O9is;zF>AMxPGGsuH2D`*Xerb+d-Jq6kv%;-_z!#4&X+eV% zDt#A|ue{_h5~~0W8Ujm*?=d=i)ZW535(n3g%J{yE|GG~$#f3=nKiq%+r%Z6DWxRb~ z*Ax3?8vKMd{A2lcKN5u(YAzwGl=zO}-~Y4;G85sncjt|@K#_fa^NO^cu(futWHN~2 z!EYqjPrCZqcDABp)THAm=_~joSRQ(3W|IpdGN38!KaCAub6VXGje4N66>xW+)PH6* zb6-f+tEVvOal;uq2}K*3w~RV3Z|=J}?r++7(!`#V<(pgPaaUJ`M%}*d$*nJ6?o^UOkwmidPJg7rfv@_dL}#O zd;+;7_Ab6YOLX{sc{DpW%kTbX13hA6g(E2y{dNYpg*;C;-P_1FvdlcSU@hU^-fvHR61^{e82+aoGCAPRlUo5FS z53F^0u9OIANZl_?m?OHNeRW1G@+01djEhQK?kYBx&NC-~$tc*oAQ{}LGu3|Yu7RXKYV+{|l?gvRut<~P zj0&UoQIk<<=SN~0aZDo!4@VrOe@RhuGjiM8ZqiSd$`4YxiJ77(sX?egmSWUjbTT+H zFf_b!T+FjMnbE&9i#v6y&5M|Jhl^wi;YzXAv*x$7SA`>wp7yvIae`)$#r*OC3)*Z0wTBc z9OQL;q-)AEy+tEu_{bqmG%S9T=#9eACkp<%AH+@1T(ISkZgElc+Jak^wmHc${xY+R z@e&7l5$pg`ZC)$=GGoj&51tkoLu#gFV(^{(RY+;0ZjbB&C}+HeN=Qvcaf``j{@#^S zt74%vA*v!x_Yb-;iGUKz8xH|FR)?B*bDFjK05)7c?Mp05IIV#ae$n-4lECIKAp3)?= zl!SFB>IAXVSo60=7OpL-QEXcYvjhJ!jm}w#bt1%LS=Ft)vZb~(Nob!c)sn&ogjKRl$>1-V9+FjHkESdg6{Du-R_E>=PGMhrwo9RP?;lC7q z@0lzlvSXOCU(lGzW|q|CbvWj=xo>1a0&V>6ZuWx=kNj_nq;K%w2*xP~NB?S{#h3iC z-Uph0n=&T(92KK9^e7}cPCEuMMtqY}){@ z82ta#w^gH~J{U>V;PRlIb4@B{U0P~1z#BnO`{9^gWFus@qM;_sbP?6GI; z0n-lylTSz7rf{U%?GhM^M$TQo|LSc$0bfSO{P&M{oJSrTZ2&vdeH5!MqKs-p5;6!X zacx7<>LBd`)Wp~F!Ypq=2h38I9eK&CfyM62Z!eFgV~_8P9*f)Z0io9?p<)=kMihbj zlzIPdQ@w5>7q^$vcnnhGd&rE5+tI+UJNg9(9)s#fe1*E+YCU)6Z5~q=*54A{R`~o$ zsQt{o@2;J|?u}k})k-D^<6o!9_RU-WhkZc*gR%dOdB%g-_B6+L53E&Lu+`cEhSwlv zoqUR<>qdvK=+U3=H?NQq_FSV!@9*YYTV*@*$(Q^(7ZN*+e653Q?#eupbr=anc>OH~ z2N68u!-E3)@61^FNZwW~>LhP`fZk9xj+ApT|G?T8rnjq;A}+Zxjy`jdcTcdJFQlS( zjK*q*=VMET`7FuH#_#G6Ne|1`$t4j^8U(j>sR8!3hL@m;!X_IP^s@-Q5Z(%(a6>at zu>eB5u}mByzZXR<+;0o{)d*`$4=aZKX;engOgmUs3oPtX0ZLY1%Xk(PCY%zFYlgHd4fbY=my1M$Wf0|mt?pE;su7{$CDs7%$5v$)Ycahrjxui zN@W)waSd<2jd_r&t^}p$kO$Czpx>DNDPFwl`M${Eha&)^f33<>q9>p__S(&H-1OhC zOHb{gRoq~7`m*qtAn*i9WcIy`Ct(L+*Ku`#v<*ctZO99n+(J2aBL+nZz2>0WVFSJ< z)%X&I$_Q-@n$u~DJ7ZeTT{rOzaFFaEZVi`Bn61bUO>ZC$O%Ic$xGcA}-86Y%u8}c? z0Hah5f?rO*(L)%=a#Dpu37a2pA|_E-Mkdjq(Dvn>_(Cb2kU~WAa-7DBgkl{oTRE1- zszb^o&HNKLzgCJLFCV+MTSH@Cpg0@FV^_w_fS}jn$m>heaw0*35OWXw5rOAYQ<`9+ zr{n;s9i6&qph4?k9y)dQa%-Rw$*ZTUM#aA)SqB^9xg-d0i(HT^+Ni0S=D9*P)4JeKkc#wRCN*wo$`K z1+|~HR>Ur!v$qVrLn6+ZXG@Ce>Is5V*$f0*c!6oU<~sTOn@G9K4sWf~C55f!%c|wL z1GqG@=5#*gGst%uRuG}5V@Wl1dEZi4wlsD@Kit;t*N zQ6sq}@ttx)mc$15Ojts!#7DWrD9+8Lxj7M;<+XeEsT)x9=t#PHS+P>vYbq`25%$ZY z_PPw~tv<%$F1vssTeYc~>WEOhi_JC>d~{ai2R9cFjZO5_i;CfgXRG_O4K;h;F%%j3 zea~+JGvm{yz$`J?k%)T)^2yu(17N1TG3-GRd{f${O@h1a>@PKu4SOp`1gkE;33UM~ zab|vH_!NJ*{~MvJF%vNLALYpO!2=DrsogxeOME*^)V5?T1UmWS`wae5i3{2kPP)kPLYGB8KQ%x&U*rwmuW_dpAo{&eVzl_lHaIcxoTxeCHfr0B~V*OvWL=v?6WYz>)>Yd(087K$5$m0j(frDTddr2k(nr zM|7GjH$S;*sX{3!FU*i)Y32fu`3zOdV?)!F;TkeS4D-8`ag;!J7ny)IY{j5TcW7D_ zF28YK77g18UC5v8XZwMCAx!@V_jV`))XUGC_4E7*RZSo&c$+%Y62l}NzDd9cjJ{9>ZK z+3L^!v?m*L_F;^rP)NOKZRGbh7-D;r0fZQaT&>j|ua6Kq_fA z^ZxnUyPV%UX~^PwSS##e^+#%1?u`4Ym$}ejnlP@ZkWcqD%%(9VB6*pN(oUEFnHg1c54jAQEDaHTDy58w z(vnQP5jk|p${SNQn5zd&h_{5u`3U{R!wLJWPzJ%h)Xjmpc5eBuQ^F;w7))qn9)q@8 zWT@|$u(Jwc;0GZm^pKMwjrss$vI2w|kXBt%Purl(KC^UnBp7nT6*k(NSm-7kAcOHH zHJDjc*uG10r4^0(DQG4(93toPOQJ5Ni{iDKX9W*hU{7qS9vtGixTF>-I;o`d^6{)m z;<#%|aH=j2!jtZ`p%3cOcY_D~`nNdjI?o z|H0pi0?Wm9&FYmv4GcTnW(bNm+v&Q=b(d?i`i8d(2S8Zw__MFR^$&=5;zr1d&shvZ zm*B@5mtdXH_sJ0Yg|-pF0i)`zaQopkr+>+f9Idd!aq~8!7s2ObD{_2aX;*7{uVW0p z!gODBpTuH}Cc*1z7WxXVH`0;et##XF{;wU$PKNk>SSmh2cKB!Fo56j#ADy{*&>dbj zga4;HB17gI!5G}@H{X5+yt9+vk(FHvoI&iGLenePzrq;C#P*Im)LnAM zD!$Sd3{_aAU?`N}JCmfSDiEazl#X62&Ut{s=(MH*c<@ZQz-=F=EFiNB5J8)EsHQuN zC3O;n7)a|Al7evgt95fpHR}G)vdNexzdCa-Eg_etaw6W?KS2AGlaIyntkm`@V}~fGJyvt% zyTxZ%W6s6_0*(i1vNsE;>h4C5)lan{kGV~QB0isqp#Ka+L&k=L|C=4l_uSt!Xpr#R z5MNbAP?v;a?19FLbkmP%Bm*z(x2aykf@Z!3Y`nM^WVY1r=$J`Ci17g4` zFjnLApkhf}nDrzKMlg^ii?8XDFBDqD`V)As4}jd5+gKikkLx0R1{&;29o8j?LAT?a z{Lxf#f08a7WeF1(~w^p?rx|iAR@IS6Z%#HcF#F-68!$6AlTZ%aWVhV={RzqeL z3&z7^{1`@dy!kvDDi>V4{mjtKl=Zk)T=QZPHTwB|!FmO?2OY^6m-rbmgP2cQeogxB z0>wr5&=xIwEvBF-CbbTp)=@-;iqdH7WcU_1pT=bpZWwCw6c?s1hQUarO%RH67pN4& z80jF_nR63b=QpfM=PM?OV#+gKxW}yP#5&$M!e9*y;1=``=BaXA}#A|A&rV zmTC$dx;LO!CX{~m4zmP3EA?I$v9E-d74$8o+t^&6?K0mvcPN=H?3zKu{JuVqgH*Mk z;_x>%&JG(N(FXfj>)BHe!OQtZpM4l1AbdUCJN{p+>Gy<*+tzPmD0dm%wFSLTwRxBy zhWiYw(Da*vPQI;T35gfqpmY8AlEI;BY}Zh`z1Dv1fmdq+0i9FN@1OPWqRJLIS{-JG z{z6YW=hOUIcAcW&AnAACY#-g`$-h8Fzr*~1y(SKP6uJuJ{D*eg@w62F>6krk9OAd0 z8q5Gwv9%Lu;Bv4Yrp}(|J7n+?5+wM%;Pgv^b46Uu`P)DdhqnQw>%He()&wH~*c;xS zcy@Ty&D9b=wJk82>e5I)Lo(vLU})^@0O#Nf!Xq|`uTMVu6J z4b@StdBmQ%iKEazcOdGa$} zI!x~*%Ag&IV(vIy-#dp<2I0a(skF=FQ4oJ#(&>+{o0t%BnsPV>lt3y=SSCoZ*Pa0su_4~qn&EP3-L9lv*u-r zd4a8sU%5`2nVpRs<%Z^Uj`2EoN2dN! z)SHtJ}MhZEH(vf~5~BVge}0p9^o$1;GF>$sMr2VB&Nzr&%G_U61GBP3 zV@SeT(^$jzS{#!$yN{FTcv=aau(8TrLclgcesh^8NVYNtajN>`VS5vB+(5vk7A0hcl_}?!C?l3{2D2>WwOgjl#v7Axbx^n2jr4sx#MDBaaPq*m`1RvMyU&B zjy#h8SCk4GTVvB2>mQ;RgJSZBRVw2oiJNVQ zh*Gib=3FU!R8t1{-J=C$^spo^z^YoWp+Pgt09stvED-joJhD;n|KvMHVjEosnZRGW z3}{X-k=jqKkl6!_>NqCPNi33e;L`3D=_s4dPNfkU%0by28nFG zW$kmi-i|mBPbWUG_dFw-97c?M|Mud3^`?~e4AJ+50k7w+1jg4adg@p2j|Im0J^Sf5 z9u`-;&Cc1+e>XiFKTKC&9vjbi1@B2LECj&4=8z>Ml$(5n?jCiHd5x=vAPLVQx{AE4 z!2*uozUJy8NmkeIFg5=6Hq+aR#}D|IqStyqFA72+E?+N9F8er6){jCBrrw!8FPiGl zbZ3V(;{DRmyq!%({E*0Pj~~_<^ejK9wWAYB4G)GQmsdq*{GFIDpPsG;D?V_K6T@NJ z1ETz#I##!*5y~Q+fx3{oNp4M)W5NKM0(nDo!&N;&99=aBts_|~P^!?S45mayAK)WKE&rg$ zVY>Nfe!QGdH}TB7dVI)l9}n4|8|}Nr z+>i^GJDNu|GK|_{^TESHNJw|`ptQe+<`@6>4Q*>P_ISY_frv_SO&SqN=w7&?cjfi1 z?=ewmMZBB&JAy8rZ(|=3i(kWvv3o-3cXGF-66gk5=&=mmUCvkx@&WK&A4 zW;Mlm^BB@nfCWDSZEXn3oiB^U#U11QI)|3!@XJ8y8(`K_v%>y6B{DM9$Snlw;hjvH%{ zsg!H!C#EWj;#{Q^5P?a`UdcocG0%>Q2$u#?;LlLxoYly>BIyx42 zsqcm%JZ61y=Rwpk<|c&3DIwgaN1cLalXZzKF7MtXQg5`zt=MN|^`dp-9if$iOjiu^ zQ>6uKf|{{>xh0|0Xxwv0)Y#TSno+fg98qSmM|9IN?U^&I#;dpo^&z z6#u)db}9wSg_I1nAW50|i$NwvqnI*c+?peO~S-hVmZ|Ll&wuC{?G=; zt;WJ3A)4wM#yhyDjmBtnY5;(YfTXzX0_oCkXK2aH>``eryb+{G)HbMeu+)Z~gPDwS zotM37Rmogne?57_jj+uE zX>u8;RL7k#lx;)ht zXNJOWar`9!1orjy-;k0W^q0I6@x;jy^V-c7N_{qQesXt&d0J`c%Iz->L)m#T&AXqU zedL+xyu4WZEuV=7xgX|4B*2FcL;&q02zY%yZmHjbQe)+YyF#eNS|)$@HTE9~8pP>4 z+4>iMl3UY{cBx4#4={z^B?hQ>Ey8aUK=F$=3w(U;hmCs-K;F9Sm-Xmp-V%5W9`iqU z7Khobqjh$g;8)(^O_a$x;{hknvaP`9NIijy+o-{c(D!-WCquUB@viSPg7A~$u>xp)$+tL*;7ZxoL3A|5ZF^MIZ%2N3~77a*t4Q%u&t zsHrhwc9=_~jdT?V#+un2NUuO;TsY}vEsaP?nihOqs3a#0@xZ(IsB8pcs7JvSW{Ri{ zzoyNcz=8DAJNsOvLuDXYZaLq-AqB!~!> zA-5i`M63NUUtqW9p}ykS1rYrkym3<{HHA8M!V!Q@l+b_9379L$Jr+JI%1dQm*0znr zN`d?oB<>5L8EnJ)5O?QD^9wIeFDbJ<%aGM;`TvvFUQ&=IaLJ9g)?ptSerJlPyA?<- zET^o(;8p{|sW749Y_%1sM?)MGOEA}>MX(ugV$LDAX~T>XWecekW)tttYn{XLCr_|K z(;U*PpwlMn*g6p_v2u|@({Xo>mjkd}G+a0*XkE&Ox5JA;@U*Fw0J^zsMs{?(V#cl6 zku@o(Y&x4LdL>0#Ok|=7ObFhUGb7O8R2opgi%L3nrK}Qgf{rqFo~{(|fPs-hbXXm8 zEnS!}JrGo)#J7t`X##+e+w9)ZA~3fmPwL_k&8eDbSXhh9)5@sKe@PXGeNB4^8}E}0 zZu5TWS{xc8Z&Uyl5oy7(;WrCkN{hi_p#*u=L^9eNDp9QbAl!gT3u;uWwnTe#BSJML zVc`W8DkwUYYHBuOHkRIvv(8CR@-m{pJ#PYf{EC2r?P;?(WdVqu+>r=^7A zgi}B7Luw)*dvMU0#bRiVAks)i$<}I5jMyoYT5g|{?3Mk)kW^+vh1Xu$c+9$obrYR* zr@f4hbZj!iSbp^Ddb>ydvYvnkjX2cqjdxHH8nFk3;zAJ2_0G>5uD&zl^q>S>Kww!P z1vvoyze@9_)9{MWbGQ@Kf=b`@(Eo=Y(7x5q_Yb*JbQKm*n&#@2}dQYxFaV+oT~6|^!c0R zKS>NTlSwKyOBK!CW3BpnF-C z)9$$fbBs|a(21GwH72BV&iz*+yr4WBwE*KJU@CxjE&*exmbzDgUCj**{OLJ2hccp~eH!c-gNa zPcz;SVP+B!n&^_@uu_3xrK9WD-8m|d{-$Myu%auYVq_76?jt5UyMY?;{Lnq4j*?Q! z=J9_4-wF9dYKFhyCWTZ$G2xRjDZLUD5?^S7lzwcQf6AkeE4TcraTa!(M+?gzjRkjG z`JihE(cR@7G5sML7Fa>gnYT!4CRU6npt6vG zO8+^;1?s{jpk8zet4t`ac6gCbeiC15O$a->ft2uJ7>OIRft+9rQ`vm)JTEAH{4 zbPkvqSbZIu zcfD^??`Popc{LkQYAd{-PTgMI#41HzqJRc$1iF=~s#aL>ZrioPWvB7Ugwpfb%RBO_ zR(RCnG)9*hkTBSS7p(Qh5}>A1$)Gm$jZ82Af?VrM*t$Qs4dzb(wE%sy-bOhr2%mkEUFor*X;$?LV zlS`oG86WVGbcmt!@4i7}YYearwOhc>Zf0Nr3HUMz|15T9(DAe%>pCw>FtFu%R@c6N zy*Ko99Vrnf@qQpNdU@&8KXm};DLCW+Jk2-g#KBJJ0iGW9eY|qC29Gk#5}eEreTGDmH&lA| z8!n9XV|!9SJ~tTU6y$Oj4iEdVL2W1D=e1W$=f|pg91?Ap0N5|6xtYPgVH<^@yxIWD zlHBGo3x4J%@zqj35td=tUIhq^9o?6bdVK%*W?tN-rhw-oDH$Oo ziFIBSEtxqG4z2IwS(=17x(M`GvdMx=({L@+pr&5YQ??<}-=wqk9dIlbwmJt!??o~G z4R?l7Mz@3BgDpIQHmrTl-+%=SV;{22jWlB~y7GY5g#SJfFW#i(sCnh+_l#~|M|2}F z{&63KK)fxC|LPR#Tv77xbc5?+{@<~A?(+fCs~{PLXTS<^juGnp4VgkY4Y|r#;tl4q zrTYjGqeOX5j#RBy4bzv;$MhxX0EfsZ`Vn$TuJ3Gu8q;2b^o>z;l($RtU$kgMLzL2* zR^@#-heuhVC1XKzQk_6|;D#3T&_vcSB#m}0_Qp=~Fo}-9Jrr6`aC$eB&Hx7dtMU7) z&}!kZt9}SJh?MfE1wJl`j^Cw9P+7r&*&j;TG77S#%VdXD$SC0Qi2#Y^5)Y1D1u?wr z4-#dxn1UuLb2Xh#eY!RPzeG%<{f8kw6g|}TV&=X0VeeGf8adMh_R0Kg4K!ZSU@UHX zl&{<>X()%e>|ZW&Sj)bqopQ({9P*?68j1|d4gR8cbj6nE7HQ-IG@AJ)WmFKR?RCaP zV@h&;WUsQM_`-xic9^;wz*2Mg&Jg^fF!&@IhLDhTSetOV5`uP&nwB$$tJsXzF$V=4cQTwDmxC^mHiF#!i`P(& zcWNw-^AEYcmnDnJmbw^}nv@XzJ&Mue zWBToz1n*r{=WjUt{KugLfrQ|d6#w_mxPHnkz$-S0;ygo@9;as?uK`?Rde8h{&GBA8 zX_{h(0T{c_@VR&!dvAIATzoZ)RS&#PeWRZRTyv%D(Er9cslIG|mjLWuFz&)A?EB98 zk#9eZ3hXZ^bM#KVnf@&%*gFZlJh}cH^ziwA50`ifl{nQCBL&~n_Ny;k|%#S(or!6kgHOGKjP=tFwFj?x6 zm8VVU0l$3E2Fw*T1XWs5arICJsuzL3H?qb&c6l#1?n%El8-CT@VjZp|l)d8Cq~Xs^ zs%j*yhgSMK2g}TB0WymADd<+#2j5j;L5Lkp`%?M%Kc~WsPz$HLPB=Va>sswxRGxE) zBaW8tx~~hLw&(%7r<&$LdYkmH=5MgL$^dZ$)=`gLIY5Ald=Oh+v0u#Z|4yqnBaF#N z>PWeABaJPF_0oGZ947=Pgk84QHV@VwA;Zcaqb_Cn*x)s6}}QGom{Fr@MrR-D4jbI&8Bod4c%iFmlk)Tb^f5}=3tuJ zK^*R}TSWNFv?yz*cUa0i&2+bUrP>#{3RV_T*6^J0c6@RoZ3vqraJZ}%zO|$F;9Hw&hi;lS?WXoVj4IX ztn%Bbz2vm|$d^)ow&efObk#v^H$XNC?(XjHP~3yN6f0ib9SX&r;!=vc6-sgU;!xZ* zIK`dfmwtEmACMoD$zfL@rS#QXc7bKO5pb|_Jn^reNB7Yq{dzetIUgk* z#nSdLT-Uk9{;rB*_Oip4Dt}z-Ys?aA$^!)Xue{I`Q=?8lI?Ro7zyy(zyqIL!Bt*DP zC9g@}Oj*kjbSgonU%lx($(N13$|n6zbH}d#vhOD6lZr4AM+18DC$RKT%(QCU*<)PJ zkw}rX%d7=J1cFYj3Y#))*4XiE%(t3PhAp}QkUp4%SbwF1-y~)T7-HHjH#jh9LjM$+ ze?iFupAKSwz|${$_Urp+8JSbjldQ)JJ!j~vfDt*+Uw>^Ia}n~L^uUL7*I#J-kmbpM zyLBm?PV&2&$Ss1vO9I!OIR5PsXh7Kht_$vABk*C&_4+sejwOfR z^1uJl(bc{DD1P_x?@gI_-1*DKxsl;5E1+9{E5g0R9$I-Ax(?vA{3*?HIc;3b#m^LY z&qVk6z&n89_2}m-@}jXHTc*{<%e_3{En~O9UDF;wn}-0&DWB>eATWtd_`FNwv-z~) z-8|J_n0wbyw)KnRl~e4d0K?4Rztf~6#BC!lfc;1m`mqsO&Vc>La<6&B1s4q7^^*fE zQ*4a!|J2lB*cCtxbVV^TtSd+z#tda?1>OrlS~07NaB5|XAOq-68a`@)X6UDia?SWzypTd675U1>!QfzLOdw>6-QUwxfs#BC6>7IF4Lj-Iy^TbOg&<$HR)GYc6)Pwc5 z(gH~khmYh(AuXrQ$3{JTA8hcd!hXVfgL^|617GZTH&I&zAMAV#Z#iS@~a4o?lRq)p! ziScxfHZ2JW&=#T{6*HL8`wV+RL!NrE z`~G?>lQ}i@CYC2SWWx+QG8lS9zI171I$AjU3B|%CjSQT4tck-Klqw!RC@=s~+FfM=m2n);t_k3WYz7mXrOI65xQwKwYXUK~E3e5Cm0 zp7&(9=Cczg5zG~kwY!;qvt0lF92zwJJJSPK|a?$2K9-cV@9`X@fLd0 zfV7E3@^HBlf1UuEBV2NEr)U0kR6taTiY}0P+%aW7CMxU?Vr|5l84RsQ6IAHPO5kwF z-kq_b0Pc6!?Fz67FWj0$+zRG*tmgS|@#GUO*{G5Y1BSwD$P!#Q7NQgc8%e!s_)pmOS~aZm>`vI0y` z+9OKn-~cMW2J^iJwd&TaF^S#zLv|v>#>`1f%V8ypzZUk#!x7t1hqA-S+R%<7*KmGu z_}6qQ`Kqly!T5BW51!?&J8%nhM8=)2Fk@l#i>{>vM>muL@Jc=!H_+ROL>_{o!7$Qp z1|av=b)KziN#qKL#h__9KVE={MBg_|mtaM>XZfl`i62AM%95C)nM0oe5<$wyg}ls) zIRIW*MOGOQ1W!T!kP7j3nxauApAjv*^AZ;xfGQZLKsCRwuv{qkoA3vtlm1bWD5`p> zsE_%^m1(yazEd?WY82y-XzZrmlpYi*O{Dgz{_^+%Iu-z}k{ghXC}$X;AWaL<3YHp9 zu7KlYb0sx}r!H|rrcTGKCk)!eZ$D0+{Mh z&xP= z_0yOUf-{eH0?*n~f==wwjXiP>yqNX8n@510ARq?(EXvaZh!udl-$f$+P_u4 zB1~+_A9CobL`thZj|+-M;S-41YvM4E2DxT{+tI0F3rc`+oxO`SHQ#T~qT*PC>Lx=i~g( zi1r5HxN!mpl9bRZYGeoI=AMGx*Cy|s~R_O}K^OHBC22+H7P)Lq0RSYL!f;Nvj5hiNf(MbdppwGypd z99tO`7|?~F7KEu8H$e&3)`btLA|o)~ULeBD4+^#PaEOCdpj&*THK`CP+P(@}38aR# z;KL3>x+<@NXL(j%h)mzXWkBlFSmz8AWk9W{vah6xD1e^(iO09aDzw2oIx?J#W?(+M*BS?6!U6eDz3FhMO&J-FTw+=)m_Pfy)CJ2Yn zTnHY`x8_I^PF0z}IWjW%vjPo-9T0<~umGKv5)YIHK`<9I93Y?poeBiTL}j9$yUUO8 z5}hyuT^1`>kbSGxz+1q;J7}XC9~iTaD8$N{)knWwo&g3Bdh&sRK?&Bh14hw3V2ea% zC&VJu3EADXaFB#t^bsS#=xZFnXZ8CfGRyFnEby#4HIqhpJQ{igt)c_!Fty4=g~U5^ z224cp!ifRCq;^?Lek+2{|SPZQu3qZDk;$;Cl)1z?Kvu zJ>ZB01?l1_2uLSu3p;K^gPM;Gv^|Rf0*J~F=%e}{{m%v8-$1102ev|xbdGe?QBsei zC`AeraHInteslDJgr`tT$h0<6j${(mWC#clnWNM8np;n z3z=rmIM<(B0S$Em06h(h6{0a}hFf6~^ec%dh=CT7y*F0T&5Bm0^;HrcD~|q9_4E4O zW|w(Hn4zI)>hG566Tj_Rs|OQatUQ6l=D+~@87=5Or|Ds>5G`$iY&K9#O=%CI(;>Je z82Ej^1qkp;i^qymm8wIO3rP#aO>xWI=}238SV###Ju5U5(Nw0U;v7o}(6>It+S?se zhqkK<97=Ho`|sp!&p=r8YN%rhN~RwBN8@P#zI6e&Uz{g>Lf>uE`!vfIh?p9s&N#_` z4APG#oO$u+z~np93(Y&4yE(|T?{E)0TUx4oStjG3cngGf4b~GH;UOBgFR$(%v6Vm( z_#Q3*2BJ$yG4Ssfp(ldmuKTm5f1)L{$s_o3ec&P@7R*u``{s5U={d26KLIW#nryf~ z*&sb2{YthKF!|x1O5BAz@)LM5`S{@7d2D2js&b>qwDm7$bZwDz0spDI!B^hDjseft z^%`O$STzWlohOzYzs8L3>gqLk0T8~QpU_^fINq?kAF{faIebw@%H(6(SI@_$)QWD7 zAr)%=%p14W-Z@;n)5jT;pXoOq7n-;CI08R)AEwa;D$KB1?*V%F%3XC4Fv$D=l|uhL z*@wc>|FroQU>NYQx3s7UG}|Sy0(8v0A@0@QS2x1LUKJ2VhFg>n>?xR*AUgB~7v`$bN zvRpAT*IaPfi=4&ps6$KS8qGiH8F|2;)dW2o zj5B&Q5msEa043ZA8P|LX?dB-%HZ9CP2XZFrl1{=zvD~6~(%X%2>NLdolp?_(d9Vjx z6Ag|cUm=V!01GJ-Xy+T%N7XPDMHg?;0eOcNJk`*qaw28(WfdGt>EZ2_#VBCvN}cgT zIw5ai>;!&J^;h9$UuVLf76RqTf9&IIII#(mzf>?%X8Tl5c359&PoN6t^l0G zIikL{p^?a!0dPCVL&qF(051KZw)Qw6OqR+h3vP@%EOH6#bZ{j=20)0=inGlP$b$1W zAGHLu<0Nr0)#A*Dn+xF+X{pYDd7@(>PKDnF@Gucw={Z+Kqoh)4T?M(VY7bbs>_5c! z9jmmqsmuu^Xj8>pKo2fpkwgpXIsHHkldwmIB&Lp@`zCgh$jkzB!BHO34ic44SgAe? ziBf#jzbxfds5q$%fK;QMx|AO|Vt#1@!VSq-Sm}IH-$~M8#l&fQmH`gbK^mai{Y#<+ zxqu*vh3w*N6KRR?_unhwK<iU}uI;Wj#a0z-o&H#C4V17Tg z{@0jFSgQ0OSi*98P_^4v#p(G{5RfYR=tmo)937uT4~RD^oYu@|S%_p=-VFyAv!166 zpBjv#kBN@N%0$FmBNHr--DiiUXZRkhxWD0}6zoQ5i$rc-93~Iw>>;iA`H9(zZA5m! zAU2bMjYXD>lAi}`W(=o}E0ikqJXzG_W>m|=#HjwVFgjq2?EtIzA$tv9igx+AQaL24 z0Q2KuY%#6^(;V$V^<*H8CDXXnLah1M1R9c5bJ92-E7`pUmU^8yMkVMls(gD+X6dZc z*_>HeX@>1PNmF=M4jxXnTz*HMI9Ya$ z!AyNLEDFfFx0Lx`$#ukFrGF9bqJ3%btg;#s*m38Z^Kh~2o<9$Buw%RF<)kG%5$@Er zm2lY{_+owU$@fnaIltj4pG3~P&OU&^arpG=vwe1SM055({@^7 z?i;pt(9=|bw9nXwvs6l7S?cKK&Qr&~(5_L~&QJnOPYU2Of6$u;{^;2lNTK89)Ol!T zW+nsQFWLBUCVhMTJb+*9aXJCi!yOa|2SJ!@Ficj`BQ$(!TkJ$n2)HSlY*~A`2A8CD1G%N@?~li3W+Xc4+aJR;AE#>V~55D$)lV`)z84 zK=$0BF5g1bC5yR3bm)RQxN?vRqUZZ_f$6|!c}k_tkz9OI23ETUnQ*$EZ6T^tAPyy% zdJRQ+D`=dBQKRF>FXVHsNLo}E8j*BF^mElXQ z5M`$(*l|BHHU-mhxWK9c4A^`6Go@FUSF}0b`88 z?9vDDN47+?b0WU|ee)~Q{nTUg%Y_TTBpYt}E7t9CxI&1}H8 zTMhE)jB%mGA)!W$ffpsxd5Qk2xzD1hlEQa>Pk=|HrUBZ@_Ic@nuxjn?H7iz=Qu z3_#Kq$xG=qiI$*6Iwis?I~@Q@fK5OE4a7y$c%#`7H@W_*GZril~> z2Ulce;J73pUjjEm^e?nqX6nqU`^mZ3x2G@x7fDl8P;-=}3`T=Qx)HWc9WUGfb3B9FpFk6BMhA?c~OT4fY9&gKcbpMO1*dmT!PX z(h$HLh2pd%hYP~v6fEfM+ zk9+cf>z)+PpQ|^jt6$!fB~7cEF#1J`k?0tpx%Sq@zh6h6SO0z<>VE zMD-yH2$y(FxGr5>k{E6e=7j^ct&TnHkxI`{?C^K&85qC6UY45kjLfSFgp+-%J% zq+GL?(Ce*jjTL+A@2E5SMjKj@{<4NoYWBw~$f^*d5H;G;J8Q;f;qF*qwYOg_^U4}! z6xI@YTEXBfnUQ>ureL>11)1*Vkzd62%DHz6>##O$SVUaUG{XR^JWiR^hjbU14|Adw05Z`08 zE?N**RmMv59STNK)-+mD{TfXlTOS+O*f`rb(^!aQ=pN^o^7z+pwqJ=nVgyNykjqk; z_NrW%I!2N*Xcl+c!OlIb;j^ihZal4Ymij(=76ukFCSNV1tCNM2f2e9_5W5;XiDQ*? zRn2ZcX_XDU5bHVNe@*+iYD^aER5~sc?Pd*2M2;n(|A-3?W!?#0^o^-5R~@ zFvKz(E{B})T29&eSS97%K$RbJZHet`jop!qyrC%nJIkTvS zXx&1;oq<%wY*zNZmFhsnC2M^Er=zT*ZSk@XpC*sitnwW1$HvpTc-ChpG7178^Nt3S zo&(iKm3E@MzN4cybn*@vC>h69C$@$ve0)kXW(xcYk2n5C>3%EgdHxF; zcNXA~3w^*U@8|8V>VMo6eqHYI-5gM7(r1w8qMt$RGMnr$b>g;ivOy#{LBcht=jw{v z_<5Tk&o;@sBE9RT#3u7Wput)jva5W%_WB#+WeOuFd|UM=OLYq<-N;K{yd4C|nv|-2 zD-XPe5x;;TOc=5*7#2S635M~R{$kwFav1wF3;MQDBdXe#>=#u)w`b<IO})2JDssjLcQGEB1G!Wt1}6&V*L5R-^h9Eb5IJsS>h1yWiu(A3`c+XO`h=)tg{OdGHz4AwN zmTT`2W=ws-4lEu#LF&)wj8PNG&s*+2Qf?_CS%!EGHO1L14%09M_ad%lLZ6KEcE?>b z@Qx6znKqvs!LTwI)2#@)J}_f9+4Z{`;`ZGlbe_1P;~hMLD!GZ=B73B$!-o3Hmgtu0 zZsatcoIZ8CPG_aVn4}>%Dqc$HJ(eRH*tQZ9|M!` z=+vaW;bnpmC2W0tr)7~a&MBVV5APn|jvh-QRTD&)qfv*6>XUUBVms`|IhJ3xXUWr@ zpY~rqU3Xxb(+|Syyx~Le0jvWzwjmaA)Uz96bv$$0O1+76O z+#LQCu#_Pwj6@7)PTOD3M)qunHQP12$)Y?R3M8ZE!&8?ZFx%4hDKro#V5EA_3BYxOG3LKZxT3d&`n4&Mfy?~%a{mH3hc=$mBI~Ud9Pk{gODn; z=&A1)6dp7jAx|d7W=ICQ&1S?i1xbyQCQGUa%Gs^Dse1D?%%-__i2!>OZ?fs5F$*o0F7$#1asd0OI25J-O$`{vVr;^pxBm)GB<%^I@^`vvfI()Ci~!0Fr^yI zNS*N+SV+jv1jS*B%!#I0J>ewlLYr+Yah9;g4Q04)qWN@mVI*U!9w}3D+Q{e}?|v;r zb~+R{sa<}=5QTDJT+q8%K5j4dq=8cAW2|ePVLp7@h#R=&J%HwWJNRILO1h9Grahc) ztfEabjGCpRMU$~kre!?4qJ{S647YE?SIffE(i84`KI=hBe$2Ke))!U0;#s|ThPL+v zF{OQYM_Vz-dN-!hTE}=;0n83bYOc8g>lX7!(#XwPclF2)m_}!042*m9ELv{(4zx;J zIxE<%lIhXIRF;{08g=nH6L>wOR^;4j%0{W~TV^_435aSEXS9=6l043{Ehs5Zh;SA` z2ej7{gu$tFt*~;t-!ziY(2wKk`c1Ge_2~qZu^Ojwk=U6Kh49FcBm0cDwwQkX(pYiM zmEb>z>pZi%B zuNGK1j^YD8Xu5r&w~DT3$~p#`!gg=hJ~Wl-K{@*`oE_5*p^KW1OJ~>(v7bY%a}8r} z(938fjw7Dw-mkBI=ilAWJ~SJgHW@#Mpw)$zSWwb1*l#D1W%YmI;~4=MFYQWO)k;x@ z(b^+^bch`R<0~u2e#}mU^q3~2D%22MWnQ94UYa@(!3OjaQ-V+Xu_>3`j!R0MJU6@U zbKULE-*_mz<~z%Nww2(o$Fa7O|GBAHDYIJ?^E_Ip(0XdlE8Dd?GSW>YaYs?O)|*Rv zkI^{>me*hXfT>lPv-CZu%1>FV#Ok}2dQqTi-^3A?xM;?ykczSz`HV+fNn@jQ+x>>x z)s%FCou#ETR2Im)>*OIJZ9R^PU-PtRxFP1Vn=98Sl8tLaCH|o$7e{>izA7CJ=coUv zJ;!kb)claX1@mF!jzX*b_-(KIIh~{KJHukvi~Ea=PV?%W^JA$q^`KAEylCy+Y2Fvd zr}sT(L6y)*QP-9V=s0@+)4;2tWnw&YtgRRN9-`Nc&g07|t*R#*!KY;K@I%2b)i{}j zy`FvEk4uq6D-L!HFQd45s`h2Cm;|-6^N0!h(52rhv(h*fA%HkvhH!G+B{=xZjSMrS z+(RR%LuRto%NX~F#}y-YnD3>%7#MpP96gghD~%fp69!jzD>1M`9?V*ajt9fa)gY;} zg_<7*e)k<`uzC!9o=R1;8^p3G5Kk3BqrRF6vw^Q@7(!2-3e23UNx-fa>_Ws7%eZ}N z^6YS|oE^d|34mvrC7!-CeIv?&=aocQeI&A5X;-P5oBaD=e`w6U=4c+|LVoa$YtSQ> z_%`;v@0CohVCJnMB&R3NfBAN{B7VZ^jxQw|zsLXjVS|Z<&S+6>!_T=%dFG2T?EPfD z(LB6pgNrcq$_< z41%CmO!#&akW=o%na)B{)i7v+cTRxmI`enqP959*N>0bOMf8=5D$k61sblVAi!SIs zK&u=_7|FWU=67-QV~s!9bV5<-@#6T?Gb~`Cb12KK);uEyJ#_V@TtMUTeO%=__~8mM z8djE!R#dZK16|cRSPOpX@1DayY#)7r$BV~d^YT9e$TH~i!5Lv0qzJU(fW)3KJQ)-T zqN87^*;OlFwXw#vwbV~#X~!cbk~9k1`5o+SGB0{p1SI?9dVeV1 z-j@B?*jn;bs4skbRx;9_g_R zRzG}GQCGG}zU&R@+{JMz5@cGT$m z)-QA5R4C+CFof>0MQA4hHRGYE`IOc~>1HM^E` z3sVlTj$y4C9DD~@ajW+haQ5g2OF%oE?*^SbY;gL$o~fQ@5A{c51MwlmmshS+|rj&9Ita{{22?c?~bg7}ak~ z`s#4B^wRptwp3r-hi!wHkO7i}!}4e-_fvW=+^*+9WM)LO5fOkTl~#W&vNmjm8xB%T zjZhvZImUbKrymA7VQ>i8@}h>4LSylk09MmKeN-o|p-nfBueqnNyY9;3Nz@T2DEN2r z>mkE8E|n7=fFm($ErgEozxoxeQdcIU>4fJ%1MSqhj4`wP!U6pf2r2dJ}b z?rVy&Bcsu711}hj59egYq=EKQf!{S+E134^d+G-gHtW6S6O4rYPWGgYt|2kDM+&e{1L^8#=hyHHge9Cep$El(B2xqc2w3a_i*jx5i1t|6?AjgCe@ z7h|n0f5ag%Y0)7S`~;MnEZ0!`IexO&^ENjbAU|_%9O2jzk~y-f(DtIaDE?oD?rOUU z*exxFj8f^U1$YJULX{R}W6V1{_)HLNP z4CCWgM!cEmp(%VLf|TB2FVZOugVgeRdY@N{N~&)ZjrJlEob>l|`2uvA9{`yub{r}l z%#aXk=~^L8?E|Dr^?q(%uKr}kEdz+1-?zTwYfQgFV!y(irnAWPsCXtJ^S@T19XFwB z-pnGdg`uHZyOqQ4o>?uf(6T&ti%_5edbaFoM(opfCmd)L_1!T`( zcGdxiDmbHq{_%xh1Ijr@8e8w_0dc$yt&4zDdkdVLe->2 z=1qLxdR_!f$Ya?FB~VGHV= z#+d!!gF2hq1)>4NI-ByAajA<#IPGUk&&}WUg(DA((qo=bt`1 zW}B^6MGl>;KHlnIy<%o)Fq-YV12vD!hHuShiauQ|gd*&XNWGO9KA80FUYG<1lec?$ zdhNsQZ;jKiklg25oK9D>_)3Ze*xd6lRa#fEF!K&H$4Id%mUx;2xK}@{hAr8&-DUS> z@bu$0jM!3ZQPlCG_v_w&bF^UGddxQ2);tKc_NSga1cKybdH@U=BC9L~Vj#lA=A@GB&GPRba- z)^6QW4?#LU_|aXlxw*z)zAyo0Ez>R-u-;*28iWz;h(Q_iN$JvW%Hk^x@%^#>fkVmW z=7dj*Sf-2uE8%pX4=u{?mNQl&0OVCds;KNZ>XK23$M&Ajhh0(0FH`+j?ifnE^^YQB z!<~JYDb+&8%4PGPq}*>zL(+&eLl^j69E;?dzpwWH>e-46qHB%@X11g{;c)&(xRqz> zk+T6lw@EahmY2VmzHXc4G|l|)_|fjnMXJw%F-7$mZ1gy%2^WBtc;YQ!q8~vF3B%#* zrzWbwkKHJ6Jw*dsh^UwYX6W~fa8+gba`mfJcBzptm0X7wu3yU3mV;kW_LcRUwGiwW zo@`BN@_$239#{ud=_*ol@nbqqr(pwYUWQ(PZwgi^w&BS8brE`NmNogx7FMF#y{W%7 z`*<^R5sPht=heyZh2Gal<@PSe-5q9@g79SUiA-Z0DiD}pd3pW&BUu3(L!YM>r>8=R zP-qxf%a<;A#=``;&wInQyFd9M_UT0#l~YrX`FB=S)_~<9#zg{lta5NVzH*559(Qmd z@AxC@6|dv(a?!Y7l?)ZNyE(E(`m>7Z?;fi_tLqo7X-jyl}4S@w3Lxl{cX8|iTqiRQDr#uE*=WNKPkoG894y-Nh=<5zY{KWGNGH| zW24x3GGVWU6KMVH7vcvA9?CmrZ@g=K86(hN=V?7{Pdlx=uls{d!T&EI;U8ruA*w-y zsP0ff5%HJ8e~cLJ{yf-6rEr41Y>MLdr}4AxYHB#@LItyR*>N$zWKq{Co;Si0weeaxU9++6U1~?aJ~3LoydV|f0@>>Fg=BJm($q9C9C&RZl49b7yd#E%8 zy9d~8$>PBAG4FiGxv+6%kyFNS51~O5njV30B2@JB*WnDnbAmrP;5UbweXwp?TM%Rn z(kju@gK07=O1OrO+x~Rv^K#9CPthVHQjB6|Uv=Z>TsA)!4W~;iJhdx(1ZWmVYk$Tl zCWIc5sX|~PHr2rWrXAH|xS+5A|4j*A_R5e7;pZ7nt>YisYfTg9;MN#42`QM}RIiU> z^x8cj=7t(2@w;om5qiSqiYXZkF;sTE0`H3Q3+e9?U<`+_0MYV50N-h$PWK@PvIBI@ zXTC8fs}akb?-x2d4!u7)tf_wG+n<+74@Un8OddxgL)VzfM~xy`P%=V7Y)Yp_I=D)r z+#=u^7QN{(QMR4NRJi#x{W}e;`xivKmzAT92*F2On&o-Y{n!KHd#S@4SXp@b4E4~{ zg*AvMS)S7u=(;q?DVp}42XJHf>bz~}DGE7!RJ`;GIymz9-{{)n6+z*Un9g>k=ss!) z95~# zem6S}!a(Pj4sp&krws%}b09x|Jkfrp$8|@EYa8tBFKqnAhtldsk^%|V`EnL?;337O z(wJ6?tfGFhue=cNvr^?shL>3`Gzil$3zJzj-+kTwbTy(O;I_*l^f_6hC^z^K5AySF zHvN|)2x0=71bVS+z5Gj)d`Fe?$v0nhSDJrh?_NV!tDJhD`0E^c2cEushLCMuw_KeE zo*%T_(QW!{+=^W%-Cy;3zjY3!bw3ciu|($Gd!{$U{e#-C_i}HvpS{jm z{uerUFX5?lb5i!KJI9^gFI8uM9G(Ww?$>X-p(cMLud?K2he2r!QQmRD>LWYo% z+JNV_VH=sxE#|T-`eHP}j{@P|Y9q<2h1cL0sA>q|THs2_qyh>f{jfShJIC(>S!HlK zUdT@INgyyusB-q;Kuh8qSQ(1hX&97RC~Dz41SIFH4B~bMyn>PR57+6B7-wQ6mt2NA z&)6uY5GhYq{eJyEk&ny8Q2K|}f}{8!RxaNV8H092Ie{B?7`ccgZORfDiZ@(jF+M^F zyjv?@_P)Ut#~KWE4lu-@vrgT?su0+C#_N>X)Jxg}b-$>deK{0BH|!2M+r7jh`+_ii z8~NDm&#=~YiMvKW;kq05k1dPV-&8@DB0OTPJ>4GB$no~zv|G**CYS{f6%u;j|D(Z4 z&@7AKs}@R-a|)hDW5-p&&BAOmANoQfr|c3klfPv2X@O}@3sYj)NxE3tvv8@(m0SQ? z><5QtGY>SC*Mv81#R{tzpt01|X!;YC_F6bK?Qlzp)*^Vb9DtY%2S-PDBw~7#%nj@< zsFugq<#kvq-*Wkh)7e%YE$zDyL{PsX?=R1VVhZg0_scQpuQrX-*>|FDrZy#3>ARH$ zMU;A%Ve%zb%Br9E+{{p%PlLRV2xc{UOM+uYCNzq8BL zN+ln?^Rg^IpKNjD5M(p1hp2U(=OnP?Rg*zR?Yr-io1CG=uL;(pC}a|_=C$hhd51rj z;(ME3j*w@Jn*Wj3uPT_g2kOdawO{>?&Fh2rfp7OF7M^NVt4{5XpYHDemBV(;rxb60 zhxA$T8yx+T-shS;t-R*_S0@YLJ-6H?$&qh02R=1FTnD~RnpmVAEDnj?akV+!%dQwD zvj;YfKtDomQd=U{EB|Kf#>1UZ=cecO-OiG%c;E|_#|`J&^&z>4>%2lg)ya2vuvhk4 zFfLbK0cSW3WR)jGu3=s3TTvQ*Uh@?C1-LKE<(-HbTb&^pJ+`Pw?dOFLAbjpHY)Yg7 zWcqIswFr#kHS~}#Qa02c)cxvDqE!^8%w{E#OcNy_n|-xGDIXf2LF=#d`fUa%gqXHXRZt zr~bfSp$jcRp}z#i$Yv<~C_#M=`;LDKT3@%RKsD`?#eWpr!(P<0_pJN<7&`8h+$Yun zpX{-4^C`|<8*y-wZ;<(N^!9gqJ8#zl?*f2LVYOpnd|tT*c|{AJY7~u&WvHr$?ur?t z)^J>F%J(~2?-NxFY8X$}epl~%QASt0AB0?tsT-}-`9B88HEdnmY+fiW@#Z_+5d}L7062pW`4&DBlqM=Cw^~!H!+Rqi zVSw{S6t#*Z^KV=!{7L2N59Bpy#D!8c;b?gU)UwfZPMqA??K3;KtBwpby3dwho{z3N zi)6I!zi4%zFuP1^x0tDm=ZrTjHi@EfQG_1DY3rElm4}qW*r%opD_UX2D2xzitd$OUlpZ_arwqVR%VgpF zp;k`i)2$1yt6(|OqyX;pDM&~g!zv9c028c$h}=Td`UCReGjOv~5qNuZ`3_bpnq}tw zQ}r}xR-)PJn`nCK6O=gQ+=8%4Wc7?#mvD+^^RB}<(H;5ygK_292gtQPtO`wxLYcaWt`LF-C8didD(N_wz6Vpn-5e@Y`d;cAZI(`b*-|I)MKzt-(qLXSZm-mZ6f;@p;$af-VmQR)^bm$39!&^u|Skc*Ump=9Rcd zO6OplbNXd;&T!!KAGO2rJPSV#ZIjo&^Apv`Zx@k|$8$7g9Lz^T z2XX7II7-P}S^_ZiO~jgFow8Dbci95Od_u%@MJ$JPf)VZ2nee{V zNF){sw5TCAA8{9esMug|;l>L3a7rQ>6?;Q!2#+Ong87tMx20o0okV)U=cjg2^d+Vd zFHXZYTVsKjD9V6|JN;0q z*WU1~erE2&B0}^?{`ISV8+-2)4GW?Yerkm-Zbi3xLFLQkFFtL=UWBM$+K9aKmLLmo zW`M4TM7ofvv9xX*oXkjAMfum?(jn*z7MXMz-bBtpj4Zri=5|%#@FJPN38vRVxPwXY zVp{8lrr?5OXNr#qr-|@?yQLpJIgvPE#ZE-yYvYb1PD#}0RGZG56_#ju=G9cUwOWL* zf@Oqa%d;uxX!EQHl{P>eR}+t=v*O&}ncd8XHW#_%>iL2xdR>TOJMnGWm0 zCrfjZAhhkASJU`*e1Cd;hFr_|uGg`)nsXBQG*il{rdS&Hq&Z;=88f5S-w57k`S zMtjASR`TV~VZ8df*-n-Eg85!Q*zf5~AE(kX9gNrnYM&mQ9Xf8RP`=a1oe3SlE%dDv4CIfbYsxJDSP$@S=#@$ij2unh-}uW6-*%fKH=#x(PPDbzEOMQ z{bzUQXj*YUVhFrq(0^ol<@%EhaHjwn!(W_vcR$qytNGUOVCWtL=GCag5~fD;VqBvk18;&5ylUrtH#X^q3 z;_y5v9SCU)qWe`>GbfEph<}VI1yl8>H+e=_9n~MNor??@uKvXRKSX_XP+Q#>ZE%7^ zf}7PsOAheC_HL($^2xVuvd#d+!XdvD&%z4_zL+(|O$oPE|_ zd!4mo3)N_FTtA^s1H9Y|wA64I>(G?k`9_wt?eyf3|9&icRV=5IzaO7PQ`%oOJCJqp zxv1%M46+n6jQtByxs0%Kih_xTe{;_6)1LPUm*7+(Xf7JZR3>klD~}cyCf;P#y$qEI zp!px^ZG8kMz3tuj53ldZ9p|gP=0Q)@9nU!z1HT{dj2Hoqq6wHNk|O!bVgM%X^`PJf zzr;`s4R{C`N;hV_m%(*_H)8V%*Pw`(v^|RXYn1c~3926ai3HgYUT5m11pD_>A1N_; z9`!7mx>oH2m}-ooPG2<$IyDRt$hia`g-_Ld;XGzG<7`p8RS+xRGue#Usdp-1x)2-Kz!PxRBEBU$`@-XGi2^V01F2A}_t7dO zykf=X*A^pwEi|VxiC7pX)#X_%xPb({%P!K@VntG779)LFDddP>&T8g^2SuJ~Dz@#zo&(j$woWW#L4 zdKq3lPFsduEt-LMGI1421+1YX2D_PIhN*kTjHggneOtACb-=#UO0h!lN`=`2vqFu3CCHs{})FAeGSdr~SQ=Y0e^Tu}Y!7u03(=skD7>Q4Y0u z9b7O$Zl{yHfzUO8Fmp~Z~ZjA)c^fg)APagi%~J>Ezx*T{@t*jS79u<$zAp1 z&zGm!_OHfns{%&ffBr|4B^UEp-^BHJA$07rIc>&^oVDyMw_g7=yn|bAh>bfUyqpne zKk=ybHs{~Qx0~=nmZ(5O!0S+7p?xz(um`E1&Rxhv-&Z$JjComg=vYnma#LS67?g z)c3UVl>Y}_rcmHshJ)@lt(K4TvUsM!y&hZsNt8o4<^nfKl(MA<0~GCb{i<)wPynXO z^fnmdy$rYRZD^_|l6s4{s_uO0e$Hh&q18$@mV5y!pMBfA3pBPlS&6{dEc2(m(o%F5 zLWRI@jN#yKDugf+3OX%2QQ23lb*DyMK*B^oG(44u39Gpmypt=5VmRWTM5JE|-VaT6 zuGEb5Doi+(yOr*IJt%GiJ1jG#In}a}j(761(O~9vffH^=Z8KPD+Wti{4F9+4g?72! zb6qx#BwpEURS1Og5gBJijCHl7PdzQ_-lA*fSGJ(`gs>wJ`4T0W8*Hude zGpLkBkqB$+P#=(o&62k`zI#h`Ek=n@;Y`ky#cnEHF4W?bge>UQJ??O#zJ#k6Kv5gkhp{QPNX(pa8caEu!f$i0@}vCx!|o%?n$M zwWbOsjXzDwCB+9R;7<4liT?+FP5tps*1faU6~%VOwfV!+ff>)L|^!ggUXLG1oU?c9s>R<`%@|I-4bxPGklM$gk= zWQrij&J>G)E%+$34wUYcCo6JHE?SPzd5`oe<_)T?y!lLgbx;WXdZkX&o}sa`*qOSC z{~#-uCzkH|^L5%u#ZIO|Jkz^`!jqtI@YVC-Zr!eIwPm>g{4qPzUa}}IHgLr4k49{U zhDAW$Uk3+u-DL`eOO5r641ygYU)EklE}t`^y!uIn*SqvgicDqny99BD3MGma?iEbE zaSTfowr;#*8q6iOSE3c}XJ;_`hm|Y4k-Vju){ffDL0$pnakyEVXtqL3u|0;&sX;U2 zZwuu!^g%h&G-(W!!5NQ2GY6G{P(IQRu6BwlKVZcTjAx5t*3IA4Vir5q7Xu1lc&^S@ zEzxu>KKkAx^%LzUqrHTN9JR`HbvoS2BW`JWrLR(ae!T%*WfCg>!B7V4+w)~}NP$u| zMC!ks^5WaiC>05?L{U&Teb}PSvD=SLp*)oWiTDD%ZBBz{M&JtT%{&INuWaqgIfS!Z zZLbsVG15LeWG=?t58cnM{;x#FcT{mi>2=VL(B<-k6X?$v*ZAg`%7e|+ced)p@8;{( zgvcKb+CaQbl0Cff+j{nAb58M2575xs9|ga2+_iUK9}2TQ(Y`*#9E_RXzD#5VT?W+) zgg(|rb^U4Cy|Vbuu>MyCPIB+Tum_O zZC4!Y23_mk-Q~aB?ZN~SaB|>uNgH17)y-k+7I>om`Sec`<(ppP_uYBFrnDJ8$Ubf= zyHm8BQ3oPk5Z&P{*?f@gvJMz}rfA)swT%FD{7C|_tqF^d$ziW~qoD7_m&GR+$a#-~ zN$E&S$e?O-o7@US?2NT)!bQl8)x$#D4%A+1OOg{21km*BW6fi%fZTmwmef^q4!+$=cN|K`5ARbi%yia0C)D=cZKQ2{|P>lM)12B@c4EtjgTl$wj~Of5j8}3b@W>7 zEC`%McP3(d=t)r^M3c3DgzgL*^UOS|M*Al5vq-IQV4ft^tLY$iS!&~BJLLv7ilAGK zO#)@}jBJozQf>TC1VVu_VUAQh?Q{wfddY)TUQZ*`{n)z&^E1ut8xO4@gv<}-N*QCN zthCGKk@_D3DrG+b4qr=Xbe~A;VGeZR=bj5`H7M#$)mTQn8{t{|stNEvceP#Yv{17> z_BBr8Bbt+M`fI06DXe2BLbAe=*JcNiQxjvxP@%5W69ZQ&zva@@rEa|*WAprarf|+o z!-HbBH<(3&5`iL;*;w}+!2DU1cl3;iC??_!hSYK%E5e8YAqP#fN-2$xjy(_ll<4PS zFda{6DvEcX=MIruSp=5qboBQ=?d7kb(`L$M1mw898v5ZBWFxC&5aVshI1yCJHHIHn zN9!31Tu!j}

JY-0FgQjIj>M4zj(WC~v<*<$6LBg%fBht||=KExN)YiZe^aEmiDw z{Kd2D#dA}6v(0E&24MR3R#&VG^aCCaWnVbQVrRo%WmRmc=-9MjXfbb$gN=7T4|&x!7hgH9QO8ekHjaZele?ZZeg(C@vz|O<5RuQgQ91Yz(6klb4|NxE;LJJ& zelo`Pe=o6&y6@!)Zz}jCi1+UC=Of_7)s+nIoVx&*DYXZ0a`2WMb)9b5scl5uA;k1d zSp4^y>fu$!Ri~))7( zx+{vw*^AjB35akvRH}`1L&r@AC%u>cHAXvb(B$+Jf{nL!%GrZ zkpdkdaPsm~D*N-#Q#A1lgus)bK>OB%mzIHUS#f|r+3mTfr|0cYrzaiphs8Qs|6#7WgKL2T!}Gp$V+Kcwc!w3>iuc)Y{QlR%2UWzV zjSG5;)t)>NsRW1KLO#J(q$r)9o@NV)#5;-!5JG5k3+@C6`;4*}136qPkyHcXUGoG< zuS5zD!D4+s2mNwP$*9GNNMz8#5>8|kAEB4eqlZCl-b+)}rkbPJs^taLf5AeZLrvuw zi1w1S_uG%w2*R|Y0WxjVY~hDbxTdSk-Xun=@${y#7{N-VK@PaeC+>WCmW#I1ZpF5^ z%HT)dL_eFY=~r1(V7S(>D-_jc%OuYNI)tqXQ2h8`X`<@S7bJ#> zxHUhN^6-#46ky96j<98XZ=)YR8XD&p!80@+Uzur`)v^6z|DGkKLeAldm6-JPhH@Qj zLZ?qlglSRQak#+NrRUw=D~FJtLQ4#6R_W9g2Yhuob#V?IUY=~|BoQ5o8;1^sN3cGN zPpw(5urMnW#fw!oWEut3d+3`=N9%?uLsV+8L)K{ywg8Gd{X%h5aNjMxuG3@WMdkUH z$QLI=(^QwqmyaCfL1YUPOhfz0%v!sMuXD71X8rI@x}8}?dPNU3^j;K;mqi4Fp*i&@ zPE2EZeE~4uwa}Mb%gh44R|6(dY9iPET#!=p#GM2*24$_i^@cw#dK<9&0sGY=c>Tjg zr?t^#yvQG+U_%p2&E9nsoga4(QB-?VKk{cK0%lnp5FZ82=y?I)Z+=K@<{i=#%1pnv zow`PzV)`1PUv@tEqqs{PpXsxc@MZ^BE&;~%#{(D})?`aTPe6>c2XzjHkHaa_Pp z(4Qq3Zx$tpj~<)8_=;bBp2U)&y!b`yVB-EEgZA)+58h>60(suboIm^Wrnx&8@7cSw zy#yS%BOCax`{6sT;{C~Bv$tyUEB^X(z%vq_#7%9&rS9{n>E_dUkc2MWs*tLE?QiFK zz~hhZJAsTAOWITC6G zTYOt-#bby?DAq$|1Z1jsyng?o<;r8--_h&uEJp~22CIo1+aB)C~$h06ey_ypy3`j*vR9u|^XxfnLNEvo{P1mYK{6~)%7eKVUFwD9| zA~;qI%!d9JBvb3x*M+u!#L0q-J#Z^YaF*gBivVqVBtNsk0ngypc6{YGLczNRzv^hh zubpK+L?hH?{&57mp{IyVA^Hknntf-lcb*nDom_WbDPBEAoMY(JpDx((E__NyqAew0*(#U?UcT~*%xnOa{RTGPz6%q_u zl>`+0T2C@oqDB8GII6&v7a9k0*-TS7Tk|N%R2ds` zAZBkYgQe~HIC?*kWvBf7g&~=#OlX~JaRv?5w8vj+?fYp|7#B+}o67&*m&C@J%xVaCKn|0_%3w*gkiuWl$#o)5Skwh@jhuI8*NgZ_&SpO)r- zY0tY$maErV~Z;{10kf*j?x7R0)nMP44icH?7)AWgQW552mFv}V^|FSz`~)z&Ol z4LEqeAgXSBWqR4x-9LIyD0+d`-QE10zx1N$^)D{)%O8!OV9%*s5IZ?I{O9T3ab4}S zTkRCUQdL!@sxzp6e{K5W(RC%#o#J=i>D79BZuIt7a5LgBq#$jAbMGOMe}>DGa8l$| z-rtUWv69&53*48)^SiwB&24zK)Ah1D?azeb!kV%Cefj4n&I=HL>ghn%XOP9D_rECg zJEQxNY2M@hkL`1>#4Xz6zv5>`+&SVJwV31hgpA@$fc4F3&rtA9p5NIf;a6`IiHCZL zF><&Ox!a9lo@xnr?P2Zj?|&zNPfkv-2H%(GA6_c1{#Py;^APvmLgZ^v>A3$VE!Oc4 zZQp1kpW+rxI*YQ5+E|*6M!L3m!H_g`cE+|3$&U}e>II3AE`J7n8SF&i&?A>*`w4!> zBTY=Lto93^K5{R{EWQzC7vlptWFYuGx^nN1_eZ^WEWu{=$~Z5e9zQEz<0KsiHUXt~ z|8Dk-gJf$2`x^t->>hPgi@p)+P2e16hq$Q!hUNKqqG+dGxsaXDbvtDfzgPFIm z=|6EqqD2J#%4J&JKJRAzeFv8EEjO=An>0u_7y7pbp2Pm4d@Fm7h?9%0EDHAk$?uwq zj-Pgb??msLx`g2_3{SQ}ixFEy6Y-aNCjQQ_1zh!>Me4!R2b1MkIh9LK z@n%23y&UdYR0GEZ65KrWD3>w)wHTmgcP1G8A#4_k70Sl_&FA|m^?X`iVIP=cM~Ufs zh}e4!genAwvzAj~O*l&(Ei!mf@7I*M%-IQVY+Ti&RA(K5p$!Pr9PEfH{O4F&f8`8 z_;7fnQdXagE>9xD%?d1d)5D204uA-b?%lYi;#2Zc7lg)#GeQ_g_xdJx(J+`lw;)>R z4VaOjSfU{o4^Bl!y8FtPRaG7RtZvV}^50L`&+(h=^l)NZ)iyqy`1|DR@k>9?ZNhD$ zx^4MNJm1Ohvx3^Z3Yh{1uW(^{rOI|erB%V1!i>ilM5=%dus^9`EH6xxs$g~6qLt$& zO=|RNb2EpQPR^K>7AV!8s==;_khQAC9B$hVCh*j7j)AhL7KaNr(^@gL>wp!6(C1sV z+N88yD#B}CgHq)NY=`#!HjJoe6b@6Voz-8KWa6oT+M!vVp>oCy^MHayXl0UTTatpU z256~49>_9V;huwPt6SwFS5G*DL6F9&9h{ka=-T!%JVrt5C$&Oq30-J8OsWbtRr1P< zmrT&JY9)7<&W4BmkNRh34k z&N$bk`~85y?kik8qnp+ORU(&TfkXVN3sH(m%^|0fi$TI=hv3%!zcXL{&Mt7YZMgu( zPrAbIEW5}?`YzunP2{PT&2LbN-yR36W_usS1;$#U{Y`NMZBMsot=E*6{wf{Z#BV3c$%Y#U~h>FV*u6tRMaipOK60}^iIL#GFJBslN!8^o9NZCO$qmAeZ&Snb+`uA`x zpos?6Yl=tS2ewB)dTpo%A4Wu=nEX!8xcCRJ1iCIiiEfil>NWn6YhT?fqIzO!?hqJx2qOVAEG8jT0ZjUrH5YJne+Xi>5$OIBipoT` zmBRSjJw{E9tuSe;jdH3dWA}j8CiNa1D{3W8S?R*RI$#^!Mo@`U#x#*OZI_yMVN*m_ z&8AF&cEb*ny_kV&kU#P*1U0MTA(&CE@bh&+WnCy-HoR;GAd1=WQO%CZ5LAb5ygiiw z;*_Zc6Enp!fxopuU6wDm5fd5Ijq-=j9J~O8(95C7RW@0kF9B= z+hK$MZr%3n0BdPi!aVi7j4lBX5!*uUfFPVuctXB$R{fWAme#Q(Ax*D(NV3GaOokj& zrkaNe1>ur>Y^sGkf`YhZ%k;-5A@;IlYBly0@AH~pn&*fdjy3p-)7vu(^= zgb6S3O`AM(ssdT!3`|}CgHmv=grGrq$+JSTk|6wuv8Y6=zbVLT8Cci-*&2<>E6K4q zw`Yvt6pX%v>@p(nW$=bt?u~3Srg6SH{y@lwh(d+-N-3=wS|z?{X>3?lAHj?QZ#45# zbi2X_oETxUG;2Oak3X~^xn^ax8ry|W#^3NjH^nhh_qL$0pgWVSieQ@Pb z@cF`7AUtG{WDglW%Mf2^tgM4Gyo4#D6+84(^WQR6Uze&#AxaVs1XWdePdlEAS&y>qM=`d?x+y-yf^TOO|Oxk4>^LO?sL8}U#Ffw1L@yS?z7}SE%%;& z72d5OiF8RXtbAdItVdEI2eJ1&{av3NGktb-Y}rK3d;U{)m0Bhmp~&7EF6MWm_Vt&L z>khi<-Kg&Eu&j7r;hU&PFCPML7kUFHk9Bg$?^W-+jeP`t6O%pNz+GLqv)Ni-<1dpj zp8Pu{_Rc>V>|M7OT4@hw?Fml)+vNXzlDBKx&&bxSFgjGU*PG@8ChuS9@mt9`?35~* z1=js}{@wrF*?rF3^2Z2uje2E>jRyt>kYy8I?RGt!ZQm?A?a$^v^U5byzc? z1bBO%w86o_P2;r)V)3r7`2Yc|?G-Egk$4=Wuyuj8=rwmxU6v?UBW?>l%c2Vy$7o75 zx1~7Jl^}i`Ld*_(c>T@`1@0@?fL;!8DA#fRLDcICq$e-}sYTfUUGxueFb+Yv=xN-2 z3L(-8OiS2FdWkjEh19LkBtcr7V5MSe5F@1SH??Jrc{Im#(nbj|`O8Py4Mls|+6+3# zr97y%fKqDv3$3h?v$rLPGFqll&4cI0qDu)jBlkd?P)NGpuWRk;Q3)?sxaWw8*->rE~kxN)}dCL z10>`+T2iAaP8vZ;S#%-OPRsq6!R(69t6D5KqQR5{l1^0d+Ypx3r$W*mvBKEby1(Y~ z_mz27u*@D!v@saxFKjA)8#QZ1QS}_s>M|1DN;f@-|HskzLzRL)v?w$;300po2DOD5 z?{2b(9S`1S&Mii(K_Nq>8S->Wz=po5e;- zQz?)_33Z=I3N1D+L2P)mq?dx7&J>5y&#>F-;ZPRK?Z^OQ2&|aQg^ns4($juI%srwo z73wjr#xuOCC^BD1e;`Ax-Cnq`6k>O-S=8;<|NsC~ z*S|hAZ8FinG%6TQJ?E6`ww`q6IpAR_kt?OiXK=5|ttsGi_LwB7sBx)A?WRYD>hnKf7 z25luoMd}KSl;>%n218l_hoo?a9u3M!p?)SRW6B6&4-~yMY07QX$iZx z-*t3#yd`8_GBe;9%TtX}_OPP)*upLJ8C&9FHd>sth8VcdqAH0apY0Ie{+MgHT&7*7 z4y9Eh<7Kz0x=cyh0f8(KR;N$}BZwdy2th5WoIsNDYR2qZ)7c`^$kT|wLjupz$Id{t zR*QB=mWBmXnnQ@`vHHDRG)AARTRKNMvHAtuy-%CRW)W|rd%~qnvw}O0zP$k=Ya#6o zT*_nLie&u0Y!0x#IxiLTS2gt)Jl|qrRK2x%`n;O)C!OO5C7eFkYStG%)C7L@+r(Bn zyP(22=dkbI|J@mWsg_p@hY+HRfF3r;Z*%|8u^EV}i0}hx;YB@BAy^OFec z>=2F~O!P@J_ZFKZ)C;Z+FYRkf!@}q#BF_|5)9_(A>_N$)@tSHYMCOSS}E91MD z-(#xJqh9FX-@V?@?(s^YQ~S~zxG@>*Re7{R3E)M{@#{OZ zGJ4hVxs7)q>nb(0=CZgsmSM1Xgat73%SILu2Gp>&x({cDaS@c1yC*tIN|GKB2wqwV zgBvJm=uqim8N&x?!aqymBjRY9=VAUoEr3h#j)u&6o0S9-FEaWg>>INB(U_}yh@jN+ zvu|a39WPL7*?7H_vZ#c{9F|sKMXB_8irs+qN9~*x!_om1MK?kHC{bmjA)H>>{hd$z zJiIa3!P3+(^p&poD3X3&)E9!L8q zS5`o+1>hxj@6_r|KF)XyPScRFTpZB?ATv5#m|kC}FuT&%568aMfx*IwS$|)*8X<_i zM{}qDBq{>t8oT8qZNUZ#m=q{ z%W4AXVpz2jKj3fAREA43{CV;iqeOVAR>Bi;C{60_vOThj<4K3B1{jLr^P~(vYS`ZzhZ-CdC`^4a1|VNI zsoH*S9dH?!RmMs`5JVnF^ofZ_>OtvwHdz`F50-r{zjA_)nKy|hDkAh~A&T`Mv`NqR zi4|o*zg5&`UfkDs`C%VaiusrlmVkC~xpcbXQ^c{`U_~K*5wZ4XP*F=eJzI?obL)Nj$!7TlpP&`;6!07kE2lyVc8CTg9?1gYnkc1ihg6a=)=6dcwgP5cX zB0qvIgjToqTRs(32BAErMb8DlM@;Blmvsj|v!uMaeO^cLKPpUhEvU>#dya|@@A2pX zUH*EKE`U2_;cRz%w`glqt<-ek6jjQ?J4*-ZKxdRi?P_kbNMdJ9Tza~}~j{Jcbz$>WrQ_XRwP)S!|Wa7VjJ2XvWP7QBA3tBQ+?CV`RaF$<`%Na(UFA2CvJ4r2u(aD$JU1k zZc(tXLhCS4&()E2G+0u#I64v<3n6E^atTL^x#te8TgD^=viMIj^Zc5y?v$(|g~^PI2d5O{t2(y8vzHlx zDG_ac%?t-_vgTuWz9R7lAjzWIQ{-^iYhJt`&B}F8Sbqx-wMH94$mS&*)EBz4P_uLj zJ9cCs@U48wGLn60w$eSA7l%+7J;gme9T1&W!D|PgB+yNxl}lB@rXTBs(WK1TB+e+0 zN&m8?c)L`t6zd5(RFXZ?Ak-^0%yO3Bl8NDE!&J0Mt_)AHG5DPRcInjgSYagp1DU+Y z$GMW2Da6BKg78`egEUdjP?As_vhXgWKkra%5I)mRkFSk1hU!JocY)C)K|oDxn0%V2 zjIBU$7jG>ETRD_1t%Tj&qfg#Hq^?Cy?5vzM*f~$3qDaa|!DlK6jb@iAVtQuafPgZu zorRcLQ}kmvCF-%I`xzeVR>-21>B9V^fQTyini?p`p#_VEuJ&txKd5d5B1N>|IiM6%ylL$>);^lG| z%0+uur&`I3mGcDoKOy(vY(SAh$;5-(j+{u`+0g5hiVbwyEGxox4nZK`%s>Kh%NPGB zH~o8Px+FdlrK}p!L8WS;T82EBNiYhUq?&tBDz{9NiaNw2?08`}AXR82J5nZ{QZPTo z;nW-ekzq=qV=Qu~CNgT@{Y40(&%$AQ-v=GpB*W1uRst)!?aV+=nny}vK-lg>s3kF- z^|#rie|sG?%czwoi(A)^ULcsHQytY%;sb6*1KT^7xsLd@C3xD?drijGW z%m<5X5+M)}UMioDPS%51e1hriw;{)A57L2>8$y5$O5@xcGkS6%^etMn)O6)4j9k2- z@sfyAFdDpYIuF}S(r?e|PM-clbRZ_gtlM`nICuo{1OE(taodpHnPf24PM)qAo-L@vFW5jrSZ2sm~niU)xkEl1sw2j;{Vys(XU;?BCs z^_BBlobko@PrJj`Lsat?YC*=Zu+?$DI<_q z5!nYZ0(9UG93|9HP6BHgbj`^!NDt7o%F!?p0P&>Dj>p{HdCXzF?z%SZr$OICRL2=n z7!i*o-|$xYs`mj62zcQvL)3S|hSkVYn1Nj8R80m0?_e52^~MVK4igBZKZ@*8j?ywn zLSN>5b+r*$3={}CGlmYygLF@%|GuAr2C7^$H83iF^gYpKZGcbt%WoSiL<}UC#f|z* zV5EoQzkONVnR``{bQmOHrbtajvl1m2W(Z2eZmSl;#kErLEpy-ilWM76t*W42k_!IcS*FaZ&rzhl7G)_7)Mh=>s^x$d)}@jwdFFsxh#rm3&aMQ2NRz=$ zl3lmQ%x+MN#AY=E>9E?A869721ko2JQwv3ZJv+!e=C=Hb0;A~R(r z5g@^trrgdIu%HiY{53g9KW`xc$l?^rHr^jdVAdE#YBETTVVd2vF*r7ki}_YPb{IYv zVpnmJWeYJMIj*keO`^`3)#0T{W1L}EbWes-7mAtUM@MIW<0VC^_3W={=qHh$r#)53 z&U7W!g=hR&jbtOzvNH`VDS*agcAgMSVS;xzmB+MoSmDSD9^Y8y6F;%+Wf)yZ54zsi zC(S<%!uMn!>gL9xZ<)gci^q*x%XDAb-i@uf3ZzimY7}MLe&1S|K`p ziMj0#_uAMtnk35ms4CR)xg#*)#Xm=LB2aidlKUSVzCA1(xxx>`@MakuVz4}GxjaV` z|87tIcm3)vaZueH40VD0<@g@naF$CH3xFfL>Z0{X&NG}Z1h^yLPl*#&3q_Abc4UC9|Q#t(}szh)qU7Gx4Qh~{LeJt zQ}3_C;XTFBMedm*Twzb!$ zmP&u~1)>Z9m&61}KINt1zQi`fcs#2tRDX(eIdhqa1F~8`o z%)_OAhv1KROlDS}aS4RHzqR}-Z|*iOn2vaI#|X})lh_FQvb}?6QXbr!Of{9l4Bi+} zVZh}?b9os(od}%p&^9AZQ7@mBtVKo#&oFX_4#=}%&27@fwJLcoNOiLg$DU?&eUtGj z*BTn1>dMfOhh=^r!<=38ck!i&dvi5k7^sZ;^vwQFLiL_1&}Ze`s_~m~87Z@f8I!yf z_t6;hRRn)Y@tjD8E7&%L30BPFGB-scs3DYBonM#&B@oq{o@k&VOe;THlGh#ub(!WC zLsqQ~GZA4-p9~ygyi&msm5C}^+r@Jh2f2kK=Cn*tty$hf^lEmkSE)Mi-ZW*3kJ&@i z%oSrZs=lU&D#)YU?yvJXd&5mhBlMRP6m*)l5onn|nAFj7jNwBIQC(yzkmf3ynVCV_ z*zqcitkm;rZsv%;i({I8Q>!tMZ=Gc9n+3nw*@mIvBF-ZP*uvyEY+;G~=5)dz>q+oi z@m~G_o-59;dV(yKKZ?I-804<>dT?}@n>`guZw;Kuie|NNGxC!E z7o$nOFAguv#o!lhRHdB^R}d?B?))BD7U_&W==P zZV2kBwJPSk&p{3`Q$q#USdy!*&3QqZdpK#imgcV`&*E{c-QhUVAu4-J!I>C&d8%N? zr6jv(5up%Tc|-KF2F&7W97WqVecyHfGsW~ss&5-H*bj%f<L+T%pi-~TEsSvxqVEg*XiJ@zXfj748=w5QQ>yzYMW+p;3ZM^ScW*E+Ev~k zlZ$?Dj5uT#U)*9EM1{D%S{rKz-^NzHTG`-g3S}TF)qLdX!vx^Pq|^8coUGxtOQ2{* zL7%0xRqbVEvEftq)78&On}AcD<^E0hw3N{m4;;Mze8q7Z15ypRR8`MCL4#B<%i^re zXLsLLGJIKB`xjf`*Mv@Z?@|R43qQ5$4xPx`5fIi0Xl_c3Ve^93Rh@8EJ8D~V_$)R9 zV~_kB56kMNWZWT0ir5_^ja@_8zv2@@2ty9a%J3my5iF(;`C|(@C`{u7F)+8d zlg?d7#Kd6ug3BA#GKe(jN5!pRdRdmGp|8+9=hZU`qDa}4u`>1-Fl_t&P1hCZgeQ#x zG#)_wuAaF3sCItot5;cBXF{W%OfiX!dg(AJoi>;$7W|7i{d}xA*8HvZ7fS6tB#c8a zN)4mZzQ!O1`?>1d(=-Ry3X9A*j9DK$nL;dd22bHlZ~pr1BrJM8Z_nB|e|KiMN0lS* z(%%4GCk$#PTBUCvWGsnNv`Xvw1Jz$9>d`RC`I2i`8H_(iTUaq{yjbGccs^K(FUiZg zHWueiq=Dev%4#VgV_GzxurgVB9-3tZ4Br`iSkE$hH)FQ2mGXSlxM;0 zCrj<8=hKtP3J8P>B~Q#^KI~RvhTv%n3h1t?@{WqW2`t7u1OEH$A(d{xxe z8Kw`Z!xS7H?cU-*97}ONY}Z#uFpY>7qg}1rVW-aY<(Ekj zXLe;2ldG!cV-Zzb+5g4Y$l93bVatIaS)>cPeW%;YkGDVhG8h1nDGZJx@kY2izma>M zQ_ywa93s1-IDb3qrfQ=QoRjR+-;v%};3Z&v;3m6rc*j7^_pUJPWC20Z<0UuCJ*gm$ zbGMA{@})e4)+E!$daP2C<$A2AOi2xan+sx^Pp1xe;+X%g{!xxCO1}?!lfucen8b1J ztq%j*gzLO+sKuJch>tYYiQ_hhaEv9ba*7B=WameHCaBaO9T=XW;7fgzIQQt;$~(On z;Ywc&d~jUjoREK&4j&Ni$M9xC$RH{KlbJj7;Dy+6KV-1{UF>o^6)}IsxNOqb=H=h> z_V)@084tq;@`O{AKzqx9F~aUXF2t&A}<=}7R^-X-Uvq@cmp%~q?9njgZV?PyOW{dSDc)E z#ZcNcA+cIe^w`oFJLb4_aa&G9#M^U6J}cSJ3T3SB)QDE7$&S;br1hq2E z6dsHX?h1&~qmMjXVT72nNZg`ml4iy|@*cgYPSvA4tf8%K!2#$Z6T^Zmzmph8V-k## z&)(~5nwh9k=JgcnYk0L@1m|DhP=qdh;ck=_0-SUyZJsG*k@OnO3^1~yj(bPHhTwk>q*V@0jy~KWH$-zEPn{c)ug7oO_b*GM zt<*x7!~pr===8tji{!mfBOO4wP|>t9AG*eg_#PYjzqDB?bF z?Ltz$m zChCkR65=od%e@O>X^^px84Rwru;e&=HV)MW3f>Tfbmr;tt)a$~S=!(3zLo)ok ze1>SuRtwW3K)$zC4iSHYuxJEtDGk=l?ZPHv}+DJ zuh`6+yY4ucRE89qCClF9O*jrWi35@xk1-0IqT zv~uj8IeGxet#~^xDcZAgcxM)oEK}Vh8#O1~^b01xUd9aizB<)3bY^9-)DI%Wk7zI7 zC;{|wGtg2R>@wvqgXIk|ggG9)jNgS6=y^J@y-^1x${X)`uj!eihc!c}kh(s26KxsA$1-^_uwNw0W+x_3?$5V@O0o7yXWv+;` zjcBZh#m zKs}MJlBv7^6xxQ-LQ;am{)2!XqYwEwN3xJ9kHd#E{(`clUeAFrKQHqRr?A35A_{6$t@>F0jC(6#LYL~R_>3NImk*m{}(C#1B)bD*V9q`7=rsfj z3=)}oFbRFSKXCfLW)`#ozc==jArsGqb4i0^1d3_)i{DuBiRXG zob~^IG(4<}^JgXbZ+|*aUi^dk^{o@BK@glvpx?^!oBHyN$M5}gXVmnBy2M2gfCGU7 znIK<$b0(#$(-8WXUQi%JTuth|wR6qKwn&cmT&shJ+`e@&^lE$*q z7Tw+&I&*65s~E>yCirFa zGo>p-Xc=5m=t#|kXS~A&^iB5Qm0ilWGy)3McepQXn))*x^VR!-+lT1{Xv1k*PBbv)XAJM@{T6B*DxY_p@XQw;T(kI~mu}$&zre+!l&BR1+V+y1S?Gsi03D4f#;14^k zoBJfqAc;~$>bXYu@pIyutDy!``)+g0D_L#2e)TIF1=0CZ#x$Q+tw`*9Gd57JTh zyc^LhBYQe84p1!pIXUT@-m@~r(# zbAWWlohteXwR5_JgIBScuiLv)D8+E@_FK~WMT=OEAi>|u)6{U_h;U4)0*G&DLK~>} z;KYr9>ZIs$-0=Z*;<^cJ14LXQG-H5#-O7^W|N7Dq^nsPbsUCL*IRS zm2sBCOr<{zLzCNqSX-A(M_lMTalTneg8R@2`4;Y=I6=Tsf+ZQ>R)}Pf(W{6*2Vm-h z1pAwWk`iO*7lL{)UO@(&lf^U z{WaSdCEa$W9`AgN_(4>SJLGB1F2AF?sGPU+W>M_Nc?r+0Z!+d{f~MQ2$0lOC=SvO# z*cHdy7b^pw3Q)4<7jXw)83krrsYhGrf^VSN2r+q_X^-Z)&Un0&Kw&2jq)t;}02hgb z2Q>R#lJk830<$*GGkewFYCgxcmpcv=73`z%0IMg$_h{9fd>X?^Hguk$V{?a})856# z#~c3b1whYoXr9pAk28Y3rxw#@$*Uch4!rL9$Qf<)o~o2xUJ<4npJBVEO<8h|dV{-J zA!+tA_kXKLVLVRCc}_46+xeEz8Qn~PqqJuGj{uPz!$r!n+Umigq;`VIn<#^Kh3u-g z5dvknliGKV9*_@5`i{XXCeus1@9U)AKjoYrO_S!`7lLi*;9`m&{fcaWxrCgK8t)AS~F(;TgR0d5l+zO@1r;m zl5n9XB5NmOsIm1Lk*GUnQ;nFzsq={MkD{kOMm;1;nKkn#pFip?V!UAgD^B=(&7O^O zGAb#ND|n};bXJLT-n)S}WEve<$G_Y6ew)xzLiYdqc{qx7+D$B*n_Y%!@bLAAxsl%M zjQHi@(vuJ)do?aldj{kx3@)pGp+ZXU`*Oyoo@%>G%ar}E9**);?__OxN*C{AY3P@v zu^XNDreD0FpYu{{4yuh(*aZ%a$4sVm+v3CKp0z-Nrw5Malz>W;^&P0y^DgI6qq)WQ zDy6c%zsZg7zlKPhc`71Mg44NOc~U~6Wt27_xUCd+a{B=~T$FU1;Agf?3H?snfqV$y zVP4t)a7f84JyKO&@mDGN#0F?k_wAgBJWhqs<@#TZ+KWm>03|f&xFt=pm>#{sHk<=S z7=g^wg>$8K*_~-E@iM^Q8rkqyBVEtJ)M&|RxVMs{C+t4?xXA{N-$FK0*D_m^xGo^&hHrzU|r^_-nyDr)^TRaT1(FinoKH0LR%pb7-t=Oq4P zmQlUFJ&Ld8NM3Fmd4#?b8+8&0JuaID6I@KUJI6+(DY7#{OQ)~TcfGd2H*OigUIFF(BcFZlhH z4}VS(k=-l^;-UKz_0NrDKZRuoQ~ZXEvV> z5QOmX+~Z5e@?veD*)K}Gddw)J|K!t%#q-Ic3&7h#y5IGF(dWn~qR%ZMhGt_l%jWAB zdCwewLQQJ*ST8Z%&UPtCUr>c@=o6_0-p;f>LM==`)w03i>KMvSXo(Xe%Z+B+58>k) z6aah%b`MAj$fddf>L(so@K9XP&k~Fw+|l5QeL?A5FO4G%*x9mig;CkOGwyqE%Nrd zQhXM659%YRYVAZq9FOZ6H3(9L^GaSi~g(-9J|e4u-cdvQ!mA369*L0Xa?5bf zYIfWyWuRC}(-t0_4m{!AQzrF}EQ*#aswIsDb{$ilkYDpYHyOCTG%iI*XC9?hDZ=e0 zxhffFu_T|jp<-B+pV1sSxI_?CY-?7r`iQM*hV)Yh?6tome~ms z(O5#Nh`A^lJ@uyX)ZeM2EDq&@!lh+_sHO^bn9>7;JWQ&3=M@9lR&pG#o@_NnkD?c#RAK4VAb>+{N$CYQ$JfKZspmH#b;V z(fGa)t>oOvMwIzNCDl&P4v1oEDiSk5f4U%(-W@3#S-ED_bVG)|%V{Z%L~GvL(c>pj zG)uGazO)-#w78p4uP6;DM(qL?t5F_Ou0VF}ifZG5Yp; zOdOF0xIh|GH5ELsHXc=3?D9{mcf6W!ooZU>jkCPE;N)blPf#@q_YZ zN)8;L8h>)(UOw))5giVZ_CJcowRk-9^lpoDj>6$8Sdsxb4|2>N zyh(agwLIM5u~SBPMmQu1!UR%i`Ntkmn*P9BwhQyo-o^v_*D|exKd*Oq7_kMX;UedC zcLx4z<`{%rCN`)%Zsek#iL+m9xB=u%7q3lmh*;}S77jgipTv|es!x8f#~VPy&4!?C zLo{nR7L9J*^L<@Wyf`p6f$i4(^&uboNyJZ;mRE<_>hUK6+wCOBAUz^2?%6%Q<*18AP znD>_6x8V8rTq(`N3f~=sHd5PrwvGJwGcUQvHZ09X9gtQS(IkDvOKI0xx3AJW6 zpvK={$B};t;Y8!ZMLHF3+!pun{VWr z>-3p(cV=xe5|2A3BA16KKt=$z0VOsNR&WQ^9wSSn-Z4hvjD2)T<%;dhg9o=st{1)E zF{cT(sy(vSvDFT)!X0B@tVjb?A>r`jkZ?8986Sv^4;YJDr(}U-&*?XD2lLw0*Mp@S zR`LY}gSdQFd}52vx~@?jU#w2#Qq75vT0P+*ZIJ_H$5xF-_JJzA*rwFDP!WBGv#=BT zy|VW&m5LUnotL!tb|FJ9OK%DErrUWg)ldJY9}ya+iv}IALP`x@p~}+5y-sHc3g1+> zO+_(&VpU)Fcs$ekQN|Z*z`UjqR#f-|Ics$ST2>osjlBTfli175N(34h4|p@wP(Eo9 zrR*FYX14vPH&~0&k>Rf~zCt@0D=p#6U4Jghh&7pOcCDU+Jb{&f1--t(b)U9QLX8s`>@C_p1Dq%gYy-rg;|=f<>&7-*0jdj0wQIX zP8{!@buQ{o0-e|@9#Z1ODY_-j^=mpb!5CaiRPbTH2Eryu`c2Br(;F?-BkdH2PAOw` zlAJGHBR(?SW_~lrHNzGT(^N^~s69DjW3v|&j(L^NF^9f(?ZX9baI0zKr0XT z_Ksx~KS_xoPuj&DVCk2ny36VJ5OF21XTzb=72D_N^LDKwl#URwA>p^4LWoJIwca!d z(g)l@3w%QBe_)pQf#E0WK;9HFJ4%;evVHN4KeynPGIBY{N*cC*q)4Iua8vlq(w0tjWWg;Z?l^JGXea)m4@(Cseks8+S zl**(Vtv@rBpxpeW)MRD3q8`iQXGp`2=~H*A&J<5GfBc z(0K^EyAi2NaF=@B+!W#DgmiMg8mYGMJvOL$Edj-51YKKGf!8{R#0D)V@1o&ojNzMRsIVSUwdF`oWWx zYf6hUE}o{(<`9&KMO?_l7`*rUxjZPZe^_^oZM(@OS_n2{o!X&}jYnT^ z43ExWS{}d9pN{Dre9U@id|u1rX0gh*dopt+W7etKS_T1I`!3LRwP+z!nUKR~mq#;R zNsYM{taz7djPqbdZeXByUAq6c)Cyx<?#I^)T?nfk-KNjvH6z zKM=UY!Fd_4^*Y0F0u#019938lK;=DLFk=E1-*@3IX`UM z&YE##KiQyzeOnD^74ueAdsfu~(Uc;$7vN$yl6Y)O%a@9=2yBcL+%+sfM~RcXBN7|4 z@2#zT%=56#Fr*g!)+-0~^+;dQ0lNb;jlJyDPltpBFGO#H^KYMdk#F`kB6f83sdZw5 zDtuwf?F@Xu2xq;uaUv zvWoisOHC}ie+1k?s-A}8%U8T6XDcNR?q6y<2iqx(C)t3M69dJ=Zc57p;O?7?*YszY zapBm+-o*}Sv}Vd}E3VZFxyy;6o7}{d_9X-20cU*4DbEebbdnfW?JyF%#z+)lMel zyWXwqa+{wX^iZaaa#_X4U!tHdCZp=DlGQH^X7LuAm-3iyR>!|kN)SzVWYD_+Azya3 zVmKUb~op+xWW4iCr;QC|vnPWE$o4<<$jy;%&lEn63ttz?3Rpt@y&!*)o5#9y&hc z?b7U9$18kg_mXys=f|_wdC$&eWnz-Hm658#%3sOBQMVlT!=SQBlR5eEcO&P{@aLz- zxmmkcpod#}tIB>F*nD+7IRe}GA)r-MKJ298w?BP4e)ukcQ*7!3Umhimv%Ou$KiT+b zuh+3~6Hjc#9^C()@$TU~<7W5bY^gcNV|`2rIN};I_2O=*s~)CW*KtgwdMd_yCBOkW z$pvLL(H{5wHd|S8aObue5{V!Sk!%C{x7t?Mkn_*+={mosLDH=o0Eve&e?2Y3JuAJI zmm}v0iy#07NCeBCcmmKCx_+;NeZvsDQCz%_>@u;rDOD-vBad{ z?UW)sYU;;{zxES{Fyei5y&U{-vXD0c{T$fzrab3LX<)v+3}pi5fwn)Z*6g)Gs~J*4 z@zDzf8_M*-78CN=dryB3)vSn$*+(ZdW>0;2Gm1Duy*+ie8@x^BJb7?2^~;C6)XX~- zJkvbAiGERq96X)PUe5z~C_NY+VPywODbGSZ)-LuA-bJ)NCj2CXiJfGtJ;O}kp4|ww z-$z7{&5*}0{albeNoYaC7W6VJ6x-ePD71Q@;*wE?v|q_kJEf+@_;M;dVq)^pcGOZp zJbVW*ceE>fWrul%zMbA0X=AR#Qa(0JHW{_Q@=M!OUM)PE&;4Lz_9A%oRS$LhM1HJn zPxW=b^NCb$lTOPk&%!LQWhGNf43v-8gB%b|>8zo9TAZb+hde~94)4fEir3k;$89xQ zi&K4C8--w;(}4a#z(N8FF1K0P)?%&}^fJQ0vjTY+bOw$^qnlBeU1?-8Ox`8kLg<1M z^BEGuP;xT2tvtB14Al&Rnu-$#mF_+gX#tYgdhY#zu3yw-(%(8%-v`byMhZChY(BlD z_6jz0NU(_s3KPp15TB&$;vr^fX{tKCsKqm6$q_DQ=l{Ijc4W^FEiv}8@zf1ry6iG9 zJnL!EHzNrf1W(#n48^0DLitANyd-JDPwfRJ&9-ese#5C$elg``E4sBpoX*jbtd9y! zI*MsoGYEmMb8s@~sTa%DsKo8y@xKj3-s$1a$YlO$8YaiFr z8ZaXnOpflO{a;RsdM}=6((0G8K`T77v6ytQ_vz`-vh#Hk-|!mShi02|iwcq(`rGR{ zRuIQ&O}P_RXu1(jf0@AY4_l4fKHeDDt_EKI>hdI8UYtSy?zL}9grsi+esY^}SD025 z=z^ZOH$9e9Vlb5 zos%@i<{mx!AH@XnZNP#zvj;m=$7voe#5ZMvCL~*( z;`n3OGQ_0wuXOCaR&8$%;~UyrYP&b&{w+o4cET)=;{aKG6m_=85sP8gY!yV|Us~(C zCdZ+Lqy3_Xz`KU??=mjlI!dnofoQ!)c(k-QlG<=^FhZ@&V96W|_nCY0R*rW#3sTto z{O+z|n#Eekw|@=~^{&5Eg*j*u8x!=jOwM2Qq@49C2yJ(oH!R5c*B4~@GpV~l#O>Cz zF^(*=r?mY;?-Ke2JufKHpspwrzX{TlnYf`6U>Z=P@#??@uX&?_>a_xe;U#aH3tq1; z%tcN;kBo{#r-K)aB74KAhK1oLju$*{vUL;hi)j0~p*i02vp@w4B4)wbi>sgQZNPh? zqrk*`t*<-vPV=5nUwGx&N^eBguw()kv;v&?%G7gDAF28^zroA3RS=A&ndF5=J;Ox( z=-cTdTul8&^u_FtRjK8bGZlke=to(;< z$VmHR^99)8r>+MeI%pNxS@qpT!onk;m?IIQxZP>(ONXsqG#ag!stbSoP)LY9K%*ta z`;8=xl&nwjsf&vSBPRwAQbLKawcJ1Y0UInyS(@Q4y4wc5babIKoTJ>L&~1nMwGoL z2>k&ec=X-o5jJS2M(YbgWc5N(1{5lhxWO~)dn00;L0J*Txn~!PW)$~xYK~!5x%*H= zpwOBrGET}fDlX;K9ZqEl*x=&b!;h)2wbp<;&hO;s>NQ#!h`DbMz{Dza@b;;wPR2LP zDIxxLS#tzw?!^^<&oQIYZ$4%MCL8a zS@Ca}2Sr#lsf=4r%D`# zbhau)zbHLq56_AQY(|fepZcX$I$DxJ@2;UOeQqPj%CH{l)mNz#su`?O zcZIk0lhBSZhn1^56?qSnN=n8+b(*cNP+wJ(B84O2#P~rhB+V+%eQuWK|7R$t0EAo+4>Rc zdk=9(7jtPA59|dTI?qR3j|^QajDWkV5re>FPxyD$8yQs4s*9wyx1sOFTK2LG1q=Ig z<{j_IZJHCS--g;DmMuzFSfCP!R=gp|382NWt}}WzRa&zI*99Oa z)r^LoKKw|$|28CE?)>hHb@>!byP>w5+6@fc&835;!;#P~w@K)tcu${T_F#od(aLbo zndH%=_QN~#fDThG1H<{`QI27z=QoRIe2kGc*J$0kz=|}g>W3#s7q=@c#0y2a_iKWS zEO;^d5baMyw+_bKY}ACf62Bne7&0sm_g?E;JtlYtgm`u=_2Vk9B5eRo(Q-4Ps=_L- zT_UomvzW+w$m6N6TOsP3uK2*1<0}(2!Z&-B%G}rt`k4w6#NbgkZ*qc{`!5J8>mLG# zjEx6R9?3~hTc_@3gBN8BO;jZwz7)yZec41k2HHimDnNZ9B&`mY9@f-`!>nr#>@Wv2 zqQj`Il_1R|7PITm7kd5+d3ikS3o-wh!tP^=XcB`jDAwYWp-%HEL=;-N-o}wfMgo4) z=Q|z=U3ay^To9hUeUKK{+w~#(gO)O~8@hu9XR%SNxOCpQZe!Fde{19l$OOLpNG2)Mo1V@yYgQm06UATOLV55?RF`_jyTF2EOeSIO6j7t@tRWt8B1UvH_7K#sW?euiH!)CTqwHvzKph`~j z$eN=dz{%CHK~zYpHkZUudp61dJO(awp7%;{$bl=I=58OBucN$;g#D||^s_c%1?(6J`!vN6u8 z324a}{CwlUhALc*5<697ORc^-nnD`-X@)e(+m|Z;m(rUl1*NV}CxHJUouWgZ9el3+ zN6;zf^lnj${?VY{_r6r;|DTU_^aE)q?|pa{HVE0lm1sH5gP#slH2n`nTPje@#gPa~ zeut+HJhzIOe+ll}jNzbA-$(!P17SO0|FgX!ACwog1mtp_AGfcS{5y_F z`mcYbXtF?EK!Sk5?k>#J3BkV)wU zeZz^`bCpmTa4Ea&B%&?pEMJtXreJ#IM{gB-VKXtC zOFK2Fn&_W|D}?ScKOWC=P^rx!pweMt#{;Q4p3e+NDJ*RZ09HSDX=#R*|D6=q4NG6j z3^DfG5Ml_nFb6A&qKq?=S?dAye8Fd6iE-$;MgJViM<^nBHdN%!FGp#&^ zKeoz4S7@S#6l*I6hmVz@>l^4j10pj)xMqbn8UtNV(^Pwz#G@aKH^gvo$PKV;5;^2r(Em$z@dkpg31kJD0R zK5P(fVH*4#rveH40Rcx{O*LLveOfs{SAl8OaQ?*ynuuj4a#4AtDxBGSc`TZB9$={i zcTwCa1CHy^KITiooP7H_HQmfwBl_75hpDBbWa}k;VNXfY!jku2!oA&5wR^+r~YDSN9i$=Ptzp@&YOZbGy?R zT~ERmX{-+pUF>X$ON5(wcP;+vgCy+N3hhH&yx5ppi+k~)b7?Ux!8#KNU)*qw7(Lph zoN+G4(RTMvD#kB#xiL?*T=DVFykgqa$O@{fNfwUJ!b}NjH2xjU6)OA7K!|i~N9;_P z2~vXdxuuP^gd_Zl-|8A~CvW0w1N_pPwXX;D-^4~6nd+OR1lgc2h}LpwRfpK&AG}Nv zfJp2+TFUA$68Q0Etv6xr+2U**@7U^^-|BTjlhgvkj6uYXq$$7Sxq!vwT_8LfaC|x6 zstpYFbwz~B!3Oy}|4Yx;f9YY1*ts%j>17sdSx~iN6k60Dr7}5}bu$?Qj~)VsffkGo zDC&rRLNf)jIErT#O9z@IT*hhig22HHhY7X$Wt+Kx{PRr3by zugY$FfSl)_V)pyH$RLtc$2Wd}U>v$eq{{uTSc~an*eHtm(qq(Rih6r}uq(V)%9h^A zdh&H|!)^JrDAl$WMm-8rf|)PZO2e^KEt8kngS%l%&;KeD5BiTlkELJ*L0<9bfM}(` z0c>@x%X~AzIUoRwwk+>#=tmh04TME^J{p-8$Z@?OJ@pj}kA8#_I>^E!9rvTp?)*vR zQA`_S^q=8!Ks|}*1>6NhD>VU=8Wp3$#MkfJ6HN#wJ|i?h*B9Fw+(Bx9$4`@eD%bbgyS zrP;cSe$F_~;BljPhP2+5HKB4A9t8|P70fzZkaJlAhBP{_yL_wniVWP~7NU1niNGHa zqDG9g6RD*3QSot@s8jRNLa1;+{ZJu<2ZWO7#%N|F686_pb4vVi7k%`DD+D9~NN7Zz zrkK_N!nDGzX_zkK8%;F0r^*7`?6`56#`P{K;DV(rvbZ?!zr zcl9-SYMVlobR*XFk*XKX{NR~Z3YV8EFINgUyCu$v+sBTf=uxxq%_`NQf8o`+n@`X2 z?TJxbl`t$2s9#ay?mR#7bmTu?;H*oQeKI767T=-9=m_01l#9s zhF)!;RW6cJlgIG?$pTS^;z2mgJMCWmD{+c6T#f(lUiN>W<^S#DV>LqXIw866CO?4k OyQ!g%D8FX+&;J7Tnz8Nx literal 0 HcmV?d00001 diff --git a/PyTorch/build-in/other/continual-learning/get_loss.py b/PyTorch/build-in/other/continual-learning/get_loss.py new file mode 100644 index 000000000..03f37fbef --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/get_loss.py @@ -0,0 +1,87 @@ +import re +import numpy as np +import matplotlib.pyplot as plt +import matplotlib +matplotlib.use('Agg') +from scipy.signal import savgol_filter +def compare_loss(benchmark_loss_array, sdaa_loss_array): + + def MeanRelativeError(cuda_loss, sdaa_loss): + return ((sdaa_loss - cuda_loss) / cuda_loss).mean() + + def MeanAbsoluteError(cuda_loss, sdaa_loss): + return (sdaa_loss - cuda_loss).mean() + + benchmark_mean_loss = benchmark_loss_array + sdaa_mean_loss = sdaa_loss_array + + benchmark_compare_loss = benchmark_mean_loss + sdaa_compare_loss = sdaa_mean_loss + mean_relative_error = MeanRelativeError(benchmark_compare_loss, sdaa_compare_loss) + mean_absolute_error = MeanAbsoluteError(benchmark_compare_loss, sdaa_compare_loss) + + print("MeanRelativeError:", mean_relative_error) + print("MeanAbsoluteError:", mean_absolute_error) + + if mean_relative_error <= mean_absolute_error: + print("Rule,mean_relative_error", mean_relative_error) + else: + print("Rule,mean_absolute_error", mean_absolute_error) + + print_str = f"{mean_relative_error=} <= 0.05 or {mean_absolute_error=} <= 0.0002" + if mean_relative_error <= 0.05 or mean_absolute_error <= 0.0002: + print('pass', print_str) + return True, print_str + else: + print('fail', print_str) + return False, print_str + +def parse_string(string): + pattern = r"Loss: ([+-]?\d+\.\d+)" + matches = re.findall(pattern, string, re.IGNORECASE) + return matches + +def parse_loss(ret_list): + loss_arr = np.array([float(loss.strip()) for loss in ret_list], dtype=np.float32) + print("Parsed loss array (first 10):", loss_arr[:10]) + return loss_arr + + +def plot_loss(sdaa_loss,a100_loss): + fig, ax = plt.subplots(figsize=(12, 6)) + + smoothed_losses = savgol_filter(sdaa_loss, 20, 1) + x = list(range(len(sdaa_loss))) + ax.plot(x, smoothed_losses, label="sdaa_loss") + + smoothed_losses = savgol_filter(a100_loss, 20, 1) + x = list(range(len(a100_loss))) + ax.plot(x, smoothed_losses, "--", label="cuda_loss") + + ax.set_xlabel("Iteration") + ax.set_ylabel("Loss") + ax.set_title("Model Training Loss Curves (Smoothed)") + ax.legend() + plt.savefig("loss.jpg") + +if __name__=="__main__": + from argparse import ArgumentParser,ArgumentTypeError + parser = ArgumentParser(description='modelzoo') + parser.add_argument('--sdaa-log', type=str,default="/localnvme/application/huangyun/continual-learning/sdaa.log") + parser.add_argument('--cuda-log', type=str,default="/localnvme/application/huangyun/continual-learning/cuda.log") + args=parser.parse_args() + + sdaa_log = args.sdaa_log + with open(sdaa_log, 'r') as f: + s = f.read() + sdaa_res = parse_string(s) + + a100_log = args.cuda_log + with open(a100_log, 'r') as f: + s = f.read() + a100_res = parse_string(s) + length=min(len(a100_res),len(sdaa_res)) + sdaa_loss = parse_loss(sdaa_res[:length]) + a100_loss = parse_loss(a100_res[:length]) + compare_loss(a100_loss, sdaa_loss) + plot_loss(sdaa_loss,a100_loss) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/hands_on_tutorial_InvictaSpringSchool.ipynb b/PyTorch/build-in/other/continual-learning/hands_on_tutorial_InvictaSpringSchool.ipynb new file mode 100644 index 000000000..af916f465 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/hands_on_tutorial_InvictaSpringSchool.ipynb @@ -0,0 +1,2689 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Hands-on tutorial: Continual Learning\n", + "\n", + "**You can make your own copy of this notebook by selecting File->Save a copy in Drive from the menu bar above.**" + ], + "metadata": { + "id": "pB15rzv-5A-i" + } + }, + { + "cell_type": "markdown", + "source": [ + "This Colab Notebook was originally used for a hands-on tutorial at the [INVICTA Spring School](https://invicta.inesctec.pt/) in March 2024. The estimated time for this tutorial is 2 hours. At the school, this hands-on tutorial was preceded by a 3-hour interactive lecutre, for which the slides can be found [here](https://gmvandeven.github.io/files/slides/InvictaSpringSchool_Mar2024.pdf)." + ], + "metadata": { + "id": "aBduCQ3QONvx" + } + }, + { + "cell_type": "markdown", + "source": [ + "Things you'll learn in this session:\n", + "- How to set up a simple continual learning experiment\n", + "- How to implement EWC, replay and EWC+replay\n", + "- How to evaluate and visualize the results of a continual learning experiment" + ], + "metadata": { + "id": "DvB7ZIPdQr5c" + } + }, + { + "cell_type": "markdown", + "source": [ + "This tutorial is based on code from this repository: https://github.com/GMvandeVen/continual-learning.\n", + "\n", + "Other popular libraries for continual learning are [Avalanche](https://github.com/ContinualAI/avalanche) and [Mammoth](https://github.com/aimagelab/mammoth)." + ], + "metadata": { + "id": "OS7kSVkOth4g" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "id": "WojfTislQ6dg" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Load required libraries\n", + "First, let's load some packages that we are going to need. We use [PyTorch](https://pytorch.org/) as our main deep learning library." + ], + "metadata": { + "id": "anTIGQYWnm--" + } + }, + { + "cell_type": "code", + "source": [ + "# Standard libraries\n", + "import numpy as np\n", + "import copy\n", + "import tqdm\n", + "# Pytorch\n", + "import torch\n", + "from torch.nn import functional as F\n", + "from torchvision import datasets, transforms\n", + "# For visualization\n", + "from torchvision.utils import make_grid\n", + "import matplotlib.pyplot as plt" + ], + "metadata": { + "id": "LNJi8AZPQ8HO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Download data\n", + "For this tutorial we will use the [MNIST dataset](http://yann.lecun.com/exdb/mnist/), to construct different types of conitnual learning experiments." + ], + "metadata": { + "id": "lCOLAWSkyA5A" + } + }, + { + "cell_type": "code", + "source": [ + "MNIST_trainset = datasets.MNIST(root='data/', train=True, download=True,\n", + " transform=transforms.ToTensor())\n", + "MNIST_testset = datasets.MNIST(root='data/', train=False, download=True,\n", + " transform=transforms.ToTensor())\n", + "config = {'size': 28, 'channels': 1, 'classes': 10}" + ], + "metadata": { + "id": "9mngyfO-RzyP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Visualization functions\n", + "def multi_context_barplot(axis, accs, title=None):\n", + " '''Generate barplot using the values in [accs].'''\n", + " contexts = len(accs)\n", + " axis.bar(range(contexts), accs, color='k')\n", + " axis.set_ylabel('Testing Accuracy (%)')\n", + " axis.set_xticks(range(contexts), [f'Context {i+1}' for i in range(contexts)])\n", + " if title is not None:\n", + " axis.set_title(title)\n", + "\n", + "def plot_examples(axis, dataset, context_id=None):\n", + " '''Plot 25 examples from [dataset].'''\n", + " data_loader = torch.utils.data.DataLoader(dataset, batch_size=25, shuffle=True)\n", + " image_tensor, _ = next(iter(data_loader))\n", + " image_grid = make_grid(image_tensor, nrow=5, pad_value=1) # pad_value=0 would give black borders\n", + " axis.imshow(np.transpose(image_grid.numpy(), (1,2,0)))\n", + " if context_id is not None:\n", + " axis.set_title(\"Context {}\".format(context_id+1))\n", + " axis.axis('off')" + ], + "metadata": { + "id": "yv-AN2xn1mZd", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Part 1: Catastrophic forgetting - Permuted MNIST\n", + "Let's start by trying to set up a simple continual learning experiment, to check whether there is indeed catastrophic forgetting." + ], + "metadata": { + "id": "sFEmAjmVQfRs" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Set up the benchmark (Permuted MNIST)\n", + "For this we will use \"Permuted MNIST\". In this continual learning experiment, in each context (or task), the neural network must learn to classify the ten MNIST digits. However, in each context a different permutation is applied to the pixels of all images.\n", + "\n", + "Permuted MNIST was first used in this paper: https://arxiv.org/abs/1312.6211." + ], + "metadata": { + "id": "wdbrA_V6jrI_" + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's start by specifying a function and a dataset class that we will use to create the various contexts (or tasks) of Permuted MNIST." + ], + "metadata": { + "id": "tm0iox7zklFq" + } + }, + { + "cell_type": "code", + "source": [ + "# Function to apply a given permutation the pixels of an image.\n", + "def permutate_image_pixels(image, permutation):\n", + " '''Permutate the pixels of [image] according to [permutation].'''\n", + "\n", + " if permutation is None:\n", + " return image\n", + " else:\n", + " c, h, w = image.size()\n", + " image = image.view(c, -1)\n", + " image = image[:, permutation] #--> same permutation for each channel\n", + " image = image.view(c, h, w)\n", + " return image" + ], + "metadata": { + "id": "DHjgX-YuyvFj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Class to create a dataset with images that have all been transformed in the same way.\n", + "class TransformedDataset(torch.utils.data.Dataset):\n", + " '''To modify an existing dataset with a transform.\n", + " Useful for creating different permutations of MNIST without loading the data multiple times.'''\n", + "\n", + " def __init__(self, original_dataset, transform=None, target_transform=None):\n", + " super().__init__()\n", + " self.dataset = original_dataset\n", + " self.transform = transform\n", + " self.target_transform = target_transform\n", + "\n", + " def __len__(self):\n", + " return len(self.dataset)\n", + "\n", + " def __getitem__(self, index):\n", + " (input, target) = self.dataset[index]\n", + " if self.transform:\n", + " input = self.transform(input)\n", + " if self.target_transform:\n", + " target = self.target_transform(target)\n", + " return (input, target)" + ], + "metadata": { + "id": "PlVMxtWVyhaa" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's use these tools to create a Permuted MNIST benchmark with 2 contexts." + ], + "metadata": { + "id": "oGt1bpQkk8Kw" + } + }, + { + "cell_type": "code", + "source": [ + "contexts = 2" + ], + "metadata": { + "id": "EklsnmDolDbR" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Specify for each context the permutations to use (with no permutation for the first context)\n", + "permutations = [None] + [np.random.permutation(config['size']**2) for _ in range(contexts-1)]" + ], + "metadata": { + "id": "XGx9n5ezlvzf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Specify for each context the transformed train- and testset\n", + "train_datasets = []\n", + "test_datasets = []\n", + "for context_id, perm in enumerate(permutations):\n", + " train_datasets.append(TransformedDataset(\n", + " MNIST_trainset, transform=transforms.Lambda(lambda x, p=perm: permutate_image_pixels(x, p)),\n", + " ))\n", + " test_datasets.append(TransformedDataset(\n", + " MNIST_testset, transform=transforms.Lambda(lambda x, p=perm: permutate_image_pixels(x, p)),\n", + " ))" + ], + "metadata": { + "id": "AVAF1WGnyVlY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the contexts\n", + "figure, axis = plt.subplots(1, contexts, figsize=(3*contexts, 4))\n", + "\n", + "for context_id in range(len(train_datasets)):\n", + " plot_examples(axis[context_id], train_datasets[context_id], context_id=context_id)" + ], + "metadata": { + "id": "w0tTkEFZy-VU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Set up the model\n", + "Now it is time to define the neural network model that we will sequentially train on these two contexts." + ], + "metadata": { + "id": "A9GSVyeAl1nh" + } + }, + { + "cell_type": "markdown", + "source": [ + "We start by specifying some \"helper functions\" and \"helper code\" that make it easier to specify the model. If you are interested you can have a look at the code in the cell below, but that is not needed to follow the rest of this tutorial.\n", + "\n", + "**It is however needed to run the code in the below cell!**" + ], + "metadata": { + "id": "xwfRu6HTmoSS" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Helper functions\n", + "\n", + "class Identity(torch.nn.Module):\n", + " '''A nn-module to simply pass on the input data.'''\n", + " def forward(self, x):\n", + " return x\n", + "\n", + " def __repr__(self):\n", + " tmpstr = self.__class__.__name__ + '()'\n", + " return tmpstr\n", + "\n", + "\n", + "class Flatten(torch.nn.Module):\n", + " '''A nn-module to flatten a multi-dimensional tensor to 2-dim tensor.'''\n", + " def forward(self, x):\n", + " batch_size = x.size(0) # first dimenstion should be batch-dimension.\n", + " return x.view(batch_size, -1)\n", + "\n", + " def __repr__(self):\n", + " tmpstr = self.__class__.__name__ + '()'\n", + " return tmpstr\n", + "\n", + "\n", + "class fc_layer(torch.nn.Module):\n", + " '''Fully connected layer, with possibility of returning \"pre-activations\".\n", + "\n", + " Input: [batch_size] x ... x [in_size] tensor\n", + " Output: [batch_size] x ... x [out_size] tensor'''\n", + "\n", + " def __init__(self, in_size, out_size, nl=torch.nn.ReLU(), bias=True):\n", + " super().__init__()\n", + " self.bias = bias\n", + " self.linear = torch.nn.Linear(in_size, out_size, bias=bias)\n", + " if isinstance(nl, torch.nn.Module):\n", + " self.nl = nl\n", + " elif nl==\"relu\":\n", + " self.nl = torch.nn.ReLU()\n", + " elif nl==\"leakyrelu\":\n", + " self.nl = torch.nn.LeakyReLU()\n", + "\n", + " def forward(self, x):\n", + " pre_activ = self.linear(x)\n", + " output = self.nl(pre_activ) if hasattr(self, 'nl') else pre_activ\n", + " return output\n", + "\n", + "\n", + "class MLP(torch.nn.Module):\n", + " '''Module for a multi-layer perceptron (MLP).\n", + "\n", + " Input: [batch_size] x ... x [size_per_layer[0]] tensor\n", + " Output: (tuple of) [batch_size] x ... x [size_per_layer[-1]] tensor'''\n", + "\n", + " def __init__(self, input_size=1000, output_size=10, layers=2,\n", + " hid_size=1000, hid_smooth=None, size_per_layer=None,\n", + " nl=\"relu\", bias=True, output='normal'):\n", + " '''sizes: 0th=[input], 1st=[hid_size], ..., 1st-to-last=[hid_smooth], last=[output].\n", + " [input_size] # of inputs\n", + " [output_size] # of units in final layer\n", + " [layers] # of layers\n", + " [hid_size] # of units in each hidden layer\n", + " [hid_smooth] if None, all hidden layers have [hid_size] units, else # of units linearly in-/decreases s.t.\n", + " final hidden layer has [hid_smooth] units (if only 1 hidden layer, it has [hid_size] units)\n", + " [size_per_layer] None or with for each layer number of units (1st element = number of inputs)\n", + " --> overwrites [input_size], [output_size], [layers], [hid_size] and [hid_smooth]\n", + " [nl] ; type of non-linearity to be used (options: \"relu\", \"leakyrelu\", \"none\")\n", + " [output] ; if - \"normal\", final layer is same as all others\n", + " - \"none\", final layer has no non-linearity\n", + " - \"sigmoid\", final layer has sigmoid non-linearity'''\n", + "\n", + " super().__init__()\n", + " self.output = output\n", + "\n", + " # get sizes of all layers\n", + " if size_per_layer is None:\n", + " hidden_sizes = []\n", + " if layers > 1:\n", + " if (hid_smooth is not None):\n", + " hidden_sizes = [int(x) for x in np.linspace(hid_size, hid_smooth, num=layers-1)]\n", + " else:\n", + " hidden_sizes = [int(x) for x in np.repeat(hid_size, layers - 1)]\n", + " size_per_layer = [input_size] + hidden_sizes + [output_size] if layers>0 else [input_size]\n", + " self.layers = len(size_per_layer)-1\n", + "\n", + " # set label for this module\n", + " # -determine \"non-default options\"-label\n", + " nd_label = \"{bias}{nl}\".format(\n", + " bias=\"\" if bias else \"n\",\n", + " nl=\"l\" if nl==\"leakyrelu\" else (\"n\" if nl==\"none\" else \"\"),\n", + " )\n", + " nd_label = \"{}{}\".format(\"\" if nd_label==\"\" else \"-{}\".format(nd_label),\n", + " \"\" if output==\"normal\" else \"-{}\".format(output))\n", + " # -set label\n", + " size_statement = \"\"\n", + " for i in size_per_layer:\n", + " size_statement += \"{}{}\".format(\"-\" if size_statement==\"\" else \"x\", i)\n", + " self.label = \"F{}{}\".format(size_statement, nd_label) if self.layers>0 else \"\"\n", + "\n", + " # set layers\n", + " for lay_id in range(1, self.layers+1):\n", + " # number of units of this layer's input and output\n", + " in_size = size_per_layer[lay_id-1]\n", + " out_size = size_per_layer[lay_id]\n", + " # define and set the fully connected layer\n", + " layer = fc_layer(\n", + " in_size, out_size, bias=bias,\n", + " nl=(\"none\" if output==\"none\" else nn.Sigmoid()) if (\n", + " lay_id==self.layers and not output==\"normal\"\n", + " ) else nl,\n", + " )\n", + " setattr(self, 'fcLayer{}'.format(lay_id), layer)\n", + "\n", + " # if no layers, add \"identity\"-module to indicate in this module's representation nothing happens\n", + " if self.layers<1:\n", + " self.noLayers = Identity()\n", + "\n", + " def forward(self, x):\n", + " for lay_id in range(1, self.layers + 1):\n", + " x = getattr(self, \"fcLayer{}\".format(lay_id))(x)\n", + " return x\n", + "\n", + " @property\n", + " def name(self):\n", + " return self.label" + ], + "metadata": { + "cellView": "form", + "id": "W5zR4KSamLJT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's specify a class for a basic neural network classifier model." + ], + "metadata": { + "id": "UOymyzR9p3ob" + } + }, + { + "cell_type": "code", + "source": [ + "class Classifier(torch.nn.Module):\n", + " '''Model for classifying images.'''\n", + "\n", + " def __init__(self, image_size, image_channels, output_units,\n", + " fc_layers=3, fc_units=1000, fc_nl=\"relu\", bias=True):\n", + "\n", + " super().__init__()\n", + "\n", + " # Flatten image to 2D-tensor\n", + " self.flatten = Flatten()\n", + "\n", + " # Specify the fully connected hidden layers\n", + " input_size = image_channels * image_size * image_size\n", + " self.fcE = MLP(input_size=input_size, output_size=fc_units, layers=fc_layers-1,\n", + " hid_size=fc_units, nl=fc_nl, bias=bias)\n", + " mlp_output_size = fc_units if fc_layers>1 else self.input_size\n", + "\n", + " # Specify the final linear classifier layer\n", + " self.classifier = fc_layer(mlp_output_size, output_units, nl='none')\n", + "\n", + " def forward(self, x):\n", + " flatten_x = self.flatten(x)\n", + " final_features = self.fcE(flatten_x)\n", + " out = self.classifier(final_features)\n", + " return out" + ], + "metadata": { + "id": "s5hXbEWan7w0" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's create an instance of such a classifier model, and print some details of it to screen." + ], + "metadata": { + "id": "SoADM8X_qCSk" + } + }, + { + "cell_type": "code", + "source": [ + "# Specify the architectural layout of the network to use\n", + "fc_lay = 4 #--> number of fully-connected layers\n", + "fc_units = 40 #--> number of units in each hidden layer\n", + "fc_nl = \"relu\" #--> what non-linearity to use?" + ], + "metadata": { + "id": "pQJISF0xqJ2B" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Define the model\n", + "model = Classifier(image_size=config['size'], image_channels=config['channels'],\n", + " output_units=config['classes'],\n", + " fc_layers=fc_lay, fc_units=fc_units, fc_nl=fc_nl)" + ], + "metadata": { + "id": "JHKjU4MUqT4f" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print the network architecture\n", + "model" + ], + "metadata": { + "id": "LsSDP19EqZHs" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Print info regarding number of parameters\n", + "total_params = 0\n", + "for param in model.parameters():\n", + " n_params = index_dims = 0\n", + " for dim in param.size():\n", + " n_params = dim if index_dims==0 else n_params*dim\n", + " index_dims += 1\n", + " total_params += n_params\n", + "print( \"--> this network has {} parameters (~{}K)\"\n", + " .format(total_params, round(total_params / 1000)))" + ], + "metadata": { + "id": "sPe52AA8qY4U" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Train on first context\n", + "It's time to start training the model on the first context (i.e., the regular MNIST dataset)." + ], + "metadata": { + "id": "Pg_98FO7q7SI" + } + }, + { + "cell_type": "markdown", + "source": [ + "To do this, let's define a function to that can train a given neural network (i.e., `model`) on a particular dataset (i.e., `dataset`). We can then later re-use this function, for example to train the network on the dataset of the second context.\n", + "\n", + "We can also specify the number of iterations we want to train for, the learning rate and the mini batch-size." + ], + "metadata": { + "id": "jbtG3Elh5wbV" + } + }, + { + "cell_type": "code", + "source": [ + "def train(model, dataset, iters, lr, batch_size):\n", + " # Define the optimizer\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=lr, betas=(0.9, 0.999))\n", + "\n", + " # Set model in training-mode\n", + " model.train()\n", + "\n", + " # Initialize # iters left on current data-loader(s)\n", + " iters_left = 1\n", + "\n", + " # Define tqdm progress bar(s)\n", + " progress_bar = tqdm.tqdm(range(1, iters+1))\n", + "\n", + " # Loop over all iterations\n", + " for batch_index in range(1, iters+1):\n", + "\n", + " # Update # iters left on current data-loader(s) and, if needed, create new one(s)\n", + " iters_left -= 1\n", + " if iters_left==0:\n", + " data_loader = iter(torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=True, drop_last=True))\n", + " iters_left = len(data_loader)\n", + "\n", + " # Sample training data of current context\n", + " x, y = next(data_loader)\n", + "\n", + " # Reset optimizer\n", + " optimizer.zero_grad()\n", + "\n", + " # Run model\n", + " y_hat = model(x)\n", + "\n", + " # Calculate prediction loss\n", + " loss = torch.nn.functional.cross_entropy(input=y_hat, target=y, reduction='mean')\n", + "\n", + " # Calculate training-accuracy (in %)\n", + " accuracy = (y == y_hat.max(1)[1]).sum().item()*100 / x.size(0)\n", + "\n", + " # Backpropagate errors\n", + " loss.backward()\n", + "\n", + " # Take the optimizer step\n", + " optimizer.step()\n", + "\n", + " # Update progress bar\n", + " progress_bar.set_description(\n", + " ' | training loss: {loss:.3} | training accuracy: {prec:.3}% |'\n", + " .format(loss=loss.item(), prec=accuracy)\n", + " )\n", + " progress_bar.update(1)\n", + "\n", + " # Close the progress bar\n", + " progress_bar.close()" + ], + "metadata": { + "id": "yNJOs8Vj54Ub" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now we need to choose the training hyperparameters (i.e., learning rate, batch size and number of iterations)." + ], + "metadata": { + "id": "DlFBimOt7Tbx" + } + }, + { + "cell_type": "code", + "source": [ + "iters = 200 # for how many iterations to train?\n", + "lr = 0.01 # learning rate\n", + "batch_size = 128 # size of mini-batches" + ], + "metadata": { + "id": "ITZJbebd7cZY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "And let's train our neural network on the first context." + ], + "metadata": { + "id": "XyTV4Ee_7d9a" + } + }, + { + "cell_type": "code", + "source": [ + "# Train the model on the first context\n", + "train(model, dataset=train_datasets[0], iters=iters, lr=lr, batch_size=batch_size)" + ], + "metadata": { + "id": "GJrEXhHwtO69" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Evaluate\n", + "Did the training work? Let's find out by evaluating the performance of the trained model on the MNIST test set." + ], + "metadata": { + "id": "_XeVQWFWtSo9" + } + }, + { + "cell_type": "markdown", + "source": [ + "Again, let's start by specifying a function to evaluate any given model (i.e., `model`) on a specific dataset (i.e., `dataset`)." + ], + "metadata": { + "id": "gYkoS0NYyYC-" + } + }, + { + "cell_type": "code", + "source": [ + "def test_acc(model, dataset, test_size=None, batch_size=128):\n", + " '''Evaluate accuracy (% samples classified correctly) of a classifier ([model]) on [dataset].'''\n", + "\n", + " # Set model to eval()-mode\n", + " mode = model.training\n", + " model.eval()\n", + "\n", + " # Loop over batches in [dataset]\n", + " data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=True, drop_last=False)\n", + " total_tested = total_correct = 0\n", + " for x, y in data_loader:\n", + " # -break on [test_size] (if \"None\", full dataset is used)\n", + " if test_size:\n", + " if total_tested >= test_size:\n", + " break\n", + " # -evaluate model\n", + " with torch.no_grad():\n", + " scores = model(x)\n", + " _, predicted = torch.max(scores, 1)\n", + " # -update statistics\n", + " total_correct += (predicted == y).sum().item()\n", + " total_tested += len(x)\n", + " accuracy = total_correct*100 / total_tested\n", + "\n", + " # Set model back to its initial mode, print result on screen (if requested) and return it\n", + " model.train(mode=mode)\n", + "\n", + " return accuracy" + ], + "metadata": { + "id": "oeR-wzk7trnq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's use this function to evaluate the performance of the model on both the test data from context 1 (i.e., regular MNIST, on which the model was just trained) and on the test data from context 2 (i.e., a permuted version of MNIST, on which the model has not yet been trained)." + ], + "metadata": { + "id": "oy0jxo7GzTZS" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluate accuracy per context and print to screen\n", + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "context1_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " context1_accs.append(acc)" + ], + "metadata": { + "id": "RLbnEFYizT-T" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "The model does well on test data from context 1, but is around chance level for test data from context 2.\n", + "\n", + "This is not very surprising, as we have not yet trained the model on context 2!" + ], + "metadata": { + "id": "tDX1C8e80Ous" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Store model copy (for later)\n", + "Before continuing to train the model on the second context, let's store a copy of the model after training on the first context. We will later use this model copy to try out different ways of training the same model on the second context (i.e., we will try out different continual learning methods)." + ], + "metadata": { + "id": "nuSXFD-O00ZJ" + } + }, + { + "cell_type": "code", + "source": [ + "model_after_context1 = copy.deepcopy(model)" + ], + "metadata": { + "id": "hfDXSlr903z-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Train on second context\n", + "Now let's continue to train our model on the second context, and see what happens." + ], + "metadata": { + "id": "KG5vmXzrtVY-" + } + }, + { + "cell_type": "code", + "source": [ + "# Continue to train the model on the second context\n", + "train(model, dataset=train_datasets[1], iters=iters, lr=lr, batch_size=batch_size)" + ], + "metadata": { + "id": "Qm8nl4vZ8Qg8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Evaluate" + ], + "metadata": { + "id": "gzz4tXXFtXbT" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluate accuracy per context and print to screen\n", + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "context2_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " context2_accs.append(acc)" + ], + "metadata": { + "id": "FHVaWONJtsps" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Train on both contexts at the same time" + ], + "metadata": { + "id": "Rq6PsBLitcRr" + } + }, + { + "cell_type": "code", + "source": [ + "# Define a new model with same architecture\n", + "model_joint = Classifier(image_size=config['size'], image_channels=config['channels'],\n", + " output_units=config['classes'],\n", + " fc_layers=fc_lay, fc_units=fc_units, fc_nl=fc_nl)" + ], + "metadata": { + "id": "ix_3i8cittOj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Create a joint dataset with data from both contexts\n", + "joint_trainset = torch.utils.data.ConcatDataset(train_datasets)" + ], + "metadata": { + "id": "y4trFHRl9jEk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We will use the same training-hyperparameters, except that we double the batch size." + ], + "metadata": { + "id": "Ldr-Z3Xa9Vgq" + } + }, + { + "cell_type": "code", + "source": [ + "batch_size_joint = 256" + ], + "metadata": { + "id": "ON_nH7Ap94R6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Train the joint model\n", + "train(model_joint, dataset=joint_trainset, iters=iters, lr=lr, batch_size=batch_size_joint)" + ], + "metadata": { + "id": "HP73reGQ-KlI" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Evaluate the model\n", + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "joint_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model_joint, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " joint_accs.append(acc)" + ], + "metadata": { + "id": "ngV6LI73-zKV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Visualize results" + ], + "metadata": { + "id": "jot0FyzK--uE" + } + }, + { + "cell_type": "code", + "source": [ + "# Visualize\n", + "figure, axis = plt.subplots(1, 4, figsize=(15, 5))\n", + "\n", + "title='After training on context 1, \\nbut not yet training on context 2'\n", + "multi_context_barplot(axis[0], context1_accs, title)\n", + "\n", + "title='After first training on context 1, \\nand then training on context 2'\n", + "multi_context_barplot(axis[1], context2_accs, title)\n", + "\n", + "axis[2].axis('off')\n", + "\n", + "title='After jointly training on both contexts'\n", + "multi_context_barplot(axis[3], joint_accs, title)" + ], + "metadata": { + "id": "OJEcM-8i_CAV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We have observed **catastrophic forgetting**! When our neural network model first learns context 1 and is then trained on context 2, the model's performance on data from context 1 substantially drops (left panels). When the same neural network model is instead trained on both context 1 and 2 at the same time, the model is able to learn both contexts well (right panel), demonstrating that the forgetting cannot be explained by limited model capacity." + ], + "metadata": { + "id": "pWWeiBRcyaCH" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Part 2: Overcoming catastrophic forgetting - EWC & replay" + ], + "metadata": { + "id": "HrAUoOovzzMf" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now that we found catastrophic forgetting, let's try out some methods to mitigate the forgetting.\n", + "\n", + "We will start by exploring two methods: EWC and replay. For both methods, the training on the first context is the same as before. We can therefore use as starting point the copy of the model that we stored after finishing training on the first context." + ], + "metadata": { + "id": "q6ox4ZT10EGB" + } + }, + { + "cell_type": "code", + "source": [ + "model_ewc = copy.deepcopy(model_after_context1)\n", + "model_replay = copy.deepcopy(model_after_context1)" + ], + "metadata": { + "id": "z9FGHT8Z161d" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Elastic Weight Consolidation (EWC)\n", + "EWC is a popular parameter regularization strategy for continual learning. It was introduced in the paper \"[Overcoming catastrophic forgetting in neural networks\n", + "](https://www.pnas.org/doi/abs/10.1073/pnas.1611835114)\" (Kirkpatrick et al., 2017; *PNAS*).\n", + "\n", + "EWC computes a diagonal approximation to the [Fisher Information matrix]((https://en.wikipedia.org/wiki/Fisher_information) to estimate for each parameter of the network how important it is for the performance on the previous context. During training on the next context, these parameter importance estimates are then used to penalize changes to the parameters, with changes to the most important parameters penalized most.\n", + "\n" + ], + "metadata": { + "id": "s7dQ5itP0RJc" + } + }, + { + "cell_type": "markdown", + "source": [ + "When training on context $k>1$, the EWC regularization term is given by:\n", + "$$\n", + "\\mathcal{L}^{(k)}_{\\text{regularization}_{\\text{EWC}}}\\left(\\boldsymbol{\\theta}\\right) = \\frac{1}{2} \\sum_{i=1}^{N_{\\text{params}}} \\tilde{F}_{ii}^{(k)} \\left(\\theta_i - \\hat{\\theta}_{i}^{(k)} \\right)^2\n", + "$$\n", + "whereby $\\hat{\\theta}_{i}^{(k)}$ is the $i^{\\text{th}}$ element of $\\hat{\\boldsymbol{\\theta}}^{\\left(k\\right)}$, which is the vector with parameter values at the end of training of task $k$, and $\\tilde{F}_{ii}^{(k)}$ is an approximation of $F_{ii}^{(k)}$, the $i^{\\text{th}}$ diagonal element of $\\boldsymbol{F}^{(k)}$, which is the Fisher Information matrix of task $k$ evaluated at $\\hat{\\boldsymbol{\\theta}}^{(k)}$." + ], + "metadata": { + "id": "OcXpF4N6kyc_" + } + }, + { + "cell_type": "markdown", + "source": [ + "(Technically, the above regularization term is for `[Online EWC](https://arxiv.org/abs/1805.06370)'. The original version of EWC did something weird, as explained in [this blog post](https://www.inference.vc/comment-on-overcoming-catastrophic-forgetting-in-nns-are-multiple-penalties-needed-2/).)" + ], + "metadata": { + "id": "uRJG6pGDoj_O" + } + }, + { + "cell_type": "markdown", + "source": [ + "The Fisher Information matrix is defined as the covariance of the `score', which is the partial derivative with respect to $\\boldsymbol{\\theta}$ of the natural logarithm of the likelihood function. The $i^{\\text{th}}$ diagonal element of the Fisher Information on context $k$ is therefore given by:\n", + "\n", + "$$\n", + "F_{ii}^{(k)} = \\mathbb{E}_{\\boldsymbol{x}\\sim Q_{\\boldsymbol{x}}^{(k)}} \\left[ \\ \\mathbb{E}_{p_{\\hat{\\boldsymbol{\\theta}}^{(k)}}} \\left[ \\left( \\left. \\frac{\\delta \\log{p_{\\boldsymbol{\\theta}}\\left(Y=y|\\boldsymbol{x}\\right)}}{\\delta \\theta_i} \\right\\rvert_{\\boldsymbol{\\theta}=\\hat{\\boldsymbol{\\theta}}^{(k)}} \\right)^2 \\right] \\right]\n", + "$$\n", + "\n", + "whereby $Q_{\\boldsymbol{x}}^{(k)}$ is the input distribution of context $k$, $p_{\\boldsymbol{\\theta}}$ is the conditional distribution of $y$ given $\\boldsymbol{x}$ defined by the neural network with parameters $\\boldsymbol{\\theta}$, and $\\hat{\\boldsymbol{\\theta}}^{(k)}$ is the vector with parameter values after finisihing training on context $k$." + ], + "metadata": { + "id": "C_8xnOyI-D5_" + } + }, + { + "cell_type": "markdown", + "source": [ + "The outer expectation in the above equation can be approximated using a random sample from the training set of context $k$. Because there is only a finit number of possible classes, the inner expectation in the above equation can be calculated for each sample exactly:\n", + "$$\n", + "\\tilde{F}_{ii}^{(k)} = \\frac{1}{|S^{(k)}|} \\sum_{\\boldsymbol{x}\\in S^{(k)}} \\left( \\sum_{c=1}^{N_{\\text{classes}}} \\tilde{y}_c \\left( \\left. \\frac{\\delta\\log p_{\\boldsymbol{\\theta}}\\left(Y=c|\\boldsymbol{x}\\right)}{\\delta\\theta_i} \\right\\rvert_{\\boldsymbol{\\theta}=\\hat{\\boldsymbol{\\theta}}^{(k)}} \\right)^2 \\right)\n", + "$$\n", + "whereby $S^{(k)}$ is the random sample of training data of context $k$ and $\\tilde{y}_c = p_{\\hat{\\boldsymbol{\\theta}}^{(k)}}\\left(Y=c|\\boldsymbol{x}\\right)$ (i.e., the probability that input $\\boldsymbol{x}$ belongs to class $c$ as predicted by the model after finishing training on context $k$)." + ], + "metadata": { + "id": "8MMh_ZZslXpd" + } + }, + { + "cell_type": "markdown", + "source": [ + "**In the literature or on GitHub, often different, rather crude approximations of the Fisher Information are used ([example](https://github.com/ContinualAI/avalanche/blob/dbdc3804b11710b85b0e564b13034f487c7cf806/avalanche/training/plugins/ewc.py#L132-L186)). Be careful, as the quality of this approximation might influence the results!**" + ], + "metadata": { + "id": "Uitfc1Hom_cC" + } + }, + { + "cell_type": "code", + "source": [ + "def estimate_fisher(model, dataset, n_samples, ewc_gamma=1.):\n", + " '''Estimate diagonal of Fisher Information matrix for [model] on [dataset] using [n_samples].'''\n", + "\n", + " # Prepare to store estimated Fisher Information matrix\n", + " est_fisher_info = {}\n", + " for n, p in model.named_parameters():\n", + " n = n.replace('.', '__')\n", + " est_fisher_info[n] = p.detach().clone().zero_()\n", + "\n", + " # Set model to evaluation mode\n", + " mode = model.training\n", + " model.eval()\n", + "\n", + " # Create data-loader to give batches of size 1\n", + " data_loader = torch.utils.data.DataLoader(dataset, batch_size=1)\n", + "\n", + " # Estimate the FI-matrix for [n_samples] batches of size 1\n", + " for index,(x,y) in enumerate(data_loader):\n", + " # break from for-loop if max number of samples has been reached\n", + " if n_samples is not None:\n", + " if index > n_samples:\n", + " break\n", + " # run forward pass of model\n", + " output = model(x)\n", + " # calculate the FI-matrix\n", + " with torch.no_grad():\n", + " label_weights = F.softmax(output, dim=1) #--> get weights, with no gradient tracked\n", + " # - loop over all classes\n", + " for label_index in range(output.shape[1]):\n", + " label = torch.LongTensor([label_index])\n", + " negloglikelihood = F.cross_entropy(output, label)\n", + " # Calculate gradient of negative loglikelihood for this class\n", + " model.zero_grad()\n", + " negloglikelihood.backward(retain_graph=True if (label_index+1)1:\n", + " ewc_losses = []\n", + " for n, p in model.named_parameters():\n", + " # Retrieve stored mode (MAP estimate) and precision (Fisher Information matrix)\n", + " n = n.replace('.', '__')\n", + " mean = getattr(model, '{}_EWC_param_values'.format(n))\n", + " fisher = getattr(model, '{}_EWC_estimated_fisher'.format(n))\n", + " # Calculate weight regularization loss\n", + " ewc_losses.append((fisher * (p-mean)**2).sum())\n", + " ewc_loss = (1./2)*sum(ewc_losses)\n", + " total_loss = loss + ewc_lambda*ewc_loss\n", + " else:\n", + " total_loss = loss\n", + "\n", + " accuracy = (y == y_hat.max(1)[1]).sum().item()*100 / x.size(0)\n", + " total_loss.backward()\n", + " optimizer.step()\n", + " progress_bar.set_description(\n", + " ' | training loss: {loss:.3} | training accuracy: {prec:.3}% |'\n", + " .format(loss=total_loss.item(), prec=accuracy)\n", + " )\n", + " progress_bar.update(1)\n", + " progress_bar.close()" + ], + "metadata": { + "id": "JjDl0lsg0Vs_" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's train the model on the second context using EWC." + ], + "metadata": { + "id": "8ikYkBt-JMm6" + } + }, + { + "cell_type": "code", + "source": [ + "# Estimate the FI-matrix (and store it as attribute in the network)\n", + "estimate_fisher(model_ewc, train_datasets[0], n_samples=200)" + ], + "metadata": { + "id": "mvW1FKRNJU2F" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Train on the second context using EWC parameter regularization\n", + "ewc_lambda = 100 #--> this is a \"continual learning hyperparameter\", setting these is a delicate\n", + " # business. Here we ignore that and just use one that gives good performance.\n", + "train_ewc(model_ewc, train_datasets[1], iters=iters, lr=lr, batch_size=batch_size,\n", + " current_context=2, ewc_lambda=ewc_lambda)" + ], + "metadata": { + "id": "9UjjXJtLJUg7" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "... and evaluate its performance." + ], + "metadata": { + "id": "60zj34suJVYJ" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluate the model\n", + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "ewc_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model_ewc, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " ewc_accs.append(acc)" + ], + "metadata": { + "id": "jiNB3edeJZ-L" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "That worked well! The performance on the first context barely dropped while the network learned the second context." + ], + "metadata": { + "id": "vSfLqS87Vm5e" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Experience Replay\n", + "For comparison, now let's train another model copy on the second context using 'experience replay'.\n", + "\n", + "The typical approach is to store a relatively small amount of samples from previous contexts, and revisit those when training on a new context. We thus first need to populate a memory buffer with some samples from the first context. We select these samples using class-balanced random sampling from the training set (other approaches are possible here, how to optimally select the samples to store in the memory buffer is an active field of research)." + ], + "metadata": { + "id": "bLC3-drp0TIk" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Helper dataset classes for constructing memory buffer\n", + "class SubDataset(torch.utils.data.Dataset):\n", + " '''To sub-sample a dataset, taking only those samples with label in [sub_labels].\n", + "\n", + " After this selection of samples has been made, it is possible to transform the target-labels,\n", + " which can be useful when doing continual learning with fixed number of output units.'''\n", + "\n", + " def __init__(self, original_dataset, sub_labels, target_transform=None):\n", + " super().__init__()\n", + " self.dataset = original_dataset\n", + " self.sub_indeces = []\n", + " for index in range(len(self.dataset)):\n", + " if hasattr(original_dataset, \"targets\"):\n", + " if self.dataset.target_transform is None:\n", + " label = self.dataset.targets[index]\n", + " else:\n", + " label = self.dataset.target_transform(self.dataset.targets[index])\n", + " else:\n", + " label = self.dataset[index][1]\n", + " if label in sub_labels:\n", + " self.sub_indeces.append(index)\n", + " self.target_transform = target_transform\n", + "\n", + " def __len__(self):\n", + " return len(self.sub_indeces)\n", + "\n", + " def __getitem__(self, index):\n", + " sample = self.dataset[self.sub_indeces[index]]\n", + " if self.target_transform:\n", + " target = self.target_transform(sample[1])\n", + " sample = (sample[0], target)\n", + " return sample\n", + "\n", + "\n", + "class MemorySetDataset(torch.utils.data.Dataset):\n", + " '''Create dataset from list of with shape (N, C, H, W) (i.e., with N images each).\n", + "\n", + " The images at the i-th entry of [memory_sets] belong to class [i],\n", + " unless a [target_transform] is specified\n", + " '''\n", + "\n", + " def __init__(self, memory_sets, target_transform=None):\n", + " super().__init__()\n", + " self.memory_sets = memory_sets\n", + " self.target_transform = target_transform\n", + "\n", + " def __len__(self):\n", + " total = 0\n", + " for class_id in range(len(self.memory_sets)):\n", + " total += len(self.memory_sets[class_id])\n", + " return total\n", + "\n", + " def __getitem__(self, index):\n", + " total = 0\n", + " for class_id in range(len(self.memory_sets)):\n", + " examples_in_this_class = len(self.memory_sets[class_id])\n", + " if index < (total + examples_in_this_class):\n", + " class_id_to_return = class_id if self.target_transform is None else self.target_transform(class_id)\n", + " example_id = index - total\n", + " break\n", + " else:\n", + " total += examples_in_this_class\n", + " image = torch.from_numpy(self.memory_sets[class_id][example_id])\n", + " return (image, class_id_to_return)" + ], + "metadata": { + "id": "06uwJLSlYfYs", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Fill the memory buffer using class-balanced random sampling\n", + "def fill_memory_buffer(memory_sets, dataset, buffer_size_per_class, class_indeces):\n", + " '''This function is rather slow and can be optimized.'''\n", + " for class_id in class_indeces:\n", + " # Create dataset with only instances of one class\n", + " class_dataset = SubDataset(original_dataset=dataset, sub_labels=[class_id])\n", + "\n", + " # Randomly select which indeces to store in the buffer\n", + " n_total = len(class_dataset)\n", + " indeces_selected = np.random.choice(n_total, size=min(buffer_size_per_class, n_total),\n", + " replace=False)\n", + "\n", + " # Select those indeces\n", + " memory_set = []\n", + " for k in indeces_selected:\n", + " memory_set.append(class_dataset[k][0].numpy())\n", + "\n", + " # Add this [memory_set] as a [n]x[ich]x[isz]x[isz] to the list of [memory_sets]\n", + " memory_sets.append(np.array(memory_set))\n", + "\n", + " return memory_sets" + ], + "metadata": { + "id": "Ll7YdfMo0VSl" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "buffer_size_per_class = 20\n", + "memory_sets = []\n", + "# The next command is unneccesary slow, apologies! Bonus question: optimize this implementation :)\n", + "memory_sets = fill_memory_buffer(memory_sets, train_datasets[0],\n", + " buffer_size_per_class=buffer_size_per_class,\n", + " class_indeces=list(range(10)))\n", + "buffer_dataset = MemorySetDataset(memory_sets)" + ], + "metadata": { + "id": "0Bbg05iTOye4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now we also need to define a new training-function that revisits data from the memory buffer along with training on the data from the new context." + ], + "metadata": { + "id": "XA5cDdKSO_Pq" + } + }, + { + "cell_type": "code", + "source": [ + "# (only the steps that differ from the original `train`-function are commented)\n", + "def train_replay(model, dataset, iters, lr, batch_size, current_context, buffer_dataset=None):\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=lr, betas=(0.9, 0.999))\n", + " model.train()\n", + " iters_left = 1\n", + " iters_left_replay = 1\n", + " progress_bar = tqdm.tqdm(range(1, iters+1))\n", + "\n", + " for batch_index in range(1, iters+1):\n", + " optimizer.zero_grad()\n", + "\n", + " # Data from current context\n", + " iters_left -= 1\n", + " if iters_left==0:\n", + " data_loader = iter(torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=True, drop_last=True))\n", + " iters_left = len(data_loader)\n", + " x, y = next(data_loader)\n", + " y_hat = model(x)\n", + " loss = torch.nn.functional.cross_entropy(input=y_hat, target=y, reduction='mean')\n", + " accuracy = (y == y_hat.max(1)[1]).sum().item()*100 / x.size(0)\n", + "\n", + " # Replay data from memory buffer\n", + " if buffer_dataset is not None:\n", + " iters_left_replay -= 1\n", + " if iters_left_replay==0:\n", + " batch_size_to_use = min(batch_size, len(buffer_dataset))\n", + " data_loader_replay = iter(torch.utils.data.DataLoader(buffer_dataset,\n", + " batch_size_to_use, shuffle=True,\n", + " drop_last=True))\n", + " iters_left_replay = len(data_loader_replay)\n", + " x_, y_ = next(data_loader_replay)\n", + " y_hat_ = model(x_)\n", + " loss_replay = torch.nn.functional.cross_entropy(input=y_hat_, target=y_, reduction='mean')\n", + "\n", + " # Combine both losses to approximate the joint loss over both contexts\n", + " # (i.e., the loss on the replayed data has weight proportional to number of contexts so far)\n", + " if buffer_dataset is not None:\n", + " rnt = 1./current_context\n", + " total_loss = rnt*loss + (1-rnt)*loss_replay\n", + " else:\n", + " total_loss = loss\n", + "\n", + " total_loss.backward()\n", + " optimizer.step()\n", + " progress_bar.set_description(\n", + " ' | training loss: {loss:.3} | training accuracy: {prec:.3}% |'\n", + " .format(loss=total_loss.item(), prec=accuracy)\n", + " )\n", + " progress_bar.update(1)\n", + " progress_bar.close()" + ], + "metadata": { + "id": "FVfyNqsMPIf4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Train on the second context using experience replay\n", + "train_replay(model_replay, train_datasets[1], iters=iters, lr=lr, batch_size=batch_size,\n", + " current_context=2, buffer_dataset=buffer_dataset)" + ], + "metadata": { + "id": "XU8LLSWFUokA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "... and evaluate its performance" + ], + "metadata": { + "id": "H35hMk3zVFs_" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluate the model\n", + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "replay_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model_replay, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " replay_accs.append(acc)" + ], + "metadata": { + "id": "hKuT_aFDVEn0" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "That also worked!" + ], + "metadata": { + "id": "t_ZmSg9hWJiV" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Compare\n", + "Let's compare the performance of naive fine-tuning, EWC and experience replay." + ], + "metadata": { + "id": "Rp4rvzgZVLBT" + } + }, + { + "cell_type": "code", + "source": [ + "figure, axis = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "title='Fine-tuning'\n", + "multi_context_barplot(axis[0], context2_accs, title)\n", + "\n", + "title='EWC \\n(lambda: {})'.format(ewc_lambda)\n", + "multi_context_barplot(axis[1], ewc_accs, title)\n", + "\n", + "title='Replay \\n(buffer: {} samples per class)'.format(buffer_size_per_class)\n", + "multi_context_barplot(axis[2], replay_accs, title)" + ], + "metadata": { + "id": "YWWDQqiFVSc0" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### **ASSIGNMENT**: Combine EWC and replay\n", + "Train another model copy on the second context using *both* EWC and experience replay." + ], + "metadata": { + "id": "kuzoBMh8fh2i" + } + }, + { + "cell_type": "code", + "source": [ + "model_ewc_replay = copy.deepcopy(model_after_context1)" + ], + "metadata": { + "id": "E-vo75W6f1tU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Start by defining the training function that can be used to train the model on the new context using both EWC and experience replay." + ], + "metadata": { + "id": "CxUvSooRgxiZ" + } + }, + { + "cell_type": "code", + "source": [ + "def train_ewc_replay(model, dataset, buffer_dataset, iters, lr, batch_size, ewc_lambda):\n", + " pass\n", + " # TO BE COMPLETED (tip: use the above training functions as example / starting point)" + ], + "metadata": { + "id": "5r96gtzkgWzZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Possible Answer\n", + "def train_ewc_replay(model, dataset, iters, lr, batch_size, current_context,\n", + " ewc_lambda=100., buffer_dataset=None):\n", + " optimizer = torch.optim.Adam(model.parameters(), lr=lr, betas=(0.9, 0.999))\n", + " model.train()\n", + " iters_left = 1\n", + " iters_left_replay = 1\n", + " progress_bar = tqdm.tqdm(range(1, iters+1))\n", + "\n", + " for batch_index in range(1, iters+1):\n", + " optimizer.zero_grad()\n", + "\n", + " # Data from current context\n", + " iters_left -= 1\n", + " if iters_left==0:\n", + " data_loader = iter(torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n", + " shuffle=True, drop_last=True))\n", + " iters_left = len(data_loader)\n", + " x, y = next(data_loader)\n", + " y_hat = model(x)\n", + " loss = torch.nn.functional.cross_entropy(input=y_hat, target=y, reduction='mean')\n", + " accuracy = (y == y_hat.max(1)[1]).sum().item()*100 / x.size(0)\n", + "\n", + " # Replay data from memory buffer\n", + " if buffer_dataset is not None:\n", + " iters_left_replay -= 1\n", + " if iters_left_replay==0:\n", + " batch_size_to_use = min(batch_size, len(buffer_dataset))\n", + " data_loader_replay = iter(torch.utils.data.DataLoader(buffer_dataset,\n", + " batch_size_to_use,\n", + " shuffle=True,\n", + " drop_last=True))\n", + " iters_left_replay = len(data_loader_replay)\n", + " x_, y_ = next(data_loader_replay)\n", + " y_hat_ = model(x_)\n", + " loss_replay = torch.nn.functional.cross_entropy(input=y_hat_, target=y_,\n", + " reduction='mean')\n", + "\n", + " # Compute the EWC-regularization term, and add it to the loss\n", + " if current_context>1:\n", + " ewc_losses = []\n", + " for n, p in model.named_parameters():\n", + " # Retrieve stored mode (MAP estimate) and precision (Fisher Information matrix)\n", + " n = n.replace('.', '__')\n", + " mean = getattr(model, '{}_EWC_param_values'.format(n))\n", + " fisher = getattr(model, '{}_EWC_estimated_fisher'.format(n))\n", + " # Calculate weight regularization loss\n", + " ewc_losses.append((fisher * (p-mean)**2).sum())\n", + " ewc_loss = (1./2)*sum(ewc_losses)\n", + " else:\n", + " ewc_loss = 0.\n", + "\n", + " # Combine all three losses\n", + " if buffer_dataset is not None:\n", + " rnt = 1./current_context\n", + " total_loss = rnt*loss + (1-rnt)*loss_replay + ewc_lambda*ewc_loss\n", + " else:\n", + " total_loss = loss + ewc_lambda*ewc_loss\n", + "\n", + " total_loss.backward()\n", + " optimizer.step()\n", + " progress_bar.set_description(\n", + " ' | training loss: {loss:.3} | training accuracy: {prec:.3}% |'\n", + " .format(loss=total_loss.item(), prec=accuracy)\n", + " )\n", + " progress_bar.update(1)\n", + " progress_bar.close()" + ], + "metadata": { + "id": "qON7O-O1ozuM", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now test your function by training the model, ..." + ], + "metadata": { + "id": "1T2XW32xhAl3" + } + }, + { + "cell_type": "code", + "source": [ + "# Select the hyperparameter for EWC\n", + "ewc_lambda_with_replay = 100 # YOU CAN EXPLORE OTHER VALUES\n", + "# (if you want to do a new try, first 'reset' [model_ewc_replay] by running the command\n", + "# `model_ewc_replay = copy.deepcopy(model_after_context1)` at the top of the assignment)\n", + "\n", + "# Compute the Fisher Information matrix (and store it as attribute in the network)\n", + "estimate_fisher(model_ewc_replay, train_datasets[0], n_samples=200)\n", + "\n", + "# Train on the second context using EWC and experience replay\n", + "train_ewc_replay(model_ewc_replay, train_datasets[1], iters=iters, lr=lr, batch_size=batch_size,\n", + " current_context=2, ewc_lambda=ewc_lambda_with_replay,\n", + " buffer_dataset=buffer_dataset)" + ], + "metadata": { + "id": "bVKKz3xdhBa9" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "... evaluating it, ..." + ], + "metadata": { + "id": "xCAXSuUGhu4B" + } + }, + { + "cell_type": "code", + "source": [ + "print(\"\\n Accuracy (in %) of the model on test-set of:\")\n", + "ewc_replay_accs = []\n", + "for i in range(contexts):\n", + " acc = test_acc(model_ewc_replay, test_datasets[i], test_size=None)\n", + " print(\" - Context {}: {:.1f}\".format(i+1, acc))\n", + " ewc_replay_accs.append(acc)" + ], + "metadata": { + "id": "Damfry4kh7d7" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "... and comparing its performance with the performance of the individual methods." + ], + "metadata": { + "id": "E5zUtbJ3h1EG" + } + }, + { + "cell_type": "code", + "source": [ + "figure, axis = plt.subplots(1, 4, figsize=(16, 4))\n", + "\n", + "title='Fine-tuning'\n", + "multi_context_barplot(axis[0], context2_accs, title)\n", + "\n", + "title='EWC \\n(lambda: {})'.format(ewc_lambda)\n", + "multi_context_barplot(axis[1], ewc_accs, title)\n", + "\n", + "title='Replay \\n(buffer: {} samples per class)'.format(buffer_size_per_class)\n", + "multi_context_barplot(axis[2], replay_accs, title)\n", + "\n", + "title='EWC + replay \\n(lambda: {} - buffer: {} per class)'.format(ewc_lambda_with_replay,\n", + " buffer_size_per_class)\n", + "multi_context_barplot(axis[3], ewc_replay_accs, title)" + ], + "metadata": { + "id": "QWR5Nw4bh7Im" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Part 3: Class-incremental learning - Split MNIST\n", + "We saw that on Permuted MNIST with two contexts, both EWC and experience replay (with a relatively small buffer of 20 samples per class) are able to succesfully prevent a large part of the catastrophic forgetting.\n", + "\n", + "Now let's look at a different type of continual learning problem. As discussed in the lecture, when it comes to supervised continual learning, three fundamental types - or 'scenarios' - can be distinguished: **task-incremental learning**, **domain-incremental learning** and **class-incremental learning**." + ], + "metadata": { + "id": "tW8VSZ_90BDN" + } + }, + { + "cell_type": "markdown", + "source": [ + "![image.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "uxpSI2BttGa1" + } + }, + { + "cell_type": "markdown", + "source": [ + "![Screenshot 2024-03-18 at 19.00.26.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "ac1wTL2duGD2" + } + }, + { + "cell_type": "markdown", + "source": [ + "### ASSIGNMENT: What scenario was used for Permuted MNIST?\n", + "\n", + "What type of 'scenario' was the permuted MNIST problem that we explored above? Was it task-incremental, domain-incremental or class-incremental? Try to motivate your answer." + ], + "metadata": { + "id": "R_oxTtVTrM5g" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Possible Answer\n", + "\n", + "'''\n", + "The Permuted MNIST problem consisted of two contexts: normal MNIST (context 1) and MNIST\n", + "with permuted input images (context 2).\n", + "\n", + "After learning both contexts, when the model was evaluated, the model was not told to\n", + "which context an image belongs (i.e., the model was not told whether the image to be\n", + "classified was permuted or not), but the model also did not need to identify to\n", + "which context an image belongs (i.e., the model did not need to predict whether\n", + "the image to be classified had permuted pixels or not; it only needed to predict\n", + "the original digit displayed in the image).\n", + "This thus means that the above Permuted MNIST problem was an example of a domain-incremental\n", + "learning problem.\n", + "\n", + "Another way to motivate that this problem is an example of domain-incremental\n", + "learning, is to say that in both context 1 (normal MNIST) and context 2 (MNIST with\n", + "permuted input images), the 'type of problem' is the same (i.e., to identify the\n", + "digit displayed in the original image), but the 'domain' or 'context' is changing (i.e.,\n", + "the order/permutation in which the image pixels are presented).\n", + "''';" + ], + "metadata": { + "id": "CIvJrwERry3C", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's explore a **class-incremental learning** problem. For this we will no longer use Permuted MNIST (because it is a bit unintuitive to perform Permuted MNIST according to the class-incremental learning scenario), but we will use Split MNIST, which was introduced in the lecture." + ], + "metadata": { + "id": "Hbp9I_kpstgv" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Set up the benchmark (Split MNIST)\n", + "We will split the MNIST dataset up in five contexts with two different classes per context." + ], + "metadata": { + "id": "Ho1dVPxFuKPj" + } + }, + { + "cell_type": "code", + "source": [ + "contexts = 5\n", + "classes_per_context = 2\n", + "# Generate labels-per-context\n", + "labels_per_context = [\n", + " list(np.array(range(classes_per_context))+classes_per_context*context_id) for context_id in range(contexts)\n", + "]\n", + "# Split the train and test datasets up into sub-datasets, one for each context\n", + "train_datasets = []\n", + "test_datasets = []\n", + "for labels in labels_per_context:\n", + " train_datasets.append(SubDataset(MNIST_trainset, labels))\n", + " test_datasets.append(SubDataset(MNIST_testset, labels))" + ], + "metadata": { + "id": "aBAcIMoG-voX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the contexts\n", + "figure, axis = plt.subplots(1, contexts, figsize=(3*contexts, 4))\n", + "\n", + "for context_id in range(len(train_datasets)):\n", + " plot_examples(axis[context_id], train_datasets[context_id], context_id=context_id)" + ], + "metadata": { + "id": "kVr-Qc3LaJAw" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Set up the model\n", + "We use the same network architecture as before." + ], + "metadata": { + "id": "VLBAv9CyFRzc" + } + }, + { + "cell_type": "code", + "source": [ + "# Specify the architectural layout of the network to use\n", + "fc_lay = 4 #--> number of fully-connected layers\n", + "fc_units = 40 #--> number of units in each hidden layer\n", + "fc_nl = \"relu\" #--> what non-linearity to use?" + ], + "metadata": { + "id": "JBmaNwqAlXQ6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Define the model\n", + "model = Classifier(image_size=config['size'], image_channels=config['channels'],\n", + " output_units=config['classes'],\n", + " fc_layers=fc_lay, fc_units=fc_units, fc_nl=fc_nl)" + ], + "metadata": { + "id": "vmCYbrRDliwp" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Prepare for evaluation throughout training\n", + "Below we will use the same continual learning strategies as before (fine-tuning, EWC and replay) to train models on the five contexts of Split MNIST. When we do this, we want to keep track of the performance of the model while it is sequentially trained on these different contexts. For that we will define some functions here.\n", + "\n", + "As is common in the continual learning literature, we will evaluate the performance of the model only after finishing training on each new task. (But see [this paper](https://openreview.net/forum?id=Zy350cRstc6) for an interesting phenomenon that can be observed if we would evaluate the model on previous tasks after each training iteration on the new task.)" + ], + "metadata": { + "id": "1zoLaBgvutQ9" + } + }, + { + "cell_type": "code", + "source": [ + "# Define a function to initiate a dict-object in which performance throughout training is logged.\n", + "def initiate_result_dict(n_contexts):\n", + " '''Initiate with accuracy-measures to keep track of.'''\n", + " result_dict = {}\n", + " result_dict[\"acc per context\"] = {}\n", + " for i in range(n_contexts):\n", + " result_dict[\"acc per context\"][\"context {}\".format(i+1)] = []\n", + " result_dict[\"average_contexts_so_far\"] = [] # average accuracy over all contexts so far\n", + " result_dict[\"average_all_contexts\"] = [] # average accuracy over all contexts\n", + " result_dict[\"context\"] = [] # number of contexts so far\n", + " return result_dict" + ], + "metadata": { + "id": "S5KOtI2Axyn8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def test_all(model, datasets, current_context, test_size=None, result_dict=None, verbose=False):\n", + " '''Evaluate accuracy of a classifier (=[model]) on all contexts in [datasets].'''\n", + "\n", + " n_contexts = len(datasets)\n", + "\n", + " # Evaluate accuracy of model on all contexts\n", + " precs = []\n", + " for i in range(n_contexts):\n", + " precs.append(test_acc(model, datasets[i], test_size=test_size))\n", + "\n", + " # Compute average accuracy both for all contexts seen so far, and for all contexts\n", + " ave_so_far = sum([precs[context_id] for context_id in range(current_context)]) / current_context\n", + " ave_all = sum([precs[context_id] for context_id in range(n_contexts)]) / n_contexts\n", + "\n", + " # Print results on screen\n", + " if verbose:\n", + " print(' => ave accuracy (contexts so far): {:.3f}'.format(ave_so_far))\n", + " print(' => ave accuracy (all contexts): {:.3f}'.format(ave_all))\n", + "\n", + " # Add results to [result_dict]\n", + " if result_dict is not None:\n", + " for i in range(n_contexts):\n", + " result_dict['acc per context']['context {}'.format(i+1)].append(precs[i])\n", + " result_dict['average_all_contexts'].append(ave_all)\n", + " result_dict['average_contexts_so_far'].append(ave_so_far)\n", + " result_dict['context'].append(current_context)" + ], + "metadata": { + "id": "N_j_o9RCuyvB" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Compare fine-tuning, EWC and experience replay on Split MNIST" + ], + "metadata": { + "id": "MooCLNx7luDs" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Fine-tuning" + ], + "metadata": { + "id": "qRNzQe6vt0mf" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a copy from the base-model\n", + "model_finetune = copy.deepcopy(model)" + ], + "metadata": { + "id": "s78p_YQQtX-M" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Initiate a `results_dict` to keep track of performance throughout the continual training.\n", + "result_dict_finetune = initiate_result_dict(contexts)" + ], + "metadata": { + "id": "L0FKJoYRy7lp" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "For fine-tuning, we can simply re-use the `train`-function we had defined above to train the model on a given dataset in \"the standard way\" (i.e., without using any specific continual learning strategy)." + ], + "metadata": { + "id": "WrMqMENnuHRg" + } + }, + { + "cell_type": "code", + "source": [ + "# Sequentially train the model on all contexts using finetuning\n", + "for context_id in range(contexts):\n", + " # train the model on this context\n", + " train(model_finetune, dataset=train_datasets[context_id], iters=iters, lr=lr,\n", + " batch_size=batch_size)\n", + " # evaluate the performance of the model after training on this context\n", + " test_all(model_finetune, test_datasets, context_id+1, test_size=None,\n", + " result_dict=result_dict_finetune, verbose=True)" + ], + "metadata": { + "id": "g0y65f07tVie" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Visualization function\n", + "def plot_lines(list_with_lines, x_axes=None, line_names=None, colors=None, title=None,\n", + " title_top=None, xlabel=None, ylabel=None, ylim=None, figsize=None, list_with_errors=None, errors=\"shaded\",\n", + " x_log=False, with_dots=False, linestyle='solid', h_line=None, h_label=None, h_error=None,\n", + " h_lines=None, h_colors=None, h_labels=None, h_errors=None):\n", + " '''Generates a figure containing multiple lines in one plot.\n", + "\n", + " :param list_with_lines: of all lines to plot (with each line being a as well)\n", + " :param x_axes: containing the values for the x-axis\n", + " :param line_names: containing the names of each line\n", + " :param colors: containing the colors of each line\n", + " :param title: title of plot\n", + " :param title_top: text to appear on top of the title\n", + " :return: f:

\n", + " '''\n", + "\n", + " # if needed, generate default x-axis\n", + " if x_axes == None:\n", + " n_obs = len(list_with_lines[0])\n", + " x_axes = list(range(n_obs))\n", + "\n", + " # if needed, generate default line-names\n", + " if line_names == None:\n", + " n_lines = len(list_with_lines)\n", + " line_names = [\"line \" + str(line_id) for line_id in range(n_lines)]\n", + "\n", + " # make plot\n", + " size = (12,7) if figsize is None else figsize\n", + " f, axarr = plt.subplots(1, 1, figsize=size)\n", + "\n", + " # add error-lines / shaded areas\n", + " if list_with_errors is not None:\n", + " for line_id, name in enumerate(line_names):\n", + " if errors==\"shaded\":\n", + " axarr.fill_between(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])),\n", + " list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])),\n", + " color=None if (colors is None) else colors[line_id], alpha=0.25)\n", + " else:\n", + " axarr.plot(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])), label=None,\n", + " color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed')\n", + " axarr.plot(x_axes, list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])), label=None,\n", + " color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed')\n", + "\n", + " # mean lines\n", + " for line_id, name in enumerate(line_names):\n", + " axarr.plot(x_axes, list_with_lines[line_id], label=name,\n", + " color=None if (colors is None) else colors[line_id],\n", + " linewidth=4, marker='o' if with_dots else None, linestyle=linestyle if type(linestyle)==str else linestyle[line_id])\n", + "\n", + " # add horizontal line\n", + " if h_line is not None:\n", + " axarr.axhline(y=h_line, label=h_label, color=\"grey\")\n", + " if h_error is not None:\n", + " if errors == \"shaded\":\n", + " axarr.fill_between([x_axes[0], x_axes[-1]],\n", + " [h_line + h_error, h_line + h_error], [h_line - h_error, h_line - h_error],\n", + " color=\"grey\", alpha=0.25)\n", + " else:\n", + " axarr.axhline(y=h_line + h_error, label=None, color=\"grey\", linewidth=1, linestyle='dashed')\n", + " axarr.axhline(y=h_line - h_error, label=None, color=\"grey\", linewidth=1, linestyle='dashed')\n", + "\n", + " # add horizontal lines\n", + " if h_lines is not None:\n", + " h_colors = colors if h_colors is None else h_colors\n", + " for line_id, new_h_line in enumerate(h_lines):\n", + " axarr.axhline(y=new_h_line, label=None if h_labels is None else h_labels[line_id],\n", + " color=None if (h_colors is None) else h_colors[line_id])\n", + " if h_errors is not None:\n", + " if errors == \"shaded\":\n", + " axarr.fill_between([x_axes[0], x_axes[-1]],\n", + " [new_h_line + h_errors[line_id], new_h_line+h_errors[line_id]],\n", + " [new_h_line - h_errors[line_id], new_h_line - h_errors[line_id]],\n", + " color=None if (h_colors is None) else h_colors[line_id], alpha=0.25)\n", + " else:\n", + " axarr.axhline(y=new_h_line+h_errors[line_id], label=None,\n", + " color=None if (h_colors is None) else h_colors[line_id], linewidth=1,\n", + " linestyle='dashed')\n", + " axarr.axhline(y=new_h_line-h_errors[line_id], label=None,\n", + " color=None if (h_colors is None) else h_colors[line_id], linewidth=1,\n", + " linestyle='dashed')\n", + "\n", + " # finish layout\n", + " # -set y-axis\n", + " if ylim is not None:\n", + " axarr.set_ylim(ylim)\n", + " # -add axis-labels\n", + " if xlabel is not None:\n", + " axarr.set_xlabel(xlabel)\n", + " if ylabel is not None:\n", + " axarr.set_ylabel(ylabel)\n", + " # -add title(s)\n", + " if title is not None:\n", + " axarr.set_title(title)\n", + " if title_top is not None:\n", + " f.suptitle(title_top)\n", + " # -add legend\n", + " if line_names is not None:\n", + " axarr.legend()\n", + " # -set x-axis to log-scale\n", + " if x_log:\n", + " axarr.set_xscale('log')\n", + "\n", + " # return the figure\n", + " return f" + ], + "metadata": { + "cellView": "form", + "id": "tK2ztl4O2SeF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize performance on each context throughout the continual training\n", + "plot_list = []\n", + "for i in range(contexts):\n", + " plot_list.append(result_dict_finetune[\"acc per context\"][\"context {}\".format(i + 1)])\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_finetune[\"context\"],\n", + " line_names=['context {}'.format(i + 1) for i in range(contexts)],\n", + " title=\"Fine-tuning\", ylabel=\"Test Accuracy (%)\",\n", + " xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "izJVfClC0Nwe" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "That doesn't look great! The performance on data from each context drops to zero as soon as the next context has been learned.\n", + "\n", + "Can this be fixed with EWC or replay?\n", + "\n" + ], + "metadata": { + "id": "XoOvQDxU0H7V" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### EWC" + ], + "metadata": { + "id": "qZpWQSzct6-j" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a copy from the base-model\n", + "model_ewc = copy.deepcopy(model)" + ], + "metadata": { + "id": "A0zJrd324EYi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Initiate a `results_dict` to keep track of performance throughout the continual training.\n", + "result_dict_ewc = initiate_result_dict(contexts)" + ], + "metadata": { + "id": "6b_toOZG4HK2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Select a hyperparameter for EWC\n", + "ewc_lambda = 100" + ], + "metadata": { + "id": "KUvoqpvC462f" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Sequentially train the model on all contexts using EWC\n", + "for context_id in range(contexts):\n", + " # Train the model on this context\n", + " train_ewc(model_ewc, train_datasets[context_id], iters=iters, lr=lr, batch_size=batch_size,\n", + " current_context=context_id+1, ewc_lambda=ewc_lambda)\n", + " # Estimate/update the FI-matrix (which is stored as attribute in the network)\n", + " estimate_fisher(model_ewc, train_datasets[context_id], n_samples=200)\n", + " # Evaluate the performance of the model after training on this context\n", + " test_all(model_ewc, test_datasets, context_id+1, test_size=None,\n", + " result_dict=result_dict_ewc, verbose=True)" + ], + "metadata": { + "id": "UaTlFqCU4L23" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize performance on each context throughout the continual training\n", + "plot_list = []\n", + "for i in range(contexts):\n", + " plot_list.append(result_dict_ewc[\"acc per context\"][\"context {}\".format(i + 1)])\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_ewc[\"context\"],\n", + " line_names=['context {}'.format(i + 1) for i in range(contexts)],\n", + " title=\"EWC\", ylabel=\"Test Accuracy (%)\",\n", + " xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "cnwEr6D86XXz" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "On this problem, EWC does not seem to help!" + ], + "metadata": { + "id": "A3veN7vFDgtg" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Experience Replay" + ], + "metadata": { + "id": "xKga8yfYt8qI" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a copy from the base-model\n", + "model_replay = copy.deepcopy(model)" + ], + "metadata": { + "id": "PNUKP7xL7Mit" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Initiate a `results_dict` to keep track of performance throughout the continual training.\n", + "result_dict_replay = initiate_result_dict(contexts)" + ], + "metadata": { + "id": "w47-mCHp7PU1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Select how many samples per class can be stored in the memory buffer\n", + "buffer_size_per_class = 20" + ], + "metadata": { + "id": "ysrAtTYN9Xq8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Sequentially train the model on all contexts using Experience Replay\n", + "memory_sets = []\n", + "buffer_dataset = None\n", + "for context_id in range(contexts):\n", + " # Train the model on this context\n", + " train_replay(model_replay, train_datasets[context_id], iters=iters, lr=lr,\n", + " batch_size=batch_size, current_context=context_id+1, buffer_dataset=buffer_dataset)\n", + " # Update memory buffer\n", + " classes_in_this_context = list(range(classes_per_context*context_id,\n", + " classes_per_context*(context_id+1)))\n", + " memory_sets = fill_memory_buffer(memory_sets, train_datasets[context_id],\n", + " buffer_size_per_class=buffer_size_per_class,\n", + " class_indeces=classes_in_this_context)\n", + " buffer_dataset = MemorySetDataset(memory_sets)\n", + " # Evaluate the performance of the model after training on this context\n", + " test_all(model_replay, test_datasets, context_id+1, test_size=None,\n", + " result_dict=result_dict_replay, verbose=True)" + ], + "metadata": { + "id": "PqEQ0psH7S5_" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize performance on each context throughout the continual training\n", + "plot_list = []\n", + "for i in range(contexts):\n", + " plot_list.append(result_dict_replay[\"acc per context\"][\"context {}\".format(i + 1)])\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_replay[\"context\"],\n", + " line_names=['context {}'.format(i + 1) for i in range(contexts)],\n", + " title=\"Experience Replay ({} samples per class)\".format(buffer_size_per_class),\n", + " ylabel=\"Test Accuracy (%)\", xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "Cd6cVn4596Z2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Experience replay does help on this type of continual learning problem!" + ], + "metadata": { + "id": "0h0_dqswDxIF" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Visual comparison fine-tuning, EWC and replay" + ], + "metadata": { + "id": "PeRrxlPMD9Ih" + } + }, + { + "cell_type": "code", + "source": [ + "key = \"average_contexts_so_far\"\n", + "plot_list = [result_dict_finetune[key], result_dict_ewc[key], result_dict_replay[key]]\n", + "line_names = ['Fine-tuning', 'EWC', 'Experience Replay']\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_replay[\"context\"], line_names=line_names,\n", + " title=\"Comparison (performance on all contexts so far)\",\n", + " ylabel=\"Test Accuracy (%)\", xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "BlMgaQw3EDNG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "key = \"average_all_contexts\"\n", + "plot_list = [result_dict_finetune[key], result_dict_ewc[key], result_dict_replay[key]]\n", + "line_names = ['Fine-tuning', 'EWC', 'Experience Replay']\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_replay[\"context\"], line_names=line_names,\n", + " title=\"Comparison (performance on all contexts)\",\n", + " ylabel=\"Test Accuracy (%)\", xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "jDvPRbb6NunA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "(Note that the lines of `fine-tuning` and `EWC` might well overlap almost completely.)" + ], + "metadata": { + "id": "BnzPs8sLNiiW" + } + }, + { + "cell_type": "markdown", + "source": [ + "### **ASSIGNMENT**: Combine EWC and replay on class-incremental Split MNIST\n", + "Train another model copy on the class-incremental version of Split MNIST, now again using *both* EWC and experience replay." + ], + "metadata": { + "id": "nnHbEqUclFzL" + } + }, + { + "cell_type": "code", + "source": [ + "model_ewc_replay = copy.deepcopy(model)\n", + "result_dict_ewc_replay = initiate_result_dict(contexts)" + ], + "metadata": { + "id": "9Z4mW-SGJ2Mz" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# TO BE COMPLETED" + ], + "metadata": { + "id": "o8uoeyclJsol" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Possible Answer\n", + "\n", + "# Select hyperparameter for EWC\n", + "ewc_lambda_with_replay = 100\n", + "\n", + "# Sequentially train the model on all contexts using both EWC and Experience Replay\n", + "memory_sets = []\n", + "buffer_dataset = None\n", + "for context_id in range(contexts):\n", + "\n", + " # Train the model on this context\n", + " train_ewc_replay(model_ewc_replay, train_datasets[context_id], iters=iters, lr=lr,\n", + " batch_size=batch_size, current_context=context_id+1,\n", + " ewc_lambda=ewc_lambda_with_replay, buffer_dataset=buffer_dataset)\n", + " # NOTE: depending on how you had written your `train_ewc_replay` function, you might need to\n", + " # adjust it to make it suitable for the more general case in which the function is used\n", + " # for arbitrary contexts\n", + "\n", + " # Estimate/update the FI-matrix (which is stored as attribute in the network)\n", + " estimate_fisher(model_ewc_replay, train_datasets[context_id], n_samples=200)\n", + "\n", + " # Update memory buffer\n", + " classes_in_this_context = list(range(classes_per_context*context_id,\n", + " classes_per_context*(context_id+1)))\n", + " memory_sets = fill_memory_buffer(memory_sets, train_datasets[context_id],\n", + " buffer_size_per_class=buffer_size_per_class,\n", + " class_indeces=classes_in_this_context)\n", + " buffer_dataset = MemorySetDataset(memory_sets)\n", + "\n", + " # Evaluate the performance of the model after training on this context\n", + " test_all(model_ewc_replay, test_datasets, context_id+1, test_size=None,\n", + " result_dict=result_dict_ewc_replay, verbose=True)" + ], + "metadata": { + "id": "NCIl4npjKA4b" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Visualize performance on each context throughout the continual training\n", + "plot_list = []\n", + "for i in range(contexts):\n", + " plot_list.append(result_dict_ewc_replay[\"acc per context\"][\"context {}\".format(i + 1)])\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_ewc_replay[\"context\"],\n", + " line_names=['context {}'.format(i + 1) for i in range(contexts)],\n", + " title=\"EWC + Experience Replay ({} samples per class)\".format(buffer_size_per_class),\n", + " ylabel=\"Test Accuracy (%)\", xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "H8Bv45h-LAOo" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Is there a benefit of \"EWC + Experience Replay\" over only \"Experience Replay\"? Let's compare them more directly." + ], + "metadata": { + "id": "lYRQToDAOHCC" + } + }, + { + "cell_type": "code", + "source": [ + "key = \"average_contexts_so_far\"\n", + "plot_list = [result_dict_finetune[key], result_dict_ewc[key], result_dict_replay[key],\n", + " result_dict_ewc_replay[key]]\n", + "line_names = ['Fine-tuning', 'EWC', 'Experience Replay', 'EWC + Experience Replay']\n", + "figure = plot_lines(\n", + " plot_list, x_axes=result_dict_replay[\"context\"], line_names=line_names,\n", + " title=\"Comparison (performance on all contexts so far)\",\n", + " ylabel=\"Test Accuracy (%)\", xlabel=\"Number of contexts trained so far\", figsize=(10,5),\n", + ")" + ], + "metadata": { + "id": "Y7tYuOJqLm1F" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Bonus Part: Task- and domain-incremental learning version of Split MNIST\n", + "As a *bonus exercise*, let's try to think about how to adapt the code above such that we can run the same experiment, except that we perform Split MNIST according to the task- and domain-incremental learning scenarios rather than the class-incremental learning scenario." + ], + "metadata": { + "id": "tysftIoWOY-u" + } + }, + { + "cell_type": "markdown", + "source": [ + "Recall from the lecture that Split MNIST (just like any other sequence of classification tasks), can be performed according to each of the three scenarios:\n", + "\n", + "![Screenshot 2024-03-14 at 15.02.19.png](data:image/png;base64,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)\n", + "\n" + ], + "metadata": { + "id": "qnzRpciWOnSY" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Domain-incremental Split MNIST\n", + "To create the domain-incrmental learning version of Split MNIST, the number of possible output classes needs to be changed from ten (one output class for each digit) to two (one output class for `odd` and one output class for `even`).\n", + "\n", + "To implement this, we need to change both the way the benchmark is defined (e.g., in the second context, the digits '2' and '3' should no longer be labelled with `y=2` and `y=3`, but instead with `y=0` and `y=1`), and we need to change the way the classifier is defined (as it should now have two output units rather than ten)." + ], + "metadata": { + "id": "AS-70pNrv4E_" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Task-incremental Split MNIST\n", + "To create the task-incremental version of Split MNIST, the context label needs to be provided as input to the model. Usually, this context label will then be used to enable a \"multi-headed output layer\", meaning that there is a separate output layer per task.\n", + "\n", + "One option to implement this is to keep the number of output classes at ten and to still have the same, single output layer as in the class-incremental learning case, but to always mask out the outputs that are not in the current context.\n", + "\n", + "Another option to implement this is to set the number of output classes to two (as in the domain-incremental learning case) and to define a separate output layer per task.\n", + "\n" + ], + "metadata": { + "id": "7Ipjh-G0wjwh" + } + }, + { + "cell_type": "markdown", + "source": [ + "![image.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "oYI2Bbr4zCDE" + } + }, + { + "cell_type": "markdown", + "source": [ + "$^{\\text{a}}$ With task-incremental learning, at the computational level, there is no difference between whether the algorithm must return the within-context label or the global label, because the within-context label can be combined with the context label (which is provided as input) to get the global label." + ], + "metadata": { + "id": "vFDIFf_KzLu-" + } + } + ] +} \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/main.py b/PyTorch/build-in/other/continual-learning/main.py new file mode 100644 index 000000000..d72979ec6 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/main.py @@ -0,0 +1,584 @@ +#!/usr/bin/env python3 +import os +import numpy as np +import time +import torch +from torch import optim +# -custom-written libraries +import utils +from utils import checkattr +from data.load import get_context_set +from models import define_models as define +from models.cl.continual_learner import ContinualLearner +from models.cl.memory_buffer import MemoryBuffer +from models.cl import fromp_optimizer +from train.train_task_based import train_cl, train_fromp, train_gen_classifier +from params import options +from params.param_stamp import get_param_stamp, get_param_stamp_from_args, visdom_name +from params.param_values import set_method_options,check_for_errors,set_default_values +from eval import evaluate, callbacks as cb +from visual import visual_plt + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'main': True} + # Define input options + parser = options.define_args(filename="main", description='Run an individual continual learning experiment ' + 'using the "academic continual learning setting".') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Parse, process and check chosen options + args = parser.parse_args() + set_method_options(args) # -if a method's "convenience"-option is chosen, select components + set_default_values(args, also_hyper_params=True) # -set defaults, some are based on chosen scenario / experiment + check_for_errors(args, **kwargs) # -check whether incompatible options are selected + return args + + +def run(args, verbose=False): + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if checkattr(args, 'pdf') and not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + # If only want param-stamp, get it printed to screen and exit + if checkattr(args, 'get_stamp'): + print(get_param_stamp_from_args(args=args)) + exit() + + # Use cuda or mps (apple silicon)? + cuda = torch.cuda.is_available() and args.gpu + mps = torch.backends.mps.is_available() and args.gpu + if cuda: + device = torch.device("cuda") + elif mps: + device = torch.device("mps") + else: + device = torch.device("cpu") + + # Report whether cuda or mps is used + if verbose: + if cuda: + print("CUDA is used") + elif mps: + print("MPS is used (apple silicon GPU)") + else: + print("NO GPU is used!") + + # Set random seeds + np.random.seed(args.seed) + torch.manual_seed(args.seed) + if cuda: + torch.cuda.manual_seed(args.seed) + elif mps: + torch.mps.manual_seed(args.seed) + + #-------------------------------------------------------------------------------------------------# + + #----------------# + #----- DATA -----# + #----------------# + + # Prepare data for chosen experiment + if verbose: + print("\n\n " +' LOAD DATA '.center(70, '*')) + (train_datasets, test_datasets), config = get_context_set( + name=args.experiment, scenario=args.scenario, contexts=args.contexts, data_dir=args.d_dir, + normalize=checkattr(args, "normalize"), verbose=verbose, exception=(args.seed==0), + singlehead=checkattr(args, 'singlehead'), train_set_per_class=checkattr(args, 'gen_classifier') + ) + # The experiments in this script follow the academic continual learning setting, + # the above lines of code therefore load both the 'context set' and the 'data stream' + + #-------------------------------------------------------------------------------------------------# + + #-----------------------------# + #----- FEATURE EXTRACTOR -----# + #-----------------------------# + + # Define the feature extractor + depth = args.depth if hasattr(args, 'depth') else 0 + use_feature_extractor = checkattr(args, 'hidden') or ( + checkattr(args, 'freeze_convE') and (not args.replay=="generative") and (not checkattr(args, "add_buffer")) + and (not checkattr(args, 'gen_classifier')) + ) + #--> when the convolutional layers are frozen, it is faster to put the data through these layers only once at the + # beginning, but this currently does not work with iCaRL or pixel-level generative replay/classification + if use_feature_extractor and depth>0: + if verbose: + print("\n\n " + ' DEFINE FEATURE EXTRACTOR '.center(70, '*')) + feature_extractor = define.define_feature_extractor(args=args, config=config, device=device) + # - initialize (pre-trained) parameters + define.init_params(feature_extractor, args, verbose=verbose) + # - freeze the parameters & set model to eval()-mode + for param in feature_extractor.parameters(): + param.requires_grad = False + feature_extractor.eval() + # - print characteristics of feature extractor on the screen + if verbose: + utils.print_model_info(feature_extractor) + # - reset size and # of channels to reflect the extracted features rather than the original images + config = config.copy() # -> make a copy to avoid overwriting info in the original config-file + config['size'] = feature_extractor.conv_out_size + config['channels'] = feature_extractor.conv_out_channels + depth = 0 + else: + feature_extractor = None + + # Convert original data to features (so this doesn't need to be done at run-time) + if (feature_extractor is not None) and args.depth>0: + if verbose: + print("\n\n " + ' PUT DATA TRHOUGH FEATURE EXTRACTOR '.center(70, '*')) + train_datasets = utils.preprocess(feature_extractor, train_datasets, config, batch=args.batch, + message='') + test_datasets = utils.preprocess(feature_extractor, test_datasets, config, batch=args.batch, + message=' ') + + #-------------------------------------------------------------------------------------------------# + + #----------------------# + #----- CLASSIFIER -----# + #----------------------# + + # Define the classifier + if verbose: + print("\n\n " + ' DEFINE THE CLASSIFIER '.center(70, '*')) + model = define.define_classifier(args=args, config=config, device=device, depth=depth) + + # Some type of classifiers consist of multiple networks + n_networks = len(train_datasets) if (checkattr(args, 'separate_networks') or + checkattr(args, 'gen_classifier')) else 1 + + # Go through all networks to ... + for network_id in range(n_networks): + model_to_set = getattr(model, 'context{}'.format(network_id+1)) if checkattr(args, 'separate_networks') else ( + getattr(model, 'vae{}'.format(network_id)) if checkattr(args, 'gen_classifier') else model + ) + # ... initialize / use pre-trained / freeze model-parameters, and + define.init_params(model_to_set, args) + # ... define optimizer (only include parameters that "requires_grad") + if not checkattr(args, 'fromp'): + model_to_set.optim_list = [{'params': filter(lambda p: p.requires_grad, model_to_set.parameters()), + 'lr': args.lr}] + model_to_set.optim_type = args.optimizer + if model_to_set.optim_type in ("adam", "adam_reset"): + model_to_set.optimizer = optim.Adam(model_to_set.optim_list, betas=(0.9, 0.999)) + elif model_to_set.optim_type=="sgd": + model_to_set.optimizer = optim.SGD(model_to_set.optim_list, + momentum=args.momentum if hasattr(args, 'momentum') else 0.) + + # On what scenario will model be trained? If needed, indicate whether singlehead output / how to set active classes. + model.scenario = args.scenario + model.classes_per_context = config['classes_per_context'] + model.singlehead = checkattr(args, 'singlehead') + model.neg_samples = args.neg_samples if hasattr(args, 'neg_samples') else "all" + + # Print some model-characteristics on the screen + if verbose: + if checkattr(args, 'gen_classifier') or checkattr(args, 'separate_networks'): + message = '{} copies of:'.format(len(train_datasets)) + utils.print_model_info(model.vae0 if checkattr(args, 'gen_classifier') else model.context1, message=message) + else: + utils.print_model_info(model) + + # -------------------------------------------------------------------------------------------------# + + # ----------------------------------------------------# + # ----- CL-STRATEGY: CONTEXT-SPECIFIC COMPONENTS -----# + # ----------------------------------------------------# + + # XdG: create for every context a "mask" for each hidden fully connected layer + if isinstance(model, ContinualLearner) and checkattr(args, 'xdg') and args.gating_prop > 0.: + model.mask_dict = {} + for context_id in range(args.contexts): + model.mask_dict[context_id + 1] = {} + for i in range(model.fcE.layers): + layer = getattr(model.fcE, "fcLayer{}".format(i + 1)).linear + if context_id == 0: + model.excit_buffer_list.append(layer.excit_buffer) + n_units = len(layer.excit_buffer) + gated_units = np.random.choice(n_units, size=int(args.gating_prop * n_units), replace=False) + model.mask_dict[context_id + 1][i] = gated_units + + #-------------------------------------------------------------------------------------------------# + + #-------------------------------------------------# + #----- CL-STRATEGY: PARAMETER REGULARIZATION -----# + #-------------------------------------------------# + + # Options for computing the Fisher Information matrix (e.g., EWC, Online-EWC, KFAC-EWC, NCL) + use_fisher = hasattr(args, 'importance_weighting') and args.importance_weighting=="fisher" and \ + (checkattr(args, 'precondition') or checkattr(args, 'weight_penalty')) + if isinstance(model, ContinualLearner) and use_fisher: + # -how to estimate the Fisher Information + model.fisher_n = args.fisher_n if hasattr(args, 'fisher_n') else None + model.fisher_labels = args.fisher_labels if hasattr(args, 'fisher_labels') else 'all' + model.fisher_batch = args.fisher_batch if hasattr(args, 'fisher_batch') else 1 + # -options relating to 'Offline EWC' (Kirkpatrick et al., 2017) and 'Online EWC' (Schwarz et al., 2018) + model.offline = checkattr(args, 'offline') + if not model.offline: + model.gamma = args.gamma if hasattr(args, 'gamma') else 1. + # -if requested, initialize Fisher with prior + if checkattr(args, 'fisher_init'): + model.data_size = args.data_size #-> sets how strong the prior is + model.context_count = 1 #-> makes that already on the first context regularization will happen + if model.fisher_kfac: + model.initialize_kfac_fisher() + else: + model.initialize_fisher() + + # Parameter regularization by adding a weight penalty (e.g., EWC, SI, NCL, EWC-KFAC) + if isinstance(model, ContinualLearner) and checkattr(args, 'weight_penalty'): + model.weight_penalty = True + model.importance_weighting = args.importance_weighting + model.reg_strength = args.reg_strength + if model.importance_weighting=='si': + model.epsilon = args.epsilon if hasattr(args, 'epsilon') else 0.1 + + # Parameter regularization through pre-conditioning of the gradient (e.g., OWM, NCL) + if isinstance(model, ContinualLearner) and checkattr(args, 'precondition'): + model.precondition = True + model.importance_weighting = args.importance_weighting + model.alpha = args.alpha + + #-------------------------------------------------------------------------------------------------# + + #--------------------------------------------------# + #----- CL-STRATEGY: FUNCTIONAL REGULARIZATION -----# + #--------------------------------------------------# + + # Should a distillation loss (i.e., soft targets) be used? (e.g., for LwF, but also for BI-R) + if isinstance(model, ContinualLearner) and hasattr(args, 'replay'): + model.replay_targets = "soft" if checkattr(args, 'distill') else "hard" + model.KD_temp = args.temp if hasattr(args, 'temp') else 2. + if args.replay=="current" and model.replay_targets=="soft": + model.lwf_weighting = True + + # Should the FROMP-optimizer by used? + if checkattr(args, 'fromp'): + model.optimizer = fromp_optimizer.opt_fromp(model, lr=args.lr, tau=args.tau, betas=(0.9, 0.999)) + + #-------------------------------------------------------------------------------------------------# + + #-------------------------------# + #----- CL-STRATEGY: REPLAY -----# + #-------------------------------# + + # DGR: Should a separate generative model be trained to generate the data to be replayed? + train_gen = True if (args.replay=="generative" and not checkattr(args, 'feedback')) else False + if train_gen: + if verbose: + print("\n\n " + ' SEPARATE GENERATIVE MODEL '.center(70, '*')) + # -specify architecture + generator = define.define_vae(args=args, config=config, device=device, depth=depth) + # -initialize parameters + define.init_params(generator, args, verbose=verbose) + # -set optimizer(s) + generator.optim_list = [{'params': filter(lambda p: p.requires_grad, generator.parameters()), + 'lr': args.lr_gen}] + generator.optim_type = args.optimizer + if generator.optim_type in ("adam", "adam_reset"): + generator.optimizer = optim.Adam(generator.optim_list, betas=(0.9, 0.999)) + elif generator.optim_type == "sgd": + generator.optimizer = optim.SGD(generator.optim_list) + # -print architecture to screen + if verbose: + utils.print_model_info(generator) + else: + generator = None + + # Should the model be trained with replay? + if isinstance(model, ContinualLearner) and hasattr(args, 'replay'): + model.replay_mode = args.replay + + # A-GEM: How should the gradient of the loss on replayed data be used? (added, as inequality constraint or both?) + if isinstance(model, ContinualLearner) and hasattr(args, 'use_replay'): + model.use_replay = args.use_replay + model.eps_agem = args.eps_agem if hasattr(args, 'eps_agem') else 0. + + #-------------------------------------------------------------------------------------------------# + + #-------------------------# + #----- MEMORY BUFFER -----# + #-------------------------# + + # Should a memory buffer be maintained? (e.g., for experience replay, FROMP or prototype-based classification) + use_memory_buffer = checkattr(args, 'prototypes') or checkattr(args, 'add_buffer') \ + or args.replay=="buffer" or checkattr(args, 'fromp') + if isinstance(model, MemoryBuffer) and use_memory_buffer: + model.use_memory_buffer = True + model.budget_per_class = args.budget + model.use_full_capacity = checkattr(args, 'use_full_capacity') + model.sample_selection = args.sample_selection if hasattr(args, 'sample_selection') else 'random' + model.norm_exemplars = (model.sample_selection=="herding") + + # Should the memory buffer be added to the training set of the current context? + model.add_buffer = checkattr(args, 'add_buffer') + + # Should classification be done using prototypes as class templates? + model.prototypes = checkattr(args, 'prototypes') + + # Relevant for iCaRL: whether to use binary distillation loss for previous classes + if model.label=="Classifier": + model.binaryCE = checkattr(args, 'bce') + model.binaryCE_distill = checkattr(args, 'bce_distill') + + #-------------------------------------------------------------------------------------------------# + + #---------------------------# + #----- PARAMETER STAMP -----# + #---------------------------# + + # Get parameter-stamp (and print on screen) + if verbose: + if verbose: + print('\n\n' + ' PARAMETER STAMP '.center(70, '*')) + param_stamp = get_param_stamp( + args, model.name, replay_model_name=generator.name if train_gen else None, + feature_extractor_name= feature_extractor.name if (feature_extractor is not None) else None, verbose=verbose, + ) + + #-------------------------------------------------------------------------------------------------# + + #---------------------# + #----- CALLBACKS -----# + #---------------------# + + # Prepare for keeping track of performance during training for plotting in pdf + plotting_dict = evaluate.initiate_plotting_dict(args.contexts) if ( + checkattr(args, 'pdf') or checkattr(args, 'results_dict') + ) else None + + # Setting up Visdom environment + if utils.checkattr(args, 'visdom'): + if verbose: + print('\n\n'+' VISDOM '.center(70, '*')) + from visdom import Visdom + env_name = "{exp}{con}-{sce}".format(exp=args.experiment, con=args.contexts, sce=args.scenario) + visdom = {'env': Visdom(env=env_name), 'graph': visdom_name(args)} + else: + visdom = None + + # Callbacks for reporting and visualizing loss + generator_loss_cbs = [ + cb._VAE_loss_cb(log=args.loss_log, visdom=visdom, replay=False if args.replay=="none" else True, + model=model if checkattr(args, 'feedback') else generator, contexts=args.contexts, + iters_per_context=args.iters if checkattr(args, 'feedback') else args.g_iters) + ] if (train_gen or checkattr(args, 'feedback')) else [None] + # loss_cbs = [ + # cb._gen_classifier_loss_cb( + # log=args.loss_log, classes=config['classes'], visdom=visdom if args.loss_log>args.iters else None, + # ) if checkattr(args, 'gen_classifier') else cb._classifier_loss_cb( + # log=args.loss_log, visdom=visdom, model=model, contexts=args.contexts, iters_per_context=args.iters, + # ) + # ] if (not checkattr(args, 'feedback')) else generator_loss_cbs + + class SimpleLossPrinter: + def __init__(self): + self.log_file = f"step_losses_{time.time()}.txt" + with open(self.log_file, 'w') as f: + f.write("context,step,loss\n") + + def __call__(self, progress, batch_index, loss_dict, context=0, **kwargs): + # 提取loss值 + loss_value = 0.0 + if isinstance(loss_dict, dict): + if 'loss' in loss_dict: + loss_value = loss_dict['loss'] + elif len(loss_dict) > 0: + loss_value = next(iter(loss_dict.values())) + elif hasattr(loss_dict, 'item'): + loss_value = loss_dict.item() + else: + loss_value = float(loss_dict) if loss_dict is not None else 0.0 + + # 如果是tensor，转换为数值 + if hasattr(loss_value, 'item'): + loss_value = loss_value.item() + + # 打印到控制台 + print(f"Context {context:2d} | Step {batch_index:4d} | Loss: {loss_value:.6f}") + + # 保存到文件 + with open(self.log_file, 'a') as f: + f.write(f"{context},{batch_index},{loss_value:.6f}\n") + + # 强制刷新输出 + import sys + sys.stdout.flush() + + simple_loss_printer = SimpleLossPrinter() + loss_cbs = [simple_loss_printer] + + # Callbacks for evaluating and plotting generated / reconstructed samples + no_samples = (checkattr(args, "no_samples") or feature_extractor is not None) + sample_cbs = [ + cb._sample_cb(log=args.sample_log, visdom=visdom, config=config, sample_size=args.sample_n, + test_datasets=None if checkattr(args, 'gen_classifier') else test_datasets) + ] if (train_gen or checkattr(args, 'feedback') or checkattr(args, 'gen_classifier')) and not no_samples else [None] + + # Callbacks for reporting and visualizing accuracy + # -after each [acc_log], for visdom + eval_cbs = [ + cb._eval_cb(log=args.acc_log, test_datasets=test_datasets, visdom=visdom, iters_per_context=args.iters, + test_size=args.acc_n) + ] if (not checkattr(args, 'prototypes')) and (not checkattr(args, 'gen_classifier')) else [None] + # -after each context, for plotting in pdf (when using prototypes / generative classifier, this is also for visdom) + context_cbs = [ + cb._eval_cb(log=args.iters, test_datasets=test_datasets, plotting_dict=plotting_dict, + visdom=visdom if checkattr(args, 'prototypes') or checkattr(args, 'gen_classifier') else None, + iters_per_context=args.iters, test_size=args.acc_n, S=args.eval_s if hasattr(args, 'eval_s') else 1) + ] + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- TRAINING -----# + #--------------------# + + # Should a baseline be used (i.e., 'joint training' or 'cummulative training')? + baseline = 'joint' if checkattr(args, 'joint') else ('cummulative' if checkattr(args, 'cummulative') else 'none') + + # Train model + if args.train: + if verbose: + print('\n\n' + ' TRAINING '.center(70, '*')) + # -keep track of training-time + if args.time: + start = time.time() + # -select correct training function + train_fn = train_fromp if checkattr(args, 'fromp') else ( + train_gen_classifier if checkattr(args, 'gen_classifier') else train_cl + ) + # -perform training + train_fn( + model, train_datasets, iters=args.iters, batch_size=args.batch, baseline=baseline, + sample_cbs=sample_cbs, eval_cbs=eval_cbs, loss_cbs=loss_cbs, context_cbs=context_cbs, + # -if using generative replay with a separate generative model: + generator=generator, gen_iters=args.g_iters if hasattr(args, 'g_iters') else args.iters, + gen_loss_cbs=generator_loss_cbs, + ) + # -get total training-time in seconds, write to file and print to screen + if args.time: + training_time = time.time() - start + time_file = open("{}/time-{}.txt".format(args.r_dir, param_stamp), 'w') + time_file.write('{}\n'.format(training_time)) + time_file.close() + if verbose and args.time: + print("Total training time = {:.1f} seconds\n".format(training_time)) + # -save trained model(s), if requested + if args.save: + save_name = "mM-{}".format(param_stamp) if ( + not hasattr(args, 'full_stag') or args.full_stag == "none" + ) else "{}-{}".format(model.name, args.full_stag) + utils.save_checkpoint(model, args.m_dir, name=save_name, verbose=verbose) + else: + # Load previously trained model(s) (if goal is to only evaluate previously trained model) + if verbose: + print("\nLoading parameters of previously trained model...") + load_name = "mM-{}".format(param_stamp) if ( + not hasattr(args, 'full_ltag') or args.full_ltag == "none" + ) else "{}-{}".format(model.name, args.full_ltag) + utils.load_checkpoint(model, args.m_dir, name=load_name, verbose=verbose, strict=False) + + #-------------------------------------------------------------------------------------------------# + + #----------------------# + #----- EVALUATION -----# + #----------------------# + + if verbose: + print('\n\n' + ' EVALUATION '.center(70, '*')) + + # Set attributes of model that define how to do classification + if checkattr(args, 'gen_classifier'): + model.S = args.eval_s + + # Evaluate accuracy of final model on full test-set + if verbose: + print("\n Accuracy of final model on test-set:") + accs = [] + for i in range(args.contexts): + acc = evaluate.test_acc( + model, test_datasets[i], verbose=False, test_size=None, context_id=i, allowed_classes=list( + range(config['classes_per_context']*i, config['classes_per_context']*(i+1)) + ) if (args.scenario=="task" and not checkattr(args, 'singlehead')) else None, + ) + if verbose: + print(" - Context {}: {:.4f}".format(i + 1, acc)) + accs.append(acc) + average_accs = sum(accs) / args.contexts + if verbose: + print('=> average accuracy over all {} contexts: {:.4f}\n\n'.format(args.contexts, average_accs)) + # -write out to text file + file_name = "{}/acc-{}{}.txt".format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + output_file = open(file_name, 'w') + output_file.write('{}\n'.format(average_accs)) + output_file.close() + # -if requested, also save the results-dict (with accuracy after each task) + if checkattr(args, 'results_dict'): + file_name = "{}/dict-{}--n{}{}".format(args.r_dir, param_stamp, "All" if args.acc_n is None else args.acc_n, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + utils.save_object(plotting_dict, file_name) + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- PLOTTING -----# + #--------------------# + + # If requested, generate pdf + if checkattr(args, 'pdf'): + # -open pdf + plot_name = "{}/{}.pdf".format(args.p_dir, param_stamp) + pp = visual_plt.open_pdf(plot_name) + # -show samples and reconstructions (either from main model or from separate generator) + if checkattr(args, 'feedback') or args.replay=="generative" or checkattr(args, 'gen_classifier'): + evaluate.show_samples( + model if checkattr(args, 'feedback') or checkattr(args, 'gen_classifier') else generator, config, + size=args.sample_n, pdf=pp + ) + if not checkattr(args, 'gen_classifier'): + for i in range(args.contexts): + evaluate.show_reconstruction(model if checkattr(args, 'feedback') else generator, + test_datasets[i], config, pdf=pp, context=i+1) + figure_list = [] #-> create list to store all figures to be plotted + # -generate all figures (and store them in [figure_list]) + plot_list = [] + for i in range(args.contexts): + plot_list.append(plotting_dict["acc per context"]["context {}".format(i + 1)]) + figure = visual_plt.plot_lines( + plot_list, x_axes=plotting_dict["x_context"], + line_names=['context {}'.format(i + 1) for i in range(args.contexts)] + ) + figure_list.append(figure) + figure = visual_plt.plot_lines( + [plotting_dict["average"]], x_axes=plotting_dict["x_context"], + line_names=['average all contexts so far'] + ) + figure_list.append(figure) + # -add figures to pdf + for figure in figure_list: + pp.savefig(figure) + # -close pdf + pp.close() + # -print name of generated plot on screen + if verbose: + print("\nGenerated plot: {}\n".format(plot_name)) + + + +if __name__ == '__main__': + # -load input-arguments + args = handle_inputs() + # -run experiment + run(args, verbose=True) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/main_pretrain.py b/PyTorch/build-in/other/continual-learning/main_pretrain.py new file mode 100644 index 000000000..6c163e1ca --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/main_pretrain.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +import numpy as np +import torch +# -custom-written libraries +import utils +from utils import checkattr +from data.load import get_singlecontext_datasets +from models import define_models as define +from train import train_standard +from params import options +from params.param_values import check_for_errors,set_default_values +from eval import callbacks as cb +from eval import evaluate + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'pretrain': True} + # Define input options + parser = options.define_args(filename="main_pretrain", description='Train classifier for pretraining conv-layers.') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + # Parse, process and check chosen options + args = parser.parse_args() + set_default_values(args, also_hyper_params=False, single_context=True) # -set defaults based on chosen experiment + check_for_errors(args, **kwargs) # -check for incompatible options + return args + + +## Function for running one experiment +def run(args, verbose=False): + + # Use cuda or mps (apple silicon)? + cuda = torch.cuda.is_available() and args.gpu + mps = torch.backends.mps.is_available() and args.gpu + if cuda: + device = torch.device("cuda") + elif mps: + device = torch.device("mps") + else: + device = torch.device("cpu") + + # Report whether cuda or mps is used + if verbose: + if cuda: + print("CUDA is used") + elif mps: + print("MPS is used (apple silicon GPU)") + else: + print("NO GPU is used!") + + # Set random seeds + np.random.seed(args.seed) + torch.manual_seed(args.seed) + if cuda: + torch.cuda.manual_seed(args.seed) + elif mps: + torch.mps.manual_seed(args.seed) + + #-------------------------------------------------------------------------------------------------# + + #----------------# + #----- DATA -----# + #----------------# + + # Prepare data for chosen experiment + if verbose: + print("\n\n " +' LOAD DATA '.center(70, '*')) + (trainset, testset), config = get_singlecontext_datasets( + name=args.experiment, data_dir=args.d_dir, verbose=True, + normalize = utils.checkattr(args, "normalize"), augment = utils.checkattr(args, "augment"), + ) + + # Specify "data-loader" (among others for easy random shuffling and 'batchifying') + train_loader = utils.get_data_loader(trainset, batch_size=args.batch, cuda=cuda, drop_last=True) + + # Determine number of iterations: + iters = args.iters if args.iters else args.epochs*len(train_loader) + + #-------------------------------------------------------------------------------------------------# + + #-----------------# + #----- MODEL -----# + #-----------------# + + # Specify model + if verbose: + print("\n\n " +' DEFINE MODEL '.center(70, '*')) + cnn = define.define_standard_classifier(args=args, config=config, device=device, depth=args.depth) + + # Initialize (pre-trained) parameters + define.init_params(cnn, args) + + # Set optimizer + optim_list = [{'params': filter(lambda p: p.requires_grad, cnn.parameters()), 'lr': args.lr}] + cnn.optimizer = torch.optim.Adam(optim_list, betas=(0.9, 0.999)) + + # Print some model-characteristics on the screen + if verbose: + utils.print_model_info(cnn) + + #-------------------------------------------------------------------------------------------------# + + #---------------------# + #----- CALLBACKS -----# + #---------------------# + + # Setting up Visdom environment + if utils.checkattr(args, 'visdom'): + if verbose: + print('\n\n'+' VISDOM '.center(70, '*')) + from visdom import Visdom + env_name = args.experiment + graph_name = cnn.name + visdom = {'env': Visdom(env=env_name), 'graph': graph_name} + else: + visdom = None + + # Determine after how many iterations to evaluate the model (in visdom) + loss_log = args.loss_log if (args.loss_log is not None) else len(train_loader) + acc_log = args.acc_log if (args.acc_log is not None) else len(train_loader) + + # Define callback-functions to evaluate during training + # -loss + loss_cbs = [cb._classifier_loss_cb(log=loss_log, visdom=visdom)] + # -accuracy + eval_cbs = [cb._eval_cb(log=acc_log, test_datasets=[testset], visdom=visdom, test_size=args.acc_n)] + + #-------------------------------------------------------------------------------------------------# + + #--------------------------# + #----- (PRE-)TRAINING -----# + #--------------------------# + + # (Pre)train model + if verbose: + print("\n\n " +' TRAINING '.center(70, '*')) + train_standard.train(cnn, train_loader, iters, loss_cbs=loss_cbs, eval_cbs=eval_cbs) + + # Save (pre)trained conv-layers and the full model + if checkattr(args, 'save'): + # -conv-layers + save_name = cnn.convE.name if ( + not hasattr(args, 'convE_stag') or args.convE_stag=="none" + ) else "{}-{}{}".format(cnn.convE.name, args.convE_stag, + "-s{}".format(args.seed) if checkattr(args, 'seed_to_stag') else "") + utils.save_checkpoint(cnn.convE, args.m_dir, name=save_name) + # -full model + save_name = cnn.name if ( + not hasattr(args, 'full_stag') or args.full_stag=="none" + ) else "{}-{}".format(cnn.name, args.full_stag) + utils.save_checkpoint(cnn, args.m_dir, name=save_name) + + #-------------------------------------------------------------------------------------------------# + + #----------------------# + #----- EVALUATION -----# + #----------------------# + + # Evaluate accuracy of final model on full test-set + if verbose: + print("\n\n " +' EVALUATION '.center(70, '*')) + train_acc = evaluate.test_acc(cnn, trainset, verbose=False, test_size=None) + test_acc = evaluate.test_acc(cnn, testset, verbose=False, test_size=None) + if verbose: + print('=> ave accuracy (on training set): {:.4f}'.format(train_acc)) + print('=> ave accuracy (on testing set): {:.4f}\n'.format(test_acc)) + + + +if __name__ == '__main__': + args = handle_inputs() + run(args, verbose=True) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/main_task_free.py b/PyTorch/build-in/other/continual-learning/main_task_free.py new file mode 100644 index 000000000..bc35dafcf --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/main_task_free.py @@ -0,0 +1,417 @@ +#!/usr/bin/env python3 +import os +import numpy as np +import time +import torch +from torch import optim +# -custom-written libraries +import utils +from utils import checkattr +from data.load import get_context_set +from data.labelstream import SharpBoundaryStream, RandomStream, FuzzyBoundaryStream +from data.datastream import DataStream +from models import define_models as define +from models.cl.continual_learner import ContinualLearner +from models.cl.memory_buffer_stream import MemoryBuffer +from train.train_stream import train_on_stream, train_gen_classifier_on_stream +from params import options +from params.param_stamp import get_param_stamp, get_param_stamp_from_args, visdom_name +from params.param_values import set_method_options,check_for_errors,set_default_values +from eval import evaluate, callbacks as cb + + +## Function for specifying input-options and organizing / checking them +def handle_inputs(): + # Set indicator-dictionary for correctly retrieving / checking input options + kwargs = {'main': True, 'no_boundaries': True} + # Define input options + parser = options.define_args(filename="main_task_free", + description='Run a "task-free" continual learning experiment ' + '(i.e., no [known,] sharp boundaries between contexts).') + parser = options.add_general_options(parser, **kwargs) + parser = options.add_eval_options(parser, **kwargs) + parser = options.add_problem_options(parser, **kwargs) + parser = options.add_model_options(parser, **kwargs) + parser = options.add_train_options(parser, **kwargs) + parser = options.add_cl_options(parser, **kwargs) + # Parse, process and check chosen options + args = parser.parse_args() + set_method_options(args) # -"convenience"-option used, select components + set_default_values(args, also_hyper_params=True, no_boundaries=True) # -set defaults, some based on chosen options + check_for_errors(args, **kwargs) # -check for incompatible options + return args + + +def run(args, verbose=False): + + # Create plots- and results-directories if needed + if not os.path.isdir(args.r_dir): + os.mkdir(args.r_dir) + if checkattr(args, 'pdf') and not os.path.isdir(args.p_dir): + os.mkdir(args.p_dir) + + # If only want param-stamp, get it printed to screen and exit + if checkattr(args, 'get_stamp'): + print(get_param_stamp_from_args(args=args, no_boundaries=True)) + exit() + + # Use cuda or mps (apple silicon)? + cuda = torch.cuda.is_available() and args.gpu + mps = torch.backends.mps.is_available() and args.gpu + if cuda: + device = torch.device("cuda") + elif mps: + device = torch.device("mps") + else: + device = torch.device("cpu") + + # Report whether cuda or mps is used + if verbose: + if cuda: + print("CUDA is used") + elif mps: + print("MPS is used (apple silicon GPU)") + else: + print("NO GPU is used!") + + # Set random seeds + np.random.seed(args.seed) + torch.manual_seed(args.seed) + if cuda: + torch.cuda.manual_seed(args.seed) + elif mps: + torch.mps.manual_seed(args.seed) + + #-------------------------------------------------------------------------------------------------# + + #-----------------------# + #----- CONTEXT SET -----# + #-----------------------# + + # Prepare the context set for the chosen experiment + if verbose: + print("\n\n " +' LOAD DATA '.center(70, '*')) + (train_datasets, test_datasets), config = get_context_set( + name=args.experiment, scenario=args.scenario, contexts=args.contexts, data_dir=args.d_dir, + normalize=checkattr(args, "normalize"), verbose=verbose, exception=(args.seed==0), + singlehead=checkattr(args, 'singlehead') + ) + + #-------------------------------------------------------------------------------------------------# + + #-----------------------------# + #----- FEATURE EXTRACTOR -----# + #-----------------------------# + + # Define the feature extractor + depth = args.depth if hasattr(args, 'depth') else 0 + use_feature_extractor = checkattr(args, 'hidden') or ( + checkattr(args, 'freeze_convE') and (not args.replay=="generative") and (not checkattr(args, "add_buffer")) + and (not checkattr(args, 'gen_classifier')) + ) + #--> when the convolutional layers are frozen, it is faster to put the data through these layers only once at the + # beginning, but this currently does not work with iCaRL or pixel-level generative replay/classification + if use_feature_extractor and depth>0: + if verbose: + print("\n\n " + ' DEFINE FEATURE EXTRACTOR '.center(70, '*')) + feature_extractor = define.define_feature_extractor(args=args, config=config, device=device) + # - initialize (pre-trained) parameters + define.init_params(feature_extractor, args, verbose=verbose) + # - freeze the parameters & set model to eval()-mode + for param in feature_extractor.parameters(): + param.requires_grad = False + feature_extractor.eval() + # - print characteristics of feature extractor on the screen + if verbose: + utils.print_model_info(feature_extractor) + # - reset size and # of channels to reflect the extracted features rather than the original images + config = config.copy() # -> make a copy to avoid overwriting info in the original config-file + config['size'] = feature_extractor.conv_out_size + config['channels'] = feature_extractor.conv_out_channels + depth = 0 + else: + feature_extractor = None + + # Convert original data to features (so this doesn't need to be done at run-time) + if (feature_extractor is not None) and args.depth>0: + if verbose: + print("\n\n " + ' PUT DATA TRHOUGH FEATURE EXTRACTOR '.center(70, '*')) + train_datasets = utils.preprocess(feature_extractor, train_datasets, config, batch=args.batch, + message='') + test_datasets = utils.preprocess(feature_extractor, test_datasets, config, batch=args.batch, + message=' ') + + #-------------------------------------------------------------------------------------------------# + + #-----------------------# + #----- DATA-STREAM -----# + #-----------------------# + + # Set up the stream of context-labels to use + if args.stream == "academic-setting": + label_stream = SharpBoundaryStream(n_contexts=args.contexts, iters_per_context=args.iters) + elif args.stream == "fuzzy-boundaries": + label_stream = FuzzyBoundaryStream( + n_contexts=args.contexts, iters_per_context=args.iters, fuzziness=args.fuzziness, + batch_size=1 if checkattr(args, 'labels_per_batch') else args.batch + ) + elif args.stream == "random": + label_stream = RandomStream(n_contexts=args.contexts) + else: + raise NotImplementedError("Stream type '{}' not currently implemented.".format(args.stream)) + + # Set up the data-stream to be presented to the network + data_stream = DataStream( + train_datasets, label_stream, batch_size=args.batch, return_context=(args.scenario=="task"), + per_batch=True if (args.stream=="academic-setting") else checkattr(args, 'labels_per_batch'), + ) + + #-------------------------------------------------------------------------------------------------# + + #----------------------# + #----- CLASSIFIER -----# + #----------------------# + + # Define the classifier + if verbose: + print("\n\n " + ' DEFINE THE CLASSIFIER '.center(70, '*')) + model = define.define_classifier(args=args, config=config, device=device, depth=depth, stream=True) + + # Some type of classifiers consist of multiple networks + n_networks = len(train_datasets) if checkattr(args, 'separate_networks') else ( + model.classes if checkattr(args, 'gen_classifier') else 1 + ) + + # Go through all networks to ... + for network_id in range(n_networks): + model_to_set = getattr(model, 'context{}'.format(network_id+1)) if checkattr(args, 'separate_networks') else ( + getattr(model, 'vae{}'.format(network_id)) if checkattr(args, 'gen_classifier') else model + ) + # ... initialize / use pre-trained / freeze model-parameters, and + define.init_params(model_to_set, args) + # ... define optimizer (only include parameters that "requires_grad") + model_to_set.optim_list = [{'params': filter(lambda p: p.requires_grad, model_to_set.parameters()), + 'lr': args.lr}] + model_to_set.optim_type = args.optimizer + if model_to_set.optim_type=="adam": + model_to_set.optimizer = optim.Adam(model_to_set.optim_list, betas=(0.9, 0.999)) + elif model_to_set.optim_type=="sgd": + model_to_set.optimizer = optim.SGD(model_to_set.optim_list, + momentum=args.momentum if hasattr(args, 'momentum') else 0.) + + # On what scenario will model be trained? + model.scenario = args.scenario + model.classes_per_context = config['classes_per_context'] + + # Print some model-characteristics on the screen + if verbose: + if checkattr(args, 'gen_classifier') or checkattr(args, 'separate_networks'): + message = '{} copies of:'.format(len(train_datasets)) + utils.print_model_info(model.vae0 if checkattr(args, 'gen_classifier') else model.context1, message=message) + else: + utils.print_model_info(model) + + # -------------------------------------------------------------------------------------------------# + + # For multiple continual learning methods: how often (after how many iters) to perform the consolidation operation? + # (this can be interpreted as: how many iterations together should be considered a "context") + model.update_every = args.update_every if hasattr(args, 'update_every') else 1 + + # -------------------------------------------------------------------------------------------------# + + # ----------------------------------------------------# + # ----- CL-STRATEGY: CONTEXT-SPECIFIC COMPONENTS -----# + # ----------------------------------------------------# + + # XdG: already indicated when defining the classifier + + #-------------------------------------------------------------------------------------------------# + + #-------------------------------------------------# + #----- CL-STRATEGY: PARAMETER REGULARIZATION -----# + #-------------------------------------------------# + + # Parameter regularization by adding a weight penalty (e.g., SI) + if isinstance(model, ContinualLearner) and checkattr(args, 'weight_penalty'): + model.weight_penalty = True + model.importance_weighting = args.importance_weighting + model.reg_strength = args.reg_strength + if model.importance_weighting=='si': + model.epsilon = args.epsilon if hasattr(args, 'epsilon') else 0.1 + + #-------------------------------------------------------------------------------------------------# + + #--------------------------------------------------# + #----- CL-STRATEGY: FUNCTIONAL REGULARIZATION -----# + #--------------------------------------------------# + + # Should a distillation loss (i.e., soft targets) be used? (e.g., for LwF) + if isinstance(model, ContinualLearner) and hasattr(args, 'replay'): + model.replay_targets = "soft" if checkattr(args, 'distill') else "hard" + model.KD_temp = args.temp if hasattr(args, 'temp') else 2. + + #-------------------------------------------------------------------------------------------------# + + #-------------------------------# + #----- CL-STRATEGY: REPLAY -----# + #-------------------------------# + + # Should the model be trained with replay? + if isinstance(model, ContinualLearner) and hasattr(args, 'replay'): + model.replay_mode = args.replay + + # A-GEM: How should the gradient of the loss on replayed data be used? (added, as inequality constraint or both?) + if isinstance(model, ContinualLearner) and hasattr(args, 'use_replay'): + model.use_replay = args.use_replay + model.eps_agem = args.eps_agem if hasattr(args, 'eps_agem') else 0. + + #-------------------------------------------------------------------------------------------------# + + #-------------------------# + #----- MEMORY BUFFER -----# + #-------------------------# + + # Should a memory buffer be maintained? (e.g., for experience replay or prototype-based classification) + use_memory_buffer = checkattr(args, 'prototypes') or args.replay=="buffer" + if isinstance(model, MemoryBuffer) and use_memory_buffer: + model.use_memory_buffer = True + model.budget = args.budget + model.initialize_buffer(config, return_c=(args.scenario=='task')) + + # Should classification be done using prototypes as class templates? + model.prototypes = checkattr(args, 'prototypes') + + # Relevant for "modified iCaRL": whether to use binary loss + if model.label=="Classifier": + model.binaryCE = checkattr(args, 'bce') + + #-------------------------------------------------------------------------------------------------# + + #---------------------------# + #----- PARAMETER STAMP -----# + #---------------------------# + + # Get parameter-stamp (and print on screen) + if verbose: + if verbose: + print('\n\n' + ' PARAMETER STAMP '.center(70, '*')) + param_stamp = get_param_stamp( + args, model.name, feature_extractor_name= feature_extractor.name if (feature_extractor is not None) else None, + verbose=verbose, no_boundaries=True, + ) + + #-------------------------------------------------------------------------------------------------# + + #---------------------# + #----- CALLBACKS -----# + #---------------------# + + # Setting up Visdom environment + if utils.checkattr(args, 'visdom'): + if verbose: + print('\n\n'+' VISDOM '.center(70, '*')) + from visdom import Visdom + env_name = "{exp}{con}-{sce}".format(exp=args.experiment, con=args.contexts, sce=args.scenario) + visdom = {'env': Visdom(env=env_name), 'graph': visdom_name(args)} + else: + visdom = None + + # Callbacks for reporting and visualizing loss + loss_cbs = [ + cb._gen_classifier_loss_cb( + log=args.loss_log, classes=None, visdom=None, + ) if checkattr(args, 'gen_classifier') else cb._classifier_loss_cb( + log=args.loss_log, visdom=visdom, model=model, contexts=None, + ) + ] + + # Callbacks for reporting and visualizing accuracy + eval_cbs = [ + cb._eval_cb(log=args.acc_log, test_datasets=test_datasets, visdom=visdom, iters_per_context=args.iters, + test_size=args.acc_n) + ] + + #-------------------------------------------------------------------------------------------------# + + #--------------------# + #----- TRAINING -----# + #--------------------# + + # Train model + if args.train: + if verbose: + print('\n\n' + ' TRAINING '.center(70, '*')) + # -keep track of training-time + if args.time: + start = time.time() + # -select training function + train_fn = train_gen_classifier_on_stream if checkattr(args, 'gen_classifier') else train_on_stream + # -perform training + train_fn(model, data_stream, iters=args.iters*args.contexts, eval_cbs=eval_cbs, loss_cbs=loss_cbs) + # -get total training-time in seconds, write to file and print to screen + if args.time: + training_time = time.time() - start + time_file = open("{}/time-{}.txt".format(args.r_dir, param_stamp), 'w') + time_file.write('{}\n'.format(training_time)) + time_file.close() + if verbose and args.time: + print("Total training time = {:.1f} seconds\n".format(training_time)) + # -save trained model(s), if requested + if args.save: + save_name = "mM-{}".format(param_stamp) if ( + not hasattr(args, 'full_stag') or args.full_stag == "none" + ) else "{}-{}".format(model.name, args.full_stag) + utils.save_checkpoint(model, args.m_dir, name=save_name, verbose=verbose) + else: + # Load previously trained model(s) (if goal is to only evaluate previously trained model) + if verbose: + print("\nLoading parameters of previously trained model...") + load_name = "mM-{}".format(param_stamp) if ( + not hasattr(args, 'full_ltag') or args.full_ltag == "none" + ) else "{}-{}".format(model.name, args.full_ltag) + utils.load_checkpoint(model, args.m_dir, name=load_name, verbose=verbose, strict=False) + + #-------------------------------------------------------------------------------------------------# + + #----------------------# + #----- EVALUATION -----# + #----------------------# + + if verbose: + print('\n\n' + ' EVALUATION '.center(70, '*')) + + # Set attributes of model that define how to do classification + if checkattr(args, 'gen_classifier'): + model.S = args.eval_s + + # Evaluate accuracy of final model on full test-set + if verbose: + print("\n Accuracy of final model on test-set:") + accs = [] + for context_id in range(args.contexts): + acc = evaluate.test_acc( + model, test_datasets[context_id], verbose=False, context_id=context_id, allowed_classes=list( + range(config['classes_per_context'] * context_id, config['classes_per_context'] * (context_id+1)) + ) if (args.scenario == "task" and not checkattr(args, 'singlehead')) else None, test_size=None, + ) + if verbose: + print(" - Context {}: {:.4f}".format(context_id+1, acc)) + accs.append(acc) + average_accs = sum(accs) / args.contexts + if verbose: + print('=> average accuracy over all {} contexts: {:.4f}\n\n'.format(args.contexts, average_accs)) + # -write out to text file + file_name = "{}/acc-{}{}.txt".format(args.r_dir, param_stamp, + "--S{}".format(args.eval_s) if checkattr(args, 'gen_classifier') else "") + output_file = open(file_name, 'w') + output_file.write('{}\n'.format(average_accs)) + output_file.close() + + + + +if __name__ == '__main__': + # -load input-arguments + args = handle_inputs() + # -run experiment + run(args, verbose=True) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/__init__.py b/PyTorch/build-in/other/continual-learning/models/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/models/cl/__init__.py b/PyTorch/build-in/other/continual-learning/models/cl/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/models/cl/continual_learner.py b/PyTorch/build-in/other/continual-learning/models/cl/continual_learner.py new file mode 100644 index 000000000..d7c5dc177 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/cl/continual_learner.py @@ -0,0 +1,641 @@ +import abc +import numpy as np +import torch +from torch import nn +from torch.distributions import Categorical +from torch.nn import functional as F +from utils import get_data_loader +from models import fc +from models.utils.ncl import additive_nearest_kf + + +class ContinualLearner(nn.Module, metaclass=abc.ABCMeta): + '''Abstract module to add continual learning capabilities to a classifier (e.g., param regularization, replay).''' + + def __init__(self): + super().__init__() + + # List with the methods to create generators that return the parameters on which to apply param regularization + self.param_list = [self.named_parameters] #-> lists the parameters to regularize with SI or diagonal Fisher + # (default is to apply it to all parameters of the network) + #-> with OWM or KFAC Fisher, only parameters in [self.fcE] and [self.classifier] are regularized + + # Optimizer (and whether it needs to be reset) + self.optimizer = None + self.optim_type = "adam" + #--> self.[optim_type] name of optimizer, relevant if optimizer should be reset for every context + self.optim_list = [] + #--> self.[optim_list] , if optimizer should be reset after each context, provide list of required + + # Scenario, singlehead & negative samples + self.scenario = 'task' # which scenario will the model be trained on + self.classes_per_context = 2 # number of classes per context + self.singlehead = False # if Task-IL, does the model have a single-headed output layer? + self.neg_samples = 'all' # if Class-IL, which output units should be set to 'active'? + + # LwF / Replay + self.replay_mode = "none" # should replay be used, and if so what kind? (none|current|buffer|all|generative) + self.replay_targets = "hard" # should distillation loss be used? (hard|soft) + self.KD_temp = 2. # temperature for distillation loss + self.use_replay = "normal" # how to use the replayed data? (normal|inequality|both) + # -inequality = use gradient of replayed data as inequality constraint for gradient + # of the current data (as in A-GEM; Chaudry et al., 2019; ICLR) + self.eps_agem = 0. # parameter that improves numerical stability of AGEM (if set slighly above 0) + self.lwf_weighting = False # LwF has different weighting of the 'stability' and 'plasticity' terms than replay + + # XdG: + self.mask_dict = None # -> with context-specific masks for each hidden fully-connected layer + self.excit_buffer_list = [] # -> with excit-buffers for all hidden fully-connected layers + + # Parameter-regularization + self.weight_penalty = False + self.reg_strength = 0 #-> hyperparam: how strong to weigh the weight penalty ("regularisation strength") + self.precondition = False + self.alpha = 1e-10 #-> small constant to stabilize inversion of the Fisher Information Matrix + # (this is used as hyperparameter in OWM) + self.importance_weighting = 'fisher' #-> Options for estimation of parameter importance: + # - 'fisher': Fisher Information matrix (e.g., as in EWC, NCL) + # - 'si': ... diagonal, online importance estimation ... + # - 'owm': ... + self.fisher_kfac = False #-> whether to use a block-diagonal KFAC approximation to the Fisher Information + # (alternative is a diagonal approximation) + self.fisher_n = None #-> sample size for estimating FI-matrix (if "None", full pass over dataset) + self.fisher_labels = "all" #-> what label(s) to use for any given sample when calculating the FI matrix? + # - 'all': use all labels, weighted according to their predicted probabilities + # - 'sample': sample one label to use, using predicted probabilities for sampling + # - 'pred': use the predicted label (i.e., the one with highest predicted prob) + # - 'true': use the true label (NOTE: this is also called "empirical FI") + self.fisher_batch = 1 #-> batch size for estimating FI-matrix (should be 1, for best results) + # (different from 1 only works if [fisher_labels]='pred' or 'true') + self.context_count = 0 #-> counts 'contexts' (if a prior is used, this is counted as the first context) + self.data_size = None #-> inverse prior (can be set to # samples per context, or used as hyperparameter) + self.epsilon = 0.1 #-> dampening parameter (SI): bounds 'omega' when squared parameter-change goes to 0 + self.offline = False #-> use separate penalty term per context (as in original EWC paper) + self.gamma = 1. #-> decay-term for old contexts' contribution to cummulative FI (as in 'Online EWC') + self.randomize_fisher = False + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + + #----------------- XdG-specifc functions -----------------# + + def apply_XdGmask(self, context): + '''Apply context-specific mask, by setting activity of pre-selected subset of nodes to zero. + + [context] , starting from 1''' + + assert self.mask_dict is not None + torchType = next(self.parameters()).detach() + + # Loop over all buffers for which a context-specific mask has been specified + for i,excit_buffer in enumerate(self.excit_buffer_list): + gating_mask = np.repeat(1., len(excit_buffer)) + gating_mask[self.mask_dict[context][i]] = 0. # -> find context-specific mask + excit_buffer.set_(torchType.new(gating_mask)) # -> apply this mask + + def reset_XdGmask(self): + '''Remove context-specific mask, by setting all "excit-buffers" to 1.''' + torchType = next(self.parameters()).detach() + for excit_buffer in self.excit_buffer_list: + gating_mask = np.repeat(1., len(excit_buffer)) # -> define "unit mask" (i.e., no masking at all) + excit_buffer.set_(torchType.new(gating_mask)) # -> apply this unit mask + + + #------------- "Synaptic Intelligence"-specifc functions -------------# + + def register_starting_param_values(self): + '''Register the starting parameter values into the model as a buffer.''' + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + self.register_buffer('{}_SI_prev_context'.format(n), p.detach().clone()) + + def prepare_importance_estimates_dicts(self): + '''Prepare to store running importance estimates and param-values before update.''' + W = {} + p_old = {} + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + W[n] = p.data.clone().zero_() + p_old[n] = p.data.clone() + return W, p_old + + def update_importance_estimates(self, W, p_old): + '''Update the running parameter importance estimates in W.''' + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + if p.grad is not None: + W[n].add_(-p.grad*(p.detach()-p_old[n])) + p_old[n] = p.detach().clone() + + def update_omega(self, W, epsilon): + '''After completing training on a context, update the per-parameter regularization strength. + + [W] estimated parameter-specific contribution to changes in total loss of completed context + [epsilon] dampening parameter (to bound [omega] when [p_change] goes to 0)''' + + # Loop over all parameters + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + + # Find/calculate new values for quadratic penalty on parameters + p_prev = getattr(self, '{}_SI_prev_context'.format(n)) + p_current = p.detach().clone() + p_change = p_current - p_prev + omega_add = W[n]/(p_change**2 + epsilon) + try: + omega = getattr(self, '{}_SI_omega'.format(n)) + except AttributeError: + omega = p.detach().clone().zero_() + omega_new = omega + omega_add + + # Store these new values in the model + self.register_buffer('{}_SI_prev_context'.format(n), p_current) + self.register_buffer('{}_SI_omega'.format(n), omega_new) + + def surrogate_loss(self): + '''Calculate SI's surrogate loss.''' + try: + losses = [] + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + # Retrieve previous parameter values and their normalized path integral (i.e., omega) + n = n.replace('.', '__') + prev_values = getattr(self, '{}_SI_prev_context'.format(n)) + omega = getattr(self, '{}_SI_omega'.format(n)) + # Calculate SI's surrogate loss, sum over all parameters + losses.append((omega * (p-prev_values)**2).sum()) + return sum(losses) + except AttributeError: + # SI-loss is 0 if there is no stored omega yet + return torch.tensor(0., device=self._device()) + + + #----------------- EWC-specifc functions -----------------# + + def initialize_fisher(self): + '''Initialize diagonal fisher matrix with the prior precision (as in NCL).''' + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + # -take initial parameters as zero for regularization purposes + self.register_buffer('{}_EWC_prev_context'.format(n), p.detach().clone()*0) + # -precision (approximated by diagonal Fisher Information matrix) + self.register_buffer( '{}_EWC_estimated_fisher'.format(n), torch.ones(p.shape) / self.data_size) + + def estimate_fisher(self, dataset, allowed_classes=None): + '''After completing training on a context, estimate diagonal of Fisher Information matrix. + + [dataset]: to be used to estimate FI-matrix + [allowed_classes]: with class-indeces of 'allowed' or 'active' classes''' + + # Prepare to store estimated Fisher Information matrix + est_fisher_info = {} + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + est_fisher_info[n] = p.detach().clone().zero_() + + # Set model to evaluation mode + mode = self.training + self.eval() + + # Create data-loader to give batches of size 1 (unless specifically asked to do otherwise) + data_loader = get_data_loader(dataset, batch_size=1 if self.fisher_batch is None else self.fisher_batch, + cuda=self._is_on_cuda()) + + # Estimate the FI-matrix for [self.fisher_n] batches of size 1 + for index,(x,y) in enumerate(data_loader): + # break from for-loop if max number of samples has been reached + if self.fisher_n is not None: + if index > self.fisher_n: + break + # run forward pass of model + x = x.to(self._device()) + output = self(x) if allowed_classes is None else self(x)[:, allowed_classes] + # calculate FI-matrix (according to one of the four options) + if self.fisher_labels=='all': + # -use a weighted combination of all labels + with torch.no_grad(): + label_weights = F.softmax(output, dim=1) # --> get weights, which shouldn't have gradient tracked + for label_index in range(output.shape[1]): + label = torch.LongTensor([label_index]).to(self._device()) + negloglikelihood = F.cross_entropy(output, label) #--> get neg log-likelihoods for this class + # Calculate gradient of negative loglikelihood + self.zero_grad() + negloglikelihood.backward(retain_graph=True if (label_index+1) use provided true label to calculate loglikelihood --> "empirical Fisher": + label = torch.LongTensor([y]) if type(y)==int else y #-> shape: [self.fisher_batch] + if allowed_classes is not None: + label = [int(np.where(i == allowed_classes)[0][0]) for i in label.numpy()] + label = torch.LongTensor(label) + label = label.to(self._device()) + elif self.fisher_labels=='pred': + # --> use predicted label to calculate loglikelihood: + label = output.max(1)[1] + elif self.fisher_labels=='sample': + # --> sample one label from predicted probabilities + with torch.no_grad(): + label_weights = F.softmax(output, dim=1) #--> get predicted probabilities + weights_array = np.array(label_weights[0].cpu()) #--> change to np-array, avoiding rounding errors + label = np.random.choice(len(weights_array), 1, p=weights_array/weights_array.sum()) + label = torch.LongTensor(label).to(self._device()) #--> change label to tensor on correct device + # calculate negative log-likelihood + negloglikelihood = F.nll_loss(F.log_softmax(output, dim=1), label) + # calculate gradient of negative loglikelihood + self.zero_grad() + negloglikelihood.backward() + # square gradients and keep running sum + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + if p.grad is not None: + est_fisher_info[n] += p.grad.detach() ** 2 + if self.randomize_fisher: + idx = torch.randperm(est_fisher_info[n].nelement()) + est_fisher_info[n] = est_fisher_info[n].view(-1)[idx].view(est_fisher_info[n].size()) + + # Normalize by sample size used for estimation + est_fisher_info = {n: p/index for n, p in est_fisher_info.items()} + + # Store new values in the network + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + n = n.replace('.', '__') + # -mode (=MAP parameter estimate) + self.register_buffer('{}_EWC_prev_context{}'.format(n, self.context_count+1 if self.offline else ""), + p.detach().clone()) + # -precision (approximated by diagonal Fisher Information matrix) + if (not self.offline) and hasattr(self, '{}_EWC_estimated_fisher'.format(n)): + existing_values = getattr(self, '{}_EWC_estimated_fisher'.format(n)) + est_fisher_info[n] += self.gamma * existing_values + self.register_buffer( + '{}_EWC_estimated_fisher{}'.format(n, self.context_count+1 if self.offline else ""), est_fisher_info[n] + ) + + # Increase context-count + self.context_count += 1 + + # Set model back to its initial mode + self.train(mode=mode) + + def ewc_loss(self): + '''Calculate EWC-loss.''' + try: + losses = [] + # If "offline EWC", loop over all previous contexts as each context has separate penalty term + num_penalty_terms = self.context_count if (self.offline and self.context_count>0) else 1 + for context in range(1, num_penalty_terms+1): + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + # Retrieve stored mode (MAP estimate) and precision (Fisher Information matrix) + n = n.replace('.', '__') + mean = getattr(self, '{}_EWC_prev_context{}'.format(n, context if self.offline else "")) + fisher = getattr(self, '{}_EWC_estimated_fisher{}'.format(n, context if self.offline else "")) + # If "online EWC", apply decay-term to the running sum of the Fisher Information matrices + fisher = fisher if self.offline else self.gamma*fisher + # Calculate weight regularization loss + losses.append((fisher * (p-mean)**2).sum()) + # Sum the regularization loss from all parameters (and from all contexts, if "offline EWC") + return (1./2)*sum(losses) + except AttributeError: + # Regularization loss is 0 if there are no stored mode and precision yet + return torch.tensor(0., device=self._device()) + + + # ----------------- KFAC-specifc functions -----------------# + + def initialize_kfac_fisher(self): + '''Initialize Kronecker-factored Fisher matrix with the prior precision (as in NCL).''' + fcE = self.fcE + classifier = self.classifier + + def initialize_for_fcLayer(layer): + if not isinstance(layer, fc.layers.fc_layer): + raise NotImplemented + linear = layer.linear + g_dim, a_dim = linear.weight.shape + abar_dim = a_dim + 1 if linear.bias is not None else a_dim + A = torch.eye(abar_dim) / np.sqrt(self.data_size) + G = torch.eye(g_dim) / np.sqrt(self.data_size) + return {"A": A, "G": G, "weight": linear.weight.data * 0, + "bias": None if linear.bias is None else linear.bias.data * 0} + + def initialize(): + est_fisher_info = {} + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + layer = getattr(fcE, label) + est_fisher_info[label] = initialize_for_fcLayer(layer) + est_fisher_info["classifier"] = initialize_for_fcLayer(classifier) + return est_fisher_info + + self.KFAC_FISHER_INFO = initialize() + + def estimate_kfac_fisher(self, dataset, allowed_classes=None): + """After completing training on a context, estimate KFAC Fisher Information matrix. + + [dataset]: to be used to estimate FI-matrix + [allowed_classes]: with class-indeces of 'allowed' or 'active' classes + """ + + print('computing kfac fisher') + + fcE = self.fcE + classifier = self.classifier + + def initialize_for_fcLayer(layer): + if not isinstance(layer, fc.layers.fc_layer): + raise NotImplemented + linear = layer.linear + g_dim, a_dim = linear.weight.shape + abar_dim = a_dim + 1 if linear.bias is not None else a_dim + A = torch.zeros(abar_dim, abar_dim) + G = torch.zeros(g_dim, g_dim) + if linear.bias is None: + bias = None + else: + bias = linear.bias.data.clone() + return {"A": A, "G": G, "weight": linear.weight.data.clone(), "bias": bias} + + def initialize(): + est_fisher_info = {} + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + layer = getattr(fcE, label) + est_fisher_info[label] = initialize_for_fcLayer(layer) + est_fisher_info["classifier"] = initialize_for_fcLayer(classifier) + return est_fisher_info + + def update_fisher_info_layer(est_fisher_info, intermediate, label, layer, n_samples, weight=1): + if not isinstance(layer, fc.layers.fc_layer): + raise NotImplemented + if not hasattr(layer, 'phantom'): + raise Exception(f"Layer {label} does not have phantom parameters") + g = layer.phantom.grad.detach() + G = g[..., None] @ g[..., None, :] + _a = intermediate[label].detach() + # Here we do one batch at a time (not ideal) + assert _a.shape[0] == 1 + a = _a[0] + + if classifier.bias is None: + abar = a + else: + o = torch.ones(*a.shape[0:-1], 1).to(self._device()) + abar = torch.cat((a, o), -1) + A = abar[..., None] @ abar[..., None, :] + Ao = est_fisher_info[label]["A"].to(self._device()) + Go = est_fisher_info[label]["G"].to(self._device()) + est_fisher_info[label]["A"] = Ao + weight * A / n_samples + est_fisher_info[label]["G"] = Go + weight * G / n_samples + + def update_fisher_info(est_fisher_info, intermediate, n_samples, weight=1): + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + layer = getattr(fcE, label) + update_fisher_info_layer(est_fisher_info, intermediate, label, layer, n_samples, weight=weight) + update_fisher_info_layer(est_fisher_info, intermediate, "classifier", self.classifier, n_samples, + weight=weight) + + # initialize estimated fisher info + est_fisher_info = initialize() + # Set model to evaluation mode + mode = self.training + self.eval() + + # Create data-loader to give batches of size 1 (unless specifically asked to do otherwise) + data_loader = get_data_loader(dataset, batch_size=1 if self.fisher_batch is None else self.fisher_batch, + cuda=self._is_on_cuda()) + + n_samples = len(data_loader) if self.fisher_n is None else self.fisher_n + + # Estimate the FI-matrix for [self.fisher_n] batches of size 1 + for i, (x, y) in enumerate(data_loader): + # break from for-loop if max number of samples has been reached + if i > n_samples: + break + # run forward pass of model + x = x.to(self._device()) + _output, intermediate = self(x, return_intermediate=True) + output = _output if allowed_classes is None else _output[:, allowed_classes] + # calculate FI-matrix (according to one of the four options) + if self.fisher_labels=='all': + # -use a weighted combination of all labels + with torch.no_grad(): + label_weights = F.softmax(output, dim=1) # --> get weights, which shouldn't have gradient tracked + for label_index in range(output.shape[1]): + label = torch.LongTensor([label_index]).to(self._device()) + negloglikelihood = F.nll_loss(F.log_softmax(output, dim=1), label) + # Calculate gradient of negative loglikelihood + self.zero_grad() + negloglikelihood.backward(retain_graph=True if (label_index+1) use provided true label to calculate loglikelihood --> "empirical Fisher": + label = torch.LongTensor([y]) if type(y) == int else y # -> shape: [self.fisher_batch] + if allowed_classes is not None: + label = [int(np.where(i == allowed_classes)[0][0]) for i in label.numpy()] + label = torch.LongTensor(label) + label = label.to(self._device()) + elif self.fisher_labels == 'pred': + # --> use predicted label to calculate loglikelihood: + label = output.max(1)[1] + elif self.fisher_labels == 'sample': + # --> sample one label from predicted probabilities + with torch.no_grad(): + label_weights = F.softmax(output, dim=1) # --> get predicted probabilities + weights_array = np.array(label_weights[0].cpu()) # --> change to np-array, avoiding rounding errors + label = np.random.choice(len(weights_array), 1, p=weights_array / weights_array.sum()) + label = torch.LongTensor(label).to(self._device()) # --> change label to tensor on correct device + + # calculate negative log-likelihood + negloglikelihood = F.nll_loss(F.log_softmax(output, dim=1), label) + + # Calculate gradient of negative loglikelihood + self.zero_grad() + negloglikelihood.backward() + update_fisher_info(est_fisher_info, intermediate, n_samples) + + + for label in est_fisher_info: + An = est_fisher_info[label]["A"].to(self._device()) # new kronecker factor + Gn = est_fisher_info[label]["G"].to(self._device()) # new kronecker factor + Ao = self.gamma * self.KFAC_FISHER_INFO[label]["A"].to(self._device()) # old kronecker factor + Go = self.KFAC_FISHER_INFO[label]["G"].to(self._device()) # old kronecker factor + + As, Gs = additive_nearest_kf({"A": Ao, "G": Go}, {"A": An, "G": Gn}) # sum of kronecker factors + self.KFAC_FISHER_INFO[label]["A"] = As + self.KFAC_FISHER_INFO[label]["G"] = Gs + + for param_name in ["weight", "bias"]: + p = est_fisher_info[label][param_name].to(self._device()) + self.KFAC_FISHER_INFO[label][param_name] = p + + # Set model back to its initial mode + self.train(mode=mode) + + + def ewc_kfac_loss(self): + fcE = self.fcE + + def loss_for_layer(label, layer): + if not isinstance(layer, fc.layers.fc_layer): + raise NotImplemented + info = self.KFAC_FISHER_INFO[label] + A = info["A"].detach().to(self._device()) + G = info["G"].detach().to(self._device()) + bias0 = info["bias"] + weight0 = info["weight"] + bias = layer.linear.bias + weight = layer.linear.weight + if bias0 is not None and bias is not None: + p = torch.cat([weight, bias[..., None]], -1) + p0 = torch.cat([weight0, bias0[..., None]], -1) + else: + p = weight + p0 = weight0 + assert p.shape[-1] == A.shape[1] + assert p0.shape[-1] == A.shape[1] + dp = p.to(self._device()) - p0.to(self._device()) + return torch.sum(dp * (G @ dp @ A)) + + classifier = self.classifier + if self.context_count > 0: + l = loss_for_layer("classifier", classifier) + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + nl = loss_for_layer(label, getattr(fcE, label)) + l += nl + return 0.5 * l + else: + return torch.tensor(0.0, device=self._device()) + + + # ----------------- OWM-specifc functions -----------------# + + def estimate_owm_fisher(self, dataset, **kwargs): + '''After completing training on a context, estimate OWM Fisher Information matrix based on [dataset].''' + + ## QUESTION: Should OWM not also be applied to the outputs?? + + fcE = self.fcE + classifier = self.classifier + + def initialize_for_fcLayer(layer): + if not isinstance(layer, fc.layers.fc_layer): + raise NotImplemented + linear = layer.linear + g_dim, a_dim = linear.weight.shape + abar_dim = a_dim + 1 if linear.bias is not None else a_dim + A = torch.zeros(abar_dim, abar_dim) + return {'A': A, 'weight': linear.weight.data.clone(), + 'bias': None if linear.bias is None else linear.bias.data.clone()} + + def initialize(): + est_fisher_info = {} + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + layer = getattr(fcE, label) + est_fisher_info[label] = initialize_for_fcLayer(layer) + est_fisher_info['classifier'] = initialize_for_fcLayer(classifier) + return est_fisher_info + + def update_fisher_info_layer(est_fisher_info, intermediate, label, n_samples): + _a = intermediate[label].detach() + # Here we do one batch at a time (not ideal) + assert (_a.shape[0] == 1) + a = _a[0] + if classifier.bias is None: + abar = a + else: + o = torch.ones(*a.shape[0:-1], 1).to(self._device()) + abar = torch.cat((a, o), -1) + A = abar[..., None] @ abar[..., None, :] + Ao = est_fisher_info[label]['A'].to(self._device()) + est_fisher_info[label]['A'] = Ao + A / n_samples + + def update_fisher_info(est_fisher_info, intermediate, n_samples): + for i in range(1, fcE.layers + 1): + label = f"fcLayer{i}" + update_fisher_info_layer(est_fisher_info, intermediate, label, n_samples) + update_fisher_info_layer(est_fisher_info, intermediate, 'classifier', n_samples) + + # initialize estimated fisher info + est_fisher_info = initialize() + # Set model to evaluation mode + mode = self.training + self.eval() + + # Create data-loader to give batches of size 1 + data_loader = get_data_loader(dataset, batch_size=1, cuda=self._is_on_cuda()) + + n_samples = len(data_loader) if self.fisher_n is None else self.fisher_n + + # Estimate the FI-matrix for [self.fisher_n] batches of size 1 + for i, (x, _) in enumerate(data_loader): + if i > n_samples: + break + # run forward pass of model + x = x.to(self._device()) + output, intermediate = self(x, return_intermediate=True) + # update OWM importance matrix + self.zero_grad() + update_fisher_info(est_fisher_info, intermediate, n_samples) + + if self.context_count == 0: + self.KFAC_FISHER_INFO = {} + + for label in est_fisher_info: + An = est_fisher_info[label]['A'].to(self._device()) # new kronecker factor + if self.context_count == 0: + self.KFAC_FISHER_INFO[label] = {} + As = An + else: + Ao = self.gamma * self.KFAC_FISHER_INFO[label]['A'].to(self._device()) # old kronecker factor + frac = 1 / (self.context_count + 1) + As = (1 - frac) * Ao + frac * An + + self.KFAC_FISHER_INFO[label]['A'] = As + + for param_name in ['weight', 'bias']: + p = est_fisher_info[label][param_name].to(self._device()) + self.KFAC_FISHER_INFO[label][param_name] = p + + self.context_count += 1 + + # Set model back to its initial mode + self.train(mode=mode) \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/cl/fromp_optimizer.py b/PyTorch/build-in/other/continual-learning/models/cl/fromp_optimizer.py new file mode 100644 index 000000000..97f8ed98e --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/cl/fromp_optimizer.py @@ -0,0 +1,415 @@ +import math +import numpy as np +import random +import torch +from torch.optim.optimizer import Optimizer +from torch.nn.utils import parameters_to_vector, vector_to_parameters +import torch.nn as nn +import torch.nn.functional as F +from models.fc import excitability_modules as em + + +## This code has been based upon: https://github.com/team-approx-bayes/fromp (accessed 8 July 2021) + + +#--------------------------------------------------------------------------------------------# + +############################ +## COMPUTATION OF HESSIAN ## +############################ + +# Calculate the diagonal elements of the hessian +def softmax_hessian(f): + s = F.softmax(f, dim=-1) + return s - s*s + +# Calculate the full softmax hessian +def full_softmax_hessian(f): + s = F.softmax(f, dim=-1) + e = torch.eye(s.shape[-1], dtype=s.dtype, device=s.device) + return s[:, :, None]*e[None, :, :] - s[:, :, None]*s[:, None, :] + + +#--------------------------------------------------------------------------------------------# + +###################### +## HELPER FUNCTIONS ## +###################### + +def _update_input(self, input, output): + self.input = input[0].data + self.output = output + +def _check_param_device(param, old_param_device): + if old_param_device is None: + old_param_device = param.get_device() if param.is_cuda else -1 + else: + warn = (param.get_device() != old_param_device) if param.is_cuda else (old_param_device != -1) + if warn: + raise TypeError('Parameters are on different devices, not currently supported.') + return old_param_device + +def _parameters_to_matrix(parameters): + param_device = None + mat = [] + for param in parameters: + param_device = _check_param_device(param, param_device) + m = param.shape[0] + mat.append(param.view(m, -1)) + return torch.cat(mat, dim=-1) + +def _parameters_grads_to_vector(parameters): + param_device = None + vec = [] + for param in parameters: + param_device = _check_param_device(param, param_device) + if param.grad is None: + raise ValueError('Gradient is not available.') + vec.append(param.grad.data.view(-1)) + return torch.cat(vec, dim=-1) + + +#--------------------------------------------------------------------------------------------# + +##################### +## FROMP OPTIMIZER ## +##################### + +class opt_fromp(Optimizer): + '''Implements the FROMP algorithm (Pan et al., 2020 NeurIPS) as a PyTorch-optimizer, combined with Adam. + + Args: + model (nn.Module): model whose parameters are to be trained + lr (float, optional): learning rate (default: 0.001) + betas (tuple, optional): coefs for computing running mean of gradient and its square (default: (0.9, 0.999)) + amsgrad (bool, optional): whether to use the AMSGrad-variant of the Adam algorithm (default: False) + tau (float, optional): how strongly to weight the regularization term, FROMP's main hyperparameter (default: 1.) + eps (float, optional): term added to the denominator to improve numerical stability (default: 1e-8) + prior_prec (float, optional): ... (default: 1e-3) + grad_clip_norm (float, optional): what value to clip the norm of the gradient to during training (default: 1.) + per_context (bool, optional): ... (default: True) + ''' + + def __init__(self, model, lr=1e-3, betas=(0.9, 0.999), amsgrad=False, + tau=1., eps=1e-8, prior_prec=1e-3, grad_clip_norm=1., per_context=True): + + # Check for invalid arguments + if not 0.0 <= lr: + raise ValueError("invalid learning rate: {}".format(lr)) + if not 0.0 <= eps: + raise ValueError("invalid epsilon value: {}".format(eps)) + if not 0.0 <= betas[0] < 1.0: + raise ValueError("invalid beta parameter at index 0: {}".format(betas[0])) + if not 0.0 <= betas[1] < 1.0: + raise ValueError("invalid beta parameter at index 1: {}".format(betas[1])) + if not 0.0 <= prior_prec: + raise ValueError("invalid prior precision: {}".format(prior_prec)) + if grad_clip_norm is not None and not 0.0 <= grad_clip_norm: + raise ValueError("invalid gradient clip norm: {}".format(grad_clip_norm)) + if not 0.0 <= tau: + raise ValueError("invalid tau: {}".format(tau)) + + # Deal with arguments set per parameter group (ALTHOUGH PARAMETER GROUPS ARE NOT FUNCTIONAL WITH THIS OPTIMIZER) + defaults = dict(lr=lr, betas=betas, eps=eps, prior_prec=prior_prec, grad_clip_norm=grad_clip_norm, + tau=tau, amsgrad=amsgrad) + super(opt_fromp, self).__init__(model.parameters(), defaults) + + # Set the model and its trainable modules + self.per_context = per_context + self.model = model + self.train_modules = [] + self.set_train_modules(model) + for module in self.train_modules: + module.register_forward_hook(_update_input) + + # Initialize the optimizer's state variables + parameters = self.param_groups[0]['params'] + p = parameters_to_vector(parameters) + self.state['mu'] = p.clone().detach() + self.state['mu_previous'] = p.clone().detach() + self.state['fisher'] = torch.zeros_like(self.state['mu']) + self.state['step'] = 0 + self.state['exp_avg'] = torch.zeros_like(self.state['mu']) + self.state['exp_avg_sq'] = torch.zeros_like(self.state['mu']) + if amsgrad: + self.state['max_exp_avg_sq'] = torch.zeros_like(self.state['mu']) + + # Set all trainable modules, required for calculating Jacobians in PyTorch + def set_train_modules(self, module): + if len(list(module.children())) == 0: + if len(list(module.parameters())) != 0: + self.train_modules.append(module) + else: + for child in list(module.children()): + self.set_train_modules(child) + + #----------------------------------------------------------------------------------------------------------# + + # Calculate the gradient of the parameters [lc] with respect to the loss (required for calculating the Jacobian) + def cac_grad(self, loss, lc, retain_graph=None): + linear_grad = torch.autograd.grad(loss, lc, retain_graph=retain_graph) + grad = [] + for i, module in enumerate(self.train_modules): + # print("--> Starting module {} of {}".format(i, len(self.train_modules))) + g = linear_grad[i].detach() + a = module.input.clone().detach() + m = a.shape[0] + + if isinstance(module, nn.Linear) or isinstance(module, em.LinearExcitability): + with torch.no_grad(): + grad.append(torch.einsum('ij,ik->ijk', g, a)) + if module.bias is not None: + grad.append(g) + + if isinstance(module, nn.Conv2d): + with torch.no_grad(): + a = F.unfold(a, kernel_size=module.kernel_size, dilation=module.dilation, padding=module.padding, + stride=module.stride) + _, k, hw = a.shape + _, c, _, _ = g.shape + g = g.view(m, c, -1) + grad.append(torch.einsum('ijl,ikl->ijk', g, a)) + if module.bias is not None: + a = torch.ones((m, 1, hw), device=a.device) + grad.append(torch.einsum('ijl,ikl->ijk', g, a)) + + if isinstance(module, nn.BatchNorm1d): + with torch.no_grad(): + grad.append(torch.mul(g, a)) + if module.bias is not None: + grad.append(g) + + if isinstance(module, nn.BatchNorm2d): + with torch.no_grad(): + grad.append(torch.einsum('ijkl->ij', torch.mul(g, a))) + if module.bias is not None: + grad.append(torch.einsum('ijkl->ij', g)) + + grad_m = _parameters_to_matrix(grad) + return grad_m.detach() + + # Calculate the Jacobian matrix + def cac_jacobian(self, output, lc): + if output.dim() > 2: + raise ValueError('the dimension of output must be smaller than 3.') + elif output.dim() == 2: + num_fun = output.shape[1] + grad = [] + for i in range(num_fun): + retain_graph = None if i == num_fun-1 else True + loss = output[:, i].sum() + g = self.cac_grad(loss, lc, retain_graph=retain_graph) + grad.append(g) + result = torch.zeros((grad[0].shape[0], grad[0].shape[1], num_fun), + dtype=grad[0].dtype, device=grad[0].device) + for i in range(num_fun): + result[:, :, i] = grad[i] + return result + + #----------------------------------------------------------------------------------------------------------# + + # Calculate values (memorable_logits, hkh_l) for regularisation term (all but the first context) + def init_context(self, context_id, eps=1e-6, reset=True, classes_per_context=2, label_sets=None): + + # If requested, reset the adam-optimizer + if reset: + self.state['exp_avg'] = torch.zeros_like(self.state['mu']) + self.state['exp_avg_sq'] = torch.zeros_like(self.state['mu']) + self.state['step'] = 0 + + # Initiliase objects to be stored as empty lists + self.state['kernel_inv'] = [] + self.state['memorable_logits'] = [] + + # Compute covariance (using the pre-computed Fisher matrix) + fisher = self.state['fisher'] + prior_prec = self.param_groups[0]['prior_prec'] + covariance = 1. / (fisher + prior_prec) #-> size: [n_params] + + # Get and store parameter values + mu = self.state['mu'] + self.state['mu_previous'] = mu.clone().detach() + parameters = self.param_groups[0]['params'] + vector_to_parameters(mu, parameters) + + # Loop over all contexts so far + self.model.eval() + for i in range(context_id if self.per_context else 1): + + # Collect all memorable points for this context from the memory buffer + classes_in_context = range(classes_per_context*i, classes_per_context*(i+1)) if self.per_context else range( + classes_per_context*context_id + ) + mem_points_np = np.concatenate([self.model.memory_sets[id] for id in classes_in_context], axis=0) + memorable_points_t = torch.from_numpy(mem_points_np).to(self.model._device()) + #-> size: [n_per_context]x[ch]x[length]x[width] + + # Compute and store the mean of their function values (i.e., the predicted logits) + self.zero_grad() + logits = self.model.forward(memorable_points_t) + preds = logits if (label_sets[i] is None) else logits[:, label_sets[i]] + preds = torch.softmax(preds, dim=-1) #-> size: [n_per_context]x[classes_per_context] + self.state['memorable_logits'].append(preds.detach()) + + # Compute and store the kernel of their function values + lc = [] + for module in self.train_modules: + lc.append(module.output) + kernel_inv = [] + num_classes = preds.shape[-1] + + for class_id in range(num_classes): + loss = preds[:, class_id].sum() + retain_graph = True if class_id < num_classes-1 else None + grad = self.cac_grad(loss, lc, retain_graph=retain_graph) #-> size: [n_mem_points]x[n_params] + with torch.no_grad(): + kernel = torch.einsum('ij,j,pj->ip', grad, covariance, grad) + \ + torch.eye(grad.shape[0], dtype=grad.dtype, device=grad.device)*eps + # -store inverse of kernel (size: [n_mem_points]x[n_mem_points]) for this class via Cholesky decomp + kernel_inv.append(torch.cholesky_inverse(torch.cholesky(kernel))) + + self.state['kernel_inv'].append(kernel_inv) + + # After training on a new context, update the fisher matrix estimate + def update_fisher(self, dataloader, label_set=None): + fisher = self.state['fisher'] + + self.model.eval() + for data,_ in dataloader: + data = data.to(self.model._device()) + + self.zero_grad() + logits = self.model.forward(data) + preds = logits if label_set is None else logits[:, label_set] + + lc = [] + for module in self.train_modules: + lc.append(module.output) + jac = self.cac_jacobian(preds, lc).detach() + with torch.no_grad(): + hes = full_softmax_hessian(preds.detach()) + jhj = torch.einsum('ijd,idp,ijp->j', jac, hes, jac) + fisher.add_(jhj) + + #----------------------------------------------------------------------------------------------------------# + + def step(self, x, y, label_sets, context_id, classes_per_context): + '''Performs a single optimization step.''' + + defaults = self.defaults + lr = self.param_groups[0]['lr'] + beta1, beta2 = self.param_groups[0]['betas'] + amsgrad = self.param_groups[0]['amsgrad'] + parameters = self.param_groups[0]['params'] + mu = self.state['mu'] + + self.model.train() + + # Calculate normal loss term over current context's data, and compute its gradient + vector_to_parameters(mu, parameters) + self.zero_grad() + logits = self.model.forward(x) if ( + label_sets[context_id] is None + ) else self.model.forward(x)[:, label_sets[context_id]] + loss_cur = F.cross_entropy(input=logits, target=y, reduction='mean') + accuracy = (y == logits.max(1)[1]).sum().item() / x.size(0) + loss_cur.backward(retain_graph=None) + grad = _parameters_grads_to_vector(parameters).detach() + + # Calculate the loss term corresponding to the memorable points, and compute & add their gradients + if context_id > 0: + self.model.eval() + kernel_inv = self.state['kernel_inv'] + memorable_logits = self.state['memorable_logits'] + grad_t_sum = torch.zeros_like(grad) + for t in range(context_id if self.per_context else 1): + + # Select subset of memorable points to use in this batch + batch_size_per_context = int(np.ceil(x.shape[0] / context_id)) if self.per_context else x.shape[0] + if self.per_context: + memory_samples_per_context = (len(self.model.memory_sets[0])*classes_per_context) + else: + memory_samples_per_context = (len(self.model.memory_sets[0])*classes_per_context*context_id) + if batch_size_per_contextj', jac_t, kinvf_t) + + grad_t_sum.add_(grad_t) + + # Weight term corresponding to memorable points by [tau] and add to gradient + with torch.no_grad(): + grad_t_sum.mul_(defaults['tau']) + grad.add_(grad_t_sum) + + # Do gradient norm clipping + clip_norm = self.defaults['grad_clip_norm'] + if clip_norm is not None: + grad_norm = torch.norm(grad) + grad_norm = 1.0 if grad_norm < clip_norm else grad_norm/clip_norm + grad.div_(grad_norm) + + # Given the gradient computed above, prepare for the updated based on Adam algorithm + exp_avg, exp_avg_sq = self.state['exp_avg'], self.state['exp_avg_sq'] + if amsgrad: + max_exp_avg_sq = self.state['max_exp_avg_sq'] + self.state['step'] += 1 + exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1) + exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) + if amsgrad: + torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq) + denom = max_exp_avg_sq.sqrt().add_(self.param_groups[0]['eps']) + else: + denom = exp_avg_sq.sqrt().add_(self.param_groups[0]['eps']) + bias_correction1 = 1 - beta1 ** self.state['step'] + bias_correction2 = 1 - beta2 ** self.state['step'] + step_size = lr * math.sqrt(bias_correction2) / bias_correction1 + + # Do the parameter update + mu.addcdiv_(exp_avg, denom, value=-step_size) + vector_to_parameters(mu, parameters) + + # Return the dictionary with different training-loss split in categories + return { + 'loss_total': loss_cur.item(), + 'loss_current': loss_cur.item(), + 'pred': loss_cur.item(), + 'accuracy': accuracy if accuracy is not None else 0., + } + + #----------------------------------------------------------------------------------------------------------# diff --git a/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer.py b/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer.py new file mode 100644 index 000000000..fb4c3f37a --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer.py @@ -0,0 +1,207 @@ +import abc +import torch +from torch import nn +from torch.nn import functional as F +from utils import get_data_loader +import copy +import numpy as np +from models.cl.fromp_optimizer import softmax_hessian + + +class MemoryBuffer(nn.Module, metaclass=abc.ABCMeta): + """Abstract module for a classifier that enables it to maintain a memory buffer.""" + + def __init__(self): + super().__init__() + + # List with memory-sets + self.memory_sets = [] #-> each entry of [self.memory_sets] is an of N images with shape (N, Ch, H, W) + self.memory_set_means = [] + self.compute_means = True + + # Settings + self.use_memory_buffer = False + self.budget_per_class = 100 + self.use_full_capacity = False + self.sample_selection = 'random' + self.norm_exemplars = True + + # Atributes defining how to use memory-buffer + self.prototypes = False #-> perform classification by using prototypes as class templates + self.add_buffer = False #-> add the memory buffer to the training set of the current task + + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + @abc.abstractmethod + def feature_extractor(self, images): + pass + + + ####----MANAGING THE MEMORY BUFFER----#### + + def reduce_memory_sets(self, m): + for y, P_y in enumerate(self.memory_sets): + self.memory_sets[y] = P_y[:m] + + def construct_memory_set(self, dataset, n, label_set): + '''Construct memory set of [n] examples from [dataset] using 'herding', 'random' or 'fromp' selection. + + Note that [dataset] should be from specific class; selected sets are added to [self.memory_sets] in order.''' + + # set model to eval()-mode + mode = self.training + self.eval() + + n_max = len(dataset) + memory_set = [] + + if self.sample_selection=="fromp": + first_entry = True + + # Loop over all samples in the dataset + dataloader = get_data_loader(dataset, 128, cuda=self._is_on_cuda()) + for i, dt in enumerate(dataloader): + # Compute for each sample its "importance score" + data, _ = dt + f = self.forward(data.to(self._device())) + lamb = softmax_hessian(f if label_set is None else f[:,label_set]) + lamb = torch.sum(lamb.cpu(), dim=-1).detach() + + # Store both the samples and their computed scores + if first_entry: + memorable_points = data + scores = lamb + first_entry = False + else: + memorable_points = torch.cat([memorable_points, data], dim=0) + scores = torch.cat([scores, lamb], dim=0) + + # Select the samples with the best (or worst) scores, and store them in the memory buffer + if len(memorable_points) > n: + _, indices = scores.sort(descending=True) + memorable_points = memorable_points[indices[:n]] + # -add this [memory_set] as a [n]x[ich]x[isz]x[isz] to the list of [memory_sets] + self.memory_sets.append(memorable_points.numpy()) + + elif self.sample_selection=="herding": + # Compute features for each example in [dataset] + first_entry = True + dataloader = get_data_loader(dataset, 128, cuda=self._is_on_cuda()) + for (image_batch, _) in dataloader: + image_batch = image_batch.to(self._device()) + with torch.no_grad(): + feature_batch = self.feature_extractor(image_batch).cpu() + if first_entry: + features = feature_batch + first_entry = False + else: + features = torch.cat([features, feature_batch], dim=0) + if self.norm_exemplars: + features = F.normalize(features, p=2, dim=1) + + # Calculate mean of all features + class_mean = torch.mean(features, dim=0, keepdim=True) + if self.norm_exemplars: + class_mean = F.normalize(class_mean, p=2, dim=1) + + # One by one, select samples so the mean of all selected samples is as close to [class_mean] as possible + selected_features = torch.zeros_like(features[:min(n, n_max)]) + list_of_selected = [] + for k in range(min(n, n_max)): + if k>0: + selected_samples_sum = torch.sum(selected_features[:k], dim=0).unsqueeze(0) + features_means = (features + selected_samples_sum)/(k+1) + features_dists = features_means - class_mean + else: + features_dists = features - class_mean + index_selected = np.argmin(torch.norm(features_dists, p=2, dim=1)) + if index_selected in list_of_selected: + raise ValueError("Samples in the memory buffer should not be repeated!!!!") + list_of_selected.append(index_selected) + + memory_set.append(dataset[index_selected][0].numpy()) + selected_features[k] = copy.deepcopy(features[index_selected]) + # -make sure this example won't be selected again + features[index_selected] = features[index_selected] + 10000 + # -add this [memory_set] as a [n]x[ich]x[isz]x[isz] to the list of [memory_sets] + self.memory_sets.append(np.array(memory_set)) + + else: + indeces_selected = np.random.choice(n_max, size=min(n, n_max), replace=False) + for k in indeces_selected: + memory_set.append(dataset[k][0].numpy()) + # -add this [memory_set] as a [n]x[ich]x[isz]x[isz] to the list of [memory_sets] + self.memory_sets.append(np.array(memory_set)) + + # Set mode of model back + self.train(mode=mode) + + + ####----CLASSIFICATION----#### + + def classify_with_prototypes(self, x, allowed_classes=None): + """Classify images by nearest-prototype / nearest-mean-of-exemplars rule (after transform to feature space) + + INPUT: x = of size (bsz,ich,isz,isz) with input image batch + allowed_classes = None or containing all "active classes" between which should be chosen + + OUTPUT: scores = of size (bsz,n_classes) + """ + + # Set model to eval()-mode + mode = self.training + self.eval() + + batch_size = x.size(0) + + # Do the exemplar-means (=prototypes) need to be recomputed? + if self.compute_means: + memory_set_means = [] #--> list of 1D-tensors (of size [feature_size]), list is of length [n_classes] + for P_y in self.memory_sets: + exemplars = [] + # Collect all 'exemplars' in P_y into a and extract their features + for ex in P_y: + exemplars.append(torch.from_numpy(ex)) + exemplars = torch.stack(exemplars).to(self._device()) + with torch.no_grad(): + features = self.feature_extractor(exemplars) + if self.norm_exemplars: + features = F.normalize(features, p=2, dim=1) + # Calculate their mean and add to list + mu_y = features.mean(dim=0, keepdim=True) + if self.norm_exemplars: + mu_y = F.normalize(mu_y, p=2, dim=1) + memory_set_means.append(mu_y.squeeze()) # -> squeeze removes all dimensions of size 1 + # Update model's attributes + self.memory_set_means = memory_set_means + self.compute_means = False + + # Reorganize the [memory_set_means]- + memory_set_means = self.memory_set_means if allowed_classes is None else [ + self.memory_set_means[i] for i in allowed_classes + ] + means = torch.stack(memory_set_means) # (n_classes, feature_size) + means = torch.stack([means] * batch_size) # (batch_size, n_classes, feature_size) + means = means.transpose(1, 2) # (batch_size, feature_size, n_classes) + + # Extract features for input data (and reorganize) + with torch.no_grad(): + feature = self.feature_extractor(x) # (batch_size, feature_size) + if self.norm_exemplars: + feature = F.normalize(feature, p=2, dim=1) + feature = feature.unsqueeze(2) # (batch_size, feature_size, 1) + feature = feature.expand_as(means) # (batch_size, feature_size, n_classes) + + # For each sample in [x], find the (negative) distance of its extracted features to exemplar-mean of each class + scores = -(feature-means).pow(2).sum(dim=1).squeeze() # (batch_size, n_classes) + + # Set mode of model back + self.train(mode=mode) + + return scores + diff --git a/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer_stream.py b/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer_stream.py new file mode 100644 index 000000000..81578a000 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/cl/memory_buffer_stream.py @@ -0,0 +1,168 @@ +import abc +import torch +from torch import nn +from torch.nn import functional as F +import numpy as np + + +def reservoir_sampling(samples_so_far, budget): + '''Reservoir sampling algorithm to decide whether an new sample should be stored in the buffer or not.''' + + # If buffer is not yet full, simply add the new sample at the first available index + if samples_so_far < budget: + return samples_so_far + + # If buffer is full, draw random number to decide whether new sample should replace old sample (and which one) + rand = np.random.randint(0, samples_so_far + 1) + if rand < budget: + return rand #--> new sample should replace old sample at index [rand] + else: + return -1 #--> new sample should not be stored in the buffer + + +class MemoryBuffer(nn.Module, metaclass=abc.ABCMeta): + """Abstract module for classifier for maintaining a memory buffer using (global-)class-based reservoir sampling.""" + + def __init__(self): + super().__init__() + + # Settings + self.use_memory_buffer = False + self.budget = 100 #-> this is the overall budget (there is not memory buffer per class) + self.samples_so_far = 0 + self.contexts_so_far = [] + + # Settings related to using the memory buffer for nearest-class-mean classification + self.prototypes = False #-> whether classification is performed by using prototypes as class templates + self.compute_means = True #-> whenever new data is added, class-means must be recomputed + self.norm_exemplars = True + + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + @abc.abstractmethod + def feature_extractor(self, images, **kwargs): + pass + + def initialize_buffer(self, config, return_c=False): + '''Initalize the memory buffer with tensors of correct shape filled with zeros.''' + self.buffer_x = torch.zeros(self.budget, config['channels'], config['size'], config['size'], + dtype=torch.float32, device=self._device()) + self.buffer_y = torch.zeros(self.budget, dtype=torch.int64, device=self._device()) + if return_c: + self.buffer_c = torch.zeros(self.budget, dtype=torch.int64, device=self._device()) + pass + + def add_new_samples(self, x, y, c): + '''Process the data, and based on reservoir sampling algorithm potentially add to the buffer.''' + + # Whenever new training data is observed, indicate that class-means of stored data should be recomputed + self.compute_means = True + + # Loop through all the samples contained in [x] + for index in range(x.shape[0]): + # -check whether this sample should be added to the memory buffer + reservoir_index = reservoir_sampling(self.samples_so_far, self.budget) + # -increase count of number of encountered samples + self.samples_so_far += 1 + # -if selected, add the sample to the memory buffer + if reservoir_index >= 0: + self.buffer_x[reservoir_index] = x[index].to(self._device()) + self.buffer_y[reservoir_index] = y[index].to(self._device()) + if hasattr(self, 'buffer_c'): + self.buffer_c[reservoir_index] = c[index].to(self._device()) + + def sample_from_buffer(self, size): + '''Randomly sample [size] samples from the memory buffer.''' + + # If more samples are requested than in the buffer, set [size] to number of samples currently in the buffer + samples_in_buffer = min(self.samples_so_far, self.budget) + if size>samples_in_buffer: + size = samples_in_buffer + + # Randomly select samples from the buffer and return them + selected_indeces = np.random.choice(samples_in_buffer, size=size, replace=False) + x = self.buffer_x[selected_indeces] + y = self.buffer_y[selected_indeces] + c = self.buffer_c[selected_indeces] if hasattr(self, 'buffer_c') else None + return (x, y, c) + + def keep_track_of_contexts_so_far(self, c): + self.contexts_so_far += [item.item() for item in c] + + def sample_contexts(self, size): + if len(self.contexts_so_far)==0: + raise AssertionError('No contexts have been observed yet.') + else: + return torch.tensor(np.random.choice(self.contexts_so_far, size, replace=True)) + + + def classify_with_prototypes(self, x, context=None): + """Classify images by nearest-prototype / nearest-mean-of-exemplars rule (after transform to feature space) + + INPUT: x = of size (bsz,ich,isz,isz) with input image batch + + OUTPUT: scores = of size (bsz,n_classes) + """ + + # Set model to eval()-mode + mode = self.training + self.eval() + + batch_size = x.size(0) + + # Do the exemplar-means (=prototypes) need to be recomputed? + if self.compute_means: + self.possible_classes = [] #--> list of classes present in the memory buffer + memory_set_means = [] #--> list of 1D-tensors (of size [feature_size]), list is of length [n_classes] + for y in range(self.classes): + if y in self.buffer_y: + self.possible_classes.append(y) + # Collect all stored samples of [y] + x_this_y = self.buffer_x[self.buffer_y==y] + c_this_y = self.buffer_c[self.buffer_y==y] if hasattr(self, 'buffer_c') else None + # Extract their features + with torch.no_grad(): + features = self.feature_extractor(x_this_y, context=c_this_y) + if self.norm_exemplars: + features = F.normalize(features, p=2, dim=1) + # Calculate their mean and add to list + mu_y = features.mean(dim=0, keepdim=True) + if self.norm_exemplars: + mu_y = F.normalize(mu_y, p=2, dim=1) + memory_set_means.append(mu_y.squeeze()) # -> squeeze removes all dimensions of size 1 + else: + memory_set_means.append(None) # to indicate that this class is not present in the memory buffer + # Update model's attributes + self.memory_set_means = memory_set_means + self.compute_means = False + + # Reorganize the [memory_set_means]- + memory_set_means = [self.memory_set_means[i] for i in self.possible_classes] + means = torch.stack(memory_set_means) # (n_possible_classes, feature_size) + means = torch.stack([means] * batch_size) # (batch_size, n_possible_classes, feature_size) + means = means.transpose(1, 2) # (batch_size, feature_size, n_possible_classes) + + # Extract features for input data (and reorganize) + with torch.no_grad(): + feature = self.feature_extractor(x, context=context) # (batch_size, feature_size) + if self.norm_exemplars: + feature = F.normalize(feature, p=2, dim=1) + feature = feature.unsqueeze(2) # (batch_size, feature_size, 1) + feature = feature.expand_as(means) # (batch_size, feature_size, n_possible_classes) + + # For each sample in [x], find the (negative) distance of its extracted features to exemplar-mean of each class + scores = -(feature-means).pow(2).sum(dim=1).squeeze() # (batch_size, n_possible_classes) + + # For all classes not in the memory, return a score of [-inf] + all_scores = torch.ones(batch_size, self.classes, device=self._device())*-np.inf + all_scores[:, self.possible_classes] = scores # (batch_size, n_classes) + + # Set mode of model back + self.train(mode=mode) + + return scores diff --git a/PyTorch/build-in/other/continual-learning/models/classifier.py b/PyTorch/build-in/other/continual-learning/models/classifier.py new file mode 100644 index 000000000..f1aa485ae --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/classifier.py @@ -0,0 +1,431 @@ +import torch +from torch.nn import functional as F +from models.fc.layers import fc_layer +from models.fc.nets import MLP +from models.conv.nets import ConvLayers +from models.cl.memory_buffer import MemoryBuffer +from models.cl.continual_learner import ContinualLearner +from models.utils import loss_functions as lf, modules +from models.utils.ncl import additive_nearest_kf + + +class Classifier(ContinualLearner, MemoryBuffer): + '''Model for classifying images, "enriched" as ContinualLearner- and MemoryBuffer-object.''' + + def __init__(self, image_size, image_channels, classes, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=True, fc_nl="relu", fc_gated=False, + bias=True, excitability=False, excit_buffer=False, phantom=False): + + # configurations + super().__init__() + self.classes = classes + self.label = "Classifier" + self.depth = depth + self.fc_layers = fc_layers + self.fc_drop = fc_drop + self.phantom = phantom + + # settings for training + self.binaryCE = False #-> use binary (instead of multiclass) prediction error + self.binaryCE_distill = False #-> for classes from previous contexts, use the by the previous model + # predicted probs as binary targets (only in Class-IL with binaryCE) + + # check whether there is at least 1 fc-layer + if fc_layers<1: + raise ValueError("The classifier needs to have at least 1 fully-connected layer.") + + + ######------SPECIFY MODEL------###### + #--> convolutional layers + self.convE = ConvLayers( + conv_type=conv_type, block_type="basic", num_blocks=num_blocks, image_channels=image_channels, + depth=depth, start_channels=start_channels, reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, + global_pooling=global_pooling, gated=conv_gated, output="none" if no_fnl else "normal", + ) + self.flatten = modules.Flatten() # flatten image to 2D-tensor + #------------------------------calculate input/output-sizes--------------------------------# + self.conv_out_units = self.convE.out_units(image_size) + self.conv_out_size = self.convE.out_size(image_size) + self.conv_out_channels = self.convE.out_channels + #------------------------------------------------------------------------------------------# + #--> fully connected hidden layers + self.fcE = MLP(input_size=self.conv_out_units, output_size=fc_units, layers=fc_layers-1, + hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, bias=bias, + excitability=excitability, excit_buffer=excit_buffer, gated=fc_gated, phantom=phantom) + mlp_output_size = fc_units if fc_layers>1 else self.conv_out_units + #--> classifier + self.classifier = fc_layer(mlp_output_size, classes, excit_buffer=True, nl='none', drop=fc_drop, + phantom=phantom) + + # Flags whether parts of the network are frozen (so they can be set to evaluation mode during training) + self.convE.frozen = False + self.fcE.frozen = False + + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.convE.list_init_layers() + list += self.fcE.list_init_layers() + list += self.classifier.list_init_layers() + return list + + @property + def name(self): + if self.depth>0 and self.fc_layers>1: + return "{}_{}_c{}".format(self.convE.name, self.fcE.name, self.classes) + elif self.depth>0: + return "{}_{}c{}".format(self.convE.name, "drop{}-".format(self.fc_drop) if self.fc_drop>0 else "", + self.classes) + elif self.fc_layers>1: + return "{}_c{}".format(self.fcE.name, self.classes) + else: + return "i{}_{}c{}".format(self.conv_out_units, "drop{}-".format(self.fc_drop) if self.fc_drop>0 else "", + self.classes) + + + def forward(self, x, return_intermediate=False): + hidden = self.convE(x) + flatten_x = self.flatten(hidden) + if not return_intermediate: + final_features = self.fcE(flatten_x) + else: + final_features, intermediate = self.fcE(flatten_x, return_intermediate=True) + intermediate["classifier"] = final_features + out = self.classifier(final_features) + return (out, intermediate) if return_intermediate else out + + + def feature_extractor(self, images): + return self.fcE(self.flatten(self.convE(images))) + + def classify(self, x, allowed_classes=None, no_prototypes=False): + '''For input [x] (image/"intermediate" features), return predicted "scores"/"logits" for [allowed_classes].''' + if self.prototypes and not no_prototypes: + return self.classify_with_prototypes(x, allowed_classes=allowed_classes) + else: + image_features = self.flatten(self.convE(x)) + hE = self.fcE(image_features) + scores = self.classifier(hE) + return scores if (allowed_classes is None) else scores[:, allowed_classes] + + + def train_a_batch(self, x, y, scores=None, x_=None, y_=None, scores_=None, rnt=0.5, active_classes=None, context=1, + **kwargs): + '''Train model for one batch ([x],[y]), possibly supplemented with replayed data ([x_],[y_/scores_]). + + [x] batch of inputs (could be None, in which case only 'replayed' data is used) + [y] batch of corresponding labels + [scores] None or 2Dtensor:[batch]x[classes] predicted "scores"/"logits" for [x] + NOTE: only to be used for "BCE with distill" (only when scenario=="class") + [x_] None or ( of) batch of replayed inputs + [y_] None or ( of) batch of corresponding "replayed" labels + [scores_] None or ( of) 2Dtensor:[batch]x[classes] predicted "scores"/"logits" for [x_] + [rnt] in [0,1], relative importance of new context + [active_classes] None or ( of) with "active" classes + [context] context-ID, with first context labelled as '1' (e.g., for setting context-specific mask) + ''' + + # Set model to training-mode + self.train() + # -however, if some layers are frozen, they should be set to eval() to prevent batch-norm layers from changing + if self.convE.frozen: + self.convE.eval() + if self.fcE.frozen: + self.fcE.eval() + + # Reset optimizer + self.optimizer.zero_grad() + + # Should gradient be computed separately for each context? (needed when a context-mask is combined with replay) + gradient_per_context = True if ((self.mask_dict is not None) and (x_ is not None)) else False + + + ##--(1)-- REPLAYED DATA --## + + if x_ is not None: + # If there are different predictions per context, [y_] or [scores_] are lists and [x_] must be evaluated + # separately on each of them (although [x_] could be a list as well!) + PerContext = (type(y_)==list) if (y_ is not None) else (type(scores_)==list) + if not PerContext: + y_ = [y_] + scores_ = [scores_] + active_classes = [active_classes] if (active_classes is not None) else None + n_replays = len(y_) if (y_ is not None) else len(scores_) + + # Prepare lists to store losses for each replay + loss_replay = [None]*n_replays + predL_r = [None]*n_replays + distilL_r = [None]*n_replays + + # Run model (if [x_] is not a list with separate replay per context and there is no context-specific mask) + if (not type(x_)==list) and (self.mask_dict is None): + y_hat_all = self(x_) + + # Loop to evalute predictions on replay according to each previous context + for replay_id in range(n_replays): + + # -if [x_] is a list with separate replay per context, evaluate model on this context's replay + if (type(x_)==list) or (self.mask_dict is not None): + x_temp_ = x_[replay_id] if type(x_)==list else x_ + if self.mask_dict is not None: + self.apply_XdGmask(context=replay_id+1) + y_hat_all = self(x_temp_) + + # -if needed, remove predictions for classes not active in the replayed context + y_hat = y_hat_all if (active_classes is None) else y_hat_all[:, active_classes[replay_id]] + + # Calculate losses + if (y_ is not None) and (y_[replay_id] is not None): + if self.binaryCE: + binary_targets_ = lf.to_one_hot(y_[replay_id].cpu(), y_hat.size(1)).to(y_[replay_id].device) + predL_r[replay_id] = F.binary_cross_entropy_with_logits( + input=y_hat, target=binary_targets_, reduction='none' + ).sum(dim=1).mean() #--> sum over classes, then average over batch + else: + predL_r[replay_id] = F.cross_entropy(y_hat, y_[replay_id], reduction='mean') + if (scores_ is not None) and (scores_[replay_id] is not None): + # n_classes_to_consider = scores.size(1) #--> with this version, no zeroes are added to [scores]! + n_classes_to_consider = y_hat.size(1) #--> zeros will be added to [scores] to make it this size! + kd_fn = lf.loss_fn_kd_binary if self.binaryCE else lf.loss_fn_kd + distilL_r[replay_id] = kd_fn(scores=y_hat[:, :n_classes_to_consider], + target_scores=scores_[replay_id], T=self.KD_temp) + + # Weigh losses + if self.replay_targets=="hard": + loss_replay[replay_id] = predL_r[replay_id] + elif self.replay_targets=="soft": + loss_replay[replay_id] = distilL_r[replay_id] + + # If needed, perform backward pass before next context-mask (gradients of all contexts will be accumulated) + if gradient_per_context: + weight = 1. if self.use_replay=='inequality' else (1.-rnt) + weighted_replay_loss_this_context = weight * loss_replay[replay_id] / n_replays + weighted_replay_loss_this_context.backward() + + # Calculate total replay loss + loss_replay = None if (x_ is None) else sum(loss_replay)/n_replays + if (x_ is not None) and self.lwf_weighting and (not self.scenario=='class'): + loss_replay *= (context-1) + + # If using the replayed loss as an inequality constraint, calculate and store averaged gradient of replayed data + if self.use_replay in ('inequality', 'both') and x_ is not None: + # Perform backward pass to calculate gradient of replayed batch (if not yet done) + if not gradient_per_context: + if self.use_replay == 'both': + loss_replay = (1-rnt) * loss_replay + loss_replay.backward() + # Reorganize the gradient of the replayed batch as a single vector + grad_rep = [] + for p in self.parameters(): + if p.requires_grad: + grad_rep.append(p.grad.data.view(-1)) + grad_rep = torch.cat(grad_rep) + # If gradients are only used as inequality constraint, reset them + if self.use_replay=='inequality': + self.optimizer.zero_grad() + + + ##--(2)-- CURRENT DATA --## + + if x is not None: + # If requested, apply correct context-specific mask + if self.mask_dict is not None: + self.apply_XdGmask(context=context) + + # Run model + y_hat = self(x) + # -if needed, remove predictions for classes not active in the current context + if active_classes is not None: + class_entries = active_classes[-1] if type(active_classes[0])==list else active_classes + y_hat = y_hat[:, class_entries] + + # Calculate prediction loss + if self.binaryCE: + # -binary prediction loss + binary_targets = lf.to_one_hot(y.cpu(), y_hat.size(1)).to(y.device) + if self.binaryCE_distill and (scores is not None): + # -replace targets for previously seen classes with predictions of previous model + binary_targets[:,:scores.size(1)] = torch.sigmoid(scores / self.KD_temp) + predL = None if y is None else F.binary_cross_entropy_with_logits( + input=y_hat, target=binary_targets, reduction='none' + ).sum(dim=1).mean() #--> sum over classes, then average over batch + else: + # -multiclass prediction loss + predL = None if y is None else F.cross_entropy(input=y_hat, target=y, reduction='mean') + + # Weigh losses + loss_cur = predL + + # Calculate training-accuracy + accuracy = None if y is None else (y == y_hat.max(1)[1]).sum().item() / x.size(0) + else: + accuracy = predL = None + # -> it's possible there is only "replay" [i.e., for offline with incremental context learning] + + + # Combine loss from current and replayed batch + if x_ is None or self.use_replay=='inequality': + loss_total = loss_cur + elif gradient_per_context or self.use_replay=='both': + # -if backward passes are performed per context (i.e., XdG combined with replay), or when the replayed loss + # is both added to the current loss and used as inequality constraint, the gradients of the replayed loss + # are already backpropagated and accumulated + loss_total = rnt*loss_cur + else: + if self.lwf_weighting: + loss_total = loss_replay if (x is None) else loss_cur+loss_replay + else: + loss_total = loss_replay if (x is None) else rnt*loss_cur+(1-rnt)*loss_replay + + + ##--(3)-- PARAMETER REGULARIZATION LOSSES --## + + # Add a parameter regularization penalty to the loss function + weight_penalty_loss = None + if self.weight_penalty: + if self.importance_weighting=='si': + weight_penalty_loss = self.surrogate_loss() + elif self.importance_weighting=='fisher': + if self.fisher_kfac: + weight_penalty_loss = self.ewc_kfac_loss() + else: + weight_penalty_loss = self.ewc_loss() + loss_total += self.reg_strength * weight_penalty_loss + + + ##--(4)-- COMPUTE (AND MANIPULATE) GRADIENTS --## + + # Backpropagate errors (for the part of the loss that has not yet been backpropagated) + loss_total.backward() + + # A-GEM: check whether gradients to be used align with gradients of replayed data, project them if needed + if self.use_replay in ('inequality', 'both') and x_ is not None: + # -reorganize the gradients to be used for the optimization step as single vector + grad_cur = [] + for p in self.parameters(): + if p.requires_grad: + grad_cur.append(p.grad.view(-1)) + grad_cur = torch.cat(grad_cur) + # -check inequality constraint + angle = (grad_cur * grad_rep).sum() + if angle < 0: + # -if violated, project the current gradient onto the gradient of the replayed batch ... + length_rep = (grad_rep * grad_rep).sum() + grad_proj = grad_cur - (angle / (length_rep + self.eps_agem)) * grad_rep + # -...and replace all the gradients within the model with this projected gradient + index = 0 + for p in self.parameters(): + if p.requires_grad: + n_param = p.numel() # number of parameters in [p] + p.grad.copy_(grad_proj[index:index + n_param].view_as(p)) + index += n_param + + # Precondition gradient of current data using projection matrix constructed from parameter importance estimates + if self.precondition: + + if self.importance_weighting=='fisher' and not self.fisher_kfac: + if self.context_count>0: + #--> scale gradients by inverse diagonal Fisher + for gen_params in self.param_list: + for n, p in gen_params(): + if p.requires_grad: + # Retrieve prior fisher matrix + n = n.replace(".", "__") + fisher = getattr(self, "{}_EWC_estimated_fisher".format(n)) + # Scale loss landscape by inverse prior fisher and divide learning rate by data size + scale = (fisher + self.alpha**2) ** (-1) + p.grad *= scale # scale lr by inverse prior information + if self.data_size is not None: + p.grad /= self.data_size # scale lr by prior (necessary for stability in 1st context) + + elif self.importance_weighting=='fisher' and self.fisher_kfac: + #--> scale gradients by inverse Fisher kronecker factors + def scale_grad(label, layer): + assert isinstance(layer, fc_layer) + info = self.KFAC_FISHER_INFO[label] # get previous KFAC fisher + A = info["A"].to(self._device()) + G = info["G"].to(self._device()) + linear = layer.linear + if linear.bias is not None: + g = torch.cat( (linear.weight.grad, linear.bias.grad[..., None]), -1).clone() + else: + g = layer.linear.weight.grad.clone() + + assert g.shape[-1] == A.shape[-1] + assert g.shape[-2] == G.shape[-2] + iA = torch.eye(A.shape[0]).to(self._device()) * (self.alpha) + iG = torch.eye(G.shape[0]).to(self._device()) * (self.alpha) + + As, Gs = additive_nearest_kf({"A": A, "G": G}, {"A": iA, "G": iG}) # kronecker sums + Ainv = torch.inverse(As) + Ginv = torch.inverse(Gs) + + scaled_g = Ginv @ g @ Ainv + if linear.bias is not None: + linear.weight.grad = scaled_g[..., 0:-1].detach() / self.data_size + linear.bias.grad = scaled_g[..., -1].detach() / self.data_size + else: + linear.weight.grad = scaled_g[..., 0:-1, :] / self.data_size + + # make sure to reset all phantom to have no zeros + if not hasattr(layer, 'phantom'): + raise ValueError(f"Layer {label} does not have phantom parameters") + # make sure phantom stays zero + layer.phantom.grad.zero_() + layer.phantom.data.zero_() + + scale_grad("classifier", self.classifier) + for i in range(1, self.fcE.layers + 1): + label = f"fcLayer{i}" + scale_grad(label, getattr(self.fcE, label)) + + elif self.importance_weighting=='owm' and context>1: + def scale_grad(label, layer): + info = self.KFAC_FISHER_INFO[label] # get previous KFAC fisher + A = info['A'].to(self._device()) + + linear = layer.linear + if linear.bias is not None: + g = torch.cat((linear.weight.grad, linear.bias.grad[..., None]), -1).clone() + else: + g = layer.linear.weight.grad.clone() + + assert (g.shape[-1] == A.shape[-1]) + iA = torch.eye(A.shape[0]).to(self._device()) # * (self.alpha) + As = A / self.alpha + iA + Ainv = torch.inverse(As) + scaled_g = g @ Ainv + + if linear.bias is not None: + linear.weight.grad = scaled_g[..., 0:-1].detach() + linear.bias.grad = scaled_g[..., -1].detach() + else: + linear.weight.grad = scaled_g[..., 0:-1, :] + + scale_grad('classifier', self.classifier) + for i in range(1, self.fcE.layers + 1): + label = f"fcLayer{i}" + scale_grad(label, getattr(self.fcE, label)) + + + ##--(5)-- TAKE THE OPTIMIZATION STEP --## + self.optimizer.step() + + + # Return the dictionary with different training-loss split in categories + return { + 'loss_total': loss_total.item(), + 'loss_current': loss_cur.item() if x is not None else 0, + 'loss_replay': loss_replay.item() if (loss_replay is not None) and (x is not None) else 0, + 'pred': predL.item() if predL is not None else 0, + 'pred_r': sum(predL_r).item()/n_replays if (x_ is not None and predL_r[0] is not None) else 0, + 'distil_r': sum(distilL_r).item()/n_replays if (x_ is not None and distilL_r[0] is not None) else 0, + 'param_reg': weight_penalty_loss.item() if weight_penalty_loss is not None else 0, + 'accuracy': accuracy if accuracy is not None else 0., + } + diff --git a/PyTorch/build-in/other/continual-learning/models/classifier_stream.py b/PyTorch/build-in/other/continual-learning/models/classifier_stream.py new file mode 100644 index 000000000..097d5515d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/classifier_stream.py @@ -0,0 +1,312 @@ +import numpy as np +import torch +from torch.nn import functional as F +from models.fc.layers import fc_layer, fc_multihead_layer +from models.fc.nets import MLP, MLP_gates +from models.conv.nets import ConvLayers +from models.cl.memory_buffer_stream import MemoryBuffer +from models.cl.continual_learner import ContinualLearner +from models.utils import loss_functions as lf, modules + + +class Classifier(ContinualLearner, MemoryBuffer): + '''Model for classifying images, "enriched" as ContinualLearner- and MemoryBuffer-object.''' + + def __init__(self, image_size, image_channels, classes, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=True, fc_nl="relu", fc_gated=False, + bias=True, excitability=False, excit_buffer=False, phantom=False, + # -how to use context-ID? + xdg_prob=0., n_contexts=5, multihead=False, device='cpu'): + + # configurations + super().__init__() + self.classes = classes + self.label = "Classifier" + self.stream_classifier = True + self.depth = depth + self.fc_layers = fc_layers + self.fc_drop = fc_drop + self.phantom = phantom + + # for using context information + self.xdg_prob = xdg_prob + self.n_contexts = n_contexts + self.multihead = multihead + + # for consolidation-operations, how often to update the model relative to which stay close + self.update_every = 1 + + # settings for training + self.binaryCE = False #-> use binary (instead of multiclass) prediction error + self.binaryCE_distill = False #-> for classes from previous contexts, use the by the previous model + # predicted probs as binary targets (only in Class-IL with binaryCE) + + # check whether there is at least 1 fc-layer + if fc_layers<1: + raise ValueError("The classifier needs to have at least 1 fully-connected layer.") + + + ######------SPECIFY MODEL------###### + #--> convolutional layers + self.convE = ConvLayers( + conv_type=conv_type, block_type="basic", num_blocks=num_blocks, image_channels=image_channels, + depth=depth, start_channels=start_channels, reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, + global_pooling=global_pooling, gated=conv_gated, output="none" if no_fnl else "normal", + ) + self.flatten = modules.Flatten() # flatten image to 2D-tensor + #------------------------------calculate input/output-sizes--------------------------------# + self.conv_out_units = self.convE.out_units(image_size) + self.conv_out_size = self.convE.out_size(image_size) + self.conv_out_channels = self.convE.out_channels + #------------------------------------------------------------------------------------------# + #--> fully connected hidden layers + if self.xdg_prob>0.: + self.fcE = MLP_gates(input_size=self.conv_out_units, output_size=fc_units, layers=fc_layers-1, + hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, bias=bias, + excitability=excitability, excit_buffer=excit_buffer, + gate_size=n_contexts, gating_prop=xdg_prob, final_gate=True, device=device) + else: + self.fcE = MLP(input_size=self.conv_out_units, output_size=fc_units, layers=fc_layers-1, + hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, bias=bias, + excitability=excitability, excit_buffer=excit_buffer, gated=fc_gated, phantom=phantom) + mlp_output_size = fc_units if fc_layers>1 else self.conv_out_units + + #--> classifier + if self.multihead: + self.classifier = fc_multihead_layer(mlp_output_size, classes, n_contexts, + excit_buffer=True, nl='none', drop=fc_drop, device=device) + else: + self.classifier = fc_layer(mlp_output_size, classes, excit_buffer=True, nl='none', drop=fc_drop, + phantom=phantom) + + # Flags whether parts of the network are frozen (so they can be set to evaluation mode during training) + self.convE.frozen = False + self.fcE.frozen = False + + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.convE.list_init_layers() + list += self.fcE.list_init_layers() + list += self.classifier.list_init_layers() + return list + + @property + def name(self): + if self.depth>0 and self.fc_layers>1: + return "{}_{}_c{}".format(self.convE.name, self.fcE.name, self.classes) + elif self.depth>0: + return "{}_{}c{}".format(self.convE.name, "drop{}-".format(self.fc_drop) if self.fc_drop>0 else "", + self.classes) + elif self.fc_layers>1: + return "{}_c{}".format(self.fcE.name, self.classes) + else: + return "i{}_{}c{}".format(self.conv_out_units, "drop{}-".format(self.fc_drop) if self.fc_drop>0 else "", + self.classes) + + + def forward(self, x, context=None): + # -if needed, convert [context] to one-hot vector + if (self.xdg_prob>0. or self.multihead) and (context is not None) and (type(context)==np.ndarray or context.dim()<2): + context_one_hot = lf.to_one_hot(context, classes=self.n_contexts, device=self._device()) + + hidden = self.convE(x) + flatten_x = self.flatten(hidden) + final_features = self.fcE(flatten_x, context_one_hot) if self.xdg_prob>0. else self.fcE(flatten_x) + out = self.classifier(final_features, context_one_hot) if self.multihead else self.classifier(final_features) + return out + + + def feature_extractor(self, images, context=None): + # -if needed, convert [context] to one-hot vector + if (self.xdg_prob>0. or self.multihead) and (context is not None) and (type(context)==np.ndarray or context.dim()<2): + context_one_hot = lf.to_one_hot(context, classes=self.n_contexts, device=self._device()) + + hidden = self.convE(images) + flatten_x = self.flatten(hidden) + final_features = self.fcE(flatten_x, context_one_hot) if self.xdg_prob>0. else self.fcE(flatten_x) + return final_features + + + def classify(self, x, context=None, no_prototypes=False): + '''For input [x] (image/"intermediate" features), return predicted "scores"/"logits" for [allowed_classes].''' + if self.prototypes and not no_prototypes: + return self.classify_with_prototypes(x, context=context) + else: + return self.forward(x, context=context) + + + def train_a_batch(self, x, y, c=None, x_=None, y_=None, c_=None, scores_=None, rnt=0.5, **kwargs): + '''Train model for one batch ([x],[y]), possibly supplemented with replayed data ([x_],[y_/scores_]). + + [x] batch of inputs (could be None, in which case only 'replayed' data is used) + [y] <1D-tensor> batch of corresponding labels + [c] <1D-tensor> or ; for each batch-element in [x] its context-ID --OR-- + <2D-tensor>; for each batch-element in [x] a probability for every context-ID + [x_] None or ( of) batch of replayed inputs + [y_] None or ( of) batch of corresponding "replayed" labels + [c_] + [scores_] None or ( of) 2Dtensor:[batch]x[classes] predicted "scores"/"logits" for [x_] + [rnt] in [0,1], relative importance of new context + ''' + + # Set model to training-mode + self.train() + # -however, if some layers are frozen, they should be set to eval() to prevent batch-norm layers from changing + if self.convE.frozen: + self.convE.eval() + if self.fcE.frozen: + self.fcE.eval() + + # Reset optimizer + self.optimizer.zero_grad() + + + ##--(1)-- REPLAYED DATA --## + + if x_ is not None: + # Run model + y_hat = self(x_, c_) + + # Calculate losses + predL_r, distilL_r = None, None + if (y_ is not None) and (y_ is not None): + if self.binaryCE: + binary_targets_ = lf.to_one_hot(y_.cpu(), y_hat.size(1)).to(y_.device) + predL_r = F.binary_cross_entropy_with_logits( + input=y_hat, target=binary_targets_, reduction='none' + ).sum(dim=1).mean() # --> sum over classes, then average over batch + else: + predL_r = F.cross_entropy(y_hat, y_, reduction='mean') + if (scores_ is not None) and (scores_ is not None): + kd_fn = lf.loss_fn_kd_binary if self.binaryCE else lf.loss_fn_kd + distilL_r = kd_fn(scores=y_hat, target_scores=scores_, T=self.KD_temp) + + # Weigh losses + if self.replay_targets == "hard": + loss_replay = predL_r + elif self.replay_targets == "soft": + loss_replay = distilL_r + + # Calculate total replay loss + loss_replay = None if (x_ is None) else loss_replay + + # If using the replayed loss as an inequality constraint, calculate and store averaged gradient of replayed data + if self.use_replay in ('inequality', 'both') and x_ is not None: + # Perform backward pass to calculate gradient of replayed batch (if not yet done) + if self.use_replay == 'both': + loss_replay = (1-rnt) * loss_replay + loss_replay.backward() + # Reorganize the gradient of the replayed batch as a single vector + grad_rep = [] + for p in self.parameters(): + if p.requires_grad: + grad_rep.append(p.grad.data.view(-1)) + grad_rep = torch.cat(grad_rep) + # If gradients are only used as inequality constraint, reset them + if self.use_replay=='inequality': + self.optimizer.zero_grad() + + + ##--(2)-- CURRENT DATA --## + + if x is not None: + # Run model + y_hat = self(x, c) + + # Calculate prediction loss + if self.binaryCE: + # -binary prediction loss + binary_targets = lf.to_one_hot(y.cpu(), y_hat.size(1)).to(y.device) + predL = None if y is None else F.binary_cross_entropy_with_logits( + input=y_hat, target=binary_targets, reduction='none' + ).sum(dim=1).mean() #--> sum over classes, then average over batch + else: + # -multiclass prediction loss + predL = None if y is None else F.cross_entropy(input=y_hat, target=y, reduction='mean') + + # Weigh losses + loss_cur = predL + + # Calculate training-accuracy + accuracy = None if y is None else (y == y_hat.max(1)[1]).sum().item() / x.size(0) + else: + accuracy = predL = None + # -> it's possible there is only "replay" [i.e., for offline with incremental context learning] + + + # Combine loss from current and replayed batch + if x_ is None or self.use_replay=='inequality': + loss_total = loss_cur + elif self.use_replay=='both': + # -if the replayed loss is both added to the current loss and used as inequality constraint, + # the gradients of the replayed loss are already backpropagated and accumulated + loss_total = rnt*loss_cur + else: + loss_total = loss_replay if (x is None) else rnt*loss_cur+(1-rnt)*loss_replay + + + ##--(3)-- PARAMETER REGULARIZATION LOSSES --## + + # Add a parameter regularization penalty to the loss function + weight_penalty_loss = None + if self.weight_penalty: + if self.importance_weighting=='si': + weight_penalty_loss = self.surrogate_loss() + elif self.importance_weighting=='fisher': + if self.fisher_kfac: + weight_penalty_loss = self.ewc_kfac_loss() + else: + weight_penalty_loss = self.ewc_loss() + loss_total += self.reg_strength * weight_penalty_loss + + + ##--(4)-- COMPUTE (AND MANIPULATE) GRADIENTS --## + + # Backpropagate errors (for the part of the loss that has not yet been backpropagated) + loss_total.backward() + + # A-GEM: check whether gradients to be used align with gradients of replayed data, project them if needed + if self.use_replay in ('inequality', 'both') and x_ is not None: + # -reorganize the gradients to be used for the optimization step as single vector + grad_cur = [] + for p in self.parameters(): + if p.requires_grad: + grad_cur.append(p.grad.view(-1)) + grad_cur = torch.cat(grad_cur) + # -check inequality constrain + angle = (grad_cur * grad_rep).sum() + if angle < 0: + # -if violated, project the current gradient onto the gradient of the replayed batch ... + length_rep = (grad_rep * grad_rep).sum() + grad_proj = grad_cur - (angle / (length_rep + self.eps_agem)) * grad_rep + # -...and replace all the gradients within the model with this projected gradient + index = 0 + for p in self.parameters(): + if p.requires_grad: + n_param = p.numel() # number of parameters in [p] + p.grad.copy_(grad_proj[index:index + n_param].view_as(p)) + index += n_param + + + ##--(5)-- TAKE THE OPTIMIZATION STEP --## + self.optimizer.step() + + + # Return the dictionary with different training-loss split in categories + return { + 'loss_total': loss_total.item(), + 'loss_current': loss_cur.item() if x is not None else 0, + 'loss_replay': loss_replay.item() if (loss_replay is not None) and (x is not None) else 0, + 'pred': predL.item() if predL is not None else 0, + 'pred_r': predL_r.item() if (x_ is not None and predL_r is not None) else 0, + 'distil_r': distilL_r.item() if (scores_ is not None and distilL_r is not None) else 0, + 'param_reg': weight_penalty_loss.item() if weight_penalty_loss is not None else 0, + 'accuracy': accuracy if accuracy is not None else 0., + } + diff --git a/PyTorch/build-in/other/continual-learning/models/cond_vae.py b/PyTorch/build-in/other/continual-learning/models/cond_vae.py new file mode 100644 index 000000000..a33118b15 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/cond_vae.py @@ -0,0 +1,747 @@ +import numpy as np +import math +import torch +from torch import nn +from torch.nn import functional as F +from models.fc.layers import fc_layer,fc_layer_split,fc_layer_fixed_gates +from models.fc.nets import MLP,MLP_gates +from models.conv.nets import ConvLayers,DeconvLayers +from models.cl.continual_learner import ContinualLearner +from models.utils import loss_functions as lf, modules + + +class CondVAE(ContinualLearner): + """Class for conditional variational auto-encoder (cond-VAE) model.""" + + def __init__(self, image_size, image_channels, classes, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=False, fc_nl="relu", fc_gated=False, excit_buffer=False, + # -prior + prior="standard", z_dim=20, per_class=False, n_modes=1, + # -decoder + recon_loss='BCE', network_output="sigmoid", deconv_type="standard", + dg_gates=False, dg_type="context", dg_prop=0., contexts=5, scenario="task", device='cuda', + # -classifer + classifier=True, **kwargs): + '''Class for variational auto-encoder (VAE) models.''' + + # Set configurations for setting up the model + super().__init__() + self.label = "CondVAE" + self.image_size = image_size + self.image_channels = image_channels + self.classes = classes + self.fc_layers = fc_layers + self.z_dim = z_dim + self.fc_units = fc_units + self.fc_drop = fc_drop + self.depth = depth + # -type of loss to be used for reconstruction + self.recon_loss = recon_loss # options: BCE|MSE + self.network_output = network_output + # -settings for class- or context-specific gates in fully-connected hidden layers of decoder + self.dg_type = dg_type + self.dg_prop = dg_prop + self.dg_gates = dg_gates if (dg_prop is not None) and dg_prop>0. else False + self.gate_size = (contexts if dg_type=="context" else classes) if self.dg_gates else 0 + self.scenario = scenario + + # Optimizer (needs to be set before training starts)) + self.optimizer = None + self.optim_list = [] + + # Prior-related parameters + self.prior = prior + self.per_class = per_class + self.n_modes = n_modes*classes if self.per_class else n_modes + self.modes_per_class = n_modes if self.per_class else None + + # Weigths of different components of the loss function + self.lamda_rcl = 1. + self.lamda_vl = 1. + self.lamda_pl = 1. if classifier else 0. + + self.average = True #--> makes that [reconL] and [variatL] are both divided by number of input-pixels + + # Check whether there is at least 1 fc-layer + if fc_layers<1: + raise ValueError("VAE cannot have 0 fully-connected layers!") + + + ######------SPECIFY MODEL------###### + + ##>----Encoder (= q[z|x])----<## + self.convE = ConvLayers(conv_type=conv_type, block_type="basic", num_blocks=num_blocks, + image_channels=image_channels, depth=self.depth, start_channels=start_channels, + reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, + output="none" if no_fnl else "normal", global_pooling=global_pooling, + gated=conv_gated) + # -flatten image to 2D-tensor + self.flatten = modules.Flatten() + #------------------------------calculate input/output-sizes--------------------------------# + self.conv_out_units = self.convE.out_units(image_size) + self.conv_out_size = self.convE.out_size(image_size) + self.conv_out_channels = self.convE.out_channels + #------------------------------------------------------------------------------------------# + # -fully connected hidden layers + self.fcE = MLP(input_size=self.conv_out_units, output_size=fc_units, layers=fc_layers-1, + hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, gated=fc_gated, + excit_buffer=excit_buffer) + mlp_output_size = fc_units if fc_layers > 1 else self.conv_out_units + # -to z + self.toZ = fc_layer_split(mlp_output_size, z_dim, nl_mean='none', nl_logvar='none') + + ##>----Classifier----<## + if classifier: + self.classifier = fc_layer(mlp_output_size, classes, excit_buffer=True, nl='none') + + ##>----Decoder (= p[x|z])----<## + out_nl = True if fc_layers > 1 else (True if (self.depth > 0 and not no_fnl) else False) + real_h_dim_down = fc_units if fc_layers > 1 else self.convE.out_units(image_size, ignore_gp=True) + if self.dg_gates: + self.fromZ = fc_layer_fixed_gates( + z_dim, real_h_dim_down, batch_norm=(out_nl and fc_bn), nl=fc_nl if out_nl else "none", + gate_size=self.gate_size, gating_prop=dg_prop, device=device + ) + else: + self.fromZ = fc_layer(z_dim, real_h_dim_down, batch_norm=(out_nl and fc_bn), nl=fc_nl if out_nl else "none") + # -> if 'gp' is used in forward pass, size of first/final hidden layer differs between forward and backward pass + if self.dg_gates: + self.fcD = MLP_gates(input_size=fc_units, output_size=self.convE.out_units(image_size, ignore_gp=True), + layers=fc_layers-1, hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, + gate_size=self.gate_size, gating_prop=dg_prop, device=device, + output=self.network_output if self.depth==0 else 'normal') + else: + self.fcD = MLP(input_size=fc_units, output_size=self.convE.out_units(image_size, ignore_gp=True), + layers=fc_layers-1, hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, + gated=fc_gated, output=self.network_output if self.depth==0 else 'normal') + # to image-shape + self.to_image = modules.Reshape(image_channels=self.convE.out_channels if self.depth>0 else image_channels) + # through deconv-layers + self.convD = DeconvLayers( + image_channels=image_channels, final_channels=start_channels, depth=self.depth, + reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, gated=conv_gated, + output=self.network_output, deconv_type=deconv_type, + ) + + ##>----Prior----<## + # -if using the GMM-prior, add its parameters + if self.prior=="GMM": + # -create + self.z_class_means = nn.Parameter(torch.Tensor(self.n_modes, self.z_dim)) + self.z_class_logvars = nn.Parameter(torch.Tensor(self.n_modes, self.z_dim)) + # -initialize + self.z_class_means.data.normal_() + self.z_class_logvars.data.normal_() + + # Flags whether parts of the network are frozen (so they can be set to evaluation mode during training) + self.convE.frozen = False + self.fcE.frozen = False + + + + ##------ NAMES --------## + + def get_name(self): + convE_label = "{}--".format(self.convE.name) if self.depth>0 else "" + fcE_label = "{}--".format(self.fcE.name) if self.fc_layers>1 else "{}{}-".format("h" if self.depth>0 else "i", + self.conv_out_units) + z_label = "z{}{}".format(self.z_dim, "" if self.prior=="standard" else "-{}{}{}".format( + self.prior, self.n_modes, "pc" if self.per_class else "" + )) + class_label = "-c{}".format(self.classes) if hasattr(self, "classifier") else "" + decoder_label = "_{}{}".format("tg" if self.dg_type=="context" else "cg", self.dg_prop) if self.dg_gates else "" + return "{}={}{}{}{}{}".format(self.label, convE_label, fcE_label, z_label, class_label, decoder_label) + + @property + def name(self): + return self.get_name() + + + + ##------ LAYERS --------## + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.convE.list_init_layers() + list += self.fcE.list_init_layers() + if hasattr(self, "classifier"): + list += self.classifier.list_init_layers() + list += self.toZ.list_init_layers() + list += self.fromZ.list_init_layers() + list += self.fcD.list_init_layers() + list += self.convD.list_init_layers() + return list + + def layer_info(self): + '''Return list with shape of all hidden layers.''' + # create list with hidden convolutional layers + layer_list = self.convE.layer_info(image_size=self.image_size) + # add output of final convolutional layer (if there was at least one conv-layer and there's fc-layers after) + if (self.fc_layers>0 and self.depth>0): + layer_list.append([self.conv_out_channels, self.conv_out_size, self.conv_out_size]) + # add layers of the MLP + if self.fc_layers>1: + for layer_id in range(1, self.fc_layers): + layer_list.append([self.fc_layer_sizes[layer_id]]) + return layer_list + + + + ##------ FORWARD FUNCTIONS --------## + + def encode(self, x): + '''Pass input through feed-forward connections, to get [z_mean], [z_logvar] and [hE].''' + # Forward-pass through conv-layers + hidden_x = self.convE(x) + image_features = self.flatten(hidden_x) + # Forward-pass through fc-layers + hE = self.fcE(image_features) + # Get parameters for reparametrization + (z_mean, z_logvar) = self.toZ(hE) + return z_mean, z_logvar, hE, hidden_x + + def classify(self, x, allowed_classes=None, **kwargs): + '''For input [x] (image/"intermediate" features), return predicted "scores"/"logits" for [allowed_classes].''' + if hasattr(self, "classifier"): + image_features = self.flatten(self.convE(x)) + hE = self.fcE(image_features) + scores = self.classifier(hE) + return scores if (allowed_classes is None) else scores[:, allowed_classes] + else: + return None + + def reparameterize(self, mu, logvar): + '''Perform "reparametrization trick" to make these stochastic variables differentiable.''' + std = logvar.mul(0.5).exp_() + eps = std.new(std.size()).normal_()#.requires_grad_() + return eps.mul(std).add_(mu) + + def decode(self, z, gate_input=None): + '''Decode latent variable activations. + + INPUT: - [z] <2D-tensor>; latent variables to be decoded + - [gate_input] <1D-tensor> or ; for each batch-element in [x] its class-/context-ID --OR-- + <2D-tensor>; for each batch-element in [x] a probability for every class-/context-ID + + OUTPUT: - [image_recon] <4D-tensor>''' + + # -if needed, convert [gate_input] to one-hot vector + if self.dg_gates and (gate_input is not None) and (type(gate_input)==np.ndarray or gate_input.dim()<2): + gate_input = lf.to_one_hot(gate_input, classes=self.gate_size, device=self._device()) + + # -put inputs through decoder + hD = self.fromZ(z, gate_input=gate_input) if self.dg_gates else self.fromZ(z) + image_features = self.fcD(hD, gate_input=gate_input) if self.dg_gates else self.fcD(hD) + image_recon = self.convD(self.to_image(image_features)) + return image_recon + + def forward(self, x, gate_input=None, full=False, reparameterize=True, **kwargs): + '''Forward function to propagate [x] through the encoder, reparametrization and decoder. + + Input: - [x] <4D-tensor> of shape [batch_size]x[channels]x[image_size]x[image_size] + - [gate_input] <1D-tensor> or ; for each batch-element in [x] its class-ID (eg, [y]) ---OR--- + <2D-tensor>; for each batch-element in [x] a probability for each class-ID (eg, [y_hat]) + + If [full] is True, output should be a consisting of: + - [x_recon] <4D-tensor> reconstructed image (features) in same shape as [x] (or 2 of those: mean & logvar) + - [y_hat] <2D-tensor> with predicted logits for each class + - [mu] <2D-tensor> with either [z] or the estimated mean of [z] + - [logvar] None or <2D-tensor> estimated log(SD^2) of [z] + - [z] <2D-tensor> reparameterized [z] used for reconstruction + If [full] is False, output is the reconstructed image (i.e., [x_recon]). + ''' + # -encode (forward), reparameterize and decode (backward) + mu, logvar, hE, hidden_x = self.encode(x) + z = self.reparameterize(mu, logvar) if reparameterize else mu + gate_input = gate_input if self.dg_gates else None + x_recon = self.decode(z, gate_input=gate_input) + # -classify + y_hat = self.classifier(hE) if hasattr(self, "classifier") else None + # -return + return (x_recon, y_hat, mu, logvar, z) if full else x_recon + + def feature_extractor(self, images): + '''Extract "final features" (i.e., after both conv- and fc-layers of forward pass) from provided images.''' + return self.fcE(self.flatten(self.convE(images))) + + + + ##------ SAMPLE FUNCTIONS --------## + + def sample(self, size, allowed_classes=None, class_probs=None, sample_mode=None, allowed_domains=None, + only_x=True, **kwargs): + '''Generate [size] samples from the model. Outputs are tensors (not "requiring grad"), on same device as . + + INPUT: - [allowed_classes] of [class_ids] from which to sample + - [class_probs] with for each class the probability it is sampled from it + - [sample_mode] to sample from specific mode of [z]-distr'n, overwrites [allowed_classes] + - [allowed_domains] of [context_ids] which are allowed to be used for 'context-gates' (if used) + NOTE: currently only relevant if [scenario]=="domain" + + OUTPUT: - [X] <4D-tensor> generated images / image-features + - [y_used] labels of classes intended to be sampled (using ) + - [context_used] labels of domains/contexts used for context-gates in decoder''' + + # set model to eval()-mode + self.eval() + + # pick for each sample the prior-mode to be used + if self.prior=="GMM": + if sample_mode is None: + if (allowed_classes is None and class_probs is None) or (not self.per_class): + # -randomly sample modes from all possible modes (and find their corresponding class, if applicable) + sampled_modes = np.random.randint(0, self.n_modes, size) + y_used = np.array( + [int(mode / self.modes_per_class) for mode in sampled_modes] + ) if self.per_class else None + else: + if allowed_classes is None: + allowed_classes = [i for i in range(len(class_probs))] + # -sample from modes belonging to [allowed_classes], possibly weighted according to [class_probs] + allowed_modes = [] # -collect all allowed modes + unweighted_probs = [] # -collect unweighted sample-probabilities of those modes + for index, class_id in enumerate(allowed_classes): + allowed_modes += list(range(class_id * self.modes_per_class, (class_id+1)*self.modes_per_class)) + if class_probs is not None: + for i in range(self.modes_per_class): + unweighted_probs.append(class_probs[index].item()) + mode_probs = None if class_probs is None else [p / sum(unweighted_probs) for p in unweighted_probs] + sampled_modes = np.random.choice(allowed_modes, size, p=mode_probs, replace=True) + y_used = np.array([int(mode / self.modes_per_class) for mode in sampled_modes]) + else: + # -always sample from the provided mode + sampled_modes = np.repeat(sample_mode, size) + y_used = np.repeat(int(sample_mode / self.modes_per_class), size) if self.per_class else None + else: + y_used = None + + # sample z + if self.prior=="GMM": + prior_means = self.z_class_means + prior_logvars = self.z_class_logvars + # -for each sample to be generated, select the previously sampled mode + z_means = prior_means[sampled_modes, :] + z_logvars = prior_logvars[sampled_modes, :] + with torch.no_grad(): + z = self.reparameterize(z_means, z_logvars) + else: + z = torch.randn(size, self.z_dim).to(self._device()) + + # if no classes are selected yet, but they are needed for the "decoder-gates", select classes to be sampled + if (y_used is None) and (self.dg_gates): + if allowed_classes is None and class_probs is None: + y_used = np.random.randint(0, self.classes, size) + else: + if allowed_classes is None: + allowed_classes = [i for i in range(len(class_probs))] + y_used = np.random.choice(allowed_classes, size, p=class_probs, replace=True) + # if gates in the decoder are "context-gates", convert [y_used] to corresponding contexts (if Task-/Class-IL) + # or simply sample which contexts should be generated (if Domain-IL) from [allowed_domains] + context_used = None + if self.dg_gates and self.dg_type=="context": + if self.scenario=="domain": + context_used = np.random.randint(0,self.gate_size,size) if ( + allowed_domains is None + ) else np.random.choice(allowed_domains, size, replace=True) + else: + classes_per_context = int(self.classes/self.gate_size) + context_used = np.array([int(class_id / classes_per_context) for class_id in y_used]) + + # decode z into image X + with torch.no_grad(): + X = self.decode(z, + gate_input=(context_used if self.dg_type=="context" else y_used) if self.dg_gates else None) + + # return samples as [batch_size]x[channels]x[image_size]x[image_size] tensor, plus requested additional info + return X if only_x else (X, y_used, context_used) + + + + ##------ LOSS FUNCTIONS --------## + + def calculate_recon_loss(self, x, x_recon, average=False): + '''Calculate reconstruction loss for each element in the batch. + + INPUT: - [x] with original input (1st dimension (ie, dim=0) is "batch-dimension") + - [x_recon] (tuple of 2x) with reconstructed input in same shape as [x] + - [average] , if True, loss is average over all pixels; otherwise it is summed + + OUTPUT: - [reconL] <1D-tensor> of length [batch_size]''' + + batch_size = x.size(0) + if self.recon_loss=="MSE": + # reconL = F.mse_loss(input=x_recon.view(batch_size, -1), target=x.view(batch_size, -1), reduction='none') + # reconL = torch.mean(reconL, dim=1) if average else torch.sum(reconL, dim=1) + reconL = -lf.log_Normal_standard(x=x, mean=x_recon, average=average, dim=-1) + elif self.recon_loss=="BCE": + reconL = F.binary_cross_entropy(input=x_recon.view(batch_size, -1), target=x.view(batch_size, -1), + reduction='none') + reconL = torch.mean(reconL, dim=1) if average else torch.sum(reconL, dim=1) + else: + raise NotImplementedError("Wrong choice for type of reconstruction-loss!") + # --> if [average]=True, reconstruction loss is averaged over all pixels/elements (otherwise it is summed) + # (averaging over all elements in the batch will be done later) + return reconL + + + def calculate_log_p_z(self, z, y=None, y_prob=None, allowed_classes=None): + '''Calculate log-likelihood of sampled [z] under the prior distirbution. + + INPUT: - [z] <2D-tensor> with sampled latent variables (1st dimension (ie, dim=0) is "batch-dimension") + + OPTIONS THAT ARE RELEVANT ONLY IF self.per_class IS TRUE: + - [y] None or <1D-tensor> with target-classes (as integers) + - [y_prob] None or <2D-tensor> with probabilities for each class (in [allowed_classes]) + - [allowed_classes] None or with class-IDs to use for selecting prior-mode(s) + + OUTPUT: - [log_p_z] <1D-tensor> of length [batch_size]''' + + if self.prior == "standard": + log_p_z = lf.log_Normal_standard(z, average=False, dim=1) # [batch_size] + + if self.prior == "GMM": + ## Get [means] and [logvars] of all (possible) modes + allowed_modes = list(range(self.n_modes)) + # -if we don't use the specific modes of a target, we could select modes based on list of classes + if (y is None) and (allowed_classes is not None) and self.per_class: + allowed_modes = [] + for class_id in allowed_classes: + allowed_modes += list(range(class_id * self.modes_per_class, (class_id + 1) * self.modes_per_class)) + # -calculate/retireve the means and logvars for the selected modes + prior_means = self.z_class_means[allowed_modes, :] + prior_logvars = self.z_class_logvars[allowed_modes, :] + # -rearrange / select for each batch prior-modes to be used + z_expand = z.unsqueeze(1) # [batch_size] x 1 x [z_dim] + means = prior_means.unsqueeze(0) # 1 x [n_modes] x [z_dim] + logvars = prior_logvars.unsqueeze(0) # 1 x [n_modes] x [z_dim] + + ## Calculate "log_p_z" (log-likelihood of "reparameterized" [z] based on selected priors) + n_modes = self.modes_per_class if ( + ((y is not None) or (y_prob is not None)) and self.per_class + ) else len(allowed_modes) + a = lf.log_Normal_diag(z_expand, mean=means, log_var=logvars, average=False, dim=2) - math.log(n_modes) + # --> for each element in batch, calculate log-likelihood for all pseudoinputs: [batch_size] x [n_modes] + if (y is not None) and self.per_class: + modes_list = list() + for i in range(len(y)): + target = y[i].item() + modes_list.append(list(range(target * self.modes_per_class, (target + 1) * self.modes_per_class))) + modes_tensor = torch.LongTensor(modes_list).to(self._device()) + a = a.gather(dim=1, index=modes_tensor) + # --> reduce [a] to size [batch_size]x[modes_per_class] (ie, per batch only keep modes of [y]) + # but within the batch, elements can have different [y], so this reduction couldn't be done before + a_max, _ = torch.max(a, dim=1) # [batch_size] + # --> for each element in batch, take highest log-likelihood over all pseudoinputs + # this is calculated and used to avoid underflow in the below computation + a_exp = torch.exp(a - a_max.unsqueeze(1)) # [batch_size] x [n_modes] + if (y is None) and (y_prob is not None) and self.per_class: + batch_size = y_prob.size(0) + y_prob = y_prob.view(-1, 1).repeat(1, self.modes_per_class).view(batch_size, -1) + # ----> extend probabilities per class to probabilities per mode; y_prob: [batch_size] x [n_modes] + a_logsum = torch.log(torch.clamp(torch.sum(y_prob * a_exp, dim=1), min=1e-40)) + else: + a_logsum = torch.log(torch.clamp(torch.sum(a_exp, dim=1), min=1e-40)) # -> sum over modes: [batch_size] + log_p_z = a_logsum + a_max # [batch_size] + + return log_p_z + + + def calculate_variat_loss(self, z, mu, logvar, y=None, y_prob=None, allowed_classes=None): + '''Calculate reconstruction loss for each element in the batch. + + INPUT: - [z] <2D-tensor> with sampled latent variables (1st dimension (ie, dim=0) is "batch-dimension") + - [mu] <2D-tensor> by encoder predicted mean for [z] + - [logvar] <2D-tensor> by encoder predicted logvar for [z] + + OPTIONS THAT ARE RELEVANT ONLY IF self.per_class IS TRUE: + - [y] None or <1D-tensor> with target-classes (as integers) + - [y_prob] None or <2D-tensor> with probabilities for each class (in [allowed_classes]) + - [allowed_classes] None or with class-IDs to use for selecting prior-mode(s) + + OUTPUT: - [variatL] <1D-tensor> of length [batch_size]''' + + if self.prior == "standard": + # --> calculate analytically + # ---- see Appendix B from: Kingma & Welling (2014) Auto-Encoding Variational Bayes, ICLR ----# + variatL = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1) + + elif self.prior=="GMM": + # --> calculate "by estimation" + + ## Calculate "log_p_z" (log-likelihood of "reparameterized" [z] based on selected priors) + log_p_z = self.calculate_log_p_z(z, y=y, y_prob=y_prob, allowed_classes=allowed_classes) + # -----> log_p_z: [batch_size] + + ## Calculate "log_q_z_x" (entropy of "reparameterized" [z] given [x]) + log_q_z_x = lf.log_Normal_diag(z, mean=mu, log_var=logvar, average=False, dim=1) + # -----> mu: [batch_size] x [z_dim]; logvar: [batch_size] x [z_dim]; z: [batch_size] x [z_dim] + # -----> log_q_z_x: [batch_size] + + ## Combine + variatL = -(log_p_z - log_q_z_x) + + return variatL + + + def loss_function(self, x, y, x_recon, y_hat, scores, mu, z, logvar=None, allowed_classes=None, batch_weights=None): + '''Calculate and return various losses that could be used for training and/or evaluating the model. + + INPUT: - [x] <4D-tensor> original image + - [y] <1D-tensor> with target-classes (as integers, corresponding to [allowed_classes]) + - [x_recon] (tuple of 2x) <4D-tensor> reconstructed image in same shape as [x] + - [y_hat] <2D-tensor> with predicted "logits" for each class (corresponding to [allowed_classes]) + - [scores] <2D-tensor> with target "logits" for each class (corresponding to [allowed_classes]) + (if len(scores) with either [z] or the estimated mean of [z] + - [z] <2D-tensor> with reparameterized [z] + - [logvar] None or <2D-tensor> with estimated log(SD^2) of [z] + - [batch_weights] <1D-tensor> with a weight for each batch-element (if None, normal average over batch) + - [allowed_classes]None or with class-IDs to use for selecting prior-mode(s) + + OUTPUT: - [reconL] reconstruction loss indicating how well [x] and [x_recon] match + - [variatL] variational (KL-divergence) loss "indicating how close distribion [z] is to prior" + - [predL] prediction loss indicating how well targets [y] are predicted + - [distilL] knowledge distillation (KD) loss indicating how well the predicted "logits" ([y_hat]) + match the target "logits" ([scores])''' + + ###-----Reconstruction loss-----### + batch_size = x.size(0) + reconL = self.calculate_recon_loss(x=x.view(batch_size, -1), average=True, + x_recon=x_recon.view(batch_size, -1)) # -> average over pixels + reconL = lf.weighted_average(reconL, weights=batch_weights, dim=0) # -> average over batch + + ###-----Variational loss-----### + if logvar is not None: + actual_y = torch.tensor([allowed_classes[i.item()] for i in y]).to(self._device()) if ( + (allowed_classes is not None) and (y is not None) + ) else y + if (y is None and scores is not None): + y_prob = F.softmax(scores / self.KD_temp, dim=1) + if allowed_classes is not None and len(allowed_classes) > y_prob.size(1): + n_batch = y_prob.size(0) + zeros_to_add = torch.zeros(n_batch, len(allowed_classes) - y_prob.size(1)) + zeros_to_add = zeros_to_add.to(self._device()) + y_prob = torch.cat([y_prob, zeros_to_add], dim=1) + else: + y_prob = None + # ---> if [y] is not provided but [scores] is, calculate variational loss using weighted sum of prior-modes + variatL = self.calculate_variat_loss(z=z, mu=mu, logvar=logvar, y=actual_y, y_prob=y_prob, + allowed_classes=allowed_classes) + variatL = lf.weighted_average(variatL, weights=batch_weights, dim=0) # -> average over batch + variatL /= (self.image_channels * self.image_size ** 2) # -> divide by # of input-pixels + else: + variatL = torch.tensor(0., device=self._device()) + + ###-----Prediction loss-----### + if y is not None and y_hat is not None: + predL = F.cross_entropy(input=y_hat, target=y, reduction='none') + #--> no reduction needed, summing over classes is "implicit" + predL = lf.weighted_average(predL, weights=batch_weights, dim=0) # -> average over batch + else: + predL = torch.tensor(0., device=self._device()) + + ###-----Distilliation loss-----### + if scores is not None and y_hat is not None: + # n_classes_to_consider = scores.size(1) #--> with this version, no zeroes would be added to [scores]! + n_classes_to_consider = y_hat.size(1) #--> zeros will be added to [scores] to make it this size! + distilL = lf.loss_fn_kd(scores=y_hat[:, :n_classes_to_consider], target_scores=scores, T=self.KD_temp, + weights=batch_weights) #--> summing over classes & averaging over batch in function + else: + distilL = torch.tensor(0., device=self._device()) + + # Return a tuple of the calculated losses + return reconL, variatL, predL, distilL + + + + ##------ TRAINING FUNCTIONS --------## + + def train_a_batch(self, x, y=None, x_=None, y_=None, scores_=None, contexts_=None, rnt=0.5, + active_classes=None, context=1, **kwargs): + '''Train model for one batch ([x],[y]), possibly supplemented with replayed data ([x_],[y_]). + + [x] batch of inputs (could be None, in which case only 'replayed' data is used) + [y] None or batch of corresponding labels + [x_] None or ( of) batch of replayed inputs + [y_] None or ( of) <1Dtensor>:[batch] of corresponding "replayed" labels + [scores_] None or ( of) <2Dtensor>:[batch]x[classes] target "scores"/"logits" for [x_] + [contexts_] None or ( of) <1Dtensor>/:[batch] of context-IDs of replayed samples (as ) + [rnt] in [0,1], relative importance of new context + [active_classes] None or ( of) with "active" classes + [context] , for setting context-specific mask''' + + # Set model to training-mode + self.train() + # -however, if some layers are frozen, they should be set to eval() to prevent batch-norm layers from changing + if self.convE.frozen: + self.convE.eval() + if self.fcE.frozen: + self.fcE.eval() + + # Reset optimizer + self.optimizer.zero_grad() + + + ##--(1)-- CURRENT DATA --## + accuracy = 0. + if x is not None: + # If using context-gates, create [context_tensor] as it's needed in the decoder + context_tensor = None + if self.dg_gates and self.dg_type=="context": + context_tensor = torch.tensor(np.repeat(context-1, x.size(0))).to(self._device()) + + # Run the model + recon_batch, y_hat, mu, logvar, z = self( + x, gate_input=(context_tensor if self.dg_type=="context" else y) if self.dg_gates else None, full=True, + reparameterize=True + ) + # --if needed, remove predictions for classes not active in the current context + if active_classes is not None: + class_entries = active_classes[-1] if type(active_classes[0])==list else active_classes + if y_hat is not None: + y_hat = y_hat[:, class_entries] + + # Calculate all losses + reconL, variatL, predL, _ = self.loss_function( + x=x, y=y, x_recon=recon_batch, y_hat=y_hat, scores=None, mu=mu, z=z, logvar=logvar, + allowed_classes=class_entries if active_classes is not None else None + ) #--> [allowed_classes] will be used only if [y] is not provided + + # Weigh losses as requested + loss_cur = self.lamda_rcl*reconL + self.lamda_vl*variatL + self.lamda_pl*predL + + # Calculate training-accuracy + if y is not None and y_hat is not None: + _, predicted = y_hat.max(1) + accuracy = (y == predicted).sum().item() / x.size(0) + + + ##--(2)-- REPLAYED DATA --## + if x_ is not None: + # If there are different predictions per context, [y_] or [scores_] are lists and [x_] must be evaluated + # separately on each of them (although [x_] could be a list as well!) + PerContext = (type(y_)==list) if (y_ is not None) else (type(scores_)==list) + if not PerContext: + y_ = [y_] + scores_ = [scores_] + active_classes = [active_classes] if (active_classes is not None) else None + n_replays = len(y_) if (y_ is not None) else len(scores_) + + # Prepare lists to store losses for each replay + loss_replay = [torch.tensor(0., device=self._device())]*n_replays + reconL_r = [torch.tensor(0., device=self._device())]*n_replays + variatL_r = [torch.tensor(0., device=self._device())]*n_replays + predL_r = [torch.tensor(0., device=self._device())]*n_replays + distilL_r = [torch.tensor(0., device=self._device())]*n_replays + + # Run model (if [x_] is not a list with separate replay per context and there is no context-specific mask) + if (not type(x_)==list) and (not (self.dg_gates and PerContext)): + # -if needed in the decoder-gates, find class-tensor [y_predicted] + y_predicted = None + if self.dg_gates and self.dg_type=="class": + if y_[0] is not None: + y_predicted = y_[0] + else: + y_predicted = F.softmax(scores_[0] / self.KD_temp, dim=1) + if y_predicted.size(1) < self.classes: + # in case of Class-IL, add zeros at the end: + n_batch = y_predicted.size(0) + zeros_to_add = torch.zeros(n_batch, self.classes - y_predicted.size(1)) + zeros_to_add = zeros_to_add.to(self._device()) + y_predicted = torch.cat([y_predicted, zeros_to_add], dim=1) + # -run full model + x_temp_ = x_ + gate_input = (contexts_ if self.dg_type=="context" else y_predicted) if self.dg_gates else None + recon_batch, y_hat_all, mu, logvar, z = self(x_temp_, gate_input=gate_input, full=True) + + # Loop to perform each replay + for replay_id in range(n_replays): + # -if [x_] is a list with separate replay per context, evaluate model on this context's replay + if (type(x_)==list) or (PerContext and self.dg_gates): + # -if needed in the decoder-gates, find class-tensor [y_predicted] + y_predicted = None + if self.dg_gates and self.dg_type == "class": + if y_ is not None and y_[replay_id] is not None: + y_predicted = y_[replay_id] + # because of Task-IL, increase class-ID with number of classes before context being replayed + y_predicted = y_predicted + replay_id*len(active_classes[0]) + else: + y_predicted = F.softmax(scores_[replay_id] / self.KD_temp, dim=1) + if y_predicted.size(1) < self.classes: + # in case of Task-IL, add zeros before and after: + n_batch = y_predicted.size(0) + zeros_to_add_before = torch.zeros(n_batch, replay_id*y_predicted.size(1)) + zeros_to_add_before = zeros_to_add_before.to(self._device()) + zeros_to_add_after = torch.zeros(n_batch,self.classes-(replay_id+1)*y_predicted.size(1)) + zeros_to_add_after = zeros_to_add_after.to(self._device()) + y_predicted = torch.cat([zeros_to_add_before, y_predicted, zeros_to_add_after], dim=1) + # -run full model + x_temp_ = x_[replay_id] if type(x_)==list else x_ + gate_input = ( + contexts_[replay_id] if self.dg_type=="context" else y_predicted + ) if self.dg_gates else None + recon_batch, y_hat_all, mu, logvar, z = self(x_temp_, full=True, gate_input=gate_input) + + # --if needed, remove predictions for classes not active in the replayed context + y_hat = y_hat_all if ( + active_classes is None or y_hat_all is None + ) else y_hat_all[:, active_classes[replay_id]] + + # Calculate all losses + reconL_r[replay_id],variatL_r[replay_id],predL_r[replay_id],distilL_r[replay_id] = self.loss_function( + x=x_temp_, y=y_[replay_id] if (y_ is not None) else None, x_recon=recon_batch, y_hat=y_hat, + scores=scores_[replay_id] if (scores_ is not None) else None, mu=mu, z=z, logvar=logvar, + allowed_classes=active_classes[replay_id] if active_classes is not None else None, + ) + + # Weigh losses as requested + loss_replay[replay_id] = self.lamda_rcl*reconL_r[replay_id] + self.lamda_vl*variatL_r[replay_id] + if self.replay_targets=="hard": + loss_replay[replay_id] += self.lamda_pl*predL_r[replay_id] + elif self.replay_targets=="soft": + loss_replay[replay_id] += self.lamda_pl*distilL_r[replay_id] + + + # Calculate total loss + loss_replay = None if (x_ is None) else sum(loss_replay)/n_replays + loss_total = loss_replay if (x is None) else (loss_cur if x_ is None else rnt*loss_cur+(1-rnt)*loss_replay) + + + ##--(3)-- PARAMETER REGULARIZATION LOSSES --## + + # Add a parameter regularization penalty to the loss function + weight_penalty_loss = None + if self.weight_penalty: + if self.importance_weighting=='si': + weight_penalty_loss = self.surrogate_loss() + elif self.importance_weighting=='fisher': + if self.fisher_kfac: + weight_penalty_loss = self.ewc_kfac_loss() + else: + weight_penalty_loss = self.ewc_loss() + loss_total += self.reg_strength * weight_penalty_loss + + + # Backpropagate errors + loss_total.backward() + # Take optimization-step + self.optimizer.step() + + + # Return the dictionary with different training-loss split in categories + return { + 'loss_total': loss_total.item(), 'accuracy': accuracy, + 'recon': reconL.item() if x is not None else 0, + 'variat': variatL.item() if x is not None else 0, + 'pred': predL.item() if x is not None else 0, + 'recon_r': sum(reconL_r).item()/n_replays if x_ is not None else 0, + 'variat_r': sum(variatL_r).item()/n_replays if x_ is not None else 0, + 'pred_r': sum(predL_r).item()/n_replays if (x_ is not None and predL_r[0] is not None) else 0, + 'distil_r': sum(distilL_r).item()/n_replays if (x_ is not None and distilL_r[0] is not None) else 0, + 'param_reg': weight_penalty_loss.item() if weight_penalty_loss is not None else 0, + } diff --git a/PyTorch/build-in/other/continual-learning/models/conv/__init__.py b/PyTorch/build-in/other/continual-learning/models/conv/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/models/conv/layers.py b/PyTorch/build-in/other/continual-learning/models/conv/layers.py new file mode 100644 index 000000000..266edb396 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/conv/layers.py @@ -0,0 +1,347 @@ +import torch.nn as nn +from models.utils import modules + + +#-----------------------------------------------------------------------------------------------------------# + +##################### +### ResNet-blocks ### +##################### + +class BasicBlock(nn.Module): + '''Standard building block for ResNets.''' + expansion = 1 + + def __init__(self, in_planes, planes, stride=1, batch_norm=True, nl="relu", no_fnl=False): + super(BasicBlock, self).__init__() + + # normal block-layers + self.block_layer1 = nn.Sequential( + nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False if batch_norm else True), + nn.BatchNorm2d(planes) if batch_norm else modules.Identity(), + nn.ReLU() if nl=="relu" else nn.LeakyReLU() + ) + self.block_layer2 = nn.Sequential( + nn.Conv2d(planes, self.expansion*planes, kernel_size=3, stride=1, padding=1, + bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else modules.Identity() + ) + + # shortcut block-layer + self.shortcut = modules.Identity() + if stride != 1 or in_planes != self.expansion*planes: + self.shortcut = nn.Sequential( + nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, + bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else modules.Identity() + ) + + # final non-linearity + self.nl = (nn.ReLU() if nl=="relu" else nn.LeakyReLU()) if not no_fnl else modules.Identity() + + def forward(self, x): + out = self.block_layer2(self.block_layer1(x)) + out += self.shortcut(x) + return self.nl(out) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [self.block_layer1[0], self.block_layer2[0]] + if not type(self.shortcut) == modules.Identity: + list.append(self.shortcut[0]) + return list + + +class Bottleneck(nn.Module): + '''Building block (with "bottleneck") for ResNets.''' + expansion = 4 + + def __init__(self, in_planes, planes, stride=1, batch_norm=True, nl="relu", no_fnl=False): + super(Bottleneck, self).__init__() + + # normal block-layers + self.block_layer1 = nn.Sequential( + nn.Conv2d(in_planes, planes, kernel_size=1, bias=False if batch_norm else True), + nn.BatchNorm2d(planes) if batch_norm else modules.Identity(), + nn.ReLU() if nl == "relu" else nn.LeakyReLU() + ) + self.block_layer2 = nn.Sequential( + nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False if batch_norm else True), + nn.BatchNorm2d(planes) if batch_norm else modules.Identity(), + nn.ReLU() if nl == "relu" else nn.LeakyReLU() + ) + self.block_layer3 = nn.Sequential( + nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else modules.Identity() + ) + + # shortcut block-layer + self.shortcut = modules.Identity() + if stride != 1 or in_planes != self.expansion*planes: + self.shortcut = nn.Sequential( + nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, + bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else True + ) + + # final non-linearity + self.nl = (nn.ReLU() if nl == "relu" else nn.LeakyReLU()) if not no_fnl else modules.Identity() + + def forward(self, x): + out = self.block_layer3(self.block_layer2(self.block_layer1(x))) + out += self.shortcut(x) + return self.nl(out) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [self.block_layer1[0], self.block_layer2[0], self.block_layer3[0]] + if not type(self.shortcut) == modules.Identity: + list.append(self.shortcut[0]) + return list + + +#-----------------------------------------------------------------------------------------------------------# + +################### +### Conv-layers ### +################### + +class conv_layer(nn.Module): + '''Standard convolutional layer. Possible to return pre-activations.''' + + def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, padding=1, + drop=0, batch_norm=False, nl=nn.ReLU(), bias=True, gated=False): + super().__init__() + if drop>0: + self.dropout = nn.Dropout2d(drop) + self.conv = nn.Conv2d(in_planes, out_planes, stride=stride, kernel_size=kernel_size, padding=padding, bias=bias) + if batch_norm: + self.bn = nn.BatchNorm2d(out_planes) + if gated: + self.gate = nn.Conv2d(in_planes, out_planes, stride=stride, kernel_size=kernel_size, padding=padding, + bias=False) + self.sigmoid = nn.Sigmoid() + if isinstance(nl, nn.Module): + self.nl = nl + elif not nl=="none": + self.nl = nn.ReLU() if nl=="relu" else (nn.LeakyReLU() if nl=="leakyrelu" else modules.Identity()) + + def forward(self, x, return_pa=False): + input = self.dropout(x) if hasattr(self, 'dropout') else x + pre_activ = self.bn(self.conv(input)) if hasattr(self, 'bn') else self.conv(input) + gate = self.sigmoid(self.gate(x)) if hasattr(self, 'gate') else None + gated_pre_activ = gate * pre_activ if hasattr(self, 'gate') else pre_activ + output = self.nl(gated_pre_activ) if hasattr(self, 'nl') else gated_pre_activ + return (output, gated_pre_activ) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + return [self.conv] + + +class res_layer(nn.Module): + '''Convolutional res-net layer. Possible to return pre-activations.''' + + def __init__(self, in_planes, out_planes, block=BasicBlock, num_blocks=2, stride=1, drop=0, batch_norm=True, + nl="relu", no_fnl=False): + + ## NOTE: should [no_fnl] be changed so that also no batch_norm is applied?? ## + + # Set configurations + super().__init__() + self.num_blocks = num_blocks + self.in_planes = in_planes + self.out_planes = out_planes * block.expansion + + # Create layer + self.dropout = nn.Dropout2d(drop) + for block_id in range(num_blocks): + # -first block has given stride, later blocks have stride 1 + new_block = block(in_planes, out_planes, stride=stride if block_id==0 else 1, batch_norm=batch_norm, nl=nl, + no_fnl=True if block_id==(num_blocks-1) else False) + setattr(self, "block{}".format(block_id+1), new_block) + in_planes = out_planes * block.expansion + # self.bn = nn.BatchNorm2d(out_planes * block.expansion) if batch_norm else utils.Identity() + self.nl = (nn.ReLU() if nl == "relu" else nn.LeakyReLU()) if not no_fnl else modules.Identity() + + def forward(self, x, return_pa=False): + x = self.dropout(x) + for block_id in range(self.num_blocks): + x = getattr(self, "block{}".format(block_id+1))(x) + output = self.nl(x) + return (output, x) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for block_id in range(self.num_blocks): + list += getattr(self, 'block{}'.format(block_id+1)).list_init_layers() + return list + + +#-----------------------------------------------------------------------------------------------------------# + +##################### +### Deconv-blocks ### +##################### + +class DeconvBlock(nn.Module): + '''Building block for deconv-layer with multiple blocks.''' + expansion = 1 + + def __init__(self, in_planes, planes, stride=1, batch_norm=True, nl="relu", no_fnl=False, smaller_kernel=False): + super(DeconvBlock, self).__init__() + + # normal block-layers + self.block_layer1 = nn.Sequential( + nn.ConvTranspose2d(in_planes, planes, stride=stride, bias=False if batch_norm else True, + kernel_size=(2 if smaller_kernel else 4) if stride==2 else 3, + padding=0 if (stride==2 and smaller_kernel) else 1), + nn.BatchNorm2d(planes) if batch_norm else modules.Identity(), + nn.ReLU() if nl=="relu" else nn.LeakyReLU() + ) + self.block_layer2 = nn.Sequential( + nn.ConvTranspose2d(planes, self.expansion*planes, kernel_size=3, stride=1, padding=1, + bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else modules.Identity() + ) + + # shortcut block-layer + self.shortcut = modules.Identity() + if stride != 1 or in_planes != self.expansion*planes: + self.shortcut = nn.Sequential( + nn.ConvTranspose2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, + output_padding=0 if stride==1 else 1, bias=False if batch_norm else True), + nn.BatchNorm2d(self.expansion*planes) if batch_norm else modules.Identity() + ) + + # final non-linearity + self.nl = (nn.ReLU() if nl=="relu" else nn.LeakyReLU()) if not no_fnl else modules.Identity() + + def forward(self, x): + out = self.block_layer2(self.block_layer1(x)) + out += self.shortcut(x) + return self.nl(out) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [self.block_layer1[0], self.block_layer2[0]] + if not type(self.shortcut) == modules.Identity: + list.append(self.shortcut[0]) + return list + + +#-----------------------------------------------------------------------------------------------------------# + +##################### +### Deconv-layers ### +##################### + +class deconv_layer(nn.Module): + '''Standard "deconvolutional" layer. Possible to return pre-activations.''' + + def __init__(self, input_channels, output_channels, stride=1, drop=0, batch_norm=True, nl="relu", bias=True, + gated=False, smaller_kernel=False): + super().__init__() + if drop>0: + self.dropout = nn.Dropout2d(drop) + self.deconv = nn.ConvTranspose2d(input_channels, output_channels, bias=bias, stride=stride, + kernel_size=(2 if smaller_kernel else 4) if stride==2 else 3, + padding=0 if (stride==2 and smaller_kernel) else 1) + if batch_norm: + self.bn = nn.BatchNorm2d(output_channels) + if gated: + self.gate = nn.ConvTranspose2d(input_channels, output_channels, bias=False, stride=stride, + kernel_size=(2 if smaller_kernel else 4) if stride==2 else 3, + padding=0 if (stride==2 and smaller_kernel) else 1) + self.sigmoid = nn.Sigmoid() + if isinstance(nl, nn.Module): + self.nl = nl + elif nl in ("sigmoid", "hardtanh"): + self.nl = nn.Sigmoid() if nl=="sigmoid" else nn.Hardtanh(min_val=-4.5, max_val=0) + elif not nl=="none": + self.nl = nn.ReLU() if nl == "relu" else (nn.LeakyReLU() if nl == "leakyrelu" else modules.Identity()) + + def forward(self, x, return_pa=False): + input = self.dropout(x) if hasattr(self, 'dropout') else x + pre_activ = self.bn(self.deconv(input)) if hasattr(self, 'bn') else self.deconv(input) + gate = self.sigmoid(self.gate(x)) if hasattr(self, 'gate') else None + gated_pre_activ = gate * pre_activ if hasattr(self, 'gate') else pre_activ + output = self.nl(gated_pre_activ) if hasattr(self, 'nl') else gated_pre_activ + return (output, gated_pre_activ) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + return [self.deconv] + + +class deconv_layer_split(nn.Module): + '''"Deconvolutional" layer outputing [mean] and [logvar] for each unit.''' + + def __init__(self, input_channels, output_channels, nl_mean="sigmoid", nl_logvar="hardtanh", + stride=1, drop=0, batch_norm=True, bias=True, gated=False, smaller_kernel=False): + super().__init__() + self.mean = deconv_layer(input_channels, output_channels, nl=nl_mean, smaller_kernel=smaller_kernel, + stride=stride, drop=drop, batch_norm=batch_norm, bias=bias, gated=gated) + self.logvar = deconv_layer(input_channels, output_channels, nl=nl_logvar, smaller_kernel=smaller_kernel, + stride=stride, drop=drop, batch_norm=batch_norm, bias=False, gated=gated) + + def forward(self, x, return_pa=False): + mean, pre_activ = self.mean(x, return_pa=True) + logvar = self.logvar(x) + return ((mean, logvar), pre_activ) if return_pa else (mean, logvar) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.mean.list_init_layers() + list += self.logvar.list_init_layers() + return list + + +class deconv_res_layer(nn.Module): + '''Deconvolutional res-net layer. Possible to return pre-activations.''' + + def __init__(self, in_planes, out_planes, block=DeconvBlock, num_blocks=2, stride=1, drop=0, batch_norm=True, + nl="relu", smaller_kernel=False, output="normal"): + + ## NOTE: should [output=="none"] be changed so that also no batch_norm is applied?? ## + + # Set configurations + super().__init__() + self.num_blocks = num_blocks + self.in_planes = in_planes + self.out_planes = out_planes * block.expansion + + # Create layer + self.dropout = nn.Dropout2d(drop) + for block_id in range(num_blocks): + # -first block has given stride, later blocks have stride 1 + new_block = block(in_planes, out_planes, stride=stride if block_id==0 else 1, batch_norm=batch_norm, nl=nl, + no_fnl=True if block_id==(num_blocks-1) else False, smaller_kernel=smaller_kernel) + setattr(self, "block{}".format(block_id+1), new_block) + in_planes = out_planes * block.expansion + # self.bn = nn.BatchNorm2d(out_planes * block.expansion) if batch_norm else utils.Identity() + if output=="sigmoid": + self.nl = nn.Sigmoid() + elif output=="normal": + self.nl = nn.ReLU() if nl=="relu" else nn.LeakyReLU() + elif output=="none": + self.nl = modules.Identity() + else: + raise NotImplementedError("Ouptut '{}' not implemented for deconvolutional ResNet layer.".format(output)) + + def forward(self, x, return_pa=False): + x = self.dropout(x) + for block_id in range(self.num_blocks): + x = getattr(self, "block{}".format(block_id+1))(x) + output = self.nl(x) + return (output, x) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for block_id in range(self.num_blocks): + list += getattr(self, 'block{}'.format(block_id+1)).list_init_layers() + return list + diff --git a/PyTorch/build-in/other/continual-learning/models/conv/nets.py b/PyTorch/build-in/other/continual-learning/models/conv/nets.py new file mode 100644 index 000000000..93a6f65da --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/conv/nets.py @@ -0,0 +1,252 @@ +from torch import nn +import numpy as np +import models.conv.layers as conv_layers +from models.utils import modules + + +class ConvLayers(nn.Module): + '''Convolutional feature extractor model for (natural) images. Possible to return (pre)activations of each layer. + Also possible to supply a [skip_first]- or [skip_last]-argument to the forward-function to only pass certain layers. + + Input: [batch_size] x [image_channels] x [image_size] x [image_size] tensor + Output: [batch_size] x [out_channels] x [out_size] x [out_size] tensor + - with [out_channels] = [start_channels] x 2**[reducing_layers] x [block.expansion] + [out_size] = [image_size] / 2**[reducing_layers]''' + + def __init__(self, conv_type="standard", block_type="basic", num_blocks=2, + image_channels=3, depth=5, start_channels=16, reducing_layers=None, batch_norm=True, nl="relu", + output="normal", global_pooling=False, gated=False): + '''Initialize stacked convolutional layers (either "standard" or "res-net" ones--1st layer is always standard). + + [conv_type] type of conv-layers to be used: [standard|resnet] + [block_type] block-type to be used: [basic|bottleneck] (only relevant if [type]=resNet) + [num_blocks] or (with len=[depth]-1) of # blocks in each layer + [image_channels] # channels of input image to encode + [depth] # layers + [start_channels] # channels in 1st layer, doubled in every "rl" (=reducing layer) + [reducing_layers] # layers in which image-size is halved & # channels doubled (default=[depth]-1) + ("rl"'s are the last conv-layers; in 1st layer # channels cannot double) + [batch_norm] whether to use batch-norm after each convolution-operation + [nl] non-linearity to be used: [relu|leakyrelu] + [output] if - "normal", final layer is same as all others + - "none", final layer has no batchnorm or non-linearity + [global_pooling] whether to include global average pooling layer at very end + [gated] whether conv-layers should be gated (not implemented for ResNet-layers)''' + + # Process type and number of blocks + conv_type = "standard" if depth<2 else conv_type + if conv_type=="resNet": + num_blocks = [num_blocks]*(depth-1) if type(num_blocks)==int else num_blocks + assert len(num_blocks)==(depth-1) + block = conv_layers.Bottleneck if block_type == "bottleneck" else conv_layers.BasicBlock + + # Prepare label + type_label = "C" if conv_type=="standard" else "R{}".format("b" if block_type=="bottleneck" else "") + channel_label = "{}-{}x{}".format(image_channels, depth, start_channels) + block_label = "" + if conv_type=="resNet" and depth>1: + block_label += "-" + for block_num in num_blocks: + block_label += "b{}".format(block_num) + nd_label = "{bn}{nl}{gp}{gate}{out}".format(bn="b" if batch_norm else "", nl="l" if nl=="leakyrelu" else "", + gp="p" if global_pooling else "", gate="g" if gated else "", + out="n" if output=="none" else "") + nd_label = "" if nd_label=="" else "-{}".format(nd_label) + + # Set configurations + super().__init__() + self.depth = depth + self.rl = depth-1 if (reducing_layers is None) else (reducing_layers if (depth+1)>reducing_layers else depth) + rl_label = "" if self.rl==(self.depth-1) else "-rl{}".format(self.rl) + self.label = "{}{}{}{}{}".format(type_label, channel_label, block_label, rl_label, nd_label) + self.block_expansion = block.expansion if conv_type=="resNet" else 1 + # -> constant by which # of output channels of each block is multiplied (if >1, it creates "bottleneck"-effect) + double_factor = self.rl if self.rl how often # start-channels is doubled + self.out_channels = (start_channels * 2**double_factor) * self.block_expansion if depth>0 else image_channels + # -> number channels in last layer (as seen from image) + self.start_channels = start_channels # -> number channels in 1st layer (doubled in every "reducing layer") + self.global_pooling = global_pooling # -> whether or not average global pooling layer should be added at end + + # Conv-layers + output_channels = start_channels + for layer_id in range(1, depth+1): + # should this layer down-sample? --> last [self.rl] layers should be down-sample layers + reducing = True if (layer_id > (depth-self.rl)) else False + # calculate number of this layer's input and output channels + input_channels = image_channels if layer_id==1 else output_channels * self.block_expansion + output_channels = output_channels*2 if (reducing and not layer_id==1) else output_channels + # define and set the convolutional-layer + if conv_type=="standard" or layer_id==1: + conv_layer = conv_layers.conv_layer(input_channels, output_channels, stride=2 if reducing else 1, + drop=0, nl="no" if output=="none" and layer_id==depth else nl, + batch_norm=False if output=="none" and layer_id==depth else batch_norm, + gated= False if output=="none" and layer_id==depth else gated) + else: + conv_layer = conv_layers.res_layer(input_channels, output_channels, block=block, + num_blocks=num_blocks[layer_id-2], stride=2 if reducing else 1, + drop=0, batch_norm=batch_norm, nl=nl, + no_fnl=True if output=="none" and layer_id==depth else False) + setattr(self, 'convLayer{}'.format(layer_id), conv_layer) + # Perform pooling (if requested) + self.pooling = nn.AdaptiveAvgPool2d((1,1)) if global_pooling else modules.Identity() + + def forward(self, x, skip_first=0, skip_last=0, return_lists=False): + # Initiate for keeping track of intermediate hidden (pre-)activations + if return_lists: + hidden_act_list = [] + pre_act_list = [] + # Sequentially pass [x] through all conv-layers + for layer_id in range(skip_first+1, self.depth+1-skip_last): + (x, pre_act) = getattr(self, 'convLayer{}'.format(layer_id))(x, return_pa=True) + if return_lists: + pre_act_list.append(pre_act) #-> for each layer, store pre-activations + if layer_id<(self.depth-skip_last): + hidden_act_list.append(x) #-> for all but last layer, store hidden activations + # Global average pooling (if requested) + x = self.pooling(x) + # Return final [x], if requested along with [hidden_act_list] and [pre_act_list] + return (x, hidden_act_list, pre_act_list) if return_lists else x + + def out_size(self, image_size, ignore_gp=False): + '''Given [image_size] of input, return the size of the "final" image that is outputted.''' + out_size = int(np.ceil(image_size / 2**(self.rl))) if self.depth>0 else image_size + return 1 if (self.global_pooling and not ignore_gp) else out_size + + def out_units(self, image_size, ignore_gp=False): + '''Given [image_size] of input, return the total number of units in the output.''' + return self.out_channels * self.out_size(image_size, ignore_gp=ignore_gp)**2 + + def layer_info(self, image_size): + '''Return list with shape of all hidden layers.''' + layer_list = [] + reduce_number = 0 # keep track how often image-size has been halved + double_number = 0 # keep track how often channel number has been doubled + for layer_id in range(1, self.depth): + reducing = True if (layer_id > (self.depth-self.rl)) else False + if reducing: + reduce_number += 1 + if reducing and layer_id>1: + double_number += 1 + pooling = True if self.global_pooling and layer_id==(self.depth-1) else False + expansion = 1 if layer_id==1 else self.block_expansion + # add shape of this layer to list + layer_list.append([(self.start_channels * 2**double_number) * expansion, + 1 if pooling else int(np.ceil(image_size / 2**reduce_number)), + 1 if pooling else int(np.ceil(image_size / 2**reduce_number))]) + return layer_list + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for layer_id in range(1, self.depth+1): + list += getattr(self, 'convLayer{}'.format(layer_id)).list_init_layers() + return list + + @property + def name(self): + return self.label + + + + +class DeconvLayers(nn.Module): + '''"Deconvolutional" feature decoder model for (natural) images. Possible to return (pre)activations of each layer. + Also possible to supply a [skip_first]- or [skip_last]-argument to the forward-function to only pass certain layers. + + Input: [batch_size] x [in_channels] x [in_size] x [in_size] tensor + Output: (tuple of) [batch_size] x [image_channels] x [final_size] x [final_size] tensor + - with [final_size] = [in_size] x 2**[reducing_layers] + [in_channels] = [final_channels] x 2**min([reducing_layers], [depth]-1)''' + + def __init__(self, image_channels=3, final_channels=16, depth=5, reducing_layers=None, batch_norm=True, nl="relu", + gated=False, output="normal", smaller_kernel=False, deconv_type="standard"): + '''[image_channels] # channels of image to decode + [final_channels] # channels in layer before output, was halved in every "rl" (=reducing layer) when moving + through model; corresponds to [start_channels] in "ConvLayers"-module + [depth] # layers (seen from the image, # channels is halved in each layer going to output image) + [reducing_layers] # of layers in which image-size is doubled & number of channels halved (default=[depth]-1) + ("rl"'s are the first conv-layers encountered--i.e., last conv-layers as seen from image) + (note that in the last layer # channels cannot be halved) + [batch_norm] whether to use batch-norm after each convolution-operation + [nl] what non-linearity to use -- choices: [relu, leakyrelu, sigmoid, none] + [gated] whether deconv-layers should be gated + [output] ; if - "normal", final layer is same as all others + - "none", final layer has no non-linearity + - "sigmoid", final layer has sigmoid non-linearity + [smaller_kernel] if True, use kernel-size of 2 (instead of 4) & without padding in reducing-layers''' + + # configurations + super().__init__() + self.depth = depth if depth>0 else 0 + self.rl = self.depth-1 if (reducing_layers is None) else min(self.depth, reducing_layers) + type_label = "Deconv" if deconv_type=="standard" else "DeResNet" + nd_label = "{bn}{nl}{gate}{out}".format(bn="-bn" if batch_norm else "", nl="-lr" if nl=="leakyrelu" else "", + gate="-gated" if gated else "", + out="" if output=="normal" else "-{}".format(output)) + self.label = "{}-ic{}-{}x{}-rl{}{}{}".format(type_label, image_channels, self.depth, final_channels, self.rl, + "s" if smaller_kernel else "", nd_label) + if self.depth>0: + self.in_channels = final_channels * 2**min(self.rl, self.depth-1) # -> input-channels for deconv + self.final_channels = final_channels # -> channels in layer before output + self.image_channels = image_channels # -> output-channels for deconv + + # "Deconv"- / "transposed conv"-layers + if self.depth>0: + output_channels = self.in_channels + for layer_id in range(1, self.depth+1): + # should this layer down-sample? --> first [self.rl] layers should be down-sample layers + reducing = True if (layer_id<(self.rl+1)) else False + # update number of this layer's input and output channels + input_channels = output_channels + output_channels = int(output_channels/2) if reducing else output_channels + # define and set the "deconvolutional"-layer + if deconv_type=="standard": + new_layer = conv_layers.deconv_layer( + input_channels, output_channels if layer_id for keeping track of intermediate hidden (pre-)activations + if return_lists: + hidden_act_list = [] + pre_act_list = [] + # Sequentially pass [x] through all "deconv"-layers + if self.depth>0: + for layer_id in range(skip_first+1, self.depth+1-skip_last): + (x, pre_act) = getattr(self, 'deconvLayer{}'.format(layer_id))(x, return_pa=True) + if return_lists: + pre_act_list.append(pre_act) #-> for each layer, store pre-activations + if layer_id<(self.depth-skip_last): + hidden_act_list.append(x) #-> for all but last layer, store hidden activations + # Return final [x], if requested along with [hidden_act_list] and [pre_act_list] + return (x, hidden_act_list, pre_act_list) if return_lists else x + + def image_size(self, in_units): + '''Given the number of units fed in, return the size of the target image.''' + if self.depth>0: + input_image_size = np.sqrt(in_units/self.in_channels) #-> size of image fed to last layer (seen from image) + return input_image_size * 2**self.rl + else: + return np.sqrt(in_units/self.image_channels) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for layer_id in range(1, self.depth+1): + list += getattr(self, 'deconvLayer{}'.format(layer_id)).list_init_layers() + return list + + @property + def name(self): + return self.label diff --git a/PyTorch/build-in/other/continual-learning/models/define_models.py b/PyTorch/build-in/other/continual-learning/models/define_models.py new file mode 100644 index 000000000..fbec558c5 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/define_models.py @@ -0,0 +1,299 @@ +import utils +from utils import checkattr + +##-------------------------------------------------------------------------------------------------------------------## + +def define_classifier(args, config, device, depth=0, stream=False): + if checkattr(args, 'separate_networks'): + model = define_separate_classifiers(args=args, config=config, device=device, depth=depth) + elif checkattr(args, 'feedback'): + model = define_rtf_classifier(args=args, config=config, device=device, depth=depth) + elif checkattr(args, 'gen_classifier'): + model = define_generative_classifer(args=args, config=config, device=device, depth=depth) + elif stream: + model = define_stream_classifier(args=args, config=config, device=device, depth=depth) + else: + model = define_standard_classifier(args=args, config=config, device=device, depth=depth) + return model + + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining discriminative classifier model +def define_stream_classifier(args, config, device, depth=0): + # Import required model + from models.classifier_stream import Classifier + # Specify model + model = Classifier( + image_size=config['size'], + image_channels=config['channels'], + classes=config['output_units'], + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth > 0 else None, + start_channels=args.channels if depth > 0 else None, + reducing_layers=args.rl if depth > 0 else None, + num_blocks=args.n_blocks if depth > 0 else None, + conv_bn=(True if args.conv_bn == "yes" else False) if depth > 0 else None, + conv_nl=args.conv_nl if depth > 0 else None, + no_fnl=True if depth > 0 else None, + global_pooling=checkattr(args, 'gp') if depth > 0 else None, + # -fc-layers + fc_layers=args.fc_lay, + fc_units=args.fc_units, + fc_drop=args.fc_drop, + fc_bn=True if args.fc_bn == "yes" else False, + fc_nl=args.fc_nl, + excit_buffer=True, + phantom=checkattr(args, 'fisher_kfac'), + # -how to use context-ID + xdg_prob=args.gating_prop if checkattr(args, 'xdg') else 0., + n_contexts=args.contexts, + multihead=((args.scenario=='task') and not checkattr(args, 'singlehead')), + device=device + ).to(device) + # Return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining discriminative classifier model +def define_standard_classifier(args, config, device, depth=0): + # Import required model + from models.classifier import Classifier + # Specify model + model = Classifier( + image_size=config['size'], + image_channels=config['channels'], + classes=config['output_units'], + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth>0 else None, + start_channels=args.channels if depth>0 else None, + reducing_layers=args.rl if depth>0 else None, + num_blocks=args.n_blocks if depth>0 else None, + conv_bn=(True if args.conv_bn=="yes" else False) if depth>0 else None, + conv_nl=args.conv_nl if depth>0 else None, + no_fnl=True if depth>0 else None, + global_pooling=checkattr(args, 'gp') if depth>0 else None, + # -fc-layers + fc_layers=args.fc_lay, + fc_units=args.fc_units, + fc_drop=args.fc_drop, + fc_bn=True if args.fc_bn=="yes" else False, + fc_nl=args.fc_nl, + excit_buffer=True, + phantom=checkattr(args, 'fisher_kfac') + ).to(device) + # Return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining 'replay-through-feedback' model +def define_rtf_classifier(args, config, device, depth=0): + # Import required model + from models.cond_vae import CondVAE + # Specify model + model = CondVAE( + image_size=config['size'], + image_channels=config['channels'], + classes=config['output_units'], + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth > 0 else None, + start_channels=args.channels if depth > 0 else None, + reducing_layers=args.rl if depth > 0 else None, + num_blocks=args.n_blocks if depth > 0 else None, + conv_bn=(True if args.conv_bn == "yes" else False) if depth > 0 else None, + conv_nl=args.conv_nl if depth > 0 else None, + global_pooling=checkattr(args, 'gp') if depth > 0 else None, + # -fc-layers + fc_layers=args.fc_lay, + fc_units=args.fc_units, + fc_drop=args.fc_drop, + fc_bn=(args.fc_bn=="yes"), + fc_nl=args.fc_nl, + excit_buffer=True, + # -prior + prior=args.prior if hasattr(args, "prior") else "standard", + n_modes=args.n_modes if hasattr(args, "prior") else 1, + per_class=args.per_class if hasattr(args, "prior") else False, + z_dim=args.z_dim, + # -decoder + recon_loss=args.recon_loss, + network_output="none" if checkattr(args, "normalize") else "sigmoid", + deconv_type=args.deconv_type if hasattr(args, "deconv_type") else "standard", + dg_gates=checkattr(args, 'dg_gates'), + dg_type=args.dg_type if hasattr(args, 'dg_type') else "context", + dg_prop=args.dg_prop if hasattr(args, 'dg_prop') else 0., + contexts=args.contexts if hasattr(args, 'contexts') else None, + scenario=args.scenario if hasattr(args, 'scenario') else None, device=device, + # -classifier + classifier=True, + ).to(device) + # -return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining classifier model with separate network per context +def define_separate_classifiers(args, config, device, depth=0): + # Import required model + from models.separate_classifiers import SeparateClassifiers + # Specify model + model = SeparateClassifiers( + image_size=config['size'], + image_channels=config['channels'], + classes_per_context=config['classes_per_context'], + contexts=args.contexts, + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth>0 else None, + start_channels=args.channels if depth>0 else None, + reducing_layers=args.rl if depth>0 else None, + num_blocks=args.n_blocks if depth>0 else None, + conv_bn=(True if args.conv_bn=="yes" else False) if depth>0 else None, + conv_nl=args.conv_nl if depth>0 else None, + no_fnl=True if depth>0 else None, + global_pooling=checkattr(args, 'gp') if depth>0 else None, + # -fc-layers + fc_layers=args.fc_lay, + fc_units=args.fc_units, + fc_drop=args.fc_drop, + fc_bn=True if args.fc_bn=="yes" else False, + fc_nl=args.fc_nl, + excit_buffer=True, + ).to(device) + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining generative classifier (with separate VAE per class) +def define_generative_classifer(args, config, device, depth=0): + # Import required model + from models.generative_classifier import GenerativeClassifier + # Specify model + model = GenerativeClassifier( + image_size=config['size'], + image_channels=config['channels'], + classes=config['classes'], + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth>0 else None, + start_channels=args.channels if depth>0 else None, + reducing_layers=args.rl if depth>0 else None, + num_blocks=args.n_blocks if depth>0 else None, + conv_bn=(True if args.conv_bn=="yes" else False) if depth>0 else None, + conv_nl=args.conv_nl if depth>0 else None, + no_fnl=True if depth>0 else None, + global_pooling=checkattr(args, 'gp') if depth>0 else None, + # -fc-layers + fc_layers=args.fc_lay, + fc_units=args.fc_units, + fc_drop=args.fc_drop, + fc_bn=(args.fc_bn=="yes"), + fc_nl=args.fc_nl, + excit_buffer=True, + # -prior + prior=args.prior if hasattr(args, "prior") else "standard", + n_modes=args.n_modes if hasattr(args, "prior") else 1, + z_dim=args.z_dim, + # -decoder + recon_loss=args.recon_loss, + network_output="none" if checkattr(args, "normalize") else "sigmoid", + deconv_type=args.deconv_type if hasattr(args, "deconv_type") else "standard", + ).to(device) + # Return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining feature extractor model +def define_feature_extractor(args, config, device): + # -import required model + from models.feature_extractor import FeatureExtractor + # -create model + model = FeatureExtractor( + image_size=config['size'], + image_channels=config['channels'], + # -conv-layers + conv_type=args.conv_type, + depth=args.depth, + start_channels=args.channels, + reducing_layers=args.rl, + num_blocks=args.n_blocks, + conv_bn=True if args.conv_bn=="yes" else False, + conv_nl=args.conv_nl, + global_pooling=checkattr(args, 'gp'), + ).to(device) + # -return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for defining VAE model +def define_vae(args, config, device, depth=0): + # Import required model + from models.vae import VAE + # Specify model + model = VAE( + image_size=config['size'], + image_channels=config['channels'], + # -conv-layers + depth=depth, + conv_type=args.conv_type if depth > 0 else None, + start_channels=args.channels if depth > 0 else None, + reducing_layers=args.rl if depth > 0 else None, + num_blocks=args.n_blocks if depth > 0 else None, + conv_bn=(True if args.conv_bn == "yes" else False) if depth > 0 else None, + conv_nl=args.conv_nl if depth > 0 else None, + global_pooling=False if depth > 0 else None, + # -fc-layers + fc_layers=args.g_fc_lay if hasattr(args, 'g_fc_lay') else args.fc_lay, + fc_units=args.g_fc_uni if hasattr(args, 'g_fc_uni') else args.fc_units, + fc_drop=0, + fc_bn=(args.fc_bn=="yes"), + fc_nl=args.fc_nl, + excit_buffer=True, + # -prior + prior=args.prior if hasattr(args, "prior") else "standard", + n_modes=args.n_modes if hasattr(args, "prior") else 1, + z_dim=args.g_z_dim if hasattr(args, 'g_z_dim') else args.z_dim, + # -decoder + recon_loss=args.recon_loss, + network_output="none" if checkattr(args, "normalize") else "sigmoid", + deconv_type=args.deconv_type if hasattr(args, "deconv_type") else "standard", + ).to(device) + # Return model + return model + +##-------------------------------------------------------------------------------------------------------------------## + +## Function for (re-)initializing the parameters of [model] +def init_params(model, args, verbose=False): + + ## Initialization + # - reinitialize all parameters according to default initialization + model.apply(utils.weight_reset) + # - initialize parameters according to chosen custom initialization (if requested) + if hasattr(args, 'init_weight') and not args.init_weight=="standard": + utils.weight_init(model, strategy="xavier_normal") + if hasattr(args, 'init_bias') and not args.init_bias=="standard": + utils.bias_init(model, strategy="constant", value=0.01) + + ## Use pre-training + if checkattr(args, "pre_convE") and hasattr(model, 'depth') and model.depth>0: + load_name = model.convE.name if ( + not hasattr(args, 'convE_ltag') or args.convE_ltag=="none" + ) else "{}-{}{}".format(model.convE.name, args.convE_ltag, + "-s{}".format(args.seed) if checkattr(args, 'seed_to_ltag') else "") + utils.load_checkpoint(model.convE, model_dir=args.m_dir, name=load_name, verbose=verbose) + + ## Freeze some parameters? + if checkattr(args, "freeze_convE") and hasattr(model, 'convE'): + for param in model.convE.parameters(): + param.requires_grad = False + model.convE.frozen = True #--> so they're set to .eval() duting trainng to ensure batchnorm-params do not change + +##-------------------------------------------------------------------------------------------------------------------## diff --git a/PyTorch/build-in/other/continual-learning/models/fc/__init__.py b/PyTorch/build-in/other/continual-learning/models/fc/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/models/fc/excitability_modules.py b/PyTorch/build-in/other/continual-learning/models/fc/excitability_modules.py new file mode 100644 index 000000000..6d14baf96 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/fc/excitability_modules.py @@ -0,0 +1,91 @@ +import math +import torch +from torch import nn +from torch.nn.parameter import Parameter + + +def linearExcitability(input, weight, excitability=None, bias=None): + '''Applies a linear transformation to the incoming data: :math:`y = c(xA^T) + b`. + + Shape: + - input: :math:`(N, *, in_features)` + - weight: :math:`(out_features, in_features)` + - excitability: :math:`(out_features)` + - bias: :math:`(out_features)` + - output: :math:`(N, *, out_features)` + (NOTE: `*` means any number of additional dimensions)''' + + if excitability is not None: + output = input.matmul(weight.t()) * excitability + else: + output = input.matmul(weight.t()) + if bias is not None: + output += bias + return output + + +class LinearExcitability(nn.Module): + '''Module for a linear transformation with multiplicative excitability-parameter (i.e., learnable) and/or -buffer. + + Args: + in_features: size of each input sample + out_features: size of each output sample + bias: if 'False', layer will not learn an additive bias-parameter (DEFAULT=True) + excitability: if 'True', layer will learn a multiplicative excitability-parameter (DEFAULT=False) + excit_buffer: if 'True', layer will have excitability-buffer whose value can be set (DEFAULT=False) + + Shape: + - input: :math:`(N, *, in_features)` where `*` means any number of additional dimensions + - output: :math:`(N, *, out_features)` where all but the last dimension are the same shape as the input. + + Attributes: + weight: the learnable weights of the module of shape (out_features x in_features) + excitability: the learnable multiplication terms (out_features) + bias: the learnable bias of the module of shape (out_features) + excit_buffer: fixed multiplication variable (out_features)''' + + def __init__(self, in_features, out_features, bias=True, excitability=False, excit_buffer=False): + super(LinearExcitability, self).__init__() + self.in_features = in_features + self.out_features = out_features + self.weight = Parameter(torch.Tensor(out_features, in_features)) + if excitability: + self.excitability = Parameter(torch.Tensor(out_features)) + else: + self.register_parameter('excitability', None) + if bias: + self.bias = Parameter(torch.Tensor(out_features)) + else: + self.register_parameter('bias', None) + if excit_buffer: + buffer = torch.Tensor(out_features).uniform_(1,1) + self.register_buffer("excit_buffer", buffer) + else: + self.register_buffer("excit_buffer", None) + self.reset_parameters() + + def reset_parameters(self): + '''Modifies the parameters "in-place" to initialize / reset them at appropriate values.''' + stdv = 1. / math.sqrt(self.weight.size(1)) + self.weight.data.uniform_(-stdv, stdv) + if self.excitability is not None: + self.excitability.data.uniform_(1, 1) + if self.bias is not None: + self.bias.data.uniform_(-stdv, stdv) + + def forward(self, input): + '''Running this model's forward step requires/returns: + -[input]: [batch_size]x[...]x[in_features] + -[output]: [batch_size]x[...]x[hidden_features]''' + if self.excit_buffer is None: + excitability = self.excitability + elif self.excitability is None: + excitability = self.excit_buffer + else: + excitability = self.excitability*self.excit_buffer + return linearExcitability(input, self.weight, excitability, self.bias) + + def __repr__(self): + return self.__class__.__name__ + '(' \ + + 'in_features=' + str(self.in_features) \ + + ', out_features=' + str(self.out_features) + ')' \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/fc/layers.py b/PyTorch/build-in/other/continual-learning/models/fc/layers.py new file mode 100644 index 000000000..d201b924d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/fc/layers.py @@ -0,0 +1,152 @@ +import numpy as np +import torch +from torch import nn +from models.utils import modules +from models.fc import excitability_modules as em + + +class fc_layer(nn.Module): + '''Fully connected layer, with possibility of returning "pre-activations". + + Input: [batch_size] x ... x [in_size] tensor + Output: [batch_size] x ... x [out_size] tensor''' + + def __init__(self, in_size, out_size, nl=nn.ReLU(), drop=0., bias=True, batch_norm=False, + excitability=False, excit_buffer=False, gated=False, phantom=False): + super().__init__() + self.bias = False if batch_norm else bias + if drop>0: + self.dropout = nn.Dropout(drop) + self.linear = em.LinearExcitability(in_size, out_size, bias=False if batch_norm else bias, + excitability=excitability, excit_buffer=excit_buffer) + if batch_norm: + self.bn = nn.BatchNorm1d(out_size) + if gated: + self.gate = nn.Linear(in_size, out_size) + self.sigmoid = nn.Sigmoid() + if phantom: + self.phantom = nn.Parameter(torch.zeros(out_size), requires_grad=True) + if isinstance(nl, nn.Module): + self.nl = nl + elif not nl=="none": + self.nl = nn.ReLU() if nl == "relu" else (nn.LeakyReLU() if nl == "leakyrelu" else modules.Identity()) + + def forward(self, x, return_pa=False, **kwargs): + input = self.dropout(x) if hasattr(self, 'dropout') else x + pre_activ = self.bn(self.linear(input)) if hasattr(self, 'bn') else self.linear(input) + gate = self.sigmoid(self.gate(x)) if hasattr(self, 'gate') else None + gated_pre_activ = gate * pre_activ if hasattr(self, 'gate') else pre_activ + if hasattr(self, 'phantom'): + gated_pre_activ = gated_pre_activ + self.phantom + output = self.nl(gated_pre_activ) if hasattr(self, 'nl') else gated_pre_activ + return (output, gated_pre_activ) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + return [self.linear, self.gate] if hasattr(self, 'gate') else [self.linear] + + + +class fc_layer_split(nn.Module): + '''Fully connected layer outputting [mean] and [logvar] for each unit. + + Input: [batch_size] x ... x [in_size] tensor + Output: tuple with two [batch_size] x ... x [out_size] tensors''' + + def __init__(self, in_size, out_size, nl_mean=nn.Sigmoid(), nl_logvar=nn.Hardtanh(min_val=-4.5, max_val=0.), + drop=0., bias=True, excitability=False, excit_buffer=False, batch_norm=False, gated=False): + super().__init__() + + self.mean = fc_layer(in_size, out_size, drop=drop, bias=bias, excitability=excitability, + excit_buffer=excit_buffer, batch_norm=batch_norm, gated=gated, nl=nl_mean) + self.logvar = fc_layer(in_size, out_size, drop=drop, bias=False, excitability=excitability, + excit_buffer=excit_buffer, batch_norm=batch_norm, gated=gated, nl=nl_logvar) + + def forward(self, x): + return (self.mean(x), self.logvar(x)) + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.mean.list_init_layers() + list += self.logvar.list_init_layers() + return list + + + +class fc_layer_fixed_gates(nn.Module): + '''Fully connected layer, with possibility of returning "pre-activations". Has fixed gates (of specified dimension). + + Input: [batch_size] x ... x [in_size] tensor & [batch_size] x ... x [gate_size] tensor + Output: [batch_size] x ... x [out_size] tensor''' + + def __init__(self, in_size, out_size, nl=nn.ReLU(), + drop=0., bias=True, excitability=False, excit_buffer=False, batch_norm=False, + gate_size=0, gating_prop=0.8, device='cpu'): + super().__init__() + if drop > 0: + self.dropout = nn.Dropout(drop) + self.linear = em.LinearExcitability(in_size, out_size, bias=False if batch_norm else bias, + excitability=excitability, excit_buffer=excit_buffer) + if batch_norm: + self.bn = nn.BatchNorm1d(out_size) + if gate_size>0: + self.gate_mask = torch.tensor( + np.random.choice([0., 1.], size=(gate_size, out_size), p=[gating_prop, 1.-gating_prop]), + dtype=torch.float, device=device + ) + if isinstance(nl, nn.Module): + self.nl = nl + elif not nl == "none": + self.nl = nn.ReLU() if nl == "relu" else (nn.LeakyReLU() if nl == "leakyrelu" else modules.Identity()) + + def forward(self, x, gate_input=None, return_pa=False): + input = self.dropout(x) if hasattr(self, 'dropout') else x + pre_activ = self.bn(self.linear(input)) if hasattr(self, 'bn') else self.linear(input) + gate = torch.matmul(gate_input, self.gate_mask) if hasattr(self, 'gate_mask') else None + gated_pre_activ = gate * pre_activ if hasattr(self, 'gate_mask') else pre_activ + output = self.nl(gated_pre_activ) if hasattr(self, 'nl') else gated_pre_activ + return (output, gated_pre_activ) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + return [self.linear, self.gate] if hasattr(self, 'gate') else [self.linear] + + + +class fc_multihead_layer(nn.Module): + '''Fully connected layer with a separate head for each context. + + Input: [batch_size] x ... x [in_size] tensor & [batch_size] x ... x [n_contexts] tensor + Output: [batch_size] x ... x [out_size] tensor''' + + def __init__(self, in_size, classes, n_contexts, nl=nn.ReLU(), + drop=0., bias=True, excitability=False, excit_buffer=False, batch_norm=False, device='cpu'): + super().__init__() + if drop > 0: + self.dropout = nn.Dropout(drop) + self.linear = em.LinearExcitability(in_size, classes, bias=False if batch_norm else bias, + excitability=excitability, excit_buffer=excit_buffer) + if batch_norm: + self.bn = nn.BatchNorm1d(classes) + if n_contexts > 0: + self.gate_mask = torch.zeros(size=(n_contexts, classes), dtype=torch.float, device=device) + classes_per_context = int(classes/n_contexts) + for context_id in range(n_contexts): + self.gate_mask[context_id, (context_id * classes_per_context):((context_id + 1) * classes_per_context)] = 1. + if isinstance(nl, nn.Module): + self.nl = nl + elif not nl == "none": + self.nl = nn.ReLU() if nl == "relu" else (nn.LeakyReLU() if nl == "leakyrelu" else modules.Identity()) + + def forward(self, x, gate_input=None, return_pa=False): + input = self.dropout(x) if hasattr(self, 'dropout') else x + pre_activ = self.bn(self.linear(input)) if hasattr(self, 'bn') else self.linear(input) + gate = torch.matmul(gate_input, self.gate_mask) if hasattr(self, 'gate_mask') else None + gated_pre_activ = gate * pre_activ if hasattr(self, 'gate_mask') else pre_activ + output = self.nl(gated_pre_activ) if hasattr(self, 'nl') else gated_pre_activ + return (output, gated_pre_activ) if return_pa else output + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + return [self.linear, self.gate] if hasattr(self, 'gate') else [self.linear] \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/fc/nets.py b/PyTorch/build-in/other/continual-learning/models/fc/nets.py new file mode 100644 index 000000000..810afe333 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/fc/nets.py @@ -0,0 +1,219 @@ +from torch import nn +import numpy as np +from models.utils.modules import Identity +from models.fc.layers import fc_layer, fc_layer_fixed_gates + + +class MLP(nn.Module): + '''Module for a multi-layer perceptron (MLP). + + Input: [batch_size] x ... x [size_per_layer[0]] tensor + Output: (tuple of) [batch_size] x ... x [size_per_layer[-1]] tensor''' + + def __init__(self, input_size=1000, output_size=10, layers=2, hid_size=1000, hid_smooth=None, size_per_layer=None, + drop=0, batch_norm=False, nl="relu", bias=True, excitability=False, excit_buffer=False, gated=False, + phantom=False, output='normal'): + '''sizes: 0th=[input], 1st=[hid_size], ..., 1st-to-last=[hid_smooth], last=[output]. + [input_size] # of inputs + [output_size] # of units in final layer + [layers] # of layers + [hid_size] # of units in each hidden layer + [hid_smooth] if None, all hidden layers have [hid_size] units, else # of units linearly in-/decreases s.t. + final hidden layer has [hid_smooth] units (if only 1 hidden layer, it has [hid_size] units) + [size_per_layer] None or with for each layer number of units (1st element = number of inputs) + --> overwrites [input_size], [output_size], [layers], [hid_size] and [hid_smooth] + [drop] % of each layer's inputs that is randomly set to zero during training + [batch_norm] ; if True, batch-normalization is applied to each layer + [nl] ; type of non-linearity to be used (options: "relu", "leakyrelu", "none") + [gated] ; if True, each linear layer has an additional learnable gate + (whereby the gate is controlled by the same input as that goes through the gate) + [phantom] ; if True, add phantom parameters to pre-activations, used for computing KFAC Fisher + [output] ; if - "normal", final layer is same as all others + - "none", final layer has no non-linearity + - "sigmoid", final layer has sigmoid non-linearity''' + + super().__init__() + self.output = output + + # get sizes of all layers + if size_per_layer is None: + hidden_sizes = [] + if layers > 1: + if (hid_smooth is not None): + hidden_sizes = [int(x) for x in np.linspace(hid_size, hid_smooth, num=layers-1)] + else: + hidden_sizes = [int(x) for x in np.repeat(hid_size, layers - 1)] + size_per_layer = [input_size] + hidden_sizes + [output_size] if layers>0 else [input_size] + self.layers = len(size_per_layer)-1 + + # set label for this module + # -determine "non-default options"-label + nd_label = "{drop}{bias}{exc}{bn}{nl}{gate}".format( + drop="" if drop==0 else "d{}".format(drop), + bias="" if bias else "n", exc="e" if excitability else "", bn="b" if batch_norm else "", + nl="l" if nl=="leakyrelu" else ("n" if nl=="none" else ""), gate="g" if gated else "", + ) + nd_label = "{}{}".format("" if nd_label=="" else "-{}".format(nd_label), + "" if output=="normal" else "-{}".format(output)) + # -set label + size_statement = "" + for i in size_per_layer: + size_statement += "{}{}".format("-" if size_statement=="" else "x", i) + self.label = "F{}{}".format(size_statement, nd_label) if self.layers>0 else "" + + # set layers + for lay_id in range(1, self.layers+1): + # number of units of this layer's input and output + in_size = size_per_layer[lay_id-1] + out_size = size_per_layer[lay_id] + # define and set the fully connected layer + layer = fc_layer( + in_size, out_size, bias=bias, excitability=excitability, excit_buffer=excit_buffer, + batch_norm=False if (lay_id==self.layers and not output=="normal") else batch_norm, gated=gated, + nl=("none" if output=="none" else nn.Sigmoid()) if ( + lay_id==self.layers and not output=="normal" + ) else nl, drop=drop if lay_id>1 else 0., phantom=phantom + ) + setattr(self, 'fcLayer{}'.format(lay_id), layer) + + # if no layers, add "identity"-module to indicate in this module's representation nothing happens + if self.layers<1: + self.noLayers = Identity() + + def forward(self, x, return_intermediate=False): + if return_intermediate: + intermediate = {} + for lay_id in range(1, self.layers + 1): + if return_intermediate: + intermediate[f"fcLayer{lay_id}"] = x + x = getattr(self, "fcLayer{}".format(lay_id))(x) + return (x, intermediate) if return_intermediate else x + + @property + def name(self): + return self.label + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for layer_id in range(1, self.layers+1): + list += getattr(self, 'fcLayer{}'.format(layer_id)).list_init_layers() + return list + + + +class MLP_gates(nn.Module): + '''Module for a multi-layer perceptron (MLP). Possible to return (pre)activations of each layer. + Also possible to supply a [skip_first]- or [skip_last]-argument to the forward-function to only pass certain layers. + With gates controlled by [gate_input] (of size [gate_size]) with a randomly selected masked (prop=[gating_prop]). + + Input: [batch_size] x ... x [size_per_layer[0]] tensor & [batch_size] x [gate_size] + Output: (tuple of) [batch_size] x ... x [size_per_layer[-1]] tensor''' + + def __init__(self, input_size=1000, output_size=10, layers=2, hid_size=1000, hid_smooth=None, size_per_layer=None, + drop=0, batch_norm=False, nl="relu", bias=True, excitability=False, excit_buffer=False, gate_size=0, + gating_prop=0., final_gate=False, output='normal', device='cpu'): + '''sizes: 0th=[input], 1st=[hid_size], ..., 1st-to-last=[hid_smooth], last=[output]. + [input_size] # of inputs + [output_size] # of units in final layer + [layers] # of layers + [hid_size] # of units in each hidden layer + [hid_smooth] if None, all hidden layers have [hid_size] units, else # of units linearly in-/decreases s.t. + final hidden layer has [hid_smooth] units (if only 1 hidden layer, it has [hid_size] units) + [size_per_layer] None or with for each layer number of units (1st element = number of inputs) + --> overwrites [input_size], [output_size], [layers], [hid_size] and [hid_smooth] + [drop] % of each layer's inputs that is randomly set to zero during training + [batch_norm] ; if True, batch-normalization is applied to each layer + [nl] ; type of non-linearity to be used (options: "relu", "leakyrelu", "none") + [gate_size] ; if>0, each linear layer has gate controlled by separate inputs of size [gate_size] + [gating_prop] ; probability for each unit to be gated + [final_gate] ; whether final layer is allowed to have a gate + [output] ; if - "normal", final layer is same as all others + - "none", final layer has no non-linearity + - "sigmoid", final layer has sigmoid non-linearity''' + + super().__init__() + self.output = output + + # get sizes of all layers + if size_per_layer is None: + hidden_sizes = [] + if layers > 1: + if (hid_smooth is not None): + hidden_sizes = [int(x) for x in np.linspace(hid_size, hid_smooth, num=layers-1)] + else: + hidden_sizes = [int(x) for x in np.repeat(hid_size, layers - 1)] + size_per_layer = [input_size] + hidden_sizes + [output_size] if layers>0 else [input_size] + self.layers = len(size_per_layer)-1 + + # set label for this module + # -determine "non-default options"-label + nd_label = "{drop}{bias}{exc}{bn}{nl}{gate}".format( + drop="" if drop==0 else "d{}".format(drop), + bias="" if bias else "n", exc="e" if excitability else "", bn="b" if batch_norm else "", + nl="l" if nl=="leakyrelu" else ("n" if nl=="none" else ""), + gate="g{}m{}".format(gate_size, gating_prop) if (gate_size>0 and gating_prop>0.) else "", + ) + nd_label = "{}{}".format("" if nd_label=="" else "-{}".format(nd_label), + "" if output=="normal" else "-{}".format(output)) + # -set label + size_statement = "" + for i in size_per_layer: + size_statement += "{}{}".format("-" if size_statement=="" else "x", i) + self.label = "F{}{}".format(size_statement, nd_label) if self.layers>0 else "" + + # set layers + for lay_id in range(1, self.layers+1): + # number of units of this layer's input and output + in_size = size_per_layer[lay_id-1] + out_size = size_per_layer[lay_id] + # define and set the fully connected layer + if (not gate_size>0.) or (not gating_prop>0.) or (lay_id==self.layers and not final_gate): + layer = fc_layer( + in_size, out_size, bias=bias, excitability=excitability, excit_buffer=excit_buffer, + batch_norm=False if (lay_id==self.layers and not output=="normal") else batch_norm, + nl=("none" if output=="none" else nn.Sigmoid()) if ( + lay_id==self.layers and not output=="normal" + ) else nl, drop=drop if lay_id>1 else 0., + ) + else: + layer = fc_layer_fixed_gates( + in_size, out_size, bias=bias, excitability=excitability, excit_buffer=excit_buffer, + batch_norm=False if (lay_id == self.layers and not output == "normal") else batch_norm, + gate_size=gate_size, gating_prop=gating_prop, device=device, + nl=("none" if output == "none" else nn.Sigmoid()) if ( + lay_id == self.layers and not output == "normal" + ) else nl, drop=drop if lay_id>1 else 0., + ) + setattr(self, 'fcLayer{}'.format(lay_id), layer) + + # if no layers, add "identity"-module to indicate in this module's representation nothing happens + if self.layers<1: + self.noLayers = Identity() + + def forward(self, x, gate_input=None, skip_first=0, skip_last=0, return_lists=False): + # Initiate for keeping track of intermediate hidden-(pre)activations + if return_lists: + hidden_act_list = [] + pre_act_list = [] + # Sequentially pass [x] through all fc-layers + for lay_id in range(skip_first+1, self.layers+1-skip_last): + (x, pre_act) = getattr(self, 'fcLayer{}'.format(lay_id))(x, gate_input=gate_input, return_pa=True) + if return_lists: + pre_act_list.append(pre_act) #-> for each layer, store pre-activations + if lay_id<(self.layers-skip_last): + hidden_act_list.append(x) #-> for all but last layer, store hidden activations + # Return final [x], if requested along with [hidden_act_list] and [pre_act_list] + return (x, hidden_act_list, pre_act_list) if return_lists else x + + + @property + def name(self): + return self.label + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for layer_id in range(1, self.layers+1): + list += getattr(self, 'fcLayer{}'.format(layer_id)).list_init_layers() + return list diff --git a/PyTorch/build-in/other/continual-learning/models/feature_extractor.py b/PyTorch/build-in/other/continual-learning/models/feature_extractor.py new file mode 100644 index 000000000..a7b0919d9 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/feature_extractor.py @@ -0,0 +1,122 @@ +import tqdm +import torch +from torch import optim +from torch.nn import functional as F +from models.utils import modules +from models.conv.nets import ConvLayers +from models.fc.layers import fc_layer + + +class FeatureExtractor(torch.nn.Module): + '''Model for encoding (i.e., feature extraction) and images.''' + + def __init__(self, image_size, image_channels, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False): + + # Model configurations + super().__init__() + self.label = "FeatureExtractor" + self.depth = depth + + # Optimizer (needs to be set before training starts)) + self.optim_type = None + self.optimizer = None + self.optim_list = [] + + ######------SPECIFY MODEL------###### + #--> convolutional layers + self.convE = ConvLayers( + conv_type=conv_type, block_type="basic", num_blocks=num_blocks, image_channels=image_channels, + depth=depth, start_channels=start_channels, reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, + global_pooling=global_pooling, gated=conv_gated, output="none" if no_fnl else "normal", + ) + #------------------------------calculate input/output-sizes--------------------------------# + self.conv_out_units = self.convE.out_units(image_size) + self.conv_out_size = self.convE.out_size(image_size) + self.conv_out_channels = self.convE.out_channels + + @property + def name(self): + return self.convE.name + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = self.convE.list_init_layers() + return list + + def forward(self, x): + return self.convE(x) + + def train_discriminatively(self, train_loader, iters, classes, lr=0.001, optimizer='adam'): + '''Train the feature extractor for [iters] iterations on data from [train_loader]. + + [model] model to optimize + [train_loader] for training [model] on + [iters] (max) number of iterations (i.e., batches) to train for + [classes] number of possible clasess (softmax layer with that many units will be added to model) + ''' + + # Create (temporary) classification output layer + self.flatten = modules.Flatten() + self.classifier = fc_layer(self.conv_out_units, classes, excit_buffer=True, nl='none').to(self._device()) + + # Define optimizer + optim_list = [{'params': filter(lambda p: p.requires_grad, self.parameters()), 'lr': lr},] + self.optimizer = optim.SGD(optim_list) if optimizer=="sgd" else optim.Adam(optim_list, betas=(0.9, 0.999)) + + # Set model to training-mode + self.train() + + # Create progress-bar (with manual control) + bar = tqdm.tqdm(total=iters) + + iteration = epoch = 0 + while iteration < iters: + epoch += 1 + + # Loop over all batches of an epoch + for batch_idx, (data, y) in enumerate(train_loader): + iteration += 1 + + # Reset optimizer + self.optimizer.zero_grad() + + # Prepare data + data, y = data.to(self._device()), y.to(self._device()) + + # Run model + features = self(data) + y_hat = self.classifier(self.flatten(features)) + + # Calculate loss + loss = F.cross_entropy(input=y_hat, target=y, reduction='mean') + + # Calculate training-accuracy + accuracy = None if y is None else (y == y_hat.max(1)[1]).sum().item() / data.size(0) + + # Backpropagate errors + loss.backward() + + # Take optimization-step + self.optimizer.step() + + # Update progress bar + bar.set_description( + ' | training loss: {loss:.3} | training accuracy: {prec:.3} |'.format( + loss=loss.cpu().item(), prec=accuracy + ) + ) + bar.update(1) + + # Break if max-number of iterations is reached + if iteration == iters: + bar.close() + break diff --git a/PyTorch/build-in/other/continual-learning/models/generative_classifier.py b/PyTorch/build-in/other/continual-learning/models/generative_classifier.py new file mode 100644 index 000000000..d361b9e0d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/generative_classifier.py @@ -0,0 +1,114 @@ +import numpy as np +import torch +from torch import nn +from models.vae import VAE + + + +class GenerativeClassifier(nn.Module): + """Class for generative classifier with separate VAE for each class to be learned.""" + + def __init__(self, image_size, image_channels, classes, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=False, fc_nl="relu", excit_buffer=False, fc_gated=False, + # -prior + z_dim=20, prior="standard", n_modes=1, + # -decoder + recon_loss='BCE', network_output="sigmoid", deconv_type="standard"): + + # Set configurations for setting up the model + super().__init__() + self.classes = classes + self.label = "GenClassifier" + + # Atributes defining how to do inference + self.S = "mean" # "mean": use [z_mu] as single (importance) sample; : use this much (importance) samples + self.importance = True + self.from_latent = False + + # Define a VAE for each class to be learned + for class_id in range(classes): + new_vae = VAE(image_size, image_channels, + # -conv-layers + conv_type=conv_type, depth=depth, start_channels=start_channels, + reducing_layers=reducing_layers, conv_bn=conv_bn, conv_nl=conv_nl, + num_blocks=num_blocks, global_pooling=global_pooling, no_fnl=no_fnl, + conv_gated=conv_gated, + # -fc-layers + fc_layers=fc_layers, fc_units=fc_units, fc_drop=fc_drop, fc_bn=fc_bn, + fc_nl=fc_nl, excit_buffer=excit_buffer, fc_gated=fc_gated, + # -prior + z_dim=z_dim, prior=prior, n_modes=n_modes, + # -decoder + recon_loss=recon_loss, network_output=network_output, deconv_type=deconv_type) + setattr(self, "vae{}".format(class_id), new_vae) + + + ##------ NAMES --------## + + def get_name(self): + return "x{}-{}".format(self.classes, self.vae0.get_name()) + + @property + def name(self): + return self.get_name() + + + ##------ UTILITIES --------## + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + + ##------ SAMPLE FUNCTIONS --------## + + def sample(self, size, only_x=True, class_id=None, **kwargs): + '''Generate [size] samples from the model. Outputs are tensors (not "requiring grad"), on same device.''' + + for sample_id in range(size): + # sample from which class-specific VAE to sample + selected_class_id = np.random.randint(0, self.classes, 1)[0] if class_id is None else class_id + model_to_sample_from = getattr(self, 'vae{}'.format(selected_class_id)) + + # sample from that VAE + new_sample = model_to_sample_from.sample(1) + + # concatanate generated X (and y) + X = torch.cat([X, new_sample], dim=0) if sample_id>0 else new_sample + if not only_x: + y = torch.cat([y, torch.LongTensor([selected_class_id]).to(self._device())]) if ( + sample_id>0 + ) else torch.LongTensor([selected_class_id]).to(self._device()) + + # return samples as [size]x[channels]x[image_size]x[image_size] tensor (and labels as [size] tensor) + return X if only_x else (X, y) + + + ##------ CLASSIFICATION FUNCTIONS --------## + + def classify(self, x, allowed_classes=None, **kwargs): + '''Given an input [x], get the scores based on [self.S] importance samples (if self.S=='mean', use [z_mu]). + + Input: - [x] <4D-tensor> of shape [batch]x[channels]x[image_size]x[image_size] + + Output: - [scores] <2D-tensor> of shape [batch]x[allowed_classes] + ''' + # If not provided, set [allowed_classes] to all possible classes + if allowed_classes is None: + allowed_classes = list(range(self.classes)) + # For each possible class, compute its 'score' (i.e., likelihood of input under generative model of that class) + scores = torch.zeros([x.size(0), len(allowed_classes)], dtype=torch.float32, device=self._device()) + for class_id in allowed_classes: + if self.from_latent: + scores[:,class_id] = getattr(self, 'vae{}'.format(class_id)).get_latent_lls(x) + else: + scores[:,class_id] = getattr(self, 'vae{}'.format(class_id)).estimate_lls( + x, S=self.S, importance=self.importance + ) + return scores \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/separate_classifiers.py b/PyTorch/build-in/other/continual-learning/models/separate_classifiers.py new file mode 100644 index 000000000..ab8abae5f --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/separate_classifiers.py @@ -0,0 +1,85 @@ +from torch import nn +from models.classifier import Classifier + + +class SeparateClassifiers(nn.Module): + '''Model for classifying images with a separate network for each context.''' + + def __init__(self, image_size, image_channels, classes_per_context, contexts, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=True, fc_nl="relu", fc_gated=False, + bias=True, excitability=False, excit_buffer=False): + + # Configurations + super().__init__() + self.classes_per_context = classes_per_context + self.contexts = contexts + self.label = "SeparateClassifiers" + self.depth = depth + self.fc_layers = fc_layers + self.fc_drop = fc_drop + + # Check whether there is at least 1 fc-layer + if fc_layers<1: + raise ValueError("The classifier needs to have at least 1 fully-connected layer.") + + # Define a separate network for each context to be learned + for context_id in range(self.contexts): + new_network = Classifier( + image_size, image_channels, classes_per_context, + # -conv-layers + conv_type=conv_type, depth=depth, start_channels=start_channels, reducing_layers=reducing_layers, + conv_bn=conv_bn, conv_nl=conv_nl, num_blocks=num_blocks, global_pooling=global_pooling, no_fnl=no_fnl, + conv_gated=conv_gated, + # -fc-layers + fc_layers=fc_layers, fc_units=fc_units, fc_drop=fc_drop, fc_bn=fc_bn, fc_nl=fc_nl, fc_gated=fc_gated, + bias=bias, excitability=excitability, excit_buffer=excit_buffer + ) + setattr(self, 'context{}'.format(context_id+1), new_network) + + + def _device(self): + return next(self.parameters()).device + + def _is_on_cuda(self): + return next(self.parameters()).is_cuda + + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + for context_id in range(self.contexts): + list += getattr(self, 'context{}'.format(context_id+1)).list_init_layers() + return list + + @property + def name(self): + return "SepNets-{}".format(self.context1.name) + + + def train_a_batch(self, x, y, c=None, context=None, **kwargs): + '''Train model for one batch ([x],[y]) from the indicated context. + + [x] batch of inputs (could be None, in which case only 'replayed' data is used) + [y] batch of corresponding labels + [c] <1D-tensor> or ; for each batch-element in [x] its context-ID + [context] the context, can be used if all elements in [x] are from same context + ''' + + # Train the sub-network of the indicated context on this batch + if context is not None: + loss_dict = getattr(self, 'context{}'.format(context)).train_a_batch(x, y) + else: + for context_id in range(self.contexts): + if context_id in c: + x_to_use = x[c == context_id] + y_to_use = y[c == context_id] + loss_dict = getattr(self, 'context{}'.format(context_id+1)).train_a_batch(x_to_use, y_to_use) + # NOTE: this way, only the [lost_dict] of the last context in the batch is returned + + # Return the dictionary with different training-loss split in categories + return loss_dict + diff --git a/PyTorch/build-in/other/continual-learning/models/utils/__init__.py b/PyTorch/build-in/other/continual-learning/models/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/models/utils/loss_functions.py b/PyTorch/build-in/other/continual-learning/models/utils/loss_functions.py new file mode 100644 index 000000000..62271b307 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/utils/loss_functions.py @@ -0,0 +1,154 @@ +import numpy as np +import torch +from torch.nn import functional as F + + +##-------------------------------------------------------------------------------------------------------------------## + +#################### +## Loss functions ## +#################### + +def loss_fn_kd(scores, target_scores, T=2., weights=None, norm=False): + """Compute knowledge-distillation (KD) loss given [scores] and [target_scores]. + + Both [scores] and [target_scores] should be <2D-tensors>, although [target_scores] should be repackaged. + 'Hyperparameter': temperature""" + + device = scores.device + + log_scores_norm = F.log_softmax(scores / T, dim=1) + targets_norm = F.softmax(target_scores / T, dim=1) + + # If [scores] and [target_scores] do not have equal size, append 0's to [targets_norm] + n = scores.size(1) + if n>target_scores.size(1): + n_batch = scores.size(0) + zeros_to_add = torch.zeros(n_batch, n-target_scores.size(1)) + zeros_to_add = zeros_to_add.to(device) + targets_norm = torch.cat([targets_norm, zeros_to_add], dim=1) + + # Calculate distillation loss (see e.g., Li and Hoiem, 2017) + KD_loss_unnorm = -targets_norm * log_scores_norm + + # Sum over the prob-scores of all classes (1) and then average over all elements in the batch (2) + KD_loss_unnorm = KD_loss_unnorm.sum(dim=1) #-> sum over classes + KD_loss_unnorm = weighted_average(KD_loss_unnorm, weights=weights, dim=0) #-> average over batch + + # Normalize + KD_loss = (KD_loss_unnorm * T**2) if norm else KD_loss_unnorm + + return KD_loss + + + +def loss_fn_kd_binary(scores, target_scores, T=2., weights=None, norm=False): + """Compute binary knowledge-distillation (KD) loss given [scores] and [target_scores]. + + Both [scores] and [target_scores] should be tensors, although [target_scores] should be repackaged. + 'Hyperparameter': temperature""" + + device = scores.device + + scores_norm = torch.sigmoid(scores / T) + targets_norm = torch.sigmoid(target_scores / T) + + # If [scores] and [target_scores] do not have equal size, append 0's to [targets_norm] + n = scores.size(1) + if n>target_scores.size(1): + n_batch = scores.size(0) + zeros_to_add = torch.zeros(n_batch, n-target_scores.size(1)) + zeros_to_add = zeros_to_add.to(device) + targets_norm = torch.cat([targets_norm, zeros_to_add], dim=1) + + # Calculate distillation loss (see e.g., Li and Hoiem, 2017) + KD_loss_unnorm = -( targets_norm * torch.log(scores_norm) + (1-targets_norm) * torch.log(1-scores_norm) ) + + # Sum over the prob-scores of all classes (1) and then average over all elements in the batch (2) + KD_loss_unnorm = KD_loss_unnorm.sum(dim=1) #-> sum over classes + KD_loss_unnorm = weighted_average(KD_loss_unnorm, weights=weights, dim=0) #-> average over batch + + # Normalize + KD_loss = (KD_loss_unnorm * T**2) if norm else KD_loss_unnorm + + + return KD_loss + + +##-------------------------------------------------------------------------------------------------------------------## + +###################### +## Helper functions ## +###################### + +def weighted_average(tensor, weights=None, dim=0): + '''Computes weighted average of [tensor] over dimension [dim].''' + if weights is None: + mean = torch.mean(tensor, dim=dim) + else: + batch_size = tensor.size(dim) if len(tensor.size())>0 else 1 + assert len(weights)==batch_size + #sum_weights = sum(weights) + #norm_weights = torch.Tensor([weight/sum_weights for weight in weights]).to(tensor.device) + norm_weights = torch.tensor([weight for weight in weights]).to(tensor.device) + mean = torch.mean(norm_weights*tensor, dim=dim) + return mean + +def to_one_hot(y, classes, device=None): + '''Convert or with integers [y] to a 2D "one-hot" .''' + if type(y)==torch.Tensor: + device=y.device + y = y.cpu() + c = np.zeros(shape=[len(y), classes], dtype='float32') + c[range(len(y)), y] = 1. + c = torch.from_numpy(c) + return c if device is None else c.to(device) + + +##-------------------------------------------------------------------------------------------------------------------## + +######################################################## +## Calculate log-likelihood for various distributions ## +######################################################## + +def log_Normal_standard(x, mean=0, average=False, dim=None): + '''Calculate log-likelihood of sample [x] under Gaussian distribution(s) with mu=[mean], diag_var=I. + NOTES: [dim]=-1 summing / averaging over all but the first dimension + [dim]=None summing / averaging is done over all dimensions''' + log_normal = -0.5 * torch.pow(x-mean, 2) + if dim is not None and dim == -1: + log_normal = log_normal.view(log_normal.size(0), -1) + dim = 1 + if average: + return torch.mean(log_normal, dim) if dim is not None else torch.mean(log_normal) + else: + return torch.sum(log_normal, dim) if dim is not None else torch.sum(log_normal) + +def log_Normal_diag(x, mean, log_var, average=False, dim=None): + '''Calculate log-likelihood of sample [x] under Gaussian distribution(s) with mu=[mean], diag_var=exp[log_var]. + NOTES: [dim]=-1 summing / averaging over all but the first dimension + [dim]=None summing / averaging is done over all dimensions''' + log_normal = -0.5 * (log_var + torch.pow(x-mean, 2) / torch.exp(log_var)) + if dim is not None and dim==-1: + log_normal = log_normal.view(log_normal.size(0), -1) + dim = 1 + if average: + return torch.mean(log_normal, dim) if dim is not None else torch.mean(log_normal) + else: + return torch.sum(log_normal, dim) if dim is not None else torch.sum(log_normal) + +def log_Bernoulli(x, mean, average=False, dim=None): + '''Calculate log-likelihood of sample [x] under Bernoulli distribution(s) with mu=[mean]. + NOTES: [dim]=-1 summing / averaging over all but the first dimension + [dim]=None summing / averaging is done over all dimensions''' + probs = torch.clamp(mean, min=1e-5, max=1.-1e-5) + log_bernoulli = x*torch.log(probs) + (1. - x)*torch.log(1. - probs) + if dim is not None and dim==-1: + log_bernoulli = log_bernoulli.view(log_bernoulli.size(0), -1) + dim = 1 + if average: + return torch.mean(log_bernoulli, dim) if dim is not None else torch.mean(log_bernoulli) + else: + return torch.sum(log_bernoulli, dim) if dim is not None else torch.sum(log_bernoulli) + +##-------------------------------------------------------------------------------------------------------------------## \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/utils/modules.py b/PyTorch/build-in/other/continual-learning/models/utils/modules.py new file mode 100644 index 000000000..56f3343b8 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/utils/modules.py @@ -0,0 +1,68 @@ +import numpy as np +from torch import nn + + +##-------------------------------------------------------------------------------------------------------------------## + +################################# +## Custom-written "nn-Modules" ## +################################# + +class Identity(nn.Module): + '''A nn-module to simply pass on the input data.''' + def forward(self, x): + return x + + def __repr__(self): + tmpstr = self.__class__.__name__ + '()' + return tmpstr + + +class Shape(nn.Module): + '''A nn-module to shape a tensor of shape [shape].''' + def __init__(self, shape): + super().__init__() + self.shape = shape + self.dim = len(shape) + + def forward(self, x): + return x.view(*self.shape) + + def __repr__(self): + tmpstr = self.__class__.__name__ + '(shape = {})'.format(self.shape) + return tmpstr + + +class Reshape(nn.Module): + '''A nn-module to reshape a tensor(-tuple) to a 4-dim "image"-tensor(-tuple) with [image_channels] channels.''' + def __init__(self, image_channels): + super().__init__() + self.image_channels = image_channels + + def forward(self, x): + if type(x)==tuple: + batch_size = x[0].size(0) # first dimenstion should be batch-dimension. + image_size = int(np.sqrt(x[0].nelement() / (batch_size*self.image_channels))) + return (x_item.view(batch_size, self.image_channels, image_size, image_size) for x_item in x) + else: + batch_size = x.size(0) # first dimenstion should be batch-dimension. + image_size = int(np.sqrt(x.nelement() / (batch_size*self.image_channels))) + return x.view(batch_size, self.image_channels, image_size, image_size) + + def __repr__(self): + tmpstr = self.__class__.__name__ + '(channels = {})'.format(self.image_channels) + return tmpstr + + +class Flatten(nn.Module): + '''A nn-module to flatten a multi-dimensional tensor to 2-dim tensor.''' + def forward(self, x): + batch_size = x.size(0) # first dimenstion should be batch-dimension. + return x.view(batch_size, -1) + + def __repr__(self): + tmpstr = self.__class__.__name__ + '()' + return tmpstr + + +##-------------------------------------------------------------------------------------------------------------------## \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/models/utils/ncl.py b/PyTorch/build-in/other/continual-learning/models/utils/ncl.py new file mode 100644 index 000000000..44fd94d8f --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/utils/ncl.py @@ -0,0 +1,24 @@ +"""NCL utility functions""" +import torch + +def additive_nearest_kf(B, C): + """Here it is assumed that all these matrices are symmetric, which is NOT CHECKED explicitly""" + BR, BL = B["A"], B["G"] + CR, CL = C["A"], C["G"] + + trBL, trBR, trCL, trCR = ( + torch.trace(BL), + torch.trace(BR), + torch.trace(CL), + torch.trace(CR), + ) + if min(trBL, trBR) <= 0: + print("zero trace!") + return CR, CL + elif min(trCL, trCR) <= 0: + print("zero trace!") + return BR, BL + + pi = torch.sqrt(torch.trace(BL) * torch.trace(CR)) / torch.sqrt(torch.trace(CL) * torch.trace(BR)) + + return BR + CR / pi, BL + CL * pi diff --git a/PyTorch/build-in/other/continual-learning/models/vae.py b/PyTorch/build-in/other/continual-learning/models/vae.py new file mode 100644 index 000000000..6397aaeaa --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/models/vae.py @@ -0,0 +1,535 @@ +import numpy as np +import math +import torch +from torch import nn +from torch.nn import functional as F +from models.fc.layers import fc_layer,fc_layer_split +from models.fc.nets import MLP +from models.conv.nets import ConvLayers,DeconvLayers +from models.cl.continual_learner import ContinualLearner +from models.utils import loss_functions as lf, modules + + +class VAE(ContinualLearner): + """Class for variational auto-encoder (VAE) model.""" + + def __init__(self, image_size, image_channels, + # -conv-layers + conv_type="standard", depth=0, start_channels=64, reducing_layers=3, conv_bn=True, conv_nl="relu", + num_blocks=2, global_pooling=False, no_fnl=True, conv_gated=False, + # -fc-layers + fc_layers=3, fc_units=1000, fc_drop=0, fc_bn=False, fc_nl="relu", fc_gated=False, excit_buffer=False, + # -prior + prior="standard", z_dim=20, n_modes=1, + # -decoder + recon_loss='BCE', network_output="sigmoid", deconv_type="standard", **kwargs): + '''Class for variational auto-encoder (VAE) models.''' + + # Set configurations for setting up the model + super().__init__() + self.label = "VAE" + self.image_size = image_size + self.image_channels = image_channels + self.fc_layers = fc_layers + self.z_dim = z_dim + self.fc_units = fc_units + self.fc_drop = fc_drop + self.depth = depth + # -type of loss to be used for reconstruction + self.recon_loss = recon_loss # options: BCE|MSE + self.network_output = network_output + + # Optimizer (needs to be set before training starts)) + self.optimizer = None + self.optim_list = [] + + # Prior-related parameters + self.prior = prior + self.n_modes = n_modes + + # Weigths of different components of the loss function + self.lamda_rcl = 1. + self.lamda_vl = 1. + + self.average = True #--> makes that [reconL] and [variatL] are both divided by number of input-pixels + + # Check whether there is at least 1 fc-layer + if fc_layers<1: + raise ValueError("VAE cannot have 0 fully-connected layers!") + + + ######------SPECIFY MODEL------###### + + ##>----Encoder (= q[z|x])----<## + self.convE = ConvLayers(conv_type=conv_type, block_type="basic", num_blocks=num_blocks, + image_channels=image_channels, depth=self.depth, start_channels=start_channels, + reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, + output="none" if no_fnl else "normal", global_pooling=global_pooling, + gated=conv_gated) + # -flatten image to 2D-tensor + self.flatten = modules.Flatten() + #------------------------------calculate input/output-sizes--------------------------------# + self.conv_out_units = self.convE.out_units(image_size) + self.conv_out_size = self.convE.out_size(image_size) + self.conv_out_channels = self.convE.out_channels + #------------------------------------------------------------------------------------------# + # -fully connected hidden layers + self.fcE = MLP(input_size=self.conv_out_units, output_size=fc_units, layers=fc_layers-1, + hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, gated=fc_gated, + excit_buffer=excit_buffer) + mlp_output_size = fc_units if fc_layers > 1 else self.conv_out_units + # -to z + self.toZ = fc_layer_split(mlp_output_size, z_dim, nl_mean='none', nl_logvar='none') + + ##>----Decoder (= p[x|z])----<## + out_nl = True if fc_layers > 1 else (True if (self.depth > 0 and not no_fnl) else False) + real_h_dim_down = fc_units if fc_layers > 1 else self.convE.out_units(image_size, ignore_gp=True) + self.fromZ = fc_layer(z_dim, real_h_dim_down, batch_norm=(out_nl and fc_bn), nl=fc_nl if out_nl else "none") + # -> if 'gp' is used in forward pass, size of first/final hidden layer differs between forward and backward pass + self.fcD = MLP(input_size=fc_units, output_size=self.convE.out_units(image_size, ignore_gp=True), + layers=fc_layers-1, hid_size=fc_units, drop=fc_drop, batch_norm=fc_bn, nl=fc_nl, + gated=fc_gated, output=self.network_output if self.depth==0 else 'normal') + # to image-shape + self.to_image = modules.Reshape(image_channels=self.convE.out_channels if self.depth>0 else image_channels) + # through deconv-layers + self.convD = DeconvLayers( + image_channels=image_channels, final_channels=start_channels, depth=self.depth, + reducing_layers=reducing_layers, batch_norm=conv_bn, nl=conv_nl, gated=conv_gated, + output=self.network_output, deconv_type=deconv_type, + ) + + ##>----Prior----<## + # -if using the GMM-prior, add its parameters + if self.prior=="GMM": + # -create + self.z_class_means = nn.Parameter(torch.Tensor(self.n_modes, self.z_dim)) + self.z_class_logvars = nn.Parameter(torch.Tensor(self.n_modes, self.z_dim)) + # -initialize + self.z_class_means.data.normal_() + self.z_class_logvars.data.normal_() + + # Flags whether parts of the network are frozen (so they can be set to evaluation mode during training) + self.convE.frozen = False + self.fcE.frozen = False + + + + ##------ NAMES --------## + + def get_name(self): + convE_label = "{}--".format(self.convE.name) if self.depth>0 else "" + fcE_label = "{}--".format(self.fcE.name) if self.fc_layers>1 else "{}{}-".format("h" if self.depth>0 else "i", + self.conv_out_units) + z_label = "z{}{}".format(self.z_dim, "" if self.prior=="standard" else "-{}{}".format(self.prior, self.n_modes)) + decoder_label = "--{}".format(self.network_output) + return "{}={}{}{}{}".format(self.label, convE_label, fcE_label, z_label, decoder_label) + + @property + def name(self): + return self.get_name() + + + + ##------ LAYERS --------## + + def list_init_layers(self): + '''Return list of modules whose parameters could be initialized differently (i.e., conv- or fc-layers).''' + list = [] + list += self.convE.list_init_layers() + list += self.fcE.list_init_layers() + list += self.toZ.list_init_layers() + list += self.fromZ.list_init_layers() + list += self.fcD.list_init_layers() + list += self.convD.list_init_layers() + return list + + def layer_info(self): + '''Return list with shape of all hidden layers.''' + # create list with hidden convolutional layers + layer_list = self.convE.layer_info(image_size=self.image_size) + # add output of final convolutional layer (if there was at least one conv-layer and there's fc-layers after) + if (self.fc_layers>0 and self.depth>0): + layer_list.append([self.conv_out_channels, self.conv_out_size, self.conv_out_size]) + # add layers of the MLP + if self.fc_layers>1: + for layer_id in range(1, self.fc_layers): + layer_list.append([self.fc_layer_sizes[layer_id]]) + return layer_list + + + + ##------ FORWARD FUNCTIONS --------## + + def encode(self, x): + '''Pass input through feed-forward connections, to get [z_mean], [z_logvar] and [hE].''' + # Forward-pass through conv-layers + hidden_x = self.convE(x) + image_features = self.flatten(hidden_x) + # Forward-pass through fc-layers + hE = self.fcE(image_features) + # Get parameters for reparametrization + (z_mean, z_logvar) = self.toZ(hE) + return z_mean, z_logvar, hE, hidden_x + + def reparameterize(self, mu, logvar): + '''Perform "reparametrization trick" to make these stochastic variables differentiable.''' + std = logvar.mul(0.5).exp_() + eps = std.new(std.size()).normal_()#.requires_grad_() + return eps.mul(std).add_(mu) + + def decode(self, z): + '''Decode latent variable activations [z] (=<2D-tensor>) into [image_recon] (=<4D-tensor>).''' + hD = self.fromZ(z) + image_features = self.fcD(hD) + image_recon = self.convD(self.to_image(image_features)) + return image_recon + + def forward(self, x, full=False, reparameterize=True, **kwargs): + '''Forward function to propagate [x] through the encoder, reparametrization and decoder. + + Input: - [x] <4D-tensor> of shape [batch_size]x[channels]x[image_size]x[image_size] + + If [full] is True, output should be a consisting of: + - [x_recon] <4D-tensor> reconstructed image (features) in same shape as [x] (or 2 of those: mean & logvar) + - [mu] <2D-tensor> with either [z] or the estimated mean of [z] + - [logvar] None or <2D-tensor> estimated log(SD^2) of [z] + - [z] <2D-tensor> reparameterized [z] used for reconstruction + If [full] is False, output is the reconstructed image (i.e., [x_recon]). + ''' + # -encode (forward), reparameterize and decode (backward) + mu, logvar, hE, hidden_x = self.encode(x) + z = self.reparameterize(mu, logvar) if reparameterize else mu + x_recon = self.decode(z) + # -return + return (x_recon, mu, logvar, z) if full else x_recon + + def feature_extractor(self, images): + '''Extract "final features" (i.e., after both conv- and fc-layers of forward pass) from provided images.''' + return self.fcE(self.flatten(self.convE(images))) + + + + ##------ SAMPLE FUNCTIONS --------## + + def sample(self, size, sample_mode=None, **kwargs): + '''Generate [size] samples from the model. Outputs are tensors (not "requiring grad"), on same device as . + + INPUT: - [sample_mode] to sample from specific mode of [z]-distribution + + OUTPUT: - [X] <4D-tensor> generated images / image-features''' + + # set model to eval()-mode + self.eval() + + # pick for each sample the prior-mode to be used + if self.prior=="GMM": + if sample_mode is None: + # -randomly sample modes from all possible modes + sampled_modes = np.random.randint(0, self.n_modes, size) + else: + # -always sample from the provided mode + sampled_modes = np.repeat(sample_mode, size) + + # sample z + if self.prior=="GMM": + prior_means = self.z_class_means + prior_logvars = self.z_class_logvars + # -for each sample to be generated, select the previously sampled mode + z_means = prior_means[sampled_modes, :] + z_logvars = prior_logvars[sampled_modes, :] + with torch.no_grad(): + z = self.reparameterize(z_means, z_logvars) + else: + z = torch.randn(size, self.z_dim).to(self._device()) + + # decode z into image X + with torch.no_grad(): + X = self.decode(z) + + # return samples as [batch_size]x[channels]x[image_size]x[image_size] tensor + return X + + + + ##------ LOSS FUNCTIONS --------## + + def calculate_recon_loss(self, x, x_recon, average=False): + '''Calculate reconstruction loss for each element in the batch. + + INPUT: - [x] with original input (1st dimension (ie, dim=0) is "batch-dimension") + - [x_recon] (tuple of 2x) with reconstructed input in same shape as [x] + - [average] , if True, loss is average over all pixels; otherwise it is summed + + OUTPUT: - [reconL] <1D-tensor> of length [batch_size]''' + + batch_size = x.size(0) + if self.recon_loss=="MSE": + # reconL = F.mse_loss(input=x_recon.view(batch_size, -1), target=x.view(batch_size, -1), reduction='none') + # reconL = torch.mean(reconL, dim=1) if average else torch.sum(reconL, dim=1) + reconL = -lf.log_Normal_standard(x=x, mean=x_recon, average=average, dim=-1) + elif self.recon_loss=="BCE": + reconL = F.binary_cross_entropy(input=x_recon.view(batch_size, -1), target=x.view(batch_size, -1), + reduction='none') + reconL = torch.mean(reconL, dim=1) if average else torch.sum(reconL, dim=1) + else: + raise NotImplementedError("Wrong choice for type of reconstruction-loss!") + # --> if [average]=True, reconstruction loss is averaged over all pixels/elements (otherwise it is summed) + # (averaging over all elements in the batch will be done later) + return reconL + + + def calculate_log_p_z(self, z): + '''Calculate log-likelihood of sampled [z] under the prior distribution. + + INPUT: - [z] <2D-tensor> with sampled latent variables (1st dimension (ie, dim=0) is "batch-dimension") + + OUTPUT: - [log_p_z] <1D-tensor> of length [batch_size]''' + + if self.prior == "standard": + log_p_z = lf.log_Normal_standard(z, average=False, dim=1) # [batch_size] + + if self.prior == "GMM": + ## Get [means] and [logvars] of all (possible) modes + allowed_modes = list(range(self.n_modes)) + # -calculate/retireve the means and logvars for the selected modes + prior_means = self.z_class_means[allowed_modes, :] + prior_logvars = self.z_class_logvars[allowed_modes, :] + # -rearrange / select for each batch prior-modes to be used + z_expand = z.unsqueeze(1) # [batch_size] x 1 x [z_dim] + means = prior_means.unsqueeze(0) # 1 x [n_modes] x [z_dim] + logvars = prior_logvars.unsqueeze(0) # 1 x [n_modes] x [z_dim] + + ## Calculate "log_p_z" (log-likelihood of "reparameterized" [z] based on selected priors) + n_modes = len(allowed_modes) + a = lf.log_Normal_diag(z_expand, mean=means, log_var=logvars, average=False, dim=2) - math.log(n_modes) + # --> for each element in batch, calculate log-likelihood for all pseudoinputs: [batch_size] x [n_modes] + a_max, _ = torch.max(a, dim=1) # [batch_size] + # --> for each element in batch, take highest log-likelihood over all pseudoinputs + # this is calculated and used to avoid underflow in the below computation + a_exp = torch.exp(a - a_max.unsqueeze(1)) # [batch_size] x [n_modes] + a_logsum = torch.log(torch.clamp(torch.sum(a_exp, dim=1), min=1e-40)) # -> sum over modes: [batch_size] + log_p_z = a_logsum + a_max # [batch_size] + + return log_p_z + + + def calculate_variat_loss(self, z, mu, logvar): + '''Calculate reconstruction loss for each element in the batch. + + INPUT: - [z] <2D-tensor> with sampled latent variables (1st dimension (ie, dim=0) is "batch-dimension") + - [mu] <2D-tensor> by encoder predicted mean for [z] + - [logvar] <2D-tensor> by encoder predicted logvar for [z] + + OUTPUT: - [variatL] <1D-tensor> of length [batch_size]''' + + if self.prior == "standard": + # --> calculate analytically + # ---- see Appendix B from: Kingma & Welling (2014) Auto-Encoding Variational Bayes, ICLR ----# + variatL = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1) + + elif self.prior=="GMM": + # --> calculate "by estimation" + + ## Calculate "log_p_z" (log-likelihood of "reparameterized" [z] based on selected priors) + log_p_z = self.calculate_log_p_z(z) + # -----> log_p_z: [batch_size] + + ## Calculate "log_q_z_x" (entropy of "reparameterized" [z] given [x]) + log_q_z_x = lf.log_Normal_diag(z, mean=mu, log_var=logvar, average=False, dim=1) + # -----> mu: [batch_size] x [z_dim]; logvar: [batch_size] x [z_dim]; z: [batch_size] x [z_dim] + # -----> log_q_z_x: [batch_size] + + ## Combine + variatL = -(log_p_z - log_q_z_x) + + return variatL + + + def loss_function(self, x, x_recon, mu, z, logvar=None, batch_weights=None): + '''Calculate and return various losses that could be used for training and/or evaluating the model. + + INPUT: - [x] <4D-tensor> original image + - [x_recon] (tuple of 2x) <4D-tensor> reconstructed image in same shape as [x] + - [mu] <2D-tensor> with either [z] or the estimated mean of [z] + - [z] <2D-tensor> with reparameterized [z] + - [logvar] None or <2D-tensor> with estimated log(SD^2) of [z] + - [batch_weights] <1D-tensor> with a weight for each batch-element (if None, normal average over batch) + + OUTPUT: - [reconL] reconstruction loss indicating how well [x] and [x_recon] match + - [variatL] variational (KL-divergence) loss "indicating how close distribion [z] is to prior" + ''' + + ###-----Reconstruction loss-----### + batch_size = x.size(0) + x_recon = (x_recon[0].view(batch_size, -1), x_recon[1].view(batch_size, -1)) if self.network_output=='split' else x_recon.view(batch_size, -1) + reconL = self.calculate_recon_loss(x=x.view(batch_size, -1), average=True, x_recon=x_recon)#-average over pixels + reconL = lf.weighted_average(reconL, weights=batch_weights, dim=0) #-average over batch + + ###-----Variational loss-----### + if logvar is not None: + variatL = self.calculate_variat_loss(z=z, mu=mu, logvar=logvar) + variatL = lf.weighted_average(variatL, weights=batch_weights, dim=0) # -> average over batch + variatL /= (self.image_channels * self.image_size ** 2) # -> divide by # of input-pixels + else: + variatL = torch.tensor(0., device=self._device()) + + # Return a tuple of the calculated losses + return reconL, variatL + + + + ##------ EVALUATION FUNCTIONS --------## + + def get_latent_lls(self, x): + '''Encode [x] as [z!x] and return log-likelihood. + + Input: - [x] <4D-tensor> of shape [batch]x[channels]x[image_size]x[image_size] + + Output: - [log_likelihood] <1D-tensor> of shape [batch] + ''' + + # Run forward pass of model to get [z_mu] and [z_logvar] + z_mu, z_logvar, _, _ = self.encode(x) + + # Calculate log_p_z + log_p_z = self.calculate_log_p_z(z_mu) + + ## NOTE: we could additionally use [z_logvar] and compute KL-divergence with prior? + return log_p_z + + + def estimate_lls(self, x, S='mean', importance=True): + '''Estimate log-likelihood for [x] using [S] importance samples (or Monte Carlo samples, if [importance]=False). + + Input: - [x] <4D-tensor> of shape [batch]x[channels]x[image_size]x[image_size] + - [S] (= # importance samples) or 'mean' (= use [z_mu] as single importance sample) + - [importance] if True do importance sampling, otherwise do Monte Carlo sampling + + Output: - [log_likelihood] <1D-tensor> of shape [batch] + ''' + # Run forward pass of model to get [z_mu] and [z_logvar] + if importance: + z_mu, z_logvar, _, _ = self.encode(x) + + if S=='mean': + if importance: + # --> Use [z_mu] as a 'single importance sample' + # Calculate log_p_z + log_p_z = self.calculate_log_p_z(z_mu) + # Calculate log_q_z_x + z_mu_dummy = torch.zeros_like(z_mu) # to avoid unnecessary gradient tracking in next computation + log_q_z_x = lf.log_Normal_diag(z_mu_dummy, mean=z_mu_dummy, log_var=z_logvar, average=False, dim=1) + else: + # --> Use the overall prior mean as a 'single Monte Carlo sample' + if self.prior=="GMM": + sampled_modes = np.random.randint(0, self.n_modes, x.size(0)) + z_mu = self.z_class_means[sampled_modes, :] + ## NOTE: if using a GMM-prior with multiple modes, this does not really make sense!!! + else: + z_mu = torch.zeros(x.size(0), self.z_dim).to(self._device()) + # Calcuate p_x_z + # -reconstruct input + x_recon = self.decode(z_mu) + # -calculate p_x_z (under Gaussian observation model with unit variance) + log_p_x_z = lf.log_Normal_standard(x=x, mean=x_recon, average=False, dim=-1) + # Calculate log-likelihood + log_likelihood = (log_p_x_z + log_p_z - log_q_z_x) if importance else log_p_x_z + else: + #--> Use [S] importance/Monte Carlo samples + # Define tensor in which to store the log-likelihoods of each sample + all_lls = torch.zeros([S, x.size(0)], dtype=torch.float32, device=self._device()) + # For each sample, calculate log_likelihood + for s_id in range(S): + if importance: + # Reparameterize (i.e., sample z_s) + z = self.reparameterize(z_mu, z_logvar) + # Calculate log_p_z + log_p_z = self.calculate_log_p_z(z) + # Calculate log_q_z_x + log_q_z_x = lf.log_Normal_diag(z, mean=z_mu, log_var=z_logvar, average=False, dim=1) + else: + # Sample z_s + if self.prior == "GMM": + # -randomly pick for each sample the prior-mode to be used + sampled_modes = np.random.randint(0, self.n_modes, x.size(0)) + # -for each sample to be generated, select the mean & logvar for the sampled mode + z_means = self.z_class_means[sampled_modes, :] + z_logvars = self.z_class_logvars[sampled_modes, :] + # -sample using the selected means & logvars + z = self.reparameterize(z_means, z_logvars) + else: + # -sample from standard normal distribution + z = torch.randn(x.size(0), self.z_dim).to(self._device()) + # Calcuate p_x_z + # -reconstruct input + x_recon = self.decode(z) + # -calculate p_x_z (under Gaussian observation model with unit variance) + log_p_x_z = lf.log_Normal_standard(x=x, mean=x_recon, average=False, dim=-1) + # Calculate log-likelihoods for this importance sample + all_lls[s_id] = (log_p_x_z + log_p_z - log_q_z_x) if importance else log_p_x_z + # Calculate average log-likelihood over all (importance) samples for this test sample + # (for this, convert log-likelihoods back to likelihoods before summing them!) + log_likelihood = all_lls.logsumexp(dim=0) - np.log(S) + return log_likelihood + + + + ##------ TRAINING FUNCTIONS --------## + + def train_a_batch(self, x, x_=None, rnt=0.5, **kwargs): + '''Train model for one batch ([x]), possibly supplemented with replayed data ([x_]). + + [x] batch of inputs (could be None, in which case only 'replayed' data is used) + [x_] None or ( of) batch of replayed inputs + [rnt] in [0,1], relative importance of new context + ''' + + # Set model to training-mode + self.train() + # -however, if some layers are frozen, they should be set to eval() to prevent batch-norm layers from changing + if self.convE.frozen: + self.convE.eval() + if self.fcE.frozen: + self.fcE.eval() + + # Reset optimizer + self.optimizer.zero_grad() + + ##--(1)-- CURRENT DATA --## + if x is not None: + # Run the model + recon_batch, mu, logvar, z = self(x, full=True, reparameterize=True) + + # Calculate losses + reconL, variatL = self.loss_function(x=x, x_recon=recon_batch, mu=mu, z=z, logvar=logvar) + + # Weigh losses as requested + loss_cur = self.lamda_rcl*reconL + self.lamda_vl*variatL + + ##--(2)-- REPLAYED DATA --## + if x_ is not None: + # Run the model + recon_batch, mu, logvar, z = self(x_, full=True, reparameterize=True) + + # Calculate losses + reconL_r, variatL_r = self.loss_function(x=x_, x_recon=recon_batch, mu=mu, z=z, logvar=logvar) + + # Weigh losses as requested + loss_replay = self.lamda_rcl*reconL_r + self.lamda_vl*variatL_r + + # Calculate total loss + loss_total = loss_replay if (x is None) else (loss_cur if x_ is None else rnt*loss_cur+(1-rnt)*loss_replay) + + # Backpropagate errors + loss_total.backward() + # Take optimization-step + self.optimizer.step() + + # Return the dictionary with different training-loss split in categories + return { + 'loss_total': loss_total.item(), + 'recon': reconL.item() if x is not None else 0, + 'variat': variatL.item() if x is not None else 0, + 'recon_r': reconL_r.item() if x_ is not None else 0, + 'variat_r': variatL_r.item() if x_ is not None else 0, + } diff --git a/PyTorch/build-in/other/continual-learning/params/__init__.py b/PyTorch/build-in/other/continual-learning/params/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/params/options.py b/PyTorch/build-in/other/continual-learning/params/options.py new file mode 100644 index 000000000..76d5559e4 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/params/options.py @@ -0,0 +1,351 @@ +import argparse + +##-------------------------------------------------------------------------------------------------------------------## + +# Where to store the data / results / models / plots +store = "./store" + +##-------------------------------------------------------------------------------------------------------------------## + +#################### +## Define options ## +#################### + +def define_args(filename, description): + parser = argparse.ArgumentParser('./{}.py'.format(filename), description=description) + return parser + +def add_general_options(parser, main=False, comparison=False, compare_hyper=False, pretrain=False, **kwargs): + if main: + parser.add_argument('--get-stamp', action='store_true', help='print param-stamp & exit') + parser.add_argument('--seed', type=int, default=0, help='[first] random seed (for each random-module used)') + if comparison and (not compare_hyper): + parser.add_argument('--n-seeds', type=int, default=1, help='how often to repeat?') + parser.add_argument('--no-gpus', action='store_false', dest='gpu', help="don't use GPUs") + parser.add_argument('--no-save', action='store_false', dest='save', help="don't save trained models") + parser.add_argument('--full-stag', type=str, metavar='STAG', default='none', help="tag for saving full model") + parser.add_argument('--full-ltag', type=str, metavar='LTAG', default='none', help="tag for loading full model") + if pretrain: + parser.add_argument('--convE-stag', type=str, metavar='STAG', default='none', + help="tag for saving convE-layers") + parser.add_argument('--seed-to-stag', action='store_true', help="add seed to tag for saving convE-layers") + if main: + parser.add_argument('--test', action='store_false', dest='train', help='evaluate previously saved model') + parser.add_argument('--data-dir', type=str, default='{}/datasets'.format(store), dest='d_dir', + help="default: %(default)s") + parser.add_argument('--model-dir', type=str, default='{}/models'.format(store), dest='m_dir', + help="default: %(default)s") + if not pretrain: + parser.add_argument('--plot-dir', type=str, default='{}/plots'.format(store), dest='p_dir', + help="default: %(default)s") + parser.add_argument('--results-dir', type=str, default='{}/results'.format(store), dest='r_dir', + help="default: %(default)s") + return parser + +##-------------------------------------------------------------------------------------------------------------------## + +def add_eval_options(parser, main=False, comparison=False, pretrain=False, compare_replay=False, no_boundaries=False, + **kwargs): + eval_params = parser.add_argument_group('Evaluation Parameters') + if not pretrain: + eval_params.add_argument('--time', action='store_true', help="keep track of total training time") + if main: + eval_params.add_argument('--pdf', action='store_true', help="generate pdf with results") + eval_params.add_argument('--visdom', action='store_true', help="use visdom for on-the-fly plots") + eval_params.add_argument('--results-dict', action='store_true', help="output dict with results after each task") + if not comparison: + eval_params.add_argument('--loss-log', type=int, metavar="N", + help="# iters after which to plot loss (def: # iters)") + eval_params.add_argument('--acc-log', type=int, metavar="N", + help="# iters after which to plot accuracy (def: # iters)") + eval_params.add_argument('--acc-n', type=int, default=1024, + help="# samples to evaluate accuracy (after each context)") + if (not no_boundaries) and (not comparison) and (not pretrain): + eval_params.add_argument('--sample-log', type=int, metavar="N", + help="# iters after which to plot samples (def: # iters)") + if (not no_boundaries) and (not pretrain) and (not compare_replay): + eval_params.add_argument('--sample-n', type=int, default=64, help="# images to show") + eval_params.add_argument('--no-samples', action='store_true', help="don't plot generated images") + return parser + +##-------------------------------------------------------------------------------------------------------------------## + +def add_problem_options(parser, pretrain=False, no_boundaries=False, **kwargs): + problem_params = parser.add_argument_group('Problem Specification') + cl_protocols = ['splitMNIST', 'permMNIST', 'CIFAR10', 'CIFAR100'] + problem_params.add_argument('--experiment', type=str, default='CIFAR10' if pretrain else 'splitMNIST', + choices=['CIFAR10', 'CIFAR100', 'MNIST', 'MNIST32'] if pretrain else cl_protocols) + if no_boundaries: + problem_params.add_argument('--stream', type=str, default='fuzzy-boundaries', + choices=['fuzzy-boundaries', 'academic-setting', 'random']) + problem_params.add_argument('--fuzziness', metavar='ITERS', type=int, default=500, help='amount of fuzziness') + if not pretrain: + problem_params.add_argument('--scenario', type=str, default='class', choices=['task', 'domain', 'class']) + problem_params.add_argument('--contexts', type=int, metavar='N', help='number of contexts') + problem_params.add_argument('--iters', type=int, help="# iterations (mini-batches) per context") + problem_params.add_argument('--batch', type=int, help="mini batch size (# observations per iteration)") + if pretrain: + problem_params.add_argument('--augment', action='store_true', + help="augment training data (random crop & horizontal flip)") + problem_params.add_argument('--no-norm', action='store_false', dest='normalize', + help="don't normalize images (only for CIFAR)") + return parser + +##-------------------------------------------------------------------------------------------------------------------## + +def add_model_options(parser, pretrain=False, compare_replay=False, **kwargs): + model = parser.add_argument_group('Parameters Main Model') + # 'Convenience-commands' that select the defaults for specific architectures + model.add_argument('--reducedResNet', action='store_true', help="select defaults for 'Reduced ResNet-18' (e.g., as in Hess et al, 2023)") + # -convolutional layers + model.add_argument('--conv-type', type=str, default="standard", choices=["standard", "resNet"]) + model.add_argument('--n-blocks', type=int, default=2, help="# blocks per conv-layer (only for 'resNet')") + model.add_argument('--depth', type=int, default=None, help="# of convolutional layers (0 = only fc-layers)") + model.add_argument('--reducing-layers', type=int, dest='rl', default=None, + help="# of layers with stride (=image-size halved)") + model.add_argument('--channels', type=int, default=None, help="# of channels 1st conv-layer (doubled every 'rl')") + model.add_argument('--conv-bn', type=str, default="yes", help="use batch-norm in the conv-layers (yes|no)") + model.add_argument('--conv-nl', type=str, default="relu", choices=["relu", "leakyrelu"]) + model.add_argument('--global-pooling', action='store_true', dest='gp', help="ave global pool after conv-layers") + # -fully connected layers + model.add_argument('--fc-layers', type=int, default=None, dest='fc_lay', help="# of fully-connected layers") + model.add_argument('--fc-units', type=int, metavar="N", help="# of units in hidden fc-layers") + model.add_argument('--fc-drop', type=float, default=0., help="dropout probability for fc-units") + model.add_argument('--fc-bn', type=str, default="no", help="use batch-norm in the fc-layers (no|yes)") + model.add_argument('--fc-nl', type=str, default="relu", choices=["relu", "leakyrelu", "none"]) + if (not pretrain) and (not compare_replay): + model.add_argument('--z-dim', type=int, default=100, help='size of latent representation (if used, def=100)') + if not pretrain: + model.add_argument('--singlehead', action='store_true', + help="for Task-IL: use a 'single-headed' output layer (instead of a 'multi-headed' one)") + return parser + +##-------------------------------------------------------------------------------------------------------------------## + +def add_train_options(parser, main=False, no_boundaries=False, pretrain=False, compare_replay=False, **kwargs): + + ## Training hyperparameters + train_params = parser.add_argument_group('Training Parameters') + if pretrain: + iter_epochs = train_params.add_mutually_exclusive_group(required=False) + iter_epochs.add_argument('--epochs', type=int, default=10, metavar='N', help='# epochs (default: %(default)d)') + iter_epochs.add_argument('--iters', type=int, metavar='N', help='# iterations (replaces "--epochs")') + train_params.add_argument('--batch', type=int, help="mini batch size") + train_params.add_argument('--lr', type=float, help="learning rate") + if not pretrain: + train_params.add_argument('--optimizer', type=str, default='adam', + choices=['adam', 'sgd'] if no_boundaries else ['adam', 'adam_reset', 'sgd']) + train_params.add_argument("--momentum", type=float, default=0., help="momentum (if using SGD optimizer)") + # -initialization / pretraining + train_params.add_argument('--pre-convE', action='store_true', help="use pretrained convE-layers") + train_params.add_argument('--convE-ltag', type=str, metavar='LTAG', default='e100', + help="tag for loading convE-layers") + train_params.add_argument('--seed-to-ltag', action='store_true', help="add seed to tag when loading convE-layers") + train_params.add_argument('--freeze-convE', action='store_true', help="freeze convE-layers") + # -for Class-IL, which output units should be set to 'active'? + if (not pretrain) and (not no_boundaries): + train_params.add_argument('--active-classes', type=str, default='all', choices=["all", "all-so-far", "current"], + dest='neg_samples', help="for Class-IL: which classes to set to 'active'?") + #--> the above command controls which output units will be set to "active" (the active classes can also + # be thought of as 'negative classes', see Li et al., 2020, https://arxiv.org/abs/2011.12216): + # - "all-so-far": the output units of all classes seen so far are set to active + # - "all": always the output units of all classes are set to active + # - "current": only output units of the classes in the current context are set to active + + ## Loss function(s) to be used + if (not pretrain) and (not compare_replay): + loss_params = parser.add_argument_group('Loss Parameters') + loss_params.add_argument('--recon-loss', type=str, choices=['MSE', 'BCE']) + if main: + loss_params.add_argument('--bce', action='store_true', + help="use binary (instead of multi-class) classification loss") + if main and (not no_boundaries): + loss_params.add_argument('--bce-distill', action='store_true', help='distilled loss on previous classes for new' + ' examples (if --bce & --scenario="class")') + return parser + +##-------------------------------------------------------------------------------------------------------------------## + +def add_cl_options(parser, main=False, compare_all=False, compare_replay=False, compare_hyper=False, + no_boundaries=False, **kwargs): + + ## Baselines + if main and (not no_boundaries): + baseline_options = parser.add_argument_group('Baseline Options') + baseline_options.add_argument('--joint', action='store_true', help="train once on data of all contexts") + baseline_options.add_argument('--cummulative', action='store_true', + help="train incrementally on data of all contexts so far") + #---> Explanation for these two "upper-target" baselines: + # - "joint": means that the network is trained on a single dataset consisting of the data of all contexts + # - "cummulative": means that the network is incrementally trained on all contexts, whereby the training data + # always consists of the training data from all contexts seen so far + + ## Stream-specific options + if no_boundaries: + stream_options = parser.add_argument_group('Stream Options') + stream_options.add_argument('--update-every', metavar='N', type=int, default=100, + help='after how many iterations to consolidate model') + if compare_all: + stream_options.add_argument('--replay-update', metavar='N', type=int, default=1, + help='after how many iterations to start replaying observed samples') + + ## Context-specific components + context_spec = parser.add_argument_group('Context-Specific Component') + xdg_message = "use 'Context-dependent Gating' (Masse et al, 2018)" if main else "combine all methods with XdG" + context_spec.add_argument('--xdg', action='store_true', help=xdg_message) + context_spec.add_argument('--gating-prop', type=float, metavar="PROP", + help="-> XdG: prop neurons per layer to gate") + if main: + context_spec.add_argument('--separate-networks', action='store_true', help="train separate network per context") + if compare_all: + context_spec.add_argument('--fc-units-sep', type=int, metavar="N", + help="# of hidden units with separate network per context") + + ## Parameter regularization + if not compare_replay: + param_reg = parser.add_argument_group('Parameter Regularization') + if main and no_boundaries: + # With the flexible, 'task-free' CL experiments, currently the only supported param reg option is SI + param_reg.add_argument('--si', action='store_true', help="select defaults for 'SI' (Zenke et al, 2017)") + param_reg.add_argument("--weight-penalty", action='store_true', + help="penalize parameters important for past contexts") + param_reg.add_argument('--reg-strength', type=float, metavar='LAMDA', + help="regularisation strength for weight penalty") + if main and not no_boundaries: + # 'Convenience-commands' that select the defaults for specific methods + param_reg.add_argument('--ewc', action='store_true', + help="select defaults for 'EWC' (Kirkpatrick et al, 2017)") + param_reg.add_argument('--si', action='store_true', help="select defaults for 'SI' (Zenke et al, 2017)") + param_reg.add_argument("--ncl", action="store_true", + help="select defaults for 'NCL' (Kao, Jensen et al., 2021)") + param_reg.add_argument("--ewc-kfac", action="store_true", + help="select defaults for 'KFAC-EWC' (Ritter et al. 2018)") + param_reg.add_argument("--owm", action="store_true", help="select defaults for 'OWM' (Zeng et al. 2019)") + # Custom commands for specifying how parameter regularization should be performed + param_reg.add_argument("--weight-penalty", action='store_true', + help="penalize parameters important for past contexts") + param_reg.add_argument('--reg-strength', type=float, metavar='LAMDA', + help="regularisation strength for weight penalty") + param_reg.add_argument("--precondition", action='store_true', + help="parameter regularization by gradient projection") + param_reg.add_argument("--alpha", type=float, default=1e-10, + help="small constant stabilizing inversion importance matrix") + param_reg.add_argument("--importance-weighting", type=str, choices=['fisher', 'si', 'owm']) + if not no_boundaries: + param_reg.add_argument('--fisher-n', type=int, help="-> Fisher: sample size estimating Fisher Information") + param_reg.add_argument('--fisher-batch', type=int, default=1, metavar='N', + help="-> Fisher: batch size estimating FI (should be 1)") + param_reg.add_argument('--fisher-labels', type=str, default='all', choices=['all', 'sample', 'pred', 'true'], + help="-> Fisher: what labels to use to calculate FI?") + param_reg.add_argument("--fisher-kfac", action='store_true', + help="-> Fisher: use KFAC approximation rather than diagonal") + param_reg.add_argument("--fisher-init", action='store_true', help="-> Fisher: start with prior (as in NCL)") + param_reg.add_argument("--fisher-prior", type=float, metavar='SIZE', dest='data_size', + help="-> Fisher: prior-strength in 'data_size' (as in NCL)") + param_reg.add_argument('--epsilon', type=float, default=0.1, dest="epsilon", help="-> SI: dampening parameter") + if main and not no_boundaries: + param_reg.add_argument('--offline', action='store_true', + help="separate penalty term per context (as original EWC)") + param_reg.add_argument('--gamma', type=float, default=1., + help="forgetting coefficient Fishers (as in Online EWC)") + # For the comparison script in which EWC and SI are both run, to enable different hyper-params for both: + if compare_all and not no_boundaries: + param_reg.add_argument('--lambda', type=float, dest="ewc_lambda", help="-> EWC: regularisation strength") + if compare_all: + param_reg.add_argument('--c', type=float, dest="si_c", help="-> SI: regularisation strength") + + ## Functional regularization + func_reg = parser.add_argument_group('Functional Regularization') + if main: + func_reg.add_argument('--lwf', action='store_true', help="select defaults for 'LwF' (Li & Hoiem, 2017)") + func_reg.add_argument('--distill', action='store_true', help="use distillation-loss for the replayed data") + if not compare_replay: + func_reg.add_argument('--temp', type=float, default=2., dest='temp', help="temperature for distillation loss") + if main and not no_boundaries: + func_reg.add_argument('--fromp', action='store_true', help="use 'FROMP' (Pan et al, 2020)") + if (not compare_hyper) and not no_boundaries: + func_reg.add_argument('--tau', type=float, help="-> FROMP: regularization strength") + if compare_replay: + func_reg.add_argument('--tau-per-budget', action='store_true', + help="-> FROMP: use separate tau for each different budget") + + ## Memory buffer parameters (if data is stored) + buffer = parser.add_argument_group('Memory Buffer Parameters') + if not compare_replay: + buffer.add_argument('--budget', type=int, help="how many samples can be stored{}".format( + " (total budget)" if no_boundaries else " of each class?" + ), default=1000 if no_boundaries else None) + if not no_boundaries: + buffer.add_argument('--use-full-capacity', action='store_true', + help="use budget of future classes to initially store more") + if main and not no_boundaries: + buffer.add_argument('--sample-selection', type=str, choices=['random', 'herding', 'fromp']) + buffer.add_argument('--add-buffer', action='store_true', + help="add memory buffer to current context's training data") + + ## Replay + replay_params = parser.add_argument_group('Replay') + if main: + replay_choices = ['none', 'current', 'buffer'] if no_boundaries else ['none', 'all', 'generative', + 'current', 'buffer'] + replay_params.add_argument('--replay', type=str, default='none', choices=replay_choices) + replay_params.add_argument('--use-replay', type=str, default='normal', choices=['normal', 'inequality', 'both']) + #---> Explanation for these three ways to use replay: + # - "normal": add the loss on the replayed data to the loss on the data of the current context + # - "inequality": use the gradient of the loss on the replayed data as an inequality constraint (as in A-GEM) + # - "both": do both of the above + replay_params.add_argument('--agem', action='store_true', + help="select defaults for 'A-GEM' (Chaudhry et al, 2019)") + replay_params.add_argument('--eps-agem', type=float, default=1e-7, + help="parameter to ensure numerical stability of A-GEM") + if (not compare_replay) and (not no_boundaries): + # -parameters for the generative model (if it is a separate model) + if not compare_hyper: + replay_params.add_argument('--g-z-dim', type=int, help='size latent space generator (def: as classifier)') + replay_params.add_argument('--g-fc-lay', type=int, help='[fc_layers] in generator (def: as classifier)') + replay_params.add_argument('--g-fc-uni', type=int, help='[fc_units] in generator (def: as classifier)') + replay_params.add_argument('--g-iters', type=int, help="# batches to train generator (def: as classifier)") + replay_params.add_argument('--lr-gen', type=float, help="learning rate generator (def: as classifier)") + # -parameters for brain-inspired replay + if main: + replay_params.add_argument('--brain-inspired', action='store_true', + help="select defaults for 'BI-R' (van de Ven et al, 2020)") + replay_params.add_argument('--feedback', action="store_true", + help="equip main model with feedback connections") + replay_params.add_argument('--prior', type=str, default="standard", choices=["standard", "GMM"]) + replay_params.add_argument('--per-class', action='store_true', + help="if selected, each class has its own modes") + replay_params.add_argument('--n-modes', type=int, default=1, + help="how many modes for prior (per class)? (def=1)") + if main: + replay_params.add_argument('--dg-gates', action='store_true', help="use context-specific gates in decoder") + replay_params.add_argument('--dg-type', type=str, metavar="TYPE", + help="decoder-gates: based on contexts or classes?") + if not compare_hyper: + replay_params.add_argument('--dg-prop', type=float, help="decoder-gates: masking-prop") + if main: + replay_params.add_argument('--hidden', action="store_true", + help="gen models at 'internal level' (after conv-layers)") + + ## Template-based classification + if not compare_replay: + templ_cl = parser.add_argument_group('Template-Based Classification') + if main: + templ_cl.add_argument('--icarl', action='store_true', + help="select defaults for '{}iCaRL' (Rebuffi et al, 2017)".format( + 'Modified ' if no_boundaries else '' + )) + templ_cl.add_argument('--prototypes', action='store_true', help="classify using nearest-exemplar-mean rule") + templ_cl.add_argument('--gen-classifier', action='store_true', + help="use 'Generative Classifier' (van de Ven et al, 2021)") + if not compare_hyper: + templ_cl.add_argument('--eval-s', type=int, default=50, + help="-> Generative Classifier: number of importance samples") + if compare_all: + templ_cl.add_argument('--fc-units-gc', type=int, metavar="N", + help="# of hidden units with generative classifier") + templ_cl.add_argument('--fc-lay-gc', type=int, metavar="N", help="# fc-layers with generative classifier") + templ_cl.add_argument('--z-dim-gc', type=int, metavar="N", help="size latent space generative classifier") + return parser + +##-------------------------------------------------------------------------------------------------------------------## diff --git a/PyTorch/build-in/other/continual-learning/params/param_stamp.py b/PyTorch/build-in/other/continual-learning/params/param_stamp.py new file mode 100644 index 000000000..2ddb3cf34 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/params/param_stamp.py @@ -0,0 +1,201 @@ +from data.load import get_context_set +from models import define_models as define +from utils import checkattr + + +def visdom_name(args): + '''Get name for graph in visdom from [args].''' + iCaRL = (checkattr(args, 'prototypes') and checkattr(args, 'add_buffer') and checkattr(args, 'bce') + and checkattr(args, 'bce_distill')) + name = "{fb}{replay}{param_reg}{xdg}{icarl}{fromp}{bud}".format( + fb="1M-" if checkattr(args, 'feedback') else "", + replay="{}{}{}".format(args.replay, "D" if checkattr(args, 'distill') else "", + "-aGEM" if hasattr(args, 'use_replay') and args.use_replay=='inequality' else ""), + param_reg="-par{}-{}".format(args.reg_strength, + args.importance_weighting) if checkattr(args, 'weight_penalty') else '', + xdg="" if (not checkattr(args, 'xdg')) or args.gating_prop == 0 else "-XdG{}".format(args.gating_prop), + icarl="-iCaRL" if iCaRL else "", + fromp="-FROMP{}".format(args.tau) if checkattr(args, 'fromp') else "", + bud="-bud{}".format(args.budget) if args.replay=='buffer' or iCaRL else "", + ) + return name + + +def get_param_stamp_from_args(args, no_boundaries=False): + '''To get param-stamp a bit quicker.''' + + config = get_context_set( + name=args.experiment, scenario=args.scenario, contexts=args.contexts, data_dir=args.d_dir, only_config=True, + normalize=checkattr(args, "normalize"), verbose=False, singlehead=checkattr(args, 'singlehead'), + ) + + # -get feature extractor architecture (if used) + feature_extractor_name = None + depth = args.depth if hasattr(args, 'depth') else 0 + use_feature_extractor = checkattr(args, 'hidden') or ( + checkattr(args, 'freeze_convE') and (not args.replay=="generative") and (not checkattr(args, "add_buffer")) + and (not checkattr(args, "augment")) and (not checkattr(args, 'gen_classifier')) + ) + if use_feature_extractor: + feature_extractor = define.define_feature_extractor(args=args, config=config, device='cpu') + feature_extractor_name = feature_extractor.name if depth > 0 else None + config = config.copy() # -> make a copy to avoid overwriting info in the original config-file + config['size'] = feature_extractor.conv_out_size + config['channels'] = feature_extractor.conv_out_channels + depth = 0 + # -get classifier architecture + model = define.define_classifier(args=args, config=config, device='cpu', depth=depth, stream=no_boundaries) + # -get generator architecture (if used) + train_gen = True if (args.replay=="generative" and not checkattr(args, 'feedback')) else False + if train_gen: + generator = define.define_vae(args=args, config=config, device='cpu', depth=depth) + + model_name = model.name + replay_model_name = generator.name if train_gen else None + param_stamp = get_param_stamp(args, model_name, verbose=False, replay_model_name=replay_model_name, + feature_extractor_name=feature_extractor_name, no_boundaries=no_boundaries) + return param_stamp + + +def get_param_stamp(args, model_name, verbose=True, replay_model_name=None, feature_extractor_name=None, + no_boundaries=False): + '''Based on the input-arguments, produce a "parameter-stamp".''' + + # -for problem specification + multi_n_stamp = "{n}{joint}{cum}-{sce}".format(n=args.contexts, joint="-Joint" if checkattr(args, 'joint') else "", + cum="-Cummulative" if checkattr(args, 'cummulative') else "", + sce=args.scenario) if hasattr(args, "contexts") else "" + stream_stamp = "-{stream}{fuzz}".format( + stream=args.stream, fuzz="{}-".format(args.fuzziness) if args.stream=="fuzzy-boundaries" else "-" + ) if no_boundaries else "" + problem_stamp = "{exp}{stream}{norm}{aug}{multi_n}".format( + exp=args.experiment, stream=stream_stamp, norm="-N" if hasattr(args, 'normalize') and args.normalize else "", + aug="+" if hasattr(args, "augment") and args.augment else "", multi_n=multi_n_stamp + ) + if verbose: + print(" --> problem: "+problem_stamp) + + # -for model + model_stamp = model_name if feature_extractor_name is None else "H{}--{}".format(feature_extractor_name, model_name) + if verbose: + print(" --> model: "+model_stamp) + + # -for training settings + if checkattr(args, "pre_convE") and hasattr(args, 'depth') and args.depth>0: + ltag = "" if ((not hasattr(args, "convE_ltag")) or args.convE_ltag=="none") else "-{}{}".format( + args.convE_ltag, "-ps" if checkattr(args, 'seed_to_ltag') else "" + ) + pre = "-pCvE{}".format(ltag) + else: + pre = "" + freeze_conv = (checkattr(args, "freeze_convE") and hasattr(args, 'depth') and args.depth>0) + freeze = "-fCvE" if (freeze_conv and (feature_extractor_name is None)) else "" + train_stamp = "i{num}-lr{lr}-b{bsz}{pre}{freeze}-{optim}{mom}{neg}{recon}".format( + num=args.iters, lr=args.lr, bsz=args.batch, pre=pre, freeze=freeze, optim=args.optimizer, mom="-m{}".format( + args.momentum + ) if args.optimizer=='sgd' and hasattr(args, 'momentum') and args.momentum>0 else "", + neg="-{}".format(args.neg_samples) if ( + args.scenario=="class" and (not checkattr(args, 'gen_classifier')) and (not no_boundaries) + ) else "", + recon="-{}".format(args.recon_loss) if ( + checkattr(args, 'gen_classifier') or (hasattr(args, 'replay') and args.replay=="generative") + ) else "", + ) + if verbose: + print(" --> train-params: " + train_stamp) + + # -for parameter regularization + param_reg_stamp = "" + if checkattr(args, 'weight_penalty') or checkattr(args, 'precondition'): + param_reg_stamp = "-" + # -how is parameter regularization done (weight penalty and/or preconditioning)? + if checkattr(args, 'weight_penalty'): + param_reg_stamp += "-PReg{}".format(args.reg_strength) + if checkattr(args, 'precondition'): + param_reg_stamp += "-PreC{}".format(args.alpha) + # -how is the parameter importance computed? + if args.importance_weighting=='fisher': + param_reg_stamp += "-FI{}{}{}{}{}{}".format( + "kfac" if checkattr(args, 'fisher_kfac') else 'diag', + "I{}".format(args.data_size) if checkattr(args, 'fisher_init') else "", + "N" if args.fisher_n is None else args.fisher_n, + "Emp" if args.fisher_labels=="true" else ("Pred" if args.fisher_labels=="pred" else ( + "Sam" if args.fisher_labels=="sample" else "All" + )), + "B{}".format(args.fisher_batch) if (hasattr(args, 'fisher_batch') and args.fisher_batch>1) else "", + # -use a separate term per task or a forgetting coefficient: + "-offline" if checkattr(args, 'offline') else ( + "-forg{}".format(args.gamma) if hasattr(args, 'gamma') and args.gamma < 1 else "" + ), + ) + elif args.importance_weighting=='si': + param_reg_stamp += "-SI{}".format(args.epsilon) + elif args.importance_weighting=='owm': + param_reg_stamp += "-OWM" + + # -for context-specific components + xdg_stamp = "" + if checkattr(args, 'xdg') and args.gating_prop>0: + xdg_stamp = "--XdG{}".format(args.gating_prop) + if verbose: + print(" --> XdG: " + "gating = {}".format(args.gating_prop)) + + # -for replay / functional regularization (except FROMP) + replay_stamp = "" + if hasattr(args, 'replay') and not args.replay=="none": + replay_stamp = "{rep}{KD}{use}{model}{gi}{lrg}".format( + rep=args.replay, + KD="-KD{}".format(args.temp) if checkattr(args, 'distill') else "", + use="-{}{}".format( + "A-GEM" if args.use_replay=='inequality' else "both", + "" if ((not hasattr(args, 'eps_agem')) or args.eps_agem==0) else args.eps_agem + ) if hasattr(args, 'use_replay') and (not args.use_replay=='normal') else "", + model="" if (replay_model_name is None) else "-{}".format(replay_model_name), + gi="-gi{}".format(args.gen_iters) if ( + hasattr(args, "gen_iters") and (replay_model_name is not None) and (not args.iters==args.gen_iters) + ) else "", + lrg="-glr{}".format(args.lr_gen) if ( + hasattr(args, "lr_gen") and (replay_model_name is not None) and (not args.lr==args.lr_gen) + ) else "", + ) + if verbose: + print(" --> replay: " + replay_stamp) + replay_stamp = "--{}".format(replay_stamp) + + # -for memory-buffer & its use (e.g., FROMP, iCaRL) + memory_buffer_stamp = "" + use_memory_buffer = checkattr(args, 'prototypes') or checkattr(args, 'add_buffer') or args.replay=="buffer" \ + or checkattr(args, 'fromp') + if use_memory_buffer: + buffer_opts = "b{bud}{cap}{sel}".format( + bud=args.budget, cap="-FC" if checkattr(args, 'use_full_capacity') else "", + sel=args.sample_selection if hasattr(args, 'sample_selection') else 'random' + ) + use = "{}{}{}".format("addB-" if checkattr(args, 'add_buffer') else "", + "useB-" if checkattr(args, 'prototypes') else "", + "fromp{}-".format(args.tau) if checkattr(args, 'fromp') else "") + memory_buffer_stamp = "--{}{}".format(use, buffer_opts) + if verbose: + print(" --> memory buffer: " + "{}{}".format(use, buffer_opts)) + + # -for binary classification loss (e.g., iCaRL) + bin_stamp = "" + if checkattr(args, 'bce'): + bin_stamp = '--BCE_dist' if (checkattr(args, 'bce_distill') and args.scenario=="class") else '--BCE' + + # -specific to task-free protocol: how often to update the 'previous_model' relative to which to stay close + stream_stamp = "" + if no_boundaries and hasattr(args, 'update_every') and not args.update_every==1: + if use_memory_buffer or replay_stamp or param_reg_stamp: + stream_stamp = '--upEv{}'.format(args.update_every) + + # --> combine + param_stamp = "{}--{}--{}{}{}{}{}{}{}{}".format( + problem_stamp, model_stamp, train_stamp, param_reg_stamp, xdg_stamp, replay_stamp, memory_buffer_stamp, + bin_stamp, stream_stamp, "-s{}".format(args.seed) if not args.seed==0 else "" + ) + + ## Print param-stamp on screen and return + if verbose: + print(param_stamp) + return param_stamp \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/params/param_values.py b/PyTorch/build-in/other/continual-learning/params/param_values.py new file mode 100644 index 000000000..15ec765e7 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/params/param_values.py @@ -0,0 +1,220 @@ +from utils import checkattr + + +def set_method_options(args, **kwargs): + # If the 'convenience' option for a specific method is selected, select the corresponding defaults + if checkattr(args, 'ewc'): + args.weight_penalty = True + args.importance_weighting = 'fisher' + args.offline = True + if checkattr(args, 'si'): + args.weight_penalty = True + args.importance_weighting = 'si' + if checkattr(args, 'ncl'): + args.weight_penalty = True + args.precondition = True + args.importance_weighting = 'fisher' + args.fisher_kfac = True + args.fisher_init = True + if checkattr(args, 'kfac_ewc'): + args.weight_penalty = True + args.importance_weighting = 'fisher' + args.fisher_kfac = True + if checkattr(args, 'owm'): + args.precondition = True + args.importance_weighting = 'owm' + if checkattr(args, "lwf"): + args.replay = "current" + args.distill = True + if checkattr(args, 'agem'): + args.replay = "buffer" + args.use_replay = "inequality" + if checkattr(args, 'brain_inspired'): + args.replay = "generative" + args.feedback = True # --> replay-through-feedback + args.prior = 'GMM' # --> conditional replay + args.per_class = True # --> conditional replay + args.dg_gates = True # --> gating based on internal context (has hyper-param 'dg_prop') + args.hidden = True # --> internal replay + args.pre_convE = True # --> internal replay + args.distill = True # --> distillation + if checkattr(args, "icarl"): + args.prototypes = True + args.add_buffer = True + args.bce = True + args.bce_distill = True + args.sample_selection = 'herding' + + +def set_default_values(args, also_hyper_params=True, single_context=False, no_boundaries=False): + # -set default-values for certain arguments based on chosen experiment + args.normalize = args.normalize if args.experiment in ('CIFAR10', 'CIFAR100') else False + args.depth = ( + 5 if (args.experiment in ('CIFAR10', 'CIFAR100')) or checkattr(args, 'reducedResNet') else 0 + ) if args.depth is None else args.depth + args.fc_lay = (1 if checkattr(args, 'reducedResNet') else 3) if args.fc_lay is None else args.fc_lay + args.channels = (20 if checkattr(args, 'reducedResNet') else 16) if args.channels is None else args.channels + args.rl = 3 if checkattr(args, 'reducedResNet') and (args.rl is None) else args.rl + args.gp = True if checkattr(args, 'reducedResNet') else args.gp + args.conv_type = 'resNet' if checkattr(args, 'reducedResNet') else args.conv_type + if not single_context: + args.contexts = ( + 5 if args.experiment in ('splitMNIST', 'CIFAR10') else 10 + ) if args.contexts is None else args.contexts + args.iters = (2000 if args.experiment == 'splitMNIST' else 5000) if args.iters is None else args.iters + args.lr = (0.001 if args.experiment == 'splitMNIST' else 0.0001) if args.lr is None else args.lr + args.batch = (128 if args.experiment in ('splitMNIST', 'permMNIST') else 256) if args.batch is None else args.batch + if checkattr(args, 'separate_networks'): + args.fc_units = (100 if args.experiment == 'splitMNIST' else 400) if args.fc_units is None else args.fc_units + else: + args.fc_units = (400 if args.experiment == 'splitMNIST' else ( + 1000 if args.experiment == 'permMNIST' else 2000 + )) if args.fc_units is None else args.fc_units + if hasattr(args, 'fc_units_sep'): + args.fc_units_sep = ( + 100 if args.experiment == 'splitMNIST' else 400 + ) if args.fc_units_sep is None else args.fc_units_sep + if hasattr(args, 'fc_units_gc'): + args.fc_units_gc = 85 if args.fc_units_gc is None else args.fc_units_gc + args.fc_lay_gc = (3 if args.experiment == 'splitMNIST' else 2) if args.fc_lay_gc is None else args.fc_lay_gc + args.z_dim_gc = (5 if args.experiment == 'splitMNIST' else 20) if args.z_dim_gc is None else args.z_dim_gc + if hasattr(args, 'recon_loss'): + args.recon_loss = ( + "MSE" if args.experiment in ('CIFAR10', 'CIFAR100') else "BCE" + ) if args.recon_loss is None else args.recon_loss + if hasattr(args, "dg_type"): + args.dg_type = ("context" if args.scenario == 'domain' else "class") if args.dg_type is None else args.dg_type + if hasattr(args, 'budget'): + args.budget = (10 if args.experiment == 'permMNIST' else 100) if args.budget is None else args.budget + if hasattr(args, 'sample_selection'): + args.sample_selection = ('fromp' if checkattr(args, 'fromp') else ( + 'herding' if checkattr(args, 'icarl') else 'random' + )) if args.sample_selection is None else args.sample_selection + # -set other default arguments (if they were not selected) + if hasattr(args, 'lr_gen'): + args.lr_gen = args.lr if args.lr_gen is None else args.lr_gen + args.g_iters = args.iters if args.g_iters is None else args.g_iters + args.g_z_dim = args.z_dim if args.g_z_dim is None else args.g_z_dim + args.g_fc_lay = args.fc_lay if args.g_fc_lay is None else args.g_fc_lay + args.g_fc_uni = args.fc_units if args.g_fc_uni is None else args.g_fc_uni + # -unless the number of iterations after which to log is explicitly set, set them equal to # of iters per context + if not single_context: + args.acc_log = args.iters if (not hasattr(args, 'acc_log')) or args.acc_log is None else args.acc_log + args.loss_log = args.iters if (not hasattr(args, 'loss_log')) or args.loss_log is None else args.loss_log + args.sample_log = args.iters if (not hasattr(args,'sample_log')) or args.sample_log is None else args.sample_log + + # -set default-values for certain arguments based on chosen scenario & experiment + if hasattr(args, 'scenario') and args.scenario == 'task' and hasattr(args, 'gating_prop'): + # -context-specific gating + args.gating_prop = ( + 0.85 if args.experiment == 'CIFAR100' else (0.9 if args.experiment == 'splitMNIST' else 0.6) + ) if args.gating_prop is None else args.gating_prop + if also_hyper_params: + # -regularization strength + if not hasattr(args, 'si_c'): + args.si_c = None + if not hasattr(args, 'ewc_lambda'): + args.ewc_lambda = None + if no_boundaries: + args.si_c = 10. if args.si_c is None else args.si_c + elif args.scenario == 'task': + args.si_c = ( + 10. if args.experiment == 'splitMNIST' else (100. if args.experiment == 'CIFAR100' else 10.) + ) if args.si_c is None else args.si_c + args.ewc_lambda = ( + 100000. if args.experiment == 'splitMNIST' else (1000. if args.experiment == 'CIFAR100' else 100.) + ) if args.ewc_lambda is None else args.ewc_lambda + elif args.scenario == 'domain': + args.si_c = ( + 50000. if args.experiment == 'splitMNIST' else (500. if args.experiment == 'CIFAR100' else 10.) + ) if args.si_c is None else args.si_c + args.ewc_lambda = ( + 10000000000. if args.experiment == 'splitMNIST' else (1000. if args.experiment == 'CIFAR100' else 100.) + ) if args.ewc_lambda is None else args.ewc_lambda + elif args.scenario == 'class': + args.si_c = (5000. if args.experiment == 'splitMNIST' else 5.) if args.si_c is None else args.si_c + args.ewc_lambda = ( + 1000000000. if args.experiment == 'splitMNIST' else 100. + ) if args.ewc_lambda is None else args.ewc_lambda + if hasattr(args, 'reg_strength'): + args.reg_strength = ( + args.si_c if checkattr(args, 'si') else (args.ewc_lambda if checkattr(args, 'ewc') else 1.) + ) if args.reg_strength is None else args.reg_strength + # -use a prior for the Fisher (as in NCL) + if hasattr(args, 'data_size'): + args.data_size = (12000 if args.experiment == 'splitMNIST' else ( + 60000 if args.experiment == 'permMNIST' else (5000 if args.experiment == 'CIFAR100' else 10000) + )) if args.data_size is None else args.data_size + # -gating based on internal context (brain-inspired replay) + if args.scenario == 'task' and hasattr(args, 'dg_prop'): + args.dg_prop = (0. if args.experiment == 'splitMNIST' else 0.) if args.dg_prop is None else args.dg_prop + elif args.scenario == 'domain' and hasattr(args, 'dg_prop'): + args.dg_prop = (0.1 if args.experiment == 'splitMNIST' else 0.5) if args.dg_prop is None else args.dg_prop + elif args.scenario == 'class' and hasattr(args, 'dg_prop'): + args.dg_prop = (0.1 if args.experiment == 'splitMNIST' else 0.7) if args.dg_prop is None else args.dg_prop + if hasattr(args, 'tau'): + # -fromp + args.tau = ((0.01 if args.scenario == 'task' else ( + 10. if args.scenario == 'domain' else 1000. + )) if args.experiment == 'splitMNIST' else 1.) if args.tau is None else args.tau + + +def check_for_errors(args, pretrain=False, **kwargs): + if pretrain: + if checkattr(args, 'augment') and not args.experiment in ('CIFAR10', 'CIFAR100'): + raise ValueError("Augmentation is only supported for 'CIFAR10' or 'CIFAR-100'.") + if not pretrain: + if (checkattr(args, 'separate_networks') or checkattr(args, 'xdg')) and (not args.scenario == "task"): + raise ValueError("'XdG' or 'SeparateNetworks' can only be used with --scenario='task'.") + # -Replay-through-Feedback model is not (yet) implemented with all possible options + if checkattr(args, 'feedback') and (checkattr(args, 'precondition') or ( + hasattr(args, 'use_replay') and args.use_replay in ('inequality', 'both') + )): + raise NotImplementedError('Replay-through-Feedback currently does not support gradient projection.') + if checkattr(args, 'feedback') and checkattr(args, 'xdg'): + raise NotImplementedError('Replay-through-Feedback currently does not support XdG (in the encoder).') + if checkattr(args, 'feedback') and args.importance_weighting=='fisher' and checkattr(args, 'fisher_kfac'): + raise NotImplementedError('Replay-through-Feedback currently does not support using KFAC Fisher.') + if checkattr(args, 'feedback') and checkattr(args, 'bce'): + raise NotImplementedError('Replay-through-Feedback currently does not support binary classification loss.') + # -if 'BCEdistill' is selected for other than scenario=="class", give error + if checkattr(args, 'bce_distill') and not args.scenario=="class": + raise ValueError("BCE-distill can only be used for class-incremental learning.") + # -with parameter regularization, not (yet) all combinations are implemented + if hasattr(args, 'importance_weighting') and args.importance_weighting=='owm' and \ + checkattr(args, 'weight_penalty'): + raise NotImplementedError('OWM-based importance weighting not supported with parameter weight penalty.') + if hasattr(args, 'importance_weighting') and args.importance_weighting=='si' and \ + checkattr(args, 'precondition'): + raise NotImplementedError('SI-based importance weighting not supported with parameter pre-conditioning.') + # -FROMP has a limited range of options it can be combined with + if checkattr(args, 'fromp') and hasattr(args, 'optimizer') and args.optimizer=="sgd": + raise NotImplementedError('FROMP is only supported with ADAM optimizer.') + if checkattr(args, 'fromp') and hasattr(args, 'replay') and not args.replay=="none": + raise NotImplementedError('FROMP is not supported combined with replay.') + if checkattr(args, 'fromp') and (checkattr(args, 'weight_penalty') or checkattr(args, 'precondition')): + raise NotImplementedError('FROMP is not supported combined with parameter regularization.') + # -the Generative Classifier implemented here cannot be combined with other approaches + if checkattr(args, 'gen_classifier') and hasattr(args, 'replay') and not args.replay == "none": + raise NotImplementedError('The Generative Classifier is not supported with replay.') + if checkattr(args, 'gen_classifier') and (checkattr(args, 'weight_penalty') or checkattr(args, 'precondition')): + raise NotImplementedError('The Generative Classifier is not supported with parameter regularization.') + if checkattr(args, 'gen_classifier') and checkattr(args, 'fromp'): + raise NotImplementedError('The Generative Classifier is not supported with FROMP.') + # -a conditional generative model for GR is only supported in combination with Replay-through-Feedback + if (checkattr(args, 'per_class') or checkattr(args, 'dg_gates')) and not checkattr(args, 'feedback'): + raise NotImplementedError('A VAE with separate mode per class or context-specific gates in the decoder is ' + 'only supported in combination with the replay-through-feedback model.') + # -warning about that XdG and FROMP and KFAC are only applied to fully connected layers? + trainable_conv = hasattr(args, 'depth') and args.depth>0 and ((not checkattr(args, 'freeze_convE')) or + checkattr(args, 'hidden')) + if checkattr(args, 'xdg') and trainable_conv: + print('Note that XdG is only applied to the fully connected layers of the network.') + if checkattr(args, 'fromp') and trainable_conv: + print('Note that FROMP is only applied to the fully connected layers of the network.') + if checkattr(args, 'fisher_kfac') and trainable_conv: + print('Note that parameter regularization based on KFAC Fisher is only applied to ' + 'the fully connected layers of the network.') + if hasattr(args, 'importance_weighting') and args.importance_weighting=='owm' and trainable_conv: + print('Note that OWM is only applied to the fully connected layers of the network.') + diff --git a/PyTorch/build-in/other/continual-learning/requirements.txt b/PyTorch/build-in/other/continual-learning/requirements.txt new file mode 100644 index 000000000..0934f044d --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/requirements.txt @@ -0,0 +1,11 @@ +numpy +scipy +pandas +torch +torchvision +tqdm +scikit-learn +matplotlib +visdom +jupyterlab +ipywidgets diff --git a/PyTorch/build-in/other/continual-learning/store/README.md b/PyTorch/build-in/other/continual-learning/store/README.md new file mode 100644 index 000000000..0b0163d75 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/store/README.md @@ -0,0 +1,7 @@ +All outputs generated by `main.py`, `main_task_free.py` and `main_pretrain.py` will by default be stored +in this directory, organized into the following subdirectories: + +- datasets +- models +- plots +- results \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/train/__init__.py b/PyTorch/build-in/other/continual-learning/train/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/train/train_standard.py b/PyTorch/build-in/other/continual-learning/train/train_standard.py new file mode 100644 index 000000000..e355fb98b --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/train/train_standard.py @@ -0,0 +1,43 @@ +import tqdm + + +def train(model, train_loader, iters, loss_cbs=list(), eval_cbs=list()): + '''Train a model with a "train_a_batch" method for [iters] iterations on data from [train_loader]. + + [model] model to optimize + [train_loader] for training [model] on + [iters] (max) number of iterations (i.e., batches) to train for + [loss_cbs] of callback- to keep track of training progress + [eval_cbs] of callback- to evaluate model on separate data-set''' + + device = model._device() + + # Create progress-bar (with manual control) + bar = tqdm.tqdm(total=iters) + + iteration = epoch = 0 + while iteration < iters: + epoch += 1 + + # Loop over all batches of an epoch + for batch_idx, (data, y) in enumerate(train_loader): + iteration += 1 + + # Perform training-step on this batch + data, y = data.to(device), y.to(device) + loss_dict = model.train_a_batch(data, y=y) + + # Fire training-callbacks (for visualization of training-progress) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(bar, iteration, loss_dict) + + # Fire evaluation-callbacks (to be executed every [eval_log] iterations, as specified within the functions) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, iteration) + + # Break if max-number of iterations is reached + if iteration == iters: + bar.close() + break \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/train/train_stream.py b/PyTorch/build-in/other/continual-learning/train/train_stream.py new file mode 100644 index 000000000..a4a13059c --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/train/train_stream.py @@ -0,0 +1,143 @@ +import torch +import tqdm +import copy +from utils import checkattr +from models.cl.continual_learner import ContinualLearner + + +def train_on_stream(model, datastream, iters=2000, loss_cbs=list(), eval_cbs=list()): + '''Incrementally train a model on a ('task-free') stream of data. + Args: + model (Classifier): model to be trained, must have a built-in `train_a_batch`-method + datastream (DataStream): iterator-object that returns for each iteration the training data + iters (int, optional): max number of iterations, could be smaller if `datastream` runs out (default: ``2000``) + *_cbs (list of callback-functions, optional): for evaluating training-progress (defaults: empty lists) + ''' + + # Define tqdm progress bar(s) + progress = tqdm.tqdm(range(1, iters + 1)) + + ##--> SI: Register starting parameter values + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + start_new_W = True + model.register_starting_param_values() + + previous_model = None + + for batch_id, (x,y,c) in enumerate(datastream, 1): + + if batch_id > iters: + break + + ##--> SI: Prepare to store running importance estimates and param-values before update + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + if start_new_W: + W, p_old = model.prepare_importance_estimates_dicts() + start_new_W = False + + # Move data to correct device + x = x.to(model._device()) + y = y.to(model._device()) + if c is not None: + c = c.to(model._device()) + + # If using separate networks, the y-targets need to be adjusted + if model.label == "SeparateClassifiers": + for sample_id in range(x.shape[0]): + y[sample_id] = y[sample_id] - model.classes_per_context * c[sample_id] + + # Add replay... + (x_, y_, c_, scores_) = (None, None, None, None) + if hasattr(model, 'replay_mode') and model.replay_mode=='buffer' and previous_model is not None: + # ... from the memory buffer + (x_, y_, c_) = previous_model.sample_from_buffer(x.shape[0]) + if model.replay_targets=='soft': + with torch.no_grad(): + scores_ = previous_model.classify(x_, c_, no_prototypes=True) + elif hasattr(model, 'replay_mode') and model.replay_mode=='current' and previous_model is not None: + # ... using the data from the current batch (as in LwF) + x_ = x + if c is not None: + c_ = previous_model.sample_contexts(x_.shape[0]).to(model._device()) + with torch.no_grad(): + scores_ = previous_model.classify(x, c_, no_prototypes=True) + _, y_ = torch.max(scores_, dim=1) + # -only keep [y_] or [scores_], depending on whether replay is with 'hard' or 'soft' targets + y_ = y_ if (hasattr(model, 'replay_targets') and model.replay_targets == "hard") else None + scores_ = scores_ if (hasattr(model, 'replay_targets') and model.replay_targets == "soft") else None + + # Train the model on this batch + loss_dict = model.train_a_batch(x, y, c, x_=x_, y_=y_, c_=c_, scores_=scores_, rnt=0.5) + + ##--> SI: Update running parameter importance estimates in W (needed for SI) + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + model.update_importance_estimates(W, p_old) + + # Add the observed data to the memory buffer (if selected by the algorithm that fills the memory buffer) + if checkattr(model, 'use_memory_buffer'): + model.add_new_samples(x, y, c) + if hasattr(model, 'replay_mode') and model.replay_mode == 'current' and c is not None: + model.keep_track_of_contexts_so_far(c) + + # Fire callbacks (for visualization of training-progress / evaluating performance after each task) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(progress, batch_id, loss_dict) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, batch_id, context=None) + + ##--> SI: calculate and update the normalized path integral + if isinstance(model, ContinualLearner) and model.importance_weighting=='si' and model.weight_penalty: + if (batch_id % model.update_every)==0: + model.update_omega(W, model.epsilon) + start_new_W = True + + ##--> Replay: update source for replay + if hasattr(model, 'replay_mode') and (not model.replay_mode=="none"): + if (batch_id % model.update_every)==0: + previous_model = copy.deepcopy(model).eval() + + # Close progres-bar(s) + progress.close() + +#------------------------------------------------------------------------------------------------------------# + +def train_gen_classifier_on_stream(model, datastream, iters=2000, loss_cbs=list(), eval_cbs=list()): + '''Incrementally train a generative classifier model on a ('task-free') stream of data. + Args: + model (Classifier): generative classifier, each generative model must have a built-in `train_a_batch`-method + datastream (DataStream): iterator-object that returns for each iteration the training data + iters (int, optional): max number of iterations, could be smaller if `datastream` runs out (default: ``2000``) + *_cbs (list of callback-functions, optional): for evaluating training-progress (defaults: empty lists) + ''' + + # Define tqdm progress bar(s) + progress = tqdm.tqdm(range(1, iters + 1)) + + for batch_id, (x,y,_) in enumerate(datastream, 1): + + if batch_id > iters: + break + + # Move data to correct device + x = x.to(model._device()) + y = y.to(model._device()) + + # Cycle through all classes. For each class present, take training step on corresponding generative model + for class_id in range(model.classes): + if class_id in y: + x_to_use = x[y==class_id] + loss_dict = getattr(model, "vae{}".format(class_id)).train_a_batch(x_to_use) + # NOTE: this way, only the [lost_dict] of the last class present in the batch enters into the [loss_cb] + + # Fire callbacks (for visualization of training-progress / evaluating performance after each task) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(progress, batch_id, loss_dict) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, batch_id, context=None) + + # Close progres-bar(s) + progress.close() \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/train/train_task_based.py b/PyTorch/build-in/other/continual-learning/train/train_task_based.py new file mode 100644 index 000000000..9232e86d7 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/train/train_task_based.py @@ -0,0 +1,635 @@ +import torch +from torch import optim +from torch.utils.data.dataloader import DataLoader +from torch.utils.data import ConcatDataset +import numpy as np +import tqdm +import copy +from utils import get_data_loader,checkattr +from data.manipulate import SubDataset, MemorySetDataset +from models.cl.continual_learner import ContinualLearner + + +def train_cl(model, train_datasets, iters=2000, batch_size=32, baseline='none', + loss_cbs=list(), eval_cbs=list(), sample_cbs=list(), context_cbs=list(), + generator=None, gen_iters=0, gen_loss_cbs=list(), **kwargs): + '''Train a model (with a "train_a_batch" method) on multiple contexts. + + [model] main model to optimize across all contexts + [train_datasets] with for each context the training + [iters] , # of optimization-steps (i.e., # of mini-batches) per context + [batch_size] , # of samples per mini-batch + [baseline] , 'joint': model trained once on data from all contexts + 'cummulative': model trained incrementally, always using data all contexts so far + [generator] None or , if separate generative model is trained (for [gen_iters] per context) + [*_cbs] of call-back functions to evaluate training-progress + ''' + + # Set model in training-mode + model.train() + + # Use cuda? + cuda = model._is_on_cuda() + device = model._device() + + # Initiate possible sources for replay (no replay for 1st context) + ReplayStoredData = ReplayGeneratedData = ReplayCurrentData = False + previous_model = None + + # Register starting parameter values (needed for SI) + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + model.register_starting_param_values() + + # Are there different active classes per context (or just potentially a different mask per context)? + per_context = (model.scenario=="task" or (model.scenario=="class" and model.neg_samples=="current")) + per_context_singlehead = per_context and (model.scenario=="task" and model.singlehead) + + # Loop over all contexts. + for context, train_dataset in enumerate(train_datasets, 1): + + # If using the "joint" baseline, skip to last context, as model is only be trained once on data of all contexts + if baseline=='joint': + if context1: + if model.scenario=="domain" or per_context_singlehead: + target_transform = (lambda y, x=model.classes_per_context: y % x) + else: + target_transform = None + memory_dataset = MemorySetDataset(model.memory_sets, target_transform=target_transform) + training_dataset = ConcatDataset([train_dataset, memory_dataset]) + else: + training_dataset = train_dataset + + # Prepare to store running importance estimates and param-values before update (needed for SI) + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + W, p_old = model.prepare_importance_estimates_dicts() + + # Find [active_classes] + if model.scenario=="task": + if not model.singlehead: + # -for Task-IL scenario, create with for all contexts so far a with the active classes + active_classes = [list( + range(model.classes_per_context * i, model.classes_per_context * (i+1)) + ) for i in range(context)] + else: + #--> if a single-headed output layer is used in the Task-IL scenario, all output units are always active + active_classes = None + elif model.scenario=="domain": + # -for Domain-IL scenario, always all classes are active + active_classes = None + elif model.scenario=="class": + # -for Class-IL scenario, the active classes are determined by [model.neg_samples] + if model.neg_samples=="all-so-far": + # --> one with active classes of all contexts so far + active_classes = list(range(model.classes_per_context * context)) + elif model.neg_samples=="all": + #--> always all classes are active + active_classes = None + elif model.neg_samples=="current": + #--> only those classes in the current or replayed context are active (i.e., train "as if Task-IL") + active_classes = [list( + range(model.classes_per_context * i, model.classes_per_context * (i + 1)) + ) for i in range(context)] + + # Reset state of optimizer(s) for every context (if requested) + if (not model.label=="SeparateClassifiers") and model.optim_type=="adam_reset": + model.optimizer = optim.Adam(model.optim_list, betas=(0.9, 0.999)) + if (generator is not None) and generator.optim_type=="adam_reset": + generator.optimizer = optim.Adam(model.optim_list, betas=(0.9, 0.999)) + + # Initialize # iters left on current data-loader(s) + iters_left = iters_left_previous = 1 + if per_context: + up_to_context = context if baseline=="cummulative" else context-1 + iters_left_previous = [1]*up_to_context + data_loader_previous = [None]*up_to_context + + # Define tqdm progress bar(s) + progress = tqdm.tqdm(range(1, iters+1)) + if generator is not None: + progress_gen = tqdm.tqdm(range(1, gen_iters+1)) + + # Loop over all iterations + iters_to_use = iters if (generator is None) else max(iters, gen_iters) + for batch_index in range(1, iters_to_use+1): + + # Update # iters left on current data-loader(s) and, if needed, create new one(s) + iters_left -= 1 + if iters_left==0: + data_loader = iter(get_data_loader(training_dataset, batch_size, cuda=cuda, drop_last=True)) + # NOTE: [train_dataset] is training-set of current context + # [training_dataset] is training-set of current context with stored samples added (if requested) + iters_left = len(data_loader) + if ReplayStoredData: + if per_context: + up_to_context = context if baseline=="cummulative" else context-1 + batch_size_replay = int(np.ceil(batch_size/up_to_context)) if (up_to_context>1) else batch_size + # -if different active classes per context (e.g., Task-IL), need separate replay for each context + for context_id in range(up_to_context): + batch_size_to_use = min(batch_size_replay, len(previous_datasets[context_id])) + iters_left_previous[context_id] -= 1 + if iters_left_previous[context_id]==0: + data_loader_previous[context_id] = iter(get_data_loader( + previous_datasets[context_id], batch_size_to_use, cuda=cuda, drop_last=True + )) + iters_left_previous[context_id] = len(data_loader_previous[context_id]) + else: + iters_left_previous -= 1 + if iters_left_previous==0: + batch_size_to_use = min(batch_size, len(ConcatDataset(previous_datasets))) + data_loader_previous = iter(get_data_loader(ConcatDataset(previous_datasets), + batch_size_to_use, cuda=cuda, drop_last=True)) + iters_left_previous = len(data_loader_previous) + + + # -----------------Collect data------------------# + + #####-----CURRENT BATCH-----##### + if baseline=="cummulative" and per_context: + x = y = scores = None + else: + x, y = next(data_loader) #--> sample training data of current context + y = y-model.classes_per_context*(context-1) if per_context and not per_context_singlehead else y + # --> adjust the y-targets to the 'active range' + x, y = x.to(device), y.to(device) #--> transfer them to correct device + # If --bce & --bce-distill, calculate scores for past classes of current batch with previous model + binary_distillation = hasattr(model, "binaryCE") and model.binaryCE and model.binaryCE_distill + if binary_distillation and model.scenario in ("class", "all") and (previous_model is not None): + with torch.no_grad(): + scores = previous_model.classify( + x, no_prototypes=True + )[:, :(model.classes_per_context * (context - 1))] + else: + scores = None + + + #####-----REPLAYED BATCH-----##### + if not ReplayStoredData and not ReplayGeneratedData and not ReplayCurrentData: + x_ = y_ = scores_ = context_used = None #-> if no replay + + ##-->> Replay of stored data <<--## + if ReplayStoredData: + scores_ = context_used = None + if not per_context: + # Sample replayed training data, move to correct device + x_, y_ = next(data_loader_previous) + x_ = x_.to(device) + y_ = y_.to(device) if (model.replay_targets=="hard") else None + # If required, get target scores (i.e, [scores_]) -- using previous model, with no_grad() + if (model.replay_targets=="soft"): + with torch.no_grad(): + scores_ = previous_model.classify(x_, no_prototypes=True) + if model.scenario=="class" and model.neg_samples=="all-so-far": + scores_ = scores_[:, :(model.classes_per_context*(context-1))] + #-> if [scores_] is not same length as [x_], zero probs are added in [loss_fn_kd]-function + else: + # Sample replayed training data, move to correct device and store in lists + x_ = list() + y_ = list() + up_to_context = context if baseline=="cummulative" else context-1 + for context_id in range(up_to_context): + x_temp, y_temp = next(data_loader_previous[context_id]) + x_.append(x_temp.to(device)) + # -only keep [y_] if required (as otherwise unnecessary computations will be done) + if model.replay_targets=="hard": + if not per_context_singlehead: + y_temp = y_temp - (model.classes_per_context*context_id) #-> adjust y to 'active range' + y_.append(y_temp.to(device)) + else: + y_.append(None) + # If required, get target scores (i.e, [scores_]) -- using previous model, with no_grad() + if (model.replay_targets=="soft") and (previous_model is not None): + scores_ = list() + for context_id in range(up_to_context): + with torch.no_grad(): + scores_temp = previous_model.classify(x_[context_id], no_prototypes=True) + if active_classes is not None: + scores_temp = scores_temp[:, active_classes[context_id]] + scores_.append(scores_temp) + + ##-->> Generative / Current Replay <<--## + + #---INPUTS---# + if ReplayCurrentData: + x_ = x #--> use current context inputs + context_used = None + + if ReplayGeneratedData: + conditional_gen = True if previous_generator.label=='CondVAE' and \ + ((previous_generator.per_class and previous_generator.prior=="GMM") + or checkattr(previous_generator, 'dg_gates')) else False + if conditional_gen and per_context: + # -if a cond generator is used with different active classes per context, generate data per context + x_ = list() + context_used = list() + for context_id in range(context-1): + allowed_domains = list(range(context - 1)) + allowed_classes = list( + range(model.classes_per_context*context_id, model.classes_per_context*(context_id+1)) + ) + batch_size_to_use = int(np.ceil(batch_size / (context-1))) + x_temp_ = previous_generator.sample(batch_size_to_use, allowed_domains=allowed_domains, + allowed_classes=allowed_classes, only_x=False) + x_.append(x_temp_[0]) + context_used.append(x_temp_[2]) + else: + # -which classes are allowed to be generated? (relevant if conditional generator / decoder-gates) + allowed_classes = None if model.scenario=="domain" else list( + range(model.classes_per_context*(context-1)) + ) + # -which contexts are allowed to be generated? (only relevant if "Domain-IL" with context-gates) + allowed_domains = list(range(context-1)) + # -generate inputs representative of previous contexts + x_temp_ = previous_generator.sample(batch_size, allowed_classes=allowed_classes, + allowed_domains=allowed_domains, only_x=False) + x_ = x_temp_[0] if type(x_temp_)==tuple else x_temp_ + context_used = x_temp_[2] if type(x_temp_)==tuple else None + + #---OUTPUTS---# + if ReplayGeneratedData or ReplayCurrentData: + # Get target scores and labels (i.e., [scores_] / [y_]) -- using previous model, with no_grad() + if not per_context: + # -if replay does not need to be evaluated separately for each context + with torch.no_grad(): + scores_ = previous_model.classify(x_, no_prototypes=True) + if model.scenario == "class" and model.neg_samples == "all-so-far": + scores_ = scores_[:, :(model.classes_per_context * (context - 1))] + # -> if [scores_] is not same length as [x_], zero probs are added in [loss_fn_kd]-function + # -also get the 'hard target' + _, y_ = torch.max(scores_, dim=1) + else: + # -[x_] needs to be evaluated according to each past context, so make list with entry per context + scores_ = list() + y_ = list() + # -if no context-mask and no conditional generator, all scores can be calculated in one go + if previous_model.mask_dict is None and not type(x_)==list: + with torch.no_grad(): + all_scores_ = previous_model.classify(x_, no_prototypes=True) + for context_id in range(context-1): + # -if there is a context-mask (i.e., XdG), obtain predicted scores for each context separately + if previous_model.mask_dict is not None: + previous_model.apply_XdGmask(context=context_id+1) + if previous_model.mask_dict is not None or type(x_)==list: + with torch.no_grad(): + all_scores_ = previous_model.classify(x_[context_id] if type(x_)==list else x_, + no_prototypes=True) + temp_scores_ = all_scores_ + if active_classes is not None: + temp_scores_ = temp_scores_[:, active_classes[context_id]] + scores_.append(temp_scores_) + # - also get hard target + _, temp_y_ = torch.max(temp_scores_, dim=1) + y_.append(temp_y_) + + # Only keep predicted y/scores if required (as otherwise unnecessary computations will be done) + y_ = y_ if (model.replay_targets == "hard") else None + scores_ = scores_ if (model.replay_targets == "soft") else None + + + #---> Train MAIN MODEL + if batch_index <= iters: + + # Train the main model with this batch + loss_dict = model.train_a_batch(x, y, x_=x_, y_=y_, scores=scores, scores_=scores_, rnt = 1./context, + contexts_=context_used, active_classes=active_classes, context=context) + + # Update running parameter importance estimates in W (needed for SI) + if isinstance(model, ContinualLearner) and model.importance_weighting=='si': + model.update_importance_estimates(W, p_old) + + # Fire callbacks (for visualization of training-progress / evaluating performance after each context) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(progress, batch_index, loss_dict, context=context) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, batch_index, context=context) + if model.label == "VAE": + for sample_cb in sample_cbs: + if sample_cb is not None: + sample_cb(model, batch_index, context=context) + + + #---> Train GENERATOR + if generator is not None and batch_index <= gen_iters: + + # Train the generator with this batch + loss_dict = generator.train_a_batch(x, x_=x_, rnt=1./context) + + # Fire callbacks on each iteration + for loss_cb in gen_loss_cbs: + if loss_cb is not None: + loss_cb(progress_gen, batch_index, loss_dict, context=context) + for sample_cb in sample_cbs: + if sample_cb is not None: + sample_cb(generator, batch_index, context=context) + + + ##----------> UPON FINISHING EACH CONTEXT... + + # Close progres-bar(s) + progress.close() + if generator is not None: + progress_gen.close() + + # Parameter regularization: update and compute the parameter importance estimates + if context EWC/NCL: estimate the Fisher Information matrix + if model.importance_weighting=='fisher' and (model.weight_penalty or model.precondition): + if model.fisher_kfac: + model.estimate_kfac_fisher(training_dataset, allowed_classes=allowed_classes) + else: + model.estimate_fisher(training_dataset, allowed_classes=allowed_classes) + ##--> OWM: calculate and update the projection matrix + if model.importance_weighting=='owm' and (model.weight_penalty or model.precondition): + model.estimate_owm_fisher(training_dataset, allowed_classes=allowed_classes) + ##--> SI: calculate and update the normalized path integral + if model.importance_weighting=='si' and (model.weight_penalty or model.precondition): + model.update_omega(W, model.epsilon) + + # MEMORY BUFFER: update the memory buffer + if checkattr(model, 'use_memory_buffer'): + samples_per_class = model.budget_per_class if (not model.use_full_capacity) else int( + np.floor((model.budget_per_class*len(train_datasets))/context) + ) + # reduce examplar-sets (only needed when '--use-full-capacity' is selected) + model.reduce_memory_sets(samples_per_class) + # for each new class trained on, construct examplar-set + new_classes = list(range(model.classes_per_context)) if ( + model.scenario=="domain" or per_context_singlehead + ) else list(range(model.classes_per_context*(context-1), model.classes_per_context*context)) + for class_id in new_classes: + # create new dataset containing only all examples of this class + class_dataset = SubDataset(original_dataset=train_dataset, sub_labels=[class_id]) + # based on this dataset, construct new memory-set for this class + allowed_classes = active_classes[-1] if per_context and not per_context_singlehead else active_classes + model.construct_memory_set(dataset=class_dataset, n=samples_per_class, label_set=allowed_classes) + model.compute_means = True + + # Run the callbacks after finishing each context + for context_cb in context_cbs: + if context_cb is not None: + context_cb(model, iters, context=context) + + # REPLAY: update source for replay + if context main model to optimize across all contexts + [train_datasets] with for each context the training + [iters] , # of optimization-steps (i.e., # of mini-batches) per context + [batch_size] , # of samples per mini-batch + [*_cbs] of call-back functions to evaluate training-progress + ''' + + # Set model in training-mode + model.train() + + # Use cuda? + cuda = model._is_on_cuda() + device = model._device() + + # Are there different active classes per context (or just potentially a different mask per context)? + per_context = (model.scenario=="task" or (model.scenario=="class" and model.neg_samples=="current")) + per_context_singlehead = per_context and (model.scenario=="task" and model.singlehead) + + # Loop over all contexts. + for context, train_dataset in enumerate(train_datasets, 1): + + # Find [active_classes] + if model.scenario=="task": + if not model.singlehead: + # -for Task-IL scenario, create with for all contexts so far a with the active classes + active_classes = [list( + range(model.classes_per_context * i, model.classes_per_context * (i+1)) + ) for i in range(context)] + else: + #--> if a single-headed output layer is used in the Task-IL scenario, all output units are always active + active_classes = None + elif model.scenario=="domain": + # -for Domain-IL scenario, always all classes are active + active_classes = None + elif model.scenario=="class": + # -for Class-IL scenario, the active classes are determined by [model.neg_samples] + if model.neg_samples=="all-so-far": + # --> one with active classes of all contexts so far + active_classes = list(range(model.classes_per_context * context)) + elif model.neg_samples=="all": + #--> always all classes are active + active_classes = None + elif model.neg_samples=="current": + #--> only those classes in the current or replayed context are active (i.e., train "as if Task-IL") + active_classes = [list( + range(model.classes_per_context * i, model.classes_per_context * (i + 1)) + ) for i in range(context)] + + # Find [label_sets] (i.e., when replaying/revisiting/regularizing previous contexts, which labels to consider) + label_sets = active_classes if (per_context and not per_context_singlehead) else [active_classes]*context + # NOTE: With Class-IL, when revisiting previous contexts, consider all labels up to *now* + # (and not up to when that context was encountered!) + + # FROMP: calculate and store regularisation-term-related quantities + if context > 1: + model.optimizer.init_context(context-1, reset=(model.optim_type=="adam_reset"), + classes_per_context=model.classes_per_context, label_sets=label_sets) + + # Initialize # iters left on current data-loader(s) + iters_left = 1 + + # Define tqdm progress bar(s) + progress = tqdm.tqdm(range(1, iters+1)) + + # Loop over all iterations + for batch_index in range(1, iters+1): + + # Update # iters left on current data-loader(s) and, if needed, create new one(s) + iters_left -= 1 + if iters_left==0: + data_loader = iter(get_data_loader(train_dataset, batch_size, cuda=cuda, drop_last=True)) + iters_left = len(data_loader) + + # -----------------Collect data------------------# + x, y = next(data_loader) #--> sample training data of current context + y = y - model.classes_per_context * (context - 1) if (per_context and not per_context_singlehead) else y + # --> adjust the y-targets to the 'active range' + x, y = x.to(device), y.to(device) # --> transfer them to correct device + + #---> Train MAIN MODEL + if batch_index <= iters: + + # Optimiser step + loss_dict = model.optimizer.step(x, y, label_sets, context-1, model.classes_per_context) + + # Fire callbacks (for visualization of training-progress / evaluating performance after each context) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(progress, batch_index, loss_dict, context=context) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, batch_index, context=context) + + ##----------> UPON FINISHING EACH CONTEXT... + + # Close progres-bar(s) + progress.close() + + # MEMORY BUFFER: update the memory buffer + if checkattr(model, 'use_memory_buffer'): + samples_per_class = model.budget_per_class if (not model.use_full_capacity) else int( + np.floor((model.budget_per_class*len(train_datasets))/context) + ) + # reduce examplar-sets (only needed when '--use-full-capacity' is selected) + model.reduce_memory_sets(samples_per_class) + # for each new class trained on, construct examplar-set + new_classes = list(range(model.classes_per_context)) if ( + model.scenario=="domain" or per_context_singlehead + ) else list(range(model.classes_per_context*(context-1), model.classes_per_context*context)) + for class_id in new_classes: + # create new dataset containing only all examples of this class + class_dataset = SubDataset(original_dataset=train_dataset, sub_labels=[class_id]) + # based on this dataset, construct new memory-set for this class + allowed_classes = active_classes[-1] if per_context and not per_context_singlehead else active_classes + model.construct_memory_set(dataset=class_dataset, n=samples_per_class, label_set=allowed_classes) + model.compute_means = True + + # FROMP: update covariance (\Sigma) + if context the generative classifier to train + [train_datasets] with for each class the training + [iters] , # of optimization-steps (i.e., # of mini-batches) per class + [batch_size] , # of samples per mini-batch + [*_cbs] of call-back functions to evaluate training-progress + ''' + + # Use cuda? + device = model._device() + cuda = model._is_on_cuda() + + # Loop over all contexts. + classes_in_current_context = 0 + context = 1 + for class_id, train_dataset in enumerate(train_datasets): + + # Initialize # iters left on data-loader(s) + iters_left = 1 + + if epochs is not None: + data_loader = iter(get_data_loader(train_dataset, batch_size, cuda=cuda, drop_last=False)) + iters = len(data_loader)*epochs + + # Define a tqdm progress bar(s) + progress = tqdm.tqdm(range(1, iters+1)) + + # Loop over all iterations + for batch_index in range(1, iters+1): + + # Update # iters left on current data-loader(s) and, if needed, create new one(s) + iters_left -= 1 + if iters_left==0: + data_loader = iter(get_data_loader(train_dataset, batch_size, cuda=cuda, + drop_last=True if epochs is None else False)) + iters_left = len(data_loader) + + # Collect data + x, y = next(data_loader) #--> sample training data of current context + x, y = x.to(device), y.to(device) #--> transfer them to correct device + #y = y.expand(1) if len(y.size())==1 else y #--> hack for if batch-size is 1 + + # Select model to be trained + model_to_be_trained = getattr(model, "vae{}".format(class_id)) + + # Train the VAE model of this class with this batch + loss_dict = model_to_be_trained.train_a_batch(x) + + # Fire callbacks (for visualization of training-progress) + for loss_cb in loss_cbs: + if loss_cb is not None: + loss_cb(progress, batch_index, loss_dict, class_id=class_id) + for eval_cb in eval_cbs: + if eval_cb is not None: + eval_cb(model, batch_index+classes_in_current_context*iters, context=context) + for sample_cb in sample_cbs: + if sample_cb is not None: + sample_cb(model_to_be_trained, batch_index, class_id=class_id) + + # Close progres-bar(s) + progress.close() + + # Did a context just finish? + classes_in_current_context += 1 + if classes_in_current_context==model.classes_per_context: + # Run the callbacks after finishing each context + for context_cb in context_cbs: + if context_cb is not None: + context_cb(model, iters, context=context) + # Updated counts + classes_in_current_context = 0 + context += 1 diff --git a/PyTorch/build-in/other/continual-learning/utils.py b/PyTorch/build-in/other/continual-learning/utils.py new file mode 100644 index 000000000..095d3ac0f --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/utils.py @@ -0,0 +1,233 @@ +import os +import numpy as np +import pickle +import torch +from torchvision import transforms +import copy +import tqdm +from torch import nn +from torch.utils.data import DataLoader,TensorDataset +from models.fc import excitability_modules as em +from data.available import AVAILABLE_TRANSFORMS + +##-------------------------------------------------------------------------------------------------------------------## + +####################### +## General utilities ## +####################### + +def checkattr(args, attr): + '''Check whether attribute exists, whether it's a boolean and whether its value is True.''' + return hasattr(args, attr) and type(getattr(args, attr))==bool and getattr(args, attr) + +##-------------------------------------------------------------------------------------------------------------------## + +############################# +## Data-handling functions ## +############################# + +def get_data_loader(dataset, batch_size, cuda=False, drop_last=False, augment=False): + '''Return -object for the provided -object [dataset].''' + + # If requested, make copy of original dataset to add augmenting transform (without altering original dataset) + if augment: + dataset_ = copy.deepcopy(dataset) + dataset_.transform = transforms.Compose([dataset.transform, *AVAILABLE_TRANSFORMS['augment']]) + else: + dataset_ = dataset + + # Create and return the -object + return DataLoader( + dataset_, batch_size=batch_size, shuffle=True, drop_last=drop_last, + **({'num_workers': 0, 'pin_memory': True} if cuda else {}) + ) + +def to_one_hot(y, classes): + '''Convert a nd-array with integers [y] to a 2D "one-hot" tensor.''' + c = np.zeros(shape=[len(y), classes], dtype='float32') + c[range(len(y)), y] = 1. + c = torch.from_numpy(c) + return c + +##-------------------------------------------------------------------------------------------------------------------## + +########################################## +## Object-saving and -loading functions ## +########################################## + +def save_object(object, path): + with open(path + '.pkl', 'wb') as f: + pickle.dump(object, f, pickle.HIGHEST_PROTOCOL) + +def load_object(path): + with open(path + '.pkl', 'rb') as f: + return pickle.load(f) + +##-------------------------------------------------------------------------------------------------------------------## + +######################################### +## Model-saving and -loading functions ## +######################################### + +def save_checkpoint(model, model_dir, verbose=True, name=None): + '''Save state of [model] as dictionary to [model_dir] (if name is None, use "model.name").''' + # -name/path to store the checkpoint + name = model.name if name is None else name + path = os.path.join(model_dir, name) + # -if required, create directory in which to save checkpoint + if not os.path.exists(model_dir): + os.makedirs(model_dir) + # -create the dictionary containing the checkpoint + checkpoint = {'state': model.state_dict()} + if hasattr(model, 'mask_dict') and model.mask_dict is not None: + checkpoint['mask_dict'] = model.mask_dict + # -(try to) save the checkpoint + try: + torch.save(checkpoint, path) + if verbose: + print(' --> saved model {name} to {path}'.format(name=name, path=model_dir)) + except OSError: + print(" --> saving model '{}' failed!!".format(name)) + +def load_checkpoint(model, model_dir, verbose=True, name=None, strict=True): + '''Load saved state (in form of dictionary) at [model_dir] (if name is None, use "model.name") to [model].''' + # -path from where to load checkpoint + name = model.name if name is None else name + path = os.path.join(model_dir, name) + # load parameters (i.e., [model] will now have the state of the loaded model) + checkpoint = torch.load(path) + model.load_state_dict(checkpoint['state'], strict=strict) + if 'mask_dict' in checkpoint: + model.mask_dict = checkpoint['mask_dict'] + # notify that we succesfully loaded the checkpoint + if verbose: + print(' --> loaded checkpoint of {name} from {path}'.format(name=name, path=model_dir)) + +##-------------------------------------------------------------------------------------------------------------------## + +################################ +## Model-inspection functions ## +################################ + +def count_parameters(model, verbose=True): + '''Count number of parameters, print to screen.''' + total_params = learnable_params = fixed_params = 0 + for param in model.parameters(): + n_params = index_dims = 0 + for dim in param.size(): + n_params = dim if index_dims==0 else n_params*dim + index_dims += 1 + total_params += n_params + if param.requires_grad: + learnable_params += n_params + else: + fixed_params += n_params + if verbose: + print( "--> this network has {} parameters (~{} million)" + .format(total_params, round(total_params / 1000000, 1))) + print(" of which: - learnable: {} (~{} million)".format(learnable_params, + round(learnable_params / 1000000, 1))) + print(" - fixed: {} (~{} million)".format(fixed_params, round(fixed_params / 1000000, 1))) + return total_params, learnable_params, fixed_params + +def print_model_info(model, message=None): + '''Print information on [model] onto the screen.''' + print(55*"-" if message is None else ' {} '.format(message).center(55, '-')) + print(model) + print(55*"-") + _ = count_parameters(model) + +##-------------------------------------------------------------------------------------------------------------------## + +######################################## +## Parameter-initialization functions ## +######################################## + +def weight_reset(m): + '''Reinitializes parameters of [m] according to default initialization scheme.''' + if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear) or isinstance(m, em.LinearExcitability): + m.reset_parameters() + +def weight_init(model, strategy="xavier_normal", std=0.01): + '''Initialize weight-parameters of [model] according to [strategy]. + + [xavier_normal] "normalized initialization" (Glorot & Bengio, 2010) with Gaussian distribution + [xavier_uniform] "normalized initialization" (Glorot & Bengio, 2010) with uniform distribution + [normal] initialize with Gaussian(mean=0, std=[std]) + [...] ...''' + + # If [model] has an "list_init_layers"-attribute, only initialize parameters in those layers + if hasattr(model, "list_init_layers"): + module_list = model.list_init_layers() + parameters = [p for m in module_list for p in m.parameters()] + else: + parameters = [p for p in model.parameters()] + + # Initialize all weight-parameters (i.e., with dim of at least 2) + for p in parameters: + if p.dim() >= 2: + if strategy=="xavier_normal": + nn.init.xavier_normal_(p) + elif strategy=="xavier_uniform": + nn.init.xavier_uniform_(p) + elif strategy=="normal": + nn.init.normal_(p, std=std) + else: + raise ValueError("Invalid weight-initialization strategy {}".format(strategy)) + +def bias_init(model, strategy="constant", value=0.01): + '''Initialize bias-parameters of [model] according to [strategy]. + + [zero] set them all to zero + [constant] set them all to [value] + [positive] initialize with Uniform(a=0, b=[value]) + [any] initialize with Uniform(a=-[value], b=[value]) + [...] ...''' + + # If [model] has an "list_init_layers"-attribute, only initialize parameters in those layers + if hasattr(model, "list_init_layers"): + module_list = model.list_init_layers() + parameters = [p for m in module_list for p in m.parameters()] + else: + parameters = [p for p in model.parameters()] + + # Initialize all weight-parameters (i.e., with dim of at least 2) + for p in parameters: + if p.dim() == 1: + ## NOTE: be careful if excitability-parameters are added to the model!!!! + if strategy == "zero": + nn.init.constant_(p, val=0) + elif strategy == "constant": + nn.init.constant_(p, val=value) + elif strategy == "positive": + nn.init.uniform_(p, a=0, b=value) + elif strategy == "any": + nn.init.uniform_(p, a=-value, b=value) + else: + raise ValueError("Invalid bias-initialization strategy {}".format(strategy)) + +##-------------------------------------------------------------------------------------------------------------------## + +def preprocess(feature_extractor, dataset_list, config, batch=128, message=''): + '''Put a list of datasets through a feature-extractor, to return a new list of pre-processed datasets.''' + device = feature_extractor._device() + new_dataset_list = [] + progress_bar = tqdm.tqdm(total=len(dataset_list)) + progress_bar.set_description('{} | dataset {}/{} |'.format(message, 0, len(dataset_list))) + for dataset_id in range(len(dataset_list)): + loader = get_data_loader(dataset_list[dataset_id], batch_size=batch, drop_last=False, + cuda=feature_extractor._is_on_cuda()) + # -pre-allocate tensors, which will be filled slice-by-slice + all_features = torch.empty((len(loader.dataset), config['channels'], config['size'], config['size'])) + all_labels = torch.empty((len(loader.dataset)), dtype=torch.long) + count = 0 + for x, y in loader: + x = feature_extractor(x.to(device)).cpu() + all_features[count:(count+x.shape[0])] = x + all_labels[count:(count+x.shape[0])] = y + count += x.shape[0] + new_dataset_list.append(TensorDataset(all_features, all_labels)) + progress_bar.update(1) + progress_bar.set_description('{} | dataset {}/{} |'.format(message, dataset_id + 1, len(dataset_list))) + progress_bar.close() + return new_dataset_list \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/visual/__init__.py b/PyTorch/build-in/other/continual-learning/visual/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/PyTorch/build-in/other/continual-learning/visual/visual_plt.py b/PyTorch/build-in/other/continual-learning/visual/visual_plt.py new file mode 100644 index 000000000..c5ec0deba --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/visual/visual_plt.py @@ -0,0 +1,380 @@ +import matplotlib +matplotlib.use('Agg') +# above 2 lines set the matplotlib backend to 'Agg', which +# enables matplotlib-plots to also be generated if no X-server +# is defined (e.g., when running in basic Docker-container) +import matplotlib.pyplot as plt +from matplotlib.backends.backend_pdf import PdfPages +from torchvision.utils import make_grid +import numpy as np + + +def open_pdf(full_path): + return PdfPages(full_path) + + +def plot_images_from_tensor(image_tensor, pdf=None, nrow=8, title=None): + '''Plot images in [image_tensor] as a grid with [nrow] into [pdf]. + + [image_tensor] [batch_size]x[channels]x[width]x[height]''' + + image_grid = make_grid(image_tensor, nrow=nrow, pad_value=1) # pad_value=0 would give black borders + plt.imshow(np.transpose(image_grid.numpy(), (1,2,0))) + if title: + plt.title(title) + if pdf is not None: + pdf.savefig() + + +def plot_scatter_groups(x, y, colors=None, ylabel=None, xlabel=None, title=None, top_title=None, names=None, + xlim=None, ylim=None, markers=None, figsize=None): + '''Generate a figure containing a scatter-plot.''' + + # if needed, generate default group-names + if names == None: + n_groups = len(y) + names = ["group " + str(id) for id in range(n_groups)] + + # make plot + f, axarr = plt.subplots(1, 1, figsize=(12, 7) if figsize is None else figsize) + for i,name in enumerate(names): + # plot individual points + axarr.scatter(x=x[i], y=y[i], color=None if (colors is None) else colors[i], + marker="o" if markers is None else markers[i], s=40, alpha=0.5) + # plot group means + axarr.scatter(x=np.mean(x[i]), y=np.mean(y[i]), color=None if (colors is None) else colors[i], label=name, + marker="*" if markers is None else markers[i], s=160) + + # finish layout + # -set y/x-axis + if ylim is not None: + axarr.set_ylim(ylim) + if xlim is not None: + axarr.set_xlim(xlim) + # -add axis-labels + if xlabel is not None: + axarr.set_xlabel(xlabel) + if ylabel is not None: + axarr.set_ylabel(ylabel) + # -add title(s) + if title is not None: + axarr.set_title(title) + if top_title is not None: + f.suptitle(top_title) + # -add legend + if names is not None: + axarr.legend() + + # return the figure + return f + + +def plot_bar(numbers, names=None, colors=None, ylabel=None, title=None, top_title=None, ylim=None, figsize=None, + yerr=None): + '''Generate a figure containing a bar-graph.''' + + # number of bars + n_bars = len(numbers) + + # make plot + size = (12,7) if figsize is None else figsize + f, axarr = plt.subplots(1, 1, figsize=size) + axarr.bar(x=range(n_bars), height=numbers, color=colors, yerr=yerr) + + # finish layout + axarr.set_xticks(range(n_bars)) + if names is not None: + axarr.set_xticklabels(names, rotation=-20) + axarr.legend() + if ylabel is not None: + axarr.set_ylabel(ylabel) + if title is not None: + axarr.set_title(title) + if top_title is not None: + f.suptitle(top_title) + # -set y-axis + if ylim is not None: + axarr.set_ylim(ylim) + + # return the figure + return f + + +def plot_lines(list_with_lines, x_axes=None, line_names=None, colors=None, title=None, + title_top=None, xlabel=None, ylabel=None, ylim=None, figsize=None, list_with_errors=None, errors="shaded", + x_log=False, with_dots=False, linestyle='solid', h_line=None, h_label=None, h_error=None, + h_lines=None, h_colors=None, h_labels=None, h_errors=None, + v_line=None, v_label=None): + '''Generates a figure containing multiple lines in one plot. + + :param list_with_lines: of all lines to plot (with each line being a as well) + :param x_axes: containing the values for the x-axis + :param line_names: containing the names of each line + :param colors: containing the colors of each line + :param title: title of plot + :param title_top: text to appear on top of the title + :return: f:
+ ''' + + # if needed, generate default x-axis + if x_axes == None: + n_obs = len(list_with_lines[0]) + x_axes = list(range(n_obs)) + + # if needed, generate default line-names + if line_names == None: + n_lines = len(list_with_lines) + line_names = ["line " + str(line_id) for line_id in range(n_lines)] + + # make plot + size = (12,7) if figsize is None else figsize + f, axarr = plt.subplots(1, 1, figsize=size) + + # add error-lines / shaded areas + if list_with_errors is not None: + for line_id, name in enumerate(line_names): + if errors=="shaded": + axarr.fill_between(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])), + list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])), + color=None if (colors is None) else colors[line_id], alpha=0.25) + else: + axarr.plot(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])), label=None, + color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed') + axarr.plot(x_axes, list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])), label=None, + color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed') + + # mean lines + for line_id, name in enumerate(line_names): + axarr.plot(x_axes, list_with_lines[line_id], label=name, + color=None if (colors is None) else colors[line_id], + linewidth=4, marker='o' if with_dots else None, linestyle=linestyle if type(linestyle)==str else linestyle[line_id]) + + # add horizontal line + if h_line is not None: + axarr.axhline(y=h_line, label=h_label, color="grey") + if h_error is not None: + if errors == "shaded": + axarr.fill_between([x_axes[0], x_axes[-1]], + [h_line + h_error, h_line + h_error], [h_line - h_error, h_line - h_error], + color="grey", alpha=0.25) + else: + axarr.axhline(y=h_line + h_error, label=None, color="grey", linewidth=1, linestyle='dashed') + axarr.axhline(y=h_line - h_error, label=None, color="grey", linewidth=1, linestyle='dashed') + + # add horizontal lines + if h_lines is not None: + h_colors = colors if h_colors is None else h_colors + for line_id, new_h_line in enumerate(h_lines): + axarr.axhline(y=new_h_line, label=None if h_labels is None else h_labels[line_id], + color=None if (h_colors is None) else h_colors[line_id]) + if h_errors is not None: + if errors == "shaded": + axarr.fill_between([x_axes[0], x_axes[-1]], + [new_h_line + h_errors[line_id], new_h_line+h_errors[line_id]], + [new_h_line - h_errors[line_id], new_h_line - h_errors[line_id]], + color=None if (h_colors is None) else h_colors[line_id], alpha=0.25) + else: + axarr.axhline(y=new_h_line+h_errors[line_id], label=None, + color=None if (h_colors is None) else h_colors[line_id], linewidth=1, + linestyle='dashed') + axarr.axhline(y=new_h_line-h_errors[line_id], label=None, + color=None if (h_colors is None) else h_colors[line_id], linewidth=1, + linestyle='dashed') + + # add vertical line(s) + if v_line is not None: + if type(v_line)==list: + for id,new_line in enumerate(v_line): + axarr.axvline(x=new_line, label=v_label if id==0 else None, color='black') + else: + axarr.axvline(x=v_line, label=v_label, color='black') + + # finish layout + # -set y-axis + if ylim is not None: + axarr.set_ylim(ylim) + # -add axis-labels + if xlabel is not None: + axarr.set_xlabel(xlabel) + if ylabel is not None: + axarr.set_ylabel(ylabel) + # -add title(s) + if title is not None: + axarr.set_title(title) + if title_top is not None: + f.suptitle(title_top) + # -add legend + if line_names is not None: + axarr.legend() + # -set x-axis to log-scale + if x_log: + axarr.set_xscale('log') + + # return the figure + return f + + + + + +def plot_lines_with_baselines( + list_with_lines, x_axes=None, line_names=None, colors=None, title=None, title_top=None, xlabel=None, + ylabel=None, ylim=None, figsize=None, list_with_errors=None, errors="shaded", x_log=False, with_dots=False, + linestyle='solid', h_lines=None, h_colors=None, h_labels=None, h_errors=None +): + '''Generates a figure containing multiple lines, with a sideplot depicting the baselines (i.e., [h_lines]). + + :param list_with_lines: of all lines to plot (with each line being a as well) + :param x_axes: containing the values for the x-axis + :param line_names: containing the names of each line + :param colors: containing the colors of each line + :param title: title of plot + :param title_top: text to appear on top of the title + :return: f:
+ ''' + + # if needed, generate default x-axis + if x_axes == None: + n_obs = len(list_with_lines[0]) + x_axes = list(range(n_obs)) + + # if needed, generate default line-names + if line_names == None: + n_lines = len(list_with_lines) + line_names = ["line " + str(line_id) for line_id in range(n_lines)] + + # make plot + size = (12, 7) if figsize is None else figsize + f, (ax0, ax1) = plt.subplots(1, 2, gridspec_kw={'width_ratios': [1, 3]}, figsize=size) + + # add error-lines / shaded areas + if list_with_errors is not None: + for line_id, name in enumerate(line_names): + if errors == "shaded": + ax1.fill_between(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])), + list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])), + color=None if (colors is None) else colors[line_id], alpha=0.25) + else: + ax1.plot(x_axes, list(np.array(list_with_lines[line_id]) + np.array(list_with_errors[line_id])), + label=None, + color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed') + ax1.plot(x_axes, list(np.array(list_with_lines[line_id]) - np.array(list_with_errors[line_id])), + label=None, + color=None if (colors is None) else colors[line_id], linewidth=1, linestyle='dashed') + + # mean lines + for line_id, name in enumerate(line_names): + ax1.plot(x_axes, list_with_lines[line_id], label=name, + color=None if (colors is None) else colors[line_id], + linewidth=2, marker='o' if with_dots else None, + linestyle=linestyle if type(linestyle) == str else linestyle[line_id]) + + # add horizontal lines + if h_lines is not None: + h_colors = colors if h_colors is None else h_colors + for line_id, new_h_line in enumerate(h_lines): + ax0.plot([line_id - 0.45, line_id + 0.45], [new_h_line, new_h_line], + label=None if h_labels is None else h_labels[line_id], + color=None if (h_colors is None) else h_colors[line_id]) + if h_errors is not None: + if errors == "shaded": + ax0.fill_between([line_id - 0.45, line_id + 0.45], + [new_h_line + h_errors[line_id], new_h_line + h_errors[line_id]], + [new_h_line - h_errors[line_id], new_h_line - h_errors[line_id]], + color=None if (h_colors is None) else h_colors[line_id], alpha=0.25) + else: + ax0.plot([line_id - 0.45, line_id + 0.45], + [new_h_line + h_errors[line_id], new_h_line + h_errors[line_id]], label=None, + color=None if (h_colors is None) else h_colors[line_id], linewidth=1, + linestyle='dashed') + ax0.plot([line_id - 0.45, line_id + 0.45], + [new_h_line - h_errors[line_id], new_h_line - h_errors[line_id]], label=None, + color=None if (h_colors is None) else h_colors[line_id], linewidth=1, + linestyle='dashed') + + # ax0.axis('off') + ax0.set_xticks([]) + # ax0.set_axis_on() + + # finish layout + # -set y-axis + if ylim is None: + ylim0 = ax0.get_ylim() + ylim1 = ax1.get_ylim() + ylim = (min(ylim0[0], ylim1[0]), max(ylim0[1], ylim1[1])) + ax0.set_ylim(ylim) + ax1.set_ylim(ylim) + # -add axis-labels + if xlabel is not None: + ax1.set_xlabel(xlabel) + if ylabel is not None: + ax0.set_ylabel(ylabel) + # -add title(s) + if title is not None: + ax1.set_title(title) + if title_top is not None: + f.suptitle(title_top) + # -add legend(s) + if line_names is not None: + ax1.legend() + if h_labels is not None: + ax0.legend() + + # -set x-axis to log-scale + if x_log: + ax1.set_xscale('log') + + # return the figure + return f + + + + +def plot_bars(number_list, names=None, colors=None, ylabel=None, title_list=None, top_title=None, ylim=None, + figsize=None, yerr=None): + '''Generate a figure containing multiple bar-graphs. + + [number_list] with of numbers to plot in each sub-graph + [names] (with ) of names for axis + [colors] (with ) of colors''' + + # number of plots + n_plots = len(number_list) + + # number of bars per plot + n_bars = [] + for i in range(n_plots): + n_bars.append(len(number_list[i])) + + # decide on scale y-axis + y_max = np.max(number_list)+0.07*np.max(number_list) + + # make figure + size = (16,7) if figsize is None else figsize + f, axarr = plt.subplots(1, n_plots, figsize=size) + + # make all plots + for i in range(n_plots): + axarr[i].bar(x=range(n_bars[i]), height=number_list[i], color=colors[i] if type(colors[0])==list else colors, + yerr=yerr[i] if yerr is not None else None) + + # finish layout for this plot + if ylim is None: + axarr[i].set_ylim(0, y_max) + else: + axarr[i].set_ylim(ylim) + axarr[i].set_xticks(range(n_bars[i])) + if names is not None: + axarr[i].set_xticklabels(names[i] if type(names[0])==list else names, rotation=-20) + axarr[i].legend() + if i==0 and ylabel is not None: + axarr[i].set_ylabel(ylabel) + if title_list is not None: + axarr[i].set_title(title_list[i]) + + # finish global layout + if top_title is not None: + f.suptitle(top_title) + + # return the figure + return f \ No newline at end of file diff --git a/PyTorch/build-in/other/continual-learning/visual/visual_visdom.py b/PyTorch/build-in/other/continual-learning/visual/visual_visdom.py new file mode 100644 index 000000000..a9fff0c90 --- /dev/null +++ b/PyTorch/build-in/other/continual-learning/visual/visual_visdom.py @@ -0,0 +1,35 @@ +import numpy as np + +_WINDOW_CASH = {} + + +def visualize_images(tensor, title, env, win=None, w=400, h=400, nrow=8): + '''Plot images contained in 4D-tensor [tensor] to visdom-server.''' + options = dict(title=title, width=w, height=h) + win = title if win is None else win + _WINDOW_CASH[win] = env.images(tensor, win=_WINDOW_CASH.get(win), nrow=nrow, opts=options) + + +def visualize_scalars(scalars, names, title, iteration, env, ylabel=None): + '''Continually update line-plot with numbers arriving in [scalars].''' + assert len(scalars) == len(names) + + # Convert scalar tensors to numpy arrays. + scalars, names = list(scalars), list(names) + scalars = [s.cpu().numpy() if (hasattr(s, 'cpu') and hasattr(s.cpu(), 'numpy')) else np.array([s]) for s in scalars] + num = len(scalars) + X = np.column_stack(np.array([iteration] * num)) if (num>1) else np.array([iteration] * num) + Y = np.column_stack(scalars) if (num>1) else scalars[0] + + # Plotting options + options = dict( + fillarea=False, legend=names, width=400, height=400, + xlabel='Iterations', ylabel=title if (ylabel is None) else ylabel, title=title, + marginleft=30, marginright=30, marginbottom=80, margintop=30, + ) + + # Update plot (or start new one if not yet present) + if title in _WINDOW_CASH: + env.line(X=X, Y=Y, win=_WINDOW_CASH[title], opts=options, update='append') + else: + _WINDOW_CASH[title] = env.line(X=X, Y=Y, opts=options)