Ich habe vor kurzem endlich angefangen, Docker zu benutzen. Mit Docker können Sie auf verschiedenen PCs ganz einfach tief lernen.
OS：Ubuntu 20.04 GPU：NVIDIA GeForce GTX 1080
Erstellen Sie zunächst eine Umgebung, in der der Host die GPU verwenden kann. Wenn Sie den Treiber bereits mit $ nvidia-smi installiert haben, ist dies in Ordnung. Dies ist ein Beispiel für die Installation, also als Referenz
$ sudo add-apt-repository ppa:graphics-drivers/ppa
$ sudo apt update
$ sudo apt install ubuntu-drivers-common
$ sudo apt dist-upgrade
$sudo neu starten
$ sudo ubuntu-drivers autoinstall
$sudo neu starten
Es ist in Ordnung, wenn $ nvidia-smi die Treiberversion und den Status der Speichernutzung anzeigt!
Dadurch wird die offizielle Homepage (https://docs.docker.com/engine/install/ubuntu/) unverändert ausgeführt
$ 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
Bestätigter Vorgang mit $ sudo docker run hello-world
Notwendig (wahrscheinlich), um CUDA mit Docker zu verwenden 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 Die Docker-Datei beschreibt, wie die virtuelle Umgebung aussehen soll. Sie können die Basisumgebung im FROM-Teil der ersten Zeile ändern. (Ubuntu- und CUDA-Versionen, Vorhandensein von Cudnn usw.) Wenn Sie den DockerHub von nvidia / cuda überprüfen, werden Sie verschiedene Dinge finden. (https://hub.docker.com/r/nvidia/cuda/tags) Sie können die Python-Bibliothek auch in der dritten Zeile von RUN auswählen.
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
Implementieren Sie train.py im selben Verzeichnis wie die gerade erstellte Docker-Datei. train.py wird mit Daten namens MNIST trainiert, die als Hello World! Of Deep Learning bezeichnet werden können. (Zitat: 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()
Erstellen Sie eine Docker-Datei, um eine virtuelle Umgebung zu erstellen und auszuführen. Sie können sehen, ob die GPU mit $ nvidia-smi verwendet wird, während train.py ausgeführt wird.
$ sudo docker build -t [Containername] .
$ sudo docker run -it --gpus all [Containername] /bin/bash
----Im Behälter unten-----
$ python3 train.py
Dieses Mal habe ich mit PyTorch eine virtuelle Umgebung erstellt, aber durch Ändern des Inhalts der Docker-Datei Ich denke, Sie können auch andere Deep-Learning-Bibliotheken verwenden. Wenn die Trainingsdaten sehr groß sind, können Sie die Trainingsdaten mit einem Docker-Befehl in einer virtuellen Umgebung bereitstellen. Trotzdem ist Docker praktisch (lacht)
Recommended Posts