# SAM

## Tổng quan

SAM (Segment Anything Model) được đề xuất trong [Segment Anything](https://huggingface.co/papers/2304.02643) bởi Alexander Kirillov, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead, Alex Berg, Wan-Yen Lo, Piotr Dollar, Ross Girshick.

Mô hình có thể được sử dụng để dự đoán mặt nạ phân đoạn của bất kỳ đối tượng nào được quan tâm khi có một hình ảnh đầu vào.

![example image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-output.png)

Tóm tắt từ bài báo như sau:

*Chúng tôi giới thiệu dự án Segment Anything (SA): một tác vụ, mô hình và bộ dữ liệu mới cho phân đoạn ảnh. Sử dụng mô hình hiệu quả của chúng tôi trong vòng lặp thu thập dữ liệu, chúng tôi đã xây dựng bộ dữ liệu phân đoạn lớn nhất cho đến nay (vượt trội hoàn toàn), với hơn 1 tỷ mask trên 11 triệu ảnh có giấy phép và tôn trọng quyền riêng tư. Mô hình được thiết kế và huấn luyện để có thể nhận prompt, nhờ đó có thể chuyển giao zero-shot sang các phân phối và tác vụ ảnh mới. Chúng tôi đánh giá khả năng của nó trên nhiều tác vụ và nhận thấy hiệu suất zero-shot của nó rất ấn tượng -- thường cạnh tranh hoặc thậm chí vượt trội so với các kết quả giám sát hoàn toàn trước đó. Chúng tôi phát hành Segment Anything Model (SAM) và bộ dữ liệu tương ứng (SA-1B) gồm 1 tỷ mask và 11 triệu ảnh tại [https://segment-anything.com](https://segment-anything.com) để thúc đẩy nghiên cứu về các mô hình nền tảng cho thị giác máy tính.*

Mẹo:

- Mô hình dự đoán các mặt nạ nhị phân (binary masks) cho biết sự hiện diện hay không của đối tượng quan tâm dựa trên một hình ảnh.
- Mô hình dự đoán kết quả tốt hơn nhiều nếu được cung cấp các điểm 2D đầu vào và/hoặc các hộp bao đầu vào
- Bạn có thể nhập nhiều điểm cho cùng một hình ảnh và dự đoán một mặt nạ duy nhất.
- Việc tinh chỉnh mô hình hiện chưa được hỗ trợ
- Theo bài báo, đầu vào văn bản cũng nên được hỗ trợ. Tuy nhiên, tại thời điểm viết bài này, điều này dường như chưa được hỗ trợ theo [bản chính thức của kho lưu trữ](https://github.com/facebookresearch/segment-anything/issues/4#issuecomment-1497626844).

Mô hình này được đóng góp bởi [ybelkada](https://huggingface.co/ybelkada) và [ArthurZ](https://huggingface.co/ArthurZ). Mã gốc có thể được tìm thấy [tại đây](https://github.com/facebookresearch/segment-anything).

Dưới đây là một ví dụ về cách chạy tạo mask khi có một hình ảnh và một điểm 2D:

```python
import requests
import torch
from PIL import Image

from transformers import SamModel, SamProcessor

model = SamModel.from_pretrained("facebook/sam-vit-huge", device_map="auto")
processor = SamProcessor.from_pretrained("facebook/sam-vit-huge")

img_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
input_points = [[[450, 600]]]  # 2D location of a window in the image

inputs = processor(raw_image, input_points=input_points, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model(**inputs)

masks = processor.image_processor.post_process_masks(
    outputs.pred_masks.cpu(), inputs["original_sizes"].cpu(), inputs["reshaped_input_sizes"].cpu()
)
scores = outputs.iou_scores
```

Bạn cũng có thể xử lý các mask của riêng mình cùng với các ảnh đầu vào trong processor để truyền vào model.

```python
import requests
import torch
from PIL import Image

from transformers import SamModel, SamProcessor

model = SamModel.from_pretrained("facebook/sam-vit-huge", device_map="auto")
processor = SamProcessor.from_pretrained("facebook/sam-vit-huge")

img_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
mask_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
segmentation_map = Image.open(requests.get(mask_url, stream=True).raw).convert("1")
input_points = [[[450, 600]]]  # 2D location of a window in the image

inputs = processor(raw_image, input_points=input_points, segmentation_maps=segmentation_map, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model(**inputs)

masks = processor.image_processor.post_process_masks(
    outputs.pred_masks.cpu(), inputs["original_sizes"].cpu(), inputs["reshaped_input_sizes"].cpu()
)
scores = outputs.iou_scores
```

## Tài nguyên

Danh sách các tài nguyên chính thức của Hugging Face và cộng đồng (được đánh dấu bằng 🌎) để giúp bạn bắt đầu với SAM.

- [Sổ ghi chú demo](https://github.com/huggingface/notebooks/blob/main/examples/segment_anything.ipynb) để sử dụng mô hình.
- [Sổ ghi chú demo](https://github.com/huggingface/notebooks/blob/main/examples/automatic_mask_generation.ipynb) cho việc sử dụng đường ống tạo mặt nạ tự động.
- [Sổ ghi chú demo](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/SAM/Run_inference_with_MedSAM_using_HuggingFace_Transformers.ipynb) cho suy luận với MedSAM, một phiên bản tinh chỉnh của SAM trên lĩnh vực y tế. 🌎
- [Sổ ghi chú demo](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/SAM/Fine_tune_SAM_(segment_anything)_on_a_custom_dataset.ipynb) để tinh chỉnh mô hình trên dữ liệu tùy chỉnh. 🌎

## SlimSAM

SlimSAM, một phiên bản đã được cắt tỉa của SAM, được đề xuất trong [0.1% Data Makes Segment Anything Slim](https://huggingface.co/papers/2312.05284) bởi Zigeng Chen và cộng sự. SlimSAM giảm đáng kể kích thước của các mô hình SAM trong khi vẫn duy trì hiệu suất tương đương.

Các checkpoint có thể được tìm thấy trên [hub](https://huggingface.co/models?other=slimsam), và chúng có thể được sử dụng như một giải pháp thay thế trực tiếp cho SAM.

## Grounded SAM

Bạn có thể kết hợp [Grounding DINO](grounding-dino) với SAM để tạo mask dựa trên văn bản như đã giới thiệu trong [Grounded SAM: Assembling Open-World Models for Diverse Visual Tasks](https://huggingface.co/papers/2401.14159). Bạn có thể tham khảo [notebook demo](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Grounding%20DINO/GroundingDINO_with_Segment_Anything.ipynb) này 🌍 để biết thêm chi tiết.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/grounded_sam.png"
alt="drawing" width="900"/>

 Tổng quan về Grounded SAM. Được trích từ kho lưu trữ gốc.

## SamConfig[[transformers.SamConfig]]

#### transformers.SamConfig[[transformers.SamConfig]]

```python
transformers.SamConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02, tie_word_embeddings: bool = True)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/configuration_sam.py#L146)

**Tham số:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *tùy chọn*) : Đối tượng config hoặc từ điển của vision backbone.

prompt_encoder_config (Union[`dict`, `SamPromptEncoderConfig`], *optional*) : Từ điển các tùy chọn cấu hình được sử dụng để khởi tạo [SamPromptEncoderConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `SamMaskDecoderConfig`], *optional*) : Từ điển các tùy chọn cấu hình được sử dụng để khởi tạo [SamMaskDecoderConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamMaskDecoderConfig).

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `True`) : Có nên gắn kết các nhúng trọng số theo ánh xạ `tied_weights_keys` của mô hình hay không.

Đây là lớp cấu hình để lưu trữ cấu hình của một SamModel. Nó được sử dụng để khởi tạo một mô hình Sam theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như của [facebook/sam-vit-huge](https://huggingface.co/facebook/sam-vit-huge)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import (
...     SamVisionConfig,
...     SamPromptEncoderConfig,
...     SamMaskDecoderConfig,
...     SamModel,
... )

>>> # Initializing a SamConfig with `"facebook/sam-vit-huge"` style configuration
>>> configuration = SamConfig()

>>> # Initializing a SamModel (with random weights) from the `"facebook/sam-vit-huge"` style configuration
>>> model = SamModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a SamConfig from a SamVisionConfig, SamPromptEncoderConfig, and SamMaskDecoderConfig

>>> # Initializing SAM vision, SAM Q-Former and language model configurations
>>> vision_config = SamVisionConfig()
>>> prompt_encoder_config = SamPromptEncoderConfig()
>>> mask_decoder_config = SamMaskDecoderConfig()

>>> config = SamConfig(vision_config, prompt_encoder_config, mask_decoder_config)
```

## SamVisionConfig[[transformers.SamVisionConfig]]

#### transformers.SamVisionConfig[[transformers.SamVisionConfig]]

```python
transformers.SamVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, output_channels: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True, mlp_ratio: float = 4.0, use_abs_pos: bool = True, use_rel_pos: bool = True, window_size: int = 14, global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11), num_pos_feats: int = 128, mlp_dim: int | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/configuration_sam.py#L81)

**Tham số:**

hidden_size (`int`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn.

output_channels (`int`, *tuỳ chọn*, mặc định là 256) : Độ chiều của các kênh đầu ra trong Patch Encoder.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

num_channels (`int`, *tuỳ chọn*, mặc định là `3`) : Số lượng kênh đầu vào.

image_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `1024`) : Kích thước (độ phân giải) của mỗi hình ảnh.

patch_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `16`) : Kích thước (độ phân giải) của mỗi patch.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

initializer_range (`float`, *optional*, mặc định là `1e-10`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

qkv_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm bias vào queries, keys và values hay không.

mlp_ratio (`float`, *tuỳ chọn*, mặc định là `4.0`) : Tỷ lệ giữa chiều ẩn của MLP và chiều nhúng.

use_abs_pos (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng nhúng vị trí tuyệt đối hay không.

use_rel_pos (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng nhúng vị trí tương đối hay không.

window_size (`int`, *tuỳ chọn*, mặc định là 14) : Kích thước cửa sổ cho vị trí tương đối.

global_attn_indexes (`list[int]`, *tuỳ chọn*, mặc định là `[2, 5, 8, 11]`) : Các chỉ số của các lớp chú ý toàn cục.

num_pos_feats (`int`, *tuỳ chọn*, mặc định là 128) : Độ cao của embedding vị trí.

mlp_dim (`int`, *optional*) : Độ cao của lớp MLP trong bộ mã hóa Transformer. Nếu là `None`, mặc định là `mlp_ratio * hidden_size`.

Đây là lớp cấu hình để lưu trữ cấu hình của một SamModel. Nó được sử dụng để khởi tạo một mô hình Sam theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như của [facebook/sam-vit-huge](https://huggingface.co/facebook/sam-vit-huge)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import (
...     SamVisionConfig,
...     SamVisionModel,
... )

>>> # Initializing a SamVisionConfig with `"facebook/sam-vit-huge"` style configuration
>>> configuration = SamVisionConfig()

>>> # Initializing a SamVisionModel (with random weights) from the `"facebook/sam-vit-huge"` style configuration
>>> model = SamVisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## SamMaskDecoderConfig[[transformers.SamMaskDecoderConfig]]

#### transformers.SamMaskDecoderConfig[[transformers.SamMaskDecoderConfig]]

```python
transformers.SamMaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, hidden_act: str = 'relu', mlp_dim: int = 2048, num_hidden_layers: int = 2, num_attention_heads: int = 8, attention_downsample_rate: int = 2, num_multimask_outputs: int = 3, iou_head_depth: int = 3, iou_head_hidden_dim: int = 256, layer_norm_eps: float = 1e-06)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/configuration_sam.py#L50)

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `256`) : Kích thước của các biểu diễn ẩn.

hidden_act (`str`, *tùy chọn*, mặc định là `relu`) : Hàm kích hoạt phi tuyến tính (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

mlp_dim (`int`, *tuỳ chọn*, mặc định là 2048) : Độ chiều của lớp "trung gian" (tức là lớp feed-forward) trong bộ mã hóa Transformer.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `2`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `8`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

attention_downsample_rate (`int`, *tuỳ chọn*, mặc định là 2) : Tỷ lệ hạ mẫu của lớp chú ý.

num_multimask_outputs (`int`, *tuỳ chọn*, mặc định là 3) : Số lượng đầu ra từ module `SamMaskDecoder`. Trong bài báo Segment Anything, giá trị này được đặt là 3.

iou_head_depth (`int`, *tuỳ chọn*, mặc định là 3) : Số lượng lớp trong module đầu ra IoU.

iou_head_hidden_dim (`int`, *optional*, mặc định là 256) : Độ chiều của các trạng thái ẩn trong module đầu IoU.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

Đây là lớp cấu hình để lưu trữ cấu hình của một SamModel. Nó được sử dụng để khởi tạo một mô hình Sam theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như của [facebook/sam-vit-huge](https://huggingface.co/facebook/sam-vit-huge)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

## SamPromptEncoderConfig[[transformers.SamPromptEncoderConfig]]

#### transformers.SamPromptEncoderConfig[[transformers.SamPromptEncoderConfig]]

```python
transformers.SamPromptEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, mask_input_channels: int = 16, num_point_embeddings: int = 4, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/configuration_sam.py#L24)

**Tham số:**

hidden_size (`int`, *tuỳ chọn*, mặc định là `256`) : Kích thước của các biểu diễn ẩn.

image_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `1024`) : Kích thước (độ phân giải) của mỗi hình ảnh.

patch_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `16`) : Kích thước (độ phân giải) của mỗi patch.

mask_input_channels (`int`, *tuỳ chọn*, mặc định là 16) : Số lượng kênh được đưa vào module `MaskDecoder`.

num_point_embeddings (`int`, *tuỳ chọn*, mặc định là 4) : Số lượng point embeddings sẽ được sử dụng.

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

Đây là lớp cấu hình để lưu trữ cấu hình của một SamModel. Nó được sử dụng để khởi tạo một mô hình Sam theo các đối số được chỉ định, xác định kiến trúc mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như của [facebook/sam-vit-huge](https://huggingface.co/facebook/sam-vit-huge)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

## SamProcessor[[transformers.SamProcessor]]

#### transformers.SamProcessor[[transformers.SamProcessor]]

```python
transformers.SamProcessor(image_processor)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/processing_sam.py#L82)

**Tham số:**

image_processor (`SamImageProcessor`) : Bộ xử lý ảnh là một đầu vào bắt buộc.

Tạo một SamProcessor đóng gói một bộ xử lý ảnh thành một bộ xử lý duy nhất.

[SamProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamProcessor) cung cấp đầy đủ các chức năng của [SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor). Xem [~SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor) để biết thêm thông tin.

#### __call__[[transformers.SamProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/processing_sam.py#L87)

**Tham số:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *tùy chọn*) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh với giá trị pixel dao động từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel nằm trong khoảng từ 0 đến 1, hãy đặt `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *tùy chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu bạn truyền vào đầu vào đã tách token trước, hãy đặt `is_split_into_words=True` để tránh nhầm lẫn với các đầu vào dạng lô.

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

**Trả về:** `~tokenization_utils_base.BatchEncoding`

- **data** (`dict`, *tuỳ chọn*) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi các phương thức `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', v.v.).
- **encoding** (`tokenizers.Encoding` hoặc `Sequence[tokenizers.Encoding]`, *tùy chọn*) -- Nếu tokenizer là fast tokenizer có xuất ra thêm thông tin như ánh xạ từ không gian từ/ký tự sang không gian token thì instance `tokenizers.Encoding` hoặc danh sách các instance (cho các batch) sẽ chứa thông tin này.
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo.
- **prepend_batch_axis** (`bool`, *tùy chọn*, mặc định là `False`) -- Có thêm một trục batch khi chuyển đổi sang tensor hay không (xem `tensor_type` ở trên). Lưu ý rằng tham số này có hiệu lực nếu tham số `tensor_type` được đặt, *ngược lại thì không có hiệu lực*.
- **n_sequences** (`int`, *tùy chọn*) -- Số lượng chuỗi đầu vào được biểu diễn bởi mỗi mã hóa (`None` cho trường hợp không xác định, `1` cho một chuỗi đơn và `2` cho một cặp chuỗi).

## SamImageProcessor[[transformers.SamImageProcessor]]

#### transformers.SamImageProcessor[[transformers.SamImageProcessor]]

```python
transformers.SamImageProcessor(**kwargs: *<class 'transformers.models.sam.image_processing_sam.SamImageProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/image_processing_sam.py#L61)

**Tham số:**

do_convert_rgb (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'longest_edge' : 1024}`): Mô tả kích thước đầu vào tối đa cho mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có nên mặc định sử dụng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, mặc định là `2`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có nên điều chỉnh lại tỷ lệ ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*, mặc định là `0.00392156862745098`) : Hệ số để điều chỉnh lại kích thước ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.485, 0.456, 0.406]`) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.229, 0.224, 0.225]`) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_pad (`bool`, *kwargs*, *optional*, mặc định là `True`) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến kích thước vuông cố định cho từng ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 1024, 'width': 1024}`): Kích thước theo `{"height": int, "width" int}` để đệm cho các hình ảnh. Phải lớn hơn kích thước bất kỳ hình ảnh nào được cung cấp để tiền xử lý. Nếu `pad_size` không được cung cấp, các hình ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong lô. Chỉ được áp dụng khi `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.

disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.

mask_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"longest_edge": int}` để thay đổi kích thước các bản đồ phân đoạn.

mask_pad_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"height": int, "width": int}` để đệm các bản đồ phân đoạn. Phải lớn hơn kích thước của bất kỳ bản đồ phân đoạn nào được cung cấp cho tiền xử lý.

Tạo bộ xử lý ảnh SamImageProcessor.

#### preprocess[[transformers.SamImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.sam.image_processing_sam.SamImageProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/image_processing_sam.py#L79)

**Tham số:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh có giá trị pixel từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.

segmentation_maps (`ImageInput`, *tùy chọn*) : Các bản đồ phân đoạn cần tiền xử lý.

do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *optional*) : Xác định có nên thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*): Mô tả các kích thước đầu vào tối đa của mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*) : Có mặc định dùng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Bộ lọc resampling để sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các enum `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có nên điều chỉnh lại tỷ lệ hình ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*) : Hệ số để thay đổi tỷ lệ ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.

disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.

mask_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"longest_edge": int}` để thay đổi kích thước các bản đồ phân đoạn.

mask_pad_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"height": int, "width": int}` để đệm các bản đồ phân đoạn. Phải lớn hơn kích thước của bất kỳ bản đồ phân đoạn nào được cung cấp cho tiền xử lý.

**Trả về:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi phương thức __call__ ('pixel_values', v.v.).
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo.

## SamImageProcessorPil[[transformers.SamImageProcessorPil]]

#### transformers.SamImageProcessorPil[[transformers.SamImageProcessorPil]]

```python
transformers.SamImageProcessorPil(**kwargs: *<class 'transformers.models.sam.image_processing_pil_sam.SamImageProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/image_processing_pil_sam.py#L82)

**Tham số:**

do_convert_rgb (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'longest_edge' : 1024}`): Mô tả kích thước đầu vào tối đa cho mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có nên mặc định sử dụng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, mặc định là `2`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có nên điều chỉnh lại tỷ lệ ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*, mặc định là `0.00392156862745098`) : Hệ số để điều chỉnh lại kích thước ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.485, 0.456, 0.406]`) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.229, 0.224, 0.225]`) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_pad (`bool`, *kwargs*, *optional*, mặc định là `True`) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến kích thước vuông cố định cho từng ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `{'height' : 1024, 'width': 1024}`): Kích thước theo `{"height": int, "width" int}` để đệm cho các hình ảnh. Phải lớn hơn kích thước bất kỳ hình ảnh nào được cung cấp để tiền xử lý. Nếu `pad_size` không được cung cấp, các hình ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong lô. Chỉ được áp dụng khi `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.

disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.

mask_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"longest_edge": int}` để thay đổi kích thước các bản đồ phân đoạn.

mask_pad_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"height": int, "width": int}` để đệm các bản đồ phân đoạn. Phải lớn hơn kích thước của bất kỳ bản đồ phân đoạn nào được cung cấp cho tiền xử lý.

Tạo bộ xử lý ảnh SamImageProcessor.

#### preprocess[[transformers.SamImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.sam.image_processing_pil_sam.SamImageProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/image_processing_pil_sam.py#L100)

**Tham số:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh có giá trị pixel từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.

segmentation_maps (`ImageInput`, *tùy chọn*) : Các bản đồ phân đoạn cần tiền xử lý.

do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *optional*) : Xác định có nên thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*): Mô tả các kích thước đầu vào tối đa của mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*) : Có mặc định dùng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Bộ lọc resampling để sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các enum `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có nên điều chỉnh lại tỷ lệ hình ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*) : Hệ số để thay đổi tỷ lệ ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước ở dạng `{"height": int, "width" int}` để đệm (pad) các ảnh. Phải lớn hơn kích thước của bất kỳ ảnh nào được cung cấp cho tiền xử lý. Nếu `pad_size` không được cung cấp, các ảnh sẽ được đệm đến chiều cao và chiều rộng lớn nhất trong batch. Chỉ được áp dụng khi `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.

disable_grouping (`bool`, *kwargs*, *optional*) : Xác định có vô hiệu hóa việc nhóm các hình ảnh theo kích thước để xử lý chúng riêng lẻ thay vì theo lô hay không. Nếu là None, giá trị sẽ được đặt thành True nếu các hình ảnh nằm trên CPU, và False trong các trường hợp khác. Lựa chọn này dựa trên các quan sát thực nghiệm, chi tiết tại đây: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *tuỳ chọn*) : Số lượng token hình ảnh sẽ được sử dụng cho mỗi hình ảnh trong đầu vào. Được thêm vào để đảm bảo tương thích ngược, nhưng trong các mô hình tương lai, giá trị này nên được đặt như một thuộc tính của bộ xử lý.

mask_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"longest_edge": int}` để thay đổi kích thước các bản đồ phân đoạn.

mask_pad_size (`dict[str, *kwargs*, int]`, *tùy chọn*) : Kích thước `{"height": int, "width": int}` để đệm các bản đồ phân đoạn. Phải lớn hơn kích thước của bất kỳ bản đồ phân đoạn nào được cung cấp cho tiền xử lý.

**Trả về:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi phương thức __call__ ('pixel_values', v.v.).
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo.

## SamVisionModel[[transformers.SamVisionModel]]

#### transformers.SamVisionModel[[transformers.SamVisionModel]]

```python
transformers.SamVisionModel(config: SamVisionConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/modeling_sam.py#L1081)

**Tham số:**

config ([SamVisionConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamVisionConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình thị giác từ Sam không có bất kỳ đầu hay phép chiếu nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.SamVisionModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/modeling_sam.py#L1093)

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng [SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor). Xem [SamImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([SamProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamProcessor) sử dụng [SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor) để xử lý ảnh).

**Trả về:** `SamVisionEncoderOutput` hoặc `tuple(torch.Tensor)`

Một `SamVisionEncoderOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([SamConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamConfig)) và đầu vào.

Phương thức forward của [SamVisionModel](/docs/transformers/main/vi/model_doc/sam#transformers.SamVisionModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **image_embeds** (`torch.Tensor` có shape `(batch_size, output_dim)` *tuỳ chọn*, được trả về khi model được khởi tạo với `with_projection=True`) -- Các embedding của ảnh thu được bằng cách áp dụng lớp projection lên pooler_output.
- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## SamModel[[transformers.SamModel]]

#### transformers.SamModel[[transformers.SamModel]]

```python
transformers.SamModel(config: SamConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/modeling_sam.py#L1108)

**Tham số:**

config ([SamConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Segment Anything (SAM) để tạo các mặt nạ phân đoạn, dựa trên ảnh đầu vào cùng các điểm và nhãn đầu vào, hộp hoặc mặt nạ.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### forward[[transformers.SamModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, input_points: typing.Optional[torch.Tensor] = None, input_labels: typing.Optional[torch.LongTensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_masks: typing.Optional[torch.LongTensor] = None, image_embeddings: typing.Optional[torch.Tensor] = None, multimask_output: bool = True, attention_similarity: typing.Optional[torch.Tensor] = None, target_embedding: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam/modeling_sam.py#L1191)

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng [SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor). Xem [SamImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([SamProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamProcessor) sử dụng [SamImageProcessor](/docs/transformers/main/vi/model_doc/sam#transformers.SamImageProcessor) để xử lý ảnh).

input_points (`torch.Tensor` có shape `(batch_size, num_points, 2)`) : Các điểm không gian 2D đầu vào, được prompt encoder sử dụng để mã hóa prompt. Thông thường cho kết quả tốt hơn đáng kể. Các điểm này có thể được tạo ra bằng cách truyền một danh sách các danh sách con vào processor, processor sẽ tạo ra các tensor `torch` tương ứng có 4 chiều. Chiều đầu tiên là kích thước batch của ảnh, chiều thứ hai là kích thước batch của điểm (tức là số lượng mask phân đoạn mà chúng ta muốn mô hình dự đoán cho mỗi điểm đầu vào), chiều thứ ba là số điểm cho mỗi mask phân đoạn (có thể truyền nhiều điểm cho một mask duy nhất), và chiều cuối cùng là tọa độ x (dọc) và y (ngang) của điểm. Nếu số lượng điểm được truyền khác nhau cho mỗi ảnh, hoặc cho mỗi mask, processor sẽ tạo ra các điểm "PAD" tương ứng với tọa độ (0, 0), và việc tính toán embedding sẽ bị bỏ qua cho các điểm này bằng cách sử dụng labels.

input_labels (`torch.LongTensor` có shape `(batch_size, point_batch_size, num_points)`) : Nhãn đầu vào cho các điểm, được prompt encoder sử dụng để mã hóa prompt. Theo cài đặt chính thức, có 3 loại nhãn - `1`: điểm chứa đối tượng quan tâm - `0`: điểm không chứa đối tượng quan tâm - `-1`: điểm tương ứng với nền  Chúng tôi đã thêm nhãn: - `-10`: điểm là điểm đệm, do đó nên được prompt encoder bỏ qua  Việc gán nhãn đệm nên được thực hiện tự động bởi processor.

input_boxes (`torch.Tensor` có shape `(batch_size, num_boxes, 4)`) : Các hộp đầu vào cho các điểm, được prompt encoder sử dụng để mã hóa prompt. Nhìn chung, cách này tạo ra các mask tốt hơn đáng kể. Các hộp có thể được lấy bằng cách truyền một danh sách các danh sách con vào processor, từ đó tạo ra một tensor `torch`, trong đó mỗi chiều lần lượt tương ứng với kích thước batch của ảnh, số lượng hộp trên mỗi ảnh và tọa độ của điểm góc trên bên trái và điểm góc dưới bên phải của hộp. Theo thứ tự (`x1`, `y1`, `x2`, `y2`):  - `x1`: tọa độ x của điểm góc trên bên trái của hộp đầu vào - `y1`: tọa độ y của điểm góc trên bên trái của hộp đầu vào - `x2`: tọa độ x của điểm góc dưới bên phải của hộp đầu vào - `y2`: tọa độ y của điểm góc dưới bên phải của hộp đầu vào

input_masks (`torch.Tensor` có shape `(batch_size, image_size, image_size)`) : Mô hình SAM cũng chấp nhận các segmentation mask làm đầu vào. Mask sẽ được nhúng bởi prompt encoder để tạo ra một embedding tương ứng, sau đó được đưa vào mask decoder. Những mask này cần được người dùng cung cấp thủ công và phải có shape (`batch_size`, `image_size`, `image_size`).

image_embeddings (`torch.Tensor` có shape `(batch_size, output_channels, window_size, window_size)`) : Image embeddings, được mask decder sử dụng để tạo ra masks và iou scores. Để tính toán hiệu quả bộ nhớ hơn, người dùng có thể lấy trước image embeddings bằng phương thức `get_image_embeddings`, sau đó truyền chúng vào phương thức `forward` thay vì truyền `pixel_values`.

multimask_output (`bool`, *tùy chọn*) : Trong bản triển khai và bài báo gốc, mô hình luôn xuất ra 3 mặt nạ cho mỗi ảnh (hoặc cho mỗi điểm / mỗi hộp bao nếu liên quan). Tuy nhiên, có thể chỉ xuất ra một mặt nạ duy nhất, tương ứng với mặt nạ "tốt nhất", bằng cách chỉ định `multimask_output=False`.

attention_similarity (`torch.Tensor`, *tùy chọn*) : Tensor tương đồng chú ý, được cung cấp cho bộ giải mã mặt nạ để chú ý có định hướng mục tiêu trong trường hợp mô hình được sử dụng cho cá nhân hóa như đã giới thiệu trong [PerSAM](https://huggingface.co/papers/2305.03048).

target_embedding (`torch.Tensor`, *tùy chọn*) : Embedding của khái niệm đích, được cung cấp cho mask decoder để thực hiện target-semantic prompting trong trường hợp mô hình được sử dụng cho cá nhân hóa như đã giới thiệu trong [PerSAM](https://huggingface.co/papers/2305.03048).

**Trả về:** `SamImageSegmentationOutput` hoặc `tuple(torch.Tensor)`

Một `SamImageSegmentationOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([SamConfig](/docs/transformers/main/vi/model_doc/sam#transformers.SamConfig)) và đầu vào.

Phương thức forward của [SamModel](/docs/transformers/main/vi/model_doc/sam#transformers.SamModel) ghi đè phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **iou_scores** (`torch.Tensor` có shape `(batch_size, num_masks)`) -- Điểm iou của các mask dự đoán.
- **pred_masks** (`torch.Tensor` có hình dạng `(batch_size, num_masks, height, width)`) -- Các mặt nạ độ phân giải thấp được dự đoán. Cần được xử lý hậu kỳ bởi bộ xử lý
- **vision_hidden_states** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_hidden_states=True` hoặc khi `config.output_hidden_states=True`) -- Tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình thị giác tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **vision_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi truyền `output_attentions=True` hoặc khi `config.output_attentions=True`) -- Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **mask_decoder_attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi truyền `output_attentions=True` hoặc khi `config.output_attentions=True`) -- Tuple của `torch.Tensor` (một cho mỗi lớp) có shape `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

Ví dụ:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor

>>> model = AutoModel.from_pretrained("facebook/sam-vit-base")
>>> processor = AutoProcessor.from_pretrained("facebook/sam-vit-base")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     raw_image = Image.open(BytesIO(response.read())).convert("RGB")
>>> input_points = [[[400, 650]]]  # 2D location of a window on the car
>>> inputs = processor(images=raw_image, input_points=input_points, return_tensors="pt")

>>> # Get segmentation mask
>>> outputs = model(**inputs)

>>> # Postprocess masks
>>> masks = processor.post_process_masks(
...     outputs.pred_masks, inputs["original_sizes"], inputs["reshaped_input_sizes"]
... )
```