@huggingface/tasks 0.0.3 → 0.0.5

package/src/sentence-similarity/data.ts

@@ -4,35 +4,31 @@ const taskData: TaskDataCustom = {
 	datasets: [
 		{
 			description: "Bing queries with relevant passages from various web sources.",
-			id:          "ms_marco",
+			id: "ms_marco",
 		},
-		
 	],
 	demo: {
 		inputs: [
-
-			
 			{
-				label:   "Source sentence",
+				label: "Source sentence",
 				content: "Machine learning is so easy.",
-				type:    "text",
+				type: "text",
 			},
 			{
-				label:   "Sentences to compare to",
+				label: "Sentences to compare to",
 				content: "Deep learning is so straightforward.",
-				type:    "text",
+				type: "text",
 			},
 			{
-				label:   "",
+				label: "",
 				content: "This is so difficult, like rocket science.",
-				type:    "text",
+				type: "text",
 			},
 			{
-				label:   "",
+				label: "",
 				content: "I can't believe how much I struggled with this.",
-				type:    "text",
+				type: "text",
 			},
-			
 		],
 		outputs: [
 			{
@@ -56,45 +52,50 @@ const taskData: TaskDataCustom = {
 	},
 	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:
+				"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",
+			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:
+				"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 model trained for FAQ retrieval.",
-			id:          "clips/mfaq",
+			id: "clips/mfaq",
 		},
 	],
-	spaces:       [
+	spaces: [
 		{
 			description: "An application that leverages sentence similarity to answer questions from YouTube videos.",
-			id:          "Gradio-Blocks/Ask_Questions_To_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 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",
+			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",
+			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.",
+	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: ["sentence-transformers/all-MiniLM-L6-v2"],
-	youtubeId:    "VCZq5AkbNEU",
+	youtubeId: "VCZq5AkbNEU",
 };
 
 export default taskData;

package/src/summarization/about.md

@@ -26,12 +26,13 @@ You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to i
 import { HfInference } from "@huggingface/inference";
 
 const inference = new HfInference(HF_ACCESS_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."
+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
-})
+	model: "sshleifer/distilbart-cnn-12-6",
+	inputs,
+});
 ```
 
 ## Useful Resources
@@ -54,4 +55,4 @@ Would you like to learn more about the topic? Awesome! Here you can find some cu
 
 ### Documentation
 
-- [Summarization task guide](https://huggingface.co/docs/transformers/tasks/summarization)
+- [Summarization task guide](https://huggingface.co/docs/transformers/tasks/summarization)

package/src/summarization/data.ts

@@ -3,70 +3,73 @@ import type { TaskDataCustom } from "../Types";
 const taskData: TaskDataCustom = {
 	datasets: [
 		{
-			description: "News articles in five different languages along with their summaries. Widely used for benchmarking multilingual summarization models.",
-			id:          "mlsum",
+			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",
+			id: "samsum",
 		},
 	],
 	demo: {
 		inputs: [
 			{
-				label:   "Input",
+				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.",
+					"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",
+				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.",
+					"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",
+			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 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:          "google/bigbird-pegasus-large-pubmed",
+			id: "google/bigbird-pegasus-large-pubmed",
 		},
 	],
-	spaces:       [
+	spaces: [
 		{
 			description: "An application that can summarize long paragraphs.",
-			id:          "pszemraj/summarize-long-text",
+			id: "pszemraj/summarize-long-text",
 		},
 		{
 			description: "A much needed summarization application for terms and conditions.",
-			id:          "ml6team/distilbart-tos-summarizer-tosdr",
+			id: "ml6team/distilbart-tos-summarizer-tosdr",
 		},
 		{
 			description: "An application that summarizes long documents.",
-			id:          "pszemraj/document-summarization",
+			id: "pszemraj/document-summarization",
 		},
 		{
 			description: "An application that can detect errors in abstractive summarization.",
-			id:          "ml6team/post-processing-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.",
+	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: ["sshleifer/distilbart-cnn-12-6"],
-	youtubeId:    "yHnr5Dk2zCI",
+	youtubeId: "yHnr5Dk2zCI",
 };
 
 export default taskData;

package/src/table-question-answering/about.md

@@ -2,9 +2,9 @@
 
 ### SQL execution
 
-You can use the Table Question Answering models to simulate SQL execution by inputting a table. 
+You can use the Table Question Answering models to simulate SQL execution by inputting a table.
 
-### Table Question Answering 
+### Table Question Answering
 
 Table Question Answering models are capable of answering questions based on a table.
 
@@ -12,11 +12,11 @@ Table Question Answering models are capable of answering questions based on a ta
 
 This place can be filled with variants of this task if there's any.
 
-## Inference 
+## Inference
 
 You can infer with TableQA models using the 🤗 Transformers library.
 
-```python 
+```python
 from transformers import pipeline
 import pandas as pd
 
@@ -40,4 +40,4 @@ print(tqa(table=table, query=query)['cells'][0])
 
 In this area, you can insert useful resources about how to train or use a model for this task.
 
-This task page is complete thanks to the efforts of [Hao Kim Tieu](https://huggingface.co/haotieu). 🦸 
+This task page is complete thanks to the efforts of [Hao Kim Tieu](https://huggingface.co/haotieu). 🦸

package/src/table-question-answering/data.ts

@@ -3,61 +3,57 @@ import type { TaskDataCustom } from "../Types";
 const taskData: TaskDataCustom = {
 	datasets: [
 		{
-			description: "The WikiTableQuestions dataset is a large-scale dataset for the task of question answering on semi-structured tables.",
-			id:          "wikitablequestions",
+			description:
+				"The WikiTableQuestions dataset is a large-scale dataset for the task of question answering on semi-structured tables.",
+			id: "wikitablequestions",
 		},
 		{
-			description: "WikiSQL is a dataset of 80654 hand-annotated examples of questions and SQL queries distributed across 24241 tables from Wikipedia.",
-			id:          "wikisql",
+			description:
+				"WikiSQL is a dataset of 80654 hand-annotated examples of questions and SQL queries distributed across 24241 tables from Wikipedia.",
+			id: "wikisql",
 		},
 	],
 	demo: {
 		inputs: [
-			{ table: [
-				["Rank", "Name", "No.of reigns", "Combined days"],
-				["1", "lou Thesz", "3", "3749"],
-				["2", "Ric Flair", "8", "3103"],
-				["3", "Harley Race", "7", "1799"],
-			],
-			  type: "tabular" },
-			 
-			 { label:   "Question",
-		           content: "What is the number of reigns for Harley Race?",
-			   type:    "text" },
-		],
-		outputs: [
-			{ label:   "Result",
-			  content: "7",
-			  type:    "text" },
-		],
-	},
-	metrics:
-		[
-			{ description: "Checks whether the predicted answer(s) is the same as the ground-truth answer(s).",
-		  id:          "Denotation Accuracy" },
-		],
-	models:
-		[
 			{
-		       	description: "A table question answering model that is capable of neural SQL execution, i.e., employ TAPEX to execute a SQL query on a given table.",
-		         id:          "microsoft/tapex-base",
+				table: [
+					["Rank", "Name", "No.of reigns", "Combined days"],
+					["1", "lou Thesz", "3", "3749"],
+					["2", "Ric Flair", "8", "3103"],
+					["3", "Harley Race", "7", "1799"],
+				],
+				type: "tabular",
 			},
-			{
-				description: "A robust table question answering model.",
-				id:          "google/tapas-base-finetuned-wtq",
 
-			},
+			{ label: "Question", content: "What is the number of reigns for Harley Race?", type: "text" },
 		],
+		outputs: [{ label: "Result", content: "7", type: "text" }],
+	},
+	metrics: [
+		{
+			description: "Checks whether the predicted answer(s) is the same as the ground-truth answer(s).",
+			id: "Denotation Accuracy",
+		},
+	],
+	models: [
+		{
+			description:
+				"A table question answering model that is capable of neural SQL execution, i.e., employ TAPEX to execute a SQL query on a given table.",
+			id: "microsoft/tapex-base",
+		},
+		{
+			description: "A robust table question answering model.",
+			id: "google/tapas-base-finetuned-wtq",
+		},
+	],
 	spaces: [
 		{
 			description: "An application that answers questions based on table CSV files.",
-			id:          "katanaml/table-query",
-
+			id: "katanaml/table-query",
 		},
 	],
-	summary:      "Table Question Answering (Table QA) is the answering a question about an information on a given table.",
+	summary: "Table Question Answering (Table QA) is the answering a question about an information on a given table.",
 	widgetModels: ["google/tapas-base-finetuned-wtq"],
 };
 
-
 export default taskData;

package/src/tabular-classification/about.md

@@ -15,16 +15,16 @@ Tabular classification models can be used in detecting fraudulent credit card tr
 ### Churn Prediction
 Tabular classification models can be used in predicting customer churn in telecommunication. An example dataset for the task is hosted [here](https://huggingface.co/datasets/scikit-learn/churn-prediction).
 
+# Model Hosting and Inference
 
-# Model Hosting and Inference 
+You can use [skops](https://skops.readthedocs.io/) for model hosting and inference on the Hugging Face Hub. This library is built to improve production workflows of various libraries that are used to train tabular models, including [sklearn](https://scikit-learn.org/stable/) and [xgboost](https://xgboost.readthedocs.io/en/stable/). Using `skops` you can:
 
-You can use [skops](https://skops.readthedocs.io/) for model hosting and inference on the Hugging Face Hub. This library is built to improve production workflows of various libraries that are used to train tabular models, including [sklearn](https://scikit-learn.org/stable/) and [xgboost](https://xgboost.readthedocs.io/en/stable/).  Using `skops` you can:
 - Easily use inference API,
 - Build neat UIs with one line of code,
 - Programmatically create model cards,
 - Securely serialize your scikit-learn model. (See limitations of using pickle [here](https://huggingface.co/docs/hub/security-pickle).)
 
-You can push your model as follows: 
+You can push your model as follows:
 
 ```python
 from skops import hub_utils
@@ -52,7 +52,6 @@ import gradio as gr
 gr.Interface.load("huggingface/username/my-awesome-model").launch()
 ```
 
-
 ## Useful Resources
 
 - Check out the [scikit-learn organization](https://huggingface.co/scikit-learn) to learn more about different algorithms used for this task.
@@ -61,7 +60,6 @@ gr.Interface.load("huggingface/username/my-awesome-model").launch()
 - [Notebook: Persisting your scikit-learn model using skops](https://www.kaggle.com/code/unofficialmerve/persisting-your-scikit-learn-model-using-skops)
 - Check out [interactive sklearn examples](https://huggingface.co/sklearn-docs) built with ❤️ using Gradio.
 
-
 ### Training your own model in just a few seconds
 
-We have built a [baseline trainer](https://huggingface.co/spaces/scikit-learn/baseline-trainer) application to which you can drag and drop your dataset. It will train a baseline and push it to your Hugging Face Hub profile with a model card containing information about the model.
+We have built a [baseline trainer](https://huggingface.co/spaces/scikit-learn/baseline-trainer) application to which you can drag and drop your dataset. It will train a baseline and push it to your Hugging Face Hub profile with a model card containing information about the model.

package/src/tabular-classification/data.ts

@@ -4,7 +4,7 @@ const taskData: TaskDataCustom = {
 	datasets: [
 		{
 			description: "A comprehensive curation of datasets covering all benchmarks.",
-			id:          "inria-soda/tabular-benchmark",
+			id: "inria-soda/tabular-benchmark",
 		},
 	],
 	demo: {
@@ -22,48 +22,47 @@ const taskData: TaskDataCustom = {
 		outputs: [
 			{
 				table: [["Diabetes"], ["1"], ["1"], ["0"]],
-				type:  "tabular",
+				type: "tabular",
 			},
 		],
 	},
 	metrics: [
 		{
 			description: "",
-			id:          "accuracy",
+			id: "accuracy",
 		},
 		{
 			description: "",
-			id:          "recall",
+			id: "recall",
 		},
 		{
 			description: "",
-			id:          "precision",
+			id: "precision",
 		},
 		{
 			description: "",
-			id:          "f1",
+			id: "f1",
 		},
 	],
 	models: [
 		{
 			description: "Breast cancer prediction model based on decision trees.",
-			id:          "scikit-learn/cancer-prediction-trees",
+			id: "scikit-learn/cancer-prediction-trees",
 		},
 	],
 	spaces: [
 		{
 			description: "An application that can predict defective products on a production line.",
-			id:          "scikit-learn/tabular-playground",
+			id: "scikit-learn/tabular-playground",
 		},
 		{
 			description: "An application that compares various tabular classification techniques on different datasets.",
-			id:          "scikit-learn/classification",
+			id: "scikit-learn/classification",
 		},
 	],
-	summary:
-		"Tabular classification is the task of classifying a target category (a group) based on set of attributes.",
+	summary: "Tabular classification is the task of classifying a target category (a group) based on set of attributes.",
 	widgetModels: ["scikit-learn/tabular-playground"],
-	youtubeId:    "",
+	youtubeId: "",
 };
 
 export default taskData;

package/src/tabular-regression/about.md

@@ -1,16 +1,15 @@
 ## About the Task
 
-Tabular regression is the task of predicting a numerical value given a set of attributes/features. *Tabular* meaning that data is stored in a table (like an excel sheet), and each sample is contained in its own row. The features used to predict our target can be both numerical and categorical. However, including categorical features often requires additional preprocessing/feature engineering (a few models do accept categorical features directly, like [CatBoost](https://catboost.ai/)). An example of tabular regression would be predicting the weight of a fish given its' species and length.
+Tabular regression is the task of predicting a numerical value given a set of attributes/features. _Tabular_ meaning that data is stored in a table (like an excel sheet), and each sample is contained in its own row. The features used to predict our target can be both numerical and categorical. However, including categorical features often requires additional preprocessing/feature engineering (a few models do accept categorical features directly, like [CatBoost](https://catboost.ai/)). An example of tabular regression would be predicting the weight of a fish given its' species and length.
 
 ## Use Cases
 
-### Sales Prediction: a Use Case for Predicting a Continuous Target Variable 
-  Here the objective is to predict a continuous variable based on a set of input variable(s). For example, predicting `sales` of an ice cream shop based on `temperature` of weather and `duration of hours` shop was open. Here we can build a regression model with `temperature` and `duration of hours` as input variable and `sales` as target variable.
-
-### Missing Value Imputation for Other Tabular Tasks
- In real-world applications, due to human error or other reasons, some of the input values can be missing or there might not be any recorded data. Considering the example above, say the shopkeeper's watch was broken and they forgot to calculate the `hours` for which the shop was open. This will lead to a missing value in their dataset. In this case, missing values could be replaced it with zero, or average hours for which the shop is kept open. Another approach we can try is to use `temperature` and `sales` variables to predict the `hours` variable here.
+### Sales Prediction: a Use Case for Predicting a Continuous Target Variable
 
+Here the objective is to predict a continuous variable based on a set of input variable(s). For example, predicting `sales` of an ice cream shop based on `temperature` of weather and `duration of hours` shop was open. Here we can build a regression model with `temperature` and `duration of hours` as input variable and `sales` as target variable.
 
+### Missing Value Imputation for Other Tabular Tasks
+In real-world applications, due to human error or other reasons, some of the input values can be missing or there might not be any recorded data. Considering the example above, say the shopkeeper's watch was broken and they forgot to calculate the `hours` for which the shop was open. This will lead to a missing value in their dataset. In this case, missing values could be replaced it with zero, or average hours for which the shop is kept open. Another approach we can try is to use `temperature` and `sales` variables to predict the `hours` variable here.
 
 ## Model Training
 
@@ -27,16 +26,16 @@ model = LinearRegression()
 model.fit(X, y)
 ```
 
-
 # Model Hosting and Inference
 
-You can use [skops](https://skops.readthedocs.io/) for model hosting and inference on the Hugging Face Hub. This library is built to improve production workflows of various libraries that are used to train tabular models, including [sklearn](https://scikit-learn.org/stable/) and [xgboost](https://xgboost.readthedocs.io/en/stable/).  Using `skops` you can:
+You can use [skops](https://skops.readthedocs.io/) for model hosting and inference on the Hugging Face Hub. This library is built to improve production workflows of various libraries that are used to train tabular models, including [sklearn](https://scikit-learn.org/stable/) and [xgboost](https://xgboost.readthedocs.io/en/stable/). Using `skops` you can:
+
 - Easily use inference API,
 - Build neat UIs with one line of code,
 - Programmatically create model cards,
 - Securely serialize your models. (See limitations of using pickle [here](https://huggingface.co/docs/hub/security-pickle).)
 
-You can push your model as follows: 
+You can push your model as follows:
 
 ```python
 from skops import hub_utils
@@ -71,21 +70,18 @@ gr.Interface.load("huggingface/username/my-awesome-model").launch()
 - Check out [interactive sklearn examples](https://huggingface.co/sklearn-docs) built with ❤️ using Gradio.
 - [Notebook: Persisting your scikit-learn model using skops](https://www.kaggle.com/code/unofficialmerve/persisting-your-scikit-learn-model-using-skops)
 
-
 - For starting with tabular regression:
-    - Doing [Exploratory Data Analysis](https://neptune.ai/blog/exploratory-data-analysis-for-tabular-data) for tabular data. 
-      - The data considered here consists of details of Olympic athletes and medal results from Athens 1896 to Rio 2016. 
-      - Here you can learn more about how to explore and analyse the data and visualize them in order to get a better understanding of dataset.
-    - Building your [first ML model](https://www.kaggle.com/code/dansbecker/your-first-machine-learning-model).
-
-- Intermediate level tutorials on tabular regression:
-    - [A Short Chronology of Deep Learning for Tabular Data](https://sebastianraschka.com/blog/2022/deep-learning-for-tabular-data.html) by Sebastian Raschka.
 
+  - Doing [Exploratory Data Analysis](https://neptune.ai/blog/exploratory-data-analysis-for-tabular-data) for tabular data.
+    - The data considered here consists of details of Olympic athletes and medal results from Athens 1896 to Rio 2016.
+    - Here you can learn more about how to explore and analyse the data and visualize them in order to get a better understanding of dataset.
+  - Building your [first ML model](https://www.kaggle.com/code/dansbecker/your-first-machine-learning-model).
 
+- Intermediate level tutorials on tabular regression:
+  - [A Short Chronology of Deep Learning for Tabular Data](https://sebastianraschka.com/blog/2022/deep-learning-for-tabular-data.html) by Sebastian Raschka.
 
 ### Training your own model in just a few seconds
 
 We have built a [baseline trainer](https://huggingface.co/spaces/scikit-learn/baseline-trainer) application to which you can drag and drop your dataset. It will train a baseline and push it to your Hugging Face Hub profile with a model card containing information about the model.
 
 This page was made possible thanks to efforts of [Brenden Connors](https://huggingface.co/brendenc) and [Ayush Bihani](https://huggingface.co/hsuyab).
-

package/src/tabular-regression/data.ts

@@ -4,7 +4,7 @@ const taskData: TaskDataCustom = {
 	datasets: [
 		{
 			description: "A comprehensive curation of datasets covering all benchmarks.",
-			id:          "inria-soda/tabular-benchmark",
+			id: "inria-soda/tabular-benchmark",
 		},
 	],
 	demo: {
@@ -15,7 +15,6 @@ const taskData: TaskDataCustom = {
 					["ford torino", "140", "3,449"],
 					["amc hornet", "97", "2,774"],
 					["toyota corolla", "65", "1,773"],
-
 				],
 				type: "tabular",
 			},
@@ -23,36 +22,36 @@ const taskData: TaskDataCustom = {
 		outputs: [
 			{
 				table: [["MPG (miles per gallon)"], ["17"], ["18"], ["31"]],
-				type:  "tabular",
+				type: "tabular",
 			},
 		],
 	},
 	metrics: [
 		{
 			description: "",
-			id:          "mse",
+			id: "mse",
 		},
 		{
-			description: "Coefficient of determination (or R-squared) is a measure of how well the model fits the data. Higher R-squared is considered a better fit.",
-			id:          "r-squared",
+			description:
+				"Coefficient of determination (or R-squared) is a measure of how well the model fits the data. Higher R-squared is considered a better fit.",
+			id: "r-squared",
 		},
 	],
 	models: [
 		{
 			description: "Fish weight prediction based on length measurements and species.",
-			id:          "scikit-learn/Fish-Weight",
+			id: "scikit-learn/Fish-Weight",
 		},
 	],
 	spaces: [
 		{
 			description: "An application that can predict weight of a fish based on set of attributes.",
-			id:          "scikit-learn/fish-weight-prediction",
+			id: "scikit-learn/fish-weight-prediction",
 		},
 	],
-	summary:
-		"Tabular regression is the task of predicting a numerical value given a set of attributes.",
+	summary: "Tabular regression is the task of predicting a numerical value given a set of attributes.",
 	widgetModels: ["scikit-learn/Fish-Weight"],
-	youtubeId:    "",
+	youtubeId: "",
 };
 
 export default taskData;