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 000000000..afb9d51bb Binary files /dev/null and b/PyTorch/build-in/other/continual-learning/figures/rotatedMNIST.png differ 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 000000000..a118d1bf0 Binary files /dev/null and b/PyTorch/build-in/other/continual-learning/figures/splitMNIST_results_tutorial.png differ 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 000000000..72d129f84 Binary files /dev/null and b/PyTorch/build-in/other/continual-learning/figures/splitMNIST_schematic.png differ diff --git a/PyTorch/build-in/other/continual-learning/figures/stabilityGap.png b/PyTorch/build-in/other/continual-learning/figures/stabilityGap.png new file mode 100644 index 000000000..e8a3a7c21 Binary files /dev/null and b/PyTorch/build-in/other/continual-learning/figures/stabilityGap.png differ 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 000000000..f5aa4dfed Binary files /dev/null and b/PyTorch/build-in/other/continual-learning/figures/strategies.png differ 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)