Página Inicial>Relacionado com a programação>Outro código-fonte
Baixar

? [2023-10-26] Adicionados backbones DINOv2 com registros, seguindo Vision Transformers Need Registers.

DINov2: aprendendo recursos visuais robustos sem supervisão

Pesquisa Meta AI, FAIR

Maxime Oquab, Timothée Darcet, Théo Moutakanni, Huy V. Vo, Marc Szafraniec, Vasil Khalidov, Patrick Labatut, Armand Joulin, Piotr Bojanowski

[ Paper #1 ] Paper #2 ] [ Blog ] [ Demo ] [ BibTeX ]

Implementação PyTorch e modelos pré-treinados para DINOv2. Para obter detalhes, consulte os artigos: DINOv2: Learning Robust Visual Features without Supervision and Vision Transformers Need Registers .

Os modelos DINOv2 produzem recursos visuais de alto desempenho que podem ser empregados diretamente com classificadores tão simples quanto camadas lineares em uma variedade de tarefas de visão computacional; esses recursos visuais são robustos e funcionam bem em todos os domínios, sem qualquer necessidade de ajuste fino. Os modelos foram pré-treinados em um conjunto de dados de 142 M imagens sem usar rótulos ou anotações.

referência de vídeo+dinov2.mp4
Visualização dos três primeiros componentes principais dos recursos de patch de todos os quadros, mapeados para valores RGB.

Modelos pré-treinados

modelo # de
parâmetros		 com
registros		 ImageNet
k-NN		 ImageNet
linear		 download
ViT-S/14 destilado 21 meses 79,0% 81,1% apenas espinha dorsal
ViT-S/14 destilado 21 meses ✅ 79,1% 80,9% apenas espinha dorsal
ViT-B/14 destilado 86 milhões 82,1% 84,5% apenas espinha dorsal
ViT-B/14 destilado 86 milhões ✅ 82,0% 84,6% apenas espinha dorsal
ViT-L/14 destilado 300 milhões 83,5% 86,3% apenas espinha dorsal
ViT-L/14 destilado 300 milhões ✅ 83,8% 86,7% apenas espinha dorsal
ViT-g/14 1.100 milhões 83,5% 86,5% apenas espinha dorsal
ViT-g/14 1.100 milhões ✅ 83,7% 87,1% apenas espinha dorsal

Backbones pré-treinados (via PyTorch Hub)

Siga as instruções aqui para instalar o PyTorch (a única dependência necessária para carregar o modelo). É altamente recomendável instalar o PyTorch com suporte CUDA.

Um cartão de modelo correspondente está incluído no repositório. 

 import torch

# DINOv2
dinov2_vits14 = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vits14' )
dinov2_vitb14 = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitb14' )
dinov2_vitl14 = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitl14' )
dinov2_vitg14 = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitg14' )

# DINOv2 with registers
dinov2_vits14_reg = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vits14_reg' )
dinov2_vitb14_reg = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitb14_reg' )
dinov2_vitl14_reg = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitl14_reg' )
dinov2_vitg14_reg = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitg14_reg' )

Cabeças pré-treinadas - Classificação de imagens

espinha dorsal com
registros		 download
ImageNet
ViT-S/14 destilado cabeça linear (1 camada, 4 camadas)
ViT-S/14 destilado ✅ cabeça linear (1 camada, 4 camadas)
ViT-B/14 destilado cabeça linear (1 camada, 4 camadas)
ViT-B/14 destilado ✅ cabeça linear (1 camada, 4 camadas)
ViT-L/14 destilado cabeça linear (1 camada, 4 camadas)
ViT-L/14 destilado ✅ cabeça linear (1 camada, 4 camadas)
ViT-g/14 cabeça linear (1 camada, 4 camadas)
ViT-g/14 ✅ cabeça linear (1 camada, 4 camadas)

Os modelos de classificador (completos) podem ser carregados via PyTorch Hub: 

 import torch

# DINOv2
dinov2_vits14_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vits14_lc' )
dinov2_vitb14_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitb14_lc' )
dinov2_vitl14_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitl14_lc' )
dinov2_vitg14_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitg14_lc' )

# DINOv2 with registers
dinov2_vits14_reg_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vits14_reg_lc' )
dinov2_vitb14_reg_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitb14_reg_lc' )
dinov2_vitl14_reg_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitl14_reg_lc' )
dinov2_vitg14_reg_lc = torch . hub . load ( 'facebookresearch/dinov2' , 'dinov2_vitg14_reg_lc' )

Cabeças pré-treinadas - estimativa de profundidade

espinha dorsal cabeça de download
NYUd KITTI
ViT-S/14 destilado linear (1 camada, 4 camadas), DPT linear (1 camada, 4 camadas), DPT
ViT-B/14 destilado linear (1 camada, 4 camadas), DPT linear (1 camada, 4 camadas), DPT
ViT-L/14 destilado linear (1 camada, 4 camadas), DPT linear (1 camada, 4 camadas), DPT
ViT-g/14 linear (1 camada, 4 camadas), DPT linear (1 camada, 4 camadas), DPT

Cabeças pré-treinadas – segmentação semântica

espinha dorsal baixar modelo cabeça de download
ADE20K ADE20K COV2012
ViT-S/14 destilado linear, multiescala linear, multiescala
ViT-B/14 destilado linear, multiescala linear, multiescala
ViT-L/14 destilado linear, multiescala linear, multiescala
ViT-g/14 Máscara2Former linear, multiescala linear, multiescala

Instalação

O código de treinamento e avaliação requer PyTorch 2.0 e xFormers 0.0.18, bem como vários outros pacotes de terceiros. Observe que o código foi testado apenas com as versões especificadas e também espera um ambiente Linux. Para configurar todas as dependências necessárias para treinamento e avaliação, siga as instruções abaixo:

conda (recomendado) - Clone o repositório e, em seguida, crie e ative um ambiente dinov2 conda usando a definição de ambiente fornecida: 

conda env create -f conda.yaml
conda activate dinov2

pip - Clone o repositório e use o requirements.txt fornecido para instalar as dependências: 

pip install -r requirements.txt

Para tarefas densas (estimativa de profundidade e segmentação semântica), existem dependências adicionais (versões específicas de mmcv e mmsegmentation ) que são capturadas nas especificações de dependência extras :

conda (recomendado) : 

conda env create -f conda-extras.yaml
conda activate dinov2-extras

pip : 

pip install -r requirements.txt -r requirements-extras.txt

Preparação de dados

ImageNet-1k

O diretório raiz do conjunto de dados deve conter o seguinte conteúdo:

  • <ROOT>/test/ILSVRC2012_test_00000001.JPEG
  • <ROOT>/test/[..]
  • <ROOT>/test/ILSVRC2012_test_00100000.JPEG
  • <ROOT>/train/n01440764/n01440764_10026.JPEG
  • <ROOT>/train/[...]
  • <ROOT>/train/n15075141/n15075141_9993.JPEG
  • <ROOT>/val/n01440764/ILSVRC2012_val_00000293.JPEG
  • <ROOT>/val/[...]
  • <ROOT>/val/n15075141/ILSVRC2012_val_00049174.JPEG
  • <ROOT>/labels.txt

A implementação do conjunto de dados fornecido espera que alguns arquivos de metadados adicionais estejam presentes no diretório extra:

  • <EXTRA>/class-ids-TRAIN.npy
  • <EXTRA>/class-ids-VAL.npy
  • <EXTRA>/class-names-TRAIN.npy
  • <EXTRA>/class-names-VAL.npy
  • <EXTRA>/entries-TEST.npy
  • <EXTRA>/entries-TRAIN.npy
  • <EXTRA>/entries-VAL.npy

Esses arquivos de metadados podem ser gerados (uma vez) com as seguintes linhas de código Python: 

 from dinov2 . data . datasets import ImageNet

for split in ImageNet . Split :
    dataset = ImageNet ( split = split , root = "<ROOT>" , extra = "<EXTRA>" )
    dataset . dump_extra ()

Observe que os diretórios raiz e extras não precisam ser diretórios distintos.

ImageNet-22k

Adapte a classe do conjunto de dados para corresponder à sua configuração local.


️ Para executar os comandos fornecidos nas próximas seções para treinamento e avaliação, o pacote dinov2 deve ser incluído no caminho de busca do módulo Python, ou seja, basta prefixar o comando para executar com PYTHONPATH=. .

Treinamento

Configuração rápida: treinando DINOv2 ViT-L/16 no ImageNet-1k

Execute o treinamento DINOv2 em 4 nós A100-80GB (32 GPUs) em um ambiente de cluster SLURM com submitit: 

python dinov2/run/train/train.py 
    --nodes 4 
    --config-file dinov2/configs/train/vitl16_short.yaml 
    --output-dir < PATH/TO/OUTPUT/DIR > 
    train.dataset_path=ImageNet:split=TRAIN:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

O tempo de treinamento é de aproximadamente 1 dia e o ponto de verificação resultante deve atingir 81,6% na avaliação k-NN e 82,9% na avaliação linear.

O código de treinamento salva os pesos do professor na pasta eval a cada 12.500 iterações para avaliação.

Configuração longa: treinando DINOv2 ViT-L/14 no ImageNet-22k

Execute o treinamento DINOv2 em 12 nós A100-80GB (96 GPUs) em um ambiente de cluster SLURM com submitit: 

python dinov2/run/train/train.py 
    --nodes 12 
    --config-file dinov2/configs/train/vitl14.yaml 
    --output-dir < PATH/TO/OUTPUT/DIR > 
    train.dataset_path=ImageNet22k:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

O tempo de treinamento é de aproximadamente 3,3 dias e o ponto de verificação resultante deve atingir 82,0% na avaliação k-NN e 84,5% na avaliação linear.

O código de treinamento salva os pesos do professor na pasta eval a cada 12.500 iterações para avaliação.

Avaliação

O código de treinamento salva regularmente os pesos do professor. Para avaliar o modelo, execute a seguinte avaliação em um único nó:

Classificação k-NN no ImageNet-1k 

python dinov2/run/eval/knn.py 
    --config-file < PATH/TO/OUTPUT/DIR > /config.yaml 
    --pretrained-weights < PATH/TO/OUTPUT/DIR > /eval/training_24999/teacher_checkpoint.pth 
    --output-dir < PATH/TO/OUTPUT/DIR > /eval/training_24999/knn 
    --train-dataset ImageNet:split=TRAIN:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET > 
    --val-dataset ImageNet:split=VAL:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

Classificação de regressão logística no ImageNet-1k 

python dinov2/run/eval/log_regression.py 
    --config-file < PATH/TO/OUTPUT/DIR > /config.yaml 
    --pretrained-weights < PATH/TO/OUTPUT/DIR > /eval/training_24999/teacher_checkpoint.pth 
    --output-dir < PATH/TO/OUTPUT/DIR > /eval/training_24999/logreg 
    --train-dataset ImageNet:split=TRAIN:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET > 
    --val-dataset ImageNet:split=VAL:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

Classificação linear com aumento de dados no ImageNet-1k 

python dinov2/run/eval/linear.py 
    --config-file < PATH/TO/OUTPUT/DIR > /config.yaml 
    --pretrained-weights < PATH/TO/OUTPUT/DIR > /eval/training_24999/teacher_checkpoint.pth 
    --output-dir < PATH/TO/OUTPUT/DIR > /eval/training_24999/linear 
    --train-dataset ImageNet:split=TRAIN:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET > 
    --val-dataset ImageNet:split=VAL:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

Liberamos os pesos da avaliação dos diferentes modelos:

modelo com
registros		 ImageNet
primeiro lugar		 avaliação linear
ViT-S/14 destilado 81,1% pesos de cabeça lineares
ViT-S/14 destilado ✅ 80,8% pesos de cabeça lineares
ViT-B/14 destilado 84,5% pesos de cabeça lineares
ViT-B/14 destilado ✅ 84,4% pesos de cabeça lineares
ViT-L/14 destilado 86,3% pesos de cabeça lineares
ViT-L/14 destilado ✅ 86,5% pesos de cabeça lineares
ViT-g/14 86,5% pesos de cabeça lineares
ViT-g/14 ✅ 87,0% pesos de cabeça lineares

O desempenho dos pesos do modelo pré-treinado fornecidos pode ser avaliado da seguinte forma no ImageNet-1k: 

python dinov2/run/eval/linear.py 
    --config-file dinov2/configs/eval/vitg14_pretrain.yaml 
    --pretrained-weights https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_pretrain.pth 
    --train-dataset ImageNet:split=TRAIN:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET > 
    --val-dataset ImageNet:split=VAL:root= < PATH/TO/DATASET > :extra= < PATH/TO/DATASET >

Cadernos

Alguns notebooks são fornecidos para ajudar a comunidade a aproveitar os modelos e o código:

  • Estimativa de profundidade - Como carregar e usar os cabeçotes de profundidade em combinação com um backbone correspondente via mmcv
  • Segmentação semântica - Como carregar e usar as cabeças de segmentação em combinação com um backbone correspondente via mmcv, e também como carregar e usar o modelo de segmentação baseado em Mask2Former treinado em ADE20K

Licença

O código DINOv2 e os pesos dos modelos são lançados sob a licença Apache 2.0. Consulte LICENÇA para obter detalhes adicionais.

Contribuindo

Veja contribuições e o código de conduta.

Citando DINOv2

Se você achar este repositório útil, considere dar uma estrela e uma citação?: 

 @misc{oquab2023dinov2,
  title={DINOv2: Learning Robust Visual Features without Supervision},
  author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy V. and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr},
  journal={arXiv:2304.07193},
  year={2023}
}

 @misc{darcet2023vitneedreg,
  title={Vision Transformers Need Registers},
  author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr},
  journal={arXiv:2309.16588},
  year={2023}
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos