Transformers 文件

CLIP

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

PyTorch TensorFlow Flax FlashAttention SDPA

CLIP

CLIP 是一個多模態視覺和語言模型,其動機是為了克服訓練計算機視覺模型時物件類別數量固定的問題。CLIP 透過對 4 億個(影像,文字)對進行聯合訓練,直接從原始文字中學習影像。這種規模的預訓練使其能夠零樣本遷移到下游任務。CLIP 使用影像編碼器和文字編碼器來獲取視覺特徵和文字特徵。這兩種特徵都被投影到具有相同維數的潛在空間中,它們的點積給出了相似度分數。

你可以在 OpenAI 組織下找到所有原始的 CLIP 檢查點。

點選右側邊欄中的 CLIP 模型,檢視更多如何將 CLIP 應用於不同影像和語言任務的示例。

下面的示例演示瞭如何使用 PipelineAutoModel 類來計算多個文字描述和一張影像之間的相似度分數。

流水線
自動模型
import torch
from transformers import pipeline

clip = pipeline(
   task="zero-shot-image-classification",
   model="openai/clip-vit-base-patch32",
   torch_dtype=torch.bfloat16,
   device=0
)
labels = ["a photo of a cat", "a photo of a dog", "a photo of a car"]
clip("http://images.cocodataset.org/val2017/000000039769.jpg", candidate_labels=labels)

注意

CLIPConfig

class transformers.CLIPConfig

< >

( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 **kwargs )

引數

  • text_config (dict, 可選) — 用於初始化 CLIPTextConfig 的配置選項字典。
  • vision_config (dict, 可選) — 用於初始化 CLIPVisionConfig 的配置選項字典。
  • projection_dim (int, 可選, 預設為 512) — 文字和視覺投影層的維度。
  • logit_scale_init_value (float, 可選, 預設為 2.6592) — logit_scale 引數的初始值。預設值根據原始 CLIP 實現使用。
  • kwargs (可選) — 關鍵字引數字典。

CLIPConfig 是用於儲存 CLIPModel 配置的配置類。它用於根據指定的引數例項化一個 CLIP 模型,定義文字模型和視覺模型配置。使用預設值例項化一個配置將產生與 CLIP openai/clip-vit-base-patch32 架構相似的配置。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。

示例

>>> from transformers import CLIPConfig, CLIPModel

>>> # Initializing a CLIPConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPConfig()

>>> # Initializing a CLIPModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPModel(configuration)

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

>>> # We can also initialize a CLIPConfig from a CLIPTextConfig and a CLIPVisionConfig
>>> from transformers import CLIPTextConfig, CLIPVisionConfig

>>> # Initializing a CLIPText and CLIPVision configuration
>>> config_text = CLIPTextConfig()
>>> config_vision = CLIPVisionConfig()

>>> config = CLIPConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

< >

( text_config: CLIPTextConfig vision_config: CLIPVisionConfig **kwargs ) CLIPConfig

返回

CLIPConfig

一個配置物件的例項

從 clip 文字模型配置和 clip 視覺模型配置例項化一個 CLIPConfig(或其派生類)。

CLIPTextConfig

class transformers.CLIPTextConfig

< >

( vocab_size = 49408 hidden_size = 512 intermediate_size = 2048 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )

引數

  • vocab_size (int, 可選, 預設為 49408) — CLIP 文字模型的詞彙表大小。定義了在呼叫 CLIPModel 時傳遞的 inputs_ids 可以表示的不同詞元的數量。
  • hidden_size (int, 可選, 預設為 512) — 編碼器層和池化層的維度。
  • intermediate_size (int, 可選, 預設為 2048) — Transformer 編碼器中“中間”層(即前饋層)的維度。
  • projection_dim (int, 可選, 預設為 512) — 文字和視覺投影層的維度。
  • num_hidden_layers (int, 可選, 預設為 12) — Transformer 編碼器中的隱藏層數量。
  • num_attention_heads (int, 可選, 預設為 8) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • max_position_embeddings (int, 可選, 預設為 77) — 該模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需(例如,512、1024 或 2048)。
  • hidden_act (strfunction, 可選, 預設為 "quick_gelu") — 編碼器和池化層中的非線性啟用函式(函式或字串)。如果為字串,則支援 "gelu""relu""selu""gelu_new""quick_gelu"
  • layer_norm_eps (float, 可選, 預設為 1e-05) — 層歸一化層使用的 epsilon 值。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力機率的 dropout 比例。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。
  • initializer_factor (float, 可選, 預設為 1.0) — 一個用於初始化所有權重矩陣的因子(應保持為 1,內部用於初始化測試)。
  • pad_token_id (int, 可選, 預設為 1) — 填充詞元 ID。
  • bos_token_id (int, 可選, 預設為 49406) — 序列開始詞元 ID。
  • eos_token_id (int, 可選, 預設為 49407) — 序列結束詞元 ID。

這是用於儲存 CLIPTextModel 配置的配置類。它用於根據指定的引數例項化一個 CLIP 文字編碼器,定義模型架構。使用預設值例項化一個配置將產生與 CLIP openai/clip-vit-base-patch32 架構的文字編碼器相似的配置。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。

示例

>>> from transformers import CLIPTextConfig, CLIPTextModel

>>> # Initializing a CLIPTextConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPTextConfig()

>>> # Initializing a CLIPTextModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPTextModel(configuration)

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

CLIPVisionConfig

class transformers.CLIPVisionConfig

< >

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )

引數

  • hidden_size (int, 可選, 預設為 768) — 編碼器層和池化層的維度。
  • intermediate_size (int, 可選, 預設為 3072) — Transformer 編碼器中“中間”層(即前饋層)的維度。
  • projection_dim (int, 可選, 預設為 512) — 文字和視覺投影層的維度。
  • num_hidden_layers (int, 可選, 預設為 12) — Transformer 編碼器中的隱藏層數量。
  • num_attention_heads (int, 可選, 預設為 12) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • num_channels (int, 可選, 預設為 3) — 輸入通道的數量。
  • image_size (int, 可選, 預設為 224) — 每個影像的尺寸(解析度)。
  • patch_size (int, 可選, 預設為 32) — 每個圖塊的尺寸(解析度)。
  • hidden_act (strfunction, 可選, 預設為 "quick_gelu") — 編碼器和池化層中的非線性啟用函式(函式或字串)。如果為字串,則支援 "gelu""relu""selu""gelu_new""quick_gelu"
  • layer_norm_eps (float, 可選, 預設為 1e-05) — 層歸一化層使用的 epsilon 值。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力機率的 dropout 比例。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。
  • initializer_factor (float, 可選, 預設為 1.0) — 一個用於初始化所有權重矩陣的因子(應保持為 1,內部用於初始化測試)。

這是用於儲存 CLIPVisionModel 配置的配置類。它用於根據指定的引數例項化一個 CLIP 視覺編碼器,定義模型架構。使用預設值例項化一個配置將產生與 CLIP openai/clip-vit-base-patch32 架構的視覺編碼器相似的配置。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。

示例

>>> from transformers import CLIPVisionConfig, CLIPVisionModel

>>> # Initializing a CLIPVisionConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPVisionConfig()

>>> # Initializing a CLIPVisionModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPVisionModel(configuration)

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

CLIPTokenizer

class transformers.CLIPTokenizer

< >

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|startoftext|>' eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

引數

  • vocab_file (str) — 詞彙表文件的路徑。
  • merges_file (str) — merges 檔案的路徑。
  • errors (str, 可選, 預設為 "replace") — 將位元組解碼為 UTF-8 時遵循的範例。有關更多資訊,請參閱 bytes.decode
  • unk_token (str, 可選, 預設為 "<|endoftext|>") — 未知詞元(token)。不在詞彙表中的詞元無法轉換為 ID,將被設定為此詞元。
  • bos_token (str, 可選, 預設為 "<|startoftext|>") — 序列開始詞元。
  • eos_token (str, 可選, 預設為 "<|endoftext|>") — 序列結束詞元。
  • pad_token (str, 可選, 預設為 "<|endoftext|>") — 用於填充的詞元,例如當批處理不同長度的序列時。

構建一個 CLIP 分詞器。基於位元組級的位元組對編碼(Byte-Pair-Encoding)。

此分詞器繼承自 PreTrainedTokenizer,其中包含大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

引數

  • token_ids_0 (list[int]) — 將要新增特殊詞元的 ID 列表。
  • token_ids_1 (list[int], 可選) — 用於序列對的可選的第二個 ID 列表。

返回

list[int]

帶有適當特殊標記的輸入ID列表。

透過連線和新增特殊詞元,從一個序列或一對序列中為序列分類任務構建模型輸入。CLIP 序列具有以下格式:

  • 單個序列:<|startoftext|> X <|endoftext|>

序列對不是預期的使用情況,但它們將在沒有分隔符的情況下被處理。

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) list[int]

引數

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可選) — 用於序列對的可選的第二個 ID 列表。
  • already_has_special_tokens (bool, 可選, 預設為 False) — 詞元列表是否已經為模型格式化了特殊詞元。

返回

list[int]

一個範圍為 [0, 1] 的整數列表:1 表示特殊標記,0 表示序列標記。

從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

引數

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可選) — 用於序列對的可選的第二個 ID 列表。

返回

list[int]

零列表。

從傳入的兩個序列建立掩碼。CLIP 不使用詞元型別 ID,因此返回一個零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

CLIPTokenizerFast

class transformers.CLIPTokenizerFast

< >

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|startoftext|>' eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

引數

  • vocab_file (str, 可選) — 詞彙表文件的路徑。
  • merges_file (str, 可選) — merges 檔案的路徑。
  • tokenizer_file (str, 可選) — 用來替代詞彙表文件的分詞器檔案的路徑。
  • unk_token (str, 可選, 預設為 "<|endoftext|>") — 未知詞元(token)。不在詞彙表中的詞元無法轉換為 ID,將被設定為此詞元。
  • bos_token (str, 可選, 預設為 "<|startoftext|>") — 序列開始詞元。
  • eos_token (str, 可選, 預設為 "<|endoftext|>") — 序列結束詞元。
  • pad_token (str, 可選, 預設為 "<|endoftext|>") — 用於填充的詞元,例如當批處理不同長度的序列時。

構建一個“快速”CLIP分詞器(由HuggingFace的*tokenizers*庫支援)。基於位元組級的位元組對編碼(Byte-Pair-Encoding)。

此分詞器繼承自 PreTrainedTokenizerFast,其中包含大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

引數

  • token_ids_0 (list[int]) — 將要新增特殊詞元的 ID 列表。
  • token_ids_1 (list[int], 可選) — 用於序列對的可選的第二個 ID 列表。

返回

list[int]

帶有適當特殊標記的輸入ID列表。

透過連線和新增特殊詞元,從一個序列或一對序列中為序列分類任務構建模型輸入。CLIP 序列具有以下格式:

  • 單個序列:<|startoftext|> X <|endoftext|>

序列對不是預期的使用情況,但它們將在沒有分隔符的情況下被處理。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

引數

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可選) — 用於序列對的可選的第二個 ID 列表。

返回

list[int]

零列表。

從傳入的兩個序列建立掩碼。CLIP 不使用詞元型別 ID,因此返回一個零列表。

CLIPImageProcessor

class transformers.CLIPImageProcessor

< >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: typing.Optional[dict[str, int]] = None do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_convert_rgb: bool = True **kwargs )

引數

  • do_resize (bool, 可選, 預設為 True) — 是否將影像的(高、寬)尺寸調整為指定的 size。可在 preprocess 方法中透過 `do_resize` 引數覆蓋。
  • size (dict[str, int] 可選, 預設為 {"shortest_edge" -- 224}): 調整大小後圖像的尺寸。影像的最短邊將調整為 size[“shortest_edge”],最長邊將相應調整以保持輸入影像的長寬比。可在 preprocess 方法中透過 `size` 引數覆蓋。
  • resample (PILImageResampling, 可選, 預設為 Resampling.BICUBIC) — 如果調整影像大小,則使用的重取樣濾波器。可在 preprocess 方法中透過 `resample` 引數覆蓋。
  • do_center_crop (bool, 可選, 預設為 True) — 是否對影像進行中心裁剪至指定的 crop_size。可在 preprocess 方法中透過 `do_center_crop` 引數覆蓋。
  • crop_size (dict[str, int] 可選, 預設為 224) — 應用 center_crop 後輸出影像的尺寸。可在 preprocess 方法中透過 `crop_size` 引數覆蓋。
  • do_rescale (bool, 可選, 預設為 True) — 是否透過指定的縮放因子 rescale_factor 來重新縮放影像。可在 preprocess 方法中透過 `do_rescale` 引數覆蓋。
  • rescale_factor (int or float, 可選, 預設為 1/255) — 如果重新縮放影像,則使用的縮放因子。可在 preprocess 方法中透過 `rescale_factor` 引數覆蓋。
  • do_normalize (bool, 可選, 預設為 True) — 是否對影像進行歸一化。可在 preprocess 方法中透過 `do_normalize` 引數覆蓋。
  • image_mean (floatlist[float], 可選, 預設為 [0.48145466, 0.4578275, 0.40821073]) — 如果對影像進行歸一化,則使用的均值。這是一個浮點數或浮點數列表,其長度等於影像中的通道數。可在 preprocess 方法中透過 image_mean 引數覆蓋。
  • image_std (floatlist[float], 可選, 預設為 [0.26862954, 0.26130258, 0.27577711]) — 如果對影像進行歸一化,則使用的標準差。這是一個浮點數或浮點數列表,其長度等於影像中的通道數。可在 preprocess 方法中透過 image_std 引數覆蓋。
  • do_convert_rgb (bool, 可選, 預設為 True) — 是否將影像轉換為 RGB。

構建一個 CLIP 影像處理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None do_center_crop: typing.Optional[bool] = None crop_size: typing.Optional[int] = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_convert_rgb: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None **kwargs )

引數

  • images (ImageInput) — 要預處理的影像。期望單個或一批影像,其畫素值範圍為 0 到 255。如果傳入的影像畫素值在 0 到 1 之間,請設定 `do_rescale=False`。
  • do_resize (bool, 可選, 預設為 self.do_resize) — 是否調整影像大小。
  • size (dict[str, int], 可選, 預設為 self.size) — 調整大小後圖像的尺寸。影像的最短邊將調整為 size[“shortest_edge”],最長邊將相應調整以保持輸入影像的長寬比。
  • resample (int, 可選, 預設為 self.resample) — 如果調整影像大小,則使用的重取樣濾波器。這可以是列舉 PILImageResampling 之一。僅當 do_resize 設定為 True 時有效。
  • do_center_crop (bool, 可選, 預設為 self.do_center_crop) — 是否對影像進行中心裁剪。
  • crop_size (dict[str, int], 可選, 預設為 self.crop_size) — 中心裁剪的尺寸。僅當 do_center_crop 設定為 True 時有效。
  • do_rescale (bool, 可選, 預設為 self.do_rescale) — 是否重新縮放影像。
  • rescale_factor (float, 可選, 預設為 self.rescale_factor) — 如果 do_rescale 設定為 True,則用於重新縮放影像的縮放因子。
  • do_normalize (bool, 可選, 預設為 self.do_normalize) — 是否對影像進行歸一化。
  • image_mean (floatlist[float], 可選, 預設為 self.image_mean) — 用於歸一化的影像均值。僅當 do_normalize 設定為 True 時有效。
  • image_std (floatlist[float], 可選, 預設為 self.image_std) — 用於歸一化的影像標準差。僅在 do_normalize 設定為 True 時生效。
  • do_convert_rgb (bool, 可選, 預設為 self.do_convert_rgb) — 是否將影像轉換為 RGB 格式。
  • return_tensors (strTensorType, 可選) — 返回張量的型別。可以是以下之一:
    • 未設定:返回一個 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf':返回一個 tf.Tensor 型別的批次。
    • TensorType.PYTORCH'pt':返回一個 torch.Tensor 型別的批次。
    • TensorType.NUMPY'np':返回一個 np.ndarray 型別的批次。
    • TensorType.JAX'jax':返回一個 jax.numpy.ndarray 型別的批次。
  • data_format (ChannelDimensionstr, 可選, 預設為 ChannelDimension.FIRST) — 輸出影像的通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:影像格式為 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:影像格式為 (height, width, num_channels)。
    • 未設定:使用輸入影像的通道維度格式。
  • input_data_format (ChannelDimensionstr, 可選) — 輸入影像的通道維度格式。如果未設定,則從輸入影像中推斷通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:影像格式為 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:影像格式為 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:影像格式為 (height, width)。

預處理一張或一批影像。

CLIPImageProcessorFast

class transformers.CLIPImageProcessorFast

< >

( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )

構建一個快速 Clip 影像處理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] *args **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] ) <class 'transformers.image_processing_base.BatchFeature'>

引數

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 待預處理的影像。可以是單個影像或一批影像,畫素值範圍為 0 到 255。如果傳入的影像畫素值在 0 到 1 之間,請設定 do_rescale=False
  • do_resize (bool, 可選) — 是否調整影像大小。
  • size (dict[str, int], 可選) — 描述模型的最大輸入尺寸。
  • default_to_square (bool, 可選) — 如果 `size` 是一個整數,在調整大小時是否預設為方形影像。
  • resample (Union[PILImageResampling, F.InterpolationMode, NoneType]) — 如果調整影像大小,使用的重取樣過濾器。可以是 PILImageResampling 列舉之一。僅在 do_resize 設定為 True 時生效。
  • do_center_crop (bool, 可選) — 是否對影像進行中心裁剪。
  • crop_size (dict[str, int], 可選) — 應用 center_crop 後輸出影像的尺寸。
  • do_rescale (bool, 可選) — 是否對影像進行縮放。
  • rescale_factor (Union[int, float, NoneType]) — 如果 do_rescale 設定為 True,用於縮放影像的比例因子。
  • do_normalize (bool, 可選) — 是否對影像進行歸一化。
  • image_mean (Union[float, list[float], NoneType]) — 用於歸一化的影像均值。僅在 do_normalize 設定為 True 時生效。
  • image_std (Union[float, list[float], NoneType]) — 用於歸一化的影像標準差。僅在 do_normalize 設定為 True 時生效。
  • do_convert_rgb (bool, 可選) — 是否將影像轉換為 RGB 格式。
  • return_tensors (Union[str, ~utils.generic.TensorType, NoneType]) — 如果設定為 `pt`,則返回堆疊的張量,否則返回張量列表。
  • data_format (~image_utils.ChannelDimension, 可選) — 僅支援 ChannelDimension.FIRST。為與慢速處理器相容而新增。
  • input_data_format (Union[str, ~image_utils.ChannelDimension, NoneType]) — 輸入影像的通道維度格式。如果未設定,則從輸入影像中推斷通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:影像格式為 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:影像格式為 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:影像格式為 (height, width)。
  • device (torch.device, 可選) — 處理影像的裝置。如果未設定,則從輸入影像中推斷裝置。
  • disable_grouping (bool, 可選) — 是否停用按尺寸對影像進行分組,以便單獨處理而不是批次處理。如果為 None,則在影像位於 CPU 上時設定為 True,否則設定為 False。此選擇基於經驗觀察,詳情請見:https://github.com/huggingface/transformers/pull/38157

返回

<class 'transformers.image_processing_base.BatchFeature'>

  • data (dict) — 由 call 方法返回的列表/陣列/張量字典(“pixel_values”等)。
  • tensor_type (Union[None, str, TensorType], 可選) — 您可以在此處提供一個`tensor_type`,以便在初始化時將整數列表轉換為PyTorch/TensorFlow/Numpy張量。

CLIPFeatureExtractor

class transformers.CLIPFeatureExtractor

< >

( *args **kwargs )

CLIPProcessor

class transformers.CLIPProcessor

< >

( image_processor = None tokenizer = None **kwargs )

引數

構建一個 CLIP 處理器,它將 CLIP 影像處理器和 CLIP 分詞器包裝成一個單一的處理器。

CLIPProcessor 提供了 CLIPImageProcessorCLIPTokenizerFast 的所有功能。更多資訊請參見 __call__()decode()

batch_decode

< >

( *args **kwargs )

此方法將其所有引數轉發給 CLIPTokenizerFast 的 batch_decode()。更多資訊請參考該方法的文件字串。

decode

< >

( *args **kwargs )

此方法將其所有引數轉發給 CLIPTokenizerFast 的 decode()。有關更多資訊,請參閱此方法的文件字串。

Pytorch
隱藏 Pytorch 內容

CLIPModel

class transformers.CLIPModel

< >

( config: CLIPConfig )

引數

  • config (CLIPConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

基礎 Clip 模型,輸出原始的隱藏狀態,頂部沒有任何特定的頭部。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.models.clip.modeling_clip.CLIPOutputtuple(torch.FloatTensor)

引數

  • input_ids (torch.LongTensor,形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • pixel_values (torch.FloatTensor,形狀為 (batch_size, num_channels, image_size, image_size), 可選) — 對應於輸入影像的張量。可以使用 {image_processor_class} 獲取畫素值。有關詳細資訊,請參見 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 處理影像)。
  • attention_mask (torch.Tensor,形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示**未被掩碼**的標記,
    • 0 表示**被掩碼**的標記。

    什麼是注意力掩碼?

  • position_ids (torch.LongTensor,形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置 ID?

  • return_loss (bool, 可選) — 是否返回對比損失。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參見返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參見返回張量下的 hidden_states
  • interpolate_pos_encoding (bool, 預設為 False) — 是否對預訓練的位置編碼進行插值。

返回

transformers.models.clip.modeling_clip.CLIPOutputtuple(torch.FloatTensor)

一個 transformers.models.clip.modeling_clip.CLIPOutput 或一個 `torch.FloatTensor` 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置 (CLIPConfig) 和輸入包含各種元素。

  • loss (torch.FloatTensor,形狀為 (1,), 可選, 當 return_lossTrue 時返回) — 影像-文字相似度的對比損失。
  • logits_per_image (torch.FloatTensor,形狀為 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之間的縮放點積得分。這表示影像-文字相似度分數。
  • logits_per_text (torch.FloatTensor,形狀為 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之間的縮放點積得分。這表示文字-影像相似度分數。
  • text_embeds (torch.FloatTensor,形狀為 (batch_size, output_dim)) — 將投影層應用於 CLIPTextModel 的池化輸出所獲得的文字嵌入。
  • image_embeds (torch.FloatTensor,形狀為 (batch_size, output_dim)) — 將投影層應用於 CLIPVisionModel 的池化輸出所獲得的影像嵌入。
  • text_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output, 預設為 None) — CLIPTextModel 的輸出。
  • vision_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.vision_model_output, 預設為 None) — CLIPVisionModel 的輸出。

CLIPModel 的 forward 方法覆蓋了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, CLIPModel

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.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

get_text_features

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) text_features (torch.FloatTensor,形狀為 (batch_size, output_dim))

引數

  • input_ids (torch.Tensor,形狀為 (batch_size, sequence_length), 可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (torch.Tensor,形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 [0, 1] 中選擇:

    • 1 表示**未被掩碼**的標記,
    • 0 表示**被掩碼**的標記。

    什麼是注意力掩碼?

  • position_ids (torch.Tensor,形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 範圍內選擇。

    什麼是位置 ID?

  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參見返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參見返回張量下的 hidden_states

返回

text_features (torch.FloatTensor, 形狀為 (batch_size, output_dim)

將投影層應用於 CLIPTextModel 的池化輸出所獲得的文字嵌入。

示例

>>> from transformers import AutoTokenizer, CLIPModel

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_image_features

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) image_features (形狀為 `(batch_size, output_dim)` 的 `torch.FloatTensor`)

引數

  • pixel_values (形狀為 `(batch_size, num_channels, image_size, image_size)` 的 `torch.FloatTensor`,可選) — 對應於輸入影像的張量。畫素值可以使用 `{image_processor_class}` 獲取。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。
  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。
  • interpolate_pos_encoding (`bool` 型別,預設為 `False`) — 是否對預訓練的位置編碼進行插值。

返回

image_features (torch.FloatTensor, 形狀為 (batch_size, output_dim)

將投影層應用於 CLIPVisionModel 的池化輸出所獲得的影像嵌入。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, CLIPModel

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> image_features = model.get_image_features(**inputs)

CLIPTextModel

class transformers.CLIPTextModel

< >

( config: CLIPTextConfig )

引數

  • config (CLIPTextConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

來自 CLIP 的文字模型,頂部沒有任何頭或投影。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.BaseModelOutputWithPooling 或 `tuple(torch.FloatTensor)`

引數

  • input_ids (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 詞彙表中輸入序列標記的索引。預設情況下將忽略填充。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.__call__()

    什麼是輸入 ID?

  • attention_mask (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示標記未被遮蓋
    • 0 表示標記被遮蓋

    什麼是注意力掩碼?

  • position_ids (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 範圍內選擇。

    什麼是位置 ID?

  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithPooling 或一個 `torch.FloatTensor` 的元組(如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時),根據配置(CLIPConfig)和輸入,包含各種元素。

  • last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (形狀為 `(batch_size, hidden_size)` 的 `torch.FloatTensor`) — 序列的第一個標記(分類標記)的最後一層隱藏狀態,經過用於輔助預訓練任務的層進一步處理。例如,對於 BERT 家族模型,這返回經過線性層和 tanh 啟用函式處理後的分類標記。線性層權重是在預訓練期間從下一句預測(分類)目標中訓練的。

  • hidden_states (`tuple(torch.FloatTensor)` 型別,可選,當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組(如果模型有嵌入層,則一個用於嵌入層的輸出,+ 每個層一個用於輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (`tuple(torch.FloatTensor)` 型別,可選,當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

CLIPTextModel 的前向方法,覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, CLIPTextModel

>>> model = CLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

CLIPTextModelWithProjection

class transformers.CLIPTextModelWithProjection

< >

( config: CLIPTextConfig )

引數

  • config (CLIPTextConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

頂部帶有一個投影層的 Clip 模型(池化輸出頂部的一個線性層)。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) `transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或 `tuple(torch.FloatTensor)`

引數

  • input_ids (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 詞彙表中輸入序列標記的索引。預設情況下將忽略填充。

    可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.__call__()

    什麼是輸入 ID?

  • attention_mask (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇:

    • 1 表示標記未被遮蓋
    • 0 表示標記被遮蓋

    什麼是注意力掩碼?

  • position_ids (形狀為 `(batch_size, sequence_length)` 的 `torch.Tensor`,可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 範圍內選擇。

    什麼是位置 ID?

  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。

返回

`transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或 `tuple(torch.FloatTensor)`

一個 `transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或一個 `torch.FloatTensor` 的元組(如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時),根據配置(CLIPConfig)和輸入,包含各種元素。

  • text_embeds (形狀為 `(batch_size, output_dim)` 的 `torch.FloatTensor`,可選,當模型以 `with_projection=True` 初始化時返回) — 透過將投影層應用於 pooler_output 獲得的文字嵌入。

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)torch.FloatTensor, 可選,預設為 None) — 模型最後一層輸出的隱藏狀態序列。

  • hidden_states (`tuple[torch.FloatTensor, ...]` 型別,可選,當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組(如果模型有嵌入層,則一個用於嵌入層的輸出,+ 每個層一個用於輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (`tuple[torch.FloatTensor, ...]` 型別,可選,當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

CLIPTextModelWithProjection 的前向方法,覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, CLIPTextModelWithProjection

>>> model = CLIPTextModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

CLIPVisionModelWithProjection

class transformers.CLIPVisionModelWithProjection

< >

( config: CLIPVisionConfig )

引數

  • config (CLIPVisionConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

頂部帶有一個投影層的 Clip 模型(池化輸出頂部的一個線性層)。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) `transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或 `tuple(torch.FloatTensor)`

引數

  • pixel_values (形狀為 `(batch_size, num_channels, image_size, image_size)` 的 `torch.FloatTensor`,可選) — 對應於輸入影像的張量。畫素值可以使用 `{image_processor_class}` 獲取。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。
  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。
  • interpolate_pos_encoding (`bool` 型別,預設為 `False`) — 是否對預訓練的位置編碼進行插值。

返回

`transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或 `tuple(torch.FloatTensor)`

一個 `transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或一個 `torch.FloatTensor` 的元組(如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時),根據配置(CLIPConfig)和輸入,包含各種元素。

  • image_embeds (形狀為 `(batch_size, output_dim)` 的 `torch.FloatTensor`,可選,當模型以 `with_projection=True` 初始化時返回) — 透過將投影層應用於 pooler_output 獲得的影像嵌入。

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)torch.FloatTensor, 可選,預設為 None) — 模型最後一層輸出的隱藏狀態序列。

  • hidden_states (`tuple[torch.FloatTensor, ...]` 型別,可選,當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組(如果模型有嵌入層,則一個用於嵌入層的輸出,+ 每個層一個用於輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (`tuple[torch.FloatTensor, ...]` 型別,可選,當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

CLIPVisionModelWithProjection 的前向方法,覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, CLIPVisionModelWithProjection

>>> model = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> image_embeds = outputs.image_embeds

CLIPVisionModel

class transformers.CLIPVisionModel

< >

( config: CLIPVisionConfig )

引數

  • config (CLIPVisionConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

來自 CLIP 的視覺模型,頂部沒有任何頭或投影。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPooling 或 `tuple(torch.FloatTensor)`

引數

  • pixel_values (形狀為 `(batch_size, num_channels, image_size, image_size)` 的 `torch.FloatTensor`,可選) — 對應於輸入影像的張量。畫素值可以使用 `{image_processor_class}` 獲取。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。
  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。
  • interpolate_pos_encoding (`bool` 型別,預設為 `False`) — 是否對預訓練的位置編碼進行插值。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithPooling 或一個 `torch.FloatTensor` 的元組(如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時),根據配置(CLIPConfig)和輸入,包含各種元素。

  • last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (形狀為 `(batch_size, hidden_size)` 的 `torch.FloatTensor`) — 序列的第一個標記(分類標記)的最後一層隱藏狀態,經過用於輔助預訓練任務的層進一步處理。例如,對於 BERT 家族模型,這返回經過線性層和 tanh 啟用函式處理後的分類標記。線性層權重是在預訓練期間從下一句預測(分類)目標中訓練的。

  • hidden_states (`tuple(torch.FloatTensor)` 型別,可選,當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組(如果模型有嵌入層,則一個用於嵌入層的輸出,+ 每個層一個用於輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。

  • attentions (`tuple(torch.FloatTensor)` 型別,可選,當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

CLIPVisionModel 的前向方法,覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, CLIPVisionModel

>>> model = CLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

CLIPForImageClassification

class transformers.CLIPForImageClassification

< >

( config: CLIPConfig )

引數

  • config (CLIPConfig) — 模型配置類,包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。

帶有影像分類頭的 CLIP 視覺編碼器(在補丁標記的池化最終隱藏狀態之上加一個線性層),例如用於 ImageNet。

此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。

此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.ImageClassifierOutput 或 `tuple(torch.FloatTensor)`

引數

  • pixel_values (形狀為 `(batch_size, num_channels, image_size, image_size)` 的 `torch.Tensor`,可選) — 對應於輸入影像的張量。畫素值可以使用 `{image_processor_class}` 獲取。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。
  • labels (形狀為 `(batch_size,)` 的 `torch.LongTensor`,可選) — 用於計算影像分類/迴歸損失的標籤。索引應在 `[0, ..., config.num_labels - 1]` 範圍內。如果 `config.num_labels == 1`,則計算迴歸損失(均方損失),如果 `config.num_labels > 1`,則計算分類損失(交叉熵)。
  • output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
  • output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。

返回

transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.ImageClassifierOutput 或一個 `torch.FloatTensor` 的元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置(CLIPConfig)和輸入。

  • loss (形狀為 (1,)torch.FloatTensor可選,當提供 labels 時返回) — 分類損失(如果 config.num_labels==1,則為迴歸損失)。

  • logits (形狀為 (batch_size, config.num_labels)torch.FloatTensor) — 分類(如果 config.num_labels==1,則為迴歸)分數(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `torch.FloatTensor` 的元組(如果模型有嵌入層,則一個用於嵌入層的輸出,外加每個階段的輸出一個),形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個階段輸出的隱藏狀態(也稱為特徵圖)。

  • attentions (tuple(torch.FloatTensor), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `torch.FloatTensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, patch_size, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

CLIPForImageClassification 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoImageProcessor, CLIPForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32")
>>> model = CLIPForImageClassification.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...
TensorFlow
隱藏 TensorFlow 內容

TFCLIPModel

class transformers.TFCLIPModel

< >

( config: CLIPConfig *inputs **kwargs )

引數

  • config (CLIPConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。

該模型繼承自 TFPreTrainedModel。請查閱超類文件,瞭解庫為所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等)。

該模型也是 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它,並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

  • 所有輸入作為關鍵字引數(如 PyTorch 模型),或
  • 所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是,Keras 方法在向模型和層傳遞輸入時更傾向於這種格式。由於這種支援,當使用 `model.fit()` 等方法時,一切應該會“自然而然地”工作——只需以 `model.fit()` 支援的任何格式傳遞您的輸入和標籤即可!然而,如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式,例如在使用 Keras `Functional` API 建立自己的層或模型時,有三種可能性可以用來將所有輸入張量收集到第一個位置引數中。

  • 只有一個 input_ids 的單個張量,沒有其他:model(input_ids)
  • 長度可變的列表,包含一個或多個輸入張量,按文件字串中給出的順序:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
  • 一個字典,其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意,當使用子類化建立模型和層時,您無需擔心這些問題,因為您可以像呼叫任何其他 Python 函式一樣傳遞輸入!

呼叫

< >

( input_ids: TFModelInputType | None = None pixel_values: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) transformers.models.clip.modeling_tf_clip.TFCLIPOutputtuple(tf.Tensor)

引數

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什麼是輸入 ID?

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, num_channels, height, width)`) — 畫素值。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()
  • attention_mask (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:

    • 1 表示標記未被掩碼
    • 0 表示標記已被掩碼

    什麼是注意力掩碼?

  • position_ids (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。

    什麼是位置 ID?

  • return_loss (bool, 可選) — 是否返回對比損失。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 `attentions`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 `hidden_states`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。該引數可以在 Eager 模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

transformers.models.clip.modeling_tf_clip.TFCLIPOutputtuple(tf.Tensor)

一個 `transformers.models.clip.modeling_tf_clip.TFCLIPOutput` 或 `tf.Tensor` 的元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置(`<class 'transformers.models.clip.configuration_clip.CLIPConfig'>`)和輸入。

  • loss (tf.Tensor,形狀為 (1,)可選,當 return_lossTrue 時返回) — 影像-文字相似度的對比損失。
  • logits_per_image:(tf.Tensor,形狀為 `(image_batch_size, text_batch_size)`) — `image_embeds` 和 `text_embeds` 之間的縮放點積得分。這表示影像-文字相似度得分。
  • logits_per_text:(tf.Tensor,形狀為 `(text_batch_size, image_batch_size)`) — `text_embeds` 和 `image_embeds` 之間的縮放點積得分。這表示文字-影像相似度得分。
  • text_embeds(tf.Tensor,形狀為 `(batch_size, output_dim`) — 將投影層應用於 TFCLIPTextModel 的池化輸出所獲得的文字嵌入。
  • image_embeds(tf.Tensor,形狀為 `(batch_size, output_dim`) — 將投影層應用於 TFCLIPVisionModel 的池化輸出所獲得的影像嵌入。
  • text_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPTextModel 的輸出。
  • vision_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPVisionModel 的輸出。

TFCLIPModel 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFCLIPModel

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="tf", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = tf.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

get_text_features

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) text_features (tf.Tensor,形狀為 `(batch_size, output_dim`)

引數

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什麼是輸入 ID?

  • attention_mask (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:

    • 1 表示標記未被掩碼
    • 0 表示標記已被掩碼

    什麼是注意力掩碼?

  • position_ids (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。

    什麼是位置 ID?

  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 `attentions`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 `hidden_states`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。該引數可以在 Eager 模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

text_features (tf.Tensor,形狀為 (batch_size, output_dim)

將投影層應用於 TFCLIPTextModel 的池化輸出所獲得的文字嵌入。

TFCLIPModel 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFCLIPModel

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)

get_image_features

< >

( pixel_values: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) image_features (tf.Tensor,形狀為 `(batch_size, output_dim`)

引數

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, num_channels, height, width)`) — 畫素值。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()。 output_attentions (bool, 可選): 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 `attentions`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 `hidden_states`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。該引數可以在 Eager 模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

image_features (tf.Tensor,形狀為 (batch_size, output_dim)

將投影層應用於 TFCLIPVisionModel 的池化輸出所獲得的影像嵌入。

TFCLIPModel 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFCLIPModel

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="tf")

>>> image_features = model.get_image_features(**inputs)

TFCLIPTextModel

class transformers.TFCLIPTextModel

< >

( config: CLIPTextConfig *inputs **kwargs )

呼叫

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

引數

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什麼是輸入 ID?

  • attention_mask (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:

    • 1 表示標記未被掩碼
    • 0 表示標記已被掩碼

    什麼是注意力掩碼?

  • position_ids (np.ndarraytf.Tensor,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。

    什麼是位置 ID?

  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 `attentions`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 `hidden_states`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。該引數可以在 Eager 模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一個 `tf.Tensor` 的元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置(`<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>`)和輸入。

  • last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (tf.Tensor,形狀為 `(batch_size, hidden_size)`) — 序列第一個標記(分類標記)的最後一層隱藏狀態,經過一個線性層和 Tanh 啟用函式進一步處理。線性層的權重是在預訓練期間根據下一句預測(分類)目標進行訓練的。

    此輸出通常不是輸入語義內容的良好摘要,通常最好對整個輸入序列的隱藏狀態進行平均或池化。

  • hidden_states (tuple(tf.Tensor), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `tf.Tensor` 的元組(一個用於嵌入層的輸出 + 一個用於每層的輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `tf.Tensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

TFCLIPTextModel 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, TFCLIPTextModel

>>> model = TFCLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

TFCLIPVisionModel

class transformers.TFCLIPVisionModel

< >

( config: CLIPVisionConfig *inputs **kwargs )

呼叫

< >

( pixel_values: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

引數

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每個樣本形狀必須為 `(batch_size, num_channels, height, width)`) — 畫素值。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()。 output_attentions (bool, 可選): 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 `attentions`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 `hidden_states`。該引數只能在 Eager 模式下使用,在圖模式下將使用配置中的值。
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。該引數可以在 Eager 模式下使用,在圖模式下該值將始終設定為 True。
  • training (bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式(一些模組如 dropout 模組在訓練和評估之間有不同的行為)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一個 `tf.Tensor` 的元組(如果傳遞了 `return_dict=False` 或 `config.return_dict=False`),包含的各種元素取決於配置(`<class 'transformers.models.clip.configuration_clip.CLIPVisionConfig'>`)和輸入。

  • last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (tf.Tensor,形狀為 `(batch_size, hidden_size)`) — 序列第一個標記(分類標記)的最後一層隱藏狀態,經過一個線性層和 Tanh 啟用函式進一步處理。線性層的權重是在預訓練期間根據下一句預測(分類)目標進行訓練的。

    此輸出通常不是輸入語義內容的良好摘要,通常最好對整個輸入序列的隱藏狀態進行平均或池化。

  • hidden_states (tuple(tf.Tensor), 可選, 當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `tf.Tensor` 的元組(一個用於嵌入層的輸出 + 一個用於每層的輸出),形狀為 `(batch_size, sequence_length, hidden_size)`。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor), 可選, 當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `tf.Tensor` 的元組(每層一個),形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

TFCLIPVisionModel 的 forward 方法覆蓋了 `__call__` 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFCLIPVisionModel

>>> model = TFCLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="tf")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states
JAX
隱藏 JAX 內容

FlaxCLIPModel

class transformers.FlaxCLIPModel

< >

( config: CLIPConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

引數

  • config (CLIPConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
  • dtype (jax.numpy.dtype, 可選, 預設為 jax.numpy.float32) — 計算時的資料型別。可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 中的一種。

    這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定了該引數,所有計算都將使用給定的 dtype 執行。

    請注意,這僅指定計算的資料型別,不影響模型引數的資料型別。

    如果您希望更改模型引數的資料型別,請參閱 to_fp16()to_bf16()

此模型繼承自 FlaxPreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法(例如下載、儲存和轉換 PyTorch 模型的權重)。

該模型也是一個 flax.linen.Module 子類。可以像常規的 Flax linen Module 一樣使用它,並參考 Flax 文件瞭解所有與通用用法和行為相關的事項。

最後,此模型支援固有的 JAX 功能,例如

__call__

< >

( input_ids pixel_values attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.clip.modeling_flax_clip.FlaxCLIPOutputtuple(torch.FloatTensor)

引數

  • input_ids (numpy.ndarray,形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選自 [0, 1]

    • 1 表示標記未被遮蓋
    • 0 表示標記已被遮蓋

    什麼是注意力掩碼?

  • position_ids (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]

    什麼是位置 ID?

  • pixel_values (numpy.ndarray,形狀為 (batch_size, num_channels, height, width)) — 畫素值。如果提供填充,預設將被忽略。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 hidden_states
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。

返回

transformers.models.clip.modeling_flax_clip.FlaxCLIPOutputtuple(torch.FloatTensor)

一個 transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或一個 torch.FloatTensor 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(<class 'transformers.models.clip.configuration_clip.CLIPConfig'>)和輸入,包含各種元素。

  • logits_per_image:(jnp.ndarray,形狀為 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之間的縮放點積得分。這表示圖文相似性得分。
  • logits_per_text:(jnp.ndarray,形狀為 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之間的縮放點積得分。這表示文圖相似性得分。
  • text_embeds(jnp.ndarray,形狀為 (batch_size, output_dim)) — 透過將投影層應用於 FlaxCLIPTextModel 的池化輸出而獲得的文字嵌入。
  • image_embeds(jnp.ndarray,形狀為 (batch_size, output_dim)) — 透過將投影層應用於 FlaxCLIPVisionModel 的池化輸出而獲得的影像嵌入。
  • text_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPTextModel 的輸出。
  • vision_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPVisionModel 的輸出。

FlaxCLIPPreTrainedModel 的前向方法重寫了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> import jax
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, FlaxCLIPModel

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="np", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = jax.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

get_text_features

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train = False ) text_features (jnp.ndarray,形狀為 (batch_size, output_dim))

引數

返回

text_features (jnp.ndarray,形狀為 (batch_size, output_dim))

透過將投影層應用於 FlaxCLIPTextModel 的池化輸出而獲得的文字嵌入。

示例

>>> from transformers import AutoTokenizer, FlaxCLIPModel

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")
>>> text_features = model.get_text_features(**inputs)

get_image_features

< >

( pixel_values params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train = False ) image_features (jnp.ndarray,形狀為 (batch_size, output_dim))

引數

  • pixel_values (numpy.ndarray,形狀為 (batch_size, num_channels, height, width)) — 畫素值。如果提供填充,預設將被忽略。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()

返回

image_features (jnp.ndarray,形狀為 (batch_size, output_dim))

透過將投影層應用於 FlaxCLIPVisionModel 的池化輸出而獲得的影像嵌入

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, FlaxCLIPModel

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="np")

>>> image_features = model.get_image_features(**inputs)

FlaxCLIPTextModel

class transformers.FlaxCLIPTextModel

< >

( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

引數

  • input_ids (numpy.ndarray,形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選自 [0, 1]

    • 1 表示標記未被遮蓋
    • 0 表示標記已被遮蓋

    什麼是注意力掩碼?

  • position_ids (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]

    什麼是位置 ID?

  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 hidden_states
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

一個 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一個 torch.FloatTensor 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>)和輸入,包含各種元素。

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (jnp.ndarray,形狀為 (batch_size, hidden_size)) — 序列第一個標記(分類標記)的最後一層隱藏狀態,經過線性層和 Tanh 啟用函式進一步處理。線性層的權重在預訓練期間透過下一句預測(分類)目標進行訓練。

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每個層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

FlaxCLIPTextPreTrainedModel 的前向方法重寫了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxCLIPTextModel

>>> model = FlaxCLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooler_output = outputs.pooler_output  # pooled (EOS token) states

FlaxCLIPTextModelWithProjection

class transformers.FlaxCLIPTextModelWithProjection

< >

( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutputtuple(torch.FloatTensor)

引數

  • input_ids (numpy.ndarray,形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。

    索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什麼是輸入 ID?

  • attention_mask (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選自 [0, 1]

    • 1 表示標記未被遮蓋
    • 0 表示標記已被遮蓋

    什麼是注意力掩碼?

  • position_ids (numpy.ndarray,形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。選值範圍為 [0, config.max_position_embeddings - 1]

    什麼是位置 ID?

  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的 hidden_states
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。

返回

transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutputtuple(torch.FloatTensor)

一個 transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput 或一個 torch.FloatTensor 元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>)和輸入,包含各種元素。

  • text_embeds (jnp.ndarray,形狀為 (batch_size, output_dim)) — 透過將投影層應用於 FlaxCLIPTextModel 的池化輸出而獲得的文字嵌入。

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每個層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

FlaxCLIPTextPreTrainedModel 的前向方法重寫了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from transformers import AutoTokenizer, FlaxCLIPTextModelWithProjection

>>> model = FlaxCLIPTextModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

FlaxCLIPVisionModel

class transformers.FlaxCLIPVisionModel

< >

( config: CLIPVisionConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( pixel_values params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

引數

  • pixel_values (numpy.ndarray,形狀為 (batch_size, num_channels, height, width)) — 畫素值。如果您提供填充(Padding),預設情況下它將被忽略。畫素值可以使用 AutoImageProcessor 獲取。有關詳細資訊,請參閱 CLIPImageProcessor.call()
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 hidden_states
  • return_dict (bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一個 torch.FloatTensor 的元組(如果傳遞了 return_dict=False 或當 config.return_dict=False 時),根據配置(<class 'transformers.models.clip.configuration_clip.CLIPVisionConfig'>)和輸入包含各種元素。

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。

  • pooler_output (jnp.ndarray,形狀為 (batch_size, hidden_size)) — 序列第一個標記(分類標記)的最後一層隱藏狀態,經過線性層和 Tanh 啟用函式進一步處理。線性層的權重在預訓練期間透過下一句預測(分類)目標進行訓練。

  • hidden_states (tuple(jnp.ndarray), 可選, 當傳遞 output_hidden_states=True 或當 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組(一個用於嵌入層的輸出,一個用於每個層的輸出),形狀為 (batch_size, sequence_length, hidden_size)

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳遞 output_attentions=True 或當 config.output_attentions=True 時返回) — jnp.ndarray 的元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 後的注意力權重,用於計算自注意力頭中的加權平均值。

FlaxCLIPVisionPreTrainedModel 的前向方法,覆蓋了 __call__ 特殊方法。

儘管前向傳播的流程需要在此函式內定義,但之後應呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, FlaxCLIPVisionModel

>>> model = FlaxCLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="np")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooler_output = outputs.pooler_output  # pooled CLS states
< > 在 GitHub 上更新

© . This site is unofficial and not affiliated with Hugging Face, Inc.