open_clip
v2.29.0
[Documento] [Citas] [Clip Colab] [Coca Colab]
Bienvenido a una implementación de código abierto del clip de OpenAI (pre-entrenamiento de imagen de lenguaje contrastante).
Usando esta base de código, hemos entrenado varios modelos en una variedad de fuentes de datos y presupuestos de calculación, que van desde experimentos a pequeña escala hasta ejecuciones más grandes, incluidos modelos entrenados en conjuntos de datos como LAION-400M, LAION-2B y DataComp-1B. Muchos de nuestros modelos y sus propiedades de escala se estudian en detalle en las leyes de escala reproducibles en papel para el aprendizaje de imagen de lenguaje contrastante. A continuación, algunos de los mejores modelos que hemos entrenado y su precisión de ImageNet-1k de disparo cero se muestran a continuación, junto con el modelo VIT-L entrenado por OpenAI y otras alternativas de código abierto de última generación (todas se pueden cargar a través de OpenClip). Proporcionamos más detalles sobre nuestra colección completa de modelos previos a la aparición aquí y resultados de cero disparos para 38 conjuntos de datos aquí.
| Modelo | Datos de capacitación | Resolución | # de muestras vistas | Imagenet cero-shot acc. |
|---|---|---|---|---|
| Convnext-base | Laion-2B | 256px | 13B | 71.5% |
| Convnext-Large | 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 original) | INGENIO | 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% |
Las tarjetas modelo con detalles específicos adicionales del modelo se pueden encontrar en el centro de la cara abrazada debajo de la etiqueta de la biblioteca OpenClip: https://huggingface.co/models?library=open_clip.
Si encontró útil este repositorio, considere citar. Agradecemos a cualquiera que envíe un problema o envíe un correo electrónico si tiene alguna otra solicitud o sugerencia.
Tenga en cuenta que las partes de src/open_clip/ Modeling y el código de tokenizer son adaptaciones del repositorio oficial de OpenAI.
| Crédito de la imagen: 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.]]Ver también este [clip colab].
Para calcular miles de millones de incrustaciones de manera eficiente, puede usar Clip-Retrieval que tiene soporte OpenClip.
Ofrecemos una interfaz de modelo simple para instanciar modelos pre-capacitados y no entrenados. Para ver qué modelos previos al estado están disponibles, use el siguiente fragmento de código. Aquí hay más detalles sobre nuestros modelos previos a los productos previos.
> >> import open_clip
> >> open_clip . list_pretrained ()Puede encontrar más sobre los modelos que admitimos (por ejemplo, número de parámetros, flops) en esta tabla.
Nota: Muchos puntos de control existentes usan la activación de QuickGelu de los modelos originales de Operai. Esta activación es en realidad menos eficiente que la antorcha nativa.nn.gelu en versiones recientes de Pytorch. Los valores predeterminados del modelo ahora son nn.gelu, por lo que uno debe usar definiciones del modelo con -quickgelu Postfix para los pesos de pretrada OpenClip. Todos los pesos previos al estado de OpenAI siempre serán predeterminados a QuickGelu. También se puede usar las definiciones del modelo que no sean -quickgelu con pesos previos al estado de la aparición utilizando QuickGelu, pero habrá una caída de precisión, para el ajuste fino que probablemente desaparecerá para carreras más largas. Los modelos futuros capacitados utilizarán nn.gelu.
Los modelos se pueden cargar con open_clip.create_model_and_transforms , como se muestra en el ejemplo a continuación. El nombre del modelo y las claves pretrained correspondientes son compatibles con las salidas de open_clip.list_pretrained() .
El argumento pretrained también acepta rutas locales, por ejemplo /path/to/my/b32.pt . También puede cargar puntos de control desde Huggingface de esta manera. Para hacerlo, descargue el archivo open_clip_pytorch_model.bin (por ejemplo, https://huggingface.co/laion/clip-vit-l-14-datacomp.xl-s13b-b90k/tree/main), y use 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' ) Este repositorio se centra en los modelos de clip de entrenamiento. Para ajustar un modelo de disparo cero entrenado en una tarea de clasificación aguas abajo como ImageNet, consulte nuestro otro repositorio: Wise-Ft. El repositorio de Wise-Ft contiene código para nuestro artículo sobre el ajuste fino robusto de modelos de disparo cero, en el que presentamos una técnica para ajustar los modelos de disparo cero mientras preservamos la robustez en el cambio de distribución.
Para descargar conjuntos de datos como WebDataSet, recomendamos IMG2Dataset.
Ver CC3M IMG2Dataset Ejemplo.
Además de especificar los datos de capacitación a través de archivos CSV como se mencionó anteriormente, nuestra base de código también admite WebDataSet, que se recomienda para conjuntos de datos a mayor escala. El formato esperado es una serie de archivos .tar . Cada uno de estos archivos .tar debe contener dos archivos para cada ejemplo de capacitación, uno para la imagen y otro para el texto correspondiente. Ambos archivos deben tener el mismo nombre pero diferentes extensiones. Por ejemplo, shard_001.tar podría contener archivos como abc.jpg y abc.txt . Puede obtener más información sobre webdataset en https://github.com/webdataset/webdataset. Utilizamos archivos .tar con 1,000 puntos de datos cada uno, que creamos usando TARP.
Puede descargar el conjunto de datos YFCC de Multimedia Commons. Similar a OpenAI, utilizamos un subconjunto de YFCC para alcanzar los números de precisión mencionados anteriormente. Los índices de imágenes en este subconjunto están en el repositorio de clips de Openai.
Le recomendamos que primero cree un entorno virtual con:
python3 -m venv .env
source .env/bin/activate
pip install -U pip
Luego puede instalar OpenClip para entrenar con pip install 'open_clip_torch[training]' .
Si desea realizar cambios para contribuir con código, puede clonar OpenClip y luego ejecutar make install en la carpeta OpenClip (después de crear un VirtualEnv)
Instale Pip Pytorch según https://pytorch.org/get-started/locally/
Puede ejecutar make install-training para instalar Deps de entrenamiento
La prueba se puede ejecutar con make install-test y luego make test
python -m pytest -x -s -v tests -k "training" para ejecutar una prueba específica
Ejecutando pruebas de regresión contra una revisión o etiqueta de GIT específica:
Generar datos de prueba
python tests/util_test.py --model RN50 RN101 --save_model_list models.txt --git_revision 9d31b2ec4df6d8228f370ff20c8267ec6ba39383 ADVERTENCIA : Esto invocará Git y modificará su árbol de trabajo, ¡pero lo restablecerá al estado actual después de que se hayan generado datos!
No modifique su árbol de trabajo mientras se generan datos de prueba de esta manera.
Ejecutar pruebas de regresión
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 Nota: imagenet-val es la ruta al conjunto de validación de Imagenet para la evaluación de disparos cero, ¡no el conjunto de entrenamiento! Puede eliminar este argumento si no desea realizar una evaluación de disparo cero en Imagenet durante el entrenamiento. Tenga en cuenta que la carpeta val debe contener subcarpetas. Si no es así, use este script.
Este código ha sido probado en batalla hasta 1024 A100 y ofrece una variedad de soluciones para capacitación distribuida. Incluimos apoyo nativo para los grupos de slurm.
A medida que aumenta el número de dispositivos utilizados para entrenar, también lo hace la complejidad espacial de la matriz logit. Usando un esquema ingenuo totalmente-recolector, la complejidad espacial será O(n^2) . En cambio, la complejidad puede volverse efectivamente lineal si se usan las banderas --gather-with-grad y --local-loss . Esta alteración da como resultado resultados numéricos uno a uno como el método ingenuo.
Para conjuntos de datos más grandes (por ejemplo, laion2b), recomendamos la configuración: --train-num-samples a un valor más bajo que la época completa, por ejemplo --train-num-samples 135646078 a 1/16 de una época en conjunto con --dataset-resampled a do muestras con reemplazo. Esto permite tener puntos de control frecuentes para evaluar con más frecuencia.
Investigaciones recientes han demostrado que uno puede abandonar la mitad a las tres cuartas partes de las fichas visuales, lo que lleva a velocidades de entrenamiento hasta 2-3X sin pérdida de precisión.
Puede configurar esto en su configuración de transformador visual con la tecla patch_dropout .
En el documento, también se centraron sin el abandono del parche al final. Puede hacer esto con el argumento de la línea de comandos --force-patch-dropout 0.
OPENCLIP admite el uso de múltiples fuentes de datos, separando diferentes rutas de datos con :: . Por ejemplo, para entrenar en CC12M y en Laion, uno podría usar --train-data "/data/cc12m/cc12m-train-{0000..2175}.tar::/data/LAION-400M/{00000..41455}.tar" . El uso de --dataset-resampled se recomienda para estos casos.
Por defecto, con la expectativa de la cantidad de veces que el modelo verá que una muestra de cada fuente es proporcional al tamaño de la fuente. Por ejemplo, cuando el entrenamiento en una fuente de datos con tamaño de 400 m y uno con tamaño de 10m, las muestras de la primera fuente tienen 40 veces más probabilidades de verse en expectativa.
También admitimos diferentes ponderaciones de las fuentes de datos, mediante el uso del indicador --train-data-upsampling-factors . Por ejemplo, el uso --train-data-upsampling-factors=1::1 En el escenario anterior es equivalente a no usar el indicador, y --train-data-upsampling-factors=1::2 es equivalente a elevar la segunda fuente de datos dos veces. Si desea probar de fuentes de datos con la misma frecuencia, los factores de muestreo ascendente deben ser inversamente proporcionales a los tamaños de las fuentes de datos. Por ejemplo, si el conjunto de datos A tiene 1000 muestras y el conjunto de datos B tiene 100 muestras, puede usar --train-data-upsampling-factors=0.001::0.01 (o análogos, --train-data-upsampling-factors=1::10 ).
Hacemos uso de torchrun para lanzar trabajos distribuidos. Lo siguiente lanza un trabajo en un nodo 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/El mismo script anterior funciona, siempre que los usuarios incluyan información sobre el número de nodos y el nodo host.
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/Esta es probablemente la solución más fácil para utilizar. El siguiente guión se utilizó para entrenar nuestros modelos más grandes:
#! /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 Training Coca Models se habilita especificando una configuración de coca utilizando el parámetro --model del script de entrenamiento. Las configuraciones actualmente disponibles son "Coca_Base", "Coca_vit-B-32" y "Coca_Roberta-Vit-B-32" (que usa Roberta como el codificador de texto). Las configuraciones de coca son diferentes de las configuraciones de clip porque tienen un componente adicional "multimodal_cfg" que especifica los parámetros para el decodificador de texto multimodal. Aquí hay un ejemplo de la configuración 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édito a Lucidrains por el código inicial, GPUCCE para adaptar el código a Open_clip e IEJMAC para capacitar a los modelos.
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>" , "" ))Ver también este [Coca Colab]
Para ajustar la coca en MSCOCO, primero cree el conjunto de datos, una forma es usar una csvdataSet y quizás la forma más simple de hacerlo es usar clip_benchmark que a su vez usa pycocotools (que también se puede usar por sí solo).
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 "
)Esto debería crear un conjunto de datos CSV que uno pueda usar para ajustar la coca con 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 Esta es una configuración general, Open_clip tiene muy parámetros que se pueden establecer, python -m open_clip_train.main --help debería mostrarlos. El único cambio relevante en comparación con la capacitación previa son los dos argumentos.
--coca-contrastive-loss-weight 0
--coca-caption-loss-weight 1que hacen que el modelo solo entrene el lado generativo.
Si desea utilizar diferentes modelos de lenguaje como el codificador de texto para el clip, puede hacerlo utilizando una de las configuraciones del modelo de cara de abrazo en src/open_clip/model_configs y pasando su tokenizer como los parámetros --model y --hf-tokenizer-name respectivamente. Actualmente solo admitimos Roberta ("Test-Roberta"), sin embargo, agregar nuevos modelos debe ser trivial. También puede determinar cuántas capas, desde el final, para dejar no congelar con el parámetro --lock-text-unlocked-layers . Aquí hay un comando de ejemplo para entrenar el clip con el Roberta LM que tiene sus últimas 10 capas que no están congeladas:
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 " Cuando se ejecuta en una máquina con 8 GPU, el comando debe producir la siguiente curva de entrenamiento para subtítulos:
Se dan curvas más detalladas para subtítulos conceptuales en /docs/clip_conceptual_captions.md.
Al entrenar un RN50 en YFCC, se utilizan los mismos hiperparámetros que anteriormente, con la excepción de lr=5e-4 y epochs=32 .
Tenga en cuenta que para usar otro modelo, como ViT-B/32 o RN50x4 o RN50x16 o ViT-B/16 , especifique con --model RN50x4 .
Para el registro de TensorBoard, ejecute:
tensorboard --logdir=logs/tensorboard/ --port=7777 Para el registro de WANDB, recomendamos ver la variable step en lugar de Step , ya que el posterior no se estableció correctamente en versiones anteriores de esta base de código. Para las ejecuciones más antiguas con modelos entrenados antes del #613, la variable Step debe ignorarse. Para carreras más nuevas, después de eso, las dos variables son las mismas.
Recomendamos https://github.com/laion-ai/clip_benchmark#how-to-use para una evaluación sistemática en 40 conjuntos de datos.
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 Puede destilar de una capacitación previa utilizando --distill-model y --distill-pretrained para especificar el modelo del que desea destilar. Por ejemplo, para destilar de Operai VIT-L/14 USE --distill-model ViT-L-14 --distill-pretrained openai .
Para simular el uso de lotes más grandes --accum-freq k . Si el tamaño de lote de GPU, --batch-size por lotes, es m , entonces el tamaño de lote efectivo será k * m * num_gpus .
Al aumentar --accum-freq desde su valor predeterminado de 1, las muestras/s permanecerán aproximadamente constantes (el tamaño del lote se duplicará, al igual que el tiempo por lote). Se recomienda utilizar otras características para reducir el tamaño de lotes, como --grad-checkpointing --local-loss --gather-with-grad antes de aumentar --accum-freq . --accum-freq se puede usar además de estas características.
En lugar de 1 pase hacia adelante por ejemplo, ahora hay 2 pases hacia adelante por ejemplo. Sin embargo, el primero se realiza con torch.no_grad .
Se requiere algo de memoria de GPU adicional: las características y datos de todos los lotes m se almacenan en la memoria.
También hay m cálculos de pérdida en lugar de los habituales 1.
Para más información, consulte Cui et al. (https://arxiv.org/abs/2112.09331) o Pham et al. (https://arxiv.org/abs/2111.10050).
Tenemos apoyo beta para la capacitación e inferencia de INT8. Puede habilitar el entrenamiento INT8 con --use-bnb-linear SwitchBackLinearGlobal o --use-bnb-linear SwitchBackLinearGlobalMemEfficient . Consulte la biblioteca Bitsandbytes para obtener definiciones para estas capas. Para el clip vit-huge, esto debería corresponder actualmente a una aceleración de entrenamiento del 10% sin pérdida de precisión. Más aceleraciones recurren cuando la capa de atención se refactora para que las capas lineales se reemplacen allí también.
Vea el tutorial https://github.com/mlfoundations/open_clip/blob/main/tutorials/int8_tutorial.ipynb o papel.
Siempre es posible reanudar directamente desde un archivo remoto, por ejemplo, un archivo en un cubo S3. Simplemente establezca --resume s3://<path-to-checkpoint> . Esto funcionará con cualquier sistema de archivos admitido por fsspec .
También es posible entrenar modelos open_clip mientras retrocede continuamente hasta S3. Esto puede ayudar a evitar sistemas de archivos locales lentos.
Digamos que su nodo tiene un SSD /scratch local, un cubo S3 s3://<path-to-bucket> .
En ese caso, establezca --logs /scratch y --remote-sync s3://<path-to-bucket> . Luego, un proceso de fondo sincronizará /scratch/<run-name> a s3://<path-to-bucket>/<run-name> . Después de la sincronización, el proceso de fondo dormirá para --remote-sync-frequency segundos, que predeterminan a 5 minutos.
También hay soporte experimental para sincronizar a otros sistemas de archivos remotos, no solo S3. Para hacerlo, especifique --remote-sync-protocol fsspec . Sin embargo, esto es actualmente muy lento y no se recomienda.
Además, para evitar opcionalmente guardar demasiados puntos de control localmente cuando usa estas funciones, puede usar --delete-previous-checkpoint que elimina el punto de control anterior después de guardar una nueva.
Nota: Si está utilizando esta función con --resume latest , hay algunas advertencias. Primero, el uso con --save-most-recent no es compatible. En segundo lugar, solo s3 es compatible. Finalmente, dado que la sincronización ocurre en segundo plano, es posible que el punto de control más reciente no termine de sincronizar al control remoto.
El módulo open_clip.push_to_hf_hub incluye ayudantes para presionar modelos /W pesos y configurar en el HF Hub.
La herramienta se puede ejecutar desde la línea de comando, 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
Agradecemos que el Centro Gauss para la Supercomputación EV (www.gauss-centre.eu) por financiar esta parte del trabajo al proporcionar tiempo de computación a través del Instituto John Von Neumann para la Computación (NIC) en el GCS SuperComputer Juwels Booster en Jülich SuperComputing Center (JSC).
El desarrollo actual de este repositorio está dirigido por Ross Wightman, Romain Beaumont, Cade Gordon y Vaishaal Shankar.
La versión original de este repositorio es de un grupo de investigadores en UW, Google, Stanford, Amazon, Columbia y Berkeley.
Gabriel Ilharco*, Mitchell Wortsman*, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, John Miller, Hongseok Namkoong, Hannaneh Hajishirzi, Ali Farhadi, Ludwig Schmidt
¡Un agradecimiento especial a Jong Wook Kim y Alec Radford por ayuda con la reproducción de clip!
Si encontró útil este repositorio, considere citar:
@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 }
}
