Transformers documentation
Perceiver
Este modelo se publicó en HF papers el 30-07-2021 y se contribuyó a Hugging Face Transformers el 08-12-2021.
Perceiver
Resumen
El modelo Perceiver IO fue propuesto en Perceiver IO: A General Architecture for Structured Inputs & Outputs por Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hénaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, João Carreira.
Perceiver IO es una generalización de Perceiver para manejar salidas arbitrarias además de entradas arbitrarias. El Perceiver original solo producía una única etiqueta de clasificación. Además de las etiquetas de clasificación, Perceiver IO puede producir (por ejemplo) lenguaje, flujo óptico y videos multimodales con audio. Esto se logra utilizando los mismos bloques de construcción que el Perceiver original. La complejidad computacional de Perceiver IO es lineal en el tamaño de la entrada y la salida, y la mayor parte del procesamiento ocurre en el espacio latente, lo que nos permite procesar entradas y salidas mucho más grandes de las que pueden manejar los Transformers estándar. Esto significa, por ejemplo, que Perceiver IO puede realizar modelado de lenguaje enmascarado estilo BERT directamente usando bytes en lugar de entradas tokenizadas.
El resumen del artículo es el siguiente:
El modelo Perceiver, propuesto recientemente, obtiene buenos resultados en varios dominios (imágenes, audio, multimodal, nubes de puntos) mientras escala linealmente en cómputo y memoria con el tamaño de la entrada. Aunque Perceiver admite muchos tipos de entradas, solo puede producir salidas muy simples, como puntuaciones de clase. Perceiver IO supera esta limitación sin sacrificar las propiedades atractivas del modelo original, al aprender a consultar de forma flexible el espacio latente del modelo para producir salidas de tamaño y semántica arbitrarios. Perceiver IO sigue desacoplando la profundidad del modelo del tamaño de los datos y sigue escalando linealmente con el tamaño de los datos, pero ahora con respecto a los tamaños tanto de entrada como de salida. El modelo completo de Perceiver IO logra resultados sólidos en tareas con espacios de salida altamente estructurados, como el lenguaje natural y la comprensión visual, StarCraft II, y dominios multitarea y multimodales. Como puntos destacados, Perceiver IO iguala a una línea base BERT basada en Transformers en el benchmark de lenguaje GLUE sin necesidad de tokenización de entrada y logra un rendimiento de última generación en la estimación de flujo óptico de Sintel.
Aquí hay un resumen (TLDR) que explica cómo funciona Perceiver:
El principal problema con el mecanismo de autoatención del Transformer es que los requisitos de tiempo y memoria escalan de forma cuadrática con la longitud de la secuencia. Por lo tanto, modelos como BERT y RoBERTa están limitados a una longitud máxima de secuencia de 512 tokens. Perceiver busca resolver este problema realizando la autoatención no sobre las entradas, sino sobre un conjunto de variables latentes, y utilizando las entradas únicamente para la atención cruzada. De esta manera, los requisitos de tiempo y memoria ya no dependen de la longitud de las entradas, ya que se utiliza una cantidad fija de variables latentes, como 256 o 512. Estas se inicializan aleatoriamente y, a continuación, se entrenan de extremo a extremo mediante retropropagación.
Internamente, PerceiverModel creará los latentes, que es un tensor de forma (batch_size, num_latents, d_latents). Se debe proporcionar inputs (que pueden ser texto, imágenes, audio, lo que se les ocurra) al modelo, el cual los utilizará para realizar atención cruzada con los latentes. La salida del codificador Perceiver es un tensor de la misma forma. A continuación, de manera similar a BERT, se pueden convertir los últimos estados ocultos de los latentes en logits de clasificación promediando a lo largo de la dimensión de la secuencia y colocando una capa lineal encima para proyectar los d_latents a num_labels.
Esta era la idea del artículo original de Perceiver. Sin embargo, solo podía generar logits de clasificación. En un trabajo posterior, PerceiverIO, lo generalizaron para permitir que el modelo también produzca salidas de tamaño arbitrario. ¿Cómo, te preguntarás? La idea es en realidad relativamente simple: se definen salidas de un tamaño arbitrario y luego se aplica atención cruzada con los últimos estados ocultos de los latentes, utilizando las salidas como consultas y los latentes como claves y valores.
Supongamos que se desea realizar modelado de lenguaje enmascarado (estilo BERT) con el Perceiver. Dado que la longitud de entrada del Perceiver no tendrá un impacto en el tiempo de cómputo de las capas de autoatención, se pueden proporcionar bytes crudos, ofreciendo inputs de longitud 2048 al modelo. Si ahora se enmascaran ciertos de estos 2048 tokens, se pueden definir los outputs como de forma: (batch_size, 2048, 768). A continuación, se realiza una atención cruzada con los estados ocultos finales de los latentes para actualizar el tensor outputs. Después de la atención cruzada, aún se tiene un tensor de forma (batch_size, 2048, 768). Entonces, se puede colocar una cabeza de modelado de lenguaje regular encima, para proyectar la última dimensión al tamaño del vocabulario del modelo, es decir, creando logits de forma (batch_size, 2048, 262) (ya que Perceiver utiliza un tamaño de vocabulario de 262 IDs de bytes).
Perceiver IO architecture. Taken from the original paper Este modelo fue aportado por nielsr. El código original se puede encontrar aquí.
Perceiver no funciona con
torch.nn.DataParalleldebido a un error en PyTorch, ver issue #36035
Recursos
- La forma más rápida de empezar con Perceiver es consultar los cuadernos de tutorial.
- Consulte la publicación en el blog si desea comprender a fondo cómo funciona el modelo y cómo está implementado en la biblioteca. Tenga en cuenta que los modelos disponibles en la biblioteca solo muestran algunos ejemplos de lo que se puede hacer con el Perceiver. Existen muchos más casos de uso, como la respuesta a preguntas, el reconocimiento de entidades nombradas, la detección de objetos, la clasificación de audio, la clasificación de video, etc.
- Guía de la tarea de clasificación de texto
- Guía de la tarea de modelado de lenguaje enmascarado
- Guía de la tarea de clasificación de imágenes
Salidas específicas de Perceiver
clase transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonelast_hidden_state: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parámetros
- logits (
torch.Tensorde forma(batch_size, num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax). - last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del modelo. - hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_hidden_states=Truese pasa o cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) con 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.
- cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Clase base para las salidas del modelo base de Perceiver, con posibles estados ocultos, atenciones y atenciones cruzadas.
clase transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parámetros
- logits (
torch.Tensorde forma(batch_size, num_labels)) — Salida del decodificador básico. - cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Clase base para las salidas del decodificador de Perceiver, con posibles cross-attentions.
clase transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parámetros
- loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje enmascarado (MLM). - logits (
torch.Tensorde 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). - hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_hidden_states=Truese pasa o cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) con 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.
- cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Clase base para las salidas del modelo de lenguaje enmascarado de Perceiver.
clase transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Parámetros
- loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1). - logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax). - hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_hidden_states=Truese pasa o cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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 cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) con 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.
- cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Clase base para las salidas de Perceiver de modelos de clasificación de secuencias/imagen, flujo óptico y auto codificación multimodal.
PerceiverConfig
clase transformers.PerceiverConfig
< source >( 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 = Nonenum_latents: int = 256d_latents: int = 1280d_model: int = 768num_blocks: int = 1num_self_attends_per_block: int = 26num_self_attention_heads: int = 8num_cross_attention_heads: int = 8qk_channels: int | None = Nonev_channels: int | None = Nonecross_attention_shape_for_attention: str = 'kv'self_attention_widening_factor: int = 1cross_attention_widening_factor: int = 1hidden_act: str = 'gelu'attention_probs_dropout_prob: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_query_residual: bool = Truevocab_size: int = 262max_position_embeddings: int = 2048image_size: int | list[int] | tuple[int, int] = 56train_size: list[int] | tuple[int, ...] = (368, 496)num_frames: int = 16audio_samples_per_frame: int = 1920samples_per_patch: int = 16output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224)output_num_channels: int = 512_label_trainable_num_channels: int = 1024 )
Parámetros
- num_latents (
int, opcional, valor predeterminado 256) — El número de latentes. - d_latents (
int, opcional, valor predeterminado 1280) — Dimensión de las incrustaciones latentes. - d_model (
int, opcional, valor predeterminado768) — Tamaño de las capas del codificador y de la capa pooler. - num_blocks (
int, opcional, valor predeterminado 1) — Número de bloques en el codificador del Transformer. - num_self_attends_per_block (
int, opcional, valor predeterminado 26) — El número de capas de autoatención por bloque. - num_self_attention_heads (
int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de autoatención en el codificador Transformer. - num_cross_attention_heads (
int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención cruzada en el codificador Transformer. - qk_channels (
int, opcional) — Dimensión a la que proyectar las consultas + claves antes de aplicar la atención en las capas de atención cruzada y autoatención del codificador. Si no se especifica, se mantendrá la dimensión de las consultas por defecto. - v_channels (
int, opcional) — Dimensión a la que proyectar los valores antes de aplicar la atención en las capas de atención cruzada y autoatención del codificador. Si no se especifica, se mantendrá la dimensión de las consultas. - cross_attention_shape_for_attention (
str, opcional, valor predeterminado"kv") — Dimensión a utilizar al reducir el tamaño de las consultas y las claves en la capa de atención cruzada del codificador. - self_attention_widening_factor (
int, opcional, valor predeterminado 1) — Dimensión de la capa feed-forward en la capa de atención cruzada del codificador Transformer. - cross_attention_widening_factor (
int, opcional, valor predeterminado 1) — Dimensión de la capa feed-forward en las capas de autoatención del codificador Transformer. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - attention_probs_dropout_prob (
Union[float, int], opcional, valor predeterminado0.1) — La proporción de dropout para las probabilidades de atención. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-12) — El epsilon utilizado por las capas de normalización de capa. - use_query_residual (
float, opcional, valor predeterminadoTrue) — Si se debe añadir un residual de consulta en la capa de atención cruzada del codificador. - vocab_size (
int, opcional, valor predeterminado262) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - max_position_embeddings (
int, opcional, valor predeterminado2048) — La longitud máxima de secuencia con la que se podría utilizar este modelo. - image_size (
int, opcional, valor predeterminado 56) — Tamaño de las imágenes después del preprocesamiento, para PerceiverForImageClassificationLearned. - train_size (
list[int], opcional, valor predeterminado[368, 496]) — Tamaño de entrenamiento de las imágenes para el modelo de flujo óptico. - num_frames (
int, opcional, valor predeterminado 16) — Número de fotogramas de vídeo utilizados para el modelo de auto codificación multimodal. - audio_samples_per_frame (
int, opcional, valor predeterminado 1920) — Número de muestras de audio por cuadro para el modelo de auto codificación multimodal. - samples_per_patch (
int, opcional, valor predeterminado 16) — Número de muestras de audio por parche al preprocesar el audio para el modelo de auto codificación multimodal. - output_shape (
list[int], opcional, valor predeterminado[1, 16, 224, 224]) — Forma de la salida (batch_size, num_frames, height, width) para las consultas del decodificador de video del modelo de auto codificación multimodal. Esto excluye la dimensión de canal. - output_num_channels (
int, opcional, valor predeterminado 512) — Número de canales de salida para cada decodificador de modalidad.
Esta es la clase de configuración para almacenar la configuración de un PerceiverModel. Se utiliza para instanciar un modelo Perceiver 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 deepmind/language-perceiver
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 PerceiverModel, PerceiverConfig
>>> # Initializing a Perceiver deepmind/language-perceiver style configuration
>>> configuration = PerceiverConfig()
>>> # Initializing a model from the deepmind/language-perceiver style configuration
>>> model = PerceiverModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configPerceiverTokenizer
clase transformers.PerceiverTokenizer
< source >( pad_token = '[PAD]'bos_token = '[BOS]'eos_token = '[EOS]'mask_token = '[MASK]'cls_token = '[CLS]'sep_token = '[SEP]'model_max_length = 2048**kwargs )
Parámetros
- pad_token (
str, opcional, valor predeterminado"[PAD]") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes. - bos_token (
str, opcional, valor predeterminado"[BOS]") — El token BOS (reservado en el vocabulario, pero no se utiliza realmente). - eos_token (
str, opcional, por defecto es"[EOS]") — El token de fin de secuencia (reservado en el vocabulario, pero no se usa realmente). Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de secuencia. El token que se utiliza es sep_token.Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el final de la secuencia. El token que se utiliza es
sep_token. - mask_token (
str, opcional, valor predeterminado"[MASK]") — El token MASK, útil para el modelado de lenguaje enmascarado. - cls_token (
str, opcional, valor predeterminado"[CLS]") — El token CLS (reservado en el vocabulario, pero no se utiliza realmente). - sep_token (
str, opcional, valor predeterminado"[SEP]") — El token separador, que se utiliza al construir una secuencia a partir de dos secuencias.
Construya un tokenizador Perceiver. El Perceiver simplemente utiliza la codificación utf-8 de bytes crudos.
Este tokenizador hereda de PreTrainedTokenizer, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.
__call__
< source >( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding
Parámetros
- text (
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 las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), debe estableceris_split_into_words=True(para eliminar la ambigüedad con un lote de secuencias). - text_pair (
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 (cadena pre-tokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pre-tokenizadas), debe estableceris_split_into_words=True(para eliminar la ambigüedad con un lote de secuencias). - text_target (
str,list[str],list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pretokenizadas), debe estableceris_split_into_words=True(para eliminar la ambigüedad con un lote de secuencias). - text_pair_target (
str,list[str],list[list[str]], opcional) — La secuencia o lote de secuencias que se codificarán como textos objetivo. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadena pretokenizada). Si las secuencias se proporcionan como lista de cadenas de caracteres (pretokenizadas), debe estableceris_split_into_words=True(para eliminar la ambigüedad con un lote de secuencias). - tokenizer_kwargs (
dict[str, Any], opcional) — Kwargs adicionales para pasar al tokenizer. Se fusionarán con los parámetros explícitos y otros kwargs, dando prioridad a los parámetros explícitos. - add_special_tokens (
bool, opcional, valor predeterminadoTrue) — Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si deseas añadir tokensbosoeosautomáticamente. - padding (
bool,stro PaddingStrategy, opcional, el valor predeterminado esFalse) — Activa y controla el relleno. Acepta los siguientes valores:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool,stro TruncationStrategy, opcional, por defectoFalse) — Activa y controla la truncación. Acepta los siguientes valores:Trueo'longest_first': Trunca hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token a token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas).'only_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).'only_second': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
- max_length (
int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.Si se deja sin definir o se establece en
None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - stride (
int, opcional, valor predeterminado 0) — Si se establece en un número junto conmax_length, los tokens de desbordamiento devueltos cuandoreturn_overflowing_tokens=Truecontendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las de desbordamiento. El valor de este argumento define el número de tokens superpuestos. - is_split_into_words (
bool, opcional, valor predeterminadoFalse) — Indica si la entrada ya está pretokenizada (por ejemplo, dividida en palabras). Si se establece enTrue, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y las tokenizará. Esto es útil para NER o clasificación de tokens. - pad_to_multiple_of (
int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere quepaddingesté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo>= 7.5(Volta). - padding_side (
str, opcional) — El lado en el que el modelo debe aplicar el relleno. Debe seleccionarse entre [‘right’, ‘left’]. El valor predeterminado se elige a partir del atributo de clase con el mismo nombre. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetos Numpynp.ndarray.
- return_token_type_ids (
bool, opcional) — Si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por elreturn_outputsatributo. - return_attention_mask (
bool, opcional) — Si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por elreturn_outputsatributo. - return_overflowing_tokens (
bool, opcional, valor predeterminadoFalse) — Indica si se deben devolver las secuencias de tokens que exceden el límite. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) contruncation_strategy = longest_firstoTrue, se genera un error en lugar de devolver los tokens que exceden el límite. - return_special_tokens_mask (
bool, opcional, valor predeterminadoFalse) — Indica si se debe o no devolver información de la máscara de tokens especiales. - return_offsets_mapping (
bool, opcional, por defectoFalse) — Si se devuelve o no(char_start, char_end)para cada token.Esto solo está disponible en los tokenizadores rápidos que heredan de PreTrainedTokenizerFast; si se utiliza el tokenizador de Python, este método lanzará
NotImplementedError. - return_length (
bool, opcional, valor predeterminadoFalse) — Indica si se deben devolver las longitudes de las entradas codificadas. - verbose (
bool, opcional, valor predeterminadoTrue) — Si se imprime más información y advertencias. - **kwargs — se pasan al método
self.tokenize()
Devuelve
Un BatchEncoding con los siguientes campos:
-
input_ids — Lista de ids de tokens que se enviarán a un modelo.
-
token_type_ids — Lista de ids de tipo de token que se enviarán a un modelo (cuando
return_token_type_ids=Trueo si “token_type_ids” está enself.model_input_names). -
attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando
return_attention_mask=Trueo si “attention_mask” está enself.model_input_names). -
overflowing_tokens — Lista de secuencias de tokens que exceden el límite (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0 y 1, donde 1 especifica los tokens especiales añadidos y 0 especifica los tokens regulares de la secuencia (cuando
add_special_tokens=Trueyreturn_special_tokens_mask=True). -
length — La longitud de las entradas (cuando
return_length=True)
Método principal para tokenizar y preparar para el modelo una o varias secuencias o uno o varios pares de secuencias.
PerceiverImageProcessor
clase transformers.PerceiverImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parámetros
- do_convert_rgb (
bool, kwargs, opcional) — Si se debe convertir la imagen a RGB. - do_resize (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe redimensionar la imagen. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto{'height' -- 224, 'width': 224}): Describe las dimensiones de entrada máximas para el modelo. - default_to_square (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto{'height' -- 256, 'width': 256}): Tamaño de la imagen de salida tras aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto3) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeraciónPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - do_rescale (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe reescalar la imagen. - rescale_factor (
float, kwargs, opcional, valor predeterminado0.00392156862745098) — Factor de reescalado para reescalar la imagen sido_rescaleestá establecido enTrue. - do_normalize (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe normalizar la imagen. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado[0.485, 0.456, 0.406]) — Media de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado[0.229, 0.224, 0.225]) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - do_pad (
bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en{"height": int, "width" int}al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporcionapad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuandodo_pad=True. - do_center_crop (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe recortar la imagen centrada. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admiteChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales)."none"oChannelDimension.NONE: imagen en formato (altura, ancho).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en'pt'; en caso contrario, devuelve una lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
Construye un procesador de imágenes PerceiverImageProcessor.
preprocesar
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parámetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 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, establezcado_rescale=False. - image_like_kwargs (
dict[str, Any], opcional) — Bandera para desarrolladores destinada a entradas adicionales de tipo imagen que también se preprocesarán. Utilice esto solo si pasar las entradas como kwarg no funciona. Por ejemplo,preprocess(images, masks=masks)es la opción preferida, pero provoca problemas de prioridad de argumentos en algunos modelos. En esos casos se puede usarpreprocess(images, image_like_inputs={"masks": masks})en su lugar. - do_convert_rgb (
bool, kwargs, opcional) — Si se debe convertir la imagen a RGB. - do_resize (
bool, kwargs, opcional) — Si se debe redimensionar la imagen. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Describe las dimensiones de entrada máximas del modelo. - default_to_square (
bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enumPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - do_rescale (
bool, kwargs, opcional) — Si se debe reescalar la imagen. - rescale_factor (
float, kwargs, opcional) — Factor de reescalado para reescalar la imagen sido_rescaleestá establecido enTrue. - do_normalize (
bool, kwargs, opcional) — Si se debe normalizar la imagen. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - do_pad (
bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en{"height": int, "width" int}al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporcionapad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Si se debe recortar la imagen centrada. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admiteChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales)."none"oChannelDimension.NONE: imagen en formato (altura, ancho).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en'pt'; en caso contrario, devuelve una lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
Devuelve
~image_processing_base.BatchFeature
- data (
dict) — Diccionario de listas/arrays/tensores devueltos por el método call (‘pixel_values’, 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.
Preprocesa una imagen o un lote de imágenes.
PerceiverImageProcessorPil
clase transformers.PerceiverImageProcessorPil
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Parámetros
- do_convert_rgb (
bool, kwargs, opcional) — Si se debe convertir la imagen a RGB. - do_resize (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe redimensionar la imagen. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto{'height' -- 224, 'width': 224}): Describe las dimensiones de entrada máximas para el modelo. - default_to_square (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto{'height' -- 256, 'width': 256}): Tamaño de la imagen de salida tras aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto3) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeraciónPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - do_rescale (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe reescalar la imagen. - rescale_factor (
float, kwargs, opcional, valor predeterminado0.00392156862745098) — Factor de reescalado para reescalar la imagen sido_rescaleestá establecido enTrue. - do_normalize (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe normalizar la imagen. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado[0.485, 0.456, 0.406]) — Media de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado[0.229, 0.224, 0.225]) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - do_pad (
bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en{"height": int, "width" int}al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporcionapad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuandodo_pad=True. - do_center_crop (
bool, kwargs, opcional, valor predeterminadoTrue) — Si se debe recortar la imagen centrada. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admiteChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales)."none"oChannelDimension.NONE: imagen en formato (altura, ancho).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en'pt'; en caso contrario, devuelve una lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
Construye un procesador de imágenes PerceiverImageProcessor.
preprocesar
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
Parámetros
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 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, establezcado_rescale=False. - image_like_kwargs (
dict[str, Any], opcional) — Bandera para desarrolladores destinada a entradas adicionales de tipo imagen que también se preprocesarán. Utilice esto solo si pasar las entradas como kwarg no funciona. Por ejemplo,preprocess(images, masks=masks)es la opción preferida, pero provoca problemas de prioridad de argumentos en algunos modelos. En esos casos se puede usarpreprocess(images, image_like_inputs={"masks": masks})en su lugar. - do_convert_rgb (
bool, kwargs, opcional) — Si se debe convertir la imagen a RGB. - do_resize (
bool, kwargs, opcional) — Si se debe redimensionar la imagen. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Describe las dimensiones de entrada máximas del modelo. - default_to_square (
bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enumPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - do_rescale (
bool, kwargs, opcional) — Si se debe reescalar la imagen. - rescale_factor (
float, kwargs, opcional) — Factor de reescalado para reescalar la imagen sido_rescaleestá establecido enTrue. - do_normalize (
bool, kwargs, opcional) — Si se debe normalizar la imagen. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto sido_normalizeestá establecido enTrue. - do_pad (
bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — El tamaño en{"height": int, "width" int}al que se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporcionapad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Si se debe recortar la imagen centrada. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admiteChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales)."none"oChannelDimension.NONE: imagen en formato (altura, ancho).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en'pt'; en caso contrario, devuelve una lista de tensores. - disable_grouping (
bool, kwargs, opcional) — Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opcional) — El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
Devuelve
~image_processing_base.BatchFeature
- data (
dict) — Diccionario de listas/arrays/tensores devueltos por el método call (‘pixel_values’, 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.
Preprocesa una imagen o un lote de imágenes.
PerceiverTextPreprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — Configuración del modelo.
Preprocesamiento de texto para Perceiver Encoder. Se puede usar para incrustar inputs y añadir codificaciones posicionales.
La dimensionalidad de las incrustaciones está determinada por el atributo d_model de la configuración.
PerceiverImagePreprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor
< source >( configprep_type = 'conv'spatial_downsample: int = 4temporal_downsample: int = 1position_encoding_type: str = 'fourier'in_channels: int = 3out_channels: int = 64conv_after_patching: bool = Falseconv_after_patching_in_channels: int = 54conv2d_use_batchnorm: bool = Trueconcat_or_add_pos: str = 'concat'project_pos_dim: int = -1**position_encoding_kwargs )
Parámetros
- config ([PerceiverConfig]) — Configuración del modelo.
- prep_type (
str, opcional, por defecto"conv") — Tipo de preprocesamiento. Puede ser “conv1x1”, “conv”, “patches”, “pixels”. - spatial_downsample (
int, opcional, valor predeterminado 4) — Factor de reducción espacial. - temporal_downsample (
int, opcional, valor predeterminado 1) — Factor de muestreo temporal (solo relevante si hay una dimensión de tiempo). - position_encoding_type (
str, opcional, valor predeterminado"fourier") — Tipo de codificación de posición. Puede ser “fourier” o “trainable”. - in_channels (
int, opcional, valor predeterminado 3) — Número de canales en la entrada. - out_channels (
int, opcional, valor predeterminado 64) — Número de canales en la salida. - conv_after_patching (
bool, opcional, valor predeterminadoFalse) — Si se aplica una capa convolucional después del patching. - conv_after_patching_in_channels (
int, opcional, valor predeterminado 54) — Número de canales en la entrada de la capa convolucional después del patching. - conv2d_use_batchnorm (
bool, opcional, valor predeterminadoTrue) — Si se debe usar la normalización por lotes en la capa convolucional. - concat_or_add_pos (
str, opcional, valor predeterminado"concat") — Cómo concatenar la codificación de posición con la entrada. Puede ser “concat” o “add”. - project_pos_dim (
int, opcional, valor predeterminado -1) — Dimensión de la codificación de posición a la que proyectar. Si es -1, no se aplica ninguna proyección. - **position_encoding_kwargs (
Dict, opcional) — Argumentos de palabra clave para la codificación de posición.
Preprocesamiento de imágenes para Perceiver Encoder.
Nota: el argumento out_channels se refiere a los canales de salida de una capa convolucional, si prep_type está establecido en “conv1x1” o “conv”. Si se añaden embeddings de posición absoluta, es necesario asegurarse de que num_channels de los kwargs de codificación de posición se establezca igual que out_channels.
PerceiverOneHotPreprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — Configuración del modelo.
Preprocesador one-hot para Perceiver Encoder. Se puede usar para añadir una dimensión de índice ficticia a la entrada.
PerceiverAudioPreprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor
< source >( configprep_type: str = 'patches'samples_per_patch: int = 96position_encoding_type: str = 'fourier'concat_or_add_pos: str = 'concat'out_channels = 64project_pos_dim = -1**position_encoding_kwargs )
Parámetros
- config ([PerceiverConfig]) — Configuración del modelo.
- prep_type (
str, opcional, valor predeterminado"patches") — Tipo de preprocesador a utilizar. Solo se admite “patches”. - samples_per_patch (
int, opcional, valor predeterminado 96) — Número de muestras por parche. - position_encoding_type (
str, opcional, valor predeterminado"fourier") — Tipo de codificación de posición a utilizar. Puede ser “trainable” o “fourier”. - concat_or_add_pos (
str, opcional, valor predeterminado"concat") — Cómo concatenar la codificación de posición con la entrada. Puede ser “concat” o “add”. - out_channels (
int, opcional, valor predeterminado 64) — Número de canales en la salida. - project_pos_dim (
int, opcional, valor predeterminado -1) — Dimensión de la codificación de posición a la que proyectar. Si es -1, no se aplica ninguna proyección. - **position_encoding_kwargs (
Dict, opcional) — Argumentos de palabra clave para la codificación de posición.
Preprocesamiento de audio para Perceiver Encoder.
PerceiverMultimodalPreprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: Mappingmask_probs: collections.abc.Mapping[str, float] | None = Nonemin_padding_size: int = 2 )
Parámetros
- modalities (
Mapping[str, PreprocessorType]) — Diccionario que mapea el nombre de la modalidad al preprocesador. - mask_probs (
dict[str, float]) — Diccionario que mapea el nombre de la modalidad a la probabilidad de enmascarado de esa modalidad. - min_padding_size (
int, opcional, valor predeterminado 2) — El tamaño mínimo de relleno para todas las modalidades. La salida final tendrá num_channels igual al máximo de canales entre todas las modalidades más min_padding_size.
Preprocesamiento multimodal para Perceiver Encoder.
Las entradas de cada modalidad se preprocesan y luego se rellenan con embeddings de posición entrenables para que tengan el mismo número de canales.
PerceiverProjectionDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
Parámetros
- config (PerceiverConfig) — Configuración del modelo.
Decodificador de proyección de línea base (sin atención cruzada).
PerceiverBasicDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder
< source >( config: PerceiverConfigoutput_num_channels: intposition_encoding_type: str | None = 'trainable'output_index_dims: int | None = Nonenum_channels: int | None = 128subsampled_index_dims: int | None = Noneqk_channels: int | None = Nonev_channels: int | None = Nonenum_heads: int | None = 1widening_factor: int | None = 1use_query_residual: bool | None = Falseconcat_preprocessed_input: bool | None = Falsefinal_project: bool | None = Trueposition_encoding_only: bool | None = False**position_encoding_kwargs )
Parámetros
- config ([PerceiverConfig]) — Configuración del modelo.
- output_num_channels (
int, opcional) — El número de canales en la salida. Solo se usará si final_project está establecido enTrue. - position_encoding_type (
str, opcional, valor predeterminado “trainable”) — El tipo de codificación de posición a utilizar. Puede ser “trainable”, “fourier” o “none”. - output_index_dims (
int, opcional) — El número de dimensiones de las consultas de salida. Se ignora si ‘position_encoding_type’ == ‘none’. - num_channels (
int, opcional, valor predeterminado 128) — El número de canales de las consultas del decodificador. Se ignora si ‘position_encoding_type’ == ‘none’. - qk_channels (
int, opcional) — El número de canales de las consultas y claves en la capa de atención cruzada. - v_channels (
int, opcional) — El número de canales de los valores en la capa de atención cruzada. - num_heads (
int, opcional, valor predeterminado 1) — El número de cabezas de atención en la capa de atención cruzada. - widening_factor (
int, opcional, valor predeterminado 1) — El factor de ampliación de la capa de atención cruzada. - use_query_residual (
bool, opcional, valor predeterminadoFalse) — Si se debe usar una conexión residual entre la consulta y la salida de la capa de atención cruzada. - concat_preprocessed_input (
bool, opcional, valor predeterminadoFalse) — Si se debe concatenar la entrada preprocesada a la consulta. - final_project (
bool, opcional, valor predeterminadoTrue) — Si se debe proyectar la salida de la capa de atención cruzada a una dimensión objetivo. - position_encoding_only (
bool, opcional, valor predeterminadoFalse) — Si se debe usar esta clase únicamente para definir las consultas de salida.
Decodificador basado en atención cruzada. Esta clase se puede utilizar para decodificar los estados ocultos finales de los latentes mediante una operación de atención cruzada, en la que los latentes producen las claves y los valores.
La forma de la salida de esta clase depende de cómo se definen las consultas de salida (también llamadas consultas del decodificador).
PerceiverClassificationDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder
< source >( config**decoder_kwargs )
Parámetros
- config (PerceiverConfig) — Configuración del modelo.
Decodificador de clasificación basado en atención cruzada. Envoltorio ligero de PerceiverBasicDecoder para la salida de logits.
Convertirá la salida del codificador Perceiver, que tiene forma (batch_size, num_latents, d_latents), en un tensor de
forma (batch_size, num_labels). Las consultas tienen forma (batch_size, 1, num_labels).
PerceiverOpticalFlowDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder
< source >( configoutput_image_shapeoutput_num_channels = 2rescale_factor = 100.0**decoder_kwargs )
Decodificador de flujo óptico basado en atención cruzada.
PerceiverBasicVideoAutoencodingDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder
< source >( config: PerceiverConfigoutput_shape: listposition_encoding_type: str**decoder_kwargs )
Parámetros
- config ([PerceiverConfig]) — Configuración del modelo.
- output_shape (
list[int]) — Forma de la salida como (batch_size, num_frames, height, width), excluyendo la dimensión de canal. - position_encoding_type (
str) — El tipo de codificación de posición a utilizar. Puede ser “trainable”, “fourier” o “none”.
Decodificador de auto-codificación de video basado en atención cruzada. Envoltorio ligero de [PerceiverBasicDecoder] con lógica de reconfiguración de video.
PerceiverMultimodalDecoder
clase transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder
< source >( config: PerceiverConfigmodalities: dictnum_outputs: intoutput_num_channels: intmin_padding_size: int | None = 2subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None**decoder_kwargs )
Parámetros
- config ([PerceiverConfig]) — Configuración del modelo.
- modalities (
dict[str, PerceiverAbstractDecoder]) — Diccionario que mapea el nombre de la modalidad al decodificador de esa modalidad. - num_outputs (
int) — El número de salidas del decodificador. - output_num_channels (
int) — El número de canales en la salida. - min_padding_size (
int, opcional, valor predeterminado 2) — El tamaño mínimo de relleno para todas las modalidades. La salida final tendrá num_channels igual al máximo de canales entre todas las modalidades más min_padding_size. - subsampled_index_dims (
dict[str, PerceiverAbstractDecoder], opcional) — Diccionario que mapea el nombre de la modalidad a las dimensiones de índice subsampleadas a utilizar para la consulta del decodificador de esa modalidad.
Decodificación multimodal mediante la composición de decodificadores unimodales. El argumento modalities del constructor es un diccionario que mapea el nombre de la modalidad al decodificador de esa modalidad. Ese decodificador se utilizará para construir consultas para esa modalidad. Las consultas específicas de cada modalidad se rellenan con parámetros entrenables específicos de la modalidad, tras lo cual se concatenan a lo largo de la dimensión temporal.
A continuación, hay una operación de atención cruzada compartida entre todas las modalidades.
PerceiverProjectionPostprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor
< source >( in_channels: intout_channels: int )
Postprocesamiento de proyección para Perceiver. Se puede usar para proyectar los canales de la salida del decodificador a una dimensión inferior.
PerceiverAudioPostprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< source >( config: PerceiverConfigin_channels: intpostproc_type: str = 'patches' )
Postprocesamiento de audio para Perceiver. Se puede usar para convertir la salida del decodificador en características de audio.
PerceiverClassificationPostprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< source >( config: PerceiverConfigin_channels: int )
Postprocesamiento de clasificación para Perceiver. Se puede usar para convertir la salida del decodificador en logits de clasificación.
PerceiverMultimodalPostprocessor
clase transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< source >( modalities: Mappinginput_is_dict: bool = False )
Parámetros
- modalities (
Mapping[str, PostprocessorType]) — Diccionario que mapea el nombre de la modalidad a la clase de postprocesador para esa modalidad. - input_is_dict (
bool, opcional, valor predeterminadoFalse) — Si es True, se asume que la entrada tiene una estructura de diccionario y las salidas conservan la misma forma de diccionario. Si es False, la entrada es un tensor que se divide durante el postprocesamiento mediante modality_sizes.
Postprocesamiento multimodal para Perceiver. Se puede usar para combinar postprocesadores específicos de cada modalidad en un único postprocesador.
PerceiverModel
clase transformers.PerceiverModel
< source >( config: PerceiverConfigdecoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = Noneinput_preprocessor: Callable = Noneoutput_postprocessor: Callable = None )
Parámetros
- config (PerceiverConfig) — 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.
- decoder (
PerceiverDecoder, opcional) — Módulo decodificador que transforma las representaciones latentes en predicciones de la tarea. - input_preprocessor (
PreprocessorType, opcional) — Preprocesador que codifica las entradas crudas en tensores para el modelo. - output_postprocessor (
PostprocessorType, opcional) — Postprocesador que transforma las salidas del modelo en predicciones finales.
The Perceiver: una arquitectura escalable y totalmente atencional.
Tenga en cuenta que es posible ajustar Perceiver con imágenes de mayor resolución que las con las que se entrenó, estableciendo
interpolate_pos_encodingenTrueen el forward del modelo. Esto interpolará los embeddings de posición preentrenados a la mayor resolución.
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
< source >( inputs: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = None**kwargs ) → PerceiverModelOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- subsampled_output_points (
dict[str, torch.Tensor], opcional) — Diccionario de tensores utilizados como consultas para el decodificador. El decodificador mapea estas consultas a la representación latente del modelo. Se utiliza para el decodificado subsampleado, por ejemplo, cuando solo se decodifican ciertas porciones de la imagen. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - interpolate_pos_encoding (
bool, opcional, valor predeterminadoFalse) — Si se debe interpolar las codificaciones de posición preentrenadas. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
PerceiverModelOutput o tuple(torch.Tensor)
Un PerceiverModelOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverModel 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
Moduledespué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.
logits (
torch.Tensorde forma(batch_size, num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del modelo.hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel
>>> from transformers.models.perceiver.modeling_perceiver import (
... PerceiverTextPreprocessor,
... PerceiverImagePreprocessor,
... PerceiverClassificationDecoder,
... )
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> # EXAMPLE 1: using the Perceiver to classify texts
>>> # - we define a TextPreprocessor, which can be used to embed tokens
>>> # - we define a ClassificationDecoder, which can be used to decode the
>>> # final hidden states of the latents to classification logits
>>> # using trainable position embeddings
>>> config = PerceiverConfig()
>>> preprocessor = PerceiverTextPreprocessor(config)
>>> decoder = PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... )
>>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder)
>>> # you can then do a forward pass as follows:
>>> tokenizer = PerceiverTokenizer()
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)
>>> # EXAMPLE 2: using the Perceiver to classify images
>>> # - we define an ImagePreprocessor, which can be used to embed images
>>> config = PerceiverConfig(image_size=224)
>>> preprocessor = PerceiverImagePreprocessor(
... config,
... prep_type="conv1x1",
... spatial_downsample=1,
... out_channels=256,
... position_encoding_type="trainable",
... concat_or_add_pos="concat",
... project_pos_dim=256,
... trainable_position_encoding_kwargs=dict(
... num_channels=256,
... index_dims=config.image_size**2,
... ),
... )
>>> model = PerceiverModel(
... config,
... input_preprocessor=preprocessor,
... decoder=PerceiverClassificationDecoder(
... config,
... num_channels=config.d_latents,
... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1),
... use_query_residual=True,
... ),
... )
>>> # you can then do a forward pass as follows:
>>> image_processor = PerceiverImageProcessor()
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt").pixel_values
>>> with torch.no_grad():
... outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]
>>> # to train, one can train the model using standard cross-entropy:
>>> criterion = torch.nn.CrossEntropyLoss()
>>> labels = torch.tensor([1])
>>> loss = criterion(logits, labels)PerceiverForMaskedLM
clase transformers.PerceiverForMaskedLM
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para modelado de lenguaje enmascarado.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverMaskedLMOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple. - input_ids (
torch.Tensorde 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.
Devuelve
PerceiverMaskedLMOutput o tuple(torch.Tensor)
Un PerceiverMaskedLMOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForMaskedLM 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje enmascarado (MLM).logits (
torch.Tensorde 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).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import AutoTokenizer, PerceiverForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver")
>>> # training
>>> text = "This is an incomplete sentence where some words are missing."
>>> inputs = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask " missing."
>>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids
>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
19.87
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> # inference
>>> text = "This is an incomplete sentence where some words are missing."
>>> encoding = tokenizer(text, padding="max_length", return_tensors="pt")
>>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space.
>>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**encoding)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2048, 262]
>>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist()
>>> tokenizer.decode(masked_tokens_predictions)
' missing.'PerceiverForSequenceClassification
clase transformers.PerceiverForSequenceClassification
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para la clasificación de texto.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Noneinput_ids: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple. - input_ids (
torch.Tensorde 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.
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForSequenceClassification 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import AutoTokenizer, PerceiverForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver")
>>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver")
>>> text = "hello world"
>>> inputs = tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]PerceiverForImageClassificationLearned
clase transformers.PerceiverForImageClassificationLearned
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para la clasificación de imágenes, para tareas como ImageNet.
Este modelo utiliza embeddings de posición aprendidos. En otras palabras, a este modelo no se le proporciona ninguna información privilegiada sobre la estructura de las imágenes. Como se muestra en el artículo, este modelo puede alcanzar una precisión top-1 de 72.7 en ImageNet.
PerceiverForImageClassificationLearned utiliza PerceiverImagePreprocessor (con prep_type="conv1x1") para preprocesar las imágenes de entrada, y PerceiverClassificationDecoder para decodificar la representación latente de PerceiverModel en logits de clasificación.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falsereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de imágenes. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - interpolate_pos_encoding (
bool, opcional, valor predeterminadoFalse) — Si se debe interpolar las codificaciones de posición preentrenadas. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple. - pixel_values (
torch.Tensorde 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 PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para más detalles (processor_classutiliza PerceiverImageProcessor para procesar las imágenes).
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForImageClassificationLearned 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationLearned
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-learned")
>>> model = PerceiverForImageClassificationLearned.from_pretrained("deepmind/vision-perceiver-learned")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForImageClassificationFourier
clase transformers.PerceiverForImageClassificationFourier
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para la clasificación de imágenes, para tareas como ImageNet.
Este modelo utiliza embeddings de posición 2D fijos de Fourier. Como se muestra en el artículo, este modelo puede alcanzar una precisión top-1 de 79.0 en ImageNet, y 84.5 cuando se pre-entrena en un conjunto de datos a gran escala (es decir, JFT).
PerceiverForImageClassificationLearned utiliza PerceiverImagePreprocessor (con prep_type="pixels") para preprocesar las imágenes de entrada, y PerceiverClassificationDecoder para decodificar la representación latente de PerceiverModel en logits de clasificación.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de imágenes. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple. - pixel_values (
torch.Tensorde 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 PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para más detalles (processor_classutiliza PerceiverImageProcessor para procesar las imágenes).
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForImageClassificationFourier 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationFourier
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-fourier")
>>> model = PerceiverForImageClassificationFourier.from_pretrained("deepmind/vision-perceiver-fourier")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForImageClassificationConvProcessing
clase transformers.PerceiverForImageClassificationConvProcessing
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para la clasificación de imágenes, para tareas como ImageNet.
Este modelo utiliza una red de preprocesamiento de conv+maxpool 2D. Como se muestra en el artículo, este modelo puede lograr una precisión top-1 de 82.1 en ImageNet.
PerceiverForImageClassificationLearned utiliza PerceiverImagePreprocessor (con prep_type="conv") para preprocesar las imágenes de entrada, y PerceiverClassificationDecoder para decodificar la representación latente de PerceiverModel en logits de clasificación.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = Nonepixel_values: typing.Optional[torch.Tensor] = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de imágenes. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple. - pixel_values (
torch.Tensorde 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 PerceiverImageProcessor. Consulte PerceiverImageProcessor.call() para más detalles (processor_classutiliza PerceiverImageProcessor para procesar las imágenes).
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForImageClassificationConvProcessing 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import AutoImageProcessor, PerceiverForImageClassificationConvProcessing
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-conv")
>>> model = PerceiverForImageClassificationConvProcessing.from_pretrained("deepmind/vision-perceiver-conv")
>>> inputs = image_processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(inputs=inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 1000]
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: tabby, tabby catPerceiverForOpticalFlow
clase transformers.PerceiverForOpticalFlow
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Uso de Perceiver para flujo óptico, en tareas como Sintel y KITTI. PerceiverForOpticalFlow utiliza PerceiverImagePreprocessor (con prep_type=“patches”) para preprocesar las imágenes de entrada, y PerceiverOpticalFlowDecoder para decodificar la representación latente de PerceiverModel.
Como entrada, se concatenan 2 fotogramas consecutivos a lo largo de la dimensión de canal y se extrae un parche de 3 x 3 alrededor de cada píxel (lo que da lugar a 3 x 3 x 3 x 2 = 54 valores para cada píxel). Se utilizan codificaciones de posición de Fourier fijas para codificar la posición de cada píxel en el parche. A continuación, se aplica el codificador Perceiver. Para decodificar, se consulta la representación latente utilizando la misma codificación empleada para la entrada.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de flujo óptico. Los índices deben estar en[0, ..., config.num_labels - 1]. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForOpticalFlow 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import PerceiverForOpticalFlow
>>> import torch
>>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver")
>>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel,
>>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels)
>>> # patches have shape (batch_size, num_frames, num_channels, height, width)
>>> # the authors train on resolutions of 368 x 496
>>> patches = torch.randn(1, 2, 27, 368, 496)
>>> outputs = model(inputs=patches)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 368, 496, 2]PerceiverForMultimodalAutoencoding
clase transformers.PerceiverForMultimodalAutoencoding
< source >( config: PerceiverConfig )
Parámetros
- config (PerceiverConfig) — 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.
Ejemplo de uso de Perceiver para autoencoding multimodal (vídeo), para tareas como Kinetics-700.
PerceiverForMultimodalAutoencoding utiliza PerceiverMultimodalPreprocessor para preprocesar las 3 modalidades: imágenes, audio y etiquetas de clase. Este preprocesador utiliza preprocesadores específicos de cada modalidad para preprocesar cada una por separado, después de lo cual se concatenan. Se utilizan embeddings de posición entrenables para rellenar cada modalidad hasta el mismo número de canales, lo que permite la concatenación a lo largo de la dimensión temporal. A continuación, se aplica el codificador Perceiver.
PerceiverMultimodalDecoder se utiliza para decodificar la representación latente de PerceiverModel. Este decodificador utiliza cada decodificador específico de modalidad para construir consultas. Las consultas del decodificador se crean en función de las entradas después del preprocesamiento. Sin embargo, auto-codificar un video completo en una sola pasada hacia adelante es computacionalmente inviable, por lo que solo se utilizan partes de las consultas del decodificador para realizar atención cruzada con la representación latente. Esto se determina mediante los índices subsampleados para cada modalidad, que pueden proporcionarse como entrada adicional a la pasada hacia adelante de PerceiverForMultimodalAutoencoding.
PerceiverMultimodalDecoder también rellena las consultas del decodificador de las distintas modalidades hasta el mismo número de canales, con el fin de concatenarlas a lo largo de la dimensión temporal. A continuación, se realiza la atención cruzada con la representación latente de PerceiverModel.
Por último, ~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor se utiliza para convertir este tensor en un
video real. Primero, divide la salida en las diferentes modalidades y, a continuación, aplica el postprocesador
correspondiente para cada modalidad.
Tenga en cuenta que, al enmascarar la etiqueta de clasificación durante la evaluación (es decir, simplemente proporcionando un tensor de ceros para la modalidad “label”), este modelo de auto-codificación se convierte en un clasificador de videos de Kinetics 700.
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
< source >( inputs: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonesubsampled_output_points: dict[str, torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → PerceiverClassifierOutput or tuple(torch.Tensor)
Parámetros
- inputs (
torch.Tensor, opcional) — Entradas para el perceiver. Puede ser cualquier cosa: imágenes, texto, audio, vídeo, etc. - attention_mask (
torch.Tensorde 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.
- subsampled_output_points (
dict[str, torch.Tensor], opcional) — Diccionario de tensores utilizados como consultas para el decodificador. El decodificador mapea estas consultas a la representación latente del modelo. Se utiliza para el decodificado subsampleado, por ejemplo, cuando solo se decodifican ciertas porciones de la imagen. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de imágenes. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
PerceiverClassifierOutput o tuple(torch.Tensor)
Un PerceiverClassifierOutput 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 (PerceiverConfig) y las entradas.
El método forward de PerceiverForMultimodalAutoencoding 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
cross_attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
Ejemplos:
>>> from transformers import PerceiverForMultimodalAutoencoding
>>> import torch
>>> import numpy as np
>>> # create multimodal inputs
>>> images = torch.randn((1, 16, 3, 224, 224))
>>> audio = torch.randn((1, 30720, 1))
>>> inputs = dict(image=images, audio=audio, label=torch.zeros((images.shape[0], 700)))
>>> model = PerceiverForMultimodalAutoencoding.from_pretrained("deepmind/multimodal-perceiver")
>>> # in the Perceiver IO paper, videos are auto-encoded in chunks
>>> # each chunk subsamples different index dimensions of the image and audio modality decoder queries
>>> nchunks = 128
>>> image_chunk_size = np.prod((16, 224, 224)) // nchunks
>>> audio_chunk_size = audio.shape[1] // model.config.samples_per_patch // nchunks
>>> # process the first chunk
>>> chunk_idx = 0
>>> subsampling = {
... "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
... "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
... "label": None,
... }
>>> outputs = model(inputs=inputs, subsampled_output_points=subsampling)
>>> logits = outputs.logits
>>> list(logits["audio"].shape)
[1, 240]
>>> list(logits["image"].shape)
[1, 6272, 3]
>>> list(logits["label"].shape)
[1, 700]