├── README.md ├── 1-guillotine ├── True_train.csv ├── False_test.csv ├── False_train.csv ├── True_test.csv ├── README.md ├── guillotine.py └── reader.ipynb ├── 2-pretext ├── README.md ├── guillotine.py └── augmentations.py └── .gitignore /README.md: -------------------------------------------------------------------------------- 1 | # SSL-course 2 | Course to learn the basics of self supervised learning 3 | -------------------------------------------------------------------------------- /1-guillotine/True_train.csv: -------------------------------------------------------------------------------- 1 | ,value_orientation,value_scale,value_shape,value_x_position,value_y_position 2 | value_orientation,0.6875,0.2455,0.7739,0.032,0.0329 3 | value_scale,0.9145,0.0395,0.3324,0.017,0.0182 4 | value_shape,0.8819,0.0515,0.2367,0.016,0.0167 5 | value_x_position,0.854,0.1666,0.735,0.0103,0.0131 6 | value_y_position,0.9376,0.164,0.7449,0.0138,0.0104 7 | -------------------------------------------------------------------------------- /1-guillotine/False_test.csv: -------------------------------------------------------------------------------- 1 | ,value_orientation,value_scale,value_shape,value_x_position,value_y_position 2 | value_orientation,0.6638,0.1622,0.7408,0.0139,0.0162 3 | value_scale,0.9508,0.1067,0.5402,0.0154,0.0161 4 | value_shape,0.8724,0.0787,0.1236,0.0135,0.0132 5 | value_x_position,0.8271,0.15,0.738,0.0027,0.0088 6 | value_y_position,0.933,0.1585,0.7654,0.0091,0.0032 7 | -------------------------------------------------------------------------------- /1-guillotine/False_train.csv: -------------------------------------------------------------------------------- 1 | ,value_orientation,value_scale,value_shape,value_x_position,value_y_position 2 | value_orientation,0.6669,0.172,0.7471,0.0133,0.0166 3 | value_scale,0.9343,0.0238,0.2382,0.0149,0.0157 4 | value_shape,0.8741,0.041,0.1005,0.0142,0.0134 5 | value_x_position,0.8326,0.1576,0.7476,0.0029,0.0088 6 | value_y_position,0.9331,0.1664,0.7728,0.0087,0.0031 7 | -------------------------------------------------------------------------------- /1-guillotine/True_test.csv: -------------------------------------------------------------------------------- 1 | ,value_orientation,value_scale,value_shape,value_x_position,value_y_position 2 | value_orientation,1.1126,0.2899,0.7979,0.0381,0.0394 3 | value_scale,0.9103,0.0487,0.3986,0.0158,0.0155 4 | value_shape,0.8817,0.0412,0.2107,0.0142,0.0146 5 | value_x_position,0.8443,0.157,0.7173,0.0104,0.0125 6 | value_y_position,0.9362,0.1532,0.7279,0.014,0.0106 7 | -------------------------------------------------------------------------------- /2-pretext/README.md: -------------------------------------------------------------------------------- 1 | # Equivariant Pretext-Task 2 | 3 | - Implementation of data augmentations that output the applied transformation parameters is provided in the [augmentations.py](./augentations.py) files. 4 | 5 | - To quickly visualize the augmentation and parameters, you can run the [debug.ipynb](./debug.ipynb) notebook 6 | 7 | - use that core codebase to experiment your own pretext-task idea! -------------------------------------------------------------------------------- /1-guillotine/README.md: -------------------------------------------------------------------------------- 1 | # Guillotine regularization 2 | 3 | ## Guillotine Regularization: Why removing layers is needed to improve generalization in Self-Supervised Learning ([link](https://arxiv.org/pdf/2206.13378)) 4 | 5 | One unexpected technique that emerged in recent years consists in training a Deep Network (DN) with a Self-Supervised Learning (SSL) method, and using this network on downstream tasks but with its last few projector layers entirely removed. This trick of throwing away the projector is actually critical for SSL methods to display competitive performances on ImageNet for which more than 30 percentage points can be gained that way. This is a little vexing, as one would hope that the network layer at which invariance is explicitly enforced by the SSL criterion during training (the last projector layer) should be the one to use for best generalization performance downstream. But it seems not to be, and this study sheds some light on why. This trick, which we name Guillotine Regularization (GR), is in fact a generically applicable method that has been used to improve generalization performance in transfer learning scenarios. In this work, we identify the underlying reasons behind its success and show that the optimal layer to use might change significantly depending on the training setup, the data or the downstream task. Lastly, we give some insights on how to reduce the need for a projector in SSL by aligning the pretext SSL task and the downstream task. 6 | 7 | 8 | ## Toy experiment on [dsprites](https://github.com/google-deepmind/dsprites-dataset) dataset 9 | 10 | - run the training pipeline using the [guillotine.py](./guillotine.py) Python file 11 | - This will generate 4 .csv files with the results (assumes you have 1 GPU available) 12 | - read the saved save using the [reader.ipynb](./reader.ipynb) Jupyter notebook 13 | - This will produce the two heatmaps to compare performances per-task with and without guillotine -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | lightning_logs/ 3 | __pycache__/ 4 | *.py[cod] 5 | *$py.class 6 | *.gz 7 | cifar-10-batches-py/ 8 | cifar-100-batches-py/ 9 | # C extensions 10 | *.so 11 | 12 | # Distribution / packaging 13 | .Python 14 | build/ 15 | develop-eggs/ 16 | dist/ 17 | downloads/ 18 | eggs/ 19 | .eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | wheels/ 26 | share/python-wheels/ 27 | *.egg-info/ 28 | .installed.cfg 29 | *.egg 30 | MANIFEST 31 | 32 | # PyInstaller 33 | # Usually these files are written by a python script from a template 34 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 35 | *.manifest 36 | *.spec 37 | 38 | # Installer logs 39 | pip-log.txt 40 | pip-delete-this-directory.txt 41 | 42 | # Unit test / coverage reports 43 | htmlcov/ 44 | .tox/ 45 | .nox/ 46 | .coverage 47 | .coverage.* 48 | .cache 49 | nosetests.xml 50 | coverage.xml 51 | *.cover 52 | *.py,cover 53 | .hypothesis/ 54 | .pytest_cache/ 55 | cover/ 56 | 57 | # Translations 58 | *.mo 59 | *.pot 60 | 61 | # Django stuff: 62 | *.log 63 | local_settings.py 64 | db.sqlite3 65 | db.sqlite3-journal 66 | 67 | # Flask stuff: 68 | instance/ 69 | .webassets-cache 70 | 71 | # Scrapy stuff: 72 | .scrapy 73 | 74 | # Sphinx documentation 75 | docs/_build/ 76 | 77 | # PyBuilder 78 | .pybuilder/ 79 | target/ 80 | 81 | # Jupyter Notebook 82 | .ipynb_checkpoints 83 | 84 | # IPython 85 | profile_default/ 86 | ipython_config.py 87 | 88 | # pyenv 89 | # For a library or package, you might want to ignore these files since the code is 90 | # intended to run in multiple environments; otherwise, check them in: 91 | # .python-version 92 | 93 | # pipenv 94 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 95 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 96 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 97 | # install all needed dependencies. 98 | #Pipfile.lock 99 | 100 | # poetry 101 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 102 | # This is especially recommended for binary packages to ensure reproducibility, and is more 103 | # commonly ignored for libraries. 104 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 105 | #poetry.lock 106 | 107 | # pdm 108 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 109 | #pdm.lock 110 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 111 | # in version control. 112 | # https://pdm.fming.dev/latest/usage/project/#working-with-version-control 113 | .pdm.toml 114 | .pdm-python 115 | .pdm-build/ 116 | 117 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 118 | __pypackages__/ 119 | 120 | # Celery stuff 121 | celerybeat-schedule 122 | celerybeat.pid 123 | 124 | # SageMath parsed files 125 | *.sage.py 126 | 127 | # Environments 128 | .env 129 | .venv 130 | env/ 131 | venv/ 132 | ENV/ 133 | env.bak/ 134 | venv.bak/ 135 | 136 | # Spyder project settings 137 | .spyderproject 138 | .spyproject 139 | 140 | # Rope project settings 141 | .ropeproject 142 | 143 | # mkdocs documentation 144 | /site 145 | 146 | # mypy 147 | .mypy_cache/ 148 | .dmypy.json 149 | dmypy.json 150 | 151 | # Pyre type checker 152 | .pyre/ 153 | 154 | # pytype static type analyzer 155 | .pytype/ 156 | 157 | # Cython debug symbols 158 | cython_debug/ 159 | 160 | # PyCharm 161 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 162 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 163 | # and can be added to the global gitignore or merged into this file. For a more nuclear 164 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 165 | #.idea/ 166 | -------------------------------------------------------------------------------- /2-pretext/guillotine.py: -------------------------------------------------------------------------------- 1 | import pytorch_lightning as pl 2 | import torch 3 | from torch.nn import MSELoss, CrossEntropyLoss 4 | from torch.optim import AdamW 5 | from torch.utils.data import DataLoader 6 | import torch.nn as nn 7 | import datasets 8 | from torchvision.transforms import v2 9 | import pandas as pd 10 | from pathlib import Path 11 | from pytorch_lightning.loggers import CSVLogger 12 | import augmentations 13 | from torchvision.datasets import CIFAR10 14 | import torchmetrics 15 | 16 | pl.seed_everything(42) 17 | 18 | train_transform = v2.Compose( 19 | [ 20 | augmentations.AddParams(), 21 | augmentations.RandomHorizontalFlip(), 22 | augmentations.ColorJitter(0.4, 0.4, 0.4, 0.2), 23 | augmentations.RandomGrayscale(0.5), 24 | augmentations.RandomRotation(30), 25 | augmentations.ToTensor(), 26 | ] 27 | ) 28 | test_transform = augmentations.ToTensor() 29 | 30 | 31 | def get_CIFAR10_dataset(): 32 | dataset = {} 33 | dataset["train"] = CIFAR10( 34 | root="./", download=True, train=True, transform=train_transform 35 | ) 36 | dataset["test"] = CIFAR10( 37 | root="./", download=True, train=False, transform=test_transform 38 | ) 39 | return dataset 40 | 41 | 42 | class MyModel(pl.LightningModule): 43 | def __init__(self, target: str, guillotine: bool = False, dataset=None): 44 | """ 45 | target: (str) the name of the dataset target to use to train the backbone 46 | guillotine: (bool) whether to add a projector and use guillotine (or not) 47 | """ 48 | super().__init__() 49 | self.target = target 50 | self.dataset = dataset 51 | self.fc = nn.Sequential( 52 | nn.Conv2d(3, 32, kernel_size=5, bias=False), 53 | nn.BatchNorm2d(32), 54 | nn.ReLU(), 55 | nn.Conv2d(32, 64, kernel_size=3, bias=False, stride=2), 56 | nn.BatchNorm2d(64), 57 | nn.ReLU(), 58 | nn.Conv2d(64, 128, kernel_size=3, bias=False, stride=2), 59 | nn.BatchNorm2d(128), 60 | nn.ReLU(), 61 | nn.AdaptiveAvgPool2d((4, 4)), 62 | nn.Flatten(), 63 | ) 64 | if guillotine: 65 | self.projector = nn.Sequential( 66 | nn.Linear(4 * 4 * 128, 4 * 4 * 128, bias=False), 67 | nn.BatchNorm1d(4 * 4 * 128), 68 | nn.ReLU(), 69 | nn.Linear(4 * 4 * 128, 4 * 4 * 128, bias=False), 70 | nn.BatchNorm1d(4 * 4 * 128), 71 | nn.ReLU(), 72 | ) 73 | else: 74 | self.projector = nn.Identity() 75 | self.sup_probe = nn.Sequential(nn.Dropout1d(0.2), nn.Linear(4 * 4 * 128, 10)) 76 | self.probe = nn.Linear(4 * 4 * 128, 10) 77 | self.criterion = CrossEntropyLoss() 78 | self.evaluate = torchmetrics.classification.MulticlassAccuracy( 79 | num_classes=10, average=None 80 | ) 81 | 82 | def forward(self, inputs_id): 83 | outputs = self.fc(inputs_id) 84 | preds = self.probe(outputs.detach()) 85 | return self.sup_probe(self.projector(outputs)), preds 86 | 87 | def get_losses(self, batch): 88 | print(batch) 89 | if self.training: 90 | input_ids = batch[0][0] 91 | else: 92 | input_ids = batch[0] 93 | labels = batch[1] 94 | 95 | outputs, preds = self(input_ids) 96 | probe_losses = self.criterion(preds, labels) 97 | sup_loss = self.criterion(outputs, labels) 98 | return probe_losses, sup_loss, range(10) 99 | 100 | def training_step(self, batch, batch_idx): 101 | probe_losses, sup_loss, label_names = self.get_losses(batch) 102 | loss = probe_losses + sup_loss 103 | log_dict = {} 104 | # log_dict = {f"{name}": p for name, p in zip(label_names, probe_losses.tolist())} 105 | log_dict["target"] = sup_loss.item() 106 | log_dict["epoch"] = self.current_epoch 107 | self.loggers[0].log_metrics(log_dict) 108 | return loss 109 | 110 | def validation_step(self, batch, batch_idx): 111 | _, preds = self(batch[0]) 112 | label_names = range(10) 113 | log_dict = { 114 | f"{name}": p for name, p in zip(label_names, self.evaluate(preds, batch[1])) 115 | } 116 | log_dict["epoch"] = self.current_epoch 117 | self.loggers[1].log_metrics(log_dict) 118 | 119 | def configure_optimizers(self): 120 | optimizer = AdamW(self.parameters(), weight_decay=1e-4, lr=1e-4) 121 | return optimizer 122 | 123 | def optimizer_zero_grad(self, epoch, batch_idx, optimizer): 124 | optimizer.zero_grad(set_to_none=True) 125 | 126 | def train_dataloader(self): 127 | return DataLoader( 128 | self.dataset["train"], 129 | shuffle=True, 130 | drop_last=True, 131 | batch_size=256, 132 | num_workers=10, 133 | persistent_workers=True, 134 | ) 135 | 136 | def val_dataloader(self): 137 | return DataLoader(dataset["test"], batch_size=512, num_workers=10) 138 | 139 | 140 | if __name__ == "__main__": 141 | 142 | for guillotine in [False, True]: 143 | target = "rotation" 144 | dataset = get_CIFAR10_dataset() 145 | train_results = [] 146 | test_results = [] 147 | model = MyModel(target=target, guillotine=guillotine, dataset=dataset) 148 | model = torch.compile(model) 149 | train_logger = CSVLogger(save_dir="lightning_logs", name="train") 150 | val_logger = CSVLogger(save_dir="lightning_logs", name="val") 151 | trainer = pl.Trainer( 152 | max_epochs=5, 153 | accelerator="gpu", 154 | devices=1, 155 | precision="16-mixed", 156 | logger=[train_logger, val_logger], 157 | enable_checkpointing=False, 158 | ) 159 | trainer.fit(model) 160 | train_metrics = pd.read_csv(Path(train_logger.log_dir) / "metrics.csv") 161 | print(train_metrics.shape) 162 | train_metrics = train_metrics.set_index("step").groupby("epoch").mean() 163 | train_results.append(train_metrics.iloc[[-1]]) 164 | val_metrics = pd.read_csv(Path(val_logger.log_dir) / "metrics.csv") 165 | print(val_metrics.shape) 166 | val_metrics = val_metrics.set_index("step").groupby("epoch").mean() 167 | test_results.append(val_metrics.iloc[[-1]]) 168 | 169 | train_results = pd.concat(train_results, axis=0) 170 | train_results = train_results[TARGETS["dsprite"]] 171 | train_results.index = TARGETS["dsprite"] 172 | 173 | test_results = pd.concat(test_results, axis=0) 174 | test_results = test_results[TARGETS["dsprite"]] 175 | test_results.index = TARGETS["dsprite"] 176 | 177 | train_results.round(4).to_csv(f"./{guillotine}_train.csv") 178 | test_results.round(4).to_csv(f"./{guillotine}_test.csv") 179 | -------------------------------------------------------------------------------- /1-guillotine/guillotine.py: -------------------------------------------------------------------------------- 1 | import pytorch_lightning as pl 2 | import torch 3 | from torch.nn import MSELoss 4 | from torch.optim import AdamW 5 | from torch.utils.data import DataLoader 6 | import torch.nn as nn 7 | import datasets 8 | from torchvision.transforms import v2 9 | import pandas as pd 10 | from pathlib import Path 11 | from pytorch_lightning.loggers import CSVLogger 12 | 13 | pl.seed_everything(42) 14 | 15 | TARGETS = { 16 | "dsprite": [ 17 | "value_orientation", 18 | "value_scale", 19 | "value_shape", 20 | "value_x_position", 21 | "value_y_position", 22 | ] 23 | } 24 | 25 | train_transform = v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)]) 26 | test_transform = v2.Compose([v2.ToImage(), v2.ToDtype(torch.float32, scale=True)]) 27 | 28 | 29 | def train_transforms(examples): 30 | examples["image"] = [ 31 | train_transform(img.convert("RGB")) for img in examples["image"] 32 | ] 33 | return examples 34 | 35 | 36 | def test_transforms(examples): 37 | examples["image"] = [ 38 | test_transform(img.convert("RGB")) for img in examples["image"] 39 | ] 40 | return examples 41 | 42 | 43 | def get_dsprites_dataset(): 44 | dataset = datasets.load_dataset("eurecom-ds/dsprites").remove_columns( 45 | [ 46 | "label_orientation", 47 | "label_scale", 48 | "label_shape", 49 | "label_x_position", 50 | "label_y_position", 51 | ] 52 | ) 53 | dataset = dataset["train"].train_test_split(test_size=0.5) 54 | for target in TARGETS["dsprite"]: 55 | mean = dataset["train"].with_format("pandas")[target].mean() 56 | std = dataset["train"].with_format("pandas")[target].std() 57 | dataset["train"] = dataset["train"].map(lambda row:{target: (row[target] - mean)/(1e-5+std)}, batched=True, batch_size=2048) 58 | dataset["test"] = dataset["test"].map(lambda row:{target: (row[target] - mean)/(1e-5+std)}, batched=True, batch_size=2048) 59 | dataset["train"] = dataset["train"].with_transform(train_transforms) 60 | dataset["test"] = dataset["test"].with_transform(test_transforms) 61 | return dataset 62 | 63 | class MyModel(pl.LightningModule): 64 | def __init__(self, target: str, guillotine: bool = False, dataset=None): 65 | """ 66 | target: (str) the name of the dataset target to use to train the backbone 67 | guillotine: (bool) whether to add a projector and use guillotine (or not) 68 | """ 69 | super().__init__() 70 | self.target = target 71 | self.dataset = dataset 72 | self.fc = nn.Sequential( 73 | nn.Conv2d(3, 32, kernel_size=5, bias=False), 74 | nn.BatchNorm2d(32), 75 | nn.ReLU(), 76 | nn.Conv2d(32, 64, kernel_size=3, bias=False, stride=2), 77 | nn.BatchNorm2d(64), 78 | nn.ReLU(), 79 | nn.Conv2d(64, 128, kernel_size=3, bias=False, stride=2), 80 | nn.BatchNorm2d(128), 81 | nn.ReLU(), 82 | nn.AdaptiveAvgPool2d((4,4)), 83 | nn.Flatten(), 84 | ) 85 | if guillotine: 86 | self.projector = nn.Sequential( 87 | nn.Linear(4*4*128, 4*4*128, bias=False), 88 | nn.BatchNorm1d(4*4*128), 89 | nn.ReLU(), 90 | nn.Linear(4*4*128, 4*4*128, bias=False), 91 | nn.BatchNorm1d(4*4*128), 92 | nn.ReLU(), 93 | ) 94 | else: 95 | self.projector = nn.Identity() 96 | self.sup_probe = nn.Sequential(nn.Dropout1d(0.2), nn.Linear(4*4*128, 1)) 97 | self.probe = nn.Linear(4*4*128, 5) 98 | self.criterion = MSELoss(reduction="none") 99 | 100 | def forward(self, inputs_id): 101 | outputs = self.fc(inputs_id) 102 | preds = self.probe(outputs.detach()) 103 | return self.sup_probe(self.projector(outputs)), preds 104 | 105 | 106 | 107 | def get_losses(self, batch): 108 | input_ids = batch["image"] 109 | label_names = [name for name in batch.keys() if name != "image"] 110 | labels = torch.stack([batch[name] for name in label_names], 1) 111 | 112 | outputs, preds = self(input_ids) 113 | probe_losses = self.criterion(preds, labels.float()).mean(0) 114 | sup_loss = self.criterion( 115 | outputs.squeeze(), batch[self.target].squeeze().float() 116 | ).mean() 117 | return probe_losses, sup_loss, label_names 118 | 119 | def training_step(self, batch, batch_idx): 120 | probe_losses, sup_loss, label_names = self.get_losses(batch) 121 | loss = probe_losses.mean() + sup_loss 122 | log_dict = {f"{name}": p for name, p in zip(label_names, probe_losses.tolist())} 123 | log_dict["target"] = sup_loss.item() 124 | log_dict["epoch"] = self.current_epoch 125 | self.loggers[0].log_metrics(log_dict) 126 | return loss 127 | 128 | def validation_step(self, batch, batch_idx): 129 | probe_losses, _, label_names = self.get_losses(batch) 130 | log_dict = {f"{name}": p for name, p in zip(label_names, probe_losses.tolist())} 131 | log_dict["epoch"] = self.current_epoch 132 | self.loggers[1].log_metrics(log_dict) 133 | 134 | def configure_optimizers(self): 135 | optimizer = AdamW(self.parameters(), weight_decay=1e-4, lr=1e-4) 136 | return optimizer 137 | 138 | def optimizer_zero_grad(self, epoch, batch_idx, optimizer): 139 | optimizer.zero_grad(set_to_none=True) 140 | 141 | def train_dataloader(self): 142 | return DataLoader( 143 | self.dataset["train"], 144 | shuffle=True, 145 | drop_last=True, 146 | batch_size=256, 147 | num_workers=10, 148 | persistent_workers=True, 149 | ) 150 | 151 | def val_dataloader(self): 152 | return DataLoader(dataset["test"], batch_size=512, num_workers=10) 153 | 154 | 155 | if __name__ == "__main__": 156 | dataset = get_dsprites_dataset() 157 | 158 | for guillotine in [False, True]: 159 | train_results = [] 160 | test_results = [] 161 | for target in TARGETS["dsprite"]: 162 | model = MyModel(target=target, guillotine=guillotine, dataset=dataset) 163 | model = torch.compile(model) 164 | train_logger = CSVLogger(save_dir="lightning_logs", name="train") 165 | val_logger = CSVLogger(save_dir="lightning_logs", name="val") 166 | trainer = pl.Trainer( 167 | max_epochs=5, 168 | accelerator="gpu", 169 | devices=1, 170 | precision="16-mixed", 171 | logger=[train_logger, val_logger], 172 | enable_checkpointing=False, 173 | ) 174 | trainer.fit(model) 175 | train_metrics = pd.read_csv(Path(train_logger.log_dir) / "metrics.csv") 176 | print(train_metrics.shape) 177 | train_metrics = train_metrics.set_index("step").groupby("epoch").mean() 178 | train_results.append(train_metrics.iloc[[-1]]) 179 | val_metrics = pd.read_csv(Path(val_logger.log_dir) / "metrics.csv") 180 | print(val_metrics.shape) 181 | val_metrics = val_metrics.set_index("step").groupby("epoch").mean() 182 | test_results.append(val_metrics.iloc[[-1]]) 183 | 184 | train_results = pd.concat(train_results, axis=0) 185 | train_results = train_results[TARGETS["dsprite"]] 186 | train_results.index = TARGETS["dsprite"] 187 | 188 | test_results = pd.concat(test_results, axis=0) 189 | test_results = test_results[TARGETS["dsprite"]] 190 | test_results.index = TARGETS["dsprite"] 191 | 192 | train_results.round(4).to_csv(f"./{guillotine}_train.csv") 193 | test_results.round(4).to_csv(f"./{guillotine}_test.csv") 194 | -------------------------------------------------------------------------------- /2-pretext/augmentations.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn.functional as F 3 | import numbers 4 | import torchvision 5 | from collections.abc import Sequence 6 | from torchvision.transforms.functional import ( 7 | _interpolation_modes_from_int, 8 | InterpolationMode, 9 | ) 10 | from typing import List, Optional, Tuple, Union 11 | import numpy as np 12 | 13 | class AddParams(torch.nn.Module): 14 | """Randomly convert image to grayscale with a probability of p (default 0.1). 15 | If the image is torch Tensor, it is expected 16 | to have [..., 3, H, W] shape, where ... means an arbitrary number of leading dimensions 17 | 18 | Args: 19 | p (float): probability that image should be converted to grayscale. 20 | 21 | Returns: 22 | PIL Image or Tensor: Grayscale version of the input image with probability p and unchanged 23 | with probability (1-p). 24 | - If input image is 1 channel: grayscale version is 1 channel 25 | - If input image is 3 channel: grayscale version is 3 channel with r == g == b 26 | 27 | """ 28 | 29 | def forward(self, img): 30 | """ 31 | Args: 32 | img (PIL Image or Tensor): Image to be converted to grayscale. 33 | 34 | Returns: 35 | PIL Image or Tensor: Randomly grayscaled image. 36 | empty list to stack DA parameters 37 | """ 38 | return img, [] 39 | 40 | def __repr__(self) -> str: 41 | return f"{self.__class__.__name__}({self.p})" 42 | 43 | 44 | class RandomGrayscale(torch.nn.Module): 45 | """Randomly convert image to grayscale with a probability of p (default 0.1). 46 | If the image is torch Tensor, it is expected 47 | to have [..., 3, H, W] shape, where ... means an arbitrary number of leading dimensions 48 | 49 | Args: 50 | p (float): probability that image should be converted to grayscale. 51 | 52 | Returns: 53 | PIL Image or Tensor: Grayscale version of the input image with probability p and unchanged 54 | with probability (1-p). 55 | - If input image is 1 channel: grayscale version is 1 channel 56 | - If input image is 3 channel: grayscale version is 3 channel with r == g == b 57 | 58 | """ 59 | 60 | def __init__(self, p=0.1): 61 | super().__init__() 62 | self.p = p 63 | 64 | def forward(self, inputs): 65 | """ 66 | Args: 67 | img (PIL Image or Tensor): Image to be converted to grayscale. 68 | 69 | Returns: 70 | PIL Image or Tensor: Randomly grayscaled image. 71 | """ 72 | img, params = inputs 73 | num_output_channels, _, _ = torchvision.transforms.functional.get_dimensions( 74 | img 75 | ) 76 | if torch.rand(1) < self.p: 77 | return torchvision.transforms.functional.rgb_to_grayscale( 78 | img, num_output_channels=num_output_channels 79 | ), params + [1] 80 | return img, params + [0] 81 | 82 | def __repr__(self) -> str: 83 | return f"{self.__class__.__name__}(p={self.p})" 84 | 85 | 86 | def _check_sequence_input(x, name, req_sizes): 87 | msg = ( 88 | req_sizes[0] if len(req_sizes) < 2 else " or ".join([str(s) for s in req_sizes]) 89 | ) 90 | if not isinstance(x, Sequence): 91 | raise TypeError(f"{name} should be a sequence of length {msg}.") 92 | if len(x) not in req_sizes: 93 | raise ValueError(f"{name} should be a sequence of length {msg}.") 94 | 95 | 96 | def _setup_angle(x, name, req_sizes=(2,)): 97 | if isinstance(x, numbers.Number): 98 | if x < 0: 99 | raise ValueError(f"If {name} is a single number, it must be positive.") 100 | x = [-x, x] 101 | else: 102 | _check_sequence_input(x, name, req_sizes) 103 | 104 | return [float(d) for d in x] 105 | 106 | 107 | class RandomRotation(torch.nn.Module): 108 | """Rotate the image by angle. 109 | If the image is torch Tensor, it is expected 110 | to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions. 111 | 112 | Args: 113 | degrees (sequence or number): Range of degrees to select from. 114 | If degrees is a number instead of sequence like (min, max), the range of degrees 115 | will be (-degrees, +degrees). 116 | interpolation (InterpolationMode): Desired interpolation enum defined by 117 | :class:`torchvision.transforms.InterpolationMode`. Default is ``InterpolationMode.NEAREST``. 118 | If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. 119 | The corresponding Pillow integer constants, e.g. ``PIL.Image.BILINEAR`` are accepted as well. 120 | expand (bool, optional): Optional expansion flag. 121 | If true, expands the output to make it large enough to hold the entire rotated image. 122 | If false or omitted, make the output image the same size as the input image. 123 | Note that the expand flag assumes rotation around the center and no translation. 124 | center (sequence, optional): Optional center of rotation, (x, y). Origin is the upper left corner. 125 | Default is the center of the image. 126 | fill (sequence or number): Pixel fill value for the area outside the rotated 127 | image. Default is ``0``. If given a number, the value is used for all bands respectively. 128 | 129 | .. _filters: https://pillow.readthedocs.io/en/latest/handbook/concepts.html#filters 130 | 131 | """ 132 | 133 | def __init__( 134 | self, 135 | degrees, 136 | interpolation=InterpolationMode.NEAREST, 137 | expand=False, 138 | center=None, 139 | fill=0, 140 | ): 141 | super().__init__() 142 | 143 | if isinstance(interpolation, int): 144 | interpolation = _interpolation_modes_from_int(interpolation) 145 | 146 | self.degrees = _setup_angle(degrees, name="degrees", req_sizes=(2,)) 147 | 148 | self.center = center 149 | 150 | self.interpolation = interpolation 151 | self.expand = expand 152 | 153 | if fill is None: 154 | fill = 0 155 | elif not isinstance(fill, (Sequence, numbers.Number)): 156 | raise TypeError("Fill should be either a sequence or a number.") 157 | 158 | self.fill = fill 159 | 160 | @staticmethod 161 | def get_params(degrees: List[float]) -> float: 162 | """Get parameters for ``rotate`` for a random rotation. 163 | 164 | Returns: 165 | float: angle parameter to be passed to ``rotate`` for random rotation. 166 | """ 167 | angle = float( 168 | torch.empty(1).uniform_(float(degrees[0]), float(degrees[1])).item() 169 | ) 170 | return angle 171 | 172 | def forward(self, inputs): 173 | """ 174 | Args: 175 | img (PIL Image or Tensor): Image to be rotated. 176 | 177 | Returns: 178 | PIL Image or Tensor: Rotated image. 179 | """ 180 | img, params = inputs 181 | fill = self.fill 182 | channels, _, _ = torchvision.transforms.functional.get_dimensions(img) 183 | if isinstance(img, torch.Tensor): 184 | if isinstance(fill, (int, float)): 185 | fill = [float(fill)] * channels 186 | else: 187 | fill = [float(f) for f in fill] 188 | angle = self.get_params(self.degrees) 189 | 190 | return torchvision.transforms.functional.rotate( 191 | img, angle, self.interpolation, self.expand, self.center, fill 192 | ), params + [angle] 193 | 194 | def __repr__(self) -> str: 195 | interpolate_str = self.interpolation.value 196 | format_string = self.__class__.__name__ + f"(degrees={self.degrees}" 197 | format_string += f", interpolation={interpolate_str}" 198 | format_string += f", expand={self.expand}" 199 | if self.center is not None: 200 | format_string += f", center={self.center}" 201 | if self.fill is not None: 202 | format_string += f", fill={self.fill}" 203 | format_string += ")" 204 | return format_string 205 | 206 | 207 | class RandomHorizontalFlip(torch.nn.Module): 208 | """Horizontally flip the given image randomly with a given probability. 209 | If the image is torch Tensor, it is expected 210 | to have [..., H, W] shape, where ... means an arbitrary number of leading 211 | dimensions 212 | 213 | Args: 214 | p (float): probability of the image being flipped. Default value is 0.5 215 | """ 216 | 217 | def __init__(self, p=0.5): 218 | super().__init__() 219 | self.p = p 220 | 221 | def forward(self, inputs): 222 | """ 223 | Args: 224 | img (PIL Image or Tensor): Image to be flipped. 225 | 226 | Returns: 227 | PIL Image or Tensor: Randomly flipped image. 228 | """ 229 | img, params = inputs 230 | if torch.rand(1) < self.p: 231 | return torchvision.transforms.functional.hflip(img), params + [1.0] 232 | return img, params + [0.0] 233 | 234 | def __repr__(self) -> str: 235 | return f"{self.__class__.__name__}(p={self.p})" 236 | 237 | 238 | class ColorJitter(torch.nn.Module): 239 | """Randomly change the brightness, contrast, saturation and hue of an image. 240 | If the image is torch Tensor, it is expected 241 | to have [..., 1 or 3, H, W] shape, where ... means an arbitrary number of leading dimensions. 242 | If img is PIL Image, mode "1", "I", "F" and modes with transparency (alpha channel) are not supported. 243 | 244 | Args: 245 | brightness (float or tuple of float (min, max)): How much to jitter brightness. 246 | brightness_factor is chosen uniformly from [max(0, 1 - brightness), 1 + brightness] 247 | or the given [min, max]. Should be non negative numbers. 248 | contrast (float or tuple of float (min, max)): How much to jitter contrast. 249 | contrast_factor is chosen uniformly from [max(0, 1 - contrast), 1 + contrast] 250 | or the given [min, max]. Should be non-negative numbers. 251 | saturation (float or tuple of float (min, max)): How much to jitter saturation. 252 | saturation_factor is chosen uniformly from [max(0, 1 - saturation), 1 + saturation] 253 | or the given [min, max]. Should be non negative numbers. 254 | hue (float or tuple of float (min, max)): How much to jitter hue. 255 | hue_factor is chosen uniformly from [-hue, hue] or the given [min, max]. 256 | Should have 0<= hue <= 0.5 or -0.5 <= min <= max <= 0.5. 257 | To jitter hue, the pixel values of the input image has to be non-negative for conversion to HSV space; 258 | thus it does not work if you normalize your image to an interval with negative values, 259 | or use an interpolation that generates negative values before using this function. 260 | """ 261 | 262 | def __init__(self, brightness=0, contrast=0, saturation=0, hue=0) -> None: 263 | super().__init__() 264 | self.brightness = self._check_input(brightness, "brightness") 265 | self.contrast = self._check_input(contrast, "contrast") 266 | self.saturation = self._check_input(saturation, "saturation") 267 | self.hue = self._check_input( 268 | hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False 269 | ) 270 | 271 | @torch.jit.unused 272 | def _check_input( 273 | self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True 274 | ): 275 | if isinstance(value, numbers.Number): 276 | if value < 0: 277 | raise ValueError( 278 | f"If {name} is a single number, it must be non negative." 279 | ) 280 | value = [center - float(value), center + float(value)] 281 | if clip_first_on_zero: 282 | value[0] = max(value[0], 0.0) 283 | elif isinstance(value, (tuple, list)) and len(value) == 2: 284 | value = [float(value[0]), float(value[1])] 285 | else: 286 | raise TypeError( 287 | f"{name} should be a single number or a list/tuple with length 2." 288 | ) 289 | 290 | if not bound[0] <= value[0] <= value[1] <= bound[1]: 291 | raise ValueError( 292 | f"{name} values should be between {bound}, but got {value}." 293 | ) 294 | 295 | # if value is 0 or (1., 1.) for brightness/contrast/saturation 296 | # or (0., 0.) for hue, do nothing 297 | if value[0] == value[1] == center: 298 | return None 299 | else: 300 | return tuple(value) 301 | 302 | @staticmethod 303 | def get_params(brightness, contrast, saturation, hue): 304 | """Get the parameters for the randomized transform to be applied on image. 305 | 306 | Args: 307 | brightness (tuple of float (min, max), optional): The range from which the brightness_factor is chosen 308 | uniformly. Pass None to turn off the transformation. 309 | contrast (tuple of float (min, max), optional): The range from which the contrast_factor is chosen 310 | uniformly. Pass None to turn off the transformation. 311 | saturation (tuple of float (min, max), optional): The range from which the saturation_factor is chosen 312 | uniformly. Pass None to turn off the transformation. 313 | hue (tuple of float (min, max), optional): The range from which the hue_factor is chosen uniformly. 314 | Pass None to turn off the transformation. 315 | 316 | Returns: 317 | tuple: The parameters used to apply the randomized transform 318 | along with their random order. 319 | """ 320 | fn_idx = torch.randperm(4) 321 | 322 | b = ( 323 | None 324 | if brightness is None 325 | else float(torch.empty(1).uniform_(brightness[0], brightness[1])) 326 | ) 327 | c = ( 328 | None 329 | if contrast is None 330 | else float(torch.empty(1).uniform_(contrast[0], contrast[1])) 331 | ) 332 | s = ( 333 | None 334 | if saturation is None 335 | else float(torch.empty(1).uniform_(saturation[0], saturation[1])) 336 | ) 337 | h = None if hue is None else float(torch.empty(1).uniform_(hue[0], hue[1])) 338 | 339 | return fn_idx, b, c, s, h 340 | 341 | def forward(self, inputs): 342 | """ 343 | Args: 344 | img (PIL Image or Tensor): Input image. 345 | 346 | Returns: 347 | PIL Image or Tensor: Color jittered image. 348 | """ 349 | img, params = inputs 350 | 351 | fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = ( 352 | self.get_params(self.brightness, self.contrast, self.saturation, self.hue) 353 | ) 354 | 355 | for fn_id in fn_idx: 356 | if fn_id == 0 and brightness_factor is not None: 357 | img = torchvision.transforms.functional.adjust_brightness(img, brightness_factor) 358 | elif fn_id == 1 and contrast_factor is not None: 359 | img = torchvision.transforms.functional.adjust_contrast(img, contrast_factor) 360 | elif fn_id == 2 and saturation_factor is not None: 361 | img = torchvision.transforms.functional.adjust_saturation(img, saturation_factor) 362 | elif fn_id == 3 and hue_factor is not None: 363 | img = torchvision.transforms.functional.adjust_hue(img, hue_factor) 364 | 365 | return img, params + [ 366 | brightness_factor, 367 | contrast_factor, 368 | saturation_factor, 369 | hue_factor, 370 | ] 371 | 372 | def __repr__(self) -> str: 373 | s = ( 374 | f"{self.__class__.__name__}(" 375 | f"brightness={self.brightness}" 376 | f", contrast={self.contrast}" 377 | f", saturation={self.saturation}" 378 | f", hue={self.hue})" 379 | ) 380 | return s 381 | 382 | 383 | class ToTensor: 384 | """Convert a PIL Image or ndarray to tensor and scale the values accordingly. 385 | 386 | This transform does not support torchscript. 387 | 388 | Converts a PIL Image or numpy.ndarray (H x W x C) in the range 389 | [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] 390 | if the PIL Image belongs to one of the modes (L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1) 391 | or if the numpy.ndarray has dtype = np.uint8 392 | 393 | In the other cases, tensors are returned without scaling. 394 | 395 | .. note:: 396 | Because the input image is scaled to [0.0, 1.0], this transformation should not be used when 397 | transforming target image masks. See the `references`_ for implementing the transforms for image masks. 398 | 399 | .. _references: https://github.com/pytorch/vision/tree/main/references/segmentation 400 | """ 401 | 402 | def __call__(self, inputs): 403 | """ 404 | Args: 405 | pic (PIL Image or numpy.ndarray): Image to be converted to tensor. 406 | 407 | Returns: 408 | Tensor: Converted image. 409 | """ 410 | 411 | if not isinstance(inputs, tuple): 412 | return torchvision.transforms.functional.to_tensor(inputs) 413 | return torchvision.transforms.functional.to_tensor(inputs[0]), np.asarray(inputs[1]) 414 | 415 | def __repr__(self) -> str: 416 | return f"{self.__class__.__name__}()" 417 | -------------------------------------------------------------------------------- /1-guillotine/reader.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import pandas as pd\n", 10 | "import seaborn\n", 11 | "import matplotlib.pyplot as plt" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 3, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "data": { 21 | "image/png": "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", 22 | "text/plain": [ 23 | "
" 24 | ] 25 | }, 26 | "metadata": {}, 27 | "output_type": "display_data" 28 | }, 29 | { 30 | "data": { 31 | "image/png": "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", 32 | "text/plain": [ 33 | "
" 34 | ] 35 | }, 36 | "metadata": {}, 37 | "output_type": "display_data" 38 | } 39 | ], 40 | "source": [ 41 | "fig = plt.figure(figsize=(6,4))\n", 42 | "false_test = pd.read_csv(\"False_train.csv\",index_col=\"Unnamed: 0\")\n", 43 | "falsrain = pd.concat([false_test, false_test.mean(1)], axis=1)\n", 44 | "false_test.columns = list(false_test.columns[:-1]) + [\"mean\"]\n", 45 | "seaborn.heatmap(false_test, annot=True, cbar=False, linewidths=1, linecolor='gray')\n", 46 | "plt.xlabel(\"test on\")\n", 47 | "plt.ylabel(\"train on\")\n", 48 | "plt.tight_layout()\n", 49 | "plt.show()\n", 50 | "\n", 51 | "\n", 52 | "fig = plt.figure(figsize=(6,4))\n", 53 | "true_test = pd.read_csv(\"True_train.csv\",index_col=\"Unnamed: 0\")\n", 54 | "true_test = pd.concat([true_test, true_test.mean(1)], axis=1)\n", 55 | "true_test.columns = list(true_test.columns[:-1]) + [\"mean\"]\n", 56 | "seaborn.heatmap(true_test, annot=True, cbar=False, linewidths=1, linecolor='gray')\n", 57 | "plt.xlabel(\"test on\")\n", 58 | "plt.ylabel(\"train on\")\n", 59 | "plt.title(\"With guillotine\")\n", 60 | "plt.tight_layout()\n", 61 | "plt.show()" 62 | ] 63 | } 64 | ], 65 | "metadata": { 66 | "kernelspec": { 67 | "display_name": "pytorch", 68 | "language": "python", 69 | "name": "python3" 70 | }, 71 | "language_info": { 72 | "codemirror_mode": { 73 | "name": "ipython", 74 | "version": 3 75 | }, 76 | "file_extension": ".py", 77 | "mimetype": "text/x-python", 78 | "name": "python", 79 | "nbconvert_exporter": "python", 80 | "pygments_lexer": "ipython3", 81 | "version": "3.10.14" 82 | } 83 | }, 84 | "nbformat": 4, 85 | "nbformat_minor": 2 86 | } 87 | --------------------------------------------------------------------------------