Upload 641 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/insight.jpg filter=lfs diff=lfs merge=lfs -text
+docs/insight.pdf filter=lfs diff=lfs merge=lfs -text
+docs/style.jpg filter=lfs diff=lfs merge=lfs -text
+docs/texture.jpg filter=lfs diff=lfs merge=lfs -text
+docs/vis.jpg filter=lfs diff=lfs merge=lfs -text
+docs/walking.jpg filter=lfs diff=lfs merge=lfs -text

Dassl.pytorch/.flake8

@@ -0,0 +1,24 @@
+[flake8]
+ignore =
+    # At least two spaces before inline comment
+    E261,
+    # Line lengths are recommended to be no greater than 79 characters
+    E501,
+    # Missing whitespace around arithmetic operator 
+    E226,
+    # Blank line contains whitespace
+    W293,
+    # Do not use bare 'except'
+    E722,
+    # Line break after binary operator
+    W504,
+    # Too many leading '#' for block comment
+    E266,
+    # Line break before binary operator
+    W503,
+    # Continuation line over-indented for hanging indent
+    E126,
+    # Module level import not at top of file
+    E402
+max-line-length = 79
+exclude = __init__.py, build

Dassl.pytorch/.gitignore

@@ -0,0 +1,139 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# OS X
+.DS_Store
+.Spotlight-V100
+.Trashes
+._*
+
+# This project
+output/
+debug/

Dassl.pytorch/.isort.cfg

@@ -0,0 +1,10 @@
+[isort]
+line_length=79
+multi_line_output=6
+length_sort=true
+known_standard_library=numpy,setuptools
+known_myself=dassl
+known_third_party=matplotlib,cv2,torch,torchvision,PIL,yacs,scipy,gdown
+no_lines_before=STDLIB,THIRDPARTY
+sections=FUTURE,STDLIB,THIRDPARTY,myself,FIRSTPARTY,LOCALFOLDER
+default_section=FIRSTPARTY

Dassl.pytorch/.style.yapf

@@ -0,0 +1,7 @@
+[style]
+BASED_ON_STYLE = pep8
+BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF = true
+SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN = true
+DEDENT_CLOSING_BRACKETS = true
+SPACES_BEFORE_COMMENT = 2
+ARITHMETIC_PRECEDENCE_INDICATION = true

Dassl.pytorch/DATASETS.md

@@ -0,0 +1,318 @@
+# How to Install Datasets
+
+`$DATA` denotes the location where datasets are installed, e.g.
+
+```
+$DATA/
+|–– office31/
+|–– office_home/
+|–– visda17/
+```
+
+[Domain Adaptation](#domain-adaptation)
+- [Office-31](#office-31)
+- [Office-Home](#office-home)
+- [VisDA17](#visda17)
+- [CIFAR10-STL10](#cifar10-stl10)
+- [Digit-5](#digit-5)
+- [DomainNet](#domainnet)
+- [miniDomainNet](#miniDomainNet)
+
+[Domain Generalization](#domain-generalization)
+- [PACS](#pacs)
+- [VLCS](#vlcs)
+- [Office-Home-DG](#office-home-dg)
+- [Digits-DG](#digits-dg)
+- [Digit-Single](#digit-single)
+- [CIFAR-10-C](#cifar-10-c)
+- [CIFAR-100-C](#cifar-100-c)
+- [WILDS](#wilds)
+
+[Semi-Supervised Learning](#semi-supervised-learning)
+- [CIFAR10/100 and SVHN](#cifar10100-and-svhn)
+- [STL10](#stl10)
+
+## Domain Adaptation
+
+### Office-31
+
+Download link: https://people.eecs.berkeley.edu/~jhoffman/domainadapt/#datasets_code.
+
+File structure:
+
+```
+office31/
+|–– amazon/
+|   |–– back_pack/
+|   |–– bike/
+|   |–– ...
+|–– dslr/
+|   |–– back_pack/
+|   |–– bike/
+|   |–– ...
+|–– webcam/
+|   |–– back_pack/
+|   |–– bike/
+|   |–– ...
+```
+
+Note that within each domain folder you need to move all class folders out of the `images/` folder and then delete the `images/` folder.
+
+### Office-Home
+
+Download link: http://hemanthdv.org/OfficeHome-Dataset/.
+
+File structure:
+
+```
+office_home/
+|–– art/
+|–– clipart/
+|–– product/
+|–– real_world/
+```
+
+### VisDA17
+
+Download link: http://ai.bu.edu/visda-2017/.
+
+The dataset can also be downloaded using our script at `datasets/da/visda17.sh`. Run the following command in your terminal under `Dassl.pytorch/datasets/da`,
+
+```bash
+sh visda17.sh $DATA
+```
+
+Once the download is finished, the file structure will look like
+
+```
+visda17/
+|–– train/
+|–– test/
+|–– validation/
+```
+
+### CIFAR10-STL10
+
+Run the following command in your terminal under `Dassl.pytorch/datasets/da`,
+
+```bash
+python cifar_stl.py $DATA/cifar_stl
+```
+
+This will create a folder named `cifar_stl` under `$DATA`. The file structure will look like
+
+```
+cifar_stl/
+|–– cifar/
+|   |–– train/
+|   |–– test/
+|–– stl/
+|   |–– train/
+|   |–– test/
+```
+
+Note that only 9 classes shared by both datasets are kept.
+
+### Digit-5
+
+Create a folder `$DATA/digit5` and download to this folder the dataset from [here](https://github.com/VisionLearningGroup/VisionLearningGroup.github.io/tree/master/M3SDA/code_MSDA_digit#digit-five-download). This should give you
+
+```
+digit5/
+|–– Digit-Five/
+```
+
+Then, run the following command in your terminal under `Dassl.pytorch/datasets/da`,
+
+```bash 
+python digit5.py $DATA/digit5
+```
+
+This will extract the data and organize the file structure as
+
+```
+digit5/
+|–– Digit-Five/
+|–– mnist/
+|–– mnist_m/
+|–– usps/
+|–– svhn/
+|–– syn/
+```
+
+### DomainNet
+
+Download link: http://ai.bu.edu/M3SDA/. (Please download the cleaned version of split files)
+
+File structure:
+
+```
+domainnet/
+|–– clipart/
+|–– infograph/
+|–– painting/
+|–– quickdraw/
+|–– real/
+|–– sketch/
+|–– splits/
+|   |–– clipart_train.txt
+|   |–– clipart_test.txt
+|   |–– ...
+```
+
+### miniDomainNet
+
+You need to download the DomainNet dataset first. The miniDomainNet's split files can be downloaded at this [google drive](https://drive.google.com/open?id=15rrLDCrzyi6ZY-1vJar3u7plgLe4COL7). After the zip file is extracted, you should have the folder `$DATA/domainnet/splits_mini/`.
+
+## Domain Generalization
+
+### PACS
+
+Download link: [google drive](https://drive.google.com/open?id=1m4X4fROCCXMO0lRLrr6Zz9Vb3974NWhE).
+
+File structure:
+
+```
+pacs/
+|–– images/
+|–– splits/
+```
+
+You do not necessarily have to manually download this dataset. Once you run ``tools/train.py``, the code will detect if the dataset exists or not and automatically download the dataset to ``$DATA`` if missing. This also applies to VLCS, Office-Home-DG, and Digits-DG.
+
+### VLCS
+
+Download link: [google drive](https://drive.google.com/file/d/1r0WL5DDqKfSPp9E3tRENwHaXNs1olLZd/view?usp=sharing) (credit to https://github.com/fmcarlucci/JigenDG#vlcs)
+
+File structure:
+
+```
+VLCS/
+|–– CALTECH/
+|–– LABELME/
+|–– PASCAL/
+|–– SUN/
+```
+
+### Office-Home-DG
+
+Download link: [google drive](https://drive.google.com/open?id=1gkbf_KaxoBws-GWT3XIPZ7BnkqbAxIFa).
+
+File structure:
+
+```
+office_home_dg/
+|–– art/
+|–– clipart/
+|–– product/
+|–– real_world/
+```
+
+### Digits-DG
+
+Download link: [google driv](https://drive.google.com/open?id=15V7EsHfCcfbKgsDmzQKj_DfXt_XYp_P7).
+
+File structure:
+
+```
+digits_dg/
+|–– mnist/
+|–– mnist_m/
+|–– svhn/
+|–– syn/
+```
+
+### Digit-Single
+Follow the steps for [Digit-5](#digit-5) to organize the dataset.
+
+### CIFAR-10-C
+
+First download the CIFAR-10-C dataset from https://zenodo.org/record/2535967#.YFxHEWQzb0o to, e.g., $DATA, and extract the file under the same directory. Then, navigate to `Dassl.pytorch/datasets/dg` and run the following command in your terminal
+```bash
+python cifar_c.py $DATA/CIFAR-10-C
+```
+where the first argument denotes the path to the (uncompressed) CIFAR-10-C dataset.
+
+The script will extract images from the `.npy` files and save them to `cifar10_c/` created under $DATA. The file structure will look like
+```
+cifar10_c/
+|–– brightness/
+|   |–– 1/ # 5 intensity levels in total
+|   |–– 2/
+|   |–– 3/
+|   |–– 4/
+|   |–– 5/
+|–– ... # 19 corruption types in total
+```
+
+Note that `cifar10_c/` only contains the test images. The training images are the normal CIFAR-10 images. See [CIFAR10/100 and SVHN](#cifar10100-and-svhn) for how to prepare the CIFAR-10 dataset.
+
+### CIFAR-100-C
+
+First download the CIFAR-100-C dataset from https://zenodo.org/record/3555552#.YFxpQmQzb0o to, e.g., $DATA, and extract the file under the same directory. Then, navigate to `Dassl.pytorch/datasets/dg` and run the following command in your terminal
+```bash
+python cifar_c.py $DATA/CIFAR-100-C
+```
+where the first argument denotes the path to the (uncompressed) CIFAR-100-C dataset.
+
+The script will extract images from the `.npy` files and save them to `cifar100_c/` created under $DATA. The file structure will look like
+```
+cifar100_c/
+|–– brightness/
+|   |–– 1/ # 5 intensity levels in total
+|   |–– 2/
+|   |–– 3/
+|   |–– 4/
+|   |–– 5/
+|–– ... # 19 corruption types in total
+```
+
+Note that `cifar100_c/` only contains the test images. The training images are the normal CIFAR-100 images. See [CIFAR10/100 and SVHN](#cifar10100-and-svhn) for how to prepare the CIFAR-100 dataset.
+
+### WILDS
+
+No action is required to preprocess WILDS's datasets. The code will automatically download the data.
+
+## Semi-Supervised Learning
+
+### CIFAR10/100 and SVHN
+
+Run the following command in your terminal under `Dassl.pytorch/datasets/ssl`,
+
+```bash
+python cifar10_cifar100_svhn.py $DATA
+```
+
+This will create three folders under `$DATA`, i.e.
+
+```
+cifar10/
+|–– train/
+|–– test/
+cifar100/
+|–– train/
+|–– test/
+svhn/
+|–– train/
+|–– test/
+```
+
+### STL10
+
+Run the following command in your terminal under `Dassl.pytorch/datasets/ssl`,
+
+```bash
+python stl10.py $DATA/stl10
+```
+
+This will create a folder named `stl10` under `$DATA` and extract the data into three folders, i.e. `train`, `test` and `unlabeled`. Then, download from http://ai.stanford.edu/~acoates/stl10/ the "Binary files" and extract it under `stl10`.
+
+The file structure will look like
+
+```
+stl10/
+|–– train/
+|–– test/
+|–– unlabeled/
+|–– stl10_binary/
+```

Dassl.pytorch/LICENSE

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

Dassl.pytorch/README.md

@@ -0,0 +1,279 @@
+# Dassl
+
+## Introduction
+
+Dassl is a [PyTorch](https://pytorch.org) toolbox initially developed for our project [Domain Adaptive Ensemble Learning (DAEL)](https://arxiv.org/abs/2003.07325) to support research in domain adaptation and generalization---since in DAEL we study how to unify these two problems in a single learning framework. Given that domain adaptation is closely related to semi-supervised learning---both study how to exploit unlabeled data---we also incorporate components that support research for the latter.
+
+Why the name "Dassl"? Dassl combines the initials of domain adaptation (DA) and semi-supervised learning (SSL), which sounds natural and informative.
+
+Dassl has a modular design and unified interfaces, allowing fast prototyping and experimentation of new DA/DG/SSL methods. With Dassl, a new method can be implemented with only a few lines of code. Don't believe? Take a look at the [engine](https://github.com/KaiyangZhou/Dassl.pytorch/tree/master/dassl/engine) folder, which contains the implementations of many existing methods (then you will come back and star this repo). :-)
+
+Basically, Dassl is perfect for doing research in the following areas:
+- Domain adaptation
+- Domain generalization
+- Semi-supervised learning
+
+BUT, thanks to the neat design, Dassl can also be used as a codebase to develop any deep learning projects, like [this](https://github.com/KaiyangZhou/CoOp). :-)
+
+A drawback of Dassl is that it doesn't (yet? hmm) support distributed multi-GPU training (Dassl uses `DataParallel` to wrap a model, which is less efficient than `DistributedDataParallel`).
+
+We don't provide detailed documentations for Dassl, unlike another [project](https://kaiyangzhou.github.io/deep-person-reid/) of ours. This is because Dassl is developed for research purpose and as a researcher, we think it's important to be able to read source code and we highly encourage you to do so---definitely not because we are lazy. :-)
+
+## What's new
+- **[Oct 2022]** New paper "[On-Device Domain Generalization](https://arxiv.org/abs/2209.07521)" is out! Code, models and datasets: https://github.com/KaiyangZhou/on-device-dg.
+
+<details>
+    <summary>More</summary>
+
+- **[Jun 2022]** `v0.6.0`: Make `cfg.TRAINER.METHOD_NAME` consistent with the method class name.
+- **[Jun 2022]** A new domain adaptation method [CDAC (CVPR'21)](https://openaccess.thecvf.com/content/CVPR2021/papers/Li_Cross-Domain_Adaptive_Clustering_for_Semi-Supervised_Domain_Adaptation_CVPR_2021_paper.pdf) is added by [Shreejal Trivedi](https://github.com/shreejalt). See [here](https://github.com/KaiyangZhou/Dassl.pytorch/pull/44) for more details.
+- **[Jun 2022]** Adds three datasets from the [WILDS](https://wilds.stanford.edu/) benchmark: iWildCam, FMoW and Camelyon17. See [here](https://github.com/KaiyangZhou/Dassl.pytorch/commit/7f7eab8e22f6e176b97a539100eca12d6a403909) for more details.
+- **[May 2022]** A new domain generalization method [DDG](https://arxiv.org/abs/2205.13913) developed by [Zhishu Sun](https://github.com/siaimes) and to appear at IJCAI'22 is added to this repo. See [here](https://github.com/MetaVisionLab/DDG) for more details.
+- **[Mar 2022]** A new domain generalization method [EFDM](https://arxiv.org/abs/2203.07740) developed by [Yabin Zhang (PolyU)](https://ybzh.github.io/) and to appear at CVPR'22 is added to this repo. See [here](https://github.com/KaiyangZhou/Dassl.pytorch/pull/36) for more details.
+- **[Feb 2022]** In case you don't know, a class in the painting domain of DomainNet (the official splits) only has test images (no training images), which could affect performance. See section 4.a in our [paper](https://arxiv.org/abs/2003.07325) for more details.
+- **[Oct 2021]** `v0.5.0`: **Important changes** made to `transforms.py`. 1) `center_crop` becomes a default transform in testing (applied after resizing the smaller edge to a certain size to keep the image aspect ratio). 2) For training, `Resize(cfg.INPUT.SIZE)` is deactivated when `random_crop` or `random_resized_crop` is used. These changes won't make any difference to the training transforms used in existing config files, nor to the testing transforms unless the raw images are not squared (the only difference is that now the image aspect ratio is respected).
+- **[Oct 2021]** `v0.4.3`: Copy the attributes in `self.dm` (data manager) to `SimpleTrainer` and make `self.dm` optional, which means from now on, you can build data loaders from any source you like rather than being forced to use `DataManager`.
+- **[Sep 2021]** `v0.4.2`: An important update is to set `drop_last=is_train and len(data_source)>=batch_size` when constructing a data loader to avoid 0-length.
+
+</details>
+
+## Overview
+
+Dassl has implemented the following methods:
+
+- Single-source domain adaptation
+    - [Cross Domain Adaptive Clustering for Semi Supervised Domain Adaptation (CVPR'21)](https://arxiv.org/pdf/2104.09415.pdf) [[dassl/engine/da/cdac.py](dassl/engine/da/cdac.py)]
+    - [Semi-supervised Domain Adaptation via Minimax Entropy (ICCV'19)](https://arxiv.org/abs/1904.06487) [[dassl/engine/da/mme.py](dassl/engine/da/mme.py)]
+    - [Maximum Classifier Discrepancy for Unsupervised Domain Adaptation (CVPR'18)](https://arxiv.org/abs/1712.02560https://arxiv.org/abs/1712.02560) [[dassl/engine/da/mcd.py](dassl/engine/da/mcd.py)]
+    - [Self-ensembling for visual domain adaptation (ICLR'18)](https://arxiv.org/abs/1706.05208) [[dassl/engine/da/self_ensembling.py](dassl/engine/da/self_ensembling.py)]
+    - [Revisiting Batch Normalization For Practical Domain Adaptation (ICLR-W'17)](https://arxiv.org/abs/1603.04779) [[dassl/engine/da/adabn.py](dassl/engine/da/adabn.py)]
+    - [Adversarial Discriminative Domain Adaptation (CVPR'17)](https://arxiv.org/abs/1702.05464) [[dassl/engine/da/adda.py](dassl/engine/da/adda.py)]
+    - [Domain-Adversarial Training of Neural Networks (JMLR'16) ](https://arxiv.org/abs/1505.07818) [[dassl/engine/da/dann.py](dassl/engine/da/dann.py)]
+
+- Multi-source domain adaptation
+    - [Domain Aadaptive Ensemble Learning](https://arxiv.org/abs/2003.07325) [[dassl/engine/da/dael.py](dassl/engine/da/dael.py)]
+    - [Moment Matching for Multi-Source Domain Adaptation (ICCV'19)](https://arxiv.org/abs/1812.01754) [[dassl/engine/da/m3sda.py](dassl/engine/da/m3sda.py)]
+
+- Domain generalization
+    - [Dynamic Domain Generalization (IJCAI'22)](https://arxiv.org/abs/2205.13913) [[dassl/modeling/backbone/resnet_dynamic.py](dassl/modeling/backbone/resnet_dynamic.py)] [[dassl/engine/dg/domain_mix.py](dassl/engine/dg/domain_mix.py)]
+    - [Exact Feature Distribution Matching for Arbitrary Style Transfer and Domain Generalization (CVPR'22)](https://arxiv.org/abs/2203.07740) [[dassl/modeling/ops/efdmix.py](dassl/modeling/ops/efdmix.py)]
+    - [Domain Generalization with MixStyle (ICLR'21)](https://openreview.net/forum?id=6xHJ37MVxxp) [[dassl/modeling/ops/mixstyle.py](dassl/modeling/ops/mixstyle.py)]
+    - [Deep Domain-Adversarial Image Generation for Domain Generalisation (AAAI'20)](https://arxiv.org/abs/2003.06054) [[dassl/engine/dg/ddaig.py](dassl/engine/dg/ddaig.py)]
+    - [Generalizing Across Domains via Cross-Gradient Training (ICLR'18)](https://arxiv.org/abs/1804.10745) [[dassl/engine/dg/crossgrad.py](dassl/engine/dg/crossgrad.py)]
+
+- Semi-supervised learning
+    - [FixMatch: Simplifying Semi-Supervised Learning with Consistency and Confidence](https://arxiv.org/abs/2001.07685) [[dassl/engine/ssl/fixmatch.py](dassl/engine/ssl/fixmatch.py)]
+    - [MixMatch: A Holistic Approach to Semi-Supervised Learning (NeurIPS'19)](https://arxiv.org/abs/1905.02249) [[dassl/engine/ssl/mixmatch.py](dassl/engine/ssl/mixmatch.py)]
+    - [Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results (NeurIPS'17)](https://arxiv.org/abs/1703.01780) [[dassl/engine/ssl/mean_teacher.py](dassl/engine/ssl/mean_teacher.py)]
+    - [Semi-supervised Learning by Entropy Minimization (NeurIPS'04)](http://papers.nips.cc/paper/2740-semi-supervised-learning-by-entropy-minimization.pdf) [[dassl/engine/ssl/entmin.py](dassl/engine/ssl/entmin.py)]
+
+*Feel free to make a [PR](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) to add your methods here to make it easier for others to benchmark!*
+
+Dassl supports the following datasets:
+
+- Domain adaptation
+    - [Office-31](https://scalable.mpi-inf.mpg.de/files/2013/04/saenko_eccv_2010.pdf)
+    - [Office-Home](http://hemanthdv.org/OfficeHome-Dataset/)
+    - [VisDA17](http://ai.bu.edu/visda-2017/)
+    - [CIFAR10](https://www.cs.toronto.edu/~kriz/cifar.html)-[STL10](https://cs.stanford.edu/~acoates/stl10/)
+    - [Digit-5](https://github.com/VisionLearningGroup/VisionLearningGroup.github.io/tree/master/M3SDA/code_MSDA_digit#digit-five-download)
+    - [DomainNet](http://ai.bu.edu/M3SDA/)
+    - [miniDomainNet](https://arxiv.org/abs/2003.07325)
+
+- Domain generalization
+    - [PACS](https://arxiv.org/abs/1710.03077)
+    - [VLCS](https://people.csail.mit.edu/torralba/publications/datasets_cvpr11.pdf)
+    - [Office-Home](http://hemanthdv.org/OfficeHome-Dataset/)
+    - [Digits-DG](https://arxiv.org/abs/2003.06054)
+    - [Digit-Single](https://arxiv.org/abs/1805.12018)
+    - [CIFAR-10-C](https://arxiv.org/abs/1807.01697)
+    - [CIFAR-100-C](https://arxiv.org/abs/1807.01697)
+    - [iWildCam-WILDS](https://wilds.stanford.edu/datasets/#iwildcam)
+    - [Camelyon17-WILDS](https://wilds.stanford.edu/datasets/#camelyon17)
+    - [FMoW-WILDS](https://wilds.stanford.edu/datasets/#fmow)
+
+- Semi-supervised learning
+    - [CIFAR10/100](https://www.cs.toronto.edu/~kriz/cifar.html.)
+    - [SVHN](http://ufldl.stanford.edu/housenumbers/)
+    - [STL10](https://cs.stanford.edu/~acoates/stl10/)
+
+## Get started
+
+### Installation
+
+Make sure [conda](https://www.anaconda.com/distribution/) is installed properly.
+
+```bash
+# Clone this repo
+git clone https://github.com/KaiyangZhou/Dassl.pytorch.git
+cd Dassl.pytorch/
+
+# Create a conda environment
+conda create -y -n dassl python=3.8
+
+# Activate the environment
+conda activate dassl
+
+# Install torch (requires version >= 1.8.1) and torchvision
+# Please refer to https://pytorch.org/ if you need a different cuda version
+conda install pytorch torchvision cudatoolkit=10.2 -c pytorch
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Install this library (no need to re-build if the source code is modified)
+python setup.py develop
+```
+
+Follow the instructions in [DATASETS.md](./DATASETS.md) to preprocess the datasets.
+
+### Training
+
+The main interface is implemented in `tools/train.py`, which basically does
+
+1. initialize the config with `cfg = setup_cfg(args)` where `args` contains the command-line input (see `tools/train.py` for the list of input arguments);
+2. instantiate a `trainer` with `build_trainer(cfg)` which loads the dataset and builds a deep neural network model;
+3. call `trainer.train()` for training and evaluating the model.
+
+Below we provide an example for training a source-only baseline on the popular domain adaptation dataset, Office-31,
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python tools/train.py \
+--root $DATA \
+--trainer SourceOnly \
+--source-domains amazon \
+--target-domains webcam \
+--dataset-config-file configs/datasets/da/office31.yaml \
+--config-file configs/trainers/da/source_only/office31.yaml \
+--output-dir output/source_only_office31
+```
+
+`$DATA` denotes the location where datasets are installed. `--dataset-config-file` loads the common setting for the dataset (Office-31 in this case) such as image size and model architecture. `--config-file` loads the algorithm-specific setting such as hyper-parameters and optimization parameters.
+
+To use multiple sources, namely the multi-source domain adaptation task, one just needs to add more sources to `--source-domains`. For instance, to train a source-only baseline on miniDomainNet, one can do
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python tools/train.py \
+--root $DATA \
+--trainer SourceOnly \
+--source-domains clipart painting real \
+--target-domains sketch \
+--dataset-config-file configs/datasets/da/mini_domainnet.yaml \
+--config-file configs/trainers/da/source_only/mini_domainnet.yaml \
+--output-dir output/source_only_minidn
+```
+
+After the training finishes, the model weights will be saved under the specified output directory, along with a log file and a tensorboard file for visualization.
+
+To print out the results saved in the log file (so you do not need to exhaustively go through all log files and calculate the mean/std by yourself), you can use `tools/parse_test_res.py`. The instruction can be found in the code.
+
+For other trainers such as `MCD`, you can set `--trainer MCD` while keeping the config file unchanged, i.e. using the same training parameters as `SourceOnly` (in the simplest case). To modify the hyper-parameters in MCD, like `N_STEP_F` (number of steps to update the feature extractor), you can append `TRAINER.MCD.N_STEP_F 4` to the existing input arguments (otherwise the default value will be used). Alternatively, you can create a new `.yaml` config file to store your custom setting. See [here](https://github.com/KaiyangZhou/Dassl.pytorch/blob/master/dassl/config/defaults.py#L176) for a complete list of algorithm-specific hyper-parameters.
+
+### Test
+Model testing can be done by using `--eval-only`, which asks the code to run `trainer.test()`. You also need to provide the trained model and specify which model file (i.e. saved at which epoch) to use. For example, to use `model.pth.tar-20` saved at `output/source_only_office31/model`, you can do
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python tools/train.py \
+--root $DATA \
+--trainer SourceOnly \
+--source-domains amazon \
+--target-domains webcam \
+--dataset-config-file configs/datasets/da/office31.yaml \
+--config-file configs/trainers/da/source_only/office31.yaml \
+--output-dir output/source_only_office31_test \
+--eval-only \
+--model-dir output/source_only_office31 \
+--load-epoch 20
+```
+
+Note that `--model-dir` takes as input the directory path which was specified in `--output-dir` in the training stage.
+
+### Write a new trainer
+A good practice is to go through `dassl/engine/trainer.py` to get familar with the base trainer classes, which provide generic functions and training loops. To write a trainer class for domain adaptation or semi-supervised learning, the new class can subclass `TrainerXU`. For domain generalization, the new class can subclass `TrainerX`. In particular, `TrainerXU` and `TrainerX` mainly differ in whether using a data loader for unlabeled data. With the base classes, a new trainer may only need to implement the `forward_backward()` method, which performs loss computation and model update. See `dassl/enigne/da/source_only.py` for example.
+
+### Add a new backbone/head/network
+`backbone` corresponds to a convolutional neural network model which performs feature extraction. `head` (which is an optional module) is mounted on top of `backbone` for further processing, which can be, for example, a MLP. `backbone` and `head` are basic building blocks for constructing a `SimpleNet()` (see `dassl/engine/trainer.py`) which serves as the primary model for a task. `network` contains custom neural network models, such as an image generator.
+
+To add a new module, namely a backbone/head/network, you need to first register the module using the corresponding `registry`, i.e. `BACKBONE_REGISTRY` for `backbone`, `HEAD_REGISTRY` for `head` and `NETWORK_RESIGTRY` for `network`. Note that for a new `backbone`, we require the model to subclass `Backbone` as defined in `dassl/modeling/backbone/backbone.py` and specify the `self._out_features` attribute.
+
+We provide an example below for how to add a new `backbone`.
+```python
+from dassl.modeling import Backbone, BACKBONE_REGISTRY
+
+class MyBackbone(Backbone):
+
+    def __init__(self):
+        super().__init__()
+        # Create layers
+        self.conv = ...
+
+        self._out_features = 2048
+
+    def forward(self, x):
+        # Extract and return features
+
+@BACKBONE_REGISTRY.register()
+def my_backbone(**kwargs):
+    return MyBackbone()
+```
+Then, you can set `MODEL.BACKBONE.NAME` to `my_backbone` to use your own architecture. For more details, please refer to the source code in `dassl/modeling`.
+
+### Add a dataset
+An example code structure is shown below. Make sure you subclass `DatasetBase` and register the dataset with `@DATASET_REGISTRY.register()`. All you need is to load `train_x`, `train_u` (optional), `val` (optional) and `test`, among which `train_u` and `val` could be `None` or simply ignored. Each of these variables contains a list of `Datum` objects. A `Datum` object (implemented [here](https://github.com/KaiyangZhou/Dassl.pytorch/blob/master/dassl/data/datasets/base_dataset.py#L12)) contains information for a single image, like `impath` (string) and `label` (int).
+
+```python
+from dassl.data.datasets import DATASET_REGISTRY, Datum, DatasetBase
+
+@DATASET_REGISTRY.register()
+class NewDataset(DatasetBase):
+
+    dataset_dir = ''
+
+    def __init__(self, cfg):
+        
+        train_x = ...
+        train_u = ...  # optional, can be None
+        val = ...  # optional, can be None
+        test = ...
+
+        super().__init__(train_x=train_x, train_u=train_u, val=val, test=test)
+```
+
+We suggest you take a look at the datasets code in some projects like [this](https://github.com/KaiyangZhou/CoOp), which is built on top of Dassl.
+
+## Relevant Research
+
+We would like to share here our research relevant to Dassl.
+
+- [On-Device Domain Generalization](https://arxiv.org/abs/2209.07521)
+- [Domain Generalization: A Survey](https://arxiv.org/abs/2103.02503) (TPAMI 2022)
+- [Domain Adaptive Ensemble Learning](https://arxiv.org/abs/2003.07325) (TIP 2021)
+- [MixStyle Neural Networks for Domain Generalization and Adaptation](https://arxiv.org/abs/2107.02053)
+- [Semi-Supervised Domain Generalization with Stochastic StyleMatch](https://arxiv.org/abs/2106.00592)
+- [Domain Generalization with MixStyle](https://openreview.net/forum?id=6xHJ37MVxxp) (ICLR 2021)
+- [Learning to Generate Novel Domains for Domain Generalization](https://arxiv.org/abs/2007.03304) (ECCV 2020)
+- [Deep Domain-Adversarial Image Generation for Domain Generalisation](https://arxiv.org/abs/2003.06054) (AAAI 2020)
+
+## Citation
+
+If you find this code useful to your research, please give credit to the following paper
+
+```
+@article{zhou2022domain,
+  title={Domain generalization: A survey},
+  author={Zhou, Kaiyang and Liu, Ziwei and Qiao, Yu and Xiang, Tao and Loy, Chen Change},
+  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  year={2022},
+  publisher={IEEE}
+}
+
+@article{zhou2021domain,
+  title={Domain adaptive ensemble learning},
+  author={Zhou, Kaiyang and Yang, Yongxin and Qiao, Yu and Xiang, Tao},
+  journal={IEEE Transactions on Image Processing},
+  volume={30},
+  pages={8008--8018},
+  year={2021},
+  publisher={IEEE}
+}
+```

Dassl.pytorch/configs/README.md

@@ -0,0 +1 @@
+The `datasets/` folder contains dataset-specific config files which define the standard protocols (e.g., image size, data augmentation, network architecture) used by most papers. The `trainers/` folder contains method-specific config files which define optimization algorithms (e.g., optimizer, epoch) and hyperparameter settings.

Dassl.pytorch/configs/datasets/da/cifar_stl.yaml

@@ -0,0 +1,7 @@
+INPUT:
+  SIZE: (32, 32)
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "CIFARSTL"

Dassl.pytorch/configs/datasets/da/digit5.yaml

@@ -0,0 +1,12 @@
+INPUT:
+  SIZE: (32, 32)
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+  TRANSFORMS: ["normalize"]
+
+DATASET:
+  NAME: "Digit5"
+
+MODEL:
+  BACKBONE:
+    NAME: "cnn_digit5_m3sda"

Dassl.pytorch/configs/datasets/da/domainnet.yaml

@@ -0,0 +1,10 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "DomainNet"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet101"

Dassl.pytorch/configs/datasets/da/mini_domainnet.yaml

@@ -0,0 +1,10 @@
+INPUT:
+  SIZE: (96, 96)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "miniDomainNet"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet18"

Dassl.pytorch/configs/datasets/da/office31.yaml

@@ -0,0 +1,14 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "Office31"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet50"
+  HEAD:
+    NAME: "mlp"
+    HIDDEN_LAYERS: [256]
+    DROPOUT: 0.

Dassl.pytorch/configs/datasets/da/office_home.yaml

@@ -0,0 +1,5 @@
+INPUT:
+  SIZE: (224, 224)
+
+DATASET:
+  NAME: "OfficeHome"

Dassl.pytorch/configs/datasets/da/visda17.yaml

@@ -0,0 +1,13 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "center_crop", "normalize"]
+
+DATASET:
+  NAME: "VisDA17"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet101"
+
+TEST:
+  PER_CLASS_RESULT: True

Dassl.pytorch/configs/datasets/dg/camelyon17.yaml

@@ -0,0 +1,6 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_resized_crop", "random_flip", "normalize"]
+
+DATASET:
+  NAME: "Camelyon17"

Dassl.pytorch/configs/datasets/dg/cifar100_c.yaml

@@ -0,0 +1,14 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["random_flip", "random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "CIFAR100C"
+  CIFAR_C_TYPE: "fog"
+  CIFAR_C_LEVEL: 5
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_16_4"

Dassl.pytorch/configs/datasets/dg/cifar10_c.yaml

@@ -0,0 +1,14 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["random_flip", "random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "CIFAR10C"
+  CIFAR_C_TYPE: "fog"
+  CIFAR_C_LEVEL: 5
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_16_4"

Dassl.pytorch/configs/datasets/dg/digit_single.yaml

@@ -0,0 +1,12 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "DigitSingle"
+
+MODEL:
+  BACKBONE:
+    NAME: "cnn_digitsingle"

Dassl.pytorch/configs/datasets/dg/digits_dg.yaml

@@ -0,0 +1,12 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "DigitsDG"
+
+MODEL:
+  BACKBONE:
+    NAME: "cnn_digitsdg"

Dassl.pytorch/configs/datasets/dg/fmow.yaml

@@ -0,0 +1,6 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_resized_crop", "random_flip", "normalize"]
+
+DATASET:
+  NAME: "FMoW"

Dassl.pytorch/configs/datasets/dg/iwildcam.yaml

@@ -0,0 +1,6 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_resized_crop", "random_flip", "normalize"]
+
+DATASET:
+  NAME: "IWildCam"

Dassl.pytorch/configs/datasets/dg/office_home_dg.yaml

@@ -0,0 +1,11 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "OfficeHomeDG"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet18"
+    PRETRAINED: True

Dassl.pytorch/configs/datasets/dg/pacs.yaml

@@ -0,0 +1,11 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "PACS"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet18"
+    PRETRAINED: True

Dassl.pytorch/configs/datasets/dg/vlcs.yaml

@@ -0,0 +1,11 @@
+INPUT:
+  SIZE: (224, 224)
+  TRANSFORMS: ["random_flip", "random_translation", "normalize"]
+
+DATASET:
+  NAME: "VLCS"
+
+MODEL:
+  BACKBONE:
+    NAME: "resnet18"
+    PRETRAINED: True

Dassl.pytorch/configs/datasets/ssl/cifar10.yaml

@@ -0,0 +1,14 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["random_flip", "random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+
+DATASET:
+  NAME: "CIFAR10"
+  NUM_LABELED: 4000
+  VAL_PERCENT: 0.
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_28_2"

Dassl.pytorch/configs/datasets/ssl/cifar100.yaml

@@ -0,0 +1,15 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["random_flip", "random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+  CROP_PADDING: 4
+
+DATASET:
+  NAME: "CIFAR100"
+  NUM_LABELED: 10000
+  VAL_PERCENT: 0.
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_28_2"

Dassl.pytorch/configs/datasets/ssl/stl10.yaml

@@ -0,0 +1,14 @@
+INPUT:
+  SIZE: (96, 96)
+  TRANSFORMS: ["random_flip", "random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+  CROP_PADDING: 4
+
+DATASET:
+  NAME: "STL10"
+  STL10_FOLD: 0
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_28_2"

Dassl.pytorch/configs/datasets/ssl/svhn.yaml

@@ -0,0 +1,15 @@
+INPUT:
+  SIZE: (32, 32)
+  TRANSFORMS: ["random_crop", "normalize"]
+  PIXEL_MEAN: [0.5, 0.5, 0.5]
+  PIXEL_STD: [0.5, 0.5, 0.5]
+  CROP_PADDING: 4
+
+DATASET:
+  NAME: "SVHN"
+  NUM_LABELED: 1000
+  VAL_PERCENT: 0.
+
+MODEL:
+  BACKBONE:
+    NAME: "wide_resnet_28_2"

Dassl.pytorch/configs/trainers/da/cdac/digit5.yaml

@@ -0,0 +1,20 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomSampler"
+    BATCH_SIZE: 64
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 192
+  TEST:
+    BATCH_SIZE: 256
+  K_TRANSFORMS: 2
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.001
+  MAX_EPOCH: 90
+  RAMPUP_ITRS: 10000
+
+TRAINER:
+  CDAC:
+    STRONG_TRANSFORMS: ["randaugment", "normalize"]

Dassl.pytorch/configs/trainers/da/cdac/domainnet.yaml

@@ -0,0 +1,20 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 30
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 6
+  TEST:
+    BATCH_SIZE: 30
+  K_TRANSFORMS: 2
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.001
+  MAX_EPOCH: 90
+  RAMPUP_ITRS: 10000
+
+TRAINER:
+  CDAC:
+    STRONG_TRANSFORMS: ["randaugment", "normalize"]

Dassl.pytorch/configs/trainers/da/cdac/mini_domainnet.yaml

@@ -0,0 +1,21 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 64
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 192
+  TEST:
+    BATCH_SIZE: 200
+  K_TRANSFORMS: 2
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.001
+  MAX_EPOCH: 60
+  RAMPUP_ITRS: 10000
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  CDAC:
+    STRONG_TRANSFORMS: ["randaugment", "normalize"]

Dassl.pytorch/configs/trainers/da/dael/digit5.yaml

@@ -0,0 +1,20 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 256
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 64
+  TEST:
+    BATCH_SIZE: 256
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.05
+  STEPSIZE: [30]
+  MAX_EPOCH: 30
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  DAEL:
+    STRONG_TRANSFORMS: ["randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/da/dael/domainnet.yaml

@@ -0,0 +1,19 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 30
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 6
+  TEST:
+    BATCH_SIZE: 30
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.002
+  MAX_EPOCH: 40
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  DAEL:
+    STRONG_TRANSFORMS: ["random_flip", "cutout", "randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/da/dael/mini_domainnet.yaml

@@ -0,0 +1,19 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 192
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 64
+  TEST:
+    BATCH_SIZE: 200
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.005
+  MAX_EPOCH: 60
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  DAEL:
+    STRONG_TRANSFORMS: ["random_flip", "cutout", "randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/da/m3sda/digit5.yaml

@@ -0,0 +1,16 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 256
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 64
+  TEST:
+    BATCH_SIZE: 256
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.05
+  STEPSIZE: [30]
+  MAX_EPOCH: 30
+  LR_SCHEDULER: "cosine"

Dassl.pytorch/configs/trainers/da/m3sda/domainnet.yaml

@@ -0,0 +1,15 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 30
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 6
+  TEST:
+    BATCH_SIZE: 30
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.002
+  MAX_EPOCH: 40
+  LR_SCHEDULER: "cosine"

Dassl.pytorch/configs/trainers/da/m3sda/mini_domainnet.yaml

@@ -0,0 +1,15 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 192
+  TRAIN_U:
+    SAME_AS_X: False
+    BATCH_SIZE: 64
+  TEST:
+    BATCH_SIZE: 200
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.005
+  MAX_EPOCH: 60
+  LR_SCHEDULER: "cosine"

Dassl.pytorch/configs/trainers/da/source_only/digit5.yaml

@@ -0,0 +1,12 @@
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 256
+  TEST:
+    BATCH_SIZE: 256
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.05
+  STEPSIZE: [30]
+  MAX_EPOCH: 30
+  LR_SCHEDULER: "cosine"

Dassl.pytorch/configs/trainers/da/source_only/mini_domainnet.yaml

@@ -0,0 +1,11 @@
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 128
+  TEST:
+    BATCH_SIZE: 128
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.005
+  MAX_EPOCH: 60
+  LR_SCHEDULER: "cosine"

Dassl.pytorch/configs/trainers/da/source_only/office31.yaml

@@ -0,0 +1,11 @@
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 32
+  TEST:
+    BATCH_SIZE: 32
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.002
+  STEPSIZE: [20]
+  MAX_EPOCH: 20

Dassl.pytorch/configs/trainers/da/source_only/visda17.yaml

@@ -0,0 +1,15 @@
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 32
+  TEST:
+    BATCH_SIZE: 32
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.0001
+  STEPSIZE: [2]
+  MAX_EPOCH: 2
+
+TRAIN:
+  PRINT_FREQ: 50
+  COUNT_ITER: "train_u"

Dassl.pytorch/configs/trainers/dg/daeldg/digits_dg.yaml

@@ -0,0 +1,16 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 120
+  TEST:
+    BATCH_SIZE: 100
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.05
+  STEPSIZE: [20]
+  MAX_EPOCH: 50
+
+TRAINER:
+  DAELDG:
+    STRONG_TRANSFORMS: ["randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/dg/daeldg/office_home_dg.yaml

@@ -0,0 +1,16 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 30
+  TEST:
+    BATCH_SIZE: 100
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.002
+  MAX_EPOCH: 40
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  DAELDG:
+    STRONG_TRANSFORMS: ["random_flip", "cutout", "randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/dg/daeldg/pacs.yaml

@@ -0,0 +1,16 @@
+DATALOADER:
+  TRAIN_X:
+    SAMPLER: "RandomDomainSampler"
+    BATCH_SIZE: 30
+  TEST:
+    BATCH_SIZE: 100
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.002
+  MAX_EPOCH: 40
+  LR_SCHEDULER: "cosine"
+
+TRAINER:
+  DAELDG:
+    STRONG_TRANSFORMS: ["random_flip", "cutout", "randaugment2", "normalize"]

Dassl.pytorch/configs/trainers/dg/ddaig/digits_dg.yaml

@@ -0,0 +1,20 @@
+INPUT:
+  PIXEL_MEAN: [0., 0., 0.]
+  PIXEL_STD: [1., 1., 1.]
+
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 128
+  TEST:
+    BATCH_SIZE: 128
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.05
+  STEPSIZE: [20]
+  MAX_EPOCH: 50
+
+TRAINER:
+  DDAIG:
+    G_ARCH: "fcn_3x32_gctx"
+    LMDA: 0.3

Dassl.pytorch/configs/trainers/dg/ddaig/office_home_dg.yaml

@@ -0,0 +1,21 @@
+INPUT:
+  PIXEL_MEAN: [0., 0., 0.]
+  PIXEL_STD: [1., 1., 1.]
+
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 16
+  TEST:
+    BATCH_SIZE: 16
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.0005
+  STEPSIZE: [20]
+  MAX_EPOCH: 25
+
+TRAINER:
+  DDAIG:
+    G_ARCH: "fcn_3x64_gctx"
+    WARMUP: 3
+    LMDA: 0.3

Dassl.pytorch/configs/trainers/dg/ddaig/pacs.yaml

@@ -0,0 +1,21 @@
+INPUT:
+  PIXEL_MEAN: [0., 0., 0.]
+  PIXEL_STD: [1., 1., 1.]
+
+DATALOADER:
+  TRAIN_X:
+    BATCH_SIZE: 16
+  TEST:
+    BATCH_SIZE: 16
+
+OPTIM:
+  NAME: "sgd"
+  LR: 0.0005
+  STEPSIZE: [20]
+  MAX_EPOCH: 25
+
+TRAINER:
+  DDAIG:
+    G_ARCH: "fcn_3x64_gctx"
+    WARMUP: 3
+    LMDA: 0.3