J'ai finalement commencé à utiliser Docker récemment. Avec Docker, vous pouvez facilement apprendre en profondeur sur différents PC.
OS：Ubuntu 20.04 GPU：NVIDIA GeForce GTX 1080
Tout d'abord, créez un environnement dans lequel l'hôte peut utiliser le GPU. Si vous avez déjà installé le pilote avec $ nvidia-smi, c'est très bien. Ceci est un exemple d'installation, donc pour référence
$ sudo add-apt-repository ppa:graphics-drivers/ppa
$ sudo apt update
$ sudo apt install ubuntu-drivers-common
$ sudo apt dist-upgrade
$redémarrage sudo
$ sudo ubuntu-drivers autoinstall
$redémarrage sudo
Ce n'est pas grave si $ nvidia-smi affiche la version du pilote et l'état d'utilisation de la mémoire!
Cela exécute la page d'accueil officielle (https://docs.docker.com/engine/install/ubuntu/) telle quelle
$ sudo apt-get update
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg-agent \
software-properties-common
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
Opération confirmée avec $ sudo docker run hello-world
Nécessaire (probablement) pour utiliser CUDA avec Docker https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html# https://github.com/NVIDIA/nvidia-docker/issues/1186
$ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
$ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
$ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
$ sudo apt-get update
$ sudo apt-get install -y nvidia-container-toolkit
$ sudo systemctl restart docker
Dockerfile Le Dockerfile décrit à quoi devrait ressembler l'environnement virtuel. Vous pouvez modifier l'environnement de base dans la partie FROM de la première ligne. (Versions Ubuntu et CUDA, présence de cudnn, etc.) Si vous vérifiez le DockerHub de nvidia / cuda, vous trouverez diverses choses. (https://hub.docker.com/r/nvidia/cuda/tags) Vous pouvez également sélectionner la bibliothèque Python sur la troisième ligne de RUN.
Dockerfile
FROM nvidia/cuda:11.0-devel-ubuntu20.04
RUN apt-get update
RUN apt-get install -y python3 python3-pip
RUN pip3 install torch torchvision
WORKDIR /work
COPY train.py /work/
ENV LIBRARY_PATH /usr/local/cuda/lib64/stubs
Implémentez train.py dans le même répertoire que le Dockerfile que vous venez de créer. train.py s'entraîne avec des données appelées MNIST, que l'on peut appeler Hello World! Of deep learning. (Citation: https://github.com/pytorch/examples/blob/master/mnist/main.py)
train.py
from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.dropout1 = nn.Dropout2d(0.25)
self.dropout2 = nn.Dropout2d(0.5)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = self.dropout1(x)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.dropout2(x)
x = self.fc2(x)
output = F.log_softmax(x, dim=1)
return output
def train(args, model, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
if batch_idx % args.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))
if args.dry_run:
break
def test(model, device, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss
pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=14, metavar='N',
help='number of epochs to train (default: 14)')
parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
help='learning rate (default: 1.0)')
parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
help='Learning rate step gamma (default: 0.7)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--dry-run', action='store_true', default=False,
help='quickly check a single pass')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=False,
help='For Saving the current Model')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'batch_size': args.batch_size}
if use_cuda:
kwargs.update({'num_workers': 1,
'pin_memory': True,
'shuffle': True},
)
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
dataset1 = datasets.MNIST('../data', train=True, download=True,
transform=transform)
dataset2 = datasets.MNIST('../data', train=False,
transform=transform)
train_loader = torch.utils.data.DataLoader(dataset1,**kwargs)
test_loader = torch.utils.data.DataLoader(dataset2, **kwargs)
model = Net().to(device)
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_loader, optimizer, epoch)
test(model, device, test_loader)
scheduler.step()
if args.save_model:
torch.save(model.state_dict(), "mnist_cnn.pt")
if __name__ == '__main__':
main()
Créez un Dockerfile pour créer et exécuter un environnement virtuel. Vous pouvez voir si le GPU est utilisé avec $ nvidia-smi lors de l'exécution de train.py.
$ sudo docker build -t [Nom du conteneur] .
$ sudo docker run -it --gpus all [Nom du conteneur] /bin/bash
----Dans le conteneur ci-dessous-----
$ python3 train.py
Cette fois, j'ai créé un environnement virtuel avec PyTorch, mais en modifiant le contenu du Dockerfile, Je pense que vous pouvez également utiliser d'autres bibliothèques d'apprentissage en profondeur. De plus, si les données d'entraînement sont énormes, vous pouvez monter les données d'entraînement dans un environnement virtuel avec une commande docker. Même ainsi, Docker est pratique (rires)
Recommended Posts