@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/tasks/token-classification/data.ts

@@ -0,0 +1,92 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A widely used dataset useful to benchmark named entity recognition models.",
+			id: "eriktks/conll2003",
+		},
+		{
+			description:
+				"A multilingual dataset of Wikipedia articles annotated for named entity recognition in over 150 different languages.",
+			id: "unimelb-nlp/wikiann",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Input",
+				content: "My name is Omar and I live in Zürich.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				text: "My name is Omar and I live in Zürich.",
+				tokens: [
+					{
+						type: "PERSON",
+						start: 11,
+						end: 15,
+					},
+					{
+						type: "GPE",
+						start: 30,
+						end: 36,
+					},
+				],
+				type: "text-with-tokens",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id: "accuracy",
+		},
+		{
+			description: "",
+			id: "recall",
+		},
+		{
+			description: "",
+			id: "precision",
+		},
+		{
+			description: "",
+			id: "f1",
+		},
+	],
+	models: [
+		{
+			description:
+				"A robust performance model to identify people, locations, organizations and names of miscellaneous entities.",
+			id: "dslim/bert-base-NER",
+		},
+		{
+			description: "A strong model to identify people, locations, organizations and names in multiple languages.",
+			id: "FacebookAI/xlm-roberta-large-finetuned-conll03-english",
+		},
+		{
+			description: "A token classification model specialized on medical entity recognition.",
+			id: "blaze999/Medical-NER",
+		},
+		{
+			description: "Flair models are typically the state of the art in named entity recognition tasks.",
+			id: "flair/ner-english",
+		},
+	],
+	spaces: [
+		{
+			description:
+				"An application that can recognizes entities, extracts noun chunks and recognizes various linguistic features of each token.",
+			id: "spacy/gradio_pipeline_visualizer",
+		},
+	],
+	summary:
+		"Token classification is a natural language understanding task in which a label is assigned to some tokens in a text. Some popular token classification subtasks are Named Entity Recognition (NER) and Part-of-Speech (PoS) tagging. NER models could be trained to identify specific entities in a text, such as dates, individuals and places; and PoS tagging would identify, for example, which words in a text are verbs, nouns, and punctuation marks.",
+	widgetModels: ["FacebookAI/xlm-roberta-large-finetuned-conll03-english"],
+	youtubeId: "wVHdVlPScxA",
+};
+
+export default taskData;

package/src/tasks/token-classification/inference.ts

@@ -0,0 +1,85 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Token Classification inference
+ */
+export interface TokenClassificationInput {
+	/**
+	 * The input text data
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TokenClassificationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Token Classification
+ */
+export interface TokenClassificationParameters {
+	/**
+	 * The strategy used to fuse tokens based on model predictions
+	 */
+	aggregation_strategy?: TokenClassificationAggregationStrategy;
+	/**
+	 * A list of labels to ignore
+	 */
+	ignore_labels?: string[];
+	/**
+	 * The number of overlapping tokens between chunks when splitting the input text.
+	 */
+	stride?: number;
+	[property: string]: unknown;
+}
+/**
+ * Do not aggregate tokens
+ *
+ * Group consecutive tokens with the same label in a single entity.
+ *
+ * Similar to "simple", also preserves word integrity (use the label predicted for the first
+ * token in a word).
+ *
+ * Similar to "simple", also preserves word integrity (uses the label with the highest
+ * score, averaged across the word's tokens).
+ *
+ * Similar to "simple", also preserves word integrity (uses the label with the highest score
+ * across the word's tokens).
+ */
+export type TokenClassificationAggregationStrategy = "none" | "simple" | "first" | "average" | "max";
+export type TokenClassificationOutput = TokenClassificationOutputElement[];
+/**
+ * Outputs of inference for the Token Classification task
+ */
+export interface TokenClassificationOutputElement {
+	/**
+	 * The character position in the input where this group ends.
+	 */
+	end: number;
+	/**
+	 * The predicted label for a single token
+	 */
+	entity?: string;
+	/**
+	 * The predicted label for a group of one or more tokens
+	 */
+	entity_group?: string;
+	/**
+	 * The associated score / probability
+	 */
+	score: number;
+	/**
+	 * The character position in the input where this group begins.
+	 */
+	start: number;
+	/**
+	 * The corresponding text
+	 */
+	word: string;
+	[property: string]: unknown;
+}

package/src/tasks/token-classification/spec/input.json

@@ -0,0 +1,65 @@
+{
+	"$id": "/inference/schemas/token-classification/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Token Classification inference",
+	"title": "TokenClassificationInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"description": "The input text data",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TokenClassificationParameters"
+		}
+	},
+	"$defs": {
+		"TokenClassificationParameters": {
+			"title": "TokenClassificationParameters",
+			"description": "Additional inference parameters for Token Classification",
+			"type": "object",
+			"properties": {
+				"ignore_labels": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"description": "A list of labels to ignore"
+				},
+				"stride": {
+					"type": "integer",
+					"description": "The number of overlapping tokens between chunks when splitting the input text."
+				},
+				"aggregation_strategy": {
+					"title": "TokenClassificationAggregationStrategy",
+					"type": "string",
+					"description": "The strategy used to fuse tokens based on model predictions",
+					"oneOf": [
+						{
+							"const": "none",
+							"description": "Do not aggregate tokens"
+						},
+						{
+							"const": "simple",
+							"description": "Group consecutive tokens with the same label in a single entity."
+						},
+						{
+							"const": "first",
+							"description": "Similar to \"simple\", also preserves word integrity (use the label predicted for the first token in a word)."
+						},
+						{
+							"const": "average",
+							"description": "Similar to \"simple\", also preserves word integrity (uses the label with the highest score, averaged across the word's tokens)."
+						},
+						{
+							"const": "max",
+							"description": "Similar to \"simple\", also preserves word integrity (uses the label with the highest score across the word's tokens)."
+						}
+					]
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/token-classification/spec/output.json

@@ -0,0 +1,37 @@
+{
+	"$id": "/inference/schemas/token-classification/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Token Classification task",
+	"title": "TokenClassificationOutput",
+	"type": "array",
+	"items": {
+		"type": "object",
+		"properties": {
+			"entity_group": {
+				"type": "string",
+				"description": "The predicted label for a group of one or more tokens"
+			},
+			"entity": {
+				"type": "string",
+				"description": "The predicted label for a single token"
+			},
+			"score": {
+				"type": "number",
+				"description": "The associated score / probability"
+			},
+			"word": {
+				"type": "string",
+				"description": "The corresponding text"
+			},
+			"start": {
+				"type": "integer",
+				"description": "The character position in the input where this group begins."
+			},
+			"end": {
+				"type": "integer",
+				"description": "The character position in the input where this group ends."
+			}
+		},
+		"required": ["score", "word", "start", "end"]
+	}
+}

package/src/tasks/translation/about.md

@@ -0,0 +1,65 @@
+## Use Cases
+
+You can find over a thousand Translation models on the Hub, but sometimes you might not find a model for the language pair you are interested in. When this happen, you can use a pretrained multilingual Translation model like [mBART](https://huggingface.co/facebook/mbart-large-cc25) and further train it on your own data in a process called fine-tuning.
+
+### Multilingual conversational agents
+
+Translation models can be used to build conversational agents across different languages. This can be done in two ways.
+
+- **Translate the dataset to a new language.** You can translate a dataset of intents (inputs) and responses to the target language. You can then train a new intent classification model with this new dataset. This allows you to proofread responses in the target language and have better control of the chatbot's outputs.
+
+* **Translate the input and output of the agent.** You can use a Translation model in user inputs so that the chatbot can process it. You can then translate the output of the chatbot into the language of the user. This approach might be less reliable as the chatbot will generate responses that were not defined before.
+
+## Inference
+
+You can use the 🤗 Transformers library with the `translation_xx_to_yy` pattern where xx is the source language code and yy is the target language code. The default model for the pipeline is [t5-base](https://huggingface.co/t5-base) which under the hood adds a task prefix indicating the task itself, e.g. “translate: English to French”.
+
+```python
+from transformers import pipeline
+en_fr_translator = pipeline("translation_en_to_fr")
+en_fr_translator("How old are you?")
+## [{'translation_text': ' quel âge êtes-vous?'}]
+```
+
+If you’d like to use a specific model checkpoint that is from one specific language to another, you can also directly use the `translation` pipeline.
+
+```python
+from transformers import pipeline
+
+model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
+translator = pipeline("translation", model=model_checkpoint)
+translator("How are you?")
+# [{'translation_text': 'Comment allez-vous ?'}]
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer translation models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_TOKEN);
+await inference.translation({
+	model: "t5-base",
+	inputs: "My name is Wolfgang and I live in Berlin",
+});
+```
+
+## Useful Resources
+
+Would you like to learn more about Translation? Great! Here you can find some curated resources that you may find helpful!
+
+- [Course Chapter on Translation](https://huggingface.co/course/chapter7/4?fw=pt)
+
+### Notebooks
+
+- [PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/translation.ipynb)
+- [TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/translation-tf.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/translation)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/translation)
+
+### Documentation
+
+- [Translation task guide](https://huggingface.co/docs/transformers/tasks/translation)

package/src/tasks/translation/data.ts

@@ -0,0 +1,70 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	canonicalId: "text2text-generation",
+	datasets: [
+		{
+			description: "A dataset of copyright-free books translated into 16 different languages.",
+			id: "Helsinki-NLP/opus_books",
+		},
+		{
+			description:
+				"An example of translation between programming languages. This dataset consists of functions in Java and C#.",
+			id: "google/code_x_glue_cc_code_to_code_trans",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Input",
+				content: "My name is Omar and I live in Zürich.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Output",
+				content: "Mein Name ist Omar und ich wohne in Zürich.",
+				type: "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"BLEU score is calculated by counting the number of shared single or subsequent tokens between the generated sequence and the reference. Subsequent n tokens are called “n-grams”. Unigram refers to a single token while bi-gram refers to token pairs and n-grams refer to n subsequent tokens. The score ranges from 0 to 1, where 1 means the translation perfectly matched and 0 did not match at all",
+			id: "bleu",
+		},
+		{
+			description: "",
+			id: "sacrebleu",
+		},
+	],
+	models: [
+		{
+			description:
+				"Very powerful model that can translate many languages between each other, especially low-resource languages.",
+			id: "facebook/nllb-200-1.3B",
+		},
+		{
+			description:
+				"A general-purpose Transformer that can be used to translate from English to German, French, or Romanian.",
+			id: "google-t5/t5-base",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that can translate between 100 languages.",
+			id: "Iker/Translate-100-languages",
+		},
+		{
+			description: "An application that can translate between many languages.",
+			id: "Geonmo/nllb-translation-demo",
+		},
+	],
+	summary: "Translation is the task of converting text from one language to another.",
+	widgetModels: ["facebook/mbart-large-50-many-to-many-mmt"],
+	youtubeId: "1JvfrvZgi6c",
+};
+
+export default taskData;

package/src/tasks/translation/inference.ts

@@ -0,0 +1,67 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+
+/**
+ * Inputs for Translation inference
+ */
+export interface TranslationInput {
+	/**
+	 * The text to translate.
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: TranslationParameters;
+	[property: string]: unknown;
+}
+
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Translation
+ */
+export interface TranslationParameters {
+	/**
+	 * 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 source language of the text. Required for models that can translate from multiple
+	 * languages.
+	 */
+	src_lang?: string;
+	/**
+	 * Target language to translate to. Required for models that can translate to multiple
+	 * languages.
+	 */
+	tgt_lang?: string;
+	/**
+	 * The truncation strategy to use.
+	 */
+	truncation?: TranslationTruncationStrategy;
+	[property: string]: unknown;
+}
+
+/**
+ * The truncation strategy to use.
+ */
+export type TranslationTruncationStrategy = "do_not_truncate" | "longest_first" | "only_first" | "only_second";
+
+/**
+ * Outputs of inference for the Translation task
+ */
+export interface TranslationOutput {
+	/**
+	 * The translated text.
+	 */
+	translation_text: string;
+	[property: string]: unknown;
+}

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

@@ -0,0 +1,50 @@
+{
+	"$id": "/inference/schemas/translation/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Translation inference",
+	"title": "TranslationInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"description": "The text to translate.",
+			"type": "string"
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/TranslationParameters"
+		}
+	},
+	"$defs": {
+		"TranslationParameters": {
+			"title": "TranslationParameters",
+			"description": "Additional inference parameters for Translation",
+			"type": "object",
+			"properties": {
+				"src_lang": {
+					"type": "string",
+					"description": "The source language of the text. Required for models that can translate from multiple languages."
+				},
+				"tgt_lang": {
+					"type": "string",
+					"description": "Target language to translate to. Required for models that can translate to multiple languages."
+				},
+				"clean_up_tokenization_spaces": {
+					"type": "boolean",
+					"description": "Whether to clean up the potential extra spaces in the text output."
+				},
+				"truncation": {
+					"title": "TranslationTruncationStrategy",
+					"type": "string",
+					"description": "The truncation strategy to use.",
+					"enum": ["do_not_truncate", "longest_first", "only_first", "only_second"]
+				},
+				"generate_parameters": {
+					"title": "generateParameters",
+					"type": "object",
+					"description": "Additional parametrization of the text generation algorithm."
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

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

@@ -0,0 +1,14 @@
+{
+	"$id": "/inference/schemas/translation/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Translation task",
+	"title": "TranslationOutput",
+	"type": "object",
+	"properties": {
+		"translation_text": {
+			"type": "string",
+			"description": "The translated text."
+		}
+	},
+	"required": ["translation_text"]
+}

package/src/tasks/unconditional-image-generation/about.md

@@ -0,0 +1,50 @@
+## About the Task
+
+Unconditional image generation is the task of generating new images without any specific input. The main goal of this is to create novel, original images that are not based on existing images.
+This can be used for a variety of applications, such as creating new artistic images, improving image recognition algorithms, or generating photorealistic images for virtual reality environments.
+
+Unconditional image generation models usually start with a _seed_ that generates a _random noise vector_. The model will then use this vector to create an output image similar to the images used for training the model.
+
+An example of unconditional image generation would be generating the image of a face on a model trained with the [CelebA dataset](https://huggingface.co/datasets/huggan/CelebA-HQ) or [generating a butterfly](https://huggingface.co/spaces/huggan/butterfly-gan) on a model trained with the [Smithsonian Butterflies dataset](https://huggingface.co/datasets/ceyda/smithsonian_butterflies).
+
+[Generative adversarial networks](https://en.wikipedia.org/wiki/Generative_adversarial_network) and [Diffusion](https://huggingface.co/docs/diffusers/index) are common architectures for this task.
+
+## Use Cases
+
+Unconditional image generation can be used for a variety of applications.
+
+### Artistic Expression
+
+Unconditional image generation can be used to create novel, original artwork that is not based on any existing images. This can be used to explore new creative possibilities and produce unique, imaginative images.
+
+### Data Augmentation
+
+Unconditional image generation models can be used to generate new images to improve the performance of image recognition algorithms. This makes algorithms more robust and able to handle a broader range of images.
+
+### Virtual Reality
+
+Unconditional image generation models can be used to create photorealistic images that can be used in virtual reality environments. This makes the VR experience more immersive and realistic.
+
+### Medical Imaging
+
+Unconditional image generation models can generate new medical images, such as CT or MRI scans, that can be used to train and evaluate medical imaging algorithms. This can improve the accuracy and reliability of these algorithms.
+
+### Industrial Design
+
+Unconditional image generation models can generate new designs for products, such as clothing or furniture, that are not based on any existing designs. This way, designers can explore new creative possibilities and produce unique, innovative designs.
+
+## Model Hosting and Inference
+
+This section should have useful information about Model Hosting and Inference
+
+## Useful Resources
+
+- [Hugging Face Diffusion Models Course](https://github.com/huggingface/diffusion-models-class)
+- [Getting Started with Diffusers](https://huggingface.co/docs/diffusers/index)
+- [Unconditional Image Generation Training](https://huggingface.co/docs/diffusers/training/unconditional_training)
+
+### Training your own model in just a few seconds
+
+In this area, you can insert useful information about training the model
+
+This page was made possible thanks to the efforts of [Someet Sahoo](https://huggingface.co/Someet24) and [Juan Carlos Piñeros](https://huggingface.co/juancopi81).

package/src/tasks/unconditional-image-generation/data.ts

@@ -0,0 +1,72 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description:
+				"The CIFAR-100 dataset consists of 60000 32x32 colour images in 100 classes, with 600 images per class.",
+			id: "cifar100",
+		},
+		{
+			description: "Multiple images of celebrities, used for facial expression translation.",
+			id: "CelebA",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label: "Seed",
+				content: "42",
+				type: "text",
+			},
+			{
+				label: "Number of images to generate:",
+				content: "4",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				filename: "unconditional-image-generation-output.jpeg",
+				type: "img",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"The inception score (IS) evaluates the quality of generated images. It measures the diversity of the generated images (the model predictions are evenly distributed across all possible labels) and their 'distinction' or 'sharpness' (the model confidently predicts a single label for each image).",
+			id: "Inception score (IS)",
+		},
+		{
+			description:
+				"The Fréchet Inception Distance (FID) evaluates the quality of images created by a generative model by calculating the distance between feature vectors for real and generated images.",
+			id: "Frećhet Inception Distance (FID)",
+		},
+	],
+	models: [
+		{
+			description:
+				"High-quality image generation model trained on the CIFAR-10 dataset. It synthesizes images of the ten classes presented in the dataset using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics.",
+			id: "google/ddpm-cifar10-32",
+		},
+		{
+			description:
+				"High-quality image generation model trained on the 256x256 CelebA-HQ dataset. It synthesizes images of faces using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics.",
+			id: "google/ddpm-celebahq-256",
+		},
+	],
+	spaces: [
+		{
+			description: "An application that can generate realistic faces.",
+			id: "CompVis/celeba-latent-diffusion",
+		},
+	],
+	summary:
+		"Unconditional image generation is the task of generating images with no condition in any context (like a prompt text or another image). Once trained, the model will create images that resemble its training data distribution.",
+	widgetModels: [""],
+	// TODO: Add related video
+	youtubeId: "",
+};
+
+export default taskData;