open metric learning
OML 3.1.0
A OML é uma estrutura baseada em Pytorch para treinar e validar os modelos que produzem incorporações de alta qualidade.
ㅤㅤ
Há várias pessoas das universidades de Oxford e HSE que usaram a OML em suas teses. [1] [2] [3]
A atualização se concentra em vários componentes:
Adicionamos o suporte de textos "oficiais" e os exemplos de Python correspondentes. (Observe que o suporte de textos em pipelines ainda não foi suportado.)
Introduzimos a classe RetrievalResults ( RR ) - um contêiner para armazenar itens da galeria recuperados para determinadas consultas. RR fornece uma maneira unificada de visualizar previsões e calcular métricas (se as verdades fundamentais forem conhecidas). Ele também simplifica o pós-processamento, onde um objeto RR é tomado como entrada e outro RR_upd é produzido como saída. Ter esses dois objetos permite os resultados da recuperação de comparação visualmente ou por métricas. Além disso, você pode criar facilmente uma cadeia desses pós-processadores.
RR é a memória otimizado por causa do uso de lote: em outras palavras, não armazena a matriz completa de distâncias de galeria de consulta. (Mas não torna a pesquisa aproximada). Fizemos Model e Dataset as únicas classes responsáveis pelo processamento da lógica específica da modalidade. Model é responsável por interpretar suas dimensões de entrada: por exemplo, BxCxHxW para imagens ou BxLxD para seqüências como textos. Dataset é responsável por preparar um item: ele pode usar Transforms para imagens ou Tokenizer para textos. Funções de computação de métricas como calc_retrieval_metrics_rr , RetrievalResults , PairwiseReranker e outras classes e funções são unificadas para trabalhar com qualquer modalidade.
IVisualizableDataset com método .visaulize() que mostra um único item. Se implementado, RetrievalResults é capaz de mostrar o layout dos resultados recuperados. A maneira mais fácil de acompanhar as mudanças é reler os exemplos!
A maneira recomendada de validação é usar RetrievalResults e funções como calc_retrieval_metrics_rr , calc_fnmr_at_fmr_rr e outros. A aula EmbeddingMetrics é mantida para uso com Pytorch Lightning e Inside Pipelines. Observe que as assinaturas dos métodos EmbeddingMetrics foram ligeiramente alteradas, consulte exemplos de raios para isso.
Como a lógica específica da modalidade é confinada ao Dataset , ele não produz mais PATHS_KEY , X1_KEY , X2_KEY , Y1_KEY e Y2_KEY . As chaves que não são específicas da modalidade, como LABELS_KEY , IS_GALLERY , IS_QUERY_KEY , CATEGORIES_KEY ainda estão em uso.
inference_on_images agora é inference e trabalha com qualquer modalidade.
Interfaces ligeiramente alteradas dos Datasets. Por exemplo, temos interfaces IQueryGalleryDataset e IQueryGalleryLabeledDataset . O primeiro deve ser usado para inferência, o segundo para validação. Também adicionou a interface IVisualizableDataset .
Removeu alguns internos como IMetricDDP , EmbeddingMetricsDDP , calc_distance_matrix , calc_gt_mask , calc_mask_to_ignore , apply_mask_to_ignore . Essas mudanças não devem afetar você. Também removeu o código relacionado a um pipeline com trigêmeos pré -computados.
Extração do recurso: sem alterações, exceto por adicionar um argumento opcional - mode_for_checkpointing = (min | max) . Pode ser útil alternar entre o menor, o melhor e o maior, o melhor tipo de métricas.
Oleoduto em pares-pós-processamento: alterou ligeiramente o nome e os argumentos do postprocessor Sub Config- pairwise_images agora é pairwise_reranker e não precisa de transformações.
Você pode pensar "se eu precisar de incorporações de imagem, posso simplesmente treinar um classificador de baunilha e tomar sua penúltima camada" . Bem, faz sentido como ponto de partida. Mas existem várias desvantagens possíveis:
Se você deseja usar incorporação para executar a pesquisa, precisa calcular alguma distância entre eles (por exemplo, Cosine ou L2). Geralmente, você não otimiza diretamente essas distâncias durante o treinamento na configuração de classificação. Portanto, você só pode esperar que as incorporações finais tenham as propriedades desejadas.
O segundo problema é o processo de validação . Na configuração de pesquisa, você geralmente se importa com o quão relacionados são as suas saídas de N-N com a consulta. A maneira natural de avaliar o modelo é simular solicitações de pesquisa no conjunto de referência e aplicar uma das métricas de recuperação. Portanto, não há garantia de que a precisão da classificação se correlacione com essas métricas.
Por fim, você pode querer implementar um pipeline de aprendizado métrico sozinho. Há muito trabalho : para usar a perda de trigêmeos necessários para formar lotes de uma maneira específica, implementar diferentes tipos de mineração de trigêmeos, rastreamento de distâncias etc. Para a validação, você também precisa implementar métricas de recuperação, que incluem incorporação eficaz durante o acúmulo de epoch, cobrindo casos de canto, etc. Você também pode querer visualizar suas solicitações de pesquisa destacando bons e maus resultados de pesquisa. Em vez de fazer isso sozinho, você pode simplesmente usar a OML para seus propósitos.
A PML é a biblioteca popular para o aprendizado métrico e inclui uma rica coleção de perdas, mineiros, distâncias e redutores; É por isso que fornecemos exemplos diretos de usá -los com a OML. Inicialmente, tentamos usar o PML, mas, no final, criamos nossa biblioteca, que é mais orientada para pipeline / receitas. É assim que a OML difere do PML:
A OML possui pipelines que permitem modelos de treinamento, preparando uma configuração e seus dados no formato necessário (é como converter dados em formato Coco para treinar um detector da MMDetecção).
A OML se concentra em oleodutos de ponta a ponta e casos de uso prático. Possui exemplos baseados em configuração em benchmarks populares próximos à vida real (como fotos de produtos de milhares de IDs). Encontramos algumas boas combinações de hiperparâmetros nesses conjuntos de dados, modelos treinados e publicados e suas configurações. Assim, torna a OML mais receitas orientadas do que a PML, e seu autor confirma isso dizendo que sua biblioteca é um conjunto de ferramentas, em vez das receitas, além disso, os exemplos no PML são principalmente para conjuntos de dados CIFAR e MNIST.
A OML possui o zoológico de modelos pré -tenhados que podem ser facilmente acessados a partir do código da mesma maneira que na torchvision (quando você digita resnet50(pretrained=True) ).
A OML é integrada ao Pytorch Lightning, para que possamos usar o poder de seu treinador. Isso é especialmente útil quando trabalhamos com o DDP, então você compara nosso exemplo DDP e o PMLS. A propósito, a PML também possui treinadores, mas não é amplamente utilizada nos exemplos e as funções train / test personalizadas são usadas.
Acreditamos que ter oleodutos, exemplos lacônicos e zoológico de modelos pré -terem previsto o limite de entrada como um valor muito baixo.
Problema de aprendizagem métrica (também conhecida como problema de classificação extrema ) significa uma situação em que temos milhares de IDs de algumas entidades, mas apenas algumas amostras para todas as entidades. Muitas vezes, assumimos que, durante o estágio de teste (ou produção), lidaremos com entidades invisíveis, o que torna impossível aplicar diretamente o pipeline de classificação de baunilha. Em muitos casos, as incorporações obtidas são usadas para executar procedimentos de pesquisa ou correspondência sobre eles.
Aqui estão alguns exemplos de tais tarefas da esfera da visão computacional:
embedding - Saída do modelo (também conhecida como features vector ou descriptor ).query - Uma amostra que é usada como solicitação no procedimento de recuperação.gallery set - o conjunto de entidades para pesquisar itens semelhantes à query (também conhecida como reference ou index ).Sampler - um argumento para DataLoader que é usado para formar lotesMiner - O objeto para formar pares ou trigêmeos depois que o lote foi formado pelo Sampler . Não é necessário formar as combinações de amostras apenas dentro do lote atual; portanto, o banco de memória pode fazer parte do Miner .Samples / Labels / Instances - como exemplo, vamos considerar o conjunto de dados Deepfashion. Inclui milhares de IDs de itens de moda (nós os chamamos labels ) e várias fotos para cada ID do item (nomeamos a foto individual como instance ou sample ). Todos os IDs de itens de moda têm seus grupos como "Saias", "Jackets", "Shorts" e assim por diante (nós os nomeamos categories ). Observe que evitamos usar a class de termo para evitar mal -entendidos.training epoch - amostradores em lote que usamos para perdas baseadas em combinação geralmente têm um comprimento igual a [number of labels in training dataset] / [numbers of labels in one batch] . Isso significa que não observamos todas as amostras de treinamento disponíveis em uma época (em oposição à classificação de baunilha); em vez disso, observamos todos os rótulos disponíveis.Pode ser comparável aos métodos SOTA atuais (2022 anos), por exemplo, hyp-vit. (Poucas palavras sobre essa abordagem: é uma arquitetura Vit treinada com perda contrastiva, mas as incorporações foram projetadas em algum espaço hiperbólico. Como os autores afirmavam, esse espaço é capaz de descrever a estrutura aninhada dos dados do mundo real. So, o artigo requer alguma matemática pesada para adaptar as operações usuais para o espaço hiperbólico.)
Treinamos a mesma arquitetura com perda de trigêmeos, corrigindo o restante dos parâmetros: transformações de treinamento e teste, tamanho da imagem e otimizador. Veja as configurações nos modelos zoológico. O truque estava em heurísticas em nosso mineiro e amostrador:
O Sampler de Balance de Categoria forma os lotes que limitam o número de categorias C nele. Por exemplo, quando C = 1 coloca apenas jaquetas em um lote e apenas jeans em outro (apenas um exemplo). Ele automaticamente dificulta os pares negativos: é mais significativo para um modelo perceber por que duas jaquetas são diferentes do que entender o mesmo sobre uma jaqueta e uma camiseta.
Tripletos duros miner torna a tarefa ainda mais difícil, mantendo apenas os trigêmeos mais difíceis (com distâncias positivas máximas e mínimas negativas).
Aqui estão o CMC@1 pontuações para 2 benchmarks populares. Conjunto de dados SOP: hyp-vit-85.9, o nosso-86.6. DataSet Deepfashion: Hyp-Vit-92,5, o nosso-92.1. Assim, utilizando heurísticas simples e evitando matemática pesada, somos capazes de executar no nível SOTA.
Pesquisas recentes no SSL definitivamente obtiveram ótimos resultados. O problema é que essas abordagens exigiam uma enorme quantidade de computação para treinar o modelo. Mas em nossa estrutura, consideramos o caso mais comum quando o usuário médio não tem mais do que algumas GPUs.
Ao mesmo tempo, seria imprudente ignorar o sucesso nessa esfera, então ainda o exploramos de duas maneiras:
Não, você não. OML é uma estrutura-estrutura. Apesar de usarmos o Pytorch Lightning como corredor de loop para os experimentos, também mantemos a possibilidade de executar tudo em Pure Pytorch. Assim, apenas a pequena parte da OML é específica do raio e mantemos essa lógica separadamente de outro código (consulte oml.lightning ). Mesmo quando você usa o Lightning, não precisa conhecê -lo, já que fornecemos pipelines prontos para usar.
A possibilidade de usar pytorch pura e estrutura modular do código deixa uma sala para utilizar a OML com sua estrutura favorita após a implementação dos invólucros necessários.
Sim. Para executar o experimento com pipelines, você só precisa escrever um conversor em nosso formato (significa preparar a tabela .csv com algumas colunas predefinidas). É isso!
Provavelmente já temos um modelo pré-treinado adequado para o seu domínio em nossos modelos zoológico . Nesse caso, você nem precisa treiná -lo.
Atualmente, não apoiamos os modelos de exportação para ONNX diretamente. No entanto, você pode usar os recursos de Pytorch embutidos para conseguir isso. Para mais informações, consulte este problema.
DOCUMENTAÇÃO
Tutorial para começar com: inglês | Russo | chinês
A demonstração do nosso papel agitou: Transformadores siameses para recuperação de imagens Pós -processamento
Conheça o OpenMetricLearning (OML) no MarkTechPost
O relatório para o Meetup, com sede em Berlim: "Visão computacional em produção". Novembro de 2022. Link
pip install -U open-metric-learning ; # minimum dependencies
pip install -U open-metric-learning[nlp]
pip install -U open-metric-learning[audio]docker pull omlteam/oml:gpu
docker pull omlteam/oml:cpu Perdas | Mineiros miner = AllTripletsMiner ()
miner = NHardTripletsMiner ()
miner = MinerWithBank ()
...
criterion = TripletLossWithMiner ( 0.1 , miner )
criterion = ArcFaceLoss ()
criterion = SurrogatePrecision () | Amostradores labels = train . get_labels ()
l2c = train . get_label2category ()
sampler = BalanceSampler ( labels )
sampler = CategoryBalanceSampler ( labels , l2c )
sampler = DistinctCategoryBalanceSampler ( labels , l2c ) |
Suporte de configurações max_epochs : 10
sampler :
name : balance
args :
n_labels : 2
n_instances : 2 | Modelos pré-treinados model_hf = AutoModel . from_pretrained ( "roberta-base" )
tokenizer = AutoTokenizer . from_pretrained ( "roberta-base" )
extractor_txt = HFWrapper ( model_hf )
extractor_img = ViTExtractor . from_pretrained ( "vits16_dino" )
transforms , _ = get_transforms_for_pretrained ( "vits16_dino" ) |
Pós-processamento emb = inference ( extractor , dataset )
rr = RetrievalResults . from_embeddings ( emb , dataset )
postprocessor = AdaptiveThresholding ()
rr_upd = postprocessor . process ( rr , dataset ) | Pós-processamento por nn | Papel embeddings = inference ( extractor , dataset )
rr = RetrievalResults . from_embeddings ( embeddings , dataset )
postprocessor = PairwiseReranker ( ConcatSiamese (), top_n = 3 )
rr_upd = postprocessor . process ( rr , dataset ) |
Log logger = TensorBoardPipelineLogger ()
logger = NeptunePipelineLogger ()
logger = WandBPipelineLogger ()
logger = MLFlowPipelineLogger ()
logger = ClearMLPipelineLogger () | Pml from pytorch_metric_learning import losses
criterion = losses . TripletMarginLoss ( 0.2 , "all" )
pred = ViTExtractor ()( data )
criterion ( pred , gts ) |
Suporte de categorias # train
loader = DataLoader ( CategoryBalanceSampler ())
# validation
rr = RetrievalResults . from_embeddings ()
m . calc_retrieval_metrics_rr ( rr , query_categories ) | Métricas misc embeddigs = inference ( model , dataset )
rr = RetrievalResults . from_embeddings ( embeddings , dataset )
m . calc_retrieval_metrics_rr ( rr , precision_top_k = ( 5 ,))
m . calc_fnmr_at_fmr_rr ( rr , fmr_vals = ( 0.1 ,))
m . calc_topological_metrics ( embeddings , pcf_variance = ( 0.5 ,)) |
Raio import pytorch_lightning as pl
model = ViTExtractor . from_pretrained ( "vits16_dino" )
clb = MetricValCallback ( EmbeddingMetrics ( dataset ))
module = ExtractorModule ( model , criterion , optimizer )
trainer = pl . Trainer ( max_epochs = 3 , callbacks = [ clb ])
trainer . fit ( module , train_loader , val_loader ) | Lightning DDP clb = MetricValCallback ( EmbeddingMetrics ( val ))
module = ExtractorModuleDDP (
model , criterion , optimizer , train , val
)
ddp = { "devices" : 2 , "strategy" : DDPStrategy ()}
trainer = pl . Trainer ( max_epochs = 3 , callbacks = [ clb ], ** ddp )
trainer . fit ( module ) |
Aqui está um exemplo de como treinar, validar e pós-processo do modelo em um pequeno conjunto de dados de imagens ou textos. Veja mais detalhes sobre o formato do conjunto de dados.
| Imagens | Textos |
from torch . optim import Adam
from torch . utils . data import DataLoader
from oml import datasets as d
from oml . inference import inference
from oml . losses import TripletLossWithMiner
from oml . metrics import calc_retrieval_metrics_rr
from oml . miners import AllTripletsMiner
from oml . models import ViTExtractor
from oml . registry import get_transforms_for_pretrained
from oml . retrieval import RetrievalResults , AdaptiveThresholding
from oml . samplers import BalanceSampler
from oml . utils import get_mock_images_dataset
model = ViTExtractor . from_pretrained ( "vits16_dino" ). to ( "cpu" ). train ()
transform , _ = get_transforms_for_pretrained ( "vits16_dino" )
df_train , df_val = get_mock_images_dataset ( global_paths = True )
train = d . ImageLabeledDataset ( df_train , transform = transform )
val = d . ImageQueryGalleryLabeledDataset ( df_val , transform = transform )
optimizer = Adam ( model . parameters (), lr = 1e-4 )
criterion = TripletLossWithMiner ( 0.1 , AllTripletsMiner (), need_logs = True )
sampler = BalanceSampler ( train . get_labels (), n_labels = 2 , n_instances = 2 )
def training ():
for batch in DataLoader ( train , batch_sampler = sampler ):
embeddings = model ( batch [ "input_tensors" ])
loss = criterion ( embeddings , batch [ "labels" ])
loss . backward ()
optimizer . step ()
optimizer . zero_grad ()
print ( criterion . last_logs )
def validation ():
embeddings = inference ( model , val , batch_size = 4 , num_workers = 0 )
rr = RetrievalResults . from_embeddings ( embeddings , val , n_items = 3 )
rr = AdaptiveThresholding ( n_std = 2 ). process ( rr )
rr . visualize ( query_ids = [ 2 , 1 ], dataset = val , show = True )
print ( calc_retrieval_metrics_rr ( rr , map_top_k = ( 3 ,), cmc_top_k = ( 1 ,)))
training ()
validation () | from torch . optim import Adam
from torch . utils . data import DataLoader
from transformers import AutoModel , AutoTokenizer
from oml import datasets as d
from oml . inference import inference
from oml . losses import TripletLossWithMiner
from oml . metrics import calc_retrieval_metrics_rr
from oml . miners import AllTripletsMiner
from oml . models import HFWrapper
from oml . retrieval import RetrievalResults , AdaptiveThresholding
from oml . samplers import BalanceSampler
from oml . utils import get_mock_texts_dataset
model = HFWrapper ( AutoModel . from_pretrained ( "bert-base-uncased" ), 768 ). to ( "cpu" ). train ()
tokenizer = AutoTokenizer . from_pretrained ( "bert-base-uncased" )
df_train , df_val = get_mock_texts_dataset ()
train = d . TextLabeledDataset ( df_train , tokenizer = tokenizer )
val = d . TextQueryGalleryLabeledDataset ( df_val , tokenizer = tokenizer )
optimizer = Adam ( model . parameters (), lr = 1e-4 )
criterion = TripletLossWithMiner ( 0.1 , AllTripletsMiner (), need_logs = True )
sampler = BalanceSampler ( train . get_labels (), n_labels = 2 , n_instances = 2 )
def training ():
for batch in DataLoader ( train , batch_sampler = sampler ):
embeddings = model ( batch [ "input_tensors" ])
loss = criterion ( embeddings , batch [ "labels" ])
loss . backward ()
optimizer . step ()
optimizer . zero_grad ()
print ( criterion . last_logs )
def validation ():
embeddings = inference ( model , val , batch_size = 4 , num_workers = 0 )
rr = RetrievalResults . from_embeddings ( embeddings , val , n_items = 3 )
rr = AdaptiveThresholding ( n_std = 2 ). process ( rr )
rr . visualize ( query_ids = [ 2 , 1 ], dataset = val , show = True )
print ( calc_retrieval_metrics_rr ( rr , map_top_k = ( 3 ,), cmc_top_k = ( 1 ,)))
training ()
validation () |
Saída{ 'active_tri' : 0.125 , 'pos_dist' : 82.5 , 'neg_dist' : 100.5 } # batch 1
{ 'active_tri' : 0.0 , 'pos_dist' : 36.3 , 'neg_dist' : 56.9 } # batch 2
{ 'cmc' : { 1 : 0.75 }, 'precision' : { 5 : 0.75 }, 'map' : { 3 : 0.8 }} | Saída{ 'active_tri' : 0.0 , 'pos_dist' : 8.5 , 'neg_dist' : 11.0 } # batch 1
{ 'active_tri' : 0.25 , 'pos_dist' : 8.9 , 'neg_dist' : 9.8 } # batch 2
{ 'cmc' : { 1 : 0.8 }, 'precision' : { 5 : 0.7 }, 'map' : { 3 : 0.9 }} |
Ilustrações extras, explicações e dicas para o código acima.
Aqui está um exemplo de tempo de inferência (em outras palavras, recuperação no conjunto de testes). O código abaixo funciona para textos e imagens.
from oml . datasets import ImageQueryGalleryDataset
from oml . inference import inference
from oml . models import ViTExtractor
from oml . registry import get_transforms_for_pretrained
from oml . utils import get_mock_images_dataset
from oml . retrieval import RetrievalResults , AdaptiveThresholding
_ , df_test = get_mock_images_dataset ( global_paths = True )
del df_test [ "label" ] # we don't need gt labels for doing predictions
extractor = ViTExtractor . from_pretrained ( "vits16_dino" ). to ( "cpu" )
transform , _ = get_transforms_for_pretrained ( "vits16_dino" )
dataset = ImageQueryGalleryDataset ( df_test , transform = transform )
embeddings = inference ( extractor , dataset , batch_size = 4 , num_workers = 0 )
rr = RetrievalResults . from_embeddings ( embeddings , dataset , n_items = 5 )
rr = AdaptiveThresholding ( n_std = 3.5 ). process ( rr )
rr . visualize ( query_ids = [ 0 , 1 ], dataset = dataset , show = True )
# you get the ids of retrieved items and the corresponding distances
print ( rr )Aqui está um exemplo em que consultas e galerias processadas separadamente.
import pandas as pd
from oml . datasets import ImageBaseDataset
from oml . inference import inference
from oml . models import ViTExtractor
from oml . registry import get_transforms_for_pretrained
from oml . retrieval import RetrievalResults , ConstantThresholding
from oml . utils import get_mock_images_dataset
extractor = ViTExtractor . from_pretrained ( "vits16_dino" ). to ( "cpu" )
transform , _ = get_transforms_for_pretrained ( "vits16_dino" )
paths = pd . concat ( get_mock_images_dataset ( global_paths = True ))[ "path" ]
galleries , queries1 , queries2 = paths [: 20 ], paths [ 20 : 22 ], paths [ 22 : 24 ]
# gallery is huge and fixed, so we only process it once
dataset_gallery = ImageBaseDataset ( galleries , transform = transform )
embeddings_gallery = inference ( extractor , dataset_gallery , batch_size = 4 , num_workers = 0 )
# queries come "online" in stream
for queries in [ queries1 , queries2 ]:
dataset_query = ImageBaseDataset ( queries , transform = transform )
embeddings_query = inference ( extractor , dataset_query , batch_size = 4 , num_workers = 0 )
# for the operation below we are going to provide integrations with vector search DB like QDrant or Faiss
rr = RetrievalResults . from_embeddings_qg (
embeddings_query = embeddings_query , embeddings_gallery = embeddings_gallery ,
dataset_query = dataset_query , dataset_gallery = dataset_gallery
)
rr = ConstantThresholding ( th = 80 ). process ( rr )
rr . visualize_qg ([ 0 , 1 ], dataset_query = dataset_query , dataset_gallery = dataset_gallery , show = True )
print ( rr )Os pipelines fornecem uma maneira de executar experimentos de aprendizado métrico através da alteração apenas do arquivo de configuração. Tudo o que você precisa é preparar seu conjunto de dados em um formato necessário.
Veja a pasta Pipelines para obter mais detalhes:
Aqui está uma integração leve com os modelos Huggingface Transformers. Você pode substituí -lo por outros modelos arbitrários herdados do iExtractor.
Observe que não temos nossos próprios modelos de texto zoológico no momento.
pip install open-metric-learning[nlp] from transformers import AutoModel , AutoTokenizer
from oml . models import HFWrapper
model = AutoModel . from_pretrained ( 'bert-base-uncased' ). eval ()
tokenizer = AutoTokenizer . from_pretrained ( 'bert-base-uncased' )
extractor = HFWrapper ( model = model , feat_dim = 768 )
inp = tokenizer ( text = "Hello world" , return_tensors = "pt" , add_special_tokens = True )
embeddings = extractor ( inp )Você pode usar um modelo de imagem do nosso zoológico ou usar outros modelos arbitrários depois de herdá -lo da Iextractor.
from oml . const import CKPT_SAVE_ROOT as CKPT_DIR , MOCK_DATASET_PATH as DATA_DIR
from oml . models import ViTExtractor
from oml . registry import get_transforms_for_pretrained
model = ViTExtractor . from_pretrained ( "vits16_dino" ). eval ()
transforms , im_reader = get_transforms_for_pretrained ( "vits16_dino" )
img = im_reader ( DATA_DIR / "images" / "circle_1.jpg" ) # put path to your image here
img_tensor = transforms ( img )
# img_tensor = transforms(image=img)["image"] # for transforms from Albumentations
features = model ( img_tensor . unsqueeze ( 0 ))
# Check other available models:
print ( list ( ViTExtractor . pretrained_models . keys ()))
# Load checkpoint saved on a disk:
model_ = ViTExtractor ( weights = CKPT_DIR / "vits16_dino.ckpt" , arch = "vits16" , normalise_features = False )Modelos, treinados por nós. As métricas abaixo são para 224 x 224 imagens:
| modelo | CMC1 | conjunto de dados | pesos | experimentar |
|---|---|---|---|---|
ViTExtractor.from_pretrained("vits16_inshop") | 0,921 | Deepfashion Inscop | link | link |
ViTExtractor.from_pretrained("vits16_sop") | 0,866 | Produtos on -line de Stanford | link | link |
ViTExtractor.from_pretrained("vits16_cars") | 0,907 | Carros 196 | link | link |
ViTExtractor.from_pretrained("vits16_cub") | 0,837 | Cub 200 2011 | link | link |
Modelos, treinados por outros pesquisadores. Observe que algumas métricas em benchmarks específicas são muito altas porque faziam parte do conjunto de dados de treinamento (por exemplo, unicom ). As métricas abaixo são para 224 x 224 imagens:
| modelo | Produtos on -line de Stanford | Deepfashion Inscop | Cub 200 2011 | Carros 196 |
|---|---|---|---|---|
ViTUnicomExtractor.from_pretrained("vitb16_unicom") | 0,700 | 0,734 | 0,847 | 0,916 |
ViTUnicomExtractor.from_pretrained("vitb32_unicom") | 0,690 | 0,722 | 0,796 | 0,893 |
ViTUnicomExtractor.from_pretrained("vitl14_unicom") | 0,726 | 0,790 | 0,868 | 0,922 |
ViTUnicomExtractor.from_pretrained("vitl14_336px_unicom") | 0,745 | 0,810 | 0,875 | 0,924 |
ViTCLIPExtractor.from_pretrained("sber_vitb32_224") | 0,547 | 0,514 | 0,448 | 0,618 |
ViTCLIPExtractor.from_pretrained("sber_vitb16_224") | 0,565 | 0,565 | 0,524 | 0,648 |
ViTCLIPExtractor.from_pretrained("sber_vitl14_224") | 0,512 | 0,555 | 0,606 | 0,707 |
ViTCLIPExtractor.from_pretrained("openai_vitb32_224") | 0,612 | 0,491 | 0,560 | 0,693 |
ViTCLIPExtractor.from_pretrained("openai_vitb16_224") | 0,648 | 0,606 | 0,665 | 0,767 |
ViTCLIPExtractor.from_pretrained("openai_vitl14_224") | 0,670 | 0,675 | 0,745 | 0,844 |
ViTExtractor.from_pretrained("vits16_dino") | 0,648 | 0,509 | 0,627 | 0,265 |
ViTExtractor.from_pretrained("vits8_dino") | 0,651 | 0,524 | 0,661 | 0,315 |
ViTExtractor.from_pretrained("vitb16_dino") | 0,658 | 0,514 | 0,541 | 0,288 |
ViTExtractor.from_pretrained("vitb8_dino") | 0,689 | 0,599 | 0,506 | 0,313 |
ViTExtractor.from_pretrained("vits14_dinov2") | 0,566 | 0,334 | 0,797 | 0,503 |
ViTExtractor.from_pretrained("vits14_reg_dinov2") | 0,566 | 0,332 | 0,795 | 0,740 |
ViTExtractor.from_pretrained("vitb14_dinov2") | 0,565 | 0,342 | 0,842 | 0,644 |
ViTExtractor.from_pretrained("vitb14_reg_dinov2") | 0,557 | 0,324 | 0,833 | 0,828 |
ViTExtractor.from_pretrained("vitl14_dinov2") | 0,576 | 0,352 | 0,844 | 0,692 |
ViTExtractor.from_pretrained("vitl14_reg_dinov2") | 0,571 | 0,340 | 0,840 | 0,871 |
ResnetExtractor.from_pretrained("resnet50_moco_v2") | 0,493 | 0,267 | 0,264 | 0,149 |
ResnetExtractor.from_pretrained("resnet50_imagenet1k_v1") | 0,515 | 0,284 | 0,455 | 0,247 |
As métricas podem ser diferentes das relatadas pelos artigos, porque a versão da divisão de trem/Val e o uso de caixas delimitadoras pode diferir.
Congratulamo -nos com novos colaboradores! Por favor, veja o nosso:
O projeto foi iniciado em 2020 como um módulo da Biblioteca Catalyst. Quero agradecer às pessoas que trabalharam comigo naquele módulo: Julia Shenshina, Nikita Balagansky, Sergey Kolesnikov e outros.
Gostaria de agradecer às pessoas que continuam trabalhando neste pipeline quando se tornou um projeto separado: Julia Shenshina, Misha Kindulov, Aron Dik, Aleksei Tarasov e Verkhovtsev Leonid.
Também quero agradecer a Newyorker, uma vez que a parte da funcionalidade foi desenvolvida (e usada) por sua equipe de visão computacional liderada por mim.
