lightly
More and better Transforms
A SSL levemente é uma estrutura de visão computacional para o aprendizado auto-supervisionado.
Para uma versão comercial com mais recursos, incluindo o suporte do Docker e os modelos de pré -treinamento para incorporação, classificação, detecção e tarefas de segmentação com um único comando, entre em contato com [email protected].
Também criamos uma plataforma inteira no topo, com recursos adicionais para aprendizado ativo e curadoria de dados. Se você estiver interessado na solução levemente de trabalhadores para processar facilmente milhões de amostras e executar algoritmos poderosos em seus dados, consulte levemente. É grátis para começar!
Esta estrutura de aprendizagem auto-supervisionada oferece os seguintes recursos:
Você pode encontrar código de exemplo para todos os modelos suportados aqui. Fornecemos exemplos distribuídos de Pytorch, Pytorch Lightning e Pytorch Lightning para todos os modelos para iniciar seu projeto.
Modelos :
| Modelo | Ano | Papel | Documentos | Colab (Pytorch) | Colab (Pytorch Lightning) |
|---|---|---|---|---|---|
| MIRAR | 2024 | papel | documentos | ||
| Barlow gêmeos | 2021 | papel | documentos | ||
| BYOL | 2020 | papel | documentos | ||
| Dcl & dclw | 2021 | papel | documentos | ||
| Densecl | 2021 | papel | documentos | ||
| Dino | 2021 | papel | documentos | ||
| Mae | 2021 | papel | documentos | ||
| Msn | 2022 | papel | documentos | ||
| MOCO | 2019 | papel | documentos | ||
| Nnclr | 2021 | papel | documentos | ||
| Pmsn | 2022 | papel | documentos | ||
| Simclr | 2020 | papel | documentos | ||
| Simmim | 2022 | papel | documentos | ||
| Simsiam | 2021 | papel | documentos | ||
| Swav | 2020 | papel | documentos | ||
| Vicreg | 2021 | papel | documentos |
Quer pular para os tutoriais e ver levemente em ação?
Projetos comunitários e parceiros:
Requer levemente o Python 3.7+ . Recomendamos instalar levemente em um ambiente Linux ou OSX . O Python 3.13 ainda não é suportado, pois a própria Pytorch não possui compatibilidade com Python 3.13.
Devido à natureza modular do pacote levemente, alguns módulos podem ser usados com versões mais antigas de dependências. No entanto, para usar todos os recursos de hoje, requer levemente as seguintes dependências:
É compatível levemente com Pytorch e Pytorch Lightning v2.0+!
Você pode instalar levemente e suas dependências do Pypi com:
pip3 install lightly
Recomendamos fortemente a instalação de ânimo leve em um VirtualEnv dedicado para evitar conflitos com os pacotes do sistema.
Com levemente, você pode usar os mais recentes métodos de aprendizado auto-supervisionado de maneira modular usando toda a potência do Pytorch. Experimente vários backbones, modelos e funções de perda. A estrutura foi projetada para ser fácil de usar desde o início. Encontre mais exemplos em nossos documentos.
import torch
import torchvision
from lightly import loss
from lightly import transforms
from lightly . data import LightlyDataset
from lightly . models . modules import heads
# Create a PyTorch module for the SimCLR model.
class SimCLR ( torch . nn . Module ):
def __init__ ( self , backbone ):
super (). __init__ ()
self . backbone = backbone
self . projection_head = heads . SimCLRProjectionHead (
input_dim = 512 , # Resnet18 features have 512 dimensions.
hidden_dim = 512 ,
output_dim = 128 ,
)
def forward ( self , x ):
features = self . backbone ( x ). flatten ( start_dim = 1 )
z = self . projection_head ( features )
return z
# Use a resnet backbone from torchvision.
backbone = torchvision . models . resnet18 ()
# Ignore the classification head as we only want the features.
backbone . fc = torch . nn . Identity ()
# Build the SimCLR model.
model = SimCLR ( backbone )
# Prepare transform that creates multiple random views for every image.
transform = transforms . SimCLRTransform ( input_size = 32 , cj_prob = 0.5 )
# Create a dataset from your image folder.
dataset = LightlyDataset ( input_dir = "./my/cute/cats/dataset/" , transform = transform )
# Build a PyTorch dataloader.
dataloader = torch . utils . data . DataLoader (
dataset , # Pass the dataset to the dataloader.
batch_size = 128 , # A large batch size helps with the learning.
shuffle = True , # Shuffling is important!
)
# Lightly exposes building blocks such as loss functions.
criterion = loss . NTXentLoss ( temperature = 0.5 )
# Get a PyTorch optimizer.
optimizer = torch . optim . SGD ( model . parameters (), lr = 0.1 , weight_decay = 1e-6 )
# Train the model.
for epoch in range ( 10 ):
for ( view0 , view1 ), targets , filenames in dataloader :
z0 = model ( view0 )
z1 = model ( view1 )
loss = criterion ( z0 , z1 )
loss . backward ()
optimizer . step ()
optimizer . zero_grad ()
print ( f"loss: { loss . item ():.5f } " )Você pode usar facilmente outro modelo como o Simsiam trocando o modelo e a função de perda.
# PyTorch module for the SimSiam model.
class SimSiam ( torch . nn . Module ):
def __init__ ( self , backbone ):
super (). __init__ ()
self . backbone = backbone
self . projection_head = heads . SimSiamProjectionHead ( 512 , 512 , 128 )
self . prediction_head = heads . SimSiamPredictionHead ( 128 , 64 , 128 )
def forward ( self , x ):
features = self . backbone ( x ). flatten ( start_dim = 1 )
z = self . projection_head ( features )
p = self . prediction_head ( z )
z = z . detach ()
return z , p
model = SimSiam ( backbone )
# Use the SimSiam loss function.
criterion = loss . NegativeCosineSimilarity ()Você pode encontrar um exemplo mais completo para Simsiam aqui.
Use Pytorch Lightning para treinar o modelo:
from pytorch_lightning import LightningModule , Trainer
class SimCLR ( LightningModule ):
def __init__ ( self ):
super (). __init__ ()
resnet = torchvision . models . resnet18 ()
resnet . fc = torch . nn . Identity ()
self . backbone = resnet
self . projection_head = heads . SimCLRProjectionHead ( 512 , 512 , 128 )
self . criterion = loss . NTXentLoss ()
def forward ( self , x ):
features = self . backbone ( x ). flatten ( start_dim = 1 )
z = self . projection_head ( features )
return z
def training_step ( self , batch , batch_index ):
( view0 , view1 ), _ , _ = batch
z0 = self . forward ( view0 )
z1 = self . forward ( view1 )
loss = self . criterion ( z0 , z1 )
return loss
def configure_optimizers ( self ):
optim = torch . optim . SGD ( self . parameters (), lr = 0.06 )
return optim
model = SimCLR ()
trainer = Trainer ( max_epochs = 10 , devices = 1 , accelerator = "gpu" )
trainer . fit ( model , dataloader )Veja nossos documentos para um exemplo completo de Pytorch Lightning.
Ou treinar o modelo em 4 GPUs:
# Use distributed version of loss functions.
criterion = loss . NTXentLoss ( gather_distributed = True )
trainer = Trainer (
max_epochs = 10 ,
devices = 4 ,
accelerator = "gpu" ,
strategy = "ddp" ,
sync_batchnorm = True ,
use_distributed_sampler = True , # or replace_sampler_ddp=True for PyTorch Lightning <2.0
)
trainer . fit ( model , dataloader )Fornecemos exemplos de treinamento multi-GPU com coletores distribuídos e síncronizados. Dê uma olhada em nossos documentos em relação ao treinamento distribuído.
Modelos implementados e seu desempenho em vários conjuntos de dados. Os hiperparâmetros não estão ajustados para a precisão máxima. Para obter resultados detalhados e mais informações sobre os benchmarks, clique aqui.
ImageNet1K Benchmarks
Nota : As configurações de avaliação são baseadas nesses documentos:
Veja os scripts de benchmarking para obter detalhes.
| Modelo | Espinha dorsal | Tamanho do lote | Épocas | Top1 linear | Finetune TOP1 | KNN TOP1 | Tensorboard | Ponto de verificação |
|---|---|---|---|---|---|---|---|---|
| Barlowtwins | Res50 | 256 | 100 | 62.9 | 72.6 | 45.6 | link | link |
| BYOL | Res50 | 256 | 100 | 62.5 | 74.5 | 46.0 | link | link |
| Dino | Res50 | 128 | 100 | 68.2 | 72.5 | 49.9 | link | link |
| Mae | Vit-B/16 | 256 | 100 | 46.0 | 81.3 | 11.2 | link | link |
| MOCOV2 | Res50 | 256 | 100 | 61.5 | 74.3 | 41.8 | link | link |
| Simclr* | Res50 | 256 | 100 | 63.2 | 73.9 | 44.8 | link | link |
| Simclr* + dcl | Res50 | 256 | 100 | 65.1 | 73.5 | 49.6 | link | link |
| Simclr* + dclw | Res50 | 256 | 100 | 64.5 | 73.2 | 48.5 | link | link |
| Swav | Res50 | 256 | 100 | 67.2 | 75.4 | 49.5 | link | link |
| Tico | Res50 | 256 | 100 | 49.7 | 72.7 | 26.6 | link | link |
| Vicreg | Res50 | 256 | 100 | 63.0 | 73.7 | 46.3 | link | link |
*Utilizamos escala de taxa de aprendizado de raiz quadrada em vez de escala linear, pois produz melhores resultados para tamanhos de lote menores. Consulte o Apêndice B.1 no artigo SIMCLR.
ImageNet100 Benchmarks Resultados detalhados
Imagenette Benchmarks Resultados detalhados
Resultados CIFAR-10
Abaixo, você pode ver uma visão geral esquemática dos diferentes conceitos do pacote. Os termos em negrito são explicados em mais detalhes em nossa documentação.
Vá para a documentação e veja as coisas que você pode alcançar com ânimo leve!
Para instalar dependências dev (por exemplo, para contribuir com a estrutura), você pode usar o seguinte comando:
pip3 install -e ".[dev]"
Para obter mais informações sobre como contribuir, faça uma olhada aqui.
Os testes de unidade estão dentro do diretório de testes e recomendamos executá -los usando o Pytest. Existem duas configurações de teste disponíveis. Por padrão, apenas um subconjunto será executado:
make test-fast
Para executar todos os testes (incluindo os lentos), você pode usar o seguinte comando:
make test
Para testar um arquivo específico ou uso de diretório:
pytest <path to file or directory>
Para formatar o código com preto e isort run:
make format
Aprendizagem auto-supervisionada :
Por que devo me preocupar com o aprendizado auto-supervisionado? Os modelos pré-treinados da ImageNet não são muito melhores para o aprendizado de transferência?
Como posso contribuir?
Essa estrutura é gratuita?
Se essa estrutura é gratuita, como a empresa está por trás de ganhar dinheiro leve?
É levemente um spin-off da ETH Zurique que ajuda as empresas a criar dutos de aprendizado ativo eficientes para selecionar os dados mais relevantes para seus modelos.
Você pode descobrir mais sobre a empresa e seus serviços seguindo os links abaixo:
De volta ao topo
