mmengine
v0.10.5
Pendahuluan | Instalasi | Mulai | Dokumentasi | Masalah pelaporan
Bahasa Inggris | 简体中文
V0.10.5 dirilis pada 2024-9-11.
Highlight:
artifact_location khusus di MLFLOWVISBackend #1505exclude_frozen_parameters untuk DeepSpeedEngine._zero3_consolidated_16bit_state_dict #1517Baca Changelog untuk detail lebih lanjut.
MMengine adalah perpustakaan dasar untuk melatih model pembelajaran mendalam berdasarkan Pytorch. Ini berfungsi sebagai mesin pelatihan semua basis kode OpenMMLAB, yang mendukung ratusan algoritma di berbagai bidang penelitian. Selain itu, mmengine juga generik untuk diterapkan pada proyek non-openmmlab. Sorotannya adalah sebagai berikut:
Mengintegrasikan kerangka kerja pelatihan model skala besar arus utama
Mendukung berbagai strategi pelatihan
Menyediakan sistem konfigurasi yang ramah pengguna
Meliputi platform pemantauan pelatihan utama
| Mmengine | Pytorch | Python |
|---|---|---|
| utama | > = 1.6 <= 2.1 | > = 3.8, <= 3.11 |
| > = 0.9.0, <= 0.10.4 | > = 1.6 <= 2.1 | > = 3.8, <= 3.11 |
Sebelum menginstal MMengine, harap pastikan bahwa Pytorch telah berhasil diinstal mengikuti panduan resmi.
Instal mmengine
pip install -U openmim
mim install mmengineVerifikasi instalasi
python -c ' from mmengine.utils.dl_utils import collect_env;print(collect_env()) ' Mengambil pelatihan model RESNET-50 pada dataset CIFAR-10 sebagai contoh, kami akan menggunakan MMengine untuk membangun proses pelatihan dan validasi yang lengkap dan dapat dikonfigurasi dalam kurang dari 80 baris kode.
Pertama, kita perlu mendefinisikan model yang 1) mewarisi dari BaseModel dan 2) menerima mode argumen tambahan dalam metode forward , di samping argumen yang terkait dengan dataset.
mode adalah "kehilangan", dan metode forward harus mengembalikan dict yang berisi "kerugian" kunci.mode adalah "prediksi", dan metode maju harus mengembalikan hasil yang berisi prediksi dan label. import torch . nn . functional as F
import torchvision
from mmengine . model import BaseModel
class MMResNet50 ( BaseModel ):
def __init__ ( self ):
super (). __init__ ()
self . resnet = torchvision . models . resnet50 ()
def forward ( self , imgs , labels , mode ):
x = self . resnet ( imgs )
if mode == 'loss' :
return { 'loss' : F . cross_entropy ( x , labels )}
elif mode == 'predict' :
return x , labelsSelanjutnya, kita perlu membuat dataset S dan DataLoader untuk pelatihan dan validasi. Dalam hal ini, kami cukup menggunakan dataset bawaan yang didukung dalam TorchVision.
import torchvision . transforms as transforms
from torch . utils . data import DataLoader
norm_cfg = dict ( mean = [ 0.491 , 0.482 , 0.447 ], std = [ 0.202 , 0.199 , 0.201 ])
train_dataloader = DataLoader ( batch_size = 32 ,
shuffle = True ,
dataset = torchvision . datasets . CIFAR10 (
'data/cifar10' ,
train = True ,
download = True ,
transform = transforms . Compose ([
transforms . RandomCrop ( 32 , padding = 4 ),
transforms . RandomHorizontalFlip (),
transforms . ToTensor (),
transforms . Normalize ( ** norm_cfg )
])))
val_dataloader = DataLoader ( batch_size = 32 ,
shuffle = False ,
dataset = torchvision . datasets . CIFAR10 (
'data/cifar10' ,
train = False ,
download = True ,
transform = transforms . Compose ([
transforms . ToTensor (),
transforms . Normalize ( ** norm_cfg )
]))) Untuk memvalidasi dan menguji model, kita perlu mendefinisikan metrik yang disebut akurasi untuk mengevaluasi model. Metrik ini perlu diwarisi dari BaseMetric dan mengimplementasikan process dan metode compute_metrics .
from mmengine . evaluator import BaseMetric
class Accuracy ( BaseMetric ):
def process ( self , data_batch , data_samples ):
score , gt = data_samples
# Save the results of a batch to `self.results`
self . results . append ({
'batch_size' : len ( gt ),
'correct' : ( score . argmax ( dim = 1 ) == gt ). sum (). cpu (),
})
def compute_metrics ( self , results ):
total_correct = sum ( item [ 'correct' ] for item in results )
total_size = sum ( item [ 'batch_size' ] for item in results )
# Returns a dictionary with the results of the evaluated metrics,
# where the key is the name of the metric
return dict ( accuracy = 100 * total_correct / total_size ) Akhirnya, kita dapat membangun pelari dengan Model yang ditentukan sebelumnya, DataLoader , dan Metrics , dengan beberapa konfigurasi lainnya, seperti yang ditunjukkan di bawah ini.
from torch . optim import SGD
from mmengine . runner import Runner
runner = Runner (
model = MMResNet50 (),
work_dir = './work_dir' ,
train_dataloader = train_dataloader ,
# a wrapper to execute back propagation and gradient update, etc.
optim_wrapper = dict ( optimizer = dict ( type = SGD , lr = 0.001 , momentum = 0.9 )),
# set some training configs like epochs
train_cfg = dict ( by_epoch = True , max_epochs = 5 , val_interval = 1 ),
val_dataloader = val_dataloader ,
val_cfg = dict (),
val_evaluator = dict ( type = Accuracy ),
) runner . train ()Kami menghargai semua kontribusi untuk meningkatkan mmengine. Silakan merujuk ke Contributing.MD untuk Pedoman yang Berkontribusi.
Jika Anda menemukan proyek ini berguna dalam penelitian Anda, silakan pertimbangkan CITE:
@article{mmengine2022,
title = {{MMEngine}: OpenMMLab Foundational Library for Training Deep Learning Models},
author = {MMEngine Contributors},
howpublished = {url{https://github.com/open-mmlab/mmengine}},
year={2022}
}
Proyek ini dirilis di bawah lisensi Apache 2.0.
