open_clip
v2.29.0
[Papier] [Citations] [Clip Colab] [Coca Colab]
Bienvenue dans une implémentation open source du clip d'Openai (pré-formation d'image linguistique contrastive).
En utilisant cette base de code, nous avons formé plusieurs modèles sur une variété de sources de données et de calcul des budgets, allant des expériences à petite échelle à des séries plus grandes, y compris des modèles formés sur des ensembles de données tels que LAION-400M, LAION-2B et DATACOMPO-1B. Beaucoup de nos modèles et leurs propriétés de mise à l'échelle sont étudiés en détail dans les lois de mise à l'échelle reproductibles de l'article pour l'apprentissage contrasté de l'image linguistique. Certains des meilleurs modèles que nous ayons formés et leur précision ImageNet-1-1-1-Shot sont illustrés ci-dessous, ainsi que le modèle Vit-L formé par OpenAI et d'autres alternatives open source de pointe (tous peuvent être chargés via OpenClip). Nous fournissons ici plus de détails sur notre collection complète de modèles pré-entraînés et des résultats zéro-shot pour 38 ensembles de données ici.
| Modèle | Données de formation | Résolution | # d'échantillons vus | ImageNet Zero-Shot Acc. |
|---|---|---|---|---|
| Bas-base | Laion-2b | 256px | 13B | 71,5% |
| Convainx | Laion-2b | 320px | 29B | 76,9% |
| Convnext-xxlARGE | Laion-2b | 256px | 34b | 79,5% |
| Vit-B / 32 | Datacomp-1b | 256px | 34b | 72,8% |
| Vit-B / 16 | Datacomp-1b | 224px | 13B | 73,5% |
| Vit-L / 14 | Laion-2b | 224px | 32b | 75,3% |
| Vit-h / 14 | Laion-2b | 224px | 32b | 78,0% |
| Vit-L / 14 | Datacomp-1b | 224px | 13B | 79,2% |
| Vit-g / 14 | Laion-2b | 224px | 34b | 80,1% |
| Vit-L / 14 (clip d'origine) | ESPRIT | 224px | 13B | 75,5% |
| VIT-SO400M / 14 (Siglip) | Webli | 224px | 45b | 82,0% |
| VIT-SO400M-14-Siglip-384 (Siglip) | Webli | 384px | 45b | 83,1% |
| Vit-H / 14-QUICKGELU (DFN) | DFN-5B | 224px | 39b | 83,4% |
| VIT-H-14-378-QUICKGELU (DFN) | DFN-5B | 378px | 44b | 84,4% |
Des cartes de modèle avec des détails spécifiques au modèle supplémentaires peuvent être trouvés sur le centre de face étreint sous la balise de la bibliothèque OpenClip: https://huggingface.co/models?library=Open_CLIP.
Si vous avez trouvé ce référentiel utile, veuillez envisager de citer. Nous accueillons quiconque à soumettre un problème ou à envoyer un e-mail si vous avez d'autres demandes ou suggestions.
Notez que des parties du code src/open_clip/ Modélisation et Tokenizer sont des adaptations du référentiel officiel d'OpenAI.
| Crédit d'image: https://github.com/openai/clip |
pip install open_clip_torch
import torch
from PIL import Image
import open_clip
model , _ , preprocess = open_clip . create_model_and_transforms ( 'ViT-B-32' , pretrained = 'laion2b_s34b_b79k' )
model . eval () # model in train mode by default, impacts some models with BatchNorm or stochastic depth active
tokenizer = open_clip . get_tokenizer ( 'ViT-B-32' )
image = preprocess ( Image . open ( "docs/CLIP.png" )). unsqueeze ( 0 )
text = tokenizer ([ "a diagram" , "a dog" , "a cat" ])
with torch . no_grad (), torch . cuda . amp . autocast ():
image_features = model . encode_image ( image )
text_features = model . encode_text ( text )
image_features /= image_features . norm ( dim = - 1 , keepdim = True )
text_features /= text_features . norm ( dim = - 1 , keepdim = True )
text_probs = ( 100.0 * image_features @ text_features . T ). softmax ( dim = - 1 )
print ( "Label probs:" , text_probs ) # prints: [[1., 0., 0.]]Voir aussi ce [clip colab].
Pour calculer efficacement des milliards d'incorpolation, vous pouvez utiliser le Retrierie Clip qui a un support OpenClip.
Nous offrons une interface de modèle simple pour instancier à la fois des modèles pré-formés et non entraînés. Pour voir quels modèles pré-entraînés sont disponibles, utilisez l'extrait de code suivant. Plus de détails sur nos modèles pré-entraînés sont disponibles ici.
> >> import open_clip
> >> open_clip . list_pretrained ()Vous pouvez en savoir plus sur les modèles que nous prenons en charge (par exemple, le nombre de paramètres, les flops) dans ce tableau.
Remarque: de nombreux points de contrôle existants utilisent l'activation QuickGelu à partir des modèles OpenAI d'origine. Cette activation est en fait moins efficace que Native Torch.nn.gelu dans les versions récentes de Pytorch. Les paramètres par défaut du modèle sont désormais nn.gelu, il faut donc utiliser des définitions de modèle avec -quickgelu postfix pour les poids pré-entraînés OpenClip. Tous les poids pré-entraînés Openai seront toujours par défaut à Quickgelu. On peut également utiliser les définitions du modèle non -quickgelu avec des poids pré-entraînés en utilisant Quickgelu, mais il y aura une baisse de précision, pour une tonnelle affinée qui disparaîtra probablement pendant des courses plus longues. Les futurs modèles formés utiliseront Nn.gelu.
Les modèles peuvent être chargés d' open_clip.create_model_and_transforms , comme indiqué dans l'exemple ci-dessous. Le nom du modèle et les clés pretrained correspondantes sont compatibles avec les sorties d' open_clip.list_pretrained() .
L'argument pretrained accepte également les chemins locaux, par exemple /path/to/my/b32.pt . Vous pouvez également charger des points de contrôle à partir de Huggingface de cette façon. Pour ce faire, téléchargez le fichier open_clip_pytorch_model.bin (par exemple, https://huggingface.co/laion/clip-vit-l-14-datacomp.xl-s13b-b90k/tree/main), et utilisez pretrained=/path/to/open_clip_pytorch_model.bin .
# pretrained also accepts local paths
model , _ , preprocess = open_clip . create_model_and_transforms ( 'ViT-B-32' , pretrained = 'laion2b_s34b_b79k' ) Ce référentiel est axé sur les modèles de clip de formation. Pour affiner un modèle formé zéro shot sur une tâche de classification en aval telle que ImageNet, veuillez consulter notre autre référentiel: Wise-FT. Le référentiel sage-FT contient du code pour notre article sur un réglage fin robuste des modèles à tirs zéro, dans lesquels nous introduisons une technique de réglage des modèles de coups zéro tout en préservant la robustesse sous décalage de distribution.
Pour télécharger des ensembles de données comme WebDataset, nous recommandons IMG2DATASET.
Voir Exemple CC3M IMG2DATASET.
En plus de spécifier les données de formation via des fichiers CSV comme mentionné ci-dessus, notre base de code prend également en charge WebDataset, qui est recommandée pour les ensembles de données à plus grande échelle. Le format attendu est une série de fichiers .tar . Chacun de ces fichiers .tar doit contenir deux fichiers pour chaque exemple de formation, un pour l'image et un pour le texte correspondant. Les deux fichiers doivent avoir le même nom mais des extensions différentes. Par exemple, shard_001.tar peut contenir des fichiers tels que abc.jpg et abc.txt . Vous pouvez en savoir plus sur webdataset sur https://github.com/webdataset/webdataset. Nous utilisons des fichiers .tar avec 1 000 points de données chacun, que nous créons en utilisant TARP.
Vous pouvez télécharger l'ensemble de données YFCC à partir de Multimedia Commons. Semblable à OpenAI, nous avons utilisé un sous-ensemble de YFCC pour atteindre les numéros de précision susmentionnés. Les indices des images de ce sous-ensemble sont dans le référentiel clip d'Openai.
Nous vous conseillons d'abord de créer un environnement virtuel avec:
python3 -m venv .env
source .env/bin/activate
pip install -U pip
Vous pouvez ensuite installer OpenClip pour une formation avec pip install 'open_clip_torch[training]' .
Si vous souhaitez apporter des modifications pour contribuer au code, vous pouvez cloner OpenClip, puis exécuter make install dans le dossier OpenClip (après avoir créé un virtualenv)
Installez Pip Pytorch selon https://pytorch.org/get-started/locally/
Vous pouvez exécuter make install-training pour installer des DEP de formation
Le test peut être exécuté avec make install-test puis make test
python -m pytest -x -s -v tests -k "training" pour exécuter un test spécifique
Exécution de tests de régression contre une révision ou une étiquette GIT spécifique:
Générer des données de test
python tests/util_test.py --model RN50 RN101 --save_model_list models.txt --git_revision 9d31b2ec4df6d8228f370ff20c8267ec6ba39383 AVERTISSEMENT : Cela invoquera Git et modifiera votre arbre fonctionnel, mais le réinitialidra à l'état actuel après la génération des données!
Ne modifiez pas votre arborescence fonctionnelle pendant que les données de test sont générées de cette façon.
Exécuter des tests de régression
OPEN_CLIP_TEST_REG_MODELS=models.txt python -m pytest -x -s -v -m regression_testpython -m open_clip_train.main
--save-frequency 1
--zeroshot-frequency 1
--report-to tensorboard
--train-data= " /path/to/train_data.csv "
--val-data= " /path/to/validation_data.csv "
--csv-img-key filepath
--csv-caption-key title
--imagenet-val=/path/to/imagenet/root/val/
--warmup 10000
--batch-size=128
--lr=1e-3
--wd=0.1
--epochs=30
--workers=8
--model RN50 Remarque: imagenet-val est le chemin vers l'ensemble de validation d'imageNet pour l'évaluation zéro-shot, pas l'ensemble de formation! Vous pouvez supprimer cet argument si vous ne voulez pas effectuer une évaluation de zéro-tir sur ImageNet tout au long de la formation. Notez que le dossier val doit contenir des sous-dossiers. Si ce n'est pas le cas, veuillez utiliser ce script.
Ce code a été testé au combat jusqu'à 1024 A100 et offre une variété de solutions pour la formation distribuée. Nous incluons le support natif pour les clusters Slurm.
À mesure que le nombre de dispositifs utilisés pour former augmente, la complexité spatiale de la matrice logit. En utilisant un schéma naïf de gathe, la complexité de l'espace sera O(n^2) . Au lieu de cela, la complexité peut devenir efficacement linéaire si les drapeaux --gather-with-grad et --local-loss qui sont utilisés. Cette altération entraîne des résultats numériques un à un comme méthode naïve.
Pour les ensembles de données plus grands (par exemple LAION2B), nous vous recommandons de définir --train-num-samples à une valeur inférieure à l'époque complète, par exemple --train-num-samples 135646078 à 1/16 d'une époque en conjonction avec --dataset-resampled pour faire un échantillonnage avec le remplacement. Cela permet à des points de contrôle fréquents d'évaluer plus souvent.
Des recherches récentes ont montré que l'on peut abandonner la moitié aux trois quarts des jetons visuels, conduisant à des vitesses d'entraînement jusqu'à 2-3x sans perte de précision.
Vous pouvez le définir sur votre configuration de transformateur visuel avec la clé patch_dropout .
Dans le journal, ils ont également été entités sans l'abandon du patch à la fin. Vous pouvez le faire avec l'argument de la ligne de commande --force-patch-dropout 0.
OpenClip prend en charge l'utilisation de plusieurs sources de données, en séparant différents chemins de données avec :: . Par exemple, pour s'entraîner sur CC12M et sur LAION, on peut utiliser --train-data "/data/cc12m/cc12m-train-{0000..2175}.tar::/data/LAION-400M/{00000..41455}.tar" . L'utilisation --dataset-resampled est recommandée pour ces cas.
Par défaut, dans l'attente, la quantité de fois où le modèle verra un échantillon de chaque source est proportionnel à la taille de la source. Par exemple, lors de la formation sur une source de données avec une taille 400m et une de taille 10m, les échantillons de la première source sont 40X plus susceptibles d'être vus dans l'attente.
Nous soutenons également une pondération différente des sources de données, en utilisant le drapeau --train-data-upsampling-factors . Par exemple, l'utilisation de --train-data-upsampling-factors=1::1 dans le scénario ci-dessus équivaut à ne pas utiliser l'indicateur, et --train-data-upsampling-factors=1::2 équivaut à la résistance à la deuxième source de données deux fois. Si vous souhaitez échantillonner à partir de sources de données avec la même fréquence, les facteurs de mise à l'échantillonnage doivent être inversement proportionnels aux tailles des sources de données. Par exemple, si l'ensemble de données A a 1000 échantillons et que l'ensemble de données B a 100 échantillons, vous pouvez utiliser --train-data-upsampling-factors=0.001::0.01 (ou de manière analogue, --train-data-upsampling-factors=1::10 ).
Nous utilisons torchrun pour lancer des travaux distribués. Ce qui suit lance un travail sur un nœud de 4 GPU:
cd open_clip/src
torchrun --nproc_per_node 4 -m open_clip_train.main
--train-data ' /data/cc12m/cc12m-train-{0000..2175}.tar '
--train-num-samples 10968539
--dataset-type webdataset
--batch-size 320
--precision amp
--workers 4
--imagenet-val /data/imagenet/validation/Le même script ci-dessus fonctionne, tant que les utilisateurs incluent des informations sur le nombre de nœuds et le nœud hôte.
cd open_clip/src
torchrun --nproc_per_node=4
--rdzv_endpoint= $HOSTE_NODE_ADDR
-m open_clip_train.main
--train-data ' /data/cc12m/cc12m-train-{0000..2175}.tar '
--train-num-samples 10968539
--dataset-type webdataset
--batch-size 320
--precision amp
--workers 4
--imagenet-val /data/imagenet/validation/C'est probablement la solution la plus simple à utiliser. Le script suivant a été utilisé pour former nos plus grands modèles:
#! /bin/bash -x
# SBATCH --nodes=32
# SBATCH --gres=gpu:4
# SBATCH --ntasks-per-node=4
# SBATCH --cpus-per-task=6
# SBATCH --wait-all-nodes=1
# SBATCH --job-name=open_clip
# SBATCH --account=ACCOUNT_NAME
# SBATCH --partition PARTITION_NAME
eval " $( /path/to/conda/bin/conda shell.bash hook ) " # init conda
conda activate open_clip
export CUDA_VISIBLE_DEVICES=0,1,2,3
export MASTER_PORT=12802
master_addr= $( scontrol show hostnames " $SLURM_JOB_NODELIST " | head -n 1 )
export MASTER_ADDR= $master_addr
cd /shared/open_clip
export PYTHONPATH= " $PYTHONPATH : $PWD /src "
srun --cpu_bind=v --accel-bind=gn python -u src/open_clip_train/main.py
--save-frequency 1
--report-to tensorboard
--train-data= " /data/LAION-400M/{00000..41455}.tar "
--warmup 2000
--batch-size=256
--epochs=32
--workers=8
--model ViT-B-32
--name " ViT-B-32-Vanilla "
--seed 0
--local-loss
--gather-with-gradpython -m open_clip_train.main
--train-data= " /path/to/train_data.csv "
--val-data= " /path/to/validation_data.csv "
--resume /path/to/checkpoints/epoch_K.pt Les modèles COCA de formation sont activés en spécifiant une configuration Coca en utilisant le paramètre --model du script d'entraînement. Les configurations actuellement disponibles sont "Coca_Base", "Coca_vit-B-32" et "Coca_roberta-Vit-B-32" (qui utilise Roberta comme encodeur de texte). Les configurations Coca sont différentes des configurations de clip car elles ont un composant supplémentaire "Multimodal_CFG" qui spécifie les paramètres du décodeur de texte multimodal. Voici un exemple de la configuration COCA_VIT-B-32:
"multimodal_cfg" : {
"context_length" : 76 ,
"vocab_size" : 49408 ,
"width" : 512 ,
"heads" : 8 ,
"layers" : 12 ,
"latent_dim" : 512 ,
"attn_pooler_heads" : 8
}Crédit à LucidRains pour le code initial, GPUCCE pour adapter le code à Open_CLIP et IEJMAC pour la formation des modèles.
import open_clip
import torch
from PIL import Image
model , _ , transform = open_clip . create_model_and_transforms (
model_name = "coca_ViT-L-14" ,
pretrained = "mscoco_finetuned_laion2B-s13B-b90k"
)
im = Image . open ( "cat.jpg" ). convert ( "RGB" )
im = transform ( im ). unsqueeze ( 0 )
with torch . no_grad (), torch . cuda . amp . autocast ():
generated = model . generate ( im )
print ( open_clip . decode ( generated [ 0 ]). split ( "<end_of_text>" )[ 0 ]. replace ( "<start_of_text>" , "" ))Voir aussi ce [Coca Colab]
Pour affiner COCA sur MSCOCO, créez d'abord l'ensemble de données, une façon consiste à utiliser un CSVDataset et peut-être que la façon la plus simple de le faire est d'utiliser Clip_benchmark qui à son tour utilise des pycocotools (qui peut également être utilisé seul).
from clip_benchmark . datasets . builder import build_dataset
import pandas as pd
import os
root_path = "path/to/data/dir" # set this to smth meaningful
ds = build_dataset ( "mscoco_captions" , root = root_path , split = "train" , task = "captioning" ) # this downloads the dataset if it is not there already
coco = ds . coco
imgs = coco . loadImgs ( coco . getImgIds ())
future_df = { "filepath" :[], "title" :[]}
for img in imgs :
caps = coco . imgToAnns [ img [ "id" ]]
for cap in caps :
future_df [ "filepath" ]. append ( img [ "file_name" ])
future_df [ "title" ]. append ( cap [ "caption" ])
pd . DataFrame . from_dict ( future_df ). to_csv (
os . path . join ( root_path , "train2014.csv" ), index = False , sep = " t "
)Cela devrait créer un ensemble de données CSV que l'on peut utiliser pour affiner la coca avec open_clip
python -m open_clip_train.main
--dataset-type " csv "
--train-data " path/to/data/dir/train2014.csv "
--warmup 1000
--batch-size 128
--lr 1e-5
--wd 0.1
--epochs 1
--workers 3
--model " coca_ViT-L-14 "
--report-to " wandb "
--coca-contrastive-loss-weight 0
--coca-caption-loss-weight 1
--log-every-n-steps 100 Il s'agit d'un paramètre général, Open_CLIP a des paramètres très qui peuvent être définis, python -m open_clip_train.main --help devrait les afficher. Le seul changement pertinent par rapport à la pré-formation est les deux arguments
--coca-contrastive-loss-weight 0
--coca-caption-loss-weight 1qui ne font que le modèle entraîne uniquement le côté génératif.
Si vous souhaitez utiliser différents modèles de langage comme encodeur de texte pour CLIP, vous pouvez le faire en utilisant l'une des configurations de modèle de visage étreint dans src/open_clip/model_configs et en passant par les paramètres de tokenzer en tant que --model et --hf-tokenizer-name . Actuellement, nous prenons uniquement Roberta ("Test-Roberta" Config), mais l'ajout de nouveaux modèles devrait être trivial. Vous pouvez également déterminer le nombre de couches, à partir de la fin, pour quitter les non-dérogées avec le paramètre de --lock-text-unlocked-layers . Voici un exemple de commande pour entraîner Clip avec le Roberta LM qui a ses 10 dernières couches non à déroge:
python -m open_clip_train.main
--train-data= " pipe:aws s3 cp s3://s-mas/cc3m/{00000..00329}.tar - "
--train-num-samples 3000000
--val-data= " pipe:aws s3 cp s3://s-mas/cc3m/{00330..00331}.tar - "
--val-num-samples 10000
--dataset-type webdataset
--batch-size 256
--warmup 2000
--epochs 10
--lr 5e-4
--precision amp
--workers 6
--model " roberta-ViT-B-32 "
--lock-text
--lock-text-unlocked-layers 10
--name " 10_unfrozen "
--report-to " tensorboard " Lorsqu'il est exécuté sur une machine avec 8 GPU, la commande doit produire la courbe de formation suivante pour les légendes conceptuelles:
Des courbes plus détaillées pour les légendes conceptuelles sont données sur /docs/clip_conceptual_captions.md.
Lors de la formation d'un RN50 sur YFCC, les mêmes hyperparamètres que ci-dessus sont utilisés, à l'exception de lr=5e-4 et epochs=32 .
Notez que pour utiliser un autre modèle, comme ViT-B/32 ou RN50x4 ou RN50x16 ou ViT-B/16 , spécifiez avec --model RN50x4 .
Pour la journalisation de Tensorboard, exécutez:
tensorboard --logdir=logs/tensorboard/ --port=7777 Pour la journalisation WANDB, nous vous recommandons de consulter la variable step au lieu de Step , car la dernière n'a pas été correctement définie dans les versions antérieures de cette base de code. Pour les courses plus anciennes avec des modèles formés avant # 613, la variable Step doit être ignorée. Pour les courses plus récentes, après cela PR, les deux variables sont les mêmes.
Nous recommandons https://github.com/Laion-ai/clip_benchmark#how-to-User pour l'évaluation systématique sur 40 ensembles de données.
python -m open_clip_train.main
--val-data= " /path/to/validation_data.csv "
--model RN101
--pretrained /path/to/checkpoints/epoch_K.ptpython -m open_clip_train.main
--imagenet-val /path/to/imagenet/validation
--model ViT-B-32-quickgelu
--pretrained laion400m_e32 Vous pouvez distiller à partir d'un pré-formé en utilisant --distill-model et --distill-pretrained pour spécifier le modèle à partir duquel vous souhaitez distiller. Par exemple, pour distiller à partir de l'Openai Vit-L / 14 Utiliser --distill-model ViT-L-14 --distill-pretrained openai .
Pour simuler des lots plus grands, utilisez --accum-freq k . Si la taille du lot de GPU, --batch-size est m , alors la taille efficace du lot sera k * m * num_gpus .
Lors de l'augmentation --accum-freq à partir de sa valeur par défaut de 1, les échantillons / s resteront approximativement constants (la taille du lot doublera, tout comme le temps par lots). Il est recommandé d'utiliser d'autres fonctionnalités pour réduire la taille des lots tels que --grad-checkpointing --local-loss --gather-with-grad avant d'augmenter --accum-freq . --accum-freq peut être utilisé en plus de ces fonctionnalités.
Au lieu de 1 pass avant par exemple, il y a maintenant 2 passes avant par exemple. Cependant, le premier se fait avec torch.no_grad .
Il y a une mémoire GPU supplémentaire requise --- Les fonctionnalités et les données de tous m lots sont stockées en mémoire.
Il y a aussi m calculs de perte au lieu du 1 habituel.
Pour plus d'informations, voir Cui et al. (https://arxiv.org/abs/2112.09331) ou Pham et al. (https://arxiv.org/abs/2111.10050).
Nous avons un soutien bêta pour la formation et l'inférence INT8. Vous pouvez activer la formation INT8 avec --use-bnb-linear SwitchBackLinearGlobal ou --use-bnb-linear SwitchBackLinearGlobalMemEfficient . Veuillez consulter la bibliothèque BitsandBytes pour les définitions de ces couches. Pour Clip Vit-Huge, cela devrait actuellement correspondre à une accélération de la formation de 10% sans perte de précision. Plus d'accélération arrive lorsque la couche d'attention est refactorisée afin que les couches linéaires soient également remplacées là-bas.
Voir le tutoriel https://github.com/mlfoundations/open_clip/blob/main/tutorials/int8_tutorial.ipynb ou papier.
Il est toujours possible de reprendre directement à partir d'un fichier distant, par exemple, un fichier dans un seau S3. Se définissez --resume s3://<path-to-checkpoint> . Cela fonctionnera avec tout système de fichiers pris en charge par fsspec .
Il est également possible de former des modèles open_clip tout en sauvegardant en continu jusqu'à S3. Cela peut aider à éviter les systèmes de fichiers locaux lents.
Dites que votre nœud a un SSD /scratch local, un seau S3 s3://<path-to-bucket> .
Dans ce cas, définissez --logs /scratch et --remote-sync s3://<path-to-bucket> . Ensuite, un processus d'arrière-plan synchronisera /scratch/<run-name> vers s3://<path-to-bucket>/<run-name> . Après la synchronisation, le processus d'arrière-plan dormira pendant des secondes --remote-sync-frequency , ce qui est par défaut à 5 minutes.
Il existe également une prise en charge expérimentale pour la synchronisation avec d'autres systèmes de fichiers distants, pas seulement S3. Pour ce faire, spécifiez --remote-sync-protocol fsspec . Cependant, cela est actuellement très lent et non recommandé.
En outre, pour éviter éventuellement d'économiser trop de points de contrôle localement lors de l'utilisation de ces fonctionnalités, vous pouvez utiliser --delete-previous-checkpoint qui supprime le point de contrôle précédent après en enregistrer un nouveau.
Remarque: Si vous utilisez cette fonctionnalité avec --resume latest , il y a quelques avertissements. Tout d'abord, l'utilisation avec --save-most-recent n'est pas prise en charge. Deuxièmement, seul s3 est pris en charge. Enfin, comme la synchronisation se produit en arrière-plan, il est possible que le point de contrôle le plus récent ne soit pas fini de synchronisation avec la télécommande.
Le module open_clip.push_to_hf_hub comprend des aides pour pousser les modèles / poids W et la configuration au centre HF.
L'outil peut être exécuté à partir de la ligne de commande, ex: python -m open_clip.push_to_hf_hub --model convnext_large_d_320 --pretrained /train/checkpoints/epoch_12.pt --repo-id laion/CLIP-convnext_large_d_320.laion2B-s29B-b131K-ft
Nous remercions le Gauss Center for Supercomputing EV (www.gauss-centre.eu) pour financer cette partie du travail en fournissant du temps de calcul via le John Von Neumann Institute for Computing (NIC) sur le GCS Supercomputer Juwels Booster au Jülich Supercomputing Center (JSC).
Le développement actuel de ce référentiel est dirigé par Ross Wightman, Romain Beaumont, Cade Gordon et Vaishaal Shankar.
La version originale de ce référentiel provient d'un groupe de chercheurs à UW, Google, Stanford, Amazon, Columbia et Berkeley.
Gabriel Ilharco *, Mitchell Wortsman *, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, John Miller, Hongseok Namkoong, Hannaneh Hajishirzi, Ali Farhadi, Ludwig Schmidt
Un merci spécial à Jong Wook Kim et Alec Radford pour l'aide à la reproduction du clip!
Si vous avez trouvé ce référentiel utile, veuillez envisager de citer:
@software { ilharco_gabriel_2021_5143773 ,
author = { Ilharco, Gabriel and
Wortsman, Mitchell and
Wightman, Ross and
Gordon, Cade and
Carlini, Nicholas and
Taori, Rohan and
Dave, Achal and
Shankar, Vaishaal and
Namkoong, Hongseok and
Miller, John and
Hajishirzi, Hannaneh and
Farhadi, Ali and
Schmidt, Ludwig } ,
title = { OpenCLIP } ,
month = jul,
year = 2021 ,
note = { If you use this software, please cite it as below. } ,
publisher = { Zenodo } ,
version = { 0.1 } ,
doi = { 10.5281/zenodo.5143773 } ,
url = { https://doi.org/10.5281/zenodo.5143773 }
} @inproceedings { cherti2023reproducible ,
title = { Reproducible scaling laws for contrastive language-image learning } ,
author = { Cherti, Mehdi and Beaumont, Romain and Wightman, Ross and Wortsman, Mitchell and Ilharco, Gabriel and Gordon, Cade and Schuhmann, Christoph and Schmidt, Ludwig and Jitsev, Jenia } ,
booktitle = { Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition } ,
pages = { 2818--2829 } ,
year = { 2023 }
} @inproceedings { Radford2021LearningTV ,
title = { Learning Transferable Visual Models From Natural Language Supervision } ,
author = { Alec Radford and Jong Wook Kim and Chris Hallacy and A. Ramesh and Gabriel Goh and Sandhini Agarwal and Girish Sastry and Amanda Askell and Pamela Mishkin and Jack Clark and Gretchen Krueger and Ilya Sutskever } ,
booktitle = { ICML } ,
year = { 2021 }
} @inproceedings { schuhmann2022laionb ,
title = { {LAION}-5B: An open large-scale dataset for training next generation image-text models } ,
author = { Christoph Schuhmann and
Romain Beaumont and
Richard Vencu and
Cade W Gordon and
Ross Wightman and
Mehdi Cherti and
Theo Coombes and
Aarush Katta and
Clayton Mullis and
Mitchell Wortsman and
Patrick Schramowski and
Srivatsa R Kundurthy and
Katherine Crowson and
Ludwig Schmidt and
Robert Kaczmarczyk and
Jenia Jitsev } ,
booktitle = { Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track } ,
year = { 2022 } ,
url = { https://openreview.net/forum?id=M3Y74vmsMcY }
}
