Hugging Face's logo

Transformers documentation

Emu3

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 27 de septiembre de 2024 y se contribuyó a Hugging Face Transformers el 10 de enero de 2025.

Emu3

FlashAttention SDPA

Resumen

El modelo Emu3 fue propuesto en Emu3: Next-Token Prediction is All You Need por Xinlong Wang, Xiaosong Zhang, Zhengxiong Luo, Quan Sun, Yufeng Cui, Jinsheng Wang, Fan Zhang, Yueze Wang, Zhen Li, Qiying Yu, Yingli Zhao, Yulong Ao, Xuebin Min, Tao Li, Boya Wu, Bo Zhao, Bowen Zhang, Liangdong Wang, Guang Liu, Zheqi He, Xi Yang, Jingjing Liu, Yonghua Lin, Tiejun Huang, Zhongyuan Wang.

Emu3 es un LLM multimodal que utiliza la cuantización de vectores para tokenizar imágenes en tokens discretos. Los tokens de imagen discretizados se fusionan posteriormente con los ids de tokens de texto para la generación de imágenes y texto. El modelo también puede generar imágenes prediciendo los ids de tokens de imagen.

El resumen del artículo es el siguiente:

Aunque la predicción del siguiente token se considera una prometedora vía hacia la inteligencia artificial general, ha tenido dificultades para destacar en tareas multimodales, que aún están dominadas por modelos de difusión (p. ej., Stable Diffusion) y enfoques composicionales (p. ej., CLIP combinado con LLMs). En este artículo, presentamos Emu3, una nueva suite de modelos multimodales de última generación entrenados exclusivamente con predicción del siguiente token. Al tokenizar imágenes, texto y videos en un espacio discreto, entrenamos un único transformer desde cero sobre una mezcla de secuencias multimodales. Emu3 supera a varios modelos específicos de tarea bien establecidos en tareas de generación y percepción, superando a modelos insignia como SDXL y LLaVA-1.6, al tiempo que elimina la necesidad de arquitecturas de difusión o composicionales. Emu3 también es capaz de generar video de alta fidelidad mediante la predicción del siguiente token en una secuencia de video. Simplificamos los diseños complejos de modelos multimodales al converger en un enfoque singular: tokens, lo que desbloquea un gran potencial para escalar tanto durante el entrenamiento como la inferencia. Nuestros resultados demuestran que la predicción del siguiente token es una prometedora vía para construir una inteligencia multimodal general más allá del lenguaje. Hacemos públicas las técnicas y modelos clave para apoyar la investigación adicional en esta dirección.

Consejos:

  • Recomendamos a los usuarios establecer processor.tokenizer.padding_side = "left" antes de la generación por lotes, ya que esto conduce a resultados más precisos.

  • Tenga en cuenta que el modelo se ha entrenado con un formato de prompt específico para chatear. Use processor.apply_chat_template(my_conversation_dict) para formatear correctamente sus prompts.

  • Emu3 tiene dos puntos de control diferentes para la generación de imágenes y la generación de texto; asegúrese de usar el punto de control correcto al cargar el modelo. Para generar una imagen, se recomienda usar prefix_constraints para que los tokens generados se muestreen solo de entre los tokens de imagen posibles. Consulte más abajo para ver ejemplos de uso.

La implementación de Emu3 en Transformers utiliza un token de imagen especial para indicar dónde fusionar los embeddings de imagen. Este token de imagen especial no es nuevo y utiliza uno de los tokens reservados: <|extra_0|>. Debes agregar <image> a tu prompt en el lugar donde se debe incrustar la imagen para una generación correcta.

Este modelo fue aportado por RaushanTurganbay. El código original se puede encontrar aquí.

Ejemplo de uso

Inferencia de generación de texto

A continuación se muestra cómo cargar el modelo y realizar inferencia en media precisión (torch.bfloat16) para generar salida de texto a partir de entradas de texto o de texto e imagen:

import requests
from PIL import Image

from transformers import Emu3ForConditionalGeneration, Emu3Processor


processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")
model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Chat-hf", device_map="auto")

# prepare image and text prompt
url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)
prompt = "What do you see in this image?<image>"

inputs = processor(images=image, text=prompt, return_tensors="pt").to(model.device)

# autoregressively complete prompt
output = model.generate(**inputs, max_new_tokens=50)
print(processor.decode(output[0], skip_special_tokens=True))

Inferencia de generación de imágenes

Emu3 también puede generar imágenes a partir de texto. A continuación se muestra cómo hacerlo:

processor = Emu3Processor.from_pretrained("BAAI/Emu3-Gen-hf")
model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Gen-hf", device_map="auto", attn_implementation="flash_attention_2")


inputs = processor(
    text=["a portrait of young girl. masterpiece, film grained, best quality.", "a dog running under the rain"],
    padding=True,
    return_tensors="pt",
    return_for_image_generation=True,
)
inputs = inputs.to(device=model.device)

neg_prompt = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry."
neg_inputs = processor(text=[neg_prompt] * 2, return_tensors="pt").to(device=model.device)

image_sizes = inputs.pop("image_sizes")
HEIGHT, WIDTH = image_sizes[0]
VISUAL_TOKENS = model.vocabulary_mapping.image_tokens

def prefix_allowed_tokens_fn(batch_id, input_ids):
    height, width = HEIGHT, WIDTH
    visual_tokens = VISUAL_TOKENS
    image_wrapper_token_id = torch.tensor([processor.tokenizer.image_wrapper_token_id], device=model.device)
    eoi_token_id = torch.tensor([processor.tokenizer.eoi_token_id], device=model.device)
    eos_token_id = torch.tensor([processor.tokenizer.eos_token_id], device=model.device)
    pad_token_id = torch.tensor([processor.tokenizer.pad_token_id], device=model.device)
    eof_token_id = torch.tensor([processor.tokenizer.eof_token_id], device=model.device)
    eol_token_id = processor.tokenizer.encode("<|extra_200|>", return_tensors="pt").to(model.device)[0]

    position = torch.nonzero(input_ids == image_wrapper_token_id, as_tuple=True)[0][0]
    offset = input_ids.shape[0] - position
    if offset % (width + 1) == 0:
        return (eol_token_id, )
    elif offset == (width + 1) * height + 1:
        return (eof_token_id, )
    elif offset == (width + 1) * height + 2:
        return (eoi_token_id, )
    elif offset == (width + 1) * height + 3:
        return (eos_token_id, )
    elif offset > (width + 1) * height + 3:
        return (pad_token_id, )
    else:
        return visual_tokens


out = model.generate(
    **inputs,
    max_new_tokens=50_000, # make sure to have enough tokens for one image
    prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,
    return_dict_in_generate=True,
    negative_prompt_ids=neg_inputs.input_ids, # indicate for Classifier-Free Guidance
    negative_prompt_attention_mask=neg_inputs.attention_mask,
)

image = model.decode_image_tokens(out.sequences[:, inputs.input_ids.shape[1]: ], height=HEIGHT, width=WIDTH)
images = processor.postprocess(list(image.float()), return_tensors="PIL.Image.Image").to(model.device) # internally we convert to np but it's not supported in bf16 precision
for i, image in enumerate(images['pixel_values']):
    image.save(f"result{i}.png")

Emu3Config

clase transformers.Emu3Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevq_config: dict | transformers.models.emu3.configuration_emu3.Emu3VQVAEConfig | None = Nonetext_config: dict | transformers.models.emu3.configuration_emu3.Emu3TextConfig | None = Nonevocabulary_map: dict[str, int] | None = Nonetie_word_embeddings: bool = False )

Parámetros

  • vq_config (Union[dict, ~models.emu3.configuration_emu3.Emu3VQVAEConfig], opcional) — Diccionario de configuración del módulo de cuantización vectorial.
  • text_config (Union[dict, ~models.emu3.configuration_emu3.Emu3TextConfig], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • vocabulary_map (dict, opcional) — Un diccionario que contiene el mapa de vocabulario del tokenizador. Se utiliza para obtener tokens de las entradas de imagen.
  • tie_word_embeddings (bool, opcional, valor predeterminado False) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un Emu3Model. Se utiliza para instanciar un modelo Emu3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de Emu3-community/Emu3-Chat-hf

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Emu3VQVAEConfig

clase transformers.Emu3VQVAEConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonecodebook_size: int = 32768embed_dim: int = 4latent_channels: int = 4double_latent: bool = Falsein_channels: int = 3out_channels: int = 3temporal_downsample_factor: int = 4base_channels: int = 256channel_multiplier: list[int] | tuple[int, ...] = (1, 2, 2, 4)num_res_blocks: int = 2attn_resolutions: list[int] | tuple[int, ...] = (3,)hidden_size: int = 1024num_attention_heads: int = 1attention_dropout: float | int = 0.0 )

Parámetros

  • codebook_size (int, opcional, valor predeterminado 32768) — El número de libros de códigos paralelos utilizados por el modelo.
  • embed_dim (int, opcional, valor predeterminado 4) — Dimensión del vector cuantizado en el codebook.
  • latent_channels (int, opcional, valor predeterminado 4) — Número de canales para el espacio latente.
  • double_latent (bool, opcional, valor predeterminado False) — Si se deben usar canales z dobles.
  • in_channels (int, opcional, valor predeterminado 3) — El número de canales de entrada.
  • out_channels (int, opcional, valor predeterminado 3) — Canal de salida del decodificador.
  • temporal_downsample_factor (int, opcional, valor predeterminado 4) — Factor de muestreo temporal.
  • base_channels (int, opcional, valor predeterminado 256) — Número básico de canales de los bloques intermedios.
  • channel_multiplier (list[int], opcional, valor predeterminado [1, 2, 2, 4]) — Factor de escalado de canales de los bloques intermedios.
  • num_res_blocks (int, opcional, valor predeterminado 2) — Número de bloques residuales en cada etapa.
  • attn_resolutions (list[int], opcional, valor predeterminado [3]) — Índices de etapa a los que aplicar la atención.
  • hidden_size (int, opcional, valor predeterminado 1024) — Dimensión de las representaciones ocultas.
  • num_attention_heads (int, opcional, valor predeterminado 1) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.

Esta es la clase de configuración para almacenar la configuración de un Emu3Model. Se utiliza para instanciar un modelo Emu3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de Emu3-community/Emu3-Chat-hf

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

>>> from transformers import Emu3VQVAE, Emu3VQVAEConfig

>>> # Initializing a video VQ model of Emu3 configuration
>>> configuration = Emu3VQVAEConfig()

>>> # Initializing a model from the Emu3 VQ model style configuration
>>> model = Emu3VQVAE(configuration)

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

Emu3TextConfig

clase transformers.Emu3TextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 184622hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int | None = 8hidden_act: str = 'silu'max_position_embeddings: int = 9216rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int = 151643bos_token_id: int = 151849eos_token_id: int | list[int] | None = 151850rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_dropout: float | int = 0.1initializer_range: float = 0.02tie_word_embeddings: bool = False )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 184622) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • hidden_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones ocultas.
  • intermediate_size (int, opcional, valor predeterminado 14336) — Dimensión de las representaciones del MLP.
  • num_hidden_layers (int, opcional, valor predeterminado 32) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 32) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • num_key_value_heads (int, opcional, valor predeterminado 8) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Si num_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); si num_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado será num_attention_heads.
  • hidden_act (str, opcional, valor predeterminado silu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, valor predeterminado 9216) — La longitud máxima de secuencia con la que podría usarse este modelo.
  • rms_norm_eps (float, opcional, valor predeterminado 1e-05) — La epsilon utilizada por las capas de normalización rms.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante si config.is_decoder=True o cuando el modelo es un modelo generativo solo de decodificador.
  • pad_token_id (int, opcional, valor predeterminado 151643) — Id del token utilizado para el relleno en el vocabulario.
  • bos_token_id (int, opcional, valor predeterminado 151849) — Identificador de token utilizado para el inicio de la secuencia en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 151850) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para rope_theta y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con max_position_embeddings más largos.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • tie_word_embeddings (bool, opcional, valor predeterminado False) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un Emu3Model. Se utiliza para instanciar un modelo Emu3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de Emu3-community/Emu3-Chat-hf

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import Emu3Model, Emu3Config

>>> # Initializing a Emu3-community/Emu3-Chat-hf style configuration
>>> configuration = Emu3Config()

>>> # Initializing a model from the Emu3-community/Emu3-Chat-hf style configuration
>>> model = Emu3Model(configuration)

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

Emu3Processor

clase transformers.Emu3Processor

< >

( image_processortokenizerchat_template = None**kwargs )

Parámetros

  • image_processor (Emu3ImageProcessor) — El procesador de imágenes es una entrada obligatoria.
  • tokenizer (GPT2Tokenizer) — El tokenizador es una entrada obligatoria.
  • chat_template (str) — Plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

Construye un Emu3Processor que envuelve un procesador de imágenes y un tokenizador en un único procesador.

Emu3Processor ofrece todas las funcionalidades de Emu3ImageProcessor y GPT2Tokenizer. Consulte ~Emu3ImageProcessor y ~GPT2Tokenizer para obtener más información.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = None**kwargs: *<class 'transformers.models.emu3.processing_emu3.Emu3ProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature

Parámetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca do_rescale=False.
  • text (Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • return_for_image_generation (bool, kwargs, opcional, valor predeterminado False) — Indica si el texto procesado está destinado a tareas de generación de imágenes. Cuando es True, el procesador prepara las entradas para la generación de imágenes añadiendo tokens de inicio de imagen e información de tamaño al prompt, y no se deben proporcionar imágenes. Cuando es False, el procesador prepara las entradas para la generación de texto a partir de imágenes y texto, requiriendo que se proporcionen ambas entradas.
  • ratio (str, kwargs, opcional, valor predeterminado "1 --1"): La proporción de la imagen para redimensionar la imagen.
  • image_area (int, kwargs, opcional, valor predeterminado 518400) — El área de la imagen a la que se debe redimensionar la imagen.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Devuelve

~feature_extraction_utils.BatchFeature

  • data (dict, opcional) — Diccionario de listas/arrays/tensores devueltos por los métodos call/pad (‘input_values’, ‘attention_mask’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.
  • skip_tensor_conversion (list[str] o set[str], opcional) — Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especifica tensor_type.

Emu3ImageProcessor

clase transformers.Emu3ImageProcessor

< >

( do_resize: bool = Trueresample: Resampling = <Resampling.BICUBIC: 3>do_rescale: bool = Truerescale_factor: int | float = 0.00392156862745098do_normalize: bool = Trueimage_mean: float | list[float] | None = Noneimage_std: float | list[float] | None = Nonedo_convert_rgb: bool = Truedo_pad: bool = Truemin_pixels: int = 262144max_pixels: int = 1048576spatial_factor: int = 8**kwargs )

Parámetros

  • do_resize (bool, opcional, valor predeterminado True) — Si se deben redimensionar las dimensiones (altura, ancho) de la imagen.
  • resample (PILImageResampling, opcional, por defecto Resampling.BICUBIC) — Filtro de remuestreo que se utiliza al redimensionar la imagen.
  • do_rescale (bool, opcional, valor predeterminado True) — Si se debe reescalar la imagen según el factor de escala especificado rescale_factor.
  • rescale_factor (int o float, opcional, por defecto 1/255) — Factor de escala a utilizar si se reescala la imagen.
  • do_normalize (bool, opcional, valor predeterminado True) — Si se debe normalizar la imagen.
  • image_mean (float o list[float], opcional, valor predeterminado [0.48145466, 0.4578275, 0.40821073]) — Media a utilizar si se normaliza la imagen. Es un float o una lista de floats para cada canal de la imagen.
  • image_std (float o list[float], opcional, valor predeterminado [0.26862954, 0.26130258, 0.27577711]) — Desviación estándar a utilizar si se normaliza la imagen. Es un float o una lista de floats para cada canal de la imagen.
  • do_convert_rgb (bool, opcional, por defecto True) — Si se debe convertir la imagen a RGB.
  • do_pad (bool, opcional, valor predeterminado True) — Indica si se debe aplicar relleno a la imagen. Si es True, se rellenará la dimensión de parches de las imágenes del lote hasta el mayor número de parches presente en el lote. El relleno se aplicará en la parte inferior y derecha con ceros.
  • min_pixels (int, opcional, valor predeterminado 512 * 512) — El número mínimo de píxeles de la imagen para redimensionarla.
  • max_pixels (int, opcional, valor predeterminado 1024 * 1024) — El número máximo de píxeles de la imagen para redimensionarla.
  • spatial_factor (int, opcional, valor predeterminado 8) — Factor de reducción espacial en el que la imagen se reducirá durante la fase de extracción de características

Construye un procesador de imágenes Emu3 que redimensiona dinámicamente las imágenes en función de las imágenes originales.

preprocesar

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]do_resize: bool | None = Nonesize: dict[str, int] | None = Noneresample: PIL.Image.Resampling | None = Nonedo_rescale: bool | None = Nonerescale_factor: float | None = Nonedo_normalize: bool | None = Noneimage_mean: float | list[float] | None = Noneimage_std: float | list[float] | None = Nonedo_convert_rgb: bool | None = Nonedo_pad: bool = Truereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonedata_format: transformers.image_utils.ChannelDimension | None = <ChannelDimension.FIRST: 'channels_first'>input_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs )

Parámetros

  • images (ImageInput) — Imagen a preprocesar. Espera una sola imagen o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca do_rescale=False.
  • do_resize (bool, opcional, valor predeterminado self.do_resize) — Si se debe redimensionar la imagen.
  • size (dict[str, int], opcional, valor predeterminado self.size) — Tamaño de la imagen después del redimensionado. El borde más corto de la imagen se redimensiona a size[“shortest_edge”], mientras que el borde más largo se redimensiona para mantener la relación de aspecto de la entrada.
  • resample (int, opcional, valor predeterminado self.resample) — Filtro de remuestreo que se utilizará si se cambia el tamaño de la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, opcional, por defecto self.do_rescale) — Si se debe reescalar la imagen.
  • rescale_factor (float, opcional, por defecto self.rescale_factor) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, opcional, valor predeterminado self.do_normalize) — Si se debe normalizar la imagen.
  • image_mean (float o list[float], opcional, valor predeterminado self.image_mean) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (float o list[float], opcional, valor predeterminado self.image_std) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_convert_rgb (bool, opcional, por defecto self.do_convert_rgb) — Si se debe convertir la imagen a RGB.
  • do_pad (bool, opcional, valor predeterminado True) — Indica si se debe aplicar relleno a la imagen. Si es True, se rellenará la dimensión de parches de las imágenes del lote hasta el mayor número de parches presente en el lote. El relleno se aplicará en la parte inferior y derecha con ceros.
  • return_tensors (str o TensorType, opcional) — El tipo de tensores a devolver. Puede ser uno de:
    • Unset: Devuelve una lista de np.ndarray.
    • TensorType.PYTORCH o 'pt': devuelve un lote de tipo torch.Tensor.
    • TensorType.NUMPY o 'np': Devuelve un lote de tipo np.ndarray.
  • data_format (ChannelDimension o str, opcional, por defecto es ChannelDimension.FIRST) — El formato de la dimensión de canales para la imagen de salida. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • Unset: usa el formato de la dimensión de canal de la imagen de entrada.
  • input_data_format (ChannelDimension o str, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).

Emu3VQVAE

clase transformers.Emu3VQVAE

< >

( config: Emu3VQVAEConfig )

Parámetros

  • config (Emu3VQVAEConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo VQ-VAE utilizado en Emu3 para codificar/decodificar imágenes en tokens discretos. Este modelo sigue el artículo “Make-a-scene: Scene-based text-to-image generation with human priors” de Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, and Yaniv Taigman.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

( *args**kwargs )

Un valor simulado para una ruta con puntos (p. ej. torch.float32): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, repr es la ruta con puntos, y su uso como clase base sustituye una base de type simple (PEP 560 __mro_entries__), de modo que las subclases reales conservan un metaclass normal y inspect.signature lee su __init__ real en lugar del de un simulado.

Emu3TextModel

clase transformers.Emu3TextModel

< >

( config: Emu3TextConfig )

Parámetros

  • config (Emu3TextConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo de texto Emu3 sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).

Devuelve

BaseModelOutputWithPast o tuple(torch.Tensor)

Un BaseModelOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Emu3Config) y las entradas.

El método forward de Emu3TextModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Emu3Model

clase transformers.Emu3Model

< >

( config: Emu3Config )

decode_image_tokens

< >

( image_tokens: LongTensorheight: intwidth: int )

Parámetros

  • image_tokens (torch.LongTensor de forma (batch_size, num_of_tokens)) — Los tensores correspondientes a las imágenes de entrada.
  • height (int) — Altura de la imagen generada antes del aumento de escala.
  • width (int) — Ancho de la imagen generada antes del aumento de escala.

Decodifica los tokens de imagen generados por el modelo de lenguaje a valores de píxeles continuos mediante el módulo VQGAN a través de una interpolación ascendente.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando Emu3ImageProcessor. Consulte Emu3ImageProcessor.call() para más detalles (Emu3Processor utiliza Emu3ImageProcessor para procesar las imágenes).
  • image_sizes (torch.LongTensor de forma (batch_size, 2)) — Los tamaños de las imágenes en el lote, siendo (altura, ancho) para cada imagen. Los tamaños de las imágenes se pueden obtener utilizando AutoImageProcessor. Consulte Emu3ImageProcessor.call() para más detalles ([]Emu3Processor] utiliza Emu3ImageProcessor para procesar las imágenes).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

Devuelve

CausalLMOutputWithPast o tuple(torch.Tensor)

Un CausalLMOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Emu3Config) y las entradas.

El método forward de Emu3Model sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

get_image_features

< >

( pixel_values: Tensorimage_sizes: LongTensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Emu3VQVAEModelOutput or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor de forma `(batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada.
  • image_sizes (torch.LongTensor de forma (batch_size, 2)) — Los tamaños de las imágenes en el lote, siendo (altura, ancho) para cada imagen.

Devuelve

Emu3VQVAEModelOutput o tuple(torch.Tensor)

Un Emu3VQVAEModelOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Emu3Config) y las entradas.

Tokeniza las imágenes en tokens discretos con el módulo VQGAN y las incrusta con la capa de incrustaciones de texto

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • image_tokens (torch.LongTensor de forma (batch_size, config.vocab_size) — Índices de los tokens de imagen predichos por el modelo VQ-VAE.

get_image_tokens

< >

( pixel_values: Tensorimage_sizes: LongTensor )

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada.
  • image_sizes (torch.LongTensor de forma (batch_size, 2)) — Los tamaños de las imágenes en el lote, siendo (altura, ancho) para cada imagen.

Tokeniza las imágenes en tokens discretos con el módulo VQGAN. Convierte los tokens de imagen obtenidos en tokens BPE y los envuelve con los tokens especiales “boi” y “eoi”.

get_placeholder_mask

< >

( input_ids: LongTensorinputs_embeds: Tensorimage_features: Tensor )

Obtiene la máscara de marcador de posición multimodal a partir de input_ids o inputs_embeds y comprueba que la cantidad de tokens de marcador de posición sea igual a la longitud de las características multimodales. Si las longitudes son diferentes, se genera un error.

Emu3ForCausalLM

clase transformers.Emu3ForCausalLM

< >

( config: Emu3TextConfig )

Parámetros

  • config (Emu3TextConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo Emu3 para el modelado de lenguaje causal.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
  • logits_to_keep (Union[int, torch.Tensor], opcional, valor predeterminado 0) — Si es un int, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un torch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

Devuelve

CausalLMOutputWithPast o tuple(torch.Tensor)

Un CausalLMOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Emu3Config) y las entradas.

El método forward de Emu3ForCausalLM sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

>>> from transformers import Emu3Processor, Emu3ForConditionalGeneration
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image

>>> model = Emu3ForCausalLM.from_pretrained("BAAI/Emu3-Chat-hf", dtype=torch.bfloat16)
>>> processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")

>>> inputs = processor(text=["Can you write me a poem about winter."], return_tensors="pt").to(model.device)

>>> generated_ids = model.generate(**inputs, max_new_tokens=100, do_sample=False)
>>> processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

Emu3ForConditionalGeneration

clase transformers.Emu3ForConditionalGeneration

< >

( config: Emu3Config )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando Emu3ImageProcessor. Consulte Emu3ImageProcessor.call() para más detalles (Emu3Processor utiliza Emu3ImageProcessor para procesar las imágenes).
  • image_sizes (torch.LongTensor de forma (batch_size, 2)) — Los tamaños de las imágenes en el lote, siendo (altura, ancho) para cada imagen. Los tamaños de las imágenes se pueden obtener utilizando AutoImageProcessor. Consulte Emu3ImageProcessor.call() para más detalles ([]Emu3Processor] utiliza Emu3ImageProcessor para procesar las imágenes).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
  • logits_to_keep (Union[int, torch.Tensor], opcional, valor predeterminado 0) — Si es un int, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un torch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

Devuelve

CausalLMOutputWithPast o tuple(torch.Tensor)

Un CausalLMOutputWithPast o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Emu3Config) y las entradas.

El método forward de Emu3ForConditionalGeneration sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

>>> from transformers import Emu3Processor, Emu3ForConditionalGeneration
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image

>>> model = Emu3ForConditionalGeneration.from_pretrained("BAAI/Emu3-Chat-hf", dtype=torch.bfloat16)
>>> processor = Emu3Processor.from_pretrained("BAAI/Emu3-Chat-hf")

>>> conversation = [
...     {
...     "role": "system",
...     "content": [
...         {"type": "text", "text": "You are a helpful assistant."},
...         ],
...     },
...     {
...     "role": "user",
...     "content": [
...         {"type": "image"},
...         {"type": "text", "text": "Please describe the image."},
...         ],
...     },
... ]

>>> prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=[image], text=[prompt], return_tensors="pt").to(model.device, torch.bfloat16)

>>> generated_ids = model.generate(**inputs, max_new_tokens=100, do_sample=False)
>>> processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
Update on GitHub

←EmbeddingGemma2 ernie4_5_vl_moe→