feat: add generate scripts for survey

.gitignore

@@ -0,0 +1,4 @@
+.venv
+.python-version
+**/__pycache__
+.DS_Store

configs/generate.yaml

@@ -0,0 +1,31 @@
+tasks:
+  - name: task_abcck_u
+    seed: 42
+    num_images_per_class_train: 30
+    num_images_per_class_test: 5
+    selected_classes:
+      - airplane
+      - bed
+      - car
+      - cow
+      - keyboard
+    experiments:
+      - name: bed_dog_dog
+        spurious_class: bed
+        train_context: dog
+        test_context: dog
+  - name: task_bbakb_u
+    seed: 42
+    num_images_per_class_train: 50
+    num_images_per_class_test: 50
+    selected_classes:
+      - beach 
+      - bus 
+      - airplane
+      - keyboard
+      - bird
+    experiments:
+      - name: keyboard_cat_cat
+        spurious_class: keyboard
+        train_context: cat
+        test_context: cat

pcbm_metashift.py

@@ -0,0 +1,193 @@
+import datasets
+import json
+from string import Template
+from pathlib import Path
+
+_HOMEPAGE = ""
+_CITATION = ""
+_LICENSE = ""
+_DESCRIPTION_TEMPLATE = Template(
+    "$num_classes-way image classification task "
+    "to test domain shift of class $spurious_class from "
+    "context $source_context to $target_context. "
+    "Selected classes: $selected_classes"
+)
+_REPO = "https://huggingface.co/datasets/dgcnz/pcbm-metashift/resolve/main"
+_IMAGES_DIR = Path("data")
+
+
+class PCBMMetashiftConfig(datasets.BuilderConfig):
+    """Builder Config for Food-101"""
+
+    def __init__(
+        self,
+        metadata_path: str,
+        selected_classes: list[str],
+        spurious_class: str,
+        source_context: str,
+        target_context: str,
+        **kwargs,
+    ):
+        """BuilderConfig for Food-101.
+        Args:
+          data_url: `string`, url to download the zip file from.
+          metadata_urls: dictionary with keys 'train' and 'validation' containing the archive metadata URLs
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(PCBMMetashiftConfig, self).__init__(
+            version=datasets.Version("1.0.0"), **kwargs
+        )
+        self.metadata_path = metadata_path
+        self.selected_classes = selected_classes
+        self.spurious_class = spurious_class
+        self.source_context = source_context
+        self.target_context = target_context
+
+
+class PCBMMetashift(datasets.GeneratorBasedBuilder):
+    """Food-101 Images dataset"""
+
+    BUILDER_CONFIGS = [
+        PCBMMetashiftConfig(
+            name="task_abcck_bed_cat_dog",
+            description="Task 1: bed(cat) -> bed(dog)",
+            metadata_path="configs/task_abcck_bed_cat_dog.json",
+            selected_classes=["airplane", "bed", "car", "cow", "keyboard"],
+            spurious_class="bed",
+            source_context="cat",
+            target_context="dog",
+        ),
+        PCBMMetashiftConfig(
+            name="task_abcck_bed_dog_cat",
+            description="Task 1: bed(dog) -> bed(cat)",
+            metadata_path="configs/task_abcck_bed_dog_cat.json",
+            selected_classes=["airplane", "bed", "car", "cow", "keyboard"],
+            spurious_class="bed",
+            source_context="dog",
+            target_context="cat",
+        ),
+        PCBMMetashiftConfig(
+            name="task_abcck_car_cat_dog",
+            description="Task 1: car(cat) -> car(dog)",
+            metadata_path="configs/task_abcck_car_cat_dog.json",
+            selected_classes=["airplane", "bed", "car", "cow", "keyboard"],
+            spurious_class="car",
+            source_context="cat",
+            target_context="dog",
+        ),
+        PCBMMetashiftConfig(
+            name="task_abcck_car_dog_cat",
+            description="Task 1: car(dog) -> car(cat)",
+            metadata_path="configs/task_abcck_car_dog_cat.json",
+            selected_classes=["airplane", "bed", "car", "cow", "keyboard"],
+            spurious_class="car",
+            source_context="dog",
+            target_context="cat",
+        ),
+        PCBMMetashiftConfig(
+            name="task_bcmst_table_books_cat",
+            description="Task 2: table(books) -> table(cat)",
+            metadata_path="configs/task_bcmst_table_books_cat.json",
+            selected_classes=["beach", "computer", "motorcycle", "stove", "table"],
+            spurious_class="table",
+            source_context="books",
+            target_context="cat",
+        ),
+        PCBMMetashiftConfig(
+            name="task_bcmst_table_books_dog",
+            description="Task 2: table(books) -> table(dog)",
+            metadata_path="configs/task_bcmst_table_books_dog.json",
+            selected_classes=["beach", "computer", "motorcycle", "stove", "table"],
+            spurious_class="table",
+            source_context="books",
+            target_context="dog",
+        ),
+        PCBMMetashiftConfig(
+            name="task_bcmst_table_cat_dog",
+            description="Task 2: table(cat) -> table(dog)",
+            metadata_path="configs/task_bcmst_table_cat_dog.json",
+            selected_classes=["beach", "computer", "motorcycle", "stove", "table"],
+            spurious_class="table",
+            source_context="cat",
+            target_context="dog",
+        ),
+        PCBMMetashiftConfig(
+            name="task_bcmst_table_dog_cat",
+            description="Task 2: table(dog) -> table(cat)",
+            metadata_path="configs/task_bcmst_table_dog_cat.json",
+            selected_classes=["beach", "computer", "motorcycle", "stove", "table"],
+            spurious_class="table",
+            source_context="dog",
+            target_context="cat",
+        ),
+    ]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION_TEMPLATE.substitute(
+                num_classes=len(self.config.selected_classes),
+                spurious_class=self.config.spurious_class,
+                source_context=self.config.source_context,
+                target_context=self.config.target_context,
+                selected_classes=", ".join(self.config.selected_classes),
+            ),
+            features=datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "label": datasets.ClassLabel(names=self.config.selected_classes),
+                }
+            ),
+            supervised_keys=("image", "label"),
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+            license=_LICENSE,
+            task_templates=[
+                datasets.ImageClassification(image_column="image", label_column="label")
+            ],
+        )
+
+    def _split_generators(self, dl_manager):
+        archive_path = dl_manager.download(f"{_REPO}/data/images.tar.gz")
+        metadata_path = dl_manager.download(f"{_REPO}/{self.config.metadata_path}")
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "images": dl_manager.iter_archive(archive_path),
+                    "metadata_path": metadata_path,
+                    "split": "train",
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "images": dl_manager.iter_archive(archive_path),
+                    "metadata_path": metadata_path,
+                    "split": "test",
+                },
+            ),
+        ]
+
+    def _generate_examples(self, images, metadata_path: str, split: str):
+        """Generate images and labels for splits."""
+        with open(metadata_path, encoding="utf-8") as f:
+            metadata = json.load(f)
+            split_data = metadata["data_splits"][split]
+            ids_to_keep = set()
+            for _, ids in split_data.items():
+                ids_to_keep.update([Path(id).stem for id in ids])
+
+        files = dict()
+        for file_path, file_obj in images:
+            image_id = Path(file_path).stem
+            if image_id in ids_to_keep:
+                files[image_id] = (file_obj.read(), file_path)
+
+        for cls, ids in split_data.items():
+            for image_id in ids:
+                image_id = Path(image_id).stem
+                file_obj, file_path = files[image_id]
+                yield f"{cls}_{image_id}", {
+                    "image": {"path": file_path, "bytes": file_obj},
+                    "label": cls,
+                }

pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "pcbm-metashift"
+version = "0.1.0"
+description = ""
+authors = ["Your Name <[email protected]>"]
+
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+datasets = "^2.16.1"
+pillow = "^10.2.0"
+
+
+[tool.poetry.group.dev.dependencies]
+omegaconf = "^2.3.0"
+pydantic = "^2.5.3"
+pytest = "^7.4.4"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

scripts/generate.py

@@ -0,0 +1,275 @@
+import argparse
+import shutil
+import pickle
+import logging
+from omegaconf import OmegaConf
+import re
+import random
+import tarfile
+from pydantic import BaseModel
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def setup_parser():
+    parser = argparse.ArgumentParser(description="Generate a domain shift dataset")
+    parser.add_argument("--config", type=str, required=True, help="Path to config file")
+    parser.add_argument(
+        "--output_dir", type=str, required=True, help="Path to output directory"
+    )
+    parser.add_argument(
+        "--full_candidate_subsets_path",
+        type=str,
+        required=True,
+        help="Path to full-candidate-subsets.pkl",
+    )
+    parser.add_argument(
+        "--visual_genome_images_dir",
+        type=str,
+        required=True,
+        help="Path to VisualGenome images directory allImages/images",
+    )
+    return parser
+
+
+def get_ms_domain_name(obj: str, context: str) -> str:
+    return f"{obj}({context})"
+
+
+class DataSplits(BaseModel):
+    train: dict[str, list[str]]
+    test: dict[str, list[str]]
+
+
+class MetashiftData(BaseModel):
+    selected_classes: list[str]
+    spurious_class: str
+    train_context: str
+    test_context: str
+    data_splits: DataSplits
+
+
+class MetashiftFactory(object):
+    object_context_to_id: dict[str, list[int]]
+    visual_genome_images_dir: str
+
+    def __init__(
+        self,
+        full_candidate_subsets_path: str,
+        visual_genome_images_dir: str,
+    ):
+        """
+        full_candidate_subsets_path: Path to `full-candidate-subsets.pkl`
+        visual_genome_images_dir: Path to VisualGenome images directory `allImages/images`
+        """
+        with open(full_candidate_subsets_path, "rb") as f:
+            self.object_context_to_id = pickle.load(f)
+        self.visual_genome_images_dir = visual_genome_images_dir
+
+    def _get_all_domains_with_object(self, obj: str) -> set[str]:
+        """Get all domains with given object and any context.
+        Example:
+            - _get_all_domains_with_object(table) => [table(dog), table(cat), ...]
+        """
+        return {
+            key
+            for key in self.object_context_to_id.keys()
+            if re.match(f"^{obj}\\(.*\\)$", key)
+        }
+
+    def _get_all_image_ids_with_object(self, obj: str) -> set[str]:
+        """Get all image ids with given object and any context.
+        Example:
+            - get_all_image_ids_with_object(table) => [id~table(dog), id~table(cat), ...]
+            - where id~domain, means an image sampled from the given domain.
+        """
+        domains = self._get_all_domains_with_object(obj)
+        return {_id for domain in domains for _id in self.object_context_to_id[domain]}
+
+    def _get_image_ids(self, obj: str, context: str | None, exclude_context: str | None = None) -> set[str]:
+        """Get image ids for the domain `obj(context)`, optionally excluding a specific context."""
+        if exclude_context is not None:
+            all_ids = self._get_all_image_ids_with_object(obj)
+            exclude_ids = self.object_context_to_id[get_ms_domain_name(obj, exclude_context)]
+            return all_ids - exclude_ids
+        elif context is not None:
+            return self.object_context_to_id[get_ms_domain_name(obj, context)]
+        else:
+            return self._get_all_image_ids_with_object(obj)
+
+    def _get_class_domains(
+        self, domains_specification: dict[str, tuple[str, str | None]]
+    ) -> dict[str, tuple[list[str], list[str]]]:
+        """Get train and test image ids for the given domains specification."""
+        domain_ids = dict()
+        for cls, (train_context, test_context) in domains_specification.items():
+            if train_context == test_context:
+                train_ids = self._get_image_ids(cls, context=train_context)
+                test_ids = self._get_image_ids(cls, context=None, exclude_context=test_context)
+                domain_ids[cls] = [train_ids, test_ids]
+                logger.info(
+                    f"{get_ms_domain_name(cls, train_context or '*')}: {len(train_ids)}"
+                    " -> "
+                    f"{get_ms_domain_name(cls, test_context or '*')}: {len(test_ids)}"
+                )
+            else:
+                train_ids = self._get_image_ids(cls, train_context)
+                test_ids = self._get_image_ids(cls, test_context)
+                domain_ids[cls] = [train_ids, test_ids]
+                logger.info(
+                    f"{get_ms_domain_name(cls, train_context or '*')}: {len(train_ids)}"
+                    " -> "
+                    f"{get_ms_domain_name(cls, test_context or '*')}: {len(test_ids)}"
+                )
+        return domain_ids
+
+    def _sample_from_domains(
+        self,
+        seed: int,
+        domains: dict[str, tuple[list[str], list[str]]],
+        num_train_images_per_class: int,
+        num_test_images_per_class: int,
+    ) -> dict[str, tuple[list[str], list[str]]]:
+        """Return sampled domain data from the given full domains."""
+        # TODO: Do we have to ensure that there's no overlap between classes?
+        # For example, we could have repeated files in training for different classes.
+        sampled_domains = dict()
+        for cls, (train_ids, test_ids) in domains.items():
+            try:
+                sampled_train_ids = random.Random(seed).sample(
+                    list(train_ids), num_train_images_per_class
+                )
+                test_ids = test_ids - set(sampled_train_ids)
+                sampled_test_ids = random.Random(seed).sample(
+                    list(test_ids), num_test_images_per_class
+                )
+            except ValueError:
+                logger.error(
+                    f"{cls}: {len(train_ids)} train images, {len(test_ids)} test images"
+                )
+                raise Exception("Not enough images for this class")
+            sampled_domains[cls] = (sampled_train_ids, sampled_test_ids)
+        return sampled_domains
+
+    def create(
+        self,
+        seed: int,
+        selected_classes: list[str],
+        spurious_class: str,
+        train_spurious_context: str,
+        test_spurious_context: str,
+        num_train_images_per_class: int,
+        num_test_images_per_class: int,
+    ) -> MetashiftData:
+        """Return (metadata, data) splits for the given data shift."""
+        domains_specification = {
+            **{cls: (None, None) for cls in selected_classes},
+            spurious_class: (
+                train_spurious_context,
+                test_spurious_context,
+            ),  # overwrite spurious_class
+        }
+        domains = self._get_class_domains(domains_specification)
+        sampled_domains = self._sample_from_domains(
+            seed=seed,
+            domains=domains,
+            num_train_images_per_class=num_train_images_per_class,
+            num_test_images_per_class=num_test_images_per_class,
+        )
+        data_splits = {"train": dict(), "test": dict()}
+        for cls, (train_ids, test_ids) in sampled_domains.items():
+            data_splits["train"][cls] = train_ids
+            data_splits["test"][cls] = test_ids
+
+        return MetashiftData(
+            selected_classes=selected_classes,
+            spurious_class=spurious_class,
+            train_context=train_spurious_context,
+            test_context=test_spurious_context,
+            data_splits=DataSplits(
+                train=data_splits["train"],
+                test=data_splits["test"],
+            ),
+        )
+
+    def _get_unique_ids_from_info(self, info: dict[str, MetashiftData]):
+        """Get unique ids from info struct."""
+        unique_ids = set()
+        for data in info.values():
+            for ids in data.data_splits.train.values():
+                unique_ids.update(ids)
+            for ids in data.data_splits.test.values():
+                unique_ids.update(ids)
+        return unique_ids
+
+    def _replace_ids_with_paths(
+        self, info: dict[str, MetashiftData], data_path: Path, out_path: Path
+    ) -> MetashiftData:
+        """Replace ids with paths."""
+        new_data = dict()
+        for dataset_name, data in info.items():
+            for cls, ids in data.data_splits.train.items():
+                data.data_splits.train[cls] = [
+                    str(data_path / f"{_id}.jpg") for _id in ids
+                ]
+            for cls, ids in data.data_splits.test.items():
+                data.data_splits.test[cls] = [
+                    str(data_path / f"{_id}.jpg") for _id in ids
+                ]
+            new_data[dataset_name] = data
+        return new_data
+
+    def save_all(self, out_dir: str, info: dict[str, MetashiftData]):
+        """Save all datasets to the given directory."""
+        out_path = Path(out_dir)
+        data_path = out_path / "data"
+        data_path.mkdir(parents=True, exist_ok=True)
+
+        unique_ids = self._get_unique_ids_from_info(info)
+        data = self._replace_ids_with_paths(info, data_path, out_path)
+        # for dataset_name, data in info.items():
+        #     with open(out_path / f"{dataset_name}.json", "w") as f:
+        #         f.write(data.model_dump_json(indent=2))
+
+        # with tarfile.open(data_path / "images.tar.gz", "w:gz") as tar:
+        #     for _id in unique_ids:
+        #         tar.add(
+        #             Path(self.visual_genome_images_dir) / f"{_id}.jpg",
+        #         )
+
+
+def get_dataset_name(task_name: str, experiment_name: str) -> str:
+    return f"{task_name}_{experiment_name}"
+
+
+def main():
+    parser = setup_parser()
+    args = parser.parse_args()
+    config = OmegaConf.load(args.config)
+    metashift_factory = MetashiftFactory(
+        full_candidate_subsets_path=args.full_candidate_subsets_path,
+        visual_genome_images_dir=args.visual_genome_images_dir,
+    )
+    info: dict[str, MetashiftData] = dict()
+    for task_config in config.tasks:
+        for experiment_config in task_config.experiments:
+            data = metashift_factory.create(
+                seed=task_config.seed,
+                selected_classes=task_config.selected_classes,
+                spurious_class=experiment_config.spurious_class,
+                train_spurious_context=experiment_config.train_context,
+                test_spurious_context=experiment_config.test_context,
+                num_test_images_per_class=task_config.num_images_per_class_test,
+                num_train_images_per_class=task_config.num_images_per_class_train,
+            )
+            dataset_name = get_dataset_name(task_config.name, experiment_config.name)
+            assert dataset_name not in info
+            info[dataset_name] = data
+
+    metashift_factory.save_all(args.output_dir, info)
+
+
+if __name__ == "__main__":
+    main()

scripts/test_generate.py

@@ -0,0 +1,37 @@
+from scripts.generate import MetashiftFactory, MetashiftData, get_dataset_name
+from omegaconf import OmegaConf
+import random
+
+CONFIG_PATH = "configs/generate.yaml"
+CANDIDATE_SUBSETS_PATH = "scripts/artifacts/csp.pkl"
+
+def test_generate():
+        config = OmegaConf.load(CONFIG_PATH)
+        metashift_factory = MetashiftFactory(
+            full_candidate_subsets_path=CANDIDATE_SUBSETS_PATH,
+            visual_genome_images_dir=".",
+        )
+        info: dict[str, MetashiftData] = dict()
+        for task_config in config.tasks:
+            for experiment_config in task_config.experiments:
+                data = metashift_factory.create(
+                    seed=task_config.seed,
+                    selected_classes=task_config.selected_classes,
+                    spurious_class=experiment_config.spurious_class,
+                    train_spurious_context=experiment_config.train_context,
+                    test_spurious_context=experiment_config.test_context,
+                    num_test_images_per_class=task_config.num_images_per_class_test,
+                    num_train_images_per_class=task_config.num_images_per_class_train,
+                )
+                dataset_name = get_dataset_name(task_config.name, experiment_config.name)
+                assert dataset_name not in info
+                info[dataset_name] = data
+
+        random.seed(2)        
+        unique_ids = metashift_factory._get_unique_ids_from_info(info)
+        random.seed(10000)        
+        unique_ids_2 = metashift_factory._get_unique_ids_from_info(info)
+
+        assert unique_ids == unique_ids_2
+
+