@huggingface/tasks 0.13.1-test → 0.13.1-test2

package/src/tasks/image-segmentation/data.ts

@@ -0,0 +1,99 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "Scene segmentation dataset.",
+			id: "scene_parse_150",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				filename: "image-segmentation-input.jpeg",
+				type: "img",
+			},
+		],
+		outputs: [
+			{
+				filename: "image-segmentation-output.png",
+				type: "img",
+			},
+		],
+	},
+	metrics: [
+		{
+			description:
+				"Average Precision (AP) is the Area Under the PR Curve (AUC-PR). It is calculated for each semantic class separately",
+			id: "Average Precision",
+		},
+		{
+			description: "Mean Average Precision (mAP) is the overall average of the AP values",
+			id: "Mean Average Precision",
+		},
+		{
+			description:
+				"Intersection over Union (IoU) is the overlap of segmentation masks. Mean IoU is the average of the IoU of all semantic classes",
+			id: "Mean Intersection over Union",
+		},
+		{
+			description: "APα is the Average Precision at the IoU threshold of a α value, for example, AP50 and AP75",
+			id: "APα",
+		},
+	],
+	models: [
+		{
+			// TO DO: write description
+			description: "Solid semantic segmentation model trained on ADE20k.",
+			id: "openmmlab/upernet-convnext-small",
+		},
+		{
+			description: "Background removal model.",
+			id: "briaai/RMBG-1.4",
+		},
+		{
+			description: "A multipurpose image segmentation model for high resolution images.",
+			id: "ZhengPeng7/BiRefNet",
+		},
+		{
+			description: "Powerful human-centric image segmentation model.",
+			id: "facebook/sapiens-seg-1b",
+		},
+		{
+			description: "Panoptic segmentation model trained on the COCO (common objects) dataset.",
+			id: "facebook/mask2former-swin-large-coco-panoptic",
+		},
+	],
+	spaces: [
+		{
+			description: "A semantic segmentation application that can predict unseen instances out of the box.",
+			id: "facebook/ov-seg",
+		},
+		{
+			description: "One of the strongest segmentation applications.",
+			id: "jbrinkma/segment-anything",
+		},
+		{
+			description: "A human-centric segmentation model.",
+			id: "facebook/sapiens-pose",
+		},
+		{
+			description: "An instance segmentation application to predict neuronal cell types from microscopy images.",
+			id: "rashmi/sartorius-cell-instance-segmentation",
+		},
+		{
+			description: "An application that segments videos.",
+			id: "ArtGAN/Segment-Anything-Video",
+		},
+		{
+			description: "An panoptic segmentation application built for outdoor environments.",
+			id: "segments/panoptic-segment-anything",
+		},
+	],
+	summary:
+		"Image Segmentation divides an image into segments where each pixel in the image is mapped to an object. This task has multiple variants such as instance segmentation, panoptic segmentation and semantic segmentation.",
+	widgetModels: ["nvidia/segformer-b0-finetuned-ade-512-512"],
+	youtubeId: "dKE8SIt9C-w",
+};
+
+export default taskData;

package/src/tasks/image-segmentation/inference.ts

@@ -0,0 +1,69 @@
+/**
+ * Inference code generated from the JSON schema spec in ./spec
+ *
+ * Using src/scripts/inference-codegen
+ */
+/**
+ * Inputs for Image Segmentation inference
+ */
+export interface ImageSegmentationInput {
+	/**
+	 * The input image data as a base64-encoded string. If no `parameters` are provided, you can
+	 * also provide the image data as a raw bytes payload.
+	 */
+	inputs: string;
+	/**
+	 * Additional inference parameters
+	 */
+	parameters?: ImageSegmentationParameters;
+	[property: string]: unknown;
+}
+/**
+ * Additional inference parameters
+ *
+ * Additional inference parameters for Image Segmentation
+ */
+export interface ImageSegmentationParameters {
+	/**
+	 * Threshold to use when turning the predicted masks into binary values.
+	 */
+	mask_threshold?: number;
+	/**
+	 * Mask overlap threshold to eliminate small, disconnected segments.
+	 */
+	overlap_mask_area_threshold?: number;
+	/**
+	 * Segmentation task to be performed, depending on model capabilities.
+	 */
+	subtask?: ImageSegmentationSubtask;
+	/**
+	 * Probability threshold to filter out predicted masks.
+	 */
+	threshold?: number;
+	[property: string]: unknown;
+}
+/**
+ * Segmentation task to be performed, depending on model capabilities.
+ */
+export type ImageSegmentationSubtask = "instance" | "panoptic" | "semantic";
+export type ImageSegmentationOutput = ImageSegmentationOutputElement[];
+/**
+ * Outputs of inference for the Image Segmentation task
+ *
+ * A predicted mask / segment
+ */
+export interface ImageSegmentationOutputElement {
+	/**
+	 * The label of the predicted segment.
+	 */
+	label: string;
+	/**
+	 * The corresponding mask as a black-and-white image (base64-encoded).
+	 */
+	mask: string;
+	/**
+	 * The score or confidence degree the model has.
+	 */
+	score?: number;
+	[property: string]: unknown;
+}

package/src/tasks/image-segmentation/spec/input.json

@@ -0,0 +1,45 @@
+{
+	"$id": "/inference/schemas/image-segmentation/input.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Inputs for Image Segmentation inference",
+	"title": "ImageSegmentationInput",
+	"type": "object",
+	"properties": {
+		"inputs": {
+			"type": "string",
+			"description": "The input image data as a base64-encoded string. If no `parameters` are provided, you can also provide the image data as a raw bytes payload."
+		},
+		"parameters": {
+			"description": "Additional inference parameters",
+			"$ref": "#/$defs/ImageSegmentationParameters"
+		}
+	},
+	"$defs": {
+		"ImageSegmentationParameters": {
+			"title": "ImageSegmentationParameters",
+			"description": "Additional inference parameters for Image Segmentation",
+			"type": "object",
+			"properties": {
+				"mask_threshold": {
+					"type": "number",
+					"description": "Threshold to use when turning the predicted masks into binary values."
+				},
+				"overlap_mask_area_threshold": {
+					"type": "number",
+					"description": "Mask overlap threshold to eliminate small, disconnected segments."
+				},
+				"subtask": {
+					"title": "ImageSegmentationSubtask",
+					"type": "string",
+					"description": "Segmentation task to be performed, depending on model capabilities.",
+					"enum": ["instance", "panoptic", "semantic"]
+				},
+				"threshold": {
+					"type": "number",
+					"description": "Probability threshold to filter out predicted masks."
+				}
+			}
+		}
+	},
+	"required": ["inputs"]
+}

package/src/tasks/image-segmentation/spec/output.json

@@ -0,0 +1,26 @@
+{
+	"$id": "/inference/schemas/image-segmentation/output.json",
+	"$schema": "http://json-schema.org/draft-06/schema#",
+	"description": "Outputs of inference for the Image Segmentation task",
+	"title": "ImageSegmentationOutput",
+	"type": "array",
+	"items": {
+		"description": "A predicted mask / segment",
+		"type": "object",
+		"properties": {
+			"label": {
+				"type": "string",
+				"description": "The label of the predicted segment."
+			},
+			"mask": {
+				"type": "string",
+				"description": "The corresponding mask as a black-and-white image (base64-encoded)."
+			},
+			"score": {
+				"type": "number",
+				"description": "The score or confidence degree the model has."
+			}
+		},
+		"required": ["label", "mask"]
+	}
+}

package/src/tasks/image-text-to-text/about.md

@@ -0,0 +1,76 @@
+## Different Types of Vision Language Models
+
+Vision language models come in three types:
+
+- **Base:** Pre-trained models that can be fine-tuned. A good example of base models is the [PaliGemma models family](https://huggingface.co/models?sort=trending&search=google%2Fpaligemma-3b-pt) by Google.
+- **Instruction:** Base models fine-tuned on instruction datasets. A good example of instruction fine-tuned models is [idefics2-8b](https://huggingface.co/HuggingFaceM4/idefics2-8b).
+- **Chatty/Conversational:** Base models fine-tuned on conversation datasets. A good example of chatty models is [deepseek-vl-7b-chat](https://huggingface.co/deepseek-ai/deepseek-vl-7b-chat).
+
+![VLM uses](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/vlm/visual.jpg)
+
+## Use Cases
+
+### Multimodal Dialogue
+
+Vision language models can be used as multimodal assistants, keeping context about the conversation and keeping the image to have multiple-turn dialogues.
+
+### Zero-shot Object Detection, Image Segmentation and Localization
+
+Some vision language models can detect or segment a set of objects or describe the positions or relative positions of the objects. For example, one could prompt such a model to ask if one object is behind another. Such a model can also output bounding box coordination or segmentation masks directly in the text output, unlike the traditional models explicitly trained on only object detection or image segmentation.
+
+### Visual Question Answering
+
+Vision language models trained on image-text pairs can be used for visual question answering and generating captions for images.
+
+### Document Question Answering and Retrieval
+
+Documents often consist of different layouts, charts, tables, images, and more. Vision language models trained on formatted documents can extract information from them. This is an OCR-free approach; the inputs skip OCR, and documents are directly fed to vision language models.
+
+### Image Recognition with Instructions
+
+Vision language models can recognize images through descriptions. When given detailed descriptions of specific entities, it can classify the entities in an image.
+
+## Inference
+
+You can use the Transformers library to interact with vision-language models. You can load the model like below.
+
+```python
+from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
+import torch
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+processor = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")
+model = LlavaNextForConditionalGeneration.from_pretrained(
+    "llava-hf/llava-v1.6-mistral-7b-hf",
+    torch_dtype=torch.float16
+)
+model.to(device)
+```
+
+We can infer by passing image and text dialogues.
+
+```python
+from PIL import Image
+import requests
+
+# image of a radar chart
+url = "https://github.com/haotian-liu/LLaVA/blob/1a91fc274d7c35a9b50b3cb29c4247ae5837ce39/images/llava_v1_5_radar.jpg?raw=true"
+image = Image.open(requests.get(url, stream=True).raw)
+prompt = "[INST] <image>\nWhat is shown in this image? [/INST]"
+
+inputs = processor(prompt, image, return_tensors="pt").to(device)
+output = model.generate(**inputs, max_new_tokens=100)
+
+print(processor.decode(output[0], skip_special_tokens=True))
+# The image appears to be a radar chart, which is a type of multivariate chart that displays values for multiple variables represented on axes
+# starting from the same point. This particular radar chart is showing the performance of different models or systems across various metrics.
+# The axes represent different metrics or benchmarks, such as MM-Vet, MM-Vet, MM-Vet, MM-Vet, MM-Vet, MM-V
+```
+
+## Useful Resources
+
+- [Vision Language Models Explained](https://huggingface.co/blog/vlms)
+- [Open-source Multimodality and How to Achieve it using Hugging Face](https://www.youtube.com/watch?v=IoGaGfU1CIg&t=601s)
+- [Introducing Idefics2: A Powerful 8B Vision-Language Model for the community](https://huggingface.co/blog/idefics2)
+- [Image-text-to-text task guide](https://huggingface.co/tasks/image-text-to-text)
+- [Preference Optimization for Vision Language Models with TRL](https://huggingface.co/blog/dpo_vlm)

package/src/tasks/image-text-to-text/data.ts

@@ -0,0 +1,102 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "Instructions composed of image and text.",
+			id: "liuhaotian/LLaVA-Instruct-150K",
+		},
+		{
+			description: "Conversation turns where questions involve image and text.",
+			id: "liuhaotian/LLaVA-Pretrain",
+		},
+		{
+			description: "A collection of datasets made for model fine-tuning.",
+			id: "HuggingFaceM4/the_cauldron",
+		},
+		{
+			description: "Screenshots of websites with their HTML/CSS codes.",
+			id: "HuggingFaceM4/WebSight",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				filename: "image-text-to-text-input.png",
+				type: "img",
+			},
+			{
+				label: "Text Prompt",
+				content: "Describe the position of the bee in detail.",
+				type: "text",
+			},
+		],
+		outputs: [
+			{
+				label: "Answer",
+				content:
+					"The bee is sitting on a pink flower, surrounded by other flowers. The bee is positioned in the center of the flower, with its head and front legs sticking out.",
+				type: "text",
+			},
+		],
+	},
+	metrics: [],
+	models: [
+		{
+			description: "Powerful vision language model with great visual understanding and reasoning capabilities.",
+			id: "meta-llama/Llama-3.2-11B-Vision-Instruct",
+		},
+		{
+			description: "Cutting-edge vision language models.",
+			id: "allenai/Molmo-7B-D-0924",
+		},
+		{
+			description: "Small yet powerful model.",
+			id: "vikhyatk/moondream2",
+		},
+		{
+			description: "Strong image-text-to-text model.",
+			id: "Qwen/Qwen2-VL-7B-Instruct",
+		},
+		{
+			description: "Strong image-text-to-text model.",
+			id: "mistralai/Pixtral-12B-2409",
+		},
+		{
+			description: "Strong image-text-to-text model focused on documents.",
+			id: "stepfun-ai/GOT-OCR2_0",
+		},
+	],
+	spaces: [
+		{
+			description: "Leaderboard to evaluate vision language models.",
+			id: "opencompass/open_vlm_leaderboard",
+		},
+		{
+			description: "Vision language models arena, where models are ranked by votes of users.",
+			id: "WildVision/vision-arena",
+		},
+		{
+			description: "Powerful vision-language model assistant.",
+			id: "akhaliq/Molmo-7B-D-0924",
+		},
+		{
+			description: "An image-text-to-text application focused on documents.",
+			id: "stepfun-ai/GOT_official_online_demo",
+		},
+		{
+			description: "An application to compare outputs of different vision language models.",
+			id: "merve/compare_VLMs",
+		},
+		{
+			description: "An application for chatting with an image-text-to-text model.",
+			id: "GanymedeNil/Qwen2-VL-7B",
+		},
+	],
+	summary:
+		"Image-text-to-text models take in an image and text prompt and output text. These models are also called vision-language models, or VLMs. The difference from image-to-text models is that these models take an additional text input, not restricting the model to certain use cases like image captioning, and may also be trained to accept a conversation as input.",
+	widgetModels: ["meta-llama/Llama-3.2-11B-Vision-Instruct"],
+	youtubeId: "IoGaGfU1CIg",
+};
+
+export default taskData;

package/src/tasks/image-to-3d/about.md

@@ -0,0 +1,62 @@
+## Use Cases
+
+Image-to-3D models can be used in a wide variety of applications that require 3D, such as games, animation, design, architecture, engineering, marketing, and more.
+
+![Image-to-3D Thumbnail](https://huggingface.co/datasets/huggingfacejs/tasks/resolve/main/image-to-3d/image-to-3d-thumbnail.png)
+
+### Generating Meshes
+
+Meshes are the standard representation of 3D in industry.
+
+### Generating Gaussian Splats
+
+[Gaussian Splatting](https://huggingface.co/blog/gaussian-splatting) is a rendering technique that represents scenes as fuzzy points.
+
+### Inference
+
+Inference for this task typically leverages the [Diffusers](https://huggingface.co/docs/diffusers/index) library for inference, using [Custom Pipelines](https://huggingface.co/docs/diffusers/v0.6.0/en/using-diffusers/custom_pipelines).
+
+These are unstandardized and depend on the model. More details can be found in each model repository.
+
+```python
+import torch
+import requests
+import numpy as np
+from io import BytesIO
+from diffusers import DiffusionPipeline
+from PIL import Image
+
+pipeline = DiffusionPipeline.from_pretrained(
+    "dylanebert/LGM-full",
+    custom_pipeline="dylanebert/LGM-full",
+    torch_dtype=torch.float16,
+    trust_remote_code=True,
+).to("cuda")
+
+input_url = "https://huggingface.co/datasets/dylanebert/iso3d/resolve/main/jpg@512/a_cat_statue.jpg"
+input_image = Image.open(BytesIO(requests.get(input_url).content))
+input_image = np.array(input_image, dtype=np.float32) / 255.0
+result = pipeline("", input_image)
+result_path = "/tmp/output.ply"
+pipeline.save_ply(result, result_path)
+```
+
+In the code above, we:
+
+1. Import the necessary libraries
+2. Load the `LGM-full` model and custom pipeline
+3. Load and preprocess the input image
+4. Run the pipeline on the input image
+5. Save the output to a file
+
+### Output Formats
+
+Meshes can be in `.obj`, `.glb`, `.stl`, or `.gltf` format. Other formats are allowed, but won't be rendered in the gradio [Model3D](https://www.gradio.app/docs/gradio/model3d) component.
+
+Splats can be in `.ply` or `.splat` format. They can be rendered in the gradio [Model3D](https://www.gradio.app/docs/gradio/model3d) component using the [gsplat.js](https://github.com/huggingface/gsplat.js) library.
+
+## Useful Resources
+
+- [ML for 3D Course](https://huggingface.co/learn/ml-for-3d-course)
+- [3D Arena Leaderboard](https://huggingface.co/spaces/dylanebert/3d-arena)
+- [gsplat.js](https://github.com/huggingface/gsplat.js)

package/src/tasks/image-to-3d/data.ts

@@ -0,0 +1,75 @@
+import type { TaskDataCustom } from "../index.js";
+
+const taskData: TaskDataCustom = {
+	datasets: [
+		{
+			description: "A large dataset of over 10 million 3D objects.",
+			id: "allenai/objaverse-xl",
+		},
+		{
+			description: "A dataset of isolated object images for evaluating image-to-3D models.",
+			id: "dylanebert/iso3d",
+		},
+	],
+	demo: {
+		inputs: [
+			{
+				filename: "image-to-3d-image-input.png",
+				type: "img",
+			},
+		],
+		outputs: [
+			{
+				label: "Result",
+				content: "image-to-3d-3d-output-filename.glb",
+				type: "text",
+			},
+		],
+	},
+	metrics: [],
+	models: [
+		{
+			description: "Fast image-to-3D mesh model by Tencent.",
+			id: "TencentARC/InstantMesh",
+		},
+		{
+			description: "Fast image-to-3D mesh model by StabilityAI",
+			id: "stabilityai/TripoSR",
+		},
+		{
+			description: "A scaled up image-to-3D mesh model derived from TripoSR.",
+			id: "hwjiang/Real3D",
+		},
+		{
+			description: "Generative 3D gaussian splatting model.",
+			id: "ashawkey/LGM",
+		},
+	],
+	spaces: [
+		{
+			description: "Leaderboard to evaluate image-to-3D models.",
+			id: "dylanebert/3d-arena",
+		},
+		{
+			description: "Image-to-3D demo with mesh outputs.",
+			id: "TencentARC/InstantMesh",
+		},
+		{
+			description: "Image-to-3D demo with mesh outputs.",
+			id: "stabilityai/TripoSR",
+		},
+		{
+			description: "Image-to-3D demo with mesh outputs.",
+			id: "hwjiang/Real3D",
+		},
+		{
+			description: "Image-to-3D demo with splat outputs.",
+			id: "dylanebert/LGM-mini",
+		},
+	],
+	summary: "Image-to-3D models take in image input and produce 3D output.",
+	widgetModels: [],
+	youtubeId: "",
+};
+
+export default taskData;