@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/tasks/text-classification/about.md

@@ -0,0 +1,173 @@
+## Use Cases
+
+### Sentiment Analysis on Customer Reviews
+
+You can track the sentiments of your customers from the product reviews using sentiment analysis models. This can help understand churn and retention by grouping reviews by sentiment, to later analyze the text and make strategic decisions based on this knowledge.
+
+## Task Variants
+
+### Natural Language Inference (NLI)
+
+In NLI the model determines the relationship between two given texts. Concretely, the model takes a premise and a hypothesis and returns a class that can either be:
+
+- **entailment**, which means the hypothesis is true.
+- **contraction**, which means the hypothesis is false.
+- **neutral**, which means there's no relation between the hypothesis and the premise.
+
+The benchmark dataset for this task is GLUE (General Language Understanding Evaluation). NLI models have different variants, such as Multi-Genre NLI, Question NLI and Winograd NLI.
+
+### Multi-Genre NLI (MNLI)
+
+MNLI is used for general NLI. Here are som examples:
+
+```
+Example 1:
+    Premise: A man inspects the uniform of a figure in some East Asian country.
+    Hypothesis: The man is sleeping.
+    Label: Contradiction
+
+Example 2:
+    Premise: Soccer game with multiple males playing.
+    Hypothesis: Some men are playing a sport.
+    Label: Entailment
+```
+
+#### Inference
+
+You can use the 🤗 Transformers library `text-classification` pipeline to infer with NLI models.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("text-classification", model = "roberta-large-mnli")
+classifier("A soccer game with multiple males playing. Some men are playing a sport.")
+## [{'label': 'ENTAILMENT', 'score': 0.98}]
+```
+
+### Question Natural Language Inference (QNLI)
+
+QNLI is the task of determining if the answer to a certain question can be found in a given document. If the answer can be found the label is “entailment”. If the answer cannot be found the label is “not entailment".
+
+```
+Question: What percentage of marine life died during the extinction?
+Sentence: It is also known as the “Great Dying” because it is considered the largest mass extinction in the Earth’s history.
+Label: not entailment
+
+Question: Who was the London Weekend Television’s Managing Director?
+Sentence: The managing director of London Weekend Television (LWT), Greg Dyke, met with the representatives of the "big five" football clubs in England in 1990.
+Label: entailment
+```
+
+#### Inference
+
+You can use the 🤗 Transformers library `text-classification` pipeline to infer with QNLI models. The model returns the label and the confidence.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("text-classification", model = "cross-encoder/qnli-electra-base")
+classifier("Where is the capital of France?, Paris is the capital of France.")
+## [{'label': 'entailment', 'score': 0.997}]
+```
+
+### Sentiment Analysis
+
+In Sentiment Analysis, the classes can be polarities like positive, negative, neutral, or sentiments such as happiness or anger.
+
+#### Inference
+
+You can use the 🤗 Transformers library with the `sentiment-analysis` pipeline to infer with Sentiment Analysis models. The model returns the label with the score.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("sentiment-analysis")
+classifier("I loved Star Wars so much!")
+##  [{'label': 'POSITIVE', 'score': 0.99}
+```
+
+### Quora Question Pairs
+
+Quora Question Pairs models assess whether two provided questions are paraphrases of each other. The model takes two questions and returns a binary value, with 0 being mapped to “not paraphrase” and 1 to “paraphrase". The benchmark dataset is [Quora Question Pairs](https://huggingface.co/datasets/glue/viewer/qqp/test) inside the [GLUE benchmark](https://huggingface.co/datasets/glue). The dataset consists of question pairs and their labels.
+
+```
+Question1: “How can I increase the speed of my internet connection while using a VPN?”
+Question2: How can Internet speed be increased by hacking through DNS?
+Label: Not paraphrase
+
+Question1: “What can make Physics easy to learn?”
+Question2: “How can you make physics easy to learn?”
+Label: Paraphrase
+```
+
+#### Inference
+
+You can use the 🤗 Transformers library `text-classification` pipeline to infer with QQPI models.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("text-classification", model = "textattack/bert-base-uncased-QQP")
+classifier("Which city is the capital of France?, Where is the capital of France?")
+## [{'label': 'paraphrase', 'score': 0.998}]
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer text classification models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_TOKEN);
+await inference.conversational({
+	model: "distilbert-base-uncased-finetuned-sst-2-english",
+	inputs: "I love this movie!",
+});
+```
+
+### Grammatical Correctness
+
+Linguistic Acceptability is the task of assessing the grammatical acceptability of a sentence. The classes in this task are “acceptable” and “unacceptable”. The benchmark dataset used for this task is [Corpus of Linguistic Acceptability (CoLA)](https://huggingface.co/datasets/glue/viewer/cola/test). The dataset consists of texts and their labels.
+
+```
+Example: Books were sent to each other by the students.
+Label: Unacceptable
+
+Example: She voted for herself.
+Label: Acceptable.
+```
+
+#### Inference
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("text-classification", model = "textattack/distilbert-base-uncased-CoLA")
+classifier("I will walk to home when I went through the bus.")
+##  [{'label': 'unacceptable', 'score': 0.95}]
+```
+
+## Useful Resources
+
+Would you like to learn more about the topic? Awesome! Here you can find some curated resources that you may find helpful!
+
+- [SetFitABSA: Few-Shot Aspect Based Sentiment Analysis using SetFit](https://huggingface.co/blog/setfit-absa)
+- [Course Chapter on Fine-tuning a Text Classification Model](https://huggingface.co/course/chapter3/1?fw=pt)
+- [Getting Started with Sentiment Analysis using Python](https://huggingface.co/blog/sentiment-analysis-python)
+- [Sentiment Analysis on Encrypted Data with Homomorphic Encryption](https://huggingface.co/blog/sentiment-analysis-fhe)
+- [Leveraging Hugging Face for complex text classification use cases](https://huggingface.co/blog/classification-use-cases)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/text_classification.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/text_classification-tf.ipynb)
+- [Flax](https://github.com/huggingface/notebooks/blob/master/examples/text_classification_flax.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification)
+- [Flax](https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification)
+
+### Documentation
+
+- [Text classification task guide](https://huggingface.co/docs/transformers/tasks/sequence_classification)

package/src/tasks/text-classification/data.ts

@@ -0,0 +1,103 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A widely used dataset used to benchmark multiple variants of text classification.",
+			id: "nyu-mll/glue",
+		},
+		{
+			description: "A text classification dataset used to benchmark natural language inference models",
+			id: "stanfordnlp/snli",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Input",
+				content: "I love Hugging Face!",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				type: "chart",
+				data: [
+					{
+						label: "POSITIVE",
+						score: 0.9,
+					},
+					{
+						label: "NEUTRAL",
+						score: 0.1,
+					},
+					{
+						label: "NEGATIVE",
+						score: 0.0,
+					},
+				],
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id: "accuracy",
+		},
+		{
+			description: "",
+			id: "recall",
+		},
+		{
+			description: "",
+			id: "precision",
+		},
+		{
+			description:
+				"The F1 metric is the harmonic mean of the precision and recall. It can be calculated as: F1 = 2 * (precision * recall) / (precision + recall)",
+			id: "f1",
+		},
+	],
+	models: [
+		{
+			description: "A robust model trained for sentiment analysis.",
+			id: "distilbert/distilbert-base-uncased-finetuned-sst-2-english",
+		},
+		{
+			description: "A sentiment analysis model specialized in financial sentiment.",
+			id: "ProsusAI/finbert",
+		},
+		{
+			description: "A sentiment analysis model specialized in analyzing tweets.",
+			id: "cardiffnlp/twitter-roberta-base-sentiment-latest",
+		},
+		{
+			description: "A model that can classify languages.",
+			id: "papluca/xlm-roberta-base-language-detection",
+		},
+		{
+			description: "A model that can classify text generation attacks.",
+			id: "meta-llama/Prompt-Guard-86M",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that can classify financial sentiment.",
+			id: "IoannisTr/Tech_Stocks_Trading_Assistant",
+		},
+		{
+			description: "A dashboard that contains various text classification tasks.",
+			id: "miesnerjacob/Multi-task-NLP",
+		},
+		{
+			description: "An application that analyzes user reviews in healthcare.",
+			id: "spacy/healthsea-demo",
+		},
+	],
+	summary:
+		"Text Classification is the task of assigning a label or class to a given text. Some use cases are sentiment analysis, natural language inference, and assessing grammatical correctness.",
+	widgetModels: ["distilbert/distilbert-base-uncased-finetuned-sst-2-english"],
+	youtubeId: "leNG9fN9FQU",
+};
+
+export default taskData;

package/src/tasks/text-classification/inference.ts

@@ -0,0 +1,51 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Text Classification inference
+ */
+export interface TextClassificationInput {
+	/**
+	 * The text to classify
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TextClassificationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Text Classification
+ */
+export interface TextClassificationParameters {
+	function_to_apply?: ClassificationOutputTransform;
+	/**
+	 * When specified, limits the output to the top K most probable classes.
+	 */
+	top_k?: number;
+	[property: string]: unknown;
+}
+/**
+ * The function to apply to the model outputs in order to retrieve the scores.
+ */
+export type ClassificationOutputTransform = "sigmoid" | "softmax" | "none";
+export type TextClassificationOutput = TextClassificationOutputElement[];
+/**
+ * Outputs of inference for the Text Classification task
+ */
+export interface TextClassificationOutputElement {
+	/**
+	 * The predicted class label.
+	 */
+	label: string;
+	/**
+	 * The corresponding probability.
+	 */
+	score: number;
+	[property: string]: unknown;
+}

package/src/tasks/text-classification/spec/input.json

@@ -0,0 +1,35 @@
+{
+	"$id": "/inference/schemas/text-classification/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Text Classification inference",
+	"title": "TextClassificationInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"description": "The text to classify",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TextClassificationParameters"
+		}
+	},
+	"$defs": {
+		"TextClassificationParameters": {
+			"title": "TextClassificationParameters",
+			"description": "Additional inference parameters for Text Classification",
+			"type": "object",
+			"properties": {
+				"function_to_apply": {
+					"title": "TextClassificationOutputTransform",
+					"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutputTransform"
+				},
+				"top_k": {
+					"type": "integer",
+					"description": "When specified, limits the output to the top K most probable classes."
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/text-classification/spec/output.json

@@ -0,0 +1,11 @@
+{
+	"$id": "/inference/schemas/text-classification/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Text Classification task",
+	"title": "TextClassificationOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutput"
+	}
+}

package/src/tasks/text-generation/about.md

@@ -0,0 +1,154 @@
+This task covers guides on both [text-generation](https://huggingface.co/models?pipeline_tag=text-generation&sort=downloads) and [text-to-text generation](https://huggingface.co/models?pipeline_tag=text2text-generation&sort=downloads) models. Popular large language models that are used for chats or following instructions are also covered in this task. You can find the list of selected open-source large language models [here](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard), ranked by their performance scores.
+
+## Use Cases
+
+### Instruction Models
+
+A model trained for text generation can be later adapted to follow instructions. You can try some of the most powerful instruction-tuned open-access models like Mixtral 8x7B, Cohere Command R+, and Meta Llama3 70B [at Hugging Chat](https://huggingface.co/chat).
+
+### Code Generation
+
+A Text Generation model, also known as a causal language model, can be trained on code from scratch to help the programmers in their repetitive coding tasks. One of the most popular open-source models for code generation is StarCoder, which can generate code in 80+ languages. You can try it [here](https://huggingface.co/spaces/bigcode/bigcode-playground).
+
+### Stories Generation
+
+A story generation model can receive an input like "Once upon a time" and proceed to create a story-like text based on those first words. You can try [this application](https://huggingface.co/spaces/mosaicml/mpt-7b-storywriter) which contains a model trained on story generation, by MosaicML.
+
+If your generative model training data is different than your use case, you can train a causal language model from scratch. Learn how to do it in the free transformers [course](https://huggingface.co/course/chapter7/6?fw=pt)!
+
+## Task Variants
+
+### Completion Generation Models
+
+A popular variant of Text Generation models predicts the next word given a bunch of words. Word by word a longer text is formed that results in for example:
+
+- Given an incomplete sentence, complete it.
+- Continue a story given the first sentences.
+- Provided a code description, generate the code.
+
+The most popular models for this task are GPT-based models, [Mistral](mistralai/Mistral-7B-v0.1) or [Llama series](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf). These models are trained on data that has no labels, so you just need plain text to train your own model. You can train text generation models to generate a wide variety of documents, from code to stories.
+
+### Text-to-Text Generation Models
+
+These models are trained to learn the mapping between a pair of texts (e.g. translation from one language to another). The most popular variants of these models are [NLLB](facebook/nllb-200-distilled-600M), [FLAN-T5](https://huggingface.co/google/flan-t5-xxl), and [BART](https://huggingface.co/docs/transformers/model_doc/bart). Text-to-Text models are trained with multi-tasking capabilities, they can accomplish a wide range of tasks, including summarization, translation, and text classification.
+
+## Language Model Variants
+
+When it comes to text generation, the underlying language model can come in several types:
+
+- **Base models:** refers to plain language models like [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) and [Meta Llama-3-70b](https://huggingface.co/meta-llama/Meta-Llama-3-70B). These models are good for fine-tuning and few-shot prompting.
+
+- **Instruction-trained models:** these models are trained in a multi-task manner to follow a broad range of instructions like "Write me a recipe for chocolate cake". Models like [Qwen 2 7B](https://huggingface.co/Qwen/Qwen2-7B-Instruct), [Yi 1.5 34B Chat](https://huggingface.co/01-ai/Yi-1.5-34B-Chat), and [Meta Llama 70B Instruct](https://huggingface.co/meta-llama/Meta-Llama-3-70B-Instruct) are examples of instruction-trained models. In general, instruction-trained models will produce better responses to instructions than base models.
+
+- **Human feedback models:** these models extend base and instruction-trained models by incorporating human feedback that rates the quality of the generated text according to criteria like [helpfulness, honesty, and harmlessness](https://arxiv.org/abs/2112.00861). The human feedback is then combined with an optimization technique like reinforcement learning to align the original model to be closer with human preferences. The overall methodology is often called [Reinforcement Learning from Human Feedback](https://huggingface.co/blog/rlhf), or RLHF for short. [Zephyr ORPO 141B A35B](https://huggingface.co/HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1) is an open-source model aligned through human feedback.
+
+## Text Generation from Image and Text
+
+There are language models that can input both text and image and output text, called vision language models. [IDEFICS 2](https://huggingface.co/HuggingFaceM4/idefics2-8b) and [MiniCPM Llama3 V](https://huggingface.co/openbmb/MiniCPM-Llama3-V-2_5) are good examples. They accept the same generation parameters as other language models. However, since they also take images as input, you have to use them with the `image-to-text` pipeline. You can find more information about this in the [image-to-text task page](https://huggingface.co/tasks/image-to-text).
+
+## Inference
+
+You can use the 🤗 Transformers library `text-generation` pipeline to do inference with Text Generation models. It takes an incomplete text and returns multiple outputs with which the text can be completed.
+
+```python
+from transformers import pipeline
+generator = pipeline('text-generation', model = 'HuggingFaceH4/zephyr-7b-beta')
+generator("Hello, I'm a language model", max_length = 30, num_return_sequences=3)
+## [{'generated_text': "Hello, I'm a language modeler. So while writing this, when I went out to meet my wife or come home she told me that my"},
+##  {'generated_text': "Hello, I'm a language modeler. I write and maintain software in Python. I love to code, and that includes coding things that require writing"}, ...
+```
+
+[Text-to-Text generation models](https://huggingface.co/models?pipeline_tag=text2text-generation&sort=downloads) have a separate pipeline called `text2text-generation`. This pipeline takes an input containing the sentence including the task and returns the output of the accomplished task.
+
+```python
+from transformers import pipeline
+
+text2text_generator = pipeline("text2text-generation")
+text2text_generator("question: What is 42 ? context: 42 is the answer to life, the universe and everything")
+[{'generated_text': 'the answer to life, the universe and everything'}]
+
+text2text_generator("translate from English to French: I'm very happy")
+[{'generated_text': 'Je suis très heureux'}]
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer text classification models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_TOKEN);
+await inference.conversational({
+	model: "distilbert-base-uncased-finetuned-sst-2-english",
+	inputs: "I love this movie!",
+});
+```
+
+## Text Generation Inference
+
+[Text Generation Inference (TGI)](https://github.com/huggingface/text-generation-inference) is an open-source toolkit for serving LLMs tackling challenges such as response time. TGI powers inference solutions like [Inference Endpoints](https://huggingface.co/inference-endpoints) and [Hugging Chat](https://huggingface.co/chat/), as well as multiple community projects. You can use it to deploy any supported open-source large language model of your choice.
+
+## ChatUI Spaces
+
+Hugging Face Spaces includes templates to easily deploy your own instance of a specific application. [ChatUI](https://github.com/huggingface/chat-ui) is an open-source interface that enables serving conversational interface for large language models and can be deployed with few clicks at Spaces. TGI powers these Spaces under the hood for faster inference. Thanks to the template, you can deploy your own instance based on a large language model with only a few clicks and customize it. Learn more about it [here](https://huggingface.co/docs/hub/spaces-sdks-docker-chatui) and create your large language model instance [here](https://huggingface.co/new-space?template=huggingchat/chat-ui-template).
+
+![ChatUI](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/os_llms/docker_chat.png)
+
+## Useful Resources
+
+Would you like to learn more about the topic? Awesome! Here you can find some curated resources that you may find helpful!
+
+### Tools within Hugging Face Ecosystem
+
+- You can use [PEFT](https://github.com/huggingface/peft) to adapt large language models in efficient way.
+- [ChatUI](https://github.com/huggingface/chat-ui) is the open-source interface to conversate with Large Language Models.
+- [text-generation-inferface](https://github.com/huggingface/text-generation-inference)
+- [HuggingChat](https://huggingface.co/chat/) is a chat interface powered by Hugging Face to chat with powerful models like Meta Llama 3 70B, Mixtral 8x7B, etc.
+
+### Documentation
+
+- [PEFT documentation](https://huggingface.co/docs/peft/index)
+- [ChatUI Docker Spaces](https://huggingface.co/docs/hub/spaces-sdks-docker-chatui)
+- [Causal language modeling task guide](https://huggingface.co/docs/transformers/tasks/language_modeling)
+- [Text generation strategies](https://huggingface.co/docs/transformers/generation_strategies)
+- [Course chapter on training a causal language model from scratch](https://huggingface.co/course/chapter7/6?fw=pt)
+
+### Model Inference & Deployment
+
+- [Optimizing your LLM in production](https://huggingface.co/blog/optimize-llm)
+- [Open-Source Text Generation & LLM Ecosystem at Hugging Face](https://huggingface.co/blog/os-llms)
+- [Introducing RWKV - An RNN with the advantages of a transformer](https://huggingface.co/blog/rwkv)
+- [Llama 2 is at Hugging Face](https://huggingface.co/blog/llama2)
+- [Guiding Text Generation with Constrained Beam Search in 🤗 Transformers](https://huggingface.co/blog/constrained-beam-search)
+- [Code generation with Hugging Face](https://huggingface.co/spaces/codeparrot/code-generation-models)
+- [Assisted Generation: a new direction toward low-latency text generation](https://huggingface.co/blog/assisted-generation)
+- [How to generate text: using different decoding methods for language generation with Transformers](https://huggingface.co/blog/how-to-generate)
+- [Faster Text Generation with TensorFlow and XLA](https://huggingface.co/blog/tf-xla-generate)
+
+### Model Fine-tuning/Training
+
+- [Non-engineers guide: Train a LLaMA 2 chatbot](https://huggingface.co/blog/Llama2-for-non-engineers)
+- [Training CodeParrot 🦜 from Scratch](https://huggingface.co/blog/codeparrot)
+- [Creating a Coding Assistant with StarCoder](https://huggingface.co/blog/starchat-alpha)
+
+### Advanced Concepts Explained Simply
+
+- [Mixture of Experts Explained](https://huggingface.co/blog/moe)
+
+### Advanced Fine-tuning/Training Recipes
+
+- [Fine-tuning Llama 2 70B using PyTorch FSDP](https://huggingface.co/blog/ram-efficient-pytorch-fsdp)
+- [The N Implementation Details of RLHF with PPO](https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo)
+- [Preference Tuning LLMs with Direct Preference Optimization Methods](https://huggingface.co/blog/pref-tuning)
+- [Fine-tune Llama 2 with DPO](https://huggingface.co/blog/dpo-trl)
+
+### Notebooks
+
+- [Training a CLM in Flax](https://github.com/huggingface/notebooks/blob/master/examples/causal_language_modeling_flax.ipynb)
+- [Training a CLM in TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/language_modeling_from_scratch-tf.ipynb)
+- [Training a CLM in PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/language_modeling_from_scratch.ipynb)
+
+### Scripts for training
+
+- [Training a CLM in PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling)
+- [Training a CLM in TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling)
+- [Text Generation in PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-generation)

package/src/tasks/text-generation/data.ts

@@ -0,0 +1,114 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A large multilingual dataset of text crawled from the web.",
+			id: "mc4",
+		},
+		{
+			description:
+				"Diverse open-source data consisting of 22 smaller high-quality datasets. It was used to train GPT-Neo.",
+			id: "the_pile",
+		},
+		{
+			description: "Truly open-source, curated and cleaned dialogue dataset.",
+			id: "HuggingFaceH4/ultrachat_200k",
+		},
+		{
+			description: "An instruction dataset with preference ratings on responses.",
+			id: "openbmb/UltraFeedback",
+		},
+		{
+			description: "A large synthetic dataset for alignment of text generation models.",
+			id: "argilla/magpie-ultra-v0.1",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Input",
+				content: "Once upon a time,",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Output",
+				content:
+					"Once upon a time, we knew that our ancestors were on the verge of extinction. The great explorers and poets of the Old World, from Alexander the Great to Chaucer, are dead and gone. A good many of our ancient explorers and poets have",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"Cross Entropy is a metric that calculates the difference between two probability distributions. Each probability distribution is the distribution of predicted words",
+			id: "Cross Entropy",
+		},
+		{
+			description:
+				"The Perplexity metric is the exponential of the cross-entropy loss. It evaluates the probabilities assigned to the next word by the model. Lower perplexity indicates better performance",
+			id: "Perplexity",
+		},
+	],
+	models: [
+		{
+			description: "A text-generation model trained to follow instructions.",
+			id: "google/gemma-2-2b-it",
+		},
+		{
+			description: "Very powerful text generation model trained to follow instructions.",
+			id: "meta-llama/Meta-Llama-3.1-8B-Instruct",
+		},
+		{
+			description: "Small yet powerful text generation model.",
+			id: "microsoft/Phi-3-mini-4k-instruct",
+		},
+		{
+			description: "A very powerful model that can solve mathematical problems.",
+			id: "AI-MO/NuminaMath-7B-TIR",
+		},
+		{
+			description: "Strong text generation model to follow instructions.",
+			id: "Qwen/Qwen2.5-7B-Instruct",
+		},
+		{
+			description: "Very strong open-source large language model.",
+			id: "nvidia/Llama-3.1-Nemotron-70B-Instruct",
+		},
+	],
+	spaces: [
+		{
+			description: "A leaderboard to compare different open-source text generation models based on various benchmarks.",
+			id: "open-llm-leaderboard/open_llm_leaderboard",
+		},
+		{
+			description: "A leaderboard for comparing chain-of-thought performance of models.",
+			id: "logikon/open_cot_leaderboard",
+		},
+		{
+			description: "An text generation based application based on a very powerful LLaMA2 model.",
+			id: "ysharma/Explore_llamav2_with_TGI",
+		},
+		{
+			description: "An text generation based application to converse with Zephyr model.",
+			id: "HuggingFaceH4/zephyr-chat",
+		},
+		{
+			description: "A leaderboard that ranks text generation models based on blind votes from people.",
+			id: "lmsys/chatbot-arena-leaderboard",
+		},
+		{
+			description: "An chatbot to converse with a very powerful text generation model.",
+			id: "mlabonne/phixtral-chat",
+		},
+	],
+	summary:
+		"Generating text is the task of generating new text given another text. These models can, for example, fill in incomplete text or paraphrase.",
+	widgetModels: ["mistralai/Mistral-Nemo-Instruct-2407"],
+	youtubeId: "e9gNEAlsOvU",
+};
+
+export default taskData;