Transformers 文件

Janus

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

Janus

概述

Janus 模型最初由 DeepSeek AI 團隊在 Janus: Decoupling Visual Encoding for Unified Multimodal Understanding and Generation 中提出,後在 Janus-Pro: Unified Multimodal Understanding and Generation with Data and Model Scaling 中進行了改進。Janus 是一種視覺-語言模型,可以生成影像和文字輸出,也可以將影像和文字作為輸入。

[!NOTE] 該模型不會以交錯格式同時生成影像和文字。使用者必須傳遞一個引數來指示是生成文字還是影像。

原始論文的摘要如下:

在本文中,我們介紹了 Janus,一個統一多模態理解和生成的自迴歸框架。之前的研究通常依賴於一個單一的視覺編碼器來完成這兩項任務,例如 Chameleon。然而,由於多模態理解和生成所需的細粒度資訊水平不同,這種方法可能會導致次優效能,尤其是在多模態理解方面。為了解決這個問題,我們將視覺編碼解耦為單獨的路徑,同時仍然利用單一的統一 Transformer 架構進行處理。這種解耦不僅緩解了視覺編碼器在理解和生成中的角色衝突,而且增強了框架的靈活性。例如,多模態理解和生成元件都可以獨立選擇最適合它們的編碼方法。實驗表明,Janus 超越了之前的統一模型,並達到或超過了特定任務模型的效能。Janus 的簡單性、高靈活性和有效性使其成為下一代統一多模態模型的有力候選。

上述 Janus-Pro 論文的摘要(釋出於之後)如下:

在這項工作中,我們介紹了 Janus-Pro,它是先前工作 Janus 的高階版本。具體來說,Janus-Pro 整合了 (1) 最佳化的訓練策略,(2) 擴充套件的訓練資料,以及 (3) 擴充套件到更大的模型尺寸。透過這些改進,Janus-Pro 在多模態理解和文字到影像指令遵循能力方面取得了顯著進展,同時還增強了文字到影像生成的穩定性。我們希望這項工作能啟發該領域的進一步探索。程式碼和模型已公開提供。

此模型由 Yaswanth GaliHugo Silva 貢獻。原始程式碼可在此處找到。

使用示例

單影像推理

以下是使用單影像進行視覺理解的示例。

[!NOTE] 請注意,該模型已針對特定的聊天提示格式進行訓練。請使用 processor.apply_chat_template(my_conversation_dict) 來正確格式化您的提示。

import torch  
from PIL import Image  
import requests  

from transformers import JanusForConditionalGeneration, JanusProcessor  

model_id = "deepseek-community/Janus-Pro-1B"
# Prepare Input for generation.
messages = [
    {
        "role": "user",
        "content": [
            {'type':'image', 'url': 'http://images.cocodataset.org/val2017/000000039769.jpg'},
            {'type':"text", "text":"What do you see in this image?."}
        ]
    },
]

# Set generation mode to `text` to perform text generation.
processor = JanusProcessor.from_pretrained(model_id)
model = JanusForConditionalGeneration.from_pretrained(model_id,     
        torch_dtype=torch.bfloat16,
        device_map="auto")

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    generation_mode="text",
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device, dtype=torch.bfloat16)

output = model.generate(**inputs, max_new_tokens=40,generation_mode='text',do_sample=True)
text = processor.decode(output[0], skip_special_tokens=True)
print(text)

多影像推理

Janus 可以對多個影像作為輸入進行推理,其中影像可以屬於相同的提示,也可以屬於批處理推理中不同的提示,模型同時處理多個對話。以下是操作方法:

import torch
from PIL import Image
import requests

from transformers import JanusForConditionalGeneration, JanusProcessor

model_id = "deepseek-community/Janus-Pro-1B"

image_urls = [
    "http://images.cocodataset.org/val2017/000000039769.jpg",
    "https://www.ilankelman.org/stopsigns/australia.jpg",
    "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
]

messages = [
    [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What’s the difference between"},
                {"type": "image", "url": image_urls[0]},
                {"type": "text", "text": " and "},
                {"type": "image", "url": image_urls[1]}
            ]
        }
    ],
    [
        {
            "role": "user",
            "content": [
                {"type": "image", "url": image_urls[2]},
                {"type": "text", "text": "What do you see in this image?"}
            ]
        }
    ]
]

# Load model and processor
processor = JanusProcessor.from_pretrained(model_id)
model = JanusForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    generation_mode="text",
    tokenize=True,
    padding=True,
    return_dict=True,
    return_tensors="pt"
).to(model.device, dtype=torch.bfloat16)

# Generate response
output = model.generate(**inputs, max_new_tokens=40, generation_mode='text', do_sample=False)
text = processor.batch_decode(output, skip_special_tokens=True)
print(text)

文字到影像生成

Janus 也可以根據提示生成影像。

import torch
from transformers import JanusForConditionalGeneration, JanusProcessor

# Set generation mode to `image` to prepare inputs for image generation..

model_id = "deepseek-community/Janus-Pro-1B"
processor = JanusProcessor.from_pretrained(model_id)
model = JanusForConditionalGeneration.from_pretrained(model_id,
        torch_dtype=torch.bfloat16,
        device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "A dog running under the rain."},
        ],
     }
]

prompt = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(text=prompt,generation_mode="image",return_tensors="pt").to(model.device, dtype=torch.bfloat16)

# Set num_return_sequence parameter to generate multiple images per prompt.
model.generation_config.num_return_sequences = 2
outputs = model.generate(**inputs,
                         generation_mode="image",
                         do_sample=True,
                         use_cache=True,
                         )
# Perform post-processing on the generated token ids.
decoded_image = model.decode_image_tokens(outputs)
images = processor.postprocess(list(decoded_image.float()),return_tensors="PIL.Image.Image")
# Save the image
for i, image in enumerate(images['pixel_values']):
    image.save(f"result{i}.png")

JanusConfig

class transformers.JanusConfig

< >

( text_config = None vision_config = None vq_config = None image_token_id = 100581 **kwargs )

引數

  • text_config (Union[AutoConfig, dict], 可選, 預設為 LlamaConfig) — 文字骨幹的配置物件或字典。
  • vision_config (Union[AutoConfig, dict], 可選, 預設為 JanusVisionConfig) — 視覺骨幹的配置物件或字典。
  • vq_config (Union[AutoConfig, dict], 可選, 預設為 JanusVQVAEConfig) — VQVAE 骨幹的配置物件或字典。
  • image_token_id (int, 可選, 預設為 100581) — 佔位影像 token 的 token 索引。

這是一個配置類,用於儲存 JanusModel 的配置。它用於根據指定的引數例項化 Janus 模型,定義模型架構。使用預設值例項化配置將生成與 Janus-1B 或 Janus-7B 模型相似的配置。

例如 deepseek-community/Janus-Pro-1Bdeepseek-community/Janus-Pro-7B

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。有關更多資訊,請參閱 PretrainedConfig 的文件。

示例

>>> from transformers import JanusForConditionalGeneration, JanusConfig, JanusVisionConfig, JanusVQVAEConfig, LlamaConfig

>>> # Initializing a Janus vision config
>>> vision_config = JanusVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> # Initializing a VQ config
>>> vq_config = JanusVQVAEConfig()

>>> # Initializing a Janus Pro 1B style configuration
>>> configuration = JanusConfig(vision_config=vision_config, text_config=text_config, vq_config=vq_config)

>>> # Initializing a model from the Janus Pro 1B style configuration
>>> model = JanusForConditionalGeneration(configuration)

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

JanusVisionConfig

class transformers.JanusVisionConfig

< >

( hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 num_channels = 3 patch_size = 16 image_size = 384 attention_dropout = 0.0 layer_norm_eps = 1e-06 hidden_act = 'gelu' mlp_ratio = 4.0 attention_bias = True hidden_dropout_rate = 0.0 projection_dim = 2048 projection_dropout = 0.0 use_qk_norm = False initializer_range = 0.02 depth = 2 num_image_tokens = 576 **kwargs )

引數

  • hidden_size (int, 可選, 預設為 1024) — 編碼器層和池化層的維度。
  • num_hidden_layers (int, 可選, 預設為 24) — Transformer 編碼器中的隱藏層數量。
  • num_attention_heads (int, 可選, 預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數量。
  • num_channels (int, 可選, 預設為 3) — 輸入通道的數量。
  • patch_size (int, 可選, 預設為 16) — 每個 patch 的大小(解析度)。
  • image_size (int, 可選, 預設為 384) — 每張影像的大小(解析度)。
  • attention_dropout (float, 可選, 預設為 0.0) — 注意力權重的 Dropout 機率。
  • layer_norm_eps (float, 可選, 預設為 1e-06) — 層歸一化層使用的 epsilon。
  • hidden_act (strfunction, 可選, 預設為 "gelu") — 編碼器和池化器中的非線性啟用函式(函式或字串)。如果為字串,支援 "gelu""relu""selu""gelu_new"
  • mlp_ratio (float, 可選, 預設為 4.0) — MLP 隱藏維度與嵌入維度的比率。
  • attention_bias (bool, 可選, 預設為 True) — 是否在注意力層中為查詢、鍵和值新增偏差。
  • hidden_dropout_rate (float, 可選, 預設為 0.0) — 編碼器中全連線層的 Dropout 機率。
  • projection_dim (int, 可選, 預設為 2048) — MLP 投影頭的維度。
  • projection_dropout (float, 可選, 預設為 0.0) — 投影層的 Dropout 機率。
  • use_qk_norm (bool, 可選, 預設為 False) — 是否歸一化查詢和鍵矩陣。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。
  • depth (int, 可選, 預設為 2) — 對齊器模組中的隱藏層數量。
  • num_image_tokens (int, 可選, 預設為 576) — 影像 token 的數量。

這是一個配置類,用於儲存 JanusVisionModel 的配置。它用於根據指定的引數例項化 JanusVisionModel,定義模型架構。

配置物件繼承自 PretrainedConfig,可用於控制模型輸出。有關更多資訊,請參閱 PretrainedConfig 的文件。

JanusVQVAEConfig

class transformers.JanusVQVAEConfig

< >

( embed_dim: int = 8 num_embeddings: int = 16384 double_latent: bool = False latent_channels: int = 256 num_patches: int = 32 in_channels: int = 3 out_channels: int = 3 base_channels: int = 128 channel_multiplier: list = [1, 1, 2, 2, 4] num_res_blocks: int = 2 dropout: float = 0.0 initializer_range = 0.02 projection_dim = 2048 num_hidden_layers = 2 hidden_act = 'gelu' image_token_embed_dim = 2048 **kwargs )

引數

  • embed_dim (int, 可選, 預設為 8) — 每個嵌入向量的維度。
  • num_embeddings (int, 可選, 預設為 16384) — 碼本嵌入的數量。
  • double_latent (bool, 可選, 預設為 False) — 是否使用雙 z 通道。
  • latent_channels (int, 可選, 預設為 256) — 潛在空間的通道數量。
  • num_patches (int, 可選, 預設為 32) — 輸入影像可分割成的 patch 數量。
  • in_channels (int, 可選, 預設為 3) — 輸入通道的數量。
  • out_channels (int, 可選, 預設為 3) — 輸出通道的數量。
  • base_channels (int, 可選, 預設為 128) — 基本通道數。
  • channel_multiplier (list[int], 可選, 預設為 [1, 1, 2, 2, 4]) — 每個解析度的通道乘數。
  • num_res_blocks (int, 可選, 預設為 2) — 殘差塊的數量。
  • dropout (float, 可選, 預設為 0.0) — Dropout 率。
  • initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。
  • projection_dim (int, 可選, 預設為 2048) — MLP 投影頭的維度。
  • num_hidden_layers (int, 可選, 預設為 2) — VAVAE MLP 聯結器模組中的隱藏層數量。
  • hidden_act (strCallable, 可選, 預設為 "gelu") — 編碼器和池化器中的非線性啟用函式(函式或字串)。如果為字串,支援 "gelu""relu""silu""gelu_new"
  • image_token_embed_dim (int, 可選, 預設為 2048) — 影像嵌入的維度。應與文字嵌入的維度相同。

這是用於儲存 JanusVQVAEModel 配置的配置類。它用於根據指定的引數例項化 JanusVQVAEModel,定義模型架構。配置物件繼承自 PretrainedConfig,可用於控制模型輸出。有關更多資訊,請參閱 PretrainedConfig 的文件。使用預設值例項化配置將產生與 deepseek-community/Janus-Pro-1B 的 VQModel 相似的配置。

JanusProcessor

class transformers.JanusProcessor

< 來源 >

( image_processor tokenizer chat_template = None use_default_system_prompt = False **kwargs )

引數

  • image_processor (JanusImageProcessor) — 影像處理器是必需的輸入。
  • tokenizer (LlamaTokenizerFast) — 分詞器是必需的輸入。
  • chat_template (str, 可選) — 用於將聊天中的訊息列表轉換為可標記化字串的 Jinja 模板。
  • use_default_system_prompt (str, 可選, 預設為 False) — 對文字生成使用預設系統提示。

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

JanusProcessor 提供了 JanusImageProcessorLlamaTokenizerFast 的所有功能。有關更多資訊,請參閱 __call__()decode()

batch_decode

< 來源 >

( *args **kwargs )

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

decode

< 來源 >

( *args **kwargs )

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

postprocess

< 來源 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs )

將所有引數轉發給影像處理器的 postprocess 方法。有關更多詳細資訊,請參閱原始方法的文件字串。

JanusImageProcessor

class transformers.JanusImageProcessor

< 來源 >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = None min_size: int = 14 resample: Resampling = <Resampling.BICUBIC: 3> 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: typing.Optional[bool] = None **kwargs )

引數

  • do_resize (bool, 可選, 預設為 True) — 是否將影像的 (height, width) 尺寸調整為指定的 size。可以透過 preprocess 方法中的 do_resize 引數覆蓋。
  • size (dict, 可選, 預設為 {"height" -- 384, "width": 384}):調整大小後輸出影像的尺寸。可以透過 preprocess 方法中的 size 引數覆蓋。
  • min_size (int, 可選, 預設為 14) — 調整大小後圖像的最小允許尺寸。確保調整大小後高度和寬度都不低於此值。
  • resample (PILImageResampling, 可選, 預設為 Resampling.BICUBIC) — 如果調整影像大小,要使用的重取樣過濾器。僅當 do_resize 設定為 True 時有效。可以透過 preprocess 方法中的 resample 引數覆蓋。
  • do_rescale (bool, 可選, 預設為 True) — 是否按指定的比例 rescale_factor 縮放影像。可以透過 preprocess 方法中的 do_rescale 引數覆蓋。
  • rescale_factor (intfloat, 可選, 預設為 1/255) — 如果縮放影像,要使用的比例因子。僅當 do_rescale 設定為 True 時有效。可以透過 preprocess 方法中的 rescale_factor 引數覆蓋。
  • do_normalize (bool, 可選, 預設為 True) — 是否對影像進行歸一化。可以透過 preprocess 方法中的 do_normalize 引數覆蓋。可以透過 preprocess 方法中的 do_normalize 引數覆蓋。
  • image_mean (floatlist[float], 可選, 預設為 IMAGENET_STANDARD_MEAN) — 如果對影像進行歸一化,要使用的均值。這是一個浮點數或浮點數列表,其長度與影像中的通道數相同。可以透過 preprocess 方法中的 image_mean 引數覆蓋。可以透過 preprocess 方法中的 image_mean 引數覆蓋。
  • image_std (floatlist[float], 可選, 預設為 IMAGENET_STANDARD_STD) — 如果對影像進行歸一化,要使用的標準差。這是一個浮點數或浮點數列表,其長度與影像中的通道數相同。可以透過 preprocess 方法中的 image_std 引數覆蓋。可以透過 preprocess 方法中的 image_std 引數覆蓋。
  • do_convert_rgb (bool, 可選, 預設為 True) — 是否將影像轉換為 RGB。

構建一個 JANUS 影像處理器。

pad_to_square

< 來源 >

( image: ndarray background_color: typing.Union[int, tuple[int, int, int]] = 0 data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None ) np.ndarray

引數

  • image (np.ndarray) — 要填充的影像。
  • background_color (inttuple[int, int, int], 可選, 預設為 0) — 用於填充的顏色。可以是單通道的整數,也可以是表示多通道影像的整數元組。如果在多通道模式下作為整數傳入,則在後續通道中預設為 0
  • data_format (strChannelDimension, 可選) — 輸出影像的通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:影像為 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:影像為 (height, width, num_channels) 格式。如果未設定,將使用與輸入影像相同的格式。
  • input_data_format (strChannelDimension, 可選) — 輸入影像的通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:影像為 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:影像為 (height, width, num_channels) 格式。

返回

np.ndarray

填充後的影像。

將影像填充為以最長邊為基準的正方形。

postprocess

< 來源 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Optional[list[float]] = None image_std: typing.Optional[list[float]] = None input_data_format: typing.Optional[str] = None return_tensors: typing.Optional[str] = None )

透過反轉預處理期間應用的轉換,對解碼的影像標記進行後處理。

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_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 return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None do_convert_rgb: typing.Optional[bool] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

引數

  • images (ImageInput) — 要預處理的影像。期望單個或批次影像,畫素值範圍從 0 到 255。如果傳入的影像畫素值在 0 到 1 之間,請設定 do_rescale=False
  • do_resize (bool, 可選, 預設為 self.do_resize) — 是否調整影像大小。
  • size (dict[str, int], 可選, 預設為 self.size) — 控制 resize 後圖像的大小。影像的最短邊將調整為 size["shortest_edge"],同時保持縱橫比。如果此調整大小後的影像的最長邊大於 int(size["shortest_edge"] * (1333 / 800)),則影像將再次調整大小,使最長邊等於 int(size["shortest_edge"] * (1333 / 800))
  • resample (PILImageResampling, 可選, 預設為 self.resample) — 如果調整影像大小,要使用的重取樣過濾器。僅當 do_resize 設定為 True 時有效。
  • do_rescale (bool, 可選, 預設為 self.do_rescale) — 是否將影像值縮放到 [0 - 1] 之間。
  • 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)。

預處理一張或一批影像。

resize

< >

( image: ndarray size: typing.Union[dict[str, int], int] resample: Resampling = <Resampling.BICUBIC: 3> data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None **kwargs ) np.ndarray

引數

  • image (np.ndarray) — 要調整大小的影像。
  • resample (PILImageResampling, 可選, 預設為 PILImageResampling.BICUBIC) — 調整影像大小時使用的 PILImageResampling 濾波器,例如 PILImageResampling.BICUBIC
  • data_format (ChannelDimensionstr, 可選) — 輸出影像的通道維度格式。如果未設定,將使用輸入影像的通道維度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 影像格式為 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 影像格式為 (height, width, num_channels)。
    • None: 將從輸入中推斷。
  • 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)。

返回

np.ndarray

調整大小後的影像。

將影像調整為動態計算的大小。

unnormalize

< >

( image: <built-in function array> image_mean: typing.Union[float, collections.abc.Iterable[float]] image_std: typing.Union[float, collections.abc.Iterable[float]] input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

引數

  • image (形狀為 (batch_size, num_channels, image_size, image_size)(num_channels, image_size, image_size)torch.Tensor) — 要後處理的畫素值批次。
  • image_mean (floatIterable[float]) — 用於反歸一化的均值。
  • image_std (floatIterable[float]) — 用於反歸一化的標準差。
  • 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)。

使用 meanstd 指定的均值和標準差對 image 進行反歸一化。image = (image * image_std) + image_mean

JanusVisionModel

class transformers.JanusVisionModel

< >

( config: JanusVisionConfig )

引數

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

裸 Janus 模型,輸出原始隱藏狀態,頂部沒有任何特定頭部。

此模型繼承自 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 return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(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
  • return_dict (bool, 可選) — 是否返回 ModelOutput 而不是純元組。
  • interpolate_pos_encoding (bool, 預設為 False) — 是否插值預訓練位置編碼。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一個 transformers.modeling_outputs.BaseModelOutputWithPoolingtorch.FloatTensor 的元組(如果傳遞了 return_dict=Falseconfig.return_dict=False),包含根據配置(JanusConfig)和輸入而變化的各種元素。

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

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

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

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

  • attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=Trueconfig.output_attentions=True 時返回) — torch.FloatTensor 元組(每層一個),形狀為 (batch_size, num_heads, sequence_length, sequence_length)

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

JanusVisionModel 的 forward 方法,覆蓋了 __call__ 特殊方法。

雖然前向傳播的配方需要在此函式中定義,但之後應該呼叫 Module 例項而不是此函式,因為前者負責執行預處理和後處理步驟,而後者則默默忽略它們。

JanusVQVAE

class transformers.JanusVQVAE

< >

( config: JanusVQVAEConfig )

引數

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

Janus 中用於將影像編碼/解碼為離散 token 的 VQ-VAE 模型。此模型遵循 Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, and Yaniv Taigman 的“Make-a-scene: Scene-based text-to-image generation with human priors”論文。

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

此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組,並參考 PyTorch 文件中與一般用法和行為相關的所有事項。

forward

< >

( pixel_values: 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} 處理影像)。

JanusVQVAE 的 forward 方法,覆蓋了 __call__ 特殊方法。

雖然前向傳播的配方需要在此函式中定義,但之後應該呼叫 Module 例項而不是此函式,因為前者負責執行預處理和後處理步驟,而後者則默默忽略它們。

JanusModel

class transformers.JanusModel

< >

( config: JanusConfig )

引數

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

Janus 模型,由 siglip 視覺骨幹、Llama 語言模型和 VQ 模型組成。

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

此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組,並參考 PyTorch 文件中與一般用法和行為相關的所有事項。

forward

< >

( input_ids: LongTensor = None pixel_values: FloatTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None cache_position: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs )

引數

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

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

    什麼是 input ID?

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

    • 1 表示 未被掩碼 的 token,
    • 0 表示 被掩碼 的 token。

    什麼是注意力掩碼?

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

    什麼是位置 ID?

  • past_key_values (~cache_utils.Cache, 可選) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速順序解碼。這通常包括模型在解碼上一階段返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,請參閱我們的 kv 快取指南
    • 長度為 config.n_layerstuple(torch.FloatTensor) 元組,每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量)。這也被稱為舊版快取格式。

    模型將輸出與作為輸入饋送的快取格式相同的快取格式。如果沒有傳入 past_key_values,將返回舊版快取格式。

    如果使用 past_key_values,使用者可以選擇只輸入形狀為 (batch_size, 1) 的最後一個 input_ids(那些沒有將其過去的鍵值狀態提供給此模型的)而不是形狀為 (batch_size, sequence_length) 的所有 input_ids

  • cache_position (形狀為 (sequence_length)torch.LongTensor, 可選) — 序列中輸入序列 token 位置的索引。與 position_ids 不同,此張量不受填充影響。它用於在正確位置更新快取並推斷完整的序列長度。
  • inputs_embeds (形狀為 (batch_size, sequence_length, hidden_size)torch.FloatTensor, 可選) — 可選地,您可以選擇直接傳遞嵌入表示,而不是傳遞 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制,這將非常有用。
  • use_cache (bool, 可選) — 如果設定為 True,將返回 past_key_values 鍵值狀態,並可用於加速解碼(請參閱 past_key_values)。
  • output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊,請參閱返回張量下的 attentions
  • output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。有關詳細資訊,請參閱返回張量下的 hidden_states
  • logits_to_keep (Union[int, torch.Tensor], 預設為 0) — 如果是 int,則計算最後 logits_to_keep 個 token 的 logits。如果是 0,則計算所有 input_ids 的 logits(特殊情況)。生成時只需要最後一個 token 的 logits,只計算該 token 可以節省記憶體,這對於長序列或大詞彙量來說非常重要。如果是 torch.Tensor,則必須是 1D,對應於序列長度維度中要保留的索引。這在使用打包張量格式(批處理和序列長度的單維度)時非常有用。

JanusModel 的 forward 方法,覆蓋了 __call__ 特殊方法。

雖然前向傳播的配方需要在此函式中定義,但之後應該呼叫 Module 例項而不是此函式,因為前者負責執行預處理和後處理步驟,而後者則默默忽略它們。

JanusForConditionalGeneration

class transformers.JanusForConditionalGeneration

< >

( config: JanusConfig )

forward

< >

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

引數

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

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

    什麼是 input ID?

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

    • 1 表示 未被掩碼 的 token,
    • 0 表示 被掩碼 的 token。

    什麼是注意力掩碼?

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

    什麼是位置ID?

  • past_key_values (~cache_utils.Cache可選) — 預先計算好的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在解碼前期返回的 past_key_values,當 use_cache=Trueconfig.use_cache=True 時。

    允許兩種格式:

    • 一個 Cache 例項,參見我們的 kv 快取指南
    • tuple(torch.FloatTensor) 的元組,長度為 config.n_layers,每個元組包含兩個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量)。這也稱為舊版快取格式。

    模型將輸出與輸入相同的快取格式。如果沒有傳入 past_key_values,則返回舊版快取格式。

    如果使用了 past_key_values,使用者可以選擇性地只輸入形狀為 (batch_size, 1) 的最後一個 input_ids(那些沒有將其過去鍵值狀態提供給此模型的)而不是形狀為 (batch_size, sequence_length) 的所有 input_ids

  • cache_position (torch.LongTensor,形狀為 (sequence_length)可選) — 表示輸入序列標記在序列中位置的索引。與 position_ids 不同,此張量不受填充影響。它用於在正確位置更新快取並推斷完整的序列長度。
  • inputs_embeds (torch.FloatTensor,形狀為 (batch_size, sequence_length, hidden_size)可選) — 可選擇直接傳入嵌入表示,而不是 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量有比模型內部嵌入查詢矩陣更多的控制,這將很有用。
  • labels (torch.LongTensor,形狀為 (batch_size, sequence_length)可選) — 用於計算掩碼語言建模損失的標籤。索引應在 [0, ..., config.vocab_size] 或 -100 之間(參見 input_ids 文件字串)。索引設定為 -100 的標記將被忽略(掩碼),損失僅針對標籤在 [0, ..., config.vocab_size] 中的標記計算。
  • use_cache (bool可選) — 如果設定為 True,則返回 past_key_values 鍵值狀態,可用於加速解碼(參見 past_key_values)。
  • output_attentions (bool可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參見返回張量下的 attentions
  • output_hidden_states (bool可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參見返回張量下的 hidden_states
  • logits_to_keep (Union[int, torch.Tensor],預設為 0) — 如果是 int 型別,則計算最後 logits_to_keep 個標記的 logits。如果是 0,則計算所有 input_ids 的 logits(特殊情況)。生成時只需要最後一個標記的 logits,只計算該標記的 logits 可以節省記憶體,這對於長序列或大詞彙量來說非常顯著。如果是 torch.Tensor 型別,則必須是與序列長度維度中要保留的索引相對應的一維張量。這在使用打包張量格式(批次和序列長度的單個維度)時很有用。

JanusForConditionalGenerationforward 方法,重寫了 __call__ 特殊方法。

雖然前向傳播的配方需要在此函式中定義,但之後應該呼叫 Module 例項而不是此函式,因為前者負責執行預處理和後處理步驟,而後者則默默忽略它們。

示例

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

>>> model = JanusForConditionalGeneration.from_pretrained("deepseek-community/Janus-Pro-1B")
>>> processor = AutoProcessor.from_pretrained("deepseek-community/Janus-Pro-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
< > 在 GitHub 上更新

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