# BLIP-2 ## Tổng quan Mô hình BLIP-2 được đề xuất trong [BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models](https://huggingface.co/papers/2301.12597) bởi Junnan Li, Dongxu Li, Silvio Savarese, Steven Hoi. BLIP-2 tận dụng các bộ mã hóa ảnh được huấn luyện trước và đóng băng cùng các mô hình ngôn ngữ lớn (LLM) bằng cách huấn luyện một bộ mã hóa Transformer 12 lớp nhẹ ở giữa chúng, đạt hiệu suất tiên tiến trên nhiều tác vụ thị giác-ngôn ngữ. Đáng chú ý nhất, BLIP-2 cải thiện [Flamingo](https://huggingface.co/papers/2204.14198), một mô hình có 80 tỷ tham số, lên 8,7% trên zero-shot VQAv2 với số tham số có thể huấn luyện ít hơn 54 lần. Tóm tắt từ bài báo như sau: *Chi phí của việc tiền huấn luyện thị giác-ngôn ngữ ngày càng trở nên khó tiếp cận do việc huấn luyện end-to-end các mô hình quy mô lớn. Bài báo này đề xuất BLIP-2, một chiến lược tiền huấn luyện tổng quát và hiệu quả, khởi tạo việc tiền huấn luyện thị giác-ngôn ngữ từ các bộ mã hóa ảnh tiền huấn luyện đóng băng có sẵn và các mô hình ngôn ngữ lớn đóng băng. BLIP-2 thu hẹp khoảng cách giữa các phương thức bằng một Querying Transformer nhẹ, được tiền huấn luyện trong hai giai đoạn. Giai đoạn đầu khởi tạo việc học biểu diễn thị giác-ngôn ngữ từ một bộ mã hóa ảnh đóng băng. Giai đoạn thứ hai khởi tạo việc học sinh thành thị giác-sang-ngôn ngữ từ một mô hình ngôn ngữ đóng băng. BLIP-2 đạt hiệu suất tiên tiến trên nhiều tác vụ thị giác-ngôn ngữ, mặc dù có số tham số có thể huấn luyện ít hơn đáng kể so với các phương pháp hiện có. Ví dụ, mô hình của chúng ta vượt trội hơn Flamingo80B 8,7% trên zero-shot VQAv2 với số tham số có thể huấn luyện ít hơn 54 lần. Chúng tôi cũng chứng minh các khả năng mới nổi của mô hình trong việc sinh thành ảnh-sang-văn bản zero-shot, có thể tuân theo các chỉ dẫn bằng ngôn ngữ tự nhiên.* drawing Kiến trúc BLIP-2. Được trích từ bài báo gốc. Mô hình này được đóng góp bởi [nielsr](https://huggingface.co/nielsr). Mã gốc có thể được tìm thấy [tại đây](https://github.com/salesforce/LAVIS/tree/5ee63d688ba4cebff63acee04adaef2dee9af207). ## Mẹo sử dụng - BLIP-2 có thể được sử dụng để tạo văn bản có điều kiện dựa trên một hình ảnh và một prompt văn bản tùy chọn. Khi suy luận, khuyến nghị sử dụng phương thức `generate`. - Bạn có thể sử dụng [Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) để chuẩn bị hình ảnh cho mô hình và giải mã các ID token dự đoán thành văn bản. > [!NOTE] > Các mô hình BLIP sau bản phát hành v4.46 sẽ phát ra cảnh báo về việc thêm `processor.num_query_tokens = {{num_query_tokens}}` và mở rộng lớp embeddings của mô hình để thêm token đặc biệt ``. Rất khuyến nghị thêm các thuộc tính này vào processor nếu bạn sở hữu checkpoint của mô hình, hoặc mở một PR nếu checkpoint không thuộc về bạn. Việc thêm các thuộc tính này có nghĩa là BLIP sẽ thêm số lượng query tokens cần thiết cho mỗi ảnh và mở rộng văn bản với số lượng placeholder `` tương ứng với số query tokens. Thông thường, con số này vào khoảng 500 tokens mỗi ảnh, vì vậy hãy đảm bảo rằng văn bản không bị cắt cụt, nếu không sẽ xảy ra lỗi khi gộp các embeddings. Các thuộc tính có thể được lấy từ cấu hình mô hình, dưới dạng `model.config.num_query_tokens` và việc mở rộng nhúng mô hình có thể được thực hiện bằng cách làm theo [liên kết này](https://gist.github.com/zucchini-nlp/e9f20b054fa322f84ac9311d9ab67042). ## Tài nguyên Danh sách các tài nguyên chính thức của Hugging Face và cộng đồng (được đánh dấu bằng 🌎) để giúp bạn bắt đầu với BLIP-2. - Các notebook demo cho BLIP-2 về chú thích hình ảnh, trả lời câu hỏi trực quan (VQA) và hội thoại kiểu chat có thể được tìm thấy [tại đây](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/BLIP-2). Nếu bạn quan tâm đến việc gửi một tài nguyên để được đưa vào đây, hãy thoải mái mở một Pull Request và chúng tôi sẽ xem xét! Lý tưởng nhất là tài nguyên nên minh họa một điều gì đó mới thay vì sao chép một tài nguyên hiện có. ## Blip2Config[[transformers.Blip2Config]] #### transformers.Blip2Config[[transformers.Blip2Config]] ```python transformers.Blip2Config(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, qformer_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_query_tokens: int = 32, image_text_hidden_size: int = 256, image_token_index: int | None = None, initializer_factor: float = 1.0, initializer_range: float = 0.02) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L107) **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. qformer_config (`dict`, *tùy chọn*) : Từ điển các tùy chọn cấu hình được sử dụng để khởi tạo [Blip2QFormerConfig](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2QFormerConfig). text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *tùy chọn*) : Đối tượng config hoặc từ điển của text backbone. num_query_tokens (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng token truy vấn được truyền qua Transformer. image_text_hidden_size (`int`, *optional*, mặc định là 256) : Độ chiều của trạng thái ẩn của lớp kết hợp hình ảnh-văn bản. image_token_index (`int`, *tuỳ chọn*) : 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_factor (`float`, *tuỳ chọn*, mặc định là `1.0`) : Hệ số để khởi tạo tất cả các ma trận trọng số (nên giữ ở mức 1, được sử dụng bên trong cho việc kiểm tra khởi tạ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ố. Đây là lớp cấu hình để lưu trữ cấu hình của một Mô hình Blip 2. Nó được sử dụng để khởi tạo một mô hình Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import ( ... Blip2VisionConfig, ... Blip2QFormerConfig, ... OPTConfig, ... Blip2Config, ... Blip2ForConditionalGeneration, ... ) >>> # Initializing a Blip2Config with Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2Config() >>> # Initializing a Blip2ForConditionalGeneration (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> # We can also initialize a Blip2Config from a Blip2VisionConfig, Blip2QFormerConfig and any PreTrainedConfig >>> # Initializing BLIP-2 vision, BLIP-2 Q-Former and language model configurations >>> vision_config = Blip2VisionConfig() >>> qformer_config = Blip2QFormerConfig() >>> text_config = OPTConfig() >>> config = Blip2Config(vision_config=vision_config, qformer_config=qformer_config, text_config=text_config) ``` ## Blip2VisionConfig[[transformers.Blip2VisionConfig]] #### transformers.Blip2VisionConfig[[transformers.Blip2VisionConfig]] ```python transformers.Blip2VisionConfig(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 = 1408, intermediate_size: int = 6144, num_hidden_layers: int = 39, num_attention_heads: int = 16, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 14, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L29) **Tham số:** hidden_size (`int`, *tuỳ chọn*, mặc định là `1408`) : Kích thước của các biểu diễn ẩn. intermediate_size (`int`, *tuỳ chọn*, mặc định là `6144`) : Kích thước của các biểu diễn MLP. num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `39`) : 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. image_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `224`) : 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. hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v. layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization). attention_dropout (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý. initializer_range (`float`, *optional*, mặc định là `1e-10`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số. qkv_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm bias vào queries, keys và values hay không. Đây là lớp cấu hình để lưu trữ cấu hình của một Mô hình Blip 2. Nó được sử dụng để khởi tạo một mô hình Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import Blip2VisionConfig, Blip2VisionModel >>> # Initializing a Blip2VisionConfig with Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2VisionConfig() >>> # Initializing a Blip2VisionModel (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2VisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Blip2QFormerConfig[[transformers.Blip2QFormerConfig]] #### transformers.Blip2QFormerConfig[[transformers.Blip2QFormerConfig]] ```python transformers.Blip2QFormerConfig(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 = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, cross_attention_frequency: int = 2, encoder_hidden_size: int = 1408, use_qformer_text_input: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/configuration_blip_2.py#L64) **Tham số:** vocab_size (`int`, *tùy chọn*, mặc định là `30522`) : 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`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn. num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer. num_attention_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer. intermediate_size (`int`, *tuỳ chọn*, mặc định là `3072`) : Kích thước của các biểu diễn MLP. 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. hidden_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler. attention_probs_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý. max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `512`) : Độ 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ố. layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-12`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization). pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng. cross_attention_frequency (`int`, *tuỳ chọn*, mặc định là 2) : Tần suất thêm cross-attention vào các lớp Transformer. encoder_hidden_size (`int`, *tuỳ chọn*, mặc định là `1408`) : Kích thước của các biểu diễn ẩn. use_qformer_text_input (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng nhúng kiểu BERT hay không. Đây là lớp cấu hình để lưu trữ cấu hình của một Mô hình Blip 2. Nó được sử dụng để khởi tạo một mô hình Blip 2 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 [Salesforce/blip2-opt-2.7b](https://huggingface.co/Salesforce/blip2-opt-2.7b) Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import Blip2QFormerConfig, Blip2QFormerModel >>> # Initializing a BLIP-2 Salesforce/blip2-opt-2.7b style configuration >>> configuration = Blip2QFormerConfig() >>> # Initializing a model (with random weights) from the Salesforce/blip2-opt-2.7b style configuration >>> model = Blip2QFormerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Blip2Processor[[transformers.Blip2Processor]] #### transformers.Blip2Processor[[transformers.Blip2Processor]] ```python transformers.Blip2Processor(image_processor, tokenizer, num_query_tokens = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/processing_blip_2.py#L45) **Tham số:** image_processor (`BlipImageProcessor`) : Bộ xử lý ảnh là một đầu vào bắt buộc. tokenizer (`GPT2Tokenizer`) : Tokenizer là một đầu vào bắt buộc. num_query_tokens (`int`, *optional*) : Số lượng token được Qformer sử dụng làm truy vấn, phải giống với cấu hình của mô hình. Tạo một Blip2Processor đóng gói một bộ xử lý ảnh và một tokenizer thành một bộ xử lý duy nhất. [Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) cung cấp đầy đủ các chức năng của [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) và [GPT2Tokenizer](/docs/transformers/main/vi/model_doc/gpt2#transformers.GPT2Tokenizer). Xem [~BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) và [~GPT2Tokenizer](/docs/transformers/main/vi/model_doc/gpt2#transformers.GPT2Tokenizer) để biết thêm thông tin. #### __call__[[transformers.Blip2Processor.__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] | None = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/processing_blip_2.py#L61) **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]]`, *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 đã được tách token trước, hãy đặt `is_split_into_words=True` để tránh nhầm lẫn với các đầu vào dạng lô. return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là: - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy. - ****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ợ. **Trả về:** `~tokenization_utils_base.BatchEncoding` - **data** (`dict`, *tuỳ chọn*) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi các phương thức `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', v.v.). - **encoding** (`tokenizers.Encoding` hoặc `Sequence[tokenizers.Encoding]`, *tùy chọn*) -- Nếu tokenizer là fast tokenizer có xuất ra thêm thông tin như ánh xạ từ không gian từ/ký tự sang không gian token thì instance `tokenizers.Encoding` hoặc danh sách các instance (cho các batch) sẽ chứa thông tin này. - **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạo. - **prepend_batch_axis** (`bool`, *tùy chọn*, mặc định là `False`) -- Có thêm một trục batch khi chuyển đổi sang tensor hay không (xem `tensor_type` ở trên). Lưu ý rằng tham số này có hiệu lực nếu tham số `tensor_type` được đặt, *ngược lại thì không có hiệu lực*. - **n_sequences** (`int`, *tùy chọn*) -- Số lượng chuỗi đầu vào được biểu diễn bởi mỗi mã hóa (`None` cho trường hợp không xác định, `1` cho một chuỗi đơn và `2` cho một cặp chuỗi). ## Blip2VisionModel[[transformers.Blip2VisionModel]] #### transformers.Blip2VisionModel[[transformers.Blip2VisionModel]] ```python transformers.Blip2VisionModel(config: Blip2VisionConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L481) **Tham số:** config ([Blip2VisionConfig](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2VisionConfig)) : 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 Blip 2 cơ bản, xuất ra các hidden-state 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.Blip2VisionModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L501) **Tham số:** pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. **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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2VisionModel](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2VisionModel) 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. - **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. ## Blip2QFormerModel[[transformers.Blip2QFormerModel]] #### transformers.Blip2QFormerModel[[transformers.Blip2QFormerModel]] ```python transformers.Blip2QFormerModel(config: Blip2QFormerConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L848) **Tham số:** config ([Blip2QFormerConfig](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2QFormerConfig)) : 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. BLIP-2 Querying Transformer (Q-Former). 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.Blip2QFormerModel.forward]] ```python forward(query_embeds: Tensor, query_length: int | None = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L885) **Tham số:** query_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) : Trạng thái ẩn (hidden states) được sử dụng trong phép tính chú ý (attention). Nếu là cross-attention, sẽ được dùng cho query (tức là key và value sẽ sử dụng encoder_hidden_states). query_length (`int`, *optional*) : Độ dài của truy vấn, thường dựa trên số lượng token truy vấn. Nếu không cung cấp giá trị, query_length sẽ được suy ra từ query_embeds. 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) encoder_hidden_states (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention nếu mô hình được cấu hình như một decoder. encoder_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ủa đầu vào bộ mã hóa. Mặt nạ này được sử dụng trong chú ý chéo nếu mô hình được cấu hình như một bộ giải 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**. **Trả về:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) hoặc `tuple(torch.Tensor)` Một [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2QFormerModel](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2QFormerModel) 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. - **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. - **cross_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` và `config.add_cross_attention=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ú ý của lớp cross-attention của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo. - **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ự. ## Blip2Model[[transformers.Blip2Model]] #### transformers.Blip2Model[[transformers.Blip2Model]] ```python transformers.Blip2Model(config: Blip2Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L957) **Tham số:** config ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) : 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 BLIP-2 để tạo ra văn bản và đặc trưng hình ảnh. Mô hình bao gồm một bộ mã hóa thị giác, Querying Transformer (Q-Former) và một mô hình ngôn ngữ. 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.Blip2Model.forward]] ```python forward(pixel_values: Tensor, input_ids: Tensor, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1152) **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 cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). input_ids (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong 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 thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) attention_mask (`torch.LongTensor` 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) decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng. Các chỉ số có thể được lấy 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. [Các ID đầu vào của bộ giải mã là gì?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Hành vi mặc định: tạo một tensor bỏ qua các token pad trong `decoder_input_ids`. Causal mask cũng sẽ được sử dụng theo mặc định. Chỉ liên quan trong trường hợp sử dụng mô hình ngôn ngữ encoder-decoder (như T5). 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]`. interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. **Trả về:** `Blip2ForConditionalGenerationModelOutput` hoặc `tuple(torch.Tensor)` Một `Blip2ForConditionalGenerationModelOutput` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2Model](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Model) 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`, *optional*, được trả về khi `labels` được cung cấp, `torch.Tensor` có hình dạng `(1,)`) -- Tổn mô hình hóa ngôn ngữ từ mô hình ngôn ngữ. - **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 ngôn ngữ (language modeling head) của mô hình ngôn ngữ. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của bộ mã hóa thị giác. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *tùy chọn*) -- Đầu ra của Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` hoặc `Seq2SeqLMOutput`) -- Đầu ra của mô hình ngôn ngữ. Ví dụ: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import Blip2Processor, Blip2Model >>> import torch >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b", dtype=torch.float16) >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> prompt = "Question: how many cats are there? Answer:" >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device, torch.float16) >>> outputs = model(**inputs) ``` #### get_text_features[[transformers.Blip2Model.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L994) **Tham số:** input_ids (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong 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 thêm chi tiết. [Input IDs 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) decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào bộ giải mã trong từ vựng. Các chỉ số có thể được lấy 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. [Decoder input IDs là gì?](../glossary#decoder-input-ids) T5 sử dụng `pad_token_id` làm token bắt đầu cho việc tạo `decoder_input_ids`. Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_input_ids` cuối cùng (xem `past_key_values`). Để biết thêm về cách chuẩn bị `decoder_input_ids` cho huấn luyện trước, hãy xem [T5 Training](./t5#training). decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Hành vi mặc định: tạo một tensor bỏ qua các token pad trong `decoder_input_ids`. Causal mask cũng sẽ được sử dụng theo mặc định. labels (`torch.Tensor` có shape `(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ó che (masked language modeling loss). 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 (che), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`. **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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. - **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 >>> import torch >>> from transformers import AutoTokenizer, Blip2Model >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/blip2-opt-2.7b") >>> inputs = tokenizer(["a photo of a cat"], padding=True, return_tensors="pt") >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.Blip2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1056) **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 cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. **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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. - **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 >>> import torch >>> from transformers import AutoProcessor, Blip2Model >>> from transformers.image_utils import load_image >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_outputs = model.get_image_features(**inputs) ``` #### get_qformer_features[[transformers.Blip2Model.get_qformer_features]] ```python get_qformer_features(pixel_values: Tensor, interpolate_pos_encoding: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1087) **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 cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. **Trả về:** qformer_outputs (`torch.Tensor`) Trạng thái ẩn của lớp cuối cùng của mô hình Q-Former. Ví dụ: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2Model >>> from transformers.image_utils import load_image >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... qformer_outputs = model.get_qformer_features(**inputs) ``` ## Blip2ForConditionalGeneration[[transformers.Blip2ForConditionalGeneration]] #### transformers.Blip2ForConditionalGeneration[[transformers.Blip2ForConditionalGeneration]] ```python transformers.Blip2ForConditionalGeneration(config: Blip2Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1460) **Tham số:** config ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) : 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 BLIP-2 để tạo văn bản dựa trên một hình ảnh và một prompt văn bản tùy chọn. Mô hình bao gồm một bộ mã hóa thị giác, Querying Transformer (Q-Former) và một mô hình ngôn ngữ. Người dùng có thể tùy chọn truyền `input_ids` vào mô hình, đóng vai trò là một prompt văn bản, để mô hình ngôn ngữ tiếp tục prompt đó. Nếu không, mô hình ngôn ngữ sẽ bắt đầu tạo văn bản từ token [BOS] (beginning-of-sequence). Lưu ý rằng các checkpoint của Flan-T5 không thể được chuyển sang float16. Chúng được huấn luyện trước bằng bfloat16. 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.Blip2ForConditionalGeneration.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1587) **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 cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). input_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào thuộc từ vựng của mô hình ngôn ngữ. Các token đầu vào có thể được cung cấp tùy chọn để đóng vai trò là văn bản gợi ý, mà mô hình ngôn ngữ có thể tiếp tục. Các chỉ số có thể được lấy bằng cách sử dụng [Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor). Xem [Blip2Processor.__call__()](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor.__call__) để biết chi tiết. [Các ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.LongTensor` 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) decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng. Các chỉ số có thể được lấy 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. [Các ID đầu vào của bộ giải mã là gì?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Hành vi mặc định: tạo một tensor bỏ qua các token pad trong `decoder_input_ids`. Causal mask cũng sẽ được sử dụng theo mặc định. Chỉ liên quan trong trường hợp sử dụng mô hình ngôn ngữ encoder-decoder (như T5). 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]`. interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. 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ề:** `Blip2ForConditionalGenerationModelOutput` hoặc `tuple(torch.Tensor)` Một `Blip2ForConditionalGenerationModelOutput` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2ForConditionalGeneration](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2ForConditionalGeneration) 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`, *optional*, được trả về khi `labels` được cung cấp, `torch.Tensor` có hình dạng `(1,)`) -- Tổn mô hình hóa ngôn ngữ từ mô hình ngôn ngữ. - **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 ngôn ngữ (language modeling head) của mô hình ngôn ngữ. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của bộ mã hóa thị giác. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *tùy chọn*) -- Đầu ra của Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` hoặc `Seq2SeqLMOutput`) -- Đầu ra của mô hình ngôn ngữ. Ví dụ: Chuẩn bị bộ xử lý, mô hình và đầu vào hình ảnh ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import Blip2Processor, Blip2ForConditionalGeneration >>> import torch >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> model = Blip2ForConditionalGeneration.from_pretrained( ... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, dtype=torch.float16 ... ) # doctest: +IGNORE_RESULT >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) ``` Đóng vai trò chú thích cho hình ảnh (không cung cấp lời nhắc văn bản): ```python >>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two cats laying on a couch ``` Trả lời câu hỏi bằng hình ảnh (prompt = câu hỏi): ```python >>> prompt = "Question: how many cats are there? Answer:" >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.float16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two ``` Lưu ý rằng suy luận int8 cũng được hỗ trợ thông qua [bitsandbytes](https://github.com/TimDettmers/bitsandbytes). Điều này giảm đáng kể lượng bộ nhớ mà mô hình sử dụng trong khi vẫn duy trì hiệu suất như nhau. ```python >>> model = Blip2ForConditionalGeneration.from_pretrained( ... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, dtype=torch.bfloat16 ... ) # doctest: +IGNORE_RESULT >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.bfloat16) >>> generated_ids = model.generate(**inputs) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip() >>> print(generated_text) two ``` #### generate[[transformers.Blip2ForConditionalGeneration.generate]] ```python generate(pixel_values: Tensor, input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **generate_kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1738) **Tham số:** pixel_values (`torch.Tensor` có shape (batch_size, num_channels, height, width)) : Ảnh đầu vào cần được xử lý. input_ids (`torch.LongTensor` có shape (batch_size, sequence_length), *tùy chọn*) : Chuỗi được sử dụng làm prompt cho quá trình sinh. attention_mask (`torch.LongTensor` có shape (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 inputs_embeds (`torch.Tensor` có shape `(batch_size, sequence_length, hidden_size)`) : Đại diện nhúng của các đầu vào. Phải là float, không phải token int. interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy mã hóa vị trí của các nhúng hình ảnh hay không. **Trả về:** `captions (list)` Một danh sách các chuỗi có độ dài batch_size * num_captions. Ghi đè hàm `generate` để có thể sử dụng mô hình như một bộ tạo có điều kiện. #### get_image_features[[transformers.Blip2ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, interpolate_pos_encoding: bool | None = False, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1519) **Tham số:** pixel_values (`torch.Tensor` có hình dạng `(batch_size, num_channels, image_size, image_size)`) : Các tensor tương ứng với các hình ảnh đầu vào. interpolate_pos_encoding (`bool`, *tùy chọn*, mặc định là `False`) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không. **Trả về:** `BaseModelOutputWithVisionQformerOutputs` hoặc `tuple(torch.Tensor)` Một `BaseModelOutputWithVisionQformerOutputs` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. - **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. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của bộ mã hóa thị giác. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *tùy chọn*) -- Đầu ra của Q-Former (Querying Transformer). Ví dụ: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Blip2ForConditionalGeneration >>> model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b") >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b") >>> 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] ``` ## Blip2ForImageTextRetrieval[[transformers.Blip2ForImageTextRetrieval]] #### transformers.Blip2ForImageTextRetrieval[[transformers.Blip2ForImageTextRetrieval]] ```python transformers.Blip2ForImageTextRetrieval(config: Blip2Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1832) **Tham số:** config ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) : 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 BLIP-2 với bộ dự phóng hình ảnh và văn bản, cùng một đầu phân loại phía trên. Mô hình được sử dụng trong ngữ cảnh truy xuất hình ảnh-văn bản. Cho một hình ảnh và một đoạn văn bản, mô hình trả về xác suất đoạn văn bản đó liên quan đến hình ảnh. 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.Blip2ForImageTextRetrieval.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, use_image_text_matching_head: bool | None = False, 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/blip_2/modeling_blip_2.py#L1866) **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 cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). input_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào thuộc từ vựng của mô hình ngôn ngữ. Các token đầu vào có thể được cung cấp tùy chọn để đóng vai trò là văn bản gợi ý, mà mô hình ngôn ngữ có thể tiếp tục. Các chỉ số có thể được lấy bằng cách sử dụng [Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor). Xem [Blip2Processor.__call__()](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor.__call__) để biết chi tiết. [Các ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.LongTensor` 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) use_image_text_matching_head (`bool`, *tuỳ chọn*) : Có trả về điểm Image-Text Matching hoặc điểm Contrastive hay không. 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. **Trả về:** `Blip2ImageTextMatchingModelOutput` hoặc `tuple(torch.Tensor)` Một `Blip2ImageTextMatchingModelOutput` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2ForImageTextRetrieval](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2ForImageTextRetrieval) 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,)`, *tuỳ chọn*, được trả về khi `return_loss` là `True`) -- Mất tương phản cho độ tương đồng giữa ảnh và văn bản. - **logits_per_image** (`torch.Tensor` có hình dạng `(image_batch_size, text_batch_size)`) -- Điểm tích vô hướng có tỷ lệ giữa `image_embeds` và `text_embeds`. Đây là các điểm tương đồng giữa ảnh và văn bản. - **logits_per_text** (`torch.Tensor` có hình dạng `(text_batch_size, image_batch_size)`) -- Điểm tích vô hướng có trọng số giữa `text_embeds` và `image_embeds`. Đây là các điểm tương đồng giữa văn bản và hình ảnh. - **text_embeds** (`torch.Tensor` có hình dạng `(batch_size, output_dim`) -- Các vector nhúng văn bản thu được bằng cách áp dụng lớp chiếu lên đầu ra đã gộp (pooled output). - **image_embeds** (`torch.Tensor` có hình dạng `(batch_size, output_dim`) -- Các embedding hình ảnh thu được bằng cách áp dụng lớp chiếu lên đầu ra đã được pool. - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của [Blip2QFormerModel](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2QFormerModel). - **vision_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của [Blip2VisionModel](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2VisionModel). Ví dụ: ```python >>> import torch >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Blip2ForImageTextRetrieval >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> model = Blip2ForImageTextRetrieval.from_pretrained("Salesforce/blip2-itm-vit-g", dtype=torch.float16) >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> text = "two cats laying on a pink blanket" >>> inputs = processor(images=image, text=text, return_tensors="pt").to(device, torch.float16) >>> itm_out = model(**inputs, use_image_text_matching_head=True) >>> logits_per_image = torch.nn.functional.softmax(itm_out.logits_per_image, dim=1) >>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities >>> print(f"{probs[0][0]:.1%} that image 0 is not '{text}'") 26.9% that image 0 is not 'two cats laying on a pink blanket' >>> print(f"{probs[0][1]:.1%} that image 0 is '{text}'") 73.0% that image 0 is 'two cats laying on a pink blanket' >>> texts = ["a photo of a cat", "a photo of a dog"] >>> inputs = processor(images=image, text=texts, return_tensors="pt").to(device, torch.float16) >>> itc_out = model(**inputs, use_image_text_matching_head=False) >>> logits_per_image = itc_out.logits_per_image # this is the image-text similarity score >>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'") 55.3% that image 0 is 'a photo of a cat' >>> print(f"{probs[0][1]:.1%} that image 0 is '{texts[1]}'") 44.7% that image 0 is 'a photo of a dog' ``` ## Blip2TextModelWithProjection[[transformers.Blip2TextModelWithProjection]] #### transformers.Blip2TextModelWithProjection[[transformers.Blip2TextModelWithProjection]] ```python transformers.Blip2TextModelWithProjection(config: Blip2Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1274) **Tham số:** config ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) : 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 Blip 2 với một lớp chiếu (projection layer) ở trên (một lớp tuyến tính trên đầu ra đã được pool). 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.Blip2TextModelWithProjection.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1298) **Tham số:** input_ids (`torch.Tensor` 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 thêm 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.Tensor` có shape `(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 position embeddings. Được chọn trong khoảng `[0, config.n_positions - 1]`. [Position IDs là gì?](../glossary#position-ids) **Trả về:** `Blip2TextModelOutput` hoặc `tuple(torch.Tensor)` Một `Blip2TextModelOutput` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2TextModelWithProjection](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2TextModelWithProjection) 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. - **text_embeds** (`torch.Tensor` có shape `(batch_size, output_dim)` *tuỳ chọn*, được trả về khi model được khởi tạo với `with_projection=True`) -- Các text embeddings thu được bằng cách áp dụng lớp projection lên pooler_output. - **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình. - **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2TextModelWithProjection >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> model = Blip2TextModelWithProjection.from_pretrained( ... "Salesforce/blip2-itm-vit-g", dtype=torch.float16 ... ) >>> model.to(device) >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], return_tensors="pt").to(device) >>> outputs = model(**inputs) >>> text_embeds = outputs.text_embeds >>> print(text_embeds.shape) torch.Size([2, 7, 256]) ``` ## Blip2VisionModelWithProjection[[transformers.Blip2VisionModelWithProjection]] #### transformers.Blip2VisionModelWithProjection[[transformers.Blip2VisionModelWithProjection]] ```python transformers.Blip2VisionModelWithProjection(config: Blip2Config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1359) **Tham số:** config ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) : 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 Blip 2 với một lớp chiếu (projection layer) ở trên (một lớp tuyến tính trên đầu ra đã được pool). 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.Blip2VisionModelWithProjection.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/blip_2/modeling_blip_2.py#L1382) **Tham số:** pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor). Xem [BlipImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([Blip2Processor](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Processor) sử dụng [BlipImageProcessor](/docs/transformers/main/vi/model_doc/blip#transformers.BlipImageProcessor) để xử lý ảnh). **Trả về:** `Blip2VisionModelOutput` hoặc `tuple(torch.Tensor)` Một `Blip2VisionModelOutput` 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 ([Blip2Config](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2Config)) và đầu vào. Phương thức forward của [Blip2VisionModelWithProjection](/docs/transformers/main/vi/model_doc/blip-2#transformers.Blip2VisionModelWithProjection) ghi đè lên phương thức đặc biệt `__call__`. Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng. - **image_embeds** (`torch.Tensor` có shape `(batch_size, output_dim)` *tuỳ chọn*, được trả về khi model được khởi tạo với `with_projection=True`) -- Các embedding của ảnh thu được bằng cách áp dụng lớp projection lên pooler_output. - **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình. - **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple[torch.Tensor, ...]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> import torch >>> from transformers import AutoProcessor, Blip2VisionModelWithProjection >>> from transformers.image_utils import load_image >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g") >>> model = Blip2VisionModelWithProjection.from_pretrained( ... "Salesforce/blip2-itm-vit-g", dtype=torch.float16 ... ) >>> model.to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16) >>> with torch.inference_mode(): ... outputs = model(**inputs) >>> image_embeds = outputs.image_embeds >>> print(image_embeds.shape) torch.Size([1, 32, 256]) ```