Update README.md

README.md

@@ -21,7 +21,7 @@ pretty_name: EZPC Pre-computed Embeddings
 
 # EZPC - Pre-computed CLIP / SigLIP Embeddings
 
-This dataset hosts the pre-computed image embeddings, class splits, and concept vocabularies used in **Explaining CLIP Zero-shot Predictions Through Concepts** (CVPR 2026).
+This dataset hosts the pre-computed image embeddings, cached text (classname / concept) embeddings, and class splits used in **Explaining CLIP Zero-shot Predictions Through Concepts** (CVPR 2026).
 
 Running EZPC from scratch requires extracting CLIP / SigLIP features for every image in five benchmark datasets (CIFAR-100, CUB-200-2011, Places365, ImageNet, ImageNet-100) with multiple backbones. To skip the expensive feature-extraction step, we release the exact tensors we used in the paper - drop them into the EZPC repo's `data/` folder and you can train, evaluate, and reproduce quantitative results without touching the raw images.
 
@@ -39,12 +39,13 @@ For each of the five datasets and each supported backbone, this repository provi
 - **Unseen-split train / test embeddings:** embeddings restricted to the 20% "unseen" classes held out from training. Used for GZSL unseen-class evaluation (and for the `--target_dataset` side of cross-dataset transfer).
 - **Split-aligned target files:** `seen_train_ids.pt`, `seen_test_ids.pt`, `unseen_train_ids.pt`, `unseen_test_ids.pt`, each giving the class index for every row of the corresponding split.
 - **Class split file:** the exact seen / unseen class partition (seed 42, 80/20) used in the paper.
+- **Cached text embeddings:** L2-normalized `"a photo of {x}"` text embeddings for class names (`{backbone}_classname_embs.pt`, shape `(C, d)`) and concepts (`{backbone}_concept_matrix.pt`, shape `(m, d)`). `test.py` loads these automatically so evaluation reproduces the reported numbers **exactly and independent of GPU / CUDA version** — without re-running the CLIP/SigLIP text encoder.
 
 Supported backbones: **CLIP RN50**, **CLIP ViT-B/32**, **CLIP ViT-L/14**, **SigLIP ViT-SO400M/14**.
 
 ## Repository Layout
 
-Each dataset follows the same two-level structure: top-level `embeddings/` holds the **full** feature dump (all classes), and `embeddings/splits/` holds the **seen/unseen partition** used throughout the paper.
+Each dataset follows the same two-level structure: top-level `embeddings/` holds the **full** image feature dump (all classes) plus the **cached text embeddings**, and `embeddings/splits/` holds the **seen/unseen partition** used throughout the paper.
 
 ```
 data/
@@ -58,6 +59,14 @@ data/
 │       ├── ViT-L-14_test_embeddings.pt
 │       ├── siglip-so400m-patch14-384_train_embeddings.pt
 │       ├── siglip-so400m-patch14-384_test_embeddings.pt
+│       ├── RN50_classname_embs.pt                         # (C, d) - class-name text embeddings
+│       ├── RN50_concept_matrix.pt                         # (m, d) - concept text embeddings
+│       ├── ViT-B-32_classname_embs.pt
+│       ├── ViT-B-32_concept_matrix.pt
+│       ├── ViT-L-14_classname_embs.pt
+│       ├── ViT-L-14_concept_matrix.pt
+│       ├── siglip-so400m-patch14-384_classname_embs.pt
+│       ├── siglip-so400m-patch14-384_concept_matrix.pt
 │       ├── train_ids.pt                                   # (N_train,)  - class indices
 │       ├── test_ids.pt                                    # (N_test,)   - class indices
 │       └── splits/
@@ -92,18 +101,6 @@ data/
     └── embeddings/ ...
 ```
 
-**File conventions:**
-
-| File | Shape | Dtype | Description |
-|:--|:--|:--|:--|
-| `{backbone}_train_embeddings.pt` / `{backbone}_test_embeddings.pt` | `(N, d)` | `float32` | Full feature dump across all classes |
-| `train_ids.pt` / `test_ids.pt` | `(N,)` | `int64` | Class indices aligned with the full embeddings above |
-| `splits/class_split.pt` | - | `dict` | `{"seen_classes": [...], "unseen_classes": [...]}` |
-| `splits/{backbone}_{seen,unseen}_{train,test}_embs.pt` | `(N', d)` | `float32` | Embeddings restricted to seen/unseen classes |
-| `splits/{seen,unseen}_{train,test}_ids.pt` | `(N',)` | `int64` | Class indices for the corresponding split |
-
-All `.pt` files are standard PyTorch tensors saved with `torch.save` and can be loaded with `torch.load(..., weights_only=True)`.
-
 ## Quickstart
 
 ### 1. Download the data
@@ -122,11 +119,11 @@ hf download oonat/ezpc-embeddings \
     --local-dir data \
     --include "CIFAR-100/*"
 
-# Or only the GZSL splits EZPC actually needs (skip the full feature dumps)
+# Or only what EZPC needs to evaluate: the GZSL splits + cached text embeddings
 hf download oonat/ezpc-embeddings \
     --repo-type dataset \
     --local-dir data \
-    --include "*/embeddings/splits/*"
+    --include "*/embeddings/splits/*" "*/embeddings/*_classname_embs.pt" "*/embeddings/*_concept_matrix.pt"
 ```
 
 ### 2. Plug it into EZPC
@@ -136,7 +133,8 @@ Clone the [EZPC GitHub repo](https://github.com/oonat/ezpc) and point `--dataset
 ```bash
 git clone https://github.com/oonat/ezpc.git
 cd ezpc
-pip install -r requirements.txt
+conda env create -f environment.yml
+conda activate ezpc
 pip install -e .
 
 # data/ lives next to train.py now - run training:
@@ -149,72 +147,18 @@ python train.py \
     --num_epochs 10000
 ```
 
-### 3. Load tensors directly
-
-If you just want to inspect or reuse the embeddings outside of EZPC:
-
-```python
-import torch
-
-# (a) Full feature dump - all classes, useful for custom experiments or
-#     regenerating seen/unseen splits under a different seed.
-full_train_embs = torch.load(
-    "data/CIFAR-100/embeddings/RN50_train_embeddings.pt",
-    weights_only=True,
-).float()
-full_train_ids = torch.load(
-    "data/CIFAR-100/embeddings/train_ids.pt",
-    weights_only=True,
-)
-print(full_train_embs.shape, full_train_ids.shape)  # (N, 1024)  (N,)
-
-# (b) GZSL split used in the paper.
-seen_train_embs = torch.load(
-    "data/CIFAR-100/embeddings/splits/RN50_seen_train_embs.pt",
-    weights_only=True,
-).float()
-class_split = torch.load(
-    "data/CIFAR-100/embeddings/splits/class_split.pt",
-    weights_only=True,
-)
-print(class_split["seen_classes"], class_split["unseen_classes"])
-```
-
-## Dataset Statistics
-
-| Dataset | # Classes | Seen / Unseen | # Concepts (m) | Source |
-|:--|:--:|:--:|:--:|:--|
-| CIFAR-100    | 100 | 80 / 20   | 5277 (dataset-specific + ImageNet concepts) | [CIFAR-100](https://www.cs.toronto.edu/~kriz/cifar.html) |
-| CUB-200-2011 | 200 | 160 / 40  | 5077 (dataset-specific + ImageNet concepts) | [CUB-200-2011](http://www.vision.caltech.edu/datasets/cub_200_2011/) |
-| Places365    | 365 | 292 / 73  | 6711 (dataset-specific + ImageNet concepts) | [Places365](http://places2.csail.mit.edu/) |
-| ImageNet-100 | 100 | 80 / 20   | 4751 | Subset of ImageNet-1k |
-| ImageNet-1k  | 1000 | 800 / 200 | 4751 | [ImageNet](https://www.image-net.org/) |
-
-The seen / unseen split is generated with seed `42` and ratio `0.8`, reproducible with `data/split_dataset.py` from the [EZPC repo](https://github.com/oonat/ezpc).
-
-## How the Embeddings Were Generated
-
-For every `(dataset, backbone)` pair we:
-
-1. Downloaded the raw dataset via `data/download_dataset.py`.
-2. Ran `data/extract_clip_features.py` to encode each image through the backbone's vision encoder, and saved the resulting features at the top level of `embeddings/` as `{backbone}_train_embeddings.pt` / `{backbone}_test_embeddings.pt`, along with `train_ids.pt` / `test_ids.pt`.
-3. Ran `data/split_dataset.py` to partition the classes 80/20 into seen/unseen splits (seed 42) and wrote the restricted seen/unseen tensors into `embeddings/splits/`. The full feature dumps from step 2 are left in place at the top level, so downstream users can regenerate splits under a different seed or ratio without re-encoding images.
-
-Each embedding is the **L2-normalized output of the backbone's image encoder** (i.e., the same vector CLIP would dot against a text embedding for zero-shot classification). Normalization is applied again inside `utils.load_train_embeddings` / `utils.load_test_embeddings` at load time, so pre-normalization status doesn't matter for downstream use.
-
-Concept vocabularies and class label files are taken from the [Label-free Concept Bottleneck Models](https://github.com/Trustworthy-ML-Lab/Label-free-CBM) repository, with the ImageNet concept list appended to CIFAR-100, CUB-200-2011, and Places365 (controlled by `append_imagenet_concepts` in `utils.DATASET_CONFIG`).
-
-
 ## Citation
 
 If you use this dataset, please cite:
 
 ```bibtex
-@inproceedings{ozdemir2026ezpc,
-  title     = {Explaining CLIP Zero-shot Predictions Through Concepts},
-  author    = {Ozdemir, Onat and Christensen, Anders and Alaniz, Stephan and Akata, Zeynep and Akbas, Emre},
-  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
-  year      = {2026}
+@InProceedings{Ozdemir_2026_CVPR,
+    author    = {Ozdemir, Onat and Christensen, Anders and Alaniz, Stephan and Akata, Zeynep and Akbas, Emre},
+    title     = {Explaining CLIP Zero-shot Predictions Through Concepts},
+    booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+    month     = {June},
+    year      = {2026},
+    pages     = {31336-31345}
 }
 ```