|
- import torch
- import torch.nn as nn
- import torch.nn.functional as F
- import torch.optim as optim
- import torchvision.transforms as transforms
- from torch.utils.data import DataLoader
- from torchvision.datasets import CIFAR10
-
- from mmcv.parallel import MMDataParallel
- from mmcv.runner import EpochBasedRunner
- from mmcv.utils import get_logger
-
-
- class Model(nn.Module):
-
- def __init__(self):
- super().__init__()
- self.conv1 = nn.Conv2d(3, 6, 5)
- self.pool = nn.MaxPool2d(2, 2)
- self.conv2 = nn.Conv2d(6, 16, 5)
- self.fc1 = nn.Linear(16 * 5 * 5, 120)
- self.fc2 = nn.Linear(120, 84)
- self.fc3 = nn.Linear(84, 10)
- self.loss_fn = nn.CrossEntropyLoss()
-
- def forward(self, x):
- x = self.pool(F.relu(self.conv1(x)))
- x = self.pool(F.relu(self.conv2(x)))
- x = x.view(-1, 16 * 5 * 5)
- x = F.relu(self.fc1(x))
- x = F.relu(self.fc2(x))
- x = self.fc3(x)
- return x
-
- def train_step(self, data, optimizer):
- images, labels = data
- predicts = self(images) # -> self.__call__() -> self.forward()
- loss = self.loss_fn(predicts, labels)
- return {'loss': loss}
-
-
- if __name__ == '__main__':
- model = Model()
- if torch.cuda.is_available():
- # only use gpu:0 to train
- # Solved issue https://github.com/open-mmlab/mmcv/issues/1470
- model = MMDataParallel(model.cuda(), device_ids=[0])
-
- # dataset and dataloader
- transform = transforms.Compose([
- transforms.ToTensor(),
- transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
- ])
- trainset = CIFAR10(
- root='data', train=True, download=True, transform=transform)
- trainloader = DataLoader(
- trainset, batch_size=128, shuffle=True, num_workers=2)
-
- optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
- logger = get_logger('mmcv')
- # runner is a scheduler to manage the training
- runner = EpochBasedRunner(
- model,
- optimizer=optimizer,
- work_dir='./work_dir',
- logger=logger,
- max_epochs=4)
-
- # learning rate scheduler config
- lr_config = dict(policy='step', step=[2, 3])
- # configuration of optimizer
- optimizer_config = dict(grad_clip=None)
- # configuration of saving checkpoints periodically
- checkpoint_config = dict(interval=1)
- # save log periodically and multiple hooks can be used simultaneously
- log_config = dict(interval=100, hooks=[dict(type='TextLoggerHook')])
- # register hooks to runner and those hooks will be invoked automatically
- runner.register_training_hooks(
- lr_config=lr_config,
- optimizer_config=optimizer_config,
- checkpoint_config=checkpoint_config,
- log_config=log_config)
-
- runner.run([trainloader], [('train', 1)])
|