Transformers 文件
CLIP
並獲得增強的文件體驗
開始使用
CLIP
CLIP 是一個多模態視覺和語言模型,其動機是為了克服訓練計算機視覺模型時物件類別數量固定的問題。CLIP 透過對 4 億個(影像,文字)對進行聯合訓練,直接從原始文字中學習影像。這種規模的預訓練使其能夠零樣本遷移到下游任務。CLIP 使用影像編碼器和文字編碼器來獲取視覺特徵和文字特徵。這兩種特徵都被投影到具有相同維數的潛在空間中,它們的點積給出了相似度分數。
你可以在 OpenAI 組織下找到所有原始的 CLIP 檢查點。
點選右側邊欄中的 CLIP 模型,檢視更多如何將 CLIP 應用於不同影像和語言任務的示例。
下面的示例演示瞭如何使用 Pipeline 或 AutoModel 類來計算多個文字描述和一張影像之間的相似度分數。
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)
注意
- 使用 CLIPImageProcessor 來調整(或縮放)和歸一化模型所需的影像。
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
從 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 (
str
或function
, 可選, 預設為"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 (
str
或function
, 可選, 預設為"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]
透過連線和新增特殊詞元,從一個序列或一對序列中為序列分類任務構建模型輸入。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]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model
方法新增特殊標記時呼叫。
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳入的兩個序列建立掩碼。CLIP 不使用詞元型別 ID,因此返回一個零列表。
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]
透過連線和新增特殊詞元,從一個序列或一對序列中為序列分類任務構建模型輸入。CLIP 序列具有以下格式:
- 單個序列:
<|startoftext|> X <|endoftext|>
序列對不是預期的使用情況,但它們將在沒有分隔符的情況下被處理。
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → 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
orfloat
, 可選, 預設為1/255
) — 如果重新縮放影像,則使用的縮放因子。可在preprocess
方法中透過 `rescale_factor` 引數覆蓋。 - do_normalize (
bool
, 可選, 預設為True
) — 是否對影像進行歸一化。可在preprocess
方法中透過 `do_normalize` 引數覆蓋。 - image_mean (
float
或list[float]
, 可選, 預設為[0.48145466, 0.4578275, 0.40821073]
) — 如果對影像進行歸一化,則使用的均值。這是一個浮點數或浮點數列表,其長度等於影像中的通道數。可在preprocess
方法中透過image_mean
引數覆蓋。 - image_std (
float
或list[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 (
float
或list[float]
, 可選, 預設為self.image_mean
) — 用於歸一化的影像均值。僅當do_normalize
設定為True
時有效。 - image_std (
float
或list[float]
, 可選, 預設為self.image_std
) — 用於歸一化的影像標準差。僅在do_normalize
設定為True
時生效。 - do_convert_rgb (
bool
, 可選, 預設為self.do_convert_rgb
) — 是否將影像轉換為 RGB 格式。 - return_tensors (
str
或TensorType
, 可選) — 返回張量的型別。可以是以下之一:- 未設定:返回一個
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 (
ChannelDimension
或str
, 可選, 預設為ChannelDimension.FIRST
) — 輸出影像的通道維度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:影像格式為 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:影像格式為 (height, width, num_channels)。- 未設定:使用輸入影像的通道維度格式。
- input_data_format (
ChannelDimension
或str
, 可選) — 輸入影像的通道維度格式。如果未設定,則從輸入影像中推斷通道維度格式。可以是以下之一:"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
< source >( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )
構建一個快速 Clip 影像處理器。
preprocess
< source >( 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
CLIPProcessor
class transformers.CLIPProcessor
< source >( image_processor = None tokenizer = None **kwargs )
引數
- image_processor (CLIPImageProcessor, 可選) — 影像處理器是必需的輸入。
- tokenizer (CLIPTokenizerFast, 可選) — 分詞器是必需的輸入。
構建一個 CLIP 處理器,它將 CLIP 影像處理器和 CLIP 分詞器包裝成一個單一的處理器。
CLIPProcessor 提供了 CLIPImageProcessor 和 CLIPTokenizerFast 的所有功能。更多資訊請參見 __call__()
和 decode()。
此方法將其所有引數轉發給 CLIPTokenizerFast 的 batch_decode()。更多資訊請參考該方法的文件字串。
此方法將其所有引數轉發給 CLIPTokenizerFast 的 decode()。有關更多資訊,請參閱此方法的文件字串。
CLIPModel
class transformers.CLIPModel
< source >( config: CLIPConfig )
引數
- config (CLIPConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎 Clip 模型,輸出原始的隱藏狀態,頂部沒有任何特定的頭部。
此模型繼承自 PreTrainedModel。請檢視超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。
此模型也是 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( 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.CLIPOutput
或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor
,形狀為(batch_size, sequence_length)
, 可選) — 詞彙表中輸入序列標記的索引。預設情況下,填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參見 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
範圍內選擇。 - return_loss (
bool
, 可選) — 是否返回對比損失。 - output_attentions (
bool
, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參見返回張量下的attentions
。 - output_hidden_states (
bool
, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參見返回張量下的hidden_states
。 - interpolate_pos_encoding (
bool
, 預設為False
) — 是否對預訓練的位置編碼進行插值。
返回
transformers.models.clip.modeling_clip.CLIPOutput
或 tuple(torch.FloatTensor)
一個 transformers.models.clip.modeling_clip.CLIPOutput
或一個 `torch.FloatTensor` 元組(如果傳遞了 return_dict=False
或當 config.return_dict=False
時),根據配置 (CLIPConfig) 和輸入包含各種元素。
- loss (
torch.FloatTensor
,形狀為(1,)
, 可選, 當return_loss
為True
時返回) — 影像-文字相似度的對比損失。 - logits_per_image (
torch.FloatTensor
,形狀為(image_batch_size, text_batch_size)
) —image_embeds
和text_embeds
之間的縮放點積得分。這表示影像-文字相似度分數。 - logits_per_text (
torch.FloatTensor
,形狀為(text_batch_size, image_batch_size)
) —text_embeds
和image_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
< source >( 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()。
- 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]
範圍內選擇。 - 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
< source >( 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__()。
- 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]` 範圍內選擇。
- output_attentions (`bool` 型別,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。
- output_hidden_states (`bool` 型別,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(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__()。
- 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]` 範圍內選擇。
- 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.BaseModelOutputWithPooling 或 tuple(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.ImageClassifierOutput 或 tuple(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])
...
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.TFCLIPOutput
或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- pixel_values (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每個樣本形狀必須為 `(batch_size, num_channels, height, width)`) — 畫素值。畫素值可以使用 AutoImageProcessor 獲得。詳情請參閱 CLIPImageProcessor.call()。 - attention_mask (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:- 1 表示標記未被掩碼,
- 0 表示標記已被掩碼。
- position_ids (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。 - 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.TFCLIPOutput
或 tuple(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_loss
為True
時返回) — 影像-文字相似度的對比損失。 - 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.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:- 1 表示標記未被掩碼,
- 0 表示標記已被掩碼。
- position_ids (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。 - 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.ndarray
、tf.Tensor
、list[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
呼叫
< 來源 >( 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.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每個樣本形狀必須為 `(batch_size, sequence_length)`) — 詞彙表中輸入序列標記的索引。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 用於避免對填充標記索引執行注意力計算的掩碼。掩碼值選自 `[0, 1]`:- 1 表示標記未被掩碼,
- 0 表示標記已被掩碼。
- position_ids (
np.ndarray
或tf.Tensor
,形狀為 `(batch_size, sequence_length)`,可選) — 位置嵌入中每個輸入序列標記的位置索引。取值範圍為 `[0, config.max_position_embeddings - 1]`。 - 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.TFBaseModelOutputWithPooling 或 tuple(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
呼叫
< 來源 >( 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.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
引數
- pixel_values (
np.ndarray
、tf.Tensor
、list[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.TFBaseModelOutputWithPooling 或 tuple(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
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.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 中的一種。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定了該引數,所有計算都將使用給定的
dtype
執行。請注意,這僅指定計算的資料型別,不影響模型引數的資料型別。
此模型繼承自 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.FlaxCLIPOutput
或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray
,形狀為(batch_size, sequence_length)
) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - 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.FlaxCLIPOutput
或 tuple(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_embeds
和text_embeds
之間的縮放點積得分。這表示圖文相似性得分。 - logits_per_text:(
jnp.ndarray
,形狀為(text_batch_size, image_batch_size)
) —text_embeds
和image_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)
)
引數
- input_ids (
numpy.ndarray
,形狀為(batch_size, sequence_length)
) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回
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.FlaxBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray
,形狀為(batch_size, sequence_length)
) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - output_attentions (
bool
, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的attentions
。 - output_hidden_states (
bool
, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的hidden_states
。 - return_dict (
bool
, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 tuple(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.FlaxCLIPTextModelOutput
或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray
,形狀為(batch_size, sequence_length)
) — 詞彙表中輸入序列標記的索引。如果提供填充,預設將被忽略。索引可以使用 AutoTokenizer 獲得。詳情請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - output_attentions (
bool
, 可選) — 是否返回所有注意力層的注意力張量。更多細節請參閱返回張量下的attentions
。 - output_hidden_states (
bool
, 可選) — 是否返回所有層的隱藏狀態。更多細節請參閱返回張量下的hidden_states
。 - return_dict (
bool
, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput
或 tuple(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.FlaxBaseModelOutputWithPooling 或 tuple(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.FlaxBaseModelOutputWithPooling 或 tuple(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