PerceiverIO_Pytorch

Perceiverio Pytorch

Adaptação do modelo de DeepMind's Perceiverio (https://arxiv.org/abs/2103.03206) a Pytorch. O código Jax/Haiku original pode ser encontrado aqui: https://github.com/deepmind/deepmind-research/tree/master/perceiver

Instalação

• Clone o repositório:

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

• Crie um ambiente virtual e ative -o:

python3 -m venv perceiverEnv
source perceiverEnv/bin/activate

• Instale o Pytorch seguindo as instruções oficiais: https://pytorch.org/get-started/locally/

• Instale outros pacotes necessários do requisitos.txt:

pip3 install -r requirements.txt

Exemplos

A implementação abrange as seguintes tarefas de exemplo para as quais estão disponíveis modelos pré -terem sido disponíveis:

• Modelagem de linguagem mascarada (exemplo_language.py)
• Classificação da imagem (exemplo_img_classify.py)
• Vídeo multimodal Auto-codificação (exemplo_multimodal.py)
• Estimativa de fluxo óptico (exemplo_opt_flow.py)

Modelos pré -teremam

Os pontos de verificação do haiku do repositório oficial do DeepMind foram convertidos em pontos de verificação de Pytorch e podem ser baixados do Google-Drive. Os pontos de verificação Pytorch devem ser colocados na pasta 'pytorch_checkpoints' para que o código de exemplo possa encontrá -los.

Uso

Para criar um novo Preceiverio para uma tarefa personalizada, a classe Perceptor em perceber_io/perceber.py é usada.

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

A seguir, é apresentado um diagrama do Perceiverio para um aplicativo multimodal:

Pré -processadores de entrada (opcional)

Os pré-processadores de entrada pegam os dados de entrada bruta e o pré-processam para que possam ser consultados pela primeira atendimento cruzado. Isso pode ser, por exemplo, algo como criar patches a partir de uma imagem. Normalmente, as codificações posicionais são incorporadas pelo pré -processador. Em vez de usar um pré -processador, as entradas também podem ser processadas manualmente.

Vários input_preprocessadores podem ser encontrados em perceiver_io/io_processors/preprocessors.py

Pós -processadores de saída (opcional)

Os pós -processadores de saída pegam a saída final do Perceptor e processam -o para obter o formato de saída desejado.

Vários output_postProcessors podem ser encontrados em perceiver_io/io_processors/postprocessors.py

Consultas de saída

As consultas do OPUT criam os recursos usados ​​para consultar a representação latente final do Perceptor para produzir a saída. Eles obtêm a entrada pré -processada como um argumento para que possam usá -lo, se desejar. Eles também geralmente incorporam codificações posicionais.

Várias saídas de saída podem ser encontradas em perceiver_io/output_queries.py ### múltiplas modalidades para processar várias modalidades de uma só vez, um dicionário com um mapeamento da modalidade para o módulo pode ser usado para o input_preprocessors, o output_PostProcessors e o Output_Queries (veja o Perceming_IO/ Para tornar as diferentes entradas compatíveis entre si, elas são acolchoadas para o mesmo tamanho de canal com parâmetros treináveis. Também é possível usar um número diferente de consultas de saída do que as entradas são fornecidas.

Citações

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