Duplicate from jainr3/diffusiondb-pixelart

Co-authored-by: Rahul Jain <jainr3@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,54 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+*.log
+.DS_Store
+git-add.py

README.md

@@ -0,0 +1,281 @@
+---
+layout: default
+title: Home
+nav_order: 1
+has_children: false
+
+annotations_creators:
+- no-annotation
+language:
+- en
+language_creators:
+- found
+license:
+- cc0-1.0
+multilinguality:
+- multilingual
+pretty_name: DiffusionDB-Pixelart
+size_categories:
+- n>1T
+source_datasets:
+- modified
+tags:
+- stable diffusion
+- prompt engineering
+- prompts
+task_categories:
+- text-to-image
+- image-to-text
+task_ids:
+- image-captioning
+---
+
+# DiffusionDB-Pixelart
+
+## Table of Contents
+
+- [DiffusionDB](#diffusiondb)
+  - [Table of Contents](#table-of-contents)
+  - [Dataset Description](#dataset-description)
+    - [Dataset Summary](#dataset-summary)
+    - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+    - [Languages](#languages)
+    - [Subset](#subset)
+  - [Dataset Structure](#dataset-structure)
+    - [Data Instances](#data-instances)
+    - [Data Fields](#data-fields)
+    - [Dataset Metadata](#dataset-metadata)
+      - [Metadata Schema](#metadata-schema)
+    - [Data Splits](#data-splits)
+    - [Loading Data Subsets](#loading-data-subsets)
+      - [Method 1: Using Hugging Face Datasets Loader](#method-1-using-hugging-face-datasets-loader)
+  - [Dataset Creation](#dataset-creation)
+    - [Curation Rationale](#curation-rationale)
+    - [Source Data](#source-data)
+      - [Initial Data Collection and Normalization](#initial-data-collection-and-normalization)
+      - [Who are the source language producers?](#who-are-the-source-language-producers)
+    - [Annotations](#annotations)
+      - [Annotation process](#annotation-process)
+      - [Who are the annotators?](#who-are-the-annotators)
+    - [Personal and Sensitive Information](#personal-and-sensitive-information)
+  - [Considerations for Using the Data](#considerations-for-using-the-data)
+    - [Social Impact of Dataset](#social-impact-of-dataset)
+    - [Discussion of Biases](#discussion-of-biases)
+    - [Other Known Limitations](#other-known-limitations)
+  - [Additional Information](#additional-information)
+    - [Dataset Curators](#dataset-curators)
+    - [Licensing Information](#licensing-information)
+    - [Citation Information](#citation-information)
+    - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** [DiffusionDB homepage](https://poloclub.github.io/diffusiondb)
+- **Repository:** [DiffusionDB repository](https://github.com/poloclub/diffusiondb)
+- **Distribution:** [DiffusionDB Hugging Face Dataset](https://huggingface.co/datasets/poloclub/diffusiondb)
+- **Paper:** [DiffusionDB: A Large-scale Prompt Gallery Dataset for Text-to-Image Generative Models](https://arxiv.org/abs/2210.14896)
+
+### Dataset Summary
+
+**This is a subset of the DiffusionDB 2M dataset which has been turned into pixel-style art.**
+
+DiffusionDB is the first large-scale text-to-image prompt dataset. It contains **14 million** images generated by Stable Diffusion using prompts and hyperparameters specified by real users.
+
+DiffusionDB is publicly available at [🤗 Hugging Face Dataset](https://huggingface.co/datasets/poloclub/diffusiondb).
+
+### Supported Tasks and Leaderboards
+
+The unprecedented scale and diversity of this human-actuated dataset provide exciting research opportunities in understanding the interplay between prompts and generative models, detecting deepfakes, and designing human-AI interaction tools to help users more easily use these models.
+
+### Languages
+
+The text in the dataset is mostly English. It also contains other languages such as Spanish, Chinese, and Russian.
+
+### Subset
+
+DiffusionDB provides two subsets (DiffusionDB 2M and DiffusionDB Large) to support different needs. The pixelated version of the data was taken from the DiffusionDB 2M and has 2000 examples only.
+
+|Subset|Num of Images|Num of Unique Prompts|Size|Image Directory|Metadata Table|
+|:--|--:|--:|--:|--:|--:|
+|DiffusionDB-pixelart|2k|~1.5k|~1.6GB|`images/`|`metadata.parquet`|
+
+Images in DiffusionDB-pixelart are stored in `png` format.
+
+## Dataset Structure
+
+We use a modularized file structure to distribute DiffusionDB. The 2k images in DiffusionDB-pixelart are split into folders, where each folder contains 1,000 images and a JSON file that links these 1,000 images to their prompts and hyperparameters.
+
+```bash
+# DiffusionDB 2k
+./
+├── images
+│   ├── part-000001
+│   │   ├── 3bfcd9cf-26ea-4303-bbe1-b095853f5360.png
+│   │   ├── 5f47c66c-51d4-4f2c-a872-a68518f44adb.png
+│   │   ├── 66b428b9-55dc-4907-b116-55aaa887de30.png
+│   │   ├── [...]
+│   │   └── part-000001.json
+│   ├── part-000002
+│   ├── part-000003
+│   ├── [...]
+│   └── part-002000
+└── metadata.parquet
+```
+
+These sub-folders have names `part-0xxxxx`, and each image has a unique name generated by [UUID Version 4](https://en.wikipedia.org/wiki/Universally_unique_identifier). The JSON file in a sub-folder has the same name as the sub-folder. Each image is a `PNG` file (DiffusionDB-pixelart). The JSON file contains key-value pairs mapping image filenames to their prompts and hyperparameters.
+
+
+### Data Instances
+
+For example, below is the image of `ec9b5e2c-028e-48ac-8857-a52814fd2a06.png` and its key-value pair in `part-000001.json`.
+
+<img width="300" src="https://datasets-server.huggingface.co/assets/jainr3/diffusiondb-pixelart/--/2k_all/train/0/image/image.png">
+
+```json
+{
+  "ec9b5e2c-028e-48ac-8857-a52814fd2a06.png": {
+    "p": "doom eternal, game concept art, veins and worms, muscular, crustacean exoskeleton, chiroptera head, chiroptera ears, mecha, ferocious, fierce, hyperrealism, fine details, artstation, cgsociety, zbrush, no background ",
+    "se": 3312523387,
+    "c": 7.0,
+    "st": 50,
+    "sa": "k_euler"
+    },
+}
+```
+
+### Data Fields
+
+- key: Unique image name
+- `p`: Text
+
+### Dataset Metadata
+
+To help you easily access prompts and other attributes of images without downloading all the Zip files, we include a metadata table `metadata.parquet` for DiffusionDB-pixelart.
+
+Two tables share the same schema, and each row represents an image. We store these tables in the Parquet format because Parquet is column-based: you can efficiently query individual columns (e.g., prompts) without reading the entire table.
+
+Below are three random rows from `metadata.parquet`.
+
+| image_name                               | prompt                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |   part_id |       seed |   step |   cfg |   sampler |   width |   height | user_name                                                        | timestamp                 |   image_nsfw |   prompt_nsfw |
+|:-----------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------:|-----------:|-------:|------:|----------:|--------:|---------:|:-----------------------------------------------------------------|:--------------------------|-------------:|--------------:|
+| 0c46f719-1679-4c64-9ba9-f181e0eae811.png | a small liquid sculpture, corvette, viscous, reflective, digital art                                                                                                                                                                                                                                                                                                                                                                                                           |      1050 | 2026845913 |     50 |   7   |         8 |     512 |      512 | c2f288a2ba9df65c38386ffaaf7749106fed29311835b63d578405db9dbcafdb | 2022-08-11 09:05:00+00:00 |    0.0845108 |   0.00383462  |
+| a00bdeaa-14eb-4f6c-a303-97732177eae9.png | human sculpture of lanky tall alien on a romantic date at italian restaurant with smiling woman, nice restaurant, photography, bokeh                                                                                                                                                                                                                                                                                                                                           |       905 | 1183522603 |     50 |  10   |         8 |     512 |      768 | df778e253e6d32168eb22279a9776b3cde107cc82da05517dd6d114724918651 | 2022-08-19 17:55:00+00:00 |    0.692934  |   0.109437    |
+| 6e5024ce-65ed-47f3-b296-edb2813e3c5b.png | portrait of barbaric spanish conquistador, symmetrical, by yoichi hatakenaka, studio ghibli and dan mumford                                                                                                                                                                                                                                                                                                                                                                    |       286 | 1713292358 |     50 |   7   |         8 |     512 |      640 | 1c2e93cfb1430adbd956be9c690705fe295cbee7d9ac12de1953ce5e76d89906 | 2022-08-12 03:26:00+00:00 |    0.0773138 |   0.0249675   |
+
+#### Metadata Schema
+
+`metadata.parquet` schema:
+
+|Column|Type|Description|
+|:---|:---|:---|
+|`image_name`|`string`|Image UUID filename.|
+|`text`|`string`|The text prompt used to generate this image.|
+
+> **Warning**
+> Although the Stable Diffusion model has an NSFW filter that automatically blurs user-generated NSFW images, this NSFW filter is not perfect—DiffusionDB still contains some NSFW images. Therefore, we compute and provide the NSFW scores for images and prompts using the state-of-the-art models. The distribution of these scores is shown below. Please decide an appropriate NSFW score threshold to filter out NSFW images before using DiffusionDB in your projects.
+
+<img src="https://i.imgur.com/1RiGAXL.png" width="100%">
+
+### Data Splits
+
+For DiffusionDB-pixelart, we split 2k images into folders where each folder contains 1,000 images and a JSON file.
+
+### Loading Data Subsets
+
+DiffusionDB is large! However, with our modularized file structure, you can easily load a desirable number of images and their prompts and hyperparameters. In the [`example-loading.ipynb`](https://github.com/poloclub/diffusiondb/blob/main/notebooks/example-loading.ipynb) notebook, we demonstrate three methods to load a subset of DiffusionDB. Below is a short summary.
+
+#### Method 1: Using Hugging Face Datasets Loader
+
+You can use the Hugging Face [`Datasets`](https://huggingface.co/docs/datasets/quickstart) library to easily load prompts and images from DiffusionDB. We pre-defined 16 DiffusionDB subsets (configurations) based on the number of instances. You can see all subsets in the [Dataset Preview](https://huggingface.co/datasets/poloclub/diffusiondb/viewer/all/train).
+
+```python
+import numpy as np
+from datasets import load_dataset
+
+# Load the dataset with the `2k_random_1k` subset
+dataset = load_dataset('jainr3/diffusiondb-pixelart', '2k_random_1k')
+```
+
+## Dataset Creation
+
+### Curation Rationale
+
+Recent diffusion models have gained immense popularity by enabling high-quality and controllable image generation based on text prompts written in natural language. Since the release of these models, people from different domains have quickly applied them to create award-winning artworks, synthetic radiology images, and even hyper-realistic videos.
+
+However, generating images with desired details is difficult, as it requires users to write proper prompts specifying the exact expected results. Developing such prompts requires trial and error, and can often feel random and unprincipled. Simon Willison analogizes writing prompts to wizards learning “magical spells”: users do not understand why some prompts work, but they will add these prompts to their “spell book.” For example, to generate highly-detailed images, it has become a common practice to add special keywords such as “trending on artstation” and “unreal engine” in the prompt.
+
+Prompt engineering has become a field of study in the context of text-to-text generation, where researchers systematically investigate how to construct prompts to effectively solve different down-stream tasks. As large text-to-image models are relatively new, there is a pressing need to understand how these models react to prompts, how to write effective prompts, and how to design tools to help users generate images.
+To help researchers tackle these critical challenges, we create DiffusionDB, the first large-scale prompt dataset with 14 million real prompt-image pairs.
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+We construct DiffusionDB by scraping user-generated images on the official Stable Diffusion Discord server. We choose Stable Diffusion because it is currently the only open-source large text-to-image generative model, and all generated images have a CC0 1.0 Universal Public Domain Dedication license that waives all copyright and allows uses for any purpose. We choose the official [Stable Diffusion Discord server](https://discord.gg/stablediffusion) because it is public, and it has strict rules against generating and sharing illegal, hateful, or NSFW (not suitable for work, such as sexual and violent content) images. The server also disallows users to write or share prompts with personal information.
+
+#### Who are the source language producers?
+
+The language producers are users of the official [Stable Diffusion Discord server](https://discord.gg/stablediffusion).
+
+### Annotations
+
+The dataset does not contain any additional annotations.
+
+#### Annotation process
+
+[N/A]
+
+#### Who are the annotators?
+
+[N/A]
+
+### Personal and Sensitive Information
+
+The authors removed the discord usernames from the dataset.
+We decide to anonymize the dataset because some prompts might include sensitive information: explicitly linking them to their creators can cause harm to creators.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+The purpose of this dataset is to help develop better understanding of large text-to-image generative models.
+The unprecedented scale and diversity of this human-actuated dataset provide exciting research opportunities in understanding the interplay between prompts and generative models, detecting deepfakes, and designing human-AI interaction tools to help users more easily use these models.
+
+It should note that we collect images and their prompts from the Stable Diffusion Discord server. The Discord server has rules against users generating or sharing harmful or NSFW (not suitable for work, such as sexual and violent content) images. The Stable Diffusion model used in the server also has an NSFW filter that blurs the generated images if it detects NSFW content. However, it is still possible that some users had generated harmful images that were not detected by the NSFW filter or removed by the server moderators. Therefore, DiffusionDB can potentially contain these images. To mitigate the potential harm, we provide a [Google Form](https://forms.gle/GbYaSpRNYqxCafMZ9) on the [DiffusionDB website](https://poloclub.github.io/diffusiondb/) where users can report harmful or inappropriate images and prompts. We will closely monitor this form and remove reported images and prompts from DiffusionDB.
+
+### Discussion of Biases
+
+The 14 million images in DiffusionDB have diverse styles and categories. However, Discord can be a biased data source. Our images come from channels where early users could use a bot to use Stable Diffusion before release. As these users had started using Stable Diffusion before the model was public, we hypothesize that they are AI art enthusiasts and are likely to have experience with other text-to-image generative models. Therefore, the prompting style in DiffusionDB might not represent novice users. Similarly, the prompts in DiffusionDB might not generalize to domains that require specific knowledge, such as medical images.
+
+### Other Known Limitations
+
+**Generalizability.** Previous research has shown a prompt that works well on one generative model might not give the optimal result when used in other models.
+Therefore, different models can need users to write different prompts. For example, many Stable Diffusion prompts use commas to separate keywords, while this pattern is less seen in prompts for DALL-E 2 or Midjourney. Thus, we caution researchers that some research findings from DiffusionDB might not be generalizable to other text-to-image generative models.
+
+## Additional Information
+
+### Dataset Curators
+
+DiffusionDB is created by [Jay Wang](https://zijie.wang), [Evan Montoya](https://www.linkedin.com/in/evan-montoya-b252391b4/), [David Munechika](https://www.linkedin.com/in/dmunechika/), [Alex Yang](https://alexanderyang.me), [Ben Hoover](https://www.bhoov.com), [Polo Chau](https://faculty.cc.gatech.edu/~dchau/).
+
+
+### Licensing Information
+
+The DiffusionDB dataset is available under the [CC0 1.0 License](https://creativecommons.org/publicdomain/zero/1.0/).
+The Python code in this repository is available under the [MIT License](https://github.com/poloclub/diffusiondb/blob/main/LICENSE).
+
+### Citation Information
+
+```bibtex
+@article{wangDiffusionDBLargescalePrompt2022,
+  title = {{{DiffusionDB}}: {{A}} Large-Scale Prompt Gallery Dataset for Text-to-Image Generative Models},
+  author = {Wang, Zijie J. and Montoya, Evan and Munechika, David and Yang, Haoyang and Hoover, Benjamin and Chau, Duen Horng},
+  year = {2022},
+  journal = {arXiv:2210.14896 [cs]},
+  url = {https://arxiv.org/abs/2210.14896}
+}
+```
+
+### Contributions
+
+If you have any questions, feel free to [open an issue](https://github.com/poloclub/diffusiondb/issues/new) or contact the original author [Jay Wang](https://zijie.wang).

diffusiondb-pixelart.py

@@ -0,0 +1,324 @@
+# Original Copyright 2022  Jay Wang, Evan Montoya, David Munechika, Alex Yang, Ben Hoover, Polo Chau
+# MIT License
+"""Loading script for DiffusionDB."""
+
+import re
+import numpy as np
+import pandas as pd
+
+from json import load, dump
+from os.path import join, basename
+from huggingface_hub import hf_hub_url
+
+import datasets
+
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@article{wangDiffusionDBLargescalePrompt2022,
+  title = {{{DiffusionDB}}: {{A}} Large-Scale Prompt Gallery Dataset for Text-to-Image Generative Models},
+  author = {Wang, Zijie J. and Montoya, Evan and Munechika, David and Yang, Haoyang and Hoover, Benjamin and Chau, Duen Horng},
+  year = {2022},
+  journal = {arXiv:2210.14896 [cs]},
+  url = {https://arxiv.org/abs/2210.14896}
+}
+"""
+
+# You can copy an official description
+_DESCRIPTION = """
+DiffusionDB is the first large-scale text-to-image prompt dataset. It contains 2
+million images generated by Stable Diffusion using prompts and hyperparameters
+specified by real users. The unprecedented scale and diversity of this
+human-actuated dataset provide exciting research opportunities in understanding
+the interplay between prompts and generative models, detecting deepfakes, and
+designing human-AI interaction tools to help users more easily use these models.
+"""
+
+_HOMEPAGE = "https://poloclub.github.io/diffusiondb"
+_LICENSE = "CC0 1.0"
+_VERSION = datasets.Version("0.9.1")
+
+# Programmatically generate the URLs for different parts
+# hf_hub_url() provides a more flexible way to resolve the file URLs
+# https://huggingface.co/datasets/jainr3/diffusiondb-pixelart/resolve/main/images/part-000001.zip
+_URLS = {}
+_PART_IDS = range(1, 3)
+
+for i in _PART_IDS:
+    _URLS[i] = hf_hub_url(
+        "jainr3/diffusiondb-pixelart",
+        filename=f"images/part-{i:06}.zip",
+        repo_type="dataset",
+    )
+
+
+# Add the metadata parquet URL as well
+_URLS["metadata"] = hf_hub_url(
+    "jainr3/diffusiondb-pixelart", filename="metadata.parquet", repo_type="dataset"
+)
+
+_SAMPLER_DICT = {
+    1: "ddim",
+    2: "plms",
+    3: "k_euler",
+    4: "k_euler_ancestral",
+    5: "ddik_heunm",
+    6: "k_dpm_2",
+    7: "k_dpm_2_ancestral",
+    8: "k_lms",
+    9: "others",
+}
+
+
+class DiffusionDBConfig(datasets.BuilderConfig):
+    """BuilderConfig for DiffusionDB."""
+
+    def __init__(self, part_ids, **kwargs):
+        """BuilderConfig for DiffusionDB.
+        Args:
+          part_ids([int]): A list of part_ids.
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(DiffusionDBConfig, self).__init__(version=_VERSION, **kwargs)
+        self.part_ids = part_ids
+
+
+class DiffusionDB(datasets.GeneratorBasedBuilder):
+    """A large-scale text-to-image prompt gallery dataset based on Stable Diffusion."""
+
+    BUILDER_CONFIGS = []
+
+    # Programmatically generate configuration options (HF requires to use a string
+    # as the config key)
+    for num_k in [1, 2]:
+        for sampling in ["first", "random"]:
+            num_k_str = f"{num_k}k" if num_k < 1000 else f"{num_k // 1000}m"
+            subset_str = "2k_"
+
+            if sampling == "random":
+                # Name the config
+                cur_name = subset_str + "random_" + num_k_str
+
+                # Add a short description for each config
+                cur_description = (
+                    f"Random {num_k_str} images with their prompts and parameters"
+                )
+
+                # Sample part_ids
+                total_part_ids = _PART_IDS
+                part_ids = np.random.choice(
+                    total_part_ids, num_k, replace=False
+                ).tolist()
+            else:
+                # Name the config
+                cur_name = subset_str + "first_" + num_k_str
+
+                # Add a short description for each config
+                cur_description = f"The first {num_k_str} images in this dataset with their prompts and parameters"
+
+                # Sample part_ids
+                total_part_ids = _PART_IDS
+                part_ids = total_part_ids[1 : num_k + 1]
+
+            # Create configs
+            BUILDER_CONFIGS.append(
+                DiffusionDBConfig(
+                    name=cur_name,
+                    part_ids=part_ids,
+                    description=cur_description,
+                ),
+            )
+
+
+    # Need to manually add all (2k)
+    BUILDER_CONFIGS.append(
+        DiffusionDBConfig(
+            name="2k_all",
+            part_ids=_PART_IDS,
+            description="All images with their prompts and parameters",
+        ),
+    )
+
+    # We also prove a text-only option, which loads the metadata parquet file
+    BUILDER_CONFIGS.append(
+        DiffusionDBConfig(
+            name="2k_text_only",
+            part_ids=[],
+            description="Only include all prompts and parameters (no image)",
+        ),
+    )
+
+
+    # Default to only load 1k random images
+    DEFAULT_CONFIG_NAME = "2k_random_1k"
+
+    def _info(self):
+        """Specify the information of DiffusionDB."""
+
+        if "text_only" in self.config.name:
+            features = datasets.Features(
+                {
+                    "image_name": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    #"part_id": datasets.Value("uint16"),
+                    #"seed": datasets.Value("uint32"),
+                    #"step": datasets.Value("uint16"),
+                    #"cfg": datasets.Value("float32"),
+                    #"sampler": datasets.Value("string"),
+                    #"width": datasets.Value("uint16"),
+                    #"height": datasets.Value("uint16"),
+                    #"user_name": datasets.Value("string"),
+                    #"timestamp": datasets.Value("timestamp[us, tz=UTC]"),
+                    #"image_nsfw": datasets.Value("float32"),
+                    #"prompt_nsfw": datasets.Value("float32"),
+                },
+            )
+
+        else:
+            features = datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "text": datasets.Value("string"),
+                    #"seed": datasets.Value("uint32"),
+                    #"step": datasets.Value("uint16"),
+                    #"cfg": datasets.Value("float32"),
+                    #"sampler": datasets.Value("string"),
+                    #"width": datasets.Value("uint16"),
+                    #"height": datasets.Value("uint16"),
+                    #"user_name": datasets.Value("string"),
+                    #"timestamp": datasets.Value("timestamp[us, tz=UTC]"),
+                    #"image_nsfw": datasets.Value("float32"),
+                    #"prompt_nsfw": datasets.Value("float32"),
+                },
+            )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # If several configurations are possible (listed in BUILDER_CONFIGS),
+        # the configuration selected by the user is in self.config.name
+
+        # dl_manager is a datasets.download.DownloadManager that can be used to
+        # download and extract URLS It can accept any type or nested list/dict
+        # and will give back the same structure with the url replaced with path
+        # to local files. By default the archives will be extracted and a path
+        # to a cached folder where they are extracted is returned instead of the
+        # archive
+
+        # Download and extract zip files of all sampled part_ids
+        data_dirs = []
+        json_paths = []
+
+        # Resolve the urls
+        urls = _URLS
+
+        for cur_part_id in self.config.part_ids:
+            cur_url = urls[cur_part_id]
+            data_dir = dl_manager.download_and_extract(cur_url)
+
+            data_dirs.append(data_dir)
+            json_paths.append(join(data_dir, f"part-{cur_part_id:06}.json"))
+
+        # Also download the metadata table
+        metadata_path = dl_manager.download(urls["metadata"])
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "data_dirs": data_dirs,
+                    "json_paths": json_paths,
+                    "metadata_path": metadata_path,
+                },
+            ),
+        ]
+
+    def _generate_examples(self, data_dirs, json_paths, metadata_path):
+        # This method handles input defined in _split_generators to yield
+        # (key, example) tuples from the dataset.
+        # The `key` is for legacy reasons (tfds) and is not important in itself,
+        # but must be unique for each example.
+
+        # Load the metadata parquet file if the config is text_only
+        if "text_only" in self.config.name:
+            metadata_df = pd.read_parquet(metadata_path)
+            for _, row in metadata_df.iterrows():
+                yield row["image_name"], {
+                    "image_name": row["image_name"],
+                    "text": row["prompt"],
+                    #"part_id": row["part_id"],
+                    #"seed": row["seed"],
+                    #"step": row["step"],
+                    #"cfg": row["cfg"],
+                    #"sampler": _SAMPLER_DICT[int(row["sampler"])],
+                    #"width": row["width"],
+                    #"height": row["height"],
+                    #"user_name": row["user_name"],
+                    #"timestamp": None
+                    #if pd.isnull(row["timestamp"])
+                    #else row["timestamp"],
+                    #"image_nsfw": row["image_nsfw"],
+                    #"prompt_nsfw": row["prompt_nsfw"],
+                }
+
+        else:
+            num_data_dirs = len(data_dirs)
+            assert num_data_dirs == len(json_paths)
+
+            # Read the metadata table (only rows with the needed part_ids)
+            part_ids = []
+            for path in json_paths:
+                cur_id = int(re.sub(r"part-(\d+)\.json", r"\1", basename(path)))
+                part_ids.append(cur_id)
+
+            # We have to use pandas here to make the dataset preview work (it
+            # uses streaming mode)
+
+            print(metadata_path)
+            
+            metadata_table = pd.read_parquet(
+                metadata_path,
+                filters=[("part_id", "in", part_ids)],
+            )
+
+            # Iterate through all extracted zip folders for images
+            for k in range(num_data_dirs):
+                cur_data_dir = data_dirs[k]
+                cur_json_path = json_paths[k]
+
+                json_data = load(open(cur_json_path, "r", encoding="utf8"))
+
+                for img_name in json_data:
+                    img_params = json_data[img_name]
+                    img_path = join(cur_data_dir, img_name)
+
+                    # Query the metadata
+                    query_result = metadata_table.query(f'`image_name` == "{img_name}"')
+
+                    # Yields examples as (key, example) tuples
+                    yield img_name, {
+                        "image": {
+                            "path": img_path,
+                            "bytes": open(img_path, "rb").read(),
+                        },
+                        "text": img_params["p"],
+                        #"seed": int(img_params["se"]),
+                        #"step": int(img_params["st"]),
+                        #"cfg": float(img_params["c"]),
+                        #"sampler": img_params["sa"],
+                        #"width": query_result["width"].to_list()[0],
+                        #"height": query_result["height"].to_list()[0],
+                        #"user_name": query_result["user_name"].to_list()[0],
+                        #"timestamp": None
+                        #if pd.isnull(query_result["timestamp"].to_list()[0])
+                        #else query_result["timestamp"].to_list()[0],
+                        #"image_nsfw": query_result["image_nsfw"].to_list()[0],
+                        #"prompt_nsfw": query_result["prompt_nsfw"].to_list()[0],
+                    }

images/part-000001.zip

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

images/part-000002.zip

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

metadata.parquet

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