# ShieldGemma 2

## Tổng quan

Mô hình ShieldGemma 2 được đề xuất trong một [báo cáo kỹ thuật](https://huggingface.co/papers/2504.01081) của Google. ShieldGemma 2, được xây dựng dựa trên [Gemma 3](https://ai.google.dev/gemma/docs/core/model_card_3), là một mô hình có 4 tỷ (4B) tham số, kiểm tra mức độ an toàn của cả hình ảnh tổng hợp và hình ảnh tự nhiên đối với các danh mục chính, giúp bạn xây dựng các bộ dữ liệu và mô hình vững chắc. Với sự bổ sung này vào gia đình các mô hình Gemma, các nhà nghiên cứu và nhà phát triển giờ đây có thể dễ dàng giảm thiểu rủi ro về nội dung gây hại trong các mô hình của họ trên các lĩnh vực gây hại chính được định nghĩa bên dưới:

- Không có nội dung khiêu dâm: Hình ảnh không được chứa nội dung mô tả các hành vi tình dục rõ ràng hoặc mô tả chi tiết (ví dụ: khiêu dâm, khỏa thân khiêu dâm, mô tả về cưỡng hiếp hoặc tấn công tình dục).
- Không có nội dung nguy hiểm: Hình ảnh không được chứa nội dung tạo điều kiện hoặc khuyến khích các hoạt động có thể gây ra thiệt hại trong thế giới thực (ví dụ: chế tạo súng và thiết bị nổ, cổ xúy cho chủ nghĩa khủng bố, hướng dẫn tự tử).
- Không có nội dung bạo lực/máu me: Hình ảnh không được chứa nội dung mô tả bạo lực gây sốc, giật gân hoặc vô cớ (ví dụ: máu me và thương tích quá mức, bạo lực vô cớ đối với động vật, chấn thương cực độ hoặc khoảnh khắc tử vong).

Chúng tôi khuyến nghị sử dụng ShieldGemma 2 như một bộ lọc đầu vào cho các mô hình ngôn ngữ thị giác, hoặc như một bộ lọc đầu ra của các hệ thống tạo ảnh. Để huấn luyện một mô hình an toàn hình ảnh vững chắc, chúng tôi đã tuyển chọn các bộ dữ liệu huấn luyện gồm ảnh tự nhiên và ảnh tổng hợp, sau đó điều chỉnh theo hướng dẫn (instruction-tune) Gemma 3 để chứng minh hiệu suất vượt trội.

Mô hình này được đóng góp bởi [Ryan Mullins](https://huggingface.co/RyanMullins).

## Ví dụ sử dụng

- ShieldGemma 2 cung cấp một Processor nhận vào một danh sách `images` và một danh sách tùy chọn `policies`, sau đó xây dựng một batch các prompt dưới dạng tích của hai danh sách này bằng cách sử dụng chat template được cung cấp.
- Bạn có thể mở rộng các chính sách tích hợp sẵn của ShieldGemma bằng cách sử dụng đối số `custom_policies` của Processor. Việc sử dụng cùng một khóa với một trong các chính sách tích hợp sẵn sẽ ghi đè chính sách đó bằng định nghĩa tùy chỉnh của bạn.
- ShieldGemma 2 không hỗ trợ các khả năng cắt ảnh được sử dụng bởi Gemma 3.

### Phân loại theo các Chính sách tích hợp

```python
import requests
from PIL import Image

from transformers import AutoProcessor, ShieldGemma2ForImageClassification

model_id = "google/shieldgemma-2-4b-it"
model = ShieldGemma2ForImageClassification.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image = Image.open(requests.get(url, stream=True).raw)

inputs = processor(images=[image], return_tensors="pt").to(model.device)

output = model(**inputs)
print(output.probabilities)
```

### Phân loại theo Chính sách Tùy chỉnh

```python
import requests
from PIL import Image

from transformers import AutoProcessor, ShieldGemma2ForImageClassification

model_id = "google/shieldgemma-2-4b-it"
model = ShieldGemma2ForImageClassification.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image = Image.open(requests.get(url, stream=True).raw)

custom_policies = {
    "key_a": "description_a",
    "key_b": "description_b",
}

inputs = processor(
    images=[image],
    custom_policies=custom_policies,
    policies=["dangerous", "key_a", "key_b"],
    return_tensors="pt",
).to(model.device)

output = model(**inputs)
print(output.probabilities)
```

## ShieldGemma2Processor[[transformers.ShieldGemma2Processor]]

#### transformers.ShieldGemma2Processor[[transformers.ShieldGemma2Processor]]

```python
transformers.ShieldGemma2Processor(image_processor, tokenizer, chat_template = None, image_seq_length = 256, policy_definitions = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/shieldgemma2/processing_shieldgemma2.py#L70)

**Tham số:**

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

tokenizer (`GemmaTokenizer`) : Tokenizer là một đầu vào bắt buộc.

chat_template (`str`) : Một mẫu Jinja để chuyển đổi các danh sách tin nhắn trong một cuộc trò chuyện thành chuỗi có thể token hóa.

image_seq_length (``, defaults to `256`) : The number of image tokens to be used for each image in the input. Added for backward compatibility but this should be set as a processor attribute in future models.

policy_definitions (`Mapping[str, str]`, *tùy chọn*) : Một ánh xạ từ tên chính sách sang mô tả của nó dưới dạng văn bản, được sử dụng làm các chính sách mặc định để phân loại hình ảnh. Các mô tả chính sách này được bao gồm trong văn bản của các prompt do trình xử lý này tạo ra. Thông thường, giá trị này không được đặt, vì cấu hình trình xử lý trên Hugging Face Hub đã bao gồm các chính sách cơ bản mà ShieldGemma được huấn luyện.

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

[ShieldGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/shieldgemma2#transformers.ShieldGemma2Processor) cung cấp đầy đủ các chức năng của [Gemma3ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma3#transformers.Gemma3ImageProcessor) và [GemmaTokenizer](/docs/transformers/v5.23.0/vi/model_doc/gemma#transformers.GemmaTokenizer). Xem [~Gemma3ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma3#transformers.Gemma3ImageProcessor) và [~GemmaTokenizer](/docs/transformers/v5.23.0/vi/model_doc/gemma#transformers.GemmaTokenizer) để biết thêm thông tin.

#### __call__[[transformers.ShieldGemma2Processor.__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 = None, **kwargs: *<class 'transformers.models.shieldgemma2.processing_shieldgemma2.ShieldGemma2ProcessorKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/shieldgemma2/processing_shieldgemma2.py#L109)

**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 (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

return_mm_token_type_ids (`bool`, *kwargs*) : Có nên trả về các id loại token đa phương thức chỉ định vị trí của các token placeholder đa phương thức hay không.

return_text_replacement_offsets (`bool`, *kwargs*) : Có nên trả về các vị trí ký tự cho mỗi placeholder đa phương thức và phần thay thế của nó hay không.

policies (`list[str]`, *kwargs*, *optional*) : Các khóa trong từ điển kết hợp `self.policy_definitions | custom_policies` được quan tâm cụ thể cho các hình ảnh được cung cấp. Nếu là `None`, các prompt sẽ được tạo cho mọi khóa trong từ điển kết hợp.

custom_policies (`dict[str, *kwargs*, str]`, *tùy chọn*) : Các định nghĩa chính sách bổ sung để mở rộng `self.policy_definitions` được truyền vào bộ khởi tạo. Lưu ý rằng `custom_policies` có cùng khóa với `self.policy_definitions` sẽ ghi đè lên mô tả chính sách.

return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/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.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

**Trả về:**

Một `BatchFeature` chứa `input_ids`, `pixel_values`, v.v., trong đó mỗi Tensor có shape `(len(images) * len(policies), )`, và thứ tự trong batch sẽ là img1_policy1, ... img1_policyN, ... imgM_policyN.

Tạo một lô đầu vào từ các hình ảnh được cung cấp.

ShieldGemma được huấn luyện để phân loại nội dung hình ảnh nhằm tuân thủ chính sách bằng cách sử dụng một cấu trúc prompt cụ thể. Bộ xử lý này tạo ra một lô các prompt như vậy từ các hình ảnh được cung cấp bằng cách:

1. Tạo một danh sách các cuộc trò chuyện, mỗi cuộc trò chuyện cho một cặp `<image, policy>`;
2. Chuyển đổi các cuộc trò chuyện này thành văn bản bằng cách sử dụng `self.apply_chat_template()`; và
3. Mã hóa các cuộc trò chuyện và hình ảnh bằng các kỹ thuật tương tự như `Gemma3Processor`.

## ShieldGemma2Config[[transformers.ShieldGemma2Config]]

#### transformers.ShieldGemma2Config[[transformers.ShieldGemma2Config]]

```python
transformers.ShieldGemma2Config(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mm_tokens_per_image: int = 256, boi_token_index: int = 255999, eoi_token_index: int = 256000, image_token_index: int = 262144, initializer_range: float = 0.02, tie_word_embeddings: bool = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/shieldgemma2/configuration_shieldgemma2.py#L26)

**Tham số:**

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

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

mm_tokens_per_image (`int`, *tuỳ chọn*, mặc định là 256) : Số lượng token cho mỗi nhúng hình ảnh.

boi_token_index (`int`, *optional*, mặc định là 255999) : Chỉ số token bắt đầu hình ảnh để bao quanh prompt hình ảnh.

eoi_token_index (`int`, *tuỳ chọn*, mặc định là 256000) : Chỉ số token kết thúc hình ảnh để bao quanh prompt hình ảnh.

image_token_index (`int`, *tuỳ chọn*, mặc định là `262144`) : Chỉ số token hình ảnh được dùng làm ký tự thay thế cho các hình ảnh đầu vào.

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*) : Có nên liên kết các nhúng từ hay không. Mặc định là giá trị của `text_config.tie_word_embeddings` nếu không được đặt.

Đây là lớp cấu hình để lưu trữ cấu hình của một Shieldgemma2Model. Nó được sử dụng để khởi tạo một mô hình Shieldgemma2 theo các đối số được chỉ định, xác định kiến trúc của 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ấu hình của [google/shieldgemma-2-4b-it](https://huggingface.co/google/shieldgemma-2-4b-it)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import ShieldGemma2ForConditionalGeneration, ShieldGemma2Config, SiglipVisionConfig, ShieldGemma2TextConfig

>>> # Initializing a Siglip-like vision config
>>> vision_config = SiglipVisionConfig()

>>> # Initializing a ShieldGemma2 Text config
>>> text_config = ShieldGemma2TextConfig()

>>> # Initializing a ShieldGemma2 gemma-3-4b style configuration
>>> configuration = ShieldGemma2Config(vision_config, text_config)

>>> # Initializing a model from the gemma-3-4b style configuration
>>> model = ShieldGemma2TextConfig(configuration)

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

## ShieldGemma2ForImageClassification[[transformers.ShieldGemma2ForImageClassification]]

#### transformers.ShieldGemma2ForImageClassification[[transformers.ShieldGemma2ForImageClassification]]

```python
transformers.ShieldGemma2ForImageClassification(config: ShieldGemma2Config)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/shieldgemma2/modeling_shieldgemma2.py#L44)

**Tham số:**

config ([ShieldGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/shieldgemma2#transformers.ShieldGemma2Config)) : 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/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Shieldgemma2 với đầu phân loại hình ảnh phía trên, ví dụ cho ImageNet.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/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.ShieldGemma2ForImageClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/shieldgemma2/modeling_shieldgemma2.py#L72)

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

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 cách sử dụng `image_processor_class`. Xem `image_processor_class.__call__` để biết chi tiết (`processor_class` sử dụng `image_processor_class` để xử lý ảnh).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/v5.23.0/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

logits_to_keep (`Union[int, torch.Tensor]`, *tùy chọn*, mặc định là `0`) : Nếu là `int`, tính logits cho `logits_to_keep` token cuối. Nếu là `0`, tính logits cho tất cả `input_ids` (trường hợp đặc biệt). Chỉ cần logits của token cuối cho quá trình sinh, và việc chỉ tính cho token đó có thể tiết kiệm bộ nhớ, điều này trở nên khá đáng kể với các chuỗi dài hoặc kích thước từ vựng lớn. Nếu là `torch.Tensor`, phải là 1 chiều tương ứng với các chỉ số cần giữ trong chiều độ dài chuỗi. Điều này hữu ích khi sử dụng định dạng tensor đóng gói (một chiều duy nhất cho batch và độ dài chuỗi).

**Trả về:**

Một instance `ShieldGemma2ImageClassifierOutputWithNoAttention` chứa logits và xác suất liên quan đến việc mô hình dự đoán token `Yes` hoặc `No` làm phản hồi cho prompt đó, được lưu trong các thuộc tính sau.

*   `logits` (`torch.Tensor` có shape `(batch_size, 2)`): Vị trí đầu tiên dọc theo dim=1 là logits cho token `Yes` và vị trí thứ hai dọc theo dim=1 là logits cho token `No`.
*   `probabilities` (`torch.Tensor` có shape `(batch_size, 2)`): Vị trí đầu tiên dọc theo dim=1 là xác suất dự đoán token `Yes` và vị trí thứ hai dọc theo dim=1 là xác suất dự đoán token `No`.

Prompt của ShieldGemma được xây dựng sao cho việc dự đoán token `Yes` có nghĩa là nội dung *vi phạm* chính sách như đã mô tả. Nếu bạn chỉ quan tâm đến điều kiện vi phạm, hãy sử dụng `violated = outputs.probabilities[:, 1]` để trích xuất phần đó từ các tensor đầu ra.

Khi được sử dụng cùng với `ShieldGemma2Processor`, `batch_size` sẽ bằng `len(images) * len(policies)`, và thứ tự trong batch sẽ là img1_policy1, ... img1_policyN, ... imgM_policyN.

Phương thức forward của [ShieldGemma2ForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/shieldgemma2#transformers.ShieldGemma2ForImageClassification) 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.

