Implémenter le GPU PyTorch + avec Docker

introduction

J'ai finalement commencé à utiliser Docker récemment. Avec Docker, vous pouvez facilement apprendre en profondeur sur différents PC.

Environnement (hôte)

OS:Ubuntu 20.04 GPU:NVIDIA GeForce GTX 1080

Installer le pilote GPU

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!

Installer Docker

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

Installez Nvidia Container Toolkit

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

Script d'apprentissage en profondeur

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()

Exécutez-le pour le moment et vérifiez l'opération

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

finalement

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

Implémenter le GPU PyTorch + avec Docker
Jouez avec PyTorch
J'ai essayé d'implémenter CVAE avec PyTorch
Validation croisée avec PyTorch
À partir de PyTorch
Guide d'installation de nvidia-docker2 pour l'utilisation de GPU avec docker
Serveur TFTP avec Docker
Utilisez RTX 3090 avec PyTorch
Implémenter FReLU avec tf.keras
Utiliser python avec docker
Serveur proxy avec Docker
Bonjour le monde avec Docker
Installer la diffusion de la torche avec PyTorch 1.7
J'ai essayé d'implémenter et d'apprendre DCGAN avec PyTorch
Préparation de l'environnement d'exécution de PyTorch avec Docker Novembre 2019
J'ai essayé d'implémenter SSD avec PyTorch maintenant (Dataset)
Implémenter la fonction de connexion avec django-allauth
Implémenter des sous-commandes avec l'argparse de Python
Essayez Auto Encoder avec Pytorch
Implémenter le transfert de style avec Pytorch
Essayez d'implémenter XOR avec PyTorch
La vie PySpark à partir de Docker
Préparer l'environnement python3 avec Docker
Prédiction de la moyenne Nikkei avec Pytorch 2
Démineur d'apprentissage automatique avec PyTorch
PyTorch avec AWS Lambda [importation Lambda]
[Qt Designer] Implémenter WebView avec PyQt5
Créez un environnement GPU avec GCP et l'image officielle de Kaggle (docker)
Prédiction de la moyenne Nikkei avec Pytorch
Essayez Selenium Grid avec Docker
Effectuer un fractionnement stratifié avec PyTorch
J'ai créé Word2Vec avec Pytorch
Implémentez la blockchain avec environ 60 lignes
Essayez de créer Jupyter Hub avec Docker
Créer une application Rails avec Docker
Essayez d'implémenter la régression linéaire à l'aide de Pytorch avec Google Colaboratory
J'ai essayé d'implémenter SSD avec PyTorch maintenant (édition du modèle)
Apprentissage automatique avec docker (42) Programmation PyTorch pour l'apprentissage en profondeur par Ian Pointer
J'ai essayé d'implémenter la classification des phrases par Self Attention avec PyTorch
Japaneseize Matplotlib avec Alpine en utilisant Docker
Jusqu'à ce que vous démarriez Jupyter dans Docker
Easy Slackbot avec Docker et Errbot
[Tutoriel PyTorch ⑤] Apprentissage de PyTorch avec des exemples (Partie 2)
Apprenez avec les réseaux convolutifs PyTorch Graph
Créer un serveur Flask avec Docker
Créer un fichier deb avec Docker
Conseils pour exécuter Go avec Docker
Construire un environnement Mysql + Python avec docker
Déployer l'application Django avec Docker
Développement Google AppEngine avec Docker
J'ai essayé d'implémenter Attention Seq2Seq avec PyTorch
J'ai essayé d'implémenter DeepPose avec PyTorch
Implémenter Keras LSTM feed forward avec numpy
Prédiction de la moyenne Nikkei avec Pytorch ~ Makuma ~
Comment augmenter les données avec PyTorch
Service mesh appris avec Docker Swarm
[Tutoriel PyTorch ⑤] Apprentissage de PyTorch avec des exemples (Partie 1)
Construction de l'environnement pytorch @ python3.8 avec pipenv
Reconstruisez l'environnement de développement de Django avec Docker! !! !! !!