@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/tasks/object-detection/inference.ts

@@ -0,0 +1,75 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Object Detection inference
+ */
+export interface ObjectDetectionInput {
+	/**
+	 * The input image data as a base64-encoded string. If no `parameters` are provided, you can
+	 * also provide the image data as a raw bytes payload.
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: ObjectDetectionParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Object Detection
+ */
+export interface ObjectDetectionParameters {
+	/**
+	 * The probability necessary to make a prediction.
+	 */
+	threshold?: number;
+	[property: string]: unknown;
+}
+/**
+ * The predicted bounding box. Coordinates are relative to the top left corner of the input
+ * image.
+ */
+export interface BoundingBox {
+	/**
+	 * The x-coordinate of the bottom-right corner of the bounding box.
+	 */
+	xmax: number;
+	/**
+	 * The x-coordinate of the top-left corner of the bounding box.
+	 */
+	xmin: number;
+	/**
+	 * The y-coordinate of the bottom-right corner of the bounding box.
+	 */
+	ymax: number;
+	/**
+	 * The y-coordinate of the top-left corner of the bounding box.
+	 */
+	ymin: number;
+	[property: string]: unknown;
+}
+export type ObjectDetectionOutput = ObjectDetectionOutputElement[];
+/**
+ * Outputs of inference for the Object Detection task
+ */
+export interface ObjectDetectionOutputElement {
+	/**
+	 * The predicted bounding box. Coordinates are relative to the top left corner of the input
+	 * image.
+	 */
+	box: BoundingBox;
+	/**
+	 * The predicted label for the bounding box.
+	 */
+	label: string;
+	/**
+	 * The associated score / probability.
+	 */
+	score: number;
+	[property: string]: unknown;
+}

package/src/tasks/object-detection/spec/input.json

@@ -0,0 +1,31 @@
+{
+	"$id": "/inference/schemas/object-detection/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Object Detection inference",
+	"title": "ObjectDetectionInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"type": "string",
+			"description": "The input image data as a base64-encoded string. If no `parameters` are provided, you can also provide the image data as a raw bytes payload."
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/ObjectDetectionParameters"
+		}
+	},
+	"$defs": {
+		"ObjectDetectionParameters": {
+			"title": "ObjectDetectionParameters",
+			"description": "Additional inference parameters for Object Detection",
+			"type": "object",
+			"properties": {
+				"threshold": {
+					"type": "number",
+					"description": "The probability necessary to make a prediction."
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/object-detection/spec/output.json

@@ -0,0 +1,50 @@
+{
+	"$id": "/inference/schemas/object-detection/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Object Detection task",
+	"title": "ObjectDetectionOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"label": {
+				"type": "string",
+				"description": "The predicted label for the bounding box."
+			},
+			"score": {
+				"type": "number",
+				"description": "The associated score / probability."
+			},
+			"box": {
+				"$ref": "#/$defs/BoundingBox",
+				"description": "The predicted bounding box. Coordinates are relative to the top left corner of the input image."
+			}
+		},
+		"required": ["box", "label", "score"]
+	},
+	"$defs": {
+		"BoundingBox": {
+			"type": "object",
+			"title": "BoundingBox",
+			"properties": {
+				"xmin": {
+					"type": "integer",
+					"description": "The x-coordinate of the top-left corner of the bounding box."
+				},
+				"xmax": {
+					"type": "integer",
+					"description": "The x-coordinate of the bottom-right corner of the bounding box."
+				},
+				"ymin": {
+					"type": "integer",
+					"description": "The y-coordinate of the top-left corner of the bounding box."
+				},
+				"ymax": {
+					"type": "integer",
+					"description": "The y-coordinate of the bottom-right corner of the bounding box."
+				}
+			},
+			"required": ["xmin", "xmax", "ymin", "ymax"]
+		}
+	}
+}

package/src/tasks/placeholder/about.md

@@ -0,0 +1,15 @@
+## Use Cases
+
+You can contribute this area with common use cases of the task!
+
+## Task Variants
+
+This place can be filled with variants of this task if there's any.
+
+## Inference
+
+This section should have useful information about how to pull a model from Hugging Face Hub that is a part of a library specialized in a task and use it.
+
+## Useful Resources
+
+In this area, you can insert useful resources about how to train or use a model for this task.

package/src/tasks/placeholder/data.ts

@@ -0,0 +1,21 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [],
+	demo: {
+		inputs: [],
+		outputs: [],
+	},
+	isPlaceholder: true,
+	metrics: [],
+	models: [],
+	spaces: [],
+	summary: "",
+	widgetModels: [],
+	youtubeId: undefined,
+	/// If this is a subtask, link to the most general task ID
+	/// (eg, text2text-generation is the canonical ID of translation)
+	canonicalId: undefined,
+};
+
+export default taskData;

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

@@ -0,0 +1,35 @@
+{
+	"$id": "/inference/schemas/<TASK_ID>/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for <TASK_ID> inference",
+	"title": "PlaceholderInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"description": "TODO: describe the input here. This must be model & framework agnostic.",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/<TASK_ID>Parameters"
+		}
+	},
+	"$defs": {
+		"<TASK_ID>Parameters": {
+			"title": "<TASK_ID>Parameters",
+			"description": "TODO: describe additional parameters here.",
+			"type": "object",
+			"properties": {
+				"dummy_parameter_name": {
+					"type": "boolean",
+					"description": "TODO: describe the parameter here"
+				},
+				"dummy_parameter_name2": {
+					"type": "integer",
+					"description": "TODO: describe the parameter here"
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

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

@@ -0,0 +1,17 @@
+{
+	"$id": "/inference/schemas/<TASK_ID>/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs for <TASK_ID> inference",
+	"title": "PlaceholderOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"meaningful_output_name": {
+				"type": "string",
+				"description": "TODO: Describe what is outputed by the inference here"
+			}
+		},
+		"required": ["meaningfulOutputName"]
+	}
+}

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

@@ -0,0 +1,56 @@
+## Use Cases
+
+### Frequently Asked Questions
+
+You can use Question Answering (QA) models to automate the response to frequently asked questions by using a knowledge base (documents) as context. Answers to customer questions can be drawn from those documents.
+
+⚡⚡ If you’d like to save inference time, you can first use [passage ranking models](/tasks/sentence-similarity) to see which document might contain the answer to the question and iterate over that document with the QA model instead.
+
+## Task Variants
+There are different QA variants based on the inputs and outputs:
+
+- **Extractive QA:** The model **extracts** the answer from a context. The context here could be a provided text, a table or even HTML! This is usually solved with BERT-like models.
+- **Open Generative QA:** The model **generates** free text directly based on the context. You can learn more about the Text Generation task in [its page](/tasks/text-generation).
+- **Closed Generative QA:** In this case, no context is provided. The answer is completely generated by a model.
+
+The schema above illustrates extractive, open book QA. The model takes a context and the question and extracts the answer from the given context.
+
+You can also differentiate QA models depending on whether they are open-domain or closed-domain. Open-domain models are not restricted to a specific domain, while closed-domain models are restricted to a specific domain (e.g. legal, medical documents).
+
+## Inference
+
+You can infer with QA models with the 🤗 Transformers library using the `question-answering` pipeline. If no model checkpoint is given, the pipeline will be initialized with `distilbert-base-cased-distilled-squad`. This pipeline takes a question and a context from which the answer will be extracted and returned.
+
+```python
+from transformers import pipeline
+
+qa_model = pipeline("question-answering")
+question = "Where do I live?"
+context = "My name is Merve and I live in İstanbul."
+qa_model(question = question, context = context)
+## {'answer': 'İstanbul', 'end': 39, 'score': 0.953, 'start': 31}
+```
+
+## Useful Resources
+
+Would you like to learn more about QA? Awesome! Here are some curated resources that you may find helpful!
+
+- [Course Chapter on Question Answering](https://huggingface.co/course/chapter7/7?fw=pt)
+- [Question Answering Workshop](https://www.youtube.com/watch?v=Ihgk8kGLpIE&ab_channel=HuggingFace)
+- [How to Build an Open-Domain Question Answering System?](https://lilianweng.github.io/lil-log/2020/10/29/open-domain-question-answering.html)
+- [Blog Post: ELI5 A Model for Open Domain Long Form Question Answering](https://yjernite.github.io/lfqa.html)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/question_answering.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering)
+- [Flax](https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering)
+
+### Documentation
+
+- [Question answering task guide](https://huggingface.co/docs/transformers/tasks/question_answering)

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

@@ -0,0 +1,75 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			// TODO write proper description
+			description: "A famous question answering dataset based on English articles from Wikipedia.",
+			id: "squad_v2",
+		},
+		{
+			// TODO write proper description
+			description: "A dataset of aggregated anonymized actual queries issued to the Google search engine.",
+			id: "natural_questions",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Question",
+				content: "Which name is also used to describe the Amazon rainforest in English?",
+				type: "text",
+			},
+			{
+				label: "Context",
+				content: "The Amazon rainforest, also known in English as Amazonia or the Amazon Jungle",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Answer",
+				content: "Amazonia",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"Exact Match is a metric based on the strict character match of the predicted answer and the right answer. For answers predicted correctly, the Exact Match will be 1. Even if only one character is different, Exact Match will be 0",
+			id: "exact-match",
+		},
+		{
+			description:
+				" The F1-Score metric is useful if we value both false positives and false negatives equally. The F1-Score is calculated on each word in the predicted sequence against the correct answer",
+			id: "f1",
+		},
+	],
+	models: [
+		{
+			description: "A robust baseline model for most question answering domains.",
+			id: "deepset/roberta-base-squad2",
+		},
+		{
+			description: "Small yet robust model that can answer questions.",
+			id: "distilbert/distilbert-base-cased-distilled-squad",
+		},
+		{
+			description: "A special model that can answer questions from tables.",
+			id: "google/tapas-base-finetuned-wtq",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that can answer a long question from Wikipedia.",
+			id: "deepset/wikipedia-assistant",
+		},
+	],
+	summary:
+		"Question Answering models can retrieve the answer to a question from a given text, which is useful for searching for an answer in a document. Some question answering models can generate answers without context!",
+	widgetModels: ["deepset/roberta-base-squad2"],
+	youtubeId: "ajPx5LwJD-I",
+};
+
+export default taskData;

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

@@ -0,0 +1,99 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Question Answering inference
+ */
+export interface QuestionAnsweringInput {
+	/**
+	 * One (context, question) pair to answer
+	 */
+	inputs: QuestionAnsweringInputData;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: QuestionAnsweringParameters;
+	[property: string]: unknown;
+}
+/**
+ * One (context, question) pair to answer
+ */
+export interface QuestionAnsweringInputData {
+	/**
+	 * The context to be used for answering the question
+	 */
+	context: string;
+	/**
+	 * The question to be answered
+	 */
+	question: string;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Question Answering
+ */
+export interface QuestionAnsweringParameters {
+	/**
+	 * 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)
+	 */
+	align_to_words?: boolean;
+	/**
+	 * 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.
+	 */
+	doc_stride?: number;
+	/**
+	 * Whether to accept impossible as an answer.
+	 */
+	handle_impossible_answer?: boolean;
+	/**
+	 * The maximum length of predicted answers (e.g., only answers with a shorter length are
+	 * considered).
+	 */
+	max_answer_len?: number;
+	/**
+	 * The maximum length of the question after tokenization. It will be truncated if needed.
+	 */
+	max_question_len?: number;
+	/**
+	 * 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_seq_len?: number;
+	/**
+	 * 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.
+	 */
+	top_k?: number;
+	[property: string]: unknown;
+}
+export type QuestionAnsweringOutput = QuestionAnsweringOutputElement[];
+/**
+ * Outputs of inference for the Question Answering task
+ */
+export interface QuestionAnsweringOutputElement {
+	/**
+	 * The answer to the question.
+	 */
+	answer: string;
+	/**
+	 * The character position in the input where the answer ends.
+	 */
+	end: number;
+	/**
+	 * The probability associated to the answer.
+	 */
+	score: number;
+	/**
+	 * The character position in the input where the answer begins.
+	 */
+	start: number;
+	[property: string]: unknown;
+}

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"]
+	}
+}