PerceiverIO_Pytorch

Perceiverio pytorch

Adaptation du modèle Perceiverio de DeepMind (https://arxiv.org/abs/2103.03206) à Pytorch. Le code JAX / Haiku original peut être trouvé ici: https://github.com/deepmind/deepmind-research/tree/master/perceiver

Installation

• Clone le référentiel:

git clone https://github.com/JOBR0/PerceiverIO_Pytorch
cd PerceiverIO_Pytorch

• Créez un environnement virtuel et activez-le:

python3 -m venv perceiverEnv
source perceiverEnv/bin/activate

• Installez Pytorch en suivant les instructions officielles: https://pytorch.org/get-started/locally/

• Installez les autres packages requis à partir des exigences.txt:

pip3 install -r requirements.txt

Exemples

La mise en œuvre couvre les exemples de tâches suivantes pour lesquelles des modèles pré-entraînés sont disponibles:

• Modélisation du langage masqué (Exemple_Language.py)
• Classification d'image (Exemple_img_classify.py)
• Auto-codage vidéo multimodal (Exemple_Multimodal.py)
• Estimation du flux optique (exemple_opt_flow.py)

Modèles pré-entraînés

Les points de contrôle Haiku du référentiel DeepMind officiel ont été convertis en points de contrôle Pytorch et peuvent être téléchargés à partir de Google-Drive. Les points de contrôle Pytorch doivent être placés dans le dossier 'pytorch_checkpoints afin que l'exemple de code puisse les trouver.

Usage

Pour créer un nouveau Preceiverio pour une tâche personnalisée, la classe Percepteur dans Perceiver_io / perceiver.py est utilisée.

 class PerceiverIO ( nn . Module ):
    """The Perceiver: a scalable, fully attentional architecture.
    Args:
        num_blocks (int): Number of times the block is applied with shared weights. Default: 8
        num_self_attends_per_block (int): Number of self-attentions in the block. Default: 6,
        num_latents: (int): Number of latent vectors. Default 512,
        num_latent_channels (int): Number of channels for the latent vectors. Default: 1024,
        final_project (bool): Whether to apply a linear layer to the outputs before the post-processors. Default: True,
        final_project_out_channels (int): Number of output channels for the final projection layer. Default: None,
        perceiver_encoder_kwargs (Dict): Additional arguments for the perceiver encoder class. Default: {},
        perceiver_decoder_kwargs (Dict): Additional arguments for the perceiver decoder class. Default: {},
        input_preprocessors (dict / nn.Module): Optional input preprocessors. 1 or none for each modality. Default: None,
        output_postprocessors (dict / nn.Module): Optional output postprocessors. 1 or none for each modality. Default: None,
        output_queries (dict / nn.Module): Modules that create the output queries. 1 for each modality. Default: None,
        output_query_padding_channels (int): Number of learnable features channels that are added to the output queries. Default: 0,
        input_padding_channels (int): Number of learnable features channels that are added to the preprocessed inputs. Default: 0,
        input_channels (dict, int): = The number of input channels need to be specified if NO preprocessor is used. Otherwise,
                                    the number will be inferred from the preprocessor. Default: None,
        input_mask_probs (dict): Probability with which each input modality will be masked out. Default None,
    """

Ce qui suit est un diagramme du Perceiverio pour une application multimodale:

Prérocesseurs d'entrée (facultatif)

Les préprocesseurs d'entrée prennent les données d'entrée brutes et le préparent à le prétraiter afin qu'il puisse être interrogé par la première transtention croisée. Cela peut être par exemple quelque chose comme créer des patchs à partir d'une image. Habituellement, les encodages positionnels sont incorporés par le préprocesseur. Au lieu d'utiliser un préprocesseur, les entrées peuvent également être traitées manuellement.

Plusieurs Input_preprocessors peuvent être trouvés dans perceiver_io/io_processors/preprocessors.py

Post-processeurs de sortie (facultatif)

Les postprocesseurs de sortie prennent la sortie finale du percepteur et le traitent pour obtenir le format de sortie souhaité.

Plusieursprocesses Output_Post peuvent être trouvées dans perceiver_io/io_processors/postprocessors.py

Requêtes de sortie

Les requêtes ouput créent les fonctionnalités utilisées pour interroger la représentation latente finale du percepteur pour produire la sortie. Ils obtiennent l'entrée prétraitée comme argument afin qu'ils puissent l'utiliser si vous le souhaitez. Ils incorporent également généralement des encodages de position.

Plusieurs Output_Queries peuvent être trouvés dans perceiver_io/output_queries.py ### plusieurs modalités pour traiter plusieurs modalités à la fois, un dictionnaire avec un mappage de la modalité au module peut être utilisé pour les INPUT_PREPROCESSOR, MOTTIMODAL_POSTPROCRESSORS ET LE SUPPORT_QUERIES (voir percever_io / multimodal_perceiver.py). Pour rendre les différentes entrées compatibles entre elles, elles sont rembourrées à la même taille de canal avec des paramètres entraînant. Il est également possible d'utiliser un nombre différent de requêtes de sortie que les entrées sont données.

Citations

 @misc { jaegle2021perceiver ,
    title   = { Perceiver IO: A General Architecture for Structured Inputs & Outputs } ,
    author  = { Andrew Jaegle and Sebastian Borgeaud and Jean-Baptiste Alayrac and Carl Doersch and Catalin Ionescu and David Ding and Skanda Koppula and Andrew Brock and Evan Shelhamer and Olivier Hénaff and Matthew M. Botvinick and Andrew Zisserman and Oriol Vinyals and João Carreira } ,
    year    = { 2021 } ,
    eprint  = { 2107.14795 } ,
    archivePrefix = { arXiv } ,
    primaryClass = { cs.LG }
}