Modèles | Exemples de scripts | Commencer | Présentation du code | Installation | Contribuer | Licence
TorchMultimodal est une bibliothèque PyTorch permettant de former à grande échelle des modèles multimodaux multitâches de pointe, incluant à la fois la compréhension du contenu et les modèles génératifs. TorchMultimodal contient :
TorchMultimodal contient un certain nombre de modèles, notamment
En plus des modèles ci-dessus, nous fournissons des exemples de scripts pour la formation, le réglage fin et l'évaluation des modèles sur des tâches multimodales populaires. Des exemples peuvent être trouvés sous exemples/ et incluent
| Modèle | Tâches prises en charge |
|---|---|
| ALBEF | Récupération Réponse visuelle aux questions |
| DDPM | Formation et inférence (carnet) |
| FLAVE | Pré-formation Réglage fin Coup zéro |
| MDETR | Mise à la terre de la phrase Réponse visuelle aux questions |
| MUGEN | Récupération de texte en vidéo Génération de texte en vidéo |
| Omnivore | Pré-formation Évaluation |
Ci-dessous, nous donnons des exemples minimaux de la façon dont vous pouvez écrire un script de formation simple ou d'évaluation zéro-shot à l'aide des composants de TorchMultimodal.
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 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 ()diffusion_labs contient des composants pour créer des modèles de diffusion. Pour plus de détails sur ces composants, voir diffusion_labs/README.md.
Recherchez ici les classes de modèles ainsi que tout autre code de modélisation spécifique à une architecture donnée. Par exemple, le répertoire torchmultimodal/models/blip2 contient des composants de modélisation spécifiques à BLIP-2.
Recherchez ici les éléments de base génériques courants qui peuvent être assemblés pour construire une nouvelle architecture. Cela inclut des couches telles que des livres de codes, des intégrations de patchs ou des encodeurs/décodeurs de transformateur, des pertes telles que la perte de contraste avec la température ou la perte de reconstruction, des encodeurs comme ViT et BERT et des modules de fusion comme la fusion Deep Set.
Recherchez ici les transformations de données courantes à partir de modèles populaires, par exemple CLIP, FLAVA et MAE.
TorchMultimodal nécessite Python >= 3.8. La bibliothèque peut être installée avec ou sans support CUDA. Ce qui suit suppose que conda est installé.
Installer l'environnement conda
conda create -n torch-multimodal python=
conda activate torch-multimodal
Installez pytorch, torchvision et torchaudio. Voir la documentation 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
Le binaire nocturne sous Linux pour Python 3.8 et 3.9 peut être installé via des roues pip. Pour l'instant, nous ne prenons en charge que la plate-forme Linux via PyPI.
python -m pip install torchmultimodal-nightly
Alternativement, vous pouvez également créer à partir de notre code source et exécuter nos exemples :
git clone --recursive https://github.com/facebookresearch/multimodal.git multimodal
cd multimodal
pip install -e .
Pour les développeurs, veuillez suivre l'installation du développement.
Nous acceptons toutes les demandes de fonctionnalités, les rapports de bugs ou les demandes d'extraction de la communauté. Voir le fichier CONTRIBUTION pour savoir comment aider.
TorchMultimodal est sous licence BSD, comme indiqué dans le fichier LICENSE.
