@huggingface/tasks 0.0.1

package/src/conversational/data.ts

@@ -0,0 +1,62 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A dataset of 7k conversations explicitly designed to exhibit multiple conversation modes: displaying personality, having empathy, and demonstrating knowledge.",
+			id:          "blended_skill_talk",
+		},
+		{
+			description: "ConvAI is a dataset of human-to-bot conversations labeled for quality. This data can be used to train a metric for evaluating dialogue systems",
+			id:          "conv_ai_2",
+		},
+		{
+			description: "EmpatheticDialogues, is a dataset of 25k conversations grounded in emotional situations",
+			id:          "empathetic_dialogues",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content: "Hey my name is Julien! How are you?",
+				type:    "text",
+			},
+			
+		],
+		outputs: [
+			{
+				label:   "Answer",
+				content: "Hi Julien! My name is Julia! I am well.",
+				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",
+		},
+	],
+	models: [
+		{
+			description: "A faster and smaller model than the famous BERT model.",
+			id:          "facebook/blenderbot-400M-distill",
+		},
+		{
+			description: "DialoGPT is a large-scale pretrained dialogue response generation model for multiturn conversations.",
+			id:          "microsoft/DialoGPT-large",
+		},
+	],
+	spaces: [
+		{
+			description: "A chatbot based on Blender model.",
+			id:          "EXFINITE/BlenderBot-UI",
+		},
+	],
+	summary:      "Conversational response modelling is the task of generating conversational text that is relevant, coherent and knowledgable given a prompt. These models have applications in chatbots, and as a part of voice assistants",
+	widgetModels: ["facebook/blenderbot-400M-distill"],
+	youtubeId:    "",
+};
+
+export default taskData;

package/src/depth-estimation/about.md

@@ -0,0 +1,38 @@
+## Use Cases
+Depth estimation models can be used to estimate the depth of different objects present in an image.
+
+### Estimation of Volumetric Information
+Depth estimation models are widely used to study volumetric formation of objects present inside an image. This is an important use case in the domain of computer graphics. 
+
+### 3D Representation
+
+Depth estimation models can also be used to develop a 3D representation from a 2D image.
+
+## Inference
+
+With the `transformers` library, you can use the `depth-estimation` pipeline to infer with image classification models. You can initialize the pipeline with a model id from the Hub. If you do not provide a model id it will initialize with [Intel/dpt-large](https://huggingface.co/Intel/dpt-large) by default. When calling the pipeline you just need to specify a path, http link or an image loaded in PIL. Additionally, you can find a comprehensive list of various depth estimation models at [this link](https://huggingface.co/models?pipeline_tag=depth-estimation).
+
+```python
+from transformers import pipeline
+
+estimator = pipeline(task="depth-estimation", model="Intel/dpt-large")
+result = estimator(images="http://images.cocodataset.org/val2017/000000039769.jpg")
+result
+
+# {'predicted_depth': tensor([[[ 6.3199,  6.3629,  6.4148,  ..., 10.4104, 10.5109, 10.3847],
+#           [ 6.3850,  6.3615,  6.4166,  ..., 10.4540, 10.4384, 10.4554],
+#           [ 6.3519,  6.3176,  6.3575,  ..., 10.4247, 10.4618, 10.4257],
+#           ...,
+#           [22.3772, 22.4624, 22.4227,  ..., 22.5207, 22.5593, 22.5293],
+#           [22.5073, 22.5148, 22.5114,  ..., 22.6604, 22.6344, 22.5871],
+#           [22.5176, 22.5275, 22.5218,  ..., 22.6282, 22.6216, 22.6108]]]),
+#  'depth': <PIL.Image.Image image mode=L size=640x480 at 0x7F1A8BFE5D90>}
+
+# You can visualize the result just by calling `result["depth"]`.
+```
+
+
+## Useful Resources
+
+- [Monocular depth estimation task guide](https://huggingface.co/docs/transformers/tasks/monocular_depth_estimation)
+

package/src/depth-estimation/data.ts

@@ -0,0 +1,52 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "NYU Depth V2 Dataset: Video dataset containing both RGB and depth sensor data",
+			id: "sayakpaul/nyu_depth_v2",
+		},
+	],
+	demo:     {
+		inputs: [
+			{
+				filename: "depth-estimation-input.jpg",
+				type:     "img",
+			},
+		],
+		outputs: [
+			{
+				filename: "depth-estimation-output.png",
+				type:     "img",
+			},
+		],
+	},
+	metrics: [],
+	models:  [
+		{
+			// TO DO: write description
+			description: "Strong Depth Estimation model trained on 1.4 million images.",
+			id:          "Intel/dpt-large",
+		},
+		{
+			// TO DO: write description
+			description: "Strong Depth Estimation model trained on the KITTI dataset.",
+			id:          "vinvino02/glpn-kitti",
+		},
+	],
+	spaces:       [
+		{
+			description: "An application that predicts the depth of an image and then reconstruct the 3D model as voxels.",
+			id:          "radames/dpt-depth-estimation-3d-voxels",
+		},
+		{
+			description: "An application that can estimate the depth in a given image.",
+			id:          "keras-io/Monocular-Depth-Estimation",
+		},
+	],
+	summary:      "Depth estimation is the task of predicting depth of the objects present in an image.",
+	widgetModels: [""],
+	youtubeId:    "",
+};
+
+export default taskData;

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

@@ -0,0 +1,54 @@
+## Use Cases
+
+Document Question Answering models can be used to answer natural language questions about documents. Typically, document QA models consider textual, layout and potentially visual information. This is useful when the question requires some understanding of the visual aspects of the document.
+Nevertheless, certain document QA models can work without document images. Hence the task is not limited to visually-rich documents and allows users to ask questions based on spreadsheets, text PDFs, etc!
+
+### Document Parsing
+
+One of the most popular use cases of document question answering models is the parsing of structured documents. For example, you can extract the name, address, and other information from a form. You can also use the model to extract information from a table, or even a resume.
+
+### Invoice Information Extraction
+
+Another very popular use case is invoice information extraction. For example, you can extract the invoice number, the invoice date, the total amount, the VAT number, and the invoice recipient.
+
+## Inference
+
+You can infer with Document QA models with the 🤗 Transformers library using the [`document-question-answering` pipeline](https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline). If no model checkpoint is given, the pipeline will be initialized with [`impira/layoutlm-document-qa`](https://huggingface.co/impira/layoutlm-document-qa). This pipeline takes question(s) and document(s) as input, and returns the answer.  
+👉 Note that the question answering task solved here is extractive: the model extracts the answer from a context (the document).
+
+
+```python
+from transformers import pipeline
+from PIL import Image
+
+pipe = pipeline("document-question-answering", model="naver-clova-ix/donut-base-finetuned-docvqa")
+
+question = "What is the purchase amount?"
+image = Image.open("your-document.png")
+
+pipe(image=image, question=question)
+
+## [{'answer': '20,000$'}]
+```
+
+## Useful Resources
+
+Would you like to learn more about Document QA? Awesome! Here are some curated resources that you may find helpful!
+
+- [Document Visual Question Answering (DocVQA) challenge](https://rrc.cvc.uab.es/?ch=17)
+- [DocVQA: A Dataset for Document Visual Question Answering](https://arxiv.org/abs/2007.00398) (Dataset paper)
+- [ICDAR 2021 Competition on Document Visual Question Answering](https://lilianweng.github.io/lil-log/2020/10/29/open-domain-question-answering.html) (Conference paper)
+- [HuggingFace's Document Question Answering pipeline](https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline)
+- [Github repo: DocQuery - Document Query Engine Powered by Large Language Models](https://github.com/impira/docquery)
+
+### Notebooks
+
+- [Fine-tuning Donut on DocVQA dataset](https://github.com/NielsRogge/Transformers-Tutorials/tree/0ea77f29d01217587d7e32a848f3691d9c15d6ab/Donut/DocVQA)
+- [Fine-tuning LayoutLMv2 on DocVQA dataset](https://github.com/NielsRogge/Transformers-Tutorials/tree/1b4bad710c41017d07a8f63b46a12523bfd2e835/LayoutLMv2/DocVQA)
+- [Accelerating Document AI](https://huggingface.co/blog/document-ai)
+
+### Documentation
+
+- [Document question answering task guide](https://huggingface.co/docs/transformers/tasks/document_question_answering)
+
+The contents of this page are contributed by [Eliott Zemour](https://huggingface.co/eliolio) and reviewed by [Kwadwo Agyapon-Ntra](https://huggingface.co/KayO) and [Ankur Goyal](https://huggingface.co/ankrgyl).

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

@@ -0,0 +1,67 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			// TODO write proper description
+			description: "Dataset from the 2020 DocVQA challenge. The documents are taken from the UCSF Industry Documents Library.",
+			id:          "eliolio/docvqa",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Question",
+				content: "What is the idea behind the consumer relations efficiency team?",
+				type:    "text",
+			},
+			{
+				filename: "document-question-answering-input.png",
+				type:     "img",
+			},
+		],
+		outputs: [
+			{
+				label:   "Answer",
+				content: "Balance cost efficiency with quality customer service",
+				type:    "text",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "The evaluation metric for the DocVQA challenge is the Average Normalized Levenshtein Similarity (ANLS). This metric is flexible to character regognition errors and compares the predicted answer with the ground truth answer.",
+			id:          "anls",
+		},
+		{
+			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",
+		},
+	],
+	models: [
+		{
+			description: "A LayoutLM model for the document QA task, fine-tuned on DocVQA and SQuAD2.0.",
+			id:          "impira/layoutlm-document-qa",
+		},
+		{
+			description: "A special model for OCR-free Document QA task. Donut model fine-tuned on DocVQA.",
+			id:          "naver-clova-ix/donut-base-finetuned-docvqa",
+		},
+	],
+	spaces:       [
+		{
+			description: "A robust document question answering application.",
+			id:          "impira/docquery",
+		},
+		{
+			description: "An application that can answer questions from invoices.",
+			id:          "impira/invoices",
+		},
+	],
+	summary:      "Document Question Answering (also known as Document Visual Question Answering) is the task of answering questions on document images. Document question answering models take a (document, question) pair as input and return an answer in natural language. Models usually rely on multi-modal features, combining text, position of words (bounding-boxes) and image.",
+	widgetModels: ["impira/layoutlm-document-qa"],
+	youtubeId:    "",
+};
+
+
+export default taskData;

package/src/feature-extraction/about.md

@@ -0,0 +1,35 @@
+## About the Task
+
+Feature extraction is the task of building features intended to be informative from a given dataset,
+facilitating the subsequent learning and generalization steps in various domains of machine learning.
+
+## Use Cases
+Feature extraction can be used to do transfer learning in natural language processing, computer vision and audio models.
+
+## Inference
+
+#### Feature Extraction
+
+```python
+from transformers import pipeline
+checkpoint = "facebook/bart-base"
+feature_extractor = pipeline("feature-extraction",framework="pt",model=checkpoint)
+text = "Transformers is an awesome library!"
+
+#Reducing along the first dimension to get a 768 dimensional array
+feature_extractor(text,return_tensors = "pt")[0].numpy().mean(axis=0) 
+
+'''tensor([[[ 2.5834,  2.7571,  0.9024,  ...,  1.5036, -0.0435, -0.8603],
+         [-1.2850, -1.0094, -2.0826,  ...,  1.5993, -0.9017,  0.6426],
+         [ 0.9082,  0.3896, -0.6843,  ...,  0.7061,  0.6517,  1.0550],
+         ...,
+         [ 0.6919, -1.1946,  0.2438,  ...,  1.3646, -1.8661, -0.1642],
+         [-0.1701, -2.0019, -0.4223,  ...,  0.3680, -1.9704, -0.0068],
+         [ 0.2520, -0.6869, -1.0582,  ...,  0.5198, -2.2106,  0.4547]]])'''
+```
+
+## Useful resources
+
+- [Documentation for feature extractor of 🤗Transformers](https://huggingface.co/docs/transformers/main_classes/feature_extractor)
+
+

package/src/feature-extraction/data.ts

@@ -0,0 +1,57 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "Wikipedia dataset containing cleaned articles of all languages. Can be used to train `feature-extraction` models.",
+			id:"wikipedia",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content:
+						"India, officially the Republic of India, is a country in South Asia.",
+				type: "text",
+			},
+
+		],
+		outputs: [
+			{	
+				table: [
+					["Dimension 1", "Dimension 2", "Dimension 3"],
+					["2.583383083343506", "2.757075071334839", "0.9023529887199402"],
+					["8.29393482208252", "1.1071064472198486", "2.03399395942688"],
+					["-0.7754912972450256", "-1.647324562072754", "-0.6113331913948059"],
+					["0.07087723910808563", "1.5942802429199219", "1.4610432386398315"],
+				
+				],
+				type: "tabular",
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id:          "",
+		},
+	],
+	models: [
+		{
+			description: "A powerful feature extraction model for natural language processing tasks.",
+			id:          "facebook/bart-base",
+		},
+		{
+			description: "A strong feature extraction model for coding tasks.",
+			id:          "microsoft/codebert-base",
+		},
+	],
+	spaces:       [
+
+	],
+	summary:      "Feature extraction refers to the process of transforming raw data into numerical features that can be processed while preserving the information in the original dataset.",
+	widgetModels: ["facebook/bart-base"],
+};
+
+export default taskData;

package/src/fill-mask/about.md

@@ -0,0 +1,51 @@
+## Use Cases
+
+### Domain Adaptation 👩‍⚕️
+
+Masked language models do not require labelled data! They are trained by masking a couple of words in sentences and the model is expected to guess the masked word. This makes it very practical!
+
+For example, masked language modeling is used to train large models for domain-specific problems. If you have to work on a domain-specific task, such as retrieving information from medical research papers, you can train a masked language model using those papers. 📄
+
+The resulting model has a statistical understanding of the language used in medical research papers, and can be further trained in a process called fine-tuning to solve different tasks, such as [Text Classification](/tasks/text-classification) or [Question Answering](/tasks/question-answering) to build a medical research papers information extraction system. 👩‍⚕️ Pre-training on domain-specific data tends to yield better results (see [this paper](https://arxiv.org/abs/2007.15779) for an example).
+
+If you don't have the data to train a masked language model, you can also use an existing [domain-specific masked language model](https://huggingface.co/microsoft/BiomedNLP-PubMedBERT-base-uncased-abstract-fulltext) from the Hub and fine-tune it with your smaller task dataset. That's the magic of Open Source and sharing your work! 🎉
+
+## Inference with Fill-Mask Pipeline
+
+You can use the 🤗 Transformers library `fill-mask` pipeline to do inference with masked language models. If a model name is not provided, the pipeline will be initialized with [distilroberta-base](/distilroberta-base). You can provide masked text and it will return a list of possible mask values ​​ranked according to the score.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("fill-mask")
+classifier("Paris is the <mask> of France.")
+
+# [{'score': 0.7, 'sequence': 'Paris is the capital of France.'},
+# {'score': 0.2, 'sequence': 'Paris is the birthplace of France.'},
+# {'score': 0.1, 'sequence': 'Paris is the heart of France.'}]
+```
+
+## Useful Resources
+
+Would you like to learn more about the topic? Awesome! Here you can find some curated resources that can be helpful to you!
+
+- [Course Chapter on Fine-tuning a Masked Language Model](https://huggingface.co/course/chapter7/3?fw=pt)
+- [Workshop on Pretraining Language Models and CodeParrot](https://www.youtube.com/watch?v=ExUR7w6xe94)
+- [BERT 101: State Of The Art NLP Model Explained](https://huggingface.co/blog/bert-101)
+- [Nyströmformer: Approximating self-attention in linear time and memory via the Nyström method](https://huggingface.co/blog/nystromformer)
+
+### Notebooks
+
+- [Pre-training an MLM for JAX/Flax](https://github.com/huggingface/notebooks/blob/master/examples/masked_language_modeling_flax.ipynb)
+- [Masked language modeling in TensorFlow](https://github.com/huggingface/notebooks/blob/master/examples/language_modeling-tf.ipynb)
+- [Masked language modeling in PyTorch](https://github.com/huggingface/notebooks/blob/master/examples/language_modeling.ipynb)
+
+### Scripts for training
+
+- [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling)
+- [Flax](https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling)
+- [TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling)
+
+### Documentation
+
+- [Masked language modeling task guide](https://huggingface.co/docs/transformers/tasks/masked_language_modeling)

package/src/fill-mask/data.ts

@@ -0,0 +1,77 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A common dataset that is used to train models for many languages.",
+			id:          "wikipedia",
+		},
+		{
+			description: "A large English dataset with text crawled from the web.",
+			id:          "c4",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				label:   "Input",
+				content: "The <mask> barked at me",
+				type:    "text",
+			},
+			
+		],
+		outputs: [
+			{
+				type: "chart",
+				data: [
+					{
+						label: "wolf",
+						score: 0.487,
+					},
+					{
+						label: "dog",
+						score: 0.061,
+					},
+					{
+						label: "cat",
+						score: 0.058,
+					},
+					{
+						label: "fox",
+						score: 0.047,
+					},
+					{
+						label: "squirrel",
+						score: 0.025,
+					},
+				],
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "Cross Entropy is a metric that calculates the difference between two probability distributions. Each probability distribution is the distribution of predicted words",
+			id:          "cross_entropy",
+		},
+		{
+			description: "Perplexity is the exponential of the cross-entropy loss. It evaluates the probabilities assigned to the next word by the model. Lower perplexity indicates better performance",
+			id:          "perplexity",
+		},
+	],
+	models: [
+		{
+			description: "A faster and smaller model than the famous BERT model.",
+			id:          "distilbert-base-uncased",
+		},
+		{
+			description: "A multilingual model trained on 100 languages.",
+			id:          "xlm-roberta-base",
+		},
+	],
+	spaces:       [],
+	summary:      "Masked language modeling is the task of masking some of the words in a sentence and predicting which words should replace those masks. These models are useful when we want to get a statistical understanding of the language in which the model is trained in.",
+	widgetModels: ["distilroberta-base"],
+	youtubeId:    "mqElG5QJWUg",
+};
+
+export default taskData;

package/src/image-classification/about.md

@@ -0,0 +1,48 @@
+## Use Cases
+Image classification models can be used when we are not interested in specific instances of objects with location information or their shape.
+
+### Keyword Classification
+Image classification models are used widely in stock photography to assign each image a keyword.
+
+### Image Search
+
+Models trained in image classification can improve user experience by organizing and categorizing photo galleries on the phone or in the cloud, on multiple keywords or tags.
+
+## Inference
+
+With the `transformers` library, you can use the `image-classification` pipeline to infer with image classification models. You can initialize the pipeline with a model id from the Hub. If you do not provide a model id it will initialize with [google/vit-base-patch16-224](https://huggingface.co/google/vit-base-patch16-224) by default. When calling the pipeline you just need to specify a path, http link or an image loaded in PIL. You can also provide a `top_k` parameter which determines how many results it should return.
+
+```python
+from transformers import pipeline
+clf = pipeline("image-classification")
+clf("path_to_a_cat_image")
+
+[{'label': 'tabby cat', 'score': 0.731},
+...
+]
+```
+
+You can use [huggingface.js](https://github.com/huggingface/huggingface.js) to classify images using models on Hugging Face Hub.
+
+```javascript
+import { HfInference } from "@huggingface/inference";
+
+const inference = new HfInference(HF_ACCESS_TOKEN);
+await inference.imageClassification({
+  data: await (await fetch('https://picsum.photos/300/300')).blob(),
+  model: 'microsoft/resnet-50',  
+})
+```
+
+## Useful Resources
+
+- [Let's Play Pictionary with Machine Learning!](https://www.youtube.com/watch?v=LS9Y2wDVI0k)
+- [Fine-Tune ViT for Image Classification with 🤗Transformers](https://huggingface.co/blog/fine-tune-vit)
+- [Walkthrough of Computer Vision Ecosystem in Hugging Face - CV Study Group](https://www.youtube.com/watch?v=oL-xmufhZM8)
+- [Computer Vision Study Group: Swin Transformer](https://www.youtube.com/watch?v=Ngikt-K1Ecc)
+- [Computer Vision Study Group: Masked Autoencoders Paper Walkthrough](https://www.youtube.com/watch?v=Ngikt-K1Ecc)
+- [Image classification task guide](https://huggingface.co/docs/transformers/tasks/image_classification)
+
+### Creating your own image classifier in just a few minutes
+
+With [HuggingPics](https://github.com/nateraw/huggingpics), you can fine-tune Vision Transformers for anything using images found on the web. This project downloads images of classes defined by you, trains a model, and pushes it to the Hub. You even get to try out the model directly with a working widget in the browser, ready to be shared with all your friends!

package/src/image-classification/data.ts

@@ -0,0 +1,88 @@
+import type { TaskDataCustom } from "../Types";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			// TODO write proper description
+			description: "Benchmark dataset used for image classification with images that belong to 100 classes.",
+			id:          "cifar100",
+		},
+		{
+			// TODO write proper description
+			description: "Dataset consisting of images of garments.",
+			id:          "fashion_mnist",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				filename: "image-classification-input.jpeg",
+				type:     "img",
+			},
+		],
+		outputs: [
+			{
+				type: "chart",
+				data: [
+					{
+						label: "Egyptian cat",
+						score: 0.514,
+					},
+					{
+						label: "Tabby cat",
+						score: 0.193,
+					},
+					{
+						label: "Tiger cat",
+						score: 0.068,
+					},
+				],
+			},
+		],
+	},
+	metrics: [
+		{
+			description: "",
+			id:          "accuracy",
+		},
+		{
+			description: "",
+			id:          "recall",
+		},
+		{
+			description: "",
+			id:          "precision",
+		},
+		{
+			description: "",
+			id:          "f1",
+		},
+
+	],
+	models: [
+		{
+			description: "A strong image classification model.",
+			id:          "google/vit-base-patch16-224",
+		},
+		{
+			description: "A robust image classification model.",
+			id:          "facebook/deit-base-distilled-patch16-224",
+		},
+		{
+			description: "A strong image classification model.",
+			id:          "facebook/convnext-large-224",
+		},
+	],
+	spaces:       [
+		{
+			// TO DO: write description
+			description: "An application that classifies what a given image is about.",
+			id:          "nielsr/perceiver-image-classification",
+		},
+	],
+	summary:      "Image classification is the task of assigning a label or class to an entire image. Images are expected to have only one class for each image. Image classification models take an image as input and return a prediction about which class the image belongs to.",
+	widgetModels: ["google/vit-base-patch16-224"],
+	youtubeId:    "tjAIM7BOYhw",
+};
+
+export default taskData;