Upload 2 files

README.md

@@ -0,0 +1,105 @@
+---
+license: apache-2.0
+---
+# Dataset Card for Scream dSprites
+
+## Dataset Description
+
+The **Scream 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 **Scream** variant, a random patch of a **Scream painting image** is used as the background for each sample, and the object sprite is embedded onto the patch by **inverting the pixel colors** of the object region. 
+
+This allows researchers to evaluate **robustness to complex background textures** and assess how well models can learn disentangled representations when the background introduces structured noise.
+
+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, here fixed but inverted on background)
+- 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**.
+
+These variants allow systematic testing under **different nuisance variations** (color, noise, background texture, abstract factors).
+![Dataset Visualization](https://huggingface.co/datasets/randall-lab/dsprites-scream/resolve/main/animation0.gif)
+
+### Scream background visualization
+
+![Scream background](https://huggingface.co/datasets/randall-lab/dsprites-scream/resolve/main/scream.jpg)
+
+You can also explore other variants:
+
+- [randall-lab/dsprites (default, grayscale)](https://huggingface.co/datasets/randall-lab/dsprites)
+- [randall-lab/dsprites-color](https://huggingface.co/datasets/randall-lab/dsprites-color)
+- [randall-lab/dsprites-noisy](https://huggingface.co/datasets/randall-lab/dsprites-noisy)
+
+## 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)|Inverted object pixels on scream background|
+|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 Scream variant, the `color` and `colorValue` fields remain 0 to match the original dSprites format. The **object pixels** are inverted on top of a random Scream background patch.
+
+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 Scream 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-scream", 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
+
+# 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]
+
+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-scream.py

@@ -0,0 +1,119 @@
+import datasets
+import numpy as np
+from PIL import Image
+
+_DSPRITES_URL = "https://github.com/google-deepmind/dsprites-dataset/raw/refs/heads/master/dsprites_ndarray_co1sh3sc6or40x32y32_64x64.npz"
+_SCREAM_URL = "https://huggingface.co/datasets/randall-lab/dsprites-scream/resolve/main/scream.jpg"
+
+class DSprites(datasets.GeneratorBasedBuilder):
+    """Scream dSprites dataset: 3x6x40x32x32 factor combinations, 64x64 RGB images with Scream background."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=(
+                "Scream dSprites dataset: procedurally generated 2D shapes dataset with known ground-truth factors, "
+                "commonly used for disentangled representation learning. "
+                "This is the ScreamDSprites variant, where each object is embedded onto a random Scream image patch "
+                "with the object pixels inverted. "
+                "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), RGB
+                    "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)
+        scream_path = dl_manager.download_and_extract(_SCREAM_URL)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"npz_path": npz_path, "scream_path": scream_path},
+            ),
+        ]
+
+    def _generate_examples(self, npz_path, scream_path):
+        # Load dSprites data
+        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
+
+        # Load Scream image once
+        scream_img = Image.open(scream_path).convert("RGB")
+        scream_img = scream_img.resize((350, 274))
+        scream = np.array(scream_img).astype(np.float32) / 255.0  # (H, W, 3)
+
+        # Iterate over images
+        for idx in range(len(images)):
+            img = images[idx].astype(np.float32)  # (64, 64), float32
+
+            # Random scream patch
+            x_crop = np.random.randint(0, scream.shape[0] - 64)
+            y_crop = np.random.randint(0, scream.shape[1] - 64)
+            background_patch = scream[x_crop:x_crop + 64, y_crop:y_crop + 64]  # (64, 64, 3)
+
+            # Create mask
+            mask = img == 1
+            mask = mask[..., None]  # (64, 64, 1)
+
+            # Invert object region
+            output_img = np.copy(background_patch)
+            output_img[mask.squeeze()] = 1.0 - background_patch[mask.squeeze()]
+
+            # Convert to RGB PIL
+            img_pil = Image.fromarray((output_img * 255).astype(np.uint8), mode="RGB")
+
+            # Labels
+            factors_classes = latents_classes[idx].tolist()
+            factors_values = latents_values[idx].tolist()
+
+            yield idx, {
+                "image": img_pil,
+                "index": idx,
+                "label": factors_classes,
+                "label_values": factors_values,
+                "color": factors_classes[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],
+                "shapeValue": factors_values[1],
+                "scaleValue": factors_values[2],
+                "orientationValue": factors_values[3],
+                "posXValue": factors_values[4],
+                "posYValue": factors_values[5],
+            }