open_clip
v2.29.0
[Paper] [Citações] [Clip Colab] [Coca -Colab]
Bem-vindo a uma implementação de código aberto do clipe do OpenAI (pré-treinamento contrastivo de imagem de linguagem).
Usando esta base de código, treinamos vários modelos em uma variedade de fontes de dados e orçamentos de computação, variando de experimentos em pequena escala a corridas maiores, incluindo modelos treinados em conjuntos de dados como Laion-400M, Laion-2b e Datacomp-1b. Muitos de nossos modelos e suas propriedades de escala são estudados em detalhes nas leis de escala reprodutível em papel para o aprendizado contrastante de imagem de linguagem. Alguns dos melhores modelos que treinamos e sua precisão de imagenet-1k zero são mostrados abaixo, juntamente com o modelo Vit-L treinado pelo OpenAI e outras alternativas de código aberto de última geração (todas podem ser carregadas via OpenClip). Fornecemos mais detalhes sobre a nossa coleção completa de modelos pré-tenhados aqui e resultados de tiro zero para 38 conjuntos de dados aqui.
| Modelo | Dados de treinamento | Resolução | # de amostras vistas | Imagenet zero 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 (clipe original) | Sagacidade | 224px | 13b | 75,5% |
| Vit-So400m/14 (Siglip) | Webbli | 224px | 45b | 82,0% |
| VIT-SO400M-14-SIGLIP-384 (Siglip) | Webbli | 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% |
Os cartões de modelo com detalhes específicos de modelo adicionais podem ser encontrados no hub de face Hugging sob a tag OpenClip Library: https://huggingface.co/models?library=open_clip.
Se você achou esse repositório útil, considere citar. Congratulamo -nos com qualquer um para enviar um problema ou enviar um email se você tiver outras solicitações ou sugestões.
Observe que partes do src/open_clip/ Modeling and Tokenizer Code são adaptações do repositório oficial do OpenAI.
| Crédito da imagem: 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.]]Veja também este [clipe colab].
Para calcular bilhões de incorporações com eficiência, você pode usar o clipe-reavalial, o que possui suporte ao OpenClip.
Oferecemos uma interface de modelo simples para instanciar modelos pré-treinados e não treinados. Para ver quais modelos pré -ridicularizados estão disponíveis, use o seguinte snippet de código. Mais detalhes sobre nossos modelos pré -treinados estão disponíveis aqui.
> >> import open_clip
> >> open_clip . list_pretrained ()Você pode encontrar mais sobre os modelos que suportamos (por exemplo, número de parâmetros, flops) nesta tabela.
NOTA: Muitos pontos de verificação existentes usam a ativação do Quickgelu dos modelos OpenAI originais. Essa ativação é realmente menos eficiente que a tocha nativa.nn.gelu em versões recentes de pytorch. Os padrões do modelo agora são NN.GELU, portanto, deve -se usar definições de modelo com -quickgelu Postfix para os pesos pré -tenhados OpenClip. Todos os pesos pré -gravados do OpenAI sempre são inadimplentes para o Quickgelu. Pode -se também usar as definições de modelo não -quickgelu com pesos pré -teriados usando o Quickgelu, mas haverá uma queda de precisão, para ajustar o tune que provavelmente desaparecerá para execuções mais longas. Futuros modelos treinados usarão nn.gelu.
Os modelos podem ser carregados com open_clip.create_model_and_transforms , conforme mostrado no exemplo abaixo. O nome do modelo e as teclas pretrained correspondentes são compatíveis com as saídas de open_clip.list_pretrained() .
O argumento pretrained também aceita caminhos locais, por exemplo /path/to/my/b32.pt to/my/b32.pt. Você também pode carregar pontos de verificação do Huggingface dessa maneira. Para fazer isso, faça o download do arquivo open_clip_pytorch_model.bin (por exemplo, https://huggingface.co/laion/clip-vit-l-l-14-datacomp.xl-s13b-b90k/tree/main) e 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 repositório está focado nos modelos de clipes de treinamento. Para ajustar um modelo de tiro zero treinado em uma tarefa de classificação a jusante, como o ImageNet, consulte nosso outro repositório: Wise-ft. O repositório Wise-FT contém código para o nosso artigo sobre o ajuste fino robusto de modelos de tiro zero, nos quais introduzimos uma técnica para modelos de tiro zero de ajuste fino, preservando a robustez sob a mudança de distribuição.
Para baixar os conjuntos de dados como WebDataset, recomendamos o img2dataSet.
Consulte o exemplo cc3m img2dataSet.
Além de especificar os dados de treinamento por meio de arquivos CSV, conforme mencionado acima, nossa base de código também suporta WebDataset, que é recomendada para conjuntos de dados de maior escala. O formato esperado é uma série de arquivos .tar . Cada um desses arquivos .tar deve conter dois arquivos para cada exemplo de treinamento, um para a imagem e outro para o texto correspondente. Ambos os arquivos devem ter o mesmo nome, mas extensões diferentes. Por exemplo, shard_001.tar pode conter arquivos como abc.jpg e abc.txt . Você pode aprender mais sobre webdataset em https://github.com/webdataset/webdataset. Utilizamos arquivos .tar com 1.000 pontos de dados cada, que criamos usando lona.
Você pode baixar o conjunto de dados YFCC do Multimedia Commons. Semelhante ao OpenAI, usamos um subconjunto de YFCC para atingir os números de precisão acima mencionados. Os índices de imagens neste subconjunto estão no repositório de clipes da OpenAI.
Aconselhamos que você crie um ambiente virtual com:
python3 -m venv .env
source .env/bin/activate
pip install -U pip
Em seguida, você pode instalar o OpenClip para treinamento com pip install 'open_clip_torch[training]' .
Se você deseja fazer alterações para contribuir com o código, poderá clonar o OpenClip e executar make install na pasta OpenClip (depois de criar um Virtualenv)
Instale o Pip Pytorch conforme https://pytorch.org/get-started/locally/
Você pode executar make install-training para Instalar deceps de Treinamento
O teste pode ser executado com make install-test e make test
python -m pytest -x -s -v tests -k "training" para executar um teste específico
Testes de regressão em execução contra uma revisão ou tag Git específico:
Gerar dados de teste
python tests/util_test.py --model RN50 RN101 --save_model_list models.txt --git_revision 9d31b2ec4df6d8228f370ff20c8267ec6ba39383 Aviso : isso invocará o GIT e modificará sua árvore de trabalho, mas a redefinirá para o estado atual após a geração de dados!
Não modifique sua árvore de trabalho enquanto os dados de teste estão sendo gerados dessa maneira.
Execute testes de regressão
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 é o caminho para o conjunto de validação do ImageNet para avaliação de tiro zero, não o conjunto de treinamento! Você pode remover esse argumento se não quiser executar uma avaliação zero no ImageNet durante todo o treinamento. Observe que a pasta val deve conter subpastas. Caso contrário, use este script.
Este código foi testado em batalha até 1024 A100s e oferece uma variedade de soluções para treinamento distribuído. Incluímos suporte nativo para aglomerados de Slurm.
À medida que o número de dispositivos usados para treinar aumenta, o mesmo ocorre com a complexidade espacial da matriz de logit. Usando um esquema ingênuo de todos os colegas, a complexidade espacial será O(n^2) . Em vez disso, a complexidade pode se tornar efetivamente linear se as bandeiras --gather-with-grad e --local-loss forem usadas. Essa alteração resulta em resultados numéricos individuais como o método ingênuo.
Para conjuntos de dados maiores (por exemplo, Laion2b), recomendamos a configuração --train-num-samples em um valor mais baixo do que a época completa, por exemplo --train-num-samples 135646078 a 1/16 de uma época em conjunto com --dataset-resampled para fazer amostragem com substituição. Isso permite ter pontos de verificação frequentes para avaliar com mais frequência.
Pesquisas recentes mostraram que se pode abandonar metade para três quartos dos tokens visuais, levando a velocidades de treinamento de até 2-3x sem perda de precisão.
Você pode definir isso na sua configuração de transformador visual com a chave patch_dropout .
No jornal, eles também fãs sem o abandono do patch no final. Você pode fazer isso com o argumento da linha de comando --force-patch-dropout 0.
OpenClip suporta o uso de várias fontes de dados, separando diferentes caminhos de dados com :: . Por exemplo, para treinar no CC12M e no Laion, pode-se usar --train-data "/data/cc12m/cc12m-train-{0000..2175}.tar::/data/LAION-400M/{00000..41455}.tar" . O uso --dataset-resampled é recomendado para esses casos.
Por padrão, na expectativa, a quantidade de vezes que o modelo verá uma amostra de cada fonte é proporcional ao tamanho da fonte. Por exemplo, ao treinar em uma fonte de dados com tamanho de 400m e um com tamanho 10m, as amostras da primeira fonte têm 40x mais chances de serem vistas em expectativa.
Também suportamos diferentes ponderação das fontes de dados, usando o sinalizador --train-data-upsampling-factors . Por exemplo, o uso --train-data-upsampling-factors=1::1 no cenário acima é equivalente a não usar o sinalizador e --train-data-upsampling-factors=1::2 é equivalente a despertar a segunda fonte de dados duas vezes. Se você deseja amostrar de fontes de dados com a mesma frequência, os fatores de amostragem devem ser inversamente proporcionais aos tamanhos das fontes de dados. Por exemplo, se o conjunto de dados A tiver 1000 amostras e o conjunto de dados B tiver 100 amostras, você poderá usar --train-data-upsampling-factors=0.001::0.01 (ou analogamente, --train-data-upsampling-factors=1::10 ).
Fazemos uso de torchrun para lançar trabalhos distribuídos. A seguir, lança um emprego em um nó de 4 GPUs:
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/O mesmo script acima funciona, desde que os usuários incluam informações sobre o número de nós e o nó do 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 é provavelmente a solução mais fácil de utilizar. O script a seguir foi usado para treinar nossos maiores modelos:
#! /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 O treinamento de modelos Coca é ativado pela especificação de uma configuração da Coca usando o parâmetro --model do script de treinamento. As configurações atualmente disponíveis são "coca_base", "coca_vit-b-32" e "coca_roberta-vit-b-32" (que usa Roberta como codificador de texto). As configurações da Coca são diferentes das configurações de clipe, porque possuem um componente "multimodal_cfg" adicional que especifica parâmetros para o decodificador de texto multimodal. Aqui está um exemplo da configuração 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 aos Lucidrains pelo código inicial, GPUCCE por adaptar o código ao Open_Clip e IEJMAC para treinar os 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>" , "" ))Veja também este [Coca -Colab]
Para ajustar a coca no MSCOCO, primeiro crie o conjunto de dados, o One Way é usar um CSVDataset e talvez a maneira mais simples de fazê-lo seja usar o CLIP_BENCHMARK que, por sua vez, usa pycocotools (que também pode ser usado por si só).
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 "
)Isso deve criar um conjunto de dados CSV que se possa usar para ajustar a coca com o 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 é uma configuração geral, o Open_Clip possui parâmetros muito que podem ser definidos, python -m open_clip_train.main --help deve mostrá -los. A única mudança relevante em comparação com o pré-treinamento são os dois argumentos
--coca-contrastive-loss-weight 0
--coca-caption-loss-weight 1que fazem o modelo treinar apenas o lado generativo.
Se você deseja usar diferentes modelos de idiomas como codificador de texto para clipe, pode fazê-lo usando uma das configurações do Hugging Face Model em src/open_clip/model_configs e passando o tokenizer como os parâmetros --model e --hf-tokenizer-name respectivamente. Atualmente, apoiamos apenas a configuração Roberta ("Test-Roberta"), no entanto, adicionar novos modelos deve ser trivial. Você também pode determinar quantas camadas, a partir do final, para deixar o descongelamento com o parâmetro --lock-text-unlocked-layers . Aqui está um comando de exemplo para treinar clipe com o Roberta LM que tem suas últimas 10 camadas descongeladas:
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 " Quando executado em uma máquina com 8 GPUs, o comando deve produzir a seguinte curva de treinamento para legendas conceituais:
Curvas mais detalhadas para legendas conceituais são fornecidas em /docs/clip_conceptual_captions.md.
Ao treinar um RN50 no YFCC, os mesmos hiperparâmetros acima são usados, com exceção de lr=5e-4 e epochs=32 .
Observe que, para usar outro modelo, como ViT-B/32 ou RN50x4 ou RN50x16 ou ViT-B/16 , especifique com --model RN50x4 .
Para registro de tensorboard, execute:
tensorboard --logdir=logs/tensorboard/ --port=7777 Para o log do Wandb, recomendamos analisar a variável step em vez de Step , pois o posterior não foi definido corretamente nas versões anteriores desta base de código. Para execuções mais antigas com modelos treinados antes do #613, a variável Step deve ser ignorada. Para execuções mais recentes, após esse PR, as duas variáveis são as mesmas.
Recomendamos https://github.com/laion-ai/clip_benchmark#how-to-use para avaliação sistemática em 40 conjuntos de dados.
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 Você pode destilar de um pré-treinado usando --distill-model e --distill-pretrained para especificar o modelo do qual gostaria de destilar. Por exemplo, destilar do OpenAI Vit-L/14 Uso --distill-model ViT-L-14 --distill-pretrained openai .
Para simular lotes maiores, use --accum-freq k . Se por tamanho de lote de GPU, --batch-size for m , o tamanho efetivo do lote será k * m * num_gpus .
Ao aumentar --accum-freq do seu padrão de 1, as amostras/s permanecerão aproximadamente constantes (o tamanho do lote dobrará, assim como o tempo por lote). Recomenda-se usar outros recursos para reduzir o tamanho do lote, como --grad-checkpointing --local-loss --gather-with-grad antes de aumentar --accum-freq . --accum-freq pode ser usado além desses recursos.
Em vez de 1 passe para a frente por exemplo, agora existem 2 passes para a frente por exemplo. No entanto, o primeiro é feito com torch.no_grad .
São necessárias alguma memória adicional da GPU-os recursos e dados de todos os lotes m são armazenados na memória.
Existem também m cálculos de perda em vez do habitual 1.
Para mais informações, consulte Cui et al. (https://arxiv.org/abs/2112.09331) ou Pham et al. (https://arxiv.org/abs/2111.10050).
Temos apoio beta para treinamento e inferência INT8. Você pode ativar o treinamento INT8 com --use-bnb-linear SwitchBackLinearGlobal --use-bnb-linear SwitchBackLinearGlobalMemEfficient . Consulte a biblioteca BitsandBytes para obter definições para essas camadas. Para o clipe Vit-huge, isso deve corresponder atualmente a uma aceleração de treinamento de 10%, sem perda de precisão. Mais acelerações vocam quando a camada de atenção é refatorada para que as camadas lineares também sejam substituídas lá.
Consulte o tutorial https://github.com/mlfoundations/open_clip/blob/main/tutorials/int8_tutorial.ipynb ou papel.
É sempre possível retomar diretamente de um arquivo remoto, por exemplo, um arquivo em um balde S3. Basta definir --resume s3://<path-to-checkpoint> . Isso funcionará com qualquer sistema de arquivos suportado pelo fsspec .
Também é possível treinar modelos open_clip enquanto faz o backup continuamente do S3. Isso pode ajudar a evitar sistemas de arquivos locais lentos.
Diga que seu nó possui um SSD /scratch local, um S3 Bucket s3://<path-to-bucket> .
Nesse caso, defina --logs /scratch e --remote-sync s3://<path-to-bucket> . Em seguida, um processo em segundo plano será sincronizado /scratch/<run-name> para s3://<path-to-bucket>/<run-name> . Após a sincronização, o processo em segundo plano dormirá por segundos --remote-sync-frequency , que padrão são 5 minutos.
Há também suporte experimental para sincronizar com outros sistemas de arquivos remotos, não apenas S3. Para fazer isso, especifique --remote-sync-protocol fsspec . No entanto, isso atualmente é muito lento e não recomendado.
Além disso, para evitar, opcionalmente, economizar muitos pontos de verificação localmente ao usar esses recursos, você pode usar --delete-previous-checkpoint , que exclui o ponto de verificação anterior depois de salvar um novo.
NOTA: Se você estiver usando esse recurso com --resume latest , existem alguns avisos. Primeiro, use com --save-most-recent não é suportado. Segundo, apenas s3 é suportado. Finalmente, como a sincronização acontece em segundo plano, é possível que o ponto de verificação mais recente não tenha terminado de sincronizar com o controle remoto.
O módulo open_clip.push_to_hf_hub inclui ajudantes para empurrar modelos /w pesos e configuração para o hub HF.
A ferramenta pode ser executada na linha 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
Reconhecemos com gratidão o Gauss Center for Supercomputing EV (www.gauss-centre.eu) por financiar essa parte do trabalho, fornecendo tempo de computação através do Instituto de Computação de John Von Neumann para computação (NIC) no Supercomputer GCS Juwels Booster no Jülich Supercomputing Center (JSC).
O desenvolvimento atual deste repositório é liderado por Ross Wightman, Romain Beaumont, Cade Gordon e Vaishaal Shankar.
A versão original deste repositório é de um grupo de pesquisadores da UW, Google, Stanford, Amazon, Columbia e Berkeley.
GABRIEL ILHARCO*, Mitchell Wortsman*, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, John Miller, Hongseok Namkoong, Hannaneh Hajishirzi, Ali Farhadi, Ludwig Schmidt
Agradecimentos especiais a Jong Wook Kim e Alec Radford pela ajuda na reprodução do clipe!
Se você achou esse repositório útil, 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 }
}
