# Llama4 [Llama 4](https://ai.meta.com/blog/llama-4-multimodal-intelligence/), do Meta phát triển, giới thiệu kiến trúc Mixture-of-Experts (MoE) tự hồi quy mới. Thế hệ này bao gồm hai mô hình: - Llama 4 Maverick có khả năng vượt trội với 17B tham số hoạt động trong tổng số ~400B, bao gồm 128 chuyên gia. - Llama 4 Scout hiệu quả cũng có 17B tham số hoạt động trên tổng số ~109B, chỉ sử dụng 16 chuyên gia. - Cả hai mô hình đều tận dụng early fusion cho khả năng đa phương thức bản địa, cho phép xử lý đầu vào văn bản và hình ảnh. Maverick và Scout đều được huấn luyện trên tối đa 40 nghìn tỷ token trên dữ liệu bao gồm 200 ngôn ngữ (với hỗ trợ fine-tuning cụ thể cho 12 ngôn ngữ, bao gồm tiếng Ả Rập, tiếng Tây Ban Nha, tiếng Đức và tiếng Hindi). Để triển khai, Llama 4 Scout được thiết kế để dễ tiếp cận, có thể chạy trên một GPU cấp máy chủ duy nhất thông qua lượng tử hóa int4 4-bit hoặc 8-bit theo thời gian thực, trong khi Maverick có sẵn ở định dạng BF16 và FP8. Các mô hình này được phát hành theo Giấy phép Cộng đồng Llama 4 tùy chỉnh, có sẵn trên các kho lưu trữ mô hình. Bạn có thể tìm thấy tất cả các checkpoint Llama gốc dưới tổ chức [meta-llama](https://huggingface.co/meta-llama). > [!TIP] > Họ model Llama 4 có hai phiên bản: 109B và 402B tham số. Cả hai phiên bản này đều cực kỳ lớn và sẽ không chạy được trên thiết bị thông thường. Xem bên dưới để có một số ví dụ giúp giảm mức sử dụng bộ nhớ của model. > > Để quá trình tải xuống nhanh hơn và ổn định hơn, chúng tôi khuyến nghị cài đặt phụ thuộc `hf_xet` như sau: `pip install transformers[hf_xet]` Các ví dụ dưới đây minh họa cách tạo nội dung bằng [Pipeline](/docs/transformers/main/vi/main_classes/pipelines#transformers.Pipeline) hoặc [AutoModel](/docs/transformers/main/vi/model_doc/auto#transformers.AutoModel). Chúng tôi cũng bổ sung một ví dụ cho thấy cách bật các thuộc tính phù hợp để kích hoạt tạo nội dung với ngữ cảnh rất dài, vì một số biến thể của Llama 4 có độ dài ngữ cảnh lên tới 10 triệu token. ```python from transformers import pipeline model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" messages = [ {"role": "user", "content": "what is the recipe of mayonnaise?"}, ] pipe = pipeline( "text-generation", model=model_id, device_map="auto", ) output = pipe(messages, do_sample=False, max_new_tokens=200) print(output[0]["generated_text"][-1]["content"]) ``` ```python from transformers import AutoTokenizer, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) outputs = model.generate(**inputs, max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` ```python from transformers import AutoProcessor, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" processor = AutoProcessor.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg" messages = [ { "role": "user", "content": [ {"type": "image", "url": img_url}, {"type": "text", "text": "Describe this image in two sentences."}, ] }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate( **inputs, max_new_tokens=256, ) response = processor.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:])[0] print(response) ``` ```python from transformers import AutoProcessor, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" processor = AutoProcessor.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) url1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg" url2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/datasets/cat_style_layout.png" messages = [ { "role": "user", "content": [ {"type": "image", "url": url1}, {"type": "image", "url": url2}, {"type": "text", "text": "Can you describe how these two images are similar, and how they differ?"}, ] }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate( **inputs, max_new_tokens=256, ) response = processor.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:])[0] print(response) ``` Cẩn thận: ví dụ bên dưới sử dụng cả `device_map="auto"` và flex-attention. Vui lòng sử dụng `torchrun` để chạy ví dụ này ở chế độ tensor-parallel. Chúng tôi sẽ nỗ lực cho phép chạy với `device_map="auto"` và flex-attention mà không cần tensor-parallel trong tương lai. ```python import time import torch from transformers import AutoTokenizer, Llama4ForConditionalGeneration file = "very_long_context_prompt.txt" model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" with open(file, "r") as f: very_long_text = "\n".join(f.readlines()) tokenizer = AutoTokenizer.from_pretrained(model_id) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", attn_implementation="flex_attention", ) messages = [ {"role": "user", "content": f"Look at the following texts: [{very_long_text}]\n\n\n\nWhat are the books, and who wrote them? Make me a nice list."}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) torch_device_module = getattr(torch, model.device.type, torch.cuda) torch_device_module.synchronize() start = time.time() out = model.generate( **inputs, prefill_chunk_size=2048*8, max_new_tokens=300, cache_implementation="hybrid", ) print(time.time()-start) print(tokenizer.batch_decode(out[:, inputs["input_ids"].shape[-1]:])) print(f"{torch_device_module.max_memory_allocated(model.device) / 1024**3:.2f} GiB") ``` ## Hiệu suất; cách khai thác tối đa llama 4 ### Các phương pháp Attention Việc cập nhật hàm chú ý mặc định có thể cải thiện đáng kể hiệu suất tính toán cũng như mức sử dụng bộ nhớ. Tham khảo phần tổng quan về [Giao diện Attention](../attention_interface) để có giải thích chi tiết về giao diện của chúng tôi. Tại thời điểm phát hành, mô hình Llama 4 hỗ trợ các phương pháp chú ý sau: `eager`, `flex_attention`, `sdpa`. Chúng tôi khuyến nghị sử dụng `flex_attention` để đạt kết quả tốt nhất. Việc chuyển đổi cơ chế chú ý được thực hiện ở bước khởi tạo mô hình: Việc thiết lập Flex Attention đảm bảo kết quả tốt nhất với ngữ cảnh rất dài mà mô hình có thể xử lý. > [!TIP] Lưu ý: ví dụ bên dưới sử dụng cả `device_map="auto"` và flex-attention. Vui lòng sử dụng `torchrun` để chạy ví dụ này ở chế độ tensor-parallel. > > Chúng tôi sẽ nỗ lực cho phép chạy với `device_map="auto"` và flex-attention mà không cần tensor-parallel trong tương lai. ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, attn_implementation="flex_attention", device_map="auto", ) ``` Phương pháp chú ý `sdpa` thường hiệu quả hơn về mặt tính toán so với phương pháp `eager`. ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, attn_implementation="sdpa", device_map="auto", ) ``` Phương pháp chú ý `eager` được đặt mặc định, vì vậy không cần thay đổi gì khi tải mô hình: ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) ``` ### Lượng tử hóa Quantization giảm gánh nặng bộ nhớ của các mô hình lớn bằng cách biểu diễn trọng số ở độ chính xác thấp hơn. Tham khảo phần tổng quan về [Quantization](../quantization/overview) để biết các backend quantization khả dụng. Tại thời điểm phát hành, cả FBGEMM và LLM-Compressor đều được hỗ trợ; nhiều phương pháp quantization hơn sẽ được hỗ trợ trong những ngày sau khi phát hành. Xem bên dưới để biết các ví dụ sử dụng cả hai: Dưới đây là một ví dụ tải mô hình BF16 trong FP8 bằng cách tiếp cận FBGEMM: ```python from transformers import AutoTokenizer, FbgemmFp8Config, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_id) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", quantization_config=FbgemmFp8Config() ) outputs = model.generate(**inputs.to(model.device), max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` Để sử dụng kỹ thuật LLM-Compressor, chúng tôi khuyến nghị tận dụng checkpoint FP8 đã lượng tử hóa sẵn có sẵn trong bản phát hành: ```python from transformers import AutoTokenizer, Llama4ForConditionalGeneration model_id = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8" tokenizer = AutoTokenizer.from_pretrained(model_id) messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(model.device) model = Llama4ForConditionalGeneration.from_pretrained( model_id, tp_plan="auto", device_map="auto", ) outputs = model.generate(**inputs.to(model.device), max_new_tokens=100) outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:]) print(outputs[0]) ``` ### Offloading Việc bật CPU-offloading có nghĩa là các thành phần của mô hình có thể được chuyển sang CPU thay vì GPU trong trường hợp bộ nhớ GPU khả dụng không đủ để nạp toàn bộ mô hình. Trong quá trình suy luận, các thành phần khác nhau sẽ được nạp/gỡ từ/vào GPU theo thời gian thực. Điều này đảm bảo rằng mô hình có thể được nạp trên các máy nhỏ hơn miễn là bộ nhớ CPU là đủ. Tuy nhiên, điều này cũng làm chậm quá trình suy luận do thêm chi phí truyền thông. Để bật tính năng CPU-offloading, bạn chỉ cần chỉ định `device_map` thành `auto` khi tải mô hình: ```python from transformers import Llama4ForConditionalGeneration model = Llama4ForConditionalGeneration.from_pretrained( model_id, device_map="auto", ) ``` ## Llama4Config[[transformers.Llama4Config]] #### transformers.Llama4Config[[transformers.Llama4Config]] ```python transformers.Llama4Config(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, boi_token_index: int = 200080, eoi_token_index: int = 200081, image_token_index: int = 200092, tie_word_embeddings: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L208) **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. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *tùy chọn*) : Đối tượng config hoặc từ điển của text backbone. boi_token_index (`int`, *optional*, mặc định là 200080) : Chỉ số token bắt đầu hình ảnh để bao quanh prompt hình ảnh. eoi_token_index (`int`, *optional*, mặc định là 200081) : 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à `200092`) : Chỉ số token hình ảnh được dùng làm ký tự thay thế cho các hình ảnh đầu vào. tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `False`) : 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 Llama4ForConditionalGeneration. Nó được sử dụng để khởi tạo một mô hình Llama4 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ấu hình của [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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. ```python >>> from transformers import Llama4Model, Llama4Config >>> # Initializing a Llama4 7B style configuration >>> configuration = Llama4Config() >>> # Initializing a model from the Llama4 7B style configuration >>> model = Llama4Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Llama4TextConfig[[transformers.Llama4TextConfig]] #### transformers.Llama4TextConfig[[transformers.Llama4TextConfig]] ```python transformers.Llama4TextConfig(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, vocab_size: int = 202048, hidden_size: int = 5120, intermediate_size: int = 8192, intermediate_size_mlp: int = 16384, num_hidden_layers: int = 48, num_attention_heads: int = 40, num_key_value_heads: int = 8, head_dim: int = 128, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = False, attention_dropout: float | int = 0.0, num_experts_per_tok: int = 1, num_local_experts: int = 16, moe_layers: list[int] | None = None, interleave_moe_layer_step: int = 1, use_qk_norm: bool = True, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, router_jitter_noise: float = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, no_rope_layers: list[int] | None = None, no_rope_layer_interval: int = 4, attention_chunk_size: int | None = 8192, layer_types: list[str] | None = None, attn_temperature_tuning: bool = True, floor_scale: int = 8192, attn_scale: float = 0.1, attention_bias: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L79) **Tham số:** vocab_size (`int`, *tùy chọn*, mặc định là `202048`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`. hidden_size (`int`, *tuỳ chọn*, mặc định là `5120`) : Kích thước của các biểu diễn ẩn. intermediate_size (`int`, *tuỳ chọn*, mặc định là `8192`) : Kích thước của các biểu diễn MLP. intermediate_size_mlp (`int`, *tuỳ chọn*, mặc định là 16384) : Kích thước trung gian của các lớp MLP dense. Giá trị lớn hơn sẽ tăng dung lượng và sức mạnh tính toán của FFN. num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `48`) : Số lượng lớp ẩn trong bộ giải mã Transformer. num_attention_heads (`int`, *tùy chọn*, mặc định là `40`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer. num_key_value_heads (`int`, *optional*, mặc định là `8`) : Đây là số lượng key_value heads cần được sử dụng để triển khai Grouped Query Attention. Nếu `num_key_value_heads=num_attention_heads`, mô hình sẽ sử dụng Multi Head Attention (MHA), nếu `num_key_value_heads=1` mô hình sẽ sử dụng Multi Query Attention (MQA), ngược lại GQA sẽ được sử dụng. Khi chuyển đổi một checkpoint multi-head sang checkpoint GQA, mỗi nhóm key và value head nên được xây dựng bằng cách meanpooling tất cả các head gốc trong nhóm đó. Để biết thêm chi tiết, hãy xem [bài báo này](https://huggingface.co/papers/2305.13245). Nếu không được chỉ định, giá trị mặc định sẽ là `num_attention_heads`. head_dim (`int`, *tùy chọn*, mặc định là `128`) : Kích thước chiều đầu chú ý. Nếu là None, giá trị mặc định sẽ là hidden_size // num_attention_heads hidden_act (`str`, *tùy chọn*, mặc định là `silu`) : 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. max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `131072`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng. 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ố. rms_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-05`) : Epsilon được sử dụng bởi các lớp chuẩn hóa rms. use_cache (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có nên trả về các chú ý key/values cuối cùng hay không (không được sử dụng bởi tất cả các mô hình). Chỉ liên quan nếu `config.is_decoder=True` hoặc khi mô hình là mô hình sinh chỉ có decoder. pad_token_id (`int`, *tùy chọn*) : Id của token được sử dụng để đệm (padding) trong từ vựng. bos_token_id (`int`, *tuỳ chọn*, mặc định là `1`) : Id của token được sử dụng cho đầu luồng (beginning-of-stream) trong từ vựng. eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `2`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng. tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `False`) : 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. 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ú ý. num_experts_per_tok (`int`, *tuỳ chọn*, mặc định là `1`) : Số lượng chuyên gia để định tuyến mỗi token. Đây là giá trị top-k cho việc định tuyến chọn token. num_local_experts (`int`, *tuỳ chọn*, mặc định là `16`) : Số lượng chuyên gia cục bộ trên mỗi thiết bị. `num_experts` phải chia hết cho `num_local_experts`. moe_layers (`list[int]`, *tuỳ chọn*) : Danh sách các chỉ số lớp sử dụng MoE. Ghi đè `interleave_moe_layer_step` khi được đặt. interleave_moe_layer_step (`int`, *tuỳ chọn*, mặc định là 1) : Khoảng cách giữa các lớp MoE khi `moe_layers` là `None`. Giá trị lớn hơn có nghĩa là ít lớp MoE hơn. use_qk_norm (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuẩn hóa L2 các truy vấn/chìa khóa trên các lớp RoPE hay không. Có thể ổn định sự chú ý khi được bật. output_router_logits (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên trả về logits của router từ mô hình hay không. Bật tùy chọn này cũng cho phép mô hình xuất ra tổn thất bổ trợ, bao gồm tổn thất cân bằng tải và tổn thất z của router. router_aux_loss_coef (`float`, *tùy chọn*, mặc định là `0.001`) : Hệ số tổn thất cân bằng tải phụ. Được sử dụng để phạt việc định tuyến chuyên gia không đồng đều trong các mô hình MoE. router_jitter_noise (`float`, *optional*, mặc định là `0.0`) : Lượng nhiễu cần thêm vào router logits trong quá trình huấn luyện để cân bằng tải tốt hơn. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Từ điển chứa các tham số cấu hình cho các embedding RoPE. Từ điển phải chứa một giá trị cho `rope_theta` và tùy chọn các tham số được sử dụng để mở rộng trong trường hợp bạn muốn sử dụng RoPE với `max_position_embeddings` dài hơn. no_rope_layers (`list[int]`, *optional*) : Danh sách có độ dài ít nhất bằng số lớp trong mô hình. Giá trị `1` tại một vị trí chỉ số cho biết lớp tương ứng sẽ sử dụng RoPE, trong khi `0` cho biết đó là lớp NoPE. no_rope_layer_interval (`int`, *tuỳ chọn*, mặc định là 4) : Nếu `no_rope_layers` là `None`, nó sẽ được tạo bằng cách sử dụng một lớp NoPE mỗi `no_rope_layer_interval` lớp. attention_chunk_size (`int`, *optional*, mặc định là 8192) : Kích thước chunk cho phép toán attention. Giá trị nhỏ hơn sẽ áp đặt attention cục bộ hơn và giảm bộ nhớ. layer_types (`list[str]`, *tùy chọn*) : Một danh sách ánh xạ rõ ràng từng chỉ số lớp với loại lớp của nó. Nếu không được cung cấp, danh sách này sẽ được tạo tự động dựa trên các giá trị cấu hình. attn_temperature_tuning (`bool`, *tùy chọn*, mặc định là `True`) : Có nên tự động điều chỉnh nhiệt độ chú ý cho từng token truy vấn dựa trên độ dài chuỗi hay không. Được khuyến nghị cho các chuỗi dài (ví dụ: >32k token) để duy trì kết quả đầu ra ổn định. floor_scale (`int`, *tuỳ chọn*, mặc định là 8192) : Thang cơ bản (theo token) để điều chỉnh nhiệt độ chú ý. Giá trị lớn hơn sẽ trì hoãn việc mở rộng sang các vị trí dài hơn. attn_scale (`float`, *tuỳ chọn*, mặc định là 0.1) : Độ mạnh của việc điều chỉnh nhiệt độ chú ý. Giá trị lớn hơn sẽ tăng mức độ mở rộng tại các vị trí dài. attention_bias (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng bias trong các lớp chiếu query, key, value và output trong quá trình tự chú ý hay không. Đây là lớp cấu hình để lưu trữ cấu hình của một Llama4ForConditionalGeneration. Nó được sử dụng để khởi tạo một mô hình Llama4 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ấu hình của [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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ụ: ## Llama4VisionConfig[[transformers.Llama4VisionConfig]] #### transformers.Llama4VisionConfig[[transformers.Llama4VisionConfig]] ```python transformers.Llama4VisionConfig(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, hidden_act: str = 'gelu', num_hidden_layers: int = 34, num_attention_heads: int = 16, num_channels: int = 3, intermediate_size: int = 5632, vision_output_dim: int = 7680, image_size: int | list[int] | tuple[int, int] = 448, patch_size: int | list[int] | tuple[int, int] = 14, norm_eps: float = 1e-05, vision_feature_select_strategy: str = 'default', initializer_range: float = 0.02, pixel_shuffle_ratio: float = 0.5, projector_input_dim: int = 4096, projector_output_dim: int = 4096, multi_modal_projector_bias: bool = False, projector_dropout: float | int = 0.0, attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/configuration_llama4.py#L29) **Tham số:** hidden_size (`int`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn. 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. num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `34`) : Số lượng lớp ẩn trong bộ giải mã Transformer. num_attention_heads (`int`, *tuỳ chọn*, mặc định là `16`) : 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. intermediate_size (`int`, *tuỳ chọn*, mặc định là `5632`) : Kích thước của các biểu diễn MLP. vision_output_dim (`int`, *optional*, mặc định là 7680) : Độ chiều của đầu ra mô hình thị giác. Bao gồm đầu ra của bộ mã hóa transformer với các lớp trung gian và bộ mã hóa transformer toàn cục. image_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `448`) : 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à `14`) : Kích thước (độ phân giải) của mỗi patch. norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-05`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization). vision_feature_select_strategy (`str`, *tùy chọn*, mặc định là `default`) : Chiến lược chọn đặc trưng được sử dụng để chọn đặc trưng thị giác từ bộ khung thị giác. 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ố. pixel_shuffle_ratio (`float`, *optional*, mặc định là 0.5) : Tỷ lệ pixel-shuffle để hạ mẫu các token patch. Giá trị nhỏ hơn tạo ra ít token hơn (hạ mẫu nhiều hơn). projector_input_dim (`int`, *tuỳ chọn*, mặc định là 4096) : Độ rộng của MLP bộ thích ứng thị giác trước khi pixel shuffle. Giá trị lớn hơn làm tăng sức chứa và lượng tính toán. projector_output_dim (`int`, *tuỳ chọn*, mặc định là 4096) : Độ rộng đầu ra của bộ thích ứng thị giác. Giá trị lớn hơn sẽ tạo ra các đặc trưng ảnh có chiều cao hơn. multi_modal_projector_bias (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng bias trong bộ dự đoán đa phương thức hay không. projector_dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Tỷ lệ dropout bên trong MLP của bộ thích ứng thị giác. Giá trị cao hơn sẽ thêm nhiều quy tắc hóa hơn. 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ú ý. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Từ điển chứa các tham số cấu hình cho các embedding RoPE. Từ điển phải chứa một giá trị cho `rope_theta` và tùy chọn các tham số được sử dụng để mở rộng trong trường hợp bạn muốn sử dụng RoPE với `max_position_embeddings` dài hơn. Đây là lớp cấu hình để lưu trữ cấu hình của một Llama4ForConditionalGeneration. Nó được sử dụng để khởi tạo một mô hình Llama4 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ấu hình của [meta-llama/Llama-4-Scout-17B-16E](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E) 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. ## Llama4Processor[[transformers.Llama4Processor]] #### transformers.Llama4Processor[[transformers.Llama4Processor]] ```python transformers.Llama4Processor(image_processor = None, tokenizer = None, patch_size: int = 14, pixel_shuffle_ratio: float = 0.5, fake_image_token = '<|image|>', image_token = '<|image|>', start_of_image_token = '<|image_start|>', end_of_image_token = '<|image_end|>', patch_token = '<|patch|>', tile_x_separator_token = '<|tile_x_separator|>', tile_y_separator_token = '<|tile_y_separator|>', chat_template = '{{- bos_token }}\n{%- if custom_tools is defined %}\n {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n {%- if strftime_now is defined %}\n {%- set date_string = strftime_now("%d %b %Y") %}\n {%- else %}\n {%- set date_string = "26 Jul 2024" %}\n {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0][\'role\'] == \'system\' %} \n {%- if messages[0][\'content\'] is string %}\n {%- set system_message = messages[0][\'content\']|trim %}\n {%- else %}\n {#- FIXME: The processor requires an array, always. #}\n {%- set system_message = messages[0][\'content\'][0][\'text\']|trim %}\n {%- endif %}\n {%- set messages = messages[1:] %}\n {%- set user_supplied_system_message = true %}\n{%- else %}\n {%- set system_message = "" %}\n {%- set user_supplied_system_message = false %}\n{%- endif %}\n\n{#- System message if the user supplied one #}\n{%- if user_supplied_system_message %}\n {{- "<|header_start|>system<|header_end|>\n\n" }}\n {%- if tools is not none %}\n {{- "Environment: ipython\n" }}\n {%- endif %}\n {%- if tools is not none and not tools_in_user_message %}\n {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {%- endif %}\n {{- system_message }}\n {{- "<|eot|>" }}\n{%- endif %}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n {#- Extract the first user message so we can plug it in here #}\n {%- if messages | length != 0 %}\n {%- set first_user_message = messages[0][\'content\']|trim %}\n {%- set messages = messages[1:] %}\n {%- else %}\n {{- raise_exception("Cannot put tools in the first user message when there\'s no first user message!") }}\n{%- endif %}\n {{- \'<|header_start|>user<|header_end|>\n\n\' -}}\n {{- "Given the following functions, please respond with a JSON for a function call " }}\n {{- "with its proper arguments that best answers the given prompt.\n\n" }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {{- first_user_message + "<|eot|>"}}\n{%- endif %}\n\n{%- for message in messages %}\n {%- if not (message.role == \'ipython\' or message.role == \'tool\' or \'tool_calls\' in message) %}\n {{- \'<|header_start|>\' + message[\'role\'] + \'<|header_end|>\n\n\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- elif \'tool_calls\' in message and message.tool_calls|length > 0 %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' -}}\n {{- \'<|python_start|>\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- \'<|python_end|>\' }}\n {%- for tool_call in message.tool_calls %}\n {{- \'{"name": "\' + tool_call.function.name + \'", \' }}\n {{- \'"parameters": \' }}\n {{- tool_call.function.arguments | tojson }}\n {{- "}" }}\n {%- endfor %}\n {{- "<|eot|>" }}\n {%- elif message.role == "tool" or message.role == "ipython" %}\n {{- "<|header_start|>ipython<|header_end|>\n\n" }}\n {%- if message.content is mapping or message.content is iterable %}\n {{- message.content | tojson }}\n {%- else %}\n {{- message.content }}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' }}\n{%- endif %}\n', **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/processing_llama4.py#L34) **Tham số:** image_processor (`Llama4ImageProcessor`) : Bộ xử lý ảnh là một đầu vào bắt buộc. tokenizer (`tokenizer_class`) : Tokenizer là đầu vào bắt buộc. patch_size (`int`, *tuỳ chọn*, mặc định là 28) : Kích thước của các mảnh ảnh (image patches) để token hóa. pixel_shuffle_ratio (`float`, *tuỳ chọn*, mặc định là `0.5`) : Tỷ lệ được sử dụng cho pixel shuffling khi xử lý hình ảnh. Tham số này kiểm soát hệ số giảm mẫu được áp dụng cho các mảnh hình ảnh. Tỷ lệ giảm mẫu thực tế được tính bằng `1 / (pixel_shuffle_ratio^2)`. fake_image_token (`str`, *tùy chọn*, mặc định là `"<|image|>"`) : Token thay thế trong văn bản sẽ được thay thế bằng các token hình ảnh thực tế. Token này đóng vai trò là dấu hiệu cho biết vị trí cần chèn hình ảnh trong chuỗi văn bản. image_token (`str`, *tùy chọn*, mặc định là `"<|image|>"`) : Token được sử dụng để biểu diễn một hình ảnh trong văn bản. start_of_image_token (`str`, *tùy chọn*, mặc định là `"<|image_start|>"`) : Token đặc biệt đánh dấu sự bắt đầu của một chuỗi hình ảnh trong văn bản. Token này được thêm vào trước các chuỗi token hình ảnh để phân định ranh giới hình ảnh. end_of_image_token (`str`, *tùy chọn*, mặc định là `"<|image_end|>"`) : Token đặc biệt đánh dấu kết thúc của một chuỗi hình ảnh trong văn bản. Token này được thêm vào các chuỗi token hình ảnh để phân định ranh giới hình ảnh. patch_token (`str`, *tùy chọn*, mặc định là `"<|patch|>"`) : Token được sử dụng để đại diện cho các patch ảnh riêng lẻ. Nhiều token patch được dùng để đại diện cho toàn bộ ảnh, với số lượng phụ thuộc vào kích thước ảnh và cấu hình patch. tile_x_separator_token (`str`, *tùy chọn*, mặc định là `"<|tile_x_separator|>"`) : Token được sử dụng để phân tách các tile (patch) theo chiều ngang trong một hình ảnh. Token này được chèn giữa các patch trong cùng một hàng khi hình ảnh được chia thành nhiều tile. tile_y_separator_token (`str`, *tùy chọn*, mặc định là `"<|tile_y_separator|>"`) : Token được sử dụng để phân tách các tile (patch) theo chiều dọc trong một hình ảnh. Token này được chèn giữa các hàng patch khi hình ảnh được chia thành nhiều tile. chat_template (`str`, mặc định là `{{- bos_token }} -- {%- if custom_tools is defined %} : {%- set tools = custom_tools %} {%- endif %} -- {%- if not tools_in_user_message is defined %} : {%- set tools_in_user_message = true %} {%- endif %} -- {%- if not date_string is defined %} : {%- if strftime_now is defined %} {%- set date_string = strftime_now("%d %b %Y") %} {%- else %} {%- set date_string = "26 Jul 2024" %} {%- endif %} {%- endif %} -- {%- if not tools is defined %} : {%- set tools = none %} {%- endif %} : {#- Khối này trích xuất thông báo hệ thống, để chúng ta có thể đặt nó vào đúng vị trí. #} -- {%- if messages[0]['role'] == 'system' %} : {%- if messages[0]['content'] is string %} {%- set system_message = messages[0]['content']|trim %} {%- else %} {#- FIXME: Bộ xử lý luôn yêu cầu một mảng. #} {%- set system_message = messages[0]['content'][0]['text']|trim %} {%- endif %} {%- set messages = messages[1:] %} {%- set user_supplied_system_message = true %} {%- else %} : {%- set system_message = "" %} {%- set user_supplied_system_message = false %} {%- endif %} : {#- Thông báo hệ thống nếu người dùng đã cung cấp một thông báo #} -- {%- if user_supplied_system_message %} : {{- "<|header_start|>system<|header_end|>" " }} : {%- if tools is not none %} {{- "Môi trường: ipython " }} : {%- endif %} {%- if tools is not none and not tools_in_user_message %} {{- "Bạn có quyền truy cập vào các hàm sau. Để gọi một hàm, vui lòng phản hồi bằng JSON cho một lời gọi hàm." }} {{- 'Phản hồi theo định dạng {"name": tên hàm, "parameters": từ điển của tên đối số và giá trị của nó}.' }} {{- "Không sử dụng biến. " }} : {%- for t in tools %} {{- t | tojson(indent=4) }} {{- " " }} : {%- endfor %} {%- endif %} {{- system_message }} {{- "<|eot|>" }} {%- endif %} : {#- Công cụ tùy chỉnh được truyền trong một thông báo người dùng kèm theo một số hướng dẫn bổ sung #} -- {%- if tools_in_user_message and not tools is none %} : {#- Trích xuất tin nhắn người dùng đầu tiên để chúng ta có thể chèn nó vào đây #} {%- if messages | length != 0 %} {%- set first_user_message = messages[0]['content']|trim %} {%- set messages = messages[1:] %} {%- else %} {{- raise_exception("Không thể đặt công cụ trong tin nhắn người dùng đầu tiên khi không có tin nhắn người dùng đầu tiên!") }} {%- endif %} : {{- '<|header_start|>user<|header_end|>' ' -}} : {{- "Với các hàm sau đây, vui lòng trả lời bằng một JSON cho một lời gọi hàm " }} {{- "có các đối số phù hợp nhất để trả lời cho prompt đã cho. " }} : {{- 'Trả lời theo định dạng {"name": tên hàm, "parameters": từ điển của tên đối số và giá trị của nó}.' }} {{- "Không sử dụng biến. " }} : {%- for t in tools %} {{- t | tojson(indent=4) }} {{- " " }} : {%- endfor %} {{- first_user_message + "<|eot|>"}} {%- endif %} : {%- for message in messages %} : {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %} {{- '<|header_start|>' + message['role'] + '<|header_end|> ' }} : {%- if message['content'] is string %} {{- message['content'] }} {%- else %} {%- for content in message['content'] %} {%- if content['type'] == 'image' %} {{- '<|image|>' }} {%- elif content['type'] == 'text' %} {{- content['text'] }} {%- endif %} {%- endfor %} {%- endif %} {{- "<|eot|>" }} {%- elif 'tool_calls' in message and message.tool_calls|length > 0 %} {{- '<|header_start|>assistant<|header_end|> ' -}} : {{- '<|python_start|>' }} {%- if message['content'] is string %} {{- message['content'] }} {%- else %} {%- for content in message['content'] %} {%- if content['type'] == 'image' %} {{- '<|image|>' }} {%- elif content['type'] == 'text' %} {{- content['text'] }} {%- endif %} {%- endfor %} {%- endif %} {{- '<|python_end|>' }} {%- for tool_call in message.tool_calls %} {{- '{"name": "' + tool_call.function.name + '", ' }} {{- '"parameters": ' }} {{- tool_call.function.arguments | tojson }} {{- "}" }} {%- endfor %} {{- "<|eot|>" }} {%- elif message.role == "tool" or message.role == "ipython" %} {{- "<|header_start|>ipython<|header_end|> " }} : {%- if message.content is mapping or message.content is iterable %} {{- message.content | tojson }} {%- else %} {{- message.content }} {%- endif %} {{- "<|eot|>" }} {%- endif %} {%- endfor %} -- {%- if add_generation_prompt %} : {{- '<|header_start|>assistant<|header_end|> ' }} -- {%- endif %} -- `) : 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. Tạo một Llama4Processor đóng gói một bộ xử lý ảnh và một bộ phân từ thành một bộ xử lý duy nhất. [Llama4Processor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Processor) cung cấp đầy đủ các chức năng của [Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor) và `tokenizer_class`. Xem [~Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor) và `~tokenizer_class` để biết thêm thông tin. #### __call__[[transformers.Llama4Processor.__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, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **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ô. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *optional*) : Video cần tiền xử lý. Kỳ vọng một video đơn hoặc một batch video với giá trị pixel từ 0 đến 255. Nếu truyền vào video có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *optional*) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh. 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. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/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ợ. ## Llama4ImageProcessor[[transformers.Llama4ImageProcessor]] #### transformers.Llama4ImageProcessor[[transformers.Llama4ImageProcessor]] ```python transformers.Llama4ImageProcessor(**kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/image_processing_llama4.py#L296) **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à `{'height' : 336, 'width': 336}`): 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.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : Độ 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ý. max_patches (`int`, *kwargs*, *optional*, mặc định là 16) : Số lượng tối đa các patch được trích xuất từ ảnh. Có thể bị ghi đè bởi tham số `max_patches` trong phương thức `preprocess`. resize_to_max_canvas (`bool`, *kwargs*, *optional*, mặc định là False) : Có nên phóng to/thu nhỏ ảnh về kích thước canvas tối đa hay không. Nếu True, sẽ chọn canvas cho phép phóng to/thu nhỏ lớn nhất mà không bị biến dạng. Nếu False, sẽ thu nhỏ ảnh ít nhất có thể, bao gồm cả việc không phóng to/thu nhỏ, nhưng không bao giờ phóng to, trừ khi ảnh nhỏ hơn kích thước patch. Tạo một bộ xử lý ảnh Llama4ImageProcessor. #### preprocess[[transformers.Llama4ImageProcessor.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']], **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/image_processing_llama4.py#L312) **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`. 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ý. max_patches (`int`, *kwargs*, *optional*, mặc định là 16) : Số lượng tối đa các patch được trích xuất từ ảnh. Có thể bị ghi đè bởi tham số `max_patches` trong phương thức `preprocess`. resize_to_max_canvas (`bool`, *kwargs*, *optional*, mặc định là False) : Có nên phóng to/thu nhỏ ảnh về kích thước canvas tối đa hay không. Nếu True, sẽ chọn canvas cho phép phóng to/thu nhỏ lớn nhất mà không bị biến dạng. Nếu False, sẽ thu nhỏ ảnh ít nhất có thể, bao gồm cả việc không phóng to/thu nhỏ, nhưng không bao giờ phóng to, trừ khi ảnh nhỏ hơn kích thước patch. **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. ## Llama4ForConditionalGeneration[[transformers.Llama4ForConditionalGeneration]] #### transformers.Llama4ForConditionalGeneration[[transformers.Llama4ForConditionalGeneration]] ```python transformers.Llama4ForConditionalGeneration(config: Llama4Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1149) #### forward[[transformers.Llama4ForConditionalGeneration.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, inputs_embeds: typing.Optional[torch.Tensor] = None, vision_feature_select_strategy: str | None = 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, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1214) **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/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/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ó hình dạng `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các hình ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor). Xem [Llama4ImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Llama4Processor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Processor) sử dụng [Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor) để xử lý hình ả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/main/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/main/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)`. 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. vision_feature_select_strategy (`str`, *tùy chọn*) : Chiến lược chọn đặc trưng được sử dụng để chọn đặc trưng thị giác từ bộ khung thị giác. Có thể là một trong `"default"` hoặc `"full"`. labels (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có mặt nạ. Chỉ số phải nằm trong `[0, ..., config.vocab_size]` hoặc -100 (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (mặt nạ), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`. 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/main/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). mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *tùy chọn*) : Dict trong đó các khóa là các chế độ (modalities) được hỗ trợ và các giá trị là kết quả mã hóa cho chế độ đó. Mỗi kết quả mã hóa là một tuple bao gồm (`pooler_output`, *tùy chọn*: `last_hidden_states`, *tùy chọn*: `hidden_states`, *tùy chọn*: `attentions`) `pooler_output` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) là một chuỗi các đặc trưng đa chế độ của bộ mã hóa được hợp nhất vào các nhúng văn bản. **Trả về:** `Llama4CausalLMOutputWithPast` hoặc `tuple(torch.Tensor)` Một `Llama4CausalLMOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Config)) và đầu vào. Phương thức forward của [Llama4ForConditionalGeneration](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ForConditionalGeneration) 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. - **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss của language modeling (cho next-token prediction). - **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax). - **past_key_values** (`Cache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự. - **hidden_states** (`tuple[torch.Tensor]`, *tuỳ 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]`, *tuỳ 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. - **image_hidden_states** (`torch.Tensor`, *tuỳ chọn*) -- Một `torch.Tensor` có kích thước (batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states của mô hình do bộ mã hóa thị giác tạo ra và sau khi chiếu trạng thái ẩn cuối cùng. - **router_logits** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi truyền `output_router_logits=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp MoE) có hình dạng `(batch_size * sequence_length, num_experts)`. Ví dụ: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, LlavaForConditionalGeneration >>> model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf") >>> processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf") >>> prompt = "USER: \nWhat's the content of the image? ASSISTANT:" >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, text=prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(**inputs, max_new_tokens=15) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "USER: \nWhat's the content of the image? ASSISTANT: The image features a busy city street with a stop sign prominently displayed" ``` #### get_image_features[[transformers.Llama4ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1181) **Tham số:** pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng [Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor). Xem [Llama4ImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Llama4Processor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Processor) sử dụng [Llama4ImageProcessor](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ImageProcessor) để xử lý ảnh). **Trả về:** [BaseModelOutputWithPooling](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc `tuple(torch.Tensor)` Một [BaseModelOutputWithPooling](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Llama4Config](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Config)) và đầu vào. Lấy trạng thái ẩn cuối cùng của hình ảnh từ tháp thị giác và áp dụng phép chiếu. - **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình. - **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện. - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ 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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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)`, *tuỳ 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. Ví dụ: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Llama4ForConditionalGeneration >>> model = Llama4ForConditionalGeneration.from_pretrained("meta-llama/Llama-4-Scout-17B-16E") >>> processor = AutoProcessor.from_pretrained("meta-llama/Llama-4-Scout-17B-16E") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ``` ## Llama4ForCausalLM[[transformers.Llama4ForCausalLM]] #### transformers.Llama4ForCausalLM[[transformers.Llama4ForCausalLM]] ```python transformers.Llama4ForCausalLM(config: Llama4TextConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L568) #### forward[[transformers.Llama4ForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L585) **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/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) 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/main/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/main/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)`. 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, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có mặt nạ. Chỉ số phải nằm trong `[0, ..., config.vocab_size]` hoặc -100 (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (mặt nạ), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`. 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`). 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ề:** `MoeCausalLMOutputWithPast` hoặc `tuple(torch.Tensor)` Một `MoeCausalLMOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Config)) và đầu vào. Phương thức forward của [Llama4ForCausalLM](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4ForCausalLM) 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. - **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss của language modeling (cho next-token prediction). - **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax). - **aux_loss** (`torch.Tensor`, *tuỳ chọn*, được trả về khi `output_router_logits=True` được truyền vào hoặc khi `config.output_router_logits=True`, và mô hình huấn luyện router của nó với tổn thất cân bằng tải) -- Tổn thất phụ cân bằng tải cho các module thưa. Các mô hình cân bằng chuyên gia của chúng bằng router bias thay thế (DeepSeek-V3 và các kiến trúc phái sinh từ nó) sẽ trả về `None` tại đây trong khi vẫn trả về `router_logits`. - **router_logits** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_router_logits=True` được truyền vào hoặc khi `config.output_router_logits=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp thưa) có hình dạng `(batch_size * sequence_length, num_experts)`. Logits thô của router được tính toán bởi các router MoE. Chúng có thể được sử dụng để tính toán tổn thất cân bằng tải hoặc để kiểm tra cách các token được phân phối đến các chuyên gia. - **past_key_values** (`Cache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự. - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ 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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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)`, *tuỳ 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. Ví dụ: ```python >>> from transformers import AutoTokenizer, Llama4ForCausalLM >>> model = Llama4ForCausalLM.from_pretrained("meta-llama4/Llama4-2-7b-hf") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama4/Llama4-2-7b-hf") >>> prompt = "Hey, are you conscious? Can you talk to me?" >>> inputs = tokenizer(prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(inputs.input_ids, max_length=30) >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you." ``` ## Llama4TextModel[[transformers.Llama4TextModel]] #### transformers.Llama4TextModel[[transformers.Llama4TextModel]] ```python transformers.Llama4TextModel(config: Llama4TextConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L475) **Tham số:** config ([Llama4TextConfig](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4TextConfig)) : 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 Llama4 Text thuần túy, tạo ra các hidden-states thô mà không có bất kỳ head cụ thể 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.Llama4TextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L502) **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/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) 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/main/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/main/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)`. 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. 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`). **Trả về:** `MoeModelOutputWithPast` hoặc `tuple(torch.Tensor)` Một `MoeModelOutputWithPast` 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 ([Llama4Config](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4Config)) và đầu vào. Phương thức forward của [Llama4TextModel](/docs/transformers/main/vi/model_doc/llama4#transformers.Llama4TextModel) 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. - **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình. - **past_key_values** (`Cache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và tùy chọn nếu `config.is_encoder_decoder=True` trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự. - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ 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ủa `torch.Tensor` (một cho đầu ra của các embedding, 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)`, *tuỳ 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. - **router_logits** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_router_probs=True` và `config.add_router_probs=True` được truyền vào hoặc khi `config.output_router_probs=True`) -- Bộ ba `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, sequence_length, num_experts)`. Logits thô (sau softmax) được tính bởi các router MoE, các thuật ngữ này được sử dụng để tính toán tổn thất bổ trợ cho các mô hình Mixture of Experts. ## Llama4VisionModel[[transformers.Llama4VisionModel]] #### transformers.Llama4VisionModel[[transformers.Llama4VisionModel]] ```python transformers.Llama4VisionModel(config: Llama4VisionConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1011) #### forward[[transformers.Llama4VisionModel.forward]] ```python forward(pixel_values: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama4/modeling_llama4.py#L1048) Ví dụ: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, MllamaVisionModel >>> checkpoint = "meta-llama/Llama-3.2-11B-Vision" >>> model = MllamaVisionModel.from_pretrained(checkpoint) >>> processor = AutoProcessor.from_pretrained(checkpoint) >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, return_tensors="pt") >>> output = model(**inputs) >>> print(output.last_hidden_state.shape) torch.Size([1, 1, 4, 1025, 7680]) ```