Upload 3 files

README.md

@@ -0,0 +1,112 @@
+---
+license: apache-2.0
+---
+# Dataset Card for Color dSprites
+
+## Dataset Description
+
+The **Color dSprites dataset** is a **synthetic 2D shapes dataset** designed for benchmarking algorithms in **disentangled representation learning** and **unsupervised representation learning**. 
+
+It is a variant of the original **dSprites dataset** introduced in the β-VAE paper. In this version, each object is randomly colored per sample, while the background remains black. This allows researchers to evaluate **robustness to color variation** and assess how well models can learn disentangled representations under color transformations.
+
+The dataset consists of procedurally generated images of 2D sprites, under controlled variations of **6 known factors of variation**:
+
+- Object color (1 value in original dSprites, but here a random RGB color ∈ [0.5,1.0] is applied to each object at runtime)
+- Object shape (3 values: square, ellipse, heart)
+- Object scale (6 values)
+- Object orientation (40 values)
+- Object position X (32 values)
+- Object position Y (32 values)
+
+All possible combinations of these factors are present exactly once, generating a total of **737,280 images** at a resolution of **64×64 pixels**.
+
+Each image is provided along with:
+
+- **Discrete latent classes** (indices for each factor)
+- **Continuous latent values**
+- **Actual object color used (colorRGB field)**
+
+The dataset is commonly used for **benchmarking disentanglement learning**, and can be used in conjunction with other variants:
+
+- [randall-lab/dsprites (default, grayscale)](https://huggingface.co/datasets/randall-lab/dsprites)
+- [randall-lab/dsprites-noisy](https://huggingface.co/datasets/randall-lab/dsprites-noisy)
+- [randall-lab/dsprites-scream](https://huggingface.co/datasets/randall-lab/dsprites-scream)
+
+These variants allow systematic testing under **different nuisance variations** (color, noise, background texture, abstract factors).
+
+![Dataset Visualization](https://huggingface.co/datasets/randall-lab/dsprites-color/blob/main/animation0.gif)
+
+## Dataset Source
+- **Homepage**: [https://github.com/google-research/disentanglement_lib/](https://github.com/google-research/disentanglement_lib/tree/master)
+- **License**: Apache License 2.0
+- **Paper**: Francesco Locatello et al. _Challenging Common Assumptions in the Unsupervised Learning of Disentangled Representations_. ICML 2019.
+
+## Dataset Structure
+|Factors|Possible Classes (Indices)|Values|
+|---|---|---|
+|color|white=0 (original label, fixed)|Random RGB color ∈ [0.5,1.0] stored in `colorRGB`|
+|shape|square=0, ellipse=1, heart=2|1.0, 2.0, 3.0 (categorical)|
+|scale|0,...,5|[0.5, 1.0] linearly spaced (6 values)|
+|orientation|0,...,39|[0, 2π] radians (40 values)|
+|posX|0,...,31|[0, 1] normalized position (32 values)|
+|posY|0,...,31|[0, 1] normalized position (32 values)|
+
+**Note:** In this Color variant, the `color` and `colorValue` fields remain 0 to match the original dSprites format. The **actual applied color** is provided in `colorRGB`, a list of `[R, G, B]` values ∈ [0.5,1.0].
+
+Each image corresponds to a unique combination of these 6 factors. The images are stored in a **row-major order** (fastest-changing factor is `posY`, slowest-changing factor is `color`).
+
+### Why no train/test split?
+The Color dSprites dataset does not provide an official train/test split. It is designed for **representation learning research**, where the goal is to learn disentangled and interpretable latent factors. Since the dataset is a complete Cartesian product of all factor combinations, models typically require access to the full dataset to explore factor-wise variations.
+
+## Example Usage
+Below is a quick example of how to load this dataset via the Hugging Face Datasets library:
+```python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("randall-lab/dsprites-color", split="train", trust_remote_code=True)
+
+# Access a sample from the dataset
+example = dataset[0]
+image = example["image"]
+label = example["label"]         # [color_idx, shape_idx, scale_idx, orientation_idx, posX_idx, posY_idx]
+label_values = example["label_values"]  # corresponding continuous values
+colorRGB = example["colorRGB"]   # Actual RGB color used in this sample
+
+# Label Classes
+color = example["color"]         # 0
+shape = example["shape"]         # 0-2
+scale = example["scale"]         # 0-5
+orientation = example["orientation"]   # 0-39
+posX = example["posX"]           # 0-31
+posY = example["posY"]           # 0-31
+
+# Label Values
+color_value = example["colorValue"]         # 1
+shape_value = example["shapeValue"]         # 1.0, 2.0, 3.0
+scale_value = example["scaleValue"]         # [0.5, 1]
+orientation_value = example["orientationValue"]   # [0, 2π]
+posX_value = example["posXValue"]           # [0, 1]
+posY_value = example["posYValue"]           # [0, 1]
+
+# Actual color applied to object
+print(f"Actual RGB color: {colorRGB}")
+
+image.show()  # Display the image
+print(f"Label (factors): {label}")
+print(f"Label values (factors): {label_values}")
+```
+If you are using colab, you should update datasets to avoid errors
+```
+pip install -U datasets
+```
+## Citation
+```
+@inproceedings{locatello2019challenging,
+  title={Challenging Common Assumptions in the Unsupervised Learning of Disentangled Representations},
+  author={Locatello, Francesco and Bauer, Stefan and Lucic, Mario and Raetsch, Gunnar and Gelly, Sylvain and Sch{\"o}lkopf, Bernhard and Bachem, Olivier},
+  booktitle={International Conference on Machine Learning},
+  pages={4114--4124},
+  year={2019}
+}
+```

dsprites-color.py

@@ -0,0 +1,100 @@
+import datasets
+import numpy as np
+from PIL import Image
+
+_DSPRITES_URL = "https://github.com/deepmind/dsprites-dataset/raw/master/dsprites_ndarray_co1sh3sc6or40x32x32_64x64.npz"
+
+class DSprites(datasets.GeneratorBasedBuilder):
+    """dSprites dataset: 3x6x40x32x32 factor combinations, 64x64 binary images."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=(
+                "Color dSprites dataset: procedurally generated 2D shapes dataset with known ground-truth factors, "
+                "commonly used for disentangled representation learning. "
+                "This is the ColorDSprites variant, where each object is randomly colored per sample, "
+                "while background remains black. "
+                "Factors: color (1), shape (3), scale (6), orientation (40), position X (32), position Y (32). "
+                "Images are 64x64 RGB."
+            ),
+            features=datasets.Features(
+                {
+                    "image": datasets.Image(),  # (64, 64), grayscale
+                    "index": datasets.Value("int32"),  # index of the image
+                    "label": datasets.Sequence(datasets.Value("int32")),  # 6 factor indices (classes)
+                    "label_values": datasets.Sequence(datasets.Value("float32")),  # 6 factor continuous values
+                    "color": datasets.Value("int32"),  # color index (always 0)
+                    "shape": datasets.Value("int32"),  # shape index (0-2)
+                    "scale": datasets.Value("int32"),  # scale index (0-5)
+                    "orientation": datasets.Value("int32"),  # orientation index (0-39)
+                    "posX": datasets.Value("int32"),  # posX index (0-31)
+                    "posY": datasets.Value("int32"),  # posY index (0-31)
+                    "colorValue": datasets.Value("float64"),  # color index (always 0)
+                    "shapeValue": datasets.Value("float64"),  # shape index (0-2)
+                    "scaleValue": datasets.Value("float64"),  # scale index (0-5)
+                    "orientationValue": datasets.Value("float64"),  # orientation index (0-39)
+                    "posXValue": datasets.Value("float64"),  # posX index (0-31)
+                    "posYValue": datasets.Value("float64"),  # posY index (0-31)
+                }
+            ),
+            supervised_keys=("image", "label"),
+            homepage="https://github.com/google-research/disentanglement_lib/tree/master",
+            license="apache-2.0",
+            citation="""@inproceedings{locatello2019challenging,
+  title={Challenging Common Assumptions in the Unsupervised Learning of Disentangled Representations},
+  author={Locatello, Francesco and Bauer, Stefan and Lucic, Mario and Raetsch, Gunnar and Gelly, Sylvain and Sch{\"o}lkopf, Bernhard and Bachem, Olivier},
+  booktitle={International Conference on Machine Learning},
+  pages={4114--4124},
+  year={2019}
+}""",
+        )
+
+    def _split_generators(self, dl_manager):
+        npz_path = dl_manager.download(_DSPRITES_URL)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"npz_path": npz_path},
+            ),
+        ]
+
+    def _generate_examples(self, npz_path):
+        # Load npz
+        data = np.load(npz_path, allow_pickle=True)
+        images = data["imgs"]  # shape: (737280, 64, 64), uint8
+        latents_classes = data["latents_classes"]  # shape: (737280, 6), int64
+        latents_values = data["latents_values"]    # shape: (737280, 6), float64
+
+        # Iterate over images
+        for idx in range(len(images)):
+            img = images[idx]  # (64, 64), uint8
+            img = img.astype(np.float32) / 1.0
+            color_rgb = np.random.uniform(0.5, 1.0, size=(3,))
+            img_rgb = (img[..., None] * color_rgb) * 255
+            img_pil = Image.fromarray(img_rgb.astype(np.uint8), mode="RGB")
+
+            factors_classes = latents_classes[idx].tolist()  # [color_idx, shape_idx, scale_idx, orientation_idx, posX_idx, posY_idx]
+            factors_values = latents_values[idx].tolist()
+
+            yield idx, {
+                "image": img_pil,
+                "index": idx,
+                "label": factors_classes,
+                "label_values": factors_values,
+                "color": factors_classes[0],        # always 0
+                "shape": factors_classes[1],
+                "scale": factors_classes[2],
+                "orientation": factors_classes[3],
+                "posX": factors_classes[4],
+                "posY": factors_classes[5],
+                "colorValue": factors_values[0],    # always 0.0
+                "shapeValue": factors_values[1],
+                "scaleValue": factors_values[2],
+                "orientationValue": factors_values[3],
+                "posXValue": factors_values[4],
+                "posYValue": factors_values[5],
+                "colorRGB": color_rgb.tolist(),  # [R, G, B], ∈ [0.5,1.0]
+            }