lightly
More and better Transforms
SSL ringan adalah kerangka kerja visi komputer untuk pembelajaran yang di-swadaya.
Untuk versi komersial dengan lebih banyak fitur, termasuk dukungan Docker dan model pretraining untuk embedding, klasifikasi, deteksi, dan tugas segmentasi dengan satu perintah, silakan hubungi [email protected].
Kami juga telah membangun seluruh platform di atas, dengan fitur tambahan untuk pembelajaran aktif dan kurasi data. Jika Anda tertarik dengan solusi pekerja ringan untuk dengan mudah memproses jutaan sampel dan menjalankan algoritma yang kuat pada data Anda, lihat dengan ringan.ai. Gratis untuk memulai!
Kerangka kerja pembelajaran swasembada ini menawarkan fitur-fitur berikut:
Anda dapat menemukan kode sampel untuk semua model yang didukung di sini. Kami memberikan contoh terdistribusi Pytorch, Pytorch Lightning, dan Pytorch Lightning untuk semua model untuk memulai proyek Anda.
Model :
| Model | Tahun | Kertas | Dokumen | Colab (Pytorch) | Colab (Pytorch Lightning) |
|---|---|---|---|---|---|
| TUJUAN | 2024 | kertas | dokumen | ||
| Barlow Twins | 2021 | kertas | dokumen | ||
| BYOL | 2020 | kertas | dokumen | ||
| DCL & DCLW | 2021 | kertas | dokumen | ||
| Densecl | 2021 | kertas | dokumen | ||
| Dino | 2021 | kertas | dokumen | ||
| Mae | 2021 | kertas | dokumen | ||
| Msn | 2022 | kertas | dokumen | ||
| Moco | 2019 | kertas | dokumen | ||
| Nnclr | 2021 | kertas | dokumen | ||
| PMSN | 2022 | kertas | dokumen | ||
| Simclr | 2020 | kertas | dokumen | ||
| Simmim | 2022 | kertas | dokumen | ||
| Simsiam | 2021 | kertas | dokumen | ||
| SWAV | 2020 | kertas | dokumen | ||
| Vicreg | 2021 | kertas | dokumen |
Ingin melompat ke tutorial dan melihat dengan ringan beraksi?
Proyek Komunitas dan Mitra:
Dengan ringan membutuhkan Python 3.7+ . Kami sarankan menginstal ringan di lingkungan Linux atau OSX . Python 3.13 belum didukung, karena Pytorch sendiri tidak memiliki kompatibilitas Python 3.13.
Karena sifat modular dari paket ringan, beberapa modul dapat digunakan dengan versi dependensi yang lebih lama. Namun, untuk menggunakan semua fitur hingga saat ini dengan ringan membutuhkan ketergantungan berikut:
Ringan kompatibel dengan Pytorch dan Pytorch Lightning v2.0+!
Anda dapat menginstal ringan dan ketergantungannya dari PYPI dengan:
pip3 install lightly
Kami sangat menyarankan menginstal ringan di VirtualEnv khusus untuk menghindari konflik dengan paket sistem Anda.
Dengan ringan, Anda dapat menggunakan metode pembelajaran swadaya terbaru dengan cara modular menggunakan kekuatan penuh Pytorch. Eksperimen dengan berbagai tulang punggung, model, dan fungsi kerugian. Kerangka kerja telah dirancang agar mudah digunakan dari bawah ke atas. Temukan lebih banyak contoh di dokumen kami.
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 } " )Anda dapat dengan mudah menggunakan model lain seperti Simsiam dengan menukar model dan fungsi kerugian.
# 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 ()Anda dapat menemukan contoh yang lebih lengkap untuk Simsiam di sini.
Gunakan Pytorch Lightning untuk melatih model:
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 )Lihat Dokumen kami untuk contoh Petir Pytorch lengkap.
Atau latih model pada 4 GPU:
# 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 )Kami memberikan contoh pelatihan multi-GPU dengan kumpulan terdistribusi dan bersinkronisasi. Lihatlah dokumen kami mengenai pelatihan yang didistribusikan.
Model yang diimplementasikan dan kinerjanya di berbagai dataset. Hyperparameters tidak disetel untuk akurasi maksimum. Untuk hasil terperinci dan informasi lebih lanjut tentang tolok ukur klik di sini.
Tolok ukur imagenet1k
Catatan : Pengaturan evaluasi didasarkan pada makalah ini:
Lihat skrip benchmarking untuk detailnya.
| Model | Tulang punggung | Ukuran batch | Zaman | Linear top1 | Finetune Top1 | Knn Top1 | Tensorboard | Pos pemeriksaan |
|---|---|---|---|---|---|---|---|---|
| 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 |
*Kami menggunakan penskalaan laju pembelajaran root persegi alih -alih penskalaan linier karena menghasilkan hasil yang lebih baik untuk ukuran batch yang lebih kecil. Lihat Lampiran B.1 di kertas SIMCLR.
Imagenet100 Benchmark Hasil Detail
Imagenette Benchmark Hasil Detail
CIFAR-10 Benchmark Hasil Detail
Di bawah ini Anda dapat melihat tinjauan skematis dari berbagai konsep dalam paket. Istilah dalam tebal dijelaskan secara lebih rinci dalam dokumentasi kami.
Pergilah ke dokumentasi dan lihat hal -hal yang dapat Anda capai dengan ringan!
Untuk menginstal dependensi dev (misalnya untuk berkontribusi pada kerangka kerja) Anda dapat menggunakan perintah berikut:
pip3 install -e ".[dev]"
Untuk informasi lebih lanjut tentang cara berkontribusi, lihat di sini.
Tes unit berada dalam direktori tes dan kami sarankan menjalankannya menggunakan pytest. Ada dua konfigurasi tes yang tersedia. Secara default, hanya subset yang akan dijalankan:
make test-fast
Untuk menjalankan semua tes (termasuk yang lambat) Anda dapat menggunakan perintah berikut:
make test
Untuk menguji file atau penggunaan direktori tertentu:
pytest <path to file or directory>
Untuk memformat kode dengan Black dan Isort Run:
make format
Pembelajaran yang di-swadaya :
Mengapa saya harus peduli dengan pembelajaran yang di-swadaya? Bukankah model pra-terlatih dari ImageNet jauh lebih baik untuk transfer pembelajaran?
Bagaimana saya bisa berkontribusi?
Apakah kerangka kerja ini gratis?
Jika kerangka kerja ini gratis, bagaimana perusahaan di balik menghasilkan uang dengan ringan?
Lightly adalah spin-off dari ETH Zurich yang membantu perusahaan membangun pipa pembelajaran aktif yang efisien untuk memilih data yang paling relevan untuk model mereka.
Anda dapat mengetahui lebih lanjut tentang perusahaan dan layanannya dengan mengikuti tautan di bawah ini:
Kembali ke atas
