@huggingface/tasks 0.13.0 → 0.13.1-test

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

@@ -1,86 +0,0 @@
-## Use Cases
-
-### Command Recognition
-
-Command recognition or keyword spotting classifies utterances into a predefined set of commands. This is often done on-device for fast response time.
-
-As an example, using the Google Speech Commands dataset, given an input, a model can classify which of the following commands the user is typing:
-
-```
-'yes', 'no', 'up', 'down', 'left', 'right', 'on', 'off', 'stop', 'go', 'unknown', 'silence'
-```
-
-Speechbrain models can easily perform this task with just a couple of lines of code!
-
-```python
-from speechbrain.pretrained import EncoderClassifier
-model = EncoderClassifier.from_hparams(
-  "speechbrain/google_speech_command_xvector"
-)
-model.classify_file("file.wav")
-```
-
-### Language Identification
-
-Datasets such as VoxLingua107 allow anyone to train language identification models for up to 107 languages! This can be extremely useful as a preprocessing step for other systems. Here's an example [model](https://huggingface.co/TalTechNLP/voxlingua107-epaca-tdnn)trained on VoxLingua107.
-
-### Emotion recognition
-
-Emotion recognition is self explanatory. In addition to trying the widgets, you can use Inference Endpoints to perform audio classification. Here is a simple example that uses a [HuBERT](https://huggingface.co/superb/hubert-large-superb-er) model fine-tuned for this task.
-
-```python
-import json
-import requests
-
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
-API_URL = "https://api-inference.huggingface.co/models/superb/hubert-large-superb-er"
-
-def query(filename):
-    with open(filename, "rb") as f:
-        data = f.read()
-    response = requests.request("POST", API_URL, headers=headers, data=data)
-    return json.loads(response.content.decode("utf-8"))
-
-data = query("sample1.flac")
-# [{'label': 'neu', 'score': 0.60},
-# {'label': 'hap', 'score': 0.20},
-# {'label': 'ang', 'score': 0.13},
-# {'label': 'sad', 'score': 0.07}]
-```
-
-You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer with audio classification models on Hugging Face Hub.
-
-```javascript
-import { HfInference } from "@huggingface/inference";
-
-const inference = new HfInference(HF_TOKEN);
-await inference.audioClassification({
-	data: await (await fetch("sample.flac")).blob(),
-	model: "facebook/mms-lid-126",
-});
-```
-
-### Speaker Identification
-
-Speaker Identification is classifying the audio of the person speaking. Speakers are usually predefined. You can try out this task with [this model](https://huggingface.co/superb/wav2vec2-base-superb-sid). A useful dataset for this task is VoxCeleb1.
-
-## Solving audio classification for your own data
-
-We have some great news! You can do fine-tuning (transfer learning) to train a well-performing model without requiring as much data. Pretrained models such as Wav2Vec2 and HuBERT exist. [Facebook's Wav2Vec2 XLS-R model](https://huggingface.co/docs/transformers/model_doc/xlsr_wav2vec2) is a large multilingual model trained on 128 languages and with 436K hours of speech. Similarly, you can also use [OpenAI's Whisper](https://huggingface.co/docs/transformers/model_doc/whisper) trained on up to 4 Million hours of multilingual speech data for this task too!
-
-## Useful Resources
-
-Would you like to learn more about the topic? Awesome! Here you can find some curated resources that you may find helpful!
-
-### Notebooks
-
-- [PyTorch](https://colab.research.google.com/github/huggingface/notebooks/blob/master/examples/audio_classification.ipynb)
-
-### Scripts for training
-
-- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/audio-classification)
-
-### Documentation
-
-- [Hugging Face Audio Course](https://huggingface.co/learn/audio-course/chapter4/introduction)
-- [Audio classification task guide](https://huggingface.co/docs/transformers/tasks/audio_classification)

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

@@ -1,81 +0,0 @@
-import type { TaskDataCustom } from "..";
-
-const taskData: TaskDataCustom = {
-	datasets: [
-		{
-			description: "A benchmark of 10 different audio tasks.",
-			id: "s3prl/superb",
-		},
-		{
-			description: "A dataset of YouTube clips and their sound categories.",
-			id: "agkphysics/AudioSet",
-		},
-	],
-	demo: {
-		inputs: [
-			{
-				filename: "audio.wav",
-				type: "audio",
-			},
-		],
-		outputs: [
-			{
-				data: [
-					{
-						label: "Up",
-						score: 0.2,
-					},
-					{
-						label: "Down",
-						score: 0.8,
-					},
-				],
-				type: "chart",
-			},
-		],
-	},
-	metrics: [
-		{
-			description: "",
-			id: "accuracy",
-		},
-		{
-			description: "",
-			id: "recall",
-		},
-		{
-			description: "",
-			id: "precision",
-		},
-		{
-			description: "",
-			id: "f1",
-		},
-	],
-	models: [
-		{
-			description: "An easy-to-use model for command recognition.",
-			id: "speechbrain/google_speech_command_xvector",
-		},
-		{
-			description: "An emotion recognition model.",
-			id: "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition",
-		},
-		{
-			description: "A language identification model.",
-			id: "facebook/mms-lid-126",
-		},
-	],
-	spaces: [
-		{
-			description: "An application that can classify music into different genre.",
-			id: "kurianbenoy/audioclassification",
-		},
-	],
-	summary:
-		"Audio classification is the task of assigning a label or class to a given audio. It can be used for recognizing which command a user is giving or the emotion of a statement, as well as identifying a speaker.",
-	widgetModels: ["MIT/ast-finetuned-audioset-10-10-0.4593"],
-	youtubeId: "KWwzcmG98Ds",
-};
-
-export default taskData;

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

@@ -1,52 +0,0 @@
-/**
- * Inference code generated from the JSON schema spec in ./spec
- *
- * Using src/scripts/inference-codegen
- */
-/**
- * Inputs for Audio Classification inference
- */
-export interface AudioClassificationInput {
-	/**
-	 * The input audio data as a base64-encoded string. If no `parameters` are provided, you can
-	 * also provide the audio data as a raw bytes payload.
-	 */
-	inputs: string;
-	/**
-	 * Additional inference parameters
-	 */
-	parameters?: AudioClassificationParameters;
-	[property: string]: unknown;
-}
-/**
- * Additional inference parameters
- *
- * Additional inference parameters for Audio Classification
- */
-export interface AudioClassificationParameters {
-	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 AudioClassificationOutput = AudioClassificationOutputElement[];
-/**
- * Outputs for Audio Classification inference
- */
-export interface AudioClassificationOutputElement {
-	/**
-	 * The predicted class label.
-	 */
-	label: string;
-	/**
-	 * The corresponding probability.
-	 */
-	score: number;
-	[property: string]: unknown;
-}

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

@@ -1,35 +0,0 @@
-{
-	"$id": "/inference/schemas/audio-classification/input.json",
-	"$schema": "http://json-schema.org/draft-06/schema#",
-	"description": "Inputs for Audio Classification inference",
-	"title": "AudioClassificationInput",
-	"type": "object",
-	"properties": {
-		"inputs": {
-			"description": "The input audio data as a base64-encoded string. If no `parameters` are provided, you can also provide the audio data as a raw bytes payload.",
-			"type": "string"
-		},
-		"parameters": {
-			"description": "Additional inference parameters",
-			"$ref": "#/$defs/AudioClassificationParameters"
-		}
-	},
-	"$defs": {
-		"AudioClassificationParameters": {
-			"title": "AudioClassificationParameters",
-			"description": "Additional inference parameters for Audio Classification",
-			"type": "object",
-			"properties": {
-				"function_to_apply": {
-					"title": "AudioClassificationOutputTransform",
-					"$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/audio-classification/spec/output.json

@@ -1,11 +0,0 @@
-{
-	"$id": "/inference/schemas/audio-classification/output.json",
-	"$schema": "http://json-schema.org/draft-06/schema#",
-	"title": "AudioClassificationOutput",
-	"description": "Outputs for Audio Classification inference",
-	"type": "array",
-	"items": {
-		"type": "object",
-		"$ref": "/inference/schemas/common-definitions.json#/definitions/ClassificationOutput"
-	}
-}

package/src/tasks/audio-to-audio/about.md

@@ -1,56 +0,0 @@
-## Use Cases
-
-### Speech Enhancement (Noise removal)
-
-Speech Enhancement is a bit self explanatory. It improves (or enhances) the quality of an audio by removing noise. There are multiple libraries to solve this task, such as Speechbrain, Asteroid and ESPNet. Here is a simple example using Speechbrain
-
-```python
-from speechbrain.pretrained import SpectralMaskEnhancement
-model = SpectralMaskEnhancement.from_hparams(
-  "speechbrain/mtl-mimic-voicebank"
-)
-model.enhance_file("file.wav")
-```
-
-Alternatively, you can use [Inference Endpoints](https://huggingface.co/inference-endpoints) to solve this task
-
-```python
-import json
-import requests
-
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
-API_URL = "https://api-inference.huggingface.co/models/speechbrain/mtl-mimic-voicebank"
-
-def query(filename):
-    with open(filename, "rb") as f:
-        data = f.read()
-    response = requests.request("POST", API_URL, headers=headers, data=data)
-    return json.loads(response.content.decode("utf-8"))
-
-data = query("sample1.flac")
-```
-
-You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer with audio-to-audio models on Hugging Face Hub.
-
-```javascript
-import { HfInference } from "@huggingface/inference";
-
-const inference = new HfInference(HF_TOKEN);
-await inference.audioToAudio({
-	data: await (await fetch("sample.flac")).blob(),
-	model: "speechbrain/sepformer-wham",
-});
-```
-
-### Audio Source Separation
-
-Audio Source Separation allows you to isolate different sounds from individual sources. For example, if you have an audio file with multiple people speaking, you can get an audio file for each of them. You can then use an Automatic Speech Recognition system to extract the text from each of these sources as an initial step for your system!
-
-Audio-to-Audio can also be used to remove noise from audio files: you get one audio for the person speaking and another audio for the noise. This can also be useful when you have multi-person audio with some noise: yyou can get one audio for each person and then one audio for the noise.
-
-## Training a model for your own data
-
-If you want to learn how to train models for the Audio-to-Audio task, we recommend the following tutorials:
-
-- [Speech Enhancement](https://speechbrain.github.io/tutorial_enhancement.html)
-- [Source Separation](https://speechbrain.github.io/tutorial_separation.html)

package/src/tasks/audio-to-audio/data.ts

@@ -1,70 +0,0 @@
-import type { TaskDataCustom } from "..";
-
-const taskData: TaskDataCustom = {
-	datasets: [
-		{
-			description: "512-element X-vector embeddings of speakers from CMU ARCTIC dataset.",
-			id: "Matthijs/cmu-arctic-xvectors",
-		},
-	],
-	demo: {
-		inputs: [
-			{
-				filename: "input.wav",
-				type: "audio",
-			},
-		],
-		outputs: [
-			{
-				filename: "label-0.wav",
-				type: "audio",
-			},
-			{
-				filename: "label-1.wav",
-				type: "audio",
-			},
-		],
-	},
-	metrics: [
-		{
-			description:
-				"The Signal-to-Noise ratio is the relationship between the target signal level and the background noise level. It is calculated as the logarithm of the target signal divided by the background noise, in decibels.",
-			id: "snri",
-		},
-		{
-			description:
-				"The Signal-to-Distortion ratio is the relationship between the target signal and the sum of noise, interference, and artifact errors",
-			id: "sdri",
-		},
-	],
-	models: [
-		{
-			description: "A solid model of audio source separation.",
-			id: "speechbrain/sepformer-wham",
-		},
-		{
-			description: "A speech enhancement model.",
-			id: "ResembleAI/resemble-enhance",
-		},
-		{
-			description: "A model that can change the voice in a speech recording.",
-			id: "microsoft/speecht5_vc",
-		},
-	],
-	spaces: [
-		{
-			description: "An application for speech separation.",
-			id: "younver/speechbrain-speech-separation",
-		},
-		{
-			description: "An application for audio style transfer.",
-			id: "nakas/audio-diffusion_style_transfer",
-		},
-	],
-	summary:
-		"Audio-to-Audio is a family of tasks in which the input is an audio and the output is one or multiple generated audios. Some example tasks are speech enhancement and source separation.",
-	widgetModels: ["speechbrain/sepformer-wham"],
-	youtubeId: "iohj7nCCYoM",
-};
-
-export default taskData;

package/src/tasks/automatic-speech-recognition/about.md

@@ -1,90 +0,0 @@
-## Use Cases
-
-### Virtual Speech Assistants
-
-Many edge devices have an embedded virtual assistant to interact with the end users better. These assistances rely on ASR models to recognize different voice commands to perform various tasks. For instance, you can ask your phone for dialing a phone number, ask a general question, or schedule a meeting.
-
-### Caption Generation
-
-A caption generation model takes audio as input from sources to generate automatic captions through transcription, for live-streamed or recorded videos. This can help with content accessibility. For example, an audience watching a video that includes a non-native language, can rely on captions to interpret the content. It can also help with information retention at online-classes environments improving knowledge assimilation while reading and taking notes faster.
-
-## Task Variants
-
-### Multilingual ASR
-
-Multilingual ASR models can convert audio inputs with multiple languages into transcripts. Some multilingual ASR models include [language identification](https://huggingface.co/tasks/audio-classification) blocks to improve the performance.
-
-The use of Multilingual ASR has become popular, the idea of maintaining just a single model for all language can simplify the production pipeline. Take a look at [Whisper](https://huggingface.co/openai/whisper-large-v2) to get an idea on how 100+ languages can be processed by a single model.
-
-## Inference
-
-The Hub contains over [17,000 ASR models](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&sort=downloads) that you can test right away in your browser using the model page widgets. You can also use any model as a service using the Serverless Inference API. We also support libraries such as [transformers](https://huggingface.co/models?library=transformers&pipeline_tag=automatic-speech-recognition&sort=downloads), [speechbrain](https://huggingface.co/models?library=speechbrain&pipeline_tag=automatic-speech-recognition&sort=downloads), [NeMo](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&library=nemo&sort=downloads) and [espnet](https://huggingface.co/models?library=espnet&pipeline_tag=automatic-speech-recognition&sort=downloads) via the Serverless Inference API. Here's a simple code snippet to run inference:
-
-```python
-import json
-import requests
-
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
-API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large-v3"
-
-def query(filename):
-    with open(filename, "rb") as f:
-        data = f.read()
-    response = requests.request("POST", API_URL, headers=headers, data=data)
-    return json.loads(response.content.decode("utf-8"))
-
-data = query("sample1.flac")
-```
-
-You can also use [huggingface.js](https://github.com/huggingface/huggingface.js), the JavaScript client, to transcribe audio with the Serverless Inference API.
-
-```javascript
-import { HfInference } from "@huggingface/inference";
-
-const inference = new HfInference(HF_TOKEN);
-await inference.automaticSpeechRecognition({
-	data: await (await fetch("sample.flac")).blob(),
-	model: "openai/whisper-large-v3",
-});
-```
-
-For transformers-compatible models like Whisper, Wav2Vec2, and HuBERT, you can also run inference with the library as follows:
-
-```python
-# pip install --upgrade transformers
-
-from transformers import pipeline
-
-pipe = pipeline("automatic-speech-recognition", "openai/whisper-large-v3")
-
-pipe("sample.flac")
-# {'text': "GOING ALONG SLUSHY COUNTRY ROADS AND SPEAKING TO DAMP AUDIENCES IN DRAUGHTY SCHOOL ROOMS DAY AFTER DAY FOR A FORTNIGHT HE'LL HAVE TO PUT IN AN APPEARANCE AT SOME PLACE OF WORSHIP ON SUNDAY MORNING AND HE CAN COME TO US IMMEDIATELY AFTERWARDS"}
-```
-
-## Solving ASR for your own data
-
-We have some great news! You can fine-tune (transfer learning) a foundational speech model on a specific language without tonnes of data. Pretrained models such as Whisper, Wav2Vec2-MMS and HuBERT exist. [OpenAI's Whisper model](https://huggingface.co/openai/whisper-large-v3) is a large multilingual model trained on 100+ languages and with 4 Million hours of speech.
-
-The following detailed [blog post](https://huggingface.co/blog/fine-tune-whisper) shows how to fine-tune a pre-trained Whisper checkpoint on labeled data for ASR. With the right data and strategy you can fine-tune a high-performant model on a free Google Colab instance too. We suggest to read the blog post for more info!
-
-## Hugging Face Whisper Event
-
-On December 2022, over 450 participants collaborated, fine-tuned and shared 600+ ASR Whisper models in 100+ different languages. You can compare these models on the event's speech recognition [leaderboard](https://huggingface.co/spaces/whisper-event/leaderboard?dataset=mozilla-foundation%2Fcommon_voice_11_0&config=ar&split=test).
-
-These events help democratize ASR for all languages, including low-resource languages. In addition to the trained models, the [event](https://github.com/huggingface/community-events/tree/main/whisper-fine-tuning-event) helps to build practical collaborative knowledge.
-
-## Useful Resources
-
-- [Hugging Face Audio Course](https://huggingface.co/learn/audio-course/chapter5/introduction)
-- [Fine-tuning MetaAI's MMS Adapter Models for Multi-Lingual ASR](https://huggingface.co/blog/mms_adapters)
-- [Making automatic speech recognition work on large files with Wav2Vec2 in 🤗 Transformers](https://huggingface.co/blog/asr-chunking)
-- [Boosting Wav2Vec2 with n-grams in 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram)
-- [ML for Audio Study Group - Intro to Audio and ASR Deep Dive](https://www.youtube.com/watch?v=D-MH6YjuIlE)
-- [Massively Multilingual ASR: 50 Languages, 1 Model, 1 Billion Parameters](https://arxiv.org/pdf/2007.03001.pdf)
-- An ASR toolkit made by [NVIDIA: NeMo](https://github.com/NVIDIA/NeMo) with code and pretrained models useful for new ASR models. Watch the [introductory video](https://www.youtube.com/embed/wBgpMf_KQVw) for an overview.
-- [An introduction to SpeechT5, a multi-purpose speech recognition and synthesis model](https://huggingface.co/blog/speecht5)
-- [Fine-tune Whisper For Multilingual ASR with 🤗Transformers](https://huggingface.co/blog/fine-tune-whisper)
-- [Automatic speech recognition task guide](https://huggingface.co/docs/transformers/tasks/asr)
-- [Speech Synthesis, Recognition, and More With SpeechT5](https://huggingface.co/blog/speecht5)
-- [Fine-Tune W2V2-Bert for low-resource ASR with 🤗 Transformers](https://huggingface.co/blog/fine-tune-w2v2-bert)
-- [Speculative Decoding for 2x Faster Whisper Inference](https://huggingface.co/blog/whisper-speculative-decoding)

package/src/tasks/automatic-speech-recognition/data.ts

@@ -1,82 +0,0 @@
-import type { TaskDataCustom } from "..";
-
-const taskData: TaskDataCustom = {
-	datasets: [
-		{
-			description: "31,175 hours of multilingual audio-text dataset in 108 languages.",
-			id: "mozilla-foundation/common_voice_17_0",
-		},
-		{
-			description: "A dataset with 44.6k hours of English speaker data and 6k hours of other language speakers.",
-			id: "parler-tts/mls_eng",
-		},
-		{
-			description: "A multi-lingual audio dataset with 370K hours of audio.",
-			id: "espnet/yodas",
-		},
-	],
-	demo: {
-		inputs: [
-			{
-				filename: "input.flac",
-				type: "audio",
-			},
-		],
-		outputs: [
-			{
-				/// GOING ALONG SLUSHY COUNTRY ROADS AND SPEAKING TO DAMP AUDIENCES I
-				label: "Transcript",
-				content: "Going along slushy country roads and speaking to damp audiences in...",
-				type: "text",
-			},
-		],
-	},
-	metrics: [
-		{
-			description: "",
-			id: "wer",
-		},
-		{
-			description: "",
-			id: "cer",
-		},
-	],
-	models: [
-		{
-			description: "A powerful ASR model by OpenAI.",
-			id: "openai/whisper-large-v3",
-		},
-		{
-			description: "A good generic speech model by MetaAI for fine-tuning.",
-			id: "facebook/w2v-bert-2.0",
-		},
-		{
-			description: "An end-to-end model that performs ASR and Speech Translation by MetaAI.",
-			id: "facebook/seamless-m4t-v2-large",
-		},
-		{
-			description: "Powerful speaker diarization model.",
-			id: "pyannote/speaker-diarization-3.1",
-		},
-	],
-	spaces: [
-		{
-			description: "A powerful general-purpose speech recognition application.",
-			id: "hf-audio/whisper-large-v3",
-		},
-		{
-			description: "Fastest speech recognition application.",
-			id: "sanchit-gandhi/whisper-jax",
-		},
-		{
-			description: "A high quality speech and text translation model by Meta.",
-			id: "facebook/seamless_m4t",
-		},
-	],
-	summary:
-		"Automatic Speech Recognition (ASR), also known as Speech to Text (STT), is the task of transcribing a given audio to text. It has many applications, such as voice user interfaces.",
-	widgetModels: ["openai/whisper-large-v3"],
-	youtubeId: "TksaY_FDgnk",
-};
-
-export default taskData;