Transformers documentation
Perceiver
Ce modèle a été publié dans HF papers le 2021-07-30 et ajouté à Hugging Face Transformers le 2021-12-08.
Perceiver
Aperçu
Le modèle Perceiver IO a été proposé dans Perceiver IO: A General Architecture for Structured Inputs & Outputs par 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 est une généralisation de Perceiver permettant de traiter des sorties arbitraires en plus des entrées arbitraires. Le Perceiver d'origine ne produisait qu'un seul libellé de classification. En plus des libellés de classification, Perceiver IO peut produire (par exemple) du langage, du flux optique et des vidéos multimodales avec audio. Cela est réalisé à l'aide des mêmes briques de base que le Perceiver d'origine. La complexité computationnelle de Perceiver IO est linéaire par rapport à la taille des entrées et des sorties, et la majeure partie du traitement a lieu dans l'espace latent, ce qui nous permet de traiter des entrées et des sorties beaucoup plus grandes que ce que les Transformers standards peuvent gérer. Cela signifie, par exemple, que Perceiver IO peut effectuer un modélisation de langage masquée de type BERT directement à l'aide d'octets au lieu d'entrées tokenisées.
L'abstract de l'article est le suivant :
Le modèle Perceiver, récemment proposé, obtient de bons résultats dans plusieurs domaines (images, audio, multimodal, nuages de points) tout en passant à l’échelle linéairement en calcul et en mémoire avec la taille de l’entrée. Bien que le Perceiver prenne en charge de nombreux types d’entrées, il ne peut produire que des sorties très simples, telles que des scores de classes. Perceiver IO surmonte cette limitation sans sacrifier les propriétés attrayantes de l’original, en apprenant à interroger de manière flexible l’espace latent du modèle pour produire des sorties de taille et de sémantique arbitraires. Perceiver IO découple toujours la profondeur du modèle de la taille des données et passe toujours à l’échelle linéairement avec la taille des données, mais désormais par rapport aux tailles d’entrée et de sortie. Le modèle Perceiver IO complet obtient de solides résultats sur des tâches avec des espaces de sortie fortement structurés, tels que la langue naturelle et la compréhension visuelle, StarCraft II, ainsi que les domaines multi-tâches et multimodaux. En points forts, Perceiver IO égale un baseline BERT basé sur des Transformers sur le benchmark linguistique GLUE sans avoir besoin de tokenisation des entrées et atteint des performances de l’état de l’art sur l’estimation du flux optique Sintel.
Voici un résumé expliquant le fonctionnement de Perceiver :
Le principal problème du mécanisme d'auto-attention du Transformer est que les exigences en temps et en mémoire évoluent de manière quadratique avec la longueur de la séquence. Par conséquent, des modèles comme BERT et RoBERTa sont limités à une longueur de séquence maximale de 512 jetons. Perceiver vise à résoudre ce problème en effectuant l'auto-attention non pas sur les entrées, mais sur un ensemble de variables latentes, et en n'utilisant les entrées que pour l'attention croisée. De cette manière, les exigences en temps et en mémoire ne dépendent plus de la longueur des entrées, car on utilise une quantité fixe de variables latentes, comme 256 ou 512. Celles-ci sont initialisées aléatoirement, puis entraînées de bout en bout par rétropropagation.
En interne, PerceiverModel crée les latents, qui sont un tenseur de forme (batch_size, num_latents, d_latents). Il faut fournir au modèle des inputs (qui peuvent être du texte, des images, de l'audio, etc.), qu'il utilisera pour effectuer une attention croisée avec les latents. La sortie de l'encodeur Perceiver est un tenseur de la même forme. On peut ensuite, de manière similaire à BERT, convertir les derniers états cachés des latents en logits de classification en moyennant le long de la dimension de la séquence, puis en plaçant une couche linéaire au-dessus pour projeter les d_latents vers num_labels.
C’était l’idée du papier original Perceiver. Cependant, il ne pouvait produire que des logits de classification. Dans un travail ultérieur, PerceiverIO, ils l’ont généralisé pour permettre au modèle de produire également des sorties de taille arbitraire. Comment, demanderez-vous ? L’idée est en réalité relativement simple : on définit des sorties de taille arbitraire, puis on applique une attention croisée avec les derniers états cachés des latents, en utilisant les sorties comme requêtes et les latents comme clés et valeurs.
Supposons donc que l’on souhaite effectuer du masked language modeling (de type BERT) avec le Perceiver. Comme la longueur d’entrée du Perceiver n’aura pas d’impact sur le temps de calcul des couches d’auto-attention, on peut fournir des octets bruts, en donnant au modèle des inputs de longueur 2048. Si l’on masque maintenant certains de ces 2048 jetons, on peut définir les outputs comme ayant la forme : (batch_size, 2048, 768). Ensuite, on effectue une cross-attention avec les états cachés finaux des latents pour mettre à jour le tenseur outputs. Après la cross-attention, on a toujours un tenseur de forme (batch_size, 2048, 768). On peut alors placer une tête de language modeling classique au-dessus, afin de projeter la dernière dimension sur la taille du vocabulaire du modèle, c’est-à-dire créer des logits de forme (batch_size, 2048, 262) (le Perceiver utilisant une taille de vocabulaire de 262 identifiants d’octets).
Perceiver IO architecture. Taken from the original paper Ce modèle a été contribué par nielsr. Le code d'origine peut être trouvé ici.
Perceiver ne fonctionne pas avec
torch.nn.DataParallelen raison d'un bug dans PyTorch, voir issue #36035
Ressources
- La façon la plus rapide de commencer avec le Perceiver est de consulter les carnets de tutoriel.
- Consultez le article de blog si vous souhaitez comprendre en détail le fonctionnement du modèle et sa mise en œuvre dans la bibliothèque. Notez que les modèles disponibles dans la bibliothèque ne présentent que quelques exemples de ce que vous pouvez faire avec le Perceiver. Il existe de nombreux autres cas d’usage, notamment la réponse à des questions, la reconnaissance d’entités nommées, la détection d’objets, la classification audio, la classification vidéo, etc.
- Guide de la tâche de classification de texte
- Guide de la tâche de modélisation de langage masqué
- Guide de la tâche de classification d'images
Sorties spécifiques à Perceiver
classe 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 )
Paramètres
- logits (
torch.Tensorde forme(batch_size, num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du modèle. - hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Classe de base pour les sorties du modèle de base Perceiver, avec états cachés, attentions et attentions croisées potentiels.
classe transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput
< source >( logits: typing.Optional[torch.Tensor] = Nonecross_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- logits (
torch.Tensorde forme(batch_size, num_labels)) — Sortie du décodeur de base. - cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Classe de base pour les sorties du décodeur Perceiver, avec des cross-attentions potentielles.
classe 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 )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation de langage masquée (MLM). - logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Classe de base pour les sorties du modèle de langage masqué de Perceiver.
classe 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 )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1). - logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Classe de base pour les sorties des modèles de classification de séquences/images, de flux optique et d'auto-encodage multimodal de Perceiver.
PerceiverConfig
classe 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 )
Paramètres
- num_latents (
int, facultatif, par défaut 256) — Le nombre de latents. - d_latents (
int, facultatif, par défaut 1280) — Dimension des embeddings latents. - d_model (
int, facultatif, par défaut768) — Taille des couches encodeur et de la couche pooler. - num_blocks (
int, facultatif, valeur par défaut 1) — Nombre de blocs dans l'encodeur Transformer. - num_self_attends_per_block (
int, facultatif, valeur par défaut 26) — Le nombre de couches d'auto-attention par bloc. - num_self_attention_heads (
int, facultatif, valeur par défaut : 8) — Nombre de têtes d'attention pour chaque couche d'auto-attention dans l'encodeur Transformer. - num_cross_attention_heads (
int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention croisée dans l'encodeur Transformer. - qk_channels (
int, facultatif) — Dimension de projection des requêtes + clés avant l'application de l'attention dans les couches d'attention croisée et d'auto-attention de l'encodeur. Par défaut, la dimension des requêtes est conservée si aucune valeur n'est spécifiée. - v_channels (
int, facultatif) — Dimension à laquelle projeter les valeurs avant d'appliquer l'attention dans les couches d'attention croisée et d'auto-attention de l'encodeur. Par défaut, la dimension des requêtes est conservée si aucune valeur n'est spécifiée. - cross_attention_shape_for_attention (
str, facultatif, par défaut"kv") — Dimension à utiliser lors du sous-échantillonnage des requêtes et des clés dans la couche d'attention croisée de l'encodeur. - self_attention_widening_factor (
int, facultatif, valeur par défaut 1) — Dimension de la couche feed-forward dans la couche d'attention croisée de l'encodeur Transformer. - cross_attention_widening_factor (
int, facultatif, valeur par défaut 1) — Dimension de la couche feed-forward dans les couches d'auto-attention de l'encodeur Transformer. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - attention_probs_dropout_prob (
Union[float, int], facultatif, par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - layer_norm_eps (
float, facultatif, valeur par défaut1e-12) — L'épsilon utilisé par les couches de normalisation de couche. - use_query_residual (
float, facultatif, valeur par défautTrue) — Indique s'il faut ajouter un résidu de requête dans la couche d'attention croisée de l'encodeur. - vocab_size (
int, facultatif, par défaut262) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - max_position_embeddings (
int, facultatif, par défaut2048) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - image_size (
int, facultatif, par défaut 56) — Taille des images après prétraitement, pour PerceiverForImageClassificationLearned. - train_size (
list[int], facultatif, par défaut[368, 496]) — Taille d'entraînement des images pour le modèle de flux optique. - num_frames (
int, facultatif, valeur par défaut 16) — Nombre de frames vidéo utilisées pour le modèle d'auto-encodage multimodal. - audio_samples_per_frame (
int, facultatif, valeur par défaut 1920) — Nombre d'échantillons audio par frame pour le modèle d'auto-encodage multimodal. - samples_per_patch (
int, facultatif, valeur par défaut 16) — Nombre d'échantillons audio par patch lors de la prétraitement de l'audio pour le modèle d'auto-encodage multimodal. - output_shape (
list[int], facultatif, par défaut[1, 16, 224, 224]) — Forme de la sortie (batch_size, num_frames, height, width) pour les requêtes du décodeur vidéo du modèle d'auto-encodage multimodal. Cela exclut la dimension des canaux. - output_num_channels (
int, facultatif, valeur par défaut 512) — Nombre de canaux de sortie pour chaque décodeur de modalité.
Ceci est la classe de configuration destinée à stocker la configuration d'un PerceiverModel. Elle est utilisée pour instancier un modèle Perceiver en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de deepmind/language-perceiver
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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
classe 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 )
Paramètres
- pad_token (
str, facultatif, par défaut"[PAD]") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes. - bos_token (
str, facultatif, par défaut"[BOS]") — Le jeton BOS (réservé dans le vocabulaire, mais non réellement utilisé). - eos_token (
str, facultatif, défaut :"[EOS]") — Le jeton de fin de séquence (réservé dans le vocabulaire, mais non réellement utilisé). Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour la fin de séquence. Le jeton utilisé est sep_token.Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour la fin de séquence. Le jeton utilisé est le
sep_token. - mask_token (
str, facultatif, par défaut"[MASK]") — Le jeton MASK, utile pour le modélisation de langage masquée. - cls_token (
str, facultatif, par défaut"[CLS]") — Le jeton CLS (réservé dans le vocabulaire, mais non réellement utilisé). - sep_token (
str, facultatif, par défaut"[SEP]") — Le jeton séparateur, utilisé lors de la construction d'une séquence à partir de deux séquences.
Construisez un tokenizer Perceiver. Le Perceiver utilise simplement l'encodage utf-8 des octets bruts.
Ce tokenizer hérite de PreTrainedTokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.
__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
Paramètres
- text (
str,list[str],list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définiris_split_into_words=True(pour lever l’ambiguïté avec un lot de séquences). - text_pair (
str,list[str],list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définiris_split_into_words=True(pour lever l’ambiguïté avec un lot de séquences). - text_target (
str,list[str],list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définiris_split_into_words=True(pour lever l’ambiguïté avec un lot de séquences). - text_pair_target (
str,list[str],list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définiris_split_into_words=True(pour lever l’ambiguïté avec un lot de séquences). - tokenizer_kwargs (
dict[str, Any], facultatif) — Kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité. - add_special_tokens (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Cela tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.'only_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.'only_second': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - stride (
int, facultatif, valeur par défaut 0) — Si défini à un nombre avecmax_length, les jetons en dépassement renvoyés lorsquereturn_overflowing_tokens=Truecontiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. - is_split_into_words (
bool, facultatif, par défautFalse) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini àTrue, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et la tokenise. Cela est utile pour la NER ou la classification de tokens. - pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation depadding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul>= 7.5(Volta). - padding_side (
str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets Numpynp.ndarray.
- return_token_type_ids (
bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton sont renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attributreturn_outputs. - return_attention_mask (
bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs. - return_overflowing_tokens (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avectruncation_strategy = longest_firstouTrue, une erreur est levée au lieu de retourner les jetons en dépassement. - return_special_tokens_mask (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. - return_offsets_mapping (
bool, facultatif, par défautFalse) — Indique s'il faut renvoyer(char_start, char_end)pour chaque jeton.Cela n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève
NotImplementedError. - return_length (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les longueurs des entrées encodées. - verbose (
bool, facultatif, par défautTrue) — Indique s'il faut afficher plus d'informations et d'avertissements. - **kwargs — transmis à la méthode
self.tokenize()
Retourne
Un BatchEncoding avec les champs suivants :
-
input_ids — Liste des identifiants de jetons à fournir à un modèle.
-
token_type_ids — Liste des identifiants de type de jeton à fournir à un modèle (lorsque
return_token_type_ids=Trueou si “token_type_ids” est présent dansself.model_input_names). -
attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque
return_attention_mask=Trueou si “attention_mask” est présent dansself.model_input_names). -
overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque
add_special_tokens=Trueetreturn_special_tokens_mask=True). -
length — La longueur des entrées (lorsque
return_length=True)
Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences.
PerceiverImageProcessor
classe transformers.PerceiverImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'height' -- 224, 'width': 224}) : Définit les dimensions maximales de l'entrée du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'height' -- 256, 'width': 256}) : Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
Construit un processeur d’images PerceiverImageProcessor.
prétraiter
< 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
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - image_like_kwargs (
dict[str, Any], facultatif) — Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant que mot-clé ne fonctionne pas. Par exemple,preprocess(images, masks=masks)est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas,preprocess(images, image_like_inputs={"masks": masks})peut être utilisé à la place. - do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
Retourne
~image_processing_base.BatchFeature
- data (
dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.). - tensor_type (
Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
Prétraitez une image ou un lot d'images.
PerceiverImageProcessorPil
classe transformers.PerceiverImageProcessorPil
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'height' -- 224, 'width': 224}) : Définit les dimensions maximales de l'entrée du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'height' -- 256, 'width': 256}) : Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
Construit un processeur d’images PerceiverImageProcessor.
prétraiter
< 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
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - image_like_kwargs (
dict[str, Any], facultatif) — Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant que mot-clé ne fonctionne pas. Par exemple,preprocess(images, masks=masks)est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas,preprocess(images, image_like_inputs={"masks": masks})peut être utilisé à la place. - do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format{"height": int, "width" int}à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_pad=True. - do_center_crop (
bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - disable_grouping (
bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
Retourne
~image_processing_base.BatchFeature
- data (
dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.). - tensor_type (
Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
Prétraitez une image ou un lot d'images.
PerceiverTextPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Configuration du modèle.
Prétraitement du texte pour Perceiver Encoder. Peut être utilisé pour intégrer les inputs et ajouter des encodages positionnels.
La dimension des embeddings est déterminée par l'attribut d_model de la configuration.
PerceiverImagePreprocessor
classe 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 )
Paramètres
- config ([PerceiverConfig]) — Configuration du modèle.
- prep_type (
str, facultatif, par défaut"conv") — Type de prétraitement. Peut être “conv1x1”, “conv”, “patches”, “pixels”. - spatial_downsample (
int, facultatif, valeur par défaut 4) — Facteur de sous-échantillonnage spatial. - temporal_downsample (
int, facultatif, valeur par défaut 1) — Facteur de sous-échantillonnage temporel (pertinent uniquement si une dimension temporelle est présente). - position_encoding_type (
str, facultatif, par défaut"fourier") — Type d’encodage de position. Peut être « fourier » ou « trainable ». - in_channels (
int, facultatif, par défaut 3) — Nombre de canaux dans l'entrée. - out_channels (
int, facultatif, valeur par défaut 64) — Nombre de canaux dans la sortie. - conv_after_patching (
bool, facultatif, par défautFalse) — Indique s'il faut appliquer une couche de convolution après le patching. - conv_after_patching_in_channels (
int, facultatif, valeur par défaut 54) — Nombre de canaux dans l'entrée de la couche convolutive après le patching. - conv2d_use_batchnorm (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser la normalisation par lot dans la couche de convolution. - concat_or_add_pos (
str, facultatif, par défaut"concat") — Méthode de concaténation de l’encodage de position à l’entrée. Peut être « concat » ou « add ». - project_pos_dim (
int, facultatif, valeur par défaut -1) — Dimension de l'encodage de position vers laquelle projeter. Si -1, aucune projection n'est appliquée. - **position_encoding_kwargs (
Dict, facultatif) — Arguments par mot-clé pour l'encodage de position.
Prétraitement des images pour Perceiver Encoder.
Note : l'argument out_channels fait référence aux canaux de sortie d'une couche de convolution, si prep_type est défini sur “conv1x1” ou “conv”. Si l'on ajoute des embeddings de position absolue, il faut s'assurer que num_channels des kwargs d'encodage de position est égal à out_channels.
PerceiverOneHotPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Configuration du modèle.
Préprocesseur one-hot pour Perceiver Encoder. Peut être utilisé pour ajouter une dimension d'index factice à l'entrée.
PerceiverAudioPreprocessor
classe 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 )
Paramètres
- config ([PerceiverConfig]) — Configuration du modèle.
- prep_type (
str, facultatif, par défaut"patches") — Type de préprocesseur à utiliser. Seul « patches » est pris en charge. - samples_per_patch (
int, facultatif, valeur par défaut 96) — Nombre d'échantillons par patch. - position_encoding_type (
str, facultatif, par défaut"fourier") — Type d’encodage de position à utiliser. Peut être « trainable » ou « fourier ». - concat_or_add_pos (
str, facultatif, par défaut"concat") — Méthode de concaténation de l’encodage de position à l’entrée. Peut être « concat » ou « add ». - out_channels (
int, facultatif, valeur par défaut 64) — Nombre de canaux dans la sortie. - project_pos_dim (
int, facultatif, valeur par défaut -1) — Dimension de l'encodage de position vers laquelle projeter. Si -1, aucune projection n'est appliquée. - **position_encoding_kwargs (
Dict, facultatif) — Arguments par mot-clé pour l'encodage de position.
Prétraitement audio pour Perceiver Encoder.
PerceiverMultimodalPreprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor
< source >( modalities: Mappingmask_probs: collections.abc.Mapping[str, float] | None = Nonemin_padding_size: int = 2 )
Paramètres
- modalities (
Mapping[str, PreprocessorType]) — Dictionnaire associant le nom de la modalité au préprocesseur. - mask_probs (
dict[str, float]) — Dictionnaire associant le nom de la modalité à la probabilité de masquage de cette modalité. - min_padding_size (
int, facultatif, valeur par défaut 2) — La taille minimale de bourrage pour toutes les modalités. La sortie finale aura un nombre de canaux (num_channels) égal au nombre maximal de canaux parmi toutes les modalités, plus min_padding_size.
Prétraitement multimodal pour Perceiver Encoder.
Les entrées de chaque modalité sont prétraitées, puis remplies avec des embeddings de position entraînables afin d’avoir le même nombre de canaux.
PerceiverProjectionDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder
< source >( config )
Paramètres
- config (PerceiverConfig) — Configuration du modèle.
Décodeur de projection de référence (sans attention croisée).
PerceiverBasicDecoder
classe 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 )
Paramètres
- config ([PerceiverConfig]) — Configuration du modèle.
- output_num_channels (
int, facultatif) — Le nombre de canaux dans la sortie. N'est utilisé que si final_project est défini surTrue. - position_encoding_type (
str, facultatif, par défaut “trainable”) — Le type d’encodage de position à utiliser. Peut être “trainable”, “fourier” ou “none”. - output_index_dims (
int, facultatif) — Le nombre de dimensions des requêtes de sortie. Ignoré si ‘position_encoding_type’ == ‘none’. - num_channels (
int, facultatif, valeur par défaut 128) — Le nombre de canaux des requêtes du décodeur. Ignoré si ‘position_encoding_type’ == ‘none’. - qk_channels (
int, facultatif) — Le nombre de canaux des requêtes et des clés dans la couche d'attention croisée. - v_channels (
int, facultatif) — Le nombre de canaux des valeurs dans la couche d'attention croisée. - num_heads (
int, facultatif, par défaut 1) — Le nombre de têtes d'attention dans la couche d'attention croisée. - widening_factor (
int, facultatif, valeur par défaut 1) — Le facteur d'élargissement de la couche d'attention croisée. - use_query_residual (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser une connexion résiduelle entre la requête et la sortie de la couche d'attention croisée. - concat_preprocessed_input (
bool, facultatif, valeur par défautFalse) — Indique s'il faut concaténer l'entrée prétraitée à la requête. - final_project (
bool, facultatif, par défautTrue) — Indique s'il faut projeter la sortie de la couche d'attention croisée vers une dimension cible. - position_encoding_only (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser cette classe uniquement pour définir les requêtes de sortie.
Décodeur basé sur l'attention croisée. Cette classe peut être utilisée pour décoder les états cachés finaux des latents à l'aide d'une opération d'attention croisée, dans laquelle les latents produisent les clés et les valeurs.
La forme de la sortie de cette classe dépend de la manière dont on définit les requêtes de sortie (également appelées requêtes du décodeur).
PerceiverClassificationDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder
< source >( config**decoder_kwargs )
Paramètres
- config (PerceiverConfig) — Configuration du modèle.
Décodeur de classification basé sur l'attention croisée. Enveloppe légère de PerceiverBasicDecoder pour la sortie de logits.
Convertit la sortie de l'encodeur Perceiver, de forme (batch_size, num_latents, d_latents), en un tenseur de
forme (batch_size, num_labels). Les requêtes sont de forme (batch_size, 1, num_labels).
PerceiverOpticalFlowDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder
< source >( configoutput_image_shapeoutput_num_channels = 2rescale_factor = 100.0**decoder_kwargs )
Décodeur de flux optique basé sur l'attention croisée.
PerceiverBasicVideoAutoencodingDecoder
classe transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder
< source >( config: PerceiverConfigoutput_shape: listposition_encoding_type: str**decoder_kwargs )
Paramètres
- config ([PerceiverConfig]) — Configuration du modèle.
- output_shape (
list[int]) — Forme de la sortie sous la forme (batch_size, num_frames, height, width), en excluant la dimension des canaux. - position_encoding_type (
str) — Le type d’encodage de position à utiliser. Peut être « trainable », « fourier » ou « none ».
Décodeur de vidéo par auto-encodage basé sur l'attention croisée. Enveloppe légère de [PerceiverBasicDecoder] avec logique de remodelage de la vidéo.
PerceiverMultimodalDecoder
classe 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 )
Paramètres
- config ([PerceiverConfig]) — Configuration du modèle.
- modalities (
dict[str, PerceiverAbstractDecoder]) — Dictionnaire associant le nom de la modalité au décodeur de cette modalité. - num_outputs (
int) — Le nombre de sorties du décodeur. - output_num_channels (
int) — Le nombre de canaux dans la sortie. - min_padding_size (
int, facultatif, valeur par défaut 2) — La taille minimale de bourrage pour toutes les modalités. La sortie finale aura un nombre de canaux (num_channels) égal au nombre maximal de canaux parmi toutes les modalités, plus min_padding_size. - subsampled_index_dims (
dict[str, PerceiverAbstractDecoder], facultatif) — Dictionnaire associant le nom de la modalité aux dimensions d’index sous-échantillonnées à utiliser pour la requête du décodeur de cette modalité.
Décodage multimodal par composition de décodeurs unimodaux. L'argument modalities du constructeur est un dictionnaire qui associe le nom d'une modalité au décodeur de cette modalité. Ce décodeur est utilisé pour construire les requêtes de la modalité concernée. Les requêtes spécifiques à chaque modalité sont remplies avec des paramètres spécifiques à la modalité et entraînables, puis concaténées le long de la dimension temporelle.
Ensuite, il y a une opération d'attention croisée partagée entre toutes les modalités.
PerceiverProjectionPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor
< source >( in_channels: intout_channels: int )
Post-traitement de la projection pour Perceiver. Peut être utilisé pour projeter les canaux de la sortie du décodeur vers une dimension inférieure.
PerceiverAudioPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor
< source >( config: PerceiverConfigin_channels: intpostproc_type: str = 'patches' )
Post-traitement audio pour Perceiver. Peut être utilisé pour convertir la sortie du décodeur en caractéristiques audio.
PerceiverClassificationPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor
< source >( config: PerceiverConfigin_channels: int )
Post-traitement de la classification pour Perceiver. Peut être utilisé pour convertir la sortie du décodeur en logits de classification.
PerceiverMultimodalPostprocessor
classe transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor
< source >( modalities: Mappinginput_is_dict: bool = False )
Paramètres
- modalities (
Mapping[str, PostprocessorType]) — Dictionnaire associant le nom de la modalité à la classe de postprocesseur pour cette modalité. - input_is_dict (
bool, facultatif, valeur par défautFalse) — Si True, l'entrée est supposée être structurée sous forme de dictionnaire, et les sorties conservent la même forme de dictionnaire. Si False, l'entrée est un tenseur qui est découpé lors du post-traitement par modality_sizes.
Post-traitement multimodal pour Perceiver. Peut être utilisé pour combiner des post-processeurs spécifiques à chaque modalité en un seul post-processeur.
PerceiverModel
classe transformers.PerceiverModel
< source >( config: PerceiverConfigdecoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = Noneinput_preprocessor: Callable = Noneoutput_postprocessor: Callable = None )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
- decoder (
PerceiverDecoder, facultatif) — Module de décodage qui transforme les représentations latentes en prédictions de tâche. - input_preprocessor (
PreprocessorType, facultatif) — Préprocesseur qui encode les entrées brutes en tenseurs pour le modèle. - output_postprocessor (
PostprocessorType, facultatif) — Postprocesseur qui transforme les sorties du modèle en prédictions finales.
Le Perceiver : une architecture entièrement attentionnelle et évolutive.
Notez qu’il est possible d’affiner Perceiver sur des images de résolution supérieure à celles sur lesquelles il a été entraîné, en définissant
interpolate_pos_encodingsurTruedans le forward du modèle. Cela interpole les embeddings de position pré-entraînés à la résolution supérieure.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- subsampled_output_points (
dict[str, torch.Tensor], facultatif) — Dictionnaire de tenseurs utilisés comme requêtes pour le décodeur. Le décodeur associe ces requêtes à la représentation latente du modèle. Utilisé pour le décodage sous-échantillonné, par exemple lors du décodage de certaines zones d’image uniquement. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - interpolate_pos_encoding (
bool, facultatif, par défautFalse) — Indique s'il faut interpoler les encodages de position pré-entraînés. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
PerceiverModelOutput ou tuple(torch.Tensor)
Un PerceiverModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward du PerceiverModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
logits (
torch.Tensorde forme(batch_size, num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du modèle.hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForMaskedLM
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour le masquage de modélisation de langage.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[-100, 0, ..., config.vocab_size](voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple. - input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Retourne
PerceiverMaskedLMOutput ou tuple(torch.Tensor)
Un PerceiverMaskedLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForMaskedLM redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation de langage masquée (MLM).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForSequenceClassification
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour la classification de texte.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple. - input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForSequenceClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForImageClassificationLearned
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour la classification d'images, pour des tâches telles qu'ImageNet.
Ce modèle utilise des embeddings de position appris. Autrement dit, ce modèle ne reçoit aucune information privilégiée sur la structure des images. Comme le montre l’article, ce modèle peut atteindre une précision top-1 de 72,7 sur ImageNet.
PerceiverForImageClassificationLearned utilise PerceiverImagePreprocessor (avec prep_type="conv1x1") pour prétraiter les images d’entrée, et PerceiverClassificationDecoder pour décoder la représentation latente de PerceiverModel en logits de classification.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - interpolate_pos_encoding (
bool, facultatif, par défautFalse) — Indique s'il faut interpoler les encodages de position pré-entraînés. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple. - pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de PerceiverImageProcessor. Voir PerceiverImageProcessor.call() pour plus de détails (processor_classutilise PerceiverImageProcessor pour le traitement des images).
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForImageClassificationLearned redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForImageClassificationFourier
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour la classification d'images, pour des tâches telles qu'ImageNet.
Ce modèle utilise des embeddings de position 2D de Fourier fixes. Comme indiqué dans l'article, ce modèle peut atteindre une précision top-1 de 79,0 sur ImageNet, et 84,5 lorsqu'il est pré-entraîné sur un jeu de données à grande échelle (c.-à-d. JFT).
PerceiverForImageClassificationLearned utilise PerceiverImagePreprocessor (avec prep_type="pixels") pour prétraiter les images d’entrée, et PerceiverClassificationDecoder pour décoder la représentation latente de PerceiverModel en logits de classification.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple. - pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de PerceiverImageProcessor. Voir PerceiverImageProcessor.call() pour plus de détails (processor_classutilise PerceiverImageProcessor pour le traitement des images).
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForImageClassificationFourier redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForImageClassificationConvProcessing
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour la classification d'images, pour des tâches telles qu'ImageNet.
Ce modèle utilise un réseau de prétraitement conv2D+maxpool. Comme indiqué dans l'article, ce modèle peut atteindre une précision top-1 de 82,1 sur ImageNet.
PerceiverForImageClassificationLearned utilise PerceiverImagePreprocessor (avec prep_type="conv") pour prétraiter les images d’entrée, et PerceiverClassificationDecoder pour décoder la représentation latente de PerceiverModel en logits de classification.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple. - pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de PerceiverImageProcessor. Voir PerceiverImageProcessor.call() pour plus de détails (processor_classutilise PerceiverImageProcessor pour le traitement des images).
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForImageClassificationConvProcessing redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForOpticalFlow
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d’utilisation de Perceiver pour le flux optique, pour des tâches telles que Sintel et KITTI. PerceiverForOpticalFlow utilise PerceiverImagePreprocessor (avec prep_type=“patches”) pour prétraiter les images d’entrée, et PerceiverOpticalFlowDecoder pour décoder la représentation latente de PerceiverModel.
En entrée, on concatène 2 images consécutives le long de la dimension des canaux et on extrait un patch de 3 x 3 autour de chaque pixel (ce qui donne 3 x 3 x 3 x 2 = 54 valeurs pour chaque pixel). Des encodages de position de Fourier fixes sont utilisés pour encoder la position de chaque pixel dans le patch. Ensuite, on applique l'encodeur Perceiver. Pour décoder, on interroge la représentation latente en utilisant le même encodage que celui utilisé pour l'entrée.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de flux optique. Les indices doivent être dans[0, ..., config.num_labels - 1]. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForOpticalFlow redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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
classe transformers.PerceiverForMultimodalAutoencoding
< source >( config: PerceiverConfig )
Paramètres
- config (PerceiverConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Exemple d'utilisation de Perceiver pour l'auto-encodage multimodal (vidéo), pour des tâches telles que Kinetics-700.
PerceiverForMultimodalAutoencoding utilise PerceiverMultimodalPreprocessor pour prétraiter les 3 modalités : images, audio et étiquettes de classes. Ce préprocesseur utilise des préprocesseurs spécifiques à chaque modalité pour prétraiter chaque modalité séparément, après quoi elles sont concaténées. Des embeddings de position entraînables sont utilisés pour rembourrer chaque modalité au même nombre de canaux afin de permettre la concaténation le long de la dimension temporelle. Ensuite, on applique l’encodeur Perceiver.
PerceiverMultimodalDecoder est utilisé pour décoder la représentation latente de PerceiverModel. Ce décodeur utilise chaque décodeur spécifique à une modalité pour construire des requêtes. Les requêtes du décodeur sont créées sur la base des entrées après prétraitement. Toutefois, l’auto-encodage d’une vidéo entière en un seul passage avant est computationnellement irréalisable, on n’utilise donc que des parties des requêtes du décodeur pour effectuer l’attention croisée avec la représentation latente. Cela est déterminé par les indices sous-échantillonnés pour chaque modalité, qui peuvent être fournis comme entrée supplémentaire au passage avant de PerceiverForMultimodalAutoencoding.
PerceiverMultimodalDecoder remplit également les requêtes du décodeur des différentes modalités jusqu’au même nombre de canaux, afin de pouvoir les concaténer le long de la dimension temporelle. Ensuite, une attention croisée est effectuée avec la représentation latente de PerceiverModel.
Enfin, ~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor est utilisé pour transformer ce tenseur en vidéo réelle. Il commence par diviser la sortie en différentes modalités, puis applique le postprocesseur correspondant à chaque modalité.
Notez que, en masquant l'étiquette de classification lors de l'évaluation (c'est-à-dire en fournissant simplement un tenseur de zéros pour la modalité « label »), ce modèle d'auto-encodage devient un classifieur de vidéos Kinetics 700.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- inputs (
torch.Tensor, facultatif) — Entrées du perceiver. Peut être n'importe quoi : images, texte, audio, vidéo, etc. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- subsampled_output_points (
dict[str, torch.Tensor], facultatif) — Dictionnaire de tenseurs utilisés comme requêtes pour le décodeur. Le décodeur associe ces requêtes à la représentation latente du modèle. Utilisé pour le décodage sous-échantillonné, par exemple lors du décodage de certaines zones d’image uniquement. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
PerceiverClassifierOutput ou tuple(torch.Tensor)
Un PerceiverClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (PerceiverConfig) et des entrées.
La méthode forward de PerceiverForMultimodalAutoencoding redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
Exemples :
>>> 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]