@huggingface/tasks 0.0.1

package/src/summarization/data.ts

@@ -0,0 +1,72 @@
+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: "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:          "google/bigbird-pegasus-large-pubmed",
+		},
+	],
+	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: ["sshleifer/distilbart-cnn-12-6"],
+	youtubeId:    "yHnr5Dk2zCI",
+};
+
+export default taskData;

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

@@ -0,0 +1,43 @@
+## Use Cases
+
+### SQL execution
+
+You can use the Table Question Answering models to simulate SQL execution by inputting a table. 
+
+### Table Question Answering 
+
+Table Question Answering models are capable of answering questions based on a table.
+
+## Task Variants
+
+This place can be filled with variants of this task if there's any.
+
+## Inference 
+
+You can infer with TableQA models using the 🤗 Transformers library.
+
+```python 
+from transformers import pipeline
+import pandas as pd
+
+# prepare table + question
+data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
+table = pd.DataFrame.from_dict(data)
+question = "how many movies does Leonardo Di Caprio have?"
+
+# pipeline model
+# Note: you must to install torch-scatter first.
+tqa = pipeline(task="table-question-answering", model="google/tapas-large-finetuned-wtq")
+
+# result
+
+print(tqa(table=table, query=query)['cells'][0])
+#53
+
+```
+
+## Useful Resources
+
+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). 🦸 

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

@@ -0,0 +1,63 @@
+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: "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",
+			},
+			{
+				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",
+
+		},
+	],
+	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

@@ -0,0 +1,67 @@
+## About the Task
+
+Tabular classification is the task of assigning a label or class given a limited number of attributes. For example, the input can be data related to a customer (balance of the customer, the time being a customer, or more) and the output can be whether the customer will churn from the service or not.
+There are three types of categorical variables:
+
+- Binary variables: Variables that can take two values, like yes or no, open or closed. The task of predicting binary variables is called binary classification.
+- Ordinal variables: Variables with a ranking relationship, e.g., good, insignificant, and bad product reviews. The task of predicting ordinal variables is called ordinal classification.
+- Nominal variables: Variables with no ranking relationship among them, e.g., predicting an animal from their weight and height, where categories are cat, dog, or bird. The task of predicting nominal variables is called multinomial classification.
+
+## Use Cases
+
+### Fraud Detection
+Tabular classification models can be used in detecting fraudulent credit card transactions, where the features could be the amount of the transaction and the account balance, and the target to predict could be whether the transaction is fraudulent or not. This is an example of binary classification.
+
+### 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 
+
+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: 
+
+```python
+from skops import hub_utils
+# initialize a repository with a trained model
+local_repo = "/path_to_new_repo"
+hub_utils.init(model, dst=local_repo)
+# push to Hub!
+hub_utils.push("username/my-awesome-model", source=local_repo)
+```
+
+Once the model is pushed, you can infer easily.
+
+```python
+import skops.hub_utils as hub_utils
+import pandas as pd
+data = pd.DataFrame(your_data)
+# Load the model from the Hub
+res = hub_utils.get_model_output("username/my-awesome-model", data)
+```
+
+You can launch a UI for your model with only one line of code!
+
+```python
+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.
+- [Skops documentation](https://skops.readthedocs.io/en/latest/)
+- [Skops announcement blog](https://huggingface.co/blog/skops)
+- [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.

package/src/tabular-classification/data.ts

@@ -0,0 +1,69 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A comprehensive curation of datasets covering all benchmarks.",
+			id:          "inria-soda/tabular-benchmark",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				table: [
+					["Glucose", "Blood Pressure ", "Skin Thickness", "Insulin", "BMI"],
+					["148", "72", "35", "0", "33.6"],
+					["150", "50", "30", "0", "35.1"],
+					["141", "60", "29", "1", "39.2"],
+				],
+				type: "tabular",
+			},
+		],
+		outputs: [
+			{
+				table: [["Diabetes"], ["1"], ["1"], ["0"]],
+				type:  "tabular",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id:          "accuracy",
+		},
+		{
+			description: "",
+			id:          "recall",
+		},
+		{
+			description: "",
+			id:          "precision",
+		},
+		{
+			description: "",
+			id:          "f1",
+		},
+	],
+	models: [
+		{
+			description: "Breast cancer prediction model based on decision 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",
+		},
+		{
+			description: "An application that compares various tabular classification techniques on different datasets.",
+			id:          "scikit-learn/classification",
+		},
+	],
+	summary:
+		"Tabular classification is the task of classifying a target category (a group) based on set of attributes.",
+	widgetModels: ["scikit-learn/tabular-playground"],
+	youtubeId:    "",
+};
+
+export default taskData;

package/src/tabular-regression/about.md

@@ -0,0 +1,91 @@
+## 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.
+
+## 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.
+
+
+
+## Model Training
+
+A simple regression model can be created using `sklearn` as follows:
+
+```python
+#set the input features
+X = data[["Feature 1", "Feature 2", "Feature 3"]]
+#set the target variable
+y = data["Target Variable"]
+#initialize the model
+model = LinearRegression()
+#Fit the model
+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:
+- 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: 
+
+```python
+from skops import hub_utils
+# initialize a repository with a trained model
+local_repo = "/path_to_new_repo"
+hub_utils.init(model, dst=local_repo)
+# push to Hub!
+hub_utils.push("username/my-awesome-model", source=local_repo)
+```
+
+Once the model is pushed, you can infer easily.
+
+```python
+import skops.hub_utils as hub_utils
+import pandas as pd
+data = pd.DataFrame(your_data)
+# Load the model from the Hub
+res = hub_utils.get_model_output("username/my-awesome-model", data)
+```
+
+You can launch a UI for your model with only one line of code!
+
+```python
+import gradio as gr
+gr.Interface.load("huggingface/username/my-awesome-model").launch()
+```
+
+## Useful Resources
+
+- [Skops documentation](https://skops.readthedocs.io/en/stable/index.html)
+
+- 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.
+
+
+
+### 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

@@ -0,0 +1,58 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A comprehensive curation of datasets covering all benchmarks.",
+			id:          "inria-soda/tabular-benchmark",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				table: [
+					["Car Name", "Horsepower", "Weight"],
+					["ford torino", "140", "3,449"],
+					["amc hornet", "97", "2,774"],
+					["toyota corolla", "65", "1,773"],
+
+				],
+				type: "tabular",
+			},
+		],
+		outputs: [
+			{
+				table: [["MPG (miles per gallon)"], ["17"], ["18"], ["31"]],
+				type:  "tabular",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			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",
+		},
+	],
+	models: [
+		{
+			description: "Fish weight prediction based on length measurements and species.",
+			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",
+		},
+	],
+	summary:
+		"Tabular regression is the task of predicting a numerical value given a set of attributes.",
+	widgetModels: ["scikit-learn/Fish-Weight"],
+	youtubeId:    "",
+};
+
+export default taskData;

package/src/tasksData.ts

@@ -0,0 +1,104 @@
+import { type PipelineType, PIPELINE_DATA } from "../../js/src/lib/interfaces/Types";
+import type { TaskDataCustom, TaskData } from "./Types";
+
+import audioClassification from "./audio-classification/data";
+import audioToAudio from "./audio-to-audio/data";
+import automaticSpeechRecognition from "./automatic-speech-recognition/data";
+import conversational from "./conversational/data";
+import documentQuestionAnswering from "./document-question-answering/data";
+import featureExtraction from "./feature-extraction/data";
+import fillMask from "./fill-mask/data";
+import imageClassification from "./image-classification/data";
+import imageToImage from "./image-to-image/data";
+import imageToText from "./image-to-text/data";
+import imageSegmentation from "./image-segmentation/data";
+import objectDetection from "./object-detection/data";
+import depthEstimation from "./depth-estimation/data";
+import placeholder from "./placeholder/data";
+import reinforcementLearning from "./reinforcement-learning/data";
+import questionAnswering from "./question-answering/data";
+import sentenceSimilarity from "./sentence-similarity/data";
+import summarization from "./summarization/data";
+import tableQuestionAnswering from "./table-question-answering/data";
+import tabularClassification from "./tabular-classification/data";
+import tabularRegression from "./tabular-regression/data";
+import textToImage from "./text-to-image/data";
+import textToSpeech from "./text-to-speech/data";
+import tokenClassification from "./token-classification/data";
+import translation from "./translation/data";
+import textClassification from "./text-classification/data";
+import textGeneration from "./text-generation/data";
+import textToVideo from "./text-to-video/data";
+import unconditionalImageGeneration from "./unconditional-image-generation/data";
+import videoClassification from "./video-classification/data";
+import visualQuestionAnswering from "./visual-question-answering/data";
+import zeroShotClassification from "./zero-shot-classification/data";
+import zeroShotImageClassification from "./zero-shot-image-classification/data";
+import { TASKS_MODEL_LIBRARIES } from "./const";
+
+// To make comparisons easier, task order is the same as in const.ts
+// Tasks set to undefined won't have an associated task page.
+// Tasks that call getData() without the second argument will
+// have a "placeholder" page.
+export const TASKS_DATA: Record<PipelineType, TaskData | undefined> = {
+	"audio-classification":           getData("audio-classification", audioClassification),
+	"audio-to-audio":                 getData("audio-to-audio", audioToAudio),
+	"automatic-speech-recognition":   getData("automatic-speech-recognition", automaticSpeechRecognition),
+	"conversational":                 getData("conversational", conversational),
+	"depth-estimation":               getData("depth-estimation", depthEstimation),
+	"document-question-answering":    getData("document-question-answering", documentQuestionAnswering),
+	"feature-extraction":             getData("feature-extraction", featureExtraction),
+	"fill-mask":                      getData("fill-mask", fillMask),
+	"graph-ml":                       undefined,
+	"image-classification":           getData("image-classification", imageClassification),
+	"image-segmentation":             getData("image-segmentation", imageSegmentation),
+	"image-to-image":                 getData("image-to-image", imageToImage),
+	"image-to-text":                  getData("image-to-text", imageToText),
+	"multiple-choice":                undefined,
+	"object-detection":               getData("object-detection", objectDetection),
+	"video-classification":           getData("video-classification", videoClassification),
+	"other":                          undefined,
+	"question-answering":             getData("question-answering", questionAnswering),
+	"reinforcement-learning":         getData("reinforcement-learning", reinforcementLearning),
+	"robotics":                       undefined,
+	"sentence-similarity":            getData("sentence-similarity", sentenceSimilarity),
+	"summarization":                  getData("summarization", summarization),
+	"table-question-answering":       getData("table-question-answering", tableQuestionAnswering),
+	"table-to-text":                  undefined,
+	"tabular-classification":         getData("tabular-classification", tabularClassification),
+	"tabular-regression":             getData("tabular-regression", tabularRegression),
+	"tabular-to-text":                undefined,
+	"text-classification":            getData("text-classification", textClassification),
+	"text-generation":                getData("text-generation", textGeneration),
+	"text-retrieval":                 undefined,
+	"text-to-image":                  getData("text-to-image", textToImage),
+	"text-to-speech":                 getData("text-to-speech", textToSpeech),
+	"text-to-audio":                  undefined,	
+	"text-to-video":                  getData("text-to-video", textToVideo),
+	"text2text-generation":           undefined,
+	"time-series-forecasting":        undefined,
+	"token-classification":           getData("token-classification", tokenClassification),
+	"translation":                    getData("translation", translation),
+	"unconditional-image-generation": getData("unconditional-image-generation", unconditionalImageGeneration),
+	"visual-question-answering":      getData("visual-question-answering", visualQuestionAnswering),
+	"voice-activity-detection":       undefined,
+	"zero-shot-classification":       getData("zero-shot-classification", zeroShotClassification),
+	"zero-shot-image-classification": getData("zero-shot-image-classification", zeroShotImageClassification),
+} as const;
+
+/* 
+ * Return the whole TaskData object for a certain task. 
+ * If the partialTaskData argument is left undefined,
+ * the default placholder data will be used.
+ */
+function getData(
+	type: PipelineType,
+	partialTaskData: TaskDataCustom = placeholder
+): TaskData {
+	return {
+		...partialTaskData,
+		id:        type,
+		label:     PIPELINE_DATA[type].name,
+		libraries: TASKS_MODEL_LIBRARIES[type],
+	};
+}