@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/tasks/reinforcement-learning/about.md

@@ -0,0 +1,167 @@
+## Use Cases
+
+### Gaming
+
+Reinforcement learning is known for its application to video games. Since the games provide a safe environment for the agent to be trained in the sense that it is perfectly defined and controllable, this makes them perfect candidates for experimentation and will help a lot to learn about the capabilities and limitations of various RL algorithms.
+
+There are many videos on the Internet where a game-playing reinforcement learning agent starts with a terrible gaming strategy due to random initialization of its settings, but over iterations, the agent gets better and better with each episode of the training. This [paper](https://arxiv.org/abs/1912.10944) mainly investigates the performance of RL in popular games such as Minecraft or Dota2. The agent's performance can exceed a human player's, although there are still some challenges mainly related to efficiency in constructing the gaming policy of the reinforcement learning agent.
+
+### Trading and Finance
+
+Reinforcement learning is the science to train computers to make decisions and thus has a novel use in trading and finance. All time-series models are helpful in predicting prices, volume and future sales of a product or a stock. Reinforcement based automated agents can decide to sell, buy or hold a stock. It shifts the impact of AI in this field to real time decision making rather than just prediction of prices. The glossary given below will clear some parameters to as to how we can train a model to take these decisions.
+
+## Task Variants
+
+### Model Based RL
+
+In model based reinforcement learning techniques intend to create a model of the environment, learn the state transition probabilities and the reward function, to find the optimal action. Some typical examples for model based reinforcement learning algorithms are dynamic programming, value iteration and policy iteration.
+
+### Model Free RL
+
+In model free reinforcement learning, agent decides on optimal actions based on its experience in the environment and the reward it collects from it. This is one of the most commonly used algorithms beneficial in complex environments, where modeling of state transition probabilities and reward functions are difficult. Some of the examples of model free reinforcement learning are SARSA, Q-Learning, actor-critic and proximal policy optimization (PPO) algorithms.
+
+## Glossary
+
+<!-- ![RL Loop](https://huggingface.co/blog/assets/63_deep_rl_intro/RL_process.jpg "Agent Environment Interaction") TODO: Uncomment image for visual understanding if it fits within the page-->
+
+**Agent:** The learner and the decision maker.
+
+**Environment:** The part of the world the agent interacts, comprising everything outside the agent.
+
+Observations and states are the information our agent gets from the environment. In the case of a video game, it can be a frame (a screenshot). In the case of the trading agent, it can be the value of a certain stock.
+
+**State:** Complete description of the state of the environment with no hidden information.
+
+**Observation:** Partial description of the state, in a partially observed environment.
+
+**Action:** The decision taken by the agent.
+
+**Reward:** The numerical feedback signal that the agent receives from the environment based on the chosen action.
+
+**Return:** Cumulative Reward. In the simplest case, the return is the sum of the rewards.
+
+**Episode:** For some applications there is a natural notion of final time step. In this case, there is a starting point and an ending point (a terminal state). This creates an episode: a list of States, Actions, Rewards, and new States. For instance, think about Chess: an episode begins at the initial board position and ends when the game is over.
+
+**Policy:** The Policy is the brain of the Agent, it’s the function that tells what action to take given the state. So it defines the agent’s behavior at a given time. Reinforcement learning methods specify how the agent’s policy is changed as a result of its experience.
+
+## Inference
+
+Inference in reinforcement learning differs from other modalities, in which there's a model and test data. In reinforcement learning, once you have trained an agent in an environment, you try to run the trained agent for additional steps to get the average reward.
+
+A typical training cycle consists of gathering experience from the environment, training the agent, and running the agent on a test environment to obtain average reward. Below there's a snippet on how you can interact with the environment using the `gymnasium` library, train an agent using `stable-baselines3`, evalute the agent on test environment and infer actions from the trained agent.
+
+```python
+# Here we are running 20 episodes of CartPole-v1 environment, taking random actions
+import gymnasium as gym
+
+env = gym.make("CartPole-v1")
+observation, info = env.reset()
+
+for _ in range(20):
+	action = env.action_space.sample() # samples random action from action sample space
+
+        # the agent takes the action
+	observation, reward, terminated, truncated, info = env.step(action)
+
+
+# if the agent reaches terminal state, we reset the environment
+if terminated or truncated:
+
+	print("Environment is reset")
+	observation = env.reset()
+
+env.close()
+```
+
+Below snippet shows how to train a PPO model on LunarLander-v2 environment using `stable-baselines3` library and saving the model
+
+```python
+from stable_baselines3 import PPO
+
+# initialize the environment
+
+env = gym.make("LunarLander-v2")
+
+# initialize the model
+
+model = PPO(policy = "MlpPolicy",
+			env = env,
+			n_steps = 1024,
+			batch_size = 64,
+			n_epochs = 4,
+			verbose = 1)
+
+# train the model for 1000 time steps
+model.learn(total_timesteps = 1000)
+
+# Saving the model in desired directory
+model_name = "PPO-LunarLander-v2"
+model.save(model_name)
+```
+
+Below code shows how to evaluate an agent trained using `stable-baselines3`
+
+```python
+# Loading a saved model and evaluating the model for 10 episodes
+from stable_baselines3.common.evaluation import evaluate_policy
+from stable_baselines3 import PPO
+
+
+env = gym.make("LunarLander-v2")
+# Loading the saved model
+model = PPO.load("PPO-LunarLander-v2",env=env)
+
+# Initializating the evaluation environment
+eval_env = gym.make("LunarLander-v2")
+
+# Running the trained agent on eval_env for 10 time steps and getting the mean reward
+mean_reward, std_reward = evaluate_policy(model, eval_env, n_eval_episodes = 10,
+										  deterministic=True)
+
+print(f"mean_reward={mean_reward:.2f} +/- {std_reward}")
+```
+
+Below code snippet shows how to infer actions from an agent trained using `stable-baselines3`
+
+```python
+from stable_baselines3.common.evaluation import evaluate_policy
+from stable_baselines3 import PPO
+
+# Loading the saved model
+model = PPO.load("PPO-LunarLander-v2",env=env)
+
+# Getting the environment from the trained agent
+env = model.get_env()
+
+obs = env.reset()
+for i in range(1000):
+	# getting action predictions from the trained agent
+	action, _states = model.predict(obs, deterministic=True)
+
+	# taking the predicted action in the environment to observe next state and rewards
+    obs, rewards, dones, info = env.step(action)
+```
+
+For more information, you can check out the documentations of the respective libraries.
+
+[Gymnasium Documentation](https://gymnasium.farama.org/)
+[Stable Baselines Documentation](https://stable-baselines3.readthedocs.io/en/master/)
+
+## Useful Resources
+
+Would you like to learn more about the topic? Awesome! Here you can find some curated resources that you may find helpful!
+
+- [HuggingFace Deep Reinforcement Learning Class](https://github.com/huggingface/deep-rl-class)
+- [Introduction to Deep Reinforcement Learning](https://huggingface.co/blog/deep-rl-intro)
+- [Stable Baselines Integration with HuggingFace](https://huggingface.co/blog/sb3)
+- Learn how reinforcement learning is used in conversational agents in this blog: [Illustrating Reinforcement Learning from Human Feedback (RLHF)](https://huggingface.co/blog/rlhf)
+- [Reinforcement Learning from Human Feedback From Zero to ChatGPT](https://www.youtube.com/watch?v=EAd4oQtEJOM)
+- [Guide on Multi-Agent Competition Systems](https://huggingface.co/blog/aivsai)
+
+### Notebooks
+
+- [Train a Deep Reinforcement Learning lander agent to land correctly on the Moon 🌕 using Stable-Baselines3](https://github.com/huggingface/deep-rl-class/blob/main/notebooks/unit1/unit1.ipynb)
+- [Introduction to Unity MLAgents](https://github.com/huggingface/deep-rl-class/blob/main/notebooks/unit5/unit5.ipynb)
+- [Training Decision Transformers with 🤗 transformers](https://github.com/huggingface/blog/blob/main/notebooks/101_train-decision-transformers.ipynb)
+
+This page was made possible thanks to the efforts of [Ram Ananth](https://huggingface.co/RamAnanth1), [Emilio Lehoucq](https://huggingface.co/emiliol), [Sagar Mathpal](https://huggingface.co/sagarmathpal) and [Osman Alenbey](https://huggingface.co/osman93).

package/src/tasks/reinforcement-learning/data.ts

@@ -0,0 +1,75 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A curation of widely used datasets for Data Driven Deep Reinforcement Learning (D4RL)",
+			id: "edbeeching/decision_transformer_gym_replay",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "State",
+				content: "Red traffic light, pedestrians are about to pass.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Action",
+				content: "Stop the car.",
+				type: "text",
+			},
+			{
+				label: "Next State",
+				content: "Yellow light, pedestrians have crossed.",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"Accumulated reward across all time steps discounted by a factor that ranges between 0 and 1 and determines how much the agent optimizes for future relative to immediate rewards. Measures how good is the policy ultimately found by a given algorithm considering uncertainty over the future.",
+			id: "Discounted Total Reward",
+		},
+		{
+			description:
+				"Average return obtained after running the policy for a certain number of evaluation episodes. As opposed to total reward, mean reward considers how much reward a given algorithm receives while learning.",
+			id: "Mean Reward",
+		},
+		{
+			description:
+				"Measures how good a given algorithm is after a predefined time. Some algorithms may be guaranteed to converge to optimal behavior across many time steps. However, an agent that reaches an acceptable level of optimality after a given time horizon may be preferable to one that ultimately reaches optimality but takes a long time.",
+			id: "Level of Performance After Some Time",
+		},
+	],
+	models: [
+		{
+			description: "A Reinforcement Learning model trained on expert data from the Gym Hopper environment",
+
+			id: "edbeeching/decision-transformer-gym-hopper-expert",
+		},
+		{
+			description: "A PPO agent playing seals/CartPole-v0 using the stable-baselines3 library and the RL Zoo.",
+			id: "HumanCompatibleAI/ppo-seals-CartPole-v0",
+		},
+	],
+	spaces: [
+		{
+			description: "An application for a cute puppy agent learning to catch a stick.",
+			id: "ThomasSimonini/Huggy",
+		},
+		{
+			description: "An application to play Snowball Fight with a reinforcement learning agent.",
+			id: "ThomasSimonini/SnowballFight",
+		},
+	],
+	summary:
+		"Reinforcement learning is the computational approach of learning from action by interacting with an environment through trial and error and receiving rewards (negative or positive) as feedback",
+	widgetModels: [],
+	youtubeId: "q0BiUn5LiBc",
+};
+
+export default taskData;

package/src/tasks/sentence-similarity/about.md

@@ -0,0 +1,97 @@
+## Use Cases 🔍
+
+### Information Retrieval
+
+You can extract information from documents using Sentence Similarity models. The first step is to rank documents using Passage Ranking models. You can then get to the top ranked document and search it with Sentence Similarity models by selecting the sentence that has the most similarity to the input query.
+
+## The Sentence Transformers library
+
+The [Sentence Transformers](https://www.sbert.net/) library is very powerful for calculating embeddings of sentences, paragraphs, and entire documents. An embedding is just a vector representation of a text and is useful for finding how similar two texts are.
+
+You can find and use [hundreds of Sentence Transformers](https://huggingface.co/models?library=sentence-transformers&sort=downloads) models from the Hub by directly using the library, playing with the widgets in the browser or using Inference Endpoints.
+
+## Task Variants
+
+### Passage Ranking
+
+Passage Ranking is the task of ranking documents based on their relevance to a given query. The task is evaluated on Mean Reciprocal Rank. These models take one query and multiple documents and return ranked documents according to the relevancy to the query. 📄
+
+You can infer with Passage Ranking models using [Inference Endpoints](https://huggingface.co/inference-endpoints). The Passage Ranking model inputs are a query for which we look for relevancy in the documents and the documents we want to search. The model will return scores according to the relevancy of these documents for the query.
+
+```python
+import json
+import requests
+
+API_URL = "https://api-inference.huggingface.co/models/sentence-transformers/msmarco-distilbert-base-tas-b"
+headers = {"Authorization": f"Bearer {api_token}"}
+
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
+
+data = query(
+    {
+        "inputs": {
+            "source_sentence": "That is a happy person",
+            "sentences": [
+                "That is a happy dog",
+                "That is a very happy person",
+                "Today is a sunny day"
+            ]
+        }
+    }
+## [0.853, 0.981, 0.655]
+```
+
+### Semantic Textual Similarity
+
+Semantic Textual Similarity is the task of evaluating how similar two texts are in terms of meaning. These models take a source sentence and a list of sentences in which we will look for similarities and will return a list of similarity scores. The benchmark dataset is the [Semantic Textual Similarity Benchmark](http://ixa2.si.ehu.eus/stswiki/index.php/STSbenchmark). The task is evaluated on Pearson’s Rank Correlation.
+
+```python
+import json
+import requests
+
+API_URL = "https://api-inference.huggingface.co/models/sentence-transformers/all-MiniLM-L6-v2"
+headers = {"Authorization": f"Bearer {api_token}"}
+
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
+
+data = query(
+    {
+        "inputs": {
+            "source_sentence": "I'm very happy",
+            "sentences":["I'm filled with happiness", "I'm happy"]
+        }
+    })
+
+## [0.605, 0.894]
+```
+
+You can also infer with the models in the Hub using Sentence Transformer models.
+
+```python
+pip install -U sentence-transformers
+
+from sentence_transformers import SentenceTransformer, util
+sentences = ["I'm happy", "I'm full of happiness"]
+
+model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+#Compute embedding for both lists
+embedding_1= model.encode(sentences[0], convert_to_tensor=True)
+embedding_2 = model.encode(sentences[1], convert_to_tensor=True)
+
+util.pytorch_cos_sim(embedding_1, embedding_2)
+## tensor([[0.6003]])
+```
+
+## Useful Resources
+
+Would you like to learn more about Sentence Transformers and Sentence Similarity? Awesome! Here you can find some curated resources that you may find helpful!
+
+- [Sentence Transformers Documentation](https://www.sbert.net/)
+- [Sentence Transformers in the Hub](https://huggingface.co/blog/sentence-transformers-in-the-hub)
+- [Building a Playlist Generator with Sentence Transformers](https://huggingface.co/blog/playlist-generator)
+- [Getting Started With Embeddings](https://huggingface.co/blog/getting-started-with-embeddings)

package/src/tasks/sentence-similarity/data.ts

@@ -0,0 +1,101 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "Bing queries with relevant passages from various web sources.",
+			id: "ms_marco",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Source sentence",
+				content: "Machine learning is so easy.",
+				type: "text",
+			},
+			{
+				label: "Sentences to compare to",
+				content: "Deep learning is so straightforward.",
+				type: "text",
+			},
+			{
+				label: "",
+				content: "This is so difficult, like rocket science.",
+				type: "text",
+			},
+			{
+				label: "",
+				content: "I can't believe how much I struggled with this.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				type: "chart",
+				data: [
+					{
+						label: "Deep learning is so straightforward.",
+						score: 0.623,
+					},
+					{
+						label: "This is so difficult, like rocket science.",
+						score: 0.413,
+					},
+					{
+						label: "I can't believe how much I struggled with this.",
+						score: 0.256,
+					},
+				],
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"Reciprocal Rank is a measure used to rank the relevancy of documents given a set of documents. Reciprocal Rank is the reciprocal of the rank of the document retrieved, meaning, if the rank is 3, the Reciprocal Rank is 0.33. If the rank is 1, the Reciprocal Rank is 1",
+			id: "Mean Reciprocal Rank",
+		},
+		{
+			description:
+				"The similarity of the embeddings is evaluated mainly on cosine similarity. It is calculated as the cosine of the angle between two vectors. It is particularly useful when your texts are not the same length",
+			id: "Cosine Similarity",
+		},
+	],
+	models: [
+		{
+			description:
+				"This model works well for sentences and paragraphs and can be used for clustering/grouping and semantic searches.",
+			id: "sentence-transformers/all-mpnet-base-v2",
+		},
+		{
+			description: "A multilingual robust sentence similarity model..",
+			id: "BAAI/bge-m3",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that leverages sentence similarity to answer questions from YouTube videos.",
+			id: "Gradio-Blocks/Ask_Questions_To_YouTube_Videos",
+		},
+		{
+			description:
+				"An application that retrieves relevant PubMed abstracts for a given online article which can be used as further references.",
+			id: "Gradio-Blocks/pubmed-abstract-retriever",
+		},
+		{
+			description: "An application that leverages sentence similarity to summarize text.",
+			id: "nickmuchi/article-text-summarizer",
+		},
+		{
+			description: "A guide that explains how Sentence Transformers can be used for semantic search.",
+			id: "sentence-transformers/Sentence_Transformers_for_semantic_search",
+		},
+	],
+	summary:
+		"Sentence Similarity is the task of determining how similar two texts are. Sentence similarity models convert input texts into vectors (embeddings) that capture semantic information and calculate how close (similar) they are between them. This task is particularly useful for information retrieval and clustering/grouping.",
+	widgetModels: ["BAAI/bge-small-en-v1.5"],
+	youtubeId: "VCZq5AkbNEU",
+};
+
+export default taskData;

package/src/tasks/sentence-similarity/inference.ts

@@ -0,0 +1,32 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+
+export type SentenceSimilarityOutput = number[];
+
+/**
+ * Inputs for Sentence similarity inference
+ */
+export interface SentenceSimilarityInput {
+	inputs: SentenceSimilarityInputData;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: { [key: string]: unknown };
+	[property: string]: unknown;
+}
+
+export interface SentenceSimilarityInputData {
+	/**
+	 * A list of strings which will be compared against the source_sentence.
+	 */
+	sentences: string[];
+	/**
+	 * The string that you wish to compare the other strings with. This can be a phrase,
+	 * sentence, or longer passage, depending on the model being used.
+	 */
+	sourceSentence: string;
+	[property: string]: unknown;
+}

package/src/tasks/sentence-similarity/spec/input.json

@@ -0,0 +1,40 @@
+{
+	"$id": "/inference/schemas/sentence-similarity/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Sentence similarity inference",
+	"title": "SentenceSimilarityInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"title": "SentenceSimilarityInputData",
+			"type": "object",
+			"properties": {
+				"sourceSentence": {
+					"description": "The string that you wish to compare the other strings with. This can be a phrase, sentence, or longer passage, depending on the model being used.",
+					"type": "string"
+				},
+				"sentences": {
+					"type": "array",
+					"description": "A list of strings which will be compared against the source_sentence.",
+					"items": {
+						"type": "string"
+					}
+				}
+			},
+			"required": ["sourceSentence", "sentences"]
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/SentenceSimilarityParameters"
+		}
+	},
+	"$defs": {
+		"SentenceSimilarityParameters": {
+			"title": "SentenceSimilarityParameters",
+			"description": "Additional inference parameters for Sentence Similarity",
+			"type": "object",
+			"properties": {}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/sentence-similarity/spec/output.json

@@ -0,0 +1,12 @@
+{
+	"$id": "/inference/schemas/sentence-similarity/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"title": "SentenceSimilarityOutput",
+	"description": "Outputs of inference for the Sentence Similarity task",
+	"type": "array",
+	"items": {
+		"description": "The associated similarity score for each of the given sentences",
+		"type": "number",
+		"title": "SentenceSimilarityScore"
+	}
+}

package/src/tasks/summarization/about.md

@@ -0,0 +1,58 @@
+## Use Cases
+
+### Research Paper Summarization 🧐
+
+Research papers can be summarized to allow researchers to spend less time selecting which articles to read. There are several approaches you can take for a task like this:
+
+1. Use an existing extractive summarization model on the Hub to do inference.
+2. Pick an existing language model trained for academic papers. This model can then be trained in a process called fine-tuning so it can solve the summarization task.
+3. Use a sequence-to-sequence model like [T5](https://huggingface.co/docs/transformers/model_doc/t5) for abstractive text summarization.
+
+## Inference
+
+You can use the 🤗 Transformers library `summarization` pipeline to infer with existing Summarization models. If no model name is provided the pipeline will be initialized with [sshleifer/distilbart-cnn-12-6](https://huggingface.co/sshleifer/distilbart-cnn-12-6).
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("summarization")
+classifier("Paris is the capital and most populous city of France, with an estimated population of 2,175,601 residents as of 2018, in an area of more than 105 square kilometres (41 square miles). The City of Paris is the centre and seat of government of the region and province of Île-de-France, or Paris Region, which has an estimated population of 12,174,880, or about 18 percent of the population of France as of 2017.")
+## [{ "summary_text": " Paris is the capital and most populous city of France..." }]
+```
+
+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_TOKEN);
+const inputs =
+	"Paris is the capital and most populous city of France, with an estimated population of 2,175,601 residents as of 2018, in an area of more than 105 square kilometres (41 square miles). The City of Paris is the centre and seat of government of the region and province of Île-de-France, or Paris Region, which has an estimated population of 12,174,880, or about 18 percent of the population of France as of 2017.";
+
+await inference.summarization({
+	model: "sshleifer/distilbart-cnn-12-6",
+	inputs,
+});
+```
+
+## Useful Resources
+
+Would you like to learn more about the topic? Awesome! Here you can find some curated resources that you may find helpful!
+
+- [Course Chapter on Summarization](https://huggingface.co/course/chapter7/5?fw=pt)
+- [Distributed Training: Train BART/T5 for Summarization using 🤗 Transformers and Amazon SageMaker](https://huggingface.co/blog/sagemaker-distributed-training-seq2seq)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/summarization.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/summarization-tf.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/summarization)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/summarization)
+- [Flax](https://github.com/huggingface/transformers/tree/main/examples/flax/summarization)
+
+### Documentation
+
+- [Summarization task guide](https://huggingface.co/docs/transformers/tasks/summarization)

package/src/tasks/summarization/data.ts

@@ -0,0 +1,76 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	canonicalId: "text2text-generation",
+	datasets: [
+		{
+			description:
+				"News articles in five different languages along with their summaries. Widely used for benchmarking multilingual summarization models.",
+			id: "mlsum",
+		},
+		{
+			description: "English conversations and their summaries. Useful for benchmarking conversational agents.",
+			id: "samsum",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Input",
+				content:
+					"The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side. It was the first structure to reach a height of 300 metres. Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Output",
+				content:
+					"The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building. It was the first structure to reach a height of 300 metres.",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"The generated sequence is compared against its summary, and the overlap of tokens are counted. ROUGE-N refers to overlap of N subsequent tokens, ROUGE-1 refers to overlap of single tokens and ROUGE-2 is the overlap of two subsequent tokens.",
+			id: "rouge",
+		},
+	],
+	models: [
+		{
+			description:
+				"A strong summarization model trained on English news articles. Excels at generating factual summaries.",
+			id: "facebook/bart-large-cnn",
+		},
+		{
+			description: "A summarization model trained on medical articles.",
+			id: "Falconsai/medical_summarization",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that can summarize long paragraphs.",
+			id: "pszemraj/summarize-long-text",
+		},
+		{
+			description: "A much needed summarization application for terms and conditions.",
+			id: "ml6team/distilbart-tos-summarizer-tosdr",
+		},
+		{
+			description: "An application that summarizes long documents.",
+			id: "pszemraj/document-summarization",
+		},
+		{
+			description: "An application that can detect errors in abstractive summarization.",
+			id: "ml6team/post-processing-summarization",
+		},
+	],
+	summary:
+		"Summarization is the task of producing a shorter version of a document while preserving its important information. Some models can extract text from the original input, while other models can generate entirely new text.",
+	widgetModels: ["facebook/bart-large-cnn"],
+	youtubeId: "yHnr5Dk2zCI",
+};
+
+export default taskData;