Download multimodal - download de código-fonte multimodal

multimodal

Outro código-fonte

Baixar

TorchMultimodal (versão beta)

Introdução

TorchMultimodal é uma biblioteca PyTorch para treinar modelos multitarefas multimodais de última geração em escala, incluindo compreensão de conteúdo e modelos generativos. TorchMultimodal contém:

Um repositório de blocos de construção modulares e combináveis (camadas de fusão, funções de perda, conjuntos de dados e utilitários).
Uma coleção de classes de modelos multimodais comuns construídas a partir dos referidos blocos de construção com pesos pré-treinados para configurações canônicas.
Um conjunto de exemplos que mostram como combinar esses blocos de construção com componentes e infraestrutura comum de todo o ecossistema PyTorch para replicar modelos de última geração publicados na literatura. Estes exemplos devem servir como base para pesquisas em andamento na área, bem como um ponto de partida para trabalhos futuros.

Modelos

TorchMultimodal contém vários modelos, incluindo

ALBEF: classe modelo, papel
BLIP-2: classe de modelo, papel
CLIP: classe modelo, papel
CoCa: classe modelo, papel
DALL-E 2: modelo, papel
FLAVA: classe modelo, papel
MAE/Áudio MAE: classe de modelo, papel MAE, papel MAE de áudio
MDETR: classe de modelo, papel

Scripts de exemplo

Além dos modelos acima, fornecemos scripts de exemplo para treinamento, ajuste fino e avaliação de modelos em tarefas multimodais populares. Exemplos podem ser encontrados em exemplos/ e incluem

Modelo	Tarefas Suportadas
ALBEF	Recuperação Resposta visual a perguntas
DDPM	Treinamento e Inferência (caderno)
FLAVA	Pré-treinamento Afinação Tiro zero
MDETR	Aterramento de frase Resposta visual a perguntas
MUGEN	Recuperação de texto para vídeo Geração de texto para vídeo
Onívoro	Pré-treino Avaliação

Começando

Abaixo, damos exemplos mínimos de como você pode escrever um script simples de treinamento ou avaliação zero-shot usando componentes do TorchMultimodal.

Exemplo de tiro zero FLAVA

 import torch
from PIL import Image
from torchmultimodal . models . flava . model import flava_model
from torchmultimodal . transforms . bert_text_transform import BertTextTransform
from torchmultimodal . transforms . flava_transform import FLAVAImageTransform

# Define helper function for zero-shot prediction
def predict ( zero_shot_model , image , labels ):
  zero_shot_model . eval ()
  with torch . no_grad ():
      image = image_transform ( img )[ "image" ]. unsqueeze ( 0 )
      texts = text_transform ( labels )
      _ , image_features = zero_shot_model . encode_image ( image , projection = True )
      _ , text_features = zero_shot_model . encode_text ( texts , projection = True )
      scores = image_features @ text_features . t ()
      probs = torch . nn . Softmax ( dim = - 1 )( scores )
      label = labels [ torch . argmax ( probs )]
      print (
          "Label probabilities: " ,
          { labels [ i ]: probs [:, i ] for i in range ( len ( labels ))},
      )
      print ( f"Predicted label: { label } " )


image_transform = FLAVAImageTransform ( is_train = False )
text_transform = BertTextTransform ()
zero_shot_model = flava_model ( pretrained = True )
img = Image . open ( "my_image.jpg" )  # point to your own image
predict ( zero_shot_model , img , [ "dog" , "cat" , "house" ])

# Example output:
# Label probabilities:  {'dog': tensor([0.80590]), 'cat': tensor([0.0971]), 'house': tensor([0.0970])}
# Predicted label: dog

Exemplo de treinamento MAE

 import torch
from torch . utils . data import DataLoader
from torchmultimodal . models . masked_auto_encoder . model import vit_l_16_image_mae
from torchmultimodal . models . masked_auto_encoder . utils import (
  CosineWithWarmupAndLRScaling ,
)
from torchmultimodal . modules . losses . reconstruction_loss import ReconstructionLoss
from torchmultimodal . transforms . mae_transform import ImagePretrainTransform

mae_transform = ImagePretrainTransform ()
dataset = MyDatasetClass ( transforms = mae_transform )  # you should define this
dataloader = DataLoader ( dataset , batch_size = 8 )

# Instantiate model and loss
mae_model = vit_l_16_image_mae ()
mae_loss = ReconstructionLoss ()

# Define optimizer and lr scheduler
optimizer = torch . optim . AdamW ( mae_model . parameters ())
lr_scheduler = CosineWithWarmupAndLRScaling (
  optimizer , max_iters = 1000 , warmup_iters = 100  # you should set these
)

# Train one epoch
for batch in dataloader :
  model_out = mae_model ( batch [ "images" ])
  loss = mae_loss ( model_out . decoder_pred , model_out . label_patches , model_out . mask )
  loss . backward ()
  optimizer . step ()
  lr_scheduler . step ()

Visão geral do código

tochamultimodal/difusão_labs

diffusion_labs contém componentes para construir modelos de difusão. Para obter mais detalhes sobre esses componentes, consulte diffusion_labs/README.md.

tochamultimodal/modelos

Procure aqui as classes de modelo, bem como qualquer outro código de modelagem específico para uma determinada arquitetura. Por exemplo, o diretório torchmultimodal/models/blip2 contém componentes de modelagem específicos para BLIP-2.

tochamultimodal/módulos

Procure aqui blocos de construção genéricos comuns que podem ser unidos para construir uma nova arquitetura. Isso inclui camadas como livros de código, embeddings de patch ou codificadores/decodificadores de transformadores, perdas como perda contrastiva com temperatura ou perda de reconstrução, codificadores como ViT e BERT e módulos de fusão como fusão Deep Set.

tochamultimodal/transforma

Procure aqui transformações de dados comuns de modelos populares, por exemplo, CLIP, FLAVA e MAE.

Instalação

TorchMultimodal requer Python >= 3.8. A biblioteca pode ser instalada com ou sem suporte CUDA. O seguinte pressupõe que o conda esteja instalado.

Pré-requisitos

Instale o ambiente conda

 conda create -n torch-multimodal python=
conda activate torch-multimodal

Instale pytorch, torchvision e torchaudio. Consulte a documentação do PyTorch.

 # Use the current CUDA version as seen [here](https://pytorch.org/get-started/locally/)
# Select the nightly Pytorch build, Linux as the OS, and conda. Pick the most recent CUDA version.
conda install pytorch torchvision torchaudio pytorch-cuda= -c pytorch-nightly -c nvidia

# For CPU-only install
conda install pytorch torchvision torchaudio cpuonly -c pytorch-nightly

Instalar a partir de binários

O binário noturno no Linux para Python 3.8 e 3.9 pode ser instalado por meio de rodas pip. Por enquanto só oferecemos suporte à plataforma Linux através do PyPI.

 python -m pip install torchmultimodal-nightly

Construindo a partir da fonte

Alternativamente, você também pode construir a partir de nosso código-fonte e executar nossos exemplos:

 git clone --recursive https://github.com/facebookresearch/multimodal.git multimodal
cd multimodal

pip install -e .

Para desenvolvedores, siga a instalação de desenvolvimento.

Contribuindo

Agradecemos quaisquer solicitações de recursos, relatórios de bugs ou solicitações de pull da comunidade. Veja o arquivo CONTRIBUTING para saber como ajudar.