@huggingface/tasks 0.0.1

package/src/text-to-speech/about.md

@@ -0,0 +1,63 @@
+## Use Cases
+
+Text-to-Speech (TTS) models can be used in any speech-enabled application that requires converting text to speech imitating human voice.
+
+### Voice Assistants
+
+TTS models are used to create voice assistants on smart devices. These models are a better alternative compared to concatenative methods where the assistant is built by recording sounds and mapping them, since the outputs in TTS models contain elements in natural speech such as emphasis.
+
+### Announcement Systems
+
+TTS models are widely used in airport and public transportation announcement systems to convert the announcement of a given text into speech.
+
+## Inference API
+
+The Hub contains over [1500 TTS models](https://huggingface.co/models?pipeline_tag=text-to-speech&sort=downloads) that you can use right away by trying out the widgets directly in the browser or calling the models as a service using the Inference API. Here is a simple code snippet to get you started:
+
+```python
+import json
+import requests
+
+headers = {"Authorization": f"Bearer {API_TOKEN}"}
+API_URL = "https://api-inference.huggingface.co/models/microsoft/speecht5_tts"
+
+def query(payload):
+	response = requests.post(API_URL, headers=headers, json=payload)
+	return response
+
+output = query({"text_inputs": "This is a test"})
+```
+
+You can also use libraries such as [espnet](https://huggingface.co/models?library=espnet&pipeline_tag=text-to-speech&sort=downloads) or [transformers](https://huggingface.co/models?pipeline_tag=text-to-speech&library=transformers&sort=trending) if you want to handle the Inference directly.
+
+## Direct Inference
+
+Now, you can also use the Text-to-Speech pipeline in Transformers to synthesise high quality voice.
+
+```python
+from transformers import pipeline
+
+synthesizer = pipeline("text-to-speech", "suno/bark")
+
+synthesizer("Look I am generating speech in three lines of code!")
+```
+
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer summarization models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_ACCESS_TOKEN);
+await inference.textToSpeech({
+  model: 'facebook/mms-tts',
+  inputs: "text to generate speech from"
+})
+```
+
+## Useful Resources
+- [ML for Audio Study Group - Text to Speech Deep Dive](https://www.youtube.com/watch?v=aLBedWj-5CQ)
+- [An introduction to SpeechT5, a multi-purpose speech recognition and synthesis model](https://huggingface.co/blog/speecht5).
+- [A guide on Fine-tuning Whisper For Multilingual ASR with 🤗Transformers](https://huggingface.co/blog/fine-tune-whisper)
+- [Speech Synthesis, Recognition, and More With SpeechT5](https://huggingface.co/blog/speecht5)
+

package/src/text-to-speech/data.ts

@@ -0,0 +1,70 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "Thousands of short audio clips of a single speaker.",
+			id:          "lj_speech",
+		},
+		{
+			description: "Multi-speaker English dataset.",
+			id:          "LibriTTS",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content:
+						"I love audio models on the Hub!",
+				type: "text",
+			},
+			
+		],
+		outputs: [
+			{
+				filename: "audio.wav",
+				type:     "audio",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "The Mel Cepstral Distortion (MCD) metric is used to calculate the quality of generated speech.",
+			id:          "mel cepstral distortion",
+		},
+	],
+	models: [
+		{
+			description: "A powerful TTS model.",
+			id:          "suno/bark",
+		},
+		{
+			description: "A massively multi-lingual TTS model.",
+			id:          "facebook/mms-tts",
+		},
+		{
+			description: "An end-to-end speech synthesis model.",
+			id:          "microsoft/speecht5_tts",
+		},
+	],
+	spaces:       [
+		{
+			description: "An application for generate highly realistic, multilingual speech.",
+			id:          "suno/bark",
+		},
+		{
+			description: "An application that contains multiple speech synthesis models for various languages and accents.",
+			id:          "coqui/CoquiTTS",
+		},
+		{
+			description: "An application that synthesizes speech for various speaker types.",
+			id:          "Matthijs/speecht5-tts-demo",
+		},
+	],
+	summary:      "Text-to-Speech (TTS) is the task of generating natural sounding speech given text input. TTS models can be extended to have a single model that generates speech for multiple speakers and multiple languages.",
+	widgetModels: ["microsoft/speecht5_tts"],
+	youtubeId:    "NW62DpzJ274",
+};
+
+export default taskData;

package/src/text-to-video/about.md

@@ -0,0 +1,36 @@
+## Use Cases
+
+### Script-based Video Generation
+Text-to-video models can be used to create short-form video content from a provided text script. These models can be used to create engaging and informative marketing videos. For example, a company could use a text-to-video model to create a video that explains how their product works.
+
+
+### Content format conversion
+Text-to-video models can be used to generate videos from long-form text, including blog posts, articles, and text files. Text-to-video models can be used to create educational videos that are more engaging and interactive. An example of this is creating a video that explains a complex concept from an article.
+
+### Voice-overs and Speech
+Text-to-video models can be used to create an AI newscaster to deliver daily news, or for a film-maker to create a short film or a music video.
+
+
+## Task Variants
+Text-to-video models have different variants based on inputs and outputs.
+
+### Text-to-video Editing
+One text-to-video task is generating text-based video style and local attribute editing. Text-to-video editing models can make it easier to perform tasks like cropping, stabilization, color correction, resizing and audio editing consistently.
+
+### Text-to-video Search
+Text-to-video search is the task of retrieving videos that are relevant to a given text query. This can be challenging, as videos are a complex medium that can contain a lot of information. By using semantic analysis to extract the meaning of the text query, visual analysis to extract features from the videos, such as the objects and actions that are present in the video, and temporal analysis to categorize relationships between the objects and actions in the video, we can determine which videos are most likely to be relevant to the text query.
+
+### Text-driven Video Prediction
+Text-driven video prediction is the task of generating a video sequence from a text description. Text description can be anything from a simple sentence to a detailed story. The goal of this task is to generate a video that is both visually realistic and semantically consistent with the text description.
+
+### Video Translation
+Text-to-video translation models can translate videos from one language to another or allow to query the multilingual text-video model with non-English sentences. This can be useful for people who want to watch videos in a language that they don't understand, especially when multi-lingual captions are available for training.
+
+## Inference
+Contribute an inference snippet for text-to-video here!
+
+## Useful Resources  
+
+In this area, you can insert useful resources about how to train or use a model for this task.  
+
+- [Text-to-Video: The Task, Challenges and the Current State](https://huggingface.co/blog/text-to-video)  

package/src/text-to-video/data.ts

@@ -0,0 +1,97 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+        {
+			description: "Microsoft Research Video to Text is a large-scale dataset for open domain video captioning",
+			id:          "iejMac/CLIP-MSR-VTT",
+		},
+        {
+			description: "UCF101 Human Actions dataset consists of 13,320 video clips from YouTube, with 101 classes.",
+			id:          "quchenyuan/UCF101-ZIP",
+		},
+        {
+			description: "A high-quality dataset for human action recognition in YouTube videos.",
+			id:          "nateraw/kinetics",
+		},
+        {
+			description: "A dataset of video clips of humans performing pre-defined basic actions with everyday objects.",
+			id:          "HuggingFaceM4/something_something_v2",
+		},
+        {
+			description: "This dataset consists of text-video pairs and contains noisy samples with irrelevant video descriptions",
+			id:          "HuggingFaceM4/webvid",
+		},
+        {
+			description: "A dataset of short Flickr videos for the temporal localization of events with descriptions.",
+			id:          "iejMac/CLIP-DiDeMo",
+		},
+    ],
+	demo:     {
+		inputs:  [
+			{
+				label:   "Input",
+				content:
+						"Darth Vader is surfing on the waves.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				filename: "text-to-video-output.gif",
+				type:     "img",
+			},
+		],
+	},
+	metrics:       [
+		{
+			description: "Inception Score uses an image classification model that predicts class labels and evaluates how distinct and diverse the images are. A higher score indicates better video generation.",
+			id: "is",
+		},
+		{
+			description: "Frechet Inception Distance uses an image classification model to obtain image embeddings. The metric compares mean and standard deviation of the embeddings of real and generated images. A smaller score indicates better video generation.",
+			id: "fid",
+		},
+		{
+			description: "Frechet Video Distance uses a model that captures coherence for changes in frames and the quality of each frame. A smaller score indicates better video generation.",
+			id: "fvd",
+		},
+		{
+			description: "CLIPSIM measures similarity between video frames and text using an image-text similarity model. A higher score indicates better video generation.",
+			id: "clipsim",
+		},
+	],
+	models:        [
+		{
+			description: "A strong model for video generation.",
+			id:          "PAIR/text2video-zero-controlnet-canny-arcane",
+		},
+		{
+			description: "A robust model for text-to-video generation.",
+			id:          "damo-vilab/text-to-video-ms-1.7b",
+		},
+		{
+			description: "A text-to-video generation model with high quality and smooth outputs.",
+			id:          "cerspense/zeroscope_v2_576w",
+		},         
+    ],
+	spaces:        [	
+		{
+			description: "An application that generates video from text.",
+			id:          "fffiloni/zeroscope",
+		},
+		{
+			description: "An application that generates video from image and text.",
+			id:          "TempoFunk/makeavid-sd-jax",
+		},
+		{
+			description: "An application that generates videos from text and provides multi-model support.",
+			id:          "ArtGAN/Video-Diffusion-WebUI",
+		},
+	],
+	summary:       "Text-to-video models can be used in any application that requires generating consistent sequence of images from text. ",
+	widgetModels:  [],
+	youtubeId:     undefined,
+};
+
+export default taskData;

package/src/token-classification/about.md

@@ -0,0 +1,78 @@
+## Use Cases
+
+### Information Extraction from Invoices
+
+You can extract entities of interest from invoices automatically using Named Entity Recognition (NER) models. Invoices can be read with Optical Character Recognition models and the output can be used to do inference with NER models. In this way, important information such as date, company name, and other named entities can be extracted.
+
+## Task Variants
+
+### Named Entity Recognition (NER)
+
+NER is the task of recognizing named entities in a text. These entities can be the names of people, locations, or organizations. The task is formulated as labeling each token with a class for each named entity and a class named "0" for tokens that do not contain any entities. The input for this task is text and the output is the annotated text with named entities.
+
+#### Inference
+
+You can use the 🤗 Transformers library `ner` pipeline to infer with NER models.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("ner")
+classifier("Hello I'm Omar and I live in Zürich.")
+```
+
+
+
+### Part-of-Speech (PoS) Tagging
+In PoS tagging, the model recognizes parts of speech, such as nouns, pronouns, adjectives, or verbs, in a given text. The task is formulated as labeling each word with a part of the speech.
+
+#### Inference
+
+You can use the 🤗 Transformers library `token-classification` pipeline with a POS tagging model of your choice. The model will return a json with PoS tags for each token.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("token-classification", model = "vblagoje/bert-english-uncased-finetuned-pos")
+classifier("Hello I'm Omar and I live in Zürich.")
+```
+
+This is not limited to transformers! You can also use other libraries such as Stanza, spaCy, and Flair to do inference! Here is an example using a canonical [spaCy](https://hf.co/blog/spacy) model.
+
+```python
+!pip install https://huggingface.co/spacy/en_core_web_sm/resolve/main/en_core_web_sm-any-py3-none-any.whl
+
+import en_core_web_sm
+
+nlp = en_core_web_sm.load()
+doc = nlp("I'm Omar and I live in Zürich.")
+for token in doc:
+    print(token.text, token.pos_, token.dep_, token.ent_type_)
+
+## I PRON nsubj
+## 'm AUX ROOT
+## Omar PROPN attr PERSON
+### ...
+```
+
+## Useful Resources
+
+Would you like to learn more about token classification? Great! Here you can find some curated resources that you may find helpful!
+
+- [Course Chapter on Token Classification](https://huggingface.co/course/chapter7/2?fw=pt)
+- [Blog post: Welcome spaCy to the Hugging Face Hub](https://huggingface.co/blog/spacy)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/token_classification.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/token_classification-tf.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow)
+- [Flax](https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification)
+
+### Documentation
+
+- [Token classification task guide](https://huggingface.co/docs/transformers/tasks/token_classification)

package/src/token-classification/data.ts

@@ -0,0 +1,83 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A widely used dataset useful to benchmark named entity recognition models.",
+			id:          "conll2003",
+		},
+		{
+			description: "A multilingual dataset of Wikipedia articles annotated for named entity recognition in over 150 different languages.",
+			id:          "wikiann",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content:
+						"My name is Omar and I live in Zürich.",
+				type: "text",
+			},
+			
+		],
+		outputs: [
+			{
+				text:   "My name is Omar and I live in Zürich.",
+				tokens: [
+					{
+						type:  "PERSON",
+						start: 11,
+						end:   15,
+					},
+					{
+						type:  "GPE",
+						start: 30,
+						end:   36,
+					},
+				],
+				type: "text-with-tokens",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id:          "accuracy",
+		},
+		{
+			description: "",
+			id:          "recall",
+
+		},
+		{
+			description: "",
+			id:          "precision",
+		},
+		{
+			description: "",
+			id:          "f1",
+		},
+	],
+	models: [
+		{
+			description: "A robust performance model to identify people, locations, organizations and names of miscellaneous entities.",
+			id:          "dslim/bert-base-NER",
+		},
+		{
+			description: "Flair models are typically the state of the art in named entity recognition tasks.",
+			id:          "flair/ner-english",
+		},
+	],
+	spaces:       [
+		{
+			description: "An application that can recognizes entities, extracts noun chunks and recognizes various linguistic features of each token.",
+			id:          "spacy/gradio_pipeline_visualizer",
+		},
+	],
+	summary:      "Token classification is a natural language understanding task in which a label is assigned to some tokens in a text. Some popular token classification subtasks are Named Entity Recognition (NER) and Part-of-Speech (PoS) tagging. NER models could be trained to identify specific entities in a text, such as dates, individuals and places; and PoS tagging would identify, for example, which words in a text are verbs, nouns, and punctuation marks.",
+	widgetModels: ["dslim/bert-base-NER"],
+	youtubeId:    "wVHdVlPScxA",
+};
+
+export default taskData;

package/src/translation/about.md

@@ -0,0 +1,65 @@
+## Use Cases
+
+You can find over a thousand Translation models on the Hub, but sometimes you might not find a model for the language pair you are interested in. When this happen, you can use a pretrained multilingual Translation model like [mBART](https://huggingface.co/facebook/mbart-large-cc25) and further train it on your own data in a process called fine-tuning.
+
+### Multilingual conversational agents
+
+Translation models can be used to build conversational agents across different languages. This can be done in two ways.
+
+- **Translate the dataset to a new language.** You can translate a dataset of intents (inputs) and responses to the target language. You can then train a new intent classification model with this new dataset. This allows you to proofread responses in the target language and have better control of the chatbot's outputs.
+
+* **Translate the input and output of the agent.** You can use a Translation model in user inputs so that the chatbot can process it. You can then translate the output of the chatbot into the language of the user. This approach might be less reliable as the chatbot will generate responses that were not defined before.
+
+## Inference
+
+You can use the 🤗 Transformers library with the `translation_xx_to_yy` pattern where xx is the source language code and yy is the target language code. The default model for the pipeline is [t5-base](https://huggingface.co/t5-base) which under the hood adds a task prefix indicating the task itself, e.g. “translate: English to French”.
+
+```python
+from transformers import pipeline
+en_fr_translator = pipeline("translation_en_to_fr")
+en_fr_translator("How old are you?")
+## [{'translation_text': ' quel âge êtes-vous?'}]
+```
+
+If you’d like to use a specific model checkpoint that is from one specific language to another, you can also directly use the `translation` pipeline.
+
+```python
+from transformers import pipeline
+
+model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
+translator = pipeline("translation", model=model_checkpoint)
+translator("How are you?")
+# [{'translation_text': 'Comment allez-vous ?'}]
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer translation models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_ACCESS_TOKEN);
+await inference.translation({
+  model: 't5-base',
+  inputs: 'My name is Wolfgang and I live in Berlin'
+})
+```
+
+## Useful Resources
+
+Would you like to learn more about Translation? Great! Here you can find some curated resources that you may find helpful!
+
+- [Course Chapter on Translation](https://huggingface.co/course/chapter7/4?fw=pt)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/translation.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/translation-tf.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/translation)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/translation)
+
+### Documentation
+
+- [Translation task guide](https://huggingface.co/docs/transformers/tasks/translation)

package/src/translation/data.ts

@@ -0,0 +1,68 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A dataset of copyright-free books translated into 16 different languages.",
+			id:          "opus_books",
+		},
+		{
+			description: "An example of translation between programming languages. This dataset consists of functions in Java and C#.",
+			id:          "code_x_glue_cc_code_to_code_trans",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content:
+						"My name is Omar and I live in Zürich.",
+				type: "text",
+			},
+			
+		],
+		outputs: [
+			{
+				label:   "Output",
+				content:
+						"Mein Name ist Omar und ich wohne in Zürich.",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "BLEU score is calculated by counting the number of shared single or subsequent tokens between the generated sequence and the reference. Subsequent n tokens are called “n-grams”. Unigram refers to a single token while bi-gram refers to token pairs and n-grams refer to n subsequent tokens. The score ranges from 0 to 1, where 1 means the translation perfectly matched and 0 did not match at all",
+			id:          "bleu",
+		},
+		{
+			description: "",
+			id:          "sacrebleu",
+		},
+	],
+	models: [
+		{
+			description: "A model that translates from English to French.",
+			id:          "Helsinki-NLP/opus-mt-en-fr",
+		},
+		{
+			description: "A general-purpose Transformer that can be used to translate from English to German, French, or Romanian.",
+			id:          "t5-base",
+		},
+	],
+	spaces:       [
+		{
+			description: "An application that can translate between 100 languages.",
+			id:          "Iker/Translate-100-languages",
+		},
+		{
+			description: "An application that can translate between English, Spanish and Hindi.",
+			id:          "EuroPython2022/Translate-with-Bloom",
+		},
+	],
+	summary:      "Translation is the task of converting text from one language to another.",
+	widgetModels: ["t5-small"],
+	youtubeId:    "1JvfrvZgi6c",
+};
+
+export default taskData;

package/src/unconditional-image-generation/about.md

@@ -0,0 +1,45 @@
+## About the Task
+
+Unconditional image generation is the task of generating new images without any specific input. The main goal of this is to create novel, original images that are not based on existing images.
+This can be used for a variety of applications, such as creating new artistic images, improving image recognition algorithms, or generating photorealistic images for virtual reality environments.
+
+Unconditional image generation models usually start with a *seed* that generates a *random noise vector*. The model will then use this vector to create an output image similar to the images used for training the model.
+
+An example of unconditional image generation would be generating the image of a face on a model trained with the [CelebA dataset](https://huggingface.co/datasets/huggan/CelebA-HQ) or [generating a butterfly](https://huggingface.co/spaces/huggan/butterfly-gan) on a model trained with the [Smithsonian Butterflies dataset](https://huggingface.co/datasets/ceyda/smithsonian_butterflies).
+
+[Generative adversarial networks](https://en.wikipedia.org/wiki/Generative_adversarial_network) and [Diffusion](https://huggingface.co/docs/diffusers/index) are common architectures for this task.
+
+## Use Cases
+
+Unconditional image generation can be used for a variety of applications.
+
+### Artistic Expression
+Unconditional image generation can be used to create novel, original artwork that is not based on any existing images. This can be used to explore new creative possibilities and produce unique, imaginative images.
+
+### Data Augmentation 
+Unconditional image generation models can be used to generate new images to improve the performance of image recognition algorithms. This makes algorithms more robust and able to handle a broader range of images.
+
+### Virtual Reality 
+Unconditional image generation models can be used to create photorealistic images that can be used in virtual reality environments. This makes the VR experience more immersive and realistic.
+
+### Medical Imaging 
+Unconditional image generation models can generate new medical images, such as CT or MRI scans, that can be used to train and evaluate medical imaging algorithms. This can improve the accuracy and reliability of these algorithms.
+
+### Industrial Design
+Unconditional image generation models can generate new designs for products, such as clothing or furniture, that are not based on any existing designs. This way, designers can explore new creative possibilities and produce unique, innovative designs.
+
+## Model Hosting and Inference
+
+This section should have useful information about Model Hosting and Inference
+
+## Useful Resources
+
+- [Hugging Face Diffusion Models Course](https://github.com/huggingface/diffusion-models-class)
+- [Getting Started with Diffusers](https://huggingface.co/docs/diffusers/index)
+- [Unconditional Image Generation Training](https://huggingface.co/docs/diffusers/training/unconditional_training)
+
+### Training your own model in just a few seconds
+
+In this area, you can insert useful information about training the model
+
+This page was made possible thanks to the efforts of [Someet Sahoo](https://huggingface.co/Someet24) and [Juan Carlos Piñeros](https://huggingface.co/juancopi81).

package/src/unconditional-image-generation/data.ts

@@ -0,0 +1,66 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "The CIFAR-100 dataset consists of 60000 32x32 colour images in 100 classes, with 600 images per class.",
+			id:          "cifar100",
+		},
+		{
+			description: "Multiple images of celebrities, used for facial expression translation.",
+			id:          "CelebA",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Seed",
+				content: "42",
+				type:    "text",
+			},
+			{
+				label:   "Number of images to generate:",
+				content: "4",
+				type:    "text",
+			},
+		],
+		outputs: [
+			{
+				filename: "unconditional-image-generation-output.jpeg",
+				type:     "img",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "The inception score (IS) evaluates the quality of generated images. It measures the diversity of the generated images (the model predictions are evenly distributed across all possible labels) and their 'distinction' or 'sharpness' (the model confidently predicts a single label for each image).",
+			id:          "Inception score (IS)",
+		},
+		{
+			description: "The Fréchet Inception Distance (FID) evaluates the quality of images created by a generative model by calculating the distance between feature vectors for real and generated images.",
+			id:          "Frećhet Inception Distance (FID)",
+		},
+	],
+	models: [
+		{
+			description: "High-quality image generation model trained on the CIFAR-10 dataset. It synthesizes images of the ten classes presented in the dataset using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics.",
+			id:          "google/ddpm-cifar10-32",
+		},
+		{
+			description: "High-quality image generation model trained on the 256x256 CelebA-HQ dataset. It synthesizes images of faces using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics.",
+			id:          "google/ddpm-celebahq-256",
+		},
+	],
+	spaces:       [
+		{
+			description: "An application that can generate realistic faces.",
+			id:          "CompVis/celeba-latent-diffusion",
+		},
+	],
+	summary:      "Unconditional image generation is the task of generating images with no condition in any context (like a prompt text or another image). Once trained, the model will create images that resemble its training data distribution.",
+	widgetModels: [""],
+	// TODO: Add related video
+	youtubeId:    "",
+};
+
+export default taskData;