├── .gitignore
├── .readthedocs.yml
├── LICENSE
├── MANIFEST.in
├── README.md
├── docs
    ├── Makefile
    ├── build
    │   ├── doctrees
    │   │   ├── environment.pickle
    │   │   ├── iirc.doctree
    │   │   ├── iirc.lifelong_dataset.doctree
    │   │   ├── iirc.utils.doctree
    │   │   ├── iirc_tutorial.doctree
    │   │   ├── index.doctree
    │   │   ├── lifelong_methods.buffer.doctree
    │   │   ├── lifelong_methods.doctree
    │   │   ├── lifelong_methods.methods.doctree
    │   │   ├── lifelong_methods.models.doctree
    │   │   ├── lifelong_methods_guide.doctree
    │   │   ├── loading_datasets_tutorial.doctree
    │   │   ├── modules.doctree
    │   │   └── nbsphinx
    │   │   │   ├── iirc_tutorial.ipynb
    │   │   │   └── loading_datasets_tutorial.ipynb
    │   └── html
    │   │   ├── .buildinfo
    │   │   ├── _sources
    │   │       ├── iirc.lifelong_dataset.rst.txt
    │   │       ├── iirc.rst.txt
    │   │       ├── iirc.utils.rst.txt
    │   │       ├── iirc_tutorial.ipynb.txt
    │   │       ├── index.rst.txt
    │   │       ├── lifelong_methods.buffer.rst.txt
    │   │       ├── lifelong_methods.methods.rst.txt
    │   │       ├── lifelong_methods.models.rst.txt
    │   │       ├── lifelong_methods.rst.txt
    │   │       ├── lifelong_methods_guide.md.txt
    │   │       ├── loading_datasets_tutorial.ipynb.txt
    │   │       └── modules.rst.txt
    │   │   ├── _static
    │   │       ├── basic.css
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   ├── fonts
    │   │       │   │   ├── Roboto-Slab-Bold.woff
    │   │       │   │   ├── Roboto-Slab-Bold.woff2
    │   │       │   │   ├── Roboto-Slab-Regular.woff
    │   │       │   │   ├── Roboto-Slab-Regular.woff2
    │   │       │   │   ├── fontawesome-webfont.eot
    │   │       │   │   ├── fontawesome-webfont.svg
    │   │       │   │   ├── fontawesome-webfont.ttf
    │   │       │   │   ├── fontawesome-webfont.woff
    │   │       │   │   ├── fontawesome-webfont.woff2
    │   │       │   │   ├── lato-bold-italic.woff
    │   │       │   │   ├── lato-bold-italic.woff2
    │   │       │   │   ├── lato-bold.woff
    │   │       │   │   ├── lato-bold.woff2
    │   │       │   │   ├── lato-normal-italic.woff
    │   │       │   │   ├── lato-normal-italic.woff2
    │   │       │   │   ├── lato-normal.woff
    │   │       │   │   └── lato-normal.woff2
    │   │       │   └── theme.css
    │   │       ├── doctools.js
    │   │       ├── documentation_options.js
    │   │       ├── file.png
    │   │       ├── jquery-3.5.1.js
    │   │       ├── jquery.js
    │   │       ├── js
    │   │       │   ├── badge_only.js
    │   │       │   ├── html5shiv-printshiv.min.js
    │   │       │   ├── html5shiv.min.js
    │   │       │   └── theme.js
    │   │       ├── language_data.js
    │   │       ├── minus.png
    │   │       ├── plus.png
    │   │       ├── pygments.css
    │   │       ├── searchtools.js
    │   │       ├── underscore-1.3.1.js
    │   │       └── underscore.js
    │   │   ├── genindex.html
    │   │   ├── iirc.html
    │   │   ├── iirc.lifelong_dataset.html
    │   │   ├── iirc.utils.html
    │   │   ├── iirc_tutorial.html
    │   │   ├── iirc_tutorial.ipynb
    │   │   ├── index.html
    │   │   ├── lifelong_methods.buffer.html
    │   │   ├── lifelong_methods.html
    │   │   ├── lifelong_methods.methods.html
    │   │   ├── lifelong_methods.models.html
    │   │   ├── lifelong_methods_guide.html
    │   │   ├── loading_datasets_tutorial.html
    │   │   ├── loading_datasets_tutorial.ipynb
    │   │   ├── modules.html
    │   │   ├── objects.inv
    │   │   ├── py-modindex.html
    │   │   ├── search.html
    │   │   └── searchindex.js
    ├── images
    │   └── task_summary.png
    ├── make.bat
    ├── requirements.txt
    └── source
    │   ├── conf.py
    │   ├── iirc.lifelong_dataset.rst
    │   ├── iirc.rst
    │   ├── iirc.utils.rst
    │   ├── iirc_tutorial.ipynb
    │   ├── index.rst
    │   ├── lifelong_methods.buffer.rst
    │   ├── lifelong_methods.methods.rst
    │   ├── lifelong_methods.models.rst
    │   ├── lifelong_methods.rst
    │   ├── lifelong_methods_guide.md
    │   ├── loading_datasets_tutorial.ipynb
    │   └── modules.rst
├── experiments
    ├── __init__.py
    ├── create_confusion_matrix.py
    ├── experiments_configurations
    │   ├── __init__.py
    │   ├── configurations_cifar.json
    │   ├── configurations_imagenet_full.json
    │   └── configurations_imagenet_lite.json
    ├── main.py
    ├── metrics.py
    ├── prepare_config.py
    ├── tests
    │   ├── __init__.py
    │   ├── test_metrics.py
    │   └── test_utils.py
    ├── train.py
    └── utils.py
├── iirc.egg-info
    ├── PKG-INFO
    ├── SOURCES.txt
    ├── dependency_links.txt
    ├── requires.txt
    └── top_level.txt
├── iirc
    ├── README.md
    ├── __init__.py
    ├── datasets_loader.py
    ├── definitions.py
    ├── lifelong_dataset
    │   ├── __init__.py
    │   ├── base_dataset.py
    │   ├── tensorflow_dataset.py
    │   └── torch_dataset.py
    ├── metadata
    │   ├── cifar100_classes.json
    │   ├── dataset_configurations.json
    │   ├── iirc_cifar100_hierarchy.json
    │   ├── iirc_cifar100_task_configurations.json
    │   ├── iirc_imagenet_full_task_configurations.json
    │   ├── iirc_imagenet_hierarchy_wnids.json
    │   ├── iirc_imagenet_hierarchy_words.json
    │   ├── iirc_imagenet_lite_task_configurations.json
    │   ├── imagenet_classes.json
    │   ├── incremental_cifar100_task_configurations.json
    │   ├── incremental_imagenet_full_task_configurations.json
    │   └── incremental_imagenet_lite_task_configurations.json
    ├── tests
    │   ├── __init__.py
    │   ├── conftest.py
    │   ├── test_get_dataset.py
    │   ├── test_load_iirc_dataset.py
    │   └── test_torch_dataset_classes.py
    └── utils
    │   ├── __init__.py
    │   ├── download_cifar.py
    │   ├── prepare_imagenet.py
    │   └── utils.py
├── index.md
├── lifelong_methods
    ├── README.md
    ├── __init__.py
    ├── buffer
    │   ├── __init__.py
    │   └── buffer.py
    ├── methods
    │   ├── __init__.py
    │   ├── agem.py
    │   ├── base_method.py
    │   ├── finetune.py
    │   ├── icarl.py
    │   ├── icarl_cnn.py
    │   ├── icarl_norm.py
    │   ├── lucir.py
    │   └── mask_seen_classes.py
    ├── models
    │   ├── __init__.py
    │   ├── cosine_linear.py
    │   ├── mlp.py
    │   ├── resnet.py
    │   └── resnetcifar.py
    └── utils.py
└── setup.py


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | share/python-wheels/
 24 | *.egg-info/
 25 | .installed.cfg
 26 | *.egg
 27 | MANIFEST
 28 | 
 29 | # PyInstaller
 30 | #  Usually these files are written by a python script from a template
 31 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 32 | *.manifest
 33 | *.spec
 34 | 
 35 | # Installer logs
 36 | pip-log.txt
 37 | pip-delete-this-directory.txt
 38 | 
 39 | # Unit test / coverage reports
 40 | htmlcov/
 41 | .tox/
 42 | .nox/
 43 | .coverage
 44 | .coverage.*
 45 | .cache
 46 | nosetests.xml
 47 | coverage.xml
 48 | *.cover
 49 | *.py,cover
 50 | .hypothesis/
 51 | .pytest_cache/
 52 | cover/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | .pybuilder/
 76 | target/
 77 | 
 78 | # Jupyter Notebook
 79 | .ipynb_checkpoints
 80 | 
 81 | # IPython
 82 | profile_default/
 83 | ipython_config.py
 84 | 
 85 | # pyenv
 86 | #   For a library or package, you might want to ignore these files since the code is
 87 | #   intended to run in multiple environments; otherwise, check them in:
 88 | # .python-version
 89 | 
 90 | # pipenv
 91 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 92 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 93 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 94 | #   install all needed dependencies.
 95 | #Pipfile.lock
 96 | 
 97 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 98 | __pypackages__/
 99 | 
100 | # Celery stuff
101 | celerybeat-schedule
102 | celerybeat.pid
103 | 
104 | # SageMath parsed files
105 | *.sage.py
106 | 
107 | # Environments
108 | .env
109 | .venv
110 | env/
111 | venv/
112 | ENV/
113 | env.bak/
114 | venv.bak/
115 | 
116 | # Spyder project settings
117 | .spyderproject
118 | .spyproject
119 | 
120 | # Rope project settings
121 | .ropeproject
122 | 
123 | # mkdocs documentation
124 | /site
125 | 
126 | # mypy
127 | .mypy_cache/
128 | .dmypy.json
129 | dmypy.json
130 | 
131 | # Pyre type checker
132 | .pyre/
133 | 
134 | # pytype static type analyzer
135 | .pytype/
136 | 
137 | # Cython debug symbols
138 | cython_debug/
139 | 
140 | /experiments/experiments_configurations/cluster_experiments_scheduler.py
141 | /experiments/data/cifar-100-python/
142 | /experiments/data/cifar-100-python.tar.gz
143 | .DS_Store
144 | .vscode/settings.json
145 | 


--------------------------------------------------------------------------------
/.readthedocs.yml:
--------------------------------------------------------------------------------
 1 | # .readthedocs.yml
 2 | # Read the Docs configuration file
 3 | # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
 4 | 
 5 | # Required
 6 | version: 1
 7 | 
 8 | # Build documentation in the docs/ directory with Sphinx
 9 | sphinx:
10 |   configuration: docs/source/conf.py
11 | 
12 | # Build documentation with MkDocs
13 | #mkdocs:
14 | #  configuration: mkdocs.yml
15 | 
16 | # Optionally build your docs in additional formats such as PDF
17 | #formats:
18 | #  - pdf
19 | 
20 | # Optionally set the version of Python and requirements required to build your docs
21 | python:
22 |   version: 3.8
23 |   install:
24 |     - requirements: docs/requirements.txt
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 chandar-lab
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | # Include the README
 2 | include iirc/*.md
 3 | 
 4 | # Include the license file
 5 | include LICENSE*
 6 | 
 7 | # Include setup.py
 8 | include setup.py
 9 | 
10 | # Include the metadata
11 | include iirc/metadata/*.json


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # IIRC: Incremental Implicitly-Refined Classification 
 2 | ![img.png](https://raw.githubusercontent.com/chandar-lab/IIRC/master/docs/images/task_summary.png)
 3 | 
 4 | This is the implementation of the [IIRC paper](https://arxiv.org/abs/2012.12477).
 5 | IIRC is a setup and benchmark to evaluate lifelong learning models in more dynamic and real-life aligned scenarios, where the labels are changing in a dynamic way and the models have to use what they have learnt to incorporate these changes into their knowledge. Further details can be found [here](https://arxiv.org/abs/2012.12477).
 6 | 
 7 | It contains the following two packages as well: **iirc** and **lifelong_methods** 
 8 | 
 9 | **iirc** is a package for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to 
10 | the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner.
11 | 
12 | **lifelong_methods** is a package that standardizes the different stages any lifelong learning method passes by, 
13 | hence it provides a faster way for implementing new ideas and embedding them in the same training code as other 
14 | baselines, it provides as well the implementation of some of these baselines. 
15 | 
16 | The documentation of these packages is available [here](https://iirc.readthedocs.io/en/latest/)
17 | 
18 | [Homepage](https://chandar-lab.github.io/IIRC/) | [Paper](https://arxiv.org/abs/2012.12477) | 
19 | [PyPI Package](https://pypi.org/project/iirc/) | [Package Documentation](https://iirc.readthedocs.io/en/latest/)
20 | 
21 | ## Running Instructions
22 | The starting point for running this code is experiments/main.py. 
23 | 
24 | The hyperparameter configurations used in the paper are available in a Json format 
25 | experiments/experiments_configurations folder.  
26 | 
27 | For example, for reproducing the results of experience replay on iirc-ImageNet-lite with a buffer of 20 samples per class:
28 | ```buildoutcfg
29 | python main.py --dataset iirc_imagenet_lite --dataset_path "./data/imagenet" --epochs_per_task 100 --batch_size 128 
30 | --seed 100 --logging_path_root "./results" -n_layers 50 --tasks_configuration_id 0 --method finetune --optimizer 
31 | momentum --lr 0.1 lr_gamma 0.1 --reduce_lr_on_plateau --weight_decay 1e-5 --use_best_model --n_memories_per_class 20
32 | ```
33 | ### Requirements
34 | This code has been tested with python 3.8.2 and the following packages:
35 | 
36 | pytorch==1.5.0
37 | <br/>
38 | torchvision==0.6.0
39 | <br/>
40 | numpy==1.18.5
41 | <br/>
42 | Pillow==7.0.0
43 | <br/>
44 | lmdb==1.0.0
45 | <br/>
46 | git+https://git@github.com/shagunsodhani/ml-logger.git@976cab1d2524ee72aef8273e6deb25c764883f3e#egg=mllogger[all] (used for logging)
47 | <br/>
48 | seaborn==0.10.1 (optional)
49 | <br/>
50 | pytest==5.4.3 (optional)
51 | <br/>
52 | pytest-cov==2.9.0 (optional)
53 | <br/>
54 | 
55 | ### CIFAR-100
56 | To be able to run the code with *CIFAR-100* derived datasets, just download the dataset from the 
57 | [official website](https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz) and extract it, or use the 
58 | *iirc/utils/download_cifar.py* file. 
59 | 
60 | The path that should be provided in the *dataset_path* argument, when running 
61 | *main.py*, is the path of the parent directory of the extracted *cifar-100-python* folder.
62 | 
63 | ### ImageNet
64 | In the case of ImageNet, it has to be downloaded manually, and be arranged in the following manner: 
65 | * dataset folder
66 |   * train 
67 |     * n01440764
68 |     * n01443537
69 |     * …
70 |   * val 
71 |     * n01440764 
72 |     * n01443537 
73 |     * …
74 | 
75 | The path that should be provided in the *dataset_path* argument, when running 
76 | *main.py*, is the path of the *dataset folder* in the previous arrangement.
77 | 
78 | **It's better to provide the dataset_path as an absolute path**
79 | 
80 | ## Contributing
81 | If you think you can help us make the **iirc** and **lifelong_methods** packages more useful for the lifelong learning 
82 | community, please don't hesistate to submit an issue or send a pull request.
83 | 
84 | ## Citation
85 | 
86 | If you find this work useful for your research, this is the way to cite it:
87 | 
88 | ```
89 | @misc{abdelsalam2021iirc,
90 | title = {IIRC: Incremental Implicitly-Refined Classification},
91 | author={Mohamed Abdelsalam and Mojtaba Faramarzi and Shagun Sodhani and Sarath Chandar},
92 | year={2021}, eprint={2012.12477}, archivePrefix={arXiv},
93 | primaryClass={cs.CV}}
94 | ```
95 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line, and also
 5 | # from the environment for the first two.
 6 | SPHINXOPTS    ?=
 7 | SPHINXBUILD   ?= sphinx-build
 8 | SOURCEDIR     = source
 9 | BUILDDIR      = build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
21 | 


--------------------------------------------------------------------------------
/docs/build/doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/environment.pickle


--------------------------------------------------------------------------------
/docs/build/doctrees/iirc.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/iirc.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/iirc.lifelong_dataset.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/iirc.lifelong_dataset.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/iirc.utils.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/iirc.utils.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/iirc_tutorial.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/iirc_tutorial.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/index.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/lifelong_methods.buffer.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/lifelong_methods.buffer.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/lifelong_methods.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/lifelong_methods.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/lifelong_methods.methods.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/lifelong_methods.methods.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/lifelong_methods.models.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/lifelong_methods.models.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/lifelong_methods_guide.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/lifelong_methods_guide.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/loading_datasets_tutorial.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/loading_datasets_tutorial.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/modules.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/doctrees/modules.doctree


--------------------------------------------------------------------------------
/docs/build/html/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: ce6343199571faaeb2984051e9e8d6eb
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/iirc.lifelong_dataset.rst.txt:
--------------------------------------------------------------------------------
 1 | iirc.lifelong\_dataset package
 2 | ==============================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | iirc.lifelong\_dataset.base\_dataset module
 8 | -------------------------------------------
 9 | 
10 | .. automodule:: iirc.lifelong_dataset.base_dataset
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | iirc.lifelong\_dataset.tensorflow\_dataset module
16 | -------------------------------------------------
17 | 
18 | .. automodule:: iirc.lifelong_dataset.tensorflow_dataset
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | iirc.lifelong\_dataset.torch\_dataset module
24 | --------------------------------------------
25 | 
26 | .. automodule:: iirc.lifelong_dataset.torch_dataset
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | Module contents
32 | ---------------
33 | 
34 | .. automodule:: iirc.lifelong_dataset
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/iirc.rst.txt:
--------------------------------------------------------------------------------
 1 | iirc package
 2 | ============
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    iirc.lifelong_dataset
11 |    iirc.utils
12 | 
13 | Submodules
14 | ----------
15 | 
16 | iirc.datasets\_loader module
17 | ----------------------------
18 | 
19 | .. automodule:: iirc.datasets_loader
20 |    :members:
21 |    :undoc-members:
22 |    :show-inheritance:
23 | 
24 | iirc.definitions module
25 | -----------------------
26 | 
27 | .. automodule:: iirc.definitions
28 |    :members:
29 |    :undoc-members:
30 |    :show-inheritance:
31 | 
32 | Module contents
33 | ---------------
34 | 
35 | .. automodule:: iirc
36 |    :members:
37 |    :undoc-members:
38 |    :show-inheritance:
39 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/iirc.utils.rst.txt:
--------------------------------------------------------------------------------
 1 | iirc.utils package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | iirc.utils.download\_cifar module
 8 | ---------------------------------
 9 | 
10 | .. automodule:: iirc.utils.download_cifar
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | iirc.utils.prepare\_imagenet module
16 | -----------------------------------
17 | 
18 | .. automodule:: iirc.utils.prepare_imagenet
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | iirc.utils.utils module
24 | -----------------------
25 | 
26 | .. automodule:: iirc.utils.utils
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | Module contents
32 | ---------------
33 | 
34 | .. automodule:: iirc.utils
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/index.rst.txt:
--------------------------------------------------------------------------------
 1 | .. IIRC documentation master file, created by
 2 |    sphinx-quickstart on Fri Jan  8 15:55:04 2021.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Welcome to IIRC's documentation!
 7 | ================================
 8 | .. image:: ../images/task_summary.png
 9 |    :width: 600
10 |    :alt: IIRC Setup
11 | 
12 | **iirc** is a package for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to
13 | the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner.
14 | 
15 | **lifelong_methods** is a package that standardizes the different stages any lifelong learning method passes by,
16 | hence it provides a faster way for implementing new ideas and embedding them in the same training code as other
17 | baselines, it provides as well the implementation of some of these baselines.
18 | 
19 | `Project Homepage <https://chandar-lab.github.io/IIRC/>`__ | `Project Paper <https://arxiv.org/abs/2012.12477>`__ |
20 | `Source Code <https://github.com/chandar-lab/IIRC>`__ | `PyPI Package <https://pypi.org/project/iirc/>`__
21 | 
22 | .. toctree::
23 |    :maxdepth: 1
24 |    :caption: Contents:
25 | 
26 | Installation:
27 | =============
28 | you can install the **iirc** package using the following command
29 | 
30 | .. code-block:: none
31 | 
32 |    pip install iirc
33 | 
34 | To use it with PyTorch, you will need as well to install *PyTorch* (1.5.0) and *torchvision* (0.6.0)
35 | 
36 | Guide:
37 | ======
38 | .. toctree::
39 |    :maxdepth: 1
40 | 
41 |    iirc_tutorial
42 |    loading_datasets_tutorial
43 |    lifelong_methods_guide
44 | 
45 | Documentation:
46 | ==============
47 | .. toctree::
48 |    :maxdepth: 1
49 | 
50 |    modules
51 | 
52 | .. Indices and tables
53 | .. ==================
54 | 
55 | * :ref:`genindex`
56 | * :ref:`modindex`
57 | * :ref:`search`
58 | 
59 | Paper
60 | ---------
61 | 
62 | IIRC is introduced in the paper `“IIRC: Incremental Implicitly-Refined Classification ” <https://arxiv.org/abs/2012.12477>`__.
63 | If you find this work useful for your research, this is the way to cite it:
64 | 
65 | .. code:: bibtex
66 | 
67 |     @misc{abdelsalam2021iirc,
68 |         title = {IIRC: Incremental Implicitly-Refined Classification},
69 |         author={Mohamed Abdelsalam and Mojtaba Faramarzi and Shagun Sodhani and Sarath Chandar},
70 |         year={2021}, eprint={2012.12477}, archivePrefix={arXiv},
71 |         primaryClass={cs.CV} 
72 |     }
73 | 
74 | Community
75 | -----------
76 | 
77 | If you think you can help us make the **iirc** and **lifelong_methods** packages more useful for the lifelong learning
78 | community, please don't hesitate to `submit an issue or send a pull request. <https://github.com/chandar-lab/IIRC>`__
79 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/lifelong_methods.buffer.rst.txt:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.buffer package
 2 | ================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.buffer.buffer module
 8 | --------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.buffer.buffer
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: lifelong_methods.buffer
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/lifelong_methods.methods.rst.txt:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.methods package
 2 | =================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.methods.agem module
 8 | -------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.methods.agem
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | lifelong\_methods.methods.base\_method module
16 | ---------------------------------------------
17 | 
18 | .. automodule:: lifelong_methods.methods.base_method
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | lifelong\_methods.methods.finetune module
24 | -----------------------------------------
25 | 
26 | .. automodule:: lifelong_methods.methods.finetune
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | lifelong\_methods.methods.icarl module
32 | --------------------------------------
33 | 
34 | .. automodule:: lifelong_methods.methods.icarl
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | lifelong\_methods.methods.icarl\_cnn module
40 | -------------------------------------------
41 | 
42 | .. automodule:: lifelong_methods.methods.icarl_cnn
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | lifelong\_methods.methods.icarl\_norm module
48 | --------------------------------------------
49 | 
50 | .. automodule:: lifelong_methods.methods.icarl_norm
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | lifelong\_methods.methods.lucir module
56 | --------------------------------------
57 | 
58 | .. automodule:: lifelong_methods.methods.lucir
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 
63 | lifelong\_methods.methods.mask\_seen\_classes module
64 | ----------------------------------------------------
65 | 
66 | .. automodule:: lifelong_methods.methods.mask_seen_classes
67 |    :members:
68 |    :undoc-members:
69 |    :show-inheritance:
70 | 
71 | Module contents
72 | ---------------
73 | 
74 | .. automodule:: lifelong_methods.methods
75 |    :members:
76 |    :undoc-members:
77 |    :show-inheritance:
78 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/lifelong_methods.models.rst.txt:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.models package
 2 | ================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.models.cosine\_linear module
 8 | ----------------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.models.cosine_linear
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | lifelong\_methods.models.mlp module
16 | -----------------------------------
17 | 
18 | .. automodule:: lifelong_methods.models.mlp
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | lifelong\_methods.models.resnet module
24 | --------------------------------------
25 | 
26 | .. automodule:: lifelong_methods.models.resnet
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | lifelong\_methods.models.resnetcifar module
32 | -------------------------------------------
33 | 
34 | .. automodule:: lifelong_methods.models.resnetcifar
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | Module contents
40 | ---------------
41 | 
42 | .. automodule:: lifelong_methods.models
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/lifelong_methods.rst.txt:
--------------------------------------------------------------------------------
 1 | lifelong\_methods package
 2 | =========================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    lifelong_methods.buffer
11 |    lifelong_methods.methods
12 |    lifelong_methods.models
13 | 
14 | Submodules
15 | ----------
16 | 
17 | lifelong\_methods.utils module
18 | ------------------------------
19 | 
20 | .. automodule:: lifelong_methods.utils
21 |    :members:
22 |    :undoc-members:
23 |    :show-inheritance:
24 | 
25 | Module contents
26 | ---------------
27 | 
28 | .. automodule:: lifelong_methods
29 |    :members:
30 |    :undoc-members:
31 |    :show-inheritance:
32 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/lifelong_methods_guide.md.txt:
--------------------------------------------------------------------------------
 1 | # Lifelong Learning Methods Guide
 2 | The lifelong learning methods in this package follow the following procedures
 3 | 
 4 | ```
 5 | example_model = lifelong_methods.methods.example.Model(args)  # replace example with whatever module is there
 6 | 
 7 | for task in tasks:
 8 |     task_data <- load here the task data
 9 |     
10 |     # This method initializes anything that needs to be inizialized at the beginning of each task
11 |     example_model.prepare_model_for_new_task(task_data, **kwargs) 
12 | 
13 |     for epoch in epochs:
14 |         # Training
15 |         for minibatch in task_data:
16 |             # This is where the training happens
17 |             predictions, loss = example_model.observe(minibatch)
18 | 
19 |         # This is where anything that needs to be done after each epoch should be done, if any
20 |         example_model.consolidate_epoch_knowledge(**kwargs) 
21 |     
22 |     # This is where anything that needs to be done after the task is done takes place
23 |     example_model.consolidate_task_knowledge(**kwargs)
24 | 
25 |     # Inference
26 |     # This is where the inference happens
27 |     predictions = example_model(inference_data_batch)
28 | ```
29 | 
30 | This is the typical order of how things flow in a lifelong learning scenario, and how does this package handles 
31 | that. This order makes it easy to implement new methods with shared base, so that they can run using the same code and 
32 | experimenting can be fast
33 | 
34 | When defining a new lifelong learning model, the first step is to create a model that inherits from 
35 | *lifelong_methods.methods.base_method.BaseMethod*, then the following abstract methods need to be defined (see the methods 
36 | docs for more details), private methods here are run from inside their similar but public methods so that shared stuff 
37 | between the different methods doesn't need to be reimplemented (like resetting the scheduler after each task, etc), 
38 | see the docs to know what is already implemented in the public methods so that you don't reimplement them:
39 | *  *_prepare_model_for_new_task*: This private method is run from inside the *prepare_model_for_new_task* in the 
40 | *BaseMethod*, 
41 | *  *_consolidate_epoch_knowledge*: This private method is run from inside the *consolidate_epoch_knowledge* in the 
42 | *BaseMethod*   
43 | *  *observe*
44 | * *forward*
45 | * *consolidate_task_knowledge*


--------------------------------------------------------------------------------
/docs/build/html/_sources/modules.rst.txt:
--------------------------------------------------------------------------------
1 | .. toctree::
2 |    :maxdepth: 4
3 | 
4 |    iirc
5 |    lifelong_methods
6 | 


--------------------------------------------------------------------------------
/docs/build/html/_static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/fontawesome-webfont.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-bold-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-bold-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-normal-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-normal-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-normal.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/css/fonts/lato-normal.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/documentation_options.js:
--------------------------------------------------------------------------------
 1 | var DOCUMENTATION_OPTIONS = {
 2 |     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
 3 |     VERSION: '1.0.0',
 4 |     LANGUAGE: 'None',
 5 |     COLLAPSE_INDEX: false,
 6 |     BUILDER: 'html',
 7 |     FILE_SUFFIX: '.html',
 8 |     LINK_SUFFIX: '.html',
 9 |     HAS_SOURCE: true,
10 |     SOURCELINK_SUFFIX: '.txt',
11 |     NAVIGATION_WITH_KEYS: false
12 | };


--------------------------------------------------------------------------------
/docs/build/html/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/file.png


--------------------------------------------------------------------------------
/docs/build/html/_static/js/badge_only.js:
--------------------------------------------------------------------------------
1 | !function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=4)}({4:function(e,t,r){}});


--------------------------------------------------------------------------------
/docs/build/html/_static/js/html5shiv-printshiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3-pre | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/build/html/_static/js/html5shiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/build/html/_static/js/theme.js:
--------------------------------------------------------------------------------
1 | !function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("<div class='wy-table-responsive'></div>"),n("table.docutils.footnote").wrap("<div class='wy-table-responsive footnote'></div>"),n("table.docutils.citation").wrap("<div class='wy-table-responsive citation'></div>"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n('<span class="toctree-expand"></span>'),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}t.length>0&&($(".wy-menu-vertical .current").removeClass("current"),t.addClass("current"),t.closest("li.toctree-l1").addClass("current"),t.closest("li.toctree-l1").parent().addClass("current"),t.closest("li.toctree-l1").addClass("current"),t.closest("li.toctree-l2").addClass("current"),t.closest("li.toctree-l3").addClass("current"),t.closest("li.toctree-l4").addClass("current"),t.closest("li.toctree-l5").addClass("current"),t[0].scrollIntoView())}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current"),e.siblings().find("li.current").removeClass("current"),e.find("> ul li.current").removeClass("current"),e.toggleClass("current")}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t<e.length&&!window.requestAnimationFrame;++t)window.requestAnimationFrame=window[e[t]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[e[t]+"CancelAnimationFrame"]||window[e[t]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(e,t){var i=(new Date).getTime(),o=Math.max(0,16-(i-n)),r=window.setTimeout((function(){e(i+o)}),o);return n=i+o,r}),window.cancelAnimationFrame||(window.cancelAnimationFrame=function(n){clearTimeout(n)})}()}).call(window)},function(n,e){n.exports=jQuery},function(n,e,t){}]);


--------------------------------------------------------------------------------
/docs/build/html/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/minus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/_static/plus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | .highlight .hll { background-color: #ffffcc }
 2 | .highlight  { background: #f8f8f8; }
 3 | .highlight .c { color: #408080; font-style: italic } /* Comment */
 4 | .highlight .err { border: 1px solid #FF0000 } /* Error */
 5 | .highlight .k { color: #008000; font-weight: bold } /* Keyword */
 6 | .highlight .o { color: #666666 } /* Operator */
 7 | .highlight .ch { color: #408080; font-style: italic } /* Comment.Hashbang */
 8 | .highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */
 9 | .highlight .cp { color: #BC7A00 } /* Comment.Preproc */
10 | .highlight .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */
11 | .highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */
12 | .highlight .cs { color: #408080; font-style: italic } /* Comment.Special */
13 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
14 | .highlight .ge { font-style: italic } /* Generic.Emph */
15 | .highlight .gr { color: #FF0000 } /* Generic.Error */
16 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
17 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
18 | .highlight .go { color: #888888 } /* Generic.Output */
19 | .highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
20 | .highlight .gs { font-weight: bold } /* Generic.Strong */
21 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
22 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
23 | .highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
24 | .highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
25 | .highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
26 | .highlight .kp { color: #008000 } /* Keyword.Pseudo */
27 | .highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
28 | .highlight .kt { color: #B00040 } /* Keyword.Type */
29 | .highlight .m { color: #666666 } /* Literal.Number */
30 | .highlight .s { color: #BA2121 } /* Literal.String */
31 | .highlight .na { color: #7D9029 } /* Name.Attribute */
32 | .highlight .nb { color: #008000 } /* Name.Builtin */
33 | .highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
34 | .highlight .no { color: #880000 } /* Name.Constant */
35 | .highlight .nd { color: #AA22FF } /* Name.Decorator */
36 | .highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
37 | .highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
38 | .highlight .nf { color: #0000FF } /* Name.Function */
39 | .highlight .nl { color: #A0A000 } /* Name.Label */
40 | .highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
41 | .highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
42 | .highlight .nv { color: #19177C } /* Name.Variable */
43 | .highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
44 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
45 | .highlight .mb { color: #666666 } /* Literal.Number.Bin */
46 | .highlight .mf { color: #666666 } /* Literal.Number.Float */
47 | .highlight .mh { color: #666666 } /* Literal.Number.Hex */
48 | .highlight .mi { color: #666666 } /* Literal.Number.Integer */
49 | .highlight .mo { color: #666666 } /* Literal.Number.Oct */
50 | .highlight .sa { color: #BA2121 } /* Literal.String.Affix */
51 | .highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
52 | .highlight .sc { color: #BA2121 } /* Literal.String.Char */
53 | .highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */
54 | .highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
55 | .highlight .s2 { color: #BA2121 } /* Literal.String.Double */
56 | .highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
57 | .highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
58 | .highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
59 | .highlight .sx { color: #008000 } /* Literal.String.Other */
60 | .highlight .sr { color: #BB6688 } /* Literal.String.Regex */
61 | .highlight .s1 { color: #BA2121 } /* Literal.String.Single */
62 | .highlight .ss { color: #19177C } /* Literal.String.Symbol */
63 | .highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
64 | .highlight .fm { color: #0000FF } /* Name.Function.Magic */
65 | .highlight .vc { color: #19177C } /* Name.Variable.Class */
66 | .highlight .vg { color: #19177C } /* Name.Variable.Global */
67 | .highlight .vi { color: #19177C } /* Name.Variable.Instance */
68 | .highlight .vm { color: #19177C } /* Name.Variable.Magic */
69 | .highlight .il { color: #666666 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/docs/build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/build/html/objects.inv


--------------------------------------------------------------------------------
/docs/build/html/search.html:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | <!DOCTYPE html>
  4 | <html class="writer-html5" lang="en" >
  5 | <head>
  6 |   <meta charset="utf-8" />
  7 |   
  8 |   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  9 |   
 10 |   <title>Search &mdash; IIRC 1.0.0 documentation</title>
 11 |   
 12 | 
 13 |   
 14 |   <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
 15 |   <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 16 | 
 17 |   
 18 |   
 19 | 
 20 |   
 21 |   
 22 | 
 23 |   
 24 | 
 25 |   
 26 |     
 27 |   <!--[if lt IE 9]>
 28 |     <script src="_static/js/html5shiv.min.js"></script>
 29 |   <![endif]-->
 30 |   
 31 |     
 32 |       <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
 33 |         <script src="_static/jquery.js"></script>
 34 |         <script src="_static/underscore.js"></script>
 35 |         <script src="_static/doctools.js"></script>
 36 |         <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
 37 |     
 38 |     <script type="text/javascript" src="_static/js/theme.js"></script>
 39 | 
 40 |     
 41 |     <script type="text/javascript" src="_static/searchtools.js"></script>
 42 |     <script type="text/javascript" src="_static/language_data.js"></script>
 43 |     <link rel="index" title="Index" href="genindex.html" />
 44 |     <link rel="search" title="Search" href="#" /> 
 45 | </head>
 46 | 
 47 | <body class="wy-body-for-nav">
 48 | 
 49 |    
 50 |   <div class="wy-grid-for-nav">
 51 |     
 52 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 53 |       <div class="wy-side-scroll">
 54 |         <div class="wy-side-nav-search" >
 55 |           
 56 | 
 57 |           
 58 |             <a href="index.html" class="icon icon-home"> IIRC
 59 |           
 60 | 
 61 |           
 62 |           </a>
 63 | 
 64 |           
 65 |             
 66 |             
 67 |           
 68 | 
 69 |           
 70 | <div role="search">
 71 |   <form id="rtd-search-form" class="wy-form" action="#" method="get">
 72 |     <input type="text" name="q" placeholder="Search docs" />
 73 |     <input type="hidden" name="check_keywords" value="yes" />
 74 |     <input type="hidden" name="area" value="default" />
 75 |   </form>
 76 | </div>
 77 | 
 78 |           
 79 |         </div>
 80 | 
 81 |         
 82 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 83 |           
 84 |             
 85 |             
 86 |               
 87 |             
 88 |             
 89 |               <ul>
 90 | <li class="toctree-l1"><a class="reference internal" href="iirc_tutorial.html">IIRC Package Tutorial Using PyTorch</a></li>
 91 | <li class="toctree-l1"><a class="reference internal" href="loading_datasets_tutorial.html">Loading IIRC and incremental datasets</a></li>
 92 | <li class="toctree-l1"><a class="reference internal" href="lifelong_methods_guide.html">Lifelong Learning Methods Guide</a></li>
 93 | </ul>
 94 | <ul>
 95 | <li class="toctree-l1"><a class="reference internal" href="iirc.html">iirc package</a></li>
 96 | <li class="toctree-l1"><a class="reference internal" href="lifelong_methods.html">lifelong_methods package</a></li>
 97 | </ul>
 98 | 
 99 |             
100 |           
101 |         </div>
102 |         
103 |       </div>
104 |     </nav>
105 | 
106 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
107 | 
108 |       
109 |       <nav class="wy-nav-top" aria-label="top navigation">
110 |         
111 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
112 |           <a href="index.html">IIRC</a>
113 |         
114 |       </nav>
115 | 
116 | 
117 |       <div class="wy-nav-content">
118 |         
119 |         <div class="rst-content">
120 |         
121 |           
122 | 
123 | 
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | <div role="navigation" aria-label="breadcrumbs navigation">
140 | 
141 |   <ul class="wy-breadcrumbs">
142 |     
143 |       <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
144 |         
145 |       <li>Search</li>
146 |     
147 |     
148 |       <li class="wy-breadcrumbs-aside">
149 |         
150 |       </li>
151 |     
152 |   </ul>
153 | 
154 |   
155 |   <hr/>
156 | </div>
157 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
158 |            <div itemprop="articleBody">
159 |             
160 |   <noscript>
161 |   <div id="fallback" class="admonition warning">
162 |     <p class="last">
163 |       Please activate JavaScript to enable the search functionality.
164 |     </p>
165 |   </div>
166 |   </noscript>
167 | 
168 |   
169 |   <div id="search-results">
170 |   
171 |   </div>
172 | 
173 |            </div>
174 |            
175 |           </div>
176 |           <footer>
177 | 
178 |   <hr/>
179 | 
180 |   <div role="contentinfo">
181 |     <p>
182 |         &#169; Copyright 2021, Mohamed Abdelsalam, Mojtaba Faramarzi, Shagun Sodhani, Sarath Chandar (Chandar-Lab/Mila).
183 | 
184 |     </p>
185 |   </div>
186 |     
187 |     
188 |     
189 |     Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
190 |     
191 |     <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
192 |     
193 |     provided by <a href="https://readthedocs.org">Read the Docs</a>. 
194 | 
195 | </footer>
196 |         </div>
197 |       </div>
198 | 
199 |     </section>
200 | 
201 |   </div>
202 |   
203 | 
204 |   <script type="text/javascript">
205 |       jQuery(function () {
206 |           SphinxRtdTheme.Navigation.enable(true);
207 |       });
208 |   </script>
209 | 
210 |   
211 |   
212 |     
213 |   
214 |   <script type="text/javascript">
215 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
216 |   </script>
217 |   
218 |   <script type="text/javascript" id="searchindexloader"></script>
219 |    
220 | 
221 | 
222 | </body>
223 | </html>


--------------------------------------------------------------------------------
/docs/images/task_summary.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/docs/images/task_summary.png


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
 1 | @ECHO OFF
 2 | 
 3 | pushd %~dp0
 4 | 
 5 | REM Command file for Sphinx documentation
 6 | 
 7 | if "%SPHINXBUILD%" == "" (
 8 | 	set SPHINXBUILD=sphinx-build
 9 | )
10 | set SOURCEDIR=source
11 | set BUILDDIR=build
12 | 
13 | if "%1" == "" goto help
14 | 
15 | %SPHINXBUILD% >NUL 2>NUL
16 | if errorlevel 9009 (
17 | 	echo.
18 | 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
19 | 	echo.installed, then set the SPHINXBUILD environment variable to point
20 | 	echo.to the full path of the 'sphinx-build' executable. Alternatively you
21 | 	echo.may add the Sphinx directory to PATH.
22 | 	echo.
23 | 	echo.If you don't have Sphinx installed, grab it from
24 | 	echo.http://sphinx-doc.org/
25 | 	exit /b 1
26 | )
27 | 
28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
29 | goto end
30 | 
31 | :help
32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
33 | 
34 | :end
35 | popd
36 | 


--------------------------------------------------------------------------------
/docs/requirements.txt:
--------------------------------------------------------------------------------
 1 | --find-links=https://download.pytorch.org/whl/torch_stable.html
 2 | torch==1.5.0
 3 | torchvision==0.6.0
 4 | numpy==1.18.5
 5 | Pillow==7.0.0
 6 | lmdb==1.0.0
 7 | git+https://git@github.com/shagunsodhani/ml-logger.git@976cab1d2524ee72aef8273e6deb25c764883f3e#egg=mllogger[all]
 8 | pytest==5.4.3
 9 | pytest-cov==2.9.0
10 | sphinxcontrib-napoleon
11 | nbsphinx
12 | recommonmark
13 | sphinx_rtd_theme
14 | seaborn==0.10.1
15 | 


--------------------------------------------------------------------------------
/docs/source/conf.py:
--------------------------------------------------------------------------------
 1 | # Configuration file for the Sphinx documentation builder.
 2 | #
 3 | # This file only contains a selection of the most common options. For a full
 4 | # list see the documentation:
 5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html
 6 | 
 7 | # -- Path setup --------------------------------------------------------------
 8 | 
 9 | # If extensions (or modules to document with autodoc) are in another directory,
10 | # add these directories to sys.path here. If the directory is relative to the
11 | # documentation root, use os.path.abspath to make it absolute, like shown here.
12 | #
13 | import os
14 | import sys
15 | import sphinx_rtd_theme
16 | 
17 | sys.path.insert(0, os.path.abspath('../../.'))
18 | 
19 | # -- Project information -----------------------------------------------------
20 | 
21 | project = 'IIRC'
22 | copyright = '2021, Mohamed Abdelsalam, Mojtaba Faramarzi, Shagun Sodhani, Sarath Chandar (Chandar-Lab/Mila)'
23 | author = 'Mohamed Abdelsalam, Mojtaba Faramarzi, Shagun Sodhani, Sarath Chandar (Chandar-Lab/Mila)'
24 | 
25 | # The full version, including alpha/beta/rc tags
26 | release = '1.0.1'
27 | 
28 | # -- General configuration ---------------------------------------------------
29 | 
30 | # Add any Sphinx extension module names here, as strings. They can be
31 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
32 | # ones.
33 | extensions = ["sphinx.ext.napoleon", "nbsphinx", "recommonmark", "sphinx_rtd_theme"
34 |               ]
35 | 
36 | # Add any paths that contain templates here, relative to this directory.
37 | templates_path = ['_templates']
38 | 
39 | # List of patterns, relative to source directory, that match files and
40 | # directories to ignore when looking for source files.
41 | # This pattern also affects html_static_path and html_extra_path.
42 | exclude_patterns = ['*experiments*', '*tests*', '*_layouts*']
43 | 
44 | # -- Options for HTML output -------------------------------------------------
45 | 
46 | # The theme to use for HTML and HTML Help pages.  See the documentation for
47 | # a list of builtin themes.
48 | #
49 | html_theme = 'sphinx_rtd_theme'
50 | 
51 | # Add any paths that contain custom static files (such as style sheets) here,
52 | # relative to this directory. They are copied after the builtin static files,
53 | # so a file named "default.css" will overwrite the builtin "default.css".
54 | html_static_path = ['_static']
55 | 
56 | autodoc_member_order = 'bysource'
57 | 


--------------------------------------------------------------------------------
/docs/source/iirc.lifelong_dataset.rst:
--------------------------------------------------------------------------------
 1 | iirc.lifelong\_dataset package
 2 | ==============================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | iirc.lifelong\_dataset.base\_dataset module
 8 | -------------------------------------------
 9 | 
10 | .. automodule:: iirc.lifelong_dataset.base_dataset
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | iirc.lifelong\_dataset.tensorflow\_dataset module
16 | -------------------------------------------------
17 | 
18 | .. automodule:: iirc.lifelong_dataset.tensorflow_dataset
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | iirc.lifelong\_dataset.torch\_dataset module
24 | --------------------------------------------
25 | 
26 | .. automodule:: iirc.lifelong_dataset.torch_dataset
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | Module contents
32 | ---------------
33 | 
34 | .. automodule:: iirc.lifelong_dataset
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 


--------------------------------------------------------------------------------
/docs/source/iirc.rst:
--------------------------------------------------------------------------------
 1 | iirc package
 2 | ============
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    iirc.lifelong_dataset
11 |    iirc.utils
12 | 
13 | Submodules
14 | ----------
15 | 
16 | iirc.datasets\_loader module
17 | ----------------------------
18 | 
19 | .. automodule:: iirc.datasets_loader
20 |    :members:
21 |    :undoc-members:
22 |    :show-inheritance:
23 | 
24 | iirc.definitions module
25 | -----------------------
26 | 
27 | .. automodule:: iirc.definitions
28 |    :members:
29 |    :undoc-members:
30 |    :show-inheritance:
31 | 
32 | Module contents
33 | ---------------
34 | 
35 | .. automodule:: iirc
36 |    :members:
37 |    :undoc-members:
38 |    :show-inheritance:
39 | 


--------------------------------------------------------------------------------
/docs/source/iirc.utils.rst:
--------------------------------------------------------------------------------
 1 | iirc.utils package
 2 | ==================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | iirc.utils.download\_cifar module
 8 | ---------------------------------
 9 | 
10 | .. automodule:: iirc.utils.download_cifar
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | iirc.utils.prepare\_imagenet module
16 | -----------------------------------
17 | 
18 | .. automodule:: iirc.utils.prepare_imagenet
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | iirc.utils.utils module
24 | -----------------------
25 | 
26 | .. automodule:: iirc.utils.utils
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | Module contents
32 | ---------------
33 | 
34 | .. automodule:: iirc.utils
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 


--------------------------------------------------------------------------------
/docs/source/index.rst:
--------------------------------------------------------------------------------
 1 | .. IIRC documentation master file, created by
 2 |    sphinx-quickstart on Fri Jan  8 15:55:04 2021.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Welcome to IIRC's documentation!
 7 | ================================
 8 | .. image:: ../images/task_summary.png
 9 |    :width: 600
10 |    :alt: IIRC Setup
11 | 
12 | **iirc** is a package for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to
13 | the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner.
14 | 
15 | **lifelong_methods** is a package that standardizes the different stages any lifelong learning method passes by,
16 | hence it provides a faster way for implementing new ideas and embedding them in the same training code as other
17 | baselines, it provides as well the implementation of some of these baselines.
18 | 
19 | `Project Homepage <https://chandar-lab.github.io/IIRC/>`__ | `Project Paper <https://arxiv.org/abs/2012.12477>`__ |
20 | `Source Code <https://github.com/chandar-lab/IIRC>`__ | `PyPI Package <https://pypi.org/project/iirc/>`__
21 | 
22 | .. toctree::
23 |    :maxdepth: 1
24 |    :caption: Contents:
25 | 
26 | Installation:
27 | =============
28 | you can install the **iirc** package using the following command
29 | 
30 | .. code-block:: none
31 | 
32 |    pip install iirc
33 | 
34 | To use it with PyTorch, you will need as well to install *PyTorch* (1.5.0) and *torchvision* (0.6.0)
35 | 
36 | Guide:
37 | ======
38 | .. toctree::
39 |    :maxdepth: 1
40 | 
41 |    iirc_tutorial
42 |    loading_datasets_tutorial
43 |    lifelong_methods_guide
44 | 
45 | Documentation:
46 | ==============
47 | .. toctree::
48 |    :maxdepth: 1
49 | 
50 |    modules
51 | 
52 | .. Indices and tables
53 | .. ==================
54 | 
55 | * :ref:`genindex`
56 | * :ref:`modindex`
57 | * :ref:`search`
58 | 
59 | Paper
60 | ---------
61 | 
62 | IIRC is introduced in the paper `“IIRC: Incremental Implicitly-Refined Classification ” <https://arxiv.org/abs/2012.12477>`__.
63 | If you find this work useful for your research, this is the way to cite it:
64 | 
65 | .. code:: bibtex
66 | 
67 |     @misc{abdelsalam2021iirc,
68 |         title = {IIRC: Incremental Implicitly-Refined Classification},
69 |         author={Mohamed Abdelsalam and Mojtaba Faramarzi and Shagun Sodhani and Sarath Chandar},
70 |         year={2021}, eprint={2012.12477}, archivePrefix={arXiv},
71 |         primaryClass={cs.CV} 
72 |     }
73 | 
74 | Community
75 | -----------
76 | 
77 | If you think you can help us make the **iirc** and **lifelong_methods** packages more useful for the lifelong learning
78 | community, please don't hesitate to `submit an issue or send a pull request. <https://github.com/chandar-lab/IIRC>`__
79 | 


--------------------------------------------------------------------------------
/docs/source/lifelong_methods.buffer.rst:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.buffer package
 2 | ================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.buffer.buffer module
 8 | --------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.buffer.buffer
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | Module contents
16 | ---------------
17 | 
18 | .. automodule:: lifelong_methods.buffer
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 


--------------------------------------------------------------------------------
/docs/source/lifelong_methods.methods.rst:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.methods package
 2 | =================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.methods.agem module
 8 | -------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.methods.agem
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | lifelong\_methods.methods.base\_method module
16 | ---------------------------------------------
17 | 
18 | .. automodule:: lifelong_methods.methods.base_method
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | lifelong\_methods.methods.finetune module
24 | -----------------------------------------
25 | 
26 | .. automodule:: lifelong_methods.methods.finetune
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | lifelong\_methods.methods.icarl module
32 | --------------------------------------
33 | 
34 | .. automodule:: lifelong_methods.methods.icarl
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | lifelong\_methods.methods.icarl\_cnn module
40 | -------------------------------------------
41 | 
42 | .. automodule:: lifelong_methods.methods.icarl_cnn
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 
47 | lifelong\_methods.methods.icarl\_norm module
48 | --------------------------------------------
49 | 
50 | .. automodule:: lifelong_methods.methods.icarl_norm
51 |    :members:
52 |    :undoc-members:
53 |    :show-inheritance:
54 | 
55 | lifelong\_methods.methods.lucir module
56 | --------------------------------------
57 | 
58 | .. automodule:: lifelong_methods.methods.lucir
59 |    :members:
60 |    :undoc-members:
61 |    :show-inheritance:
62 | 
63 | lifelong\_methods.methods.mask\_seen\_classes module
64 | ----------------------------------------------------
65 | 
66 | .. automodule:: lifelong_methods.methods.mask_seen_classes
67 |    :members:
68 |    :undoc-members:
69 |    :show-inheritance:
70 | 
71 | Module contents
72 | ---------------
73 | 
74 | .. automodule:: lifelong_methods.methods
75 |    :members:
76 |    :undoc-members:
77 |    :show-inheritance:
78 | 


--------------------------------------------------------------------------------
/docs/source/lifelong_methods.models.rst:
--------------------------------------------------------------------------------
 1 | lifelong\_methods.models package
 2 | ================================
 3 | 
 4 | Submodules
 5 | ----------
 6 | 
 7 | lifelong\_methods.models.cosine\_linear module
 8 | ----------------------------------------------
 9 | 
10 | .. automodule:: lifelong_methods.models.cosine_linear
11 |    :members:
12 |    :undoc-members:
13 |    :show-inheritance:
14 | 
15 | lifelong\_methods.models.mlp module
16 | -----------------------------------
17 | 
18 | .. automodule:: lifelong_methods.models.mlp
19 |    :members:
20 |    :undoc-members:
21 |    :show-inheritance:
22 | 
23 | lifelong\_methods.models.resnet module
24 | --------------------------------------
25 | 
26 | .. automodule:: lifelong_methods.models.resnet
27 |    :members:
28 |    :undoc-members:
29 |    :show-inheritance:
30 | 
31 | lifelong\_methods.models.resnetcifar module
32 | -------------------------------------------
33 | 
34 | .. automodule:: lifelong_methods.models.resnetcifar
35 |    :members:
36 |    :undoc-members:
37 |    :show-inheritance:
38 | 
39 | Module contents
40 | ---------------
41 | 
42 | .. automodule:: lifelong_methods.models
43 |    :members:
44 |    :undoc-members:
45 |    :show-inheritance:
46 | 


--------------------------------------------------------------------------------
/docs/source/lifelong_methods.rst:
--------------------------------------------------------------------------------
 1 | lifelong\_methods package
 2 | =========================
 3 | 
 4 | Subpackages
 5 | -----------
 6 | 
 7 | .. toctree::
 8 |    :maxdepth: 4
 9 | 
10 |    lifelong_methods.buffer
11 |    lifelong_methods.methods
12 |    lifelong_methods.models
13 | 
14 | Submodules
15 | ----------
16 | 
17 | lifelong\_methods.utils module
18 | ------------------------------
19 | 
20 | .. automodule:: lifelong_methods.utils
21 |    :members:
22 |    :undoc-members:
23 |    :show-inheritance:
24 | 
25 | Module contents
26 | ---------------
27 | 
28 | .. automodule:: lifelong_methods
29 |    :members:
30 |    :undoc-members:
31 |    :show-inheritance:
32 | 


--------------------------------------------------------------------------------
/docs/source/lifelong_methods_guide.md:
--------------------------------------------------------------------------------
 1 | # Lifelong Learning Methods Guide
 2 | The lifelong learning methods in this package follow the following procedures
 3 | 
 4 | ```
 5 | example_model = lifelong_methods.methods.example.Model(args)  # replace example with whatever module is there
 6 | 
 7 | for task in tasks:
 8 |     task_data <- load here the task data
 9 |     
10 |     # This method initializes anything that needs to be inizialized at the beginning of each task
11 |     example_model.prepare_model_for_new_task(task_data, **kwargs) 
12 | 
13 |     for epoch in epochs:
14 |         # Training
15 |         for minibatch in task_data:
16 |             # This is where the training happens
17 |             predictions, loss = example_model.observe(minibatch)
18 | 
19 |         # This is where anything that needs to be done after each epoch should be done, if any
20 |         example_model.consolidate_epoch_knowledge(**kwargs) 
21 |     
22 |     # This is where anything that needs to be done after the task is done takes place
23 |     example_model.consolidate_task_knowledge(**kwargs)
24 | 
25 |     # Inference
26 |     # This is where the inference happens
27 |     predictions = example_model(inference_data_batch)
28 | ```
29 | 
30 | This is the typical order of how things flow in a lifelong learning scenario, and how does this package handles 
31 | that. This order makes it easy to implement new methods with shared base, so that they can run using the same code and 
32 | experimenting can be fast
33 | 
34 | When defining a new lifelong learning model, the first step is to create a model that inherits from 
35 | *lifelong_methods.methods.base_method.BaseMethod*, then the following abstract methods need to be defined (see the methods 
36 | docs for more details), private methods here are run from inside their similar but public methods so that shared stuff 
37 | between the different methods doesn't need to be reimplemented (like resetting the scheduler after each task, etc), 
38 | see the docs to know what is already implemented in the public methods so that you don't reimplement them:
39 | *  *_prepare_model_for_new_task*: This private method is run from inside the *prepare_model_for_new_task* in the 
40 | *BaseMethod*, 
41 | *  *_consolidate_epoch_knowledge*: This private method is run from inside the *consolidate_epoch_knowledge* in the 
42 | *BaseMethod*   
43 | *  *observe*
44 | * *forward*
45 | * *consolidate_task_knowledge*


--------------------------------------------------------------------------------
/docs/source/modules.rst:
--------------------------------------------------------------------------------
1 | .. toctree::
2 |    :maxdepth: 4
3 | 
4 |    iirc
5 |    lifelong_methods
6 | 


--------------------------------------------------------------------------------
/experiments/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/experiments/__init__.py


--------------------------------------------------------------------------------
/experiments/create_confusion_matrix.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | import argparse
  3 | import numpy as np
  4 | import random
  5 | import torchvision
  6 | import json
  7 | import os
  8 | import importlib
  9 | import torch.utils.data as data
 10 | import seaborn as sn
 11 | import pandas as pd
 12 | import matplotlib.pyplot as plt
 13 | import matplotlib
 14 | from typing import Optional
 15 | 
 16 | from iirc.datasets_loader import get_lifelong_datasets
 17 | from lifelong_methods.methods.base_method import BaseMethod
 18 | from lifelong_methods.utils import SubsetSampler
 19 | 
 20 | 
 21 | def get_transforms(dataset_name):
 22 |     transforms = None
 23 |     if "cifar100" in dataset_name:
 24 |         transforms = torchvision.transforms.Compose([
 25 |             torchvision.transforms.ToTensor(),
 26 |             torchvision.transforms.Normalize((0.5071, 0.4866, 0.4409), (0.2009, 0.1984, 0.2023)),
 27 |         ])
 28 |     elif "imagenet" in dataset_name:
 29 |         normalize = torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
 30 |         transforms = torchvision.transforms.Compose([
 31 |             torchvision.transforms.Resize(256),
 32 |             torchvision.transforms.CenterCrop(224),
 33 |             torchvision.transforms.ToTensor(),
 34 |             normalize,
 35 |         ])
 36 |     return transforms
 37 | 
 38 | 
 39 | def get_model(args, device, task_id=0):
 40 |     if args.models_dir == "None":
 41 |         model = None
 42 |     else:
 43 |         checkpoint = torch.load(os.path.join(args.models_dir, f"task_{task_id}_model"))
 44 |         metadata = checkpoint['metadata']
 45 |         config = checkpoint['config']
 46 |         assert os.path.isdir('experiments/methods')
 47 |         method = importlib.import_module('experiments.methods.' + config["method"])
 48 |         model = method.Model(metadata["n_cla_per_tsk"], metadata["class_names_to_idx"],
 49 |                              config)  # type: Optional[BaseMethod]
 50 |         model.to(device)
 51 |         method_state_dict = checkpoint["method_state_dict"]
 52 |         model._load_method_state_dict(method_state_dict)
 53 |         model.load_state_dict(method_state_dict['model_state_dict'])
 54 |         for key, value in method_state_dict['method_variables'].items():
 55 |             model.__dict__[key] = value
 56 |         model.eval()
 57 |     return model
 58 | 
 59 | 
 60 | if __name__ == '__main__':
 61 |     parser = argparse.ArgumentParser()
 62 |     parser.add_argument('--dataset', type=str, default="iirc_cifar100",
 63 |                         choices=["incremental_cifar100", "iirc_cifar100", "iirc_imagenet_full", "iirc_imagenet_lite"])
 64 |     parser.add_argument('--dataset_path', type=str, default="./data")
 65 |     parser.add_argument('--metadata_root', type=str, default="./iirc/metadata")
 66 |     parser.add_argument('--results_path', type=str, default="./figures/confusion_matrices/ground_truth")
 67 |     parser.add_argument('--batch_size', type=int, default=128)
 68 |     parser.add_argument('--models_dir', type=str, default="None")
 69 |     parser.add_argument('--seed', type=int, default=100)
 70 |     parser.add_argument('--tasks_configuration_id', type=int, default=0)
 71 |     parser.add_argument('--joint', action="store_true")
 72 |     args = parser.parse_args()
 73 | 
 74 |     torch.random.manual_seed(args.seed)
 75 |     np.random.seed(args.seed)
 76 |     random.seed(args.seed)
 77 | 
 78 |     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 79 | 
 80 |     with open(os.path.join(args.metadata_root, "iirc_cifar100_hierarchy.json"), "r") as f:
 81 |         class_hierarchy = json.load(f)
 82 | 
 83 |     superclass_to_subclasses = class_hierarchy['super_classes']
 84 |     subclasses_to_superclass = {subclass: superclass for superclass, subclasses in superclass_to_subclasses.items()
 85 |                                 for subclass in subclasses}
 86 | 
 87 |     essential_transforms_fn = get_transforms(args.dataset)
 88 |     lifelong_datasets, tasks, class_names_to_idx = \
 89 |         get_lifelong_datasets(args.dataset, dataset_root=args.dataset_path,
 90 |                               tasks_configuration_id=args.tasks_configuration_id,
 91 |                               essential_transforms_fn=essential_transforms_fn, cache_images=False, joint=args.joint)
 92 | 
 93 |     dataset = lifelong_datasets["posttask_valid"]
 94 |     model = None
 95 | 
 96 |     tasks_id_to_show = [0, 1, 5, 10]
 97 |     num_classes_per_task = [10, 5, 5, 5]
 98 |     confusions = [np.zeros((sum(num_classes_per_task), sum(num_classes_per_task))) for _ in
 99 |                   range(len(tasks_id_to_show))]
100 |     total_classes_to_show = []
101 |     for task_id, num_classes in zip(tasks_id_to_show, num_classes_per_task):
102 |         total_classes_to_show.extend(tasks[task_id][:num_classes])
103 |     class_names_to_idx = {cla: idx for idx, cla in enumerate(total_classes_to_show)}
104 |     classes_shown = []
105 | 
106 |     for i, (task_id, num_classes) in enumerate(zip(tasks_id_to_show, num_classes_per_task)):
107 |         confusion = confusions[i]
108 |         task_classes = tasks[task_id][:num_classes]
109 |         classes_shown.extend(task_classes)
110 |         dataset.load_tasks_up_to(task_id)
111 |         model = get_model(args, device, task_id)
112 |         for class_ in classes_shown:
113 |             class_data_indices = dataset.get_image_indices_by_cla(class_)
114 |             class_idx = class_names_to_idx[class_]
115 |             if model is None:
116 |                 confusion[class_idx, class_idx] = 1.0
117 |                 if class_ in subclasses_to_superclass.keys():
118 |                     super_cla = subclasses_to_superclass[class_]
119 |                     if super_cla in classes_shown:
120 |                         super_cla_idx = class_names_to_idx[super_cla]
121 |                         confusion[class_idx, super_cla_idx] = 1.0
122 |                 if class_ in superclass_to_subclasses.keys():
123 |                     for sub_cla in superclass_to_subclasses[class_]:
124 |                         if sub_cla in classes_shown:
125 |                             sub_cla_idx = class_names_to_idx[sub_cla]
126 |                             confusion[class_idx, sub_cla_idx] = 1.0 / len(superclass_to_subclasses[class_])
127 |             else:
128 |                 sampler = SubsetSampler(class_data_indices)
129 |                 class_loader = data.DataLoader(dataset, batch_size=args.batch_size, sampler=sampler)
130 |                 model_class_names_to_idx = model.class_names_to_idx
131 |                 relevant_idx = np.array([model_class_names_to_idx[cla] for cla in classes_shown])
132 |                 total_class_predictions = torch.zeros(len(classes_shown)).to(device)
133 |                 for minibatch in class_loader:
134 |                     images = minibatch[0].to(device)
135 |                     predictions = model(images)
136 |                     predictions = predictions[:, relevant_idx]
137 |                     total_class_predictions += predictions.sum(dim=0)
138 |                 total_class_predictions /= (1.0 * len(class_data_indices))
139 |                 confusion[class_idx, :len(classes_shown)] = total_class_predictions.cpu().numpy()
140 | 
141 |     os.makedirs(args.results_path, exist_ok=True)
142 |     for task_id, confusion in zip(tasks_id_to_show, confusions):
143 |         confusion_df = pd.DataFrame(confusion, total_classes_to_show,
144 |                                     total_classes_to_show)
145 |         matplotlib.use('Agg')
146 |         sn.heatmap(confusion_df * 100.0, vmin=0, vmax=100, annot=False, yticklabels=False, xticklabels=False,
147 |                    fmt='.1f')  # , annot_kws={"size": 8}
148 |         fig = matplotlib.pyplot.gcf()
149 |         fig.set_size_inches(15, 12)
150 |         fig.tight_layout()
151 |         plt.savefig(os.path.join(args.results_path, f"task_{task_id}_confusion.png"))
152 |         plt.close()
153 |         confusion_df = pd.DataFrame(confusion, total_classes_to_show,
154 |                                     total_classes_to_show)
155 |         matplotlib.use('Agg')
156 |         sn.heatmap(confusion_df * 100.0, vmin=0, vmax=100, annot=True, fmt='.1f')  # , annot_kws={"size": 8}
157 |         fig = matplotlib.pyplot.gcf()
158 |         fig.set_size_inches(15, 12)
159 |         fig.tight_layout()
160 |         plt.savefig(os.path.join(args.results_path, f"task_{task_id}_confusion_annot.png"))
161 |         plt.close()
162 | 


--------------------------------------------------------------------------------
/experiments/experiments_configurations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/experiments/experiments_configurations/__init__.py


--------------------------------------------------------------------------------
/experiments/experiments_configurations/configurations_imagenet_full.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "finetune": {
  3 |     "active": true,
  4 |     "run_id_key": "tasks_configuration_id",
  5 |     "cluster_arguments": {
  6 |       "gpus_per_node": 1,
  7 |       "nodes": 1,
  8 |       "time": "71:00:00"
  9 |     },
 10 |     "fixed_arguments": {
 11 |       "dataset": "iirc_imagenet_full",
 12 |       "batch_size": 128,
 13 |       "n_layers": 50,
 14 |       "method": "finetune",
 15 |       "seed": 100,
 16 |       "optimizer": "momentum",
 17 |       "epochs_per_task": 100,
 18 |       "checkpoint_interval": 5,
 19 |       "lr": 0.1,
 20 |       "lr_gamma": 0.1,
 21 |       "lr_schedule": "-1",
 22 |       "weight_decay": 0.00001,
 23 |       "n_memories_per_class": 0,
 24 |       "total_n_memories": -1,
 25 |       "group": "iirc_imagenet_full_final"
 26 |     },
 27 |     "iterable_arguments": {
 28 |       "tasks_configuration_id": [
 29 |         0,
 30 |         1,
 31 |         2,
 32 |         3,
 33 |         4
 34 |       ]
 35 |     },
 36 |     "flags": {
 37 |       "reduce_lr_on_plateau": true,
 38 |       "use_best_model": true,
 39 |       "complete_info": false,
 40 |       "incremental_joint": false,
 41 |       "joint": false
 42 |     }
 43 |   },
 44 |   "finetune_20": {
 45 |     "active": true,
 46 |     "run_id_key": "tasks_configuration_id",
 47 |     "cluster_arguments": {
 48 |       "gpus_per_node": 1,
 49 |       "nodes": 1,
 50 |       "time": "71:00:00"
 51 |     },
 52 |     "fixed_arguments": {
 53 |       "dataset": "iirc_imagenet_full",
 54 |       "batch_size": 128,
 55 |       "n_layers": 50,
 56 |       "method": "finetune",
 57 |       "seed": 100,
 58 |       "optimizer": "momentum",
 59 |       "epochs_per_task": 100,
 60 |       "checkpoint_interval": 5,
 61 |       "lr": 0.1,
 62 |       "lr_gamma": 0.1,
 63 |       "lr_schedule": "-1",
 64 |       "weight_decay": 0.00001,
 65 |       "n_memories_per_class": 20,
 66 |       "total_n_memories": -1,
 67 |       "group": "iirc_imagenet_full_final"
 68 |     },
 69 |     "iterable_arguments": {
 70 |       "tasks_configuration_id": [
 71 |         0,
 72 |         1,
 73 |         2,
 74 |         3,
 75 |         4
 76 |       ]
 77 |     },
 78 |     "flags": {
 79 |       "reduce_lr_on_plateau": true,
 80 |       "use_best_model": true,
 81 |       "complete_info": false,
 82 |       "incremental_joint": false,
 83 |       "joint": false
 84 |     }
 85 |   },
 86 |   "finetune_50": {
 87 |     "active": true,
 88 |     "run_id_key": "tasks_configuration_id",
 89 |     "cluster_arguments": {
 90 |       "gpus_per_node": 1,
 91 |       "nodes": 1,
 92 |       "time": "71:00:00"
 93 |     },
 94 |     "fixed_arguments": {
 95 |       "dataset": "iirc_imagenet_full",
 96 |       "batch_size": 128,
 97 |       "n_layers": 50,
 98 |       "method": "finetune",
 99 |       "seed": 100,
100 |       "optimizer": "momentum",
101 |       "epochs_per_task": 100,
102 |       "checkpoint_interval": 5,
103 |       "lr": 0.1,
104 |       "lr_gamma": 0.1,
105 |       "lr_schedule": "-1",
106 |       "weight_decay": 0.00001,
107 |       "n_memories_per_class": 50,
108 |       "total_n_memories": -1,
109 |       "group": "iirc_imagenet_full_final"
110 |     },
111 |     "iterable_arguments": {
112 |       "tasks_configuration_id": [
113 |         0,
114 |         1,
115 |         2,
116 |         3,
117 |         4
118 |       ]
119 |     },
120 |     "flags": {
121 |       "reduce_lr_on_plateau": true,
122 |       "use_best_model": true,
123 |       "complete_info": false,
124 |       "incremental_joint": false,
125 |       "joint": false
126 |     }
127 |   },
128 |   "finetune_100": {
129 |     "active": true,
130 |     "run_id_key": "tasks_configuration_id",
131 |     "cluster_arguments": {
132 |       "gpus_per_node": 1,
133 |       "nodes": 1,
134 |       "time": "71:00:00"
135 |     },
136 |     "fixed_arguments": {
137 |       "dataset": "iirc_imagenet_full",
138 |       "batch_size": 128,
139 |       "n_layers": 50,
140 |       "method": "finetune",
141 |       "seed": 100,
142 |       "optimizer": "momentum",
143 |       "epochs_per_task": 100,
144 |       "checkpoint_interval": 5,
145 |       "lr": 0.1,
146 |       "lr_gamma": 0.1,
147 |       "lr_schedule": "-1",
148 |       "weight_decay": 0.00001,
149 |       "n_memories_per_class": 100,
150 |       "total_n_memories": -1,
151 |       "group": "iirc_imagenet_full_final"
152 |     },
153 |     "iterable_arguments": {
154 |       "tasks_configuration_id": [
155 |         0,
156 |         1,
157 |         2,
158 |         3,
159 |         4
160 |       ]
161 |     },
162 |     "flags": {
163 |       "reduce_lr_on_plateau": true,
164 |       "use_best_model": true,
165 |       "complete_info": false,
166 |       "incremental_joint": false,
167 |       "joint": false
168 |     }
169 |   },
170 |   "joint": {
171 |     "active": true,
172 |     "run_id_key": "tasks_configuration_id",
173 |     "cluster_arguments": {
174 |       "gpus_per_node": 4,
175 |       "nodes": 1,
176 |       "time": "71:00:00"
177 |     },
178 |     "fixed_arguments": {
179 |       "dataset": "iirc_imagenet_full",
180 |       "batch_size": 128,
181 |       "n_layers": 50,
182 |       "method": "finetune",
183 |       "tasks_configuration_id": -1,
184 |       "optimizer": "momentum",
185 |       "epochs_per_task": 90,
186 |       "checkpoint_interval": 5,
187 |       "lr": 0.1,
188 |       "lr_gamma": 0.1,
189 |       "lr_schedule": "-1",
190 |       "weight_decay": 0.00001,
191 |       "n_memories_per_class": 0,
192 |       "total_n_memories": -1,
193 |       "group": "iirc_imagenet_full_final"
194 |     },
195 |     "iterable_arguments": {
196 |       "seed": [
197 |         100,
198 |         101,
199 |         102,
200 |         103,
201 |         104
202 |       ]
203 |     },
204 |     "flags": {
205 |       "reduce_lr_on_plateau": true,
206 |       "use_best_model": true,
207 |       "complete_info": true,
208 |       "incremental_joint": false,
209 |       "joint": true
210 |     }
211 |   },
212 |   "lucir_20": {
213 |     "active": true,
214 |     "run_id_key": "tasks_configuration_id",
215 |     "cluster_arguments": {
216 |       "gpus_per_node": 1,
217 |       "nodes": 1,
218 |       "time": "71:00:00"
219 |     },
220 |     "fixed_arguments": {
221 |       "dataset": "iirc_imagenet_full",
222 |       "batch_size": 128,
223 |       "n_layers": 50,
224 |       "method": "lucir",
225 |       "seed": 100,
226 |       "optimizer": "momentum",
227 |       "epochs_per_task": 100,
228 |       "checkpoint_interval": 5,
229 |       "lr": 0.1,
230 |       "lr_gamma": 0.1,
231 |       "lr_schedule": "80 120",
232 |       "weight_decay": 1e-5,
233 |       "n_memories_per_class": 20,
234 |       "total_n_memories": -1,
235 |       "lucir_lambda": 5.0,
236 |       "lucir_margin_1": 0.5,
237 |       "lucir_margin_2": 0.5,
238 |       "group": "iirc_imagenet_full_final"
239 |     },
240 |     "iterable_arguments": {
241 |       "tasks_configuration_id": [
242 |         0,
243 |         1,
244 |         2,
245 |         3,
246 |         4
247 |       ]
248 |     },
249 |     "flags": {
250 |       "reduce_lr_on_plateau": true,
251 |       "use_best_model": false,
252 |       "complete_info": false,
253 |       "incremental_joint": false,
254 |       "joint": false
255 |     }
256 |   },
257 |   "icarl_cnn_20": {
258 |     "active": true,
259 |     "run_id_key": "tasks_configuration_id",
260 |     "cluster_arguments": {
261 |       "gpus_per_node": 1,
262 |       "nodes": 1,
263 |       "time": "71:00:00"
264 |     },
265 |     "fixed_arguments": {
266 |       "dataset": "iirc_imagenet_full",
267 |       "batch_size": 128,
268 |       "n_layers": 50,
269 |       "method": "icarl_cnn",
270 |       "seed": 100,
271 |       "optimizer": "momentum",
272 |       "epochs_per_task": 100,
273 |       "checkpoint_interval": 5,
274 |       "lr": 0.5,
275 |       "lr_gamma": 0.1,
276 |       "lr_schedule": "80 120",
277 |       "weight_decay": 1e-5,
278 |       "n_memories_per_class": 20,
279 |       "total_n_memories": -1,
280 |       "group": "iirc_imagenet_full_final"
281 |     },
282 |     "iterable_arguments": {
283 |       "tasks_configuration_id": [
284 |         0,
285 |         1,
286 |         2,
287 |         3,
288 |         4
289 |       ]
290 |     },
291 |     "flags": {
292 |       "reduce_lr_on_plateau": true,
293 |       "use_best_model": false,
294 |       "complete_info": false,
295 |       "incremental_joint": false,
296 |       "joint": false
297 |     }
298 |   },
299 |   "icarl_norm_20": {
300 |     "active": true,
301 |     "run_id_key": "tasks_configuration_id",
302 |     "cluster_arguments": {
303 |       "gpus_per_node": 1,
304 |       "nodes": 1,
305 |       "time": "71:00:00"
306 |     },
307 |     "fixed_arguments": {
308 |       "dataset": "iirc_imagenet_full",
309 |       "batch_size": 128,
310 |       "n_layers": 50,
311 |       "method": "icarl_norm",
312 |       "seed": 100,
313 |       "optimizer": "momentum",
314 |       "epochs_per_task": 100,
315 |       "checkpoint_interval": 5,
316 |       "lr": 0.1,
317 |       "lr_gamma": 0.1,
318 |       "lr_schedule": "80 120",
319 |       "weight_decay": 1e-5,
320 |       "n_memories_per_class": 20,
321 |       "total_n_memories": -1,
322 |       "group": "iirc_imagenet_full_final"
323 |     },
324 |     "iterable_arguments": {
325 |       "tasks_configuration_id": [
326 |         0,
327 |         1,
328 |         2,
329 |         3,
330 |         4
331 |       ]
332 |     },
333 |     "flags": {
334 |       "reduce_lr_on_plateau": true,
335 |       "use_best_model": false,
336 |       "complete_info": false,
337 |       "incremental_joint": false,
338 |       "joint": false
339 |     }
340 |   },
341 |   "agem_20": {
342 |     "active": true,
343 |     "run_id_key": "tasks_configuration_id",
344 |     "cluster_arguments": {
345 |       "gpus_per_node": 1,
346 |       "nodes": 1,
347 |       "time": "71:00:00"
348 |     },
349 |     "fixed_arguments": {
350 |       "dataset": "iirc_imagenet_full",
351 |       "batch_size": 128,
352 |       "n_layers": 50,
353 |       "method": "agem",
354 |       "seed": 100,
355 |       "optimizer": "momentum",
356 |       "epochs_per_task": 100,
357 |       "checkpoint_interval": 5,
358 |       "lr": 0.5,
359 |       "lr_gamma": 0.1,
360 |       "lr_schedule": "80 120",
361 |       "weight_decay": 1e-5,
362 |       "n_memories_per_class": 20,
363 |       "total_n_memories": -1,
364 |       "group": "iirc_imagenet_full_final"
365 |     },
366 |     "iterable_arguments": {
367 |       "tasks_configuration_id": [
368 |         0,
369 |         1,
370 |         2,
371 |         3,
372 |         4
373 |       ]
374 |     },
375 |     "flags": {
376 |       "reduce_lr_on_plateau": true,
377 |       "use_best_model": false,
378 |       "complete_info": false,
379 |       "incremental_joint": false,
380 |       "joint": false
381 |     }
382 |   }
383 | }
384 | 


--------------------------------------------------------------------------------
/experiments/experiments_configurations/configurations_imagenet_lite.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "finetune": {
  3 |     "active": true,
  4 |     "run_id_key": "tasks_configuration_id",
  5 |     "cluster_arguments": {
  6 |       "gpus_per_node": 1,
  7 |       "nodes": 1,
  8 |       "time": "71:00:00"
  9 |     },
 10 |     "fixed_arguments": {
 11 |       "dataset": "iirc_imagenet_lite",
 12 |       "batch_size": 128,
 13 |       "n_layers": 50,
 14 |       "method": "finetune",
 15 |       "seed": 100,
 16 |       "optimizer": "momentum",
 17 |       "epochs_per_task": 100,
 18 |       "checkpoint_interval": 5,
 19 |       "lr": 0.1,
 20 |       "lr_gamma": 0.1,
 21 |       "lr_schedule": "-1",
 22 |       "weight_decay": 0.00001,
 23 |       "n_memories_per_class": 0,
 24 |       "total_n_memories": -1,
 25 |       "group": "iirc_imagenet_lite_final"
 26 |     },
 27 |     "iterable_arguments": {
 28 |       "tasks_configuration_id": [
 29 |         0,
 30 |         1,
 31 |         2,
 32 |         3,
 33 |         4
 34 |       ]
 35 |     },
 36 |     "flags": {
 37 |       "reduce_lr_on_plateau": true,
 38 |       "use_best_model": true,
 39 |       "complete_info": false,
 40 |       "incremental_joint": false,
 41 |       "joint": false
 42 |     }
 43 |   },
 44 |   "finetune_20": {
 45 |     "active": true,
 46 |     "run_id_key": "tasks_configuration_id",
 47 |     "cluster_arguments": {
 48 |       "gpus_per_node": 1,
 49 |       "nodes": 1,
 50 |       "time": "71:00:00"
 51 |     },
 52 |     "fixed_arguments": {
 53 |       "dataset": "iirc_imagenet_lite",
 54 |       "batch_size": 128,
 55 |       "n_layers": 50,
 56 |       "method": "finetune",
 57 |       "seed": 100,
 58 |       "optimizer": "momentum",
 59 |       "epochs_per_task": 100,
 60 |       "checkpoint_interval": 5,
 61 |       "lr": 0.1,
 62 |       "lr_gamma": 0.1,
 63 |       "lr_schedule": "-1",
 64 |       "weight_decay": 0.00001,
 65 |       "n_memories_per_class": 20,
 66 |       "total_n_memories": -1,
 67 |       "group": "iirc_imagenet_lite_final"
 68 |     },
 69 |     "iterable_arguments": {
 70 |       "tasks_configuration_id": [
 71 |         0,
 72 |         1,
 73 |         2,
 74 |         3,
 75 |         4
 76 |       ]
 77 |     },
 78 |     "flags": {
 79 |       "reduce_lr_on_plateau": true,
 80 |       "use_best_model": true,
 81 |       "complete_info": false,
 82 |       "incremental_joint": false,
 83 |       "joint": false
 84 |     }
 85 |   },
 86 |   "finetune_50": {
 87 |     "active": true,
 88 |     "run_id_key": "tasks_configuration_id",
 89 |     "cluster_arguments": {
 90 |       "gpus_per_node": 1,
 91 |       "nodes": 1,
 92 |       "time": "71:00:00"
 93 |     },
 94 |     "fixed_arguments": {
 95 |       "dataset": "iirc_imagenet_lite",
 96 |       "batch_size": 128,
 97 |       "n_layers": 50,
 98 |       "method": "finetune",
 99 |       "seed": 100,
100 |       "optimizer": "momentum",
101 |       "epochs_per_task": 100,
102 |       "checkpoint_interval": 5,
103 |       "lr": 0.1,
104 |       "lr_gamma": 0.1,
105 |       "lr_schedule": "-1",
106 |       "weight_decay": 0.00001,
107 |       "n_memories_per_class": 50,
108 |       "total_n_memories": -1,
109 |       "group": "iirc_imagenet_lite_final"
110 |     },
111 |     "iterable_arguments": {
112 |       "tasks_configuration_id": [
113 |         0,
114 |         1,
115 |         2,
116 |         3,
117 |         4
118 |       ]
119 |     },
120 |     "flags": {
121 |       "reduce_lr_on_plateau": true,
122 |       "use_best_model": true,
123 |       "complete_info": false,
124 |       "incremental_joint": false,
125 |       "joint": false
126 |     }
127 |   },
128 |   "finetune_100": {
129 |     "active": true,
130 |     "run_id_key": "tasks_configuration_id",
131 |     "cluster_arguments": {
132 |       "gpus_per_node": 1,
133 |       "nodes": 1,
134 |       "time": "71:00:00"
135 |     },
136 |     "fixed_arguments": {
137 |       "dataset": "iirc_imagenet_lite",
138 |       "batch_size": 128,
139 |       "n_layers": 50,
140 |       "method": "finetune",
141 |       "seed": 100,
142 |       "optimizer": "momentum",
143 |       "epochs_per_task": 100,
144 |       "checkpoint_interval": 5,
145 |       "lr": 0.1,
146 |       "lr_gamma": 0.1,
147 |       "lr_schedule": "-1",
148 |       "weight_decay": 0.00001,
149 |       "n_memories_per_class": 100,
150 |       "total_n_memories": -1,
151 |       "group": "iirc_imagenet_lite_final"
152 |     },
153 |     "iterable_arguments": {
154 |       "tasks_configuration_id": [
155 |         0,
156 |         1,
157 |         2,
158 |         3,
159 |         4
160 |       ]
161 |     },
162 |     "flags": {
163 |       "reduce_lr_on_plateau": true,
164 |       "use_best_model": true,
165 |       "complete_info": false,
166 |       "incremental_joint": false,
167 |       "joint": false
168 |     }
169 |   },
170 |   "incremental_joint": {
171 |     "active": true,
172 |     "run_id_key": "tasks_configuration_id",
173 |     "cluster_arguments": {
174 |       "gpus_per_node": 4,
175 |       "nodes": 1,
176 |       "time": "71:00:00"
177 |     },
178 |     "fixed_arguments": {
179 |       "dataset": "iirc_imagenet_lite",
180 |       "batch_size": 128,
181 |       "n_layers": 50,
182 |       "method": "finetune",
183 |       "seed": 100,
184 |       "optimizer": "momentum",
185 |       "epochs_per_task": 100,
186 |       "checkpoint_interval": 5,
187 |       "lr": 0.1,
188 |       "lr_gamma": 0.1,
189 |       "lr_schedule": "-1",
190 |       "weight_decay": 0.00001,
191 |       "n_memories_per_class": 0,
192 |       "total_n_memories": -1,
193 |       "group": "iirc_imagenet_lite_final"
194 |     },
195 |     "iterable_arguments": {
196 |       "tasks_configuration_id": [
197 |         0,
198 |         1,
199 |         2,
200 |         3,
201 |         4
202 |       ]
203 |     },
204 |     "flags": {
205 |       "reduce_lr_on_plateau": true,
206 |       "use_best_model": true,
207 |       "complete_info": true,
208 |       "incremental_joint": true,
209 |       "joint": false
210 |     }
211 |   },
212 |   "lucir_20": {
213 |     "active": true,
214 |     "run_id_key": "tasks_configuration_id",
215 |     "cluster_arguments": {
216 |       "gpus_per_node": 1,
217 |       "nodes": 1,
218 |       "time": "71:00:00"
219 |     },
220 |     "fixed_arguments": {
221 |       "dataset": "iirc_imagenet_lite",
222 |       "batch_size": 128,
223 |       "n_layers": 50,
224 |       "method": "lucir",
225 |       "seed": 100,
226 |       "optimizer": "momentum",
227 |       "epochs_per_task": 100,
228 |       "checkpoint_interval": 5,
229 |       "lr": 0.1,
230 |       "lr_gamma": 0.1,
231 |       "lr_schedule": "80 120",
232 |       "weight_decay": 1e-5,
233 |       "n_memories_per_class": 20,
234 |       "total_n_memories": -1,
235 |       "lucir_lambda": 5.0,
236 |       "lucir_margin_1": 0.5,
237 |       "lucir_margin_2": 0.5,
238 |       "group": "iirc_imagenet_lite_final"
239 |     },
240 |     "iterable_arguments": {
241 |       "tasks_configuration_id": [
242 |         0,
243 |         1,
244 |         2,
245 |         3,
246 |         4
247 |       ]
248 |     },
249 |     "flags": {
250 |       "reduce_lr_on_plateau": true,
251 |       "use_best_model": false,
252 |       "complete_info": false,
253 |       "incremental_joint": false,
254 |       "joint": false
255 |     }
256 |   },
257 |   "icarl_cnn_20": {
258 |     "active": true,
259 |     "run_id_key": "tasks_configuration_id",
260 |     "cluster_arguments": {
261 |       "gpus_per_node": 1,
262 |       "nodes": 1,
263 |       "time": "71:00:00"
264 |     },
265 |     "fixed_arguments": {
266 |       "dataset": "iirc_imagenet_lite",
267 |       "batch_size": 128,
268 |       "n_layers": 50,
269 |       "method": "icarl_cnn",
270 |       "seed": 100,
271 |       "optimizer": "momentum",
272 |       "epochs_per_task": 100,
273 |       "checkpoint_interval": 5,
274 |       "lr": 0.5,
275 |       "lr_gamma": 0.1,
276 |       "lr_schedule": "80 120",
277 |       "weight_decay": 1e-5,
278 |       "n_memories_per_class": 20,
279 |       "total_n_memories": -1,
280 |       "group": "iirc_imagenet_lite_final"
281 |     },
282 |     "iterable_arguments": {
283 |       "tasks_configuration_id": [
284 |         0,
285 |         1,
286 |         2,
287 |         3,
288 |         4
289 |       ]
290 |     },
291 |     "flags": {
292 |       "reduce_lr_on_plateau": true,
293 |       "use_best_model": false,
294 |       "complete_info": false,
295 |       "incremental_joint": false,
296 |       "joint": false
297 |     }
298 |   },
299 |   "icarl_norm_20": {
300 |     "active": true,
301 |     "run_id_key": "tasks_configuration_id",
302 |     "cluster_arguments": {
303 |       "gpus_per_node": 1,
304 |       "nodes": 1,
305 |       "time": "71:00:00"
306 |     },
307 |     "fixed_arguments": {
308 |       "dataset": "iirc_imagenet_lite",
309 |       "batch_size": 128,
310 |       "n_layers": 50,
311 |       "method": "icarl_norm",
312 |       "seed": 100,
313 |       "optimizer": "momentum",
314 |       "epochs_per_task": 100,
315 |       "checkpoint_interval": 5,
316 |       "lr": 0.1,
317 |       "lr_gamma": 0.1,
318 |       "lr_schedule": "80 120",
319 |       "weight_decay": 1e-5,
320 |       "n_memories_per_class": 20,
321 |       "total_n_memories": -1,
322 |       "group": "iirc_imagenet_lite_final"
323 |     },
324 |     "iterable_arguments": {
325 |       "tasks_configuration_id": [
326 |         0,
327 |         1,
328 |         2,
329 |         3,
330 |         4
331 |       ]
332 |     },
333 |     "flags": {
334 |       "reduce_lr_on_plateau": true,
335 |       "use_best_model": false,
336 |       "complete_info": false,
337 |       "incremental_joint": false,
338 |       "joint": false
339 |     }
340 |   },
341 |   "agem_20": {
342 |     "active": true,
343 |     "run_id_key": "tasks_configuration_id",
344 |     "cluster_arguments": {
345 |       "gpus_per_node": 1,
346 |       "nodes": 1,
347 |       "time": "71:00:00"
348 |     },
349 |     "fixed_arguments": {
350 |       "dataset": "iirc_imagenet_lite",
351 |       "batch_size": 128,
352 |       "n_layers": 50,
353 |       "method": "agem",
354 |       "seed": 100,
355 |       "optimizer": "momentum",
356 |       "epochs_per_task": 100,
357 |       "checkpoint_interval": 5,
358 |       "lr": 0.5,
359 |       "lr_gamma": 0.1,
360 |       "lr_schedule": "80 120",
361 |       "weight_decay": 1e-5,
362 |       "n_memories_per_class": 20,
363 |       "total_n_memories": -1,
364 |       "group": "iirc_imagenet_lite_final"
365 |     },
366 |     "iterable_arguments": {
367 |       "tasks_configuration_id": [
368 |         0,
369 |         1,
370 |         2,
371 |         3,
372 |         4
373 |       ]
374 |     },
375 |     "flags": {
376 |       "reduce_lr_on_plateau": true,
377 |       "use_best_model": false,
378 |       "complete_info": false,
379 |       "incremental_joint": false,
380 |       "joint": false
381 |     }
382 |   }
383 | }
384 | 


--------------------------------------------------------------------------------
/experiments/metrics.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import numpy as np
 3 | 
 4 | 
 5 | def jaccard_sim(predictions, target):
 6 |     '''
 7 |     Jaccard similarity (intersection over union)
 8 |     Args:
 9 |         predictions (boolean tensor): Model predictions of size batch_size x number of classes
10 |         target (boolean tensor): target predictions of size batch_size x number of classes
11 |     '''
12 |     jac_sim = torch.sum(target & predictions, dim=-1) * 1.0 / torch.sum(target | predictions, dim=-1)
13 |     jac_sim = torch.sum(jac_sim)
14 |     jac_sim /= target.shape[0]
15 |     return jac_sim.item()
16 | 
17 | 
18 | def modified_jaccard_sim(predictions, target):
19 |     '''
20 |     Jaccard similarity multiplied by percentage of correct predictions (per sample precision)
21 |     Args:
22 |         predictions (boolean tensor): Model predictions of size batch_size x number of classes
23 |         target (boolean tensor): target predictions of size batch_size x number of classes
24 |     '''
25 |     jac_sim = torch.sum(target & predictions, dim=-1) * 1.0 / torch.sum(target | predictions, dim=-1)
26 |     correct_pred_pct = torch.sum(target & predictions, dim=-1) * 1.0 / (torch.sum(predictions, dim=-1) + 1e-8)
27 |     modified_jac_sim = jac_sim * correct_pred_pct
28 |     modified_jac_sim = torch.sum(modified_jac_sim)
29 |     modified_jac_sim /= target.shape[0]
30 |     return modified_jac_sim.item()
31 | 
32 | 
33 | def strict_accuracy(predictions, target):
34 |     '''
35 |     The accuracy measure where if some of the labels for a sample are predicted correctly, and some are wrong, it gives
36 |     a score of zero to the accuracy of that sample
37 |     Args:
38 |         predictions (boolean tensor): Model predictions of size batch_size x number of classes
39 |         target (boolean tensor): target predictions of size batch_size x number of classes
40 |     '''
41 |     acc = torch.sum((target == predictions).all(dim=-1)) * 1.0
42 |     acc /= target.shape[0]
43 |     return acc.item()
44 | 
45 | 
46 | def recall(predictions, target):
47 |     '''
48 |     The recall measure
49 |     Args:
50 |         predictions (torch.BoolTensor): Model predictions of size batch_size x number of classes
51 |         target (torch.BoolTensor): target predictions of size batch_size x number of classes
52 |     '''
53 |     recall = torch.sum(predictions[target]) * 1.0 / torch.sum(target)
54 |     return recall.item()
55 | 
56 | 
57 | 


--------------------------------------------------------------------------------
/experiments/prepare_config.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import random
 3 | 
 4 | def prepare_config(args):
 5 |     config = vars(args)
 6 |     config["cur_task_id"] = 0
 7 |     config["task_epoch"] = 0
 8 |     if args.wandb_project is not None and args.wandb_project != "None":
 9 |         config["wandb_log"] = True
10 |     else:
11 |         config["wandb_log"] = False
12 | 
13 |     if config["reduce_lr_on_plateau"]:
14 |         config["lr_schedule"] = None
15 | 
16 |     if config['run_id'] is None:
17 |         config['run_id'] = random.randint(0, 100000)
18 | 
19 |     if config["incremental_joint"]:
20 |         assert config["complete_info"], "Use incremental_joint only with the complete_info option. Otherwise, " \
21 |                                         "increase the buffer size"
22 |         config["total_n_memories"] = 0
23 |         config["n_memories_per_class"] = -1
24 | 
25 |     if config["joint"]:
26 |         assert config["complete_info"], "Use joint only with the complete_info option."
27 |         config["total_n_memories"] = 0
28 |         config["n_memories_per_class"] = -1
29 | 
30 |     config['id'] = f"{config['dataset']}" \
31 |                    f"_{config['method']}" \
32 |                    f"_{config['optimizer']}" \
33 |                    f"_lr{config['lr']}" \
34 |                    f"_wd{config['weight_decay']}"
35 |     if not config['joint']:
36 |         config['id'] += f"_tci{config['tasks_configuration_id']}"
37 |     if config["complete_info"]:
38 |         config['id'] += "_complete_info"
39 |     if config["incremental_joint"]:
40 |         config['id'] += "_incremental_joint"
41 |     elif config['joint']:
42 |         config['id'] += "_joint"
43 |     elif config['n_memories_per_class'] > -1:
44 |         config['total_n_memories'] = -1
45 |         if config['n_memories_per_class'] > 0:
46 |             config['id'] += f"_nmpc{config['n_memories_per_class']}"
47 |     else:
48 |         config['n_memories_per_class'] = -1
49 |         if config['total_n_memories'] > 0:
50 |             config['id'] += f"_tnm{config['total_n_memories']}"
51 |     if config['reduce_lr_on_plateau']:
52 |         config['id'] += "_lr_on_plat"
53 |     elif config["lr_schedule"] is not None:
54 |         config['id'] += "_lr_sched"
55 |     if config['use_best_model']:
56 |         config['id'] += "_use_best"
57 |     config['id'] += f"_nl{config['n_layers']}" \
58 |                     f"_ept{config['epochs_per_task']}" \
59 |                     f"_s{config['seed']}" \
60 |                     f"_{config['run_id']}"
61 | 
62 |     config['logging_path'] = os.path.join(config['logging_path_root'], config['id'])
63 |     return config


--------------------------------------------------------------------------------
/experiments/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/experiments/tests/__init__.py


--------------------------------------------------------------------------------
/experiments/tests/test_metrics.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from experiments.metrics import jaccard_sim, modified_jaccard_sim, strict_accuracy
 3 | import torch
 4 | 
 5 | target1 = torch.tensor([[1, 0, 0, 0], [1, 0, 1, 0]]).bool()
 6 | 
 7 | predictions11 = torch.tensor([[0, 1, 0, 0], [0, 1, 0, 0]]).bool()
 8 | JS11 = 0
 9 | MJS11 = 0
10 | acc11 = 0
11 | 
12 | predictions12 = torch.tensor([[1, 0, 0, 0], [0, 0, 1, 0]]).bool()
13 | JS12 = 0.75
14 | MJS12 = 0.75
15 | acc12 = 0.5
16 | 
17 | predictions13 = torch.tensor([[1, 1, 1, 1], [1, 1, 1, 1]]).bool()
18 | JS13 = 0.375
19 | MJS13 = 0.15625
20 | acc13 = 0
21 | 
22 | predictions14 = torch.tensor([[1, 1, 0, 0], [0, 1, 1, 1]]).bool()
23 | JS14 = 0.375
24 | MJS14 = 0.16667
25 | acc14 = 0
26 | 
27 | predictions15 = torch.tensor([[0, 0, 0, 0], [0, 0, 0, 0]]).bool()
28 | JS15 = 0
29 | MJS15 = 0
30 | acc15 = 0
31 | 
32 | 
33 | @pytest.mark.parametrize("target, predictions, expected_JS, expected_MJS, expected_acc",
34 |                          [(target1, predictions11, JS11, MJS11, acc11),
35 |                           (target1, predictions12, JS12, MJS12, acc12),
36 |                           (target1, predictions13, JS13, MJS13, acc13),
37 |                           (target1, predictions14, JS14, MJS14, acc14),
38 |                           (target1, predictions15, JS15, MJS15, acc15)])
39 | def test_metrics(target, predictions, expected_JS, expected_MJS, expected_acc):
40 |     assert round(jaccard_sim(predictions, target), 5) == expected_JS
41 |     assert round(modified_jaccard_sim(predictions, target), 5) == expected_MJS
42 |     assert round(strict_accuracy(predictions, target), 5) == expected_acc
43 | 


--------------------------------------------------------------------------------
/experiments/tests/test_utils.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from experiments.utils import extend_list
 3 | 
 4 | 
 5 | @pytest.mark.parametrize("input_, output_length, expected_output",
 6 |                          [(5, 0, []),
 7 |                           ([10, 3], 0, []),
 8 |                           (5, 1, [5]),
 9 |                           (5, 2, [5, 5]),
10 |                           ([10, 3, 2], 5, [10, 3, 2, 2, 2]),
11 |                           ([10, 3, 2], 2, [10, 3])])
12 | def test_extend_list(input_, output_length, expected_output):
13 |     extended_list = extend_list(input_, output_length)
14 |     assert extended_list == expected_output
15 | 


--------------------------------------------------------------------------------
/experiments/utils.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import torch.nn as nn
 3 | import json
 4 | 
 5 | 
 6 | def log(epoch, task_id, log_dict, logbook):
 7 |     log_dict["message"] = f"task_{task_id}_metrics"
 8 |     log_dict["task_id"] = task_id
 9 |     log_dict["task_epoch"] = epoch
10 |     log_dict["step"] = epoch
11 |     logbook.write_metric(log_dict)
12 | 
13 | 
14 | def log_task(task_id, log_dict, logbook):
15 |     log_dict["message"] = f"incremental_metrics"
16 |     log_dict["task_id"] = task_id
17 |     log_dict["step"] = task_id
18 |     logbook.write_metric(log_dict)
19 | 
20 | 
21 | def pad_random_crop(tensor_img, per_direction_padding=0):
22 |     pad_left = pad_right = pad_top = pad_bottom = per_direction_padding
23 |     tensor_width = tensor_img.shape[-1]
24 |     tensor_height = tensor_img.shape[-2]
25 |     tensor_img = nn.functional.pad(tensor_img,
26 |                                    [pad_left, pad_right, pad_top, pad_bottom])
27 | 
28 |     start_index_width = np.random.randint(0, pad_left + pad_right)
29 |     start_index_height = np.random.randint(0, pad_top + pad_bottom)
30 |     end_index_width = start_index_width + tensor_width
31 |     end_index_height = start_index_height + tensor_height
32 | 
33 |     return tensor_img[..., start_index_height:end_index_height, start_index_width:end_index_width]
34 | 
35 | 
36 | def random_horizontal_flip(tensor_img, flip_prop=0.5):
37 |     do_flip = np.random.random() >= (1 - flip_prop)
38 |     if do_flip:
39 |         return tensor_img.flip((-1))
40 |     else:
41 |         return tensor_img
42 | 
43 | 
44 | def remove_extra_logs(cur_task_id, cur_epoch, file):
45 |     logs_to_keep = []
46 |     remove_task_summary = False
47 |     with open(file, 'r') as logs_file:
48 |         for line in logs_file:
49 |             json_line = json.loads(line)
50 |             if not (json_line['logbook_type'] == "metric"):
51 |                 logs_to_keep.append(json_line)
52 |             elif json_line["task_id"] < cur_task_id:
53 |                 logs_to_keep.append(json_line)
54 |             elif json_line["task_id"] == cur_task_id:
55 |                 if "task_epoch" in json_line.keys() and json_line["task_epoch"] < cur_epoch:
56 |                     logs_to_keep.append(json_line)
57 |                 elif "task_epoch" in json_line.keys() and json_line["task_epoch"] >= cur_epoch:
58 |                     remove_task_summary = True
59 |                 elif not remove_task_summary:
60 |                     logs_to_keep.append(json_line)
61 |     with open(file, 'w') as logs_file:
62 |         for json_line in logs_to_keep:
63 |             logs_file.write(json.dumps(json_line))
64 |             logs_file.write("\n")
65 | 
66 | 
67 | def extend_list(input_, output_length):
68 |     if isinstance(input_, int):
69 |         output = [input_ for _ in range(output_length)]
70 |     elif hasattr(input_, '__iter__'):
71 |         if len(input_) < output_length:
72 |             output = input_
73 |             output.extend([input_[-1] for _ in range(output_length - len(input_))])
74 |         elif len(input_) > output_length:
75 |             output = input_[:output_length]
76 |         else:
77 |             output = input_
78 |     else:
79 |         raise TypeError("Neither an integer nor an iterable was provided")
80 |     return output


--------------------------------------------------------------------------------
/iirc.egg-info/PKG-INFO:
--------------------------------------------------------------------------------
 1 | Metadata-Version: 2.1
 2 | Name: iirc
 3 | Version: 1.0.1
 4 | Summary: This package provides a way for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to  the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner. 
 5 | Home-page: https://chandar-lab.github.io/IIRC/
 6 | Author: Mohamed Abdelsalam
 7 | Author-email: mabdelsalam944@gmail.com
 8 | License: MIT
 9 | Project-URL: Documentation, https://iirc.readthedocs.io/en/latest/
10 | Project-URL: Source, https://github.com/chandar-lab/IIRC
11 | Description: # iirc package
12 |         ![img.png](https://raw.githubusercontent.com/chandar-lab/IIRC/master/docs/images/task_summary.png)
13 |         
14 |         This package provides a way for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to 
15 |         the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner.
16 |         
17 |         The documentation and usage guide are available [here](https://iirc.readthedocs.io/en/latest/)
18 |         
19 |         [Homepage](https://chandar-lab.github.io/IIRC/) | [Paper](https://arxiv.org/abs/2012.12477) | 
20 |         [Documentation](https://iirc.readthedocs.io/en/latest/)
21 |         
22 |         ## Installation
23 |         you can install this package using the following command
24 |         
25 |         ```pip install iirc```
26 |         
27 |         ## Dataset Downloading Instructions
28 |         ### CIFAR-100
29 |         To be able to run the code with *CIFAR-100* derived datasets, just download the dataset from the 
30 |         [official website](https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz) and extract it, or use the 
31 |         *./utils/download_cifar.py* file. 
32 |         
33 |         ### ImageNet
34 |         In the case of ImageNet, it has to be downloaded manually, and be arranged in the following manner: 
35 |         * dataset folder
36 |           * train 
37 |             * n01440764
38 |             * n01443537
39 |             * …
40 |           * val 
41 |             * n01440764 
42 |             * n01443537 
43 |             * …
44 |             
45 |         ## Contributing
46 |         If you think you can help us make the **iirc** package more useful for the lifelong learning 
47 |         community, please don't hesistate to submit an issue or send a pull request.
48 |         
49 |         ## Citation
50 |         If you find this work useful for your research, this is the way to cite it:
51 |         
52 |         ```
53 |         @misc{abdelsalam2021iirc,
54 |         title = {IIRC: Incremental Implicitly-Refined Classification},
55 |         author={Mohamed Abdelsalam and Mojtaba Faramarzi and Shagun Sodhani and Sarath Chandar},
56 |         year={2021}, eprint={2012.12477}, archivePrefix={arXiv},
57 |         primaryClass={cs.CV} }
58 |         ```
59 |         
60 | Platform: UNKNOWN
61 | Classifier: License :: OSI Approved :: MIT License
62 | Classifier: Programming Language :: Python :: 3
63 | Classifier: Programming Language :: Python :: 3.8
64 | Requires-Python: >=3
65 | Description-Content-Type: text/markdown
66 | 


--------------------------------------------------------------------------------
/iirc.egg-info/SOURCES.txt:
--------------------------------------------------------------------------------
 1 | LICENSE
 2 | MANIFEST.in
 3 | README.md
 4 | setup.py
 5 | iirc/README.md
 6 | iirc/__init__.py
 7 | iirc/datasets_loader.py
 8 | iirc/definitions.py
 9 | iirc.egg-info/PKG-INFO
10 | iirc.egg-info/SOURCES.txt
11 | iirc.egg-info/dependency_links.txt
12 | iirc.egg-info/requires.txt
13 | iirc.egg-info/top_level.txt
14 | iirc/lifelong_dataset/__init__.py
15 | iirc/lifelong_dataset/base_dataset.py
16 | iirc/lifelong_dataset/tensorflow_dataset.py
17 | iirc/lifelong_dataset/torch_dataset.py
18 | iirc/metadata/cifar100_classes.json
19 | iirc/metadata/dataset_configurations.json
20 | iirc/metadata/iirc_cifar100_hierarchy.json
21 | iirc/metadata/iirc_cifar100_task_configurations.json
22 | iirc/metadata/iirc_imagenet_full_task_configurations.json
23 | iirc/metadata/iirc_imagenet_hierarchy_wnids.json
24 | iirc/metadata/iirc_imagenet_hierarchy_words.json
25 | iirc/metadata/iirc_imagenet_lite_task_configurations.json
26 | iirc/metadata/imagenet_classes.json
27 | iirc/metadata/incremental_cifar100_task_configurations.json
28 | iirc/metadata/incremental_imagenet_full_task_configurations.json
29 | iirc/metadata/incremental_imagenet_lite_task_configurations.json
30 | iirc/utils/__init__.py
31 | iirc/utils/download_cifar.py
32 | iirc/utils/prepare_imagenet.py
33 | iirc/utils/utils.py


--------------------------------------------------------------------------------
/iirc.egg-info/dependency_links.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/iirc.egg-info/requires.txt:
--------------------------------------------------------------------------------
1 | numpy
2 | Pillow
3 | lmdb
4 | 


--------------------------------------------------------------------------------
/iirc.egg-info/top_level.txt:
--------------------------------------------------------------------------------
1 | iirc
2 | 


--------------------------------------------------------------------------------
/iirc/README.md:
--------------------------------------------------------------------------------
 1 | # iirc package
 2 | ![img.png](https://raw.githubusercontent.com/chandar-lab/IIRC/master/docs/images/task_summary.png)
 3 | 
 4 | This package provides a way for adapting the different datasets (currently supports *CIFAR-100* and *ImageNet*) to 
 5 | the *iirc* setup and the *class incremental learning* setup, and loading them in a standardized manner.
 6 | 
 7 | The documentation and usage guide are available [here](https://iirc.readthedocs.io/en/latest/)
 8 | 
 9 | [Homepage](https://chandar-lab.github.io/IIRC/) | [Paper](https://arxiv.org/abs/2012.12477) | 
10 | [Documentation](https://iirc.readthedocs.io/en/latest/)
11 | 
12 | ## Installation
13 | you can install this package using the following command
14 | 
15 | ```pip install iirc```
16 | 
17 | ## Dataset Downloading Instructions
18 | ### CIFAR-100
19 | To be able to run the code with *CIFAR-100* derived datasets, just download the dataset from the 
20 | [official website](https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz) and extract it, or use the 
21 | *./utils/download_cifar.py* file. 
22 | 
23 | ### ImageNet
24 | In the case of ImageNet, it has to be downloaded manually, and be arranged in the following manner: 
25 | * dataset folder
26 |   * train 
27 |     * n01440764
28 |     * n01443537
29 |     * …
30 |   * val 
31 |     * n01440764 
32 |     * n01443537 
33 |     * …
34 |     
35 | ## Contributing
36 | If you think you can help us make the **iirc** package more useful for the lifelong learning 
37 | community, please don't hesistate to submit an issue or send a pull request.
38 | 
39 | ## Citation
40 | If you find this work useful for your research, this is the way to cite it:
41 | 
42 | ```
43 | @misc{abdelsalam2021iirc,
44 | title = {IIRC: Incremental Implicitly-Refined Classification},
45 | author={Mohamed Abdelsalam and Mojtaba Faramarzi and Shagun Sodhani and Sarath Chandar},
46 | year={2021}, eprint={2012.12477}, archivePrefix={arXiv},
47 | primaryClass={cs.CV} }
48 | ```
49 | 


--------------------------------------------------------------------------------
/iirc/__init__.py:
--------------------------------------------------------------------------------
1 | __version__ = '1.0.1'


--------------------------------------------------------------------------------
/iirc/definitions.py:
--------------------------------------------------------------------------------
1 | from typing import Union, List, Tuple
2 | from PIL import Image
3 | 
4 | PYTORCH = "PyTorch"
5 | TENSORFLOW = "Tensorflow"
6 | NO_LABEL_PLACEHOLDER = "None"  # A place holder when only one label is provided
7 | CIL_SETUP = "CIL"  # Class Incemental Learning Setup
8 | IIRC_SETUP = "IIRC"  # Incremental Implicitly Refined Classification Setup
9 | DatasetStructType = Union[List[Tuple[Image.Image, Tuple[str, ...]]], List[Tuple[str, Tuple[str, ...]]]]


--------------------------------------------------------------------------------
/iirc/lifelong_dataset/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/iirc/lifelong_dataset/__init__.py


--------------------------------------------------------------------------------
/iirc/lifelong_dataset/tensorflow_dataset.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from PIL import Image
  3 | import tensorflow as tf
  4 | from typing import Optional, Callable, List, Tuple, Union
  5 | 
  6 | from iirc.lifelong_dataset.base_dataset import BaseDataset
  7 | from iirc.definitions import IIRC_SETUP, DatasetStructType
  8 | 
  9 | 
 10 | class Dataset(BaseDataset):
 11 |     """
 12 |     An Lifelong Learning dataset that returns images as numpy arrays or tensorflow tensors
 13 | 
 14 |     Args:
 15 |         dataset (DatasetStructType): a list of tuples which contains the data in the form of (image, (label,)) or
 16 |             (image, (label1,label2)). The image path (str) can be provided instead if the images would be loaded on the
 17 |             fly (see the argument using_image_path). label is a string representing the class name
 18 |         tasks (List[List[str]]): a list of lists where each inner list contains the set of classes (class names) that
 19 |             will be introduced in that task (example: [[dog, cat, car], [tiger, truck, fish]])
 20 |         setup (str): Class Incremental Learning setup (CIL) or Incremental Implicitly Refined Classification setup
 21 |             (IIRC) (default: IIRC_SETUP)
 22 |         using_image_path (bool): whether the pillow image is provided in the dataset argument, or the image path that
 23 |             would be used later to load the image. set True if using the image path (default: False)
 24 |         cache_images (bool): cache images that belong to the current task in the memory, only applicable when using
 25 |             the image path (default: False)
 26 |         essential_transforms_fn (Optional[Callable[[Image.Image], Union[tf.Tensor, np.ndarray]]]): A function that
 27 |             contains the essential transforms (for example, converting a pillow image to a tensor) that should be
 28 |             applied to each image. This function is applied only when the augmentation_transforms_fn is set to None
 29 |             (as in the case of a test set) or inside the disable_augmentations context (default: None)
 30 |         augmentation_transforms_fn: (Optional[Callable[[Image.Image], Union[tf.Tensor, np.ndarray]]]): A function that
 31 |             contains the essential transforms (for example, converting a pillow image to a tensor) and augmentation
 32 |             transforms (for example, applying random cropping) that should be applied to each image.
 33 |             When this function is provided, essential_transforms_fn is not used except inside the disable_augmentations
 34 |             context (default: None)
 35 |         test_mode (bool): Whether this dataset is considered a training split or a test split. This info is only helpful
 36 |             when using the IIRC setup (default: False)
 37 |         complete_information_mode (bool): Whether the dataset is in complete information mode or incomplete information
 38 |             mode.
 39 |             This is only valid when using the IIRC setup.
 40 |             In the incomplete information mode, if a sample has two labels corresponding to a previous task and a
 41 |             current task (example: dog and Bulldog), only the label present in the current task is provided (Bulldog).
 42 |             In the complete information mode, both labels will be provided. In all cases, no label from a future task
 43 |             would be provided.
 44 |             When no value is set for complete_information_mode, this value is defaulted to the test_mode value (complete
 45 |             information during test mode only) (default: None)
 46 |         superclass_data_pct (float) : The percentage of samples sampled for each superclass from its consistuent
 47 |             subclasses.
 48 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 49 |             For example, If the superclass "dog" has the subclasses "Bulldog" and "Whippet", and superclass_data_pct is
 50 |             set to 0.4, then 40% of each of the "Bulldog" samples and "Whippet" samples will be provided when training
 51 |             on the task that has the class "dog"  (default: 0.6)
 52 |         subclass_data_pct (float): The percentage of samples sampled for each subclass if it has a superclass.
 53 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 54 |             For example, If the superclass "dog" has one of the subclasses as "Bulldog", and superclass_data_pct is
 55 |             set to 0.4 while subclass_data_pct is set to 0.8, then 40% of the "Bulldog" samples will be provided when
 56 |             training on the task that contains "dog", and 80% of the "Bulldog" samples will be provided when training on
 57 |             the task that contains "Bulldog". superclass_data_pct and subclass_data_pct don't need to sum to 1 as the
 58 |             samples can be repeated across tasks (in the previous example, 20% of the samples were repeated across the
 59 |             two tasks) (default: 0.6)
 60 |         superclass_sampling_size_cap (int): The number of subclasses a superclass should contain after which the number
 61 |             of samples doesn't increase anymore.
 62 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 63 |             For example, If a superclass has 8 subclasses, with the superclass_data_pct set to 0.4, and
 64 |             superclass_sampling_size_cap set to 5, then superclass_data_pct for that specific superclass will be
 65 |             adjusted to 0.25 (5 / 8 * 0.4) (default: 100)
 66 |     """
 67 | 
 68 |     def __init__(self,
 69 |                  dataset: DatasetStructType,
 70 |                  tasks: List[List[str]],
 71 |                  setup: str = IIRC_SETUP,
 72 |                  using_image_path: bool = False,
 73 |                  cache_images: bool = False,
 74 |                  essential_transforms_fn: Optional[Callable[[Image.Image], Union[tf.Tensor, np.ndarray]]] = None,
 75 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], Union[tf.Tensor, np.ndarray]]] = None,
 76 |                  test_mode: bool = False,
 77 |                  complete_information_mode: Optional[bool] = None,
 78 |                  superclass_data_pct: float = 0.6,
 79 |                  subclass_data_pct: float = 0.6,
 80 |                  superclass_sampling_size_cap: int = 100):
 81 |         if essential_transforms_fn is None:
 82 |             essential_transforms_fn = np.asarray
 83 |         if augmentation_transforms_fn is None:
 84 |             augmentation_transforms_fn = essential_transforms_fn
 85 |         super(Dataset, self).__init__(dataset=dataset, tasks=tasks, setup=setup,
 86 |                                       using_image_path=using_image_path, cache_images=cache_images,
 87 |                                       essential_transforms_fn=essential_transforms_fn,
 88 |                                       augmentation_transforms_fn=augmentation_transforms_fn,
 89 |                                       test_mode=test_mode,
 90 |                                       complete_information_mode=complete_information_mode,
 91 |                                       superclass_data_pct=superclass_data_pct,
 92 |                                       subclass_data_pct=subclass_data_pct,
 93 |                                       superclass_sampling_size_cap=superclass_sampling_size_cap)
 94 | 
 95 |     def __getitem__(self, index) -> Tuple[Union[tf.Tensor, np.ndarray], str, str]:
 96 |         image, label_1, label_2 = self.get_item(index)
 97 |         if self._apply_augmentations:
 98 |             image = self.augmentation_transforms_fn(image)
 99 |         else:
100 |             image = self.essential_transforms_fn(image)
101 |         return image, label_1, label_2
102 | 


--------------------------------------------------------------------------------
/iirc/lifelong_dataset/torch_dataset.py:
--------------------------------------------------------------------------------
  1 | from PIL import Image
  2 | import torch
  3 | import torch.utils.data as data
  4 | import torchvision.transforms as transforms
  5 | from typing import Optional, Callable, List, Tuple
  6 | 
  7 | from iirc.lifelong_dataset.base_dataset import BaseDataset
  8 | from iirc.definitions import IIRC_SETUP, DatasetStructType
  9 | 
 10 | 
 11 | class Dataset(BaseDataset, data.Dataset):
 12 |     """
 13 |      A class inhereting from BaseDataset to be used with PyTorch
 14 | 
 15 |      Args:
 16 |          dataset (DatasetStructType): a list of tuples which contains the data in the form of (image, (label,)) or
 17 |             (image, (label1,label2)). The image path (str) can be provided instead if the images would be loaded on the
 18 |             fly (see the argument using_image_path). label is a string representing the class name
 19 |          tasks (List[List[str]]): a list of lists where each inner list contains the set of classes (class names) that
 20 |             will be introduced in that task (example: [[dog, cat, car], [tiger, truck, fish]])
 21 |          setup (str): Class Incremental Learning setup (CIL) or Incremental Implicitly Refined Classification setup
 22 |             (IIRC) (default: IIRC_SETUP)
 23 |          using_image_path (bool): whether the pillow image is provided in the dataset argument, or the image path that
 24 |             would be used later to load the image. set True if using the image path (default: False)
 25 |          cache_images (bool): cache images that belong to the current task in the memory, only applicable when using the
 26 |             image path (default: False)
 27 |          essential_transforms_fn (Optional[Callable[[Image.Image], torch.Tensor]]): A function that contains the
 28 |             essential transforms (for example, converting a pillow image to a tensor) that should be applied to each
 29 |             image. This function is applied only when the augmentation_transforms_fn is set to None (as in the case
 30 |             of a test set) or inside the disable_augmentations context (default: None)
 31 |          augmentation_transforms_fn: (Optional[Callable[[Image.Image], torch.Tensor]]): A function that contains the
 32 |             essential transforms (for example, converting a pillow image to a tensor) and augmentation transforms (for
 33 |             example, applying random cropping) that should be applied to each image. When this function is provided,
 34 |             essential_transforms_fn is not used except inside the disable_augmentations context (default: None)
 35 |          test_mode (bool): Whether this dataset is considered a training split or a test split. This info is only
 36 |             helpful when using the IIRC setup (default: False)
 37 |          complete_information_mode (bool): Whether the dataset is in complete information mode or incomplete information
 38 |             mode.
 39 |             This is only valid when using the IIRC setup.
 40 |             In the incomplete information mode, if a sample has two labels corresponding to a previous task and a
 41 |             current task (example: dog and Bulldog), only the label present in the current task is provided (Bulldog).
 42 |             In the complete information mode, both labels will be provided. In all cases, no label from a future task
 43 |             would be provided.
 44 |             When no value is set for complete_information_mode, this value is defaulted to the test_mode value (complete
 45 |             information during test mode only) (default: None)
 46 |          superclass_data_pct (float) : The percentage of samples sampled for each superclass from its consistuent
 47 |             subclasses.
 48 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 49 |             For example, If the superclass "dog" has the subclasses "Bulldog" and "Whippet", and superclass_data_pct is
 50 |             set to 0.4, then 40% of each of the "Bulldog" samples and "Whippet" samples will be provided when training
 51 |             on the task that has the class "dog"  (default: 0.6)
 52 |          subclass_data_pct (float): The percentage of samples sampled for each subclass if it has a superclass.
 53 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 54 |             For example, If the superclass "dog" has one of the subclasses as "Bulldog", and superclass_data_pct is set
 55 |             to 0.4 while subclass_data_pct is set to 0.8, then 40% of the "Bulldog" samples will be provided when
 56 |             training on the task that contains "dog", and 80% of the "Bulldog" samples will be provided when training on
 57 |             the task that contains "Bulldog". superclass_data_pct and subclass_data_pct don't need to sum to 1 as the
 58 |             samples can be repeated across tasks (in the previous example, 20% of the samples were repeated across the
 59 |             two tasks) (default: 0.6)
 60 |          superclass_sampling_size_cap (int): The number of subclasses a superclass should contain after which the
 61 |             number of samples doesn't increase anymore.
 62 |             This is valid only when using the IIRC setup and when test_mode is set to False.
 63 |             For example, If a superclass has 8 subclasses, with the superclass_data_pct set to 0.4, and
 64 |             superclass_sampling_size_cap set to 5, then superclass_data_pct for that specific superclass will be
 65 |             adjusted to 0.25 (5 / 8 * 0.4) (default: 100)
 66 |     """
 67 | 
 68 |     def __init__(self,
 69 |                  dataset: DatasetStructType,
 70 |                  tasks: List[List[str]],
 71 |                  setup: str = IIRC_SETUP,
 72 |                  using_image_path: bool = False,
 73 |                  cache_images: bool = False,
 74 |                  essential_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
 75 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
 76 |                  test_mode: bool = False,
 77 |                  complete_information_mode: Optional[bool] = None,
 78 |                  superclass_data_pct: float = 0.6,
 79 |                  subclass_data_pct: float = 0.6,
 80 |                  superclass_sampling_size_cap: int = 100):
 81 |         if essential_transforms_fn is None:
 82 |             essential_transforms_fn = transforms.ToTensor()
 83 |         if augmentation_transforms_fn is None:
 84 |             augmentation_transforms_fn = essential_transforms_fn
 85 |         super(Dataset, self).__init__(dataset=dataset, tasks=tasks, setup=setup,
 86 |                                       using_image_path=using_image_path, cache_images=cache_images,
 87 |                                       essential_transforms_fn=essential_transforms_fn,
 88 |                                       augmentation_transforms_fn=augmentation_transforms_fn,
 89 |                                       test_mode=test_mode,
 90 |                                       complete_information_mode=complete_information_mode,
 91 |                                       superclass_data_pct=superclass_data_pct,
 92 |                                       subclass_data_pct=subclass_data_pct,
 93 |                                       superclass_sampling_size_cap=superclass_sampling_size_cap)
 94 | 
 95 |     def __getitem__(self, index: int) -> Tuple[torch.Tensor, str, str]:
 96 |         image, label_1, label_2 = self.get_item(index)
 97 |         if self._apply_augmentations:
 98 |             image = self.augmentation_transforms_fn(image)
 99 |         else:
100 |             image = self.essential_transforms_fn(image)
101 |         return image, label_1, label_2
102 | 


--------------------------------------------------------------------------------
/iirc/metadata/cifar100_classes.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "classes": [
  3 |     "mushroom",
  4 |     "clock",
  5 |     "keyboard",
  6 |     "lamp",
  7 |     "telephone",
  8 |     "television",
  9 |     "bridge",
 10 |     "castle",
 11 |     "house",
 12 |     "road",
 13 |     "skyscraper",
 14 |     "cloud",
 15 |     "forest",
 16 |     "mountain",
 17 |     "plain",
 18 |     "sea",
 19 |     "crab",
 20 |     "lobster",
 21 |     "snail",
 22 |     "spider",
 23 |     "worm",
 24 |     "lawn_mower",
 25 |     "rocket",
 26 |     "beaver",
 27 |     "dolphin",
 28 |     "otter",
 29 |     "seal",
 30 |     "whale",
 31 |     "aquarium_fish",
 32 |     "flatfish",
 33 |     "ray",
 34 |     "shark",
 35 |     "trout",
 36 |     "orchid",
 37 |     "poppy",
 38 |     "rose",
 39 |     "sunflower",
 40 |     "tulip",
 41 |     "bottle",
 42 |     "bowl",
 43 |     "can",
 44 |     "cup",
 45 |     "plate",
 46 |     "apple",
 47 |     "orange",
 48 |     "pear",
 49 |     "sweet_pepper",
 50 |     "bed",
 51 |     "chair",
 52 |     "couch",
 53 |     "table",
 54 |     "wardrobe",
 55 |     "bee",
 56 |     "beetle",
 57 |     "butterfly",
 58 |     "caterpillar",
 59 |     "cockroach",
 60 |     "leopard",
 61 |     "lion",
 62 |     "tiger",
 63 |     "wolf",
 64 |     "bear",
 65 |     "camel",
 66 |     "cattle",
 67 |     "chimpanzee",
 68 |     "elephant",
 69 |     "kangaroo",
 70 |     "fox",
 71 |     "porcupine",
 72 |     "possum",
 73 |     "raccoon",
 74 |     "skunk",
 75 |     "baby",
 76 |     "boy",
 77 |     "girl",
 78 |     "man",
 79 |     "woman",
 80 |     "crocodile",
 81 |     "dinosaur",
 82 |     "lizard",
 83 |     "snake",
 84 |     "turtle",
 85 |     "hamster",
 86 |     "mouse",
 87 |     "rabbit",
 88 |     "shrew",
 89 |     "squirrel",
 90 |     "maple_tree",
 91 |     "oak_tree",
 92 |     "palm_tree",
 93 |     "pine_tree",
 94 |     "willow_tree",
 95 |     "bicycle",
 96 |     "bus",
 97 |     "motorcycle",
 98 |     "pickup_truck",
 99 |     "train",
100 |     "streetcar",
101 |     "tank",
102 |     "tractor"
103 |   ]
104 | }


--------------------------------------------------------------------------------
/iirc/metadata/dataset_configurations.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "iirc_cifar100": {
 3 |     "superclass_data_pct": 0.4,
 4 |     "subclass_data_pct": 0.8,
 5 |     "intask_valid_train_ratio": 0.1,
 6 |     "posttask_valid_train_ratio": 0.1,
 7 |     "using_image_path": false,
 8 |     "superclass_sampling_size_cap": 8
 9 |   },
10 |   "iirc_imagenet": {
11 |     "superclass_data_pct": 0.4,
12 |     "subclass_data_pct": 0.8,
13 |     "intask_valid_train_ratio": 0.04,
14 |     "posttask_valid_train_ratio": 0.04,
15 |     "using_image_path": true,
16 |     "superclass_sampling_size_cap": 8
17 |   },
18 |   "incremental_cifar100": {
19 |     "superclass_data_pct": 0.002,
20 |     "subclass_data_pct": 1.0,
21 |     "intask_valid_train_ratio": 0.1,
22 |     "posttask_valid_train_ratio": 0.1,
23 |     "using_image_path": false,
24 |     "superclass_sampling_size_cap": 8
25 |   },
26 |   "incremental_imagenet": {
27 |   "superclass_data_pct": 0.002,
28 |   "subclass_data_pct": 1.0,
29 |   "intask_valid_train_ratio": 0.04,
30 |   "posttask_valid_train_ratio": 0.04,
31 |   "using_image_path": true,
32 |   "superclass_sampling_size_cap": 8
33 |   }
34 | }


--------------------------------------------------------------------------------
/iirc/metadata/iirc_cifar100_hierarchy.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "super_classes": {
  3 |     "aquatic_mammals": [
  4 |       "beaver",
  5 |       "dolphin",
  6 |       "otter",
  7 |       "seal",
  8 |       "whale"
  9 |     ],
 10 |     "fish": [
 11 |       "aquarium_fish",
 12 |       "flatfish",
 13 |       "ray",
 14 |       "shark",
 15 |       "trout"
 16 |     ],
 17 |     "flowers": [
 18 |       "orchid",
 19 |       "poppy",
 20 |       "rose",
 21 |       "sunflower",
 22 |       "tulip"
 23 |     ],
 24 |     "food_containers": [
 25 |       "bottle",
 26 |       "bowl",
 27 |       "can",
 28 |       "cup",
 29 |       "plate"
 30 |     ],
 31 |     "fruit_and_vegetables": [
 32 |       "apple",
 33 |       "orange",
 34 |       "pear",
 35 |       "sweet_pepper"
 36 |     ],
 37 |     "household_furniture": [
 38 |       "bed",
 39 |       "chair",
 40 |       "couch",
 41 |       "table",
 42 |       "wardrobe"
 43 |     ],
 44 |     "insects": [
 45 |       "bee",
 46 |       "beetle",
 47 |       "butterfly",
 48 |       "caterpillar",
 49 |       "cockroach"
 50 |     ],
 51 |     "large_carnivores": [
 52 |       "leopard",
 53 |       "lion",
 54 |       "tiger",
 55 |       "wolf"
 56 |     ],
 57 |     "large_omnivores_and_herbivores": [
 58 |       "bear",
 59 |       "camel",
 60 |       "cattle",
 61 |       "chimpanzee",
 62 |       "elephant",
 63 |       "kangaroo"
 64 |     ],
 65 |     "medium_sized_mammals": [
 66 |       "fox",
 67 |       "porcupine",
 68 |       "possum",
 69 |       "raccoon",
 70 |       "skunk"
 71 |     ],
 72 |     "people": [
 73 |       "baby",
 74 |       "boy",
 75 |       "girl",
 76 |       "man",
 77 |       "woman"
 78 |     ],
 79 |     "reptiles": [
 80 |       "crocodile",
 81 |       "dinosaur",
 82 |       "lizard",
 83 |       "snake",
 84 |       "turtle"
 85 |     ],
 86 |     "small_mammals": [
 87 |       "hamster",
 88 |       "mouse",
 89 |       "rabbit",
 90 |       "shrew",
 91 |       "squirrel"
 92 |     ],
 93 |     "trees": [
 94 |       "maple_tree",
 95 |       "oak_tree",
 96 |       "palm_tree",
 97 |       "pine_tree",
 98 |       "willow_tree"
 99 |     ],
100 |     "vehicles": [
101 |       "bicycle",
102 |       "bus",
103 |       "motorcycle",
104 |       "pickup_truck",
105 |       "train",
106 |       "streetcar",
107 |       "tank",
108 |       "tractor"
109 |     ]
110 |   },
111 |   "other_sub_classes": [
112 |     "mushroom",
113 |     "clock",
114 |     "keyboard",
115 |     "lamp",
116 |     "telephone",
117 |     "television",
118 |     "bridge",
119 |     "castle",
120 |     "house",
121 |     "road",
122 |     "skyscraper",
123 |     "cloud",
124 |     "forest",
125 |     "mountain",
126 |     "plain",
127 |     "sea",
128 |     "crab",
129 |     "lobster",
130 |     "snail",
131 |     "spider",
132 |     "worm",
133 |     "lawn_mower",
134 |     "rocket"
135 |   ]
136 | }


--------------------------------------------------------------------------------
/iirc/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/iirc/tests/__init__.py


--------------------------------------------------------------------------------
/iirc/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | def pytest_addoption(parser):
 2 |     parser.addoption("--imagenet_root", action="store", default="./data")
 3 | 
 4 | 
 5 | def pytest_generate_tests(metafunc):
 6 |     """ This is called for every test. Only get/set command line arguments
 7 |     if the argument is specified in the list of test "fixturenames".
 8 |     """
 9 |     option_value = metafunc.config.option.imagenet_root
10 |     if 'imagenet_root' in metafunc.fixturenames and option_value is not None:
11 |         metafunc.parametrize("imagenet_root", [option_value])
12 | 


--------------------------------------------------------------------------------
/iirc/tests/test_get_dataset.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import numpy as np
 3 | from PIL import Image
 4 | from iirc.datasets_loader import _get_dataset
 5 | 
 6 | # Test that the output dataset have the specified shape (image/image_path, (label1,)) or
 7 | # (image/image_path, (label1, label2))
 8 | np.random.seed(100)
 9 | 
10 | 
11 | @pytest.mark.parametrize("dataset_name", ["iirc_cifar100", "iirc_imagenet_full"])
12 | def test_get_dataset(imagenet_root, dataset_name):
13 |     if dataset_name == "iirc_cifar100":
14 |         datasets, dataset_configuration = \
15 |             _get_dataset(dataset_name=dataset_name, dataset_root="./data")
16 |         assert "superclass_data_pct" in dataset_configuration.keys()
17 |         assert "subclass_data_pct" in dataset_configuration.keys()
18 |         assert "intask_valid_train_ratio" in dataset_configuration.keys()
19 |         assert "posttask_valid_train_ratio" in dataset_configuration.keys()
20 |         assert "using_image_path" in dataset_configuration.keys()
21 |     elif dataset_name == "iirc_imagenet_full":
22 |         datasets, dataset_configuration = \
23 |             _get_dataset(dataset_name=dataset_name, dataset_root=imagenet_root)
24 |         assert "intask_valid_train_ratio" in dataset_configuration.keys()
25 |         assert "posttask_valid_train_ratio" in dataset_configuration.keys()
26 |         assert "using_image_path" in dataset_configuration.keys()
27 | 
28 |     assert "train" in datasets.keys()
29 |     assert "intask_valid" in datasets.keys()
30 |     assert "posttask_valid" in datasets.keys()
31 |     assert "test" in datasets.keys()
32 |     for dataset in datasets.values():
33 |         sample_size = min(len(dataset), 100)
34 |         sample_idx = np.arange(len(dataset))
35 |         np.random.shuffle(sample_idx)
36 |         sample_idx = sample_idx[:sample_size]
37 |         for i in sample_idx:
38 |             sample_image, sample_labels = dataset[i]
39 |             assert len(sample_labels) == 1 or len(sample_labels) == 2
40 |             assert isinstance(sample_image, Image.Image) or isinstance(sample_image,
41 |                                                                        str)  # string in case of image path
42 | 


--------------------------------------------------------------------------------
/iirc/tests/test_load_iirc_dataset.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | from iirc.datasets_loader import _load_iirc_cifar100, _load_iirc_imagenet
  3 | import json
  4 | import os
  5 | 
  6 | # test data integrity
  7 | @pytest.mark.parametrize("intask_valid_train_ratio", [0, 0.15])
  8 | @pytest.mark.parametrize("posttask_valid_train_ratio", [0, 0.15])
  9 | @pytest.mark.parametrize("dataset_root", ["./data"])
 10 | @pytest.mark.parametrize("metadata_root", ["./iirc/metadata"])
 11 | def test_load_iirc_cifar100(dataset_root, metadata_root, intask_valid_train_ratio, posttask_valid_train_ratio):
 12 |     datasets = _load_iirc_cifar100(root=dataset_root, intask_valid_train_ratio=intask_valid_train_ratio,
 13 |                                    posttask_valid_train_ratio=posttask_valid_train_ratio)
 14 |     with open(os.path.join(metadata_root, "iirc_cifar100_hierarchy.json"), "r") as f:
 15 |         class_hierarchy = json.load(f)
 16 |     superclasses = list(class_hierarchy["super_classes"].keys())
 17 |     subclasses = [subclass for subclasses_list in list(class_hierarchy["super_classes"].values())
 18 |                   for subclass in subclasses_list]
 19 |     subclasses.extend(class_hierarchy["other_sub_classes"])
 20 | 
 21 |     n_subclasses = 100
 22 |     assert len(subclasses) == n_subclasses
 23 | 
 24 |     num_intask_valid_samples = int(intask_valid_train_ratio * 500) * n_subclasses
 25 |     num_posttask_valid_samples = int(posttask_valid_train_ratio * 500) * n_subclasses
 26 |     assert len(datasets["train"]) == (50000 - num_intask_valid_samples - num_posttask_valid_samples)
 27 |     assert len(datasets["test"]) == 10000
 28 |     assert len(datasets["intask_valid"]) == num_intask_valid_samples
 29 |     assert len(datasets["posttask_valid"]) == num_posttask_valid_samples
 30 | 
 31 |     for superclass in superclasses:
 32 |         num_intask_valid_samples = int(intask_valid_train_ratio * 500) * len(
 33 |             class_hierarchy["super_classes"][superclass])
 34 |         num_posttask_valid_samples = int(posttask_valid_train_ratio * 500) * len(
 35 |             class_hierarchy["super_classes"][superclass])
 36 |         num_train_samples = 500 * len(class_hierarchy["super_classes"][superclass]) - num_intask_valid_samples - \
 37 |                             num_posttask_valid_samples
 38 |         num_test_samples = 100 * len(class_hierarchy["super_classes"][superclass])
 39 |         assert len([0 for sample in datasets["train"] if superclass in sample[1]]) == num_train_samples
 40 |         assert len([0 for sample in datasets["test"] if superclass in sample[1]]) == num_test_samples
 41 |         assert len([0 for sample in datasets["intask_valid"] if superclass in sample[1]]) == \
 42 |                num_intask_valid_samples
 43 |         assert len([0 for sample in datasets["posttask_valid"] if superclass in sample[1]]) == \
 44 |                num_posttask_valid_samples
 45 | 
 46 |     for subclass in subclasses:
 47 |         num_intask_valid_samples = int(intask_valid_train_ratio * 500)
 48 |         num_posttask_valid_samples = int(posttask_valid_train_ratio * 500)
 49 |         num_train_samples = 500 - num_intask_valid_samples - num_posttask_valid_samples
 50 |         num_test_samples = 100
 51 |         assert len([0 for sample in datasets['train'] if subclass in sample[1]]) == num_train_samples
 52 |         assert len([0 for sample in datasets["test"] if subclass in sample[1]]) == num_test_samples
 53 |         assert len([0 for sample in datasets["intask_valid"] if subclass in sample[1]]) == \
 54 |                num_intask_valid_samples
 55 |         assert len([0 for sample in datasets["posttask_valid"] if subclass in sample[1]]) == \
 56 |                num_posttask_valid_samples
 57 | 
 58 | 
 59 | @pytest.mark.parametrize("intask_valid_train_ratio", [0, 0.1])
 60 | @pytest.mark.parametrize("posttask_valid_train_ratio", [0, 0.1])
 61 | @pytest.mark.parametrize("metadata_root", ["./iirc/metadata"])
 62 | def test_load_iirc_imagenet(imagenet_root, metadata_root, intask_valid_train_ratio, posttask_valid_train_ratio):
 63 |     datasets = _load_iirc_imagenet(root=imagenet_root, intask_valid_train_ratio=intask_valid_train_ratio,
 64 |                                    posttask_valid_train_ratio=posttask_valid_train_ratio)
 65 |     with open(os.path.join(metadata_root, "iirc_imagenet_hierarchy_wnids.json"), "r") as f:
 66 |         class_hierarchy = json.load(f)
 67 |     superclasses = list(class_hierarchy["super_classes"].keys())
 68 |     subclasses = [subclass for subclasses_list in list(class_hierarchy["super_classes"].values())
 69 |                   for subclass in subclasses_list]
 70 |     subclasses.extend(class_hierarchy["other_sub_classes"])
 71 | 
 72 |     n_subclasses = 998
 73 |     assert len(subclasses) == n_subclasses
 74 | 
 75 |     num_intask_valid_samples_max = int(intask_valid_train_ratio * 1300) * n_subclasses
 76 |     num_intask_valid_samples_min = int(intask_valid_train_ratio * 1250) * n_subclasses
 77 |     num_posttask_valid_samples_max = int(posttask_valid_train_ratio * 1300) * n_subclasses
 78 |     num_posttask_valid_samples_min = int(posttask_valid_train_ratio * 1250) * n_subclasses
 79 |     assert (1250*n_subclasses - num_intask_valid_samples_min - num_posttask_valid_samples_min) \
 80 |            <= len(datasets["train"]) <= \
 81 |            (1300*n_subclasses - num_intask_valid_samples_max - num_posttask_valid_samples_max)
 82 |     assert len(datasets["test"]) == n_subclasses * 50
 83 |     assert num_intask_valid_samples_min <= len(datasets["intask_valid"]) <= num_intask_valid_samples_max
 84 |     assert num_posttask_valid_samples_min <= len(datasets["posttask_valid"]) <= num_posttask_valid_samples_max
 85 | 
 86 |     for superclass in superclasses:
 87 |         num_intask_valid_samples_min = int(intask_valid_train_ratio * 700) * len(
 88 |             class_hierarchy["super_classes"][superclass])
 89 |         num_posttask_valid_samples_min = int(posttask_valid_train_ratio * 700) * len(
 90 |             class_hierarchy["super_classes"][superclass])
 91 |         num_train_samples_min = 700 * len(class_hierarchy["super_classes"][superclass]) - \
 92 |                                 num_intask_valid_samples_min - num_posttask_valid_samples_min
 93 |         num_test_samples_min = 50 * len(class_hierarchy["super_classes"][superclass])
 94 |         assert len([0 for sample in datasets["train"] if superclass in sample[1]]) >= num_train_samples_min
 95 |         assert len([0 for sample in datasets["test"] if superclass in sample[1]]) >= num_test_samples_min
 96 |         assert len([0 for sample in datasets["intask_valid"] if superclass in sample[1]]) >= \
 97 |                num_intask_valid_samples_min
 98 |         assert len([0 for sample in datasets["posttask_valid"] if superclass in sample[1]]) >= \
 99 |                num_posttask_valid_samples_min
100 | 
101 |     for subclass in subclasses:
102 |         num_intask_valid_samples_min = int(intask_valid_train_ratio * 700)
103 |         num_posttask_valid_samples_min = int(posttask_valid_train_ratio * 700)
104 |         num_train_samples_min = 700 - num_intask_valid_samples_min - num_posttask_valid_samples_min
105 |         num_test_samples_min = 50
106 |         assert len([0 for sample in datasets['train'] if subclass in sample[1]]) >= num_train_samples_min
107 |         assert len([0 for sample in datasets["test"] if subclass in sample[1]]) >= num_test_samples_min
108 |         assert len([0 for sample in datasets["intask_valid"] if subclass in sample[1]]) >= \
109 |                num_intask_valid_samples_min
110 |         assert len([0 for sample in datasets["posttask_valid"] if subclass in sample[1]]) >= \
111 |                num_posttask_valid_samples_min
112 | 


--------------------------------------------------------------------------------
/iirc/tests/test_torch_dataset_classes.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | import random
  3 | from iirc.lifelong_dataset.torch_dataset import Dataset
  4 | from iirc.definitions import IIRC_SETUP, NO_LABEL_PLACEHOLDER, CIL_SETUP
  5 | 
  6 | # Create an example dataset
  7 | # 'a' is superclass of 'aa' and 'ab', etc
  8 | random.seed(100)
  9 | superclass_subclass = {'a': ['aa', 'ab'], 'b': ['ba', 'bb', 'bc'], 'c': ['ca', 'cb']}
 10 | subclasses_superclasses = {subclass: superclass for superclass, subclasses in superclass_subclass.items()
 11 |                            for subclass in subclasses}
 12 | other_subclasses = ['_d', '_e', '_f']
 13 | dataset = []
 14 | n_samples_per_subclass = 100
 15 | for subclass in list(subclasses_superclasses.keys()) + other_subclasses:
 16 |     if subclass in subclasses_superclasses.keys():
 17 |         superclass = subclasses_superclasses[subclass]
 18 |         data_subset = [(None, (superclass, subclass)) for _ in range(n_samples_per_subclass)]
 19 |     else:
 20 |         data_subset = [(None, (subclass,)) for _ in range(n_samples_per_subclass)]
 21 |     dataset.extend(data_subset)
 22 | random.shuffle(dataset)
 23 | 
 24 | superclass_data_pct = 0.4
 25 | subclass_data_pct = 0.8
 26 | 
 27 | tasks = [['a', 'b'], ['c', 'aa', '_d'], ['ab', 'ba', '_f']]
 28 | 
 29 | 
 30 | @pytest.mark.parametrize("expected_task_data_size", [[200, 260, 260]])
 31 | def test_Dataset_divide_data_across_tasks_IIRC_Train(expected_task_data_size):
 32 |     lifelong_dataset = Dataset(dataset, tasks, essential_transforms_fn=lambda x: x, setup=IIRC_SETUP, test_mode=False,
 33 |                                superclass_data_pct=superclass_data_pct, subclass_data_pct=subclass_data_pct)
 34 |     for task_id in range(len(tasks)):
 35 |         assert len(lifelong_dataset.task_id_to_data_idx[task_id]) == expected_task_data_size[task_id]
 36 | 
 37 | 
 38 | @pytest.mark.parametrize("expected_task_data_size", [[500, 400, 300]])
 39 | def test_Dataset_divide_data_across_tasks_IIRC_Test(expected_task_data_size):
 40 |     lifelong_dataset = Dataset(dataset, tasks, test_mode=True, setup=IIRC_SETUP, essential_transforms_fn=lambda x: x)
 41 |     for task_id in range(len(tasks)):
 42 |         assert len(lifelong_dataset.task_id_to_data_idx[task_id]) == expected_task_data_size[task_id]
 43 | 
 44 | 
 45 | @pytest.mark.parametrize("expected_task_data_size", [[500, 400, 300]])
 46 | def test_Dataset_divide_data_across_tasks_CIL(expected_task_data_size):
 47 |     lifelong_dataset = Dataset(dataset, tasks, setup=CIL_SETUP, essential_transforms_fn=lambda x: x)
 48 |     for task_id in range(len(tasks)):
 49 |         assert len(lifelong_dataset.task_id_to_data_idx[task_id]) == expected_task_data_size[task_id]
 50 | 
 51 | 
 52 | @pytest.mark.parametrize("expected_task_data_size", [[200, 260, 260]])
 53 | def test_choose_task(expected_task_data_size):
 54 |     lifelong_dataset = Dataset(dataset, tasks, essential_transforms_fn=lambda x: x, setup=IIRC_SETUP,
 55 |                                superclass_data_pct=superclass_data_pct, subclass_data_pct=subclass_data_pct)
 56 | 
 57 |     for task_id in range(len(tasks)):
 58 |         lifelong_dataset.choose_task(task_id)
 59 |         assert len(lifelong_dataset) == expected_task_data_size[task_id]
 60 |         assert set(lifelong_dataset.seen_classes) == set([cla for task in tasks[:task_id + 1] for cla in task])
 61 | 
 62 |         # test that the no labels from outside the current task are given (when not using complete information mode in
 63 |         # the case of IIRC)
 64 |         assert lifelong_dataset.cur_task == tasks[task_id]
 65 |         for i in range(len(lifelong_dataset)):
 66 |             image, label_1, label_2 = lifelong_dataset[i]
 67 |             # Check that only one label is given when not using the complete information mode (in IIRC)
 68 |             assert label_2 == NO_LABEL_PLACEHOLDER
 69 |             assert label_1 in tasks[task_id]
 70 | 
 71 | 
 72 | @pytest.mark.parametrize("expected_task_data_size, expected_data_up_to_size",
 73 |                          [([200, 260, 260], [200, 440, 660])])
 74 | def test_complete_information_mode(expected_task_data_size, expected_data_up_to_size):
 75 |     lifelong_dataset = Dataset(dataset, tasks, essential_transforms_fn=lambda x: x, setup=IIRC_SETUP,
 76 |                                superclass_data_pct=superclass_data_pct,
 77 |                                subclass_data_pct=subclass_data_pct)
 78 |     lifelong_dataset.enable_complete_information_mode()
 79 | 
 80 |     for task_id in range(len(tasks)):
 81 |         lifelong_dataset.choose_task(task_id)
 82 |         assert len(lifelong_dataset) == expected_task_data_size[task_id]
 83 |         assert set(lifelong_dataset.seen_classes) == set([cla for task in tasks[:task_id + 1] for cla in task])
 84 | 
 85 |         # test that all labels that have been observed so far are given
 86 |         assert lifelong_dataset.cur_task == tasks[task_id]
 87 |         for i in range(len(lifelong_dataset)):
 88 |             image, label_1, label_2 = lifelong_dataset[i]
 89 |             assert label_1 == NO_LABEL_PLACEHOLDER or label_1 in lifelong_dataset.seen_classes
 90 |             assert label_2 == NO_LABEL_PLACEHOLDER or label_2 in lifelong_dataset.seen_classes
 91 |             if label_1 in subclasses_superclasses.keys():
 92 |                 assert label_2 == subclasses_superclasses[label_1]
 93 |             elif label_2 in subclasses_superclasses.keys():
 94 |                 assert label_1 == subclasses_superclasses[label_2]
 95 | 
 96 |         lifelong_dataset.load_tasks_up_to(task_id)
 97 |         assert len(lifelong_dataset) == expected_data_up_to_size[task_id]
 98 |         assert set(lifelong_dataset.cur_task) == set([cla for task in tasks[:task_id + 1] for cla in task])
 99 |         for i in range(len(lifelong_dataset)):
100 |             image, label_1, label_2 = lifelong_dataset[i]
101 |             assert label_1 == NO_LABEL_PLACEHOLDER or label_1 in lifelong_dataset.seen_classes
102 |             assert label_2 == NO_LABEL_PLACEHOLDER or label_2 in lifelong_dataset.seen_classes
103 |             if label_1 in subclasses_superclasses.keys():
104 |                 assert label_2 == subclasses_superclasses[label_1]
105 |             elif label_2 in subclasses_superclasses.keys():
106 |                 assert label_1 == subclasses_superclasses[label_2]
107 | 
108 | 
109 | @pytest.mark.parametrize("class1, class2, class1_size0, class1_size01, class2_size1, class2_size01",
110 |                          [("a", "aa", 80, 140, 80, 100)])
111 | def test_get_shuffled_image_indices(class1, class2, class1_size0, class1_size01, class2_size1, class2_size01):
112 |     lifelong_dataset = Dataset(dataset, tasks, essential_transforms_fn=lambda x: x, setup=IIRC_SETUP,
113 |                                superclass_data_pct=superclass_data_pct, subclass_data_pct=subclass_data_pct)
114 |     assert class1 in tasks[0]
115 |     assert class2 in tasks[1]
116 | 
117 |     lifelong_dataset.choose_task(0)
118 |     class1_indices = lifelong_dataset.get_image_indices_by_cla(class1)
119 |     assert len(class1_indices) == class1_size0
120 |     for idx in class1_indices:
121 |         image, label_1, label_2 = lifelong_dataset[idx]
122 |         assert label_1 == class1
123 |         assert label_2 == NO_LABEL_PLACEHOLDER
124 | 
125 |     lifelong_dataset.choose_task(1)
126 |     class2_indices = lifelong_dataset.get_image_indices_by_cla(class2)
127 |     assert len(class2_indices) == class2_size1
128 |     for idx in class2_indices:
129 |         image, label_1, label_2 = lifelong_dataset[idx]
130 |         assert label_1 == class2
131 |         assert label_2 == NO_LABEL_PLACEHOLDER
132 | 
133 |     lifelong_dataset.enable_complete_information_mode()
134 |     lifelong_dataset.load_tasks_up_to(1)
135 |     class1_indices = lifelong_dataset.get_image_indices_by_cla(class1)
136 |     class2_indices = lifelong_dataset.get_image_indices_by_cla(class2)
137 |     assert len(class1_indices) == class1_size01
138 |     assert len(class2_indices) == class2_size01
139 |     for idx in class1_indices:
140 |         image, label_1, label_2 = lifelong_dataset[idx]
141 |         if label_1 == class1:
142 |             assert label_2 == class2 or label_2 == NO_LABEL_PLACEHOLDER
143 |         elif label_2 == class1:
144 |             assert label_1 == class2 or label_1 == NO_LABEL_PLACEHOLDER
145 |         else:
146 |             raise ValueError(f"{class1} is not there")
147 |     for idx in class2_indices:
148 |         image, label_1, label_2 = lifelong_dataset[idx]
149 |         if label_1 == class2:
150 |             assert label_2 == class1
151 |         elif label_2 == class2:
152 |             assert label_1 == class1
153 |         else:
154 |             raise ValueError(f"{class2} is not there")
155 | 


--------------------------------------------------------------------------------
/iirc/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/iirc/utils/__init__.py


--------------------------------------------------------------------------------
/iirc/utils/download_cifar.py:
--------------------------------------------------------------------------------
 1 | # from torchvision import datasets
 2 | import argparse
 3 | import requests
 4 | import os
 5 | import hashlib
 6 | import warnings
 7 | import tarfile
 8 | import logging
 9 | 
10 | def _download_cifar100(root="data"):
11 |     url = 'https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz'
12 |     os.makedirs(root, exist_ok=True)
13 |     target_path = os.path.join(root, 'cifar-100-python.tar.gz')
14 |     if os.path.exists(target_path):
15 |         warnings.warn(f"{target_path} already exists, the dataset won't be download")
16 |         return None
17 |     print("downloading CIFAR 100")
18 |     logging.info("downloading dataset")
19 |     response = requests.get(url, stream=True)
20 |     assert response.status_code == 200
21 |     with open(target_path, 'wb') as f:
22 |         f_content = response.raw.read()
23 |         assert hashlib.md5(f_content).hexdigest() == 'eb9058c3a382ffc7106e4002c42a8d85'
24 |         f.write(f_content)
25 |     print("dataset downloaded")
26 |     logging.info("dataset downloaded")
27 |     return target_path
28 | 
29 | 
30 | def download_extract_cifar100(root="data"):
31 |     tar_file_path = _download_cifar100(root=root)
32 |     print("extracting CIFAR 100")
33 |     logging.info("extracting dataset")
34 |     if tar_file_path is not None:
35 |         with tarfile.open(tar_file_path, 'r') as tar:
36 |             tar.extractall(root)
37 |     print("dataset extracted")
38 |     logging.info("dataset extracted")
39 | 
40 | 
41 | if __name__ == '__main__':
42 |     parser = argparse.ArgumentParser()
43 | 
44 |     parser.add_argument('--dataset_path', type=str, default="./data")
45 |     args = parser.parse_args()
46 | 
47 |     logging.basicConfig(level=logging.INFO)
48 | 
49 |     download_extract_cifar100(args.dataset_path)


--------------------------------------------------------------------------------
/iirc/utils/prepare_imagenet.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | import subprocess
 3 | from scipy.io import loadmat
 4 | import time
 5 | import os
 6 | import logging
 7 | 
 8 | if __name__ == '__main__':
 9 |     parser = argparse.ArgumentParser()
10 |     parser.add_argument('--source_dir', type=str,
11 |                         help="The folder where the ILSVRC2012_devkit_t12.tar.gz, ILSVRC2012_img_train.tar and "
12 |                              "ILSVRC2012_img_val.tar exist")
13 |     parser.add_argument('--target_dir', type=str)
14 |     args = parser.parse_args()
15 | 
16 |     logging.basicConfig(level=logging.INFO)
17 | 
18 |     slurm_tmpdir = os.environ['SLURM_TMPDIR']
19 |     to_be_zipped_folder = os.path.join(slurm_tmpdir, "imagenet_prepared")
20 |     os.makedirs(os.path.join(to_be_zipped_folder), exist_ok=True)
21 | 
22 |     if os.path.exists(os.path.join(args.target_dir, "imagenet_prepared.tar")):
23 |         logging.info(f"imagenet_prepared.tar already exists")
24 |     else:
25 |         start_time = time.time()
26 |         assert os.path.exists(os.path.join(args.source_dir, "ILSVRC2012_devkit_t12.tar.gz"))
27 |         assert os.path.exists(os.path.join(args.source_dir, "ILSVRC2012_img_train.tar"))
28 |         assert os.path.exists(os.path.join(args.source_dir, "ILSVRC2012_img_val.tar"))
29 | 
30 |         logging.info(f"copying files")
31 |         subprocess.run(f"rsync --progress -av {os.path.join(args.source_dir, '*')} {slurm_tmpdir}", shell=True)
32 |         logging.info(f"Copying done")
33 | 
34 |         logging.info(f"unzipping ILSVRC2012_devkit_t12.tar.gz")
35 |         subprocess.run(f"tar -xf {os.path.join(slurm_tmpdir, 'ILSVRC2012_devkit_t12.tar.gz')} "
36 |                        f"-C {to_be_zipped_folder}", shell=True)
37 | 
38 |         meta = loadmat(os.path.join(to_be_zipped_folder, 'ILSVRC2012_devkit_t12', 'data', 'meta.mat'))
39 |         meta = meta["synsets"]
40 |         ilsvrc_id_2_wnid = {int(synset[0][0][0]): str(synset[0][1][0]) for synset in meta}
41 | 
42 |         val_ground_truth_file = os.path.join(to_be_zipped_folder, 'ILSVRC2012_devkit_t12', 'data',
43 |                                              'ILSVRC2012_validation_ground_truth.txt')
44 |         with open(val_ground_truth_file, "r") as f:
45 |             val_ground_truth = f.readlines()
46 |         val_ground_truth = [int(id.strip('\n')) for id in val_ground_truth]
47 |         ilsvrc_ids = list(set(val_ground_truth))
48 |         ilsvrc_id_2_wnid_keys = list(ilsvrc_id_2_wnid.keys())
49 |         for id in ilsvrc_id_2_wnid_keys:
50 |             if id not in ilsvrc_ids:
51 |                 del ilsvrc_id_2_wnid[id]
52 | 
53 |         os.makedirs(os.path.join(to_be_zipped_folder, "train"), exist_ok=True)
54 |         logging.info(f"unzipping ILSVRC2012_img_train.tar")
55 |         subprocess.run(f"tar -xf {os.path.join(slurm_tmpdir, 'ILSVRC2012_img_train.tar')} "
56 |                        f"-C {os.path.join(to_be_zipped_folder, 'train')}", shell=True)
57 |         for wnid in ilsvrc_id_2_wnid.values():
58 |             os.makedirs(os.path.join(to_be_zipped_folder, "train", wnid), exist_ok=True)
59 |             logging.info(f"unzipping {wnid}.tar")
60 |             subprocess.run(f"tar -xf {os.path.join(to_be_zipped_folder, 'train', wnid + '.tar')} "
61 |                            f"-C {os.path.join(to_be_zipped_folder, 'train', wnid)}", shell=True)
62 | 
63 |         os.makedirs(os.path.join(to_be_zipped_folder, "val"), exist_ok=True)
64 |         logging.info(f"unzipping ILSVRC2012_img_val.tar")
65 |         subprocess.run(f"tar -xf {os.path.join(slurm_tmpdir, 'ILSVRC2012_img_val.tar')} "
66 |                        f"-C {os.path.join(to_be_zipped_folder, 'val')}", shell=True)
67 |         val_files = [os.path.join(to_be_zipped_folder, "val", f"ILSVRC2012_val_{i:08d}.JPEG") for i in range(1, 50001)]
68 |         for id, wnid in ilsvrc_id_2_wnid.items():
69 |             logging.info(f"Separating the validation samples for class {wnid}")
70 |             os.makedirs(os.path.join(to_be_zipped_folder, "val", wnid), exist_ok=True)
71 |             command = f"mv -t {os.path.join(to_be_zipped_folder, 'val', wnid)}"
72 |             count = 0
73 |             for i in range(50000):
74 |                 if val_ground_truth[i] == id:
75 |                     command += f" {val_files[i]}"
76 |                     count += 1
77 |             assert count == 50
78 |             subprocess.run(command, shell=True)
79 | 
80 |         logging.info(f"removing the training per-class tar files")
81 |         subprocess.run(f"rm {os.path.join(to_be_zipped_folder, 'train', '*.tar')}", shell=True)
82 | 
83 |         logging.info(f"archiving and compressing imagenet_prepared.tar.gz")
84 |         subprocess.run(f"tar -zcf {os.path.join(slurm_tmpdir, 'imagenet_prepared.tar')} -C {slurm_tmpdir} "
85 |                        f"imagenet_prepared", shell=True)
86 | 
87 |         logging.info(f"putting imagenet_prepared.tar in {args.target_dir}")
88 |         subprocess.run(f"rsync --progress {os.path.join(slurm_tmpdir, 'imagenet_prepared.tar')} "
89 |                        f"{args.target_dir}", shell=True)
90 | 


--------------------------------------------------------------------------------
/iirc/utils/utils.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | 
 4 | def print_msg(msg):
 5 |     print(msg)
 6 |     logging.info(msg)
 7 |     return
 8 | 
 9 | 
10 | def unpickle(file):
11 |     import pickle
12 |     with open(file, 'rb') as fo:
13 |         dict = pickle.load(fo, encoding='bytes')
14 |     return dict


--------------------------------------------------------------------------------
/index.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/lifelong_methods/README.md:
--------------------------------------------------------------------------------
 1 | # Lifelong Learning Methods Guide
 2 | The package documentation is [here](https://iirc.readthedocs.io/en/latest/lifelong_methods.html)
 3 | 
 4 | The lifelong learning methods in this package follow the following procedures
 5 | 
 6 | ```
 7 | example_model = lifelong_methods.methods.example.Model(args)  # replace example with whatever module is there
 8 | 
 9 | for task in tasks:
10 |     task_data <- load here the task data
11 |     
12 |     # This method initializes anything that needs to be inizialized at the beginning of each task
13 |     example_model.prepare_model_for_new_task(task_data, **kwargs) 
14 | 
15 |     for epoch in epochs:
16 |         # Training
17 |         for minibatch in task_data:
18 |             # This is where the training happens
19 |             predictions, loss = example_model.observe(minibatch)
20 | 
21 |         # This is where anything that needs to be done after each epoch should be done, if any
22 |         example_model.consolidate_epoch_knowledge(**kwargs) 
23 |     
24 |     # This is where anything that needs to be done after the task is done takes place
25 |     example_model.consolidate_task_knowledge(**kwargs)
26 | 
27 |     # Inference
28 |     # This is where the inference happens
29 |     predictions = example_model(inference_data_batch)
30 | ```
31 | 
32 | This is the typical order of how things flow in a lifelong learning scenario, and how does this package handles 
33 | that. This order makes it easy to implement new methods with shared base, so that they can run using the same code and 
34 | experimenting can be fast
35 | 
36 | When defining a new lifelong learning model, the first step is to create a model that inherits from 
37 | *lifelong_methods.methods.base_method.BaseMethod*, then the following abstract methods need to be defined (see the methods 
38 | docs for more details), private methods here are run from inside their similar but public methods so that shared stuff 
39 | between the different methods doesn't need to be reimplemented (like resetting the scheduler after each task, etc), 
40 | see the docs to know what is already implemented in the public methods so that you don't reimplement them:
41 | *  *_prepare_model_for_new_task*: This private method is run from inside the *prepare_model_for_new_task* in the 
42 | *BaseMethod*, 
43 | *  *_consolidate_epoch_knowledge*: This private method is run from inside the *consolidate_epoch_knowledge* in the 
44 | *BaseMethod*   
45 | *  *observe*
46 | * *forward*
47 | * *consolidate_task_knowledge*
48 | 


--------------------------------------------------------------------------------
/lifelong_methods/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/lifelong_methods/__init__.py


--------------------------------------------------------------------------------
/lifelong_methods/buffer/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/lifelong_methods/buffer/__init__.py


--------------------------------------------------------------------------------
/lifelong_methods/methods/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/lifelong_methods/methods/__init__.py


--------------------------------------------------------------------------------
/lifelong_methods/methods/agem.py:
--------------------------------------------------------------------------------
  1 | import torch.nn as nn
  2 | import torch.distributed as dist
  3 | import torch
  4 | from torch.utils.data import DataLoader
  5 | import numpy as np
  6 | from PIL import Image
  7 | import warnings
  8 | from typing import Optional, Union, List, Dict, Callable, Tuple
  9 | 
 10 | from iirc.lifelong_dataset.torch_dataset import Dataset
 11 | from iirc.definitions import NO_LABEL_PLACEHOLDER
 12 | from lifelong_methods.buffer.buffer import BufferBase
 13 | from lifelong_methods.methods.base_method import BaseMethod
 14 | from lifelong_methods.utils import transform_labels_names_to_vector, get_gradient, update_gradient
 15 | 
 16 | 
 17 | class Model(BaseMethod):
 18 |     """
 19 |     An  implementation of A-GEM from
 20 |         Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny.
 21 |         Efficient Lifelong Learning with A-GEM.
 22 |         ICLR, 2019.
 23 |     """
 24 | 
 25 |     def __init__(self, n_cla_per_tsk: Union[np.ndarray, List[int]], class_names_to_idx: Dict[str, int], config: Dict):
 26 |         super(Model, self).__init__(n_cla_per_tsk, class_names_to_idx, config)
 27 |         # setup losses
 28 |         self.bce = nn.BCEWithLogitsLoss(reduction="mean")
 29 |         self.device = config["device"]
 30 |         self.memory_batch_size = config["batch_size"]
 31 |         self.memory_loader = None
 32 | 
 33 |         self.method_variables.extend(["memory_batch_size"])
 34 | 
 35 |     def _load_method_state_dict(self, state_dicts: Dict[str, Dict]) -> None:
 36 |         """
 37 |         This is where anything model specific needs to be done before the state_dicts are loaded
 38 | 
 39 |         Args:
 40 |             state_dicts (Dict[str, Dict]): a dictionary with the state dictionaries of this method, the optimizer, the
 41 |             scheduler, and the values of the variables whose names are inside the self.method_variables
 42 |         """
 43 |         pass
 44 | 
 45 |     def _prepare_model_for_new_task(self, buffer: Optional[BufferBase] = None, dist_args: Optional[Dict] = None,
 46 |                                     num_workers: int = 2, **kwargs) -> None:
 47 |         """
 48 |         A method specific function that takes place before the starting epoch of each new task (runs from the
 49 |         prepare_model_for_task function).
 50 |         It checks if the buffer is not empty, and creates a dataloader for it, which is used later in getting the
 51 |             gradients of the loss on the buffer samples.
 52 | 
 53 |         Args:
 54 |             buffer (Optional[BufferBase]): The replay buffer (default: None)
 55 |             dist_args (Optional[Dict]): a dictionary of the distributed processing values in case of multiple gpu (ex:
 56 |             rank of the device) (default: None)
 57 |             num_workers (int): The number of workers to use with the dataloader of the replay buffer (default: 2)
 58 |         """
 59 |         if dist_args is not None:
 60 |             raise NotImplementedError
 61 |         if buffer is not None and len(buffer) > 0:
 62 |             self.memory_loader = DataLoader(buffer, batch_size=self.memory_batch_size, num_workers=num_workers,
 63 |                                             shuffle=True)
 64 | 
 65 |     def _get_buffer_gradient(self) -> torch.Tensor:
 66 |         device = self.device
 67 |         buffer_gradient = None  # type: Optional[torch.Tensor]
 68 |         if self.memory_loader is not None:
 69 |             buffer_batch = next(iter(self.memory_loader))
 70 |             samples = buffer_batch[0].to(device)
 71 |             labels_names = list(zip(buffer_batch[1], buffer_batch[2]))
 72 |             labels = transform_labels_names_to_vector(
 73 |                 labels_names, len(self.seen_classes), self.class_names_to_idx
 74 |             )
 75 |             labels = labels.to(device)
 76 |             offset_1, offset_2 = self._compute_offsets(self.cur_task_id)
 77 |             output, _ = self.forward_net(samples)
 78 |             output = output[:, :offset_1]
 79 |             labels = labels[:, :offset_1]
 80 |             loss = self.bce(output / self.temperature, labels)
 81 |             self.opt.zero_grad()
 82 |             loss.backward()
 83 |             buffer_gradient = get_gradient(self.net)
 84 |         return buffer_gradient
 85 | 
 86 |     def observe(self, x: torch.Tensor, y: torch.Tensor, in_buffer: Optional[torch.Tensor] = None,
 87 |                 train: bool = True) -> Tuple[torch.Tensor, float]:
 88 |         """
 89 |         The method used for training and validation, returns a tensor of model predictions and the loss
 90 |         This function needs to be defined in the inheriting method class
 91 | 
 92 |         Args:
 93 |             x (torch.Tensor): The batch of images
 94 |             y (torch.Tensor): A 2-d batch indicator tensor of shape (number of samples x number of classes)
 95 |             in_buffer (Optional[torch.Tensor]): A 1-d boolean tensor which indicates which sample is from the buffer.
 96 |             train (bool): Whether this is training or validation/test
 97 | 
 98 |         Returns:
 99 |             Tuple[torch.Tensor, float]:
100 |             predictions (torch.Tensor) : a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
101 |             loss (float): the value of the loss
102 |         """
103 |         if in_buffer is not None:
104 |             assert torch.sum(in_buffer).item() == 0
105 |         num_seen_classes = len(self.seen_classes)
106 |         offset_1, offset_2 = self._compute_offsets(self.cur_task_id)
107 |         target = y
108 |         assert target.shape[1] == offset_2
109 |         output, _ = self.forward_net(x)
110 |         output = output[:, :offset_2]
111 | 
112 |         buffer_gradient = None  # type: Optional[torch.Tensor]
113 |         if train and self.memory_loader is not None:
114 |             buffer_gradient = self._get_buffer_gradient()
115 | 
116 |         loss = self.bce(output[:, offset_1:] / self.temperature, target[:, offset_1:])
117 | 
118 |         # TODO weigh the buffer loss by the self.memory_strength before getting the loss mean (use in_buffer)
119 |         if train:
120 |             self.opt.zero_grad()
121 |             loss.backward()
122 |             if buffer_gradient is not None:
123 |                 cur_gradient = get_gradient(self.net)
124 |                 dotp = torch.dot(cur_gradient, buffer_gradient)
125 |                 if dotp < 0:
126 |                     # efficient gradient projection
127 |                     ref_mag = torch.dot(buffer_gradient, buffer_gradient)
128 |                     new_grad = cur_gradient - ((dotp / ref_mag) * buffer_gradient)
129 |                     update_gradient(self.net, new_grad)
130 |             self.opt.step()
131 | 
132 |         predictions = output > 0.0
133 |         return predictions, loss.item()
134 | 
135 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
136 |         """
137 |         The method used during inference, returns a tensor of model predictions
138 | 
139 |         Args:
140 |             x (torch.Tensor): The batch of images
141 | 
142 |         Returns:
143 |             torch.Tensor: a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
144 |         """
145 |         num_seen_classes = len(self.seen_classes)
146 |         output, _ = self.forward_net(x)
147 |         output = output[:, :num_seen_classes]
148 |         predictions = output > 0.0
149 |         return predictions
150 | 
151 |     def _consolidate_epoch_knowledge(self, **kwargs) -> None:
152 |         """
153 |         A method specific function that takes place after training on each epoch (runs from the
154 |         consolidate_epoch_knowledge function)
155 |         """
156 |         pass
157 | 
158 |     def consolidate_task_knowledge(self, **kwargs) -> None:
159 |         """Takes place after training on each task"""
160 |         pass
161 | 
162 | 
163 | class Buffer(BufferBase):
164 |     def __init__(self,
165 |                  config: Dict,
166 |                  buffer_dir: Optional[str] = None,
167 |                  map_size: int = 1e9,
168 |                  essential_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
169 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None):
170 |         super(Buffer, self).__init__(config, buffer_dir, map_size, essential_transforms_fn, augmentation_transforms_fn)
171 | 
172 |     def _reduce_exemplar_set(self, **kwargs) -> None:
173 |         """
174 |         remove extra exemplars from the buffer
175 |         """
176 |         for label in self.seen_classes:
177 |             if len(self.mem_class_x[label]) > self.n_mems_per_cla:
178 |                 n = len(self.mem_class_x[label]) - self.n_mems_per_cla
179 |                 self.remove_samples(label, n)
180 | 
181 |     def _construct_exemplar_set(self, task_data: Dataset, dist_args: Optional[Dict] = None, **kwargs) -> None:
182 |         """
183 |         update the buffer with the new task exemplars, chosen randomly for each class.
184 | 
185 |         Args:
186 |             new_task_data (Dataset): The new task data
187 |             dist_args (Optional[Dict]): a dictionary of the distributed processing values in case of multiple gpu (ex:
188 |             rank of the device) (default: None)
189 |         """
190 |         distributed = dist_args is not None
191 |         if distributed:
192 |             rank = dist_args['rank']
193 |         else:
194 |             rank = 0
195 |         new_class_labels = task_data.cur_task
196 | 
197 |         for class_label in new_class_labels:
198 |             num_images_to_add = min(self.n_mems_per_cla, self.max_mems_pool_size)
199 |             class_images_indices = task_data.get_image_indices_by_cla(class_label, num_images_to_add)
200 |             if distributed:
201 |                 device = torch.device(f"cuda:{dist_args['gpu']}")
202 |                 class_images_indices_to_broadcast = torch.from_numpy(class_images_indices).to(device)
203 |                 torch.distributed.broadcast(class_images_indices_to_broadcast, 0)
204 |                 class_images_indices = class_images_indices_to_broadcast.cpu().numpy()
205 | 
206 |             for image_index in class_images_indices:
207 |                 image, label1, label2 = task_data.get_item(image_index)
208 |                 if label2 != NO_LABEL_PLACEHOLDER:
209 |                     warnings.warn(f"Sample is being added to the buffer with labels {label1} and {label2}")
210 |                 self.add_sample(class_label, image, (label1, label2), rank=rank)
211 | 


--------------------------------------------------------------------------------
/lifelong_methods/methods/finetune.py:
--------------------------------------------------------------------------------
  1 | import torch.nn as nn
  2 | import torch.distributed as dist
  3 | import torch
  4 | import numpy as np
  5 | from PIL import Image
  6 | import warnings
  7 | from typing import Optional, Union, List, Dict, Callable, Tuple
  8 | 
  9 | from iirc.lifelong_dataset.torch_dataset import Dataset
 10 | from iirc.definitions import NO_LABEL_PLACEHOLDER
 11 | from lifelong_methods.buffer.buffer import BufferBase
 12 | from lifelong_methods.methods.base_method import BaseMethod
 13 | 
 14 | 
 15 | class Model(BaseMethod):
 16 |     """
 17 |     A finetuning (Experience Replay) baseline.
 18 |     """
 19 | 
 20 |     def __init__(self, n_cla_per_tsk: Union[np.ndarray, List[int]], class_names_to_idx: Dict[str, int], config: Dict):
 21 |         super(Model, self).__init__(n_cla_per_tsk, class_names_to_idx, config)
 22 | 
 23 |         # setup losses
 24 |         self.bce = nn.BCEWithLogitsLoss(reduction="mean")
 25 | 
 26 |     def _load_method_state_dict(self, state_dicts: Dict[str, Dict]) -> None:
 27 |         """
 28 |         This is where anything model specific needs to be done before the state_dicts are loaded
 29 | 
 30 |         Args:
 31 |             state_dicts (Dict[str, Dict]): a dictionary with the state dictionaries of this method, the optimizer, the
 32 |             scheduler, and the values of the variables whose names are inside the self.method_variables
 33 |         """
 34 |         pass
 35 | 
 36 |     def _prepare_model_for_new_task(self, **kwargs) -> None:
 37 |         """
 38 |         A method specific function that takes place before the starting epoch of each new task (runs from the
 39 |             prepare_model_for_task function)
 40 |         """
 41 |         pass
 42 | 
 43 |     def observe(self, x: torch.Tensor, y: torch.Tensor, in_buffer: Optional[torch.Tensor] = None,
 44 |                 train: bool = True) -> Tuple[torch.Tensor, float]:
 45 |         """
 46 |         The method used for training and validation, returns a tensor of model predictions and the loss
 47 |         This function needs to be defined in the inheriting method class
 48 | 
 49 |         Args:
 50 |             x (torch.Tensor): The batch of images
 51 |             y (torch.Tensor): A 2-d batch indicator tensor of shape (number of samples x number of classes)
 52 |             in_buffer (Optional[torch.Tensor]): A 1-d boolean tensor which indicates which sample is from the buffer.
 53 |             train (bool): Whether this is training or validation/test
 54 | 
 55 |         Returns:
 56 |             Tuple[torch.Tensor, float]:
 57 |             predictions (torch.Tensor) : a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
 58 |             loss (float): the value of the loss
 59 |         """
 60 |         num_seen_classes = len(self.seen_classes)
 61 |         offset_1, offset_2 = self._compute_offsets(self.cur_task_id)
 62 |         target = y
 63 |         assert target.shape[1] == offset_2
 64 |         output, _ = self.forward_net(x)
 65 |         output = output[:, :offset_2]
 66 |         loss = self.bce(output / self.temperature, target)
 67 | 
 68 |         # TODO weigh the buffer loss by the self.memory_strength before getting the loss mean (use in_buffer)
 69 |         if train:
 70 |             self.opt.zero_grad()
 71 |             loss.backward()
 72 |             self.opt.step()
 73 | 
 74 |         predictions = output > 0.0
 75 |         return predictions, loss.item()
 76 | 
 77 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 78 |         """
 79 |         The method used during inference, returns a tensor of model predictions
 80 | 
 81 |         Args:
 82 |             x (torch.Tensor): The batch of images
 83 | 
 84 |         Returns:
 85 |             torch.Tensor: a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
 86 |         """
 87 |         num_seen_classes = len(self.seen_classes)
 88 |         output, _ = self.forward_net(x)
 89 |         output = output[:, :num_seen_classes]
 90 |         predictions = output > 0.0
 91 |         return predictions
 92 | 
 93 |     def _consolidate_epoch_knowledge(self, **kwargs) -> None:
 94 |         """
 95 |         A method specific function that takes place after training on each epoch (runs from the
 96 |         consolidate_epoch_knowledge function)
 97 |         """
 98 |         pass
 99 | 
100 |     def consolidate_task_knowledge(self, **kwargs) -> None:
101 |         """Takes place after training on each task"""
102 |         pass
103 | 
104 | 
105 | class Buffer(BufferBase):
106 |     def __init__(self,
107 |                  config: Dict,
108 |                  buffer_dir: Optional[str] = None,
109 |                  map_size: int = 1e9,
110 |                  essential_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
111 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None):
112 |         super(Buffer, self).__init__(config, buffer_dir, map_size, essential_transforms_fn, augmentation_transforms_fn)
113 | 
114 |     def _reduce_exemplar_set(self, **kwargs) -> None:
115 |         """remove extra exemplars from the buffer"""
116 |         for label in self.seen_classes:
117 |             if len(self.mem_class_x[label]) > self.n_mems_per_cla:
118 |                 n = len(self.mem_class_x[label]) - self.n_mems_per_cla
119 |                 self.remove_samples(label, n)
120 | 
121 |     def _construct_exemplar_set(self, task_data: Dataset, dist_args: Optional[Dict] = None, **kwargs) -> None:
122 |         """
123 |         update the buffer with the new task exemplars, chosen randomly for each class.
124 | 
125 |         Args:
126 |             new_task_data (Dataset): The new task data
127 |             dist_args (Optional[Dict]): a dictionary of the distributed processing values in case of multiple gpu (ex:
128 |             rank of the device) (default: None)
129 |         """
130 |         distributed = dist_args is not None
131 |         if distributed:
132 |             rank = dist_args['rank']
133 |         else:
134 |             rank = 0
135 |         new_class_labels = task_data.cur_task
136 | 
137 |         for class_label in new_class_labels:
138 |             num_images_to_add = min(self.n_mems_per_cla, self.max_mems_pool_size)
139 |             class_images_indices = task_data.get_image_indices_by_cla(class_label, num_images_to_add)
140 |             if distributed:
141 |                 device = torch.device(f"cuda:{dist_args['gpu']}")
142 |                 class_images_indices_to_broadcast = torch.from_numpy(class_images_indices).to(device)
143 |                 torch.distributed.broadcast(class_images_indices_to_broadcast, 0)
144 |                 class_images_indices = class_images_indices_to_broadcast.cpu().numpy()
145 | 
146 |             for image_index in class_images_indices:
147 |                 image, label1, label2 = task_data.get_item(image_index)
148 |                 if label2 != NO_LABEL_PLACEHOLDER:
149 |                     warnings.warn(f"Sample is being added to the buffer with labels {label1} and {label2}")
150 |                 self.add_sample(class_label, image, (label1, label2), rank=rank)
151 | 


--------------------------------------------------------------------------------
/lifelong_methods/methods/icarl_cnn.py:
--------------------------------------------------------------------------------
  1 | import torch.nn as nn
  2 | import torch.distributed as dist
  3 | import torch
  4 | import torch.nn.functional as F
  5 | from torch.utils.data import DataLoader
  6 | import numpy as np
  7 | from PIL import Image
  8 | import warnings
  9 | from typing import Optional, Union, List, Dict, Callable, Tuple
 10 | 
 11 | from iirc.lifelong_dataset.torch_dataset import Dataset
 12 | from iirc.definitions import NO_LABEL_PLACEHOLDER
 13 | from lifelong_methods.buffer.buffer import BufferBase
 14 | from lifelong_methods.methods.base_method import BaseMethod
 15 | from lifelong_methods.utils import SubsetSampler, copy_freeze
 16 | 
 17 | 
 18 | class Model(BaseMethod):
 19 |     """
 20 |     An  implementation of modified version of iCaRL that doesn't use the nearest class mean during inference
 21 |     """
 22 | 
 23 |     def __init__(self, n_cla_per_tsk: Union[np.ndarray, List[int]], class_names_to_idx: Dict[str, int], config: Dict):
 24 |         super(Model, self).__init__(n_cla_per_tsk, class_names_to_idx, config)
 25 | 
 26 |         self.old_net = copy_freeze(self.net)
 27 | 
 28 |         # setup losses
 29 |         self.bce = nn.BCEWithLogitsLoss(reduction="mean")
 30 | 
 31 |     def _load_method_state_dict(self, state_dicts: Dict[str, Dict]) -> None:
 32 |         """
 33 |         This is where anything model specific needs to be done before the state_dicts are loaded
 34 | 
 35 |         Args:
 36 |             state_dicts (Dict[str, Dict]): a dictionary with the state dictionaries of this method, the optimizer, the
 37 |             scheduler, and the values of the variables whose names are inside the self.method_variables
 38 |         """
 39 |         pass
 40 | 
 41 |     def _prepare_model_for_new_task(self, **kwargs) -> None:
 42 |         """
 43 |         A method specific function that takes place before the starting epoch of each new task (runs from the
 44 |         prepare_model_for_task function).
 45 |         It copies the old network and freezes it's gradients.
 46 |         """
 47 |         self.old_net = copy_freeze(self.net)
 48 |         self.old_net.eval()
 49 | 
 50 |     def _preprocess_target(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
 51 |         """Replaces the labels on the older classes with the distillation targets produced by the old network"""
 52 |         offset1, offset2 = self._compute_offsets(self.cur_task_id)
 53 |         y = y.clone()
 54 |         if self.cur_task_id > 0:
 55 |             distill_model_output, _ = self.old_net(x)
 56 |             distill_model_output = distill_model_output.detach()
 57 |             distill_model_output = torch.sigmoid(distill_model_output / self.temperature)
 58 |             y[:, :offset1] = distill_model_output[:, :offset1]
 59 |         return y
 60 | 
 61 |     def observe(self, x: torch.Tensor, y: torch.Tensor, in_buffer: Optional[torch.Tensor] = None,
 62 |                 train: bool = True) -> Tuple[torch.Tensor, float]:
 63 |         """
 64 |         The method used for training and validation, returns a tensor of model predictions and the loss
 65 |         This function needs to be defined in the inheriting method class
 66 | 
 67 |         Args:
 68 |             x (torch.Tensor): The batch of images
 69 |             y (torch.Tensor): A 2-d batch indicator tensor of shape (number of samples x number of classes)
 70 |             in_buffer (Optional[torch.Tensor]): A 1-d boolean tensor which indicates which sample is from the buffer.
 71 |             train (bool): Whether this is training or validation/test
 72 | 
 73 |         Returns:
 74 |             Tuple[torch.Tensor, float]:
 75 |             predictions (torch.Tensor) : a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
 76 |             loss (float): the value of the loss
 77 |         """
 78 |         offset_1, offset_2 = self._compute_offsets(self.cur_task_id)
 79 |         target = self._preprocess_target(x, y)
 80 |         assert target.shape[1] == offset_2
 81 |         output, _ = self.forward_net(x)
 82 |         output = output[:, :offset_2]
 83 |         loss = self.bce(output / self.temperature, target)
 84 | 
 85 |         if train:
 86 |             self.opt.zero_grad()
 87 |             loss.backward()
 88 |             self.opt.step()
 89 | 
 90 |         predictions = output.ge(0.0)
 91 |         return predictions, loss.item()
 92 | 
 93 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 94 |         """
 95 |         The method used during inference, returns a tensor of model predictions
 96 | 
 97 |         Args:
 98 |             x (torch.Tensor): The batch of images
 99 | 
100 |         Returns:
101 |             torch.Tensor: a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
102 |         """
103 |         num_seen_classes = len(self.seen_classes)
104 |         output, _ = self.forward_net(x)
105 |         output = output[:, :num_seen_classes]
106 |         predictions = output.ge(0.0)
107 |         return predictions
108 | 
109 |     def _consolidate_epoch_knowledge(self, **kwargs) -> None:
110 |         """
111 |         A method specific function that takes place after training on each epoch (runs from the
112 |         consolidate_epoch_knowledge function)
113 |         """
114 |         pass
115 | 
116 |     def consolidate_task_knowledge(self, **kwargs) -> None:
117 |         """Takes place after training on each task"""
118 |         pass
119 | 
120 | 
121 | class Buffer(BufferBase):
122 |     def __init__(self,
123 |                  config: Dict,
124 |                  buffer_dir: Optional[str] = None,
125 |                  map_size: int = 1e9,
126 |                  essential_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
127 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None):
128 |         super(Buffer, self).__init__(config, buffer_dir, map_size, essential_transforms_fn, augmentation_transforms_fn)
129 | 
130 |     def _reduce_exemplar_set(self, **kwargs) -> None:
131 |         """remove extra exemplars from the buffer"""
132 |         for label in self.seen_classes:
133 |             if len(self.mem_class_x[label]) > self.n_mems_per_cla:
134 |                 n = len(self.mem_class_x[label]) - self.n_mems_per_cla
135 |                 self.remove_samples(label, n)
136 | 
137 |     def _construct_exemplar_set(self, task_data: Dataset, dist_args: Optional[dict] = None,
138 |                                 model: torch.nn.Module = None, batch_size=1, **kwargs):
139 |         """
140 |         Update the buffer with the new task samples using herding
141 | 
142 |         Args:
143 |             task_data (Dataset): The new task data
144 |             dist_args (Optional[Dict]): a dictionary of the distributed processing values in case of multiple gpu (ex:
145 |             rank of the device) (default: None)
146 |             model (BaseMethod): The current method object to calculate the latent variables
147 |             batch_size (int): The minibatch size
148 |         """
149 |         distributed = dist_args is not None
150 |         if distributed:
151 |             device = torch.device(f"cuda:{dist_args['gpu']}")
152 |             rank = dist_args['rank']
153 |         else:
154 |             device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
155 |             rank = 0
156 |         new_class_labels = task_data.cur_task
157 |         model.eval()
158 | 
159 |         with task_data.disable_augmentations(): # disable augmentations then enable them (if they were already enabled)
160 |             with torch.no_grad():
161 |                 for class_label in new_class_labels:
162 |                     class_data_indices = task_data.get_image_indices_by_cla(class_label, self.max_mems_pool_size)
163 |                     if distributed:
164 |                         device = torch.device(f"cuda:{dist_args['gpu']}")
165 |                         class_data_indices_to_broadcast = torch.from_numpy(class_data_indices).to(device)
166 |                         dist.broadcast(class_data_indices_to_broadcast, 0)
167 |                         class_data_indices = class_data_indices_to_broadcast.cpu().numpy()
168 |                     sampler = SubsetSampler(class_data_indices)
169 |                     class_loader = DataLoader(task_data, batch_size=batch_size, sampler=sampler)
170 |                     latent_vectors = []
171 |                     for minibatch in class_loader:
172 |                         images = minibatch[0].to(device)
173 |                         output, out_latent = model.forward_net(images)
174 |                         out_latent = out_latent.detach()
175 |                         out_latent = F.normalize(out_latent, p=2, dim=-1)
176 |                         latent_vectors.append(out_latent)
177 |                     latent_vectors = torch.cat(latent_vectors, dim=0)
178 |                     class_mean = torch.mean(latent_vectors, dim=0)
179 | 
180 |                     chosen_exemplars_ind = []
181 |                     exemplars_mean = torch.zeros_like(class_mean)
182 |                     while len(chosen_exemplars_ind) < min(self.n_mems_per_cla, len(class_data_indices)):
183 |                         potential_exemplars_mean = (exemplars_mean.unsqueeze(0) * len(chosen_exemplars_ind) + latent_vectors) \
184 |                                                    / (len(chosen_exemplars_ind) + 1)
185 |                         distance = (class_mean.unsqueeze(0) - potential_exemplars_mean).norm(dim=-1)
186 |                         shuffled_index = torch.argmin(distance).item()
187 |                         exemplars_mean = potential_exemplars_mean[shuffled_index, :].clone()
188 |                         exemplar_index = class_data_indices[shuffled_index]
189 |                         chosen_exemplars_ind.append(exemplar_index)
190 |                         latent_vectors[shuffled_index, :] = float("inf")
191 | 
192 |                     for image_index in chosen_exemplars_ind:
193 |                         image, label1, label2 = task_data.get_item(image_index)
194 |                         if label2 != NO_LABEL_PLACEHOLDER:
195 |                             warnings.warn(f"Sample is being added to the buffer with labels {label1} and {label2}")
196 |                         self.add_sample(class_label, image, (label1, label2), rank=rank)
197 | 


--------------------------------------------------------------------------------
/lifelong_methods/methods/mask_seen_classes.py:
--------------------------------------------------------------------------------
  1 | import torch.nn as nn
  2 | import torch
  3 | import numpy as np
  4 | from PIL import Image
  5 | import warnings
  6 | from typing import Optional, Union, List, Dict, Callable, Tuple
  7 | 
  8 | from iirc.lifelong_dataset.torch_dataset import Dataset
  9 | from iirc.definitions import NO_LABEL_PLACEHOLDER
 10 | from lifelong_methods.buffer.buffer import BufferBase
 11 | from lifelong_methods.methods.base_method import BaseMethod
 12 | 
 13 | 
 14 | class Model(BaseMethod):
 15 |     """
 16 |     A method that only provides feedback for the classes that belong to the task of the sample (masks other tasks
 17 |     classes when computing the loss).
 18 |     """
 19 | 
 20 |     def __init__(self, n_cla_per_tsk: Union[np.ndarray, List[int]], class_names_to_idx: Dict[str, int], config: Dict):
 21 |         super(Model, self).__init__(n_cla_per_tsk, class_names_to_idx, config)
 22 | 
 23 |         # setup losses
 24 |         self.bce = nn.BCEWithLogitsLoss(reduction="mean")
 25 | 
 26 |     def _load_method_state_dict(self, state_dicts: Dict[str, Dict]) -> None:
 27 |         """
 28 |         This is where anything model specific needs to be done before the state_dicts are loaded
 29 | 
 30 |         Args:
 31 |             state_dicts (Dict[str, Dict]): a dictionary with the state dictionaries of this method, the optimizer, the
 32 |             scheduler, and the values of the variables whose names are inside the self.method_variables
 33 |         """
 34 |         pass
 35 | 
 36 |     def _prepare_model_for_new_task(self, **kwargs) -> None:
 37 |         """
 38 |         A method specific function that takes place before the starting epoch of each new task (runs from the
 39 |             prepare_model_for_task function)
 40 |         """
 41 |         pass
 42 | 
 43 |     def observe(self, x: torch.Tensor, y: torch.Tensor, in_buffer: Optional[torch.Tensor] = None,
 44 |                 train: bool = True) -> Tuple[torch.Tensor, float]:
 45 |         """
 46 |         The method used for training and validation, returns a tensor of model predictions and the loss
 47 |         This function needs to be defined in the inheriting method class
 48 | 
 49 |         Args:
 50 |             x (torch.Tensor): The batch of images
 51 |             y (torch.Tensor): A 2-d batch indicator tensor of shape (number of samples x number of classes)
 52 |             in_buffer (Optional[torch.Tensor]): A 1-d boolean tensor which indicates which sample is from the buffer.
 53 |             train (bool): Whether this is training or validation/test
 54 | 
 55 |         Returns:
 56 |             Tuple[torch.Tensor, float]:
 57 |             predictions (torch.Tensor) : a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
 58 |             loss (float): the value of the loss
 59 |         """
 60 |         num_seen_classes = len(self.seen_classes)
 61 |         offset_1, offset_2 = self._compute_offsets(self.cur_task_id)
 62 |         target = y
 63 |         assert target.shape[1] == offset_2
 64 |         output, _ = self.forward_net(x)
 65 |         output = output[:, :offset_2]
 66 |         loss = self.bce(output[:, offset_1:] / self.temperature, target[:, offset_1:])
 67 | 
 68 |         # TODO weigh the buffer loss by the self.memory_strength before getting the loss mean (use in_buffer)
 69 |         if train:
 70 |             self.opt.zero_grad()
 71 |             loss.backward()
 72 |             self.opt.step()
 73 | 
 74 |         predictions = output > 0.0
 75 |         return predictions, loss.item()
 76 | 
 77 |     def forward(self, x: torch.Tensor) -> torch.Tensor:
 78 |         """
 79 |         The method used during inference, returns a tensor of model predictions
 80 | 
 81 |         Args:
 82 |             x (torch.Tensor): The batch of images
 83 | 
 84 |         Returns:
 85 |             torch.Tensor: a 2-d float tensor of the model predictions of shape (number of samples x number of classes)
 86 |         """
 87 |         num_seen_classes = len(self.seen_classes)
 88 |         output, _ = self.forward_net(x)
 89 |         output = output[:, :num_seen_classes]
 90 |         predictions = output > 0.0
 91 |         return predictions
 92 | 
 93 |     def _consolidate_epoch_knowledge(self, **kwargs) -> None:
 94 |         """
 95 |         A method specific function that takes place after training on each epoch (runs from the
 96 |         consolidate_epoch_knowledge function)
 97 |         """
 98 |         pass
 99 | 
100 |     def consolidate_task_knowledge(self, **kwargs) -> None:
101 |         """Takes place after training on each task"""
102 |         pass
103 | 
104 | 
105 | class Buffer(BufferBase):
106 |     def __init__(self,
107 |                  config: Dict,
108 |                  buffer_dir: Optional[str] = None,
109 |                  map_size: int = 1e9,
110 |                  essential_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None,
111 |                  augmentation_transforms_fn: Optional[Callable[[Image.Image], torch.Tensor]] = None):
112 |         super(Buffer, self).__init__(config, buffer_dir, map_size, essential_transforms_fn, augmentation_transforms_fn)
113 | 
114 |     def _reduce_exemplar_set(self, **kwargs) -> None:
115 |         """remove extra exemplars from the buffer"""
116 |         for label in self.seen_classes:
117 |             if len(self.mem_class_x[label]) > self.n_mems_per_cla:
118 |                 n = len(self.mem_class_x[label]) - self.n_mems_per_cla
119 |                 self.remove_samples(label, n)
120 | 
121 |     def _construct_exemplar_set(self, task_data : Dataset, dist_args=None, **kwargs) -> None:
122 |         """
123 |         update the buffer with the new task exemplars, chosen randomly for each class.
124 | 
125 |         Args:
126 |             new_task_data (Dataset): The new task data
127 |             dist_args (Optional[Dict]): a dictionary of the distributed processing values in case of multiple gpu (ex:
128 |             rank of the device) (default: None)
129 |         """
130 |         distributed = dist_args is not None
131 |         new_class_labels = task_data.cur_task
132 | 
133 |         for class_label in new_class_labels:
134 |             num_images_to_add = min(self.n_mems_per_cla, self.max_mems_pool_size)
135 |             if not distributed:
136 |                 class_images_indices = task_data.get_image_indices_by_cla(class_label, num_images_to_add)
137 |             else:
138 |                 raise NotImplementedError
139 | 
140 |             for image_index in class_images_indices:
141 |                 image, label1, label2 = task_data.get_item(image_index)
142 |                 if label2 != NO_LABEL_PLACEHOLDER:
143 |                     warnings.warn(f"Sample is being added to the buffer with labels {label1} and {label2}")
144 |                 self.add_sample(class_label, image, (label1, label2))
145 | 


--------------------------------------------------------------------------------
/lifelong_methods/models/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chandar-lab/IIRC/ae6ffcfc0a42274bcda66e2288e09118604620e4/lifelong_methods/models/__init__.py


--------------------------------------------------------------------------------
/lifelong_methods/models/cosine_linear.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Adapted from
 3 | https://github.com/hshustc/CVPR19_Incremental_Learning/blob/master/cifar100-class-incremental/modified_linear.py
 4 | 
 5 | Reference:
 6 | [1] Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, Dahua Lin
 7 |     Learning a Unified Classifier Incrementally via Rebalancing. CVPR 2019
 8 | '''
 9 | 
10 | import math
11 | import torch
12 | from torch.nn.parameter import Parameter
13 | from torch.nn import functional as F
14 | from torch.nn import Module
15 | from typing import Union
16 | 
17 | 
18 | class CosineLinear(Module):
19 |     def __init__(self, in_features, out_features, sigma: Union[bool, float, int] = True):
20 |         super(CosineLinear, self).__init__()
21 |         self.in_features = in_features
22 |         self.out_features = out_features
23 |         self.weight = Parameter(torch.empty(out_features, in_features), requires_grad=True)
24 |         if isinstance(sigma, bool):
25 |             if sigma:
26 |                 self.sigma = Parameter(torch.empty(1), requires_grad=True)
27 |                 self.sigma.data.fill_(1)
28 |             else:
29 |                 self.register_parameter('sigma', None)
30 |         elif isinstance(sigma, int) or isinstance(sigma, float):
31 |             self.register_buffer('sigma', torch.tensor(float(sigma)))
32 |         else:
33 |             raise ValueError("sigma should be a boolean or a float")
34 |         self.reset_parameters()
35 | 
36 |     def reset_parameters(self):
37 |         stdv = 1. / math.sqrt(self.weight.size(1))
38 |         self.weight.data.uniform_(-stdv, stdv)
39 | 
40 |     def forward(self, input_: torch.Tensor):
41 |         out = F.linear(F.normalize(input_, p=2,dim=1), F.normalize(self.weight, p=2, dim=1))
42 |         if self.sigma is not None:
43 |             out = self.sigma * out
44 |         return out
45 | 
46 | 
47 | class SplitCosineLinear(Module):
48 |     #consists of two fc layers and concatenate their outputs
49 |     def __init__(self, in_features, out_features1, out_features2, sigma: Union[bool, float, int] = True):
50 |         super(SplitCosineLinear, self).__init__()
51 |         self.in_features = in_features
52 |         self.out_features = out_features1 + out_features2
53 |         self.fc1 = CosineLinear(in_features, out_features1, False)
54 |         self.fc2 = CosineLinear(in_features, out_features2, False)
55 |         if isinstance(sigma, bool):
56 |             if sigma:
57 |                 self.sigma = Parameter(torch.empty(1), requires_grad=True)
58 |                 self.sigma.data.fill_(1)
59 |             else:
60 |                 self.register_parameter('sigma', None)
61 |         elif isinstance(sigma, int) or isinstance(sigma, float):
62 |             self.register_buffer('sigma', torch.tensor(float(sigma)))
63 |         else:
64 |             raise ValueError("sigma should be a boolean or a float")
65 | 
66 |     def forward(self, x):
67 |         out1 = self.fc1(x)
68 |         out2 = self.fc2(x)
69 |         out = torch.cat((out1, out2), dim=1) # concatenate along the channel
70 |         if self.sigma is not None:
71 |             out = self.sigma * out
72 |         return out
73 | 


--------------------------------------------------------------------------------
/lifelong_methods/models/mlp.py:
--------------------------------------------------------------------------------
 1 | import torch
 2 | import torch.nn as nn
 3 | 
 4 | import experiments.utils
 5 | 
 6 | 
 7 | class MLP(nn.Module):
 8 |     # If multi_head is false, A single head is constructed with the total number of classes
 9 |     def __init__(self, input_shape, num_tasks, classes_per_task, num_hidden_layers=1, hidden_sizes=128,
10 |                  multi_head=False):
11 |         super(MLP, self).__init__()
12 |         self.hidden_sizes = experiments.utils.extend_list(hidden_sizes, num_hidden_layers)
13 |         self.classes_per_task = experiments.utils.extend_list(classes_per_task, num_tasks)
14 |         self.num_hidden_layers = num_hidden_layers
15 |         self.num_tasks = num_tasks
16 |         self.multi_head = multi_head
17 | 
18 |         self.layers = nn.ModuleList([nn.Linear(input_shape, self.hidden_sizes[0], bias=True)])
19 |         self.layers.extend(nn.ModuleList([nn.Linear(self.hidden_sizes[i], self.hidden_sizes[i + 1], bias=True)
20 |                                           for i in range(self.num_hidden_layers - 1)]))
21 |         if self.multi_head:
22 |             self.output_layer = nn.ModuleList(
23 |                 [nn.Linear(self.hidden_sizes[-1], num_classes) for num_classes in self.classes_per_task])
24 |         else:
25 |             self.output_layer = nn.Linear(self.hidden_sizes[-1], sum(self.classes_per_task))
26 | 
27 |         self.relu = torch.nn.ReLU()
28 | 
29 |     def forward(self, input_):
30 |         x = self.layers[0](input_)
31 |         x = self.relu(x)
32 |         for layer in self.layers[1:]:
33 |             x = layer(x)
34 |             x = self.relu(x)
35 |         if self.multi_head:
36 |             output = [self.output_layer[t](x) for t in range(self.num_tasks)]
37 |         else:
38 |             output = self.output_layer(x)
39 |         return output, x
40 | 


--------------------------------------------------------------------------------
/lifelong_methods/models/resnet.py:
--------------------------------------------------------------------------------
 1 | from torchvision import models
 2 | import torch.nn as nn
 3 | 
 4 | 
 5 | # Todo add a relu_last_hidden=False parameter as in ResNetCifar
 6 | class ResNet(nn.Module):
 7 |     def __init__(self, num_classes=10, num_layers=18):
 8 |         super(ResNet, self).__init__()
 9 |         self.num_classes = num_classes
10 |         self.num_layers = num_layers
11 |         if num_layers not in [18, 34, 50, 101, 152]:
12 |             raise ValueError("For ResNet, choose a number of layers out of 18, 34, 50, 101, and 152")
13 |         elif num_layers == 18:
14 |             self.model = models.resnet18()
15 |         elif num_layers == 34:
16 |             self.model = models.resnet34()
17 |         elif num_layers == 50:
18 |             self.model = models.resnet50()
19 |         elif num_layers == 101:
20 |             self.model = models.resnet101()
21 |         elif num_layers == 152:
22 |             self.model = models.resnet152()
23 | 
24 |         latent_dim = self.model.fc.in_features
25 |         self.model.fc = nn.Identity()  # replace the builtin fully connected layer with an identity layer
26 |         self.model.output_layer = nn.Linear(latent_dim, self.num_classes)
27 | 
28 |     def forward(self, input_):
29 |         x = self.model(input_)
30 |         output = self.model.output_layer(x)
31 |         return output, x
32 | 


--------------------------------------------------------------------------------
/lifelong_methods/models/resnetcifar.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Taken with some modifications from the code written by Yerlan Idelbayev
  3 | https://github.com/akamaster/pytorch_resnet_cifar10
  4 | 
  5 | Properly implemented ResNet-s for CIFAR10 as described in paper [1].
  6 | The implementation and structure of this file is hugely influenced by [2]
  7 | which is implemented for ImageNet and doesn't have option A for identity.
  8 | Moreover, most of the implementations on the web is copy-paste from
  9 | torchvision's resnet and has wrong number of params.
 10 | Proper ResNet-s for CIFAR10 (for fair comparision and etc.) has following
 11 | number of layers and parameters:
 12 | name      | layers | params
 13 | ResNet20  |    20  | 0.27M
 14 | ResNet32  |    32  | 0.46M
 15 | ResNet44  |    44  | 0.66M
 16 | ResNet56  |    56  | 0.85M
 17 | ResNet110 |   110  |  1.7M
 18 | ResNet1202|  1202  | 19.4m
 19 | which this implementation indeed has.
 20 | Reference:
 21 | [1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
 22 |     Deep Residual Learning for Image Recognition. arXiv:1512.03385
 23 | [2] https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
 24 | '''
 25 | import torch.nn as nn
 26 | import torch.nn.functional as F
 27 | import torch.nn.init as init
 28 | 
 29 | __all__ = ['ResNetCIFAR']
 30 | 
 31 | 
 32 | def _weights_init(m):
 33 |     if isinstance(m, nn.Conv2d):
 34 |         init.kaiming_normal_(m.weight, nonlinearity="relu")
 35 |     elif isinstance(m, nn.Linear):
 36 |         init.kaiming_normal_(m.weight, nonlinearity="sigmoid")
 37 | 
 38 | 
 39 | class LambdaLayer(nn.Module):
 40 |     def __init__(self, lambd):
 41 |         super(LambdaLayer, self).__init__()
 42 |         self.lambd = lambd
 43 | 
 44 |     def forward(self, x):
 45 |         return self.lambd(x)
 46 | 
 47 | 
 48 | class BasicBlock(nn.Module):
 49 |     expansion = 1
 50 | 
 51 |     def __init__(self, in_planes, planes, stride=1, option='B', relu_output=True):
 52 |         super(BasicBlock, self).__init__()
 53 |         self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
 54 |         self.bn1 = nn.BatchNorm2d(planes)
 55 |         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
 56 |         self.bn2 = nn.BatchNorm2d(planes)
 57 |         self.relu_output = relu_output
 58 | 
 59 |         self.shortcut = nn.Sequential()
 60 |         if stride != 1 or in_planes != planes:
 61 |             if option == 'A':
 62 |                 """
 63 |                 For CIFAR10 ResNet paper uses option A.
 64 |                 """
 65 |                 self.shortcut = LambdaLayer(lambda x:
 66 |                                             F.pad(x[:, :, ::2, ::2], [0, 0, 0, 0, planes // 4, planes // 4], "constant",
 67 |                                                   0))
 68 |             elif option == 'B':
 69 |                 self.shortcut = nn.Sequential(
 70 |                     nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
 71 |                     nn.BatchNorm2d(self.expansion * planes)
 72 |                 )
 73 | 
 74 |     def forward(self, x):
 75 |         out = F.relu(self.bn1(self.conv1(x)))
 76 |         out = self.bn2(self.conv2(out))
 77 |         out += self.shortcut(x)
 78 |         if self.relu_output:
 79 |             out = F.relu(out)
 80 |         return out
 81 | 
 82 | 
 83 | class ResNetCIFARModule(nn.Module):
 84 |     def __init__(self, block, num_blocks, num_classes=10, relu_last_hidden=False):
 85 |         super(ResNetCIFARModule, self).__init__()
 86 |         self.in_planes = 16
 87 |         self.latent_dim = 64
 88 |         self.num_classes = num_classes
 89 | 
 90 |         self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1, bias=False)
 91 |         self.bn1 = nn.BatchNorm2d(16)
 92 |         self.layer1 = self._make_layer(block, 16, num_blocks[0], 1)
 93 |         self.layer2 = self._make_layer(block, 32, num_blocks[1], 2)
 94 |         self.layer3 = self._make_layer(block, 64, num_blocks[2], 2, relu_last_hidden)
 95 |         self.output_layer = nn.Linear(self.latent_dim, self.num_classes)
 96 | 
 97 |     def _make_layer(self, block, planes, num_blocks, stride, relu_last_hidden=True):
 98 |         strides = [stride] + [1] * (num_blocks - 1)
 99 |         layers = []
100 |         for i in range(len(strides)):
101 |             if i == (len(strides) - 1):
102 |                 layers.append(block(self.in_planes, planes, strides[i], relu_output=relu_last_hidden))
103 |             else:
104 |                 layers.append(block(self.in_planes, planes, strides[i]))
105 |             self.in_planes = planes * block.expansion
106 |         return nn.Sequential(*layers)
107 | 
108 |     def forward(self, x):
109 |         x = F.relu(self.bn1(self.conv1(x)))
110 |         x = self.layer1(x)
111 |         x = self.layer2(x)
112 |         x = self.layer3(x)
113 |         x = F.avg_pool2d(x, x.size()[3])
114 |         x = x.view(x.size(0), -1)
115 |         out = self.output_layer(x)
116 |         return out, x
117 | 
118 | 
119 | class ResNetCIFAR(nn.Module):
120 |     def __init__(self, num_classes=10, num_layers=20, relu_last_hidden=False):
121 |         super(ResNetCIFAR, self).__init__()
122 |         self.num_layers = num_layers
123 |         self.num_classes = num_classes
124 |         self.relu_last_hidden = relu_last_hidden
125 | 
126 |         if num_layers not in [20, 32, 44, 56, 110]:
127 |             raise ValueError("For ResNetCifar, choose a number of layers out of 20, 32, 44, 56, and 110")
128 |         elif num_layers == 20:
129 |             self.model = ResNetCIFARModule(BasicBlock, [3, 3, 3], num_classes, relu_last_hidden)
130 |         elif num_layers == 32:
131 |             self.model = ResNetCIFARModule(BasicBlock, [5, 5, 5], num_classes, relu_last_hidden)
132 |         elif num_layers == 44:
133 |             self.model = ResNetCIFARModule(BasicBlock, [7, 7, 7], num_classes, relu_last_hidden)
134 |         elif num_layers == 56:
135 |             self.model = ResNetCIFARModule(BasicBlock, [9, 9, 9], num_classes, relu_last_hidden)
136 |         elif num_layers == 110:
137 |             self.model = ResNetCIFARModule(BasicBlock, [18, 18, 18], num_classes, relu_last_hidden)
138 | 
139 |         self.apply(_weights_init)
140 | 
141 |     def forward(self, input_):
142 |         return self.model(input_)
143 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup
 2 | 
 3 | # read the contents of your README file
 4 | from os import path
 5 | this_directory = path.abspath(path.dirname(__file__))
 6 | with open(path.join(this_directory, 'iirc', 'README.md'), encoding='utf-8') as f:
 7 |     long_description = f.read()
 8 | 
 9 | setup(
10 |     name='iirc',
11 |     version='1.0.1',
12 |     packages=['iirc', 'iirc.utils', 'iirc.lifelong_dataset'],
13 |     include_package_data=True,
14 |     long_description=long_description,
15 |     long_description_content_type="text/markdown",
16 |     url='https://chandar-lab.github.io/IIRC/',
17 |     project_urls={
18 |         'Documentation': 'https://iirc.readthedocs.io/en/latest/',
19 |         'Source': 'https://github.com/chandar-lab/IIRC',
20 |     },
21 |     license='MIT',
22 |     install_requires=['numpy', 'Pillow', 'lmdb'],
23 |     python_requires='>=3',
24 |     author='Mohamed Abdelsalam',
25 |     author_email='mabdelsalam944@gmail.com',
26 |     classifiers=[
27 |         'License :: OSI Approved :: MIT License',
28 |         'Programming Language :: Python :: 3',
29 |         'Programming Language :: Python :: 3.8',
30 |     ],
31 |     description='This package provides a way for adapting the different datasets (currently supports *CIFAR-100* and '
32 |                 '*ImageNet*) to  the *iirc* setup and the *class incremental learning* setup, and loading them in a '
33 |                 'standardized manner. '
34 | )
35 | 


--------------------------------------------------------------------------------