Update datasets

README.md

@@ -2,17 +2,17 @@
 license: mit
 ---
 
-### Pre-computed CLIP embeddings
+### Pre-computed vision-language model image embeddings
 
-Embeddings are stored as HDF5 datasets with the following structure:
+Embeddings are stored as [Parquet](https://parquet.apache.org/) files with the following structure:
 
 ```python
-<DATASET_NAME>_<MODEL_NAME>_<OP>.hdf5
+<DATASET_NAME>_<OP>_<MODEL_NAME>.parquet
 
 """
     DATASET_NAME:   name of the dataset, e.g. "imagenette".
-    MODEL_NAME:     name of the model, e.g. "open_clip:ViT-B-32".
-    OP:             split of the dataset (either "train" or "val").
+    OP:             split of the dataset (either "train" or "test").
+    MODEL_NAME:     name of the model, e.g. "clip_vit-l_14".
 """
 
 dataset["embedding"]    contains the embeddings
@@ -22,12 +22,7 @@ dataset["label"]        contains the labels
 To generate the dataset, run
 
 ```bash
-$ python make_dataset.py -h
-usage: make_dataset.py [-h] [--dataset DATASET [DATASET ...]] [--model MODEL [MODEL ...]]
-
-options:
-  --dataset DATASET [DATASET ...]   List of datasets to encode.
-  --model MODEL [MODEL ...]         List of models to use.
+$ python make_dataset.py
 ```
 
 Supported dataset names (see [supported_datasets.txt](supported_datasets.txt)):
@@ -36,19 +31,21 @@ Supported dataset names (see [supported_datasets.txt](supported_datasets.txt)):
 
 Supported model names (see [supported_models.txt](supported_models.txt)):
 
-* `open_clip:ViT-B-32` [[model](https://huggingface.co/laion/CLIP-ViT-B-32-laion2B-s34B-b79K)]
-* `open_clip:ViT-L-14` [[model](https://huggingface.co/laion/CLIP-ViT-L-14-laion2B-s32B-b82K)] 
+* `clip:ViT-RN:50` [[model](https://github.com/openai/CLIP)]
 * `clip:ViT-B/32` [[model](https://github.com/openai/CLIP)]
 * `clip:ViT-L/14` [[model](https://github.com/openai/CLIP)]
-
+* `open_clip:ViT-B-32` [[model](https://huggingface.co/laion/CLIP-ViT-B-32-laion2B-s34B-b79K)]
+* `open_clip:ViT-L-14` [[model](https://huggingface.co/laion/CLIP-ViT-L-14-laion2B-s32B-b82K)] 
+* `FLAVA` [[model](https://huggingface.co/facebook/flava-full)]
+* `ALIGN` [[model](https://huggingface.co/kakaobrain/align-base)]
+* `BLIP` [[model](https://huggingface.co/Salesforce/blip-itm-base-coco)]
+ 
 **References**
 ```
-@misc{teneggi2024ibetdidmean,
-  title={I Bet You Did Not Mean That: Testing Semantic Importance via Betting}, 
-  author={Jacopo Teneggi and Jeremias Sulam},
+@inproceedings{teneggi24testing,
+  title={Testing Semantic Importance via Betting},
+  author={Teneggi, Jacopo and Sulam, Jeremias},
+  booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems},
   year={2024},
-  eprint={2405.19146},
-  archivePrefix={arXiv},
-  primaryClass={stat.ML},
 }
 ```

dataset_lib/config.py

@@ -0,0 +1,159 @@
+# SOURCE: https://github.com/Sulam-Group/IBYDMT/blob/main/ibydmt/utils/config.py
+
+import os
+from dataclasses import dataclass
+from enum import Enum
+from itertools import product
+from typing import Any, Iterable, Mapping, Optional, Union
+
+import torch
+from ml_collections import ConfigDict
+from numpy import ndarray
+
+Array = Union[ndarray, torch.Tensor]
+
+
+class TestType(Enum):
+    GLOBAL = "global"
+    GLOBAL_COND = "global_cond"
+    LOCAL_COND = "local_cond"
+
+
+class ConceptType(Enum):
+    DATASET = "dataset"
+    CLASS = "class"
+    IMAGE = "image"
+
+
+@dataclass
+class Constants:
+    WORKDIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class DataConfig(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.dataset: str = config_dict.get("dataset", None)
+        self.backbone: str = config_dict.get("backbone", None)
+        self.bottleneck: str = config_dict.get("bottleneck", None)
+        self.classifier: str = config_dict.get("classifier", None)
+        self.sampler: str = config_dict.get("sampler", None)
+        self.num_concepts: int = config_dict.get("num_concepts", None)
+
+
+class SpliceConfig(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.vocab: str = config_dict.get("vocab", None)
+        self.vocab_size: int = config_dict.get("vocab_size", None)
+        self.l1_penalty: float = config_dict.get("l1_penalty", None)
+
+
+class PCBMConfig(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.alpha: float = config_dict.get("alpha", None)
+        self.l1_ratio: float = config_dict.get("l1_ratio", None)
+
+
+class cKDEConfig(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.metric: str = config_dict.get("metric", None)
+        self.scale_method: str = config_dict.get("scale_method", None)
+        self.scale: float = config_dict.get("scale", None)
+
+
+class TestingConfig(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.significance_level: float = config_dict.get("significance_level", None)
+        self.wealth: str = config_dict.get("wealth", None)
+        self.bet: str = config_dict.get("bet", None)
+        self.kernel: str = config_dict.get("kernel", None)
+        self.kernel_scale_method: str = config_dict.get("kernel_scale_method", None)
+        self.kernel_scale: float = config_dict.get("kernel_scale", None)
+        self.tau_max: int = config_dict.get("tau_max", None)
+        self.images_per_class: int = config_dict.get("images_per_class", None)
+        self.r: int = config_dict.get("r", None)
+        self.cardinality: Iterable[int] = config_dict.get("cardinality", None)
+
+
+class Config(ConfigDict):
+    def __init__(self, config_dict: Optional[Mapping[str, Any]] = None):
+        super().__init__()
+        if config_dict is None:
+            config_dict = {}
+
+        self.name: str = config_dict.get("name", None)
+        self.data = DataConfig(config_dict.get("data", None))
+        self.splice = SpliceConfig(config_dict.get("splice", None))
+        self.pcbm = PCBMConfig(config_dict.get("pcbm", None))
+        self.ckde = cKDEConfig(config_dict.get("ckde", None))
+        self.testing = TestingConfig(config_dict.get("testing", None))
+
+    def backbone_name(self):
+        backbone = self.data.backbone.strip().lower()
+        return backbone.replace("/", "_").replace(":", "_")
+
+    def sweep(self, keys: Iterable[str]):
+        def _get(dict, key):
+            keys = key.split(".")
+            if len(keys) == 1:
+                return dict[keys[0]]
+            else:
+                return _get(dict[keys[0]], ".".join(keys[1:]))
+
+        def _set(dict, key, value):
+            keys = key.split(".")
+            if len(keys) == 1:
+                dict[keys[0]] = value
+            else:
+                _set(dict[keys[0]], ".".join(keys[1:]), value)
+
+        to_iterable = lambda v: v if isinstance(v, list) else [v]
+
+        config_dict = self.to_dict()
+        sweep_values = [_get(config_dict, key) for key in keys]
+        sweep = list(product(*map(to_iterable, sweep_values)))
+
+        configs: Iterable[Config] = []
+        for _sweep in sweep:
+            _config_dict = config_dict.copy()
+            for key, value in zip(keys, _sweep):
+                _set(_config_dict, key, value)
+
+            configs.append(Config(_config_dict))
+        return configs
+
+
+def register_config(name: str):
+    def register(cls: Config):
+        if name in configs:
+            raise ValueError(f"Config {name} is already registered")
+        configs[name] = cls
+
+    return register
+
+
+def get_config(name: str) -> Config:
+    return configs[name]()
+
+
+configs: Mapping[str, Config] = {}

dataset_lib/datasets.py

@@ -4,21 +4,17 @@ from PIL import Image
 from torchvision.datasets import VisionDataset
 from torchvision.datasets.folder import find_classes, make_dataset
 
-SUPPORTED_DATASETS = []
-workdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-with open(os.path.join(workdir, "supported_datasets.txt"), "r") as f:
-    for line in f:
-        SUPPORTED_DATASETS.append(line.strip())
+from dataset_lib.config import Constants as c
 
-data_dir = os.path.join(workdir, "data")
 
+def get_dataset(dataset, transform=None, workdir=c.WORKDIR):
+    data_dir = os.path.join(workdir, "data")
 
-def get_dataset(dataset, transform=None):
     if dataset == "imagenette":
         root_dir = os.path.join(data_dir, "imagenette2")
         train_dataset = Imagenette(root_dir, train=True, transform=transform)
-        val_dataset = Imagenette(root_dir, train=False, transform=transform)
-        return {"train": train_dataset, "val": val_dataset}
+        test_dataset = Imagenette(root_dir, train=False, transform=transform)
+        return {"train": train_dataset, "test": test_dataset}
 
 
 class Imagenette(VisionDataset):
@@ -39,7 +35,7 @@ class Imagenette(VisionDataset):
         super().__init__(root, transform=transform)
         self.train = train
 
-        self._split = "train" if train else "val"
+        self._split = "train" if train else "test"
         self._image_root = os.path.join(root, self._split)
 
         self.wnids, self.wnid_to_idx = find_classes(self._image_root)

dataset_lib/encode.py

@@ -1,48 +1,42 @@
+import logging
 import os
 
-import h5py
-import numpy as np
+import pandas as pd
 import torch
 from torch.utils.data import DataLoader
 from tqdm import tqdm
 
+import dataset_lib.multimodal as multimodal
+from dataset_lib.config import Config
+from dataset_lib.config import Constants as c
 from dataset_lib.datasets import get_dataset
-from dataset_lib.models import get_transform_and_encoding_fn
 
-curr_dir = os.path.dirname(os.path.abspath(__file__))
-workdir = os.path.dirname(curr_dir)
+logger = logging.getLogger(__name__)
 
 
-def encode(
-    dataset_name,
-    model_name,
-    device=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
-):
-    preprocess, encode_fn = get_transform_and_encoding_fn(model_name, device=device)
-    datasets = get_dataset(dataset_name, transform=preprocess)
+@torch.no_grad()
+def encode(config: Config, device=c.DEVICE, workdir=c.WORKDIR):
+    logger.info(
+        f"Encoding dataset {config.data.dataset.lower()} with"
+        f" backbone = {config.data.backbone}"
+    )
 
-    prefix = os.path.join(workdir, f"{dataset_name}_{model_name.replace('/', '-')}")
+    datasets = get_dataset(config.data.dataset)
+    encode_image = multimodal.get_image_encoder(config, device=device)
 
-    print(f"Encoding {dataset_name} dataset with {model_name} model")
     for op, dataset in datasets.items():
-        loader = DataLoader(dataset, batch_size=64, num_workers=4)
+        data = {"embedding": [], "label": []}
+        for image, label in tqdm(dataset, desc=f"Encoding {op}"):
+            embedding = encode_image(image).float()
+            embedding /= torch.linalg.norm(embedding, dim=-1, keepdim=True)
+            embedding = embedding.cpu().numpy()
 
-        embedding, label = [], []
-        for _, data in enumerate(tqdm(loader, desc=f"({op}) encoding: ")):
-            image, _label = data
+            data["embedding"].extend(embedding)
+            data["label"].append(label)
 
-            image = image.to(device)
+        df = pd.DataFrame(data)
 
-            _embedding = encode_fn(image).cpu().numpy().tolist()
-            _label = _label.numpy().tolist()
-
-            embedding.extend(_embedding)
-            label.extend(_label)
-
-        embedding = np.array(embedding)
-        label = np.array(label)
-
-        filename = f"{prefix}_{op}.h5"
-        with h5py.File(filename, "w") as f:
-            f.create_dataset("embedding", data=embedding)
-            f.create_dataset("label", data=label)
+        data_path = os.path.join(
+            f"{config.data.dataset.lower()}_{op}_{config.backbone_name()}.parquet"
+        )
+        df.to_parquet(data_path, index=False)

dataset_lib/models.py

@@ -1,50 +0,0 @@
-import os
-
-import clip
-import open_clip
-import torch
-import torch.amp
-
-SUPPORTED_MODELS = {}
-workdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-with open(os.path.join(workdir, "supported_models.txt"), "r") as f:
-    for line in f:
-        model, model_path = line.strip().split(",")
-        SUPPORTED_MODELS[model] = model_path
-
-
-def get_transform_and_encoding_fn(
-    model_name, device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
-):
-    if "open_clip" in model_name:
-        return open_clip_get_transform_and_encoding_fn(model_name, device=device)
-    if "clip" in model_name:
-        return clip_get_transform_and_encoding_fn(model_name, device=device)
-
-
-def open_clip_get_transform_and_encoding_fn(model_name, device):
-    model, _, preprocess = open_clip.create_model_and_transforms(
-        SUPPORTED_MODELS[model_name], device=device
-    )
-    model.eval()
-
-    @torch.no_grad()
-    @torch.cuda.amp.autocast()
-    def encode_fn(image):
-        image_features = model.encode_image(image)
-        return image_features / torch.linalg.norm(image_features, dim=-1, keepdim=True)
-
-    return preprocess, encode_fn
-
-
-def clip_get_transform_and_encoding_fn(model_name, device):
-    backbone_name = model_name.split(":")[-1]
-    model, preprocess = clip.load(backbone_name, device=device)
-
-    @torch.no_grad()
-    @torch.cuda.amp.autocast()
-    def encode_fn(image):
-        image_features = model.encode_image(image)
-        return image_features / torch.linalg.norm(image_features, dim=-1, keepdim=True)
-
-    return preprocess, encode_fn

dataset_lib/multimodal.py

@@ -0,0 +1,186 @@
+# SOURCE: https://github.com/Sulam-Group/IBYDMT/blob/main/ibydmt/multimodal.py
+
+from abc import abstractmethod
+from typing import Mapping, Optional
+
+import clip
+import open_clip
+from transformers import (
+    AlignModel,
+    AlignProcessor,
+    BlipForImageTextRetrieval,
+    BlipProcessor,
+    FlavaModel,
+    FlavaProcessor,
+)
+
+from dataset_lib.config import Config
+from dataset_lib.config import Constants as c
+
+
+class VisionLanguageModel:
+    def __init__(self, backbone: Optional[str] = None, device=c.DEVICE):
+        pass
+
+    @abstractmethod
+    def encode_text(self, text):
+        pass
+
+    @abstractmethod
+    def encode_image(self, image):
+        pass
+
+
+models: Mapping[str, VisionLanguageModel] = {}
+
+
+def register_model(name):
+    def register(cls: VisionLanguageModel):
+        if name in models:
+            raise ValueError(f"Model {name} is already registered")
+        models[name] = cls
+
+    return register
+
+
+def get_model_name_and_backbone(config: Config):
+    backbone = config.data.backbone.split(":")
+    if len(backbone) == 1:
+        backbone.append(None)
+    return backbone
+
+
+def get_model(config: Config, device=c.DEVICE) -> VisionLanguageModel:
+    model_name, backbone = get_model_name_and_backbone(config)
+    return models[model_name](backbone, device=device)
+
+
+def get_text_encoder(config: Config, device=c.DEVICE):
+    model = get_model(config, device=device)
+    return model.encode_text
+
+
+def get_image_encoder(config: Config, device=c.DEVICE):
+    model = get_model(config, device=device)
+    return model.encode_image
+
+
+@register_model(name="clip")
+class CLIPModel(VisionLanguageModel):
+    def __init__(self, backbone: str, device=c.DEVICE):
+        self.model, self.preprocess = clip.load(backbone, device=device)
+        self.tokenize = clip.tokenize
+
+        self.device = device
+
+    def encode_text(self, text):
+        text = self.tokenize(text).to(self.device)
+        return self.model.encode_text(text)
+
+    def encode_image(self, image):
+        image = self.preprocess(image).unsqueeze(0).to(self.device)
+        return self.model.encode_image(image)
+
+
+@register_model(name="open_clip")
+class OpenClipModel(VisionLanguageModel):
+    OPENCLIP_WEIGHTS = {
+        "ViT-B-32": "laion2b_s34b_b79k",
+        "ViT-L-14": "laion2b_s32b_b82k",
+    }
+
+    def __init__(self, backbone: str, device=c.DEVICE):
+        self.model, _, self.preprocess = open_clip.create_model_and_transforms(
+            backbone, pretrained=self.OPENCLIP_WEIGHTS[backbone], device=device
+        )
+        self.tokenize = open_clip.get_tokenizer(backbone)
+
+        self.device = device
+
+    def encode_text(self, text):
+        text = self.tokenize(text).to(self.device)
+        return self.model.encode_text(text)
+
+    def encode_image(self, image):
+        image = self.preprocess(image).unsqueeze(0).to(self.device)
+        return self.model.encode_image(image)
+
+
+@register_model(name="flava")
+class FLAVAModel(VisionLanguageModel):
+    HF_MODEL = "facebook/flava-full"
+
+    def __init__(self, backbone: Optional[str] = None, device=c.DEVICE):
+        if backbone is None:
+            backbone = self.HF_MODEL
+
+        self.model = FlavaModel.from_pretrained(backbone).to(device)
+        self.processor = FlavaProcessor.from_pretrained(backbone)
+
+        self.device = device
+
+    def encode_text(self, text):
+        text_inputs = self.processor(
+            text=text, return_tensors="pt", padding="max_length", max_length=77
+        )
+        text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
+        return self.model.get_text_features(**text_inputs)[:, 0, :]
+
+    def encode_image(self, image):
+        image_inputs = self.processor(images=image, return_tensors="pt")
+        image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
+        return self.model.get_image_features(**image_inputs)[:, 0, :]
+
+
+@register_model(name="align")
+class ALIGNModel(VisionLanguageModel):
+    HF_MODEL = "kakaobrain/align-base"
+
+    def __init__(self, backbone: Optional[str] = None, device=c.DEVICE):
+        if backbone is None:
+            backbone = self.HF_MODEL
+
+        self.model = AlignModel.from_pretrained(backbone).to(device)
+        self.processor = AlignProcessor.from_pretrained(backbone)
+
+        self.device = device
+
+    def encode_text(self, text):
+        text_inputs = self.processor(
+            text=text, return_tensors="pt", padding="max_length", max_length=77
+        )
+        text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
+        return self.model.get_text_features(**text_inputs)
+
+    def encode_image(self, image):
+        image_inputs = self.processor(images=image, return_tensors="pt")
+        image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
+        return self.model.get_image_features(**image_inputs)
+
+
+@register_model(name="blip")
+class BLIPModel(VisionLanguageModel):
+    HF_MODEL = "Salesforce/blip-itm-base-coco"
+
+    def __init__(self, backbone: Optional[str] = None, device=c.DEVICE):
+        if backbone is None:
+            backbone = self.HF_MODEL
+
+        self.model = BlipForImageTextRetrieval.from_pretrained(backbone).to(device)
+        self.processor = BlipProcessor.from_pretrained(backbone)
+
+        self.device = device
+
+    def encode_text(self, text):
+        text_inputs = self.processor(
+            text=text, return_tensors="pt", padding="max_length", max_length=77
+        )
+        text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
+        question_embeds = self.model.text_encoder(**text_inputs)[0]
+        return self.model.text_proj(question_embeds[:, 0, :])
+
+    def encode_image(self, image):
+        image_inputs = self.processor(images=image, return_tensors="pt")
+        image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
+        image_embeds = self.model.vision_model(**image_inputs)[0]
+        return self.model.vision_proj(image_embeds[:, 0, :])

imagenette_open_clip:ViT-B-32_train.h5

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:46b95fe30a90c980d4af8a150e983de327de80fc7a06e17c2e63e7c4ad7559d1
-size 38862824

imagenette_open_clip:ViT-B-32_val.h5

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9c19c97aea008a9ccb07fc2a75b877404058de937270cc1c6d151c10926d5cce
-size 16110248

imagenette_open_clip:ViT-L-14_train.h5

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:10c758c9aa4d7345d04ffdfe16c3832197137c41ff6e218c2fa69a023b7cc399
-size 58255336

imagenette_open_clip:ViT-L-14_val.h5

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9ce512d7495006818a5c32c5770eeda1ab0c20e1891ac19df33c23de4d52497c
-size 24148648

imagenette_clip:ViT-L-14_val.h5 → imagenette_test_align.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:13f5f737a9305bc6b89fedd6624e143c4decdb0b47761f9603415275cc41878f
-size 24148648
+oid sha256:265db09eb55e5cbef235fa204020fd5ad2badf200038d9e0126374521affada6
+size 10675850

imagenette_clip:ViT-B-32_train.h5 → imagenette_test_blip.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:71ceaca38ea7430915ea046e0212d906c7d2927a7e5d3c6bd479c5ca2ab8ef5a
-size 38862824
+oid sha256:f66d559b9440a59932c811636f5a721e2bdf5bde59a8f632ec6bf2f3d13fae1f
+size 4646191

imagenette_clip:ViT-B-32_val.h5 → imagenette_test_clip_rn50.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1179b7dae485a821eff53c4509eca4326022f6feb5779e3365c01795d2690310
-size 16110248
+oid sha256:67d7d1db195dd85e756b057aa0135b603b462cc9ca9ccfe895b5696c9ba2fada
+size 16684784

imagenette_clip:ViT-L-14_train.h5 → imagenette_test_clip_vit-b_32.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cc1e525af84214c040db67abee6c8db934dda16d85afe6154629667a939411b8
-size 58255336
+oid sha256:3346b56e3d339872ff50f3a183581a781f367fb8077f9910f93492aaec3f729d
+size 8654915

imagenette_test_clip_vit-l_14.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2bf060d1aaeaa225f775be69b42ff73e4d08416f35ffb57e4d18c7c5feefbf0
+size 12668923

imagenette_test_flava.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21df42fc4e7730ceae8c9310e231124106a5e1fb35bacc799b516a933e83ee74
+size 12685761

imagenette_test_open_clip_vit-b-32.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc2283f0f9e3cbedb581143d06dda53a014cea1b4f4ce54a9ef34746c9520fe0
+size 8666033

imagenette_test_open_clip_vit-l-14.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4e4d1337006b6a9333654f3066b1b77844bd1341d3094a3818e1fbea85ff5c1
+size 12685737

imagenette_train_align.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:264aade88e2ec1490d31d2368dfcdeb7a17351a51d92562f9a4904effceac83e
+size 24871704

imagenette_train_blip.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:717255e31ed7afc8019001e068243d7755428430757d249d314f725bb821fe41
+size 10325500

imagenette_train_clip_rn50.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0928498b881718f20350c7632f9846c69f5b1095d8786e2bc8676cf82c7294c1
+size 39397651

imagenette_train_clip_vit-b_32.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23e319b3c1ebb785410417e1aa06276ef3b9b9f1d7d1ea220be69c36e878251a
+size 20012432

imagenette_train_clip_vit-l_14.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5f88fe23098887b34b21b7dc39183d3fb3024f6d0f96a0312af1f0124a00b27
+size 29701980

imagenette_train_flava.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e608ac7a1e915da8800f1b97551e4d94df1d61bd1ae645adca4fd2814e85bb7
+size 29720268

imagenette_train_open_clip_vit-b-32.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceab9e99ced509a0658ef4557ec87b4cb8a8535b7cb3a1a4c0ff994651994651
+size 20023012

imagenette_train_open_clip_vit-l-14.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7a31312b34936eb226e93ae94a67f18ba4ec6edf4d21196784ef035b99889e1
+size 29720534

make_dataset.py

@@ -1,53 +1,65 @@
 import argparse
+import os
 from itertools import product
 
-from dataset_lib.datasets import SUPPORTED_DATASETS
+from dataset_lib.config import Config
+from dataset_lib.config import Constants as c
 from dataset_lib.encode import encode
-from dataset_lib.models import SUPPORTED_MODELS
 
 
-def _dataset_type(dataset):
-    if isinstance(dataset, str):
-        dataset = [dataset]
+def setup_logging(level):
+    import logging
 
-    for d in dataset:
-        assert d in SUPPORTED_DATASETS, ValueError(f"Dataset {d} not supported.")
-    return dataset
-
-
-def _model_type(model):
-    if isinstance(model, str):
-        model = [model]
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    logging.root.setLevel(level)
+    loggers = [
+        logging.getLogger(name)
+        for name in logging.root.manager.loggerDict
+        if "ibydmt" in name
+    ]
+    for logger in loggers:
+        logger.setLevel(level)
 
-    for m in model:
-        assert m in SUPPORTED_MODELS, ValueError(f"Model {m} not supported.")
-    return model
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+    logging.root.addHandler(stream_handler)
 
 
 def config():
     parser = argparse.ArgumentParser()
     parser.add_argument(
-        "--dataset",
-        type=_dataset_type,
-        nargs="+",
-        default=SUPPORTED_DATASETS,
-        help="List of datasets to encode.",
+        "--workdir", type=str, default=c.WORKDIR, help="Working directory"
     )
-    parser.add_argument(
-        "--model",
-        type=_model_type,
-        nargs="+",
-        default=list(SUPPORTED_MODELS.keys()),
-        help="List of models to use.",
-    )
-
+    parser.add_argument("--log_level", type=str, default="INFO", help="Logging level")
     return parser.parse_args()
 
 
+def get_support_datasets(workdir: str):
+    with open(os.path.join(workdir, "supported_datasets.txt"), "r") as f:
+        return f.read().splitlines()
+
+
+def get_supported_models(workdir: str):
+    with open(os.path.join(workdir, "supported_models.txt"), "r") as f:
+        return f.read().splitlines()
+
+
 def main(args):
-    dataset, model = args.dataset, args.model
-    for d, m in product(dataset, model):
-        encode(d, m)
+    workdir = args.workdir
+    log_level = args.log_level
+
+    setup_logging(log_level)
+
+    datasets = get_support_datasets(workdir)
+    models = get_supported_models(workdir)
+    for dataset in datasets:
+        config = Config()
+        config.data.dataset = dataset
+        config.data.backbone = models
+        for _config in config.sweep(["data.backbone"]):
+            encode(_config)
 
 
 if __name__ == "__main__":

supported_models.txt

@@ -1,4 +1,8 @@
-open_clip:ViT-B-32,hf-hub:laion/CLIP-ViT-B-32-laion2B-s34B-b79K
-open_clip:ViT-L-14,hf-hub:laion/CLIP-ViT-L-14-laion2B-s32B-b82K
-clip:ViT-B/32,
-clip:ViT-L/14,
+clip:RN50
+clip:ViT-B/32
+clip:ViT-L/14
+open_clip:ViT-B-32
+open_clip:ViT-L-14
+flava
+align
+blip