PerceiverIO_Pytorch

Perceptio pytorch

Adaptación del modelo Perceiverio de Deepmind (https://arxiv.org/abs/2103.03206) a Pytorch. El código Jax/Haiku original se puede encontrar aquí: https://github.com/deepmind/deepmind-research/tree/master/perceiver

Instalación

• Clon el repositorio:

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

• Crear un entorno virtual y activarlo:

python3 -m venv perceiverEnv
source perceiverEnv/bin/activate

• Instale Pytorch siguiendo las instrucciones oficiales: https://pytorch.org/get-started/locally/

• Instale otros paquetes requeridos de requisitos.txt:

pip3 install -r requirements.txt

Ejemplos

La implementación cubre las siguientes tareas de ejemplo para las que están disponibles los modelos previos a los detenidos:

• Modelado de lenguaje enmascarado (ejemplo_language.py)
• Clasificación de imagen (ejemplo_img_classify.py)
• Video multimodal en codificación automática (ejemplo_multimodal.py)
• Estimación de flujo óptico (ejemplo_opt_flow.py)

Modelos previos a la aparición

Los puntos de control de Haiku del repositorio oficial de DeepMind se han convertido en puntos de control de Pytorch y se pueden descargar desde Google-Drive. Los puntos de control de Pytorch deben colocarse en la carpeta 'Pytorch_checkpoints' para que el código de ejemplo pueda encontrarlos.

Uso

Para crear un nuevo preceptorio para una tarea personalizada, se usa la clase de perceptor en Perceiver_io/Perceiver.py.

 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,
    """

El siguiente es un diagrama de Perceiverio para una aplicación multimodal:

Preprocesadores de entrada (opcional)

Los preprocesadores de entrada toman los datos de entrada sin procesar y los preprocesan para que pueda ser consultado mediante la primera atención cruzada. Esto puede ser, por ejemplo, algo así como crear parches a partir de una imagen. Por lo general, las codificaciones posicionales son incorporadas por el preprocesador. En lugar de usar un preprocesador, las entradas también se pueden procesar manualmente.

Se pueden encontrar varios input_processors en perceiver_io/io_processors/preprocessors.py

Postprocesadores de salida (opcional)

Postprocesadores de salida tome la salida final del perceptor y la procese para obtener el formato de salida deseado.

Se pueden encontrar varios proposores de salida_post en perceiver_io/io_processors/postprocessors.py

Consultas de salida

Las consultas de salida crean las características que se utilizan para consultar la representación latente final del perceptor para producir la salida. Obtienen la entrada preprocesada como un argumento para que puedan usarla si lo desea. También generalmente incorporan codificaciones posicionales.

Se pueden encontrar varias salidas_queries en perceiver_io/output_queries.py ### Múltiples modalidades para procesar múltiples modalidades a la vez, un diccionario con una asignación de modalidad al módulo se puede usar para input_processors, output_postProcessors y el output_queries (ver Perceriver_io/multimodal_perceiver.py). Para hacer que las diferentes entradas sean compatibles entre sí, están acolchadas al mismo tamaño de canal con parámetros entrenables. También es posible usar un número diferente de consultas de salida a las que se dan entradas.

Citas

 @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 }
}