@huggingface/tasks 0.2.1 → 0.3.0

package/src/tasks/question-answering/spec/input.json

@@ -0,0 +1,67 @@
+{
+	"$id": "/inference/schemas/question-answering/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Question Answering inference",
+	"title": "QuestionAnsweringInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"title": "QuestionAnsweringInputData",
+			"description": "One (context, question) pair to answer",
+			"type": "object",
+			"properties": {
+				"context": {
+					"type": "string",
+					"description": "The context to be used for answering the question"
+				},
+				"question": {
+					"type": "string",
+					"description": "The question to be answered"
+				}
+			},
+			"required": ["question", "context"]
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/QuestionAnsweringParameters"
+		}
+	},
+	"$defs": {
+		"QuestionAnsweringParameters": {
+			"title": "QuestionAnsweringParameters",
+			"description": "Additional inference parameters for Question Answering",
+			"type": "object",
+			"properties": {
+				"top_k": {
+					"type": "integer",
+					"description": "The number of answers to return (will be chosen by order of likelihood). Note that we return less than topk answers if there are not enough options available within the context."
+				},
+				"doc_stride": {
+					"type": "integer",
+					"description": "If the context is too long to fit with the question for the model, it will be split in several chunks with some overlap. This argument controls the size of that overlap."
+				},
+				"max_answer_len": {
+					"type": "integer",
+					"description": "The maximum length of predicted answers (e.g., only answers with a shorter length are considered)."
+				},
+				"max_seq_len": {
+					"type": "integer",
+					"description": "The maximum length of the total sentence (context + question) in tokens of each chunk passed to the model. The context will be split in several chunks (using docStride as overlap) if needed."
+				},
+				"max_question_len": {
+					"type": "integer",
+					"description": "The maximum length of the question after tokenization. It will be truncated if needed."
+				},
+				"handle_impossible_answer": {
+					"type": "boolean",
+					"description": "Whether to accept impossible as an answer."
+				},
+				"align_to_words": {
+					"type": "boolean",
+					"description": "Attempts to align the answer to real words. Improves quality on space separated languages. Might hurt on non-space-separated languages (like Japanese or Chinese)"
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/question-answering/spec/output.json

@@ -0,0 +1,29 @@
+{
+	"$id": "/inference/schemas/question-answering/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"title": "QuestionAnsweringOutput",
+	"description": "Outputs of inference for the Question Answering task",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"answer": {
+				"type": "string",
+				"description": "The answer to the question."
+			},
+			"score": {
+				"type": "number",
+				"description": "The probability associated to the answer."
+			},
+			"start": {
+				"type": "integer",
+				"description": "The character position in the input where the answer begins."
+			},
+			"end": {
+				"type": "integer",
+				"description": "The character position in the input where the answer ends."
+			}
+		},
+		"required": ["answer", "score", "start", "end"]
+	}
+}

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

@@ -8,7 +8,7 @@ You can extract information from documents using Sentence Similarity models. The
 
 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 the Inference API.
+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
 
@@ -16,7 +16,7 @@ You can find and use [hundreds of Sentence Transformers](https://huggingface.co/
 
 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 the [Inference API](https://huggingface.co/inference-api). 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.
+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

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/data.ts

@@ -1,6 +1,7 @@
 import type { TaskDataCustom } from "..";
 
 const taskData: TaskDataCustom = {
+	canonicalId: "text2text-generation",
 	datasets: [
 		{
 			description:

package/src/tasks/summarization/inference.ts

@@ -0,0 +1,59 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+
+/**
+ * Inputs for Summarization inference
+ *
+ * Inputs for Text2text Generation inference
+ */
+export interface SummarizationInput {
+	/**
+	 * The input text data
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: Text2TextGenerationParameters;
+	[property: string]: unknown;
+}
+
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Text2text Generation
+ */
+export interface Text2TextGenerationParameters {
+	/**
+	 * Whether to clean up the potential extra spaces in the text output.
+	 */
+	clean_up_tokenization_spaces?: boolean;
+	/**
+	 * Additional parametrization of the text generation algorithm
+	 */
+	generate_parameters?: { [key: string]: unknown };
+	/**
+	 * The truncation strategy to use
+	 */
+	truncation?: Text2TextGenerationTruncationStrategy;
+	[property: string]: unknown;
+}
+
+export type Text2TextGenerationTruncationStrategy = "do_not_truncate" | "longest_first" | "only_first" | "only_second";
+
+/**
+ * Outputs for Summarization inference
+ *
+ * Outputs of inference for the Text2text Generation task
+ */
+export interface SummarizationOutput {
+	generatedText: unknown;
+	/**
+	 * The generated text.
+	 */
+	generated_text?: string;
+	[property: string]: unknown;
+}

package/src/tasks/summarization/spec/input.json

@@ -0,0 +1,7 @@
+{
+	"$ref": "/inference/schemas/text2text-generation/input.json",
+	"$id": "/inference/schemas/summarization/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"title": "SummarizationInput",
+	"description": "Inputs for Summarization inference"
+}

package/src/tasks/summarization/spec/output.json

@@ -0,0 +1,7 @@
+{
+	"$ref": "/inference/schemas/text2text-generation/output.json",
+	"$id": "/inference/schemas/summarization/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"title": "SummarizationOutput",
+	"description": "Outputs for Summarization inference"
+}

package/src/tasks/table-question-answering/inference.ts

@@ -0,0 +1,61 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Table Question Answering inference
+ */
+export interface TableQuestionAnsweringInput {
+	/**
+	 * One (table, question) pair to answer
+	 */
+	inputs: TableQuestionAnsweringInputData;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: {
+		[key: string]: unknown;
+	};
+	[property: string]: unknown;
+}
+/**
+ * One (table, question) pair to answer
+ */
+export interface TableQuestionAnsweringInputData {
+	/**
+	 * The question to be answered about the table
+	 */
+	question: string;
+	/**
+	 * The table to serve as context for the questions
+	 */
+	table: {
+		[key: string]: string[];
+	};
+	[property: string]: unknown;
+}
+export type TableQuestionAnsweringOutput = TableQuestionAnsweringOutputElement[];
+/**
+ * Outputs of inference for the Table Question Answering task
+ */
+export interface TableQuestionAnsweringOutputElement {
+	/**
+	 * If the model has an aggregator, this returns the aggregator.
+	 */
+	aggregator?: string;
+	/**
+	 * The answer of the question given the table. If there is an aggregator, the answer will be
+	 * preceded by `AGGREGATOR >`.
+	 */
+	answer: string;
+	/**
+	 * List of strings made up of the answer cell values.
+	 */
+	cells: string[];
+	/**
+	 * Coordinates of the cells of the answers.
+	 */
+	coordinates: Array<number[]>;
+	[property: string]: unknown;
+}

package/src/tasks/table-question-answering/spec/input.json

@@ -0,0 +1,44 @@
+{
+	"$id": "/inference/schemas/table-question-answering/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Table Question Answering inference",
+	"title": "TableQuestionAnsweringInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"description": "One (table, question) pair to answer",
+			"title": "TableQuestionAnsweringInputData",
+			"type": "object",
+			"properties": {
+				"table": {
+					"description": "The table to serve as context for the questions",
+					"type": "object",
+					"additionalProperties": {
+						"type": "array",
+						"items": {
+							"type": "string"
+						}
+					}
+				},
+				"question": {
+					"description": "The question to be answered about the table",
+					"type": "string"
+				}
+			},
+			"required": ["table", "question"]
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TableQuestionAnsweringParameters"
+		}
+	},
+	"$defs": {
+		"TableQuestionAnsweringParameters": {
+			"title": "TableQuestionAnsweringParameters",
+			"description": "Additional inference parameters for Table Question Answering",
+			"type": "object",
+			"properties": {}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/table-question-answering/spec/output.json

@@ -0,0 +1,40 @@
+{
+	"$id": "/inference/schemas/table-question-answering/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Table Question Answering task",
+	"title": "TableQuestionAnsweringOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"answer": {
+				"type": "string",
+				"description": "The answer of the question given the table. If there is an aggregator, the answer will be preceded by `AGGREGATOR >`."
+			},
+			"coordinates": {
+				"type": "array",
+				"description": "Coordinates of the cells of the answers.",
+				"items": {
+					"type": "array",
+					"items": {
+						"type": "integer"
+					},
+					"minLength": 2,
+					"maxLength": 2
+				}
+			},
+			"cells": {
+				"type": "array",
+				"description": "List of strings made up of the answer cell values.",
+				"items": {
+					"type": "string"
+				}
+			},
+			"aggregator": {
+				"type": "string",
+				"description": "If the model has an aggregator, this returns the aggregator."
+			}
+		},
+		"required": ["answer", "cells", "coordinates"]
+	}
+}

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

@@ -19,7 +19,7 @@ Tabular classification models can be used in predicting customer churn in teleco
 
 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,
+- Easily use Inference Endpoints
 - 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).)

package/src/tasks/tabular-regression/about.md

@@ -30,7 +30,7 @@ model.fit(X, y)
 
 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,
+- Easily use Inference Endpoints,
 - 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).)

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

@@ -150,6 +150,7 @@ classifier("I will walk to home when I went through the bus.")
 
 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)

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,10 @@
+{
+	"$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": {
+		"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutput"
+	}
+}

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

@@ -110,25 +110,36 @@ Would you like to learn more about the topic? Awesome! Here you can find some cu
 - [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)
 
-### Course and Blogs
+### Model Inference & Deployment
 
-- [Course Chapter on Training a causal language model from scratch](https://huggingface.co/course/chapter7/6?fw=pt)
-- [TO Discussion with Victor Sanh](https://www.youtube.com/watch?v=Oy49SCW_Xpw&ab_channel=HuggingFace)
-- [Hugging Face Course Workshops: Pretraining Language Models & CodeParrot](https://www.youtube.com/watch?v=ExUR7w6xe94&ab_channel=HuggingFace)
-- [Training CodeParrot 🦜 from Scratch](https://huggingface.co/blog/codeparrot)
-- [How to generate text: using different decoding methods for language generation with Transformers](https://huggingface.co/blog/how-to-generate)
+- [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)
-- [🌸 Introducing The World's Largest Open Multilingual Language Model: BLOOM 🌸](https://huggingface.co/blog/bloom)
-- [The Technology Behind BLOOM Training](https://huggingface.co/blog/bloom-megatron-deepspeed)
-- [Faster Text Generation with TensorFlow and XLA](https://huggingface.co/blog/tf-xla-generate)
 - [Assisted Generation: a new direction toward low-latency text generation](https://huggingface.co/blog/assisted-generation)
-- [Introducing RWKV - An RNN with the advantages of a transformer](https://huggingface.co/blog/rwkv)
+- [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)
-- [StarCoder: A State-of-the-Art LLM for Code](https://huggingface.co/blog/starcoder)
-- [Open-Source Text Generation & LLM Ecosystem at Hugging Face](https://huggingface.co/blog/os-llms)
-- [Llama 2 is at Hugging Face](https://huggingface.co/blog/llama2)
+
+### 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