@huggingface/tasks 0.0.1

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@huggingface/tasks",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "A library of tasks for the Hugging Face Hub",
+	"main": "./dist/index.js",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"require": "./dist/index.js",
+			"import": "./dist/index.mjs"
+		}
+	},
+  "scripts": {
+    "prepublishOnly": "npm run build",
+		"build": "tsup src/index.ts --format cjs,esm --clean --dts",
+		"test": "vitest run",
+		"type-check": "tsc"
+  },
+	"source": "src/index.ts",
+	"files": [
+		"assets",
+		"src",
+		"dist"
+	],
+	"devDependencies": {
+		"tsup": "^7.3.0",
+		"typescript": "^5.2.2"
+	},
+  "publishConfig": {
+		"access": "public"
+	}
+}

package/src/Types.ts

@@ -0,0 +1,58 @@
+import type { ModelLibraryKey } from "../../js/src/lib/interfaces/Libraries";
+import type { PipelineType } from "../../js/src/lib/interfaces/Types";
+
+export interface ExampleRepo {
+	description: string;
+	id:          string;
+}
+
+export type TaskDemoEntry = {
+	filename: string;
+	type:     "audio";
+} | {
+	data: Array<{
+		label: string;
+		score: number;
+	}>;
+	type: "chart";
+} | {
+	filename: string;
+	type:     "img";
+} | {
+	table: string[][];
+	type:  "tabular";
+} | {
+	content: string;
+	label:   string;
+	type:    "text";
+} | {
+	text:   string;
+	tokens: Array<{
+		end:   number;
+		start: number;
+		type:  string;
+	}>;
+	type: "text-with-tokens";
+} ;
+
+export interface TaskDemo {
+	inputs:  TaskDemoEntry[];
+	outputs: TaskDemoEntry[];
+}
+
+export interface TaskData {
+	datasets:       ExampleRepo[];
+	demo:           TaskDemo;
+	id:             PipelineType;
+	isPlaceholder?: boolean;
+	label:          string;
+	libraries:      ModelLibraryKey[];
+	metrics:        ExampleRepo[];
+	models:         ExampleRepo[];
+	spaces:         ExampleRepo[];
+	summary:        string;
+	widgetModels:   string[];
+	youtubeId?:     string;
+}
+
+export type TaskDataCustom = Omit<TaskData, "id" | "label" | "libraries">;

package/src/audio-classification/about.md

@@ -0,0 +1,85 @@
+## 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 the Inference API 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_ACCESS_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://ai.facebook.com/blog/wav2vec-20-learning-the-structure-of-speech-from-raw-audio/) is a large multilingual model trained on 128 languages and with 436K hours of speech.
+
+## 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
+
+- [Audio classification task guide](https://huggingface.co/docs/transformers/tasks/audio_classification)

package/src/audio-classification/data.ts

@@ -0,0 +1,77 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A benchmark of 10 different audio tasks.",
+			id:          "superb",
+		},
+	],
+	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 predict the language spoken in a given audio.",
+			id:          "akhaliq/Speechbrain-audio-classification",
+		},
+	],
+	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: ["facebook/mms-lid-126"],
+	youtubeId:    "KWwzcmG98Ds",
+};
+
+export default taskData;

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

@@ -0,0 +1,55 @@
+## 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 the [Inference API](https://huggingface.co/inference-api) 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_ACCESS_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/audio-to-audio/data.ts

@@ -0,0 +1,63 @@
+import type { TaskDataCustom } from "../Types";
+
+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:          "speechbrain/metricgan-plus-voicebank",
+		},
+	],
+	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/automatic-speech-recognition/about.md

@@ -0,0 +1,86 @@
+## 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 [~9,000 ASR models](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&sort=downloads) that you can use right away by trying out the widgets directly in the browser or calling the models as a service using the Inference API. Here is a simple code snippet to do exactly this:
+
+```python
+import json
+import requests
+
+headers = {"Authorization": f"Bearer {API_TOKEN}"}
+API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large-v2"
+
+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 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) if you want one-click managed Inference without any hassle.
+
+```python
+from transformers import pipeline
+
+with open("sample.flac", "rb") as f:
+  data = f.read()
+
+pipe = pipeline("automatic-speech-recognition", "openai/whisper-large-v2")
+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"}
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to transcribe text with javascript using models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_ACCESS_TOKEN);
+await inference.automaticSpeechRecognition({
+  data: await (await fetch("sample.flac")).blob(),
+  model: "openai/whisper-large-v2",  
+})
+```
+
+## 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-v2) is a large multilingual model trained on 100+ languages and with 680K 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
+- [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)
+- [A guide on Fine-tuning 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)

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

@@ -0,0 +1,77 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "18,000 hours of multilingual audio-text dataset in 108 languages.",
+			id:          "mozilla-foundation/common_voice_13_0",
+		},
+		{
+			description: "An English dataset with 1,000 hours of data.",
+			id:          "librispeech_asr",
+		},
+		{
+			description: "High quality, multi-speaker audio data and their transcriptions in various languages.",
+			id:          "openslr",
+		},
+	],
+	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-v2",
+		},
+		{
+			description: "A good generic ASR model by MetaAI.",
+			id:          "facebook/wav2vec2-base-960h",
+		},
+		{
+			description: "An end-to-end model that performs ASR and Speech Translation by MetaAI.",
+			id:          "facebook/s2t-small-mustc-en-fr-st",
+		},
+	],
+	spaces:       [
+		{
+			description: "A powerful general-purpose speech recognition application.",
+			id:          "openai/whisper",
+		},
+		{
+			description: "Fastest speech recognition application.",
+			id:          "sanchit-gandhi/whisper-jax",
+		},
+		{
+			description: "An application that transcribes speeches in YouTube videos.",
+			id:          "jeffistyping/Youtube-Whisperer",
+		},
+	],
+	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-v2"],
+	youtubeId:    "TksaY_FDgnk",
+};
+
+export default taskData;

package/src/const.ts

@@ -0,0 +1,51 @@
+import type { ModelLibraryKey } from "../../js/src/lib/interfaces/Libraries";
+import type { PipelineType } from "../../js/src/lib/interfaces/Types";
+
+/*
+ * Model libraries compatible with each ML task
+ */
+export const TASKS_MODEL_LIBRARIES: Record<PipelineType, ModelLibraryKey[]> = {
+	"audio-classification":           ["speechbrain", "transformers"],
+	"audio-to-audio":                 ["asteroid", "speechbrain"],
+	"automatic-speech-recognition":   ["espnet", "nemo", "speechbrain", "transformers", "transformers.js"],
+	"conversational":                 ["transformers"],
+	"depth-estimation":               ["transformers"],
+	"document-question-answering":    ["transformers"],
+	"feature-extraction":             ["sentence-transformers", "transformers", "transformers.js"],
+	"fill-mask":                      ["transformers", "transformers.js"],
+	"graph-ml":                       ["transformers"],
+	"image-classification":           ["keras", "timm", "transformers", "transformers.js"],
+	"image-segmentation":             ["transformers", "transformers.js"],
+	"image-to-image":                 [],
+	"image-to-text":                  ["transformers.js"],
+	"video-classification":           [],
+	"multiple-choice":                ["transformers"],
+	"object-detection":               ["transformers", "transformers.js"],
+	"other":                          [],
+	"question-answering":             ["adapter-transformers", "allennlp", "transformers", "transformers.js"],
+	"robotics":                       [],
+	"reinforcement-learning":         ["transformers", "stable-baselines3", "ml-agents", "sample-factory"],
+	"sentence-similarity":            ["sentence-transformers", "spacy", "transformers.js"],
+	"summarization":                  ["transformers", "transformers.js"],
+	"table-question-answering":       ["transformers"],
+	"table-to-text":                  ["transformers"],
+	"tabular-classification":         ["sklearn"],
+	"tabular-regression":             ["sklearn"],
+	"tabular-to-text":                ["transformers"],
+	"text-classification":            ["adapter-transformers", "spacy", "transformers", "transformers.js"],
+	"text-generation":                ["transformers", "transformers.js"],
+	"text-retrieval":                 [],
+	"text-to-image":                  [],
+	"text-to-speech":                 ["espnet", "tensorflowtts", "transformers"],
+	"text-to-audio":                  ["transformers"],	
+	"text-to-video":                  [],
+	"text2text-generation":           ["transformers", "transformers.js"],
+	"time-series-forecasting":        [],
+	"token-classification":           ["adapter-transformers", "flair", "spacy", "span-marker", "stanza", "transformers", "transformers.js"],
+	"translation":                    ["transformers", "transformers.js"],
+	"unconditional-image-generation": [],
+	"visual-question-answering":      [],
+	"voice-activity-detection":       [],
+	"zero-shot-classification":       ["transformers", "transformers.js"],
+	"zero-shot-image-classification": ["transformers.js"],
+};

package/src/conversational/about.md

@@ -0,0 +1,50 @@
+## Use Cases
+
+### Chatbot 💬
+
+Chatbots are used to have conversations instead of providing direct contact with a live human. They are used to provide customer service, sales, and can even be used to play games (see [ELIZA](https://en.wikipedia.org/wiki/ELIZA) from 1966 for one of the earliest examples). 
+
+## Voice Assistants 🎙️
+
+Conversational response models are used as part of voice assistants to provide appropriate responses to voice based queries. 
+
+## Inference
+
+You can infer with Conversational models with the 🤗 Transformers library using the `conversational` pipeline. This pipeline takes a conversation prompt or a list of conversations and generates responses for each prompt. The models that this pipeline can use are models that have been fine-tuned on a multi-turn conversational task (see https://huggingface.co/models?filter=conversational for a list of updated Conversational models). 
+
+```python
+from transformers import pipeline, Conversation
+converse = pipeline("conversational")
+
+conversation_1 = Conversation("Going to the movies tonight - any suggestions?")
+conversation_2 = Conversation("What's the last book you have read?")
+converse([conversation_1, conversation_2])
+
+## Output:
+## Conversation 1
+## user >> Going to the movies tonight - any suggestions? 
+## bot >> The Big Lebowski ,
+## Conversation 2
+## user >> What's the last book you have read? 
+## bot >> The Last Question
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to infer with conversational models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_ACCESS_TOKEN);
+await inference.conversational({
+  model: 'facebook/blenderbot-400M-distill',
+  inputs: "Going to the movies tonight - any suggestions?"
+})
+```
+
+## Useful Resources
+
+- Learn how ChatGPT and InstructGPT work in this blog: [Illustrating Reinforcement Learning from Human Feedback (RLHF)](https://huggingface.co/blog/rlhf)
+- [Reinforcement Learning from Human Feedback From Zero to ChatGPT](https://www.youtube.com/watch?v=EAd4oQtEJOM)
+- [A guide on Dialog Agents](https://huggingface.co/blog/dialog-agents)
+
+This page was made possible thanks to the efforts of [Viraat Aryabumi](https://huggingface.co/viraat).